2 * processor_thermal_device.c
3 * Copyright (c) 2014, 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
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/pci.h>
19 #include <linux/interrupt.h>
20 #include <linux/platform_device.h>
21 #include <linux/acpi.h>
22 #include <linux/thermal.h>
23 #include "int340x_thermal_zone.h"
24 #include "../intel_soc_dts_iosf.h"
26 /* Broadwell-U/HSB thermal reporting device */
27 #define PCI_DEVICE_ID_PROC_BDW_THERMAL 0x1603
28 #define PCI_DEVICE_ID_PROC_HSB_THERMAL 0x0A03
30 /* Skylake thermal reporting device */
31 #define PCI_DEVICE_ID_PROC_SKL_THERMAL 0x1903
33 /* Braswell thermal reporting device */
34 #define PCI_DEVICE_ID_PROC_BSW_THERMAL 0x22DC
36 /* Broxton thermal reporting device */
37 #define PCI_DEVICE_ID_PROC_BXT0_THERMAL 0x0A8C
38 #define PCI_DEVICE_ID_PROC_BXT1_THERMAL 0x1A8C
39 #define PCI_DEVICE_ID_PROC_BXTX_THERMAL 0x4A8C
40 #define PCI_DEVICE_ID_PROC_BXTP_THERMAL 0x5A8C
51 struct proc_thermal_device
{
53 struct acpi_device
*adev
;
54 struct power_config power_limits
[2];
55 struct int34x_thermal_zone
*int340x_zone
;
56 struct intel_soc_dts_sensors
*soc_dts
;
59 enum proc_thermal_emum_mode_type
{
62 PROC_THERMAL_PLATFORM_DEV
66 * We can have only one type of enumeration, PCI or Platform,
67 * not both. So we don't need instance specific data.
69 static enum proc_thermal_emum_mode_type proc_thermal_emum_mode
=
72 #define POWER_LIMIT_SHOW(index, suffix) \
73 static ssize_t power_limit_##index##_##suffix##_show(struct device *dev, \
74 struct device_attribute *attr, \
77 struct pci_dev *pci_dev; \
78 struct platform_device *pdev; \
79 struct proc_thermal_device *proc_dev; \
81 if (proc_thermal_emum_mode == PROC_THERMAL_PLATFORM_DEV) { \
82 pdev = to_platform_device(dev); \
83 proc_dev = platform_get_drvdata(pdev); \
85 pci_dev = to_pci_dev(dev); \
86 proc_dev = pci_get_drvdata(pci_dev); \
88 return sprintf(buf, "%lu\n",\
89 (unsigned long)proc_dev->power_limits[index].suffix * 1000); \
92 POWER_LIMIT_SHOW(0, min_uw
)
93 POWER_LIMIT_SHOW(0, max_uw
)
94 POWER_LIMIT_SHOW(0, step_uw
)
95 POWER_LIMIT_SHOW(0, tmin_us
)
96 POWER_LIMIT_SHOW(0, tmax_us
)
98 POWER_LIMIT_SHOW(1, min_uw
)
99 POWER_LIMIT_SHOW(1, max_uw
)
100 POWER_LIMIT_SHOW(1, step_uw
)
101 POWER_LIMIT_SHOW(1, tmin_us
)
102 POWER_LIMIT_SHOW(1, tmax_us
)
104 static DEVICE_ATTR_RO(power_limit_0_min_uw
);
105 static DEVICE_ATTR_RO(power_limit_0_max_uw
);
106 static DEVICE_ATTR_RO(power_limit_0_step_uw
);
107 static DEVICE_ATTR_RO(power_limit_0_tmin_us
);
108 static DEVICE_ATTR_RO(power_limit_0_tmax_us
);
110 static DEVICE_ATTR_RO(power_limit_1_min_uw
);
111 static DEVICE_ATTR_RO(power_limit_1_max_uw
);
112 static DEVICE_ATTR_RO(power_limit_1_step_uw
);
113 static DEVICE_ATTR_RO(power_limit_1_tmin_us
);
114 static DEVICE_ATTR_RO(power_limit_1_tmax_us
);
116 static struct attribute
*power_limit_attrs
[] = {
117 &dev_attr_power_limit_0_min_uw
.attr
,
118 &dev_attr_power_limit_1_min_uw
.attr
,
119 &dev_attr_power_limit_0_max_uw
.attr
,
120 &dev_attr_power_limit_1_max_uw
.attr
,
121 &dev_attr_power_limit_0_step_uw
.attr
,
122 &dev_attr_power_limit_1_step_uw
.attr
,
123 &dev_attr_power_limit_0_tmin_us
.attr
,
124 &dev_attr_power_limit_1_tmin_us
.attr
,
125 &dev_attr_power_limit_0_tmax_us
.attr
,
126 &dev_attr_power_limit_1_tmax_us
.attr
,
130 static struct attribute_group power_limit_attribute_group
= {
131 .attrs
= power_limit_attrs
,
132 .name
= "power_limits"
135 static int stored_tjmax
; /* since it is fixed, we can have local storage */
137 static int get_tjmax(void)
143 err
= rdmsr_safe(MSR_IA32_TEMPERATURE_TARGET
, &eax
, &edx
);
147 val
= (eax
>> 16) & 0xff;
154 static int read_temp_msr(int *temp
)
159 unsigned long curr_temp_off
= 0;
163 for_each_online_cpu(cpu
) {
164 err
= rdmsr_safe_on_cpu(cpu
, MSR_IA32_THERM_STATUS
, &eax
,
169 if (eax
& 0x80000000) {
170 curr_temp_off
= (eax
>> 16) & 0x7f;
171 if (!*temp
|| curr_temp_off
< *temp
)
172 *temp
= curr_temp_off
;
185 static int proc_thermal_get_zone_temp(struct thermal_zone_device
*zone
,
190 ret
= read_temp_msr(temp
);
192 *temp
= (stored_tjmax
- *temp
) * 1000;
197 static struct thermal_zone_device_ops proc_thermal_local_ops
= {
198 .get_temp
= proc_thermal_get_zone_temp
,
201 static int proc_thermal_read_ppcc(struct proc_thermal_device
*proc_priv
)
205 struct acpi_buffer buf
= { ACPI_ALLOCATE_BUFFER
, NULL
};
206 union acpi_object
*elements
, *ppcc
;
207 union acpi_object
*p
;
210 status
= acpi_evaluate_object(proc_priv
->adev
->handle
, "PPCC",
212 if (ACPI_FAILURE(status
))
216 if (!p
|| (p
->type
!= ACPI_TYPE_PACKAGE
)) {
217 dev_err(proc_priv
->dev
, "Invalid PPCC data\n");
222 if (!p
->package
.count
) {
223 dev_err(proc_priv
->dev
, "Invalid PPCC package size\n");
228 for (i
= 0; i
< min((int)p
->package
.count
- 1, 2); ++i
) {
229 elements
= &(p
->package
.elements
[i
+1]);
230 if (elements
->type
!= ACPI_TYPE_PACKAGE
||
231 elements
->package
.count
!= 6) {
235 ppcc
= elements
->package
.elements
;
236 proc_priv
->power_limits
[i
].index
= ppcc
[0].integer
.value
;
237 proc_priv
->power_limits
[i
].min_uw
= ppcc
[1].integer
.value
;
238 proc_priv
->power_limits
[i
].max_uw
= ppcc
[2].integer
.value
;
239 proc_priv
->power_limits
[i
].tmin_us
= ppcc
[3].integer
.value
;
240 proc_priv
->power_limits
[i
].tmax_us
= ppcc
[4].integer
.value
;
241 proc_priv
->power_limits
[i
].step_uw
= ppcc
[5].integer
.value
;
250 #define PROC_POWER_CAPABILITY_CHANGED 0x83
251 static void proc_thermal_notify(acpi_handle handle
, u32 event
, void *data
)
253 struct proc_thermal_device
*proc_priv
= data
;
259 case PROC_POWER_CAPABILITY_CHANGED
:
260 proc_thermal_read_ppcc(proc_priv
);
261 int340x_thermal_zone_device_update(proc_priv
->int340x_zone
);
264 dev_err(proc_priv
->dev
, "Unsupported event [0x%x]\n", event
);
270 static int proc_thermal_add(struct device
*dev
,
271 struct proc_thermal_device
**priv
)
273 struct proc_thermal_device
*proc_priv
;
274 struct acpi_device
*adev
;
276 unsigned long long tmp
;
277 struct thermal_zone_device_ops
*ops
= NULL
;
280 adev
= ACPI_COMPANION(dev
);
284 proc_priv
= devm_kzalloc(dev
, sizeof(*proc_priv
), GFP_KERNEL
);
288 proc_priv
->dev
= dev
;
289 proc_priv
->adev
= adev
;
292 ret
= proc_thermal_read_ppcc(proc_priv
);
294 ret
= sysfs_create_group(&dev
->kobj
,
295 &power_limit_attribute_group
);
301 status
= acpi_evaluate_integer(adev
->handle
, "_TMP", NULL
, &tmp
);
302 if (ACPI_FAILURE(status
)) {
303 /* there is no _TMP method, add local method */
304 stored_tjmax
= get_tjmax();
305 if (stored_tjmax
> 0)
306 ops
= &proc_thermal_local_ops
;
309 proc_priv
->int340x_zone
= int340x_thermal_zone_add(adev
, ops
);
310 if (IS_ERR(proc_priv
->int340x_zone
)) {
311 ret
= PTR_ERR(proc_priv
->int340x_zone
);
316 ret
= acpi_install_notify_handler(adev
->handle
, ACPI_DEVICE_NOTIFY
,
325 int340x_thermal_zone_remove(proc_priv
->int340x_zone
);
327 sysfs_remove_group(&proc_priv
->dev
->kobj
,
328 &power_limit_attribute_group
);
333 static void proc_thermal_remove(struct proc_thermal_device
*proc_priv
)
335 acpi_remove_notify_handler(proc_priv
->adev
->handle
,
336 ACPI_DEVICE_NOTIFY
, proc_thermal_notify
);
337 int340x_thermal_zone_remove(proc_priv
->int340x_zone
);
338 sysfs_remove_group(&proc_priv
->dev
->kobj
,
339 &power_limit_attribute_group
);
342 static int int3401_add(struct platform_device
*pdev
)
344 struct proc_thermal_device
*proc_priv
;
347 if (proc_thermal_emum_mode
== PROC_THERMAL_PCI
) {
348 dev_err(&pdev
->dev
, "error: enumerated as PCI dev\n");
352 ret
= proc_thermal_add(&pdev
->dev
, &proc_priv
);
356 platform_set_drvdata(pdev
, proc_priv
);
357 proc_thermal_emum_mode
= PROC_THERMAL_PLATFORM_DEV
;
362 static int int3401_remove(struct platform_device
*pdev
)
364 proc_thermal_remove(platform_get_drvdata(pdev
));
369 static irqreturn_t
proc_thermal_pci_msi_irq(int irq
, void *devid
)
371 struct proc_thermal_device
*proc_priv
;
372 struct pci_dev
*pdev
= devid
;
374 proc_priv
= pci_get_drvdata(pdev
);
376 intel_soc_dts_iosf_interrupt_handler(proc_priv
->soc_dts
);
381 static int proc_thermal_pci_probe(struct pci_dev
*pdev
,
382 const struct pci_device_id
*unused
)
384 struct proc_thermal_device
*proc_priv
;
387 if (proc_thermal_emum_mode
== PROC_THERMAL_PLATFORM_DEV
) {
388 dev_err(&pdev
->dev
, "error: enumerated as platform dev\n");
392 ret
= pci_enable_device(pdev
);
394 dev_err(&pdev
->dev
, "error: could not enable device\n");
398 ret
= proc_thermal_add(&pdev
->dev
, &proc_priv
);
400 pci_disable_device(pdev
);
404 pci_set_drvdata(pdev
, proc_priv
);
405 proc_thermal_emum_mode
= PROC_THERMAL_PCI
;
407 if (pdev
->device
== PCI_DEVICE_ID_PROC_BSW_THERMAL
) {
409 * Enumerate additional DTS sensors available via IOSF.
410 * But we are not treating as a failure condition, if
411 * there are no aux DTSs enabled or fails. This driver
412 * already exposes sensors, which can be accessed via
413 * ACPI/MSR. So we don't want to fail for auxiliary DTSs.
415 proc_priv
->soc_dts
= intel_soc_dts_iosf_init(
416 INTEL_SOC_DTS_INTERRUPT_MSI
, 2, 0);
418 if (proc_priv
->soc_dts
&& pdev
->irq
) {
419 ret
= pci_enable_msi(pdev
);
421 ret
= request_threaded_irq(pdev
->irq
, NULL
,
422 proc_thermal_pci_msi_irq
,
423 IRQF_ONESHOT
, "proc_thermal",
426 intel_soc_dts_iosf_exit(
428 pci_disable_msi(pdev
);
429 proc_priv
->soc_dts
= NULL
;
433 dev_err(&pdev
->dev
, "No auxiliary DTSs enabled\n");
439 static void proc_thermal_pci_remove(struct pci_dev
*pdev
)
441 struct proc_thermal_device
*proc_priv
= pci_get_drvdata(pdev
);
443 if (proc_priv
->soc_dts
) {
444 intel_soc_dts_iosf_exit(proc_priv
->soc_dts
);
446 free_irq(pdev
->irq
, pdev
);
447 pci_disable_msi(pdev
);
450 proc_thermal_remove(proc_priv
);
451 pci_disable_device(pdev
);
454 static const struct pci_device_id proc_thermal_pci_ids
[] = {
455 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BDW_THERMAL
)},
456 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_HSB_THERMAL
)},
457 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_SKL_THERMAL
)},
458 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BSW_THERMAL
)},
459 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BXT0_THERMAL
)},
460 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BXT1_THERMAL
)},
461 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BXTX_THERMAL
)},
462 { PCI_DEVICE(PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_PROC_BXTP_THERMAL
)},
466 MODULE_DEVICE_TABLE(pci
, proc_thermal_pci_ids
);
468 static struct pci_driver proc_thermal_pci_driver
= {
469 .name
= "proc_thermal",
470 .probe
= proc_thermal_pci_probe
,
471 .remove
= proc_thermal_pci_remove
,
472 .id_table
= proc_thermal_pci_ids
,
475 static const struct acpi_device_id int3401_device_ids
[] = {
479 MODULE_DEVICE_TABLE(acpi
, int3401_device_ids
);
481 static struct platform_driver int3401_driver
= {
482 .probe
= int3401_add
,
483 .remove
= int3401_remove
,
485 .name
= "int3401 thermal",
486 .acpi_match_table
= int3401_device_ids
,
490 static int __init
proc_thermal_init(void)
494 ret
= platform_driver_register(&int3401_driver
);
498 ret
= pci_register_driver(&proc_thermal_pci_driver
);
503 static void __exit
proc_thermal_exit(void)
505 platform_driver_unregister(&int3401_driver
);
506 pci_unregister_driver(&proc_thermal_pci_driver
);
509 module_init(proc_thermal_init
);
510 module_exit(proc_thermal_exit
);
512 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
513 MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
514 MODULE_LICENSE("GPL v2");