2 * POWERNV cpufreq driver for the IBM POWER processors
4 * (C) Copyright IBM 2014
6 * Author: Vaidyanathan Srinivasan <svaidy at linux.vnet.ibm.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
20 #define pr_fmt(fmt) "powernv-cpufreq: " fmt
22 #include <linux/kernel.h>
23 #include <linux/sysfs.h>
24 #include <linux/cpumask.h>
25 #include <linux/module.h>
26 #include <linux/cpufreq.h>
27 #include <linux/smp.h>
29 #include <linux/reboot.h>
30 #include <linux/slab.h>
32 #include <asm/cputhreads.h>
33 #include <asm/firmware.h>
35 #include <asm/smp.h> /* Required for cpu_sibling_mask() in UP configs */
38 #define POWERNV_MAX_PSTATES 256
39 #define PMSR_PSAFE_ENABLE (1UL << 30)
40 #define PMSR_SPR_EM_DISABLE (1UL << 31)
41 #define PMSR_MAX(x) ((x >> 32) & 0xFF)
42 #define PMSR_LP(x) ((x >> 48) & 0xFF)
44 static struct cpufreq_frequency_table powernv_freqs
[POWERNV_MAX_PSTATES
+1];
45 static bool rebooting
, throttled
, occ_reset
;
51 struct work_struct throttle
;
57 * Note: The set of pstates consists of contiguous integers, the
58 * smallest of which is indicated by powernv_pstate_info.min, the
59 * largest of which is indicated by powernv_pstate_info.max.
61 * The nominal pstate is the highest non-turbo pstate in this
62 * platform. This is indicated by powernv_pstate_info.nominal.
64 static struct powernv_pstate_info
{
69 } powernv_pstate_info
;
72 * Initialize the freq table based on data obtained
73 * from the firmware passed via device-tree
75 static int init_powernv_pstates(void)
77 struct device_node
*power_mgt
;
78 int i
, pstate_min
, pstate_max
, pstate_nominal
, nr_pstates
= 0;
79 const __be32
*pstate_ids
, *pstate_freqs
;
80 u32 len_ids
, len_freqs
;
82 power_mgt
= of_find_node_by_path("/ibm,opal/power-mgt");
84 pr_warn("power-mgt node not found\n");
88 if (of_property_read_u32(power_mgt
, "ibm,pstate-min", &pstate_min
)) {
89 pr_warn("ibm,pstate-min node not found\n");
93 if (of_property_read_u32(power_mgt
, "ibm,pstate-max", &pstate_max
)) {
94 pr_warn("ibm,pstate-max node not found\n");
98 if (of_property_read_u32(power_mgt
, "ibm,pstate-nominal",
100 pr_warn("ibm,pstate-nominal not found\n");
103 pr_info("cpufreq pstate min %d nominal %d max %d\n", pstate_min
,
104 pstate_nominal
, pstate_max
);
106 pstate_ids
= of_get_property(power_mgt
, "ibm,pstate-ids", &len_ids
);
108 pr_warn("ibm,pstate-ids not found\n");
112 pstate_freqs
= of_get_property(power_mgt
, "ibm,pstate-frequencies-mhz",
115 pr_warn("ibm,pstate-frequencies-mhz not found\n");
119 if (len_ids
!= len_freqs
) {
120 pr_warn("Entries in ibm,pstate-ids and "
121 "ibm,pstate-frequencies-mhz does not match\n");
124 nr_pstates
= min(len_ids
, len_freqs
) / sizeof(u32
);
126 pr_warn("No PStates found\n");
130 pr_debug("NR PStates %d\n", nr_pstates
);
131 for (i
= 0; i
< nr_pstates
; i
++) {
132 u32 id
= be32_to_cpu(pstate_ids
[i
]);
133 u32 freq
= be32_to_cpu(pstate_freqs
[i
]);
135 pr_debug("PState id %d freq %d MHz\n", id
, freq
);
136 powernv_freqs
[i
].frequency
= freq
* 1000; /* kHz */
137 powernv_freqs
[i
].driver_data
= id
;
139 /* End of list marker entry */
140 powernv_freqs
[i
].frequency
= CPUFREQ_TABLE_END
;
142 powernv_pstate_info
.min
= pstate_min
;
143 powernv_pstate_info
.max
= pstate_max
;
144 powernv_pstate_info
.nominal
= pstate_nominal
;
145 powernv_pstate_info
.nr_pstates
= nr_pstates
;
150 /* Returns the CPU frequency corresponding to the pstate_id. */
151 static unsigned int pstate_id_to_freq(int pstate_id
)
155 i
= powernv_pstate_info
.max
- pstate_id
;
156 if (i
>= powernv_pstate_info
.nr_pstates
|| i
< 0) {
157 pr_warn("PState id %d outside of PState table, "
158 "reporting nominal id %d instead\n",
159 pstate_id
, powernv_pstate_info
.nominal
);
160 i
= powernv_pstate_info
.max
- powernv_pstate_info
.nominal
;
163 return powernv_freqs
[i
].frequency
;
167 * cpuinfo_nominal_freq_show - Show the nominal CPU frequency as indicated by
170 static ssize_t
cpuinfo_nominal_freq_show(struct cpufreq_policy
*policy
,
173 return sprintf(buf
, "%u\n",
174 pstate_id_to_freq(powernv_pstate_info
.nominal
));
177 struct freq_attr cpufreq_freq_attr_cpuinfo_nominal_freq
=
178 __ATTR_RO(cpuinfo_nominal_freq
);
180 static struct freq_attr
*powernv_cpu_freq_attr
[] = {
181 &cpufreq_freq_attr_scaling_available_freqs
,
182 &cpufreq_freq_attr_cpuinfo_nominal_freq
,
186 /* Helper routines */
188 /* Access helpers to power mgt SPR */
190 static inline unsigned long get_pmspr(unsigned long sprn
)
194 return mfspr(SPRN_PMCR
);
197 return mfspr(SPRN_PMICR
);
200 return mfspr(SPRN_PMSR
);
205 static inline void set_pmspr(unsigned long sprn
, unsigned long val
)
209 mtspr(SPRN_PMCR
, val
);
213 mtspr(SPRN_PMICR
, val
);
220 * Use objects of this type to query/update
221 * pstates on a remote CPU via smp_call_function.
223 struct powernv_smp_call_data
{
229 * powernv_read_cpu_freq: Reads the current frequency on this CPU.
231 * Called via smp_call_function.
233 * Note: The caller of the smp_call_function should pass an argument of
234 * the type 'struct powernv_smp_call_data *' along with this function.
236 * The current frequency on this CPU will be returned via
237 * ((struct powernv_smp_call_data *)arg)->freq;
239 static void powernv_read_cpu_freq(void *arg
)
241 unsigned long pmspr_val
;
243 struct powernv_smp_call_data
*freq_data
= arg
;
245 pmspr_val
= get_pmspr(SPRN_PMSR
);
248 * The local pstate id corresponds bits 48..55 in the PMSR.
249 * Note: Watch out for the sign!
251 local_pstate_id
= (pmspr_val
>> 48) & 0xFF;
252 freq_data
->pstate_id
= local_pstate_id
;
253 freq_data
->freq
= pstate_id_to_freq(freq_data
->pstate_id
);
255 pr_debug("cpu %d pmsr %016lX pstate_id %d frequency %d kHz\n",
256 raw_smp_processor_id(), pmspr_val
, freq_data
->pstate_id
,
261 * powernv_cpufreq_get: Returns the CPU frequency as reported by the
262 * firmware for CPU 'cpu'. This value is reported through the sysfs
263 * file cpuinfo_cur_freq.
265 static unsigned int powernv_cpufreq_get(unsigned int cpu
)
267 struct powernv_smp_call_data freq_data
;
269 smp_call_function_any(cpu_sibling_mask(cpu
), powernv_read_cpu_freq
,
272 return freq_data
.freq
;
276 * set_pstate: Sets the pstate on this CPU.
278 * This is called via an smp_call_function.
280 * The caller must ensure that freq_data is of the type
281 * (struct powernv_smp_call_data *) and the pstate_id which needs to be set
282 * on this CPU should be present in freq_data->pstate_id.
284 static void set_pstate(void *freq_data
)
287 unsigned long pstate_ul
=
288 ((struct powernv_smp_call_data
*) freq_data
)->pstate_id
;
290 val
= get_pmspr(SPRN_PMCR
);
291 val
= val
& 0x0000FFFFFFFFFFFFULL
;
293 pstate_ul
= pstate_ul
& 0xFF;
295 /* Set both global(bits 56..63) and local(bits 48..55) PStates */
296 val
= val
| (pstate_ul
<< 56) | (pstate_ul
<< 48);
298 pr_debug("Setting cpu %d pmcr to %016lX\n",
299 raw_smp_processor_id(), val
);
300 set_pmspr(SPRN_PMCR
, val
);
304 * get_nominal_index: Returns the index corresponding to the nominal
305 * pstate in the cpufreq table
307 static inline unsigned int get_nominal_index(void)
309 return powernv_pstate_info
.max
- powernv_pstate_info
.nominal
;
312 static void powernv_cpufreq_throttle_check(void *data
)
314 unsigned int cpu
= smp_processor_id();
316 int pmsr_pmax
, pmsr_lp
, i
;
318 pmsr
= get_pmspr(SPRN_PMSR
);
320 for (i
= 0; i
< nr_chips
; i
++)
321 if (chips
[i
].id
== cpu_to_chip_id(cpu
))
324 /* Check for Pmax Capping */
325 pmsr_pmax
= (s8
)PMSR_MAX(pmsr
);
326 if (pmsr_pmax
!= powernv_pstate_info
.max
) {
327 if (chips
[i
].throttled
)
329 chips
[i
].throttled
= true;
330 pr_info("CPU %d on Chip %u has Pmax reduced to %d\n", cpu
,
331 chips
[i
].id
, pmsr_pmax
);
332 } else if (chips
[i
].throttled
) {
333 chips
[i
].throttled
= false;
334 pr_info("CPU %d on Chip %u has Pmax restored to %d\n", cpu
,
335 chips
[i
].id
, pmsr_pmax
);
339 * Check for Psafe by reading LocalPstate
340 * or check if Psafe_mode_active is set in PMSR.
343 pmsr_lp
= (s8
)PMSR_LP(pmsr
);
344 if ((pmsr_lp
< powernv_pstate_info
.min
) ||
345 (pmsr
& PMSR_PSAFE_ENABLE
)) {
347 pr_info("Pstate set to safe frequency\n");
350 /* Check if SPR_EM_DISABLE is set in PMSR */
351 if (pmsr
& PMSR_SPR_EM_DISABLE
) {
353 pr_info("Frequency Control disabled from OS\n");
357 pr_info("PMSR = %16lx\n", pmsr
);
358 pr_crit("CPU Frequency could be throttled\n");
363 * powernv_cpufreq_target_index: Sets the frequency corresponding to
364 * the cpufreq table entry indexed by new_index on the cpus in the
367 static int powernv_cpufreq_target_index(struct cpufreq_policy
*policy
,
368 unsigned int new_index
)
370 struct powernv_smp_call_data freq_data
;
372 if (unlikely(rebooting
) && new_index
!= get_nominal_index())
376 powernv_cpufreq_throttle_check(NULL
);
378 freq_data
.pstate_id
= powernv_freqs
[new_index
].driver_data
;
381 * Use smp_call_function to send IPI and execute the
382 * mtspr on target CPU. We could do that without IPI
383 * if current CPU is within policy->cpus (core)
385 smp_call_function_any(policy
->cpus
, set_pstate
, &freq_data
, 1);
390 static int powernv_cpufreq_cpu_init(struct cpufreq_policy
*policy
)
394 base
= cpu_first_thread_sibling(policy
->cpu
);
396 for (i
= 0; i
< threads_per_core
; i
++)
397 cpumask_set_cpu(base
+ i
, policy
->cpus
);
399 return cpufreq_table_validate_and_show(policy
, powernv_freqs
);
402 static int powernv_cpufreq_reboot_notifier(struct notifier_block
*nb
,
403 unsigned long action
, void *unused
)
406 struct cpufreq_policy cpu_policy
;
409 for_each_online_cpu(cpu
) {
410 cpufreq_get_policy(&cpu_policy
, cpu
);
411 powernv_cpufreq_target_index(&cpu_policy
, get_nominal_index());
417 static struct notifier_block powernv_cpufreq_reboot_nb
= {
418 .notifier_call
= powernv_cpufreq_reboot_notifier
,
421 void powernv_cpufreq_work_fn(struct work_struct
*work
)
423 struct chip
*chip
= container_of(work
, struct chip
, throttle
);
425 smp_call_function_any(&chip
->mask
,
426 powernv_cpufreq_throttle_check
, NULL
, 0);
429 static char throttle_reason
[][30] = {
432 "Processor Over Temperature",
433 "Power Supply Failure",
438 static int powernv_cpufreq_occ_msg(struct notifier_block
*nb
,
439 unsigned long msg_type
, void *_msg
)
441 struct opal_msg
*msg
= _msg
;
442 struct opal_occ_msg omsg
;
445 if (msg_type
!= OPAL_MSG_OCC
)
448 omsg
.type
= be64_to_cpu(msg
->params
[0]);
454 * powernv_cpufreq_throttle_check() is called in
455 * target() callback which can detect the throttle state
456 * for governors like ondemand.
457 * But static governors will not call target() often thus
458 * report throttling here.
462 pr_crit("CPU Frequency is throttled\n");
464 pr_info("OCC: Reset\n");
467 pr_info("OCC: Loaded\n");
470 omsg
.chip
= be64_to_cpu(msg
->params
[1]);
471 omsg
.throttle_status
= be64_to_cpu(msg
->params
[2]);
476 pr_info("OCC: Active\n");
478 for (i
= 0; i
< nr_chips
; i
++)
479 schedule_work(&chips
[i
].throttle
);
484 if (omsg
.throttle_status
&&
485 omsg
.throttle_status
<= OCC_MAX_THROTTLE_STATUS
)
486 pr_info("OCC: Chip %u Pmax reduced due to %s\n",
487 (unsigned int)omsg
.chip
,
488 throttle_reason
[omsg
.throttle_status
]);
489 else if (!omsg
.throttle_status
)
490 pr_info("OCC: Chip %u %s\n", (unsigned int)omsg
.chip
,
491 throttle_reason
[omsg
.throttle_status
]);
495 for (i
= 0; i
< nr_chips
; i
++)
496 if (chips
[i
].id
== omsg
.chip
)
497 schedule_work(&chips
[i
].throttle
);
502 static struct notifier_block powernv_cpufreq_opal_nb
= {
503 .notifier_call
= powernv_cpufreq_occ_msg
,
508 static void powernv_cpufreq_stop_cpu(struct cpufreq_policy
*policy
)
510 struct powernv_smp_call_data freq_data
;
512 freq_data
.pstate_id
= powernv_pstate_info
.min
;
513 smp_call_function_single(policy
->cpu
, set_pstate
, &freq_data
, 1);
516 static struct cpufreq_driver powernv_cpufreq_driver
= {
517 .name
= "powernv-cpufreq",
518 .flags
= CPUFREQ_CONST_LOOPS
,
519 .init
= powernv_cpufreq_cpu_init
,
520 .verify
= cpufreq_generic_frequency_table_verify
,
521 .target_index
= powernv_cpufreq_target_index
,
522 .get
= powernv_cpufreq_get
,
523 .stop_cpu
= powernv_cpufreq_stop_cpu
,
524 .attr
= powernv_cpu_freq_attr
,
527 static int init_chip_info(void)
529 unsigned int chip
[256];
531 unsigned int prev_chip_id
= UINT_MAX
;
533 for_each_possible_cpu(cpu
) {
534 unsigned int id
= cpu_to_chip_id(cpu
);
536 if (prev_chip_id
!= id
) {
538 chip
[nr_chips
++] = id
;
542 chips
= kmalloc_array(nr_chips
, sizeof(struct chip
), GFP_KERNEL
);
546 for (i
= 0; i
< nr_chips
; i
++) {
547 chips
[i
].id
= chip
[i
];
548 chips
[i
].throttled
= false;
549 cpumask_copy(&chips
[i
].mask
, cpumask_of_node(chip
[i
]));
550 INIT_WORK(&chips
[i
].throttle
, powernv_cpufreq_work_fn
);
556 static int __init
powernv_cpufreq_init(void)
560 /* Don't probe on pseries (guest) platforms */
561 if (!firmware_has_feature(FW_FEATURE_OPALv3
))
564 /* Discover pstates from device tree and init */
565 rc
= init_powernv_pstates();
567 pr_info("powernv-cpufreq disabled. System does not support PState control\n");
571 /* Populate chip info */
572 rc
= init_chip_info();
576 register_reboot_notifier(&powernv_cpufreq_reboot_nb
);
577 opal_message_notifier_register(OPAL_MSG_OCC
, &powernv_cpufreq_opal_nb
);
578 return cpufreq_register_driver(&powernv_cpufreq_driver
);
580 module_init(powernv_cpufreq_init
);
582 static void __exit
powernv_cpufreq_exit(void)
584 unregister_reboot_notifier(&powernv_cpufreq_reboot_nb
);
585 opal_message_notifier_unregister(OPAL_MSG_OCC
,
586 &powernv_cpufreq_opal_nb
);
587 cpufreq_unregister_driver(&powernv_cpufreq_driver
);
589 module_exit(powernv_cpufreq_exit
);
591 MODULE_LICENSE("GPL");
592 MODULE_AUTHOR("Vaidyanathan Srinivasan <svaidy at linux.vnet.ibm.com>");