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