Pull suspend into release branch
[linux-2.6] / 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 #ifndef CONFIG_PCI
18 #error "This file is PCI bus glue.  CONFIG_PCI must be defined."
19 #endif
20
21 /*-------------------------------------------------------------------------*/
22
23 static int broken_suspend(struct usb_hcd *hcd)
24 {
25         device_init_wakeup(&hcd->self.root_hub->dev, 0);
26         return 0;
27 }
28
29 /* AMD 756, for most chips (early revs), corrupts register
30  * values on read ... so enable the vendor workaround.
31  */
32 static int ohci_quirk_amd756(struct usb_hcd *hcd)
33 {
34         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
35
36         ohci->flags = OHCI_QUIRK_AMD756;
37         ohci_dbg (ohci, "AMD756 erratum 4 workaround\n");
38
39         /* also erratum 10 (suspend/resume issues) */
40         return broken_suspend(hcd);
41 }
42
43 /* Apple's OHCI driver has a lot of bizarre workarounds
44  * for this chip.  Evidently control and bulk lists
45  * can get confused.  (B&W G3 models, and ...)
46  */
47 static int ohci_quirk_opti(struct usb_hcd *hcd)
48 {
49         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
50
51         ohci_dbg (ohci, "WARNING: OPTi workarounds unavailable\n");
52
53         return 0;
54 }
55
56 /* Check for NSC87560. We have to look at the bridge (fn1) to
57  * identify the USB (fn2). This quirk might apply to more or
58  * even all NSC stuff.
59  */
60 static int ohci_quirk_ns(struct usb_hcd *hcd)
61 {
62         struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
63         struct pci_dev  *b;
64
65         b  = pci_get_slot (pdev->bus, PCI_DEVFN (PCI_SLOT (pdev->devfn), 1));
66         if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO
67             && b->vendor == PCI_VENDOR_ID_NS) {
68                 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
69
70                 ohci->flags |= OHCI_QUIRK_SUPERIO;
71                 ohci_dbg (ohci, "Using NSC SuperIO setup\n");
72         }
73         pci_dev_put(b);
74
75         return 0;
76 }
77
78 /* Check for Compaq's ZFMicro chipset, which needs short
79  * delays before control or bulk queues get re-activated
80  * in finish_unlinks()
81  */
82 static int ohci_quirk_zfmicro(struct usb_hcd *hcd)
83 {
84         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
85
86         ohci->flags |= OHCI_QUIRK_ZFMICRO;
87         ohci_dbg (ohci, "enabled Compaq ZFMicro chipset quirk\n");
88
89         return 0;
90 }
91
92 /* Check for Toshiba SCC OHCI which has big endian registers
93  * and little endian in memory data structures
94  */
95 static int ohci_quirk_toshiba_scc(struct usb_hcd *hcd)
96 {
97         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
98
99         /* That chip is only present in the southbridge of some
100          * cell based platforms which are supposed to select
101          * CONFIG_USB_OHCI_BIG_ENDIAN_MMIO. We verify here if
102          * that was the case though.
103          */
104 #ifdef CONFIG_USB_OHCI_BIG_ENDIAN_MMIO
105         ohci->flags |= OHCI_QUIRK_BE_MMIO;
106         ohci_dbg (ohci, "enabled big endian Toshiba quirk\n");
107         return 0;
108 #else
109         ohci_err (ohci, "unsupported big endian Toshiba quirk\n");
110         return -ENXIO;
111 #endif
112 }
113
114 /* Check for NEC chip and apply quirk for allegedly lost interrupts.
115  */
116 static int ohci_quirk_nec(struct usb_hcd *hcd)
117 {
118         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
119
120         ohci->flags |= OHCI_QUIRK_NEC;
121         ohci_dbg (ohci, "enabled NEC chipset lost interrupt quirk\n");
122
123         return 0;
124 }
125
126 /* List of quirks for OHCI */
127 static const struct pci_device_id ohci_pci_quirks[] = {
128         {
129                 PCI_DEVICE(PCI_VENDOR_ID_AMD, 0x740c),
130                 .driver_data = (unsigned long)ohci_quirk_amd756,
131         },
132         {
133                 PCI_DEVICE(PCI_VENDOR_ID_OPTI, 0xc861),
134                 .driver_data = (unsigned long)ohci_quirk_opti,
135         },
136         {
137                 PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_ANY_ID),
138                 .driver_data = (unsigned long)ohci_quirk_ns,
139         },
140         {
141                 PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xa0f8),
142                 .driver_data = (unsigned long)ohci_quirk_zfmicro,
143         },
144         {
145                 PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA_2, 0x01b6),
146                 .driver_data = (unsigned long)ohci_quirk_toshiba_scc,
147         },
148         {
149                 PCI_DEVICE(PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_USB),
150                 .driver_data = (unsigned long)ohci_quirk_nec,
151         },
152         {
153                 /* Toshiba portege 4000 */
154                 .vendor         = PCI_VENDOR_ID_AL,
155                 .device         = 0x5237,
156                 .subvendor      = PCI_VENDOR_ID_TOSHIBA,
157                 .subdevice      = 0x0004,
158                 .driver_data    = (unsigned long) broken_suspend,
159         },
160         {
161                 PCI_DEVICE(PCI_VENDOR_ID_ITE, 0x8152),
162                 .driver_data = (unsigned long) broken_suspend,
163         },
164         /* FIXME for some of the early AMD 760 southbridges, OHCI
165          * won't work at all.  blacklist them.
166          */
167
168         {},
169 };
170
171 static int ohci_pci_reset (struct usb_hcd *hcd)
172 {
173         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
174         int ret = 0;
175
176         if (hcd->self.controller) {
177                 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
178                 const struct pci_device_id *quirk_id;
179
180                 quirk_id = pci_match_id(ohci_pci_quirks, pdev);
181                 if (quirk_id != NULL) {
182                         int (*quirk)(struct usb_hcd *ohci);
183                         quirk = (void *)quirk_id->driver_data;
184                         ret = quirk(hcd);
185                 }
186         }
187         if (ret == 0) {
188                 ohci_hcd_init (ohci);
189                 return ohci_init (ohci);
190         }
191         return ret;
192 }
193
194
195 static int __devinit ohci_pci_start (struct usb_hcd *hcd)
196 {
197         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
198         int             ret;
199
200 #ifdef CONFIG_PM /* avoid warnings about unused pdev */
201         if (hcd->self.controller) {
202                 struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
203
204                 /* RWC may not be set for add-in PCI cards, since boot
205                  * firmware probably ignored them.  This transfers PCI
206                  * PM wakeup capabilities (once the PCI layer is fixed).
207                  */
208                 if (device_may_wakeup(&pdev->dev))
209                         ohci->hc_control |= OHCI_CTRL_RWC;
210         }
211 #endif /* CONFIG_PM */
212
213         ret = ohci_run (ohci);
214         if (ret < 0) {
215                 ohci_err (ohci, "can't start\n");
216                 ohci_stop (hcd);
217         }
218         return ret;
219 }
220
221 #if     defined(CONFIG_USB_PERSIST) && (defined(CONFIG_USB_EHCI_HCD) || \
222                 defined(CONFIG_USB_EHCI_HCD_MODULE))
223
224 /* Following a power loss, we must prepare to regain control of the ports
225  * we used to own.  This means turning on the port power before ehci-hcd
226  * tries to switch ownership.
227  *
228  * This isn't a 100% perfect solution.  On most systems the OHCI controllers
229  * lie at lower PCI addresses than the EHCI controller, so they will be
230  * discovered (and hence resumed) first.  But there is no guarantee things
231  * will always work this way.  If the EHCI controller is resumed first and
232  * the OHCI ports are unpowered, then the handover will fail.
233  */
234 static void prepare_for_handover(struct usb_hcd *hcd)
235 {
236         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
237         int             port;
238
239         /* Here we "know" root ports should always stay powered */
240         ohci_dbg(ohci, "powerup ports\n");
241         for (port = 0; port < ohci->num_ports; port++)
242                 ohci_writel(ohci, RH_PS_PPS,
243                                 &ohci->regs->roothub.portstatus[port]);
244
245         /* Flush those writes */
246         ohci_readl(ohci, &ohci->regs->control);
247         msleep(20);
248 }
249
250 #else
251
252 static inline void prepare_for_handover(struct usb_hcd *hcd)
253 { }
254
255 #endif  /* CONFIG_USB_PERSIST etc. */
256
257 #ifdef  CONFIG_PM
258
259 static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
260 {
261         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
262         unsigned long   flags;
263         int             rc = 0;
264
265         /* Root hub was already suspended. Disable irq emission and
266          * mark HW unaccessible, bail out if RH has been resumed. Use
267          * the spinlock to properly synchronize with possible pending
268          * RH suspend or resume activity.
269          *
270          * This is still racy as hcd->state is manipulated outside of
271          * any locks =P But that will be a different fix.
272          */
273         spin_lock_irqsave (&ohci->lock, flags);
274         if (hcd->state != HC_STATE_SUSPENDED) {
275                 rc = -EINVAL;
276                 goto bail;
277         }
278         ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
279         (void)ohci_readl(ohci, &ohci->regs->intrdisable);
280
281         /* make sure snapshot being resumed re-enumerates everything */
282         if (message.event == PM_EVENT_PRETHAW)
283                 ohci_usb_reset(ohci);
284
285         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
286  bail:
287         spin_unlock_irqrestore (&ohci->lock, flags);
288
289         return rc;
290 }
291
292
293 static int ohci_pci_resume (struct usb_hcd *hcd)
294 {
295         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
296
297         /* FIXME: we should try to detect loss of VBUS power here */
298         prepare_for_handover(hcd);
299
300         return 0;
301 }
302
303 #endif  /* CONFIG_PM */
304
305
306 /*-------------------------------------------------------------------------*/
307
308 static const struct hc_driver ohci_pci_hc_driver = {
309         .description =          hcd_name,
310         .product_desc =         "OHCI Host Controller",
311         .hcd_priv_size =        sizeof(struct ohci_hcd),
312
313         /*
314          * generic hardware linkage
315          */
316         .irq =                  ohci_irq,
317         .flags =                HCD_MEMORY | HCD_USB11,
318
319         /*
320          * basic lifecycle operations
321          */
322         .reset =                ohci_pci_reset,
323         .start =                ohci_pci_start,
324         .stop =                 ohci_stop,
325         .shutdown =             ohci_shutdown,
326
327 #ifdef  CONFIG_PM
328         /* these suspend/resume entries are for upstream PCI glue ONLY */
329         .suspend =              ohci_pci_suspend,
330         .resume =               ohci_pci_resume,
331 #endif
332
333         /*
334          * managing i/o requests and associated device resources
335          */
336         .urb_enqueue =          ohci_urb_enqueue,
337         .urb_dequeue =          ohci_urb_dequeue,
338         .endpoint_disable =     ohci_endpoint_disable,
339
340         /*
341          * scheduling support
342          */
343         .get_frame_number =     ohci_get_frame,
344
345         /*
346          * root hub support
347          */
348         .hub_status_data =      ohci_hub_status_data,
349         .hub_control =          ohci_hub_control,
350         .hub_irq_enable =       ohci_rhsc_enable,
351 #ifdef  CONFIG_PM
352         .bus_suspend =          ohci_bus_suspend,
353         .bus_resume =           ohci_bus_resume,
354 #endif
355         .start_port_reset =     ohci_start_port_reset,
356 };
357
358 /*-------------------------------------------------------------------------*/
359
360
361 static const struct pci_device_id pci_ids [] = { {
362         /* handle any USB OHCI controller */
363         PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_OHCI, ~0),
364         .driver_data =  (unsigned long) &ohci_pci_hc_driver,
365         }, { /* end: all zeroes */ }
366 };
367 MODULE_DEVICE_TABLE (pci, pci_ids);
368
369 /* pci driver glue; this is a "new style" PCI driver module */
370 static struct pci_driver ohci_pci_driver = {
371         .name =         (char *) hcd_name,
372         .id_table =     pci_ids,
373
374         .probe =        usb_hcd_pci_probe,
375         .remove =       usb_hcd_pci_remove,
376
377 #ifdef  CONFIG_PM
378         .suspend =      usb_hcd_pci_suspend,
379         .resume =       usb_hcd_pci_resume,
380 #endif
381
382         .shutdown =     usb_hcd_pci_shutdown,
383 };
384