[net-next-2.6.git] / drivers / hwmon / coretemp.c

/*
 * coretemp.c - Linux kernel module for hardware monitoring
 *
 * Copyright (C) 2007 Rudolf Marek <r.marek@assembler.cz>
 *
 * Inspired from many hwmon drivers
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/hwmon.h>
#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>

#define DRVNAME	"coretemp"

typedef enum { SHOW_TEMP, SHOW_TJMAX, SHOW_TTARGET, SHOW_LABEL,
		SHOW_NAME } SHOW;

/*
 * Functions declaration
 */

static struct coretemp_data *coretemp_update_device(struct device *dev);

struct coretemp_data {
	struct device *hwmon_dev;
	struct mutex update_lock;
	const char *name;
	u32 id;
	char valid;		/* zero until following fields are valid */
	unsigned long last_updated;	/* in jiffies */
	int temp;
	int tjmax;
	int ttarget;
	u8 alarm;
};

/*
 * 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 coretemp_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_alarm(struct device *dev, struct device_attribute
			  *devattr, char *buf)
{
	struct coretemp_data *data = coretemp_update_device(dev);
	/* read the Out-of-spec log, never clear */
	return sprintf(buf, "%d\n", data->alarm);
}

static ssize_t show_temp(struct device *dev,
			 struct device_attribute *devattr, char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct coretemp_data *data = coretemp_update_device(dev);
	int err;

	if (attr->index == SHOW_TEMP)
		err = data->valid ? sprintf(buf, "%d\n", data->temp) : -EAGAIN;
	else if (attr->index == SHOW_TJMAX)
		err = sprintf(buf, "%d\n", data->tjmax);
	else
		err = sprintf(buf, "%d\n", data->ttarget);
	return err;
}

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
			  SHOW_TEMP);
static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL,
			  SHOW_TJMAX);
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp, NULL,
			  SHOW_TTARGET);
static DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL);
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 *coretemp_attributes[] = {
	&sensor_dev_attr_name.dev_attr.attr,
	&sensor_dev_attr_temp1_label.dev_attr.attr,
	&dev_attr_temp1_crit_alarm.attr,
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp1_crit.dev_attr.attr,
	NULL
};

static const struct attribute_group coretemp_group = {
	.attrs = coretemp_attributes,
};

static struct coretemp_data *coretemp_update_device(struct device *dev)
{
	struct coretemp_data *data = dev_get_drvdata(dev);

	mutex_lock(&data->update_lock);

	if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
		u32 eax, edx;

		data->valid = 0;
		rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
		data->alarm = (eax >> 5) & 1;
		/* update only if data has been valid */
		if (eax & 0x80000000) {
			data->temp = data->tjmax - (((eax >> 16)
							& 0x7f) * 1000);
			data->valid = 1;
		} else {
			dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax);
		}
		data->last_updated = jiffies;
	}

	mutex_unlock(&data->update_lock);
	return data;
}

