← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-omap/trusty

« back to all changes in this revision

Viewing changes to drivers/hwmon/coretemp.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-57i0gl3v99b3lkfg
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hwmon/coretemp.c
35
35
#include <linux/platform_device.h>
36
36
#include <linux/cpu.h>
37
37
#include <linux/pci.h>
 
38
#include <linux/smp.h>
38
39
#include <asm/msr.h>
39
40
#include <asm/processor.h>
40
 
#include <asm/smp.h>
41
41
 
42
42
#define DRVNAME "coretemp"
43
43
 
44
 
typedef enum { SHOW_TEMP, SHOW_TJMAX, SHOW_TTARGET, SHOW_LABEL,
45
 
                SHOW_NAME } SHOW;
 
44
#define BASE_SYSFS_ATTR_NO      2       /* Sysfs Base attr no for coretemp */
 
45
#define NUM_REAL_CORES          16      /* Number of Real cores per cpu */
 
46
#define CORETEMP_NAME_LENGTH    17      /* String Length of attrs */
 
47
#define MAX_ATTRS               5       /* Maximum no of per-core attrs */
 
48
#define MAX_CORE_DATA           (NUM_REAL_CORES + BASE_SYSFS_ATTR_NO)
 
49
 
 
50
#ifdef CONFIG_SMP
 
51
#define TO_PHYS_ID(cpu)         cpu_data(cpu).phys_proc_id
 
52
#define TO_CORE_ID(cpu)         cpu_data(cpu).cpu_core_id
 
53
#define TO_ATTR_NO(cpu)         (TO_CORE_ID(cpu) + BASE_SYSFS_ATTR_NO)
 
54
#define for_each_sibling(i, cpu)        for_each_cpu(i, cpu_sibling_mask(cpu))
 
55
#else
 
56
#define TO_PHYS_ID(cpu)         (cpu)
 
57
#define TO_CORE_ID(cpu)         (cpu)
 
58
#define TO_ATTR_NO(cpu)         (cpu)
 
59
#define for_each_sibling(i, cpu)        for (i = 0; false; )
 
60
#endif
46
61
 
47
62
/*
48
 
 * Functions declaration
 
63
 * Per-Core Temperature Data
 
64
 * @last_updated: The time when the current temperature value was updated
 
65
 *              earlier (in jiffies).
 
66
 * @cpu_core_id: The CPU Core from which temperature values should be read
 
67
 *              This value is passed as "id" field to rdmsr/wrmsr functions.
 
68
 * @status_reg: One of IA32_THERM_STATUS or IA32_PACKAGE_THERM_STATUS,
 
69
 *              from where the temperature values should be read.
 
70
 * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
 
71
 *              Otherwise, temp_data holds coretemp data.
 
72
 * @valid: If this is 1, the current temperature is valid.
49
73
 */
50
 
 
51
 
static struct coretemp_data *coretemp_update_device(struct device *dev);
52
 
 
53
 
struct coretemp_data {
54
 
        struct device *hwmon_dev;
55
 
        struct mutex update_lock;
56
 
        const char *name;
57
 
        u32 id;
58
 
        u16 core_id;
59
 
        char valid;             /* zero until following fields are valid */
60
 
        unsigned long last_updated;     /* in jiffies */
 
74
struct temp_data {
61
75
        int temp;
 
76
        int ttarget;
62
77
        int tjmax;
63
 
        int ttarget;
64
 
