coretemp.c 21.2 KB
Newer Older
R
Rudolf Marek 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * 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.
 */

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

R
Rudolf Marek 已提交
25 26 27 28 29 30 31 32 33 34 35 36
#include <linux/module.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>
37
#include <linux/pci.h>
38
#include <linux/smp.h>
39
#include <linux/moduleparam.h>
R
Rudolf Marek 已提交
40 41
#include <asm/msr.h>
#include <asm/processor.h>
42
#include <asm/cpu_device_id.h>
R
Rudolf Marek 已提交
43 44 45

#define DRVNAME	"coretemp"

46 47 48 49 50 51 52 53
/*
 * force_tjmax only matters when TjMax can't be read from the CPU itself.
 * When set, it replaces the driver's suboptimal heuristic.
 */
static int force_tjmax;
module_param_named(tjmax, force_tjmax, int, 0444);
MODULE_PARM_DESC(tjmax, "TjMax value in degrees Celsius");

54
#define BASE_SYSFS_ATTR_NO	2	/* Sysfs Base attr no for coretemp */
55
#define NUM_REAL_CORES		32	/* Number of Real cores per cpu */
56
#define CORETEMP_NAME_LENGTH	17	/* String Length of attrs */
57
#define MAX_CORE_ATTRS		4	/* Maximum no of basic attrs */
58
#define TOTAL_ATTRS		(MAX_CORE_ATTRS + 1)
59 60
#define MAX_CORE_DATA		(NUM_REAL_CORES + BASE_SYSFS_ATTR_NO)

61 62
#define TO_PHYS_ID(cpu)		(cpu_data(cpu).phys_proc_id)
#define TO_CORE_ID(cpu)		(cpu_data(cpu).cpu_core_id)
63 64 65
#define TO_ATTR_NO(cpu)		(TO_CORE_ID(cpu) + BASE_SYSFS_ATTR_NO)

#ifdef CONFIG_SMP
66
#define for_each_sibling(i, cpu)	for_each_cpu(i, cpu_sibling_mask(cpu))
67
#else
68
#define for_each_sibling(i, cpu)	for (i = 0; false; )
69
#endif
R
Rudolf Marek 已提交
70 71

/*
72 73 74 75 76 77 78
 * Per-Core Temperature Data
 * @last_updated: The time when the current temperature value was updated
 *		earlier (in jiffies).
 * @cpu_core_id: The CPU Core from which temperature values should be read
 *		This value is passed as "id" field to rdmsr/wrmsr functions.
 * @status_reg: One of IA32_THERM_STATUS or IA32_PACKAGE_THERM_STATUS,
 *		from where the temperature values should be read.
79
 * @attr_size:  Total number of pre-core attrs displayed in the sysfs.
80 81 82
 * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
 *		Otherwise, temp_data holds coretemp data.
 * @valid: If this is 1, the current temperature is valid.
R
Rudolf Marek 已提交
83
 */
84
struct temp_data {
R
Rudolf Marek 已提交
85
	int temp;
86
	int ttarget;
87 88 89 90 91
	int tjmax;
	unsigned long last_updated;
	unsigned int cpu;
	u32 cpu_core_id;
	u32 status_reg;
92
	int attr_size;
93 94
	bool is_pkg_data;
	bool valid;
95 96
	struct sensor_device_attribute sd_attrs[TOTAL_ATTRS];
	char attr_name[TOTAL_ATTRS][CORETEMP_NAME_LENGTH];
97
	struct mutex update_lock;
R
Rudolf Marek 已提交
98 99
};

100 101 102 103 104 105 106
/* Platform Data per Physical CPU */
struct platform_data {
	struct device *hwmon_dev;
	u16 phys_proc_id;
	struct temp_data *core_data[MAX_CORE_DATA];
	struct device_attribute name_attr;
};
R
Rudolf Marek 已提交
107

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
struct pdev_entry {
	struct list_head list;
	struct platform_device *pdev;
	u16 phys_proc_id;
};

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

static ssize_t show_name(struct device *dev,
			struct device_attribute *devattr, char *buf)
{
	return sprintf(buf, "%s\n", DRVNAME);
}

static ssize_t show_label(struct device *dev,
				struct device_attribute *devattr, char *buf)
