libusb 解析描述符

static void dump_altsetting(libusb_device_handle *dev, const struct libusb_interface_descriptor *interface)
{
//	char cls[128], subcls[128], proto[128];
//	char *ifstr;
 
//	get_class_string(cls, sizeof(cls), interface->bInterfaceClass);
//	get_subclass_string(subcls, sizeof(subcls), interface->bInterfaceClass, interface->bInterfaceSubClass);
//	get_protocol_string(proto, sizeof(proto), interface->bInterfaceClass, interface->bInterfaceSubClass, interface->bInterfaceProtocol);
//	ifstr = get_dev_string(dev, interface->iInterface);
 
	printf("    Interface Descriptor:\n"
	       "      bLength             %5u\n"
	       "      bDescriptorType     %5u\n"
	       "      bInterfaceNumber    %5u\n"
	       "      bAlternateSetting   %5u\n"
	       "      bNumEndpoints       %5u\n"
	       "      bInterfaceClass     %5u\n"
	       "      bInterfaceSubClass  %5u\n"
	       "      bInterfaceProtocol  %5u\n",
	       interface->bLength, interface->bDescriptorType, interface->bInterfaceNumber,
	       interface->bAlternateSetting, interface->bNumEndpoints, interface->bInterfaceClass,
	       interface->bInterfaceSubClass,interface->bInterfaceProtocol);
 
//	free(ifstr);
}
 
static void dump_interface(libusb_device_handle *dev, const struct libusb_interface *interface)
{
	int i;
 
	for (i = 0; i < interface->num_altsetting; i++)
		dump_altsetting(dev, &interface->altsetting[i]);
}

static int parserDescriptor(libusb_device *dev)
{
	struct libusb_device_descriptor desc;
	struct libusb_config_descriptor* conf;
    libusb_device_handle* handle;
 
	int config = 0;
	int ret;
 
	int status;
	ssize_t num_devs, i, j, k;

		libusb_open(dev,&handle);
 
		libusb_get_configuration(handle,&config);
 
 		uint8_t bnum = libusb_get_bus_number(dev);
		uint8_t dnum = libusb_get_device_address(dev);
 
		libusb_get_device_descriptor(dev, &desc);
		status = 0;
		printf("device:%04x:%04x\n",desc.idVendor,desc.idProduct);
		printf("bDeviceSubClass = %5u\n",desc.bDeviceSubClass);
		printf("bDeviceClass    = %5u\n",desc.bDeviceClass);
		printf("bDeviceProtocol    = %5u\n",desc.bDeviceProtocol);
		printf("bNumConfigurations    = %5u\n",desc.bNumConfigurations);
		for( j = 0; j < desc.bNumConfigurations; ++j) {
                        ret = libusb_get_config_descriptor(dev, j, &conf);
                        if (ret) {
                                fprintf(stderr, "    Couldn't get configuration "
                                                "descriptor %lu, some information will "
                                                "be missing\n", j);
                        } else {
				printf("    bNumberInterfaces = %5u\n",conf->bNumInterfaces);
				printf("    bConfigurationValue = %5u\n",conf->bConfigurationValue);
				
				for (k = 0 ; k < conf->bNumInterfaces ; k++)
					dump_interface(handle, &conf->interface[k]);
                                libusb_free_config_descriptor(conf);
                        }
                }
		
    libusb_close(handle);
}

init()
{
    bool res = false;
    int ret = 0;
    int count = 0;

    libusb_device** devs = NULL;

retry:
    if (NULL != devs)
    {
        libusb_free_device_list(devs, 1);
        devs = NULL;
    }

    libusbExit();
    libusbInit();

//    if (count++ >= INIT_RETRY_COUNT_MAX)
//    {
//        LOGD("------accessory exit");
//        return false;
//    }

    int size = libusb_get_device_list(mContext, &devs);
    //printf("usb device list size = %d\n", size);

    if (size < 0)
    {
        devs = NULL;
        goto retry;
    }

    for (int i = 0; i < size; i++)
    {
        libusb_device_descriptor desc;
        ret = libusb_get_device_descriptor(devs[i], &desc);


        if (LIBUSB_SUCCESS == ret)
        {
                parserDescriptor(devs[i]);
        }
        else
        {
            LOGW("Failed to libusb_get_device_descriptor %d", ret);

            sleep(1);

            goto retry;
        }
    }

    if (NULL != devs)
    {
        libusb_free_device_list(devs, 1);
        devs = NULL;
    }

    if (!res)
    {
        sleep(1);
        goto retry;
    }

    return res;
}


int libusbInit()
{
    int ret = 0;
    if (NULL == mContext)
    {
        ret = libusb_init(&mContext);
        if (ret != LIBUSB_SUCCESS)
        {
            LOGE("Failed to initialize libusb\n");
        }

        //libusb_set_debug(mContext, LIBUSB_LOG_LEVEL_DEBUG); // Verbose USB debug output
    }

    return ret;
}

void libusbExit()
{
    if (NULL != mContext)
    {
        libusb_exit(mContext);
        mContext = NULL;
    }
}