git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/f71805f.c

   1 /*
   2  * f71805f.c - driver for the Fintek F71805F/FG and F71872F/FG Super-I/O
   3  *             chips integrated hardware monitoring features
   4  * Copyright (C) 2005-2006  Jean Delvare <khali@linux-fr.org>
   5  *
   6  * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates
   7  * complete hardware monitoring features: voltage, fan and temperature
   8  * sensors, and manual and automatic fan speed control.
   9  *
  10  * The F71872F/FG is almost the same, with two more voltages monitored,
  11  * and 6 VID inputs.
  12  *
  13  * The F71806F/FG is essentially the same as the F71872F/FG. It even has
  14  * the same chip ID, so the driver can't differentiate between.
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  */
  30
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33 #include <linux/slab.h>
  34 #include <linux/jiffies.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/hwmon.h>
  37 #include <linux/hwmon-sysfs.h>
  38 #include <linux/err.h>
  39 #include <linux/mutex.h>
  40 #include <linux/sysfs.h>
  41 #include <linux/ioport.h>
  42 #include <linux/acpi.h>
  43 #include <asm/io.h>
  44
  45 static unsigned short force_id;
  46 module_param(force_id, ushort, 0);
  47 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  48
  49 static struct platform_device *pdev;
  50
  51 #define DRVNAME "f71805f"
  52 enum kinds { f71805f, f71872f };
  53
  54 /*
  55  * Super-I/O constants and functions
  56  */
  57
  58 #define F71805F_LD_HWM          0x04
  59
  60 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  61 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  62 #define SIO_REG_DEVREV          0x22    /* Device revision */
  63 #define SIO_REG_MANID           0x23    /* Fintek ID (2 bytes) */
  64 #define SIO_REG_FNSEL1          0x29    /* Multi Function Select 1 (F71872F) */
  65 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  66 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  67
  68 #define SIO_FINTEK_ID           0x1934
  69 #define SIO_F71805F_ID          0x0406
  70 #define SIO_F71872F_ID          0x0341
  71
  72 static inline int
  73 superio_inb(int base, int reg)
  74 {
  75         outb(reg, base);
  76         return inb(base + 1);
  77 }
  78
  79 static int
  80 superio_inw(int base, int reg)
  81 {
  82         int val;
  83         outb(reg++, base);
  84         val = inb(base + 1) << 8;
  85         outb(reg, base);
  86         val |= inb(base + 1);
  87         return val;
  88 }
  89
  90 static inline void
  91 superio_select(int base, int ld)
  92 {
  93         outb(SIO_REG_LDSEL, base);
  94         outb(ld, base + 1);
  95 }
  96
  97 static inline void
  98 superio_enter(int base)
  99 {
 100         outb(0x87, base);
 101         outb(0x87, base);
 102 }
 103
 104 static inline void
 105 superio_exit(int base)
 106 {
 107         outb(0xaa, base);
 108 }
 109
 110 /*
 111  * ISA constants
 112  */
 113
 114 #define REGION_LENGTH           8
 115 #define ADDR_REG_OFFSET         5
 116 #define DATA_REG_OFFSET         6
 117
 118 /*
 119  * Registers
 120  */
 121
 122 /* in nr from 0 to 10 (8-bit values) */
 123 #define F71805F_REG_IN(nr)              (0x10 + (nr))
 124 #define F71805F_REG_IN_HIGH(nr)         ((nr) < 10 ? 0x40 + 2 * (nr) : 0x2E)
 125 #define F71805F_REG_IN_LOW(nr)          ((nr) < 10 ? 0x41 + 2 * (nr) : 0x2F)
 126 /* fan nr from 0 to 2 (12-bit values, two registers) */
 127 #define F71805F_REG_FAN(nr)             (0x20 + 2 * (nr))
 128 #define F71805F_REG_FAN_LOW(nr)         (0x28 + 2 * (nr))
 129 #define F71805F_REG_FAN_TARGET(nr)      (0x69 + 16 * (nr))
 130 #define F71805F_REG_FAN_CTRL(nr)        (0x60 + 16 * (nr))
 131 #define F71805F_REG_PWM_FREQ(nr)        (0x63 + 16 * (nr))
 132 #define F71805F_REG_PWM_DUTY(nr)        (0x6B + 16 * (nr))
 133 /* temp nr from 0 to 2 (8-bit values) */
 134 #define F71805F_REG_TEMP(nr)            (0x1B + (nr))
 135 #define F71805F_REG_TEMP_HIGH(nr)       (0x54 + 2 * (nr))
 136 #define F71805F_REG_TEMP_HYST(nr)       (0x55 + 2 * (nr))
 137 #define F71805F_REG_TEMP_MODE           0x01
 138 /* pwm/fan pwmnr from 0 to 2, auto point apnr from 0 to 2 */
 139 /* map Fintek numbers to our numbers as follows: 9->0, 5->1, 1->2 */
 140 #define F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr) \
 141                                         (0xA0 + 0x10 * (pwmnr) + (2 - (apnr)))
 142 #define F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr) \
 143                                         (0xA4 + 0x10 * (pwmnr) + \
 144                                                 2 * (2 - (apnr)))
 145
 146 #define F71805F_REG_START               0x00
 147 /* status nr from 0 to 2 */
 148 #define F71805F_REG_STATUS(nr)          (0x36 + (nr))
 149
 150 /* individual register bits */
 151 #define FAN_CTRL_DC_MODE                0x10
 152 #define FAN_CTRL_LATCH_FULL             0x08
 153 #define FAN_CTRL_MODE_MASK              0x03
 154 #define FAN_CTRL_MODE_SPEED             0x00
 155 #define FAN_CTRL_MODE_TEMPERATURE       0x01
 156 #define FAN_CTRL_MODE_MANUAL            0x02
 157
 158 /*
 159  * Data structures and manipulation thereof
 160  */
 161
 162 struct f71805f_auto_point {
 163         u8 temp[3];
 164         u16 fan[3];
 165 };
 166
 167 struct f71805f_data {
 168         unsigned short addr;
 169         const char *name;
 170         struct device *hwmon_dev;
 171
 172         struct mutex update_lock;
 173         char valid;             /* !=0 if following fields are valid */
 174         unsigned long last_updated;     /* In jiffies */
 175         unsigned long last_limits;      /* In jiffies */
 176
 177         /* Register values */
 178         u8 in[11];
 179         u8 in_high[11];
 180         u8 in_low[11];
 181         u16 has_in;
 182         u16 fan[3];
 183         u16 fan_low[3];
 184         u16 fan_target[3];
 185         u8 fan_ctrl[3];
 186         u8 pwm[3];
 187         u8 pwm_freq[3];
 188         u8 temp[3];
 189         u8 temp_high[3];
 190         u8 temp_hyst[3];
 191         u8 temp_mode;
 192         unsigned long alarms;
 193         struct f71805f_auto_point auto_points[3];
 194 };
 195
 196 struct f71805f_sio_data {
 197         enum kinds kind;
 198         u8 fnsel1;
 199 };
 200
 201 static inline long in_from_reg(u8 reg)
 202 {
 203         return (reg * 8);
 204 }
 205
 206 /* The 2 least significant bits are not used */
 207 static inline u8 in_to_reg(long val)
 208 {
 209         if (val <= 0)
 210                 return 0;
 211         if (val >= 2016)
 212                 return 0xfc;
 213         return (((val + 16) / 32) << 2);
 214 }
 215
 216 /* in0 is downscaled by a factor 2 internally */
 217 static inline long in0_from_reg(u8 reg)
 218 {
 219         return (reg * 16);
 220 }
 221
 222 static inline u8 in0_to_reg(long val)
 223 {
 224         if (val <= 0)
 225                 return 0;
 226         if (val >= 4032)
 227                 return 0xfc;
 228         return (((val + 32) / 64) << 2);
 229 }
 230
 231 /* The 4 most significant bits are not used */
 232 static inline long fan_from_reg(u16 reg)
 233 {
 234         reg &= 0xfff;
 235         if (!reg || reg == 0xfff)
 236                 return 0;
 237         return (1500000 / reg);
 238 }
 239
 240 static inline u16 fan_to_reg(long rpm)
 241 {
 242         /* If the low limit is set below what the chip can measure,
 243            store the largest possible 12-bit value in the registers,
 244            so that no alarm will ever trigger. */
 245         if (rpm < 367)
 246                 return 0xfff;
 247         return (1500000 / rpm);
 248 }
 249
 250 static inline unsigned long pwm_freq_from_reg(u8 reg)
 251 {
 252         unsigned long clock = (reg & 0x80) ? 48000000UL : 1000000UL;
 253
 254         reg &= 0x7f;
 255         if (reg == 0)
 256                 reg++;
 257         return clock / (reg << 8);
 258 }
 259
 260 static inline u8 pwm_freq_to_reg(unsigned long val)
 261 {
 262         if (val >= 187500)      /* The highest we can do */
 263                 return 0x80;
 264         if (val >= 1475)        /* Use 48 MHz clock */
 265                 return 0x80 | (48000000UL / (val << 8));
 266         if (val < 31)           /* The lowest we can do */
 267                 return 0x7f;
 268         else                    /* Use 1 MHz clock */
 269                 return 1000000UL / (val << 8);
 270 }
 271
 272 static inline int pwm_mode_from_reg(u8 reg)
 273 {
 274         return !(reg & FAN_CTRL_DC_MODE);
 275 }
 276
 277 static inline long temp_from_reg(u8 reg)
 278 {
 279         return (reg * 1000);
 280 }
 281
 282 static inline u8 temp_to_reg(long val)
 283 {
 284         if (val < 0)
 285                 val = 0;
 286         else if (val > 1000 * 0xff)
 287                 val = 0xff;
 288         return ((val + 500) / 1000);
 289 }
 290
 291 /*
 292  * Device I/O access
 293  */
 294
 295 /* Must be called with data->update_lock held, except during initialization */
 296 static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
 297 {
 298         outb(reg, data->addr + ADDR_REG_OFFSET);
 299         return inb(data->addr + DATA_REG_OFFSET);
 300 }
 301
 302 /* Must be called with data->update_lock held, except during initialization */
 303 static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
 304 {
 305         outb(reg, data->addr + ADDR_REG_OFFSET);
 306         outb(val, data->addr + DATA_REG_OFFSET);
 307 }
 308
 309 /* It is important to read the MSB first, because doing so latches the
 310    value of the LSB, so we are sure both bytes belong to the same value.
 311    Must be called with data->update_lock held, except during initialization */
 312 static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
 313 {
 314         u16 val;
 315
 316         outb(reg, data->addr + ADDR_REG_OFFSET);
 317         val = inb(data->addr + DATA_REG_OFFSET) << 8;
 318         outb(++reg, data->addr + ADDR_REG_OFFSET);
 319         val |= inb(data->addr + DATA_REG_OFFSET);
 320
 321         return val;
 322 }
 323
 324 /* Must be called with data->update_lock held, except during initialization */
 325 static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
 326 {
 327         outb(reg, data->addr + ADDR_REG_OFFSET);
 328         outb(val >> 8, data->addr + DATA_REG_OFFSET);
 329         outb(++reg, data->addr + ADDR_REG_OFFSET);
 330         outb(val & 0xff, data->addr + DATA_REG_OFFSET);
 331 }
 332
 333 static struct f71805f_data *f71805f_update_device(struct device *dev)
 334 {
 335         struct f71805f_data *data = dev_get_drvdata(dev);
 336         int nr, apnr;
 337
 338         mutex_lock(&data->update_lock);
 339
 340         /* Limit registers cache is refreshed after 60 seconds */
 341         if (time_after(jiffies, data->last_updated + 60 * HZ)
 342          || !data->valid) {
 343                 for (nr = 0; nr < 11; nr++) {
 344                         if (!(data->has_in & (1 << nr)))
 345                                 continue;
 346                         data->in_high[nr] = f71805f_read8(data,
 347                                             F71805F_REG_IN_HIGH(nr));
 348                         data->in_low[nr] = f71805f_read8(data,
 349                                            F71805F_REG_IN_LOW(nr));
 350                 }
 351                 for (nr = 0; nr < 3; nr++) {
 352                         data->fan_low[nr] = f71805f_read16(data,
 353                                             F71805F_REG_FAN_LOW(nr));
 354                         data->fan_target[nr] = f71805f_read16(data,
 355                                                F71805F_REG_FAN_TARGET(nr));
 356                         data->pwm_freq[nr] = f71805f_read8(data,
 357                                              F71805F_REG_PWM_FREQ(nr));
 358                 }
 359                 for (nr = 0; nr < 3; nr++) {
 360                         data->temp_high[nr] = f71805f_read8(data,
 361                                               F71805F_REG_TEMP_HIGH(nr));
 362                         data->temp_hyst[nr] = f71805f_read8(data,
 363                                               F71805F_REG_TEMP_HYST(nr));
 364                 }
 365                 data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
 366                 for (nr = 0; nr < 3; nr++) {
 367                         for (apnr = 0; apnr < 3; apnr++) {
 368                                 data->auto_points[nr].temp[apnr] =
 369                                         f71805f_read8(data,
 370                                         F71805F_REG_PWM_AUTO_POINT_TEMP(nr,
 371                                                                         apnr));
 372                                 data->auto_points[nr].fan[apnr] =
 373                                         f71805f_read16(data,
 374                                         F71805F_REG_PWM_AUTO_POINT_FAN(nr,
 375                                                                        apnr));
 376                         }
 377                 }
 378
 379                 data->last_limits = jiffies;
 380         }
 381
 382         /* Measurement registers cache is refreshed after 1 second */
 383         if (time_after(jiffies, data->last_updated + HZ)
 384          || !data->valid) {
 385                 for (nr = 0; nr < 11; nr++) {
 386                         if (!(data->has_in & (1 << nr)))
 387                                 continue;
 388                         data->in[nr] = f71805f_read8(data,
 389                                        F71805F_REG_IN(nr));
 390                 }
 391                 for (nr = 0; nr < 3; nr++) {
 392                         data->fan[nr] = f71805f_read16(data,
 393                                         F71805F_REG_FAN(nr));
 394                         data->fan_ctrl[nr] = f71805f_read8(data,
 395                                              F71805F_REG_FAN_CTRL(nr));
 396                         data->pwm[nr] = f71805f_read8(data,
 397                                         F71805F_REG_PWM_DUTY(nr));
 398                 }
 399                 for (nr = 0; nr < 3; nr++) {
 400                         data->temp[nr] = f71805f_read8(data,
 401                                          F71805F_REG_TEMP(nr));
 402                 }
 403                 data->alarms = f71805f_read8(data, F71805F_REG_STATUS(0))
 404                         + (f71805f_read8(data, F71805F_REG_STATUS(1)) << 8)
 405                         + (f71805f_read8(data, F71805F_REG_STATUS(2)) << 16);
 406
 407                 data->last_updated = jiffies;
 408                 data->valid = 1;
 409         }
 410
 411         mutex_unlock(&data->update_lock);
 412
 413         return data;
 414 }
 415
 416 /*
 417  * Sysfs interface
 418  */
 419
 420 static ssize_t show_in0(struct device *dev, struct device_attribute *devattr,
 421                         char *buf)
 422 {
 423         struct f71805f_data *data = f71805f_update_device(dev);
 424         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 425         int nr = attr->index;
 426
 427         return sprintf(buf, "%ld\n", in0_from_reg(data->in[nr]));
 428 }
 429
 430 static ssize_t show_in0_max(struct device *dev, struct device_attribute
 431                             *devattr, char *buf)
 432 {
 433         struct f71805f_data *data = f71805f_update_device(dev);
 434         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 435         int nr = attr->index;
 436
 437         return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[nr]));
 438 }
 439
 440 static ssize_t show_in0_min(struct device *dev, struct device_attribute
 441                             *devattr, char *buf)
 442 {
 443         struct f71805f_data *data = f71805f_update_device(dev);
 444         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 445         int nr = attr->index;
 446
 447         return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[nr]));
 448 }
 449
 450 static ssize_t set_in0_max(struct device *dev, struct device_attribute
 451                            *devattr, const char *buf, size_t count)
 452 {
 453         struct f71805f_data *data = dev_get_drvdata(dev);
 454         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 455         int nr = attr->index;
 456         long val = simple_strtol(buf, NULL, 10);
 457
 458         mutex_lock(&data->update_lock);
 459         data->in_high[nr] = in0_to_reg(val);
 460         f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
 461         mutex_unlock(&data->update_lock);
 462
 463         return count;
 464 }
 465
 466 static ssize_t set_in0_min(struct device *dev, struct device_attribute
 467                            *devattr, const char *buf, size_t count)
 468 {
 469         struct f71805f_data *data = dev_get_drvdata(dev);
 470         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 471         int nr = attr->index;
 472         long val = simple_strtol(buf, NULL, 10);
 473
 474         mutex_lock(&data->update_lock);
 475         data->in_low[nr] = in0_to_reg(val);
 476         f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
 477         mutex_unlock(&data->update_lock);
 478
 479         return count;
 480 }
 481
 482 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
 483                        char *buf)
 484 {
 485         struct f71805f_data *data = f71805f_update_device(dev);
 486         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 487         int nr = attr->index;
 488
 489         return sprintf(buf, "%ld\n", in_from_reg(data->in[nr]));
 490 }
 491
 492 static ssize_t show_in_max(struct device *dev, struct device_attribute
 493                            *devattr, char *buf)
 494 {
 495         struct f71805f_data *data = f71805f_update_device(dev);
 496         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 497         int nr = attr->index;
 498
 499         return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr]));
 500 }
 501
 502 static ssize_t show_in_min(struct device *dev, struct device_attribute
 503                            *devattr, char *buf)
 504 {
 505         struct f71805f_data *data = f71805f_update_device(dev);
 506         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 507         int nr = attr->index;
 508
 509         return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr]));
 510 }
 511
 512 static ssize_t set_in_max(struct device *dev, struct device_attribute
 513                           *devattr, const char *buf, size_t count)
 514 {
 515         struct f71805f_data *data = dev_get_drvdata(dev);
 516         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 517         int nr = attr->index;
 518         long val = simple_strtol(buf, NULL, 10);
 519
 520         mutex_lock(&data->update_lock);
 521         data->in_high[nr] = in_to_reg(val);
 522         f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
 523         mutex_unlock(&data->update_lock);
 524
 525         return count;
 526 }
 527
 528 static ssize_t set_in_min(struct device *dev, struct device_attribute
 529                           *devattr, const char *buf, size_t count)
 530 {
 531         struct f71805f_data *data = dev_get_drvdata(dev);
 532         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 533         int nr = attr->index;
 534         long val = simple_strtol(buf, NULL, 10);
 535
 536         mutex_lock(&data->update_lock);
 537         data->in_low[nr] = in_to_reg(val);
 538         f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
 539         mutex_unlock(&data->update_lock);
 540
 541         return count;
 542 }
 543
 544 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 545                         char *buf)
 546 {
 547         struct f71805f_data *data = f71805f_update_device(dev);
 548         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 549         int nr = attr->index;
 550
 551         return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr]));
 552 }
 553
 554 static ssize_t show_fan_min(struct device *dev, struct device_attribute
 555                             *devattr, char *buf)
 556 {
 557         struct f71805f_data *data = f71805f_update_device(dev);
 558         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 559         int nr = attr->index;
 560
 561         return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr]));
 562 }
 563
 564 static ssize_t show_fan_target(struct device *dev, struct device_attribute
 565                                *devattr, char *buf)
 566 {
 567         struct f71805f_data *data = f71805f_update_device(dev);
 568         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 569         int nr = attr->index;
 570
 571         return sprintf(buf, "%ld\n", fan_from_reg(data->fan_target[nr]));
 572 }
 573
 574 static ssize_t set_fan_min(struct device *dev, struct device_attribute
 575                            *devattr, const char *buf, size_t count)
 576 {
 577         struct f71805f_data *data = dev_get_drvdata(dev);
 578         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 579         int nr = attr->index;
 580         long val = simple_strtol(buf, NULL, 10);
 581
 582         mutex_lock(&data->update_lock);
 583         data->fan_low[nr] = fan_to_reg(val);
 584         f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
 585         mutex_unlock(&data->update_lock);
 586
 587         return count;
 588 }
 589
 590 static ssize_t set_fan_target(struct device *dev, struct device_attribute
 591                               *devattr, const char *buf, size_t count)
 592 {
 593         struct f71805f_data *data = dev_get_drvdata(dev);
 594         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 595         int nr = attr->index;
 596         long val = simple_strtol(buf, NULL, 10);
 597
 598         mutex_lock(&data->update_lock);
 599         data->fan_target[nr] = fan_to_reg(val);
 600         f71805f_write16(data, F71805F_REG_FAN_TARGET(nr),
 601                         data->fan_target[nr]);
 602         mutex_unlock(&data->update_lock);
 603
 604         return count;
 605 }
 606
 607 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
 608                         char *buf)
 609 {
 610         struct f71805f_data *data = f71805f_update_device(dev);
 611         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 612         int nr = attr->index;
 613
 614         return sprintf(buf, "%d\n", (int)data->pwm[nr]);
 615 }
 616
 617 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
 618                                *devattr, char *buf)
 619 {
 620         struct f71805f_data *data = f71805f_update_device(dev);
 621         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 622         int nr = attr->index;
 623         int mode;
 624
 625         switch (data->fan_ctrl[nr] & FAN_CTRL_MODE_MASK) {
 626         case FAN_CTRL_MODE_SPEED:
 627                 mode = 3;
 628                 break;
 629         case FAN_CTRL_MODE_TEMPERATURE:
 630                 mode = 2;
 631                 break;
 632         default: /* MANUAL */
 633                 mode = 1;
 634         }
 635
 636         return sprintf(buf, "%d\n", mode);
 637 }
 638
 639 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute
 640                              *devattr, char *buf)
 641 {
 642         struct f71805f_data *data = f71805f_update_device(dev);
 643         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 644         int nr = attr->index;
 645
 646         return sprintf(buf, "%lu\n", pwm_freq_from_reg(data->pwm_freq[nr]));
 647 }
 648
 649 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
 650                              *devattr, char *buf)
 651 {
 652         struct f71805f_data *data = f71805f_update_device(dev);
 653         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 654         int nr = attr->index;
 655
 656         return sprintf(buf, "%d\n", pwm_mode_from_reg(data->fan_ctrl[nr]));
 657 }
 658
 659 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
 660                        const char *buf, size_t count)
 661 {
 662         struct f71805f_data *data = dev_get_drvdata(dev);
 663         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 664         int nr = attr->index;
 665         unsigned long val = simple_strtoul(buf, NULL, 10);
 666
 667         if (val > 255)
 668                 return -EINVAL;
 669
 670         mutex_lock(&data->update_lock);
 671         data->pwm[nr] = val;
 672         f71805f_write8(data, F71805F_REG_PWM_DUTY(nr), data->pwm[nr]);
 673         mutex_unlock(&data->update_lock);
 674
 675         return count;
 676 }
 677
 678 static struct attribute *f71805f_attr_pwm[];
 679
 680 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
 681                               *devattr, const char *buf, size_t count)
 682 {
 683         struct f71805f_data *data = dev_get_drvdata(dev);
 684         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 685         int nr = attr->index;
 686         unsigned long val = simple_strtoul(buf, NULL, 10);
 687         u8 reg;
 688
 689         if (val < 1 || val > 3)
 690                 return -EINVAL;
 691
 692         if (val > 1) { /* Automatic mode, user can't set PWM value */
 693                 if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr],
 694                                      S_IRUGO))
 695                         dev_dbg(dev, "chmod -w pwm%d failed\n", nr + 1);
 696         }
 697
 698         mutex_lock(&data->update_lock);
 699         reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(nr))
 700             & ~FAN_CTRL_MODE_MASK;
 701         switch (val) {
 702         case 1:
 703                 reg |= FAN_CTRL_MODE_MANUAL;
 704                 break;
 705         case 2:
 706                 reg |= FAN_CTRL_MODE_TEMPERATURE;
 707                 break;
 708         case 3:
 709                 reg |= FAN_CTRL_MODE_SPEED;
 710                 break;
 711         }
 712         data->fan_ctrl[nr] = reg;
 713         f71805f_write8(data, F71805F_REG_FAN_CTRL(nr), reg);
 714         mutex_unlock(&data->update_lock);
 715
 716         if (val == 1) { /* Manual mode, user can set PWM value */
 717                 if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr],
 718                                      S_IRUGO | S_IWUSR))
 719                         dev_dbg(dev, "chmod +w pwm%d failed\n", nr + 1);
 720         }
 721
 722         return count;
 723 }
 724
 725 static ssize_t set_pwm_freq(struct device *dev, struct device_attribute
 726                             *devattr, const char *buf, size_t count)
 727 {
 728         struct f71805f_data *data = dev_get_drvdata(dev);
 729         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 730         int nr = attr->index;
 731         unsigned long val = simple_strtoul(buf, NULL, 10);
 732
 733         mutex_lock(&data->update_lock);
 734         data->pwm_freq[nr] = pwm_freq_to_reg(val);
 735         f71805f_write8(data, F71805F_REG_PWM_FREQ(nr), data->pwm_freq[nr]);
 736         mutex_unlock(&data->update_lock);
 737
 738         return count;
 739 }
 740
 741 static ssize_t show_pwm_auto_point_temp(struct device *dev,
 742                                         struct device_attribute *devattr,
 743                                         char* buf)
 744 {
 745         struct f71805f_data *data = dev_get_drvdata(dev);
 746         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 747         int pwmnr = attr->nr;
 748         int apnr = attr->index;
 749
 750         return sprintf(buf, "%ld\n",
 751                        temp_from_reg(data->auto_points[pwmnr].temp[apnr]));
 752 }
 753
 754 static ssize_t set_pwm_auto_point_temp(struct device *dev,
 755                                        struct device_attribute *devattr,
 756                                        const char* buf, size_t count)
 757 {
 758         struct f71805f_data *data = dev_get_drvdata(dev);
 759         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 760         int pwmnr = attr->nr;
 761         int apnr = attr->index;
 762         unsigned long val = simple_strtol(buf, NULL, 10);
 763
 764         mutex_lock(&data->update_lock);
 765         data->auto_points[pwmnr].temp[apnr] = temp_to_reg(val);
 766         f71805f_write8(data, F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr),
 767                        data->auto_points[pwmnr].temp[apnr]);
 768         mutex_unlock(&data->update_lock);
 769
 770         return count;
 771 }
 772
 773 static ssize_t show_pwm_auto_point_fan(struct device *dev,
 774                                        struct device_attribute *devattr,
 775                                        char* buf)
 776 {
 777         struct f71805f_data *data = dev_get_drvdata(dev);
 778         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 779         int pwmnr = attr->nr;
 780         int apnr = attr->index;
 781
 782         return sprintf(buf, "%ld\n",
 783                        fan_from_reg(data->auto_points[pwmnr].fan[apnr]));
 784 }
 785
 786 static ssize_t set_pwm_auto_point_fan(struct device *dev,
 787                                       struct device_attribute *devattr,
 788                                       const char* buf, size_t count)
 789 {
 790         struct f71805f_data *data = dev_get_drvdata(dev);
 791         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 792         int pwmnr = attr->nr;
 793         int apnr = attr->index;
 794         unsigned long val = simple_strtoul(buf, NULL, 10);
 795
 796         mutex_lock(&data->update_lock);
 797         data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val);
 798         f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr),
 799                         data->auto_points[pwmnr].fan[apnr]);
 800         mutex_unlock(&data->update_lock);
 801
 802         return count;
 803 }
 804
 805 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 806                          char *buf)
 807 {
 808         struct f71805f_data *data = f71805f_update_device(dev);
 809         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 810         int nr = attr->index;
 811
 812         return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
 813 }
 814
 815 static ssize_t show_temp_max(struct device *dev, struct device_attribute
 816                              *devattr, char *buf)
 817 {
 818         struct f71805f_data *data = f71805f_update_device(dev);
 819         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 820         int nr = attr->index;
 821
 822         return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr]));
 823 }
 824
 825 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute
 826                               *devattr, char *buf)
 827 {
 828         struct f71805f_data *data = f71805f_update_device(dev);
 829         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 830         int nr = attr->index;
 831
 832         return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr]));
 833 }
 834
 835 static ssize_t show_temp_type(struct device *dev, struct device_attribute
 836                               *devattr, char *buf)
 837 {
 838         struct f71805f_data *data = f71805f_update_device(dev);
 839         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 840         int nr = attr->index;
 841
 842         /* 3 is diode, 4 is thermistor */
 843         return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4);
 844 }
 845
 846 static ssize_t set_temp_max(struct device *dev, struct device_attribute
 847                             *devattr, const char *buf, size_t count)
 848 {
 849         struct f71805f_data *data = dev_get_drvdata(dev);
 850         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 851         int nr = attr->index;
 852         long val = simple_strtol(buf, NULL, 10);
 853
 854         mutex_lock(&data->update_lock);
 855         data->temp_high[nr] = temp_to_reg(val);
 856         f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
 857         mutex_unlock(&data->update_lock);
 858
 859         return count;
 860 }
 861
 862 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
 863                              *devattr, const char *buf, size_t count)
 864 {
 865         struct f71805f_data *data = dev_get_drvdata(dev);
 866         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 867         int nr = attr->index;
 868         long val = simple_strtol(buf, NULL, 10);
 869
 870         mutex_lock(&data->update_lock);
 871         data->temp_hyst[nr] = temp_to_reg(val);
 872         f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
 873         mutex_unlock(&data->update_lock);
 874
 875         return count;
 876 }
 877
 878 static ssize_t show_alarms_in(struct device *dev, struct device_attribute
 879                               *devattr, char *buf)
 880 {
 881         struct f71805f_data *data = f71805f_update_device(dev);
 882
 883         return sprintf(buf, "%lu\n", data->alarms & 0x7ff);
 884 }
 885
 886 static ssize_t show_alarms_fan(struct device *dev, struct device_attribute
 887                                *devattr, char *buf)
 888 {
 889         struct f71805f_data *data = f71805f_update_device(dev);
 890
 891         return sprintf(buf, "%lu\n", (data->alarms >> 16) & 0x07);
 892 }
 893
 894 static ssize_t show_alarms_temp(struct device *dev, struct device_attribute
 895                                 *devattr, char *buf)
 896 {
 897         struct f71805f_data *data = f71805f_update_device(dev);
 898
 899         return sprintf(buf, "%lu\n", (data->alarms >> 11) & 0x07);
 900 }
 901
 902 static ssize_t show_alarm(struct device *dev, struct device_attribute
 903                           *devattr, char *buf)
 904 {
 905         struct f71805f_data *data = f71805f_update_device(dev);
 906         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 907         int bitnr = attr->index;
 908
 909         return sprintf(buf, "%lu\n", (data->alarms >> bitnr) & 1);
 910 }
 911
 912 static ssize_t show_name(struct device *dev, struct device_attribute
 913                          *devattr, char *buf)
 914 {
 915         struct f71805f_data *data = dev_get_drvdata(dev);
 916
 917         return sprintf(buf, "%s\n", data->name);
 918 }
 919
 920 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL, 0);
 921 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO| S_IWUSR,
 922                           show_in0_max, set_in0_max, 0);
 923 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO| S_IWUSR,
 924                           show_in0_min, set_in0_min, 0);
 925 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
 926 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
 927                           show_in_max, set_in_max, 1);
 928 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
 929                           show_in_min, set_in_min, 1);
 930 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
 931 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
 932                           show_in_max, set_in_max, 2);
 933 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
 934                           show_in_min, set_in_min, 2);
 935 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
 936 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
 937                           show_in_max, set_in_max, 3);
 938 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
 939                           show_in_min, set_in_min, 3);
 940 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 4);
 941 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
 942                           show_in_max, set_in_max, 4);
 943 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
 944                           show_in_min, set_in_min, 4);
 945 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 5);
 946 static SENSOR_DEVICE_ATTR(in5_max, S_IRUGO | S_IWUSR,
 947                           show_in_max, set_in_max, 5);
 948 static SENSOR_DEVICE_ATTR(in5_min, S_IRUGO | S_IWUSR,
 949                           show_in_min, set_in_min, 5);
 950 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 6);
 951 static SENSOR_DEVICE_ATTR(in6_max, S_IRUGO | S_IWUSR,
 952                           show_in_max, set_in_max, 6);
 953 static SENSOR_DEVICE_ATTR(in6_min, S_IRUGO | S_IWUSR,
 954                           show_in_min, set_in_min, 6);
 955 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 7);
 956 static SENSOR_DEVICE_ATTR(in7_max, S_IRUGO | S_IWUSR,
 957                           show_in_max, set_in_max, 7);
 958 static SENSOR_DEVICE_ATTR(in7_min, S_IRUGO | S_IWUSR,
 959                           show_in_min, set_in_min, 7);
 960 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 8);
 961 static SENSOR_DEVICE_ATTR(in8_max, S_IRUGO | S_IWUSR,
 962                           show_in_max, set_in_max, 8);
 963 static SENSOR_DEVICE_ATTR(in8_min, S_IRUGO | S_IWUSR,
 964                           show_in_min, set_in_min, 8);
 965 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in0, NULL, 9);
 966 static SENSOR_DEVICE_ATTR(in9_max, S_IRUGO | S_IWUSR,
 967                           show_in0_max, set_in0_max, 9);
 968 static SENSOR_DEVICE_ATTR(in9_min, S_IRUGO | S_IWUSR,
 969                           show_in0_min, set_in0_min, 9);
 970 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in0, NULL, 10);
 971 static SENSOR_DEVICE_ATTR(in10_max, S_IRUGO | S_IWUSR,
 972                           show_in0_max, set_in0_max, 10);
 973 static SENSOR_DEVICE_ATTR(in10_min, S_IRUGO | S_IWUSR,
 974                           show_in0_min, set_in0_min, 10);
 975
 976 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
 977 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
 978                           show_fan_min, set_fan_min, 0);
 979 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR,
 980                           show_fan_target, set_fan_target, 0);
 981 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
 982 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
 983                           show_fan_min, set_fan_min, 1);
 984 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO | S_IWUSR,
 985                           show_fan_target, set_fan_target, 1);
 986 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
 987 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
 988                           show_fan_min, set_fan_min, 2);
 989 static SENSOR_DEVICE_ATTR(fan3_target, S_IRUGO | S_IWUSR,
 990                           show_fan_target, set_fan_target, 2);
 991
 992 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 993 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 994                     show_temp_max, set_temp_max, 0);
 995 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 996                     show_temp_hyst, set_temp_hyst, 0);
 997 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0);
 998 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
 999 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
