1 /*
2 * EHCI HCD (Host Controller Driver) for USB.
3 *
4 * Bus Glue for PPC On-Chip EHCI driver on the of_platform bus
5 * Tested on AMCC PPC 440EPx
6 *
7 * Valentine Barshak <vbarshak@ru.mvista.com>
8 *
9 * Based on "ehci-ppc-soc.c" by Stefan Roese <sr@denx.de>
10 * and "ohci-ppc-of.c" by Sylvain Munaut <tnt@246tNt.com>
11 *
12 * This file is licenced under the GPL.
13 */
14
15 #include <linux/signal.h>
16
17 #include <linux/of.h>
18 #include <linux/of_platform.h>
19
20 /* called during probe() after chip reset completes */
ehci_ppc_of_setup(struct usb_hcd * hcd)21 static int ehci_ppc_of_setup(struct usb_hcd *hcd)
22 {
23 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
24 int retval;
25
26 retval = ehci_halt(ehci);
27 if (retval)
28 return retval;
29
30 retval = ehci_init(hcd);
31 if (retval)
32 return retval;
33
34 ehci->sbrn = 0x20;
35 return ehci_reset(ehci);
36 }
37
38
39 static const struct hc_driver ehci_ppc_of_hc_driver = {
40 .description = hcd_name,
41 .product_desc = "OF EHCI",
42 .hcd_priv_size = sizeof(struct ehci_hcd),
43
44 /*
45 * generic hardware linkage
46 */
47 .irq = ehci_irq,
48 .flags = HCD_MEMORY | HCD_USB2,
49
50 /*
51 * basic lifecycle operations
52 */
53 .reset = ehci_ppc_of_setup,
54 .start = ehci_run,
55 .stop = ehci_stop,
56 .shutdown = ehci_shutdown,
57
58 /*
59 * managing i/o requests and associated device resources
60 */
61 .urb_enqueue = ehci_urb_enqueue,
62 .urb_dequeue = ehci_urb_dequeue,
63 .endpoint_disable = ehci_endpoint_disable,
64
65 /*
66 * scheduling support
67 */
68 .get_frame_number = ehci_get_frame,
69
70 /*
71 * root hub support
72 */
73 .hub_status_data = ehci_hub_status_data,
74 .hub_control = ehci_hub_control,
75 #ifdef CONFIG_PM
76 .bus_suspend = ehci_bus_suspend,
77 .bus_resume = ehci_bus_resume,
78 #endif
79 .relinquish_port = ehci_relinquish_port,
80 .port_handed_over = ehci_port_handed_over,
81 };
82
83
84 /*
85 * 440EPx Errata USBH_3
86 * Fix: Enable Break Memory Transfer (BMT) in INSNREG3
87 */
88 #define PPC440EPX_EHCI0_INSREG_BMT (0x1 << 0)
89 static int __devinit
ppc44x_enable_bmt(struct device_node * dn)90 ppc44x_enable_bmt(struct device_node *dn)
91 {
92 __iomem u32 *insreg_virt;
93
94 insreg_virt = of_iomap(dn, 1);
95 if (!insreg_virt)
96 return -EINVAL;
97
98 out_be32(insreg_virt + 3, PPC440EPX_EHCI0_INSREG_BMT);
99
100 iounmap(insreg_virt);
101 return 0;
102 }
103
104
105 static int __devinit
ehci_hcd_ppc_of_probe(struct of_device * op,const struct of_device_id * match)106 ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
107 {
108 struct device_node *dn = op->node;
109 struct usb_hcd *hcd;
110 struct ehci_hcd *ehci = NULL;
111 struct resource res;
112 int irq;
113 int rv;
114
115 struct device_node *np;
116
117 if (usb_disabled())
118 return -ENODEV;
119
120 dev_dbg(&op->dev, "initializing PPC-OF USB Controller\n");
121
122 rv = of_address_to_resource(dn, 0, &res);
123 if (rv)
124 return rv;
125
126 hcd = usb_create_hcd(&ehci_ppc_of_hc_driver, &op->dev, "PPC-OF USB");
127 if (!hcd)
128 return -ENOMEM;
129
130 hcd->rsrc_start = res.start;
131 hcd->rsrc_len = res.end - res.start + 1;
132
133 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
134 printk(KERN_ERR __FILE__ ": request_mem_region failed\n");
135 rv = -EBUSY;
136 goto err_rmr;
137 }
138
139 irq = irq_of_parse_and_map(dn, 0);
140 if (irq == NO_IRQ) {
141 printk(KERN_ERR __FILE__ ": irq_of_parse_and_map failed\n");
142 rv = -EBUSY;
143 goto err_irq;
144 }
145
146 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
147 if (!hcd->regs) {
148 printk(KERN_ERR __FILE__ ": ioremap failed\n");
149 rv = -ENOMEM;
150 goto err_ioremap;
151 }
152
153 ehci = hcd_to_ehci(hcd);
154 np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
155 if (np != NULL) {
156 /* claim we really affected by usb23 erratum */
157 if (!of_address_to_resource(np, 0, &res))
158 ehci->ohci_hcctrl_reg = ioremap(res.start +
159 OHCI_HCCTRL_OFFSET, OHCI_HCCTRL_LEN);
160 else
161 pr_debug(__FILE__ ": no ohci offset in fdt\n");
162 if (!ehci->ohci_hcctrl_reg) {
163 pr_debug(__FILE__ ": ioremap for ohci hcctrl failed\n");
164 } else {
165 ehci->has_amcc_usb23 = 1;
166 }
167 }
168
169 if (of_get_property(dn, "big-endian", NULL)) {
170 ehci->big_endian_mmio = 1;
171 ehci->big_endian_desc = 1;
172 }
173 if (of_get_property(dn, "big-endian-regs", NULL))
174 ehci->big_endian_mmio = 1;
175 if (of_get_property(dn, "big-endian-desc", NULL))
176 ehci->big_endian_desc = 1;
177
178 ehci->caps = hcd->regs;
179 ehci->regs = hcd->regs +
180 HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
181
182 /* cache this readonly data; minimize chip reads */
183 ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
184
185 if (of_device_is_compatible(dn, "ibm,usb-ehci-440epx")) {
186 rv = ppc44x_enable_bmt(dn);
187 ehci_dbg(ehci, "Break Memory Transfer (BMT) is %senabled!\n",
188 rv ? "NOT ": "");
189 }
190
191 rv = usb_add_hcd(hcd, irq, 0);
192 if (rv == 0)
193 return 0;
194
195 iounmap(hcd->regs);
196 err_ioremap:
197 irq_dispose_mapping(irq);
198 err_irq:
199 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
200
201 if (ehci->has_amcc_usb23)
202 iounmap(ehci->ohci_hcctrl_reg);
203 err_rmr:
204 usb_put_hcd(hcd);
205
206 return rv;
207 }
208
209
ehci_hcd_ppc_of_remove(struct of_device * op)210 static int ehci_hcd_ppc_of_remove(struct of_device *op)
211 {
212 struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
213 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
214
215 struct device_node *np;
216 struct resource res;
217
218 dev_set_drvdata(&op->dev, NULL);
219
220 dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
221
222 usb_remove_hcd(hcd);
223
224 iounmap(hcd->regs);
225 irq_dispose_mapping(hcd->irq);
226 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
227
228 /* use request_mem_region to test if the ohci driver is loaded. if so
229 * ensure the ohci core is operational.
230 */
231 if (ehci->has_amcc_usb23) {
232 np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
233 if (np != NULL) {
234 if (!of_address_to_resource(np, 0, &res))
235 if (!request_mem_region(res.start,
236 0x4, hcd_name))
237 set_ohci_hcfs(ehci, 1);
238 else
239 release_mem_region(res.start, 0x4);
240 else
241 pr_debug(__FILE__ ": no ohci offset in fdt\n");
242 of_node_put(np);
243 }
244
245 iounmap(ehci->ohci_hcctrl_reg);
246 }
247 usb_put_hcd(hcd);
248
249 return 0;
250 }
251
252
ehci_hcd_ppc_of_shutdown(struct of_device * op)253 static int ehci_hcd_ppc_of_shutdown(struct of_device *op)
254 {
255 struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
256
257 if (hcd->driver->shutdown)
258 hcd->driver->shutdown(hcd);
259
260 return 0;
261 }
262
263
264 static struct of_device_id ehci_hcd_ppc_of_match[] = {
265 {
266 .compatible = "usb-ehci",
267 },
268 {},
269 };
270 MODULE_DEVICE_TABLE(of, ehci_hcd_ppc_of_match);
271
272
273 static struct of_platform_driver ehci_hcd_ppc_of_driver = {
274 .name = "ppc-of-ehci",
275 .match_table = ehci_hcd_ppc_of_match,
276 .probe = ehci_hcd_ppc_of_probe,
277 .remove = ehci_hcd_ppc_of_remove,
278 .shutdown = ehci_hcd_ppc_of_shutdown,
279 .driver = {
280 .name = "ppc-of-ehci",
281 .owner = THIS_MODULE,
282 },
283 };
284