libusb를 사용하여 펜 드라이브에서 읽기/쓰기 : libusb_bulk_transfer()

Question

pen drive에서 읽기 및 쓰기 작업을 수행하려고합니다.

세부 정보 : 공급 업체 ID : 8564 및 제품 ID : 1000. Transcend JetFlash 대용량 저장 장치입니다.

필자는 펜 드라이브에서 읽기/쓰기가 가능한지 여부를 알고 싶어합니다. 그렇다면 아래 제공된 코드에서 시도한 방식대로 진행됩니다.

나는 디바이스 ID, 제품 ID 및 엔드 포인트 주소를 얻는 방법을 배웠다. 이것이 내가 구현 한 것입니다.

여기 장치가 인식되고 열립니다. 그리고 인터페이스조차도 성공이라고 주장합니다.

하지만 대량 전달 함수는 -1을 반환합니다.

설명은 무엇입니까?

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

#define BULK_EP_OUT  0x82 
#define BULK_EP_IN  0x02 

int main(void) 
{ 
    int r = 0, e = 0; 
    struct libusb_device_handle *handle = NULL; 
    struct libusb_device **devs; 
    struct libusb_device *dev; 
    struct libusb_device_descriptor desc; 
    char str1[256], str2[256]; 

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

    handle = libusb_open_device_with_vid_pid(NULL, 0x8564, 0x1000); 
    if(handle == NULL) 
    { 
     printf("\nError in device opening!"); 
    } 
    else 
     printf("\nDevice Opened"); 

    // Tell libusb to use the CONFIGNUM configuration of the device 

    libusb_set_configuration(handle, 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!"); 
    } 

    e = libusb_claim_interface(handle, 0); 
    if(e < 0) 
    { 
     printf("\nCannot Claim Interface"); 
    } 
    else 
     printf("\nClaimed Interface"); 

     /* Communicate */ 

    int bytes_read; 
    int nbytes = 256; 
    unsigned char *my_string, *my_string1; 
    int transferred = 0; 
    my_string = (unsigned char *) malloc (nbytes + 1); 
    my_string1 = (unsigned char *) malloc (nbytes + 1); 

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

    e = libusb_bulk_transfer(handle, BULK_EP_OUT, my_string, bytes_read, &transferred, 5000); 
    printf("\nXfer returned with %d", e); 
    printf("\nSent %d bytes with string: %s\n", transferred, my_string); 

    libusb_bulk_transfer(handle, BULK_EP_IN, my_string1, 256, &transferred, 5000); 
    printf("\nXfer returned with %d", e);  //It returns -1... This is an error, I guess. 
    printf("\nReceived %d bytes with string: %s\n", transferred, my_string1); 

    e = libusb_release_interface(handle, 0); 
    libusb_close(handle); 
    libusb_exit(NULL); 
    return 0; 
} 

Answer 1

아래 코드를 시도하면 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 of USB devices 
    cnt = libusb_get_device_list(NULL, &devs); 
    if (cnt < 0) 
    { 
     printf("\nThere are no USB devices on the 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\tNumber of Configurations: %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 Length 
     if(e == 0) 
     { 
      printf("\nReceived: "); 
      printf("%c", my_string1[i]); //Will read a string from LPC2148 
      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; 
}