1 /*-
2 * SPDX-License-Identifier: Beerware
3 *
4 * ----------------------------------------------------------------------------
5 * "THE BEER-WARE LICENSE" (Revision 42) (by Poul-Henning Kamp):
6 * <[email protected]> wrote this file. As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return. Joerg Wunsch
9 * ----------------------------------------------------------------------------
10 *
11 * $FreeBSD$
12 */
13
14 /*
15 * Simple demo program to illustrate the handling of FreeBSD's
16 * libusb20.
17 */
18
19 /*
20 * Examples:
21 * Just list all VID:PID pairs
22 * ./control
23 *
24 * Standard device request GET_STATUS, report two bytes of status
25 * (bit 0 in the first byte returned is the "self powered" bit)
26 * ./control -v 0x3eb -p 0x2103 in std dev get_status 0 0 2
27 *
28 * Request input reports through the interrupt pipe from a mouse
29 * device (move the mouse around after issuing the command):
30 * ./control -v 0x093a -p 0x2516 -i 0x81
31 *
32 */
33
34
35 #include <limits.h>
36 #include <stdbool.h>
37 #include <stdio.h>
38 #include <stdint.h>
39 #include <stdlib.h>
40 #include <sysexits.h>
41 #include <unistd.h>
42 #include <string.h>
43
44 #include <libusb20.h>
45 #include <libusb20_desc.h>
46
47 #include <sys/queue.h>
48
49 #include "util.h"
50
51 /*
52 * If you want to see the details of the internal datastructures
53 * in the debugger, unifdef the following.
54 */
55 #ifdef DEBUG
56 # include "/usr/src/lib/libusb/libusb20_int.h"
57 #endif
58
59 #define BUFLEN 64
60
61 #define TIMEOUT 5000 /* 5 s */
62
63 int intr_ep; /* endpoints */
64 struct LIBUSB20_CONTROL_SETUP_DECODED setup;
65
66 uint8_t out_buf[BUFLEN];
67 uint16_t out_len;
68
69 bool do_request;
70
71 static void
doit(struct libusb20_device * dev)72 doit(struct libusb20_device *dev)
73 {
74 int rv;
75
76 if (do_request)
77 printf("doit(): bmRequestType 0x%02x, bRequest 0x%02x, wValue 0x%04x, wIndex 0x%04x, wLength 0x%04x\n",
78 setup.bmRequestType,
79 setup.bRequest,
80 setup.wValue,
81 setup.wIndex,
82 setup.wLength);
83
84 /*
85 * Open the device, allocating memory for two possible (bulk or
86 * interrupt) transfers.
87 *
88 * If only control transfers are intended (via
89 * libusb20_dev_request_sync()), transfer_max can be given as 0.
90 */
91 if ((rv = libusb20_dev_open(dev, 1)) != 0)
92 {
93 fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv));
94 return;
95 }
96
97 /*
98 * If the device has more than one configuration, select the desired
99 * one here.
100 */
101 if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0)
102 {
103 fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv));
104 return;
105 }
106
107 uint8_t *data = 0;
108 uint16_t actlen;
109
110 if ((setup.bmRequestType & 0x80) != 0)
111 {
112 /* this is an IN request, allocate a buffer */
113 data = malloc(setup.wLength);
114 if (data == 0)
115 {
116 fprintf(stderr,
117 "Out of memory allocating %u bytes of reply buffer\n",
118 setup.wLength);
119 return;
120 }
121 }
122 else
123 data = out_buf;
124
125 if (do_request)
126 {
127 if ((rv = libusb20_dev_request_sync(dev, &setup, data,
128 &actlen,
129 TIMEOUT,
130 0 /* flags */)) != 0)
131 {
132 fprintf(stderr,
133 "libusb20_dev_request_sync: %s\n", libusb20_strerror(rv));
134 }
135 printf("sent %d bytes\n", actlen);
136 if ((setup.bmRequestType & 0x80) != 0)
137 {
138 print_formatted(data, (uint32_t)setup.wLength);
139 free(data);
140 }
141 }
142
143 if (intr_ep != 0)
144 {
145 /*
146 * One transfer has been requested in libusb20_dev_open() above;
147 * obtain the corresponding transfer struct pointer.
148 */
149 struct libusb20_transfer *xfr_intr = libusb20_tr_get_pointer(dev, 0);
150
151 if (xfr_intr == NULL)
152 {
153 fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv));
154 return;
155 }
156
157 /*
158 * Open the interrupt transfer.
159 */
160 if ((rv = libusb20_tr_open(xfr_intr, 0, 1, intr_ep)) != 0)
161 {
162 fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv));
163 return;
164 }
165
166 uint8_t in_buf[BUFLEN];
167 uint32_t rlen;
168
169 if ((rv = libusb20_tr_bulk_intr_sync(xfr_intr, in_buf, BUFLEN, &rlen, TIMEOUT))
170 != 0)
171 {
172 fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv));
173 }
174 printf("received %d bytes\n", rlen);
175 if (rlen > 0)
176 print_formatted(in_buf, rlen);
177
178 libusb20_tr_close(xfr_intr);
179 }
180
181 libusb20_dev_close(dev);
182 }
183
184 static void
usage(void)185 usage(void)
186 {
187 fprintf(stderr,
188 "Usage ./usb [-i <INTR_EP>] -v <VID> -p <PID> [dir type rcpt req wValue wIndex wLength [<outdata> ...]]\n");
189 exit(EX_USAGE);
190 }
191
192 static const char *reqnames[] =
193 {
194 "get_status",
195 "clear_feature",
196 "res1",
197 "set_feature",
198 "res2",
199 "set_address",
200 "get_descriptor",
201 "set_descriptor",
202 "get_configuration",
203 "set_configuration",
204 "get_interface",
205 "set_interface",
206 "synch_frame",
207 };
208
209 static int
get_req(const char * reqname)210 get_req(const char *reqname)
211 {
212 size_t i;
213 size_t l = strlen(reqname);
214
215 for (i = 0;
216 i < sizeof reqnames / sizeof reqnames[0];
217 i++)
218 if (strncasecmp(reqname, reqnames[i], l) == 0)
219 return i;
220
221 return strtoul(reqname, 0, 0);
222 }
223
224
225 static int
parse_req(int argc,char ** argv)226 parse_req(int argc, char **argv)
227 {
228 int idx;
229 uint8_t rt = 0;
230
231 for (idx = 0; argc != 0 && idx <= 6; argc--, idx++)
232 switch (idx)
233 {
234 case 0:
235 /* dir[ection]: i[n] | o[ut] */
236 if (*argv[idx] == 'i')
237 rt |= 0x80;
238 else if (*argv[idx] == 'o')
239 /* nop */;
240 else
241 {
242 fprintf(stderr, "request direction must be \"in\" or \"out\" (got %s)\n",
243 argv[idx]);
244 return -1;
245 }
246 break;
247
248 case 1:
249 /* type: s[tandard] | c[lass] | v[endor] */
250 if (*argv[idx] == 's')
251 /* nop */;
252 else if (*argv[idx] == 'c')
253 rt |= 0x20;
254 else if (*argv[idx] == 'v')
255 rt |= 0x40;
256 else
257 {
258 fprintf(stderr,
259 "request type must be one of \"standard\", \"class\", or \"vendor\" (got %s)\n",
260 argv[idx]);
261 return -1;
262 }
263 break;
264
265 case 2:
266 /* rcpt: d[evice], i[nterface], e[ndpoint], o[ther] */
267 if (*argv[idx] == 'd')
268 /* nop */;
269 else if (*argv[idx] == 'i')
270 rt |= 1;
271 else if (*argv[idx] == 'e')
272 rt |= 2;
273 else if (*argv[idx] == 'o')
274 rt |= 3;
275 else
276 {
277 fprintf(stderr,
278 "recipient must be one of \"device\", \"interface\", \"endpoint\", or \"other\" (got %s)\n",
279 argv[idx]);
280 return -1;
281 }
282 setup.bmRequestType = rt;
283 break;
284
285 case 3:
286 setup.bRequest = get_req(argv[idx]);
287 break;
288
289 case 4:
290 setup.wValue = strtoul(argv[idx], 0, 0);
291 break;
292
293 case 5:
294 setup.wIndex = strtoul(argv[idx], 0, 0);
295 break;
296
297 case 6:
298 setup.wLength = strtoul(argv[idx], 0, 0);
299 break;
300 }
301
302 return argc;
303 }
304
305
306 int
main(int argc,char ** argv)307 main(int argc, char **argv)
308 {
309 unsigned int vid = UINT_MAX, pid = UINT_MAX; /* impossible VID:PID */
310 int c;
311
312 /*
313 * Initialize setup struct. This step is required, and initializes
314 * internal fields in the struct.
315 *
316 * All the "public" fields are named exactly the way as the USB
317 * standard describes them, namely:
318 *
319 * setup.bmRequestType: bitmask, bit 7 is direction
320 * bits 6/5 is request type
321 * (standard, class, vendor)
322 * bits 4..0 is recipient
323 * (device, interface, endpoint,
324 * other)
325 * setup.bRequest: the request itself (see get_req() for standard
326 * requests, or specific value)
327 * setup.wValue: a 16-bit value
328 * setup.wIndex: another 16-bit value
329 * setup.wLength: length of associated data transfer, direction
330 * depends on bit 7 of bmRequestType
331 */
332 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
333
334 while ((c = getopt(argc, argv, "i:p:v:")) != -1)
335 switch (c)
336 {
337 case 'i':
338 intr_ep = strtol(optarg, NULL, 0);
339 break;
340
341 case 'p':
342 pid = strtol(optarg, NULL, 0);
343 break;
344
345 case 'v':
346 vid = strtol(optarg, NULL, 0);
347 break;
348
349 default:
350 usage();
351 break;
352 }
353 argc -= optind;
354 argv += optind;
355
356 if (vid != UINT_MAX || pid != UINT_MAX)
357 {
358 if (intr_ep != 0 && (intr_ep & 0x80) == 0)
359 {
360 fprintf(stderr, "Interrupt endpoint must be of type IN\n");
361 usage();
362 }
363
364 if (argc > 0)
365 {
366 do_request = true;
367
368 int rv = parse_req(argc, argv);
369 if (rv < 0)
370 return EX_USAGE;
371 argc = rv;
372
373 if (argc > 0)
374 {
375 for (out_len = 0; argc > 0 && out_len < BUFLEN; out_len++, argc--)
376 {
377 unsigned n = strtoul(argv[out_len], 0, 0);
378 if (n > 255)
379 fprintf(stderr,
380 "Warning: data #%d 0x%0x > 0xff, truncating\n",
381 out_len, n);
382 out_buf[out_len] = (uint8_t)n;
383 }
384 out_len++;
385 if (argc > 0)
386 fprintf(stderr,
387 "Data count exceeds maximum of %d, ignoring %d elements\n",
388 BUFLEN, optind);
389 }
390 }
391 }
392
393 struct libusb20_backend *be;
394 struct libusb20_device *dev;
395
396 if ((be = libusb20_be_alloc_default()) == NULL)
397 {
398 perror("libusb20_be_alloc()");
399 return 1;
400 }
401
402 dev = NULL;
403 while ((dev = libusb20_be_device_foreach(be, dev)) != NULL)
404 {
405 struct LIBUSB20_DEVICE_DESC_DECODED *ddp =
406 libusb20_dev_get_device_desc(dev);
407
408 printf("Found device %s (VID:PID = 0x%04x:0x%04x)\n",
409 libusb20_dev_get_desc(dev),
410 ddp->idVendor, ddp->idProduct);
411
412 if (ddp->idVendor == vid && ddp->idProduct == pid)
413 doit(dev);
414 }
415
416 libusb20_be_free(be);
417 return 0;
418 }
419