Merge branch 'for-1111' of git://gitorious.org/smack-next/kernel into for-linus
[pandora-kernel.git] / drivers / usb / host / fsl-mph-dr-of.c
1 /*
2  * Setup platform devices needed by the Freescale multi-port host
3  * and/or dual-role USB controller modules based on the description
4  * in flat device tree.
5  *
6  * This program is free software; you can redistribute  it and/or modify it
7  * under  the terms of  the GNU General  Public License as published by the
8  * Free Software Foundation;  either version 2 of the  License, or (at your
9  * option) any later version.
10  */
11
12 #include <linux/kernel.h>
13 #include <linux/platform_device.h>
14 #include <linux/fsl_devices.h>
15 #include <linux/err.h>
16 #include <linux/io.h>
17 #include <linux/of_platform.h>
18 #include <linux/clk.h>
19 #include <linux/module.h>
20
21 struct fsl_usb2_dev_data {
22         char *dr_mode;          /* controller mode */
23         char *drivers[3];       /* drivers to instantiate for this mode */
24         enum fsl_usb2_operating_modes op_mode;  /* operating mode */
25 };
26
27 struct fsl_usb2_dev_data dr_mode_data[] __devinitdata = {
28         {
29                 .dr_mode = "host",
30                 .drivers = { "fsl-ehci", NULL, NULL, },
31                 .op_mode = FSL_USB2_DR_HOST,
32         },
33         {
34                 .dr_mode = "otg",
35                 .drivers = { "fsl-usb2-otg", "fsl-ehci", "fsl-usb2-udc", },
36                 .op_mode = FSL_USB2_DR_OTG,
37         },
38         {
39                 .dr_mode = "peripheral",
40                 .drivers = { "fsl-usb2-udc", NULL, NULL, },
41                 .op_mode = FSL_USB2_DR_DEVICE,
42         },
43 };
44
45 struct fsl_usb2_dev_data * __devinit get_dr_mode_data(struct device_node *np)
46 {
47         const unsigned char *prop;
48         int i;
49
50         prop = of_get_property(np, "dr_mode", NULL);
51         if (prop) {
52                 for (i = 0; i < ARRAY_SIZE(dr_mode_data); i++) {
53                         if (!strcmp(prop, dr_mode_data[i].dr_mode))
54                                 return &dr_mode_data[i];
55                 }
56         }
57         pr_warn("%s: Invalid 'dr_mode' property, fallback to host mode\n",
58                 np->full_name);
59         return &dr_mode_data[0]; /* mode not specified, use host */
60 }
61
62 static enum fsl_usb2_phy_modes __devinit determine_usb_phy(const char *phy_type)
63 {
64         if (!phy_type)
65                 return FSL_USB2_PHY_NONE;
66         if (!strcasecmp(phy_type, "ulpi"))
67                 return FSL_USB2_PHY_ULPI;
68         if (!strcasecmp(phy_type, "utmi"))
69                 return FSL_USB2_PHY_UTMI;
70         if (!strcasecmp(phy_type, "utmi_wide"))
71                 return FSL_USB2_PHY_UTMI_WIDE;
72         if (!strcasecmp(phy_type, "serial"))
73                 return FSL_USB2_PHY_SERIAL;
74
75         return FSL_USB2_PHY_NONE;
76 }
77
78 struct platform_device * __devinit fsl_usb2_device_register(
79                                         struct platform_device *ofdev,
80                                         struct fsl_usb2_platform_data *pdata,
81                                         const char *name, int id)
82 {
83         struct platform_device *pdev;
84         const struct resource *res = ofdev->resource;
85         unsigned int num = ofdev->num_resources;
86         int retval;
87
88         pdev = platform_device_alloc(name, id);
89         if (!pdev) {
90                 retval = -ENOMEM;
91                 goto error;
92         }
93
94         pdev->dev.parent = &ofdev->dev;
95
96         pdev->dev.coherent_dma_mask = ofdev->dev.coherent_dma_mask;
97         pdev->dev.dma_mask = &pdev->archdata.dma_mask;
98         *pdev->dev.dma_mask = *ofdev->dev.dma_mask;
99
100         retval = platform_device_add_data(pdev, pdata, sizeof(*pdata));
101         if (retval)
102                 goto error;
103
104         if (num) {
105                 retval = platform_device_add_resources(pdev, res, num);
106                 if (retval)
107                         goto error;
108         }
109
110         retval = platform_device_add(pdev);
111         if (retval)
112                 goto error;
113
114         return pdev;
115
116 error:
117         platform_device_put(pdev);
118         return ERR_PTR(retval);
119 }
120
121 static const struct of_device_id fsl_usb2_mph_dr_of_match[];
122
123 static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
124 {
125         struct device_node *np = ofdev->dev.of_node;
126         struct platform_device *usb_dev;
127         struct fsl_usb2_platform_data data, *pdata;
128         struct fsl_usb2_dev_data *dev_data;
129         const struct of_device_id *match;
130         const unsigned char *prop;
131         static unsigned int idx;
132         int i;
133
134         if (!of_device_is_available(np))
135                 return -ENODEV;
136
137         match = of_match_device(fsl_usb2_mph_dr_of_match, &ofdev->dev);
138         if (!match)
139                 return -ENODEV;
140
141         pdata = &data;
142         if (match->data)
143                 memcpy(pdata, match->data, sizeof(data));
144         else
145                 memset(pdata, 0, sizeof(data));
146
147         dev_data = get_dr_mode_data(np);
148
149         if (of_device_is_compatible(np, "fsl-usb2-mph")) {
150                 if (of_get_property(np, "port0", NULL))
151                         pdata->port_enables |= FSL_USB2_PORT0_ENABLED;
152
153                 if (of_get_property(np, "port1", NULL))
154                         pdata->port_enables |= FSL_USB2_PORT1_ENABLED;
155
156                 pdata->operating_mode = FSL_USB2_MPH_HOST;
157         } else {
158                 if (of_get_property(np, "fsl,invert-drvvbus", NULL))
159                         pdata->invert_drvvbus = 1;
160
161                 if (of_get_property(np, "fsl,invert-pwr-fault", NULL))
162                         pdata->invert_pwr_fault = 1;
163
164                 /* setup mode selected in the device tree */
165                 pdata->operating_mode = dev_data->op_mode;
166         }
167
168         prop = of_get_property(np, "phy_type", NULL);
169         pdata->phy_mode = determine_usb_phy(prop);
170
171         for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
172                 if (!dev_data->drivers[i])
173                         continue;
174                 usb_dev = fsl_usb2_device_register(ofdev, pdata,
175                                         dev_data->drivers[i], idx);
176                 if (IS_ERR(usb_dev)) {
177                         dev_err(&ofdev->dev, "Can't register usb device\n");
178                         return PTR_ERR(usb_dev);
179                 }
180         }
181         idx++;
182         return 0;
183 }
184
185 static int __devexit __unregister_subdev(struct device *dev, void *d)
186 {
187         platform_device_unregister(to_platform_device(dev));
188         return 0;
189 }
190
191 static int __devexit fsl_usb2_mph_dr_of_remove(struct platform_device *ofdev)
192 {
193         device_for_each_child(&ofdev->dev, NULL, __unregister_subdev);
194         return 0;
195 }
196
197 #ifdef CONFIG_PPC_MPC512x
198
199 #define USBGENCTRL              0x200           /* NOTE: big endian */
200 #define GC_WU_INT_CLR           (1 << 5)        /* Wakeup int clear */
201 #define GC_ULPI_SEL             (1 << 4)        /* ULPI i/f select (usb0 only)*/
202 #define GC_PPP                  (1 << 3)        /* Inv. Port Power Polarity */
203 #define GC_PFP                  (1 << 2)        /* Inv. Power Fault Polarity */
204 #define GC_WU_ULPI_EN           (1 << 1)        /* Wakeup on ULPI event */
205 #define GC_WU_IE                (1 << 1)        /* Wakeup interrupt enable */
206
207 #define ISIPHYCTRL              0x204           /* NOTE: big endian */
208 #define PHYCTRL_PHYE            (1 << 4)        /* On-chip UTMI PHY enable */
209 #define PHYCTRL_BSENH           (1 << 3)        /* Bit Stuff Enable High */
210 #define PHYCTRL_BSEN            (1 << 2)        /* Bit Stuff Enable */
211 #define PHYCTRL_LSFE            (1 << 1)        /* Line State Filter Enable */
212 #define PHYCTRL_PXE             (1 << 0)        /* PHY oscillator enable */
213
214 int fsl_usb2_mpc5121_init(struct platform_device *pdev)
215 {
216         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
217         struct clk *clk;
218         char clk_name[10];
219         int base, clk_num;
220
221         base = pdev->resource->start & 0xf000;
222         if (base == 0x3000)
223                 clk_num = 1;
224         else if (base == 0x4000)
225                 clk_num = 2;
226         else
227                 return -ENODEV;
228
229         snprintf(clk_name, sizeof(clk_name), "usb%d_clk", clk_num);
230         clk = clk_get(&pdev->dev, clk_name);
231         if (IS_ERR(clk)) {
232                 dev_err(&pdev->dev, "failed to get clk\n");
233                 return PTR_ERR(clk);
234         }
235
236         clk_enable(clk);
237         pdata->clk = clk;
238
239         if (pdata->phy_mode == FSL_USB2_PHY_UTMI_WIDE) {
240                 u32 reg = 0;
241
242                 if (pdata->invert_drvvbus)
243                         reg |= GC_PPP;
244
245                 if (pdata->invert_pwr_fault)
246                         reg |= GC_PFP;
247
248                 out_be32(pdata->regs + ISIPHYCTRL, PHYCTRL_PHYE | PHYCTRL_PXE);
249                 out_be32(pdata->regs + USBGENCTRL, reg);
250         }
251         return 0;
252 }
253
254 static void fsl_usb2_mpc5121_exit(struct platform_device *pdev)
255 {
256         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
257
258         pdata->regs = NULL;
259
260         if (pdata->clk) {
261                 clk_disable(pdata->clk);
262                 clk_put(pdata->clk);
263         }
264 }
265
266 static struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd = {
267         .big_endian_desc = 1,
268         .big_endian_mmio = 1,
269         .es = 1,
270         .have_sysif_regs = 0,
271         .le_setup_buf = 1,
272         .init = fsl_usb2_mpc5121_init,
273         .exit = fsl_usb2_mpc5121_exit,
274 };
275 #endif /* CONFIG_PPC_MPC512x */
276
277 static struct fsl_usb2_platform_data fsl_usb2_mpc8xxx_pd = {
278         .have_sysif_regs = 1,
279 };
280
281 static const struct of_device_id fsl_usb2_mph_dr_of_match[] = {
282         { .compatible = "fsl-usb2-mph", .data = &fsl_usb2_mpc8xxx_pd, },
283         { .compatible = "fsl-usb2-dr", .data = &fsl_usb2_mpc8xxx_pd, },
284 #ifdef CONFIG_PPC_MPC512x
285         { .compatible = "fsl,mpc5121-usb2-dr", .data = &fsl_usb2_mpc5121_pd, },
286 #endif
287         {},
288 };
289
290 static struct platform_driver fsl_usb2_mph_dr_driver = {
291         .driver = {
292                 .name = "fsl-usb2-mph-dr",
293                 .owner = THIS_MODULE,
294                 .of_match_table = fsl_usb2_mph_dr_of_match,
295         },
296         .probe  = fsl_usb2_mph_dr_of_probe,
297         .remove = __devexit_p(fsl_usb2_mph_dr_of_remove),
298 };
299
300 static int __init fsl_usb2_mph_dr_init(void)
301 {
302         return platform_driver_register(&fsl_usb2_mph_dr_driver);
303 }
304 module_init(fsl_usb2_mph_dr_init);
305
306 static void __exit fsl_usb2_mph_dr_exit(void)
307 {
308         platform_driver_unregister(&fsl_usb2_mph_dr_driver);
309 }
310 module_exit(fsl_usb2_mph_dr_exit);
311
312 MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
313 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
314 MODULE_LICENSE("GPL");