1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * SuperH EHCI host controller driver
4  *
5  * Copyright (C) 2010  Paul Mundt
6  *
7  * Based on ohci-sh.c and ehci-atmel.c.
8  */
9 #include <linux/platform_device.h>
10 #include <linux/clk.h>
11 
12 struct ehci_sh_priv {
13 	struct clk *iclk, *fclk;
14 	struct usb_hcd *hcd;
15 };
16 
ehci_sh_reset(struct usb_hcd * hcd)17 static int ehci_sh_reset(struct usb_hcd *hcd)
18 {
19 	struct ehci_hcd	*ehci = hcd_to_ehci(hcd);
20 
21 	ehci->caps = hcd->regs;
22 
23 	return ehci_setup(hcd);
24 }
25 
26 static const struct hc_driver ehci_sh_hc_driver = {
27 	.description			= hcd_name,
28 	.product_desc			= "SuperH EHCI",
29 	.hcd_priv_size			= sizeof(struct ehci_hcd),
30 
31 	/*
32 	 * generic hardware linkage
33 	 */
34 	.irq				= ehci_irq,
35 	.flags				= HCD_USB2 | HCD_DMA | HCD_MEMORY | HCD_BH,
36 
37 	/*
38 	 * basic lifecycle operations
39 	 */
40 	.reset				= ehci_sh_reset,
41 	.start				= ehci_run,
42 	.stop				= ehci_stop,
43 	.shutdown			= ehci_shutdown,
44 
45 	/*
46 	 * managing i/o requests and associated device resources
47 	 */
48 	.urb_enqueue			= ehci_urb_enqueue,
49 	.urb_dequeue			= ehci_urb_dequeue,
50 	.endpoint_disable		= ehci_endpoint_disable,
51 	.endpoint_reset			= ehci_endpoint_reset,
52 
53 	/*
54 	 * scheduling support
55 	 */
56 	.get_frame_number		= ehci_get_frame,
57 
58 	/*
59 	 * root hub support
60 	 */
61 	.hub_status_data		= ehci_hub_status_data,
62 	.hub_control			= ehci_hub_control,
63 
64 #ifdef CONFIG_PM
65 	.bus_suspend			= ehci_bus_suspend,
66 	.bus_resume			= ehci_bus_resume,
67 #endif
68 
69 	.relinquish_port		= ehci_relinquish_port,
70 	.port_handed_over		= ehci_port_handed_over,
71 	.clear_tt_buffer_complete	= ehci_clear_tt_buffer_complete,
72 };
73 
ehci_hcd_sh_probe(struct platform_device * pdev)74 static int ehci_hcd_sh_probe(struct platform_device *pdev)
75 {
76 	struct resource *res;
77 	struct ehci_sh_priv *priv;
78 	struct usb_hcd *hcd;
79 	int irq, ret;
80 
81 	if (usb_disabled())
82 		return -ENODEV;
83 
84 	irq = platform_get_irq(pdev, 0);
85 	if (irq <= 0) {
86 		ret = -ENODEV;
87 		goto fail_create_hcd;
88 	}
89 
90 	/* initialize hcd */
91 	hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
92 			     dev_name(&pdev->dev));
93 	if (!hcd) {
94 		ret = -ENOMEM;
95 		goto fail_create_hcd;
96 	}
97 
98 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
99 	hcd->regs = devm_ioremap_resource(&pdev->dev, res);
100 	if (IS_ERR(hcd->regs)) {
101 		ret = PTR_ERR(hcd->regs);
102 		goto fail_request_resource;
103 	}
104 	hcd->rsrc_start = res->start;
105 	hcd->rsrc_len = resource_size(res);
106 
107 	priv = devm_kzalloc(&pdev->dev, sizeof(struct ehci_sh_priv),
108 			    GFP_KERNEL);
109 	if (!priv) {
110 		ret = -ENOMEM;
111 		goto fail_request_resource;
112 	}
113 
114 	/* These are optional, we don't care if they fail */
115 	priv->fclk = devm_clk_get(&pdev->dev, "usb_fck");
116 	if (IS_ERR(priv->fclk))
117 		priv->fclk = NULL;
118 
119 	priv->iclk = devm_clk_get(&pdev->dev, "usb_ick");
120 	if (IS_ERR(priv->iclk))
121 		priv->iclk = NULL;
122 
123 	clk_enable(priv->fclk);
124 	clk_enable(priv->iclk);
125 
126 	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
127 	if (ret != 0) {
128 		dev_err(&pdev->dev, "Failed to add hcd");
129 		goto fail_add_hcd;
130 	}
131 	device_wakeup_enable(hcd->self.controller);
132 
133 	priv->hcd = hcd;
134 	platform_set_drvdata(pdev, priv);
135 
136 	return ret;
137 
138 fail_add_hcd:
139 	clk_disable(priv->iclk);
140 	clk_disable(priv->fclk);
141 
142 fail_request_resource:
143 	usb_put_hcd(hcd);
144 fail_create_hcd:
145 	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
146 
147 	return ret;
148 }
149 
ehci_hcd_sh_remove(struct platform_device * pdev)150 static int ehci_hcd_sh_remove(struct platform_device *pdev)
151 {
152 	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
153 	struct usb_hcd *hcd = priv->hcd;
154 
155 	usb_remove_hcd(hcd);
156 	usb_put_hcd(hcd);
157 
158 	clk_disable(priv->fclk);
159 	clk_disable(priv->iclk);
160 
161 	return 0;
162 }
163 
ehci_hcd_sh_shutdown(struct platform_device * pdev)164 static void ehci_hcd_sh_shutdown(struct platform_device *pdev)
165 {
166 	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
167 	struct usb_hcd *hcd = priv->hcd;
168 
169 	if (hcd->driver->shutdown)
170 		hcd->driver->shutdown(hcd);
171 }
172 
173 static struct platform_driver ehci_hcd_sh_driver = {
174 	.probe		= ehci_hcd_sh_probe,
175 	.remove		= ehci_hcd_sh_remove,
176 	.shutdown	= ehci_hcd_sh_shutdown,
177 	.driver		= {
178 		.name	= "sh_ehci",
179 	},
180 };
181 
182 MODULE_ALIAS("platform:sh_ehci");
183