0c3e6b790b7b8e1372005940389d648affd69392
[linux-2.6.git] / drivers / usb / host / ohci-ppc-of.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  * (C) Copyright 2002 Hewlett-Packard Company
7  * (C) Copyright 2006 Sylvain Munaut <tnt@246tNt.com>
8  *
9  * Bus glue for OHCI HC on the of_platform bus
10  *
11  * Modified for of_platform bus from ohci-sa1111.c
12  *
13  * This file is licenced under the GPL.
14  */
15
16 #include <linux/signal.h>
17
18 #include <asm/of_platform.h>
19 #include <asm/prom.h>
20
21
22 static int __devinit
23 ohci_ppc_of_start(struct usb_hcd *hcd)
24 {
25         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
26         int             ret;
27
28         if ((ret = ohci_init(ohci)) < 0)
29                 return ret;
30
31         if ((ret = ohci_run(ohci)) < 0) {
32                 err("can't start %s", ohci_to_hcd(ohci)->self.bus_name);
33                 ohci_stop(hcd);
34                 return ret;
35         }
36
37         return 0;
38 }
39
40 static const struct hc_driver ohci_ppc_of_hc_driver = {
41         .description =          hcd_name,
42         .product_desc =         "OF OHCI",
43         .hcd_priv_size =        sizeof(struct ohci_hcd),
44
45         /*
46          * generic hardware linkage
47          */
48         .irq =                  ohci_irq,
49         .flags =                HCD_USB11 | HCD_MEMORY,
50
51         /*
52          * basic lifecycle operations
53          */
54         .start =                ohci_ppc_of_start,
55         .stop =                 ohci_stop,
56         .shutdown =             ohci_shutdown,
57
58         /*
59          * managing i/o requests and associated device resources
60          */
61         .urb_enqueue =          ohci_urb_enqueue,
62         .urb_dequeue =          ohci_urb_dequeue,
63         .endpoint_disable =     ohci_endpoint_disable,
64
65         /*
66          * scheduling support
67          */
68         .get_frame_number =     ohci_get_frame,
69
70         /*
71          * root hub support
72          */
73         .hub_status_data =      ohci_hub_status_data,
74         .hub_control =          ohci_hub_control,
75         .hub_irq_enable =       ohci_rhsc_enable,
76 #ifdef  CONFIG_PM
77         .bus_suspend =          ohci_bus_suspend,
78         .bus_resume =           ohci_bus_resume,
79 #endif
80         .start_port_reset =     ohci_start_port_reset,
81 };
82
83
84 static int __devinit
85 ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
86 {
87         struct device_node *dn = op->node;
88         struct usb_hcd *hcd;
89         struct ohci_hcd *ohci;
90         struct resource res;
91         int irq;
92
93         int rv;
94         int is_bigendian;
95
96         if (usb_disabled())
97                 return -ENODEV;
98
99         is_bigendian =
100                 of_device_is_compatible(dn, "ohci-bigendian") ||
101                 of_device_is_compatible(dn, "ohci-be");
102
103         dev_dbg(&op->dev, "initializing PPC-OF USB Controller\n");
104
105         rv = of_address_to_resource(dn, 0, &res);
106         if (rv)
107                 return rv;
108
109         hcd = usb_create_hcd(&ohci_ppc_of_hc_driver, &op->dev, "PPC-OF USB");
110         if (!hcd)
111                 return -ENOMEM;
112
113         hcd->rsrc_start = res.start;
114         hcd->rsrc_len = res.end - res.start + 1;
115
116         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
117                 printk(KERN_ERR __FILE__ ": request_mem_region failed\n");
118                 rv = -EBUSY;
119                 goto err_rmr;
120         }
121
122         irq = irq_of_parse_and_map(dn, 0);
123         if (irq == NO_IRQ) {
124                 printk(KERN_ERR __FILE__ ": irq_of_parse_and_map failed\n");
125                 rv = -EBUSY;
126                 goto err_irq;
127         }
128
129         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
130         if (!hcd->regs) {
131                 printk(KERN_ERR __FILE__ ": ioremap failed\n");
132                 rv = -ENOMEM;
133                 goto err_ioremap;
134         }
135
136         ohci = hcd_to_ohci(hcd);
137         if (is_bigendian) {
138                 ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;
139                 if (of_device_is_compatible(dn, "mpc5200-ohci"))
140                         ohci->flags |= OHCI_QUIRK_FRAME_NO;
141         }
142
143         ohci_hcd_init(ohci);
144
145         rv = usb_add_hcd(hcd, irq, IRQF_DISABLED);
146         if (rv == 0)
147                 return 0;
148
149         iounmap(hcd->regs);
150 err_ioremap:
151         irq_dispose_mapping(irq);
152 err_irq:
153         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
154 err_rmr:
155         usb_put_hcd(hcd);
156
157         return rv;
158 }
159
160 static int ohci_hcd_ppc_of_remove(struct of_device *op)
161 {
162         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
163         dev_set_drvdata(&op->dev, NULL);
164
165         dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
166
167         usb_remove_hcd(hcd);
168
169         iounmap(hcd->regs);
170         irq_dispose_mapping(hcd->irq);
171         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
172
173         usb_put_hcd(hcd);
174
175         return 0;
176 }
177
178 static int ohci_hcd_ppc_of_shutdown(struct of_device *op)
179 {
180         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
181
182         if (hcd->driver->shutdown)
183                 hcd->driver->shutdown(hcd);
184
185         return 0;
186 }
187
188
189 static struct of_device_id ohci_hcd_ppc_of_match[] = {
190 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_BE
191         {
192                 .name = "usb",
193                 .compatible = "ohci-bigendian",
194         },
195         {
196                 .name = "usb",
197                 .compatible = "ohci-be",
198         },
199 #endif
200 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_LE
201         {
202                 .name = "usb",
203                 .compatible = "ohci-littledian",
204         },
205         {
206                 .name = "usb",
207                 .compatible = "ohci-le",
208         },
209 #endif
210         {},
211 };
212 MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match);
213
214 #if     !defined(CONFIG_USB_OHCI_HCD_PPC_OF_BE) && \
215         !defined(CONFIG_USB_OHCI_HCD_PPC_OF_LE)
216 #error "No endianess selected for ppc-of-ohci"
217 #endif
218
219
220 static struct of_platform_driver ohci_hcd_ppc_of_driver = {
221         .name           = "ppc-of-ohci",
222         .match_table    = ohci_hcd_ppc_of_match,
223         .probe          = ohci_hcd_ppc_of_probe,
224         .remove         = ohci_hcd_ppc_of_remove,
225         .shutdown       = ohci_hcd_ppc_of_shutdown,
226 #ifdef CONFIG_PM
227         /*.suspend      = ohci_hcd_ppc_soc_drv_suspend,*/
228         /*.resume       = ohci_hcd_ppc_soc_drv_resume,*/
229 #endif
230         .driver         = {
231                 .name   = "ppc-of-ohci",
232                 .owner  = THIS_MODULE,
233         },
234 };
235