]> git.kernelconcepts.de Git - karo-tx-redboot.git/blobdiff - packages/hal/arm/mx53/karo/v1_0/src/tx53_misc.c
RedBoot Release TX53-v3 2012-02-08
[karo-tx-redboot.git] / packages / hal / arm / mx53 / karo / v1_0 / src / tx53_misc.c
index 39de7b5f3e297d5dd064c99ef6e7df55f2d38c95..d3d03b7ba4869cd69b315eaf83612e1843c4f52c 100644 (file)
@@ -602,13 +602,7 @@ void tx53_program_new_stack(void *func)
        stack_ptr = old_stack;
 }
 
-#if CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2
-#define PMIC_NAME                      "LP3972"
-#elif CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 3
 #define PMIC_NAME                      "LT3598"
-#else
-#error Bad CYGNUM_HAL_ARM_TX53_SDRAM_TYPE
-#endif
 
 static int pmic_reg_read(cyg_uint8 reg)
 {
@@ -618,6 +612,10 @@ static int pmic_reg_read(cyg_uint8 reg)
        if (ret < 0)
                diag_printf("Failed to read %s reg 0x%02x %d\n", PMIC_NAME,
                                        reg, ret);
+#ifdef DEBUG
+       else
+               diag_printf("read %02x from reg %02x\n", ret, reg);
+#endif
        return ret;
 }
 
@@ -629,47 +627,17 @@ static int pmic_reg_write(cyg_uint8 reg, cyg_uint8 val)
        if (ret)
                diag_printf("Failed to write 0x%02x to %s reg 0x%02x: %d\n",
                                        val, PMIC_NAME, reg, ret);
+#ifdef DEBUG
+       else
+               diag_printf("wrote %02x to reg %02x\n", val, reg);
+#endif
        return ret;
 }
 
