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