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