[lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[Durgadoss R]

This patch merges the pkgtemp driver with the coretemp driver.
This merged driver creates one hwmon device per physical CPU.

Changes from v3 of this patch:
Added appropriate support for CONFIG_HOTPLUG_CPU.

Signed-off-by: Durgadoss R <durgadoss.r@intel.com>
---
 drivers/hwmon/coretemp.c |  618 ++++++++++++++++++++++++++++++++++------------
 1 files changed, 455 insertions(+), 163 deletions(-)

diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 42de98d..2667828 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -39,119 +39,140 @@
 
 #define DRVNAME	"coretemp"
 
-typedef enum { SHOW_TEMP, SHOW_TJMAX, SHOW_TTARGET, SHOW_LABEL,
-		SHOW_NAME } SHOW;
+#define CORES_PER_CPU		16	/* No of Real Cores per CPU */
+#define CORETEMP_NAME_LENGTH	17	/* String Length of attrs */
+#define MAX_ATTRS		5	/* Maximum no of per-core attrs */
 
 /*
- * Functions declaration
+ * 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.
+ * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
+ *		Otherwise, temp_data holds coretemp data.
  */
-
-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;
-	u16 core_id;
-	char valid;		/* zero until following fields are valid */
-	unsigned long last_updated;	/* in jiffies */
+struct temp_data {
 	int temp;
-	int tjmax;
 	int ttarget;
-	u8 alarm;
+	int tjmax;
+	u8 crit_alarm;
+	u8 max_alarm;
+	unsigned long last_updated;
+	unsigned int cpu;
+	u32 cpu_core_id;
+	u32 status_reg;
+	bool is_pkg_data;
+	struct sensor_device_attribute sd_attrs[MAX_ATTRS];
+	char attr_name[MAX_ATTRS][CORETEMP_NAME_LENGTH];
+	struct mutex update_lock;
 };
 
 /*
- * Sysfs stuff
+ * Platform Data per Physical CPU
+ * @core_count:		Number of real cores(not HT ones) in a CPU
+ * @phys_proc_id:	The physical CPU id
  */
+struct platform_data {
+	struct device *hwmon_dev;
+	int core_count;
+	u16 phys_proc_id;
+	struct temp_data *core_data[CORES_PER_CPU];
+	struct device_attribute name_attr;
+};
+
+/* Function Declarations */
+static void remove_core(struct platform_data *data, struct device *dev, int i);
+
+static ssize_t show_name(struct device *dev,
+				struct device_attribute *devattr, char *buf)
+{
+	return sprintf(buf, "%s\n", DRVNAME);
+}
 
-static ssize_t show_name(struct device *dev, struct device_attribute
-			  *devattr, char *buf)
+static ssize_t show_label(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);
+	struct platform_data *pdata = dev_get_drvdata(dev);
+	struct temp_data *tdata = pdata->core_data[attr->index];
 
-	if (attr->index = SHOW_NAME)
-		ret = sprintf(buf, "%s\n", data->name);
-	else	/* show label */
-		ret = sprintf(buf, "Core %d\n", data->core_id);
-	return ret;
+	if (tdata->is_pkg_data)
+		return sprintf(buf, "Physical id %d\n", pdata->phys_proc_id);
+
+	return sprintf(buf, "Core %d\n", tdata->cpu_core_id);
 }
 
-static ssize_t show_alarm(struct device *dev, struct device_attribute
-			  *devattr, char *buf)
+static ssize_t show_crit_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);
+	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_core_id, tdata->status_reg, &eax, &edx);
+	tdata->crit_alarm = (eax >> 5) & 1;
+
+	return sprintf(buf, "%d\n", tdata->crit_alarm);
 }
 
-static ssize_t show_temp(struct device *dev,
-			 struct device_attribute *devattr, char *buf)
+static ssize_t show_tjmax(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;
+	struct platform_data *pdata = dev_get_drvdata(dev);
 
-	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;
+	return sprintf(buf, "%d\n", pdata->core_data[attr->index]->tjmax);
 }
 
