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