[POWERPC] mpc5200: normalize compatible property bindings
[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, "fsl,mpc5200-ohci"))
140                         ohci->flags |= OHCI_QUIRK_FRAME_NO;
141                 if (of_device_is_compatible(dn, "mpc5200-ohci"))
142                         ohci->flags |= OHCI_QUIRK_FRAME_NO;
143         }
144
145         ohci_hcd_init(ohci);
146
147         rv = usb_add_hcd(hcd, irq, IRQF_DISABLED);
148         if (rv == 0)
149                 return 0;
150
151         iounmap(hcd->regs);
152 err_ioremap:
153         irq_dispose_mapping(irq);
154 err_irq:
155         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
156 err_rmr:
157         usb_put_hcd(hcd);
158
159         return rv;
160 }
161
162 static int ohci_hcd_ppc_of_remove(struct of_device *op)
163 {
164         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
165         dev_set_drvdata(&op->dev, NULL);
166
167         dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
168
169         usb_remove_hcd(hcd);
170
171         iounmap(hcd->regs);
172         irq_dispose_mapping(hcd->irq);
173         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
174
175         usb_put_hcd(hcd);
176
177         return 0;
178 }
179
180 static int ohci_hcd_ppc_of_shutdown(struct of_device *op)
181 {
182         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
183
184         if (hcd->driver->shutdown)
185                 hcd->driver->shutdown(hcd);
186
187         return 0;
188 }
189
190
191 static struct of_device_id ohci_hcd_ppc_of_match[] = {
192 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_BE
193         {
194                 .name = "usb",
195                 .compatible = "ohci-bigendian",
196         },
197         {
198                 .name = "usb",
199                 .compatible = "ohci-be",
200         },
201 #endif
202 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_LE
203         {
204                 .name = "usb",
205                 .compatible = "ohci-littledian",
206         },
207         {
208                 .name = "usb",
209                 .compatible = "ohci-le",
210         },
211 #endif
212         {},
213 };
214 MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match);
215
216 #if     !defined(CONFIG_USB_OHCI_HCD_PPC_OF_BE) && \
217         !defined(CONFIG_USB_OHCI_HCD_PPC_OF_LE)
218 #error "No endianess selected for ppc-of-ohci"
219 #endif
220
221
222 static struct of_platform_driver ohci_hcd_ppc_of_driver = {
223         .name           = "ppc-of-ohci",
224         .match_table    = ohci_hcd_ppc_of_match,
225         .probe          = ohci_hcd_ppc_of_probe,
226         .remove         = ohci_hcd_ppc_of_remove,
227         .shutdown       = ohci_hcd_ppc_of_shutdown,
228 #ifdef CONFIG_PM
229         /*.suspend      = ohci_hcd_ppc_soc_drv_suspend,*/
230         /*.resume       = ohci_hcd_ppc_soc_drv_resume,*/
231 #endif
232         .driver         = {
233                 .name   = "ppc-of-ohci",
234                 .owner  = THIS_MODULE,
235         },
236 };
237