-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 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);
 
-static const struct attribute_group coretemp_group = {
-	.attrs = coretemp_attributes,
-};
+	return sprintf(buf, "%d\n", pdata->core_data[attr->index]->ttarget);
+}
 
-static struct coretemp_data *coretemp_update_device(struct device *dev)
+static int update_curr_temp(struct temp_data *tdata, u32 eax, int tjmax)
 {
-	struct coretemp_data *data = dev_get_drvdata(dev);
+	int err = -EINVAL;
 
-	mutex_lock(&data->update_lock);
+	mutex_lock(&tdata->update_lock);
+	/*
+	 * Update the current temperature only if:
+	 * 1. The time interval has elapsed _and_
+	 * 2. The data is valid
+	 */
+	if (time_after(jiffies, tdata->last_updated + HZ) &&
+						(eax & 0x80000000)) {
+		tdata->temp = tjmax - (((eax >> 16) & 0x7f) * 1000);
+		tdata->last_updated = jiffies;
+		err = 0;
+	}
 
-	if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
-		u32 eax, edx;
+	mutex_unlock(&tdata->update_lock);
+	return err;
+}
 
-		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;
-	}
+static ssize_t show_temp(struct device *dev,
+				struct device_attribute *devattr, char *buf)
+{
+	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];
+	int err;
 
-	mutex_unlock(&data->update_lock);
-	return data;
+	rdmsr_on_cpu(tdata->cpu_core_id, tdata->status_reg, &eax, &edx);
+	err = update_curr_temp(tdata, eax, tdata->tjmax);
+	if (err)
+		return err;
+
+	return sprintf(buf, "%d\n", tdata->temp);
 }
 
 static int __devinit adjust_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
@@ -298,115 +319,242 @@ static void __devinit get_ucode_rev_on_cpu(void *edx)
 	rdmsr(MSR_IA32_UCODE_REV, eax, *(u32 *)edx);
 }
 
-static int __devinit coretemp_probe(struct platform_device *pdev)
+static int get_pkg_tjmax(int cpu, struct device *dev)
 {
-	struct coretemp_data *data;
-	struct cpuinfo_x86 *c = &cpu_data(pdev->id);
+	int default_tjmax = 100000;	/* 100 degree celsius */
 	int err;
-	u32 eax, edx;
+	u32 eax, edx, val;
 
-	if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
-		err = -ENOMEM;
-		dev_err(&pdev->dev, "Out of memory\n");
-		goto exit;
+	err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
+	if (!err) {
+		val = (eax >> 16) & 0xff;
+		if ((val > 80) && (val < 120))
+			return val * 1000;
 	}
+	dev_warn(dev, "Unable to read Pkg-TjMax from CPU:%d\n", cpu);
+	return default_tjmax;
+}
 
-	data->id = pdev->id;
-#ifdef CONFIG_SMP
-	data->core_id = c->cpu_core_id;
-#endif
-	data->name = "coretemp";
-	mutex_init(&data->update_lock);
+static int create_name_attr(struct platform_data *pdata, struct device *dev)
+{
+	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);
+}
 
-	/* 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;
+static int create_core_attrs(struct temp_data *tdata, struct device *dev,
+				int attr_no)
+{
+	int err, i;
+	ssize_t (*rd_ptr[MAX_ATTRS]) (struct device *dev,
+			struct device_attribute *devattr, char *buf) = {
+			show_label, show_crit_alarm, show_ttarget,
+			show_temp, show_tjmax };
+	const char *names[MAX_ATTRS] = { "temp%d_label", "temp%d_crit_alarm",
+					"temp%d_max", "temp%d_input",
+					"temp%d_crit" };
+
+	/* Increment attr_no since the sysfs interfaces start with temp1_* */
+	int sysfs_attr_no = attr_no + 1;
+
+	for (i = 0; i < MAX_ATTRS; i++) {
+		snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH, names[i],
+			sysfs_attr_no);
+		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].dev_attr.store = NULL;
+		tdata->sd_attrs[i].index = attr_no;
+		err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
+		if (err)
+			goto exit_free;
 	}
