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