usb_linux.c revision a61bcad58ba1f7359183a333ee58303ed67e4a2f 
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/stat.h>
36#include <sys/types.h>
37#include <dirent.h>
38#include <fcntl.h>
39#include <errno.h>
40#include <pthread.h>
41#include <ctype.h>
42
43#include <linux/usbdevice_fs.h>
44#include <linux/usbdevice_fs.h>
45#include <linux/version.h>
46#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
47#include <linux/usb/ch9.h>
48#else
49#include <linux/usb_ch9.h>
50#endif
51#include <asm/byteorder.h>
52
53#include "usb.h"
54
55#define MAX_RETRIES 5
56
57#ifdef TRACE_USB
58#define DBG1(x...) fprintf(stderr, x)
59#define DBG(x...) fprintf(stderr, x)
60#else
61#define DBG(x...)
62#define DBG1(x...)
63#endif
64
65/* The max bulk size for linux is 16384 which is defined
66 * in drivers/usb/core/devio.c.
67 */
68#define MAX_USBFS_BULK_SIZE (16 * 1024)
69
70struct usb_handle
71{
72    char fname[64];
73    int desc;
74    unsigned char ep_in;
75    unsigned char ep_out;
76};
77
78static inline int badname(const char *name)
79{
80    while(*name) {
81        if(!isdigit(*name++)) return 1;
82    }
83    return 0;
84}
85
86static int check(void *_desc, int len, unsigned type, int size)
87{
88    unsigned char *desc = _desc;
89
90    if(len < size) return -1;
91    if(desc[0] < size) return -1;
92    if(desc[0] > len) return -1;
93    if(desc[1] != type) return -1;
94
95    return 0;
96}
97
98static int filter_usb_device(int fd, char *ptr, int len, int writable,
99                             ifc_match_func callback,
100                             int *ept_in_id, int *ept_out_id, int *ifc_id)
101{
102    struct usb_device_descriptor *dev;
103    struct usb_config_descriptor *cfg;
104    struct usb_interface_descriptor *ifc;
105    struct usb_endpoint_descriptor *ept;
106    struct usb_ifc_info info;
107
108    int in, out;
109    unsigned i;
110    unsigned e;
111
112    struct stat st;
113    int result;
114
115    if(check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
116        return -1;
117    dev = (void*) ptr;
118    len -= dev->bLength;
119    ptr += dev->bLength;
120
121    if(check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
122        return -1;
123    cfg = (void*) ptr;
124    len -= cfg->bLength;
125    ptr += cfg->bLength;
126
127    info.dev_vendor = dev->idVendor;
128    info.dev_product = dev->idProduct;
129    info.dev_class = dev->bDeviceClass;
130    info.dev_subclass = dev->bDeviceSubClass;
131    info.dev_protocol = dev->bDeviceProtocol;
132    info.writable = writable;
133
134    // read device serial number (if there is one)
135    info.serial_number[0] = 0;
136    if (dev->iSerialNumber) {
137        struct usbdevfs_ctrltransfer  ctrl;
138        // Keep it short enough because some bootloaders are borked if the URB len is > 255
139        // 128 is too big by 1.
140        __u16 buffer[127];
141
142        memset(buffer, 0, sizeof(buffer));
143
144        ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE;
145        ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
146        ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber;
147        //language ID (en-us) for serial number string
148        ctrl.wIndex = 0x0409;
149        ctrl.wLength = sizeof(buffer);
150        ctrl.data = buffer;
151        ctrl.timeout = 50;
152
153        result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
154        if (result > 0) {
155            int i;
156            // skip first word, and copy the rest to the serial string, changing shorts to bytes.
157            result /= 2;
158            for (i = 1; i < result; i++)
159                info.serial_number[i - 1] = buffer[i];
160            info.serial_number[i - 1] = 0;
161        }
162    }
163
164    /* We need to get a path that represents a particular port on a particular
165     * hub.  We are passed an fd that was obtained by opening an entry under
166     * /dev/bus/usb.  Unfortunately, the names of those entries change each
167     * time devices are plugged and unplugged.  So how to get a repeatable
168     * path?  udevadm provided the inspiration.  We can get the major and
169     * minor of the device file, read the symlink that can be found here:
170     *   /sys/dev/char/<major>:<minor>
171     * and then use the last element of that path.  As a concrete example, I
172     * have an Android device at /dev/bus/usb/001/027 so working with bash:
173     *   $ ls -l /dev/bus/usb/001/027
174     *   crw-rw-r-- 1 root plugdev 189, 26 Apr  9 11:03 /dev/bus/usb/001/027
175     *   $ ls -l /sys/dev/char/189:26
176     *   lrwxrwxrwx 1 root root 0 Apr  9 11:03 /sys/dev/char/189:26 ->
177     *           ../../devices/pci0000:00/0000:00:1a.7/usb1/1-4/1-4.2/1-4.2.3
178     * So our device_path would be 1-4.2.3 which says my device is connected
179     * to port 3 of a hub on port 2 of a hub on port 4 of bus 1 (per
180     * http://www.linux-usb.org/FAQ.html).
181     */
182    info.device_path[0] = '\0';
183    result = fstat(fd, &st);
184    if (!result && S_ISCHR(st.st_mode)) {
185        char cdev[128];
186        char link[256];
187        char *slash;
188        ssize_t link_len;
189        snprintf(cdev, sizeof(cdev), "/sys/dev/char/%d:%d",
190                 major(st.st_rdev), minor(st.st_rdev));
191        link_len = readlink(cdev, link, sizeof(link) - 1);
192        if (link_len > 0) {
193            link[link_len] = '\0';
194            slash = strrchr(link, '/');
195            if (slash)
196                snprintf(info.device_path, sizeof(info.device_path), "usb:%s", slash+1);
197        }
198    }
199
200    for(i = 0; i < cfg->bNumInterfaces; i++) {
201        if(check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE))
202            return -1;
203        ifc = (void*) ptr;
204        len -= ifc->bLength;
205        ptr += ifc->bLength;
206
207        in = -1;
208        out = -1;
209        info.ifc_class = ifc->bInterfaceClass;
210        info.ifc_subclass = ifc->bInterfaceSubClass;
211        info.ifc_protocol = ifc->bInterfaceProtocol;
212
213        for(e = 0; e < ifc->bNumEndpoints; e++) {
214            if(check(ptr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE))
215                return -1;
216            ept = (void*) ptr;
217            len -= ept->bLength;
218            ptr += ept->bLength;
219
220            if((ept->bmAttributes & 0x03) != 0x02)
221                continue;
222
223            if(ept->bEndpointAddress & 0x80) {
224                in = ept->bEndpointAddress;
225            } else {
226                out = ept->bEndpointAddress;
227            }
228        }
229
230        info.has_bulk_in = (in != -1);
231        info.has_bulk_out = (out != -1);
232
233        if(callback(&info) == 0) {
234            *ept_in_id = in;
235            *ept_out_id = out;
236            *ifc_id = ifc->bInterfaceNumber;
237            return 0;
238        }
239    }
240
241    return -1;
242}
243
244static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
245{
246    usb_handle *usb = 0;
247    char busname[64], devname[64];
248    char desc[1024];
249    int n, in, out, ifc;
250
251    DIR *busdir, *devdir;
252    struct dirent *de;
253    int fd;
254    int writable;
255
256    busdir = opendir(base);
257    if(busdir == 0) return 0;
258
259    while((de = readdir(busdir)) && (usb == 0)) {
260        if(badname(de->d_name)) continue;
261
262        sprintf(busname, "%s/%s", base, de->d_name);
263        devdir = opendir(busname);
264        if(devdir == 0) continue;
265
266//        DBG("[ scanning %s ]\n", busname);
267        while((de = readdir(devdir)) && (usb == 0)) {
268
269            if(badname(de->d_name)) continue;
270            sprintf(devname, "%s/%s", busname, de->d_name);
271
272//            DBG("[ scanning %s ]\n", devname);
273            writable = 1;
274            if((fd = open(devname, O_RDWR)) < 0) {
275                // Check if we have read-only access, so we can give a helpful
276                // diagnostic like "adb devices" does.
277                writable = 0;
278                if((fd = open(devname, O_RDONLY)) < 0) {
279                    continue;
280                }
281            }
282
283            n = read(fd, desc, sizeof(desc));
284
285            if(filter_usb_device(fd, desc, n, writable, callback,
286                                 &in, &out, &ifc) == 0) {
287                usb = calloc(1, sizeof(usb_handle));
288                strcpy(usb->fname, devname);
289                usb->ep_in = in;
290                usb->ep_out = out;
291                usb->desc = fd;
292
293                n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
294                if(n != 0) {
295                    close(fd);
296                    free(usb);
297                    usb = 0;
298                    continue;
299                }
300            } else {
301                close(fd);
302            }
303        }
304        closedir(devdir);
305    }
306    closedir(busdir);
307
308    return usb;
309}
310
311int usb_write(usb_handle *h, const void *_data, int len)
312{
313    unsigned char *data = (unsigned char*) _data;
314    unsigned count = 0;
315    struct usbdevfs_bulktransfer bulk;
316    int n;
317
318    if(h->ep_out == 0) {
319        return -1;
320    }
321
322    if(len == 0) {
323        bulk.ep = h->ep_out;
324        bulk.len = 0;
325        bulk.data = data;
326        bulk.timeout = 0;
327
328        n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
329        if(n != 0) {
330            fprintf(stderr,"ERROR: n = %d, errno = %d (%s)\n",
331                    n, errno, strerror(errno));
332            return -1;
333        }
334        return 0;
335    }
336
337    while(len > 0) {
338        int xfer;
339        xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
340
341        bulk.ep = h->ep_out;
342        bulk.len = xfer;
343        bulk.data = data;
344        bulk.timeout = 0;
345
346        n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
347        if(n != xfer) {
348            DBG("ERROR: n = %d, errno = %d (%s)\n",
349                n, errno, strerror(errno));
350            return -1;
351        }
352
353        count += xfer;
354        len -= xfer;
355        data += xfer;
356    }
357
358    return count;
359}
360
361int usb_read(usb_handle *h, void *_data, int len)
362{
363    unsigned char *data = (unsigned char*) _data;
364    unsigned count = 0;
365    struct usbdevfs_bulktransfer bulk;
366    int n, retry;
367
368    if(h->ep_in == 0) {
369        return -1;
370    }
371
372    while(len > 0) {
373        int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
374
375        bulk.ep = h->ep_in;
376        bulk.len = xfer;
377        bulk.data = data;
378        bulk.timeout = 0;
379        retry = 0;
380
381        do{
382           DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
383           n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
384           DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
385
386           if( n < 0 ) {
387            DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
388            if ( ++retry > MAX_RETRIES ) return -1;
389            sleep( 1 );
390           }
391        }
392        while( n < 0 );
393
394        count += n;
395        len -= n;
396        data += n;
397
398        if(n < xfer) {
399            break;
400        }
401    }
402
403    return count;
404}
405
406void usb_kick(usb_handle *h)
407{
408    int fd;
409
410    fd = h->desc;
411    h->desc = -1;
412    if(fd >= 0) {
413        close(fd);
414        DBG("[ usb closed %d ]\n", fd);
415    }
416}
417
418int usb_close(usb_handle *h)
419{
420    int fd;
421
422    fd = h->desc;
423    h->desc = -1;
424    if(fd >= 0) {
425        close(fd);
426        DBG("[ usb closed %d ]\n", fd);
427    }
428
429    return 0;
430}
431
432usb_handle *usb_open(ifc_match_func callback)
433{
434    return find_usb_device("/dev/bus/usb", callback);
435}
436