drivers/thermal/intel/x86_pkg_temp_thermal.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * x86_pkg_temp_thermal driver
   4  * Copyright (c) 2013, Intel Corporation.
   5  */
   6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/intel_tcc.h>
  11 #include <linux/err.h>
  12 #include <linux/param.h>
  13 #include <linux/device.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/cpu.h>
  16 #include <linux/smp.h>
  17 #include <linux/slab.h>
  18 #include <linux/pm.h>
  19 #include <linux/thermal.h>
  20 #include <linux/debugfs.h>
  21
  22 #include <asm/cpu_device_id.h>
  23
  24 #include "thermal_interrupt.h"
  25
  26 /*
  27 * Rate control delay: Idea is to introduce denounce effect
  28 * This should be long enough to avoid reduce events, when
  29 * threshold is set to a temperature, which is constantly
  30 * violated, but at the short enough to take any action.
  31 * The action can be remove threshold or change it to next
  32 * interesting setting. Based on experiments, in around
  33 * every 5 seconds under load will give us a significant
  34 * temperature change.
  35 */
  36 #define PKG_TEMP_THERMAL_NOTIFY_DELAY   5000
  37 static int notify_delay_ms = PKG_TEMP_THERMAL_NOTIFY_DELAY;
  38 module_param(notify_delay_ms, int, 0644);
  39 MODULE_PARM_DESC(notify_delay_ms,
  40         "User space notification delay in milli seconds.");
  41
  42 /* Number of trip points in thermal zone. Currently it can't
  43 * be more than 2. MSR can allow setting and getting notifications
  44 * for only 2 thresholds. This define enforces this, if there
  45 * is some wrong values returned by cpuid for number of thresholds.
  46 */
  47 #define MAX_NUMBER_OF_TRIPS     2
  48
  49 struct zone_device {
  50         int                             cpu;
  51         bool                            work_scheduled;
  52         u32                             msr_pkg_therm_low;
  53         u32                             msr_pkg_therm_high;
  54         struct delayed_work             work;
  55         struct thermal_zone_device      *tzone;
  56         struct cpumask                  cpumask;
  57 };
  58
  59 static struct thermal_zone_params pkg_temp_tz_params = {
  60         .no_hwmon       = true,
  61 };
  62
  63 /* Keep track of how many zone pointers we allocated in init() */
  64 static int max_id __read_mostly;
  65 /* Array of zone pointers */
  66 static struct zone_device **zones;
  67 /* Serializes interrupt notification, work and hotplug */
  68 static DEFINE_RAW_SPINLOCK(pkg_temp_lock);
  69 /* Protects zone operation in the work function against hotplug removal */
  70 static DEFINE_MUTEX(thermal_zone_mutex);
  71
  72 /* The dynamically assigned cpu hotplug state for module_exit() */
  73 static enum cpuhp_state pkg_thermal_hp_state __read_mostly;
  74
  75 /* Debug counters to show using debugfs */
  76 static struct dentry *debugfs;
  77 static unsigned int pkg_interrupt_cnt;
  78 static unsigned int pkg_work_cnt;
  79
  80 static void pkg_temp_debugfs_init(void)
  81 {
  82         debugfs = debugfs_create_dir("pkg_temp_thermal", NULL);
  83
  84         debugfs_create_u32("pkg_thres_interrupt", S_IRUGO, debugfs,
  85                            &pkg_interrupt_cnt);
  86         debugfs_create_u32("pkg_thres_work", S_IRUGO, debugfs,
  87                            &pkg_work_cnt);
  88 }
  89
  90 /*
  91  * Protection:
  92  *
  93  * - cpu hotplug: Read serialized by cpu hotplug lock
  94  *                Write must hold pkg_temp_lock
  95  *
  96  * - Other callsites: Must hold pkg_temp_lock
  97  */
  98 static struct zone_device *pkg_temp_thermal_get_dev(unsigned int cpu)
  99 {
 100         int id = topology_logical_die_id(cpu);
 101
 102         if (id >= 0 && id < max_id)
 103                 return zones[id];
 104         return NULL;
 105 }
 106
 107 static int sys_get_curr_temp(struct thermal_zone_device *tzd, int *temp)
 108 {
 109         struct zone_device *zonedev = thermal_zone_device_priv(tzd);
 110         int val, ret;
 111
 112         ret = intel_tcc_get_temp(zonedev->cpu, &val, true);
 113         if (ret < 0)
 114                 return ret;
 115
 116         *temp = val * 1000;
 117         pr_debug("sys_get_curr_temp %d\n", *temp);
 118         return 0;
 119 }
 120
 121 static int
 122 sys_set_trip_temp(struct thermal_zone_device *tzd, int trip, int temp)
 123 {
 124         struct zone_device *zonedev = thermal_zone_device_priv(tzd);
 125         u32 l, h, mask, shift, intr;
 126         int tj_max, val, ret;
 127
 128         tj_max = intel_tcc_get_tjmax(zonedev->cpu);
 129         if (tj_max < 0)
 130                 return tj_max;
 131         tj_max *= 1000;
 132
 133         val = (tj_max - temp)/1000;
 134
 135         if (trip >= MAX_NUMBER_OF_TRIPS || val < 0 || val > 0x7f)
 136                 return -EINVAL;
 137
 138         ret = rdmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,
 139                            &l, &h);
 140         if (ret < 0)
 141                 return ret;
 142
 143         if (trip) {
 144                 mask = THERM_MASK_THRESHOLD1;
 145                 shift = THERM_SHIFT_THRESHOLD1;
 146                 intr = THERM_INT_THRESHOLD1_ENABLE;
 147         } else {
 148                 mask = THERM_MASK_THRESHOLD0;
 149                 shift = THERM_SHIFT_THRESHOLD0;
 150                 intr = THERM_INT_THRESHOLD0_ENABLE;
 151         }
 152         l &= ~mask;
 153         /*
 154         * When users space sets a trip temperature == 0, which is indication
 155         * that, it is no longer interested in receiving notifications.
 156         */
 157         if (!temp) {
 158                 l &= ~intr;
 159         } else {
 160                 l |= val << shift;
 161                 l |= intr;
 162         }
 163
 164         return wrmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,
 165                         l, h);
 166 }
 167
 168 /* Thermal zone callback registry */
 169 static const struct thermal_zone_device_ops tzone_ops = {
 170         .get_temp = sys_get_curr_temp,
 171         .set_trip_temp = sys_set_trip_temp,
 172 };
 173
 174 static bool pkg_thermal_rate_control(void)
 175 {
 176         return true;
 177 }
 178
 179 /* Enable threshold interrupt on local package/cpu */
 180 static inline void enable_pkg_thres_interrupt(void)
 181 {
 182         u8 thres_0, thres_1;
 183         u32 l, h;
 184
 185         rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);
 186         /* only enable/disable if it had valid threshold value */
 187         thres_0 = (l & THERM_MASK_THRESHOLD0) >> THERM_SHIFT_THRESHOLD0;
 188         thres_1 = (l & THERM_MASK_THRESHOLD1) >> THERM_SHIFT_THRESHOLD1;
 189         if (thres_0)
 190                 l |= THERM_INT_THRESHOLD0_ENABLE;
 191         if (thres_1)
 192                 l |= THERM_INT_THRESHOLD1_ENABLE;
 193         wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);
 194 }
 195
 196 /* Disable threshold interrupt on local package/cpu */
 197 static inline void disable_pkg_thres_interrupt(void)
 198 {
 199         u32 l, h;
 200
 201         rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);
 202
 203         l &= ~(THERM_INT_THRESHOLD0_ENABLE | THERM_INT_THRESHOLD1_ENABLE);
 204         wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);
 205 }
 206
 207 static void pkg_temp_thermal_threshold_work_fn(struct work_struct *work)
 208 {
 209         struct thermal_zone_device *tzone = NULL;
 210         int cpu = smp_processor_id();
 211         struct zone_device *zonedev;
 212
 213         mutex_lock(&thermal_zone_mutex);
 214         raw_spin_lock_irq(&pkg_temp_lock);
 215         ++pkg_work_cnt;
 216
 217         zonedev = pkg_temp_thermal_get_dev(cpu);
 218         if (!zonedev) {
 219                 raw_spin_unlock_irq(&pkg_temp_lock);
 220                 mutex_unlock(&thermal_zone_mutex);
 221                 return;
 222         }
 223         zonedev->work_scheduled = false;
 224
 225         thermal_clear_package_intr_status(PACKAGE_LEVEL, THERM_LOG_THRESHOLD0 | THERM_LOG_THRESHOLD1);
 226         tzone = zonedev->tzone;
 227
 228         enable_pkg_thres_interrupt();
 229         raw_spin_unlock_irq(&pkg_temp_lock);
 230
 231         /*
 232          * If tzone is not NULL, then thermal_zone_mutex will prevent the
 233          * concurrent removal in the cpu offline callback.
 234          */
 235         if (tzone)
 236                 thermal_zone_device_update(tzone, THERMAL_EVENT_UNSPECIFIED);
 237
 238         mutex_unlock(&thermal_zone_mutex);
 239 }
 240
 241 static void pkg_thermal_schedule_work(int cpu, struct delayed_work *work)
 242 {
 243         unsigned long ms = msecs_to_jiffies(notify_delay_ms);
 244
 245         schedule_delayed_work_on(cpu, work, ms);
 246 }
 247
 248 static int pkg_thermal_notify(u64 msr_val)
 249 {
 250         int cpu = smp_processor_id();
 251         struct zone_device *zonedev;
 252         unsigned long flags;
 253
 254         raw_spin_lock_irqsave(&pkg_temp_lock, flags);
 255         ++pkg_interrupt_cnt;
 256
 257         disable_pkg_thres_interrupt();
 258
 259         /* Work is per package, so scheduling it once is enough. */
 260         zonedev = pkg_temp_thermal_get_dev(cpu);
 261         if (zonedev && !zonedev->work_scheduled) {
 262                 zonedev->work_scheduled = true;
 263                 pkg_thermal_schedule_work(zonedev->cpu, &zonedev->work);
 264         }
 265
 266         raw_spin_unlock_irqrestore(&pkg_temp_lock, flags);
 267         return 0;
 268 }
 269
 270 static int pkg_temp_thermal_trips_init(int cpu, int tj_max,
 271                                        struct thermal_trip *trips, int num_trips)
 272 {
 273         unsigned long thres_reg_value;
 274         u32 mask, shift, eax, edx;
 275         int ret, i;
 276
 277         for (i = 0; i < num_trips; i++) {
 278
 279                 if (i) {
 280                         mask = THERM_MASK_THRESHOLD1;
 281                         shift = THERM_SHIFT_THRESHOLD1;
 282                 } else {
 283                         mask = THERM_MASK_THRESHOLD0;
 284                         shift = THERM_SHIFT_THRESHOLD0;
 285                 }
 286
 287                 ret = rdmsr_on_cpu(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,
 288                                    &eax, &edx);
 289                 if (ret < 0)
 290                         return ret;
 291
 292                 thres_reg_value = (eax & mask) >> shift;
 293
 294                 trips[i].temperature = thres_reg_value ?
 295                         tj_max - thres_reg_value * 1000 : THERMAL_TEMP_INVALID;
 296
 297                 trips[i].type = THERMAL_TRIP_PASSIVE;
 298                 trips[i].flags |= THERMAL_TRIP_FLAG_RW_TEMP;
 299
 300                 pr_debug("%s: cpu=%d, trip=%d, temp=%d\n",
 301                          __func__, cpu, i, trips[i].temperature);
 302         }
 303
 304         return 0;
 305 }
 306
 307 static int pkg_temp_thermal_device_add(unsigned int cpu)
 308 {
 309         struct thermal_trip trips[MAX_NUMBER_OF_TRIPS] = { 0 };
 310         int id = topology_logical_die_id(cpu);
 311         u32 eax, ebx, ecx, edx;
 312         struct zone_device *zonedev;
 313         int thres_count, err;
 314         int tj_max;
 315
 316         if (id >= max_id)
 317                 return -ENOMEM;
 318
 319         cpuid(6, &eax, &ebx, &ecx, &edx);
 320         thres_count = ebx & 0x07;
 321         if (!thres_count)
 322                 return -ENODEV;
 323
 324         thres_count = clamp_val(thres_count, 0, MAX_NUMBER_OF_TRIPS);
 325
 326         tj_max = intel_tcc_get_tjmax(cpu);
 327         if (tj_max < 0)
 328                 return tj_max;
 329
 330         zonedev = kzalloc(sizeof(*zonedev), GFP_KERNEL);
 331         if (!zonedev)
 332                 return -ENOMEM;
 333
 334         err = pkg_temp_thermal_trips_init(cpu, tj_max, trips, thres_count);
 335         if (err)
 336                 goto out_kfree_zonedev;
 337
 338         INIT_DELAYED_WORK(&zonedev->work, pkg_temp_thermal_threshold_work_fn);
 339         zonedev->cpu = cpu;
 340         zonedev->tzone = thermal_zone_device_register_with_trips("x86_pkg_temp",
 341                         trips, thres_count,
 342                         zonedev, &tzone_ops, &pkg_temp_tz_params, 0, 0);
 343         if (IS_ERR(zonedev->tzone)) {
 344                 err = PTR_ERR(zonedev->tzone);
 345                 goto out_kfree_zonedev;
 346         }
 347         err = thermal_zone_device_enable(zonedev->tzone);
 348         if (err)
 349                 goto out_unregister_tz;
 350
 351         /* Store MSR value for package thermal interrupt, to restore at exit */
 352         rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, zonedev->msr_pkg_therm_low,
 353               zonedev->msr_pkg_therm_high);
 354
 355         cpumask_set_cpu(cpu, &zonedev->cpumask);
 356         raw_spin_lock_irq(&pkg_temp_lock);
 357         zones[id] = zonedev;
 358         raw_spin_unlock_irq(&pkg_temp_lock);
 359
 360         return 0;
 361
 362 out_unregister_tz:
 363         thermal_zone_device_unregister(zonedev->tzone);
 364 out_kfree_zonedev:
 365         kfree(zonedev);
 366         return err;
 367 }
 368
 369 static int pkg_thermal_cpu_offline(unsigned int cpu)
 370 {
 371         struct zone_device *zonedev = pkg_temp_thermal_get_dev(cpu);
 372         bool lastcpu, was_target;
 373         int target;
 374
 375         if (!zonedev)
 376                 return 0;
 377
 378         target = cpumask_any_but(&zonedev->cpumask, cpu);
 379         cpumask_clear_cpu(cpu, &zonedev->cpumask);
 380         lastcpu = target >= nr_cpu_ids;
 381         /*
 382          * Remove the sysfs files, if this is the last cpu in the package
 383          * before doing further cleanups.
 384          */
 385         if (lastcpu) {
 386                 struct thermal_zone_device *tzone = zonedev->tzone;
 387
 388                 /*
 389                  * We must protect against a work function calling
 390                  * thermal_zone_update, after/while unregister. We null out
 391                  * the pointer under the zone mutex, so the worker function
 392                  * won't try to call.
 393                  */
 394                 mutex_lock(&thermal_zone_mutex);
 395                 zonedev->tzone = NULL;
 396                 mutex_unlock(&thermal_zone_mutex);
 397
 398                 thermal_zone_device_unregister(tzone);
 399         }
 400
 401         /* Protect against work and interrupts */
 402         raw_spin_lock_irq(&pkg_temp_lock);
 403
 404         /*
 405          * Check whether this cpu was the current target and store the new
 406          * one. When we drop the lock, then the interrupt notify function
 407          * will see the new target.
 408          */
 409         was_target = zonedev->cpu == cpu;
 410         zonedev->cpu = target;
 411
 412         /*
 413          * If this is the last CPU in the package remove the package
 414          * reference from the array and restore the interrupt MSR. When we
 415          * drop the lock neither the interrupt notify function nor the
 416          * worker will see the package anymore.
 417          */
 418         if (lastcpu) {
 419                 zones[topology_logical_die_id(cpu)] = NULL;
 420                 /* After this point nothing touches the MSR anymore. */
 421                 wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT,
 422                       zonedev->msr_pkg_therm_low, zonedev->msr_pkg_therm_high);
 423         }
 424
 425         /*
 426          * Check whether there is work scheduled and whether the work is
 427          * targeted at the outgoing CPU.
 428          */
 429         if (zonedev->work_scheduled && was_target) {
 430                 /*
 431                  * To cancel the work we need to drop the lock, otherwise
 432                  * we might deadlock if the work needs to be flushed.
 433                  */
 434                 raw_spin_unlock_irq(&pkg_temp_lock);
 435                 cancel_delayed_work_sync(&zonedev->work);
 436                 raw_spin_lock_irq(&pkg_temp_lock);
 437                 /*
 438                  * If this is not the last cpu in the package and the work
 439                  * did not run after we dropped the lock above, then we
 440                  * need to reschedule the work, otherwise the interrupt
 441                  * stays disabled forever.
 442                  */
 443                 if (!lastcpu && zonedev->work_scheduled)
 444                         pkg_thermal_schedule_work(target, &zonedev->work);
 445         }
 446
 447         raw_spin_unlock_irq(&pkg_temp_lock);
 448
 449         /* Final cleanup if this is the last cpu */
 450         if (lastcpu)
 451                 kfree(zonedev);
 452
 453         return 0;
 454 }
 455
 456 static int pkg_thermal_cpu_online(unsigned int cpu)
 457 {
 458         struct zone_device *zonedev = pkg_temp_thermal_get_dev(cpu);
 459         struct cpuinfo_x86 *c = &cpu_data(cpu);
 460
 461         /* Paranoia check */
 462         if (!cpu_has(c, X86_FEATURE_DTHERM) || !cpu_has(c, X86_FEATURE_PTS))
 463                 return -ENODEV;
 464
 465         /* If the package exists, nothing to do */
 466         if (zonedev) {
 467                 cpumask_set_cpu(cpu, &zonedev->cpumask);
 468                 return 0;
 469         }
 470         return pkg_temp_thermal_device_add(cpu);
 471 }
 472
 473 static const struct x86_cpu_id __initconst pkg_temp_thermal_ids[] = {
 474         X86_MATCH_VENDOR_FEATURE(INTEL, X86_FEATURE_PTS, NULL),
 475         {}
 476 };
 477 MODULE_DEVICE_TABLE(x86cpu, pkg_temp_thermal_ids);
 478
 479 static int __init pkg_temp_thermal_init(void)
 480 {
 481         int ret;
 482
 483         if (!x86_match_cpu(pkg_temp_thermal_ids))
 484                 return -ENODEV;
 485
 486         max_id = topology_max_packages() * topology_max_dies_per_package();
 487         zones = kcalloc(max_id, sizeof(struct zone_device *),
 488                            GFP_KERNEL);
 489         if (!zones)
 490                 return -ENOMEM;
 491
 492         ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "thermal/x86_pkg:online",
 493                                 pkg_thermal_cpu_online, pkg_thermal_cpu_offline);
 494         if (ret < 0)
 495                 goto err;
 496
 497         /* Store the state for module exit */
 498         pkg_thermal_hp_state = ret;
 499
 500         platform_thermal_package_notify = pkg_thermal_notify;
 501         platform_thermal_package_rate_control = pkg_thermal_rate_control;
 502
 503          /* Don't care if it fails */
 504         pkg_temp_debugfs_init();
 505         return 0;
 506
 507 err:
 508         kfree(zones);
 509         return ret;
 510 }
 511 module_init(pkg_temp_thermal_init)
 512
 513 static void __exit pkg_temp_thermal_exit(void)
 514 {
 515         platform_thermal_package_notify = NULL;
 516         platform_thermal_package_rate_control = NULL;
 517
 518         cpuhp_remove_state(pkg_thermal_hp_state);
 519         debugfs_remove_recursive(debugfs);
 520         kfree(zones);
 521 }
 522 module_exit(pkg_temp_thermal_exit)
 523
 524 MODULE_IMPORT_NS(INTEL_TCC);
 525 MODULE_DESCRIPTION("X86 PKG TEMP Thermal Driver");
 526 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
 527 MODULE_LICENSE("GPL v2");