linux/drivers/hwmon/via-cputemp.c
<<
>>
Prefs
   1/*
   2 * via-cputemp.c - Driver for VIA CPU core temperature monitoring
   3 * Copyright (C) 2009 VIA Technologies, Inc.
   4 *
   5 * based on existing coretemp.c, which is
   6 *
   7 * Copyright (C) 2007 Rudolf Marek <r.marek@assembler.cz>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; version 2 of the License.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 * 02110-1301 USA.
  22 */
  23
  24#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26#include <linux/module.h>
  27#include <linux/init.h>
  28#include <linux/slab.h>
  29#include <linux/hwmon.h>
  30#include <linux/hwmon-vid.h>
  31#include <linux/sysfs.h>
  32#include <linux/hwmon-sysfs.h>
  33#include <linux/err.h>
  34#include <linux/mutex.h>
  35#include <linux/list.h>
  36#include <linux/platform_device.h>
  37#include <linux/cpu.h>
  38#include <asm/msr.h>
  39#include <asm/processor.h>
  40#include <asm/cpu_device_id.h>
  41
  42#define DRVNAME "via_cputemp"
  43
  44enum { SHOW_TEMP, SHOW_LABEL, SHOW_NAME };
  45
  46/*
  47 * Functions declaration
  48 */
  49
  50struct via_cputemp_data {
  51        struct device *hwmon_dev;
  52        const char *name;
  53        u8 vrm;
  54        u32 id;
  55        u32 msr_temp;
  56        u32 msr_vid;
  57};
  58
  59/*
  60 * Sysfs stuff
  61 */
  62
  63static ssize_t show_name(struct device *dev, struct device_attribute
  64                          *devattr, char *buf)
  65{
  66        int ret;
  67        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  68        struct via_cputemp_data *data = dev_get_drvdata(dev);
  69
  70        if (attr->index == SHOW_NAME)
  71                ret = sprintf(buf, "%s\n", data->name);
  72        else    /* show label */
  73                ret = sprintf(buf, "Core %d\n", data->id);
  74        return ret;
  75}
  76
  77static ssize_t show_temp(struct device *dev,
  78                         struct device_attribute *devattr, char *buf)
  79{
  80        struct via_cputemp_data *data = dev_get_drvdata(dev);
  81        u32 eax, edx;
  82        int err;
  83
  84        err = rdmsr_safe_on_cpu(data->id, data->msr_temp, &eax, &edx);
  85        if (err)
  86                return -EAGAIN;
  87
  88        return sprintf(buf, "%lu\n", ((unsigned long)eax & 0xffffff) * 1000);
  89}
  90
  91static ssize_t show_cpu_vid(struct device *dev,
  92                            struct device_attribute *devattr, char *buf)
  93{
  94        struct via_cputemp_data *data = dev_get_drvdata(dev);
  95        u32 eax, edx;
  96        int err;
  97
  98        err = rdmsr_safe_on_cpu(data->id, data->msr_vid, &eax, &edx);
  99        if (err)
 100                return -EAGAIN;
 101
 102        return sprintf(buf, "%d\n", vid_from_reg(~edx & 0x7f, data->vrm));
 103}
 104
 105static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
 106                          SHOW_TEMP);
 107static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
 108static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
 109
 110static struct attribute *via_cputemp_attributes[] = {
 111        &sensor_dev_attr_name.dev_attr.attr,
 112        &sensor_dev_attr_temp1_label.dev_attr.attr,
 113        &sensor_dev_attr_temp1_input.dev_attr.attr,
 114        NULL
 115};
 116
 117static const struct attribute_group via_cputemp_group = {
 118        .attrs = via_cputemp_attributes,
 119};
 120
 121/* Optional attributes */
 122static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_cpu_vid, NULL);
 123
 124static int __devinit via_cputemp_probe(struct platform_device *pdev)
 125{
 126        struct via_cputemp_data *data;
 127        struct cpuinfo_x86 *c = &cpu_data(pdev->id);
 128        int err;
 129        u32 eax, edx;
 130
 131        data = kzalloc(sizeof(struct via_cputemp_data), GFP_KERNEL);
 132        if (!data) {
 133                err = -ENOMEM;
 134                dev_err(&pdev->dev, "Out of memory\n");
 135                goto exit;
 136        }
 137
 138        data->id = pdev->id;
 139        data->name = "via_cputemp";
 140
 141        switch (c->x86_model) {
 142        case 0xA:
 143                /* C7 A */
 144        case 0xD:
 145                /* C7 D */
 146                data->msr_temp = 0x1169;
 147                data->msr_vid = 0x198;
 148                break;
 149        case 0xF:
 150                /* Nano */
 151                data->msr_temp = 0x1423;
 152                break;
 153        default:
 154                err = -ENODEV;
 155                goto exit_free;
 156        }
 157
 158        /* test if we can access the TEMPERATURE MSR */
 159        err = rdmsr_safe_on_cpu(data->id, data->msr_temp, &eax, &edx);
 160        if (err) {
 161                dev_err(&pdev->dev,
 162                        "Unable to access TEMPERATURE MSR, giving up\n");
 163                goto exit_free;
 164        }
 165
 166        platform_set_drvdata(pdev, data);
 167
 168        err = sysfs_create_group(&pdev->dev.kobj, &via_cputemp_group);
 169        if (err)
 170                goto exit_free;
 171
 172        if (data->msr_vid)
 173                data->vrm = vid_which_vrm();
 174
 175        if (data->vrm) {
 176                err = device_create_file(&pdev->dev, &dev_attr_cpu0_vid);
 177                if (err)
 178                        goto exit_remove;
 179        }
 180
 181        data->hwmon_dev = hwmon_device_register(&pdev->dev);
 182        if (IS_ERR(data->hwmon_dev)) {
 183                err = PTR_ERR(data->hwmon_dev);
 184                dev_err(&pdev->dev, "Class registration failed (%d)\n",
 185                        err);
 186                goto exit_remove;
 187        }
 188
 189        return 0;
 190
 191exit_remove:
 192        if (data->vrm)
 193                device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 194        sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 195exit_free:
 196        platform_set_drvdata(pdev, NULL);
 197        kfree(data);
 198exit:
 199        return err;
 200}
 201
 202static int __devexit via_cputemp_remove(struct platform_device *pdev)
 203{
 204        struct via_cputemp_data *data = platform_get_drvdata(pdev);
 205
 206        hwmon_device_unregister(data->hwmon_dev);
 207        if (data->vrm)
 208                device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 209        sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 210        platform_set_drvdata(pdev, NULL);
 211        kfree(data);
 212        return 0;
 213}
 214
 215static struct platform_driver via_cputemp_driver = {
 216        .driver = {
 217                .owner = THIS_MODULE,
 218                .name = DRVNAME,
 219        },
 220        .probe = via_cputemp_probe,
 221        .remove = __devexit_p(via_cputemp_remove),
 222};
 223
 224struct pdev_entry {
 225        struct list_head list;
 226        struct platform_device *pdev;
 227        unsigned int cpu;
 228};
 229
 230static LIST_HEAD(pdev_list);
 231static DEFINE_MUTEX(pdev_list_mutex);
 232
 233static int __cpuinit via_cputemp_device_add(unsigned int cpu)
 234{
 235        int err;
 236        struct platform_device *pdev;
 237        struct pdev_entry *pdev_entry;
 238
 239        pdev = platform_device_alloc(DRVNAME, cpu);
 240        if (!pdev) {
 241                err = -ENOMEM;
 242                pr_err("Device allocation failed\n");
 243                goto exit;
 244        }
 245
 246        pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
 247        if (!pdev_entry) {
 248                err = -ENOMEM;
 249                goto exit_device_put;
 250        }
 251
 252        err = platform_device_add(pdev);
 253        if (err) {
 254                pr_err("Device addition failed (%d)\n", err);
 255                goto exit_device_free;
 256        }
 257
 258        pdev_entry->pdev = pdev;
 259        pdev_entry->cpu = cpu;
 260        mutex_lock(&pdev_list_mutex);
 261        list_add_tail(&pdev_entry->list, &pdev_list);
 262        mutex_unlock(&pdev_list_mutex);
 263
 264        return 0;
 265
 266exit_device_free:
 267        kfree(pdev_entry);
 268exit_device_put:
 269        platform_device_put(pdev);
 270exit:
 271        return err;
 272}
 273
 274static void __cpuinit via_cputemp_device_remove(unsigned int cpu)
 275{
 276        struct pdev_entry *p;
 277
 278        mutex_lock(&pdev_list_mutex);
 279        list_for_each_entry(p, &pdev_list, list) {
 280                if (p->cpu == cpu) {
 281                        platform_device_unregister(p->pdev);
 282                        list_del(&p->list);
 283                        mutex_unlock(&pdev_list_mutex);
 284                        kfree(p);
 285                        return;
 286                }
 287        }
 288        mutex_unlock(&pdev_list_mutex);
 289}
 290
 291static int __cpuinit via_cputemp_cpu_callback(struct notifier_block *nfb,
 292                                 unsigned long action, void *hcpu)
 293{
 294        unsigned int cpu = (unsigned long) hcpu;
 295
 296        switch (action) {
 297        case CPU_ONLINE:
 298        case CPU_DOWN_FAILED:
 299                via_cputemp_device_add(cpu);
 300                break;
 301        case CPU_DOWN_PREPARE:
 302                via_cputemp_device_remove(cpu);
 303                break;
 304        }
 305        return NOTIFY_OK;
 306}
 307
 308static struct notifier_block via_cputemp_cpu_notifier __refdata = {
 309        .notifier_call = via_cputemp_cpu_callback,
 310};
 311
 312static const struct x86_cpu_id __initconst cputemp_ids[] = {
 313        { X86_VENDOR_CENTAUR, 6, 0xa, }, /* C7 A */
 314        { X86_VENDOR_CENTAUR, 6, 0xd, }, /* C7 D */
 315        { X86_VENDOR_CENTAUR, 6, 0xf, }, /* Nano */
 316        {}
 317};
 318MODULE_DEVICE_TABLE(x86cpu, cputemp_ids);
 319
 320static int __init via_cputemp_init(void)
 321{
 322        int i, err;
 323
 324        if (!x86_match_cpu(cputemp_ids))
 325                return -ENODEV;
 326
 327        err = platform_driver_register(&via_cputemp_driver);
 328        if (err)
 329                goto exit;
 330
 331        get_online_cpus();
 332        for_each_online_cpu(i) {
 333                struct cpuinfo_x86 *c = &cpu_data(i);
 334
 335                if (c->x86 != 6)
 336                        continue;
 337
 338                if (c->x86_model < 0x0a)
 339                        continue;
 340
 341                if (c->x86_model > 0x0f) {
 342                        pr_warn("Unknown CPU model 0x%x\n", c->x86_model);
 343                        continue;
 344                }
 345
 346                via_cputemp_device_add(i);
 347        }
 348
 349#ifndef CONFIG_HOTPLUG_CPU
 350        if (list_empty(&pdev_list)) {
 351                put_online_cpus();
 352                err = -ENODEV;
 353                goto exit_driver_unreg;
 354        }
 355#endif
 356
 357        register_hotcpu_notifier(&via_cputemp_cpu_notifier);
 358        put_online_cpus();
 359        return 0;
 360
 361#ifndef CONFIG_HOTPLUG_CPU
 362exit_driver_unreg:
 363        platform_driver_unregister(&via_cputemp_driver);
 364#endif
 365exit:
 366        return err;
 367}
 368
 369static void __exit via_cputemp_exit(void)
 370{
 371        struct pdev_entry *p, *n;
 372
 373        get_online_cpus();
 374        unregister_hotcpu_notifier(&via_cputemp_cpu_notifier);
 375        mutex_lock(&pdev_list_mutex);
 376        list_for_each_entry_safe(p, n, &pdev_list, list) {
 377                platform_device_unregister(p->pdev);
 378                list_del(&p->list);
 379                kfree(p);
 380        }
 381        mutex_unlock(&pdev_list_mutex);
 382        put_online_cpus();
 383        platform_driver_unregister(&via_cputemp_driver);
 384}
 385
 386MODULE_AUTHOR("Harald Welte <HaraldWelte@viatech.com>");
 387MODULE_DESCRIPTION("VIA CPU temperature monitor");
 388MODULE_LICENSE("GPL");
 389
 390module_init(via_cputemp_init)
 391module_exit(via_cputemp_exit)
 392
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.