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