drivers/misc/tegra-profiler/power_clk.c

   1 /*
   2  * drivers/misc/tegra-profiler/power_clk.c
   3  *
   4  * Copyright (c) 2013-2015, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/cpufreq.h>
  20 #include <linux/clk.h>
  21 #include <linux/notifier.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/cpu.h>
  24 #include <linux/timer.h>
  25 #include <linux/err.h>
  26
  27 #include <linux/tegra_profiler.h>
  28
  29 #include "power_clk.h"
  30 #include "quadd.h"
  31 #include "hrt.h"
  32 #include "comm.h"
  33 #include "debug.h"
  34
  35 #define POWER_CLK_MAX_VALUES    32
  36
  37 typedef int (*notifier_call_ft)(struct notifier_block *,
  38                                 unsigned long, void *);
  39
  40 struct power_clk_data {
  41         unsigned long value;
  42         unsigned long prev;
  43 };
  44
  45 struct power_clk_source {
  46         int type;
  47
  48         struct clk *clkp;
  49         struct notifier_block nb;
  50
  51         int nr;
  52         struct power_clk_data data[POWER_CLK_MAX_VALUES];
  53
  54         atomic_t active;
  55         struct mutex lock;
  56 };
  57
  58 struct power_clk_context_s {
  59         struct power_clk_source cpu;
  60         struct power_clk_source gpu;
  61         struct power_clk_source emc;
  62
  63         struct timer_list timer;
  64         unsigned int period;
  65
  66         struct quadd_ctx *quadd_ctx;
  67 };
  68
  69 enum {
  70         QUADD_POWER_CLK_CPU = 1,
  71         QUADD_POWER_CLK_GPU,
  72         QUADD_POWER_CLK_EMC,
  73 };
  74
  75 static struct power_clk_context_s power_ctx;
  76
  77 static void make_sample(void)
  78 {
  79         int i;
  80         u32 extra_cpus[NR_CPUS];
  81         struct power_clk_source *s;
  82         struct quadd_iovec vec;
  83
  84         struct quadd_record_data record;
  85         struct quadd_power_rate_data *power_rate = &record.power_rate;
  86
  87         record.record_type = QUADD_RECORD_TYPE_POWER_RATE;
  88
  89         power_rate->time = quadd_get_time();
  90
  91         s = &power_ctx.cpu;
  92         mutex_lock(&s->lock);
  93         if (atomic_read(&s->active)) {
  94                 power_rate->nr_cpus = s->nr;
  95                 for (i = 0; i < s->nr; i++)
  96                         extra_cpus[i] = s->data[i].value;
  97         } else {
  98                 power_rate->nr_cpus = 0;
  99         }
 100         mutex_unlock(&s->lock);
 101
 102         s = &power_ctx.gpu;
 103         mutex_lock(&s->lock);
 104         if (atomic_read(&s->active))
 105                 power_rate->gpu = s->data[0].value;
 106         else
 107                 power_rate->gpu = 0;
 108
 109         mutex_unlock(&s->lock);
 110
 111         s = &power_ctx.emc;
 112         mutex_lock(&s->lock);
 113         if (atomic_read(&s->active))
 114                 power_rate->emc = s->data[0].value;
 115         else
 116                 power_rate->emc = 0;
 117
 118         mutex_unlock(&s->lock);
 119 /*
 120         pr_debug("make_sample: cpu: %u/%u/%u/%u, gpu: %u, emc: %u\n",
 121                  extra_cpus[0], extra_cpus[1], extra_cpus[2], extra_cpus[3],
 122                  power_rate->gpu, power_rate->emc);
 123 */
 124         vec.base = extra_cpus;
 125         vec.len = power_rate->nr_cpus * sizeof(extra_cpus[0]);
 126
 127         quadd_put_sample(&record, &vec, 1);
 128 }
 129
 130 static inline int
 131 is_data_changed(struct power_clk_source *s)
 132 {
 133         int i;
 134
 135         for (i = 0; i < s->nr; i++) {
 136                 if (s->data[i].value != s->data[i].prev)
 137                         return 1;
 138         }
 139
 140         return 0;
 141 }
 142
 143 static inline void
 144 update_data(struct power_clk_source *s)
 145 {
 146         int i;
 147
 148         for (i = 0; i < s->nr; i++)
 149                 s->data[i].prev = s->data[i].value;
 150 }
 151
 152 static void check_clks(void)
 153 {
 154         struct power_clk_source *s;
 155         int changed = 0;
 156
 157         s = &power_ctx.gpu;
 158         mutex_lock(&s->lock);
 159         if (is_data_changed(s)) {
 160                 update_data(s);
 161                 changed = 1;
 162         }
 163         mutex_unlock(&s->lock);
 164
 165         s = &power_ctx.emc;
 166         mutex_lock(&s->lock);
 167         if (is_data_changed(s)) {
 168                 update_data(s);
 169                 changed = 1;
 170         }
 171         mutex_unlock(&s->lock);
 172
 173         if (changed) {
 174                 pr_debug("gpu: %lu, emc: %lu\n",
 175                          power_ctx.gpu.data[0].value,
 176                          power_ctx.emc.data[0].value);
 177
 178                 make_sample();
 179         }
 180 }
 181
 182 static void check_source(struct power_clk_source *s)
 183 {
 184         mutex_lock(&s->lock);
 185
 186         if (!is_data_changed(s))
 187                 goto out_unlock;
 188
 189         pr_debug("cpu: %lu/%lu/%lu/%lu\n",
 190                  power_ctx.cpu.data[0].value,
 191                  power_ctx.cpu.data[1].value,
 192                  power_ctx.cpu.data[2].value,
 193                  power_ctx.cpu.data[3].value);
 194
 195         update_data(s);
 196         mutex_unlock(&s->lock);
 197
 198         make_sample();
 199         return;
 200
 201 out_unlock:
 202         mutex_unlock(&s->lock);
 203 }
 204
 205 static void
 206 read_source(struct power_clk_source *s, int cpu)
 207 {
 208         mutex_lock(&s->lock);
 209
 210         switch (s->type) {
 211         case QUADD_POWER_CLK_CPU:
 212                 /* update cpu frequency */
 213                 if (cpu < 0 || cpu >= POWER_CLK_MAX_VALUES) {
 214                         pr_err_once("error: cpu id: %d\n", cpu);
 215                         break;
 216                 }
 217
 218                 s->data[cpu].value = cpufreq_get(cpu);
 219                 pr_debug("QUADD_POWER_CLK_CPU, cpu: %d, value: %lu\n",
 220                          cpu, s->data[cpu].value);
 221                 break;
 222
 223         case QUADD_POWER_CLK_GPU:
 224                 /* update gpu frequency */
 225                 s->clkp = clk_get_sys("3d", NULL);
 226                 if (!IS_ERR_OR_NULL(s->clkp)) {
 227                         s->data[0].value =
 228                                 clk_get_rate(s->clkp) / 1000;
 229                         clk_put(s->clkp);
 230                 }
 231                 pr_debug("QUADD_POWER_CLK_GPU, value: %lu\n",
 232                          s->data[0].value);
 233                 break;
 234
 235         case QUADD_POWER_CLK_EMC:
 236                 /* update emc frequency */
 237                 s->clkp = clk_get_sys("cpu", "emc");
 238                 if (!IS_ERR_OR_NULL(s->clkp)) {
 239                         s->data[0].value =
 240                                 clk_get_rate(s->clkp) / 1000;
 241                         clk_put(s->clkp);
 242                 }
 243                 pr_debug("QUADD_POWER_CLK_EMC, value: %lu\n",
 244                          s->data[0].value);
 245                 break;
 246
 247         default:
 248                 pr_err_once("error: invalid power_clk type\n");
 249                 break;
 250         }
 251
 252         mutex_unlock(&s->lock);
 253 }
 254
 255 static int
 256 gpu_notifier_call(struct notifier_block *nb,
 257                   unsigned long action, void *data)
 258 {
 259         read_source(&power_ctx.gpu, -1);
 260         check_clks();
 261
 262         return NOTIFY_DONE;
 263 }
 264
 265 static int
 266 emc_notifier_call(struct notifier_block *nb,
 267                   unsigned long action, void *data)
 268 {
 269         read_source(&power_ctx.emc, -1);
 270         check_clks();
 271
 272         return NOTIFY_DONE;
 273 }
 274
 275 static void
 276 read_cpufreq(struct power_clk_source *s, struct cpufreq_freqs *freq)
 277 {
 278         int cpu, cpufreq;
 279
 280         mutex_lock(&s->lock);
 281
 282         if (!atomic_read(&s->active))
 283                 goto out_unlock;
 284
 285         cpu = freq->cpu;
 286         cpufreq = freq->new;
 287
 288         pr_debug("cpu: %d, cpufreq: %d\n", cpu, cpufreq);
 289
 290         if (cpu >= s->nr) {
 291                 pr_err_once("error: cpu id: %d\n", cpu);
 292                 goto out_unlock;
 293         }
 294
 295         s->data[cpu].value = cpufreq;
 296
 297         pr_debug("[%d] cpufreq: %u --> %u\n",
 298                  cpu, freq->old, cpufreq);
 299
 300         mutex_unlock(&s->lock);
 301         check_source(s);
 302         return;
 303
 304 out_unlock:
 305         mutex_unlock(&s->lock);
 306 }
 307
 308 static int
 309 cpufreq_notifier_call(struct notifier_block *nb,
 310                       unsigned long action, void *hcpu)
 311 {
 312         struct cpufreq_freqs *freq;
 313         struct power_clk_source *s = &power_ctx.cpu;
 314
 315         if (!atomic_read(&s->active))
 316                 return 0;
 317
 318         pr_debug("action: %lu\n", action);
 319
 320         if (action == CPUFREQ_POSTCHANGE ||
 321             action == CPUFREQ_RESUMECHANGE) {
 322                 freq = hcpu;
 323                 read_cpufreq(s, freq);
 324         }
 325
 326         return 0;
 327 }
 328
 329 static void reset_data(struct power_clk_source *s)
 330 {
 331         int i;
 332
 333         mutex_lock(&s->lock);
 334         for (i = 0; i < s->nr; i++) {
 335                 s->data[i].value = 0;
 336                 s->data[i].prev = 0;
 337         }
 338         mutex_unlock(&s->lock);
 339 }
 340
 341 static void init_source(struct power_clk_source *s,
 342                         notifier_call_ft notifier,
 343                         int nr_values,
 344                         int type)
 345 {
 346         s->type = type;
 347         s->nb.notifier_call = notifier;
 348         s->nr = min_t(int, nr_values, POWER_CLK_MAX_VALUES);
 349         atomic_set(&s->active, 0);
 350         mutex_init(&s->lock);
 351
 352         reset_data(s);
 353 }
 354
 355 static void
 356 power_clk_work_func(struct work_struct *work)
 357 {
 358         read_source(&power_ctx.gpu, -1);
 359         read_source(&power_ctx.emc, -1);
 360
 361         check_clks();
 362 }
 363
 364 static DECLARE_WORK(power_clk_work, power_clk_work_func);
 365
 366 static void power_clk_timer(unsigned long data)
 367 {
 368         struct timer_list *timer = &power_ctx.timer;
 369
 370         schedule_work(&power_clk_work);
 371         timer->expires = jiffies + msecs_to_jiffies(power_ctx.period);
 372         add_timer(timer);
 373 }
 374
 375 static void
 376 read_all_sources_work_func(struct work_struct *work)
 377 {
 378         int cpu_id;
 379
 380         for_each_possible_cpu(cpu_id)
 381                 read_source(&power_ctx.cpu, cpu_id);
 382
 383         read_source(&power_ctx.gpu, -1);
 384         read_source(&power_ctx.emc, -1);
 385
 386         check_clks();
 387 }
 388
 389 static DECLARE_WORK(read_all_sources_work, read_all_sources_work_func);
 390
 391 int quadd_power_clk_start(void)
 392 {
 393         struct power_clk_source *s;
 394         struct timer_list *timer = &power_ctx.timer;
 395         struct quadd_parameters *param = &power_ctx.quadd_ctx->param;
 396
 397         if (param->power_rate_freq == 0) {
 398                 pr_info("power_clk is not started\n");
 399                 return 0;
 400         }
 401
 402 #ifdef CONFIG_COMMON_CLK
 403         power_ctx.period = 0;
 404 #else
 405         power_ctx.period = MSEC_PER_SEC / param->power_rate_freq;
 406         pr_info("clk: use timer\n");
 407 #endif
 408
 409         pr_info("power_clk: start, freq: %d\n",
 410                 param->power_rate_freq);
 411
 412         /* setup gpu frequency */
 413         s = &power_ctx.gpu;
 414         s->clkp = clk_get_sys("3d", NULL);
 415         if (!IS_ERR_OR_NULL(s->clkp)) {
 416 #ifdef CONFIG_COMMON_CLK
 417                 status = clk_notifier_register(s->clkp, s->nb);
 418                 if (status < 0) {
 419                         pr_err("error: could not setup gpu freq\n");
 420                         clk_put(s->clkp);
 421                         return status;
 422                 }
 423 #endif
 424                 clk_put(s->clkp);
 425                 reset_data(s);
 426                 atomic_set(&s->active, 1);
 427         } else {
 428                 pr_warn("warning: could not setup gpu freq\n");
 429                 atomic_set(&s->active, 0);
 430         }
 431
 432         /* setup emc frequency */
 433         s = &power_ctx.emc;
 434         s->clkp = clk_get_sys("cpu", "emc");
 435         if (!IS_ERR_OR_NULL(s->clkp)) {
 436 #ifdef CONFIG_COMMON_CLK
 437                 status = clk_notifier_register(s->clkp, s->nb);
 438                 if (status < 0) {
 439                         pr_err("error: could not setup emc freq\n");
 440                         clk_put(s->clkp);
 441                         return status;
 442                 }
 443 #endif
 444                 clk_put(s->clkp);
 445                 reset_data(s);
 446                 atomic_set(&s->active, 1);
 447         } else {
 448                 pr_warn("warning: could not setup emc freq\n");
 449                 atomic_set(&s->active, 0);
 450         }
 451
 452         /* setup cpu frequency notifier */
 453         s = &power_ctx.cpu;
 454         reset_data(s);
 455         atomic_set(&s->active, 1);
 456
 457         if (power_ctx.period > 0) {
 458                 init_timer(timer);
 459                 timer->function = power_clk_timer;
 460                 timer->expires = jiffies + msecs_to_jiffies(power_ctx.period);
 461                 timer->data = 0;
 462                 add_timer(timer);
 463         }
 464
 465         schedule_work(&read_all_sources_work);
 466
 467         return 0;
 468 }
 469
 470 void quadd_power_clk_stop(void)
 471 {
 472         struct power_clk_source *s;
 473         struct quadd_parameters *param = &power_ctx.quadd_ctx->param;
 474
 475         if (param->power_rate_freq == 0)
 476                 return;
 477
 478         if (power_ctx.period > 0)
 479                 del_timer_sync(&power_ctx.timer);
 480
 481         s = &power_ctx.gpu;
 482         mutex_lock(&s->lock);
 483         if (atomic_cmpxchg(&s->active, 1, 0)) {
 484 #ifdef CONFIG_COMMON_CLK
 485                 if (s->clkp)
 486                         clk_notifier_unregister(s->clkp, &s->nb);
 487 #endif
 488         }
 489         mutex_unlock(&s->lock);
 490
 491         s = &power_ctx.emc;
 492         mutex_lock(&s->lock);
 493         if (atomic_cmpxchg(&s->active, 1, 0)) {
 494 #ifdef CONFIG_COMMON_CLK
 495                 if (s->clkp)
 496                         clk_notifier_unregister(s->clkp, &s->nb);
 497 #endif
 498         }
 499         mutex_unlock(&s->lock);
 500
 501         s = &power_ctx.cpu;
 502         mutex_lock(&s->lock);
 503         atomic_set(&s->active, 0);
 504         mutex_unlock(&s->lock);
 505
 506         pr_info("power_clk: stop\n");
 507 }
 508
 509 int quadd_power_clk_init(struct quadd_ctx *quadd_ctx)
 510 {
 511         init_source(&power_ctx.cpu, cpufreq_notifier_call, nr_cpu_ids,
 512                     QUADD_POWER_CLK_CPU);
 513
 514         init_source(&power_ctx.gpu, gpu_notifier_call, 1, QUADD_POWER_CLK_GPU);
 515         init_source(&power_ctx.emc, emc_notifier_call, 1, QUADD_POWER_CLK_EMC);
 516
 517         cpufreq_register_notifier(&power_ctx.cpu.nb,
 518                                   CPUFREQ_TRANSITION_NOTIFIER);
 519
 520         power_ctx.quadd_ctx = quadd_ctx;
 521
 522         return 0;
 523 }
 524
 525 void quadd_power_clk_deinit(void)
 526 {
 527         quadd_power_clk_stop();
 528         cpufreq_unregister_notifier(&power_ctx.cpu.nb,
 529                                     CPUFREQ_TRANSITION_NOTIFIER);
 530 }