]> git.sur5r.net Git - u-boot/blob - drivers/usb/host/ehci-fsl.c
97b7f14542591cf22e4e576ddbc21512f1e49fa9
[u-boot] / drivers / usb / host / ehci-fsl.c
1 /*
2  * (C) Copyright 2009, 2011 Freescale Semiconductor, Inc.
3  *
4  * (C) Copyright 2008, Excito Elektronik i Sk=E5ne AB
5  *
6  * Author: Tor Krill tor@excito.com
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10
11 #include <common.h>
12 #include <pci.h>
13 #include <usb.h>
14 #include <asm/io.h>
15 #include <usb/ehci-fsl.h>
16 #include <hwconfig.h>
17 #include <fsl_usb.h>
18 #include <fdt_support.h>
19
20 #include "ehci.h"
21
22 #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
23 #define CONFIG_USB_MAX_CONTROLLER_COUNT 1
24 #endif
25
26 static void set_txfifothresh(struct usb_ehci *, u32);
27
28 /* Check USB PHY clock valid */
29 static int usb_phy_clk_valid(struct usb_ehci *ehci)
30 {
31         if (!((in_be32(&ehci->control) & PHY_CLK_VALID) ||
32                         in_be32(&ehci->prictrl))) {
33                 printf("USB PHY clock invalid!\n");
34                 return 0;
35         } else {
36                 return 1;
37         }
38 }
39
40 /*
41  * Create the appropriate control structures to manage
42  * a new EHCI host controller.
43  *
44  * Excerpts from linux ehci fsl driver.
45  */
46 int ehci_hcd_init(int index, enum usb_init_type init,
47                 struct ehci_hccr **hccr, struct ehci_hcor **hcor)
48 {
49         struct usb_ehci *ehci = NULL;
50         const char *phy_type = NULL;
51         size_t len;
52         char current_usb_controller[5];
53 #ifdef CONFIG_SYS_FSL_USB_INTERNAL_UTMI_PHY
54         char usb_phy[5];
55
56         usb_phy[0] = '\0';
57 #endif
58         if (has_erratum_a007075()) {
59                 /*
60                  * A 5ms delay is needed after applying soft-reset to the
61                  * controller to let external ULPI phy come out of reset.
62                  * This delay needs to be added before re-initializing
63                  * the controller after soft-resetting completes
64                  */
65                 mdelay(5);
66         }
67         memset(current_usb_controller, '\0', 5);
68         snprintf(current_usb_controller, 4, "usb%d", index+1);
69
70         switch (index) {
71         case 0:
72                 ehci = (struct usb_ehci *)CONFIG_SYS_FSL_USB1_ADDR;
73                 break;
74         case 1:
75                 ehci = (struct usb_ehci *)CONFIG_SYS_FSL_USB2_ADDR;
76                 break;
77         default:
78                 printf("ERROR: wrong controller index!!\n");
79                 return -EINVAL;
80         };
81
82         *hccr = (struct ehci_hccr *)((uint32_t)&ehci->caplength);
83         *hcor = (struct ehci_hcor *)((uint32_t) *hccr +
84                         HC_LENGTH(ehci_readl(&(*hccr)->cr_capbase)));
85
86         /* Set to Host mode */
87         setbits_le32(&ehci->usbmode, CM_HOST);
88
89         out_be32(&ehci->snoop1, SNOOP_SIZE_2GB);
90         out_be32(&ehci->snoop2, 0x80000000 | SNOOP_SIZE_2GB);
91
92         /* Init phy */
93         if (hwconfig_sub(current_usb_controller, "phy_type"))
94                 phy_type = hwconfig_subarg(current_usb_controller,
95                                 "phy_type", &len);
96         else
97                 phy_type = getenv("usb_phy_type");
98
99         if (!phy_type) {
100 #ifdef CONFIG_SYS_FSL_USB_INTERNAL_UTMI_PHY
101                 /* if none specified assume internal UTMI */
102                 strcpy(usb_phy, "utmi");
103                 phy_type = usb_phy;
104 #else
105                 printf("WARNING: USB phy type not defined !!\n");
106                 return -1;
107 #endif
108         }
109
110         if (!strncmp(phy_type, "utmi", 4)) {
111 #if defined(CONFIG_SYS_FSL_USB_INTERNAL_UTMI_PHY)
112                 clrsetbits_be32(&ehci->control, CONTROL_REGISTER_W1C_MASK,
113                                 PHY_CLK_SEL_UTMI);
114                 clrsetbits_be32(&ehci->control, CONTROL_REGISTER_W1C_MASK,
115                                 UTMI_PHY_EN);
116                 udelay(1000); /* delay required for PHY Clk to appear */
117 #endif
118                 out_le32(&(*hcor)->or_portsc[0], PORT_PTS_UTMI);
119                 clrsetbits_be32(&ehci->control, CONTROL_REGISTER_W1C_MASK,
120                                 USB_EN);
121         } else {
122                 clrsetbits_be32(&ehci->control, CONTROL_REGISTER_W1C_MASK,
123                                 PHY_CLK_SEL_ULPI);
124                 clrsetbits_be32(&ehci->control, UTMI_PHY_EN |
125                                 CONTROL_REGISTER_W1C_MASK, USB_EN);
126                 udelay(1000); /* delay required for PHY Clk to appear */
127                 if (!usb_phy_clk_valid(ehci))
128                         return -EINVAL;
129                 out_le32(&(*hcor)->or_portsc[0], PORT_PTS_ULPI);
130         }
131
132         out_be32(&ehci->prictrl, 0x0000000c);
133         out_be32(&ehci->age_cnt_limit, 0x00000040);
134         out_be32(&ehci->sictrl, 0x00000001);
135
136         in_le32(&ehci->usbmode);
137
138         if (has_erratum_a007798())
139                 set_txfifothresh(ehci, TXFIFOTHRESH);
140
141         if (has_erratum_a004477()) {
142                 /*
143                  * When reset is issued while any ULPI transaction is ongoing
144                  * then it may result to corruption of ULPI Function Control
145                  * Register which eventually causes phy clock to enter low
146                  * power mode which stops the clock. Thus delay is required
147                  * before reset to let ongoing ULPI transaction complete.
148                  */
149                 udelay(1);
150         }
151         return 0;
152 }
153
154 /*
155  * Destroy the appropriate control structures corresponding
156  * the the EHCI host controller.
157  */
158 int ehci_hcd_stop(int index)
159 {
160         return 0;
161 }
162
163 /*
164  * Setting the value of TXFIFO_THRESH field in TXFILLTUNING register
165  * to counter DDR latencies in writing data into Tx buffer.
166  * This prevents Tx buffer from getting underrun
167  */
168 static void set_txfifothresh(struct usb_ehci *ehci, u32 txfifo_thresh)
169 {
170         u32 cmd;
171         cmd = ehci_readl(&ehci->txfilltuning);
172         cmd &= ~TXFIFO_THRESH_MASK;
173         cmd |= TXFIFO_THRESH(txfifo_thresh);
174         ehci_writel(&ehci->txfilltuning, cmd);
175 }
176
177 #if defined(CONFIG_HAS_FSL_DR_USB) || defined(CONFIG_HAS_FSL_MPH_USB)
178 static int fdt_fixup_usb_mode_phy_type(void *blob, const char *mode,
179                                        const char *phy_type, int start_offset)
180 {
181         const char *compat_dr = "fsl-usb2-dr";
182         const char *compat_mph = "fsl-usb2-mph";
183         const char *prop_mode = "dr_mode";
184         const char *prop_type = "phy_type";
185         const char *node_type = NULL;
186         int node_offset;
187         int err;
188
189         node_offset = fdt_node_offset_by_compatible(blob,
190                                                     start_offset, compat_mph);
191         if (node_offset < 0) {
192                 node_offset = fdt_node_offset_by_compatible(blob,
193                                                             start_offset,
194                                                             compat_dr);
195                 if (node_offset < 0) {
196                         printf("WARNING: could not find compatible node: %s",
197                                fdt_strerror(node_offset));
198                         return -1;
199                 }
200                 node_type = compat_dr;
201         } else {
202                 node_type = compat_mph;
203         }
204
205         if (mode) {
206                 err = fdt_setprop(blob, node_offset, prop_mode, mode,
207                                   strlen(mode) + 1);
208                 if (err < 0)
209                         printf("WARNING: could not set %s for %s: %s.\n",
210                                prop_mode, node_type, fdt_strerror(err));
211         }
212
213         if (phy_type) {
214                 err = fdt_setprop(blob, node_offset, prop_type, phy_type,
215                                   strlen(phy_type) + 1);
216                 if (err < 0)
217                         printf("WARNING: could not set %s for %s: %s.\n",
218                                prop_type, node_type, fdt_strerror(err));
219         }
220
221         return node_offset;
222 }
223
224 static const char *fdt_usb_get_node_type(void *blob, int start_offset,
225                                          int *node_offset)
226 {
227         const char *compat_dr = "fsl-usb2-dr";
228         const char *compat_mph = "fsl-usb2-mph";
229         const char *node_type = NULL;
230
231         *node_offset = fdt_node_offset_by_compatible(blob, start_offset,
232                                                      compat_mph);
233         if (*node_offset < 0) {
234                 *node_offset = fdt_node_offset_by_compatible(blob,
235                                                              start_offset,
236                                                              compat_dr);
237                 if (*node_offset < 0) {
238                         printf("ERROR: could not find compatible node: %s\n",
239                                fdt_strerror(*node_offset));
240                 } else {
241                         node_type = compat_dr;
242                 }
243         } else {
244                 node_type = compat_mph;
245         }
246
247         return node_type;
248 }
249
250 static int fdt_fixup_usb_erratum(void *blob, const char *prop_erratum,
251                                  int start_offset)
252 {
253         int node_offset, err;
254         const char *node_type = NULL;
255
256         node_type = fdt_usb_get_node_type(blob, start_offset, &node_offset);
257         if (!node_type)
258                 return -1;
259
260         err = fdt_setprop(blob, node_offset, prop_erratum, NULL, 0);
261         if (err < 0) {
262                 printf("ERROR: could not set %s for %s: %s.\n",
263                        prop_erratum, node_type, fdt_strerror(err));
264         }
265
266         return node_offset;
267 }
268
269 void fdt_fixup_dr_usb(void *blob, bd_t *bd)
270 {
271         static const char * const modes[] = { "host", "peripheral", "otg" };
272         static const char * const phys[] = { "ulpi", "utmi", "utmi_dual" };
273         int usb_erratum_a006261_off = -1;
274         int usb_erratum_a007075_off = -1;
275         int usb_erratum_a007792_off = -1;
276         int usb_erratum_a005697_off = -1;
277         int usb_mode_off = -1;
278         int usb_phy_off = -1;
279         char str[5];
280         int i, j;
281
282         for (i = 1; i <= CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
283                 const char *dr_mode_type = NULL;
284                 const char *dr_phy_type = NULL;
285                 int mode_idx = -1, phy_idx = -1;
286
287                 snprintf(str, 5, "%s%d", "usb", i);
288                 if (hwconfig(str)) {
289                         for (j = 0; j < ARRAY_SIZE(modes); j++) {
290                                 if (hwconfig_subarg_cmp(str, "dr_mode",
291                                                         modes[j])) {
292                                         mode_idx = j;
293                                         break;
294                                 }
295                         }
296
297                         for (j = 0; j < ARRAY_SIZE(phys); j++) {
298                                 if (hwconfig_subarg_cmp(str, "phy_type",
299                                                         phys[j])) {
300                                         phy_idx = j;
301                                         break;
302                                 }
303                         }
304
305                         if (mode_idx < 0 && phy_idx < 0) {
306                                 printf("WARNING: invalid phy or mode\n");
307                                 return;
308                         }
309
310                         if (mode_idx > -1)
311                                 dr_mode_type = modes[mode_idx];
312
313                         if (phy_idx > -1)
314                                 dr_phy_type = phys[phy_idx];
315                 }
316
317                 if (has_dual_phy())
318                         dr_phy_type = phys[2];
319
320                 usb_mode_off = fdt_fixup_usb_mode_phy_type(blob,
321                                                            dr_mode_type, NULL,
322                                                            usb_mode_off);
323
324                 if (usb_mode_off < 0)
325                         return;
326
327                 usb_phy_off = fdt_fixup_usb_mode_phy_type(blob,
328                                                           NULL, dr_phy_type,
329                                                           usb_phy_off);
330
331                 if (usb_phy_off < 0)
332                         return;
333
334                 if (has_erratum_a006261()) {
335                         usb_erratum_a006261_off =  fdt_fixup_usb_erratum
336                                                    (blob,
337                                                     "fsl,usb-erratum-a006261",
338                                                     usb_erratum_a006261_off);
339                         if (usb_erratum_a006261_off < 0)
340                                 return;
341                 }
342
343                 if (has_erratum_a007075()) {
344                         usb_erratum_a007075_off =  fdt_fixup_usb_erratum
345                                                    (blob,
346                                                     "fsl,usb-erratum-a007075",
347                                                     usb_erratum_a007075_off);
348                         if (usb_erratum_a007075_off < 0)
349                                 return;
350                 }
351
352                 if (has_erratum_a007792()) {
353                         usb_erratum_a007792_off =  fdt_fixup_usb_erratum
354                                                    (blob,
355                                                     "fsl,usb-erratum-a007792",
356                                                     usb_erratum_a007792_off);
357                         if (usb_erratum_a007792_off < 0)
358                                 return;
359                 }
360                 if (has_erratum_a005697()) {
361                         usb_erratum_a005697_off =  fdt_fixup_usb_erratum
362                                                    (blob,
363                                                     "fsl,usb-erratum-a005697",
364                                                     usb_erratum_a005697_off);
365                         if (usb_erratum_a005697_off < 0)
366                                 return;
367                 }
368         }
369 }
370 #endif