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 and LPC47M997 Super-I/O chips.
   7
   8     Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
   9     Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
  10     Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
  11                         and Jean Delvare
  12
  13     This program is free software; you can redistribute it and/or modify
  14     it under the terms of the GNU General Public License as published by
  15     the Free Software Foundation; either version 2 of the License, or
  16     (at your option) any later version.
  17
  18     This program is distributed in the hope that it will be useful,
  19     but WITHOUT ANY WARRANTY; without even the implied warranty of
  20     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21     GNU General Public License for more details.
  22
  23     You should have received a copy of the GNU General Public License
  24     along with this program; if not, write to the Free Software
  25     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26 */
  27
  28 #include <linux/module.h>
  29 #include <linux/slab.h>
  30 #include <linux/ioport.h>
  31 #include <linux/jiffies.h>
  32 #include <linux/i2c.h>
  33 #include <linux/i2c-isa.h>
  34 #include <linux/hwmon.h>
  35 #include <linux/err.h>
  36 #include <linux/init.h>
  37 #include <linux/mutex.h>
  38 #include <linux/sysfs.h>
  39 #include <asm/io.h>
  40
  41 /* Address is autodetected, there is no default value */
  42 static unsigned short address;
  43
  44 /* Super-I/0 registers and commands */
  45
  46 #define REG     0x2e    /* The register to read/write */
  47 #define VAL     0x2f    /* The value to read/write */
  48
  49 static inline void
  50 superio_outb(int reg, int val)
  51 {
  52         outb(reg, REG);
  53         outb(val, VAL);
  54 }
  55
  56 static inline int
  57 superio_inb(int reg)
  58 {
  59         outb(reg, REG);
  60         return inb(VAL);
  61 }
  62
  63 /* logical device for fans is 0x0A */
  64 #define superio_select() superio_outb(0x07, 0x0A)
  65
  66 static inline void
  67 superio_enter(void)
  68 {
  69         outb(0x55, REG);
  70 }
  71
  72 static inline void
  73 superio_exit(void)
  74 {
  75         outb(0xAA, REG);
  76 }
  77
  78 #define SUPERIO_REG_ACT         0x30
  79 #define SUPERIO_REG_BASE        0x60
  80 #define SUPERIO_REG_DEVID       0x20
  81
  82 /* Logical device registers */
  83
  84 #define SMSC_EXTENT             0x80
  85
  86 /* nr is 0 or 1 in the macros below */
  87 #define SMSC47M1_REG_ALARM              0x04
  88 #define SMSC47M1_REG_TPIN(nr)           (0x34 - (nr))
  89 #define SMSC47M1_REG_PPIN(nr)           (0x36 - (nr))
  90 #define SMSC47M1_REG_PWM(nr)            (0x56 + (nr))
  91 #define SMSC47M1_REG_FANDIV             0x58
  92 #define SMSC47M1_REG_FAN(nr)            (0x59 + (nr))
  93 #define SMSC47M1_REG_FAN_PRELOAD(nr)    (0x5B + (nr))
  94
  95 #define MIN_FROM_REG(reg,div)           ((reg)>=192 ? 0 : \
  96                                          983040/((192-(reg))*(div)))
  97 #define FAN_FROM_REG(reg,div,preload)   ((reg)<=(preload) || (reg)==255 ? 0 : \
  98                                          983040/(((reg)-(preload))*(div)))
  99 #define DIV_FROM_REG(reg)               (1 << (reg))
 100 #define PWM_FROM_REG(reg)               (((reg) & 0x7E) << 1)
 101 #define PWM_EN_FROM_REG(reg)            ((~(reg)) & 0x01)
 102 #define PWM_TO_REG(reg)                 (((reg) >> 1) & 0x7E)
 103
 104 struct smsc47m1_data {
 105         struct i2c_client client;
 106         struct class_device *class_dev;
 107         struct mutex lock;
 108
 109         struct mutex update_lock;
 110         unsigned long last_updated;     /* In jiffies */
 111
 112         u8 fan[2];              /* Register value */
 113         u8 fan_preload[2];      /* Register value */
 114         u8 fan_div[2];          /* Register encoding, shifted right */
 115         u8 alarms;              /* Register encoding */
 116         u8 pwm[2];              /* Register value (bit 7 is enable) */
 117 };
 118
 119
 120 static int smsc47m1_detect(struct i2c_adapter *adapter);
 121 static int smsc47m1_detach_client(struct i2c_client *client);
 122
 123 static int smsc47m1_read_value(struct i2c_client *client, u8 reg);
 124 static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value);
 125
 126 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
 127                 int init);
 128
 129
 130 static struct i2c_driver smsc47m1_driver = {
 131         .driver = {
 132                 .owner  = THIS_MODULE,
 133                 .name   = "smsc47m1",
 134         },
 135         .attach_adapter = smsc47m1_detect,
 136         .detach_client  = smsc47m1_detach_client,
 137 };
 138
 139 /* nr is 0 or 1 in the callback functions below */
 140
 141 static ssize_t get_fan(struct device *dev, char *buf, int nr)
 142 {
 143         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 144         /* This chip (stupidly) stops monitoring fan speed if PWM is
 145            enabled and duty cycle is 0%. This is fine if the monitoring
 146            and control concern the same fan, but troublesome if they are
 147            not (which could as well happen). */
 148         int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
 149                   FAN_FROM_REG(data->fan[nr],
 150                                DIV_FROM_REG(data->fan_div[nr]),
 151                                data->fan_preload[nr]);
 152         return sprintf(buf, "%d\n", rpm);
 153 }
 154
 155 static ssize_t get_fan_min(struct device *dev, char *buf, int nr)
 156 {
 157         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 158         int rpm = MIN_FROM_REG(data->fan_preload[nr],
 159                                DIV_FROM_REG(data->fan_div[nr]));
 160         return sprintf(buf, "%d\n", rpm);
 161 }
 162
 163 static ssize_t get_fan_div(struct device *dev, char *buf, int nr)
 164 {
 165         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 166         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 167 }
 168
 169 static ssize_t get_pwm(struct device *dev, char *buf, int nr)
 170 {
 171         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 172         return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 173 }
 174
 175 static ssize_t get_pwm_en(struct device *dev, char *buf, int nr)
 176 {
 177         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 178         return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
 179 }
 180
 181 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 182 {
 183         struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 184         return sprintf(buf, "%d\n", data->alarms);
 185 }
 186
 187 static ssize_t set_fan_min(struct device *dev, const char *buf,
 188                 size_t count, int nr)
 189 {
 190         struct i2c_client *client = to_i2c_client(dev);
 191         struct smsc47m1_data *data = i2c_get_clientdata(client);
 192         long rpmdiv, val = simple_strtol(buf, NULL, 10);
 193
 194         mutex_lock(&data->update_lock);
 195         rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
 196
 197         if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
 198                 mutex_unlock(&data->update_lock);
 199                 return -EINVAL;
 200         }
 201
 202         data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
 203         smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
 204                              data->fan_preload[nr]);
 205         mutex_unlock(&data->update_lock);
 206
 207         return count;
 208 }
 209
 210 /* Note: we save and restore the fan minimum here, because its value is
 211    determined in part by the fan clock divider.  This follows the principle
 212    of least surprise; the user doesn't expect the fan minimum to change just
 213    because the divider changed. */
 214 static ssize_t set_fan_div(struct device *dev, const char *buf,
 215                 size_t count, int nr)
 216 {
 217         struct i2c_client *client = to_i2c_client(dev);
 218         struct smsc47m1_data *data = i2c_get_clientdata(client);
 219
 220         long new_div = simple_strtol(buf, NULL, 10), tmp;
 221         u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
 222
 223         if (new_div == old_div) /* No change */
 224                 return count;
 225
 226         mutex_lock(&data->update_lock);
 227         switch (new_div) {
 228         case 1: data->fan_div[nr] = 0; break;
 229         case 2: data->fan_div[nr] = 1; break;
 230         case 4: data->fan_div[nr] = 2; break;
 231         case 8: data->fan_div[nr] = 3; break;
 232         default:
 233                 mutex_unlock(&data->update_lock);
 234                 return -EINVAL;
 235         }
 236
 237         tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
 238         tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6);
 239         smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);
 240
 241         /* Preserve fan min */
 242         tmp = 192 - (old_div * (192 - data->fan_preload[nr])
 243                      + new_div / 2) / new_div;
 244         data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
 245         smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
 246                              data->fan_preload[nr]);
 247         mutex_unlock(&data->update_lock);
 248
 249         return count;
 250 }
 251
 252 static ssize_t set_pwm(struct device *dev, const char *buf,
 253                 size_t count, int nr)
 254 {
 255         struct i2c_client *client = to_i2c_client(dev);
 256         struct smsc47m1_data *data = i2c_get_clientdata(client);
 257
 258         long val = simple_strtol(buf, NULL, 10);
 259
 260         if (val < 0 || val > 255)
 261                 return -EINVAL;
 262
 263         mutex_lock(&data->update_lock);
 264         data->pwm[nr] &= 0x81; /* Preserve additional bits */
 265         data->pwm[nr] |= PWM_TO_REG(val);
 266         smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
 267                              data->pwm[nr]);
 268         mutex_unlock(&data->update_lock);
 269
 270         return count;
 271 }
 272
 273 static ssize_t set_pwm_en(struct device *dev, const char *buf,
 274                 size_t count, int nr)
 275 {
 276         struct i2c_client *client = to_i2c_client(dev);
 277         struct smsc47m1_data *data = i2c_get_clientdata(client);
 278
 279         long val = simple_strtol(buf, NULL, 10);
 280
 281         if (val != 0 && val != 1)
 282                 return -EINVAL;
 283
 284         mutex_lock(&data->update_lock);
 285         data->pwm[nr] &= 0xFE; /* preserve the other bits */
 286         data->pwm[nr] |= !val;
 287         smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
 288                              data->pwm[nr]);
 289         mutex_unlock(&data->update_lock);
 290
 291         return count;
 292 }
 293
 294 #define fan_present(offset)                                             \
 295 static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf)           \
 296 {                                                                       \
 297         return get_fan(dev, buf, offset - 1);                           \
 298 }                                                                       \
 299 static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)     \
 300 {                                                                       \
 301         return get_fan_min(dev, buf, offset - 1);                       \
 302 }                                                                       \
 303 static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr,                \
 304                 const char *buf, size_t count)                          \
 305 {                                                                       \
 306         return set_fan_min(dev, buf, count, offset - 1);                \
 307 }                                                                       \
 308 static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)     \
 309 {                                                                       \
 310         return get_fan_div(dev, buf, offset - 1);                       \
 311 }                                                                       \
 312 static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr,                \
 313                 const char *buf, size_t count)                          \
 314 {                                                                       \
 315         return set_fan_div(dev, buf, count, offset - 1);                \
 316 }                                                                       \
 317 static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf)           \
 318 {                                                                       \
 319         return get_pwm(dev, buf, offset - 1);                           \
 320 }                                                                       \
 321 static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr,                      \
 322                 const char *buf, size_t count)                          \
 323 {                                                                       \
 324         return set_pwm(dev, buf, count, offset - 1);                    \
 325 }                                                                       \
 326 static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf)      \
 327 {                                                                       \
 328         return get_pwm_en(dev, buf, offset - 1);                        \
 329 }                                                                       \
 330 static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr,         \
 331                 const char *buf, size_t count)                          \
 332 {                                                                       \
 333         return set_pwm_en(dev, buf, count, offset - 1);                 \
 334 }                                                                       \
 335 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset,       \
 336                 NULL);                                                  \
 337 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
 338                 get_fan##offset##_min, set_fan##offset##_min);          \
 339 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,                \
 340                 get_fan##offset##_div, set_fan##offset##_div);          \
 341 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,                      \
 342                 get_pwm##offset, set_pwm##offset);                      \
 343 static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,             \
 344                 get_pwm##offset##_en, set_pwm##offset##_en);
 345
 346 fan_present(1);
 347 fan_present(2);
 348
 349 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
 350
 351 /* Almost all sysfs files may or may not be created depending on the chip
 352    setup so we create them individually. It is still convenient to define a
 353    group to remove them all at once. */
 354 static struct attribute *smsc47m1_attributes[] = {
 355         &dev_attr_fan1_input.attr,
 356         &dev_attr_fan1_min.attr,
 357         &dev_attr_fan1_div.attr,
 358         &dev_attr_fan2_input.attr,
 359         &dev_attr_fan2_min.attr,
 360         &dev_attr_fan2_div.attr,
 361
 362         &dev_attr_pwm1.attr,
 363         &dev_attr_pwm1_enable.attr,
 364         &dev_attr_pwm2.attr,
 365         &dev_attr_pwm2_enable.attr,
 366
 367         &dev_attr_alarms.attr,
 368         NULL
 369 };
 370
 371 static const struct attribute_group smsc47m1_group = {
 372         .attrs = smsc47m1_attributes,
 373 };
 374
 375 static int __init smsc47m1_find(unsigned short *addr)
 376 {
 377         u8 val;
 378
 379         superio_enter();
 380         val = superio_inb(SUPERIO_REG_DEVID);
 381
 382         /*
 383          * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
 384          * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
 385          * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
 386          * can do much more besides (device id 0x60).
 387          * The LPC47M997 is undocumented, but seems to be compatible with
 388          * the LPC47M192, and has the same device id.
 389          */
 390         if (val == 0x51)
 391                 printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
 392         else if (val == 0x59)
 393                 printk(KERN_INFO "smsc47m1: Found SMSC "
 394                        "LPC47M10x/LPC47M112/LPC47M13x\n");
 395         else if (val == 0x5F)
 396                 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
 397         else if (val == 0x60)
 398                 printk(KERN_INFO "smsc47m1: Found SMSC "
 399                        "LPC47M15x/LPC47M192/LPC47M997\n");
 400         else {
 401                 superio_exit();
 402                 return -ENODEV;
 403         }
 404
 405         superio_select();
 406         *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
 407               |  superio_inb(SUPERIO_REG_BASE + 1);
 408         val = superio_inb(SUPERIO_REG_ACT);
 409         if (*addr == 0 || (val & 0x01) == 0) {
 410                 printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
 411                 superio_exit();
 412                 return -ENODEV;
 413         }
 414
 415         superio_exit();
 416         return 0;
 417 }
 418
 419 static int smsc47m1_detect(struct i2c_adapter *adapter)
 420 {
 421         struct i2c_client *new_client;
 422         struct smsc47m1_data *data;
 423         int err = 0;
 424         int fan1, fan2, pwm1, pwm2;
 425
 426         if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.driver.name)) {
 427                 dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
 428                 return -EBUSY;
 429         }
 430
 431         if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
 432                 err = -ENOMEM;
 433                 goto error_release;
 434         }
 435
 436         new_client = &data->client;
 437         i2c_set_clientdata(new_client, data);
 438         new_client->addr = address;
 439         mutex_init(&data->lock);
 440         new_client->adapter = adapter;
 441         new_client->driver = &smsc47m1_driver;
 442         new_client->flags = 0;
 443
 444         strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
 445         mutex_init(&data->update_lock);
 446
 447         /* If no function is properly configured, there's no point in
 448            actually registering the chip. */
 449         fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
 450                == 0x05;
 451         fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
 452                == 0x05;
 453         pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
 454                == 0x04;
 455         pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
 456                == 0x04;
 457         if (!(fan1 || fan2 || pwm1 || pwm2)) {
 458                 dev_warn(&adapter->dev, "Device at 0x%x is not configured, "
 459                          "will not use\n", new_client->addr);
 460                 err = -ENODEV;
 461                 goto error_free;
 462         }
 463
 464         if ((err = i2c_attach_client(new_client)))
 465                 goto error_free;
 466
 467         /* Some values (fan min, clock dividers, pwm registers) may be
 468            needed before any update is triggered, so we better read them
 469            at least once here. We don't usually do it that way, but in
 470            this particular case, manually reading 5 registers out of 8
 471            doesn't make much sense and we're better using the existing
 472            function. */
 473         smsc47m1_update_device(&new_client->dev, 1);
 474
 475         /* Register sysfs hooks */
 476         if (fan1) {
 477                 if ((err = device_create_file(&new_client->dev,
 478                                               &dev_attr_fan1_input))
 479                  || (err = device_create_file(&new_client->dev,
 480                                               &dev_attr_fan1_min))
 481                  || (err = device_create_file(&new_client->dev,
 482                                               &dev_attr_fan1_div)))
 483                         goto error_remove_files;
 484         } else
 485                 dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
 486                         "skipping\n");
 487
 488         if (fan2) {
 489                 if ((err = device_create_file(&new_client->dev,
 490                                               &dev_attr_fan2_input))
 491                  || (err = device_create_file(&new_client->dev,
 492                                               &dev_attr_fan2_min))
 493                  || (err = device_create_file(&new_client->dev,
 494                                               &dev_attr_fan2_div)))
 495                         goto error_remove_files;
 496         } else
 497                 dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
 498                         "skipping\n");
 499
 500         if (pwm1) {
 501                 if ((err = device_create_file(&new_client->dev,
 502                                               &dev_attr_pwm1))
 503                  || (err = device_create_file(&new_client->dev,
 504                                               &dev_attr_pwm1_enable)))
 505                         goto error_remove_files;
 506         } else
 507                 dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
 508                         "skipping\n");
 509         if (pwm2) {
 510                 if ((err = device_create_file(&new_client->dev,
 511                                               &dev_attr_pwm2))
 512                  || (err = device_create_file(&new_client->dev,
 513                                               &dev_attr_pwm2_enable)))
 514                         goto error_remove_files;
 515         } else
 516                 dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
 517                         "skipping\n");
 518
 519         if ((err = device_create_file(&new_client->dev, &dev_attr_alarms)))
 520                 goto error_remove_files;
 521
 522         data->class_dev = hwmon_device_register(&new_client->dev);
 523         if (IS_ERR(data->class_dev)) {
 524                 err = PTR_ERR(data->class_dev);
 525                 goto error_remove_files;
 526         }
 527
 528         return 0;
 529
 530 error_remove_files:
 531         sysfs_remove_group(&new_client->dev.kobj, &smsc47m1_group);
 532         i2c_detach_client(new_client);
 533 error_free:
 534         kfree(data);
 535 error_release:
 536         release_region(address, SMSC_EXTENT);
 537         return err;
 538 }
 539
 540 static int smsc47m1_detach_client(struct i2c_client *client)
 541 {
 542         struct smsc47m1_data *data = i2c_get_clientdata(client);
 543         int err;
 544
 545         hwmon_device_unregister(data->class_dev);
 546         sysfs_remove_group(&client->dev.kobj, &smsc47m1_group);
 547
 548         if ((err = i2c_detach_client(client)))
 549                 return err;
 550
 551         release_region(client->addr, SMSC_EXTENT);
 552         kfree(data);
 553
 554         return 0;
 555 }
 556
 557 static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
 558 {
 559         int res;
 560
 561         mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
 562         res = inb_p(client->addr + reg);
 563         mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
 564         return res;
 565 }
 566
 567 static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
 568 {
 569         mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
 570         outb_p(value, client->addr + reg);
 571         mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
 572 }
 573
 574 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
 575                 int init)
 576 {
 577         struct i2c_client *client = to_i2c_client(dev);
 578         struct smsc47m1_data *data = i2c_get_clientdata(client);
 579
 580         mutex_lock(&data->update_lock);
 581
 582         if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
 583                 int i;
 584
 585                 for (i = 0; i < 2; i++) {
 586                         data->fan[i] = smsc47m1_read_value(client,
 587                                        SMSC47M1_REG_FAN(i));
 588                         data->fan_preload[i] = smsc47m1_read_value(client,
 589                                                SMSC47M1_REG_FAN_PRELOAD(i));
 590                         data->pwm[i] = smsc47m1_read_value(client,
 591                                        SMSC47M1_REG_PWM(i));
 592                 }
 593
 594                 i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
 595                 data->fan_div[0] = (i >> 4) & 0x03;
 596                 data->fan_div[1] = i >> 6;
 597
 598                 data->alarms = smsc47m1_read_value(client,
 599                                SMSC47M1_REG_ALARM) >> 6;
 600                 /* Clear alarms if needed */
 601                 if (data->alarms)
 602                         smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);
 603
 604                 data->last_updated = jiffies;
 605         }
 606
 607         mutex_unlock(&data->update_lock);
 608         return data;
 609 }
 610
 611 static int __init sm_smsc47m1_init(void)
 612 {
 613         if (smsc47m1_find(&address)) {
 614                 return -ENODEV;
 615         }
 616
 617         return i2c_isa_add_driver(&smsc47m1_driver);
 618 }
 619
 620 static void __exit sm_smsc47m1_exit(void)
 621 {
 622         i2c_isa_del_driver(&smsc47m1_driver);
 623 }
 624
 625 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
 626 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
 627 MODULE_LICENSE("GPL");
 628
 629 module_init(sm_smsc47m1_init);
 630 module_exit(sm_smsc47m1_exit);