hwmon: (lm90) Restore configuration on exit
[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 <linux/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 #define SUPERIO_REG_DEVREV      0x21
90
91 /* Logical device registers */
92
93 #define SMSC_EXTENT             0x80
94
95 /* nr is 0 or 1 in the macros below */
96 #define SMSC47M1_REG_ALARM              0x04
97 #define SMSC47M1_REG_TPIN(nr)           (0x34 - (nr))
98 #define SMSC47M1_REG_PPIN(nr)           (0x36 - (nr))
99 #define SMSC47M1_REG_FANDIV             0x58
100
101 static const u8 SMSC47M1_REG_FAN[3]             = { 0x59, 0x5a, 0x6b };
102 static const u8 SMSC47M1_REG_FAN_PRELOAD[3]     = { 0x5b, 0x5c, 0x6c };
103 static const u8 SMSC47M1_REG_PWM[3]             = { 0x56, 0x57, 0x69 };
104
105 #define SMSC47M2_REG_ALARM6             0x09
106 #define SMSC47M2_REG_TPIN1              0x38
107 #define SMSC47M2_REG_TPIN2              0x37
108 #define SMSC47M2_REG_TPIN3              0x2d
109 #define SMSC47M2_REG_PPIN3              0x2c
110 #define SMSC47M2_REG_FANDIV3            0x6a
111
112 #define MIN_FROM_REG(reg,div)           ((reg)>=192 ? 0 : \
113                                          983040/((192-(reg))*(div)))
114 #define FAN_FROM_REG(reg,div,preload)   ((reg)<=(preload) || (reg)==255 ? 0 : \
115                                          983040/(((reg)-(preload))*(div)))
116 #define DIV_FROM_REG(reg)               (1 << (reg))
117 #define PWM_FROM_REG(reg)               (((reg) & 0x7E) << 1)
118 #define PWM_EN_FROM_REG(reg)            ((~(reg)) & 0x01)
119 #define PWM_TO_REG(reg)                 (((reg) >> 1) & 0x7E)
120
121 struct smsc47m1_data {
122         unsigned short addr;
123         const char *name;
124         enum chips type;
125         struct device *hwmon_dev;
126
127         struct mutex update_lock;
128         unsigned long last_updated;     /* In jiffies */
129
130         u8 fan[3];              /* Register value */
131         u8 fan_preload[3];      /* Register value */
132         u8 fan_div[3];          /* Register encoding, shifted right */
133         u8 alarms;              /* Register encoding */
134         u8 pwm[3];              /* Register value (bit 0 is disable) */
135 };
136
137 struct smsc47m1_sio_data {
138         enum chips type;
139         u8 activate;            /* Remember initial device state */
140 };
141
142
143 static int __exit smsc47m1_remove(struct platform_device *pdev);
144 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
145                 int init);
146
147 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
148 {
149         return inb_p(data->addr + reg);
150 }
151
152 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
153                 u8 value)
154 {
155         outb_p(value, data->addr + reg);
156 }
157
158 static struct platform_driver smsc47m1_driver = {
159         .driver = {
160                 .owner  = THIS_MODULE,
161                 .name   = DRVNAME,
162         },
163         .remove         = __exit_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          * The LPC47M233 has the same device id (0x6B) but is not compatible.
433          * We check the high bit of the device revision register to
434          * differentiate them.
435          */
436         switch (val) {
437         case 0x51:
438                 pr_info(DRVNAME ": Found SMSC LPC47B27x\n");
439                 sio_data->type = smsc47m1;
440                 break;
441         case 0x59:
442                 pr_info(DRVNAME ": Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
443                 sio_data->type = smsc47m1;
444                 break;
445         case 0x5F:
446                 pr_info(DRVNAME ": Found SMSC LPC47M14x\n");
447                 sio_data->type = smsc47m1;
448                 break;
449         case 0x60:
450                 pr_info(DRVNAME ": Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
451                 sio_data->type = smsc47m1;
452                 break;
453         case 0x6B:
454                 if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) {
455                         pr_debug(DRVNAME ": "
456                                  "Found SMSC LPC47M233, unsupported\n");
457                         superio_exit();
458                         return -ENODEV;
459                 }
460
461                 pr_info(DRVNAME ": Found SMSC LPC47M292\n");
462                 sio_data->type = smsc47m2;
463                 break;
464         default:
465                 superio_exit();
466                 return -ENODEV;
467         }
468
469         superio_select();
470         *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
471               |  superio_inb(SUPERIO_REG_BASE + 1);
472         if (*addr == 0) {
473                 pr_info(DRVNAME ": Device address not set, will not use\n");
474                 superio_exit();
475                 return -ENODEV;
476         }
477
478         /* Enable only if address is set (needed at least on the
479          * Compaq Presario S4000NX) */
480         sio_data->activate = superio_inb(SUPERIO_REG_ACT);
481         if ((sio_data->activate & 0x01) == 0) {
482                 pr_info(DRVNAME ": Enabling device\n");
483                 superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01);
484         }
485
486         superio_exit();
487         return 0;
488 }
489
490 /* Restore device to its initial state */
491 static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
492 {
493         if ((sio_data->activate & 0x01) == 0) {
494                 superio_enter();
495                 superio_select();
496
497                 pr_info(DRVNAME ": Disabling device\n");
498                 superio_outb(SUPERIO_REG_ACT, sio_data->activate);
499
500                 superio_exit();
501         }
502 }
503
504 #define CHECK           1
505 #define REQUEST         2
506 #define RELEASE         3
507
508 /*
509  * This function can be used to:
510  *  - test for resource conflicts with ACPI
511  *  - request the resources
512  *  - release the resources
513  * We only allocate the I/O ports we really need, to minimize the risk of
514  * conflicts with ACPI or with other drivers.
515  */
516 static int smsc47m1_handle_resources(unsigned short address, enum chips type,
517                                      int action, struct device *dev)
518 {
519         static const u8 ports_m1[] = {
520                 /* register, region length */
521                 0x04, 1,
522                 0x33, 4,
523                 0x56, 7,
524         };
525
526         static const u8 ports_m2[] = {
527                 /* register, region length */
528                 0x04, 1,
529                 0x09, 1,
530                 0x2c, 2,
531                 0x35, 4,
532                 0x56, 7,
533                 0x69, 4,
534         };
535
536         int i, ports_size, err;
537         const u8 *ports;
538
539         switch (type) {
540         case smsc47m1:
541         default:
542                 ports = ports_m1;
543                 ports_size = ARRAY_SIZE(ports_m1);
544                 break;
545         case smsc47m2:
546                 ports = ports_m2;
547                 ports_size = ARRAY_SIZE(ports_m2);
548                 break;
549         }
550
551         for (i = 0; i + 1 < ports_size; i += 2) {
552                 unsigned short start = address + ports[i];
553                 unsigned short len = ports[i + 1];
554
555                 switch (action) {
556                 case CHECK:
557                         /* Only check for conflicts */
558                         err = acpi_check_region(start, len, DRVNAME);
559                         if (err)
560                                 return err;
561                         break;
562                 case REQUEST:
563                         /* Request the resources */
564                         if (!request_region(start, len, DRVNAME)) {
565                                 dev_err(dev, "Region 0x%hx-0x%hx already in "
566                                         "use!\n", start, start + len);
567
568                                 /* Undo all requests */
569                                 for (i -= 2; i >= 0; i -= 2)
570                                         release_region(address + ports[i],
571                                                        ports[i + 1]);
572                                 return -EBUSY;
573                         }
574                         break;
575                 case RELEASE:
576                         /* Release the resources */
577                         release_region(start, len);
578                         break;
579                 }
580         }
581
582         return 0;
583 }
584
585 static int __init smsc47m1_probe(struct platform_device *pdev)
586 {
587         struct device *dev = &pdev->dev;
588         struct smsc47m1_sio_data *sio_data = dev->platform_data;
589         struct smsc47m1_data *data;
590         struct resource *res;
591         int err;
592         int fan1, fan2, fan3, pwm1, pwm2, pwm3;
593
594         static const char *names[] = {
595                 "smsc47m1",
596                 "smsc47m2",
597         };
598
599         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
600         err = smsc47m1_handle_resources(res->start, sio_data->type,
601                                         REQUEST, dev);
602         if (err < 0)
603                 return err;
604
605         if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
606                 err = -ENOMEM;
607                 goto error_release;
608         }
609
610         data->addr = res->start;
611         data->type = sio_data->type;
612         data->name = names[sio_data->type];
613         mutex_init(&data->update_lock);
614         platform_set_drvdata(pdev, data);
615
616         /* If no function is properly configured, there's no point in
617            actually registering the chip. */
618         pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
619                == 0x04;
620         pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
621                == 0x04;
622         if (data->type == smsc47m2) {
623                 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
624                         & 0x0d) == 0x09;
625                 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
626                         & 0x0d) == 0x09;
627                 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
628                         & 0x0d) == 0x0d;
629                 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
630                         & 0x0d) == 0x08;
631         } else {
632                 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
633                         & 0x05) == 0x05;
634                 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
635                         & 0x05) == 0x05;
636                 fan3 = 0;
637                 pwm3 = 0;
638         }
639         if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
640                 dev_warn(dev, "Device not configured, will not use\n");
641                 err = -ENODEV;
642                 goto error_free;
643         }
644
645         /* Some values (fan min, clock dividers, pwm registers) may be
646            needed before any update is triggered, so we better read them
647            at least once here. We don't usually do it that way, but in
648            this particular case, manually reading 5 registers out of 8
649            doesn't make much sense and we're better using the existing
650            function. */
651         smsc47m1_update_device(dev, 1);
652
653         /* Register sysfs hooks */
654         if (fan1) {
655                 if ((err = device_create_file(dev,
656                                 &sensor_dev_attr_fan1_input.dev_attr))
657                  || (err = device_create_file(dev,
658                                 &sensor_dev_attr_fan1_min.dev_attr))
659                  || (err = device_create_file(dev,
660                                 &sensor_dev_attr_fan1_div.dev_attr))
661                  || (err = device_create_file(dev,
662                                 &sensor_dev_attr_fan1_alarm.dev_attr)))
663                         goto error_remove_files;
664         } else
665                 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
666
667         if (fan2) {
668                 if ((err = device_create_file(dev,
669                                 &sensor_dev_attr_fan2_input.dev_attr))
670                  || (err = device_create_file(dev,
671                                 &sensor_dev_attr_fan2_min.dev_attr))
672                  || (err = device_create_file(dev,
673                                 &sensor_dev_attr_fan2_div.dev_attr))
674                  || (err = device_create_file(dev,
675                                 &sensor_dev_attr_fan2_alarm.dev_attr)))
676                         goto error_remove_files;
677         } else
678                 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
679
680         if (fan3) {
681                 if ((err = device_create_file(dev,
682                                 &sensor_dev_attr_fan3_input.dev_attr))
683                  || (err = device_create_file(dev,
684                                 &sensor_dev_attr_fan3_min.dev_attr))
685                  || (err = device_create_file(dev,
686                                 &sensor_dev_attr_fan3_div.dev_attr))
687                  || (err = device_create_file(dev,
688                                 &sensor_dev_attr_fan3_alarm.dev_attr)))
689                         goto error_remove_files;
690         } else if (data->type == smsc47m2)
691                 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
692
693         if (pwm1) {
694                 if ((err = device_create_file(dev,
695                                 &sensor_dev_attr_pwm1.dev_attr))
696                  || (err = device_create_file(dev,
697                                 &sensor_dev_attr_pwm1_enable.dev_attr)))
698                         goto error_remove_files;
699         } else
700                 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
701
702         if (pwm2) {
703                 if ((err = device_create_file(dev,
704                                 &sensor_dev_attr_pwm2.dev_attr))
705                  || (err = device_create_file(dev,
706                                 &sensor_dev_attr_pwm2_enable.dev_attr)))
707                         goto error_remove_files;
708         } else
709                 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
710
711         if (pwm3) {
712                 if ((err = device_create_file(dev,
713                                 &sensor_dev_attr_pwm3.dev_attr))
714                  || (err = device_create_file(dev,
715                                 &sensor_dev_attr_pwm3_enable.dev_attr)))
716                         goto error_remove_files;
717         } else if (data->type == smsc47m2)
718                 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
719
720         if ((err = device_create_file(dev, &dev_attr_alarms)))
721                 goto error_remove_files;
722         if ((err = device_create_file(dev, &dev_attr_name)))
723                 goto error_remove_files;
724
725         data->hwmon_dev = hwmon_device_register(dev);
726         if (IS_ERR(data->hwmon_dev)) {
727                 err = PTR_ERR(data->hwmon_dev);
728                 goto error_remove_files;
729         }
730
731         return 0;
732
733 error_remove_files:
734         sysfs_remove_group(&dev->kobj, &smsc47m1_group);
735 error_free:
736         platform_set_drvdata(pdev, NULL);
737         kfree(data);
738 error_release:
739         smsc47m1_handle_resources(res->start, sio_data->type, RELEASE, dev);
740         return err;
741 }
742
743 static int __exit smsc47m1_remove(struct platform_device *pdev)
744 {
745         struct smsc47m1_data *data = platform_get_drvdata(pdev);
746         struct resource *res;
747
748         hwmon_device_unregister(data->hwmon_dev);
749         sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
750
751         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
752         smsc47m1_handle_resources(res->start, data->type, RELEASE, &pdev->dev);
753         platform_set_drvdata(pdev, NULL);
754         kfree(data);
755
756         return 0;
757 }
758
759 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
760                 int init)
761 {
762         struct smsc47m1_data *data = dev_get_drvdata(dev);
763
764         mutex_lock(&data->update_lock);
765
766         if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
767                 int i, fan_nr;
768                 fan_nr = data->type == smsc47m2 ? 3 : 2;
769
770                 for (i = 0; i < fan_nr; i++) {
771                         data->fan[i] = smsc47m1_read_value(data,
772                                        SMSC47M1_REG_FAN[i]);
773                         data->fan_preload[i] = smsc47m1_read_value(data,
774                                                SMSC47M1_REG_FAN_PRELOAD[i]);
775                         data->pwm[i] = smsc47m1_read_value(data,
776                                        SMSC47M1_REG_PWM[i]);
777                 }
778
779                 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
780                 data->fan_div[0] = (i >> 4) & 0x03;
781                 data->fan_div[1] = i >> 6;
782
783                 data->alarms = smsc47m1_read_value(data,
784                                SMSC47M1_REG_ALARM) >> 6;
785                 /* Clear alarms if needed */
786                 if (data->alarms)
787                         smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
788
789                 if (fan_nr >= 3) {
790                         data->fan_div[2] = (smsc47m1_read_value(data,
791                                             SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
792                         data->alarms |= (smsc47m1_read_value(data,
793                                          SMSC47M2_REG_ALARM6) & 0x40) >> 4;
794                         /* Clear alarm if needed */
795                         if (data->alarms & 0x04)
796                                 smsc47m1_write_value(data,
797                                                      SMSC47M2_REG_ALARM6,
798                                                      0x40);
799                 }
800
801                 data->last_updated = jiffies;
802         }
803
804         mutex_unlock(&data->update_lock);
805         return data;
806 }
807
808 static int __init smsc47m1_device_add(unsigned short address,
809                                       const struct smsc47m1_sio_data *sio_data)
810 {
811         struct resource res = {
812                 .start  = address,
813                 .end    = address + SMSC_EXTENT - 1,
814                 .name   = DRVNAME,
815                 .flags  = IORESOURCE_IO,
816         };
817         int err;
818
819         err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL);
820         if (err)
821                 goto exit;
822
823         pdev = platform_device_alloc(DRVNAME, address);
824         if (!pdev) {
825                 err = -ENOMEM;
826                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
827                 goto exit;
828         }
829
830         err = platform_device_add_resources(pdev, &res, 1);
831         if (err) {
832                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
833                        "(%d)\n", err);
834                 goto exit_device_put;
835         }
836
837         err = platform_device_add_data(pdev, sio_data,
838                                        sizeof(struct smsc47m1_sio_data));
839         if (err) {
840                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
841                 goto exit_device_put;
842         }
843
844         err = platform_device_add(pdev);
845         if (err) {
846                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
847                        err);
848                 goto exit_device_put;
849         }
850
851         return 0;
852
853 exit_device_put:
854         platform_device_put(pdev);
855 exit:
856         return err;
857 }
858
859 static int __init sm_smsc47m1_init(void)
860 {
861         int err;
862         unsigned short address;
863         struct smsc47m1_sio_data sio_data;
864
865         if (smsc47m1_find(&address, &sio_data))
866                 return -ENODEV;
867
868         /* Sets global pdev as a side effect */
869         err = smsc47m1_device_add(address, &sio_data);
870         if (err)
871                 goto exit;
872
873         err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe);
874         if (err)
875                 goto exit_device;
876
877         return 0;
878
879 exit_device:
880         platform_device_unregister(pdev);
881         smsc47m1_restore(&sio_data);
882 exit:
883         return err;
884 }
885
886 static void __exit sm_smsc47m1_exit(void)
887 {
888         platform_driver_unregister(&smsc47m1_driver);
889         smsc47m1_restore(pdev->dev.platform_data);
890         platform_device_unregister(pdev);
891 }
892
893 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
894 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
895 MODULE_LICENSE("GPL");
896
897 module_init(sm_smsc47m1_init);
898 module_exit(sm_smsc47m1_exit);