Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 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 | |
Mike Lockwood | e15af09 | 2010-06-10 10:20:49 -0400 | [diff] [blame] | 17 | // #define DEBUG 1 |
| 18 | #if DEBUG |
| 19 | |
| 20 | #ifdef USE_LIBLOG |
| 21 | #define LOG_TAG "usbhost" |
| 22 | #include "utils/Log.h" |
Steve Block | 8d66c49 | 2011-12-20 16:07:45 +0000 | [diff] [blame] | 23 | #define D ALOGD |
Mike Lockwood | e15af09 | 2010-06-10 10:20:49 -0400 | [diff] [blame] | 24 | #else |
| 25 | #define D printf |
| 26 | #endif |
| 27 | |
| 28 | #else |
| 29 | #define D(...) |
| 30 | #endif |
| 31 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 32 | #include <stdio.h> |
| 33 | #include <stdlib.h> |
| 34 | #include <unistd.h> |
| 35 | #include <string.h> |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 36 | #include <stddef.h> |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 37 | |
| 38 | #include <sys/ioctl.h> |
| 39 | #include <sys/types.h> |
| 40 | #include <sys/time.h> |
| 41 | #include <sys/inotify.h> |
| 42 | #include <dirent.h> |
| 43 | #include <fcntl.h> |
| 44 | #include <errno.h> |
| 45 | #include <ctype.h> |
| 46 | #include <pthread.h> |
| 47 | |
| 48 | #include <linux/usbdevice_fs.h> |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 49 | #include <asm/byteorder.h> |
| 50 | |
| 51 | #include "usbhost/usbhost.h" |
| 52 | |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 53 | #define DEV_DIR "/dev" |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 54 | #define USB_FS_DIR DEV_DIR "/bus/usb" |
| 55 | #define USB_FS_ID_SCANNER USB_FS_DIR "/%d/%d" |
| 56 | #define USB_FS_ID_FORMAT USB_FS_DIR "/%03d/%03d" |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 57 | |
Mike Lockwood | c4c00d8 | 2011-03-12 12:25:11 -0500 | [diff] [blame] | 58 | // From drivers/usb/core/devio.c |
| 59 | // I don't know why this isn't in a kernel header |
| 60 | #define MAX_USBFS_BUFFER_SIZE 16384 |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 61 | |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 62 | #define MAX_USBFS_WD_COUNT 10 |
| 63 | |
Mike Lockwood | 6ac3aa1 | 2010-05-25 08:10:02 -0400 | [diff] [blame] | 64 | struct usb_host_context { |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 65 | int fd; |
| 66 | usb_device_added_cb cb_added; |
| 67 | usb_device_removed_cb cb_removed; |
| 68 | void *data; |
| 69 | int wds[MAX_USBFS_WD_COUNT]; |
| 70 | int wdd; |
Mike Lockwood | 6ac3aa1 | 2010-05-25 08:10:02 -0400 | [diff] [blame] | 71 | }; |
| 72 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 73 | struct usb_device { |
| 74 | char dev_name[64]; |
Mike Lockwood | ec9e7b1 | 2011-01-22 09:17:07 -0800 | [diff] [blame] | 75 | unsigned char desc[4096]; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 76 | int desc_length; |
| 77 | int fd; |
| 78 | int writeable; |
| 79 | }; |
| 80 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 81 | static inline int badname(const char *name) |
| 82 | { |
| 83 | while(*name) { |
| 84 | if(!isdigit(*name++)) return 1; |
| 85 | } |
| 86 | return 0; |
| 87 | } |
| 88 | |
Benoit Goby | 6cc883c | 2012-07-31 19:22:06 -0700 | [diff] [blame] | 89 | static int find_existing_devices_bus(char *busname, |
| 90 | usb_device_added_cb added_cb, |
| 91 | void *client_data) |
| 92 | { |
| 93 | char devname[32]; |
| 94 | DIR *devdir; |
| 95 | struct dirent *de; |
| 96 | int done = 0; |
| 97 | |
| 98 | devdir = opendir(busname); |
| 99 | if(devdir == 0) return 0; |
| 100 | |
| 101 | while ((de = readdir(devdir)) && !done) { |
| 102 | if(badname(de->d_name)) continue; |
| 103 | |
| 104 | snprintf(devname, sizeof(devname), "%s/%s", busname, de->d_name); |
| 105 | done = added_cb(devname, client_data); |
| 106 | } // end of devdir while |
| 107 | closedir(devdir); |
| 108 | |
| 109 | return done; |
| 110 | } |
| 111 | |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 112 | /* returns true if one of the callbacks indicates we are done */ |
| 113 | static int find_existing_devices(usb_device_added_cb added_cb, |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 114 | void *client_data) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 115 | { |
Benoit Goby | 6cc883c | 2012-07-31 19:22:06 -0700 | [diff] [blame] | 116 | char busname[32]; |
| 117 | DIR *busdir; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 118 | struct dirent *de; |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 119 | int done = 0; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 120 | |
| 121 | busdir = opendir(USB_FS_DIR); |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 122 | if(busdir == 0) return 0; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 123 | |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 124 | while ((de = readdir(busdir)) != 0 && !done) { |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 125 | if(badname(de->d_name)) continue; |
| 126 | |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 127 | snprintf(busname, sizeof(busname), USB_FS_DIR "/%s", de->d_name); |
Benoit Goby | 6cc883c | 2012-07-31 19:22:06 -0700 | [diff] [blame] | 128 | done = find_existing_devices_bus(busname, added_cb, |
| 129 | client_data); |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 130 | } //end of busdir while |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 131 | closedir(busdir); |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 132 | |
| 133 | return done; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 134 | } |
| 135 | |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 136 | static void watch_existing_subdirs(struct usb_host_context *context, |
| 137 | int *wds, int wd_count) |
| 138 | { |
| 139 | char path[100]; |
| 140 | int i, ret; |
| 141 | |
| 142 | wds[0] = inotify_add_watch(context->fd, USB_FS_DIR, IN_CREATE | IN_DELETE); |
| 143 | if (wds[0] < 0) |
| 144 | return; |
| 145 | |
| 146 | /* watch existing subdirectories of USB_FS_DIR */ |
| 147 | for (i = 1; i < wd_count; i++) { |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 148 | snprintf(path, sizeof(path), USB_FS_DIR "/%03d", i); |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 149 | ret = inotify_add_watch(context->fd, path, IN_CREATE | IN_DELETE); |
| 150 | if (ret >= 0) |
| 151 | wds[i] = ret; |
| 152 | } |
| 153 | } |
| 154 | |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 155 | struct usb_host_context *usb_host_init() |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 156 | { |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 157 | struct usb_host_context *context = calloc(1, sizeof(struct usb_host_context)); |
| 158 | if (!context) { |
| 159 | fprintf(stderr, "out of memory in usb_host_context\n"); |
| 160 | return NULL; |
| 161 | } |
| 162 | context->fd = inotify_init(); |
| 163 | if (context->fd < 0) { |
| 164 | fprintf(stderr, "inotify_init failed\n"); |
| 165 | free(context); |
| 166 | return NULL; |
| 167 | } |
| 168 | return context; |
| 169 | } |
| 170 | |
| 171 | void usb_host_cleanup(struct usb_host_context *context) |
| 172 | { |
| 173 | close(context->fd); |
| 174 | free(context); |
| 175 | } |
| 176 | |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 177 | int usb_host_get_fd(struct usb_host_context *context) |
| 178 | { |
| 179 | return context->fd; |
| 180 | } /* usb_host_get_fd() */ |
| 181 | |
| 182 | int usb_host_load(struct usb_host_context *context, |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 183 | usb_device_added_cb added_cb, |
| 184 | usb_device_removed_cb removed_cb, |
Mike Lockwood | a805519 | 2010-07-19 20:15:15 -0400 | [diff] [blame] | 185 | usb_discovery_done_cb discovery_done_cb, |
Mike Lockwood | 7a96ba4 | 2010-07-01 11:33:41 -0400 | [diff] [blame] | 186 | void *client_data) |
| 187 | { |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 188 | int done = 0; |
| 189 | int i; |
| 190 | |
| 191 | context->cb_added = added_cb; |
| 192 | context->cb_removed = removed_cb; |
| 193 | context->data = client_data; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 194 | |
| 195 | D("Created device discovery thread\n"); |
| 196 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 197 | /* watch for files added and deleted within USB_FS_DIR */ |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 198 | for (i = 0; i < MAX_USBFS_WD_COUNT; i++) |
| 199 | context->wds[i] = -1; |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 200 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 201 | /* watch the root for new subdirectories */ |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 202 | context->wdd = inotify_add_watch(context->fd, DEV_DIR, IN_CREATE | IN_DELETE); |
| 203 | if (context->wdd < 0) { |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 204 | fprintf(stderr, "inotify_add_watch failed\n"); |
Mike Lockwood | e8849d1 | 2010-07-20 16:31:42 -0400 | [diff] [blame] | 205 | if (discovery_done_cb) |
| 206 | discovery_done_cb(client_data); |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 207 | return done; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 208 | } |
| 209 | |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 210 | watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 211 | |
| 212 | /* check for existing devices first, after we have inotify set up */ |
Benoit Goby | 6cc883c | 2012-07-31 19:22:06 -0700 | [diff] [blame] | 213 | done = find_existing_devices(added_cb, client_data); |
Mike Lockwood | a805519 | 2010-07-19 20:15:15 -0400 | [diff] [blame] | 214 | if (discovery_done_cb) |
| 215 | done |= discovery_done_cb(client_data); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 216 | |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 217 | return done; |
| 218 | } /* usb_host_load() */ |
| 219 | |
| 220 | int usb_host_read_event(struct usb_host_context *context) |
| 221 | { |
| 222 | struct inotify_event* event; |
| 223 | char event_buf[512]; |
| 224 | char path[100]; |
| 225 | int i, ret, done = 0; |
Ziv Hendel | f75ea8d | 2013-03-24 18:10:52 +0200 | [diff] [blame] | 226 | int offset = 0; |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 227 | int wd; |
| 228 | |
| 229 | ret = read(context->fd, event_buf, sizeof(event_buf)); |
| 230 | if (ret >= (int)sizeof(struct inotify_event)) { |
Ziv Hendel | f75ea8d | 2013-03-24 18:10:52 +0200 | [diff] [blame] | 231 | while (offset < ret) { |
| 232 | event = (struct inotify_event*)&event_buf[offset]; |
| 233 | done = 0; |
| 234 | wd = event->wd; |
| 235 | if (wd == context->wdd) { |
| 236 | if ((event->mask & IN_CREATE) && !strcmp(event->name, "bus")) { |
| 237 | watch_existing_subdirs(context, context->wds, MAX_USBFS_WD_COUNT); |
| 238 | done = find_existing_devices(context->cb_added, context->data); |
| 239 | } else if ((event->mask & IN_DELETE) && !strcmp(event->name, "bus")) { |
| 240 | for (i = 0; i < MAX_USBFS_WD_COUNT; i++) { |
| 241 | if (context->wds[i] >= 0) { |
| 242 | inotify_rm_watch(context->fd, context->wds[i]); |
| 243 | context->wds[i] = -1; |
| 244 | } |
| 245 | } |
| 246 | } |
| 247 | } else if (wd == context->wds[0]) { |
| 248 | i = atoi(event->name); |
| 249 | snprintf(path, sizeof(path), USB_FS_DIR "/%s", event->name); |
| 250 | D("%s subdirectory %s: index: %d\n", (event->mask & IN_CREATE) ? |
| 251 | "new" : "gone", path, i); |
| 252 | if (i > 0 && i < MAX_USBFS_WD_COUNT) { |
| 253 | if (event->mask & IN_CREATE) { |
| 254 | ret = inotify_add_watch(context->fd, path, |
| 255 | IN_CREATE | IN_DELETE); |
| 256 | if (ret >= 0) |
| 257 | context->wds[i] = ret; |
| 258 | done = find_existing_devices_bus(path, context->cb_added, |
| 259 | context->data); |
| 260 | } else if (event->mask & IN_DELETE) { |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 261 | inotify_rm_watch(context->fd, context->wds[i]); |
| 262 | context->wds[i] = -1; |
Benoit Goby | f4de078 | 2012-08-01 18:54:02 -0700 | [diff] [blame] | 263 | } |
| 264 | } |
Ziv Hendel | f75ea8d | 2013-03-24 18:10:52 +0200 | [diff] [blame] | 265 | } else { |
| 266 | for (i = 1; (i < MAX_USBFS_WD_COUNT) && !done; i++) { |
| 267 | if (wd == context->wds[i]) { |
| 268 | snprintf(path, sizeof(path), USB_FS_DIR "/%03d/%s", i, event->name); |
| 269 | if (event->mask == IN_CREATE) { |
| 270 | D("new device %s\n", path); |
| 271 | done = context->cb_added(path, context->data); |
| 272 | } else if (event->mask == IN_DELETE) { |
| 273 | D("gone device %s\n", path); |
| 274 | done = context->cb_removed(path, context->data); |
| 275 | } |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 276 | } |
| 277 | } |
| 278 | } |
Ziv Hendel | f75ea8d | 2013-03-24 18:10:52 +0200 | [diff] [blame] | 279 | |
| 280 | offset += sizeof(struct inotify_event) + event->len; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 281 | } |
| 282 | } |
Guillaume Ranquet | dea46b6 | 2012-10-23 17:11:44 +0200 | [diff] [blame] | 283 | |
| 284 | return done; |
| 285 | } /* usb_host_read_event() */ |
| 286 | |
| 287 | void usb_host_run(struct usb_host_context *context, |
| 288 | usb_device_added_cb added_cb, |
| 289 | usb_device_removed_cb removed_cb, |
| 290 | usb_discovery_done_cb discovery_done_cb, |
| 291 | void *client_data) |
| 292 | { |
| 293 | int done; |
| 294 | |
| 295 | done = usb_host_load(context, added_cb, removed_cb, discovery_done_cb, client_data); |
| 296 | |
| 297 | while (!done) { |
| 298 | |
| 299 | done = usb_host_read_event(context); |
| 300 | } |
| 301 | } /* usb_host_run() */ |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 302 | |
| 303 | struct usb_device *usb_device_open(const char *dev_name) |
| 304 | { |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 305 | int fd, did_retry = 0, writeable = 1; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 306 | |
Mike Lockwood | ec9e7b1 | 2011-01-22 09:17:07 -0800 | [diff] [blame] | 307 | D("usb_device_open %s\n", dev_name); |
| 308 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 309 | retry: |
| 310 | fd = open(dev_name, O_RDWR); |
| 311 | if (fd < 0) { |
| 312 | /* if we fail, see if have read-only access */ |
| 313 | fd = open(dev_name, O_RDONLY); |
Mike Lockwood | e15af09 | 2010-06-10 10:20:49 -0400 | [diff] [blame] | 314 | D("usb_device_open open returned %d errno %d\n", fd, errno); |
| 315 | if (fd < 0 && (errno == EACCES || errno == ENOENT) && !did_retry) { |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 316 | /* work around race condition between inotify and permissions management */ |
| 317 | sleep(1); |
| 318 | did_retry = 1; |
| 319 | goto retry; |
| 320 | } |
| 321 | |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 322 | if (fd < 0) |
| 323 | return NULL; |
| 324 | writeable = 0; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 325 | D("[ usb open read-only %s fd = %d]\n", dev_name, fd); |
| 326 | } |
| 327 | |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 328 | struct usb_device* result = usb_device_new(dev_name, fd); |
| 329 | if (result) |
| 330 | result->writeable = writeable; |
| 331 | return result; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | void usb_device_close(struct usb_device *device) |
| 335 | { |
| 336 | close(device->fd); |
| 337 | free(device); |
| 338 | } |
| 339 | |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 340 | struct usb_device *usb_device_new(const char *dev_name, int fd) |
| 341 | { |
| 342 | struct usb_device *device = calloc(1, sizeof(struct usb_device)); |
| 343 | int length; |
| 344 | |
Mike Lockwood | ec9e7b1 | 2011-01-22 09:17:07 -0800 | [diff] [blame] | 345 | D("usb_device_new %s fd: %d\n", dev_name, fd); |
| 346 | |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 347 | if (lseek(fd, 0, SEEK_SET) != 0) |
| 348 | goto failed; |
| 349 | length = read(fd, device->desc, sizeof(device->desc)); |
Mike Lockwood | ec9e7b1 | 2011-01-22 09:17:07 -0800 | [diff] [blame] | 350 | D("usb_device_new read returned %d errno %d\n", length, errno); |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 351 | if (length < 0) |
| 352 | goto failed; |
| 353 | |
Mike Lockwood | 93aff72 | 2010-12-15 12:58:04 -0800 | [diff] [blame] | 354 | strncpy(device->dev_name, dev_name, sizeof(device->dev_name) - 1); |
Mike Lockwood | cd185f2 | 2010-12-12 14:17:02 -0800 | [diff] [blame] | 355 | device->fd = fd; |
| 356 | device->desc_length = length; |
| 357 | // assume we are writeable, since usb_device_get_fd will only return writeable fds |
| 358 | device->writeable = 1; |
| 359 | return device; |
| 360 | |
| 361 | failed: |
| 362 | close(fd); |
| 363 | free(device); |
| 364 | return NULL; |
| 365 | } |
| 366 | |
| 367 | static int usb_device_reopen_writeable(struct usb_device *device) |
| 368 | { |
| 369 | if (device->writeable) |
| 370 | return 1; |
| 371 | |
| 372 | int fd = open(device->dev_name, O_RDWR); |
| 373 | if (fd >= 0) { |
| 374 | close(device->fd); |
| 375 | device->fd = fd; |
| 376 | device->writeable = 1; |
| 377 | return 1; |
| 378 | } |
| 379 | D("usb_device_reopen_writeable failed errno %d\n", errno); |
| 380 | return 0; |
| 381 | } |
| 382 | |
| 383 | int usb_device_get_fd(struct usb_device *device) |
| 384 | { |
| 385 | if (!usb_device_reopen_writeable(device)) |
| 386 | return -1; |
| 387 | return device->fd; |
| 388 | } |
| 389 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 390 | const char* usb_device_get_name(struct usb_device *device) |
| 391 | { |
| 392 | return device->dev_name; |
| 393 | } |
| 394 | |
Mike Lockwood | 203f102 | 2010-05-27 10:12:03 -0400 | [diff] [blame] | 395 | int usb_device_get_unique_id(struct usb_device *device) |
| 396 | { |
| 397 | int bus = 0, dev = 0; |
| 398 | sscanf(device->dev_name, USB_FS_ID_SCANNER, &bus, &dev); |
| 399 | return bus * 1000 + dev; |
| 400 | } |
| 401 | |
Mike Lockwood | 07eb4af | 2010-07-27 19:05:33 -0400 | [diff] [blame] | 402 | int usb_device_get_unique_id_from_name(const char* name) |
| 403 | { |
| 404 | int bus = 0, dev = 0; |
| 405 | sscanf(name, USB_FS_ID_SCANNER, &bus, &dev); |
| 406 | return bus * 1000 + dev; |
| 407 | } |
| 408 | |
Mike Lockwood | 7d700f8 | 2010-12-29 08:47:29 -0500 | [diff] [blame] | 409 | char* usb_device_get_name_from_unique_id(int id) |
| 410 | { |
| 411 | int bus = id / 1000; |
| 412 | int dev = id % 1000; |
| 413 | char* result = (char *)calloc(1, strlen(USB_FS_ID_FORMAT)); |
| 414 | snprintf(result, strlen(USB_FS_ID_FORMAT) - 1, USB_FS_ID_FORMAT, bus, dev); |
| 415 | return result; |
| 416 | } |
| 417 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 418 | uint16_t usb_device_get_vendor_id(struct usb_device *device) |
| 419 | { |
| 420 | struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc; |
| 421 | return __le16_to_cpu(desc->idVendor); |
| 422 | } |
| 423 | |
| 424 | uint16_t usb_device_get_product_id(struct usb_device *device) |
| 425 | { |
| 426 | struct usb_device_descriptor* desc = (struct usb_device_descriptor*)device->desc; |
| 427 | return __le16_to_cpu(desc->idProduct); |
| 428 | } |
| 429 | |
Mike Lockwood | 5037207 | 2010-12-13 10:15:25 -0800 | [diff] [blame] | 430 | const struct usb_device_descriptor* usb_device_get_device_descriptor(struct usb_device *device) |
| 431 | { |
| 432 | return (struct usb_device_descriptor*)device->desc; |
| 433 | } |
| 434 | |
Mike Lockwood | 1b7d991 | 2010-07-24 13:57:21 -0400 | [diff] [blame] | 435 | char* usb_device_get_string(struct usb_device *device, int id) |
| 436 | { |
| 437 | char string[256]; |
| 438 | __u16 buffer[128]; |
| 439 | __u16 languages[128]; |
| 440 | int i, result; |
| 441 | int languageCount = 0; |
| 442 | |
| 443 | string[0] = 0; |
| 444 | memset(languages, 0, sizeof(languages)); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 445 | |
| 446 | // read list of supported languages |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 447 | result = usb_device_control_transfer(device, |
Mike Lockwood | 1b7d991 | 2010-07-24 13:57:21 -0400 | [diff] [blame] | 448 | USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR, |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 449 | (USB_DT_STRING << 8) | 0, 0, languages, sizeof(languages), 0); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 450 | if (result > 0) |
| 451 | languageCount = (result - 2) / 2; |
| 452 | |
| 453 | for (i = 1; i <= languageCount; i++) { |
| 454 | memset(buffer, 0, sizeof(buffer)); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 455 | |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 456 | result = usb_device_control_transfer(device, |
Mike Lockwood | 1b7d991 | 2010-07-24 13:57:21 -0400 | [diff] [blame] | 457 | USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE, USB_REQ_GET_DESCRIPTOR, |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 458 | (USB_DT_STRING << 8) | id, languages[i], buffer, sizeof(buffer), 0); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 459 | if (result > 0) { |
| 460 | int i; |
| 461 | // skip first word, and copy the rest to the string, changing shorts to bytes. |
| 462 | result /= 2; |
| 463 | for (i = 1; i < result; i++) |
| 464 | string[i - 1] = buffer[i]; |
| 465 | string[i - 1] = 0; |
| 466 | return strdup(string); |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | return NULL; |
| 471 | } |
| 472 | |
| 473 | char* usb_device_get_manufacturer_name(struct usb_device *device) |
| 474 | { |
| 475 | struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc; |
| 476 | |
| 477 | if (desc->iManufacturer) |
| 478 | return usb_device_get_string(device, desc->iManufacturer); |
| 479 | else |
| 480 | return NULL; |
| 481 | } |
| 482 | |
| 483 | char* usb_device_get_product_name(struct usb_device *device) |
| 484 | { |
| 485 | struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc; |
| 486 | |
| 487 | if (desc->iProduct) |
| 488 | return usb_device_get_string(device, desc->iProduct); |
| 489 | else |
| 490 | return NULL; |
| 491 | } |
| 492 | |
| 493 | char* usb_device_get_serial(struct usb_device *device) |
| 494 | { |
| 495 | struct usb_device_descriptor *desc = (struct usb_device_descriptor *)device->desc; |
| 496 | |
| 497 | if (desc->iSerialNumber) |
| 498 | return usb_device_get_string(device, desc->iSerialNumber); |
| 499 | else |
| 500 | return NULL; |
| 501 | } |
| 502 | |
| 503 | int usb_device_is_writeable(struct usb_device *device) |
| 504 | { |
| 505 | return device->writeable; |
| 506 | } |
| 507 | |
| 508 | void usb_descriptor_iter_init(struct usb_device *device, struct usb_descriptor_iter *iter) |
| 509 | { |
| 510 | iter->config = device->desc; |
| 511 | iter->config_end = device->desc + device->desc_length; |
| 512 | iter->curr_desc = device->desc; |
| 513 | } |
| 514 | |
| 515 | struct usb_descriptor_header *usb_descriptor_iter_next(struct usb_descriptor_iter *iter) |
| 516 | { |
| 517 | struct usb_descriptor_header* next; |
| 518 | if (iter->curr_desc >= iter->config_end) |
| 519 | return NULL; |
| 520 | next = (struct usb_descriptor_header*)iter->curr_desc; |
| 521 | iter->curr_desc += next->bLength; |
| 522 | return next; |
| 523 | } |
| 524 | |
| 525 | int usb_device_claim_interface(struct usb_device *device, unsigned int interface) |
| 526 | { |
| 527 | return ioctl(device->fd, USBDEVFS_CLAIMINTERFACE, &interface); |
| 528 | } |
| 529 | |
| 530 | int usb_device_release_interface(struct usb_device *device, unsigned int interface) |
| 531 | { |
| 532 | return ioctl(device->fd, USBDEVFS_RELEASEINTERFACE, &interface); |
| 533 | } |
| 534 | |
Mike Lockwood | ec9e7b1 | 2011-01-22 09:17:07 -0800 | [diff] [blame] | 535 | int usb_device_connect_kernel_driver(struct usb_device *device, |
| 536 | unsigned int interface, int connect) |
| 537 | { |
| 538 | struct usbdevfs_ioctl ctl; |
| 539 | |
| 540 | ctl.ifno = interface; |
| 541 | ctl.ioctl_code = (connect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT); |
| 542 | ctl.data = NULL; |
| 543 | return ioctl(device->fd, USBDEVFS_IOCTL, &ctl); |
| 544 | } |
| 545 | |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 546 | int usb_device_control_transfer(struct usb_device *device, |
| 547 | int requestType, |
| 548 | int request, |
| 549 | int value, |
| 550 | int index, |
| 551 | void* buffer, |
| 552 | int length, |
| 553 | unsigned int timeout) |
| 554 | { |
| 555 | struct usbdevfs_ctrltransfer ctrl; |
| 556 | |
| 557 | // this usually requires read/write permission |
| 558 | if (!usb_device_reopen_writeable(device)) |
| 559 | return -1; |
| 560 | |
| 561 | memset(&ctrl, 0, sizeof(ctrl)); |
| 562 | ctrl.bRequestType = requestType; |
| 563 | ctrl.bRequest = request; |
| 564 | ctrl.wValue = value; |
| 565 | ctrl.wIndex = index; |
| 566 | ctrl.wLength = length; |
| 567 | ctrl.data = buffer; |
| 568 | ctrl.timeout = timeout; |
| 569 | return ioctl(device->fd, USBDEVFS_CONTROL, &ctrl); |
| 570 | } |
| 571 | |
| 572 | int usb_device_bulk_transfer(struct usb_device *device, |
| 573 | int endpoint, |
| 574 | void* buffer, |
| 575 | int length, |
| 576 | unsigned int timeout) |
| 577 | { |
| 578 | struct usbdevfs_bulktransfer ctrl; |
| 579 | |
Mike Lockwood | c4c00d8 | 2011-03-12 12:25:11 -0500 | [diff] [blame] | 580 | // need to limit request size to avoid EINVAL |
| 581 | if (length > MAX_USBFS_BUFFER_SIZE) |
| 582 | length = MAX_USBFS_BUFFER_SIZE; |
| 583 | |
Mike Lockwood | 120b57a | 2011-01-27 10:46:19 -0800 | [diff] [blame] | 584 | memset(&ctrl, 0, sizeof(ctrl)); |
| 585 | ctrl.ep = endpoint; |
| 586 | ctrl.len = length; |
| 587 | ctrl.data = buffer; |
| 588 | ctrl.timeout = timeout; |
| 589 | return ioctl(device->fd, USBDEVFS_BULK, &ctrl); |
| 590 | } |
| 591 | |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 592 | struct usb_request *usb_request_new(struct usb_device *dev, |
| 593 | const struct usb_endpoint_descriptor *ep_desc) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 594 | { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 595 | struct usbdevfs_urb *urb = calloc(1, sizeof(struct usbdevfs_urb)); |
| 596 | if (!urb) |
| 597 | return NULL; |
| 598 | |
| 599 | if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) |
| 600 | urb->type = USBDEVFS_URB_TYPE_BULK; |
| 601 | else if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) |
| 602 | urb->type = USBDEVFS_URB_TYPE_INTERRUPT; |
| 603 | else { |
| 604 | D("Unsupported endpoint type %d", ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK); |
| 605 | free(urb); |
| 606 | return NULL; |
| 607 | } |
| 608 | urb->endpoint = ep_desc->bEndpointAddress; |
| 609 | |
| 610 | struct usb_request *req = calloc(1, sizeof(struct usb_request)); |
| 611 | if (!req) { |
| 612 | free(urb); |
| 613 | return NULL; |
| 614 | } |
| 615 | |
| 616 | req->dev = dev; |
| 617 | req->max_packet_size = __le16_to_cpu(ep_desc->wMaxPacketSize); |
| 618 | req->private_data = urb; |
Mike Lockwood | b5d68a3 | 2011-02-14 08:05:40 -0500 | [diff] [blame] | 619 | req->endpoint = urb->endpoint; |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 620 | urb->usercontext = req; |
| 621 | |
| 622 | return req; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 623 | } |
| 624 | |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 625 | void usb_request_free(struct usb_request *req) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 626 | { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 627 | free(req->private_data); |
| 628 | free(req); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 629 | } |
| 630 | |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 631 | int usb_request_queue(struct usb_request *req) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 632 | { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 633 | struct usbdevfs_urb *urb = (struct usbdevfs_urb*)req->private_data; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 634 | int res; |
| 635 | |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 636 | urb->status = -1; |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 637 | urb->buffer = req->buffer; |
Mike Lockwood | c4c00d8 | 2011-03-12 12:25:11 -0500 | [diff] [blame] | 638 | // need to limit request size to avoid EINVAL |
| 639 | if (req->buffer_length > MAX_USBFS_BUFFER_SIZE) |
| 640 | urb->buffer_length = MAX_USBFS_BUFFER_SIZE; |
| 641 | else |
| 642 | urb->buffer_length = req->buffer_length; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 643 | |
| 644 | do { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 645 | res = ioctl(req->dev->fd, USBDEVFS_SUBMITURB, urb); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 646 | } while((res < 0) && (errno == EINTR)); |
| 647 | |
| 648 | return res; |
| 649 | } |
| 650 | |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 651 | struct usb_request *usb_request_wait(struct usb_device *dev) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 652 | { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 653 | struct usbdevfs_urb *urb = NULL; |
| 654 | struct usb_request *req = NULL; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 655 | |
| 656 | while (1) { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 657 | int res = ioctl(dev->fd, USBDEVFS_REAPURB, &urb); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 658 | D("USBDEVFS_REAPURB returned %d\n", res); |
| 659 | if (res < 0) { |
| 660 | if(errno == EINTR) { |
| 661 | continue; |
| 662 | } |
| 663 | D("[ reap urb - error ]\n"); |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 664 | return NULL; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 665 | } else { |
| 666 | D("[ urb @%p status = %d, actual = %d ]\n", |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 667 | urb, urb->status, urb->actual_length); |
| 668 | req = (struct usb_request*)urb->usercontext; |
| 669 | req->actual_length = urb->actual_length; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 670 | } |
| 671 | break; |
| 672 | } |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 673 | return req; |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 674 | } |
| 675 | |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 676 | int usb_request_cancel(struct usb_request *req) |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 677 | { |
Mike Lockwood | e533c5f | 2011-01-04 20:04:36 -0500 | [diff] [blame] | 678 | struct usbdevfs_urb *urb = ((struct usbdevfs_urb*)req->private_data); |
| 679 | return ioctl(req->dev->fd, USBDEVFS_DISCARDURB, &urb); |
Mike Lockwood | 30ff2c7 | 2010-05-09 16:23:47 -0400 | [diff] [blame] | 680 | } |
| 681 | |