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, message); 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_USB_SUSPEND 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); 273