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-2008 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/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/device.h>
  20 #include <linux/list.h>
  21 #include <linux/errno.h>
  22 #include <linux/delay.h>
  23 #include <linux/clk.h>
  24 #include <asm/bitops.h>
  25
  26 #include <asm/io.h>
  27
  28 #include <asm/arch/clock.h>
  29 #include <asm/arch/sram.h>
  30 #include <asm/arch/cpu.h>
  31 #include <asm/div64.h>
  32
  33 #include "memory.h"
  34 #include "sdrc.h"
  35 #include "clock.h"
  36 #include "prm.h"
  37 #include "prm-regbits-24xx.h"
  38 #include "cm.h"
  39 #include "cm-regbits-24xx.h"
  40 #include "cm-regbits-34xx.h"
  41
  42 #define MAX_CLOCK_ENABLE_WAIT           100000
  43
  44 u8 cpu_mask;
  45
  46 /*-------------------------------------------------------------------------
  47  * Omap2 specific clock functions
  48  *-------------------------------------------------------------------------*/
  49
  50 /**
  51  * omap2_init_clksel_parent - set a clksel clk's parent field from the hardware
  52  * @clk: OMAP clock struct ptr to use
  53  *
  54  * Given a pointer to a source-selectable struct clk, read the hardware
  55  * register and determine what its parent is currently set to.  Update the
  56  * clk->parent field with the appropriate clk ptr.
  57  */
  58 void omap2_init_clksel_parent(struct clk *clk)
  59 {
  60         const struct clksel *clks;
  61         const struct clksel_rate *clkr;
  62         u32 r, found = 0;
  63
  64         if (!clk->clksel)
  65                 return;
  66
  67         r = __raw_readl(clk->clksel_reg) & clk->clksel_mask;
  68         r >>= __ffs(clk->clksel_mask);
  69
  70         for (clks = clk->clksel; clks->parent && !found; clks++) {
  71                 for (clkr = clks->rates; clkr->div && !found; clkr++) {
  72                         if ((clkr->flags & cpu_mask) && (clkr->val == r)) {
  73                                 if (clk->parent != clks->parent) {
  74                                         pr_debug("clock: inited %s parent "
  75                                                  "to %s (was %s)\n",
  76                                                  clk->name, clks->parent->name,
  77                                                  ((clk->parent) ?
  78                                                   clk->parent->name : "NULL"));
  79                                         clk->parent = clks->parent;
  80                                 };
  81                                 found = 1;
  82                         }
  83                 }
  84         }
  85
  86         if (!found)
  87                 printk(KERN_ERR "clock: init parent: could not find "
  88                        "regval %0x for clock %s\n", r,  clk->name);
  89
  90         return;
  91 }
  92
  93 /* Returns the DPLL rate */
  94 u32 omap2_get_dpll_rate(struct clk *clk)
  95 {
  96         long long dpll_clk;
  97         u32 dpll_mult, dpll_div, dpll;
  98         const struct dpll_data *dd;
  99
 100         dd = clk->dpll_data;
 101         /* REVISIT: What do we return on error? */
 102         if (!dd)
 103                 return 0;
 104
 105         dpll = __raw_readl(dd->mult_div1_reg);
 106         dpll_mult = dpll & dd->mult_mask;
 107         dpll_mult >>= __ffs(dd->mult_mask);
 108         dpll_div = dpll & dd->div1_mask;
 109         dpll_div >>= __ffs(dd->div1_mask);
 110
 111         dpll_clk = (long long)clk->parent->rate * dpll_mult;
 112         do_div(dpll_clk, dpll_div + 1);
 113
 114         return dpll_clk;
 115 }
 116
 117 /*
 118  * Used for clocks that have the same value as the parent clock,
 119  * divided by some factor
 120  */
 121 void omap2_fixed_divisor_recalc(struct clk *clk)
 122 {
 123         WARN_ON(!clk->fixed_div);
 124
 125         clk->rate = clk->parent->rate / clk->fixed_div;
 126
 127         if (clk->flags & RATE_PROPAGATES)
 128                 propagate_rate(clk);
 129 }
 130
 131 /**
 132  * omap2_wait_clock_ready - wait for clock to enable
 133  * @reg: physical address of clock IDLEST register
 134  * @mask: value to mask against to determine if the clock is active
 135  * @name: name of the clock (for printk)
 136  *
 137  * Returns 1 if the clock enabled in time, or 0 if it failed to enable
 138  * in roughly MAX_CLOCK_ENABLE_WAIT microseconds.
 139  */
 140 int omap2_wait_clock_ready(void __iomem *reg, u32 mask, const char *name)
 141 {
 142         int i = 0;
 143         int ena = 0;
 144
 145         /*
 146          * 24xx uses 0 to indicate not ready, and 1 to indicate ready.
 147          * 34xx reverses this, just to keep us on our toes
 148          */
 149         if (cpu_mask & (RATE_IN_242X | RATE_IN_243X)) {
 150                 ena = mask;
 151         } else if (cpu_mask & RATE_IN_343X) {
 152                 ena = 0;
 153         }
 154
 155         /* Wait for lock */
 156         while (((__raw_readl(reg) & mask) != ena) &&
 157                (i++ < MAX_CLOCK_ENABLE_WAIT)) {
 158                 udelay(1);
 159         }
 160
 161         if (i < MAX_CLOCK_ENABLE_WAIT)
 162                 pr_debug("Clock %s stable after %d loops\n", name, i);
 163         else
 164                 printk(KERN_ERR "Clock %s didn't enable in %d tries\n",
 165                        name, MAX_CLOCK_ENABLE_WAIT);
 166
 167
 168         return (i < MAX_CLOCK_ENABLE_WAIT) ? 1 : 0;
 169 };
 170
 171
 172 /*
 173  * Note: We don't need special code here for INVERT_ENABLE
 174  * for the time being since INVERT_ENABLE only applies to clocks enabled by
 175  * CM_CLKEN_PLL
 176  */
 177 static void omap2_clk_wait_ready(struct clk *clk)
 178 {
 179         void __iomem *reg, *other_reg, *st_reg;
 180         u32 bit;
 181
 182         /*
 183          * REVISIT: This code is pretty ugly.  It would be nice to generalize
 184          * it and pull it into struct clk itself somehow.
 185          */
 186         reg = clk->enable_reg;
 187         if ((((u32)reg & 0xff) >= CM_FCLKEN1) &&
 188             (((u32)reg & 0xff) <= OMAP24XX_CM_FCLKEN2))
 189                 other_reg = (void __iomem *)(((u32)reg & ~0xf0) | 0x10); /* CM_ICLKEN* */
 190         else if ((((u32)reg & 0xff) >= CM_ICLKEN1) &&
 191                  (((u32)reg & 0xff) <= OMAP24XX_CM_ICLKEN4))
 192                 other_reg = (void __iomem *)(((u32)reg & ~0xf0) | 0x00); /* CM_FCLKEN* */
 193         else
 194                 return;
 195
 196         /* REVISIT: What are the appropriate exclusions for 34XX? */
 197         /* No check for DSS or cam clocks */
 198         if (cpu_is_omap24xx() && ((u32)reg & 0x0f) == 0) { /* CM_{F,I}CLKEN1 */
 199                 if (clk->enable_bit == OMAP24XX_EN_DSS2_SHIFT ||
 200                     clk->enable_bit == OMAP24XX_EN_DSS1_SHIFT ||
 201                     clk->enable_bit == OMAP24XX_EN_CAM_SHIFT)
 202                         return;
 203         }
 204
 205         /* REVISIT: What are the appropriate exclusions for 34XX? */
 206         /* OMAP3: ignore DSS-mod clocks */
 207         if (cpu_is_omap34xx() &&
 208             (((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(OMAP3430_DSS_MOD, 0) ||
 209              ((((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(CORE_MOD, 0)) &&
 210              clk->enable_bit == OMAP3430_EN_SSI_SHIFT)))
 211                 return;
 212
 213         /* Check if both functional and interface clocks
 214          * are running. */
 215         bit = 1 << clk->enable_bit;
 216         if (!(__raw_readl(other_reg) & bit))
 217                 return;
 218         st_reg = (void __iomem *)(((u32)other_reg & ~0xf0) | 0x20); /* CM_IDLEST* */
 219
 220         omap2_wait_clock_ready(st_reg, bit, clk->name);
 221 }
 222
 223 /* Enables clock without considering parent dependencies or use count
 224  * REVISIT: Maybe change this to use clk->enable like on omap1?
 225  */
 226 int _omap2_clk_enable(struct clk *clk)
 227 {
 228         u32 regval32;
 229
 230         if (clk->flags & (ALWAYS_ENABLED | PARENT_CONTROLS_CLOCK))
 231                 return 0;
 232
 233         if (clk->enable)
 234                 return clk->enable(clk);
 235
 236         if (unlikely(clk->enable_reg == 0)) {
 237                 printk(KERN_ERR "clock.c: Enable for %s without enable code\n",
 238                        clk->name);
 239                 return 0; /* REVISIT: -EINVAL */
 240         }
 241
 242         regval32 = __raw_readl(clk->enable_reg);
 243         if (clk->flags & INVERT_ENABLE)
 244                 regval32 &= ~(1 << clk->enable_bit);
 245         else
 246                 regval32 |= (1 << clk->enable_bit);
 247         __raw_writel(regval32, clk->enable_reg);
 248         wmb();
 249
 250         omap2_clk_wait_ready(clk);
 251
 252         return 0;
 253 }
 254
 255 /* Disables clock without considering parent dependencies or use count */
 256 void _omap2_clk_disable(struct clk *clk)
 257 {
 258         u32 regval32;
 259
 260         if (clk->flags & (ALWAYS_ENABLED | PARENT_CONTROLS_CLOCK))
 261                 return;
 262
 263         if (clk->disable) {
 264                 clk->disable(clk);
 265                 return;
 266         }
 267
 268         if (clk->enable_reg == 0) {
 269                 /*
 270                  * 'Independent' here refers to a clock which is not
 271                  * controlled by its parent.
 272                  */
 273                 printk(KERN_ERR "clock: clk_disable called on independent "
 274                        "clock %s which has no enable_reg\n", clk->name);
 275                 return;
 276         }
 277
 278         regval32 = __raw_readl(clk->enable_reg);
 279         if (clk->flags & INVERT_ENABLE)
 280                 regval32 |= (1 << clk->enable_bit);
 281         else
 282                 regval32 &= ~(1 << clk->enable_bit);
 283         __raw_writel(regval32, clk->enable_reg);
 284         wmb();
 285 }
 286
 287 void omap2_clk_disable(struct clk *clk)
 288 {
 289         if (clk->usecount > 0 && !(--clk->usecount)) {
 290                 _omap2_clk_disable(clk);
 291                 if (likely((u32)clk->parent))
 292                         omap2_clk_disable(clk->parent);
 293         }
 294 }
 295
 296 int omap2_clk_enable(struct clk *clk)
 297 {
 298         int ret = 0;
 299
 300         if (clk->usecount++ == 0) {
 301                 if (likely((u32)clk->parent))
 302                         ret = omap2_clk_enable(clk->parent);
 303
 304                 if (unlikely(ret != 0)) {
 305                         clk->usecount--;
 306                         return ret;
 307                 }
 308
 309                 ret = _omap2_clk_enable(clk);
 310
 311                 if (unlikely(ret != 0) && clk->parent) {
 312                         omap2_clk_disable(clk->parent);
 313                         clk->usecount--;
 314                 }
 315         }
 316
 317         return ret;
 318 }
 319
 320 /*
 321  * Used for clocks that are part of CLKSEL_xyz governed clocks.
 322  * REVISIT: Maybe change to use clk->enable() functions like on omap1?
 323  */
 324 void omap2_clksel_recalc(struct clk *clk)
 325 {
 326         u32 div = 0;
 327
 328         pr_debug("clock: recalc'ing clksel clk %s\n", clk->name);
 329
 330         div = omap2_clksel_get_divisor(clk);
 331         if (div == 0)
 332                 return;
 333
 334         if (unlikely(clk->rate == clk->parent->rate / div))
 335                 return;
 336         clk->rate = clk->parent->rate / div;
 337
 338         pr_debug("clock: new clock rate is %ld (div %d)\n", clk->rate, div);
 339
 340         if (unlikely(clk->flags & RATE_PROPAGATES))
 341                 propagate_rate(clk);
 342 }
 343
 344 /**
 345  * omap2_get_clksel_by_parent - return clksel struct for a given clk & parent
 346  * @clk: OMAP struct clk ptr to inspect
 347  * @src_clk: OMAP struct clk ptr of the parent clk to search for
 348  *
 349  * Scan the struct clksel array associated with the clock to find
 350  * the element associated with the supplied parent clock address.
 351  * Returns a pointer to the struct clksel on success or NULL on error.
 352  */
 353 const struct clksel *omap2_get_clksel_by_parent(struct clk *clk,
 354                                                 struct clk *src_clk)
 355 {
 356         const struct clksel *clks;
 357
 358         if (!clk->clksel)
 359                 return NULL;
 360
 361         for (clks = clk->clksel; clks->parent; clks++) {
 362                 if (clks->parent == src_clk)
 363                         break; /* Found the requested parent */
 364         }
 365
 366         if (!clks->parent) {
 367                 printk(KERN_ERR "clock: Could not find parent clock %s in "
 368                        "clksel array of clock %s\n", src_clk->name,
 369                        clk->name);
 370                 return NULL;
 371         }
 372
 373         return clks;
 374 }
 375
 376 /**
 377  * omap2_clksel_round_rate_div - find divisor for the given clock and rate
 378  * @clk: OMAP struct clk to use
 379  * @target_rate: desired clock rate
 380  * @new_div: ptr to where we should store the divisor
 381  *
 382  * Finds 'best' divider value in an array based on the source and target
 383  * rates.  The divider array must be sorted with smallest divider first.
 384  * Note that this will not work for clocks which are part of CONFIG_PARTICIPANT,
 385  * they are only settable as part of virtual_prcm set.
 386  *
 387  * Returns the rounded clock rate or returns 0xffffffff on error.
 388  */
 389 u32 omap2_clksel_round_rate_div(struct clk *clk, unsigned long target_rate,
 390                                 u32 *new_div)
 391 {
 392         unsigned long test_rate;
 393         const struct clksel *clks;
 394         const struct clksel_rate *clkr;
 395         u32 last_div = 0;
 396
 397         printk(KERN_INFO "clock: clksel_round_rate_div: %s target_rate %ld\n",
 398                clk->name, target_rate);
 399
 400         *new_div = 1;
 401
 402         clks = omap2_get_clksel_by_parent(clk, clk->parent);
 403         if (clks == NULL)
 404                 return ~0;
 405
 406         for (clkr = clks->rates; clkr->div; clkr++) {
 407                 if (!(clkr->flags & cpu_mask))
 408                     continue;
 409
 410                 /* Sanity check */
 411                 if (clkr->div <= last_div)
 412                         printk(KERN_ERR "clock: clksel_rate table not sorted "
 413                                "for clock %s", clk->name);
 414
 415                 last_div = clkr->div;
 416
 417                 test_rate = clk->parent->rate / clkr->div;
 418
 419                 if (test_rate <= target_rate)
 420                         break; /* found it */
 421         }
 422
 423         if (!clkr->div) {
 424                 printk(KERN_ERR "clock: Could not find divisor for target "
 425                        "rate %ld for clock %s parent %s\n", target_rate,
 426                        clk->name, clk->parent->name);
 427                 return ~0;
 428         }
 429
 430         *new_div = clkr->div;
 431
 432         printk(KERN_INFO "clock: new_div = %d, new_rate = %ld\n", *new_div,
 433                (clk->parent->rate / clkr->div));
 434
 435         return (clk->parent->rate / clkr->div);
 436 }
 437
 438 /**
 439  * omap2_clksel_round_rate - find rounded rate for the given clock and rate
 440  * @clk: OMAP struct clk to use
 441  * @target_rate: desired clock rate
 442  *
 443  * Compatibility wrapper for OMAP clock framework
 444  * Finds best target rate based on the source clock and possible dividers.
 445  * rates. The divider array must be sorted with smallest divider first.
 446  * Note that this will not work for clocks which are part of CONFIG_PARTICIPANT,
 447  * they are only settable as part of virtual_prcm set.
 448  *
 449  * Returns the rounded clock rate or returns 0xffffffff on error.
 450  */
 451 long omap2_clksel_round_rate(struct clk *clk, unsigned long target_rate)
 452 {
 453         u32 new_div;
 454
 455         return omap2_clksel_round_rate_div(clk, target_rate, &new_div);
 456 }
 457
 458
 459 /* Given a clock and a rate apply a clock specific rounding function */
 460 long omap2_clk_round_rate(struct clk *clk, unsigned long rate)
 461 {
 462         if (clk->round_rate != 0)
 463                 return clk->round_rate(clk, rate);
 464
 465         if (clk->flags & RATE_FIXED)
 466                 printk(KERN_ERR "clock: generic omap2_clk_round_rate called "
 467                        "on fixed-rate clock %s\n", clk->name);
 468
 469         return clk->rate;
 470 }
 471
 472 /**
 473  * omap2_clksel_to_divisor() - turn clksel field value into integer divider
 474  * @clk: OMAP struct clk to use
 475  * @field_val: register field value to find
 476  *
 477  * Given a struct clk of a rate-selectable clksel clock, and a register field
 478  * value to search for, find the corresponding clock divisor.  The register
 479  * field value should be pre-masked and shifted down so the LSB is at bit 0
 480  * before calling.  Returns 0 on error
 481  */
 482 u32 omap2_clksel_to_divisor(struct clk *clk, u32 field_val)
 483 {
 484         const struct clksel *clks;
 485         const struct clksel_rate *clkr;
 486
 487         clks = omap2_get_clksel_by_parent(clk, clk->parent);
 488         if (clks == NULL)
 489                 return 0;
 490
 491         for (clkr = clks->rates; clkr->div; clkr++) {
 492                 if ((clkr->flags & cpu_mask) && (clkr->val == field_val))
 493                         break;
 494         }
 495
 496         if (!clkr->div) {
 497                 printk(KERN_ERR "clock: Could not find fieldval %d for "
 498                        "clock %s parent %s\n", field_val, clk->name,
 499                        clk->parent->name);
 500                 return 0;
 501         }
 502
 503         return clkr->div;
 504 }
 505
 506 /**
 507  * omap2_divisor_to_clksel() - turn clksel integer divisor into a field value
 508  * @clk: OMAP struct clk to use
 509  * @div: integer divisor to search for
 510  *
 511  * Given a struct clk of a rate-selectable clksel clock, and a clock divisor,
 512  * find the corresponding register field value.  The return register value is
 513  * the value before left-shifting.  Returns 0xffffffff on error
 514  */
 515 u32 omap2_divisor_to_clksel(struct clk *clk, u32 div)
 516 {
 517         const struct clksel *clks;
 518         const struct clksel_rate *clkr;
 519
 520         /* should never happen */
 521         WARN_ON(div == 0);
 522
 523         clks = omap2_get_clksel_by_parent(clk, clk->parent);
 524         if (clks == NULL)
 525                 return 0;
 526
 527         for (clkr = clks->rates; clkr->div; clkr++) {
 528                 if ((clkr->flags & cpu_mask) && (clkr->div == div))
 529                         break;
 530         }
 531
 532         if (!clkr->div) {
 533                 printk(KERN_ERR "clock: Could not find divisor %d for "
 534                        "clock %s parent %s\n", div, clk->name,
 535                        clk->parent->name);
 536                 return 0;
 537         }
 538
 539         return clkr->val;
 540 }
 541
 542 /**
 543  * omap2_get_clksel - find clksel register addr & field mask for a clk
 544  * @clk: struct clk to use
 545  * @field_mask: ptr to u32 to store the register field mask
 546  *
 547  * Returns the address of the clksel register upon success or NULL on error.
 548  */
 549 void __iomem *omap2_get_clksel(struct clk *clk, u32 *field_mask)
 550 {
 551         if (unlikely((clk->clksel_reg == 0) || (clk->clksel_mask == 0)))
 552                 return NULL;
 553
 554         *field_mask = clk->clksel_mask;
 555
 556         return clk->clksel_reg;
 557 }
 558
 559 /**
 560  * omap2_clksel_get_divisor - get current divider applied to parent clock.
 561  * @clk: OMAP struct clk to use.
 562  *
 563  * Returns the integer divisor upon success or 0 on error.
 564  */
 565 u32 omap2_clksel_get_divisor(struct clk *clk)
 566 {
 567         u32 field_mask, field_val;
 568         void __iomem *div_addr;
 569
 570         div_addr = omap2_get_clksel(clk, &field_mask);
 571         if (div_addr == 0)
 572                 return 0;
 573
 574         field_val = __raw_readl(div_addr) & field_mask;
 575         field_val >>= __ffs(field_mask);
 576
 577         return omap2_clksel_to_divisor(clk, field_val);
 578 }
 579
 580 int omap2_clksel_set_rate(struct clk *clk, unsigned long rate)
 581 {
 582         u32 field_mask, field_val, reg_val, validrate, new_div = 0;
 583         void __iomem *div_addr;
 584
 585         validrate = omap2_clksel_round_rate_div(clk, rate, &new_div);
 586         if (validrate != rate)
 587                 return -EINVAL;
 588
 589         div_addr = omap2_get_clksel(clk, &field_mask);
 590         if (div_addr == 0)
 591                 return -EINVAL;
 592
 593         field_val = omap2_divisor_to_clksel(clk, new_div);
 594         if (field_val == ~0)
 595                 return -EINVAL;
 596
 597         reg_val = __raw_readl(div_addr);
 598         reg_val &= ~field_mask;
 599         reg_val |= (field_val << __ffs(field_mask));
 600         __raw_writel(reg_val, div_addr);
 601         wmb();
 602
 603         clk->rate = clk->parent->rate / new_div;
 604
 605         if (clk->flags & DELAYED_APP && cpu_is_omap24xx()) {
 606                 __raw_writel(OMAP24XX_VALID_CONFIG, OMAP24XX_PRCM_CLKCFG_CTRL);
 607                 wmb();
 608         }
 609
 610         return 0;
 611 }
 612
 613
 614 /* Set the clock rate for a clock source */
 615 int omap2_clk_set_rate(struct clk *clk, unsigned long rate)
 616 {
 617         int ret = -EINVAL;
 618
 619         pr_debug("clock: set_rate for clock %s to rate %ld\n", clk->name, rate);
 620
 621         /* CONFIG_PARTICIPANT clocks are changed only in sets via the
 622            rate table mechanism, driven by mpu_speed  */
 623         if (clk->flags & CONFIG_PARTICIPANT)
 624                 return -EINVAL;
 625
 626         /* dpll_ck, core_ck, virt_prcm_set; plus all clksel clocks */
 627         if (clk->set_rate != 0)
 628                 ret = clk->set_rate(clk, rate);
 629
 630         if (unlikely(ret == 0 && (clk->flags & RATE_PROPAGATES)))
 631                 propagate_rate(clk);
 632
 633         return ret;
 634 }
 635
 636 /*
 637  * Converts encoded control register address into a full address
 638  * On error, *src_addr will be returned as 0.
 639  */
 640 static u32 omap2_clksel_get_src_field(void __iomem **src_addr,
 641                                       struct clk *src_clk, u32 *field_mask,
 642                                       struct clk *clk, u32 *parent_div)
 643 {
 644         const struct clksel *clks;
 645         const struct clksel_rate *clkr;
 646
 647         *parent_div = 0;
 648         *src_addr = 0;
 649
 650         clks = omap2_get_clksel_by_parent(clk, src_clk);
 651         if (clks == NULL)
 652                 return 0;
 653
 654         for (clkr = clks->rates; clkr->div; clkr++) {
 655                 if (clkr->flags & (cpu_mask | DEFAULT_RATE))
 656                         break; /* Found the default rate for this platform */
 657         }
 658
 659         if (!clkr->div) {
 660                 printk(KERN_ERR "clock: Could not find default rate for "
 661                        "clock %s parent %s\n", clk->name,
 662                        src_clk->parent->name);
 663                 return 0;
 664         }
 665
 666         /* Should never happen.  Add a clksel mask to the struct clk. */
 667         WARN_ON(clk->clksel_mask == 0);
 668
 669         *field_mask = clk->clksel_mask;
 670         *src_addr = clk->clksel_reg;
 671         *parent_div = clkr->div;
 672
 673         return clkr->val;
 674 }
 675
 676 int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
 677 {
 678         void __iomem *src_addr;
 679         u32 field_val, field_mask, reg_val, parent_div;
 680
 681         if (unlikely(clk->flags & CONFIG_PARTICIPANT))
 682                 return -EINVAL;
 683
 684         if (!clk->clksel)
 685                 return -EINVAL;
 686
 687         field_val = omap2_clksel_get_src_field(&src_addr, new_parent,
 688                                                &field_mask, clk, &parent_div);
 689         if (src_addr == 0)
 690                 return -EINVAL;
 691
 692         if (clk->usecount > 0)
 693                 _omap2_clk_disable(clk);
 694
 695         /* Set new source value (previous dividers if any in effect) */
 696         reg_val = __raw_readl(src_addr) & ~field_mask;
 697         reg_val |= (field_val << __ffs(field_mask));
 698         __raw_writel(reg_val, src_addr);
 699         wmb();
 700
 701         if (clk->flags & DELAYED_APP && cpu_is_omap24xx()) {
 702                 __raw_writel(OMAP24XX_VALID_CONFIG, OMAP24XX_PRCM_CLKCFG_CTRL);
 703                 wmb();
 704         }
 705
 706         if (clk->usecount > 0)
 707                 _omap2_clk_enable(clk);
 708
 709         clk->parent = new_parent;
 710
 711         /* CLKSEL clocks follow their parents' rates, divided by a divisor */
 712         clk->rate = new_parent->rate;
 713
 714         if (parent_div > 0)
 715                 clk->rate /= parent_div;
 716
 717         pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
 718                  clk->name, clk->parent->name, clk->rate);
 719
 720         if (unlikely(clk->flags & RATE_PROPAGATES))
 721                 propagate_rate(clk);
 722
 723         return 0;
 724 }
 725
 726 /*-------------------------------------------------------------------------
 727  * Omap2 clock reset and init functions
 728  *-------------------------------------------------------------------------*/
 729
 730 #ifdef CONFIG_OMAP_RESET_CLOCKS
 731 void omap2_clk_disable_unused(struct clk *clk)
 732 {
 733         u32 regval32, v;
 734
 735         v = (clk->flags & INVERT_ENABLE) ? (1 << clk->enable_bit) : 0;
 736
 737         regval32 = __raw_readl(clk->enable_reg);
 738         if ((regval32 & (1 << clk->enable_bit)) == v)
 739                 return;
 740
 741         printk(KERN_INFO "Disabling unused clock \"%s\"\n", clk->name);
 742         _omap2_clk_disable(clk);
 743 }
 744 #endif