static int __devinit coretemp_probe(struct platform_device *pdev)
{
	struct coretemp_data *data;
	struct cpuinfo_x86 *c = &cpu_data(pdev->id);
	int err;
	u32 eax, edx;

	if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
		err = -ENOMEM;
		dev_err(&pdev->dev, "Out of memory\n");
		goto exit;
	}

	data->id = pdev->id;
	data->name = "coretemp";
	mutex_init(&data->update_lock);
	/* Tjmax default is 100 degrees C */
	data->tjmax = 100000;

	/* test if we can access the THERM_STATUS MSR */
	err = rdmsr_safe_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
	if (err) {
		dev_err(&pdev->dev,
			"Unable to access THERM_STATUS MSR, giving up\n");
		goto exit_free;
	}

	/* Check if we have problem with errata AE18 of Core processors:
	   Readings might stop update when processor visited too deep sleep,
	   fixed for stepping D0 (6EC).
	*/

	if ((c->x86_model == 0xe) && (c->x86_mask < 0xc)) {
		/* check for microcode update */
		rdmsr_on_cpu(data->id, MSR_IA32_UCODE_REV, &eax, &edx);
		if (edx < 0x39) {
			err = -ENODEV;
			dev_err(&pdev->dev,
				"Errata AE18 not fixed, update BIOS or "
				"microcode of the CPU!\n");
			goto exit_free;
		}
	}

	/* Some processors have Tjmax 85 following magic should detect it
	   Intel won't disclose the information without signed NDA, but
	   individuals cannot sign it. Catch(ed) 22.
	*/

	if (((c->x86_model == 0xf) && (c->x86_mask > 3)) ||
		(c->x86_model == 0xe))  {
		err = rdmsr_safe_on_cpu(data->id, 0xee, &eax, &edx);
		if (err) {
			dev_warn(&pdev->dev,
				 "Unable to access MSR 0xEE, Tjmax left at %d "
				 "degrees C\n", data->tjmax/1000);
		} else if (eax & 0x40000000) {
			data->tjmax = 85000;
		}
	}

	/* Intel says that above should not work for desktop Core2 processors,
	   but it seems to work. There is no other way how get the absolute
	   readings. Warn the user about this. First check if are desktop,
	   bit 50 of MSR_IA32_PLATFORM_ID should be 0.
	*/

	rdmsr_safe_on_cpu(data->id, MSR_IA32_PLATFORM_ID, &eax, &edx);

	if ((c->x86_model == 0xf) && (!(edx & 0x00040000))) {
		dev_warn(&pdev->dev, "Using undocumented features, absolute "
			 "temperature might be wrong!\n");
	}

	platform_set_drvdata(pdev, data);

	/* read the still undocumented IA32_TEMPERATURE_TARGET it exists
	   on older CPUs but not in this register */

	if (c->x86_model > 0xe) {
		err = rdmsr_safe_on_cpu(data->id, 0x1a2, &eax, &edx);
		if (err) {
			dev_warn(&pdev->dev, "Unable to read"
					" IA32_TEMPERATURE_TARGET MSR\n");
		} else {
			data->ttarget = data->tjmax -
					(((eax >> 8) & 0xff) * 1000);
			err = device_create_file(&pdev->dev,
					&sensor_dev_attr_temp1_max.dev_attr);
			if (err)
				goto exit_free;
		}
	}

	if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
		goto exit_dev;

	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_class;
	}

	return 0;

exit_class:
	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
exit_dev:
	device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
exit_free:
	kfree(data);
exit:
	return err;
}

static int __devexit coretemp_remove(struct platform_device *pdev)
{
	struct coretemp_data *data = platform_get_drvdata(pdev);

	hwmon_device_unregister(data->hwmon_dev);
	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
	device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
	platform_set_drvdata(pdev, NULL);
	kfree(data);
	return 0;
}

static struct platform_driver coretemp_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = DRVNAME,
	},
	.probe = coretemp_probe,
	.remove = __devexit_p(coretemp_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 coretemp_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;
		printk(KERN_ERR DRVNAME ": Device allocation failed\n");
		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) {
		printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
		       err);
		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;
}

#ifdef CONFIG_HOTPLUG_CPU
static void coretemp_device_remove(unsigned int cpu)
{
	struct pdev_entry *p, *n;
	mutex_lock(&pdev_list_mutex);
	list_for_each_entry_safe(p, n, &pdev_list, list) {
		if (p->cpu == cpu) {
			platform_device_unregister(p->pdev);
			list_del(&p->list);
			kfree(p);
		}
	}
	mutex_unlock(&pdev_list_mutex);
}

static int __cpuinit coretemp_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:
		coretemp_device_add(cpu);
		break;
	case CPU_DOWN_PREPARE:
		coretemp_device_remove(cpu);
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block coretemp_cpu_notifier __refdata = {
	.notifier_call = coretemp_cpu_callback,
};
#endif				/* !CONFIG_HOTPLUG_CPU */

