Home | History | Annotate | Download | only in libusbhost
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 // #define DEBUG 1
     18 #if DEBUG
     19 
     20 #ifdef USE_LIBLOG
     21 #define LOG_TAG "usbhost"
     22 #include "utils/Log.h"
     23 #define D ALOGD
     24 #else
     25 #define D printf
     26 #endif
     27 
     28 #else
     29 #define D(...)
     30 #endif
     31 
     32 #include <stdio.h>
     33 #include <stdlib.h>
     34 #include <unistd.h>
     35 #include <string.h>
     36 #include <stddef.h>
     37 
     38 #include <sys/ioctl.h>
     39 #include <sys/types.h>
     40 #include <sys/time.h>
     41 #include <sys/inotify.h>
     42 #include <dirent.h>
     43 #include <fcntl.h>
     44 #include <errno.h>
     45 #include <ctype.h>
     46 #include <pthread.h>
     47 
     48 #include <linux/usbdevice_fs.h>
     49 #include <asm/byteorder.h>
     50 
     51 #include "usbhost/usbhost.h"
     52 
     53 #define DEV_DIR             "/dev"
     54 #define DEV_BUS_DIR         DEV_DIR "/bus"
     55 #define USB_FS_DIR          DEV_BUS_DIR "/usb"
     56 #define USB_FS_ID_SCANNER   USB_FS_DIR "/%d/%d"
     57 #define USB_FS_ID_FORMAT    USB_FS_DIR "/%03d/%03d"
     58 
     59 // Some devices fail to send string descriptors if we attempt reading > 255 bytes
     60 #define MAX_STRING_DESCRIPTOR_LENGTH    255
     61 
     62 // From drivers/usb/core/devio.c
     63 // I don't know why this isn't in a kernel header
     64 #define MAX_USBFS_BUFFER_SIZE   16384
     65 
     66 #define MAX_USBFS_WD_COUNT      10
     67 
     68 struct usb_host_context {
     69     int                         fd;
     70     usb_device_added_cb         cb_added;
     71     usb_device_removed_cb       cb_removed;
     72     void                        *data;
     73     int                         wds[MAX_USBFS_WD_COUNT];
     74     int                         wdd;
     75     int                         wddbus;
     76 };
     77 
     78 struct usb_device {
     79     char dev_name[64];
     80     unsigned char desc[4096];
     81     int desc_length;
     82     int fd;
     83     int writeable;
     84 };
     85 
     86 static inline int badname(const char *name)
     87 {
     88     while(*name) {
     89         if(!isdigit(*name++)) return 1;
     90     }
     91     return 0;
     92 }
     93 
     94 static int find_existing_devices_bus(char *busname,
     95                                      usb_device_added_cb added_cb,
     96                                      void *client_data)
     97 {
     98     char devname[32];
     99     DIR *devdir;
    100     struct dirent *de;
    101     int done = 0;
    102 
    103     devdir = opendir(busname);
    104     if(devdir == 0) return 0;
    105 
    106     while ((de = readdir(devdir)) && !done) {
    107         if(badname(de->d_name)) continue;
    108 
    109         snprintf(devname, sizeof(devname), "%s/%s", busname, de->d_name);
    110         done = added_cb(devname, client_data);
    111     } // end of devdir while
    112     closedir(devdir);
    113 
    114     return done;
    115 }
    116 
    117 /* returns true if one of the callbacks indicates we are done */
    118 static int find_existing_devices(usb_device_added_cb added_cb,
    119                                   void *client_data)
    120 {
    121     char busname[32];
    122     DIR *busdir;
    123     struct dirent *de;
    124     int done = 0;
    125 
    126     busdir = opendir(USB_FS_DIR);
    127     if(busdir == 0) return 0;
    128 
    129     while ((de = readdir(busdir)) != 0 && !done) {
    130         if(badname(de->d_name)) continue;
    131 
    132         snprintf(busname, sizeof(busname), USB_FS_DIR "/%s", de->d_name);
    133         done = find_existing_devices_bus(busname, added_cb,
    134                                          client_data);
    135     } //end of busdir while
    136     closedir(busdir);
    137 
    138     return done;
    139 }
    140 
    141 static void watch_existing_subdirs(struct usb_host_context *context,
    142                                    int *wds, int wd_count)
    143 {
    144     char path[100];
    145     int i, ret;
    146 
    147     wds[0] = inotify_add_watch(context->fd, USB_FS_DIR, IN_CREATE | IN_DELETE);
    148     if (wds[0] < 0)
    149         return;
    150 
    151     /* watch existing subdirectories of USB_FS_DIR */
    152     for (i = 1; i < wd_count; i++) {
    153         snprintf(path, sizeof(path), USB_FS_DIR "/%03d", i);
    154         ret = inotify_add_watch(context->fd, path, IN_CREATE | IN_DELETE);
    155         if (ret >= 0)
    156             wds[i] = ret;
    157     }
    158 }
    159 
    160 struct usb_host_context *usb_host_init()
    161 {
    162     struct usb_host_context *context = calloc(1, sizeof(struct usb_host_context));
    163     if (!context) {
    164         fprintf(stderr, "out of memory in usb_host_context\n");
    165         return NULL;
    166     }
    167     context->fd = inotify_init();
    168     if (context->fd < 0) {
    169         fprintf(stderr, "inotify_init failed\n");
    170         free(context);
    171         return NULL;
    172     }
    173     return context;
    174 }
    175 
    176 void usb_host_cleanup(struct usb_host_context *context)
    177 {
    178     close(context->fd);
    179     free(context);
    180 }
    181 
    182 int usb_host_get_fd(struct usb_host_context *context)
    183 {
    184     return context->fd;
    185 } /* usb_host_get_fd() */
    186 
    187 int usb_host_load(struct usb_host_context *context,
    188                   usb_device_added_cb added_cb,
    189                   usb_device_removed_cb removed_cb,
    190                   usb_discovery_done_cb discovery_done_cb,
    191                   void *client_data)
    192 {
    193     int done = 0;
    194     int i;
    195 
    196     context->cb_added = added_cb;
    197     context->cb_removed = removed_cb;
    198     context->data = client_data;
    199 
    200     D("Created device discovery thread\n");
    201 
    202     /* watch for files added and deleted within USB_FS_DIR */
    203     context->wddbus = -1;
    204     for (i = 0; i < MAX_USBFS_WD_COUNT; i++)
    205         context->wds[i] = -1;
    206 
    207     /* watch the root for new subdirectories */
    208     context->wdd = inotify_add_watch(context->fd, DEV_DIR, IN_CREATE | IN_DELETE);
    209     if (context->wdd < 0) {
    210         fprintf(stderr, "inotify_add_watch failed\n");
    211         if (discovery_done_cb)
    212             discovery_done_cb(client_data);
    213         return done;
    214     }
    215 
    216     watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
    217 
    218     /* check for existing devices first, after we have inotify set up */
    219     done = find_existing_devices(added_cb, client_data);
    220     if (discovery_done_cb)
    221         done |= discovery_done_cb(client_data);
    222 
    223     return done;
    224 } /* usb_host_load() */
    225 
    226 int usb_host_read_event(struct usb_host_context *context)
    227 {
    228     struct inotify_event* event;
    229     char event_buf[512];
    230     char path[100];
    231     int i, ret, done = 0;
    232     int offset = 0;
    233     int wd;
    234 
    235     ret = read(context->fd, event_buf, sizeof(event_buf));
    236     if (ret >= (int)sizeof(struct inotify_event)) {
    237         while (offset < ret && !done) {
    238             event = (struct inotify_event*)&event_buf[offset];
    239             done = 0;
    240             wd = event->wd;
    241             if (wd == context->wdd) {
    242                 if ((event->mask & IN_CREATE) && !strcmp(event->name, "bus")) {
    243                     context->wddbus = inotify_add_watch(context->fd, DEV_BUS_DIR, IN_CREATE | IN_DELETE);
    244                     if (context->wddbus < 0) {
    245                         done = 1;
    246                     } else {
    247                         watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
    248                         done = find_existing_devices(context->cb_added, context->data);
    249                     }
    250                 }
    251             } else if (wd == context->wddbus) {
    252                 if ((event->mask & IN_CREATE) && !strcmp(event->name, "usb")) {
    253                     watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT);
    254                     done = find_existing_devices(context->cb_added, context->data);
    255                 } else if ((event->mask & IN_DELETE) && !strcmp(event->name, "usb")) {
    256                     for (i = 0; i < MAX_USBFS_WD_COUNT; i++) {
    257                         if (context->wds[i] >= 0) {
    258                             inotify_rm_watch(context->fd, context->wds[i]);
    259                             context->wds[i] = -1;
    260                         }
    261                     }
    262                 }
    263             } else if (wd == context->wds[0]) {
    264                 i = atoi(event->name);
    265                 snprintf(path, sizeof(path), USB_FS_DIR "/%s", event->name);
    266                 D("%s subdirectory %s: index: %d\n", (event->mask & IN_CREATE) ?
    267                         "new" : "gone", path, i);
    268                 if (i > 0 && i < MAX_USBFS_WD_COUNT) {
    269                     int local_ret = 0;
    270                     if (event->mask & IN_CREATE) {
    271                         local_ret = inotify_add_watch(context->fd, path,
    272                                 IN_CREATE | IN_DELETE);
    273                         if (local_ret >= 0)
    274                             context->wds[i] = local_ret;
    275                         done = find_existing_devices_bus(path, context->cb_added,
    276                                 context->data);
    277                     } else if (event->mask & IN_DELETE) {
    278                         inotify_rm_watch(context->fd, context->wds[i]);
    279                         context->wds[i] = -1;
    280                     }
    281                 }
    282             } else {
    283                 for (i = 1; (i < MAX_USBFS_WD_COUNT) && !done; i++) {
    284                     if (wd == context->wds[i]) {
    285                         snprintf(path, sizeof(path), USB_FS_DIR "/%03d/%s", i, event->name);
    286                         if (event->mask == IN_CREATE) {
    287                             D("new device %s\n", path);
    288                             done = context->cb_added(path, context->data);
    289                         } else if (event->mask == IN_DELETE) {
    290                             D("gone device %s\n", path);
    291                             done = context->cb_removed(path, context->data);
    292                         }
    293                     }
    294                 }
    295             }
    296 
    297             offset += sizeof(struct inotify_event) + event->len;
    298         }
    299     }
    300 
    301     return done;
    302 } /* usb_host_read_event() */
    303 
    304 void usb_host_run(struct usb_host_context *context,
    305                   usb_device_added_cb added_cb,
    306                   usb_device_removed_cb removed_cb,
    307                   usb_discovery_done_cb discovery_done_cb,
    308                   void *client_data)
    309 {
    310     int done;
    311 
    312     done = usb_host_load(context, added_cb, removed_cb, discovery_done_cb, client_data);
    313 
    314     while (!done) {
    315 
    316         done = usb_host_read_event(context);
    317     }
    318 } /* usb_host_run() */
    319 
    320 struct usb_device *usb_device_open(const char *dev_name)
    321 {
    322     int fd, did_retry = 0, writeable = 1;
    323 
    324     D("usb_device_open %s\n", dev_name);
    325 
    326 retry:
    327     fd = open(dev_name, O_RDWR);
    328     if (fd < 0) {
    329         /* if we fail, see if have read-only access */
    330         fd = open(dev_name, O_RDONLY);
    331         D("usb_device_open open returned %d errno %d\n", fd, errno);
    332         if (fd < 0 && (errno == EACCES || errno == ENOENT) && !did_retry) {
    333             /* work around race condition between inotify and permissions management */
    334             sleep(1);
    335             did_retry = 1;
    336             goto retry;
    337         }
    338 
    339         if (fd < 0)
    340             return NULL;
    341         writeable = 0;
    342         D("[ usb open read-only %s fd = %d]\n", dev_name, fd);
    343     }
    344 
    345     struct usb_device* result = usb_device_new(dev_name, fd);
    346     if (result)
    347         result->writeable = writeable;
    348     return result;
    349 }
    350 
    351 void usb_device_close(struct usb_device *device)
    352 {
    353     close(device->fd);
    354     free(device);
    355 }
    356 
    357 struct usb_device *usb_device_new(const char *dev_name, int fd)
    358 {
    359     struct usb_device *device = calloc(1, sizeof(struct usb_device));
    360     int length;
    361 
    362     D("usb_device_new %s fd: %d\n", dev_name, fd);
    363 
    364     if (lseek(fd, 0, SEEK_SET) != 0)
    365         goto failed;
    366     length = read(fd, device->desc, sizeof(device->desc));
    367     D("usb_device_new read returned %d errno %d\n", length, errno);
    368     if (length < 0)
    369         goto failed;
    370 
    371     strncpy(device->dev_name, dev_name, sizeof(device->dev_name) - 1);
    372     device->fd = fd;
    373     device->desc_length = length;
    374     // assume we are writeable, since usb_device_get_fd will only return writeable fds
    375     device->writeable = 1;
    376     return device;
    377 
    378 failed:
    379     close(fd);
    380     free(device);
    381     return NULL;
    382 }
    383 
    384 static int usb_device_reopen_writeable(struct usb_device *device)
    385 {
    386     if (device->writeable)
    387         return 1;
    388 
    389     int fd = open(device->dev_name, O_RDWR);
    390     if (fd >= 0) {
    391         close(device->fd);
    392         device->fd = fd;
    393         device->writeable = 1;
    394         return 1;
    395     }
    396     D("usb_device_reopen_writeable failed errno %d\n", errno);
    397     return 0;
    398 }
    399 
    400 int usb_device_get_fd(struct usb_device *device)
    401 {
    402     if (!usb_device_reopen_writeable(device))
    403         return -1;
    404     return device->fd;
    405 }
    406 
    407 const char* usb_device_get_name(struct usb_device *device)
    408 {
    409     return device->dev_name;
    410 }
    411 
    412 int usb_device_get_unique_id(struct usb_device *device)
    413 {
    414     int bus = 0, dev = 0;
    415     sscanf(device->dev_name, USB_FS_ID_SCANNER, &bus, &dev);
    416     return bus * 1000 + dev;
    417 }
    418 
    419 int usb_device_get_unique_id_from_name(const char* name)
    420 {
    421     int bus = 0, dev = 0;
    422     sscanf(name, USB_FS_ID_SCANNER, &bus, &dev);
    423     return bus * 1000 + dev;
    424 }
    425 
    426 char* usb_device_get_name_from_unique_id(int id)
    427 {
    428     int bus = id / 1000;
    429     int dev = id % 1000;
    430     char* result = (char *)calloc(1, strlen(USB_FS_ID_FORMAT));
    431     snprintf(result, strlen(USB_FS_ID_FORMAT) - 1, USB_FS_ID_FORMAT, bus, dev);
    432     return result;
    433 }
    434 
    435 uint16_t usb_device_get_vendor_id(struct usb_device *device)
    436 {
    437     struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
    438     return __le16_to_cpu(desc->idVendor);
    439 }
    440 
    441 uint16_t usb_device_get_product_id(struct usb_device *device)
    442 {
    443     struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
    444     return __le16_to_cpu(desc->idProduct);
    445 }
    446 
    447 const struct usb_device_descriptor* usb_device_get_device_descriptor(struct usb_device *device)
    448 {
    449     return (struct usb_device_descriptor*)device->desc;
    450 }
    451 
    452 char* usb_device_get_string(struct usb_device *device, int id)
    453 {
    454     char string[256];
    455     __u16 buffer[MAX_STRING_DESCRIPTOR_LENGTH / sizeof(__u16)];
    456     __u16 languages[MAX_STRING_DESCRIPTOR_LENGTH / sizeof(__u16)];
    457     int i, result;
    458     int languageCount = 0;
    459 
    460     if (id == 0) return NULL;
    461 
    462     string[0] = 0;
    463     memset(languages, 0, sizeof(languages));
    464 
    465     // read list of supported languages
    466     result = usb_device_control_transfer(device,
    467             USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
    468             (USB_DT_STRING << 8) | 0, 0, languages, sizeof(languages), 0);
    469     if (result > 0)
    470         languageCount = (result - 2) / 2;
    471 
    472     for (i = 1; i <= languageCount; i++) {
    473         memset(buffer, 0, sizeof(buffer));
    474 
    475         result = usb_device_control_transfer(device,
    476                 USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
    477                 (USB_DT_STRING << 8) | id, languages[i], buffer, sizeof(buffer), 0);
    478         if (result > 0) {
    479             int i;
    480             // skip first word, and copy the rest to the string, changing shorts to bytes.
    481             result /= 2;
    482             for (i = 1; i < result; i++)
    483                 string[i - 1] = buffer[i];
    484             string[i - 1] = 0;
    485             return strdup(string);
    486         }
    487     }
    488 
    489     return NULL;
    490 }
    491 
    492 char* usb_device_get_manufacturer_name(struct usb_device *device)
    493 {
    494     struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
    495     return usb_device_get_string(device, desc->iManufacturer);
    496 }
    497 
    498 char* usb_device_get_product_name(struct usb_device *device)
    499 {
    500     struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
    501     return usb_device_get_string(device, desc->iProduct);
    502 }
    503 
    504 int usb_device_get_version(struct usb_device *device)
    505 {
    506     struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
    507     return desc->bcdUSB;
    508 }
    509 
    510 char* usb_device_get_serial(struct usb_device *device)
    511 {
    512     struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
    513     return usb_device_get_string(device, desc->iSerialNumber);
    514 }
    515 
    516 int usb_device_is_writeable(struct usb_device *device)
    517 {
    518     return device->writeable;
    519 }
    520 
    521 void usb_descriptor_iter_init(struct usb_device *device, struct usb_descriptor_iter *iter)
    522 {
    523     iter->config = device->desc;
    524     iter->config_end = device->desc + device->desc_length;
    525     iter->curr_desc = device->desc;
    526 }
    527 
    528 struct usb_descriptor_header *usb_descriptor_iter_next(struct usb_descriptor_iter *iter)
    529 {
    530     struct usb_descriptor_header* next;
    531     if (iter->curr_desc >= iter->config_end)
    532         return NULL;
    533     next = (struct usb_descriptor_header*)iter->curr_desc;
    534     iter->curr_desc += next->bLength;
    535     return next;
    536 }
    537 
    538 int usb_device_claim_interface(struct usb_device *device, unsigned int interface)
    539 {
    540     return ioctl(device->fd, USBDEVFS_CLAIMINTERFACE, &interface);
    541 }
    542 
    543 int usb_device_release_interface(struct usb_device *device, unsigned int interface)
    544 {
    545     return ioctl(device->fd, USBDEVFS_RELEASEINTERFACE, &interface);
    546 }
    547 
    548 int usb_device_connect_kernel_driver(struct usb_device *device,
    549         unsigned int interface, int connect)
    550 {
    551     struct usbdevfs_ioctl ctl;
    552 
    553     ctl.ifno = interface;
    554     ctl.ioctl_code = (connect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT);
    555     ctl.data = NULL;
    556     return ioctl(device->fd, USBDEVFS_IOCTL, &ctl);
    557 }
    558 
    559 int usb_device_set_configuration(struct usb_device *device, int configuration)
    560 {
    561     return ioctl(device->fd, USBDEVFS_SETCONFIGURATION, &configuration);
    562 }
    563 
    564 int usb_device_set_interface(struct usb_device *device, unsigned int interface,
    565                             unsigned int alt_setting)
    566 {
    567     struct usbdevfs_setinterface ctl;
    568 
    569     ctl.interface = interface;
    570     ctl.altsetting = alt_setting;
    571     return ioctl(device->fd, USBDEVFS_SETINTERFACE, &ctl);
    572 }
    573 
    574 int usb_device_control_transfer(struct usb_device *device,
    575                             int requestType,
    576                             int request,
    577                             int value,
    578                             int index,
    579                             void* buffer,
    580                             int length,
    581                             unsigned int timeout)
    582 {
    583     struct usbdevfs_ctrltransfer  ctrl;
    584 
    585     // this usually requires read/write permission
    586     if (!usb_device_reopen_writeable(device))
    587         return -1;
    588 
    589     memset(&ctrl, 0, sizeof(ctrl));
    590     ctrl.bRequestType = requestType;
    591     ctrl.bRequest = request;
    592     ctrl.wValue = value;
    593     ctrl.wIndex = index;
    594     ctrl.wLength = length;
    595     ctrl.data = buffer;
    596     ctrl.timeout = timeout;
    597     return ioctl(device->fd, USBDEVFS_CONTROL, &ctrl);
    598 }
    599 
    600 int usb_device_bulk_transfer(struct usb_device *device,
    601                             int endpoint,
    602                             void* buffer,
    603                             int length,
    604                             unsigned int timeout)
    605 {
    606     struct usbdevfs_bulktransfer  ctrl;
    607 
    608     // need to limit request size to avoid EINVAL
    609     if (length > MAX_USBFS_BUFFER_SIZE)
    610         length = MAX_USBFS_BUFFER_SIZE;
    611 
    612     memset(&ctrl, 0, sizeof(ctrl));
    613     ctrl.ep = endpoint;
    614     ctrl.len = length;
    615     ctrl.data = buffer;
    616     ctrl.timeout = timeout;
    617     return ioctl(device->fd, USBDEVFS_BULK, &ctrl);
    618 }
    619 
    620 int usb_device_reset(struct usb_device *device)
    621 {
    622     return ioctl(device->fd, USBDEVFS_RESET);
    623 }
    624 
    625 struct usb_request *usb_request_new(struct usb_device *dev,
    626         const struct usb_endpoint_descriptor *ep_desc)
    627 {
    628     struct usbdevfs_urb *urb = calloc(1, sizeof(struct usbdevfs_urb));
    629     if (!urb)
    630         return NULL;
    631 
    632     if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
    633         urb->type = USBDEVFS_URB_TYPE_BULK;
    634     else if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
    635         urb->type = USBDEVFS_URB_TYPE_INTERRUPT;
    636     else {
    637         D("Unsupported endpoint type %d", ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
    638         free(urb);
    639         return NULL;
    640     }
    641     urb->endpoint = ep_desc->bEndpointAddress;
    642 
    643     struct usb_request *req = calloc(1, sizeof(struct usb_request));
    644     if (!req) {
    645         free(urb);
    646         return NULL;
    647     }
    648 
    649     req->dev = dev;
    650     req->max_packet_size = __le16_to_cpu(ep_desc->wMaxPacketSize);
    651     req->private_data = urb;
    652     req->endpoint = urb->endpoint;
    653     urb->usercontext = req;
    654 
    655     return req;
    656 }
    657 
    658 void usb_request_free(struct usb_request *req)
    659 {
    660     free(req->private_data);
    661     free(req);
    662 }
    663 
    664 int usb_request_queue(struct usb_request *req)
    665 {
    666     struct usbdevfs_urb *urb = (struct usbdevfs_urb*)req->private_data;
    667     int res;
    668 
    669     urb->status = -1;
    670     urb->buffer = req->buffer;
    671     // need to limit request size to avoid EINVAL
    672     if (req->buffer_length > MAX_USBFS_BUFFER_SIZE)
    673         urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
    674     else
    675         urb->buffer_length = req->buffer_length;
    676 
    677     do {
    678         res = ioctl(req->dev->fd, USBDEVFS_SUBMITURB, urb);
    679     } while((res < 0) && (errno == EINTR));
    680 
    681     return res;
    682 }
    683 
    684 struct usb_request *usb_request_wait(struct usb_device *dev)
    685 {
    686     struct usbdevfs_urb *urb = NULL;
    687     struct usb_request *req = NULL;
    688 
    689     while (1) {
    690         int res = ioctl(dev->fd, USBDEVFS_REAPURB, &urb);
    691         D("USBDEVFS_REAPURB returned %d\n", res);
    692         if (res < 0) {
    693             if(errno == EINTR) {
    694                 continue;
    695             }
    696             D("[ reap urb - error ]\n");
    697             return NULL;
    698         } else {
    699             D("[ urb @%p status = %d, actual = %d ]\n",
    700                 urb, urb->status, urb->actual_length);
    701             req = (struct usb_request*)urb->usercontext;
    702             req->actual_length = urb->actual_length;
    703         }
    704         break;
    705     }
    706     return req;
    707 }
    708 
    709 int usb_request_cancel(struct usb_request *req)
    710 {
    711     struct usbdevfs_urb *urb = ((struct usbdevfs_urb*)req->private_data);
    712     return ioctl(req->dev->fd, USBDEVFS_DISCARDURB, urb);
    713 }
    714 
    715