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); 276