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
  29 #include <mach/clock.h>
  30 #include <mach/sram.h>
  31 #include <asm/div64.h>
  32 #include <asm/bitops.h>
  33
  34 #include <mach/sdrc.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 = cm_read_mod_reg(clk->prcm_mod, dd->control_reg);
  70         v &= ~dd->enable_mask;
  71         v |= clken_bits << __ffs(dd->enable_mask);
  72         cm_write_mod_reg(v, clk->prcm_mod, 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
  82         dd = clk->dpll_data;
  83
  84         state <<= __ffs(dd->idlest_mask);
  85
  86         while (((cm_read_mod_reg(clk->prcm_mod, dd->idlest_reg)
  87                  & dd->idlest_mask) != state) &&
  88                i < MAX_DPLL_WAIT_TRIES) {
  89                 i++;
  90                 udelay(1);
  91         }
  92
  93         if (i == MAX_DPLL_WAIT_TRIES) {
  94                 printk(KERN_ERR "clock: %s failed transition to '%s'\n",
  95                        clk->name, (state) ? "locked" : "bypassed");
  96         } else {
  97                 pr_debug("clock: %s transition to '%s' in %d loops\n",
  98                          clk->name, (state) ? "locked" : "bypassed", i);
  99
 100                 ret = 0;
 101         }
 102
 103         return ret;
 104 }
 105
 106 /* From 3430 TRM ES2 4.7.6.2 */
 107 static u16 _omap3_dpll_compute_freqsel(struct clk *clk, u8 n)
 108 {
 109         unsigned long fint;
 110         u16 f = 0;
 111
 112         fint = clk->parent->rate / (n + 1);
 113
 114         pr_debug("clock: fint is %lu\n", fint);
 115
 116         if (fint >= 750000 && fint <= 1000000)
 117                 f = 0x3;
 118         else if (fint > 1000000 && fint <= 1250000)
 119                 f = 0x4;
 120         else if (fint > 1250000 && fint <= 1500000)
 121                 f = 0x5;
 122         else if (fint > 1500000 && fint <= 1750000)
 123                 f = 0x6;
 124         else if (fint > 1750000 && fint <= 2100000)
 125                 f = 0x7;
 126         else if (fint > 7500000 && fint <= 10000000)
 127                 f = 0xB;
 128         else if (fint > 10000000 && fint <= 12500000)
 129                 f = 0xC;
 130         else if (fint > 12500000 && fint <= 15000000)
 131                 f = 0xD;
 132         else if (fint > 15000000 && fint <= 17500000)
 133                 f = 0xE;
 134         else if (fint > 17500000 && fint <= 21000000)
 135                 f = 0xF;
 136         else
 137                 pr_debug("clock: unknown freqsel setting for %d\n", n);
 138
 139         return f;
 140 }
 141
 142 /* Non-CORE DPLL (e.g., DPLLs that do not control SDRC) clock functions */
 143
 144 /*
 145  * _omap3_noncore_dpll_lock - instruct a DPLL to lock and wait for readiness
 146  * @clk: pointer to a DPLL struct clk
 147  *
 148  * Instructs a non-CORE DPLL to lock.  Waits for the DPLL to report
 149  * readiness before returning.  Will save and restore the DPLL's
 150  * autoidle state across the enable, per the CDP code.  If the DPLL
 151  * locked successfully, return 0; if the DPLL did not lock in the time
 152  * allotted, or DPLL3 was passed in, return -EINVAL.
 153  */
 154 static int _omap3_noncore_dpll_lock(struct clk *clk)
 155 {
 156         u8 ai;
 157         int r;
 158
 159         if (clk == &dpll3_ck)
 160                 return -EINVAL;
 161
 162         pr_debug("clock: locking DPLL %s\n", clk->name);
 163
 164         ai = omap3_dpll_autoidle_read(clk);
 165
 166         _omap3_dpll_write_clken(clk, DPLL_LOCKED);
 167
 168         if (ai) {
 169                 /*
 170                  * If no downstream clocks are enabled, CM_IDLEST bit
 171                  * may never become active, so don't wait for DPLL to lock.
 172                  */
 173                 r = 0;
 174                 omap3_dpll_allow_idle(clk);
 175         } else {
 176                 r = _omap3_wait_dpll_status(clk, 1);
 177                 omap3_dpll_deny_idle(clk);
 178         };
 179
 180         return r;
 181 }
 182
 183 /*
 184  * _omap3_noncore_dpll_bypass - instruct a DPLL to bypass and wait for readiness
 185  * @clk: pointer to a DPLL struct clk
 186  *
 187  * Instructs a non-CORE DPLL to enter low-power bypass mode.  In
 188  * bypass mode, the DPLL's rate is set equal to its parent clock's
 189  * rate.  Waits for the DPLL to report readiness before returning.
 190  * Will save and restore the DPLL's autoidle state across the enable,
 191  * per the CDP code.  If the DPLL entered bypass mode successfully,
 192  * return 0; if the DPLL did not enter bypass in the time allotted, or
 193  * DPLL3 was passed in, or the DPLL does not support low-power bypass,
 194  * return -EINVAL.
 195  */
 196 static int _omap3_noncore_dpll_bypass(struct clk *clk)
 197 {
 198         int r;
 199         u8 ai;
 200
 201         if (clk == &dpll3_ck)
 202                 return -EINVAL;
 203
 204         if (!(clk->dpll_data->modes & (1 << DPLL_LOW_POWER_BYPASS)))
 205                 return -EINVAL;
 206
 207         pr_debug("clock: configuring DPLL %s for low-power bypass\n",
 208                  clk->name);
 209
 210         ai = omap3_dpll_autoidle_read(clk);
 211
 212         _omap3_dpll_write_clken(clk, DPLL_LOW_POWER_BYPASS);
 213
 214         r = _omap3_wait_dpll_status(clk, 0);
 215
 216         if (ai)
 217                 omap3_dpll_allow_idle(clk);
 218         else
 219                 omap3_dpll_deny_idle(clk);
 220
 221         return r;
 222 }
 223
 224 /*
 225  * _omap3_noncore_dpll_stop - instruct a DPLL to stop
 226  * @clk: pointer to a DPLL struct clk
 227  *
 228  * Instructs a non-CORE DPLL to enter low-power stop. Will save and
 229  * restore the DPLL's autoidle state across the stop, per the CDP
 230  * code.  If DPLL3 was passed in, or the DPLL does not support
 231  * low-power stop, return -EINVAL; otherwise, return 0.
 232  */
 233 static int _omap3_noncore_dpll_stop(struct clk *clk)
 234 {
 235         u8 ai;
 236
 237         if (clk == &dpll3_ck)
 238                 return -EINVAL;
 239
 240         if (!(clk->dpll_data->modes & (1 << DPLL_LOW_POWER_STOP)))
 241                 return -EINVAL;
 242
 243         pr_debug("clock: stopping DPLL %s\n", clk->name);
 244
 245         ai = omap3_dpll_autoidle_read(clk);
 246
 247         _omap3_dpll_write_clken(clk, DPLL_LOW_POWER_STOP);
 248
 249         if (ai)
 250                 omap3_dpll_allow_idle(clk);
 251         else
 252                 omap3_dpll_deny_idle(clk);
 253
 254         return 0;
 255 }
 256
 257 /**
 258  * omap3_noncore_dpll_enable - instruct a DPLL to enter bypass or lock mode
 259  * @clk: pointer to a DPLL struct clk
 260  *
 261  * Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
 262  * The choice of modes depends on the DPLL's programmed rate: if it is
 263  * the same as the DPLL's parent clock, it will enter bypass;
 264  * otherwise, it will enter lock.  This code will wait for the DPLL to
 265  * indicate readiness before returning, unless the DPLL takes too long
 266  * to enter the target state.  Intended to be used as the struct clk's
 267  * enable function.  If DPLL3 was passed in, or the DPLL does not
 268  * support low-power stop, or if the DPLL took too long to enter
 269  * bypass or lock, return -EINVAL; otherwise, return 0.
 270  */
 271 static int omap3_noncore_dpll_enable(struct clk *clk)
 272 {
 273         int r;
 274         long rate;
 275         struct dpll_data *dd;
 276
 277         if (clk == &dpll3_ck)
 278                 return -EINVAL;
 279
 280         dd = clk->dpll_data;
 281         if (!dd)
 282                 return -EINVAL;
 283
 284         if (clk->rate == dd->bypass_clk->rate)
 285                 r = _omap3_noncore_dpll_bypass(clk);
 286         else
 287                 r = _omap3_noncore_dpll_lock(clk);
 288
 289         if (!r)
 290                 clk->rate = rate;
 291
 292         return r;
 293 }
 294
 295 /**
 296  * omap3_noncore_dpll_enable - instruct a DPLL to enter bypass or lock mode
 297  * @clk: pointer to a DPLL struct clk
 298  *
 299  * Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
 300  * The choice of modes depends on the DPLL's programmed rate: if it is
 301  * the same as the DPLL's parent clock, it will enter bypass;
 302  * otherwise, it will enter lock.  This code will wait for the DPLL to
 303  * indicate readiness before returning, unless the DPLL takes too long
 304  * to enter the target state.  Intended to be used as the struct clk's
 305  * enable function.  If DPLL3 was passed in, or the DPLL does not
 306  * support low-power stop, or if the DPLL took too long to enter
 307  * bypass or lock, return -EINVAL; otherwise, return 0.
 308  */
 309 static void omap3_noncore_dpll_disable(struct clk *clk)
 310 {
 311         if (clk == &dpll3_ck)
 312                 return;
 313
 314         _omap3_noncore_dpll_stop(clk);
 315 }
 316
 317
 318 /* Non-CORE DPLL rate set code */
 319
 320 /*
 321  * omap3_noncore_dpll_program - set non-core DPLL M,N values directly
 322  * @clk: struct clk * of DPLL to set
 323  * @m: DPLL multiplier to set
 324  * @n: DPLL divider to set
 325  * @freqsel: FREQSEL value to set
 326  *
 327  * Program the DPLL with the supplied M, N values, and wait for the DPLL to
 328  * lock..  Returns -EINVAL upon error, or 0 upon success.
 329  */
 330 static int omap3_noncore_dpll_program(struct clk *clk, u16 m, u8 n, u16 freqsel)
 331 {
 332         struct dpll_data *dd;
 333         u32 v;
 334
 335         if (!clk)
 336                 return -EINVAL;
 337
 338         dd = clk->dpll_data;
 339         if (!dd)
 340                 return -EINVAL;
 341
 342         /*
 343          * According to the 12-5 CDP code from TI, "Limitation 2.5"
 344          * on 3430ES1 prevents us from changing DPLL multipliers or dividers
 345          * on DPLL4.
 346          */
 347         if (system_rev == OMAP3430_REV_ES1_0 &&
 348             !strcmp("dpll4_ck", clk->name)) {
 349                 printk(KERN_ERR "clock: DPLL4 cannot change rate due to "
 350                        "silicon 'Limitation 2.5' on 3430ES1.\n");
 351                 return -EINVAL;
 352         }
 353
 354         /* 3430 ES2 TRM: 4.7.6.9 DPLL Programming Sequence */
 355         _omap3_noncore_dpll_bypass(clk);
 356
 357         /* Set jitter correction */
 358         v = cm_read_mod_reg(clk->prcm_mod, dd->control_reg);
 359         v &= ~dd->freqsel_mask;
 360         v |= freqsel << __ffs(dd->freqsel_mask);
 361         cm_write_mod_reg(v, clk->prcm_mod, dd->control_reg);
 362
 363         /* Set DPLL multiplier, divider */
 364         v = cm_read_mod_reg(clk->prcm_mod, dd->mult_div1_reg);
 365         v &= ~(dd->mult_mask | dd->div1_mask);
 366         v |= m << __ffs(dd->mult_mask);
 367         v |= (n - 1) << __ffs(dd->div1_mask);
 368         cm_write_mod_reg(v, clk->prcm_mod, dd->mult_div1_reg);
 369
 370         /* We let the clock framework set the other output dividers later */
 371
 372         /* REVISIT: Set ramp-up delay? */
 373
 374         _omap3_noncore_dpll_lock(clk);
 375
 376         return 0;
 377 }
 378
 379 /**
 380  * omap3_noncore_dpll_set_rate - set non-core DPLL rate
 381  * @clk: struct clk * of DPLL to set
 382  * @rate: rounded target rate
 383  *
 384  * Set the DPLL CLKOUT to the target rate.  If the DPLL can enter
 385  * low-power bypass, and the target rate is the bypass source clock
 386  * rate, then configure the DPLL for bypass.  Otherwise, round the
 387  * target rate if it hasn't been done already, then program and lock
 388  * the DPLL.  Returns -EINVAL upon error, or 0 upon success.
 389  */
 390 static int omap3_noncore_dpll_set_rate(struct clk *clk, unsigned long rate)
 391 {
 392         u16 freqsel;
 393         struct dpll_data *dd;
 394         int ret;
 395
 396         if (!clk || !rate)
 397                 return -EINVAL;
 398
 399         dd = clk->dpll_data;
 400         if (!dd)
 401                 return -EINVAL;
 402
 403         if (rate == omap2_get_dpll_rate(clk))
 404                 return 0;
 405
 406         if (dd->bypass_clk->rate == rate &&
 407             (clk->dpll_data->modes & (1 << DPLL_LOW_POWER_BYPASS))) {
 408
 409                 pr_debug("clock: %s: set rate: entering bypass.\n", clk->name);
 410
 411                 ret = _omap3_noncore_dpll_bypass(clk);
 412                 if (!ret)
 413                         clk->rate = rate;
 414
 415         } else {
 416
 417                 if (dd->last_rounded_rate != rate)
 418                         omap2_dpll_round_rate(clk, rate);
 419
 420                 if (dd->last_rounded_rate == 0)
 421                         return -EINVAL;
 422
 423                 freqsel = _omap3_dpll_compute_freqsel(clk, dd->last_rounded_n);
 424                 if (!freqsel)
 425                         WARN_ON(1);
 426
 427                 pr_debug("clock: %s: set rate: locking rate to %lu.\n",
 428                          clk->name, rate);
 429
 430                 ret = omap3_noncore_dpll_program(clk, dd->last_rounded_m,
 431                                                  dd->last_rounded_n, freqsel);
 432
 433         }
 434
 435         omap3_dpll_recalc(clk);
 436
 437         return 0;
 438 }
 439
 440
 441 /*
 442  * CORE DPLL (DPLL3) rate programming functions
 443  *
 444  * These call into SRAM code to do the actual CM writes, since the SDRAM
 445  * is clocked from DPLL3.
 446  */
 447
 448 /**
 449  * omap3_core_dpll_m2_set_rate - set CORE DPLL M2 divider
 450  * @clk: struct clk * of DPLL to set
 451  * @rate: rounded target rate
 452  *
 453  * Program the DPLL M2 divider with the rounded target rate.  Returns
 454  * -EINVAL upon error, or 0 upon success.
 455  */
 456 static int omap3_core_dpll_m2_set_rate(struct clk *clk, unsigned long rate)
 457 {
 458         u32 new_div = 0;
 459         unsigned long validrate, sdrcrate;
 460         struct omap_sdrc_params *sp;
 461
 462         if (!clk || !rate)
 463                 return -EINVAL;
 464
 465         if (clk != &dpll3_m2_ck)
 466                 return -EINVAL;
 467
 468         if (rate == clk->rate)
 469                 return 0;
 470
 471         validrate = omap2_clksel_round_rate_div(clk, rate, &new_div);
 472         if (validrate != rate)
 473                 return -EINVAL;
 474
 475         sdrcrate = sdrc_ick.rate;
 476         if (rate > clk->rate)
 477                 sdrcrate <<= ((rate / clk->rate) - 1);
 478         else
 479                 sdrcrate >>= ((clk->rate / rate) - 1);
 480
 481         sp = omap2_sdrc_get_params(sdrcrate);
 482         if (!sp)
 483                 return -EINVAL;
 484
 485         pr_info("clock: changing CORE DPLL rate from %lu to %lu\n", clk->rate,
 486                 validrate);
 487         pr_info("clock: SDRC timing params used: %08x %08x %08x\n",
 488                 sp->rfr_ctrl, sp->actim_ctrla, sp->actim_ctrlb);
 489
 490         /* REVISIT: SRAM code doesn't support other M2 divisors yet */
 491         WARN_ON(new_div != 1 && new_div != 2);
 492
 493         /* REVISIT: Add SDRC_MR changing to this code also */
 494         local_irq_disable();
 495         omap3_configure_core_dpll(sp->rfr_ctrl, sp->actim_ctrla,
 496                                   sp->actim_ctrlb, new_div);
 497         local_irq_enable();
 498
 499         omap2_clksel_recalc(clk);
 500
 501         return 0;
 502 }
 503
 504
 505 /* DPLL autoidle read/set code */
 506
 507
 508 /**
 509  * omap3_dpll_autoidle_read - read a DPLL's autoidle bits
 510  * @clk: struct clk * of the DPLL to read
 511  *
 512  * Return the DPLL's autoidle bits, shifted down to bit 0.  Returns
 513  * -EINVAL if passed a null pointer or if the struct clk does not
 514  * appear to refer to a DPLL.
 515  */
 516 static u32 omap3_dpll_autoidle_read(struct clk *clk)
 517 {
 518         const struct dpll_data *dd;
 519         u32 v;
 520
 521         if (!clk || !clk->dpll_data)
 522                 return -EINVAL;
 523
 524         dd = clk->dpll_data;
 525
 526         v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
 527         v &= dd->autoidle_mask;
 528         v >>= __ffs(dd->autoidle_mask);
 529
 530         return v;
 531 }
 532
 533 /**
 534  * omap3_dpll_allow_idle - enable DPLL autoidle bits
 535  * @clk: struct clk * of the DPLL to operate on
 536  *
 537  * Enable DPLL automatic idle control.  This automatic idle mode
 538  * switching takes effect only when the DPLL is locked, at least on
 539  * OMAP3430.  The DPLL will enter low-power stop when its downstream
 540  * clocks are gated.  No return value.
 541  */
 542 static void omap3_dpll_allow_idle(struct clk *clk)
 543 {
 544         const struct dpll_data *dd;
 545         u32 v;
 546
 547         if (!clk || !clk->dpll_data)
 548                 return;
 549
 550         dd = clk->dpll_data;
 551
 552         /*
 553          * REVISIT: CORE DPLL can optionally enter low-power bypass
 554          * by writing 0x5 instead of 0x1.  Add some mechanism to
 555          * optionally enter this mode.
 556          */
 557         v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
 558         v &= ~dd->autoidle_mask;
 559         v |= DPLL_AUTOIDLE_LOW_POWER_STOP << __ffs(dd->autoidle_mask);
 560         cm_write_mod_reg(v, clk->prcm_mod, dd->autoidle_reg);
 561 }
 562
 563 /**
 564  * omap3_dpll_deny_idle - prevent DPLL from automatically idling
 565  * @clk: struct clk * of the DPLL to operate on
 566  *
 567  * Disable DPLL automatic idle control.  No return value.
 568  */
 569 static void omap3_dpll_deny_idle(struct clk *clk)
 570 {
 571         const struct dpll_data *dd;
 572         u32 v;
 573
 574         if (!clk || !clk->dpll_data)
 575                 return;
 576
 577         dd = clk->dpll_data;
 578
 579         v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
 580         v &= ~dd->autoidle_mask;
 581         v |= DPLL_AUTOIDLE_DISABLE << __ffs(dd->autoidle_mask);
 582         cm_write_mod_reg(v, clk->prcm_mod, dd->autoidle_reg);
 583 }
 584
 585 /* Clock control for DPLL outputs */
 586
 587 /**
 588  * omap3_clkoutx2_recalc - recalculate DPLL X2 output virtual clock rate
 589  * @clk: DPLL output struct clk
 590  *
 591  * Using parent clock DPLL data, look up DPLL state.  If locked, set our
 592  * rate to the dpll_clk * 2; otherwise, just use dpll_clk.
 593  */
 594 static void omap3_clkoutx2_recalc(struct clk *clk)
 595 {
 596         const struct dpll_data *dd;
 597         u32 v;
 598         struct clk *pclk;
 599
 600         /* Walk up the parents of clk, looking for a DPLL */
 601         pclk = clk->parent;
 602         while (pclk && !pclk->dpll_data)
 603                 pclk = pclk->parent;
 604
 605         /* clk does not have a DPLL as a parent? */
 606         WARN_ON(!pclk);
 607
 608         dd = pclk->dpll_data;
 609
 610         WARN_ON(!dd->idlest_reg || !dd->idlest_mask);
 611
 612         v = cm_read_mod_reg(pclk->prcm_mod, dd->idlest_reg) & dd->idlest_mask;
 613         if (!v)
 614                 clk->rate = clk->parent->rate;
 615         else
 616                 clk->rate = clk->parent->rate * 2;
 617
 618         if (clk->flags & RATE_PROPAGATES)
 619                 propagate_rate(clk);
 620 }
 621
 622 /* Common clock code */
 623
 624 /*
 625  * As it is structured now, this will prevent an OMAP2/3 multiboot
 626  * kernel from compiling.  This will need further attention.
 627  */
 628 #if defined(CONFIG_ARCH_OMAP3)
 629
 630 static struct clk_functions omap2_clk_functions = {
 631         .clk_enable             = omap2_clk_enable,
 632         .clk_disable            = omap2_clk_disable,
 633         .clk_round_rate         = omap2_clk_round_rate,
 634         .clk_set_rate           = omap2_clk_set_rate,
 635         .clk_set_parent         = omap2_clk_set_parent,
 636         .clk_disable_unused     = omap2_clk_disable_unused,
 637 };
 638
 639 /*
 640  * Set clocks for bypass mode for reboot to work.
 641  */
 642 void omap2_clk_prepare_for_reboot(void)
 643 {
 644         /* REVISIT: Not ready for 343x */
 645 #if 0
 646         u32 rate;
 647
 648         if (vclk == NULL || sclk == NULL)
 649                 return;
 650
 651         rate = clk_get_rate(sclk);
 652         clk_set_rate(vclk, rate);
 653 #endif
 654 }
 655
 656 /* REVISIT: Move this init stuff out into clock.c */
 657
 658 /*
 659  * Switch the MPU rate if specified on cmdline.
 660  * We cannot do this early until cmdline is parsed.
 661  */
 662 static int __init omap2_clk_arch_init(void)
 663 {
 664         if (!mpurate)
 665                 return -EINVAL;
 666
 667         /* REVISIT: not yet ready for 343x */
 668 #if 0
 669         if (omap2_select_table_rate(&virt_prcm_set, mpurate))
 670                 printk(KERN_ERR "Could not find matching MPU rate\n");
 671 #endif
 672
 673         recalculate_root_clocks();
 674
 675         printk(KERN_INFO "Switched to new clocking rate (Crystal/DPLL3/MPU): "
 676                "%ld.%01ld/%ld/%ld MHz\n",
 677                (osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
 678                (core_ck.rate / 1000000), (dpll1_fck.rate / 1000000)) ;
 679
 680         return 0;
 681 }
 682 arch_initcall(omap2_clk_arch_init);
 683
 684 int __init omap2_clk_init(void)
 685 {
 686         /* struct prcm_config *prcm; */
 687         struct clk **clkp;
 688         /* u32 clkrate; */
 689         u32 cpu_clkflg;
 690
 691         /* REVISIT: Ultimately this will be used for multiboot */
 692 #if 0
 693         if (cpu_is_omap242x()) {
 694                 cpu_mask = RATE_IN_242X;
 695                 cpu_clkflg = CLOCK_IN_OMAP242X;
 696                 clkp = onchip_24xx_clks;
 697         } else if (cpu_is_omap2430()) {
 698                 cpu_mask = RATE_IN_243X;
 699                 cpu_clkflg = CLOCK_IN_OMAP243X;
 700                 clkp = onchip_24xx_clks;
 701         }
 702 #endif
 703         if (cpu_is_omap34xx()) {
 704                 cpu_mask = RATE_IN_343X;
 705                 cpu_clkflg = CLOCK_IN_OMAP343X;
 706                 clkp = onchip_34xx_clks;
 707
 708                 /*
 709                  * Update this if there are further clock changes between ES2
 710                  * and production parts
 711                  */
 712                 if (system_rev == OMAP3430_REV_ES1_0) {
 713                         /* No 3430ES1-only rates exist, so no RATE_IN_3430ES1 */
 714                         cpu_clkflg |= CLOCK_IN_OMAP3430ES1;
 715                 } else {
 716                         cpu_mask |= RATE_IN_3430ES2;
 717                         cpu_clkflg |= CLOCK_IN_OMAP3430ES2;
 718                 }
 719         }
 720
 721         clk_init(&omap2_clk_functions);
 722
 723         for (clkp = onchip_34xx_clks;
 724              clkp < onchip_34xx_clks + ARRAY_SIZE(onchip_34xx_clks);
 725              clkp++) {
 726                 if ((*clkp)->flags & cpu_clkflg) {
 727                         clk_register(*clkp);
 728                         omap2_init_clk_clkdm(*clkp);
 729                 }
 730         }
 731
 732         /* REVISIT: Not yet ready for OMAP3 */
 733 #if 0
 734         /* Check the MPU rate set by bootloader */
 735         clkrate = omap2_get_dpll_rate_24xx(&dpll_ck);
 736         for (prcm = rate_table; prcm->mpu_speed; prcm++) {
 737                 if (!(prcm->flags & cpu_mask))
 738                         continue;
 739                 if (prcm->xtal_speed != sys_ck.rate)
 740                         continue;
 741                 if (prcm->dpll_speed <= clkrate)
 742                          break;
 743         }
 744         curr_prcm_set = prcm;
 745 #endif
 746
 747         recalculate_root_clocks();
 748
 749         printk(KERN_INFO "Clocking rate (Crystal/DPLL/ARM core): "
 750                "%ld.%01ld/%ld/%ld MHz\n",
 751                (osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
 752                (core_ck.rate / 1000000), (arm_fck.rate / 1000000));
 753
 754         /*
 755          * Only enable those clocks we will need, let the drivers
 756          * enable other clocks as necessary
 757          */
 758         clk_enable_init_clocks();
 759
 760         /* Avoid sleeping during omap2_clk_prepare_for_reboot() */
 761         /* REVISIT: not yet ready for 343x */
 762 #if 0
 763         vclk = clk_get(NULL, "virt_prcm_set");
 764         sclk = clk_get(NULL, "sys_ck");
 765 #endif
 766         return 0;
 767 }
 768
 769 #endif