Kernel

Kernel Git Source Tree

Root/tools/firewire/nosy-dump.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/tools/firewire/nosy-dump.c

interactive