usbhost.c revision cd185f23cc6f062b252d1d19bca55e721290ee62 
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 LOGD
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
37#include <sys/ioctl.h>
38#include <sys/types.h>
39#include <sys/time.h>
40#include <sys/inotify.h>
41#include <dirent.h>
42#include <fcntl.h>
43#include <errno.h>
44#include <ctype.h>
45#include <pthread.h>
46
47#include <linux/usbdevice_fs.h>
48#include <linux/version.h>
49#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
50#include <linux/usb/ch9.h>
51#else
52#include <linux/usb_ch9.h>
53#endif
54#include <asm/byteorder.h>
55
56#include "usbhost/usbhost.h"
57
58#define USB_FS_DIR "/dev/bus/usb"
59#define USB_FS_ID_SCANNER   "/dev/bus/usb/%d/%d"
60
61
62struct usb_host_context {
63    int fd;
64};
65
66struct usb_device {
67    char dev_name[64];
68    unsigned char desc[256];
69    int desc_length;
70    int fd;
71    int writeable;
72};
73
74struct usb_endpoint
75{
76    struct usb_device *dev;
77    struct usb_endpoint_descriptor  desc;
78    struct usbdevfs_urb urb;
79};
80
81static inline int badname(const char *name)
82{
83    while(*name) {
84        if(!isdigit(*name++)) return 1;
85    }
86    return 0;
87}
88
89/* returns true if one of the callbacks indicates we are done */
90static int find_existing_devices(usb_device_added_cb added_cb,
91                                  usb_device_removed_cb removed_cb,
92                                  void *client_data)
93{
94    char busname[32], devname[32];
95    DIR *busdir , *devdir ;
96    struct dirent *de;
97    int done = 0;
98
99    busdir = opendir(USB_FS_DIR);
100    if(busdir == 0) return 1;
101
102    while ((de = readdir(busdir)) != 0 && !done) {
103        if(badname(de->d_name)) continue;
104
105        snprintf(busname, sizeof busname, "%s/%s", USB_FS_DIR, de->d_name);
106        devdir = opendir(busname);
107        if(devdir == 0) continue;
108
109        while ((de = readdir(devdir)) && !done) {
110            if(badname(de->d_name)) continue;
111
112            snprintf(devname, sizeof devname, "%s/%s", busname, de->d_name);
113            done = added_cb(devname, client_data);
114        } // end of devdir while
115        closedir(devdir);
116    } //end of busdir while
117    closedir(busdir);
118
119    return done;
120}
121
122struct usb_host_context *usb_host_init()
123{
124    struct usb_host_context *context = calloc(1, sizeof(struct usb_host_context));
125    if (!context) {
126        fprintf(stderr, "out of memory in usb_host_context\n");
127        return NULL;
128    }
129    context->fd = inotify_init();
130    if (context->fd < 0) {
131        fprintf(stderr, "inotify_init failed\n");
132        free(context);
133        return NULL;
134    }
135    return context;
136}
137
138void usb_host_cleanup(struct usb_host_context *context)
139{
140    close(context->fd);
141    free(context);
142}
143
144void usb_host_run(struct usb_host_context *context,
145                  usb_device_added_cb added_cb,
146                  usb_device_removed_cb removed_cb,
147                  usb_discovery_done_cb discovery_done_cb,
148                  void *client_data)
149{
150    struct inotify_event* event;
151    char event_buf[512];
152    char path[100];
153    int i, ret, done = 0;
154    int wd, wds[10];
155    int wd_count = sizeof(wds) / sizeof(wds[0]);
156
157    D("Created device discovery thread\n");
158
159    /* watch for files added and deleted within USB_FS_DIR */
160    memset(wds, 0, sizeof(wds));
161    /* watch the root for new subdirectories */
162    wds[0] = inotify_add_watch(context->fd, USB_FS_DIR, IN_CREATE | IN_DELETE);
163    if (wds[0] < 0) {
164        fprintf(stderr, "inotify_add_watch failed\n");
165        if (discovery_done_cb)
166            discovery_done_cb(client_data);
167        return;
168    }
169
170    /* watch existing subdirectories of USB_FS_DIR */
171    for (i = 1; i < wd_count; i++) {
172        snprintf(path, sizeof(path), "%s/%03d", USB_FS_DIR, i);
173        ret = inotify_add_watch(context->fd, path, IN_CREATE | IN_DELETE);
174        if (ret > 0)
175            wds[i] = ret;
176    }
177
178    /* check for existing devices first, after we have inotify set up */
179    done = find_existing_devices(added_cb, removed_cb, client_data);
180    if (discovery_done_cb)
181        done |= discovery_done_cb(client_data);
182
183    while (!done) {
184        ret = read(context->fd, event_buf, sizeof(event_buf));
185        if (ret >= (int)sizeof(struct inotify_event)) {
186            event = (struct inotify_event *)event_buf;
187            wd = event->wd;
188            if (wd == wds[0]) {
189                i = atoi(event->name);
190                snprintf(path, sizeof(path), "%s/%s", USB_FS_DIR, event->name);
191                D("new subdirectory %s: index: %d\n", path, i);
192                if (i > 0 && i < wd_count) {
193                ret = inotify_add_watch(context->fd, path, IN_CREATE | IN_DELETE);
194                if (ret > 0)
195                    wds[i] = ret;
196                }
197            } else {
198                for (i = 1; i < wd_count && !done; i++) {
199                    if (wd == wds[i]) {
200                        snprintf(path, sizeof(path), "%s/%03d/%s", USB_FS_DIR, i, event->name);
201                        if (event->mask == IN_CREATE) {
202                            D("new device %s\n", path);
203                            done = added_cb(path, client_data);
204                        } else if (event->mask == IN_DELETE) {
205                            D("gone device %s\n", path);
206                            done = removed_cb(path, client_data);
207                        }
208                    }
209                }
210            }
211        }
212    }
213}
214
215struct usb_device *usb_device_open(const char *dev_name)
216{
217    int fd, did_retry = 0, writeable = 1;
218
219retry:
220    fd = open(dev_name, O_RDWR);
221    if (fd < 0) {
222        /* if we fail, see if have read-only access */
223        fd = open(dev_name, O_RDONLY);
224        D("usb_device_open open returned %d errno %d\n", fd, errno);
225        if (fd < 0 && (errno == EACCES || errno == ENOENT) && !did_retry) {
226            /* work around race condition between inotify and permissions management */
227            sleep(1);
228            did_retry = 1;
229            goto retry;
230        }
231
232        if (fd < 0)
233            return NULL;
234        writeable = 0;
235        D("[ usb open read-only %s fd = %d]\n", dev_name, fd);
236    }
237
238    struct usb_device* result = usb_device_new(dev_name, fd);
239    if (result)
240        result->writeable = writeable;
241    return result;
242}
243
244void usb_device_close(struct usb_device *device)
245{
246    close(device->fd);
247    free(device);
248}
249
250struct usb_device *usb_device_new(const char *dev_name, int fd)
251{
252    struct usb_device *device = calloc(1, sizeof(struct usb_device));
253    int length;
254
255    if (lseek(fd, 0, SEEK_SET) != 0)
256        goto failed;
257    length = read(fd, device->desc, sizeof(device->desc));
258    D("usb_device_new read returned %d errno %d\n", fd, errno);
259    if (length < 0)
260        goto failed;
261
262    device->fd = fd;
263    device->desc_length = length;
264    // assume we are writeable, since usb_device_get_fd will only return writeable fds
265    device->writeable = 1;
266    return device;
267
268failed:
269    close(fd);
270    free(device);
271    return NULL;
272}
273
274static int usb_device_reopen_writeable(struct usb_device *device)
275{
276    if (device->writeable)
277        return 1;
278
279    int fd = open(device->dev_name, O_RDWR);
280    if (fd >= 0) {
281        close(device->fd);
282        device->fd = fd;
283        device->writeable = 1;
284        return 1;
285    }
286    D("usb_device_reopen_writeable failed errno %d\n", errno);
287    return 0;
288}
289
290int usb_device_get_fd(struct usb_device *device)
291{
292    if (!usb_device_reopen_writeable(device))
293        return -1;
294    return device->fd;
295}
296
297const char* usb_device_get_name(struct usb_device *device)
298{
299    return device->dev_name;
300}
301
302int usb_device_get_unique_id(struct usb_device *device)
303{
304    int bus = 0, dev = 0;
305    sscanf(device->dev_name, USB_FS_ID_SCANNER, &bus, &dev);
306    return bus * 1000 + dev;
307}
308
309int usb_device_get_unique_id_from_name(const char* name)
310{
311    int bus = 0, dev = 0;
312    sscanf(name, USB_FS_ID_SCANNER, &bus, &dev);
313    return bus * 1000 + dev;
314}
315
316uint16_t usb_device_get_vendor_id(struct usb_device *device)
317{
318    struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
319    return __le16_to_cpu(desc->idVendor);
320}
321
322uint16_t usb_device_get_product_id(struct usb_device *device)
323{
324    struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc;
325    return __le16_to_cpu(desc->idProduct);
326}
327
328int usb_device_send_control(struct usb_device *device,
329                            int requestType,
330                            int request,
331                            int value,
332                            int index,
333                            int length,
334                            void* buffer)
335{
336    struct usbdevfs_ctrltransfer  ctrl;
337
338    // this usually requires read/write permission
339    if (!usb_device_reopen_writeable(device))
340        return -1;
341
342    memset(&ctrl, 0, sizeof(ctrl));
343    ctrl.bRequestType = requestType;
344    ctrl.bRequest = request;
345    ctrl.wValue = value;
346    ctrl.wIndex = index;
347    ctrl.wLength = length;
348    ctrl.data = buffer;
349    return ioctl(device->fd, USBDEVFS_CONTROL, &ctrl);
350}
351
352char* usb_device_get_string(struct usb_device *device, int id)
353{
354    char string[256];
355    __u16 buffer[128];
356    __u16 languages[128];
357    int i, result;
358    int languageCount = 0;
359
360    string[0] = 0;
361    memset(languages, 0, sizeof(languages));
362
363    // read list of supported languages
364    result = usb_device_send_control(device,
365            USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
366            (USB_DT_STRING << 8) | 0, 0, sizeof(languages), languages);
367    if (result > 0)
368        languageCount = (result - 2) / 2;
369
370    for (i = 1; i <= languageCount; i++) {
371        memset(buffer, 0, sizeof(buffer));
372
373        result = usb_device_send_control(device,
374                USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR,
375                (USB_DT_STRING << 8) | id, languages[i], sizeof(buffer), buffer);
376        if (result > 0) {
377            int i;
378            // skip first word, and copy the rest to the string, changing shorts to bytes.
379            result /= 2;
380            for (i = 1; i < result; i++)
381                string[i - 1] = buffer[i];
382            string[i - 1] = 0;
383            return strdup(string);
384        }
385    }
386
387    return NULL;
388}
389
390char* usb_device_get_manufacturer_name(struct usb_device *device)
391{
392    struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
393
394    if (desc->iManufacturer)
395        return usb_device_get_string(device, desc->iManufacturer);
396    else
397        return NULL;
398}
399
400char* usb_device_get_product_name(struct usb_device *device)
401{
402    struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
403
404    if (desc->iProduct)
405        return usb_device_get_string(device, desc->iProduct);
406    else
407        return NULL;
408}
409
410char* usb_device_get_serial(struct usb_device *device)
411{
412    struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc;
413
414    if (desc->iSerialNumber)
415        return usb_device_get_string(device, desc->iSerialNumber);
416    else
417        return NULL;
418}
419
420int usb_device_is_writeable(struct usb_device *device)
421{
422    return device->writeable;
423}
424
425void usb_descriptor_iter_init(struct usb_device *device, struct usb_descriptor_iter *iter)
426{
427    iter->config = device->desc;
428    iter->config_end = device->desc + device->desc_length;
429    iter->curr_desc = device->desc;
430}
431
432struct usb_descriptor_header *usb_descriptor_iter_next(struct usb_descriptor_iter *iter)
433{
434    struct usb_descriptor_header* next;
435    if (iter->curr_desc >= iter->config_end)
436        return NULL;
437    next = (struct usb_descriptor_header*)iter->curr_desc;
438    iter->curr_desc += next->bLength;
439    return next;
440}
441
442int usb_device_claim_interface(struct usb_device *device, unsigned int interface)
443{
444    return ioctl(device->fd, USBDEVFS_CLAIMINTERFACE, &interface);
445}
446
447int usb_device_release_interface(struct usb_device *device, unsigned int interface)
448{
449    return ioctl(device->fd, USBDEVFS_RELEASEINTERFACE, &interface);
450}
451
452struct usb_endpoint *usb_endpoint_open(struct usb_device *dev,
453        const struct usb_endpoint_descriptor *desc)
454{
455    struct usb_endpoint *ep = calloc(1, sizeof(struct usb_endpoint));
456    memcpy(&ep->desc, desc, sizeof(ep->desc));
457    ep->dev = dev;
458    return ep;
459}
460
461void usb_endpoint_close(struct usb_endpoint *ep)
462{
463    // cancel IO here?
464    free(ep);
465}
466
467int usb_endpoint_queue(struct usb_endpoint *ep, void *data, int len)
468{
469    struct usbdevfs_urb *urb = &ep->urb;
470    int res;
471
472    D("usb_endpoint_queue\n");
473    memset(urb, 0, sizeof(*urb));
474    urb->type = USBDEVFS_URB_TYPE_BULK;
475    urb->endpoint = ep->desc.bEndpointAddress;
476    urb->status = -1;
477    urb->buffer = data;
478    urb->buffer_length = len;
479
480    do {
481        res = ioctl(ep->dev->fd, USBDEVFS_SUBMITURB, urb);
482    } while((res < 0) && (errno == EINTR));
483
484    return res;
485}
486
487int usb_endpoint_wait(struct usb_device *dev, int *out_ep_num)
488{
489    struct usbdevfs_urb *out = NULL;
490    int res;
491
492    while (1) {
493        res = ioctl(dev->fd, USBDEVFS_REAPURB, &out);
494        D("USBDEVFS_REAPURB returned %d\n", res);
495        if (res < 0) {
496            if(errno == EINTR) {
497                continue;
498            }
499            D("[ reap urb - error ]\n");
500            *out_ep_num = -1;
501        } else {
502            D("[ urb @%p status = %d, actual = %d ]\n",
503                out, out->status, out->actual_length);
504            res = out->actual_length;
505            *out_ep_num = out->endpoint;
506        }
507        break;
508    }
509    return res;
510}
511
512int usb_endpoint_cancel(struct usb_endpoint *ep)
513{
514    return ioctl(ep->dev->fd, USBDEVFS_DISCARDURB, &ep->urb);
515}
516
517struct usb_device *usb_endpoint_get_device(struct usb_endpoint *ep)
518{
519    return ep->dev;
520}
521
522int usb_endpoint_number(struct usb_endpoint *ep)
523{
524    return ep->desc.bEndpointAddress;
525}
526
527int usb_endpoint_max_packet(struct usb_endpoint *ep)
528{
529    return __le16_to_cpu(ep->desc.wMaxPacketSize);
530}
531
532