static int __init coretemp_init(void)
{
	int i, err = -ENODEV;
	struct pdev_entry *p, *n;

	/* quick check if we run Intel */
	if (cpu_data(0).x86_vendor != X86_VENDOR_INTEL)
		goto exit;

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

	for_each_online_cpu(i) {
		struct cpuinfo_x86 *c = &cpu_data(i);

		/* check if family 6, models e, f, 16 */
		if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
		    !((c->x86_model == 0xe) || (c->x86_model == 0xf) ||
			(c->x86_model == 0x16))) {

			/* supported CPU not found, but report the unknown
			   family 6 CPU */
			if ((c->x86 == 0x6) && (c->x86_model > 0xf))
				printk(KERN_WARNING DRVNAME ": Unknown CPU "
					"model %x\n", c->x86_model);
			continue;
		}

		err = coretemp_device_add(i);
		if (err)
			goto exit_devices_unreg;
	}
	if (list_empty(&pdev_list)) {
		err = -ENODEV;
		goto exit_driver_unreg;
	}

#ifdef CONFIG_HOTPLUG_CPU
	register_hotcpu_notifier(&coretemp_cpu_notifier);
#endif
	return 0;

exit_devices_unreg:
	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);
exit_driver_unreg:
	platform_driver_unregister(&coretemp_driver);
exit:
	return err;
}

static void __exit coretemp_exit(void)
{
	struct pdev_entry *p, *n;
#ifdef CONFIG_HOTPLUG_CPU
	unregister_hotcpu_notifier(&coretemp_cpu_notifier);
#endif
	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);
	platform_driver_unregister(&coretemp_driver);
}

MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");
MODULE_DESCRIPTION("Intel Core temperature monitor");
MODULE_LICENSE("GPL");

module_init(coretemp_init)
module_exit(coretemp_exit)
Commit	Line	Data
bebe4678 RM	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
6369a288 RM	41	typedef enum { SHOW_TEMP, SHOW_TJMAX, SHOW_TTARGET, SHOW_LABEL,
6369a288 RM	42	SHOW_NAME } SHOW;
bebe4678 RM	43
	44	/*
	45	* Functions declaration
	46	*/
	47
	48	static struct coretemp_data coretemp_update_device(struct device dev);
	49
	50	struct coretemp_data {
1beeffe4	51	struct device *hwmon_dev;
bebe4678 RM	52	struct mutex update_lock;
	53	const char *name;
	54	u32 id;
	55	char valid; /* zero until following fields are valid */
	56	unsigned long last_updated; /* in jiffies */
	57	int temp;
	58	int tjmax;
6369a288	59	int ttarget;
bebe4678 RM	60	u8 alarm;
	61	};
	62
bebe4678 RM	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;
6369a288	98	else if (attr->index == SHOW_TJMAX)
bebe4678	99	err = sprintf(buf, "%d\n", data->tjmax);
6369a288 RM	100	else
6369a288 RM	101	err = sprintf(buf, "%d\n", data->ttarget);
bebe4678 RM	102	return err;
	103	}
	104
	105	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
	106	SHOW_TEMP);
	107	static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL,
	108	SHOW_TJMAX);