+	return 0;
+
+exit_free:
+	while (--i >= 0)
+		device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
+	return err;
+}
+
+static void remove_attrs(struct device *dev, struct temp_data *tdata)
+{
+	int i;
 
-	/* 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).
-	*/
+	/* Remove the sysfs attributes */
+	for (i = 0; i < MAX_ATTRS; i++)
+		device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
+}
 
+static void update_ttarget(__u8 cpu_model, struct temp_data *tdata,
+				struct device *dev)
+{
+	int err;
+	u32 eax, edx;
+
+	/*
+	 * Read the still undocumented IA32_TEMPERATURE_TARGET. It exists
+	 * on older CPUs but not in this register,
+	 * Atoms don't have it either.
+	 */
+	if ((cpu_model > 0xe) && (cpu_model != 0x1c)) {
+		err = rdmsr_safe_on_cpu(tdata->cpu_core_id,
+				MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
+		if (err) {
+			dev_warn(dev,
+			"Unable to read IA32_TEMPERATURE_TARGET MSR\n");
+
+		} else {
+			tdata->ttarget = tdata->tjmax -
+					(((eax >> 8) & 0xff) * 1000);
+		}
+	}
+}
+
+static int chk_ucode_version(struct cpuinfo_x86 *c,
+				struct platform_device *pdev)
+{
+	int err;
+	u32 edx;
+
+	/*
+	 * 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 */
-		err = smp_call_function_single(data->id, get_ucode_rev_on_cpu,
-					       &edx, 1);
+		err = smp_call_function_single(pdev->id, get_ucode_rev_on_cpu,
+								&edx, 1);
 		if (err) {
 			dev_err(&pdev->dev,
 				"Cannot determine microcode revision of "
-				"CPU#%u (%d)!\n", data->id, err);
-			err = -ENODEV;
-			goto exit_free;
+				"CPU#%u (%d)!\n", pdev->id, err);
+			return -ENODEV;
 		} else if (edx < 0x39) {
-			err = -ENODEV;
 			dev_err(&pdev->dev,
 				"Errata AE18 not fixed, update BIOS or "
 				"microcode of the CPU!\n");
-			goto exit_free;
+			return -ENODEV;
 		}
 	}
+	return 0;
+}
 
-	data->tjmax = get_tjmax(c, data->id, &pdev->dev);
-	platform_set_drvdata(pdev, data);
+static struct temp_data *init_temp_data(int cpu, int core_id, int pkg_flag)
+{
+	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_core_id = core_id;
+	tdata->cpu = cpu;
+	mutex_init(&tdata->update_lock);
+	return tdata;
+}
 
