xhci: tegra: support HSIC ports
[linux-3.10.git] / drivers / usb / host / ohci-jz4740.c
1 /*
2  *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3  *
4  *  This program is free software; you can redistribute it and/or modify it
5  *  under  the terms of the GNU General  Public License as published by the
6  *  Free Software Foundation;  either version 2 of the License, or (at your
7  *  option) any later version.
8  *
9  *  You should have received a copy of the  GNU General Public License along
10  *  with this program; if not, write  to the Free Software Foundation, Inc.,
11  *  675 Mass Ave, Cambridge, MA 02139, USA.
12  *
13  */
14
15 #include <linux/platform_device.h>
16 #include <linux/clk.h>
17 #include <linux/regulator/consumer.h>
18
19 struct jz4740_ohci_hcd {
20         struct ohci_hcd ohci_hcd;
21
22         struct regulator *vbus;
23         bool vbus_enabled;
24         struct clk *clk;
25 };
26
27 static inline struct jz4740_ohci_hcd *hcd_to_jz4740_hcd(struct usb_hcd *hcd)
28 {
29         return (struct jz4740_ohci_hcd *)(hcd->hcd_priv);
30 }
31
32 static inline struct usb_hcd *jz4740_hcd_to_hcd(struct jz4740_ohci_hcd *jz4740_ohci)
33 {
34         return container_of((void *)jz4740_ohci, struct usb_hcd, hcd_priv);
35 }
36
37 static int ohci_jz4740_start(struct usb_hcd *hcd)
38 {
39         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
40         int     ret;
41
42         ret = ohci_init(ohci);
43         if (ret < 0)
44                 return ret;
45
46         ohci->num_ports = 1;
47
48         ret = ohci_run(ohci);
49         if (ret < 0) {
50                 dev_err(hcd->self.controller, "Can not start %s",
51                         hcd->self.bus_name);
52                 ohci_stop(hcd);
53                 return ret;
54         }
55         return 0;
56 }
57
58 static int ohci_jz4740_set_vbus_power(struct jz4740_ohci_hcd *jz4740_ohci,
59         bool enabled)
60 {
61         int ret = 0;
62
63         if (!jz4740_ohci->vbus)
64                 return 0;
65
66         if (enabled && !jz4740_ohci->vbus_enabled) {
67                 ret = regulator_enable(jz4740_ohci->vbus);
68                 if (ret)
69                         dev_err(jz4740_hcd_to_hcd(jz4740_ohci)->self.controller,
70                                 "Could not power vbus\n");
71         } else if (!enabled && jz4740_ohci->vbus_enabled) {
72                 ret = regulator_disable(jz4740_ohci->vbus);
73         }
74
75         if (ret == 0)
76                 jz4740_ohci->vbus_enabled = enabled;
77
78         return ret;
79 }
80
81 static int ohci_jz4740_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
82         u16 wIndex, char *buf, u16 wLength)
83 {
84         struct jz4740_ohci_hcd *jz4740_ohci = hcd_to_jz4740_hcd(hcd);
85         int ret;
86
87         switch (typeReq) {
88         case SetHubFeature:
89                 if (wValue == USB_PORT_FEAT_POWER)
90                         ret = ohci_jz4740_set_vbus_power(jz4740_ohci, true);
91                 break;
92         case ClearHubFeature:
93                 if (wValue == USB_PORT_FEAT_POWER)
94                         ret = ohci_jz4740_set_vbus_power(jz4740_ohci, false);
95                 break;
96         }
97
98         if (ret)
99                 return ret;
100
101         return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
102 }
103
104
105 static const struct hc_driver ohci_jz4740_hc_driver = {
106         .description =          hcd_name,
107         .product_desc =         "JZ4740 OHCI",
108         .hcd_priv_size =        sizeof(struct jz4740_ohci_hcd),
109
110         /*
111          * generic hardware linkage
112          */
113         .irq =                  ohci_irq,
114         .flags =                HCD_USB11 | HCD_MEMORY,
115
116         /*
117          * basic lifecycle operations
118          */
119         .start =                ohci_jz4740_start,
120         .stop =                 ohci_stop,
121         .shutdown =             ohci_shutdown,
122
123         /*
124          * managing i/o requests and associated device resources
125          */
126         .urb_enqueue =          ohci_urb_enqueue,
127         .urb_dequeue =          ohci_urb_dequeue,
128         .endpoint_disable =     ohci_endpoint_disable,
129
130         /*
131          * scheduling support
132          */
133         .get_frame_number =     ohci_get_frame,
134
135         /*
136          * root hub support
137          */
138         .hub_status_data =      ohci_hub_status_data,
139         .hub_control =          ohci_jz4740_hub_control,
140 #ifdef  CONFIG_PM
141         .bus_suspend =          ohci_bus_suspend,
142         .bus_resume =           ohci_bus_resume,
143 #endif
144         .start_port_reset =     ohci_start_port_reset,
145 };
146
147
148 static int jz4740_ohci_probe(struct platform_device *pdev)
149 {
150         int ret;
151         struct usb_hcd *hcd;
152         struct jz4740_ohci_hcd *jz4740_ohci;
153         struct resource *res;
154         int irq;
155
156         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
157
158         if (!res) {
159                 dev_err(&pdev->dev, "Failed to get platform resource\n");
160                 return -ENOENT;
161         }
162
163         irq = platform_get_irq(pdev, 0);
164         if (irq < 0) {
165                 dev_err(&pdev->dev, "Failed to get platform irq\n");
166                 return irq;
167         }
168
169         hcd = usb_create_hcd(&ohci_jz4740_hc_driver, &pdev->dev, "jz4740");
170         if (!hcd) {
171                 dev_err(&pdev->dev, "Failed to create hcd.\n");
172                 return -ENOMEM;
173         }
174
175         jz4740_ohci = hcd_to_jz4740_hcd(hcd);
176
177         res = request_mem_region(res->start, resource_size(res), hcd_name);
178         if (!res) {
179                 dev_err(&pdev->dev, "Failed to request mem region.\n");
180                 ret = -EBUSY;
181                 goto err_free;
182         }
183
184         hcd->rsrc_start = res->start;
185         hcd->rsrc_len = resource_size(res);
186         hcd->regs = ioremap(res->start, resource_size(res));
187
188         if (!hcd->regs) {
189                 dev_err(&pdev->dev, "Failed to ioremap registers.\n");
190                 ret = -EBUSY;
191                 goto err_release_mem;
192         }
193
194         jz4740_ohci->clk = clk_get(&pdev->dev, "uhc");
195         if (IS_ERR(jz4740_ohci->clk)) {
196                 ret = PTR_ERR(jz4740_ohci->clk);
197                 dev_err(&pdev->dev, "Failed to get clock: %d\n", ret);
198                 goto err_iounmap;
199         }
200
201         jz4740_ohci->vbus = regulator_get(&pdev->dev, "vbus");
202         if (IS_ERR(jz4740_ohci->vbus))
203                 jz4740_ohci->vbus = NULL;
204
205
206         clk_set_rate(jz4740_ohci->clk, 48000000);
207         clk_enable(jz4740_ohci->clk);
208         if (jz4740_ohci->vbus)
209                 ohci_jz4740_set_vbus_power(jz4740_ohci, true);
210
211         platform_set_drvdata(pdev, hcd);
212
213         ohci_hcd_init(hcd_to_ohci(hcd));
214
215         ret = usb_add_hcd(hcd, irq, 0);
216         if (ret) {
217                 dev_err(&pdev->dev, "Failed to add hcd: %d\n", ret);
218                 goto err_disable;
219         }
220
221         return 0;
222
223 err_disable:
224         platform_set_drvdata(pdev, NULL);
225         if (jz4740_ohci->vbus) {
226                 regulator_disable(jz4740_ohci->vbus);
227                 regulator_put(jz4740_ohci->vbus);
228         }
229         clk_disable(jz4740_ohci->clk);
230
231         clk_put(jz4740_ohci->clk);
232 err_iounmap:
233         iounmap(hcd->regs);
234 err_release_mem:
235         release_mem_region(res->start, resource_size(res));
236 err_free:
237         usb_put_hcd(hcd);
238
239         return ret;
240 }
241
242 static int jz4740_ohci_remove(struct platform_device *pdev)
243 {
244         struct usb_hcd *hcd = platform_get_drvdata(pdev);
245         struct jz4740_ohci_hcd *jz4740_ohci = hcd_to_jz4740_hcd(hcd);
246
247         usb_remove_hcd(hcd);
248
249         platform_set_drvdata(pdev, NULL);
250
251         if (jz4740_ohci->vbus) {
252                 regulator_disable(jz4740_ohci->vbus);
253                 regulator_put(jz4740_ohci->vbus);
254         }
255
256         clk_disable(jz4740_ohci->clk);
257         clk_put(jz4740_ohci->clk);
258
259         iounmap(hcd->regs);
260         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
261
262         usb_put_hcd(hcd);
263
264         return 0;
265 }
266
267 static struct platform_driver ohci_hcd_jz4740_driver = {
268         .probe = jz4740_ohci_probe,
269         .remove = jz4740_ohci_remove,
270         .driver = {
271                 .name = "jz4740-ohci",
272                 .owner = THIS_MODULE,
273         },
274 };
275
276 MODULE_ALIAS("platform:jz4740-ohci");