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 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 = devm_kzalloc(&pdev->dev, sizeof(struct via_cputemp_data),
 132                            GFP_KERNEL);
 133        if (!data)
 134                return -ENOMEM;
 135
 136        data->id = pdev->id;
 137        data->name = "via_cputemp";
 138
 139        switch (c->x86_model) {
 140        case 0xA:
 141                /* C7 A */
 142        case 0xD:
 143                /* C7 D */
 144                data->msr_temp = 0x1169;
 145                data->msr_vid = 0x198;
 146                break;
 147        case 0xF:
 148                /* Nano */
 149                data->msr_temp = 0x1423;
 150                break;
 151        default:
 152                return -ENODEV;
 153        }
 154
 155        /* test if we can access the TEMPERATURE MSR */
 156        err = rdmsr_safe_on_cpu(data->id, data->msr_temp, &eax, &edx);
 157        if (err) {
 158                dev_err(&pdev->dev,
 159                        "Unable to access TEMPERATURE MSR, giving up\n");
 160                return err;
 161        }
 162
 163        platform_set_drvdata(pdev, data);
 164
 165        err = sysfs_create_group(&pdev->dev.kobj, &via_cputemp_group);
 166        if (err)
 167                return err;
 168
 169        if (data->msr_vid)
 170                data->vrm = vid_which_vrm();
 171
 172        if (data->vrm) {
 173                err = device_create_file(&pdev->dev, &dev_attr_cpu0_vid);
 174                if (err)
 175                        goto exit_remove;
 176        }
 177
 178        data->hwmon_dev = hwmon_device_register(&pdev->dev);
 179        if (IS_ERR(data->hwmon_dev)) {
 180                err = PTR_ERR(data->hwmon_dev);
 181                dev_err(&pdev->dev, "Class registration failed (%d)\n",
 182                        err);
 183                goto exit_remove;
 184        }
 185
 186        return 0;
 187
 188exit_remove:
 189        if (data->vrm)
 190                device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 191        sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 192        return err;
 193}
 194
 195static int via_cputemp_remove(struct platform_device *pdev)
 196{
 197        struct via_cputemp_data *data = platform_get_drvdata(pdev);
 198
 199        hwmon_device_unregister(data->hwmon_dev);
 200        if (data->vrm)
 201                device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 202        sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 203        return 0;
 204}
 205
 206static struct platform_driver via_cputemp_driver = {
 207        .driver = {
 208                .owner = THIS_MODULE,
 209                .name = DRVNAME,
 210        },
 211        .probe = via_cputemp_probe,
 212        .remove = via_cputemp_remove,
 213};
 214
 215struct pdev_entry {
 216        struct list_head list;
 217        struct platform_device *pdev;
 218        unsigned int cpu;
 219};
 220
 221static LIST_HEAD(pdev_list);
 222static DEFINE_MUTEX(pdev_list_mutex);
 223
 224static int via_cputemp_device_add(unsigned int cpu)
 225{
 226        int err;
 227        struct platform_device *pdev;
 228        struct pdev_entry *pdev_entry;
 229
 230        pdev = platform_device_alloc(DRVNAME, cpu);
 231        if (!pdev) {
 232                err = -ENOMEM;
 233                pr_err("Device allocation failed\n");
 234                goto exit;
 235        }
 236
 237        pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
 238        if (!pdev_entry) {
 239                err = -ENOMEM;
 240                goto exit_device_put;
 241        }
 242
 243        err = platform_device_add(pdev);
 244        if (err) {
 245                pr_err("Device addition failed (%d)\n", err);
 246                goto exit_device_free;
 247        }
 248
 249        pdev_entry->pdev = pdev;
 250        pdev_entry->cpu = cpu;
 251        mutex_lock(&pdev_list_mutex);
 252        list_add_tail(&pdev_entry->list, &pdev_list);
 253        mutex_unlock(&pdev_list_mutex);
 254
 255        return 0;
 256
 257exit_device_free:
 258        kfree(pdev_entry);
 259exit_device_put:
 260        platform_device_put(pdev);
 261exit:
 262        return err;
 263}
 264
 265static void via_cputemp_device_remove(unsigned int cpu)
 266{
 267        struct pdev_entry *p;
 268
 269        mutex_lock(&pdev_list_mutex);
 270        list_for_each_entry(p, &pdev_list, list) {
 271                if (p->cpu == cpu) {
 272                        platform_device_unregister(p->pdev);
 273                        list_del(&p->list);
 274                        mutex_unlock(&pdev_list_mutex);
 275                        kfree(p);
 276                        return;
 277                }
 278        }
 279        mutex_unlock(&pdev_list_mutex);
 280}
 281
 282static int via_cputemp_cpu_callback(struct notifier_block *nfb,
 283                                    unsigned long action, void *hcpu)
 284{
 285        unsigned int cpu = (unsigned long) hcpu;
 286
 287        switch (action) {
 288        case CPU_ONLINE:
 289        case CPU_DOWN_FAILED:
 290                via_cputemp_device_add(cpu);
 291                break;
 292        case CPU_DOWN_PREPARE:
 293                via_cputemp_device_remove(cpu);
 294                break;
 295        }
 296        return NOTIFY_OK;
 297}
 298
 299static struct notifier_block via_cputemp_cpu_notifier __refdata = {
 300        .notifier_call = via_cputemp_cpu_callback,
 301};
 302
 303static const struct x86_cpu_id __initconst cputemp_ids[] = {
 304        { X86_VENDOR_CENTAUR, 6, 0xa, }, /* C7 A */
 305        { X86_VENDOR_CENTAUR, 6, 0xd, }, /* C7 D */
 306        { X86_VENDOR_CENTAUR, 6, 0xf, }, /* Nano */
 307        {}
 308};
 309MODULE_DEVICE_TABLE(x86cpu, cputemp_ids);
 310
 311static int __init via_cputemp_init(void)
 312{
 313        int i, err;
 314
 315        if (!x86_match_cpu(cputemp_ids))
 316                return -ENODEV;
 317
 318        err = platform_driver_register(&via_cputemp_driver);
 319        if (err)
 320                goto exit;
 321
 322        get_online_cpus();
 323        for_each_online_cpu(i) {
 324                struct cpuinfo_x86 *c = &cpu_data(i);
 325
 326                if (c->x86 != 6)
 327                        continue;
 328
 329                if (c->x86_model < 0x0a)
 330                        continue;
 331
 332                if (c->x86_model > 0x0f) {
 333                        pr_warn("Unknown CPU model 0x%x\n", c->x86_model);
 334                        continue;
 335                }
 336
 337                via_cputemp_device_add(i);
 338        }
 339
 340#ifndef CONFIG_HOTPLUG_CPU
 341        if (list_empty(&pdev_list)) {
 342                put_online_cpus();
 343                err = -ENODEV;
 344                goto exit_driver_unreg;
 345        }
 346#endif
 347
 348        register_hotcpu_notifier(&via_cputemp_cpu_notifier);
 349        put_online_cpus();
 350        return 0;
 351
 352#ifndef CONFIG_HOTPLUG_CPU
 353exit_driver_unreg:
 354        platform_driver_unregister(&via_cputemp_driver);
 355#endif
 356exit:
 357        return err;
 358}
 359
 360static void __exit via_cputemp_exit(void)
 361{
 362        struct pdev_entry *p, *n;
 363
 364        get_online_cpus();
 365        unregister_hotcpu_notifier(&via_cputemp_cpu_notifier);
 366        mutex_lock(&pdev_list_mutex);
 367        list_for_each_entry_safe(p, n, &pdev_list, list) {
 368                platform_device_unregister(p->pdev);
 369                list_del(&p->list);
 370                kfree(p);
 371        }
 372        mutex_unlock(&pdev_list_mutex);
 373        put_online_cpus();
 374        platform_driver_unregister(&via_cputemp_driver);
 375}
 376
 377MODULE_AUTHOR("Harald Welte <HaraldWelte@viatech.com>");
 378MODULE_DESCRIPTION("VIA CPU temperature monitor");
 379MODULE_LICENSE("GPL");
 380
 381module_init(via_cputemp_init)
 382module_exit(via_cputemp_exit)
 383
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.