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