6369a288 RM	109	static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp, NULL,
6369a288 RM	110	SHOW_TTARGET);
bebe4678 RM	111	static DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL);
	112	static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
	113	static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
	114
	115	static struct attribute *coretemp_attributes[] = {
	116	&sensor_dev_attr_name.dev_attr.attr,
	117	&sensor_dev_attr_temp1_label.dev_attr.attr,
	118	&dev_attr_temp1_crit_alarm.attr,
	119	&sensor_dev_attr_temp1_input.dev_attr.attr,
	120	&sensor_dev_attr_temp1_crit.dev_attr.attr,
	121	NULL
	122	};
	123
	124	static const struct attribute_group coretemp_group = {
	125	.attrs = coretemp_attributes,
	126	};
	127
	128	static struct coretemp_data coretemp_update_device(struct device dev)
	129	{
	130	struct coretemp_data *data = dev_get_drvdata(dev);
	131
	132	mutex_lock(&data->update_lock);
	133
	134	if (!data->valid \|\| time_after(jiffies, data->last_updated + HZ)) {
	135	u32 eax, edx;
	136
	137	data->valid = 0;
	138	rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
	139	data->alarm = (eax >> 5) & 1;
	140	/* update only if data has been valid */
	141	if (eax & 0x80000000) {
	142	data->temp = data->tjmax - (((eax >> 16)
	143	& 0x7f) * 1000);
	144	data->valid = 1;
	145	} else {
	146	dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax);
	147	}
	148	data->last_updated = jiffies;
	149	}
	150
	151	mutex_unlock(&data->update_lock);
	152	return data;
	153	}
	154
	155	static int __devinit coretemp_probe(struct platform_device *pdev)
	156	{
	157	struct coretemp_data *data;
92cb7612	158	struct cpuinfo_x86 *c = &cpu_data(pdev->id);
bebe4678 RM	159	int err;
	160	u32 eax, edx;
	161
	162	if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
	163	err = -ENOMEM;
	164	dev_err(&pdev->dev, "Out of memory\n");
	165	goto exit;
	166	}
	167
	168	data->id = pdev->id;
	169	data->name = "coretemp";
	170	mutex_init(&data->update_lock);
	171	/* Tjmax default is 100 degrees C */
	172	data->tjmax = 100000;
	173
	174	/* test if we can access the THERM_STATUS MSR */
	175	err = rdmsr_safe_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
	176	if (err) {
	177	dev_err(&pdev->dev,
	178	"Unable to access THERM_STATUS MSR, giving up\n");
	179	goto exit_free;
	180	}
	181
67f363b1 RM	182	/* Check if we have problem with errata AE18 of Core processors:
	183	Readings might stop update when processor visited too deep sleep,
	184	fixed for stepping D0 (6EC).
	185	*/
	186
	187	if ((c->x86_model == 0xe) && (c->x86_mask < 0xc)) {
	188	/* check for microcode update */
	189	rdmsr_on_cpu(data->id, MSR_IA32_UCODE_REV, &eax, &edx);
	190	if (edx < 0x39) {
6d79af70	191	err = -ENODEV;
67f363b1 RM	192	dev_err(&pdev->dev,
	193	"Errata AE18 not fixed, update BIOS or "
	194	"microcode of the CPU!\n");
	195	goto exit_free;
	196	}
	197	}
	198
bebe4678 RM	199	/* Some processors have Tjmax 85 following magic should detect it
	200	Intel won't disclose the information without signed NDA, but
	201	individuals cannot sign it. Catch(ed) 22.
	202	*/
	203
	204	if (((c->x86_model == 0xf) && (c->x86_mask > 3)) \|\|
	205	(c->x86_model == 0xe)) {
	206	err = rdmsr_safe_on_cpu(data->id, 0xee, &eax, &edx);
	207	if (err) {
	208	dev_warn(&pdev->dev,
	209	"Unable to access MSR 0xEE, Tjmax left at %d "
	210	"degrees C\n", data->tjmax/1000);
	211	} else if (eax & 0x40000000) {
	212	data->tjmax = 85000;
	213	}
	214	}
	215
67f363b1 RM	216	/* Intel says that above should not work for desktop Core2 processors,
	217	but it seems to work. There is no other way how get the absolute
	218	readings. Warn the user about this. First check if are desktop,
	219	bit 50 of MSR_IA32_PLATFORM_ID should be 0.
	220	*/
	221
	222	rdmsr_safe_on_cpu(data->id, MSR_IA32_PLATFORM_ID, &eax, &edx);
	223
	224	if ((c->x86_model == 0xf) && (!(edx & 0x00040000))) {
	225	dev_warn(&pdev->dev, "Using undocumented features, absolute "
	226	"temperature might be wrong!\n");
	227	}
	228
bebe4678 RM	229	platform_set_drvdata(pdev, data);
bebe4678 RM	230
6369a288 RM	231	/* read the still undocumented IA32_TEMPERATURE_TARGET it exists
	232	on older CPUs but not in this register */
	233
	234	if (c->x86_model > 0xe) {
	235	err = rdmsr_safe_on_cpu(data->id, 0x1a2, &eax, &edx);
	236	if (err) {
	237	dev_warn(&pdev->dev, "Unable to read"
	238	" IA32_TEMPERATURE_TARGET MSR\n");
	239	} else {
	240	data->ttarget = data->tjmax -
	241	(((eax >> 8) & 0xff) * 1000);
	242	err = device_create_file(&pdev->dev,
	243	&sensor_dev_attr_temp1_max.dev_attr);
	244	if (err)
	245	goto exit_free;
	246	}
	247	}
	248
