drivers/hwmon/smsc47m1.c

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