arch/arm/mach-omap2/clock24xx.c

   1 /*
   2  *  linux/arch/arm/mach-omap2/clock.c
   3  *
   4  *  Copyright (C) 2005 Texas Instruments Inc.
   5  *  Richard Woodruff <r-woodruff2@ti.com>
   6  *  Created for OMAP2.
   7  *
   8  *  Cleaned up and modified to use omap shared clock framework by
   9  *  Tony Lindgren <tony@atomide.com>
  10  *
  11  *  Based on omap1 clock.c, Copyright (C) 2004 - 2005 Nokia corporation
  12  *  Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  */
  18 #undef DEBUG
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/device.h>
  23 #include <linux/list.h>
  24 #include <linux/errno.h>
  25 #include <linux/delay.h>
  26 #include <linux/clk.h>
  27
  28 #include <linux/io.h>
  29 #include <linux/cpufreq.h>
  30
  31 #include <asm/arch/clock.h>
  32 #include <asm/arch/sram.h>
  33 #include <asm/div64.h>
  34
  35 #include "memory.h"
  36 #include "clock.h"
  37 #include "clock24xx.h"
  38 #include "prm.h"
  39 #include "prm_regbits_24xx.h"
  40 #include "cm.h"
  41 #include "cm_regbits_24xx.h"
  42
  43 /* CM_CLKEN_PLL.EN_{54,96}M_PLL options (24XX) */
  44 #define EN_APLL_STOPPED                 0
  45 #define EN_APLL_LOCKED                  3
  46
  47 /* CM_CLKSEL1_PLL.APLLS_CLKIN options (24XX) */
  48 #define APLLS_CLKIN_19_2MHZ             0
  49 #define APLLS_CLKIN_13MHZ               2
  50 #define APLLS_CLKIN_12MHZ               3
  51
  52 /* #define DOWN_VARIABLE_DPLL 1 */              /* Experimental */
  53
  54 static struct prcm_config *curr_prcm_set;
  55 static struct clk *vclk;
  56 static struct clk *sclk;
  57
  58 /*-------------------------------------------------------------------------
  59  * Omap24xx specific clock functions
  60  *-------------------------------------------------------------------------*/
  61
  62 /* This actually returns the rate of core_ck, not dpll_ck. */
  63 static u32 omap2_get_dpll_rate_24xx(struct clk *tclk)
  64 {
  65         long long dpll_clk;
  66         u8 amult;
  67
  68         dpll_clk = omap2_get_dpll_rate(tclk);
  69
  70         amult = cm_read_mod_reg(PLL_MOD, CM_CLKSEL2);
  71         amult &= OMAP24XX_CORE_CLK_SRC_MASK;
  72         dpll_clk *= amult;
  73
  74         return dpll_clk;
  75 }
  76
  77 static int omap2_enable_osc_ck(struct clk *clk)
  78 {
  79         u32 pcc;
  80
  81         pcc = prm_read_reg(OMAP24XX_PRCM_CLKSRC_CTRL);
  82
  83         prm_write_reg(pcc & ~OMAP_AUTOEXTCLKMODE_MASK,
  84                       OMAP24XX_PRCM_CLKSRC_CTRL);
  85
  86         return 0;
  87 }
  88
  89 static void omap2_disable_osc_ck(struct clk *clk)
  90 {
  91         u32 pcc;
  92
  93         pcc = prm_read_reg(OMAP24XX_PRCM_CLKSRC_CTRL);
  94
  95         prm_write_reg(pcc | OMAP_AUTOEXTCLKMODE_MASK,
  96                       OMAP24XX_PRCM_CLKSRC_CTRL);
  97 }
  98
  99 /* Enable an APLL if off */
 100 static int omap2_clk_fixed_enable(struct clk *clk)
 101 {
 102         u32 cval, apll_mask;
 103
 104         apll_mask = EN_APLL_LOCKED << clk->enable_bit;
 105
 106         cval = cm_read_mod_reg(PLL_MOD, CM_CLKEN);
 107
 108         if ((cval & apll_mask) == apll_mask)
 109                 return 0;   /* apll already enabled */
 110
 111         cval &= ~apll_mask;
 112         cval |= apll_mask;
 113         cm_write_mod_reg(cval, PLL_MOD, CM_CLKEN);
 114
 115         if (clk == &apll96_ck)
 116                 cval = OMAP24XX_ST_96M_APLL;
 117         else if (clk == &apll54_ck)
 118                 cval = OMAP24XX_ST_54M_CLK;
 119
 120         omap2_wait_clock_ready(OMAP_CM_REGADDR(PLL_MOD, CM_IDLEST), cval,
 121                             clk->name);
 122
 123         /*
 124          * REVISIT: Should we return an error code if omap2_wait_clock_ready()
 125          * fails?
 126          */
 127         return 0;
 128 }
 129
 130 /* Stop APLL */
 131 static void omap2_clk_fixed_disable(struct clk *clk)
 132 {
 133         u32 cval;
 134
 135         cval = cm_read_mod_reg(PLL_MOD, CM_CLKEN);
 136         cval &= ~(EN_APLL_LOCKED << clk->enable_bit);
 137         cm_write_mod_reg(cval, PLL_MOD, CM_CLKEN);
 138 }
 139
 140 /*
 141  * Uses the current prcm set to tell if a rate is valid.
 142  * You can go slower, but not faster within a given rate set.
 143  */
 144 static u32 omap2_dpll_round_rate(unsigned long target_rate)
 145 {
 146         u32 high, low, core_clk_src;
 147
 148         core_clk_src = cm_read_mod_reg(PLL_MOD, CM_CLKSEL2);
 149         core_clk_src &= OMAP24XX_CORE_CLK_SRC_MASK;
 150
 151         if (core_clk_src == CORE_CLK_SRC_DPLL) {        /* DPLL clockout */
 152                 high = curr_prcm_set->dpll_speed * 2;
 153                 low = curr_prcm_set->dpll_speed;
 154         } else {                                /* DPLL clockout x 2 */
 155                 high = curr_prcm_set->dpll_speed;
 156                 low = curr_prcm_set->dpll_speed / 2;
 157         }
 158
 159 #ifdef DOWN_VARIABLE_DPLL
 160         if (target_rate > high)
 161                 return high;
 162         else
 163                 return target_rate;
 164 #else
 165         if (target_rate > low)
 166                 return high;
 167         else
 168                 return low;
 169 #endif
 170
 171 }
 172
 173 static void omap2_dpll_recalc(struct clk *clk)
 174 {
 175         clk->rate = omap2_get_dpll_rate_24xx(clk);
 176
 177         propagate_rate(clk);
 178 }
 179
 180 static int omap2_reprogram_dpll(struct clk *clk, unsigned long rate)
 181 {
 182         u32 cur_rate, low, mult, div, valid_rate, done_rate;
 183         u32 bypass = 0;
 184         struct prcm_config tmpset;
 185         const struct dpll_data *dd;
 186         unsigned long flags;
 187         int ret = -EINVAL;
 188
 189         local_irq_save(flags);
 190         cur_rate = omap2_get_dpll_rate_24xx(&dpll_ck);
 191         mult = cm_read_mod_reg(PLL_MOD, CM_CLKSEL2);
 192         mult &= OMAP24XX_CORE_CLK_SRC_MASK;
 193
 194         if ((rate == (cur_rate / 2)) && (mult == 2)) {
 195                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL, 1);
 196         } else if ((rate == (cur_rate * 2)) && (mult == 1)) {
 197                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL_X2, 1);
 198         } else if (rate != cur_rate) {
 199                 valid_rate = omap2_dpll_round_rate(rate);
 200                 if (valid_rate != rate)
 201                         goto dpll_exit;
 202
 203                 if (mult == 1)
 204                         low = curr_prcm_set->dpll_speed;
 205                 else
 206                         low = curr_prcm_set->dpll_speed / 2;
 207
 208                 dd = clk->dpll_data;
 209                 if (!dd)
 210                         goto dpll_exit;
 211
 212                 tmpset.cm_clksel1_pll = cm_read_reg(dd->mult_div1_reg);
 213                 tmpset.cm_clksel1_pll &= ~(dd->mult_mask |
 214                                            dd->div1_mask);
 215                 div = ((curr_prcm_set->xtal_speed / 1000000) - 1);
 216                 tmpset.cm_clksel2_pll = cm_read_mod_reg(PLL_MOD, CM_CLKSEL2);
 217                 tmpset.cm_clksel2_pll &= ~OMAP24XX_CORE_CLK_SRC_MASK;
 218                 if (rate > low) {
 219                         tmpset.cm_clksel2_pll |= CORE_CLK_SRC_DPLL_X2;
 220                         mult = ((rate / 2) / 1000000);
 221                         done_rate = CORE_CLK_SRC_DPLL_X2;
 222                 } else {
 223                         tmpset.cm_clksel2_pll |= CORE_CLK_SRC_DPLL;
 224                         mult = (rate / 1000000);
 225                         done_rate = CORE_CLK_SRC_DPLL;
 226                 }
 227                 tmpset.cm_clksel1_pll |= (div << mask_to_shift(dd->mult_mask));
 228                 tmpset.cm_clksel1_pll |= (mult << mask_to_shift(dd->div1_mask));
 229
 230                 /* Worst case */
 231                 tmpset.base_sdrc_rfr = SDRC_RFR_CTRL_BYPASS;
 232
 233                 if (rate == curr_prcm_set->xtal_speed)  /* If asking for 1-1 */
 234                         bypass = 1;
 235
 236                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL_X2, 1); /* For init_mem */
 237
 238                 /* Force dll lock mode */
 239                 omap2_set_prcm(tmpset.cm_clksel1_pll, tmpset.base_sdrc_rfr,
 240                                bypass);
 241
 242                 /* Errata: ret dll entry state */
 243                 omap2_init_memory_params(omap2_dll_force_needed());
 244                 omap2_reprogram_sdrc(done_rate, 0);
 245         }
 246         omap2_dpll_recalc(&dpll_ck);
 247         ret = 0;
 248
 249 dpll_exit:
 250         local_irq_restore(flags);
 251         return(ret);
 252 }
 253
 254 /**
 255  * omap2_table_mpu_recalc - just return the MPU speed
 256  * @clk: virt_prcm_set struct clk
 257  *
 258  * Set virt_prcm_set's rate to the mpu_speed field of the current PRCM set.
 259  */
 260 static void omap2_table_mpu_recalc(struct clk *clk)
 261 {
 262         clk->rate = curr_prcm_set->mpu_speed;
 263 }
 264
 265 /*
 266  * Look for a rate equal or less than the target rate given a configuration set.
 267  *
 268  * What's not entirely clear is "which" field represents the key field.
 269  * Some might argue L3-DDR, others ARM, others IVA. This code is simple and
 270  * just uses the ARM rates.
 271  */
 272 static long omap2_round_to_table_rate(struct clk *clk, unsigned long rate)
 273 {
 274         struct prcm_config *ptr;
 275         long highest_rate;
 276
 277         if (clk != &virt_prcm_set)
 278                 return -EINVAL;
 279
 280         highest_rate = -EINVAL;
 281
 282         for (ptr = rate_table; ptr->mpu_speed; ptr++) {
 283                 if (!(ptr->flags & cpu_mask))
 284                         continue;
 285                 if (ptr->xtal_speed != sys_ck.rate)
 286                         continue;
 287
 288                 highest_rate = ptr->mpu_speed;
 289
 290                 /* Can check only after xtal frequency check */
 291                 if (ptr->mpu_speed <= rate)
 292                         break;
 293         }
 294         return highest_rate;
 295 }
 296
 297 /* Sets basic clocks based on the specified rate */
 298 static int omap2_select_table_rate(struct clk *clk, unsigned long rate)
 299 {
 300         u32 cur_rate, done_rate, bypass = 0, tmp;
 301         struct prcm_config *prcm;
 302         unsigned long found_speed = 0;
 303         unsigned long flags;
 304
 305         if (clk != &virt_prcm_set)
 306                 return -EINVAL;
 307
 308         for (prcm = rate_table; prcm->mpu_speed; prcm++) {
 309                 if (!(prcm->flags & cpu_mask))
 310                         continue;
 311
 312                 if (prcm->xtal_speed != sys_ck.rate)
 313                         continue;
 314
 315                 if (prcm->mpu_speed <= rate) {
 316                         found_speed = prcm->mpu_speed;
 317                         break;
 318                 }
 319         }
 320
 321         if (!found_speed) {
 322                 printk(KERN_INFO "Could not set MPU rate to %luMHz\n",
 323                        rate / 1000000);
 324                 return -EINVAL;
 325         }
 326
 327         curr_prcm_set = prcm;
 328         cur_rate = omap2_get_dpll_rate_24xx(&dpll_ck);
 329
 330         if (prcm->dpll_speed == cur_rate / 2) {
 331                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL, 1);
 332         } else if (prcm->dpll_speed == cur_rate * 2) {
 333                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL_X2, 1);
 334         } else if (prcm->dpll_speed != cur_rate) {
 335                 local_irq_save(flags);
 336
 337                 if (prcm->dpll_speed == prcm->xtal_speed)
 338                         bypass = 1;
 339
 340                 if ((prcm->cm_clksel2_pll & OMAP24XX_CORE_CLK_SRC_MASK) ==
 341                     CORE_CLK_SRC_DPLL_X2)
 342                         done_rate = CORE_CLK_SRC_DPLL_X2;
 343                 else
 344                         done_rate = CORE_CLK_SRC_DPLL;
 345
 346                 /* MPU divider */
 347                 cm_write_mod_reg(prcm->cm_clksel_mpu, MPU_MOD, CM_CLKSEL);
 348
 349                 /* dsp + iva1 div(2420), iva2.1(2430) */
 350                 cm_write_mod_reg(prcm->cm_clksel_dsp,
 351                                  OMAP24XX_DSP_MOD, CM_CLKSEL);
 352
 353                 cm_write_mod_reg(prcm->cm_clksel_gfx, GFX_MOD, CM_CLKSEL);
 354
 355                 /* Major subsystem dividers */
 356                 tmp = cm_read_mod_reg(CORE_MOD, CM_CLKSEL1) & OMAP24XX_CLKSEL_DSS2_MASK;
 357                 cm_write_mod_reg(prcm->cm_clksel1_core | tmp, CORE_MOD, CM_CLKSEL1);
 358                 if (cpu_is_omap2430())
 359                         cm_write_mod_reg(prcm->cm_clksel_mdm,
 360                                          OMAP2430_MDM_MOD, CM_CLKSEL);
 361
 362                 /* x2 to enter init_mem */
 363                 omap2_reprogram_sdrc(CORE_CLK_SRC_DPLL_X2, 1);
 364
 365                 omap2_set_prcm(prcm->cm_clksel1_pll, prcm->base_sdrc_rfr,
 366                                bypass);
 367
 368                 omap2_init_memory_params(omap2_dll_force_needed());
 369                 omap2_reprogram_sdrc(done_rate, 0);
 370
 371                 local_irq_restore(flags);
 372         }
 373         omap2_dpll_recalc(&dpll_ck);
 374
 375         return 0;
 376 }
 377
 378 #ifdef CONFIG_CPU_FREQ
 379 /*
 380  * Walk PRCM rate table and fillout cpufreq freq_table
 381  */
 382 static struct cpufreq_frequency_table freq_table[ARRAY_SIZE(rate_table)];
 383
 384 void omap2_clk_init_cpufreq_table(struct cpufreq_frequency_table **table)
 385 {
 386         struct prcm_config *prcm;
 387         int i = 0;
 388
 389         for (prcm = rate_table; prcm->mpu_speed; prcm++) {
 390                 if (!(prcm->flags & cpu_mask))
 391                         continue;
 392                 if (prcm->xtal_speed != sys_ck.rate)
 393                         continue;
 394
 395                 /* don't put bypass rates in table */
 396                 if (prcm->dpll_speed == prcm->xtal_speed)
 397                         continue;
 398
 399                 freq_table[i].index = i;
 400                 freq_table[i].frequency = prcm->mpu_speed / 1000;
 401                 i++;
 402         }
 403
 404         if (i == 0) {
 405                 printk(KERN_WARNING "%s: failed to initialize frequency table\n",
 406                        __FUNCTION__);
 407                 return;
 408         }
 409
 410         freq_table[i].index = i;
 411         freq_table[i].frequency = CPUFREQ_TABLE_END;
 412
 413         *table = &freq_table[0];
 414 }
 415 #endif
 416
 417 static struct clk_functions omap2_clk_functions = {
 418         .clk_enable             = omap2_clk_enable,
 419         .clk_disable            = omap2_clk_disable,
 420         .clk_round_rate         = omap2_clk_round_rate,
 421         .clk_set_rate           = omap2_clk_set_rate,
 422         .clk_set_parent         = omap2_clk_set_parent,
 423         .clk_disable_unused     = omap2_clk_disable_unused,
 424 #ifdef  CONFIG_CPU_FREQ
 425         .clk_init_cpufreq_table = omap2_clk_init_cpufreq_table,
 426 #endif
 427 };
 428
 429 static u32 omap2_get_apll_clkin(void)
 430 {
 431         u32 aplls, sclk = 0;
 432
 433         aplls = cm_read_mod_reg(PLL_MOD, CM_CLKSEL1);
 434         aplls &= OMAP24XX_APLLS_CLKIN_MASK;
 435         aplls >>= OMAP24XX_APLLS_CLKIN_SHIFT;
 436
 437         if (aplls == APLLS_CLKIN_19_2MHZ)
 438                 sclk = 19200000;
 439         else if (aplls == APLLS_CLKIN_13MHZ)
 440                 sclk = 13000000;
 441         else if (aplls == APLLS_CLKIN_12MHZ)
 442                 sclk = 12000000;
 443
 444         return sclk;
 445 }
 446
 447 static u32 omap2_get_sysclkdiv(void)
 448 {
 449         u32 div;
 450
 451         div = prm_read_reg(OMAP24XX_PRCM_CLKSRC_CTRL);
 452         div &= OMAP_SYSCLKDIV_MASK;
 453         div >>= OMAP_SYSCLKDIV_SHIFT;
 454
 455         return div;
 456 }
 457
 458 static void omap2_osc_clk_recalc(struct clk *clk)
 459 {
 460         clk->rate = omap2_get_apll_clkin() * omap2_get_sysclkdiv();
 461         propagate_rate(clk);
 462 }
 463
 464 static void omap2_sys_clk_recalc(struct clk *clk)
 465 {
 466         clk->rate = clk->parent->rate / omap2_get_sysclkdiv();
 467         propagate_rate(clk);
 468 }
 469
 470 /*
 471  * Set clocks for bypass mode for reboot to work.
 472  */
 473 void omap2_clk_prepare_for_reboot(void)
 474 {
 475         u32 rate;
 476
 477         if (vclk == NULL || sclk == NULL)
 478                 return;
 479
 480         rate = clk_get_rate(sclk);
 481         clk_set_rate(vclk, rate);
 482 }
 483
 484 /*
 485  * Switch the MPU rate if specified on cmdline.
 486  * We cannot do this early until cmdline is parsed.
 487  */
 488 static int __init omap2_clk_arch_init(void)
 489 {
 490         if (!mpurate)
 491                 return -EINVAL;
 492
 493         if (omap2_select_table_rate(&virt_prcm_set, mpurate))
 494                 printk(KERN_ERR "Could not find matching MPU rate\n");
 495
 496         recalculate_root_clocks();
 497
 498         printk(KERN_INFO "Switched to new clocking rate (Crystal/DPLL/MPU): "
 499                "%ld.%01ld/%ld/%ld MHz\n",
 500                (sys_ck.rate / 1000000), (sys_ck.rate / 100000) % 10,
 501                (dpll_ck.rate / 1000000), (mpu_ck.rate / 1000000)) ;
 502
 503         return 0;
 504 }
 505 arch_initcall(omap2_clk_arch_init);
 506
 507 int __init omap2_clk_init(void)
 508 {
 509         struct prcm_config *prcm;
 510         struct clk **clkp;
 511         u32 clkrate;
 512
 513         if (cpu_is_omap242x())
 514                 cpu_mask = RATE_IN_242X;
 515         else if (cpu_is_omap2430())
 516                 cpu_mask = RATE_IN_243X;
 517
 518         clk_init(&omap2_clk_functions);
 519
 520         omap2_osc_clk_recalc(&osc_ck);
 521         omap2_sys_clk_recalc(&sys_ck);
 522
 523         for (clkp = onchip_24xx_clks;
 524              clkp < onchip_24xx_clks + ARRAY_SIZE(onchip_24xx_clks);
 525              clkp++) {
 526
 527                 if ((*clkp)->flags & CLOCK_IN_OMAP242X && cpu_is_omap2420()) {
 528                         clk_register(*clkp);
 529                         continue;
 530                 }
 531
 532                 if ((*clkp)->flags & CLOCK_IN_OMAP243X && (cpu_is_omap2430() || cpu_is_omap34xx())) {
 533                         clk_register(*clkp);
 534                         continue;
 535                 }
 536         }
 537
 538         /* Check the MPU rate set by bootloader */
 539         clkrate = omap2_get_dpll_rate_24xx(&dpll_ck);
 540         for (prcm = rate_table; prcm->mpu_speed; prcm++) {
 541                 if (!(prcm->flags & cpu_mask))
 542                         continue;
 543                 if (prcm->xtal_speed != sys_ck.rate)
 544                         continue;
 545                 if (prcm->dpll_speed <= clkrate)
 546                          break;
 547         }
 548         curr_prcm_set = prcm;
 549
 550         recalculate_root_clocks();
 551
 552         printk(KERN_INFO "Clocking rate (Crystal/DPLL/MPU): "
 553                "%ld.%01ld/%ld/%ld MHz\n",
 554                (sys_ck.rate / 1000000), (sys_ck.rate / 100000) % 10,
 555                (dpll_ck.rate / 1000000), (mpu_ck.rate / 1000000)) ;
 556
 557         /*
 558          * Only enable those clocks we will need, let the drivers
 559          * enable other clocks as necessary
 560          */
 561         clk_enable_init_clocks();
 562
 563         /* Avoid sleeping sleeping during omap2_clk_prepare_for_reboot() */
 564         vclk = clk_get(NULL, "virt_prcm_set");
 565         sclk = clk_get(NULL, "sys_ck");
 566
 567         return 0;
 568 }