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 class_device *class_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 static struct coretemp_data *coretemp_update_device(struct device *dev);
  62
  63 /*
  64  * Sysfs stuff
  65  */
  66
  67 static ssize_t show_name(struct device *dev, struct device_attribute
  68                           *devattr, char *buf)
  69 {
  70         int ret;
  71         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  72         struct coretemp_data *data = dev_get_drvdata(dev);
  73
  74         if (attr->index == SHOW_NAME)
  75                 ret = sprintf(buf, "%s\n", data->name);
  76         else    /* show label */
  77                 ret = sprintf(buf, "Core %d\n", data->id);
  78         return ret;
  79 }
  80
  81 static ssize_t show_alarm(struct device *dev, struct device_attribute
  82                           *devattr, char *buf)
  83 {
  84         struct coretemp_data *data = coretemp_update_device(dev);
  85         /* read the Out-of-spec log, never clear */
  86         return sprintf(buf, "%d\n", data->alarm);
  87 }
  88
  89 static ssize_t show_temp(struct device *dev,
  90                          struct device_attribute *devattr, char *buf)
  91 {
  92         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  93         struct coretemp_data *data = coretemp_update_device(dev);
  94         int err;
  95
  96         if (attr->index == SHOW_TEMP)
  97                 err = data->valid ? sprintf(buf, "%d\n", data->temp) : -EAGAIN;
  98         else
  99                 err = sprintf(buf, "%d\n", data->tjmax);
 100
 101         return err;
 102 }
 103
 104 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
 105                           SHOW_TEMP);
 106 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL,
 107                           SHOW_TJMAX);
 108 static DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL);
 109 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
 110 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
 111
 112 static struct attribute *coretemp_attributes[] = {
 113         &sensor_dev_attr_name.dev_attr.attr,
 114         &sensor_dev_attr_temp1_label.dev_attr.attr,
 115         &dev_attr_temp1_crit_alarm.attr,
 116         &sensor_dev_attr_temp1_input.dev_attr.attr,
 117         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 118         NULL
 119 };
 120
 121 static const struct attribute_group coretemp_group = {
 122         .attrs = coretemp_attributes,
 123 };
 124
 125 static struct coretemp_data *coretemp_update_device(struct device *dev)
 126 {
 127         struct coretemp_data *data = dev_get_drvdata(dev);
 128
 129         mutex_lock(&data->update_lock);
 130
 131         if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
 132                 u32 eax, edx;
 133
 134                 data->valid = 0;
 135                 rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
 136                 data->alarm = (eax >> 5) & 1;
 137                 /* update only if data has been valid */
 138                 if (eax & 0x80000000) {
 139                         data->temp = data->tjmax - (((eax >> 16)
 140                                                         & 0x7f) * 1000);
 141                         data->valid = 1;
 142                 } else {
 143                         dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax);
 144                 }
 145                 data->last_updated = jiffies;
 146         }
 147
 148         mutex_unlock(&data->update_lock);
 149         return data;
 150 }
 151
 152 static int __devinit coretemp_probe(struct platform_device *pdev)
 153 {
 154         struct coretemp_data *data;
 155         struct cpuinfo_x86 *c = &(cpu_data)[pdev->id];
 156         int err;
 157         u32 eax, edx;
 158
 159         if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
 160                 err = -ENOMEM;
 161                 dev_err(&pdev->dev, "Out of memory\n");
 162                 goto exit;
 163         }
 164
 165         data->id = pdev->id;
 166         data->name = "coretemp";
 167         mutex_init(&data->update_lock);
 168         /* Tjmax default is 100 degrees C */
 169         data->tjmax = 100000;
 170
 171         /* test if we can access the THERM_STATUS MSR */
 172         err = rdmsr_safe_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
 173         if (err) {
 174                 dev_err(&pdev->dev,
 175                         "Unable to access THERM_STATUS MSR, giving up\n");
 176                 goto exit_free;
 177         }
 178
 179         /* Check if we have problem with errata AE18 of Core processors:
 180            Readings might stop update when processor visited too deep sleep,
 181            fixed for stepping D0 (6EC).
 182         */
 183
 184         if ((c->x86_model == 0xe) && (c->x86_mask < 0xc)) {
 185                 /* check for microcode update */
 186                 rdmsr_on_cpu(data->id, MSR_IA32_UCODE_REV, &eax, &edx);
 187                 if (edx < 0x39) {
 188                         dev_err(&pdev->dev,
 189                                 "Errata AE18 not fixed, update BIOS or "
 190                                 "microcode of the CPU!\n");
 191                         goto exit_free;
 192                 }
 193         }
 194
 195         /* Some processors have Tjmax 85 following magic should detect it
 196            Intel won't disclose the information without signed NDA, but
 197            individuals cannot sign it. Catch(ed) 22.
 198         */
 199
 200         if (((c->x86_model == 0xf) && (c->x86_mask > 3)) ||
 201                 (c->x86_model == 0xe))  {
 202                 err = rdmsr_safe_on_cpu(data->id, 0xee, &eax, &edx);
 203                 if (err) {
 204                         dev_warn(&pdev->dev,
 205                                  "Unable to access MSR 0xEE, Tjmax left at %d "
 206                                  "degrees C\n", data->tjmax/1000);
 207                 } else if (eax & 0x40000000) {
 208                         data->tjmax = 85000;
 209                 }
 210         }
 211
 212         /* Intel says that above should not work for desktop Core2 processors,
 213            but it seems to work. There is no other way how get the absolute
 214            readings. Warn the user about this. First check if are desktop,
 215            bit 50 of MSR_IA32_PLATFORM_ID should be 0.
 216         */
 217
 218         rdmsr_safe_on_cpu(data->id, MSR_IA32_PLATFORM_ID, &eax, &edx);
 219
 220         if ((c->x86_model == 0xf) && (!(edx & 0x00040000))) {
 221                 dev_warn(&pdev->dev, "Using undocumented features, absolute "
 222                          "temperature might be wrong!\n");
 223         }
 224
 225         platform_set_drvdata(pdev, data);
 226
 227         if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
 228                 goto exit_free;
 229
 230         data->class_dev = hwmon_device_register(&pdev->dev);
 231         if (IS_ERR(data->class_dev)) {
 232                 err = PTR_ERR(data->class_dev);
 233                 dev_err(&pdev->dev, "Class registration failed (%d)\n",
 234                         err);
 235                 goto exit_class;
 236         }
 237
 238         return 0;
 239
 240 exit_class:
 241         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 242 exit_free:
 243         kfree(data);
 244 exit:
 245         return err;
 246 }
 247
 248 static int __devexit coretemp_remove(struct platform_device *pdev)
 249 {
 250         struct coretemp_data *data = platform_get_drvdata(pdev);
 251
 252         hwmon_device_unregister(data->class_dev);
 253         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 254         platform_set_drvdata(pdev, NULL);
 255         kfree(data);
 256         return 0;
 257 }
 258
 259 static struct platform_driver coretemp_driver = {
 260         .driver = {
 261                 .owner = THIS_MODULE,
 262                 .name = DRVNAME,
 263         },
 264         .probe = coretemp_probe,
 265         .remove = __devexit_p(coretemp_remove),
 266 };
 267
 268 struct pdev_entry {
 269         struct list_head list;
 270         struct platform_device *pdev;
 271         unsigned int cpu;
 272 };
 273
 274 static LIST_HEAD(pdev_list);
 275 static DEFINE_MUTEX(pdev_list_mutex);
 276
 277 static int __cpuinit coretemp_device_add(unsigned int cpu)
 278 {
 279         int err;
 280         struct platform_device *pdev;
 281         struct pdev_entry *pdev_entry;
 282
 283         pdev = platform_device_alloc(DRVNAME, cpu);
 284         if (!pdev) {
 285                 err = -ENOMEM;
 286                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
 287                 goto exit;
 288         }
 289
 290         pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
 291         if (!pdev_entry) {
 292                 err = -ENOMEM;
 293                 goto exit_device_put;
 294         }
 295
 296         err = platform_device_add(pdev);
 297         if (err) {
 298                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
 299                        err);
 300                 goto exit_device_free;
 301         }
 302
 303         pdev_entry->pdev = pdev;
 304         pdev_entry->cpu = cpu;
 305         mutex_lock(&pdev_list_mutex);
 306         list_add_tail(&pdev_entry->list, &pdev_list);
 307         mutex_unlock(&pdev_list_mutex);
 308
 309         return 0;
 310
 311 exit_device_free:
 312         kfree(pdev_entry);
 313 exit_device_put:
 314         platform_device_put(pdev);
 315 exit:
 316         return err;
 317 }
 318
 319 #ifdef CONFIG_HOTPLUG_CPU
 320 void coretemp_device_remove(unsigned int cpu)
 321 {
 322         struct pdev_entry *p, *n;
 323         mutex_lock(&pdev_list_mutex);
 324         list_for_each_entry_safe(p, n, &pdev_list, list) {
 325                 if (p->cpu == cpu) {
 326                         platform_device_unregister(p->pdev);
 327                         list_del(&p->list);
 328                         kfree(p);
 329                 }
 330         }
 331         mutex_unlock(&pdev_list_mutex);
 332 }
 333
 334 static int coretemp_cpu_callback(struct notifier_block *nfb,
 335                                  unsigned long action, void *hcpu)
 336 {
 337         unsigned int cpu = (unsigned long) hcpu;
 338
 339         switch (action) {
 340         case CPU_ONLINE:
 341         case CPU_ONLINE_FROZEN:
 342                 coretemp_device_add(cpu);
 343                 break;
 344         case CPU_DEAD:
 345         case CPU_DEAD_FROZEN:
 346                 coretemp_device_remove(cpu);
 347                 break;
 348         }
 349         return NOTIFY_OK;
 350 }
 351
 352 static struct notifier_block __cpuinitdata coretemp_cpu_notifier = {
 353         .notifier_call = coretemp_cpu_callback,
 354 };
 355 #endif                          /* !CONFIG_HOTPLUG_CPU */
 356
 357 static int __init coretemp_init(void)
 358 {
 359         int i, err = -ENODEV;
 360         struct pdev_entry *p, *n;
 361
 362         /* quick check if we run Intel */
 363         if (cpu_data[0].x86_vendor != X86_VENDOR_INTEL)
 364                 goto exit;
 365
 366         err = platform_driver_register(&coretemp_driver);
 367         if (err)
 368                 goto exit;
 369
 370         for_each_online_cpu(i) {
 371                 struct cpuinfo_x86 *c = &(cpu_data)[i];
 372
 373                 /* check if family 6, models e, f */
 374                 if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
 375                     !((c->x86_model == 0xe) || (c->x86_model == 0xf))) {
 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)