-	/*
-	 * read the still undocumented IA32_TEMPERATURE_TARGET. It exists
-	 * on older CPUs but not in this register,
-	 * Atoms don't have it either.
-	 */
+static int create_core_data(struct platform_data *pdata,
+				struct platform_device *pdev,
+				unsigned int cpu, int pkg_flag)
+{
+	struct temp_data *tdata;
+	struct cpuinfo_x86 *c = &cpu_data(cpu);
+	u32 eax, edx;
+	int err;
+	int core_id = c->cpu_core_id;
 
-	if ((c->x86_model > 0xe) && (c->x86_model != 0x1c)) {
-		err = rdmsr_safe_on_cpu(data->id, MSR_IA32_TEMPERATURE_TARGET,
-		    &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;
-		}
+	tdata = init_temp_data(cpu, core_id, pkg_flag);
+	if (!tdata)
+		return -ENOMEM;
+
+	/* Test if we can access the status register */
+	err = rdmsr_safe_on_cpu(core_id, tdata->status_reg, &eax, &edx);
+	if (err)
+		goto exit_free;
+
+	/* Create sysfs interfaces */
+	err = create_core_attrs(tdata, &pdev->dev, pdata->core_count);
+	if (err)
+		goto exit_free;
+
+	/* Get Critical Temperature */
+	if (pkg_flag)
+		tdata->tjmax = get_pkg_tjmax(pdev->id, &pdev->dev);
+	else
+		tdata->tjmax = get_tjmax(c, core_id, &pdev->dev);
+
+	update_ttarget(c->x86_model, tdata, &pdev->dev);
+
+	pdata->core_data[pdata->core_count] = tdata;
+	pdata->core_count++;
+
+	return 0;
+exit_free:
+	kfree(tdata);
+	return err;
+}
+
+static int __devinit coretemp_probe(struct platform_device *pdev)
+{
+	struct platform_data *pdata;
+	struct cpuinfo_x86 *c = &cpu_data(pdev->id);
+	int err;
+
+	/* Initialize the per-package data structures */
+	pdata = kzalloc(sizeof(struct platform_data), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(&pdev->dev, "Out of memory\n");
+		return -ENOMEM;
 	}
 
-	if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
-		goto exit_dev;
+	pdata->core_count = 0;
+	pdata->phys_proc_id = c->phys_proc_id;
 
-	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;
+	err = create_name_attr(pdata, &pdev->dev);
+	if (err)
+		goto exit_free;
+
+	/* Check the microcode version of the CPU */
+	err = chk_ucode_version(c, pdev);
+	if (err)
+		goto exit_name;
+
+	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_class:
-	sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
-exit_dev:
-	device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
+exit_name:
+	device_remove_file(&pdev->dev, &pdata->name_attr);
 exit_free:
-	kfree(data);
-exit:
+	kfree(pdata);
 	return err;
 }
 
 static int __devexit coretemp_remove(struct platform_device *pdev)
 {
-	struct coretemp_data *data = platform_get_drvdata(pdev);
+	struct platform_data *pdata = platform_get_drvdata(pdev);
+	int i;
 
-	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);
+	for (i = pdata->core_count - 1; i >= 0; --i)
+		remove_core(pdata, &pdev->dev, i);
+
+	device_remove_file(&pdev->dev, &pdata->name_attr);
+	hwmon_device_unregister(pdata->hwmon_dev);
 	platform_set_drvdata(pdev, NULL);
-	kfree(data);
+	kfree(pdata);
 	return 0;
 }
 
