1 // SPDX-License-Identifier: GPL-2.0-only
3 * x86_pkg_temp_thermal driver
4 * Copyright (c) 2013, Intel Corporation.
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/err.h>
11 #include <linux/param.h>
12 #include <linux/device.h>
13 #include <linux/platform_device.h>
14 #include <linux/cpu.h>
15 #include <linux/smp.h>
16 #include <linux/slab.h>
18 #include <linux/thermal.h>
19 #include <linux/debugfs.h>
20 #include <asm/cpu_device_id.h>
24 * Rate control delay: Idea is to introduce denounce effect
25 * This should be long enough to avoid reduce events, when
26 * threshold is set to a temperature, which is constantly
27 * violated, but at the short enough to take any action.
28 * The action can be remove threshold or change it to next
29 * interesting setting. Based on experiments, in around
30 * every 5 seconds under load will give us a significant
33 #define PKG_TEMP_THERMAL_NOTIFY_DELAY 5000
34 static int notify_delay_ms
= PKG_TEMP_THERMAL_NOTIFY_DELAY
;
35 module_param(notify_delay_ms
, int, 0644);
36 MODULE_PARM_DESC(notify_delay_ms
,
37 "User space notification delay in milli seconds.");
39 /* Number of trip points in thermal zone. Currently it can't
40 * be more than 2. MSR can allow setting and getting notifications
41 * for only 2 thresholds. This define enforces this, if there
42 * is some wrong values returned by cpuid for number of thresholds.
44 #define MAX_NUMBER_OF_TRIPS 2
50 u32 msr_pkg_therm_low
;
51 u32 msr_pkg_therm_high
;
52 struct delayed_work work
;
53 struct thermal_zone_device
*tzone
;
54 struct cpumask cpumask
;
57 static struct thermal_zone_params pkg_temp_tz_params
= {
61 /* Keep track of how many package pointers we allocated in init() */
62 static int max_packages __read_mostly
;
63 /* Array of package pointers */
64 static struct pkg_device
**packages
;
65 /* Serializes interrupt notification, work and hotplug */
66 static DEFINE_SPINLOCK(pkg_temp_lock
);
67 /* Protects zone operation in the work function against hotplug removal */
68 static DEFINE_MUTEX(thermal_zone_mutex
);
70 /* The dynamically assigned cpu hotplug state for module_exit() */
71 static enum cpuhp_state pkg_thermal_hp_state __read_mostly
;
73 /* Debug counters to show using debugfs */
74 static struct dentry
*debugfs
;
75 static unsigned int pkg_interrupt_cnt
;
76 static unsigned int pkg_work_cnt
;
78 static int pkg_temp_debugfs_init(void)
82 debugfs
= debugfs_create_dir("pkg_temp_thermal", NULL
);
86 d
= debugfs_create_u32("pkg_thres_interrupt", S_IRUGO
, debugfs
,
91 d
= debugfs_create_u32("pkg_thres_work", S_IRUGO
, debugfs
,
99 debugfs_remove_recursive(debugfs
);
106 * - cpu hotplug: Read serialized by cpu hotplug lock
107 * Write must hold pkg_temp_lock
109 * - Other callsites: Must hold pkg_temp_lock
111 static struct pkg_device
*pkg_temp_thermal_get_dev(unsigned int cpu
)
113 int pkgid
= topology_logical_package_id(cpu
);
115 if (pkgid
>= 0 && pkgid
< max_packages
)
116 return packages
[pkgid
];
121 * tj-max is is interesting because threshold is set relative to this
124 static int get_tj_max(int cpu
, u32
*tj_max
)
129 err
= rdmsr_safe_on_cpu(cpu
, MSR_IA32_TEMPERATURE_TARGET
, &eax
, &edx
);
133 val
= (eax
>> 16) & 0xff;
134 *tj_max
= val
* 1000;
136 return val
? 0 : -EINVAL
;
139 static int sys_get_curr_temp(struct thermal_zone_device
*tzd
, int *temp
)
141 struct pkg_device
*pkgdev
= tzd
->devdata
;
144 rdmsr_on_cpu(pkgdev
->cpu
, MSR_IA32_PACKAGE_THERM_STATUS
, &eax
, &edx
);
145 if (eax
& 0x80000000) {
146 *temp
= pkgdev
->tj_max
- ((eax
>> 16) & 0x7f) * 1000;
147 pr_debug("sys_get_curr_temp %d\n", *temp
);
153 static int sys_get_trip_temp(struct thermal_zone_device
*tzd
,
156 struct pkg_device
*pkgdev
= tzd
->devdata
;
157 unsigned long thres_reg_value
;
158 u32 mask
, shift
, eax
, edx
;
161 if (trip
>= MAX_NUMBER_OF_TRIPS
)
165 mask
= THERM_MASK_THRESHOLD1
;
166 shift
= THERM_SHIFT_THRESHOLD1
;
168 mask
= THERM_MASK_THRESHOLD0
;
169 shift
= THERM_SHIFT_THRESHOLD0
;
172 ret
= rdmsr_on_cpu(pkgdev
->cpu
, MSR_IA32_PACKAGE_THERM_INTERRUPT
,
177 thres_reg_value
= (eax
& mask
) >> shift
;
179 *temp
= pkgdev
->tj_max
- thres_reg_value
* 1000;
182 pr_debug("sys_get_trip_temp %d\n", *temp
);
188 sys_set_trip_temp(struct thermal_zone_device
*tzd
, int trip
, int temp
)
190 struct pkg_device
*pkgdev
= tzd
->devdata
;
191 u32 l
, h
, mask
, shift
, intr
;
194 if (trip
>= MAX_NUMBER_OF_TRIPS
|| temp
>= pkgdev
->tj_max
)
197 ret
= rdmsr_on_cpu(pkgdev
->cpu
, MSR_IA32_PACKAGE_THERM_INTERRUPT
,
203 mask
= THERM_MASK_THRESHOLD1
;
204 shift
= THERM_SHIFT_THRESHOLD1
;
205 intr
= THERM_INT_THRESHOLD1_ENABLE
;
207 mask
= THERM_MASK_THRESHOLD0
;
208 shift
= THERM_SHIFT_THRESHOLD0
;
209 intr
= THERM_INT_THRESHOLD0_ENABLE
;
213 * When users space sets a trip temperature == 0, which is indication
214 * that, it is no longer interested in receiving notifications.
219 l
|= (pkgdev
->tj_max
- temp
)/1000 << shift
;
223 return wrmsr_on_cpu(pkgdev
->cpu
, MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
226 static int sys_get_trip_type(struct thermal_zone_device
*thermal
, int trip
,
227 enum thermal_trip_type
*type
)
229 *type
= THERMAL_TRIP_PASSIVE
;
233 /* Thermal zone callback registry */
234 static struct thermal_zone_device_ops tzone_ops
= {
235 .get_temp
= sys_get_curr_temp
,
236 .get_trip_temp
= sys_get_trip_temp
,
237 .get_trip_type
= sys_get_trip_type
,
238 .set_trip_temp
= sys_set_trip_temp
,
241 static bool pkg_thermal_rate_control(void)
246 /* Enable threshold interrupt on local package/cpu */
247 static inline void enable_pkg_thres_interrupt(void)
252 rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
253 /* only enable/disable if it had valid threshold value */
254 thres_0
= (l
& THERM_MASK_THRESHOLD0
) >> THERM_SHIFT_THRESHOLD0
;
255 thres_1
= (l
& THERM_MASK_THRESHOLD1
) >> THERM_SHIFT_THRESHOLD1
;
257 l
|= THERM_INT_THRESHOLD0_ENABLE
;
259 l
|= THERM_INT_THRESHOLD1_ENABLE
;
260 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
263 /* Disable threshold interrupt on local package/cpu */
264 static inline void disable_pkg_thres_interrupt(void)
268 rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
270 l
&= ~(THERM_INT_THRESHOLD0_ENABLE
| THERM_INT_THRESHOLD1_ENABLE
);
271 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
274 static void pkg_temp_thermal_threshold_work_fn(struct work_struct
*work
)
276 struct thermal_zone_device
*tzone
= NULL
;
277 int cpu
= smp_processor_id();
278 struct pkg_device
*pkgdev
;
281 mutex_lock(&thermal_zone_mutex
);
282 spin_lock_irq(&pkg_temp_lock
);
285 pkgdev
= pkg_temp_thermal_get_dev(cpu
);
287 spin_unlock_irq(&pkg_temp_lock
);
288 mutex_unlock(&thermal_zone_mutex
);
291 pkgdev
->work_scheduled
= false;
293 rdmsrl(MSR_IA32_PACKAGE_THERM_STATUS
, msr_val
);
294 wr_val
= msr_val
& ~(THERM_LOG_THRESHOLD0
| THERM_LOG_THRESHOLD1
);
295 if (wr_val
!= msr_val
) {
296 wrmsrl(MSR_IA32_PACKAGE_THERM_STATUS
, wr_val
);
297 tzone
= pkgdev
->tzone
;
300 enable_pkg_thres_interrupt();
301 spin_unlock_irq(&pkg_temp_lock
);
304 * If tzone is not NULL, then thermal_zone_mutex will prevent the
305 * concurrent removal in the cpu offline callback.
308 thermal_zone_device_update(tzone
, THERMAL_EVENT_UNSPECIFIED
);
310 mutex_unlock(&thermal_zone_mutex
);
313 static void pkg_thermal_schedule_work(int cpu
, struct delayed_work
*work
)
315 unsigned long ms
= msecs_to_jiffies(notify_delay_ms
);
317 schedule_delayed_work_on(cpu
, work
, ms
);
320 static int pkg_thermal_notify(u64 msr_val
)
322 int cpu
= smp_processor_id();
323 struct pkg_device
*pkgdev
;
326 spin_lock_irqsave(&pkg_temp_lock
, flags
);
329 disable_pkg_thres_interrupt();
331 /* Work is per package, so scheduling it once is enough. */
332 pkgdev
= pkg_temp_thermal_get_dev(cpu
);
333 if (pkgdev
&& !pkgdev
->work_scheduled
) {
334 pkgdev
->work_scheduled
= true;
335 pkg_thermal_schedule_work(pkgdev
->cpu
, &pkgdev
->work
);
338 spin_unlock_irqrestore(&pkg_temp_lock
, flags
);
342 static int pkg_temp_thermal_device_add(unsigned int cpu
)
344 int pkgid
= topology_logical_package_id(cpu
);
345 u32 tj_max
, eax
, ebx
, ecx
, edx
;
346 struct pkg_device
*pkgdev
;
347 int thres_count
, err
;
349 if (pkgid
>= max_packages
)
352 cpuid(6, &eax
, &ebx
, &ecx
, &edx
);
353 thres_count
= ebx
& 0x07;
357 thres_count
= clamp_val(thres_count
, 0, MAX_NUMBER_OF_TRIPS
);
359 err
= get_tj_max(cpu
, &tj_max
);
363 pkgdev
= kzalloc(sizeof(*pkgdev
), GFP_KERNEL
);
367 INIT_DELAYED_WORK(&pkgdev
->work
, pkg_temp_thermal_threshold_work_fn
);
369 pkgdev
->tj_max
= tj_max
;
370 pkgdev
->tzone
= thermal_zone_device_register("x86_pkg_temp",
372 (thres_count
== MAX_NUMBER_OF_TRIPS
) ? 0x03 : 0x01,
373 pkgdev
, &tzone_ops
, &pkg_temp_tz_params
, 0, 0);
374 if (IS_ERR(pkgdev
->tzone
)) {
375 err
= PTR_ERR(pkgdev
->tzone
);
379 /* Store MSR value for package thermal interrupt, to restore at exit */
380 rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, pkgdev
->msr_pkg_therm_low
,
381 pkgdev
->msr_pkg_therm_high
);
383 cpumask_set_cpu(cpu
, &pkgdev
->cpumask
);
384 spin_lock_irq(&pkg_temp_lock
);
385 packages
[pkgid
] = pkgdev
;
386 spin_unlock_irq(&pkg_temp_lock
);
390 static int pkg_thermal_cpu_offline(unsigned int cpu
)
392 struct pkg_device
*pkgdev
= pkg_temp_thermal_get_dev(cpu
);
393 bool lastcpu
, was_target
;
399 target
= cpumask_any_but(&pkgdev
->cpumask
, cpu
);
400 cpumask_clear_cpu(cpu
, &pkgdev
->cpumask
);
401 lastcpu
= target
>= nr_cpu_ids
;
403 * Remove the sysfs files, if this is the last cpu in the package
404 * before doing further cleanups.
407 struct thermal_zone_device
*tzone
= pkgdev
->tzone
;
410 * We must protect against a work function calling
411 * thermal_zone_update, after/while unregister. We null out
412 * the pointer under the zone mutex, so the worker function
415 mutex_lock(&thermal_zone_mutex
);
416 pkgdev
->tzone
= NULL
;
417 mutex_unlock(&thermal_zone_mutex
);
419 thermal_zone_device_unregister(tzone
);
422 /* Protect against work and interrupts */
423 spin_lock_irq(&pkg_temp_lock
);
426 * Check whether this cpu was the current target and store the new
427 * one. When we drop the lock, then the interrupt notify function
428 * will see the new target.
430 was_target
= pkgdev
->cpu
== cpu
;
431 pkgdev
->cpu
= target
;
434 * If this is the last CPU in the package remove the package
435 * reference from the array and restore the interrupt MSR. When we
436 * drop the lock neither the interrupt notify function nor the
437 * worker will see the package anymore.
440 packages
[topology_logical_package_id(cpu
)] = NULL
;
441 /* After this point nothing touches the MSR anymore. */
442 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
,
443 pkgdev
->msr_pkg_therm_low
, pkgdev
->msr_pkg_therm_high
);
447 * Check whether there is work scheduled and whether the work is
448 * targeted at the outgoing CPU.
450 if (pkgdev
->work_scheduled
&& was_target
) {
452 * To cancel the work we need to drop the lock, otherwise
453 * we might deadlock if the work needs to be flushed.
455 spin_unlock_irq(&pkg_temp_lock
);
456 cancel_delayed_work_sync(&pkgdev
->work
);
457 spin_lock_irq(&pkg_temp_lock
);
459 * If this is not the last cpu in the package and the work
460 * did not run after we dropped the lock above, then we
461 * need to reschedule the work, otherwise the interrupt
462 * stays disabled forever.
464 if (!lastcpu
&& pkgdev
->work_scheduled
)
465 pkg_thermal_schedule_work(target
, &pkgdev
->work
);
468 spin_unlock_irq(&pkg_temp_lock
);
470 /* Final cleanup if this is the last cpu */
476 static int pkg_thermal_cpu_online(unsigned int cpu
)
478 struct pkg_device
*pkgdev
= pkg_temp_thermal_get_dev(cpu
);
479 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
482 if (!cpu_has(c
, X86_FEATURE_DTHERM
) || !cpu_has(c
, X86_FEATURE_PTS
))
485 /* If the package exists, nothing to do */
487 cpumask_set_cpu(cpu
, &pkgdev
->cpumask
);
490 return pkg_temp_thermal_device_add(cpu
);
493 static const struct x86_cpu_id __initconst pkg_temp_thermal_ids
[] = {
494 { X86_VENDOR_INTEL
, X86_FAMILY_ANY
, X86_MODEL_ANY
, X86_FEATURE_PTS
},
497 MODULE_DEVICE_TABLE(x86cpu
, pkg_temp_thermal_ids
);
499 static int __init
pkg_temp_thermal_init(void)
503 if (!x86_match_cpu(pkg_temp_thermal_ids
))
506 max_packages
= topology_max_packages();
507 packages
= kcalloc(max_packages
, sizeof(struct pkg_device
*),
512 ret
= cpuhp_setup_state(CPUHP_AP_ONLINE_DYN
, "thermal/x86_pkg:online",
513 pkg_thermal_cpu_online
, pkg_thermal_cpu_offline
);
517 /* Store the state for module exit */
518 pkg_thermal_hp_state
= ret
;
520 platform_thermal_package_notify
= pkg_thermal_notify
;
521 platform_thermal_package_rate_control
= pkg_thermal_rate_control
;
523 /* Don't care if it fails */
524 pkg_temp_debugfs_init();
531 module_init(pkg_temp_thermal_init
)
533 static void __exit
pkg_temp_thermal_exit(void)
535 platform_thermal_package_notify
= NULL
;
536 platform_thermal_package_rate_control
= NULL
;
538 cpuhp_remove_state(pkg_thermal_hp_state
);
539 debugfs_remove_recursive(debugfs
);
542 module_exit(pkg_temp_thermal_exit
)
544 MODULE_DESCRIPTION("X86 PKG TEMP Thermal Driver");
545 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
546 MODULE_LICENSE("GPL v2");