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