via-cputemp.c 8.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * via-cputemp.c - Driver for VIA CPU core temperature monitoring
 * Copyright (C) 2009 VIA Technologies, Inc.
 *
 * based on existing coretemp.c, which is
 *
 * Copyright (C) 2007 Rudolf Marek <r.marek@assembler.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

24 25
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

26 27 28 29
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/hwmon.h>
30
#include <linux/hwmon-vid.h>
31 32 33 34 35 36 37 38 39
#include <linux/sysfs.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/cpu.h>
#include <asm/msr.h>
#include <asm/processor.h>
40
#include <asm/cpu_device_id.h>
41 42 43

#define DRVNAME	"via_cputemp"

44
enum { SHOW_TEMP, SHOW_LABEL, SHOW_NAME };
45 46 47 48 49 50 51 52

/*
 * Functions declaration
 */

struct via_cputemp_data {
	struct device *hwmon_dev;
	const char *name;
53
	u8 vrm;
54
	u32 id;
55 56
	u32 msr_temp;
	u32 msr_vid;
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
};

/*
 * Sysfs stuff
 */

static ssize_t show_name(struct device *dev, struct device_attribute
			  *devattr, char *buf)
{
	int ret;
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct via_cputemp_data *data = dev_get_drvdata(dev);

	if (attr->index == SHOW_NAME)
		ret = sprintf(buf, "%s\n", data->name);
	else	/* show label */
		ret = sprintf(buf, "Core %d\n", data->id);
	return ret;
}

static ssize_t show_temp(struct device *dev,
			 struct device_attribute *devattr, char *buf)
{
	struct via_cputemp_data *data = dev_get_drvdata(dev);
	u32 eax, edx;
	int err;

84
	err = rdmsr_safe_on_cpu(data->id, data->msr_temp, &eax, &edx);
85 86 87 88 89 90
	if (err)
		return -EAGAIN;

	return sprintf(buf, "%lu\n", ((unsigned long)eax & 0xffffff) * 1000);
}

91 92 93 94 95 96 97 98 99 100 101 102 103 104
static ssize_t show_cpu_vid(struct device *dev,
			    struct device_attribute *devattr, char *buf)
{
	struct via_cputemp_data *data = dev_get_drvdata(dev);
	u32 eax, edx;
	int err;

	err = rdmsr_safe_on_cpu(data->id, data->msr_vid, &eax, &edx);
	if (err)
		return -EAGAIN;

	return sprintf(buf, "%d\n", vid_from_reg(~edx & 0x7f, data->vrm));
}

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
			  SHOW_TEMP);
static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);

static struct attribute *via_cputemp_attributes[] = {
	&sensor_dev_attr_name.dev_attr.attr,
	&sensor_dev_attr_temp1_label.dev_attr.attr,
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	NULL
};

static const struct attribute_group via_cputemp_group = {
	.attrs = via_cputemp_attributes,
};

121 122 123
/* Optional attributes */
static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_cpu_vid, NULL);

124 125 126 127 128 129 130
static int __devinit via_cputemp_probe(struct platform_device *pdev)
{
	struct via_cputemp_data *data;
	struct cpuinfo_x86 *c = &cpu_data(pdev->id);
	int err;
	u32 eax, edx;

131 132 133 134
	data = devm_kzalloc(&pdev->dev, sizeof(struct via_cputemp_data),
			    GFP_KERNEL);
	if (!data)
		return -ENOMEM;
135 136 137 138 139 140 141 142 143

	data->id = pdev->id;
	data->name = "via_cputemp";

	switch (c->x86_model) {
	case 0xA:
		/* C7 A */
	case 0xD:
		/* C7 D */
144 145
		data->msr_temp = 0x1169;
		data->msr_vid = 0x198;
146 147 148
		break;
	case 0xF:
		/* Nano */
149
		data->msr_temp = 0x1423;
150 151
		break;
	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 158 159
	if (err) {
		dev_err(&pdev->dev,
			"Unable to access TEMPERATURE MSR, giving up\n");
160
		return err;
161 162 163 164 165 166
	}

	platform_set_drvdata(pdev, data);

	err = sysfs_create_group(&pdev->dev.kobj, &via_cputemp_group);
	if (err)
167
		return err;
168

169 170 171 172 173 174 175 176 177
	if (data->msr_vid)
		data->vrm = vid_which_vrm();

	if (data->vrm) {
		err = device_create_file(&pdev->dev, &dev_attr_cpu0_vid);
		if (err)
			goto exit_remove;
	}

178 179 180 181 182 183 184 185 186 187 188
	data->hwmon_dev = hwmon_device_register(&pdev->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
		dev_err(&pdev->dev, "Class registration failed (%d)\n",
			err);
		goto exit_remove;
	}

	return 0;

exit_remove:
189 190
	if (data->vrm)
		device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
191 192 193 194 195 196 197 198 199
	sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
	return err;
}

static int __devexit via_cputemp_remove(struct platform_device *pdev)
{
	struct via_cputemp_data *data = platform_get_drvdata(pdev);

	hwmon_device_unregister(data->hwmon_dev);
200 201
	if (data->vrm)
		device_remove_file(&pdev->dev, &dev_attr_cpu0_vid);
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
	sysfs_remove_group(&pdev->dev.kobj, &via_cputemp_group);
	return 0;
}

static struct platform_driver via_cputemp_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = DRVNAME,
	},
	.probe = via_cputemp_probe,
	.remove = __devexit_p(via_cputemp_remove),
};

