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