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