/drivers/usb/core/hub.c
C | 4051 lines | 2699 code | 486 blank | 866 comment | 636 complexity | 391473d5e0cab8c688aa1a8fac051e4a MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
Large files files are truncated, but you can click here to view the full file
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/usb/hcd.h> 23#include <linux/usb/quirks.h> 24#include <linux/kthread.h> 25#include <linux/mutex.h> 26#include <linux/freezer.h> 27 28#include <asm/uaccess.h> 29#include <asm/byteorder.h> 30 31#include "usb.h" 32 33/* if we are in debug mode, always announce new devices */ 34#ifdef DEBUG 35#ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES 36#define CONFIG_USB_ANNOUNCE_NEW_DEVICES 37#endif 38#endif 39 40struct usb_hub { 41 struct device *intfdev; /* the "interface" device */ 42 struct usb_device *hdev; 43 struct kref kref; 44 struct urb *urb; /* for interrupt polling pipe */ 45 46 /* buffer for urb ... with extra space in case of babble */ 47 char (*buffer)[8]; 48 union { 49 struct usb_hub_status hub; 50 struct usb_port_status port; 51 } *status; /* buffer for status reports */ 52 struct mutex status_mutex; /* for the status buffer */ 53 54 int error; /* last reported error */ 55 int nerrors; /* track consecutive errors */ 56 57 struct list_head event_list; /* hubs w/data or errs ready */ 58 unsigned long event_bits[1]; /* status change bitmask */ 59 unsigned long change_bits[1]; /* ports with logical connect 60 status change */ 61 unsigned long busy_bits[1]; /* ports being reset or 62 resumed */ 63 unsigned long removed_bits[1]; /* ports with a "removed" 64 device present */ 65#if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */ 66#error event_bits[] is too short! 67#endif 68 69 struct usb_hub_descriptor *descriptor; /* class descriptor */ 70 struct usb_tt tt; /* Transaction Translator */ 71 72 unsigned mA_per_port; /* current for each child */ 73 74 unsigned limited_power:1; 75 unsigned quiescing:1; 76 unsigned disconnected:1; 77 78 unsigned has_indicators:1; 79 u8 indicator[USB_MAXCHILDREN]; 80 struct delayed_work leds; 81 struct delayed_work init_work; 82 void **port_owners; 83}; 84 85static inline int hub_is_superspeed(struct usb_device *hdev) 86{ 87 return (hdev->descriptor.bDeviceProtocol == 3); 88} 89 90/* Protect struct usb_device->state and ->children members 91 * Note: Both are also protected by ->dev.sem, except that ->state can 92 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */ 93static DEFINE_SPINLOCK(device_state_lock); 94 95/* khubd's worklist and its lock */ 96static DEFINE_SPINLOCK(hub_event_lock); 97static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */ 98 99/* Wakes up khubd */ 100static DECLARE_WAIT_QUEUE_HEAD(khubd_wait); 101 102static struct task_struct *khubd_task; 103 104/* cycle leds on hubs that aren't blinking for attention */ 105static int blinkenlights = 0; 106module_param (blinkenlights, bool, S_IRUGO); 107MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs"); 108 109/* 110 * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about 111 * 10 seconds to send reply for the initial 64-byte descriptor request. 112 */ 113/* define initial 64-byte descriptor request timeout in milliseconds */ 114static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT; 115module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR); 116MODULE_PARM_DESC(initial_descriptor_timeout, 117 "initial 64-byte descriptor request timeout in milliseconds " 118 "(default 5000 - 5.0 seconds)"); 119 120/* 121 * As of 2.6.10 we introduce a new USB device initialization scheme which 122 * closely resembles the way Windows works. Hopefully it will be compatible 123 * with a wider range of devices than the old scheme. However some previously 124 * working devices may start giving rise to "device not accepting address" 125 * errors; if that happens the user can try the old scheme by adjusting the 126 * following module parameters. 127 * 128 * For maximum flexibility there are two boolean parameters to control the 129 * hub driver's behavior. On the first initialization attempt, if the 130 * "old_scheme_first" parameter is set then the old scheme will be used, 131 * otherwise the new scheme is used. If that fails and "use_both_schemes" 132 * is set, then the driver will make another attempt, using the other scheme. 133 */ 134static int old_scheme_first = 0; 135module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR); 136MODULE_PARM_DESC(old_scheme_first, 137 "start with the old device initialization scheme"); 138 139static int use_both_schemes = 1; 140module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR); 141MODULE_PARM_DESC(use_both_schemes, 142 "try the other device initialization scheme if the " 143 "first one fails"); 144 145/* Mutual exclusion for EHCI CF initialization. This interferes with 146 * port reset on some companion controllers. 147 */ 148DECLARE_RWSEM(ehci_cf_port_reset_rwsem); 149EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem); 150 151#define HUB_DEBOUNCE_TIMEOUT 1500 152#define HUB_DEBOUNCE_STEP 25 153#define HUB_DEBOUNCE_STABLE 100 154 155 156static int usb_reset_and_verify_device(struct usb_device *udev); 157 158static inline char *portspeed(struct usb_hub *hub, int portstatus) 159{ 160 if (hub_is_superspeed(hub->hdev)) 161 return "5.0 Gb/s"; 162 if (portstatus & USB_PORT_STAT_HIGH_SPEED) 163 return "480 Mb/s"; 164 else if (portstatus & USB_PORT_STAT_LOW_SPEED) 165 return "1.5 Mb/s"; 166 else 167 return "12 Mb/s"; 168} 169 170/* Note that hdev or one of its children must be locked! */ 171static struct usb_hub *hdev_to_hub(struct usb_device *hdev) 172{ 173 if (!hdev || !hdev->actconfig) 174 return NULL; 175 return usb_get_intfdata(hdev->actconfig->interface[0]); 176} 177 178/* USB 2.0 spec Section 11.24.4.5 */ 179static int get_hub_descriptor(struct usb_device *hdev, void *data) 180{ 181 int i, ret, size; 182 unsigned dtype; 183 184 if (hub_is_superspeed(hdev)) { 185 dtype = USB_DT_SS_HUB; 186 size = USB_DT_SS_HUB_SIZE; 187 } else { 188 dtype = USB_DT_HUB; 189 size = sizeof(struct usb_hub_descriptor); 190 } 191 192 for (i = 0; i < 3; i++) { 193 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 194 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 195 dtype << 8, 0, data, size, 196 USB_CTRL_GET_TIMEOUT); 197 if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2)) 198 return ret; 199 } 200 return -EINVAL; 201} 202 203/* 204 * USB 2.0 spec Section 11.24.2.1 205 */ 206static int clear_hub_feature(struct usb_device *hdev, int feature) 207{ 208 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 209 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000); 210} 211 212/* 213 * USB 2.0 spec Section 11.24.2.2 214 */ 215static int clear_port_feature(struct usb_device *hdev, int port1, int feature) 216{ 217 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 218 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1, 219 NULL, 0, 1000); 220} 221 222/* 223 * USB 2.0 spec Section 11.24.2.13 224 */ 225static int set_port_feature(struct usb_device *hdev, int port1, int feature) 226{ 227 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 228 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1, 229 NULL, 0, 1000); 230} 231 232/* 233 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7 234 * for info about using port indicators 235 */ 236static void set_port_led( 237 struct usb_hub *hub, 238 int port1, 239 int selector 240) 241{ 242 int status = set_port_feature(hub->hdev, (selector << 8) | port1, 243 USB_PORT_FEAT_INDICATOR); 244 if (status < 0) 245 dev_dbg (hub->intfdev, 246 "port %d indicator %s status %d\n", 247 port1, 248 ({ char *s; switch (selector) { 249 case HUB_LED_AMBER: s = "amber"; break; 250 case HUB_LED_GREEN: s = "green"; break; 251 case HUB_LED_OFF: s = "off"; break; 252 case HUB_LED_AUTO: s = "auto"; break; 253 default: s = "??"; break; 254 }; s; }), 255 status); 256} 257 258#define LED_CYCLE_PERIOD ((2*HZ)/3) 259 260static void led_work (struct work_struct *work) 261{ 262 struct usb_hub *hub = 263 container_of(work, struct usb_hub, leds.work); 264 struct usb_device *hdev = hub->hdev; 265 unsigned i; 266 unsigned changed = 0; 267 int cursor = -1; 268 269 if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing) 270 return; 271 272 for (i = 0; i < hub->descriptor->bNbrPorts; i++) { 273 unsigned selector, mode; 274 275 /* 30%-50% duty cycle */ 276 277 switch (hub->indicator[i]) { 278 /* cycle marker */ 279 case INDICATOR_CYCLE: 280 cursor = i; 281 selector = HUB_LED_AUTO; 282 mode = INDICATOR_AUTO; 283 break; 284 /* blinking green = sw attention */ 285 case INDICATOR_GREEN_BLINK: 286 selector = HUB_LED_GREEN; 287 mode = INDICATOR_GREEN_BLINK_OFF; 288 break; 289 case INDICATOR_GREEN_BLINK_OFF: 290 selector = HUB_LED_OFF; 291 mode = INDICATOR_GREEN_BLINK; 292 break; 293 /* blinking amber = hw attention */ 294 case INDICATOR_AMBER_BLINK: 295 selector = HUB_LED_AMBER; 296 mode = INDICATOR_AMBER_BLINK_OFF; 297 break; 298 case INDICATOR_AMBER_BLINK_OFF: 299 selector = HUB_LED_OFF; 300 mode = INDICATOR_AMBER_BLINK; 301 break; 302 /* blink green/amber = reserved */ 303 case INDICATOR_ALT_BLINK: 304 selector = HUB_LED_GREEN; 305 mode = INDICATOR_ALT_BLINK_OFF; 306 break; 307 case INDICATOR_ALT_BLINK_OFF: 308 selector = HUB_LED_AMBER; 309 mode = INDICATOR_ALT_BLINK; 310 break; 311 default: 312 continue; 313 } 314 if (selector != HUB_LED_AUTO) 315 changed = 1; 316 set_port_led(hub, i + 1, selector); 317 hub->indicator[i] = mode; 318 } 319 if (!changed && blinkenlights) { 320 cursor++; 321 cursor %= hub->descriptor->bNbrPorts; 322 set_port_led(hub, cursor + 1, HUB_LED_GREEN); 323 hub->indicator[cursor] = INDICATOR_CYCLE; 324 changed++; 325 } 326 if (changed) 327 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD); 328} 329 330/* use a short timeout for hub/port status fetches */ 331#define USB_STS_TIMEOUT 1000 332#define USB_STS_RETRIES 5 333 334/* 335 * USB 2.0 spec Section 11.24.2.6 336 */ 337static int get_hub_status(struct usb_device *hdev, 338 struct usb_hub_status *data) 339{ 340 int i, status = -ETIMEDOUT; 341 342 for (i = 0; i < USB_STS_RETRIES && 343 (status == -ETIMEDOUT || status == -EPIPE); i++) { 344 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 345 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 346 data, sizeof(*data), USB_STS_TIMEOUT); 347 } 348 return status; 349} 350 351/* 352 * USB 2.0 spec Section 11.24.2.7 353 */ 354static int get_port_status(struct usb_device *hdev, int port1, 355 struct usb_port_status *data) 356{ 357 int i, status = -ETIMEDOUT; 358 359 for (i = 0; i < USB_STS_RETRIES && 360 (status == -ETIMEDOUT || status == -EPIPE); i++) { 361 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 362 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1, 363 data, sizeof(*data), USB_STS_TIMEOUT); 364 } 365 return status; 366} 367 368static int hub_port_status(struct usb_hub *hub, int port1, 369 u16 *status, u16 *change) 370{ 371 int ret; 372 373 mutex_lock(&hub->status_mutex); 374 ret = get_port_status(hub->hdev, port1, &hub->status->port); 375 if (ret < 4) { 376 dev_err(hub->intfdev, 377 "%s failed (err = %d)\n", __func__, ret); 378 if (ret >= 0) 379 ret = -EIO; 380 } else { 381 *status = le16_to_cpu(hub->status->port.wPortStatus); 382 *change = le16_to_cpu(hub->status->port.wPortChange); 383 384 ret = 0; 385 } 386 mutex_unlock(&hub->status_mutex); 387 return ret; 388} 389 390static void kick_khubd(struct usb_hub *hub) 391{ 392 unsigned long flags; 393 394 spin_lock_irqsave(&hub_event_lock, flags); 395 if (!hub->disconnected && list_empty(&hub->event_list)) { 396 list_add_tail(&hub->event_list, &hub_event_list); 397 398 /* Suppress autosuspend until khubd runs */ 399 usb_autopm_get_interface_no_resume( 400 to_usb_interface(hub->intfdev)); 401 wake_up(&khubd_wait); 402 } 403 spin_unlock_irqrestore(&hub_event_lock, flags); 404} 405 406void usb_kick_khubd(struct usb_device *hdev) 407{ 408 struct usb_hub *hub = hdev_to_hub(hdev); 409 410 if (hub) 411 kick_khubd(hub); 412} 413 414 415/* completion function, fires on port status changes and various faults */ 416static void hub_irq(struct urb *urb) 417{ 418 struct usb_hub *hub = urb->context; 419 int status = urb->status; 420 unsigned i; 421 unsigned long bits; 422 423 switch (status) { 424 case -ENOENT: /* synchronous unlink */ 425 case -ECONNRESET: /* async unlink */ 426 case -ESHUTDOWN: /* hardware going away */ 427 return; 428 429 default: /* presumably an error */ 430 /* Cause a hub reset after 10 consecutive errors */ 431 dev_dbg (hub->intfdev, "transfer --> %d\n", status); 432 if ((++hub->nerrors < 10) || hub->error) 433 goto resubmit; 434 hub->error = status; 435 /* FALL THROUGH */ 436 437 /* let khubd handle things */ 438 case 0: /* we got data: port status changed */ 439 bits = 0; 440 for (i = 0; i < urb->actual_length; ++i) 441 bits |= ((unsigned long) ((*hub->buffer)[i])) 442 << (i*8); 443 hub->event_bits[0] = bits; 444 break; 445 } 446 447 hub->nerrors = 0; 448 449 /* Something happened, let khubd figure it out */ 450 kick_khubd(hub); 451 452resubmit: 453 if (hub->quiescing) 454 return; 455 456 if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0 457 && status != -ENODEV && status != -EPERM) 458 dev_err (hub->intfdev, "resubmit --> %d\n", status); 459} 460 461/* USB 2.0 spec Section 11.24.2.3 */ 462static inline int 463hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt) 464{ 465 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 466 HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo, 467 tt, NULL, 0, 1000); 468} 469 470/* 471 * enumeration blocks khubd for a long time. we use keventd instead, since 472 * long blocking there is the exception, not the rule. accordingly, HCDs 473 * talking to TTs must queue control transfers (not just bulk and iso), so 474 * both can talk to the same hub concurrently. 475 */ 476static void hub_tt_work(struct work_struct *work) 477{ 478 struct usb_hub *hub = 479 container_of(work, struct usb_hub, tt.clear_work); 480 unsigned long flags; 481 int limit = 100; 482 483 spin_lock_irqsave (&hub->tt.lock, flags); 484 while (--limit && !list_empty (&hub->tt.clear_list)) { 485 struct list_head *next; 486 struct usb_tt_clear *clear; 487 struct usb_device *hdev = hub->hdev; 488 const struct hc_driver *drv; 489 int status; 490 491 next = hub->tt.clear_list.next; 492 clear = list_entry (next, struct usb_tt_clear, clear_list); 493 list_del (&clear->clear_list); 494 495 /* drop lock so HCD can concurrently report other TT errors */ 496 spin_unlock_irqrestore (&hub->tt.lock, flags); 497 status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt); 498 if (status) 499 dev_err (&hdev->dev, 500 "clear tt %d (%04x) error %d\n", 501 clear->tt, clear->devinfo, status); 502 503 /* Tell the HCD, even if the operation failed */ 504 drv = clear->hcd->driver; 505 if (drv->clear_tt_buffer_complete) 506 (drv->clear_tt_buffer_complete)(clear->hcd, clear->ep); 507 508 kfree(clear); 509 spin_lock_irqsave(&hub->tt.lock, flags); 510 } 511 spin_unlock_irqrestore (&hub->tt.lock, flags); 512} 513 514/** 515 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub 516 * @urb: an URB associated with the failed or incomplete split transaction 517 * 518 * High speed HCDs use this to tell the hub driver that some split control or 519 * bulk transaction failed in a way that requires clearing internal state of 520 * a transaction translator. This is normally detected (and reported) from 521 * interrupt context. 522 * 523 * It may not be possible for that hub to handle additional full (or low) 524 * speed transactions until that state is fully cleared out. 525 */ 526int usb_hub_clear_tt_buffer(struct urb *urb) 527{ 528 struct usb_device *udev = urb->dev; 529 int pipe = urb->pipe; 530 struct usb_tt *tt = udev->tt; 531 unsigned long flags; 532 struct usb_tt_clear *clear; 533 534 /* we've got to cope with an arbitrary number of pending TT clears, 535 * since each TT has "at least two" buffers that can need it (and 536 * there can be many TTs per hub). even if they're uncommon. 537 */ 538 if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) { 539 dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n"); 540 /* FIXME recover somehow ... RESET_TT? */ 541 return -ENOMEM; 542 } 543 544 /* info that CLEAR_TT_BUFFER needs */ 545 clear->tt = tt->multi ? udev->ttport : 1; 546 clear->devinfo = usb_pipeendpoint (pipe); 547 clear->devinfo |= udev->devnum << 4; 548 clear->devinfo |= usb_pipecontrol (pipe) 549 ? (USB_ENDPOINT_XFER_CONTROL << 11) 550 : (USB_ENDPOINT_XFER_BULK << 11); 551 if (usb_pipein (pipe)) 552 clear->devinfo |= 1 << 15; 553 554 /* info for completion callback */ 555 clear->hcd = bus_to_hcd(udev->bus); 556 clear->ep = urb->ep; 557 558 /* tell keventd to clear state for this TT */ 559 spin_lock_irqsave (&tt->lock, flags); 560 list_add_tail (&clear->clear_list, &tt->clear_list); 561 schedule_work(&tt->clear_work); 562 spin_unlock_irqrestore (&tt->lock, flags); 563 return 0; 564} 565EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer); 566 567/* If do_delay is false, return the number of milliseconds the caller 568 * needs to delay. 569 */ 570static unsigned hub_power_on(struct usb_hub *hub, bool do_delay) 571{ 572 int port1; 573 unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2; 574 unsigned delay; 575 u16 wHubCharacteristics = 576 le16_to_cpu(hub->descriptor->wHubCharacteristics); 577 578 /* Enable power on each port. Some hubs have reserved values 579 * of LPSM (> 2) in their descriptors, even though they are 580 * USB 2.0 hubs. Some hubs do not implement port-power switching 581 * but only emulate it. In all cases, the ports won't work 582 * unless we send these messages to the hub. 583 */ 584 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) 585 dev_dbg(hub->intfdev, "enabling power on all ports\n"); 586 else 587 dev_dbg(hub->intfdev, "trying to enable port power on " 588 "non-switchable hub\n"); 589 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++) 590 set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER); 591 592 /* Wait at least 100 msec for power to become stable */ 593 delay = max(pgood_delay, (unsigned) 100); 594 if (do_delay) 595 msleep(delay); 596 return delay; 597} 598 599static int hub_hub_status(struct usb_hub *hub, 600 u16 *status, u16 *change) 601{ 602 int ret; 603 604 mutex_lock(&hub->status_mutex); 605 ret = get_hub_status(hub->hdev, &hub->status->hub); 606 if (ret < 0) 607 dev_err (hub->intfdev, 608 "%s failed (err = %d)\n", __func__, ret); 609 else { 610 *status = le16_to_cpu(hub->status->hub.wHubStatus); 611 *change = le16_to_cpu(hub->status->hub.wHubChange); 612 ret = 0; 613 } 614 mutex_unlock(&hub->status_mutex); 615 return ret; 616} 617 618static int hub_port_disable(struct usb_hub *hub, int port1, int set_state) 619{ 620 struct usb_device *hdev = hub->hdev; 621 int ret = 0; 622 623 if (hdev->children[port1-1] && set_state) 624 usb_set_device_state(hdev->children[port1-1], 625 USB_STATE_NOTATTACHED); 626 if (!hub->error && !hub_is_superspeed(hub->hdev)) 627 ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE); 628 if (ret) 629 dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n", 630 port1, ret); 631 return ret; 632} 633 634/* 635 * Disable a port and mark a logical connect-change event, so that some 636 * time later khubd will disconnect() any existing usb_device on the port 637 * and will re-enumerate if there actually is a device attached. 638 */ 639static void hub_port_logical_disconnect(struct usb_hub *hub, int port1) 640{ 641 dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1); 642 hub_port_disable(hub, port1, 1); 643 644 /* FIXME let caller ask to power down the port: 645 * - some devices won't enumerate without a VBUS power cycle 646 * - SRP saves power that way 647 * - ... new call, TBD ... 648 * That's easy if this hub can switch power per-port, and 649 * khubd reactivates the port later (timer, SRP, etc). 650 * Powerdown must be optional, because of reset/DFU. 651 */ 652 653 set_bit(port1, hub->change_bits); 654 kick_khubd(hub); 655} 656 657/** 658 * usb_remove_device - disable a device's port on its parent hub 659 * @udev: device to be disabled and removed 660 * Context: @udev locked, must be able to sleep. 661 * 662 * After @udev's port has been disabled, khubd is notified and it will 663 * see that the device has been disconnected. When the device is 664 * physically unplugged and something is plugged in, the events will 665 * be received and processed normally. 666 */ 667int usb_remove_device(struct usb_device *udev) 668{ 669 struct usb_hub *hub; 670 struct usb_interface *intf; 671 672 if (!udev->parent) /* Can't remove a root hub */ 673 return -EINVAL; 674 hub = hdev_to_hub(udev->parent); 675 intf = to_usb_interface(hub->intfdev); 676 677 usb_autopm_get_interface(intf); 678 set_bit(udev->portnum, hub->removed_bits); 679 hub_port_logical_disconnect(hub, udev->portnum); 680 usb_autopm_put_interface(intf); 681 return 0; 682} 683 684enum hub_activation_type { 685 HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */ 686 HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME, 687}; 688 689static void hub_init_func2(struct work_struct *ws); 690static void hub_init_func3(struct work_struct *ws); 691 692static void hub_activate(struct usb_hub *hub, enum hub_activation_type type) 693{ 694 struct usb_device *hdev = hub->hdev; 695 struct usb_hcd *hcd; 696 int ret; 697 int port1; 698 int status; 699 bool need_debounce_delay = false; 700 unsigned delay; 701 702 /* Continue a partial initialization */ 703 if (type == HUB_INIT2) 704 goto init2; 705 if (type == HUB_INIT3) 706 goto init3; 707 708 /* After a resume, port power should still be on. 709 * For any other type of activation, turn it on. 710 */ 711 if (type != HUB_RESUME) { 712 713 /* Speed up system boot by using a delayed_work for the 714 * hub's initial power-up delays. This is pretty awkward 715 * and the implementation looks like a home-brewed sort of 716 * setjmp/longjmp, but it saves at least 100 ms for each 717 * root hub (assuming usbcore is compiled into the kernel 718 * rather than as a module). It adds up. 719 * 720 * This can't be done for HUB_RESUME or HUB_RESET_RESUME 721 * because for those activation types the ports have to be 722 * operational when we return. In theory this could be done 723 * for HUB_POST_RESET, but it's easier not to. 724 */ 725 if (type == HUB_INIT) { 726 delay = hub_power_on(hub, false); 727 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2); 728 schedule_delayed_work(&hub->init_work, 729 msecs_to_jiffies(delay)); 730 731 /* Suppress autosuspend until init is done */ 732 usb_autopm_get_interface_no_resume( 733 to_usb_interface(hub->intfdev)); 734 return; /* Continues at init2: below */ 735 } else if (type == HUB_RESET_RESUME) { 736 /* The internal host controller state for the hub device 737 * may be gone after a host power loss on system resume. 738 * Update the device's info so the HW knows it's a hub. 739 */ 740 hcd = bus_to_hcd(hdev->bus); 741 if (hcd->driver->update_hub_device) { 742 ret = hcd->driver->update_hub_device(hcd, hdev, 743 &hub->tt, GFP_NOIO); 744 if (ret < 0) { 745 dev_err(hub->intfdev, "Host not " 746 "accepting hub info " 747 "update.\n"); 748 dev_err(hub->intfdev, "LS/FS devices " 749 "and hubs may not work " 750 "under this hub\n."); 751 } 752 } 753 hub_power_on(hub, true); 754 } else { 755 hub_power_on(hub, true); 756 } 757 } 758 init2: 759 760 /* Check each port and set hub->change_bits to let khubd know 761 * which ports need attention. 762 */ 763 for (port1 = 1; port1 <= hdev->maxchild; ++port1) { 764 struct usb_device *udev = hdev->children[port1-1]; 765 u16 portstatus, portchange; 766 767 portstatus = portchange = 0; 768 status = hub_port_status(hub, port1, &portstatus, &portchange); 769 if (udev || (portstatus & USB_PORT_STAT_CONNECTION)) 770 dev_dbg(hub->intfdev, 771 "port %d: status %04x change %04x\n", 772 port1, portstatus, portchange); 773 774 /* After anything other than HUB_RESUME (i.e., initialization 775 * or any sort of reset), every port should be disabled. 776 * Unconnected ports should likewise be disabled (paranoia), 777 * and so should ports for which we have no usb_device. 778 */ 779 if ((portstatus & USB_PORT_STAT_ENABLE) && ( 780 type != HUB_RESUME || 781 !(portstatus & USB_PORT_STAT_CONNECTION) || 782 !udev || 783 udev->state == USB_STATE_NOTATTACHED)) { 784 /* 785 * USB3 protocol ports will automatically transition 786 * to Enabled state when detect an USB3.0 device attach. 787 * Do not disable USB3 protocol ports. 788 */ 789 if (!hub_is_superspeed(hdev)) { 790 clear_port_feature(hdev, port1, 791 USB_PORT_FEAT_ENABLE); 792 portstatus &= ~USB_PORT_STAT_ENABLE; 793 } else { 794 /* Pretend that power was lost for USB3 devs */ 795 portstatus &= ~USB_PORT_STAT_ENABLE; 796 } 797 } 798 799 /* Clear status-change flags; we'll debounce later */ 800 if (portchange & USB_PORT_STAT_C_CONNECTION) { 801 need_debounce_delay = true; 802 clear_port_feature(hub->hdev, port1, 803 USB_PORT_FEAT_C_CONNECTION); 804 } 805 if (portchange & USB_PORT_STAT_C_ENABLE) { 806 need_debounce_delay = true; 807 clear_port_feature(hub->hdev, port1, 808 USB_PORT_FEAT_C_ENABLE); 809 } 810 if (portchange & USB_PORT_STAT_C_LINK_STATE) { 811 need_debounce_delay = true; 812 clear_port_feature(hub->hdev, port1, 813 USB_PORT_FEAT_C_PORT_LINK_STATE); 814 } 815 816 if ((portchange & USB_PORT_STAT_C_BH_RESET) && 817 hub_is_superspeed(hub->hdev)) { 818 need_debounce_delay = true; 819 clear_port_feature(hub->hdev, port1, 820 USB_PORT_FEAT_C_BH_PORT_RESET); 821 } 822 /* We can forget about a "removed" device when there's a 823 * physical disconnect or the connect status changes. 824 */ 825 if (!(portstatus & USB_PORT_STAT_CONNECTION) || 826 (portchange & USB_PORT_STAT_C_CONNECTION)) 827 clear_bit(port1, hub->removed_bits); 828 829 if (!udev || udev->state == USB_STATE_NOTATTACHED) { 830 /* Tell khubd to disconnect the device or 831 * check for a new connection 832 */ 833 if (udev || (portstatus & USB_PORT_STAT_CONNECTION)) 834 set_bit(port1, hub->change_bits); 835 836 } else if (portstatus & USB_PORT_STAT_ENABLE) { 837 /* The power session apparently survived the resume. 838 * If there was an overcurrent or suspend change 839 * (i.e., remote wakeup request), have khubd 840 * take care of it. 841 */ 842 if (portchange) 843 set_bit(port1, hub->change_bits); 844 845 } else if (udev->persist_enabled) { 846#ifdef CONFIG_PM 847 udev->reset_resume = 1; 848#endif 849 set_bit(port1, hub->change_bits); 850 851 } else { 852 /* The power session is gone; tell khubd */ 853 usb_set_device_state(udev, USB_STATE_NOTATTACHED); 854 set_bit(port1, hub->change_bits); 855 } 856 } 857 858 /* If no port-status-change flags were set, we don't need any 859 * debouncing. If flags were set we can try to debounce the 860 * ports all at once right now, instead of letting khubd do them 861 * one at a time later on. 862 * 863 * If any port-status changes do occur during this delay, khubd 864 * will see them later and handle them normally. 865 */ 866 if (need_debounce_delay) { 867 delay = HUB_DEBOUNCE_STABLE; 868 869 /* Don't do a long sleep inside a workqueue routine */ 870 if (type == HUB_INIT2) { 871 PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3); 872 schedule_delayed_work(&hub->init_work, 873 msecs_to_jiffies(delay)); 874 return; /* Continues at init3: below */ 875 } else { 876 msleep(delay); 877 } 878 } 879 init3: 880 hub->quiescing = 0; 881 882 status = usb_submit_urb(hub->urb, GFP_NOIO); 883 if (status < 0) 884 dev_err(hub->intfdev, "activate --> %d\n", status); 885 if (hub->has_indicators && blinkenlights) 886 schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD); 887 888 /* Scan all ports that need attention */ 889 kick_khubd(hub); 890 891 /* Allow autosuspend if it was suppressed */ 892 if (type <= HUB_INIT3) 893 usb_autopm_put_interface_async(to_usb_interface(hub->intfdev)); 894} 895 896/* Implement the continuations for the delays above */ 897static void hub_init_func2(struct work_struct *ws) 898{ 899 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work); 900 901 hub_activate(hub, HUB_INIT2); 902} 903 904static void hub_init_func3(struct work_struct *ws) 905{ 906 struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work); 907 908 hub_activate(hub, HUB_INIT3); 909} 910 911enum hub_quiescing_type { 912 HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND 913}; 914 915static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type) 916{ 917 struct usb_device *hdev = hub->hdev; 918 int i; 919 920 cancel_delayed_work_sync(&hub->init_work); 921 922 /* khubd and related activity won't re-trigger */ 923 hub->quiescing = 1; 924 925 if (type != HUB_SUSPEND) { 926 /* Disconnect all the children */ 927 for (i = 0; i < hdev->maxchild; ++i) { 928 if (hdev->children[i]) 929 usb_disconnect(&hdev->children[i]); 930 } 931 } 932 933 /* Stop khubd and related activity */ 934 usb_kill_urb(hub->urb); 935 if (hub->has_indicators) 936 cancel_delayed_work_sync(&hub->leds); 937 if (hub->tt.hub) 938 cancel_work_sync(&hub->tt.clear_work); 939} 940 941/* caller has locked the hub device */ 942static int hub_pre_reset(struct usb_interface *intf) 943{ 944 struct usb_hub *hub = usb_get_intfdata(intf); 945 946 hub_quiesce(hub, HUB_PRE_RESET); 947 return 0; 948} 949 950/* caller has locked the hub device */ 951static int hub_post_reset(struct usb_interface *intf) 952{ 953 struct usb_hub *hub = usb_get_intfdata(intf); 954 955 hub_activate(hub, HUB_POST_RESET); 956 return 0; 957} 958 959static int hub_configure(struct usb_hub *hub, 960 struct usb_endpoint_descriptor *endpoint) 961{ 962 struct usb_hcd *hcd; 963 struct usb_device *hdev = hub->hdev; 964 struct device *hub_dev = hub->intfdev; 965 u16 hubstatus, hubchange; 966 u16 wHubCharacteristics; 967 unsigned int pipe; 968 int maxp, ret; 969 char *message = "out of memory"; 970 971 hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL); 972 if (!hub->buffer) { 973 ret = -ENOMEM; 974 goto fail; 975 } 976 977 hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL); 978 if (!hub->status) { 979 ret = -ENOMEM; 980 goto fail; 981 } 982 mutex_init(&hub->status_mutex); 983 984 hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL); 985 if (!hub->descriptor) { 986 ret = -ENOMEM; 987 goto fail; 988 } 989 990 if (hub_is_superspeed(hdev) && (hdev->parent != NULL)) { 991 ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 992 HUB_SET_DEPTH, USB_RT_HUB, 993 hdev->level - 1, 0, NULL, 0, 994 USB_CTRL_SET_TIMEOUT); 995 996 if (ret < 0) { 997 message = "can't set hub depth"; 998 goto fail; 999 } 1000 } 1001 1002 /* Request the entire hub descriptor. 1003 * hub->descriptor can handle USB_MAXCHILDREN ports, 1004 * but the hub can/will return fewer bytes here. 1005 */ 1006 ret = get_hub_descriptor(hdev, hub->descriptor); 1007 if (ret < 0) { 1008 message = "can't read hub descriptor"; 1009 goto fail; 1010 } else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) { 1011 message = "hub has too many ports!"; 1012 ret = -ENODEV; 1013 goto fail; 1014 } 1015 1016 hdev->maxchild = hub->descriptor->bNbrPorts; 1017 dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild, 1018 (hdev->maxchild == 1) ? "" : "s"); 1019 1020 hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL); 1021 if (!hub->port_owners) { 1022 ret = -ENOMEM; 1023 goto fail; 1024 } 1025 1026 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics); 1027 1028 /* FIXME for USB 3.0, skip for now */ 1029 if ((wHubCharacteristics & HUB_CHAR_COMPOUND) && 1030 !(hub_is_superspeed(hdev))) { 1031 int i; 1032 char portstr [USB_MAXCHILDREN + 1]; 1033 1034 for (i = 0; i < hdev->maxchild; i++) 1035 portstr[i] = hub->descriptor->u.hs.DeviceRemovable 1036 [((i + 1) / 8)] & (1 << ((i + 1) % 8)) 1037 ? 'F' : 'R'; 1038 portstr[hdev->maxchild] = 0; 1039 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr); 1040 } else 1041 dev_dbg(hub_dev, "standalone hub\n"); 1042 1043 switch (wHubCharacteristics & HUB_CHAR_LPSM) { 1044 case 0x00: 1045 dev_dbg(hub_dev, "ganged power switching\n"); 1046 break; 1047 case 0x01: 1048 dev_dbg(hub_dev, "individual port power switching\n"); 1049 break; 1050 case 0x02: 1051 case 0x03: 1052 dev_dbg(hub_dev, "no power switching (usb 1.0)\n"); 1053 break; 1054 } 1055 1056 switch (wHubCharacteristics & HUB_CHAR_OCPM) { 1057 case 0x00: 1058 dev_dbg(hub_dev, "global over-current protection\n"); 1059 break; 1060 case 0x08: 1061 dev_dbg(hub_dev, "individual port over-current protection\n"); 1062 break; 1063 case 0x10: 1064 case 0x18: 1065 dev_dbg(hub_dev, "no over-current protection\n"); 1066 break; 1067 } 1068 1069 spin_lock_init (&hub->tt.lock); 1070 INIT_LIST_HEAD (&hub->tt.clear_list); 1071 INIT_WORK(&hub->tt.clear_work, hub_tt_work); 1072 switch (hdev->descriptor.bDeviceProtocol) { 1073 case 0: 1074 break; 1075 case 1: 1076 dev_dbg(hub_dev, "Single TT\n"); 1077 hub->tt.hub = hdev; 1078 break; 1079 case 2: 1080 ret = usb_set_interface(hdev, 0, 1); 1081 if (ret == 0) { 1082 dev_dbg(hub_dev, "TT per port\n"); 1083 hub->tt.multi = 1; 1084 } else 1085 dev_err(hub_dev, "Using single TT (err %d)\n", 1086 ret); 1087 hub->tt.hub = hdev; 1088 break; 1089 case 3: 1090 /* USB 3.0 hubs don't have a TT */ 1091 break; 1092 default: 1093 dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", 1094 hdev->descriptor.bDeviceProtocol); 1095 break; 1096 } 1097 1098 /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */ 1099 switch (wHubCharacteristics & HUB_CHAR_TTTT) { 1100 case HUB_TTTT_8_BITS: 1101 if (hdev->descriptor.bDeviceProtocol != 0) { 1102 hub->tt.think_time = 666; 1103 dev_dbg(hub_dev, "TT requires at most %d " 1104 "FS bit times (%d ns)\n", 1105 8, hub->tt.think_time); 1106 } 1107 break; 1108 case HUB_TTTT_16_BITS: 1109 hub->tt.think_time = 666 * 2; 1110 dev_dbg(hub_dev, "TT requires at most %d " 1111 "FS bit times (%d ns)\n", 1112 16, hub->tt.think_time); 1113 break; 1114 case HUB_TTTT_24_BITS: 1115 hub->tt.think_time = 666 * 3; 1116 dev_dbg(hub_dev, "TT requires at most %d " 1117 "FS bit times (%d ns)\n", 1118 24, hub->tt.think_time); 1119 break; 1120 case HUB_TTTT_32_BITS: 1121 hub->tt.think_time = 666 * 4; 1122 dev_dbg(hub_dev, "TT requires at most %d " 1123 "FS bit times (%d ns)\n", 1124 32, hub->tt.think_time); 1125 break; 1126 } 1127 1128 /* probe() zeroes hub->indicator[] */ 1129 if (wHubCharacteristics & HUB_CHAR_PORTIND) { 1130 hub->has_indicators = 1; 1131 dev_dbg(hub_dev, "Port indicators are supported\n"); 1132 } 1133 1134 dev_dbg(hub_dev, "power on to power good time: %dms\n", 1135 hub->descriptor->bPwrOn2PwrGood * 2); 1136 1137 /* power budgeting mostly matters with bus-powered hubs, 1138 * and battery-powered root hubs (may provide just 8 mA). 1139 */ 1140 ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus); 1141 if (ret < 2) { 1142 message = "can't get hub status"; 1143 goto fail; 1144 } 1145 le16_to_cpus(&hubstatus); 1146 if (hdev == hdev->bus->root_hub) { 1147 if (hdev->bus_mA == 0 || hdev->bus_mA >= 500) 1148 hub->mA_per_port = 500; 1149 else { 1150 hub->mA_per_port = hdev->bus_mA; 1151 hub->limited_power = 1; 1152 } 1153 } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) { 1154 dev_dbg(hub_dev, "hub controller current requirement: %dmA\n", 1155 hub->descriptor->bHubContrCurrent); 1156 hub->limited_power = 1; 1157 if (hdev->maxchild > 0) { 1158 int remaining = hdev->bus_mA - 1159 hub->descriptor->bHubContrCurrent; 1160 1161 if (remaining < hdev->maxchild * 100) 1162 dev_warn(hub_dev, 1163 "insufficient power available " 1164 "to use all downstream ports\n"); 1165 hub->mA_per_port = 100; /* 7.2.1.1 */ 1166 } 1167 } else { /* Self-powered external hub */ 1168 /* FIXME: What about battery-powered external hubs that 1169 * provide less current per port? */ 1170 hub->mA_per_port = 500; 1171 } 1172 if (hub->mA_per_port < 500) 1173 dev_dbg(hub_dev, "%umA bus power budget for each child\n", 1174 hub->mA_per_port); 1175 1176 /* Update the HCD's internal representation of this hub before khubd 1177 * starts getting port status changes for devices under the hub. 1178 */ 1179 hcd = bus_to_hcd(hdev->bus); 1180 if (hcd->driver->update_hub_device) { 1181 ret = hcd->driver->update_hub_device(hcd, hdev, 1182 &hub->tt, GFP_KERNEL); 1183 if (ret < 0) { 1184 message = "can't update HCD hub info"; 1185 goto fail; 1186 } 1187 } 1188 1189 ret = hub_hub_status(hub, &hubstatus, &hubchange); 1190 if (ret < 0) { 1191 message = "can't get hub status"; 1192 goto fail; 1193 } 1194 1195 /* local power status reports aren't always correct */ 1196 if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER) 1197 dev_dbg(hub_dev, "local power source is %s\n", 1198 (hubstatus & HUB_STATUS_LOCAL_POWER) 1199 ? "lost (inactive)" : "good"); 1200 1201 if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0) 1202 dev_dbg(hub_dev, "%sover-current condition exists\n", 1203 (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no "); 1204 1205 /* set up the interrupt endpoint 1206 * We use the EP's maxpacket size instead of (PORTS+1+7)/8 1207 * bytes as USB2.0[11.12.3] says because some hubs are known 1208 * to send more data (and thus cause overflow). For root hubs, 1209 * maxpktsize is defined in hcd.c's fake endpoint descriptors 1210 * to be big enough for at least USB_MAXCHILDREN ports. */ 1211 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress); 1212 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe)); 1213 1214 if (maxp > sizeof(*hub->buffer)) 1215 maxp = sizeof(*hub->buffer); 1216 1217 hub->urb = usb_alloc_urb(0, GFP_KERNEL); 1218 if (!hub->urb) { 1219 ret = -ENOMEM; 1220 goto fail; 1221 } 1222 1223 usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, 1224 hub, endpoint->bInterval); 1225 1226 /* maybe cycle the hub leds */ 1227 if (hub->has_indicators && blinkenlights) 1228 hub->indicator [0] = INDICATOR_CYCLE; 1229 1230 hub_activate(hub, HUB_INIT); 1231 return 0; 1232 1233fail: 1234 dev_err (hub_dev, "config failed, %s (err %d)\n", 1235 message, ret); 1236 /* hub_disconnect() frees urb and descriptor */ 1237 return ret; 1238} 1239 1240static void hub_release(struct kref *kref) 1241{ 1242 struct usb_hub *hub = container_of(kref, struct usb_hub, kref); 1243 1244 usb_put_intf(to_usb_interface(hub->intfdev)); 1245 kfree(hub); 1246} 1247 1248static unsigned highspeed_hubs; 1249 1250static void hub_disconnect(struct usb_interface *intf) 1251{ 1252 struct usb_hub *hub = usb_get_intfdata (intf); 1253 1254 /* Take the hub off the event list and don't let it be added again */ 1255 spin_lock_irq(&hub_event_lock); 1256 if (!list_empty(&hub->event_list)) { 1257 list_del_init(&hub->event_list); 1258 usb_autopm_put_interface_no_suspend(intf); 1259 } 1260 hub->disconnected = 1; 1261 spin_unlock_irq(&hub_event_lock); 1262 1263 /* Disconnect all children and quiesce the hub */ 1264 hub->error = 0; 1265 hub_quiesce(hub, HUB_DISCONNECT); 1266 1267 usb_set_intfdata (intf, NULL); 1268 hub->hdev->maxchild = 0; 1269 1270 if (hub->hdev->speed == USB_SPEED_HIGH) 1271 highspeed_hubs--; 1272 1273 usb_free_urb(hub->urb); 1274 kfree(hub->port_owners); 1275 kfree(hub->descriptor); 1276 kfree(hub->status); 1277 kfree(hub->buffer); 1278 1279 kref_put(&hub->kref, hub_release); 1280} 1281 1282static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) 1283{ 1284 struct usb_host_interface *desc; 1285 struct usb_endpoint_descriptor *endpoint; 1286 struct usb_device *hdev; 1287 struct usb_hub *hub; 1288 1289 desc = intf->cur_altsetting; 1290 hdev = interface_to_usbdev(intf); 1291 1292 /* Hubs have proper suspend/resume support. USB 3.0 device suspend is 1293 * different from USB 2.0/1.1 device suspend, and unfortunately we 1294 * don't support it yet. So leave autosuspend disabled for USB 3.0 1295 * external hubs for now. Enable autosuspend for USB 3.0 roothubs, 1296 * since that isn't a "real" hub. 1297 */ 1298 if (!hub_is_superspeed(hdev) || !hdev->parent) 1299 usb_enable_autosuspend(hdev); 1300 1301 if (hdev->level == MAX_TOPO_LEVEL) { 1302 dev_err(&intf->dev, 1303 "Unsupported bus topology: hub nested too deep\n"); 1304 return -E2BIG; 1305 } 1306 1307#ifdef CONFIG_USB_OTG_BLACKLIST_HUB 1308 if (hdev->parent) { 1309 dev_warn(&intf->dev, "ignoring external hub\n"); 1310 return -ENODEV; 1311 } 1312#endif 1313 1314 /* Some hubs have a subclass of 1, which AFAICT according to the */ 1315 /* specs is not defined, but it works */ 1316 if ((desc->desc.bInterfaceSubClass != 0) && 1317 (desc->desc.bInterfaceSubClass != 1)) { 1318descriptor_error: 1319 dev_err (&intf->dev, "bad descriptor, ignoring hub\n"); 1320 return -EIO; 1321 } 1322 1323 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 1324 if (desc->desc.bNumEndpoints != 1) 1325 goto descriptor_error; 1326 1327 endpoint = &desc->endpoint[0].desc; 1328 1329 /* If it's not an interrupt in endpoint, we'd better punt! */ 1330 if (!usb_endpoint_is_int_in(endpoint)) 1331 goto descriptor_error; 1332 1333 /* We found a hub */ 1334 dev_info (&intf->dev, "USB hub found\n"); 1335 1336 hub = kzalloc(sizeof(*hub), GFP_KERNEL); 1337 if (!hub) { 1338 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n"); 1339 return -ENOMEM; 1340 } 1341 1342 kref_init(&hub->kref); 1343 INIT_LIST_HEAD(&hub->event_list); 1344 hub->intfdev = &intf->dev; 1345 hub->hdev = hdev; 1346 INIT_DELAYED_WORK(&hub->leds, led_work); 1347 INIT_DELAYED_WORK(&hub->init_work, NULL); 1348 usb_get_intf(intf); 1349 1350 usb_set_intfdata (intf, hub); 1351 intf->needs_remote_wakeup = 1; 1352 1353 if (hdev->speed == USB_SPEED_HIGH) 1354 highspeed_hubs++; 1355 1356 if (hub_configure(hub, endpoint) >= 0) 1357 return 0; 1358 1359 hub_disconnect (intf); 1360 return -ENODEV; 1361} 1362 1363/* No BKL needed */ 1364static int 1365hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data) 1366{ 1367 struct usb_device *hdev = interface_to_usbdev (intf); 1368 1369 /* assert ifno == 0 (part of hub spec) */ 1370 switch (code) { 1371 case USBDEVFS_HUB_PORTINFO: { 1372 struct usbdevfs_hub_portinfo *info = user_data; 1373 int i; 1374 1375 spin_lock_irq(&device_state_lock); 1376 if (hdev->devnum <= 0) 1377 info->nports = 0; 1378 else { 1379 info->nports = hdev->maxchild; 1380 for (i = 0; i < info->nports; i++) { 1381 if (hdev->children[i] == NULL) 1382 info->port[i] = 0; 1383 else 1384 info->port[i] = 1385 hdev->children[i]->devnum; 1386 } 1387 } 1388 spin_unlock_irq(&device_state_lock); 1389 1390 return info->nports + 1; 1391 } 1392 1393 default: 1394 return -ENOSYS; 1395 } 1396} 1397 1398/* 1399 * Allow user programs to claim ports on a hub. When a device is attached 1400 * to one of these "claimed" ports, the program will "own" the device. 1401 */ 1402static int find_port_owner(struct usb_device *hdev, unsigned port1, 1403 void ***ppowner) 1404{ 1405 if (hdev->state == USB_STATE_NOTATTACHED) 1406 return -ENODEV; 1407 if (port1 == 0 || port1 > hdev->maxchild) 1408 return -EINVAL; 1409 1410 /* This assumes that devices not managed by the hub driver 1411 * will always have maxchild equal to 0. 1412 */ 1413 *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]); 1414 return 0; 1415} 1416 1417/* In the following three functions, the caller must hold hdev's lock */ 1418int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner) 1419{ 1420 int rc; 1421 void **powner; 1422 1423 rc = find_port_owner(hdev, port1, &powner); 1424 if (rc) 1425 return rc; 1426 if (*powner) 1427 return -EBUSY; 1428 *powner = owner; 1429 return rc; 1430} 1431 1432int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner) 1433{ 1434 int rc; 1435 void **powner; 1436 1437 rc = find_port_owner(hdev, port1, &powner); 1438 if (rc) 1439 return rc; 1440 if (*powner != owner) 1441 return -ENOENT; 1442 *powner = NULL; 1443 return rc; 1444} 1445 1446void usb_hub_release_all_ports(struct usb_device *hdev, void *owner) 1447{ 1448 int n; 1449 void **powner; 1450 1451 n = find_port_owner(hdev, 1, &powner); 1452 if (n == 0) { 1453 for (; n < hdev->maxchild; (++n, ++powner)) { 1454 if (*powner == owner) 1455 *powner = NULL; 1456 } 1457 } 1458} 1459 1460/* The caller must hold udev's lock */ 1461bool usb_device_is_owned(struct usb_device *udev) 1462{ 1463 struct usb_hub *hub; 1464 1465 if (udev->state == USB_STATE_NOTATTACHED || !udev->parent) 1466 return false; 1467 hub = hdev_to_hub(udev->parent); 1468 return !!hub->port_owners[udev->portnum - 1]; 1469} 1470 1471 1472static void recursively_mark_NOTATTACHED(struct usb_device *udev) 1473{ 1474 int i; 1475 1476 for (i = 0; i < udev->maxchild; ++i) { 1477 if (udev->children[i]) 1478 recursively_mark_NOTATTACHED(udev->children[i]); 1479 } 1480 if (udev->state == USB_STATE_SUSPENDED) 1481 udev->active_duration -= jiffies; 1482 udev->state = USB_STATE_NOTATTACHED; 1483} 1484 1485/** 1486 * usb_set_device_state - change a device's current state (usbcore, hcds) 1487 * @udev: pointer to device whose state should be changed 1488 * @new_state: new state value to be stored 1489 * 1490 * udev->state is _not_ fully protected by the device lock. Although 1491 * most transitions are made only while holding the lock, the state can 1492 * can change to USB_STATE_NOTATTACHED at almost any time. This 1493 * is so that devices can be marked as disconnected as soon as possible, 1494 * without having to wait for any semaphores to be released. As a result, 1495 * all changes to any device's state must be protected by the 1496 * device_state_lock spinlock. 1497 * 1498 * Once a device has been added to the device tree, all changes to its state 1499 * should be made using this routine. The state should _not_ be set directly. 1500 * 1501 * If udev->state is already USB_STATE_NOTATTACHED then no change is made. 1502 * Otherwise udev->state is set to new_state, and if new_state is 1503 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set 1504 * to USB_STATE_NOTATTACHED. 1505 */ 1506void usb_set_device_state(struct usb_device *udev, 1507 enum usb_device_state new_state) 1508{ 1509 unsigned long flags; 1510 int wakeup = -1; 1511 1512 spin_lock_irqsave(&device_state_lock, flags); 1513 if (udev->state == USB_STATE_NOTATTACHED) 1514 ; /* do nothing */ 1515 else if (new_state != USB_STATE_NOTATTACHED) { 1516 1517 /* root hub wakeup capabilities are managed out-of-band 1518 * and may involve silicon errata ... ignore them here. 1519 */ 1520 if (udev->parent) { 1521 if (udev->state == USB_STATE_SUSPENDED 1522 || new_state == USB_STATE_SUSPENDED) 1523 ; /* No change to wakeup settings */ 1524 else if (new_state == USB_STATE_CONFIGURED) 1525 wakeup = udev->actconfig->desc.bmAttributes 1526 & USB_CONFIG_ATT_WAKEUP; 1527 else 1528 wakeup = 0; 1529 } 1530 if (udev->state == USB_STATE_SUSPENDED && 1531 new_state != USB_STATE_SUSPENDED) 1532 udev->active_duration -= jiffies; 1533 else if (new_state == USB_STATE_SUSPENDED && 1534 udev->state != USB_STATE_SUSPENDED) 1535 udev->active_duration += jiffies; 1536 udev->state = new_state; 1537 } else 1538 recursively_mark_NOTATTACHED(udev); 1539 spin_unlock_irqrestore(&device_state_lock, flags); 1540 if (wakeup >= 0) 1541 device_set_wakeup_capable(&udev->dev, wakeup); 1542} 1543EXPORT_SYMBOL_GPL(usb_set_device_state); 1544 1545/* 1546 * Choose a device number. 1547 * 1548 * Device numbers are used as filenames in usbfs. On USB-1.1 and 1549 * USB-2.0 buses they are also used as device addresses, however on 1550 * USB-3.0 buses the address is assigned by the controller hardware 1551 * and it usually is not the same as the device number. 1552 * 1553 * WUSB devices are simple: they have no hubs behind, so the mapping 1554 * device <-> virtual port number becomes 1:1. Why? to simplify the 1555 * life of the device connection logic in 1556 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret 1557 * handshake we need to assign a temporary address in the unauthorized 1558 * space. For simplicity we use the first virtual port number found to 1559 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()] 1560 * and that becomes it's address [X < 128] or its unauthorized address 1561 * [X | 0x80]. 1562 * 1563 * We add 1 as an offset to the one-based USB-stack port number 1564 * (zero-based wusb virtual port index) for two reasons: (a) dev addr 1565 * 0 is reserved by USB for default address; (b) Linux's USB stack 1566 * uses always #1 for the root hub of the controller. So USB stack's 1567 * port #1, which is wusb virtual-port #0 has address #2. 1568 * 1569 * Devices connected under xHCI are not as simple. The host controller 1570 * supports virtualization, so the hardware assigns device addresses and 1571 * the HCD must setup data structures before issuing a set address 1572 * command to the hardware. 1573 */ 1574static void choose_devnum(struct usb_device *udev) 1575{ 1576 int devnum; 1577 struct usb_bus *bus = udev->bus; 1578 1579 /* If khubd ever becomes multithreaded, this will need a lock */ 1580 if (udev->wusb) { 1581 devnum = udev->portnum + 1; 1582 BUG_ON(test_bit(devnum, bus->devmap.devicemap)); 1583 } else { 1584 /* Try to allocate the next devnum beginning at 1585 * bus->devnum_next. */ 1586 devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1587 bus->devnum_next); 1588 if (devnum >= 128) 1589 devnum = find_next_zero_bit(bus->devmap.devicemap, 1590 128, 1); 1591 bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1); 1592 } 1593 if (devnum < 128) { 1594 set_bit(devnum, bus->devmap.devicemap); 1595 udev->devnum = devnum; 1596 } 1597} 1598 1599static void release_devnum(struct usb_device *udev) 1600{ 1601 if (udev->devnum > 0) { 1602 clear_bit(udev->devnum, udev->bus->devmap.devicemap); 1603 udev->devnum = -1; 1604 } 1605} 1606 1607static void update_devnum(struct usb_device *udev, int devnum) 1608{ 1609 /* The address for a WUSB device is managed by wusbcore. */ 1610 if (!udev->wusb) 1611 udev->devnum = devnum; 1612} 1613 1614static void hub_free_dev(struct usb_device *udev) 1615{ 1616 struct usb_hcd *hcd = bus_to_hcd(udev->bus); 1617 1618 /* Root hubs aren't real devices, so don't free HCD resources */ 1619 if (hcd->driver->free_dev && udev->parent) 1620 hcd->driver->free_dev(hcd, udev); 1621} 1622 1623/** 1624 * usb_disconnect - disconnect a device (usbcore-internal) 1625 * @pdev: pointer to device being disconnected 1626 * Context: !in_interrupt () 1627 * 1628 * Something got disconnected. Get rid of it and all of its children. 1629 * 1630 * If *pdev is a normal device then the parent hub must already be locked. 1631 * If *pdev is a root hub then this routine will acquire the 1632 * usb_bus_list_lock on behalf of the caller. 1633 * 1634 * Only hub drivers (including virtual root hub drivers for host 1635 * controllers) should ever call this. 1636 * 1637 * This call is synchronous, and may not be used in an interrupt context. 1638 */ 1639void usb_disconnect(struct usb_device **pdev) 1640{ 1641 struct usb_device *udev = *pdev; 1642 int i; 1643 struct usb_hcd *hcd = bus_to_hcd(udev->bus); 1644 1645 if (!udev) { 1646 pr_debug ("%s nodev\n", __func__); 1647 return; 1648 } 1649 1650 /* mark the device as inactive, so any further urb submissions for 1651 * this device (and any of its children) will fail immediately. 1652 * this quiesces everything except pending urbs. 1653 */ 1654 usb_set_device_state(udev, USB_STATE_NOTATTACHED); 1655 dev_info(&udev->dev, "USB disconnect, device number %d\n", 1656 udev->devnum); 1657 1658 usb_lock_device(udev); 1659 1660 /* Free up all the children before we remove this device */ 1661 for (i = 0; i < USB_MAXCHILDREN; i++) { 1662 if (udev->children[i]) 1663 usb_disconnect(&udev->children[i]); 1664 } 1665 1666 /* deallocate hcd/hardware state ... nuking all pending urbs and 1667 * cleaning up all state associated with the current configuration 1668 * so that the hardware is now fully quiesced. 1669 */ 1670 dev_dbg (&udev->dev, "unregistering device\n"); 1671 mutex_lock(hcd->bandwidth_mutex); 1672 usb_disable_device(udev, 0); 1673 mutex_unlock(hcd->bandwidth_mutex); 1674 usb_hcd_synchronize_unlinks(udev); 1675 1676 usb_remove_ep_devs(&udev->ep0); 1677 usb_unlock_device(udev); 1678 1679 /* Unregister the device. The device driver is responsible 1680 * for de-configuring the device and invoking the remove-device 1681 * notifier chain (used by usbfs and possibly others). 1682 */ 1683 device_del(&udev->dev); 1684 1685 /* Free the device number and delete the parent's children[] 1686 * (or root_hub) pointer. 1687 */ 1688 release_devnum(udev); 1689 1690 /* Avoid races with recursively_mark_NOTATTACHED() */ 1691 spin_lock_irq(&device_state_lock); 1692 *pdev = NULL; 1693 spin_unlock_irq(&device_state_lock); 1694 1695 hub_free_dev(udev); 1696 1697 put_device(&udev->dev); 1698} 1699 1700#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES 1701static void show_string(struct usb_device *udev, char *id, char *string) 1702{ 1703 if (!string) 1704 return; 1705 dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string); 1706} 1707 1708static void announce_device(struct usb_device *udev) 1709{ 1710 dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n", 1711 le16_to_cpu(udev->descriptor.idVendor), 1712 le16_to_cpu(udev->descriptor.idProduct)); 1713 dev_info(&udev->dev, 1714 "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 1715 udev->descriptor.iManufacturer, 1716 udev->descriptor.iProduct, 1717 udev->descriptor.iSerialNumber); 1718 show_string(udev, "Product", udev->product); 1719 show_string(udev, "Manufacturer", udev->manufacturer); 1720 show_string(udev, "SerialNumber", udev->serial); 1721} 1722#else 1723static inline void announce_device(struct usb_device *udev) { } 1724#endif 1725 1726#ifdef CONFIG_USB_OTG 1727#include "otg_whitelist.h" 1728#endif 1729 1730/** 1731 * usb_enumerate_device_otg - FIXME (usbcore-internal) 1732 * @udev: newly addressed device (in ADDRESS state) 1733 * 1734 * Finish enumeration for On-The-Go devices 1735 */ 1736static int usb_enumerate_device_otg(struct usb_device *udev) 1737{ 1738 int err = 0; 1739 1740#ifdef CONFIG_USB_OTG 1741 /* 1742 * OTG-aware devices on OTG-capable root hubs may be able to use SRP, 1743 * to wake us after we've powered off VBUS; and HNP, switching roles 1744 * "host" to "peripheral". The OTG descriptor helps figure this out. 1745 */ 1746 if (!udev->bus->is_b_host 1747 && udev->config 1748 && udev->parent == udev->…
Large files files are truncated, but you can click here to view the full file