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                         err = -ENODEV;
 189                         dev_err(&pdev->dev,
 190                                 "Errata AE18 not fixed, update BIOS or "
 191                                 "microcode of the CPU!\n");
 192                         goto exit_free;
 193                 }
 194         }
 195
 196         /* Some processors have Tjmax 85 following magic should detect it
 197            Intel won't disclose the information without signed NDA, but
 198            individuals cannot sign it. Catch(ed) 22.
 199         */
 200
 201         if (((c->x86_model == 0xf) && (c->x86_mask > 3)) ||
 202                 (c->x86_model == 0xe))  {
 203                 err = rdmsr_safe_on_cpu(data->id, 0xee, &eax, &edx);
 204                 if (err) {
 205                         dev_warn(&pdev->dev,
 206                                  "Unable to access MSR 0xEE, Tjmax left at %d "
 207                                  "degrees C\n", data->tjmax/1000);
 208                 } else if (eax & 0x40000000) {
 209                         data->tjmax = 85000;
 210                 }
 211         }
 212
 213         /* Intel says that above should not work for desktop Core2 processors,
 214            but it seems to work. There is no other way how get the absolute
 215            readings. Warn the user about this. First check if are desktop,
 216            bit 50 of MSR_IA32_PLATFORM_ID should be 0.
 217         */
 218
 219         rdmsr_safe_on_cpu(data->id, MSR_IA32_PLATFORM_ID, &eax, &edx);
 220
 221         if ((c->x86_model == 0xf) && (!(edx & 0x00040000))) {
 222                 dev_warn(&pdev->dev, "Using undocumented features, absolute "
 223                          "temperature might be wrong!\n");
 224         }
 225
 226         platform_set_drvdata(pdev, data);
 227
 228         if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
 229                 goto exit_free;
 230
 231         data->class_dev = hwmon_device_register(&pdev->dev);
 232         if (IS_ERR(data->class_dev)) {
 233                 err = PTR_ERR(data->class_dev);
 234                 dev_err(&pdev->dev, "Class registration failed (%d)\n",
 235                         err);
 236                 goto exit_class;
 237         }
 238
 239         return 0;
 240
 241 exit_class:
 242         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 243 exit_free:
 244         kfree(data);
 245 exit:
 246         return err;
 247 }
 248
 249 static int __devexit coretemp_remove(struct platform_device *pdev)
 250 {
 251         struct coretemp_data *data = platform_get_drvdata(pdev);
 252
 253         hwmon_device_unregister(data->class_dev);
 254         sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
 255         platform_set_drvdata(pdev, NULL);
 256         kfree(data);
 257         return 0;
 258 }
 259
 260 static struct platform_driver coretemp_driver = {
 261         .driver = {
 262                 .owner = THIS_MODULE,
 263                 .name = DRVNAME,
 264         },
 265         .probe = coretemp_probe,
 266         .remove = __devexit_p(coretemp_remove),
 267 };
 268
 269 struct pdev_entry {
 270         struct list_head list;
 271         struct platform_device *pdev;
 272         unsigned int cpu;
 273 };
 274
 275 static LIST_HEAD(pdev_list);
 276 static DEFINE_MUTEX(pdev_list_mutex);
 277
 278 static int __cpuinit coretemp_device_add(unsigned int cpu)
 279 {
 280         int err;
 281         struct platform_device *pdev;
 282         struct pdev_entry *pdev_entry;
 283
 284         pdev = platform_device_alloc(DRVNAME, cpu);
 285         if (!pdev) {
 286                 err = -ENOMEM;
 287                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
 288                 goto exit;
 289         }
 290
 291         pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
 292         if (!pdev_entry) {
 293                 err = -ENOMEM;
 294                 goto exit_device_put;
 295         }
 296
 297         err = platform_device_add(pdev);
 298         if (err) {
 299                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
 300                        err);
 301                 goto exit_device_free;
 302         }
 303
 304         pdev_entry->pdev = pdev;
 305         pdev_entry->cpu = cpu;
 306         mutex_lock(&pdev_list_mutex);
 307         list_add_tail(&pdev_entry->list, &pdev_list);
 308         mutex_unlock(&pdev_list_mutex);
 309
 310         return 0;
 311
 312 exit_device_free:
 313         kfree(pdev_entry);
 314 exit_device_put:
 315         platform_device_put(pdev);
 316 exit:
 317         return err;
 318 }
 319
 320 #ifdef CONFIG_HOTPLUG_CPU
 321 void coretemp_device_remove(unsigned int cpu)
 322 {
 323         struct pdev_entry *p, *n;
 324         mutex_lock(&pdev_list_mutex);
 325         list_for_each_entry_safe(p, n, &pdev_list, list) {
 326                 if (p->cpu == cpu) {
 327                         platform_device_unregister(p->pdev);
 328                         list_del(&p->list);
 329                         kfree(p);
 330                 }
 331         }
 332         mutex_unlock(&pdev_list_mutex);
 333 }
 334
 335 static int coretemp_cpu_callback(struct notifier_block *nfb,
 336                                  unsigned long action, void *hcpu)
 337 {
 338         unsigned int cpu = (unsigned long) hcpu;
 339
 340         switch (action) {
 341         case CPU_ONLINE:
 342         case CPU_ONLINE_FROZEN:
 343                 coretemp_device_add(cpu);
 344                 break;
 345         case CPU_DEAD:
 346         case CPU_DEAD_FROZEN:
 347                 coretemp_device_remove(cpu);
 348                 break;
 349         }
 350         return NOTIFY_OK;
 351 }
 352
 353 static struct notifier_block __cpuinitdata coretemp_cpu_notifier = {
 354         .notifier_call = coretemp_cpu_callback,
 355 };
 356 #endif                          /* !CONFIG_HOTPLUG_CPU */
 357
 358 static int __init coretemp_init(void)
 359 {
 360         int i, err = -ENODEV;
 361         struct pdev_entry *p, *n;
 362
 363         /* quick check if we run Intel */
 364         if (cpu_data[0].x86_vendor != X86_VENDOR_INTEL)
 365                 goto exit;
 366
 367         err = platform_driver_register(&coretemp_driver);
 368         if (err)
 369                 goto exit;
 370
 371         for_each_online_cpu(i) {
 372                 struct cpuinfo_x86 *c = &(cpu_data)[i];
 373
 374                 /* check if family 6, models e, f */
 375                 if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
 376                     !((c->x86_model == 0xe) || (c->x86_model == 0xf))) {
 377
 378                         /* supported CPU not found, but report the unknown
 379                            family 6 CPU */
 380                         if ((c->x86 == 0x6) && (c->x86_model > 0xf))
 381                                 printk(KERN_WARNING DRVNAME ": Unknown CPU "
 382                                         "model %x\n", c->x86_model);
 383                         continue;
 384                 }
 385
 386                 err = coretemp_device_add(i);
 387                 if (err)
 388                         goto exit_devices_unreg;
 389         }
 390         if (list_empty(&pdev_list)) {
 391                 err = -ENODEV;
 392                 goto exit_driver_unreg;
 393         }
 394
 395 #ifdef CONFIG_HOTPLUG_CPU
 396         register_hotcpu_notifier(&coretemp_cpu_notifier);
 397 #endif
 398         return 0;
 399
 400 exit_devices_unreg:
 401         mutex_lock(&pdev_list_mutex);
 402         list_for_each_entry_safe(p, n, &pdev_list, list) {
 403                 platform_device_unregister(p->pdev);
 404                 list_del(&p->list);
 405                 kfree(p);
 406         }
 407         mutex_unlock(&pdev_list_mutex);
 408 exit_driver_unreg:
 409         platform_driver_unregister(&coretemp_driver);
 410 exit:
 411         return err;
 412 }
 413
 414 static void __exit coretemp_exit(void)
 415 {
 416         struct pdev_entry *p, *n;
 417 #ifdef CONFIG_HOTPLUG_CPU
 418         unregister_hotcpu_notifier(&coretemp_cpu_notifier);
 419 #endif
 420         mutex_lock(&pdev_list_mutex);
 421         list_for_each_entry_safe(p, n, &pdev_list, list) {
 422                 platform_device_unregister(p->pdev);
 423                 list_del(&p->list);
 424                 kfree(p);
 425         }
 426         mutex_unlock(&pdev_list_mutex);
 427         platform_driver_unregister(&coretemp_driver);
 428 }
 429
 430 MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");
 431 MODULE_DESCRIPTION("Intel Core temperature monitor");
 432 MODULE_LICENSE("GPL");
 433
 434 module_init(coretemp_init)
 435 module_exit(coretemp_exit)