1// SPDX-License-Identifier: GPL-2.0
  2/*
  3* Driver for EHCI HCD on SPEAr SOC
  4*
  5* Copyright (C) 2010 ST Micro Electronics,
  6* Deepak Sikri <deepak.sikri@st.com>
  7*
  8* Based on various ehci-*.c drivers
 
 
 
 
  9*/
 10
 11#include <linux/clk.h>
 12#include <linux/dma-mapping.h>
 13#include <linux/io.h>
 14#include <linux/jiffies.h>
 15#include <linux/kernel.h>
 16#include <linux/module.h>
 17#include <linux/of.h>
 18#include <linux/platform_device.h>
 19#include <linux/pm.h>
 20#include <linux/usb.h>
 21#include <linux/usb/hcd.h>
 22
 23#include "ehci.h"
 24
 25#define DRIVER_DESC "EHCI SPEAr driver"
 26
 27struct spear_ehci {
 
 28	struct clk *clk;
 29};
 30
 31#define to_spear_ehci(hcd)	(struct spear_ehci *)(hcd_to_ehci(hcd)->priv)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 32
 33static struct hc_driver __read_mostly ehci_spear_hc_driver;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 34
 35static int __maybe_unused ehci_spear_drv_suspend(struct device *dev)
 
 36{
 37	struct usb_hcd *hcd = dev_get_drvdata(dev);
 38	bool do_wakeup = device_may_wakeup(dev);
 
 
 39
 40	return ehci_suspend(hcd, do_wakeup);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 41}
 42
 43static int __maybe_unused ehci_spear_drv_resume(struct device *dev)
 44{
 45	struct usb_hcd *hcd = dev_get_drvdata(dev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 46
 47	ehci_resume(hcd, false);
 
 48	return 0;
 49}
 
 50
 51static SIMPLE_DEV_PM_OPS(ehci_spear_pm_ops, ehci_spear_drv_suspend,
 52		ehci_spear_drv_resume);
 53
 
 
 54static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
 55{
 56	struct usb_hcd *hcd ;
 57	struct spear_ehci *sehci;
 58	struct resource *res;
 59	struct clk *usbh_clk;
 60	const struct hc_driver *driver = &ehci_spear_hc_driver;
 61	int irq, retval;
 
 
 62
 63	if (usb_disabled())
 64		return -ENODEV;
 65
 66	irq = platform_get_irq(pdev, 0);
 67	if (irq < 0) {
 68		retval = irq;
 69		goto fail;
 70	}
 71
 72	/*
 73	 * Right now device-tree probed devices don't get dma_mask set.
 74	 * Since shared usb code relies on it, set it here for now.
 75	 * Once we have dma capability bindings this can go away.
 76	 */
 77	retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 78	if (retval)
 79		goto fail;
 80
 81	usbh_clk = devm_clk_get(&pdev->dev, NULL);
 
 
 
 
 
 
 
 
 
 82	if (IS_ERR(usbh_clk)) {
 83		dev_err(&pdev->dev, "Error getting interface clock\n");
 84		retval = PTR_ERR(usbh_clk);
 85		goto fail;
 86	}
 87
 88	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
 89	if (!hcd) {
 90		retval = -ENOMEM;
 91		goto fail;
 92	}
 93
 94	hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
 95	if (IS_ERR(hcd->regs)) {
 96		retval = PTR_ERR(hcd->regs);
 97		goto err_put_hcd;
 98	}
 
 99	hcd->rsrc_start = res->start;
100	hcd->rsrc_len = resource_size(res);
 
 
 
 
 
101
102	sehci = to_spear_ehci(hcd);
103	sehci->clk = usbh_clk;
 
 
 
 
104
105	/* registers start at offset 0x0 */
106	hcd_to_ehci(hcd)->caps = hcd->regs;
107
108	clk_prepare_enable(sehci->clk);
109	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
110	if (retval)
111		goto err_stop_ehci;
112
113	device_wakeup_enable(hcd->self.controller);
114	return retval;
115
116err_stop_ehci:
117	clk_disable_unprepare(sehci->clk);
118err_put_hcd:
 
 
 
119	usb_put_hcd(hcd);
120fail:
 
 
 
121	dev_err(&pdev->dev, "init fail, %d\n", retval);
122
123	return retval ;
124}
125
126static void spear_ehci_hcd_drv_remove(struct platform_device *pdev)
127{
128	struct usb_hcd *hcd = platform_get_drvdata(pdev);
129	struct spear_ehci *sehci = to_spear_ehci(hcd);
130
 
 
 
 
131	usb_remove_hcd(hcd);
132
133	if (sehci->clk)
134		clk_disable_unprepare(sehci->clk);
 
 
135	usb_put_hcd(hcd);
 
 
 
 
 
136}
137
138static const struct of_device_id spear_ehci_id_table[] = {
139	{ .compatible = "st,spear600-ehci", },
140	{ },
141};
142MODULE_DEVICE_TABLE(of, spear_ehci_id_table);
143
144static struct platform_driver spear_ehci_hcd_driver = {
145	.probe		= spear_ehci_hcd_drv_probe,
146	.remove_new	= spear_ehci_hcd_drv_remove,
147	.shutdown	= usb_hcd_platform_shutdown,
148	.driver		= {
149		.name = "spear-ehci",
150		.bus = &platform_bus_type,
151		.pm = pm_ptr(&ehci_spear_pm_ops),
152		.of_match_table = spear_ehci_id_table,
153	}
154};
155
156static const struct ehci_driver_overrides spear_overrides __initconst = {
157	.extra_priv_size = sizeof(struct spear_ehci),
158};
159
160static int __init ehci_spear_init(void)
161{
162	if (usb_disabled())
163		return -ENODEV;
164
165	ehci_init_driver(&ehci_spear_hc_driver, &spear_overrides);
166	return platform_driver_register(&spear_ehci_hcd_driver);
167}
168module_init(ehci_spear_init);
169
170static void __exit ehci_spear_cleanup(void)
171{
172	platform_driver_unregister(&spear_ehci_hcd_driver);
173}
174module_exit(ehci_spear_cleanup);
175
176MODULE_DESCRIPTION(DRIVER_DESC);
177MODULE_ALIAS("platform:spear-ehci");
178MODULE_AUTHOR("Deepak Sikri");
179MODULE_LICENSE("GPL");

 
  1/*
  2* Driver for EHCI HCD on SPEAR SOC
  3*
  4* Copyright (C) 2010 ST Micro Electronics,
  5* Deepak Sikri <deepak.sikri@st.com>
  6*
  7* Based on various ehci-*.c drivers
  8*
  9* This file is subject to the terms and conditions of the GNU General Public
 10* License. See the file COPYING in the main directory of this archive for
 11* more details.
 12*/
 13
 14#include <linux/clk.h>
 
 
 15#include <linux/jiffies.h>
 
 
 16#include <linux/of.h>
 17#include <linux/platform_device.h>
 18#include <linux/pm.h>
 
 
 
 
 
 
 19
 20struct spear_ehci {
 21	struct ehci_hcd ehci;
 22	struct clk *clk;
 23};
 24
 25#define to_spear_ehci(hcd)	(struct spear_ehci *)hcd_to_ehci(hcd)
 26
 27static void spear_start_ehci(struct spear_ehci *ehci)
 28{
 29	clk_prepare_enable(ehci->clk);
 30}
 31
 32static void spear_stop_ehci(struct spear_ehci *ehci)
 33{
 34	clk_disable_unprepare(ehci->clk);
 35}
 36
 37static int ehci_spear_setup(struct usb_hcd *hcd)
 38{
 39	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 40	int retval = 0;
 41
 42	/* registers start at offset 0x0 */
 43	ehci->caps = hcd->regs;
 44	ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
 45				&ehci->caps->hc_capbase));
 46	/* cache this readonly data; minimize chip reads */
 47	ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 48	retval = ehci_halt(ehci);
 49	if (retval)
 50		return retval;
 51
 52	retval = ehci_init(hcd);
 53	if (retval)
 54		return retval;
 55
 56	ehci_reset(ehci);
 57	ehci_port_power(ehci, 0);
 58
 59	return retval;
 60}
 61
 62static const struct hc_driver ehci_spear_hc_driver = {
 63	.description			= hcd_name,
 64	.product_desc			= "SPEAr EHCI",
 65	.hcd_priv_size			= sizeof(struct spear_ehci),
 66
 67	/* generic hardware linkage */
 68	.irq				= ehci_irq,
 69	.flags				= HCD_MEMORY | HCD_USB2,
 70
 71	/* basic lifecycle operations */
 72	.reset				= ehci_spear_setup,
 73	.start				= ehci_run,
 74	.stop				= ehci_stop,
 75	.shutdown			= ehci_shutdown,
 76
 77	/* managing i/o requests and associated device resources */
 78	.urb_enqueue			= ehci_urb_enqueue,
 79	.urb_dequeue			= ehci_urb_dequeue,
 80	.endpoint_disable		= ehci_endpoint_disable,
 81	.endpoint_reset			= ehci_endpoint_reset,
 82
 83	/* scheduling support */
 84	.get_frame_number		= ehci_get_frame,
 85
 86	/* root hub support */
 87	.hub_status_data		= ehci_hub_status_data,
 88	.hub_control			= ehci_hub_control,
 89	.bus_suspend			= ehci_bus_suspend,
 90	.bus_resume			= ehci_bus_resume,
 91	.relinquish_port		= ehci_relinquish_port,
 92	.port_handed_over		= ehci_port_handed_over,
 93	.clear_tt_buffer_complete	= ehci_clear_tt_buffer_complete,
 94};
 95
 96#ifdef CONFIG_PM
 97static int ehci_spear_drv_suspend(struct device *dev)
 98{
 99	struct usb_hcd *hcd = dev_get_drvdata(dev);
100	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
101	unsigned long flags;
102	int rc = 0;
103
104	if (time_before(jiffies, ehci->next_statechange))
105		msleep(10);
106
107	/*
108	 * Root hub was already suspended. Disable irq emission and mark HW
109	 * unaccessible. The PM and USB cores make sure that the root hub is
110	 * either suspended or stopped.
111	 */
112	spin_lock_irqsave(&ehci->lock, flags);
113	ehci_prepare_ports_for_controller_suspend(ehci, device_may_wakeup(dev));
114	ehci_writel(ehci, 0, &ehci->regs->intr_enable);
115	ehci_readl(ehci, &ehci->regs->intr_enable);
116	spin_unlock_irqrestore(&ehci->lock, flags);
117
118	return rc;
119}
120
121static int ehci_spear_drv_resume(struct device *dev)
122{
123	struct usb_hcd *hcd = dev_get_drvdata(dev);
124	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
125
126	if (time_before(jiffies, ehci->next_statechange))
127		msleep(100);
128
129	if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
130		int mask = INTR_MASK;
131
132		ehci_prepare_ports_for_controller_resume(ehci);
133
134		if (!hcd->self.root_hub->do_remote_wakeup)
135			mask &= ~STS_PCD;
136
137		ehci_writel(ehci, mask, &ehci->regs->intr_enable);
138		ehci_readl(ehci, &ehci->regs->intr_enable);
139		return 0;
140	}
141
142	usb_root_hub_lost_power(hcd->self.root_hub);
143
144	/*
145	 * Else reset, to cope with power loss or flush-to-storage style
146	 * "resume" having let BIOS kick in during reboot.
147	 */
148	ehci_halt(ehci);
149	ehci_reset(ehci);
150
151	/* emptying the schedule aborts any urbs */
152	spin_lock_irq(&ehci->lock);
153	if (ehci->reclaim)
154		end_unlink_async(ehci);
155
156	ehci_work(ehci);
157	spin_unlock_irq(&ehci->lock);
158
159	ehci_writel(ehci, ehci->command, &ehci->regs->command);
160	ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
161	ehci_readl(ehci, &ehci->regs->command);	/* unblock posted writes */
162
163	/* here we "know" root ports should always stay powered */
164	ehci_port_power(ehci, 1);
165	return 0;
166}
167#endif /* CONFIG_PM */
168
169static SIMPLE_DEV_PM_OPS(ehci_spear_pm_ops, ehci_spear_drv_suspend,
170		ehci_spear_drv_resume);
171
172static u64 spear_ehci_dma_mask = DMA_BIT_MASK(32);
173
174static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
175{
176	struct usb_hcd *hcd ;
177	struct spear_ehci *ehci;
178	struct resource *res;
179	struct clk *usbh_clk;
180	const struct hc_driver *driver = &ehci_spear_hc_driver;
181	int irq, retval;
182	char clk_name[20] = "usbh_clk";
183	static int instance = -1;
184
185	if (usb_disabled())
186		return -ENODEV;
187
188	irq = platform_get_irq(pdev, 0);
189	if (irq < 0) {
190		retval = irq;
191		goto fail_irq_get;
192	}
193
194	/*
195	 * Right now device-tree probed devices don't get dma_mask set.
196	 * Since shared usb code relies on it, set it here for now.
197	 * Once we have dma capability bindings this can go away.
198	 */
199	if (!pdev->dev.dma_mask)
200		pdev->dev.dma_mask = &spear_ehci_dma_mask;
 
201
202	/*
203	 * Increment the device instance, when probing via device-tree
204	 */
205	if (pdev->id < 0)
206		instance++;
207	else
208		instance = pdev->id;
209	sprintf(clk_name, "usbh.%01d_clk", instance);
210
211	usbh_clk = clk_get(NULL, clk_name);
212	if (IS_ERR(usbh_clk)) {
213		dev_err(&pdev->dev, "Error getting interface clock\n");
214		retval = PTR_ERR(usbh_clk);
215		goto fail_get_usbh_clk;
216	}
217
218	hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
219	if (!hcd) {
220		retval = -ENOMEM;
221		goto fail_create_hcd;
222	}
223
224	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
225	if (!res) {
226		retval = -ENODEV;
227		goto fail_request_resource;
228	}
229
230	hcd->rsrc_start = res->start;
231	hcd->rsrc_len = resource_size(res);
232	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
233				driver->description)) {
234		retval = -EBUSY;
235		goto fail_request_resource;
236	}
237
238	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
239	if (hcd->regs == NULL) {
240		dev_dbg(&pdev->dev, "error mapping memory\n");
241		retval = -ENOMEM;
242		goto fail_ioremap;
243	}
244
245	ehci = (struct spear_ehci *)hcd_to_ehci(hcd);
246	ehci->clk = usbh_clk;
247
248	spear_start_ehci(ehci);
249	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
250	if (retval)
251		goto fail_add_hcd;
252
 
