1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <string.h>
33
34 #include <sys/ioctl.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <dirent.h>
38 #include <fcntl.h>
39 #include <errno.h>
40 #include <pthread.h>
41 #include <ctype.h>
42
43 #include <linux/usbdevice_fs.h>
44 #include <linux/usbdevice_fs.h>
45 #include <linux/version.h>
46 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20)
47 #include <linux/usb/ch9.h>
48 #else
49 #include <linux/usb_ch9.h>
50 #endif
51 #include <asm/byteorder.h>
52
53 #include "usb.h"
54
55 #define MAX_RETRIES 5
56
57 #ifdef TRACE_USB
58 #define DBG1(x...) fprintf(stderr, x)
59 #define DBG(x...) fprintf(stderr, x)
60 #else
61 #define DBG(x...)
62 #define DBG1(x...)
63 #endif
64
65 /* The max bulk size for linux is 16384 which is defined
66 * in drivers/usb/core/devio.c.
67 */
68 #define MAX_USBFS_BULK_SIZE (16 * 1024)
69
70 struct usb_handle
71 {
72 char fname[64];
73 int desc;
74 unsigned char ep_in;
75 unsigned char ep_out;
76 };
77
badname(const char * name)78 static inline int badname(const char *name)
79 {
80 while(*name) {
81 if(!isdigit(*name++)) return 1;
82 }
83 return 0;
84 }
85
check(void * _desc,int len,unsigned type,int size)86 static int check(void *_desc, int len, unsigned type, int size)
87 {
88 unsigned char *desc = _desc;
89
90 if(len < size) return -1;
91 if(desc[0] < size) return -1;
92 if(desc[0] > len) return -1;
93 if(desc[1] != type) return -1;
94
95 return 0;
96 }
97
filter_usb_device(int fd,char * ptr,int len,int writable,ifc_match_func callback,int * ept_in_id,int * ept_out_id,int * ifc_id)98 static int filter_usb_device(int fd, char *ptr, int len, int writable,
99 ifc_match_func callback,
100 int *ept_in_id, int *ept_out_id, int *ifc_id)
101 {
102 struct usb_device_descriptor *dev;
103 struct usb_config_descriptor *cfg;
104 struct usb_interface_descriptor *ifc;
105 struct usb_endpoint_descriptor *ept;
106 struct usb_ifc_info info;
107
108 int in, out;
109 unsigned i;
110 unsigned e;
111
112 struct stat st;
113 int result;
114
115 if(check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
116 return -1;
117 dev = (void*) ptr;
118 len -= dev->bLength;
119 ptr += dev->bLength;
120
121 if(check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
122 return -1;
123 cfg = (void*) ptr;
124 len -= cfg->bLength;
125 ptr += cfg->bLength;
126
127 info.dev_vendor = dev->idVendor;
128 info.dev_product = dev->idProduct;
129 info.dev_class = dev->bDeviceClass;
130 info.dev_subclass = dev->bDeviceSubClass;
131 info.dev_protocol = dev->bDeviceProtocol;
132 info.writable = writable;
133
134 // read device serial number (if there is one)
135 info.serial_number[0] = 0;
136 if (dev->iSerialNumber) {
137 struct usbdevfs_ctrltransfer ctrl;
138 // Keep it short enough because some bootloaders are borked if the URB len is > 255
139 // 128 is too big by 1.
140 __u16 buffer[127];
141
142 memset(buffer, 0, sizeof(buffer));
143
144 ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE;
145 ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
146 ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber;
147 //language ID (en-us) for serial number string
148 ctrl.wIndex = 0x0409;
149 ctrl.wLength = sizeof(buffer);
150 ctrl.data = buffer;
151 ctrl.timeout = 50;
152
153 result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
154 if (result > 0) {
155 int i;
156 // skip first word, and copy the rest to the serial string, changing shorts to bytes.
157 result /= 2;
158 for (i = 1; i < result; i++)
159 info.serial_number[i - 1] = buffer[i];
160 info.serial_number[i - 1] = 0;
161 }
162 }
163
164 /* We need to get a path that represents a particular port on a particular
165 * hub. We are passed an fd that was obtained by opening an entry under
166 * /dev/bus/usb. Unfortunately, the names of those entries change each
167 * time devices are plugged and unplugged. So how to get a repeatable
168 * path? udevadm provided the inspiration. We can get the major and
169 * minor of the device file, read the symlink that can be found here:
170 * /sys/dev/char/<major>:<minor>
171 * and then use the last element of that path. As a concrete example, I
172 * have an Android device at /dev/bus/usb/001/027 so working with bash:
173 * $ ls -l /dev/bus/usb/001/027
174 * crw-rw-r-- 1 root plugdev 189, 26 Apr 9 11:03 /dev/bus/usb/001/027
175 * $ ls -l /sys/dev/char/189:26
176 * lrwxrwxrwx 1 root root 0 Apr 9 11:03 /sys/dev/char/189:26 ->
177 * ../../devices/pci0000:00/0000:00:1a.7/usb1/1-4/1-4.2/1-4.2.3
178 * So our device_path would be 1-4.2.3 which says my device is connected
179 * to port 3 of a hub on port 2 of a hub on port 4 of bus 1 (per
180 * http://www.linux-usb.org/FAQ.html).
181 */
182 info.device_path[0] = '\0';
183 result = fstat(fd, &st);
184 if (!result && S_ISCHR(st.st_mode)) {
185 char cdev[128];
186 char link[256];
187 char *slash;
188 ssize_t link_len;
189 snprintf(cdev, sizeof(cdev), "/sys/dev/char/%d:%d",
190 major(st.st_rdev), minor(st.st_rdev));
191 link_len = readlink(cdev, link, sizeof(link) - 1);
192 if (link_len > 0) {
193 link[link_len] = '\0';
194 slash = strrchr(link, '/');
195 if (slash)
196 snprintf(info.device_path, sizeof(info.device_path), "usb:%s", slash+1);
197 }
198 }
199
200 for(i = 0; i < cfg->bNumInterfaces; i++) {
201 if(check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE))
202 return -1;
203 ifc = (void*) ptr;
204 len -= ifc->bLength;
205 ptr += ifc->bLength;
206
207 in = -1;
208 out = -1;
209 info.ifc_class = ifc->bInterfaceClass;
210 info.ifc_subclass = ifc->bInterfaceSubClass;
211 info.ifc_protocol = ifc->bInterfaceProtocol;
212
213 for(e = 0; e < ifc->bNumEndpoints; e++) {
214 if(check(ptr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE))
215 return -1;
216 ept = (void*) ptr;
217 len -= ept->bLength;
218 ptr += ept->bLength;
219
220 if((ept->bmAttributes & 0x03) != 0x02)
221 continue;
222
223 if(ept->bEndpointAddress & 0x80) {
224 in = ept->bEndpointAddress;
225 } else {
226 out = ept->bEndpointAddress;
227 }
228 }
229
230 info.has_bulk_in = (in != -1);
231 info.has_bulk_out = (out != -1);
232
233 if(callback(&info) == 0) {
234 *ept_in_id = in;
235 *ept_out_id = out;
236 *ifc_id = ifc->bInterfaceNumber;
237 return 0;
238 }
239 }
240
241 return -1;
242 }
243
find_usb_device(const char * base,ifc_match_func callback)244 static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
245 {
246 usb_handle *usb = 0;
247 char busname[64], devname[64];
248 char desc[1024];
249 int n, in, out, ifc;
250
251 DIR *busdir, *devdir;
252 struct dirent *de;
253 int fd;
254 int writable;
255
256 busdir = opendir(base);
257 if(busdir == 0) return 0;
258
259 while((de = readdir(busdir)) && (usb == 0)) {
260 if(badname(de->d_name)) continue;
261
262 sprintf(busname, "%s/%s", base, de->d_name);
263 devdir = opendir(busname);
264 if(devdir == 0) continue;
265
266 // DBG("[ scanning %s ]\n", busname);
267 while((de = readdir(devdir)) && (usb == 0)) {
268
269 if(badname(de->d_name)) continue;
270 sprintf(devname, "%s/%s", busname, de->d_name);
271
272 // DBG("[ scanning %s ]\n", devname);
273 writable = 1;
274 if((fd = open(devname, O_RDWR)) < 0) {
275 // Check if we have read-only access, so we can give a helpful
276 // diagnostic like "adb devices" does.
277 writable = 0;
278 if((fd = open(devname, O_RDONLY)) < 0) {
279 continue;
280 }
281 }
282
283 n = read(fd, desc, sizeof(desc));
284
285 if(filter_usb_device(fd, desc, n, writable, callback,
286 &in, &out, &ifc) == 0) {
287 usb = calloc(1, sizeof(usb_handle));
288 strcpy(usb->fname, devname);
289 usb->ep_in = in;
290 usb->ep_out = out;
291 usb->desc = fd;
292
293 n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
294 if(n != 0) {
295 close(fd);
296 free(usb);
297 usb = 0;
298 continue;
299 }
300 } else {
301 close(fd);
302 }
303 }
304 closedir(devdir);
305 }
306 closedir(busdir);
307
308 return usb;
309 }
310
usb_write(usb_handle * h,const void * _data,int len)311 int usb_write(usb_handle *h, const void *_data, int len)
312 {
313 unsigned char *data = (unsigned char*) _data;
314 unsigned count = 0;
315 struct usbdevfs_bulktransfer bulk;
316 int n;
317
318 if(h->ep_out == 0) {
319 return -1;
320 }
321
322 if(len == 0) {
323 bulk.ep = h->ep_out;
324 bulk.len = 0;
325 bulk.data = data;
326 bulk.timeout = 0;
327
328 n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
329 if(n != 0) {
330 fprintf(stderr,"ERROR: n = %d, errno = %d (%s)\n",
331 n, errno, strerror(errno));
332 return -1;
333 }
334 return 0;
335 }
336
337 while(len > 0) {
338 int xfer;
339 xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
340
341 bulk.ep = h->ep_out;
342 bulk.len = xfer;
343 bulk.data = data;
344 bulk.timeout = 0;
345
346 n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
347 if(n != xfer) {
348 DBG("ERROR: n = %d, errno = %d (%s)\n",
349 n, errno, strerror(errno));
350 return -1;
351 }
352
353 count += xfer;
354 len -= xfer;
355 data += xfer;
356 }
357
358 return count;
359 }
360
usb_read(usb_handle * h,void * _data,int len)361 int usb_read(usb_handle *h, void *_data, int len)
362 {
363 unsigned char *data = (unsigned char*) _data;
364 unsigned count = 0;
365 struct usbdevfs_bulktransfer bulk;
366 int n, retry;
367
368 if(h->ep_in == 0) {
369 return -1;
370 }
371
372 while(len > 0) {
373 int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
374
375 bulk.ep = h->ep_in;
376 bulk.len = xfer;
377 bulk.data = data;
378 bulk.timeout = 0;
379 retry = 0;
380
381 do{
382 DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
383 n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
384 DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
385
386 if( n < 0 ) {
387 DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
388 if ( ++retry > MAX_RETRIES ) return -1;
389 sleep( 1 );
390 }
391 }
392 while( n < 0 );
393
394 count += n;
395 len -= n;
396 data += n;
397
398 if(n < xfer) {
399 break;
400 }
401 }
402
403 return count;
404 }
405
usb_kick(usb_handle * h)406 void usb_kick(usb_handle *h)
407 {
408 int fd;
409
410 fd = h->desc;
411 h->desc = -1;
412 if(fd >= 0) {
413 close(fd);
414 DBG("[ usb closed %d ]\n", fd);
415 }
416 }
417
usb_close(usb_handle * h)418 int usb_close(usb_handle *h)
419 {
420 int fd;
421
422 fd = h->desc;
423 h->desc = -1;
424 if(fd >= 0) {
425 close(fd);
426 DBG("[ usb closed %d ]\n", fd);
427 }
428
429 return 0;
430 }
431
usb_open(ifc_match_func callback)432 usb_handle *usb_open(ifc_match_func callback)
433 {
434 return find_usb_device("/dev/bus/usb", callback);
435 }
436