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 "fastboot.h"
54 #include "usb.h"
55
56 #define MAX_RETRIES 5
57
58 /* Timeout in seconds for usb_wait_for_disconnect.
59 * It doesn't usually take long for a device to disconnect (almost always
60 * under 2 seconds) but we'll time out after 3 seconds just in case.
61 */
62 #define WAIT_FOR_DISCONNECT_TIMEOUT 3
63
64 #ifdef TRACE_USB
65 #define DBG1(x...) fprintf(stderr, x)
66 #define DBG(x...) fprintf(stderr, x)
67 #else
68 #define DBG(x...)
69 #define DBG1(x...)
70 #endif
71
72 /* The max bulk size for linux is 16384 which is defined
73 * in drivers/usb/core/devio.c.
74 */
75 #define MAX_USBFS_BULK_SIZE (16 * 1024)
76
77 struct usb_handle
78 {
79 char fname[64];
80 int desc;
81 unsigned char ep_in;
82 unsigned char ep_out;
83 };
84
85 /* True if name isn't a valid name for a USB device in /sys/bus/usb/devices.
86 * Device names are made up of numbers, dots, and dashes, e.g., '7-1.5'.
87 * We reject interfaces (e.g., '7-1.5:1.0') and host controllers (e.g. 'usb1').
88 * The name must also start with a digit, to disallow '.' and '..'
89 */
badname(const char * name)90 static inline int badname(const char *name)
91 {
92 if (!isdigit(*name))
93 return 1;
94 while(*++name) {
95 if(!isdigit(*name) && *name != '.' && *name != '-')
96 return 1;
97 }
98 return 0;
99 }
100
check(void * _desc,int len,unsigned type,int size)101 static int check(void *_desc, int len, unsigned type, int size)
102 {
103 struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)_desc;
104
105 if(len < size) return -1;
106 if(hdr->bLength < size) return -1;
107 if(hdr->bLength > len) return -1;
108 if(hdr->bDescriptorType != type) return -1;
109
110 return 0;
111 }
112
filter_usb_device(char * sysfs_name,char * ptr,int len,int writable,ifc_match_func callback,int * ept_in_id,int * ept_out_id,int * ifc_id)113 static int filter_usb_device(char* sysfs_name,
114 char *ptr, int len, int writable,
115 ifc_match_func callback,
116 int *ept_in_id, int *ept_out_id, int *ifc_id)
117 {
118 struct usb_device_descriptor *dev;
119 struct usb_config_descriptor *cfg;
120 struct usb_interface_descriptor *ifc;
121 struct usb_endpoint_descriptor *ept;
122 struct usb_ifc_info info;
123
124 int in, out;
125 unsigned i;
126 unsigned e;
127
128 if (check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
129 return -1;
130 dev = (struct usb_device_descriptor *)ptr;
131 len -= dev->bLength;
132 ptr += dev->bLength;
133
134 if (check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
135 return -1;
136 cfg = (struct usb_config_descriptor *)ptr;
137 len -= cfg->bLength;
138 ptr += cfg->bLength;
139
140 info.dev_vendor = dev->idVendor;
141 info.dev_product = dev->idProduct;
142 info.dev_class = dev->bDeviceClass;
143 info.dev_subclass = dev->bDeviceSubClass;
144 info.dev_protocol = dev->bDeviceProtocol;
145 info.writable = writable;
146
147 snprintf(info.device_path, sizeof(info.device_path), "usb:%s", sysfs_name);
148
149 /* Read device serial number (if there is one).
150 * We read the serial number from sysfs, since it's faster and more
151 * reliable than issuing a control pipe read, and also won't
152 * cause problems for devices which don't like getting descriptor
153 * requests while they're in the middle of flashing.
154 */
155 info.serial_number[0] = '\0';
156 if (dev->iSerialNumber) {
157 char path[80];
158 int fd;
159
160 snprintf(path, sizeof(path),
161 "/sys/bus/usb/devices/%s/serial", sysfs_name);
162 path[sizeof(path) - 1] = '\0';
163
164 fd = open(path, O_RDONLY);
165 if (fd >= 0) {
166 int chars_read = read(fd, info.serial_number,
167 sizeof(info.serial_number) - 1);
168 close(fd);
169
170 if (chars_read <= 0)
171 info.serial_number[0] = '\0';
172 else if (info.serial_number[chars_read - 1] == '\n') {
173 // strip trailing newline
174 info.serial_number[chars_read - 1] = '\0';
175 }
176 }
177 }
178
179 for(i = 0; i < cfg->bNumInterfaces; i++) {
180
181 while (len > 0) {
182 struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)ptr;
183 if (check(hdr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE) == 0)
184 break;
185 len -= hdr->bLength;
186 ptr += hdr->bLength;
187 }
188
189 if (len <= 0)
190 return -1;
191
192 ifc = (struct usb_interface_descriptor *)ptr;
193 len -= ifc->bLength;
194 ptr += ifc->bLength;
195
196 in = -1;
197 out = -1;
198 info.ifc_class = ifc->bInterfaceClass;
199 info.ifc_subclass = ifc->bInterfaceSubClass;
200 info.ifc_protocol = ifc->bInterfaceProtocol;
201
202 for(e = 0; e < ifc->bNumEndpoints; e++) {
203 while (len > 0) {
204 struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)ptr;
205 if (check(hdr, len, USB_DT_ENDPOINT, USB_DT_ENDPOINT_SIZE) == 0)
206 break;
207 len -= hdr->bLength;
208 ptr += hdr->bLength;
209 }
210 if (len < 0) {
211 break;
212 }
213
214 ept = (struct usb_endpoint_descriptor *)ptr;
215 len -= ept->bLength;
216 ptr += ept->bLength;
217
218 if((ept->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK)
219 continue;
220
221 if(ept->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
222 in = ept->bEndpointAddress;
223 } else {
224 out = ept->bEndpointAddress;
225 }
226
227 // For USB 3.0 devices skip the SS Endpoint Companion descriptor
228 if (check((struct usb_descriptor_hdr *)ptr, len,
229 USB_DT_SS_ENDPOINT_COMP, USB_DT_SS_EP_COMP_SIZE) == 0) {
230 len -= USB_DT_SS_EP_COMP_SIZE;
231 ptr += USB_DT_SS_EP_COMP_SIZE;
232 }
233 }
234
235 info.has_bulk_in = (in != -1);
236 info.has_bulk_out = (out != -1);
237
238 if(callback(&info) == 0) {
239 *ept_in_id = in;
240 *ept_out_id = out;
241 *ifc_id = ifc->bInterfaceNumber;
242 return 0;
243 }
244 }
245
246 return -1;
247 }
248
read_sysfs_string(const char * sysfs_name,const char * sysfs_node,char * buf,int bufsize)249 static int read_sysfs_string(const char *sysfs_name, const char *sysfs_node,
250 char* buf, int bufsize)
251 {
252 char path[80];
253 int fd, n;
254
255 snprintf(path, sizeof(path),
256 "/sys/bus/usb/devices/%s/%s", sysfs_name, sysfs_node);
257 path[sizeof(path) - 1] = '\0';
258
259 fd = open(path, O_RDONLY);
260 if (fd < 0)
261 return -1;
262
263 n = read(fd, buf, bufsize - 1);
264 close(fd);
265
266 if (n < 0)
267 return -1;
268
269 buf[n] = '\0';
270
271 return n;
272 }
273
read_sysfs_number(const char * sysfs_name,const char * sysfs_node)274 static int read_sysfs_number(const char *sysfs_name, const char *sysfs_node)
275 {
276 char buf[16];
277 int value;
278
279 if (read_sysfs_string(sysfs_name, sysfs_node, buf, sizeof(buf)) < 0)
280 return -1;
281
282 if (sscanf(buf, "%d", &value) != 1)
283 return -1;
284
285 return value;
286 }
287
288 /* Given the name of a USB device in sysfs, get the name for the same
289 * device in devfs. Returns 0 for success, -1 for failure.
290 */
convert_to_devfs_name(const char * sysfs_name,char * devname,int devname_size)291 static int convert_to_devfs_name(const char* sysfs_name,
292 char* devname, int devname_size)
293 {
294 int busnum, devnum;
295
296 busnum = read_sysfs_number(sysfs_name, "busnum");
297 if (busnum < 0)
298 return -1;
299
300 devnum = read_sysfs_number(sysfs_name, "devnum");
301 if (devnum < 0)
302 return -1;
303
304 snprintf(devname, devname_size, "/dev/bus/usb/%03d/%03d", busnum, devnum);
305 return 0;
306 }
307
find_usb_device(const char * base,ifc_match_func callback)308 static usb_handle *find_usb_device(const char *base, ifc_match_func callback)
309 {
310 usb_handle *usb = 0;
311 char devname[64];
312 char desc[1024];
313 int n, in, out, ifc;
314
315 DIR *busdir;
316 struct dirent *de;
317 int fd;
318 int writable;
319
320 busdir = opendir(base);
321 if(busdir == 0) return 0;
322
323 while((de = readdir(busdir)) && (usb == 0)) {
324 if(badname(de->d_name)) continue;
325
326 if(!convert_to_devfs_name(de->d_name, devname, sizeof(devname))) {
327
328 // DBG("[ scanning %s ]\n", devname);
329 writable = 1;
330 if((fd = open(devname, O_RDWR)) < 0) {
331 // Check if we have read-only access, so we can give a helpful
332 // diagnostic like "adb devices" does.
333 writable = 0;
334 if((fd = open(devname, O_RDONLY)) < 0) {
335 continue;
336 }
337 }
338
339 n = read(fd, desc, sizeof(desc));
340
341 if(filter_usb_device(de->d_name, desc, n, writable, callback,
342 &in, &out, &ifc) == 0) {
343 usb = calloc(1, sizeof(usb_handle));
344 strcpy(usb->fname, devname);
345 usb->ep_in = in;
346 usb->ep_out = out;
347 usb->desc = fd;
348
349 n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
350 if(n != 0) {
351 close(fd);
352 free(usb);
353 usb = 0;
354 continue;
355 }
356 } else {
357 close(fd);
358 }
359 }
360 }
361 closedir(busdir);
362
363 return usb;
364 }
365
usb_write(usb_handle * h,const void * _data,int len)366 int usb_write(usb_handle *h, const void *_data, int len)
367 {
368 unsigned char *data = (unsigned char*) _data;
369 unsigned count = 0;
370 struct usbdevfs_bulktransfer bulk;
371 int n;
372
373 if(h->ep_out == 0 || h->desc == -1) {
374 return -1;
375 }
376
377 do {
378 int xfer;
379 xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
380
381 bulk.ep = h->ep_out;
382 bulk.len = xfer;
383 bulk.data = data;
384 bulk.timeout = 0;
385
386 n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
387 if(n != xfer) {
388 DBG("ERROR: n = %d, errno = %d (%s)\n",
389 n, errno, strerror(errno));
390 return -1;
391 }
392
393 count += xfer;
394 len -= xfer;
395 data += xfer;
396 } while(len > 0);
397
398 return count;
399 }
400
usb_read(usb_handle * h,void * _data,int len)401 int usb_read(usb_handle *h, void *_data, int len)
402 {
403 unsigned char *data = (unsigned char*) _data;
404 unsigned count = 0;
405 struct usbdevfs_bulktransfer bulk;
406 int n, retry;
407
408 if(h->ep_in == 0 || h->desc == -1) {
409 return -1;
410 }
411
412 while(len > 0) {
413 int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
414
415 bulk.ep = h->ep_in;
416 bulk.len = xfer;
417 bulk.data = data;
418 bulk.timeout = 0;
419 retry = 0;
420
421 do{
422 DBG("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname);
423 n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
424 DBG("[ usb read %d ] = %d, fname=%s, Retry %d \n", xfer, n, h->fname, retry);
425
426 if( n < 0 ) {
427 DBG1("ERROR: n = %d, errno = %d (%s)\n",n, errno, strerror(errno));
428 if ( ++retry > MAX_RETRIES ) return -1;
429 sleep( 1 );
430 }
431 }
432 while( n < 0 );
433
434 count += n;
435 len -= n;
436 data += n;
437
438 if(n < xfer) {
439 break;
440 }
441 }
442
443 return count;
444 }
445
usb_kick(usb_handle * h)446 void usb_kick(usb_handle *h)
447 {
448 int fd;
449
450 fd = h->desc;
451 h->desc = -1;
452 if(fd >= 0) {
453 close(fd);
454 DBG("[ usb closed %d ]\n", fd);
455 }
456 }
457
usb_close(usb_handle * h)458 int usb_close(usb_handle *h)
459 {
460 int fd;
461
462 fd = h->desc;
463 h->desc = -1;
464 if(fd >= 0) {
465 close(fd);
466 DBG("[ usb closed %d ]\n", fd);
467 }
468
469 return 0;
470 }
471
usb_open(ifc_match_func callback)472 usb_handle *usb_open(ifc_match_func callback)
473 {
474 return find_usb_device("/sys/bus/usb/devices", callback);
475 }
476
477 /* Wait for the system to notice the device is gone, so that a subsequent
478 * fastboot command won't try to access the device before it's rebooted.
479 * Returns 0 for success, -1 for timeout.
480 */
usb_wait_for_disconnect(usb_handle * usb)481 int usb_wait_for_disconnect(usb_handle *usb)
482 {
483 double deadline = now() + WAIT_FOR_DISCONNECT_TIMEOUT;
484 while (now() < deadline) {
485 if (access(usb->fname, F_OK))
486 return 0;
487 usleep(50000);
488 }
489 return -1;
490 }
491