usb_linux.c revision f8ff3a5ae21ce34f22928709cc6f992ff2fdd56e 
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/* The max bulk size for linux is 16384 which is defined
65 * in drivers/usb/core/devio.c.
66 */
67#define MAX_USBFS_BULK_SIZE (16 * 1024)
68
69struct usb_handle
70{
71    char fname[64];
72    int desc;
73    unsigned char ep_in;
74    unsigned char ep_out;
75};
76
77static inline int badname(const char *name)
78{
79    while(*name) {
80        if(!isdigit(*name++)) return 1;
81    }
82    return 0;
83}
84
85static int check(void *_desc, int len, unsigned type, int size)
86{
87    unsigned char *desc = _desc;
88
89    if(len < size) return -1;
90    if(desc[0] < size) return -1;
91    if(desc[0] > len) return -1;
92    if(desc[1] != type) return -1;
93
94    return 0;
95}
96
97static int filter_usb_device(int fd, char *ptr, int len, int writable,
98                             ifc_match_func callback,
99                             int *ept_in_id, int *ept_out_id, int *ifc_id)
100{
101    struct usb_device_descriptor *dev;
102    struct usb_config_descriptor *cfg;
103    struct usb_interface_descriptor *ifc;
104    struct usb_endpoint_descriptor *ept;
105    struct usb_ifc_info info;
106
107    int in, out;
108    unsigned i;
109    unsigned e;
110
111    if(check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
112        return -1;
113    dev = (void*) ptr;
114    len -= dev->bLength;
115    ptr += dev->bLength;
116
117    if(check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
118        return -1;
119    cfg = (void*) ptr;
120    len -= cfg->bLength;
121    ptr += cfg->bLength;
122
123    info.dev_vendor = dev->idVendor;
124    info.dev_product = dev->idProduct;
125    info.dev_class = dev->bDeviceClass;
126    info.dev_subclass = dev->bDeviceSubClass;
127    info.dev_protocol = dev->bDeviceProtocol;
128    info.writable = writable;
129
130    // read device serial number (if there is one)
131    info.serial_number[0] = 0;
132    if (dev->iSerialNumber) {
133        struct usbdevfs_ctrltransfer  ctrl;
134        // Keep it short enough because some bootloaders are borked if the URB len is > 255
135        // 128 is too big by 1.
136        __u16 buffer[127];
137        int result;
138
139        memset(buffer, 0, sizeof(buffer));
140
141        ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE;
142        ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
143        ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber;
144        //language ID (en-us) for serial number string
145        ctrl.wIndex = 0x0409;
146        ctrl.wLength = sizeof(buffer);
147        ctrl.data = buffer;
148        ctrl.timeout = 50;
149
150        result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
151        if (result > 0) {
152            int i;
153            // skip first word, and copy the rest to the serial string, changing shorts to bytes.
154            result /= 2;
155            for (i = 1; i < result; i++)
156                info.serial_number[i - 1] = buffer[i];
157            info.serial_number[i - 1] = 0;
158        }
159    }
160
161    for(i = 0; i < cfg->bNumInterfaces; i++) {
162        if(check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE))
163            return -1;
164        ifc = (void*) ptr;
165        len -= ifc->bLength;
166        ptr += ifc->bLength;
167
168        in = -1;
169        out = -1;
170        info.ifc_class = ifc->bInterfaceClass;
171        info.ifc_subclass = ifc->bInterfaceSubClass;
172        info.ifc_protocol = ifc->bInterfaceProtocol;
173
174        for(e = 0; e < ifc->bNumEndpoints; e++) {
175            if(check(ptr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE))
176                return -1;
177            ept = (void*) ptr;
178            len -= ept->bLength;
179            ptr += ept->bLength;
180
181            if((ept->bmAttributes & 0x03) != 0x02)
182                continue;
183
184            if(ept->bEndpointAddress & 0x80) {
185                in = ept->bEndpointAddress;
186            } else {
187                out = ept->bEndpointAddress;
188            }
189        }
190
191        info.has_bulk_in = (in != -1);
192        info.has_bulk_out = (out != -1);
193
194        if(callback(&info) == 0) {
195            *ept_in_id = in;
196            *ept_out_id = out;
197            *ifc_id = ifc->bInterfaceNumber;
198            return 0;
199        }
200    }
201
202    return -1;
203}
204
205static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
206{
207    usb_handle *usb = 0;
208    char busname[64], devname[64];
209    char desc[1024];
210    int n, in, out, ifc;
211
212    DIR *busdir, *devdir;
213    struct dirent *de;
214    int fd;
215    int writable;
216
217    busdir = opendir(base);
218    if(busdir == 0) return 0;
219
220    while((de = readdir(busdir)) && (usb == 0)) {
221        if(badname(de->d_name)) continue;
222
223        sprintf(busname, "%s/%s", base, de->d_name);
224        devdir = opendir(busname);
225        if(devdir == 0) continue;
226
227//        DBG("[ scanning %s ]\n", busname);
228        while((de = readdir(devdir)) && (usb == 0)) {
229
230            if(badname(de->d_name)) continue;
231            sprintf(devname, "%s/%s", busname, de->d_name);
232
233//            DBG("[ scanning %s ]\n", devname);
234            writable = 1;
235            if((fd = open(devname, O_RDWR)) < 0) {
236                // Check if we have read-only access, so we can give a helpful
237                // diagnostic like "adb devices" does.
238                writable = 0;
239                if((fd = open(devname, O_RDONLY)) < 0) {
240                    continue;
241                }
242            }
243
244            n = read(fd, desc, sizeof(desc));
245
246            if(filter_usb_device(fd, desc, n, writable, callback,
247                                 &in, &out, &ifc) == 0) {
248                usb = calloc(1, sizeof(usb_handle));
249                strcpy(usb->fname, devname);
250                usb->ep_in = in;
251                usb->ep_out = out;
252                usb->desc = fd;
253
254                n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
255                if(n != 0) {
256                    close(fd);
257                    free(usb);
258                    usb = 0;
259                    continue;
260                }
261            } else {
262                close(fd);
263            }
264        }
265        closedir(devdir);
266    }
267    closedir(busdir);
268
269    return usb;
270}
271
272int usb_write(usb_handle *h, const void *_data, int len)
273{
274    unsigned char *data = (unsigned char*) _data;
275    unsigned count = 0;
276    struct usbdevfs_bulktransfer bulk;
277    int n;
278
279    if(h->ep_out == 0) {
280        return -1;
281    }
282
283    if(len == 0) {
284        bulk.ep = h->ep_out;
285        bulk.len = 0;
286        bulk.data = data;
287        bulk.timeout = 0;
288
289        n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
290        if(n != 0) {
291            fprintf(stderr,"ERROR: n = %d, errno = %d (%s)\n",
292                    n, errno, strerror(errno));
293            return -1;
294        }
295        return 0;
296    }
297
298    while(len > 0) {
299        int xfer;
300        xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
301
302        bulk.ep = h->ep_out;
303        bulk.len = xfer;
304        bulk.data = data;
305        bulk.timeout = 0;
306
307        n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
308        if(n != xfer) {
309            DBG("ERROR: n = %d, errno = %d (%s)\n",
310                n, errno, strerror(errno));
311            return -1;
312        }
313
314        count += xfer;
315        len -= xfer;
316        data += xfer;
317    }
318
319    return count;
320}
321
322int usb_read(usb_handle *h, void *_data, int len)
323{
324    unsigned char *data = (unsigned char*) _data;
325    unsigned count = 0;
326    struct usbdevfs_bulktransfer bulk;
327    int n, retry;
328
329    if(h->ep_in == 0) {
330        return -1;
331    }
332
333    while(len > 0) {
334        int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
335
336        bulk.ep = h->ep_in;
337        bulk.len = xfer;
338        bulk.data = data;
339        bulk.timeout = 0;
340        retry = 0;
341
342        do{
343           DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
344           n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
345           DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
346
347           if( n < 0 ) {
348            DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
349            if ( ++retry > MAX_RETRIES ) return -1;
350            sleep( 1 );
351           }
352        }
353        while( n < 0 );
354
355        count += n;
356        len -= n;
357        data += n;
358
359        if(n < xfer) {
360            break;
361        }
362    }
363
364    return count;
365}
366
367void usb_kick(usb_handle *h)
368{
369    int fd;
370
371    fd = h->desc;
372    h->desc = -1;
373    if(fd >= 0) {
374        close(fd);
375        DBG("[ usb closed %d ]\n", fd);
376    }
377}
378
379int usb_close(usb_handle *h)
380{
381    int fd;
382
383    fd = h->desc;
384    h->desc = -1;
385    if(fd >= 0) {
386        close(fd);
387        DBG("[ usb closed %d ]\n", fd);
388    }
389
390    return 0;
391}
392
393usb_handle *usb_open(ifc_match_func callback)
394{
395    return find_usb_device("/dev/bus/usb", callback);
396}
397