struct pdev_entry {
	struct list_head list;
	struct platform_device *pdev;
	unsigned int cpu;
};

static LIST_HEAD(pdev_list);
static DEFINE_MUTEX(pdev_list_mutex);

static int __cpuinit via_cputemp_device_add(unsigned int cpu)
{
	int err;
	struct platform_device *pdev;
	struct pdev_entry *pdev_entry;

	pdev = platform_device_alloc(DRVNAME, cpu);
	if (!pdev) {
		err = -ENOMEM;
233
		pr_err("Device allocation failed\n");
234 235 236 237 238 239 240 241 242 243 244
		goto exit;
	}

	pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
	if (!pdev_entry) {
		err = -ENOMEM;
		goto exit_device_put;
	}

	err = platform_device_add(pdev);
	if (err) {
245
		pr_err("Device addition failed (%d)\n", err);
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
		goto exit_device_free;
	}

	pdev_entry->pdev = pdev;
	pdev_entry->cpu = cpu;
	mutex_lock(&pdev_list_mutex);
	list_add_tail(&pdev_entry->list, &pdev_list);
	mutex_unlock(&pdev_list_mutex);

	return 0;

exit_device_free:
	kfree(pdev_entry);
exit_device_put:
	platform_device_put(pdev);
exit:
	return err;
}

265
static void __cpuinit via_cputemp_device_remove(unsigned int cpu)
266
{
267 268
	struct pdev_entry *p;

269
	mutex_lock(&pdev_list_mutex);
270
	list_for_each_entry(p, &pdev_list, list) {
271 272 273
		if (p->cpu == cpu) {
			platform_device_unregister(p->pdev);
			list_del(&p->list);
274
			mutex_unlock(&pdev_list_mutex);
275
			kfree(p);
276
			return;
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
		}
	}
	mutex_unlock(&pdev_list_mutex);
}

static int __cpuinit via_cputemp_cpu_callback(struct notifier_block *nfb,
				 unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long) hcpu;

	switch (action) {
	case CPU_ONLINE:
	case CPU_DOWN_FAILED:
		via_cputemp_device_add(cpu);
		break;
	case CPU_DOWN_PREPARE:
		via_cputemp_device_remove(cpu);
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block via_cputemp_cpu_notifier __refdata = {
	.notifier_call = via_cputemp_cpu_callback,
};

303
static const struct x86_cpu_id __initconst cputemp_ids[] = {
304 305 306 307 308 309 310
	{ X86_VENDOR_CENTAUR, 6, 0xa, }, /* C7 A */
	{ X86_VENDOR_CENTAUR, 6, 0xd, }, /* C7 D */
	{ X86_VENDOR_CENTAUR, 6, 0xf, }, /* Nano */
	{}
};
MODULE_DEVICE_TABLE(x86cpu, cputemp_ids);

311 312 313 314
static int __init via_cputemp_init(void)
{
	int i, err;

315 316
	if (!x86_match_cpu(cputemp_ids))
		return -ENODEV;
317 318 319 320 321

	err = platform_driver_register(&via_cputemp_driver);
	if (err)
		goto exit;

322
	get_online_cpus();
323 324 325 326 327 328 329 330 331 332
	for_each_online_cpu(i) {
		struct cpuinfo_x86 *c = &cpu_data(i);

		if (c->x86 != 6)
			continue;

		if (c->x86_model < 0x0a)
			continue;

		if (c->x86_model > 0x0f) {
333
			pr_warn("Unknown CPU model 0x%x\n", c->x86_model);
334 335 336
			continue;
		}

337
		via_cputemp_device_add(i);
338
	}
339 340

#ifndef CONFIG_HOTPLUG_CPU
341
	if (list_empty(&pdev_list)) {
342
		put_online_cpus();
343 344 345
		err = -ENODEV;
		goto exit_driver_unreg;
	}
346
#endif
347 348

	register_hotcpu_notifier(&via_cputemp_cpu_notifier);
349
	put_online_cpus();
350 351
	return 0;

352
#ifndef CONFIG_HOTPLUG_CPU
353 354
exit_driver_unreg:
	platform_driver_unregister(&via_cputemp_driver);
355
#endif
356 357 358 359 360 361 362
exit:
	return err;
}

static void __exit via_cputemp_exit(void)
{
	struct pdev_entry *p, *n;
363

364
	get_online_cpus();
365 366 367 368 369 370 371 372
	unregister_hotcpu_notifier(&via_cputemp_cpu_notifier);
	mutex_lock(&pdev_list_mutex);
	list_for_each_entry_safe(p, n, &pdev_list, list) {
		platform_device_unregister(p->pdev);
		list_del(&p->list);
		kfree(p);
	}
	mutex_unlock(&pdev_list_mutex);
373
	put_online_cpus();
374 375 376 377 378 379 380 381 382
	platform_driver_unregister(&via_cputemp_driver);
}

MODULE_AUTHOR("Harald Welte <HaraldWelte@viatech.com>");
MODULE_DESCRIPTION("VIA CPU temperature monitor");
MODULE_LICENSE("GPL");

module_init(via_cputemp_init)
module_exit(via_cputemp_exit)