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