Merge branch 'for-davem' of ssh://master.kernel.org/pub/scm/linux/kernel/git/linville...
[linux-2.6.git] / drivers / usb / host / ehci-xilinx-of.c
1 /*
2  * EHCI HCD (Host Controller Driver) for USB.
3  *
4  * Bus Glue for Xilinx EHCI core on the of_platform bus
5  *
6  * Copyright (c) 2009 Xilinx, Inc.
7  *
8  * Based on "ehci-ppc-of.c" by Valentine Barshak <vbarshak@ru.mvista.com>
9  * and "ehci-ppc-soc.c" by Stefan Roese <sr@denx.de>
10  * and "ohci-ppc-of.c" by Sylvain Munaut <tnt@246tNt.com>
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License as published by the
14  * Free Software Foundation; either version 2 of the License, or (at your
15  * option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful, but
18  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
20  * for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software Foundation,
24  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  */
27
28 #include <linux/signal.h>
29
30 #include <linux/of.h>
31 #include <linux/of_platform.h>
32 #include <linux/of_address.h>
33
34 /**
35  * ehci_xilinx_of_setup - Initialize the device for ehci_reset()
36  * @hcd:        Pointer to the usb_hcd device to which the host controller bound
37  *
38  * called during probe() after chip reset completes.
39  */
40 static int ehci_xilinx_of_setup(struct usb_hcd *hcd)
41 {
42         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
43         int             retval;
44
45         retval = ehci_halt(ehci);
46         if (retval)
47                 return retval;
48
49         retval = ehci_init(hcd);
50         if (retval)
51                 return retval;
52
53         ehci->sbrn = 0x20;
54
55         return ehci_reset(ehci);
56 }
57
58 /**
59  * ehci_xilinx_port_handed_over - hand the port out if failed to enable it
60  * @hcd:        Pointer to the usb_hcd device to which the host controller bound
61  * @portnum:Port number to which the device is attached.
62  *
63  * This function is used as a place to tell the user that the Xilinx USB host
64  * controller does support LS devices. And in an HS only configuration, it
65  * does not support FS devices either. It is hoped that this can help a
66  * confused user.
67  *
68  * There are cases when the host controller fails to enable the port due to,
69  * for example, insufficient power that can be supplied to the device from
70  * the USB bus. In those cases, the messages printed here are not helpful.
71  */
72 static int ehci_xilinx_port_handed_over(struct usb_hcd *hcd, int portnum)
73 {
74         dev_warn(hcd->self.controller, "port %d cannot be enabled\n", portnum);
75         if (hcd->has_tt) {
76                 dev_warn(hcd->self.controller,
77                         "Maybe you have connected a low speed device?\n");
78
79                 dev_warn(hcd->self.controller,
80                         "We do not support low speed devices\n");
81         } else {
82                 dev_warn(hcd->self.controller,
83                         "Maybe your device is not a high speed device?\n");
84                 dev_warn(hcd->self.controller,
85                         "The USB host controller does not support full speed "
86                         "nor low speed devices\n");
87                 dev_warn(hcd->self.controller,
88                         "You can reconfigure the host controller to have "
89                         "full speed support\n");
90         }
91
92         return 0;
93 }
94
95
96 static const struct hc_driver ehci_xilinx_of_hc_driver = {
97         .description            = hcd_name,
98         .product_desc           = "OF EHCI",
99         .hcd_priv_size          = sizeof(struct ehci_hcd),
100
101         /*
102          * generic hardware linkage
103          */
104         .irq                    = ehci_irq,
105         .flags                  = HCD_MEMORY | HCD_USB2,
106
107         /*
108          * basic lifecycle operations
109          */
110         .reset                  = ehci_xilinx_of_setup,
111         .start                  = ehci_run,
112         .stop                   = ehci_stop,
113         .shutdown               = ehci_shutdown,
114
115         /*
116          * managing i/o requests and associated device resources
117          */
118         .urb_enqueue            = ehci_urb_enqueue,
119         .urb_dequeue            = ehci_urb_dequeue,
120         .endpoint_disable       = ehci_endpoint_disable,
121         .endpoint_reset         = ehci_endpoint_reset,
122
123         /*
124          * scheduling support
125          */
126         .get_frame_number       = ehci_get_frame,
127
128         /*
129          * root hub support
130          */
131         .hub_status_data        = ehci_hub_status_data,
132         .hub_control            = ehci_hub_control,
133 #ifdef  CONFIG_PM
134         .bus_suspend            = ehci_bus_suspend,
135         .bus_resume             = ehci_bus_resume,
136 #endif
137         .relinquish_port        = NULL,
138         .port_handed_over       = ehci_xilinx_port_handed_over,
139
140         .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
141 };
142
143 /**
144  * ehci_hcd_xilinx_of_probe - Probe method for the USB host controller
145  * @op:         pointer to the platform_device bound to the host controller
146  * @match:      pointer to of_device_id structure, not used
147  *
148  * This function requests resources and sets up appropriate properties for the
149  * host controller. Because the Xilinx USB host controller can be configured
150  * as HS only or HS/FS only, it checks the configuration in the device tree
151  * entry, and sets an appropriate value for hcd->has_tt.
152  */
153 static int __devinit
154 ehci_hcd_xilinx_of_probe(struct platform_device *op, const struct of_device_id *match)
155 {
156         struct device_node *dn = op->dev.of_node;
157         struct usb_hcd *hcd;
158         struct ehci_hcd *ehci;
159         struct resource res;
160         int irq;
161         int rv;
162         int *value;
163
164         if (usb_disabled())
165                 return -ENODEV;
166
167         dev_dbg(&op->dev, "initializing XILINX-OF USB Controller\n");
168
169         rv = of_address_to_resource(dn, 0, &res);
170         if (rv)
171                 return rv;
172
173         hcd = usb_create_hcd(&ehci_xilinx_of_hc_driver, &op->dev,
174                                 "XILINX-OF USB");
175         if (!hcd)
176                 return -ENOMEM;
177
178         hcd->rsrc_start = res.start;
179         hcd->rsrc_len = res.end - res.start + 1;
180
181         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
182                 printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
183                 rv = -EBUSY;
184                 goto err_rmr;
185         }
186
187         irq = irq_of_parse_and_map(dn, 0);
188         if (irq == NO_IRQ) {
189                 printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
190                 rv = -EBUSY;
191                 goto err_irq;
192         }
193
194         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
195         if (!hcd->regs) {
196                 printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
197                 rv = -ENOMEM;
198                 goto err_ioremap;
199         }
200
201         ehci = hcd_to_ehci(hcd);
202
203         /* This core always has big-endian register interface and uses
204          * big-endian memory descriptors.
205          */
206         ehci->big_endian_mmio = 1;
207         ehci->big_endian_desc = 1;
208
209         /* Check whether the FS support option is selected in the hardware.
210          */
211         value = (int *)of_get_property(dn, "xlnx,support-usb-fs", NULL);
212         if (value && (*value == 1)) {
213                 ehci_dbg(ehci, "USB host controller supports FS devices\n");
214                 hcd->has_tt = 1;
215         } else {
216                 ehci_dbg(ehci,
217                         "USB host controller is HS only\n");
218                 hcd->has_tt = 0;
219         }
220
221         /* Debug registers are at the first 0x100 region
222          */
223         ehci->caps = hcd->regs + 0x100;
224         ehci->regs = hcd->regs + 0x100 +
225                         HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
226
227         /* cache this readonly data; minimize chip reads */
228         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
229
230         rv = usb_add_hcd(hcd, irq, 0);
231         if (rv == 0)
232                 return 0;
233
234         iounmap(hcd->regs);
235
236 err_ioremap:
237 err_irq:
238         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
239 err_rmr:
240         usb_put_hcd(hcd);
241
242         return rv;
243 }
244
245 /**
246  * ehci_hcd_xilinx_of_remove - shutdown hcd and release resources
247  * @op:         pointer to platform_device structure that is to be removed
248  *
249  * Remove the hcd structure, and release resources that has been requested
250  * during probe.
251  */
252 static int ehci_hcd_xilinx_of_remove(struct platform_device *op)
253 {
254         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
255         dev_set_drvdata(&op->dev, NULL);
256
257         dev_dbg(&op->dev, "stopping XILINX-OF USB Controller\n");
258
259         usb_remove_hcd(hcd);
260
261         iounmap(hcd->regs);
262         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
263
264         usb_put_hcd(hcd);
265
266         return 0;
267 }
268
269 /**
270  * ehci_hcd_xilinx_of_shutdown - shutdown the hcd
271  * @op:         pointer to platform_device structure that is to be removed
272  *
273  * Properly shutdown the hcd, call driver's shutdown routine.
274  */
275 static int ehci_hcd_xilinx_of_shutdown(struct platform_device *op)
276 {
277         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
278
279         if (hcd->driver->shutdown)
280                 hcd->driver->shutdown(hcd);
281
282         return 0;
283 }
284
285
286 static const struct of_device_id ehci_hcd_xilinx_of_match[] = {
287                 {.compatible = "xlnx,xps-usb-host-1.00.a",},
288         {},
289 };
290 MODULE_DEVICE_TABLE(of, ehci_hcd_xilinx_of_match);
291
292 static struct of_platform_driver ehci_hcd_xilinx_of_driver = {
293         .probe          = ehci_hcd_xilinx_of_probe,
294         .remove         = ehci_hcd_xilinx_of_remove,
295         .shutdown       = ehci_hcd_xilinx_of_shutdown,
296         .driver = {
297                 .name = "xilinx-of-ehci",
298                 .owner = THIS_MODULE,
299                 .of_match_table = ehci_hcd_xilinx_of_match,
300         },
301 };