PageRenderTime 28ms CodeModel.GetById 14ms app.highlight 11ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/usb/host/ehci-ppc-of.c

https://gitlab.com/stalker-android/linux-omap3
C | 287 lines | 192 code | 57 blank | 38 comment | 27 complexity | 2b6d23697b292c42064f9588e0426c02 MD5 | raw file
  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 */
 21static 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
 39static 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	.endpoint_reset		= ehci_endpoint_reset,
 65
 66	/*
 67	 * scheduling support
 68	 */
 69	.get_frame_number	= ehci_get_frame,
 70
 71	/*
 72	 * root hub support
 73	 */
 74	.hub_status_data	= ehci_hub_status_data,
 75	.hub_control		= ehci_hub_control,
 76#ifdef	CONFIG_PM
 77	.bus_suspend		= ehci_bus_suspend,
 78	.bus_resume		= ehci_bus_resume,
 79#endif
 80	.relinquish_port	= ehci_relinquish_port,
 81	.port_handed_over	= ehci_port_handed_over,
 82
 83	.clear_tt_buffer_complete	= ehci_clear_tt_buffer_complete,
 84};
 85
 86
 87/*
 88 * 440EPx Errata USBH_3
 89 * Fix: Enable Break Memory Transfer (BMT) in INSNREG3
 90 */
 91#define PPC440EPX_EHCI0_INSREG_BMT	(0x1 << 0)
 92static int __devinit
 93ppc44x_enable_bmt(struct device_node *dn)
 94{
 95	__iomem u32 *insreg_virt;
 96
 97	insreg_virt = of_iomap(dn, 1);
 98	if (!insreg_virt)
 99		return  -EINVAL;
100
101	out_be32(insreg_virt + 3, PPC440EPX_EHCI0_INSREG_BMT);
102
103	iounmap(insreg_virt);
104	return 0;
105}
106
107
108static int __devinit
109ehci_hcd_ppc_of_probe(struct platform_device *op, const struct of_device_id *match)
110{
111	struct device_node *dn = op->dev.of_node;
112	struct usb_hcd *hcd;
113	struct ehci_hcd	*ehci = NULL;
114	struct resource res;
115	int irq;
116	int rv;
117
118	struct device_node *np;
119
120	if (usb_disabled())
121		return -ENODEV;
122
123	dev_dbg(&op->dev, "initializing PPC-OF USB Controller\n");
124
125	rv = of_address_to_resource(dn, 0, &res);
126	if (rv)
127		return rv;
128
129	hcd = usb_create_hcd(&ehci_ppc_of_hc_driver, &op->dev, "PPC-OF USB");
130	if (!hcd)
131		return -ENOMEM;
132
133	hcd->rsrc_start = res.start;
134	hcd->rsrc_len = res.end - res.start + 1;
135
136	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
137		printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
138		rv = -EBUSY;
139		goto err_rmr;
140	}
141
142	irq = irq_of_parse_and_map(dn, 0);
143	if (irq == NO_IRQ) {
144		printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
145		rv = -EBUSY;
146		goto err_irq;
147	}
148
149	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
150	if (!hcd->regs) {
151		printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
152		rv = -ENOMEM;
153		goto err_ioremap;
154	}
155
156	ehci = hcd_to_ehci(hcd);
157	np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
158	if (np != NULL) {
159		/* claim we really affected by usb23 erratum */
160		if (!of_address_to_resource(np, 0, &res))
161			ehci->ohci_hcctrl_reg = ioremap(res.start +
162					OHCI_HCCTRL_OFFSET, OHCI_HCCTRL_LEN);
163		else
164			pr_debug("%s: no ohci offset in fdt\n", __FILE__);
165		if (!ehci->ohci_hcctrl_reg) {
166			pr_debug("%s: ioremap for ohci hcctrl failed\n", __FILE__);
167		} else {
168			ehci->has_amcc_usb23 = 1;
169		}
170	}
171
172	if (of_get_property(dn, "big-endian", NULL)) {
173		ehci->big_endian_mmio = 1;
174		ehci->big_endian_desc = 1;
175	}
176	if (of_get_property(dn, "big-endian-regs", NULL))
177		ehci->big_endian_mmio = 1;
178	if (of_get_property(dn, "big-endian-desc", NULL))
179		ehci->big_endian_desc = 1;
180
181	ehci->caps = hcd->regs;
182	ehci->regs = hcd->regs +
183			HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
184
185	/* cache this readonly data; minimize chip reads */
186	ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
187
188	if (of_device_is_compatible(dn, "ibm,usb-ehci-440epx")) {
189		rv = ppc44x_enable_bmt(dn);
190		ehci_dbg(ehci, "Break Memory Transfer (BMT) is %senabled!\n",
191				rv ? "NOT ": "");
192	}
193
194	rv = usb_add_hcd(hcd, irq, 0);
195	if (rv)
196		goto err_ehci;
197
198	return 0;
199
200err_ehci:
201	if (ehci->has_amcc_usb23)
202		iounmap(ehci->ohci_hcctrl_reg);
203	iounmap(hcd->regs);
204err_ioremap:
205	irq_dispose_mapping(irq);
206err_irq:
207	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
208err_rmr:
209	usb_put_hcd(hcd);
210
211	return rv;
212}
213
214
215static int ehci_hcd_ppc_of_remove(struct platform_device *op)
216{
217	struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
218	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
219
220	struct device_node *np;
221	struct resource res;
222
223	dev_set_drvdata(&op->dev, NULL);
224
225	dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
226
227	usb_remove_hcd(hcd);
228
229	iounmap(hcd->regs);
230	irq_dispose_mapping(hcd->irq);
231	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
232
233	/* use request_mem_region to test if the ohci driver is loaded.  if so
234	 * ensure the ohci core is operational.
235	 */
236	if (ehci->has_amcc_usb23) {
237		np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
238		if (np != NULL) {
239			if (!of_address_to_resource(np, 0, &res))
240				if (!request_mem_region(res.start,
241							    0x4, hcd_name))
242					set_ohci_hcfs(ehci, 1);
243				else
244					release_mem_region(res.start, 0x4);
245			else
246				pr_debug("%s: no ohci offset in fdt\n", __FILE__);
247			of_node_put(np);
248		}
249
250		iounmap(ehci->ohci_hcctrl_reg);
251	}
252	usb_put_hcd(hcd);
253
254	return 0;
255}
256
257
258static int ehci_hcd_ppc_of_shutdown(struct platform_device *op)
259{
260	struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
261
262	if (hcd->driver->shutdown)
263		hcd->driver->shutdown(hcd);
264
265	return 0;
266}
267
268
269static const struct of_device_id ehci_hcd_ppc_of_match[] = {
270	{
271		.compatible = "usb-ehci",
272	},
273	{},
274};
275MODULE_DEVICE_TABLE(of, ehci_hcd_ppc_of_match);
276
277
278static struct of_platform_driver ehci_hcd_ppc_of_driver = {
279	.probe		= ehci_hcd_ppc_of_probe,
280	.remove		= ehci_hcd_ppc_of_remove,
281	.shutdown	= ehci_hcd_ppc_of_shutdown,
282	.driver = {
283		.name = "ppc-of-ehci",
284		.owner = THIS_MODULE,
285		.of_match_table = ehci_hcd_ppc_of_match,
286	},
287};