drivers/hwmon/coretemp.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * coretemp.c - Linux kernel module for hardware monitoring
   4  *
   5  * Copyright (C) 2007 Rudolf Marek <[email protected]>
   6  *
   7  * Inspired from many hwmon drivers
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/slab.h>
  15 #include <linux/jiffies.h>
  16 #include <linux/hwmon.h>
  17 #include <linux/sysfs.h>
  18 #include <linux/hwmon-sysfs.h>
  19 #include <linux/err.h>
  20 #include <linux/mutex.h>
  21 #include <linux/list.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/cpu.h>
  24 #include <linux/smp.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/pci.h>
  27 #include <asm/msr.h>
  28 #include <asm/processor.h>
  29 #include <asm/cpu_device_id.h>
  30
  31 #define DRVNAME "coretemp"
  32
  33 /*
  34  * force_tjmax only matters when TjMax can't be read from the CPU itself.
  35  * When set, it replaces the driver's suboptimal heuristic.
  36  */
  37 static int force_tjmax;
  38 module_param_named(tjmax, force_tjmax, int, 0444);
  39 MODULE_PARM_DESC(tjmax, "TjMax value in degrees Celsius");
  40
  41 #define PKG_SYSFS_ATTR_NO       1       /* Sysfs attribute for package temp */
  42 #define BASE_SYSFS_ATTR_NO      2       /* Sysfs Base attr no for coretemp */
  43 #define NUM_REAL_CORES          128     /* Number of Real cores per cpu */
  44 #define CORETEMP_NAME_LENGTH    19      /* String Length of attrs */
  45 #define MAX_CORE_ATTRS          4       /* Maximum no of basic attrs */
  46 #define TOTAL_ATTRS             (MAX_CORE_ATTRS + 1)
  47 #define MAX_CORE_DATA           (NUM_REAL_CORES + BASE_SYSFS_ATTR_NO)
  48
  49 #ifdef CONFIG_SMP
  50 #define for_each_sibling(i, cpu) \
  51         for_each_cpu(i, topology_sibling_cpumask(cpu))
  52 #else
  53 #define for_each_sibling(i, cpu)        for (i = 0; false; )
  54 #endif
  55
  56 /*
  57  * Per-Core Temperature Data
  58  * @tjmax: The static tjmax value when tjmax cannot be retrieved from
  59  *              IA32_TEMPERATURE_TARGET MSR.
  60  * @last_updated: The time when the current temperature value was updated
  61  *              earlier (in jiffies).
  62  * @cpu_core_id: The CPU Core from which temperature values should be read
  63  *              This value is passed as "id" field to rdmsr/wrmsr functions.
  64  * @status_reg: One of IA32_THERM_STATUS or IA32_PACKAGE_THERM_STATUS,
  65  *              from where the temperature values should be read.
  66  * @attr_size:  Total number of pre-core attrs displayed in the sysfs.
  67  * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
  68  *              Otherwise, temp_data holds coretemp data.
  69  */
  70 struct temp_data {
  71         int temp;
  72         int tjmax;
  73         unsigned long last_updated;
  74         unsigned int cpu;
  75         u32 cpu_core_id;
  76         u32 status_reg;
  77         int attr_size;
  78         bool is_pkg_data;
  79         struct sensor_device_attribute sd_attrs[TOTAL_ATTRS];
  80         char attr_name[TOTAL_ATTRS][CORETEMP_NAME_LENGTH];
  81         struct attribute *attrs[TOTAL_ATTRS + 1];
  82         struct attribute_group attr_group;
  83         struct mutex update_lock;
  84 };
  85
  86 /* Platform Data per Physical CPU */
  87 struct platform_data {
  88         struct device           *hwmon_dev;
  89         u16                     pkg_id;
  90         u16                     cpu_map[NUM_REAL_CORES];
  91         struct ida              ida;
  92         struct cpumask          cpumask;
  93         struct temp_data        *core_data[MAX_CORE_DATA];
  94         struct device_attribute name_attr;
  95 };
  96
  97 struct tjmax_pci {
  98         unsigned int device;
  99         int tjmax;
 100 };
 101
 102 static const struct tjmax_pci tjmax_pci_table[] = {
 103         { 0x0708, 110000 },     /* CE41x0 (Sodaville ) */
 104         { 0x0c72, 102000 },     /* Atom S1240 (Centerton) */
 105         { 0x0c73, 95000 },      /* Atom S1220 (Centerton) */
 106         { 0x0c75, 95000 },      /* Atom S1260 (Centerton) */
 107 };
 108
 109 struct tjmax {
 110         char const *id;
 111         int tjmax;
 112 };
 113
 114 static const struct tjmax tjmax_table[] = {
 115         { "CPU  230", 100000 },         /* Model 0x1c, stepping 2       */
 116         { "CPU  330", 125000 },         /* Model 0x1c, stepping 2       */
 117 };
 118
 119 struct tjmax_model {
 120         u8 model;
 121         u8 mask;
 122         int tjmax;
 123 };
 124
 125 #define ANY 0xff
 126
 127 static const struct tjmax_model tjmax_model_table[] = {
 128         { 0x1c, 10, 100000 },   /* D4xx, K4xx, N4xx, D5xx, K5xx, N5xx */
 129         { 0x1c, ANY, 90000 },   /* Z5xx, N2xx, possibly others
 130                                  * Note: Also matches 230 and 330,
 131                                  * which are covered by tjmax_table
 132                                  */
 133         { 0x26, ANY, 90000 },   /* Atom Tunnel Creek (Exx), Lincroft (Z6xx)
 134                                  * Note: TjMax for E6xxT is 110C, but CPU type
 135                                  * is undetectable by software
 136                                  */
 137         { 0x27, ANY, 90000 },   /* Atom Medfield (Z2460) */
 138         { 0x35, ANY, 90000 },   /* Atom Clover Trail/Cloverview (Z27x0) */
 139         { 0x36, ANY, 100000 },  /* Atom Cedar Trail/Cedarview (N2xxx, D2xxx)
 140                                  * Also matches S12x0 (stepping 9), covered by
 141                                  * PCI table
 142                                  */
 143 };
 144
 145 static int adjust_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
 146 {
 147         /* The 100C is default for both mobile and non mobile CPUs */
 148
 149         int tjmax = 100000;
 150         int tjmax_ee = 85000;
 151         int usemsr_ee = 1;
 152         int err;
 153         u32 eax, edx;
 154         int i;
 155         u16 devfn = PCI_DEVFN(0, 0);
 156         struct pci_dev *host_bridge = pci_get_domain_bus_and_slot(0, 0, devfn);
 157
 158         /*
 159          * Explicit tjmax table entries override heuristics.
 160          * First try PCI host bridge IDs, followed by model ID strings
 161          * and model/stepping information.
 162          */
 163         if (host_bridge && host_bridge->vendor == PCI_VENDOR_ID_INTEL) {
 164                 for (i = 0; i < ARRAY_SIZE(tjmax_pci_table); i++) {
 165                         if (host_bridge->device == tjmax_pci_table[i].device) {
 166                                 pci_dev_put(host_bridge);
 167                                 return tjmax_pci_table[i].tjmax;
 168                         }
 169                 }
 170         }
 171         pci_dev_put(host_bridge);
 172
 173         for (i = 0; i < ARRAY_SIZE(tjmax_table); i++) {
 174                 if (strstr(c->x86_model_id, tjmax_table[i].id))
 175                         return tjmax_table[i].tjmax;
 176         }
 177
 178         for (i = 0; i < ARRAY_SIZE(tjmax_model_table); i++) {
 179                 const struct tjmax_model *tm = &tjmax_model_table[i];
 180                 if (c->x86_model == tm->model &&
 181                     (tm->mask == ANY || c->x86_stepping == tm->mask))
 182                         return tm->tjmax;
 183         }
 184
 185         /* Early chips have no MSR for TjMax */
 186
 187         if (c->x86_model == 0xf && c->x86_stepping < 4)
 188                 usemsr_ee = 0;
 189
 190         if (c->x86_model > 0xe && usemsr_ee) {
 191                 u8 platform_id;
 192
 193                 /*
 194                  * Now we can detect the mobile CPU using Intel provided table
 195                  * http://softwarecommunity.intel.com/Wiki/Mobility/720.htm
 196                  * For Core2 cores, check MSR 0x17, bit 28 1 = Mobile CPU
 197                  */
 198                 err = rdmsr_safe_on_cpu(id, 0x17, &eax, &edx);
 199                 if (err) {
 200                         dev_warn(dev,
 201                                  "Unable to access MSR 0x17, assuming desktop"
 202                                  " CPU\n");
 203                         usemsr_ee = 0;
 204                 } else if (c->x86_model < 0x17 && !(eax & 0x10000000)) {
 205                         /*
 206                          * Trust bit 28 up to Penryn, I could not find any
 207                          * documentation on that; if you happen to know
 208                          * someone at Intel please ask
 209                          */
 210                         usemsr_ee = 0;
 211                 } else {
 212                         /* Platform ID bits 52:50 (EDX starts at bit 32) */
 213                         platform_id = (edx >> 18) & 0x7;
 214
 215                         /*
 216                          * Mobile Penryn CPU seems to be platform ID 7 or 5
 217                          * (guesswork)
 218                          */
 219                         if (c->x86_model == 0x17 &&
 220                             (platform_id == 5 || platform_id == 7)) {
 221                                 /*
 222                                  * If MSR EE bit is set, set it to 90 degrees C,
 223                                  * otherwise 105 degrees C
 224                                  */
 225                                 tjmax_ee = 90000;
 226                                 tjmax = 105000;
 227                         }
 228                 }
 229         }
 230
 231         if (usemsr_ee) {
 232                 err = rdmsr_safe_on_cpu(id, 0xee, &eax, &edx);
 233                 if (err) {
 234                         dev_warn(dev,
 235                                  "Unable to access MSR 0xEE, for Tjmax, left"
 236                                  " at default\n");
 237                 } else if (eax & 0x40000000) {
 238                         tjmax = tjmax_ee;
 239                 }
 240         } else if (tjmax == 100000) {
 241                 /*
 242                  * If we don't use msr EE it means we are desktop CPU
 243                  * (with exeception of Atom)
 244                  */
 245                 dev_warn(dev, "Using relative temperature scale!\n");
 246         }
 247
 248         return tjmax;
 249 }
 250
 251 static bool cpu_has_tjmax(struct cpuinfo_x86 *c)
 252 {
 253         u8 model = c->x86_model;
 254
 255         return model > 0xe &&
 256                model != 0x1c &&
 257                model != 0x26 &&
 258                model != 0x27 &&
 259                model != 0x35 &&
 260                model != 0x36;
 261 }
 262
 263 static int get_tjmax(struct temp_data *tdata, struct device *dev)
 264 {
 265         struct cpuinfo_x86 *c = &cpu_data(tdata->cpu);
 266         int err;
 267         u32 eax, edx;
 268         u32 val;
 269
 270         /* use static tjmax once it is set */
 271         if (tdata->tjmax)
 272                 return tdata->tjmax;
 273
 274         /*
 275          * A new feature of current Intel(R) processors, the
 276          * IA32_TEMPERATURE_TARGET contains the TjMax value
 277          */
 278         err = rdmsr_safe_on_cpu(tdata->cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
 279         if (err) {
 280                 if (cpu_has_tjmax(c))
 281                         dev_warn(dev, "Unable to read TjMax from CPU %u\n", tdata->cpu);
 282         } else {
 283                 val = (eax >> 16) & 0xff;
 284                 /*
 285                  * If the TjMax is not plausible, an assumption
 286                  * will be used
 287                  */
 288                 if (val) {
 289                         dev_dbg(dev, "TjMax is %d degrees C\n", val);
 290                         return val * 1000;
 291                 }
 292         }
 293
 294         if (force_tjmax) {
 295                 dev_notice(dev, "TjMax forced to %d degrees C by user\n",
 296                            force_tjmax);
 297                 tdata->tjmax = force_tjmax * 1000;
 298         } else {
 299                 /*
 300                  * An assumption is made for early CPUs and unreadable MSR.
 301                  * NOTE: the calculated value may not be correct.
 302                  */
 303                 tdata->tjmax = adjust_tjmax(c, tdata->cpu, dev);
 304         }
 305         return tdata->tjmax;
 306 }
 307
 308 static int get_ttarget(struct temp_data *tdata, struct device *dev)
 309 {
 310         u32 eax, edx;
 311         int tjmax, ttarget_offset, ret;
 312
 313         /*
 314          * ttarget is valid only if tjmax can be retrieved from
 315          * MSR_IA32_TEMPERATURE_TARGET
 316          */
 317         if (tdata->tjmax)
 318                 return -ENODEV;
 319
 320         ret = rdmsr_safe_on_cpu(tdata->cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
 321         if (ret)
 322                 return ret;
 323
 324         tjmax = (eax >> 16) & 0xff;
 325
 326         /* Read the still undocumented bits 8:15 of IA32_TEMPERATURE_TARGET. */
 327         ttarget_offset = (eax >> 8) & 0xff;
 328
 329         return (tjmax - ttarget_offset) * 1000;
 330 }
 331
 332 /* Keep track of how many zone pointers we allocated in init() */
 333 static int max_zones __read_mostly;
 334 /* Array of zone pointers. Serialized by cpu hotplug lock */
 335 static struct platform_device **zone_devices;
 336
 337 static ssize_t show_label(struct device *dev,
 338                                 struct device_attribute *devattr, char *buf)
 339 {
 340         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 341         struct platform_data *pdata = dev_get_drvdata(dev);
 342         struct temp_data *tdata = pdata->core_data[attr->index];
 343
 344         if (tdata->is_pkg_data)
 345                 return sprintf(buf, "Package id %u\n", pdata->pkg_id);
 346
 347         return sprintf(buf, "Core %u\n", tdata->cpu_core_id);
 348 }
 349
 350 static ssize_t show_crit_alarm(struct device *dev,
 351                                 struct device_attribute *devattr, char *buf)
 352 {
 353         u32 eax, edx;
 354         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 355         struct platform_data *pdata = dev_get_drvdata(dev);
 356         struct temp_data *tdata = pdata->core_data[attr->index];
 357
 358         mutex_lock(&tdata->update_lock);
 359         rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
 360         mutex_unlock(&tdata->update_lock);
 361
 362         return sprintf(buf, "%d\n", (eax >> 5) & 1);
 363 }
 364
 365 static ssize_t show_tjmax(struct device *dev,
 366                         struct device_attribute *devattr, char *buf)
 367 {
 368         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 369         struct platform_data *pdata = dev_get_drvdata(dev);
 370         struct temp_data *tdata = pdata->core_data[attr->index];
 371         int tjmax;
 372
 373         mutex_lock(&tdata->update_lock);
 374         tjmax = get_tjmax(tdata, dev);
 375         mutex_unlock(&tdata->update_lock);
 376
 377         return sprintf(buf, "%d\n", tjmax);
 378 }
 379
 380 static ssize_t show_ttarget(struct device *dev,
 381                                 struct device_attribute *devattr, char *buf)
 382 {
 383         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 384         struct platform_data *pdata = dev_get_drvdata(dev);
 385         struct temp_data *tdata = pdata->core_data[attr->index];
 386         int ttarget;
 387
 388         mutex_lock(&tdata->update_lock);
 389         ttarget = get_ttarget(tdata, dev);
 390         mutex_unlock(&tdata->update_lock);
 391
 392         if (ttarget < 0)
 393                 return ttarget;
 394         return sprintf(buf, "%d\n", ttarget);
 395 }
 396
 397 static ssize_t show_temp(struct device *dev,
 398                         struct device_attribute *devattr, char *buf)
 399 {
 400         u32 eax, edx;
 401         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 402         struct platform_data *pdata = dev_get_drvdata(dev);
 403         struct temp_data *tdata = pdata->core_data[attr->index];
 404         int tjmax;
 405
 406         mutex_lock(&tdata->update_lock);
 407
 408         tjmax = get_tjmax(tdata, dev);
 409         /* Check whether the time interval has elapsed */
 410         if (time_after(jiffies, tdata->last_updated + HZ)) {
 411                 rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
 412                 /*
 413                  * Ignore the valid bit. In all observed cases the register
 414                  * value is either low or zero if the valid bit is 0.
 415                  * Return it instead of reporting an error which doesn't
 416                  * really help at all.
 417                  */
 418                 tdata->temp = tjmax - ((eax >> 16) & 0x7f) * 1000;
 419                 tdata->last_updated = jiffies;
 420         }
 421
 422         mutex_unlock(&tdata->update_lock);
 423         return sprintf(buf, "%d\n", tdata->temp);
 424 }
 425
 426 static int create_core_attrs(struct temp_data *tdata, struct device *dev,
 427                              int attr_no)
 428 {
 429         int i;
 430         static ssize_t (*const rd_ptr[TOTAL_ATTRS]) (struct device *dev,
 431                         struct device_attribute *devattr, char *buf) = {
 432                         show_label, show_crit_alarm, show_temp, show_tjmax,
 433                         show_ttarget };
 434         static const char *const suffixes[TOTAL_ATTRS] = {
 435                 "label", "crit_alarm", "input", "crit", "max"
 436         };
 437
 438         for (i = 0; i < tdata->attr_size; i++) {
 439                 snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH,
 440                          "temp%d_%s", attr_no, suffixes[i]);
 441                 sysfs_attr_init(&tdata->sd_attrs[i].dev_attr.attr);
 442                 tdata->sd_attrs[i].dev_attr.attr.name = tdata->attr_name[i];
 443                 tdata->sd_attrs[i].dev_attr.attr.mode = 0444;
 444                 tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
 445                 tdata->sd_attrs[i].index = attr_no;
 446                 tdata->attrs[i] = &tdata->sd_attrs[i].dev_attr.attr;
 447         }
 448         tdata->attr_group.attrs = tdata->attrs;
 449         return sysfs_create_group(&dev->kobj, &tdata->attr_group);
 450 }
 451
 452
 453 static int chk_ucode_version(unsigned int cpu)
 454 {
 455         struct cpuinfo_x86 *c = &cpu_data(cpu);
 456
 457         /*
 458          * Check if we have problem with errata AE18 of Core processors:
 459          * Readings might stop update when processor visited too deep sleep,
 460          * fixed for stepping D0 (6EC).
 461          */
 462         if (c->x86_model == 0xe && c->x86_stepping < 0xc && c->microcode < 0x39) {
 463                 pr_err("Errata AE18 not fixed, update BIOS or microcode of the CPU!\n");
 464                 return -ENODEV;
 465         }
 466         return 0;
 467 }
 468
 469 static struct platform_device *coretemp_get_pdev(unsigned int cpu)
 470 {
 471         int id = topology_logical_die_id(cpu);
 472
 473         if (id >= 0 && id < max_zones)
 474                 return zone_devices[id];
 475         return NULL;
 476 }
 477
 478 static struct temp_data *init_temp_data(unsigned int cpu, int pkg_flag)
 479 {
 480         struct temp_data *tdata;
 481
 482         tdata = kzalloc(sizeof(struct temp_data), GFP_KERNEL);
 483         if (!tdata)
 484                 return NULL;
 485
 486         tdata->status_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_STATUS :
 487                                                         MSR_IA32_THERM_STATUS;
 488         tdata->is_pkg_data = pkg_flag;
 489         tdata->cpu = cpu;
 490         tdata->cpu_core_id = topology_core_id(cpu);
 491         tdata->attr_size = MAX_CORE_ATTRS;
 492         mutex_init(&tdata->update_lock);
 493         return tdata;
 494 }
 495
 496 static int create_core_data(struct platform_device *pdev, unsigned int cpu,
 497                             int pkg_flag)
 498 {
 499         struct temp_data *tdata;
 500         struct platform_data *pdata = platform_get_drvdata(pdev);
 501         struct cpuinfo_x86 *c = &cpu_data(cpu);
 502         u32 eax, edx;
 503         int err, index, attr_no;
 504
 505         /*
 506          * Find attr number for sysfs:
 507          * We map the attr number to core id of the CPU
 508          * The attr number is always core id + 2
 509          * The Pkgtemp will always show up as temp1_*, if available
 510          */
 511         if (pkg_flag) {
 512                 attr_no = PKG_SYSFS_ATTR_NO;
 513         } else {
 514                 index = ida_alloc(&pdata->ida, GFP_KERNEL);
 515                 if (index < 0)
 516                         return index;
 517                 pdata->cpu_map[index] = topology_core_id(cpu);
 518                 attr_no = index + BASE_SYSFS_ATTR_NO;
 519         }
 520
 521         if (attr_no > MAX_CORE_DATA - 1) {
 522                 err = -ERANGE;
 523                 goto ida_free;
 524         }
 525
 526         tdata = init_temp_data(cpu, pkg_flag);
 527         if (!tdata) {
 528                 err = -ENOMEM;
 529                 goto ida_free;
 530         }
 531
 532         /* Test if we can access the status register */
 533         err = rdmsr_safe_on_cpu(cpu, tdata->status_reg, &eax, &edx);
 534         if (err)
 535                 goto exit_free;
 536
 537         /* Make sure tdata->tjmax is a valid indicator for dynamic/static tjmax */
 538         get_tjmax(tdata, &pdev->dev);
 539
 540         /*
 541          * The target temperature is available on older CPUs but not in the
 542          * MSR_IA32_TEMPERATURE_TARGET register. Atoms don't have the register
 543          * at all.
 544          */
 545         if (c->x86_model > 0xe && c->x86_model != 0x1c)
 546                 if (get_ttarget(tdata, &pdev->dev) >= 0)
 547                         tdata->attr_size++;
 548
 549         pdata->core_data[attr_no] = tdata;
 550
 551         /* Create sysfs interfaces */
 552         err = create_core_attrs(tdata, pdata->hwmon_dev, attr_no);
 553         if (err)
 554                 goto exit_free;
 555
 556         return 0;
 557 exit_free:
 558         pdata->core_data[attr_no] = NULL;
 559         kfree(tdata);
 560 ida_free:
 561         if (!pkg_flag)
 562                 ida_free(&pdata->ida, index);
 563         return err;
 564 }
 565
 566 static void
 567 coretemp_add_core(struct platform_device *pdev, unsigned int cpu, int pkg_flag)
 568 {
 569         if (create_core_data(pdev, cpu, pkg_flag))
 570                 dev_err(&pdev->dev, "Adding Core %u failed\n", cpu);
 571 }
 572
 573 static void coretemp_remove_core(struct platform_data *pdata, int indx)
 574 {
 575         struct temp_data *tdata = pdata->core_data[indx];
 576
 577         /* if we errored on add then this is already gone */
 578         if (!tdata)
 579                 return;
 580
 581         /* Remove the sysfs attributes */
 582         sysfs_remove_group(&pdata->hwmon_dev->kobj, &tdata->attr_group);
 583
 584         kfree(pdata->core_data[indx]);
 585         pdata->core_data[indx] = NULL;
 586
 587         if (indx >= BASE_SYSFS_ATTR_NO)
 588                 ida_free(&pdata->ida, indx - BASE_SYSFS_ATTR_NO);
 589 }
 590
 591 static int coretemp_probe(struct platform_device *pdev)
 592 {
 593         struct device *dev = &pdev->dev;
 594         struct platform_data *pdata;
 595
 596         /* Initialize the per-zone data structures */
 597         pdata = devm_kzalloc(dev, sizeof(struct platform_data), GFP_KERNEL);
 598         if (!pdata)
 599                 return -ENOMEM;
 600
 601         pdata->pkg_id = pdev->id;
 602         ida_init(&pdata->ida);
 603         platform_set_drvdata(pdev, pdata);
 604
 605         pdata->hwmon_dev = devm_hwmon_device_register_with_groups(dev, DRVNAME,
 606                                                                   pdata, NULL);
 607         return PTR_ERR_OR_ZERO(pdata->hwmon_dev);
 608 }
 609
 610 static int coretemp_remove(struct platform_device *pdev)
 611 {
 612         struct platform_data *pdata = platform_get_drvdata(pdev);
 613         int i;
 614
 615         for (i = MAX_CORE_DATA - 1; i >= 0; --i)
 616                 if (pdata->core_data[i])
 617                         coretemp_remove_core(pdata, i);
 618
 619         ida_destroy(&pdata->ida);
 620         return 0;
 621 }
 622
 623 static struct platform_driver coretemp_driver = {
 624         .driver = {
 625                 .name = DRVNAME,
 626         },
 627         .probe = coretemp_probe,
 628         .remove = coretemp_remove,
 629 };
 630
 631 static struct platform_device *coretemp_device_add(unsigned int cpu)
 632 {
 633         int err, zoneid = topology_logical_die_id(cpu);
 634         struct platform_device *pdev;
 635
 636         if (zoneid < 0)
 637                 return ERR_PTR(-ENOMEM);
 638
 639         pdev = platform_device_alloc(DRVNAME, zoneid);
 640         if (!pdev)
 641                 return ERR_PTR(-ENOMEM);
 642
 643         err = platform_device_add(pdev);
 644         if (err) {
 645                 platform_device_put(pdev);
 646                 return ERR_PTR(err);
 647         }
 648
 649         zone_devices[zoneid] = pdev;
 650         return pdev;
 651 }
 652
 653 static int coretemp_cpu_online(unsigned int cpu)
 654 {
 655         struct platform_device *pdev = coretemp_get_pdev(cpu);
 656         struct cpuinfo_x86 *c = &cpu_data(cpu);
 657         struct platform_data *pdata;
 658
 659         /*
 660          * Don't execute this on resume as the offline callback did
 661          * not get executed on suspend.
 662          */
 663         if (cpuhp_tasks_frozen)
 664                 return 0;
 665
 666         /*
 667          * CPUID.06H.EAX[0] indicates whether the CPU has thermal
 668          * sensors. We check this bit only, all the early CPUs
 669          * without thermal sensors will be filtered out.
 670          */
 671         if (!cpu_has(c, X86_FEATURE_DTHERM))
 672                 return -ENODEV;
 673
 674         if (!pdev) {
 675                 /* Check the microcode version of the CPU */
 676                 if (chk_ucode_version(cpu))
 677                         return -EINVAL;
 678
 679                 /*
 680                  * Alright, we have DTS support.
 681                  * We are bringing the _first_ core in this pkg
 682                  * online. So, initialize per-pkg data structures and
 683                  * then bring this core online.
 684                  */
 685                 pdev = coretemp_device_add(cpu);
 686                 if (IS_ERR(pdev))
 687                         return PTR_ERR(pdev);
 688
 689                 /*
 690                  * Check whether pkgtemp support is available.
 691                  * If so, add interfaces for pkgtemp.
 692                  */
 693                 if (cpu_has(c, X86_FEATURE_PTS))
 694                         coretemp_add_core(pdev, cpu, 1);
 695         }
 696
 697         pdata = platform_get_drvdata(pdev);
 698         /*
 699          * Check whether a thread sibling is already online. If not add the
 700          * interface for this CPU core.
 701          */
 702         if (!cpumask_intersects(&pdata->cpumask, topology_sibling_cpumask(cpu)))
 703                 coretemp_add_core(pdev, cpu, 0);
 704
 705         cpumask_set_cpu(cpu, &pdata->cpumask);
 706         return 0;
 707 }
 708
 709 static int coretemp_cpu_offline(unsigned int cpu)
 710 {
 711         struct platform_device *pdev = coretemp_get_pdev(cpu);
 712         struct platform_data *pd;
 713         struct temp_data *tdata;
 714         int i, indx = -1, target;
 715
 716         /*
 717          * Don't execute this on suspend as the device remove locks
 718          * up the machine.
 719          */
 720         if (cpuhp_tasks_frozen)
 721                 return 0;
 722
 723         /* If the physical CPU device does not exist, just return */
 724         if (!pdev)
 725                 return 0;
 726
 727         pd = platform_get_drvdata(pdev);
 728
 729         for (i = 0; i < NUM_REAL_CORES; i++) {
 730                 if (pd->cpu_map[i] == topology_core_id(cpu)) {
 731                         indx = i + BASE_SYSFS_ATTR_NO;
 732                         break;
 733                 }
 734         }
 735
 736         /* Too many cores and this core is not populated, just return */
 737         if (indx < 0)
 738                 return 0;
 739
 740         tdata = pd->core_data[indx];
 741
 742         cpumask_clear_cpu(cpu, &pd->cpumask);
 743
 744         /*
 745          * If this is the last thread sibling, remove the CPU core
 746          * interface, If there is still a sibling online, transfer the
 747          * target cpu of that core interface to it.
 748          */
 749         target = cpumask_any_and(&pd->cpumask, topology_sibling_cpumask(cpu));
 750         if (target >= nr_cpu_ids) {
 751                 coretemp_remove_core(pd, indx);
 752         } else if (tdata && tdata->cpu == cpu) {
 753                 mutex_lock(&tdata->update_lock);
 754                 tdata->cpu = target;
 755                 mutex_unlock(&tdata->update_lock);
 756         }
 757
 758         /*
 759          * If all cores in this pkg are offline, remove the device. This
 760          * will invoke the platform driver remove function, which cleans up
 761          * the rest.
 762          */
 763         if (cpumask_empty(&pd->cpumask)) {
 764                 zone_devices[topology_logical_die_id(cpu)] = NULL;
 765                 platform_device_unregister(pdev);
 766                 return 0;
 767         }
 768
 769         /*
 770          * Check whether this core is the target for the package
 771          * interface. We need to assign it to some other cpu.
 772          */
 773         tdata = pd->core_data[PKG_SYSFS_ATTR_NO];
 774         if (tdata && tdata->cpu == cpu) {
 775                 target = cpumask_first(&pd->cpumask);
 776                 mutex_lock(&tdata->update_lock);
 777                 tdata->cpu = target;
 778                 mutex_unlock(&tdata->update_lock);
 779         }
 780         return 0;
 781 }
 782 static const struct x86_cpu_id __initconst coretemp_ids[] = {
 783         X86_MATCH_VENDOR_FEATURE(INTEL, X86_FEATURE_DTHERM, NULL),
 784         {}
 785 };
 786 MODULE_DEVICE_TABLE(x86cpu, coretemp_ids);
 787
 788 static enum cpuhp_state coretemp_hp_online;
 789
 790 static int __init coretemp_init(void)
 791 {
 792         int err;
 793
 794         /*
 795          * CPUID.06H.EAX[0] indicates whether the CPU has thermal
 796          * sensors. We check this bit only, all the early CPUs
 797          * without thermal sensors will be filtered out.
 798          */
 799         if (!x86_match_cpu(coretemp_ids))
 800                 return -ENODEV;
 801
 802         max_zones = topology_max_packages() * topology_max_die_per_package();
 803         zone_devices = kcalloc(max_zones, sizeof(struct platform_device *),
 804                               GFP_KERNEL);
 805         if (!zone_devices)
 806                 return -ENOMEM;
 807
 808         err = platform_driver_register(&coretemp_driver);
 809         if (err)
 810                 goto outzone;
 811
 812         err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "hwmon/coretemp:online",
 813                                 coretemp_cpu_online, coretemp_cpu_offline);
 814         if (err < 0)
 815                 goto outdrv;
 816         coretemp_hp_online = err;
 817         return 0;
 818
 819 outdrv:
 820         platform_driver_unregister(&coretemp_driver);
 821 outzone:
 822         kfree(zone_devices);
 823         return err;
 824 }
 825 module_init(coretemp_init)
 826
 827 static void __exit coretemp_exit(void)
 828 {
 829         cpuhp_remove_state(coretemp_hp_online);
 830         platform_driver_unregister(&coretemp_driver);
 831         kfree(zone_devices);
 832 }
 833 module_exit(coretemp_exit)
 834
 835 MODULE_AUTHOR("Rudolf Marek <[email protected]>");
 836 MODULE_DESCRIPTION("Intel Core temperature monitor");
 837 MODULE_LICENSE("GPL");