253	return retval;
254
255fail_add_hcd:
256	spear_stop_ehci(ehci);
257	iounmap(hcd->regs);
258fail_ioremap:
259	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
260fail_request_resource:
261	usb_put_hcd(hcd);
262fail_create_hcd:
263	clk_put(usbh_clk);
264fail_get_usbh_clk:
265fail_irq_get:
266	dev_err(&pdev->dev, "init fail, %d\n", retval);
267
268	return retval ;
269}
270
271static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)
272{
273	struct usb_hcd *hcd = platform_get_drvdata(pdev);
274	struct spear_ehci *ehci_p = to_spear_ehci(hcd);
275
276	if (!hcd)
277		return 0;
278	if (in_interrupt())
279		BUG();
280	usb_remove_hcd(hcd);
281
282	if (ehci_p->clk)
283		spear_stop_ehci(ehci_p);
284	iounmap(hcd->regs);
285	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
286	usb_put_hcd(hcd);
287
288	if (ehci_p->clk)
289		clk_put(ehci_p->clk);
290
291	return 0;
292}
293
294static struct of_device_id spear_ehci_id_table[] __devinitdata = {
295	{ .compatible = "st,spear600-ehci", },
296	{ },
297};
 
298
299static struct platform_driver spear_ehci_hcd_driver = {
300	.probe		= spear_ehci_hcd_drv_probe,
301	.remove		= spear_ehci_hcd_drv_remove,
302	.shutdown	= usb_hcd_platform_shutdown,
303	.driver		= {
304		.name = "spear-ehci",
305		.bus = &platform_bus_type,
306		.pm = &ehci_spear_pm_ops,
307		.of_match_table = of_match_ptr(spear_ehci_id_table),
308	}
309};
310
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
311MODULE_ALIAS("platform:spear-ehci");