usb4bsd: Pull up libusb and usbcontrol to FreeBSD current's.
[dragonfly.git] / usr.sbin / usbconfig / dump.c
1 /* $FreeBSD: src/usr.sbin/usbconfig/dump.c,v 1.7 2011/02/26 09:28:52 hselasky Exp $ */
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
46 const char *
47 dump_mode(uint8_t value)
48 {
49         if (value == LIBUSB20_MODE_HOST)
50                 return ("HOST");
51         return ("DEVICE");
52 }
53
54 const char *
55 dump_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
75 const char *
76 dump_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
95 static void
96 dump_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
165 static void
166 dump_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
193 static void
194 dump_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
205 static void
206 dump_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
223 void
224 dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
225 {
226         char buf[128];
227         uint8_t n;
228
229         printf("%s, cfg=%u md=%s spd=%s pwr=%s\n",
230             libusb20_dev_get_desc(pdev),
231             libusb20_dev_get_config_index(pdev),
232             dump_mode(libusb20_dev_get_mode(pdev)),
233             dump_speed(libusb20_dev_get_speed(pdev)),
234             dump_power_mode(libusb20_dev_get_power_mode(pdev)));
235
236         if (!show_ifdrv)
237                 return;
238
239         for (n = 0; n != 255; n++) {
240                 if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
241                         break;
242                 if (buf[0] == 0)
243                         continue;
244                 printf("ugen%u.%u.%u: %s\n",
245                     libusb20_dev_get_bus_number(pdev),
246                     libusb20_dev_get_address(pdev), n, buf);
247         }
248 }
249
250 void
251 dump_be_quirk_names(struct libusb20_backend *pbe)
252 {
253         struct libusb20_quirk q;
254         uint16_t x;
255         int error;
256
257         memset(&q, 0, sizeof(q));
258
259         printf("\nDumping list of supported quirks:\n\n");
260
261         for (x = 0; x != 0xFFFF; x++) {
262
263                 error = libusb20_be_get_quirk_name(pbe, x, &q);
264                 if (error) {
265                         if (x == 0) {
266                                 printf("No quirk names - maybe the USB quirk "
267                                     "module has not been loaded.\n");
268                         }
269                         break;
270                 }
271                 if (strcmp(q.quirkname, "UQ_NONE"))
272                         printf("%s\n", q.quirkname);
273         }
274         printf("\n");
275         return;
276 }
277
278 void
279 dump_be_dev_quirks(struct libusb20_backend *pbe)
280 {
281         struct libusb20_quirk q;
282         uint16_t x;
283         int error;
284
285         memset(&q, 0, sizeof(q));
286
287         printf("\nDumping current device quirks:\n\n");
288
289         for (x = 0; x != 0xFFFF; x++) {
290
291                 error = libusb20_be_get_dev_quirk(pbe, x, &q);
292                 if (error) {
293                         if (x == 0) {
294                                 printf("No device quirks - maybe the USB quirk "
295                                     "module has not been loaded.\n");
296                         }
297                         break;
298                 }
299                 if (strcmp(q.quirkname, "UQ_NONE")) {
300                         printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
301                             "REVHI=0x%04x QUIRK=%s\n",
302                             q.vid, q.pid, q.bcdDeviceLow,
303                             q.bcdDeviceHigh, q.quirkname);
304                 }
305         }
306         printf("\n");
307         return;
308 }
309
310 void
311 dump_device_desc(struct libusb20_device *pdev)
312 {
313         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
314
315         ddesc = libusb20_dev_get_device_desc(pdev);
316         LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
317         return;
318 }
319
320 void
321 dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
322 {
323         struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
324         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
325         struct libusb20_config *pcfg = NULL;
326         uint8_t cfg_index;
327         uint8_t cfg_index_end;
328         uint8_t x;
329         uint8_t y;
330
331         ddesc = libusb20_dev_get_device_desc(pdev);
332
333         if (all_cfg) {
334                 cfg_index = 0;
335                 cfg_index_end = ddesc->bNumConfigurations;
336         } else {
337                 cfg_index = libusb20_dev_get_config_index(pdev);
338                 cfg_index_end = cfg_index + 1;
339         }
340
341         for (; cfg_index != cfg_index_end; cfg_index++) {
342
343                 pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
344                 if (!pcfg) {
345                         continue;
346                 }
347                 printf("\n Configuration index %u\n\n", cfg_index);
348                 cdesc = &(pcfg->desc);
349                 LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
350                 dump_extra(&(pcfg->extra), "  " "  ");
351
352                 for (x = 0; x != pcfg->num_interface; x++) {
353                         printf("\n    Interface %u\n", x);
354                         dump_iface(pdev, pcfg->interface + x);
355                         printf("\n");
356                         for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
357                                 printf("\n    Interface %u Alt %u\n", x, y + 1);
358                                 dump_iface(pdev,
359                                     (pcfg->interface + x)->altsetting + y);
360                                 printf("\n");
361                         }
362                 }
363                 printf("\n");
364                 free(pcfg);
365         }
366         return;
367 }
368
369 void
370 dump_string_by_index(struct libusb20_device *pdev, uint8_t str_index)
371 {
372         char *pbuf;
373         uint8_t n;
374         uint8_t len;
375
376         pbuf = malloc(256);
377         if (pbuf == NULL)
378                 err(1, "out of memory");
379
380         if (str_index == 0) {
381                 /* language table */
382                 if (libusb20_dev_req_string_sync(pdev,
383                     str_index, 0, pbuf, 256)) {
384                         printf("STRING_0x%02x = <read error>\n", str_index);
385                 } else {
386                         printf("STRING_0x%02x = ", str_index);
387                         len = (uint8_t)pbuf[0];
388                         for (n = 0; n != len; n++) {
389                                 printf("0x%02x%s", (uint8_t)pbuf[n], 
390                                     (n != (len-1)) ? ", " : "");
391                         }
392                         printf("\n");
393                 }
394         } else {
395                 /* ordinary string */
396                 if (libusb20_dev_req_string_simple_sync(pdev,
397                     str_index, pbuf, 256)) {
398                         printf("STRING_0x%02x = <read error>\n", str_index);
399                 } else {
400                         printf("STRING_0x%02x = <%s>\n", str_index, pbuf);
401                 }
402         }
403         free(pbuf);
404 }