Bulk transfer libusb

Question

Bulk transfer libusb

I am trying to implement a usb user space driver using libusb1.0.9. I have a lpc2148 panel (ARM7) with me. This board is loaded using Mr. Bertrick Sikken's open source USB stack / firmware. Now my user space driver is trying to read the record using the board. I get garbage data. I want to know about the flow of volumetric transport. Is there a kernel device driver for any transfer / transaction? and do we need a gadget device usb driver? I cannot figure out where the data is being copied. The important thing is that when I read / write an interrupt, it is generated, and I can see the correct data on the LCD. Do I need to read / write USBRxData / USBTxData? Please do the necessary.

I tried the read and write code for bulk translation below.

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;  
}

+5

bulk libusb

swappy Feb 08 '13 at 9:10

source share

2 answers

To handle detachment of the kernel.

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;
    }
}

0

axon Dec 28 '15 at 18:37

source share

user2045557 · Accepted Answer · 2013-02-10T14:30:26+0000

Try the code below and it should work on lpc2148. I tested this with lpc2148 configured to receive a USB interrupt after recording a record (from user space) and starting RTC.

Answering your question whether it includes the kernel driver in read / write or not, as far as I have learned, you need to separate the kernel driver and require an interface using the libusb API. Although I'm not sure if this can be done without taking it off or not.

#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;    
}

Bulk transfer libusb

More articles: