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