2 * x86_pkg_temp_thermal driver
3 * Copyright (c) 2013, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/err.h>
23 #include <linux/param.h>
24 #include <linux/device.h>
25 #include <linux/platform_device.h>
26 #include <linux/cpu.h>
27 #include <linux/smp.h>
28 #include <linux/slab.h>
30 #include <linux/thermal.h>
31 #include <linux/debugfs.h>
32 #include <asm/cpu_device_id.h>
36 * Rate control delay: Idea is to introduce denounce effect
37 * This should be long enough to avoid reduce events, when
38 * threshold is set to a temperature, which is constantly
39 * violated, but at the short enough to take any action.
40 * The action can be remove threshold or change it to next
41 * interesting setting. Based on experiments, in around
42 * every 5 seconds under load will give us a significant
45 #define PKG_TEMP_THERMAL_NOTIFY_DELAY 5000
46 static int notify_delay_ms
= PKG_TEMP_THERMAL_NOTIFY_DELAY
;
47 module_param(notify_delay_ms
, int, 0644);
48 MODULE_PARM_DESC(notify_delay_ms
,
49 "User space notification delay in milli seconds.");
51 /* Number of trip points in thermal zone. Currently it can't
52 * be more than 2. MSR can allow setting and getting notifications
53 * for only 2 thresholds. This define enforces this, if there
54 * is some wrong values returned by cpuid for number of thresholds.
56 #define MAX_NUMBER_OF_TRIPS 2
57 /* Limit number of package temp zones */
58 #define MAX_PKG_TEMP_ZONE_IDS 256
60 struct phy_dev_entry
{
61 struct list_head list
;
66 u32 start_pkg_therm_low
;
67 u32 start_pkg_therm_high
;
68 struct thermal_zone_device
*tzone
;
71 static struct thermal_zone_params pkg_temp_tz_params
= {
75 /* List maintaining number of package instances */
76 static LIST_HEAD(phy_dev_list
);
77 static DEFINE_MUTEX(phy_dev_list_mutex
);
79 /* Interrupt to work function schedule queue */
80 static DEFINE_PER_CPU(struct delayed_work
, pkg_temp_thermal_threshold_work
);
82 /* To track if the work is already scheduled on a package */
83 static u8
*pkg_work_scheduled
;
85 /* Spin lock to prevent races with pkg_work_scheduled */
86 static spinlock_t pkg_work_lock
;
87 static u16 max_phy_id
;
89 /* Debug counters to show using debugfs */
90 static struct dentry
*debugfs
;
91 static unsigned int pkg_interrupt_cnt
;
92 static unsigned int pkg_work_cnt
;
94 static int pkg_temp_debugfs_init(void)
98 debugfs
= debugfs_create_dir("pkg_temp_thermal", NULL
);
102 d
= debugfs_create_u32("pkg_thres_interrupt", S_IRUGO
, debugfs
,
103 (u32
*)&pkg_interrupt_cnt
);
107 d
= debugfs_create_u32("pkg_thres_work", S_IRUGO
, debugfs
,
108 (u32
*)&pkg_work_cnt
);
115 debugfs_remove_recursive(debugfs
);
119 static struct phy_dev_entry
120 *pkg_temp_thermal_get_phy_entry(unsigned int cpu
)
122 u16 phys_proc_id
= topology_physical_package_id(cpu
);
123 struct phy_dev_entry
*phy_ptr
;
125 mutex_lock(&phy_dev_list_mutex
);
127 list_for_each_entry(phy_ptr
, &phy_dev_list
, list
)
128 if (phy_ptr
->phys_proc_id
== phys_proc_id
) {
129 mutex_unlock(&phy_dev_list_mutex
);
133 mutex_unlock(&phy_dev_list_mutex
);
139 * tj-max is is interesting because threshold is set relative to this
142 static int get_tj_max(int cpu
, u32
*tj_max
)
148 err
= rdmsr_safe_on_cpu(cpu
, MSR_IA32_TEMPERATURE_TARGET
, &eax
, &edx
);
152 val
= (eax
>> 16) & 0xff;
154 *tj_max
= val
* 1000;
167 static int sys_get_curr_temp(struct thermal_zone_device
*tzd
, int *temp
)
170 struct phy_dev_entry
*phy_dev_entry
;
172 phy_dev_entry
= tzd
->devdata
;
173 rdmsr_on_cpu(phy_dev_entry
->first_cpu
, MSR_IA32_PACKAGE_THERM_STATUS
,
175 if (eax
& 0x80000000) {
176 *temp
= phy_dev_entry
->tj_max
-
177 ((eax
>> 16) & 0x7f) * 1000;
178 pr_debug("sys_get_curr_temp %d\n", *temp
);
185 static int sys_get_trip_temp(struct thermal_zone_device
*tzd
,
189 struct phy_dev_entry
*phy_dev_entry
;
191 unsigned long thres_reg_value
;
194 if (trip
>= MAX_NUMBER_OF_TRIPS
)
197 phy_dev_entry
= tzd
->devdata
;
200 mask
= THERM_MASK_THRESHOLD1
;
201 shift
= THERM_SHIFT_THRESHOLD1
;
203 mask
= THERM_MASK_THRESHOLD0
;
204 shift
= THERM_SHIFT_THRESHOLD0
;
207 ret
= rdmsr_on_cpu(phy_dev_entry
->first_cpu
,
208 MSR_IA32_PACKAGE_THERM_INTERRUPT
, &eax
, &edx
);
212 thres_reg_value
= (eax
& mask
) >> shift
;
214 *temp
= phy_dev_entry
->tj_max
- thres_reg_value
* 1000;
217 pr_debug("sys_get_trip_temp %d\n", *temp
);
222 static int sys_set_trip_temp(struct thermal_zone_device
*tzd
, int trip
,
226 struct phy_dev_entry
*phy_dev_entry
;
227 u32 mask
, shift
, intr
;
230 phy_dev_entry
= tzd
->devdata
;
232 if (trip
>= MAX_NUMBER_OF_TRIPS
|| temp
>= phy_dev_entry
->tj_max
)
235 ret
= rdmsr_on_cpu(phy_dev_entry
->first_cpu
,
236 MSR_IA32_PACKAGE_THERM_INTERRUPT
,
242 mask
= THERM_MASK_THRESHOLD1
;
243 shift
= THERM_SHIFT_THRESHOLD1
;
244 intr
= THERM_INT_THRESHOLD1_ENABLE
;
246 mask
= THERM_MASK_THRESHOLD0
;
247 shift
= THERM_SHIFT_THRESHOLD0
;
248 intr
= THERM_INT_THRESHOLD0_ENABLE
;
252 * When users space sets a trip temperature == 0, which is indication
253 * that, it is no longer interested in receiving notifications.
258 l
|= (phy_dev_entry
->tj_max
- temp
)/1000 << shift
;
262 return wrmsr_on_cpu(phy_dev_entry
->first_cpu
,
263 MSR_IA32_PACKAGE_THERM_INTERRUPT
,
267 static int sys_get_trip_type(struct thermal_zone_device
*thermal
,
268 int trip
, enum thermal_trip_type
*type
)
271 *type
= THERMAL_TRIP_PASSIVE
;
276 /* Thermal zone callback registry */
277 static struct thermal_zone_device_ops tzone_ops
= {
278 .get_temp
= sys_get_curr_temp
,
279 .get_trip_temp
= sys_get_trip_temp
,
280 .get_trip_type
= sys_get_trip_type
,
281 .set_trip_temp
= sys_set_trip_temp
,
284 static bool pkg_temp_thermal_platform_thermal_rate_control(void)
289 /* Enable threshold interrupt on local package/cpu */
290 static inline void enable_pkg_thres_interrupt(void)
295 rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
296 /* only enable/disable if it had valid threshold value */
297 thres_0
= (l
& THERM_MASK_THRESHOLD0
) >> THERM_SHIFT_THRESHOLD0
;
298 thres_1
= (l
& THERM_MASK_THRESHOLD1
) >> THERM_SHIFT_THRESHOLD1
;
300 l
|= THERM_INT_THRESHOLD0_ENABLE
;
302 l
|= THERM_INT_THRESHOLD1_ENABLE
;
303 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
306 /* Disable threshold interrupt on local package/cpu */
307 static inline void disable_pkg_thres_interrupt(void)
310 rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
, l
, h
);
311 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT
,
312 l
& (~THERM_INT_THRESHOLD0_ENABLE
) &
313 (~THERM_INT_THRESHOLD1_ENABLE
), h
);
316 static void pkg_temp_thermal_threshold_work_fn(struct work_struct
*work
)
319 int cpu
= smp_processor_id();
320 int phy_id
= topology_physical_package_id(cpu
);
321 struct phy_dev_entry
*phdev
= pkg_temp_thermal_get_phy_entry(cpu
);
328 spin_lock_irqsave(&pkg_work_lock
, flags
);
330 if (unlikely(phy_id
> max_phy_id
)) {
331 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
334 pkg_work_scheduled
[phy_id
] = 0;
335 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
337 enable_pkg_thres_interrupt();
338 rdmsrl(MSR_IA32_PACKAGE_THERM_STATUS
, msr_val
);
339 if (msr_val
& THERM_LOG_THRESHOLD0
) {
340 wrmsrl(MSR_IA32_PACKAGE_THERM_STATUS
,
341 msr_val
& ~THERM_LOG_THRESHOLD0
);
344 if (msr_val
& THERM_LOG_THRESHOLD1
) {
345 wrmsrl(MSR_IA32_PACKAGE_THERM_STATUS
,
346 msr_val
& ~THERM_LOG_THRESHOLD1
);
350 pr_debug("thermal_zone_device_update\n");
351 thermal_zone_device_update(phdev
->tzone
,
352 THERMAL_EVENT_UNSPECIFIED
);
356 static int pkg_temp_thermal_platform_thermal_notify(__u64 msr_val
)
359 int cpu
= smp_processor_id();
360 int phy_id
= topology_physical_package_id(cpu
);
363 * When a package is in interrupted state, all CPU's in that package
364 * are in the same interrupt state. So scheduling on any one CPU in
365 * the package is enough and simply return for others.
367 spin_lock_irqsave(&pkg_work_lock
, flags
);
369 if (unlikely(phy_id
> max_phy_id
) || unlikely(!pkg_work_scheduled
) ||
370 pkg_work_scheduled
[phy_id
]) {
371 disable_pkg_thres_interrupt();
372 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
375 pkg_work_scheduled
[phy_id
] = 1;
376 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
378 disable_pkg_thres_interrupt();
379 schedule_delayed_work_on(cpu
,
380 &per_cpu(pkg_temp_thermal_threshold_work
, cpu
),
381 msecs_to_jiffies(notify_delay_ms
));
385 static int find_siblings_cpu(int cpu
)
388 int id
= topology_physical_package_id(cpu
);
390 for_each_online_cpu(i
)
391 if (i
!= cpu
&& topology_physical_package_id(i
) == id
)
397 static int pkg_temp_thermal_device_add(unsigned int cpu
)
401 struct phy_dev_entry
*phy_dev_entry
;
403 u32 eax
, ebx
, ecx
, edx
;
407 cpuid(6, &eax
, &ebx
, &ecx
, &edx
);
408 thres_count
= ebx
& 0x07;
412 if (topology_physical_package_id(cpu
) > MAX_PKG_TEMP_ZONE_IDS
)
415 thres_count
= clamp_val(thres_count
, 0, MAX_NUMBER_OF_TRIPS
);
417 err
= get_tj_max(cpu
, &tj_max
);
421 mutex_lock(&phy_dev_list_mutex
);
423 phy_dev_entry
= kzalloc(sizeof(*phy_dev_entry
), GFP_KERNEL
);
424 if (!phy_dev_entry
) {
429 spin_lock_irqsave(&pkg_work_lock
, flags
);
430 if (topology_physical_package_id(cpu
) > max_phy_id
)
431 max_phy_id
= topology_physical_package_id(cpu
);
432 temp
= krealloc(pkg_work_scheduled
,
433 (max_phy_id
+1) * sizeof(u8
), GFP_ATOMIC
);
435 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
439 pkg_work_scheduled
= temp
;
440 pkg_work_scheduled
[topology_physical_package_id(cpu
)] = 0;
441 spin_unlock_irqrestore(&pkg_work_lock
, flags
);
443 phy_dev_entry
->phys_proc_id
= topology_physical_package_id(cpu
);
444 phy_dev_entry
->first_cpu
= cpu
;
445 phy_dev_entry
->tj_max
= tj_max
;
446 phy_dev_entry
->ref_cnt
= 1;
447 phy_dev_entry
->tzone
= thermal_zone_device_register("x86_pkg_temp",
449 (thres_count
== MAX_NUMBER_OF_TRIPS
) ?
451 phy_dev_entry
, &tzone_ops
, &pkg_temp_tz_params
, 0, 0);
452 if (IS_ERR(phy_dev_entry
->tzone
)) {
453 err
= PTR_ERR(phy_dev_entry
->tzone
);
456 /* Store MSR value for package thermal interrupt, to restore at exit */
457 rdmsr_on_cpu(cpu
, MSR_IA32_PACKAGE_THERM_INTERRUPT
,
458 &phy_dev_entry
->start_pkg_therm_low
,
459 &phy_dev_entry
->start_pkg_therm_high
);
461 list_add_tail(&phy_dev_entry
->list
, &phy_dev_list
);
462 pr_debug("pkg_temp_thermal_device_add :phy_id %d cpu %d\n",
463 phy_dev_entry
->phys_proc_id
, cpu
);
465 mutex_unlock(&phy_dev_list_mutex
);
470 kfree(phy_dev_entry
);
472 mutex_unlock(&phy_dev_list_mutex
);
478 static int pkg_temp_thermal_device_remove(unsigned int cpu
)
480 struct phy_dev_entry
*n
;
481 u16 phys_proc_id
= topology_physical_package_id(cpu
);
482 struct phy_dev_entry
*phdev
=
483 pkg_temp_thermal_get_phy_entry(cpu
);
488 mutex_lock(&phy_dev_list_mutex
);
489 /* If we are loosing the first cpu for this package, we need change */
490 if (phdev
->first_cpu
== cpu
) {
491 phdev
->first_cpu
= find_siblings_cpu(cpu
);
492 pr_debug("thermal_device_remove: first cpu switched %d\n",
496 * It is possible that no siblings left as this was the last cpu
497 * going offline. We don't need to worry about this assignment
498 * as the phydev entry will be removed in this case and
499 * thermal zone is removed.
502 pr_debug("thermal_device_remove: pkg: %d cpu %d ref_cnt %d\n",
503 phys_proc_id
, cpu
, phdev
->ref_cnt
);
505 list_for_each_entry_safe(phdev
, n
, &phy_dev_list
, list
) {
506 if (phdev
->phys_proc_id
== phys_proc_id
) {
507 thermal_zone_device_unregister(phdev
->tzone
);
508 list_del(&phdev
->list
);
513 mutex_unlock(&phy_dev_list_mutex
);
518 static int get_core_online(unsigned int cpu
)
520 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
521 struct phy_dev_entry
*phdev
= pkg_temp_thermal_get_phy_entry(cpu
);
523 /* Check if there is already an instance for this package */
525 if (!cpu_has(c
, X86_FEATURE_DTHERM
) ||
526 !cpu_has(c
, X86_FEATURE_PTS
))
528 if (pkg_temp_thermal_device_add(cpu
))
531 mutex_lock(&phy_dev_list_mutex
);
533 pr_debug("get_core_online: cpu %d ref_cnt %d\n",
534 cpu
, phdev
->ref_cnt
);
535 mutex_unlock(&phy_dev_list_mutex
);
537 INIT_DELAYED_WORK(&per_cpu(pkg_temp_thermal_threshold_work
, cpu
),
538 pkg_temp_thermal_threshold_work_fn
);
540 pr_debug("get_core_online: cpu %d successful\n", cpu
);
545 static void put_core_offline(unsigned int cpu
)
547 if (!pkg_temp_thermal_device_remove(cpu
))
548 cancel_delayed_work_sync(
549 &per_cpu(pkg_temp_thermal_threshold_work
, cpu
));
551 pr_debug("put_core_offline: cpu %d\n", cpu
);
554 static int pkg_temp_thermal_cpu_callback(struct notifier_block
*nfb
,
555 unsigned long action
, void *hcpu
)
557 unsigned int cpu
= (unsigned long) hcpu
;
559 switch (action
& ~CPU_TASKS_FROZEN
) {
561 case CPU_DOWN_FAILED
:
562 get_core_online(cpu
);
564 case CPU_DOWN_PREPARE
:
565 put_core_offline(cpu
);
571 static struct notifier_block pkg_temp_thermal_notifier __refdata
= {
572 .notifier_call
= pkg_temp_thermal_cpu_callback
,
575 static const struct x86_cpu_id __initconst pkg_temp_thermal_ids
[] = {
576 { X86_VENDOR_INTEL
, X86_FAMILY_ANY
, X86_MODEL_ANY
, X86_FEATURE_PTS
},
579 MODULE_DEVICE_TABLE(x86cpu
, pkg_temp_thermal_ids
);
581 static int __init
pkg_temp_thermal_init(void)
585 if (!x86_match_cpu(pkg_temp_thermal_ids
))
588 spin_lock_init(&pkg_work_lock
);
589 platform_thermal_package_notify
=
590 pkg_temp_thermal_platform_thermal_notify
;
591 platform_thermal_package_rate_control
=
592 pkg_temp_thermal_platform_thermal_rate_control
;
594 cpu_notifier_register_begin();
595 for_each_online_cpu(i
)
596 if (get_core_online(i
))
598 __register_hotcpu_notifier(&pkg_temp_thermal_notifier
);
599 cpu_notifier_register_done();
601 pkg_temp_debugfs_init(); /* Don't care if fails */
606 for_each_online_cpu(i
)
608 cpu_notifier_register_done();
609 kfree(pkg_work_scheduled
);
610 platform_thermal_package_notify
= NULL
;
611 platform_thermal_package_rate_control
= NULL
;
616 static void __exit
pkg_temp_thermal_exit(void)
618 struct phy_dev_entry
*phdev
, *n
;
621 cpu_notifier_register_begin();
622 __unregister_hotcpu_notifier(&pkg_temp_thermal_notifier
);
623 mutex_lock(&phy_dev_list_mutex
);
624 list_for_each_entry_safe(phdev
, n
, &phy_dev_list
, list
) {
625 /* Retore old MSR value for package thermal interrupt */
626 wrmsr_on_cpu(phdev
->first_cpu
,
627 MSR_IA32_PACKAGE_THERM_INTERRUPT
,
628 phdev
->start_pkg_therm_low
,
629 phdev
->start_pkg_therm_high
);
630 thermal_zone_device_unregister(phdev
->tzone
);
631 list_del(&phdev
->list
);
634 mutex_unlock(&phy_dev_list_mutex
);
635 platform_thermal_package_notify
= NULL
;
636 platform_thermal_package_rate_control
= NULL
;
637 for_each_online_cpu(i
)
638 cancel_delayed_work_sync(
639 &per_cpu(pkg_temp_thermal_threshold_work
, i
));
640 cpu_notifier_register_done();
642 kfree(pkg_work_scheduled
);
644 debugfs_remove_recursive(debugfs
);
647 module_init(pkg_temp_thermal_init
)
648 module_exit(pkg_temp_thermal_exit
)
650 MODULE_DESCRIPTION("X86 PKG TEMP Thermal Driver");
651 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
652 MODULE_LICENSE("GPL v2");