1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#ifndef CONFIG_PCI
18#error "This file is PCI bus glue. CONFIG_PCI must be defined."
19#endif
20
21#include <linux/pci.h>
22#include <linux/io.h>
23
24
25
26
27
28#define AB_REG_BAR 0xf0
29#define AB_INDX(addr) ((addr) + 0x00)
30#define AB_DATA(addr) ((addr) + 0x04)
31#define AX_INDXC 0X30
32#define AX_DATAC 0x34
33
34#define NB_PCIE_INDX_ADDR 0xe0
35#define NB_PCIE_INDX_DATA 0xe4
36#define PCIE_P_CNTL 0x10040
37#define BIF_NB 0x10002
38
39static struct pci_dev *amd_smbus_dev;
40static struct pci_dev *amd_hb_dev;
41static int amd_ohci_iso_count;
42
43
44
45static int broken_suspend(struct usb_hcd *hcd)
46{
47 device_init_wakeup(&hcd->self.root_hub->dev, 0);
48 return 0;
49}
50
51
52
53
54static int ohci_quirk_amd756(struct usb_hcd *hcd)
55{
56 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
57
58 ohci->flags = OHCI_QUIRK_AMD756;
59 ohci_dbg (ohci, "AMD756 erratum 4 workaround\n");
60
61
62 return broken_suspend(hcd);
63}
64
65
66
67
68
69static int ohci_quirk_opti(struct usb_hcd *hcd)
70{
71 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
72
73 ohci_dbg (ohci, "WARNING: OPTi workarounds unavailable\n");
74
75 return 0;
76}
77
78
79
80
81
82static int ohci_quirk_ns(struct usb_hcd *hcd)
83{
84 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
85 struct pci_dev *b;
86
87 b = pci_get_slot (pdev->bus, PCI_DEVFN (PCI_SLOT (pdev->devfn), 1));
88 if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO
89 && b->vendor == PCI_VENDOR_ID_NS) {
90 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
91
92 ohci->flags |= OHCI_QUIRK_SUPERIO;
93 ohci_dbg (ohci, "Using NSC SuperIO setup\n");
94 }
95 pci_dev_put(b);
96
97 return 0;
98}
99
100
101
102
103
104static int ohci_quirk_zfmicro(struct usb_hcd *hcd)
105{
106 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
107
108 ohci->flags |= OHCI_QUIRK_ZFMICRO;
109 ohci_dbg(ohci, "enabled Compaq ZFMicro chipset quirks\n");
110
111 return 0;
112}
113
114
115
116
117static int ohci_quirk_toshiba_scc(struct usb_hcd *hcd)
118{
119 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
120
121
122
123
124
125
126#ifdef CONFIG_USB_OHCI_BIG_ENDIAN_MMIO
127 ohci->flags |= OHCI_QUIRK_BE_MMIO;
128 ohci_dbg (ohci, "enabled big endian Toshiba quirk\n");
129 return 0;
130#else
131 ohci_err (ohci, "unsupported big endian Toshiba quirk\n");
132 return -ENXIO;
133#endif
134}
135
136
137
138
139static void ohci_quirk_nec_worker(struct work_struct *work)
140{
141 struct ohci_hcd *ohci = container_of(work, struct ohci_hcd, nec_work);
142 int status;
143
144 status = ohci_init(ohci);
145 if (status != 0) {
146 ohci_err(ohci, "Restarting NEC controller failed in %s, %d\n",
147 "ohci_init", status);
148 return;
149 }
150
151 status = ohci_restart(ohci);
152 if (status != 0)
153 ohci_err(ohci, "Restarting NEC controller failed in %s, %d\n",
154 "ohci_restart", status);
155}
156
157static int ohci_quirk_nec(struct usb_hcd *hcd)
158{
159 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
160
161 ohci->flags |= OHCI_QUIRK_NEC;
162 INIT_WORK(&ohci->nec_work, ohci_quirk_nec_worker);
163 ohci_dbg (ohci, "enabled NEC chipset lost interrupt quirk\n");
164
165 return 0;
166}
167
168static int ohci_quirk_amd700(struct usb_hcd *hcd)
169{
170 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
171 u8 rev = 0;
172
173 if (!amd_smbus_dev)
174 amd_smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
175 PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
176 if (!amd_smbus_dev)
177 return 0;
178
179 pci_read_config_byte(amd_smbus_dev, PCI_REVISION_ID, &rev);
180 if ((rev > 0x3b) || (rev < 0x30)) {
181 pci_dev_put(amd_smbus_dev);
182 amd_smbus_dev = NULL;
183 return 0;
184 }
185
186 amd_ohci_iso_count++;
187
188 if (!amd_hb_dev)
189 amd_hb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x9600, NULL);
190
191 ohci->flags |= OHCI_QUIRK_AMD_ISO;
192 ohci_dbg(ohci, "enabled AMD ISO transfers quirk\n");
193
194 return 0;
195}
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211static void quirk_amd_pll(int on)
212{
213 u32 addr;
214 u32 val;
215 u32 bit = (on > 0) ? 1 : 0;
216
217 pci_read_config_dword(amd_smbus_dev, AB_REG_BAR, &addr);
218
219
220
221 outl(AX_INDXC, AB_INDX(addr));
222 outl(0x40, AB_DATA(addr));
223 outl(AX_DATAC, AB_INDX(addr));
224 val = inl(AB_DATA(addr));
225 val &= ~((1 << 3) | (1 << 4) | (1 << 9));
226 val |= (bit << 3) | ((!bit) << 4) | ((!bit) << 9);
227 outl(val, AB_DATA(addr));
228
229 if (amd_hb_dev) {
230 addr = PCIE_P_CNTL;
231 pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_ADDR, addr);
232
233 pci_read_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, &val);
234 val &= ~(1 | (1 << 3) | (1 << 4) | (1 << 9) | (1 << 12));
235 val |= bit | (bit << 3) | (bit << 12);
236 val |= ((!bit) << 4) | ((!bit) << 9);
237 pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, val);
238
239 addr = BIF_NB;
240 pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_ADDR, addr);
241
242 pci_read_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, &val);
243 val &= ~(1 << 8);
244 val |= bit << 8;
245 pci_write_config_dword(amd_hb_dev, NB_PCIE_INDX_DATA, val);
246 }
247}
248
249static void amd_iso_dev_put(void)
250{
251 amd_ohci_iso_count--;
252 if (amd_ohci_iso_count == 0) {
253 if (amd_smbus_dev) {
254 pci_dev_put(amd_smbus_dev);
255 amd_smbus_dev = NULL;
256 }
257 if (amd_hb_dev) {
258 pci_dev_put(amd_hb_dev);
259 amd_hb_dev = NULL;
260 }
261 }
262
263}
264
265
266static const struct pci_device_id ohci_pci_quirks[] = {
267 {
268 PCI_DEVICE(PCI_VENDOR_ID_AMD, 0x740c),
269 .driver_data = (unsigned long)ohci_quirk_amd756,
270 },
271 {
272 PCI_DEVICE(PCI_VENDOR_ID_OPTI, 0xc861),
273 .driver_data = (unsigned long)ohci_quirk_opti,
274 },
275 {
276 PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_ANY_ID),
277 .driver_data = (unsigned long)ohci_quirk_ns,
278 },
279 {
280 PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xa0f8),
281 .driver_data = (unsigned long)ohci_quirk_zfmicro,
282 },
283 {
284 PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA_2, 0x01b6),
285 .driver_data = (unsigned long)ohci_quirk_toshiba_scc,
286 },
287 {
288 PCI_DEVICE(PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_USB),
289 .driver_data = (unsigned long)ohci_quirk_nec,
290 },
291 {
292
293 .vendor = PCI_VENDOR_ID_AL,
294 .device = 0x5237,
295 .subvendor = PCI_VENDOR_ID_TOSHIBA,
296 .subdevice = 0x0004,
297 .driver_data = (unsigned long) broken_suspend,
298 },
299 {
300 PCI_DEVICE(PCI_VENDOR_ID_ITE, 0x8152),
301 .driver_data = (unsigned long) broken_suspend,
302 },
303 {
304 PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4397),
305 .driver_data = (unsigned long)ohci_quirk_amd700,
306 },
307 {
308 PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4398),
309 .driver_data = (unsigned long)ohci_quirk_amd700,
310 },
311 {
312 PCI_DEVICE(PCI_VENDOR_ID_ATI, 0x4399),
313 .driver_data = (unsigned long)ohci_quirk_amd700,
314 },
315
316
317
318
319
320 {},
321};
322
323static int ohci_pci_reset (struct usb_hcd *hcd)
324{
325 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
326 int ret = 0;
327
328 if (hcd->self.controller) {
329 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
330 const struct pci_device_id *quirk_id;
331
332 quirk_id = pci_match_id(ohci_pci_quirks, pdev);
333 if (quirk_id != NULL) {
334 int (*quirk)(struct usb_hcd *ohci);
335 quirk = (void *)quirk_id->driver_data;
336 ret = quirk(hcd);
337 }
338 }
339 if (ret == 0) {
340 ohci_hcd_init (ohci);
341 return ohci_init (ohci);
342 }
343 return ret;
344}
345
346
347static int __devinit ohci_pci_start (struct usb_hcd *hcd)
348{
349 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
350 int ret;
351
352#ifdef CONFIG_PM
353 if (hcd->self.controller) {
354 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
355
356
357
358
359
360 if (device_may_wakeup(&pdev->dev))
361 ohci->hc_control |= OHCI_CTRL_RWC;
362 }
363#endif
364
365 ret = ohci_run (ohci);
366 if (ret < 0) {
367 ohci_err (ohci, "can't start\n");
368 ohci_stop (hcd);
369 }
370 return ret;
371}
372
373#ifdef CONFIG_PM
374
375static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
376{
377 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
378 unsigned long flags;
379 int rc = 0;
380
381
382
383
384
385
386
387
388
389 spin_lock_irqsave (&ohci->lock, flags);
390 if (hcd->state != HC_STATE_SUSPENDED) {
391 rc = -EINVAL;
392 goto bail;
393 }
394 ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
395 (void)ohci_readl(ohci, &ohci->regs->intrdisable);
396
397
398 if (message.event == PM_EVENT_PRETHAW)
399 ohci_usb_reset(ohci);
400
401 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
402 bail:
403 spin_unlock_irqrestore (&ohci->lock, flags);
404
405 return rc;
406}
407
408
409static int ohci_pci_resume (struct usb_hcd *hcd)
410{
411 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
412 ohci_finish_controller_resume(hcd);
413 return 0;
414}
415
416#endif
417
418
419
420
421static const struct hc_driver ohci_pci_hc_driver = {
422 .description = hcd_name,
423 .product_desc = "OHCI Host Controller",
424 .hcd_priv_size = sizeof(struct ohci_hcd),
425
426
427
428
429 .irq = ohci_irq,
430 .flags = HCD_MEMORY | HCD_USB11,
431
432
433
434
435 .reset = ohci_pci_reset,
436 .start = ohci_pci_start,
437 .stop = ohci_stop,
438 .shutdown = ohci_shutdown,
439
440#ifdef CONFIG_PM
441 .pci_suspend = ohci_pci_suspend,
442 .pci_resume = ohci_pci_resume,
443#endif
444
445
446
447
448 .urb_enqueue = ohci_urb_enqueue,
449 .urb_dequeue = ohci_urb_dequeue,
450 .endpoint_disable = ohci_endpoint_disable,
451
452
453
454
455 .get_frame_number = ohci_get_frame,
456
457
458
459
460 .hub_status_data = ohci_hub_status_data,
461 .hub_control = ohci_hub_control,
462#ifdef CONFIG_PM
463 .bus_suspend = ohci_bus_suspend,
464 .bus_resume = ohci_bus_resume,
465#endif
466 .start_port_reset = ohci_start_port_reset,
467};
468
469
470
471
472static const struct pci_device_id pci_ids [] = { {
473
474 PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_OHCI, ~0),
475 .driver_data = (unsigned long) &ohci_pci_hc_driver,
476 }, { }
477};
478MODULE_DEVICE_TABLE (pci, pci_ids);
479
480
481static struct pci_driver ohci_pci_driver = {
482 .name = (char *) hcd_name,
483 .id_table = pci_ids,
484
485 .probe = usb_hcd_pci_probe,
486 .remove = usb_hcd_pci_remove,
487
488#ifdef CONFIG_PM
489 .suspend = usb_hcd_pci_suspend,
490 .resume = usb_hcd_pci_resume,
491#endif
492
493 .shutdown = usb_hcd_pci_shutdown,
494};
495