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->regs = hcd->regs;
  39         ohci->next_statechange = jiffies;
  40         return hc_reset (ohci);
  41 }
  42
  43 static int __devinit
  44 ohci_pci_start (struct usb_hcd *hcd)
  45 {
  46         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
  47         int             ret;
  48
  49         ohci->hcca = dma_alloc_coherent (hcd->self.controller,
  50                         sizeof *ohci->hcca, &ohci->hcca_dma, 0);
  51         if (!ohci->hcca)
  52                 return -ENOMEM;
  53
  54         if(hcd->self.controller && hcd->self.controller->bus == &pci_bus_type) {
  55                 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
  56
  57                 /* AMD 756, for most chips (early revs), corrupts register
  58                  * values on read ... so enable the vendor workaround.
  59                  */
  60                 if (pdev->vendor == PCI_VENDOR_ID_AMD
  61                                 && pdev->device == 0x740c) {
  62                         ohci->flags = OHCI_QUIRK_AMD756;
  63                         ohci_info (ohci, "AMD756 erratum 4 workaround\n");
  64                 }
  65
  66                 /* FIXME for some of the early AMD 760 southbridges, OHCI
  67                  * won't work at all.  blacklist them.
  68                  */
  69
  70                 /* Apple's OHCI driver has a lot of bizarre workarounds
  71                  * for this chip.  Evidently control and bulk lists
  72                  * can get confused.  (B&W G3 models, and ...)
  73                  */
  74                 else if (pdev->vendor == PCI_VENDOR_ID_OPTI
  75                                 && pdev->device == 0xc861) {
  76                         ohci_info (ohci,
  77                                 "WARNING: OPTi workarounds unavailable\n");
  78                 }
  79
  80                 /* Check for NSC87560. We have to look at the bridge (fn1) to
  81                  * identify the USB (fn2). This quirk might apply to more or
  82                  * even all NSC stuff.
  83                  */
  84                 else if (pdev->vendor == PCI_VENDOR_ID_NS) {
  85                         struct pci_dev  *b;
  86
  87                         b  = pci_find_slot (pdev->bus->number,
  88                                         PCI_DEVFN (PCI_SLOT (pdev->devfn), 1));
  89                         if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO
  90                                         && b->vendor == PCI_VENDOR_ID_NS) {
  91                                 ohci->flags |= OHCI_QUIRK_SUPERIO;
  92                                 ohci_info (ohci, "Using NSC SuperIO setup\n");
  93                         }
  94                 }
  95
  96         }
  97
  98         memset (ohci->hcca, 0, sizeof (struct ohci_hcca));
  99         if ((ret = ohci_mem_init (ohci)) < 0) {
 100                 ohci_stop (hcd);
 101                 return ret;
 102         }
 103
 104         if (hc_start (ohci) < 0) {
 105                 ohci_err (ohci, "can't start\n");
 106                 ohci_stop (hcd);
 107                 return -EBUSY;
 108         }
 109         create_debug_files (ohci);
 110
 111 #ifdef  DEBUG
 112         ohci_dump (ohci, 1);
 113 #endif
 114         return 0;
 115 }
 116
 117 #ifdef  CONFIG_PM
 118
 119 static int ohci_pci_suspend (struct usb_hcd *hcd, u32 state)
 120 {
 121         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 122
 123         /* suspend root hub, hoping it keeps power during suspend */
 124         while (time_before (jiffies, ohci->next_statechange))
 125                 msleep (100);
 126
 127 #ifdef  CONFIG_USB_SUSPEND
 128         (void) usb_suspend_device (hcd->self.root_hub);
 129 #else
 130         down (&hcd->self.root_hub->serialize);
 131         (void) ohci_hub_suspend (hcd);
 132         up (&hcd->self.root_hub->serialize);
 133 #endif
 134
 135         /* let things settle down a bit */
 136         msleep (100);
 137
 138 #ifdef CONFIG_PMAC_PBOOK
 139         if (_machine == _MACH_Pmac)
 140                 disable_irq ((to_pci_dev(hcd->self.controller))->irq);
 141
 142         {
 143                 struct device_node      *of_node;
 144
 145                 /* Disable USB PAD & cell clock */
 146                 of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
 147                 if (of_node)
 148                         pmac_call_feature(PMAC_FTR_USB_ENABLE, of_node, 0, 0);
 149         }
 150 #endif
 151         return 0;
 152 }
 153
 154
 155 static int ohci_pci_resume (struct usb_hcd *hcd)
 156 {
 157         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 158         int                     retval = 0;
 159
 160 #ifdef CONFIG_PMAC_PBOOK
 161         {
 162                 struct device_node *of_node;
 163
 164                 /* Re-enable USB PAD & cell clock */
 165                 of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
 166                 if (of_node)
 167                         pmac_call_feature (PMAC_FTR_USB_ENABLE, of_node, 0, 1);
 168         }
 169 #endif
 170
 171         /* resume root hub */
 172         while (time_before (jiffies, ohci->next_statechange))
 173                 msleep (100);
 174 #ifdef  CONFIG_USB_SUSPEND
 175         /* get extra cleanup even if remote wakeup isn't in use */
 176         retval = usb_resume_device (hcd->self.root_hub);
 177 #else
 178         down (&hcd->self.root_hub->serialize);
 179         retval = ohci_hub_resume (hcd);
 180         up (&hcd->self.root_hub->serialize);
 181 #endif
 182
 183         if (retval == 0) {
 184                 hcd->self.controller->power.power_state = 0;
 185 #ifdef CONFIG_PMAC_PBOOK
 186                 if (_machine == _MACH_Pmac)
 187                         enable_irq (to_pci_dev(hcd->self.controller)->irq);
 188 #endif
 189         }
 190         return retval;
 191 }
 192
 193 #endif  /* CONFIG_PM */
 194
 195
 196 /*-------------------------------------------------------------------------*/
 197
 198 static const struct hc_driver ohci_pci_hc_driver = {
 199         .description =          hcd_name,
 200
 201         /*
 202          * generic hardware linkage
 203          */
 204         .irq =                  ohci_irq,
 205         .flags =                HCD_MEMORY | HCD_USB11,
 206
 207         /*
 208          * basic lifecycle operations
 209          */
 210         .reset =                ohci_pci_reset,
 211         .start =                ohci_pci_start,
 212 #ifdef  CONFIG_PM
 213         .suspend =              ohci_pci_suspend,
 214         .resume =               ohci_pci_resume,
 215 #endif
 216         .stop =                 ohci_stop,
 217
 218         /*
 219          * memory lifecycle (except per-request)
 220          */
 221         .hcd_alloc =            ohci_hcd_alloc,
 222         .hcd_free =             ohci_hcd_free,
 223
 224         /*
 225          * managing i/o requests and associated device resources
 226          */
 227         .urb_enqueue =          ohci_urb_enqueue,
 228         .urb_dequeue =          ohci_urb_dequeue,
 229         .endpoint_disable =     ohci_endpoint_disable,
 230
 231         /*
 232          * scheduling support
 233          */
 234         .get_frame_number =     ohci_get_frame,
 235
 236         /*
 237          * root hub support
 238          */
 239         .hub_status_data =      ohci_hub_status_data,
 240         .hub_control =          ohci_hub_control,
 241 };
 242
 243 /*-------------------------------------------------------------------------*/
 244
 245
 246 static const struct pci_device_id pci_ids [] = { {
 247         /* handle any USB OHCI controller */
 248         PCI_DEVICE_CLASS((PCI_CLASS_SERIAL_USB << 8) | 0x10, ~0),
 249         .driver_data =  (unsigned long) &ohci_pci_hc_driver,
 250         }, { /* end: all zeroes */ }
 251 };
 252 MODULE_DEVICE_TABLE (pci, pci_ids);
 253
 254 /* pci driver glue; this is a "new style" PCI driver module */
 255 static struct pci_driver ohci_pci_driver = {
 256         .name =         (char *) hcd_name,
 257         .id_table =     pci_ids,
 258
 259         .probe =        usb_hcd_pci_probe,
 260         .remove =       usb_hcd_pci_remove,
 261
 262 #ifdef  CONFIG_PM
 263         .suspend =      usb_hcd_pci_suspend,
 264         .resume =       usb_hcd_pci_resume,
 265 #endif
 266 };
 267
 268
 269 static int __init ohci_hcd_pci_init (void)
 270 {
 271         printk (KERN_DEBUG "%s: " DRIVER_INFO " (PCI)\n", hcd_name);
 272         if (usb_disabled())
 273                 return -ENODEV;
 274
 275         printk (KERN_DEBUG "%s: block sizes: ed %Zd td %Zd\n", hcd_name,
 276                 sizeof (struct ed), sizeof (struct td));
 277         return pci_module_init (&ohci_pci_driver);
 278 }
 279 module_init (ohci_hcd_pci_init);
 280
 281 /*-------------------------------------------------------------------------*/
 282
 283 static void __exit ohci_hcd_pci_cleanup (void)
 284 {
 285         pci_unregister_driver (&ohci_pci_driver);
 286 }
 287 module_exit (ohci_hcd_pci_cleanup);