drivers/usb/hub.c

   1 /*
   2  * USB hub driver.
   3  *
   4  * (C) Copyright 1999 Linus Torvalds
   5  * (C) Copyright 1999 Johannes Erdfelt
   6  * (C) Copyright 1999 Gregory P. Smith
   7  * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
   8  *
   9  */
  10
  11 #include <linux/config.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/completion.h>
  15 #include <linux/sched.h>
  16 #include <linux/list.h>
  17 #include <linux/slab.h>
  18 #include <linux/smp_lock.h>
  19 #ifdef CONFIG_USB_DEBUG
  20         #define DEBUG
  21 #else
  22         #undef DEBUG
  23 #endif
  24 #include <linux/usb.h>
  25 #include <linux/usbdevice_fs.h>
  26
  27 #include <asm/semaphore.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/byteorder.h>
  30
  31 #include "hub.h"
  32
  33 /* Wakes up khubd */
  34 static spinlock_t hub_event_lock = SPIN_LOCK_UNLOCKED;
  35 static DECLARE_MUTEX(usb_address0_sem);
  36
  37 static LIST_HEAD(hub_event_list);       /* List of hubs needing servicing */
  38 static LIST_HEAD(hub_list);             /* List containing all of the hubs (for cleanup) */
  39
  40 static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
  41 static pid_t khubd_pid = 0;                     /* PID of khubd */
  42 static DECLARE_COMPLETION(khubd_exited);
  43
  44 #ifdef  DEBUG
  45 static inline char *portspeed (int portstatus)
  46 {
  47         if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
  48                 return "480 Mb/s";
  49         else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
  50                 return "1.5 Mb/s";
  51         else
  52                 return "12 Mb/s";
  53 }
  54 #endif
  55
  56 /* USB 2.0 spec Section 11.24.4.5 */
  57 static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
  58 {
  59         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  60                 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
  61                 USB_DT_HUB << 8, 0, data, size, HZ);
  62 }
  63
  64 /*
  65  * USB 2.0 spec Section 11.24.2.1
  66  */
  67 static int usb_clear_hub_feature(struct usb_device *dev, int feature)
  68 {
  69         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  70                 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, HZ);
  71 }
  72
  73 /*
  74  * USB 2.0 spec Section 11.24.2.2
  75  * BUG: doesn't handle port indicator selector in high byte of wIndex
  76  */
  77 static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
  78 {
  79         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  80                 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
  81 }
  82
  83 /*
  84  * USB 2.0 spec Section 11.24.2.13
  85  * BUG: doesn't handle port indicator selector in high byte of wIndex
  86  */
  87 static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
  88 {
  89         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  90                 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
  91 }
  92
  93 /*
  94  * USB 2.0 spec Section 11.24.2.6
  95  */
  96 static int usb_get_hub_status(struct usb_device *dev, void *data)
  97 {
  98         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  99                 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
 100                 data, sizeof(struct usb_hub_status), HZ);
 101 }
 102
 103 /*
 104  * USB 2.0 spec Section 11.24.2.7
 105  */
 106 static int usb_get_port_status(struct usb_device *dev, int port, void *data)
 107 {
 108         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 109                 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
 110                 data, sizeof(struct usb_hub_status), HZ);
 111 }
 112
 113 static void hub_irq(struct urb *urb)
 114 {
 115         struct usb_hub *hub = (struct usb_hub *)urb->context;
 116         unsigned long flags;
 117
 118         /* Cause a hub reset after 10 consecutive errors */
 119         if (urb->status) {
 120                 if (urb->status == -ENOENT)
 121                         return;
 122
 123                 dbg("nonzero status in irq %d", urb->status);
 124
 125                 if ((++hub->nerrors < 10) || hub->error)
 126                         return;
 127
 128                 hub->error = urb->status;
 129         }
 130
 131         hub->nerrors = 0;
 132
 133         /* Something happened, let khubd figure it out */
 134         spin_lock_irqsave(&hub_event_lock, flags);
 135         if (list_empty(&hub->event_list)) {
 136                 list_add(&hub->event_list, &hub_event_list);
 137                 wake_up(&khubd_wait);
 138         }
 139         spin_unlock_irqrestore(&hub_event_lock, flags);
 140 }
 141
 142 static void usb_hub_power_on(struct usb_hub *hub)
 143 {
 144         int i;
 145
 146         /* Enable power to the ports */
 147         dbg("enabling power on all ports");
 148         for (i = 0; i < hub->descriptor->bNbrPorts; i++)
 149                 usb_set_port_feature(hub->dev, i + 1, USB_PORT_FEAT_POWER);
 150
 151         /* Wait for power to be enabled */
 152         wait_ms(hub->descriptor->bPwrOn2PwrGood * 2);
 153 }
 154
 155 static int usb_hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint)
 156 {
 157         struct usb_device *dev = hub->dev;
 158         struct usb_hub_status *hubstatus;
 159         char portstr[USB_MAXCHILDREN + 1];
 160         unsigned int pipe;
 161         int i, maxp, ret;
 162
 163         hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
 164         if (!hub->descriptor) {
 165                 err("Unable to kmalloc %Zd bytes for hub descriptor", sizeof(*hub->descriptor));
 166                 return -1;
 167         }
 168
 169         /* Request the entire hub descriptor. */
 170         ret = usb_get_hub_descriptor(dev, hub->descriptor, sizeof(*hub->descriptor));
 171                 /* <hub->descriptor> is large enough for a hub with 127 ports;
 172                  * the hub can/will return fewer bytes here. */
 173         if (ret < 0) {
 174                 err("Unable to get hub descriptor (err = %d)", ret);
 175                 kfree(hub->descriptor);
 176                 return -1;
 177         }
 178
 179         dev->maxchild = hub->descriptor->bNbrPorts;
 180         info("%d port%s detected", hub->descriptor->bNbrPorts, (hub->descriptor->bNbrPorts == 1) ? "" : "s");
 181
 182         le16_to_cpus(&hub->descriptor->wHubCharacteristics);
 183
 184         if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND)
 185                 dbg("part of a compound device");
 186         else
 187                 dbg("standalone hub");
 188
 189         switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {
 190                 case 0x00:
 191                         dbg("ganged power switching");
 192                         break;
 193                 case 0x01:
 194                         dbg("individual port power switching");
 195                         break;
 196                 case 0x02:
 197                 case 0x03:
 198                         dbg("unknown reserved power switching mode");
 199                         break;
 200         }
 201
 202         switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {
 203                 case 0x00:
 204                         dbg("global over-current protection");
 205                         break;
 206                 case 0x08:
 207                         dbg("individual port over-current protection");
 208                         break;
 209                 case 0x10:
 210                 case 0x18:
 211                         dbg("no over-current protection");
 212                         break;
 213         }
 214
 215         switch (dev->descriptor.bDeviceProtocol) {
 216                 case 0:
 217                         break;
 218                 case 1:
 219                         dbg("Single TT");
 220                         hub->tt.hub = dev;
 221                         break;
 222                 case 2:
 223                         dbg("TT per port");
 224                         hub->tt.hub = dev;
 225                         hub->tt.multi = 1;
 226                         break;
 227                 default:
 228                         dbg("Unrecognized hub protocol %d",
 229                                 dev->descriptor.bDeviceProtocol);
 230                         break;
 231         }
 232
 233         switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
 234                 case 0x00:
 235                         if (dev->descriptor.bDeviceProtocol != 0)
 236                                 dbg("TT requires at most 8 FS bit times");
 237                         break;
 238                 case 0x20:
 239                         dbg("TT requires at most 16 FS bit times");
 240                         break;
 241                 case 0x40:
 242                         dbg("TT requires at most 24 FS bit times");
 243                         break;
 244                 case 0x60:
 245                         dbg("TT requires at most 32 FS bit times");
 246                         break;
 247         }
 248
 249         dbg("Port indicators are %s supported",
 250             (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) ? "" : "not");
 251
 252         dbg("power on to power good time: %dms", hub->descriptor->bPwrOn2PwrGood * 2);
 253         dbg("hub controller current requirement: %dmA", hub->descriptor->bHubContrCurrent);
 254
 255         for (i = 0; i < dev->maxchild; i++)
 256                 portstr[i] = hub->descriptor->DeviceRemovable[((i + 1) / 8)] & (1 << ((i + 1) % 8)) ? 'F' : 'R';
 257         portstr[dev->maxchild] = 0;
 258
 259         dbg("port removable status: %s", portstr);
 260
 261         hubstatus = kmalloc(sizeof *hubstatus, GFP_KERNEL);
 262         if (!hubstatus) {
 263                 err("Unable to allocate hubstatus");
 264                 kfree(hub->descriptor);
 265                 return -1;
 266         }
 267         ret = usb_get_hub_status(dev, hubstatus);
 268         if (ret < 0) {
 269                 err("Unable to get hub status (err = %d)", ret);
 270                 kfree(hubstatus);
 271                 kfree(hub->descriptor);
 272                 return -1;
 273         }
 274
 275         le16_to_cpus(&hubstatus->wHubStatus);
 276
 277         dbg("local power source is %s",
 278                 (hubstatus->wHubStatus & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");
 279
 280         dbg("%sover-current condition exists",
 281                 (hubstatus->wHubStatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
 282
 283         kfree(hubstatus);
 284
 285         /* Start the interrupt endpoint */
 286         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
 287         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
 288
 289         if (maxp > sizeof(hub->buffer))
 290                 maxp = sizeof(hub->buffer);
 291
 292         hub->urb = usb_alloc_urb(0);
 293         if (!hub->urb) {
 294                 err("couldn't allocate interrupt urb");
 295                 kfree(hub->descriptor);
 296                 return -1;
 297         }
 298
 299         FILL_INT_URB(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq, hub,
 300                 /* NOTE:  in 2.5 fill_int_urb() converts the encoding */
 301                 (dev->speed == USB_SPEED_HIGH)
 302                         ? 1 << (endpoint->bInterval - 1)
 303                         : endpoint->bInterval);
 304         ret = usb_submit_urb(hub->urb);
 305         if (ret) {
 306                 err("usb_submit_urb failed (%d)", ret);
 307                 kfree(hub->descriptor);
 308                 return -1;
 309         }
 310
 311         /* Wake up khubd */
 312         wake_up(&khubd_wait);
 313
 314         usb_hub_power_on(hub);
 315
 316         return 0;
 317 }
 318
 319 static void *hub_probe(struct usb_device *dev, unsigned int i,
 320                        const struct usb_device_id *id)
 321 {
 322         struct usb_interface_descriptor *interface;
 323         struct usb_endpoint_descriptor *endpoint;
 324         struct usb_hub *hub;
 325         unsigned long flags;
 326
 327         interface = &dev->actconfig->interface[i].altsetting[0];
 328
 329         /* Some hubs have a subclass of 1, which AFAICT according to the */
 330         /*  specs is not defined, but it works */
 331         if ((interface->bInterfaceSubClass != 0) &&
 332             (interface->bInterfaceSubClass != 1)) {
 333                 err("invalid subclass (%d) for USB hub device #%d",
 334                         interface->bInterfaceSubClass, dev->devnum);
 335                 return NULL;
 336         }
 337
 338         /* Multiple endpoints? What kind of mutant ninja-hub is this? */
 339         if (interface->bNumEndpoints != 1) {
 340                 err("invalid bNumEndpoints (%d) for USB hub device #%d",
 341                         interface->bNumEndpoints, dev->devnum);
 342                 return NULL;
 343         }
 344
 345         endpoint = &interface->endpoint[0];
 346
 347         /* Output endpoint? Curiousier and curiousier.. */
 348         if (!(endpoint->bEndpointAddress & USB_DIR_IN)) {
 349                 err("Device #%d is hub class, but has output endpoint?",
 350                         dev->devnum);
 351                 return NULL;
 352         }
 353
 354         /* If it's not an interrupt endpoint, we'd better punt! */
 355         if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT) {
 356                 err("Device #%d is hub class, but has endpoint other than interrupt?",
 357                         dev->devnum);
 358                 return NULL;
 359         }
 360
 361         /* We found a hub */
 362         info("USB hub found");
 363
 364         hub = kmalloc(sizeof(*hub), GFP_KERNEL);
 365         if (!hub) {
 366                 err("couldn't kmalloc hub struct");
 367                 return NULL;
 368         }
 369
 370         memset(hub, 0, sizeof(*hub));
 371
 372         INIT_LIST_HEAD(&hub->event_list);
 373         hub->dev = dev;
 374         init_MUTEX(&hub->khubd_sem);
 375
 376         /* Record the new hub's existence */
 377         spin_lock_irqsave(&hub_event_lock, flags);
 378         INIT_LIST_HEAD(&hub->hub_list);
 379         list_add(&hub->hub_list, &hub_list);
 380         spin_unlock_irqrestore(&hub_event_lock, flags);
 381
 382         if (usb_hub_configure(hub, endpoint) >= 0)
 383                 return hub;
 384
 385         err("hub configuration failed for device #%d", dev->devnum);
 386
 387         /* free hub, but first clean up its list. */
 388         spin_lock_irqsave(&hub_event_lock, flags);
 389
 390         /* Delete it and then reset it */
 391         list_del(&hub->event_list);
 392         INIT_LIST_HEAD(&hub->event_list);
 393         list_del(&hub->hub_list);
 394         INIT_LIST_HEAD(&hub->hub_list);
 395
 396         spin_unlock_irqrestore(&hub_event_lock, flags);
 397
 398         kfree(hub);
 399
 400         return NULL;
 401 }
 402
 403 static void hub_disconnect(struct usb_device *dev, void *ptr)
 404 {
 405         struct usb_hub *hub = (struct usb_hub *)ptr;
 406         unsigned long flags;
 407
 408         spin_lock_irqsave(&hub_event_lock, flags);
 409
 410         /* Delete it and then reset it */
 411         list_del(&hub->event_list);
 412         INIT_LIST_HEAD(&hub->event_list);
 413         list_del(&hub->hub_list);
 414         INIT_LIST_HEAD(&hub->hub_list);
 415
 416         spin_unlock_irqrestore(&hub_event_lock, flags);
 417
 418         down(&hub->khubd_sem); /* Wait for khubd to leave this hub alone. */
 419         up(&hub->khubd_sem);
 420
 421         if (hub->urb) {
 422                 usb_unlink_urb(hub->urb);
 423                 usb_free_urb(hub->urb);
 424                 hub->urb = NULL;
 425         }
 426
 427         if (hub->descriptor) {
 428                 kfree(hub->descriptor);
 429                 hub->descriptor = NULL;
 430         }
 431
 432         /* Free the memory */
 433         kfree(hub);
 434 }
 435
 436 static int hub_ioctl(struct usb_device *hub, unsigned int code, void *user_data)
 437 {
 438         /* assert ifno == 0 (part of hub spec) */
 439         switch (code) {
 440         case USBDEVFS_HUB_PORTINFO: {
 441                 struct usbdevfs_hub_portinfo *info = user_data;
 442                 unsigned long flags;
 443                 int i;
 444
 445                 spin_lock_irqsave(&hub_event_lock, flags);
 446                 if (hub->devnum <= 0)
 447                         info->nports = 0;
 448                 else {
 449                         info->nports = hub->maxchild;
 450                         for (i = 0; i < info->nports; i++) {
 451                                 if (hub->children[i] == NULL)
 452                                         info->port[i] = 0;
 453                                 else
 454                                         info->port[i] = hub->children[i]->devnum;
 455                         }
 456                 }
 457                 spin_unlock_irqrestore(&hub_event_lock, flags);
 458
 459                 return info->nports + 1;
 460                 }
 461
 462         default:
 463                 return -ENOSYS;
 464         }
 465 }
 466
 467 static int usb_hub_reset(struct usb_hub *hub)
 468 {
 469         struct usb_device *dev = hub->dev;
 470         int i;
 471
 472         /* Disconnect any attached devices */
 473         for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
 474                 if (dev->children[i])
 475                         usb_disconnect(&dev->children[i]);
 476         }
 477
 478         /* Attempt to reset the hub */
 479         if (hub->urb)
 480                 usb_unlink_urb(hub->urb);
 481         else
 482                 return -1;
 483
 484         if (usb_reset_device(dev))
 485                 return -1;
 486
 487         hub->urb->dev = dev;
 488         if (usb_submit_urb(hub->urb))
 489                 return -1;
 490
 491         usb_hub_power_on(hub);
 492
 493         return 0;
 494 }
 495
 496 static void usb_hub_disconnect(struct usb_device *dev)
 497 {
 498         struct usb_device *parent = dev->parent;
 499         int i;
 500
 501         /* Find the device pointer to disconnect */
 502         if (parent) {
 503                 for (i = 0; i < parent->maxchild; i++) {
 504                         if (parent->children[i] == dev) {
 505                                 usb_disconnect(&parent->children[i]);
 506                                 return;
 507                         }
 508                 }
 509         }
 510
 511         err("cannot disconnect hub %d", dev->devnum);
 512 }
 513
 514 static int usb_hub_port_status(struct usb_device *hub, int port,
 515                                u16 *status, u16 *change)
 516 {
 517         struct usb_port_status *portsts;
 518         int ret = -ENOMEM;
 519
 520         portsts = kmalloc(sizeof(*portsts), GFP_KERNEL);
 521         if (portsts) {
 522                 ret = usb_get_port_status(hub, port + 1, portsts);
 523                 if (ret < 0)
 524                         err("%s (%d) failed (err = %d)", __FUNCTION__, hub->devnum, ret);
 525                 else {
 526                         *status = le16_to_cpu(portsts->wPortStatus);
 527                         *change = le16_to_cpu(portsts->wPortChange);
 528                         dbg("port %d, portstatus %x, change %x, %s", port + 1,
 529                                 *status, *change, portspeed(*status));
 530                         ret = 0;
 531                 }
 532                 kfree(portsts);
 533         }
 534         return ret;
 535 }
 536
 537 #define HUB_RESET_TRIES         5
 538 #define HUB_PROBE_TRIES         2
 539 #define HUB_SHORT_RESET_TIME    10
 540 #define HUB_LONG_RESET_TIME     200
 541 #define HUB_RESET_TIMEOUT       500
 542
 543 /* return: -1 on error, 0 on success, 1 on disconnect.  */
 544 static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
 545                                 struct usb_device *dev, unsigned int delay)
 546 {
 547         int delay_time, ret;
 548         u16 portstatus;
 549         u16 portchange;
 550
 551         for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT; delay_time += delay) {
 552                 /* wait to give the device a chance to reset */
 553                 wait_ms(delay);
 554
 555                 /* read and decode port status */
 556                 ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
 557                 if (ret < 0) {
 558                         return -1;
 559                 }
 560
 561                 /* Device went away? */
 562                 if (!(portstatus & USB_PORT_STAT_CONNECTION))
 563                         return 1;
 564
 565                 /* bomb out completely if something weird happened */
 566                 if ((portchange & USB_PORT_STAT_C_CONNECTION))
 567                         return -1;
 568
 569                 /* if we`ve finished resetting, then break out of the loop */
 570                 if (!(portstatus & USB_PORT_STAT_RESET) &&
 571                     (portstatus & USB_PORT_STAT_ENABLE)) {
 572                         if (portstatus & USB_PORT_STAT_HIGH_SPEED)
 573                                 dev->speed = USB_SPEED_HIGH;
 574                         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
 575                                 dev->speed = USB_SPEED_LOW;
 576                         else
 577                                 dev->speed = USB_SPEED_FULL;
 578                         return 0;
 579                 }
 580
 581                 /* switch to the long delay after two short delay failures */
 582                 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
 583                         delay = HUB_LONG_RESET_TIME;
 584
 585                 dbg("port %d of hub %d not reset yet, waiting %dms", port + 1,
 586                         hub->devnum, delay);
 587         }
 588
 589         return -1;
 590 }
 591
 592 /* return: -1 on error, 0 on success, 1 on disconnect.  */
 593 static int usb_hub_port_reset(struct usb_device *hub, int port,
 594                                 struct usb_device *dev, unsigned int delay)
 595 {
 596         int i, status;
 597
 598         /* Reset the port */
 599         for (i = 0; i < HUB_RESET_TRIES; i++) {
 600                 usb_set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
 601
 602                 /* return on disconnect or reset */
 603                 status = usb_hub_port_wait_reset(hub, port, dev, delay);
 604                 if (status != -1) {
 605                         usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_RESET);
 606                         return status;
 607                 }
 608
 609                 dbg("port %d of hub %d not enabled, trying reset again...",
 610                         port + 1, hub->devnum);
 611                 delay = HUB_LONG_RESET_TIME;
 612         }
 613
 614         err("Cannot enable port %i of hub %d, disabling port.",
 615                 port + 1, hub->devnum);
 616         err("Maybe the USB cable is bad?");
 617
 618         return -1;
 619 }
 620
 621 void usb_hub_port_disable(struct usb_device *hub, int port)
 622 {
 623         int ret;
 624
 625         ret = usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_ENABLE);
 626         if (ret)
 627                 err("cannot disable port %d of hub %d (err = %d)",
 628                         port + 1, hub->devnum, ret);
 629 }
 630
 631 /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
 632  *
 633  * Between connect detection and reset signaling there must be a delay
 634  * of 100ms at least for debounce and power-settling. The corresponding
 635  * timer shall restart whenever the downstream port detects a disconnect.
 636  *
 637  * Apparently there are some bluetooth and irda-dongles and a number
 638  * of low-speed devices which require longer delays of about 200-400ms.
 639  * Not covered by the spec - but easy to deal with.
 640  *
 641  * This implementation uses 400ms minimum debounce timeout and checks
 642  * every 100ms for transient disconnects to restart the delay.
 643  */
 644
 645 #define HUB_DEBOUNCE_TIMEOUT    400
 646 #define HUB_DEBOUNCE_STEP       100
 647
 648 /* return: -1 on error, 0 on success, 1 on disconnect.  */
 649 static int usb_hub_port_debounce(struct usb_device *hub, int port)
 650 {
 651         int ret;
 652         unsigned delay_time;
 653         u16 portchange, portstatus;
 654
 655         for (delay_time = 0; delay_time < HUB_DEBOUNCE_TIMEOUT; /* empty */ ) {
 656
 657                 /* wait debounce step increment */
 658                 wait_ms(HUB_DEBOUNCE_STEP);
 659
 660                 ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
 661                 if (ret < 0)
 662                         return -1;
 663
 664                 if ((portchange & USB_PORT_STAT_C_CONNECTION)) {
 665                         usb_clear_port_feature(hub, port+1, USB_PORT_FEAT_C_CONNECTION);
 666                         delay_time = 0;
 667                 }
 668                 else
 669                         delay_time += HUB_DEBOUNCE_STEP;
 670         }
 671         return ((portstatus&USB_PORT_STAT_CONNECTION)) ? 0 : 1;
 672 }
 673
 674 static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
 675                                         u16 portstatus, u16 portchange)
 676 {
 677         struct usb_device *hub = hubstate->dev;
 678         struct usb_device *dev;
 679         unsigned int delay = HUB_SHORT_RESET_TIME;
 680         int i;
 681
 682         dbg("port %d, portstatus %x, change %x, %s",
 683                 port + 1, portstatus, portchange, portspeed (portstatus));
 684
 685         /* Clear the connection change status */
 686         usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_CONNECTION);
 687
 688         /* Disconnect any existing devices under this port */
 689         if (hub->children[port])
 690                 usb_disconnect(&hub->children[port]);
 691
 692         /* Return now if nothing is connected */
 693         if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
 694                 if (portstatus & USB_PORT_STAT_ENABLE)
 695                         usb_hub_port_disable(hub, port);
 696
 697                 return;
 698         }
 699
 700         if (usb_hub_port_debounce(hub, port)) {
 701                 err("connect-debounce failed, port %d disabled", port+1);
 702                 usb_hub_port_disable(hub, port);
 703                 return;
 704         }
 705
 706         down(&usb_address0_sem);
 707
 708         for (i = 0; i < HUB_PROBE_TRIES; i++) {
 709                 struct usb_device *pdev;
 710                 int len;
 711
 712                 /* Allocate a new device struct */
 713                 dev = usb_alloc_dev(hub, hub->bus);
 714                 if (!dev) {
 715                         err("couldn't allocate usb_device");
 716                         break;
 717                 }
 718
 719                 /* Reset the device */
 720                 if (usb_hub_port_reset(hub, port, dev, delay)) {
 721                         usb_free_dev(dev);
 722                         break;
 723                 }
 724
 725                 /* Find a new device ID for it */
 726                 usb_connect(dev);
 727
 728                 /* Set up TT records, if needed  */
 729                 if (hub->tt) {
 730                         dev->tt = hub->tt;
 731                         dev->ttport = hub->ttport;
 732                 } else if (dev->speed != USB_SPEED_HIGH
 733                                 && hub->speed == USB_SPEED_HIGH) {
 734                         dev->tt = &hubstate->tt;
 735                         dev->ttport = port + 1;
 736                 }
 737
 738                 /* Save readable and stable topology id, distinguishing
 739                  * devices by location for diagnostics, tools, etc.  The
 740                  * string is a path along hub ports, from the root.  Each
 741                  * device's id will be stable until USB is re-cabled, and
 742                  * hubs are often labeled with these port numbers.
 743                  *
 744                  * Initial size: ".NN" times five hubs + NUL = 16 bytes max
 745                  * (quite rare, since most hubs have 4-6 ports).
 746                  */
 747                 pdev = dev->parent;
 748                 if (pdev->devpath [0] != '0')   /* parent not root? */
 749                         len = snprintf (dev->devpath, sizeof dev->devpath,
 750                                 "%s.%d", pdev->devpath, port + 1);
 751                 /* root == "0", root port 2 == "2", port 3 that hub "2.3" */
 752                 else
 753                         len = snprintf (dev->devpath, sizeof dev->devpath,
 754                                 "%d", port + 1);
 755                 if (len == sizeof dev->devpath)
 756                         warn ("devpath size! usb/%03d/%03d path %s",
 757                                 dev->bus->busnum, dev->devnum, dev->devpath);
 758                 info("new USB device %s-%s, assigned address %d",
 759                         dev->bus->bus_name, dev->devpath, dev->devnum);
 760
 761                 /* Run it through the hoops (find a driver, etc) */
 762                 if (!usb_new_device(dev)) {
 763                         hub->children[port] = dev;
 764                         goto done;
 765                 }
 766
 767                 /* Free the configuration if there was an error */
 768                 usb_free_dev(dev);
 769
 770                 /* Switch to a long reset time */
 771                 delay = HUB_LONG_RESET_TIME;
 772         }
 773
 774         usb_hub_port_disable(hub, port);
 775 done:
 776         up(&usb_address0_sem);
 777 }
 778
 779 static void usb_hub_events(void)
 780 {
 781         unsigned long flags;
 782         struct list_head *tmp;
 783         struct usb_device *dev;
 784         struct usb_hub *hub;
 785         struct usb_hub_status *hubsts;
 786         u16 hubstatus;
 787         u16 hubchange;
 788         u16 portstatus;
 789         u16 portchange;
 790         int i, ret;
 791
 792         /*
 793          *  We restart the list everytime to avoid a deadlock with
 794          * deleting hubs downstream from this one. This should be
 795          * safe since we delete the hub from the event list.
 796          * Not the most efficient, but avoids deadlocks.
 797          */
 798         while (1) {
 799                 spin_lock_irqsave(&hub_event_lock, flags);
 800
 801                 if (list_empty(&hub_event_list))
 802                         break;
 803
 804                 /* Grab the next entry from the beginning of the list */
 805                 tmp = hub_event_list.next;
 806
 807                 hub = list_entry(tmp, struct usb_hub, event_list);
 808                 dev = hub->dev;
 809
 810                 list_del(tmp);
 811                 INIT_LIST_HEAD(tmp);
 812
 813                 down(&hub->khubd_sem); /* never blocks, we were on list */
 814                 spin_unlock_irqrestore(&hub_event_lock, flags);
 815
 816                 if (hub->error) {
 817                         dbg("resetting hub %d for error %d", dev->devnum, hub->error);
 818
 819                         if (usb_hub_reset(hub)) {
 820                                 err("error resetting hub %d - disconnecting", dev->devnum);
 821                                 up(&hub->khubd_sem);
 822                                 usb_hub_disconnect(dev);
 823                                 continue;
 824                         }
 825
 826                         hub->nerrors = 0;
 827                         hub->error = 0;
 828                 }
 829
 830                 for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
 831                         ret = usb_hub_port_status(dev, i, &portstatus, &portchange);
 832                         if (ret < 0) {
 833                                 continue;
 834                         }
 835
 836                         if (portchange & USB_PORT_STAT_C_CONNECTION) {
 837                                 dbg("port %d connection change", i + 1);
 838
 839                                 usb_hub_port_connect_change(hub, i, portstatus, portchange);
 840                         } else if (portchange & USB_PORT_STAT_C_ENABLE) {
 841                                 dbg("port %d enable change, status %x", i + 1, portstatus);
 842                                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
 843
 844                                 /*
 845                                  * EM interference sometimes causes bad shielded USB devices to
 846                                  * be shutdown by the hub, this hack enables them again.
 847                                  * Works at least with mouse driver.
 848                                  */
 849                                 if (!(portstatus & USB_PORT_STAT_ENABLE) &&
 850                                     (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) {
 851                                         err("already running port %i disabled by hub (EMI?), re-enabling...",
 852                                                 i + 1);
 853                                         usb_hub_port_connect_change(hub, i, portstatus, portchange);
 854                                 }
 855                         }
 856
 857                         if (portchange & USB_PORT_STAT_C_SUSPEND) {
 858                                 dbg("port %d suspend change", i + 1);
 859                                 usb_clear_port_feature(dev, i + 1,  USB_PORT_FEAT_C_SUSPEND);
 860                         }
 861
 862                         if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
 863                                 err("port %d over-current change", i + 1);
 864                                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
 865                                 usb_hub_power_on(hub);
 866                         }
 867
 868                         if (portchange & USB_PORT_STAT_C_RESET) {
 869                                 dbg("port %d reset change", i + 1);
 870                                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
 871                         }
 872                 } /* end for i */
 873
 874                 /* deal with hub status changes */
 875                 hubsts = kmalloc(sizeof *hubsts, GFP_KERNEL);
 876                 if (!hubsts) {
 877                         err("couldn't allocate hubsts");
 878                 } else {
 879                         if (usb_get_hub_status(dev, hubsts) < 0)
 880                                 err("get_hub_status failed");
 881                         else {
 882                                 hubstatus = le16_to_cpup(&hubsts->wHubStatus);
 883                                 hubchange = le16_to_cpup(&hubsts->wHubChange);
 884                                 if (hubchange & HUB_CHANGE_LOCAL_POWER) {
 885                                         dbg("hub power change");
 886                                         usb_clear_hub_feature(dev, C_HUB_LOCAL_POWER);
 887                                 }
 888                                 if (hubchange & HUB_CHANGE_OVERCURRENT) {
 889                                         dbg("hub overcurrent change");
 890                                         wait_ms(500);   /* Cool down */
 891                                         usb_clear_hub_feature(dev, C_HUB_OVER_CURRENT);
 892                                         usb_hub_power_on(hub);
 893                                 }
 894                         }
 895                         kfree(hubsts);
 896                 }
 897                 up(&hub->khubd_sem);
 898         } /* end while (1) */
 899
 900         spin_unlock_irqrestore(&hub_event_lock, flags);
 901 }
 902
 903 static int usb_hub_thread(void *__hub)
 904 {
 905         lock_kernel();
 906
 907         /*
 908          * This thread doesn't need any user-level access,
 909          * so get rid of all our resources
 910          */
 911
 912         daemonize();
 913         reparent_to_init();
 914
 915         /* Setup a nice name */
 916         strcpy(current->comm, "khubd");
 917
 918         /* Send me a signal to get me die (for debugging) */
 919         do {
 920                 usb_hub_events();
 921                 wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list));
 922         } while (!signal_pending(current));
 923
 924         dbg("usb_hub_thread exiting");
 925
 926         unlock_kernel();
 927         complete_and_exit(&khubd_exited, 0);
 928 }
 929
 930 static struct usb_device_id hub_id_table [] = {
 931     { match_flags: USB_DEVICE_ID_MATCH_INT_CLASS,
 932       bInterfaceClass: USB_CLASS_HUB},
 933     { }                                         /* Terminating entry */
 934 };
 935
 936 MODULE_DEVICE_TABLE (usb, hub_id_table);
 937
 938 static struct usb_driver hub_driver = {
 939         name:           "hub",
 940         probe:          hub_probe,
 941         ioctl:          hub_ioctl,
 942         disconnect:     hub_disconnect,
 943         id_table:       hub_id_table,
 944 };
 945
 946 /*
 947  * This should be a separate module.
 948  */
 949 int usb_hub_init(void)
 950 {
 951         pid_t pid;
 952
 953         if (usb_register(&hub_driver) < 0) {
 954                 err("Unable to register USB hub driver");
 955                 return -1;
 956         }
 957
 958         pid = kernel_thread(usb_hub_thread, NULL,
 959                 CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
 960         if (pid >= 0) {
 961                 khubd_pid = pid;
 962
 963                 return 0;
 964         }
 965
 966         /* Fall through if kernel_thread failed */
 967         usb_deregister(&hub_driver);
 968         err("failed to start usb_hub_thread");
 969
 970         return -1;
 971 }
 972
 973 void usb_hub_cleanup(void)
 974 {
 975         int ret;
 976
 977         /* Kill the thread */
 978         ret = kill_proc(khubd_pid, SIGTERM, 1);
 979
 980         wait_for_completion(&khubd_exited);
 981
 982         /*
 983          * Hub resources are freed for us by usb_deregister. It calls
 984          * usb_driver_purge on every device which in turn calls that
 985          * devices disconnect function if it is using this driver.
 986          * The hub_disconnect function takes care of releasing the
 987          * individual hub resources. -greg
 988          */
 989         usb_deregister(&hub_driver);
 990 } /* usb_hub_cleanup() */
 991
 992 /*
 993  * WARNING - If a driver calls usb_reset_device, you should simulate a
 994  * disconnect() and probe() for other interfaces you doesn't claim. This
 995  * is left up to the driver writer right now. This insures other drivers
 996  * have a chance to re-setup their interface.
 997  *
 998  * Take a look at proc_resetdevice in devio.c for some sample code to
 999  * do this.
1000  */
1001 int usb_reset_device(struct usb_device *dev)
1002 {
1003         struct usb_device *parent = dev->parent;
1004         struct usb_device_descriptor *descriptor;
1005         int i, ret, port = -1;
1006
1007         if (!parent) {
1008                 err("attempting to reset root hub!");
1009                 return -EINVAL;
1010         }
1011
1012         for (i = 0; i < parent->maxchild; i++)
1013                 if (parent->children[i] == dev) {
1014                         port = i;
1015                         break;
1016                 }
1017
1018         if (port < 0)
1019                 return -ENOENT;
1020
1021         down(&usb_address0_sem);
1022
1023         /* Send a reset to the device */
1024         if (usb_hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
1025                 usb_hub_port_disable(parent, port);
1026                 up(&usb_address0_sem);
1027                 return(-ENODEV);
1028         }
1029
1030         /* Reprogram the Address */
1031         ret = usb_set_address(dev);
1032         if (ret < 0) {
1033                 err("USB device not accepting new address (error=%d)", ret);
1034                 usb_hub_port_disable(parent, port);
1035                 up(&usb_address0_sem);
1036                 return ret;
1037         }
1038
1039         /* Let the SET_ADDRESS settle */
1040         wait_ms(10);
1041
1042         up(&usb_address0_sem);
1043
1044         /*
1045          * Now we fetch the configuration descriptors for the device and
1046          * see if anything has changed. If it has, we dump the current
1047          * parsed descriptors and reparse from scratch. Then we leave
1048          * the device alone for the caller to finish setting up.
1049          *
1050          * If nothing changed, we reprogram the configuration and then
1051          * the alternate settings.
1052          */
1053         descriptor = kmalloc(sizeof *descriptor, GFP_NOIO);
1054         if (!descriptor) {
1055                 return -ENOMEM;
1056         }
1057         ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, descriptor,
1058                         sizeof(*descriptor));
1059         if (ret < 0) {
1060                 kfree(descriptor);
1061                 return ret;
1062         }
1063
1064         le16_to_cpus(&descriptor->bcdUSB);
1065         le16_to_cpus(&descriptor->idVendor);
1066         le16_to_cpus(&descriptor->idProduct);
1067         le16_to_cpus(&descriptor->bcdDevice);
1068
1069         if (memcmp(&dev->descriptor, descriptor, sizeof(*descriptor))) {
1070                 kfree(descriptor);
1071                 usb_destroy_configuration(dev);
1072
1073                 ret = usb_get_device_descriptor(dev);
1074                 if (ret < sizeof(dev->descriptor)) {
1075                         if (ret < 0)
1076                                 err("unable to get device descriptor (error=%d)", ret);
1077                         else
1078                                 err("USB device descriptor short read (expected %Zi, got %i)", sizeof(dev->descriptor), ret);
1079
1080                         clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1081                         dev->devnum = -1;
1082                         return -EIO;
1083                 }
1084
1085                 ret = usb_get_configuration(dev);
1086                 if (ret < 0) {
1087                         err("unable to get configuration (error=%d)", ret);
1088                         usb_destroy_configuration(dev);
1089                         clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1090                         dev->devnum = -1;
1091                         return 1;
1092                 }
1093
1094                 dev->actconfig = dev->config;
1095                 usb_set_maxpacket(dev);
1096
1097                 return 1;
1098         }
1099
1100         kfree(descriptor);
1101
1102         ret = usb_set_configuration(dev, dev->actconfig->bConfigurationValue);
1103         if (ret < 0) {
1104                 err("failed to set active configuration (error=%d)", ret);
1105                 return ret;
1106         }
1107
1108         for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
1109                 struct usb_interface *intf = &dev->actconfig->interface[i];
1110                 struct usb_interface_descriptor *as = &intf->altsetting[intf->act_altsetting];
1111
1112                 ret = usb_set_interface(dev, as->bInterfaceNumber, as->bAlternateSetting);
1113                 if (ret < 0) {
1114                         err("failed to set active alternate setting for interface %d (error=%d)", i, ret);
1115                         return ret;
1116                 }
1117         }
1118
1119         return 0;
1120 }
1121