1 /* 2 * Copyright (C) 2007 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 17 #include <stdio.h> 18 #include <stdlib.h> 19 #include <unistd.h> 20 #include <string.h> 21 22 #include <linux/usb/ch9.h> 23 #include <linux/usb/functionfs.h> 24 #include <sys/ioctl.h> 25 #include <sys/types.h> 26 #include <dirent.h> 27 #include <errno.h> 28 29 #include "sysdeps.h" 30 31 #define TRACE_TAG TRACE_USB 32 #include "adb.h" 33 34 #define MAX_PACKET_SIZE_FS 64 35 #define MAX_PACKET_SIZE_HS 512 36 37 #define cpu_to_le16(x) htole16(x) 38 #define cpu_to_le32(x) htole32(x) 39 40 struct usb_handle 41 { 42 adb_cond_t notify; 43 adb_mutex_t lock; 44 45 int (*write)(usb_handle *h, const void *data, int len); 46 int (*read)(usb_handle *h, void *data, int len); 47 void (*kick)(usb_handle *h); 48 49 // Legacy f_adb 50 int fd; 51 52 // FunctionFS 53 int control; 54 int bulk_out; /* "out" from the host's perspective => source for adbd */ 55 int bulk_in; /* "in" from the host's perspective => sink for adbd */ 56 }; 57 58 static const struct { 59 struct usb_functionfs_descs_head header; 60 struct { 61 struct usb_interface_descriptor intf; 62 struct usb_endpoint_descriptor_no_audio source; 63 struct usb_endpoint_descriptor_no_audio sink; 64 } __attribute__((packed)) fs_descs, hs_descs; 65 } __attribute__((packed)) descriptors = { 66 .header = { 67 .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC), 68 .length = cpu_to_le32(sizeof(descriptors)), 69 .fs_count = 3, 70 .hs_count = 3, 71 }, 72 .fs_descs = { 73 .intf = { 74 .bLength = sizeof(descriptors.fs_descs.intf), 75 .bDescriptorType = USB_DT_INTERFACE, 76 .bInterfaceNumber = 0, 77 .bNumEndpoints = 2, 78 .bInterfaceClass = ADB_CLASS, 79 .bInterfaceSubClass = ADB_SUBCLASS, 80 .bInterfaceProtocol = ADB_PROTOCOL, 81 .iInterface = 1, /* first string from the provided table */ 82 }, 83 .source = { 84 .bLength = sizeof(descriptors.fs_descs.source), 85 .bDescriptorType = USB_DT_ENDPOINT, 86 .bEndpointAddress = 1 | USB_DIR_OUT, 87 .bmAttributes = USB_ENDPOINT_XFER_BULK, 88 .wMaxPacketSize = MAX_PACKET_SIZE_FS, 89 }, 90 .sink = { 91 .bLength = sizeof(descriptors.fs_descs.sink), 92 .bDescriptorType = USB_DT_ENDPOINT, 93 .bEndpointAddress = 2 | USB_DIR_IN, 94 .bmAttributes = USB_ENDPOINT_XFER_BULK, 95 .wMaxPacketSize = MAX_PACKET_SIZE_FS, 96 }, 97 }, 98 .hs_descs = { 99 .intf = { 100 .bLength = sizeof(descriptors.hs_descs.intf), 101 .bDescriptorType = USB_DT_INTERFACE, 102 .bInterfaceNumber = 0, 103 .bNumEndpoints = 2, 104 .bInterfaceClass = ADB_CLASS, 105 .bInterfaceSubClass = ADB_SUBCLASS, 106 .bInterfaceProtocol = ADB_PROTOCOL, 107 .iInterface = 1, /* first string from the provided table */ 108 }, 109 .source = { 110 .bLength = sizeof(descriptors.hs_descs.source), 111 .bDescriptorType = USB_DT_ENDPOINT, 112 .bEndpointAddress = 1 | USB_DIR_OUT, 113 .bmAttributes = USB_ENDPOINT_XFER_BULK, 114 .wMaxPacketSize = MAX_PACKET_SIZE_HS, 115 }, 116 .sink = { 117 .bLength = sizeof(descriptors.hs_descs.sink), 118 .bDescriptorType = USB_DT_ENDPOINT, 119 .bEndpointAddress = 2 | USB_DIR_IN, 120 .bmAttributes = USB_ENDPOINT_XFER_BULK, 121 .wMaxPacketSize = MAX_PACKET_SIZE_HS, 122 }, 123 }, 124 }; 125 126 #define STR_INTERFACE_ "ADB Interface" 127 128 static const struct { 129 struct usb_functionfs_strings_head header; 130 struct { 131 __le16 code; 132 const char str1[sizeof(STR_INTERFACE_)]; 133 } __attribute__((packed)) lang0; 134 } __attribute__((packed)) strings = { 135 .header = { 136 .magic = cpu_to_le32(FUNCTIONFS_STRINGS_MAGIC), 137 .length = cpu_to_le32(sizeof(strings)), 138 .str_count = cpu_to_le32(1), 139 .lang_count = cpu_to_le32(1), 140 }, 141 .lang0 = { 142 cpu_to_le16(0x0409), /* en-us */ 143 STR_INTERFACE_, 144 }, 145 }; 146 147 148 149 static void *usb_adb_open_thread(void *x) 150 { 151 struct usb_handle *usb = (struct usb_handle *)x; 152 int fd; 153 154 while (1) { 155 // wait until the USB device needs opening 156 adb_mutex_lock(&usb->lock); 157 while (usb->fd != -1) 158 adb_cond_wait(&usb->notify, &usb->lock); 159 adb_mutex_unlock(&usb->lock); 160 161 D("[ usb_thread - opening device ]\n"); 162 do { 163 /* XXX use inotify? */ 164 fd = unix_open("/dev/android_adb", O_RDWR); 165 if (fd < 0) { 166 // to support older kernels 167 fd = unix_open("/dev/android", O_RDWR); 168 } 169 if (fd < 0) { 170 adb_sleep_ms(1000); 171 } 172 } while (fd < 0); 173 D("[ opening device succeeded ]\n"); 174 175 close_on_exec(fd); 176 usb->fd = fd; 177 178 D("[ usb_thread - registering device ]\n"); 179 register_usb_transport(usb, 0, 0, 1); 180 } 181 182 // never gets here 183 return 0; 184 } 185 186 static int usb_adb_write(usb_handle *h, const void *data, int len) 187 { 188 int n; 189 190 D("about to write (fd=%d, len=%d)\n", h->fd, len); 191 n = adb_write(h->fd, data, len); 192 if(n != len) { 193 D("ERROR: fd = %d, n = %d, errno = %d (%s)\n", 194 h->fd, n, errno, strerror(errno)); 195 return -1; 196 } 197 D("[ done fd=%d ]\n", h->fd); 198 return 0; 199 } 200 201 static int usb_adb_read(usb_handle *h, void *data, int len) 202 { 203 int n; 204 205 D("about to read (fd=%d, len=%d)\n", h->fd, len); 206 n = adb_read(h->fd, data, len); 207 if(n != len) { 208 D("ERROR: fd = %d, n = %d, errno = %d (%s)\n", 209 h->fd, n, errno, strerror(errno)); 210 return -1; 211 } 212 D("[ done fd=%d ]\n", h->fd); 213 return 0; 214 } 215 216 static void usb_adb_kick(usb_handle *h) 217 { 218 D("usb_kick\n"); 219 adb_mutex_lock(&h->lock); 220 adb_close(h->fd); 221 h->fd = -1; 222 223 // notify usb_adb_open_thread that we are disconnected 224 adb_cond_signal(&h->notify); 225 adb_mutex_unlock(&h->lock); 226 } 227 228 static void usb_adb_init() 229 { 230 usb_handle *h; 231 adb_thread_t tid; 232 int fd; 233 234 h = calloc(1, sizeof(usb_handle)); 235 236 h->write = usb_adb_write; 237 h->read = usb_adb_read; 238 h->kick = usb_adb_kick; 239 h->fd = -1; 240 241 adb_cond_init(&h->notify, 0); 242 adb_mutex_init(&h->lock, 0); 243 244 // Open the file /dev/android_adb_enable to trigger 245 // the enabling of the adb USB function in the kernel. 246 // We never touch this file again - just leave it open 247 // indefinitely so the kernel will know when we are running 248 // and when we are not. 249 fd = unix_open("/dev/android_adb_enable", O_RDWR); 250 if (fd < 0) { 251 D("failed to open /dev/android_adb_enable\n"); 252 } else { 253 close_on_exec(fd); 254 } 255 256 D("[ usb_init - starting thread ]\n"); 257 if(adb_thread_create(&tid, usb_adb_open_thread, h)){ 258 fatal_errno("cannot create usb thread"); 259 } 260 } 261 262 263 static void init_functionfs(struct usb_handle *h) 264 { 265 ssize_t ret; 266 267 D("OPENING %s\n", USB_FFS_ADB_EP0); 268 h->control = adb_open(USB_FFS_ADB_EP0, O_RDWR); 269 if (h->control < 0) { 270 D("[ %s: cannot open control endpoint: errno=%d]\n", USB_FFS_ADB_EP0, errno); 271 goto err; 272 } 273 274 ret = adb_write(h->control, &descriptors, sizeof(descriptors)); 275 if (ret < 0) { 276 D("[ %s: write descriptors failed: errno=%d ]\n", USB_FFS_ADB_EP0, errno); 277 goto err; 278 } 279 280 ret = adb_write(h->control, &strings, sizeof(strings)); 281 if (ret < 0) { 282 D("[ %s: writing strings failed: errno=%d]\n", USB_FFS_ADB_EP0, errno); 283 goto err; 284 } 285 286 h->bulk_out = adb_open(USB_FFS_ADB_OUT, O_RDWR); 287 if (h->bulk_out < 0) { 288 D("[ %s: cannot open bulk-out ep: errno=%d ]\n", USB_FFS_ADB_OUT, errno); 289 goto err; 290 } 291 292 h->bulk_in = adb_open(USB_FFS_ADB_IN, O_RDWR); 293 if (h->bulk_in < 0) { 294 D("[ %s: cannot open bulk-in ep: errno=%d ]\n", USB_FFS_ADB_IN, errno); 295 goto err; 296 } 297 298 return; 299 300 err: 301 if (h->bulk_in > 0) { 302 adb_close(h->bulk_in); 303 h->bulk_in = -1; 304 } 305 if (h->bulk_out > 0) { 306 adb_close(h->bulk_out); 307 h->bulk_out = -1; 308 } 309 if (h->control > 0) { 310 adb_close(h->control); 311 h->control = -1; 312 } 313 return; 314 } 315 316 static void *usb_ffs_open_thread(void *x) 317 { 318 struct usb_handle *usb = (struct usb_handle *)x; 319 320 while (1) { 321 // wait until the USB device needs opening 322 adb_mutex_lock(&usb->lock); 323 while (usb->control != -1) 324 adb_cond_wait(&usb->notify, &usb->lock); 325 adb_mutex_unlock(&usb->lock); 326 327 while (1) { 328 init_functionfs(usb); 329 330 if (usb->control >= 0) 331 break; 332 333 adb_sleep_ms(1000); 334 } 335 336 D("[ usb_thread - registering device ]\n"); 337 register_usb_transport(usb, 0, 0, 1); 338 } 339 340 // never gets here 341 return 0; 342 } 343 344 static int bulk_write(int bulk_in, const char *buf, size_t length) 345 { 346 size_t count = 0; 347 int ret; 348 349 do { 350 ret = adb_write(bulk_in, buf + count, length - count); 351 if (ret < 0) { 352 if (errno != EINTR) 353 return ret; 354 } else { 355 count += ret; 356 } 357 } while (count < length); 358 359 D("[ bulk_write done fd=%d ]\n", bulk_in); 360 return count; 361 } 362 363 static int usb_ffs_write(usb_handle *h, const void *data, int len) 364 { 365 int n; 366 367 D("about to write (fd=%d, len=%d)\n", h->bulk_in, len); 368 n = bulk_write(h->bulk_in, data, len); 369 if (n != len) { 370 D("ERROR: fd = %d, n = %d, errno = %d (%s)\n", 371 h->bulk_in, n, errno, strerror(errno)); 372 return -1; 373 } 374 D("[ done fd=%d ]\n", h->bulk_in); 375 return 0; 376 } 377 378 static int bulk_read(int bulk_out, char *buf, size_t length) 379 { 380 size_t count = 0; 381 int ret; 382 383 do { 384 ret = adb_read(bulk_out, buf + count, length - count); 385 if (ret < 0) { 386 if (errno != EINTR) { 387 D("[ bulk_read failed fd=%d length=%d count=%d ]\n", 388 bulk_out, length, count); 389 return ret; 390 } 391 } else { 392 count += ret; 393 } 394 } while (count < length); 395 396 return count; 397 } 398 399 static int usb_ffs_read(usb_handle *h, void *data, int len) 400 { 401 int n; 402 403 D("about to read (fd=%d, len=%d)\n", h->bulk_out, len); 404 n = bulk_read(h->bulk_out, data, len); 405 if (n != len) { 406 D("ERROR: fd = %d, n = %d, errno = %d (%s)\n", 407 h->bulk_out, n, errno, strerror(errno)); 408 return -1; 409 } 410 D("[ done fd=%d ]\n", h->bulk_out); 411 return 0; 412 } 413 414 static void usb_ffs_kick(usb_handle *h) 415 { 416 int err; 417 418 err = ioctl(h->bulk_in, FUNCTIONFS_CLEAR_HALT); 419 if (err < 0) 420 D("[ kick: source (fd=%d) clear halt failed (%d) ]", h->bulk_in, errno); 421 422 err = ioctl(h->bulk_out, FUNCTIONFS_CLEAR_HALT); 423 if (err < 0) 424 D("[ kick: sink (fd=%d) clear halt failed (%d) ]", h->bulk_out, errno); 425 426 adb_mutex_lock(&h->lock); 427 adb_close(h->control); 428 adb_close(h->bulk_out); 429 adb_close(h->bulk_in); 430 h->control = h->bulk_out = h->bulk_in = -1; 431 432 // notify usb_ffs_open_thread that we are disconnected 433 adb_cond_signal(&h->notify); 434 adb_mutex_unlock(&h->lock); 435 } 436 437 static void usb_ffs_init() 438 { 439 usb_handle *h; 440 adb_thread_t tid; 441 442 D("[ usb_init - using FunctionFS ]\n"); 443 444 h = calloc(1, sizeof(usb_handle)); 445 446 h->write = usb_ffs_write; 447 h->read = usb_ffs_read; 448 h->kick = usb_ffs_kick; 449 450 h->control = -1; 451 h->bulk_out = -1; 452 h->bulk_out = -1; 453 454 adb_cond_init(&h->notify, 0); 455 adb_mutex_init(&h->lock, 0); 456 457 D("[ usb_init - starting thread ]\n"); 458 if (adb_thread_create(&tid, usb_ffs_open_thread, h)){ 459 fatal_errno("[ cannot create usb thread ]\n"); 460 } 461 } 462 463 void usb_init() 464 { 465 if (access(USB_FFS_ADB_EP0, F_OK) == 0) 466 usb_ffs_init(); 467 else 468 usb_adb_init(); 469 } 470 471 void usb_cleanup() 472 { 473 } 474 475 int usb_write(usb_handle *h, const void *data, int len) 476 { 477 return h->write(h, data, len); 478 } 479 480 int usb_read(usb_handle *h, void *data, int len) 481 { 482 return h->read(h, data, len); 483 } 484 int usb_close(usb_handle *h) 485 { 486 return 0; 487 } 488 489 void usb_kick(usb_handle *h) 490 { 491 h->kick(h); 492 } 493