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