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 * $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 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 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 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 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 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