drivers/cpufreq/omap-cpufreq.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  CPU frequency scaling for OMAP using OPP information
   4  *
   5  *  Copyright (C) 2005 Nokia Corporation
   6  *  Written by Tony Lindgren <tony@atomide.com>
   7  *
   8  *  Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
   9  *
  10  * Copyright (C) 2007-2011 Texas Instruments, Inc.
  11  * - OMAP3/4 support by Rajendra Nayak, Santosh Shilimkar
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/types.h>
  17 #include <linux/kernel.h>
  18 #include <linux/sched.h>
  19 #include <linux/cpufreq.h>
  20 #include <linux/delay.h>
  21 #include <linux/init.h>
  22 #include <linux/err.h>
  23 #include <linux/clk.h>
  24 #include <linux/io.h>
  25 #include <linux/pm_opp.h>
  26 #include <linux/cpu.h>
  27 #include <linux/module.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/regulator/consumer.h>
  30
  31 /* OPP tolerance in percentage */
  32 #define OPP_TOLERANCE   4
  33
  34 static struct cpufreq_frequency_table *freq_table;
  35 static atomic_t freq_table_users = ATOMIC_INIT(0);
  36 static struct device *mpu_dev;
  37 static struct regulator *mpu_reg;
  38
  39 static int omap_target(struct cpufreq_policy *policy, unsigned int index)
  40 {
  41         int r, ret;
  42         struct dev_pm_opp *opp;
  43         unsigned long freq, volt = 0, volt_old = 0, tol = 0;
  44         unsigned int old_freq, new_freq;
  45
  46         old_freq = policy->cur;
  47         new_freq = freq_table[index].frequency;
  48
  49         freq = new_freq * 1000;
  50         ret = clk_round_rate(policy->clk, freq);
  51         if (ret < 0) {
  52                 dev_warn(mpu_dev,
  53                          "CPUfreq: Cannot find matching frequency for %lu\n",
  54                          freq);
  55                 return ret;
  56         }
  57         freq = ret;
  58
  59         if (mpu_reg) {
  60                 opp = dev_pm_opp_find_freq_ceil(mpu_dev, &freq);
  61                 if (IS_ERR(opp)) {
  62                         dev_err(mpu_dev, "%s: unable to find MPU OPP for %d\n",
  63                                 __func__, new_freq);
  64                         return -EINVAL;
  65                 }
  66                 volt = dev_pm_opp_get_voltage(opp);
  67                 dev_pm_opp_put(opp);
  68                 tol = volt * OPP_TOLERANCE / 100;
  69                 volt_old = regulator_get_voltage(mpu_reg);
  70         }
  71
  72         dev_dbg(mpu_dev, "cpufreq-omap: %u MHz, %ld mV --> %u MHz, %ld mV\n",
  73                 old_freq / 1000, volt_old ? volt_old / 1000 : -1,
  74                 new_freq / 1000, volt ? volt / 1000 : -1);
  75
  76         /* scaling up?  scale voltage before frequency */
  77         if (mpu_reg && (new_freq > old_freq)) {
  78                 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol);
  79                 if (r < 0) {
  80                         dev_warn(mpu_dev, "%s: unable to scale voltage up.\n",
  81                                  __func__);
  82                         return r;
  83                 }
  84         }
  85
  86         ret = clk_set_rate(policy->clk, new_freq * 1000);
  87
  88         /* scaling down?  scale voltage after frequency */
  89         if (mpu_reg && (new_freq < old_freq)) {
  90                 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol);
  91                 if (r < 0) {
  92                         dev_warn(mpu_dev, "%s: unable to scale voltage down.\n",
  93                                  __func__);
  94                         clk_set_rate(policy->clk, old_freq * 1000);
  95                         return r;
  96                 }
  97         }
  98
  99         return ret;
 100 }
 101
 102 static inline void freq_table_free(void)
 103 {
 104         if (atomic_dec_and_test(&freq_table_users))
 105                 dev_pm_opp_free_cpufreq_table(mpu_dev, &freq_table);
 106 }
 107
 108 static int omap_cpu_init(struct cpufreq_policy *policy)
 109 {
 110         int result;
 111
 112         policy->clk = clk_get(NULL, "cpufreq_ck");
 113         if (IS_ERR(policy->clk))
 114                 return PTR_ERR(policy->clk);
 115
 116         if (!freq_table) {
 117                 result = dev_pm_opp_init_cpufreq_table(mpu_dev, &freq_table);
 118                 if (result) {
 119                         dev_err(mpu_dev,
 120                                 "%s: cpu%d: failed creating freq table[%d]\n",
 121                                 __func__, policy->cpu, result);
 122                         clk_put(policy->clk);
 123                         return result;
 124                 }
 125         }
 126
 127         atomic_inc_return(&freq_table_users);
 128
 129         /* FIXME: what's the actual transition time? */
 130         cpufreq_generic_init(policy, freq_table, 300 * 1000);
 131
 132         return 0;
 133 }
 134
 135 static void omap_cpu_exit(struct cpufreq_policy *policy)
 136 {
 137         freq_table_free();
 138         clk_put(policy->clk);
 139 }
 140
 141 static struct cpufreq_driver omap_driver = {
 142         .flags          = CPUFREQ_NEED_INITIAL_FREQ_CHECK,
 143         .verify         = cpufreq_generic_frequency_table_verify,
 144         .target_index   = omap_target,
 145         .get            = cpufreq_generic_get,
 146         .init           = omap_cpu_init,
 147         .exit           = omap_cpu_exit,
 148         .register_em    = cpufreq_register_em_with_opp,
 149         .name           = "omap",
 150         .attr           = cpufreq_generic_attr,
 151 };
 152
 153 static int omap_cpufreq_probe(struct platform_device *pdev)
 154 {
 155         mpu_dev = get_cpu_device(0);
 156         if (!mpu_dev) {
 157                 pr_warn("%s: unable to get the MPU device\n", __func__);
 158                 return -EINVAL;
 159         }
 160
 161         mpu_reg = regulator_get(mpu_dev, "vcc");
 162         if (IS_ERR(mpu_reg)) {
 163                 pr_warn("%s: unable to get MPU regulator\n", __func__);
 164                 mpu_reg = NULL;
 165         } else {
 166                 /*
 167                  * Ensure physical regulator is present.
 168                  * (e.g. could be dummy regulator.)
 169                  */
 170                 if (regulator_get_voltage(mpu_reg) < 0) {
 171                         pr_warn("%s: physical regulator not present for MPU\n",
 172                                 __func__);
 173                         regulator_put(mpu_reg);
 174                         mpu_reg = NULL;
 175                 }
 176         }
 177
 178         return cpufreq_register_driver(&omap_driver);
 179 }
 180
 181 static void omap_cpufreq_remove(struct platform_device *pdev)
 182 {
 183         cpufreq_unregister_driver(&omap_driver);
 184 }
 185
 186 static struct platform_driver omap_cpufreq_platdrv = {
 187         .driver = {
 188                 .name   = "omap-cpufreq",
 189         },
 190         .probe          = omap_cpufreq_probe,
 191         .remove         = omap_cpufreq_remove,
 192 };
 193 module_platform_driver(omap_cpufreq_platdrv);
 194
 195 MODULE_DESCRIPTION("cpufreq driver for OMAP SoCs");
 196 MODULE_LICENSE("GPL");