arch/arm/mach-s3c2440/s3c2440-cpufreq.c

   1 /* linux/arch/arm/plat-s3c24xx/s3c2440-cpufreq.c
   2  *
   3  * Copyright (c) 2006-2009 Simtec Electronics
   4  *      http://armlinux.simtec.co.uk/
   5  *      Ben Dooks <ben@simtec.co.uk>
   6  *      Vincent Sanders <vince@simtec.co.uk>
   7  *
   8  * S3C2440/S3C2442 CPU Frequency scaling
   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/cpufreq.h>
  20 #include <linux/sysdev.h>
  21 #include <linux/delay.h>
  22 #include <linux/clk.h>
  23 #include <linux/err.h>
  24 #include <linux/io.h>
  25
  26 #include <mach/hardware.h>
  27
  28 #include <asm/mach/arch.h>
  29 #include <asm/mach/map.h>
  30
  31 #include <mach/regs-clock.h>
  32
  33 #include <plat/cpu.h>
  34 #include <plat/cpu-freq-core.h>
  35 #include <plat/clock.h>
  36
  37 static struct clk *xtal;
  38 static struct clk *fclk;
  39 static struct clk *hclk;
  40 static struct clk *armclk;
  41
  42 /* HDIV: 1, 2, 3, 4, 6, 8 */
  43
  44 static inline int within_khz(unsigned long a, unsigned long b)
  45 {
  46         long diff = a - b;
  47
  48         return (diff >= -1000 && diff <= 1000);
  49 }
  50
  51 /**
  52  * s3c2440_cpufreq_calcdivs - calculate divider settings
  53  * @cfg: The cpu frequency settings.
  54  *
  55  * Calcualte the divider values for the given frequency settings
  56  * specified in @cfg. The values are stored in @cfg for later use
  57  * by the relevant set routine if the request settings can be reached.
  58  */
  59 int s3c2440_cpufreq_calcdivs(struct s3c_cpufreq_config *cfg)
  60 {
  61         unsigned int hdiv, pdiv;
  62         unsigned long hclk, fclk, armclk;
  63         unsigned long hclk_max;
  64
  65         fclk = cfg->freq.fclk;
  66         armclk = cfg->freq.armclk;
  67         hclk_max = cfg->max.hclk;
  68
  69         s3c_freq_dbg("%s: fclk is %lu, armclk %lu, max hclk %lu\n",
  70                      __func__, fclk, armclk, hclk_max);
  71
  72         if (armclk > fclk) {
  73                 printk(KERN_WARNING "%s: armclk > fclk\n", __func__);
  74                 armclk = fclk;
  75         }
  76
  77         /* if we are in DVS, we need HCLK to be <= ARMCLK */
  78         if (armclk < fclk && armclk < hclk_max)
  79                 hclk_max = armclk;
  80
  81         for (hdiv = 1; hdiv < 9; hdiv++) {
  82                 if (hdiv == 5 || hdiv == 7)
  83                         hdiv++;
  84
  85                 hclk = (fclk / hdiv);
  86                 if (hclk <= hclk_max || within_khz(hclk, hclk_max))
  87                         break;
  88         }
  89
  90         s3c_freq_dbg("%s: hclk %lu, div %d\n", __func__, hclk, hdiv);
  91
  92         if (hdiv > 8)
  93                 goto invalid;
  94
  95         pdiv = (hclk > cfg->max.pclk) ? 2 : 1;
  96
  97         if ((hclk / pdiv) > cfg->max.pclk)
  98                 pdiv++;
  99
 100         s3c_freq_dbg("%s: pdiv %d\n", __func__, pdiv);
 101
 102         if (pdiv > 2)
 103                 goto invalid;
 104
 105         pdiv *= hdiv;
 106
 107         /* calculate a valid armclk */
 108
 109         if (armclk < hclk)
 110                 armclk = hclk;
 111
 112         /* if we're running armclk lower than fclk, this really means
 113          * that the system should go into dvs mode, which means that
 114          * armclk is connected to hclk. */
 115         if (armclk < fclk) {
 116                 cfg->divs.dvs = 1;
 117                 armclk = hclk;
 118         } else
 119                 cfg->divs.dvs = 0;
 120
 121         cfg->freq.armclk = armclk;
 122
 123         /* store the result, and then return */
 124
 125         cfg->divs.h_divisor = hdiv;
 126         cfg->divs.p_divisor = pdiv;
 127
 128         return 0;
 129
 130  invalid:
 131         return -EINVAL;
 132 }
 133
 134 #define CAMDIVN_HCLK_HALF (S3C2440_CAMDIVN_HCLK3_HALF | \
 135                            S3C2440_CAMDIVN_HCLK4_HALF)
 136
 137 /**
 138  * s3c2440_cpufreq_setdivs - set the cpu frequency divider settings
 139  * @cfg: The cpu frequency settings.
 140  *
 141  * Set the divisors from the settings in @cfg, which where generated
 142  * during the calculation phase by s3c2440_cpufreq_calcdivs().
 143  */
 144 static void s3c2440_cpufreq_setdivs(struct s3c_cpufreq_config *cfg)
 145 {
 146         unsigned long clkdiv, camdiv;
 147
 148         s3c_freq_dbg("%s: divsiors: h=%d, p=%d\n", __func__,
 149                      cfg->divs.h_divisor, cfg->divs.p_divisor);
 150
 151         clkdiv = __raw_readl(S3C2410_CLKDIVN);
 152         camdiv = __raw_readl(S3C2440_CAMDIVN);
 153
 154         clkdiv &= ~(S3C2440_CLKDIVN_HDIVN_MASK | S3C2440_CLKDIVN_PDIVN);
 155         camdiv &= ~CAMDIVN_HCLK_HALF;
 156
 157         switch (cfg->divs.h_divisor) {
 158         case 1:
 159                 clkdiv |= S3C2440_CLKDIVN_HDIVN_1;
 160                 break;
 161
 162         case 2:
 163                 clkdiv |= S3C2440_CLKDIVN_HDIVN_2;
 164                 break;
 165
 166         case 6:
 167                 camdiv |= S3C2440_CAMDIVN_HCLK3_HALF;
 168         case 3:
 169                 clkdiv |= S3C2440_CLKDIVN_HDIVN_3_6;
 170                 break;
 171
 172         case 8:
 173                 camdiv |= S3C2440_CAMDIVN_HCLK4_HALF;
 174         case 4:
 175                 clkdiv |= S3C2440_CLKDIVN_HDIVN_4_8;
 176                 break;
 177
 178         default:
 179                 BUG();  /* we don't expect to get here. */
 180         }
 181
 182         if (cfg->divs.p_divisor != cfg->divs.h_divisor)
 183                 clkdiv |= S3C2440_CLKDIVN_PDIVN;
 184
 185         /* todo - set pclk. */
 186
 187         /* Write the divisors first with hclk intentionally halved so that
 188          * when we write clkdiv we will under-frequency instead of over. We
 189          * then make a short delay and remove the hclk halving if necessary.
 190          */
 191
 192         __raw_writel(camdiv | CAMDIVN_HCLK_HALF, S3C2440_CAMDIVN);
 193         __raw_writel(clkdiv, S3C2410_CLKDIVN);
 194
 195         ndelay(20);
 196         __raw_writel(camdiv, S3C2440_CAMDIVN);
 197
 198         clk_set_parent(armclk, cfg->divs.dvs ? hclk : fclk);
 199 }
 200
 201 static int run_freq_for(unsigned long max_hclk, unsigned long fclk,
 202                         int *divs,
 203                         struct cpufreq_frequency_table *table,
 204                         size_t table_size)
 205 {
 206         unsigned long freq;
 207         int index = 0;
 208         int div;
 209
 210         for (div = *divs; div > 0; div = *divs++) {
 211                 freq = fclk / div;
 212
 213                 if (freq > max_hclk && div != 1)
 214                         continue;
 215
 216                 freq /= 1000; /* table is in kHz */
 217                 index = s3c_cpufreq_addfreq(table, index, table_size, freq);
 218                 if (index < 0)
 219                         break;
 220         }
 221
 222         return index;
 223 }
 224
 225 static int hclk_divs[] = { 1, 2, 3, 4, 6, 8, -1 };
 226
 227 static int s3c2440_cpufreq_calctable(struct s3c_cpufreq_config *cfg,
 228                                      struct cpufreq_frequency_table *table,
 229                                      size_t table_size)
 230 {
 231         int ret;
 232
 233         WARN_ON(cfg->info == NULL);
 234         WARN_ON(cfg->board == NULL);
 235
 236         ret = run_freq_for(cfg->info->max.hclk,
 237                            cfg->info->max.fclk,
 238                            hclk_divs,
 239                            table, table_size);
 240
 241         s3c_freq_dbg("%s: returning %d\n", __func__, ret);
 242
 243         return ret;
 244 }
 245
 246 struct s3c_cpufreq_info s3c2440_cpufreq_info = {
 247         .max            = {
 248                 .fclk   = 400000000,
 249                 .hclk   = 133333333,
 250                 .pclk   =  66666666,
 251         },
 252
 253         .locktime_m     = 300,
 254         .locktime_u     = 300,
 255         .locktime_bits  = 16,
 256
 257         .name           = "s3c244x",
 258         .calc_iotiming  = s3c2410_iotiming_calc,
 259         .set_iotiming   = s3c2410_iotiming_set,
 260         .get_iotiming   = s3c2410_iotiming_get,
 261         .set_fvco       = s3c2410_set_fvco,
 262
 263         .set_refresh    = s3c2410_cpufreq_setrefresh,
 264         .set_divs       = s3c2440_cpufreq_setdivs,
 265         .calc_divs      = s3c2440_cpufreq_calcdivs,
 266         .calc_freqtable = s3c2440_cpufreq_calctable,
 267
 268         .resume_clocks  = s3c244x_setup_clocks,
 269
 270         .debug_io_show  = s3c_cpufreq_debugfs_call(s3c2410_iotiming_debugfs),
 271 };
 272
 273 static int s3c2440_cpufreq_add(struct sys_device *sysdev)
 274 {
 275         xtal = s3c_cpufreq_clk_get(NULL, "xtal");
 276         hclk = s3c_cpufreq_clk_get(NULL, "hclk");
 277         fclk = s3c_cpufreq_clk_get(NULL, "fclk");
 278         armclk = s3c_cpufreq_clk_get(NULL, "armclk");
 279
 280         if (IS_ERR(xtal) || IS_ERR(hclk) || IS_ERR(fclk) || IS_ERR(armclk)) {
 281                 printk(KERN_ERR "%s: failed to get clocks\n", __func__);
 282                 return -ENOENT;
 283         }
 284
 285         return s3c_cpufreq_register(&s3c2440_cpufreq_info);
 286 }
 287
 288 static struct sysdev_driver s3c2440_cpufreq_driver = {
 289         .add            = s3c2440_cpufreq_add,
 290 };
 291
 292 static int s3c2440_cpufreq_init(void)
 293 {
 294         return sysdev_driver_register(&s3c2440_sysclass,
 295                                       &s3c2440_cpufreq_driver);
 296 }
 297
 298 /* arch_initcall adds the clocks we need, so use subsys_initcall. */
 299 subsys_initcall(s3c2440_cpufreq_init);
 300
 301 static struct sysdev_driver s3c2442_cpufreq_driver = {
 302         .add            = s3c2440_cpufreq_add,
 303 };
 304
 305 static int s3c2442_cpufreq_init(void)
 306 {
 307         return sysdev_driver_register(&s3c2442_sysclass,
 308                                       &s3c2442_cpufreq_driver);
 309 }
 310
 311 subsys_initcall(s3c2442_cpufreq_init);