drivers/usb/host/ohci-pci.c

   1 /*
   2  * OHCI HCD (Host Controller Driver) for USB.
   3  *
   4  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
   5  * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
   6  *
   7  * [ Initialisation is based on Linus'  ]
   8  * [ uhci code and gregs ohci fragments ]
   9  * [ (C) Copyright 1999 Linus Torvalds  ]
  10  * [ (C) Copyright 1999 Gregory P. Smith]
  11  *
  12  * PCI Bus Glue
  13  *
  14  * This file is licenced under the GPL.
  15  */
  16
  17 #ifdef CONFIG_PMAC_PBOOK
  18 #include <asm/machdep.h>
  19 #include <asm/pmac_feature.h>
  20 #include <asm/pci-bridge.h>
  21 #include <asm/prom.h>
  22 #ifndef CONFIG_PM
  23 #       define CONFIG_PM
  24 #endif
  25 #endif
  26
  27 #ifndef CONFIG_PCI
  28 #error "This file is PCI bus glue.  CONFIG_PCI must be defined."
  29 #endif
  30
  31 /*-------------------------------------------------------------------------*/
  32
  33 static int
  34 ohci_pci_reset (struct usb_hcd *hcd)
  35 {
  36         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  37
  38         ohci_hcd_init (ohci);
  39         return ohci_init (ohci);
  40 }
  41
  42 static int __devinit
  43 ohci_pci_start (struct usb_hcd *hcd)
  44 {
  45         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  46         int             ret;
  47
  48         if(hcd->self.controller && hcd->self.controller->bus == &pci_bus_type) {
  49                 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
  50
  51                 /* AMD 756, for most chips (early revs), corrupts register
  52                  * values on read ... so enable the vendor workaround.
  53                  */
  54                 if (pdev->vendor == PCI_VENDOR_ID_AMD
  55                                 && pdev->device == 0x740c) {
  56                         ohci->flags = OHCI_QUIRK_AMD756;
  57                         ohci_dbg (ohci, "AMD756 erratum 4 workaround\n");
  58                         // also somewhat erratum 10 (suspend/resume issues)
  59                 }
  60
  61                 /* FIXME for some of the early AMD 760 southbridges, OHCI
  62                  * won't work at all.  blacklist them.
  63                  */
  64
  65                 /* Apple's OHCI driver has a lot of bizarre workarounds
  66                  * for this chip.  Evidently control and bulk lists
  67                  * can get confused.  (B&W G3 models, and ...)
  68                  */
  69                 else if (pdev->vendor == PCI_VENDOR_ID_OPTI
  70                                 && pdev->device == 0xc861) {
  71                         ohci_dbg (ohci,
  72                                 "WARNING: OPTi workarounds unavailable\n");
  73                 }
  74
  75                 /* Check for NSC87560. We have to look at the bridge (fn1) to
  76                  * identify the USB (fn2). This quirk might apply to more or
  77                  * even all NSC stuff.
  78                  */
  79                 else if (pdev->vendor == PCI_VENDOR_ID_NS) {
  80                         struct pci_dev  *b;
  81
  82                         b  = pci_find_slot (pdev->bus->number,
  83                                         PCI_DEVFN (PCI_SLOT (pdev->devfn), 1));
  84                         if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO
  85                                         && b->vendor == PCI_VENDOR_ID_NS) {
  86                                 ohci->flags |= OHCI_QUIRK_SUPERIO;
  87                                 ohci_dbg (ohci, "Using NSC SuperIO setup\n");
  88                         }
  89                 }
  90
  91                 /* Check for Compaq's ZFMicro chipset, which needs short
  92                  * delays before control or bulk queues get re-activated
  93                  * in finish_unlinks()
  94                  */
  95                 else if (pdev->vendor == PCI_VENDOR_ID_COMPAQ
  96                                 && pdev->device  == 0xa0f8) {
  97                         ohci->flags |= OHCI_QUIRK_ZFMICRO;
  98                         ohci_dbg (ohci,
  99                                 "enabled Compaq ZFMicro chipset quirk\n");
 100                 }
 101         }
 102
 103         /* NOTE: there may have already been a first reset, to
 104          * keep bios/smm irqs from making trouble
 105          */
 106         if ((ret = ohci_run (ohci)) < 0) {
 107                 ohci_err (ohci, "can't start\n");
 108                 ohci_stop (hcd);
 109                 return ret;
 110         }
 111         return 0;
 112 }
 113
 114 #ifdef  CONFIG_PM
 115
 116 static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
 117 {
 118         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 119
 120         /* suspend root hub, hoping it keeps power during suspend */
 121         if (time_before (jiffies, ohci->next_statechange))
 122                 msleep (100);
 123
 124 #ifdef  CONFIG_USB_SUSPEND
 125         (void) usb_suspend_device (hcd->self.root_hub, message);
 126 #else
 127         usb_lock_device (hcd->self.root_hub);
 128         (void) ohci_hub_suspend (hcd);
 129         usb_unlock_device (hcd->self.root_hub);
 130 #endif
 131
 132         /* let things settle down a bit */
 133         msleep (100);
 134
 135 #ifdef CONFIG_PMAC_PBOOK
 136         if (_machine == _MACH_Pmac) {
 137                 struct device_node      *of_node;
 138
 139                 /* Disable USB PAD & cell clock */
 140                 of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
 141                 if (of_node)
 142                         pmac_call_feature(PMAC_FTR_USB_ENABLE, of_node, 0, 0);
 143         }
 144 #endif /* CONFIG_PMAC_PBOOK */
 145         return 0;
 146 }
 147
 148
 149 static int ohci_pci_resume (struct usb_hcd *hcd)
 150 {
 151         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 152         int                     retval = 0;
 153
 154 #ifdef CONFIG_PMAC_PBOOK
 155         if (_machine == _MACH_Pmac) {
 156                 struct device_node *of_node;
 157
 158                 /* Re-enable USB PAD & cell clock */
 159                 of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
 160                 if (of_node)
 161                         pmac_call_feature (PMAC_FTR_USB_ENABLE, of_node, 0, 1);
 162         }
 163 #endif /* CONFIG_PMAC_PBOOK */
 164
 165         /* resume root hub */
 166         if (time_before (jiffies, ohci->next_statechange))
 167                 msleep (100);
 168 #ifdef  CONFIG_USB_SUSPEND
 169         /* get extra cleanup even if remote wakeup isn't in use */
 170         retval = usb_resume_device (hcd->self.root_hub);
 171 #else
 172         usb_lock_device (hcd->self.root_hub);
 173         retval = ohci_hub_resume (hcd);
 174         usb_unlock_device (hcd->self.root_hub);
 175 #endif
 176
 177         return retval;
 178 }
 179
 180 #endif  /* CONFIG_PM */
 181
 182
 183 /*-------------------------------------------------------------------------*/
 184
 185 static const struct hc_driver ohci_pci_hc_driver = {
 186         .description =          hcd_name,
 187         .product_desc =         "OHCI Host Controller",
 188         .hcd_priv_size =        sizeof(struct ohci_hcd),
 189
 190         /*
 191          * generic hardware linkage
 192          */
 193         .irq =                  ohci_irq,
 194         .flags =                HCD_MEMORY | HCD_USB11,
 195
 196         /*
 197          * basic lifecycle operations
 198          */
 199         .reset =                ohci_pci_reset,
 200         .start =                ohci_pci_start,
 201 #ifdef  CONFIG_PM
 202         .suspend =              ohci_pci_suspend,
 203         .resume =               ohci_pci_resume,
 204 #endif
 205         .stop =                 ohci_stop,
 206
 207         /*
 208          * managing i/o requests and associated device resources
 209          */
 210         .urb_enqueue =          ohci_urb_enqueue,
 211         .urb_dequeue =          ohci_urb_dequeue,
 212         .endpoint_disable =     ohci_endpoint_disable,
 213
 214         /*
 215          * scheduling support
 216          */
 217         .get_frame_number =     ohci_get_frame,
 218
 219         /*
 220          * root hub support
 221          */
 222         .hub_status_data =      ohci_hub_status_data,
 223         .hub_control =          ohci_hub_control,
 224 #ifdef  CONFIG_USB_SUSPEND
 225         .hub_suspend =          ohci_hub_suspend,
 226         .hub_resume =           ohci_hub_resume,
 227 #endif
 228         .start_port_reset =     ohci_start_port_reset,
 229 };
 230
 231 /*-------------------------------------------------------------------------*/
 232
 233
 234 static const struct pci_device_id pci_ids [] = { {
 235         /* handle any USB OHCI controller */
 236         PCI_DEVICE_CLASS((PCI_CLASS_SERIAL_USB << 8) | 0x10, ~0),
 237         .driver_data =  (unsigned long) &ohci_pci_hc_driver,
 238         }, { /* end: all zeroes */ }
 239 };
 240 MODULE_DEVICE_TABLE (pci, pci_ids);
 241
 242 /* pci driver glue; this is a "new style" PCI driver module */
 243 static struct pci_driver ohci_pci_driver = {
 244         .name =         (char *) hcd_name,
 245         .id_table =     pci_ids,
 246
 247         .probe =        usb_hcd_pci_probe,
 248         .remove =       usb_hcd_pci_remove,
 249
 250 #ifdef  CONFIG_PM
 251         .suspend =      usb_hcd_pci_suspend,
 252         .resume =       usb_hcd_pci_resume,
 253 #endif
 254 };
 255
 256
 257 static int __init ohci_hcd_pci_init (void)
 258 {
 259         printk (KERN_DEBUG "%s: " DRIVER_INFO " (PCI)\n", hcd_name);
 260         if (usb_disabled())
 261                 return -ENODEV;
 262
 263         pr_debug ("%s: block sizes: ed %Zd td %Zd\n", hcd_name,
 264                 sizeof (struct ed), sizeof (struct td));
 265         return pci_register_driver (&ohci_pci_driver);
 266 }
 267 module_init (ohci_hcd_pci_init);
 268
 269 /*-------------------------------------------------------------------------*/
 270
 271 static void __exit ohci_hcd_pci_cleanup (void)
 272 {
 273         pci_unregister_driver (&ohci_pci_driver);
 274 }
 275 module_exit (ohci_hcd_pci_cleanup);