git.sur5r.net Git - u-boot/blob - arch/arm/cpu/armv7/omap4/clocks.c

   1 /*
   2  *
   3  * Clock initialization for OMAP4
   4  *
   5  * (C) Copyright 2010
   6  * Texas Instruments, <www.ti.com>
   7  *
   8  * Aneesh V <aneesh@ti.com>
   9  *
  10  * Based on previous work by:
  11  *      Santosh Shilimkar <santosh.shilimkar@ti.com>
  12  *      Rajendra Nayak <rnayak@ti.com>
  13  *
  14  * See file CREDITS for list of people who contributed to this
  15  * project.
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License as
  19  * published by the Free Software Foundation; either version 2 of
  20  * the License, or (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, write to the Free Software
  29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  30  * MA 02111-1307 USA
  31  */
  32 #include <common.h>
  33 #include <asm/omap_common.h>
  34 #include <asm/arch/clocks.h>
  35 #include <asm/arch/sys_proto.h>
  36 #include <asm/utils.h>
  37 #include <asm/omap_gpio.h>
  38
  39 #ifndef CONFIG_SPL_BUILD
  40 /*
  41  * printing to console doesn't work unless
  42  * this code is executed from SPL
  43  */
  44 #define printf(fmt, args...)
  45 #define puts(s)
  46 #endif
  47
  48 #define abs(x) (((x) < 0) ? ((x)*-1) : (x))
  49
  50 struct omap4_prcm_regs *const prcm = (struct omap4_prcm_regs *)0x4A004100;
  51
  52 static const u32 sys_clk_array[8] = {
  53         12000000,              /* 12 MHz */
  54         13000000,              /* 13 MHz */
  55         16800000,              /* 16.8 MHz */
  56         19200000,              /* 19.2 MHz */
  57         26000000,              /* 26 MHz */
  58         27000000,              /* 27 MHz */
  59         38400000,              /* 38.4 MHz */
  60 };
  61
  62 /*
  63  * The M & N values in the following tables are created using the
  64  * following tool:
  65  * tools/omap/clocks_get_m_n.c
  66  * Please use this tool for creating the table for any new frequency.
  67  */
  68
  69 /* dpll locked at 1584 MHz - MPU clk at 792 MHz(OPP Turbo) */
  70 static const struct dpll_params mpu_dpll_params_1584mhz[NUM_SYS_CLKS] = {
  71         {66, 0, 1, -1, -1, -1, -1, -1},         /* 12 MHz   */
  72         {792, 12, 1, -1, -1, -1, -1, -1},       /* 13 MHz   */
  73         {330, 6, 1, -1, -1, -1, -1, -1},        /* 16.8 MHz */
  74         {165, 3, 1, -1, -1, -1, -1, -1},        /* 19.2 MHz */
  75         {396, 12, 1, -1, -1, -1, -1, -1},       /* 26 MHz   */
  76         {88, 2, 1, -1, -1, -1, -1, -1},         /* 27 MHz   */
  77         {165, 7, 1, -1, -1, -1, -1, -1}         /* 38.4 MHz */
  78 };
  79
  80 /* dpll locked at 1200 MHz - MPU clk at 600 MHz */
  81 static const struct dpll_params mpu_dpll_params_1200mhz[NUM_SYS_CLKS] = {
  82         {50, 0, 1, -1, -1, -1, -1, -1},         /* 12 MHz   */
  83         {600, 12, 1, -1, -1, -1, -1, -1},       /* 13 MHz   */
  84         {250, 6, 1, -1, -1, -1, -1, -1},        /* 16.8 MHz */
  85         {125, 3, 1, -1, -1, -1, -1, -1},        /* 19.2 MHz */
  86         {300, 12, 1, -1, -1, -1, -1, -1},       /* 26 MHz   */
  87         {200, 8, 1, -1, -1, -1, -1, -1},        /* 27 MHz   */
  88         {125, 7, 1, -1, -1, -1, -1, -1}         /* 38.4 MHz */
  89 };
  90
  91 static const struct dpll_params core_dpll_params_1600mhz[NUM_SYS_CLKS] = {
  92         {200, 2, 1, 5, 8, 4, 6, 5},     /* 12 MHz   */
  93         {800, 12, 1, 5, 8, 4, 6, 5},    /* 13 MHz   */
  94         {619, 12, 1, 5, 8, 4, 6, 5},    /* 16.8 MHz */
  95         {125, 2, 1, 5, 8, 4, 6, 5},     /* 19.2 MHz */
  96         {400, 12, 1, 5, 8, 4, 6, 5},    /* 26 MHz   */
  97         {800, 26, 1, 5, 8, 4, 6, 5},    /* 27 MHz   */
  98         {125, 5, 1, 5, 8, 4, 6, 5}      /* 38.4 MHz */
  99 };
 100
 101 static const struct dpll_params core_dpll_params_es1_1524mhz[NUM_SYS_CLKS] = {
 102         {127, 1, 1, 5, 8, 4, 6, 5},     /* 12 MHz   */
 103         {762, 12, 1, 5, 8, 4, 6, 5},    /* 13 MHz   */
 104         {635, 13, 1, 5, 8, 4, 6, 5},    /* 16.8 MHz */
 105         {635, 15, 1, 5, 8, 4, 6, 5},    /* 19.2 MHz */
 106         {381, 12, 1, 5, 8, 4, 6, 5},    /* 26 MHz   */
 107         {254, 8, 1, 5, 8, 4, 6, 5},     /* 27 MHz   */
 108         {496, 24, 1, 5, 8, 4, 6, 5}     /* 38.4 MHz */
 109 };
 110
 111 static const struct dpll_params
 112                 core_dpll_params_es2_1600mhz_ddr200mhz[NUM_SYS_CLKS] = {
 113         {200, 2, 2, 5, 8, 4, 6, 5},     /* 12 MHz   */
 114         {800, 12, 2, 5, 8, 4, 6, 5},    /* 13 MHz   */
 115         {619, 12, 2, 5, 8, 4, 6, 5},    /* 16.8 MHz */
 116         {125, 2, 2, 5, 8, 4, 6, 5},     /* 19.2 MHz */
 117         {400, 12, 2, 5, 8, 4, 6, 5},    /* 26 MHz   */
 118         {800, 26, 2, 5, 8, 4, 6, 5},    /* 27 MHz   */
 119         {125, 5, 2, 5, 8, 4, 6, 5}      /* 38.4 MHz */
 120 };
 121
 122 static const struct dpll_params per_dpll_params_1536mhz[NUM_SYS_CLKS] = {
 123         {64, 0, 8, 6, 12, 9, 4, 5},     /* 12 MHz   */
 124         {768, 12, 8, 6, 12, 9, 4, 5},   /* 13 MHz   */
 125         {320, 6, 8, 6, 12, 9, 4, 5},    /* 16.8 MHz */
 126         {40, 0, 8, 6, 12, 9, 4, 5},     /* 19.2 MHz */
 127         {384, 12, 8, 6, 12, 9, 4, 5},   /* 26 MHz   */
 128         {256, 8, 8, 6, 12, 9, 4, 5},    /* 27 MHz   */
 129         {20, 0, 8, 6, 12, 9, 4, 5}      /* 38.4 MHz */
 130 };
 131
 132 static const struct dpll_params iva_dpll_params_1862mhz[NUM_SYS_CLKS] = {
 133         {931, 11, -1, -1, 4, 7, -1, -1},        /* 12 MHz   */
 134         {931, 12, -1, -1, 4, 7, -1, -1},        /* 13 MHz   */
 135         {665, 11, -1, -1, 4, 7, -1, -1},        /* 16.8 MHz */
 136         {727, 14, -1, -1, 4, 7, -1, -1},        /* 19.2 MHz */
 137         {931, 25, -1, -1, 4, 7, -1, -1},        /* 26 MHz   */
 138         {931, 26, -1, -1, 4, 7, -1, -1},        /* 27 MHz   */
 139         {412, 16, -1, -1, 4, 7, -1, -1}         /* 38.4 MHz */
 140 };
 141
 142 /* ABE M & N values with sys_clk as source */
 143 static const struct dpll_params
 144                 abe_dpll_params_sysclk_196608khz[NUM_SYS_CLKS] = {
 145         {49, 5, 1, 1, -1, -1, -1, -1},  /* 12 MHz   */
 146         {68, 8, 1, 1, -1, -1, -1, -1},  /* 13 MHz   */
 147         {35, 5, 1, 1, -1, -1, -1, -1},  /* 16.8 MHz */
 148         {46, 8, 1, 1, -1, -1, -1, -1},  /* 19.2 MHz */
 149         {34, 8, 1, 1, -1, -1, -1, -1},  /* 26 MHz   */
 150         {29, 7, 1, 1, -1, -1, -1, -1},  /* 27 MHz   */
 151         {64, 24, 1, 1, -1, -1, -1, -1}  /* 38.4 MHz */
 152 };
 153
 154 /* ABE M & N values with 32K clock as source */
 155 static const struct dpll_params abe_dpll_params_32k_196608khz = {
 156         750, 0, 1, 1, -1, -1, -1, -1
 157 };
 158
 159
 160 static const struct dpll_params usb_dpll_params_1920mhz[NUM_SYS_CLKS] = {
 161         {80, 0, 2, -1, -1, -1, -1, -1},         /* 12 MHz   */
 162         {960, 12, 2, -1, -1, -1, -1, -1},       /* 13 MHz   */
 163         {400, 6, 2, -1, -1, -1, -1, -1},        /* 16.8 MHz */
 164         {50, 0, 2, -1, -1, -1, -1, -1},         /* 19.2 MHz */
 165         {480, 12, 2, -1, -1, -1, -1, -1},       /* 26 MHz   */
 166         {320, 8, 2, -1, -1, -1, -1, -1},        /* 27 MHz   */
 167         {25, 0, 2, -1, -1, -1, -1, -1}          /* 38.4 MHz */
 168 };
 169
 170 static inline u32 __get_sys_clk_index(void)
 171 {
 172         u32 ind;
 173         /*
 174          * For ES1 the ROM code calibration of sys clock is not reliable
 175          * due to hw issue. So, use hard-coded value. If this value is not
 176          * correct for any board over-ride this function in board file
 177          * From ES2.0 onwards you will get this information from
 178          * CM_SYS_CLKSEL
 179          */
 180         if (omap_revision() == OMAP4430_ES1_0)
 181                 ind = OMAP_SYS_CLK_IND_38_4_MHZ;
 182         else {
 183                 /* SYS_CLKSEL - 1 to match the dpll param array indices */
 184                 ind = (readl(&prcm->cm_sys_clksel) &
 185                         CM_SYS_CLKSEL_SYS_CLKSEL_MASK) - 1;
 186         }
 187         return ind;
 188 }
 189
 190 u32 get_sys_clk_index(void)
 191         __attribute__ ((weak, alias("__get_sys_clk_index")));
 192
 193 u32 get_sys_clk_freq(void)
 194 {
 195         u8 index = get_sys_clk_index();
 196         return sys_clk_array[index];
 197 }
 198
 199 static inline void do_bypass_dpll(u32 *const base)
 200 {
 201         struct dpll_regs *dpll_regs = (struct dpll_regs *)base;
 202
 203         clrsetbits_le32(&dpll_regs->cm_clkmode_dpll,
 204                         CM_CLKMODE_DPLL_DPLL_EN_MASK,
 205                         DPLL_EN_FAST_RELOCK_BYPASS <<
 206                         CM_CLKMODE_DPLL_EN_SHIFT);
 207 }
 208
 209 static inline void wait_for_bypass(u32 *const base)
 210 {
 211         struct dpll_regs *const dpll_regs = (struct dpll_regs *)base;
 212
 213         if (!wait_on_value(ST_DPLL_CLK_MASK, 0, &dpll_regs->cm_idlest_dpll,
 214                                 LDELAY)) {
 215                 printf("Bypassing DPLL failed %p\n", base);
 216         }
 217 }
 218
 219 static inline void do_lock_dpll(u32 *const base)
 220 {
 221         struct dpll_regs *const dpll_regs = (struct dpll_regs *)base;
 222
 223         clrsetbits_le32(&dpll_regs->cm_clkmode_dpll,
 224                       CM_CLKMODE_DPLL_DPLL_EN_MASK,
 225                       DPLL_EN_LOCK << CM_CLKMODE_DPLL_EN_SHIFT);
 226 }
 227
 228 static inline void wait_for_lock(u32 *const base)
 229 {
 230         struct dpll_regs *const dpll_regs = (struct dpll_regs *)base;
 231
 232         if (!wait_on_value(ST_DPLL_CLK_MASK, ST_DPLL_CLK_MASK,
 233                 &dpll_regs->cm_idlest_dpll, LDELAY)) {
 234                 printf("DPLL locking failed for %p\n", base);
 235                 hang();
 236         }
 237 }
 238
 239 static void do_setup_dpll(u32 *const base, const struct dpll_params *params,
 240                                 u8 lock)
 241 {
 242         u32 temp;
 243         struct dpll_regs *const dpll_regs = (struct dpll_regs *)base;
 244
 245         bypass_dpll(base);
 246
 247         /* Set M & N */
 248         temp = readl(&dpll_regs->cm_clksel_dpll);
 249
 250         temp &= ~CM_CLKSEL_DPLL_M_MASK;
 251         temp |= (params->m << CM_CLKSEL_DPLL_M_SHIFT) & CM_CLKSEL_DPLL_M_MASK;
 252
 253         temp &= ~CM_CLKSEL_DPLL_N_MASK;
 254         temp |= (params->n << CM_CLKSEL_DPLL_N_SHIFT) & CM_CLKSEL_DPLL_N_MASK;
 255
 256         writel(temp, &dpll_regs->cm_clksel_dpll);
 257
 258         /* Lock */
 259         if (lock)
 260                 do_lock_dpll(base);
 261
 262         /* Setup post-dividers */
 263         if (params->m2 >= 0)
 264                 writel(params->m2, &dpll_regs->cm_div_m2_dpll);
 265         if (params->m3 >= 0)
 266                 writel(params->m3, &dpll_regs->cm_div_m3_dpll);
 267         if (params->m4 >= 0)
 268                 writel(params->m4, &dpll_regs->cm_div_m4_dpll);
 269         if (params->m5 >= 0)
 270                 writel(params->m5, &dpll_regs->cm_div_m5_dpll);
 271         if (params->m6 >= 0)
 272                 writel(params->m6, &dpll_regs->cm_div_m6_dpll);
 273         if (params->m7 >= 0)
 274                 writel(params->m7, &dpll_regs->cm_div_m7_dpll);
 275
 276         /* Wait till the DPLL locks */
 277         if (lock)
 278                 wait_for_lock(base);
 279 }
 280
 281 const struct dpll_params *get_core_dpll_params(void)
 282 {
 283         u32 sysclk_ind = get_sys_clk_index();
 284
 285         switch (omap_revision()) {
 286         case OMAP4430_ES1_0:
 287                 return &core_dpll_params_es1_1524mhz[sysclk_ind];
 288         case OMAP4430_ES2_0:
 289         case OMAP4430_SILICON_ID_INVALID:
 290                  /* safest */
 291                 return &core_dpll_params_es2_1600mhz_ddr200mhz[sysclk_ind];
 292         default:
 293                 return &core_dpll_params_1600mhz[sysclk_ind];
 294         }
 295 }
 296
 297 u32 omap4_ddr_clk(void)
 298 {
 299         u32 ddr_clk, sys_clk_khz;
 300         const struct dpll_params *core_dpll_params;
 301
 302         sys_clk_khz = get_sys_clk_freq() / 1000;
 303
 304         core_dpll_params = get_core_dpll_params();
 305
 306         debug("sys_clk %d\n ", sys_clk_khz * 1000);
 307
 308         /* Find Core DPLL locked frequency first */
 309         ddr_clk = sys_clk_khz * 2 * core_dpll_params->m /
 310                         (core_dpll_params->n + 1);
 311         /*
 312          * DDR frequency is PHY_ROOT_CLK/2
 313          * PHY_ROOT_CLK = Fdpll/2/M2
 314          */
 315         ddr_clk = ddr_clk / 4 / core_dpll_params->m2;
 316
 317         ddr_clk *= 1000;        /* convert to Hz */
 318         debug("ddr_clk %d\n ", ddr_clk);
 319
 320         return ddr_clk;
 321 }
 322
 323 static void setup_dplls(void)
 324 {
 325         u32 sysclk_ind, temp;
 326         const struct dpll_params *params;
 327         debug("setup_dplls\n");
 328
 329         sysclk_ind = get_sys_clk_index();
 330
 331         /* CORE dpll */
 332         params = get_core_dpll_params();        /* default - safest */
 333         /*
 334          * Do not lock the core DPLL now. Just set it up.
 335          * Core DPLL will be locked after setting up EMIF
 336          * using the FREQ_UPDATE method(freq_update_core())
 337          */
 338         do_setup_dpll(&prcm->cm_clkmode_dpll_core, params, DPLL_NO_LOCK);
 339         /* Set the ratios for CORE_CLK, L3_CLK, L4_CLK */
 340         temp = (CLKSEL_CORE_X2_DIV_1 << CLKSEL_CORE_SHIFT) |
 341             (CLKSEL_L3_CORE_DIV_2 << CLKSEL_L3_SHIFT) |
 342             (CLKSEL_L4_L3_DIV_2 << CLKSEL_L4_SHIFT);
 343         writel(temp, &prcm->cm_clksel_core);
 344         debug("Core DPLL configured\n");
 345
 346         /* lock PER dpll */
 347         do_setup_dpll(&prcm->cm_clkmode_dpll_per,
 348                         &per_dpll_params_1536mhz[sysclk_ind], DPLL_LOCK);
 349         debug("PER DPLL locked\n");
 350
 351         /* MPU dpll */
 352         if (omap_revision() == OMAP4430_ES1_0)
 353                 params = &mpu_dpll_params_1200mhz[sysclk_ind];
 354         else
 355                 params = &mpu_dpll_params_1584mhz[sysclk_ind];
 356         do_setup_dpll(&prcm->cm_clkmode_dpll_mpu, params, DPLL_LOCK);
 357         debug("MPU DPLL locked\n");
 358 }
 359
 360 static void setup_non_essential_dplls(void)
 361 {
 362         u32 sys_clk_khz, abe_ref_clk;
 363         u32 sysclk_ind, sd_div, num, den;
 364         const struct dpll_params *params;
 365
 366         sysclk_ind = get_sys_clk_index();
 367         sys_clk_khz = get_sys_clk_freq() / 1000;
 368
 369         /* IVA */
 370         clrsetbits_le32(&prcm->cm_bypclk_dpll_iva,
 371                 CM_BYPCLK_DPLL_IVA_CLKSEL_MASK, DPLL_IVA_CLKSEL_CORE_X2_DIV_2);
 372
 373         do_setup_dpll(&prcm->cm_clkmode_dpll_iva,
 374                         &iva_dpll_params_1862mhz[sysclk_ind], DPLL_LOCK);
 375
 376         /*
 377          * USB:
 378          * USB dpll is J-type. Need to set DPLL_SD_DIV for jitter correction
 379          * DPLL_SD_DIV = CEILING ([DPLL_MULT/(DPLL_DIV+1)]* CLKINP / 250)
 380          *      - where CLKINP is sys_clk in MHz
 381          * Use CLKINP in KHz and adjust the denominator accordingly so
 382          * that we have enough accuracy and at the same time no overflow
 383          */
 384         params = &usb_dpll_params_1920mhz[sysclk_ind];
 385         num = params->m * sys_clk_khz;
 386         den = (params->n + 1) * 250 * 1000;
 387         num += den - 1;
 388         sd_div = num / den;
 389         clrsetbits_le32(&prcm->cm_clksel_dpll_usb,
 390                         CM_CLKSEL_DPLL_DPLL_SD_DIV_MASK,
 391                         sd_div << CM_CLKSEL_DPLL_DPLL_SD_DIV_SHIFT);
 392
 393         /* Now setup the dpll with the regular function */
 394         do_setup_dpll(&prcm->cm_clkmode_dpll_usb, params, DPLL_LOCK);
 395
 396 #ifdef CONFIG_SYS_OMAP4_ABE_SYSCK
 397         params = &abe_dpll_params_sysclk_196608khz[sysclk_ind];
 398         abe_ref_clk = CM_ABE_PLL_REF_CLKSEL_CLKSEL_SYSCLK;
 399 #else
 400         params = &abe_dpll_params_32k_196608khz;
 401         abe_ref_clk = CM_ABE_PLL_REF_CLKSEL_CLKSEL_32KCLK;
 402         /*
 403          * We need to enable some additional options to achieve
 404          * 196.608MHz from 32768 Hz
 405          */
 406         setbits_le32(&prcm->cm_clkmode_dpll_abe,
 407                         CM_CLKMODE_DPLL_DRIFTGUARD_EN_MASK|
 408                         CM_CLKMODE_DPLL_RELOCK_RAMP_EN_MASK|
 409                         CM_CLKMODE_DPLL_LPMODE_EN_MASK|
 410                         CM_CLKMODE_DPLL_REGM4XEN_MASK);
 411         /* Spend 4 REFCLK cycles at each stage */
 412         clrsetbits_le32(&prcm->cm_clkmode_dpll_abe,
 413                         CM_CLKMODE_DPLL_RAMP_RATE_MASK,
 414                         1 << CM_CLKMODE_DPLL_RAMP_RATE_SHIFT);
 415 #endif
 416
 417         /* Select the right reference clk */
 418         clrsetbits_le32(&prcm->cm_abe_pll_ref_clksel,
 419                         CM_ABE_PLL_REF_CLKSEL_CLKSEL_MASK,
 420                         abe_ref_clk << CM_ABE_PLL_REF_CLKSEL_CLKSEL_SHIFT);
 421         /* Lock the dpll */
 422         do_setup_dpll(&prcm->cm_clkmode_dpll_abe, params, DPLL_LOCK);
 423 }
 424
 425 static void do_scale_tps62361(u32 reg, u32 volt_mv)
 426 {
 427         u32 temp, step;
 428
 429         step = volt_mv - TPS62361_BASE_VOLT_MV;
 430         step /= 10;
 431
 432         /*
 433          * Select SET1 in TPS62361:
 434          * VSEL1 is grounded on board. So the following selects
 435          * VSEL1 = 0 and VSEL0 = 1
 436          */
 437         omap_set_gpio_direction(TPS62361_VSEL0_GPIO, 0);
 438         omap_set_gpio_dataout(TPS62361_VSEL0_GPIO, 1);
 439
 440         temp = TPS62361_I2C_SLAVE_ADDR |
 441             (reg << PRM_VC_VAL_BYPASS_REGADDR_SHIFT) |
 442             (step << PRM_VC_VAL_BYPASS_DATA_SHIFT) |
 443             PRM_VC_VAL_BYPASS_VALID_BIT;
 444         debug("do_scale_tps62361: volt - %d step - 0x%x\n", volt_mv, step);
 445
 446         writel(temp, &prcm->prm_vc_val_bypass);
 447         if (!wait_on_value(PRM_VC_VAL_BYPASS_VALID_BIT, 0,
 448                                 &prcm->prm_vc_val_bypass, LDELAY)) {
 449                 puts("Scaling voltage failed for vdd_mpu from TPS\n");
 450         }
 451 }
 452
 453 static void do_scale_vcore(u32 vcore_reg, u32 volt_mv)
 454 {
 455         u32 temp, offset_code;
 456         u32 step = 12660; /* 12.66 mV represented in uV */
 457         u32 offset = volt_mv;
 458
 459         /* convert to uV for better accuracy in the calculations */
 460         offset *= 1000;
 461
 462         if (omap_revision() == OMAP4430_ES1_0)
 463                 offset -= PHOENIX_SMPS_BASE_VOLT_STD_MODE_UV;
 464         else
 465                 offset -= PHOENIX_SMPS_BASE_VOLT_STD_MODE_WITH_OFFSET_UV;
 466
 467         offset_code = (offset + step - 1) / step;
 468         /* The code starts at 1 not 0 */
 469         offset_code++;
 470
 471         debug("do_scale_vcore: volt - %d offset_code - 0x%x\n", volt_mv,
 472                 offset_code);
 473
 474         temp = SMPS_I2C_SLAVE_ADDR |
 475             (vcore_reg << PRM_VC_VAL_BYPASS_REGADDR_SHIFT) |
 476             (offset_code << PRM_VC_VAL_BYPASS_DATA_SHIFT) |
 477             PRM_VC_VAL_BYPASS_VALID_BIT;
 478         writel(temp, &prcm->prm_vc_val_bypass);
 479         if (!wait_on_value(PRM_VC_VAL_BYPASS_VALID_BIT, 0,
 480                                 &prcm->prm_vc_val_bypass, LDELAY)) {
 481                 printf("Scaling voltage failed for 0x%x\n", vcore_reg);
 482         }
 483 }
 484
 485 /*
 486  * Setup the voltages for vdd_mpu, vdd_core, and vdd_iva
 487  * We set the maximum voltages allowed here because Smart-Reflex is not
 488  * enabled in bootloader. Voltage initialization in the kernel will set
 489  * these to the nominal values after enabling Smart-Reflex
 490  */
 491 static void scale_vcores(void)
 492 {
 493         u32 volt, sys_clk_khz, cycles_hi, cycles_low, temp, omap4_rev;
 494
 495         sys_clk_khz = get_sys_clk_freq() / 1000;
 496
 497         /*
 498          * Setup the dedicated I2C controller for Voltage Control
 499          * I2C clk - high period 40% low period 60%
 500          */
 501         cycles_hi = sys_clk_khz * 4 / PRM_VC_I2C_CHANNEL_FREQ_KHZ / 10;
 502         cycles_low = sys_clk_khz * 6 / PRM_VC_I2C_CHANNEL_FREQ_KHZ / 10;
 503         /* values to be set in register - less by 5 & 7 respectively */
 504         cycles_hi -= 5;
 505         cycles_low -= 7;
 506         temp = (cycles_hi << PRM_VC_CFG_I2C_CLK_SCLH_SHIFT) |
 507                (cycles_low << PRM_VC_CFG_I2C_CLK_SCLL_SHIFT);
 508         writel(temp, &prcm->prm_vc_cfg_i2c_clk);
 509
 510         /* Disable high speed mode and all advanced features */
 511         writel(0x0, &prcm->prm_vc_cfg_i2c_mode);
 512
 513         omap4_rev = omap_revision();
 514         /* TPS - supplies vdd_mpu on 4460 */
 515         if (omap4_rev >= OMAP4460_ES1_0) {
 516                 volt = 1430;
 517                 do_scale_tps62361(TPS62361_REG_ADDR_SET1, volt);
 518         }
 519
 520         /*
 521          * VCORE 1
 522          *
 523          * 4430 : supplies vdd_mpu
 524          * Setting a high voltage for Nitro mode as smart reflex is not enabled.
 525          * We use the maximum possible value in the AVS range because the next
 526          * higher voltage in the discrete range (code >= 0b111010) is way too
 527          * high
 528          *
 529          * 4460 : supplies vdd_core
 530          */
 531         if (omap4_rev < OMAP4460_ES1_0) {
 532                 volt = 1417;
 533                 do_scale_vcore(SMPS_REG_ADDR_VCORE1, volt);
 534         } else {
 535                 volt = 1200;
 536                 do_scale_vcore(SMPS_REG_ADDR_VCORE1, volt);
 537         }
 538
 539         /* VCORE 2 - supplies vdd_iva */
 540         volt = 1200;
 541         do_scale_vcore(SMPS_REG_ADDR_VCORE2, volt);
 542
 543         /*
 544          * VCORE 3
 545          * 4430 : supplies vdd_core
 546          * 4460 : not connected
 547          */
 548         if (omap4_rev < OMAP4460_ES1_0) {
 549                 volt = 1200;
 550                 do_scale_vcore(SMPS_REG_ADDR_VCORE3, volt);
 551         }
 552 }
 553
 554 static inline void enable_clock_domain(u32 *const clkctrl_reg, u32 enable_mode)
 555 {
 556         clrsetbits_le32(clkctrl_reg, CD_CLKCTRL_CLKTRCTRL_MASK,
 557                         enable_mode << CD_CLKCTRL_CLKTRCTRL_SHIFT);
 558         debug("Enable clock domain - 0x%08x\n", clkctrl_reg);
 559 }
 560
 561 static inline void wait_for_clk_enable(u32 *clkctrl_addr)
 562 {
 563         u32 clkctrl, idlest = MODULE_CLKCTRL_IDLEST_DISABLED;
 564         u32 bound = LDELAY;
 565
 566         while ((idlest == MODULE_CLKCTRL_IDLEST_DISABLED) ||
 567                 (idlest == MODULE_CLKCTRL_IDLEST_TRANSITIONING)) {
 568
 569                 clkctrl = readl(clkctrl_addr);
 570                 idlest = (clkctrl & MODULE_CLKCTRL_IDLEST_MASK) >>
 571                          MODULE_CLKCTRL_IDLEST_SHIFT;
 572                 if (--bound == 0) {
 573                         printf("Clock enable failed for 0x%p idlest 0x%x\n",
 574                                 clkctrl_addr, clkctrl);
 575                         return;
 576                 }
 577         }
 578 }
 579
 580 static inline void enable_clock_module(u32 *const clkctrl_addr, u32 enable_mode,
 581                                 u32 wait_for_enable)
 582 {
 583         clrsetbits_le32(clkctrl_addr, MODULE_CLKCTRL_MODULEMODE_MASK,
 584                         enable_mode << MODULE_CLKCTRL_MODULEMODE_SHIFT);
 585         debug("Enable clock module - 0x%08x\n", clkctrl_addr);
 586         if (wait_for_enable)
 587                 wait_for_clk_enable(clkctrl_addr);
 588 }
 589
 590 /*
 591  * Enable essential clock domains, modules and
 592  * do some additional special settings needed
 593  */
 594 static void enable_basic_clocks(void)
 595 {
 596         u32 i, max = 100, wait_for_enable = 1;
 597         u32 *const clk_domains_essential[] = {
 598                 &prcm->cm_l4per_clkstctrl,
 599                 &prcm->cm_l3init_clkstctrl,
 600                 &prcm->cm_memif_clkstctrl,
 601                 &prcm->cm_l4cfg_clkstctrl,
 602                 0
 603         };
 604
 605         u32 *const clk_modules_hw_auto_essential[] = {
 606                 &prcm->cm_wkup_gpio1_clkctrl,
 607                 &prcm->cm_l4per_gpio2_clkctrl,
 608                 &prcm->cm_l4per_gpio3_clkctrl,
 609                 &prcm->cm_l4per_gpio4_clkctrl,
 610                 &prcm->cm_l4per_gpio5_clkctrl,
 611                 &prcm->cm_l4per_gpio6_clkctrl,
 612                 &prcm->cm_memif_emif_1_clkctrl,
 613                 &prcm->cm_memif_emif_2_clkctrl,
 614                 &prcm->cm_l3init_hsusbotg_clkctrl,
 615                 &prcm->cm_l3init_usbphy_clkctrl,
 616                 &prcm->cm_l4cfg_l4_cfg_clkctrl,
 617                 0
 618         };
 619
 620         u32 *const clk_modules_explicit_en_essential[] = {
 621                 &prcm->cm_l4per_gptimer2_clkctrl,
 622                 &prcm->cm_l3init_hsmmc1_clkctrl,
 623                 &prcm->cm_l3init_hsmmc2_clkctrl,
 624                 &prcm->cm_l4per_mcspi1_clkctrl,
 625                 &prcm->cm_wkup_gptimer1_clkctrl,
 626                 &prcm->cm_l4per_i2c1_clkctrl,
 627                 &prcm->cm_l4per_i2c2_clkctrl,
 628                 &prcm->cm_l4per_i2c3_clkctrl,
 629                 &prcm->cm_l4per_i2c4_clkctrl,
 630                 &prcm->cm_wkup_wdtimer2_clkctrl,
 631                 &prcm->cm_l4per_uart3_clkctrl,
 632                 0
 633         };
 634
 635         /* Enable optional additional functional clock for GPIO4 */
 636         setbits_le32(&prcm->cm_l4per_gpio4_clkctrl,
 637                         GPIO4_CLKCTRL_OPTFCLKEN_MASK);
 638
 639         /* Enable 96 MHz clock for MMC1 & MMC2 */
 640         setbits_le32(&prcm->cm_l3init_hsmmc1_clkctrl,
 641                         HSMMC_CLKCTRL_CLKSEL_MASK);
 642         setbits_le32(&prcm->cm_l3init_hsmmc2_clkctrl,
 643                         HSMMC_CLKCTRL_CLKSEL_MASK);
 644
 645         /* Select 32KHz clock as the source of GPTIMER1 */
 646         setbits_le32(&prcm->cm_wkup_gptimer1_clkctrl,
 647                         GPTIMER1_CLKCTRL_CLKSEL_MASK);
 648
 649         /* Enable optional 48M functional clock for USB  PHY */
 650         setbits_le32(&prcm->cm_l3init_usbphy_clkctrl,
 651                         USBPHY_CLKCTRL_OPTFCLKEN_PHY_48M_MASK);
 652
 653         /* Put the clock domains in SW_WKUP mode */
 654         for (i = 0; (i < max) && clk_domains_essential[i]; i++) {
 655                 enable_clock_domain(clk_domains_essential[i],
 656                                     CD_CLKCTRL_CLKTRCTRL_SW_WKUP);
 657         }
 658
 659         /* Clock modules that need to be put in HW_AUTO */
 660         for (i = 0; (i < max) && clk_modules_hw_auto_essential[i]; i++) {
 661                 enable_clock_module(clk_modules_hw_auto_essential[i],
 662                                     MODULE_CLKCTRL_MODULEMODE_HW_AUTO,
 663                                     wait_for_enable);
 664         };
 665
 666         /* Clock modules that need to be put in SW_EXPLICIT_EN mode */
 667         for (i = 0; (i < max) && clk_modules_explicit_en_essential[i]; i++) {
 668                 enable_clock_module(clk_modules_explicit_en_essential[i],
 669                                     MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN,
 670                                     wait_for_enable);
 671         };
 672
 673         /* Put the clock domains in HW_AUTO mode now */
 674         for (i = 0; (i < max) && clk_domains_essential[i]; i++) {
 675                 enable_clock_domain(clk_domains_essential[i],
 676                                     CD_CLKCTRL_CLKTRCTRL_HW_AUTO);
 677         }
 678 }
 679
 680 /*
 681  * Enable non-essential clock domains, modules and
 682  * do some additional special settings needed
 683  */
 684 static void enable_non_essential_clocks(void)
 685 {
 686         u32 i, max = 100, wait_for_enable = 0;
 687         u32 *const clk_domains_non_essential[] = {
 688                 &prcm->cm_mpu_m3_clkstctrl,
 689                 &prcm->cm_ivahd_clkstctrl,
 690                 &prcm->cm_dsp_clkstctrl,
 691                 &prcm->cm_dss_clkstctrl,
 692                 &prcm->cm_sgx_clkstctrl,
 693                 &prcm->cm1_abe_clkstctrl,
 694                 &prcm->cm_c2c_clkstctrl,
 695                 &prcm->cm_cam_clkstctrl,
 696                 &prcm->cm_dss_clkstctrl,
 697                 &prcm->cm_sdma_clkstctrl,
 698                 0
 699         };
 700
 701         u32 *const clk_modules_hw_auto_non_essential[] = {
 702                 &prcm->cm_mpu_m3_mpu_m3_clkctrl,
 703                 &prcm->cm_ivahd_ivahd_clkctrl,
 704                 &prcm->cm_ivahd_sl2_clkctrl,
 705                 &prcm->cm_dsp_dsp_clkctrl,
 706                 &prcm->cm_l3_2_gpmc_clkctrl,
 707                 &prcm->cm_l3instr_l3_3_clkctrl,
 708                 &prcm->cm_l3instr_l3_instr_clkctrl,
 709                 &prcm->cm_l3instr_intrconn_wp1_clkctrl,
 710                 &prcm->cm_l3init_hsi_clkctrl,
 711                 &prcm->cm_l3init_hsusbtll_clkctrl,
 712                 0
 713         };
 714
 715         u32 *const clk_modules_explicit_en_non_essential[] = {
 716                 &prcm->cm1_abe_aess_clkctrl,
 717                 &prcm->cm1_abe_pdm_clkctrl,
 718                 &prcm->cm1_abe_dmic_clkctrl,
 719                 &prcm->cm1_abe_mcasp_clkctrl,
 720                 &prcm->cm1_abe_mcbsp1_clkctrl,
 721                 &prcm->cm1_abe_mcbsp2_clkctrl,
 722                 &prcm->cm1_abe_mcbsp3_clkctrl,
 723                 &prcm->cm1_abe_slimbus_clkctrl,
 724                 &prcm->cm1_abe_timer5_clkctrl,
 725                 &prcm->cm1_abe_timer6_clkctrl,
 726                 &prcm->cm1_abe_timer7_clkctrl,
 727                 &prcm->cm1_abe_timer8_clkctrl,
 728                 &prcm->cm1_abe_wdt3_clkctrl,
 729                 &prcm->cm_l4per_gptimer9_clkctrl,
 730                 &prcm->cm_l4per_gptimer10_clkctrl,
 731                 &prcm->cm_l4per_gptimer11_clkctrl,
 732                 &prcm->cm_l4per_gptimer3_clkctrl,
 733                 &prcm->cm_l4per_gptimer4_clkctrl,
 734                 &prcm->cm_l4per_hdq1w_clkctrl,
 735                 &prcm->cm_l4per_mcbsp4_clkctrl,
 736                 &prcm->cm_l4per_mcspi2_clkctrl,
 737                 &prcm->cm_l4per_mcspi3_clkctrl,
 738                 &prcm->cm_l4per_mcspi4_clkctrl,
 739                 &prcm->cm_l4per_mmcsd3_clkctrl,
 740                 &prcm->cm_l4per_mmcsd4_clkctrl,
 741                 &prcm->cm_l4per_mmcsd5_clkctrl,
 742                 &prcm->cm_l4per_uart1_clkctrl,
 743                 &prcm->cm_l4per_uart2_clkctrl,
 744                 &prcm->cm_l4per_uart4_clkctrl,
 745                 &prcm->cm_wkup_keyboard_clkctrl,
 746                 &prcm->cm_wkup_wdtimer2_clkctrl,
 747                 &prcm->cm_cam_iss_clkctrl,
 748                 &prcm->cm_cam_fdif_clkctrl,
 749                 &prcm->cm_dss_dss_clkctrl,
 750                 &prcm->cm_sgx_sgx_clkctrl,
 751                 &prcm->cm_l3init_hsusbhost_clkctrl,
 752                 &prcm->cm_l3init_fsusb_clkctrl,
 753                 0
 754         };
 755
 756         /* Enable optional functional clock for ISS */
 757         setbits_le32(&prcm->cm_cam_iss_clkctrl, ISS_CLKCTRL_OPTFCLKEN_MASK);
 758
 759         /* Enable all optional functional clocks of DSS */
 760         setbits_le32(&prcm->cm_dss_dss_clkctrl, DSS_CLKCTRL_OPTFCLKEN_MASK);
 761
 762
 763         /* Put the clock domains in SW_WKUP mode */
 764         for (i = 0; (i < max) && clk_domains_non_essential[i]; i++) {
 765                 enable_clock_domain(clk_domains_non_essential[i],
 766                                     CD_CLKCTRL_CLKTRCTRL_SW_WKUP);
 767         }
 768
 769         /* Clock modules that need to be put in HW_AUTO */
 770         for (i = 0; (i < max) && clk_modules_hw_auto_non_essential[i]; i++) {
 771                 enable_clock_module(clk_modules_hw_auto_non_essential[i],
 772                                     MODULE_CLKCTRL_MODULEMODE_HW_AUTO,
 773                                     wait_for_enable);
 774         };
 775
 776         /* Clock modules that need to be put in SW_EXPLICIT_EN mode */
 777         for (i = 0; (i < max) && clk_modules_explicit_en_non_essential[i];
 778              i++) {
 779                 enable_clock_module(clk_modules_explicit_en_non_essential[i],
 780                                     MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN,
 781                                     wait_for_enable);
 782         };
 783
 784         /* Put the clock domains in HW_AUTO mode now */
 785         for (i = 0; (i < max) && clk_domains_non_essential[i]; i++) {
 786                 enable_clock_domain(clk_domains_non_essential[i],
 787                                     CD_CLKCTRL_CLKTRCTRL_HW_AUTO);
 788         }
 789
 790         /* Put camera module in no sleep mode */
 791         clrsetbits_le32(&prcm->cm_cam_clkstctrl, MODULE_CLKCTRL_MODULEMODE_MASK,
 792                         CD_CLKCTRL_CLKTRCTRL_NO_SLEEP <<
 793                         MODULE_CLKCTRL_MODULEMODE_SHIFT);
 794 }
 795
 796
 797 void freq_update_core(void)
 798 {
 799         u32 freq_config1 = 0;
 800         const struct dpll_params *core_dpll_params;
 801
 802         core_dpll_params = get_core_dpll_params();
 803         /* Put EMIF clock domain in sw wakeup mode */
 804         enable_clock_domain(&prcm->cm_memif_clkstctrl,
 805                                 CD_CLKCTRL_CLKTRCTRL_SW_WKUP);
 806         wait_for_clk_enable(&prcm->cm_memif_emif_1_clkctrl);
 807         wait_for_clk_enable(&prcm->cm_memif_emif_2_clkctrl);
 808
 809         freq_config1 = SHADOW_FREQ_CONFIG1_FREQ_UPDATE_MASK |
 810             SHADOW_FREQ_CONFIG1_DLL_RESET_MASK;
 811
 812         freq_config1 |= (DPLL_EN_LOCK << SHADOW_FREQ_CONFIG1_DPLL_EN_SHIFT) &
 813                                 SHADOW_FREQ_CONFIG1_DPLL_EN_MASK;
 814
 815         freq_config1 |= (core_dpll_params->m2 <<
 816                         SHADOW_FREQ_CONFIG1_M2_DIV_SHIFT) &
 817                         SHADOW_FREQ_CONFIG1_M2_DIV_MASK;
 818
 819         writel(freq_config1, &prcm->cm_shadow_freq_config1);
 820         if (!wait_on_value(SHADOW_FREQ_CONFIG1_FREQ_UPDATE_MASK, 0,
 821                                 &prcm->cm_shadow_freq_config1, LDELAY)) {
 822                 puts("FREQ UPDATE procedure failed!!");
 823                 hang();
 824         }
 825
 826         /* Put EMIF clock domain back in hw auto mode */
 827         enable_clock_domain(&prcm->cm_memif_clkstctrl,
 828                                 CD_CLKCTRL_CLKTRCTRL_HW_AUTO);
 829         wait_for_clk_enable(&prcm->cm_memif_emif_1_clkctrl);
 830         wait_for_clk_enable(&prcm->cm_memif_emif_2_clkctrl);
 831 }
 832
 833 void bypass_dpll(u32 *const base)
 834 {
 835         do_bypass_dpll(base);
 836         wait_for_bypass(base);
 837 }
 838
 839 void lock_dpll(u32 *const base)
 840 {
 841         do_lock_dpll(base);
 842         wait_for_lock(base);
 843 }
 844
 845 void setup_clocks_for_console(void)
 846 {
 847         /* Do not add any spl_debug prints in this function */
 848         clrsetbits_le32(&prcm->cm_l4per_clkstctrl, CD_CLKCTRL_CLKTRCTRL_MASK,
 849                         CD_CLKCTRL_CLKTRCTRL_SW_WKUP <<
 850                         CD_CLKCTRL_CLKTRCTRL_SHIFT);
 851
 852         /* Enable all UARTs - console will be on one of them */
 853         clrsetbits_le32(&prcm->cm_l4per_uart1_clkctrl,
 854                         MODULE_CLKCTRL_MODULEMODE_MASK,
 855                         MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN <<
 856                         MODULE_CLKCTRL_MODULEMODE_SHIFT);
 857
 858         clrsetbits_le32(&prcm->cm_l4per_uart2_clkctrl,
 859                         MODULE_CLKCTRL_MODULEMODE_MASK,
 860                         MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN <<
 861                         MODULE_CLKCTRL_MODULEMODE_SHIFT);
 862
 863         clrsetbits_le32(&prcm->cm_l4per_uart3_clkctrl,
 864                         MODULE_CLKCTRL_MODULEMODE_MASK,
 865                         MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN <<
 866                         MODULE_CLKCTRL_MODULEMODE_SHIFT);
 867
 868         clrsetbits_le32(&prcm->cm_l4per_uart3_clkctrl,
 869                         MODULE_CLKCTRL_MODULEMODE_MASK,
 870                         MODULE_CLKCTRL_MODULEMODE_SW_EXPLICIT_EN <<
 871                         MODULE_CLKCTRL_MODULEMODE_SHIFT);
 872
 873         clrsetbits_le32(&prcm->cm_l4per_clkstctrl, CD_CLKCTRL_CLKTRCTRL_MASK,
 874                         CD_CLKCTRL_CLKTRCTRL_HW_AUTO <<
 875                         CD_CLKCTRL_CLKTRCTRL_SHIFT);
 876 }
 877
 878 void prcm_init(void)
 879 {
 880         switch (omap4_hw_init_context()) {
 881         case OMAP_INIT_CONTEXT_SPL:
 882         case OMAP_INIT_CONTEXT_UBOOT_FROM_NOR:
 883         case OMAP_INIT_CONTEXT_UBOOT_AFTER_CH:
 884                 enable_basic_clocks();
 885                 scale_vcores();
 886                 setup_dplls();
 887                 setup_non_essential_dplls();
 888                 enable_non_essential_clocks();
 889                 break;
 890         default:
 891                 break;
 892         }
 893 }