R
Rudolf Marek 已提交
125 126
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
127 128 129 130 131
	struct platform_data *pdata = dev_get_drvdata(dev);
	struct temp_data *tdata = pdata->core_data[attr->index];

	if (tdata->is_pkg_data)
		return sprintf(buf, "Physical id %u\n", pdata->phys_proc_id);
R
Rudolf Marek 已提交
132

133
	return sprintf(buf, "Core %u\n", tdata->cpu_core_id);
R
Rudolf Marek 已提交
134 135
}

136 137
static ssize_t show_crit_alarm(struct device *dev,
				struct device_attribute *devattr, char *buf)
R
Rudolf Marek 已提交
138
{
139 140 141 142 143 144 145 146
	u32 eax, edx;
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct platform_data *pdata = dev_get_drvdata(dev);
	struct temp_data *tdata = pdata->core_data[attr->index];

	rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);

	return sprintf(buf, "%d\n", (eax >> 5) & 1);
R
Rudolf Marek 已提交
147 148
}

149 150
static ssize_t show_tjmax(struct device *dev,
			struct device_attribute *devattr, char *buf)
R
Rudolf Marek 已提交
151 152
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
153
	struct platform_data *pdata = dev_get_drvdata(dev);
R
Rudolf Marek 已提交
154

155
	return sprintf(buf, "%d\n", pdata->core_data[attr->index]->tjmax);
R
Rudolf Marek 已提交
156 157
}

158 159 160 161 162
static ssize_t show_ttarget(struct device *dev,
				struct device_attribute *devattr, char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct platform_data *pdata = dev_get_drvdata(dev);
R
Rudolf Marek 已提交
163

164 165
	return sprintf(buf, "%d\n", pdata->core_data[attr->index]->ttarget);
}
R
Rudolf Marek 已提交
166

167 168
static ssize_t show_temp(struct device *dev,
			struct device_attribute *devattr, char *buf)
R
Rudolf Marek 已提交
169
{
170 171 172 173
	u32 eax, edx;
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct platform_data *pdata = dev_get_drvdata(dev);
	struct temp_data *tdata = pdata->core_data[attr->index];
R
Rudolf Marek 已提交
174

175
	mutex_lock(&tdata->update_lock);
R
Rudolf Marek 已提交
176

177 178 179 180 181
	/* Check whether the time interval has elapsed */
	if (!tdata->valid || time_after(jiffies, tdata->last_updated + HZ)) {
		rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
		tdata->valid = 0;
		/* Check whether the data is valid */
R
Rudolf Marek 已提交
182
		if (eax & 0x80000000) {
183
			tdata->temp = tdata->tjmax -
184
					((eax >> 16) & 0x7f) * 1000;
185
			tdata->valid = 1;
R
Rudolf Marek 已提交
186
		}
187
		tdata->last_updated = jiffies;
R
Rudolf Marek 已提交
188 189
	}

190 191
	mutex_unlock(&tdata->update_lock);
	return tdata->valid ? sprintf(buf, "%d\n", tdata->temp) : -EAGAIN;
R
Rudolf Marek 已提交
192 193
}

194 195
static int __cpuinit adjust_tjmax(struct cpuinfo_x86 *c, u32 id,
				  struct device *dev)
