Home | History | Annotate | Download | only in fastboot 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  * All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  *  * Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  *  * Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in
     12  *    the documentation and/or other materials provided with the
     13  *    distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
     19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
     22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
     25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <stdio.h>
     30 #include <stdlib.h>
     31 #include <unistd.h>
     32 #include <string.h>
     33 
     34 #include <sys/ioctl.h>
     35 #include <sys/types.h>
     36 #include <dirent.h>
     37 #include <fcntl.h>
     38 #include <errno.h>
     39 #include <pthread.h>
     40 #include <ctype.h>
     41 
     42 #include <linux/usbdevice_fs.h>
     43 #include <linux/usbdevice_fs.h>
     44 #include <linux/version.h>
     45 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
     46 #include <linux/usb/ch9.h>
     47 #else
     48 #include <linux/usb_ch9.h>
     49 #endif
     50 #include <asm/byteorder.h>
     51 
     52 #include "usb.h"
     53 
     54 #define MAX_RETRIES 5
     55 
     56 #ifdef TRACE_USB
     57 #define DBG1(x...) fprintf(stderr, x)
     58 #define DBG(x...) fprintf(stderr, x)
     59 #else
     60 #define DBG(x...)
     61 #define DBG1(x...)
     62 #endif
     63 
     64 struct usb_handle
     65 {
     66     char fname[64];
     67     int desc;
     68     unsigned char ep_in;
     69     unsigned char ep_out;
     70 };
     71 
     72 static inline int badname(const char *name)
     73 {
     74     while(*name) {
     75         if(!isdigit(*name++)) return 1;
     76     }
     77     return 0;
     78 }
     79 
     80 static int check(void *_desc, int len, unsigned type, int size)
     81 {
     82     unsigned char *desc = _desc;
     83 
     84     if(len < size) return -1;
     85     if(desc[0] < size) return -1;
     86     if(desc[0] > len) return -1;
     87     if(desc[1] != type) return -1;
     88 
     89     return 0;
     90 }
     91 
     92 static int filter_usb_device(int fd, char *ptr, int len, int writable,
     93                              ifc_match_func callback,
     94                              int *ept_in_id, int *ept_out_id, int *ifc_id)
     95 {
     96     struct usb_device_descriptor *dev;
     97     struct usb_config_descriptor *cfg;
     98     struct usb_interface_descriptor *ifc;
     99     struct usb_endpoint_descriptor *ept;
    100     struct usb_ifc_info info;
    101 
    102     int in, out;
    103     unsigned i;
    104     unsigned e;
    105 
    106     if(check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
    107         return -1;
    108     dev = (void*) ptr;
    109     len -= dev->bLength;
    110     ptr += dev->bLength;
    111 
    112     if(check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
    113         return -1;
    114     cfg = (void*) ptr;
    115     len -= cfg->bLength;
    116     ptr += cfg->bLength;
    117 
    118     info.dev_vendor = dev->idVendor;
    119     info.dev_product = dev->idProduct;
    120     info.dev_class = dev->bDeviceClass;
    121     info.dev_subclass = dev->bDeviceSubClass;
    122     info.dev_protocol = dev->bDeviceProtocol;
    123     info.writable = writable;
    124 
    125     // read device serial number (if there is one)
    126     info.serial_number[0] = 0;
    127     if (dev->iSerialNumber) {
    128         struct usbdevfs_ctrltransfer  ctrl;
    129         __u16 buffer[128];
    130         int result;
    131 
    132         memset(buffer, 0, sizeof(buffer));
    133 
    134         ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE;
    135         ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
    136         ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber;
    137         ctrl.wIndex = 0;
    138         ctrl.wLength = sizeof(buffer);
    139         ctrl.data = buffer;
    140 	ctrl.timeout = 50;
    141 
    142         result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
    143         if (result > 0) {
    144             int i;
    145             // skip first word, and copy the rest to the serial string, changing shorts to bytes.
    146             result /= 2;
    147             for (i = 1; i < result; i++)
    148                 info.serial_number[i - 1] = buffer[i];
    149             info.serial_number[i - 1] = 0;
    150         }
    151     }
    152 
    153     for(i = 0; i < cfg->bNumInterfaces; i++) {
    154         if(check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE))
    155             return -1;
    156         ifc = (void*) ptr;
    157         len -= ifc->bLength;
    158         ptr += ifc->bLength;
    159 
    160         in = -1;
    161         out = -1;
    162         info.ifc_class = ifc->bInterfaceClass;
    163         info.ifc_subclass = ifc->bInterfaceSubClass;
    164         info.ifc_protocol = ifc->bInterfaceProtocol;
    165 
    166         for(e = 0; e < ifc->bNumEndpoints; e++) {
    167             if(check(ptr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE))
    168                 return -1;
    169             ept = (void*) ptr;
    170             len -= ept->bLength;
    171             ptr += ept->bLength;
    172 
    173             if((ept->bmAttributes & 0x03) != 0x02)
    174                 continue;
    175 
    176             if(ept->bEndpointAddress & 0x80) {
    177                 in = ept->bEndpointAddress;
    178             } else {
    179                 out = ept->bEndpointAddress;
    180             }
    181         }
    182 
    183         info.has_bulk_in = (in != -1);
    184         info.has_bulk_out = (out != -1);
    185 
    186         if(callback(&info) == 0) {
    187             *ept_in_id = in;
    188             *ept_out_id = out;
    189             *ifc_id = ifc->bInterfaceNumber;
    190             return 0;
    191         }
    192     }
    193 
    194     return -1;
    195 }
    196 
    197 static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
    198 {
    199     usb_handle *usb = 0;
    200     char busname[64], devname[64];
    201     char desc[1024];
    202     int n, in, out, ifc;
    203 
    204     DIR *busdir, *devdir;
    205     struct dirent *de;
    206     int fd;
    207     int writable;
    208 
    209     busdir = opendir(base);
    210     if(busdir == 0) return 0;
    211 
    212     while((de = readdir(busdir)) && (usb == 0)) {
    213         if(badname(de->d_name)) continue;
    214 
    215         sprintf(busname, "%s/%s", base, de->d_name);
    216         devdir = opendir(busname);
    217         if(devdir == 0) continue;
    218 
    219 //        DBG("[ scanning %s ]\n", busname);
    220         while((de = readdir(devdir)) && (usb == 0)) {
    221 
    222             if(badname(de->d_name)) continue;
    223             sprintf(devname, "%s/%s", busname, de->d_name);
    224 
    225 //            DBG("[ scanning %s ]\n", devname);
    226             writable = 1;
    227             if((fd = open(devname, O_RDWR)) < 0) {
    228                 // Check if we have read-only access, so we can give a helpful
    229                 // diagnostic like "adb devices" does.
    230                 writable = 0;
    231                 if((fd = open(devname, O_RDONLY)) < 0) {
    232                     continue;
    233                 }
    234             }
    235 
    236             n = read(fd, desc, sizeof(desc));
    237 
    238             if(filter_usb_device(fd, desc, n, writable, callback,
    239                                  &in, &out, &ifc) == 0) {
    240                 usb = calloc(1, sizeof(usb_handle));
    241                 strcpy(usb->fname, devname);
    242                 usb->ep_in = in;
    243                 usb->ep_out = out;
    244                 usb->desc = fd;
    245 
    246                 n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
    247                 if(n != 0) {
    248                     close(fd);
    249                     free(usb);
    250                     usb = 0;
    251                     continue;
    252                 }
    253             } else {
    254                 close(fd);
    255             }
    256         }
    257         closedir(devdir);
    258     }
    259     closedir(busdir);
    260 
    261     return usb;
    262 }
    263 
    264 int usb_write(usb_handle *h, const void *_data, int len)
    265 {
    266     unsigned char *data = (unsigned char*) _data;
    267     unsigned count = 0;
    268     struct usbdevfs_bulktransfer bulk;
    269     int n;
    270 
    271     if(h->ep_out == 0) {
    272         return -1;
    273     }
    274 
    275     if(len == 0) {
    276         bulk.ep = h->ep_out;
    277         bulk.len = 0;
    278         bulk.data = data;
    279         bulk.timeout = 0;
    280 
    281         n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
    282         if(n != 0) {
    283             fprintf(stderr,"ERROR: n = %d, errno = %d (%s)\n",
    284                     n, errno, strerror(errno));
    285             return -1;
    286         }
    287         return 0;
    288     }
    289 
    290     while(len > 0) {
    291         int xfer;
    292         xfer = (len > 4096) ? 4096 : len;
    293 
    294         bulk.ep = h->ep_out;
    295         bulk.len = xfer;
    296         bulk.data = data;
    297         bulk.timeout = 0;
    298 
    299         n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
    300         if(n != xfer) {
    301             DBG("ERROR: n = %d, errno = %d (%s)\n",
    302                 n, errno, strerror(errno));
    303             return -1;
    304         }
    305 
    306         count += xfer;
    307         len -= xfer;
    308         data += xfer;
    309     }
    310 
    311     return count;
    312 }
    313 
    314 int usb_read(usb_handle *h, void *_data, int len)
    315 {
    316     unsigned char *data = (unsigned char*) _data;
    317     unsigned count = 0;
    318     struct usbdevfs_bulktransfer bulk;
    319     int n, retry;
    320 
    321     if(h->ep_in == 0) {
    322         return -1;
    323     }
    324 
    325     while(len > 0) {
    326         int xfer = (len > 4096) ? 4096 : len;
    327 
    328         bulk.ep = h->ep_in;
    329         bulk.len = xfer;
    330         bulk.data = data;
    331         bulk.timeout = 0;
    332         retry = 0;
    333 
    334         do{
    335            DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
    336            n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
    337            DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
    338 
    339            if( n < 0 ) {
    340             DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
    341             if ( ++retry > MAX_RETRIES ) return -1;
    342             sleep( 1 );
    343            }
    344         }
    345         while( n < 0 );
    346 
    347         count += n;
    348         len -= n;
    349         data += n;
    350 
    351         if(n < xfer) {
    352             break;
    353         }
    354     }
    355 
    356     return count;
    357 }
    358 
    359 void usb_kick(usb_handle *h)
    360 {
    361     int fd;
    362 
    363     fd = h->desc;
    364     h->desc = -1;
    365     if(fd >= 0) {
    366         close(fd);
    367         DBG("[ usb closed %d ]\n", fd);
    368     }
    369 }
    370 
    371 int usb_close(usb_handle *h)
    372 {
    373     int fd;
    374 
    375     fd = h->desc;
    376     h->desc = -1;
    377     if(fd >= 0) {
    378         close(fd);
    379         DBG("[ usb closed %d ]\n", fd);
    380     }
    381 
    382     return 0;
    383 }
    384 
    385 usb_handle *usb_open(ifc_match_func callback)
    386 {
    387     return find_usb_device("/dev/bus/usb", callback);
    388 }
    389