git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-u300/clock.c

   1 /*
   2  *
   3  * arch/arm/mach-u300/clock.c
   4  *
   5  *
   6  * Copyright (C) 2007-2009 ST-Ericsson AB
   7  * License terms: GNU General Public License (GPL) version 2
   8  * Define clocks in the app platform.
   9  * Author: Linus Walleij <linus.walleij@stericsson.com>
  10  * Author: Jonas Aaberg <jonas.aberg@stericsson.com>
  11  *
  12  */
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/list.h>
  16 #include <linux/errno.h>
  17 #include <linux/err.h>
  18 #include <linux/string.h>
  19 #include <linux/clk.h>
  20 #include <linux/mutex.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/debugfs.h>
  23 #include <linux/device.h>
  24 #include <linux/init.h>
  25 #include <linux/timer.h>
  26 #include <linux/io.h>
  27
  28 #include <asm/clkdev.h>
  29 #include <mach/hardware.h>
  30 #include <mach/syscon.h>
  31
  32 #include "clock.h"
  33
  34 /*
  35  * TODO:
  36  * - move all handling of the CCR register into this file and create
  37  *   a spinlock for the CCR register
  38  * - switch to the clkdevice lookup mechanism that maps clocks to
  39  *   device ID:s instead when it becomes available in kernel 2.6.29.
  40  * - implement rate get/set for all clocks that need it.
  41  */
  42
  43 /*
  44  * Syscon clock I/O registers lock so clock requests don't collide
  45  * NOTE: this is a local lock only used to lock access to clock and
  46  * reset registers in syscon.
  47  */
  48 static DEFINE_SPINLOCK(syscon_clkreg_lock);
  49 static DEFINE_SPINLOCK(syscon_resetreg_lock);
  50
  51 /*
  52  * The clocking hierarchy currently looks like this.
  53  * NOTE: the idea is NOT to show how the clocks are routed on the chip!
  54  * The ideas is to show dependencies, so a clock higher up in the
  55  * hierarchy has to be on in order for another clock to be on. Now,
  56  * both CPU and DMA can actually be on top of the hierarchy, and that
  57  * is not modeled currently. Instead we have the backbone AMBA bus on
  58  * top. This bus cannot be programmed in any way but conceptually it
  59  * needs to be active for the bridges and devices to transport data.
  60  *
  61  * Please be aware that a few clocks are hw controlled, which mean that
  62  * the hw itself can turn on/off or change the rate of the clock when
  63  * needed!
  64  *
  65  *  AMBA bus
  66  *  |
  67  *  +- CPU
  68  *  +- NANDIF NAND Flash interface
  69  *  +- SEMI Shared Memory interface
  70  *  +- ISP Image Signal Processor (U335 only)
  71  *  +- CDS (U335 only)
  72  *  +- DMA Direct Memory Access Controller
  73  *  +- AAIF APP/ACC Inteface (Mobile Scalable Link, MSL)
  74  *  +- APEX
  75  *  +- VIDEO_ENC AVE2/3 Video Encoder
  76  *  +- XGAM Graphics Accelerator Controller
  77  *  +- AHB
  78  *  |
  79  *  +- ahb:0 AHB Bridge
  80  *  |  |
  81  *  |  +- ahb:1 INTCON Interrupt controller
  82  *  |  +- ahb:3 MSPRO  Memory Stick Pro controller
  83  *  |  +- ahb:4 EMIF   External Memory interface
  84  *  |
  85  *  +- fast:0 FAST bridge
  86  *  |  |
  87  *  |  +- fast:1 MMCSD MMC/SD card reader controller
  88  *  |  +- fast:2 I2S0  PCM I2S channel 0 controller
  89  *  |  +- fast:3 I2S1  PCM I2S channel 1 controller
  90  *  |  +- fast:4 I2C0  I2C channel 0 controller
  91  *  |  +- fast:5 I2C1  I2C channel 1 controller
  92  *  |  +- fast:6 SPI   SPI controller
  93  *  |  +- fast:7 UART1 Secondary UART (U335 only)
  94  *  |
  95  *  +- slow:0 SLOW bridge
  96  *     |
  97  *     +- slow:1 SYSCON (not possible to control)
  98  *     +- slow:2 WDOG Watchdog
  99  *     +- slow:3 UART0 primary UART
 100  *     +- slow:4 TIMER_APP Application timer - used in Linux
 101  *     +- slow:5 KEYPAD controller
 102  *     +- slow:6 GPIO controller
 103  *     +- slow:7 RTC controller
 104  *     +- slow:8 BT Bus Tracer (not used currently)
 105  *     +- slow:9 EH Event Handler (not used currently)
 106  *     +- slow:a TIMER_ACC Access style timer (not used currently)
 107  *     +- slow:b PPM (U335 only, what is that?)
 108  */
 109
 110 /*
 111  * Reset control functions. We remember if a block has been
 112  * taken out of reset and don't remove the reset assertion again
 113  * and vice versa. Currently we only remove resets so the
 114  * enablement function is defined out.
 115  */
 116 static void syscon_block_reset_enable(struct clk *clk)
 117 {
 118         u16 val;
 119         unsigned long iflags;
 120
 121         /* Not all blocks support resetting */
 122         if (!clk->res_reg || !clk->res_mask)
 123                 return;
 124         spin_lock_irqsave(&syscon_resetreg_lock, iflags);
 125         val = readw(clk->res_reg);
 126         val |= clk->res_mask;
 127         writew(val, clk->res_reg);
 128         spin_unlock_irqrestore(&syscon_resetreg_lock, iflags);
 129         clk->reset = true;
 130 }
 131
 132 static void syscon_block_reset_disable(struct clk *clk)
 133 {
 134         u16 val;
 135         unsigned long iflags;
 136
 137         /* Not all blocks support resetting */
 138         if (!clk->res_reg || !clk->res_mask)
 139                 return;
 140         spin_lock_irqsave(&syscon_resetreg_lock, iflags);
 141         val = readw(clk->res_reg);
 142         val &= ~clk->res_mask;
 143         writew(val, clk->res_reg);
 144         spin_unlock_irqrestore(&syscon_resetreg_lock, iflags);
 145         clk->reset = false;
 146 }
 147
 148 int __clk_get(struct clk *clk)
 149 {
 150         u16 val;
 151
 152         /* The MMC and MSPRO clocks need some special set-up */
 153         if (!strcmp(clk->name, "MCLK")) {
 154                 /* Set default MMC clock divisor to 18.9 MHz */
 155                 writew(0x0054U, U300_SYSCON_VBASE + U300_SYSCON_MMF0R);
 156                 val = readw(U300_SYSCON_VBASE + U300_SYSCON_MMCR);
 157                 /* Disable the MMC feedback clock */
 158                 val &= ~U300_SYSCON_MMCR_MMC_FB_CLK_SEL_ENABLE;
 159                 /* Disable MSPRO frequency */
 160                 val &= ~U300_SYSCON_MMCR_MSPRO_FREQSEL_ENABLE;
 161                 writew(val, U300_SYSCON_VBASE + U300_SYSCON_MMCR);
 162         }
 163         if (!strcmp(clk->name, "MSPRO")) {
 164                 val = readw(U300_SYSCON_VBASE + U300_SYSCON_MMCR);
 165                 /* Disable the MMC feedback clock */
 166                 val &= ~U300_SYSCON_MMCR_MMC_FB_CLK_SEL_ENABLE;
 167                 /* Enable MSPRO frequency */
 168                 val |= U300_SYSCON_MMCR_MSPRO_FREQSEL_ENABLE;
 169                 writew(val, U300_SYSCON_VBASE + U300_SYSCON_MMCR);
 170         }
 171         return 1;
 172 }
 173 EXPORT_SYMBOL(__clk_get);
 174
 175 void __clk_put(struct clk *clk)
 176 {
 177 }
 178 EXPORT_SYMBOL(__clk_put);
 179
 180 static void syscon_clk_disable(struct clk *clk)
 181 {
 182         unsigned long iflags;
 183
 184         /* Don't touch the hardware controlled clocks */
 185         if (clk->hw_ctrld)
 186                 return;
 187
 188         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 189         writew(clk->clk_val, U300_SYSCON_VBASE + U300_SYSCON_SBCDR);
 190         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 191 }
 192
 193 static void syscon_clk_enable(struct clk *clk)
 194 {
 195         unsigned long iflags;
 196
 197         /* Don't touch the hardware controlled clocks */
 198         if (clk->hw_ctrld)
 199                 return;
 200
 201         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 202         writew(clk->clk_val, U300_SYSCON_VBASE + U300_SYSCON_SBCER);
 203         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 204 }
 205
 206 static u16 syscon_clk_get_rate(void)
 207 {
 208         u16 val;
 209         unsigned long iflags;
 210
 211         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 212         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
 213         val &= U300_SYSCON_CCR_CLKING_PERFORMANCE_MASK;
 214         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 215         return val;
 216 }
 217
 218 #ifdef CONFIG_MACH_U300_USE_I2S_AS_MASTER
 219 static void enable_i2s0_vcxo(void)
 220 {
 221         u16 val;
 222         unsigned long iflags;
 223
 224         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 225         /* Set I2S0 to use the VCXO 26 MHz clock */
 226         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
 227         val |= U300_SYSCON_CCR_TURN_VCXO_ON;
 228         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 229         val |= U300_SYSCON_CCR_I2S0_USE_VCXO;
 230         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 231         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 232         val |= U300_SYSCON_CEFR_I2S0_CLK_EN;
 233         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 234         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 235 }
 236
 237 static void enable_i2s1_vcxo(void)
 238 {
 239         u16 val;
 240         unsigned long iflags;
 241
 242         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 243         /* Set I2S1 to use the VCXO 26 MHz clock */
 244         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
 245         val |= U300_SYSCON_CCR_TURN_VCXO_ON;
 246         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 247         val |= U300_SYSCON_CCR_I2S1_USE_VCXO;
 248         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 249         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 250         val |= U300_SYSCON_CEFR_I2S1_CLK_EN;
 251         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 252         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 253 }
 254
 255 static void disable_i2s0_vcxo(void)
 256 {
 257         u16 val;
 258         unsigned long iflags;
 259
 260         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 261         /* Disable I2S0 use of the VCXO 26 MHz clock */
 262         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
 263         val &= ~U300_SYSCON_CCR_I2S0_USE_VCXO;
 264         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 265         /* Deactivate VCXO if noone else is using VCXO */
 266         if (!(val & U300_SYSCON_CCR_I2S1_USE_VCXO))
 267                 val &= ~U300_SYSCON_CCR_TURN_VCXO_ON;
 268         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 269         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 270         val &= ~U300_SYSCON_CEFR_I2S0_CLK_EN;
 271         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 272         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 273 }
 274
 275 static void disable_i2s1_vcxo(void)
 276 {
 277         u16 val;
 278         unsigned long iflags;
 279
 280         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 281         /* Disable I2S1 use of the VCXO 26 MHz clock */
 282         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
 283         val &= ~U300_SYSCON_CCR_I2S1_USE_VCXO;
 284         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 285         /* Deactivate VCXO if noone else is using VCXO */
 286         if (!(val & U300_SYSCON_CCR_I2S0_USE_VCXO))
 287                 val &= ~U300_SYSCON_CCR_TURN_VCXO_ON;
 288         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 289         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 290         val &= ~U300_SYSCON_CEFR_I2S0_CLK_EN;
 291         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CEFR);
 292         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 293 }
 294 #endif /* CONFIG_MACH_U300_USE_I2S_AS_MASTER */
 295
 296
 297 static void syscon_clk_rate_set_mclk(unsigned long rate)
 298 {
 299         u16 val;
 300         u32 reg;
 301         unsigned long iflags;
 302
 303         switch (rate) {
 304         case 18900000:
 305                 val = 0x0054;
 306                 break;
 307         case 20800000:
 308                 val = 0x0044;
 309                 break;
 310         case 23100000:
 311                 val = 0x0043;
 312                 break;
 313         case 26000000:
 314                 val = 0x0033;
 315                 break;
 316         case 29700000:
 317                 val = 0x0032;
 318                 break;
 319         case 34700000:
 320                 val = 0x0022;
 321                 break;
 322         case 41600000:
 323                 val = 0x0021;
 324                 break;
 325         case 52000000:
 326                 val = 0x0011;
 327                 break;
 328         case 104000000:
 329                 val = 0x0000;
 330                 break;
 331         default:
 332                 printk(KERN_ERR "Trying to set MCLK to unknown speed! %ld\n",
 333                        rate);
 334                 return;
 335         }
 336
 337         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 338         reg = readw(U300_SYSCON_VBASE + U300_SYSCON_MMF0R) &
 339                 ~U300_SYSCON_MMF0R_MASK;
 340         writew(reg | val, U300_SYSCON_VBASE + U300_SYSCON_MMF0R);
 341         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 342 }
 343
 344 void syscon_clk_rate_set_cpuclk(unsigned long rate)
 345 {
 346         u16 val;
 347         unsigned long iflags;
 348
 349         switch (rate) {
 350         case 13000000:
 351                 val = U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER;
 352                 break;
 353         case 52000000:
 354                 val = U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE;
 355                 break;
 356         case 104000000:
 357                 val = U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH;
 358                 break;
 359         case 208000000:
 360                 val = U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST;
 361                 break;
 362         default:
 363                 return;
 364         }
 365         spin_lock_irqsave(&syscon_clkreg_lock, iflags);
 366         val |= readw(U300_SYSCON_VBASE + U300_SYSCON_CCR) &
 367                 ~U300_SYSCON_CCR_CLKING_PERFORMANCE_MASK ;
 368         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
 369         spin_unlock_irqrestore(&syscon_clkreg_lock, iflags);
 370 }
 371 EXPORT_SYMBOL(syscon_clk_rate_set_cpuclk);
 372
 373 void clk_disable(struct clk *clk)
 374 {
 375         unsigned long iflags;
 376
 377         spin_lock_irqsave(&clk->lock, iflags);
 378         if (clk->usecount > 0 && !(--clk->usecount)) {
 379                 /* some blocks lack clocking registers and cannot be disabled */
 380                 if (clk->disable)
 381                         clk->disable(clk);
 382                 if (likely((u32)clk->parent))
 383                         clk_disable(clk->parent);
 384         }
 385 #ifdef CONFIG_MACH_U300_USE_I2S_AS_MASTER
 386         if (unlikely(!strcmp(clk->name, "I2S0")))
 387                 disable_i2s0_vcxo();
 388         if (unlikely(!strcmp(clk->name, "I2S1")))
 389                 disable_i2s1_vcxo();
 390 #endif
 391         spin_unlock_irqrestore(&clk->lock, iflags);
 392 }
 393 EXPORT_SYMBOL(clk_disable);
 394
 395 int clk_enable(struct clk *clk)
 396 {
 397         int ret = 0;
 398         unsigned long iflags;
 399
 400         spin_lock_irqsave(&clk->lock, iflags);
 401         if (clk->usecount++ == 0) {
 402                 if (likely((u32)clk->parent))
 403                         ret = clk_enable(clk->parent);
 404
 405                 if (unlikely(ret != 0))
 406                         clk->usecount--;
 407                 else {
 408                         /* remove reset line (we never enable reset again) */
 409                         syscon_block_reset_disable(clk);
 410                         /* clocks without enable function are always on */
 411                         if (clk->enable)
 412                                 clk->enable(clk);
 413 #ifdef CONFIG_MACH_U300_USE_I2S_AS_MASTER
 414                         if (unlikely(!strcmp(clk->name, "I2S0")))
 415                                 enable_i2s0_vcxo();
 416                         if (unlikely(!strcmp(clk->name, "I2S1")))
 417                                 enable_i2s1_vcxo();
 418 #endif
 419                 }
 420         }
 421         spin_unlock_irqrestore(&clk->lock, iflags);
 422         return ret;
 423
 424 }
 425 EXPORT_SYMBOL(clk_enable);
 426
 427 /* Returns the clock rate in Hz */
 428 static unsigned long clk_get_rate_cpuclk(struct clk *clk)
 429 {
 430         u16 val;
 431
 432         val = syscon_clk_get_rate();
 433
 434         switch (val) {
 435         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 436         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 437                 return 13000000;
 438         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 439                 return 52000000;
 440         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 441                 return 104000000;
 442         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 443                 return 208000000;
 444         default:
 445                 break;
 446         }
 447         return clk->rate;
 448 }
 449
 450 static unsigned long clk_get_rate_ahb_clk(struct clk *clk)
 451 {
 452         u16 val;
 453
 454         val = syscon_clk_get_rate();
 455
 456         switch (val) {
 457         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 458         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 459                 return 6500000;
 460         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 461                 return 26000000;
 462         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 463         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 464                 return 52000000;
 465         default:
 466                 break;
 467         }
 468         return clk->rate;
 469
 470 }
 471
 472 static unsigned long clk_get_rate_emif_clk(struct clk *clk)
 473 {
 474         u16 val;
 475
 476         val = syscon_clk_get_rate();
 477
 478         switch (val) {
 479         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 480         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 481                 return 13000000;
 482         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 483                 return 52000000;
 484         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 485         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 486                 return 104000000;
 487         default:
 488                 break;
 489         }
 490         return clk->rate;
 491
 492 }
 493
 494 static unsigned long clk_get_rate_xgamclk(struct clk *clk)
 495 {
 496         u16 val;
 497
 498         val = syscon_clk_get_rate();
 499
 500         switch (val) {
 501         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 502         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 503                 return 6500000;
 504         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 505                 return 26000000;
 506         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 507         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 508                 return 52000000;
 509         default:
 510                 break;
 511         }
 512
 513         return clk->rate;
 514 }
 515
 516 static unsigned long clk_get_rate_mclk(struct clk *clk)
 517 {
 518         u16 val;
 519
 520         val = syscon_clk_get_rate();
 521
 522         switch (val) {
 523         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 524                 /*
 525                  * Here, the 208 MHz PLL gets shut down and the always
 526                  * on 13 MHz PLL used for RTC etc kicks into use
 527                  * instead.
 528                  */
 529                 return 13000000;
 530         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 531         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 532         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 533         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 534         {
 535                 /*
 536                  * This clock is under program control. The register is
 537                  * divided in two nybbles, bit 7-4 gives cycles-1 to count
 538                  * high, bit 3-0 gives cycles-1 to count low. Distribute
 539                  * these with no more than 1 cycle difference between
 540                  * low and high and add low and high to get the actual
 541                  * divisor. The base PLL is 208 MHz. Writing 0x00 will
 542                  * divide by 1 and 1 so the highest frequency possible
 543                  * is 104 MHz.
 544                  *
 545                  * e.g. 0x54 =>
 546                  * f = 208 / ((5+1) + (4+1)) = 208 / 11 = 18.9 MHz
 547                  */
 548                 u16 val = readw(U300_SYSCON_VBASE + U300_SYSCON_MMF0R) &
 549                         U300_SYSCON_MMF0R_MASK;
 550                 switch (val) {
 551                 case 0x0054:
 552                         return 18900000;
 553                 case 0x0044:
 554                         return 20800000;
 555                 case 0x0043:
 556                         return 23100000;
 557                 case 0x0033:
 558                         return 26000000;
 559                 case 0x0032:
 560                         return 29700000;
 561                 case 0x0022:
 562                         return 34700000;
 563                 case 0x0021:
 564                         return 41600000;
 565                 case 0x0011:
 566                         return 52000000;
 567                 case 0x0000:
 568                         return 104000000;
 569                 default:
 570                         break;
 571                 }
 572         }
 573         default:
 574                 break;
 575         }
 576
 577         return clk->rate;
 578 }
 579
 580 static unsigned long clk_get_rate_i2s_i2c_spi(struct clk *clk)
 581 {
 582         u16 val;
 583
 584         val = syscon_clk_get_rate();
 585
 586         switch (val) {
 587         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW_POWER:
 588         case U300_SYSCON_CCR_CLKING_PERFORMANCE_LOW:
 589                 return 13000000;
 590         case U300_SYSCON_CCR_CLKING_PERFORMANCE_INTERMEDIATE:
 591         case U300_SYSCON_CCR_CLKING_PERFORMANCE_HIGH:
 592         case U300_SYSCON_CCR_CLKING_PERFORMANCE_BEST:
 593                 return 26000000;
 594         default:
 595                 break;
 596         }
 597
 598         return clk->rate;
 599 }
 600
 601 unsigned long clk_get_rate(struct clk *clk)
 602 {
 603         if (clk->get_rate)
 604                 return clk->get_rate(clk);
 605         else
 606                 return clk->rate;
 607 }
 608 EXPORT_SYMBOL(clk_get_rate);
 609
 610 static unsigned long clk_round_rate_mclk(struct clk *clk, unsigned long rate)
 611 {
 612         if (rate >= 18900000)
 613                 return 18900000;
 614         if (rate >= 20800000)
 615                 return 20800000;
 616         if (rate >= 23100000)
 617                 return 23100000;
 618         if (rate >= 26000000)
 619                 return 26000000;
 620         if (rate >= 29700000)
 621                 return 29700000;
 622         if (rate >= 34700000)
 623                 return 34700000;
 624         if (rate >= 41600000)
 625                 return 41600000;
 626         if (rate >= 52000000)
 627                 return 52000000;
 628         return -EINVAL;
 629 }
 630
 631 static unsigned long clk_round_rate_cpuclk(struct clk *clk, unsigned long rate)
 632 {
 633         if (rate >= 13000000)
 634                 return 13000000;
 635         if (rate >= 52000000)
 636                 return 52000000;
 637         if (rate >= 104000000)
 638                 return 104000000;
 639         if (rate >= 208000000)
 640                 return 208000000;
 641         return -EINVAL;
 642 }
 643
 644 /*
 645  * This adjusts a requested rate to the closest exact rate
 646  * a certain clock can provide. For a fixed clock it's
 647  * mostly clk->rate.
 648  */
 649 long clk_round_rate(struct clk *clk, unsigned long rate)
 650 {
 651         /* TODO: get apropriate switches for EMIFCLK, AHBCLK and MCLK */
 652         /* Else default to fixed value */
 653
 654         if (clk->round_rate) {
 655                 return (long) clk->round_rate(clk, rate);
 656         } else {
 657                 printk(KERN_ERR "clock: Failed to round rate of %s\n",
 658                        clk->name);
 659         }
 660         return (long) clk->rate;
 661 }
 662 EXPORT_SYMBOL(clk_round_rate);
 663
 664 static int clk_set_rate_mclk(struct clk *clk, unsigned long rate)
 665 {
 666         syscon_clk_rate_set_mclk(clk_round_rate(clk, rate));
 667         return 0;
 668 }
 669
 670 static int clk_set_rate_cpuclk(struct clk *clk, unsigned long rate)
 671 {
 672         syscon_clk_rate_set_cpuclk(clk_round_rate(clk, rate));
 673         return 0;
 674 }
 675
 676 int clk_set_rate(struct clk *clk, unsigned long rate)
 677 {
 678         /* TODO: set for EMIFCLK and AHBCLK */
 679         /* Else assume the clock is fixed and fail */
 680         if (clk->set_rate) {
 681                 return clk->set_rate(clk, rate);
 682         } else {
 683                 printk(KERN_ERR "clock: Failed to set %s to %ld hz\n",
 684                        clk->name, rate);
 685                 return -EINVAL;
 686         }
 687 }
 688 EXPORT_SYMBOL(clk_set_rate);
 689
 690 /*
 691  * Clock definitions. The clock parents are set to respective
 692  * bridge and the clock framework makes sure that the clocks have
 693  * parents activated and are brought out of reset when in use.
 694  *
 695  * Clocks that have hw_ctrld = true are hw controlled, and the hw
 696  * can by itself turn these clocks on and off.
 697  * So in other words, we don't really have to care about them.
 698  */
 699
 700 static struct clk amba_clk = {
 701         .name       = "AMBA",
 702         .rate       = 52000000, /* this varies! */
 703         .hw_ctrld   = true,
 704         .reset      = false,
 705 };
 706
 707 /*
 708  * These blocks are connected directly to the AMBA bus
 709  * with no bridge.
 710  */
 711
 712 static struct clk cpu_clk = {
 713         .name       = "CPU",
 714         .parent     = &amba_clk,
 715         .rate       = 208000000, /* this varies! */
 716         .hw_ctrld   = true,
 717         .reset      = true,
 718         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 719         .res_mask   = U300_SYSCON_RRR_CPU_RESET_EN,
 720         .set_rate   = clk_set_rate_cpuclk,
 721         .get_rate   = clk_get_rate_cpuclk,
 722         .round_rate = clk_round_rate_cpuclk,
 723 };
 724
 725 static struct clk nandif_clk = {
 726         .name       = "NANDIF",
 727         .parent     = &amba_clk,
 728         .hw_ctrld   = false,
 729         .reset      = true,
 730         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 731         .res_mask   = U300_SYSCON_RRR_NANDIF_RESET_EN,
 732         .clk_val    = U300_SYSCON_SBCER_NANDIF_CLK_EN,
 733         .enable     = syscon_clk_enable,
 734         .disable    = syscon_clk_disable,
 735 };
 736
 737 static struct clk semi_clk = {
 738         .name       = "SEMI",
 739         .parent     = &amba_clk,
 740         .rate       = 0, /* FIXME */
 741         /* It is not possible to reset SEMI */
 742         .hw_ctrld   = false,
 743         .reset      = false,
 744         .clk_val    = U300_SYSCON_SBCER_SEMI_CLK_EN,
 745         .enable     = syscon_clk_enable,
 746         .disable    = syscon_clk_disable,
 747 };
 748
 749 #ifdef CONFIG_MACH_U300_BS335
 750 static struct clk isp_clk = {
 751         .name       = "ISP",
 752         .parent     = &amba_clk,
 753         .rate       = 0, /* FIXME */
 754         .hw_ctrld   = false,
 755         .reset      = true,
 756         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 757         .res_mask   = U300_SYSCON_RRR_ISP_RESET_EN,
 758         .clk_val    = U300_SYSCON_SBCER_ISP_CLK_EN,
 759         .enable     = syscon_clk_enable,
 760         .disable    = syscon_clk_disable,
 761 };
 762
 763 static struct clk cds_clk = {
 764         .name       = "CDS",
 765         .parent     = &amba_clk,
 766         .rate       = 0, /* FIXME */
 767         .hw_ctrld   = false,
 768         .reset      = true,
 769         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 770         .res_mask   = U300_SYSCON_RRR_CDS_RESET_EN,
 771         .clk_val    = U300_SYSCON_SBCER_CDS_CLK_EN,
 772         .enable     = syscon_clk_enable,
 773         .disable    = syscon_clk_disable,
 774 };
 775 #endif
 776
 777 static struct clk dma_clk = {
 778         .name       = "DMA",
 779         .parent     = &amba_clk,
 780         .rate       = 52000000, /* this varies! */
 781         .hw_ctrld   = true,
 782         .reset      = true,
 783         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 784         .res_mask   = U300_SYSCON_RRR_DMAC_RESET_EN,
 785         .clk_val    = U300_SYSCON_SBCER_DMAC_CLK_EN,
 786         .enable     = syscon_clk_enable,
 787         .disable    = syscon_clk_disable,
 788 };
 789
 790 static struct clk aaif_clk = {
 791         .name       = "AAIF",
 792         .parent     = &amba_clk,
 793         .rate       = 52000000, /* this varies! */
 794         .hw_ctrld   = true,
 795         .reset      = true,
 796         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 797         .res_mask   = U300_SYSCON_RRR_AAIF_RESET_EN,
 798         .clk_val    = U300_SYSCON_SBCER_AAIF_CLK_EN,
 799         .enable     = syscon_clk_enable,
 800         .disable    = syscon_clk_disable,
 801 };
 802
 803 static struct clk apex_clk = {
 804         .name       = "APEX",
 805         .parent     = &amba_clk,
 806         .rate       = 0, /* FIXME */
 807         .hw_ctrld   = true,
 808         .reset      = true,
 809         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 810         .res_mask   = U300_SYSCON_RRR_APEX_RESET_EN,
 811         .clk_val    = U300_SYSCON_SBCER_APEX_CLK_EN,
 812         .enable     = syscon_clk_enable,
 813         .disable    = syscon_clk_disable,
 814 };
 815
 816 static struct clk video_enc_clk = {
 817         .name       = "VIDEO_ENC",
 818         .parent     = &amba_clk,
 819         .rate       = 208000000, /* this varies! */
 820         .hw_ctrld   = false,
 821         .reset      = false,
 822         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 823         /* This has XGAM in the name but refers to the video encoder */
 824         .res_mask   = U300_SYSCON_RRR_XGAM_VC_SYNC_RESET_EN,
 825         .clk_val    = U300_SYSCON_SBCER_VIDEO_ENC_CLK_EN,
 826         .enable     = syscon_clk_enable,
 827         .disable    = syscon_clk_disable,
 828 };
 829
 830 static struct clk xgam_clk = {
 831         .name       = "XGAMCLK",
 832         .parent     = &amba_clk,
 833         .rate       = 52000000, /* this varies! */
 834         .hw_ctrld   = false,
 835         .reset      = true,
 836         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 837         .res_mask   = U300_SYSCON_RRR_XGAM_RESET_EN,
 838         .clk_val    = U300_SYSCON_SBCER_XGAM_CLK_EN,
 839         .get_rate   = clk_get_rate_xgamclk,
 840         .enable     = syscon_clk_enable,
 841         .disable    = syscon_clk_disable,
 842 };
 843
 844 /* This clock is used to activate the video encoder */
 845 static struct clk ahb_clk = {
 846         .name       = "AHB",
 847         .parent     = &amba_clk,
 848         .rate       = 52000000, /* this varies! */
 849         .hw_ctrld   = false, /* This one is set to false due to HW bug */
 850         .reset      = true,
 851         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 852         .res_mask   = U300_SYSCON_RRR_AHB_RESET_EN,
 853         .clk_val    = U300_SYSCON_SBCER_AHB_CLK_EN,
 854         .enable     = syscon_clk_enable,
 855         .disable    = syscon_clk_disable,
 856         .get_rate   = clk_get_rate_ahb_clk,
 857 };
 858
 859
 860 /*
 861  * Clocks on the AHB bridge
 862  */
 863
 864 static struct clk ahb_subsys_clk = {
 865         .name       = "AHB_SUBSYS",
 866         .parent     = &amba_clk,
 867         .rate       = 52000000, /* this varies! */
 868         .hw_ctrld   = true,
 869         .reset      = false,
 870         .clk_val    = U300_SYSCON_SBCER_AHB_SUBSYS_BRIDGE_CLK_EN,
 871         .enable     = syscon_clk_enable,
 872         .disable    = syscon_clk_disable,
 873         .get_rate   = clk_get_rate_ahb_clk,
 874 };
 875
 876 static struct clk intcon_clk = {
 877         .name       = "INTCON",
 878         .parent     = &ahb_subsys_clk,
 879         .rate       = 52000000, /* this varies! */
 880         .hw_ctrld   = false,
 881         .reset      = true,
 882         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 883         .res_mask   = U300_SYSCON_RRR_INTCON_RESET_EN,
 884         /* INTCON can be reset but not clock-gated */
 885 };
 886
 887 static struct clk mspro_clk = {
 888         .name       = "MSPRO",
 889         .parent     = &ahb_subsys_clk,
 890         .rate       = 0, /* FIXME */
 891         .hw_ctrld   = false,
 892         .reset      = true,
 893         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 894         .res_mask   = U300_SYSCON_RRR_MSPRO_RESET_EN,
 895         .clk_val    = U300_SYSCON_SBCER_MSPRO_CLK_EN,
 896         .enable     = syscon_clk_enable,
 897         .disable    = syscon_clk_disable,
 898 };
 899
 900 static struct clk emif_clk = {
 901         .name       = "EMIF",
 902         .parent     = &ahb_subsys_clk,
 903         .rate       = 104000000, /* this varies! */
 904         .hw_ctrld   = false,
 905         .reset      = true,
 906         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RRR,
 907         .res_mask   = U300_SYSCON_RRR_EMIF_RESET_EN,
 908         .clk_val    = U300_SYSCON_SBCER_EMIF_CLK_EN,
 909         .enable     = syscon_clk_enable,
 910         .disable    = syscon_clk_disable,
 911         .get_rate   = clk_get_rate_emif_clk,
 912 };
 913
 914
 915 /*
 916  * Clocks on the FAST bridge
 917  */
 918 static struct clk fast_clk = {
 919         .name       = "FAST_BRIDGE",
 920         .parent     = &amba_clk,
 921         .rate       = 13000000, /* this varies! */
 922         .hw_ctrld   = true,
 923         .reset      = true,
 924         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 925         .res_mask   = U300_SYSCON_RFR_FAST_BRIDGE_RESET_ENABLE,
 926         .clk_val    = U300_SYSCON_SBCER_FAST_BRIDGE_CLK_EN,
 927         .enable     = syscon_clk_enable,
 928         .disable    = syscon_clk_disable,
 929 };
 930
 931 static struct clk mmcsd_clk = {
 932         .name       = "MCLK",
 933         .parent     = &fast_clk,
 934         .rate       = 18900000, /* this varies! */
 935         .hw_ctrld   = false,
 936         .reset      = true,
 937         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 938         .res_mask   = U300_SYSCON_RFR_MMC_RESET_ENABLE,
 939         .clk_val    = U300_SYSCON_SBCER_MMC_CLK_EN,
 940         .get_rate   = clk_get_rate_mclk,
 941         .set_rate   = clk_set_rate_mclk,
 942         .round_rate = clk_round_rate_mclk,
 943         .disable    = syscon_clk_disable,
 944         .enable     = syscon_clk_enable,
 945 };
 946
 947 static struct clk i2s0_clk = {
 948         .name       = "i2s0",
 949         .parent     = &fast_clk,
 950         .rate       = 26000000, /* this varies! */
 951         .hw_ctrld   = true,
 952         .reset      = true,
 953         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 954         .res_mask   = U300_SYSCON_RFR_PCM_I2S0_RESET_ENABLE,
 955         .clk_val    = U300_SYSCON_SBCER_I2S0_CORE_CLK_EN,
 956         .enable     = syscon_clk_enable,
 957         .disable    = syscon_clk_disable,
 958         .get_rate   = clk_get_rate_i2s_i2c_spi,
 959 };
 960
 961 static struct clk i2s1_clk = {
 962         .name       = "i2s1",
 963         .parent     = &fast_clk,
 964         .rate       = 26000000, /* this varies! */
 965         .hw_ctrld   = true,
 966         .reset      = true,
 967         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 968         .res_mask   = U300_SYSCON_RFR_PCM_I2S1_RESET_ENABLE,
 969         .clk_val    = U300_SYSCON_SBCER_I2S1_CORE_CLK_EN,
 970         .enable     = syscon_clk_enable,
 971         .disable    = syscon_clk_disable,
 972         .get_rate   = clk_get_rate_i2s_i2c_spi,
 973 };
 974
 975 static struct clk i2c0_clk = {
 976         .name       = "I2C0",
 977         .parent     = &fast_clk,
 978         .rate       = 26000000, /* this varies! */
 979         .hw_ctrld   = false,
 980         .reset      = true,
 981         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 982         .res_mask   = U300_SYSCON_RFR_I2C0_RESET_ENABLE,
 983         .clk_val    = U300_SYSCON_SBCER_I2C0_CLK_EN,
 984         .enable     = syscon_clk_enable,
 985         .disable    = syscon_clk_disable,
 986         .get_rate   = clk_get_rate_i2s_i2c_spi,
 987 };
 988
 989 static struct clk i2c1_clk = {
 990         .name       = "I2C1",
 991         .parent     = &fast_clk,
 992         .rate       = 26000000, /* this varies! */
 993         .hw_ctrld   = false,
 994         .reset      = true,
 995         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
 996         .res_mask   = U300_SYSCON_RFR_I2C1_RESET_ENABLE,
 997         .clk_val    = U300_SYSCON_SBCER_I2C1_CLK_EN,
 998         .enable     = syscon_clk_enable,
 999         .disable    = syscon_clk_disable,
1000         .get_rate   = clk_get_rate_i2s_i2c_spi,
1001 };
1002
1003 static struct clk spi_clk = {
1004         .name       = "SPI",
1005         .parent     = &fast_clk,
1006         .rate       = 26000000, /* this varies! */
1007         .hw_ctrld   = false,
1008         .reset      = true,
1009         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
1010         .res_mask   = U300_SYSCON_RFR_SPI_RESET_ENABLE,
1011         .clk_val    = U300_SYSCON_SBCER_SPI_CLK_EN,
1012         .enable     = syscon_clk_enable,
1013         .disable    = syscon_clk_disable,
1014         .get_rate   = clk_get_rate_i2s_i2c_spi,
1015 };
1016
1017 #ifdef CONFIG_MACH_U300_BS335
1018 static struct clk uart1_clk = {
1019         .name       = "UART1",
1020         .parent     = &fast_clk,
1021         .rate       = 13000000,
1022         .hw_ctrld   = false,
1023         .reset      = true,
1024         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RFR,
1025         .res_mask   = U300_SYSCON_RFR_UART1_RESET_ENABLE,
1026         .clk_val    = U300_SYSCON_SBCER_UART1_CLK_EN,
1027         .enable     = syscon_clk_enable,
1028         .disable    = syscon_clk_disable,
1029 };
1030 #endif
1031
1032
1033 /*
1034  * Clocks on the SLOW bridge
1035  */
1036 static struct clk slow_clk = {
1037         .name       = "SLOW_BRIDGE",
1038         .parent     = &amba_clk,
1039         .rate       = 13000000,
1040         .hw_ctrld   = true,
1041         .reset      = true,
1042         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1043         .res_mask   = U300_SYSCON_RSR_SLOW_BRIDGE_RESET_EN,
1044         .clk_val    = U300_SYSCON_SBCER_SLOW_BRIDGE_CLK_EN,
1045         .enable     = syscon_clk_enable,
1046         .disable    = syscon_clk_disable,
1047 };
1048
1049 /* TODO: implement SYSCON clock? */
1050
1051 static struct clk wdog_clk = {
1052         .name       = "WDOG",
1053         .parent     = &slow_clk,
1054         .hw_ctrld   = false,
1055         .rate       = 32768,
1056         .reset      = false,
1057         /* This is always on, cannot be enabled/disabled or reset */
1058 };
1059
1060 /* This one is hardwired to PLL13 */
1061 static struct clk uart_clk = {
1062         .name       = "UARTCLK",
1063         .parent     = &slow_clk,
1064         .rate       = 13000000,
1065         .hw_ctrld   = false,
1066         .reset      = true,
1067         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1068         .res_mask   = U300_SYSCON_RSR_UART_RESET_EN,
1069         .clk_val    = U300_SYSCON_SBCER_UART_CLK_EN,
1070         .enable     = syscon_clk_enable,
1071         .disable    = syscon_clk_disable,
1072 };
1073
1074 static struct clk keypad_clk = {
1075         .name       = "KEYPAD",
1076         .parent     = &slow_clk,
1077         .rate       = 32768,
1078         .hw_ctrld   = false,
1079         .reset      = true,
1080         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1081         .res_mask   = U300_SYSCON_RSR_KEYPAD_RESET_EN,
1082         .clk_val    = U300_SYSCON_SBCER_KEYPAD_CLK_EN,
1083         .enable     = syscon_clk_enable,
1084         .disable    = syscon_clk_disable,
1085 };
1086
1087 static struct clk gpio_clk = {
1088         .name       = "GPIO",
1089         .parent     = &slow_clk,
1090         .rate       = 13000000,
1091         .hw_ctrld   = true,
1092         .reset      = true,
1093         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1094         .res_mask   = U300_SYSCON_RSR_GPIO_RESET_EN,
1095         .clk_val    = U300_SYSCON_SBCER_GPIO_CLK_EN,
1096         .enable     = syscon_clk_enable,
1097         .disable    = syscon_clk_disable,
1098 };
1099
1100 static struct clk rtc_clk = {
1101         .name       = "RTC",
1102         .parent     = &slow_clk,
1103         .rate       = 32768,
1104         .hw_ctrld   = true,
1105         .reset      = true,
1106         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1107         .res_mask   = U300_SYSCON_RSR_RTC_RESET_EN,
1108         /* This clock is always on, cannot be enabled/disabled */
1109 };
1110
1111 static struct clk bustr_clk = {
1112         .name       = "BUSTR",
1113         .parent     = &slow_clk,
1114         .rate       = 13000000,
1115         .hw_ctrld   = true,
1116         .reset      = true,
1117         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1118         .res_mask   = U300_SYSCON_RSR_BTR_RESET_EN,
1119         .clk_val    = U300_SYSCON_SBCER_BTR_CLK_EN,
1120         .enable     = syscon_clk_enable,
1121         .disable    = syscon_clk_disable,
1122 };
1123
1124 static struct clk evhist_clk = {
1125         .name       = "EVHIST",
1126         .parent     = &slow_clk,
1127         .rate       = 13000000,
1128         .hw_ctrld   = true,
1129         .reset      = true,
1130         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1131         .res_mask   = U300_SYSCON_RSR_EH_RESET_EN,
1132         .clk_val    = U300_SYSCON_SBCER_EH_CLK_EN,
1133         .enable     = syscon_clk_enable,
1134         .disable    = syscon_clk_disable,
1135 };
1136
1137 static struct clk timer_clk = {
1138         .name       = "TIMER",
1139         .parent     = &slow_clk,
1140         .rate       = 13000000,
1141         .hw_ctrld   = true,
1142         .reset      = true,
1143         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1144         .res_mask   = U300_SYSCON_RSR_ACC_TMR_RESET_EN,
1145         .clk_val    = U300_SYSCON_SBCER_ACC_TMR_CLK_EN,
1146         .enable     = syscon_clk_enable,
1147         .disable    = syscon_clk_disable,
1148 };
1149
1150 static struct clk app_timer_clk = {
1151         .name       = "TIMER_APP",
1152         .parent     = &slow_clk,
1153         .rate       = 13000000,
1154         .hw_ctrld   = true,
1155         .reset      = true,
1156         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1157         .res_mask   = U300_SYSCON_RSR_APP_TMR_RESET_EN,
1158         .clk_val    = U300_SYSCON_SBCER_APP_TMR_CLK_EN,
1159         .enable     = syscon_clk_enable,
1160         .disable    = syscon_clk_disable,
1161 };
1162
1163 #ifdef CONFIG_MACH_U300_BS335
1164 static struct clk ppm_clk = {
1165         .name       = "PPM",
1166         .parent     = &slow_clk,
1167         .rate       = 0, /* FIXME */
1168         .hw_ctrld   = true, /* TODO: Look up if it is hw ctrld or not */
1169         .reset      = true,
1170         .res_reg    = U300_SYSCON_VBASE + U300_SYSCON_RSR,
1171         .res_mask   = U300_SYSCON_RSR_PPM_RESET_EN,
1172         .clk_val    = U300_SYSCON_SBCER_PPM_CLK_EN,
1173         .enable     = syscon_clk_enable,
1174         .disable    = syscon_clk_disable,
1175 };
1176 #endif
1177
1178 #define DEF_LOOKUP(devid, clkref)               \
1179         {                                       \
1180         .dev_id = devid,                        \
1181         .clk = clkref,                          \
1182         }
1183
1184 /*
1185  * Here we only define clocks that are meaningful to
1186  * look up through clockdevice.
1187  */
1188 static struct clk_lookup lookups[] = {
1189         /* Connected directly to the AMBA bus */
1190         DEF_LOOKUP("amba", &amba_clk),
1191         DEF_LOOKUP("cpu", &cpu_clk),
1192         DEF_LOOKUP("nandif", &nandif_clk),
1193         DEF_LOOKUP("semi", &semi_clk),
1194 #ifdef CONFIG_MACH_U300_BS335
1195         DEF_LOOKUP("isp", &isp_clk),
1196         DEF_LOOKUP("cds", &cds_clk),
1197 #endif
1198         DEF_LOOKUP("dma", &dma_clk),
1199         DEF_LOOKUP("aaif", &aaif_clk),
1200         DEF_LOOKUP("apex", &apex_clk),
1201         DEF_LOOKUP("video_enc", &video_enc_clk),
1202         DEF_LOOKUP("xgam", &xgam_clk),
1203         DEF_LOOKUP("ahb", &ahb_clk),
1204         /* AHB bridge clocks */
1205         DEF_LOOKUP("ahb", &ahb_subsys_clk),
1206         DEF_LOOKUP("intcon", &intcon_clk),
1207         DEF_LOOKUP("mspro", &mspro_clk),
1208         DEF_LOOKUP("pl172", &emif_clk),
1209         /* FAST bridge clocks */
1210         DEF_LOOKUP("fast", &fast_clk),
1211         DEF_LOOKUP("mmci", &mmcsd_clk),
1212         /*
1213          * The .0 and .1 identifiers on these comes from the platform device
1214          * .id field and are assigned when the platform devices are registered.
1215          */
1216         DEF_LOOKUP("i2s.0", &i2s0_clk),
1217         DEF_LOOKUP("i2s.1", &i2s1_clk),
1218         DEF_LOOKUP("stddci2c.0", &i2c0_clk),
1219         DEF_LOOKUP("stddci2c.1", &i2c1_clk),
1220         DEF_LOOKUP("pl022", &spi_clk),
1221 #ifdef CONFIG_MACH_U300_BS335
1222         DEF_LOOKUP("uart1", &uart1_clk),
1223 #endif
1224         /* SLOW bridge clocks */
1225         DEF_LOOKUP("slow", &slow_clk),
1226         DEF_LOOKUP("wdog", &wdog_clk),
1227         DEF_LOOKUP("uart0", &uart_clk),
1228         DEF_LOOKUP("apptimer", &app_timer_clk),
1229         DEF_LOOKUP("keypad", &keypad_clk),
1230         DEF_LOOKUP("u300-gpio", &gpio_clk),
1231         DEF_LOOKUP("rtc0", &rtc_clk),
1232         DEF_LOOKUP("bustr", &bustr_clk),
1233         DEF_LOOKUP("evhist", &evhist_clk),
1234         DEF_LOOKUP("timer", &timer_clk),
1235 #ifdef CONFIG_MACH_U300_BS335
1236         DEF_LOOKUP("ppm", &ppm_clk),
1237 #endif
1238 };
1239
1240 static void __init clk_register(void)
1241 {
1242         int i;
1243
1244         /* Register the lookups */
1245         for (i = 0; i < ARRAY_SIZE(lookups); i++)
1246                 clkdev_add(&lookups[i]);
1247 }
1248
1249 /*
1250  * These are the clocks for cells registered as primecell drivers
1251  * on the AMBA bus. These must be on during AMBA device registration
1252  * since the bus probe will attempt to read magic configuration
1253  * registers for these devices. If they are deactivated these probes
1254  * will fail.
1255  *
1256  *
1257  * Please note that on emif, both RAM and NAND is connected in dual
1258  * RAM phones. On single RAM phones, ram is on semi and NAND on emif.
1259  *
1260  */
1261 void u300_clock_primecells(void)
1262 {
1263         clk_enable(&intcon_clk);
1264         clk_enable(&uart_clk);
1265 #ifdef CONFIG_MACH_U300_BS335
1266         clk_enable(&uart1_clk);
1267 #endif
1268         clk_enable(&spi_clk);
1269
1270         clk_enable(&mmcsd_clk);
1271
1272 }
1273 EXPORT_SYMBOL(u300_clock_primecells);
1274
1275 void u300_unclock_primecells(void)
1276 {
1277
1278         clk_disable(&intcon_clk);
1279         clk_disable(&uart_clk);
1280 #ifdef CONFIG_MACH_U300_BS335
1281         clk_disable(&uart1_clk);
1282 #endif
1283         clk_disable(&spi_clk);
1284         clk_disable(&mmcsd_clk);
1285
1286 }
1287 EXPORT_SYMBOL(u300_unclock_primecells);
1288
1289 /*
1290  * The interrupt controller is enabled before the clock API is registered.
1291  */
1292 void u300_enable_intcon_clock(void)
1293 {
1294         clk_enable(&intcon_clk);
1295 }
1296 EXPORT_SYMBOL(u300_enable_intcon_clock);
1297
1298 /*
1299  * The timer is enabled before the clock API is registered.
1300  */
1301 void u300_enable_timer_clock(void)
1302 {
1303         clk_enable(&app_timer_clk);
1304 }
1305 EXPORT_SYMBOL(u300_enable_timer_clock);
1306
1307 #if (defined(CONFIG_DEBUG_FS) && defined(CONFIG_U300_DEBUG))
1308 /*
1309  * The following makes it possible to view the status (especially
1310  * reference count and reset status) for the clocks in the platform
1311  * by looking into the special file <debugfs>/u300_clocks
1312  */
1313
1314 /* A list of all clocks in the platform */
1315 static struct clk *clks[] = {
1316         /* Top node clock for the AMBA bus */
1317         &amba_clk,
1318         /* Connected directly to the AMBA bus */
1319         &cpu_clk,
1320         &nandif_clk,
1321         &semi_clk,
1322 #ifdef CONFIG_MACH_U300_BS335
1323         &isp_clk,
1324         &cds_clk,
1325 #endif
1326         &dma_clk,
1327         &aaif_clk,
1328         &apex_clk,
1329         &video_enc_clk,
1330         &xgam_clk,
1331         &ahb_clk,
1332
1333         /* AHB bridge clocks */
1334         &ahb_subsys_clk,
1335         &intcon_clk,
1336         &mspro_clk,
1337         &emif_clk,
1338         /* FAST bridge clocks */
1339         &fast_clk,
1340         &mmcsd_clk,
1341         &i2s0_clk,
1342         &i2s1_clk,
1343         &i2c0_clk,
1344         &i2c1_clk,
1345         &spi_clk,
1346 #ifdef CONFIG_MACH_U300_BS335
1347         &uart1_clk,
1348 #endif
1349         /* SLOW bridge clocks */
1350         &slow_clk,
1351         &wdog_clk,
1352         &uart_clk,
1353         &app_timer_clk,
1354         &keypad_clk,
1355         &gpio_clk,
1356         &rtc_clk,
1357         &bustr_clk,
1358         &evhist_clk,
1359         &timer_clk,
1360 #ifdef CONFIG_MACH_U300_BS335
1361         &ppm_clk,
1362 #endif
1363 };
1364
1365 static int u300_clocks_show(struct seq_file *s, void *data)
1366 {
1367         struct clk *clk;
1368         int i;
1369
1370         seq_printf(s, "CLOCK           DEVICE          RESET STATE\t" \
1371                    "ACTIVE\tUSERS\tHW CTRL FREQ\n");
1372         seq_printf(s, "---------------------------------------------" \
1373                    "-----------------------------------------\n");
1374         for (i = 0; i < ARRAY_SIZE(clks); i++) {
1375                 clk = clks[i];
1376                 if (clk != ERR_PTR(-ENOENT)) {
1377                         /* Format clock and device name nicely */
1378                         char cdp[33];
1379                         int chars;
1380
1381                         chars = snprintf(&cdp[0], 17, "%s", clk->name);
1382                         while (chars < 16) {
1383                                 cdp[chars] = ' ';
1384                                 chars++;
1385                         }
1386                         chars = snprintf(&cdp[16], 17, "%s", clk->dev ?
1387                                          dev_name(clk->dev) : "N/A");
1388                         while (chars < 16) {
1389                                 cdp[chars+16] = ' ';
1390                                 chars++;
1391                         }
1392                         cdp[32] = '\0';
1393                         if (clk->get_rate)
1394                                 seq_printf(s,
1395                                            "%s%s\t%s\t%d\t%s\t%lu Hz\n",
1396                                            &cdp[0],
1397                                            clk->reset ?
1398                                            "ASSERTED" : "RELEASED",
1399                                            clk->usecount ? "ON" : "OFF",
1400                                            clk->usecount,
1401                                            clk->hw_ctrld  ? "YES" : "NO ",
1402                                            clk->get_rate(clk));
1403                         else
1404                                 seq_printf(s,
1405                                            "%s%s\t%s\t%d\t%s\t" \
1406                                            "(unknown rate)\n",
1407                                            &cdp[0],
1408                                            clk->reset ?
1409                                            "ASSERTED" : "RELEASED",
1410                                            clk->usecount ? "ON" : "OFF",
1411                                            clk->usecount,
1412                                            clk->hw_ctrld  ? "YES" : "NO ");
1413                 }
1414         }
1415         return 0;
1416 }
1417
1418 static int u300_clocks_open(struct inode *inode, struct file *file)
1419 {
1420         return single_open(file, u300_clocks_show, NULL);
1421 }
1422
1423 static const struct file_operations u300_clocks_operations = {
1424         .open           = u300_clocks_open,
1425         .read           = seq_read,
1426         .llseek         = seq_lseek,
1427         .release        = single_release,
1428 };
1429
1430 static void init_clk_read_procfs(void)
1431 {
1432         /* Expose a simple debugfs interface to view all clocks */
1433         (void) debugfs_create_file("u300_clocks", S_IFREG | S_IRUGO,
1434                                    NULL, NULL, &u300_clocks_operations);
1435 }
1436 #else
1437 static inline void init_clk_read_procfs(void)
1438 {
1439 }
1440 #endif
1441
1442 static int __init u300_clock_init(void)
1443 {
1444         u16 val;
1445
1446         /*
1447          * FIXME: shall all this powermanagement stuff really live here???
1448          */
1449
1450         /* Set system to run at PLL208, max performance, a known state. */
1451         val = readw(U300_SYSCON_VBASE + U300_SYSCON_CCR);
1452         val &= ~U300_SYSCON_CCR_CLKING_PERFORMANCE_MASK;
1453         writew(val, U300_SYSCON_VBASE + U300_SYSCON_CCR);
1454         /* Wait for the PLL208 to lock if not locked in yet */
1455         while (!(readw(U300_SYSCON_VBASE + U300_SYSCON_CSR) &
1456                  U300_SYSCON_CSR_PLL208_LOCK_IND));
1457
1458         /* Power management enable */
1459         val = readw(U300_SYSCON_VBASE + U300_SYSCON_PMCR);
1460         val |= U300_SYSCON_PMCR_PWR_MGNT_ENABLE;
1461         writew(val, U300_SYSCON_VBASE + U300_SYSCON_PMCR);
1462
1463         clk_register();
1464
1465         init_clk_read_procfs();
1466
1467         /*
1468          * Some of these may be on when we boot the system so make sure they
1469          * are turned OFF.
1470          */
1471         syscon_block_reset_enable(&timer_clk);
1472         timer_clk.disable(&timer_clk);
1473
1474         /*
1475          * These shall be turned on by default when we boot the system
1476          * so make sure they are ON. (Adding CPU here is a bit too much.)
1477          * These clocks will be claimed by drivers later.
1478          */
1479         syscon_block_reset_disable(&semi_clk);
1480         syscon_block_reset_disable(&emif_clk);
1481         semi_clk.enable(&semi_clk);
1482         emif_clk.enable(&emif_clk);
1483
1484         return 0;
1485 }
1486 /* initialize clocking early to be available later in the boot */
1487 core_initcall(u300_clock_init);