drivers/hwmon/via-cputemp-xen.c

   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/cpu_device_id.h>
  40 #include <xen/pcpu.h>
  41 #include "../xen/core/domctl.h"
  42
  43 #define DRVNAME "via_cputemp"
  44
  45 enum { SHOW_TEMP, SHOW_LABEL, SHOW_NAME };
  46
  47 /*
  48  * Functions declaration
  49  */
  50
  51 struct pdev_entry {
  52         struct list_head list;
  53         struct platform_device *pdev;
  54         struct device *hwmon_dev;
  55         const char *name;
  56         u8 x86_model;
  57         u8 vrm;
  58         u32 msr_temp;
  59         u32 msr_vid;
  60 };
  61 #define via_cputemp_data pdev_entry
  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 via_cputemp_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->pdev->id);
  78         return ret;
  79 }
  80
  81 static ssize_t show_temp(struct device *dev,
  82                          struct device_attribute *devattr, char *buf)
  83 {
  84         struct via_cputemp_data *data = dev_get_drvdata(dev);
  85         u32 eax, edx;
  86         int err;
  87
  88         err = rdmsr_safe_on_pcpu(data->pdev->id, data->msr_temp, &eax, &edx);
  89         if (err < 0)
  90                 return -EAGAIN;
  91
  92         return sprintf(buf, "%lu\n", ((unsigned long)eax & 0xffffff) * 1000);
  93 }
  94
  95 static ssize_t show_cpu_vid(struct device *dev,
  96                             struct device_attribute *devattr, char *buf)
  97 {
  98         struct via_cputemp_data *data = dev_get_drvdata(dev);
  99         u32 eax, edx;
 100         int err;
 101
 102         err = rdmsr_safe_on_pcpu(data->pdev->id, data->msr_vid, &eax, &edx);
 103         if (err < 0)
 104                 return -EAGAIN;
 105
 106         return sprintf(buf, "%d\n", vid_from_reg(~edx & 0x7f, data->vrm));
 107 }
 108
 109 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
 110                           SHOW_TEMP);
 111 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
 112 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
 113
 114 static struct attribute *via_cputemp_attributes[] = {
 115         &sensor_dev_attr_name.dev_attr.attr,
 116         &sensor_dev_attr_temp1_label.dev_attr.attr,
 117         &sensor_dev_attr_temp1_input.dev_attr.attr,
 118         NULL
 119 };
 120
 121 static const struct attribute_group via_cputemp_group = {
 122         .attrs = via_cputemp_attributes,
 123 };
 124
 125 /* Optional attributes */
 126 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_cpu_vid, NULL);
 127
 128 static int via_cputemp_probe(struct platform_device *pdev)
 129 {
 130         struct via_cputemp_data *data = platform_get_drvdata(pdev);
 131         int err;
 132         u32 eax, edx;
 133
 134         data->name = "via_cputemp";
 135
 136         switch (data->x86_model) {
 137         case 0xA:
 138                 /* C7 A */
 139         case 0xD:
 140                 /* C7 D */
 141                 data->msr_temp = 0x1169;
 142                 data->msr_vid = 0x198;
 143                 break;
 144         case 0xF:
 145                 /* Nano */
 146                 data->msr_temp = 0x1423;
 147                 break;
 148         default:
 149                 return -ENODEV;
 150         }
 151
 152         /* test if we can access the TEMPERATURE MSR */
 153         err = rdmsr_safe_on_pcpu(pdev->id, data->msr_temp, &eax, &edx);
 154         if (err < 0) {
 155                 dev_err(&pdev->dev,
 156                         "Unable to access TEMPERATURE MSR, giving up\n");
 157                 return err;
 158         }
 159
 160         err = sysfs_create_group(&pdev->dev.kobj, &via_cputemp_group);
 161         if (err)
 162                 return err;
 163
 164         if (data->msr_vid)
 165                 data->vrm = vid_which_vrm();
 166
 167         if (data->vrm) {
 168                 err = device_create_file(&pdev->dev, &dev_attr_cpu0_vid);
 169                 if (err)
 170                         goto exit_remove;
 171         }
 172
 173         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 174         if (IS_ERR(data->hwmon_dev)) {
 175                 err = PTR_ERR(data->hwmon_dev);
 176                 dev_err(&pdev->dev, "Class registration failed (%d)\n",
 177                         err);
 178                 goto exit_remove;
 179         }
 180
 181         return 0;
 182
 183 exit_remove:
 184         if (data->vrm)
 185                 device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 186         sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 187         return err;
 188 }
 189
 190 static int via_cputemp_remove(struct platform_device *pdev)
 191 {
 192         struct via_cputemp_data *data = platform_get_drvdata(pdev);
 193
 194         hwmon_device_unregister(data->hwmon_dev);
 195         if (data->vrm)
 196                 device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
 197         sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
 198         return 0;
 199 }
 200
 201 static struct platform_driver via_cputemp_driver = {
 202         .driver = {
 203                 .owner = THIS_MODULE,
 204                 .name = DRVNAME,
 205         },
 206         .probe = via_cputemp_probe,
 207         .remove = via_cputemp_remove,
 208 };
 209
 210 static LIST_HEAD(pdev_list);
 211 static DEFINE_MUTEX(pdev_list_mutex);
 212
 213 struct cpu_info {
 214         struct pdev_entry *pdev_entry;
 215         u8 x86;
 216 };
 217
 218 static void get_cpuid_info(void *arg)
 219 {
 220         struct cpu_info *info = arg;
 221         struct pdev_entry *pdev_entry = info->pdev_entry;
 222         u32 val = cpuid_eax(1);
 223
 224         info->x86 = ((val >> 8) & 0xf) + ((val >> 20) & 0xff);
 225         pdev_entry->x86_model = ((val >> 4) & 0xf) | ((val >> 12) & 0xf0);
 226 }
 227
 228 static int via_cputemp_device_add(unsigned int cpu)
 229 {
 230         int err;
 231         struct cpu_info info;
 232         struct platform_device *pdev;
 233         struct pdev_entry *pdev_entry;
 234
 235         pdev_entry = kzalloc(sizeof(*pdev_entry), GFP_KERNEL);
 236         if (!pdev_entry)
 237                 return -ENOMEM;
 238
 239         info.pdev_entry = pdev_entry;
 240         err = xen_set_physical_cpu_affinity(cpu);
 241         if (!err) {
 242                 get_cpuid_info(&info);
 243                 WARN_ON_ONCE(xen_set_physical_cpu_affinity(-1));
 244         } else if (err > 0) {
 245                 static bool warned;
 246
 247                 if (!warned) {
 248                         warned = true;
 249                         printk(KERN_WARNING DRVNAME
 250                                "Cannot set physical CPU affinity"
 251                                " (assuming use of dom0_vcpus_pin)\n");
 252                 }
 253                 err = smp_call_function_single(cpu, get_cpuid_info, &info, 1);
 254         }
 255         if (err)
 256                 goto exit_entry_free;
 257
 258         if (info.x86 != 6)
 259                 goto exit_entry_free;
 260
 261         if (pdev_entry->x86_model < 0x0a)
 262                 goto exit_entry_free;
 263
 264         if (pdev_entry->x86_model > 0x0f) {
 265                 pr_warn("Unknown CPU model 0x%x\n", pdev_entry->x86_model);
 266                 goto exit_entry_free;
 267         }
 268
 269         pdev = platform_device_alloc(DRVNAME, cpu);
 270         if (!pdev) {
 271                 err = -ENOMEM;
 272                 pr_err("Device allocation failed\n");
 273                 goto exit_entry_free;
 274         }
 275
 276         platform_set_drvdata(pdev, pdev_entry);
 277         pdev_entry->pdev = pdev;
 278
 279         err = platform_device_add(pdev);
 280         if (err) {
 281                 pr_err("Device addition failed (%d)\n", err);
 282                 goto exit_device_put;
 283         }
 284
 285         mutex_lock(&pdev_list_mutex);
 286         list_add_tail(&pdev_entry->list, &pdev_list);
 287         mutex_unlock(&pdev_list_mutex);
 288
 289         return 0;
 290
 291 exit_device_put:
 292         platform_device_put(pdev);
 293 exit_entry_free:
 294         kfree(pdev_entry);
 295         return err;
 296 }
 297
 298 static void via_cputemp_device_remove(unsigned int cpu)
 299 {
 300         struct pdev_entry *p;
 301
 302         mutex_lock(&pdev_list_mutex);
 303         list_for_each_entry(p, &pdev_list, list) {
 304                 if (p->pdev->id == cpu) {
 305                         platform_device_unregister(p->pdev);
 306                         list_del(&p->list);
 307                         mutex_unlock(&pdev_list_mutex);
 308                         kfree(p);
 309                         return;
 310                 }
 311         }
 312         mutex_unlock(&pdev_list_mutex);
 313 }
 314
 315 static int via_cputemp_cpu_callback(struct notifier_block *nfb,
 316                                  unsigned long action, void *hcpu)
 317 {
 318         unsigned int cpu = (unsigned long) hcpu;
 319
 320         switch (action) {
 321         case CPU_ONLINE:
 322                 via_cputemp_device_add(cpu);
 323                 break;
 324         case CPU_DEAD:
 325                 via_cputemp_device_remove(cpu);
 326                 break;
 327         }
 328         return NOTIFY_OK;
 329 }
 330
 331 static struct notifier_block via_cputemp_cpu_notifier = {
 332         .notifier_call = via_cputemp_cpu_callback,
 333 };
 334
 335 static const struct x86_cpu_id cputemp_ids[] = {
 336         { X86_VENDOR_CENTAUR, 6, 0xa, }, /* C7 A */
 337         { X86_VENDOR_CENTAUR, 6, 0xd, }, /* C7 D */
 338         { X86_VENDOR_CENTAUR, 6, 0xf, }, /* Nano */
 339         {}
 340 };
 341 MODULE_DEVICE_TABLE(x86cpu, cputemp_ids);
 342
 343 static int __init via_cputemp_init(void)
 344 {
 345         int err;
 346
 347         if (!is_initial_xendomain())
 348                 return -ENODEV;
 349
 350         if (!x86_match_cpu(cputemp_ids))
 351                 return -ENODEV;
 352
 353         err = platform_driver_register(&via_cputemp_driver);
 354         if (err)
 355                 goto exit;
 356
 357         err = register_pcpu_notifier(&via_cputemp_cpu_notifier);
 358         if (err)
 359                 goto exit_driver_unreg;
 360
 361 #ifndef CONFIG_ACPI_HOTPLUG_CPU
 362         if (list_empty(&pdev_list)) {
 363                 unregister_pcpu_notifier(&via_cputemp_cpu_notifier);
 364                 err = -ENODEV;
 365                 goto exit_driver_unreg;
 366         }
 367 #endif
 368
 369         return 0;
 370
 371 exit_driver_unreg:
 372         platform_driver_unregister(&via_cputemp_driver);
 373 exit:
 374         return err;
 375 }
 376
 377 static void __exit via_cputemp_exit(void)
 378 {
 379         struct pdev_entry *p, *n;
 380
 381         unregister_pcpu_notifier(&via_cputemp_cpu_notifier);
 382         mutex_lock(&pdev_list_mutex);
 383         list_for_each_entry_safe(p, n, &pdev_list, list) {
 384                 platform_device_unregister(p->pdev);
 385                 list_del(&p->list);
 386                 kfree(p);
 387         }
 388         mutex_unlock(&pdev_list_mutex);
 389         platform_driver_unregister(&via_cputemp_driver);
 390 }
 391
 392 MODULE_AUTHOR("Harald Welte <HaraldWelte@viatech.com>");
 393 MODULE_DESCRIPTION("VIA CPU temperature monitor");
 394 MODULE_LICENSE("GPL");
 395
 396 module_init(via_cputemp_init)
 397 module_exit(via_cputemp_exit)