drivers/hwmon/w83627ehf.c

   1 /*
   2     w83627ehf - Driver for the hardware monitoring functionality of
   3                 the Winbond W83627EHF Super-I/O chip
   4     Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
   5     Copyright (C) 2006  Yuan Mu (Winbond),
   6                         Rudolf Marek <r.marek@assembler.cz>
   7                         David Hubbard <david.c.hubbard@gmail.com>
   8                         Daniel J Blueman <daniel.blueman@gmail.com>
   9     Copyright (C) 2010  Sheng-Yuan Huang (Nuvoton) (PS00)
  10
  11     Shamelessly ripped from the w83627hf driver
  12     Copyright (C) 2003  Mark Studebaker
  13
  14     Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
  15     in testing and debugging this driver.
  16
  17     This driver also supports the W83627EHG, which is the lead-free
  18     version of the W83627EHF.
  19
  20     This program is free software; you can redistribute it and/or modify
  21     it under the terms of the GNU General Public License as published by
  22     the Free Software Foundation; either version 2 of the License, or
  23     (at your option) any later version.
  24
  25     This program is distributed in the hope that it will be useful,
  26     but WITHOUT ANY WARRANTY; without even the implied warranty of
  27     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28     GNU General Public License for more details.
  29
  30     You should have received a copy of the GNU General Public License
  31     along with this program; if not, write to the Free Software
  32     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  33
  34
  35     Supports the following chips:
  36
  37     Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
  38     w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
  39                                                0x8860 0xa1
  40     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
  41     w83627dhg-p  9      5       4       3      0xb070 0xc1    0x5ca3
  42     w83667hg     9      5       3       3      0xa510 0xc1    0x5ca3
  43     w83667hg-b   9      5       3       4      0xb350 0xc1    0x5ca3
  44     nct6775f     9      4       3       9      0xb470 0xc1    0x5ca3
  45     nct6776f     9      5       3       9      0xC330 0xc1    0x5ca3
  46 */
  47
  48 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  49
  50 #include <linux/module.h>
  51 #include <linux/init.h>
  52 #include <linux/slab.h>
  53 #include <linux/jiffies.h>
  54 #include <linux/platform_device.h>
  55 #include <linux/hwmon.h>
  56 #include <linux/hwmon-sysfs.h>
  57 #include <linux/hwmon-vid.h>
  58 #include <linux/err.h>
  59 #include <linux/mutex.h>
  60 #include <linux/acpi.h>
  61 #include <linux/io.h>
  62 #include "lm75.h"
  63
  64 enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b, nct6775,
  65         nct6776 };
  66
  67 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
  68 static const char * const w83627ehf_device_names[] = {
  69         "w83627ehf",
  70         "w83627dhg",
  71         "w83627dhg",
  72         "w83667hg",
  73         "w83667hg",
  74         "nct6775",
  75         "nct6776",
  76 };
  77
  78 static unsigned short force_id;
  79 module_param(force_id, ushort, 0);
  80 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  81
  82 static unsigned short fan_debounce;
  83 module_param(fan_debounce, ushort, 0);
  84 MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
  85
  86 #define DRVNAME "w83627ehf"
  87
  88 /*
  89  * Super-I/O constants and functions
  90  */
  91
  92 #define W83627EHF_LD_HWM        0x0b
  93 #define W83667HG_LD_VID         0x0d
  94
  95 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  96 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  97 #define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
  98 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  99 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
 100 #define SIO_REG_VID_CTRL        0xF0    /* VID control */
 101 #define SIO_REG_VID_DATA        0xF1    /* VID data */
 102
 103 #define SIO_W83627EHF_ID        0x8850
 104 #define SIO_W83627EHG_ID        0x8860
 105 #define SIO_W83627DHG_ID        0xa020
 106 #define SIO_W83627DHG_P_ID      0xb070
 107 #define SIO_W83667HG_ID         0xa510
 108 #define SIO_W83667HG_B_ID       0xb350
 109 #define SIO_NCT6775_ID          0xb470
 110 #define SIO_NCT6776_ID          0xc330
 111 #define SIO_ID_MASK             0xFFF0
 112
 113 static inline void
 114 superio_outb(int ioreg, int reg, int val)
 115 {
 116         outb(reg, ioreg);
 117         outb(val, ioreg + 1);
 118 }
 119
 120 static inline int
 121 superio_inb(int ioreg, int reg)
 122 {
 123         outb(reg, ioreg);
 124         return inb(ioreg + 1);
 125 }
 126
 127 static inline void
 128 superio_select(int ioreg, int ld)
 129 {
 130         outb(SIO_REG_LDSEL, ioreg);
 131         outb(ld, ioreg + 1);
 132 }
 133
 134 static inline void
 135 superio_enter(int ioreg)
 136 {
 137         outb(0x87, ioreg);
 138         outb(0x87, ioreg);
 139 }
 140
 141 static inline void
 142 superio_exit(int ioreg)
 143 {
 144         outb(0xaa, ioreg);
 145         outb(0x02, ioreg);
 146         outb(0x02, ioreg + 1);
 147 }
 148
 149 /*
 150  * ISA constants
 151  */
 152
 153 #define IOREGION_ALIGNMENT      (~7)
 154 #define IOREGION_OFFSET         5
 155 #define IOREGION_LENGTH         2
 156 #define ADDR_REG_OFFSET         0
 157 #define DATA_REG_OFFSET         1
 158
 159 #define W83627EHF_REG_BANK              0x4E
 160 #define W83627EHF_REG_CONFIG            0x40
 161
 162 /* Not currently used:
 163  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
 164  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
 165  * REG_MAN_ID is at port 0x4f
 166  * REG_CHIP_ID is at port 0x58 */
 167
 168 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
 169 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
 170
 171 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
 172 #define W83627EHF_REG_IN_MAX(nr)        ((nr < 7) ? (0x2b + (nr) * 2) : \
 173                                          (0x554 + (((nr) - 7) * 2)))
 174 #define W83627EHF_REG_IN_MIN(nr)        ((nr < 7) ? (0x2c + (nr) * 2) : \
 175                                          (0x555 + (((nr) - 7) * 2)))
 176 #define W83627EHF_REG_IN(nr)            ((nr < 7) ? (0x20 + (nr)) : \
 177                                          (0x550 + (nr) - 7))
 178
 179 static const u16 W83627EHF_REG_TEMP[] = { 0x27, 0x150, 0x250, 0x7e };
 180 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x3a, 0x153, 0x253, 0 };
 181 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x39, 0x155, 0x255, 0 };
 182 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0, 0x152, 0x252, 0 };
 183
 184 /* Fan clock dividers are spread over the following five registers */
 185 #define W83627EHF_REG_FANDIV1           0x47
 186 #define W83627EHF_REG_FANDIV2           0x4B
 187 #define W83627EHF_REG_VBAT              0x5D
 188 #define W83627EHF_REG_DIODE             0x59
 189 #define W83627EHF_REG_SMI_OVT           0x4C
 190
 191 /* NCT6775F has its own fan divider registers */
 192 #define NCT6775_REG_FANDIV1             0x506
 193 #define NCT6775_REG_FANDIV2             0x507
 194 #define NCT6775_REG_FAN_DEBOUNCE        0xf0
 195
 196 #define W83627EHF_REG_ALARM1            0x459
 197 #define W83627EHF_REG_ALARM2            0x45A
 198 #define W83627EHF_REG_ALARM3            0x45B
 199
 200 /* SmartFan registers */
 201 #define W83627EHF_REG_FAN_STEPUP_TIME 0x0f
 202 #define W83627EHF_REG_FAN_STEPDOWN_TIME 0x0e
 203
 204 /* DC or PWM output fan configuration */
 205 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
 206         0x04,                   /* SYS FAN0 output mode and PWM mode */
 207         0x04,                   /* CPU FAN0 output mode and PWM mode */
 208         0x12,                   /* AUX FAN mode */
 209         0x62,                   /* CPU FAN1 mode */
 210 };
 211
 212 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
 213 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
 214
 215 /* FAN Duty Cycle, be used to control */
 216 static const u16 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
 217 static const u16 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
 218 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
 219
 220 /* Advanced Fan control, some values are common for all fans */
 221 static const u16 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
 222 static const u16 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
 223 static const u16 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
 224
 225 static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
 226                                                 = { 0xff, 0x67, 0xff, 0x69 };
 227 static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
 228                                                 = { 0xff, 0x68, 0xff, 0x6a };
 229
 230 static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
 231 static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[]
 232                                                 = { 0x68, 0x6a, 0x6c };
 233
 234 static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301 };
 235 static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302 };
 236 static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = { 0x105, 0x205, 0x305 };
 237 static const u16 NCT6775_REG_FAN_START_OUTPUT[] = { 0x106, 0x206, 0x306 };
 238 static const u16 NCT6775_REG_FAN_STOP_TIME[] = { 0x107, 0x207, 0x307 };
 239 static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309 };
 240 static const u16 NCT6775_REG_FAN_MAX_OUTPUT[] = { 0x10a, 0x20a, 0x30a };
 241 static const u16 NCT6775_REG_FAN_STEP_OUTPUT[] = { 0x10b, 0x20b, 0x30b };
 242 static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
 243 static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
 244
 245 static const u16 NCT6775_REG_TEMP[]
 246         = { 0x27, 0x150, 0x250, 0x73, 0x75, 0x77, 0x62b, 0x62c, 0x62d };
 247 static const u16 NCT6775_REG_TEMP_CONFIG[]
 248         = { 0, 0x152, 0x252, 0, 0, 0, 0x628, 0x629, 0x62A };
 249 static const u16 NCT6775_REG_TEMP_HYST[]
 250         = { 0x3a, 0x153, 0x253, 0, 0, 0, 0x673, 0x678, 0x67D };
 251 static const u16 NCT6775_REG_TEMP_OVER[]
 252         = { 0x39, 0x155, 0x255, 0, 0, 0, 0x672, 0x677, 0x67C };
 253 static const u16 NCT6775_REG_TEMP_SOURCE[]
 254         = { 0x621, 0x622, 0x623, 0x100, 0x200, 0x300, 0x624, 0x625, 0x626 };
 255
 256 static const char *const w83667hg_b_temp_label[] = {
 257         "SYSTIN",
 258         "CPUTIN",
 259         "AUXTIN",
 260         "AMDTSI",
 261         "PECI Agent 1",
 262         "PECI Agent 2",
 263         "PECI Agent 3",
 264         "PECI Agent 4"
 265 };
 266
 267 static const char *const nct6775_temp_label[] = {
 268         "",
 269         "SYSTIN",
 270         "CPUTIN",
 271         "AUXTIN",
 272         "AMD SB-TSI",
 273         "PECI Agent 0",
 274         "PECI Agent 1",
 275         "PECI Agent 2",
 276         "PECI Agent 3",
 277         "PECI Agent 4",
 278         "PECI Agent 5",
 279         "PECI Agent 6",
 280         "PECI Agent 7",
 281         "PCH_CHIP_CPU_MAX_TEMP",
 282         "PCH_CHIP_TEMP",
 283         "PCH_CPU_TEMP",
 284         "PCH_MCH_TEMP",
 285         "PCH_DIM0_TEMP",
 286         "PCH_DIM1_TEMP",
 287         "PCH_DIM2_TEMP",
 288         "PCH_DIM3_TEMP"
 289 };
 290
 291 static const char *const nct6776_temp_label[] = {
 292         "",
 293         "SYSTIN",
 294         "CPUTIN",
 295         "AUXTIN",
 296         "SMBUSMASTER 0",
 297         "SMBUSMASTER 1",
 298         "SMBUSMASTER 2",
 299         "SMBUSMASTER 3",
 300         "SMBUSMASTER 4",
 301         "SMBUSMASTER 5",
 302         "SMBUSMASTER 6",
 303         "SMBUSMASTER 7",
 304         "PECI Agent 0",
 305         "PECI Agent 1",
 306         "PCH_CHIP_CPU_MAX_TEMP",
 307         "PCH_CHIP_TEMP",
 308         "PCH_CPU_TEMP",
 309         "PCH_MCH_TEMP",
 310         "PCH_DIM0_TEMP",
 311         "PCH_DIM1_TEMP",
 312         "PCH_DIM2_TEMP",
 313         "PCH_DIM3_TEMP",
 314         "BYTE_TEMP"
 315 };
 316
 317 #define NUM_REG_TEMP    ARRAY_SIZE(NCT6775_REG_TEMP)
 318
 319 static inline int is_word_sized(u16 reg)
 320 {
 321         return ((((reg & 0xff00) == 0x100
 322               || (reg & 0xff00) == 0x200)
 323              && ((reg & 0x00ff) == 0x50
 324               || (reg & 0x00ff) == 0x53
 325               || (reg & 0x00ff) == 0x55))
 326              || (reg & 0xfff0) == 0x630
 327              || reg == 0x640 || reg == 0x642
 328              || ((reg & 0xfff0) == 0x650
 329                  && (reg & 0x000f) >= 0x06)
 330              || reg == 0x73 || reg == 0x75 || reg == 0x77
 331                 );
 332 }
 333
 334 /*
 335  * Conversions
 336  */
 337
 338 /* 1 is PWM mode, output in ms */
 339 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
 340 {
 341         return mode ? 100 * reg : 400 * reg;
 342 }
 343
 344 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
 345 {
 346         return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
 347                                                 (msec + 200) / 400), 1, 255);
 348 }
 349
 350 static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
 351 {
 352         if (reg == 0 || reg == 255)
 353                 return 0;
 354         return 1350000U / (reg << divreg);
 355 }
 356
 357 static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
 358 {
 359         if ((reg & 0xff1f) == 0xff1f)
 360                 return 0;
 361
 362         reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
 363
 364         if (reg == 0)
 365                 return 0;
 366
 367         return 1350000U / reg;
 368 }
 369
 370 static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
 371 {
 372         if (reg == 0 || reg == 0xffff)
 373                 return 0;
 374
 375         /*
 376          * Even though the registers are 16 bit wide, the fan divisor
 377          * still applies.
 378          */
 379         return 1350000U / (reg << divreg);
 380 }
 381
 382 static inline unsigned int
 383 div_from_reg(u8 reg)
 384 {
 385         return 1 << reg;
 386 }
 387
 388 static inline int
 389 temp_from_reg(u16 reg, s16 regval)
 390 {
 391         if (is_word_sized(reg))
 392                 return LM75_TEMP_FROM_REG(regval);
 393         return ((s8)regval) * 1000;
 394 }
 395
 396 static inline u16
 397 temp_to_reg(u16 reg, long temp)
 398 {
 399         if (is_word_sized(reg))
 400                 return LM75_TEMP_TO_REG(temp);
 401         return (s8)DIV_ROUND_CLOSEST(SENSORS_LIMIT(temp, -127000, 128000),
 402                                      1000);
 403 }
 404
 405 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
 406
 407 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
 408
 409 static inline long in_from_reg(u8 reg, u8 nr)
 410 {
 411         return reg * scale_in[nr];
 412 }
 413
 414 static inline u8 in_to_reg(u32 val, u8 nr)
 415 {
 416         return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0,
 417                              255);
 418 }
 419
 420 /*
 421  * Data structures and manipulation thereof
 422  */
 423
 424 struct w83627ehf_data {
 425         int addr;       /* IO base of hw monitor block */
 426         const char *name;
 427
 428         struct device *hwmon_dev;
 429         struct mutex lock;
 430
 431         u16 reg_temp[NUM_REG_TEMP];
 432         u16 reg_temp_over[NUM_REG_TEMP];
 433         u16 reg_temp_hyst[NUM_REG_TEMP];
 434         u16 reg_temp_config[NUM_REG_TEMP];
 435         u8 temp_src[NUM_REG_TEMP];
 436         const char * const *temp_label;
 437
 438         const u16 *REG_PWM;
 439         const u16 *REG_TARGET;
 440         const u16 *REG_FAN;
 441         const u16 *REG_FAN_MIN;
 442         const u16 *REG_FAN_START_OUTPUT;
 443         const u16 *REG_FAN_STOP_OUTPUT;
 444         const u16 *REG_FAN_STOP_TIME;
 445         const u16 *REG_FAN_MAX_OUTPUT;
 446         const u16 *REG_FAN_STEP_OUTPUT;
 447
 448         unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
 449         unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
 450
 451         struct mutex update_lock;
 452         char valid;             /* !=0 if following fields are valid */
 453         unsigned long last_updated;     /* In jiffies */
 454
 455         /* Register values */
 456         u8 bank;                /* current register bank */
 457         u8 in_num;              /* number of in inputs we have */
 458         u8 in[10];              /* Register value */
 459         u8 in_max[10];          /* Register value */
 460         u8 in_min[10];          /* Register value */
 461         unsigned int rpm[5];
 462         u16 fan_min[5];
 463         u8 fan_div[5];
 464         u8 has_fan;             /* some fan inputs can be disabled */
 465         u8 has_fan_min;         /* some fans don't have min register */
 466         bool has_fan_div;
 467         u8 temp_type[3];
 468         s16 temp[9];
 469         s16 temp_max[9];
 470         s16 temp_max_hyst[9];
 471         u32 alarms;
 472
 473         u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
 474         u8 pwm_enable[4]; /* 1->manual
 475                              2->thermal cruise mode (also called SmartFan I)
 476                              3->fan speed cruise mode
 477                              4->variable thermal cruise (also called
 478                                 SmartFan III)
 479                              5->enhanced variable thermal cruise (also called
 480                                 SmartFan IV) */
 481         u8 pwm_enable_orig[4];  /* original value of pwm_enable */
 482         u8 pwm_num;             /* number of pwm */
 483         u8 pwm[4];
 484         u8 target_temp[4];
 485         u8 tolerance[4];
 486
 487         u8 fan_start_output[4]; /* minimum fan speed when spinning up */
 488         u8 fan_stop_output[4]; /* minimum fan speed when spinning down */
 489         u8 fan_stop_time[4]; /* time at minimum before disabling fan */
 490         u8 fan_max_output[4]; /* maximum fan speed */
 491         u8 fan_step_output[4]; /* rate of change output value */
 492
 493         u8 vid;
 494         u8 vrm;
 495
 496         u16 have_temp;
 497         u8 in6_skip;
 498 };
 499
 500 struct w83627ehf_sio_data {
 501         int sioreg;
 502         enum kinds kind;
 503 };
 504
 505 /*
 506  * On older chips, only registers 0x50-0x5f are banked.
 507  * On more recent chips, all registers are banked.
 508  * Assume that is the case and set the bank number for each access.
 509  * Cache the bank number so it only needs to be set if it changes.
 510  */
 511 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
 512 {
 513         u8 bank = reg >> 8;
 514         if (data->bank != bank) {
 515                 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
 516                 outb_p(bank, data->addr + DATA_REG_OFFSET);
 517                 data->bank = bank;
 518         }
 519 }
 520
 521 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
 522 {
 523         int res, word_sized = is_word_sized(reg);
 524
 525         mutex_lock(&data->lock);
 526
 527         w83627ehf_set_bank(data, reg);
 528         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 529         res = inb_p(data->addr + DATA_REG_OFFSET);
 530         if (word_sized) {
 531                 outb_p((reg & 0xff) + 1,
 532                        data->addr + ADDR_REG_OFFSET);
 533                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
 534         }
 535
 536         mutex_unlock(&data->lock);
 537         return res;
 538 }
 539
 540 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg,
 541                                  u16 value)
 542 {
 543         int word_sized = is_word_sized(reg);
 544
 545         mutex_lock(&data->lock);
 546
 547         w83627ehf_set_bank(data, reg);
 548         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 549         if (word_sized) {
 550                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
 551                 outb_p((reg & 0xff) + 1,
 552                        data->addr + ADDR_REG_OFFSET);
 553         }
 554         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
 555
 556         mutex_unlock(&data->lock);
 557         return 0;
 558 }
 559
 560 /* This function assumes that the caller holds data->update_lock */
 561 static void nct6775_write_fan_div(struct w83627ehf_data *data, int nr)
 562 {
 563         u8 reg;
 564
 565         switch (nr) {
 566         case 0:
 567                 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
 568                     | (data->fan_div[0] & 0x7);
 569                 w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
 570                 break;
 571         case 1:
 572                 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
 573                     | ((data->fan_div[1] << 4) & 0x70);
 574                 w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
 575         case 2:
 576                 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
 577                     | (data->fan_div[2] & 0x7);
 578                 w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
 579                 break;
 580         case 3:
 581                 reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
 582                     | ((data->fan_div[3] << 4) & 0x70);
 583                 w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
 584                 break;
 585         }
 586 }
 587
 588 /* This function assumes that the caller holds data->update_lock */
 589 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
 590 {
 591         u8 reg;
 592
 593         switch (nr) {
 594         case 0:
 595                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
 596                     | ((data->fan_div[0] & 0x03) << 4);
 597                 /* fan5 input control bit is write only, compute the value */
 598                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
 599                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
 600                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
 601                     | ((data->fan_div[0] & 0x04) << 3);
 602                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 603                 break;
 604         case 1:
 605                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
 606                     | ((data->fan_div[1] & 0x03) << 6);
 607                 /* fan5 input control bit is write only, compute the value */
 608                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
 609                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
 610                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
 611                     | ((data->fan_div[1] & 0x04) << 4);
 612                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 613                 break;
 614         case 2:
 615                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
 616                     | ((data->fan_div[2] & 0x03) << 6);
 617                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
 618                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
 619                     | ((data->fan_div[2] & 0x04) << 5);
 620                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 621                 break;
 622         case 3:
 623                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
 624                     | (data->fan_div[3] & 0x03);
 625                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
 626                 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
 627                     | ((data->fan_div[3] & 0x04) << 5);
 628                 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
 629                 break;
 630         case 4:
 631                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
 632                     | ((data->fan_div[4] & 0x03) << 2)
 633                     | ((data->fan_div[4] & 0x04) << 5);
 634                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
 635                 break;
 636         }
 637 }
 638
 639 static void w83627ehf_write_fan_div_common(struct device *dev,
 640                                            struct w83627ehf_data *data, int nr)
 641 {
 642         struct w83627ehf_sio_data *sio_data = dev->platform_data;
 643
 644         if (sio_data->kind == nct6776)
 645                 ; /* no dividers, do nothing */
 646         else if (sio_data->kind == nct6775)
 647                 nct6775_write_fan_div(data, nr);
 648         else
 649                 w83627ehf_write_fan_div(data, nr);
 650 }
 651
 652 static void nct6775_update_fan_div(struct w83627ehf_data *data)
 653 {
 654         u8 i;
 655
 656         i = w83627ehf_read_value(data, NCT6775_REG_FANDIV1);
 657         data->fan_div[0] = i & 0x7;
 658         data->fan_div[1] = (i & 0x70) >> 4;
 659         i = w83627ehf_read_value(data, NCT6775_REG_FANDIV2);
 660         data->fan_div[2] = i & 0x7;
 661         if (data->has_fan & (1<<3))
 662                 data->fan_div[3] = (i & 0x70) >> 4;
 663 }
 664
 665 static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
 666 {
 667         int i;
 668
 669         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
 670         data->fan_div[0] = (i >> 4) & 0x03;
 671         data->fan_div[1] = (i >> 6) & 0x03;
 672         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
 673         data->fan_div[2] = (i >> 6) & 0x03;
 674         i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
 675         data->fan_div[0] |= (i >> 3) & 0x04;
 676         data->fan_div[1] |= (i >> 4) & 0x04;
 677         data->fan_div[2] |= (i >> 5) & 0x04;
 678         if (data->has_fan & ((1 << 3) | (1 << 4))) {
 679                 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
 680                 data->fan_div[3] = i & 0x03;
 681                 data->fan_div[4] = ((i >> 2) & 0x03)
 682                                  | ((i >> 5) & 0x04);
 683         }
 684         if (data->has_fan & (1 << 3)) {
 685                 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
 686                 data->fan_div[3] |= (i >> 5) & 0x04;
 687         }
 688 }
 689
 690 static void w83627ehf_update_fan_div_common(struct device *dev,
 691                                             struct w83627ehf_data *data)
 692 {
 693         struct w83627ehf_sio_data *sio_data = dev->platform_data;
 694
 695         if (sio_data->kind == nct6776)
 696                 ; /* no dividers, do nothing */
 697         else if (sio_data->kind == nct6775)
 698                 nct6775_update_fan_div(data);
 699         else
 700                 w83627ehf_update_fan_div(data);
 701 }
 702
 703 static void nct6775_update_pwm(struct w83627ehf_data *data)
 704 {
 705         int i;
 706         int pwmcfg, fanmodecfg;
 707
 708         for (i = 0; i < data->pwm_num; i++) {
 709                 pwmcfg = w83627ehf_read_value(data,
 710                                               W83627EHF_REG_PWM_ENABLE[i]);
 711                 fanmodecfg = w83627ehf_read_value(data,
 712                                                   NCT6775_REG_FAN_MODE[i]);
 713                 data->pwm_mode[i] =
 714                   ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
 715                 data->pwm_enable[i] = ((fanmodecfg >> 4) & 7) + 1;
 716                 data->tolerance[i] = fanmodecfg & 0x0f;
 717                 data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
 718         }
 719 }
 720
 721 static void w83627ehf_update_pwm(struct w83627ehf_data *data)
 722 {
 723         int i;
 724         int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
 725
 726         for (i = 0; i < data->pwm_num; i++) {
 727                 if (!(data->has_fan & (1 << i)))
 728                         continue;
 729
 730                 /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
 731                 if (i != 1) {
 732                         pwmcfg = w83627ehf_read_value(data,
 733                                         W83627EHF_REG_PWM_ENABLE[i]);
 734                         tolerance = w83627ehf_read_value(data,
 735                                         W83627EHF_REG_TOLERANCE[i]);
 736                 }
 737                 data->pwm_mode[i] =
 738                         ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
 739                 data->pwm_enable[i] = ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
 740                                        & 3) + 1;
 741                 data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
 742
 743                 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0)) & 0x0f;
 744         }
 745 }
 746
 747 static void w83627ehf_update_pwm_common(struct device *dev,
 748                                         struct w83627ehf_data *data)
 749 {
 750         struct w83627ehf_sio_data *sio_data = dev->platform_data;
 751
 752         if (sio_data->kind == nct6775 || sio_data->kind == nct6776)
 753                 nct6775_update_pwm(data);
 754         else
 755                 w83627ehf_update_pwm(data);
 756 }
 757
 758 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
 759 {
 760         struct w83627ehf_data *data = dev_get_drvdata(dev);
 761         struct w83627ehf_sio_data *sio_data = dev->platform_data;
 762
 763         int i;
 764
 765         mutex_lock(&data->update_lock);
 766
 767         if (time_after(jiffies, data->last_updated + HZ + HZ/2)
 768          || !data->valid) {
 769                 /* Fan clock dividers */
 770                 w83627ehf_update_fan_div_common(dev, data);
 771
 772                 /* Measured voltages and limits */
 773                 for (i = 0; i < data->in_num; i++) {
 774                         data->in[i] = w83627ehf_read_value(data,
 775                                       W83627EHF_REG_IN(i));
 776                         data->in_min[i] = w83627ehf_read_value(data,
 777                                           W83627EHF_REG_IN_MIN(i));
 778                         data->in_max[i] = w83627ehf_read_value(data,
 779                                           W83627EHF_REG_IN_MAX(i));
 780                 }
 781
 782                 /* Measured fan speeds and limits */
 783                 for (i = 0; i < 5; i++) {
 784                         u16 reg;
 785
 786                         if (!(data->has_fan & (1 << i)))
 787                                 continue;
 788
 789                         reg = w83627ehf_read_value(data, data->REG_FAN[i]);
 790                         data->rpm[i] = data->fan_from_reg(reg,
 791                                                           data->fan_div[i]);
 792
 793                         if (data->has_fan_min & (1 << i))
 794                                 data->fan_min[i] = w83627ehf_read_value(data,
 795                                            data->REG_FAN_MIN[i]);
 796
 797                         /* If we failed to measure the fan speed and clock
 798                            divider can be increased, let's try that for next
 799                            time */
 800                         if (data->has_fan_div
 801                             && (reg >= 0xff || (sio_data->kind == nct6775
 802                                                 && reg == 0x00))
 803                             && data->fan_div[i] < 0x07) {
 804                                 dev_dbg(dev, "Increasing fan%d "
 805                                         "clock divider from %u to %u\n",
 806                                         i + 1, div_from_reg(data->fan_div[i]),
 807                                         div_from_reg(data->fan_div[i] + 1));
 808                                 data->fan_div[i]++;
 809                                 w83627ehf_write_fan_div_common(dev, data, i);
 810                                 /* Preserve min limit if possible */
 811                                 if ((data->has_fan_min & (1 << i))
 812                                  && data->fan_min[i] >= 2
 813                                  && data->fan_min[i] != 255)
 814                                         w83627ehf_write_value(data,
 815                                                 data->REG_FAN_MIN[i],
 816                                                 (data->fan_min[i] /= 2));
 817                         }
 818                 }
 819
 820                 w83627ehf_update_pwm_common(dev, data);
 821
 822                 for (i = 0; i < data->pwm_num; i++) {
 823                         if (!(data->has_fan & (1 << i)))
 824                                 continue;
 825
 826                         data->fan_start_output[i] =
 827                           w83627ehf_read_value(data,
 828                                                data->REG_FAN_START_OUTPUT[i]);
 829                         data->fan_stop_output[i] =
 830                           w83627ehf_read_value(data,
 831                                                data->REG_FAN_STOP_OUTPUT[i]);
 832                         data->fan_stop_time[i] =
 833                           w83627ehf_read_value(data,
 834                                                data->REG_FAN_STOP_TIME[i]);
 835
 836                         if (data->REG_FAN_MAX_OUTPUT &&
 837                             data->REG_FAN_MAX_OUTPUT[i] != 0xff)
 838                                 data->fan_max_output[i] =
 839                                   w83627ehf_read_value(data,
 840                                                 data->REG_FAN_MAX_OUTPUT[i]);
 841
 842                         if (data->REG_FAN_STEP_OUTPUT &&
 843                             data->REG_FAN_STEP_OUTPUT[i] != 0xff)
 844                                 data->fan_step_output[i] =
 845                                   w83627ehf_read_value(data,
 846                                                 data->REG_FAN_STEP_OUTPUT[i]);
 847
 848                         data->target_temp[i] =
 849                                 w83627ehf_read_value(data,
 850                                         data->REG_TARGET[i]) &
 851                                         (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
 852                 }
 853
 854                 /* Measured temperatures and limits */
 855                 for (i = 0; i < NUM_REG_TEMP; i++) {
 856                         if (!(data->have_temp & (1 << i)))
 857                                 continue;
 858                         data->temp[i] = w83627ehf_read_value(data,
 859                                                 data->reg_temp[i]);
 860                         if (data->reg_temp_over[i])
 861                                 data->temp_max[i]
 862                                   = w83627ehf_read_value(data,
 863                                                 data->reg_temp_over[i]);
 864                         if (data->reg_temp_hyst[i])
 865                                 data->temp_max_hyst[i]
 866                                   = w83627ehf_read_value(data,
 867                                                 data->reg_temp_hyst[i]);
 868                 }
 869
 870                 data->alarms = w83627ehf_read_value(data,
 871                                         W83627EHF_REG_ALARM1) |
 872                                (w83627ehf_read_value(data,
 873                                         W83627EHF_REG_ALARM2) << 8) |
 874                                (w83627ehf_read_value(data,
 875                                         W83627EHF_REG_ALARM3) << 16);
 876
 877                 data->last_updated = jiffies;
 878                 data->valid = 1;
 879         }
 880
 881         mutex_unlock(&data->update_lock);
 882         return data;
 883 }
 884
 885 /*
 886  * Sysfs callback functions
 887  */
 888 #define show_in_reg(reg) \
 889 static ssize_t \
 890 show_##reg(struct device *dev, struct device_attribute *attr, \
 891            char *buf) \
 892 { \
 893         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 894         struct sensor_device_attribute *sensor_attr = \
 895                 to_sensor_dev_attr(attr); \
 896         int nr = sensor_attr->index; \
 897         return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
 898 }
 899 show_in_reg(in)
 900 show_in_reg(in_min)
 901 show_in_reg(in_max)
 902
 903 #define store_in_reg(REG, reg) \
 904 static ssize_t \
 905 store_in_##reg(struct device *dev, struct device_attribute *attr, \
 906                const char *buf, size_t count) \
 907 { \
 908         struct w83627ehf_data *data = dev_get_drvdata(dev); \
 909         struct sensor_device_attribute *sensor_attr = \
 910                 to_sensor_dev_attr(attr); \
 911         int nr = sensor_attr->index; \
 912         unsigned long val; \
 913         int err; \
 914         err = strict_strtoul(buf, 10, &val); \
 915         if (err < 0) \
 916                 return err; \
 917         mutex_lock(&data->update_lock); \
 918         data->in_##reg[nr] = in_to_reg(val, nr); \
 919         w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
 920                               data->in_##reg[nr]); \
 921         mutex_unlock(&data->update_lock); \
 922         return count; \
 923 }
 924
 925 store_in_reg(MIN, min)
 926 store_in_reg(MAX, max)
 927
 928 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 929                           char *buf)
 930 {
 931         struct w83627ehf_data *data = w83627ehf_update_device(dev);
 932         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 933         int nr = sensor_attr->index;
 934         return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
 935 }
 936
 937 static struct sensor_device_attribute sda_in_input[] = {
 938         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 939         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 940         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 941         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
 942         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
 943         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
 944         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
 945         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
 946         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
 947         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
 948 };
 949
 950 static struct sensor_device_attribute sda_in_alarm[] = {
 951         SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
 952         SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
 953         SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
 954         SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
 955         SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
 956         SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
 957         SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
 958         SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
 959         SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
 960         SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
 961 };
 962
 963 static struct sensor_device_attribute sda_in_min[] = {
 964         SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 965         SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 966         SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 967         SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 968         SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 969         SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 970         SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 971         SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 972         SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 973         SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 974 };
 975
 976 static struct sensor_device_attribute sda_in_max[] = {
 977         SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 978         SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 979         SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 980         SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 981         SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 982         SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 983         SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 984         SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 985         SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 986         SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 987 };
 988
 989 static ssize_t
 990 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 991 {
 992         struct w83627ehf_data *data = w83627ehf_update_device(dev);
 993         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 994         int nr = sensor_attr->index;
 995         return sprintf(buf, "%d\n", data->rpm[nr]);
 996 }
 997
 998 static ssize_t
 999 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
