intel_pstate.c revision b57ffac5e57bff33dde3cff35dff5c41876a6d12
1/* 2 * intel_pstate.c: Native P state management for Intel processors 3 * 4 * (C) Copyright 2012 Intel Corporation 5 * Author: Dirk Brandewie <dirk.j.brandewie@intel.com> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; version 2 10 * of the License. 11 */ 12 13#include <linux/kernel.h> 14#include <linux/kernel_stat.h> 15#include <linux/module.h> 16#include <linux/ktime.h> 17#include <linux/hrtimer.h> 18#include <linux/tick.h> 19#include <linux/slab.h> 20#include <linux/sched.h> 21#include <linux/list.h> 22#include <linux/cpu.h> 23#include <linux/cpufreq.h> 24#include <linux/sysfs.h> 25#include <linux/types.h> 26#include <linux/fs.h> 27#include <linux/debugfs.h> 28#include <trace/events/power.h> 29 30#include <asm/div64.h> 31#include <asm/msr.h> 32#include <asm/cpu_device_id.h> 33 34#define SAMPLE_COUNT 3 35 36#define FRAC_BITS 8 37#define int_tofp(X) ((int64_t)(X) << FRAC_BITS) 38#define fp_toint(X) ((X) >> FRAC_BITS) 39 40static inline int32_t mul_fp(int32_t x, int32_t y) 41{ 42 return ((int64_t)x * (int64_t)y) >> FRAC_BITS; 43} 44 45static inline int32_t div_fp(int32_t x, int32_t y) 46{ 47 return div_s64((int64_t)x << FRAC_BITS, (int64_t)y); 48} 49 50struct sample { 51 int core_pct_busy; 52 u64 aperf; 53 u64 mperf; 54 int freq; 55}; 56 57struct pstate_data { 58 int current_pstate; 59 int min_pstate; 60 int max_pstate; 61 int turbo_pstate; 62}; 63 64struct _pid { 65 int setpoint; 66 int32_t integral; 67 int32_t p_gain; 68 int32_t i_gain; 69 int32_t d_gain; 70 int deadband; 71 int last_err; 72}; 73 74struct cpudata { 75 int cpu; 76 77 char name[64]; 78 79 struct timer_list timer; 80 81 struct pstate_adjust_policy *pstate_policy; 82 struct pstate_data pstate; 83 struct _pid pid; 84 85 int min_pstate_count; 86 87 u64 prev_aperf; 88 u64 prev_mperf; 89 int sample_ptr; 90 struct sample samples[SAMPLE_COUNT]; 91}; 92 93static struct cpudata **all_cpu_data; 94struct pstate_adjust_policy { 95 int sample_rate_ms; 96 int deadband; 97 int setpoint; 98 int p_gain_pct; 99 int d_gain_pct; 100 int i_gain_pct; 101}; 102 103static struct pstate_adjust_policy default_policy = { 104 .sample_rate_ms = 10, 105 .deadband = 0, 106 .setpoint = 109, 107 .p_gain_pct = 17, 108 .d_gain_pct = 0, 109 .i_gain_pct = 4, 110}; 111 112struct perf_limits { 113 int no_turbo; 114 int max_perf_pct; 115 int min_perf_pct; 116 int32_t max_perf; 117 int32_t min_perf; 118 int max_policy_pct; 119 int max_sysfs_pct; 120}; 121 122static struct perf_limits limits = { 123 .no_turbo = 0, 124 .max_perf_pct = 100, 125 .max_perf = int_tofp(1), 126 .min_perf_pct = 0, 127 .min_perf = 0, 128 .max_policy_pct = 100, 129 .max_sysfs_pct = 100, 130}; 131 132static inline void pid_reset(struct _pid *pid, int setpoint, int busy, 133 int deadband, int integral) { 134 pid->setpoint = setpoint; 135 pid->deadband = deadband; 136 pid->integral = int_tofp(integral); 137 pid->last_err = setpoint - busy; 138} 139 140static inline void pid_p_gain_set(struct _pid *pid, int percent) 141{ 142 pid->p_gain = div_fp(int_tofp(percent), int_tofp(100)); 143} 144 145static inline void pid_i_gain_set(struct _pid *pid, int percent) 146{ 147 pid->i_gain = div_fp(int_tofp(percent), int_tofp(100)); 148} 149 150static inline void pid_d_gain_set(struct _pid *pid, int percent) 151{ 152 153 pid->d_gain = div_fp(int_tofp(percent), int_tofp(100)); 154} 155 156static signed int pid_calc(struct _pid *pid, int busy) 157{ 158 signed int err, result; 159 int32_t pterm, dterm, fp_error; 160 int32_t integral_limit; 161 162 err = pid->setpoint - busy; 163 fp_error = int_tofp(err); 164 165 if (abs(err) <= pid->deadband) 166 return 0; 167 168 pterm = mul_fp(pid->p_gain, fp_error); 169 170 pid->integral += fp_error; 171 172 /* limit the integral term */ 173 integral_limit = int_tofp(30); 174 if (pid->integral > integral_limit) 175 pid->integral = integral_limit; 176 if (pid->integral < -integral_limit) 177 pid->integral = -integral_limit; 178 179 dterm = mul_fp(pid->d_gain, (err - pid->last_err)); 180 pid->last_err = err; 181 182 result = pterm + mul_fp(pid->integral, pid->i_gain) + dterm; 183 184 return (signed int)fp_toint(result); 185} 186 187static inline void intel_pstate_busy_pid_reset(struct cpudata *cpu) 188{ 189 pid_p_gain_set(&cpu->pid, cpu->pstate_policy->p_gain_pct); 190 pid_d_gain_set(&cpu->pid, cpu->pstate_policy->d_gain_pct); 191 pid_i_gain_set(&cpu->pid, cpu->pstate_policy->i_gain_pct); 192 193 pid_reset(&cpu->pid, 194 cpu->pstate_policy->setpoint, 195 100, 196 cpu->pstate_policy->deadband, 197 0); 198} 199 200static inline void intel_pstate_reset_all_pid(void) 201{ 202 unsigned int cpu; 203 for_each_online_cpu(cpu) { 204 if (all_cpu_data[cpu]) 205 intel_pstate_busy_pid_reset(all_cpu_data[cpu]); 206 } 207} 208 209/************************** debugfs begin ************************/ 210static int pid_param_set(void *data, u64 val) 211{ 212 *(u32 *)data = val; 213 intel_pstate_reset_all_pid(); 214 return 0; 215} 216static int pid_param_get(void *data, u64 *val) 217{ 218 *val = *(u32 *)data; 219 return 0; 220} 221DEFINE_SIMPLE_ATTRIBUTE(fops_pid_param, pid_param_get, 222 pid_param_set, "%llu\n"); 223 224struct pid_param { 225 char *name; 226 void *value; 227}; 228 229static struct pid_param pid_files[] = { 230 {"sample_rate_ms", &default_policy.sample_rate_ms}, 231 {"d_gain_pct", &default_policy.d_gain_pct}, 232 {"i_gain_pct", &default_policy.i_gain_pct}, 233 {"deadband", &default_policy.deadband}, 234 {"setpoint", &default_policy.setpoint}, 235 {"p_gain_pct", &default_policy.p_gain_pct}, 236 {NULL, NULL} 237}; 238 239static struct dentry *debugfs_parent; 240static void intel_pstate_debug_expose_params(void) 241{ 242 int i = 0; 243 244 debugfs_parent = debugfs_create_dir("pstate_snb", NULL); 245 if (IS_ERR_OR_NULL(debugfs_parent)) 246 return; 247 while (pid_files[i].name) { 248 debugfs_create_file(pid_files[i].name, 0660, 249 debugfs_parent, pid_files[i].value, 250 &fops_pid_param); 251 i++; 252 } 253} 254 255/************************** debugfs end ************************/ 256 257/************************** sysfs begin ************************/ 258#define show_one(file_name, object) \ 259 static ssize_t show_##file_name \ 260 (struct kobject *kobj, struct attribute *attr, char *buf) \ 261 { \ 262 return sprintf(buf, "%u\n", limits.object); \ 263 } 264 265static ssize_t store_no_turbo(struct kobject *a, struct attribute *b, 266 const char *buf, size_t count) 267{ 268 unsigned int input; 269 int ret; 270 ret = sscanf(buf, "%u", &input); 271 if (ret != 1) 272 return -EINVAL; 273 limits.no_turbo = clamp_t(int, input, 0 , 1); 274 275 return count; 276} 277 278static ssize_t store_max_perf_pct(struct kobject *a, struct attribute *b, 279 const char *buf, size_t count) 280{ 281 unsigned int input; 282 int ret; 283 ret = sscanf(buf, "%u", &input); 284 if (ret != 1) 285 return -EINVAL; 286 287 limits.max_sysfs_pct = clamp_t(int, input, 0 , 100); 288 limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct); 289 limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100)); 290 return count; 291} 292 293static ssize_t store_min_perf_pct(struct kobject *a, struct attribute *b, 294 const char *buf, size_t count) 295{ 296 unsigned int input; 297 int ret; 298 ret = sscanf(buf, "%u", &input); 299 if (ret != 1) 300 return -EINVAL; 301 limits.min_perf_pct = clamp_t(int, input, 0 , 100); 302 limits.min_perf = div_fp(int_tofp(limits.min_perf_pct), int_tofp(100)); 303 304 return count; 305} 306 307show_one(no_turbo, no_turbo); 308show_one(max_perf_pct, max_perf_pct); 309show_one(min_perf_pct, min_perf_pct); 310 311define_one_global_rw(no_turbo); 312define_one_global_rw(max_perf_pct); 313define_one_global_rw(min_perf_pct); 314 315static struct attribute *intel_pstate_attributes[] = { 316 &no_turbo.attr, 317 &max_perf_pct.attr, 318 &min_perf_pct.attr, 319 NULL 320}; 321 322static struct attribute_group intel_pstate_attr_group = { 323 .attrs = intel_pstate_attributes, 324}; 325static struct kobject *intel_pstate_kobject; 326 327static void intel_pstate_sysfs_expose_params(void) 328{ 329 int rc; 330 331 intel_pstate_kobject = kobject_create_and_add("intel_pstate", 332 &cpu_subsys.dev_root->kobj); 333 BUG_ON(!intel_pstate_kobject); 334 rc = sysfs_create_group(intel_pstate_kobject, 335 &intel_pstate_attr_group); 336 BUG_ON(rc); 337} 338 339/************************** sysfs end ************************/ 340 341static int intel_pstate_min_pstate(void) 342{ 343 u64 value; 344 rdmsrl(MSR_PLATFORM_INFO, value); 345 return (value >> 40) & 0xFF; 346} 347 348static int intel_pstate_max_pstate(void) 349{ 350 u64 value; 351 rdmsrl(MSR_PLATFORM_INFO, value); 352 return (value >> 8) & 0xFF; 353} 354 355static int intel_pstate_turbo_pstate(void) 356{ 357 u64 value; 358 int nont, ret; 359 rdmsrl(MSR_NHM_TURBO_RATIO_LIMIT, value); 360 nont = intel_pstate_max_pstate(); 361 ret = ((value) & 255); 362 if (ret <= nont) 363 ret = nont; 364 return ret; 365} 366 367static void intel_pstate_get_min_max(struct cpudata *cpu, int *min, int *max) 368{ 369 int max_perf = cpu->pstate.turbo_pstate; 370 int min_perf; 371 if (limits.no_turbo) 372 max_perf = cpu->pstate.max_pstate; 373 374 max_perf = fp_toint(mul_fp(int_tofp(max_perf), limits.max_perf)); 375 *max = clamp_t(int, max_perf, 376 cpu->pstate.min_pstate, cpu->pstate.turbo_pstate); 377 378 min_perf = fp_toint(mul_fp(int_tofp(max_perf), limits.min_perf)); 379 *min = clamp_t(int, min_perf, 380 cpu->pstate.min_pstate, max_perf); 381} 382 383static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate) 384{ 385 int max_perf, min_perf; 386 387 intel_pstate_get_min_max(cpu, &min_perf, &max_perf); 388 389 pstate = clamp_t(int, pstate, min_perf, max_perf); 390 391 if (pstate == cpu->pstate.current_pstate) 392 return; 393 394 trace_cpu_frequency(pstate * 100000, cpu->cpu); 395 396 cpu->pstate.current_pstate = pstate; 397 wrmsrl(MSR_IA32_PERF_CTL, pstate << 8); 398 399} 400 401static inline void intel_pstate_pstate_increase(struct cpudata *cpu, int steps) 402{ 403 int target; 404 target = cpu->pstate.current_pstate + steps; 405 406 intel_pstate_set_pstate(cpu, target); 407} 408 409static inline void intel_pstate_pstate_decrease(struct cpudata *cpu, int steps) 410{ 411 int target; 412 target = cpu->pstate.current_pstate - steps; 413 intel_pstate_set_pstate(cpu, target); 414} 415 416static void intel_pstate_get_cpu_pstates(struct cpudata *cpu) 417{ 418 sprintf(cpu->name, "Intel 2nd generation core"); 419 420 cpu->pstate.min_pstate = intel_pstate_min_pstate(); 421 cpu->pstate.max_pstate = intel_pstate_max_pstate(); 422 cpu->pstate.turbo_pstate = intel_pstate_turbo_pstate(); 423 424 /* 425 * goto max pstate so we don't slow up boot if we are built-in if we are 426 * a module we will take care of it during normal operation 427 */ 428 intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate); 429} 430 431static inline void intel_pstate_calc_busy(struct cpudata *cpu, 432 struct sample *sample) 433{ 434 u64 core_pct; 435 core_pct = div64_u64(sample->aperf * 100, sample->mperf); 436 sample->freq = cpu->pstate.max_pstate * core_pct * 1000; 437 438 sample->core_pct_busy = core_pct; 439} 440 441static inline void intel_pstate_sample(struct cpudata *cpu) 442{ 443 u64 aperf, mperf; 444 445 rdmsrl(MSR_IA32_APERF, aperf); 446 rdmsrl(MSR_IA32_MPERF, mperf); 447 cpu->sample_ptr = (cpu->sample_ptr + 1) % SAMPLE_COUNT; 448 cpu->samples[cpu->sample_ptr].aperf = aperf; 449 cpu->samples[cpu->sample_ptr].mperf = mperf; 450 cpu->samples[cpu->sample_ptr].aperf -= cpu->prev_aperf; 451 cpu->samples[cpu->sample_ptr].mperf -= cpu->prev_mperf; 452 453 intel_pstate_calc_busy(cpu, &cpu->samples[cpu->sample_ptr]); 454 455 cpu->prev_aperf = aperf; 456 cpu->prev_mperf = mperf; 457} 458 459static inline void intel_pstate_set_sample_time(struct cpudata *cpu) 460{ 461 int sample_time, delay; 462 463 sample_time = cpu->pstate_policy->sample_rate_ms; 464 delay = msecs_to_jiffies(sample_time); 465 mod_timer_pinned(&cpu->timer, jiffies + delay); 466} 467 468static inline int intel_pstate_get_scaled_busy(struct cpudata *cpu) 469{ 470 int32_t busy_scaled; 471 int32_t core_busy, turbo_pstate, current_pstate; 472 473 core_busy = int_tofp(cpu->samples[cpu->sample_ptr].core_pct_busy); 474 turbo_pstate = int_tofp(cpu->pstate.turbo_pstate); 475 current_pstate = int_tofp(cpu->pstate.current_pstate); 476 busy_scaled = mul_fp(core_busy, div_fp(turbo_pstate, current_pstate)); 477 478 return fp_toint(busy_scaled); 479} 480 481static inline void intel_pstate_adjust_busy_pstate(struct cpudata *cpu) 482{ 483 int busy_scaled; 484 struct _pid *pid; 485 signed int ctl = 0; 486 int steps; 487 488 pid = &cpu->pid; 489 busy_scaled = intel_pstate_get_scaled_busy(cpu); 490 491 ctl = pid_calc(pid, busy_scaled); 492 493 steps = abs(ctl); 494 if (ctl < 0) 495 intel_pstate_pstate_increase(cpu, steps); 496 else 497 intel_pstate_pstate_decrease(cpu, steps); 498} 499 500static void intel_pstate_timer_func(unsigned long __data) 501{ 502 struct cpudata *cpu = (struct cpudata *) __data; 503 504 intel_pstate_sample(cpu); 505 intel_pstate_adjust_busy_pstate(cpu); 506 507 if (cpu->pstate.current_pstate == cpu->pstate.min_pstate) { 508 cpu->min_pstate_count++; 509 if (!(cpu->min_pstate_count % 5)) { 510 intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate); 511 } 512 } else 513 cpu->min_pstate_count = 0; 514 515 intel_pstate_set_sample_time(cpu); 516} 517 518#define ICPU(model, policy) \ 519 { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, (unsigned long)&policy } 520 521static const struct x86_cpu_id intel_pstate_cpu_ids[] = { 522 ICPU(0x2a, default_policy), 523 ICPU(0x2d, default_policy), 524 {} 525}; 526MODULE_DEVICE_TABLE(x86cpu, intel_pstate_cpu_ids); 527 528static int intel_pstate_init_cpu(unsigned int cpunum) 529{ 530 531 const struct x86_cpu_id *id; 532 struct cpudata *cpu; 533 534 id = x86_match_cpu(intel_pstate_cpu_ids); 535 if (!id) 536 return -ENODEV; 537 538 all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata), GFP_KERNEL); 539 if (!all_cpu_data[cpunum]) 540 return -ENOMEM; 541 542 cpu = all_cpu_data[cpunum]; 543 544 intel_pstate_get_cpu_pstates(cpu); 545 546 cpu->cpu = cpunum; 547 cpu->pstate_policy = 548 (struct pstate_adjust_policy *)id->driver_data; 549 init_timer_deferrable(&cpu->timer); 550 cpu->timer.function = intel_pstate_timer_func; 551 cpu->timer.data = 552 (unsigned long)cpu; 553 cpu->timer.expires = jiffies + HZ/100; 554 intel_pstate_busy_pid_reset(cpu); 555 intel_pstate_sample(cpu); 556 intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate); 557 558 add_timer_on(&cpu->timer, cpunum); 559 560 pr_info("Intel pstate controlling: cpu %d\n", cpunum); 561 562 return 0; 563} 564 565static unsigned int intel_pstate_get(unsigned int cpu_num) 566{ 567 struct sample *sample; 568 struct cpudata *cpu; 569 570 cpu = all_cpu_data[cpu_num]; 571 if (!cpu) 572 return 0; 573 sample = &cpu->samples[cpu->sample_ptr]; 574 return sample->freq; 575} 576 577static int intel_pstate_set_policy(struct cpufreq_policy *policy) 578{ 579 struct cpudata *cpu; 580 581 cpu = all_cpu_data[policy->cpu]; 582 583 if (!policy->cpuinfo.max_freq) 584 return -ENODEV; 585 586 if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) { 587 limits.min_perf_pct = 100; 588 limits.min_perf = int_tofp(1); 589 limits.max_perf_pct = 100; 590 limits.max_perf = int_tofp(1); 591 limits.no_turbo = 0; 592 return 0; 593 } 594 limits.min_perf_pct = (policy->min * 100) / policy->cpuinfo.max_freq; 595 limits.min_perf_pct = clamp_t(int, limits.min_perf_pct, 0 , 100); 596 limits.min_perf = div_fp(int_tofp(limits.min_perf_pct), int_tofp(100)); 597 598 limits.max_policy_pct = policy->max * 100 / policy->cpuinfo.max_freq; 599 limits.max_policy_pct = clamp_t(int, limits.max_policy_pct, 0 , 100); 600 limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct); 601 limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100)); 602 603 return 0; 604} 605 606static int intel_pstate_verify_policy(struct cpufreq_policy *policy) 607{ 608 cpufreq_verify_within_limits(policy, 609 policy->cpuinfo.min_freq, 610 policy->cpuinfo.max_freq); 611 612 if ((policy->policy != CPUFREQ_POLICY_POWERSAVE) && 613 (policy->policy != CPUFREQ_POLICY_PERFORMANCE)) 614 return -EINVAL; 615 616 return 0; 617} 618 619static int __cpuinit intel_pstate_cpu_exit(struct cpufreq_policy *policy) 620{ 621 int cpu = policy->cpu; 622 623 del_timer(&all_cpu_data[cpu]->timer); 624 kfree(all_cpu_data[cpu]); 625 all_cpu_data[cpu] = NULL; 626 return 0; 627} 628 629static int __cpuinit intel_pstate_cpu_init(struct cpufreq_policy *policy) 630{ 631 int rc, min_pstate, max_pstate; 632 struct cpudata *cpu; 633 634 rc = intel_pstate_init_cpu(policy->cpu); 635 if (rc) 636 return rc; 637 638 cpu = all_cpu_data[policy->cpu]; 639 640 if (!limits.no_turbo && 641 limits.min_perf_pct == 100 && limits.max_perf_pct == 100) 642 policy->policy = CPUFREQ_POLICY_PERFORMANCE; 643 else 644 policy->policy = CPUFREQ_POLICY_POWERSAVE; 645 646 intel_pstate_get_min_max(cpu, &min_pstate, &max_pstate); 647 policy->min = min_pstate * 100000; 648 policy->max = max_pstate * 100000; 649 650 /* cpuinfo and default policy values */ 651 policy->cpuinfo.min_freq = cpu->pstate.min_pstate * 100000; 652 policy->cpuinfo.max_freq = cpu->pstate.turbo_pstate * 100000; 653 policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; 654 cpumask_set_cpu(policy->cpu, policy->cpus); 655 656 return 0; 657} 658 659static struct cpufreq_driver intel_pstate_driver = { 660 .flags = CPUFREQ_CONST_LOOPS, 661 .verify = intel_pstate_verify_policy, 662 .setpolicy = intel_pstate_set_policy, 663 .get = intel_pstate_get, 664 .init = intel_pstate_cpu_init, 665 .exit = intel_pstate_cpu_exit, 666 .name = "intel_pstate", 667 .owner = THIS_MODULE, 668}; 669 670static int __initdata no_load; 671 672static int intel_pstate_msrs_not_valid(void) 673{ 674 /* Check that all the msr's we are using are valid. */ 675 u64 aperf, mperf, tmp; 676 677 rdmsrl(MSR_IA32_APERF, aperf); 678 rdmsrl(MSR_IA32_MPERF, mperf); 679 680 if (!intel_pstate_min_pstate() || 681 !intel_pstate_max_pstate() || 682 !intel_pstate_turbo_pstate()) 683 return -ENODEV; 684 685 rdmsrl(MSR_IA32_APERF, tmp); 686 if (!(tmp - aperf)) 687 return -ENODEV; 688 689 rdmsrl(MSR_IA32_MPERF, tmp); 690 if (!(tmp - mperf)) 691 return -ENODEV; 692 693 return 0; 694} 695static int __init intel_pstate_init(void) 696{ 697 int cpu, rc = 0; 698 const struct x86_cpu_id *id; 699 700 if (no_load) 701 return -ENODEV; 702 703 id = x86_match_cpu(intel_pstate_cpu_ids); 704 if (!id) 705 return -ENODEV; 706 707 if (intel_pstate_msrs_not_valid()) 708 return -ENODEV; 709 710 pr_info("Intel P-state driver initializing.\n"); 711 712 all_cpu_data = vzalloc(sizeof(void *) * num_possible_cpus()); 713 if (!all_cpu_data) 714 return -ENOMEM; 715 716 rc = cpufreq_register_driver(&intel_pstate_driver); 717 if (rc) 718 goto out; 719 720 intel_pstate_debug_expose_params(); 721 intel_pstate_sysfs_expose_params(); 722 return rc; 723out: 724 get_online_cpus(); 725 for_each_online_cpu(cpu) { 726 if (all_cpu_data[cpu]) { 727 del_timer_sync(&all_cpu_data[cpu]->timer); 728 kfree(all_cpu_data[cpu]); 729 } 730 } 731 732 put_online_cpus(); 733 vfree(all_cpu_data); 734 return -ENODEV; 735} 736device_initcall(intel_pstate_init); 737 738static int __init intel_pstate_setup(char *str) 739{ 740 if (!str) 741 return -EINVAL; 742 743 if (!strcmp(str, "disable")) 744 no_load = 1; 745 return 0; 746} 747early_param("intel_pstate", intel_pstate_setup); 748 749MODULE_AUTHOR("Dirk Brandewie <dirk.j.brandewie@intel.com>"); 750MODULE_DESCRIPTION("'intel_pstate' - P state driver Intel Core processors"); 751MODULE_LICENSE("GPL"); 752