7

我正在尝试使用 libusb1.0.9 实现用户空间 USB 驱动程序。我有 lpc2148 蓝板（ARM7）。这个板由 Bertrik Sikken 先生加载了开源 USB 堆栈/固件。现在我的用户空间驱动程序正在尝试用板读写。我正在获取垃圾数据。我想了解大宗转账的流程。对于任何传输/事务是否涉及内核设备驱动程序？我们还需要usb gadget设备驱动程序吗？我无法理解数据被复制的位置。重要的是，当我产生读/写中断时，我可以在 LCD 上看到正确的数据。我需要读/写 USBRxData/USBTxData 吗？请做必要的事。

我尝试了以下代码进行批量传输读写..

int usb_read(struct libusb_device *dev,struct libusb_device_handle *hDevice)  
{  
    char *data,*data1;  
    struct  libusb_endpoint_descriptor *ep;     
    struct  libusb_interface_descriptor *id;  
    int len=64,r,ret_alt,ret_clm,ret_rst,i;  
    struct libusb_device **list;  

    data = (char *)malloc(512); //allocation  of buffers  
    data1 = (char *)malloc(512);  
    memset(data,'\0',512);  
    memset(data1,'\0',512);  

    if(hDevice==NULL)  
    {  
        printf("\nNO device found\n");  
        return 0;  
    }  
    int ret_open = libusb_open(dev,&hDevice);  
    if(ret_open!=0)  
    {  
        printf("Error in libusb_open\n");  
        libusb_free_device_list(list,1);  
        return -1;  
    }       
    char str_tx[512]="G";    //data to send to device  
    char str_rx[512];        //receive string   
    data = str_tx;  

    printf("data::%s\t,str::%s\n",data,str_tx);  
    //printf("%c\n",data);  
    ep = active_config(dev,hDevice);  
    printf("after ep\n");  
    //printf("alt_interface = %d\n",alt_interface);  
    ret_rst = libusb_reset_device(hDevice);  
    if(ret_rst < 0)  
    {  
        printf("Error in reset :: %d",ret_rst);  
        return -1;  
    }  
    printf("original data1 : %s\n",data1);  
    r = libusb_bulk_transfer(hDevice,0x08,str_tx,512,&len,0);  
    //write to device buffer from data  

    printf("Error number :: %d\n",r);  
    int le = ep->bEndpointAddress;  
    int ty = ep->bDescriptorType;  
    int y = ep->bmAttributes;  

    printf("y::%d\tatt:: %d\n",y,ep->bmAttributes);  
    if(r==-1)  
        printf("Error in io\n");  
    if(r==0)  
    {  
        printf("data returned :: %s\n",data);  
        printf("len= %d\n",len);  
        printf("Device Button Pressed!!!!\n");  
    }  
    else  
    {  
        printf("Error in bulk transfer\n");  
        return -1;  
    }  

    r = libusb_bulk_transfer(hDevice,0x82,data1,512,&len,0);   
    //read from device buffer to data1  
    //str_rx = data1;  
    //printf("End point address::%d\n",le);  
    //printf("End point desc.type::%d\n",ty);  
    if(r==-1)  
        printf("Error in io\n");  
    if(r==0)  
    {  
        printf("data1 returned::%s\n",data1);   //received string in data1  
        printf("len= %d\n",len);  
        printf("Device Button Pressed!!!!\n");  
    }  
    else  
    {  
        printf("Error in bulk transfer\n");  
        return -1;  
    }  


    return 0;  
}
4

2 回答 2

7

试试下面给出的代码，它应该可以在 lpc2148 上运行。我已经使用配置为在写入发生（来自用户空间）并且 RTC 开始运行后从 USB 接收中断的 lpc2148 对此进行了测试。

回答您的问题是否涉及读/写内核驱动程序，据我研究，您必须分离内核驱动程序并使用 libusb API 声明接口。虽然我不确定它是否可以在不分离的情况下完成。

#include <stdio.h>    
#include <stdlib.h>    
#include <sys/types.h>    
#include <string.h>    
#include </usr/local/include/libusb-1.0/libusb.h>    


#define BULK_EP_OUT     0x82    
#define BULK_EP_IN      0x08    

int interface_ref = 0;    
int alt_interface,interface_number;    

