arch/arm/mach-tegra/tegra2_clocks.c

   1 /*
   2  * arch/arm/mach-tegra/tegra2_clocks.c
   3  *
   4  * Copyright (C) 2010 Google, Inc.
   5  *
   6  * Author:
   7  *      Colin Cross <ccross@google.com>
   8  *
   9  * This software is licensed under the terms of the GNU General Public
  10  * License version 2, as published by the Free Software Foundation, and
  11  * may be copied, distributed, and modified under those terms.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/list.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/delay.h>
  25 #include <linux/io.h>
  26 #include <linux/clkdev.h>
  27 #include <linux/clk.h>
  28
  29 #include <mach/iomap.h>
  30 #include <mach/suspend.h>
  31
  32 #include "clock.h"
  33 #include "fuse.h"
  34 #include "tegra2_emc.h"
  35
  36 #define RST_DEVICES                     0x004
  37 #define RST_DEVICES_SET                 0x300
  38 #define RST_DEVICES_CLR                 0x304
  39 #define RST_DEVICES_NUM                 3
  40
  41 #define CLK_OUT_ENB                     0x010
  42 #define CLK_OUT_ENB_SET                 0x320
  43 #define CLK_OUT_ENB_CLR                 0x324
  44 #define CLK_OUT_ENB_NUM                 3
  45
  46 #define CLK_MASK_ARM                    0x44
  47 #define MISC_CLK_ENB                    0x48
  48
  49 #define OSC_CTRL                        0x50
  50 #define OSC_CTRL_OSC_FREQ_MASK          (3<<30)
  51 #define OSC_CTRL_OSC_FREQ_13MHZ         (0<<30)
  52 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (1<<30)
  53 #define OSC_CTRL_OSC_FREQ_12MHZ         (2<<30)
  54 #define OSC_CTRL_OSC_FREQ_26MHZ         (3<<30)
  55 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
  56
  57 #define OSC_FREQ_DET                    0x58
  58 #define OSC_FREQ_DET_TRIG               (1<<31)
  59
  60 #define OSC_FREQ_DET_STATUS             0x5C
  61 #define OSC_FREQ_DET_BUSY               (1<<31)
  62 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
  63
  64 #define PERIPH_CLK_SOURCE_I2S1          0x100
  65 #define PERIPH_CLK_SOURCE_EMC           0x19c
  66 #define PERIPH_CLK_SOURCE_OSC           0x1fc
  67 #define PERIPH_CLK_SOURCE_NUM \
  68         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
  69
  70 #define PERIPH_CLK_SOURCE_MASK          (3<<30)
  71 #define PERIPH_CLK_SOURCE_SHIFT         30
  72 #define PERIPH_CLK_SOURCE_ENABLE        (1<<28)
  73 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
  74 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
  75 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
  76
  77 #define SDMMC_CLK_INT_FB_SEL            (1 << 23)
  78 #define SDMMC_CLK_INT_FB_DLY_SHIFT      16
  79 #define SDMMC_CLK_INT_FB_DLY_MASK       (0xF << SDMMC_CLK_INT_FB_DLY_SHIFT)
  80
  81 #define PLL_BASE                        0x0
  82 #define PLL_BASE_BYPASS                 (1<<31)
  83 #define PLL_BASE_ENABLE                 (1<<30)
  84 #define PLL_BASE_REF_ENABLE             (1<<29)
  85 #define PLL_BASE_OVERRIDE               (1<<28)
  86 #define PLL_BASE_DIVP_MASK              (0x7<<20)
  87 #define PLL_BASE_DIVP_SHIFT             20
  88 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
  89 #define PLL_BASE_DIVN_SHIFT             8
  90 #define PLL_BASE_DIVM_MASK              (0x1F)
  91 #define PLL_BASE_DIVM_SHIFT             0
  92
  93 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
  94 #define PLL_OUT_RATIO_SHIFT             8
  95 #define PLL_OUT_OVERRIDE                (1<<2)
  96 #define PLL_OUT_CLKEN                   (1<<1)
  97 #define PLL_OUT_RESET_DISABLE           (1<<0)
  98
  99 #define PLL_MISC(c)                     (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
 100
 101 #define PLL_MISC_DCCON_SHIFT            20
 102 #define PLL_MISC_CPCON_SHIFT            8
 103 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
 104 #define PLL_MISC_LFCON_SHIFT            4
 105 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
 106 #define PLL_MISC_VCOCON_SHIFT           0
 107 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
 108
 109 #define PLLU_BASE_POST_DIV              (1<<20)
 110
 111 #define PLLD_MISC_CLKENABLE             (1<<30)
 112 #define PLLD_MISC_DIV_RST               (1<<23)
 113 #define PLLD_MISC_DCCON_SHIFT           12
 114
 115 #define PLLE_MISC_READY                 (1 << 15)
 116
 117 #define PERIPH_CLK_TO_ENB_REG(c)        ((c->u.periph.clk_num / 32) * 4)
 118 #define PERIPH_CLK_TO_ENB_SET_REG(c)    ((c->u.periph.clk_num / 32) * 8)
 119 #define PERIPH_CLK_TO_ENB_BIT(c)        (1 << (c->u.periph.clk_num % 32))
 120
 121 #define SUPER_CLK_MUX                   0x00
 122 #define SUPER_STATE_SHIFT               28
 123 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
 124 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
 125 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
 126 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
 127 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
 128 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
 129 #define SUPER_SOURCE_MASK               0xF
 130 #define SUPER_FIQ_SOURCE_SHIFT          12
 131 #define SUPER_IRQ_SOURCE_SHIFT          8
 132 #define SUPER_RUN_SOURCE_SHIFT          4
 133 #define SUPER_IDLE_SOURCE_SHIFT         0
 134
 135 #define SUPER_CLK_DIVIDER               0x04
 136
 137 #define BUS_CLK_DISABLE                 (1<<3)
 138 #define BUS_CLK_DIV_MASK                0x3
 139
 140 #define PMC_CTRL                        0x0
 141  #define PMC_CTRL_BLINK_ENB             (1 << 7)
 142
 143 #define PMC_DPD_PADS_ORIDE              0x1c
 144  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
 145
 146 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
 147 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
 148 #define PMC_BLINK_TIMER_ENB             (1 << 15)
 149 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
 150 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
 151
 152 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
 153 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
 154
 155 /*
 156  * Some clocks share a register with other clocks.  Any clock op that
 157  * non-atomically modifies a register used by another clock must lock
 158  * clock_register_lock first.
 159  */
 160 static DEFINE_SPINLOCK(clock_register_lock);
 161
 162 /*
 163  * Some peripheral clocks share an enable bit, so refcount the enable bits
 164  * in registers CLK_ENABLE_L, CLK_ENABLE_H, and CLK_ENABLE_U
 165  */
 166 static int tegra_periph_clk_enable_refcount[3 * 32];
 167
 168 #define clk_writel(value, reg) \
 169         __raw_writel(value, (u32)reg_clk_base + (reg))
 170 #define clk_readl(reg) \
 171         __raw_readl((u32)reg_clk_base + (reg))
 172 #define pmc_writel(value, reg) \
 173         __raw_writel(value, (u32)reg_pmc_base + (reg))
 174 #define pmc_readl(reg) \
 175         __raw_readl((u32)reg_pmc_base + (reg))
 176
 177 unsigned long clk_measure_input_freq(void)
 178 {
 179         u32 clock_autodetect;
 180         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
 181         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
 182         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
 183         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
 184                 return 12000000;
 185         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
 186                 return 13000000;
 187         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
 188                 return 19200000;
 189         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
 190                 return 26000000;
 191         } else {
 192                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
 193                 BUG();
 194                 return 0;
 195         }
 196 }
 197
 198 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
 199 {
 200         s64 divider_u71 = parent_rate * 2;
 201         divider_u71 += rate - 1;
 202         do_div(divider_u71, rate);
 203
 204         if (divider_u71 - 2 < 0)
 205                 return 0;
 206
 207         if (divider_u71 - 2 > 255)
 208                 return -EINVAL;
 209
 210         return divider_u71 - 2;
 211 }
 212
 213 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
 214 {
 215         s64 divider_u16;
 216
 217         divider_u16 = parent_rate;
 218         divider_u16 += rate - 1;
 219         do_div(divider_u16, rate);
 220
 221         if (divider_u16 - 1 < 0)
 222                 return 0;
 223
 224         if (divider_u16 - 1 > 255)
 225                 return -EINVAL;
 226
 227         return divider_u16 - 1;
 228 }
 229
 230 /* clk_m functions */
 231 static unsigned long tegra2_clk_m_autodetect_rate(struct clk *c)
 232 {
 233         u32 auto_clock_control = clk_readl(OSC_CTRL) & ~OSC_CTRL_OSC_FREQ_MASK;
 234
 235         c->rate = clk_measure_input_freq();
 236         switch (c->rate) {
 237         case 12000000:
 238                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
 239                 break;
 240         case 13000000:
 241                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
 242                 break;
 243         case 19200000:
 244                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
 245                 break;
 246         case 26000000:
 247                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
 248                 break;
 249         default:
 250                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
 251                 BUG();
 252         }
 253         clk_writel(auto_clock_control, OSC_CTRL);
 254         return c->rate;
 255 }
 256
 257 static void tegra2_clk_m_init(struct clk *c)
 258 {
 259         pr_debug("%s on clock %s\n", __func__, c->name);
 260         tegra2_clk_m_autodetect_rate(c);
 261 }
 262
 263 static int tegra2_clk_m_enable(struct clk *c)
 264 {
 265         pr_debug("%s on clock %s\n", __func__, c->name);
 266         return 0;
 267 }
 268
 269 static void tegra2_clk_m_disable(struct clk *c)
 270 {
 271         pr_debug("%s on clock %s\n", __func__, c->name);
 272         BUG();
 273 }
 274
 275 static struct clk_ops tegra_clk_m_ops = {
 276         .init           = tegra2_clk_m_init,
 277         .enable         = tegra2_clk_m_enable,
 278         .disable        = tegra2_clk_m_disable,
 279 };
 280
 281 void tegra2_periph_reset_assert(struct clk *c)
 282 {
 283         BUG_ON(!c->ops->reset);
 284         c->ops->reset(c, true);
 285 }
 286
 287 void tegra2_periph_reset_deassert(struct clk *c)
 288 {
 289         BUG_ON(!c->ops->reset);
 290         c->ops->reset(c, false);
 291 }
 292
 293 /* super clock functions */
 294 /* "super clocks" on tegra have two-stage muxes and a clock skipping
 295  * super divider.  We will ignore the clock skipping divider, since we
 296  * can't lower the voltage when using the clock skip, but we can if we
 297  * lower the PLL frequency.
 298  */
 299 static void tegra2_super_clk_init(struct clk *c)
 300 {
 301         u32 val;
 302         int source;
 303         int shift;
 304         const struct clk_mux_sel *sel;
 305         val = clk_readl(c->reg + SUPER_CLK_MUX);
 306         c->state = ON;
 307         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
 308                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
 309         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
 310                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
 311         source = (val >> shift) & SUPER_SOURCE_MASK;
 312         for (sel = c->inputs; sel->input != NULL; sel++) {
 313                 if (sel->value == source)
 314                         break;
 315         }
 316         BUG_ON(sel->input == NULL);
 317         c->parent = sel->input;
 318 }
 319
 320 static int tegra2_super_clk_enable(struct clk *c)
 321 {
 322         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
 323         return 0;
 324 }
 325
 326 static void tegra2_super_clk_disable(struct clk *c)
 327 {
 328         pr_debug("%s on clock %s\n", __func__, c->name);
 329
 330         /* oops - don't disable the CPU clock! */
 331         BUG();
 332 }
 333
 334 static int tegra2_super_clk_set_parent(struct clk *c, struct clk *p)
 335 {
 336         u32 val;
 337         const struct clk_mux_sel *sel;
 338         int shift;
 339
 340         val = clk_readl(c->reg + SUPER_CLK_MUX);
 341         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
 342                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
 343         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
 344                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
 345         for (sel = c->inputs; sel->input != NULL; sel++) {
 346                 if (sel->input == p) {
 347                         val &= ~(SUPER_SOURCE_MASK << shift);
 348                         val |= sel->value << shift;
 349
 350                         if (c->refcnt)
 351                                 clk_enable(p);
 352
 353                         clk_writel(val, c->reg);
 354
 355                         if (c->refcnt && c->parent)
 356                                 clk_disable(c->parent);
 357
 358                         clk_reparent(c, p);
 359                         return 0;
 360                 }
 361         }
 362         return -EINVAL;
 363 }
 364
 365 /*
 366  * Super clocks have "clock skippers" instead of dividers.  Dividing using
 367  * a clock skipper does not allow the voltage to be scaled down, so instead
 368  * adjust the rate of the parent clock.  This requires that the parent of a
 369  * super clock have no other children, otherwise the rate will change
 370  * underneath the other children.
 371  */
 372 static int tegra2_super_clk_set_rate(struct clk *c, unsigned long rate)
 373 {
 374         return clk_set_rate(c->parent, rate);
 375 }
 376
 377 static struct clk_ops tegra_super_ops = {
 378         .init                   = tegra2_super_clk_init,
 379         .enable                 = tegra2_super_clk_enable,
 380         .disable                = tegra2_super_clk_disable,
 381         .set_parent             = tegra2_super_clk_set_parent,
 382         .set_rate               = tegra2_super_clk_set_rate,
 383 };
 384
 385 /* virtual cpu clock functions */
 386 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
 387    To change the frequency of these clocks, the parent pll may need to be
 388    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
 389    and then the clock moved back to the pll.  To hide this sequence, a virtual
 390    clock handles it.
 391  */
 392 static void tegra2_cpu_clk_init(struct clk *c)
 393 {
 394 }
 395
 396 static int tegra2_cpu_clk_enable(struct clk *c)
 397 {
 398         return 0;
 399 }
 400
 401 static void tegra2_cpu_clk_disable(struct clk *c)
 402 {
 403         pr_debug("%s on clock %s\n", __func__, c->name);
 404
 405         /* oops - don't disable the CPU clock! */
 406         BUG();
 407 }
 408
 409 static int tegra2_cpu_clk_set_rate(struct clk *c, unsigned long rate)
 410 {
 411         int ret;
 412         /*
 413          * Take an extra reference to the main pll so it doesn't turn
 414          * off when we move the cpu off of it
 415          */
 416         clk_enable(c->u.cpu.main);
 417
 418         ret = clk_set_parent(c->parent, c->u.cpu.backup);
 419         if (ret) {
 420                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.backup->name);
 421                 goto out;
 422         }
 423
 424         if (rate == clk_get_rate(c->u.cpu.backup))
 425                 goto out;
 426
 427         ret = clk_set_rate(c->u.cpu.main, rate);
 428         if (ret) {
 429                 pr_err("Failed to change cpu pll to %lu\n", rate);
 430                 goto out;
 431         }
 432
 433         ret = clk_set_parent(c->parent, c->u.cpu.main);
 434         if (ret) {
 435                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
 436                 goto out;
 437         }
 438
 439 out:
 440         clk_disable(c->u.cpu.main);
 441         return ret;
 442 }
 443
 444 static struct clk_ops tegra_cpu_ops = {
 445         .init     = tegra2_cpu_clk_init,
 446         .enable   = tegra2_cpu_clk_enable,
 447         .disable  = tegra2_cpu_clk_disable,
 448         .set_rate = tegra2_cpu_clk_set_rate,
 449 };
 450
 451 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
 452  * reset the COP block (i.e. AVP) */
 453 static void tegra2_cop_clk_reset(struct clk *c, bool assert)
 454 {
 455         unsigned long reg = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
 456
 457         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
 458         clk_writel(1 << 1, reg);
 459 }
 460
 461 static struct clk_ops tegra_cop_ops = {
 462         .reset    = tegra2_cop_clk_reset,
 463 };
 464
 465 /* bus clock functions */
 466 static void tegra2_bus_clk_init(struct clk *c)
 467 {
 468         u32 val = clk_readl(c->reg);
 469         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
 470         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
 471         c->mul = 1;
 472 }
 473
 474 static int tegra2_bus_clk_enable(struct clk *c)
 475 {
 476         u32 val;
 477         unsigned long flags;
 478
 479         spin_lock_irqsave(&clock_register_lock, flags);
 480
 481         val = clk_readl(c->reg);
 482         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
 483         clk_writel(val, c->reg);
 484
 485         spin_unlock_irqrestore(&clock_register_lock, flags);
 486
 487         return 0;
 488 }
 489
 490 static void tegra2_bus_clk_disable(struct clk *c)
 491 {
 492         u32 val;
 493         unsigned long flags;
 494
 495         spin_lock_irqsave(&clock_register_lock, flags);
 496
 497         val = clk_readl(c->reg);
 498         val |= BUS_CLK_DISABLE << c->reg_shift;
 499         clk_writel(val, c->reg);
 500
 501         spin_unlock_irqrestore(&clock_register_lock, flags);
 502 }
 503
 504 static int tegra2_bus_clk_set_rate(struct clk *c, unsigned long rate)
 505 {
 506         u32 val;
 507         unsigned long parent_rate = clk_get_rate(c->parent);
 508         unsigned long flags;
 509         int ret = -EINVAL;
 510         int i;
 511
 512         spin_lock_irqsave(&clock_register_lock, flags);
 513
 514         val = clk_readl(c->reg);
 515         for (i = 1; i <= 4; i++) {
 516                 if (rate == parent_rate / i) {
 517                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
 518                         val |= (i - 1) << c->reg_shift;
 519                         clk_writel(val, c->reg);
 520                         c->div = i;
 521                         c->mul = 1;
 522                         ret = 0;
 523                         break;
 524                 }
 525         }
 526
 527         spin_unlock_irqrestore(&clock_register_lock, flags);
 528
 529         return ret;
 530 }
 531
 532 static struct clk_ops tegra_bus_ops = {
 533         .init                   = tegra2_bus_clk_init,
 534         .enable                 = tegra2_bus_clk_enable,
 535         .disable                = tegra2_bus_clk_disable,
 536         .set_rate               = tegra2_bus_clk_set_rate,
 537 };
 538
 539 /* Blink output functions */
 540
 541 static void tegra2_blink_clk_init(struct clk *c)
 542 {
 543         u32 val;
 544
 545         val = pmc_readl(PMC_CTRL);
 546         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
 547         c->mul = 1;
 548         val = pmc_readl(c->reg);
 549
 550         if (val & PMC_BLINK_TIMER_ENB) {
 551                 unsigned int on_off;
 552
 553                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
 554                         PMC_BLINK_TIMER_DATA_ON_MASK;
 555                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
 556                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
 557                 on_off += val;
 558                 /* each tick in the blink timer is 4 32KHz clocks */
 559                 c->div = on_off * 4;
 560         } else {
 561                 c->div = 1;
 562         }
 563 }
 564
 565 static int tegra2_blink_clk_enable(struct clk *c)
 566 {
 567         u32 val;
 568
 569         val = pmc_readl(PMC_DPD_PADS_ORIDE);
 570         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
 571
 572         val = pmc_readl(PMC_CTRL);
 573         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
 574
 575         return 0;
 576 }
 577
 578 static void tegra2_blink_clk_disable(struct clk *c)
 579 {
 580         u32 val;
 581
 582         val = pmc_readl(PMC_CTRL);
 583         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
 584
 585         val = pmc_readl(PMC_DPD_PADS_ORIDE);
 586         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
 587 }
 588
 589 static int tegra2_blink_clk_set_rate(struct clk *c, unsigned long rate)
 590 {
 591         unsigned long parent_rate = clk_get_rate(c->parent);
 592         if (rate >= parent_rate) {
 593                 c->div = 1;
 594                 pmc_writel(0, c->reg);
 595         } else {
 596                 unsigned int on_off;
 597                 u32 val;
 598
 599                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
 600                 c->div = on_off * 8;
 601
 602                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
 603                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
 604                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
 605                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
 606                 val |= on_off;
 607                 val |= PMC_BLINK_TIMER_ENB;
 608                 pmc_writel(val, c->reg);
 609         }
 610
 611         return 0;
 612 }
 613
 614 static struct clk_ops tegra_blink_clk_ops = {
 615         .init                   = &tegra2_blink_clk_init,
 616         .enable                 = &tegra2_blink_clk_enable,
 617         .disable                = &tegra2_blink_clk_disable,
 618         .set_rate               = &tegra2_blink_clk_set_rate,
 619 };
 620
 621 /* PLL Functions */
 622 static int tegra2_pll_clk_wait_for_lock(struct clk *c)
 623 {
 624         udelay(c->u.pll.lock_delay);
 625
 626         return 0;
 627 }
 628
 629 static void tegra2_pll_clk_init(struct clk *c)
 630 {
 631         u32 val = clk_readl(c->reg + PLL_BASE);
 632
 633         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
 634
 635         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
 636                 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
 637                 c->mul = 1;
 638                 c->div = 1;
 639         } else if (val & PLL_BASE_BYPASS) {
 640                 c->mul = 1;
 641                 c->div = 1;
 642         } else {
 643                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
 644                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
 645                 if (c->flags & PLLU)
 646                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
 647                 else
 648                         c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
 649         }
 650 }
 651
 652 static int tegra2_pll_clk_enable(struct clk *c)
 653 {
 654         u32 val;
 655         pr_debug("%s on clock %s\n", __func__, c->name);
 656
 657         val = clk_readl(c->reg + PLL_BASE);
 658         val &= ~PLL_BASE_BYPASS;
 659         val |= PLL_BASE_ENABLE;
 660         clk_writel(val, c->reg + PLL_BASE);
 661
 662         tegra2_pll_clk_wait_for_lock(c);
 663
 664         return 0;
 665 }
 666
 667 static void tegra2_pll_clk_disable(struct clk *c)
 668 {
 669         u32 val;
 670         pr_debug("%s on clock %s\n", __func__, c->name);
 671
 672         val = clk_readl(c->reg);
 673         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
 674         clk_writel(val, c->reg);
 675 }
 676
 677 static int tegra2_pll_clk_set_rate(struct clk *c, unsigned long rate)
 678 {
 679         u32 val;
 680         unsigned long input_rate;
 681         const struct clk_pll_freq_table *sel;
 682
 683         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
 684
 685         input_rate = clk_get_rate(c->parent);
 686         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
 687                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
 688                         c->mul = sel->n;
 689                         c->div = sel->m * sel->p;
 690
 691                         val = clk_readl(c->reg + PLL_BASE);
 692                         if (c->flags & PLL_FIXED)
 693                                 val |= PLL_BASE_OVERRIDE;
 694                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
 695                                  PLL_BASE_DIVM_MASK);
 696                         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
 697                                 (sel->n << PLL_BASE_DIVN_SHIFT);
 698                         BUG_ON(sel->p < 1 || sel->p > 2);
 699                         if (c->flags & PLLU) {
 700                                 if (sel->p == 1)
 701                                         val |= PLLU_BASE_POST_DIV;
 702                         } else {
 703                                 if (sel->p == 2)
 704                                         val |= 1 << PLL_BASE_DIVP_SHIFT;
 705                         }
 706                         clk_writel(val, c->reg + PLL_BASE);
 707
 708                         if (c->flags & PLL_HAS_CPCON) {
 709                                 val = clk_readl(c->reg + PLL_MISC(c));
 710                                 val &= ~PLL_MISC_CPCON_MASK;
 711                                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
 712                                 clk_writel(val, c->reg + PLL_MISC(c));
 713                         }
 714
 715                         if (c->state == ON)
 716                                 tegra2_pll_clk_enable(c);
 717
 718                         return 0;
 719                 }
 720         }
 721         return -EINVAL;
 722 }
 723
 724 static struct clk_ops tegra_pll_ops = {
 725         .init                   = tegra2_pll_clk_init,
 726         .enable                 = tegra2_pll_clk_enable,
 727         .disable                = tegra2_pll_clk_disable,
 728         .set_rate               = tegra2_pll_clk_set_rate,
 729 };
 730
 731 static void tegra2_pllx_clk_init(struct clk *c)
 732 {
 733         tegra2_pll_clk_init(c);
 734
 735         if (tegra_sku_id() == 7)
 736                 c->max_rate = 750000000;
 737 }
 738
 739 static struct clk_ops tegra_pllx_ops = {
 740         .init     = tegra2_pllx_clk_init,
 741         .enable   = tegra2_pll_clk_enable,
 742         .disable  = tegra2_pll_clk_disable,
 743         .set_rate = tegra2_pll_clk_set_rate,
 744 };
 745
 746 static int tegra2_plle_clk_enable(struct clk *c)
 747 {
 748         u32 val;
 749
 750         pr_debug("%s on clock %s\n", __func__, c->name);
 751
 752         mdelay(1);
 753
 754         val = clk_readl(c->reg + PLL_BASE);
 755         if (!(val & PLLE_MISC_READY))
 756                 return -EBUSY;
 757
 758         val = clk_readl(c->reg + PLL_BASE);
 759         val |= PLL_BASE_ENABLE | PLL_BASE_BYPASS;
 760         clk_writel(val, c->reg + PLL_BASE);
 761
 762         return 0;
 763 }
 764
 765 static struct clk_ops tegra_plle_ops = {
 766         .init       = tegra2_pll_clk_init,
 767         .enable     = tegra2_plle_clk_enable,
 768         .set_rate   = tegra2_pll_clk_set_rate,
 769 };
 770
 771 /* Clock divider ops */
 772 static void tegra2_pll_div_clk_init(struct clk *c)
 773 {
 774         u32 val = clk_readl(c->reg);
 775         u32 divu71;
 776         val >>= c->reg_shift;
 777         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
 778         if (!(val & PLL_OUT_RESET_DISABLE))
 779                 c->state = OFF;
 780
 781         if (c->flags & DIV_U71) {
 782                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
 783                 c->div = (divu71 + 2);
 784                 c->mul = 2;
 785         } else if (c->flags & DIV_2) {
 786                 c->div = 2;
 787                 c->mul = 1;
 788         } else {
 789                 c->div = 1;
 790                 c->mul = 1;
 791         }
 792 }
 793
 794 static int tegra2_pll_div_clk_enable(struct clk *c)
 795 {
 796         u32 val;
 797         u32 new_val;
 798         unsigned long flags;
 799
 800         pr_debug("%s: %s\n", __func__, c->name);
 801         if (c->flags & DIV_U71) {
 802                 spin_lock_irqsave(&clock_register_lock, flags);
 803                 val = clk_readl(c->reg);
 804                 new_val = val >> c->reg_shift;
 805                 new_val &= 0xFFFF;
 806
 807                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
 808
 809                 val &= ~(0xFFFF << c->reg_shift);
 810                 val |= new_val << c->reg_shift;
 811                 clk_writel(val, c->reg);
 812                 spin_unlock_irqrestore(&clock_register_lock, flags);
 813                 return 0;
 814         } else if (c->flags & DIV_2) {
 815                 BUG_ON(!(c->flags & PLLD));
 816                 spin_lock_irqsave(&clock_register_lock, flags);
 817                 val = clk_readl(c->reg);
 818                 val &= ~PLLD_MISC_DIV_RST;
 819                 clk_writel(val, c->reg);
 820                 spin_unlock_irqrestore(&clock_register_lock, flags);
 821                 return 0;
 822         }
 823         return -EINVAL;
 824 }
 825
 826 static void tegra2_pll_div_clk_disable(struct clk *c)
 827 {
 828         u32 val;
 829         u32 new_val;
 830         unsigned long flags;
 831
 832         pr_debug("%s: %s\n", __func__, c->name);
 833         if (c->flags & DIV_U71) {
 834                 spin_lock_irqsave(&clock_register_lock, flags);
 835                 val = clk_readl(c->reg);
 836                 new_val = val >> c->reg_shift;
 837                 new_val &= 0xFFFF;
 838
 839                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
 840
 841                 val &= ~(0xFFFF << c->reg_shift);
 842                 val |= new_val << c->reg_shift;
 843                 clk_writel(val, c->reg);
 844                 spin_unlock_irqrestore(&clock_register_lock, flags);
 845         } else if (c->flags & DIV_2) {
 846                 BUG_ON(!(c->flags & PLLD));
 847                 spin_lock_irqsave(&clock_register_lock, flags);
 848                 val = clk_readl(c->reg);
 849                 val |= PLLD_MISC_DIV_RST;
 850                 clk_writel(val, c->reg);
 851                 spin_unlock_irqrestore(&clock_register_lock, flags);
 852         }
 853 }
 854
 855 static int tegra2_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
 856 {
 857         u32 val;
 858         u32 new_val;
 859         int divider_u71;
 860         unsigned long parent_rate = clk_get_rate(c->parent);
 861         unsigned long flags;
 862
 863         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
 864         if (c->flags & DIV_U71) {
 865                 divider_u71 = clk_div71_get_divider(parent_rate, rate);
 866                 if (divider_u71 >= 0) {
 867                         spin_lock_irqsave(&clock_register_lock, flags);
 868                         val = clk_readl(c->reg);
 869                         new_val = val >> c->reg_shift;
 870                         new_val &= 0xFFFF;
 871                         if (c->flags & DIV_U71_FIXED)
 872                                 new_val |= PLL_OUT_OVERRIDE;
 873                         new_val &= ~PLL_OUT_RATIO_MASK;
 874                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
 875
 876                         val &= ~(0xFFFF << c->reg_shift);
 877                         val |= new_val << c->reg_shift;
 878                         clk_writel(val, c->reg);
 879                         c->div = divider_u71 + 2;
 880                         c->mul = 2;
 881                         spin_unlock_irqrestore(&clock_register_lock, flags);
 882                         return 0;
 883                 }
 884         } else if (c->flags & DIV_2) {
 885                 if (parent_rate == rate * 2)
 886                         return 0;
 887         }
 888         return -EINVAL;
 889 }
 890
 891 static long tegra2_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
 892 {
 893         int divider;
 894         unsigned long parent_rate = clk_get_rate(c->parent);
 895         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
 896
 897         if (c->flags & DIV_U71) {
 898                 divider = clk_div71_get_divider(parent_rate, rate);
 899                 if (divider < 0)
 900                         return divider;
 901                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
 902         } else if (c->flags & DIV_2) {
 903                 return DIV_ROUND_UP(parent_rate, 2);
 904         }
 905         return -EINVAL;
 906 }
 907
 908 static struct clk_ops tegra_pll_div_ops = {
 909         .init                   = tegra2_pll_div_clk_init,
 910         .enable                 = tegra2_pll_div_clk_enable,
 911         .disable                = tegra2_pll_div_clk_disable,
 912         .set_rate               = tegra2_pll_div_clk_set_rate,
 913         .round_rate             = tegra2_pll_div_clk_round_rate,
 914 };
 915
 916 /* Periph clk ops */
 917
 918 static void tegra2_periph_clk_init(struct clk *c)
 919 {
 920         u32 val = clk_readl(c->reg);
 921         const struct clk_mux_sel *mux = 0;
 922         const struct clk_mux_sel *sel;
 923         if (c->flags & MUX) {
 924                 for (sel = c->inputs; sel->input != NULL; sel++) {
 925                         if (val >> PERIPH_CLK_SOURCE_SHIFT == sel->value)
 926                                 mux = sel;
 927                 }
 928                 BUG_ON(!mux);
 929
 930                 c->parent = mux->input;
 931         } else {
 932                 c->parent = c->inputs[0].input;
 933         }
 934
 935         if (c->flags & DIV_U71) {
 936                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
 937                 c->div = divu71 + 2;
 938                 c->mul = 2;
 939         } else if (c->flags & DIV_U16) {
 940                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
 941                 c->div = divu16 + 1;
 942                 c->mul = 1;
 943         } else {
 944                 c->div = 1;
 945                 c->mul = 1;
 946         }
 947
 948         c->state = ON;
 949
 950         if (!c->u.periph.clk_num)
 951                 return;
 952
 953         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
 954                         PERIPH_CLK_TO_ENB_BIT(c)))
 955                 c->state = OFF;
 956
 957         if (!(c->flags & PERIPH_NO_RESET))
 958                 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
 959                                 PERIPH_CLK_TO_ENB_BIT(c))
 960                         c->state = OFF;
 961 }
 962
 963 static int tegra2_periph_clk_enable(struct clk *c)
 964 {
 965         u32 val;
 966         unsigned long flags;
 967         int refcount;
 968         pr_debug("%s on clock %s\n", __func__, c->name);
 969
 970         if (!c->u.periph.clk_num)
 971                 return 0;
 972
 973         spin_lock_irqsave(&clock_register_lock, flags);
 974
 975         refcount = tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
 976
 977         if (refcount > 1)
 978                 goto out;
 979
 980         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
 981                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
 982         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
 983                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
 984                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
 985         if (c->flags & PERIPH_EMC_ENB) {
 986                 /* The EMC peripheral clock has 2 extra enable bits */
 987                 /* FIXME: Do they need to be disabled? */
 988                 val = clk_readl(c->reg);
 989                 val |= 0x3 << 24;
 990                 clk_writel(val, c->reg);
 991         }
 992
 993 out:
 994         spin_unlock_irqrestore(&clock_register_lock, flags);
 995
 996         return 0;
 997 }
 998
 999 static void tegra2_periph_clk_disable(struct clk *c)
