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