arch/arm/plat-s3c64xx/clock.c

   1 /* linux/arch/arm/plat-s3c64xx/clock.c
   2  *
   3  * Copyright 2008 Openmoko, Inc.
   4  * Copyright 2008 Simtec Electronics
   5  *      Ben Dooks <ben@simtec.co.uk>
   6  *      http://armlinux.simtec.co.uk/
   7  *
   8  * S3C64XX Base clock support
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13 */
  14
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/ioport.h>
  19 #include <linux/io.h>
  20
  21 #include <mach/hardware.h>
  22 #include <mach/map.h>
  23
  24 #include <plat/regs-sys.h>
  25 #include <plat/regs-clock.h>
  26 #include <plat/cpu.h>
  27 #include <plat/devs.h>
  28 #include <plat/clock.h>
  29
  30 struct clk clk_h2 = {
  31         .name           = "hclk2",
  32         .id             = -1,
  33         .rate           = 0,
  34 };
  35
  36 struct clk clk_27m = {
  37         .name           = "clk_27m",
  38         .id             = -1,
  39         .rate           = 27000000,
  40 };
  41
  42 static int clk_48m_ctrl(struct clk *clk, int enable)
  43 {
  44         unsigned long flags;
  45         u32 val;
  46
  47         /* can't rely on clock lock, this register has other usages */
  48         local_irq_save(flags);
  49
  50         val = __raw_readl(S3C64XX_OTHERS);
  51         if (enable)
  52                 val |= S3C64XX_OTHERS_USBMASK;
  53         else
  54                 val &= ~S3C64XX_OTHERS_USBMASK;
  55
  56         __raw_writel(val, S3C64XX_OTHERS);
  57         local_irq_restore(flags);
  58
  59         return 0;
  60 }
  61
  62 struct clk clk_48m = {
  63         .name           = "clk_48m",
  64         .id             = -1,
  65         .rate           = 48000000,
  66         .enable         = clk_48m_ctrl,
  67 };
  68
  69 static int inline s3c64xx_gate(void __iomem *reg,
  70                                 struct clk *clk,
  71                                 int enable)
  72 {
  73         unsigned int ctrlbit = clk->ctrlbit;
  74         u32 con;
  75
  76         con = __raw_readl(reg);
  77
  78         if (enable)
  79                 con |= ctrlbit;
  80         else
  81                 con &= ~ctrlbit;
  82
  83         __raw_writel(con, reg);
  84         return 0;
  85 }
  86
  87 static int s3c64xx_pclk_ctrl(struct clk *clk, int enable)
  88 {
  89         return s3c64xx_gate(S3C_PCLK_GATE, clk, enable);
  90 }
  91
  92 static int s3c64xx_hclk_ctrl(struct clk *clk, int enable)
  93 {
  94         return s3c64xx_gate(S3C_HCLK_GATE, clk, enable);
  95 }
  96
  97 int s3c64xx_sclk_ctrl(struct clk *clk, int enable)
  98 {
  99         return s3c64xx_gate(S3C_SCLK_GATE, clk, enable);
 100 }
 101
 102 static struct clk init_clocks_disable[] = {
 103         {
 104                 .name           = "nand",
 105                 .id             = -1,
 106                 .parent         = &clk_h,
 107         }, {
 108                 .name           = "adc",
 109                 .id             = -1,
 110                 .parent         = &clk_p,
 111                 .enable         = s3c64xx_pclk_ctrl,
 112                 .ctrlbit        = S3C_CLKCON_PCLK_TSADC,
 113         }, {
 114                 .name           = "i2c",
 115                 .id             = -1,
 116                 .parent         = &clk_p,
 117                 .enable         = s3c64xx_pclk_ctrl,
 118                 .ctrlbit        = S3C_CLKCON_PCLK_IIC,
 119         }, {
 120                 .name           = "iis",
 121                 .id             = 0,
 122                 .parent         = &clk_p,
 123                 .enable         = s3c64xx_pclk_ctrl,
 124                 .ctrlbit        = S3C_CLKCON_PCLK_IIS0,
 125         }, {
 126                 .name           = "iis",
 127                 .id             = 1,
 128                 .parent         = &clk_p,
 129                 .enable         = s3c64xx_pclk_ctrl,
 130                 .ctrlbit        = S3C_CLKCON_PCLK_IIS1,
 131         }, {
 132                 .name           = "spi",
 133                 .id             = 0,
 134                 .parent         = &clk_p,
 135                 .enable         = s3c64xx_pclk_ctrl,
 136                 .ctrlbit        = S3C_CLKCON_PCLK_SPI0,
 137         }, {
 138                 .name           = "spi",
 139                 .id             = 1,
 140                 .parent         = &clk_p,
 141                 .enable         = s3c64xx_pclk_ctrl,
 142                 .ctrlbit        = S3C_CLKCON_PCLK_SPI1,
 143         }, {
 144                 .name           = "48m",
 145                 .id             = 0,
 146                 .parent         = &clk_48m,
 147                 .enable         = s3c64xx_sclk_ctrl,
 148                 .ctrlbit        = S3C_CLKCON_SCLK_MMC0_48,
 149         }, {
 150                 .name           = "48m",
 151                 .id             = 1,
 152                 .parent         = &clk_48m,
 153                 .enable         = s3c64xx_sclk_ctrl,
 154                 .ctrlbit        = S3C_CLKCON_SCLK_MMC1_48,
 155         }, {
 156                 .name           = "48m",
 157                 .id             = 2,
 158                 .parent         = &clk_48m,
 159                 .enable         = s3c64xx_sclk_ctrl,
 160                 .ctrlbit        = S3C_CLKCON_SCLK_MMC2_48,
 161         },
 162 };
 163
 164 static struct clk init_clocks[] = {
 165         {
 166                 .name           = "lcd",
 167                 .id             = -1,
 168                 .parent         = &clk_h,
 169                 .enable         = s3c64xx_hclk_ctrl,
 170                 .ctrlbit        = S3C_CLKCON_HCLK_LCD,
 171         }, {
 172                 .name           = "gpio",
 173                 .id             = -1,
 174                 .parent         = &clk_p,
 175                 .enable         = s3c64xx_pclk_ctrl,
 176                 .ctrlbit        = S3C_CLKCON_PCLK_GPIO,
 177         }, {
 178                 .name           = "usb-host",
 179                 .id             = -1,
 180                 .parent         = &clk_h,
 181                 .enable         = s3c64xx_hclk_ctrl,
 182                 .ctrlbit        = S3C_CLKCON_SCLK_UHOST,
 183         }, {
 184                 .name           = "hsmmc",
 185                 .id             = 0,
 186                 .parent         = &clk_h,
 187                 .enable         = s3c64xx_hclk_ctrl,
 188                 .ctrlbit        = S3C_CLKCON_HCLK_HSMMC0,
 189         }, {
 190                 .name           = "hsmmc",
 191                 .id             = 1,
 192                 .parent         = &clk_h,
 193                 .enable         = s3c64xx_hclk_ctrl,
 194                 .ctrlbit        = S3C_CLKCON_HCLK_HSMMC1,
 195         }, {
 196                 .name           = "hsmmc",
 197                 .id             = 2,
 198                 .parent         = &clk_h,
 199                 .enable         = s3c64xx_hclk_ctrl,
 200                 .ctrlbit        = S3C_CLKCON_HCLK_HSMMC2,
 201         }, {
 202                 .name           = "timers",
 203                 .id             = -1,
 204                 .parent         = &clk_p,
 205                 .enable         = s3c64xx_pclk_ctrl,
 206                 .ctrlbit        = S3C_CLKCON_PCLK_PWM,
 207         }, {
 208                 .name           = "uart",
 209                 .id             = 0,
 210                 .parent         = &clk_p,
 211                 .enable         = s3c64xx_pclk_ctrl,
 212                 .ctrlbit        = S3C_CLKCON_PCLK_UART0,
 213         }, {
 214                 .name           = "uart",
 215                 .id             = 1,
 216                 .parent         = &clk_p,
 217                 .enable         = s3c64xx_pclk_ctrl,
 218                 .ctrlbit        = S3C_CLKCON_PCLK_UART1,
 219         }, {
 220                 .name           = "uart",
 221                 .id             = 2,
 222                 .parent         = &clk_p,
 223                 .enable         = s3c64xx_pclk_ctrl,
 224                 .ctrlbit        = S3C_CLKCON_PCLK_UART2,
 225         }, {
 226                 .name           = "uart",
 227                 .id             = 3,
 228                 .parent         = &clk_p,
 229                 .enable         = s3c64xx_pclk_ctrl,
 230                 .ctrlbit        = S3C_CLKCON_PCLK_UART3,
 231         }, {
 232                 .name           = "rtc",
 233                 .id             = -1,
 234                 .parent         = &clk_p,
 235                 .enable         = s3c64xx_pclk_ctrl,
 236                 .ctrlbit        = S3C_CLKCON_PCLK_RTC,
 237         }, {
 238                 .name           = "watchdog",
 239                 .id             = -1,
 240                 .parent         = &clk_p,
 241                 .ctrlbit        = S3C_CLKCON_PCLK_WDT,
 242         }, {
 243                 .name           = "ac97",
 244                 .id             = -1,
 245                 .parent         = &clk_p,
 246                 .ctrlbit        = S3C_CLKCON_PCLK_AC97,
 247         }
 248 };
 249
 250 static struct clk *clks[] __initdata = {
 251         &clk_ext,
 252         &clk_epll,
 253         &clk_27m,
 254         &clk_48m,
 255         &clk_h2,
 256 };
 257
 258 void __init s3c64xx_register_clocks(void)
 259 {
 260         struct clk *clkp;
 261         int ret;
 262         int ptr;
 263
 264         s3c24xx_register_clocks(clks, ARRAY_SIZE(clks));
 265
 266         clkp = init_clocks;
 267         for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {
 268                 ret = s3c24xx_register_clock(clkp);
 269                 if (ret < 0) {
 270                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
 271                                clkp->name, ret);
 272                 }
 273         }
 274
 275         clkp = init_clocks_disable;
 276         for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) {
 277
 278                 ret = s3c24xx_register_clock(clkp);
 279                 if (ret < 0) {
 280                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
 281                                clkp->name, ret);
 282                 }
 283
 284                 (clkp->enable)(clkp, 0);
 285         }
 286
 287         s3c_pwmclk_init();
 288 }