1
2
3
4
5
6
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
23DECLARE_GLOBAL_DATA_PTR;
24
25#if CONFIG_IS_ENABLED(DM_USB)
26
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
35static 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
54static 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
81static 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
148static 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
169static 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)
180static 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
199U_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)
213struct ti_musb_peripheral {
214 struct musb *periph;
215};
216
217#if CONFIG_IS_ENABLED(OF_CONTROL)
218static 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
236int 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
245static 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
262static 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
272U_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)
288static 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
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
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
331static const struct udevice_id ti_musb_ids[] = {
332 { .compatible = "ti,am33xx-usb" },
333 { }
334};
335
336U_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
343
344#endif
345
