1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * MISC driver for TI MUSB Glue.
4 *
5 * (C) Copyright 2016
6 * Texas Instruments Incorporated, <www.ti.com>
7 */
8 #include <common.h>
9 #include <command.h>
10 #include <console.h>
11 #include <dm.h>
12 #include <log.h>
13 #include <malloc.h>
14 #include <asm/global_data.h>
15 #include <linux/usb/otg.h>
16 #include <dm/device-internal.h>
17 #include <dm/lists.h>
18
19 #include <asm/io.h>
20 #include <asm/omap_musb.h>
21 #include "musb_uboot.h"
22
23 DECLARE_GLOBAL_DATA_PTR;
24
25 #if CONFIG_IS_ENABLED(DM_USB)
26 /* USB 2.0 PHY Control */
27 #define CM_PHY_PWRDN (1 << 0)
28 #define CM_PHY_OTG_PWRDN (1 << 1)
29 #define OTGVDET_EN (1 << 19)
30 #define OTGSESSENDEN (1 << 20)
31
32 #define AM335X_USB0_CTRL 0x0
33 #define AM335X_USB1_CTRL 0x8
34
ti_musb_set_phy_power(struct udevice * dev,u8 on)35 static void ti_musb_set_phy_power(struct udevice *dev, u8 on)
36 {
37 struct ti_musb_plat *plat = dev_get_plat(dev);
38
39 if (!plat->ctrl_mod_base)
40 return;
41
42 if (on) {
43 clrsetbits_le32(plat->ctrl_mod_base,
44 CM_PHY_PWRDN | CM_PHY_OTG_PWRDN,
45 OTGVDET_EN | OTGSESSENDEN);
46 } else {
47 clrsetbits_le32(plat->ctrl_mod_base, 0,
48 CM_PHY_PWRDN | CM_PHY_OTG_PWRDN);
49 }
50 }
51
52 #if CONFIG_IS_ENABLED(OF_CONTROL)
53
ti_musb_get_usb_index(int node)54 static int ti_musb_get_usb_index(int node)
55 {
56 const void *fdt = gd->fdt_blob;
57 int i = 0;
58 char path[64];
59 const char *alias_path;
60 char alias[16];
61
62 fdt_get_path(fdt, node, path, sizeof(path));
63
64 do {
65 snprintf(alias, sizeof(alias), "usb%d", i);
66 alias_path = fdt_get_alias(fdt, alias);
67 if (alias_path == NULL) {
68 debug("USB index not found\n");
69 return -ENOENT;
70 }
71
72 if (!strcmp(path, alias_path))
73 return i;
74
75 i++;
76 } while (alias_path);
77
78 return -ENOENT;
79 }
80
ti_musb_of_to_plat(struct udevice * dev)81 static int ti_musb_of_to_plat(struct udevice *dev)
82 {
83 struct ti_musb_plat *plat = dev_get_plat(dev);
84 const void *fdt = gd->fdt_blob;
85 int node = dev_of_offset(dev);
86 int phys;
87 int ctrl_mod;
88 int usb_index;
89 struct musb_hdrc_config *musb_config;
90
91 plat->base = (void *)devfdt_get_addr_index(dev, 1);
92
93 phys = fdtdec_lookup_phandle(fdt, node, "phys");
94 ctrl_mod = fdtdec_lookup_phandle(fdt, phys, "ti,ctrl_mod");
95 plat->ctrl_mod_base = (void *)fdtdec_get_addr(fdt, ctrl_mod, "reg");
96 usb_index = ti_musb_get_usb_index(node);
97 switch (usb_index) {
98 case 1:
99 plat->ctrl_mod_base += AM335X_USB1_CTRL;
100 break;
101 case 0:
102 plat->ctrl_mod_base += AM335X_USB0_CTRL;
103 break;
104 default:
105 break;
106 }
107
108 musb_config = malloc(sizeof(struct musb_hdrc_config));
109 memset(musb_config, 0, sizeof(struct musb_hdrc_config));
110
111 musb_config->multipoint = fdtdec_get_int(fdt, node,
112 "mentor,multipoint", -1);
113 if (musb_config->multipoint < 0) {
114 pr_err("MUSB multipoint DT entry missing\n");
115 return -ENOENT;
116 }
117
118 musb_config->dyn_fifo = 1;
119
120 musb_config->num_eps = fdtdec_get_int(fdt, node, "mentor,num-eps",
121 -1);
122 if (musb_config->num_eps < 0) {
123 pr_err("MUSB num-eps DT entry missing\n");
124 return -ENOENT;
125 }
126
127 musb_config->ram_bits = fdtdec_get_int(fdt, node, "mentor,ram-bits",
128 -1);
129 if (musb_config->ram_bits < 0) {
130 pr_err("MUSB ram-bits DT entry missing\n");
131 return -ENOENT;
132 }
133
134 plat->plat.config = musb_config;
135
136 plat->plat.power = fdtdec_get_int(fdt, node, "mentor,power", -1);
137 if (plat->plat.power < 0) {
138 pr_err("MUSB mentor,power DT entry missing\n");
139 return -ENOENT;
140 }
141
142 plat->plat.platform_ops = &musb_dsps_ops;
143
144 return 0;
145 }
146 #endif
147
ti_musb_host_probe(struct udevice * dev)148 static int ti_musb_host_probe(struct udevice *dev)
149 {
150 struct musb_host_data *host = dev_get_priv(dev);
151 struct ti_musb_plat *plat = dev_get_plat(dev);
152 struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
153 int ret;
154
155 priv->desc_before_addr = true;
156
157 host->host = musb_init_controller(&plat->plat,
158 NULL,
159 plat->base);
160 if (!host->host)
161 return -EIO;
162
163 ti_musb_set_phy_power(dev, 1);
164 ret = musb_lowlevel_init(host);
165
166 return ret;
167 }
168
ti_musb_host_remove(struct udevice * dev)169 static int ti_musb_host_remove(struct udevice *dev)
170 {
171 struct musb_host_data *host = dev_get_priv(dev);
172
173 musb_stop(host->host);
174 ti_musb_set_phy_power(dev, 0);
175
176 return 0;
177 }
178
179 #if CONFIG_IS_ENABLED(OF_CONTROL)
ti_musb_host_of_to_plat(struct udevice * dev)180 static int ti_musb_host_of_to_plat(struct udevice *dev)
181 {
182 struct ti_musb_plat *plat = dev_get_plat(dev);
183 const void *fdt = gd->fdt_blob;
184 int node = dev_of_offset(dev);
185 int ret;
186
187 ret = ti_musb_of_to_plat(dev);
188 if (ret) {
189 pr_err("plat dt parse error\n");
190 return ret;
191 }
192
193 plat->plat.mode = MUSB_HOST;
194
195 return 0;
196 }
197 #endif
198
199 U_BOOT_DRIVER(ti_musb_host) = {
200 .name = "ti-musb-host",
201 .id = UCLASS_USB,
202 #if CONFIG_IS_ENABLED(OF_CONTROL)
203 .of_to_plat = ti_musb_host_of_to_plat,
204 #endif
205 .probe = ti_musb_host_probe,
206 .remove = ti_musb_host_remove,
207 .ops = &musb_usb_ops,
208 .plat_auto = sizeof(struct ti_musb_plat),
209 .priv_auto = sizeof(struct musb_host_data),
210 };
211
212 #if CONFIG_IS_ENABLED(DM_USB_GADGET)
213 struct ti_musb_peripheral {
214 struct musb *periph;
215 };
216
217 #if CONFIG_IS_ENABLED(OF_CONTROL)
ti_musb_peripheral_of_to_plat(struct udevice * dev)218 static int ti_musb_peripheral_of_to_plat(struct udevice *dev)
219 {
220 struct ti_musb_plat *plat = dev_get_plat(dev);
221 const void *fdt = gd->fdt_blob;
222 int node = dev_of_offset(dev);
223 int ret;
224
225 ret = ti_musb_of_to_plat(dev);
226 if (ret) {
227 pr_err("plat dt parse error\n");
228 return ret;
229 }
230 plat->plat.mode = MUSB_PERIPHERAL;
231
232 return 0;
233 }
234 #endif
235
dm_usb_gadget_handle_interrupts(struct udevice * dev)236 int dm_usb_gadget_handle_interrupts(struct udevice *dev)
237 {
238 struct ti_musb_peripheral *priv = dev_get_priv(dev);
239
240 priv->periph->isr(0, priv->periph);
241
242 return 0;
243 }
244
ti_musb_peripheral_probe(struct udevice * dev)245 static int ti_musb_peripheral_probe(struct udevice *dev)
246 {
247 struct ti_musb_peripheral *priv = dev_get_priv(dev);
248 struct ti_musb_plat *plat = dev_get_plat(dev);
249 int ret;
250
251 priv->periph = musb_init_controller(&plat->plat,
252 NULL,
253 plat->base);
254 if (!priv->periph)
255 return -EIO;
256
257 ti_musb_set_phy_power(dev, 1);
258 musb_gadget_setup(priv->periph);
259 return usb_add_gadget_udc((struct device *)dev, &priv->periph->g);
260 }
261
ti_musb_peripheral_remove(struct udevice * dev)262 static int ti_musb_peripheral_remove(struct udevice *dev)
263 {
264 struct ti_musb_peripheral *priv = dev_get_priv(dev);
265
266 usb_del_gadget_udc(&priv->periph->g);
267 ti_musb_set_phy_power(dev, 0);
268
269 return 0;
270 }
271
272 U_BOOT_DRIVER(ti_musb_peripheral) = {
273 .name = "ti-musb-peripheral",
274 .id = UCLASS_USB_GADGET_GENERIC,
275 #if CONFIG_IS_ENABLED(OF_CONTROL)
276 .of_to_plat = ti_musb_peripheral_of_to_plat,
277 #endif
278 .probe = ti_musb_peripheral_probe,
279 .remove = ti_musb_peripheral_remove,
280 .ops = &musb_usb_ops,
281 .plat_auto = sizeof(struct ti_musb_plat),
282 .priv_auto = sizeof(struct ti_musb_peripheral),
283 .flags = DM_FLAG_PRE_RELOC,
284 };
285 #endif
286
287 #if CONFIG_IS_ENABLED(OF_CONTROL)
ti_musb_wrapper_bind(struct udevice * parent)288 static int ti_musb_wrapper_bind(struct udevice *parent)
289 {
290 ofnode node;
291 int ret;
292
293 ofnode_for_each_subnode(node, dev_ofnode(parent)) {
294 struct udevice *dev;
295 const char *name = ofnode_get_name(node);
296 enum usb_dr_mode dr_mode;
297 struct driver *drv;
298
299 if (strncmp(name, "usb@", 4))
300 continue;
301
302 dr_mode = usb_get_dr_mode(node);
303 switch (dr_mode) {
304 case USB_DR_MODE_PERIPHERAL:
305 /* Bind MUSB device */
306 ret = device_bind_driver_to_node(parent,
307 "ti-musb-peripheral",
308 name,
309 node,
310 &dev);
311 if (ret)
312 pr_err("musb - not able to bind usb peripheral node\n");
313 break;
314 case USB_DR_MODE_HOST:
315 /* Bind MUSB host */
316 ret = device_bind_driver_to_node(parent,
317 "ti-musb-host",
318 name,
319 node,
320 &dev);
321 if (ret)
322 pr_err("musb - not able to bind usb host node\n");
323 break;
324 default:
325 break;
326 };
327 }
328 return 0;
329 }
330
331 static const struct udevice_id ti_musb_ids[] = {
332 { .compatible = "ti,am33xx-usb" },
333 { }
334 };
335
336 U_BOOT_DRIVER(ti_musb_wrapper) = {
337 .name = "ti-musb-wrapper",
338 .id = UCLASS_MISC,
339 .of_match = ti_musb_ids,
340 .bind = ti_musb_wrapper_bind,
341 };
342 #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */
343
344 #endif /* CONFIG_IS_ENABLED(DM_USB) */
345