Hi Fenghua, Could you please let us know your comments on this patch ? Thanks, Durga > -----Original Message----- > From: lm-sensors-bounces@xxxxxxxxxxxxxx [mailto:lm-sensors-bounces@lm- > sensors.org] On Behalf Of R, Durgadoss > Sent: Friday, March 25, 2011 6:34 PM > To: Guenter Roeck; lm-sensors@xxxxxxxxxxxxxx > Subject: [PATCH:hwmon:v4:Resend]Merging_pkgtemp_with_coretemp > > Hi Guenter, > > This patch merges the pkgtemp driver with the coretemp driver. > This merged driver creates one hwmon device per physical CPU i.e > per Physical Package. Also, the sysfs interfaces per core are created > as each core comes online and removed when it goes offline. > > v1 of this patch: > Basic Merging of pkgtemp with coretemp. This creates one hwmon device > per core. > v2 of this patch: > Fixed some Data structure related comments from v1. This also > creates one hwmon device per core. > v3 of this patch: > This version creates one hwmon device per physical package, but > no appropriate support for CPU hotplug. > v4 of this patch: > This creates one hwmon device per package. > Added appropriate support for CONFIG_HOTPLUG_CPU. > > --- > From: Durgadoss R <durgadoss.r@xxxxxxxxx> > > Date: Thu, 3 Mar 2011 02:37:40 +0530 > Subject: [PATCH:hwmon:v4:Resend]Merging_pkgtemp_with_coretemp > > This patch merges the pkgtemp driver with the coretemp driver. > This merged driver creates one hwmon device per physical CPU i.e > per Physical Package. Also, the sysfs interfaces per core are created > as each core comes online and removed when it goes offline. > > Signed-off-by: Durgadoss R <durgadoss.r@xxxxxxxxx> > > --- > 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@xxxxxxxxxxxxxx http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
