drivers/thermal/intel/intel

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
duration_set
window_size_set
find_target_mwait
has_pkg_state_counter
pkg_state_counter
get_compensation
adjust_compensation
powerclamp_adjust_controls
clamp_balancing_func
clamp_idle_injection_func
poll_pkg_cstate
start_power_clamp_worker
stop_power_clamp_worker
start_power_clamp
end_power_clamp
powerclamp_cpu_online
powerclamp_cpu_predown
powerclamp_get_max_state
powerclamp_get_cur_state
powerclamp_set_cur_state
powerclamp_probe
powerclamp_debug_show
powerclamp_create_debug_files
powerclamp_init
powerclamp_exit
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * intel_powerclamp.c - package c-state idle injection
   4  *
   5  * Copyright (c) 2012, Intel Corporation.
   6  *
   7  * Authors:
   8  *     Arjan van de Ven <arjan@linux.intel.com>
   9  *     Jacob Pan <jacob.jun.pan@linux.intel.com>
  10  *
  11  *      TODO:
  12  *           1. better handle wakeup from external interrupts, currently a fixed
  13  *              compensation is added to clamping duration when excessive amount
  14  *              of wakeups are observed during idle time. the reason is that in
  15  *              case of external interrupts without need for ack, clamping down
  16  *              cpu in non-irq context does not reduce irq. for majority of the
  17  *              cases, clamping down cpu does help reduce irq as well, we should
  18  *              be able to differentiate the two cases and give a quantitative
  19  *              solution for the irqs that we can control. perhaps based on
  20  *              get_cpu_iowait_time_us()
  21  *
  22  *           2. synchronization with other hw blocks
  23  */
  24 
  25 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  26 
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/delay.h>
  30 #include <linux/kthread.h>
  31 #include <linux/cpu.h>
  32 #include <linux/thermal.h>
  33 #include <linux/slab.h>
  34 #include <linux/tick.h>
  35 #include <linux/debugfs.h>
  36 #include <linux/seq_file.h>
  37 #include <linux/sched/rt.h>
  38 #include <uapi/linux/sched/types.h>
  39 
  40 #include <asm/nmi.h>
  41 #include <asm/msr.h>
  42 #include <asm/mwait.h>
  43 #include <asm/cpu_device_id.h>
  44 #include <asm/hardirq.h>
  45 
  46 #define MAX_TARGET_RATIO (50U)
  47 /* For each undisturbed clamping period (no extra wake ups during idle time),
  48  * we increment the confidence counter for the given target ratio.
  49  * CONFIDENCE_OK defines the level where runtime calibration results are
  50  * valid.
  51  */
  52 #define CONFIDENCE_OK (3)
  53 /* Default idle injection duration, driver adjust sleep time to meet target
  54  * idle ratio. Similar to frequency modulation.
  55  */
  56 #define DEFAULT_DURATION_JIFFIES (6)
  57 
  58 static unsigned int target_mwait;
  59 static struct dentry *debug_dir;
  60 
  61 /* user selected target */
  62 static unsigned int set_target_ratio;
  63 static unsigned int current_ratio;
  64 static bool should_skip;
  65 static bool reduce_irq;
  66 static atomic_t idle_wakeup_counter;
  67 static unsigned int control_cpu; /* The cpu assigned to collect stat and update
  68                                   * control parameters. default to BSP but BSP
  69                                   * can be offlined.
  70                                   */
  71 static bool clamping;
  72 
  73 static const struct sched_param sparam = {
  74         .sched_priority = MAX_USER_RT_PRIO / 2,
  75 };
  76 struct powerclamp_worker_data {
  77         struct kthread_worker *worker;
  78         struct kthread_work balancing_work;
  79         struct kthread_delayed_work idle_injection_work;
  80         unsigned int cpu;
  81         unsigned int count;
  82         unsigned int guard;
  83         unsigned int window_size_now;
  84         unsigned int target_ratio;
  85         unsigned int duration_jiffies;
  86         bool clamping;
  87 };
  88 
  89 static struct powerclamp_worker_data __percpu *worker_data;
  90 static struct thermal_cooling_device *cooling_dev;
  91 static unsigned long *cpu_clamping_mask;  /* bit map for tracking per cpu
  92                                            * clamping kthread worker
  93                                            */
  94 
  95 static unsigned int duration;
  96 static unsigned int pkg_cstate_ratio_cur;
  97 static unsigned int window_size;
  98 
  99 static int duration_set(const char *arg, const struct kernel_param *kp)
 100 {
 101         int ret = 0;
 102         unsigned long new_duration;
 103 
 104         ret = kstrtoul(arg, 10, &new_duration);
 105         if (ret)
 106                 goto exit;
 107         if (new_duration > 25 || new_duration < 6) {
 108                 pr_err("Out of recommended range %lu, between 6-25ms\n",
 109                         new_duration);
 110                 ret = -EINVAL;
 111         }
 112 
 113         duration = clamp(new_duration, 6ul, 25ul);
 114         smp_mb();
 115 
 116 exit:
 117 
 118         return ret;
 119 }
 120 
 121 static const struct kernel_param_ops duration_ops = {
 122         .set = duration_set,
 123         .get = param_get_int,
 124 };
 125 
 126 
 127 module_param_cb(duration, &duration_ops, &duration, 0644);
 128 MODULE_PARM_DESC(duration, "forced idle time for each attempt in msec.");
 129 
 130 struct powerclamp_calibration_data {
 131         unsigned long confidence;  /* used for calibration, basically a counter
 132                                     * gets incremented each time a clamping
 133                                     * period is completed without extra wakeups
 134                                     * once that counter is reached given level,
 135                                     * compensation is deemed usable.
 136                                     */
 137         unsigned long steady_comp; /* steady state compensation used when
 138                                     * no extra wakeups occurred.
 139                                     */
 140         unsigned long dynamic_comp; /* compensate excessive wakeup from idle
 141                                      * mostly from external interrupts.
 142                                      */
 143 };
 144 
 145 static struct powerclamp_calibration_data cal_data[MAX_TARGET_RATIO];
 146 
 147 static int window_size_set(const char *arg, const struct kernel_param *kp)
 148 {
 149         int ret = 0;
 150         unsigned long new_window_size;
 151 
 152         ret = kstrtoul(arg, 10, &new_window_size);
 153         if (ret)
 154                 goto exit_win;
 155         if (new_window_size > 10 || new_window_size < 2) {
 156                 pr_err("Out of recommended window size %lu, between 2-10\n",
 157                         new_window_size);
 158                 ret = -EINVAL;
 159         }
 160 
 161         window_size = clamp(new_window_size, 2ul, 10ul);
 162         smp_mb();
 163 
 164 exit_win:
 165 
 166         return ret;
 167 }
 168 
 169 static const struct kernel_param_ops window_size_ops = {
 170         .set = window_size_set,
 171         .get = param_get_int,
 172 };
 173 
 174 module_param_cb(window_size, &window_size_ops, &window_size, 0644);
 175 MODULE_PARM_DESC(window_size, "sliding window in number of clamping cycles\n"
 176         "\tpowerclamp controls idle ratio within this window. larger\n"
 177         "\twindow size results in slower response time but more smooth\n"
 178         "\tclamping results. default to 2.");
 179 
 180 static void find_target_mwait(void)
 181 {
 182         unsigned int eax, ebx, ecx, edx;
 183         unsigned int highest_cstate = 0;
 184         unsigned int highest_subcstate = 0;
 185         int i;
 186 
 187         if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF)
 188                 return;
 189 
 190         cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx);
 191 
 192         if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED) ||
 193             !(ecx & CPUID5_ECX_INTERRUPT_BREAK))
 194                 return;
 195 
 196         edx >>= MWAIT_SUBSTATE_SIZE;
 197         for (i = 0; i < 7 && edx; i++, edx >>= MWAIT_SUBSTATE_SIZE) {
 198                 if (edx & MWAIT_SUBSTATE_MASK) {
 199                         highest_cstate = i;
 200                         highest_subcstate = edx & MWAIT_SUBSTATE_MASK;
 201                 }
 202         }
 203         target_mwait = (highest_cstate << MWAIT_SUBSTATE_SIZE) |
 204                 (highest_subcstate - 1);
 205 
 206 }
 207 
 208 struct pkg_cstate_info {
 209         bool skip;
 210         int msr_index;
 211         int cstate_id;
 212 };
 213 
 214 #define PKG_CSTATE_INIT(id) {                           \
 215                 .msr_index = MSR_PKG_C##id##_RESIDENCY, \
 216                 .cstate_id = id                         \
 217                         }
 218 
 219 static struct pkg_cstate_info pkg_cstates[] = {
 220         PKG_CSTATE_INIT(2),
 221         PKG_CSTATE_INIT(3),
 222         PKG_CSTATE_INIT(6),
 223         PKG_CSTATE_INIT(7),
 224         PKG_CSTATE_INIT(8),
 225         PKG_CSTATE_INIT(9),
 226         PKG_CSTATE_INIT(10),
 227         {NULL},
 228 };
 229 
 230 static bool has_pkg_state_counter(void)
 231 {
 232         u64 val;
 233         struct pkg_cstate_info *info = pkg_cstates;
 234 
 235         /* check if any one of the counter msrs exists */
 236         while (info->msr_index) {
 237                 if (!rdmsrl_safe(info->msr_index, &val))
 238                         return true;
 239                 info++;
 240         }
 241 
 242         return false;
 243 }
 244 
 245 static u64 pkg_state_counter(void)
 246 {
 247         u64 val;
 248         u64 count = 0;
 249         struct pkg_cstate_info *info = pkg_cstates;
 250 
 251         while (info->msr_index) {
 252                 if (!info->skip) {
 253                         if (!rdmsrl_safe(info->msr_index, &val))
 254                                 count += val;
 255                         else
 256                                 info->skip = true;
 257                 }
 258                 info++;
 259         }
 260 
 261         return count;
 262 }
 263 
 264 static unsigned int get_compensation(int ratio)
 265 {
 266         unsigned int comp = 0;
 267 
 268         /* we only use compensation if all adjacent ones are good */
 269         if (ratio == 1 &&
 270                 cal_data[ratio].confidence >= CONFIDENCE_OK &&
 271                 cal_data[ratio + 1].confidence >= CONFIDENCE_OK &&
 272                 cal_data[ratio + 2].confidence >= CONFIDENCE_OK) {
 273                 comp = (cal_data[ratio].steady_comp +
 274                         cal_data[ratio + 1].steady_comp +
 275                         cal_data[ratio + 2].steady_comp) / 3;
 276         } else if (ratio == MAX_TARGET_RATIO - 1 &&
 277                 cal_data[ratio].confidence >= CONFIDENCE_OK &&
 278                 cal_data[ratio - 1].confidence >= CONFIDENCE_OK &&
 279                 cal_data[ratio - 2].confidence >= CONFIDENCE_OK) {
 280                 comp = (cal_data[ratio].steady_comp +
 281                         cal_data[ratio - 1].steady_comp +
 282                         cal_data[ratio - 2].steady_comp) / 3;
 283         } else if (cal_data[ratio].confidence >= CONFIDENCE_OK &&
 284                 cal_data[ratio - 1].confidence >= CONFIDENCE_OK &&
 285                 cal_data[ratio + 1].confidence >= CONFIDENCE_OK) {
 286                 comp = (cal_data[ratio].steady_comp +
 287                         cal_data[ratio - 1].steady_comp +
 288                         cal_data[ratio + 1].steady_comp) / 3;
 289         }
 290 
 291         /* REVISIT: simple penalty of double idle injection */
 292         if (reduce_irq)
 293                 comp = ratio;
 294         /* do not exceed limit */
 295         if (comp + ratio >= MAX_TARGET_RATIO)
 296                 comp = MAX_TARGET_RATIO - ratio - 1;
 297 
 298         return comp;
 299 }
 300 
 301 static void adjust_compensation(int target_ratio, unsigned int win)
 302 {
 303         int delta;
 304         struct powerclamp_calibration_data *d = &cal_data[target_ratio];
 305 
 306         /*
 307          * adjust compensations if confidence level has not been reached or
 308          * there are too many wakeups during the last idle injection period, we
 309          * cannot trust the data for compensation.
 310          */
 311         if (d->confidence >= CONFIDENCE_OK ||
 312                 atomic_read(&idle_wakeup_counter) >
 313                 win * num_online_cpus())
 314                 return;
 315 
 316         delta = set_target_ratio - current_ratio;
 317         /* filter out bad data */
 318         if (delta >= 0 && delta <= (1+target_ratio/10)) {
 319                 if (d->steady_comp)
 320                         d->steady_comp =
 321                                 roundup(delta+d->steady_comp, 2)/2;
 322                 else
 323                         d->steady_comp = delta;
 324                 d->confidence++;
 325         }
 326 }
 327 
 328 static bool powerclamp_adjust_controls(unsigned int target_ratio,
 329                                 unsigned int guard, unsigned int win)
 330 {
 331         static u64 msr_last, tsc_last;
 332         u64 msr_now, tsc_now;
 333         u64 val64;
 334 
 335         /* check result for the last window */
 336         msr_now = pkg_state_counter();
 337         tsc_now = rdtsc();
 338 
 339         /* calculate pkg cstate vs tsc ratio */
 340         if (!msr_last || !tsc_last)
 341                 current_ratio = 1;
 342         else if (tsc_now-tsc_last) {
 343                 val64 = 100*(msr_now-msr_last);
 344                 do_div(val64, (tsc_now-tsc_last));
 345                 current_ratio = val64;
 346         }
 347 
 348         /* update record */
 349         msr_last = msr_now;
 350         tsc_last = tsc_now;
 351 
 352         adjust_compensation(target_ratio, win);
 353         /*
 354          * too many external interrupts, set flag such
 355          * that we can take measure later.
 356          */
 357         reduce_irq = atomic_read(&idle_wakeup_counter) >=
 358                 2 * win * num_online_cpus();
 359 
 360         atomic_set(&idle_wakeup_counter, 0);
 361         /* if we are above target+guard, skip */
 362         return set_target_ratio + guard <= current_ratio;
 363 }
 364 
 365 static void clamp_balancing_func(struct kthread_work *work)
 366 {
 367         struct powerclamp_worker_data *w_data;
 368         int sleeptime;
 369         unsigned long target_jiffies;
 370         unsigned int compensated_ratio;
 371         int interval; /* jiffies to sleep for each attempt */
 372 
 373         w_data = container_of(work, struct powerclamp_worker_data,
 374                               balancing_work);
 375 
 376         /*
 377          * make sure user selected ratio does not take effect until
 378          * the next round. adjust target_ratio if user has changed
 379          * target such that we can converge quickly.
 380          */
 381         w_data->target_ratio = READ_ONCE(set_target_ratio);
 382         w_data->guard = 1 + w_data->target_ratio / 20;
 383         w_data->window_size_now = window_size;
 384         w_data->duration_jiffies = msecs_to_jiffies(duration);
 385         w_data->count++;
 386 
 387         /*
 388          * systems may have different ability to enter package level
 389          * c-states, thus we need to compensate the injected idle ratio
 390          * to achieve the actual target reported by the HW.
 391          */
 392         compensated_ratio = w_data->target_ratio +
 393                 get_compensation(w_data->target_ratio);
 394         if (compensated_ratio <= 0)
 395                 compensated_ratio = 1;
 396         interval = w_data->duration_jiffies * 100 / compensated_ratio;
 397 
 398         /* align idle time */
 399         target_jiffies = roundup(jiffies, interval);
 400         sleeptime = target_jiffies - jiffies;
 401         if (sleeptime <= 0)
 402                 sleeptime = 1;
 403 
 404         if (clamping && w_data->clamping && cpu_online(w_data->cpu))
 405                 kthread_queue_delayed_work(w_data->worker,
 406                                            &w_data->idle_injection_work,
 407                                            sleeptime);
 408 }
 409 
 410 static void clamp_idle_injection_func(struct kthread_work *work)
 411 {
 412         struct powerclamp_worker_data *w_data;
 413 
 414         w_data = container_of(work, struct powerclamp_worker_data,
 415                               idle_injection_work.work);
 416 
 417         /*
 418          * only elected controlling cpu can collect stats and update
 419          * control parameters.
 420          */
 421         if (w_data->cpu == control_cpu &&
 422             !(w_data->count % w_data->window_size_now)) {
 423                 should_skip =
 424                         powerclamp_adjust_controls(w_data->target_ratio,
 425                                                    w_data->guard,
 426                                                    w_data->window_size_now);
 427                 smp_mb();
 428         }
 429 
 430         if (should_skip)
 431                 goto balance;
 432 
 433         play_idle(jiffies_to_usecs(w_data->duration_jiffies));
 434 
 435 balance:
 436         if (clamping && w_data->clamping && cpu_online(w_data->cpu))
 437                 kthread_queue_work(w_data->worker, &w_data->balancing_work);
 438 }
 439 
 440 /*
 441  * 1 HZ polling while clamping is active, useful for userspace
 442  * to monitor actual idle ratio.
 443  */
 444 static void poll_pkg_cstate(struct work_struct *dummy);
 445 static DECLARE_DELAYED_WORK(poll_pkg_cstate_work, poll_pkg_cstate);
 446 static void poll_pkg_cstate(struct work_struct *dummy)
 447 {
 448         static u64 msr_last;
 449         static u64 tsc_last;
 450 
 451         u64 msr_now;
 452         u64 tsc_now;
 453         u64 val64;
 454 
 455         msr_now = pkg_state_counter();
 456         tsc_now = rdtsc();
 457 
 458         /* calculate pkg cstate vs tsc ratio */
 459         if (!msr_last || !tsc_last)
 460                 pkg_cstate_ratio_cur = 1;
 461         else {
 462                 if (tsc_now - tsc_last) {
 463                         val64 = 100 * (msr_now - msr_last);
 464                         do_div(val64, (tsc_now - tsc_last));
 465                         pkg_cstate_ratio_cur = val64;
 466                 }
 467         }
 468 
 469         /* update record */
 470         msr_last = msr_now;
 471         tsc_last = tsc_now;
 472 
 473         if (true == clamping)
 474                 schedule_delayed_work(&poll_pkg_cstate_work, HZ);
 475 }
 476 
 477 static void start_power_clamp_worker(unsigned long cpu)
 478 {
 479         struct powerclamp_worker_data *w_data = per_cpu_ptr(worker_data, cpu);
 480         struct kthread_worker *worker;
 481 
 482         worker = kthread_create_worker_on_cpu(cpu, 0, "kidle_inj/%ld", cpu);
 483         if (IS_ERR(worker))
 484                 return;
 485 
 486         w_data->worker = worker;
 487         w_data->count = 0;
 488         w_data->cpu = cpu;
 489         w_data->clamping = true;
 490         set_bit(cpu, cpu_clamping_mask);
 491         sched_setscheduler(worker->task, SCHED_FIFO, &sparam);
 492         kthread_init_work(&w_data->balancing_work, clamp_balancing_func);
 493         kthread_init_delayed_work(&w_data->idle_injection_work,
 494                                   clamp_idle_injection_func);
 495         kthread_queue_work(w_data->worker, &w_data->balancing_work);
 496 }
 497 
 498 static void stop_power_clamp_worker(unsigned long cpu)
 499 {
 500         struct powerclamp_worker_data *w_data = per_cpu_ptr(worker_data, cpu);
 501 
 502         if (!w_data->worker)
 503                 return;
 504 
 505         w_data->clamping = false;
 506         /*
 507          * Make sure that all works that get queued after this point see
 508          * the clamping disabled. The counter part is not needed because
 509          * there is an implicit memory barrier when the queued work
 510          * is proceed.
 511          */
 512         smp_wmb();
 513         kthread_cancel_work_sync(&w_data->balancing_work);
 514         kthread_cancel_delayed_work_sync(&w_data->idle_injection_work);
 515         /*
 516          * The balancing work still might be queued here because
 517          * the handling of the "clapming" variable, cancel, and queue
 518          * operations are not synchronized via a lock. But it is not
 519          * a big deal. The balancing work is fast and destroy kthread
 520          * will wait for it.
 521          */
 522         clear_bit(w_data->cpu, cpu_clamping_mask);
 523         kthread_destroy_worker(w_data->worker);
 524 
 525         w_data->worker = NULL;
 526 }
 527 
 528 static int start_power_clamp(void)
 529 {
 530         unsigned long cpu;
 531 
 532         set_target_ratio = clamp(set_target_ratio, 0U, MAX_TARGET_RATIO - 1);
 533         /* prevent cpu hotplug */
 534         get_online_cpus();
 535 
 536         /* prefer BSP */
 537         control_cpu = 0;
 538         if (!cpu_online(control_cpu))
 539                 control_cpu = smp_processor_id();
 540 
 541         clamping = true;
 542         schedule_delayed_work(&poll_pkg_cstate_work, 0);
 543 
 544         /* start one kthread worker per online cpu */
 545         for_each_online_cpu(cpu) {
 546                 start_power_clamp_worker(cpu);
 547         }
 548         put_online_cpus();
 549 
 550         return 0;
 551 }
 552 
 553 static void end_power_clamp(void)
 554 {
 555         int i;
 556 
 557         /*
 558          * Block requeuing in all the kthread workers. They will flush and
 559          * stop faster.
 560          */
 561         clamping = false;
 562         if (bitmap_weight(cpu_clamping_mask, num_possible_cpus())) {
 563                 for_each_set_bit(i, cpu_clamping_mask, num_possible_cpus()) {
 564                         pr_debug("clamping worker for cpu %d alive, destroy\n",
 565                                  i);
 566                         stop_power_clamp_worker(i);
 567                 }
 568         }
 569 }
 570 
 571 static int powerclamp_cpu_online(unsigned int cpu)
 572 {
 573         if (clamping == false)
 574                 return 0;
 575         start_power_clamp_worker(cpu);
 576         /* prefer BSP as controlling CPU */
 577         if (cpu == 0) {
 578                 control_cpu = 0;
 579                 smp_mb();
 580         }
 581         return 0;
 582 }
 583 
 584 static int powerclamp_cpu_predown(unsigned int cpu)
 585 {
 586         if (clamping == false)
 587                 return 0;
 588 
 589         stop_power_clamp_worker(cpu);
 590         if (cpu != control_cpu)
 591                 return 0;
 592 
 593         control_cpu = cpumask_first(cpu_online_mask);
 594         if (control_cpu == cpu)
 595                 control_cpu = cpumask_next(cpu, cpu_online_mask);
 596         smp_mb();
 597         return 0;
 598 }
 599 
 600 static int powerclamp_get_max_state(struct thermal_cooling_device *cdev,
 601                                  unsigned long *state)
 602 {
 603         *state = MAX_TARGET_RATIO;
 604 
 605         return 0;
 606 }
 607 
 608 static int powerclamp_get_cur_state(struct thermal_cooling_device *cdev,
 609                                  unsigned long *state)
 610 {
 611         if (true == clamping)
 612                 *state = pkg_cstate_ratio_cur;
 613         else
 614                 /* to save power, do not poll idle ratio while not clamping */
 615                 *state = -1; /* indicates invalid state */
 616 
 617         return 0;
 618 }
 619 
 620 static int powerclamp_set_cur_state(struct thermal_cooling_device *cdev,
 621                                  unsigned long new_target_ratio)
 622 {
 623         int ret = 0;
 624 
 625         new_target_ratio = clamp(new_target_ratio, 0UL,
 626                                 (unsigned long) (MAX_TARGET_RATIO-1));
 627         if (set_target_ratio == 0 && new_target_ratio > 0) {
 628                 pr_info("Start idle injection to reduce power\n");
 629                 set_target_ratio = new_target_ratio;
 630                 ret = start_power_clamp();
 631                 goto exit_set;
 632         } else  if (set_target_ratio > 0 && new_target_ratio == 0) {
 633                 pr_info("Stop forced idle injection\n");
 634                 end_power_clamp();
 635                 set_target_ratio = 0;
 636         } else  /* adjust currently running */ {
 637                 set_target_ratio = new_target_ratio;
 638                 /* make new set_target_ratio visible to other cpus */
 639                 smp_mb();
 640         }
 641 
 642 exit_set:
 643         return ret;
 644 }
 645 
 646 /* bind to generic thermal layer as cooling device*/
 647 static struct thermal_cooling_device_ops powerclamp_cooling_ops = {
 648         .get_max_state = powerclamp_get_max_state,
 649         .get_cur_state = powerclamp_get_cur_state,
 650         .set_cur_state = powerclamp_set_cur_state,
 651 };
 652 
 653 static const struct x86_cpu_id __initconst intel_powerclamp_ids[] = {
 654         { X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, X86_FEATURE_MWAIT },
 655         {}
 656 };
 657 MODULE_DEVICE_TABLE(x86cpu, intel_powerclamp_ids);
 658 
 659 static int __init powerclamp_probe(void)
 660 {
 661 
 662         if (!x86_match_cpu(intel_powerclamp_ids)) {
 663                 pr_err("CPU does not support MWAIT\n");
 664                 return -ENODEV;
 665         }
 666 
 667         /* The goal for idle time alignment is to achieve package cstate. */
 668         if (!has_pkg_state_counter()) {
 669                 pr_info("No package C-state available\n");
 670                 return -ENODEV;
 671         }
 672 
 673         /* find the deepest mwait value */
 674         find_target_mwait();
 675 
 676         return 0;
 677 }
 678 
 679 static int powerclamp_debug_show(struct seq_file *m, void *unused)
 680 {
 681         int i = 0;
 682 
 683         seq_printf(m, "controlling cpu: %d\n", control_cpu);
 684         seq_printf(m, "pct confidence steady dynamic (compensation)\n");
 685         for (i = 0; i < MAX_TARGET_RATIO; i++) {
 686                 seq_printf(m, "%d\t%lu\t%lu\t%lu\n",
 687                         i,
 688                         cal_data[i].confidence,
 689                         cal_data[i].steady_comp,
 690                         cal_data[i].dynamic_comp);
 691         }
 692 
 693         return 0;
 694 }
 695 
 696 DEFINE_SHOW_ATTRIBUTE(powerclamp_debug);
 697 
 698 static inline void powerclamp_create_debug_files(void)
 699 {
 700         debug_dir = debugfs_create_dir("intel_powerclamp", NULL);
 701 
 702         debugfs_create_file("powerclamp_calib", S_IRUGO, debug_dir, cal_data,
 703                             &powerclamp_debug_fops);
 704 }
 705 
 706 static enum cpuhp_state hp_state;
 707 
 708 static int __init powerclamp_init(void)
 709 {
 710         int retval;
 711         int bitmap_size;
 712 
 713         bitmap_size = BITS_TO_LONGS(num_possible_cpus()) * sizeof(long);
 714         cpu_clamping_mask = kzalloc(bitmap_size, GFP_KERNEL);
 715         if (!cpu_clamping_mask)
 716                 return -ENOMEM;
 717 
 718         /* probe cpu features and ids here */
 719         retval = powerclamp_probe();
 720         if (retval)
 721                 goto exit_free;
 722 
 723         /* set default limit, maybe adjusted during runtime based on feedback */
 724         window_size = 2;
 725         retval = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
 726                                            "thermal/intel_powerclamp:online",
 727                                            powerclamp_cpu_online,
 728                                            powerclamp_cpu_predown);
 729         if (retval < 0)
 730                 goto exit_free;
 731 
 732         hp_state = retval;
 733 
 734         worker_data = alloc_percpu(struct powerclamp_worker_data);
 735         if (!worker_data) {
 736                 retval = -ENOMEM;
 737                 goto exit_unregister;
 738         }
 739 
 740         cooling_dev = thermal_cooling_device_register("intel_powerclamp", NULL,
 741                                                 &powerclamp_cooling_ops);
 742         if (IS_ERR(cooling_dev)) {
 743                 retval = -ENODEV;
 744                 goto exit_free_thread;
 745         }
 746 
 747         if (!duration)
 748                 duration = jiffies_to_msecs(DEFAULT_DURATION_JIFFIES);
 749 
 750         powerclamp_create_debug_files();
 751 
 752         return 0;
 753 
 754 exit_free_thread:
 755         free_percpu(worker_data);
 756 exit_unregister:
 757         cpuhp_remove_state_nocalls(hp_state);
 758 exit_free:
 759         kfree(cpu_clamping_mask);
 760         return retval;
 761 }
 762 module_init(powerclamp_init);
 763 
 764 static void __exit powerclamp_exit(void)
 765 {
 766         end_power_clamp();
 767         cpuhp_remove_state_nocalls(hp_state);
 768         free_percpu(worker_data);
 769         thermal_cooling_device_unregister(cooling_dev);
 770         kfree(cpu_clamping_mask);
 771 
 772         cancel_delayed_work_sync(&poll_pkg_cstate_work);
 773         debugfs_remove_recursive(debug_dir);
 774 }
 775 module_exit(powerclamp_exit);
 776 
 777 MODULE_LICENSE("GPL");
 778 MODULE_AUTHOR("Arjan van de Ven <arjan@linux.intel.com>");
 779 MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@linux.intel.com>");
 780 MODULE_DESCRIPTION("Package Level C-state Idle Injection for Intel CPUs");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/thermal/intel/intel_powerclamp.c

DEFINITIONS
