usb_linux.c revision 4f6e8d7a00cbeda1e70cc15be9c4af1018bdad53 
1/*
2 * Copyright (C) 2007 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#include <stdio.h>
18#include <stdlib.h>
19#include <unistd.h>
20#include <string.h>
21
22#include <sys/ioctl.h>
23#include <sys/types.h>
24#include <dirent.h>
25#include <fcntl.h>
26#include <errno.h>
27#include <ctype.h>
28
29#include <linux/usbdevice_fs.h>
30#include <linux/version.h>
31#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
32#include <linux/usb/ch9.h>
33#else
34#include <linux/usb_ch9.h>
35#endif
36#include <asm/byteorder.h>
37
38#include "sysdeps.h"
39
40#define   TRACE_TAG  TRACE_USB
41#include "adb.h"
42
43
44/* usb scan debugging is waaaay too verbose */
45#define DBGX(x...)
46
47static adb_mutex_t usb_lock = ADB_MUTEX_INITIALIZER;
48
49struct usb_handle
50{
51    usb_handle *prev;
52    usb_handle *next;
53
54    char fname[64];
55    int desc;
56    unsigned char ep_in;
57    unsigned char ep_out;
58
59    unsigned zero_mask;
60
61    struct usbdevfs_urb urb_in;
62    struct usbdevfs_urb urb_out;
63
64    int urb_in_busy;
65    int urb_out_busy;
66    int dead;
67
68    adb_cond_t notify;
69    adb_mutex_t lock;
70
71    // for garbage collecting disconnected devices
72    int mark;
73
74    // ID of thread currently in REAPURB
75    pthread_t reaper_thread;
76};
77
78static usb_handle handle_list = {
79    .prev = &handle_list,
80    .next = &handle_list,
81};
82
83static int known_device(const char *dev_name)
84{
85    usb_handle *usb;
86
87    adb_mutex_lock(&usb_lock);
88    for(usb = handle_list.next; usb != &handle_list; usb = usb->next){
89        if(!strcmp(usb->fname, dev_name)) {
90            // set mark flag to indicate this device is still alive
91            usb->mark = 1;
92            adb_mutex_unlock(&usb_lock);
93            return 1;
94        }
95    }
96    adb_mutex_unlock(&usb_lock);
97    return 0;
98}
99
100static void kick_disconnected_devices()
101{
102    usb_handle *usb;
103
104    adb_mutex_lock(&usb_lock);
105    // kick any devices in the device list that were not found in the device scan
106    for(usb = handle_list.next; usb != &handle_list; usb = usb->next){
107        if (usb->mark == 0) {
108            usb_kick(usb);
109        } else {
110            usb->mark = 0;
111        }
112    }
113    adb_mutex_unlock(&usb_lock);
114
115}
116
117static void register_device(const char *dev_name, unsigned char ep_in, unsigned char ep_out,
118                            int ifc, const char *serial, unsigned zero_mask);
119
120static inline int badname(const char *name)
121{
122    while(*name) {
123        if(!isdigit(*name++)) return 1;
124    }
125    return 0;
126}
127
128static int find_usb_device(const char *base,
129                           void (*register_device_callback) (const char *, unsigned char, unsigned char, int, const char *, unsigned))
130{
131    char busname[32], devname[32];
132    unsigned char local_ep_in, local_ep_out;
133    DIR *busdir , *devdir ;
134    struct dirent *de;
135    int fd ;
136    int found_device = 0;
137    char serial[256];
138
139    busdir = opendir(base);
140    if(busdir == 0) return 0;
141
142    while((de = readdir(busdir)) != 0) {
143        if(badname(de->d_name)) continue;
144
145        snprintf(busname, sizeof busname, "%s/%s", base, de->d_name);
146        devdir = opendir(busname);
147        if(devdir == 0) continue;
148
149//        DBGX("[ scanning %s ]\n", busname);
150        while((de = readdir(devdir))) {
151            unsigned char devdesc[256];
152            unsigned char* bufptr = devdesc;
153            struct usb_device_descriptor* device;
154            struct usb_config_descriptor* config;
155            struct usb_interface_descriptor* interface;
156            struct usb_endpoint_descriptor *ep1, *ep2;
157            unsigned zero_mask = 0;
158            unsigned vid, pid;
159            int i, interfaces;
160            size_t desclength;
161
162            if(badname(de->d_name)) continue;
163            snprintf(devname, sizeof devname, "%s/%s", busname, de->d_name);
164
165            if(known_device(devname)) {
166                DBGX("skipping %s\n", devname);
167                continue;
168            }
169
170//            DBGX("[ scanning %s ]\n", devname);
171            if((fd = unix_open(devname, O_RDWR)) < 0) {
172                continue;
173            }
174
175            desclength = adb_read(fd, devdesc, sizeof(devdesc));
176
177                // should have device and configuration descriptors, and atleast two endpoints
178            if (desclength < USB_DT_DEVICE_SIZE + USB_DT_CONFIG_SIZE) {
179                D("desclength %d is too small\n", desclength);
180                adb_close(fd);
181                continue;
182            }
183
184            device = (struct usb_device_descriptor*)bufptr;
185            bufptr += USB_DT_DEVICE_SIZE;
186
187            if((device->bLength != USB_DT_DEVICE_SIZE) || (device->bDescriptorType != USB_DT_DEVICE)) {
188                adb_close(fd);
189                continue;
190            }
191
192            vid = __le16_to_cpu(device->idVendor);
193            pid = __le16_to_cpu(device->idProduct);
194            pid = devdesc[10] | (devdesc[11] << 8);
195            DBGX("[ %s is V:%04x P:%04x ]\n", devname, vid, pid);
196
197                // should have config descriptor next
198            config = (struct usb_config_descriptor *)bufptr;
199            bufptr += USB_DT_CONFIG_SIZE;
200            if (config->bLength != USB_DT_CONFIG_SIZE || config->bDescriptorType != USB_DT_CONFIG) {
201                D("usb_config_descriptor not found\n");
202                adb_close(fd);
203                continue;
204            }
205
206                // loop through all the interfaces and look for the ADB interface
207            interfaces = config->bNumInterfaces;
208            for (i = 0; i < interfaces; i++) {
209                if (bufptr + USB_DT_ENDPOINT_SIZE > devdesc + desclength)
210                    break;
211
212                interface = (struct usb_interface_descriptor *)bufptr;
213                bufptr += USB_DT_INTERFACE_SIZE;
214                if (interface->bLength != USB_DT_INTERFACE_SIZE ||
215                    interface->bDescriptorType != USB_DT_INTERFACE) {
216                    D("usb_interface_descriptor not found\n");
217                    break;
218                }
219
220                DBGX("bInterfaceClass: %d,  bInterfaceSubClass: %d,"
221                     "bInterfaceProtocol: %d, bNumEndpoints: %d\n",
222                     interface->bInterfaceClass, interface->bInterfaceSubClass,
223                     interface->bInterfaceProtocol, interface->bNumEndpoints);
224
225                if (interface->bNumEndpoints == 2 &&
226                        is_adb_interface(vid, pid, interface->bInterfaceClass,
227                        interface->bInterfaceSubClass, interface->bInterfaceProtocol))  {
228
229                    DBGX("looking for bulk endpoints\n");
230                        // looks like ADB...
231                    ep1 = (struct usb_endpoint_descriptor *)bufptr;
232                    bufptr += USB_DT_ENDPOINT_SIZE;
233                    ep2 = (struct usb_endpoint_descriptor *)bufptr;
234                    bufptr += USB_DT_ENDPOINT_SIZE;
235
236                    if (bufptr > devdesc + desclength ||
237                        ep1->bLength != USB_DT_ENDPOINT_SIZE ||
238                        ep1->bDescriptorType != USB_DT_ENDPOINT ||
239                        ep2->bLength != USB_DT_ENDPOINT_SIZE ||
240                        ep2->bDescriptorType != USB_DT_ENDPOINT) {
241                        D("endpoints not found\n");
242                        break;
243                    }
244
245                        // both endpoints should be bulk
246                    if (ep1->bmAttributes != USB_ENDPOINT_XFER_BULK ||
247                        ep2->bmAttributes != USB_ENDPOINT_XFER_BULK) {
248                        D("bulk endpoints not found\n");
249                        continue;
250                    }
251
252                        /* aproto 01 needs 0 termination */
253                    if(interface->bInterfaceProtocol == 0x01) {
254                        zero_mask = ep1->wMaxPacketSize - 1;
255                    }
256
257                        // we have a match.  now we just need to figure out which is in and which is out.
258                    if (ep1->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
259                        local_ep_in = ep1->bEndpointAddress;
260                        local_ep_out = ep2->bEndpointAddress;
261                    } else {
262                        local_ep_in = ep2->bEndpointAddress;
263                        local_ep_out = ep1->bEndpointAddress;
264                    }
265
266                        // read the device's serial number
267                    serial[0] = 0;
268                    memset(serial, 0, sizeof(serial));
269                    if (device->iSerialNumber) {
270                        struct usbdevfs_ctrltransfer  ctrl;
271                        __u16 buffer[128];
272                        int result;
273
274                        memset(buffer, 0, sizeof(buffer));
275                        memset(&ctrl, 0, sizeof(ctrl));
276
277                        ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE;
278                        ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
279                        ctrl.wValue = (USB_DT_STRING << 8) | device->iSerialNumber;
280                        ctrl.wIndex = 0;
281                        ctrl.wLength = sizeof(buffer);
282                        ctrl.data = buffer;
283
284                        result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
285                        if (result > 0) {
286                            int i;
287                                // skip first word, and copy the rest to the serial string, changing shorts to bytes.
288                            result /= 2;
289                            for (i = 1; i < result; i++)
290                                serial[i - 1] = buffer[i];
291                            serial[i - 1] = 0;
292                        }
293                    }
294
295                    register_device_callback(devname, local_ep_in, local_ep_out, i, serial, zero_mask);
296
297                    found_device = 1;
298                    break;
299                } else {
300                        // skip to next interface
301                    bufptr += (interface->bNumEndpoints * USB_DT_ENDPOINT_SIZE);
302                }
303            } // end of for
304
305            adb_close(fd);
306        } // end of devdir while
307        closedir(devdir);
308    } //end of busdir while
309    closedir(busdir);
310
311    return found_device;
312}
313
314void usb_cleanup()
315{
316}
317
318static int usb_bulk_write(usb_handle *h, const void *data, int len)
319{
320    struct usbdevfs_urb *urb = &h->urb_out;
321    int res;
322
323    memset(urb, 0, sizeof(*urb));
324    urb->type = USBDEVFS_URB_TYPE_BULK;
325    urb->endpoint = h->ep_out;
326    urb->status = -1;
327    urb->buffer = (void*) data;
328    urb->buffer_length = len;
329
330    D("++ write ++\n");
331
332    adb_mutex_lock(&h->lock);
333    if(h->dead) {
334        res = -1;
335        goto fail;
336    }
337    do {
338        res = ioctl(h->desc, USBDEVFS_SUBMITURB, urb);
339    } while((res < 0) && (errno == EINTR));
340
341    if(res < 0) {
342        goto fail;
343    }
344
345    res = -1;
346    h->urb_out_busy = 1;
347    for(;;) {
348        adb_cond_wait(&h->notify, &h->lock);
349        if(h->dead) {
350            break;
351        }
352        if(h->urb_out_busy == 0) {
353            if(urb->status == 0) {
354                res = urb->actual_length;
355            }
356            break;
357        }
358    }
359fail:
360    adb_mutex_unlock(&h->lock);
361    D("-- write --\n");
362    return res;
363}
364
365static int usb_bulk_read(usb_handle *h, void *data, int len)
366{
367    struct usbdevfs_urb *urb = &h->urb_in;
368    struct usbdevfs_urb *out = NULL;
369    int res;
370
371    memset(urb, 0, sizeof(*urb));
372    urb->type = USBDEVFS_URB_TYPE_BULK;
373    urb->endpoint = h->ep_in;
374    urb->status = -1;
375    urb->buffer = data;
376    urb->buffer_length = len;
377
378
379    adb_mutex_lock(&h->lock);
380    if(h->dead) {
381        res = -1;
382        goto fail;
383    }
384    do {
385        res = ioctl(h->desc, USBDEVFS_SUBMITURB, urb);
386    } while((res < 0) && (errno == EINTR));
387
388    if(res < 0) {
389        goto fail;
390    }
391
392    h->urb_in_busy = 1;
393    for(;;) {
394        D("[ reap urb - wait ]\n");
395        h->reaper_thread = pthread_self();
396        adb_mutex_unlock(&h->lock);
397        res = ioctl(h->desc, USBDEVFS_REAPURB, &out);
398        adb_mutex_lock(&h->lock);
399        h->reaper_thread = 0;
400        if(h->dead) {
401            res = -1;
402            break;
403        }
404        if(res < 0) {
405            if(errno == EINTR) {
406                continue;
407            }
408            D("[ reap urb - error ]\n");
409            break;
410        }
411        D("[ urb @%p status = %d, actual = %d ]\n",
412            out, out->status, out->actual_length);
413
414        if(out == &h->urb_in) {
415            D("[ reap urb - IN complete ]\n");
416            h->urb_in_busy = 0;
417            if(urb->status == 0) {
418                res = urb->actual_length;
419            } else {
420                res = -1;
421            }
422            break;
423        }
424        if(out == &h->urb_out) {
425            D("[ reap urb - OUT compelete ]\n");
426            h->urb_out_busy = 0;
427            adb_cond_broadcast(&h->notify);
428        }
429    }
430fail:
431    adb_mutex_unlock(&h->lock);
432    return res;
433}
434
435
436int usb_write(usb_handle *h, const void *_data, int len)
437{
438    unsigned char *data = (unsigned char*) _data;
439    int n;
440    int need_zero = 0;
441
442    if(h->zero_mask) {
443            /* if we need 0-markers and our transfer
444            ** is an even multiple of the packet size,
445            ** we make note of it
446            */
447        if(!(len & h->zero_mask)) {
448            need_zero = 1;
449        }
450    }
451
452    while(len > 0) {
453        int xfer = (len > 4096) ? 4096 : len;
454
455        n = usb_bulk_write(h, data, xfer);
456        if(n != xfer) {
457            D("ERROR: n = %d, errno = %d (%s)\n",
458                n, errno, strerror(errno));
459            return -1;
460        }
461
462        len -= xfer;
463        data += xfer;
464    }
465
466    if(need_zero){
467        n = usb_bulk_write(h, _data, 0);
468        return n;
469    }
470
471    return 0;
472}
473
474int usb_read(usb_handle *h, void *_data, int len)
475{
476    unsigned char *data = (unsigned char*) _data;
477    int n;
478
479    D("++ usb_read ++\n");
480    while(len > 0) {
481        int xfer = (len > 4096) ? 4096 : len;
482
483        D("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
484        n = usb_bulk_read(h, data, xfer);
485        D("[ usb read %d ] = %d, fname=%s\n", xfer, n, h->fname);
486        if(n != xfer) {
487            if((errno == ETIMEDOUT) && (h->desc != -1)) {
488                D("[ timeout ]\n");
489                if(n > 0){
490                    data += n;
491                    len -= n;
492                }
493                continue;
494            }
495            D("ERROR: n = %d, errno = %d (%s)\n",
496                n, errno, strerror(errno));
497            return -1;
498        }
499
500        len -= xfer;
501        data += xfer;
502    }
503
504    D("-- usb_read --\n");
505    return 0;
506}
507
508void usb_kick(usb_handle *h)
509{
510    D("[ kicking %p (fd = %d) ]\n", h, h->desc);
511    adb_mutex_lock(&h->lock);
512    if(h->dead == 0) {
513        h->dead = 1;
514
515        /* HACK ALERT!
516        ** Sometimes we get stuck in ioctl(USBDEVFS_REAPURB).
517        ** This is a workaround for that problem.
518        */
519        if (h->reaper_thread) {
520            pthread_kill(h->reaper_thread, SIGALRM);
521        }
522
523        /* cancel any pending transactions
524        ** these will quietly fail if the txns are not active,
525        ** but this ensures that a reader blocked on REAPURB
526        ** will get unblocked
527        */
528        ioctl(h->desc, USBDEVFS_DISCARDURB, &h->urb_in);
529        ioctl(h->desc, USBDEVFS_DISCARDURB, &h->urb_out);
530        h->urb_in.status = -ENODEV;
531        h->urb_out.status = -ENODEV;
532        h->urb_in_busy = 0;
533        h->urb_out_busy = 0;
534        adb_cond_broadcast(&h->notify);
535    }
536    adb_mutex_unlock(&h->lock);
537}
538
539int usb_close(usb_handle *h)
540{
541    D("[ usb close ... ]\n");
542    adb_mutex_lock(&usb_lock);
543    h->next->prev = h->prev;
544    h->prev->next = h->next;
545    h->prev = 0;
546    h->next = 0;
547
548    adb_close(h->desc);
549    D("[ usb closed %p (fd = %d) ]\n", h, h->desc);
550    adb_mutex_unlock(&usb_lock);
551
552    free(h);
553    return 0;
554}
555
556static void register_device(const char *dev_name,
557                            unsigned char ep_in, unsigned char ep_out,
558                            int interface,
559                            const char *serial, unsigned zero_mask)
560{
561    usb_handle* usb = 0;
562    int n = 0;
563
564        /* Since Linux will not reassign the device ID (and dev_name)
565        ** as long as the device is open, we can add to the list here
566        ** once we open it and remove from the list when we're finally
567        ** closed and everything will work out fine.
568        **
569        ** If we have a usb_handle on the list 'o handles with a matching
570        ** name, we have no further work to do.
571        */
572    adb_mutex_lock(&usb_lock);
573    for(usb = handle_list.next; usb != &handle_list; usb = usb->next){
574        if(!strcmp(usb->fname, dev_name)) {
575            adb_mutex_unlock(&usb_lock);
576            return;
577        }
578    }
579    adb_mutex_unlock(&usb_lock);
580
581    D("[ usb located new device %s (%d/%d/%d) ]\n",
582        dev_name, ep_in, ep_out, interface);
583    usb = calloc(1, sizeof(usb_handle));
584    strcpy(usb->fname, dev_name);
585    usb->ep_in = ep_in;
586    usb->ep_out = ep_out;
587    usb->zero_mask = zero_mask;
588
589    adb_cond_init(&usb->notify, 0);
590    adb_mutex_init(&usb->lock, 0);
591    /* initialize mark to 1 so we don't get garbage collected after the device scan */
592    usb->mark = 1;
593    usb->reaper_thread = 0;
594
595    usb->desc = unix_open(usb->fname, O_RDWR);
596    if(usb->desc < 0) goto fail;
597    D("[ usb open %s fd = %d]\n", usb->fname, usb->desc);
598    n = ioctl(usb->desc, USBDEVFS_CLAIMINTERFACE, &interface);
599    if(n != 0) goto fail;
600
601        /* add to the end of the active handles */
602    adb_mutex_lock(&usb_lock);
603    usb->next = &handle_list;
604    usb->prev = handle_list.prev;
605    usb->prev->next = usb;
606    usb->next->prev = usb;
607    adb_mutex_unlock(&usb_lock);
608
609    register_usb_transport(usb, serial);
610    return;
611
612fail:
613    D("[ usb open %s error=%d, err_str = %s]\n",
614        usb->fname,  errno, strerror(errno));
615    if(usb->desc >= 0) {
616        adb_close(usb->desc);
617    }
618    free(usb);
619}
620
621void* device_poll_thread(void* unused)
622{
623    D("Created device thread\n");
624    for(;;) {
625            /* XXX use inotify */
626        find_usb_device("/dev/bus/usb", register_device);
627        kick_disconnected_devices();
628        sleep(1);
629    }
630    return NULL;
631}
632
633static void sigalrm_handler(int signo)
634{
635    // don't need to do anything here
636}
637
638void usb_init()
639{
640    adb_thread_t tid;
641    struct sigaction    actions;
642
643    memset(&actions, 0, sizeof(actions));
644    sigemptyset(&actions.sa_mask);
645    actions.sa_flags = 0;
646    actions.sa_handler = sigalrm_handler;
647    sigaction(SIGALRM,& actions, NULL);
648
649    if(adb_thread_create(&tid, device_poll_thread, NULL)){
650        fatal_errno("cannot create input thread");
651    }
652}
653
654