196 197 198 199
{
	/* The 100C is default for both mobile and non mobile CPUs */

	int tjmax = 100000;
200
	int tjmax_ee = 85000;
201
	int usemsr_ee = 1;
202 203
	int err;
	u32 eax, edx;
204
	struct pci_dev *host_bridge;
205 206 207

	/* Early chips have no MSR for TjMax */

208
	if (c->x86_model == 0xf && c->x86_mask < 4)
209
		usemsr_ee = 0;
210

211
	/* Atom CPUs */
212

213 214
	if (c->x86_model == 0x1c || c->x86_model == 0x26
	    || c->x86_model == 0x27) {
215
		usemsr_ee = 0;
216 217 218 219 220 221 222 223 224 225 226

		host_bridge = pci_get_bus_and_slot(0, PCI_DEVFN(0, 0));

		if (host_bridge && host_bridge->vendor == PCI_VENDOR_ID_INTEL
		    && (host_bridge->device == 0xa000	/* NM10 based nettop */
		    || host_bridge->device == 0xa010))	/* NM10 based netbook */
			tjmax = 100000;
		else
			tjmax = 90000;

		pci_dev_put(host_bridge);
227 228 229
	} else if (c->x86_model == 0x36) {
		usemsr_ee = 0;
		tjmax = 100000;
230 231
	}

232
	if (c->x86_model > 0xe && usemsr_ee) {
233
		u8 platform_id;
234

235 236 237 238 239
		/*
		 * Now we can detect the mobile CPU using Intel provided table
		 * http://softwarecommunity.intel.com/Wiki/Mobility/720.htm
		 * For Core2 cores, check MSR 0x17, bit 28 1 = Mobile CPU
		 */
240 241 242 243 244
		err = rdmsr_safe_on_cpu(id, 0x17, &eax, &edx);
		if (err) {
			dev_warn(dev,
				 "Unable to access MSR 0x17, assuming desktop"
				 " CPU\n");
245
			usemsr_ee = 0;
246
		} else if (c->x86_model < 0x17 && !(eax & 0x10000000)) {
247 248 249 250 251
			/*
			 * Trust bit 28 up to Penryn, I could not find any
			 * documentation on that; if you happen to know
			 * someone at Intel please ask
			 */
252
			usemsr_ee = 0;
253 254 255 256
		} else {
			/* Platform ID bits 52:50 (EDX starts at bit 32) */
			platform_id = (edx >> 18) & 0x7;

257 258 259 260 261 262 263 264 265 266
			/*
			 * Mobile Penryn CPU seems to be platform ID 7 or 5
			 * (guesswork)
			 */
			if (c->x86_model == 0x17 &&
			    (platform_id == 5 || platform_id == 7)) {
				/*
				 * If MSR EE bit is set, set it to 90 degrees C,
				 * otherwise 105 degrees C
				 */
267 268 269
				tjmax_ee = 90000;
				tjmax = 105000;
			}
270 271 272
		}
	}

273
	if (usemsr_ee) {
274 275 276 277
		err = rdmsr_safe_on_cpu(id, 0xee, &eax, &edx);
		if (err) {
			dev_warn(dev,
				 "Unable to access MSR 0xEE, for Tjmax, left"
278
				 " at default\n");
279
		} else if (eax & 0x40000000) {
280
			tjmax = tjmax_ee;
281
		}
282
	} else if (tjmax == 100000) {
283 284 285 286
		/*
		 * If we don't use msr EE it means we are desktop CPU
		 * (with exeception of Atom)
		 */
287 288 289 290 291 292
		dev_warn(dev, "Using relative temperature scale!\n");
	}

	return tjmax;
}

293 294
static int __cpuinit get_tjmax(struct cpuinfo_x86 *c, u32 id,
			       struct device *dev)
