应用程序利用libusb读取usb设备数据

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <getopt.h>
#include <ctype.h>
#include <signal.h>
 
#include "libusb.h"
 
int verbose = 1;
 
static volatile sig_atomic_t rcv_exit;
 
 
static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp)
{
printf("      USB 3.0 Endpoint Companion:\n");
printf("        bMaxBurst:           %u\n", ep_comp->bMaxBurst);
printf("        bmAttributes:        %02xh\n", ep_comp->bmAttributes);
printf("        wBytesPerInterval:   %u\n", ep_comp->wBytesPerInterval);
}
 
static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint)
{
int i, ret;
 
printf("      Endpoint:\n");
printf("        bEndpointAddress:    %02xh\n", endpoint->bEndpointAddress);
printf("        bmAttributes:        %02xh\n", endpoint->bmAttributes);
printf("        wMaxPacketSize:      %u\n", endpoint->wMaxPacketSize);
printf("        bInterval:           %u\n", endpoint->bInterval);
printf("        bRefresh:            %u\n", endpoint->bRefresh);
printf("        bSynchAddress:       %u\n", endpoint->bSynchAddress);
 
for (i = 0; i < endpoint->extra_length;) {
if (LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
struct libusb_ss_endpoint_companion_descriptor *ep_comp;
 
ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
if (LIBUSB_SUCCESS != ret)
continue;
 
print_endpoint_comp(ep_comp);
 
libusb_free_ss_endpoint_companion_descriptor(ep_comp);
}
 
i += endpoint->extra[i];
}
}
 
static void print_altsetting(const struct libusb_interface_descriptor *interface)
{
uint8_t i;
 
printf("    Interface:\n");
printf("      bInterfaceNumber:      %u\n", interface->bInterfaceNumber);
printf("      bAlternateSetting:     %u\n", interface->bAlternateSetting);
printf("      bNumEndpoints:         %u\n", interface->bNumEndpoints);
printf("      bInterfaceClass:       %u\n", interface->bInterfaceClass);
printf("      bInterfaceSubClass:    %u\n", interface->bInterfaceSubClass);
printf("      bInterfaceProtocol:    %u\n", interface->bInterfaceProtocol);
printf("      iInterface:            %u\n", interface->iInterface);
 
for (i = 0; i < interface->bNumEndpoints; i++)
print_endpoint(&interface->endpoint[i]);
}
 
static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap)
{
printf("    USB 2.0 Extension Capabilities:\n");
printf("      bDevCapabilityType:    %u\n", usb_2_0_ext_cap->bDevCapabilityType);
printf("      bmAttributes:          %08xh\n", usb_2_0_ext_cap->bmAttributes);
}
 
static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap)
{
printf("    USB 3.0 Capabilities:\n");
printf("      bDevCapabilityType:    %u\n", ss_usb_cap->bDevCapabilityType);
printf("      bmAttributes:          %02xh\n", ss_usb_cap->bmAttributes);
printf("      wSpeedSupported:       %u\n", ss_usb_cap->wSpeedSupported);
printf("      bFunctionalitySupport: %u\n", ss_usb_cap->bFunctionalitySupport);
printf("      bU1devExitLat:         %u\n", ss_usb_cap->bU1DevExitLat);
printf("      bU2devExitLat:         %u\n", ss_usb_cap->bU2DevExitLat);
}
 
static void print_bos(libusb_device_handle *handle)
{
struct libusb_bos_descriptor *bos;
uint8_t i;
int ret;
 
ret = libusb_get_bos_descriptor(handle, &bos);
if (ret < 0)
return;
 
printf("  Binary Object Store (BOS):\n");
printf("    wTotalLength:            %u\n", bos->wTotalLength);
printf("    bNumDeviceCaps:          %u\n", bos->bNumDeviceCaps);
 
for (i = 0; i < bos->bNumDeviceCaps; i++) {
struct libusb_bos_dev_capability_descriptor *dev_cap = bos->dev_capability[i];
 
if (dev_cap->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
 
ret = libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_extension);
if (ret < 0)
return;
 
print_2_0_ext_cap(usb_2_0_extension);
libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
} else if (dev_cap->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
struct libusb_ss_usb_device_capability_descriptor *ss_dev_cap;
 
ret = libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_dev_cap);
if (ret < 0)
return;
 
print_ss_usb_cap(ss_dev_cap);
libusb_free_ss_usb_device_capability_descriptor(ss_dev_cap);
}
}
 
