drivers/hwmon/coretemp.c

   1 /*
   2  * coretemp.c - Linux kernel module for hardware monitoring
   3  *
   4  * Copyright (C) 2007 Rudolf Marek <r.marek@assembler.cz>
   5  *
   6  * Inspired from many hwmon drivers
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301 USA.
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/delay.h>
  25 #include <linux/init.h>
  26 #include <linux/slab.h>
  27 #include <linux/jiffies.h>
  28 #include <linux/hwmon.h>
  29 #include <linux/sysfs.h>
  30 #include <linux/hwmon-sysfs.h>
  31 #include <linux/err.h>
  32 #include <linux/mutex.h>
  33 #include <linux/list.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/cpu.h>
  36 #include <asm/msr.h>
  37 #include <asm/processor.h>
  38
  39 #define DRVNAME "coretemp"
  40
  41 typedef enum { SHOW_TEMP, SHOW_TJMAX, SHOW_LABEL, SHOW_NAME } SHOW;
  42
  43 /*
  44  * Functions declaration
  45  */
  46
  47 static struct coretemp_data *coretemp_update_device(struct device *dev);
  48
  49 struct coretemp_data {
  50         struct device *hwmon_dev;
  51         struct mutex update_lock;
  52         const char *name;
  53         u32 id;
  54         char valid;             /* zero until following fields are valid */
  55         unsigned long last_updated;     /* in jiffies */
  56         int temp;
  57         int tjmax;
  58         u8 alarm;
  59 };
  60
  61 /*
  62  * Sysfs stuff
  63  */
  64
  65 static ssize_t show_name(struct device *dev, struct device_attribute
  66                           *devattr, char *buf)
  67 {
  68         int ret;
  69         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  70         struct coretemp_data *data = dev_get_drvdata(dev);
  71
  72         if (attr->index == SHOW_NAME)
  73                 ret = sprintf(buf, "%s\n", data->name);
  74         else    /* show label */
  75                 ret = sprintf(buf, "Core %d\n", data->id);
  76         return ret;
  77 }
  78
  79 static ssize_t show_alarm(struct device *dev, struct device_attribute
  80                           *devattr, char *buf)
  81 {
  82         struct coretemp_data *data = coretemp_update_device(dev);
  83         /* read the Out-of-spec log, never clear */
  84         return sprintf(buf, "%d\n", data->alarm);
  85 }
  86
  87 static ssize_t show_temp(struct device *dev,
  88                          struct device_attribute *devattr, char *buf)
  89 {
  90         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  91         struct coretemp_data *data = coretemp_update_device(dev);
  92         int err;
  93
  94         if (attr->index == SHOW_TEMP)
  95                 err = data->valid ? sprintf(buf, "%d\n", data->temp) : -EAGAIN;
  96         else
  97                 err = sprintf(buf, "%d\n", data->tjmax);
  98
  99         return err;
 100 }
 101
 102 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
 103                           SHOW_TEMP);
 104 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL,
 105                           SHOW_TJMAX);
 106 static DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL);
 107 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
 108 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
 109
 110 static struct attribute *coretemp_attributes[] = {
 111         &sensor_dev_attr_name.dev_attr.attr,
 112         &sensor_dev_attr_temp1_label.dev_attr.attr,
 113         &dev_attr_temp1_crit_alarm.attr,
 114         &sensor_dev_attr_temp1_input.dev_attr.attr,
 115         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 116         NULL
 117 };
 118
 119 static const struct attribute_group coretemp_group = {
 120         .attrs = coretemp_attributes,
 121 };
 122
 123 static struct coretemp_data *coretemp_update_device(struct device *dev)
 124 {
 125         struct coretemp_data *data = dev_get_drvdata(dev);
 126
 127         mutex_lock(&data->update_lock);
 128
 129         if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
 130                 u32 eax, edx;
 131
 132                 data->valid = 0;
 133                 rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
 134                 data->alarm = (eax >> 5) & 1;
 135                 /* update only if data has been valid */
 136                 if (eax & 0x80000000) {
 137                         data->temp = data->tjmax - (((eax >> 16)
 138                                                         & 0x7f) * 1000);
 139                         data->valid = 1;
 140                 } else {
 141                         dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax);
 142                 }
 143                 data->last_updated = jiffies;
 144         }
 145
 146         mutex_unlock(&data->update_lock);
 147         return data;
 148 }
 149
 150 static int __devinit coretemp_probe(struct platform_device *pdev)
 151 {
 152         struct coretemp_data *data;
 153         struct cpuinfo_x86 *c = &(cpu_data)[pdev->id];
 154         int err;
 155         u32 eax, edx;
 156
 157         if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
 158                 err = -ENOMEM;
 159                 dev_err(&pdev->dev, "Out of memory\n");
 160                 goto exit;
 161         }
 162
 163         data->id = pdev->id;
 164         data->name = "coretemp";
 165         mutex_init(&data->update_lock);
 166         /* Tjmax default is 100 degrees C */
 167         data->tjmax = 100000;
 168
 169         /* test if we can access the THERM_STATUS MSR */
 170         err = rdmsr_safe_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
 171         if (err) {
 172                 dev_err(&pdev->dev,
 173                         "Unable to access THERM_STATUS MSR, giving up\n");
 174                 goto exit_free;
 175         }
 176
 177         /* Check if we have problem with errata AE18 of Core processors:
 178            Readings might stop update when processor visited too deep sleep,
 179            fixed for stepping D0 (6EC).
 180         */
 181
 182         if ((c->x86_model == 0xe) && (c->x86_mask < 0xc)) {
 183                 /* check for microcode update */
 184                 rdmsr_on_cpu(data->id, MSR_IA32_UCODE_REV, &eax, &edx);
 185                 if (edx < 0x39) {
 186                         err = -ENODEV;
 187                         dev_err(&pdev->dev,
 188                                 "Errata AE18 not fixed, update BIOS or "
 189                                 "microcode of the CPU!\n");
 190                         goto exit_free;
 191                 }
 192         }
 193
 194         /* Some processors have Tjmax 85 following magic should detect it
 195            Intel won't disclose the information without signed NDA, but
 196            individuals cannot sign it. Catch(ed) 22.
 197         */
 198
 199         if (((c->x86_model == 0xf) && (c->x86_mask > 3)) ||
 200                 (c->x86_model == 0xe))  {
 201                 err = rdmsr_safe_on_cpu(data->id, 0xee, &eax, &edx);
 202                 if (err) {
 203                         dev_warn(&pdev->dev,
 204                                  "Unable to access MSR 0xEE, Tjmax left at %d "
 205                                  "degrees C\n", data->tjmax/1000);
 206                 } else if (eax & 0x40000000) {
 207                         data->tjmax = 85000;
 208                 }
 209         }
 210
 211         /* Intel says that above should not work for desktop Core2 processors,
 212            but it seems to work. There is no other way how get the absolute
 213            readings. Warn the user about this. First check if are desktop,
 214            bit 50 of MSR_IA32_PLATFORM_ID should be 0.
 215         */
 216
 217         rdmsr_safe_on_cpu(data->id, MSR_IA32_PLATFORM_ID, &eax, &edx);
 218
 219         if ((c->x86_model == 0xf) && (!(edx & 0x00040000))) {
 220                 dev_warn(&pdev->dev, "Using undocumented features, absolute "
 221                          "temperature might be wrong!\n");
 222         }
 223
 224         platform_set_drvdata(pdev, data);
 225
 226         if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
 227                 goto exit_free;
 228
 229         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 230         if (IS_ERR(data->hwmon_dev)) {
 231                 err = PTR_ERR(data->hwmon_dev);
 232                 dev_err(&pdev->dev, "Class registration failed (%d)\n",
 233                         err);
 234                 goto exit_class;
 235         }
 236
 237         return 0;
 238
 239 exit_class:
 240         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 241 exit_free:
 242         kfree(data);
 243 exit:
 244         return err;
 245 }
 246
 247 static int __devexit coretemp_remove(struct platform_device *pdev)
 248 {
 249         struct coretemp_data *data = platform_get_drvdata(pdev);
 250
 251         hwmon_device_unregister(data->hwmon_dev);
 252         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 253         platform_set_drvdata(pdev, NULL);
 254         kfree(data);
 255         return 0;
 256 }
 257
 258 static struct platform_driver coretemp_driver = {
 259         .driver = {
 260                 .owner = THIS_MODULE,
 261                 .name = DRVNAME,
 262         },
 263         .probe = coretemp_probe,
 264         .remove = __devexit_p(coretemp_remove),
 265 };
 266
 267 struct pdev_entry {
 268         struct list_head list;
 269         struct platform_device *pdev;
 270         unsigned int cpu;
 271 };
 272
 273 static LIST_HEAD(pdev_list);
 274 static DEFINE_MUTEX(pdev_list_mutex);
 275
 276 static int __cpuinit coretemp_device_add(unsigned int cpu)
 277 {
 278         int err;
 279         struct platform_device *pdev;
 280         struct pdev_entry *pdev_entry;
 281
 282         pdev = platform_device_alloc(DRVNAME, cpu);
 283         if (!pdev) {
 284                 err = -ENOMEM;
 285                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
 286                 goto exit;
 287         }
 288
 289         pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
 290         if (!pdev_entry) {
 291                 err = -ENOMEM;
 292                 goto exit_device_put;
 293         }
 294
 295         err = platform_device_add(pdev);
 296         if (err) {
 297                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
 298                        err);
 299                 goto exit_device_free;
 300         }
 301
 302         pdev_entry->pdev = pdev;
 303         pdev_entry->cpu = cpu;
 304         mutex_lock(&pdev_list_mutex);
 305         list_add_tail(&pdev_entry->list, &pdev_list);
 306         mutex_unlock(&pdev_list_mutex);
 307
 308         return 0;
 309
 310 exit_device_free:
 311         kfree(pdev_entry);
 312 exit_device_put:
 313         platform_device_put(pdev);
 314 exit:
 315         return err;
 316 }
 317
 318 #ifdef CONFIG_HOTPLUG_CPU
 319 static void coretemp_device_remove(unsigned int cpu)
 320 {
 321         struct pdev_entry *p, *n;
 322         mutex_lock(&pdev_list_mutex);
 323         list_for_each_entry_safe(p, n, &pdev_list, list) {
 324                 if (p->cpu == cpu) {
 325                         platform_device_unregister(p->pdev);
 326                         list_del(&p->list);
 327                         kfree(p);
 328                 }
 329         }
 330         mutex_unlock(&pdev_list_mutex);
 331 }
 332
 333 static int coretemp_cpu_callback(struct notifier_block *nfb,
 334                                  unsigned long action, void *hcpu)
 335 {
 336         unsigned int cpu = (unsigned long) hcpu;
 337
 338         switch (action) {
 339         case CPU_ONLINE:
 340         case CPU_ONLINE_FROZEN:
 341                 coretemp_device_add(cpu);
 342                 break;
 343         case CPU_DEAD:
 344         case CPU_DEAD_FROZEN:
 345                 coretemp_device_remove(cpu);
 346                 break;
 347         }
 348         return NOTIFY_OK;
 349 }
 350
 351 static struct notifier_block coretemp_cpu_notifier = {
 352         .notifier_call = coretemp_cpu_callback,
 353 };
 354 #endif                          /* !CONFIG_HOTPLUG_CPU */
 355
 356 static int __init coretemp_init(void)
 357 {
 358         int i, err = -ENODEV;
 359         struct pdev_entry *p, *n;
 360
 361         /* quick check if we run Intel */
 362         if (cpu_data[0].x86_vendor != X86_VENDOR_INTEL)
 363                 goto exit;
 364
 365         err = platform_driver_register(&coretemp_driver);
 366         if (err)
 367                 goto exit;
 368
 369         for_each_online_cpu(i) {
 370                 struct cpuinfo_x86 *c = &(cpu_data)[i];
 371
 372                 /* check if family 6, models e, f, 16 */
 373                 if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
 374                     !((c->x86_model == 0xe) || (c->x86_model == 0xf) ||
 375                         (c->x86_model == 0x16))) {
 376
 377                         /* supported CPU not found, but report the unknown
 378                            family 6 CPU */
 379                         if ((c->x86 == 0x6) && (c->x86_model > 0xf))
 380                                 printk(KERN_WARNING DRVNAME ": Unknown CPU "
 381                                         "model %x\n", c->x86_model);
 382                         continue;
 383                 }
 384
 385                 err = coretemp_device_add(i);
 386                 if (err)
 387                         goto exit_devices_unreg;
 388         }
 389         if (list_empty(&pdev_list)) {
 390                 err = -ENODEV;
 391                 goto exit_driver_unreg;
 392         }
 393
 394 #ifdef CONFIG_HOTPLUG_CPU
 395         register_hotcpu_notifier(&coretemp_cpu_notifier);
 396 #endif
 397         return 0;
 398
 399 exit_devices_unreg:
 400         mutex_lock(&pdev_list_mutex);
 401         list_for_each_entry_safe(p, n, &pdev_list, list) {
 402                 platform_device_unregister(p->pdev);
 403                 list_del(&p->list);
 404                 kfree(p);
 405         }
 406         mutex_unlock(&pdev_list_mutex);
 407 exit_driver_unreg:
 408         platform_driver_unregister(&coretemp_driver);
 409 exit:
 410         return err;
 411 }
 412
 413 static void __exit coretemp_exit(void)
 414 {
 415         struct pdev_entry *p, *n;
 416 #ifdef CONFIG_HOTPLUG_CPU
 417         unregister_hotcpu_notifier(&coretemp_cpu_notifier);
 418 #endif
 419         mutex_lock(&pdev_list_mutex);
 420         list_for_each_entry_safe(p, n, &pdev_list, list) {
 421                 platform_device_unregister(p->pdev);
 422                 list_del(&p->list);
 423                 kfree(p);
 424         }
 425         mutex_unlock(&pdev_list_mutex);
 426         platform_driver_unregister(&coretemp_driver);
 427 }
 428
 429 MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");
 430 MODULE_DESCRIPTION("Intel Core temperature monitor");
 431 MODULE_LICENSE("GPL");
 432
 433 module_init(coretemp_init)
 434 module_exit(coretemp_exit)