1 /* 2 * USB hub driver. 3 * 4 * (C) Copyright 1999 Linus Torvalds 5 * (C) Copyright 1999 Johannes Erdfelt 6 * (C) Copyright 1999 Gregory P. Smith 7 * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au) 8 * 9 */ 10 11 #include <linux/config.h> 12 #ifdef CONFIG_USB_DEBUG 13 #define DEBUG 14 #else 15 #undef DEBUG 16 #endif 17 #include <linux/kernel.h> 18 #include <linux/errno.h> 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/completion.h> 22 #include <linux/sched.h> 23 #include <linux/list.h> 24 #include <linux/slab.h> 25 #include <linux/smp_lock.h> 26 #include <linux/ioctl.h> 27 #include <linux/usb.h> 28 #include <linux/usbdevice_fs.h> 29 30 #include <asm/semaphore.h> 31 #include <asm/uaccess.h> 32 #include <asm/byteorder.h> 33 34 #include "usb.h" 35 #include "hcd.h" 36 #include "hub.h" 37 38 /* Protect struct usb_device->state and ->children members 39 * Note: Both are also protected by ->serialize, except that ->state can 40 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */ 41 static DEFINE_SPINLOCK(device_state_lock); 42 43 /* khubd's worklist and its lock */ 44 static DEFINE_SPINLOCK(hub_event_lock); 45 static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */ 46 47 /* Wakes up khubd */ 48 static DECLARE_WAIT_QUEUE_HEAD(khubd_wait); 49 50 static pid_t khubd_pid = 0; /* PID of khubd */ 51 static DECLARE_COMPLETION(khubd_exited); 52 53 /* cycle leds on hubs that aren't blinking for attention */ 54 static int blinkenlights = 0; 55 module_param (blinkenlights, bool, S_IRUGO); 56 MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs"); 57 58 /* 59 * As of 2.6.10 we introduce a new USB device initialization scheme which 60 * closely resembles the way Windows works. Hopefully it will be compatible 61 * with a wider range of devices than the old scheme. However some previously 62 * working devices may start giving rise to "device not accepting address" 63 * errors; if that happens the user can try the old scheme by adjusting the 64 * following module parameters. 65 * 66 * For maximum flexibility there are two boolean parameters to control the 67 * hub driver's behavior. On the first initialization attempt, if the 68 * "old_scheme_first" parameter is set then the old scheme will be used, 69 * otherwise the new scheme is used. If that fails and "use_both_schemes" 70 * is set, then the driver will make another attempt, using the other scheme. 71 */ 72 static int old_scheme_first = 0; 73 module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR); 74 MODULE_PARM_DESC(old_scheme_first, 75 "start with the old device initialization scheme"); 76 77 static int use_both_schemes = 1; 78 module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR); 79 MODULE_PARM_DESC(use_both_schemes, 80 "try the other device initialization scheme if the " 81 "first one fails"); 82 83 84 #ifdef DEBUG 85 static inline char *portspeed (int portstatus) 86 { 87 if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED)) 88 return "480 Mb/s"; 89 else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED)) 90 return "1.5 Mb/s"; 91 else 92 return "12 Mb/s"; 93 } 94 #endif 95 96 /* Note that hdev or one of its children must be locked! */ 97 static inline struct usb_hub *hdev_to_hub(struct usb_device *hdev) 98 { 99 return usb_get_intfdata(hdev->actconfig->interface[0]); 100 } 101 102 /* USB 2.0 spec Section 11.24.4.5 */ 103 static int get_hub_descriptor(struct usb_device *hdev, void *data, int size) 104 { 105 int i, ret; 106 107 for (i = 0; i < 3; i++) { 108 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 109 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 110 USB_DT_HUB << 8, 0, data, size, 111 USB_CTRL_GET_TIMEOUT); 112 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2)) 113 return ret; 114 } 115 return -EINVAL; 116 } 117 118 /* 119 * USB 2.0 spec Section 11.24.2.1 120 */ 121 static int clear_hub_feature(struct usb_device *hdev, int feature) 122 { 123 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 124 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000); 125 } 126 127 /* 128 * USB 2.0 spec Section 11.24.2.2 129 */ 130 static int clear_port_feature(struct usb_device *hdev, int port1, int feature) 131 { 132 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 133 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1, 134 NULL, 0, 1000); 135 } 136 137 /* 138 * USB 2.0 spec Section 11.24.2.13 139 */ 140 static int set_port_feature(struct usb_device *hdev, int port1, int feature) 141 { 142 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 143 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1, 144 NULL, 0, 1000); 145 } 146 147 /* 148 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7 149 * for info about using port indicators 150 */ 151 static void set_port_led( 152 struct usb_hub *hub, 153 int port1, 154 int selector 155 ) 156 { 157 int status = set_port_feature(hub->hdev, (selector << 8) | port1, 158 USB_PORT_FEAT_INDICATOR); 159 if (status < 0) 160 dev_dbg (hub->intfdev, 161 "port %d indicator %s status %d\n", 162 port1, 163 ({ char *s; switch (selector) { 164 case HUB_LED_AMBER: s = "amber"; break; 165 case HUB_LED_GREEN: s = "green"; break; 166 case HUB_LED_OFF: s = "off"; break; 167 case HUB_LED_AUTO: s = "auto"; break; 168 default: s = "??"; break; 169 }; s; }), 170 status); 171 } 172 173 #define LED_CYCLE_PERIOD ((2*HZ)/3) 174 175 static void led_work (void *__hub) 176 { 177 struct usb_hub *hub = __hub; 178 struct usb_device *hdev = hub->hdev; 179 unsigned i; 180 unsigned changed = 0; 181 int cursor = -1; 182 183 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing) 184 return; 185 186 for (i = 0; i < hub->descriptor->bNbrPorts; i++) { 187 unsigned selector, mode; 188 189 /* 30%-50% duty cycle */ 190 191 switch (hub->indicator[i]) { 192 /* cycle marker */ 193 case INDICATOR_CYCLE: 194 cursor = i; 195 selector = HUB_LED_AUTO; 196 mode = INDICATOR_AUTO; 197 break; 198 /* blinking green = sw attention */ 199 case INDICATOR_GREEN_BLINK: 200 selector = HUB_LED_GREEN; 201 mode = INDICATOR_GREEN_BLINK_OFF; 202 break; 203 case INDICATOR_GREEN_BLINK_OFF: 204 selector = HUB_LED_OFF; 205 mode = INDICATOR_GREEN_BLINK; 206 break; 207 /* blinking amber = hw attention */ 208 case INDICATOR_AMBER_BLINK: 209 selector = HUB_LED_AMBER; 210 mode = INDICATOR_AMBER_BLINK_OFF; 211 break; 212 case INDICATOR_AMBER_BLINK_OFF: 213 selector = HUB_LED_OFF; 214 mode = INDICATOR_AMBER_BLINK; 215 break; 216 /* blink green/amber = reserved */ 217 case INDICATOR_ALT_BLINK: 218 selector = HUB_LED_GREEN; 219 mode = INDICATOR_ALT_BLINK_OFF; 220 break; 221 case INDICATOR_ALT_BLINK_OFF: 222 selector = HUB_LED_AMBER; 223 mode = INDICATOR_ALT_BLINK; 224 break; 225 default: 226 continue; 227 } 228 if (selector != HUB_LED_AUTO) 229 changed = 1; 230 set_port_led(hub, i + 1, selector); 231 hub->indicator[i] = mode; 232 } 233 if (!changed && blinkenlights) { 234 cursor++; 235 cursor %= hub->descriptor->bNbrPorts; 236 set_port_led(hub, cursor + 1, HUB_LED_GREEN); 237 hub->indicator[cursor] = INDICATOR_CYCLE; 238 changed++; 239 } 240 if (changed) 241 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD); 242 } 243 244 /* use a short timeout for hub/port status fetches */ 245 #define USB_STS_TIMEOUT 1000 246 #define USB_STS_RETRIES 5 247 248 /* 249 * USB 2.0 spec Section 11.24.2.6 250 */ 251 static int get_hub_status(struct usb_device *hdev, 252 struct usb_hub_status *data) 253 { 254 int i, status = -ETIMEDOUT; 255 256 for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) { 257 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 258 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 259 data, sizeof(*data), USB_STS_TIMEOUT); 260 } 261 return status; 262 } 263 264 /* 265 * USB 2.0 spec Section 11.24.2.7 266 */ 267 static int get_port_status(struct usb_device *hdev, int port1, 268 struct usb_port_status *data) 269 { 270 int i, status = -ETIMEDOUT; 271 272 for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) { 273 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 274 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1, 275 data, sizeof(*data), USB_STS_TIMEOUT); 276 } 277 return status; 278 } 279 280 static void kick_khubd(struct usb_hub *hub) 281 { 282 unsigned long flags; 283 284 spin_lock_irqsave(&hub_event_lock, flags); 285 if (list_empty(&hub->event_list)) { 286 list_add_tail(&hub->event_list, &hub_event_list); 287 wake_up(&khubd_wait); 288 } 289 spin_unlock_irqrestore(&hub_event_lock, flags); 290 } 291 292 void usb_kick_khubd(struct usb_device *hdev) 293 { 294 kick_khubd(hdev_to_hub(hdev)); 295 } 296 297 298 /* completion function, fires on port status changes and various faults */ 299 static void hub_irq(struct urb *urb, struct pt_regs *regs) 300 { 301 struct usb_hub *hub = (struct usb_hub *)urb->context; 302 int status; 303 int i; 304 unsigned long bits; 305 306 switch (urb->status) { 307 case -ENOENT: /* synchronous unlink */ 308 case -ECONNRESET: /* async unlink */ 309 case -ESHUTDOWN: /* hardware going away */ 310 return; 311 312 default: /* presumably an error */ 313 /* Cause a hub reset after 10 consecutive errors */ 314 dev_dbg (hub->intfdev, "transfer --> %d\n", urb->status); 315 if ((++hub->nerrors < 10) || hub->error) 316 goto resubmit; 317 hub->error = urb->status; 318 /* FALL THROUGH */ 319 320 /* let khubd handle things */ 321 case 0: /* we got data: port status changed */ 322 bits = 0; 323 for (i = 0; i < urb->actual_length; ++i) 324 bits |= ((unsigned long) ((*hub->buffer)[i])) 325 << (i*8); 326 hub->event_bits[0] = bits; 327 break; 328 } 329 330 hub->nerrors = 0; 331 332 /* Something happened, let khubd figure it out */ 333 kick_khubd(hub); 334 335 resubmit: 336 if (hub->quiescing) 337 return; 338 339 if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0 340 && status != -ENODEV && status != -EPERM) 341 dev_err (hub->intfdev, "resubmit --> %d\n", status); 342 } 343 344 /* USB 2.0 spec Section 11.24.2.3 */ 345 static inline int 346 hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt) 347 { 348 return usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 349 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo, 350 tt, NULL, 0, 1000); 351 } 352 353 /* 354 * enumeration blocks khubd for a long time. we use keventd instead, since 355 * long blocking there is the exception, not the rule. accordingly, HCDs 356 * talking to TTs must queue control transfers (not just bulk and iso), so 357 * both can talk to the same hub concurrently. 358 */ 359 static void hub_tt_kevent (void *arg) 360 { 361 struct usb_hub *hub = arg; 362 unsigned long flags; 363 364 spin_lock_irqsave (&hub->tt.lock, flags); 365 while (!list_empty (&hub->tt.clear_list)) { 366 struct list_head *temp; 367 struct usb_tt_clear *clear; 368 struct usb_device *hdev = hub->hdev; 369 int status; 370 371 temp = hub->tt.clear_list.next; 372 clear = list_entry (temp, struct usb_tt_clear, clear_list); 373 list_del (&clear->clear_list); 374 375 /* drop lock so HCD can concurrently report other TT errors */ 376 spin_unlock_irqrestore (&hub->tt.lock, flags); 377 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt); 378 spin_lock_irqsave (&hub->tt.lock, flags); 379 380 if (status) 381 dev_err (&hdev->dev, 382 "clear tt %d (%04x) error %d\n", 383 clear->tt, clear->devinfo, status); 384 kfree(clear); 385 } 386 spin_unlock_irqrestore (&hub->tt.lock, flags); 387 } 388 389 /** 390 * usb_hub_tt_clear_buffer - clear control/bulk TT state in high speed hub 391 * @udev: the device whose split transaction failed 392 * @pipe: identifies the endpoint of the failed transaction 393 * 394 * High speed HCDs use this to tell the hub driver that some split control or 395 * bulk transaction failed in a way that requires clearing internal state of 396 * a transaction translator. This is normally detected (and reported) from 397 * interrupt context. 398 * 399 * It may not be possible for that hub to handle additional full (or low) 400 * speed transactions until that state is fully cleared out. 401 */ 402 void usb_hub_tt_clear_buffer (struct usb_device *udev, int pipe) 403 { 404 struct usb_tt *tt = udev->tt; 405 unsigned long flags; 406 struct usb_tt_clear *clear; 407 408 /* we've got to cope with an arbitrary number of pending TT clears, 409 * since each TT has "at least two" buffers that can need it (and 410 * there can be many TTs per hub). even if they're uncommon. 411 */ 412 if ((clear = kmalloc (sizeof *clear, SLAB_ATOMIC)) == NULL) { 413 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n"); 414 /* FIXME recover somehow ... RESET_TT? */ 415 return; 416 } 417 418 /* info that CLEAR_TT_BUFFER needs */ 419 clear->tt = tt->multi ? udev->ttport : 1; 420 clear->devinfo = usb_pipeendpoint (pipe); 421 clear->devinfo |= udev->devnum << 4; 422 clear->devinfo |= usb_pipecontrol (pipe) 423 ? (USB_ENDPOINT_XFER_CONTROL << 11) 424 : (USB_ENDPOINT_XFER_BULK << 11); 425 if (usb_pipein (pipe)) 426 clear->devinfo |= 1 << 15; 427 428 /* tell keventd to clear state for this TT */ 429 spin_lock_irqsave (&tt->lock, flags); 430 list_add_tail (&clear->clear_list, &tt->clear_list); 431 schedule_work (&tt->kevent); 432 spin_unlock_irqrestore (&tt->lock, flags); 433 } 434 435 static void hub_power_on(struct usb_hub *hub) 436 { 437 int port1; 438 439 /* if hub supports power switching, enable power on each port */ 440 if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) < 2) { 441 dev_dbg(hub->intfdev, "enabling power on all ports\n"); 442 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++) 443 set_port_feature(hub->hdev, port1, 444 USB_PORT_FEAT_POWER); 445 } 446 447 /* Wait for power to be enabled */ 448 msleep(hub->descriptor->bPwrOn2PwrGood * 2); 449 } 450 451 static void hub_quiesce(struct usb_hub *hub) 452 { 453 /* stop khubd and related activity */ 454 hub->quiescing = 1; 455 usb_kill_urb(hub->urb); 456 if (hub->has_indicators) 457 cancel_delayed_work(&hub->leds); 458 if (hub->has_indicators || hub->tt.hub) 459 flush_scheduled_work(); 460 } 461 462 static void hub_activate(struct usb_hub *hub) 463 { 464 int status; 465 466 hub->quiescing = 0; 467 hub->activating = 1; 468 status = usb_submit_urb(hub->urb, GFP_NOIO); 469 if (status < 0) 470 dev_err(hub->intfdev, "activate --> %d\n", status); 471 if (hub->has_indicators && blinkenlights) 472 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD); 473 474 /* scan all ports ASAP */ 475 kick_khubd(hub); 476 } 477 478 static int hub_hub_status(struct usb_hub *hub, 479 u16 *status, u16 *change) 480 { 481 int ret; 482 483 ret = get_hub_status(hub->hdev, &hub->status->hub); 484 if (ret < 0) 485 dev_err (hub->intfdev, 486 "%s failed (err = %d)\n", __FUNCTION__, ret); 487 else { 488 *status = le16_to_cpu(hub->status->hub.wHubStatus); 489 *change = le16_to_cpu(hub->status->hub.wHubChange); 490 ret = 0; 491 } 492 return ret; 493 } 494 495 static int hub_configure(struct usb_hub *hub, 496 struct usb_endpoint_descriptor *endpoint) 497 { 498 struct usb_device *hdev = hub->hdev; 499 struct device *hub_dev = hub->intfdev; 500 u16 hubstatus, hubchange; 501 unsigned int pipe; 502 int maxp, ret; 503 char *message; 504 505 hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL, 506 &hub->buffer_dma); 507 if (!hub->buffer) { 508 message = "can't allocate hub irq buffer"; 509 ret = -ENOMEM; 510 goto fail; 511 } 512 513 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL); 514 if (!hub->status) { 515 message = "can't kmalloc hub status buffer"; 516 ret = -ENOMEM; 517 goto fail; 518 } 519 520 hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL); 521 if (!hub->descriptor) { 522 message = "can't kmalloc hub descriptor"; 523 ret = -ENOMEM; 524 goto fail; 525 } 526 527 /* Request the entire hub descriptor. 528 * hub->descriptor can handle USB_MAXCHILDREN ports, 529 * but the hub can/will return fewer bytes here. 530 */ 531 ret = get_hub_descriptor(hdev, hub->descriptor, 532 sizeof(*hub->descriptor)); 533 if (ret < 0) { 534 message = "can't read hub descriptor"; 535 goto fail; 536 } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) { 537 message = "hub has too many ports!"; 538 ret = -ENODEV; 539 goto fail; 540 } 541 542 hdev->maxchild = hub->descriptor->bNbrPorts; 543 dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild, 544 (hdev->maxchild == 1) ? "" : "s"); 545 546 le16_to_cpus(&hub->descriptor->wHubCharacteristics); 547 548 if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND) { 549 int i; 550 char portstr [USB_MAXCHILDREN + 1]; 551 552 for (i = 0; i < hdev->maxchild; i++) 553 portstr[i] = hub->descriptor->DeviceRemovable 554 [((i + 1) / 8)] & (1 << ((i + 1) % 8)) 555 ? 'F' : 'R'; 556 portstr[hdev->maxchild] = 0; 557 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr); 558 } else 559 dev_dbg(hub_dev, "standalone hub\n"); 560 561 switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) { 562 case 0x00: 563 dev_dbg(hub_dev, "ganged power switching\n"); 564 break; 565 case 0x01: 566 dev_dbg(hub_dev, "individual port power switching\n"); 567 break; 568 case 0x02: 569 case 0x03: 570 dev_dbg(hub_dev, "no power switching (usb 1.0)\n"); 571 break; 572 } 573 574 switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) { 575 case 0x00: 576 dev_dbg(hub_dev, "global over-current protection\n"); 577 break; 578 case 0x08: 579 dev_dbg(hub_dev, "individual port over-current protection\n"); 580 break; 581 case 0x10: 582 case 0x18: 583 dev_dbg(hub_dev, "no over-current protection\n"); 584 break; 585 } 586 587 spin_lock_init (&hub->tt.lock); 588 INIT_LIST_HEAD (&hub->tt.clear_list); 589 INIT_WORK (&hub->tt.kevent, hub_tt_kevent, hub); 590 switch (hdev->descriptor.bDeviceProtocol) { 591 case 0: 592 break; 593 case 1: 594 dev_dbg(hub_dev, "Single TT\n"); 595 hub->tt.hub = hdev; 596 break; 597 case 2: 598 ret = usb_set_interface(hdev, 0, 1); 599 if (ret == 0) { 600 dev_dbg(hub_dev, "TT per port\n"); 601 hub->tt.multi = 1; 602 } else 603 dev_err(hub_dev, "Using single TT (err %d)\n", 604 ret); 605 hub->tt.hub = hdev; 606 break; 607 default: 608 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", 609 hdev->descriptor.bDeviceProtocol); 610 break; 611 } 612 613 switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) { 614 case 0x00: 615 if (hdev->descriptor.bDeviceProtocol != 0) 616 dev_dbg(hub_dev, "TT requires at most 8 FS bit times\n"); 617 break; 618 case 0x20: 619 dev_dbg(hub_dev, "TT requires at most 16 FS bit times\n"); 620 break; 621 case 0x40: 622 dev_dbg(hub_dev, "TT requires at most 24 FS bit times\n"); 623 break; 624 case 0x60: 625 dev_dbg(hub_dev, "TT requires at most 32 FS bit times\n"); 626 break; 627 } 628 629 /* probe() zeroes hub->indicator[] */ 630 if (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) { 631 hub->has_indicators = 1; 632 dev_dbg(hub_dev, "Port indicators are supported\n"); 633 } 634 635 dev_dbg(hub_dev, "power on to power good time: %dms\n", 636 hub->descriptor->bPwrOn2PwrGood * 2); 637 638 /* power budgeting mostly matters with bus-powered hubs, 639 * and battery-powered root hubs (may provide just 8 mA). 640 */ 641 ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus); 642 if (ret < 0) { 643 message = "can't get hub status"; 644 goto fail; 645 } 646 le16_to_cpus(&hubstatus); 647 if (hdev == hdev->bus->root_hub) { 648 struct usb_hcd *hcd = 649 container_of(hdev->bus, struct usb_hcd, self); 650 651 hub->power_budget = min(500u, hcd->power_budget) / 2; 652 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) { 653 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n", 654 hub->descriptor->bHubContrCurrent); 655 hub->power_budget = (501 - hub->descriptor->bHubContrCurrent) 656 / 2; 657 } 658 if (hub->power_budget) 659 dev_dbg(hub_dev, "%dmA bus power budget for children\n", 660 hub->power_budget * 2); 661 662 663 ret = hub_hub_status(hub, &hubstatus, &hubchange); 664 if (ret < 0) { 665 message = "can't get hub status"; 666 goto fail; 667 } 668 669 /* local power status reports aren't always correct */ 670 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER) 671 dev_dbg(hub_dev, "local power source is %s\n", 672 (hubstatus & HUB_STATUS_LOCAL_POWER) 673 ? "lost (inactive)" : "good"); 674 675 if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) == 0) 676 dev_dbg(hub_dev, "%sover-current condition exists\n", 677 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no "); 678 679 /* set up the interrupt endpoint */ 680 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress); 681 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe)); 682 683 if (maxp > sizeof(*hub->buffer)) 684 maxp = sizeof(*hub->buffer); 685 686 hub->urb = usb_alloc_urb(0, GFP_KERNEL); 687 if (!hub->urb) { 688 message = "couldn't allocate interrupt urb"; 689 ret = -ENOMEM; 690 goto fail; 691 } 692 693 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, 694 hub, endpoint->bInterval); 695 hub->urb->transfer_dma = hub->buffer_dma; 696 hub->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 697 698 /* maybe cycle the hub leds */ 699 if (hub->has_indicators && blinkenlights) 700 hub->indicator [0] = INDICATOR_CYCLE; 701 702 hub_power_on(hub); 703 hub_activate(hub); 704 return 0; 705 706 fail: 707 dev_err (hub_dev, "config failed, %s (err %d)\n", 708 message, ret); 709 /* hub_disconnect() frees urb and descriptor */ 710 return ret; 711 } 712 713 static unsigned highspeed_hubs; 714 715 static void hub_disconnect(struct usb_interface *intf) 716 { 717 struct usb_hub *hub = usb_get_intfdata (intf); 718 struct usb_device *hdev; 719 720 if (!hub) 721 return; 722 hdev = hub->hdev; 723 724 if (hdev->speed == USB_SPEED_HIGH) 725 highspeed_hubs--; 726 727 usb_set_intfdata (intf, NULL); 728 729 hub_quiesce(hub); 730 usb_free_urb(hub->urb); 731 hub->urb = NULL; 732 733 spin_lock_irq(&hub_event_lock); 734 list_del_init(&hub->event_list); 735 spin_unlock_irq(&hub_event_lock); 736 737 kfree(hub->descriptor); 738 hub->descriptor = NULL; 739 740 kfree(hub->status); 741 hub->status = NULL; 742 743 if (hub->buffer) { 744 usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer, 745 hub->buffer_dma); 746 hub->buffer = NULL; 747 } 748 749 /* Free the memory */ 750 kfree(hub); 751 } 752 753 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) 754 { 755 struct usb_host_interface *desc; 756 struct usb_endpoint_descriptor *endpoint; 757 struct usb_device *hdev; 758 struct usb_hub *hub; 759 760 desc = intf->cur_altsetting; 761 hdev = interface_to_usbdev(intf); 762 763 /* Some hubs have a subclass of 1, which AFAICT according to the */ 764 /* specs is not defined, but it works */ 765 if ((desc->desc.bInterfaceSubClass != 0) && 766 (desc->desc.bInterfaceSubClass != 1)) { 767 descriptor_error: 768 dev_err (&intf->dev, "bad descriptor, ignoring hub\n"); 769 return -EIO; 770 } 771 772 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 773 if (desc->desc.bNumEndpoints != 1) 774 goto descriptor_error; 775 776 endpoint = &desc->endpoint[0].desc; 777 778 /* Output endpoint? Curiouser and curiouser.. */ 779 if (!(endpoint->bEndpointAddress & USB_DIR_IN)) 780 goto descriptor_error; 781 782 /* If it's not an interrupt endpoint, we'd better punt! */ 783 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 784 != USB_ENDPOINT_XFER_INT) 785 goto descriptor_error; 786 787 /* We found a hub */ 788 dev_info (&intf->dev, "USB hub found\n"); 789 790 hub = kmalloc(sizeof(*hub), GFP_KERNEL); 791 if (!hub) { 792 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n"); 793 return -ENOMEM; 794 } 795 796 memset(hub, 0, sizeof(*hub)); 797 798 INIT_LIST_HEAD(&hub->event_list); 799 hub->intfdev = &intf->dev; 800 hub->hdev = hdev; 801 INIT_WORK(&hub->leds, led_work, hub); 802 803 usb_set_intfdata (intf, hub); 804 805 if (hdev->speed == USB_SPEED_HIGH) 806 highspeed_hubs++; 807 808 if (hub_configure(hub, endpoint) >= 0) 809 return 0; 810 811 hub_disconnect (intf); 812 return -ENODEV; 813 } 814 815 static int 816 hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data) 817 { 818 struct usb_device *hdev = interface_to_usbdev (intf); 819 820 /* assert ifno == 0 (part of hub spec) */ 821 switch (code) { 822 case USBDEVFS_HUB_PORTINFO: { 823 struct usbdevfs_hub_portinfo *info = user_data; 824 int i; 825 826 spin_lock_irq(&device_state_lock); 827 if (hdev->devnum <= 0) 828 info->nports = 0; 829 else { 830 info->nports = hdev->maxchild; 831 for (i = 0; i < info->nports; i++) { 832 if (hdev->children[i] == NULL) 833 info->port[i] = 0; 834 else 835 info->port[i] = 836 hdev->children[i]->devnum; 837 } 838 } 839 spin_unlock_irq(&device_state_lock); 840 841 return info->nports + 1; 842 } 843 844 default: 845 return -ENOSYS; 846 } 847 } 848 849 /* caller has locked the hub device */ 850 static void hub_pre_reset(struct usb_hub *hub) 851 { 852 struct usb_device *hdev = hub->hdev; 853 int i; 854 855 for (i = 0; i < hdev->maxchild; ++i) { 856 if (hdev->children[i]) 857 usb_disconnect(&hdev->children[i]); 858 } 859 hub_quiesce(hub); 860 } 861 862 /* caller has locked the hub device */ 863 static void hub_post_reset(struct usb_hub *hub) 864 { 865 hub_activate(hub); 866 hub_power_on(hub); 867 } 868 869 870 /* grab device/port lock, returning index of that port (zero based). 871 * protects the upstream link used by this device from concurrent 872 * tree operations like suspend, resume, reset, and disconnect, which 873 * apply to everything downstream of a given port. 874 */ 875 static int locktree(struct usb_device *udev) 876 { 877 int t; 878 struct usb_device *hdev; 879 880 if (!udev) 881 return -ENODEV; 882 883 /* root hub is always the first lock in the series */ 884 hdev = udev->parent; 885 if (!hdev) { 886 usb_lock_device(udev); 887 return 0; 888 } 889 890 /* on the path from root to us, lock everything from 891 * top down, dropping parent locks when not needed 892 */ 893 t = locktree(hdev); 894 if (t < 0) 895 return t; 896 for (t = 0; t < hdev->maxchild; t++) { 897 if (hdev->children[t] == udev) { 898 /* everything is fail-fast once disconnect 899 * processing starts 900 */ 901 if (udev->state == USB_STATE_NOTATTACHED) 902 break; 903 904 /* when everyone grabs locks top->bottom, 905 * non-overlapping work may be concurrent 906 */ 907 down(&udev->serialize); 908 up(&hdev->serialize); 909 return t + 1; 910 } 911 } 912 usb_unlock_device(hdev); 913 return -ENODEV; 914 } 915 916 static void recursively_mark_NOTATTACHED(struct usb_device *udev) 917 { 918 int i; 919 920 for (i = 0; i < udev->maxchild; ++i) { 921 if (udev->children[i]) 922 recursively_mark_NOTATTACHED(udev->children[i]); 923 } 924 udev->state = USB_STATE_NOTATTACHED; 925 } 926 927 /** 928 * usb_set_device_state - change a device's current state (usbcore, hcds) 929 * @udev: pointer to device whose state should be changed 930 * @new_state: new state value to be stored 931 * 932 * udev->state is _not_ fully protected by the device lock. Although 933 * most transitions are made only while holding the lock, the state can 934 * can change to USB_STATE_NOTATTACHED at almost any time. This 935 * is so that devices can be marked as disconnected as soon as possible, 936 * without having to wait for any semaphores to be released. As a result, 937 * all changes to any device's state must be protected by the 938 * device_state_lock spinlock. 939 * 940 * Once a device has been added to the device tree, all changes to its state 941 * should be made using this routine. The state should _not_ be set directly. 942 * 943 * If udev->state is already USB_STATE_NOTATTACHED then no change is made. 944 * Otherwise udev->state is set to new_state, and if new_state is 945 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set 946 * to USB_STATE_NOTATTACHED. 947 */ 948 void usb_set_device_state(struct usb_device *udev, 949 enum usb_device_state new_state) 950 { 951 unsigned long flags; 952 953 spin_lock_irqsave(&device_state_lock, flags); 954 if (udev->state == USB_STATE_NOTATTACHED) 955 ; /* do nothing */ 956 else if (new_state != USB_STATE_NOTATTACHED) 957 udev->state = new_state; 958 else 959 recursively_mark_NOTATTACHED(udev); 960 spin_unlock_irqrestore(&device_state_lock, flags); 961 } 962 EXPORT_SYMBOL(usb_set_device_state); 963 964 965 static void choose_address(struct usb_device *udev) 966 { 967 int devnum; 968 struct usb_bus *bus = udev->bus; 969 970 /* If khubd ever becomes multithreaded, this will need a lock */ 971 972 /* Try to allocate the next devnum beginning at bus->devnum_next. */ 973 devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 974 bus->devnum_next); 975 if (devnum >= 128) 976 devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1); 977 978 bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1); 979 980 if (devnum < 128) { 981 set_bit(devnum, bus->devmap.devicemap); 982 udev->devnum = devnum; 983 } 984 } 985 986 static void release_address(struct usb_device *udev) 987 { 988 if (udev->devnum > 0) { 989 clear_bit(udev->devnum, udev->bus->devmap.devicemap); 990 udev->devnum = -1; 991 } 992 } 993 994 /** 995 * usb_disconnect - disconnect a device (usbcore-internal) 996 * @pdev: pointer to device being disconnected 997 * Context: !in_interrupt () 998 * 999 * Something got disconnected. Get rid of it and all of its children. 1000 * 1001 * If *pdev is a normal device then the parent hub must already be locked. 1002 * If *pdev is a root hub then this routine will acquire the 1003 * usb_bus_list_lock on behalf of the caller. 1004 * 1005 * Only hub drivers (including virtual root hub drivers for host 1006 * controllers) should ever call this. 1007 * 1008 * This call is synchronous, and may not be used in an interrupt context. 1009 */ 1010 void usb_disconnect(struct usb_device **pdev) 1011 { 1012 struct usb_device *udev = *pdev; 1013 int i; 1014 1015 if (!udev) { 1016 pr_debug ("%s nodev\n", __FUNCTION__); 1017 return; 1018 } 1019 1020 /* mark the device as inactive, so any further urb submissions for 1021 * this device (and any of its children) will fail immediately. 1022 * this quiesces everyting except pending urbs. 1023 */ 1024 usb_set_device_state(udev, USB_STATE_NOTATTACHED); 1025 1026 /* lock the bus list on behalf of HCDs unregistering their root hubs */ 1027 if (!udev->parent) { 1028 down(&usb_bus_list_lock); 1029 usb_lock_device(udev); 1030 } else 1031 down(&udev->serialize); 1032 1033 dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum); 1034 1035 /* Free up all the children before we remove this device */ 1036 for (i = 0; i < USB_MAXCHILDREN; i++) { 1037 if (udev->children[i]) 1038 usb_disconnect(&udev->children[i]); 1039 } 1040 1041 /* deallocate hcd/hardware state ... nuking all pending urbs and 1042 * cleaning up all state associated with the current configuration 1043 * so that the hardware is now fully quiesced. 1044 */ 1045 usb_disable_device(udev, 0); 1046 1047 /* Free the device number, remove the /proc/bus/usb entry and 1048 * the sysfs attributes, and delete the parent's children[] 1049 * (or root_hub) pointer. 1050 */ 1051 dev_dbg (&udev->dev, "unregistering device\n"); 1052 release_address(udev); 1053 usbfs_remove_device(udev); 1054 usb_remove_sysfs_dev_files(udev); 1055 1056 /* Avoid races with recursively_mark_NOTATTACHED() */ 1057 spin_lock_irq(&device_state_lock); 1058 *pdev = NULL; 1059 spin_unlock_irq(&device_state_lock); 1060 1061 if (!udev->parent) { 1062 usb_unlock_device(udev); 1063 up(&usb_bus_list_lock); 1064 } else 1065 up(&udev->serialize); 1066 1067 device_unregister(&udev->dev); 1068 } 1069 1070 static int choose_configuration(struct usb_device *udev) 1071 { 1072 int c, i; 1073 1074 /* NOTE: this should interact with hub power budgeting */ 1075 1076 c = udev->config[0].desc.bConfigurationValue; 1077 if (udev->descriptor.bNumConfigurations != 1) { 1078 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) { 1079 struct usb_interface_descriptor *desc; 1080 1081 /* heuristic: Linux is more likely to have class 1082 * drivers, so avoid vendor-specific interfaces. 1083 */ 1084 desc = &udev->config[i].intf_cache[0] 1085 ->altsetting->desc; 1086 if (desc->bInterfaceClass == USB_CLASS_VENDOR_SPEC) 1087 continue; 1088 /* COMM/2/all is CDC ACM, except 0xff is MSFT RNDIS. 1089 * MSFT needs this to be the first config; never use 1090 * it as the default unless Linux has host-side RNDIS. 1091 * A second config would ideally be CDC-Ethernet, but 1092 * may instead be the "vendor specific" CDC subset 1093 * long used by ARM Linux for sa1100 or pxa255. 1094 */ 1095 if (desc->bInterfaceClass == USB_CLASS_COMM 1096 && desc->bInterfaceSubClass == 2 1097 && desc->bInterfaceProtocol == 0xff) { 1098 c = udev->config[1].desc.bConfigurationValue; 1099 continue; 1100 } 1101 c = udev->config[i].desc.bConfigurationValue; 1102 break; 1103 } 1104 dev_info(&udev->dev, 1105 "configuration #%d chosen from %d choices\n", 1106 c, udev->descriptor.bNumConfigurations); 1107 } 1108 return c; 1109 } 1110 1111 #ifdef DEBUG 1112 static void show_string(struct usb_device *udev, char *id, char *string) 1113 { 1114 if (!string) 1115 return; 1116 dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string); 1117 } 1118 1119 #else 1120 static inline void show_string(struct usb_device *udev, char *id, char *string) 1121 {} 1122 #endif 1123 1124 static void get_string(struct usb_device *udev, char **string, int index) 1125 { 1126 char *buf; 1127 1128 if (!index) 1129 return; 1130 buf = kmalloc(256, GFP_KERNEL); 1131 if (!buf) 1132 return; 1133 if (usb_string(udev, index, buf, 256) > 0) 1134 *string = buf; 1135 else 1136 kfree(buf); 1137 } 1138 1139 1140 #ifdef CONFIG_USB_OTG 1141 #include "otg_whitelist.h" 1142 #endif 1143 1144 /** 1145 * usb_new_device - perform initial device setup (usbcore-internal) 1146 * @udev: newly addressed device (in ADDRESS state) 1147 * 1148 * This is called with devices which have been enumerated, but not yet 1149 * configured. The device descriptor is available, but not descriptors 1150 * for any device configuration. The caller must have locked udev and 1151 * either the parent hub (if udev is a normal device) or else the 1152 * usb_bus_list_lock (if udev is a root hub). The parent's pointer to 1153 * udev has already been installed, but udev is not yet visible through 1154 * sysfs or other filesystem code. 1155 * 1156 * Returns 0 for success (device is configured and listed, with its 1157 * interfaces, in sysfs); else a negative errno value. 1158 * 1159 * This call is synchronous, and may not be used in an interrupt context. 1160 * 1161 * Only the hub driver should ever call this; root hub registration 1162 * uses it indirectly. 1163 */ 1164 int usb_new_device(struct usb_device *udev) 1165 { 1166 int err; 1167 int c; 1168 1169 err = usb_get_configuration(udev); 1170 if (err < 0) { 1171 dev_err(&udev->dev, "can't read configurations, error %d\n", 1172 err); 1173 goto fail; 1174 } 1175 1176 /* read the standard strings and cache them if present */ 1177 get_string(udev, &udev->product, udev->descriptor.iProduct); 1178 get_string(udev, &udev->manufacturer, udev->descriptor.iManufacturer); 1179 get_string(udev, &udev->serial, udev->descriptor.iSerialNumber); 1180 1181 /* Tell the world! */ 1182 dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, " 1183 "SerialNumber=%d\n", 1184 udev->descriptor.iManufacturer, 1185 udev->descriptor.iProduct, 1186 udev->descriptor.iSerialNumber); 1187 show_string(udev, "Product", udev->product); 1188 show_string(udev, "Manufacturer", udev->manufacturer); 1189 show_string(udev, "SerialNumber", udev->serial); 1190 1191 #ifdef CONFIG_USB_OTG 1192 /* 1193 * OTG-aware devices on OTG-capable root hubs may be able to use SRP, 1194 * to wake us after we've powered off VBUS; and HNP, switching roles 1195 * "host" to "peripheral". The OTG descriptor helps figure this out. 1196 */ 1197 if (!udev->bus->is_b_host 1198 && udev->config 1199 && udev->parent == udev->bus->root_hub) { 1200 struct usb_otg_descriptor *desc = 0; 1201 struct usb_bus *bus = udev->bus; 1202 1203 /* descriptor may appear anywhere in config */ 1204 if (__usb_get_extra_descriptor (udev->rawdescriptors[0], 1205 le16_to_cpu(udev->config[0].desc.wTotalLength), 1206 USB_DT_OTG, (void **) &desc) == 0) { 1207 if (desc->bmAttributes & USB_OTG_HNP) { 1208 unsigned port1; 1209 struct usb_device *root = udev->parent; 1210 1211 for (port1 = 1; port1 <= root->maxchild; 1212 port1++) { 1213 if (root->children[port1-1] == udev) 1214 break; 1215 } 1216 1217 dev_info(&udev->dev, 1218 "Dual-Role OTG device on %sHNP port\n", 1219 (port1 == bus->otg_port) 1220 ? "" : "non-"); 1221 1222 /* enable HNP before suspend, it's simpler */ 1223 if (port1 == bus->otg_port) 1224 bus->b_hnp_enable = 1; 1225 err = usb_control_msg(udev, 1226 usb_sndctrlpipe(udev, 0), 1227 USB_REQ_SET_FEATURE, 0, 1228 bus->b_hnp_enable 1229 ? USB_DEVICE_B_HNP_ENABLE 1230 : USB_DEVICE_A_ALT_HNP_SUPPORT, 1231 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 1232 if (err < 0) { 1233 /* OTG MESSAGE: report errors here, 1234 * customize to match your product. 1235 */ 1236 dev_info(&udev->dev, 1237 "can't set HNP mode; %d\n", 1238 err); 1239 bus->b_hnp_enable = 0; 1240 } 1241 } 1242 } 1243 } 1244 1245 if (!is_targeted(udev)) { 1246 1247 /* Maybe it can talk to us, though we can't talk to it. 1248 * (Includes HNP test device.) 1249 */ 1250 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) { 1251 static int __usb_suspend_device (struct usb_device *, 1252 int port1, pm_message_t state); 1253 err = __usb_suspend_device(udev, 1254 udev->bus->otg_port, 1255 PMSG_SUSPEND); 1256 if (err < 0) 1257 dev_dbg(&udev->dev, "HNP fail, %d\n", err); 1258 } 1259 err = -ENODEV; 1260 goto fail; 1261 } 1262 #endif 1263 1264 /* put device-specific files into sysfs */ 1265 err = device_add (&udev->dev); 1266 if (err) { 1267 dev_err(&udev->dev, "can't device_add, error %d\n", err); 1268 goto fail; 1269 } 1270 usb_create_sysfs_dev_files (udev); 1271 1272 /* choose and set the configuration. that registers the interfaces 1273 * with the driver core, and lets usb device drivers bind to them. 1274 */ 1275 c = choose_configuration(udev); 1276 if (c < 0) 1277 dev_warn(&udev->dev, 1278 "can't choose an initial configuration\n"); 1279 else { 1280 err = usb_set_configuration(udev, c); 1281 if (err) { 1282 dev_err(&udev->dev, "can't set config #%d, error %d\n", 1283 c, err); 1284 usb_remove_sysfs_dev_files(udev); 1285 device_del(&udev->dev); 1286 goto fail; 1287 } 1288 } 1289 1290 /* USB device state == configured ... usable */ 1291 1292 /* add a /proc/bus/usb entry */ 1293 usbfs_add_device(udev); 1294 return 0; 1295 1296 fail: 1297 usb_set_device_state(udev, USB_STATE_NOTATTACHED); 1298 return err; 1299 } 1300 1301 1302 static int hub_port_status(struct usb_hub *hub, int port1, 1303 u16 *status, u16 *change) 1304 { 1305 int ret; 1306 1307 ret = get_port_status(hub->hdev, port1, &hub->status->port); 1308 if (ret < 0) 1309 dev_err (hub->intfdev, 1310 "%s failed (err = %d)\n", __FUNCTION__, ret); 1311 else { 1312 *status = le16_to_cpu(hub->status->port.wPortStatus); 1313 *change = le16_to_cpu(hub->status->port.wPortChange); 1314 ret = 0; 1315 } 1316 return ret; 1317 } 1318 1319 #define PORT_RESET_TRIES 5 1320 #define SET_ADDRESS_TRIES 2 1321 #define GET_DESCRIPTOR_TRIES 2 1322 #define SET_CONFIG_TRIES (2 * (use_both_schemes + 1)) 1323 #define USE_NEW_SCHEME(i) ((i) / 2 == old_scheme_first) 1324 1325 #define HUB_ROOT_RESET_TIME 50 /* times are in msec */ 1326 #define HUB_SHORT_RESET_TIME 10 1327 #define HUB_LONG_RESET_TIME 200 1328 #define HUB_RESET_TIMEOUT 500 1329 1330 static int hub_port_wait_reset(struct usb_hub *hub, int port1, 1331 struct usb_device *udev, unsigned int delay) 1332 { 1333 int delay_time, ret; 1334 u16 portstatus; 1335 u16 portchange; 1336 1337 for (delay_time = 0; 1338 delay_time < HUB_RESET_TIMEOUT; 1339 delay_time += delay) { 1340 /* wait to give the device a chance to reset */ 1341 msleep(delay); 1342 1343 /* read and decode port status */ 1344 ret = hub_port_status(hub, port1, &portstatus, &portchange); 1345 if (ret < 0) 1346 return ret; 1347 1348 /* Device went away? */ 1349 if (!(portstatus & USB_PORT_STAT_CONNECTION)) 1350 return -ENOTCONN; 1351 1352 /* bomb out completely if something weird happened */ 1353 if ((portchange & USB_PORT_STAT_C_CONNECTION)) 1354 return -EINVAL; 1355 1356 /* if we`ve finished resetting, then break out of the loop */ 1357 if (!(portstatus & USB_PORT_STAT_RESET) && 1358 (portstatus & USB_PORT_STAT_ENABLE)) { 1359 if (portstatus & USB_PORT_STAT_HIGH_SPEED) 1360 udev->speed = USB_SPEED_HIGH; 1361 else if (portstatus & USB_PORT_STAT_LOW_SPEED) 1362 udev->speed = USB_SPEED_LOW; 1363 else 1364 udev->speed = USB_SPEED_FULL; 1365 return 0; 1366 } 1367 1368 /* switch to the long delay after two short delay failures */ 1369 if (delay_time >= 2 * HUB_SHORT_RESET_TIME) 1370 delay = HUB_LONG_RESET_TIME; 1371 1372 dev_dbg (hub->intfdev, 1373 "port %d not reset yet, waiting %dms\n", 1374 port1, delay); 1375 } 1376 1377 return -EBUSY; 1378 } 1379 1380 static int hub_port_reset(struct usb_hub *hub, int port1, 1381 struct usb_device *udev, unsigned int delay) 1382 { 1383 int i, status; 1384 1385 /* Reset the port */ 1386 for (i = 0; i < PORT_RESET_TRIES; i++) { 1387 status = set_port_feature(hub->hdev, 1388 port1, USB_PORT_FEAT_RESET); 1389 if (status) 1390 dev_err(hub->intfdev, 1391 "cannot reset port %d (err = %d)\n", 1392 port1, status); 1393 else { 1394 status = hub_port_wait_reset(hub, port1, udev, delay); 1395 if (status) 1396 dev_dbg(hub->intfdev, 1397 "port_wait_reset: err = %d\n", 1398 status); 1399 } 1400 1401 /* return on disconnect or reset */ 1402 switch (status) { 1403 case 0: 1404 /* TRSTRCY = 10 ms */ 1405 msleep(10); 1406 /* FALL THROUGH */ 1407 case -ENOTCONN: 1408 case -ENODEV: 1409 clear_port_feature(hub->hdev, 1410 port1, USB_PORT_FEAT_C_RESET); 1411 /* FIXME need disconnect() for NOTATTACHED device */ 1412 usb_set_device_state(udev, status 1413 ? USB_STATE_NOTATTACHED 1414 : USB_STATE_DEFAULT); 1415 return status; 1416 } 1417 1418 dev_dbg (hub->intfdev, 1419 "port %d not enabled, trying reset again...\n", 1420 port1); 1421 delay = HUB_LONG_RESET_TIME; 1422 } 1423 1424 dev_err (hub->intfdev, 1425 "Cannot enable port %i. Maybe the USB cable is bad?\n", 1426 port1); 1427 1428 return status; 1429 } 1430 1431 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state) 1432 { 1433 struct usb_device *hdev = hub->hdev; 1434 int ret; 1435 1436 if (hdev->children[port1-1] && set_state) { 1437 usb_set_device_state(hdev->children[port1-1], 1438 USB_STATE_NOTATTACHED); 1439 } 1440 ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE); 1441 if (ret) 1442 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n", 1443 port1, ret); 1444 1445 return ret; 1446 } 1447 1448 /* 1449 * Disable a port and mark a logical connnect-change event, so that some 1450 * time later khubd will disconnect() any existing usb_device on the port 1451 * and will re-enumerate if there actually is a device attached. 1452 */ 1453 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1) 1454 { 1455 dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1); 1456 hub_port_disable(hub, port1, 1); 1457 1458 /* FIXME let caller ask to power down the port: 1459 * - some devices won't enumerate without a VBUS power cycle 1460 * - SRP saves power that way 1461 * - usb_suspend_device(dev, PMSG_SUSPEND) 1462 * That's easy if this hub can switch power per-port, and 1463 * khubd reactivates the port later (timer, SRP, etc). 1464 * Powerdown must be optional, because of reset/DFU. 1465 */ 1466 1467 set_bit(port1, hub->change_bits); 1468 kick_khubd(hub); 1469 } 1470 1471 1472 #ifdef CONFIG_USB_SUSPEND 1473 1474 /* 1475 * Selective port suspend reduces power; most suspended devices draw 1476 * less than 500 uA. It's also used in OTG, along with remote wakeup. 1477 * All devices below the suspended port are also suspended. 1478 * 1479 * Devices leave suspend state when the host wakes them up. Some devices 1480 * also support "remote wakeup", where the device can activate the USB 1481 * tree above them to deliver data, such as a keypress or packet. In 1482 * some cases, this wakes the USB host. 1483 */ 1484 static int hub_port_suspend(struct usb_hub *hub, int port1, 1485 struct usb_device *udev) 1486 { 1487 int status; 1488 1489 // dev_dbg(hub->intfdev, "suspend port %d\n", port1); 1490 1491 /* enable remote wakeup when appropriate; this lets the device 1492 * wake up the upstream hub (including maybe the root hub). 1493 * 1494 * NOTE: OTG devices may issue remote wakeup (or SRP) even when 1495 * we don't explicitly enable it here. 1496 */ 1497 if (udev->actconfig 1498 // && FIXME (remote wakeup enabled on this bus) 1499 // ... currently assuming it's always appropriate 1500 && (udev->actconfig->desc.bmAttributes 1501 & USB_CONFIG_ATT_WAKEUP) != 0) { 1502 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 1503 USB_REQ_SET_FEATURE, USB_RECIP_DEVICE, 1504 USB_DEVICE_REMOTE_WAKEUP, 0, 1505 NULL, 0, 1506 USB_CTRL_SET_TIMEOUT); 1507 if (status) 1508 dev_dbg(&udev->dev, 1509 "won't remote wakeup, status %d\n", 1510 status); 1511 } 1512 1513 /* see 7.1.7.6 */ 1514 status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND); 1515 if (status) { 1516 dev_dbg(hub->intfdev, 1517 "can't suspend port %d, status %d\n", 1518 port1, status); 1519 /* paranoia: "should not happen" */ 1520 (void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 1521 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE, 1522 USB_DEVICE_REMOTE_WAKEUP, 0, 1523 NULL, 0, 1524 USB_CTRL_SET_TIMEOUT); 1525 } else { 1526 /* device has up to 10 msec to fully suspend */ 1527 dev_dbg(&udev->dev, "usb suspend\n"); 1528 usb_set_device_state(udev, USB_STATE_SUSPENDED); 1529 msleep(10); 1530 } 1531 return status; 1532 } 1533 1534 /* 1535 * Devices on USB hub ports have only one "suspend" state, corresponding 1536 * to ACPI D2, "may cause the device to lose some context". 1537 * State transitions include: 1538 * 1539 * - suspend, resume ... when the VBUS power link stays live 1540 * - suspend, disconnect ... VBUS lost 1541 * 1542 * Once VBUS drop breaks the circuit, the port it's using has to go through 1543 * normal re-enumeration procedures, starting with enabling VBUS power. 1544 * Other than re-initializing the hub (plug/unplug, except for root hubs), 1545 * Linux (2.6) currently has NO mechanisms to initiate that: no khubd 1546 * timer, no SRP, no requests through sysfs. 1547 */ 1548 static int __usb_suspend_device (struct usb_device *udev, int port1, 1549 pm_message_t state) 1550 { 1551 int status; 1552 1553 /* caller owns the udev device lock */ 1554 if (port1 < 0) 1555 return port1; 1556 1557 if (udev->state == USB_STATE_SUSPENDED 1558 || udev->state == USB_STATE_NOTATTACHED) { 1559 return 0; 1560 } 1561 1562 /* suspend interface drivers; if this is a hub, it 1563 * suspends the child devices 1564 */ 1565 if (udev->actconfig) { 1566 int i; 1567 1568 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 1569 struct usb_interface *intf; 1570 struct usb_driver *driver; 1571 1572 intf = udev->actconfig->interface[i]; 1573 if (state <= intf->dev.power.power_state) 1574 continue; 1575 if (!intf->dev.driver) 1576 continue; 1577 driver = to_usb_driver(intf->dev.driver); 1578 1579 if (driver->suspend) { 1580 status = driver->suspend(intf, state); 1581 if (intf->dev.power.power_state != state 1582 || status) 1583 dev_err(&intf->dev, 1584 "suspend %d fail, code %d\n", 1585 state, status); 1586 } 1587 1588 /* only drivers with suspend() can ever resume(); 1589 * and after power loss, even they won't. 1590 * bus_rescan_devices() can rebind drivers later. 1591 * 1592 * FIXME the PM core self-deadlocks when unbinding 1593 * drivers during suspend/resume ... everything grabs 1594 * dpm_sem (not a spinlock, ugh). we want to unbind, 1595 * since we know every driver's probe/disconnect works 1596 * even for drivers that can't suspend. 1597 */ 1598 if (!driver->suspend || state > PM_SUSPEND_MEM) { 1599 #if 1 1600 dev_warn(&intf->dev, "resume is unsafe!\n"); 1601 #else 1602 down_write(&usb_bus_type.rwsem); 1603 device_release_driver(&intf->dev); 1604 up_write(&usb_bus_type.rwsem); 1605 #endif 1606 } 1607 } 1608 } 1609 1610 /* 1611 * FIXME this needs port power off call paths too, to help force 1612 * USB into the "generic" PM model. At least for devices on 1613 * ports that aren't using ganged switching (usually root hubs). 1614 * 1615 * NOTE: SRP-capable links should adopt more aggressive poweroff 1616 * policies (when HNP doesn't apply) once we have mechanisms to 1617 * turn power back on! (Likely not before 2.7...) 1618 */ 1619 if (state > PM_SUSPEND_MEM) { 1620 dev_warn(&udev->dev, "no poweroff yet, suspending instead\n"); 1621 } 1622 1623 /* "global suspend" of the HC-to-USB interface (root hub), or 1624 * "selective suspend" of just one hub-device link. 1625 */ 1626 if (!udev->parent) { 1627 struct usb_bus *bus = udev->bus; 1628 if (bus && bus->op->hub_suspend) { 1629 status = bus->op->hub_suspend (bus); 1630 if (status == 0) { 1631 dev_dbg(&udev->dev, "usb suspend\n"); 1632 usb_set_device_state(udev, 1633 USB_STATE_SUSPENDED); 1634 } 1635 } else 1636 status = -EOPNOTSUPP; 1637 } else 1638 status = hub_port_suspend(hdev_to_hub(udev->parent), port1, 1639 udev); 1640 1641 if (status == 0) 1642 udev->dev.power.power_state = state; 1643 return status; 1644 } 1645 1646 /** 1647 * usb_suspend_device - suspend a usb device 1648 * @udev: device that's no longer in active use 1649 * @state: PMSG_SUSPEND to suspend 1650 * Context: must be able to sleep; device not locked 1651 * 1652 * Suspends a USB device that isn't in active use, conserving power. 1653 * Devices may wake out of a suspend, if anything important happens, 1654 * using the remote wakeup mechanism. They may also be taken out of 1655 * suspend by the host, using usb_resume_device(). It's also routine 1656 * to disconnect devices while they are suspended. 1657 * 1658 * Suspending OTG devices may trigger HNP, if that's been enabled 1659 * between a pair of dual-role devices. That will change roles, such 1660 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral. 1661 * 1662 * Returns 0 on success, else negative errno. 1663 */ 1664 int usb_suspend_device(struct usb_device *udev, pm_message_t state) 1665 { 1666 int port1, status; 1667 1668 port1 = locktree(udev); 1669 if (port1 < 0) 1670 return port1; 1671 1672 status = __usb_suspend_device(udev, port1, state); 1673 usb_unlock_device(udev); 1674 return status; 1675 } 1676 1677 /* 1678 * hardware resume signaling is finished, either because of selective 1679 * resume (by host) or remote wakeup (by device) ... now see what changed 1680 * in the tree that's rooted at this device. 1681 */ 1682 static int finish_port_resume(struct usb_device *udev) 1683 { 1684 int status; 1685 u16 devstatus; 1686 1687 /* caller owns the udev device lock */ 1688 dev_dbg(&udev->dev, "usb resume\n"); 1689 1690 /* usb ch9 identifies four variants of SUSPENDED, based on what 1691 * state the device resumes to. Linux currently won't see the 1692 * first two on the host side; they'd be inside hub_port_init() 1693 * during many timeouts, but khubd can't suspend until later. 1694 */ 1695 usb_set_device_state(udev, udev->actconfig 1696 ? USB_STATE_CONFIGURED 1697 : USB_STATE_ADDRESS); 1698 udev->dev.power.power_state = PMSG_ON; 1699 1700 /* 10.5.4.5 says be sure devices in the tree are still there. 1701 * For now let's assume the device didn't go crazy on resume, 1702 * and device drivers will know about any resume quirks. 1703 */ 1704 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus); 1705 if (status < 0) 1706 dev_dbg(&udev->dev, 1707 "gone after usb resume? status %d\n", 1708 status); 1709 else if (udev->actconfig) { 1710 unsigned i; 1711 1712 le16_to_cpus(&devstatus); 1713 if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) { 1714 status = usb_control_msg(udev, 1715 usb_sndctrlpipe(udev, 0), 1716 USB_REQ_CLEAR_FEATURE, 1717 USB_RECIP_DEVICE, 1718 USB_DEVICE_REMOTE_WAKEUP, 0, 1719 NULL, 0, 1720 USB_CTRL_SET_TIMEOUT); 1721 if (status) { 1722 dev_dbg(&udev->dev, "disable remote " 1723 "wakeup, status %d\n", status); 1724 status = 0; 1725 } 1726 } 1727 1728 /* resume interface drivers; if this is a hub, it 1729 * resumes the child devices 1730 */ 1731 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 1732 struct usb_interface *intf; 1733 struct usb_driver *driver; 1734 1735 intf = udev->actconfig->interface[i]; 1736 if (intf->dev.power.power_state == PMSG_ON) 1737 continue; 1738 if (!intf->dev.driver) { 1739 /* FIXME maybe force to alt 0 */ 1740 continue; 1741 } 1742 driver = to_usb_driver(intf->dev.driver); 1743 1744 /* bus_rescan_devices() may rebind drivers */ 1745 if (!driver->resume) 1746 continue; 1747 1748 /* can we do better than just logging errors? */ 1749 status = driver->resume(intf); 1750 if (intf->dev.power.power_state != PMSG_ON 1751 || status) 1752 dev_dbg(&intf->dev, 1753 "resume fail, state %d code %d\n", 1754 intf->dev.power.power_state, status); 1755 } 1756 status = 0; 1757 1758 } else if (udev->devnum <= 0) { 1759 dev_dbg(&udev->dev, "bogus resume!\n"); 1760 status = -EINVAL; 1761 } 1762 return status; 1763 } 1764 1765 static int 1766 hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev) 1767 { 1768 int status; 1769 1770 // dev_dbg(hub->intfdev, "resume port %d\n", port1); 1771 1772 /* see 7.1.7.7; affects power usage, but not budgeting */ 1773 status = clear_port_feature(hub->hdev, 1774 port1, USB_PORT_FEAT_SUSPEND); 1775 if (status) { 1776 dev_dbg(hub->intfdev, 1777 "can't resume port %d, status %d\n", 1778 port1, status); 1779 } else { 1780 u16 devstatus; 1781 u16 portchange; 1782 1783 /* drive resume for at least 20 msec */ 1784 if (udev) 1785 dev_dbg(&udev->dev, "RESUME\n"); 1786 msleep(25); 1787 1788 #define LIVE_FLAGS ( USB_PORT_STAT_POWER \ 1789 | USB_PORT_STAT_ENABLE \ 1790 | USB_PORT_STAT_CONNECTION) 1791 1792 /* Virtual root hubs can trigger on GET_PORT_STATUS to 1793 * stop resume signaling. Then finish the resume 1794 * sequence. 1795 */ 1796 devstatus = portchange = 0; 1797 status = hub_port_status(hub, port1, 1798 &devstatus, &portchange); 1799 if (status < 0 1800 || (devstatus & LIVE_FLAGS) != LIVE_FLAGS 1801 || (devstatus & USB_PORT_STAT_SUSPEND) != 0 1802 ) { 1803 dev_dbg(hub->intfdev, 1804 "port %d status %04x.%04x after resume, %d\n", 1805 port1, portchange, devstatus, status); 1806 } else { 1807 /* TRSMRCY = 10 msec */ 1808 msleep(10); 1809 if (udev) 1810 status = finish_port_resume(udev); 1811 } 1812 } 1813 if (status < 0) 1814 hub_port_logical_disconnect(hub, port1); 1815 1816 return status; 1817 } 1818 1819 static int hub_resume (struct usb_interface *intf); 1820 1821 /** 1822 * usb_resume_device - re-activate a suspended usb device 1823 * @udev: device to re-activate 1824 * Context: must be able to sleep; device not locked 1825 * 1826 * This will re-activate the suspended device, increasing power usage 1827 * while letting drivers communicate again with its endpoints. 1828 * USB resume explicitly guarantees that the power session between 1829 * the host and the device is the same as it was when the device 1830 * suspended. 1831 * 1832 * Returns 0 on success, else negative errno. 1833 */ 1834 int usb_resume_device(struct usb_device *udev) 1835 { 1836 int port1, status; 1837 1838 port1 = locktree(udev); 1839 if (port1 < 0) 1840 return port1; 1841 1842 /* "global resume" of the HC-to-USB interface (root hub), or 1843 * selective resume of one hub-to-device port 1844 */ 1845 if (!udev->parent) { 1846 struct usb_bus *bus = udev->bus; 1847 if (bus && bus->op->hub_resume) { 1848 status = bus->op->hub_resume (bus); 1849 } else 1850 status = -EOPNOTSUPP; 1851 if (status == 0) { 1852 dev_dbg(&udev->dev, "usb resume\n"); 1853 /* TRSMRCY = 10 msec */ 1854 msleep(10); 1855 usb_set_device_state (udev, USB_STATE_CONFIGURED); 1856 udev->dev.power.power_state = PMSG_ON; 1857 status = hub_resume (udev 1858 ->actconfig->interface[0]); 1859 } 1860 } else if (udev->state == USB_STATE_SUSPENDED) { 1861 // NOTE this fails if parent is also suspended... 1862 status = hub_port_resume(hdev_to_hub(udev->parent), 1863 port1, udev); 1864 } else { 1865 status = 0; 1866 } 1867 if (status < 0) { 1868 dev_dbg(&udev->dev, "can't resume, status %d\n", 1869 status); 1870 } 1871 1872 usb_unlock_device(udev); 1873 1874 /* rebind drivers that had no suspend() */ 1875 if (status == 0) { 1876 usb_lock_all_devices(); 1877 bus_rescan_devices(&usb_bus_type); 1878 usb_unlock_all_devices(); 1879 } 1880 return status; 1881 } 1882 1883 static int remote_wakeup(struct usb_device *udev) 1884 { 1885 int status = 0; 1886 1887 /* don't repeat RESUME sequence if this device 1888 * was already woken up by some other task 1889 */ 1890 down(&udev->serialize); 1891 if (udev->state == USB_STATE_SUSPENDED) { 1892 dev_dbg(&udev->dev, "RESUME (wakeup)\n"); 1893 /* TRSMRCY = 10 msec */ 1894 msleep(10); 1895 status = finish_port_resume(udev); 1896 } 1897 up(&udev->serialize); 1898 return status; 1899 } 1900 1901 static int hub_suspend(struct usb_interface *intf, pm_message_t state) 1902 { 1903 struct usb_hub *hub = usb_get_intfdata (intf); 1904 struct usb_device *hdev = hub->hdev; 1905 unsigned port1; 1906 int status; 1907 1908 /* stop khubd and related activity */ 1909 hub_quiesce(hub); 1910 1911 /* then suspend every port */ 1912 for (port1 = 1; port1 <= hdev->maxchild; port1++) { 1913 struct usb_device *udev; 1914 1915 udev = hdev->children [port1-1]; 1916 if (!udev) 1917 continue; 1918 down(&udev->serialize); 1919 status = __usb_suspend_device(udev, port1, state); 1920 up(&udev->serialize); 1921 if (status < 0) 1922 dev_dbg(&intf->dev, "suspend port %d --> %d\n", 1923 port1, status); 1924 } 1925 1926 intf->dev.power.power_state = state; 1927 return 0; 1928 } 1929 1930 static int hub_resume(struct usb_interface *intf) 1931 { 1932 struct usb_device *hdev = interface_to_usbdev(intf); 1933 struct usb_hub *hub = usb_get_intfdata (intf); 1934 unsigned port1; 1935 int status; 1936 1937 if (intf->dev.power.power_state == PM_SUSPEND_ON) 1938 return 0; 1939 1940 for (port1 = 1; port1 <= hdev->maxchild; port1++) { 1941 struct usb_device *udev; 1942 u16 portstat, portchange; 1943 1944 udev = hdev->children [port1-1]; 1945 status = hub_port_status(hub, port1, &portstat, &portchange); 1946 if (status == 0) { 1947 if (portchange & USB_PORT_STAT_C_SUSPEND) { 1948 clear_port_feature(hdev, port1, 1949 USB_PORT_FEAT_C_SUSPEND); 1950 portchange &= ~USB_PORT_STAT_C_SUSPEND; 1951 } 1952 1953 /* let khubd handle disconnects etc */ 1954 if (portchange) 1955 continue; 1956 } 1957 1958 if (!udev || status < 0) 1959 continue; 1960 down (&udev->serialize); 1961 if (portstat & USB_PORT_STAT_SUSPEND) 1962 status = hub_port_resume(hub, port1, udev); 1963 else { 1964 status = finish_port_resume(udev); 1965 if (status < 0) { 1966 dev_dbg(&intf->dev, "resume port %d --> %d\n", 1967 port1, status); 1968 hub_port_logical_disconnect(hub, port1); 1969 } 1970 } 1971 up(&udev->serialize); 1972 } 1973 intf->dev.power.power_state = PMSG_ON; 1974 1975 hub->resume_root_hub = 0; 1976 hub_activate(hub); 1977 return 0; 1978 } 1979 1980 void usb_resume_root_hub(struct usb_device *hdev) 1981 { 1982 struct usb_hub *hub = hdev_to_hub(hdev); 1983 1984 hub->resume_root_hub = 1; 1985 kick_khubd(hub); 1986 } 1987 1988 #else /* !CONFIG_USB_SUSPEND */ 1989 1990 int usb_suspend_device(struct usb_device *udev, pm_message_t state) 1991 { 1992 return 0; 1993 } 1994 1995 int usb_resume_device(struct usb_device *udev) 1996 { 1997 return 0; 1998 } 1999 2000 #define hub_suspend NULL 2001 #define hub_resume NULL 2002 #define remote_wakeup(x) 0 2003 2004 #endif /* CONFIG_USB_SUSPEND */ 2005 2006 EXPORT_SYMBOL(usb_suspend_device); 2007 EXPORT_SYMBOL(usb_resume_device); 2008 2009 2010 2011 /* USB 2.0 spec, 7.1.7.3 / fig 7-29: 2012 * 2013 * Between connect detection and reset signaling there must be a delay 2014 * of 100ms at least for debounce and power-settling. The corresponding 2015 * timer shall restart whenever the downstream port detects a disconnect. 2016 * 2017 * Apparently there are some bluetooth and irda-dongles and a number of 2018 * low-speed devices for which this debounce period may last over a second. 2019 * Not covered by the spec - but easy to deal with. 2020 * 2021 * This implementation uses a 1500ms total debounce timeout; if the 2022 * connection isn't stable by then it returns -ETIMEDOUT. It checks 2023 * every 25ms for transient disconnects. When the port status has been 2024 * unchanged for 100ms it returns the port status. 2025 */ 2026 2027 #define HUB_DEBOUNCE_TIMEOUT 1500 2028 #define HUB_DEBOUNCE_STEP 25 2029 #define HUB_DEBOUNCE_STABLE 100 2030 2031 static int hub_port_debounce(struct usb_hub *hub, int port1) 2032 { 2033 int ret; 2034 int total_time, stable_time = 0; 2035 u16 portchange, portstatus; 2036 unsigned connection = 0xffff; 2037 2038 for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) { 2039 ret = hub_port_status(hub, port1, &portstatus, &portchange); 2040 if (ret < 0) 2041 return ret; 2042 2043 if (!(portchange & USB_PORT_STAT_C_CONNECTION) && 2044 (portstatus & USB_PORT_STAT_CONNECTION) == connection) { 2045 stable_time += HUB_DEBOUNCE_STEP; 2046 if (stable_time >= HUB_DEBOUNCE_STABLE) 2047 break; 2048 } else { 2049 stable_time = 0; 2050 connection = portstatus & USB_PORT_STAT_CONNECTION; 2051 } 2052 2053 if (portchange & USB_PORT_STAT_C_CONNECTION) { 2054 clear_port_feature(hub->hdev, port1, 2055 USB_PORT_FEAT_C_CONNECTION); 2056 } 2057 2058 if (total_time >= HUB_DEBOUNCE_TIMEOUT) 2059 break; 2060 msleep(HUB_DEBOUNCE_STEP); 2061 } 2062 2063 dev_dbg (hub->intfdev, 2064 "debounce: port %d: total %dms stable %dms status 0x%x\n", 2065 port1, total_time, stable_time, portstatus); 2066 2067 if (stable_time < HUB_DEBOUNCE_STABLE) 2068 return -ETIMEDOUT; 2069 return portstatus; 2070 } 2071 2072 static void ep0_reinit(struct usb_device *udev) 2073 { 2074 usb_disable_endpoint(udev, 0 + USB_DIR_IN); 2075 usb_disable_endpoint(udev, 0 + USB_DIR_OUT); 2076 udev->ep_in[0] = udev->ep_out[0] = &udev->ep0; 2077 } 2078 2079 #define usb_sndaddr0pipe() (PIPE_CONTROL << 30) 2080 #define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN) 2081 2082 static int hub_set_address(struct usb_device *udev) 2083 { 2084 int retval; 2085 2086 if (udev->devnum == 0) 2087 return -EINVAL; 2088 if (udev->state == USB_STATE_ADDRESS) 2089 return 0; 2090 if (udev->state != USB_STATE_DEFAULT) 2091 return -EINVAL; 2092 retval = usb_control_msg(udev, usb_sndaddr0pipe(), 2093 USB_REQ_SET_ADDRESS, 0, udev->devnum, 0, 2094 NULL, 0, USB_CTRL_SET_TIMEOUT); 2095 if (retval == 0) { 2096 usb_set_device_state(udev, USB_STATE_ADDRESS); 2097 ep0_reinit(udev); 2098 } 2099 return retval; 2100 } 2101 2102 /* Reset device, (re)assign address, get device descriptor. 2103 * Device connection must be stable, no more debouncing needed. 2104 * Returns device in USB_STATE_ADDRESS, except on error. 2105 * 2106 * If this is called for an already-existing device (as part of 2107 * usb_reset_device), the caller must own the device lock. For a 2108 * newly detected device that is not accessible through any global 2109 * pointers, it's not necessary to lock the device. 2110 */ 2111 static int 2112 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, 2113 int retry_counter) 2114 { 2115 static DECLARE_MUTEX(usb_address0_sem); 2116 2117 struct usb_device *hdev = hub->hdev; 2118 int i, j, retval; 2119 unsigned delay = HUB_SHORT_RESET_TIME; 2120 enum usb_device_speed oldspeed = udev->speed; 2121 2122 /* root hub ports have a slightly longer reset period 2123 * (from USB 2.0 spec, section 7.1.7.5) 2124 */ 2125 if (!hdev->parent) { 2126 delay = HUB_ROOT_RESET_TIME; 2127 if (port1 == hdev->bus->otg_port) 2128 hdev->bus->b_hnp_enable = 0; 2129 } 2130 2131 /* Some low speed devices have problems with the quick delay, so */ 2132 /* be a bit pessimistic with those devices. RHbug #23670 */ 2133 if (oldspeed == USB_SPEED_LOW) 2134 delay = HUB_LONG_RESET_TIME; 2135 2136 down(&usb_address0_sem); 2137 2138 /* Reset the device; full speed may morph to high speed */ 2139 retval = hub_port_reset(hub, port1, udev, delay); 2140 if (retval < 0) /* error or disconnect */ 2141 goto fail; 2142 /* success, speed is known */ 2143 retval = -ENODEV; 2144 2145 if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) { 2146 dev_dbg(&udev->dev, "device reset changed speed!\n"); 2147 goto fail; 2148 } 2149 oldspeed = udev->speed; 2150 2151 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ... 2152 * it's fixed size except for full speed devices. 2153 */ 2154 switch (udev->speed) { 2155 case USB_SPEED_HIGH: /* fixed at 64 */ 2156 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64); 2157 break; 2158 case USB_SPEED_FULL: /* 8, 16, 32, or 64 */ 2159 /* to determine the ep0 maxpacket size, try to read 2160 * the device descriptor to get bMaxPacketSize0 and 2161 * then correct our initial guess. 2162 */ 2163 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64); 2164 break; 2165 case USB_SPEED_LOW: /* fixed at 8 */ 2166 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8); 2167 break; 2168 default: 2169 goto fail; 2170 } 2171 2172 dev_info (&udev->dev, 2173 "%s %s speed USB device using %s and address %d\n", 2174 (udev->config) ? "reset" : "new", 2175 ({ char *speed; switch (udev->speed) { 2176 case USB_SPEED_LOW: speed = "low"; break; 2177 case USB_SPEED_FULL: speed = "full"; break; 2178 case USB_SPEED_HIGH: speed = "high"; break; 2179 default: speed = "?"; break; 2180 }; speed;}), 2181 udev->bus->controller->driver->name, 2182 udev->devnum); 2183 2184 /* Set up TT records, if needed */ 2185 if (hdev->tt) { 2186 udev->tt = hdev->tt; 2187 udev->ttport = hdev->ttport; 2188 } else if (udev->speed != USB_SPEED_HIGH 2189 && hdev->speed == USB_SPEED_HIGH) { 2190 udev->tt = &hub->tt; 2191 udev->ttport = port1; 2192 } 2193 2194 /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way? 2195 * Because device hardware and firmware is sometimes buggy in 2196 * this area, and this is how Linux has done it for ages. 2197 * Change it cautiously. 2198 * 2199 * NOTE: If USE_NEW_SCHEME() is true we will start by issuing 2200 * a 64-byte GET_DESCRIPTOR request. This is what Windows does, 2201 * so it may help with some non-standards-compliant devices. 2202 * Otherwise we start with SET_ADDRESS and then try to read the 2203 * first 8 bytes of the device descriptor to get the ep0 maxpacket 2204 * value. 2205 */ 2206 for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) { 2207 if (USE_NEW_SCHEME(retry_counter)) { 2208 struct usb_device_descriptor *buf; 2209 int r = 0; 2210 2211 #define GET_DESCRIPTOR_BUFSIZE 64 2212 buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO); 2213 if (!buf) { 2214 retval = -ENOMEM; 2215 continue; 2216 } 2217 2218 /* Use a short timeout the first time through, 2219 * so that recalcitrant full-speed devices with 2220 * 8- or 16-byte ep0-maxpackets won't slow things 2221 * down tremendously by NAKing the unexpectedly 2222 * early status stage. Also, retry on all errors; 2223 * some devices are flakey. 2224 */ 2225 for (j = 0; j < 3; ++j) { 2226 buf->bMaxPacketSize0 = 0; 2227 r = usb_control_msg(udev, usb_rcvaddr0pipe(), 2228 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 2229 USB_DT_DEVICE << 8, 0, 2230 buf, GET_DESCRIPTOR_BUFSIZE, 2231 (i ? USB_CTRL_GET_TIMEOUT : 1000)); 2232 switch (buf->bMaxPacketSize0) { 2233 case 8: case 16: case 32: case 64: 2234 if (buf->bDescriptorType == 2235 USB_DT_DEVICE) { 2236 r = 0; 2237 break; 2238 } 2239 /* FALL THROUGH */ 2240 default: 2241 if (r == 0) 2242 r = -EPROTO; 2243 break; 2244 } 2245 if (r == 0) 2246 break; 2247 } 2248 udev->descriptor.bMaxPacketSize0 = 2249 buf->bMaxPacketSize0; 2250 kfree(buf); 2251 2252 retval = hub_port_reset(hub, port1, udev, delay); 2253 if (retval < 0) /* error or disconnect */ 2254 goto fail; 2255 if (oldspeed != udev->speed) { 2256 dev_dbg(&udev->dev, 2257 "device reset changed speed!\n"); 2258 retval = -ENODEV; 2259 goto fail; 2260 } 2261 if (r) { 2262 dev_err(&udev->dev, "device descriptor " 2263 "read/%s, error %d\n", 2264 "64", r); 2265 retval = -EMSGSIZE; 2266 continue; 2267 } 2268 #undef GET_DESCRIPTOR_BUFSIZE 2269 } 2270 2271 for (j = 0; j < SET_ADDRESS_TRIES; ++j) { 2272 retval = hub_set_address(udev); 2273 if (retval >= 0) 2274 break; 2275 msleep(200); 2276 } 2277 if (retval < 0) { 2278 dev_err(&udev->dev, 2279 "device not accepting address %d, error %d\n", 2280 udev->devnum, retval); 2281 goto fail; 2282 } 2283 2284 /* cope with hardware quirkiness: 2285 * - let SET_ADDRESS settle, some device hardware wants it 2286 * - read ep0 maxpacket even for high and low speed, 2287 */ 2288 msleep(10); 2289 if (USE_NEW_SCHEME(retry_counter)) 2290 break; 2291 2292 retval = usb_get_device_descriptor(udev, 8); 2293 if (retval < 8) { 2294 dev_err(&udev->dev, "device descriptor " 2295 "read/%s, error %d\n", 2296 "8", retval); 2297 if (retval >= 0) 2298 retval = -EMSGSIZE; 2299 } else { 2300 retval = 0; 2301 break; 2302 } 2303 } 2304 if (retval) 2305 goto fail; 2306 2307 i = udev->descriptor.bMaxPacketSize0; 2308 if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) { 2309 if (udev->speed != USB_SPEED_FULL || 2310 !(i == 8 || i == 16 || i == 32 || i == 64)) { 2311 dev_err(&udev->dev, "ep0 maxpacket = %d\n", i); 2312 retval = -EMSGSIZE; 2313 goto fail; 2314 } 2315 dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i); 2316 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i); 2317 ep0_reinit(udev); 2318 } 2319 2320 retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE); 2321 if (retval < (signed)sizeof(udev->descriptor)) { 2322 dev_err(&udev->dev, "device descriptor read/%s, error %d\n", 2323 "all", retval); 2324 if (retval >= 0) 2325 retval = -ENOMSG; 2326 goto fail; 2327 } 2328 2329 retval = 0; 2330 2331 fail: 2332 if (retval) 2333 hub_port_disable(hub, port1, 0); 2334 up(&usb_address0_sem); 2335 return retval; 2336 } 2337 2338 static void 2339 check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1) 2340 { 2341 struct usb_qualifier_descriptor *qual; 2342 int status; 2343 2344 qual = kmalloc (sizeof *qual, SLAB_KERNEL); 2345 if (qual == NULL) 2346 return; 2347 2348 status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0, 2349 qual, sizeof *qual); 2350 if (status == sizeof *qual) { 2351 dev_info(&udev->dev, "not running at top speed; " 2352 "connect to a high speed hub\n"); 2353 /* hub LEDs are probably harder to miss than syslog */ 2354 if (hub->has_indicators) { 2355 hub->indicator[port1-1] = INDICATOR_GREEN_BLINK; 2356 schedule_work (&hub->leds); 2357 } 2358 } 2359 kfree(qual); 2360 } 2361 2362 static unsigned 2363 hub_power_remaining (struct usb_hub *hub) 2364 { 2365 struct usb_device *hdev = hub->hdev; 2366 int remaining; 2367 unsigned i; 2368 2369 remaining = hub->power_budget; 2370 if (!remaining) /* self-powered */ 2371 return 0; 2372 2373 for (i = 0; i < hdev->maxchild; i++) { 2374 struct usb_device *udev = hdev->children[i]; 2375 int delta, ceiling; 2376 2377 if (!udev) 2378 continue; 2379 2380 /* 100mA per-port ceiling, or 8mA for OTG ports */ 2381 if (i != (udev->bus->otg_port - 1) || hdev->parent) 2382 ceiling = 50; 2383 else 2384 ceiling = 4; 2385 2386 if (udev->actconfig) 2387 delta = udev->actconfig->desc.bMaxPower; 2388 else 2389 delta = ceiling; 2390 // dev_dbg(&udev->dev, "budgeted %dmA\n", 2 * delta); 2391 if (delta > ceiling) 2392 dev_warn(&udev->dev, "%dmA over %dmA budget!\n", 2393 2 * (delta - ceiling), 2 * ceiling); 2394 remaining -= delta; 2395 } 2396 if (remaining < 0) { 2397 dev_warn(hub->intfdev, 2398 "%dmA over power budget!\n", 2399 -2 * remaining); 2400 remaining = 0; 2401 } 2402 return remaining; 2403 } 2404 2405 /* Handle physical or logical connection change events. 2406 * This routine is called when: 2407 * a port connection-change occurs; 2408 * a port enable-change occurs (often caused by EMI); 2409 * usb_reset_device() encounters changed descriptors (as from 2410 * a firmware download) 2411 * caller already locked the hub 2412 */ 2413 static void hub_port_connect_change(struct usb_hub *hub, int port1, 2414 u16 portstatus, u16 portchange) 2415 { 2416 struct usb_device *hdev = hub->hdev; 2417 struct device *hub_dev = hub->intfdev; 2418 int status, i; 2419 2420 dev_dbg (hub_dev, 2421 "port %d, status %04x, change %04x, %s\n", 2422 port1, portstatus, portchange, portspeed (portstatus)); 2423 2424 if (hub->has_indicators) { 2425 set_port_led(hub, port1, HUB_LED_AUTO); 2426 hub->indicator[port1-1] = INDICATOR_AUTO; 2427 } 2428 2429 /* Disconnect any existing devices under this port */ 2430 if (hdev->children[port1-1]) 2431 usb_disconnect(&hdev->children[port1-1]); 2432 clear_bit(port1, hub->change_bits); 2433 2434 #ifdef CONFIG_USB_OTG 2435 /* during HNP, don't repeat the debounce */ 2436 if (hdev->bus->is_b_host) 2437 portchange &= ~USB_PORT_STAT_C_CONNECTION; 2438 #endif 2439 2440 if (portchange & USB_PORT_STAT_C_CONNECTION) { 2441 status = hub_port_debounce(hub, port1); 2442 if (status < 0) { 2443 dev_err (hub_dev, 2444 "connect-debounce failed, port %d disabled\n", 2445 port1); 2446 goto done; 2447 } 2448 portstatus = status; 2449 } 2450 2451 /* Return now if nothing is connected */ 2452 if (!(portstatus & USB_PORT_STAT_CONNECTION)) { 2453 2454 /* maybe switch power back on (e.g. root hub was reset) */ 2455 if ((hub->descriptor->wHubCharacteristics 2456 & HUB_CHAR_LPSM) < 2 2457 && !(portstatus & (1 << USB_PORT_FEAT_POWER))) 2458 set_port_feature(hdev, port1, USB_PORT_FEAT_POWER); 2459 2460 if (portstatus & USB_PORT_STAT_ENABLE) 2461 goto done; 2462 return; 2463 } 2464 2465 #ifdef CONFIG_USB_SUSPEND 2466 /* If something is connected, but the port is suspended, wake it up. */ 2467 if (portstatus & USB_PORT_STAT_SUSPEND) { 2468 status = hub_port_resume(hub, port1, NULL); 2469 if (status < 0) { 2470 dev_dbg(hub_dev, 2471 "can't clear suspend on port %d; %d\n", 2472 port1, status); 2473 goto done; 2474 } 2475 } 2476 #endif 2477 2478 for (i = 0; i < SET_CONFIG_TRIES; i++) { 2479 struct usb_device *udev; 2480 2481 /* reallocate for each attempt, since references 2482 * to the previous one can escape in various ways 2483 */ 2484 udev = usb_alloc_dev(hdev, hdev->bus, port1); 2485 if (!udev) { 2486 dev_err (hub_dev, 2487 "couldn't allocate port %d usb_device\n", 2488 port1); 2489 goto done; 2490 } 2491 2492 usb_set_device_state(udev, USB_STATE_POWERED); 2493 udev->speed = USB_SPEED_UNKNOWN; 2494 2495 /* set the address */ 2496 choose_address(udev); 2497 if (udev->devnum <= 0) { 2498 status = -ENOTCONN; /* Don't retry */ 2499 goto loop; 2500 } 2501 2502 /* reset and get descriptor */ 2503 status = hub_port_init(hub, udev, port1, i); 2504 if (status < 0) 2505 goto loop; 2506 2507 /* consecutive bus-powered hubs aren't reliable; they can 2508 * violate the voltage drop budget. if the new child has 2509 * a "powered" LED, users should notice we didn't enable it 2510 * (without reading syslog), even without per-port LEDs 2511 * on the parent. 2512 */ 2513 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB 2514 && hub->power_budget) { 2515 u16 devstat; 2516 2517 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, 2518 &devstat); 2519 if (status < 0) { 2520 dev_dbg(&udev->dev, "get status %d ?\n", status); 2521 goto loop_disable; 2522 } 2523 cpu_to_le16s(&devstat); 2524 if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) { 2525 dev_err(&udev->dev, 2526 "can't connect bus-powered hub " 2527 "to this port\n"); 2528 if (hub->has_indicators) { 2529 hub->indicator[port1-1] = 2530 INDICATOR_AMBER_BLINK; 2531 schedule_work (&hub->leds); 2532 } 2533 status = -ENOTCONN; /* Don't retry */ 2534 goto loop_disable; 2535 } 2536 } 2537 2538 /* check for devices running slower than they could */ 2539 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200 2540 && udev->speed == USB_SPEED_FULL 2541 && highspeed_hubs != 0) 2542 check_highspeed (hub, udev, port1); 2543 2544 /* Store the parent's children[] pointer. At this point 2545 * udev becomes globally accessible, although presumably 2546 * no one will look at it until hdev is unlocked. 2547 */ 2548 down (&udev->serialize); 2549 status = 0; 2550 2551 /* We mustn't add new devices if the parent hub has 2552 * been disconnected; we would race with the 2553 * recursively_mark_NOTATTACHED() routine. 2554 */ 2555 spin_lock_irq(&device_state_lock); 2556 if (hdev->state == USB_STATE_NOTATTACHED) 2557 status = -ENOTCONN; 2558 else 2559 hdev->children[port1-1] = udev; 2560 spin_unlock_irq(&device_state_lock); 2561 2562 /* Run it through the hoops (find a driver, etc) */ 2563 if (!status) { 2564 status = usb_new_device(udev); 2565 if (status) { 2566 spin_lock_irq(&device_state_lock); 2567 hdev->children[port1-1] = NULL; 2568 spin_unlock_irq(&device_state_lock); 2569 } 2570 } 2571 2572 up (&udev->serialize); 2573 if (status) 2574 goto loop_disable; 2575 2576 status = hub_power_remaining(hub); 2577 if (status) 2578 dev_dbg(hub_dev, 2579 "%dmA power budget left\n", 2580 2 * status); 2581 2582 return; 2583 2584 loop_disable: 2585 hub_port_disable(hub, port1, 1); 2586 loop: 2587 ep0_reinit(udev); 2588 release_address(udev); 2589 usb_put_dev(udev); 2590 if (status == -ENOTCONN) 2591 break; 2592 } 2593 2594 done: 2595 hub_port_disable(hub, port1, 1); 2596 } 2597 2598 static void hub_events(void) 2599 { 2600 struct list_head *tmp; 2601 struct usb_device *hdev; 2602 struct usb_interface *intf; 2603 struct usb_hub *hub; 2604 struct device *hub_dev; 2605 u16 hubstatus; 2606 u16 hubchange; 2607 u16 portstatus; 2608 u16 portchange; 2609 int i, ret; 2610 int connect_change; 2611 2612 /* 2613 * We restart the list every time to avoid a deadlock with 2614 * deleting hubs downstream from this one. This should be 2615 * safe since we delete the hub from the event list. 2616 * Not the most efficient, but avoids deadlocks. 2617 */ 2618 while (1) { 2619 2620 /* Grab the first entry at the beginning of the list */ 2621 spin_lock_irq(&hub_event_lock); 2622 if (list_empty(&hub_event_list)) { 2623 spin_unlock_irq(&hub_event_lock); 2624 break; 2625 } 2626 2627 tmp = hub_event_list.next; 2628 list_del_init(tmp); 2629 2630 hub = list_entry(tmp, struct usb_hub, event_list); 2631 hdev = hub->hdev; 2632 intf = to_usb_interface(hub->intfdev); 2633 hub_dev = &intf->dev; 2634 2635 dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n", 2636 hdev->state, hub->descriptor 2637 ? hub->descriptor->bNbrPorts 2638 : 0, 2639 /* NOTE: expects max 15 ports... */ 2640 (u16) hub->change_bits[0], 2641 (u16) hub->event_bits[0]); 2642 2643 usb_get_intf(intf); 2644 i = hub->resume_root_hub; 2645 spin_unlock_irq(&hub_event_lock); 2646 2647 /* Is this is a root hub wanting to be resumed? */ 2648 if (i) 2649 usb_resume_device(hdev); 2650 2651 /* Lock the device, then check to see if we were 2652 * disconnected while waiting for the lock to succeed. */ 2653 if (locktree(hdev) < 0) { 2654 usb_put_intf(intf); 2655 continue; 2656 } 2657 if (hub != usb_get_intfdata(intf)) 2658 goto loop; 2659 2660 /* If the hub has died, clean up after it */ 2661 if (hdev->state == USB_STATE_NOTATTACHED) { 2662 hub_pre_reset(hub); 2663 goto loop; 2664 } 2665 2666 /* If this is an inactive or suspended hub, do nothing */ 2667 if (hub->quiescing) 2668 goto loop; 2669 2670 if (hub->error) { 2671 dev_dbg (hub_dev, "resetting for error %d\n", 2672 hub->error); 2673 2674 ret = usb_reset_device(hdev); 2675 if (ret) { 2676 dev_dbg (hub_dev, 2677 "error resetting hub: %d\n", ret); 2678 goto loop; 2679 } 2680 2681 hub->nerrors = 0; 2682 hub->error = 0; 2683 } 2684 2685 /* deal with port status changes */ 2686 for (i = 1; i <= hub->descriptor->bNbrPorts; i++) { 2687 if (test_bit(i, hub->busy_bits)) 2688 continue; 2689 connect_change = test_bit(i, hub->change_bits); 2690 if (!test_and_clear_bit(i, hub->event_bits) && 2691 !connect_change && !hub->activating) 2692 continue; 2693 2694 ret = hub_port_status(hub, i, 2695 &portstatus, &portchange); 2696 if (ret < 0) 2697 continue; 2698 2699 if (hub->activating && !hdev->children[i-1] && 2700 (portstatus & 2701 USB_PORT_STAT_CONNECTION)) 2702 connect_change = 1; 2703 2704 if (portchange & USB_PORT_STAT_C_CONNECTION) { 2705 clear_port_feature(hdev, i, 2706 USB_PORT_FEAT_C_CONNECTION); 2707 connect_change = 1; 2708 } 2709 2710 if (portchange & USB_PORT_STAT_C_ENABLE) { 2711 if (!connect_change) 2712 dev_dbg (hub_dev, 2713 "port %d enable change, " 2714 "status %08x\n", 2715 i, portstatus); 2716 clear_port_feature(hdev, i, 2717 USB_PORT_FEAT_C_ENABLE); 2718 2719 /* 2720 * EM interference sometimes causes badly 2721 * shielded USB devices to be shutdown by 2722 * the hub, this hack enables them again. 2723 * Works at least with mouse driver. 2724 */ 2725 if (!(portstatus & USB_PORT_STAT_ENABLE) 2726 && !connect_change 2727 && hdev->children[i-1]) { 2728 dev_err (hub_dev, 2729 "port %i " 2730 "disabled by hub (EMI?), " 2731 "re-enabling...\n", 2732 i); 2733 connect_change = 1; 2734 } 2735 } 2736 2737 if (portchange & USB_PORT_STAT_C_SUSPEND) { 2738 clear_port_feature(hdev, i, 2739 USB_PORT_FEAT_C_SUSPEND); 2740 if (hdev->children[i-1]) { 2741 ret = remote_wakeup(hdev-> 2742 children[i-1]); 2743 if (ret < 0) 2744 connect_change = 1; 2745 } else { 2746 ret = -ENODEV; 2747 hub_port_disable(hub, i, 1); 2748 } 2749 dev_dbg (hub_dev, 2750 "resume on port %d, status %d\n", 2751 i, ret); 2752 } 2753 2754 if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 2755 dev_err (hub_dev, 2756 "over-current change on port %d\n", 2757 i); 2758 clear_port_feature(hdev, i, 2759 USB_PORT_FEAT_C_OVER_CURRENT); 2760 hub_power_on(hub); 2761 } 2762 2763 if (portchange & USB_PORT_STAT_C_RESET) { 2764 dev_dbg (hub_dev, 2765 "reset change on port %d\n", 2766 i); 2767 clear_port_feature(hdev, i, 2768 USB_PORT_FEAT_C_RESET); 2769 } 2770 2771 if (connect_change) 2772 hub_port_connect_change(hub, i, 2773 portstatus, portchange); 2774 } /* end for i */ 2775 2776 /* deal with hub status changes */ 2777 if (test_and_clear_bit(0, hub->event_bits) == 0) 2778 ; /* do nothing */ 2779 else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0) 2780 dev_err (hub_dev, "get_hub_status failed\n"); 2781 else { 2782 if (hubchange & HUB_CHANGE_LOCAL_POWER) { 2783 dev_dbg (hub_dev, "power change\n"); 2784 clear_hub_feature(hdev, C_HUB_LOCAL_POWER); 2785 } 2786 if (hubchange & HUB_CHANGE_OVERCURRENT) { 2787 dev_dbg (hub_dev, "overcurrent change\n"); 2788 msleep(500); /* Cool down */ 2789 clear_hub_feature(hdev, C_HUB_OVER_CURRENT); 2790 hub_power_on(hub); 2791 } 2792 } 2793 2794 hub->activating = 0; 2795 2796 /* If this is a root hub, tell the HCD it's okay to 2797 * re-enable port-change interrupts now. */ 2798 if (!hdev->parent) 2799 usb_enable_root_hub_irq(hdev->bus); 2800 2801 loop: 2802 usb_unlock_device(hdev); 2803 usb_put_intf(intf); 2804 2805 } /* end while (1) */ 2806 } 2807 2808 static int hub_thread(void *__unused) 2809 { 2810 /* 2811 * This thread doesn't need any user-level access, 2812 * so get rid of all our resources 2813 */ 2814 2815 daemonize("khubd"); 2816 allow_signal(SIGKILL); 2817 2818 /* Send me a signal to get me die (for debugging) */ 2819 do { 2820 hub_events(); 2821 wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list)); 2822 try_to_freeze(); 2823 } while (!signal_pending(current)); 2824 2825 pr_debug ("%s: khubd exiting\n", usbcore_name); 2826 complete_and_exit(&khubd_exited, 0); 2827 } 2828 2829 static struct usb_device_id hub_id_table [] = { 2830 { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS, 2831 .bDeviceClass = USB_CLASS_HUB}, 2832 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 2833 .bInterfaceClass = USB_CLASS_HUB}, 2834 { } /* Terminating entry */ 2835 }; 2836 2837 MODULE_DEVICE_TABLE (usb, hub_id_table); 2838 2839 static struct usb_driver hub_driver = { 2840 .owner = THIS_MODULE, 2841 .name = "hub", 2842 .probe = hub_probe, 2843 .disconnect = hub_disconnect, 2844 .suspend = hub_suspend, 2845 .resume = hub_resume, 2846 .ioctl = hub_ioctl, 2847 .id_table = hub_id_table, 2848 }; 2849 2850 int usb_hub_init(void) 2851 { 2852 pid_t pid; 2853 2854 if (usb_register(&hub_driver) < 0) { 2855 printk(KERN_ERR "%s: can't register hub driver\n", 2856 usbcore_name); 2857 return -1; 2858 } 2859 2860 pid = kernel_thread(hub_thread, NULL, CLONE_KERNEL); 2861 if (pid >= 0) { 2862 khubd_pid = pid; 2863 2864 return 0; 2865 } 2866 2867 /* Fall through if kernel_thread failed */ 2868 usb_deregister(&hub_driver); 2869 printk(KERN_ERR "%s: can't start khubd\n", usbcore_name); 2870 2871 return -1; 2872 } 2873 2874 void usb_hub_cleanup(void) 2875 { 2876 int ret; 2877 2878 /* Kill the thread */ 2879 ret = kill_proc(khubd_pid, SIGKILL, 1); 2880 2881 wait_for_completion(&khubd_exited); 2882 2883 /* 2884 * Hub resources are freed for us by usb_deregister. It calls 2885 * usb_driver_purge on every device which in turn calls that 2886 * devices disconnect function if it is using this driver. 2887 * The hub_disconnect function takes care of releasing the 2888 * individual hub resources. -greg 2889 */ 2890 usb_deregister(&hub_driver); 2891 } /* usb_hub_cleanup() */ 2892 2893 2894 static int config_descriptors_changed(struct usb_device *udev) 2895 { 2896 unsigned index; 2897 unsigned len = 0; 2898 struct usb_config_descriptor *buf; 2899 2900 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) { 2901 if (len < le16_to_cpu(udev->config[index].desc.wTotalLength)) 2902 len = le16_to_cpu(udev->config[index].desc.wTotalLength); 2903 } 2904 buf = kmalloc (len, SLAB_KERNEL); 2905 if (buf == NULL) { 2906 dev_err(&udev->dev, "no mem to re-read configs after reset\n"); 2907 /* assume the worst */ 2908 return 1; 2909 } 2910 for (index = 0; index < udev->descriptor.bNumConfigurations; index++) { 2911 int length; 2912 int old_length = le16_to_cpu(udev->config[index].desc.wTotalLength); 2913 2914 length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf, 2915 old_length); 2916 if (length < old_length) { 2917 dev_dbg(&udev->dev, "config index %d, error %d\n", 2918 index, length); 2919 break; 2920 } 2921 if (memcmp (buf, udev->rawdescriptors[index], old_length) 2922 != 0) { 2923 dev_dbg(&udev->dev, "config index %d changed (#%d)\n", 2924 index, buf->bConfigurationValue); 2925 break; 2926 } 2927 } 2928 kfree(buf); 2929 return index != udev->descriptor.bNumConfigurations; 2930 } 2931 2932 /** 2933 * usb_reset_device - perform a USB port reset to reinitialize a device 2934 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state) 2935 * 2936 * WARNING - don't reset any device unless drivers for all of its 2937 * interfaces are expecting that reset! Maybe some driver->reset() 2938 * method should eventually help ensure sufficient cooperation. 2939 * 2940 * Do a port reset, reassign the device's address, and establish its 2941 * former operating configuration. If the reset fails, or the device's 2942 * descriptors change from their values before the reset, or the original 2943 * configuration and altsettings cannot be restored, a flag will be set 2944 * telling khubd to pretend the device has been disconnected and then 2945 * re-connected. All drivers will be unbound, and the device will be 2946 * re-enumerated and probed all over again. 2947 * 2948 * Returns 0 if the reset succeeded, -ENODEV if the device has been 2949 * flagged for logical disconnection, or some other negative error code 2950 * if the reset wasn't even attempted. 2951 * 2952 * The caller must own the device lock. For example, it's safe to use 2953 * this from a driver probe() routine after downloading new firmware. 2954 * For calls that might not occur during probe(), drivers should lock 2955 * the device using usb_lock_device_for_reset(). 2956 */ 2957 int usb_reset_device(struct usb_device *udev) 2958 { 2959 struct usb_device *parent_hdev = udev->parent; 2960 struct usb_hub *parent_hub; 2961 struct usb_device_descriptor descriptor = udev->descriptor; 2962 struct usb_hub *hub = NULL; 2963 int i, ret = 0, port1 = -1; 2964 2965 if (udev->state == USB_STATE_NOTATTACHED || 2966 udev->state == USB_STATE_SUSPENDED) { 2967 dev_dbg(&udev->dev, "device reset not allowed in state %d\n", 2968 udev->state); 2969 return -EINVAL; 2970 } 2971 2972 if (!parent_hdev) { 2973 /* this requires hcd-specific logic; see OHCI hc_restart() */ 2974 dev_dbg(&udev->dev, "%s for root hub!\n", __FUNCTION__); 2975 return -EISDIR; 2976 } 2977 2978 for (i = 0; i < parent_hdev->maxchild; i++) 2979 if (parent_hdev->children[i] == udev) { 2980 port1 = i + 1; 2981 break; 2982 } 2983 2984 if (port1 < 0) { 2985 /* If this ever happens, it's very bad */ 2986 dev_err(&udev->dev, "Can't locate device's port!\n"); 2987 return -ENOENT; 2988 } 2989 parent_hub = hdev_to_hub(parent_hdev); 2990 2991 /* If we're resetting an active hub, take some special actions */ 2992 if (udev->actconfig && 2993 udev->actconfig->interface[0]->dev.driver == 2994 &hub_driver.driver && 2995 (hub = hdev_to_hub(udev)) != NULL) { 2996 hub_pre_reset(hub); 2997 } 2998 2999 set_bit(port1, parent_hub->busy_bits); 3000 for (i = 0; i < SET_CONFIG_TRIES; ++i) { 3001 3002 /* ep0 maxpacket size may change; let the HCD know about it. 3003 * Other endpoints will be handled by re-enumeration. */ 3004 ep0_reinit(udev); 3005 ret = hub_port_init(parent_hub, udev, port1, i); 3006 if (ret >= 0) 3007 break; 3008 } 3009 clear_bit(port1, parent_hub->busy_bits); 3010 if (ret < 0) 3011 goto re_enumerate; 3012 3013 /* Device might have changed firmware (DFU or similar) */ 3014 if (memcmp(&udev->descriptor, &descriptor, sizeof descriptor) 3015 || config_descriptors_changed (udev)) { 3016 dev_info(&udev->dev, "device firmware changed\n"); 3017 udev->descriptor = descriptor; /* for disconnect() calls */ 3018 goto re_enumerate; 3019 } 3020 3021 if (!udev->actconfig) 3022 goto done; 3023 3024 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 3025 USB_REQ_SET_CONFIGURATION, 0, 3026 udev->actconfig->desc.bConfigurationValue, 0, 3027 NULL, 0, USB_CTRL_SET_TIMEOUT); 3028 if (ret < 0) { 3029 dev_err(&udev->dev, 3030 "can't restore configuration #%d (error=%d)\n", 3031 udev->actconfig->desc.bConfigurationValue, ret); 3032 goto re_enumerate; 3033 } 3034 usb_set_device_state(udev, USB_STATE_CONFIGURED); 3035 3036 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 3037 struct usb_interface *intf = udev->actconfig->interface[i]; 3038 struct usb_interface_descriptor *desc; 3039 3040 /* set_interface resets host side toggle even 3041 * for altsetting zero. the interface may have no driver. 3042 */ 3043 desc = &intf->cur_altsetting->desc; 3044 ret = usb_set_interface(udev, desc->bInterfaceNumber, 3045 desc->bAlternateSetting); 3046 if (ret < 0) { 3047 dev_err(&udev->dev, "failed to restore interface %d " 3048 "altsetting %d (error=%d)\n", 3049 desc->bInterfaceNumber, 3050 desc->bAlternateSetting, 3051 ret); 3052 goto re_enumerate; 3053 } 3054 } 3055 3056 done: 3057 if (hub) 3058 hub_post_reset(hub); 3059 return 0; 3060 3061 re_enumerate: 3062 hub_port_logical_disconnect(parent_hub, port1); 3063 return -ENODEV; 3064 } 3065