arch/arm/plat-rk/ddr_freq.c

   1 #define pr_fmt(fmt) "ddrfreq: " fmt
   2 #include <linux/clk.h>
   3 #include <linux/cpu.h>
   4 #include <linux/cpufreq.h>
   5 #include <linux/delay.h>
   6 #include <linux/earlysuspend.h>
   7 #include <linux/freezer.h>
   8 #include <linux/fs.h>
   9 #include <linux/kthread.h>
  10 #include <linux/miscdevice.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/uaccess.h>
  14
  15 #include <mach/board.h>
  16 #include <mach/clock.h>
  17 #include <mach/ddr.h>
  18 #include <mach/dvfs.h>
  19
  20 enum {
  21         DEBUG_DDR = 1U << 0,
  22         DEBUG_VIDEO_STATE = 1U << 1,
  23         DEBUG_SUSPEND = 1U << 2,
  24         DEBUG_VERBOSE = 1U << 3,
  25 };
  26 static int debug_mask = DEBUG_DDR;
  27 module_param(debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
  28 #define dprintk(mask, fmt, ...) do { if (mask & debug_mask) pr_info(fmt, ##__VA_ARGS__); } while (0)
  29
  30 #define MHZ     (1000*1000)
  31 #define KHZ     1000
  32
  33 enum SYS_STATUS {
  34         SYS_STATUS_SUSPEND = 0, // 0x01
  35         SYS_STATUS_VIDEO,       // 0x02
  36         SYS_STATUS_GPU,         // 0x04
  37         SYS_STATUS_RGA,         // 0x08
  38         SYS_STATUS_CIF0,        // 0x10
  39         SYS_STATUS_CIF1,        // 0x20
  40 };
  41
  42 struct ddr {
  43 #ifdef CONFIG_HAS_EARLYSUSPEND
  44         struct early_suspend early_suspend;
  45 #endif
  46         struct clk *pll;
  47         struct clk *clk;
  48         unsigned long normal_rate;
  49         unsigned long video_rate;
  50         unsigned long idle_rate;
  51         unsigned long suspend_rate;
  52         char video_state;
  53         bool auto_self_refresh;
  54         char *mode;
  55         unsigned long sys_status;
  56         struct task_struct *task;
  57         wait_queue_head_t wait;
  58 };
  59 static struct ddr ddr;
  60
  61 module_param_named(sys_status, ddr.sys_status, ulong, S_IRUGO);
  62 module_param_named(video_state, ddr.video_state, byte, S_IRUGO);
  63 module_param_named(auto_self_refresh, ddr.auto_self_refresh, bool, S_IRUGO);
  64 module_param_named(mode, ddr.mode, charp, S_IRUGO);
  65
  66 static noinline void ddrfreq_set_sys_status(enum SYS_STATUS status)
  67 {
  68         set_bit(status, &ddr.sys_status);
  69         wake_up(&ddr.wait);
  70 }
  71
  72 static noinline void ddrfreq_clear_sys_status(enum SYS_STATUS status)
  73 {
  74         clear_bit(status, &ddr.sys_status);
  75         wake_up(&ddr.wait);
  76 }
  77
  78 static void ddrfreq_mode(bool auto_self_refresh, unsigned long *target_rate, char *name)
  79 {
  80         ddr.mode = name;
  81         if (auto_self_refresh != ddr.auto_self_refresh) {
  82                 ddr_set_auto_self_refresh(auto_self_refresh);
  83                 ddr.auto_self_refresh = auto_self_refresh;
  84                 dprintk(DEBUG_DDR, "change auto self refresh to %d when %s\n", auto_self_refresh, name);
  85         }
  86         if (*target_rate != clk_get_rate(ddr.clk)) {
  87                 if (clk_set_rate(ddr.clk, *target_rate) == 0) {
  88                         *target_rate = clk_get_rate(ddr.clk);
  89                         dprintk(DEBUG_DDR, "change freq to %lu MHz when %s\n", *target_rate / MHZ, name);
  90                 }
  91         }
  92 }
  93
  94 static noinline void ddrfreq_work(unsigned long sys_status)
  95 {
  96         static struct clk *cpu = NULL;
  97         static struct clk *gpu = NULL;
  98         unsigned long s = sys_status;
  99
 100         if (!cpu)
 101                 cpu = clk_get(NULL, "cpu");
 102         if (!gpu)
 103                 gpu = clk_get(NULL, "gpu");
 104         dprintk(DEBUG_VERBOSE, "sys_status %02lx\n", sys_status);
 105         if (ddr.suspend_rate && (s & (1 << SYS_STATUS_SUSPEND))) {
 106                 ddrfreq_mode(true, &ddr.suspend_rate, "suspend");
 107         } else if (ddr.video_rate && (s & (1 << SYS_STATUS_VIDEO))) {
 108                 ddrfreq_mode(false, &ddr.video_rate, "video");
 109         } else if (ddr.idle_rate
 110                 && !(s & (1 << SYS_STATUS_GPU))
 111                 && !(s & (1 << SYS_STATUS_RGA))
 112                 && !(s & (1 << SYS_STATUS_CIF0))
 113                 && !(s & (1 << SYS_STATUS_CIF1))
 114                 && (clk_get_rate(cpu) < 816 * MHZ)
 115                 && (clk_get_rate(gpu) <= 200 * MHZ)
 116                 ) {
 117                 ddrfreq_mode(false, &ddr.idle_rate, "idle");
 118         } else {
 119                 ddrfreq_mode(false, &ddr.normal_rate, "normal");
 120         }
 121 }
 122
 123 static int ddrfreq_task(void *data)
 124 {
 125         set_freezable();
 126
 127         do {
 128                 unsigned long status = ddr.sys_status;
 129                 ddrfreq_work(status);
 130                 wait_event_freezable(ddr.wait, (status != ddr.sys_status) || kthread_should_stop());
 131         } while (!kthread_should_stop());
 132
 133         return 0;
 134 }
 135
 136 #ifdef CONFIG_SMP
 137 static volatile bool __sramdata cpu1_pause;
 138 static inline bool is_cpu1_paused(void) { smp_rmb(); return cpu1_pause; }
 139 static inline void set_cpu1_pause(bool pause) { cpu1_pause = pause; smp_wmb(); }
 140 #define MAX_TIMEOUT (16000000UL << 6) //>0.64s
 141
 142 static void __ddr_change_freq(void *info)
 143 {
 144         uint32_t *value = info;
 145         u32 timeout = MAX_TIMEOUT;
 146
 147         while (!is_cpu1_paused() && --timeout);
 148         if (timeout == 0)
 149                 return;
 150
 151         *value = ddr_change_freq(*value);
 152
 153         set_cpu1_pause(false);
 154 }
 155
 156 /* Do not use stack, safe on SMP */
 157 static void __sramfunc pause_cpu1(void *info)
 158 {
 159         u32 timeout = MAX_TIMEOUT;
 160         unsigned long flags;
 161         local_irq_save(flags);
 162
 163         set_cpu1_pause(true);
 164         while (is_cpu1_paused() && --timeout);
 165
 166         local_irq_restore(flags);
 167 }
 168
 169 static uint32_t _ddr_change_freq(uint32_t nMHz)
 170 {
 171         int this_cpu = get_cpu();
 172
 173         set_cpu1_pause(false);
 174         if (this_cpu == 0) {
 175                 if (smp_call_function_single(1, (smp_call_func_t)pause_cpu1, NULL, 0) == 0) {
 176                         u32 timeout = MAX_TIMEOUT;
 177                         while (!is_cpu1_paused() && --timeout);
 178                         if (timeout == 0)
 179                                 goto out;
 180                 }
 181
 182                 nMHz = ddr_change_freq(nMHz);
 183
 184                 set_cpu1_pause(false);
 185         } else {
 186                 smp_call_function_single(0, __ddr_change_freq, &nMHz, 0);
 187
 188                 pause_cpu1(NULL);
 189         }
 190
 191 out:
 192         put_cpu();
 193
 194         return nMHz;
 195 }
 196 #else
 197 static uint32_t _ddr_change_freq(uint32_t nMHz)
 198 {
 199         return ddr_change_freq(nMHz);
 200 }
 201 #endif
 202
 203 uint32_t ddr_set_rate(uint32_t nMHz)
 204 {
 205         nMHz = _ddr_change_freq(nMHz);
 206         clk_set_rate(ddr.pll, 0);
 207         return nMHz;
 208 }
 209
 210 #ifdef CONFIG_HAS_EARLYSUSPEND
 211 static void ddrfreq_early_suspend(struct early_suspend *h)
 212 {
 213         dprintk(DEBUG_SUSPEND, "early suspend\n");
 214         ddrfreq_set_sys_status(SYS_STATUS_SUSPEND);
 215 }
 216
 217 static void ddrfreq_late_resume(struct early_suspend *h)
 218 {
 219         dprintk(DEBUG_SUSPEND, "late resume\n");
 220         ddrfreq_clear_sys_status(SYS_STATUS_SUSPEND);
 221 }
 222 #endif
 223
 224 static int video_state_release(struct inode *inode, struct file *file)
 225 {
 226         dprintk(DEBUG_VIDEO_STATE, "video_state release\n");
 227         ddr.video_state = '0';
 228         ddrfreq_clear_sys_status(SYS_STATUS_VIDEO);
 229         return 0;
 230 }
 231
 232 static ssize_t video_state_write(struct file *file, const char __user *buffer,
 233                                  size_t count, loff_t *ppos)
 234 {
 235         char state;
 236
 237         if (count < 1)
 238                 return count;
 239         if (copy_from_user(&state, buffer, 1)) {
 240                 return -EFAULT;
 241         }
 242
 243         dprintk(DEBUG_VIDEO_STATE, "video_state write %c\n", state);
 244         switch (state) {
 245         case '0':
 246                 ddrfreq_clear_sys_status(SYS_STATUS_VIDEO);
 247                 break;
 248         case '1':
 249                 ddrfreq_set_sys_status(SYS_STATUS_VIDEO);
 250                 break;
 251         default:
 252                 return -EINVAL;
 253         }
 254         ddr.video_state = state;
 255         return count;
 256 }
 257
 258 static const struct file_operations video_state_fops = {
 259         .owner  = THIS_MODULE,
 260         .release= video_state_release,
 261         .write  = video_state_write,
 262 };
 263
 264 static struct miscdevice video_state_dev = {
 265         .fops   = &video_state_fops,
 266         .name   = "video_state",
 267         .minor  = MISC_DYNAMIC_MINOR,
 268 };
 269
 270 static int ddrfreq_clk_event(enum SYS_STATUS status, unsigned long event)
 271 {
 272         switch (event) {
 273         case CLK_PRE_ENABLE:
 274                 ddrfreq_set_sys_status(status);
 275                 break;
 276         case CLK_ABORT_ENABLE:
 277         case CLK_POST_DISABLE:
 278                 ddrfreq_clear_sys_status(status);
 279                 break;
 280         }
 281
 282         return NOTIFY_OK;
 283 }
 284
 285 #define CLK_NOTIFIER(name, status) \
 286 static int ddrfreq_clk_##name##_event(struct notifier_block *this, unsigned long event, void *ptr) \
 287 { \
 288         return ddrfreq_clk_event(SYS_STATUS_##status, event); \
 289 } \
 290 static struct notifier_block ddrfreq_clk_##name##_notifier = { .notifier_call = ddrfreq_clk_##name##_event };
 291
 292 #define REGISTER_CLK_NOTIFIER(name) \
 293 do { \
 294         struct clk *clk = clk_get(NULL, #name); \
 295         clk_notifier_register(clk, &ddrfreq_clk_##name##_notifier); \
 296         clk_put(clk); \
 297 } while (0)
 298
 299 #define UNREGISTER_CLK_NOTIFIER(name) \
 300 do { \
 301         struct clk *clk = clk_get(NULL, #name); \
 302         clk_notifier_unregister(clk, &ddrfreq_clk_##name##_notifier); \
 303         clk_put(clk); \
 304 } while (0)
 305
 306 CLK_NOTIFIER(pd_gpu, GPU);
 307 CLK_NOTIFIER(pd_rga, RGA);
 308 CLK_NOTIFIER(pd_cif0, CIF0);
 309 CLK_NOTIFIER(pd_cif1, CIF1);
 310
 311 static int ddr_scale_rate_for_dvfs(struct clk *clk, unsigned long rate, dvfs_set_rate_callback set_rate)
 312 {
 313         ddr_set_rate(rate/(1000*1000));
 314         return 0;
 315 }
 316
 317 static int ddrfreq_init(void)
 318 {
 319         int i, ret;
 320         struct cpufreq_frequency_table *table;
 321         bool new_version = false;
 322
 323         init_waitqueue_head(&ddr.wait);
 324         ddr.video_state = '0';
 325         ddr.mode = "normal";
 326
 327         ddr.pll = clk_get(NULL, "ddr_pll");
 328         ddr.clk = clk_get(NULL, "ddr");
 329         if (IS_ERR(ddr.clk)) {
 330                 ret = PTR_ERR(ddr.clk);
 331                 ddr.clk = NULL;
 332                 pr_err("failed to get ddr clk, error %d\n", ret);
 333                 return ret;
 334         }
 335     dvfs_clk_register_set_rate_callback(ddr.clk, ddr_scale_rate_for_dvfs);
 336
 337         ddr.normal_rate = clk_get_rate(ddr.clk);
 338
 339         table = dvfs_get_freq_volt_table(ddr.clk);
 340         if (!table) {
 341                 pr_err("failed to get ddr freq volt table\n");
 342         }
 343
 344         for (i = 0; table && table[i].frequency != CPUFREQ_TABLE_END; i++) {
 345                 if (table[i].frequency % 1000) {
 346                         new_version = true;
 347                         break;
 348                 }
 349         }
 350         if (!new_version) {
 351                 ddr.video_rate = 300 * MHZ;
 352                 ddr.suspend_rate = 200 * MHZ;
 353         }
 354         for (i = 0; new_version && table && table[i].frequency != CPUFREQ_TABLE_END; i++) {
 355                 unsigned int mode = table[i].frequency % 1000;
 356                 unsigned long rate;
 357
 358                 table[i].frequency -= mode;
 359                 rate = table[i].frequency * 1000;
 360
 361                 switch (mode) {
 362                 case DDR_FREQ_NORMAL:
 363                         ddr.normal_rate = rate;
 364                         break;
 365                 case DDR_FREQ_VIDEO:
 366                         ddr.video_rate = rate;
 367                         break;
 368                 case DDR_FREQ_IDLE:
 369                         ddr.idle_rate = rate;
 370                         break;
 371                 case DDR_FREQ_SUSPEND:
 372                         ddr.suspend_rate = rate;
 373                         break;
 374                 }
 375         }
 376
 377         if (ddr.idle_rate) {
 378                 REGISTER_CLK_NOTIFIER(pd_gpu);
 379                 REGISTER_CLK_NOTIFIER(pd_rga);
 380                 REGISTER_CLK_NOTIFIER(pd_cif0);
 381                 REGISTER_CLK_NOTIFIER(pd_cif1);
 382         }
 383
 384         return 0;
 385
 386 }
 387 core_initcall(ddrfreq_init);
 388
 389 static int ddrfreq_late_init(void)
 390 {
 391         int ret;
 392         struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
 393
 394         if (!ddr.clk) {
 395                 return -EINVAL;
 396         }
 397
 398         ret = misc_register(&video_state_dev);
 399         if (unlikely(ret)) {
 400                 pr_err("failed to register video_state misc device! error %d\n", ret);
 401                 goto err;
 402         }
 403
 404 #ifdef CONFIG_HAS_EARLYSUSPEND
 405         ddr.early_suspend.suspend = ddrfreq_early_suspend;
 406         ddr.early_suspend.resume = ddrfreq_late_resume;
 407         ddr.early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 50;
 408         register_early_suspend(&ddr.early_suspend);
 409 #endif
 410
 411         ddr.task = kthread_create(ddrfreq_task, NULL, "ddrfreqd");
 412         if (IS_ERR(ddr.task)) {
 413                 ret = PTR_ERR(ddr.task);
 414                 pr_err("failed to create kthread! error %d\n", ret);
 415                 goto err1;
 416         }
 417
 418         sched_setscheduler_nocheck(ddr.task, SCHED_FIFO, &param);
 419         get_task_struct(ddr.task);
 420         kthread_bind(ddr.task, 0);
 421         wake_up_process(ddr.task);
 422
 423         pr_info("verion 1.1\n");
 424         dprintk(DEBUG_DDR, "normal %luMHz video %luMHz idle %luMHz suspend %luMHz\n",
 425                 ddr.normal_rate / MHZ, ddr.video_rate / MHZ, ddr.idle_rate / MHZ, ddr.suspend_rate / MHZ);
 426
 427         return 0;
 428
 429 err1:
 430 #ifdef CONFIG_HAS_EARLYSUSPEND
 431         unregister_early_suspend(&ddr.early_suspend);
 432 #endif
 433         misc_deregister(&video_state_dev);
 434 err:
 435         if (ddr.idle_rate) {
 436                 UNREGISTER_CLK_NOTIFIER(pd_gpu);
 437                 UNREGISTER_CLK_NOTIFIER(pd_rga);
 438                 UNREGISTER_CLK_NOTIFIER(pd_cif0);
 439                 UNREGISTER_CLK_NOTIFIER(pd_cif1);
 440         }
 441
 442         return ret;
 443 }
 444 late_initcall(ddrfreq_late_init);