        u8 alarm;
65
 
};
66
 
 
67
 
/*
68
 
 * Sysfs stuff
69
 
 */
70
 
 
71
 
static ssize_t show_name(struct device *dev, struct device_attribute
72
 
                          *devattr, char *buf)
73
 
{
74
 
        int ret;
75
 
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
76
 
        struct coretemp_data *data = dev_get_drvdata(dev);
77
 
 
78
 
        if (attr->index == SHOW_NAME)
79
 
                ret = sprintf(buf, "%s\n", data->name);
80
 
        else    /* show label */
81
 
                ret = sprintf(buf, "Core %d\n", data->core_id);
82
 
        return ret;
83
 
}
84
 
 
85
 
static ssize_t show_alarm(struct device *dev, struct device_attribute
86
 
                          *devattr, char *buf)
87
 
{
88
 
        struct coretemp_data *data = coretemp_update_device(dev);
89
 
        /* read the Out-of-spec log, never clear */
90
 
        return sprintf(buf, "%d\n", data->alarm);
 
78
        unsigned long last_updated;
 
79
        unsigned int cpu;
 
80
        u32 cpu_core_id;
 
81
        u32 status_reg;
 
82
        bool is_pkg_data;
 
83
        bool valid;
 
84
        struct sensor_device_attribute sd_attrs[MAX_ATTRS];
 
85
        char attr_name[MAX_ATTRS][CORETEMP_NAME_LENGTH];
 
86
        struct mutex update_lock;
 
87
};
 
88
 
 
89
/* Platform Data per Physical CPU */
 
90
struct platform_data {
 
91
        struct device *hwmon_dev;
 
92
        u16 phys_proc_id;
 
93
        struct temp_data *core_data[MAX_CORE_DATA];
 
94
        struct device_attribute name_attr;
 
95
};
 
96
 
 
97
struct pdev_entry {
 
98
        struct list_head list;
 
99
        struct platform_device *pdev;
 
100
        u16 phys_proc_id;
 
101
};
 
102
 
 
103
static LIST_HEAD(pdev_list);
 
104
static DEFINE_MUTEX(pdev_list_mutex);
 
105
 
 
106
static ssize_t show_name(struct device *dev,
 
107
                        struct device_attribute *devattr, char *buf)
 
108
{
 
109
        return sprintf(buf, "%s\n", DRVNAME);
 
110
}
 
111
 
 
112
static ssize_t show_label(struct device *dev,
 
113
                                struct device_attribute *devattr, char *buf)
 
114
{
 
115
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 
116
        struct platform_data *pdata = dev_get_drvdata(dev);
 
117
        struct temp_data *tdata = pdata->core_data[attr->index];
 
118
 
 
119
        if (tdata->is_pkg_data)
 
120
                return sprintf(buf, "Physical id %u\n", pdata->phys_proc_id);
 
121
 
 
122
        return sprintf(buf, "Core %u\n", tdata->cpu_core_id);
 
123
}
 
124
 
 
125
static ssize_t show_crit_alarm(struct device *dev,
 
126
                                struct device_attribute *devattr, char *buf)
 
127
{
 
128
        u32 eax, edx;
 
129
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 
130
        struct platform_data *pdata = dev_get_drvdata(dev);
 
131
        struct temp_data *tdata = pdata->core_data[attr->index];
 
132
 
 
133
        rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
 
134
 
 
135
        return sprintf(buf, "%d\n", (eax >> 5) & 1);
 
136
}
 
137
 
 
138
static ssize_t show_tjmax(struct device *dev,
 
139
                        struct device_attribute *devattr, char *buf)
 
140
{
 
141
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 
142
        struct platform_data *pdata = dev_get_drvdata(dev);
 
143
 
 
144
        return sprintf(buf, "%d\n", pdata->core_data[attr->index]->tjmax);
 
145
}
 
146
 
 
147
static ssize_t show_ttarget(struct device *dev,
 
148
                                struct device_attribute *devattr, char *buf)
 
149
{
 
150
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 
151
        struct platform_data *pdata = dev_get_drvdata(dev);
 
152
 
 
153
        return sprintf(buf, "%d\n", pdata->core_data[attr->index]->ttarget);
91
154
}
92
155
 
93
156
static ssize_t show_temp(struct device *dev,
94
 
                         struct device_attribute *devattr, char *buf)
 
157
                        struct device_attribute *devattr, char *buf)
95
158
{
 
159
        u32 eax, edx;
96
160
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
97
 
        struct coretemp_data *data = coretemp_update_device(dev);
98
 
        int err;
99
 
 
100
 
        if (attr->index == SHOW_TEMP)
101
 
                err = data->valid ? sprintf(buf, "%d\n", data->temp) : -EAGAIN;
102
 
        else if (attr->index == SHOW_TJMAX)
103
 
                err = sprintf(buf, "%d\n", data->tjmax);
104
 
        else
105
 
                err = sprintf(buf, "%d\n", data->ttarget);
106
 
        return err;
107
 
}
108
 
 
109
 
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL,
110
 
                          SHOW_TEMP);
111
 
static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL,
112
 
                          SHOW_TJMAX);
113
 
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp, NULL,
114
 
                          SHOW_TTARGET);
115
 
static DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL);
116
 
static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_name, NULL, SHOW_LABEL);
117
 
static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, SHOW_NAME);
118
 
 
119
 
static struct attribute *coretemp_attributes[] = {
120
 
        &sensor_dev_attr_name.dev_attr.attr,
121
 
        &sensor_dev_attr_temp1_label.dev_attr.attr,
122
 
        &dev_attr_temp1_crit_alarm.attr,
123
 
        &sensor_dev_attr_temp1_input.dev_attr.attr,
124
 
        &sensor_dev_attr_temp1_crit.dev_attr.attr,
125
 
        NULL
126
 
};
127
 
 
128
 
static const struct attribute_group coretemp_group = {
129
 
        .attrs = coretemp_attributes,
130
 
};
131
 
 
132
 
static struct coretemp_data *coretemp_update_device(struct device *dev)
133
 
{
134
 
        struct coretemp_data *data = dev_get_drvdata(dev);
135
 
 
136
 
        mutex_lock(&data->update_lock);
137
 
 
138
 
        if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
139
 
                u32 eax, edx;
140
 
 
141
 
                data->valid = 0;
142
 
                rdmsr_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
143
 
                data->alarm = (eax >> 5) & 1;
144
 
                /* update only if data has been valid */
 
161
        struct platform_data *pdata = dev_get_drvdata(dev);
 
162
        struct temp_data *tdata = pdata->core_data[attr->index];
 
163
 
 
164
        mutex_lock(&tdata->update_lock);
 
165
 
 
166
        /* Check whether the time interval has elapsed */
 
167
        if (!tdata->valid || time_after(jiffies, tdata->last_updated + HZ)) {
 
168
                rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
 
169
                tdata->valid = 0;
 
170
                /* Check whether the data is valid */
145
171
                if (eax & 0x80000000) {
146
 
                        data->temp = data->tjmax - (((eax >> 16)
147
 
                                                        & 0x7f) * 1000);
148
 
                        data->valid = 1;
149
 
                } else {
150
 
                        dev_dbg(dev, "Temperature data invalid (0x%x)\n", eax);
 
172
                        tdata->temp = tdata->tjmax -
 
173
                                        ((eax >> 16) & 0x7f) * 1000;
 
174
                        tdata->valid = 1;
151
175
                }
152
 
                data->last_updated = jiffies;
 
176
                tdata->last_updated = jiffies;
153
177
        }
154
178
 
155
 
        mutex_unlock(&data->update_lock);
156
 
        return data;
 
179
        mutex_unlock(&tdata->update_lock);
 
180
        return tdata->valid ? sprintf(buf, "%d\n", tdata->temp) : -EAGAIN;
157
181
}
158
182
 
