usb_libusb.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656
  1. /*
  2. * Copyright (C) 2009 bsdroid project
  3. * Alexey Tarasov <tarasov@dodologics.com>
  4. *
  5. * Copyright (C) 2007 The Android Open Source Project
  6. *
  7. * Licensed under the Apache License, Version 2.0 (the "License");
  8. * you may not use this file except in compliance with the License.
  9. * You may obtain a copy of the License at
  10. *
  11. * http://www.apache.org/licenses/LICENSE-2.0
  12. *
  13. * Unless required by applicable law or agreed to in writing, software
  14. * distributed under the License is distributed on an "AS IS" BASIS,
  15. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16. * See the License for the specific language governing permissions and
  17. * limitations under the License.
  18. */
  19. #include <sys/endian.h>
  20. #include <sys/ioctl.h>
  21. #include <sys/types.h>
  22. #include <sys/uio.h>
  23. #include <err.h>
  24. #include <errno.h>
  25. #include <poll.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <strings.h>
  29. #include <string.h>
  30. #include <sysexits.h>
  31. #include <unistd.h>
  32. #include <libusb.h>
  33. #include "sysdeps.h"
  34. #define TRACE_TAG TRACE_USB
  35. #include "adb.h"
  36. static adb_mutex_t usb_lock = ADB_MUTEX_INITIALIZER;
  37. static libusb_context *ctx = NULL;
  38. struct usb_handle
  39. {
  40. usb_handle *prev;
  41. usb_handle *next;
  42. libusb_device *dev;
  43. libusb_device_handle *devh;
  44. int interface;
  45. uint8_t dev_bus;
  46. uint8_t dev_addr;
  47. int zero_mask;
  48. unsigned char end_point_address[2];
  49. char serial[128];
  50. adb_cond_t notify;
  51. adb_mutex_t lock;
  52. };
  53. static struct usb_handle handle_list = {
  54. .prev = &handle_list,
  55. .next = &handle_list,
  56. };
  57. void
  58. usb_cleanup()
  59. {
  60. libusb_exit(ctx);
  61. }
  62. void
  63. report_bulk_libusb_error(int r)
  64. {
  65. switch (r) {
  66. case LIBUSB_ERROR_TIMEOUT:
  67. D("Transfer timeout\n");
  68. break;
  69. case LIBUSB_ERROR_PIPE:
  70. D("Control request is not supported\n");
  71. break;
  72. case LIBUSB_ERROR_OVERFLOW:
  73. D("Device offered more data\n");
  74. break;
  75. case LIBUSB_ERROR_NO_DEVICE :
  76. D("Device was disconnected\n");
  77. break;
  78. default:
  79. D("Error %d during transfer\n", r);
  80. break;
  81. };
  82. }
  83. static int
  84. usb_bulk_write(usb_handle *uh, const void *data, int len)
  85. {
  86. int r = 0;
  87. int transferred = 0;
  88. r = libusb_bulk_transfer(uh->devh, uh->end_point_address[1], (void *)data, len,
  89. &transferred, 0);
  90. if (r != 0) {
  91. D("usb_bulk_write(): ");
  92. report_bulk_libusb_error(r);
  93. return r;
  94. }
  95. return (transferred);
  96. }
  97. static int
  98. usb_bulk_read(usb_handle *uh, void *data, int len)
  99. {
  100. int r = 0;
  101. int transferred = 0;
  102. r = libusb_bulk_transfer(uh->devh, uh->end_point_address[0], data, len,
  103. &transferred, 0);
  104. if (r != 0) {
  105. D("usb_bulk_read(): ");
  106. report_bulk_libusb_error(r);
  107. return r;
  108. }
  109. return (transferred);
  110. }
  111. int
  112. usb_write(struct usb_handle *uh, const void *_data, int len)
  113. {
  114. unsigned char *data = (unsigned char*) _data;
  115. int n;
  116. int need_zero = 0;
  117. if (uh->zero_mask == 1) {
  118. if (!(len & uh->zero_mask)) {
  119. need_zero = 1;
  120. }
  121. }
  122. D("usb_write(): %p:%d -> transport %p\n", _data, len, uh);
  123. while (len > 0) {
  124. int xfer = (len > 4096) ? 4096 : len;
  125. n = usb_bulk_write(uh, data, xfer);
  126. if (n != xfer) {
  127. D("usb_write(): failed for transport %p (%d bytes left)\n", uh, len);
  128. return -1;
  129. }
  130. len -= xfer;
  131. data += xfer;
  132. }
  133. if (need_zero){
  134. n = usb_bulk_write(uh, _data, 0);
  135. if (n < 0) {
  136. D("usb_write(): failed to finish operation for transport %p\n", uh);
  137. }
  138. return n;
  139. }
  140. return 0;
  141. }
  142. int
  143. usb_read(struct usb_handle *uh, void *_data, int len)
  144. {
  145. unsigned char *data = (unsigned char*) _data;
  146. int n;
  147. D("usb_read(): %p:%d <- transport %p\n", _data, len, uh);
  148. while (len > 0) {
  149. int xfer = (len > 4096) ? 4096 : len;
  150. n = usb_bulk_read(uh, data, xfer);
  151. if (n != xfer) {
  152. if (n > 0) {
  153. data += n;
  154. len -= n;
  155. continue;
  156. }
  157. D("usb_read(): failed for transport %p (%d bytes left)\n", uh, len);
  158. return -1;
  159. }
  160. len -= xfer;
  161. data += xfer;
  162. }
  163. return 0;
  164. }
  165. int
  166. usb_close(struct usb_handle *h)
  167. {
  168. D("usb_close(): closing transport %p\n", h);
  169. adb_mutex_lock(&usb_lock);
  170. h->next->prev = h->prev;
  171. h->prev->next = h->next;
  172. h->prev = NULL;
  173. h->next = NULL;
  174. libusb_release_interface(h->devh, h->interface);
  175. libusb_close(h->devh);
  176. libusb_unref_device(h->dev);
  177. adb_mutex_unlock(&usb_lock);
  178. free(h);
  179. return (0);
  180. }
  181. void usb_kick(struct usb_handle *h)
  182. {
  183. D("usb_cick(): kicking transport %p\n", h);
  184. adb_mutex_lock(&h->lock);
  185. unregister_usb_transport(h);
  186. adb_mutex_unlock(&h->lock);
  187. h->next->prev = h->prev;
  188. h->prev->next = h->next;
  189. h->prev = NULL;
  190. h->next = NULL;
  191. libusb_release_interface(h->devh, h->interface);
  192. libusb_close(h->devh);
  193. libusb_unref_device(h->dev);
  194. free(h);
  195. }
  196. int
  197. check_usb_interface(libusb_interface *interface,
  198. libusb_device_descriptor *desc,
  199. struct usb_handle *uh)
  200. {
  201. int e;
  202. if (interface->num_altsetting == 0) {
  203. D("check_usb_interface(): No interface settings\n");
  204. return -1;
  205. }
  206. libusb_interface_descriptor *idesc = &interface->altsetting[0];
  207. if (idesc->bNumEndpoints != 2) {
  208. D("check_usb_interface(): Interface have not 2 endpoints, ignoring\n");
  209. return -1;
  210. }
  211. for (e = 0; e < idesc->bNumEndpoints; e++) {
  212. libusb_endpoint_descriptor *edesc = &idesc->endpoint[e];
  213. if (edesc->bmAttributes != LIBUSB_TRANSFER_TYPE_BULK) {
  214. D("check_usb_interface(): Endpoint (%u) is not bulk (%u), ignoring\n",
  215. edesc->bmAttributes, LIBUSB_TRANSFER_TYPE_BULK);
  216. return -1;
  217. }
  218. if (edesc->bEndpointAddress & LIBUSB_ENDPOINT_IN)
  219. uh->end_point_address[0] = edesc->bEndpointAddress;
  220. else
  221. uh->end_point_address[1] = edesc->bEndpointAddress;
  222. /* aproto 01 needs 0 termination */
  223. if (idesc->bInterfaceProtocol == 0x01) {
  224. uh->zero_mask = edesc->wMaxPacketSize - 1;
  225. D("check_usb_interface(): Forced Android interface protocol v.1\n");
  226. }
  227. }
  228. D("check_usb_interface(): Device: %04x:%04x "
  229. "iclass: %x, isclass: %x, iproto: %x ep: %x/%x-> ",
  230. desc->idVendor, desc->idProduct, idesc->bInterfaceClass,
  231. idesc->bInterfaceSubClass, idesc->bInterfaceProtocol,
  232. uh->end_point_address[0], uh->end_point_address[1]);
  233. if (!is_adb_interface(desc->idVendor, desc->idProduct,
  234. idesc->bInterfaceClass, idesc->bInterfaceSubClass,
  235. idesc->bInterfaceProtocol))
  236. {
  237. D("not matches\n");
  238. return -1;
  239. }
  240. D("matches\n");
  241. return 1;
  242. }
  243. int
  244. check_usb_interfaces(libusb_config_descriptor *config,
  245. libusb_device_descriptor *desc, struct usb_handle *uh)
  246. {
  247. int i;
  248. for (i = 0; i < config->bNumInterfaces; ++i) {
  249. if (check_usb_interface(&config->interface[i], desc, uh) != -1) {
  250. /* found some interface and saved information about it */
  251. D("check_usb_interfaces(): Interface %d of %04x:%04x "
  252. "matches Android device\n", i, desc->idVendor,
  253. desc->idProduct);
  254. return i;
  255. }
  256. }
  257. return -1;
  258. }
  259. int
  260. register_device(struct usb_handle *uh, const char *serial)
  261. {
  262. D("register_device(): Registering %p [%s] as USB transport\n",
  263. uh, serial);
  264. struct usb_handle *usb= NULL;
  265. usb = calloc(1, sizeof(struct usb_handle));
  266. memcpy(usb, uh, sizeof(struct usb_handle));
  267. strcpy(usb->serial, uh->serial);
  268. adb_cond_init(&usb->notify, 0);
  269. adb_mutex_init(&usb->lock, 0);
  270. adb_mutex_lock(&usb_lock);
  271. usb->next = &handle_list;
  272. usb->prev = handle_list.prev;
  273. usb->prev->next = usb;
  274. usb->next->prev = usb;
  275. adb_mutex_unlock(&usb_lock);
  276. register_usb_transport(usb, serial, NULL, 1);
  277. return (1);
  278. }
  279. int
  280. already_registered(usb_handle *uh)
  281. {
  282. struct usb_handle *usb= NULL;
  283. int exists = 0;
  284. adb_mutex_lock(&usb_lock);
  285. for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
  286. if ((usb->dev_bus == uh->dev_bus) &&
  287. (usb->dev_addr == uh->dev_addr))
  288. {
  289. exists = 1;
  290. break;
  291. }
  292. }
  293. adb_mutex_unlock(&usb_lock);
  294. return exists;
  295. }
  296. void
  297. check_device(libusb_device *dev)
  298. {
  299. struct usb_handle uh;
  300. int i = 0;
  301. int found = -1;
  302. char serial[256] = {0};
  303. libusb_device_descriptor desc;
  304. libusb_config_descriptor *config = NULL;
  305. int r = libusb_get_device_descriptor(dev, &desc);
  306. if (r != LIBUSB_SUCCESS) {
  307. D("check_device(): Failed to get device descriptor\n");
  308. return;
  309. }
  310. if ((desc.idVendor == 0) && (desc.idProduct == 0))
  311. return;
  312. D("check_device(): Probing usb device %04x:%04x\n",
  313. desc.idVendor, desc.idProduct);
  314. if (!is_adb_interface (desc.idVendor, desc.idProduct,
  315. ADB_CLASS, ADB_SUBCLASS, ADB_PROTOCOL))
  316. {
  317. D("check_device(): Ignored due unknown vendor id\n");
  318. return;
  319. }
  320. uh.dev_bus = libusb_get_bus_number(dev);
  321. uh.dev_addr = libusb_get_device_address(dev);
  322. if (already_registered(&uh)) {
  323. D("check_device(): Device (bus: %d, address: %d) "
  324. "is already registered\n", uh.dev_bus, uh.dev_addr);
  325. return;
  326. }
  327. D("check_device(): Device bus: %d, address: %d\n",
  328. uh.dev_bus, uh.dev_addr);
  329. r = libusb_get_active_config_descriptor(dev, &config);
  330. if (r != 0) {
  331. if (r == LIBUSB_ERROR_NOT_FOUND) {
  332. D("check_device(): Device %4x:%4x is unconfigured\n",
  333. desc.idVendor, desc.idProduct);
  334. return;
  335. }
  336. D("check_device(): Failed to get configuration for %4x:%4x\n",
  337. desc.idVendor, desc.idProduct);
  338. return;
  339. }
  340. if (config == NULL) {
  341. D("check_device(): Sanity check failed after "
  342. "getting active config\n");
  343. return;
  344. }
  345. if (config->interface != NULL) {
  346. found = check_usb_interfaces(config, &desc, &uh);
  347. }
  348. /* not needed anymore */
  349. libusb_free_config_descriptor(config);
  350. r = libusb_open(dev, &uh.devh);
  351. uh.dev = dev;
  352. if (r != 0) {
  353. switch (r) {
  354. case LIBUSB_ERROR_NO_MEM:
  355. D("check_device(): Memory allocation problem\n");
  356. break;
  357. case LIBUSB_ERROR_ACCESS:
  358. D("check_device(): Permissions problem, "
  359. "current user priveleges are messed up?\n");
  360. break;
  361. case LIBUSB_ERROR_NO_DEVICE:
  362. D("check_device(): Device disconected, bad cable?\n");
  363. break;
  364. default:
  365. D("check_device(): libusb triggered error %d\n", r);
  366. }
  367. // skip rest
  368. found = -1;
  369. }
  370. if (found >= 0) {
  371. D("check_device(): Device matches Android interface\n");
  372. // read the device's serial number
  373. memset(serial, 0, sizeof(serial));
  374. uh.interface = found;
  375. r = libusb_claim_interface(uh.devh, uh.interface);
  376. if (r < 0) {
  377. D("check_device(): Failed to claim interface %d\n",
  378. uh.interface);
  379. goto fail;
  380. }
  381. if (desc.iSerialNumber) {
  382. // reading serial
  383. uint16_t buffer[128] = {0};
  384. uint16_t languages[128] = {0};
  385. int languageCount = 0;
  386. memset(languages, 0, sizeof(languages));
  387. r = libusb_control_transfer(uh.devh,
  388. LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
  389. LIBUSB_REQUEST_GET_DESCRIPTOR, LIBUSB_DT_STRING << 8,
  390. 0, (uint8_t *)languages, sizeof(languages), 0);
  391. if (r <= 0) {
  392. D("check_device(): Failed to get languages count\n");
  393. goto fail;
  394. }
  395. languageCount = (r - 2) / 2;
  396. for (i = 1; i <= languageCount; ++i) {
  397. memset(buffer, 0, sizeof(buffer));
  398. r = libusb_control_transfer(uh.devh,
  399. LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
  400. LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc.iSerialNumber,
  401. languages[i], (uint8_t *)buffer, sizeof(buffer), 0);
  402. if (r > 0) { /* converting serial */
  403. int j = 0;
  404. r /= 2;
  405. for (j = 1; j < r; ++j)
  406. serial[j - 1] = buffer[j];
  407. serial[j - 1] = '\0';
  408. break; /* languagesCount cycle */
  409. }
  410. }
  411. if (register_device(&uh, serial) == 0) {
  412. D("check_device(): Failed to register device\n");
  413. goto fail_interface;
  414. }
  415. libusb_ref_device(dev);
  416. }
  417. }
  418. return;
  419. fail_interface:
  420. libusb_release_interface(uh.devh, uh.interface);
  421. fail:
  422. libusb_close(uh.devh);
  423. uh.devh = NULL;
  424. }
  425. int
  426. check_device_connected(struct usb_handle *uh)
  427. {
  428. int r = libusb_kernel_driver_active(uh->devh, uh->interface);
  429. if (r == LIBUSB_ERROR_NO_DEVICE)
  430. return 0;
  431. if (r < 0)
  432. return -1;
  433. return 1;
  434. }
  435. void
  436. kick_disconnected()
  437. {
  438. struct usb_handle *usb= NULL;
  439. adb_mutex_lock(&usb_lock);
  440. for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
  441. if (check_device_connected(usb) == 0) {
  442. D("kick_disconnected(): Transport %p is not online anymore\n",
  443. usb);
  444. usb_kick(usb);
  445. }
  446. }
  447. adb_mutex_unlock(&usb_lock);
  448. }
  449. void
  450. scan_usb_devices()
  451. {
  452. D("scan_usb_devices(): started\n");
  453. libusb_device **devs= NULL;
  454. libusb_device *dev= NULL;
  455. ssize_t cnt = libusb_get_device_list(ctx, &devs);
  456. if (cnt < 0) {
  457. D("scan_usb_devices(): Failed to get device list (error: %d)\n",
  458. cnt);
  459. return;
  460. }
  461. int i = 0;
  462. while ((dev = devs[i++]) != NULL) {
  463. check_device(dev);
  464. }
  465. libusb_free_device_list(devs, 1);
  466. }
  467. void *
  468. device_poll_thread(void* unused)
  469. {
  470. D("device_poll_thread(): Created USB scan thread\n");
  471. for (;;) {
  472. sleep(5);
  473. kick_disconnected();
  474. scan_usb_devices();
  475. }
  476. /* never reaching this point */
  477. return (NULL);
  478. }
  479. static void
  480. sigalrm_handler(int signo)
  481. {
  482. /* nothing */
  483. }
  484. void
  485. usb_init()
  486. {
  487. D("usb_init(): started\n");
  488. adb_thread_t tid;
  489. struct sigaction actions;
  490. int r = libusb_init(&ctx);
  491. if (r != LIBUSB_SUCCESS) {
  492. err(EX_IOERR, "Failed to init libusb\n");
  493. }
  494. memset(&actions, 0, sizeof(actions));
  495. sigemptyset(&actions.sa_mask);
  496. actions.sa_flags = 0;
  497. actions.sa_handler = sigalrm_handler;
  498. sigaction(SIGALRM, &actions, NULL);
  499. /* initial device scan */
  500. scan_usb_devices();
  501. /* starting USB event polling thread */
  502. if (adb_thread_create(&tid, device_poll_thread, NULL)) {
  503. err(EX_IOERR, "cannot create USB scan thread\n");
  504. }
  505. D("usb_init(): finished\n");
  506. }