drivers/cpufreq/exynos4x12-cpufreq.c

   1 /*
   2  * Copyright (c) 2010-2012 Samsung Electronics Co., Ltd.
   3  *              http://www.samsung.com
   4  *
   5  * EXYNOS4X12 - CPU frequency scaling support
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10 */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/err.h>
  15 #include <linux/clk.h>
  16 #include <linux/io.h>
  17 #include <linux/slab.h>
  18 #include <linux/cpufreq.h>
  19
  20 #include <mach/regs-clock.h>
  21
  22 #include "exynos-cpufreq.h"
  23
  24 #define CPUFREQ_LEVEL_END       (L13 + 1)
  25
  26 static int max_support_idx;
  27 static int min_support_idx = (CPUFREQ_LEVEL_END - 1);
  28
  29 static struct clk *cpu_clk;
  30 static struct clk *moutcore;
  31 static struct clk *mout_mpll;
  32 static struct clk *mout_apll;
  33
  34 struct cpufreq_clkdiv {
  35         unsigned int    index;
  36         unsigned int    clkdiv;
  37         unsigned int    clkdiv1;
  38 };
  39
  40 static unsigned int exynos4x12_volt_table[CPUFREQ_LEVEL_END];
  41
  42 static struct cpufreq_frequency_table exynos4x12_freq_table[] = {
  43         {L0, 1500 * 1000},
  44         {L1, 1400 * 1000},
  45         {L2, 1300 * 1000},
  46         {L3, 1200 * 1000},
  47         {L4, 1100 * 1000},
  48         {L5, 1000 * 1000},
  49         {L6,  900 * 1000},
  50         {L7,  800 * 1000},
  51         {L8,  700 * 1000},
  52         {L9,  600 * 1000},
  53         {L10, 500 * 1000},
  54         {L11, 400 * 1000},
  55         {L12, 300 * 1000},
  56         {L13, 200 * 1000},
  57         {0, CPUFREQ_TABLE_END},
  58 };
  59
  60 static struct cpufreq_clkdiv exynos4x12_clkdiv_table[CPUFREQ_LEVEL_END];
  61
  62 static unsigned int clkdiv_cpu0_4212[CPUFREQ_LEVEL_END][8] = {
  63         /*
  64          * Clock divider value for following
  65          * { DIVCORE, DIVCOREM0, DIVCOREM1, DIVPERIPH,
  66          *              DIVATB, DIVPCLK_DBG, DIVAPLL, DIVCORE2 }
  67          */
  68         /* ARM L0: 1500 MHz */
  69         { 0, 3, 7, 0, 6, 1, 2, 0 },
  70
  71         /* ARM L1: 1400 MHz */
  72         { 0, 3, 7, 0, 6, 1, 2, 0 },
  73
  74         /* ARM L2: 1300 MHz */
  75         { 0, 3, 7, 0, 5, 1, 2, 0 },
  76
  77         /* ARM L3: 1200 MHz */
  78         { 0, 3, 7, 0, 5, 1, 2, 0 },
  79
  80         /* ARM L4: 1100 MHz */
  81         { 0, 3, 6, 0, 4, 1, 2, 0 },
  82
  83         /* ARM L5: 1000 MHz */
  84         { 0, 2, 5, 0, 4, 1, 1, 0 },
  85
  86         /* ARM L6: 900 MHz */
  87         { 0, 2, 5, 0, 3, 1, 1, 0 },
  88
  89         /* ARM L7: 800 MHz */
  90         { 0, 2, 5, 0, 3, 1, 1, 0 },
  91
  92         /* ARM L8: 700 MHz */
  93         { 0, 2, 4, 0, 3, 1, 1, 0 },
  94
  95         /* ARM L9: 600 MHz */
  96         { 0, 2, 4, 0, 3, 1, 1, 0 },
  97
  98         /* ARM L10: 500 MHz */
  99         { 0, 2, 4, 0, 3, 1, 1, 0 },
 100
 101         /* ARM L11: 400 MHz */
 102         { 0, 2, 4, 0, 3, 1, 1, 0 },
 103
 104         /* ARM L12: 300 MHz */
 105         { 0, 2, 4, 0, 2, 1, 1, 0 },
 106
 107         /* ARM L13: 200 MHz */
 108         { 0, 1, 3, 0, 1, 1, 1, 0 },
 109 };
 110
 111 static unsigned int clkdiv_cpu0_4412[CPUFREQ_LEVEL_END][8] = {
 112         /*
 113          * Clock divider value for following
 114          * { DIVCORE, DIVCOREM0, DIVCOREM1, DIVPERIPH,
 115          *              DIVATB, DIVPCLK_DBG, DIVAPLL, DIVCORE2 }
 116          */
 117         /* ARM L0: 1500 MHz */
 118         { 0, 3, 7, 0, 6, 1, 2, 0 },
 119
 120         /* ARM L1: 1400 MHz */
 121         { 0, 3, 7, 0, 6, 1, 2, 0 },
 122
 123         /* ARM L2: 1300 MHz */
 124         { 0, 3, 7, 0, 5, 1, 2, 0 },
 125
 126         /* ARM L3: 1200 MHz */
 127         { 0, 3, 7, 0, 5, 1, 2, 0 },
 128
 129         /* ARM L4: 1100 MHz */
 130         { 0, 3, 6, 0, 4, 1, 2, 0 },
 131
 132         /* ARM L5: 1000 MHz */
 133         { 0, 2, 5, 0, 4, 1, 1, 0 },
 134
 135         /* ARM L6: 900 MHz */
 136         { 0, 2, 5, 0, 3, 1, 1, 0 },
 137
 138         /* ARM L7: 800 MHz */
 139         { 0, 2, 5, 0, 3, 1, 1, 0 },
 140
 141         /* ARM L8: 700 MHz */
 142         { 0, 2, 4, 0, 3, 1, 1, 0 },
 143
 144         /* ARM L9: 600 MHz */
 145         { 0, 2, 4, 0, 3, 1, 1, 0 },
 146
 147         /* ARM L10: 500 MHz */
 148         { 0, 2, 4, 0, 3, 1, 1, 0 },
 149
 150         /* ARM L11: 400 MHz */
 151         { 0, 2, 4, 0, 3, 1, 1, 0 },
 152
 153         /* ARM L12: 300 MHz */
 154         { 0, 2, 4, 0, 2, 1, 1, 0 },
 155
 156         /* ARM L13: 200 MHz */
 157         { 0, 1, 3, 0, 1, 1, 1, 0 },
 158 };
 159
 160 static unsigned int clkdiv_cpu1_4212[CPUFREQ_LEVEL_END][2] = {
 161         /* Clock divider value for following
 162          * { DIVCOPY, DIVHPM }
 163          */
 164         /* ARM L0: 1500 MHz */
 165         { 6, 0 },
 166
 167         /* ARM L1: 1400 MHz */
 168         { 6, 0 },
 169
 170         /* ARM L2: 1300 MHz */
 171         { 5, 0 },
 172
 173         /* ARM L3: 1200 MHz */
 174         { 5, 0 },
 175
 176         /* ARM L4: 1100 MHz */
 177         { 4, 0 },
 178
 179         /* ARM L5: 1000 MHz */
 180         { 4, 0 },
 181
 182         /* ARM L6: 900 MHz */
 183         { 3, 0 },
 184
 185         /* ARM L7: 800 MHz */
 186         { 3, 0 },
 187
 188         /* ARM L8: 700 MHz */
 189         { 3, 0 },
 190
 191         /* ARM L9: 600 MHz */
 192         { 3, 0 },
 193
 194         /* ARM L10: 500 MHz */
 195         { 3, 0 },
 196
 197         /* ARM L11: 400 MHz */
 198         { 3, 0 },
 199
 200         /* ARM L12: 300 MHz */
 201         { 3, 0 },
 202
 203         /* ARM L13: 200 MHz */
 204         { 3, 0 },
 205 };
 206
 207 static unsigned int clkdiv_cpu1_4412[CPUFREQ_LEVEL_END][3] = {
 208         /* Clock divider value for following
 209          * { DIVCOPY, DIVHPM, DIVCORES }
 210          */
 211         /* ARM L0: 1500 MHz */
 212         { 6, 0, 7 },
 213
 214         /* ARM L1: 1400 MHz */
 215         { 6, 0, 6 },
 216
 217         /* ARM L2: 1300 MHz */
 218         { 5, 0, 6 },
 219
 220         /* ARM L3: 1200 MHz */
 221         { 5, 0, 5 },
 222
 223         /* ARM L4: 1100 MHz */
 224         { 4, 0, 5 },
 225
 226         /* ARM L5: 1000 MHz */
 227         { 4, 0, 4 },
 228
 229         /* ARM L6: 900 MHz */
 230         { 3, 0, 4 },
 231
 232         /* ARM L7: 800 MHz */
 233         { 3, 0, 3 },
 234
 235         /* ARM L8: 700 MHz */
 236         { 3, 0, 3 },
 237
 238         /* ARM L9: 600 MHz */
 239         { 3, 0, 2 },
 240
 241         /* ARM L10: 500 MHz */
 242         { 3, 0, 2 },
 243
 244         /* ARM L11: 400 MHz */
 245         { 3, 0, 1 },
 246
 247         /* ARM L12: 300 MHz */
 248         { 3, 0, 1 },
 249
 250         /* ARM L13: 200 MHz */
 251         { 3, 0, 0 },
 252 };
 253
 254 static unsigned int exynos4x12_apll_pms_table[CPUFREQ_LEVEL_END] = {
 255         /* APLL FOUT L0: 1500 MHz */
 256         ((250 << 16) | (4 << 8) | (0x0)),
 257
 258         /* APLL FOUT L1: 1400 MHz */
 259         ((175 << 16) | (3 << 8) | (0x0)),
 260
 261         /* APLL FOUT L2: 1300 MHz */
 262         ((325 << 16) | (6 << 8) | (0x0)),
 263
 264         /* APLL FOUT L3: 1200 MHz */
 265         ((200 << 16) | (4 << 8) | (0x0)),
 266
 267         /* APLL FOUT L4: 1100 MHz */
 268         ((275 << 16) | (6 << 8) | (0x0)),
 269
 270         /* APLL FOUT L5: 1000 MHz */
 271         ((125 << 16) | (3 << 8) | (0x0)),
 272
 273         /* APLL FOUT L6: 900 MHz */
 274         ((150 << 16) | (4 << 8) | (0x0)),
 275
 276         /* APLL FOUT L7: 800 MHz */
 277         ((100 << 16) | (3 << 8) | (0x0)),
 278
 279         /* APLL FOUT L8: 700 MHz */
 280         ((175 << 16) | (3 << 8) | (0x1)),
 281
 282         /* APLL FOUT L9: 600 MHz */
 283         ((200 << 16) | (4 << 8) | (0x1)),
 284
 285         /* APLL FOUT L10: 500 MHz */
 286         ((125 << 16) | (3 << 8) | (0x1)),
 287
 288         /* APLL FOUT L11 400 MHz */
 289         ((100 << 16) | (3 << 8) | (0x1)),
 290
 291         /* APLL FOUT L12: 300 MHz */
 292         ((200 << 16) | (4 << 8) | (0x2)),
 293
 294         /* APLL FOUT L13: 200 MHz */
 295         ((100 << 16) | (3 << 8) | (0x2)),
 296 };
 297
 298 static const unsigned int asv_voltage_4x12[CPUFREQ_LEVEL_END] = {
 299         1350000, 1287500, 1250000, 1187500, 1137500, 1087500, 1037500,
 300         1000000,  987500,  975000,  950000,  925000,  900000,  900000
 301 };
 302
 303 static void exynos4x12_set_clkdiv(unsigned int div_index)
 304 {
 305         unsigned int tmp;
 306         unsigned int stat_cpu1;
 307
 308         /* Change Divider - CPU0 */
 309
 310         tmp = exynos4x12_clkdiv_table[div_index].clkdiv;
 311
 312         __raw_writel(tmp, EXYNOS4_CLKDIV_CPU);
 313
 314         while (__raw_readl(EXYNOS4_CLKDIV_STATCPU) & 0x11111111)
 315                 cpu_relax();
 316
 317         /* Change Divider - CPU1 */
 318         tmp = exynos4x12_clkdiv_table[div_index].clkdiv1;
 319
 320         __raw_writel(tmp, EXYNOS4_CLKDIV_CPU1);
 321         if (soc_is_exynos4212())
 322                 stat_cpu1 = 0x11;
 323         else
 324                 stat_cpu1 = 0x111;
 325
 326         while (__raw_readl(EXYNOS4_CLKDIV_STATCPU1) & stat_cpu1)
 327                 cpu_relax();
 328 }
 329
 330 static void exynos4x12_set_apll(unsigned int index)
 331 {
 332         unsigned int tmp, pdiv;
 333
 334         /* 1. MUX_CORE_SEL = MPLL, ARMCLK uses MPLL for lock time */
 335         clk_set_parent(moutcore, mout_mpll);
 336
 337         do {
 338                 cpu_relax();
 339                 tmp = (__raw_readl(EXYNOS4_CLKMUX_STATCPU)
 340                         >> EXYNOS4_CLKSRC_CPU_MUXCORE_SHIFT);
 341                 tmp &= 0x7;
 342         } while (tmp != 0x2);
 343
 344         /* 2. Set APLL Lock time */
 345         pdiv = ((exynos4x12_apll_pms_table[index] >> 8) & 0x3f);
 346
 347         __raw_writel((pdiv * 250), EXYNOS4_APLL_LOCK);
 348
 349         /* 3. Change PLL PMS values */
 350         tmp = __raw_readl(EXYNOS4_APLL_CON0);
 351         tmp &= ~((0x3ff << 16) | (0x3f << 8) | (0x7 << 0));
 352         tmp |= exynos4x12_apll_pms_table[index];
 353         __raw_writel(tmp, EXYNOS4_APLL_CON0);
 354
 355         /* 4. wait_lock_time */
 356         do {
 357                 cpu_relax();
 358                 tmp = __raw_readl(EXYNOS4_APLL_CON0);
 359         } while (!(tmp & (0x1 << EXYNOS4_APLLCON0_LOCKED_SHIFT)));
 360
 361         /* 5. MUX_CORE_SEL = APLL */
 362         clk_set_parent(moutcore, mout_apll);
 363
 364         do {
 365                 cpu_relax();
 366                 tmp = __raw_readl(EXYNOS4_CLKMUX_STATCPU);
 367                 tmp &= EXYNOS4_CLKMUX_STATCPU_MUXCORE_MASK;
 368         } while (tmp != (0x1 << EXYNOS4_CLKSRC_CPU_MUXCORE_SHIFT));
 369 }
 370
 371 bool exynos4x12_pms_change(unsigned int old_index, unsigned int new_index)
 372 {
 373         unsigned int old_pm = exynos4x12_apll_pms_table[old_index] >> 8;
 374         unsigned int new_pm = exynos4x12_apll_pms_table[new_index] >> 8;
 375
 376         return (old_pm == new_pm) ? 0 : 1;
 377 }
 378
 379 static void exynos4x12_set_frequency(unsigned int old_index,
 380                                   unsigned int new_index)
 381 {
 382         unsigned int tmp;
 383
 384         if (old_index > new_index) {
 385                 if (!exynos4x12_pms_change(old_index, new_index)) {
 386                         /* 1. Change the system clock divider values */
 387                         exynos4x12_set_clkdiv(new_index);
 388                         /* 2. Change just s value in apll m,p,s value */
 389                         tmp = __raw_readl(EXYNOS4_APLL_CON0);
 390                         tmp &= ~(0x7 << 0);
 391                         tmp |= (exynos4x12_apll_pms_table[new_index] & 0x7);
 392                         __raw_writel(tmp, EXYNOS4_APLL_CON0);
 393
 394                 } else {
 395                         /* Clock Configuration Procedure */
 396                         /* 1. Change the system clock divider values */
 397                         exynos4x12_set_clkdiv(new_index);
 398                         /* 2. Change the apll m,p,s value */
 399                         exynos4x12_set_apll(new_index);
 400                 }
 401         } else if (old_index < new_index) {
 402                 if (!exynos4x12_pms_change(old_index, new_index)) {
 403                         /* 1. Change just s value in apll m,p,s value */
 404                         tmp = __raw_readl(EXYNOS4_APLL_CON0);
 405                         tmp &= ~(0x7 << 0);
 406                         tmp |= (exynos4x12_apll_pms_table[new_index] & 0x7);
 407                         __raw_writel(tmp, EXYNOS4_APLL_CON0);
 408                         /* 2. Change the system clock divider values */
 409                         exynos4x12_set_clkdiv(new_index);
 410                 } else {
 411                         /* Clock Configuration Procedure */
 412                         /* 1. Change the apll m,p,s value */
 413                         exynos4x12_set_apll(new_index);
 414                         /* 2. Change the system clock divider values */
 415                         exynos4x12_set_clkdiv(new_index);
 416                 }
 417         }
 418 }
 419
 420 static void __init set_volt_table(void)
 421 {
 422         unsigned int i;
 423
 424         max_support_idx = L1;
 425
 426         /* Not supported */
 427         exynos4x12_freq_table[L0].frequency = CPUFREQ_ENTRY_INVALID;
 428
 429         for (i = 0 ; i < CPUFREQ_LEVEL_END ; i++)
 430                 exynos4x12_volt_table[i] = asv_voltage_4x12[i];
 431 }
 432
 433 int exynos4x12_cpufreq_init(struct exynos_dvfs_info *info)
 434 {
 435         int i;
 436         unsigned int tmp;
 437         unsigned long rate;
 438
 439         set_volt_table();
 440
 441         cpu_clk = clk_get(NULL, "armclk");
 442         if (IS_ERR(cpu_clk))
 443                 return PTR_ERR(cpu_clk);
 444
 445         moutcore = clk_get(NULL, "moutcore");
 446         if (IS_ERR(moutcore))
 447                 goto err_moutcore;
 448
 449         mout_mpll = clk_get(NULL, "mout_mpll");
 450         if (IS_ERR(mout_mpll))
 451                 goto err_mout_mpll;
 452
 453         rate = clk_get_rate(mout_mpll) / 1000;
 454
 455         mout_apll = clk_get(NULL, "mout_apll");
 456         if (IS_ERR(mout_apll))
 457                 goto err_mout_apll;
 458
 459         for (i = L0; i <  CPUFREQ_LEVEL_END; i++) {
 460
 461                 exynos4x12_clkdiv_table[i].index = i;
 462
 463                 tmp = __raw_readl(EXYNOS4_CLKDIV_CPU);
 464
 465                 tmp &= ~(EXYNOS4_CLKDIV_CPU0_CORE_MASK |
 466                         EXYNOS4_CLKDIV_CPU0_COREM0_MASK |
 467                         EXYNOS4_CLKDIV_CPU0_COREM1_MASK |
 468                         EXYNOS4_CLKDIV_CPU0_PERIPH_MASK |
 469                         EXYNOS4_CLKDIV_CPU0_ATB_MASK |
 470                         EXYNOS4_CLKDIV_CPU0_PCLKDBG_MASK |
 471                         EXYNOS4_CLKDIV_CPU0_APLL_MASK);
 472
 473                 if (soc_is_exynos4212()) {
 474                         tmp |= ((clkdiv_cpu0_4212[i][0] << EXYNOS4_CLKDIV_CPU0_CORE_SHIFT) |
 475                                 (clkdiv_cpu0_4212[i][1] << EXYNOS4_CLKDIV_CPU0_COREM0_SHIFT) |
 476                                 (clkdiv_cpu0_4212[i][2] << EXYNOS4_CLKDIV_CPU0_COREM1_SHIFT) |
 477                                 (clkdiv_cpu0_4212[i][3] << EXYNOS4_CLKDIV_CPU0_PERIPH_SHIFT) |
 478                                 (clkdiv_cpu0_4212[i][4] << EXYNOS4_CLKDIV_CPU0_ATB_SHIFT) |
 479                                 (clkdiv_cpu0_4212[i][5] << EXYNOS4_CLKDIV_CPU0_PCLKDBG_SHIFT) |
 480                                 (clkdiv_cpu0_4212[i][6] << EXYNOS4_CLKDIV_CPU0_APLL_SHIFT));
 481                 } else {
 482                         tmp &= ~EXYNOS4_CLKDIV_CPU0_CORE2_MASK;
 483
 484                         tmp |= ((clkdiv_cpu0_4412[i][0] << EXYNOS4_CLKDIV_CPU0_CORE_SHIFT) |
 485                                 (clkdiv_cpu0_4412[i][1] << EXYNOS4_CLKDIV_CPU0_COREM0_SHIFT) |
 486                                 (clkdiv_cpu0_4412[i][2] << EXYNOS4_CLKDIV_CPU0_COREM1_SHIFT) |
 487                                 (clkdiv_cpu0_4412[i][3] << EXYNOS4_CLKDIV_CPU0_PERIPH_SHIFT) |
 488                                 (clkdiv_cpu0_4412[i][4] << EXYNOS4_CLKDIV_CPU0_ATB_SHIFT) |
 489                                 (clkdiv_cpu0_4412[i][5] << EXYNOS4_CLKDIV_CPU0_PCLKDBG_SHIFT) |
 490                                 (clkdiv_cpu0_4412[i][6] << EXYNOS4_CLKDIV_CPU0_APLL_SHIFT) |
 491                                 (clkdiv_cpu0_4412[i][7] << EXYNOS4_CLKDIV_CPU0_CORE2_SHIFT));
 492                 }
 493
 494                 exynos4x12_clkdiv_table[i].clkdiv = tmp;
 495
 496                 tmp = __raw_readl(EXYNOS4_CLKDIV_CPU1);
 497
 498                 if (soc_is_exynos4212()) {
 499                         tmp &= ~(EXYNOS4_CLKDIV_CPU1_COPY_MASK |
 500                                 EXYNOS4_CLKDIV_CPU1_HPM_MASK);
 501                         tmp |= ((clkdiv_cpu1_4212[i][0] << EXYNOS4_CLKDIV_CPU1_COPY_SHIFT) |
 502                                 (clkdiv_cpu1_4212[i][1] << EXYNOS4_CLKDIV_CPU1_HPM_SHIFT));
 503                 } else {
 504                         tmp &= ~(EXYNOS4_CLKDIV_CPU1_COPY_MASK |
 505                                 EXYNOS4_CLKDIV_CPU1_HPM_MASK |
 506                                 EXYNOS4_CLKDIV_CPU1_CORES_MASK);
 507                         tmp |= ((clkdiv_cpu1_4412[i][0] << EXYNOS4_CLKDIV_CPU1_COPY_SHIFT) |
 508                                 (clkdiv_cpu1_4412[i][1] << EXYNOS4_CLKDIV_CPU1_HPM_SHIFT) |
 509                                 (clkdiv_cpu1_4412[i][2] << EXYNOS4_CLKDIV_CPU1_CORES_SHIFT));
 510                 }
 511                 exynos4x12_clkdiv_table[i].clkdiv1 = tmp;
 512         }
 513
 514         info->mpll_freq_khz = rate;
 515         info->pm_lock_idx = L5;
 516         info->pll_safe_idx = L7;
 517         info->max_support_idx = max_support_idx;
 518         info->min_support_idx = min_support_idx;
 519         info->cpu_clk = cpu_clk;
 520         info->volt_table = exynos4x12_volt_table;
 521         info->freq_table = exynos4x12_freq_table;
 522         info->set_freq = exynos4x12_set_frequency;
 523         info->need_apll_change = exynos4x12_pms_change;
 524
 525         return 0;
 526
 527 err_mout_apll:
 528         clk_put(mout_mpll);
 529 err_mout_mpll:
 530         clk_put(moutcore);
 531 err_moutcore:
 532         clk_put(cpu_clk);
 533
 534         pr_debug("%s: failed initialization\n", __func__);
 535         return -EINVAL;
 536 }
 537 EXPORT_SYMBOL(exynos4x12_cpufreq_init);