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);