libusb_free_bos_descriptor(bos);
}
 
static void print_interface(const struct libusb_interface *interface)
{
int i;
 
for (i = 0; i < interface->num_altsetting; i++)
print_altsetting(&interface->altsetting[i]);
}
 
static void print_configuration(struct libusb_config_descriptor *config)
{
uint8_t i;
 
printf("  Configuration:\n");
printf("    wTotalLength:            %u\n", config->wTotalLength);
printf("    bNumInterfaces:          %u\n", config->bNumInterfaces);
printf("    bConfigurationValue:     %u\n", config->bConfigurationValue);
printf("    iConfiguration:          %u\n", config->iConfiguration);
printf("    bmAttributes:            %02xh\n", config->bmAttributes);
printf("    MaxPower:                %u\n", config->MaxPower);
 
for (i = 0; i < config->bNumInterfaces; i++)
print_interface(&config->interface[i]);
}
 
 
static void print_device(libusb_device *dev, libusb_device_handle *handle, uint16_t vid, uint16_t pid)
{
struct libusb_device_descriptor desc;
unsigned char string[256];
const char *speed;
int ret;
uint8_t i;
 
switch (libusb_get_device_speed(dev)) {
case LIBUSB_SPEED_LOW: speed = "1.5M"; break;
case LIBUSB_SPEED_FULL: speed = "12M"; break;
case LIBUSB_SPEED_HIGH: speed = "480M"; break;
case LIBUSB_SPEED_SUPER: speed = "5G"; break;
case LIBUSB_SPEED_SUPER_PLUS: speed = "10G"; break;
default: speed = "Unknown";
}
 
ret = libusb_get_device_descriptor(dev, &desc);
if (ret < 0) {
fprintf(stderr, "failed to get device descriptor");
return;
}
 

if (!handle)
libusb_open(dev, &handle);
 
if((desc.idVendor == vid) && (desc.idProduct == pid))
{
printf("Dev (bus %u, device %u): %04X - %04X speed: %s\n",
   libusb_get_bus_number(dev), libusb_get_device_address(dev),
   desc.idVendor, desc.idProduct, speed);

 
if (handle)
{
if (desc.iManufacturer) {
ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
if (ret > 0)
printf("  Manufacturer:              %s\n", (char *)string);
}
 
if (desc.iProduct) {
ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
if (ret > 0)
printf("  Product:                   %s\n", (char *)string);
}
 
if (desc.iSerialNumber && verbose) {
ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
if (ret > 0)
printf("  Serial Number:             %s\n", (char *)string);
}

}
 
if (verbose) {
for (i = 0; i < desc.bNumConfigurations; i++) {
struct libusb_config_descriptor *config;
 
ret = libusb_get_config_descriptor(dev, i, &config);
if (LIBUSB_SUCCESS != ret) {
printf("  Couldn't retrieve descriptors\n");
continue;
}
 
print_configuration(config);
 
libusb_free_config_descriptor(config);
}
 
if (handle && desc.bcdUSB >= 0x0201)
print_bos(handle);
}
 
}
 

if(handle)
{
libusb_close(handle);
}
}
 
 
static int test_wrapped_device(const char *device_name, uint16_t vendor_id, uint16_t product_id)
{
libusb_device_handle *handle;
int r, fd;
 
fd = open(device_name, O_RDWR);
if (fd < 0) {
printf("Error could not open %s: %s\n", device_name, strerror(errno));
return 1;
}
r = libusb_wrap_sys_device(NULL, fd, &handle);
if (r) {
printf("Error wrapping device: %s: %s\n", device_name, libusb_strerror(r));
close(fd);
return 1;
}
print_device(libusb_get_device(handle), handle, vendor_id, product_id);
close(fd);
return 0;
}
 
 
 
