int
libusb_get_device_descriptor(libusb_device *dev,
struct libusb_device_descriptor *desc)
{
struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
struct libusb20_device *pdev;
if ((dev == NULL) || (desc == NULL))
return (LIBUSB_ERROR_INVALID_PARAM);
pdev = dev->os_priv;
pdesc = libusb20_dev_get_device_desc(pdev);
desc->bLength = pdesc->bLength;
desc->bDescriptorType = pdesc->bDescriptorType;
desc->bcdUSB = pdesc->bcdUSB;
desc->bDeviceClass = pdesc->bDeviceClass;
desc->bDeviceSubClass = pdesc->bDeviceSubClass;
desc->bDeviceProtocol = pdesc->bDeviceProtocol;
desc->bMaxPacketSize0 = pdesc->bMaxPacketSize0;
desc->idVendor = pdesc->idVendor;
desc->idProduct = pdesc->idProduct;
desc->bcdDevice = pdesc->bcdDevice;
desc->iManufacturer = pdesc->iManufacturer;
desc->iProduct = pdesc->iProduct;
desc->iSerialNumber = pdesc->iSerialNumber;
desc->bNumConfigurations = pdesc->bNumConfigurations;
return (0);
}
int
libusb_get_config_descriptor_by_value(libusb_device *dev,
uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
{
struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
struct libusb20_device *pdev;
int i;
int err;
if (dev == NULL || config == NULL)
return (LIBUSB_ERROR_INVALID_PARAM);
pdev = dev->os_priv;
pdesc = libusb20_dev_get_device_desc(pdev);
for (i = 0; i < pdesc->bNumConfigurations; i++) {
err = libusb_get_config_descriptor(dev, i, config);
if (err)
return (err);
if ((*config)->bConfigurationValue == bConfigurationValue)
return (0); /* success */
libusb_free_config_descriptor(*config);
}
*config = NULL;
return (LIBUSB_ERROR_NOT_FOUND);
}
void
usb_set_config_test(uint16_t vid, uint16_t pid, uint32_t duration)
{
struct libusb20_device *pdev;
struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
int x;
int error;
int failed;
int exp;
pdev = find_usb_device(vid, pid);
if (pdev == NULL) {
printf("USB device not found\n");
return;
}
error = libusb20_dev_open(pdev, 0);
if (error) {
printf("Could not open USB device\n");
libusb20_dev_free(pdev);
return;
}
failed = 0;
printf("Starting set config test for "
"VID=0x%04x PID=0x%04x\n", vid, pid);
for (x = 255; x > -1; x--) {
error = libusb20_dev_set_config_index(pdev, x);
if (error == 0) {
if (x == 255) {
printf("Unconfiguring USB device "
"was successful\n");
} else {
printf("Setting configuration %d "
"was successful\n", x);
}
} else {
failed++;
}
}
ddesc = libusb20_dev_get_device_desc(pdev);
if (ddesc != NULL)
exp = ddesc->bNumConfigurations + 1;
else
exp = 1;
printf("\n\n"
"Set configuration summary\n"
"Valid count: %d/%d %s\n"
"Failed count: %d\n",
256 - failed, exp,
(exp == (256 - failed)) ? "(expected)" : "(unexpected)",
failed);
libusb20_dev_free(pdev);
}
void
dump_device_desc(struct libusb20_device *pdev)
{
struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
ddesc = libusb20_dev_get_device_desc(pdev);
LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
return;
}
void
dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
{
struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
struct libusb20_config *pcfg = NULL;
uint8_t cfg_index;
uint8_t cfg_index_end;
uint8_t x;
uint8_t y;
ddesc = libusb20_dev_get_device_desc(pdev);
if (all_cfg) {
cfg_index = 0;
cfg_index_end = ddesc->bNumConfigurations;
} else {
cfg_index = libusb20_dev_get_config_index(pdev);
cfg_index_end = cfg_index + 1;
}
for (; cfg_index != cfg_index_end; cfg_index++) {
pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
if (!pcfg) {
continue;
}
printf("\n Configuration index %u\n\n", cfg_index);
cdesc = &(pcfg->desc);
LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
dump_extra(&(pcfg->extra), " " " ");
for (x = 0; x != pcfg->num_interface; x++) {
printf("\n Interface %u\n", x);
dump_iface(pdev, pcfg->interface + x);
printf("\n");
for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
printf("\n Interface %u Alt %u\n", x, y + 1);
dump_iface(pdev,
(pcfg->interface + x)->altsetting + y);
printf("\n");
}
}
printf("\n");
free(pcfg);
}
return;
}
int
usb_find_devices(void)
{
struct libusb20_device *pdev;
struct usb_device *udev;
struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
int devnum;
int err;
/* cleanup after last device search */
/* close all opened devices, if any */
while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
udev = pdev->privLuData;
libusb20_be_dequeue_device(usb_backend, pdev);
libusb20_dev_free(pdev);
if (udev != NULL) {
LIST_DEL(usb_global_bus.devices, udev);
free(udev);
}
}
/* free old USB backend, if any */
libusb20_be_free(usb_backend);
/* do a new backend device search */
usb_backend = libusb20_be_alloc_default();
if (usb_backend == NULL) {
return (-1);
}
/* iterate all devices */
devnum = 1;
pdev = NULL;
while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) {
udev = malloc(sizeof(*udev));
if (udev == NULL)
break;
memset(udev, 0, sizeof(*udev));
udev->bus = &usb_global_bus;
snprintf(udev->filename, sizeof(udev->filename),
"/dev/ugen%u.%u",
libusb20_dev_get_bus_number(pdev),
libusb20_dev_get_address(pdev));
ddesc = libusb20_dev_get_device_desc(pdev);
udev->descriptor.bLength = sizeof(udev->descriptor);
udev->descriptor.bDescriptorType = ddesc->bDescriptorType;
udev->descriptor.bcdUSB = ddesc->bcdUSB;
udev->descriptor.bDeviceClass = ddesc->bDeviceClass;
udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass;
udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol;
udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0;
udev->descriptor.idVendor = ddesc->idVendor;
udev->descriptor.idProduct = ddesc->idProduct;
udev->descriptor.bcdDevice = ddesc->bcdDevice;
udev->descriptor.iManufacturer = ddesc->iManufacturer;
udev->descriptor.iProduct = ddesc->iProduct;
udev->descriptor.iSerialNumber = ddesc->iSerialNumber;
udev->descriptor.bNumConfigurations =
ddesc->bNumConfigurations;
if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
/* truncate number of configurations */
udev->descriptor.bNumConfigurations = USB_MAXCONFIG;
}
udev->devnum = devnum++;
/* link together the two structures */
udev->dev = pdev;
pdev->privLuData = udev;
err = libusb20_dev_open(pdev, 0);
if (err == 0) {
/* XXX get all config descriptors by default */
usb_fetch_and_parse_descriptors((void *)pdev);
libusb20_dev_close(pdev);
}
LIST_ADD(usb_global_bus.devices, udev);
}
return (devnum - 1); /* success */
}
int
main(int argc, char **argv)
{
unsigned int vid = UINT_MAX, pid = UINT_MAX; /* impossible VID:PID */
int c;
/*
* Initialize setup struct. This step is required, and initializes
* internal fields in the struct.
*
* All the "public" fields are named exactly the way as the USB
* standard describes them, namely:
*
* setup.bmRequestType: bitmask, bit 7 is direction
* bits 6/5 is request type
* (standard, class, vendor)
* bits 4..0 is recipient
* (device, interface, endpoint,
* other)
* setup.bRequest: the request itself (see get_req() for standard
* requests, or specific value)
* setup.wValue: a 16-bit value
* setup.wIndex: another 16-bit value
* setup.wLength: length of associated data transfer, direction
* depends on bit 7 of bmRequestType
*/
LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
while ((c = getopt(argc, argv, "i:p:v:")) != -1)
switch (c)
{
case 'i':
intr_ep = strtol(optarg, NULL, 0);
break;
case 'p':
pid = strtol(optarg, NULL, 0);
break;
case 'v':
vid = strtol(optarg, NULL, 0);
break;
default:
usage();
break;
}
argc -= optind;
argv += optind;
if (vid != UINT_MAX || pid != UINT_MAX)
{
if (intr_ep != 0 && (intr_ep & 0x80) == 0)
{
fprintf(stderr, "Interrupt endpoint must be of type IN\n");
usage();
}
if (argc > 0)
{
do_request = true;
int rv = parse_req(argc, argv);
if (rv < 0)
return EX_USAGE;
argc = rv;
if (argc > 0)
{
for (out_len = 0; argc > 0 && out_len < BUFLEN; out_len++, argc--)
{
unsigned n = strtoul(argv[out_len], 0, 0);
if (n > 255)
fprintf(stderr,
"Warning: data #%d 0x%0x > 0xff, truncating\n",
out_len, n);
out_buf[out_len] = (uint8_t)n;
}
out_len++;
if (argc > 0)
fprintf(stderr,
"Data count exceeds maximum of %d, ignoring %d elements\n",
BUFLEN, optind);
}
}
}
struct libusb20_backend *be;
struct libusb20_device *dev;
if ((be = libusb20_be_alloc_default()) == NULL)
{
perror("libusb20_be_alloc()");
return 1;
}
dev = NULL;
while ((dev = libusb20_be_device_foreach(be, dev)) != NULL)
{
struct LIBUSB20_DEVICE_DESC_DECODED *ddp =
libusb20_dev_get_device_desc(dev);
printf("Found device %s (VID:PID = 0x%04x:0x%04x)\n",
libusb20_dev_get_desc(dev),
ddp->idVendor, ddp->idProduct);
if (ddp->idVendor == vid && ddp->idProduct == pid)
doit(dev);
}
libusb20_be_free(be);
return 0;
}
int
main(int argc, char **argv)
{
unsigned int vid = UINT_MAX, pid = UINT_MAX; /* impossible VID:PID */
int c;
while ((c = getopt(argc, argv, "i:o:p:v:")) != -1)
switch (c)
{
case 'i':
in_ep = strtol(optarg, NULL, 0);
break;
case 'o':
out_ep = strtol(optarg, NULL, 0);
break;
case 'p':
pid = strtol(optarg, NULL, 0);
break;
case 'v':
vid = strtol(optarg, NULL, 0);
break;
default:
usage();
break;
}
argc -= optind;
argv += optind;
if (vid != UINT_MAX || pid != UINT_MAX)
{
if (in_ep == 0 || out_ep == 0)
{
usage();
}
if ((in_ep & 0x80) == 0)
{
fprintf(stderr, "IN_EP must have bit 7 set\n");
return (EX_USAGE);
}
if (argc > 0)
{
for (out_len = 0; argc > 0 && out_len < BUFLEN; out_len++, argc--)
{
unsigned n = strtoul(argv[out_len], 0, 0);
if (n > 255)
fprintf(stderr,
"Warning: data #%d 0x%0x > 0xff, truncating\n",
out_len, n);
out_buf[out_len] = (uint8_t)n;
}
out_len++;
if (argc > 0)
fprintf(stderr,
"Data count exceeds maximum of %d, ignoring %d elements\n",
BUFLEN, optind);
}
}
struct libusb20_backend *be;
struct libusb20_device *dev;
if ((be = libusb20_be_alloc_default()) == NULL)
{
perror("libusb20_be_alloc()");
return 1;
}
dev = NULL;
while ((dev = libusb20_be_device_foreach(be, dev)) != NULL)
{
struct LIBUSB20_DEVICE_DESC_DECODED *ddp =
libusb20_dev_get_device_desc(dev);
printf("Found device %s (VID:PID = 0x%04x:0x%04x)\n",
libusb20_dev_get_desc(dev),
ddp->idVendor, ddp->idProduct);
if (ddp->idVendor == vid && ddp->idProduct == pid)
doit(dev);
}
libusb20_be_free(be);
return 0;
}