1000 {
1001         struct w83627ehf_data *data = w83627ehf_update_device(dev);
1002         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1003         int nr = sensor_attr->index;
1004         return sprintf(buf, "%d\n",
1005                        data->fan_from_reg_min(data->fan_min[nr],
1006                                               data->fan_div[nr]));
1007 }
1008
1009 static ssize_t
1010 show_fan_div(struct device *dev, struct device_attribute *attr,
1011              char *buf)
1012 {
1013         struct w83627ehf_data *data = w83627ehf_update_device(dev);
1014         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1015         int nr = sensor_attr->index;
1016         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1017 }
1018
1019 static ssize_t
1020 store_fan_min(struct device *dev, struct device_attribute *attr,
1021               const char *buf, size_t count)
1022 {
1023         struct w83627ehf_data *data = dev_get_drvdata(dev);
1024         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1025         int nr = sensor_attr->index;
1026         unsigned long val;
1027         int err;
1028         unsigned int reg;
1029         u8 new_div;
1030
1031         err = strict_strtoul(buf, 10, &val);
1032         if (err < 0)
1033                 return err;
1034
1035         mutex_lock(&data->update_lock);
1036         if (!data->has_fan_div) {
1037                 /*
1038                  * Only NCT6776F for now, so we know that this is a 13 bit
1039                  * register
1040                  */
1041                 if (!val) {
1042                         val = 0xff1f;
1043                 } else {
1044                         if (val > 1350000U)
1045                                 val = 135000U;
1046                         val = 1350000U / val;
1047                         val = (val & 0x1f) | ((val << 3) & 0xff00);
1048                 }
1049                 data->fan_min[nr] = val;
1050                 goto done;      /* Leave fan divider alone */
1051         }
1052         if (!val) {
1053                 /* No min limit, alarm disabled */
1054                 data->fan_min[nr] = 255;
1055                 new_div = data->fan_div[nr]; /* No change */
1056                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
1057         } else if ((reg = 1350000U / val) >= 128 * 255) {
1058                 /* Speed below this value cannot possibly be represented,
1059                    even with the highest divider (128) */
1060                 data->fan_min[nr] = 254;
1061                 new_div = 7; /* 128 == (1 << 7) */
1062                 dev_warn(dev, "fan%u low limit %lu below minimum %u, set to "
1063                          "minimum\n", nr + 1, val,
1064                          data->fan_from_reg_min(254, 7));
1065         } else if (!reg) {
1066                 /* Speed above this value cannot possibly be represented,
1067                    even with the lowest divider (1) */
1068                 data->fan_min[nr] = 1;
1069                 new_div = 0; /* 1 == (1 << 0) */
1070                 dev_warn(dev, "fan%u low limit %lu above maximum %u, set to "
1071                          "maximum\n", nr + 1, val,
1072                          data->fan_from_reg_min(1, 0));
1073         } else {
1074                 /* Automatically pick the best divider, i.e. the one such
1075                    that the min limit will correspond to a register value
1076                    in the 96..192 range */
1077                 new_div = 0;
1078                 while (reg > 192 && new_div < 7) {
1079                         reg >>= 1;
1080                         new_div++;
1081                 }
1082                 data->fan_min[nr] = reg;
1083         }
1084
1085         /* Write both the fan clock divider (if it changed) and the new
1086            fan min (unconditionally) */
1087         if (new_div != data->fan_div[nr]) {
1088                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1089                         nr + 1, div_from_reg(data->fan_div[nr]),
1090                         div_from_reg(new_div));
1091                 data->fan_div[nr] = new_div;
1092                 w83627ehf_write_fan_div_common(dev, data, nr);
1093                 /* Give the chip time to sample a new speed value */
1094                 data->last_updated = jiffies;
1095         }
1096 done:
1097         w83627ehf_write_value(data, data->REG_FAN_MIN[nr],
1098                               data->fan_min[nr]);
1099         mutex_unlock(&data->update_lock);
1100
1101         return count;
1102 }
1103
1104 static struct sensor_device_attribute sda_fan_input[] = {
1105         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
1106         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
1107         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
1108         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
1109         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
1110 };
1111
1112 static struct sensor_device_attribute sda_fan_alarm[] = {
1113         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
1114         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
1115         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
1116         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
1117         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
1118 };
1119
1120 static struct sensor_device_attribute sda_fan_min[] = {
1121         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1122                     store_fan_min, 0),
1123         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1124                     store_fan_min, 1),
1125         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1126                     store_fan_min, 2),
1127         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1128                     store_fan_min, 3),
1129         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1130                     store_fan_min, 4),
1131 };
1132
1133 static struct sensor_device_attribute sda_fan_div[] = {
1134         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
1135         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
1136         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
1137         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
1138         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
1139 };
1140
1141 static ssize_t
1142 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
1143 {
1144         struct w83627ehf_data *data = w83627ehf_update_device(dev);
1145         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1146         int nr = sensor_attr->index;
1147         return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
1148 }
1149
1150 #define show_temp_reg(addr, reg) \
1151 static ssize_t \
1152 show_##reg(struct device *dev, struct device_attribute *attr, \
1153            char *buf) \
1154 { \
1155         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1156         struct sensor_device_attribute *sensor_attr = \
1157                 to_sensor_dev_attr(attr); \
1158         int nr = sensor_attr->index; \
1159         return sprintf(buf, "%d\n", \
1160                        temp_from_reg(data->addr[nr], data->reg[nr])); \
1161 }
1162 show_temp_reg(reg_temp, temp);
1163 show_temp_reg(reg_temp_over, temp_max);
1164 show_temp_reg(reg_temp_hyst, temp_max_hyst);
1165
1166 #define store_temp_reg(addr, reg) \
1167 static ssize_t \
1168 store_##reg(struct device *dev, struct device_attribute *attr, \
1169             const char *buf, size_t count) \
1170 { \
1171         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1172         struct sensor_device_attribute *sensor_attr = \
1173                 to_sensor_dev_attr(attr); \
1174         int nr = sensor_attr->index; \
1175         int err; \
1176         long val; \
1177         err = strict_strtol(buf, 10, &val); \
1178         if (err < 0) \
1179                 return err; \
1180         mutex_lock(&data->update_lock); \
1181         data->reg[nr] = temp_to_reg(data->addr[nr], val); \
1182         w83627ehf_write_value(data, data->addr[nr], \
1183                               data->reg[nr]); \
1184         mutex_unlock(&data->update_lock); \
1185         return count; \
1186 }
1187 store_temp_reg(reg_temp_over, temp_max);
1188 store_temp_reg(reg_temp_hyst, temp_max_hyst);
1189
1190 static ssize_t
1191 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
1192 {
1193         struct w83627ehf_data *data = w83627ehf_update_device(dev);
1194         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1195         int nr = sensor_attr->index;
1196         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
1197 }
1198
1199 static struct sensor_device_attribute sda_temp_input[] = {
1200         SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
1201         SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
1202         SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
1203         SENSOR_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3),
1204         SENSOR_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4),
1205         SENSOR_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5),
1206         SENSOR_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6),
1207         SENSOR_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7),
1208         SENSOR_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8),
1209 };
1210
1211 static struct sensor_device_attribute sda_temp_label[] = {
1212         SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
1213         SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
1214         SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
1215         SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
1216         SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
1217         SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
1218         SENSOR_ATTR(temp7_label, S_IRUGO, show_temp_label, NULL, 6),
1219         SENSOR_ATTR(temp8_label, S_IRUGO, show_temp_label, NULL, 7),
1220         SENSOR_ATTR(temp9_label, S_IRUGO, show_temp_label, NULL, 8),
1221 };
1222
1223 static struct sensor_device_attribute sda_temp_max[] = {
1224         SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
1225                     store_temp_max, 0),
1226         SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
1227                     store_temp_max, 1),
1228         SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
1229                     store_temp_max, 2),
1230         SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
1231                     store_temp_max, 3),
1232         SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR, show_temp_max,
1233                     store_temp_max, 4),
1234         SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR, show_temp_max,
1235                     store_temp_max, 5),
1236         SENSOR_ATTR(temp7_max, S_IRUGO | S_IWUSR, show_temp_max,
1237                     store_temp_max, 6),
1238         SENSOR_ATTR(temp8_max, S_IRUGO | S_IWUSR, show_temp_max,
1239                     store_temp_max, 7),
1240         SENSOR_ATTR(temp9_max, S_IRUGO | S_IWUSR, show_temp_max,
1241                     store_temp_max, 8),
1242 };
1243
1244 static struct sensor_device_attribute sda_temp_max_hyst[] = {
1245         SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1246                     store_temp_max_hyst, 0),
1247         SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1248                     store_temp_max_hyst, 1),
1249         SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1250                     store_temp_max_hyst, 2),
1251         SENSOR_ATTR(temp4_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1252                     store_temp_max_hyst, 3),
1253         SENSOR_ATTR(temp5_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1254                     store_temp_max_hyst, 4),
1255         SENSOR_ATTR(temp6_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1256                     store_temp_max_hyst, 5),
1257         SENSOR_ATTR(temp7_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1258                     store_temp_max_hyst, 6),
1259         SENSOR_ATTR(temp8_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1260                     store_temp_max_hyst, 7),
1261         SENSOR_ATTR(temp9_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
1262                     store_temp_max_hyst, 8),
1263 };
1264
1265 static struct sensor_device_attribute sda_temp_alarm[] = {
1266         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
1267         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1268         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1269 };
1270
1271 static struct sensor_device_attribute sda_temp_type[] = {
1272         SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
1273         SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
1274         SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
1275 };
1276
1277 #define show_pwm_reg(reg) \
1278 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1279                           char *buf) \
1280 { \
1281         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1282         struct sensor_device_attribute *sensor_attr = \
1283                 to_sensor_dev_attr(attr); \
1284         int nr = sensor_attr->index; \
1285         return sprintf(buf, "%d\n", data->reg[nr]); \
1286 }
1287
1288 show_pwm_reg(pwm_mode)
1289 show_pwm_reg(pwm_enable)
1290 show_pwm_reg(pwm)
1291
1292 static ssize_t
1293 store_pwm_mode(struct device *dev, struct device_attribute *attr,
1294                         const char *buf, size_t count)
1295 {
1296         struct w83627ehf_data *data = dev_get_drvdata(dev);
1297         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1298         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1299         int nr = sensor_attr->index;
1300         unsigned long val;
1301         int err;
1302         u16 reg;
1303
1304         err = strict_strtoul(buf, 10, &val);
1305         if (err < 0)
1306                 return err;
1307
1308         if (val > 1)
1309                 return -EINVAL;
1310
1311         /* On NCT67766F, DC mode is only supported for pwm1 */
1312         if (sio_data->kind == nct6776 && nr && val != 1)
1313                 return -EINVAL;
1314
1315         mutex_lock(&data->update_lock);
1316         reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1317         data->pwm_mode[nr] = val;
1318         reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
1319         if (!val)
1320                 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
1321         w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1322         mutex_unlock(&data->update_lock);
1323         return count;
1324 }
1325
1326 static ssize_t
1327 store_pwm(struct device *dev, struct device_attribute *attr,
1328                         const char *buf, size_t count)
1329 {
1330         struct w83627ehf_data *data = dev_get_drvdata(dev);
1331         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1332         int nr = sensor_attr->index;
1333         unsigned long val;
1334         int err;
1335
1336         err = strict_strtoul(buf, 10, &val);
1337         if (err < 0)
1338                 return err;
1339
1340         val = SENSORS_LIMIT(val, 0, 255);
1341
1342         mutex_lock(&data->update_lock);
1343         data->pwm[nr] = val;
1344         w83627ehf_write_value(data, data->REG_PWM[nr], val);
1345         mutex_unlock(&data->update_lock);
1346         return count;
1347 }
1348
1349 static ssize_t
1350 store_pwm_enable(struct device *dev, struct device_attribute *attr,
1351                         const char *buf, size_t count)
1352 {
1353         struct w83627ehf_data *data = dev_get_drvdata(dev);
1354         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1355         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1356         int nr = sensor_attr->index;
1357         unsigned long val;
1358         int err;
1359         u16 reg;
1360
1361         err = strict_strtoul(buf, 10, &val);
1362         if (err < 0)
1363                 return err;
1364
1365         if (!val || (val > 4 && val != data->pwm_enable_orig[nr]))
1366                 return -EINVAL;
1367         /* SmartFan III mode is not supported on NCT6776F */
1368         if (sio_data->kind == nct6776 && val == 4)
1369                 return -EINVAL;
1370
1371         mutex_lock(&data->update_lock);
1372         data->pwm_enable[nr] = val;
1373         if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1374                 reg = w83627ehf_read_value(data,
1375                                            NCT6775_REG_FAN_MODE[nr]);
1376                 reg &= 0x0f;
1377                 reg |= (val - 1) << 4;
1378                 w83627ehf_write_value(data,
1379                                       NCT6775_REG_FAN_MODE[nr], reg);
1380         } else {
1381                 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1382                 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
1383                 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
1384                 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1385         }
1386         mutex_unlock(&data->update_lock);
1387         return count;
1388 }
1389
1390
1391 #define show_tol_temp(reg) \
1392 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1393                                 char *buf) \
1394 { \
1395         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1396         struct sensor_device_attribute *sensor_attr = \
1397                 to_sensor_dev_attr(attr); \
1398         int nr = sensor_attr->index; \
1399         return sprintf(buf, "%d\n", data->reg[nr] * 1000); \
1400 }
1401
1402 show_tol_temp(tolerance)
1403 show_tol_temp(target_temp)
1404
1405 static ssize_t
1406 store_target_temp(struct device *dev, struct device_attribute *attr,
1407                         const char *buf, size_t count)
1408 {
1409         struct w83627ehf_data *data = dev_get_drvdata(dev);
1410         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1411         int nr = sensor_attr->index;
1412         long val;
1413         int err;
1414
1415         err = strict_strtol(buf, 10, &val);
1416         if (err < 0)
1417                 return err;
1418
1419         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 127);
1420
1421         mutex_lock(&data->update_lock);
1422         data->target_temp[nr] = val;
1423         w83627ehf_write_value(data, data->REG_TARGET[nr], val);
1424         mutex_unlock(&data->update_lock);
1425         return count;
1426 }
1427
1428 static ssize_t
1429 store_tolerance(struct device *dev, struct device_attribute *attr,
1430                         const char *buf, size_t count)
1431 {
1432         struct w83627ehf_data *data = dev_get_drvdata(dev);
1433         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1434         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1435         int nr = sensor_attr->index;
1436         u16 reg;
1437         long val;
1438         int err;
1439
1440         err = strict_strtol(buf, 10, &val);
1441         if (err < 0)
1442                 return err;
1443
1444         /* Limit the temp to 0C - 15C */
1445         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 15);
1446
1447         mutex_lock(&data->update_lock);
1448         if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1449                 /* Limit tolerance further for NCT6776F */
1450                 if (sio_data->kind == nct6776 && val > 7)
1451                         val = 7;
1452                 reg = w83627ehf_read_value(data, NCT6775_REG_FAN_MODE[nr]);
1453                 reg = (reg & 0xf0) | val;
1454                 w83627ehf_write_value(data, NCT6775_REG_FAN_MODE[nr], reg);
1455         } else {
1456                 reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1457                 if (nr == 1)
1458                         reg = (reg & 0x0f) | (val << 4);
1459                 else
1460                         reg = (reg & 0xf0) | val;
1461                 w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1462         }
1463         data->tolerance[nr] = val;
1464         mutex_unlock(&data->update_lock);
1465         return count;
1466 }
1467
1468 static struct sensor_device_attribute sda_pwm[] = {
1469         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
1470         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
1471         SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
1472         SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1473 };
1474
1475 static struct sensor_device_attribute sda_pwm_mode[] = {
1476         SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1477                     store_pwm_mode, 0),
1478         SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1479                     store_pwm_mode, 1),
1480         SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1481                     store_pwm_mode, 2),
1482         SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1483                     store_pwm_mode, 3),
1484 };
1485
1486 static struct sensor_device_attribute sda_pwm_enable[] = {
1487         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1488                     store_pwm_enable, 0),
1489         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1490                     store_pwm_enable, 1),
1491         SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1492                     store_pwm_enable, 2),
1493         SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1494                     store_pwm_enable, 3),
1495 };
1496
1497 static struct sensor_device_attribute sda_target_temp[] = {
1498         SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1499                     store_target_temp, 0),
1500         SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1501                     store_target_temp, 1),
1502         SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1503                     store_target_temp, 2),
1504         SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1505                     store_target_temp, 3),
1506 };
1507
1508 static struct sensor_device_attribute sda_tolerance[] = {
1509         SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1510                     store_tolerance, 0),
1511         SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1512                     store_tolerance, 1),
1513         SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1514                     store_tolerance, 2),
1515         SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1516                     store_tolerance, 3),
1517 };
1518
1519 /* Smart Fan registers */
1520
1521 #define fan_functions(reg, REG) \
1522 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1523                        char *buf) \
1524 { \
1525         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1526         struct sensor_device_attribute *sensor_attr = \
1527                 to_sensor_dev_attr(attr); \
1528         int nr = sensor_attr->index; \
1529         return sprintf(buf, "%d\n", data->reg[nr]); \
1530 } \
1531 static ssize_t \
1532 store_##reg(struct device *dev, struct device_attribute *attr, \
1533                             const char *buf, size_t count) \
1534 { \
1535         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1536         struct sensor_device_attribute *sensor_attr = \
1537                 to_sensor_dev_attr(attr); \
1538         int nr = sensor_attr->index; \
1539         unsigned long val; \
1540         int err; \
1541         err = strict_strtoul(buf, 10, &val); \
1542         if (err < 0) \
1543                 return err; \
1544         val = SENSORS_LIMIT(val, 1, 255); \
1545         mutex_lock(&data->update_lock); \
1546         data->reg[nr] = val; \
1547         w83627ehf_write_value(data, data->REG_##REG[nr], val); \
1548         mutex_unlock(&data->update_lock); \
1549         return count; \
1550 }
1551
1552 fan_functions(fan_start_output, FAN_START_OUTPUT)
1553 fan_functions(fan_stop_output, FAN_STOP_OUTPUT)
1554 fan_functions(fan_max_output, FAN_MAX_OUTPUT)
1555 fan_functions(fan_step_output, FAN_STEP_OUTPUT)
1556
1557 #define fan_time_functions(reg, REG) \
1558 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1559                                 char *buf) \
1560 { \
1561         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1562         struct sensor_device_attribute *sensor_attr = \
1563                 to_sensor_dev_attr(attr); \
1564         int nr = sensor_attr->index; \
1565         return sprintf(buf, "%d\n", \
1566                         step_time_from_reg(data->reg[nr], \
1567                                            data->pwm_mode[nr])); \
1568 } \
1569 \
1570 static ssize_t \
1571 store_##reg(struct device *dev, struct device_attribute *attr, \
1572                         const char *buf, size_t count) \
1573 { \
1574         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1575         struct sensor_device_attribute *sensor_attr = \
1576                 to_sensor_dev_attr(attr); \
1577         int nr = sensor_attr->index; \
1578         unsigned long val; \
1579         int err; \
1580         err = strict_strtoul(buf, 10, &val); \
1581         if (err < 0) \
1582                 return err; \
1583         val = step_time_to_reg(val, data->pwm_mode[nr]); \
1584         mutex_lock(&data->update_lock); \
1585         data->reg[nr] = val; \
1586         w83627ehf_write_value(data, data->REG_##REG[nr], val); \
1587         mutex_unlock(&data->update_lock); \
1588         return count; \
1589 } \
1590
1591 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1592
1593 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1594                          char *buf)
1595 {
1596         struct w83627ehf_data *data = dev_get_drvdata(dev);
1597
1598         return sprintf(buf, "%s\n", data->name);
1599 }
1600 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1601
1602 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1603         SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1604                     store_fan_stop_time, 3),
1605         SENSOR_ATTR(pwm4_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1606                     store_fan_start_output, 3),
1607         SENSOR_ATTR(pwm4_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1608                     store_fan_stop_output, 3),
1609         SENSOR_ATTR(pwm4_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1610                     store_fan_max_output, 3),
1611         SENSOR_ATTR(pwm4_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1612                     store_fan_step_output, 3),
1613 };
1614
1615 static struct sensor_device_attribute sda_sf3_arrays[] = {
1616         SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1617                     store_fan_stop_time, 0),
1618         SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1619                     store_fan_stop_time, 1),
1620         SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1621                     store_fan_stop_time, 2),
1622         SENSOR_ATTR(pwm1_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1623                     store_fan_start_output, 0),
1624         SENSOR_ATTR(pwm2_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1625                     store_fan_start_output, 1),
1626         SENSOR_ATTR(pwm3_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
1627                     store_fan_start_output, 2),
1628         SENSOR_ATTR(pwm1_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1629                     store_fan_stop_output, 0),
1630         SENSOR_ATTR(pwm2_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1631                     store_fan_stop_output, 1),
1632         SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
1633                     store_fan_stop_output, 2),
1634 };
1635
1636
1637 /*
1638  * pwm1 and pwm3 don't support max and step settings on all chips.
1639  * Need to check support while generating/removing attribute files.
1640  */
1641 static struct sensor_device_attribute sda_sf3_max_step_arrays[] = {
1642         SENSOR_ATTR(pwm1_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1643                     store_fan_max_output, 0),
1644         SENSOR_ATTR(pwm1_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1645                     store_fan_step_output, 0),
1646         SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1647                     store_fan_max_output, 1),
1648         SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1649                     store_fan_step_output, 1),
1650         SENSOR_ATTR(pwm3_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
1651                     store_fan_max_output, 2),
1652         SENSOR_ATTR(pwm3_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
1653                     store_fan_step_output, 2),
1654 };
1655
1656 static ssize_t
1657 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
1658 {
1659         struct w83627ehf_data *data = dev_get_drvdata(dev);
1660         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1661 }
1662 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1663
1664 /*
1665  * Driver and device management
1666  */
1667
1668 static void w83627ehf_device_remove_files(struct device *dev)
1669 {
1670         /* some entries in the following arrays may not have been used in
1671          * device_create_file(), but device_remove_file() will ignore them */
1672         int i;
1673         struct w83627ehf_data *data = dev_get_drvdata(dev);
1674
1675         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1676                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1677         for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1678                 struct sensor_device_attribute *attr =
1679                   &sda_sf3_max_step_arrays[i];
1680                 if (data->REG_FAN_STEP_OUTPUT &&
1681                     data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
1682                         device_remove_file(dev, &attr->dev_attr);
1683         }
1684         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1685                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1686         for (i = 0; i < data->in_num; i++) {
1687                 if ((i == 6) && data->in6_skip)
1688                         continue;
1689                 device_remove_file(dev, &sda_in_input[i].dev_attr);
1690                 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1691                 device_remove_file(dev, &sda_in_min[i].dev_attr);
1692                 device_remove_file(dev, &sda_in_max[i].dev_attr);
1693         }
1694         for (i = 0; i < 5; i++) {
1695                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1696                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1697                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1698                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1699         }
1700         for (i = 0; i < data->pwm_num; i++) {
1701                 device_remove_file(dev, &sda_pwm[i].dev_attr);
1702                 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1703                 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1704                 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1705                 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1706         }
1707         for (i = 0; i < NUM_REG_TEMP; i++) {
1708                 if (!(data->have_temp & (1 << i)))
1709                         continue;
1710                 device_remove_file(dev, &sda_temp_input[i].dev_attr);
1711                 device_remove_file(dev, &sda_temp_label[i].dev_attr);
1712                 device_remove_file(dev, &sda_temp_max[i].dev_attr);
1713                 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
1714                 if (i > 2)
1715                         continue;
1716                 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1717                 device_remove_file(dev, &sda_temp_type[i].dev_attr);
1718         }
1719
1720         device_remove_file(dev, &dev_attr_name);
1721         device_remove_file(dev, &dev_attr_cpu0_vid);
1722 }
1723
1724 /* Get the monitoring functions started */
1725 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data,
1726                                                    enum kinds kind)
1727 {
1728         int i;
1729         u8 tmp, diode;
1730
1731         /* Start monitoring is needed */
1732         tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
1733         if (!(tmp & 0x01))
1734                 w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1735                                       tmp | 0x01);
1736
1737         /* Enable temperature sensors if needed */
1738         for (i = 0; i < NUM_REG_TEMP; i++) {
1739                 if (!(data->have_temp & (1 << i)))
1740                         continue;
1741                 if (!data->reg_temp_config[i])
1742                         continue;
1743                 tmp = w83627ehf_read_value(data,
1744                                            data->reg_temp_config[i]);
1745                 if (tmp & 0x01)
1746                         w83627ehf_write_value(data,
1747                                               data->reg_temp_config[i],
1748                                               tmp & 0xfe);
1749         }
1750
1751         /* Enable VBAT monitoring if needed */
1752         tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
1753         if (!(tmp & 0x01))
1754                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
1755
1756         /* Get thermal sensor types */
1757         switch (kind) {
1758         case w83627ehf:
1759                 diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
1760                 break;
1761         default:
1762                 diode = 0x70;
1763         }
1764         for (i = 0; i < 3; i++) {
1765                 const char *label = NULL;
1766
1767                 if (data->temp_label)
1768                         label = data->temp_label[data->temp_src[i]];
1769
1770                 /* Digital source overrides analog type */
1771                 if (label && strncmp(label, "PECI", 4) == 0)
1772                         data->temp_type[i] = 6;
1773                 else if (label && strncmp(label, "AMD", 3) == 0)
1774                         data->temp_type[i] = 5;
1775                 else if ((tmp & (0x02 << i)))
1776                         data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 3;
1777                 else
1778                         data->temp_type[i] = 4; /* thermistor */
1779         }
1780 }
1781
1782 static void w82627ehf_swap_tempreg(struct w83627ehf_data *data,
1783                                    int r1, int r2)
1784 {
1785         u16 tmp;
1786
1787         tmp = data->temp_src[r1];
1788         data->temp_src[r1] = data->temp_src[r2];
1789         data->temp_src[r2] = tmp;
1790
1791         tmp = data->reg_temp[r1];
1792         data->reg_temp[r1] = data->reg_temp[r2];
1793         data->reg_temp[r2] = tmp;
1794
1795         tmp = data->reg_temp_over[r1];
1796         data->reg_temp_over[r1] = data->reg_temp_over[r2];
1797         data->reg_temp_over[r2] = tmp;
1798
1799         tmp = data->reg_temp_hyst[r1];
1800         data->reg_temp_hyst[r1] = data->reg_temp_hyst[r2];
1801         data->reg_temp_hyst[r2] = tmp;
1802
1803         tmp = data->reg_temp_config[r1];
1804         data->reg_temp_config[r1] = data->reg_temp_config[r2];
1805         data->reg_temp_config[r2] = tmp;
1806 }
1807
1808 static int __devinit w83627ehf_probe(struct platform_device *pdev)
1809 {
1810         struct device *dev = &pdev->dev;
1811         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1812         struct w83627ehf_data *data;
1813         struct resource *res;
1814         u8 fan3pin, fan4pin, fan4min, fan5pin, en_vrm10;
1815         int i, err = 0;
1816
1817         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1818         if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
1819                 err = -EBUSY;
1820                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1821                         (unsigned long)res->start,
1822                         (unsigned long)res->start + IOREGION_LENGTH - 1);
1823                 goto exit;
1824         }
1825
1826         data = devm_kzalloc(&pdev->dev, sizeof(struct w83627ehf_data),
1827                             GFP_KERNEL);
1828         if (!data) {
1829                 err = -ENOMEM;
1830                 goto exit_release;
1831         }
1832
1833         data->addr = res->start;
1834         mutex_init(&data->lock);
1835         mutex_init(&data->update_lock);
1836         data->name = w83627ehf_device_names[sio_data->kind];
1837         platform_set_drvdata(pdev, data);
1838
1839         /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
1840         data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
1841         /* 667HG, NCT6775F, and NCT6776F have 3 pwms */
1842         data->pwm_num = (sio_data->kind == w83667hg
1843                          || sio_data->kind == w83667hg_b
1844                          || sio_data->kind == nct6775
1845                          || sio_data->kind == nct6776) ? 3 : 4;
1846
1847         data->have_temp = 0x07;
1848         /* Check temp3 configuration bit for 667HG */
1849         if (sio_data->kind == w83667hg) {
1850                 u8 reg;
1851
1852                 reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
1853                 if (reg & 0x01)
1854                         data->have_temp &= ~(1 << 2);
1855                 else
1856                         data->in6_skip = 1;     /* either temp3 or in6 */
1857         }
1858
1859         /* Deal with temperature register setup first. */
1860         if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1861                 int mask = 0;
1862
1863                 /*
1864                  * Display temperature sensor output only if it monitors
1865                  * a source other than one already reported. Always display
1866                  * first three temperature registers, though.
1867                  */
1868                 for (i = 0; i < NUM_REG_TEMP; i++) {
1869                         u8 src;
1870
1871                         data->reg_temp[i] = NCT6775_REG_TEMP[i];
1872                         data->reg_temp_over[i] = NCT6775_REG_TEMP_OVER[i];
1873                         data->reg_temp_hyst[i] = NCT6775_REG_TEMP_HYST[i];
1874                         data->reg_temp_config[i] = NCT6775_REG_TEMP_CONFIG[i];
1875
1876                         src = w83627ehf_read_value(data,
1877                                                    NCT6775_REG_TEMP_SOURCE[i]);
1878                         src &= 0x1f;
1879                         if (src && !(mask & (1 << src))) {
1880                                 data->have_temp |= 1 << i;
1881                                 mask |= 1 << src;
1882                         }
1883
1884                         data->temp_src[i] = src;
1885
1886                         /*
1887                          * Now do some register swapping if index 0..2 don't
1888                          * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
1889                          * Idea is to have the first three attributes
1890                          * report SYSTIN, CPUIN, and AUXIN if possible
1891                          * without overriding the basic system configuration.
1892                          */
1893                         if (i > 0 && data->temp_src[0] != 1
1894                             && data->temp_src[i] == 1)
1895                                 w82627ehf_swap_tempreg(data, 0, i);
1896                         if (i > 1 && data->temp_src[1] != 2
1897                             && data->temp_src[i] == 2)
1898                                 w82627ehf_swap_tempreg(data, 1, i);
1899                         if (i > 2 && data->temp_src[2] != 3
1900                             && data->temp_src[i] == 3)
1901                                 w82627ehf_swap_tempreg(data, 2, i);
1902                 }
1903                 if (sio_data->kind == nct6776) {
1904                         /*
1905                          * On NCT6776, AUXTIN and VIN3 pins are shared.
1906                          * Only way to detect it is to check if AUXTIN is used
1907                          * as a temperature source, and if that source is
1908                          * enabled.
1909                          *
1910                          * If that is the case, disable in6, which reports VIN3.
1911                          * Otherwise disable temp3.
1912                          */
1913                         if (data->temp_src[2] == 3) {
1914                                 u8 reg;
1915
1916                                 if (data->reg_temp_config[2])
1917                                         reg = w83627ehf_read_value(data,
1918                                                 data->reg_temp_config[2]);
1919                                 else
1920                                         reg = 0; /* Assume AUXTIN is used */
1921
1922                                 if (reg & 0x01)
1923                                         data->have_temp &= ~(1 << 2);
1924                                 else
1925                                         data->in6_skip = 1;
1926                         }
1927                         data->temp_label = nct6776_temp_label;
1928                 } else {
1929                         data->temp_label = nct6775_temp_label;
1930                 }
1931         } else if (sio_data->kind == w83667hg_b) {
1932                 u8 reg;
1933
1934                 /*
1935                  * Temperature sources are selected with bank 0, registers 0x49
1936                  * and 0x4a.
1937                  */
1938                 for (i = 0; i < ARRAY_SIZE(W83627EHF_REG_TEMP); i++) {
1939                         data->reg_temp[i] = W83627EHF_REG_TEMP[i];
1940                         data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
1941                         data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
1942                         data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
1943                 }
1944                 reg = w83627ehf_read_value(data, 0x4a);
1945                 data->temp_src[0] = reg >> 5;
1946                 reg = w83627ehf_read_value(data, 0x49);
1947                 data->temp_src[1] = reg & 0x07;
1948                 data->temp_src[2] = (reg >> 4) & 0x07;
1949
1950                 /*
1951                  * W83667HG-B has another temperature register at 0x7e.
1952                  * The temperature source is selected with register 0x7d.
1953                  * Support it if the source differs from already reported
1954                  * sources.
1955                  */
1956                 reg = w83627ehf_read_value(data, 0x7d);
1957                 reg &= 0x07;
1958                 if (reg != data->temp_src[0] && reg != data->temp_src[1]
1959                     && reg != data->temp_src[2]) {
1960                         data->temp_src[3] = reg;
1961                         data->have_temp |= 1 << 3;
1962                 }
1963
1964                 /*
1965                  * Chip supports either AUXTIN or VIN3. Try to find out which
1966                  * one.
1967                  */
1968                 reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
1969                 if (data->temp_src[2] == 2 && (reg & 0x01))
1970                         data->have_temp &= ~(1 << 2);
1971
1972                 if ((data->temp_src[2] == 2 && (data->have_temp & (1 << 2)))
1973                     || (data->temp_src[3] == 2 && (data->have_temp & (1 << 3))))
1974                         data->in6_skip = 1;
1975
1976                 data->temp_label = w83667hg_b_temp_label;
1977         } else {
1978                 /* Temperature sources are fixed */
1979                 for (i = 0; i < 3; i++) {
1980                         data->reg_temp[i] = W83627EHF_REG_TEMP[i];
1981                         data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
1982                         data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
1983                         data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
1984                 }
1985         }
1986
1987         if (sio_data->kind == nct6775) {
1988                 data->has_fan_div = true;
1989                 data->fan_from_reg = fan_from_reg16;
1990                 data->fan_from_reg_min = fan_from_reg8;
1991                 data->REG_PWM = NCT6775_REG_PWM;
1992                 data->REG_TARGET = NCT6775_REG_TARGET;
1993                 data->REG_FAN = NCT6775_REG_FAN;
1994                 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
1995                 data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
1996                 data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
1997                 data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
1998                 data->REG_FAN_MAX_OUTPUT = NCT6775_REG_FAN_MAX_OUTPUT;
1999                 data->REG_FAN_STEP_OUTPUT = NCT6775_REG_FAN_STEP_OUTPUT;
2000         } else if (sio_data->kind == nct6776) {
2001                 data->has_fan_div = false;
2002                 data->fan_from_reg = fan_from_reg13;
2003                 data->fan_from_reg_min = fan_from_reg13;
2004                 data->REG_PWM = NCT6775_REG_PWM;
2005                 data->REG_TARGET = NCT6775_REG_TARGET;
2006                 data->REG_FAN = NCT6775_REG_FAN;
2007                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
2008                 data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
2009                 data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
2010                 data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
2011         } else if (sio_data->kind == w83667hg_b) {
2012                 data->has_fan_div = true;
2013                 data->fan_from_reg = fan_from_reg8;
2014                 data->fan_from_reg_min = fan_from_reg8;
2015                 data->REG_PWM = W83627EHF_REG_PWM;
2016                 data->REG_TARGET = W83627EHF_REG_TARGET;
2017                 data->REG_FAN = W83627EHF_REG_FAN;
2018                 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2019                 data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2020                 data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2021                 data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
2022                 data->REG_FAN_MAX_OUTPUT =
2023                   W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
2024                 data->REG_FAN_STEP_OUTPUT =
2025                   W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
2026         } else {
2027                 data->has_fan_div = true;
2028                 data->fan_from_reg = fan_from_reg8;
2029                 data->fan_from_reg_min = fan_from_reg8;
2030                 data->REG_PWM = W83627EHF_REG_PWM;
2031                 data->REG_TARGET = W83627EHF_REG_TARGET;
2032                 data->REG_FAN = W83627EHF_REG_FAN;
2033                 data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2034                 data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2035                 data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2036                 data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
2037                 data->REG_FAN_MAX_OUTPUT =
2038                   W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
2039                 data->REG_FAN_STEP_OUTPUT =
2040                   W83627EHF_REG_FAN_STEP_OUTPUT_COMMON;
2041         }
2042
2043         /* Initialize the chip */
2044         w83627ehf_init_device(data, sio_data->kind);
2045
2046         data->vrm = vid_which_vrm();
2047         superio_enter(sio_data->sioreg);
2048         /* Read VID value */
2049         if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b ||
2050             sio_data->kind == nct6775 || sio_data->kind == nct6776) {
2051                 /* W83667HG has different pins for VID input and output, so
2052                 we can get the VID input values directly at logical device D
2053                 0xe3. */
2054                 superio_select(sio_data->sioreg, W83667HG_LD_VID);
2055                 data->vid = superio_inb(sio_data->sioreg, 0xe3);
2056                 err = device_create_file(dev, &dev_attr_cpu0_vid);
2057                 if (err)
2058                         goto exit_release;
2059         } else {
2060                 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2061                 if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
2062                         /* Set VID input sensibility if needed. In theory the
2063                            BIOS should have set it, but in practice it's not
2064                            always the case. We only do it for the W83627EHF/EHG
2065                            because the W83627DHG is more complex in this
2066                            respect. */
2067                         if (sio_data->kind == w83627ehf) {
2068                                 en_vrm10 = superio_inb(sio_data->sioreg,
2069                                                        SIO_REG_EN_VRM10);
2070                                 if ((en_vrm10 & 0x08) && data->vrm == 90) {
2071                                         dev_warn(dev, "Setting VID input "
2072                                                  "voltage to TTL\n");
2073                                         superio_outb(sio_data->sioreg,
2074                                                      SIO_REG_EN_VRM10,
2075                                                      en_vrm10 & ~0x08);
2076                                 } else if (!(en_vrm10 & 0x08)
2077                                            && data->vrm == 100) {
2078                                         dev_warn(dev, "Setting VID input "
2079                                                  "voltage to VRM10\n");
2080                                         superio_outb(sio_data->sioreg,
2081                                                      SIO_REG_EN_VRM10,
2082                                                      en_vrm10 | 0x08);
2083                                 }
2084                         }
2085
2086                         data->vid = superio_inb(sio_data->sioreg,
2087                                                 SIO_REG_VID_DATA);
2088                         if (sio_data->kind == w83627ehf) /* 6 VID pins only */
2089                                 data->vid &= 0x3f;
2090
2091                         err = device_create_file(dev, &dev_attr_cpu0_vid);
2092                         if (err)
2093                                 goto exit_release;
2094                 } else {
2095                         dev_info(dev, "VID pins in output mode, CPU VID not "
2096                                  "available\n");
2097                 }
2098         }
2099
2100         /* fan4 and fan5 share some pins with the GPIO and serial flash */
2101         if (sio_data->kind == nct6775) {
2102                 /* On NCT6775, fan4 shares pins with the fdc interface */
2103                 fan3pin = 1;
2104                 fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
2105                 fan4min = 0;
2106                 fan5pin = 0;
2107         } else if (sio_data->kind == nct6776) {
2108                 bool gpok = superio_inb(sio_data->sioreg, 0x27) & 0x80;
2109                 u8 regval;
2110
2111                 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2112                 regval = superio_inb(sio_data->sioreg, SIO_REG_ENABLE);
2113
2114                 if (regval & 0x80)
2115                         fan3pin = gpok;
2116                 else
2117                         fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
2118
2119                 if (regval & 0x40)
2120                         fan4pin = gpok;
2121                 else
2122                         fan4pin = !!(superio_inb(sio_data->sioreg, 0x1C)
2123                                      & 0x01);
2124
2125                 if (regval & 0x20)
2126                         fan5pin = gpok;
2127                 else
2128                         fan5pin = !!(superio_inb(sio_data->sioreg, 0x1C)
2129                                      & 0x02);
2130
2131                 fan4min = fan4pin;
2132         } else if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
2133                 fan3pin = 1;
2134                 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
2135                 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
2136                 fan4min = fan4pin;
2137         } else {
2138                 fan3pin = 1;
2139                 fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
2140                 fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
2141                 fan4min = fan4pin;
2142         }
2143
2144         if (fan_debounce &&
2145             (sio_data->kind == nct6775 || sio_data->kind == nct6776)) {
2146                 u8 tmp;
2147
2148                 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2149                 tmp = superio_inb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE);
2150                 if (sio_data->kind == nct6776)
2151                         superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2152                                      0x3e | tmp);
2153                 else
2154                         superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2155                                      0x1e | tmp);
2156                 pr_info("Enabled fan debounce for chip %s\n", data->name);
2157         }
2158
2159         superio_exit(sio_data->sioreg);
2160
2161         /* It looks like fan4 and fan5 pins can be alternatively used
2162            as fan on/off switches, but fan5 control is write only :/
2163            We assume that if the serial interface is disabled, designers
2164            connected fan5 as input unless they are emitting log 1, which
2165            is not the default. */
2166
2167         data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
2168
2169         data->has_fan |= (fan3pin << 2);
2170         data->has_fan_min |= (fan3pin << 2);
2171
2172         /*
2173          * NCT6775F and NCT6776F don't have the W83627EHF_REG_FANDIV1 register
2174          */
2175         if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
2176                 data->has_fan |= (fan4pin << 3) | (fan5pin << 4);
2177                 data->has_fan_min |= (fan4min << 3) | (fan5pin << 4);
2178         } else {
2179                 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
2180                 if ((i & (1 << 2)) && fan4pin) {
2181                         data->has_fan |= (1 << 3);
2182                         data->has_fan_min |= (1 << 3);
2183                 }
2184                 if (!(i & (1 << 1)) && fan5pin) {
2185                         data->has_fan |= (1 << 4);
2186                         data->has_fan_min |= (1 << 4);
2187                 }
2188         }
2189
2190         /* Read fan clock dividers immediately */
2191         w83627ehf_update_fan_div_common(dev, data);
2192
2193         /* Read pwm data to save original values */
2194         w83627ehf_update_pwm_common(dev, data);
2195         for (i = 0; i < data->pwm_num; i++)
2196                 data->pwm_enable_orig[i] = data->pwm_enable[i];
2197
2198         /* Read pwm data to save original values */
2199         w83627ehf_update_pwm_common(dev, data);
2200         for (i = 0; i < data->pwm_num; i++)
2201                 data->pwm_enable_orig[i] = data->pwm_enable[i];
2202
2203         /* Register sysfs hooks */
2204         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) {
2205                 err = device_create_file(dev, &sda_sf3_arrays[i].dev_attr);
2206                 if (err)
2207                         goto exit_remove;
2208         }
2209
2210         for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
2211                 struct sensor_device_attribute *attr =
2212                   &sda_sf3_max_step_arrays[i];
2213                 if (data->REG_FAN_STEP_OUTPUT &&
2214                     data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
2215                         err = device_create_file(dev, &attr->dev_attr);
2216                         if (err)
2217                                 goto exit_remove;
2218                 }
2219         }
2220         /* if fan4 is enabled create the sf3 files for it */
2221         if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
2222                 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
2223                         err = device_create_file(dev,
2224                                         &sda_sf3_arrays_fan4[i].dev_attr);
2225                         if (err)
2226                                 goto exit_remove;
2227                 }
2228
2229         for (i = 0; i < data->in_num; i++) {
2230                 if ((i == 6) && data->in6_skip)
2231                         continue;
2232                 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
2233                         || (err = device_create_file(dev,
2234                                 &sda_in_alarm[i].dev_attr))
2235                         || (err = device_create_file(dev,
2236                                 &sda_in_min[i].dev_attr))
2237                         || (err = device_create_file(dev,
2238                                 &sda_in_max[i].dev_attr)))
2239                         goto exit_remove;
2240         }
2241
2242         for (i = 0; i < 5; i++) {
2243                 if (data->has_fan & (1 << i)) {
2244                         if ((err = device_create_file(dev,
2245                                         &sda_fan_input[i].dev_attr))
2246                                 || (err = device_create_file(dev,
2247                                         &sda_fan_alarm[i].dev_attr)))
2248                                 goto exit_remove;
2249                         if (sio_data->kind != nct6776) {
2250                                 err = device_create_file(dev,
2251                                                 &sda_fan_div[i].dev_attr);
2252                                 if (err)
2253                                         goto exit_remove;
2254                         }
2255                         if (data->has_fan_min & (1 << i)) {
2256                                 err = device_create_file(dev,
2257                                                 &sda_fan_min[i].dev_attr);
2258                                 if (err)
2259                                         goto exit_remove;
2260                         }
2261                         if (i < data->pwm_num &&
2262                                 ((err = device_create_file(dev,
2263                                         &sda_pwm[i].dev_attr))
2264                                 || (err = device_create_file(dev,
2265                                         &sda_pwm_mode[i].dev_attr))
2266                                 || (err = device_create_file(dev,
2267                                         &sda_pwm_enable[i].dev_attr))
2268                                 || (err = device_create_file(dev,
2269                                         &sda_target_temp[i].dev_attr))
2270                                 || (err = device_create_file(dev,
2271                                         &sda_tolerance[i].dev_attr))))
2272                                 goto exit_remove;
2273                 }
2274         }
2275
2276         for (i = 0; i < NUM_REG_TEMP; i++) {
2277                 if (!(data->have_temp & (1 << i)))
2278                         continue;
2279                 err = device_create_file(dev, &sda_temp_input[i].dev_attr);
2280                 if (err)
2281                         goto exit_remove;
2282                 if (data->temp_label) {
2283                         err = device_create_file(dev,
2284                                                  &sda_temp_label[i].dev_attr);
2285                         if (err)
2286                                 goto exit_remove;
2287                 }
2288                 if (data->reg_temp_over[i]) {
2289                         err = device_create_file(dev,
2290                                 &sda_temp_max[i].dev_attr);
2291                         if (err)
2292                                 goto exit_remove;
2293                 }
2294                 if (data->reg_temp_hyst[i]) {
2295                         err = device_create_file(dev,
2296                                 &sda_temp_max_hyst[i].dev_attr);
2297                         if (err)
2298                                 goto exit_remove;
2299                 }
2300                 if (i > 2)
2301                         continue;
2302                 if ((err = device_create_file(dev,
2303                                 &sda_temp_alarm[i].dev_attr))
2304                         || (err = device_create_file(dev,
2305                                 &sda_temp_type[i].dev_attr)))
2306                         goto exit_remove;
2307         }
2308
2309         err = device_create_file(dev, &dev_attr_name);
2310         if (err)
2311                 goto exit_remove;
2312
2313         data->hwmon_dev = hwmon_device_register(dev);
2314         if (IS_ERR(data->hwmon_dev)) {
2315                 err = PTR_ERR(data->hwmon_dev);
2316                 goto exit_remove;
2317         }
2318
2319         return 0;
2320
2321 exit_remove:
2322         w83627ehf_device_remove_files(dev);
2323 exit_release:
2324         platform_set_drvdata(pdev, NULL);
2325         release_region(res->start, IOREGION_LENGTH);
2326 exit:
2327         return err;
2328 }
2329
2330 static int __devexit w83627ehf_remove(struct platform_device *pdev)
2331 {
2332         struct w83627ehf_data *data = platform_get_drvdata(pdev);
2333
2334         hwmon_device_unregister(data->hwmon_dev);
2335         w83627ehf_device_remove_files(&pdev->dev);
2336         release_region(data->addr, IOREGION_LENGTH);
2337         platform_set_drvdata(pdev, NULL);
2338
2339         return 0;
2340 }
2341
2342 static struct platform_driver w83627ehf_driver = {
2343         .driver = {
2344                 .owner  = THIS_MODULE,
2345                 .name   = DRVNAME,
2346         },
2347         .probe          = w83627ehf_probe,
2348         .remove         = __devexit_p(w83627ehf_remove),
2349 };
2350
2351 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
2352 static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
2353                                  struct w83627ehf_sio_data *sio_data)
2354 {
2355         static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
2356         static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
2357         static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
2358         static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
2359         static const char __initdata sio_name_W83667HG[] = "W83667HG";
2360         static const char __initdata sio_name_W83667HG_B[] = "W83667HG-B";
2361         static const char __initdata sio_name_NCT6775[] = "NCT6775F";
2362         static const char __initdata sio_name_NCT6776[] = "NCT6776F";
2363
2364         u16 val;
2365         const char *sio_name;
2366
2367         superio_enter(sioaddr);
2368
2369         if (force_id)
2370                 val = force_id;
2371         else
2372                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
2373                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
2374         switch (val & SIO_ID_MASK) {
2375         case SIO_W83627EHF_ID:
2376                 sio_data->kind = w83627ehf;
2377                 sio_name = sio_name_W83627EHF;
2378                 break;
2379         case SIO_W83627EHG_ID:
2380                 sio_data->kind = w83627ehf;
2381                 sio_name = sio_name_W83627EHG;
2382                 break;
2383         case SIO_W83627DHG_ID:
2384                 sio_data->kind = w83627dhg;
2385                 sio_name = sio_name_W83627DHG;
2386                 break;
2387         case SIO_W83627DHG_P_ID:
2388                 sio_data->kind = w83627dhg_p;
2389                 sio_name = sio_name_W83627DHG_P;
2390                 break;
2391         case SIO_W83667HG_ID:
2392                 sio_data->kind = w83667hg;
2393                 sio_name = sio_name_W83667HG;
2394                 break;
2395         case SIO_W83667HG_B_ID:
2396                 sio_data->kind = w83667hg_b;
2397                 sio_name = sio_name_W83667HG_B;
2398                 break;
2399         case SIO_NCT6775_ID:
2400                 sio_data->kind = nct6775;
2401                 sio_name = sio_name_NCT6775;
2402                 break;
2403         case SIO_NCT6776_ID:
2404                 sio_data->kind = nct6776;
2405                 sio_name = sio_name_NCT6776;
2406                 break;
2407         default:
2408                 if (val != 0xffff)
2409                         pr_debug("unsupported chip ID: 0x%04x\n", val);
2410                 superio_exit(sioaddr);
2411                 return -ENODEV;
2412         }
2413
2414         /* We have a known chip, find the HWM I/O address */
2415         superio_select(sioaddr, W83627EHF_LD_HWM);
2416         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
2417             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
2418         *addr = val & IOREGION_ALIGNMENT;
2419         if (*addr == 0) {
2420                 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n");
2421                 superio_exit(sioaddr);
2422                 return -ENODEV;
2423         }
2424
2425         /* Activate logical device if needed */
2426         val = superio_inb(sioaddr, SIO_REG_ENABLE);
2427         if (!(val & 0x01)) {
2428                 pr_warn("Forcibly enabling Super-I/O. "
2429                         "Sensor is probably unusable.\n");
2430                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
2431         }
2432
2433         superio_exit(sioaddr);
2434         pr_info("Found %s chip at %#x\n", sio_name, *addr);
2435         sio_data->sioreg = sioaddr;
2436
2437         return 0;
2438 }
2439
2440 /* when Super-I/O functions move to a separate file, the Super-I/O
2441  * bus will manage the lifetime of the device and this module will only keep
2442  * track of the w83627ehf driver. But since we platform_device_alloc(), we
2443  * must keep track of the device */
2444 static struct platform_device *pdev;
2445
2446 static int __init sensors_w83627ehf_init(void)
2447 {
2448         int err;
2449         unsigned short address;
2450         struct resource res;
2451         struct w83627ehf_sio_data sio_data;
2452
2453         /* initialize sio_data->kind and sio_data->sioreg.
2454          *
2455          * when Super-I/O functions move to a separate file, the Super-I/O
2456          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
2457          * w83627ehf hardware monitor, and call probe() */
2458         if (w83627ehf_find(0x2e, &address, &sio_data) &&
2459             w83627ehf_find(0x4e, &address, &sio_data))
2460                 return -ENODEV;
2461
2462         err = platform_driver_register(&w83627ehf_driver);
2463         if (err)
2464                 goto exit;
2465
2466         pdev = platform_device_alloc(DRVNAME, address);
2467         if (!pdev) {
2468                 err = -ENOMEM;
2469                 pr_err("Device allocation failed\n");
2470                 goto exit_unregister;
2471         }
2472
2473         err = platform_device_add_data(pdev, &sio_data,
2474                                        sizeof(struct w83627ehf_sio_data));
2475         if (err) {
2476                 pr_err("Platform data allocation failed\n");
2477                 goto exit_device_put;
2478         }
2479
2480         memset(&res, 0, sizeof(res));
2481         res.name = DRVNAME;
2482         res.start = address + IOREGION_OFFSET;
2483         res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
2484         res.flags = IORESOURCE_IO;
2485
2486         err = acpi_check_resource_conflict(&res);
2487         if (err)
2488                 goto exit_device_put;
2489
2490         err = platform_device_add_resources(pdev, &res, 1);
2491         if (err) {
2492                 pr_err("Device resource addition failed (%d)\n", err);
2493                 goto exit_device_put;
2494         }
2495
2496         /* platform_device_add calls probe() */
2497         err = platform_device_add(pdev);
2498         if (err) {
2499                 pr_err("Device addition failed (%d)\n", err);
2500                 goto exit_device_put;
2501         }
2502
2503         return 0;
2504
2505 exit_device_put:
2506         platform_device_put(pdev);
2507 exit_unregister:
2508         platform_driver_unregister(&w83627ehf_driver);
2509 exit:
2510         return err;
2511 }
2512
2513 static void __exit sensors_w83627ehf_exit(void)
2514 {
2515         platform_device_unregister(pdev);
2516         platform_driver_unregister(&w83627ehf_driver);
2517 }
2518
2519 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
2520 MODULE_DESCRIPTION("W83627EHF driver");
2521 MODULE_LICENSE("GPL");
2522
2523 module_init(sensors_w83627ehf_init);
2524 module_exit(sensors_w83627ehf_exit);