static void sig_handler(int signum)
{
switch (signum) {
case SIGTERM:
rcv_exit = 1;
break;
case SIGINT:
rcv_exit = 1;
break;
case SIGUSR1:
break;
}
}
 
 
static void usage(char *program)
{
printf("%s - test usb data transfers to/from usb device\n",
program);
printf("Usage:\n");
printf("  %s [options]\n", program);
printf("options are:\n");
printf("Common:\n");
printf("  --help (or -h)\n");
printf("  -v vendor_id\n");
printf("  -p product_id\n");
printf("  -d device name\n");
}
 
static int interrupt_data_rw(uint16_t vendor_id, uint16_t product_id)
{
int kernelDriverDetached = 0;
unsigned char data_in[64]={0};
int length = 0;
int r,j;
libusb_device_handle *handle;
 
handle = libusb_open_device_with_vid_pid(NULL, vendor_id, product_id);
if (handle == NULL) 
{
printf("libusb_open() failed\n");
return -1;;
}
 
 
/*驱动必须解绑定，否则数据由驱动程序处理*/ if(libusb_kernel_driver_active(handle, 0))
{
printf("Kernel Driver Active\n");
r = libusb_detach_kernel_driver(handle, 0);
if (r == 0)
{
printf("Detach Kernel Driver\n");
kernelDriverDetached = 1;
}
else
{
fprintf(stderr, "Error detaching kernel driver.\n");
return -1;;
}
}


  /* 指定当前接口 */
r = libusb_claim_interface(handle, 0);
if (r != 0)
{
fprintf(stderr, "Error claiming interface.\n");
goto exit;
}

 
while(!rcv_exit)
{
memset(data_in, 0, sizeof(data_in));
/*中断方式读取断点数据，
由端点描述符可知端点地址 0x81 为鼠标输入端点
读取长度为5字节，超时时间为1000ms*/
 
r = libusb_interrupt_transfer(handle, 0x81, data_in, 5, &length, 1000);
if ((r < 0) || (length == 0))
{
printf("bulk recive error,r:%d length:%d\n",r,length);
}
else
{
printf("receive data:\n");
for(j=0; j<length; j++)
{
printf("0x%x ",data_in[j]);
}
printf("\n");
}
usleep(500000);
}
 

  /* 释放指定的接口 */
r = libusb_release_interface(handle, 0);
if (0 != r)
{
fprintf(stderr, "Error releasing interface.\n");
}


exit:
if(kernelDriverDetached)
{
//恢复驱动绑定，否则鼠标不可用
    libusb_attach_kernel_driver(handle, 0);
}
 

libusb_close(handle);
return r;

 
}
 
 
int main(int argc, char *argv[])
{
char *program = argv[0];
int option;
const char *device_name = NULL; //"/dev/bus/usb/001/005"
libusb_device **devs;
ssize_t cnt;
int r, i;
uint16_t vid=0, pid=0;
libusb_device_handle *handle = NULL;
 
static const struct option options[] = {
{ "vendid", required_argument, NULL, 'v' },
{ "productid",  required_argument, NULL, 'p' },
{ "devicename",   required_argument, NULL, 'd' },
{ "help",   no_argument, NULL, 'h' },
};
 
/* Parse command line options, if any */
while ((option = getopt_long_only(argc, argv,
"hv:p:d:",options, NULL)))
{
if (option == -1)
break;
switch (option) {
case 'v':
vid = strtoul(optarg, NULL, 0);
break;
case 'p':
pid = strtoul(optarg, NULL, 0);
break;
case 'd':
device_name = optarg;
break;
case 'h':
usage(program);
exit(EXIT_SUCCESS);
break;
default:
printf("ERROR: Invalid command line option\n");
usage(program);
exit(EXIT_FAILURE);
}
}
 
 
printf("vid:0x%x pid:0x%x devicename:%s\n",vid,pid,device_name);
 

 
r = libusb_init(NULL);
if (r < 0)
return r;
 
if (device_name) {
printf("test_wrapped_device\n");
r = test_wrapped_device(device_name,vid,pid);
} else {
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0) {
libusb_exit(NULL);
return 1;
}
 
for (i = 0; devs[i]; i++)
print_device(devs[i], handle,vid,pid);
 
libusb_free_device_list(devs, 1);
}
 
 
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
 
//read mouse data
interrupt_data_rw(vid,pid);
 
libusb_exit(NULL);
return r;
}