1
2
3
4
5
6#include <linux/kernel.h>
7#include <linux/module.h>
8#include <linux/init.h>
9#include <linux/pci.h>
10#include <linux/interrupt.h>
11#include <linux/platform_device.h>
12#include <linux/acpi.h>
13#include <linux/thermal.h>
14#include <linux/cpuhotplug.h>
15#include <linux/intel_rapl.h>
16#include "int340x_thermal_zone.h"
17#include "../intel_soc_dts_iosf.h"
18
19
20#define PCI_DEVICE_ID_PROC_BDW_THERMAL 0x1603
21#define PCI_DEVICE_ID_PROC_HSB_THERMAL 0x0A03
22
23
24#define PCI_DEVICE_ID_PROC_SKL_THERMAL 0x1903
25
26
27#define PCI_DEVICE_ID_PROC_CNL_THERMAL 0x5a03
28#define PCI_DEVICE_ID_PROC_CFL_THERMAL 0x3E83
29
30
31#define PCI_DEVICE_ID_PROC_BSW_THERMAL 0x22DC
32
33
34#define PCI_DEVICE_ID_PROC_BXT0_THERMAL 0x0A8C
35#define PCI_DEVICE_ID_PROC_BXT1_THERMAL 0x1A8C
36#define PCI_DEVICE_ID_PROC_BXTX_THERMAL 0x4A8C
37#define PCI_DEVICE_ID_PROC_BXTP_THERMAL 0x5A8C
38
39
40#define PCI_DEVICE_ID_PROC_GLK_THERMAL 0x318C
41
42
43#define PCI_DEVICE_ID_PROC_ICL_THERMAL 0x8a03
44
45
46#define PCI_DEVICE_ID_PROC_JSL_THERMAL 0x4E03
47
48
49#define PCI_DEVICE_ID_PROC_TGL_THERMAL 0x9A03
50
51#define DRV_NAME "proc_thermal"
52
53struct power_config {
54 u32 index;
55 u32 min_uw;
56 u32 max_uw;
57 u32 tmin_us;
58 u32 tmax_us;
59 u32 step_uw;
60};
61
62struct proc_thermal_device {
63 struct device *dev;
64 struct acpi_device *adev;
65 struct power_config power_limits[2];
66 struct int34x_thermal_zone *int340x_zone;
67 struct intel_soc_dts_sensors *soc_dts;
68 void __iomem *mmio_base;
69};
70
71enum proc_thermal_emum_mode_type {
72 PROC_THERMAL_NONE,
73 PROC_THERMAL_PCI,
74 PROC_THERMAL_PLATFORM_DEV
75};
76
77struct rapl_mmio_regs {
78 u64 reg_unit;
79 u64 regs[RAPL_DOMAIN_MAX][RAPL_DOMAIN_REG_MAX];
80 int limits[RAPL_DOMAIN_MAX];
81};
82
83
84
85
86
87static enum proc_thermal_emum_mode_type proc_thermal_emum_mode =
88 PROC_THERMAL_NONE;
89
90#define POWER_LIMIT_SHOW(index, suffix) \
91static ssize_t power_limit_##index##_##suffix##_show(struct device *dev, \
92 struct device_attribute *attr, \
93 char *buf) \
94{ \
95 struct proc_thermal_device *proc_dev = dev_get_drvdata(dev); \
96 \
97 if (proc_thermal_emum_mode == PROC_THERMAL_NONE) { \
98 dev_warn(dev, "Attempted to get power limit before device was initialized!\n"); \
99 return 0; \
100 } \
101 \
102 return sprintf(buf, "%lu\n",\
103 (unsigned long)proc_dev->power_limits[index].suffix * 1000); \
104}
105
106POWER_LIMIT_SHOW(0, min_uw)
107POWER_LIMIT_SHOW(0, max_uw)
108POWER_LIMIT_SHOW(0, step_uw)
109POWER_LIMIT_SHOW(0, tmin_us)
110POWER_LIMIT_SHOW(0, tmax_us)
111
112POWER_LIMIT_SHOW(1, min_uw)
113POWER_LIMIT_SHOW(1, max_uw)
114POWER_LIMIT_SHOW(1, step_uw)
115POWER_LIMIT_SHOW(1, tmin_us)
116POWER_LIMIT_SHOW(1, tmax_us)
117
118static DEVICE_ATTR_RO(power_limit_0_min_uw);
119static DEVICE_ATTR_RO(power_limit_0_max_uw);
120static DEVICE_ATTR_RO(power_limit_0_step_uw);
121static DEVICE_ATTR_RO(power_limit_0_tmin_us);
122static DEVICE_ATTR_RO(power_limit_0_tmax_us);
123
124static DEVICE_ATTR_RO(power_limit_1_min_uw);
125static DEVICE_ATTR_RO(power_limit_1_max_uw);
126static DEVICE_ATTR_RO(power_limit_1_step_uw);
127static DEVICE_ATTR_RO(power_limit_1_tmin_us);
128static DEVICE_ATTR_RO(power_limit_1_tmax_us);
129
130static struct attribute *power_limit_attrs[] = {
131 &dev_attr_power_limit_0_min_uw.attr,
132 &dev_attr_power_limit_1_min_uw.attr,
133 &dev_attr_power_limit_0_max_uw.attr,
134 &dev_attr_power_limit_1_max_uw.attr,
135 &dev_attr_power_limit_0_step_uw.attr,
136 &dev_attr_power_limit_1_step_uw.attr,
137 &dev_attr_power_limit_0_tmin_us.attr,
138 &dev_attr_power_limit_1_tmin_us.attr,
139 &dev_attr_power_limit_0_tmax_us.attr,
140 &dev_attr_power_limit_1_tmax_us.attr,
141 NULL
142};
143
144static const struct attribute_group power_limit_attribute_group = {
145 .attrs = power_limit_attrs,
146 .name = "power_limits"
147};
148
149static ssize_t tcc_offset_degree_celsius_show(struct device *dev,
150 struct device_attribute *attr, char *buf)
151{
152 u64 val;
153 int err;
154
155 err = rdmsrl_safe(MSR_IA32_TEMPERATURE_TARGET, &val);
156 if (err)
157 return err;
158
159 val = (val >> 24) & 0xff;
160 return sprintf(buf, "%d\n", (int)val);
161}
162
163static int tcc_offset_update(int tcc)
164{
165 u64 val;
166 int err;
167
168 if (!tcc)
169 return -EINVAL;
170
171 err = rdmsrl_safe(MSR_IA32_TEMPERATURE_TARGET, &val);
172 if (err)
173 return err;
174
175 val &= ~GENMASK_ULL(31, 24);
176 val |= (tcc & 0xff) << 24;
177
178 err = wrmsrl_safe(MSR_IA32_TEMPERATURE_TARGET, val);
179 if (err)
180 return err;
181
182 return 0;
183}
184
185static int tcc_offset_save;
186
187static ssize_t tcc_offset_degree_celsius_store(struct device *dev,
188 struct device_attribute *attr, const char *buf,
189 size_t count)
190{
191 u64 val;
192 int tcc, err;
193
194 err = rdmsrl_safe(MSR_PLATFORM_INFO, &val);
195 if (err)
196 return err;
197
198 if (!(val & BIT(30)))
199 return -EACCES;
200
201 if (kstrtoint(buf, 0, &tcc))
202 return -EINVAL;
203
204 err = tcc_offset_update(tcc);
205 if (err)
206 return err;
207
208 tcc_offset_save = tcc;
209
210 return count;
211}
212
213static DEVICE_ATTR_RW(tcc_offset_degree_celsius);
214
215static int stored_tjmax;
216
217static int get_tjmax(void)
218{
219 u32 eax, edx;
220 u32 val;
221 int err;
222
223 err = rdmsr_safe(MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
224 if (err)
225 return err;
226
227 val = (eax >> 16) & 0xff;
228 if (val)
229 return val;
230
231 return -EINVAL;
232}
233
234static int read_temp_msr(int *temp)
235{
236 int cpu;
237 u32 eax, edx;
238 int err;
239 unsigned long curr_temp_off = 0;
240
241 *temp = 0;
242
243 for_each_online_cpu(cpu) {
244 err = rdmsr_safe_on_cpu(cpu, MSR_IA32_THERM_STATUS, &eax,
245 &edx);
246 if (err)
247 goto err_ret;
248 else {
249 if (eax & 0x80000000) {
250 curr_temp_off = (eax >> 16) & 0x7f;
251 if (!*temp || curr_temp_off < *temp)
252 *temp = curr_temp_off;
253 } else {
254 err = -EINVAL;
255 goto err_ret;
256 }
257 }
258 }
259
260 return 0;
261err_ret:
262 return err;
263}
264
265static int proc_thermal_get_zone_temp(struct thermal_zone_device *zone,
266 int *temp)
267{
268 int ret;
269
270 ret = read_temp_msr(temp);
271 if (!ret)
272 *temp = (stored_tjmax - *temp) * 1000;
273
274 return ret;
275}
276
277static struct thermal_zone_device_ops proc_thermal_local_ops = {
278 .get_temp = proc_thermal_get_zone_temp,
279};
280
281static int proc_thermal_read_ppcc(struct proc_thermal_device *proc_priv)
282{
283 int i;
284 acpi_status status;
285 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
286 union acpi_object *elements, *ppcc;
287 union acpi_object *p;
288 int ret = 0;
289
290 status = acpi_evaluate_object(proc_priv->adev->handle, "PPCC",
291 NULL, &buf);
292 if (ACPI_FAILURE(status))
293 return -ENODEV;
294
295 p = buf.pointer;
296 if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
297 dev_err(proc_priv->dev, "Invalid PPCC data\n");
298 ret = -EFAULT;
299 goto free_buffer;
300 }
301
302 if (!p->package.count) {
303 dev_err(proc_priv->dev, "Invalid PPCC package size\n");
304 ret = -EFAULT;
305 goto free_buffer;
306 }
307
308 for (i = 0; i < min((int)p->package.count - 1, 2); ++i) {
309 elements = &(p->package.elements[i+1]);
310 if (elements->type != ACPI_TYPE_PACKAGE ||
311 elements->package.count != 6) {
312 ret = -EFAULT;
313 goto free_buffer;
314 }
315 ppcc = elements->package.elements;
316 proc_priv->power_limits[i].index = ppcc[0].integer.value;
317 proc_priv->power_limits[i].min_uw = ppcc[1].integer.value;
318 proc_priv->power_limits[i].max_uw = ppcc[2].integer.value;
319 proc_priv->power_limits[i].tmin_us = ppcc[3].integer.value;
320 proc_priv->power_limits[i].tmax_us = ppcc[4].integer.value;
321 proc_priv->power_limits[i].step_uw = ppcc[5].integer.value;
322 }
323
324free_buffer:
325 kfree(buf.pointer);
326
327 return ret;
328}
329
330#define PROC_POWER_CAPABILITY_CHANGED 0x83
331static void proc_thermal_notify(acpi_handle handle, u32 event, void *data)
332{
333 struct proc_thermal_device *proc_priv = data;
334
335 if (!proc_priv)
336 return;
337
338 switch (event) {
339 case PROC_POWER_CAPABILITY_CHANGED:
340 proc_thermal_read_ppcc(proc_priv);
341 int340x_thermal_zone_device_update(proc_priv->int340x_zone,
342 THERMAL_DEVICE_POWER_CAPABILITY_CHANGED);
343 break;
344 default:
345 dev_dbg(proc_priv->dev, "Unsupported event [0x%x]\n", event);
346 break;
347 }
348}
349
350
351static int proc_thermal_add(struct device *dev,
352 struct proc_thermal_device **priv)
353{
354 struct proc_thermal_device *proc_priv;
355 struct acpi_device *adev;
356 acpi_status status;
357 unsigned long long tmp;
358 struct thermal_zone_device_ops *ops = NULL;
359 int ret;
360
361 adev = ACPI_COMPANION(dev);
362 if (!adev)
363 return -ENODEV;
364
365 proc_priv = devm_kzalloc(dev, sizeof(*proc_priv), GFP_KERNEL);
366 if (!proc_priv)
367 return -ENOMEM;
368
369 proc_priv->dev = dev;
370 proc_priv->adev = adev;
371 *priv = proc_priv;
372
373 ret = proc_thermal_read_ppcc(proc_priv);
374 if (ret)
375 return ret;
376
377 status = acpi_evaluate_integer(adev->handle, "_TMP", NULL, &tmp);
378 if (ACPI_FAILURE(status)) {
379
380 stored_tjmax = get_tjmax();
381 if (stored_tjmax > 0)
382 ops = &proc_thermal_local_ops;
383 }
384
385 proc_priv->int340x_zone = int340x_thermal_zone_add(adev, ops);
386 if (IS_ERR(proc_priv->int340x_zone)) {
387 return PTR_ERR(proc_priv->int340x_zone);
388 } else
389 ret = 0;
390
391 ret = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
392 proc_thermal_notify,
393 (void *)proc_priv);
394 if (ret)
395 goto remove_zone;
396
397 return 0;
398
399remove_zone:
400 int340x_thermal_zone_remove(proc_priv->int340x_zone);
401
402 return ret;
403}
404
405static void proc_thermal_remove(struct proc_thermal_device *proc_priv)
406{
407 acpi_remove_notify_handler(proc_priv->adev->handle,
408 ACPI_DEVICE_NOTIFY, proc_thermal_notify);
409 int340x_thermal_zone_remove(proc_priv->int340x_zone);
410 sysfs_remove_file(&proc_priv->dev->kobj, &dev_attr_tcc_offset_degree_celsius.attr);
411 sysfs_remove_group(&proc_priv->dev->kobj,
412 &power_limit_attribute_group);
413}
414
415static int int3401_add(struct platform_device *pdev)
416{
417 struct proc_thermal_device *proc_priv;
418 int ret;
419
420 if (proc_thermal_emum_mode == PROC_THERMAL_PCI) {
421 dev_err(&pdev->dev, "error: enumerated as PCI dev\n");
422 return -ENODEV;
423 }
424
425 ret = proc_thermal_add(&pdev->dev, &proc_priv);
426 if (ret)
427 return ret;
428
429 platform_set_drvdata(pdev, proc_priv);
430 proc_thermal_emum_mode = PROC_THERMAL_PLATFORM_DEV;
431
432 dev_info(&pdev->dev, "Creating sysfs group for PROC_THERMAL_PLATFORM_DEV\n");
433
434 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_tcc_offset_degree_celsius.attr);
435 if (ret)
436 return ret;
437
438 ret = sysfs_create_group(&pdev->dev.kobj, &power_limit_attribute_group);
439 if (ret)
440 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_tcc_offset_degree_celsius.attr);
441
442 return ret;
443}
444
445static int int3401_remove(struct platform_device *pdev)
446{
447 proc_thermal_remove(platform_get_drvdata(pdev));
448
449 return 0;
450}
451
452static irqreturn_t proc_thermal_pci_msi_irq(int irq, void *devid)
453{
454 struct proc_thermal_device *proc_priv;
455 struct pci_dev *pdev = devid;
456
457 proc_priv = pci_get_drvdata(pdev);
458
459 intel_soc_dts_iosf_interrupt_handler(proc_priv->soc_dts);
460
461 return IRQ_HANDLED;
462}
463
464#ifdef CONFIG_PROC_THERMAL_MMIO_RAPL
465
466#define MCHBAR 0
467
468
469static struct rapl_if_priv rapl_mmio_priv;
470
471static int rapl_mmio_cpu_online(unsigned int cpu)
472{
473 struct rapl_package *rp;
474
475
476 if (topology_physical_package_id(cpu))
477 return 0;
478
479 rp = rapl_find_package_domain(cpu, &rapl_mmio_priv);
480 if (!rp) {
481 rp = rapl_add_package(cpu, &rapl_mmio_priv);
482 if (IS_ERR(rp))
483 return PTR_ERR(rp);
484 }
485 cpumask_set_cpu(cpu, &rp->cpumask);
486 return 0;
487}
488
489static int rapl_mmio_cpu_down_prep(unsigned int cpu)
490{
491 struct rapl_package *rp;
492 int lead_cpu;
493
494 rp = rapl_find_package_domain(cpu, &rapl_mmio_priv);
495 if (!rp)
496 return 0;
497
498 cpumask_clear_cpu(cpu, &rp->cpumask);
499 lead_cpu = cpumask_first(&rp->cpumask);
500 if (lead_cpu >= nr_cpu_ids)
501 rapl_remove_package(rp);
502 else if (rp->lead_cpu == cpu)
503 rp->lead_cpu = lead_cpu;
504 return 0;
505}
506
507static int rapl_mmio_read_raw(int cpu, struct reg_action *ra)
508{
509 if (!ra->reg)
510 return -EINVAL;
511
512 ra->value = readq((void __iomem *)ra->reg);
513 ra->value &= ra->mask;
514 return 0;
515}
516
517static int rapl_mmio_write_raw(int cpu, struct reg_action *ra)
518{
519 u64 val;
520
521 if (!ra->reg)
522 return -EINVAL;
523
524 val = readq((void __iomem *)ra->reg);
525 val &= ~ra->mask;
526 val |= ra->value;
527 writeq(val, (void __iomem *)ra->reg);
528 return 0;
529}
530
531static int proc_thermal_rapl_add(struct pci_dev *pdev,
532 struct proc_thermal_device *proc_priv,
533 struct rapl_mmio_regs *rapl_regs)
534{
535 enum rapl_domain_reg_id reg;
536 enum rapl_domain_type domain;
537 int ret;
538
539 if (!rapl_regs)
540 return 0;
541
542 ret = pcim_iomap_regions(pdev, 1 << MCHBAR, DRV_NAME);
543 if (ret) {
544 dev_err(&pdev->dev, "cannot reserve PCI memory region\n");
545 return -ENOMEM;
546 }
547
548 proc_priv->mmio_base = pcim_iomap_table(pdev)[MCHBAR];
549
550 for (domain = RAPL_DOMAIN_PACKAGE; domain < RAPL_DOMAIN_MAX; domain++) {
551 for (reg = RAPL_DOMAIN_REG_LIMIT; reg < RAPL_DOMAIN_REG_MAX; reg++)
552 if (rapl_regs->regs[domain][reg])
553 rapl_mmio_priv.regs[domain][reg] =
554 (u64)proc_priv->mmio_base +
555 rapl_regs->regs[domain][reg];
556 rapl_mmio_priv.limits[domain] = rapl_regs->limits[domain];
557 }
558 rapl_mmio_priv.reg_unit = (u64)proc_priv->mmio_base + rapl_regs->reg_unit;
559
560 rapl_mmio_priv.read_raw = rapl_mmio_read_raw;
561 rapl_mmio_priv.write_raw = rapl_mmio_write_raw;
562
563 rapl_mmio_priv.control_type = powercap_register_control_type(NULL, "intel-rapl-mmio", NULL);
564 if (IS_ERR(rapl_mmio_priv.control_type)) {
565 pr_debug("failed to register powercap control_type.\n");
566 return PTR_ERR(rapl_mmio_priv.control_type);
567 }
568
569 ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "powercap/rapl:online",
570 rapl_mmio_cpu_online, rapl_mmio_cpu_down_prep);
571 if (ret < 0) {
572 powercap_unregister_control_type(rapl_mmio_priv.control_type);
573 rapl_mmio_priv.control_type = NULL;
574 return ret;
575 }
576 rapl_mmio_priv.pcap_rapl_online = ret;
577
578 return 0;
579}
580
581static void proc_thermal_rapl_remove(void)
582{
583 if (IS_ERR_OR_NULL(rapl_mmio_priv.control_type))
584 return;
585
586 cpuhp_remove_state(rapl_mmio_priv.pcap_rapl_online);
587 powercap_unregister_control_type(rapl_mmio_priv.control_type);
588}
589
590static const struct rapl_mmio_regs rapl_mmio_hsw = {
591 .reg_unit = 0x5938,
592 .regs[RAPL_DOMAIN_PACKAGE] = { 0x59a0, 0x593c, 0x58f0, 0, 0x5930},
593 .regs[RAPL_DOMAIN_DRAM] = { 0x58e0, 0x58e8, 0x58ec, 0, 0},
594 .limits[RAPL_DOMAIN_PACKAGE] = 2,
595 .limits[RAPL_DOMAIN_DRAM] = 2,
596};
597
598#else
599
600static int proc_thermal_rapl_add(struct pci_dev *pdev,
601 struct proc_thermal_device *proc_priv,
602 struct rapl_mmio_regs *rapl_regs)
603{
604 return 0;
605}
606static void proc_thermal_rapl_remove(void) {}
607static const struct rapl_mmio_regs rapl_mmio_hsw;
608
609#endif
610
611static int proc_thermal_pci_probe(struct pci_dev *pdev,
612 const struct pci_device_id *id)
613{
614 struct proc_thermal_device *proc_priv;
615 int ret;
616
617 if (proc_thermal_emum_mode == PROC_THERMAL_PLATFORM_DEV) {
618 dev_err(&pdev->dev, "error: enumerated as platform dev\n");
619 return -ENODEV;
620 }
621
622 ret = pcim_enable_device(pdev);
623 if (ret < 0) {
624 dev_err(&pdev->dev, "error: could not enable device\n");
625 return ret;
626 }
627
628 ret = proc_thermal_add(&pdev->dev, &proc_priv);
629 if (ret)
630 return ret;
631
632 ret = proc_thermal_rapl_add(pdev, proc_priv,
633 (struct rapl_mmio_regs *)id->driver_data);
634 if (ret) {
635 dev_err(&pdev->dev, "failed to add RAPL MMIO interface\n");
636 proc_thermal_remove(proc_priv);
637 return ret;
638 }
639
640 pci_set_drvdata(pdev, proc_priv);
641 proc_thermal_emum_mode = PROC_THERMAL_PCI;
642
643 if (pdev->device == PCI_DEVICE_ID_PROC_BSW_THERMAL) {
644
645
646
647
648
649
650
651 proc_priv->soc_dts = intel_soc_dts_iosf_init(
652 INTEL_SOC_DTS_INTERRUPT_MSI, 2, 0);
653
654 if (!IS_ERR(proc_priv->soc_dts) && pdev->irq) {
655 ret = pci_enable_msi(pdev);
656 if (!ret) {
657 ret = request_threaded_irq(pdev->irq, NULL,
658 proc_thermal_pci_msi_irq,
659 IRQF_ONESHOT, "proc_thermal",
660 pdev);
661 if (ret) {
662 intel_soc_dts_iosf_exit(
663 proc_priv->soc_dts);
664 pci_disable_msi(pdev);
665 proc_priv->soc_dts = NULL;
666 }
667 }
668 } else
669 dev_err(&pdev->dev, "No auxiliary DTSs enabled\n");
670 }
671
672 dev_info(&pdev->dev, "Creating sysfs group for PROC_THERMAL_PCI\n");
673
674 ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_tcc_offset_degree_celsius.attr);
675 if (ret)
676 return ret;
677
678 ret = sysfs_create_group(&pdev->dev.kobj, &power_limit_attribute_group);
679 if (ret)
680 sysfs_remove_file(&pdev->dev.kobj, &dev_attr_tcc_offset_degree_celsius.attr);
681
682 return ret;
683}
684
685static void proc_thermal_pci_remove(struct pci_dev *pdev)
686{
687 struct proc_thermal_device *proc_priv = pci_get_drvdata(pdev);
688
689 if (proc_priv->soc_dts) {
690 intel_soc_dts_iosf_exit(proc_priv->soc_dts);
691 if (pdev->irq) {
692 free_irq(pdev->irq, pdev);
693 pci_disable_msi(pdev);
694 }
695 }
696 proc_thermal_rapl_remove();
697 proc_thermal_remove(proc_priv);
698}
699
700#ifdef CONFIG_PM_SLEEP
701static int proc_thermal_resume(struct device *dev)
702{
703 struct proc_thermal_device *proc_dev;
704
705 proc_dev = dev_get_drvdata(dev);
706 proc_thermal_read_ppcc(proc_dev);
707
708 tcc_offset_update(tcc_offset_save);
709
710 return 0;
711}
712#else
713#define proc_thermal_resume NULL
714#endif
715
716static SIMPLE_DEV_PM_OPS(proc_thermal_pm, NULL, proc_thermal_resume);
717
718static const struct pci_device_id proc_thermal_pci_ids[] = {
719 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BDW_THERMAL)},
720 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_HSB_THERMAL)},
721 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_SKL_THERMAL),
722 .driver_data = (kernel_ulong_t)&rapl_mmio_hsw, },
723 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BSW_THERMAL)},
724 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BXT0_THERMAL)},
725 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BXT1_THERMAL)},
726 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BXTX_THERMAL)},
727 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_BXTP_THERMAL)},
728 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_CNL_THERMAL)},
729 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_CFL_THERMAL)},
730 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_GLK_THERMAL)},
731 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_ICL_THERMAL),
732 .driver_data = (kernel_ulong_t)&rapl_mmio_hsw, },
733 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_JSL_THERMAL)},
734 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PROC_TGL_THERMAL),
735 .driver_data = (kernel_ulong_t)&rapl_mmio_hsw, },
736 { 0, },
737};
738
739MODULE_DEVICE_TABLE(pci, proc_thermal_pci_ids);
740
741static struct pci_driver proc_thermal_pci_driver = {
742 .name = DRV_NAME,
743 .probe = proc_thermal_pci_probe,
744 .remove = proc_thermal_pci_remove,
745 .id_table = proc_thermal_pci_ids,
746 .driver.pm = &proc_thermal_pm,
747};
748
749static const struct acpi_device_id int3401_device_ids[] = {
750 {"INT3401", 0},
751 {"", 0},
752};
753MODULE_DEVICE_TABLE(acpi, int3401_device_ids);
754
755static struct platform_driver int3401_driver = {
756 .probe = int3401_add,
757 .remove = int3401_remove,
758 .driver = {
759 .name = "int3401 thermal",
760 .acpi_match_table = int3401_device_ids,
761 .pm = &proc_thermal_pm,
762 },
763};
764
765static int __init proc_thermal_init(void)
766{
767 int ret;
768
769 ret = platform_driver_register(&int3401_driver);
770 if (ret)
771 return ret;
772
773 ret = pci_register_driver(&proc_thermal_pci_driver);
774
775 return ret;
776}
777
778static void __exit proc_thermal_exit(void)
779{
780 platform_driver_unregister(&int3401_driver);
781 pci_unregister_driver(&proc_thermal_pci_driver);
782}
783
784module_init(proc_thermal_init);
785module_exit(proc_thermal_exit);
786
787MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
788MODULE_DESCRIPTION("Processor Thermal Reporting Device Driver");
789MODULE_LICENSE("GPL v2");
790
