xref: /openbmc/linux/drivers/usb/host/fsl-mph-dr-of.c (revision e8f6f3b4)
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 static struct fsl_usb2_dev_data dr_mode_data[] = {
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 static struct fsl_usb2_dev_data *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 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 static struct platform_device *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 = *ofdev->dev.dma_mask;
98 
99 	retval = platform_device_add_data(pdev, pdata, sizeof(*pdata));
100 	if (retval)
101 		goto error;
102 
103 	if (num) {
104 		retval = platform_device_add_resources(pdev, res, num);
105 		if (retval)
106 			goto error;
107 	}
108 
109 	retval = platform_device_add(pdev);
110 	if (retval)
111 		goto error;
112 
113 	return pdev;
114 
115 error:
116 	platform_device_put(pdev);
117 	return ERR_PTR(retval);
118 }
119 
120 static const struct of_device_id fsl_usb2_mph_dr_of_match[];
121 
122 static int usb_get_ver_info(struct device_node *np)
123 {
124 	int ver = -1;
125 
126 	/*
127 	 * returns 1 for usb controller version 1.6
128 	 * returns 2 for usb controller version 2.2
129 	 * returns 0 otherwise
130 	 */
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 if (of_device_is_compatible(np, "fsl-usb2-dr-v2.4"))
137 			ver = FSL_USB_VER_2_4;
138 		else /* for previous controller versions */
139 			ver = FSL_USB_VER_OLD;
140 
141 		if (ver > -1)
142 			return ver;
143 	}
144 
145 	if (of_device_is_compatible(np, "fsl,mpc5121-usb2-dr"))
146 		return FSL_USB_VER_OLD;
147 
148 	if (of_device_is_compatible(np, "fsl-usb2-mph")) {
149 		if (of_device_is_compatible(np, "fsl-usb2-mph-v1.6"))
150 			ver = FSL_USB_VER_1_6;
151 		else if (of_device_is_compatible(np, "fsl-usb2-mph-v2.2"))
152 			ver = FSL_USB_VER_2_2;
153 		else /* for previous controller versions */
154 			ver = FSL_USB_VER_OLD;
155 	}
156 
157 	return ver;
158 }
159 
160 static int fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
161 {
162 	struct device_node *np = ofdev->dev.of_node;
163 	struct platform_device *usb_dev;
164 	struct fsl_usb2_platform_data data, *pdata;
165 	struct fsl_usb2_dev_data *dev_data;
166 	const struct of_device_id *match;
167 	const unsigned char *prop;
168 	static unsigned int idx;
169 	int i;
170 
171 	if (!of_device_is_available(np))
172 		return -ENODEV;
173 
174 	match = of_match_device(fsl_usb2_mph_dr_of_match, &ofdev->dev);
175 	if (!match)
176 		return -ENODEV;
177 
178 	pdata = &data;
179 	if (match->data)
180 		memcpy(pdata, match->data, sizeof(data));
181 	else
182 		memset(pdata, 0, sizeof(data));
183 
184 	dev_data = get_dr_mode_data(np);
185 
186 	if (of_device_is_compatible(np, "fsl-usb2-mph")) {
187 		if (of_get_property(np, "port0", NULL))
188 			pdata->port_enables |= FSL_USB2_PORT0_ENABLED;
189 
190 		if (of_get_property(np, "port1", NULL))
191 			pdata->port_enables |= FSL_USB2_PORT1_ENABLED;
192 
193 		pdata->operating_mode = FSL_USB2_MPH_HOST;
194 	} else {
195 		if (of_get_property(np, "fsl,invert-drvvbus", NULL))
196 			pdata->invert_drvvbus = 1;
197 
198 		if (of_get_property(np, "fsl,invert-pwr-fault", NULL))
199 			pdata->invert_pwr_fault = 1;
200 
201 		/* setup mode selected in the device tree */
202 		pdata->operating_mode = dev_data->op_mode;
203 	}
204 
205 	prop = of_get_property(np, "phy_type", NULL);
206 	pdata->phy_mode = determine_usb_phy(prop);
207 	pdata->controller_ver = usb_get_ver_info(np);
208 
209 	if (pdata->have_sysif_regs) {
210 		if (pdata->controller_ver < 0) {
211 			dev_warn(&ofdev->dev, "Could not get controller version\n");
212 			return -ENODEV;
213 		}
214 	}
215 
216 	for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
217 		if (!dev_data->drivers[i])
218 			continue;
219 		usb_dev = fsl_usb2_device_register(ofdev, pdata,
220 					dev_data->drivers[i], idx);
221 		if (IS_ERR(usb_dev)) {
222 			dev_err(&ofdev->dev, "Can't register usb device\n");
223 			return PTR_ERR(usb_dev);
224 		}
225 	}
226 	idx++;
227 	return 0;
228 }
229 
230 static int __unregister_subdev(struct device *dev, void *d)
231 {
232 	platform_device_unregister(to_platform_device(dev));
233 	return 0;
234 }
235 
236 static int fsl_usb2_mph_dr_of_remove(struct platform_device *ofdev)
237 {
238 	device_for_each_child(&ofdev->dev, NULL, __unregister_subdev);
239 	return 0;
240 }
241 
242 #ifdef CONFIG_PPC_MPC512x
243 
244 #define USBGENCTRL		0x200		/* NOTE: big endian */
245 #define GC_WU_INT_CLR		(1 << 5)	/* Wakeup int clear */
246 #define GC_ULPI_SEL		(1 << 4)	/* ULPI i/f select (usb0 only)*/
247 #define GC_PPP			(1 << 3)	/* Inv. Port Power Polarity */
248 #define GC_PFP			(1 << 2)	/* Inv. Power Fault Polarity */
249 #define GC_WU_ULPI_EN		(1 << 1)	/* Wakeup on ULPI event */
250 #define GC_WU_IE		(1 << 1)	/* Wakeup interrupt enable */
251 
252 #define ISIPHYCTRL		0x204		/* NOTE: big endian */
253 #define PHYCTRL_PHYE		(1 << 4)	/* On-chip UTMI PHY enable */
254 #define PHYCTRL_BSENH		(1 << 3)	/* Bit Stuff Enable High */
255 #define PHYCTRL_BSEN		(1 << 2)	/* Bit Stuff Enable */
256 #define PHYCTRL_LSFE		(1 << 1)	/* Line State Filter Enable */
257 #define PHYCTRL_PXE		(1 << 0)	/* PHY oscillator enable */
258 
259 int fsl_usb2_mpc5121_init(struct platform_device *pdev)
260 {
261 	struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
262 	struct clk *clk;
263 	int err;
264 
265 	clk = devm_clk_get(pdev->dev.parent, "ipg");
266 	if (IS_ERR(clk)) {
267 		dev_err(&pdev->dev, "failed to get clk\n");
268 		return PTR_ERR(clk);
269 	}
270 	err = clk_prepare_enable(clk);
271 	if (err) {
272 		dev_err(&pdev->dev, "failed to enable clk\n");
273 		return err;
274 	}
275 	pdata->clk = clk;
276 
277 	if (pdata->phy_mode == FSL_USB2_PHY_UTMI_WIDE) {
278 		u32 reg = 0;
279 
280 		if (pdata->invert_drvvbus)
281 			reg |= GC_PPP;
282 
283 		if (pdata->invert_pwr_fault)
284 			reg |= GC_PFP;
285 
286 		out_be32(pdata->regs + ISIPHYCTRL, PHYCTRL_PHYE | PHYCTRL_PXE);
287 		out_be32(pdata->regs + USBGENCTRL, reg);
288 	}
289 	return 0;
290 }
291 
292 static void fsl_usb2_mpc5121_exit(struct platform_device *pdev)
293 {
294 	struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
295 
296 	pdata->regs = NULL;
297 
298 	if (pdata->clk)
299 		clk_disable_unprepare(pdata->clk);
300 }
301 
302 static struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd = {
303 	.big_endian_desc = 1,
304 	.big_endian_mmio = 1,
305 	.es = 1,
306 	.have_sysif_regs = 0,
307 	.le_setup_buf = 1,
308 	.init = fsl_usb2_mpc5121_init,
309 	.exit = fsl_usb2_mpc5121_exit,
310 };
311 #endif /* CONFIG_PPC_MPC512x */
312 
313 static struct fsl_usb2_platform_data fsl_usb2_mpc8xxx_pd = {
314 	.have_sysif_regs = 1,
315 };
316 
317 static const struct of_device_id fsl_usb2_mph_dr_of_match[] = {
318 	{ .compatible = "fsl-usb2-mph", .data = &fsl_usb2_mpc8xxx_pd, },
319 	{ .compatible = "fsl-usb2-dr", .data = &fsl_usb2_mpc8xxx_pd, },
320 #ifdef CONFIG_PPC_MPC512x
321 	{ .compatible = "fsl,mpc5121-usb2-dr", .data = &fsl_usb2_mpc5121_pd, },
322 #endif
323 	{},
324 };
325 
326 static struct platform_driver fsl_usb2_mph_dr_driver = {
327 	.driver = {
328 		.name = "fsl-usb2-mph-dr",
329 		.of_match_table = fsl_usb2_mph_dr_of_match,
330 	},
331 	.probe	= fsl_usb2_mph_dr_of_probe,
332 	.remove	= fsl_usb2_mph_dr_of_remove,
333 };
334 
335 module_platform_driver(fsl_usb2_mph_dr_driver);
336 
337 MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
338 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
339 MODULE_LICENSE("GPL");
340