Linux USB

 

All USB devices have a hierarchy of descriptors which describe to the host information such as what device is, who makes it, what version

 

of USB it supports, how many ways it can be configured, the number of endpoints and their types etc. The more common USB descriptions

 

are: Device Descriptors, Configurations Descriptors, Interface Descriptors, Endpoint Descriptors, String Descriptors

 

USB devices can only have one device descriptor. The device descriptor includes information such as what USB revision the device

 

complies to, the Vendor ID and the Product ID used to load appropriated drivers and the numbers of configurations the device can have.

 

The number of configurations indicate how many configuration descriptors branches are to follow.

 

The configuration descriptor specifies values such as the amount of power this particular configuration uses, if the device is self or bus

 

powered and the number of interfaces it has. When a device is enumerated, the host reads the device descriptors and can make a

 

decision of which configuration to enable. It can only enable one configuration at a time.

 

For example, it is possible to have a high power bus powered configuration and a self powered configuration. If the device is plugged into

 

a host with a mains power supply, the device driver choose to enable high power bus powered configuration enabling the device to be

 

powered without a connection to the mains, yet it it is connected to a laptop or personal organiser it could enable the 2nd configuration

 

(self powered) requiring the user to plug your device into the power point. The configuration settings are not limited to power differences.

 

Each configuration could be powered in the same way and draw the same current, yet have different interface or endpoint combinations.

 

However it should be noted that changing the configuration requires all activity on each endpoint to stop. While USB offers flexiability,

 

very few devices have more than 1 configuration.

 

 

 

To enumerate USB devices: usb.h + usb1.c

 

usb.h >>

 

#ifndef _USB_H #define _USB_H typedef struct usb_handle usb_handle; typedef struct usb_ifc_info usb_ifc_info; struct usb_ifc_info { unsigned short dev_vendor; unsigned short dev_product; unsigned char dev_class; unsigned char dev_subclass; unsigned char dev_protocol; unsigned char ifc_class; unsigned char ifc_subclass; unsigned char ifc_protocol; unsigned char has_bulk_in; unsigned char has_bulk_out; unsigned char writable; char serial_number[256]; }; typedef int (*ifc_match_func)(usb_ifc_info *ifc); usb_handle *usb_open(ifc_match_func callback); int usb_close(usb_handle *h); int usb_read(usb_handle *h, void *_data, int len); int usb_write(usb_handle *h, const void *_data, int len); #endif 

 

usb.c >>

 