int print_configuration(struct libusb_device_handle *hDevice,struct libusb_config_descriptor *config)    
{    
    char *data;    
    int index;    

    data = (char *)malloc(512);    
    memset(data,0,512);    

    index = config->iConfiguration;    

    libusb_get_string_descriptor_ascii(hDevice,index,data,512);    

    printf("\nInterface Descriptors: ");    
    printf("\n\tNumber of Interfaces : %d",config->bNumInterfaces);    
    printf("\n\tLength : %d",config->bLength);    
    printf("\n\tDesc_Type : %d",config->bDescriptorType);    
    printf("\n\tConfig_index : %d",config->iConfiguration);    
    printf("\n\tTotal length : %lu",config->wTotalLength);    
    printf("\n\tConfiguration Value  : %d",config->bConfigurationValue);    
    printf("\n\tConfiguration Attributes : %d",config->bmAttributes);    
    printf("\n\tMaxPower(mA) : %d\n",config->MaxPower);    

    free(data);    
    data = NULL;    
    return 0;    
}    

struct libusb_endpoint_descriptor* active_config(struct libusb_device *dev,struct libusb_device_handle *handle)    
{    
    struct libusb_device_handle *hDevice_req;    
    struct libusb_config_descriptor *config;    
    struct libusb_endpoint_descriptor *endpoint;    
    int altsetting_index,interface_index=0,ret_active;    
    int i,ret_print;    

    hDevice_req = handle;    

    ret_active = libusb_get_active_config_descriptor(dev,&config);    
    ret_print = print_configuration(hDevice_req,config);    

    for(interface_index=0;interface_index<config->bNumInterfaces;interface_index++)    
    {    
        const struct libusb_interface *iface = &config->interface[interface_index];    
        for(altsetting_index=0;altsetting_index<iface->num_altsetting;altsetting_index++)    
        {    
            const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_index];    

            int endpoint_index;    
            for(endpoint_index=0;endpoint_index<altsetting->bNumEndpoints;endpoint_index++)    
            {    
                const struct libusb_endpoint_desriptor *ep = &altsetting->endpoint[endpoint_index];    
                endpoint = ep;      
                alt_interface = altsetting->bAlternateSetting;    
                interface_number = altsetting->bInterfaceNumber;    
            }    

            printf("\nEndPoint Descriptors: ");    
            printf("\n\tSize of EndPoint Descriptor : %d",endpoint->bLength);    
            printf("\n\tType of Descriptor : %d",endpoint->bDescriptorType);    
            printf("\n\tEndpoint Address : 0x0%x",endpoint->bEndpointAddress);    
            printf("\n\tMaximum Packet Size: %x",endpoint->wMaxPacketSize);    
            printf("\n\tAttributes applied to Endpoint: %d",endpoint->bmAttributes);    
            printf("\n\tInterval for Polling for data Tranfer : %d\n",endpoint->bInterval);    
        }    
    }    
    libusb_free_config_descriptor(NULL);    
    return endpoint;    
}    