295 296 297 298 299
{
	int err;
	u32 eax, edx;
	u32 val;

300 301 302 303
	/*
	 * A new feature of current Intel(R) processors, the
	 * IA32_TEMPERATURE_TARGET contains the TjMax value
	 */
304 305
	err = rdmsr_safe_on_cpu(id, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
	if (err) {
306 307
		if (c->x86_model > 0xe && c->x86_model != 0x1c)
			dev_warn(dev, "Unable to read TjMax from CPU %u\n", id);
308 309 310 311 312 313
	} else {
		val = (eax >> 16) & 0xff;
		/*
		 * If the TjMax is not plausible, an assumption
		 * will be used
		 */
314
		if (val) {
315
			dev_dbg(dev, "TjMax is %d degrees C\n", val);
316 317 318 319
			return val * 1000;
		}
	}

320 321 322 323 324 325
	if (force_tjmax) {
		dev_notice(dev, "TjMax forced to %d degrees C by user\n",
			   force_tjmax);
		return force_tjmax * 1000;
	}

326 327
	/*
	 * An assumption is made for early CPUs and unreadable MSR.
328
	 * NOTE: the calculated value may not be correct.
329
	 */
330
	return adjust_tjmax(c, id, dev);
331 332
}

333 334
static int __devinit create_name_attr(struct platform_data *pdata,
				      struct device *dev)
335
{
336
	sysfs_attr_init(&pdata->name_attr.attr);
337 338 339 340 341
	pdata->name_attr.attr.name = "name";
	pdata->name_attr.attr.mode = S_IRUGO;
	pdata->name_attr.show = show_name;
	return device_create_file(dev, &pdata->name_attr);
}
R
Rudolf Marek 已提交
342

343 344
static int __cpuinit create_core_attrs(struct temp_data *tdata,
				       struct device *dev, int attr_no)
345 346
{
	int err, i;
347
	static ssize_t (*const rd_ptr[TOTAL_ATTRS]) (struct device *dev,
348
			struct device_attribute *devattr, char *buf) = {
349
			show_label, show_crit_alarm, show_temp, show_tjmax,
350
			show_ttarget };
351
	static const char *const names[TOTAL_ATTRS] = {
352
					"temp%d_label", "temp%d_crit_alarm",
353
					"temp%d_input", "temp%d_crit",
354
					"temp%d_max" };
355

356
	for (i = 0; i < tdata->attr_size; i++) {
357 358
		snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH, names[i],
			attr_no);
359
		sysfs_attr_init(&tdata->sd_attrs[i].dev_attr.attr);
360 361 362 363 364 365 366
		tdata->sd_attrs[i].dev_attr.attr.name = tdata->attr_name[i];
		tdata->sd_attrs[i].dev_attr.attr.mode = S_IRUGO;
		tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
		tdata->sd_attrs[i].index = attr_no;
		err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
		if (err)
			goto exit_free;
R
Rudolf Marek 已提交
367
	}
368 369 370 371 372 373 374 375 376
	return 0;

exit_free:
	while (--i >= 0)
		device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
	return err;
}


377
static int __cpuinit chk_ucode_version(unsigned int cpu)
378
{
379
	struct cpuinfo_x86 *c = &cpu_data(cpu);
380

381 382 383 384 385
	/*
	 * 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).
	 */
386 387 388 389
	if (c->x86_model == 0xe && c->x86_mask < 0xc && c->microcode < 0x39) {
		pr_err("Errata AE18 not fixed, update BIOS or "
		       "microcode of the CPU!\n");
		return -ENODEV;
390
	}
391 392 393
	return 0;
}

394
static struct platform_device __cpuinit *coretemp_get_pdev(unsigned int cpu)
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
{
	u16 phys_proc_id = TO_PHYS_ID(cpu);
	struct pdev_entry *p;

	mutex_lock(&pdev_list_mutex);

	list_for_each_entry(p, &pdev_list, list)
		if (p->phys_proc_id == phys_proc_id) {
			mutex_unlock(&pdev_list_mutex);
			return p->pdev;
		}

	mutex_unlock(&pdev_list_mutex);
	return NULL;
}

411 412
static struct temp_data __cpuinit *init_temp_data(unsigned int cpu,
						  int pkg_flag)
413 414 415 416 417 418 419 420 421 422 423 424
{
	struct temp_data *tdata;

	tdata = kzalloc(sizeof(struct temp_data), GFP_KERNEL);
	if (!tdata)
		return NULL;

	tdata->status_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_STATUS :
							MSR_IA32_THERM_STATUS;
	tdata->is_pkg_data = pkg_flag;
	tdata->cpu = cpu;
	tdata->cpu_core_id = TO_CORE_ID(cpu);
425
	tdata->attr_size = MAX_CORE_ATTRS;
426 427 428
	mutex_init(&tdata->update_lock);
	return tdata;
}
429