1000 {
1001         unsigned long flags;
1002
1003         pr_debug("%s on clock %s\n", __func__, c->name);
1004
1005         if (!c->u.periph.clk_num)
1006                 return;
1007
1008         spin_lock_irqsave(&clock_register_lock, flags);
1009
1010         if (c->refcnt)
1011                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
1012
1013         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0)
1014                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1015                         CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1016
1017         spin_unlock_irqrestore(&clock_register_lock, flags);
1018 }
1019
1020 static void tegra2_periph_clk_reset(struct clk *c, bool assert)
1021 {
1022         unsigned long base = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
1023
1024         pr_debug("%s %s on clock %s\n", __func__,
1025                  assert ? "assert" : "deassert", c->name);
1026
1027         BUG_ON(!c->u.periph.clk_num);
1028
1029         if (!(c->flags & PERIPH_NO_RESET))
1030                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1031                            base + PERIPH_CLK_TO_ENB_SET_REG(c));
1032 }
1033
1034 static int tegra2_periph_clk_set_parent(struct clk *c, struct clk *p)
1035 {
1036         u32 val;
1037         const struct clk_mux_sel *sel;
1038         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1039         for (sel = c->inputs; sel->input != NULL; sel++) {
1040                 if (sel->input == p) {
1041                         val = clk_readl(c->reg);
1042                         val &= ~PERIPH_CLK_SOURCE_MASK;
1043                         val |= (sel->value) << PERIPH_CLK_SOURCE_SHIFT;
1044
1045                         if (c->refcnt)
1046                                 clk_enable(p);
1047
1048                         clk_writel(val, c->reg);
1049
1050                         if (c->refcnt && c->parent)
1051                                 clk_disable(c->parent);
1052
1053                         clk_reparent(c, p);
1054                         return 0;
1055                 }
1056         }
1057
1058         return -EINVAL;
1059 }
1060
1061 static int tegra2_periph_clk_set_rate(struct clk *c, unsigned long rate)
1062 {
1063         u32 val;
1064         int divider;
1065         unsigned long parent_rate = clk_get_rate(c->parent);
1066
1067         if (c->flags & DIV_U71) {
1068                 divider = clk_div71_get_divider(parent_rate, rate);
1069                 if (divider >= 0) {
1070                         val = clk_readl(c->reg);
1071                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
1072                         val |= divider;
1073                         clk_writel(val, c->reg);
1074                         c->div = divider + 2;
1075                         c->mul = 2;
1076                         return 0;
1077                 }
1078         } else if (c->flags & DIV_U16) {
1079                 divider = clk_div16_get_divider(parent_rate, rate);
1080                 if (divider >= 0) {
1081                         val = clk_readl(c->reg);
1082                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
1083                         val |= divider;
1084                         clk_writel(val, c->reg);
1085                         c->div = divider + 1;
1086                         c->mul = 1;
1087                         return 0;
1088                 }
1089         } else if (parent_rate <= rate) {
1090                 c->div = 1;
1091                 c->mul = 1;
1092                 return 0;
1093         }
1094         return -EINVAL;
1095 }
1096
1097 static long tegra2_periph_clk_round_rate(struct clk *c,
1098         unsigned long rate)
1099 {
1100         int divider;
1101         unsigned long parent_rate = clk_get_rate(c->parent);
1102         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1103
1104         if (c->flags & DIV_U71) {
1105                 divider = clk_div71_get_divider(parent_rate, rate);
1106                 if (divider < 0)
1107                         return divider;
1108
1109                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
1110         } else if (c->flags & DIV_U16) {
1111                 divider = clk_div16_get_divider(parent_rate, rate);
1112                 if (divider < 0)
1113                         return divider;
1114                 return DIV_ROUND_UP(parent_rate, divider + 1);
1115         }
1116         return -EINVAL;
1117 }
1118
1119 static struct clk_ops tegra_periph_clk_ops = {
1120         .init                   = &tegra2_periph_clk_init,
1121         .enable                 = &tegra2_periph_clk_enable,
1122         .disable                = &tegra2_periph_clk_disable,
1123         .set_parent             = &tegra2_periph_clk_set_parent,
1124         .set_rate               = &tegra2_periph_clk_set_rate,
1125         .round_rate             = &tegra2_periph_clk_round_rate,
1126         .reset                  = &tegra2_periph_clk_reset,
1127 };
1128
1129 /* The SDMMC controllers have extra bits in the clock source register that
1130  * adjust the delay between the clock and data to compenstate for delays
1131  * on the PCB. */
1132 void tegra2_sdmmc_tap_delay(struct clk *c, int delay)
1133 {
1134         u32 reg;
1135
1136         delay = clamp(delay, 0, 15);
1137         reg = clk_readl(c->reg);
1138         reg &= ~SDMMC_CLK_INT_FB_DLY_MASK;
1139         reg |= SDMMC_CLK_INT_FB_SEL;
1140         reg |= delay << SDMMC_CLK_INT_FB_DLY_SHIFT;
1141         clk_writel(reg, c->reg);
1142 }
1143
1144 /* External memory controller clock ops */
1145 static void tegra2_emc_clk_init(struct clk *c)
1146 {
1147         tegra2_periph_clk_init(c);
1148         c->max_rate = clk_get_rate_locked(c);
1149 }
1150
1151 static long tegra2_emc_clk_round_rate(struct clk *c, unsigned long rate)
1152 {
1153         long new_rate = rate;
1154
1155         new_rate = tegra_emc_round_rate(new_rate);
1156         if (new_rate < 0)
1157                 return c->max_rate;
1158
1159         BUG_ON(new_rate != tegra2_periph_clk_round_rate(c, new_rate));
1160
1161         return new_rate;
1162 }
1163
1164 static int tegra2_emc_clk_set_rate(struct clk *c, unsigned long rate)
1165 {
1166         int ret;
1167         /*
1168          * The Tegra2 memory controller has an interlock with the clock
1169          * block that allows memory shadowed registers to be updated,
1170          * and then transfer them to the main registers at the same
1171          * time as the clock update without glitches.
1172          */
1173         ret = tegra_emc_set_rate(rate);
1174         if (ret < 0)
1175                 return ret;
1176
1177         ret = tegra2_periph_clk_set_rate(c, rate);
1178         udelay(1);
1179
1180         return ret;
1181 }
1182
1183 static struct clk_ops tegra_emc_clk_ops = {
1184         .init                   = &tegra2_emc_clk_init,
1185         .enable                 = &tegra2_periph_clk_enable,
1186         .disable                = &tegra2_periph_clk_disable,
1187         .set_parent             = &tegra2_periph_clk_set_parent,
1188         .set_rate               = &tegra2_emc_clk_set_rate,
1189         .round_rate             = &tegra2_emc_clk_round_rate,
1190         .reset                  = &tegra2_periph_clk_reset,
1191 };
1192
1193 /* Clock doubler ops */
1194 static void tegra2_clk_double_init(struct clk *c)
1195 {
1196         c->mul = 2;
1197         c->div = 1;
1198         c->state = ON;
1199
1200         if (!c->u.periph.clk_num)
1201                 return;
1202
1203         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1204                         PERIPH_CLK_TO_ENB_BIT(c)))
1205                 c->state = OFF;
1206 };
1207
1208 static int tegra2_clk_double_set_rate(struct clk *c, unsigned long rate)
1209 {
1210         if (rate != 2 * clk_get_rate(c->parent))
1211                 return -EINVAL;
1212         c->mul = 2;
1213         c->div = 1;
1214         return 0;
1215 }
1216
1217 static struct clk_ops tegra_clk_double_ops = {
1218         .init                   = &tegra2_clk_double_init,
1219         .enable                 = &tegra2_periph_clk_enable,
1220         .disable                = &tegra2_periph_clk_disable,
1221         .set_rate               = &tegra2_clk_double_set_rate,
1222 };
1223
1224 /* Audio sync clock ops */
1225 static void tegra2_audio_sync_clk_init(struct clk *c)
1226 {
1227         int source;
1228         const struct clk_mux_sel *sel;
1229         u32 val = clk_readl(c->reg);
1230         c->state = (val & (1<<4)) ? OFF : ON;
1231         source = val & 0xf;
1232         for (sel = c->inputs; sel->input != NULL; sel++)
1233                 if (sel->value == source)
1234                         break;
1235         BUG_ON(sel->input == NULL);
1236         c->parent = sel->input;
1237 }
1238
1239 static int tegra2_audio_sync_clk_enable(struct clk *c)
1240 {
1241         clk_writel(0, c->reg);
1242         return 0;
1243 }
1244
1245 static void tegra2_audio_sync_clk_disable(struct clk *c)
1246 {
1247         clk_writel(1, c->reg);
1248 }
1249
1250 static int tegra2_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
1251 {
1252         u32 val;
1253         const struct clk_mux_sel *sel;
1254         for (sel = c->inputs; sel->input != NULL; sel++) {
1255                 if (sel->input == p) {
1256                         val = clk_readl(c->reg);
1257                         val &= ~0xf;
1258                         val |= sel->value;
1259
1260                         if (c->refcnt)
1261                                 clk_enable(p);
1262
1263                         clk_writel(val, c->reg);
1264
1265                         if (c->refcnt && c->parent)
1266                                 clk_disable(c->parent);
1267
1268                         clk_reparent(c, p);
1269                         return 0;
1270                 }
1271         }
1272
1273         return -EINVAL;
1274 }
1275
1276 static struct clk_ops tegra_audio_sync_clk_ops = {
1277         .init       = tegra2_audio_sync_clk_init,
1278         .enable     = tegra2_audio_sync_clk_enable,
1279         .disable    = tegra2_audio_sync_clk_disable,
1280         .set_parent = tegra2_audio_sync_clk_set_parent,
1281 };
1282
1283 /* cdev1 and cdev2 (dap_mclk1 and dap_mclk2) ops */
1284
1285 static void tegra2_cdev_clk_init(struct clk *c)
1286 {
1287         /* We could un-tristate the cdev1 or cdev2 pingroup here; this is
1288          * currently done in the pinmux code. */
1289         c->state = ON;
1290
1291         BUG_ON(!c->u.periph.clk_num);
1292
1293         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1294                         PERIPH_CLK_TO_ENB_BIT(c)))
1295                 c->state = OFF;
1296 }
1297
1298 static int tegra2_cdev_clk_enable(struct clk *c)
1299 {
1300         BUG_ON(!c->u.periph.clk_num);
1301
1302         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1303                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1304         return 0;
1305 }
1306
1307 static void tegra2_cdev_clk_disable(struct clk *c)
1308 {
1309         BUG_ON(!c->u.periph.clk_num);
1310
1311         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1312                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1313 }
1314
1315 static struct clk_ops tegra_cdev_clk_ops = {
1316         .init                   = &tegra2_cdev_clk_init,
1317         .enable                 = &tegra2_cdev_clk_enable,
1318         .disable                = &tegra2_cdev_clk_disable,
1319 };
1320
1321 /* shared bus ops */
1322 /*
1323  * Some clocks may have multiple downstream users that need to request a
1324  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
1325  * clock to each user.  The frequency of the bus is set to the highest
1326  * enabled shared_bus_user clock, with a minimum value set by the
1327  * shared bus.
1328  */
1329 static int tegra_clk_shared_bus_update(struct clk *bus)
1330 {
1331         struct clk *c;
1332         unsigned long rate = bus->min_rate;
1333
1334         list_for_each_entry(c, &bus->shared_bus_list, u.shared_bus_user.node)
1335                 if (c->u.shared_bus_user.enabled)
1336                         rate = max(c->u.shared_bus_user.rate, rate);
1337
1338         if (rate == clk_get_rate_locked(bus))
1339                 return 0;
1340
1341         return clk_set_rate_locked(bus, rate);
1342 };
1343
1344 static void tegra_clk_shared_bus_init(struct clk *c)
1345 {
1346         unsigned long flags;
1347
1348         c->max_rate = c->parent->max_rate;
1349         c->u.shared_bus_user.rate = c->parent->max_rate;
1350         c->state = OFF;
1351         c->set = true;
1352
1353         spin_lock_irqsave(&c->parent->spinlock, flags);
1354
1355         list_add_tail(&c->u.shared_bus_user.node,
1356                 &c->parent->shared_bus_list);
1357
1358         spin_unlock_irqrestore(&c->parent->spinlock, flags);
1359 }
1360
1361 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
1362 {
1363         unsigned long flags;
1364         int ret;
1365         long new_rate = rate;
1366
1367         new_rate = clk_round_rate(c->parent, new_rate);
1368         if (new_rate < 0)
1369                 return new_rate;
1370
1371         spin_lock_irqsave(&c->parent->spinlock, flags);
1372
1373         c->u.shared_bus_user.rate = new_rate;
1374         ret = tegra_clk_shared_bus_update(c->parent);
1375
1376         spin_unlock_irqrestore(&c->parent->spinlock, flags);
1377
1378         return ret;
1379 }
1380
1381 static long tegra_clk_shared_bus_round_rate(struct clk *c, unsigned long rate)
1382 {
1383         return clk_round_rate(c->parent, rate);
1384 }
1385
1386 static int tegra_clk_shared_bus_enable(struct clk *c)
1387 {
1388         unsigned long flags;
1389         int ret;
1390
1391         spin_lock_irqsave(&c->parent->spinlock, flags);
1392
1393         c->u.shared_bus_user.enabled = true;
1394         ret = tegra_clk_shared_bus_update(c->parent);
1395
1396         spin_unlock_irqrestore(&c->parent->spinlock, flags);
1397
1398         return ret;
1399 }
1400
1401 static void tegra_clk_shared_bus_disable(struct clk *c)
1402 {
1403         unsigned long flags;
1404         int ret;
1405
1406         spin_lock_irqsave(&c->parent->spinlock, flags);
1407
1408         c->u.shared_bus_user.enabled = false;
1409         ret = tegra_clk_shared_bus_update(c->parent);
1410         WARN_ON_ONCE(ret);
1411
1412         spin_unlock_irqrestore(&c->parent->spinlock, flags);
1413 }
1414
1415 static struct clk_ops tegra_clk_shared_bus_ops = {
1416         .init = tegra_clk_shared_bus_init,
1417         .enable = tegra_clk_shared_bus_enable,
1418         .disable = tegra_clk_shared_bus_disable,
1419         .set_rate = tegra_clk_shared_bus_set_rate,
1420         .round_rate = tegra_clk_shared_bus_round_rate,
1421 };
1422
1423
1424 /* Clock definitions */
1425 static struct clk tegra_clk_32k = {
1426         .name = "clk_32k",
1427         .rate = 32768,
1428         .ops  = NULL,
1429         .max_rate = 32768,
1430 };
1431
1432 static struct clk_pll_freq_table tegra_pll_s_freq_table[] = {
1433         {32768, 12000000, 366, 1, 1, 0},
1434         {32768, 13000000, 397, 1, 1, 0},
1435         {32768, 19200000, 586, 1, 1, 0},
1436         {32768, 26000000, 793, 1, 1, 0},
1437         {0, 0, 0, 0, 0, 0},
1438 };
1439
1440 static struct clk tegra_pll_s = {
1441         .name      = "pll_s",
1442         .flags     = PLL_ALT_MISC_REG,
1443         .ops       = &tegra_pll_ops,
1444         .parent    = &tegra_clk_32k,
1445         .max_rate  = 26000000,
1446         .reg       = 0xf0,
1447         .u.pll = {
1448                 .input_min = 32768,
1449                 .input_max = 32768,
1450                 .cf_min    = 0, /* FIXME */
1451                 .cf_max    = 0, /* FIXME */
1452                 .vco_min   = 12000000,
1453                 .vco_max   = 26000000,
1454                 .freq_table = tegra_pll_s_freq_table,
1455                 .lock_delay = 300,
1456         },
1457 };
1458
1459 static struct clk_mux_sel tegra_clk_m_sel[] = {
1460         { .input = &tegra_clk_32k, .value = 0},
1461         { .input = &tegra_pll_s,  .value = 1},
1462         { 0, 0},
1463 };
1464
1465 static struct clk tegra_clk_m = {
1466         .name      = "clk_m",
1467         .flags     = ENABLE_ON_INIT,
1468         .ops       = &tegra_clk_m_ops,
1469         .inputs    = tegra_clk_m_sel,
1470         .reg       = 0x1fc,
1471         .reg_shift = 28,
1472         .max_rate  = 26000000,
1473 };
1474
1475 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
1476         { 0, 0, 0, 0, 0, 0 },
1477 };
1478
1479 static struct clk tegra_pll_c = {
1480         .name      = "pll_c",
1481         .flags     = PLL_HAS_CPCON,
1482         .ops       = &tegra_pll_ops,
1483         .reg       = 0x80,
1484         .parent    = &tegra_clk_m,
1485         .max_rate  = 600000000,
1486         .u.pll = {
1487                 .input_min = 2000000,
1488                 .input_max = 31000000,
1489                 .cf_min    = 1000000,
1490                 .cf_max    = 6000000,
1491                 .vco_min   = 20000000,
1492                 .vco_max   = 1400000000,
1493                 .freq_table = tegra_pll_c_freq_table,
1494                 .lock_delay = 300,
1495         },
1496 };
1497
1498 static struct clk tegra_pll_c_out1 = {
1499         .name      = "pll_c_out1",
1500         .ops       = &tegra_pll_div_ops,
1501         .flags     = DIV_U71,
1502         .parent    = &tegra_pll_c,
1503         .reg       = 0x84,
1504         .reg_shift = 0,
1505         .max_rate  = 600000000,
1506 };
1507
1508 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
1509         { 12000000, 666000000, 666, 12, 1, 8},
1510         { 13000000, 666000000, 666, 13, 1, 8},
1511         { 19200000, 666000000, 555, 16, 1, 8},
1512         { 26000000, 666000000, 666, 26, 1, 8},
1513         { 12000000, 600000000, 600, 12, 1, 8},
1514         { 13000000, 600000000, 600, 13, 1, 8},
1515         { 19200000, 600000000, 375, 12, 1, 6},
1516         { 26000000, 600000000, 600, 26, 1, 8},
1517         { 0, 0, 0, 0, 0, 0 },
1518 };
1519
1520 static struct clk tegra_pll_m = {
1521         .name      = "pll_m",
1522         .flags     = PLL_HAS_CPCON,
1523         .ops       = &tegra_pll_ops,
1524         .reg       = 0x90,
1525         .parent    = &tegra_clk_m,
1526         .max_rate  = 800000000,
1527         .u.pll = {
1528                 .input_min = 2000000,
1529                 .input_max = 31000000,
1530                 .cf_min    = 1000000,
1531                 .cf_max    = 6000000,
1532                 .vco_min   = 20000000,
1533                 .vco_max   = 1200000000,
1534                 .freq_table = tegra_pll_m_freq_table,
1535                 .lock_delay = 300,
1536         },
1537 };
1538
1539 static struct clk tegra_pll_m_out1 = {
1540         .name      = "pll_m_out1",
1541         .ops       = &tegra_pll_div_ops,
1542         .flags     = DIV_U71,
1543         .parent    = &tegra_pll_m,
1544         .reg       = 0x94,
1545         .reg_shift = 0,
1546         .max_rate  = 600000000,
1547 };
1548
1549 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
1550         { 12000000, 216000000, 432, 12, 2, 8},
1551         { 13000000, 216000000, 432, 13, 2, 8},
1552         { 19200000, 216000000, 90,   4, 2, 1},
1553         { 26000000, 216000000, 432, 26, 2, 8},
1554         { 12000000, 432000000, 432, 12, 1, 8},
1555         { 13000000, 432000000, 432, 13, 1, 8},
1556         { 19200000, 432000000, 90,   4, 1, 1},
1557         { 26000000, 432000000, 432, 26, 1, 8},
1558         { 0, 0, 0, 0, 0, 0 },
1559 };
1560
1561 static struct clk tegra_pll_p = {
1562         .name      = "pll_p",
1563         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
1564         .ops       = &tegra_pll_ops,
1565         .reg       = 0xa0,
1566         .parent    = &tegra_clk_m,
1567         .max_rate  = 432000000,
1568         .u.pll = {
1569                 .input_min = 2000000,
1570                 .input_max = 31000000,
1571                 .cf_min    = 1000000,
1572                 .cf_max    = 6000000,
1573                 .vco_min   = 20000000,
1574                 .vco_max   = 1400000000,
1575                 .freq_table = tegra_pll_p_freq_table,
1576                 .lock_delay = 300,
1577         },
1578 };
1579
1580 static struct clk tegra_pll_p_out1 = {
1581         .name      = "pll_p_out1",
1582         .ops       = &tegra_pll_div_ops,
1583         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1584         .parent    = &tegra_pll_p,
1585         .reg       = 0xa4,
1586         .reg_shift = 0,
1587         .max_rate  = 432000000,
1588 };
1589
1590 static struct clk tegra_pll_p_out2 = {
1591         .name      = "pll_p_out2",
1592         .ops       = &tegra_pll_div_ops,
1593         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1594         .parent    = &tegra_pll_p,
1595         .reg       = 0xa4,
1596         .reg_shift = 16,
1597         .max_rate  = 432000000,
1598 };
1599
1600 static struct clk tegra_pll_p_out3 = {
1601         .name      = "pll_p_out3",
1602         .ops       = &tegra_pll_div_ops,
1603         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1604         .parent    = &tegra_pll_p,
1605         .reg       = 0xa8,
1606         .reg_shift = 0,
1607         .max_rate  = 432000000,
1608 };
1609
1610 static struct clk tegra_pll_p_out4 = {
1611         .name      = "pll_p_out4",
1612         .ops       = &tegra_pll_div_ops,
1613         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1614         .parent    = &tegra_pll_p,
1615         .reg       = 0xa8,
1616         .reg_shift = 16,
1617         .max_rate  = 432000000,
1618 };
1619
1620 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
1621         { 28800000, 56448000, 49, 25, 1, 1},
1622         { 28800000, 73728000, 64, 25, 1, 1},
1623         { 28800000, 24000000,  5,  6, 1, 1},
1624         { 0, 0, 0, 0, 0, 0 },
1625 };
1626
1627 static struct clk tegra_pll_a = {
1628         .name      = "pll_a",
1629         .flags     = PLL_HAS_CPCON,
1630         .ops       = &tegra_pll_ops,
1631         .reg       = 0xb0,
1632         .parent    = &tegra_pll_p_out1,
1633         .max_rate  = 73728000,
1634         .u.pll = {
1635                 .input_min = 2000000,
1636                 .input_max = 31000000,
1637                 .cf_min    = 1000000,
1638                 .cf_max    = 6000000,
1639                 .vco_min   = 20000000,
1640                 .vco_max   = 1400000000,
1641                 .freq_table = tegra_pll_a_freq_table,
1642                 .lock_delay = 300,
1643         },
1644 };
1645
1646 static struct clk tegra_pll_a_out0 = {
1647         .name      = "pll_a_out0",
1648         .ops       = &tegra_pll_div_ops,
1649         .flags     = DIV_U71,
1650         .parent    = &tegra_pll_a,
1651         .reg       = 0xb4,
1652         .reg_shift = 0,
1653         .max_rate  = 73728000,
1654 };
1655
1656 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
1657         { 12000000, 216000000, 216, 12, 1, 4},
1658         { 13000000, 216000000, 216, 13, 1, 4},
1659         { 19200000, 216000000, 135, 12, 1, 3},
1660         { 26000000, 216000000, 216, 26, 1, 4},
1661
1662         { 12000000, 594000000, 594, 12, 1, 8},
1663         { 13000000, 594000000, 594, 13, 1, 8},
1664         { 19200000, 594000000, 495, 16, 1, 8},
1665         { 26000000, 594000000, 594, 26, 1, 8},
1666
1667         { 12000000, 1000000000, 1000, 12, 1, 12},
1668         { 13000000, 1000000000, 1000, 13, 1, 12},
1669         { 19200000, 1000000000, 625,  12, 1, 8},
1670         { 26000000, 1000000000, 1000, 26, 1, 12},
1671
1672         { 0, 0, 0, 0, 0, 0 },
1673 };
1674
1675 static struct clk tegra_pll_d = {
1676         .name      = "pll_d",
1677         .flags     = PLL_HAS_CPCON | PLLD,
1678         .ops       = &tegra_pll_ops,
1679         .reg       = 0xd0,
1680         .parent    = &tegra_clk_m,
1681         .max_rate  = 1000000000,
1682         .u.pll = {
1683                 .input_min = 2000000,
1684                 .input_max = 40000000,
1685                 .cf_min    = 1000000,
1686                 .cf_max    = 6000000,
1687                 .vco_min   = 40000000,
1688                 .vco_max   = 1000000000,
1689                 .freq_table = tegra_pll_d_freq_table,
1690                 .lock_delay = 1000,
1691         },
1692 };
1693
1694 static struct clk tegra_pll_d_out0 = {
1695         .name      = "pll_d_out0",
1696         .ops       = &tegra_pll_div_ops,
1697         .flags     = DIV_2 | PLLD,
1698         .parent    = &tegra_pll_d,
1699         .max_rate  = 500000000,
1700 };
1701
1702 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
1703         { 12000000, 480000000, 960, 12, 2, 0},
1704         { 13000000, 480000000, 960, 13, 2, 0},
1705         { 19200000, 480000000, 200, 4,  2, 0},
1706         { 26000000, 480000000, 960, 26, 2, 0},
1707         { 0, 0, 0, 0, 0, 0 },
1708 };
1709
1710 static struct clk tegra_pll_u = {
1711         .name      = "pll_u",
1712         .flags     = PLLU,
1713         .ops       = &tegra_pll_ops,
1714         .reg       = 0xc0,
1715         .parent    = &tegra_clk_m,
1716         .max_rate  = 480000000,
1717         .u.pll = {
1718                 .input_min = 2000000,
1719                 .input_max = 40000000,
1720                 .cf_min    = 1000000,
1721                 .cf_max    = 6000000,
1722                 .vco_min   = 480000000,
1723                 .vco_max   = 960000000,
1724                 .freq_table = tegra_pll_u_freq_table,
1725                 .lock_delay = 1000,
1726         },
1727 };
1728
1729 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
1730         /* 1 GHz */
1731         { 12000000, 1000000000, 1000, 12, 1, 12},
1732         { 13000000, 1000000000, 1000, 13, 1, 12},
1733         { 19200000, 1000000000, 625,  12, 1, 8},
1734         { 26000000, 1000000000, 1000, 26, 1, 12},
1735
1736         /* 912 MHz */
1737         { 12000000, 912000000,  912,  12, 1, 12},
1738         { 13000000, 912000000,  912,  13, 1, 12},
1739         { 19200000, 912000000,  760,  16, 1, 8},
1740         { 26000000, 912000000,  912,  26, 1, 12},
1741
1742         /* 816 MHz */
1743         { 12000000, 816000000,  816,  12, 1, 12},
1744         { 13000000, 816000000,  816,  13, 1, 12},
1745         { 19200000, 816000000,  680,  16, 1, 8},
1746         { 26000000, 816000000,  816,  26, 1, 12},
1747
1748         /* 760 MHz */
1749         { 12000000, 760000000,  760,  12, 1, 12},
1750         { 13000000, 760000000,  760,  13, 1, 12},
1751         { 19200000, 760000000,  950,  24, 1, 8},
1752         { 26000000, 760000000,  760,  26, 1, 12},
1753
1754         /* 608 MHz */
1755         { 12000000, 608000000,  608,  12, 1, 12},
1756         { 13000000, 608000000,  608,  13, 1, 12},
1757         { 19200000, 608000000,  380,  12, 1, 8},
1758         { 26000000, 608000000,  608,  26, 1, 12},
1759
1760         /* 456 MHz */
1761         { 12000000, 456000000,  456,  12, 1, 12},
1762         { 13000000, 456000000,  456,  13, 1, 12},
1763         { 19200000, 456000000,  380,  16, 1, 8},
1764         { 26000000, 456000000,  456,  26, 1, 12},
1765
1766         /* 312 MHz */
1767         { 12000000, 312000000,  312,  12, 1, 12},
1768         { 13000000, 312000000,  312,  13, 1, 12},
1769         { 19200000, 312000000,  260,  16, 1, 8},
1770         { 26000000, 312000000,  312,  26, 1, 12},
1771
1772         { 0, 0, 0, 0, 0, 0 },
1773 };
1774
1775 static struct clk tegra_pll_x = {
1776         .name      = "pll_x",
1777         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG,
1778         .ops       = &tegra_pllx_ops,
1779         .reg       = 0xe0,
1780         .parent    = &tegra_clk_m,
1781         .max_rate  = 1000000000,
1782         .u.pll = {
1783                 .input_min = 2000000,
1784                 .input_max = 31000000,
1785                 .cf_min    = 1000000,
1786                 .cf_max    = 6000000,
1787                 .vco_min   = 20000000,
1788                 .vco_max   = 1200000000,
1789                 .freq_table = tegra_pll_x_freq_table,
1790                 .lock_delay = 300,
1791         },
1792 };
1793
1794 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
1795         { 12000000, 100000000,  200,  24, 1, 0 },
1796         { 0, 0, 0, 0, 0, 0 },
1797 };
1798
1799 static struct clk tegra_pll_e = {
1800         .name      = "pll_e",
1801         .flags     = PLL_ALT_MISC_REG,
1802         .ops       = &tegra_plle_ops,
1803         .parent    = &tegra_clk_m,
1804         .reg       = 0xe8,
1805         .max_rate  = 100000000,
1806         .u.pll = {
1807                 .input_min = 12000000,
1808                 .input_max = 12000000,
1809                 .freq_table = tegra_pll_e_freq_table,
1810         },
1811 };
1812
1813 static struct clk tegra_clk_d = {
1814         .name      = "clk_d",
1815         .flags     = PERIPH_NO_RESET,
1816         .ops       = &tegra_clk_double_ops,
1817         .reg       = 0x34,
1818         .reg_shift = 12,
1819         .parent    = &tegra_clk_m,
1820         .max_rate  = 52000000,
1821         .u.periph  = {
1822                 .clk_num = 90,
1823         },
1824 };
1825
1826 /* dap_mclk1, belongs to the cdev1 pingroup. */
1827 static struct clk tegra_clk_cdev1 = {
1828         .name      = "cdev1",
1829         .ops       = &tegra_cdev_clk_ops,
1830         .rate      = 26000000,
1831         .max_rate  = 26000000,
1832         .u.periph  = {
1833                 .clk_num = 94,
1834         },
1835 };
1836
1837 /* dap_mclk2, belongs to the cdev2 pingroup. */
1838 static struct clk tegra_clk_cdev2 = {
1839         .name      = "cdev2",
1840         .ops       = &tegra_cdev_clk_ops,
1841         .rate      = 26000000,
1842         .max_rate  = 26000000,
1843         .u.periph  = {
1844                 .clk_num   = 93,
1845         },
1846 };
1847
1848 /* initialized before peripheral clocks */
1849 static struct clk_mux_sel mux_audio_sync_clk[8+1];
1850 static const struct audio_sources {
1851         const char *name;
1852         int value;
1853 } mux_audio_sync_clk_sources[] = {
1854         { .name = "spdif_in", .value = 0 },
1855         { .name = "i2s1", .value = 1 },
1856         { .name = "i2s2", .value = 2 },
1857         { .name = "pll_a_out0", .value = 4 },
1858 #if 0 /* FIXME: not implemented */
1859         { .name = "ac97", .value = 3 },
1860         { .name = "ext_audio_clk2", .value = 5 },
1861         { .name = "ext_audio_clk1", .value = 6 },
1862         { .name = "ext_vimclk", .value = 7 },
1863 #endif
1864         { 0, 0 }
1865 };
1866
1867 static struct clk tegra_clk_audio = {
1868         .name      = "audio",
1869         .inputs    = mux_audio_sync_clk,
1870         .reg       = 0x38,
1871         .max_rate  = 73728000,
1872         .ops       = &tegra_audio_sync_clk_ops
1873 };
1874
1875 static struct clk tegra_clk_audio_2x = {
1876         .name      = "audio_2x",
1877         .flags     = PERIPH_NO_RESET,
1878         .max_rate  = 48000000,
1879         .ops       = &tegra_clk_double_ops,
1880         .reg       = 0x34,
1881         .reg_shift = 8,
1882         .parent    = &tegra_clk_audio,
1883         .u.periph = {
1884                 .clk_num = 89,
1885         },
1886 };
1887
1888 struct clk_lookup tegra_audio_clk_lookups[] = {
1889         { .con_id = "audio", .clk = &tegra_clk_audio },
1890         { .con_id = "audio_2x", .clk = &tegra_clk_audio_2x }
1891 };
1892
1893 /* This is called after peripheral clocks are initialized, as the
1894  * audio_sync clock depends on some of the peripheral clocks.
1895  */
1896
1897 static void init_audio_sync_clock_mux(void)
1898 {
1899         int i;
1900         struct clk_mux_sel *sel = mux_audio_sync_clk;
1901         const struct audio_sources *src = mux_audio_sync_clk_sources;
1902         struct clk_lookup *lookup;
1903
1904         for (i = 0; src->name; i++, sel++, src++) {
1905                 sel->input = tegra_get_clock_by_name(src->name);
1906                 if (!sel->input)
1907                         pr_err("%s: could not find clk %s\n", __func__,
1908                                 src->name);
1909                 sel->value = src->value;
1910         }
1911
1912         lookup = tegra_audio_clk_lookups;
1913         for (i = 0; i < ARRAY_SIZE(tegra_audio_clk_lookups); i++, lookup++) {
1914                 clk_init(lookup->clk);
1915                 clkdev_add(lookup);
1916         }
1917 }
1918
1919 static struct clk_mux_sel mux_cclk[] = {
1920         { .input = &tegra_clk_m,        .value = 0},
1921         { .input = &tegra_pll_c,        .value = 1},
1922         { .input = &tegra_clk_32k,      .value = 2},
1923         { .input = &tegra_pll_m,        .value = 3},
1924         { .input = &tegra_pll_p,        .value = 4},
1925         { .input = &tegra_pll_p_out4,   .value = 5},
1926         { .input = &tegra_pll_p_out3,   .value = 6},
1927         { .input = &tegra_clk_d,        .value = 7},
1928         { .input = &tegra_pll_x,        .value = 8},
1929         { 0, 0},
1930 };
1931
1932 static struct clk_mux_sel mux_sclk[] = {
1933         { .input = &tegra_clk_m,        .value = 0},
1934         { .input = &tegra_pll_c_out1,   .value = 1},
1935         { .input = &tegra_pll_p_out4,   .value = 2},
1936         { .input = &tegra_pll_p_out3,   .value = 3},
1937         { .input = &tegra_pll_p_out2,   .value = 4},
1938         { .input = &tegra_clk_d,        .value = 5},
1939         { .input = &tegra_clk_32k,      .value = 6},
1940         { .input = &tegra_pll_m_out1,   .value = 7},
1941         { 0, 0},
1942 };
1943
1944 static struct clk tegra_clk_cclk = {
1945         .name   = "cclk",
1946         .inputs = mux_cclk,
1947         .reg    = 0x20,
1948         .ops    = &tegra_super_ops,
1949         .max_rate = 1000000000,
1950 };
1951
1952 static struct clk tegra_clk_sclk = {
1953         .name   = "sclk",
1954         .inputs = mux_sclk,
1955         .reg    = 0x28,
1956         .ops    = &tegra_super_ops,
1957         .max_rate = 240000000,
1958         .min_rate = 120000000,
1959 };
1960
1961 static struct clk tegra_clk_virtual_cpu = {
1962         .name      = "cpu",
1963         .parent    = &tegra_clk_cclk,
1964         .ops       = &tegra_cpu_ops,
1965         .max_rate  = 1000000000,
1966         .u.cpu = {
1967                 .main      = &tegra_pll_x,
1968                 .backup    = &tegra_pll_p,
1969         },
1970 };
1971
1972 static struct clk tegra_clk_cop = {
1973         .name      = "cop",
1974         .parent    = &tegra_clk_sclk,
1975         .ops       = &tegra_cop_ops,
1976         .max_rate  = 240000000,
1977 };
1978
1979 static struct clk tegra_clk_hclk = {
1980         .name           = "hclk",
1981         .flags          = DIV_BUS,
1982         .parent         = &tegra_clk_sclk,
1983         .reg            = 0x30,
1984         .reg_shift      = 4,
1985         .ops            = &tegra_bus_ops,
1986         .max_rate       = 240000000,
1987 };
1988
1989 static struct clk tegra_clk_pclk = {
1990         .name           = "pclk",
1991         .flags          = DIV_BUS,
1992         .parent         = &tegra_clk_hclk,
1993         .reg            = 0x30,
1994         .reg_shift      = 0,
1995         .ops            = &tegra_bus_ops,
1996         .max_rate       = 120000000,
1997 };
1998
1999 static struct clk tegra_clk_blink = {
2000         .name           = "blink",
2001         .parent         = &tegra_clk_32k,
2002         .reg            = 0x40,
2003         .ops            = &tegra_blink_clk_ops,
2004         .max_rate       = 32768,
2005 };
2006
2007 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
2008         { .input = &tegra_pll_m, .value = 0},
2009         { .input = &tegra_pll_c, .value = 1},
2010         { .input = &tegra_pll_p, .value = 2},
2011         { .input = &tegra_pll_a_out0, .value = 3},
2012         { 0, 0},
2013 };
2014
2015 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
2016         { .input = &tegra_pll_m, .value = 0},
2017         { .input = &tegra_pll_c, .value = 1},
2018         { .input = &tegra_pll_p, .value = 2},
2019         { .input = &tegra_clk_m, .value = 3},
2020         { 0, 0},
2021 };
2022
2023 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
2024         { .input = &tegra_pll_p, .value = 0},
2025         { .input = &tegra_pll_c, .value = 1},
2026         { .input = &tegra_pll_m, .value = 2},
2027         { .input = &tegra_clk_m, .value = 3},
2028         { 0, 0},
2029 };
2030
2031 static struct clk_mux_sel mux_pllaout0_audio2x_pllp_clkm[] = {
2032         {.input = &tegra_pll_a_out0, .value = 0},
2033         {.input = &tegra_clk_audio_2x, .value = 1},
2034         {.input = &tegra_pll_p, .value = 2},
2035         {.input = &tegra_clk_m, .value = 3},
2036         { 0, 0},
2037 };
2038
2039 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
2040         {.input = &tegra_pll_p, .value = 0},
2041         {.input = &tegra_pll_d_out0, .value = 1},
2042         {.input = &tegra_pll_c, .value = 2},
2043         {.input = &tegra_clk_m, .value = 3},
2044         { 0, 0},
2045 };
2046
2047 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32[] = {
2048         {.input = &tegra_pll_p,     .value = 0},
2049         {.input = &tegra_pll_c,     .value = 1},
2050         {.input = &tegra_clk_audio,     .value = 2},
2051         {.input = &tegra_clk_m,     .value = 3},
2052         {.input = &tegra_clk_32k,   .value = 4},
2053         { 0, 0},
2054 };
2055
2056 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
2057         {.input = &tegra_pll_p,     .value = 0},
2058         {.input = &tegra_pll_c,     .value = 1},
2059         {.input = &tegra_pll_m,     .value = 2},
2060         { 0, 0},
2061 };
2062
2063 static struct clk_mux_sel mux_clk_m[] = {
2064         { .input = &tegra_clk_m, .value = 0},
2065         { 0, 0},
2066 };
2067
2068 static struct clk_mux_sel mux_pllp_out3[] = {
2069         { .input = &tegra_pll_p_out3, .value = 0},
2070         { 0, 0},
2071 };
2072
2073 static struct clk_mux_sel mux_plld[] = {
2074         { .input = &tegra_pll_d, .value = 0},
2075         { 0, 0},
2076 };
2077
2078 static struct clk_mux_sel mux_clk_32k[] = {
2079         { .input = &tegra_clk_32k, .value = 0},
2080         { 0, 0},
2081 };
2082
2083 static struct clk_mux_sel mux_pclk[] = {
2084         { .input = &tegra_clk_pclk, .value = 0},
2085         { 0, 0},
2086 };
2087
2088 static struct clk tegra_clk_emc = {
2089         .name = "emc",
2090         .ops = &tegra_emc_clk_ops,
2091         .reg = 0x19c,
2092         .max_rate = 800000000,
2093         .inputs = mux_pllm_pllc_pllp_clkm,
2094         .flags = MUX | DIV_U71 | PERIPH_EMC_ENB,
2095         .u.periph = {
2096                 .clk_num = 57,
2097         },
2098 };
2099
2100 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
2101         {                                               \
2102                 .name      = _name,                     \
2103                 .lookup    = {                          \
2104                         .dev_id    = _dev,              \
2105                         .con_id    = _con,              \
2106                 },                                      \
2107                 .ops       = &tegra_periph_clk_ops,     \
2108                 .reg       = _reg,                      \
2109                 .inputs    = _inputs,                   \
2110                 .flags     = _flags,                    \
2111                 .max_rate  = _max,                      \
2112                 .u.periph = {                           \
2113                         .clk_num   = _clk_num,          \
2114                 },                                      \
2115         }
2116
2117 #define SHARED_CLK(_name, _dev, _con, _parent)          \
2118         {                                               \
2119                 .name      = _name,                     \
2120                 .lookup    = {                          \
2121                         .dev_id    = _dev,              \
2122                         .con_id    = _con,              \
2123                 },                                      \
2124                 .ops       = &tegra_clk_shared_bus_ops, \
2125                 .parent = _parent,                      \
2126         }
2127
2128 struct clk tegra_list_clks[] = {
2129         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      108000000, mux_pclk,                    0),
2130         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET),
2131         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
2132         PERIPH_CLK("i2s1",      "tegra-i2s.0",          NULL,   11,     0x100,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2133         PERIPH_CLK("i2s2",      "tegra-i2s.1",          NULL,   18,     0x104,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2134         PERIPH_CLK("spdif_out", "spdif_out",            NULL,   10,     0x108,  100000000, mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2135         PERIPH_CLK("spdif_in",  "spdif_in",             NULL,   10,     0x10c,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71),
2136         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  432000000, mux_pllp_pllc_audio_clkm_clk32,      MUX | DIV_U71),
2137         PERIPH_CLK("spi",       "spi",                  NULL,   43,     0x114,  40000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2138         PERIPH_CLK("xio",       "xio",                  NULL,   45,     0x120,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2139         PERIPH_CLK("twc",       "twc",                  NULL,   16,     0x12c,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2140         PERIPH_CLK("sbc1",      "spi_tegra.0",          NULL,   41,     0x134,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2141         PERIPH_CLK("sbc2",      "spi_tegra.1",          NULL,   44,     0x118,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2142         PERIPH_CLK("sbc3",      "spi_tegra.2",          NULL,   46,     0x11c,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2143         PERIPH_CLK("sbc4",      "spi_tegra.3",          NULL,   68,     0x1b4,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2144         PERIPH_CLK("ide",       "ide",                  NULL,   25,     0x144,  100000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2145         PERIPH_CLK("ndflash",   "tegra_nand",           NULL,   13,     0x160,  164000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2146         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2147         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2148         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2149         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2150         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2151         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
2152         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
2153         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      250000000, mux_clk_m,                   0),
2154         PERIPH_CLK("vde",       "tegra-avp",            "vde",  61,     0x1c8,  250000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2155         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* max rate ??? */
2156         /* FIXME: what is la? */
2157         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2158         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2159         PERIPH_CLK("nor",       "nor",                  NULL,   42,     0x1d0,  92000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2160         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2161         PERIPH_CLK("i2c1",      "tegra-i2c.0",          NULL,   12,     0x124,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2162         PERIPH_CLK("i2c2",      "tegra-i2c.1",          NULL,   54,     0x198,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2163         PERIPH_CLK("i2c3",      "tegra-i2c.2",          NULL,   67,     0x1b8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2164         PERIPH_CLK("dvc",       "tegra-i2c.3",          NULL,   47,     0x128,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2165         PERIPH_CLK("i2c1_i2c",  "tegra-i2c.0",          "i2c",  0,      0,      72000000,  mux_pllp_out3,                       0),
2166         PERIPH_CLK("i2c2_i2c",  "tegra-i2c.1",          "i2c",  0,      0,      72000000,  mux_pllp_out3,                       0),
2167         PERIPH_CLK("i2c3_i2c",  "tegra-i2c.2",          "i2c",  0,      0,      72000000,  mux_pllp_out3,                       0),
2168         PERIPH_CLK("dvc_i2c",   "tegra-i2c.3",          "i2c",  0,      0,      72000000,  mux_pllp_out3,                       0),
2169         PERIPH_CLK("uarta",     "uart.0",               NULL,   6,      0x178,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2170         PERIPH_CLK("uartb",     "uart.1",               NULL,   7,      0x17c,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2171         PERIPH_CLK("uartc",     "uart.2",               NULL,   55,     0x1a0,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2172         PERIPH_CLK("uartd",     "uart.3",               NULL,   65,     0x1c0,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2173         PERIPH_CLK("uarte",     "uart.4",               NULL,   66,     0x1c4,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2174         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
2175         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2176         PERIPH_CLK("vi",        "tegra_camera",         "vi",   20,     0x148,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2177         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET), /* scales with voltage and process_id */
2178         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2179         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  250000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2180         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  166000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2181         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2182         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2183         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  600000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2184         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2185         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  600000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2186         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  600000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2187         PERIPH_CLK("usbd",      "fsl-tegra-udc",        NULL,   22,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2188         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2189         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2190         PERIPH_CLK("dsi",       "dsi",                  NULL,   48,     0,      500000000, mux_plld,                    0), /* scales with voltage */
2191         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      72000000,  mux_pllp_out3,               0),
2192         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      150000000, mux_clk_m,                   0), /* same frequency as VI */
2193         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      150000000, mux_clk_m,                   PERIPH_NO_RESET),
2194         PERIPH_CLK("pex",       NULL,                   "pex",  70,     0,      26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2195         PERIPH_CLK("afi",       NULL,                   "afi",  72,     0,      26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2196         PERIPH_CLK("pcie_xclk", NULL,             "pcie_xclk",  74,     0,      26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2197
2198         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sclk),
2199         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc),
2200         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc),
2201         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc),
2202         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc),
2203         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc),
2204         SHARED_CLK("host.emc",  "tegra_grhost",         "emc",  &tegra_clk_emc),
2205         SHARED_CLK("usbd.emc",  "fsl-tegra-udc",        "emc",  &tegra_clk_emc),
2206         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc),
2207         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc),
2208         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc),
2209 };
2210
2211 #define CLK_DUPLICATE(_name, _dev, _con)                \
2212         {                                               \
2213                 .name   = _name,                        \
2214                 .lookup = {                             \
2215                         .dev_id = _dev,                 \
2216                         .con_id         = _con,         \
2217                 },                                      \
2218         }
2219
2220 /* Some clocks may be used by different drivers depending on the board
2221  * configuration.  List those here to register them twice in the clock lookup
2222  * table under two names.
2223  */
2224 struct clk_duplicate tegra_clk_duplicates[] = {
2225         CLK_DUPLICATE("uarta",  "tegra_uart.0", NULL),
2226         CLK_DUPLICATE("uartb",  "tegra_uart.1", NULL),
2227         CLK_DUPLICATE("uartc",  "tegra_uart.2", NULL),
2228         CLK_DUPLICATE("uartd",  "tegra_uart.3", NULL),
2229         CLK_DUPLICATE("uarte",  "tegra_uart.4", NULL),
2230         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
2231         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
2232         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
2233         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
2234         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
2235         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
2236         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
2237         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
2238         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
2239         CLK_DUPLICATE("host1x", "tegra_grhost", "host1x"),
2240         CLK_DUPLICATE("2d", "tegra_grhost", "gr2d"),
2241         CLK_DUPLICATE("3d", "tegra_grhost", "gr3d"),
2242         CLK_DUPLICATE("epp", "tegra_grhost", "epp"),
2243         CLK_DUPLICATE("mpe", "tegra_grhost", "mpe"),
2244         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
2245         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
2246 };
2247
2248 #define CLK(dev, con, ck)       \
2249         {                       \
2250                 .dev_id = dev,  \
2251                 .con_id = con,  \
2252                 .clk = ck,      \
2253         }
2254
2255 struct clk *tegra_ptr_clks[] = {
2256         &tegra_clk_32k,
2257         &tegra_pll_s,
2258         &tegra_clk_m,
2259         &tegra_pll_m,
2260         &tegra_pll_m_out1,
2261         &tegra_pll_c,
2262         &tegra_pll_c_out1,
2263         &tegra_pll_p,
2264         &tegra_pll_p_out1,
2265         &tegra_pll_p_out2,
2266         &tegra_pll_p_out3,
2267         &tegra_pll_p_out4,
2268         &tegra_pll_a,
2269         &tegra_pll_a_out0,
2270         &tegra_pll_d,
2271         &tegra_pll_d_out0,
2272         &tegra_pll_u,
2273         &tegra_pll_x,
2274         &tegra_pll_e,
2275         &tegra_clk_cclk,
2276         &tegra_clk_sclk,
2277         &tegra_clk_hclk,
2278         &tegra_clk_pclk,
2279         &tegra_clk_d,
2280         &tegra_clk_cdev1,
2281         &tegra_clk_cdev2,
2282         &tegra_clk_virtual_cpu,
2283         &tegra_clk_blink,
2284         &tegra_clk_cop,
2285         &tegra_clk_emc,
2286 };
2287
2288 static void tegra2_init_one_clock(struct clk *c)
2289 {
2290         clk_init(c);
2291         INIT_LIST_HEAD(&c->shared_bus_list);
2292         if (!c->lookup.dev_id && !c->lookup.con_id)
2293                 c->lookup.con_id = c->name;
2294         c->lookup.clk = c;
2295         clkdev_add(&c->lookup);
2296 }
2297
2298 void __init tegra2_init_clocks(void)
2299 {
2300         int i;
2301         struct clk *c;
2302
2303         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
2304                 tegra2_init_one_clock(tegra_ptr_clks[i]);
2305
2306         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
2307                 tegra2_init_one_clock(&tegra_list_clks[i]);
2308
2309         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
2310                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
2311                 if (!c) {
2312                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
2313                                 tegra_clk_duplicates[i].name);
2314                         continue;
2315                 }
2316
2317                 tegra_clk_duplicates[i].lookup.clk = c;
2318                 clkdev_add(&tegra_clk_duplicates[i].lookup);
2319         }
2320
2321         init_audio_sync_clock_mux();
2322 }
2323
2324 #ifdef CONFIG_PM
2325 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
2326                            PERIPH_CLK_SOURCE_NUM + 22];
2327
2328 void tegra_clk_suspend(void)
2329 {
2330         unsigned long off, i;
2331         u32 *ctx = clk_rst_suspend;
2332
2333         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
2334         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
2335         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2336         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
2337         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2338         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_BASE);
2339         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2340         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
2341         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2342         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_BASE);
2343         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2344
2345         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
2346         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
2347         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
2348
2349         *ctx++ = clk_readl(tegra_clk_cclk.reg);
2350         *ctx++ = clk_readl(tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2351
2352         *ctx++ = clk_readl(tegra_clk_sclk.reg);
2353         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2354         *ctx++ = clk_readl(tegra_clk_pclk.reg);
2355
2356         *ctx++ = clk_readl(tegra_clk_audio.reg);
2357
2358         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2359                         off += 4) {
2360                 if (off == PERIPH_CLK_SOURCE_EMC)
2361                         continue;
2362                 *ctx++ = clk_readl(off);
2363         }
2364
2365         off = RST_DEVICES;
2366         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2367                 *ctx++ = clk_readl(off);
2368
2369         off = CLK_OUT_ENB;
2370         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2371                 *ctx++ = clk_readl(off);
2372
2373         *ctx++ = clk_readl(MISC_CLK_ENB);
2374         *ctx++ = clk_readl(CLK_MASK_ARM);
2375
2376         BUG_ON(ctx - clk_rst_suspend != ARRAY_SIZE(clk_rst_suspend));
2377 }
2378
2379 void tegra_clk_resume(void)
2380 {
2381         unsigned long off, i;
2382         const u32 *ctx = clk_rst_suspend;
2383         u32 val;
2384
2385         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
2386         val |= *ctx++;
2387         clk_writel(val, OSC_CTRL);
2388
2389         clk_writel(*ctx++, tegra_pll_c.reg + PLL_BASE);
2390         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2391         clk_writel(*ctx++, tegra_pll_a.reg + PLL_BASE);
2392         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2393         clk_writel(*ctx++, tegra_pll_s.reg + PLL_BASE);
2394         clk_writel(*ctx++, tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2395         clk_writel(*ctx++, tegra_pll_d.reg + PLL_BASE);
2396         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2397         clk_writel(*ctx++, tegra_pll_u.reg + PLL_BASE);
2398         clk_writel(*ctx++, tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2399         udelay(1000);
2400
2401         clk_writel(*ctx++, tegra_pll_m_out1.reg);
2402         clk_writel(*ctx++, tegra_pll_a_out0.reg);
2403         clk_writel(*ctx++, tegra_pll_c_out1.reg);
2404
2405         clk_writel(*ctx++, tegra_clk_cclk.reg);
2406         clk_writel(*ctx++, tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2407
2408         clk_writel(*ctx++, tegra_clk_sclk.reg);
2409         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2410         clk_writel(*ctx++, tegra_clk_pclk.reg);
2411
2412         clk_writel(*ctx++, tegra_clk_audio.reg);
2413
2414         /* enable all clocks before configuring clock sources */
2415         clk_writel(0xbffffff9ul, CLK_OUT_ENB);
2416         clk_writel(0xfefffff7ul, CLK_OUT_ENB + 4);
2417         clk_writel(0x77f01bfful, CLK_OUT_ENB + 8);
2418         wmb();
2419
2420         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2421                         off += 4) {
2422                 if (off == PERIPH_CLK_SOURCE_EMC)
2423                         continue;
2424                 clk_writel(*ctx++, off);
2425         }
2426         wmb();
2427
2428         off = RST_DEVICES;
2429         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2430                 clk_writel(*ctx++, off);
2431         wmb();
2432
2433         off = CLK_OUT_ENB;
2434         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2435                 clk_writel(*ctx++, off);
2436         wmb();
2437
2438         clk_writel(*ctx++, MISC_CLK_ENB);
2439         clk_writel(*ctx++, CLK_MASK_ARM);
2440 }
2441 #endif