bebe4678	249	if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
6369a288	250	goto exit_dev;
bebe4678	251
1beeffe4 TJ	252	data->hwmon_dev = hwmon_device_register(&pdev->dev);
	253	if (IS_ERR(data->hwmon_dev)) {
	254	err = PTR_ERR(data->hwmon_dev);
bebe4678 RM	255	dev_err(&pdev->dev, "Class registration failed (%d)\n",
	256	err);
	257	goto exit_class;
	258	}
	259
	260	return 0;
	261
	262	exit_class:
	263	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
6369a288 RM	264	exit_dev:
6369a288 RM	265	device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
bebe4678 RM	266	exit_free:
	267	kfree(data);
	268	exit:
	269	return err;
	270	}
	271
	272	static int __devexit coretemp_remove(struct platform_device *pdev)
	273	{
	274	struct coretemp_data *data = platform_get_drvdata(pdev);
	275
1beeffe4	276	hwmon_device_unregister(data->hwmon_dev);
bebe4678	277	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
6369a288	278	device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
bebe4678 RM	279	platform_set_drvdata(pdev, NULL);
	280	kfree(data);
	281	return 0;
	282	}
	283
	284	static struct platform_driver coretemp_driver = {
	285	.driver = {
	286	.owner = THIS_MODULE,
	287	.name = DRVNAME,
	288	},
	289	.probe = coretemp_probe,
	290	.remove = __devexit_p(coretemp_remove),
	291	};
	292
	293	struct pdev_entry {
	294	struct list_head list;
	295	struct platform_device *pdev;
	296	unsigned int cpu;
	297	};
	298
	299	static LIST_HEAD(pdev_list);
	300	static DEFINE_MUTEX(pdev_list_mutex);
	301
	302	static int __cpuinit coretemp_device_add(unsigned int cpu)
	303	{
	304	int err;
	305	struct platform_device *pdev;
	306	struct pdev_entry *pdev_entry;
	307
	308	pdev = platform_device_alloc(DRVNAME, cpu);
	309	if (!pdev) {
	310	err = -ENOMEM;
	311	printk(KERN_ERR DRVNAME ": Device allocation failed\n");
	312	goto exit;
	313	}
	314
	315	pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
	316	if (!pdev_entry) {
	317	err = -ENOMEM;
	318	goto exit_device_put;
	319	}
	320
	321	err = platform_device_add(pdev);
	322	if (err) {
	323	printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
	324	err);
	325	goto exit_device_free;
	326	}
	327
	328	pdev_entry->pdev = pdev;
	329	pdev_entry->cpu = cpu;
	330	mutex_lock(&pdev_list_mutex);
	331	list_add_tail(&pdev_entry->list, &pdev_list);
	332	mutex_unlock(&pdev_list_mutex);
	333
	334	return 0;
	335
	336	exit_device_free:
	337	kfree(pdev_entry);
	338	exit_device_put:
	339	platform_device_put(pdev);
	340	exit:
	341	return err;
	342	}
343
344	#ifdef CONFIG_HOTPLUG_CPU
d2bc7b13	345	static void coretemp_device_remove(unsigned int cpu)
bebe4678 RM	346	{
	347	struct pdev_entry p, n;
	348	mutex_lock(&pdev_list_mutex);
	349	list_for_each_entry_safe(p, n, &pdev_list, list) {
	350	if (p->cpu == cpu) {
	351	platform_device_unregister(p->pdev);
	352	list_del(&p->list);
	353	kfree(p);
	354	}
	355	}
	356	mutex_unlock(&pdev_list_mutex);
	357	}
	358