430
static int __cpuinit create_core_data(struct platform_device *pdev,
431 432 433
				unsigned int cpu, int pkg_flag)
{
	struct temp_data *tdata;
434
	struct platform_data *pdata = platform_get_drvdata(pdev);
435 436 437
	struct cpuinfo_x86 *c = &cpu_data(cpu);
	u32 eax, edx;
	int err, attr_no;
R
Rudolf Marek 已提交
438

439
	/*
440 441 442 443
	 * Find attr number for sysfs:
	 * We map the attr number to core id of the CPU
	 * The attr number is always core id + 2
	 * The Pkgtemp will always show up as temp1_*, if available
444
	 */
445
	attr_no = pkg_flag ? 1 : TO_ATTR_NO(cpu);
446

447 448 449
	if (attr_no > MAX_CORE_DATA - 1)
		return -ERANGE;

450 451 452
	/*
	 * Provide a single set of attributes for all HT siblings of a core
	 * to avoid duplicate sensors (the processor ID and core ID of all
453 454
	 * HT siblings of a core are the same).
	 * Skip if a HT sibling of this core is already registered.
455 456
	 * This is not an error.
	 */
457 458
	if (pdata->core_data[attr_no] != NULL)
		return 0;
459

460 461 462
	tdata = init_temp_data(cpu, pkg_flag);
	if (!tdata)
		return -ENOMEM;
R
Rudolf Marek 已提交
463

464 465 466 467 468 469
	/* Test if we can access the status register */
	err = rdmsr_safe_on_cpu(cpu, tdata->status_reg, &eax, &edx);
	if (err)
		goto exit_free;

	/* We can access status register. Get Critical Temperature */
470
	tdata->tjmax = get_tjmax(c, cpu, &pdev->dev);
471

472
	/*
473 474 475
	 * Read the still undocumented bits 8:15 of IA32_TEMPERATURE_TARGET.
	 * The target temperature is available on older CPUs but not in this
	 * register. Atoms don't have the register at all.
476
	 */
477 478 479 480 481 482 483 484
	if (c->x86_model > 0xe && c->x86_model != 0x1c) {
		err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET,
					&eax, &edx);
		if (!err) {
			tdata->ttarget
			  = tdata->tjmax - ((eax >> 8) & 0xff) * 1000;
			tdata->attr_size++;
		}
485 486
	}

487 488 489 490 491 492
	pdata->core_data[attr_no] = tdata;

	/* Create sysfs interfaces */
	err = create_core_attrs(tdata, &pdev->dev, attr_no);
	if (err)
		goto exit_free;
R
Rudolf Marek 已提交
493 494

	return 0;
495
exit_free:
496
	pdata->core_data[attr_no] = NULL;
497 498 499 500
	kfree(tdata);
	return err;
}

501
static void __cpuinit coretemp_add_core(unsigned int cpu, int pkg_flag)
502 503 504 505 506 507 508
{
	struct platform_device *pdev = coretemp_get_pdev(cpu);
	int err;

	if (!pdev)
		return;

509
	err = create_core_data(pdev, cpu, pkg_flag);
510 511 512 513 514 515 516 517 518 519 520
	if (err)
		dev_err(&pdev->dev, "Adding Core %u failed\n", cpu);
}

static void coretemp_remove_core(struct platform_data *pdata,
				struct device *dev, int indx)
{
	int i;
	struct temp_data *tdata = pdata->core_data[indx];

	/* Remove the sysfs attributes */
521
	for (i = 0; i < tdata->attr_size; i++)
522 523 524 525 526 527 528 529 530 531
		device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);

	kfree(pdata->core_data[indx]);
	pdata->core_data[indx] = NULL;
}

static int __devinit coretemp_probe(struct platform_device *pdev)
{
	struct platform_data *pdata;
	int err;
R
Rudolf Marek 已提交
532

533 534 535 536 537 538 539 540 541
	/* Initialize the per-package data structures */
	pdata = kzalloc(sizeof(struct platform_data), GFP_KERNEL);
	if (!pdata)
		return -ENOMEM;

	err = create_name_attr(pdata, &pdev->dev);
	if (err)
		goto exit_free;

542
	pdata->phys_proc_id = pdev->id;
543 544 545 546 547 548 549 550 551 552 553 554 555
	platform_set_drvdata(pdev, pdata);

	pdata->hwmon_dev = hwmon_device_register(&pdev->dev);
	if (IS_ERR(pdata->hwmon_dev)) {
		err = PTR_ERR(pdata->hwmon_dev);
		dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
		goto exit_name;
	}
	return 0;

exit_name:
	device_remove_file(&pdev->dev, &pdata->name_attr);
	platform_set_drvdata(pdev, NULL);
R
Rudolf Marek 已提交
556
exit_free:
557
	kfree(pdata);
R
Rudolf Marek 已提交
558 559 560 561 562
	return err;
}