-#if CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2
-int tx53_fuse_voltage(int on)
-{
-       int ret;
-
-       ret = pmic_reg_read(0x81);
-       if (ret < 0)
-               return ret;
-
-       /* Try to enable FUSE_VDD by asserting LP3972 GPIO1 */
-       ret = (ret & ~0x3) | (on ? 1 : 3);
-       ret = pmic_reg_write(0x81, ret);
-       if (ret) {
-               return ret;
-       }
-       ret = pmic_reg_read(0x81);
-       if ((ret & 0x3) != (on ? 0x1 : 0x3)) {
-               return -EIO;
-       }
-       return 0;
-}
-
-#define CORE_VOLTAGE_HIGH              0x1b
-#define CORE_VOLTAGE_LOW               0x03
-#if CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ_512M
-#define SDRAM_SIZE_STR                 '0'
-#else
-#if CYGNUM_HAL_ARM_TX53_CPU_CLK == 1000
-#define SDRAM_SIZE_STR                 '2'
-#else
-#define SDRAM_SIZE_STR                 '1'
-#endif /* CYGNUM_HAL_ARM_TX53_CPU_CLK == 1000 */
-#endif /* CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ512M */
-
-#elif CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 3
 int tx53_fuse_voltage(int on)
 {
        int ret;
+       int retries = 0;
 
        if (on) {
                ret = pmic_reg_read(0x33);
@@ -695,80 +663,127 @@ int tx53_fuse_voltage(int on)
                        return ret;
 
                if (!(ret & (1 << 6))) {
-                       ret |= 1 << 6; /* LDO4 Startup: don't wait for output < 300mV */
-                       ret = pmic_reg_write(0x12, ret);
+                       ret = pmic_reg_write(0x12, ret | (1 << 6));
                        if (ret)
-                               return -EIO;
-                       ret = pmic_reg_read(0x12);
-                       if (!(ret & (1 << 6))) {
-                               diag_printf("Could not set LT3589 LDO4 Startup control\n");
-                               return -EIO;
+                               return ret;
+               }
+
+               /* enable SW regulator control and all regulators */
+               ret = pmic_reg_write(0x10, 0xff);
+               if (ret)
+                       return ret;
+
+               for (;;) {
+                       ret = pmic_reg_read(0x13);
+                       if (ret < 0)
+                               return ret;
+                       if (ret & (1 << 7))
+                               break;
+
+#ifdef DEBUG
+                       if (retries == 0)
+                               diag_printf("Waiting for LDO4 PGOOD\n");
+#endif
+                       HAL_DELAY_US(100);
+                       if (++retries >= 1000) {
+                               diag_printf("Failed to enable LDO4\n");
+                               return -ETIMEDOUT;
                        }
                }
+       } else {
+               ret = pmic_reg_write(0x10, 0xbf);
+               if (ret)
+                       return ret;
+
+               ret = pmic_reg_read(0x12);
+               if (ret < 0)
+                       return ret;
+               if (ret & (1 << 6)) {
+                       ret = pmic_reg_write(0x12, ret & ~(1 << 6));
+                       if (ret)
+                               return ret;
+               }
        }
-       /* enable SW regulator control and all regulators (except LDO4, if !on) */
-       ret = pmic_reg_write(0x10, 0xbf | (!!on << 6));
-       if (ret)
-               return ret;
 
        ret = pmic_reg_read(0x10);
        if (ret < 0)
                return ret;
 
        if (!(ret & (1 << 6)) ^ !on) {
-               diag_printf("Could not enable LT3589 LDO4 output\n");
+               diag_printf("Could not %sable LT3589 LDO4 output\n",
+                                       on ? "en" : "dis");
                return -EIO;
        }
        return 0;
 }
 
-#define CORE_VOLTAGE_HIGH              0x1c
-#define CORE_VOLTAGE_LOW               0x17
-#if CYGNUM_HAL_ARM_TX53_SDRAM_SIZE == SZ_512M
-#define SDRAM_SIZE_STR                 '0'
-#else
-#define SDRAM_SIZE_STR                 '1'
-#endif
-#endif
+#define LT3589_PGOOD_MASK              (1 << 5)
+#define LT3589_SLEW_RATE(n)            (((n) & 3) << 6)
+#define CORE_VOLTAGE_1200              0x1e
+#define CORE_VOLTAGE_1000              0x19
+#define CORE_VOLTAGE_800               0x13
 
-void increase_core_voltage(bool high)
+int adjust_core_voltage(unsigned int clock)
 {
        int ret;
-       const int volt = high ? CORE_VOLTAGE_HIGH : CORE_VOLTAGE_LOW;
+       int volt;
+       int retries = 0;
+
+       switch (clock) {
+       case 1200:
+               volt = CORE_VOLTAGE_1200;
+               break;
+
+       case 1000:
+               volt = CORE_VOLTAGE_1000;
+               break;
+
+       case 800:
+               volt = CORE_VOLTAGE_800;
+               break;
+
+       default:
+               if (clock > 1200) {
+                       diag_printf("No core voltage assigned for %u MHz core clock\n",
+                                               clock);
+                       return -EINVAL;
+               }
+               volt = CORE_VOLTAGE_800;
+       }
 
        ret = pmic_reg_read(0x23);
        if (ret < 0) {
-               diag_printf("Failed to read core voltage: %d\n", ret);
-               return;
+               return ret;
        }
 
-       ret = pmic_reg_write(0x23, volt);
+       ret = pmic_reg_write(0x23, volt | LT3589_SLEW_RATE(3) | LT3589_PGOOD_MASK);
        if (ret < 0) {
-               diag_printf("Failed to write core voltage: %d\n", ret);
+               return ret;
        }
-}
 
-static void display_board_type(void)
-{
-       char cpu_freq;
-       const char *ddr_type = _stringify(CYGNUM_HAL_ARM_TX53_SDRAM_TYPE);
-
-       switch (CYGNUM_HAL_ARM_TX53_CPU_CLK) {
-       case 800:
-               cpu_freq = '8';
-               break;
+       ret = pmic_reg_read(0x20);
+       if (ret < 0)
+               return ret;
 
-       case 1000:
-               cpu_freq = '1';
-               break;
+       /* Select V1 reference and enable slew */
+       ret = pmic_reg_write(0x20, (ret & ~(1 << 1)) | (1 << 0));
+       if (ret)
+               return ret;
 
-       default:
-               cpu_freq = '?';
-       }
+       do {
+               ret = pmic_reg_read(0x20);
+               if (ret < 0)
+                       return ret;
+               if (++retries >= 1000)
+                       return -ETIMEDOUT;
+               HAL_DELAY_US(100);
+       } while (ret & (1 << 0));
+       return ret;
+}
 
-       diag_printf("\nBoard Type: Ka-Ro TX53-%c%c%s%c\n",
-                               cpu_freq, CYGNUM_HAL_ARM_TX53_SDRAM_TYPE == 2 ? '0' : 'x',
-                               ddr_type, SDRAM_SIZE_STR);
+static void display_board_type(void)
+{
+       diag_printf("\nBoard Type: Ka-Ro TX53 v3\n");
 }
 
 static void display_board_info(void)