@@ -432,6 +580,96 @@ struct pdev_entry {
 static LIST_HEAD(pdev_list);
 static DEFINE_MUTEX(pdev_list_mutex);
 
+static struct platform_device *get_pdev(int phys_proc_id)
+{
+	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;
+}
+
+static int get_core_indx(struct platform_data *pdata, int core_id)
+{
+	int i;
+
+	for (i = 0; i < pdata->core_count; i++) {
+		if (pdata->core_data[i]->cpu_core_id = core_id &&
+			!pdata->core_data[i]->is_pkg_data)
+			return i;
+	}
+	return -ENODEV;
+}
+
+static void add_core(unsigned int cpu, int pkg_flag)
+{
+	int indx, err;
+	struct platform_data *pdata;
+	struct cpuinfo_x86 *c = &cpu_data(cpu);
+	struct platform_device *pdev = get_pdev(c->phys_proc_id);
+
+	if (!pdev)
+		return;
+
+	pdata = platform_get_drvdata(pdev);
+
+	/* If this core is a HT one, do not create any interfaces */
+	indx = get_core_indx(pdata, c->cpu_core_id);
+	if (indx >= 0) {
+		dev_info(&pdev->dev, "A HT core (%u) is onlined\n", cpu);
+		return;
+	}
+
+	err = create_core_data(pdata, pdev, cpu, pkg_flag);
+	if (err) {
+		dev_err(&pdev->dev, "Onlining Core %u on Pkg %d failed\n",
+			cpu, c->phys_proc_id);
+	}
+}
+
+static void remove_core(struct platform_data *pdata, struct device *dev,
+			int indx)
+{
+	int i;
+	int max = pdata->core_count - 1;
+
+	/* Remove all sysfs attrs for this core */
+	remove_attrs(dev, pdata->core_data[indx]);
+
+	/* Shift the core_data elements */
+	for (i = indx; i < max; i++)
+		pdata->core_data[i] = pdata->core_data[i + 1];
+
+	/* Free the _last_ element */
+	kfree(pdata->core_data[max]);
+	pdata->core_data[max] = NULL;
+
+	pdata->core_count--;
+
+	/*
+	 * If count is _only_ one and the device is pkg temp
+	 * remove those interfaces and get rid off this 'pdev' entry
+	 * in the pdev_entry list.
+	 *
+	 * The pkg temp is alive as long as atleast one of the
+	 * cores inside the pkg is online. And it is removed
+	 * when all cores in a pkg go offline.
+	 */
+	if (pdata->core_count = 1 && pdata->core_data[0]->is_pkg_data) {
+		remove_attrs(dev, pdata->core_data[0]);
+		kfree(pdata->core_data[0]);
+		pdata->core_data[0] = NULL;
+		pdata->core_count--;
+	}
+}
+
 static int __cpuinit coretemp_device_add(unsigned int cpu)
 {
 	int err;
@@ -503,28 +741,81 @@ exit:
 	return err;
 }
 
-static void __cpuinit coretemp_device_remove(unsigned int cpu)
+static void __cpuinit coretemp_device_remove(int phys_proc_id)
 {
 	struct pdev_entry *p;
-	unsigned int i;
 
 	mutex_lock(&pdev_list_mutex);
 	list_for_each_entry(p, &pdev_list, list) {
-		if (p->cpu != cpu)
+		if (p->phys_proc_id != phys_proc_id)
 			continue;
 
 		platform_device_unregister(p->pdev);
 		list_del(&p->list);
 		mutex_unlock(&pdev_list_mutex);
 		kfree(p);
-		for_each_cpu(i, cpu_sibling_mask(cpu))
-			if (i != cpu && !coretemp_device_add(i))
-				break;
 		return;
 	}
 	mutex_unlock(&pdev_list_mutex);
 }
 
+static void get_core_online(unsigned int cpu)
+{
+	struct cpuinfo_x86 *c = &cpu_data(cpu);
+	struct platform_device *pdev = get_pdev(c->phys_proc_id);
+
+	if (!pdev) {
+		/*
+		 * We are bringing the _first_ core in this pkg
+		 * online. So initialize per-pkg data structures and
+		 * then bring this core online.
+		 */
+		coretemp_device_add(cpu);
+		if (cpu_has(c, X86_FEATURE_PTS))
+			add_core(cpu, 1);
+	}
+	/*
+	 * Physical CPU device already exists.
+	 * So, just bring this core online.
+	 */
+	add_core(cpu, 0);
+}
+
+
+static void put_core_offline(unsigned int cpu)
+{
+	int indx;
+	struct platform_data *pdata;
+	struct cpuinfo_x86 *c = &cpu_data(cpu);
+	struct platform_device *pdev = get_pdev(c->phys_proc_id);
+
+	/* If the physical CPU device does not exist, just return */
+	if (!pdev)
+		return;
+
+	pdata = platform_get_drvdata(pdev);
+
+	indx = get_core_indx(pdata, c->cpu_core_id);
+	if (indx < 0) {
+		dev_info(&pdev->dev, "Core %d does not exist\n",
+			c->cpu_core_id);
+		return;
+	}
+
+	if (pdata->core_data[indx]->cpu = cpu)
+		remove_core(pdata, &pdev->dev, indx);
+	else
+		dev_info(&pdev->dev, "A HT CPU (%u) is offlined\n", cpu);
+
+	/*
+	 * If all cores in this pkg are offline,
+	 * remove this device from the pdev_entry list and
+	 * do pkg level clean ups
+	 */
+	if (pdata->core_count = 0)
+		coretemp_device_remove(c->phys_proc_id);
+}
+
 static int __cpuinit coretemp_cpu_callback(struct notifier_block *nfb,
 				 unsigned long action, void *hcpu)
 {
@@ -533,10 +824,10 @@ static int __cpuinit coretemp_cpu_callback(struct notifier_block *nfb,
 	switch (action) {
 	case CPU_ONLINE:
 	case CPU_DOWN_FAILED:
-		coretemp_device_add(cpu);
+		get_core_online(cpu);
 		break;
 	case CPU_DOWN_PREPARE:
-		coretemp_device_remove(cpu);
+		put_core_offline(cpu);
 		break;
 	}
 	return NOTIFY_OK;
@@ -546,6 +837,7 @@ static struct notifier_block coretemp_cpu_notifier __refdata = {
 	.notifier_call = coretemp_cpu_callback,
 };
 
+
 static int __init coretemp_init(void)
 {
 	int i, err = -ENODEV;
@@ -559,7 +851,7 @@ static int __init coretemp_init(void)
 		goto exit;
 
 	for_each_online_cpu(i)
-		coretemp_device_add(i);
+		get_core_online(i);
 
 #ifndef CONFIG_HOTPLUG_CPU
 	if (list_empty(&pdev_list)) {
-- 
1.7.4


_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[Guenter Roeck]

On Mon, Mar 07, 2011 at 03:14:20AM -0500, R, Durgadoss wrote:
> Hi Guenter,
> Ping..Any comments on this version of the patch ?
> 
> > -----Original Message-----
> > From: R, Durgadoss
> > Sent: Thursday, March 03, 2011 3:08 AM
> > To: guenter.roeck@ericsson.com; khali@linux-fr.org; Yu, Fenghua
> > Cc: lm-sensors@lm-sensors.org; R, Durgadoss
> > Subject: [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp
> >
> > This patch merges the pkgtemp driver with the coretemp driver.
> > This merged driver creates one hwmon device per physical CPU.
> >
> > Changes from v3 of this patch:
> > Added appropriate support for CONFIG_HOTPLUG_CPU.
> >

Problem is that you don't provide a complete changelog ... meaning I have no idea
if you addressed the crash problem I reported earlier, much less how you addressed 
it if you did. So I'll have to load the latest kernel on a machine and test your
patch with it. Then I'll have to compare this version of the patch with the previous
version to see if I find out what you may have changed to fix the crash condition.
And I'll have to do all that before I can actually start reviewing the patch itself.

In other words, you are loading a lot of work on me. I don't have the time for all this
right now, so you'll have to be patient.

Guenter

_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[R, Durgadoss]

Hi Guenter,

> > > Subject: [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp
> > >
> > > This patch merges the pkgtemp driver with the coretemp driver.
> > > This merged driver creates one hwmon device per physical CPU.
> > >
> > > Changes from v3 of this patch:
> > > Added appropriate support for CONFIG_HOTPLUG_CPU.
> > >
> 
> Problem is that you don't provide a complete changelog ... meaning I have no

I shall provide a complete changelog for all versions of this patch, from now on.

> if you addressed the crash problem I reported earlier, much less how you

I tested these patch sets on a Core i5 machine, I did not get any crash.
That's why I did not talk about this.
But If you can send me the crash logs,
I shall look into them and try to reproduce and see
What is going on .. 

> 
> In other words, you are loading a lot of work on me. I don't have the time for

Sorry for that.

> right now, so you'll have to be patient.

I tested these patch sets on some boards that I have.
Since I am too new to this, I do not know whether I covered all
Corner cases. There is a fair chance that something might break..
Hence, I would wait for these patches to be tested
and reviewed by you at your convenience.

Thanks,
Durga

_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[Yu, Fenghua]

> This patch merges the pkgtemp driver with the coretemp driver.
> This merged driver creates one hwmon device per physical CPU.
> 
> Changes from v3 of this patch:
> Added appropriate support for CONFIG_HOTPLUG_CPU.
> 
> Signed-off-by: Durgadoss R <durgadoss.r@intel.com>
> ---
>  drivers/hwmon/coretemp.c |  618 ++++++++++++++++++++++++++++++++++----
> --------
>  1 files changed, 455 insertions(+), 163 deletions(-)

You patch needs to remove pkgtemp.c file as well.

Please publish your test results on Sandybridge and non-Sandybridge.

Thanks.

-Fenghua

_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[Guenter Roeck]

On Mon, 2011-04-04 at 14:16 -0400, Yu, Fenghua wrote:
> > This patch merges the pkgtemp driver with the coretemp driver.
> > This merged driver creates one hwmon device per physical CPU.
> > 
> > Changes from v3 of this patch:
> > Added appropriate support for CONFIG_HOTPLUG_CPU.
> > 
> > Signed-off-by: Durgadoss R <durgadoss.r@intel.com>
> > ---
> >  drivers/hwmon/coretemp.c |  618 ++++++++++++++++++++++++++++++++++----
> > --------
> >  1 files changed, 455 insertions(+), 163 deletions(-)
> 
> You patch needs to remove pkgtemp.c file as well.
> 
That should be a separate patch.

Guenter

> Please publish your test results on Sandybridge and non-Sandybridge.
> 
> Thanks.
> 
> -Fenghua



_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[R, Durgadoss]

Hi Fenghua,

> -----Original Message-----
> From: Yu, Fenghua
> Sent: Monday, April 04, 2011 11:47 PM
> To: R, Durgadoss; guenter.roeck@ericsson.com; khali@linux-fr.org
> Cc: lm-sensors@lm-sensors.org
> Subject: RE: [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp
> 
> > This patch merges the pkgtemp driver with the coretemp driver.
> > This merged driver creates one hwmon device per physical CPU.
> >
> > Changes from v3 of this patch:
> > Added appropriate support for CONFIG_HOTPLUG_CPU.
> >
> > Signed-off-by: Durgadoss R <durgadoss.r@intel.com>
> > ---
> >  drivers/hwmon/coretemp.c |  618 ++++++++++++++++++++++++++++++++++----
> > --------
> >  1 files changed, 455 insertions(+), 163 deletions(-)
> 
> You patch needs to remove pkgtemp.c file as well.

I have this in mind. I was waiting for this patch to be reviewed thoroughly.
Then Shall send a 1/2 and 2/2 patches for this.

> 
> Please publish your test results on Sandybridge and non-Sandybridge.

I have test results on non-SandyBridge.
Looking for a Sandy-Bridge system to test the pkgtemp support.
Shall send both the logs in a couple of days.

Would be happy if anybody on the list can also test this
Patch on a SandyBridge.

Thanks,
Durga

_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [lm-sensors] [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp

[R, Durgadoss]

[-- Attachment #1: Type: text/plain, Size: 2137 bytes --]

Hi Fenghua,

I have attached the logs of the merged coretemp driver on
a SNB and non-SNB platform. Kindly review and let me know your
comments.
For me, the log indicates that the driver works fine.
Let me know your Ack/comments on the patch too.

[NON_SNB]
/sys/class/hwmon/hwmon0/device
---
modalias:platform:coretemp
name:coretemp
temp1_crit:105000
temp1_crit_alarm:0
temp1_input:23000
temp1_label:Core 0
temp1_max:89000
temp2_crit:105000
temp2_crit_alarm:0
temp2_input:25000
temp2_label:Core 2
temp2_max:89000
uevent:DRIVER=coretemp
uevent:MODALIAS=platform:coretemp

[SNB-With PKG Support]
/sys/class/hwmon/hwmon1/device
---
modalias:platform:coretemp
name:coretemp
temp1_crit:100000
temp1_crit_alarm:0
temp1_input:37000
temp1_label:Physical id 0
temp1_max:86000
temp2_crit:100000
temp2_crit_alarm:0
temp2_input:30000
temp2_label:Core 0
temp2_max:86000
temp3_crit:100000
temp3_crit_alarm:0
temp3_input:37000
temp3_label:Core 1
temp3_max:86000
temp4_crit:100000
temp4_crit_alarm:0
temp4_input:29000
temp4_label:Core 2
temp4_max:86000
temp5_crit:100000
temp5_crit_alarm:0
temp5_input:36000
temp5_label:Core 3
temp5_max:86000
uevent:DRIVER=coretemp
uevent:MODALIAS=platform:coretemp

Thanks,
Durga

> -----Original Message-----
> From: Yu, Fenghua
> Sent: Monday, April 04, 2011 11:47 PM
> To: R, Durgadoss; guenter.roeck@ericsson.com; khali@linux-fr.org
> Cc: lm-sensors@lm-sensors.org
> Subject: RE: [PATCH:hwmon:v4:]Merging_pkgtemp_with_coretemp
> 
> > This patch merges the pkgtemp driver with the coretemp driver.
> > This merged driver creates one hwmon device per physical CPU.
> >
> > Changes from v3 of this patch:
> > Added appropriate support for CONFIG_HOTPLUG_CPU.
> >
> > Signed-off-by: Durgadoss R <durgadoss.r@intel.com>
> > ---
> >  drivers/hwmon/coretemp.c |  618 ++++++++++++++++++++++++++++++++++----
> > --------
> >  1 files changed, 455 insertions(+), 163 deletions(-)
> 
> You patch needs to remove pkgtemp.c file as well.
> 
> Please publish your test results on Sandybridge and non-Sandybridge.
> 
> Thanks.
> 
> -Fenghua

[-- Attachment #2: non_snb_coretemp.log --]
[-- Type: application/octet-stream, Size: 313 bytes --]

/sys/class/hwmon/hwmon0/device
---
modalias:platform:coretemp
name:coretemp
temp1_crit:105000
temp1_crit_alarm:0
temp1_input:23000
temp1_label:Core 0
temp1_max:89000
temp2_crit:105000
temp2_crit_alarm:0
temp2_input:25000
temp2_label:Core 2
temp2_max:89000
uevent:DRIVER=coretemp
uevent:MODALIAS=platform:coretemp

[-- Attachment #3: snb_coretemp.log --]
[-- Type: application/octet-stream, Size: 590 bytes --]

/sys/class/hwmon/hwmon1/device
---
modalias:platform:coretemp
name:coretemp
temp1_crit:100000
temp1_crit_alarm:0
temp1_input:37000
temp1_label:Physical id 0
temp1_max:86000
temp2_crit:100000
temp2_crit_alarm:0
temp2_input:30000
temp2_label:Core 0
temp2_max:86000
temp3_crit:100000
temp3_crit_alarm:0
temp3_input:37000
temp3_label:Core 1
temp3_max:86000
temp4_crit:100000
temp4_crit_alarm:0
temp4_input:29000
temp4_label:Core 2
temp4_max:86000
temp5_crit:100000
temp5_crit_alarm:0
temp5_input:36000
temp5_label:Core 3
temp5_max:86000
uevent:DRIVER=coretemp
uevent:MODALIAS=platform:coretemp

[-- Attachment #4: Type: text/plain, Size: 153 bytes --]

_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors