xref: /linux/drivers/usb/host/ehci-sh.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
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 = irq;
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 	hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
99 	if (IS_ERR(hcd->regs)) {
100 		ret = PTR_ERR(hcd->regs);
101 		goto fail_request_resource;
102 	}
103 	hcd->rsrc_start = res->start;
104 	hcd->rsrc_len = resource_size(res);
105 
106 	priv = devm_kzalloc(&pdev->dev, sizeof(struct ehci_sh_priv),
107 			    GFP_KERNEL);
108 	if (!priv) {
109 		ret = -ENOMEM;
110 		goto fail_request_resource;
111 	}
112 
113 	/* These are optional, we don't care if they fail */
114 	priv->fclk = devm_clk_get(&pdev->dev, "usb_fck");
115 	if (IS_ERR(priv->fclk))
116 		priv->fclk = NULL;
117 
118 	priv->iclk = devm_clk_get(&pdev->dev, "usb_ick");
119 	if (IS_ERR(priv->iclk))
120 		priv->iclk = NULL;
121 
122 	clk_enable(priv->fclk);
123 	clk_enable(priv->iclk);
124 
125 	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
126 	if (ret != 0) {
127 		dev_err(&pdev->dev, "Failed to add hcd");
128 		goto fail_add_hcd;
129 	}
130 	device_wakeup_enable(hcd->self.controller);
131 
132 	priv->hcd = hcd;
133 	platform_set_drvdata(pdev, priv);
134 
135 	return ret;
136 
137 fail_add_hcd:
138 	clk_disable(priv->iclk);
139 	clk_disable(priv->fclk);
140 
141 fail_request_resource:
142 	usb_put_hcd(hcd);
143 fail_create_hcd:
144 	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
145 
146 	return ret;
147 }
148 
ehci_hcd_sh_remove(struct platform_device * pdev)149 static void ehci_hcd_sh_remove(struct platform_device *pdev)
150 {
151 	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
152 	struct usb_hcd *hcd = priv->hcd;
153 
154 	usb_remove_hcd(hcd);
155 	usb_put_hcd(hcd);
156 
157 	clk_disable(priv->fclk);
158 	clk_disable(priv->iclk);
159 }
160 
ehci_hcd_sh_shutdown(struct platform_device * pdev)161 static void ehci_hcd_sh_shutdown(struct platform_device *pdev)
162 {
163 	struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
164 	struct usb_hcd *hcd = priv->hcd;
165 
166 	if (hcd->driver->shutdown)
167 		hcd->driver->shutdown(hcd);
168 }
169 
170 static struct platform_driver ehci_hcd_sh_driver = {
171 	.probe		= ehci_hcd_sh_probe,
172 	.remove_new	= ehci_hcd_sh_remove,
173 	.shutdown	= ehci_hcd_sh_shutdown,
174 	.driver		= {
175 		.name	= "sh_ehci",
176 	},
177 };
178 
179 MODULE_ALIAS("platform:sh_ehci");
180