159
 
static int __devinit adjust_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
 
183
static int adjust_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
160
184
{
161
185
        /* The 100C is default for both mobile and non mobile CPUs */
162
186
 
169
193
 
170
194
        /* Early chips have no MSR for TjMax */
171
195
 
172
 
        if ((c->x86_model == 0xf) && (c->x86_mask < 4)) {
 
196
        if (c->x86_model == 0xf && c->x86_mask < 4)
173
197
                usemsr_ee = 0;
174
 
        }
175
198
 
176
199
        /* Atom CPUs */
177
200
 
190
213
                pci_dev_put(host_bridge);
191
214
        }
192
215
 
193
 
        if ((c->x86_model > 0xe) && (usemsr_ee)) {
 
216
        if (c->x86_model > 0xe && usemsr_ee) {
194
217
                u8 platform_id;
195
218
 
196
 
                /* Now we can detect the mobile CPU using Intel provided table
197
 
                   http://softwarecommunity.intel.com/Wiki/Mobility/720.htm
198
 
                   For Core2 cores, check MSR 0x17, bit 28 1 = Mobile CPU
199
 
                */
200
 
 
 
219
                /*
 
220
                 * Now we can detect the mobile CPU using Intel provided table
 
221
                 * http://softwarecommunity.intel.com/Wiki/Mobility/720.htm
 
222
                 * For Core2 cores, check MSR 0x17, bit 28 1 = Mobile CPU
 
223
                 */
201
224
                err = rdmsr_safe_on_cpu(id, 0x17, &eax, &edx);
202
225
                if (err) {
203
226
                        dev_warn(dev,
205
228
                                 " CPU\n");
206
229
                        usemsr_ee = 0;
207
230
                } else if (c->x86_model < 0x17 && !(eax & 0x10000000)) {
208
 
                        /* Trust bit 28 up to Penryn, I could not find any
209
 
                           documentation on that; if you happen to know
210
 
                           someone at Intel please ask */
 
231
                        /*
 
232
                         * Trust bit 28 up to Penryn, I could not find any
 
233
                         * documentation on that; if you happen to know
 
234
                         * someone at Intel please ask
 
235
                         */
211
236
                        usemsr_ee = 0;
212
237
                } else {
213
238
                        /* Platform ID bits 52:50 (EDX starts at bit 32) */
214
239
                        platform_id = (edx >> 18) & 0x7;
215
240
 
216
 
                        /* Mobile Penryn CPU seems to be platform ID 7 or 5
217
 
                          (guesswork) */
218
 
                        if ((c->x86_model == 0x17) &&
219
 
                            ((platform_id == 5) || (platform_id == 7))) {
220
 
                                /* If MSR EE bit is set, set it to 90 degrees C,
221
 
                                   otherwise 105 degrees C */
 
241
                        /*
 
242
                         * Mobile Penryn CPU seems to be platform ID 7 or 5
 
243
                         * (guesswork)
 
244
                         */
 
245
                        if (c->x86_model == 0x17 &&
 
246
                            (platform_id == 5 || platform_id == 7)) {
 
247
                                /*
 
248
                                 * If MSR EE bit is set, set it to 90 degrees C,
 
249
                                 * otherwise 105 degrees C
 
250
                                 */
222
251
                                tjmax_ee = 90000;
223
252
                                tjmax = 105000;
224
253
                        }
226
255
        }
227
256
 
228
257
        if (usemsr_ee) {
229
 
 
230
258
                err = rdmsr_safe_on_cpu(id, 0xee, &eax, &edx);
231
259
                if (err) {
232
260
                        dev_warn(dev,
235
263
                } else if (eax & 0x40000000) {
236
264
                        tjmax = tjmax_ee;
237
265
                }
238
 
        /* if we dont use msr EE it means we are desktop CPU (with exeception
239
 
           of Atom) */
240
266
        } else if (tjmax == 100000) {
 
267
                /*
 
268
                 * If we don't use msr EE it means we are desktop CPU
 
269
                 * (with exeception of Atom)
 
270
                 */
241
271
                dev_warn(dev, "Using relative temperature scale!\n");
242
272
        }
243
273
 
244
274
        return tjmax;
245
275
}
246
276
 
247
 
static int __devinit get_tjmax(struct cpuinfo_x86 *c, u32 id,
248
 
                               struct device *dev)
 
277
static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
249
278
{
250
279
        /* The 100C is default for both mobile and non mobile CPUs */
251
280
        int err;
252
281
        u32 eax, edx;
253
282
        u32 val;
254
283
 
255
 
        /* A new feature of current Intel(R) processors, the
256
 
           IA32_TEMPERATURE_TARGET contains the TjMax value */
 
284
        /*
 
285
         * A new feature of current Intel(R) processors, the
 
286
         * IA32_TEMPERATURE_TARGET contains the TjMax value
 
287
         */
257
288
        err = rdmsr_safe_on_cpu(id, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
258
289
        if (err) {
259
290
                dev_warn(dev, "Unable to read TjMax from CPU.\n");
263
294
                 * If the TjMax is not plausible, an assumption
264
295
                 * will be used
265
296
                 */
266
 
                if ((val > 80) && (val < 120)) {
 
297
                if (val) {
267
298
                        dev_info(dev, "TjMax is %d C.\n", val);
268
299
                        return val * 1000;
269
300
                }
271
302
 
272
303
        /*
273
304
         * An assumption is made for early CPUs and unreadable MSR.
274
 
         * NOTE: the given value may not be correct.
 
305
         * NOTE: the calculated value may not be correct.
275
306
         */
276
 
 
277
 
        switch (c->x86_model) {
278
 
        case 0xe:
279
 
        case 0xf:
280
 
        case 0x16:
281
 
        case 0x1a:
282
 
                dev_warn(dev, "TjMax is assumed as 100 C!\n");
283
 
                return 100000;
284
 
        case 0x17:
285
 
        case 0x1c:              /* Atom CPUs */
286
 
                return adjust_tjmax(c, id, dev);
287
 
        default:
288
 
                dev_warn(dev, "CPU (model=0x%x) is not supported yet,"
289
 
                        " using default TjMax of 100C.\n", c->x86_model);
290
 
                return 100000;
291
 
        }
 
307
        return adjust_tjmax(c, id, dev);
292
308
}
293
309
 
294
310
static void __devinit get_ucode_rev_on_cpu(void *edx)
300
316
        rdmsr(MSR_IA32_UCODE_REV, eax, *(u32 *)edx);
301
317
}
302
318
 
303
 
static int __devinit coretemp_probe(struct platform_device *pdev)
304
 
{
305
 
        struct coretemp_data *data;
 
319
static int get_pkg_tjmax(unsigned int cpu, struct device *dev)
 
320
{
 
321
        int err;
 
322
        u32 eax, edx, val;
 
323
 
 
324
        err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
 
325
        if (!err) {
 
326
                val = (eax >> 16) & 0xff;
 
327
                if (val)
 
328
                        return val * 1000;
 
329
        }
 
330
        dev_warn(dev, "Unable to read Pkg-TjMax from CPU:%u\n", cpu);
 
331
        return 100000; /* Default TjMax: 100 degree celsius */
 
332
}
 
333
 
 
334
static int create_name_attr(struct platform_data *pdata, struct device *dev)
 
335
{
 
336
        sysfs_attr_init(&pdata->name_attr.attr);
 
337
        pdata->name_attr.attr.name = "name";
 
338
        pdata->name_attr.attr.mode = S_IRUGO;
 
339
        pdata->name_attr.show = show_name;
 
340
        return device_create_file(dev, &pdata->name_attr);
 
341
}
 
342
 
 
343
static int create_core_attrs(struct temp_data *tdata, struct device *dev,
 
344
                                int attr_no)
 
345
{
 
346
        int err, i;
 
347
        static ssize_t (*rd_ptr[MAX_ATTRS]) (struct device *dev,
 
348
                        struct device_attribute *devattr, char *buf) = {
 
349
                        show_label, show_crit_alarm, show_ttarget,
 
350
                        show_temp, show_tjmax };
 
351
        static const char *names[MAX_ATTRS] = {
 
352
                                        "temp%d_label", "temp%d_crit_alarm",
 
353
                                        "temp%d_max", "temp%d_input",
 
354
                                        "temp%d_crit" };
 
355
 
 
356
        for (i = 0; i < MAX_ATTRS; i++) {
 
357
                snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH, names[i],
 
358
                        attr_no);
 
359
                sysfs_attr_init(&tdata->sd_attrs[i].dev_attr.attr);
 
360
                tdata->sd_attrs[i].dev_attr.attr.name = tdata->attr_name[i];
 
361
                tdata->sd_attrs[i].dev_attr.attr.mode = S_IRUGO;
 
362
                tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
 
363
                tdata->sd_attrs[i].dev_attr.store = NULL;
 
364
                tdata->sd_attrs[i].index = attr_no;
 
365
                err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
 
366
                if (err)
 
367
                        goto exit_free;
 
368
        }
 
369
        return 0;
 
370
 
 
371
exit_free:
 
372
        while (--i >= 0)
 
373
                device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
 
374
        return err;
 
375
}
 
376
 
 
377
static void update_ttarget(__u8 cpu_model, struct temp_data *tdata,
 
378
                                struct device *dev)
 
379
{
 
380
        int err;
 
381
        u32 eax, edx;
 
382
 
 
383
        /*
 
384
         * Initialize ttarget value. Eventually this will be
 
385
         * initialized with the value from MSR_IA32_THERM_INTERRUPT
 
386
         * register. If IA32_TEMPERATURE_TARGET is supported, this
 
387
         * value will be over written below.
 
388
         * To Do: Patch to initialize ttarget from MSR_IA32_THERM_INTERRUPT
 
389
         */
 
390
        tdata->ttarget = tdata->tjmax - 20000;
 
391
 
 
392
        /*
 
393
         * Read the still undocumented IA32_TEMPERATURE_TARGET. It exists
 
394
         * on older CPUs but not in this register,
 
395
         * Atoms don't have it either.
 
396
         */
 
397
        if (cpu_model > 0xe && cpu_model != 0x1c) {
 
398
                err = rdmsr_safe_on_cpu(tdata->cpu,
 
399
                                MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
 
400
                if (err) {
 
401
                        dev_warn(dev,
 
402
                        "Unable to read IA32_TEMPERATURE_TARGET MSR\n");
 
403
                } else {
 
404
                        tdata->ttarget = tdata->tjmax -
 
405
                                        ((eax >> 8) & 0xff) * 1000;
 
406
                }
 
407
        }
 
408
}
 
409
 
 
410
static int __devinit chk_ucode_version(struct platform_device *pdev)
 
411
{
306
412
        struct cpuinfo_x86 *c = &cpu_data(pdev->id);
307
413
        int err;
308
 
        u32 eax, edx;
309
 
 
310
 
        if (!(data = kzalloc(sizeof(struct coretemp_data), GFP_KERNEL))) {
311
 
                err = -ENOMEM;
312
 
                dev_err(&pdev->dev, "Out of memory\n");
313
 
                goto exit;
314
 
        }
315
 
 
316
 
        data->id = pdev->id;
317
 
#ifdef CONFIG_SMP
318
 
        data->core_id = c->cpu_core_id;
319
 
#endif
320
 
        data->name = "coretemp";
321
 
        mutex_init(&data->update_lock);
322
 
 
323
 
        /* test if we can access the THERM_STATUS MSR */
324
 
        err = rdmsr_safe_on_cpu(data->id, MSR_IA32_THERM_STATUS, &eax, &edx);
325
 
        if (err) {
326
 
                dev_err(&pdev->dev,
327
 
                        "Unable to access THERM_STATUS MSR, giving up\n");
328
 
                goto exit_free;
329
 
        }
330
 
 
331
 
        /* Check if we have problem with errata AE18 of Core processors:
332
 
           Readings might stop update when processor visited too deep sleep,
333
 
           fixed for stepping D0 (6EC).
334
 
        */
335
 
 
336
 
        if ((c->x86_model == 0xe) && (c->x86_mask < 0xc)) {
 
414
        u32 edx;
 
415
 
 
416
        /*
 
417
         * Check if we have problem with errata AE18 of Core processors:
 
418
         * Readings might stop update when processor visited too deep sleep,
 
419
         * fixed for stepping D0 (6EC).
 
420
         */
 
421
        if (c->x86_model == 0xe && c->x86_mask < 0xc) {
337
422
                /* check for microcode update */
338
 
                err = smp_call_function_single(data->id, get_ucode_rev_on_cpu,
 
423
                err = smp_call_function_single(pdev->id, get_ucode_rev_on_cpu,
339
424
                                               &edx, 1);
340
425
                if (err) {
341
426
                        dev_err(&pdev->dev,
342
427
                                "Cannot determine microcode revision of "
343
 
                                "CPU#%u (%d)!\n", data->id, err);
344
 
                        err = -ENODEV;
345
 
                        goto exit_free;
 
428
                                "CPU#%u (%d)!\n", pdev->id, err);
 
429
                        return -ENODEV;
346
430
                } else if (edx < 0x39) {
347
 
                        err = -ENODEV;
348
431
                        dev_err(&pdev->dev,
349
432
                                "Errata AE18 not fixed, update BIOS or "
350
433
                                "microcode of the CPU!\n");
351
 
                        goto exit_free;
352
 
                }
353
 
        }
354
 
 
355
 
        data->tjmax = get_tjmax(c, data->id, &pdev->dev);
356
 
        platform_set_drvdata(pdev, data);
357
 
 
358
 
        /*
359
 
         * read the still undocumented IA32_TEMPERATURE_TARGET. It exists
360
 
         * on older CPUs but not in this register,
361
 
         * Atoms don't have it either.
362
 
         */
363
 
 
364
 
        if ((c->x86_model > 0xe) && (c->x86_model != 0x1c)) {
365
 
                err = rdmsr_safe_on_cpu(data->id, MSR_IA32_TEMPERATURE_TARGET,
366
 
                    &eax, &edx);
367
 
                if (err) {
368
 
                        dev_warn(&pdev->dev, "Unable to read"
369
 
                                        " IA32_TEMPERATURE_TARGET MSR\n");
370
 
                } else {
371
 
                        data->ttarget = data->tjmax -
372
 
                                        (((eax >> 8) & 0xff) * 1000);
373
 
                        err = device_create_file(&pdev->dev,
374
 
                                        &sensor_dev_attr_temp1_max.dev_attr);
375
 
                        if (err)
376
 
                                goto exit_free;
377
 
                }
378
 
        }
379
 
 
380
 
        if ((err = sysfs_create_group(&pdev->dev.kobj, &coretemp_group)))
381
 
                goto exit_dev;
382
 
 
383
 
        data->hwmon_dev = hwmon_device_register(&pdev->dev);
384
 
        if (IS_ERR(data->hwmon_dev)) {
385
 
                err = PTR_ERR(data->hwmon_dev);
386
 
                dev_err(&pdev->dev, "Class registration failed (%d)\n",
387
 
                        err);
388
 
                goto exit_class;
389
 
        }
390
 
 
391
 
        return 0;
392
 
 
393
 
exit_class:
394
 
        sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
395
 
exit_dev:
396
 
        device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
397
 
exit_free:
398
 
        kfree(data);
399
 
exit:
 
434
                        return -ENODEV;
 
435
                }
 
436
        }
 
437
        return 0;
 
438
}
 
439
 
 
440
static struct platform_device *coretemp_get_pdev(unsigned int cpu)
 
441
{
 
442
        u16 phys_proc_id = TO_PHYS_ID(cpu);
 
443
        struct pdev_entry *p;
 
444
 
 
445
        mutex_lock(&pdev_list_mutex);
 
446
 
 
447
        list_for_each_entry(p, &pdev_list, list)
 
448
                if (p->phys_proc_id == phys_proc_id) {
 
449
                        mutex_unlock(&pdev_list_mutex);
 
450
                        return p->pdev;
 
451
                }
 
452
 
 
453
        mutex_unlock(&pdev_list_mutex);
 
454
        return NULL;
 
455
}
 
456
 
 
457
static struct temp_data *init_temp_data(unsigned int cpu, int pkg_flag)
 
458
{
 
459
        struct temp_data *tdata;
 
460
 
 
461
        tdata = kzalloc(sizeof(struct temp_data), GFP_KERNEL);
 
462
        if (!tdata)
 
463
                return NULL;
 
464
 
 
465
        tdata->status_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_STATUS :
 
466
                                                        MSR_IA32_THERM_STATUS;
 
467
        tdata->is_pkg_data = pkg_flag;
 
468
        tdata->cpu = cpu;
 
469
        tdata->cpu_core_id = TO_CORE_ID(cpu);
 
470
        mutex_init(&tdata->update_lock);
 
471
        return tdata;
 
472
}
 
473
 
 
474
static int create_core_data(struct platform_data *pdata,
 
475
                                struct platform_device *pdev,
 
476
                                unsigned int cpu, int pkg_flag)
 
477
{
 
478
        struct temp_data *tdata;
 
479
        struct cpuinfo_x86 *c = &cpu_data(cpu);
 
480
        u32 eax, edx;
 
481
        int err, attr_no;
 
482
 
 
483
        /*
 
484
         * Find attr number for sysfs:
 
485
         * We map the attr number to core id of the CPU
 
486
         * The attr number is always core id + 2
 
487
         * The Pkgtemp will always show up as temp1_*, if available
 
488
         */
 
489
        attr_no = pkg_flag ? 1 : TO_ATTR_NO(cpu);
 
490
 
 
491
        if (attr_no > MAX_CORE_DATA - 1)
 
492
                return -ERANGE;
 
493
 
 
494
        /*
 
495
         * Provide a single set of attributes for all HT siblings of a core
 
496
         * to avoid duplicate sensors (the processor ID and core ID of all
 
497
         * HT siblings of a core are the same).
 
498
         * Skip if a HT sibling of this core is already registered.
 
499
         * This is not an error.
 
500
         */
 
501
        if (pdata->core_data[attr_no] != NULL)
 
502
                return 0;
 
503
 
 
504
        tdata = init_temp_data(cpu, pkg_flag);
 
505
        if (!tdata)
 
506
                return -ENOMEM;
 
507
 
 
508
        /* Test if we can access the status register */
 
509
        err = rdmsr_safe_on_cpu(cpu, tdata->status_reg, &eax, &edx);
 
510
        if (err)
 
511
                goto exit_free;
 
512
 
 
513
        /* We can access status register. Get Critical Temperature */
 
514
        if (pkg_flag)
 
515
                tdata->tjmax = get_pkg_tjmax(pdev->id, &pdev->dev);
 
516
        else
 
517
                tdata->tjmax = get_tjmax(c, cpu, &pdev->dev);
 
518
 
 
519
        update_ttarget(c->x86_model, tdata, &pdev->dev);
 
520
        pdata->core_data[attr_no] = tdata;
 
521
 
 
522
        /* Create sysfs interfaces */
 
523
        err = create_core_attrs(tdata, &pdev->dev, attr_no);
 
524
        if (err)
 
525
                goto exit_free;
 
526
 
 
527
        return 0;
 
528
exit_free:
 
529
        kfree(tdata);
 
530
        return err;
 
531
}
 
532
 
 
533
static void coretemp_add_core(unsigned int cpu, int pkg_flag)
 
534
{
 
535
        struct platform_data *pdata;
 
536
        struct platform_device *pdev = coretemp_get_pdev(cpu);
 
537
        int err;
 
538
 
 
539
        if (!pdev)
 
540
                return;
 
541
 
 
542
        pdata = platform_get_drvdata(pdev);
 
543
 
 
544
        err = create_core_data(pdata, pdev, cpu, pkg_flag);
 
545
        if (err)
 
546
                dev_err(&pdev->dev, "Adding Core %u failed\n", cpu);
 
547
}
 
548
 
 
549
static void coretemp_remove_core(struct platform_data *pdata,
 
550
                                struct device *dev, int indx)
 
551
{
 
552
        int i;
 
553
        struct temp_data *tdata = pdata->core_data[indx];
 
554
 
 
555
        /* Remove the sysfs attributes */
 
556
        for (i = 0; i < MAX_ATTRS; i++)
 
557
                device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
 
558
 
 
559
        kfree(pdata->core_data[indx]);
 
560
        pdata->core_data[indx] = NULL;
 
561
}
 
562
 
 
563
static int __devinit coretemp_probe(struct platform_device *pdev)
 
564
{
 
565
        struct platform_data *pdata;
 
566
        int err;
 
567
 
 
568
        /* Check the microcode version of the CPU */
 
569
        err = chk_ucode_version(pdev);
 
570
        if (err)
 
571
                return err;
 
572
 
 
573
        /* Initialize the per-package data structures */
 
574
        pdata = kzalloc(sizeof(struct platform_data), GFP_KERNEL);
 
575
        if (!pdata)
 
576
                return -ENOMEM;
 
577
 
 
578
        err = create_name_attr(pdata, &pdev->dev);
 
579
        if (err)
 
580
                goto exit_free;
 
581
 
 
582
        pdata->phys_proc_id = TO_PHYS_ID(pdev->id);
 
583
        platform_set_drvdata(pdev, pdata);
 
584
 
 
585
        pdata->hwmon_dev = hwmon_device_register(&pdev->dev);
 
586
        if (IS_ERR(pdata->hwmon_dev)) {
 
587
                err = PTR_ERR(pdata->hwmon_dev);
 
588
                dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
 
589
                goto exit_name;
 
590
        }
 
591
        return 0;
 
592
 
 
593
exit_name:
 
594
        device_remove_file(&pdev->dev, &pdata->name_attr);
 
595
        platform_set_drvdata(pdev, NULL);
 
596
exit_free:
 
597
        kfree(pdata);
400
598
        return err;
401
599
}
402
600
 
403
601
static int __devexit coretemp_remove(struct platform_device *pdev)
404
602
{
405
 
        struct coretemp_data *data = platform_get_drvdata(pdev);
406
 
 
407
 
        hwmon_device_unregister(data->hwmon_dev);
408
 
        sysfs_remove_group(&pdev->dev.kobj, &coretemp_group);
409
 
        device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
 
603
        struct platform_data *pdata = platform_get_drvdata(pdev);
 
604
        int i;
 
605
 
 
606
        for (i = MAX_CORE_DATA - 1; i >= 0; --i)
 
607
                if (pdata->core_data[i])
 
608
                        coretemp_remove_core(pdata, &pdev->dev, i);
 
609
 
 
610
        device_remove_file(&pdev->dev, &pdata->name_attr);
 
611
        hwmon_device_unregister(pdata->hwmon_dev);
410
612
        platform_set_drvdata(pdev, NULL);
411
 
        kfree(data);
 
613
        kfree(pdata);
412
614
        return 0;
413
615
}
414
616
 
421
623
        .remove = __devexit_p(coretemp_remove),
422
624
};
423
625
 
424
 
struct pdev_entry {
425
 
        struct list_head list;
426
 
        struct platform_device *pdev;
427
 
        unsigned int cpu;
428
 
#ifdef CONFIG_SMP
429
 
        u16 phys_proc_id;
430
 
        u16 cpu_core_id;
431
 
#endif
432
 
};
433
 
 
434
 
static LIST_HEAD(pdev_list);
435
 
static DEFINE_MUTEX(pdev_list_mutex);
436
 
 
437
626
static int __cpuinit coretemp_device_add(unsigned int cpu)
438
627
{
439
628
        int err;
440
629
        struct platform_device *pdev;
441
630
        struct pdev_entry *pdev_entry;
442
 
        struct cpuinfo_x86 *c = &cpu_data(cpu);
443
 
 
444
 
        /*
445
 
         * CPUID.06H.EAX[0] indicates whether the CPU has thermal
446
 
         * sensors. We check this bit only, all the early CPUs
447
 
         * without thermal sensors will be filtered out.
448
 
         */
449
 
        if (!cpu_has(c, X86_FEATURE_DTS)) {
450
 
                pr_info("CPU (model=0x%x) has no thermal sensor\n",
451
 
                        c->x86_model);
452
 
                return 0;
453
 
        }
454
631
 
455
632
        mutex_lock(&pdev_list_mutex);
456
633
 
457
 
#ifdef CONFIG_SMP
458
 
        /* Skip second HT entry of each core */
459
 
        list_for_each_entry(pdev_entry, &pdev_list, list) {
460
 
                if (c->phys_proc_id == pdev_entry->phys_proc_id &&
461
 
                    c->cpu_core_id == pdev_entry->cpu_core_id) {
462
 
                        err = 0;        /* Not an error */
463
 
                        goto exit;
464
 
                }
465
 
        }
466
 
#endif
467
 
 
468
634
        pdev = platform_device_alloc(DRVNAME, cpu);
469
635
        if (!pdev) {
470
636
                err = -ENOMEM;
485
651
        }
486
652
 
487
653
        pdev_entry->pdev = pdev;
488
 
        pdev_entry->cpu = cpu;
489
 
#ifdef CONFIG_SMP
490
 
        pdev_entry->phys_proc_id = c->phys_proc_id;
491
 
        pdev_entry->cpu_core_id = c->cpu_core_id;
492
 
#endif
 
654
        pdev_entry->phys_proc_id = TO_PHYS_ID(cpu);
 
655
 
493
656
        list_add_tail(&pdev_entry->list, &pdev_list);
494
657
        mutex_unlock(&pdev_list_mutex);
495
658
 
504
667
        return err;
505
668
}
506
669
 
507
 
static void __cpuinit coretemp_device_remove(unsigned int cpu)
 
670
static void coretemp_device_remove(unsigned int cpu)
508
671
{
509
 
        struct pdev_entry *p;
510
 
        unsigned int i;
 
672
        struct pdev_entry *p, *n;
 
673
        u16 phys_proc_id = TO_PHYS_ID(cpu);
511
674
 
512
675
        mutex_lock(&pdev_list_mutex);
513
 
        list_for_each_entry(p, &pdev_list, list) {
514
 
                if (p->cpu != cpu)
 
676
        list_for_each_entry_safe(p, n, &pdev_list, list) {
 
677
                if (p->phys_proc_id != phys_proc_id)
515
678
                        continue;
516
 
 
517
679
                platform_device_unregister(p->pdev);
518
680
                list_del(&p->list);
519
 
                mutex_unlock(&pdev_list_mutex);
520
681
                kfree(p);
521
 
                for_each_cpu(i, cpu_sibling_mask(cpu))
522
 
                        if (i != cpu && !coretemp_device_add(i))
523
 
                                break;
524
 
                return;
525
682
        }
526
683
        mutex_unlock(&pdev_list_mutex);
527
684
}
528
685
 
 
686
static bool is_any_core_online(struct platform_data *pdata)
 
687
{
 
688
        int i;
 
689
 
 
690
        /* Find online cores, except pkgtemp data */
 
691
        for (i = MAX_CORE_DATA - 1; i >= 0; --i) {
 
692
                if (pdata->core_data[i] &&
 
693
                        !pdata->core_data[i]->is_pkg_data) {
 
694
                        return true;
 
695
                }
 
696
        }
 
697
        return false;
 
698
}
 
699
 
 
700
static void __cpuinit get_core_online(unsigned int cpu)
 
701
{
 
702
        struct cpuinfo_x86 *c = &cpu_data(cpu);
 
703
        struct platform_device *pdev = coretemp_get_pdev(cpu);
 
704
        int err;
 
705
 
 
706
        /*
 
707
         * CPUID.06H.EAX[0] indicates whether the CPU has thermal
 
708
         * sensors. We check this bit only, all the early CPUs
 
709
         * without thermal sensors will be filtered out.
 
710
         */
 
711
        if (!cpu_has(c, X86_FEATURE_DTS))
 
712
                return;
 
713
 
 
714
        if (!pdev) {
 
715
                /*
 
716
                 * Alright, we have DTS support.
 
717
                 * We are bringing the _first_ core in this pkg
 
718
                 * online. So, initialize per-pkg data structures and
 
719
                 * then bring this core online.
 
720
                 */
 
721
                err = coretemp_device_add(cpu);
 
722
                if (err)
 
723
                        return;
 
724
                /*
 
725
                 * Check whether pkgtemp support is available.
 
726
                 * If so, add interfaces for pkgtemp.
 
727
                 */
 
728
                if (cpu_has(c, X86_FEATURE_PTS))
 
729
                        coretemp_add_core(cpu, 1);
 
730
        }
 
731
        /*
 
732
         * Physical CPU device already exists.
 
733
         * So, just add interfaces for this core.
 
734
         */
 
735
        coretemp_add_core(cpu, 0);
 
736
}
 
737
 
 
738
static void __cpuinit put_core_offline(unsigned int cpu)
 
739
{
 
740
        int i, indx;
 
741
        struct platform_data *pdata;
 
742
        struct platform_device *pdev = coretemp_get_pdev(cpu);
 
743
 
 
744
        /* If the physical CPU device does not exist, just return */
 
745
        if (!pdev)
 
746
                return;
 
747
 
 
748
        pdata = platform_get_drvdata(pdev);
 
749
 
 
750
        indx = TO_ATTR_NO(cpu);
 
751
 
 
752
        if (pdata->core_data[indx] && pdata->core_data[indx]->cpu == cpu)
 
753
                coretemp_remove_core(pdata, &pdev->dev, indx);
 
754
 
 
755
        /*
 
756
         * If a HT sibling of a core is taken offline, but another HT sibling
 
757
         * of the same core is still online, register the alternate sibling.
 
758
         * This ensures that exactly one set of attributes is provided as long
 
759
         * as at least one HT sibling of a core is online.
 
760
         */
 
761
        for_each_sibling(i, cpu) {
 
762
                if (i != cpu) {
 
763
                        get_core_online(i);
 
764
                        /*
 
765
                         * Display temperature sensor data for one HT sibling
 
766
                         * per core only, so abort the loop after one such
 
767
                         * sibling has been found.
 
768
                         */
 
769
                        break;
 
770
                }
 
771
        }
 
772
        /*
 
773
         * If all cores in this pkg are offline, remove the device.
 
774
         * coretemp_device_remove calls unregister_platform_device,
 
775
         * which in turn calls coretemp_remove. This removes the
 
776
         * pkgtemp entry and does other clean ups.
 
777
         */
 
778
        if (!is_any_core_online(pdata))
 
779
                coretemp_device_remove(cpu);
 
780
}
 
781
 
529
782
static int __cpuinit coretemp_cpu_callback(struct notifier_block *nfb,
530
783
                                 unsigned long action, void *hcpu)
531
784
{
534
787
        switch (action) {
535
788
        case CPU_ONLINE:
536
789
        case CPU_DOWN_FAILED:
537
 
                coretemp_device_add(cpu);
 
790
                get_core_online(cpu);
538
791
                break;
539
792
        case CPU_DOWN_PREPARE:
540
 
                coretemp_device_remove(cpu);
 
793
                put_core_offline(cpu);
541
794
                break;
542
795
        }
543
796
        return NOTIFY_OK;
560
813
                goto exit;
561
814
 
562
815
        for_each_online_cpu(i)
563
 
                coretemp_device_add(i);
 
816
                get_core_online(i);
564
817
 
565
818
#ifndef CONFIG_HOTPLUG_CPU
566
819
        if (list_empty(&pdev_list)) {