static int __devexit coretemp_remove(struct platform_device *pdev)
{
563 564
	struct platform_data *pdata = platform_get_drvdata(pdev);
	int i;
R
Rudolf Marek 已提交
565

566 567 568 569 570 571
	for (i = MAX_CORE_DATA - 1; i >= 0; --i)
		if (pdata->core_data[i])
			coretemp_remove_core(pdata, &pdev->dev, i);

	device_remove_file(&pdev->dev, &pdata->name_attr);
	hwmon_device_unregister(pdata->hwmon_dev);
R
Rudolf Marek 已提交
572
	platform_set_drvdata(pdev, NULL);
573
	kfree(pdata);
R
Rudolf Marek 已提交
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	return 0;
}

static struct platform_driver coretemp_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = DRVNAME,
	},
	.probe = coretemp_probe,
	.remove = __devexit_p(coretemp_remove),
};

static int __cpuinit coretemp_device_add(unsigned int cpu)
{
	int err;
	struct platform_device *pdev;
	struct pdev_entry *pdev_entry;
591 592 593

	mutex_lock(&pdev_list_mutex);

594
	pdev = platform_device_alloc(DRVNAME, TO_PHYS_ID(cpu));
R
Rudolf Marek 已提交
595 596
	if (!pdev) {
		err = -ENOMEM;
597
		pr_err("Device allocation failed\n");
R
Rudolf Marek 已提交
598 599 600 601 602 603 604 605 606 607 608
		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) {
609
		pr_err("Device addition failed (%d)\n", err);
R
Rudolf Marek 已提交
610 611 612 613
		goto exit_device_free;
	}

	pdev_entry->pdev = pdev;
614
	pdev_entry->phys_proc_id = pdev->id;
615

R
Rudolf Marek 已提交
616 617 618 619 620 621 622 623 624 625
	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:
626
	mutex_unlock(&pdev_list_mutex);
R
Rudolf Marek 已提交
627 628 629
	return err;
}

630
static void __cpuinit coretemp_device_remove(unsigned int cpu)
R
Rudolf Marek 已提交
631
{
632 633
	struct pdev_entry *p, *n;
	u16 phys_proc_id = TO_PHYS_ID(cpu);
634

R
Rudolf Marek 已提交
635
	mutex_lock(&pdev_list_mutex);
636 637
	list_for_each_entry_safe(p, n, &pdev_list, list) {
		if (p->phys_proc_id != phys_proc_id)
638 639 640 641
			continue;
		platform_device_unregister(p->pdev);
		list_del(&p->list);
		kfree(p);
R
Rudolf Marek 已提交
642 643 644 645
	}
	mutex_unlock(&pdev_list_mutex);
}

646
static bool __cpuinit is_any_core_online(struct platform_data *pdata)
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
{
	int i;

	/* Find online cores, except pkgtemp data */
	for (i = MAX_CORE_DATA - 1; i >= 0; --i) {
		if (pdata->core_data[i] &&
			!pdata->core_data[i]->is_pkg_data) {
			return true;
		}
	}
	return false;
}

static void __cpuinit get_core_online(unsigned int cpu)
{
	struct cpuinfo_x86 *c = &cpu_data(cpu);
	struct platform_device *pdev = coretemp_get_pdev(cpu);
	int err;

	/*
	 * CPUID.06H.EAX[0] indicates whether the CPU has thermal
	 * sensors. We check this bit only, all the early CPUs
	 * without thermal sensors will be filtered out.
	 */
	if (!cpu_has(c, X86_FEATURE_DTS))
		return;

	if (!pdev) {
675 676 677 678
		/* Check the microcode version of the CPU */
		if (chk_ucode_version(cpu))
			return;

679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
		/*
		 * Alright, we have DTS support.
		 * We are bringing the _first_ core in this pkg
		 * online. So, initialize per-pkg data structures and
		 * then bring this core online.
		 */
		err = coretemp_device_add(cpu);
		if (err)
			return;
		/*
		 * Check whether pkgtemp support is available.
		 * If so, add interfaces for pkgtemp.
		 */
		if (cpu_has(c, X86_FEATURE_PTS))
			coretemp_add_core(cpu, 1);
	}
	/*
	 * Physical CPU device already exists.
	 * So, just add interfaces for this core.
	 */
	coretemp_add_core(cpu, 0);
}

