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