int main(void)    
{    
    int r = 1;    
    struct libusb_device **devs;    
    struct libusb_device_handle *handle = NULL, *hDevice_expected = NULL;    
    struct libusb_device *dev,*dev_expected;    

    struct libusb_device_descriptor desc;    
    struct libusb_endpoint_descriptor *epdesc;    
    struct libusb_interface_descriptor *intdesc;    

    ssize_t cnt;    
    int e = 0,config2;    
    int i = 0,index;    
    char str1[64], str2[64];    
    char found = 0;    

// Init libusb     
    r = libusb_init(NULL);    
    if(r < 0)    
    {    
        printf("\nfailed to initialise libusb\n");    
        return 1;    
    }    
    else    
        printf("\nInit Successful!\n");    

// Get a list os USB devices    
    cnt = libusb_get_device_list(NULL, &devs);    
    if (cnt < 0)    
    {    
        printf("\nThere are no USB devices on bus\n");    
        return -1;    
    }    
    printf("\nDevice Count : %d\n-------------------------------\n",cnt);    

    while ((dev = devs[i++]) != NULL)    
    {    
        r = libusb_get_device_descriptor(dev, &desc);    
        if (r < 0)    
            {    
            printf("failed to get device descriptor\n");    
            libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            break;    
        }    

        e = libusb_open(dev,&handle);    
        if (e < 0)    
        {    
            printf("error opening device\n");    
            libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            break;    
        }    

        printf("\nDevice Descriptors: ");    
        printf("\n\tVendor ID : %x",desc.idVendor);    
        printf("\n\tProduct ID : %x",desc.idProduct);    
        printf("\n\tSerial Number : %x",desc.iSerialNumber);    
        printf("\n\tSize of Device Descriptor : %d",desc.bLength);    
        printf("\n\tType of Descriptor : %d",desc.bDescriptorType);    
        printf("\n\tUSB Specification Release Number : %d",desc.bcdUSB);    
        printf("\n\tDevice Release Number : %d",desc.bcdDevice);    
        printf("\n\tDevice Class : %d",desc.bDeviceClass);    
        printf("\n\tDevice Sub-Class : %d",desc.bDeviceSubClass);    
        printf("\n\tDevice Protocol : %d",desc.bDeviceProtocol);    
        printf("\n\tMax. Packet Size : %d",desc.bMaxPacketSize0);    
        printf("\n\tNo. of Configuraions : %d\n",desc.bNumConfigurations);    

        e = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, (unsigned char*) str1, sizeof(str1));    
        if (e < 0)    
        {    
        libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            break;    
        }    
        printf("\nManufactured : %s",str1);    

        e = libusb_get_string_descriptor_ascii(handle, desc.iProduct, (unsigned char*) str2, sizeof(str2));    
        if(e < 0)    
        {    
        libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            break;    
        }    
        printf("\nProduct : %s",str2);    
        printf("\n----------------------------------------");    

        if(desc.idVendor == 0xffff && desc.idProduct == 0x4)    
        {    
        found = 1;    
        break;    
        }    
    }//end of while    
    if(found == 0)    
    {    
        printf("\nDevice NOT found\n");    
        libusb_free_device_list(devs,1);    
        libusb_close(handle);    
        return 1;    
    }    
    else    
    {    
        printf("\nDevice found");    
        dev_expected = dev;    
        hDevice_expected = handle;    
    }    

    e = libusb_get_configuration(handle,&config2);    
    if(e!=0)    
    {    
        printf("\n***Error in libusb_get_configuration\n");    
        libusb_free_device_list(devs,1);    
        libusb_close(handle);    
        return -1;    
    }    
    printf("\nConfigured value : %d",config2);    

    if(config2 != 1)    
    {    
        libusb_set_configuration(handle, 1);    
        if(e!=0)    
        {    
            printf("Error in libusb_set_configuration\n");    
            libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            return -1;    
        }    
        else    
            printf("\nDevice is in configured state!");    
    }    

    libusb_free_device_list(devs, 1);    

    if(libusb_kernel_driver_active(handle, 0) == 1)    
    {    
        printf("\nKernel Driver Active");    
        if(libusb_detach_kernel_driver(handle, 0) == 0)    
            printf("\nKernel Driver Detached!");    
        else    
        {    
            printf("\nCouldn't detach kernel driver!\n");    
            libusb_free_device_list(devs,1);    
            libusb_close(handle);    
            return -1;    
        }    
    }    

    e = libusb_claim_interface(handle, 0);    
    if(e < 0)    
    {    
        printf("\nCannot Claim Interface");    
        libusb_free_device_list(devs,1);    
        libusb_close(handle);    
        return -1;    
    }    
    else    
        printf("\nClaimed Interface\n");    

    active_config(dev_expected,hDevice_expected);    

    //   Communicate     

    char *my_string, *my_string1;    
    int transferred = 0;    
    int received = 0;    
    int length = 0;    

    my_string = (char *)malloc(nbytes + 1);    
    my_string1 = (char *)malloc(nbytes + 1);    

    memset(my_string,'\0',64);    
    memset(my_string1,'\0',64);    

    strcpy(my_string,"prasad divesd");    
    length = strlen(my_string);    

    printf("\nTo be sent : %s",my_string);    

    e = libusb_bulk_transfer(handle,BULK_EP_IN,my_string,length,&transferred,0);    
    if(e == 0 && transferred == length)    
    {    
        printf("\nWrite successful!");    
        printf("\nSent %d bytes with string: %s\n", transferred, my_string);    
    }    
    else    
        printf("\nError in write! e = %d and transferred = %d\n",e,transferred);    

    sleep(3);    
    i = 0;    

    for(i = 0; i < length; i++)    
    {    
        e = libusb_bulk_transfer(handle,BULK_EP_OUT,my_string1,64,&received,0);  //64 : Max Packet Lenght    
        if(e == 0)    
        {    
            printf("\nReceived: ");    
            printf("%c",my_string1[i]);    //will read a string from lcp2148
            sleep(1);    
        }    
        else    
        {    
            printf("\nError in read! e = %d and received = %d\n",e,received);    
            return -1;    
        }    
    }    


    e = libusb_release_interface(handle, 0);    

    libusb_close(handle);    
    libusb_exit(NULL);    

    printf("\n");    
    return 0;    
}
于 2013-02-10T14:30:26.400 回答
0

处理内核分离。

if(libusb_kernel_driver_active(dev_handle, 0) == 1)         //find out if kernel driver is attached
{
    cout << "Kernel Driver Active" << endl;

    if(libusb_detach_kernel_driver(dev_handle, 0) == 0)     //detach it
    {
        cout << "Kernel Driver Detached!" << endl;
    }
}
于 2015-12-28T18:37:56.770 回答