1/* $FreeBSD: stable/10/usr.sbin/usbconfig/dump.c 356408 2020-01-06 09:40:59Z hselasky $ */
2/*-
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <stdint.h>
30#include <err.h>
31#include <string.h>
32#include <pwd.h>
33#include <grp.h>
34#include <ctype.h>
35
36#include <libusb20.h>
37#include <libusb20_desc.h>
38
39#include "dump.h"
40
41#define	DUMP0(n,type,field,...) dump_field(pdev, "  ", #field, n->field);
42#define	DUMP1(n,type,field,...) dump_field(pdev, "    ", #field, n->field);
43#define	DUMP2(n,type,field,...) dump_field(pdev, "      ", #field, n->field);
44#define	DUMP3(n,type,field,...) dump_field(pdev, "        ", #field, n->field);
45
46const char *
47dump_mode(uint8_t value)
48{
49	if (value == LIBUSB20_MODE_HOST)
50		return ("HOST");
51	return ("DEVICE");
52}
53
54const char *
55dump_speed(uint8_t value)
56{
57	;				/* style fix */
58	switch (value) {
59	case LIBUSB20_SPEED_LOW:
60		return ("LOW (1.5Mbps)");
61	case LIBUSB20_SPEED_FULL:
62		return ("FULL (12Mbps)");
63	case LIBUSB20_SPEED_HIGH:
64		return ("HIGH (480Mbps)");
65	case LIBUSB20_SPEED_VARIABLE:
66		return ("VARIABLE (52-480Mbps)");
67	case LIBUSB20_SPEED_SUPER:
68		return ("SUPER (5.0Gbps)");
69	default:
70		break;
71	}
72	return ("UNKNOWN ()");
73}
74
75const char *
76dump_power_mode(uint8_t value)
77{
78	;				/* style fix */
79	switch (value) {
80	case LIBUSB20_POWER_OFF:
81		return ("OFF");
82	case LIBUSB20_POWER_ON:
83		return ("ON");
84	case LIBUSB20_POWER_SAVE:
85		return ("SAVE");
86	case LIBUSB20_POWER_SUSPEND:
87		return ("SUSPEND");
88	case LIBUSB20_POWER_RESUME:
89		return ("RESUME");
90	default:
91		return ("UNKNOWN");
92	}
93}
94
95static void
96dump_field(struct libusb20_device *pdev, const char *plevel,
97    const char *field, uint32_t value)
98{
99	uint8_t temp_string[256];
100
101	printf("%s%s = 0x%04x ", plevel, field, value);
102
103	if (strlen(plevel) == 8) {
104		/* Endpoint Descriptor */
105
106		if (strcmp(field, "bEndpointAddress") == 0) {
107			if (value & 0x80)
108				printf(" <IN>\n");
109			else
110				printf(" <OUT>\n");
111			return;
112		}
113		if (strcmp(field, "bmAttributes") == 0) {
114			switch (value & 0x03) {
115			case 0:
116				printf(" <CONTROL>\n");
117				break;
118			case 1:
119				switch (value & 0x0C) {
120				case 0x00:
121					printf(" <ISOCHRONOUS>\n");
122					break;
123				case 0x04:
124					printf(" <ASYNC-ISOCHRONOUS>\n");
125					break;
126				case 0x08:
127					printf(" <ADAPT-ISOCHRONOUS>\n");
128					break;
129				default:
130					printf(" <SYNC-ISOCHRONOUS>\n");
131					break;
132				}
133				break;
134			case 2:
135				printf(" <BULK>\n");
136				break;
137			default:
138				printf(" <INTERRUPT>\n");
139				break;
140			}
141			return;
142		}
143	}
144	if ((field[0] == 'i') && (field[1] != 'd')) {
145		/* Indirect String Descriptor */
146		if (value == 0) {
147			printf(" <no string>\n");
148			return;
149		}
150		if (libusb20_dev_req_string_simple_sync(pdev, value,
151		    temp_string, sizeof(temp_string))) {
152			printf(" <retrieving string failed>\n");
153			return;
154		}
155		printf(" <%s>\n", temp_string);
156		return;
157	}
158	if (strlen(plevel) == 2 || strlen(plevel) == 6) {
159
160		/* Device and Interface Descriptor class codes */
161
162		if (strcmp(field, "bInterfaceClass") == 0 ||
163		    strcmp(field, "bDeviceClass") == 0) {
164
165			switch (value) {
166			case 0x00:
167				printf(" <Probed by interface class>\n");
168				break;
169			case 0x01:
170				printf(" <Audio device>\n");
171				break;
172			case 0x02:
173				printf(" <Communication device>\n");
174				break;
175			case 0x03:
176				printf(" <HID device>\n");
177				break;
178			case 0x05:
179				printf(" <Physical device>\n");
180				break;
181			case 0x06:
182				printf(" <Still imaging>\n");
183				break;
184			case 0x07:
185				printf(" <Printer device>\n");
186				break;
187			case 0x08:
188				printf(" <Mass storage>\n");
189				break;
190			case 0x09:
191				printf(" <HUB>\n");
192				break;
193			case 0x0A:
194				printf(" <CDC-data>\n");
195				break;
196			case 0x0B:
197				printf(" <Smart card>\n");
198				break;
199			case 0x0D:
200				printf(" <Content security>\n");
201				break;
202			case 0x0E:
203				printf(" <Video device>\n");
204				break;
205			case 0x0F:
206				printf(" <Personal healthcare>\n");
207				break;
208			case 0x10:
209				printf(" <Audio and video device>\n");
210				break;
211			case 0x11:
212				printf(" <Billboard device>\n");
213				break;
214			case 0xDC:
215				printf(" <Diagnostic device>\n");
216				break;
217			case 0xE0:
218				printf(" <Wireless controller>\n");
219				break;
220			case 0xEF:
221				printf(" <Miscellaneous device>\n");
222				break;
223			case 0xFE:
224				printf(" <Application specific>\n");
225				break;
226			case 0xFF:
227				printf(" <Vendor specific>\n");
228				break;
229			default:
230				printf(" <Unknown>\n");
231				break;
232			}
233			return;
234		}
235	}
236	/* No additional information */
237	printf("\n");
238}
239
240static void
241dump_extra(struct libusb20_me_struct *str, const char *plevel)
242{
243	const uint8_t *ptr;
244	uint8_t x;
245
246	ptr = NULL;
247
248	while ((ptr = libusb20_desc_foreach(str, ptr))) {
249		printf("\n" "%sAdditional Descriptor\n\n", plevel);
250		printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
251		printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
252		if (ptr[0] > 1)
253			printf("%sbDescriptorSubType = 0x%02x\n",
254			    plevel, ptr[2]);
255		printf("%s RAW dump: ", plevel);
256		for (x = 0; x != ptr[0]; x++) {
257			if ((x % 8) == 0) {
258				printf("\n%s 0x%02x | ", plevel, x);
259			}
260			printf("0x%02x%s", ptr[x],
261			    (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
262		}
263		printf("\n");
264	}
265	return;
266}
267
268static void
269dump_endpoint(struct libusb20_device *pdev,
270    struct libusb20_endpoint *ep)
271{
272	struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
273
274	edesc = &ep->desc;
275	LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
276	dump_extra(&ep->extra, "  " "  " "  ");
277	return;
278}
279
280static void
281dump_iface(struct libusb20_device *pdev,
282    struct libusb20_interface *iface)
283{
284	struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
285	uint8_t z;
286
287	idesc = &iface->desc;
288	LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
289	dump_extra(&iface->extra, "  " "  " "  ");
290
291	for (z = 0; z != iface->num_endpoints; z++) {
292		printf("\n     Endpoint %u\n", z);
293		dump_endpoint(pdev, iface->endpoints + z);
294	}
295	return;
296}
297
298void
299dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
300{
301	char buf[128];
302	uint8_t n;
303	unsigned int usage;
304
305	usage = libusb20_dev_get_power_usage(pdev);
306
307	printf("%s, cfg=%u md=%s spd=%s pwr=%s (%umA)\n",
308	    libusb20_dev_get_desc(pdev),
309	    libusb20_dev_get_config_index(pdev),
310	    dump_mode(libusb20_dev_get_mode(pdev)),
311	    dump_speed(libusb20_dev_get_speed(pdev)),
312	    dump_power_mode(libusb20_dev_get_power_mode(pdev)),
313	    usage);
314
315	if (!show_ifdrv)
316		return;
317
318	for (n = 0; n != 255; n++) {
319		if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
320			break;
321		if (buf[0] == 0)
322			continue;
323		printf("ugen%u.%u.%u: %s\n",
324		    libusb20_dev_get_bus_number(pdev),
325		    libusb20_dev_get_address(pdev), n, buf);
326	}
327}
328
329void
330dump_be_quirk_names(struct libusb20_backend *pbe)
331{
332	struct libusb20_quirk q;
333	uint16_t x;
334	int error;
335
336	memset(&q, 0, sizeof(q));
337
338	printf("\nDumping list of supported quirks:\n\n");
339
340	for (x = 0; x != 0xFFFF; x++) {
341
342		error = libusb20_be_get_quirk_name(pbe, x, &q);
343		if (error) {
344			if (x == 0) {
345				printf("No quirk names - maybe the USB quirk "
346				    "module has not been loaded.\n");
347			}
348			break;
349		}
350		if (strcmp(q.quirkname, "UQ_NONE"))
351			printf("%s\n", q.quirkname);
352	}
353	printf("\n");
354	return;
355}
356
357void
358dump_be_dev_quirks(struct libusb20_backend *pbe)
359{
360	struct libusb20_quirk q;
361	uint16_t x;
362	int error;
363
364	memset(&q, 0, sizeof(q));
365
366	printf("\nDumping current device quirks:\n\n");
367
368	for (x = 0; x != 0xFFFF; x++) {
369
370		error = libusb20_be_get_dev_quirk(pbe, x, &q);
371		if (error) {
372			if (x == 0) {
373				printf("No device quirks - maybe the USB quirk "
374				    "module has not been loaded.\n");
375			}
376			break;
377		}
378		if (strcmp(q.quirkname, "UQ_NONE")) {
379			printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
380			    "REVHI=0x%04x QUIRK=%s\n",
381			    q.vid, q.pid, q.bcdDeviceLow,
382			    q.bcdDeviceHigh, q.quirkname);
383		}
384	}
385	printf("\n");
386	return;
387}
388
389void
390dump_device_desc(struct libusb20_device *pdev)
391{
392	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
393
394	ddesc = libusb20_dev_get_device_desc(pdev);
395	LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
396	return;
397}
398
399void
400dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
401{
402	struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
403	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
404	struct libusb20_config *pcfg = NULL;
405	uint8_t cfg_index;
406	uint8_t cfg_index_end;
407	uint8_t x;
408	uint8_t y;
409
410	ddesc = libusb20_dev_get_device_desc(pdev);
411
412	if (all_cfg) {
413		cfg_index = 0;
414		cfg_index_end = ddesc->bNumConfigurations;
415	} else {
416		cfg_index = libusb20_dev_get_config_index(pdev);
417		cfg_index_end = cfg_index + 1;
418	}
419
420	for (; cfg_index != cfg_index_end; cfg_index++) {
421
422		pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
423		if (!pcfg) {
424			continue;
425		}
426		printf("\n Configuration index %u\n\n", cfg_index);
427		cdesc = &(pcfg->desc);
428		LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
429		dump_extra(&(pcfg->extra), "  " "  ");
430
431		for (x = 0; x != pcfg->num_interface; x++) {
432			printf("\n    Interface %u\n", x);
433			dump_iface(pdev, pcfg->interface + x);
434			printf("\n");
435			for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
436				printf("\n    Interface %u Alt %u\n", x, y + 1);
437				dump_iface(pdev,
438				    (pcfg->interface + x)->altsetting + y);
439				printf("\n");
440			}
441		}
442		printf("\n");
443		free(pcfg);
444	}
445	return;
446}
447
448void
449dump_string_by_index(struct libusb20_device *pdev, uint8_t str_index)
450{
451	char *pbuf;
452	uint8_t n;
453	uint8_t len;
454
455	pbuf = malloc(256);
456	if (pbuf == NULL)
457		err(1, "out of memory");
458
459	if (str_index == 0) {
460		/* language table */
461		if (libusb20_dev_req_string_sync(pdev,
462		    str_index, 0, pbuf, 256)) {
463			printf("STRING_0x%02x = <read error>\n", str_index);
464		} else {
465			printf("STRING_0x%02x = ", str_index);
466			len = (uint8_t)pbuf[0];
467			for (n = 0; n != len; n++) {
468				printf("0x%02x%s", (uint8_t)pbuf[n],
469				    (n != (len - 1)) ? ", " : "");
470			}
471			printf("\n");
472		}
473	} else {
474		/* ordinary string */
475		if (libusb20_dev_req_string_simple_sync(pdev,
476		    str_index, pbuf, 256)) {
477			printf("STRING_0x%02x = <read error>\n", str_index);
478		} else {
479			printf("STRING_0x%02x = <%s>\n", str_index, pbuf);
480		}
481	}
482	free(pbuf);
483}
484
485void
486dump_device_stats(struct libusb20_device *pdev)
487{
488	struct libusb20_device_stats st;
489
490	if (libusb20_dev_get_stats(pdev, &st)) {
491		printf("{}\n");
492	} else {
493		printf("{\n"
494		    "    UE_CONTROL_OK       : %llu\n"
495		    "    UE_ISOCHRONOUS_OK   : %llu\n"
496		    "    UE_BULK_OK          : %llu\n"
497		    "    UE_INTERRUPT_OK     : %llu\n"
498		    "    UE_CONTROL_FAIL     : %llu\n"
499		    "    UE_ISOCHRONOUS_FAIL : %llu\n"
500		    "    UE_BULK_FAIL        : %llu\n"
501		    "    UE_INTERRUPT_FAIL   : %llu\n"
502		    "}\n",
503		    (unsigned long long)st.xfer_ok[0],
504		    (unsigned long long)st.xfer_ok[1],
505		    (unsigned long long)st.xfer_ok[2],
506	            (unsigned long long)st.xfer_ok[3],
507		    (unsigned long long)st.xfer_fail[0],
508		    (unsigned long long)st.xfer_fail[1],
509		    (unsigned long long)st.xfer_fail[2],
510		    (unsigned long long)st.xfer_fail[3]);
511	}
512}
513