intel_pstate.c 18 KB

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