static void __cpuinit put_core_offline(unsigned int cpu)
{
	int i, indx;
	struct platform_data *pdata;
	struct platform_device *pdev = coretemp_get_pdev(cpu);

	/* If the physical CPU device does not exist, just return */
	if (!pdev)
		return;

	pdata = platform_get_drvdata(pdev);

	indx = TO_ATTR_NO(cpu);

716 717 718 719
	/* The core id is too big, just return */
	if (indx > MAX_CORE_DATA - 1)
		return;

720 721 722
	if (pdata->core_data[indx] && pdata->core_data[indx]->cpu == cpu)
		coretemp_remove_core(pdata, &pdev->dev, indx);

723
	/*
724 725 726 727
	 * If a HT sibling of a core is taken offline, but another HT sibling
	 * of the same core is still online, register the alternate sibling.
	 * This ensures that exactly one set of attributes is provided as long
	 * as at least one HT sibling of a core is online.
728
	 */
729
	for_each_sibling(i, cpu) {
730 731
		if (i != cpu) {
			get_core_online(i);
732 733 734 735 736
			/*
			 * Display temperature sensor data for one HT sibling
			 * per core only, so abort the loop after one such
			 * sibling has been found.
			 */
737 738 739 740 741 742 743 744 745 746 747 748 749
			break;
		}
	}
	/*
	 * If all cores in this pkg are offline, remove the device.
	 * coretemp_device_remove calls unregister_platform_device,
	 * which in turn calls coretemp_remove. This removes the
	 * pkgtemp entry and does other clean ups.
	 */
	if (!is_any_core_online(pdata))
		coretemp_device_remove(cpu);
}

750
static int __cpuinit coretemp_cpu_callback(struct notifier_block *nfb,
R
Rudolf Marek 已提交
751 752 753 754 755 756
				 unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long) hcpu;

	switch (action) {
	case CPU_ONLINE:
R
Rafael J. Wysocki 已提交
757
	case CPU_DOWN_FAILED:
758
		get_core_online(cpu);
R
Rudolf Marek 已提交
759
		break;
R
Rafael J. Wysocki 已提交
760
	case CPU_DOWN_PREPARE:
761
		put_core_offline(cpu);
R
Rudolf Marek 已提交
762 763 764 765 766
		break;
	}
	return NOTIFY_OK;
}

767
static struct notifier_block coretemp_cpu_notifier __refdata = {
R
Rudolf Marek 已提交
768 769 770
	.notifier_call = coretemp_cpu_callback,
};

771 772 773 774 775 776
static const struct x86_cpu_id coretemp_ids[] = {
	{ X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, X86_FEATURE_DTS },
	{}
};
MODULE_DEVICE_TABLE(x86cpu, coretemp_ids);

R
Rudolf Marek 已提交
777 778 779 780
static int __init coretemp_init(void)
{
	int i, err = -ENODEV;

781 782 783 784 785 786 787
	/*
	 * CPUID.06H.EAX[0] indicates whether the CPU has thermal
	 * sensors. We check this bit only, all the early CPUs
	 * without thermal sensors will be filtered out.
	 */
	if (!x86_match_cpu(coretemp_ids))
		return -ENODEV;
R
Rudolf Marek 已提交
788 789 790 791 792

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

793
	for_each_online_cpu(i)
794
		get_core_online(i);
795 796

#ifndef CONFIG_HOTPLUG_CPU
R
Rudolf Marek 已提交
797 798 799 800
	if (list_empty(&pdev_list)) {
		err = -ENODEV;
		goto exit_driver_unreg;
	}
801
#endif
R
Rudolf Marek 已提交
802 803 804 805

	register_hotcpu_notifier(&coretemp_cpu_notifier);
	return 0;

806
#ifndef CONFIG_HOTPLUG_CPU
807
exit_driver_unreg:
R
Rudolf Marek 已提交
808
	platform_driver_unregister(&coretemp_driver);
809
#endif
R
Rudolf Marek 已提交
810 811 812 813 814 815 816
exit:
	return err;
}

static void __exit coretemp_exit(void)
{
	struct pdev_entry *p, *n;
817

R
Rudolf Marek 已提交
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
	unregister_hotcpu_notifier(&coretemp_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);
	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)