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