static struct libusb20_transfer * usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no) { struct libusb20_device *pdev = (void *)dev; struct libusb20_transfer *xfer; int err; uint32_t bufsize; uint8_t x; uint8_t speed; x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2; if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) { /* this is an IN endpoint */ x |= 1; } speed = libusb20_dev_get_speed(pdev); /* select a sensible buffer size */ if (speed == LIBUSB20_SPEED_LOW) { bufsize = 256; } else if (speed == LIBUSB20_SPEED_FULL) { bufsize = 4096; } else if (speed == LIBUSB20_SPEED_SUPER) { bufsize = 65536; } else { bufsize = 16384; } xfer = libusb20_tr_get_pointer(pdev, x); if (xfer == NULL) return (xfer); err = libusb20_tr_open(xfer, bufsize, 1, ep_no); if (err == LIBUSB20_ERROR_BUSY) { /* already opened */ return (xfer); } else if (err) { return (NULL); } /* success */ return (xfer); }
static void exec_host_modem_test(struct modem *p, uint16_t vid, uint16_t pid) { struct libusb20_device *pdev; uint8_t ntest = 0; uint8_t x; uint8_t in_ep; uint8_t out_ep; uint8_t iface; int error; pdev = find_usb_device(vid, pid); if (pdev == NULL) { printf("USB device not found\n"); return; } if (p->use_vendor_specific) find_usb_endpoints(pdev, 255, 255, 255, 0, &iface, &in_ep, &out_ep, 0); else find_usb_endpoints(pdev, 2, 2, 1, 0, &iface, &in_ep, &out_ep, 1); if ((in_ep == 0) || (out_ep == 0)) { printf("Could not find USB endpoints\n"); libusb20_dev_free(pdev); return; } printf("Attaching to: %s @ iface %d\n", libusb20_dev_get_desc(pdev), iface); if (libusb20_dev_open(pdev, 2)) { printf("Could not open USB device\n"); libusb20_dev_free(pdev); return; } if (libusb20_dev_detach_kernel_driver(pdev, iface)) { printf("WARNING: Could not detach kernel driver\n"); } p->xfer_in = libusb20_tr_get_pointer(pdev, 0); error = libusb20_tr_open(p->xfer_in, 65536 / 4, 1, in_ep); if (error) { printf("Could not open USB endpoint %d\n", in_ep); libusb20_dev_free(pdev); return; } p->xfer_out = libusb20_tr_get_pointer(pdev, 1); error = libusb20_tr_open(p->xfer_out, 65536 / 4, 1, out_ep); if (error) { printf("Could not open USB endpoint %d\n", out_ep); libusb20_dev_free(pdev); return; } p->usb_dev = pdev; p->usb_iface = iface; p->errors = 0; if (p->control_ep_test) ntest += 7; if (p->data_stress_test) ntest += 1; if (ntest == 0) { printf("No tests selected\n"); } else { if (p->control_ep_test) { for (x = 1; x != 8; x++) { usb_modem_control_ep_test(p, (p->duration + ntest - 1) / ntest, x); } } if (p->data_stress_test) { usb_modem_data_stress_test(p, (p->duration + ntest - 1) / ntest); } } printf("\nDone\n"); libusb20_dev_free(pdev); }
static void doit(struct libusb20_device *dev) { int rv; if (do_request) printf("doit(): bmRequestType 0x%02x, bRequest 0x%02x, wValue 0x%04x, wIndex 0x%04x, wLength 0x%04x\n", setup.bmRequestType, setup.bRequest, setup.wValue, setup.wIndex, setup.wLength); /* * Open the device, allocating memory for two possible (bulk or * interrupt) transfers. * * If only control transfers are intended (via * libusb20_dev_request_sync()), transfer_max can be given as 0. */ if ((rv = libusb20_dev_open(dev, 1)) != 0) { fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv)); return; } /* * If the device has more than one configuration, select the desired * one here. */ if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0) { fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv)); return; } uint8_t *data = 0; uint16_t actlen; if ((setup.bmRequestType & 0x80) != 0) { /* this is an IN request, allocate a buffer */ data = malloc(setup.wLength); if (data == 0) { fprintf(stderr, "Out of memory allocating %u bytes of reply buffer\n", setup.wLength); return; } } else data = out_buf; if (do_request) { if ((rv = libusb20_dev_request_sync(dev, &setup, data, &actlen, TIMEOUT, 0 /* flags */)) != 0) { fprintf(stderr, "libusb20_dev_request_sync: %s\n", libusb20_strerror(rv)); } printf("sent %d bytes\n", actlen); if ((setup.bmRequestType & 0x80) != 0) { print_formatted(data, (uint32_t)setup.wLength); free(data); } } if (intr_ep != 0) { /* * One transfer has been requested in libusb20_dev_open() above; * obtain the corresponding transfer struct pointer. */ struct libusb20_transfer *xfr_intr = libusb20_tr_get_pointer(dev, 0); if (xfr_intr == NULL) { fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv)); return; } /* * Open the interrupt transfer. */ if ((rv = libusb20_tr_open(xfr_intr, 0, 1, intr_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } uint8_t in_buf[BUFLEN]; uint32_t rlen; if ((rv = libusb20_tr_bulk_intr_sync(xfr_intr, in_buf, BUFLEN, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv)); } printf("received %d bytes\n", rlen); if (rlen > 0) print_formatted(in_buf, rlen); libusb20_tr_close(xfr_intr); } libusb20_dev_close(dev); }
static void doit(struct libusb20_device *dev) { int rv; /* * Open the device, allocating memory for two possible (bulk or * interrupt) transfers. * * If only control transfers are intended (via * libusb20_dev_request_sync()), transfer_max can be given as 0. */ if ((rv = libusb20_dev_open(dev, 2)) != 0) { fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv)); return; } /* * If the device has more than one configuration, select the desired * one here. */ if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0) { fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv)); return; } /* * Two transfers have been requested in libusb20_dev_open() above; * obtain the corresponding transfer struct pointers. */ struct libusb20_transfer *xfr_out = libusb20_tr_get_pointer(dev, 0); struct libusb20_transfer *xfr_in = libusb20_tr_get_pointer(dev, 1); if (xfr_in == NULL || xfr_out == NULL) { fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv)); return; } /* * Open both transfers, the "out" one for the write endpoint, the * "in" one for the read endpoint (ep | 0x80). */ if ((rv = libusb20_tr_open(xfr_out, 0, 1, out_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } if ((rv = libusb20_tr_open(xfr_in, 0, 1, in_ep)) != 0) { fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv)); return; } uint8_t in_buf[BUFLEN]; uint32_t rlen; if (out_len > 0) { if ((rv = libusb20_tr_bulk_intr_sync(xfr_out, out_buf, out_len, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync (OUT): %s\n", libusb20_strerror(rv)); } printf("sent %d bytes\n", rlen); } if ((rv = libusb20_tr_bulk_intr_sync(xfr_in, in_buf, BUFLEN, &rlen, TIMEOUT)) != 0) { fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv)); } printf("received %d bytes\n", rlen); if (rlen > 0) print_formatted(in_buf, rlen); libusb20_tr_close(xfr_out); libusb20_tr_close(xfr_in); libusb20_dev_close(dev); }
void usb_set_and_clear_stall_test(uint16_t vid, uint16_t pid) { struct libusb20_device *pdev; struct libusb20_transfer *pxfer; int iter; int error; int errcnt; int ep; pdev = find_usb_device(vid, pid); if (pdev == NULL) { printf("USB device not found\n"); return; } error = libusb20_dev_open(pdev, 1); if (error) { printf("Could not open USB device\n"); libusb20_dev_free(pdev); return; } printf("Starting set and clear stall test " "for VID=0x%04x PID=0x%04x\n", vid, pid); iter = 0; errcnt = 0; for (ep = 2; ep != 32; ep++) { struct LIBUSB20_CONTROL_SETUP_DECODED setup_set_stall; struct LIBUSB20_CONTROL_SETUP_DECODED setup_get_status; uint8_t epno = ((ep / 2) | ((ep & 1) << 7)); uint8_t buf[1]; LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup_set_stall); setup_set_stall.bmRequestType = 0x02; /* write endpoint */ setup_set_stall.bRequest = 0x03; /* set feature */ setup_set_stall.wValue = 0x00; /* UF_ENDPOINT_HALT */ setup_set_stall.wIndex = epno; setup_set_stall.wLength = 0; LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup_get_status); setup_get_status.bmRequestType = 0x82; /* read endpoint */ setup_get_status.bRequest = 0x00; /* get status */ setup_get_status.wValue = 0x00; setup_get_status.wIndex = epno; setup_get_status.wLength = 1; if (libusb20_dev_check_connected(pdev) != 0) { printf("Device disconnected\n"); break; } pxfer = libusb20_tr_get_pointer(pdev, 0); error = libusb20_tr_open(pxfer, 1, 1, epno); if (error != 0) { printf("Endpoint 0x%02x does not exist " "in current setting. (%s, ignored)\n", epno, libusb20_strerror(error)); continue; } printf("Stalling endpoint 0x%02x\n", epno); /* set stall */ error = libusb20_dev_request_sync(pdev, &setup_set_stall, NULL, NULL, 250, 0); if (error != 0) { printf("Endpoint 0x%02x does not allow " "setting of stall. (%s)\n", epno, libusb20_strerror(error)); errcnt++; } /* get EP status */ buf[0] = 0; error = libusb20_dev_request_sync(pdev, &setup_get_status, buf, NULL, 250, 0); if (error != 0) { printf("Endpoint 0x%02x does not allow " "reading status. (%s)\n", epno, libusb20_strerror(error)); errcnt++; } else { if (!(buf[0] & 1)) { printf("Endpoint 0x%02x status is " "not set to stalled\n", epno); errcnt++; } } buf[0] = 0; error = libusb20_tr_bulk_intr_sync(pxfer, buf, 1, NULL, 250); if (error != LIBUSB20_TRANSFER_STALL) { printf("Endpoint 0x%02x does not appear to " "have stalled. Missing stall PID!\n", epno); errcnt++; } printf("Unstalling endpoint 0x%02x\n", epno); libusb20_tr_clear_stall_sync(pxfer); /* get EP status */ buf[0] = 0; error = libusb20_dev_request_sync(pdev, &setup_get_status, buf, NULL, 250, 0); if (error != 0) { printf("Endpoint 0x%02x does not allow " "reading status. (%s)\n", epno, libusb20_strerror(error)); errcnt++; } else { if (buf[0] & 1) { printf("Endpoint 0x%02x status is " "still stalled\n", epno); errcnt++; } } libusb20_tr_close(pxfer); iter++; } libusb20_dev_free(pdev); printf("\n" "Test summary\n" "============\n" "Endpoints tested: %d\n" "Errors: %d\n", iter, errcnt); }