drivers/cpufreq/rockchip-cpufreq.c

   1 /*
   2  * Copyright (C) 2013 ROCKCHIP, Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14 #define pr_fmt(fmt) "cpufreq: " fmt
  15 #include <linux/clk.h>
  16 #include <linux/cpufreq.h>
  17 #include <linux/err.h>
  18 #include <linux/kernel_stat.h>
  19 #include <linux/init.h>
  20 #include <linux/reboot.h>
  21 #include <linux/suspend.h>
  22 #include <linux/tick.h>
  23 #include <linux/workqueue.h>
  24 #include <linux/delay.h>
  25 #include <linux/regulator/consumer.h>
  26 #include <linux/fs.h>
  27 #include <linux/miscdevice.h>
  28 #include <linux/string.h>
  29 #include <linux/rockchip/cpu.h>
  30 #include <linux/rockchip/dvfs.h>
  31 #include <asm/smp_plat.h>
  32 #include <asm/cpu.h>
  33 #include <asm/unistd.h>
  34 #include <asm/uaccess.h>
  35 #include "../../../drivers/clk/rockchip/clk-pd.h"
  36
  37 extern void dvfs_disable_temp_limit(void);
  38
  39 #define VERSION "1.0"
  40
  41 #ifdef DEBUG
  42 #define FREQ_DBG(fmt, args...) pr_debug(fmt, ## args)
  43 #define FREQ_LOG(fmt, args...) pr_debug(fmt, ## args)
  44 #else
  45 #define FREQ_DBG(fmt, args...) do {} while(0)
  46 #define FREQ_LOG(fmt, args...) do {} while(0)
  47 #endif
  48 #define FREQ_ERR(fmt, args...) pr_err(fmt, ## args)
  49
  50 /* Frequency table index must be sequential starting at 0 */
  51 static struct cpufreq_frequency_table default_freq_table[] = {
  52         {.frequency = 312 * 1000,       .index = 875 * 1000},
  53         {.frequency = 504 * 1000,       .index = 925 * 1000},
  54         {.frequency = 816 * 1000,       .index = 975 * 1000},
  55         {.frequency = 1008 * 1000,      .index = 1075 * 1000},
  56         {.frequency = 1200 * 1000,      .index = 1150 * 1000},
  57         {.frequency = 1416 * 1000,      .index = 1250 * 1000},
  58         {.frequency = 1608 * 1000,      .index = 1350 * 1000},
  59         {.frequency = CPUFREQ_TABLE_END},
  60 };
  61 static struct cpufreq_frequency_table *freq_table = default_freq_table;
  62 /*********************************************************/
  63 /* additional symantics for "relation" in cpufreq with pm */
  64 #define DISABLE_FURTHER_CPUFREQ         0x10
  65 #define ENABLE_FURTHER_CPUFREQ          0x20
  66 #define MASK_FURTHER_CPUFREQ            0x30
  67 /* With 0x00(NOCHANGE), it depends on the previous "further" status */
  68 #define CPUFREQ_PRIVATE                 0x100
  69 static unsigned int no_cpufreq_access = 0;
  70 static unsigned int suspend_freq = 816 * 1000;
  71 static unsigned int suspend_volt = 1000000; // 1V
  72 static unsigned int low_battery_freq = 600 * 1000;
  73 static unsigned int low_battery_capacity = 5; // 5%
  74 static bool is_booting = true;
  75 static DEFINE_MUTEX(cpufreq_mutex);
  76 static bool gpu_is_mali400;
  77 struct dvfs_node *clk_cpu_dvfs_node = NULL;
  78 struct dvfs_node *clk_gpu_dvfs_node = NULL;
  79 struct dvfs_node *aclk_vio1_dvfs_node = NULL;
  80 struct dvfs_node *clk_ddr_dvfs_node = NULL;
  81 /*******************************************************/
  82 static unsigned int cpufreq_get_rate(unsigned int cpu)
  83 {
  84         if (clk_cpu_dvfs_node)
  85                 return clk_get_rate(clk_cpu_dvfs_node->clk) / 1000;
  86
  87         return 0;
  88 }
  89
  90 static bool cpufreq_is_ondemand(struct cpufreq_policy *policy)
  91 {
  92         char c = 0;
  93         if (policy && policy->governor)
  94                 c = policy->governor->name[0];
  95         return (c == 'o' || c == 'i' || c == 'c' || c == 'h');
  96 }
  97
  98 static unsigned int get_freq_from_table(unsigned int max_freq)
  99 {
 100         unsigned int i;
 101         unsigned int target_freq = 0;
 102         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
 103                 unsigned int freq = freq_table[i].frequency;
 104                 if (freq <= max_freq && target_freq < freq) {
 105                         target_freq = freq;
 106                 }
 107         }
 108         if (!target_freq)
 109                 target_freq = max_freq;
 110         return target_freq;
 111 }
 112
 113 static int cpufreq_notifier_policy(struct notifier_block *nb, unsigned long val, void *data)
 114 {
 115         static unsigned int min_rate=0, max_rate=-1;
 116         struct cpufreq_policy *policy = data;
 117
 118         if (val != CPUFREQ_ADJUST)
 119                 return 0;
 120
 121         if (cpufreq_is_ondemand(policy)) {
 122                 FREQ_DBG("queue work\n");
 123                 dvfs_clk_enable_limit(clk_cpu_dvfs_node, min_rate, max_rate);
 124         } else {
 125                 FREQ_DBG("cancel work\n");
 126                 dvfs_clk_get_limit(clk_cpu_dvfs_node, &min_rate, &max_rate);
 127         }
 128
 129         return 0;
 130 }
 131
 132 static struct notifier_block notifier_policy_block = {
 133         .notifier_call = cpufreq_notifier_policy
 134 };
 135
 136 static int cpufreq_verify(struct cpufreq_policy *policy)
 137 {
 138         if (!freq_table)
 139                 return -EINVAL;
 140         return cpufreq_frequency_table_verify(policy, freq_table);
 141 }
 142
 143 static int cpufreq_scale_rate_for_dvfs(struct clk *clk, unsigned long rate)
 144 {
 145         int ret;
 146         struct cpufreq_freqs freqs;
 147         struct cpufreq_policy *policy;
 148
 149         freqs.new = rate / 1000;
 150         freqs.old = clk_get_rate(clk) / 1000;
 151
 152         for_each_online_cpu(freqs.cpu) {
 153                 policy = cpufreq_cpu_get(freqs.cpu);
 154                 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 155                 cpufreq_cpu_put(policy);
 156         }
 157
 158         FREQ_DBG("cpufreq_scale_rate_for_dvfs(%lu)\n", rate);
 159
 160         ret = clk_set_rate(clk, rate);
 161
 162         freqs.new = clk_get_rate(clk) / 1000;
 163         /* notifiers */
 164         for_each_online_cpu(freqs.cpu) {
 165                 policy = cpufreq_cpu_get(freqs.cpu);
 166                 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 167                 cpufreq_cpu_put(policy);
 168         }
 169
 170         return ret;
 171
 172 }
 173
 174 static int cpufreq_init_cpu0(struct cpufreq_policy *policy)
 175 {
 176         unsigned int i;
 177         gpu_is_mali400 = cpu_is_rk3188();
 178
 179         clk_gpu_dvfs_node = clk_get_dvfs_node("clk_gpu");
 180         if (clk_gpu_dvfs_node){
 181                 clk_enable_dvfs(clk_gpu_dvfs_node);
 182                 if (gpu_is_mali400)
 183                         dvfs_clk_enable_limit(clk_gpu_dvfs_node, 133000000, 600000000);
 184         }
 185
 186         clk_ddr_dvfs_node = clk_get_dvfs_node("clk_ddr");
 187         if (clk_ddr_dvfs_node){
 188                 clk_enable_dvfs(clk_ddr_dvfs_node);
 189         }
 190
 191         clk_cpu_dvfs_node = clk_get_dvfs_node("clk_core");
 192         if (!clk_cpu_dvfs_node){
 193                 return -EINVAL;
 194         }
 195         dvfs_clk_register_set_rate_callback(clk_cpu_dvfs_node, cpufreq_scale_rate_for_dvfs);
 196         freq_table = dvfs_get_freq_volt_table(clk_cpu_dvfs_node);
 197         if (freq_table == NULL) {
 198                 freq_table = default_freq_table;
 199         } else {
 200                 int v = INT_MAX;
 201                 for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
 202                         if (freq_table[i].index >= suspend_volt && v > freq_table[i].index) {
 203                                 suspend_freq = freq_table[i].frequency;
 204                                 v = freq_table[i].index;
 205                         }
 206                 }
 207         }
 208         low_battery_freq = get_freq_from_table(low_battery_freq);
 209         clk_enable_dvfs(clk_cpu_dvfs_node);
 210
 211         cpufreq_register_notifier(&notifier_policy_block, CPUFREQ_POLICY_NOTIFIER);
 212
 213         printk("cpufreq version " VERSION ", suspend freq %d MHz\n", suspend_freq / 1000);
 214         return 0;
 215 }
 216
 217 static int cpufreq_init(struct cpufreq_policy *policy)
 218 {
 219         static int cpu0_err;
 220
 221         if (policy->cpu == 0) {
 222                 cpu0_err = cpufreq_init_cpu0(policy);
 223         }
 224
 225         if (cpu0_err)
 226                 return cpu0_err;
 227
 228         //set freq min max
 229         cpufreq_frequency_table_cpuinfo(policy, freq_table);
 230         //sys nod
 231         cpufreq_frequency_table_get_attr(freq_table, policy->cpu);
 232
 233
 234         policy->cur = clk_get_rate(clk_cpu_dvfs_node->clk) / 1000;
 235
 236         policy->cpuinfo.transition_latency = 40 * NSEC_PER_USEC;        // make ondemand default sampling_rate to 40000
 237
 238         /*
 239          * On SMP configuartion, both processors share the voltage
 240          * and clock. So both CPUs needs to be scaled together and hence
 241          * needs software co-ordination. Use cpufreq affected_cpus
 242          * interface to handle this scenario. Additional is_smp() check
 243          * is to keep SMP_ON_UP build working.
 244          */
 245         if (is_smp())
 246                 cpumask_setall(policy->cpus);
 247
 248         return 0;
 249
 250 }
 251
 252 static int cpufreq_exit(struct cpufreq_policy *policy)
 253 {
 254         if (policy->cpu != 0)
 255                 return 0;
 256
 257         cpufreq_frequency_table_cpuinfo(policy, freq_table);
 258         clk_put_dvfs_node(clk_cpu_dvfs_node);
 259         cpufreq_unregister_notifier(&notifier_policy_block, CPUFREQ_POLICY_NOTIFIER);
 260
 261         return 0;
 262 }
 263
 264 static struct freq_attr *cpufreq_attr[] = {
 265         &cpufreq_freq_attr_scaling_available_freqs,
 266         NULL,
 267 };
 268
 269 #ifdef CONFIG_CHARGER_DISPLAY
 270 extern int rk_get_system_battery_capacity(void);
 271 #else
 272 static int rk_get_system_battery_capacity(void) { return 100; }
 273 #endif
 274
 275 static unsigned int cpufreq_scale_limit(unsigned int target_freq, struct cpufreq_policy *policy, bool is_private)
 276 {
 277         bool is_ondemand = cpufreq_is_ondemand(policy);
 278
 279         if (!is_ondemand)
 280                 return target_freq;
 281
 282         if (is_booting) {
 283                 s64 boottime_ms = ktime_to_ms(ktime_get_boottime());
 284                 if (boottime_ms > 60 * MSEC_PER_SEC) {
 285                         is_booting = false;
 286                 } else if (target_freq > low_battery_freq &&
 287                            rk_get_system_battery_capacity() <= low_battery_capacity) {
 288                         target_freq = low_battery_freq;
 289                 }
 290         }
 291
 292         return target_freq;
 293 }
 294
 295 static int cpufreq_target(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation)
 296 {
 297         unsigned int i, new_freq = target_freq, new_rate, cur_rate;
 298         int ret = 0;
 299         bool is_private;
 300
 301         if (!freq_table) {
 302                 FREQ_ERR("no freq table!\n");
 303                 return -EINVAL;
 304         }
 305
 306         mutex_lock(&cpufreq_mutex);
 307
 308         is_private = relation & CPUFREQ_PRIVATE;
 309         relation &= ~CPUFREQ_PRIVATE;
 310
 311         if ((relation & ENABLE_FURTHER_CPUFREQ) && no_cpufreq_access)
 312                 no_cpufreq_access--;
 313         if (no_cpufreq_access) {
 314                 FREQ_LOG("denied access to %s as it is disabled temporarily\n", __func__);
 315                 ret = -EINVAL;
 316                 goto out;
 317         }
 318         if (relation & DISABLE_FURTHER_CPUFREQ)
 319                 no_cpufreq_access++;
 320         relation &= ~MASK_FURTHER_CPUFREQ;
 321
 322         ret = cpufreq_frequency_table_target(policy, freq_table, target_freq, relation, &i);
 323         if (ret) {
 324                 FREQ_ERR("no freq match for %d(ret=%d)\n", target_freq, ret);
 325                 goto out;
 326         }
 327         new_freq = freq_table[i].frequency;
 328         if (!no_cpufreq_access)
 329                 new_freq = cpufreq_scale_limit(new_freq, policy, is_private);
 330
 331         new_rate = new_freq * 1000;
 332         cur_rate = dvfs_clk_get_rate(clk_cpu_dvfs_node);
 333         FREQ_LOG("req = %7u new = %7u (was = %7u)\n", target_freq, new_freq, cur_rate / 1000);
 334         if (new_rate == cur_rate)
 335                 goto out;
 336         ret = dvfs_clk_set_rate(clk_cpu_dvfs_node, new_rate);
 337
 338 out:
 339         FREQ_DBG("set freq (%7u) end, ret %d\n", new_freq, ret);
 340         mutex_unlock(&cpufreq_mutex);
 341         return ret;
 342
 343 }
 344
 345 static int cpufreq_pm_notifier_event(struct notifier_block *this, unsigned long event, void *ptr)
 346 {
 347         int ret = NOTIFY_DONE;
 348         struct cpufreq_policy *policy = cpufreq_cpu_get(0);
 349
 350         if (!policy)
 351                 return ret;
 352
 353         if (!cpufreq_is_ondemand(policy))
 354                 goto out;
 355
 356         switch (event) {
 357         case PM_SUSPEND_PREPARE:
 358                 policy->cur++;
 359                 ret = cpufreq_driver_target(policy, suspend_freq, DISABLE_FURTHER_CPUFREQ | CPUFREQ_RELATION_H);
 360                 if (ret < 0) {
 361                         ret = NOTIFY_BAD;
 362                         goto out;
 363                 }
 364                 ret = NOTIFY_OK;
 365                 break;
 366         case PM_POST_RESTORE:
 367         case PM_POST_SUSPEND:
 368                 //if (target_freq == policy->cur) then cpufreq_driver_target
 369                 //will return, and our target will not be called, it casue
 370                 //ENABLE_FURTHER_CPUFREQ flag invalid, avoid that.
 371                 policy->cur++;
 372                 cpufreq_driver_target(policy, suspend_freq, ENABLE_FURTHER_CPUFREQ | CPUFREQ_RELATION_H);
 373                 ret = NOTIFY_OK;
 374                 break;
 375         }
 376 out:
 377         cpufreq_cpu_put(policy);
 378         return ret;
 379 }
 380
 381 static struct notifier_block cpufreq_pm_notifier = {
 382         .notifier_call = cpufreq_pm_notifier_event,
 383 };
 384
 385 static int cpufreq_reboot_notifier_event(struct notifier_block *this, unsigned long event, void *ptr)
 386 {
 387         struct cpufreq_policy *policy = cpufreq_cpu_get(0);
 388
 389         if (policy) {
 390                 is_booting = false;
 391                 policy->cur++;
 392                 cpufreq_driver_target(policy, suspend_freq, DISABLE_FURTHER_CPUFREQ | CPUFREQ_RELATION_H);
 393                 cpufreq_cpu_put(policy);
 394         }
 395
 396         return NOTIFY_OK;
 397 }
 398
 399 int rockchip_cpufreq_reboot_limit_freq(void)
 400 {
 401         dvfs_disable_temp_limit();
 402         dvfs_clk_enable_limit(clk_cpu_dvfs_node, 1000*suspend_freq, 1000*suspend_freq);
 403         printk("cpufreq: reboot set core rate=%lu, volt=%d\n", dvfs_clk_get_rate(clk_cpu_dvfs_node),
 404                 regulator_get_voltage(clk_cpu_dvfs_node->vd->regulator));
 405
 406         return 0;
 407 }
 408
 409 static struct notifier_block cpufreq_reboot_notifier = {
 410         .notifier_call = cpufreq_reboot_notifier_event,
 411 };
 412
 413 static int clk_pd_vio_notifier_call(struct notifier_block *nb, unsigned long event, void *ptr)
 414 {
 415         switch (event) {
 416         case RK_CLK_PD_PREPARE:
 417                 if (aclk_vio1_dvfs_node)
 418                         clk_enable_dvfs(aclk_vio1_dvfs_node);
 419                 break;
 420         case RK_CLK_PD_UNPREPARE:
 421                 if (aclk_vio1_dvfs_node)
 422                         clk_disable_dvfs(aclk_vio1_dvfs_node);
 423                 break;
 424         }
 425         return NOTIFY_OK;
 426 }
 427
 428 static struct notifier_block clk_pd_vio_notifier = {
 429         .notifier_call = clk_pd_vio_notifier_call,
 430 };
 431
 432
 433 static struct cpufreq_driver cpufreq_driver = {
 434         .flags = CPUFREQ_CONST_LOOPS,
 435         .verify = cpufreq_verify,
 436         .target = cpufreq_target,
 437         .get = cpufreq_get_rate,
 438         .init = cpufreq_init,
 439         .exit = cpufreq_exit,
 440         .name = "rockchip",
 441         .attr = cpufreq_attr,
 442 };
 443
 444 static int __init cpufreq_driver_init(void)
 445 {
 446         struct clk *clk;
 447
 448         clk = clk_get(NULL, "pd_vio");
 449         if (clk) {
 450                 rk_clk_pd_notifier_register(clk, &clk_pd_vio_notifier);
 451                 aclk_vio1_dvfs_node = clk_get_dvfs_node("aclk_vio1");
 452                 if (aclk_vio1_dvfs_node && __clk_is_enabled(clk)){
 453                         clk_enable_dvfs(aclk_vio1_dvfs_node);
 454                 }
 455         }
 456         register_pm_notifier(&cpufreq_pm_notifier);
 457         return cpufreq_register_driver(&cpufreq_driver);
 458 }
 459
 460 device_initcall(cpufreq_driver_init);