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(struct smsc47m1_sio_data *sio_data)
 495 {
 496         u8 val;
 497         unsigned short addr;
 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 addr;
 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
 588 /*
 589  * This function can be used to:
 590  *  - test for resource conflicts with ACPI
 591  *  - request the resources
 592  * We only allocate the I/O ports we really need, to minimize the risk of
 593  * conflicts with ACPI or with other drivers.
 594  */
 595 static int __init smsc47m1_handle_resources(unsigned short address,
 596                                             enum chips type, int action,
 597                                             struct device *dev)
 598 {
 599         static const u8 ports_m1[] = {
 600                 /* register, region length */
 601                 0x04, 1,
 602                 0x33, 4,
 603                 0x56, 7,
 604         };
 605
 606         static const u8 ports_m2[] = {
 607                 /* register, region length */
 608                 0x04, 1,
 609                 0x09, 1,
 610                 0x2c, 2,
 611                 0x35, 4,
 612                 0x56, 7,
 613                 0x69, 4,
 614         };
 615
 616         int i, ports_size, err;
 617         const u8 *ports;
 618
 619         switch (type) {
 620         case smsc47m1:
 621         default:
 622                 ports = ports_m1;
 623                 ports_size = ARRAY_SIZE(ports_m1);
 624                 break;
 625         case smsc47m2:
 626                 ports = ports_m2;
 627                 ports_size = ARRAY_SIZE(ports_m2);
 628                 break;
 629         }
 630
 631         for (i = 0; i + 1 < ports_size; i += 2) {
 632                 unsigned short start = address + ports[i];
 633                 unsigned short len = ports[i + 1];
 634
 635                 switch (action) {
 636                 case CHECK:
 637                         /* Only check for conflicts */
 638                         err = acpi_check_region(start, len, DRVNAME);
 639                         if (err)
 640                                 return err;
 641                         break;
 642                 case REQUEST:
 643                         /* Request the resources */
 644                         if (!devm_request_region(dev, start, len, DRVNAME)) {
 645                                 dev_err(dev,
 646                                         "Region 0x%hx-0x%hx already in use!\n",
 647                                         start, start + len);
 648                                 return -EBUSY;
 649                         }
 650                         break;
 651                 }
 652         }
 653
 654         return 0;
 655 }
 656
 657 static void smsc47m1_remove_files(struct device *dev)
 658 {
 659         sysfs_remove_group(&dev->kobj, &smsc47m1_group);
 660         sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan1);
 661         sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan2);
 662         sysfs_remove_group(&dev->kobj, &smsc47m1_group_fan3);
 663         sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm1);
 664         sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm2);
 665         sysfs_remove_group(&dev->kobj, &smsc47m1_group_pwm3);
 666 }
 667
 668 static int __init smsc47m1_probe(struct platform_device *pdev)
 669 {
 670         struct device *dev = &pdev->dev;
 671         struct smsc47m1_sio_data *sio_data = dev->platform_data;
 672         struct smsc47m1_data *data;
 673         struct resource *res;
 674         int err;
 675         int fan1, fan2, fan3, pwm1, pwm2, pwm3;
 676
 677         static const char * const names[] = {
 678                 "smsc47m1",
 679                 "smsc47m2",
 680         };
 681
 682         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 683         err = smsc47m1_handle_resources(res->start, sio_data->type,
 684                                         REQUEST, dev);
 685         if (err < 0)
 686                 return err;
 687
 688         data = devm_kzalloc(dev, sizeof(struct smsc47m1_data), GFP_KERNEL);
 689         if (!data)
 690                 return -ENOMEM;
 691
 692         data->addr = res->start;
 693         data->type = sio_data->type;
 694         data->name = names[sio_data->type];
 695         mutex_init(&data->update_lock);
 696         platform_set_drvdata(pdev, data);
 697
 698         /*
 699          * If no function is properly configured, there's no point in
 700          * actually registering the chip.
 701          */
 702         pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
 703                == 0x04;
 704         pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
 705                == 0x04;
 706         if (data->type == smsc47m2) {
 707                 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
 708                         & 0x0d) == 0x09;
 709                 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
 710                         & 0x0d) == 0x09;
 711                 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
 712                         & 0x0d) == 0x0d;
 713                 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
 714                         & 0x0d) == 0x08;
 715         } else {
 716                 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
 717                         & 0x05) == 0x05;
 718                 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
 719                         & 0x05) == 0x05;
 720                 fan3 = 0;
 721                 pwm3 = 0;
 722         }
 723         if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
 724                 dev_warn(dev, "Device not configured, will not use\n");
 725                 return -ENODEV;
 726         }
 727
 728         /*
 729          * Some values (fan min, clock dividers, pwm registers) may be
 730          * needed before any update is triggered, so we better read them
 731          * at least once here. We don't usually do it that way, but in
 732          * this particular case, manually reading 5 registers out of 8
 733          * doesn't make much sense and we're better using the existing
 734          * function.
 735          */
 736         smsc47m1_update_device(dev, 1);
 737
 738         /* Register sysfs hooks */
 739         if (fan1) {
 740                 err = sysfs_create_group(&dev->kobj,
 741                                          &smsc47m1_group_fan1);
 742                 if (err)
 743                         goto error_remove_files;
 744         } else
 745                 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
 746
 747         if (fan2) {
 748                 err = sysfs_create_group(&dev->kobj,
 749                                          &smsc47m1_group_fan2);
 750                 if (err)
 751                         goto error_remove_files;
 752         } else
 753                 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
 754
 755         if (fan3) {
 756                 err = sysfs_create_group(&dev->kobj,
 757                                          &smsc47m1_group_fan3);
 758                 if (err)
 759                         goto error_remove_files;
 760         } else if (data->type == smsc47m2)
 761                 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
 762
 763         if (pwm1) {
 764                 err = sysfs_create_group(&dev->kobj,
 765                                          &smsc47m1_group_pwm1);
 766                 if (err)
 767                         goto error_remove_files;
 768         } else
 769                 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
 770
 771         if (pwm2) {
 772                 err = sysfs_create_group(&dev->kobj,
 773                                          &smsc47m1_group_pwm2);
 774                 if (err)
 775                         goto error_remove_files;
 776         } else
 777                 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
 778
 779         if (pwm3) {
 780                 err = sysfs_create_group(&dev->kobj,
 781                                          &smsc47m1_group_pwm3);
 782                 if (err)
 783                         goto error_remove_files;
 784         } else if (data->type == smsc47m2)
 785                 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
 786
 787         err = sysfs_create_group(&dev->kobj, &smsc47m1_group);
 788         if (err)
 789                 goto error_remove_files;
 790
 791         data->hwmon_dev = hwmon_device_register(dev);
 792         if (IS_ERR(data->hwmon_dev)) {
 793                 err = PTR_ERR(data->hwmon_dev);
 794                 goto error_remove_files;
 795         }
 796
 797         return 0;
 798
 799 error_remove_files:
 800         smsc47m1_remove_files(dev);
 801         return err;
 802 }
 803
 804 static int __exit smsc47m1_remove(struct platform_device *pdev)
 805 {
 806         struct smsc47m1_data *data = platform_get_drvdata(pdev);
 807
 808         hwmon_device_unregister(data->hwmon_dev);
 809         smsc47m1_remove_files(&pdev->dev);
 810
 811         return 0;
 812 }
 813
 814 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
 815                 int init)
 816 {
 817         struct smsc47m1_data *data = dev_get_drvdata(dev);
 818
 819         mutex_lock(&data->update_lock);
 820
 821         if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
 822                 int i, fan_nr;
 823                 fan_nr = data->type == smsc47m2 ? 3 : 2;
 824
 825                 for (i = 0; i < fan_nr; i++) {
 826                         data->fan[i] = smsc47m1_read_value(data,
 827                                        SMSC47M1_REG_FAN[i]);
 828                         data->fan_preload[i] = smsc47m1_read_value(data,
 829                                                SMSC47M1_REG_FAN_PRELOAD[i]);
 830                         data->pwm[i] = smsc47m1_read_value(data,
 831                                        SMSC47M1_REG_PWM[i]);
 832                 }
 833
 834                 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
 835                 data->fan_div[0] = (i >> 4) & 0x03;
 836                 data->fan_div[1] = i >> 6;
 837
 838                 data->alarms = smsc47m1_read_value(data,
 839                                SMSC47M1_REG_ALARM) >> 6;
 840                 /* Clear alarms if needed */
 841                 if (data->alarms)
 842                         smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
 843
 844                 if (fan_nr >= 3) {
 845                         data->fan_div[2] = (smsc47m1_read_value(data,
 846                                             SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
 847                         data->alarms |= (smsc47m1_read_value(data,
 848                                          SMSC47M2_REG_ALARM6) & 0x40) >> 4;
 849                         /* Clear alarm if needed */
 850                         if (data->alarms & 0x04)
 851                                 smsc47m1_write_value(data,
 852                                                      SMSC47M2_REG_ALARM6,
 853                                                      0x40);
 854                 }
 855
 856                 data->last_updated = jiffies;
 857         }
 858
 859         mutex_unlock(&data->update_lock);
 860         return data;
 861 }
 862
 863 static int __init smsc47m1_device_add(unsigned short address,
 864                                       const struct smsc47m1_sio_data *sio_data)
 865 {
 866         struct resource res = {
 867                 .start  = address,
 868                 .end    = address + SMSC_EXTENT - 1,
 869                 .name   = DRVNAME,
 870                 .flags  = IORESOURCE_IO,
 871         };
 872         int err;
 873
 874         err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL);
 875         if (err)
 876                 goto exit;
 877
 878         pdev = platform_device_alloc(DRVNAME, address);
 879         if (!pdev) {
 880                 err = -ENOMEM;
 881                 pr_err("Device allocation failed\n");
 882                 goto exit;
 883         }
 884
 885         err = platform_device_add_resources(pdev, &res, 1);
 886         if (err) {
 887                 pr_err("Device resource addition failed (%d)\n", err);
 888                 goto exit_device_put;
 889         }
 890
 891         err = platform_device_add_data(pdev, sio_data,
 892                                        sizeof(struct smsc47m1_sio_data));
 893         if (err) {
 894                 pr_err("Platform data allocation failed\n");
 895                 goto exit_device_put;
 896         }
 897
 898         err = platform_device_add(pdev);
 899         if (err) {
 900                 pr_err("Device addition failed (%d)\n", err);
 901                 goto exit_device_put;
 902         }
 903
 904         return 0;
 905
 906 exit_device_put:
 907         platform_device_put(pdev);
 908 exit:
 909         return err;
 910 }
 911
 912 static int __init sm_smsc47m1_init(void)
 913 {
 914         int err;
 915         unsigned short address;
 916         struct smsc47m1_sio_data sio_data;
 917
 918         err = smsc47m1_find(&sio_data);
 919         if (err < 0)
 920                 return err;
 921         address = err;
 922
 923         /* Sets global pdev as a side effect */
 924         err = smsc47m1_device_add(address, &sio_data);
 925         if (err)
 926                 return err;
 927
 928         err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe);
 929         if (err)
 930                 goto exit_device;
 931
 932         return 0;
 933
 934 exit_device:
 935         platform_device_unregister(pdev);
 936         smsc47m1_restore(&sio_data);
 937         return err;
 938 }
 939
 940 static void __exit sm_smsc47m1_exit(void)
 941 {
 942         platform_driver_unregister(&smsc47m1_driver);
 943         smsc47m1_restore(pdev->dev.platform_data);
 944         platform_device_unregister(pdev);
 945 }
 946
 947 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
 948 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
 949 MODULE_LICENSE("GPL");
 950
 951 module_init(sm_smsc47m1_init);
 952 module_exit(sm_smsc47m1_exit);