1/* $FreeBSD$ */
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
114		if (strcmp(field, "bmAttributes") == 0) {
115			switch (value & 0x03) {
116			case 0:
117				printf(" <CONTROL>\n");
118				break;
119			case 1:
120				switch (value & 0x0C) {
121				case 0x00:
122					printf(" <ISOCHRONOUS>\n");
123					break;
124				case 0x04:
125					printf(" <ASYNC-ISOCHRONOUS>\n");
126					break;
127				case 0x08:
128					printf(" <ADAPT-ISOCHRONOUS>\n");
129					break;
130				default:
131					printf(" <SYNC-ISOCHRONOUS>\n");
132					break;
133				}
134				break;
135			case 2:
136				printf(" <BULK>\n");
137				break;
138			default:
139				printf(" <INTERRUPT>\n");
140				break;
141			}
142			return;
143		}
144	}
145
146	if ((field[0] == 'i') && (field[1] != 'd')) {
147		/* Indirect String Descriptor */
148		if (value == 0) {
149			printf(" <no string>\n");
150			return;
151		}
152		if (libusb20_dev_req_string_simple_sync(pdev, value,
153		    temp_string, sizeof(temp_string))) {
154			printf(" <retrieving string failed>\n");
155			return;
156		}
157		printf(" <%s>\n", temp_string);
158		return;
159	}
160
161	/* No additional information */
162	printf("\n");
163}
164
165static void
166dump_extra(struct libusb20_me_struct *str, const char *plevel)
167{
168	const uint8_t *ptr;
169	uint8_t x;
170
171	ptr = NULL;
172
173	while ((ptr = libusb20_desc_foreach(str, ptr))) {
174		printf("\n" "%sAdditional Descriptor\n\n", plevel);
175		printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
176		printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
177		if (ptr[0] > 1)
178			printf("%sbDescriptorSubType = 0x%02x\n",
179			    plevel, ptr[2]);
180		printf("%s RAW dump: ", plevel);
181		for (x = 0; x != ptr[0]; x++) {
182			if ((x % 8) == 0) {
183				printf("\n%s 0x%02x | ", plevel, x);
184			}
185			printf("0x%02x%s", ptr[x],
186			    (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
187		}
188		printf("\n");
189	}
190	return;
191}
192
193static void
194dump_endpoint(struct libusb20_device *pdev,
195    struct libusb20_endpoint *ep)
196{
197	struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
198
199	edesc = &ep->desc;
200	LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
201	dump_extra(&ep->extra, "  " "  " "  ");
202	return;
203}
204
205static void
206dump_iface(struct libusb20_device *pdev,
207    struct libusb20_interface *iface)
208{
209	struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
210	uint8_t z;
211
212	idesc = &iface->desc;
213	LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
214	dump_extra(&iface->extra, "  " "  " "  ");
215
216	for (z = 0; z != iface->num_endpoints; z++) {
217		printf("\n     Endpoint %u\n", z);
218		dump_endpoint(pdev, iface->endpoints + z);
219	}
220	return;
221}
222
223void
224dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
225{
226	char buf[128];
227	uint8_t n;
228	unsigned int usage;
229
230	usage = libusb20_dev_get_power_usage(pdev);
231
232	printf("%s, cfg=%u md=%s spd=%s pwr=%s (%umA)\n",
233	    libusb20_dev_get_desc(pdev),
234	    libusb20_dev_get_config_index(pdev),
235	    dump_mode(libusb20_dev_get_mode(pdev)),
236	    dump_speed(libusb20_dev_get_speed(pdev)),
237	    dump_power_mode(libusb20_dev_get_power_mode(pdev)),
238	    usage);
239
240	if (!show_ifdrv)
241		return;
242
243	for (n = 0; n != 255; n++) {
244		if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
245			break;
246		if (buf[0] == 0)
247			continue;
248		printf("ugen%u.%u.%u: %s\n",
249		    libusb20_dev_get_bus_number(pdev),
250		    libusb20_dev_get_address(pdev), n, buf);
251	}
252}
253
254void
255dump_be_quirk_names(struct libusb20_backend *pbe)
256{
257	struct libusb20_quirk q;
258	uint16_t x;
259	int error;
260
261	memset(&q, 0, sizeof(q));
262
263	printf("\nDumping list of supported quirks:\n\n");
264
265	for (x = 0; x != 0xFFFF; x++) {
266
267		error = libusb20_be_get_quirk_name(pbe, x, &q);
268		if (error) {
269			if (x == 0) {
270				printf("No quirk names - maybe the USB quirk "
271				    "module has not been loaded.\n");
272			}
273			break;
274		}
275		if (strcmp(q.quirkname, "UQ_NONE"))
276			printf("%s\n", q.quirkname);
277	}
278	printf("\n");
279	return;
280}
281
282void
283dump_be_dev_quirks(struct libusb20_backend *pbe)
284{
285	struct libusb20_quirk q;
286	uint16_t x;
287	int error;
288
289	memset(&q, 0, sizeof(q));
290
291	printf("\nDumping current device quirks:\n\n");
292
293	for (x = 0; x != 0xFFFF; x++) {
294
295		error = libusb20_be_get_dev_quirk(pbe, x, &q);
296		if (error) {
297			if (x == 0) {
298				printf("No device quirks - maybe the USB quirk "
299				    "module has not been loaded.\n");
300			}
301			break;
302		}
303		if (strcmp(q.quirkname, "UQ_NONE")) {
304			printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
305			    "REVHI=0x%04x QUIRK=%s\n",
306			    q.vid, q.pid, q.bcdDeviceLow,
307			    q.bcdDeviceHigh, q.quirkname);
308		}
309	}
310	printf("\n");
311	return;
312}
313
314void
315dump_device_desc(struct libusb20_device *pdev)
316{
317	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
318
319	ddesc = libusb20_dev_get_device_desc(pdev);
320	LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
321	return;
322}
323
324void
325dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
326{
327	struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
328	struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
329	struct libusb20_config *pcfg = NULL;
330	uint8_t cfg_index;
331	uint8_t cfg_index_end;
332	uint8_t x;
333	uint8_t y;
334
335	ddesc = libusb20_dev_get_device_desc(pdev);
336
337	if (all_cfg) {
338		cfg_index = 0;
339		cfg_index_end = ddesc->bNumConfigurations;
340	} else {
341		cfg_index = libusb20_dev_get_config_index(pdev);
342		cfg_index_end = cfg_index + 1;
343	}
344
345	for (; cfg_index != cfg_index_end; cfg_index++) {
346
347		pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
348		if (!pcfg) {
349			continue;
350		}
351		printf("\n Configuration index %u\n\n", cfg_index);
352		cdesc = &(pcfg->desc);
353		LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
354		dump_extra(&(pcfg->extra), "  " "  ");
355
356		for (x = 0; x != pcfg->num_interface; x++) {
357			printf("\n    Interface %u\n", x);
358			dump_iface(pdev, pcfg->interface + x);
359			printf("\n");
360			for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
361				printf("\n    Interface %u Alt %u\n", x, y + 1);
362				dump_iface(pdev,
363				    (pcfg->interface + x)->altsetting + y);
364				printf("\n");
365			}
366		}
367		printf("\n");
368		free(pcfg);
369	}
370	return;
371}
372
373void
374dump_string_by_index(struct libusb20_device *pdev, uint8_t str_index)
375{
376	char *pbuf;
377	uint8_t n;
378	uint8_t len;
379
380	pbuf = malloc(256);
381	if (pbuf == NULL)
382		err(1, "out of memory");
383
384	if (str_index == 0) {
385		/* language table */
386		if (libusb20_dev_req_string_sync(pdev,
387		    str_index, 0, pbuf, 256)) {
388			printf("STRING_0x%02x = <read error>\n", str_index);
389		} else {
390			printf("STRING_0x%02x = ", str_index);
391			len = (uint8_t)pbuf[0];
392			for (n = 0; n != len; n++) {
393				printf("0x%02x%s", (uint8_t)pbuf[n],
394				    (n != (len-1)) ? ", " : "");
395			}
396			printf("\n");
397		}
398	} else {
399		/* ordinary string */
400		if (libusb20_dev_req_string_simple_sync(pdev,
401		    str_index, pbuf, 256)) {
402			printf("STRING_0x%02x = <read error>\n", str_index);
403		} else {
404			printf("STRING_0x%02x = <%s>\n", str_index, pbuf);
405		}
406	}
407	free(pbuf);
408}
409