drivers/cpufreq/exynos-cpufreq.c

   1 /*
   2  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
   3  *              http://www.samsung.com
   4  *
   5  * EXYNOS - CPU frequency scaling support for EXYNOS series
   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/kernel.h>
  13 #include <linux/err.h>
  14 #include <linux/clk.h>
  15 #include <linux/io.h>
  16 #include <linux/slab.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/cpufreq.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/of.h>
  21
  22 #include "exynos-cpufreq.h"
  23
  24 static struct exynos_dvfs_info *exynos_info;
  25 static struct regulator *arm_regulator;
  26 static unsigned int locking_frequency;
  27
  28 static int exynos_cpufreq_get_index(unsigned int freq)
  29 {
  30         struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
  31         int index;
  32
  33         for (index = 0;
  34                 freq_table[index].frequency != CPUFREQ_TABLE_END; index++)
  35                 if (freq_table[index].frequency == freq)
  36                         break;
  37
  38         if (freq_table[index].frequency == CPUFREQ_TABLE_END)
  39                 return -EINVAL;
  40
  41         return index;
  42 }
  43
  44 static int exynos_cpufreq_scale(unsigned int target_freq)
  45 {
  46         struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
  47         unsigned int *volt_table = exynos_info->volt_table;
  48         struct cpufreq_policy *policy = cpufreq_cpu_get(0);
  49         unsigned int arm_volt, safe_arm_volt = 0;
  50         unsigned int mpll_freq_khz = exynos_info->mpll_freq_khz;
  51         unsigned int old_freq;
  52         int index, old_index;
  53         int ret = 0;
  54
  55         old_freq = policy->cur;
  56
  57         /*
  58          * The policy max have been changed so that we cannot get proper
  59          * old_index with cpufreq_frequency_table_target(). Thus, ignore
  60          * policy and get the index from the raw frequency table.
  61          */
  62         old_index = exynos_cpufreq_get_index(old_freq);
  63         if (old_index < 0) {
  64                 ret = old_index;
  65                 goto out;
  66         }
  67
  68         index = exynos_cpufreq_get_index(target_freq);
  69         if (index < 0) {
  70                 ret = index;
  71                 goto out;
  72         }
  73
  74         /*
  75          * ARM clock source will be changed APLL to MPLL temporary
  76          * To support this level, need to control regulator for
  77          * required voltage level
  78          */
  79         if (exynos_info->need_apll_change != NULL) {
  80                 if (exynos_info->need_apll_change(old_index, index) &&
  81                    (freq_table[index].frequency < mpll_freq_khz) &&
  82                    (freq_table[old_index].frequency < mpll_freq_khz))
  83                         safe_arm_volt = volt_table[exynos_info->pll_safe_idx];
  84         }
  85         arm_volt = volt_table[index];
  86
  87         /* When the new frequency is higher than current frequency */
  88         if ((target_freq > old_freq) && !safe_arm_volt) {
  89                 /* Firstly, voltage up to increase frequency */
  90                 ret = regulator_set_voltage(arm_regulator, arm_volt, arm_volt);
  91                 if (ret) {
  92                         pr_err("%s: failed to set cpu voltage to %d\n",
  93                                 __func__, arm_volt);
  94                         return ret;
  95                 }
  96         }
  97
  98         if (safe_arm_volt) {
  99                 ret = regulator_set_voltage(arm_regulator, safe_arm_volt,
 100                                       safe_arm_volt);
 101                 if (ret) {
 102                         pr_err("%s: failed to set cpu voltage to %d\n",
 103                                 __func__, safe_arm_volt);
 104                         return ret;
 105                 }
 106         }
 107
 108         exynos_info->set_freq(old_index, index);
 109
 110         /* When the new frequency is lower than current frequency */
 111         if ((target_freq < old_freq) ||
 112            ((target_freq > old_freq) && safe_arm_volt)) {
 113                 /* down the voltage after frequency change */
 114                 ret = regulator_set_voltage(arm_regulator, arm_volt,
 115                                 arm_volt);
 116                 if (ret) {
 117                         pr_err("%s: failed to set cpu voltage to %d\n",
 118                                 __func__, arm_volt);
 119                         goto out;
 120                 }
 121         }
 122
 123 out:
 124         cpufreq_cpu_put(policy);
 125
 126         return ret;
 127 }
 128
 129 static int exynos_target(struct cpufreq_policy *policy, unsigned int index)
 130 {
 131         return exynos_cpufreq_scale(exynos_info->freq_table[index].frequency);
 132 }
 133
 134 static int exynos_cpufreq_cpu_init(struct cpufreq_policy *policy)
 135 {
 136         policy->clk = exynos_info->cpu_clk;
 137         policy->suspend_freq = locking_frequency;
 138         return cpufreq_generic_init(policy, exynos_info->freq_table, 100000);
 139 }
 140
 141 static struct cpufreq_driver exynos_driver = {
 142         .flags          = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
 143         .verify         = cpufreq_generic_frequency_table_verify,
 144         .target_index   = exynos_target,
 145         .get            = cpufreq_generic_get,
 146         .init           = exynos_cpufreq_cpu_init,
 147         .name           = "exynos_cpufreq",
 148         .attr           = cpufreq_generic_attr,
 149 #ifdef CONFIG_ARM_EXYNOS_CPU_FREQ_BOOST_SW
 150         .boost_supported = true,
 151 #endif
 152 #ifdef CONFIG_PM
 153         .suspend        = cpufreq_generic_suspend,
 154 #endif
 155 };
 156
 157 static int exynos_cpufreq_probe(struct platform_device *pdev)
 158 {
 159         int ret = -EINVAL;
 160
 161         exynos_info = kzalloc(sizeof(*exynos_info), GFP_KERNEL);
 162         if (!exynos_info)
 163                 return -ENOMEM;
 164
 165         if (of_machine_is_compatible("samsung,exynos4210")) {
 166                 exynos_info->type = EXYNOS_SOC_4210;
 167                 ret = exynos4210_cpufreq_init(exynos_info);
 168         } else if (of_machine_is_compatible("samsung,exynos4212")) {
 169                 exynos_info->type = EXYNOS_SOC_4212;
 170                 ret = exynos4x12_cpufreq_init(exynos_info);
 171         } else if (of_machine_is_compatible("samsung,exynos4412")) {
 172                 exynos_info->type = EXYNOS_SOC_4412;
 173                 ret = exynos4x12_cpufreq_init(exynos_info);
 174         } else if (of_machine_is_compatible("samsung,exynos5250")) {
 175                 exynos_info->type = EXYNOS_SOC_5250;
 176                 ret = exynos5250_cpufreq_init(exynos_info);
 177         } else {
 178                 pr_err("%s: Unknown SoC type\n", __func__);
 179                 return -ENODEV;
 180         }
 181
 182         if (ret)
 183                 goto err_vdd_arm;
 184
 185         if (exynos_info->set_freq == NULL) {
 186                 pr_err("%s: No set_freq function (ERR)\n", __func__);
 187                 goto err_vdd_arm;
 188         }
 189
 190         arm_regulator = regulator_get(NULL, "vdd_arm");
 191         if (IS_ERR(arm_regulator)) {
 192                 pr_err("%s: failed to get resource vdd_arm\n", __func__);
 193                 goto err_vdd_arm;
 194         }
 195
 196         /* Done here as we want to capture boot frequency */
 197         locking_frequency = clk_get_rate(exynos_info->cpu_clk) / 1000;
 198
 199         if (!cpufreq_register_driver(&exynos_driver))
 200                 return 0;
 201
 202         pr_err("%s: failed to register cpufreq driver\n", __func__);
 203         regulator_put(arm_regulator);
 204 err_vdd_arm:
 205         kfree(exynos_info);
 206         return -EINVAL;
 207 }
 208
 209 static struct platform_driver exynos_cpufreq_platdrv = {
 210         .driver = {
 211                 .name   = "exynos-cpufreq",
 212                 .owner  = THIS_MODULE,
 213         },
 214         .probe = exynos_cpufreq_probe,
 215 };
 216 module_platform_driver(exynos_cpufreq_platdrv);