[PATCH] USB: convert kcalloc to kzalloc
[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 #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);