arch/arm/mach-omap2/clock.c

   1 /*
   2  *  linux/arch/arm/mach-omap2/clock.c
   3  *
   4  *  Copyright (C) 2005-2008 Texas Instruments, Inc.
   5  *  Copyright (C) 2004-2010 Nokia Corporation
   6  *
   7  *  Contacts:
   8  *  Richard Woodruff <r-woodruff2@ti.com>
   9  *  Paul Walmsley
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  */
  15 #undef DEBUG
  16
  17 #include <linux/kernel.h>
  18 #include <linux/list.h>
  19 #include <linux/errno.h>
  20 #include <linux/err.h>
  21 #include <linux/delay.h>
  22 #include <linux/clk.h>
  23 #include <linux/io.h>
  24 #include <linux/bitops.h>
  25
  26 #include <asm/cpu.h>
  27
  28 #include <plat/clock.h>
  29 #include <plat/prcm.h>
  30
  31 #include <trace/events/power.h>
  32
  33 #include "soc.h"
  34 #include "clockdomain.h"
  35 #include "clock.h"
  36 #include "cm2xxx.h"
  37 #include "cm3xxx.h"
  38 #include "cm-regbits-24xx.h"
  39 #include "cm-regbits-34xx.h"
  40
  41 u16 cpu_mask;
  42
  43 /*
  44  * clkdm_control: if true, then when a clock is enabled in the
  45  * hardware, its clockdomain will first be enabled; and when a clock
  46  * is disabled in the hardware, its clockdomain will be disabled
  47  * afterwards.
  48  */
  49 static bool clkdm_control = true;
  50
  51 /*
  52  * OMAP2+ specific clock functions
  53  */
  54
  55 /* Private functions */
  56
  57 /**
  58  * _omap2_module_wait_ready - wait for an OMAP module to leave IDLE
  59  * @clk: struct clk * belonging to the module
  60  *
  61  * If the necessary clocks for the OMAP hardware IP block that
  62  * corresponds to clock @clk are enabled, then wait for the module to
  63  * indicate readiness (i.e., to leave IDLE).  This code does not
  64  * belong in the clock code and will be moved in the medium term to
  65  * module-dependent code.  No return value.
  66  */
  67 static void _omap2_module_wait_ready(struct clk *clk)
  68 {
  69         void __iomem *companion_reg, *idlest_reg;
  70         u8 other_bit, idlest_bit, idlest_val;
  71
  72         /* Not all modules have multiple clocks that their IDLEST depends on */
  73         if (clk->ops->find_companion) {
  74                 clk->ops->find_companion(clk, &companion_reg, &other_bit);
  75                 if (!(__raw_readl(companion_reg) & (1 << other_bit)))
  76                         return;
  77         }
  78
  79         clk->ops->find_idlest(clk, &idlest_reg, &idlest_bit, &idlest_val);
  80
  81         omap2_cm_wait_idlest(idlest_reg, (1 << idlest_bit), idlest_val,
  82                              __clk_get_name(clk));
  83 }
  84
  85 /* Public functions */
  86
  87 /**
  88  * omap2_init_clk_clkdm - look up a clockdomain name, store pointer in clk
  89  * @clk: OMAP clock struct ptr to use
  90  *
  91  * Convert a clockdomain name stored in a struct clk 'clk' into a
  92  * clockdomain pointer, and save it into the struct clk.  Intended to be
  93  * called during clk_register().  No return value.
  94  */
  95 void omap2_init_clk_clkdm(struct clk *clk)
  96 {
  97         struct clockdomain *clkdm;
  98         const char *clk_name;
  99
 100         if (!clk->clkdm_name)
 101                 return;
 102
 103         clk_name = __clk_get_name(clk);
 104
 105         clkdm = clkdm_lookup(clk->clkdm_name);
 106         if (clkdm) {
 107                 pr_debug("clock: associated clk %s to clkdm %s\n",
 108                          clk_name, clk->clkdm_name);
 109                 clk->clkdm = clkdm;
 110         } else {
 111                 pr_debug("clock: could not associate clk %s to clkdm %s\n",
 112                          clk_name, clk->clkdm_name);
 113         }
 114 }
 115
 116 /**
 117  * omap2_clk_disable_clkdm_control - disable clkdm control on clk enable/disable
 118  *
 119  * Prevent the OMAP clock code from calling into the clockdomain code
 120  * when a hardware clock in that clockdomain is enabled or disabled.
 121  * Intended to be called at init time from omap*_clk_init().  No
 122  * return value.
 123  */
 124 void __init omap2_clk_disable_clkdm_control(void)
 125 {
 126         clkdm_control = false;
 127 }
 128
 129 /**
 130  * omap2_clk_dflt_find_companion - find companion clock to @clk
 131  * @clk: struct clk * to find the companion clock of
 132  * @other_reg: void __iomem ** to return the companion clock CM_*CLKEN va in
 133  * @other_bit: u8 ** to return the companion clock bit shift in
 134  *
 135  * Note: We don't need special code here for INVERT_ENABLE for the
 136  * time being since INVERT_ENABLE only applies to clocks enabled by
 137  * CM_CLKEN_PLL
 138  *
 139  * Convert CM_ICLKEN* <-> CM_FCLKEN*.  This conversion assumes it's
 140  * just a matter of XORing the bits.
 141  *
 142  * Some clocks don't have companion clocks.  For example, modules with
 143  * only an interface clock (such as MAILBOXES) don't have a companion
 144  * clock.  Right now, this code relies on the hardware exporting a bit
 145  * in the correct companion register that indicates that the
 146  * nonexistent 'companion clock' is active.  Future patches will
 147  * associate this type of code with per-module data structures to
 148  * avoid this issue, and remove the casts.  No return value.
 149  */
 150 void omap2_clk_dflt_find_companion(struct clk *clk, void __iomem **other_reg,
 151                                    u8 *other_bit)
 152 {
 153         u32 r;
 154
 155         /*
 156          * Convert CM_ICLKEN* <-> CM_FCLKEN*.  This conversion assumes
 157          * it's just a matter of XORing the bits.
 158          */
 159         r = ((__force u32)clk->enable_reg ^ (CM_FCLKEN ^ CM_ICLKEN));
 160
 161         *other_reg = (__force void __iomem *)r;
 162         *other_bit = clk->enable_bit;
 163 }
 164
 165 /**
 166  * omap2_clk_dflt_find_idlest - find CM_IDLEST reg va, bit shift for @clk
 167  * @clk: struct clk * to find IDLEST info for
 168  * @idlest_reg: void __iomem ** to return the CM_IDLEST va in
 169  * @idlest_bit: u8 * to return the CM_IDLEST bit shift in
 170  * @idlest_val: u8 * to return the idle status indicator
 171  *
 172  * Return the CM_IDLEST register address and bit shift corresponding
 173  * to the module that "owns" this clock.  This default code assumes
 174  * that the CM_IDLEST bit shift is the CM_*CLKEN bit shift, and that
 175  * the IDLEST register address ID corresponds to the CM_*CLKEN
 176  * register address ID (e.g., that CM_FCLKEN2 corresponds to
 177  * CM_IDLEST2).  This is not true for all modules.  No return value.
 178  */
 179 void omap2_clk_dflt_find_idlest(struct clk *clk, void __iomem **idlest_reg,
 180                                 u8 *idlest_bit, u8 *idlest_val)
 181 {
 182         u32 r;
 183
 184         r = (((__force u32)clk->enable_reg & ~0xf0) | 0x20);
 185         *idlest_reg = (__force void __iomem *)r;
 186         *idlest_bit = clk->enable_bit;
 187
 188         /*
 189          * 24xx uses 0 to indicate not ready, and 1 to indicate ready.
 190          * 34xx reverses this, just to keep us on our toes
 191          * AM35xx uses both, depending on the module.
 192          */
 193         if (cpu_is_omap24xx())
 194                 *idlest_val = OMAP24XX_CM_IDLEST_VAL;
 195         else if (cpu_is_omap34xx())
 196                 *idlest_val = OMAP34XX_CM_IDLEST_VAL;
 197         else
 198                 BUG();
 199
 200 }
 201
 202 int omap2_dflt_clk_enable(struct clk *clk)
 203 {
 204         u32 v;
 205
 206         if (unlikely(clk->enable_reg == NULL)) {
 207                 pr_err("clock.c: Enable for %s without enable code\n",
 208                        clk->name);
 209                 return 0; /* REVISIT: -EINVAL */
 210         }
 211
 212         v = __raw_readl(clk->enable_reg);
 213         if (clk->flags & INVERT_ENABLE)
 214                 v &= ~(1 << clk->enable_bit);
 215         else
 216                 v |= (1 << clk->enable_bit);
 217         __raw_writel(v, clk->enable_reg);
 218         v = __raw_readl(clk->enable_reg); /* OCP barrier */
 219
 220         if (clk->ops->find_idlest)
 221                 _omap2_module_wait_ready(clk);
 222
 223         return 0;
 224 }
 225
 226 void omap2_dflt_clk_disable(struct clk *clk)
 227 {
 228         u32 v;
 229
 230         if (!clk->enable_reg) {
 231                 /*
 232                  * 'Independent' here refers to a clock which is not
 233                  * controlled by its parent.
 234                  */
 235                 pr_err("clock: clk_disable called on independent clock %s which has no enable_reg\n", clk->name);
 236                 return;
 237         }
 238
 239         v = __raw_readl(clk->enable_reg);
 240         if (clk->flags & INVERT_ENABLE)
 241                 v |= (1 << clk->enable_bit);
 242         else
 243                 v &= ~(1 << clk->enable_bit);
 244         __raw_writel(v, clk->enable_reg);
 245         /* No OCP barrier needed here since it is a disable operation */
 246 }
 247
 248 const struct clkops clkops_omap2_dflt_wait = {
 249         .enable         = omap2_dflt_clk_enable,
 250         .disable        = omap2_dflt_clk_disable,
 251         .find_companion = omap2_clk_dflt_find_companion,
 252         .find_idlest    = omap2_clk_dflt_find_idlest,
 253 };
 254
 255 const struct clkops clkops_omap2_dflt = {
 256         .enable         = omap2_dflt_clk_enable,
 257         .disable        = omap2_dflt_clk_disable,
 258 };
 259
 260 /**
 261  * omap2_clk_disable - disable a clock, if the system is not using it
 262  * @clk: struct clk * to disable
 263  *
 264  * Decrements the usecount on struct clk @clk.  If there are no users
 265  * left, call the clkops-specific clock disable function to disable it
 266  * in hardware.  If the clock is part of a clockdomain (which they all
 267  * should be), request that the clockdomain be disabled.  (It too has
 268  * a usecount, and so will not be disabled in the hardware until it no
 269  * longer has any users.)  If the clock has a parent clock (most of
 270  * them do), then call ourselves, recursing on the parent clock.  This
 271  * can cause an entire branch of the clock tree to be powered off by
 272  * simply disabling one clock.  Intended to be called with the clockfw_lock
 273  * spinlock held.  No return value.
 274  */
 275 void omap2_clk_disable(struct clk *clk)
 276 {
 277         if (clk->usecount == 0) {
 278                 WARN(1, "clock: %s: omap2_clk_disable() called, but usecount already 0?", clk->name);
 279                 return;
 280         }
 281
 282         pr_debug("clock: %s: decrementing usecount\n", clk->name);
 283
 284         clk->usecount--;
 285
 286         if (clk->usecount > 0)
 287                 return;
 288
 289         pr_debug("clock: %s: disabling in hardware\n", clk->name);
 290
 291         if (clk->ops && clk->ops->disable) {
 292                 trace_clock_disable(clk->name, 0, smp_processor_id());
 293                 clk->ops->disable(clk);
 294         }
 295
 296         if (clkdm_control && clk->clkdm)
 297                 clkdm_clk_disable(clk->clkdm, clk);
 298
 299         if (clk->parent)
 300                 omap2_clk_disable(clk->parent);
 301 }
 302
 303 /**
 304  * omap2_clk_enable - request that the system enable a clock
 305  * @clk: struct clk * to enable
 306  *
 307  * Increments the usecount on struct clk @clk.  If there were no users
 308  * previously, then recurse up the clock tree, enabling all of the
 309  * clock's parents and all of the parent clockdomains, and finally,
 310  * enabling @clk's clockdomain, and @clk itself.  Intended to be
 311  * called with the clockfw_lock spinlock held.  Returns 0 upon success
 312  * or a negative error code upon failure.
 313  */
 314 int omap2_clk_enable(struct clk *clk)
 315 {
 316         int ret;
 317
 318         pr_debug("clock: %s: incrementing usecount\n", clk->name);
 319
 320         clk->usecount++;
 321
 322         if (clk->usecount > 1)
 323                 return 0;
 324
 325         pr_debug("clock: %s: enabling in hardware\n", clk->name);
 326
 327         if (clk->parent) {
 328                 ret = omap2_clk_enable(clk->parent);
 329                 if (ret) {
 330                         WARN(1, "clock: %s: could not enable parent %s: %d\n",
 331                              clk->name, clk->parent->name, ret);
 332                         goto oce_err1;
 333                 }
 334         }
 335
 336         if (clkdm_control && clk->clkdm) {
 337                 ret = clkdm_clk_enable(clk->clkdm, clk);
 338                 if (ret) {
 339                         WARN(1, "clock: %s: could not enable clockdomain %s: %d\n",
 340                              clk->name, clk->clkdm->name, ret);
 341                         goto oce_err2;
 342                 }
 343         }
 344
 345         if (clk->ops && clk->ops->enable) {
 346                 trace_clock_enable(clk->name, 1, smp_processor_id());
 347                 ret = clk->ops->enable(clk);
 348                 if (ret) {
 349                         WARN(1, "clock: %s: could not enable: %d\n",
 350                              clk->name, ret);
 351                         goto oce_err3;
 352                 }
 353         }
 354
 355         return 0;
 356
 357 oce_err3:
 358         if (clkdm_control && clk->clkdm)
 359                 clkdm_clk_disable(clk->clkdm, clk);
 360 oce_err2:
 361         if (clk->parent)
 362                 omap2_clk_disable(clk->parent);
 363 oce_err1:
 364         clk->usecount--;
 365
 366         return ret;
 367 }
 368
 369 /* Given a clock and a rate apply a clock specific rounding function */
 370 long omap2_clk_round_rate(struct clk *clk, unsigned long rate)
 371 {
 372         if (clk->round_rate)
 373                 return clk->round_rate(clk, rate);
 374
 375         return clk->rate;
 376 }
 377
 378 /* Set the clock rate for a clock source */
 379 int omap2_clk_set_rate(struct clk *clk, unsigned long rate)
 380 {
 381         int ret = -EINVAL;
 382
 383         pr_debug("clock: set_rate for clock %s to rate %ld\n", clk->name, rate);
 384
 385         /* dpll_ck, core_ck, virt_prcm_set; plus all clksel clocks */
 386         if (clk->set_rate) {
 387                 trace_clock_set_rate(clk->name, rate, smp_processor_id());
 388                 ret = clk->set_rate(clk, rate);
 389         }
 390
 391         return ret;
 392 }
 393
 394 int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
 395 {
 396         if (!clk->clksel)
 397                 return -EINVAL;
 398
 399         if (clk->parent == new_parent)
 400                 return 0;
 401
 402         return omap2_clksel_set_parent(clk, new_parent);
 403 }
 404
 405 /*
 406  * OMAP2+ clock reset and init functions
 407  */
 408
 409 #ifdef CONFIG_OMAP_RESET_CLOCKS
 410 void omap2_clk_disable_unused(struct clk *clk)
 411 {
 412         u32 regval32, v;
 413
 414         v = (clk->flags & INVERT_ENABLE) ? (1 << clk->enable_bit) : 0;
 415
 416         regval32 = __raw_readl(clk->enable_reg);
 417         if ((regval32 & (1 << clk->enable_bit)) == v)
 418                 return;
 419
 420         pr_debug("Disabling unused clock \"%s\"\n", clk->name);
 421         if (cpu_is_omap34xx()) {
 422                 omap2_clk_enable(clk);
 423                 omap2_clk_disable(clk);
 424         } else {
 425                 clk->ops->disable(clk);
 426         }
 427         if (clk->clkdm != NULL)
 428                 pwrdm_state_switch(clk->clkdm->pwrdm.ptr);
 429 }
 430 #endif
 431
 432 /**
 433  * omap2_clk_switch_mpurate_at_boot - switch ARM MPU rate by boot-time argument
 434  * @mpurate_ck_name: clk name of the clock to change rate
 435  *
 436  * Change the ARM MPU clock rate to the rate specified on the command
 437  * line, if one was specified.  @mpurate_ck_name should be
 438  * "virt_prcm_set" on OMAP2xxx and "dpll1_ck" on OMAP34xx/OMAP36xx.
 439  * XXX Does not handle voltage scaling - on OMAP2xxx this is currently
 440  * handled by the virt_prcm_set clock, but this should be handled by
 441  * the OPP layer.  XXX This is intended to be handled by the OPP layer
 442  * code in the near future and should be removed from the clock code.
 443  * Returns -EINVAL if 'mpurate' is zero or if clk_set_rate() rejects
 444  * the rate, -ENOENT if the struct clk referred to by @mpurate_ck_name
 445  * cannot be found, or 0 upon success.
 446  */
 447 int __init omap2_clk_switch_mpurate_at_boot(const char *mpurate_ck_name)
 448 {
 449         struct clk *mpurate_ck;
 450         int r;
 451
 452         if (!mpurate)
 453                 return -EINVAL;
 454
 455         mpurate_ck = clk_get(NULL, mpurate_ck_name);
 456         if (WARN(IS_ERR(mpurate_ck), "Failed to get %s.\n", mpurate_ck_name))
 457                 return -ENOENT;
 458
 459         r = clk_set_rate(mpurate_ck, mpurate);
 460         if (IS_ERR_VALUE(r)) {
 461                 WARN(1, "clock: %s: unable to set MPU rate to %d: %d\n",
 462                      mpurate_ck->name, mpurate, r);
 463                 clk_put(mpurate_ck);
 464                 return -EINVAL;
 465         }
 466
 467         calibrate_delay();
 468         recalculate_root_clocks();
 469
 470         clk_put(mpurate_ck);
 471
 472         return 0;
 473 }
 474
 475 /**
 476  * omap2_clk_print_new_rates - print summary of current clock tree rates
 477  * @hfclkin_ck_name: clk name for the off-chip HF oscillator
 478  * @core_ck_name: clk name for the on-chip CORE_CLK
 479  * @mpu_ck_name: clk name for the ARM MPU clock
 480  *
 481  * Prints a short message to the console with the HFCLKIN oscillator
 482  * rate, the rate of the CORE clock, and the rate of the ARM MPU clock.
 483  * Called by the boot-time MPU rate switching code.   XXX This is intended
 484  * to be handled by the OPP layer code in the near future and should be
 485  * removed from the clock code.  No return value.
 486  */
 487 void __init omap2_clk_print_new_rates(const char *hfclkin_ck_name,
 488                                       const char *core_ck_name,
 489                                       const char *mpu_ck_name)
 490 {
 491         struct clk *hfclkin_ck, *core_ck, *mpu_ck;
 492         unsigned long hfclkin_rate;
 493
 494         mpu_ck = clk_get(NULL, mpu_ck_name);
 495         if (WARN(IS_ERR(mpu_ck), "clock: failed to get %s.\n", mpu_ck_name))
 496                 return;
 497
 498         core_ck = clk_get(NULL, core_ck_name);
 499         if (WARN(IS_ERR(core_ck), "clock: failed to get %s.\n", core_ck_name))
 500                 return;
 501
 502         hfclkin_ck = clk_get(NULL, hfclkin_ck_name);
 503         if (WARN(IS_ERR(hfclkin_ck), "Failed to get %s.\n", hfclkin_ck_name))
 504                 return;
 505
 506         hfclkin_rate = clk_get_rate(hfclkin_ck);
 507
 508         pr_info("Switched to new clocking rate (Crystal/Core/MPU): %ld.%01ld/%ld/%ld MHz\n",
 509                 (hfclkin_rate / 1000000), ((hfclkin_rate / 100000) % 10),
 510                 (clk_get_rate(core_ck) / 1000000),
 511                 (clk_get_rate(mpu_ck) / 1000000));
 512 }
 513
 514 /* Common data */
 515
 516 struct clk_functions omap2_clk_functions = {
 517         .clk_enable             = omap2_clk_enable,
 518         .clk_disable            = omap2_clk_disable,
 519         .clk_round_rate         = omap2_clk_round_rate,
 520         .clk_set_rate           = omap2_clk_set_rate,
 521         .clk_set_parent         = omap2_clk_set_parent,
 522         .clk_disable_unused     = omap2_clk_disable_unused,
 523 };
 524