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