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#include <linux/of_platform.h>
18
19#include <asm/prom.h>
20
21
22static int __devinit
23ohci_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
40static 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#ifdef	CONFIG_PM
76	.bus_suspend =		ohci_bus_suspend,
77	.bus_resume =		ohci_bus_resume,
78#endif
79	.start_port_reset =	ohci_start_port_reset,
80};
81
82
83static int __devinit ohci_hcd_ppc_of_probe(struct platform_device *op)
84{
85	struct device_node *dn = op->dev.of_node;
86	struct usb_hcd *hcd;
87	struct ohci_hcd	*ohci;
88	struct resource res;
89	int irq;
90
91	int rv;
92	int is_bigendian;
93	struct device_node *np;
94
95	if (usb_disabled())
96		return -ENODEV;
97
98	is_bigendian =
99		of_device_is_compatible(dn, "ohci-bigendian") ||
100		of_device_is_compatible(dn, "ohci-be");
101
102	dev_dbg(&op->dev, "initializing PPC-OF USB Controller\n");
103
104	rv = of_address_to_resource(dn, 0, &res);
105	if (rv)
106		return rv;
107
108	hcd = usb_create_hcd(&ohci_ppc_of_hc_driver, &op->dev, "PPC-OF USB");
109	if (!hcd)
110		return -ENOMEM;
111
112	hcd->rsrc_start = res.start;
113	hcd->rsrc_len = resource_size(&res);
114
115	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
116		printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
117		rv = -EBUSY;
118		goto err_rmr;
119	}
120
121	irq = irq_of_parse_and_map(dn, 0);
122	if (irq == NO_IRQ) {
123		printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
124		rv = -EBUSY;
125		goto err_irq;
126	}
127
128	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
129	if (!hcd->regs) {
130		printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
131		rv = -ENOMEM;
132		goto err_ioremap;
133	}
134
135	ohci = hcd_to_ohci(hcd);
136	if (is_bigendian) {
137		ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;
138		if (of_device_is_compatible(dn, "fsl,mpc5200-ohci"))
139			ohci->flags |= OHCI_QUIRK_FRAME_NO;
140		if (of_device_is_compatible(dn, "mpc5200-ohci"))
141			ohci->flags |= OHCI_QUIRK_FRAME_NO;
142	}
143
144	ohci_hcd_init(ohci);
145
146	rv = usb_add_hcd(hcd, irq, 0);
147	if (rv == 0)
148		return 0;
149
150	/* by now, 440epx is known to show usb_23 erratum */
151	np = of_find_compatible_node(NULL, NULL, "ibm,usb-ehci-440epx");
152
153	/* Work around - At this point ohci_run has executed, the
154	* controller is running, everything, the root ports, etc., is
155	* set up.  If the ehci driver is loaded, put the ohci core in
156	* the suspended state.  The ehci driver will bring it out of
157	* suspended state when / if a non-high speed USB device is
158	* attached to the USB Host port.  If the ehci driver is not
159	* loaded, do nothing. request_mem_region is used to test if
160	* the ehci driver is loaded.
161	*/
162	if (np !=  NULL) {
163		if (!of_address_to_resource(np, 0, &res)) {
164			if (!request_mem_region(res.start, 0x4, hcd_name)) {
165				writel_be((readl_be(&ohci->regs->control) |
166					OHCI_USB_SUSPEND), &ohci->regs->control);
167					(void) readl_be(&ohci->regs->control);
168			} else
169				release_mem_region(res.start, 0x4);
170		} else
171			pr_debug("%s: cannot get ehci offset from fdt\n", __FILE__);
172	}
173
174	iounmap(hcd->regs);
175err_ioremap:
176	irq_dispose_mapping(irq);
177err_irq:
178	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
179err_rmr:
180 	usb_put_hcd(hcd);
181
182	return rv;
183}
184
185static int ohci_hcd_ppc_of_remove(struct platform_device *op)
186{
187	struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
188	dev_set_drvdata(&op->dev, NULL);
189
190	dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
191
192	usb_remove_hcd(hcd);
193
194	iounmap(hcd->regs);
195	irq_dispose_mapping(hcd->irq);
196	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
197
198	usb_put_hcd(hcd);
199
200	return 0;
201}
202
203static void ohci_hcd_ppc_of_shutdown(struct platform_device *op)
204{
205	struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
206
207        if (hcd->driver->shutdown)
208                hcd->driver->shutdown(hcd);
209}
210
211
212static const struct of_device_id ohci_hcd_ppc_of_match[] = {
213#ifdef CONFIG_USB_OHCI_HCD_PPC_OF_BE
214	{
215		.name = "usb",
216		.compatible = "ohci-bigendian",
217	},
218	{
219		.name = "usb",
220		.compatible = "ohci-be",
221	},
222#endif
223#ifdef CONFIG_USB_OHCI_HCD_PPC_OF_LE
224	{
225		.name = "usb",
226		.compatible = "ohci-littledian",
227	},
228	{
229		.name = "usb",
230		.compatible = "ohci-le",
231	},
232#endif
233	{},
234};
235MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match);
236
237#if	!defined(CONFIG_USB_OHCI_HCD_PPC_OF_BE) && \
238	!defined(CONFIG_USB_OHCI_HCD_PPC_OF_LE)
239#error "No endianess selected for ppc-of-ohci"
240#endif
241
242
243static struct platform_driver ohci_hcd_ppc_of_driver = {
244	.probe		= ohci_hcd_ppc_of_probe,
245	.remove		= ohci_hcd_ppc_of_remove,
246	.shutdown 	= ohci_hcd_ppc_of_shutdown,
247	.driver = {
248		.name = "ppc-of-ohci",
249		.owner = THIS_MODULE,
250		.of_match_table = ohci_hcd_ppc_of_match,
251	},
252};
253
254