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