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