tools/firewire: nosy-dump: work around segfault in decode_fcp
[linux-3.10.git] / tools / firewire / nosy-dump.c
1 /* -*- mode: c; c-basic-offset: 2 -*- */
2
3 /*
4  * nosy-dump - Interface to snoop mode driver for TI PCILynx 1394 controllers
5  * Copyright (C) 2002-2006 Kristian Høgsberg
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/ioctl.h>
28 #include <sys/time.h>
29 #include <endian.h>
30 #include <popt.h>
31 #include <poll.h>
32 #include <byteswap.h>
33 #include <termios.h>
34
35 #include <signal.h>
36
37 #include "list.h"
38 #include "nosy-user.h"
39 #include "nosy-dump.h"
40
41 enum {
42   PACKET_FIELD_DETAIL           = 0x01,
43   PACKET_FIELD_DATA_LENGTH      = 0x02,
44   /* Marks the fields we print in transaction view. */
45   PACKET_FIELD_TRANSACTION      = 0x04
46 };
47
48 static void
49 print_packet(uint32_t *data, size_t length);
50 static void
51 decode_link_packet(struct link_packet *packet, size_t length,
52                    int include_flags, int exclude_flags);
53
54 static int   run = 1;
55 sig_t sys_sigint_handler;
56
57 static char *option_nosy_device = "/dev/nosy";
58 static char *option_view = "packet";
59 static char *option_output = NULL;
60 static char *option_input = NULL;
61 static int   option_hex;
62 static int   option_iso;
63 static int   option_cycle_start;
64 static int   option_version;
65 static int   option_verbose;
66
67 enum {
68   VIEW_TRANSACTION,
69   VIEW_PACKET,
70   VIEW_STATS
71 };
72
73 static const struct poptOption options[] = {
74   {
75     longName:   "device",
76     shortName:  'd',
77     argInfo:    POPT_ARG_STRING,
78     arg:        &option_nosy_device,
79     descrip:    "Path to nosy device.",
80     argDescrip: "DEVICE"
81   },
82   {
83     longName:   "view",
84     argInfo:    POPT_ARG_STRING,
85     arg:        &option_view,
86     descrip:    "Specify view of bus traffic: packet, transaction or stats.",
87     argDescrip: "VIEW"
88   },
89   {
90     longName:   "hex",
91     shortName:  'x',
92     argInfo:    POPT_ARG_NONE,
93     arg:        &option_hex,
94     descrip:    "Print each packet in hex.",
95   },
96   {
97     longName:   "iso",
98     argInfo:    POPT_ARG_NONE,
99     arg:        &option_iso,
100     descrip:    "Print iso packets.",
101   },
102   {
103     longName:   "cycle-start",
104     argInfo:    POPT_ARG_NONE,
105     arg:        &option_cycle_start,
106     descrip:    "Print cycle start packets.",
107   },
108   {
109     longName:   "verbose",
110     shortName:  'v',
111     argInfo:    POPT_ARG_NONE,
112     arg:        &option_verbose,
113     descrip:    "Verbose packet view.",
114   },
115   {
116     longName:   "output",
117     shortName:  'o',
118     argInfo:    POPT_ARG_STRING,
119     arg:        &option_output,
120     descrip:    "Log to output file.",
121     argDescrip: "FILENAME"
122   },
123   {
124     longName:   "input",
125     shortName:  'i',
126     argInfo:    POPT_ARG_STRING,
127     arg:        &option_input,
128     descrip:    "Decode log from file.",
129     argDescrip: "FILENAME"
130   },
131   {
132     longName:   "version",
133     argInfo:    POPT_ARG_NONE,
134     arg:        &option_version,
135     descrip:    "Specify print version info.",
136   },
137   POPT_AUTOHELP
138   POPT_TABLEEND
139 };
140
141 void 
142 sigint_handler(int signal_num)
143 {
144   if (run == 1) {
145     run = 0;
146     /* Allow all Ctrl-C's except the first to interrupt the program in
147      * the usual way.
148      */
149     signal(SIGINT, SIG_DFL);
150   }
151 }
152
153 struct subaction *
154 subaction_create(uint32_t *data, size_t length)
155 {
156   struct subaction *sa;
157
158   /* we put the ack in the subaction struct for easy access. */
159   sa = malloc(sizeof *sa - sizeof sa->packet + length);
160   sa->ack = data[length / 4 - 1];
161   sa->length = length;
162   memcpy (&sa->packet, data, length);
163
164   return sa;
165 }
166
167 void
168 subaction_destroy(struct subaction *sa)
169 {
170   free(sa);
171 }
172
173 struct list pending_transaction_list =
174   { &pending_transaction_list, &pending_transaction_list };
175
176 struct link_transaction *
177 link_transaction_lookup(int request_node, int response_node, int tlabel)
178 {
179   struct link_transaction *t;
180
181   list_for_each_entry(t, &pending_transaction_list, link) {
182     if (t->request_node == request_node &&
183         t->response_node == response_node &&
184         t->tlabel == tlabel)
185       return t;
186   }
187
188   t = malloc(sizeof *t);
189   t->request_node = request_node;
190   t->response_node = response_node;
191   t->tlabel = tlabel;
192   list_init(&t->request_list);
193   list_init(&t->response_list);
194   
195   list_append(&pending_transaction_list, &t->link);
196   
197   return t;
198 }
199
200 void
201 link_transaction_destroy(struct link_transaction *t)
202 {
203   while (!list_empty(&t->request_list)) {
204     struct subaction *sa = list_head(&t->request_list, struct subaction, link);
205     list_remove(&sa->link);
206     subaction_destroy(sa);
207   }    
208
209   while (!list_empty(&t->response_list)) {
210     struct subaction *sa = list_head(&t->response_list, struct subaction, link);
211     list_remove(&sa->link);
212     subaction_destroy(sa);
213   }    
214   
215   free(t);
216 }
217
218 struct protocol_decoder {
219   const char *name;
220   int (*decode)(struct link_transaction *t);
221 };
222
223 static struct protocol_decoder protocol_decoders[] = {
224   { "FCP", decode_fcp }
225 };
226
227 void
228 handle_transaction(struct link_transaction *t)
229 {
230   struct subaction *sa;
231   int i;
232
233   if (!t->request) {
234     printf("BUG in handle_transaction\n");
235     return;
236   }
237
238   for (i = 0; i < array_length(protocol_decoders); i++)
239     if (protocol_decoders[i].decode(t))
240       break;
241
242   /* HACK: decode only fcp right now. */
243   return;
244
245   decode_link_packet(&t->request->packet, t->request->length,
246                      PACKET_FIELD_TRANSACTION, 0);
247   if (t->response)
248     decode_link_packet(&t->response->packet, t->request->length,
249                        PACKET_FIELD_TRANSACTION, 0);
250   else
251     printf("[no response]");
252
253   if (option_verbose) {
254     list_for_each_entry(sa, &t->request_list, link)
255       print_packet((uint32_t *) &sa->packet, sa->length);
256     list_for_each_entry(sa, &t->response_list, link)
257       print_packet((uint32_t *) &sa->packet, sa->length);
258   }
259   printf("\r\n");
260
261   link_transaction_destroy(t);
262 }
263
264 void
265 clear_pending_transaction_list(void)
266 {
267   struct link_transaction *t;
268
269   while (!list_empty(&pending_transaction_list)) {
270     t = list_head(&pending_transaction_list, struct link_transaction, link);
271     list_remove(&t->link);
272     link_transaction_destroy(t);
273     /* print unfinished transactions */
274   }    
275 }
276
277 static const char * const tcode_names[] = {
278   "write_quadlet_request",
279   "write_block_request",
280   "write_response",
281   "reserved",
282   "read_quadlet_request",
283   "read_block_request",
284   "read_quadlet_response",
285   "read_block_response",
286   "cycle_start",
287   "lock_request",
288   "iso_data",
289   "lock_response"
290 };
291
292 static const char * const ack_names[] = {
293   "no ack",
294   "ack_complete",
295   "ack_pending",
296   "reserved (0x03)",
297   "ack_busy_x",
298   "ack_busy_a",
299   "ack_busy_b",
300   "reserved (0x07)",
301   "reserved (0x08)",
302   "reserved (0x09)",
303   "reserved (0x0a)",
304   "reserved (0x0b)",
305   "reserved (0x0c)",
306   "ack_data_error",
307   "ack_type_error",
308   "reserved (0x0f)",
309 };
310
311 static const char * const rcode_names[] = {
312   "complete",
313   "reserved (0x01)",
314   "reserved (0x02)",
315   "reserved (0x03)",
316   "conflict_error",
317   "data_error",
318   "type_error",
319   "address_error",
320 };
321
322 static const char * const retry_names[] = {
323   "retry_1",
324   "retry_x",
325   "retry_a",
326   "retry_b",
327 };
328
329 enum {
330   PACKET_RESERVED,
331   PACKET_REQUEST,
332   PACKET_RESPONSE,
333   PACKET_OTHER,
334 };
335
336 struct packet_info {
337   const char *name;
338   int type;
339   int response_tcode;
340   struct packet_field *fields;
341   int field_count;
342 };
343
344 struct packet_field {
345   const char *name;     /* Short name for field. */
346   int offset;           /* Location of field, specified in bits.
347                          * Negative means from end of packet */
348   int width;            /* Width of field, 0 means use data_length. */
349   int flags;            /* Show options. */
350   const char * const *value_names;
351 };
352
353 #define COMMON_REQUEST_FIELDS                                   \
354   { "dest", 0, 16, PACKET_FIELD_TRANSACTION },                  \
355   { "tl", 16, 6 },                                              \
356   { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names },            \
357   { "tcode", 24, 4, PACKET_FIELD_TRANSACTION, tcode_names },    \
358   { "pri", 28, 4, PACKET_FIELD_DETAIL },                        \
359   { "src", 32, 16, PACKET_FIELD_TRANSACTION },                  \
360   { "offs", 48, 48, PACKET_FIELD_TRANSACTION }
361
362 #define COMMON_RESPONSE_FIELDS                                  \
363   { "dest", 0, 16 },                                            \
364   { "tl", 16, 6 },                                              \
365   { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names },            \
366   { "tcode", 24, 4, 0, tcode_names },                           \
367   { "pri", 28, 4, PACKET_FIELD_DETAIL },                        \
368   { "src", 32, 16 },                                            \
369   { "rcode", 48, 4, PACKET_FIELD_TRANSACTION, rcode_names }
370
371 struct packet_field read_quadlet_request_fields[] = {
372   COMMON_REQUEST_FIELDS,
373   { "crc", 96, 32, PACKET_FIELD_DETAIL },
374   { "ack", 156, 4, 0, ack_names }
375 };
376
377 struct packet_field read_quadlet_response_fields[] = {
378   COMMON_RESPONSE_FIELDS,
379   { "data", 96, 32, PACKET_FIELD_TRANSACTION },
380   { "crc", 128, 32, PACKET_FIELD_DETAIL },
381   { "ack", 188, 4, 0, ack_names }
382 };
383
384 struct packet_field read_block_request_fields[] = {
385   COMMON_REQUEST_FIELDS,
386   { "data_length", 96, 16, PACKET_FIELD_TRANSACTION },
387   { "extended_tcode", 112, 16 },
388   { "crc", 128, 32, PACKET_FIELD_DETAIL },
389   { "ack", 188, 4, 0, ack_names },
390 };
391
392 struct packet_field block_response_fields[] = {
393   COMMON_RESPONSE_FIELDS,
394   { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH },
395   { "extended_tcode", 112, 16 },
396   { "crc", 128, 32, PACKET_FIELD_DETAIL },
397   { "data", 160, 0, PACKET_FIELD_TRANSACTION },
398   { "crc", -64, 32, PACKET_FIELD_DETAIL },
399   { "ack", -4, 4, 0, ack_names }
400 };
401
402 struct packet_field write_quadlet_request_fields[] = {
403   COMMON_REQUEST_FIELDS,
404   { "data", 96, 32, PACKET_FIELD_TRANSACTION },
405   { "ack", -4, 4, 0, ack_names }
406 };
407
408 struct packet_field block_request_fields[] = {
409   COMMON_REQUEST_FIELDS,
410   { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH | PACKET_FIELD_TRANSACTION },
411   { "extended_tcode", 112, 16, PACKET_FIELD_TRANSACTION },
412   { "crc", 128, 32, PACKET_FIELD_DETAIL },
413   { "data", 160, 0, PACKET_FIELD_TRANSACTION },
414   { "crc", -64, 32, PACKET_FIELD_DETAIL },
415   { "ack", -4, 4, 0, ack_names }
416 };
417
418 struct packet_field write_response_fields[] = {
419   COMMON_RESPONSE_FIELDS,
420   { "reserved", 64, 32, PACKET_FIELD_DETAIL },
421   { "ack", -4, 4, 0, ack_names }
422 };
423
424 struct packet_field iso_data_fields[] = {
425   { "data_length", 0, 16, PACKET_FIELD_DATA_LENGTH },
426   { "tag", 16, 2 },
427   { "channel", 18, 6 },
428   { "tcode", 24, 4, 0, tcode_names },
429   { "sy", 28, 4 },
430   { "crc", 32, 32, PACKET_FIELD_DETAIL },
431   { "data", 64, 0 },
432   { "crc", -64, 32, PACKET_FIELD_DETAIL },
433   { "ack", -4, 4, 0, ack_names }
434 };
435
436 static struct packet_info packet_info[] = {
437   {
438     .name =             "write_quadlet_request",
439     .type =             PACKET_REQUEST,
440     .response_tcode =   TCODE_WRITE_RESPONSE,
441     .fields =           write_quadlet_request_fields,
442     .field_count =      array_length(write_quadlet_request_fields)
443   },
444   {
445     .name =             "write_block_request",
446     .type =             PACKET_REQUEST,
447     .response_tcode =   TCODE_WRITE_RESPONSE,
448     .fields =           block_request_fields,
449     .field_count =      array_length(block_request_fields)
450   },
451   {
452     .name =             "write_response",
453     .type =             PACKET_RESPONSE,
454     .fields =           write_response_fields,
455     .field_count =      array_length(write_response_fields)
456   },
457   {
458     .name =             "reserved",
459     .type =             PACKET_RESERVED,
460   },
461   {
462     .name =             "read_quadlet_request",
463     .type =             PACKET_REQUEST,
464     .response_tcode =   TCODE_READ_QUADLET_RESPONSE,
465     .fields =           read_quadlet_request_fields,
466     .field_count =      array_length(read_quadlet_request_fields)
467   },
468   {
469     .name =             "read_block_request",
470     .type =             PACKET_REQUEST,
471     .response_tcode =   TCODE_READ_BLOCK_RESPONSE,
472     .fields =           read_block_request_fields,
473     .field_count =      array_length(read_block_request_fields)
474   },
475   {
476     .name =             "read_quadlet_response",
477     .type =             PACKET_RESPONSE,
478     .fields =           read_quadlet_response_fields,
479     .field_count =      array_length(read_quadlet_response_fields)
480   },
481   {
482     .name =             "read_block_response",
483     .type =             PACKET_RESPONSE,
484     .fields =           block_response_fields,
485     .field_count =      array_length(block_response_fields)
486   },
487   {
488     .name =             "cycle_start",
489     .type =             PACKET_OTHER,
490     .fields =           write_quadlet_request_fields,
491     .field_count =      array_length(write_quadlet_request_fields)
492   },
493   {
494     .name =             "lock_request",
495     .type =             PACKET_REQUEST,
496     .fields =           block_request_fields,
497     .field_count =      array_length(block_request_fields)
498   },
499   {
500     .name =             "iso_data",
501     .type =             PACKET_OTHER,
502     .fields =           iso_data_fields,
503     .field_count =      array_length(iso_data_fields)
504   },
505   {
506     .name =             "lock_response",
507     .type =             PACKET_RESPONSE,
508     .fields =           block_response_fields,
509     .field_count =      array_length(block_response_fields)
510   }
511 };
512
513 int
514 handle_packet(uint32_t *data, size_t length)
515 {
516   if (length == 0) {
517     printf("bus reset\r\n");
518     clear_pending_transaction_list();
519   }
520   else if (length > sizeof(struct phy_packet)) {
521     struct link_packet *p = (struct link_packet *) data;
522     struct subaction *sa, *prev;
523     struct link_transaction *t;
524
525     switch (packet_info[p->common.tcode].type) {
526     case PACKET_REQUEST:
527       t = link_transaction_lookup(p->common.source, p->common.destination,
528                                   p->common.tlabel);
529       sa = subaction_create(data, length);
530       t->request = sa;
531
532       if (!list_empty(&t->request_list)) {
533         prev = list_tail(&t->request_list, struct subaction, link);
534
535         if (!ACK_BUSY(prev->ack)) {
536           /* error, we should only see ack_busy_* before the
537            * ack_pending/ack_complete -- this is an ack_pending
538            * instead (ack_complete would have finished the
539            * transaction). */
540         }
541         
542         if (prev->packet.common.tcode != sa->packet.common.tcode ||
543             prev->packet.common.tlabel != sa->packet.common.tlabel)
544           /* memcmp() ? */
545           /* error, these should match for retries. */;
546       }
547
548       list_append(&t->request_list, &sa->link);
549
550       switch (sa->ack) {
551       case ACK_COMPLETE:
552         if (p->common.tcode != TCODE_WRITE_QUADLET &&
553             p->common.tcode != TCODE_WRITE_BLOCK)
554           /* error, unified transactions only allowed for write */;
555         list_remove(&t->link);
556         handle_transaction(t);
557         break;
558
559       case ACK_NO_ACK:
560       case ACK_DATA_ERROR:
561       case ACK_TYPE_ERROR:
562         list_remove(&t->link);
563         handle_transaction(t);
564         break;
565
566       case ACK_PENDING:
567         /* request subaction phase over, wait for response. */
568         break;
569
570       case ACK_BUSY_X:
571       case ACK_BUSY_A:
572       case ACK_BUSY_B:
573         /* ok, wait for retry. */
574         /* check that retry protocol is respected. */
575         break;
576       }
577       break;
578
579     case PACKET_RESPONSE:
580       t = link_transaction_lookup(p->common.destination, p->common.source,
581                                   p->common.tlabel);
582       if (list_empty(&t->request_list)) {
583         /* unsolicited response */
584       }
585
586       sa = subaction_create(data, length);
587       t->response = sa;
588
589       if (!list_empty(&t->response_list)) {
590         prev = list_tail(&t->response_list, struct subaction, link);
591
592         if (!ACK_BUSY(prev->ack))
593           /* error, we should only see ack_busy_* before the
594            * ack_pending/ack_complete */;
595
596         if (prev->packet.common.tcode != sa->packet.common.tcode ||
597             prev->packet.common.tlabel != sa->packet.common.tlabel)
598           /* use memcmp() instead? */
599           /* error, these should match for retries. */;
600       }
601       else {
602         prev = list_tail(&t->request_list, struct subaction, link);
603         if (prev->ack != ACK_PENDING) {
604           /* error, should not get response unless last request got
605            * ack_pending. */
606         }
607         
608         if (packet_info[prev->packet.common.tcode].response_tcode !=
609             sa->packet.common.tcode) {
610           /* error, tcode mismatch */
611         }
612       }
613       
614       list_append(&t->response_list, &sa->link);
615
616       switch (sa->ack) {
617       case ACK_COMPLETE:
618       case ACK_NO_ACK:
619       case ACK_DATA_ERROR:
620       case ACK_TYPE_ERROR:
621         list_remove(&t->link);
622         handle_transaction(t);
623         /* transaction complete, remove t from pending list. */
624         break;
625
626       case ACK_PENDING:
627         /* error for responses. */
628         break;
629
630       case ACK_BUSY_X:
631       case ACK_BUSY_A:
632       case ACK_BUSY_B:
633         /* no problem, wait for next retry */
634         break;
635       }
636       
637       break;
638
639     case PACKET_OTHER:
640     case PACKET_RESERVED:
641       return 0;
642     }
643   }
644
645   return 1;
646 }
647
648 unsigned int get_bits(struct link_packet *packet, int offset, int width)
649 {
650   uint32_t *data = (uint32_t *) packet;
651   uint32_t index, shift, mask;
652
653   index = offset / 32 + 1;
654   shift = 32 - (offset & 31) - width;
655   mask = width == 32 ? ~0 : (1 << width) - 1;
656
657   return (data[index] >> shift) & mask;
658 }
659
660 #if __BYTE_ORDER == __LITTLE_ENDIAN
661 #define byte_index(i) ((i) ^ 3)
662 #elif __BYTE_ORDER == __BIG_ENDIAN
663 #define byte_index(i) (i)
664 #else
665 #error unsupported byte order.
666 #endif
667
668 void dump_data(unsigned char *data, int length)
669 {
670   int i, print_length;
671
672   if (length > 128)
673     print_length = 128;
674   else
675     print_length = length;
676
677   for (i = 0; i < print_length; i++)
678     printf("%s%02hhx",
679            (i % 4 == 0 && i != 0) ? " " : "",
680            data[byte_index(i)]);
681
682   if (print_length < length)
683     printf(" (%d more bytes)", length - print_length);
684 }
685
686 static void
687 decode_link_packet(struct link_packet *packet, size_t length,
688                    int include_flags, int exclude_flags)
689 {
690   struct packet_info *pi;
691   int data_length = 0;
692   int i;
693
694   pi = &packet_info[packet->common.tcode];
695
696   for (i = 0; i < pi->field_count; i++) {
697     struct packet_field *f = &pi->fields[i];
698     int offset;
699
700     if (f->flags & exclude_flags)
701       continue;
702     if (include_flags && !(f->flags & include_flags))
703       continue;
704
705     if (f->offset < 0)
706       offset = length * 8 + f->offset - 32;
707     else
708       offset = f->offset;
709
710     if (f->value_names != NULL) {
711       uint32_t bits;
712
713       bits = get_bits(packet, offset, f->width);
714       printf("%s", f->value_names[bits]);
715     }
716     else if (f->width == 0) {
717       printf("%s=[", f->name);
718       dump_data((unsigned char *) packet + (offset / 8 + 4), data_length);
719       printf("]");
720     }
721     else {
722       unsigned long long bits;
723       int high_width, low_width;
724
725       if ((offset & ~31) != ((offset + f->width - 1) & ~31)) {
726         /* Bit field spans quadlet boundary. */
727         high_width = ((offset + 31) & ~31) - offset;
728         low_width = f->width - high_width;
729
730         bits = get_bits(packet, offset, high_width);
731         bits = (bits << low_width) |
732           get_bits(packet, offset + high_width, low_width);
733       }
734       else
735         bits = get_bits(packet, offset, f->width);
736
737       printf("%s=0x%0*llx", f->name, (f->width + 3) / 4, bits);
738
739       if (f->flags & PACKET_FIELD_DATA_LENGTH)
740         data_length = bits;
741     }
742
743     if (i < pi->field_count - 1)
744       printf(", ");
745   }
746 }
747
748 static void
749 print_packet(uint32_t *data, size_t length)
750 {
751   int i;
752
753   printf("%6u  ", data[0]);
754
755   if (length == 4)
756     printf("bus reset");
757   else if (length < sizeof(struct phy_packet)) {
758     printf("short packet: ");
759     for (i = 1; i < length / 4; i++)
760       printf("%s%08x", i == 0 ? "[" : " ", data[i]);
761     printf("]");
762
763   }
764   else if (length == sizeof(struct phy_packet) && data[1] == ~data[2]) {
765     struct phy_packet *pp = (struct phy_packet *) data;
766
767     /* phy packet are 3 quadlets: the 1 quadlet payload,
768      * the bitwise inverse of the payload and the snoop
769      * mode ack */
770
771     switch (pp->common.identifier) {
772     case PHY_PACKET_CONFIGURATION:
773       if (!pp->phy_config.set_root && !pp->phy_config.set_gap_count) {
774         printf("ext phy config: phy_id=%02x", pp->phy_config.root_id);
775       }
776       else {
777         printf("phy config:");
778         if (pp->phy_config.set_root)
779           printf(" set_root_id=%02x", pp->phy_config.root_id);
780         if (pp->phy_config.set_gap_count)
781           printf(" set_gap_count=%d", pp->phy_config.gap_count);
782       }
783       break;
784
785     case PHY_PACKET_LINK_ON:
786       printf("link-on packet, phy_id=%02x", pp->link_on.phy_id);
787       break;
788
789     case PHY_PACKET_SELF_ID:
790       if (pp->self_id.extended) {
791         printf("extended self id: phy_id=%02x, seq=%d",
792                pp->ext_self_id.phy_id, pp->ext_self_id.sequence);
793       }
794       else {
795         static const char * const speed_names[] = {
796           "S100", "S200", "S400", "BETA"
797         };
798         printf("self id: phy_id=%02x, link %s, gap_count=%d, speed=%s%s%s", 
799                pp->self_id.phy_id,
800                (pp->self_id.link_active ? "active" : "not active"),
801                pp->self_id.gap_count,
802                speed_names[pp->self_id.phy_speed],
803                (pp->self_id.contender ? ", irm contender" : ""),
804                (pp->self_id.initiated_reset ? ", initiator" : ""));
805                
806       }
807       break;
808     default:
809       printf("unknown phy packet: ");
810       for (i = 1; i < length / 4; i++)
811         printf("%s%08x", i == 0 ? "[" : " ", data[i]);
812       printf("]");
813       break;
814     }
815   }
816   else {
817     struct link_packet *packet = (struct link_packet *) data;
818
819     decode_link_packet(packet, length, 0,
820                        option_verbose ? 0 : PACKET_FIELD_DETAIL);
821   }
822
823   if (option_hex) {
824     printf("  [");
825     dump_data((unsigned char *) data + 4, length - 4);
826     printf("]");
827   }
828
829   printf("\r\n");
830 }
831
832 #define HIDE_CURSOR     "\033[?25l"
833 #define SHOW_CURSOR     "\033[?25h"
834 #define CLEAR           "\033[H\033[2J"
835
836 static void
837 print_stats(uint32_t *data, size_t length)
838 {
839   static int bus_reset_count, short_packet_count, phy_packet_count;
840   static int tcode_count[16];
841   static struct timeval last_update;
842   struct timeval now;
843   int i;
844
845   if (length == 0)
846     bus_reset_count++;
847   else if (length < sizeof(struct phy_packet))
848     short_packet_count++;
849   else if (length == sizeof(struct phy_packet) && data[1] == ~data[2])
850     phy_packet_count++;
851   else {
852     struct link_packet *packet = (struct link_packet *) data;
853     tcode_count[packet->common.tcode]++;
854   }
855
856   gettimeofday(&now, NULL);
857   if (now.tv_sec <= last_update.tv_sec &&
858       now.tv_usec < last_update.tv_usec + 500000)
859     return;
860   
861   last_update = now;
862   printf(CLEAR HIDE_CURSOR
863          "  bus resets              : %8d\n"
864          "  short packets           : %8d\n"
865          "  phy packets             : %8d\n",
866          bus_reset_count, short_packet_count, phy_packet_count);
867
868   for (i = 0; i < array_length(packet_info); i++)
869     if (packet_info[i].type != PACKET_RESERVED)
870       printf("  %-24s: %8d\n", packet_info[i].name, tcode_count[i]);
871   printf(SHOW_CURSOR "\n");
872 }
873
874 struct termios saved_attributes;
875
876 void
877 reset_input_mode (void)
878 {
879   tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
880 }
881
882 void
883 set_input_mode (void)
884 {
885   struct termios tattr;
886
887   /* Make sure stdin is a terminal. */
888   if (!isatty(STDIN_FILENO)) {
889     fprintf(stderr, "Not a terminal.\n");
890     exit(EXIT_FAILURE);
891   }
892
893   /* Save the terminal attributes so we can restore them later. */
894   tcgetattr(STDIN_FILENO, &saved_attributes);
895   atexit(reset_input_mode);
896
897   /* Set the funny terminal modes. */
898   tcgetattr(STDIN_FILENO, &tattr);
899   tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
900   tattr.c_cc[VMIN] = 1;
901   tattr.c_cc[VTIME] = 0;
902   tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
903 }
904
905 int main(int argc, const char *argv[])
906 {
907   int fd = -1;
908   FILE *output = NULL, *input = NULL;
909   poptContext con;
910   int retval;
911   int view;
912   char c;
913   struct pollfd pollfds[2];
914
915   sys_sigint_handler = signal(SIGINT, sigint_handler);
916
917   con = poptGetContext(NULL, argc, argv, options, 0);
918   retval = poptGetNextOpt(con);
919   if (retval < -1) {
920     poptPrintUsage(con, stdout, 0);
921     return -1;
922   }
923
924   if (option_version) {
925     printf("dump tool for nosy sniffer, version %s\n", VERSION);
926     return 0;
927   }
928
929   if (__BYTE_ORDER != __LITTLE_ENDIAN)
930     fprintf(stderr, "warning: nosy has only been tested on little "
931             "endian machines\n");
932
933   if (option_input != NULL) {
934     input = fopen(option_input, "r");
935     if (input == NULL) {
936       fprintf(stderr, "Could not open %s, %m\n", option_input);
937       return -1;
938     }
939   }
940   else {
941     fd = open(option_nosy_device, O_RDWR);
942     if (fd < 0) {
943       fprintf(stderr, "Could not open %s, %m\n", option_nosy_device);
944       return -1;
945     }
946     set_input_mode();
947   }
948
949   if (strcmp(option_view, "transaction") == 0)
950     view = VIEW_TRANSACTION;
951   else if (strcmp(option_view, "stats") == 0)
952     view = VIEW_STATS;
953   else
954     view = VIEW_PACKET;
955
956   if (option_output) {
957     output = fopen(option_output, "w");
958     if (output == NULL) {
959       fprintf(stderr, "Could not open %s, %m\n", option_output);
960       return -1;
961     }
962   }
963
964   setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
965
966   if (1) {
967     uint32_t buf[128 * 1024];
968     uint32_t filter;
969     int length;
970
971     filter = ~0;
972     if (!option_iso)
973       filter &= ~(1 <<TCODE_ISO_DATA);
974     if (!option_cycle_start)
975       filter &= ~(1 << TCODE_CYCLE_START);
976     if (view == VIEW_STATS)
977       filter = ~(1 << TCODE_CYCLE_START);
978
979     ioctl(fd, NOSY_IOC_FILTER, filter);
980
981     ioctl(fd, NOSY_IOC_START);
982
983     pollfds[0].fd = fd;
984     pollfds[0].events = POLLIN;
985     pollfds[1].fd = STDIN_FILENO;
986     pollfds[1].events = POLLIN;
987
988     while (run) {
989       if (input != NULL) {
990         if (fread(&length, sizeof length, 1, input) != 1)
991           return 0;
992         fread(buf, 1, length, input);
993       }
994       else {
995         poll(pollfds, 2, -1);
996         if (pollfds[1].revents) {
997           read(STDIN_FILENO, &c, sizeof c);
998           switch (c) {
999           case 'q':
1000             if (output != NULL)
1001               fclose(output);
1002             return 0;
1003           }
1004         }
1005
1006         if (pollfds[0].revents)
1007           length = read(fd, buf, sizeof buf);
1008         else
1009           continue;
1010       }
1011
1012       if (output != NULL) {
1013         fwrite(&length, sizeof length, 1, output);
1014         fwrite(buf, 1, length, output);
1015       }
1016
1017       switch (view) {
1018       case VIEW_TRANSACTION:
1019         handle_packet(buf, length);
1020         break;
1021       case VIEW_PACKET:
1022         print_packet(buf, length);
1023         break;
1024       case VIEW_STATS:
1025         print_stats(buf, length);
1026         break;
1027       }
1028     }
1029   }
1030   else
1031     poptPrintUsage(con, stdout, 0);
1032
1033   if (output != NULL)
1034     fclose(output);
1035
1036   close(fd);
1037
1038   poptFreeContext(con);
1039
1040   return 0;
1041 }