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