[deliverable/linux.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_LABEL, SHOW_NAME } SHOW;

/*
 * Functions declaration
 */

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

struct coretemp_data {
	struct class_device *class_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;
	u8 alarm;
};

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

/*
 * 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
		err = sprintf(buf, "%d\n", data->tjmax);

	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 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) {
			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);

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

	data->class_dev = hwmon_device_register(&pdev->dev);
	if (IS_ERR(data->class_dev)) {
		err = PTR_ERR(data->class_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_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->class_dev);
	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
	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
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 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_ONLINE_FROZEN:
		coretemp_device_add(cpu);
		break;
	case CPU_DEAD:
	case CPU_DEAD_FROZEN:
		coretemp_device_remove(cpu);
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block __cpuinitdata coretemp_cpu_notifier = {
	.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 */
		if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
		    !((c->x86_model == 0xe) || (c->x86_model == 0xf))) {

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