SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/hwmon/f71882fg.c

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Hans Edgington <hans@edgington.nl>              *
   3  *   Copyright (C) 2007,2008 by Hans de Goede <hdegoede@redhat.com>        *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/hwmon.h>
  27 #include <linux/hwmon-sysfs.h>
  28 #include <linux/err.h>
  29 #include <linux/mutex.h>
  30 #include <linux/io.h>
  31
  32 #define DRVNAME "f71882fg"
  33
  34 #define SIO_F71882FG_LD_HWM     0x04    /* Hardware monitor logical device */
  35 #define SIO_UNLOCK_KEY          0x87    /* Key to enable Super-I/O */
  36 #define SIO_LOCK_KEY            0xAA    /* Key to diasble Super-I/O */
  37
  38 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  39 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  40 #define SIO_REG_DEVREV          0x22    /* Device revision */
  41 #define SIO_REG_MANID           0x23    /* Fintek ID (2 bytes) */
  42 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  43 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  44
  45 #define SIO_FINTEK_ID           0x1934  /* Manufacturers ID */
  46 #define SIO_F71862_ID           0x0601  /* Chipset ID */
  47 #define SIO_F71882_ID           0x0541  /* Chipset ID */
  48
  49 #define REGION_LENGTH           8
  50 #define ADDR_REG_OFFSET         5
  51 #define DATA_REG_OFFSET         6
  52
  53 #define F71882FG_REG_PECI               0x0A
  54
  55 #define F71882FG_REG_IN_STATUS          0x12 /* f71882fg only */
  56 #define F71882FG_REG_IN_BEEP            0x13 /* f71882fg only */
  57 #define F71882FG_REG_IN(nr)             (0x20  + (nr))
  58 #define F71882FG_REG_IN1_HIGH           0x32 /* f71882fg only */
  59
  60 #define F71882FG_REG_FAN(nr)            (0xA0 + (16 * (nr)))
  61 #define F71882FG_REG_FAN_TARGET(nr)     (0xA2 + (16 * (nr)))
  62 #define F71882FG_REG_FAN_FULL_SPEED(nr) (0xA4 + (16 * (nr)))
  63 #define F71882FG_REG_FAN_STATUS         0x92
  64 #define F71882FG_REG_FAN_BEEP           0x93
  65
  66 #define F71882FG_REG_TEMP(nr)           (0x70 + 2 * (nr))
  67 #define F71882FG_REG_TEMP_OVT(nr)       (0x80 + 2 * (nr))
  68 #define F71882FG_REG_TEMP_HIGH(nr)      (0x81 + 2 * (nr))
  69 #define F71882FG_REG_TEMP_STATUS        0x62
  70 #define F71882FG_REG_TEMP_BEEP          0x63
  71 #define F71882FG_REG_TEMP_HYST(nr)      (0x6C + (nr))
  72 #define F71882FG_REG_TEMP_TYPE          0x6B
  73 #define F71882FG_REG_TEMP_DIODE_OPEN    0x6F
  74
  75 #define F71882FG_REG_PWM(nr)            (0xA3 + (16 * (nr)))
  76 #define F71882FG_REG_PWM_TYPE           0x94
  77 #define F71882FG_REG_PWM_ENABLE         0x96
  78
  79 #define F71882FG_REG_FAN_HYST(nr)       (0x98 + (nr))
  80
  81 #define F71882FG_REG_POINT_PWM(pwm, point)      (0xAA + (point) + (16 * (pwm)))
  82 #define F71882FG_REG_POINT_TEMP(pwm, point)     (0xA6 + (point) + (16 * (pwm)))
  83 #define F71882FG_REG_POINT_MAPPING(nr)          (0xAF + 16 * (nr))
  84
  85 #define F71882FG_REG_START              0x01
  86
  87 #define FAN_MIN_DETECT                  366 /* Lowest detectable fanspeed */
  88
  89 static unsigned short force_id;
  90 module_param(force_id, ushort, 0);
  91 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  92
  93 enum chips { f71862fg, f71882fg };
  94
  95 static const char *f71882fg_names[] = {
  96         "f71862fg",
  97         "f71882fg",
  98 };
  99
 100 static struct platform_device *f71882fg_pdev;
 101
 102 /* Super-I/O Function prototypes */
 103 static inline int superio_inb(int base, int reg);
 104 static inline int superio_inw(int base, int reg);
 105 static inline void superio_enter(int base);
 106 static inline void superio_select(int base, int ld);
 107 static inline void superio_exit(int base);
 108
 109 struct f71882fg_sio_data {
 110         enum chips type;
 111 };
 112
 113 struct f71882fg_data {
 114         unsigned short addr;
 115         enum chips type;
 116         struct device *hwmon_dev;
 117
 118         struct mutex update_lock;
 119         char valid;                     /* !=0 if following fields are valid */
 120         unsigned long last_updated;     /* In jiffies */
 121         unsigned long last_limits;      /* In jiffies */
 122
 123         /* Register Values */
 124         u8      in[9];
 125         u8      in1_max;
 126         u8      in_status;
 127         u8      in_beep;
 128         u16     fan[4];
 129         u16     fan_target[4];
 130         u16     fan_full_speed[4];
 131         u8      fan_status;
 132         u8      fan_beep;
 133         /* Note: all models have only 3 temperature channels, but on some
 134            they are addressed as 0-2 and on others as 1-3, so for coding
 135            convenience we reserve space for 4 channels */
 136         u8      temp[4];
 137         u8      temp_ovt[4];
 138         u8      temp_high[4];
 139         u8      temp_hyst[2]; /* 2 hysts stored per reg */
 140         u8      temp_type[4];
 141         u8      temp_status;
 142         u8      temp_beep;
 143         u8      temp_diode_open;
 144         u8      pwm[4];
 145         u8      pwm_enable;
 146         u8      pwm_auto_point_hyst[2];
 147         u8      pwm_auto_point_mapping[4];
 148         u8      pwm_auto_point_pwm[4][5];
 149         u8      pwm_auto_point_temp[4][4];
 150 };
 151
 152 /* Sysfs in */
 153 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
 154         char *buf);
 155 static ssize_t show_in_max(struct device *dev, struct device_attribute
 156         *devattr, char *buf);
 157 static ssize_t store_in_max(struct device *dev, struct device_attribute
 158         *devattr, const char *buf, size_t count);
 159 static ssize_t show_in_beep(struct device *dev, struct device_attribute
 160         *devattr, char *buf);
 161 static ssize_t store_in_beep(struct device *dev, struct device_attribute
 162         *devattr, const char *buf, size_t count);
 163 static ssize_t show_in_alarm(struct device *dev, struct device_attribute
 164         *devattr, char *buf);
 165 /* Sysfs Fan */
 166 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 167         char *buf);
 168 static ssize_t show_fan_full_speed(struct device *dev,
 169         struct device_attribute *devattr, char *buf);
 170 static ssize_t store_fan_full_speed(struct device *dev,
 171         struct device_attribute *devattr, const char *buf, size_t count);
 172 static ssize_t show_fan_beep(struct device *dev, struct device_attribute
 173         *devattr, char *buf);
 174 static ssize_t store_fan_beep(struct device *dev, struct device_attribute
 175         *devattr, const char *buf, size_t count);
 176 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
 177         *devattr, char *buf);
 178 /* Sysfs Temp */
 179 static ssize_t show_temp(struct device *dev, struct device_attribute
 180         *devattr, char *buf);
 181 static ssize_t show_temp_max(struct device *dev, struct device_attribute
 182         *devattr, char *buf);
 183 static ssize_t store_temp_max(struct device *dev, struct device_attribute
 184         *devattr, const char *buf, size_t count);
 185 static ssize_t show_temp_max_hyst(struct device *dev, struct device_attribute
 186         *devattr, char *buf);
 187 static ssize_t store_temp_max_hyst(struct device *dev, struct device_attribute
 188         *devattr, const char *buf, size_t count);
 189 static ssize_t show_temp_crit(struct device *dev, struct device_attribute
 190         *devattr, char *buf);
 191 static ssize_t store_temp_crit(struct device *dev, struct device_attribute
 192         *devattr, const char *buf, size_t count);
 193 static ssize_t show_temp_crit_hyst(struct device *dev, struct device_attribute
 194         *devattr, char *buf);
 195 static ssize_t show_temp_type(struct device *dev, struct device_attribute
 196         *devattr, char *buf);
 197 static ssize_t show_temp_beep(struct device *dev, struct device_attribute
 198         *devattr, char *buf);
 199 static ssize_t store_temp_beep(struct device *dev, struct device_attribute
 200         *devattr, const char *buf, size_t count);
 201 static ssize_t show_temp_alarm(struct device *dev, struct device_attribute
 202         *devattr, char *buf);
 203 static ssize_t show_temp_fault(struct device *dev, struct device_attribute
 204         *devattr, char *buf);
 205 /* PWM and Auto point control */
 206 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
 207         char *buf);
 208 static ssize_t store_pwm(struct device *dev, struct device_attribute *devattr,
 209         const char *buf, size_t count);
 210 static ssize_t show_pwm_enable(struct device *dev,
 211         struct device_attribute *devattr, char *buf);
 212 static ssize_t store_pwm_enable(struct device *dev,
 213         struct device_attribute *devattr, const char *buf, size_t count);
 214 static ssize_t show_pwm_interpolate(struct device *dev,
 215         struct device_attribute *devattr, char *buf);
 216 static ssize_t store_pwm_interpolate(struct device *dev,
 217         struct device_attribute *devattr, const char *buf, size_t count);
 218 static ssize_t show_pwm_auto_point_channel(struct device *dev,
 219         struct device_attribute *devattr, char *buf);
 220 static ssize_t store_pwm_auto_point_channel(struct device *dev,
 221         struct device_attribute *devattr, const char *buf, size_t count);
 222 static ssize_t show_pwm_auto_point_temp_hyst(struct device *dev,
 223         struct device_attribute *devattr, char *buf);
 224 static ssize_t store_pwm_auto_point_temp_hyst(struct device *dev,
 225         struct device_attribute *devattr, const char *buf, size_t count);
 226 static ssize_t show_pwm_auto_point_pwm(struct device *dev,
 227         struct device_attribute *devattr, char *buf);
 228 static ssize_t store_pwm_auto_point_pwm(struct device *dev,
 229         struct device_attribute *devattr, const char *buf, size_t count);
 230 static ssize_t show_pwm_auto_point_temp(struct device *dev,
 231         struct device_attribute *devattr, char *buf);
 232 static ssize_t store_pwm_auto_point_temp(struct device *dev,
 233         struct device_attribute *devattr, const char *buf, size_t count);
 234 /* Sysfs misc */
 235 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
 236         char *buf);
 237
 238 static int __devinit f71882fg_probe(struct platform_device * pdev);
 239 static int f71882fg_remove(struct platform_device *pdev);
 240
 241 static struct platform_driver f71882fg_driver = {
 242         .driver = {
 243                 .owner  = THIS_MODULE,
 244                 .name   = DRVNAME,
 245         },
 246         .probe          = f71882fg_probe,
 247         .remove         = __devexit_p(f71882fg_remove),
 248 };
 249
 250 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 251
 252 static struct sensor_device_attribute_2 f718x2fg_in_temp_attr[] = {
 253         SENSOR_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0),
 254         SENSOR_ATTR_2(in1_input, S_IRUGO, show_in, NULL, 0, 1),
 255         SENSOR_ATTR_2(in2_input, S_IRUGO, show_in, NULL, 0, 2),
 256         SENSOR_ATTR_2(in3_input, S_IRUGO, show_in, NULL, 0, 3),
 257         SENSOR_ATTR_2(in4_input, S_IRUGO, show_in, NULL, 0, 4),
 258         SENSOR_ATTR_2(in5_input, S_IRUGO, show_in, NULL, 0, 5),
 259         SENSOR_ATTR_2(in6_input, S_IRUGO, show_in, NULL, 0, 6),
 260         SENSOR_ATTR_2(in7_input, S_IRUGO, show_in, NULL, 0, 7),
 261         SENSOR_ATTR_2(in8_input, S_IRUGO, show_in, NULL, 0, 8),
 262         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 1),
 263         SENSOR_ATTR_2(temp1_max, S_IRUGO|S_IWUSR, show_temp_max,
 264                 store_temp_max, 0, 1),
 265         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO|S_IWUSR, show_temp_max_hyst,
 266                 store_temp_max_hyst, 0, 1),
 267         /* Should really be temp1_max_alarm, but older versions did not handle
 268            the max and crit alarms separately and lm_sensors v2 depends on the
 269            presence of temp#_alarm files. The same goes for temp2/3 _alarm. */
 270         SENSOR_ATTR_2(temp1_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 1),
 271         SENSOR_ATTR_2(temp1_max_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 272                 store_temp_beep, 0, 1),
 273         SENSOR_ATTR_2(temp1_crit, S_IRUGO|S_IWUSR, show_temp_crit,
 274                 store_temp_crit, 0, 1),
 275         SENSOR_ATTR_2(temp1_crit_hyst, S_IRUGO, show_temp_crit_hyst, NULL,
 276                 0, 1),
 277         SENSOR_ATTR_2(temp1_crit_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 5),
 278         SENSOR_ATTR_2(temp1_crit_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 279                 store_temp_beep, 0, 5),
 280         SENSOR_ATTR_2(temp1_type, S_IRUGO, show_temp_type, NULL, 0, 1),
 281         SENSOR_ATTR_2(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0, 1),
 282         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0, 2),
 283         SENSOR_ATTR_2(temp2_max, S_IRUGO|S_IWUSR, show_temp_max,
 284                 store_temp_max, 0, 2),
 285         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO|S_IWUSR, show_temp_max_hyst,
 286                 store_temp_max_hyst, 0, 2),
 287         /* Should be temp2_max_alarm, see temp1_alarm note */
 288         SENSOR_ATTR_2(temp2_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 2),
 289         SENSOR_ATTR_2(temp2_max_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 290                 store_temp_beep, 0, 2),
 291         SENSOR_ATTR_2(temp2_crit, S_IRUGO|S_IWUSR, show_temp_crit,
 292                 store_temp_crit, 0, 2),
 293         SENSOR_ATTR_2(temp2_crit_hyst, S_IRUGO, show_temp_crit_hyst, NULL,
 294                 0, 2),
 295         SENSOR_ATTR_2(temp2_crit_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 6),
 296         SENSOR_ATTR_2(temp2_crit_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 297                 store_temp_beep, 0, 6),
 298         SENSOR_ATTR_2(temp2_type, S_IRUGO, show_temp_type, NULL, 0, 2),
 299         SENSOR_ATTR_2(temp2_fault, S_IRUGO, show_temp_fault, NULL, 0, 2),
 300         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0, 3),
 301         SENSOR_ATTR_2(temp3_max, S_IRUGO|S_IWUSR, show_temp_max,
 302                 store_temp_max, 0, 3),
 303         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO|S_IWUSR, show_temp_max_hyst,
 304                 store_temp_max_hyst, 0, 3),
 305         /* Should be temp3_max_alarm, see temp1_alarm note */
 306         SENSOR_ATTR_2(temp3_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 3),
 307         SENSOR_ATTR_2(temp3_max_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 308                 store_temp_beep, 0, 3),
 309         SENSOR_ATTR_2(temp3_crit, S_IRUGO|S_IWUSR, show_temp_crit,
 310                 store_temp_crit, 0, 3),
 311         SENSOR_ATTR_2(temp3_crit_hyst, S_IRUGO, show_temp_crit_hyst, NULL,
 312                 0, 3),
 313         SENSOR_ATTR_2(temp3_crit_alarm, S_IRUGO, show_temp_alarm, NULL, 0, 7),
 314         SENSOR_ATTR_2(temp3_crit_beep, S_IRUGO|S_IWUSR, show_temp_beep,
 315                 store_temp_beep, 0, 7),
 316         SENSOR_ATTR_2(temp3_type, S_IRUGO, show_temp_type, NULL, 0, 3),
 317         SENSOR_ATTR_2(temp3_fault, S_IRUGO, show_temp_fault, NULL, 0, 3),
 318 };
 319
 320 static struct sensor_device_attribute_2 f71882fg_in_temp_attr[] = {
 321         SENSOR_ATTR_2(in1_max, S_IRUGO|S_IWUSR, show_in_max, store_in_max,
 322                 0, 1),
 323         SENSOR_ATTR_2(in1_beep, S_IRUGO|S_IWUSR, show_in_beep, store_in_beep,
 324                 0, 1),
 325         SENSOR_ATTR_2(in1_alarm, S_IRUGO, show_in_alarm, NULL, 0, 1),
 326 };
 327
 328 static struct sensor_device_attribute_2 f718x2fg_fan_attr[] = {
 329         SENSOR_ATTR_2(fan1_input, S_IRUGO, show_fan, NULL, 0, 0),
 330         SENSOR_ATTR_2(fan1_full_speed, S_IRUGO|S_IWUSR,
 331                       show_fan_full_speed,
 332                       store_fan_full_speed, 0, 0),
 333         SENSOR_ATTR_2(fan1_beep, S_IRUGO|S_IWUSR, show_fan_beep,
 334                 store_fan_beep, 0, 0),
 335         SENSOR_ATTR_2(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 0),
 336         SENSOR_ATTR_2(fan2_input, S_IRUGO, show_fan, NULL, 0, 1),
 337         SENSOR_ATTR_2(fan2_full_speed, S_IRUGO|S_IWUSR,
 338                       show_fan_full_speed,
 339                       store_fan_full_speed, 0, 1),
 340         SENSOR_ATTR_2(fan2_beep, S_IRUGO|S_IWUSR, show_fan_beep,
 341                 store_fan_beep, 0, 1),
 342         SENSOR_ATTR_2(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 1),
 343         SENSOR_ATTR_2(fan3_input, S_IRUGO, show_fan, NULL, 0, 2),
 344         SENSOR_ATTR_2(fan3_full_speed, S_IRUGO|S_IWUSR,
 345                       show_fan_full_speed,
 346                       store_fan_full_speed, 0, 2),
 347         SENSOR_ATTR_2(fan3_beep, S_IRUGO|S_IWUSR, show_fan_beep,
 348                 store_fan_beep, 0, 2),
 349         SENSOR_ATTR_2(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 2),
 350
 351         SENSOR_ATTR_2(pwm1, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 0),
 352         SENSOR_ATTR_2(pwm1_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
 353                       store_pwm_enable, 0, 0),
 354         SENSOR_ATTR_2(pwm1_interpolate, S_IRUGO|S_IWUSR,
 355                       show_pwm_interpolate, store_pwm_interpolate, 0, 0),
 356         SENSOR_ATTR_2(pwm1_auto_channels_temp, S_IRUGO|S_IWUSR,
 357                       show_pwm_auto_point_channel,
 358                       store_pwm_auto_point_channel, 0, 0),
 359
 360         SENSOR_ATTR_2(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 1),
 361         SENSOR_ATTR_2(pwm2_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
 362                       store_pwm_enable, 0, 1),
 363         SENSOR_ATTR_2(pwm2_interpolate, S_IRUGO|S_IWUSR,
 364                       show_pwm_interpolate, store_pwm_interpolate, 0, 1),
 365         SENSOR_ATTR_2(pwm2_auto_channels_temp, S_IRUGO|S_IWUSR,
 366                       show_pwm_auto_point_channel,
 367                       store_pwm_auto_point_channel, 0, 1),
 368
 369         SENSOR_ATTR_2(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 2),
 370         SENSOR_ATTR_2(pwm3_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
 371                       store_pwm_enable, 0, 2),
 372         SENSOR_ATTR_2(pwm3_interpolate, S_IRUGO|S_IWUSR,
 373                       show_pwm_interpolate, store_pwm_interpolate, 0, 2),
 374         SENSOR_ATTR_2(pwm3_auto_channels_temp, S_IRUGO|S_IWUSR,
 375                       show_pwm_auto_point_channel,
 376                       store_pwm_auto_point_channel, 0, 2),
 377 };
 378
 379 static struct sensor_device_attribute_2 f71862fg_fan_attr[] = {
 380         SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO|S_IWUSR,
 381                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 382                       1, 0),
 383         SENSOR_ATTR_2(pwm1_auto_point2_pwm, S_IRUGO|S_IWUSR,
 384                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 385                       4, 0),
 386         SENSOR_ATTR_2(pwm1_auto_point1_temp, S_IRUGO|S_IWUSR,
 387                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 388                       0, 0),
 389         SENSOR_ATTR_2(pwm1_auto_point2_temp, S_IRUGO|S_IWUSR,
 390                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 391                       3, 0),
 392         SENSOR_ATTR_2(pwm1_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 393                       show_pwm_auto_point_temp_hyst,
 394                       store_pwm_auto_point_temp_hyst,
 395                       0, 0),
 396         SENSOR_ATTR_2(pwm1_auto_point2_temp_hyst, S_IRUGO,
 397                       show_pwm_auto_point_temp_hyst, NULL, 3, 0),
 398
 399         SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO|S_IWUSR,
 400                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 401                       1, 1),
 402         SENSOR_ATTR_2(pwm2_auto_point2_pwm, S_IRUGO|S_IWUSR,
 403                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 404                       4, 1),
 405         SENSOR_ATTR_2(pwm2_auto_point1_temp, S_IRUGO|S_IWUSR,
 406                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 407                       0, 1),
 408         SENSOR_ATTR_2(pwm2_auto_point2_temp, S_IRUGO|S_IWUSR,
 409                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 410                       3, 1),
 411         SENSOR_ATTR_2(pwm2_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 412                       show_pwm_auto_point_temp_hyst,
 413                       store_pwm_auto_point_temp_hyst,
 414                       0, 1),
 415         SENSOR_ATTR_2(pwm2_auto_point2_temp_hyst, S_IRUGO,
 416                       show_pwm_auto_point_temp_hyst, NULL, 3, 1),
 417 };
 418
 419 static struct sensor_device_attribute_2 f71882fg_fan_attr[] = {
 420         SENSOR_ATTR_2(fan4_input, S_IRUGO, show_fan, NULL, 0, 3),
 421         SENSOR_ATTR_2(fan4_full_speed, S_IRUGO|S_IWUSR,
 422                       show_fan_full_speed,
 423                       store_fan_full_speed, 0, 3),
 424         SENSOR_ATTR_2(fan4_beep, S_IRUGO|S_IWUSR, show_fan_beep,
 425                 store_fan_beep, 0, 3),
 426         SENSOR_ATTR_2(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 3),
 427
 428         SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO|S_IWUSR,
 429                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 430                       0, 0),
 431         SENSOR_ATTR_2(pwm1_auto_point2_pwm, S_IRUGO|S_IWUSR,
 432                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 433                       1, 0),
 434         SENSOR_ATTR_2(pwm1_auto_point3_pwm, S_IRUGO|S_IWUSR,
 435                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 436                       2, 0),
 437         SENSOR_ATTR_2(pwm1_auto_point4_pwm, S_IRUGO|S_IWUSR,
 438                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 439                       3, 0),
 440         SENSOR_ATTR_2(pwm1_auto_point5_pwm, S_IRUGO|S_IWUSR,
 441                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 442                       4, 0),
 443         SENSOR_ATTR_2(pwm1_auto_point1_temp, S_IRUGO|S_IWUSR,
 444                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 445                       0, 0),
 446         SENSOR_ATTR_2(pwm1_auto_point2_temp, S_IRUGO|S_IWUSR,
 447                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 448                       1, 0),
 449         SENSOR_ATTR_2(pwm1_auto_point3_temp, S_IRUGO|S_IWUSR,
 450                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 451                       2, 0),
 452         SENSOR_ATTR_2(pwm1_auto_point4_temp, S_IRUGO|S_IWUSR,
 453                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 454                       3, 0),
 455         SENSOR_ATTR_2(pwm1_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 456                       show_pwm_auto_point_temp_hyst,
 457                       store_pwm_auto_point_temp_hyst,
 458                       0, 0),
 459         SENSOR_ATTR_2(pwm1_auto_point2_temp_hyst, S_IRUGO,
 460                       show_pwm_auto_point_temp_hyst, NULL, 1, 0),
 461         SENSOR_ATTR_2(pwm1_auto_point3_temp_hyst, S_IRUGO,
 462                       show_pwm_auto_point_temp_hyst, NULL, 2, 0),
 463         SENSOR_ATTR_2(pwm1_auto_point4_temp_hyst, S_IRUGO,
 464                       show_pwm_auto_point_temp_hyst, NULL, 3, 0),
 465
 466         SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO|S_IWUSR,
 467                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 468                       0, 1),
 469         SENSOR_ATTR_2(pwm2_auto_point2_pwm, S_IRUGO|S_IWUSR,
 470                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 471                       1, 1),
 472         SENSOR_ATTR_2(pwm2_auto_point3_pwm, S_IRUGO|S_IWUSR,
 473                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 474                       2, 1),
 475         SENSOR_ATTR_2(pwm2_auto_point4_pwm, S_IRUGO|S_IWUSR,
 476                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 477                       3, 1),
 478         SENSOR_ATTR_2(pwm2_auto_point5_pwm, S_IRUGO|S_IWUSR,
 479                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 480                       4, 1),
 481         SENSOR_ATTR_2(pwm2_auto_point1_temp, S_IRUGO|S_IWUSR,
 482                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 483                       0, 1),
 484         SENSOR_ATTR_2(pwm2_auto_point2_temp, S_IRUGO|S_IWUSR,
 485                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 486                       1, 1),
 487         SENSOR_ATTR_2(pwm2_auto_point3_temp, S_IRUGO|S_IWUSR,
 488                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 489                       2, 1),
 490         SENSOR_ATTR_2(pwm2_auto_point4_temp, S_IRUGO|S_IWUSR,
 491                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 492                       3, 1),
 493         SENSOR_ATTR_2(pwm2_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 494                       show_pwm_auto_point_temp_hyst,
 495                       store_pwm_auto_point_temp_hyst,
 496                       0, 1),
 497         SENSOR_ATTR_2(pwm2_auto_point2_temp_hyst, S_IRUGO,
 498                       show_pwm_auto_point_temp_hyst, NULL, 1, 1),
 499         SENSOR_ATTR_2(pwm2_auto_point3_temp_hyst, S_IRUGO,
 500                       show_pwm_auto_point_temp_hyst, NULL, 2, 1),
 501         SENSOR_ATTR_2(pwm2_auto_point4_temp_hyst, S_IRUGO,
 502                       show_pwm_auto_point_temp_hyst, NULL, 3, 1),
 503
 504         SENSOR_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO|S_IWUSR,
 505                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 506                       0, 2),
 507         SENSOR_ATTR_2(pwm3_auto_point2_pwm, S_IRUGO|S_IWUSR,
 508                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 509                       1, 2),
 510         SENSOR_ATTR_2(pwm3_auto_point3_pwm, S_IRUGO|S_IWUSR,
 511                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 512                       2, 2),
 513         SENSOR_ATTR_2(pwm3_auto_point4_pwm, S_IRUGO|S_IWUSR,
 514                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 515                       3, 2),
 516         SENSOR_ATTR_2(pwm3_auto_point5_pwm, S_IRUGO|S_IWUSR,
 517                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 518                       4, 2),
 519         SENSOR_ATTR_2(pwm3_auto_point1_temp, S_IRUGO|S_IWUSR,
 520                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 521                       0, 2),
 522         SENSOR_ATTR_2(pwm3_auto_point2_temp, S_IRUGO|S_IWUSR,
 523                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 524                       1, 2),
 525         SENSOR_ATTR_2(pwm3_auto_point3_temp, S_IRUGO|S_IWUSR,
 526                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 527                       2, 2),
 528         SENSOR_ATTR_2(pwm3_auto_point4_temp, S_IRUGO|S_IWUSR,
 529                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 530                       3, 2),
 531         SENSOR_ATTR_2(pwm3_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 532                       show_pwm_auto_point_temp_hyst,
 533                       store_pwm_auto_point_temp_hyst,
 534                       0, 2),
 535         SENSOR_ATTR_2(pwm3_auto_point2_temp_hyst, S_IRUGO,
 536                       show_pwm_auto_point_temp_hyst, NULL, 1, 2),
 537         SENSOR_ATTR_2(pwm3_auto_point3_temp_hyst, S_IRUGO,
 538                       show_pwm_auto_point_temp_hyst, NULL, 2, 2),
 539         SENSOR_ATTR_2(pwm3_auto_point4_temp_hyst, S_IRUGO,
 540                       show_pwm_auto_point_temp_hyst, NULL, 3, 2),
 541
 542         SENSOR_ATTR_2(pwm4, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 3),
 543         SENSOR_ATTR_2(pwm4_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
 544                       store_pwm_enable, 0, 3),
 545         SENSOR_ATTR_2(pwm4_interpolate, S_IRUGO|S_IWUSR,
 546                       show_pwm_interpolate, store_pwm_interpolate, 0, 3),
 547         SENSOR_ATTR_2(pwm4_auto_channels_temp, S_IRUGO|S_IWUSR,
 548                       show_pwm_auto_point_channel,
 549                       store_pwm_auto_point_channel, 0, 3),
 550         SENSOR_ATTR_2(pwm4_auto_point1_pwm, S_IRUGO|S_IWUSR,
 551                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 552                       0, 3),
 553         SENSOR_ATTR_2(pwm4_auto_point2_pwm, S_IRUGO|S_IWUSR,
 554                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 555                       1, 3),
 556         SENSOR_ATTR_2(pwm4_auto_point3_pwm, S_IRUGO|S_IWUSR,
 557                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 558                       2, 3),
 559         SENSOR_ATTR_2(pwm4_auto_point4_pwm, S_IRUGO|S_IWUSR,
 560                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 561                       3, 3),
 562         SENSOR_ATTR_2(pwm4_auto_point5_pwm, S_IRUGO|S_IWUSR,
 563                       show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
 564                       4, 3),
 565         SENSOR_ATTR_2(pwm4_auto_point1_temp, S_IRUGO|S_IWUSR,
 566                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 567                       0, 3),
 568         SENSOR_ATTR_2(pwm4_auto_point2_temp, S_IRUGO|S_IWUSR,
 569                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 570                       1, 3),
 571         SENSOR_ATTR_2(pwm4_auto_point3_temp, S_IRUGO|S_IWUSR,
 572                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 573                       2, 3),
 574         SENSOR_ATTR_2(pwm4_auto_point4_temp, S_IRUGO|S_IWUSR,
 575                       show_pwm_auto_point_temp, store_pwm_auto_point_temp,
 576                       3, 3),
 577         SENSOR_ATTR_2(pwm4_auto_point1_temp_hyst, S_IRUGO|S_IWUSR,
 578                       show_pwm_auto_point_temp_hyst,
 579                       store_pwm_auto_point_temp_hyst,
 580                       0, 3),
 581         SENSOR_ATTR_2(pwm4_auto_point2_temp_hyst, S_IRUGO,
 582                       show_pwm_auto_point_temp_hyst, NULL, 1, 3),
 583         SENSOR_ATTR_2(pwm4_auto_point3_temp_hyst, S_IRUGO,
 584                       show_pwm_auto_point_temp_hyst, NULL, 2, 3),
 585         SENSOR_ATTR_2(pwm4_auto_point4_temp_hyst, S_IRUGO,
 586                       show_pwm_auto_point_temp_hyst, NULL, 3, 3),
 587 };
 588
 589
 590 /* Super I/O functions */
 591 static inline int superio_inb(int base, int reg)
 592 {
 593         outb(reg, base);
 594         return inb(base + 1);
 595 }
 596
 597 static int superio_inw(int base, int reg)
 598 {
 599         int val;
 600         outb(reg++, base);
 601         val = inb(base + 1) << 8;
 602         outb(reg, base);
 603         val |= inb(base + 1);
 604         return val;
 605 }
 606
 607 static inline void superio_enter(int base)
 608 {
 609         /* according to the datasheet the key must be send twice! */
 610         outb( SIO_UNLOCK_KEY, base);
 611         outb( SIO_UNLOCK_KEY, base);
 612 }
 613
 614 static inline void superio_select( int base, int ld)
 615 {
 616         outb(SIO_REG_LDSEL, base);
 617         outb(ld, base + 1);
 618 }
 619
 620 static inline void superio_exit(int base)
 621 {
 622         outb(SIO_LOCK_KEY, base);
 623 }
 624
 625 static inline u16 fan_from_reg(u16 reg)
 626 {
 627         return reg ? (1500000 / reg) : 0;
 628 }
 629
 630 static inline u16 fan_to_reg(u16 fan)
 631 {
 632         return fan ? (1500000 / fan) : 0;
 633 }
 634
 635 static u8 f71882fg_read8(struct f71882fg_data *data, u8 reg)
 636 {
 637         u8 val;
 638
 639         outb(reg, data->addr + ADDR_REG_OFFSET);
 640         val = inb(data->addr + DATA_REG_OFFSET);
 641
 642         return val;
 643 }
 644
 645 static u16 f71882fg_read16(struct f71882fg_data *data, u8 reg)
 646 {
 647         u16 val;
 648
 649         outb(reg++, data->addr + ADDR_REG_OFFSET);
 650         val = inb(data->addr + DATA_REG_OFFSET) << 8;
 651         outb(reg, data->addr + ADDR_REG_OFFSET);
 652         val |= inb(data->addr + DATA_REG_OFFSET);
 653
 654         return val;
 655 }
 656
 657 static void f71882fg_write8(struct f71882fg_data *data, u8 reg, u8 val)
 658 {
 659         outb(reg, data->addr + ADDR_REG_OFFSET);
 660         outb(val, data->addr + DATA_REG_OFFSET);
 661 }
 662
 663 static void f71882fg_write16(struct f71882fg_data *data, u8 reg, u16 val)
 664 {
 665         outb(reg++, data->addr + ADDR_REG_OFFSET);
 666         outb(val >> 8, data->addr + DATA_REG_OFFSET);
 667         outb(reg, data->addr + ADDR_REG_OFFSET);
 668         outb(val & 255, data->addr + DATA_REG_OFFSET);
 669 }
 670
 671 static struct f71882fg_data *f71882fg_update_device(struct device *dev)
 672 {
 673         struct f71882fg_data *data = dev_get_drvdata(dev);
 674         int nr, reg, reg2;
 675         int nr_fans = (data->type == f71862fg) ? 3 : 4;
 676
 677         mutex_lock(&data->update_lock);
 678
 679         /* Update once every 60 seconds */
 680         if ( time_after(jiffies, data->last_limits + 60 * HZ ) ||
 681                         !data->valid) {
 682                 if (data->type == f71882fg) {
 683                         data->in1_max =
 684                                 f71882fg_read8(data, F71882FG_REG_IN1_HIGH);
 685                         data->in_beep =
 686                                 f71882fg_read8(data, F71882FG_REG_IN_BEEP);
 687                 }
 688
 689                 /* Get High & boundary temps*/
 690                 for (nr = 1; nr < 4; nr++) {
 691                         data->temp_ovt[nr] = f71882fg_read8(data,
 692                                                 F71882FG_REG_TEMP_OVT(nr));
 693                         data->temp_high[nr] = f71882fg_read8(data,
 694                                                 F71882FG_REG_TEMP_HIGH(nr));
 695                 }
 696
 697                 /* hyst */
 698                 data->temp_hyst[0] =
 699                         f71882fg_read8(data, F71882FG_REG_TEMP_HYST(0));
 700                 data->temp_hyst[1] =
 701                         f71882fg_read8(data, F71882FG_REG_TEMP_HYST(1));
 702
 703                 /* Have to hardcode type, because temp1 is special */
 704                 reg  = f71882fg_read8(data, F71882FG_REG_TEMP_TYPE);
 705                 reg2 = f71882fg_read8(data, F71882FG_REG_PECI);
 706                 if ((reg2 & 0x03) == 0x01)
 707                         data->temp_type[1] = 6 /* PECI */;
 708                 else if ((reg2 & 0x03) == 0x02)
 709                         data->temp_type[1] = 5 /* AMDSI */;
 710                 else
 711                         data->temp_type[1] = (reg & 0x02) ? 2 : 4;
 712
 713                 data->temp_type[2] = (reg & 0x04) ? 2 : 4;
 714                 data->temp_type[3] = (reg & 0x08) ? 2 : 4;
 715
 716                 data->temp_beep = f71882fg_read8(data, F71882FG_REG_TEMP_BEEP);
 717
 718                 data->fan_beep = f71882fg_read8(data, F71882FG_REG_FAN_BEEP);
 719
 720                 data->pwm_enable = f71882fg_read8(data,
 721                                                   F71882FG_REG_PWM_ENABLE);
 722                 data->pwm_auto_point_hyst[0] =
 723                         f71882fg_read8(data, F71882FG_REG_FAN_HYST(0));
 724                 data->pwm_auto_point_hyst[1] =
 725                         f71882fg_read8(data, F71882FG_REG_FAN_HYST(1));
 726
 727                 for (nr = 0; nr < nr_fans; nr++) {
 728                         data->pwm_auto_point_mapping[nr] =
 729                             f71882fg_read8(data,
 730                                            F71882FG_REG_POINT_MAPPING(nr));
 731
 732                         if (data->type == f71882fg) {
 733                                 int point;
 734                                 for (point = 0; point < 5; point++) {
 735                                         data->pwm_auto_point_pwm[nr][point] =
 736                                                 f71882fg_read8(data,
 737                                                         F71882FG_REG_POINT_PWM
 738                                                         (nr, point));
 739                                 }
 740                                 for (point = 0; point < 4; point++) {
 741                                         data->pwm_auto_point_temp[nr][point] =
 742                                                 f71882fg_read8(data,
 743                                                         F71882FG_REG_POINT_TEMP
 744                                                         (nr, point));
 745                                 }
 746                         } else {
 747                                 data->pwm_auto_point_pwm[nr][1] =
 748                                         f71882fg_read8(data,
 749                                                 F71882FG_REG_POINT_PWM
 750                                                 (nr, 1));
 751                                 data->pwm_auto_point_pwm[nr][4] =
 752                                         f71882fg_read8(data,
 753                                                 F71882FG_REG_POINT_PWM
 754                                                 (nr, 4));
 755                                 data->pwm_auto_point_temp[nr][0] =
 756                                         f71882fg_read8(data,
 757                                                 F71882FG_REG_POINT_TEMP
 758                                                 (nr, 0));
 759                                 data->pwm_auto_point_temp[nr][3] =
 760                                         f71882fg_read8(data,
 761                                                 F71882FG_REG_POINT_TEMP
 762                                                 (nr, 3));
 763                         }
 764                 }
 765                 data->last_limits = jiffies;
 766         }
 767
 768         /* Update every second */
 769         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 770                 data->temp_status = f71882fg_read8(data,
 771                                                 F71882FG_REG_TEMP_STATUS);
 772                 data->temp_diode_open = f71882fg_read8(data,
 773                                                 F71882FG_REG_TEMP_DIODE_OPEN);
 774                 for (nr = 1; nr < 4; nr++)
 775                         data->temp[nr] = f71882fg_read8(data,
 776                                                 F71882FG_REG_TEMP(nr));
 777
 778                 data->fan_status = f71882fg_read8(data,
 779                                                 F71882FG_REG_FAN_STATUS);
 780                 for (nr = 0; nr < nr_fans; nr++) {
 781                         data->fan[nr] = f71882fg_read16(data,
 782                                                 F71882FG_REG_FAN(nr));
 783                         data->fan_target[nr] =
 784                             f71882fg_read16(data, F71882FG_REG_FAN_TARGET(nr));
 785                         data->fan_full_speed[nr] =
 786                             f71882fg_read16(data,
 787                                             F71882FG_REG_FAN_FULL_SPEED(nr));
 788                         data->pwm[nr] =
 789                             f71882fg_read8(data, F71882FG_REG_PWM(nr));
 790                 }
 791
 792                 if (data->type == f71882fg)
 793                         data->in_status = f71882fg_read8(data,
 794                                                 F71882FG_REG_IN_STATUS);
 795                 for (nr = 0; nr < 9; nr++)
 796                         data->in[nr] = f71882fg_read8(data,
 797                                                 F71882FG_REG_IN(nr));
 798
 799                 data->last_updated = jiffies;
 800                 data->valid = 1;
 801         }
 802
 803         mutex_unlock(&data->update_lock);
 804
 805         return data;
 806 }
 807
 808 /* Sysfs Interface */
 809 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 810         char *buf)
 811 {
 812         struct f71882fg_data *data = f71882fg_update_device(dev);
 813         int nr = to_sensor_dev_attr_2(devattr)->index;
 814         int speed = fan_from_reg(data->fan[nr]);
 815
 816         if (speed == FAN_MIN_DETECT)
 817                 speed = 0;
 818
 819         return sprintf(buf, "%d\n", speed);
 820 }
 821
 822 static ssize_t show_fan_full_speed(struct device *dev,
 823                                    struct device_attribute *devattr, char *buf)
 824 {
 825         struct f71882fg_data *data = f71882fg_update_device(dev);
 826         int nr = to_sensor_dev_attr_2(devattr)->index;
 827         int speed = fan_from_reg(data->fan_full_speed[nr]);
 828         return sprintf(buf, "%d\n", speed);
 829 }
 830
 831 static ssize_t store_fan_full_speed(struct device *dev,
 832                                     struct device_attribute *devattr,
 833                                     const char *buf, size_t count)
 834 {
 835         struct f71882fg_data *data = dev_get_drvdata(dev);
 836         int nr = to_sensor_dev_attr_2(devattr)->index;
 837         long val = simple_strtol(buf, NULL, 10);
 838
 839         val = SENSORS_LIMIT(val, 23, 1500000);
 840         val = fan_to_reg(val);
 841
 842         mutex_lock(&data->update_lock);
 843         f71882fg_write16(data, F71882FG_REG_FAN_FULL_SPEED(nr), val);
 844         data->fan_full_speed[nr] = val;
 845         mutex_unlock(&data->update_lock);
 846
 847         return count;
 848 }
 849
 850 static ssize_t show_fan_beep(struct device *dev, struct device_attribute
 851         *devattr, char *buf)
 852 {
 853         struct f71882fg_data *data = f71882fg_update_device(dev);
 854         int nr = to_sensor_dev_attr_2(devattr)->index;
 855
 856         if (data->fan_beep & (1 << nr))
 857                 return sprintf(buf, "1\n");
 858         else
 859                 return sprintf(buf, "0\n");
 860 }
 861
 862 static ssize_t store_fan_beep(struct device *dev, struct device_attribute
 863         *devattr, const char *buf, size_t count)
 864 {
 865         struct f71882fg_data *data = dev_get_drvdata(dev);
 866         int nr = to_sensor_dev_attr_2(devattr)->index;
 867         unsigned long val = simple_strtoul(buf, NULL, 10);
 868
 869         mutex_lock(&data->update_lock);
 870         data->fan_beep = f71882fg_read8(data, F71882FG_REG_FAN_BEEP);
 871         if (val)
 872                 data->fan_beep |= 1 << nr;
 873         else
 874                 data->fan_beep &= ~(1 << nr);
 875
 876         f71882fg_write8(data, F71882FG_REG_FAN_BEEP, data->fan_beep);
 877         mutex_unlock(&data->update_lock);
 878
 879         return count;
 880 }
 881
 882 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
 883         *devattr, char *buf)
 884 {
 885         struct f71882fg_data *data = f71882fg_update_device(dev);
 886         int nr = to_sensor_dev_attr_2(devattr)->index;
 887
 888         if (data->fan_status & (1 << nr))
 889                 return sprintf(buf, "1\n");
 890         else
 891                 return sprintf(buf, "0\n");
 892 }
 893
 894 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
 895         char *buf)
 896 {
 897         struct f71882fg_data *data = f71882fg_update_device(dev);
 898         int nr = to_sensor_dev_attr_2(devattr)->index;
 899
 900         return sprintf(buf, "%d\n", data->in[nr] * 8);
 901 }
 902
 903 static ssize_t show_in_max(struct device *dev, struct device_attribute
 904         *devattr, char *buf)
 905 {
 906         struct f71882fg_data *data = f71882fg_update_device(dev);
 907
 908         return sprintf(buf, "%d\n", data->in1_max * 8);
 909 }
 910
 911 static ssize_t store_in_max(struct device *dev, struct device_attribute
 912         *devattr, const char *buf, size_t count)
 913 {
 914         struct f71882fg_data *data = dev_get_drvdata(dev);
 915         long val = simple_strtol(buf, NULL, 10) / 8;
 916         val = SENSORS_LIMIT(val, 0, 255);
 917
 918         mutex_lock(&data->update_lock);
 919         f71882fg_write8(data, F71882FG_REG_IN1_HIGH, val);
 920         data->in1_max = val;
 921         mutex_unlock(&data->update_lock);
 922
 923         return count;
 924 }
 925
 926 static ssize_t show_in_beep(struct device *dev, struct device_attribute
 927         *devattr, char *buf)
 928 {
 929         struct f71882fg_data *data = f71882fg_update_device(dev);
 930         int nr = to_sensor_dev_attr_2(devattr)->index;
 931
 932         if (data->in_beep & (1 << nr))
 933                 return sprintf(buf, "1\n");
 934         else
 935                 return sprintf(buf, "0\n");
 936 }
 937
 938 static ssize_t store_in_beep(struct device *dev, struct device_attribute
 939         *devattr, const char *buf, size_t count)
 940 {
 941         struct f71882fg_data *data = dev_get_drvdata(dev);
 942         int nr = to_sensor_dev_attr_2(devattr)->index;
 943         unsigned long val = simple_strtoul(buf, NULL, 10);
 944
 945         mutex_lock(&data->update_lock);
 946         data->in_beep = f71882fg_read8(data, F71882FG_REG_IN_BEEP);
 947         if (val)
 948                 data->in_beep |= 1 << nr;
 949         else
 950                 data->in_beep &= ~(1 << nr);
 951
 952         f71882fg_write8(data, F71882FG_REG_IN_BEEP, data->in_beep);
 953         mutex_unlock(&data->update_lock);
 954
 955         return count;
 956 }
 957
 958 static ssize_t show_in_alarm(struct device *dev, struct device_attribute
 959         *devattr, char *buf)
 960 {
 961         struct f71882fg_data *data = f71882fg_update_device(dev);
 962         int nr = to_sensor_dev_attr_2(devattr)->index;
 963
 964         if (data->in_status & (1 << nr))
 965                 return sprintf(buf, "1\n");
 966         else
 967                 return sprintf(buf, "0\n");
 968 }
 969
 970 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 971         char *buf)
 972 {
 973         struct f71882fg_data *data = f71882fg_update_device(dev);
 974         int nr = to_sensor_dev_attr_2(devattr)->index;
 975
 976         return sprintf(buf, "%d\n", data->temp[nr] * 1000);
 977 }
 978
 979 static ssize_t show_temp_max(struct device *dev, struct device_attribute
 980         *devattr, char *buf)
 981 {
 982         struct f71882fg_data *data = f71882fg_update_device(dev);
 983         int nr = to_sensor_dev_attr_2(devattr)->index;
 984
 985         return sprintf(buf, "%d\n", data->temp_high[nr] * 1000);
 986 }
 987
 988 static ssize_t store_temp_max(struct device *dev, struct device_attribute
 989         *devattr, const char *buf, size_t count)
 990 {
 991         struct f71882fg_data *data = dev_get_drvdata(dev);
 992         int nr = to_sensor_dev_attr_2(devattr)->index;
 993         long val = simple_strtol(buf, NULL, 10) / 1000;
 994         val = SENSORS_LIMIT(val, 0, 255);
 995
 996         mutex_lock(&data->update_lock);
 997         f71882fg_write8(data, F71882FG_REG_TEMP_HIGH(nr), val);
 998         data->temp_high[nr] = val;
 999         mutex_unlock(&data->update_lock);
1000
1001         return count;
1002 }
1003
1004 static ssize_t show_temp_max_hyst(struct device *dev, struct device_attribute
1005         *devattr, char *buf)
1006 {
1007         struct f71882fg_data *data = f71882fg_update_device(dev);
1008         int nr = to_sensor_dev_attr_2(devattr)->index;
1009         int temp_max_hyst;
1010
1011         mutex_lock(&data->update_lock);
1012         if (nr & 1)
1013                 temp_max_hyst = data->temp_hyst[nr / 2] >> 4;
1014         else
1015                 temp_max_hyst = data->temp_hyst[nr / 2] & 0x0f;
1016         temp_max_hyst = (data->temp_high[nr] - temp_max_hyst) * 1000;
1017         mutex_unlock(&data->update_lock);
1018
1019         return sprintf(buf, "%d\n", temp_max_hyst);
1020 }
1021
1022 static ssize_t store_temp_max_hyst(struct device *dev, struct device_attribute
1023         *devattr, const char *buf, size_t count)
1024 {
1025         struct f71882fg_data *data = dev_get_drvdata(dev);
1026         int nr = to_sensor_dev_attr_2(devattr)->index;
1027         long val = simple_strtol(buf, NULL, 10) / 1000;
1028         ssize_t ret = count;
1029         u8 reg;
1030
1031         mutex_lock(&data->update_lock);
1032
1033         /* convert abs to relative and check */
1034         data->temp_high[nr] = f71882fg_read8(data, F71882FG_REG_TEMP_HIGH(nr));
1035         val = SENSORS_LIMIT(val, data->temp_high[nr] - 15,
1036                             data->temp_high[nr]);
1037         val = data->temp_high[nr] - val;
1038
1039         /* convert value to register contents */
1040         reg = f71882fg_read8(data, F71882FG_REG_TEMP_HYST(nr / 2));
1041         if (nr & 1)
1042                 reg = (reg & 0x0f) | (val << 4);
1043         else
1044                 reg = (reg & 0xf0) | val;
1045         f71882fg_write8(data, F71882FG_REG_TEMP_HYST(nr / 2), reg);
1046         data->temp_hyst[nr / 2] = reg;
1047
1048         mutex_unlock(&data->update_lock);
1049         return ret;
1050 }
1051
1052 static ssize_t show_temp_crit(struct device *dev, struct device_attribute
1053         *devattr, char *buf)
1054 {
1055         struct f71882fg_data *data = f71882fg_update_device(dev);
1056         int nr = to_sensor_dev_attr_2(devattr)->index;
1057
1058         return sprintf(buf, "%d\n", data->temp_ovt[nr] * 1000);
1059 }
1060
1061 static ssize_t store_temp_crit(struct device *dev, struct device_attribute
1062         *devattr, const char *buf, size_t count)
1063 {
1064         struct f71882fg_data *data = dev_get_drvdata(dev);
1065         int nr = to_sensor_dev_attr_2(devattr)->index;
1066         long val = simple_strtol(buf, NULL, 10) / 1000;
1067         val = SENSORS_LIMIT(val, 0, 255);
1068
1069         mutex_lock(&data->update_lock);
1070         f71882fg_write8(data, F71882FG_REG_TEMP_OVT(nr), val);
1071         data->temp_ovt[nr] = val;
1072         mutex_unlock(&data->update_lock);
1073
1074         return count;
1075 }
1076
1077 static ssize_t show_temp_crit_hyst(struct device *dev, struct device_attribute
1078         *devattr, char *buf)
1079 {
1080         struct f71882fg_data *data = f71882fg_update_device(dev);
1081         int nr = to_sensor_dev_attr_2(devattr)->index;
1082         int temp_crit_hyst;
1083
1084         mutex_lock(&data->update_lock);
1085         if (nr & 1)
1086                 temp_crit_hyst = data->temp_hyst[nr / 2] >> 4;
1087         else
1088                 temp_crit_hyst = data->temp_hyst[nr / 2] & 0x0f;
1089         temp_crit_hyst = (data->temp_ovt[nr] - temp_crit_hyst) * 1000;
1090         mutex_unlock(&data->update_lock);
1091
1092         return sprintf(buf, "%d\n", temp_crit_hyst);
1093 }
1094
1095 static ssize_t show_temp_type(struct device *dev, struct device_attribute
1096         *devattr, char *buf)
1097 {
1098         struct f71882fg_data *data = f71882fg_update_device(dev);
1099         int nr = to_sensor_dev_attr_2(devattr)->index;
1100
1101         return sprintf(buf, "%d\n", data->temp_type[nr]);
1102 }
1103
1104 static ssize_t show_temp_beep(struct device *dev, struct device_attribute
1105         *devattr, char *buf)
1106 {
1107         struct f71882fg_data *data = f71882fg_update_device(dev);
1108         int nr = to_sensor_dev_attr_2(devattr)->index;
1109
1110         if (data->temp_beep & (1 << nr))
1111                 return sprintf(buf, "1\n");
1112         else
1113                 return sprintf(buf, "0\n");
1114 }
1115
1116 static ssize_t store_temp_beep(struct device *dev, struct device_attribute
1117         *devattr, const char *buf, size_t count)
1118 {
1119         struct f71882fg_data *data = dev_get_drvdata(dev);
1120         int nr = to_sensor_dev_attr_2(devattr)->index;
1121         unsigned long val = simple_strtoul(buf, NULL, 10);
1122
1123         mutex_lock(&data->update_lock);
1124         data->temp_beep = f71882fg_read8(data, F71882FG_REG_TEMP_BEEP);
1125         if (val)
1126                 data->temp_beep |= 1 << nr;
1127         else
1128                 data->temp_beep &= ~(1 << nr);
1129
1130         f71882fg_write8(data, F71882FG_REG_TEMP_BEEP, data->temp_beep);
1131         mutex_unlock(&data->update_lock);
1132
1133         return count;
1134 }
1135
1136 static ssize_t show_temp_alarm(struct device *dev, struct device_attribute
1137         *devattr, char *buf)
1138 {
1139         struct f71882fg_data *data = f71882fg_update_device(dev);
1140         int nr = to_sensor_dev_attr_2(devattr)->index;
1141
1142         if (data->temp_status & (1 << nr))
1143                 return sprintf(buf, "1\n");
1144         else
1145                 return sprintf(buf, "0\n");
1146 }
1147
1148 static ssize_t show_temp_fault(struct device *dev, struct device_attribute
1149         *devattr, char *buf)
1150 {
1151         struct f71882fg_data *data = f71882fg_update_device(dev);
1152         int nr = to_sensor_dev_attr_2(devattr)->index;
1153
1154         if (data->temp_diode_open & (1 << nr))
1155                 return sprintf(buf, "1\n");
1156         else
1157                 return sprintf(buf, "0\n");
1158 }
1159
1160 static ssize_t show_pwm(struct device *dev,
1161                         struct device_attribute *devattr, char *buf)
1162 {
1163         struct f71882fg_data *data = f71882fg_update_device(dev);
1164         int val, nr = to_sensor_dev_attr_2(devattr)->index;
1165         mutex_lock(&data->update_lock);
1166         if (data->pwm_enable & (1 << (2 * nr)))
1167                 /* PWM mode */
1168                 val = data->pwm[nr];
1169         else {
1170                 /* RPM mode */
1171                 val = 255 * fan_from_reg(data->fan_target[nr])
1172                         / fan_from_reg(data->fan_full_speed[nr]);
1173         }
1174         mutex_unlock(&data->update_lock);
1175         return sprintf(buf, "%d\n", val);
1176 }
1177
1178 static ssize_t store_pwm(struct device *dev,
1179                          struct device_attribute *devattr, const char *buf,
1180                          size_t count)
1181 {
1182         struct f71882fg_data *data = dev_get_drvdata(dev);
1183         int nr = to_sensor_dev_attr_2(devattr)->index;
1184         long val = simple_strtol(buf, NULL, 10);
1185         val = SENSORS_LIMIT(val, 0, 255);
1186
1187         mutex_lock(&data->update_lock);
1188         data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1189         if (data->pwm_enable & (1 << (2 * nr))) {
1190                 /* PWM mode */
1191                 f71882fg_write8(data, F71882FG_REG_PWM(nr), val);
1192                 data->pwm[nr] = val;
1193         } else {
1194                 /* RPM mode */
1195                 int target, full_speed;
1196                 full_speed = f71882fg_read16(data,
1197                                              F71882FG_REG_FAN_FULL_SPEED(nr));
1198                 target = fan_to_reg(val * fan_from_reg(full_speed) / 255);
1199                 f71882fg_write16(data, F71882FG_REG_FAN_TARGET(nr), target);
1200                 data->fan_target[nr] = target;
1201                 data->fan_full_speed[nr] = full_speed;
1202         }
1203         mutex_unlock(&data->update_lock);
1204
1205         return count;
1206 }
1207
1208 static ssize_t show_pwm_enable(struct device *dev,
1209                                struct device_attribute *devattr, char *buf)
1210 {
1211         int result;
1212         struct f71882fg_data *data = f71882fg_update_device(dev);
1213         int nr = to_sensor_dev_attr_2(devattr)->index;
1214
1215         if (data->pwm_enable & (2 << (2 * nr)))
1216                 result = 1;
1217         else
1218                 result = 2;
1219
1220         return sprintf(buf, "%d\n", result);
1221 }
1222
1223 static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
1224                                 *devattr, const char *buf, size_t count)
1225 {
1226         struct f71882fg_data *data = dev_get_drvdata(dev);
1227         int nr = to_sensor_dev_attr_2(devattr)->index;
1228         long val = simple_strtol(buf, NULL, 10);
1229         if (val < 1 || val > 2)
1230                 return -EINVAL;
1231
1232         mutex_lock(&data->update_lock);
1233         data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1234         switch (val) {
1235         case 1:
1236                 data->pwm_enable |= 2 << (2 * nr);
1237                 break;          /* Manual */
1238         case 2:
1239                 data->pwm_enable &= ~(2 << (2 * nr));
1240                 break;          /* Temperature ctrl */
1241         }
1242         f71882fg_write8(data, F71882FG_REG_PWM_ENABLE, data->pwm_enable);
1243         mutex_unlock(&data->update_lock);
1244
1245         return count;
1246 }
1247
1248 static ssize_t show_pwm_auto_point_pwm(struct device *dev,
1249                                        struct device_attribute *devattr,
1250                                        char *buf)
1251 {
1252         int result;
1253         struct f71882fg_data *data = f71882fg_update_device(dev);
1254         int pwm = to_sensor_dev_attr_2(devattr)->index;
1255         int point = to_sensor_dev_attr_2(devattr)->nr;
1256
1257         mutex_lock(&data->update_lock);
1258         if (data->pwm_enable & (1 << (2 * pwm))) {
1259                 /* PWM mode */
1260                 result = data->pwm_auto_point_pwm[pwm][point];
1261         } else {
1262                 /* RPM mode */
1263                 result = 32 * 255 / (32 + data->pwm_auto_point_pwm[pwm][point]);
1264         }
1265         mutex_unlock(&data->update_lock);
1266
1267         return sprintf(buf, "%d\n", result);
1268 }
1269
1270 static ssize_t store_pwm_auto_point_pwm(struct device *dev,
1271                                         struct device_attribute *devattr,
1272                                         const char *buf, size_t count)
1273 {
1274         struct f71882fg_data *data = dev_get_drvdata(dev);
1275         int pwm = to_sensor_dev_attr_2(devattr)->index;
1276         int point = to_sensor_dev_attr_2(devattr)->nr;
1277         long val = simple_strtol(buf, NULL, 10);
1278         val = SENSORS_LIMIT(val, 0, 255);
1279
1280         mutex_lock(&data->update_lock);
1281         data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1282         if (data->pwm_enable & (1 << (2 * pwm))) {
1283                 /* PWM mode */
1284         } else {
1285                 /* RPM mode */
1286                 if (val < 29)   /* Prevent negative numbers */
1287                         val = 255;
1288                 else
1289                         val = (255 - val) * 32 / val;
1290         }
1291         f71882fg_write8(data, F71882FG_REG_POINT_PWM(pwm, point), val);
1292         data->pwm_auto_point_pwm[pwm][point] = val;
1293         mutex_unlock(&data->update_lock);
1294
1295         return count;
1296 }
1297
1298 static ssize_t show_pwm_auto_point_temp_hyst(struct device *dev,
1299                                              struct device_attribute *devattr,
1300                                              char *buf)
1301 {
1302         int result = 0;
1303         struct f71882fg_data *data = f71882fg_update_device(dev);
1304         int nr = to_sensor_dev_attr_2(devattr)->index;
1305         int point = to_sensor_dev_attr_2(devattr)->nr;
1306
1307         mutex_lock(&data->update_lock);
1308         if (nr & 1)
1309                 result = data->pwm_auto_point_hyst[nr / 2] >> 4;
1310         else
1311                 result = data->pwm_auto_point_hyst[nr / 2] & 0x0f;
1312         result = 1000 * (data->pwm_auto_point_temp[nr][point] - result);
1313         mutex_unlock(&data->update_lock);
1314
1315         return sprintf(buf, "%d\n", result);
1316 }
1317
1318 static ssize_t store_pwm_auto_point_temp_hyst(struct device *dev,
1319                                               struct device_attribute *devattr,
1320                                               const char *buf, size_t count)
1321 {
1322         struct f71882fg_data *data = dev_get_drvdata(dev);
1323         int nr = to_sensor_dev_attr_2(devattr)->index;
1324         int point = to_sensor_dev_attr_2(devattr)->nr;
1325         long val = simple_strtol(buf, NULL, 10) / 1000;
1326         u8 reg;
1327
1328         mutex_lock(&data->update_lock);
1329         data->pwm_auto_point_temp[nr][point] =
1330                 f71882fg_read8(data, F71882FG_REG_POINT_TEMP(nr, point));
1331         val = SENSORS_LIMIT(val, data->pwm_auto_point_temp[nr][point] - 15,
1332                                 data->pwm_auto_point_temp[nr][point]);
1333         val = data->pwm_auto_point_temp[nr][point] - val;
1334
1335         reg = f71882fg_read8(data, F71882FG_REG_FAN_HYST(nr / 2));
1336         if (nr & 1)
1337                 reg = (reg & 0x0f) | (val << 4);
1338         else
1339                 reg = (reg & 0xf0) | val;
1340
1341         f71882fg_write8(data, F71882FG_REG_FAN_HYST(nr / 2), reg);
1342         data->pwm_auto_point_hyst[nr / 2] = reg;
1343         mutex_unlock(&data->update_lock);
1344
1345         return count;
1346 }
1347
1348 static ssize_t show_pwm_interpolate(struct device *dev,
1349                                     struct device_attribute *devattr, char *buf)
1350 {
1351         int result;
1352         struct f71882fg_data *data = f71882fg_update_device(dev);
1353         int nr = to_sensor_dev_attr_2(devattr)->index;
1354
1355         result = (data->pwm_auto_point_mapping[nr] >> 4) & 1;
1356
1357         return sprintf(buf, "%d\n", result);
1358 }
1359
1360 static ssize_t store_pwm_interpolate(struct device *dev,
1361                                      struct device_attribute *devattr,
1362                                      const char *buf, size_t count)
1363 {
1364         struct f71882fg_data *data = dev_get_drvdata(dev);
1365         int nr = to_sensor_dev_attr_2(devattr)->index;
1366         unsigned long val = simple_strtoul(buf, NULL, 10);
1367
1368         mutex_lock(&data->update_lock);
1369         data->pwm_auto_point_mapping[nr] =
1370                 f71882fg_read8(data, F71882FG_REG_POINT_MAPPING(nr));
1371         if (val)
1372                 val = data->pwm_auto_point_mapping[nr] | (1 << 4);
1373         else
1374                 val = data->pwm_auto_point_mapping[nr] & (~(1 << 4));
1375         f71882fg_write8(data, F71882FG_REG_POINT_MAPPING(nr), val);
1376         data->pwm_auto_point_mapping[nr] = val;
1377         mutex_unlock(&data->update_lock);
1378
1379         return count;
1380 }
1381
1382 static ssize_t show_pwm_auto_point_channel(struct device *dev,
1383                                            struct device_attribute *devattr,
1384                                            char *buf)
1385 {
1386         int result;
1387         struct f71882fg_data *data = f71882fg_update_device(dev);
1388         int nr = to_sensor_dev_attr_2(devattr)->index;
1389
1390         result = 1 << ((data->pwm_auto_point_mapping[nr] & 3) - 1);
1391
1392         return sprintf(buf, "%d\n", result);
1393 }
1394
1395 static ssize_t store_pwm_auto_point_channel(struct device *dev,
1396                                             struct device_attribute *devattr,
1397                                             const char *buf, size_t count)
1398 {
1399         struct f71882fg_data *data = dev_get_drvdata(dev);
1400         int nr = to_sensor_dev_attr_2(devattr)->index;
1401         long val = simple_strtol(buf, NULL, 10);
1402         switch (val) {
1403         case 1:
1404                 val = 1;
1405                 break;
1406         case 2:
1407                 val = 2;
1408                 break;
1409         case 4:
1410                 val = 3;
1411                 break;
1412         default:
1413                 return -EINVAL;
1414         }
1415         mutex_lock(&data->update_lock);
1416         data->pwm_auto_point_mapping[nr] =
1417                 f71882fg_read8(data, F71882FG_REG_POINT_MAPPING(nr));
1418         val = (data->pwm_auto_point_mapping[nr] & 0xfc) | val;
1419         f71882fg_write8(data, F71882FG_REG_POINT_MAPPING(nr), val);
1420         data->pwm_auto_point_mapping[nr] = val;
1421         mutex_unlock(&data->update_lock);
1422
1423         return count;
1424 }
1425
1426 static ssize_t show_pwm_auto_point_temp(struct device *dev,
1427                                         struct device_attribute *devattr,
1428                                         char *buf)
1429 {
1430         int result;
1431         struct f71882fg_data *data = f71882fg_update_device(dev);
1432         int pwm = to_sensor_dev_attr_2(devattr)->index;
1433         int point = to_sensor_dev_attr_2(devattr)->nr;
1434
1435         result = data->pwm_auto_point_temp[pwm][point];
1436         return sprintf(buf, "%d\n", 1000 * result);
1437 }
1438
1439 static ssize_t store_pwm_auto_point_temp(struct device *dev,
1440                                          struct device_attribute *devattr,
1441                                          const char *buf, size_t count)
1442 {
1443         struct f71882fg_data *data = dev_get_drvdata(dev);
1444         int pwm = to_sensor_dev_attr_2(devattr)->index;
1445         int point = to_sensor_dev_attr_2(devattr)->nr;
1446         long val = simple_strtol(buf, NULL, 10) / 1000;
1447         val = SENSORS_LIMIT(val, 0, 255);
1448
1449         mutex_lock(&data->update_lock);
1450         f71882fg_write8(data, F71882FG_REG_POINT_TEMP(pwm, point), val);
1451         data->pwm_auto_point_temp[pwm][point] = val;
1452         mutex_unlock(&data->update_lock);
1453
1454         return count;
1455 }
1456
1457 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
1458         char *buf)
1459 {
1460         struct f71882fg_data *data = dev_get_drvdata(dev);
1461         return sprintf(buf, "%s\n", f71882fg_names[data->type]);
1462 }
1463
1464 static int __devinit f71882fg_create_sysfs_files(struct platform_device *pdev,
1465         struct sensor_device_attribute_2 *attr, int count)
1466 {
1467         int err, i;
1468
1469         for (i = 0; i < count; i++) {
1470                 err = device_create_file(&pdev->dev, &attr[i].dev_attr);
1471                 if (err)
1472                         return err;
1473         }
1474         return 0;
1475 }
1476
1477 static int __devinit f71882fg_probe(struct platform_device *pdev)
1478 {
1479         struct f71882fg_data *data;
1480         struct f71882fg_sio_data *sio_data = pdev->dev.platform_data;
1481         int err;
1482         u8 start_reg;
1483
1484         data = kzalloc(sizeof(struct f71882fg_data), GFP_KERNEL);
1485         if (!data)
1486                 return -ENOMEM;
1487
1488         data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
1489         data->type = sio_data->type;
1490         mutex_init(&data->update_lock);
1491         platform_set_drvdata(pdev, data);
1492
1493         start_reg = f71882fg_read8(data, F71882FG_REG_START);
1494         if (start_reg & 0x04) {
1495                 dev_warn(&pdev->dev, "Hardware monitor is powered down\n");
1496                 err = -ENODEV;
1497                 goto exit_free;
1498         }
1499         if (!(start_reg & 0x03)) {
1500                 dev_warn(&pdev->dev, "Hardware monitoring not activated\n");
1501                 err = -ENODEV;
1502                 goto exit_free;
1503         }
1504
1505         /* If it is a 71862 and the fan / pwm part is enabled sanity check
1506            the pwm settings */
1507         if (data->type == f71862fg && (start_reg & 0x02)) {
1508                 u8 reg = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1509                 if ((reg & 0x15) != 0x15) {
1510                         dev_err(&pdev->dev,
1511                                 "Invalid (reserved) pwm settings: 0x%02x\n",
1512                                 (unsigned int)reg);
1513                         err = -ENODEV;
1514                         goto exit_free;
1515                 }
1516         }
1517
1518         /* Register sysfs interface files */
1519         err = device_create_file(&pdev->dev, &dev_attr_name);
1520         if (err)
1521                 goto exit_unregister_sysfs;
1522
1523         if (start_reg & 0x01) {
1524                 err = f71882fg_create_sysfs_files(pdev, f718x2fg_in_temp_attr,
1525                                         ARRAY_SIZE(f718x2fg_in_temp_attr));
1526                 if (err)
1527                         goto exit_unregister_sysfs;
1528
1529                 if (data->type == f71882fg) {
1530                         err = f71882fg_create_sysfs_files(pdev,
1531                                         f71882fg_in_temp_attr,
1532                                         ARRAY_SIZE(f71882fg_in_temp_attr));
1533                         if (err)
1534                                 goto exit_unregister_sysfs;
1535                 }
1536         }
1537
1538         if (start_reg & 0x02) {
1539                 err = f71882fg_create_sysfs_files(pdev, f718x2fg_fan_attr,
1540                                         ARRAY_SIZE(f718x2fg_fan_attr));
1541                 if (err)
1542                         goto exit_unregister_sysfs;
1543
1544                 if (data->type == f71862fg) {
1545                         err = f71882fg_create_sysfs_files(pdev,
1546                                         f71862fg_fan_attr,
1547                                         ARRAY_SIZE(f71862fg_fan_attr));
1548                 } else {
1549                         err = f71882fg_create_sysfs_files(pdev,
1550                                         f71882fg_fan_attr,
1551                                         ARRAY_SIZE(f71882fg_fan_attr));
1552                 }
1553                 if (err)
1554                         goto exit_unregister_sysfs;
1555         }
1556
1557         data->hwmon_dev = hwmon_device_register(&pdev->dev);
1558         if (IS_ERR(data->hwmon_dev)) {
1559                 err = PTR_ERR(data->hwmon_dev);
1560                 data->hwmon_dev = NULL;
1561                 goto exit_unregister_sysfs;
1562         }
1563
1564         return 0;
1565
1566 exit_unregister_sysfs:
1567         f71882fg_remove(pdev); /* Will unregister the sysfs files for us */
1568         return err; /* f71882fg_remove() also frees our data */
1569 exit_free:
1570         kfree(data);
1571         return err;
1572 }
1573
1574 static int f71882fg_remove(struct platform_device *pdev)
1575 {
1576         int i;
1577         struct f71882fg_data *data = platform_get_drvdata(pdev);
1578
1579         platform_set_drvdata(pdev, NULL);
1580         if (data->hwmon_dev)
1581                 hwmon_device_unregister(data->hwmon_dev);
1582
1583         device_remove_file(&pdev->dev, &dev_attr_name);
1584
1585         for (i = 0; i < ARRAY_SIZE(f718x2fg_in_temp_attr); i++)
1586                 device_remove_file(&pdev->dev,
1587                                         &f718x2fg_in_temp_attr[i].dev_attr);
1588
1589         for (i = 0; i < ARRAY_SIZE(f71882fg_in_temp_attr); i++)
1590                 device_remove_file(&pdev->dev,
1591                                         &f71882fg_in_temp_attr[i].dev_attr);
1592
1593         for (i = 0; i < ARRAY_SIZE(f718x2fg_fan_attr); i++)
1594                 device_remove_file(&pdev->dev, &f718x2fg_fan_attr[i].dev_attr);
1595
1596         for (i = 0; i < ARRAY_SIZE(f71862fg_fan_attr); i++)
1597                 device_remove_file(&pdev->dev, &f71862fg_fan_attr[i].dev_attr);
1598
1599         for (i = 0; i < ARRAY_SIZE(f71882fg_fan_attr); i++)
1600                 device_remove_file(&pdev->dev, &f71882fg_fan_attr[i].dev_attr);
1601
1602         kfree(data);
1603
1604         return 0;
1605 }
1606
1607 static int __init f71882fg_find(int sioaddr, unsigned short *address,
1608         struct f71882fg_sio_data *sio_data)
1609 {
1610         int err = -ENODEV;
1611         u16 devid;
1612
1613         superio_enter(sioaddr);
1614
1615         devid = superio_inw(sioaddr, SIO_REG_MANID);
1616         if (devid != SIO_FINTEK_ID) {
1617                 printk(KERN_INFO DRVNAME ": Not a Fintek device\n");
1618                 goto exit;
1619         }
1620
1621         devid = force_id ? force_id : superio_inw(sioaddr, SIO_REG_DEVID);
1622         switch (devid) {
1623         case SIO_F71862_ID:
1624                 sio_data->type = f71862fg;
1625                 break;
1626         case SIO_F71882_ID:
1627                 sio_data->type = f71882fg;
1628                 break;
1629         default:
1630                 printk(KERN_INFO DRVNAME ": Unsupported Fintek device\n");
1631                 goto exit;
1632         }
1633
1634         superio_select(sioaddr, SIO_F71882FG_LD_HWM);
1635         if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
1636                 printk(KERN_WARNING DRVNAME ": Device not activated\n");
1637                 goto exit;
1638         }
1639
1640         *address = superio_inw(sioaddr, SIO_REG_ADDR);
1641         if (*address == 0)
1642         {
1643                 printk(KERN_WARNING DRVNAME ": Base address not set\n");
1644                 goto exit;
1645         }
1646         *address &= ~(REGION_LENGTH - 1);       /* Ignore 3 LSB */
1647
1648         err = 0;
1649         printk(KERN_INFO DRVNAME ": Found %s chip at %#x, revision %d\n",
1650                 f71882fg_names[sio_data->type], (unsigned int)*address,
1651                 (int)superio_inb(sioaddr, SIO_REG_DEVREV));
1652 exit:
1653         superio_exit(sioaddr);
1654         return err;
1655 }
1656
1657 static int __init f71882fg_device_add(unsigned short address,
1658         const struct f71882fg_sio_data *sio_data)
1659 {
1660         struct resource res = {
1661                 .start  = address,
1662                 .end    = address + REGION_LENGTH - 1,
1663                 .flags  = IORESOURCE_IO,
1664         };
1665         int err;
1666
1667         f71882fg_pdev = platform_device_alloc(DRVNAME, address);
1668         if (!f71882fg_pdev)
1669                 return -ENOMEM;
1670
1671         res.name = f71882fg_pdev->name;
1672         err = platform_device_add_resources(f71882fg_pdev, &res, 1);
1673         if (err) {
1674                 printk(KERN_ERR DRVNAME ": Device resource addition failed\n");
1675                 goto exit_device_put;
1676         }
1677
1678         err = platform_device_add_data(f71882fg_pdev, sio_data,
1679                                        sizeof(struct f71882fg_sio_data));
1680         if (err) {
1681                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1682                 goto exit_device_put;
1683         }
1684
1685         err = platform_device_add(f71882fg_pdev);
1686         if (err) {
1687                 printk(KERN_ERR DRVNAME ": Device addition failed\n");
1688                 goto exit_device_put;
1689         }
1690
1691         return 0;
1692
1693 exit_device_put:
1694         platform_device_put(f71882fg_pdev);
1695
1696         return err;
1697 }
1698
1699 static int __init f71882fg_init(void)
1700 {
1701         int err = -ENODEV;
1702         unsigned short address;
1703         struct f71882fg_sio_data sio_data;
1704
1705         memset(&sio_data, 0, sizeof(sio_data));
1706
1707         if (f71882fg_find(0x2e, &address, &sio_data) &&
1708             f71882fg_find(0x4e, &address, &sio_data))
1709                 goto exit;
1710
1711         err = platform_driver_register(&f71882fg_driver);
1712         if (err)
1713                 goto exit;
1714
1715         err = f71882fg_device_add(address, &sio_data);
1716         if (err)
1717                 goto exit_driver;
1718
1719         return 0;
1720
1721 exit_driver:
1722         platform_driver_unregister(&f71882fg_driver);
1723 exit:
1724         return err;
1725 }
1726
1727 static void __exit f71882fg_exit(void)
1728 {
1729         platform_device_unregister(f71882fg_pdev);
1730         platform_driver_unregister(&f71882fg_driver);
1731 }
1732
1733 MODULE_DESCRIPTION("F71882FG Hardware Monitoring Driver");
1734 MODULE_AUTHOR("Hans Edgington, Hans de Goede (hdegoede@redhat.com)");
1735 MODULE_LICENSE("GPL");
1736
1737 module_init(f71882fg_init);
1738 module_exit(f71882fg_exit);