2 * SuperH EHCI host controller driver
4 * Copyright (C) 2010 Paul Mundt
6 * Based on ohci-sh.c and ehci-atmel.c.
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
12 #include <linux/platform_device.h>
13 #include <linux/clk.h>
14 #include <linux/platform_data/ehci-sh.h>
17 struct clk
*iclk
, *fclk
;
21 static int ehci_sh_reset(struct usb_hcd
*hcd
)
23 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
26 ehci
->caps
= hcd
->regs
;
27 ehci
->regs
= hcd
->regs
+ HC_LENGTH(ehci
, ehci_readl(ehci
,
28 &ehci
->caps
->hc_capbase
));
30 dbg_hcs_params(ehci
, "reset");
31 dbg_hcc_params(ehci
, "reset");
33 ehci
->hcs_params
= ehci_readl(ehci
, &ehci
->caps
->hcs_params
);
35 ret
= ehci_halt(ehci
);
46 ehci_port_power(ehci
, 0);
51 static const struct hc_driver ehci_sh_hc_driver
= {
52 .description
= hcd_name
,
53 .product_desc
= "SuperH EHCI",
54 .hcd_priv_size
= sizeof(struct ehci_hcd
),
57 * generic hardware linkage
60 .flags
= HCD_USB2
| HCD_MEMORY
,
63 * basic lifecycle operations
65 .reset
= ehci_sh_reset
,
68 .shutdown
= ehci_shutdown
,
71 * managing i/o requests and associated device resources
73 .urb_enqueue
= ehci_urb_enqueue
,
74 .urb_dequeue
= ehci_urb_dequeue
,
75 .endpoint_disable
= ehci_endpoint_disable
,
76 .endpoint_reset
= ehci_endpoint_reset
,
81 .get_frame_number
= ehci_get_frame
,
86 .hub_status_data
= ehci_hub_status_data
,
87 .hub_control
= ehci_hub_control
,
90 .bus_suspend
= ehci_bus_suspend
,
91 .bus_resume
= ehci_bus_resume
,
94 .relinquish_port
= ehci_relinquish_port
,
95 .port_handed_over
= ehci_port_handed_over
,
96 .clear_tt_buffer_complete
= ehci_clear_tt_buffer_complete
,
99 static int ehci_hcd_sh_probe(struct platform_device
*pdev
)
101 const struct hc_driver
*driver
= &ehci_sh_hc_driver
;
102 struct resource
*res
;
103 struct ehci_sh_priv
*priv
;
104 struct ehci_sh_platdata
*pdata
;
111 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
114 "Found HC with no register addr. Check %s setup!\n",
115 dev_name(&pdev
->dev
));
117 goto fail_create_hcd
;
120 irq
= platform_get_irq(pdev
, 0);
123 "Found HC with no IRQ. Check %s setup!\n",
124 dev_name(&pdev
->dev
));
126 goto fail_create_hcd
;
129 pdata
= pdev
->dev
.platform_data
;
132 hcd
= usb_create_hcd(&ehci_sh_hc_driver
, &pdev
->dev
,
133 dev_name(&pdev
->dev
));
136 goto fail_create_hcd
;
139 hcd
->rsrc_start
= res
->start
;
140 hcd
->rsrc_len
= resource_size(res
);
142 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
,
143 driver
->description
)) {
144 dev_dbg(&pdev
->dev
, "controller already in use\n");
146 goto fail_request_resource
;
149 hcd
->regs
= ioremap_nocache(hcd
->rsrc_start
, hcd
->rsrc_len
);
150 if (hcd
->regs
== NULL
) {
151 dev_dbg(&pdev
->dev
, "error mapping memory\n");
156 priv
= kmalloc(sizeof(struct ehci_sh_priv
), GFP_KERNEL
);
158 dev_dbg(&pdev
->dev
, "error allocating priv data\n");
163 /* These are optional, we don't care if they fail */
164 priv
->fclk
= clk_get(&pdev
->dev
, "usb_fck");
165 if (IS_ERR(priv
->fclk
))
168 priv
->iclk
= clk_get(&pdev
->dev
, "usb_ick");
169 if (IS_ERR(priv
->iclk
))
172 clk_enable(priv
->fclk
);
173 clk_enable(priv
->iclk
);
175 if (pdata
&& pdata
->phy_init
)
178 ret
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
180 dev_err(&pdev
->dev
, "Failed to add hcd");
185 platform_set_drvdata(pdev
, priv
);
190 clk_disable(priv
->iclk
);
191 clk_disable(priv
->fclk
);
200 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
201 fail_request_resource
:
204 dev_err(&pdev
->dev
, "init %s fail, %d\n", dev_name(&pdev
->dev
), ret
);
209 static int __exit
ehci_hcd_sh_remove(struct platform_device
*pdev
)
211 struct ehci_sh_priv
*priv
= platform_get_drvdata(pdev
);
212 struct usb_hcd
*hcd
= priv
->hcd
;
216 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
218 platform_set_drvdata(pdev
, NULL
);
220 clk_disable(priv
->fclk
);
221 clk_disable(priv
->iclk
);
231 static void ehci_hcd_sh_shutdown(struct platform_device
*pdev
)
233 struct ehci_sh_priv
*priv
= platform_get_drvdata(pdev
);
234 struct usb_hcd
*hcd
= priv
->hcd
;
236 if (hcd
->driver
->shutdown
)
237 hcd
->driver
->shutdown(hcd
);
240 static struct platform_driver ehci_hcd_sh_driver
= {
241 .probe
= ehci_hcd_sh_probe
,
242 .remove
= __exit_p(ehci_hcd_sh_remove
),
243 .shutdown
= ehci_hcd_sh_shutdown
,
246 .owner
= THIS_MODULE
,
250 MODULE_ALIAS("platform:sh_ehci");