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