drivers/hwmon/w83627ehf.c

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

DEFINITIONS
