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