1 /* 2 * pc87427.c - hardware monitoring driver for the 3 * National Semiconductor PC87427 Super-I/O chip 4 * Copyright (C) 2006 Jean Delvare <khali@linux-fr.org> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * Supports the following chips: 16 * 17 * Chip #vin #fan #pwm #temp devid 18 * PC87427 - 8 - - 0xF2 19 * 20 * This driver assumes that no more than one chip is present. 21 * Only fan inputs are supported so far, although the chip can do much more. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/jiffies.h> 28 #include <linux/platform_device.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/err.h> 32 #include <linux/mutex.h> 33 #include <linux/sysfs.h> 34 #include <asm/io.h> 35 36 static struct platform_device *pdev; 37 38 #define DRVNAME "pc87427" 39 40 /* The lock mutex protects both the I/O accesses (needed because the 41 device is using banked registers) and the register cache (needed to keep 42 the data in the registers and the cache in sync at any time). */ 43 struct pc87427_data { 44 struct class_device *class_dev; 45 struct mutex lock; 46 int address[2]; 47 const char *name; 48 49 unsigned long last_updated; /* in jiffies */ 50 u8 fan_enabled; /* bit vector */ 51 u16 fan[8]; /* register values */ 52 u16 fan_min[8]; /* register values */ 53 u8 fan_status[8]; /* register values */ 54 }; 55 56 /* 57 * Super-I/O registers and operations 58 */ 59 60 #define SIOREG_LDSEL 0x07 /* Logical device select */ 61 #define SIOREG_DEVID 0x20 /* Device ID */ 62 #define SIOREG_ACT 0x30 /* Device activation */ 63 #define SIOREG_MAP 0x50 /* I/O or memory mapping */ 64 #define SIOREG_IOBASE 0x60 /* I/O base address */ 65 66 static const u8 logdev[2] = { 0x09, 0x14 }; 67 static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" }; 68 #define LD_FAN 0 69 #define LD_IN 1 70 #define LD_TEMP 1 71 72 static inline void superio_outb(int sioaddr, int reg, int val) 73 { 74 outb(reg, sioaddr); 75 outb(val, sioaddr + 1); 76 } 77 78 static inline int superio_inb(int sioaddr, int reg) 79 { 80 outb(reg, sioaddr); 81 return inb(sioaddr + 1); 82 } 83 84 static inline void superio_exit(int sioaddr) 85 { 86 outb(0x02, sioaddr); 87 outb(0x02, sioaddr + 1); 88 } 89 90 /* 91 * Logical devices 92 */ 93 94 #define REGION_LENGTH 32 95 #define PC87427_REG_BANK 0x0f 96 #define BANK_FM(nr) (nr) 97 #define BANK_FT(nr) (0x08 + (nr)) 98 #define BANK_FC(nr) (0x10 + (nr) * 2) 99 100 /* 101 * I/O access functions 102 */ 103 104 /* ldi is the logical device index */ 105 static inline int pc87427_read8(struct pc87427_data *data, u8 ldi, u8 reg) 106 { 107 return inb(data->address[ldi] + reg); 108 } 109 110 /* Must be called with data->lock held, except during init */ 111 static inline int pc87427_read8_bank(struct pc87427_data *data, u8 ldi, 112 u8 bank, u8 reg) 113 { 114 outb(bank, data->address[ldi] + PC87427_REG_BANK); 115 return inb(data->address[ldi] + reg); 116 } 117 118 /* Must be called with data->lock held, except during init */ 119 static inline void pc87427_write8_bank(struct pc87427_data *data, u8 ldi, 120 u8 bank, u8 reg, u8 value) 121 { 122 outb(bank, data->address[ldi] + PC87427_REG_BANK); 123 outb(value, data->address[ldi] + reg); 124 } 125 126 /* 127 * Fan registers and conversions 128 */ 129 130 /* fan data registers are 16-bit wide */ 131 #define PC87427_REG_FAN 0x12 132 #define PC87427_REG_FAN_MIN 0x14 133 #define PC87427_REG_FAN_STATUS 0x10 134 135 #define FAN_STATUS_STALL (1 << 3) 136 #define FAN_STATUS_LOSPD (1 << 1) 137 #define FAN_STATUS_MONEN (1 << 0) 138 139 /* Dedicated function to read all registers related to a given fan input. 140 This saves us quite a few locks and bank selections. 141 Must be called with data->lock held. 142 nr is from 0 to 7 */ 143 static void pc87427_readall_fan(struct pc87427_data *data, u8 nr) 144 { 145 int iobase = data->address[LD_FAN]; 146 147 outb(BANK_FM(nr), iobase + PC87427_REG_BANK); 148 data->fan[nr] = inw(iobase + PC87427_REG_FAN); 149 data->fan_min[nr] = inw(iobase + PC87427_REG_FAN_MIN); 150 data->fan_status[nr] = inb(iobase + PC87427_REG_FAN_STATUS); 151 /* Clear fan alarm bits */ 152 outb(data->fan_status[nr], iobase + PC87427_REG_FAN_STATUS); 153 } 154 155 /* The 2 LSB of fan speed registers are used for something different. 156 The actual 2 LSB of the measurements are not available. */ 157 static inline unsigned long fan_from_reg(u16 reg) 158 { 159 reg &= 0xfffc; 160 if (reg == 0x0000 || reg == 0xfffc) 161 return 0; 162 return 5400000UL / reg; 163 } 164 165 /* The 2 LSB of the fan speed limit registers are not significant. */ 166 static inline u16 fan_to_reg(unsigned long val) 167 { 168 if (val < 83UL) 169 return 0xffff; 170 if (val >= 1350000UL) 171 return 0x0004; 172 return ((1350000UL + val / 2) / val) << 2; 173 } 174 175 /* 176 * Data interface 177 */ 178 179 static struct pc87427_data *pc87427_update_device(struct device *dev) 180 { 181 struct pc87427_data *data = dev_get_drvdata(dev); 182 int i; 183 184 mutex_lock(&data->lock); 185 if (!time_after(jiffies, data->last_updated + HZ) 186 && data->last_updated) 187 goto done; 188 189 /* Fans */ 190 for (i = 0; i < 8; i++) { 191 if (!(data->fan_enabled & (1 << i))) 192 continue; 193 pc87427_readall_fan(data, i); 194 } 195 data->last_updated = jiffies; 196 197 done: 198 mutex_unlock(&data->lock); 199 return data; 200 } 201 202 static ssize_t show_fan_input(struct device *dev, struct device_attribute 203 *devattr, char *buf) 204 { 205 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 206 struct pc87427_data *data = pc87427_update_device(dev); 207 int nr = attr->index; 208 209 return sprintf(buf, "%lu\n", fan_from_reg(data->fan[nr])); 210 } 211 212 static ssize_t show_fan_min(struct device *dev, struct device_attribute 213 *devattr, char *buf) 214 { 215 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 216 struct pc87427_data *data = pc87427_update_device(dev); 217 int nr = attr->index; 218 219 return sprintf(buf, "%lu\n", fan_from_reg(data->fan_min[nr])); 220 } 221 222 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute 223 *devattr, char *buf) 224 { 225 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 226 struct pc87427_data *data = pc87427_update_device(dev); 227 int nr = attr->index; 228 229 return sprintf(buf, "%d\n", !!(data->fan_status[nr] 230 & FAN_STATUS_LOSPD)); 231 } 232 233 static ssize_t show_fan_fault(struct device *dev, struct device_attribute 234 *devattr, char *buf) 235 { 236 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 237 struct pc87427_data *data = pc87427_update_device(dev); 238 int nr = attr->index; 239 240 return sprintf(buf, "%d\n", !!(data->fan_status[nr] 241 & FAN_STATUS_STALL)); 242 } 243 244 static ssize_t set_fan_min(struct device *dev, struct device_attribute 245 *devattr, const char *buf, size_t count) 246 { 247 struct pc87427_data *data = dev_get_drvdata(dev); 248 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 249 int nr = attr->index; 250 unsigned long val = simple_strtoul(buf, NULL, 10); 251 int iobase = data->address[LD_FAN]; 252 253 mutex_lock(&data->lock); 254 outb(BANK_FM(nr), iobase + PC87427_REG_BANK); 255 /* The low speed limit registers are read-only while monitoring 256 is enabled, so we have to disable monitoring, then change the 257 limit, and finally enable monitoring again. */ 258 outb(0, iobase + PC87427_REG_FAN_STATUS); 259 data->fan_min[nr] = fan_to_reg(val); 260 outw(data->fan_min[nr], iobase + PC87427_REG_FAN_MIN); 261 outb(FAN_STATUS_MONEN, iobase + PC87427_REG_FAN_STATUS); 262 mutex_unlock(&data->lock); 263 264 return count; 265 } 266 267 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0); 268 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1); 269 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2); 270 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3); 271 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_input, NULL, 4); 272 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_input, NULL, 5); 273 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_input, NULL, 6); 274 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_input, NULL, 7); 275 276 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, 277 show_fan_min, set_fan_min, 0); 278 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, 279 show_fan_min, set_fan_min, 1); 280 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, 281 show_fan_min, set_fan_min, 2); 282 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, 283 show_fan_min, set_fan_min, 3); 284 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, 285 show_fan_min, set_fan_min, 4); 286 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, 287 show_fan_min, set_fan_min, 5); 288 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, 289 show_fan_min, set_fan_min, 6); 290 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, 291 show_fan_min, set_fan_min, 7); 292 293 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0); 294 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 1); 295 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 2); 296 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 3); 297 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_fan_alarm, NULL, 4); 298 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_fan_alarm, NULL, 5); 299 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_fan_alarm, NULL, 6); 300 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_fan_alarm, NULL, 7); 301 302 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL, 0); 303 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault, NULL, 1); 304 static SENSOR_DEVICE_ATTR(fan3_fault, S_IRUGO, show_fan_fault, NULL, 2); 305 static SENSOR_DEVICE_ATTR(fan4_fault, S_IRUGO, show_fan_fault, NULL, 3); 306 static SENSOR_DEVICE_ATTR(fan5_fault, S_IRUGO, show_fan_fault, NULL, 4); 307 static SENSOR_DEVICE_ATTR(fan6_fault, S_IRUGO, show_fan_fault, NULL, 5); 308 static SENSOR_DEVICE_ATTR(fan7_fault, S_IRUGO, show_fan_fault, NULL, 6); 309 static SENSOR_DEVICE_ATTR(fan8_fault, S_IRUGO, show_fan_fault, NULL, 7); 310 311 static struct attribute *pc87427_attributes_fan[8][5] = { 312 { 313 &sensor_dev_attr_fan1_input.dev_attr.attr, 314 &sensor_dev_attr_fan1_min.dev_attr.attr, 315 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 316 &sensor_dev_attr_fan1_fault.dev_attr.attr, 317 NULL 318 }, { 319 &sensor_dev_attr_fan2_input.dev_attr.attr, 320 &sensor_dev_attr_fan2_min.dev_attr.attr, 321 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 322 &sensor_dev_attr_fan2_fault.dev_attr.attr, 323 NULL 324 }, { 325 &sensor_dev_attr_fan3_input.dev_attr.attr, 326 &sensor_dev_attr_fan3_min.dev_attr.attr, 327 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 328 &sensor_dev_attr_fan3_fault.dev_attr.attr, 329 NULL 330 }, { 331 &sensor_dev_attr_fan4_input.dev_attr.attr, 332 &sensor_dev_attr_fan4_min.dev_attr.attr, 333 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 334 &sensor_dev_attr_fan4_fault.dev_attr.attr, 335 NULL 336 }, { 337 &sensor_dev_attr_fan5_input.dev_attr.attr, 338 &sensor_dev_attr_fan5_min.dev_attr.attr, 339 &sensor_dev_attr_fan5_alarm.dev_attr.attr, 340 &sensor_dev_attr_fan5_fault.dev_attr.attr, 341 NULL 342 }, { 343 &sensor_dev_attr_fan6_input.dev_attr.attr, 344 &sensor_dev_attr_fan6_min.dev_attr.attr, 345 &sensor_dev_attr_fan6_alarm.dev_attr.attr, 346 &sensor_dev_attr_fan6_fault.dev_attr.attr, 347 NULL 348 }, { 349 &sensor_dev_attr_fan7_input.dev_attr.attr, 350 &sensor_dev_attr_fan7_min.dev_attr.attr, 351 &sensor_dev_attr_fan7_alarm.dev_attr.attr, 352 &sensor_dev_attr_fan7_fault.dev_attr.attr, 353 NULL 354 }, { 355 &sensor_dev_attr_fan8_input.dev_attr.attr, 356 &sensor_dev_attr_fan8_min.dev_attr.attr, 357 &sensor_dev_attr_fan8_alarm.dev_attr.attr, 358 &sensor_dev_attr_fan8_fault.dev_attr.attr, 359 NULL 360 } 361 }; 362 363 static const struct attribute_group pc87427_group_fan[8] = { 364 { .attrs = pc87427_attributes_fan[0] }, 365 { .attrs = pc87427_attributes_fan[1] }, 366 { .attrs = pc87427_attributes_fan[2] }, 367 { .attrs = pc87427_attributes_fan[3] }, 368 { .attrs = pc87427_attributes_fan[4] }, 369 { .attrs = pc87427_attributes_fan[5] }, 370 { .attrs = pc87427_attributes_fan[6] }, 371 { .attrs = pc87427_attributes_fan[7] }, 372 }; 373 374 static ssize_t show_name(struct device *dev, struct device_attribute 375 *devattr, char *buf) 376 { 377 struct pc87427_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 384 /* 385 * Device detection, attach and detach 386 */ 387 388 static void __devinit pc87427_init_device(struct device *dev) 389 { 390 struct pc87427_data *data = dev_get_drvdata(dev); 391 int i; 392 u8 reg; 393 394 /* The FMC module should be ready */ 395 reg = pc87427_read8(data, LD_FAN, PC87427_REG_BANK); 396 if (!(reg & 0x80)) 397 dev_warn(dev, "FMC module not ready!\n"); 398 399 /* Check which fans are enabled */ 400 for (i = 0; i < 8; i++) { 401 reg = pc87427_read8_bank(data, LD_FAN, BANK_FM(i), 402 PC87427_REG_FAN_STATUS); 403 if (reg & FAN_STATUS_MONEN) 404 data->fan_enabled |= (1 << i); 405 } 406 407 if (!data->fan_enabled) { 408 dev_dbg(dev, "Enabling all fan inputs\n"); 409 for (i = 0; i < 8; i++) 410 pc87427_write8_bank(data, LD_FAN, BANK_FM(i), 411 PC87427_REG_FAN_STATUS, 412 FAN_STATUS_MONEN); 413 data->fan_enabled = 0xff; 414 } 415 } 416 417 static int __devinit pc87427_probe(struct platform_device *pdev) 418 { 419 struct pc87427_data *data; 420 struct resource *res; 421 int i, err; 422 423 if (!(data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL))) { 424 err = -ENOMEM; 425 printk(KERN_ERR DRVNAME ": Out of memory\n"); 426 goto exit; 427 } 428 429 /* This will need to be revisited when we add support for 430 temperature and voltage monitoring. */ 431 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 432 data->address[0] = res->start; 433 434 mutex_init(&data->lock); 435 data->name = "pc87427"; 436 platform_set_drvdata(pdev, data); 437 pc87427_init_device(&pdev->dev); 438 439 /* Register sysfs hooks */ 440 if ((err = device_create_file(&pdev->dev, &dev_attr_name))) 441 goto exit_kfree; 442 for (i = 0; i < 8; i++) { 443 if (!(data->fan_enabled & (1 << i))) 444 continue; 445 if ((err = sysfs_create_group(&pdev->dev.kobj, 446 &pc87427_group_fan[i]))) 447 goto exit_remove_files; 448 } 449 450 data->class_dev = hwmon_device_register(&pdev->dev); 451 if (IS_ERR(data->class_dev)) { 452 err = PTR_ERR(data->class_dev); 453 dev_err(&pdev->dev, "Class registration failed (%d)\n", err); 454 goto exit_remove_files; 455 } 456 457 return 0; 458 459 exit_remove_files: 460 for (i = 0; i < 8; i++) { 461 if (!(data->fan_enabled & (1 << i))) 462 continue; 463 sysfs_remove_group(&pdev->dev.kobj, &pc87427_group_fan[i]); 464 } 465 exit_kfree: 466 platform_set_drvdata(pdev, NULL); 467 kfree(data); 468 exit: 469 return err; 470 } 471 472 static int __devexit pc87427_remove(struct platform_device *pdev) 473 { 474 struct pc87427_data *data = platform_get_drvdata(pdev); 475 int i; 476 477 platform_set_drvdata(pdev, NULL); 478 hwmon_device_unregister(data->class_dev); 479 device_remove_file(&pdev->dev, &dev_attr_name); 480 for (i = 0; i < 8; i++) { 481 if (!(data->fan_enabled & (1 << i))) 482 continue; 483 sysfs_remove_group(&pdev->dev.kobj, &pc87427_group_fan[i]); 484 } 485 kfree(data); 486 487 return 0; 488 } 489 490 491 static struct platform_driver pc87427_driver = { 492 .driver = { 493 .owner = THIS_MODULE, 494 .name = DRVNAME, 495 }, 496 .probe = pc87427_probe, 497 .remove = __devexit_p(pc87427_remove), 498 }; 499 500 static int __init pc87427_device_add(unsigned short address) 501 { 502 struct resource res = { 503 .start = address, 504 .end = address + REGION_LENGTH - 1, 505 .name = logdev_str[0], 506 .flags = IORESOURCE_IO, 507 }; 508 int err; 509 510 pdev = platform_device_alloc(DRVNAME, address); 511 if (!pdev) { 512 err = -ENOMEM; 513 printk(KERN_ERR DRVNAME ": Device allocation failed\n"); 514 goto exit; 515 } 516 517 err = platform_device_add_resources(pdev, &res, 1); 518 if (err) { 519 printk(KERN_ERR DRVNAME ": Device resource addition failed " 520 "(%d)\n", err); 521 goto exit_device_put; 522 } 523 524 err = platform_device_add(pdev); 525 if (err) { 526 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n", 527 err); 528 goto exit_device_put; 529 } 530 531 return 0; 532 533 exit_device_put: 534 platform_device_put(pdev); 535 exit: 536 return err; 537 } 538 539 static int __init pc87427_find(int sioaddr, unsigned short *address) 540 { 541 u16 val; 542 int i, err = 0; 543 544 /* Identify device */ 545 val = superio_inb(sioaddr, SIOREG_DEVID); 546 if (val != 0xf2) { /* PC87427 */ 547 err = -ENODEV; 548 goto exit; 549 } 550 551 for (i = 0; i < 2; i++) { 552 address[i] = 0; 553 /* Select logical device */ 554 superio_outb(sioaddr, SIOREG_LDSEL, logdev[i]); 555 556 val = superio_inb(sioaddr, SIOREG_ACT); 557 if (!(val & 0x01)) { 558 printk(KERN_INFO DRVNAME ": Logical device 0x%02x " 559 "not activated\n", logdev[i]); 560 continue; 561 } 562 563 val = superio_inb(sioaddr, SIOREG_MAP); 564 if (val & 0x01) { 565 printk(KERN_WARNING DRVNAME ": Logical device 0x%02x " 566 "is memory-mapped, can't use\n", logdev[i]); 567 continue; 568 } 569 570 val = (superio_inb(sioaddr, SIOREG_IOBASE) << 8) 571 | superio_inb(sioaddr, SIOREG_IOBASE + 1); 572 if (!val) { 573 printk(KERN_INFO DRVNAME ": I/O base address not set " 574 "for logical device 0x%02x\n", logdev[i]); 575 continue; 576 } 577 address[i] = val; 578 } 579 580 exit: 581 superio_exit(sioaddr); 582 return err; 583 } 584 585 static int __init pc87427_init(void) 586 { 587 int err; 588 unsigned short address[2]; 589 590 if (pc87427_find(0x2e, address) 591 && pc87427_find(0x4e, address)) 592 return -ENODEV; 593 594 /* For now the driver only handles fans so we only care about the 595 first address. */ 596 if (!address[0]) 597 return -ENODEV; 598 599 err = platform_driver_register(&pc87427_driver); 600 if (err) 601 goto exit; 602 603 /* Sets global pdev as a side effect */ 604 err = pc87427_device_add(address[0]); 605 if (err) 606 goto exit_driver; 607 608 return 0; 609 610 exit_driver: 611 platform_driver_unregister(&pc87427_driver); 612 exit: 613 return err; 614 } 615 616 static void __exit pc87427_exit(void) 617 { 618 platform_device_unregister(pdev); 619 platform_driver_unregister(&pc87427_driver); 620 } 621 622 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 623 MODULE_DESCRIPTION("PC87427 hardware monitoring driver"); 624 MODULE_LICENSE("GPL"); 625 626 module_init(pc87427_init); 627 module_exit(pc87427_exit); 628