drivers/usb/hub.c

   1 /*
   2  * USB hub driver.
   3  *
   4  * This is horrible, it knows about the UHCI driver
   5  * internals, but it's just meant as a rough example,
   6  * let's do the virtualization later when this works.
   7  *
   8  * (C) Copyright 1999 Linus Torvalds
   9  * (C) Copyright 1999 Johannes Erdfelt
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/sched.h>
  14 #include <linux/list.h>
  15 #include <linux/malloc.h>
  16 #include <linux/smp_lock.h>
  17
  18 #include <asm/spinlock.h>
  19
  20 #include "usb.h"
  21 #include "uhci.h"
  22 #include "hub.h"
  23
  24 extern struct usb_operations uhci_device_operations;
  25
  26 /* Wakes up khubd */
  27 static DECLARE_WAIT_QUEUE_HEAD(usb_hub_wait);
  28 static spinlock_t hub_event_lock = SPIN_LOCK_UNLOCKED;
  29
  30 /* List of hubs needing servicing */
  31 static struct list_head hub_event_list;
  32
  33 /* PID of khubd */
  34 static int khubd_pid = 0;
  35
  36 /*
  37  * A irq handler returns non-zero to indicate to
  38  * the low-level driver that it wants to be re-activated,
  39  * or zero to say "I'm done".
  40  */
  41 static int hub_irq(int status, void *__buffer, void *dev_id)
  42 {
  43         struct usb_hub *hub = dev_id;
  44         unsigned long flags;
  45
  46         if (waitqueue_active(&usb_hub_wait)) {
  47                 /* Add the hub to the event queue */
  48                 spin_lock_irqsave(&hub_event_lock, flags);
  49                 if (hub->event_list.next == &hub->event_list) {
  50                         list_add(&hub->event_list, &hub_event_list);
  51                         /* Wake up khubd */
  52                         wake_up(&usb_hub_wait);
  53                 }
  54                 spin_unlock_irqrestore(&hub_event_lock, flags);
  55         }
  56
  57         return 1;
  58 }
  59
  60 static void usb_hub_configure(struct usb_hub *hub)
  61 {
  62         struct usb_device *dev = hub->dev;
  63         unsigned char hubdescriptor[8], buf[4];
  64         int charac, i;
  65
  66         usb_set_configuration(dev, dev->config[0].bConfigurationValue);
  67
  68         if (usb_get_hub_descriptor(dev, hubdescriptor, 8))
  69                 return;
  70
  71         hub->nports = dev->maxchild = hubdescriptor[2];
  72         printk("hub: %d-port%s detected\n", hub->nports,
  73                 (hub->nports == 1) ? "" : "s");
  74
  75         charac = (hubdescriptor[4] << 8) + hubdescriptor[3];
  76         switch (charac & HUB_CHAR_LPSM) {
  77                 case 0x00:
  78                         printk("hub: ganged power switching\n");
  79                         break;
  80                 case 0x01:
  81                         printk("hub: individual port power switching\n");
  82                         break;
  83                 case 0x02:
  84                 case 0x03:
  85                         printk("hub: unknown reserved power switching mode\n");
  86                         break;
  87         }
  88
  89         if (charac & HUB_CHAR_COMPOUND)
  90                 printk("hub: part of a compound device\n");
  91         else
  92                 printk("hub: standalone hub\n");
  93
  94         switch (charac & HUB_CHAR_OCPM) {
  95                 case 0x00:
  96                         printk("hub: global over current protection\n");
  97                         break;
  98                 case 0x08:
  99                         printk("hub: individual port over current protection\n");
 100                         break;
 101                 case 0x10:
 102                 case 0x18:
 103                         printk("hub: no over current protection\n");
 104                         break;
 105         }
 106
 107         printk("hub: power on to power good time: %dms\n",
 108                 hubdescriptor[5] * 2);
 109
 110         printk("hub: hub controller current requirement: %dmA\n",
 111                 hubdescriptor[6]);
 112
 113         for (i = 0; i < dev->maxchild; i++)
 114                 printk("hub:  port %d is%s removable\n", i + 1,
 115                         hubdescriptor[7 + ((i + 1)/8)] & (1 << ((i + 1) % 8))
 116                         ? " not" : "");
 117
 118         if (usb_get_hub_status(dev, buf))
 119                 return;
 120
 121         printk("hub: local power source is %s\n",
 122                 (buf[0] & 1) ? "lost (inactive)" : "good");
 123
 124         printk("hub: %sover current condition exists\n",
 125                 (buf[0] & 2) ? "" : "no ");
 126
 127 #if 0
 128         for (i = 0; i < hub->nports; i++) {
 129                 int portstat, portchange;
 130                 unsigned char portstatus[4];
 131
 132                 if (usb_get_port_status(dev, i + 1, portstatus))
 133                         return;
 134                 portstat = (portstatus[1] << 8) + portstatus[0];
 135                 portchange = (portstatus[3] << 8) + portstatus[2];
 136
 137                 printk("hub: port %d status\n", i + 1);
 138                 printk("hub:  %sdevice present\n", (portstat & 1) ? "" : "no ");
 139                 printk("hub:  %s\n", (portstat & 2) ? "enabled" : "disabled");
 140                 printk("hub:  %ssuspended\n", (portstat & 4) ? "" : "not ");
 141                 printk("hub:  %sover current\n", (portstat & 8) ? "" : "not ");
 142                 printk("hub:  has %spower\n", (portstat & 0x100) ? "" : "no ");
 143                 printk("hub:  %s speed\n", (portstat & 0x200) ? "low" : "full");
 144         }
 145 #endif
 146
 147         /* Enable power to the ports */
 148         printk("enabling power on all ports\n");
 149         for (i = 0; i < hub->nports; i++)
 150                 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
 151 }
 152
 153 static int hub_probe(struct usb_device *dev)
 154 {
 155         struct usb_interface_descriptor *interface;
 156         struct usb_endpoint_descriptor *endpoint;
 157         struct usb_hub *hub;
 158
 159         /* We don't handle multi-config hubs */
 160         if (dev->descriptor.bNumConfigurations != 1)
 161                 return -1;
 162
 163         /* We don't handle multi-interface hubs */
 164         if (dev->config[0].bNumInterfaces != 1)
 165                 return -1;
 166
 167         interface = &dev->config[0].interface[0];
 168
 169         /* Is it a hub? */
 170         if (interface->bInterfaceClass != 9)
 171                 return -1;
 172         if ((interface->bInterfaceSubClass != 0) &&
 173             (interface->bInterfaceSubClass != 1))
 174                 return -1;
 175
 176         /* Multiple endpoints? What kind of mutant ninja-hub is this? */
 177         if (interface->bNumEndpoints != 1)
 178                 return -1;
 179
 180         endpoint = &interface->endpoint[0];
 181
 182         /* Output endpoint? Curiousier and curiousier.. */
 183         if (!(endpoint->bEndpointAddress & 0x80))
 184                 return -1;
 185
 186         /* If it's not an interrupt endpoint, we'd better punt! */
 187         if ((endpoint->bmAttributes & 3) != 3)
 188                 return -1;
 189
 190         /* We found a hub */
 191         printk("USB hub found\n");
 192
 193         if ((hub = kmalloc(sizeof(*hub), GFP_KERNEL)) == NULL) {
 194                 printk("couldn't kmalloc hub struct\n");
 195                 return -1;
 196         }
 197
 198         memset(hub, 0, sizeof(*hub));
 199
 200         dev->private = hub;
 201
 202         INIT_LIST_HEAD(&hub->event_list);
 203         hub->dev = dev;
 204
 205         usb_hub_configure(hub);
 206
 207         usb_request_irq(dev, usb_rcvctrlpipe(dev, endpoint->bEndpointAddress), hub_irq, endpoint->bInterval, hub);
 208
 209         /* Wake up khubd */
 210         wake_up(&usb_hub_wait);
 211
 212         return 0;
 213 }
 214
 215 static void hub_disconnect(struct usb_device *dev)
 216 {
 217         struct usb_hub *hub = dev->private;
 218         unsigned long flags;
 219
 220         spin_lock_irqsave(&hub_event_lock, flags);
 221
 222         /* Delete it and then reset it */
 223         list_del(&hub->event_list);
 224         INIT_LIST_HEAD(&hub->event_list);
 225
 226         spin_unlock_irqrestore(&hub_event_lock, flags);
 227
 228         /* Free the memory */
 229         kfree(hub);
 230 }
 231
 232 static void usb_hub_port_connect_change(struct usb_device *hub, int port)
 233 {
 234         struct usb_device *usb;
 235         unsigned char buf[4];
 236         unsigned short portstatus, portchange;
 237
 238         usb_disconnect(&hub->children[port]);
 239
 240         usb_set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
 241
 242         wait_ms(50);    /* FIXME: This is from the *BSD stack, thanks! :) */
 243
 244         if (usb_get_port_status(hub, port + 1, buf)) {
 245                 printk("get_port_status failed\n");
 246                 return;
 247         }
 248
 249         portstatus = *((unsigned short *)buf + 0);
 250         portchange = *((unsigned short *)buf + 1);
 251
 252         if ((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
 253                 (!(portstatus & USB_PORT_STAT_ENABLE))) {
 254                 /* We're done now, we already disconnected the device */
 255                 /* printk("not connected/enabled\n"); */
 256                 return;
 257         }
 258
 259         usb = hub->bus->op->allocate(hub);
 260         if (!usb) {
 261                 printk("couldn't allocate usb_device\n");
 262                 return;
 263         }
 264
 265         usb_connect(usb);
 266
 267         usb->slow = (portstatus & USB_PORT_STAT_LOW_SPEED) ? 1 : 0;
 268
 269         hub->children[port] = usb;
 270
 271         usb_new_device(usb);
 272 }
 273
 274 static void usb_hub_events(void)
 275 {
 276         unsigned long flags;
 277         unsigned char buf[4];
 278         unsigned short portstatus, portchange;
 279         int i;
 280         struct list_head *next, *tmp, *head = &hub_event_list;
 281         struct usb_device *dev;
 282         struct usb_hub *hub;
 283
 284         spin_lock_irqsave(&hub_event_lock, flags);
 285
 286         tmp = head->next;
 287         while (tmp != head) {
 288                 hub = list_entry(tmp, struct usb_hub, event_list);
 289                 dev = hub->dev;
 290
 291                 next = tmp->next;
 292
 293                 list_del(tmp);
 294                 INIT_LIST_HEAD(tmp);
 295
 296                 for (i = 0; i < hub->nports; i++) {
 297                         if (usb_get_port_status(dev, i + 1, buf)) {
 298                                 printk("get_port_status failed\n");
 299                                 continue;
 300                         }
 301
 302                         portstatus = *((unsigned short *)buf + 0);
 303                         portchange = *((unsigned short *)buf + 1);
 304
 305                         if (portchange & USB_PORT_STAT_C_CONNECTION) {
 306                                 printk("hub: port %d connection change\n", i + 1);
 307
 308                                 usb_clear_port_feature(dev, i + 1,
 309                                         USB_PORT_FEAT_C_CONNECTION);
 310
 311                                 usb_hub_port_connect_change(dev, i);
 312                         }
 313
 314                         if (portchange & USB_PORT_STAT_C_ENABLE) {
 315                                 printk("hub: port %d enable change\n", i + 1);
 316                                 usb_clear_port_feature(dev, i + 1,
 317                                         USB_PORT_FEAT_C_ENABLE);
 318                         }
 319
 320                         if (portchange & USB_PORT_STAT_C_SUSPEND)
 321                                 printk("hub: port %d suspend change\n", i + 1);
 322
 323                         if (portchange & USB_PORT_STAT_C_OVERCURRENT)
 324                                 printk("hub: port %d over-current change\n", i + 1);
 325
 326                         if (portchange & USB_PORT_STAT_C_RESET) {
 327                                 printk("hub: port %d reset change\n", i + 1);
 328                                 usb_clear_port_feature(dev, i + 1,
 329                                         USB_PORT_FEAT_C_RESET);
 330                         }
 331
 332 #if 0
 333                         if (!portchange)
 334                                 continue;
 335
 336                         if (usb_get_port_status(dev, i + 1, buf))
 337                                 return;
 338
 339                         portstatus = (buf[1] << 8) + buf[0];
 340                         portchange = (buf[3] << 8) + buf[2];
 341
 342                         printk("hub: port %d status\n", i + 1);
 343                         printk("hub:  %sdevice present\n", (portstatus & 1) ? "" : "no ");
 344                         printk("hub:  %s\n", (portstatus & 2) ? "enabled" : "disabled");
 345                         printk("hub:  %ssuspended\n", (portstatus & 4) ? "" : "not ");
 346                         printk("hub:  %sover current\n", (portstatus & 8) ? "" : "not ");
 347                         printk("hub:  has %spower\n", (portstatus & 0x100) ? "" : "no ");
 348                         printk("hub:  %s speed\n", (portstatus & 0x200) ? "low" : "full");
 349 #endif
 350                 }
 351                 tmp = next;
 352 #if 0
 353                 wait_ms(1000);
 354 #endif
 355         }
 356
 357         spin_unlock_irqrestore(&hub_event_lock, flags);
 358 }
 359
 360 static int usb_hub_thread(void *__hub)
 361 {
 362         lock_kernel();
 363
 364         /*
 365          * This thread doesn't need any user-level access,
 366          * so get rid of all our resources
 367          */
 368         printk("usb_hub_thread at %p\n", &usb_hub_thread);
 369         exit_mm(current);
 370         exit_files(current);
 371         exit_fs(current);
 372
 373         /* Setup a nice name */
 374         strcpy(current->comm, "khubd");
 375
 376         /* Send me a signal to get me die (for debugging) */
 377         do {
 378                 interruptible_sleep_on(&usb_hub_wait);
 379                 usb_hub_events();
 380         } while (!signal_pending(current));
 381
 382         printk("usb_hub_thread exiting\n");
 383
 384         return 0;
 385 }
 386
 387 static struct usb_driver hub_driver = {
 388         "hub",
 389         hub_probe,
 390         hub_disconnect,
 391         { NULL, NULL }
 392 };
 393
 394 /*
 395  * This should be a separate module.
 396  */
 397 int hub_init(void)
 398 {
 399         int pid;
 400
 401         INIT_LIST_HEAD(&hub_event_list);
 402
 403         usb_register(&hub_driver);
 404         pid = kernel_thread(usb_hub_thread, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
 405         if (pid >= 0) {
 406                 khubd_pid = pid;
 407                 return 0;
 408         }
 409
 410         /* Fall through if kernel_thread failed */
 411         usb_deregister(&hub_driver);
 412
 413         return 0;
 414 }
 415
 416 void hub_cleanup(void)
 417 {
 418         if (khubd_pid >= 0)
 419                 kill_proc(khubd_pid, SIGINT, 1);
 420
 421         usb_deregister(&hub_driver);
 422 }