2 * Setup platform devices needed by the Freescale multi-port host
3 * and/or dual-role USB controller modules based on the description
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.
12 #include <linux/kernel.h>
13 #include <linux/platform_device.h>
14 #include <linux/fsl_devices.h>
15 #include <linux/err.h>
17 #include <linux/of_platform.h>
18 #include <linux/clk.h>
19 #include <linux/module.h>
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 */
27 struct fsl_usb2_dev_data dr_mode_data
[] __devinitdata
= {
30 .drivers
= { "fsl-ehci", NULL
, NULL
, },
31 .op_mode
= FSL_USB2_DR_HOST
,
35 .drivers
= { "fsl-usb2-otg", "fsl-ehci", "fsl-usb2-udc", },
36 .op_mode
= FSL_USB2_DR_OTG
,
39 .dr_mode
= "peripheral",
40 .drivers
= { "fsl-usb2-udc", NULL
, NULL
, },
41 .op_mode
= FSL_USB2_DR_DEVICE
,
45 struct fsl_usb2_dev_data
* __devinit
get_dr_mode_data(struct device_node
*np
)
47 const unsigned char *prop
;
50 prop
= of_get_property(np
, "dr_mode", NULL
);
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
];
57 pr_warn("%s: Invalid 'dr_mode' property, fallback to host mode\n",
59 return &dr_mode_data
[0]; /* mode not specified, use host */
62 static enum fsl_usb2_phy_modes __devinit
determine_usb_phy(const char *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
;
75 return FSL_USB2_PHY_NONE
;
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
)
83 struct platform_device
*pdev
;
84 const struct resource
*res
= ofdev
->resource
;
85 unsigned int num
= ofdev
->num_resources
;
88 pdev
= platform_device_alloc(name
, id
);
94 pdev
->dev
.parent
= &ofdev
->dev
;
96 pdev
->dev
.coherent_dma_mask
= ofdev
->dev
.coherent_dma_mask
;
97 *pdev
->dev
.dma_mask
= *ofdev
->dev
.dma_mask
;
99 retval
= platform_device_add_data(pdev
, pdata
, sizeof(*pdata
));
104 retval
= platform_device_add_resources(pdev
, res
, num
);
109 retval
= platform_device_add(pdev
);
116 platform_device_put(pdev
);
117 return ERR_PTR(retval
);
120 static const struct of_device_id fsl_usb2_mph_dr_of_match
[];
122 static int usb_get_ver_info(struct device_node
*np
)
127 * returns 1 for usb controller version 1.6
128 * returns 2 for usb controller version 2.2
129 * returns 0 otherwise
131 if (of_device_is_compatible(np
, "fsl-usb2-dr")) {
132 if (of_device_is_compatible(np
, "fsl-usb2-dr-v1.6"))
133 ver
= FSL_USB_VER_1_6
;
134 else if (of_device_is_compatible(np
, "fsl-usb2-dr-v2.2"))
135 ver
= FSL_USB_VER_2_2
;
136 else /* for previous controller versions */
137 ver
= FSL_USB_VER_OLD
;
143 if (of_device_is_compatible(np
, "fsl-usb2-mph")) {
144 if (of_device_is_compatible(np
, "fsl-usb2-mph-v1.6"))
145 ver
= FSL_USB_VER_1_6
;
146 else if (of_device_is_compatible(np
, "fsl-usb2-mph-v2.2"))
147 ver
= FSL_USB_VER_2_2
;
148 else /* for previous controller versions */
149 ver
= FSL_USB_VER_OLD
;
155 static int __devinit
fsl_usb2_mph_dr_of_probe(struct platform_device
*ofdev
)
157 struct device_node
*np
= ofdev
->dev
.of_node
;
158 struct platform_device
*usb_dev
;
159 struct fsl_usb2_platform_data data
, *pdata
;
160 struct fsl_usb2_dev_data
*dev_data
;
161 const struct of_device_id
*match
;
162 const unsigned char *prop
;
163 static unsigned int idx
;
166 if (!of_device_is_available(np
))
169 match
= of_match_device(fsl_usb2_mph_dr_of_match
, &ofdev
->dev
);
175 memcpy(pdata
, match
->data
, sizeof(data
));
177 memset(pdata
, 0, sizeof(data
));
179 dev_data
= get_dr_mode_data(np
);
181 if (of_device_is_compatible(np
, "fsl-usb2-mph")) {
182 if (of_get_property(np
, "port0", NULL
))
183 pdata
->port_enables
|= FSL_USB2_PORT0_ENABLED
;
185 if (of_get_property(np
, "port1", NULL
))
186 pdata
->port_enables
|= FSL_USB2_PORT1_ENABLED
;
188 pdata
->operating_mode
= FSL_USB2_MPH_HOST
;
190 if (of_get_property(np
, "fsl,invert-drvvbus", NULL
))
191 pdata
->invert_drvvbus
= 1;
193 if (of_get_property(np
, "fsl,invert-pwr-fault", NULL
))
194 pdata
->invert_pwr_fault
= 1;
196 /* setup mode selected in the device tree */
197 pdata
->operating_mode
= dev_data
->op_mode
;
200 prop
= of_get_property(np
, "phy_type", NULL
);
201 pdata
->phy_mode
= determine_usb_phy(prop
);
202 pdata
->controller_ver
= usb_get_ver_info(np
);
204 if (pdata
->have_sysif_regs
) {
205 if (pdata
->controller_ver
< 0) {
206 dev_warn(&ofdev
->dev
, "Could not get controller version\n");
211 for (i
= 0; i
< ARRAY_SIZE(dev_data
->drivers
); i
++) {
212 if (!dev_data
->drivers
[i
])
214 usb_dev
= fsl_usb2_device_register(ofdev
, pdata
,
215 dev_data
->drivers
[i
], idx
);
216 if (IS_ERR(usb_dev
)) {
217 dev_err(&ofdev
->dev
, "Can't register usb device\n");
218 return PTR_ERR(usb_dev
);
225 static int __devexit
__unregister_subdev(struct device
*dev
, void *d
)
227 platform_device_unregister(to_platform_device(dev
));
231 static int __devexit
fsl_usb2_mph_dr_of_remove(struct platform_device
*ofdev
)
233 device_for_each_child(&ofdev
->dev
, NULL
, __unregister_subdev
);
237 #ifdef CONFIG_PPC_MPC512x
239 #define USBGENCTRL 0x200 /* NOTE: big endian */
240 #define GC_WU_INT_CLR (1 << 5) /* Wakeup int clear */
241 #define GC_ULPI_SEL (1 << 4) /* ULPI i/f select (usb0 only)*/
242 #define GC_PPP (1 << 3) /* Inv. Port Power Polarity */
243 #define GC_PFP (1 << 2) /* Inv. Power Fault Polarity */
244 #define GC_WU_ULPI_EN (1 << 1) /* Wakeup on ULPI event */
245 #define GC_WU_IE (1 << 1) /* Wakeup interrupt enable */
247 #define ISIPHYCTRL 0x204 /* NOTE: big endian */
248 #define PHYCTRL_PHYE (1 << 4) /* On-chip UTMI PHY enable */
249 #define PHYCTRL_BSENH (1 << 3) /* Bit Stuff Enable High */
250 #define PHYCTRL_BSEN (1 << 2) /* Bit Stuff Enable */
251 #define PHYCTRL_LSFE (1 << 1) /* Line State Filter Enable */
252 #define PHYCTRL_PXE (1 << 0) /* PHY oscillator enable */
254 int fsl_usb2_mpc5121_init(struct platform_device
*pdev
)
256 struct fsl_usb2_platform_data
*pdata
= pdev
->dev
.platform_data
;
261 base
= pdev
->resource
->start
& 0xf000;
264 else if (base
== 0x4000)
269 snprintf(clk_name
, sizeof(clk_name
), "usb%d_clk", clk_num
);
270 clk
= clk_get(&pdev
->dev
, clk_name
);
272 dev_err(&pdev
->dev
, "failed to get clk\n");
279 if (pdata
->phy_mode
== FSL_USB2_PHY_UTMI_WIDE
) {
282 if (pdata
->invert_drvvbus
)
285 if (pdata
->invert_pwr_fault
)
288 out_be32(pdata
->regs
+ ISIPHYCTRL
, PHYCTRL_PHYE
| PHYCTRL_PXE
);
289 out_be32(pdata
->regs
+ USBGENCTRL
, reg
);
294 static void fsl_usb2_mpc5121_exit(struct platform_device
*pdev
)
296 struct fsl_usb2_platform_data
*pdata
= pdev
->dev
.platform_data
;
301 clk_disable(pdata
->clk
);
306 static struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd
= {
307 .big_endian_desc
= 1,
308 .big_endian_mmio
= 1,
310 .have_sysif_regs
= 0,
312 .init
= fsl_usb2_mpc5121_init
,
313 .exit
= fsl_usb2_mpc5121_exit
,
315 #endif /* CONFIG_PPC_MPC512x */
317 static struct fsl_usb2_platform_data fsl_usb2_mpc8xxx_pd
= {
318 .have_sysif_regs
= 1,
321 static const struct of_device_id fsl_usb2_mph_dr_of_match
[] = {
322 { .compatible
= "fsl-usb2-mph", .data
= &fsl_usb2_mpc8xxx_pd
, },
323 { .compatible
= "fsl-usb2-dr", .data
= &fsl_usb2_mpc8xxx_pd
, },
324 #ifdef CONFIG_PPC_MPC512x
325 { .compatible
= "fsl,mpc5121-usb2-dr", .data
= &fsl_usb2_mpc5121_pd
, },
330 static struct platform_driver fsl_usb2_mph_dr_driver
= {
332 .name
= "fsl-usb2-mph-dr",
333 .owner
= THIS_MODULE
,
334 .of_match_table
= fsl_usb2_mph_dr_of_match
,
336 .probe
= fsl_usb2_mph_dr_of_probe
,
337 .remove
= __devexit_p(fsl_usb2_mph_dr_of_remove
),
340 module_platform_driver(fsl_usb2_mph_dr_driver
);
342 MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
343 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
344 MODULE_LICENSE("GPL");