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 *
8 * Bus Glue for AMD Alchemy Au1xxx
9 *
10 * Written by Christopher Hoover <ch@hpl.hp.com>
11 * Based on fragments of previous driver by Russell King et al.
12 *
13 * Modified for LH7A404 from ohci-sa1111.c
14 *  by Durgesh Pattamatta <pattamattad@sharpsec.com>
15 * Modified for AMD Alchemy Au1xxx
16 *  by Matt Porter <mporter@kernel.crashing.org>
17 *
18 * This file is licenced under the GPL.
19 */
20
21#include <linux/platform_device.h>
22#include <linux/signal.h>
23
24#include <asm/mach-au1x00/au1000.h>
25
26
27extern int usb_disabled(void);
28
29static int __devinit ohci_au1xxx_start(struct usb_hcd *hcd)
30{
31	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);
32	int ret;
33
34	ohci_dbg(ohci, "ohci_au1xxx_start, ohci:%p", ohci);
35
36	if ((ret = ohci_init(ohci)) < 0)
37		return ret;
38
39	if ((ret = ohci_run(ohci)) < 0) {
40		err ("can't start %s", hcd->self.bus_name);
41		ohci_stop(hcd);
42		return ret;
43	}
44
45	return 0;
46}
47
48static const struct hc_driver ohci_au1xxx_hc_driver = {
49	.description =		hcd_name,
50	.product_desc =		"Au1xxx OHCI",
51	.hcd_priv_size =	sizeof(struct ohci_hcd),
52
53	/*
54	 * generic hardware linkage
55	 */
56	.irq =			ohci_irq,
57	.flags =		HCD_USB11 | HCD_MEMORY,
58
59	/*
60	 * basic lifecycle operations
61	 */
62	.start =		ohci_au1xxx_start,
63	.stop =			ohci_stop,
64	.shutdown =		ohci_shutdown,
65
66	/*
67	 * managing i/o requests and associated device resources
68	 */
69	.urb_enqueue =		ohci_urb_enqueue,
70	.urb_dequeue =		ohci_urb_dequeue,
71	.endpoint_disable =	ohci_endpoint_disable,
72
73	/*
74	 * scheduling support
75	 */
76	.get_frame_number =	ohci_get_frame,
77
78	/*
79	 * root hub support
80	 */
81	.hub_status_data =	ohci_hub_status_data,
82	.hub_control =		ohci_hub_control,
83#ifdef	CONFIG_PM
84	.bus_suspend =		ohci_bus_suspend,
85	.bus_resume =		ohci_bus_resume,
86#endif
87	.start_port_reset =	ohci_start_port_reset,
88};
89
90static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
91{
92	int ret, unit;
93	struct usb_hcd *hcd;
94
95	if (usb_disabled())
96		return -ENODEV;
97
98	if (pdev->resource[1].flags != IORESOURCE_IRQ) {
99		pr_debug("resource[1] is not IORESOURCE_IRQ\n");
100		return -ENOMEM;
101	}
102
103	hcd = usb_create_hcd(&ohci_au1xxx_hc_driver, &pdev->dev, "au1xxx");
104	if (!hcd)
105		return -ENOMEM;
106
107	hcd->rsrc_start = pdev->resource[0].start;
108	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
109
110	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
111		pr_debug("request_mem_region failed\n");
112		ret = -EBUSY;
113		goto err1;
114	}
115
116	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
117	if (!hcd->regs) {
118		pr_debug("ioremap failed\n");
119		ret = -ENOMEM;
120		goto err2;
121	}
122
123	unit = (hcd->rsrc_start == AU1300_USB_OHCI1_PHYS_ADDR) ?
124			ALCHEMY_USB_OHCI1 : ALCHEMY_USB_OHCI0;
125	if (alchemy_usb_control(unit, 1)) {
126		printk(KERN_INFO "%s: controller init failed!\n", pdev->name);
127		ret = -ENODEV;
128		goto err3;
129	}
130
131	ohci_hcd_init(hcd_to_ohci(hcd));
132
133	ret = usb_add_hcd(hcd, pdev->resource[1].start,
134			  IRQF_SHARED);
135	if (ret == 0) {
136		platform_set_drvdata(pdev, hcd);
137		return ret;
138	}
139
140	alchemy_usb_control(unit, 0);
141err3:
142	iounmap(hcd->regs);
143err2:
144	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
145err1:
146	usb_put_hcd(hcd);
147	return ret;
148}
149
150static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
151{
152	struct usb_hcd *hcd = platform_get_drvdata(pdev);
153	int unit;
154
155	unit = (hcd->rsrc_start == AU1300_USB_OHCI1_PHYS_ADDR) ?
156			ALCHEMY_USB_OHCI1 : ALCHEMY_USB_OHCI0;
157	usb_remove_hcd(hcd);
158	alchemy_usb_control(unit, 0);
159	iounmap(hcd->regs);
160	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
161	usb_put_hcd(hcd);
162	platform_set_drvdata(pdev, NULL);
163
164	return 0;
165}
166
167#ifdef CONFIG_PM
168static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
169{
170	struct usb_hcd *hcd = dev_get_drvdata(dev);
171	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);
172	unsigned long flags;
173	int rc;
174
175	rc = 0;
176
177	/* Root hub was already suspended. Disable irq emission and
178	 * mark HW unaccessible, bail out if RH has been resumed. Use
179	 * the spinlock to properly synchronize with possible pending
180	 * RH suspend or resume activity.
181	 */
182	spin_lock_irqsave(&ohci->lock, flags);
183	if (ohci->rh_state != OHCI_RH_SUSPENDED) {
184		rc = -EINVAL;
185		goto bail;
186	}
187	ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
188	(void)ohci_readl(ohci, &ohci->regs->intrdisable);
189
190	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
191
192	alchemy_usb_control(ALCHEMY_USB_OHCI0, 0);
193bail:
194	spin_unlock_irqrestore(&ohci->lock, flags);
195
196	return rc;
197}
198
199static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
200{
201	struct usb_hcd *hcd = dev_get_drvdata(dev);
202
203	alchemy_usb_control(ALCHEMY_USB_OHCI0, 1);
204
205	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
206	ohci_finish_controller_resume(hcd);
207
208	return 0;
209}
210
211static const struct dev_pm_ops au1xxx_ohci_pmops = {
212	.suspend	= ohci_hcd_au1xxx_drv_suspend,
213	.resume		= ohci_hcd_au1xxx_drv_resume,
214};
215
216#define AU1XXX_OHCI_PMOPS &au1xxx_ohci_pmops
217
218#else
219#define AU1XXX_OHCI_PMOPS NULL
220#endif
221
222static struct platform_driver ohci_hcd_au1xxx_driver = {
223	.probe		= ohci_hcd_au1xxx_drv_probe,
224	.remove		= ohci_hcd_au1xxx_drv_remove,
225	.shutdown	= usb_hcd_platform_shutdown,
226	.driver		= {
227		.name	= "au1xxx-ohci",
228		.owner	= THIS_MODULE,
229		.pm	= AU1XXX_OHCI_PMOPS,
230	},
231};
232
233MODULE_ALIAS("platform:au1xxx-ohci");
234