drivers: usb: fsl: Return if USB_MAX_CONTROLLER_COUNT is incorrect

[u-boot] / drivers / usb / host / ehci-fsl.c

diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 54efe5ef00e75a998c006b55c1e5dbb8866b19a9..97b7f14542591cf22e4e576ddbc21512f1e49fa9 100644 (file)
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -76,7 +76,7 @@ int ehci_hcd_init(int index, enum usb_init_type init,
                break;
        default:
                printf("ERROR: wrong controller index!!\n");
-               break;
+               return -EINVAL;
        };
 
        *hccr = (struct ehci_hccr *)((uint32_t)&ehci->caplength);
@@ -138,6 +138,16 @@ int ehci_hcd_init(int index, enum usb_init_type init,
        if (has_erratum_a007798())
                set_txfifothresh(ehci, TXFIFOTHRESH);
 
+       if (has_erratum_a004477()) {
+               /*
+                * When reset is issued while any ULPI transaction is ongoing
+                * then it may result to corruption of ULPI Function Control
+                * Register which eventually causes phy clock to enter low
+                * power mode which stops the clock. Thus delay is required
+                * before reset to let ongoing ULPI transaction complete.
+                */
+               udelay(1);
+       }
        return 0;
 }
 
@@ -211,10 +221,59 @@ static int fdt_fixup_usb_mode_phy_type(void *blob, const char *mode,
        return node_offset;
 }
 
+static const char *fdt_usb_get_node_type(void *blob, int start_offset,
+                                        int *node_offset)
+{
+       const char *compat_dr = "fsl-usb2-dr";
+       const char *compat_mph = "fsl-usb2-mph";
+       const char *node_type = NULL;
+
+       *node_offset = fdt_node_offset_by_compatible(blob, start_offset,
+                                                    compat_mph);
+       if (*node_offset < 0) {
+               *node_offset = fdt_node_offset_by_compatible(blob,
+                                                            start_offset,
+                                                            compat_dr);
+               if (*node_offset < 0) {
+                       printf("ERROR: could not find compatible node: %s\n",
+                              fdt_strerror(*node_offset));
+               } else {
+                       node_type = compat_dr;
+               }
+       } else {
+               node_type = compat_mph;
+       }
+
+       return node_type;
+}
+
+static int fdt_fixup_usb_erratum(void *blob, const char *prop_erratum,
+                                int start_offset)
+{
+       int node_offset, err;
+       const char *node_type = NULL;
+
+       node_type = fdt_usb_get_node_type(blob, start_offset, &node_offset);
+       if (!node_type)
+               return -1;
+
+       err = fdt_setprop(blob, node_offset, prop_erratum, NULL, 0);
+       if (err < 0) {
+               printf("ERROR: could not set %s for %s: %s.\n",
+                      prop_erratum, node_type, fdt_strerror(err));
+       }
+
+       return node_offset;
+}
+
 void fdt_fixup_dr_usb(void *blob, bd_t *bd)
 {
        static const char * const modes[] = { "host", "peripheral", "otg" };
-       static const char * const phys[] = { "ulpi", "utmi" };
+       static const char * const phys[] = { "ulpi", "utmi", "utmi_dual" };
+       int usb_erratum_a006261_off = -1;
+       int usb_erratum_a007075_off = -1;
+       int usb_erratum_a007792_off = -1;
+       int usb_erratum_a005697_off = -1;
        int usb_mode_off = -1;
        int usb_phy_off = -1;
        char str[5];
@@ -255,6 +314,9 @@ void fdt_fixup_dr_usb(void *blob, bd_t *bd)
                                dr_phy_type = phys[phy_idx];
                }
 
+               if (has_dual_phy())
+                       dr_phy_type = phys[2];
+
                usb_mode_off = fdt_fixup_usb_mode_phy_type(blob,
                                                           dr_mode_type, NULL,
                                                           usb_mode_off);
@@ -268,6 +330,41 @@ void fdt_fixup_dr_usb(void *blob, bd_t *bd)
 
                if (usb_phy_off < 0)
                        return;
+
+               if (has_erratum_a006261()) {
+                       usb_erratum_a006261_off =  fdt_fixup_usb_erratum
+                                                  (blob,
+                                                   "fsl,usb-erratum-a006261",
+                                                   usb_erratum_a006261_off);
+                       if (usb_erratum_a006261_off < 0)
+                               return;
+               }
+
+               if (has_erratum_a007075()) {
+                       usb_erratum_a007075_off =  fdt_fixup_usb_erratum
+                                                  (blob,
+                                                   "fsl,usb-erratum-a007075",
+                                                   usb_erratum_a007075_off);
+                       if (usb_erratum_a007075_off < 0)
+                               return;
+               }
+
+               if (has_erratum_a007792()) {
+                       usb_erratum_a007792_off =  fdt_fixup_usb_erratum
+                                                  (blob,
+                                                   "fsl,usb-erratum-a007792",
+                                                   usb_erratum_a007792_off);
+                       if (usb_erratum_a007792_off < 0)
+                               return;
+               }
+               if (has_erratum_a005697()) {
+                       usb_erratum_a005697_off =  fdt_fixup_usb_erratum
+                                                  (blob,
+                                                   "fsl,usb-erratum-a005697",
+                                                   usb_erratum_a005697_off);
+                       if (usb_erratum_a005697_off < 0)
+                               return;
+               }
        }
 }
 #endif