ba7c1927	359	static int __cpuinit coretemp_cpu_callback(struct notifier_block *nfb,
bebe4678 RM	360	unsigned long action, void *hcpu)
	361	{
	362	unsigned int cpu = (unsigned long) hcpu;
	363
	364	switch (action) {
	365	case CPU_ONLINE:
561d9a96	366	case CPU_DOWN_FAILED:
bebe4678 RM	367	coretemp_device_add(cpu);
bebe4678 RM	368	break;
561d9a96	369	case CPU_DOWN_PREPARE:
bebe4678 RM	370	coretemp_device_remove(cpu);
	371	break;
	372	}
	373	return NOTIFY_OK;
	374	}
	375
ba7c1927	376	static struct notifier_block coretemp_cpu_notifier __refdata = {
bebe4678 RM	377	.notifier_call = coretemp_cpu_callback,
	378	};
	379	#endif /* !CONFIG_HOTPLUG_CPU */
	380
	381	static int __init coretemp_init(void)
	382	{
	383	int i, err = -ENODEV;
	384	struct pdev_entry p, n;
	385
bebe4678	386	/* quick check if we run Intel */
92cb7612	387	if (cpu_data(0).x86_vendor != X86_VENDOR_INTEL)
bebe4678 RM	388	goto exit;
	389
	390	err = platform_driver_register(&coretemp_driver);
	391	if (err)
	392	goto exit;
	393
	394	for_each_online_cpu(i) {
92cb7612	395	struct cpuinfo_x86 *c = &cpu_data(i);
bebe4678	396
c940336b	397	/* check if family 6, models e, f, 16 */
bebe4678	398	if ((c->cpuid_level < 0) \|\| (c->x86 != 0x6) \|\|
c940336b RM	399	!((c->x86_model == 0xe) \|\| (c->x86_model == 0xf) \|\|
c940336b RM	400	(c->x86_model == 0x16))) {
bebe4678 RM	401
	402	/* supported CPU not found, but report the unknown
	403	family 6 CPU */
	404	if ((c->x86 == 0x6) && (c->x86_model > 0xf))
	405	printk(KERN_WARNING DRVNAME ": Unknown CPU "
	406	"model %x\n", c->x86_model);
	407	continue;
	408	}
	409
	410	err = coretemp_device_add(i);
	411	if (err)
	412	goto exit_devices_unreg;
	413	}
	414	if (list_empty(&pdev_list)) {
	415	err = -ENODEV;
	416	goto exit_driver_unreg;
	417	}
	418
	419	#ifdef CONFIG_HOTPLUG_CPU
	420	register_hotcpu_notifier(&coretemp_cpu_notifier);
	421	#endif
	422	return 0;
	423
	424	exit_devices_unreg:
	425	mutex_lock(&pdev_list_mutex);
	426	list_for_each_entry_safe(p, n, &pdev_list, list) {
	427	platform_device_unregister(p->pdev);
	428	list_del(&p->list);
	429	kfree(p);
	430	}
	431	mutex_unlock(&pdev_list_mutex);
	432	exit_driver_unreg:
	433	platform_driver_unregister(&coretemp_driver);
	434	exit:
	435	return err;
	436	}
	437
	438	static void __exit coretemp_exit(void)
	439	{
	440	struct pdev_entry p, n;
	441	#ifdef CONFIG_HOTPLUG_CPU
	442	unregister_hotcpu_notifier(&coretemp_cpu_notifier);
	443	#endif
	444	mutex_lock(&pdev_list_mutex);
	445	list_for_each_entry_safe(p, n, &pdev_list, list) {
	446	platform_device_unregister(p->pdev);
	447	list_del(&p->list);
	448	kfree(p);
	449	}
	450	mutex_unlock(&pdev_list_mutex);
	451	platform_driver_unregister(&coretemp_driver);
	452	}
	453
	454	MODULE_AUTHOR("Rudolf Marek <r.marek@assembler.cz>");
	455	MODULE_DESCRIPTION("Intel Core temperature monitor");
	456	MODULE_LICENSE("GPL");
	457
	458	module_init(coretemp_init)
	459	module_exit(coretemp_exit)