1000                     show_temp_max, set_temp_max, 1);
1001 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
1002                     show_temp_hyst, set_temp_hyst, 1);
1003 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1);
1004 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1005 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR,
1006                     show_temp_max, set_temp_max, 2);
1007 static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR,
1008                     show_temp_hyst, set_temp_hyst, 2);
1009 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2);
1010
1011 /* pwm (value) files are created read-only, write permission is
1012    then added or removed dynamically as needed */
1013 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, show_pwm, set_pwm, 0);
1014 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
1015                           show_pwm_enable, set_pwm_enable, 0);
1016 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IRUGO | S_IWUSR,
1017                           show_pwm_freq, set_pwm_freq, 0);
1018 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL, 0);
1019 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO, show_pwm, set_pwm, 1);
1020 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
1021                           show_pwm_enable, set_pwm_enable, 1);
1022 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IRUGO | S_IWUSR,
1023                           show_pwm_freq, set_pwm_freq, 1);
1024 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO, show_pwm_mode, NULL, 1);
1025 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO, show_pwm, set_pwm, 2);
1026 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR,
1027                           show_pwm_enable, set_pwm_enable, 2);
1028 static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO | S_IWUSR,
1029                           show_pwm_freq, set_pwm_freq, 2);
1030 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IRUGO, show_pwm_mode, NULL, 2);
1031
1032 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_temp, S_IRUGO | S_IWUSR,
1033                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1034                             0, 0);
1035 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_fan, S_IRUGO | S_IWUSR,
1036                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1037                             0, 0);
1038 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_temp, S_IRUGO | S_IWUSR,
1039                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1040                             0, 1);
1041 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_fan, S_IRUGO | S_IWUSR,
1042                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1043                             0, 1);
1044 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_temp, S_IRUGO | S_IWUSR,
1045                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1046                             0, 2);
1047 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_fan, S_IRUGO | S_IWUSR,
1048                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1049                             0, 2);
1050
1051 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_temp, S_IRUGO | S_IWUSR,
1052                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1053                             1, 0);
1054 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_fan, S_IRUGO | S_IWUSR,
1055                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1056                             1, 0);
1057 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_temp, S_IRUGO | S_IWUSR,
1058                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1059                             1, 1);
1060 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_fan, S_IRUGO | S_IWUSR,
1061                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1062                             1, 1);
1063 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_temp, S_IRUGO | S_IWUSR,
1064                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1065                             1, 2);
1066 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_fan, S_IRUGO | S_IWUSR,
1067                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1068                             1, 2);
1069
1070 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_temp, S_IRUGO | S_IWUSR,
1071                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1072                             2, 0);
1073 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_fan, S_IRUGO | S_IWUSR,
1074                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1075                             2, 0);
1076 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_temp, S_IRUGO | S_IWUSR,
1077                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1078                             2, 1);
1079 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_fan, S_IRUGO | S_IWUSR,
1080                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1081                             2, 1);
1082 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_temp, S_IRUGO | S_IWUSR,
1083                             show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1084                             2, 2);
1085 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_fan, S_IRUGO | S_IWUSR,
1086                             show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1087                             2, 2);
1088
1089 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
1090 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
1091 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
1092 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
1093 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4);
1094 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5);
1095 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6);
1096 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 7);
1097 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 8);
1098 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 9);
1099 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 10);
1100 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 11);
1101 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 12);
1102 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
1103 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 16);
1104 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 17);
1105 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 18);
1106 static DEVICE_ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL);
1107 static DEVICE_ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL);
1108 static DEVICE_ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL);
1109
1110 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1111
1112 static struct attribute *f71805f_attributes[] = {
1113         &sensor_dev_attr_in0_input.dev_attr.attr,
1114         &sensor_dev_attr_in0_max.dev_attr.attr,
1115         &sensor_dev_attr_in0_min.dev_attr.attr,
1116         &sensor_dev_attr_in1_input.dev_attr.attr,
1117         &sensor_dev_attr_in1_max.dev_attr.attr,
1118         &sensor_dev_attr_in1_min.dev_attr.attr,
1119         &sensor_dev_attr_in2_input.dev_attr.attr,
1120         &sensor_dev_attr_in2_max.dev_attr.attr,
1121         &sensor_dev_attr_in2_min.dev_attr.attr,
1122         &sensor_dev_attr_in3_input.dev_attr.attr,
1123         &sensor_dev_attr_in3_max.dev_attr.attr,
1124         &sensor_dev_attr_in3_min.dev_attr.attr,
1125         &sensor_dev_attr_in5_input.dev_attr.attr,
1126         &sensor_dev_attr_in5_max.dev_attr.attr,
1127         &sensor_dev_attr_in5_min.dev_attr.attr,
1128         &sensor_dev_attr_in6_input.dev_attr.attr,
1129         &sensor_dev_attr_in6_max.dev_attr.attr,
1130         &sensor_dev_attr_in6_min.dev_attr.attr,
1131         &sensor_dev_attr_in7_input.dev_attr.attr,
1132         &sensor_dev_attr_in7_max.dev_attr.attr,
1133         &sensor_dev_attr_in7_min.dev_attr.attr,
1134
1135         &sensor_dev_attr_fan1_input.dev_attr.attr,
1136         &sensor_dev_attr_fan1_min.dev_attr.attr,
1137         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1138         &sensor_dev_attr_fan1_target.dev_attr.attr,
1139         &sensor_dev_attr_fan2_input.dev_attr.attr,
1140         &sensor_dev_attr_fan2_min.dev_attr.attr,
1141         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1142         &sensor_dev_attr_fan2_target.dev_attr.attr,
1143         &sensor_dev_attr_fan3_input.dev_attr.attr,
1144         &sensor_dev_attr_fan3_min.dev_attr.attr,
1145         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1146         &sensor_dev_attr_fan3_target.dev_attr.attr,
1147
1148         &sensor_dev_attr_pwm1.dev_attr.attr,
1149         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1150         &sensor_dev_attr_pwm1_mode.dev_attr.attr,
1151         &sensor_dev_attr_pwm2.dev_attr.attr,
1152         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1153         &sensor_dev_attr_pwm2_mode.dev_attr.attr,
1154         &sensor_dev_attr_pwm3.dev_attr.attr,
1155         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1156         &sensor_dev_attr_pwm3_mode.dev_attr.attr,
1157
1158         &sensor_dev_attr_temp1_input.dev_attr.attr,
1159         &sensor_dev_attr_temp1_max.dev_attr.attr,
1160         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
1161         &sensor_dev_attr_temp1_type.dev_attr.attr,
1162         &sensor_dev_attr_temp2_input.dev_attr.attr,
1163         &sensor_dev_attr_temp2_max.dev_attr.attr,
1164         &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
1165         &sensor_dev_attr_temp2_type.dev_attr.attr,
1166         &sensor_dev_attr_temp3_input.dev_attr.attr,
1167         &sensor_dev_attr_temp3_max.dev_attr.attr,
1168         &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
1169         &sensor_dev_attr_temp3_type.dev_attr.attr,
1170
1171         &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1172         &sensor_dev_attr_pwm1_auto_point1_fan.dev_attr.attr,
1173         &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1174         &sensor_dev_attr_pwm1_auto_point2_fan.dev_attr.attr,
1175         &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
1176         &sensor_dev_attr_pwm1_auto_point3_fan.dev_attr.attr,
1177         &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1178         &sensor_dev_attr_pwm2_auto_point1_fan.dev_attr.attr,
1179         &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1180         &sensor_dev_attr_pwm2_auto_point2_fan.dev_attr.attr,
1181         &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
1182         &sensor_dev_attr_pwm2_auto_point3_fan.dev_attr.attr,
1183         &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1184         &sensor_dev_attr_pwm3_auto_point1_fan.dev_attr.attr,
1185         &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1186         &sensor_dev_attr_pwm3_auto_point2_fan.dev_attr.attr,
1187         &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
1188         &sensor_dev_attr_pwm3_auto_point3_fan.dev_attr.attr,
1189
1190         &sensor_dev_attr_in0_alarm.dev_attr.attr,
1191         &sensor_dev_attr_in1_alarm.dev_attr.attr,
1192         &sensor_dev_attr_in2_alarm.dev_attr.attr,
1193         &sensor_dev_attr_in3_alarm.dev_attr.attr,
1194         &sensor_dev_attr_in5_alarm.dev_attr.attr,
1195         &sensor_dev_attr_in6_alarm.dev_attr.attr,
1196         &sensor_dev_attr_in7_alarm.dev_attr.attr,
1197         &dev_attr_alarms_in.attr,
1198         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1199         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1200         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1201         &dev_attr_alarms_temp.attr,
1202         &dev_attr_alarms_fan.attr,
1203
1204         &dev_attr_name.attr,
1205         NULL
1206 };
1207
1208 static const struct attribute_group f71805f_group = {
1209         .attrs = f71805f_attributes,
1210 };
1211
1212 static struct attribute *f71805f_attributes_optin[4][5] = {
1213         {
1214                 &sensor_dev_attr_in4_input.dev_attr.attr,
1215                 &sensor_dev_attr_in4_max.dev_attr.attr,
1216                 &sensor_dev_attr_in4_min.dev_attr.attr,
1217                 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1218                 NULL
1219         }, {
1220                 &sensor_dev_attr_in8_input.dev_attr.attr,
1221                 &sensor_dev_attr_in8_max.dev_attr.attr,
1222                 &sensor_dev_attr_in8_min.dev_attr.attr,
1223                 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1224                 NULL
1225         }, {
1226                 &sensor_dev_attr_in9_input.dev_attr.attr,
1227                 &sensor_dev_attr_in9_max.dev_attr.attr,
1228                 &sensor_dev_attr_in9_min.dev_attr.attr,
1229                 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1230                 NULL
1231         }, {
1232                 &sensor_dev_attr_in10_input.dev_attr.attr,
1233                 &sensor_dev_attr_in10_max.dev_attr.attr,
1234                 &sensor_dev_attr_in10_min.dev_attr.attr,
1235                 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1236                 NULL
1237         }
1238 };
1239
1240 static const struct attribute_group f71805f_group_optin[4] = {
1241         { .attrs = f71805f_attributes_optin[0] },
1242         { .attrs = f71805f_attributes_optin[1] },
1243         { .attrs = f71805f_attributes_optin[2] },
1244         { .attrs = f71805f_attributes_optin[3] },
1245 };
1246
1247 /* We don't include pwm_freq files in the arrays above, because they must be
1248    created conditionally (only if pwm_mode is 1 == PWM) */
1249 static struct attribute *f71805f_attributes_pwm_freq[] = {
1250         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1251         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1252         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1253         NULL
1254 };
1255
1256 static const struct attribute_group f71805f_group_pwm_freq = {
1257         .attrs = f71805f_attributes_pwm_freq,
1258 };
1259
1260 /* We also need an indexed access to pwmN files to toggle writability */
1261 static struct attribute *f71805f_attr_pwm[] = {
1262         &sensor_dev_attr_pwm1.dev_attr.attr,
1263         &sensor_dev_attr_pwm2.dev_attr.attr,
1264         &sensor_dev_attr_pwm3.dev_attr.attr,
1265 };
1266
1267 /*
1268  * Device registration and initialization
1269  */
1270
1271 static void __devinit f71805f_init_device(struct f71805f_data *data)
1272 {
1273         u8 reg;
1274         int i;
1275
1276         reg = f71805f_read8(data, F71805F_REG_START);
1277         if ((reg & 0x41) != 0x01) {
1278                 printk(KERN_DEBUG DRVNAME ": Starting monitoring "
1279                        "operations\n");
1280                 f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40);
1281         }
1282
1283         /* Fan monitoring can be disabled. If it is, we won't be polling
1284            the register values, and won't create the related sysfs files. */
1285         for (i = 0; i < 3; i++) {
1286                 data->fan_ctrl[i] = f71805f_read8(data,
1287                                                   F71805F_REG_FAN_CTRL(i));
1288                 /* Clear latch full bit, else "speed mode" fan speed control
1289                    doesn't work */
1290                 if (data->fan_ctrl[i] & FAN_CTRL_LATCH_FULL) {
1291                         data->fan_ctrl[i] &= ~FAN_CTRL_LATCH_FULL;
1292                         f71805f_write8(data, F71805F_REG_FAN_CTRL(i),
1293                                        data->fan_ctrl[i]);
1294                 }
1295         }
1296 }
1297
1298 static int __devinit f71805f_probe(struct platform_device *pdev)
1299 {
1300         struct f71805f_sio_data *sio_data = pdev->dev.platform_data;
1301         struct f71805f_data *data;
1302         struct resource *res;
1303         int i, err;
1304
1305         static const char *names[] = {
1306                 "f71805f",
1307                 "f71872f",
1308         };
1309
1310         if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) {
1311                 err = -ENOMEM;
1312                 printk(KERN_ERR DRVNAME ": Out of memory\n");
1313                 goto exit;
1314         }
1315
1316         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1317         if (!request_region(res->start + ADDR_REG_OFFSET, 2, DRVNAME)) {
1318                 err = -EBUSY;
1319                 dev_err(&pdev->dev, "Failed to request region 0x%lx-0x%lx\n",
1320                         (unsigned long)(res->start + ADDR_REG_OFFSET),
1321                         (unsigned long)(res->start + ADDR_REG_OFFSET + 1));
1322                 goto exit_free;
1323         }
1324         data->addr = res->start;
1325         data->name = names[sio_data->kind];
1326         mutex_init(&data->update_lock);
1327
1328         platform_set_drvdata(pdev, data);
1329
1330         /* Some voltage inputs depend on chip model and configuration */
1331         switch (sio_data->kind) {
1332         case f71805f:
1333                 data->has_in = 0x1ff;
1334                 break;
1335         case f71872f:
1336                 data->has_in = 0x6ef;
1337                 if (sio_data->fnsel1 & 0x01)
1338                         data->has_in |= (1 << 4); /* in4 */
1339                 if (sio_data->fnsel1 & 0x02)
1340                         data->has_in |= (1 << 8); /* in8 */
1341                 break;
1342         }
1343
1344         /* Initialize the F71805F chip */
1345         f71805f_init_device(data);
1346
1347         /* Register sysfs interface files */
1348         if ((err = sysfs_create_group(&pdev->dev.kobj, &f71805f_group)))
1349                 goto exit_release_region;
1350         if (data->has_in & (1 << 4)) { /* in4 */
1351                 if ((err = sysfs_create_group(&pdev->dev.kobj,
1352                                               &f71805f_group_optin[0])))
1353                         goto exit_remove_files;
1354         }
1355         if (data->has_in & (1 << 8)) { /* in8 */
1356                 if ((err = sysfs_create_group(&pdev->dev.kobj,
1357                                               &f71805f_group_optin[1])))
1358                         goto exit_remove_files;
1359         }
1360         if (data->has_in & (1 << 9)) { /* in9 (F71872F/FG only) */
1361                 if ((err = sysfs_create_group(&pdev->dev.kobj,
1362                                               &f71805f_group_optin[2])))
1363                         goto exit_remove_files;
1364         }
1365         if (data->has_in & (1 << 10)) { /* in9 (F71872F/FG only) */
1366                 if ((err = sysfs_create_group(&pdev->dev.kobj,
1367                                               &f71805f_group_optin[3])))
1368                         goto exit_remove_files;
1369         }
1370         for (i = 0; i < 3; i++) {
1371                 /* If control mode is PWM, create pwm_freq file */
1372                 if (!(data->fan_ctrl[i] & FAN_CTRL_DC_MODE)) {
1373                         if ((err = sysfs_create_file(&pdev->dev.kobj,
1374                                         f71805f_attributes_pwm_freq[i])))
1375                                 goto exit_remove_files;
1376                 }
1377                 /* If PWM is in manual mode, add write permission */
1378                 if (data->fan_ctrl[i] & FAN_CTRL_MODE_MANUAL) {
1379                         if ((err = sysfs_chmod_file(&pdev->dev.kobj,
1380                                                     f71805f_attr_pwm[i],
1381                                                     S_IRUGO | S_IWUSR))) {
1382                                 dev_err(&pdev->dev, "chmod +w pwm%d failed\n",
1383                                         i + 1);
1384                                 goto exit_remove_files;
1385                         }
1386                 }
1387         }
1388
1389         data->hwmon_dev = hwmon_device_register(&pdev->dev);
1390         if (IS_ERR(data->hwmon_dev)) {
1391                 err = PTR_ERR(data->hwmon_dev);
1392                 dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
1393                 goto exit_remove_files;
1394         }
1395
1396         return 0;
1397
1398 exit_remove_files:
1399         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group);
1400         for (i = 0; i < 4; i++)
1401                 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]);
1402         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq);
1403 exit_release_region:
1404         release_region(res->start + ADDR_REG_OFFSET, 2);
1405 exit_free:
1406         platform_set_drvdata(pdev, NULL);
1407         kfree(data);
1408 exit:
1409         return err;
1410 }
1411
1412 static int __devexit f71805f_remove(struct platform_device *pdev)
1413 {
1414         struct f71805f_data *data = platform_get_drvdata(pdev);
1415         struct resource *res;
1416         int i;
1417
1418         hwmon_device_unregister(data->hwmon_dev);
1419         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group);
1420         for (i = 0; i < 4; i++)
1421                 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]);
1422         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq);
1423         platform_set_drvdata(pdev, NULL);
1424         kfree(data);
1425
1426         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1427         release_region(res->start + ADDR_REG_OFFSET, 2);
1428
1429         return 0;
1430 }
1431
1432 static struct platform_driver f71805f_driver = {
1433         .driver = {
1434                 .owner  = THIS_MODULE,
1435                 .name   = DRVNAME,
1436         },
1437         .probe          = f71805f_probe,
1438         .remove         = __devexit_p(f71805f_remove),
1439 };
1440
1441 static int __init f71805f_device_add(unsigned short address,
1442                                      const struct f71805f_sio_data *sio_data)
1443 {
1444         struct resource res = {
1445                 .start  = address,
1446                 .end    = address + REGION_LENGTH - 1,
1447                 .flags  = IORESOURCE_IO,
1448         };
1449         int err;
1450
1451         pdev = platform_device_alloc(DRVNAME, address);
1452         if (!pdev) {
1453                 err = -ENOMEM;
1454                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1455                 goto exit;
1456         }
1457
1458         res.name = pdev->name;
1459         err = acpi_check_resource_conflict(&res);
1460         if (err)
1461                 goto exit_device_put;
1462
1463         err = platform_device_add_resources(pdev, &res, 1);
1464         if (err) {
1465                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1466                        "(%d)\n", err);
1467                 goto exit_device_put;
1468         }
1469
1470         err = platform_device_add_data(pdev, sio_data,
1471                                        sizeof(struct f71805f_sio_data));
1472         if (err) {
1473                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1474                 goto exit_device_put;
1475         }
1476
1477         err = platform_device_add(pdev);
1478         if (err) {
1479                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1480                        err);
1481                 goto exit_device_put;
1482         }
1483
1484         return 0;
1485
1486 exit_device_put:
1487         platform_device_put(pdev);
1488 exit:
1489         return err;
1490 }
1491
1492 static int __init f71805f_find(int sioaddr, unsigned short *address,
1493                                struct f71805f_sio_data *sio_data)
1494 {
1495         int err = -ENODEV;
1496         u16 devid;
1497
1498         static const char *names[] = {
1499                 "F71805F/FG",
1500                 "F71872F/FG or F71806F/FG",
1501         };
1502
1503         superio_enter(sioaddr);
1504
1505         devid = superio_inw(sioaddr, SIO_REG_MANID);
1506         if (devid != SIO_FINTEK_ID)
1507                 goto exit;
1508
1509         devid = force_id ? force_id : superio_inw(sioaddr, SIO_REG_DEVID);
1510         switch (devid) {
1511         case SIO_F71805F_ID:
1512                 sio_data->kind = f71805f;
1513                 break;
1514         case SIO_F71872F_ID:
1515                 sio_data->kind = f71872f;
1516                 sio_data->fnsel1 = superio_inb(sioaddr, SIO_REG_FNSEL1);
1517                 break;
1518         default:
1519                 printk(KERN_INFO DRVNAME ": Unsupported Fintek device, "
1520                        "skipping\n");
1521                 goto exit;
1522         }
1523
1524         superio_select(sioaddr, F71805F_LD_HWM);
1525         if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
1526                 printk(KERN_WARNING DRVNAME ": Device not activated, "
1527                        "skipping\n");
1528                 goto exit;
1529         }
1530
1531         *address = superio_inw(sioaddr, SIO_REG_ADDR);
1532         if (*address == 0) {
1533                 printk(KERN_WARNING DRVNAME ": Base address not set, "
1534                        "skipping\n");
1535                 goto exit;
1536         }
1537         *address &= ~(REGION_LENGTH - 1);       /* Ignore 3 LSB */
1538
1539         err = 0;
1540         printk(KERN_INFO DRVNAME ": Found %s chip at %#x, revision %u\n",
1541                names[sio_data->kind], *address,
1542                superio_inb(sioaddr, SIO_REG_DEVREV));
1543
1544 exit:
1545         superio_exit(sioaddr);
1546         return err;
1547 }
1548
1549 static int __init f71805f_init(void)
1550 {
1551         int err;
1552         unsigned short address;
1553         struct f71805f_sio_data sio_data;
1554
1555         if (f71805f_find(0x2e, &address, &sio_data)
1556          && f71805f_find(0x4e, &address, &sio_data))
1557                 return -ENODEV;
1558
1559         err = platform_driver_register(&f71805f_driver);
1560         if (err)
1561                 goto exit;
1562
1563         /* Sets global pdev as a side effect */
1564         err = f71805f_device_add(address, &sio_data);
1565         if (err)
1566                 goto exit_driver;
1567
1568         return 0;
1569
1570 exit_driver:
1571         platform_driver_unregister(&f71805f_driver);
1572 exit:
1573         return err;
1574 }
1575
1576 static void __exit f71805f_exit(void)
1577 {
1578         platform_device_unregister(pdev);
1579         platform_driver_unregister(&f71805f_driver);
1580 }
1581
1582 MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
1583 MODULE_LICENSE("GPL");
1584 MODULE_DESCRIPTION("F71805F/F71872F hardware monitoring driver");
1585
1586 module_init(f71805f_init);
1587 module_exit(f71805f_exit);