#include <stdio.h> #include <stdlib.h> #include <dirent.h> #include <fcntl.h> #include <sys/ioctl.h> #include <string.h> #include <linux/usbdevice_fs.h> #include "usb.h" #include <linux/version.h> #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20) #include <linux/usb/ch9.h> #else #include <linux/usb_ch9.h> #endif static unsigned short vendor_id = 0; static const char *serial = 0; static usb_handle *usb = 0; int match_fastboot(usb_ifc_info *info) { if (!(vendor_id && (info->dev_vendor == vendor_id)) && (info->dev_vendor != 0x18d1)) return -1; if (info->ifc_class != 0xff) return -1; if (info->ifc_subclass != 0x42) return -1; if (info->ifc_protocol != 0x03) return -1; if (serial && strcmp(serial, info->serial_number) != 0) return -1; return 0; } int list_devices_callback(usb_ifc_info *info) { if (match_fastboot(info) == 0) { char* serial = info->serial_number; if (!info->writable) { serial = "no permissions"; } if (!serial[0]) { serial = "??????????????"; } //printf("%s/tfastboot/n", serial); } return -1; } struct usb_handle { char fname[64]; int desc; unsigned char ep_in; unsigned char ep_out; }; static inline int badname(const char *name) { while (*name) { if (!isdigit(*name++)) return 1; } return 0; } static inline int check(void *_desc, int len, unsigned type, int size) { unsigned char *desc = _desc; if (len < size) return -1; if (desc[0] < size) return -1; if (desc[0] > len) return -1; if (desc[1] != type) return -1; return 0; } // All USB devices have a hierarchy of descriptors which describe to the host information such as what device is, who makes it, what version of USB it supports, how many ways // it can be configured, the number of endpoints and their types etc. // The more common USB descriptions are: Device Descriptors, Configurations Descriptors, Interface Descriptors, Endpoint Descriptors, String Descriptors // USB devices can only have one device descriptor. The device descriptor includes information such as what USB revision the device complies to, the Vendor ID and the Product ID // used to load appropriated drivers and the numbers of configurations the device can have. The number of configurations indicate how many configuration descriptors branches // are to follow. // The configuration descriptor specifies values such as the amount of power this particular configuration uses, if the device is self or bus powered and the number of interfaces // it has. When a device is enumerated, the host reads the device descriptors and can make a decision of which configuration to enable. It can only enable one configuration at a time. // For example, it is possible to have a high power bus powered configuration and a self powered configuration. If the device is plugged into a host with a mains power supply, the // device driver choose to enable high power bus powered configuration enabling the device to be powered without a connection to the mains, yet it it is connected to a laptop or personal // organiser it could enable the 2nd configuration (self powered) requiring the user to plug your device into the power point. // The configuration settings are not limited to power differences. Each configuration could be powered in the same way and draw the same current, yet have different interface or endpoint // combinations. However it should be noted that changing the configuration requires all activity on each endpoint to stop. While USB offers flexiability, very few devices have more than 1 // configuration. // descriptor = dev + cfg + ifc1 + ... + ifcN static int filter_usb_device(int fd, char *ptr, int len, int writable, ifc_match_func callback, int *ept_in_id, int *ept_out_id, int *ifc_id) { struct usb_device_descriptor *dev; struct usb_config_descriptor *cfg; struct usb_interface_descriptor *ifc; struct usb_endpoint_descriptor *ept; struct usb_ifc_info info; int in, out; unsigned i, e; if (check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE)) return -1; dev = (void*) ptr; len -= dev->bLength; ptr += dev->bLength; if (check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE)) return -1; cfg = (void*) ptr; len -= cfg->bLength; ptr += cfg->bLength; info.dev_vendor = dev->idVendor; info.dev_product = dev->idProduct; info.dev_class = dev->bDeviceClass; info.dev_subclass = dev->bDeviceSubClass; info.dev_protocol = dev->bDeviceProtocol; info.writable = writable; printf(" [VID=0x%04x:PID=0x%04x Class=%d SubClass=%d protocol=%d]", info.dev_vendor, info.dev_product, info.dev_class, info.dev_subclass, info.dev_protocol); printf("Numbers of Congigurations = %d /n", dev->bNumConfigurations); info.serial_number[0] = 0; if (dev->iSerialNumber) { struct usbdevfs_ctrltransfer ctrl; __u16 buffer[128]; int result; memset(buffer, 0, sizeof(buffer)); ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE; ctrl.bRequest = USB_REQ_GET_DESCRIPTOR; ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber; ctrl.wIndex = 0; ctrl.wLength = sizeof(buffer); ctrl.data = buffer; result = ioctl(fd, USBDEVFS_CONTROL, &ctrl); if (result > 0) { int i; // skip first word and copy the rest to the serial string, change shorts to bytes. result /= 2; for (i = 1; i < result; i++) { info.serial_number[i-1] = buffer[i]; } info.serial_number[i-1] = 0; printf(" [SerialNumber=%s]/n", info.serial_number); } else { printf("/n"); } } else { printf("/n"); } for (i = 0; i < cfg->bNumInterfaces; i++) { if (check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE)) return -1; ifc = (void*) ptr; len -= ifc->bLength; ptr += ifc->bLength; in = -1; out = -1; info.ifc_class = ifc->bInterfaceClass; info.ifc_subclass = ifc->bInterfaceSubClass; info.ifc_protocol = ifc->bInterfaceProtocol; for (e = 0; e < ifc->bNumEndpoints; e++) { if (check(ptr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE)) return -1; ept = (void*) ptr; len -= ept->bLength; ptr += ept->bLength; if ((ept->bmAttributes & 0x03) != 0x02) continue; if (ept->bEndpointAddress & 0x80) { in = ept->bEndpointAddress; } else { out = ept->bEndpointAddress; } } info.has_bulk_in = (in != -1); info.has_bulk_out = (out != -1); // list_devices_callback(&info) if (callback(&info) == 0) { *ept_in_id = in; *ept_out_id = out; *ifc_id = ifc->bInterfaceNumber; return 0; } } return -1; } // find_usb_device("/dev/bus/usb", list_devices_callback) static usb_handle *find_usb_device(const char *base, ifc_match_func callback) { usb_handle *usb = 0; char busname[64], devname[64]; char desc[1024]; int n, in, out, ifc; DIR *busdir, *devdir; struct dirent *de; int fd; int writable; busdir = opendir(base); if (busdir == 0) return 0; while ((de = readdir(busdir)) && (usb == 0)) { if (badname(de->d_name)) continue; sprintf(busname, "%s/%s", base, de->d_name); printf("[BusName] : %s/n", busname); devdir = opendir(busname); if (devdir == 0) continue; while ((de = readdir(devdir)) && (usb == 0)) { if (badname(de->d_name)) continue; sprintf(devname, "%s/%s", busname, de->d_name); printf("/t[DeviceName] : %s/n", devname); writable = 1; if ((fd = open(devname, O_RDWR)) < 0) { writable = 0; if ((fd = open(devname, O_RDONLY)) < 0) { continue; } else { printf("/t/t[Readable]"); } } else { printf("/t/t[Writable && Readable]"); } // 1024 bytes n = read(fd, desc, sizeof(desc)); printf(" [Length=%d]", n); if (filter_usb_device(fd, desc, n, writable, callback, &in, &out, &ifc) == 0) { usb = calloc(1, sizeof(usb_handle)); strcpy(usb->fname, devname); usb->ep_in = in; usb->ep_out = out; usb->desc = fd; n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc); if (n != 0) { close(fd); free(usb); usb = 0; continue; } else { close(fd); } } } closedir(devdir); } closedir(busdir); return usb; } usb_handle *usb_open(ifc_match_func callback) { return find_usb_device("/dev/bus/usb", callback); } int main() { usb_open(list_devices_callback); return 0; } 

 

执行结果: