git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-omap2/clock34xx.c

   1 /*
   2  * OMAP3-specific clock framework functions
   3  *
   4  * Copyright (C) 2007-2008 Texas Instruments, Inc.
   5  * Copyright (C) 2007-2008 Nokia Corporation
   6  *
   7  * Written by Paul Walmsley
   8  * Testing and integration fixes by Jouni Högander
   9  *
  10  * Parts of this code are based on code written by
  11  * Richard Woodruff, Tony Lindgren, Tuukka Tikkanen, Karthik Dasu
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  */
  17 #undef DEBUG
  18
  19 #include <linux/module.h>
  20 #include <linux/kernel.h>
  21 #include <linux/device.h>
  22 #include <linux/list.h>
  23 #include <linux/errno.h>
  24 #include <linux/delay.h>
  25 #include <linux/clk.h>
  26 #include <linux/io.h>
  27 #include <linux/limits.h>
  28 #include <linux/bitops.h>
  29
  30 #include <mach/clock.h>
  31 #include <mach/sram.h>
  32 #include <asm/div64.h>
  33
  34 #include "memory.h"
  35 #include "clock.h"
  36 #include "clock34xx.h"
  37 #include "prm.h"
  38 #include "prm-regbits-34xx.h"
  39 #include "cm.h"
  40 #include "cm-regbits-34xx.h"
  41
  42 /* CM_AUTOIDLE_PLL*.AUTO_* bit values */
  43 #define DPLL_AUTOIDLE_DISABLE                   0x0
  44 #define DPLL_AUTOIDLE_LOW_POWER_STOP            0x1
  45
  46 #define MAX_DPLL_WAIT_TRIES             1000000
  47
  48 /**
  49  * omap3_dpll_recalc - recalculate DPLL rate
  50  * @clk: DPLL struct clk
  51  *
  52  * Recalculate and propagate the DPLL rate.
  53  */
  54 static void omap3_dpll_recalc(struct clk *clk)
  55 {
  56         clk->rate = omap2_get_dpll_rate(clk);
  57
  58         propagate_rate(clk);
  59 }
  60
  61 /* _omap3_dpll_write_clken - write clken_bits arg to a DPLL's enable bits */
  62 static void _omap3_dpll_write_clken(struct clk *clk, u8 clken_bits)
  63 {
  64         const struct dpll_data *dd;
  65         u32 v;
  66
  67         dd = clk->dpll_data;
  68
  69         v = __raw_readl(dd->control_reg);
  70         v &= ~dd->enable_mask;
  71         v |= clken_bits << __ffs(dd->enable_mask);
  72         __raw_writel(v, dd->control_reg);
  73 }
  74
  75 /* _omap3_wait_dpll_status: wait for a DPLL to enter a specific state */
  76 static int _omap3_wait_dpll_status(struct clk *clk, u8 state)
  77 {
  78         const struct dpll_data *dd;
  79         int i = 0;
  80         int ret = -EINVAL;
  81         u32 idlest_mask;
  82
  83         dd = clk->dpll_data;
  84
  85         state <<= dd->idlest_bit;
  86         idlest_mask = 1 << dd->idlest_bit;
  87
  88         while (((__raw_readl(dd->idlest_reg) & idlest_mask) != state) &&
  89                i < MAX_DPLL_WAIT_TRIES) {
  90                 i++;
  91                 udelay(1);
  92         }
  93
  94         if (i == MAX_DPLL_WAIT_TRIES) {
  95                 printk(KERN_ERR "clock: %s failed transition to '%s'\n",
  96                        clk->name, (state) ? "locked" : "bypassed");
  97         } else {
  98                 pr_debug("clock: %s transition to '%s' in %d loops\n",
  99                          clk->name, (state) ? "locked" : "bypassed", i);
 100
 101                 ret = 0;
 102         }
 103
 104         return ret;
 105 }
 106
 107 /* Non-CORE DPLL (e.g., DPLLs that do not control SDRC) clock functions */
 108
 109 /*
 110  * _omap3_noncore_dpll_lock - instruct a DPLL to lock and wait for readiness
 111  * @clk: pointer to a DPLL struct clk
 112  *
 113  * Instructs a non-CORE DPLL to lock.  Waits for the DPLL to report
 114  * readiness before returning.  Will save and restore the DPLL's
 115  * autoidle state across the enable, per the CDP code.  If the DPLL
 116  * locked successfully, return 0; if the DPLL did not lock in the time
 117  * allotted, or DPLL3 was passed in, return -EINVAL.
 118  */
 119 static int _omap3_noncore_dpll_lock(struct clk *clk)
 120 {
 121         u8 ai;
 122         int r;
 123
 124         if (clk == &dpll3_ck)
 125                 return -EINVAL;
 126
 127         pr_debug("clock: locking DPLL %s\n", clk->name);
 128
 129         ai = omap3_dpll_autoidle_read(clk);
 130
 131         _omap3_dpll_write_clken(clk, DPLL_LOCKED);
 132
 133         if (ai) {
 134                 /*
 135                  * If no downstream clocks are enabled, CM_IDLEST bit
 136                  * may never become active, so don't wait for DPLL to lock.
 137                  */
 138                 r = 0;
 139                 omap3_dpll_allow_idle(clk);
 140         } else {
 141                 r = _omap3_wait_dpll_status(clk, 1);
 142                 omap3_dpll_deny_idle(clk);
 143         };
 144
 145         return r;
 146 }
 147
 148 /*
 149  * omap3_noncore_dpll_bypass - instruct a DPLL to bypass and wait for readiness
 150  * @clk: pointer to a DPLL struct clk
 151  *
 152  * Instructs a non-CORE DPLL to enter low-power bypass mode.  In
 153  * bypass mode, the DPLL's rate is set equal to its parent clock's
 154  * rate.  Waits for the DPLL to report readiness before returning.
 155  * Will save and restore the DPLL's autoidle state across the enable,
 156  * per the CDP code.  If the DPLL entered bypass mode successfully,
 157  * return 0; if the DPLL did not enter bypass in the time allotted, or
 158  * DPLL3 was passed in, or the DPLL does not support low-power bypass,
 159  * return -EINVAL.
 160  */
 161 static int _omap3_noncore_dpll_bypass(struct clk *clk)
 162 {
 163         int r;
 164         u8 ai;
 165
 166         if (clk == &dpll3_ck)
 167                 return -EINVAL;
 168
 169         if (!(clk->dpll_data->modes & (1 << DPLL_LOW_POWER_BYPASS)))
 170                 return -EINVAL;
 171
 172         pr_debug("clock: configuring DPLL %s for low-power bypass\n",
 173                  clk->name);
 174
 175         ai = omap3_dpll_autoidle_read(clk);
 176
 177         _omap3_dpll_write_clken(clk, DPLL_LOW_POWER_BYPASS);
 178
 179         r = _omap3_wait_dpll_status(clk, 0);
 180
 181         if (ai)
 182                 omap3_dpll_allow_idle(clk);
 183         else
 184                 omap3_dpll_deny_idle(clk);
 185
 186         return r;
 187 }
 188
 189 /*
 190  * _omap3_noncore_dpll_stop - instruct a DPLL to stop
 191  * @clk: pointer to a DPLL struct clk
 192  *
 193  * Instructs a non-CORE DPLL to enter low-power stop. Will save and
 194  * restore the DPLL's autoidle state across the stop, per the CDP
 195  * code.  If DPLL3 was passed in, or the DPLL does not support
 196  * low-power stop, return -EINVAL; otherwise, return 0.
 197  */
 198 static int _omap3_noncore_dpll_stop(struct clk *clk)
 199 {
 200         u8 ai;
 201
 202         if (clk == &dpll3_ck)
 203                 return -EINVAL;
 204
 205         if (!(clk->dpll_data->modes & (1 << DPLL_LOW_POWER_STOP)))
 206                 return -EINVAL;
 207
 208         pr_debug("clock: stopping DPLL %s\n", clk->name);
 209
 210         ai = omap3_dpll_autoidle_read(clk);
 211
 212         _omap3_dpll_write_clken(clk, DPLL_LOW_POWER_STOP);
 213
 214         if (ai)
 215                 omap3_dpll_allow_idle(clk);
 216         else
 217                 omap3_dpll_deny_idle(clk);
 218
 219         return 0;
 220 }
 221
 222 /**
 223  * omap3_noncore_dpll_enable - instruct a DPLL to enter bypass or lock mode
 224  * @clk: pointer to a DPLL struct clk
 225  *
 226  * Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
 227  * The choice of modes depends on the DPLL's programmed rate: if it is
 228  * the same as the DPLL's parent clock, it will enter bypass;
 229  * otherwise, it will enter lock.  This code will wait for the DPLL to
 230  * indicate readiness before returning, unless the DPLL takes too long
 231  * to enter the target state.  Intended to be used as the struct clk's
 232  * enable function.  If DPLL3 was passed in, or the DPLL does not
 233  * support low-power stop, or if the DPLL took too long to enter
 234  * bypass or lock, return -EINVAL; otherwise, return 0.
 235  */
 236 static int omap3_noncore_dpll_enable(struct clk *clk)
 237 {
 238         int r;
 239
 240         if (clk == &dpll3_ck)
 241                 return -EINVAL;
 242
 243         if (clk->parent->rate == clk_get_rate(clk))
 244                 r = _omap3_noncore_dpll_bypass(clk);
 245         else
 246                 r = _omap3_noncore_dpll_lock(clk);
 247
 248         return r;
 249 }
 250
 251 /**
 252  * omap3_noncore_dpll_enable - instruct a DPLL to enter bypass or lock mode
 253  * @clk: pointer to a DPLL struct clk
 254  *
 255  * Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
 256  * The choice of modes depends on the DPLL's programmed rate: if it is
 257  * the same as the DPLL's parent clock, it will enter bypass;
 258  * otherwise, it will enter lock.  This code will wait for the DPLL to
 259  * indicate readiness before returning, unless the DPLL takes too long
 260  * to enter the target state.  Intended to be used as the struct clk's
 261  * enable function.  If DPLL3 was passed in, or the DPLL does not
 262  * support low-power stop, or if the DPLL took too long to enter
 263  * bypass or lock, return -EINVAL; otherwise, return 0.
 264  */
 265 static void omap3_noncore_dpll_disable(struct clk *clk)
 266 {
 267         if (clk == &dpll3_ck)
 268                 return;
 269
 270         _omap3_noncore_dpll_stop(clk);
 271 }
 272
 273 /**
 274  * omap3_dpll_autoidle_read - read a DPLL's autoidle bits
 275  * @clk: struct clk * of the DPLL to read
 276  *
 277  * Return the DPLL's autoidle bits, shifted down to bit 0.  Returns
 278  * -EINVAL if passed a null pointer or if the struct clk does not
 279  * appear to refer to a DPLL.
 280  */
 281 static u32 omap3_dpll_autoidle_read(struct clk *clk)
 282 {
 283         const struct dpll_data *dd;
 284         u32 v;
 285
 286         if (!clk || !clk->dpll_data)
 287                 return -EINVAL;
 288
 289         dd = clk->dpll_data;
 290
 291         v = __raw_readl(dd->autoidle_reg);
 292         v &= dd->autoidle_mask;
 293         v >>= __ffs(dd->autoidle_mask);
 294
 295         return v;
 296 }
 297
 298 /**
 299  * omap3_dpll_allow_idle - enable DPLL autoidle bits
 300  * @clk: struct clk * of the DPLL to operate on
 301  *
 302  * Enable DPLL automatic idle control.  This automatic idle mode
 303  * switching takes effect only when the DPLL is locked, at least on
 304  * OMAP3430.  The DPLL will enter low-power stop when its downstream
 305  * clocks are gated.  No return value.
 306  */
 307 static void omap3_dpll_allow_idle(struct clk *clk)
 308 {
 309         const struct dpll_data *dd;
 310         u32 v;
 311
 312         if (!clk || !clk->dpll_data)
 313                 return;
 314
 315         dd = clk->dpll_data;
 316
 317         /*
 318          * REVISIT: CORE DPLL can optionally enter low-power bypass
 319          * by writing 0x5 instead of 0x1.  Add some mechanism to
 320          * optionally enter this mode.
 321          */
 322         v = __raw_readl(dd->autoidle_reg);
 323         v &= ~dd->autoidle_mask;
 324         v |= DPLL_AUTOIDLE_LOW_POWER_STOP << __ffs(dd->autoidle_mask);
 325         __raw_writel(v, dd->autoidle_reg);
 326 }
 327
 328 /**
 329  * omap3_dpll_deny_idle - prevent DPLL from automatically idling
 330  * @clk: struct clk * of the DPLL to operate on
 331  *
 332  * Disable DPLL automatic idle control.  No return value.
 333  */
 334 static void omap3_dpll_deny_idle(struct clk *clk)
 335 {
 336         const struct dpll_data *dd;
 337         u32 v;
 338
 339         if (!clk || !clk->dpll_data)
 340                 return;
 341
 342         dd = clk->dpll_data;
 343
 344         v = __raw_readl(dd->autoidle_reg);
 345         v &= ~dd->autoidle_mask;
 346         v |= DPLL_AUTOIDLE_DISABLE << __ffs(dd->autoidle_mask);
 347         __raw_writel(v, dd->autoidle_reg);
 348 }
 349
 350 /* Clock control for DPLL outputs */
 351
 352 /**
 353  * omap3_clkoutx2_recalc - recalculate DPLL X2 output virtual clock rate
 354  * @clk: DPLL output struct clk
 355  *
 356  * Using parent clock DPLL data, look up DPLL state.  If locked, set our
 357  * rate to the dpll_clk * 2; otherwise, just use dpll_clk.
 358  */
 359 static void omap3_clkoutx2_recalc(struct clk *clk)
 360 {
 361         const struct dpll_data *dd;
 362         u32 v;
 363         struct clk *pclk;
 364
 365         /* Walk up the parents of clk, looking for a DPLL */
 366         pclk = clk->parent;
 367         while (pclk && !pclk->dpll_data)
 368                 pclk = pclk->parent;
 369
 370         /* clk does not have a DPLL as a parent? */
 371         WARN_ON(!pclk);
 372
 373         dd = pclk->dpll_data;
 374
 375         WARN_ON(!dd->control_reg || !dd->enable_mask);
 376
 377         v = __raw_readl(dd->control_reg) & dd->enable_mask;
 378         v >>= __ffs(dd->enable_mask);
 379         if (v != DPLL_LOCKED)
 380                 clk->rate = clk->parent->rate;
 381         else
 382                 clk->rate = clk->parent->rate * 2;
 383
 384         if (clk->flags & RATE_PROPAGATES)
 385                 propagate_rate(clk);
 386 }
 387
 388 /* Common clock code */
 389
 390 /*
 391  * As it is structured now, this will prevent an OMAP2/3 multiboot
 392  * kernel from compiling.  This will need further attention.
 393  */
 394 #if defined(CONFIG_ARCH_OMAP3)
 395
 396 static struct clk_functions omap2_clk_functions = {
 397         .clk_enable             = omap2_clk_enable,
 398         .clk_disable            = omap2_clk_disable,
 399         .clk_round_rate         = omap2_clk_round_rate,
 400         .clk_set_rate           = omap2_clk_set_rate,
 401         .clk_set_parent         = omap2_clk_set_parent,
 402         .clk_disable_unused     = omap2_clk_disable_unused,
 403 };
 404
 405 /*
 406  * Set clocks for bypass mode for reboot to work.
 407  */
 408 void omap2_clk_prepare_for_reboot(void)
 409 {
 410         /* REVISIT: Not ready for 343x */
 411 #if 0
 412         u32 rate;
 413
 414         if (vclk == NULL || sclk == NULL)
 415                 return;
 416
 417         rate = clk_get_rate(sclk);
 418         clk_set_rate(vclk, rate);
 419 #endif
 420 }
 421
 422 /* REVISIT: Move this init stuff out into clock.c */
 423
 424 /*
 425  * Switch the MPU rate if specified on cmdline.
 426  * We cannot do this early until cmdline is parsed.
 427  */
 428 static int __init omap2_clk_arch_init(void)
 429 {
 430         if (!mpurate)
 431                 return -EINVAL;
 432
 433         /* REVISIT: not yet ready for 343x */
 434 #if 0
 435         if (omap2_select_table_rate(&virt_prcm_set, mpurate))
 436                 printk(KERN_ERR "Could not find matching MPU rate\n");
 437 #endif
 438
 439         recalculate_root_clocks();
 440
 441         printk(KERN_INFO "Switched to new clocking rate (Crystal/DPLL3/MPU): "
 442                "%ld.%01ld/%ld/%ld MHz\n",
 443                (osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
 444                (core_ck.rate / 1000000), (dpll1_fck.rate / 1000000)) ;
 445
 446         return 0;
 447 }
 448 arch_initcall(omap2_clk_arch_init);
 449
 450 int __init omap2_clk_init(void)
 451 {
 452         /* struct prcm_config *prcm; */
 453         struct clk **clkp;
 454         /* u32 clkrate; */
 455         u32 cpu_clkflg;
 456
 457         /* REVISIT: Ultimately this will be used for multiboot */
 458 #if 0
 459         if (cpu_is_omap242x()) {
 460                 cpu_mask = RATE_IN_242X;
 461                 cpu_clkflg = CLOCK_IN_OMAP242X;
 462                 clkp = onchip_24xx_clks;
 463         } else if (cpu_is_omap2430()) {
 464                 cpu_mask = RATE_IN_243X;
 465                 cpu_clkflg = CLOCK_IN_OMAP243X;
 466                 clkp = onchip_24xx_clks;
 467         }
 468 #endif
 469         if (cpu_is_omap34xx()) {
 470                 cpu_mask = RATE_IN_343X;
 471                 cpu_clkflg = CLOCK_IN_OMAP343X;
 472                 clkp = onchip_34xx_clks;
 473
 474                 /*
 475                  * Update this if there are further clock changes between ES2
 476                  * and production parts
 477                  */
 478                 if (omap_rev() == OMAP3430_REV_ES1_0) {
 479                         /* No 3430ES1-only rates exist, so no RATE_IN_3430ES1 */
 480                         cpu_clkflg |= CLOCK_IN_OMAP3430ES1;
 481                 } else {
 482                         cpu_mask |= RATE_IN_3430ES2;
 483                         cpu_clkflg |= CLOCK_IN_OMAP3430ES2;
 484                 }
 485         }
 486
 487         clk_init(&omap2_clk_functions);
 488
 489         for (clkp = onchip_34xx_clks;
 490              clkp < onchip_34xx_clks + ARRAY_SIZE(onchip_34xx_clks);
 491              clkp++) {
 492                 if ((*clkp)->flags & cpu_clkflg) {
 493                         clk_register(*clkp);
 494                         omap2_init_clk_clkdm(*clkp);
 495                 }
 496         }
 497
 498         /* REVISIT: Not yet ready for OMAP3 */
 499 #if 0
 500         /* Check the MPU rate set by bootloader */
 501         clkrate = omap2_get_dpll_rate_24xx(&dpll_ck);
 502         for (prcm = rate_table; prcm->mpu_speed; prcm++) {
 503                 if (!(prcm->flags & cpu_mask))
 504                         continue;
 505                 if (prcm->xtal_speed != sys_ck.rate)
 506                         continue;
 507                 if (prcm->dpll_speed <= clkrate)
 508                          break;
 509         }
 510         curr_prcm_set = prcm;
 511 #endif
 512
 513         recalculate_root_clocks();
 514
 515         printk(KERN_INFO "Clocking rate (Crystal/DPLL/ARM core): "
 516                "%ld.%01ld/%ld/%ld MHz\n",
 517                (osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
 518                (core_ck.rate / 1000000), (arm_fck.rate / 1000000));
 519
 520         /*
 521          * Only enable those clocks we will need, let the drivers
 522          * enable other clocks as necessary
 523          */
 524         clk_enable_init_clocks();
 525
 526         /* Avoid sleeping during omap2_clk_prepare_for_reboot() */
 527         /* REVISIT: not yet ready for 343x */
 528 #if 0
 529         vclk = clk_get(NULL, "virt_prcm_set");
 530         sclk = clk_get(NULL, "sys_ck");
 531 #endif
 532         return 0;
 533 }
 534
 535 #endif