hwmon: Check for ACPI resource conflicts
[linux-2.6.git] / drivers / hwmon / smsc47m1.c
1 /*
2     smsc47m1.c - Part of lm_sensors, Linux kernel modules
3                  for hardware monitoring
4
5     Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x,
6     LPC47M14x, LPC47M15x, LPC47M192, LPC47M292 and LPC47M997
7     Super-I/O chips.
8
9     Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
10     Copyright (C) 2004-2007 Jean Delvare <khali@linux-fr.org>
11     Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
12                         and Jean Delvare
13
14     This program is free software; you can redistribute it and/or modify
15     it under the terms of the GNU General Public License as published by
16     the Free Software Foundation; either version 2 of the License, or
17     (at your option) any later version.
18
19     This program is distributed in the hope that it will be useful,
20     but WITHOUT ANY WARRANTY; without even the implied warranty of
21     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22     GNU General Public License for more details.
23
24     You should have received a copy of the GNU General Public License
25     along with this program; if not, write to the Free Software
26     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 */
28
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/ioport.h>
32 #include <linux/jiffies.h>
33 #include <linux/platform_device.h>
34 #include <linux/hwmon.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/err.h>
37 #include <linux/init.h>
38 #include <linux/mutex.h>
39 #include <linux/sysfs.h>
40 #include <linux/acpi.h>
41 #include <asm/io.h>
42
43 static unsigned short force_id;
44 module_param(force_id, ushort, 0);
45 MODULE_PARM_DESC(force_id, "Override the detected device ID");
46
47 static struct platform_device *pdev;
48
49 #define DRVNAME "smsc47m1"
50 enum chips { smsc47m1, smsc47m2 };
51
52 /* Super-I/0 registers and commands */
53
54 #define REG     0x2e    /* The register to read/write */
55 #define VAL     0x2f    /* The value to read/write */
56
57 static inline void
58 superio_outb(int reg, int val)
59 {
60         outb(reg, REG);
61         outb(val, VAL);
62 }
63
64 static inline int
65 superio_inb(int reg)
66 {
67         outb(reg, REG);
68         return inb(VAL);
69 }
70
71 /* logical device for fans is 0x0A */
72 #define superio_select() superio_outb(0x07, 0x0A)
73
74 static inline void
75 superio_enter(void)
76 {
77         outb(0x55, REG);
78 }
79
80 static inline void
81 superio_exit(void)
82 {
83         outb(0xAA, REG);
84 }
85
86 #define SUPERIO_REG_ACT         0x30
87 #define SUPERIO_REG_BASE        0x60
88 #define SUPERIO_REG_DEVID       0x20
89
90 /* Logical device registers */
91
92 #define SMSC_EXTENT             0x80
93
94 /* nr is 0 or 1 in the macros below */
95 #define SMSC47M1_REG_ALARM              0x04
96 #define SMSC47M1_REG_TPIN(nr)           (0x34 - (nr))
97 #define SMSC47M1_REG_PPIN(nr)           (0x36 - (nr))
98 #define SMSC47M1_REG_FANDIV             0x58
99
100 static const u8 SMSC47M1_REG_FAN[3]             = { 0x59, 0x5a, 0x6b };
101 static const u8 SMSC47M1_REG_FAN_PRELOAD[3]     = { 0x5b, 0x5c, 0x6c };
102 static const u8 SMSC47M1_REG_PWM[3]             = { 0x56, 0x57, 0x69 };
103
104 #define SMSC47M2_REG_ALARM6             0x09
105 #define SMSC47M2_REG_TPIN1              0x38
106 #define SMSC47M2_REG_TPIN2              0x37
107 #define SMSC47M2_REG_TPIN3              0x2d
108 #define SMSC47M2_REG_PPIN3              0x2c
109 #define SMSC47M2_REG_FANDIV3            0x6a
110
111 #define MIN_FROM_REG(reg,div)           ((reg)>=192 ? 0 : \
112                                          983040/((192-(reg))*(div)))
113 #define FAN_FROM_REG(reg,div,preload)   ((reg)<=(preload) || (reg)==255 ? 0 : \
114                                          983040/(((reg)-(preload))*(div)))
115 #define DIV_FROM_REG(reg)               (1 << (reg))
116 #define PWM_FROM_REG(reg)               (((reg) & 0x7E) << 1)
117 #define PWM_EN_FROM_REG(reg)            ((~(reg)) & 0x01)
118 #define PWM_TO_REG(reg)                 (((reg) >> 1) & 0x7E)
119
120 struct smsc47m1_data {
121         unsigned short addr;
122         const char *name;
123         enum chips type;
124         struct device *hwmon_dev;
125
126         struct mutex update_lock;
127         unsigned long last_updated;     /* In jiffies */
128
129         u8 fan[3];              /* Register value */
130         u8 fan_preload[3];      /* Register value */
131         u8 fan_div[3];          /* Register encoding, shifted right */
132         u8 alarms;              /* Register encoding */
133         u8 pwm[3];              /* Register value (bit 0 is disable) */
134 };
135
136 struct smsc47m1_sio_data {
137         enum chips type;
138 };
139
140
141 static int smsc47m1_probe(struct platform_device *pdev);
142 static int __devexit smsc47m1_remove(struct platform_device *pdev);
143 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
144                 int init);
145
146 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
147 {
148         return inb_p(data->addr + reg);
149 }
150
151 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
152                 u8 value)
153 {
154         outb_p(value, data->addr + reg);
155 }
156
157 static struct platform_driver smsc47m1_driver = {
158         .driver = {
159                 .owner  = THIS_MODULE,
160                 .name   = DRVNAME,
161         },
162         .probe          = smsc47m1_probe,
163         .remove         = __devexit_p(smsc47m1_remove),
164 };
165
166 static ssize_t get_fan(struct device *dev, struct device_attribute
167                        *devattr, char *buf)
168 {
169         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
170         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
171         int nr = attr->index;
172         /* This chip (stupidly) stops monitoring fan speed if PWM is
173            enabled and duty cycle is 0%. This is fine if the monitoring
174            and control concern the same fan, but troublesome if they are
175            not (which could as well happen). */
176         int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
177                   FAN_FROM_REG(data->fan[nr],
178                                DIV_FROM_REG(data->fan_div[nr]),
179                                data->fan_preload[nr]);
180         return sprintf(buf, "%d\n", rpm);
181 }
182
183 static ssize_t get_fan_min(struct device *dev, struct device_attribute
184                            *devattr, char *buf)
185 {
186         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
187         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
188         int nr = attr->index;
189         int rpm = MIN_FROM_REG(data->fan_preload[nr],
190                                DIV_FROM_REG(data->fan_div[nr]));
191         return sprintf(buf, "%d\n", rpm);
192 }
193
194 static ssize_t get_fan_div(struct device *dev, struct device_attribute
195                            *devattr, char *buf)
196 {
197         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
198         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
199         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
200 }
201
202 static ssize_t get_fan_alarm(struct device *dev, struct device_attribute
203                              *devattr, char *buf)
204 {
205         int bitnr = to_sensor_dev_attr(devattr)->index;
206         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
207         return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
208 }
209
210 static ssize_t get_pwm(struct device *dev, struct device_attribute
211                        *devattr, char *buf)
212 {
213         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
214         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
215         return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));
216 }
217
218 static ssize_t get_pwm_en(struct device *dev, struct device_attribute
219                           *devattr, char *buf)
220 {
221         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
222         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
223         return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));
224 }
225
226 static ssize_t get_alarms(struct device *dev, struct device_attribute
227                           *devattr, char *buf)
228 {
229         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
230         return sprintf(buf, "%d\n", data->alarms);
231 }
232
233 static ssize_t set_fan_min(struct device *dev, struct device_attribute
234                            *devattr, const char *buf, size_t count)
235 {
236         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
237         struct smsc47m1_data *data = dev_get_drvdata(dev);
238         int nr = attr->index;
239         long rpmdiv, val = simple_strtol(buf, NULL, 10);
240
241         mutex_lock(&data->update_lock);
242         rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
243
244         if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
245                 mutex_unlock(&data->update_lock);
246                 return -EINVAL;
247         }
248
249         data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
250         smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
251                              data->fan_preload[nr]);
252         mutex_unlock(&data->update_lock);
253
254         return count;
255 }
256
257 /* Note: we save and restore the fan minimum here, because its value is
258    determined in part by the fan clock divider.  This follows the principle
259    of least surprise; the user doesn't expect the fan minimum to change just
260    because the divider changed. */
261 static ssize_t set_fan_div(struct device *dev, struct device_attribute
262                            *devattr, const char *buf, size_t count)
263 {
264         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
265         struct smsc47m1_data *data = dev_get_drvdata(dev);
266         int nr = attr->index;
267         long new_div = simple_strtol(buf, NULL, 10), tmp;
268         u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
269
270         if (new_div == old_div) /* No change */
271                 return count;
272
273         mutex_lock(&data->update_lock);
274         switch (new_div) {
275         case 1: data->fan_div[nr] = 0; break;
276         case 2: data->fan_div[nr] = 1; break;
277         case 4: data->fan_div[nr] = 2; break;
278         case 8: data->fan_div[nr] = 3; break;
279         default:
280                 mutex_unlock(&data->update_lock);
281                 return -EINVAL;
282         }
283
284         switch (nr) {
285         case 0:
286         case 1:
287                 tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV)
288                       & ~(0x03 << (4 + 2 * nr));
289                 tmp |= data->fan_div[nr] << (4 + 2 * nr);
290                 smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp);
291                 break;
292         case 2:
293                 tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF;
294                 tmp |= data->fan_div[2] << 4;
295                 smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp);
296                 break;
297         }
298
299         /* Preserve fan min */
300         tmp = 192 - (old_div * (192 - data->fan_preload[nr])
301                      + new_div / 2) / new_div;
302         data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
303         smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
304                              data->fan_preload[nr]);
305         mutex_unlock(&data->update_lock);
306
307         return count;
308 }
309
310 static ssize_t set_pwm(struct device *dev, struct device_attribute
311                        *devattr, const char *buf, size_t count)
312 {
313         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
314         struct smsc47m1_data *data = dev_get_drvdata(dev);
315         int nr = attr->index;
316         long val = simple_strtol(buf, NULL, 10);
317
318         if (val < 0 || val > 255)
319                 return -EINVAL;
320
321         mutex_lock(&data->update_lock);
322         data->pwm[nr] &= 0x81; /* Preserve additional bits */
323         data->pwm[nr] |= PWM_TO_REG(val);
324         smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
325                              data->pwm[nr]);
326         mutex_unlock(&data->update_lock);
327
328         return count;
329 }
330
331 static ssize_t set_pwm_en(struct device *dev, struct device_attribute
332                           *devattr, const char *buf, size_t count)
333 {
334         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
335         struct smsc47m1_data *data = dev_get_drvdata(dev);
336         int nr = attr->index;
337         long val = simple_strtol(buf, NULL, 10);
338         
339         if (val != 0 && val != 1)
340                 return -EINVAL;
341
342         mutex_lock(&data->update_lock);
343         data->pwm[nr] &= 0xFE; /* preserve the other bits */
344         data->pwm[nr] |= !val;
345         smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
346                              data->pwm[nr]);
347         mutex_unlock(&data->update_lock);
348
349         return count;
350 }
351
352 #define fan_present(offset)                                             \
353 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan,        \
354                 NULL, offset - 1);                                      \
355 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
356                 get_fan_min, set_fan_min, offset - 1);                  \
357 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
358                 get_fan_div, set_fan_div, offset - 1);                  \
359 static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm,  \
360                 NULL, offset - 1);                                      \
361 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,               \
362                 get_pwm, set_pwm, offset - 1);                          \
363 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,      \
364                 get_pwm_en, set_pwm_en, offset - 1)
365
366 fan_present(1);
367 fan_present(2);
368 fan_present(3);
369
370 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
371
372 static ssize_t show_name(struct device *dev, struct device_attribute
373                          *devattr, char *buf)
374 {
375         struct smsc47m1_data *data = dev_get_drvdata(dev);
376
377         return sprintf(buf, "%s\n", data->name);
378 }
379 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
380
381 /* Almost all sysfs files may or may not be created depending on the chip
382    setup so we create them individually. It is still convenient to define a
383    group to remove them all at once. */
384 static struct attribute *smsc47m1_attributes[] = {
385         &sensor_dev_attr_fan1_input.dev_attr.attr,
386         &sensor_dev_attr_fan1_min.dev_attr.attr,
387         &sensor_dev_attr_fan1_div.dev_attr.attr,
388         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
389         &sensor_dev_attr_fan2_input.dev_attr.attr,
390         &sensor_dev_attr_fan2_min.dev_attr.attr,
391         &sensor_dev_attr_fan2_div.dev_attr.attr,
392         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
393         &sensor_dev_attr_fan3_input.dev_attr.attr,
394         &sensor_dev_attr_fan3_min.dev_attr.attr,
395         &sensor_dev_attr_fan3_div.dev_attr.attr,
396         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
397
398         &sensor_dev_attr_pwm1.dev_attr.attr,
399         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
400         &sensor_dev_attr_pwm2.dev_attr.attr,
401         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
402         &sensor_dev_attr_pwm3.dev_attr.attr,
403         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
404
405         &dev_attr_alarms.attr,
406         &dev_attr_name.attr,
407         NULL
408 };
409
410 static const struct attribute_group smsc47m1_group = {
411         .attrs = smsc47m1_attributes,
412 };
413
414 static int __init smsc47m1_find(unsigned short *addr,
415                                 struct smsc47m1_sio_data *sio_data)
416 {
417         u8 val;
418
419         superio_enter();
420         val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
421
422         /*
423          * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
424          * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
425          * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
426          * can do much more besides (device id 0x60).
427          * The LPC47M997 is undocumented, but seems to be compatible with
428          * the LPC47M192, and has the same device id.
429          * The LPC47M292 (device id 0x6B) is somewhat compatible, but it
430          * supports a 3rd fan, and the pin configuration registers are
431          * unfortunately different.
432          */
433         switch (val) {
434         case 0x51:
435                 pr_info(DRVNAME ": Found SMSC LPC47B27x\n");
436                 sio_data->type = smsc47m1;
437                 break;
438         case 0x59:
439                 pr_info(DRVNAME ": Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
440                 sio_data->type = smsc47m1;
441                 break;
442         case 0x5F:
443                 pr_info(DRVNAME ": Found SMSC LPC47M14x\n");
444                 sio_data->type = smsc47m1;
445                 break;
446         case 0x60:
447                 pr_info(DRVNAME ": Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
448                 sio_data->type = smsc47m1;
449                 break;
450         case 0x6B:
451                 pr_info(DRVNAME ": Found SMSC LPC47M292\n");
452                 sio_data->type = smsc47m2;
453                 break;
454         default:
455                 superio_exit();
456                 return -ENODEV;
457         }
458
459         superio_select();
460         *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
461               |  superio_inb(SUPERIO_REG_BASE + 1);
462         val = superio_inb(SUPERIO_REG_ACT);
463         if (*addr == 0 || (val & 0x01) == 0) {
464                 pr_info(DRVNAME ": Device is disabled, will not use\n");
465                 superio_exit();
466                 return -ENODEV;
467         }
468
469         superio_exit();
470         return 0;
471 }
472
473 static int __devinit smsc47m1_probe(struct platform_device *pdev)
474 {
475         struct device *dev = &pdev->dev;
476         struct smsc47m1_sio_data *sio_data = dev->platform_data;
477         struct smsc47m1_data *data;
478         struct resource *res;
479         int err = 0;
480         int fan1, fan2, fan3, pwm1, pwm2, pwm3;
481
482         static const char *names[] = {
483                 "smsc47m1",
484                 "smsc47m2",
485         };
486
487         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
488         if (!request_region(res->start, SMSC_EXTENT, DRVNAME)) {
489                 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
490                         (unsigned long)res->start,
491                         (unsigned long)res->end);
492                 return -EBUSY;
493         }
494
495         if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
496                 err = -ENOMEM;
497                 goto error_release;
498         }
499
500         data->addr = res->start;
501         data->type = sio_data->type;
502         data->name = names[sio_data->type];
503         mutex_init(&data->update_lock);
504         platform_set_drvdata(pdev, data);
505
506         /* If no function is properly configured, there's no point in
507            actually registering the chip. */
508         pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
509                == 0x04;
510         pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
511                == 0x04;
512         if (data->type == smsc47m2) {
513                 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
514                         & 0x0d) == 0x09;
515                 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
516                         & 0x0d) == 0x09;
517                 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
518                         & 0x0d) == 0x0d;
519                 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
520                         & 0x0d) == 0x08;
521         } else {
522                 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
523                         & 0x05) == 0x05;
524                 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
525                         & 0x05) == 0x05;
526                 fan3 = 0;
527                 pwm3 = 0;
528         }
529         if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
530                 dev_warn(dev, "Device not configured, will not use\n");
531                 err = -ENODEV;
532                 goto error_free;
533         }
534
535         /* Some values (fan min, clock dividers, pwm registers) may be
536            needed before any update is triggered, so we better read them
537            at least once here. We don't usually do it that way, but in
538            this particular case, manually reading 5 registers out of 8
539            doesn't make much sense and we're better using the existing
540            function. */
541         smsc47m1_update_device(dev, 1);
542
543         /* Register sysfs hooks */
544         if (fan1) {
545                 if ((err = device_create_file(dev,
546                                 &sensor_dev_attr_fan1_input.dev_attr))
547                  || (err = device_create_file(dev,
548                                 &sensor_dev_attr_fan1_min.dev_attr))
549                  || (err = device_create_file(dev,
550                                 &sensor_dev_attr_fan1_div.dev_attr))
551                  || (err = device_create_file(dev,
552                                 &sensor_dev_attr_fan1_alarm.dev_attr)))
553                         goto error_remove_files;
554         } else
555                 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
556
557         if (fan2) {
558                 if ((err = device_create_file(dev,
559                                 &sensor_dev_attr_fan2_input.dev_attr))
560                  || (err = device_create_file(dev,
561                                 &sensor_dev_attr_fan2_min.dev_attr))
562                  || (err = device_create_file(dev,
563                                 &sensor_dev_attr_fan2_div.dev_attr))
564                  || (err = device_create_file(dev,
565                                 &sensor_dev_attr_fan2_alarm.dev_attr)))
566                         goto error_remove_files;
567         } else
568                 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
569
570         if (fan3) {
571                 if ((err = device_create_file(dev,
572                                 &sensor_dev_attr_fan3_input.dev_attr))
573                  || (err = device_create_file(dev,
574                                 &sensor_dev_attr_fan3_min.dev_attr))
575                  || (err = device_create_file(dev,
576                                 &sensor_dev_attr_fan3_div.dev_attr))
577                  || (err = device_create_file(dev,
578                                 &sensor_dev_attr_fan3_alarm.dev_attr)))
579                         goto error_remove_files;
580         } else if (data->type == smsc47m2)
581                 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
582
583         if (pwm1) {
584                 if ((err = device_create_file(dev,
585                                 &sensor_dev_attr_pwm1.dev_attr))
586                  || (err = device_create_file(dev,
587                                 &sensor_dev_attr_pwm1_enable.dev_attr)))
588                         goto error_remove_files;
589         } else
590                 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
591
592         if (pwm2) {
593                 if ((err = device_create_file(dev,
594                                 &sensor_dev_attr_pwm2.dev_attr))
595                  || (err = device_create_file(dev,
596                                 &sensor_dev_attr_pwm2_enable.dev_attr)))
597                         goto error_remove_files;
598         } else
599                 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
600
601         if (pwm3) {
602                 if ((err = device_create_file(dev,
603                                 &sensor_dev_attr_pwm3.dev_attr))
604                  || (err = device_create_file(dev,
605                                 &sensor_dev_attr_pwm3_enable.dev_attr)))
606                         goto error_remove_files;
607         } else if (data->type == smsc47m2)
608                 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
609
610         if ((err = device_create_file(dev, &dev_attr_alarms)))
611                 goto error_remove_files;
612         if ((err = device_create_file(dev, &dev_attr_name)))
613                 goto error_remove_files;
614
615         data->hwmon_dev = hwmon_device_register(dev);
616         if (IS_ERR(data->hwmon_dev)) {
617                 err = PTR_ERR(data->hwmon_dev);
618                 goto error_remove_files;
619         }
620
621         return 0;
622
623 error_remove_files:
624         sysfs_remove_group(&dev->kobj, &smsc47m1_group);
625 error_free:
626         platform_set_drvdata(pdev, NULL);
627         kfree(data);
628 error_release:
629         release_region(res->start, SMSC_EXTENT);
630         return err;
631 }
632
633 static int __devexit smsc47m1_remove(struct platform_device *pdev)
634 {
635         struct smsc47m1_data *data = platform_get_drvdata(pdev);
636         struct resource *res;
637
638         hwmon_device_unregister(data->hwmon_dev);
639         sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
640
641         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
642         release_region(res->start, SMSC_EXTENT);
643         platform_set_drvdata(pdev, NULL);
644         kfree(data);
645
646         return 0;
647 }
648
649 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
650                 int init)
651 {
652         struct smsc47m1_data *data = dev_get_drvdata(dev);
653
654         mutex_lock(&data->update_lock);
655
656         if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
657                 int i, fan_nr;
658                 fan_nr = data->type == smsc47m2 ? 3 : 2;
659
660                 for (i = 0; i < fan_nr; i++) {
661                         data->fan[i] = smsc47m1_read_value(data,
662                                        SMSC47M1_REG_FAN[i]);
663                         data->fan_preload[i] = smsc47m1_read_value(data,
664                                                SMSC47M1_REG_FAN_PRELOAD[i]);
665                         data->pwm[i] = smsc47m1_read_value(data,
666                                        SMSC47M1_REG_PWM[i]);
667                 }
668
669                 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
670                 data->fan_div[0] = (i >> 4) & 0x03;
671                 data->fan_div[1] = i >> 6;
672
673                 data->alarms = smsc47m1_read_value(data,
674                                SMSC47M1_REG_ALARM) >> 6;
675                 /* Clear alarms if needed */
676                 if (data->alarms)
677                         smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
678
679                 if (fan_nr >= 3) {
680                         data->fan_div[2] = (smsc47m1_read_value(data,
681                                             SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
682                         data->alarms |= (smsc47m1_read_value(data,
683                                          SMSC47M2_REG_ALARM6) & 0x40) >> 4;
684                         /* Clear alarm if needed */
685                         if (data->alarms & 0x04)
686                                 smsc47m1_write_value(data,
687                                                      SMSC47M2_REG_ALARM6,
688                                                      0x40);
689                 }
690
691                 data->last_updated = jiffies;
692         }
693
694         mutex_unlock(&data->update_lock);
695         return data;
696 }
697
698 static int __init smsc47m1_device_add(unsigned short address,
699                                       const struct smsc47m1_sio_data *sio_data)
700 {
701         struct resource res = {
702                 .start  = address,
703                 .end    = address + SMSC_EXTENT - 1,
704                 .name   = DRVNAME,
705                 .flags  = IORESOURCE_IO,
706         };
707         int err;
708
709         err = acpi_check_resource_conflict(&res);
710         if (err)
711                 goto exit;
712
713         pdev = platform_device_alloc(DRVNAME, address);
714         if (!pdev) {
715                 err = -ENOMEM;
716                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
717                 goto exit;
718         }
719
720         err = platform_device_add_resources(pdev, &res, 1);
721         if (err) {
722                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
723                        "(%d)\n", err);
724                 goto exit_device_put;
725         }
726
727         err = platform_device_add_data(pdev, sio_data,
728                                        sizeof(struct smsc47m1_sio_data));
729         if (err) {
730                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
731                 goto exit_device_put;
732         }
733
734         err = platform_device_add(pdev);
735         if (err) {
736                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
737                        err);
738                 goto exit_device_put;
739         }
740
741         return 0;
742
743 exit_device_put:
744         platform_device_put(pdev);
745 exit:
746         return err;
747 }
748
749 static int __init sm_smsc47m1_init(void)
750 {
751         int err;
752         unsigned short address;
753         struct smsc47m1_sio_data sio_data;
754
755         if (smsc47m1_find(&address, &sio_data))
756                 return -ENODEV;
757
758         err = platform_driver_register(&smsc47m1_driver);
759         if (err)
760                 goto exit;
761
762         /* Sets global pdev as a side effect */
763         err = smsc47m1_device_add(address, &sio_data);
764         if (err)
765                 goto exit_driver;
766
767         return 0;
768
769 exit_driver:
770         platform_driver_unregister(&smsc47m1_driver);
771 exit:
772         return err;
773 }
774
775 static void __exit sm_smsc47m1_exit(void)
776 {
777         platform_device_unregister(pdev);
778         platform_driver_unregister(&smsc47m1_driver);
779 }
780
781 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
782 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
783 MODULE_LICENSE("GPL");
784
785 module_init(sm_smsc47m1_init);
786 module_exit(sm_smsc47m1_exit);