2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <sys/endian.h>
18 #include <sys/ioctl.h>
19 #include <sys/types.h>
34 #define TRACE_TAG TRACE_USB
37 static sdb_mutex_t usb_lock = SDB_MUTEX_INITIALIZER;
38 static libusb_context *ctx = NULL;
46 libusb_device_handle *devh;
52 unsigned char end_point_address[2];
59 static struct usb_handle handle_list = {
71 report_bulk_libusb_error(int r)
74 case LIBUSB_ERROR_TIMEOUT:
75 D("Transfer timeout\n");
78 case LIBUSB_ERROR_PIPE:
79 D("Control request is not supported\n");
82 case LIBUSB_ERROR_OVERFLOW:
83 D("Device offered more data\n");
86 case LIBUSB_ERROR_NO_DEVICE :
87 D("Device was disconnected\n");
91 D("Error %d during transfer\n", r);
97 usb_bulk_write(usb_handle *uh, const void *data, int len)
102 r = libusb_bulk_transfer(uh->devh, uh->end_point_address[1], (void *)data, len,
106 D("usb_bulk_write(): ");
107 report_bulk_libusb_error(r);
111 return (transferred);
115 usb_bulk_read(usb_handle *uh, void *data, int len)
120 r = libusb_bulk_transfer(uh->devh, uh->end_point_address[0], data, len,
124 D("usb_bulk_read(): ");
125 report_bulk_libusb_error(r);
129 return (transferred);
133 usb_write(struct usb_handle *uh, const void *_data, int len)
135 unsigned char *data = (unsigned char*) _data;
139 if (uh->zero_mask == 1) {
140 if (!(len & uh->zero_mask)) {
145 D("usb_write(): %p:%d -> transport %p\n", _data, len, uh);
148 int xfer = (len > 4096) ? 4096 : len;
150 n = usb_bulk_write(uh, data, xfer);
153 D("usb_write(): failed for transport %p (%d bytes left)\n", uh, len);
162 n = usb_bulk_write(uh, _data, 0);
165 D("usb_write(): failed to finish operation for transport %p\n", uh);
174 usb_read(struct usb_handle *uh, void *_data, size_t len)
176 unsigned char *data = (unsigned char*) _data;
179 D("usb_read(): %p:%d <- transport %p\n", _data, len, uh);
182 int xfer = (len > 4096) ? 4096 : len;
184 n = usb_bulk_read(uh, data, xfer);
193 D("usb_read(): failed for transport %p (%d bytes left)\n", uh, len);
205 usb_close(struct usb_handle *h)
207 D("usb_close(): closing transport %p\n", h);
208 sdb_mutex_lock(&usb_lock);
210 h->next->prev = h->prev;
211 h->prev->next = h->next;
215 libusb_release_interface(h->devh, h->interface);
216 libusb_close(h->devh);
217 libusb_unref_device(h->dev);
219 sdb_mutex_unlock(&usb_lock);
226 void usb_kick(struct usb_handle *h)
228 D("usb_cick(): kicking transport %p\n", h);
230 sdb_mutex_lock(&h->lock);
231 unregister_usb_transport(h);
232 sdb_mutex_unlock(&h->lock);
234 h->next->prev = h->prev;
235 h->prev->next = h->next;
239 libusb_release_interface(h->devh, h->interface);
240 libusb_close(h->devh);
241 libusb_unref_device(h->dev);
246 check_usb_interface(libusb_interface *interface,
247 libusb_device_descriptor *desc,
248 struct usb_handle *uh)
252 if (interface->num_altsetting == 0) {
253 D("check_usb_interface(): No interface settings\n");
257 libusb_interface_descriptor *idesc = &interface->altsetting[0];
259 if (idesc->bNumEndpoints != 2) {
260 D("check_usb_interface(): Interface have not 2 endpoints, ignoring\n");
264 for (e = 0; e < idesc->bNumEndpoints; e++) {
265 libusb_endpoint_descriptor *edesc = &idesc->endpoint[e];
267 if (edesc->bmAttributes != LIBUSB_TRANSFER_TYPE_BULK) {
268 D("check_usb_interface(): Endpoint (%u) is not bulk (%u), ignoring\n",
269 edesc->bmAttributes, LIBUSB_TRANSFER_TYPE_BULK);
273 if (edesc->bEndpointAddress & LIBUSB_ENDPOINT_IN)
274 uh->end_point_address[0] = edesc->bEndpointAddress;
276 uh->end_point_address[1] = edesc->bEndpointAddress;
278 /* aproto 01 needs 0 termination */
279 if (idesc->bInterfaceProtocol == 0x01) {
280 uh->zero_mask = edesc->wMaxPacketSize - 1;
281 D("check_usb_interface(): Forced Android interface protocol v.1\n");
285 D("check_usb_interface(): Device: %04x:%04x "
286 "iclass: %x, isclass: %x, iproto: %x ep: %x/%x-> ",
287 desc->idVendor, desc->idProduct, idesc->bInterfaceClass,
288 idesc->bInterfaceSubClass, idesc->bInterfaceProtocol,
289 uh->end_point_address[0], uh->end_point_address[1]);
291 if (!is_sdb_interface(desc->idVendor, desc->idProduct,
292 idesc->bInterfaceClass, idesc->bInterfaceSubClass,
293 idesc->bInterfaceProtocol))
304 check_usb_interfaces(libusb_config_descriptor *config,
305 libusb_device_descriptor *desc, struct usb_handle *uh)
309 for (i = 0; i < config->bNumInterfaces; ++i) {
310 if (check_usb_interface(&config->interface[i], desc, uh) != -1) {
311 /* found some interface and saved information about it */
312 D("check_usb_interfaces(): Interface %d of %04x:%04x "
313 "matches Android device\n", i, desc->idVendor,
324 register_device(struct usb_handle *uh, const char *serial)
326 D("register_device(): Registering %p [%s] as USB transport\n",
329 struct usb_handle *usb= NULL;
331 usb = calloc(1, sizeof(struct usb_handle));
332 memcpy(usb, uh, sizeof(struct usb_handle));
333 strcpy(usb->serial, uh->serial);
335 sdb_cond_init(&usb->notify, 0);
336 sdb_mutex_init(&usb->lock, 0);
338 sdb_mutex_lock(&usb_lock);
340 usb->next = &handle_list;
341 usb->prev = handle_list.prev;
342 usb->prev->next = usb;
343 usb->next->prev = usb;
345 sdb_mutex_unlock(&usb_lock);
347 register_usb_transport(usb, serial, 1);
353 already_registered(usb_handle *uh)
355 struct usb_handle *usb= NULL;
358 sdb_mutex_lock(&usb_lock);
360 for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
361 if ((usb->dev_bus == uh->dev_bus) &&
362 (usb->dev_addr == uh->dev_addr))
369 sdb_mutex_unlock(&usb_lock);
375 check_device(libusb_device *dev)
377 struct usb_handle uh;
380 char serial[256] = {0};
382 libusb_device_descriptor desc;
383 libusb_config_descriptor *config = NULL;
385 int r = libusb_get_device_descriptor(dev, &desc);
387 if (r != LIBUSB_SUCCESS) {
388 D("check_device(): Failed to get device descriptor\n");
392 if ((desc.idVendor == 0) && (desc.idProduct == 0))
395 D("check_device(): Probing usb device %04x:%04x\n",
396 desc.idVendor, desc.idProduct);
398 if (!is_sdb_interface (desc.idVendor, desc.idProduct,
399 SDB_CLASS, SDB_SUBCLASS, SDB_PROTOCOL))
401 D("check_device(): Ignored due unknown vendor id\n");
405 uh.dev_bus = libusb_get_bus_number(dev);
406 uh.dev_addr = libusb_get_device_address(dev);
408 if (already_registered(&uh)) {
409 D("check_device(): Device (bus: %d, address: %d) "
410 "is already registered\n", uh.dev_bus, uh.dev_addr);
414 D("check_device(): Device bus: %d, address: %d\n",
415 uh.dev_bus, uh.dev_addr);
417 r = libusb_get_active_config_descriptor(dev, &config);
420 if (r == LIBUSB_ERROR_NOT_FOUND) {
421 D("check_device(): Device %4x:%4x is unconfigured\n",
422 desc.idVendor, desc.idProduct);
426 D("check_device(): Failed to get configuration for %4x:%4x\n",
427 desc.idVendor, desc.idProduct);
431 if (config == NULL) {
432 D("check_device(): Sanity check failed after "
433 "getting active config\n");
437 if (config->interface != NULL) {
438 found = check_usb_interfaces(config, &desc, &uh);
441 /* not needed anymore */
442 libusb_free_config_descriptor(config);
444 r = libusb_open(dev, &uh.devh);
449 case LIBUSB_ERROR_NO_MEM:
450 D("check_device(): Memory allocation problem\n");
453 case LIBUSB_ERROR_ACCESS:
454 D("check_device(): Permissions problem, "
455 "current user priveleges are messed up?\n");
458 case LIBUSB_ERROR_NO_DEVICE:
459 D("check_device(): Device disconected, bad cable?\n");
463 D("check_device(): libusb triggered error %d\n", r);
470 D("check_device(): Device matches Android interface\n");
471 // read the device's serial number
472 memset(serial, 0, sizeof(serial));
473 uh.interface = found;
475 r = libusb_claim_interface(uh.devh, uh.interface);
478 D("check_device(): Failed to claim interface %d\n",
484 if (desc.iSerialNumber) {
486 uint16_t buffer[128] = {0};
487 uint16_t languages[128] = {0};
488 int languageCount = 0;
490 memset(languages, 0, sizeof(languages));
491 r = libusb_control_transfer(uh.devh,
492 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
493 LIBUSB_REQUEST_GET_DESCRIPTOR, LIBUSB_DT_STRING << 8,
494 0, (uint8_t *)languages, sizeof(languages), 0);
497 D("check_device(): Failed to get languages count\n");
501 languageCount = (r - 2) / 2;
503 for (i = 1; i <= languageCount; ++i) {
504 memset(buffer, 0, sizeof(buffer));
506 r = libusb_control_transfer(uh.devh,
507 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
508 LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc.iSerialNumber,
509 languages[i], (uint8_t *)buffer, sizeof(buffer), 0);
511 if (r > 0) { /* converting serial */
515 for (j = 1; j < r; ++j)
516 serial[j - 1] = buffer[j];
518 serial[j - 1] = '\0';
519 break; /* languagesCount cycle */
523 if (register_device(&uh, serial) == 0) {
524 D("check_device(): Failed to register device\n");
528 libusb_ref_device(dev);
535 libusb_release_interface(uh.devh, uh.interface);
538 libusb_close(uh.devh);
543 check_device_connected(struct usb_handle *uh)
545 int r = libusb_kernel_driver_active(uh->devh, uh->interface);
547 if (r == LIBUSB_ERROR_NO_DEVICE)
559 struct usb_handle *usb= NULL;
561 sdb_mutex_lock(&usb_lock);
563 for (usb = handle_list.next; usb != &handle_list; usb = usb->next) {
565 if (check_device_connected(usb) == 0) {
566 D("kick_disconnected(): Transport %p is not online anymore\n",
573 sdb_mutex_unlock(&usb_lock);
579 D("scan_usb_devices(): started\n");
581 libusb_device **devs= NULL;
582 libusb_device *dev= NULL;
583 ssize_t cnt = libusb_get_device_list(ctx, &devs);
586 D("scan_usb_devices(): Failed to get device list (error: %d)\n",
594 while ((dev = devs[i++]) != NULL) {
598 libusb_free_device_list(devs, 1);
602 device_poll_thread(void* unused)
604 D("device_poll_thread(): Created USB scan thread\n");
612 /* never reaching this point */
617 sigalrm_handler(int signo)
625 D("usb_init(): started\n");
627 struct sigaction actions;
629 int r = libusb_init(&ctx);
631 if (r != LIBUSB_SUCCESS) {
632 err(EX_IOERR, "Failed to init libusb\n");
635 memset(&actions, 0, sizeof(actions));
637 sigemptyset(&actions.sa_mask);
639 actions.sa_flags = 0;
640 actions.sa_handler = sigalrm_handler;
642 sigaction(SIGALRM, &actions, NULL);
644 /* initial device scan */
647 /* starting USB event polling thread */
648 if (sdb_thread_create(&tid, device_poll_thread, NULL)) {
649 err(EX_IOERR, "cannot create USB scan thread\n");
652 D("usb_init(): finished\n");