git.sur5r.net Git - groeck-nct6775/blob - nct6775.c

   1 /*
   2  * nct6775 - Driver for the hardware monitoring functionality of
   3  *             Nuvoton NCT677x Super-I/O chips
   4  *
   5  * Copyright (C) 2012  Guenter Roeck <linux@roeck-us.net>
   6  *
   7  * Derived from w83627ehf driver
   8  * Copyright (C) 2005-2011  Jean Delvare <khali@linux-fr.org>
   9  * Copyright (C) 2006  Yuan Mu (Winbond),
  10  *                     Rudolf Marek <r.marek@assembler.cz>
  11  *                     David Hubbard <david.c.hubbard@gmail.com>
  12  *                     Daniel J Blueman <daniel.blueman@gmail.com>
  13  * Copyright (C) 2010  Sheng-Yuan Huang (Nuvoton) (PS00)
  14  *
  15  * Shamelessly ripped from the w83627hf driver
  16  * Copyright (C) 2003  Mark Studebaker
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  *
  32  *
  33  * Supports the following chips:
  34  *
  35  * Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
  36  * nct6775f     9      4       3       6+3    0xb470 0xc1    0x5ca3
  37  * nct6776f     9      5       3       6+3    0xc330 0xc1    0x5ca3
  38  * nct6779d    15      5       5       2+5    0xc560 0xc1    0x5ca3
  39  */
  40
  41 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  42
  43 #include <linux/module.h>
  44 #include <linux/init.h>
  45 #include <linux/slab.h>
  46 #include <linux/jiffies.h>
  47 #include <linux/platform_device.h>
  48 #include <linux/hwmon.h>
  49 #include <linux/hwmon-sysfs.h>
  50 #include <linux/hwmon-vid.h>
  51 #include <linux/err.h>
  52 #include <linux/mutex.h>
  53 #include <linux/acpi.h>
  54 #include <linux/io.h>
  55 #include "lm75.h"
  56
  57 enum kinds { nct6775, nct6776, nct6779 };
  58
  59 /* used to set data->name = nct6775_device_names[data->sio_kind] */
  60 static const char * const nct6775_device_names[] = {
  61         "nct6775",
  62         "nct6776",
  63         "nct6779",
  64 };
  65
  66 static unsigned short force_id;
  67 module_param(force_id, ushort, 0);
  68 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  69
  70 static unsigned short fan_debounce;
  71 module_param(fan_debounce, ushort, 0);
  72 MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
  73
  74 #define DRVNAME "nct6775"
  75
  76 /*
  77  * Super-I/O constants and functions
  78  */
  79
  80 #define NCT6775_LD_ACPI         0x0a
  81 #define NCT6775_LD_HWM          0x0b
  82 #define NCT6775_LD_VID          0x0d
  83
  84 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  85 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  86 #define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
  87 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  88 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  89 #define SIO_REG_VID_CTRL        0xF0    /* VID control */
  90 #define SIO_REG_VID_DATA        0xF1    /* VID data */
  91
  92 #define SIO_NCT6775_ID          0xb470
  93 #define SIO_NCT6776_ID          0xc330
  94 #define SIO_NCT6779_ID          0xc560
  95 #define SIO_ID_MASK             0xFFF0
  96
  97 static inline void
  98 superio_outb(int ioreg, int reg, int val)
  99 {
 100         outb(reg, ioreg);
 101         outb(val, ioreg + 1);
 102 }
 103
 104 static inline int
 105 superio_inb(int ioreg, int reg)
 106 {
 107         outb(reg, ioreg);
 108         return inb(ioreg + 1);
 109 }
 110
 111 static inline void
 112 superio_select(int ioreg, int ld)
 113 {
 114         outb(SIO_REG_LDSEL, ioreg);
 115         outb(ld, ioreg + 1);
 116 }
 117
 118 static inline void
 119 superio_enter(int ioreg)
 120 {
 121         outb(0x87, ioreg);
 122         outb(0x87, ioreg);
 123 }
 124
 125 static inline void
 126 superio_exit(int ioreg)
 127 {
 128         outb(0xaa, ioreg);
 129         outb(0x02, ioreg);
 130         outb(0x02, ioreg + 1);
 131 }
 132
 133 /*
 134  * ISA constants
 135  */
 136
 137 #define IOREGION_ALIGNMENT      (~7)
 138 #define IOREGION_OFFSET         5
 139 #define IOREGION_LENGTH         2
 140 #define ADDR_REG_OFFSET         0
 141 #define DATA_REG_OFFSET         1
 142
 143 #define NCT6775_REG_BANK        0x4E
 144 #define NCT6775_REG_CONFIG      0x40
 145
 146 /*
 147  * Not currently used:
 148  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
 149  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
 150  * REG_MAN_ID is at port 0x4f
 151  * REG_CHIP_ID is at port 0x58
 152  */
 153
 154 static const u16 NCT6775_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d };
 155
 156 /* Voltage min/max registers for nr=7..14 are in bank 5 */
 157
 158 static const u16 NCT6775_REG_IN_MAX[] = {
 159         0x2b, 0x2d, 0x2f, 0x31, 0x33, 0x35, 0x37, 0x554, 0x556 };
 160 static const u16 NCT6775_REG_IN_MIN[] = {
 161         0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x555, 0x557 };
 162 static const u16 NCT6775_REG_IN[] = {
 163         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x550, 0x551, 0x552
 164 };
 165
 166 static const u16 NCT6779_REG_IN[] = {
 167         0x480, 0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487,
 168         0x488, 0x489, 0x48a, 0x48b, 0x48c, 0x48d, 0x48e
 169 };
 170
 171 #define NCT6775_REG_VBAT                0x5D
 172
 173 #define NCT6775_REG_FANDIV1             0x506
 174 #define NCT6775_REG_FANDIV2             0x507
 175
 176 #define NCT6775_REG_CR_FAN_DEBOUNCE     0xf0
 177
 178 static const u16 NCT6775_REG_ALARM[6] = { 0x459, 0x45A, 0x45B };
 179 static const u16 NCT6779_REG_ALARM[6] = { 0x459, 0x45A, 0x45B, 0x568 };
 180
 181 #define NCT6775_REG_CASEOPEN            0x42
 182
 183 static const u8 NCT6775_CASEOPEN_MASK[] = { 0x10, 0x00 };
 184 static const u8 NCT6776_CASEOPEN_MASK[] = { 0x10, 0x40 };
 185
 186 static const u8 NCT6775_REG_CR_CASEOPEN_CLR[] = { 0xe6, 0xee };
 187 static const u8 NCT6775_CR_CASEOPEN_CLR_MASK[] = { 0x20, 0x01 };
 188
 189 /* DC or PWM output fan configuration */
 190 static const u8 NCT6775_REG_PWM_MODE[] = { 0x04, 0x04, 0x12 };
 191 static const u8 NCT6775_PWM_MODE_MASK[] = { 0x01, 0x02, 0x01 };
 192
 193 static const u8 NCT6776_REG_PWM_MODE[] = { 0x04, 0, 0 };
 194 static const u8 NCT6776_PWM_MODE_MASK[] = { 0x01, 0, 0 };
 195
 196 /* Advanced Fan control, some values are common for all fans */
 197
 198 static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301, 0x801, 0x901 };
 199 static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302, 0x802, 0x902 };
 200 static const u16 NCT6775_REG_FAN_STEP_DOWN_TIME[] = {
 201         0x103, 0x203, 0x303, 0x803, 0x903 };
 202 static const u16 NCT6775_REG_FAN_STEP_UP_TIME[] = {
 203         0x104, 0x204, 0x304, 0x804, 0x904 };
 204 static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = {
 205         0x105, 0x205, 0x305, 0x805, 0x905 };
 206 static const u16 NCT6775_REG_FAN_START_OUTPUT[]
 207         = { 0x106, 0x206, 0x306, 0x806, 0x906 };
 208 static const u16 NCT6775_REG_FAN_STOP_TIME[]
 209         = { 0x107, 0x207, 0x307, 0x807, 0x907 };
 210 static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309, 0x809, 0x909 };
 211 static const u16 NCT6775_REG_PWM_READ[] = { 0x01, 0x03, 0x11, 0x13, 0x15 };
 212
 213 static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
 214
 215 static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
 216
 217 static const u16 NCT6779_REG_TOLERANCE_H[]
 218         = { 0x10c, 0x20c, 0x30c, 0x40c, 0x50c };
 219
 220 static const u16 NCT6779_REG_FAN[] = { 0x4c0, 0x4c2, 0x4c4, 0x4c6, 0x4c8 };
 221
 222 static const u16 NCT6775_REG_TEMP[]
 223         = { 0x27, 0x150, 0x250, 0x62b, 0x62c, 0x62d };
 224 static const u16 NCT6779_REG_TEMP[] = { 0x27, 0x150 };
 225 static const u16 NCT6775_REG_TEMP_CONFIG[]
 226         = { 0, 0x152, 0x252, 0x628, 0x629, 0x62A };
 227 static const u16 NCT6775_REG_TEMP_HYST[]
 228         = { 0x3a, 0x153, 0x253, 0x673, 0x678, 0x67D };
 229 static const u16 NCT6775_REG_TEMP_OVER[]
 230         = { 0x39, 0x155, 0x255, 0x672, 0x677, 0x67C };
 231
 232 static const u16 NCT6775_REG_TEMP_SOURCE[]
 233         = { 0x621, 0x622, 0x623, 0x624, 0x625, 0x626 };
 234
 235 static const u16 NCT6775_REG_TEMP_SEL[]
 236         = { 0x100, 0x200, 0x300, 0x800, 0x900 };
 237
 238 static const u16 NCT6775_REG_WEIGHT_TEMP_SEL[]
 239         = { 0x139, 0x239, 0x339, 0x839, 0x939 };
 240 static const u16 NCT6775_REG_WEIGHT_TEMP_STEP[]
 241         = { 0x13a, 0x23a, 0x33a, 0x83a, 0x93a };
 242 static const u16 NCT6775_REG_WEIGHT_TEMP_STEP_TOL[]
 243         = { 0x13b, 0x23b, 0x33b, 0x83b, 0x93b };
 244 static const u16 NCT6775_REG_WEIGHT_DUTY_STEP[]
 245         = { 0x13c, 0x23c, 0x33c, 0x83c, 0x93c };
 246 static const u16 NCT6775_REG_WEIGHT_TEMP_BASE[]
 247         = { 0x13d, 0x23d, 0x33d, 0x83d, 0x93d };
 248
 249 static const u16 NCT6776_REG_WEIGHT_DUTY_BASE[]
 250         = { 0x13e, 0x23e, 0x33e, 0x83e, 0x93e };
 251
 252 static const u16 NCT6775_REG_TEMP_OFFSET[] = { 0x454, 0x455, 0x456 };
 253
 254 static const u16 NCT6776_REG_TEMP_CONFIG[11]
 255         = { 0x18, 0x152, 0x252, 0x628, 0x629, 0x62A };
 256
 257 static const u16 NCT6775_REG_TEMP_MON[] = { 0x73, 0x75, 0x77, 0x79, 0x7b };
 258
 259 static const u16 NCT6775_REG_AUTO_TEMP[]
 260         = { 0x121, 0x221, 0x321, 0x821, 0x921 };
 261 static const u16 NCT6775_REG_AUTO_PWM[]
 262         = { 0x127, 0x227, 0x327, 0x827, 0x927 };
 263
 264 #define NCT6775_AUTO_TEMP(data, nr, p)  ((data)->REG_AUTO_TEMP[nr] + (p))
 265 #define NCT6775_AUTO_PWM(data, nr, p)   ((data)->REG_AUTO_PWM[nr] + (p))
 266
 267 static const u16 NCT6775_REG_CRITICAL_ENAB[] = { 0x134, 0x234, 0x334 };
 268
 269 static const u16 NCT6775_REG_CRITICAL_TEMP[] = {
 270         0x135, 0x235, 0x335, 0x835, 0x935 };
 271 static const u16 NCT6775_REG_CRITICAL_TEMP_TOLERANCE[] = {
 272         0x138, 0x238, 0x338, 0x838, 0x938 };
 273
 274 static const u16 NCT6779_REG_CRITICAL_PWM_ENABLE[] = {
 275         0x136, 0x236, 0x336, 0x836, 0x936 };
 276 static const u16 NCT6779_REG_CRITICAL_PWM[] = {
 277         0x137, 0x237, 0x337, 0x837, 0x937 };
 278
 279 static const char *const nct6775_temp_label[] = {
 280         "",
 281         "SYSTIN",
 282         "CPUTIN",
 283         "AUXTIN",
 284         "AMD SB-TSI",
 285         "PECI Agent 0",
 286         "PECI Agent 1",
 287         "PECI Agent 2",
 288         "PECI Agent 3",
 289         "PECI Agent 4",
 290         "PECI Agent 5",
 291         "PECI Agent 6",
 292         "PECI Agent 7",
 293         "PCH_CHIP_CPU_MAX_TEMP",
 294         "PCH_CHIP_TEMP",
 295         "PCH_CPU_TEMP",
 296         "PCH_MCH_TEMP",
 297         "PCH_DIM0_TEMP",
 298         "PCH_DIM1_TEMP",
 299         "PCH_DIM2_TEMP",
 300         "PCH_DIM3_TEMP"
 301 };
 302
 303 static const char *const nct6776_temp_label[] = {
 304         "",
 305         "SYSTIN",
 306         "CPUTIN",
 307         "AUXTIN",
 308         "SMBUSMASTER 0",
 309         "SMBUSMASTER 1",
 310         "SMBUSMASTER 2",
 311         "SMBUSMASTER 3",
 312         "SMBUSMASTER 4",
 313         "SMBUSMASTER 5",
 314         "SMBUSMASTER 6",
 315         "SMBUSMASTER 7",
 316         "PECI Agent 0",
 317         "PECI Agent 1",
 318         "PCH_CHIP_CPU_MAX_TEMP",
 319         "PCH_CHIP_TEMP",
 320         "PCH_CPU_TEMP",
 321         "PCH_MCH_TEMP",
 322         "PCH_DIM0_TEMP",
 323         "PCH_DIM1_TEMP",
 324         "PCH_DIM2_TEMP",
 325         "PCH_DIM3_TEMP",
 326         "BYTE_TEMP"
 327 };
 328
 329 static const char *const nct6779_temp_label[] = {
 330         "",
 331         "SYSTIN",
 332         "CPUTIN",
 333         "AUXTIN0",
 334         "AUXTIN1",
 335         "AUXTIN2",
 336         "AUXTIN3",
 337         "",
 338         "SMBUSMASTER 0",
 339         "SMBUSMASTER 1",
 340         "SMBUSMASTER 2",
 341         "SMBUSMASTER 3",
 342         "SMBUSMASTER 4",
 343         "SMBUSMASTER 5",
 344         "SMBUSMASTER 6",
 345         "SMBUSMASTER 7",
 346         "PECI Agent 0",
 347         "PECI Agent 1",
 348         "PCH_CHIP_CPU_MAX_TEMP",
 349         "PCH_CHIP_TEMP",
 350         "PCH_CPU_TEMP",
 351         "PCH_MCH_TEMP",
 352         "PCH_DIM0_TEMP",
 353         "PCH_DIM1_TEMP",
 354         "PCH_DIM2_TEMP",
 355         "PCH_DIM3_TEMP",
 356         "BYTE_TEMP"
 357 };
 358
 359 #define NUM_REG_TEMP    ARRAY_SIZE(NCT6775_REG_TEMP)
 360
 361 static inline int reg_to_pwm_enable(int pwm, int mode)
 362 {
 363         if (mode == 0 && pwm == 255)
 364                 return 0;       /* off  */
 365         if (mode == 3)          /* SmartFan III */
 366                 return 2;       /* convert to thermal cruise */
 367         if (mode < 3)
 368                 return mode + 1;
 369         return 4;               /* SmartFan IV */
 370 }
 371
 372 static inline int pwm_enable_to_reg(int mode)
 373 {
 374         if (mode == 0)
 375                 return 0;
 376         if (mode < 4)
 377                 return mode - 1;
 378         return 4;
 379 }
 380
 381 /*
 382  * Conversions
 383  */
 384
 385 /* 1 is DC mode, output in ms */
 386 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
 387 {
 388         return mode ? 400 * reg : 100 * reg;
 389 }
 390
 391 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
 392 {
 393         return SENSORS_LIMIT((mode ? (msec + 200) / 400 :
 394                                         (msec + 50) / 100), 1, 255);
 395 }
 396
 397 static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
 398 {
 399         if (reg == 0 || reg == 255)
 400                 return 0;
 401         return 1350000U / (reg << divreg);
 402 }
 403
 404 static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
 405 {
 406         if ((reg & 0xff1f) == 0xff1f)
 407                 return 0;
 408
 409         reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
 410
 411         if (reg == 0)
 412                 return 0;
 413
 414         return 1350000U / reg;
 415 }
 416
 417 static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
 418 {
 419         if (reg == 0 || reg == 0xffff)
 420                 return 0;
 421
 422         /*
 423          * Even though the registers are 16 bit wide, the fan divisor
 424          * still applies.
 425          */
 426         return 1350000U / (reg << divreg);
 427 }
 428
 429 static inline unsigned int
 430 div_from_reg(u8 reg)
 431 {
 432         return 1 << reg;
 433 }
 434
 435 /*
 436  * Some of the voltage inputs have internal scaling, the tables below
 437  * contain 8 (the ADC LSB in mV) * scaling factor * 100
 438  */
 439 static const u16 scale_in[15] = {
 440         800, 800, 1600, 1600, 800, 800, 800, 1600, 1600, 800, 800, 800, 800,
 441         800, 800
 442 };
 443
 444 static inline long in_from_reg(u8 reg, u8 nr)
 445 {
 446         return DIV_ROUND_CLOSEST(reg * scale_in[nr], 100);
 447 }
 448
 449 static inline u8 in_to_reg(u32 val, u8 nr)
 450 {
 451         return SENSORS_LIMIT(DIV_ROUND_CLOSEST(val * 100, scale_in[nr]), 0,
 452                              255);
 453 }
 454
 455 /*
 456  * Data structures and manipulation thereof
 457  */
 458
 459 struct nct6775_data {
 460         int addr;       /* IO base of hw monitor block */
 461         enum kinds kind;
 462         const char *name;
 463
 464         struct device *hwmon_dev;
 465         struct mutex lock;
 466
 467         u16 reg_temp[3][NUM_REG_TEMP]; /* 0=temp, 1=temp_over, 2=temp_hyst */
 468         u8 temp_src[NUM_REG_TEMP];
 469         u16 reg_temp_config[NUM_REG_TEMP];
 470         const char * const *temp_label;
 471
 472         const u16 *REG_VIN;
 473         const u16 *REG_IN_MINMAX[2];
 474
 475         const u16 *REG_TARGET;
 476         const u16 *REG_FAN;
 477         const u16 *REG_FAN_MODE;
 478         const u16 *REG_FAN_MIN;
 479         const u16 *REG_FAN_TIME[3];
 480
 481         const u8 *REG_PWM_MODE;
 482         const u8 *PWM_MODE_MASK;
 483
 484         const u16 *REG_PWM[3];
 485         const u16 *REG_PWM_READ;
 486
 487         const u16 *REG_TEMP_MON;
 488         const u16 *REG_AUTO_TEMP;
 489         const u16 *REG_AUTO_PWM;
 490
 491         const u16 *REG_CRITICAL_TEMP;
 492         const u16 *REG_CRITICAL_TEMP_TOLERANCE;
 493
 494         const u16 *REG_TEMP_SOURCE;     /* temp register sources */
 495         const u16 *REG_TEMP_SEL[2];     /* pwm temp, 0=base, 1=weight */
 496
 497         const u16 *REG_WEIGHT_TEMP[3];  /* 0=base, 1=hyst, 2=step */
 498         const u16 *REG_WEIGHT_DUTY[2];  /* 0=step, 1=base */
 499
 500         const u16 *REG_TEMP_OFFSET;
 501
 502         const u16 *REG_ALARM;
 503
 504         u8 REG_CASEOPEN;
 505         const u8 *CASEOPEN_MASK;
 506
 507         unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
 508         unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
 509
 510         struct mutex update_lock;
 511         char valid;             /* !=0 if following fields are valid */
 512         unsigned long last_updated;     /* In jiffies */
 513
 514         /* Register values */
 515         u8 bank;                /* current register bank */
 516         u8 in_num;              /* number of in inputs we have */
 517         u8 in[15][3];           /* [0]=in, [1]=in_max, [2]=in_min */
 518         unsigned int rpm[5];
 519         u16 fan_min[5];
 520         u8 fan_div[5];
 521         u8 has_pwm;
 522         u8 has_fan;             /* some fan inputs can be disabled */
 523         u8 has_fan_min;         /* some fans don't have min register */
 524         bool has_fan_div;
 525         u8 temp_type[3];
 526         s8 temp_offset[3];
 527         s16 temp[3][NUM_REG_TEMP]; /* 0=temp, 1=temp_over, 2=temp_hyst */
 528         u64 alarms;
 529         u8 caseopen;
 530
 531         u8 pwm_num;     /* number of pwm */
 532
 533         u8 pwm_mode[5]; /* 1->DC variable voltage, 0->PWM variable duty cycle */
 534         u8 pwm_enable[5]; /* 0->off
 535                            * 1->manual
 536                            * 2->thermal cruise mode (also called SmartFan I)
 537                            * 3->fan speed cruise mode
 538                            * 4->enhanced variable thermal cruise (also called
 539                            *    SmartFan IV)
 540                            */
 541         u8 pwm[3][5];   /* [0]=pwm, [1]=fan_start_output, [2]=fan_stop_output */
 542         u8 target_temp[5];
 543         s16 pwm_temp[5];
 544         u8 tolerance[5][2];
 545
 546         u8 fan_time[3][5]; /* 0 = stop_time, 1 = step_up, 2 = step_down */
 547
 548         /* Automatic fan speed control registers */
 549         int auto_pwm_num;
 550         u8 auto_pwm[5][7];
 551         u8 auto_temp[5][7];
 552
 553         u8 pwm_temp_sel[2][5];
 554
 555         u8 pwm_weight_enable[5]; /* 0->off, 1->on */
 556         u8 weight_temp[3][5];   /* 0->temp_step, 1->temp_step_tol,
 557                                  * 2->temp_base
 558                                  */
 559         u8 weight_duty[2][5];   /* 0->duty_step, 1->duty_base */
 560
 561         u8 vid;
 562         u8 vrm;
 563
 564         u16 have_temp;
 565         u16 have_temp_offset;
 566         u16 have_in;
 567 };
 568
 569 struct nct6775_sio_data {
 570         int sioreg;
 571         enum kinds kind;
 572 };
 573
 574 static bool is_word_sized(struct nct6775_data *data, u16 reg)
 575 {
 576         switch (data->kind) {
 577         case nct6775:
 578         case nct6776:
 579                 return (((reg & 0xff00) == 0x100 ||
 580                     (reg & 0xff00) == 0x200) &&
 581                    ((reg & 0x00ff) == 0x50 ||
 582                     (reg & 0x00ff) == 0x53 ||
 583                     (reg & 0x00ff) == 0x55)) ||
 584                   (reg & 0xfff0) == 0x630 ||
 585                   reg == 0x640 || reg == 0x642 ||
 586                   ((reg & 0xfff0) == 0x650 && (reg & 0x000f) >= 0x06) ||
 587                   reg == 0x73 || reg == 0x75 || reg == 0x77;
 588         case nct6779:
 589                 return reg == 0x150 || reg == 0x153 || reg == 0x155 ||
 590                   ((reg & 0xfff0) == 0x4c0 && (reg & 0x000f) < 0x09) ||
 591                   reg == 0x63a || reg == 0x63c || reg == 0x63e ||
 592                   reg == 0x640 || reg == 0x642 ||
 593                   reg == 0x73 || reg == 0x75 || reg == 0x77 || reg == 0x79 ||
 594                   reg == 0x7b;
 595         }
 596         return false;
 597 }
 598
 599 /*
 600  * On older chips, only registers 0x50-0x5f are banked.
 601  * On more recent chips, all registers are banked.
 602  * Assume that is the case and set the bank number for each access.
 603  * Cache the bank number so it only needs to be set if it changes.
 604  */
 605 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg)
 606 {
 607         u8 bank = reg >> 8;
 608         if (data->bank != bank) {
 609                 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET);
 610                 outb_p(bank, data->addr + DATA_REG_OFFSET);
 611                 data->bank = bank;
 612         }
 613 }
 614
 615 static u16 nct6775_read_value(struct nct6775_data *data, u16 reg)
 616 {
 617         int res, word_sized = is_word_sized(data, reg);
 618
 619         mutex_lock(&data->lock);
 620
 621         nct6775_set_bank(data, reg);
 622         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 623         res = inb_p(data->addr + DATA_REG_OFFSET);
 624         if (word_sized) {
 625                 outb_p((reg & 0xff) + 1,
 626                        data->addr + ADDR_REG_OFFSET);
 627                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
 628         }
 629
 630         mutex_unlock(&data->lock);
 631         return res;
 632 }
 633
 634 static int nct6775_write_value(struct nct6775_data *data, u16 reg,
 635                                  u16 value)
 636 {
 637         int word_sized = is_word_sized(data, reg);
 638
 639         mutex_lock(&data->lock);
 640
 641         nct6775_set_bank(data, reg);
 642         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 643         if (word_sized) {
 644                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
 645                 outb_p((reg & 0xff) + 1,
 646                        data->addr + ADDR_REG_OFFSET);
 647         }
 648         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
 649
 650         mutex_unlock(&data->lock);
 651         return 0;
 652 }
 653
 654 /* We left-align 8-bit temperature values to make the code simpler */
 655 static u16 nct6775_read_temp(struct nct6775_data *data, u16 reg)
 656 {
 657         u16 res;
 658
 659         res = nct6775_read_value(data, reg);
 660         if (!is_word_sized(data, reg))
 661                 res <<= 8;
 662
 663         return res;
 664 }
 665
 666 static int nct6775_write_temp(struct nct6775_data *data, u16 reg,
 667                                        u16 value)
 668 {
 669         if (!is_word_sized(data, reg))
 670                 value >>= 8;
 671         return nct6775_write_value(data, reg, value);
 672 }
 673
 674 /* This function assumes that the caller holds data->update_lock */
 675 static void nct6775_write_fan_div(struct nct6775_data *data, int nr)
 676 {
 677         u8 reg;
 678
 679         switch (nr) {
 680         case 0:
 681                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
 682                     | (data->fan_div[0] & 0x7);
 683                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
 684                 break;
 685         case 1:
 686                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
 687                     | ((data->fan_div[1] << 4) & 0x70);
 688                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
 689         case 2:
 690                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
 691                     | (data->fan_div[2] & 0x7);
 692                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
 693                 break;
 694         case 3:
 695                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
 696                     | ((data->fan_div[3] << 4) & 0x70);
 697                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
 698                 break;
 699         }
 700 }
 701
 702 static void nct6775_write_fan_div_common(struct device *dev,
 703                                            struct nct6775_data *data, int nr)
 704 {
 705         if (data->kind == nct6775)
 706                 nct6775_write_fan_div(data, nr);
 707 }
 708
 709 static void nct6775_update_fan_div(struct nct6775_data *data)
 710 {
 711         u8 i;
 712
 713         i = nct6775_read_value(data, NCT6775_REG_FANDIV1);
 714         data->fan_div[0] = i & 0x7;
 715         data->fan_div[1] = (i & 0x70) >> 4;
 716         i = nct6775_read_value(data, NCT6775_REG_FANDIV2);
 717         data->fan_div[2] = i & 0x7;
 718         if (data->has_fan & (1<<3))
 719                 data->fan_div[3] = (i & 0x70) >> 4;
 720 }
 721
 722 static void nct6775_update_fan_div_common(struct device *dev,
 723                                             struct nct6775_data *data)
 724 {
 725         if (data->kind == nct6775)
 726                 nct6775_update_fan_div(data);
 727 }
 728
 729 static void nct6775_update_pwm(struct device *dev)
 730 {
 731         struct nct6775_data *data = dev_get_drvdata(dev);
 732         int i, j;
 733         int fanmodecfg, reg;
 734         bool duty_is_dc;
 735
 736         for (i = 0; i < data->pwm_num; i++) {
 737                 if (!(data->has_pwm & (1 << i)))
 738                         continue;
 739
 740                 duty_is_dc = data->REG_PWM_MODE[i] &&
 741                   (nct6775_read_value(data, data->REG_PWM_MODE[i])
 742                    & data->PWM_MODE_MASK[i]);
 743                 data->pwm_mode[i] = duty_is_dc;
 744
 745                 fanmodecfg = nct6775_read_value(data, data->REG_FAN_MODE[i]);
 746                 for (j = 0; j < 3; j++)
 747                         data->pwm[j][i]
 748                           = nct6775_read_value(data, data->REG_PWM[j][i]);
 749
 750                 data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],
 751                                                         (fanmodecfg >> 4) & 7);
 752
 753                 data->tolerance[i][0] = fanmodecfg & 0x0f;
 754                 if (data->kind == nct6779) {
 755                         reg = nct6775_read_value(data,
 756                                                  NCT6779_REG_TOLERANCE_H[i]);
 757                         data->tolerance[i][0] |= (reg & 0x70) >> 1;
 758                 }
 759                 data->tolerance[i][1] =
 760                         nct6775_read_value(data,
 761                                         data->REG_CRITICAL_TEMP_TOLERANCE[i]);
 762
 763                 data->pwm_weight_enable[i] =
 764                         nct6775_read_value(data, data->REG_TEMP_SEL[1][i])
 765                                 & 0x80 ? 1 : 0;
 766
 767                 /* Weight data */
 768                 for (j = 0; j < 2; j++) {
 769                         reg = nct6775_read_value(data,
 770                                                  data->REG_TEMP_SEL[j][i]);
 771                         data->pwm_temp_sel[j][i] = reg & 0x1f;
 772                 }
 773                 /* Weight temp data */
 774                 for (j = 0; j < 3; j++) {
 775                         data->weight_temp[j][i]
 776                           = nct6775_read_value(data,
 777                                                data->REG_WEIGHT_TEMP[j][i]);
 778                 }
 779                 /* Weight duty (pwm) data */
 780                 for (j = 0; j < 2; j++) {
 781                         if (!data->REG_WEIGHT_DUTY[j])
 782                                 continue;
 783                         data->weight_duty[j][i]
 784                           = nct6775_read_value(data,
 785                                                data->REG_WEIGHT_DUTY[j][i]);
 786                 }
 787         }
 788 }
 789
 790 static void nct6775_update_pwm_limits(struct device *dev)
 791 {
 792         struct nct6775_data *data = dev_get_drvdata(dev);
 793         int i, j;
 794         u8 reg;
 795
 796         for (i = 0; i < data->pwm_num; i++) {
 797                 if (!(data->has_pwm & (1 << i)))
 798                         continue;
 799
 800                 for (j = 0; j < 3; j++) {
 801                         data->fan_time[j][i] =
 802                           nct6775_read_value(data, data->REG_FAN_TIME[j][i]);
 803                 }
 804
 805                 data->target_temp[i] =
 806                         nct6775_read_value(data, data->REG_TARGET[i]) &
 807                                         (data->pwm_mode[i] ? 0xff : 0x7f);
 808                 data->pwm_temp[i] =
 809                         nct6775_read_value(data, data->REG_TEMP_MON[i]);
 810
 811                 for (j = 0; j < data->auto_pwm_num; j++) {
 812                         data->auto_pwm[i][j] =
 813                           nct6775_read_value(data,
 814                                              NCT6775_AUTO_PWM(data, i, j));
 815                         data->auto_temp[i][j] =
 816                           nct6775_read_value(data,
 817                                              NCT6775_AUTO_TEMP(data, i, j));
 818                 }
 819
 820                 /* critical auto_pwm temperature data */
 821                 data->auto_temp[i][data->auto_pwm_num] =
 822                         nct6775_read_value(data, data->REG_CRITICAL_TEMP[i]);
 823
 824                 switch (data->kind) {
 825                 case nct6775:
 826                         reg = nct6775_read_value(data,
 827                                                  NCT6775_REG_CRITICAL_ENAB[i]);
 828                         data->auto_pwm[i][data->auto_pwm_num] =
 829                                                 (reg & 0x02) ? 0xff : 0x00;
 830                         break;
 831                 case nct6776:
 832                         data->auto_pwm[i][data->auto_pwm_num] = 0xff;
 833                         break;
 834                 case nct6779:
 835                         reg = nct6775_read_value(data,
 836                                         NCT6779_REG_CRITICAL_PWM_ENABLE[i]);
 837                         if (reg & 1)
 838                                 data->auto_pwm[i][data->auto_pwm_num] =
 839                                   nct6775_read_value(data,
 840                                         NCT6779_REG_CRITICAL_PWM[i]);
 841                         else
 842                                 data->auto_pwm[i][data->auto_pwm_num] = 0xff;
 843                         break;
 844                 }
 845         }
 846 }
 847
 848 static struct nct6775_data *nct6775_update_device(struct device *dev)
 849 {
 850         struct nct6775_data *data = dev_get_drvdata(dev);
 851         int i, j;
 852
 853         mutex_lock(&data->update_lock);
 854
 855         if (time_after(jiffies, data->last_updated + HZ + HZ/2)
 856          || !data->valid) {
 857                 /* Fan clock dividers */
 858                 nct6775_update_fan_div_common(dev, data);
 859
 860                 /* Measured voltages and limits */
 861                 for (i = 0; i < data->in_num; i++) {
 862                         if (!(data->have_in & (1 << i)))
 863                                 continue;
 864
 865                         data->in[i][0] = nct6775_read_value(data,
 866                                                             data->REG_VIN[i]);
 867                         data->in[i][1] = nct6775_read_value(data,
 868                                           data->REG_IN_MINMAX[0][i]);
 869                         data->in[i][2] = nct6775_read_value(data,
 870                                           data->REG_IN_MINMAX[1][i]);
 871                 }
 872
 873                 /* Measured fan speeds and limits */
 874                 for (i = 0; i < 5; i++) {
 875                         u16 reg;
 876
 877                         if (!(data->has_fan & (1 << i)))
 878                                 continue;
 879
 880                         reg = nct6775_read_value(data, data->REG_FAN[i]);
 881                         data->rpm[i] = data->fan_from_reg(reg,
 882                                                           data->fan_div[i]);
 883
 884                         if (data->has_fan_min & (1 << i))
 885                                 data->fan_min[i] = nct6775_read_value(data,
 886                                            data->REG_FAN_MIN[i]);
 887
 888                         /*
 889                          * If we failed to measure the fan speed and clock
 890                          * divider can be increased, let's try that for next
 891                          * time
 892                          */
 893                         if (data->has_fan_div
 894                             && (reg >= 0xff || (data->kind == nct6775
 895                                                 && reg == 0x00))
 896                             && data->fan_div[i] < 0x07) {
 897                                 dev_dbg(dev, "Increasing fan%d "
 898                                         "clock divider from %u to %u\n",
 899                                         i + 1, div_from_reg(data->fan_div[i]),
 900                                         div_from_reg(data->fan_div[i] + 1));
 901                                 data->fan_div[i]++;
 902                                 nct6775_write_fan_div_common(dev, data, i);
 903                                 /* Preserve min limit if possible */
 904                                 if ((data->has_fan_min & (1 << i))
 905                                  && data->fan_min[i] >= 2
 906                                  && data->fan_min[i] != 255)
 907                                         nct6775_write_value(data,
 908                                                 data->REG_FAN_MIN[i],
 909                                                 (data->fan_min[i] /= 2));
 910                         }
 911                 }
 912
 913                 nct6775_update_pwm(dev);
 914                 nct6775_update_pwm_limits(dev);
 915
 916                 /* Measured temperatures and limits */
 917                 for (i = 0; i < NUM_REG_TEMP; i++) {
 918                         if (!(data->have_temp & (1 << i)))
 919                                 continue;
 920                         for (j = 0; j < 3; j++) {
 921                                 if (data->reg_temp[j][i])
 922                                         data->temp[j][i]
 923                                           = nct6775_read_temp(data,
 924                                                 data->reg_temp[j][i]);
 925                         }
 926                         if (!(data->have_temp_offset & (1 << i)))
 927                                 continue;
 928                         data->temp_offset[i]
 929                           = nct6775_read_value(data, data->REG_TEMP_OFFSET[i]);
 930                 }
 931
 932                 data->alarms = 0;
 933                 for (i = 0; i < 6; i++) {
 934                         u8 alarm;
 935                         if (!data->REG_ALARM[i])
 936                                 continue;
 937                         alarm = nct6775_read_value(data, data->REG_ALARM[i]);
 938                         data->alarms |= (((u64)alarm) << (i << 3));
 939                 }
 940
 941                 data->caseopen = nct6775_read_value(data, data->REG_CASEOPEN);
 942
 943                 data->last_updated = jiffies;
 944                 data->valid = 1;
 945         }
 946
 947         mutex_unlock(&data->update_lock);
 948         return data;
 949 }
 950
 951 /*
 952  * Sysfs callback functions
 953  */
 954 static ssize_t
 955 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
 956 {
 957         struct nct6775_data *data = nct6775_update_device(dev);
 958         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 959         int nr = sattr->nr;
 960         int index = sattr->index;
 961         return sprintf(buf, "%ld\n", in_from_reg(data->in[nr][index], nr));
 962 }
 963
 964 static ssize_t
 965 store_in_reg(struct device *dev, struct device_attribute *attr, const char *buf,
 966              size_t count)
 967 {
 968         struct nct6775_data *data = dev_get_drvdata(dev);
 969         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 970         int nr = sattr->nr;
 971         int index = sattr->index;
 972         unsigned long val;
 973         int err = kstrtoul(buf, 10, &val);
 974         if (err < 0)
 975                 return err;
 976         mutex_lock(&data->update_lock);
 977         data->in[nr][index] = in_to_reg(val, nr);
 978         nct6775_write_value(data, data->REG_IN_MINMAX[index-1][nr],
 979                             data->in[nr][index]);
 980         mutex_unlock(&data->update_lock);
 981         return count;
 982 }
 983
 984 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 985                           char *buf)
 986 {
 987         struct nct6775_data *data = nct6775_update_device(dev);
 988         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 989         int nr = sensor_attr->index;
 990         return sprintf(buf, "%u\n",
 991                        (unsigned int)((data->alarms >> nr) & 0x01));
 992 }
 993
 994 static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, show_in_reg, NULL, 0, 0);
 995 static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_in_reg, NULL, 1, 0);
 996 static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_in_reg, NULL, 2, 0);
 997 static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, show_in_reg, NULL, 3, 0);
 998 static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, show_in_reg, NULL, 4, 0);
 999 static SENSOR_DEVICE_ATTR_2(in5_input, S_IRUGO, show_in_reg, NULL, 5, 0);
1000 static SENSOR_DEVICE_ATTR_2(in6_input, S_IRUGO, show_in_reg, NULL, 6, 0);
1001 static SENSOR_DEVICE_ATTR_2(in7_input, S_IRUGO, show_in_reg, NULL, 7, 0);
1002 static SENSOR_DEVICE_ATTR_2(in8_input, S_IRUGO, show_in_reg, NULL, 8, 0);
1003 static SENSOR_DEVICE_ATTR_2(in9_input, S_IRUGO, show_in_reg, NULL, 9, 0);
1004 static SENSOR_DEVICE_ATTR_2(in10_input, S_IRUGO, show_in_reg, NULL, 10, 0);
1005 static SENSOR_DEVICE_ATTR_2(in11_input, S_IRUGO, show_in_reg, NULL, 11, 0);
1006 static SENSOR_DEVICE_ATTR_2(in12_input, S_IRUGO, show_in_reg, NULL, 12, 0);
1007 static SENSOR_DEVICE_ATTR_2(in13_input, S_IRUGO, show_in_reg, NULL, 13, 0);
1008 static SENSOR_DEVICE_ATTR_2(in14_input, S_IRUGO, show_in_reg, NULL, 14, 0);
1009
1010 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
1011 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
1012 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
1013 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
1014 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
1015 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21);
1016 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20);
1017 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
1018 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
1019 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 24);
1020 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 25);
1021 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL, 26);
1022 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL, 27);
1023 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL, 28);
1024 static SENSOR_DEVICE_ATTR(in14_alarm, S_IRUGO, show_alarm, NULL, 29);
1025
1026 static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR | S_IRUGO, show_in_reg,
1027                             store_in_reg, 0, 1);
1028 static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR | S_IRUGO, show_in_reg,
1029                             store_in_reg, 1, 1);
1030 static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR | S_IRUGO, show_in_reg,
1031                             store_in_reg, 2, 1);
1032 static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR | S_IRUGO, show_in_reg,
1033                             store_in_reg, 3, 1);
1034 static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR | S_IRUGO, show_in_reg,
1035                             store_in_reg, 4, 1);
1036 static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR | S_IRUGO, show_in_reg,
1037                             store_in_reg, 5, 1);
1038 static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR | S_IRUGO, show_in_reg,
1039                             store_in_reg, 6, 1);
1040 static SENSOR_DEVICE_ATTR_2(in7_min, S_IWUSR | S_IRUGO, show_in_reg,
1041                             store_in_reg, 7, 1);
1042 static SENSOR_DEVICE_ATTR_2(in8_min, S_IWUSR | S_IRUGO, show_in_reg,
1043                             store_in_reg, 8, 1);
1044 static SENSOR_DEVICE_ATTR_2(in9_min, S_IWUSR | S_IRUGO, show_in_reg,
1045                             store_in_reg, 9, 1);
1046 static SENSOR_DEVICE_ATTR_2(in10_min, S_IWUSR | S_IRUGO, show_in_reg,
1047                             store_in_reg, 10, 1);
1048 static SENSOR_DEVICE_ATTR_2(in11_min, S_IWUSR | S_IRUGO, show_in_reg,
1049                             store_in_reg, 11, 1);
1050 static SENSOR_DEVICE_ATTR_2(in12_min, S_IWUSR | S_IRUGO, show_in_reg,
1051                             store_in_reg, 12, 1);
1052 static SENSOR_DEVICE_ATTR_2(in13_min, S_IWUSR | S_IRUGO, show_in_reg,
1053                             store_in_reg, 13, 1);
1054 static SENSOR_DEVICE_ATTR_2(in14_min, S_IWUSR | S_IRUGO, show_in_reg,
1055                             store_in_reg, 14, 1);
1056
1057 static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR | S_IRUGO, show_in_reg,
1058                           store_in_reg, 0, 2);
1059 static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR | S_IRUGO, show_in_reg,
1060                           store_in_reg, 1, 2);
1061 static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR | S_IRUGO, show_in_reg,
1062                           store_in_reg, 2, 2);
1063 static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR | S_IRUGO, show_in_reg,
1064                           store_in_reg, 3, 2);
1065 static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR | S_IRUGO, show_in_reg,
1066                           store_in_reg, 4, 2);
1067 static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR | S_IRUGO, show_in_reg,
1068                           store_in_reg, 5, 2);
1069 static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR | S_IRUGO, show_in_reg,
1070                           store_in_reg, 6, 2);
1071 static SENSOR_DEVICE_ATTR_2(in7_max, S_IWUSR | S_IRUGO, show_in_reg,
1072                           store_in_reg, 7, 2);
1073 static SENSOR_DEVICE_ATTR_2(in8_max, S_IWUSR | S_IRUGO, show_in_reg,
1074                           store_in_reg, 8, 2);
1075 static SENSOR_DEVICE_ATTR_2(in9_max, S_IWUSR | S_IRUGO, show_in_reg,
1076                           store_in_reg, 9, 2);
1077 static SENSOR_DEVICE_ATTR_2(in10_max, S_IWUSR | S_IRUGO, show_in_reg,
1078                           store_in_reg, 10, 2);
1079 static SENSOR_DEVICE_ATTR_2(in11_max, S_IWUSR | S_IRUGO, show_in_reg,
1080                           store_in_reg, 11, 2);
1081 static SENSOR_DEVICE_ATTR_2(in12_max, S_IWUSR | S_IRUGO, show_in_reg,
1082                           store_in_reg, 12, 2);
1083 static SENSOR_DEVICE_ATTR_2(in13_max, S_IWUSR | S_IRUGO, show_in_reg,
1084                           store_in_reg, 13, 2);
1085 static SENSOR_DEVICE_ATTR_2(in14_max, S_IWUSR | S_IRUGO, show_in_reg,
1086                           store_in_reg, 14, 2);
1087
1088 static struct attribute *nct6775_attributes_in[15][5] = {
1089         {
1090                 &sensor_dev_attr_in0_input.dev_attr.attr,
1091                 &sensor_dev_attr_in0_min.dev_attr.attr,
1092                 &sensor_dev_attr_in0_max.dev_attr.attr,
1093                 &sensor_dev_attr_in0_alarm.dev_attr.attr,
1094                 NULL
1095         },
1096         {
1097                 &sensor_dev_attr_in1_input.dev_attr.attr,
1098                 &sensor_dev_attr_in1_min.dev_attr.attr,
1099                 &sensor_dev_attr_in1_max.dev_attr.attr,
1100                 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1101                 NULL
1102         },
1103         {
1104                 &sensor_dev_attr_in2_input.dev_attr.attr,
1105                 &sensor_dev_attr_in2_min.dev_attr.attr,
1106                 &sensor_dev_attr_in2_max.dev_attr.attr,
1107                 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1108                 NULL
1109         },
1110         {
1111                 &sensor_dev_attr_in3_input.dev_attr.attr,
1112                 &sensor_dev_attr_in3_min.dev_attr.attr,
1113                 &sensor_dev_attr_in3_max.dev_attr.attr,
1114                 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1115                 NULL
1116         },
1117         {
1118                 &sensor_dev_attr_in4_input.dev_attr.attr,
1119                 &sensor_dev_attr_in4_min.dev_attr.attr,
1120                 &sensor_dev_attr_in4_max.dev_attr.attr,
1121                 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1122                 NULL
1123         },
1124         {
1125                 &sensor_dev_attr_in5_input.dev_attr.attr,
1126                 &sensor_dev_attr_in5_min.dev_attr.attr,
1127                 &sensor_dev_attr_in5_max.dev_attr.attr,
1128                 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1129                 NULL
1130         },
1131         {
1132                 &sensor_dev_attr_in6_input.dev_attr.attr,
1133                 &sensor_dev_attr_in6_min.dev_attr.attr,
1134                 &sensor_dev_attr_in6_max.dev_attr.attr,
1135                 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1136                 NULL
1137         },
1138         {
1139                 &sensor_dev_attr_in7_input.dev_attr.attr,
1140                 &sensor_dev_attr_in7_min.dev_attr.attr,
1141                 &sensor_dev_attr_in7_max.dev_attr.attr,
1142                 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1143                 NULL
1144         },
1145         {
1146                 &sensor_dev_attr_in8_input.dev_attr.attr,
1147                 &sensor_dev_attr_in8_min.dev_attr.attr,
1148                 &sensor_dev_attr_in8_max.dev_attr.attr,
1149                 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1150                 NULL
1151         },
1152         {
1153                 &sensor_dev_attr_in9_input.dev_attr.attr,
1154                 &sensor_dev_attr_in9_min.dev_attr.attr,
1155                 &sensor_dev_attr_in9_max.dev_attr.attr,
1156                 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1157                 NULL
1158         },
1159         {
1160                 &sensor_dev_attr_in10_input.dev_attr.attr,
1161                 &sensor_dev_attr_in10_min.dev_attr.attr,
1162                 &sensor_dev_attr_in10_max.dev_attr.attr,
1163                 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1164                 NULL
1165         },
1166         {
1167                 &sensor_dev_attr_in11_input.dev_attr.attr,
1168                 &sensor_dev_attr_in11_min.dev_attr.attr,
1169                 &sensor_dev_attr_in11_max.dev_attr.attr,
1170                 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1171                 NULL
1172         },
1173         {
1174                 &sensor_dev_attr_in12_input.dev_attr.attr,
1175                 &sensor_dev_attr_in12_min.dev_attr.attr,
1176                 &sensor_dev_attr_in12_max.dev_attr.attr,
1177                 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1178                 NULL
1179         },
1180         {
1181                 &sensor_dev_attr_in13_input.dev_attr.attr,
1182                 &sensor_dev_attr_in13_min.dev_attr.attr,
1183                 &sensor_dev_attr_in13_max.dev_attr.attr,
1184                 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1185                 NULL
1186         },
1187         {
1188                 &sensor_dev_attr_in14_input.dev_attr.attr,
1189                 &sensor_dev_attr_in14_min.dev_attr.attr,
1190                 &sensor_dev_attr_in14_max.dev_attr.attr,
1191                 &sensor_dev_attr_in14_alarm.dev_attr.attr,
1192                 NULL
1193         },
1194 };
1195
1196 static const struct attribute_group nct6775_group_in[15] = {
1197         { .attrs = nct6775_attributes_in[0] },
1198         { .attrs = nct6775_attributes_in[1] },
1199         { .attrs = nct6775_attributes_in[2] },
1200         { .attrs = nct6775_attributes_in[3] },
1201         { .attrs = nct6775_attributes_in[4] },
1202         { .attrs = nct6775_attributes_in[5] },
1203         { .attrs = nct6775_attributes_in[6] },
1204         { .attrs = nct6775_attributes_in[7] },
1205         { .attrs = nct6775_attributes_in[8] },
1206         { .attrs = nct6775_attributes_in[9] },
1207         { .attrs = nct6775_attributes_in[10] },
1208         { .attrs = nct6775_attributes_in[11] },
1209         { .attrs = nct6775_attributes_in[12] },
1210         { .attrs = nct6775_attributes_in[13] },
1211         { .attrs = nct6775_attributes_in[14] },
1212 };
1213
1214 static ssize_t
1215 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
1216 {
1217         struct nct6775_data *data = nct6775_update_device(dev);
1218         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1219         int nr = sensor_attr->index;
1220         return sprintf(buf, "%d\n", data->rpm[nr]);
1221 }
1222
1223 static ssize_t
1224 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
1225 {
1226         struct nct6775_data *data = nct6775_update_device(dev);
1227         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1228         int nr = sensor_attr->index;
1229         return sprintf(buf, "%d\n",
1230                        data->fan_from_reg_min(data->fan_min[nr],
1231                                               data->fan_div[nr]));
1232 }
1233
1234 static ssize_t
1235 show_fan_div(struct device *dev, struct device_attribute *attr,
1236              char *buf)
1237 {
1238         struct nct6775_data *data = nct6775_update_device(dev);
1239         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1240         int nr = sensor_attr->index;
1241         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1242 }
1243
1244 static ssize_t
1245 store_fan_min(struct device *dev, struct device_attribute *attr,
1246               const char *buf, size_t count)
1247 {
1248         struct nct6775_data *data = dev_get_drvdata(dev);
1249         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1250         int nr = sensor_attr->index;
1251         unsigned long val;
1252         int err;
1253         unsigned int reg;
1254         u8 new_div;
1255
1256         err = kstrtoul(buf, 10, &val);
1257         if (err < 0)
1258                 return err;
1259
1260         mutex_lock(&data->update_lock);
1261         if (!data->has_fan_div) {
1262                 /*
1263                  * Only NCT6776F for now, so we know that this is a 13 bit
1264                  * register
1265                  */
1266                 if (!val) {
1267                         val = 0xff1f;
1268                 } else {
1269                         if (val > 1350000U)
1270                                 val = 135000U;
1271                         val = 1350000U / val;
1272                         val = (val & 0x1f) | ((val << 3) & 0xff00);
1273                 }
1274                 data->fan_min[nr] = val;
1275                 goto write_min; /* Leave fan divider alone */
1276         }
1277         if (!val) {
1278                 /* No min limit, alarm disabled */
1279                 data->fan_min[nr] = 255;
1280                 new_div = data->fan_div[nr]; /* No change */
1281                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
1282                 goto write_div;
1283         }
1284         reg = 1350000U / val;
1285         if (reg >= 128 * 255) {
1286                 /*
1287                  * Speed below this value cannot possibly be represented,
1288                  * even with the highest divider (128)
1289                  */
1290                 data->fan_min[nr] = 254;
1291                 new_div = 7; /* 128 == (1 << 7) */
1292                 dev_warn(dev, "fan%u low limit %lu below minimum %u, set to "
1293                          "minimum\n", nr + 1, val,
1294                          data->fan_from_reg_min(254, 7));
1295         } else if (!reg) {
1296                 /*
1297                  * Speed above this value cannot possibly be represented,
1298                  * even with the lowest divider (1)
1299                  */
1300                 data->fan_min[nr] = 1;
1301                 new_div = 0; /* 1 == (1 << 0) */
1302                 dev_warn(dev, "fan%u low limit %lu above maximum %u, set to "
1303                          "maximum\n", nr + 1, val,
1304                          data->fan_from_reg_min(1, 0));
1305         } else {
1306                 /*
1307                  * Automatically pick the best divider, i.e. the one such
1308                  * that the min limit will correspond to a register value
1309                  * in the 96..192 range
1310                  */
1311                 new_div = 0;
1312                 while (reg > 192 && new_div < 7) {
1313                         reg >>= 1;
1314                         new_div++;
1315                 }
1316                 data->fan_min[nr] = reg;
1317         }
1318
1319 write_div:
1320         /*
1321          * Write both the fan clock divider (if it changed) and the new
1322          * fan min (unconditionally)
1323          */
1324         if (new_div != data->fan_div[nr]) {
1325                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1326                         nr + 1, div_from_reg(data->fan_div[nr]),
1327                         div_from_reg(new_div));
1328                 data->fan_div[nr] = new_div;
1329                 nct6775_write_fan_div_common(dev, data, nr);
1330                 /* Give the chip time to sample a new speed value */
1331                 data->last_updated = jiffies;
1332         }
1333 write_min:
1334         nct6775_write_value(data, data->REG_FAN_MIN[nr],
1335                               data->fan_min[nr]);
1336         mutex_unlock(&data->update_lock);
1337
1338         return count;
1339 }
1340
1341 static struct sensor_device_attribute sda_fan_input[] = {
1342         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
1343         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
1344         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
1345         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
1346         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
1347 };
1348
1349 static struct sensor_device_attribute sda_fan_alarm[] = {
1350         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
1351         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
1352         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
1353         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
1354         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
1355 };
1356
1357 static struct sensor_device_attribute sda_fan_min[] = {
1358         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1359                     store_fan_min, 0),
1360         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1361                     store_fan_min, 1),
1362         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1363                     store_fan_min, 2),
1364         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1365                     store_fan_min, 3),
1366         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1367                     store_fan_min, 4),
1368 };
1369
1370 static struct sensor_device_attribute sda_fan_div[] = {
1371         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
1372         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
1373         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
1374         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
1375         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
1376 };
1377
1378 static ssize_t
1379 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
1380 {
1381         struct nct6775_data *data = nct6775_update_device(dev);
1382         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1383         int nr = sensor_attr->index;
1384         return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
1385 }
1386
1387 static ssize_t
1388 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
1389 {
1390         struct nct6775_data *data = nct6775_update_device(dev);
1391         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1392         int nr = sattr->nr;
1393         int index = sattr->index;
1394
1395         return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->temp[index][nr]));
1396 }
1397
1398 static ssize_t
1399 store_temp(struct device *dev, struct device_attribute *attr, const char *buf,
1400            size_t count)
1401 {
1402         struct nct6775_data *data = dev_get_drvdata(dev);
1403         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1404         int nr = sattr->nr;
1405         int index = sattr->index;
1406         int err;
1407         long val;
1408
1409         err = kstrtol(buf, 10, &val);
1410         if (err < 0)
1411                 return err;
1412
1413         mutex_lock(&data->update_lock);
1414         data->temp[index][nr] = LM75_TEMP_TO_REG(val);
1415         nct6775_write_temp(data, data->reg_temp[index][nr],
1416                            data->temp[index][nr]);
1417         mutex_unlock(&data->update_lock);
1418         return count;
1419 }
1420
1421 static ssize_t
1422 show_temp_offset(struct device *dev, struct device_attribute *attr, char *buf)
1423 {
1424         struct nct6775_data *data = nct6775_update_device(dev);
1425         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1426
1427         return sprintf(buf, "%d\n", data->temp_offset[sensor_attr->index] * 1000);
1428 }
1429
1430 static ssize_t
1431 store_temp_offset(struct device *dev, struct device_attribute *attr,
1432                   const char *buf, size_t count)
1433 {
1434         struct nct6775_data *data = dev_get_drvdata(dev);
1435         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1436         int nr = sensor_attr->index;
1437         long val;
1438         int err;
1439
1440         err = kstrtol(buf, 10, &val);
1441         if (err < 0)
1442                 return err;
1443
1444         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
1445
1446         mutex_lock(&data->update_lock);
1447         data->temp_offset[nr] = val;
1448         nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val);
1449         mutex_unlock(&data->update_lock);
1450
1451         return count;
1452 }
1453
1454 static ssize_t
1455 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
1456 {
1457         struct nct6775_data *data = nct6775_update_device(dev);
1458         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1459         int nr = sensor_attr->index;
1460         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
1461 }
1462
1463 static struct sensor_device_attribute_2 sda_temp_input[] = {
1464         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0),
1465         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 1, 0),
1466         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 2, 0),
1467         SENSOR_ATTR_2(temp4_input, S_IRUGO, show_temp, NULL, 3, 0),
1468         SENSOR_ATTR_2(temp5_input, S_IRUGO, show_temp, NULL, 4, 0),
1469         SENSOR_ATTR_2(temp6_input, S_IRUGO, show_temp, NULL, 5, 0),
1470 };
1471
1472 static struct sensor_device_attribute sda_temp_label[] = {
1473         SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
1474         SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
1475         SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
1476         SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
1477         SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
1478         SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
1479 };
1480
1481 static struct sensor_device_attribute_2 sda_temp_max[] = {
1482         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1483                       0, 1),
1484         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1485                       1, 1),
1486         SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1487                       2, 1),
1488         SENSOR_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1489                       3, 1),
1490         SENSOR_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1491                       4, 1),
1492         SENSOR_ATTR_2(temp6_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1493                       5, 1),
1494 };
1495
1496 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
1497         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1498                       0, 2),
1499         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1500                       1, 2),
1501         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1502                       2, 2),
1503         SENSOR_ATTR_2(temp4_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1504                       3, 2),
1505         SENSOR_ATTR_2(temp5_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1506                       4, 2),
1507         SENSOR_ATTR_2(temp6_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1508                       5, 2),
1509 };
1510
1511 static struct sensor_device_attribute sda_temp_offset[] = {
1512         SENSOR_ATTR(temp1_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1513                     store_temp_offset, 0),
1514         SENSOR_ATTR(temp2_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1515                     store_temp_offset, 1),
1516         SENSOR_ATTR(temp3_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1517                     store_temp_offset, 2),
1518 };
1519
1520 static struct sensor_device_attribute sda_temp_alarm[] = {
1521         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
1522         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1523         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1524 };
1525
1526 static struct sensor_device_attribute sda_temp_type[] = {
1527         SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
1528         SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
1529         SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
1530 };
1531
1532 static ssize_t
1533 show_pwm_mode(struct device *dev, struct device_attribute *attr, char *buf)
1534 {
1535         struct nct6775_data *data = nct6775_update_device(dev);
1536         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1537
1538         return sprintf(buf, "%d\n", !data->pwm_mode[sensor_attr->index]);
1539 }
1540
1541 static ssize_t
1542 store_pwm_mode(struct device *dev, struct device_attribute *attr,
1543                         const char *buf, size_t count)
1544 {
1545         struct nct6775_data *data = dev_get_drvdata(dev);
1546         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1547         int nr = sensor_attr->index;
1548         unsigned long val;
1549         int err;
1550         u8 reg;
1551
1552         err = kstrtoul(buf, 10, &val);
1553         if (err < 0)
1554                 return err;
1555
1556         if (val > 1)
1557                 return -EINVAL;
1558
1559         /* Setting DC mode is not supported for all chips/channels */
1560         if (data->REG_PWM_MODE[nr] == 0) {
1561                 if (val)
1562                         return -EINVAL;
1563                 return count;
1564         }
1565
1566         mutex_lock(&data->update_lock);
1567         data->pwm_mode[nr] = val;
1568         reg = nct6775_read_value(data, data->REG_PWM_MODE[nr]);
1569         reg &= ~data->PWM_MODE_MASK[nr];
1570         if (val)
1571                 reg |= data->PWM_MODE_MASK[nr];
1572         nct6775_write_value(data, data->REG_PWM_MODE[nr], reg);
1573         mutex_unlock(&data->update_lock);
1574         return count;
1575 }
1576
1577 static ssize_t
1578 show_pwm_enable(struct device *dev, struct device_attribute *attr, char *buf)
1579 {
1580         struct nct6775_data *data = nct6775_update_device(dev);
1581         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1582
1583         return sprintf(buf, "%d\n", data->pwm_enable[sensor_attr->index]);
1584 }
1585
1586 static ssize_t
1587 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
1588 {
1589         struct nct6775_data *data = nct6775_update_device(dev);
1590         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1591         int nr = sattr->nr;
1592         int index = sattr->index;
1593         int pwm;
1594
1595         /*
1596          * For automatic fan control modes, show current pwm readings.
1597          * Otherwise, show the configured value.
1598          */
1599         if (index == 0 && data->pwm_enable[nr] > 1)
1600                 pwm = nct6775_read_value(data, data->REG_PWM_READ[nr]);
1601         else
1602                 pwm = data->pwm[index][nr];
1603
1604         return sprintf(buf, "%d\n", pwm);
1605 }
1606
1607 static ssize_t
1608 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
1609           size_t count)
1610 {
1611         struct nct6775_data *data = dev_get_drvdata(dev);
1612         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1613         int nr = sattr->nr;
1614         int index = sattr->index;
1615         unsigned long val;
1616         int err;
1617
1618         err = kstrtoul(buf, 10, &val);
1619         if (err < 0)
1620                 return err;
1621         if (val > 255 || (index && val == 0))
1622                 return -EINVAL;
1623
1624         mutex_lock(&data->update_lock);
1625         data->pwm[index][nr] = val;
1626         nct6775_write_value(data, data->REG_PWM[index][nr], val);
1627         mutex_unlock(&data->update_lock);
1628         return count;
1629 }
1630
1631 /* Returns 0 if OK, -EINVAL otherwise */
1632 static int check_trip_points(struct nct6775_data *data, int nr)
1633 {
1634         int i;
1635
1636         for (i = 0; i < data->auto_pwm_num - 1; i++) {
1637                 if (data->auto_temp[nr][i] > data->auto_temp[nr][i + 1])
1638                         return -EINVAL;
1639         }
1640         for (i = 0; i < data->auto_pwm_num - 1; i++) {
1641                 if (data->auto_pwm[nr][i] > data->auto_pwm[nr][i + 1])
1642                         return -EINVAL;
1643         }
1644         /* validate critical temperature and pwm if enabled (pwm > 0) */
1645         if (data->auto_pwm[nr][data->auto_pwm_num]) {
1646                 if (data->auto_temp[nr][data->auto_pwm_num - 1] >
1647                                 data->auto_temp[nr][data->auto_pwm_num] ||
1648                     data->auto_pwm[nr][data->auto_pwm_num - 1] >
1649                                 data->auto_pwm[nr][data->auto_pwm_num])
1650                         return -EINVAL;
1651         }
1652         return 0;
1653 }
1654
1655 static ssize_t
1656 store_pwm_enable(struct device *dev, struct device_attribute *attr,
1657                  const char *buf, size_t count)
1658 {
1659         struct nct6775_data *data = dev_get_drvdata(dev);
1660         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1661         int nr = sensor_attr->index;
1662         unsigned long val;
1663         int err;
1664         u16 reg;
1665
1666         err = kstrtoul(buf, 10, &val);
1667         if (err < 0)
1668                 return err;
1669
1670         if (val > 4)
1671                 return -EINVAL;
1672
1673         if (val == 4 && check_trip_points(data, nr)) {
1674                 dev_err(dev, "Inconsistent trip points, not switching to SmartFan IV mode\n");
1675                 dev_err(dev, "Adjust trip points and try again\n");
1676                 return -EINVAL;
1677         }
1678
1679         mutex_lock(&data->update_lock);
1680         data->pwm_enable[nr] = val;
1681         if (!val) {
1682                 /*
1683                  * turn off pwm control: select manual mode, set pwm to maximum
1684                  */
1685                 data->pwm[0][nr] = 255;
1686                 nct6775_write_value(data, data->REG_PWM[0][nr], 255);
1687         }
1688         reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
1689         reg &= 0x0f;
1690         reg |= (pwm_enable_to_reg(val) << 4);
1691         nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
1692         mutex_unlock(&data->update_lock);
1693         return count;
1694 }
1695
1696 static ssize_t
1697 show_pwm_temp(struct device *dev, struct device_attribute *attr, char *buf)
1698 {
1699         struct nct6775_data *data = nct6775_update_device(dev);
1700         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1701         int nr = sattr->index;
1702
1703         return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->pwm_temp[nr]));
1704 }
1705
1706 static ssize_t
1707 show_pwm_temp_sel(struct device *dev, struct device_attribute *attr, char *buf)
1708 {
1709         struct nct6775_data *data = nct6775_update_device(dev);
1710         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1711
1712         return sprintf(buf, "%d\n",
1713                        data->pwm_temp_sel[sattr->index][sattr->nr]);
1714 }
1715
1716 static ssize_t
1717 store_pwm_temp_sel(struct device *dev, struct device_attribute *attr,
1718                    const char *buf, size_t count)
1719 {
1720         struct nct6775_data *data = nct6775_update_device(dev);
1721         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1722         int nr = sattr->nr;
1723         int index = sattr->index;
1724         unsigned long val;
1725         int err;
1726         int reg;
1727         static const int max_src[] = {
1728             ARRAY_SIZE(nct6775_temp_label),
1729             ARRAY_SIZE(nct6776_temp_label),
1730             ARRAY_SIZE(nct6779_temp_label)
1731         };
1732
1733         err = kstrtoul(buf, 10, &val);
1734         if (err < 0)
1735                 return err;
1736         if (val == 0 || val > 0x1f)
1737                 return -EINVAL;
1738
1739         val = SENSORS_LIMIT(val, 1, max_src[data->kind]);
1740
1741         if (!strlen(data->temp_label[val]))
1742                 return -EINVAL;
1743
1744         mutex_lock(&data->update_lock);
1745         data->pwm_temp_sel[index][nr] = val;
1746         reg = nct6775_read_value(data, data->REG_TEMP_SEL[index][nr]);
1747         reg &= 0xe0;
1748         reg |= val;
1749         nct6775_write_value(data, data->REG_TEMP_SEL[index][nr], reg);
1750         mutex_unlock(&data->update_lock);
1751
1752         return count;
1753 }
1754
1755 static ssize_t
1756 show_target_temp(struct device *dev, struct device_attribute *attr, char *buf)
1757 {
1758         struct nct6775_data *data = nct6775_update_device(dev);
1759         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1760
1761         return sprintf(buf, "%d\n",
1762                        data->target_temp[sensor_attr->index] * 1000);
1763 }
1764
1765 static ssize_t
1766 store_target_temp(struct device *dev, struct device_attribute *attr,
1767                         const char *buf, size_t count)
1768 {
1769         struct nct6775_data *data = dev_get_drvdata(dev);
1770         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1771         int nr = sensor_attr->index;
1772         long val;
1773         int err;
1774
1775         err = kstrtol(buf, 10, &val);
1776         if (err < 0)
1777                 return err;
1778
1779         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 127);
1780
1781         mutex_lock(&data->update_lock);
1782         data->target_temp[nr] = val;
1783         nct6775_write_value(data, data->REG_TARGET[nr], val);
1784         mutex_unlock(&data->update_lock);
1785         return count;
1786 }
1787
1788 static ssize_t
1789 show_auto_temp_hyst(struct device *dev, struct device_attribute *attr,
1790                     char *buf)
1791 {
1792         struct nct6775_data *data = nct6775_update_device(dev);
1793         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1794         int nr = sattr->nr;
1795         int point = sattr->index >= data->auto_pwm_num ? 1 : 0;
1796         int tolerance = data->tolerance[nr][point];
1797         int temp = data->auto_temp[nr][sattr->index];
1798
1799         return sprintf(buf, "%d\n", (temp - tolerance) * 1000);
1800 }
1801
1802 static ssize_t
1803 store_auto_temp_hyst(struct device *dev, struct device_attribute *attr,
1804                      const char *buf, size_t count)
1805 {
1806         struct nct6775_data *data = dev_get_drvdata(dev);
1807         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1808         int nr = sattr->nr;
1809         int point = sattr->index >= data->auto_pwm_num ? 1 : 0;
1810         u16 reg;
1811         long val;
1812         int err;
1813         int maxlimit[2][3] = { { 15, 7, 63 }, { 15, 7, 7 } };
1814         int mask[] = { 0x0f, 0x07, 0x07 };
1815         int temp;
1816
1817         err = kstrtol(buf, 10, &val);
1818         if (err < 0)
1819                 return err;
1820
1821         temp = data->auto_temp[nr][sattr->index];
1822         val = temp - DIV_ROUND_CLOSEST(val, 1000);
1823
1824         /* Limit tolerance as needed */
1825         val = SENSORS_LIMIT(val, 0, maxlimit[point][data->kind]);
1826
1827         mutex_lock(&data->update_lock);
1828         if (point) {
1829                 nct6775_write_value(data,
1830                                     data->REG_CRITICAL_TEMP_TOLERANCE[nr],
1831                                     val);
1832         } else {
1833                 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
1834                 reg = (reg & ~mask[nr]) | (val & mask[nr]);
1835                 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
1836                 if (data->kind == nct6779) {
1837                         reg = nct6775_read_value(data,
1838                                                  NCT6779_REG_TOLERANCE_H[nr]);
1839                         reg = (reg & 0x70) | ((val & 0x38) << 1);
1840                         nct6775_write_value(data,
1841                                             NCT6779_REG_TOLERANCE_H[nr], reg);
1842                 }
1843         }
1844
1845         data->tolerance[nr][point] = val;
1846         mutex_unlock(&data->update_lock);
1847         return count;
1848 }
1849
1850 static SENSOR_DEVICE_ATTR_2(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0, 0);
1851 static SENSOR_DEVICE_ATTR_2(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1, 0);
1852 static SENSOR_DEVICE_ATTR_2(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2, 0);
1853 static SENSOR_DEVICE_ATTR_2(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3, 0);
1854 static SENSOR_DEVICE_ATTR_2(pwm5, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 4, 0);
1855
1856 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1857                           store_pwm_mode, 0);
1858 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1859                           store_pwm_mode, 1);
1860 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1861                           store_pwm_mode, 2);
1862 static SENSOR_DEVICE_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1863                           store_pwm_mode, 3);
1864 static SENSOR_DEVICE_ATTR(pwm5_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1865                           store_pwm_mode, 4);
1866
1867 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1868                           store_pwm_enable, 0);
1869 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1870                           store_pwm_enable, 1);
1871 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1872                           store_pwm_enable, 2);
1873 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1874                           store_pwm_enable, 3);
1875 static SENSOR_DEVICE_ATTR(pwm5_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1876                           store_pwm_enable, 4);
1877
1878 static SENSOR_DEVICE_ATTR_2(pwm1_temp_sel, S_IWUSR | S_IRUGO,
1879                             show_pwm_temp_sel, store_pwm_temp_sel, 0, 0);
1880 static SENSOR_DEVICE_ATTR_2(pwm2_temp_sel, S_IWUSR | S_IRUGO,
1881                             show_pwm_temp_sel, store_pwm_temp_sel, 1, 0);
1882 static SENSOR_DEVICE_ATTR_2(pwm3_temp_sel, S_IWUSR | S_IRUGO,
1883                             show_pwm_temp_sel, store_pwm_temp_sel, 2, 0);
1884 static SENSOR_DEVICE_ATTR_2(pwm4_temp_sel, S_IWUSR | S_IRUGO,
1885                             show_pwm_temp_sel, store_pwm_temp_sel, 3, 0);
1886 static SENSOR_DEVICE_ATTR_2(pwm5_temp_sel, S_IWUSR | S_IRUGO,
1887                             show_pwm_temp_sel, store_pwm_temp_sel, 4, 0);
1888
1889 static SENSOR_DEVICE_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1890                           store_target_temp, 0);
1891 static SENSOR_DEVICE_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1892                           store_target_temp, 1);
1893 static SENSOR_DEVICE_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1894                           store_target_temp, 2);
1895 static SENSOR_DEVICE_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1896                           store_target_temp, 3);
1897 static SENSOR_DEVICE_ATTR(pwm5_target, S_IWUSR | S_IRUGO, show_target_temp,
1898                           store_target_temp, 4);
1899
1900 /* Monitored pwm temperatures */
1901 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_pwm_temp, NULL, 0);
1902 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_pwm_temp, NULL, 1);
1903 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_pwm_temp, NULL, 2);
1904 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_pwm_temp, NULL, 3);
1905 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, show_pwm_temp, NULL, 4);
1906
1907 /* Smart Fan registers */
1908
1909 static ssize_t
1910 show_pwm_weight_enable(struct device *dev, struct device_attribute *attr,
1911                        char *buf)
1912 {
1913         struct nct6775_data *data = nct6775_update_device(dev);
1914         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1915
1916         return sprintf(buf, "%d\n", data->pwm_weight_enable[sattr->index]);
1917 }
1918
1919 static ssize_t
1920 store_pwm_weight_enable(struct device *dev, struct device_attribute *attr,
1921                         const char *buf, size_t count)
1922 {
1923         struct nct6775_data *data = dev_get_drvdata(dev);
1924         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1925         int nr = sensor_attr->index;
1926         unsigned long val;
1927         int err;
1928         u8 reg;
1929
1930         err = kstrtoul(buf, 10, &val);
1931         if (err < 0)
1932                 return err;
1933
1934         if (val > 1)
1935                 return -EINVAL;
1936
1937         mutex_lock(&data->update_lock);
1938         data->pwm_weight_enable[nr] = val;
1939         reg = nct6775_read_value(data, data->REG_TEMP_SEL[1][nr]);
1940         reg &= 0x7f;
1941         if (val)
1942                 reg |= 0x80;
1943         nct6775_write_value(data, data->REG_TEMP_SEL[1][nr], reg);
1944         mutex_unlock(&data->update_lock);
1945         return count;
1946 }
1947
1948 static ssize_t
1949 show_weight_temp(struct device *dev, struct device_attribute *attr, char *buf)
1950 {
1951         struct nct6775_data *data = nct6775_update_device(dev);
1952         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1953         int nr = sattr->nr;
1954         int index = sattr->index;
1955
1956         return sprintf(buf, "%d\n", data->weight_temp[index][nr] * 1000);
1957 }
1958
1959 static ssize_t
1960 store_weight_temp(struct device *dev, struct device_attribute *attr,
1961                   const char *buf, size_t count)
1962 {
1963         struct nct6775_data *data = dev_get_drvdata(dev);
1964         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1965         int nr = sattr->nr;
1966         int index = sattr->index;
1967         unsigned long val;
1968         int err;
1969
1970         err = kstrtoul(buf, 10, &val);
1971         if (err < 0)
1972                 return err;
1973
1974         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 255);
1975
1976         mutex_lock(&data->update_lock);
1977         data->weight_temp[index][nr] = val;
1978         nct6775_write_value(data, data->REG_WEIGHT_TEMP[index][nr], val);
1979         mutex_unlock(&data->update_lock);
1980         return count;
1981 }
1982
1983 static ssize_t
1984 show_weight_duty(struct device *dev, struct device_attribute *attr, char *buf)
1985 {
1986         struct nct6775_data *data = nct6775_update_device(dev);
1987         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1988         int nr = sattr->nr;
1989         int index = sattr->index;
1990
1991         return sprintf(buf, "%d\n", data->weight_duty[index][nr]);
1992 }
1993
1994 static ssize_t
1995 store_weight_duty(struct device *dev, struct device_attribute *attr,
1996                   const char *buf, size_t count)
1997 {
1998         struct nct6775_data *data = dev_get_drvdata(dev);
1999         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2000         int nr = sattr->nr;
2001         int index = sattr->index;
2002         unsigned long val;
2003         int err;
2004
2005         err = kstrtoul(buf, 10, &val);
2006         if (err < 0)
2007                 return err;
2008
2009         val = SENSORS_LIMIT(val, 0, 255);
2010
2011         mutex_lock(&data->update_lock);
2012         data->weight_duty[index][nr] = val;
2013         nct6775_write_value(data, data->REG_WEIGHT_DUTY[index][nr], val);
2014         mutex_unlock(&data->update_lock);
2015         return count;
2016 }
2017
2018 static SENSOR_DEVICE_ATTR(pwm1_weight_enable, S_IWUSR | S_IRUGO,
2019                           show_pwm_weight_enable, store_pwm_weight_enable, 0);
2020 static SENSOR_DEVICE_ATTR(pwm2_weight_enable, S_IWUSR | S_IRUGO,
2021                           show_pwm_weight_enable, store_pwm_weight_enable, 1);
2022 static SENSOR_DEVICE_ATTR(pwm3_weight_enable, S_IWUSR | S_IRUGO,
2023                           show_pwm_weight_enable, store_pwm_weight_enable, 2);
2024 static SENSOR_DEVICE_ATTR(pwm4_weight_enable, S_IWUSR | S_IRUGO,
2025                           show_pwm_weight_enable, store_pwm_weight_enable, 3);
2026 static SENSOR_DEVICE_ATTR(pwm5_weight_enable, S_IWUSR | S_IRUGO,
2027                           show_pwm_weight_enable, store_pwm_weight_enable, 4);
2028
2029 static SENSOR_DEVICE_ATTR_2(pwm1_weight_temp_sel, S_IWUSR | S_IRUGO,
2030                             show_pwm_temp_sel, store_pwm_temp_sel, 0, 1);
2031 static SENSOR_DEVICE_ATTR_2(pwm2_weight_temp_sel, S_IWUSR | S_IRUGO,
2032                             show_pwm_temp_sel, store_pwm_temp_sel, 1, 1);
2033 static SENSOR_DEVICE_ATTR_2(pwm3_weight_temp_sel, S_IWUSR | S_IRUGO,
2034                             show_pwm_temp_sel, store_pwm_temp_sel, 2, 1);
2035 static SENSOR_DEVICE_ATTR_2(pwm4_weight_temp_sel, S_IWUSR | S_IRUGO,
2036                             show_pwm_temp_sel, store_pwm_temp_sel, 3, 1);
2037 static SENSOR_DEVICE_ATTR_2(pwm5_weight_temp_sel, S_IWUSR | S_IRUGO,
2038                             show_pwm_temp_sel, store_pwm_temp_sel, 4, 1);
2039
2040 static SENSOR_DEVICE_ATTR_2(pwm1_weight_temp_step, S_IWUSR | S_IRUGO,
2041                             show_weight_temp, store_weight_temp, 0, 0);
2042 static SENSOR_DEVICE_ATTR_2(pwm2_weight_temp_step, S_IWUSR | S_IRUGO,
2043                             show_weight_temp, store_weight_temp, 1, 0);
2044 static SENSOR_DEVICE_ATTR_2(pwm3_weight_temp_step, S_IWUSR | S_IRUGO,
2045                             show_weight_temp, store_weight_temp, 2, 0);
2046 static SENSOR_DEVICE_ATTR_2(pwm4_weight_temp_step, S_IWUSR | S_IRUGO,
2047                             show_weight_temp, store_weight_temp, 3, 0);
2048 static SENSOR_DEVICE_ATTR_2(pwm5_weight_temp_step, S_IWUSR | S_IRUGO,
2049                             show_weight_temp, store_weight_temp, 4, 0);
2050
2051 static SENSOR_DEVICE_ATTR_2(pwm1_weight_temp_step_tol, S_IWUSR | S_IRUGO,
2052                             show_weight_temp, store_weight_temp, 0, 1);
2053 static SENSOR_DEVICE_ATTR_2(pwm2_weight_temp_step_tol, S_IWUSR | S_IRUGO,
2054                             show_weight_temp, store_weight_temp, 1, 1);
2055 static SENSOR_DEVICE_ATTR_2(pwm3_weight_temp_step_tol, S_IWUSR | S_IRUGO,
2056                             show_weight_temp, store_weight_temp, 2, 1);
2057 static SENSOR_DEVICE_ATTR_2(pwm4_weight_temp_step_tol, S_IWUSR | S_IRUGO,
2058                             show_weight_temp, store_weight_temp, 3, 1);
2059 static SENSOR_DEVICE_ATTR_2(pwm5_weight_temp_step_tol, S_IWUSR | S_IRUGO,
2060                             show_weight_temp, store_weight_temp, 4, 1);
2061
2062 static SENSOR_DEVICE_ATTR_2(pwm1_weight_temp_step_base, S_IWUSR | S_IRUGO,
2063                             show_weight_temp, store_weight_temp, 0, 2);
2064 static SENSOR_DEVICE_ATTR_2(pwm2_weight_temp_step_base, S_IWUSR | S_IRUGO,
2065                             show_weight_temp, store_weight_temp, 1, 2);
2066 static SENSOR_DEVICE_ATTR_2(pwm3_weight_temp_step_base, S_IWUSR | S_IRUGO,
2067                             show_weight_temp, store_weight_temp, 2, 2);
2068 static SENSOR_DEVICE_ATTR_2(pwm4_weight_temp_step_base, S_IWUSR | S_IRUGO,
2069                             show_weight_temp, store_weight_temp, 3, 2);
2070 static SENSOR_DEVICE_ATTR_2(pwm5_weight_temp_step_base, S_IWUSR | S_IRUGO,
2071                             show_weight_temp, store_weight_temp, 4, 2);
2072
2073 static SENSOR_DEVICE_ATTR_2(pwm1_weight_duty_step, S_IWUSR | S_IRUGO,
2074                             show_weight_duty, store_weight_duty, 0, 0);
2075 static SENSOR_DEVICE_ATTR_2(pwm2_weight_duty_step, S_IWUSR | S_IRUGO,
2076                             show_weight_duty, store_weight_duty, 1, 0);
2077 static SENSOR_DEVICE_ATTR_2(pwm3_weight_duty_step, S_IWUSR | S_IRUGO,
2078                             show_weight_duty, store_weight_duty, 2, 0);
2079 static SENSOR_DEVICE_ATTR_2(pwm4_weight_duty_step, S_IWUSR | S_IRUGO,
2080                             show_weight_duty, store_weight_duty, 3, 0);
2081 static SENSOR_DEVICE_ATTR_2(pwm5_weight_duty_step, S_IWUSR | S_IRUGO,
2082                             show_weight_duty, store_weight_duty, 4, 0);
2083
2084 /* duty_base is not supported on all chips */
2085 static struct sensor_device_attribute_2 sda_weight_duty_base[] = {
2086         SENSOR_ATTR_2(pwm1_weight_duty_base, S_IWUSR | S_IRUGO,
2087                       show_weight_duty, store_weight_duty, 0, 1),
2088         SENSOR_ATTR_2(pwm2_weight_duty_base, S_IWUSR | S_IRUGO,
2089                       show_weight_duty, store_weight_duty, 1, 1),
2090         SENSOR_ATTR_2(pwm3_weight_duty_base, S_IWUSR | S_IRUGO,
2091                       show_weight_duty, store_weight_duty, 2, 1),
2092         SENSOR_ATTR_2(pwm4_weight_duty_base, S_IWUSR | S_IRUGO,
2093                       show_weight_duty, store_weight_duty, 3, 1),
2094         SENSOR_ATTR_2(pwm5_weight_duty_base, S_IWUSR | S_IRUGO,
2095                       show_weight_duty, store_weight_duty, 4, 1),
2096 };
2097
2098 static ssize_t
2099 show_fan_time(struct device *dev, struct device_attribute *attr, char *buf)
2100 {
2101         struct nct6775_data *data = nct6775_update_device(dev);
2102         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2103         int nr = sattr->nr;
2104         int index = sattr->index;
2105
2106         return sprintf(buf, "%d\n",
2107                        step_time_from_reg(data->fan_time[index][nr],
2108                                           data->pwm_mode[nr]));
2109 }
2110
2111 static ssize_t
2112 store_fan_time(struct device *dev, struct device_attribute *attr,
2113                const char *buf, size_t count)
2114 {
2115         struct nct6775_data *data = dev_get_drvdata(dev);
2116         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2117         int nr = sattr->nr;
2118         int index = sattr->index;
2119         unsigned long val;
2120         int err;
2121
2122         err = kstrtoul(buf, 10, &val);
2123         if (err < 0)
2124                 return err;
2125
2126         val = step_time_to_reg(val, data->pwm_mode[nr]);
2127         mutex_lock(&data->update_lock);
2128         data->fan_time[index][nr] = val;
2129         nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val);
2130         mutex_unlock(&data->update_lock);
2131         return count;
2132 }
2133
2134 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
2135                          char *buf)
2136 {
2137         struct nct6775_data *data = dev_get_drvdata(dev);
2138
2139         return sprintf(buf, "%s\n", data->name);
2140 }
2141 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
2142
2143 static SENSOR_DEVICE_ATTR_2(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
2144                             store_fan_time, 0, 0);
2145 static SENSOR_DEVICE_ATTR_2(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
2146                             store_fan_time, 1, 0);
2147 static SENSOR_DEVICE_ATTR_2(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
2148                             store_fan_time, 2, 0);
2149 static SENSOR_DEVICE_ATTR_2(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
2150                             store_fan_time, 3, 0);
2151 static SENSOR_DEVICE_ATTR_2(pwm5_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
2152                             store_fan_time, 4, 0);
2153
2154 static SENSOR_DEVICE_ATTR_2(pwm1_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
2155                             store_fan_time, 0, 1);
2156 static SENSOR_DEVICE_ATTR_2(pwm2_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
2157                             store_fan_time, 1, 1);
2158 static SENSOR_DEVICE_ATTR_2(pwm3_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
2159                             store_fan_time, 2, 1);
2160 static SENSOR_DEVICE_ATTR_2(pwm4_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
2161                             store_fan_time, 3, 1);
2162 static SENSOR_DEVICE_ATTR_2(pwm5_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
2163                             store_fan_time, 4, 1);
2164
2165 static SENSOR_DEVICE_ATTR_2(pwm1_step_down_time, S_IWUSR | S_IRUGO,
2166                             show_fan_time, store_fan_time, 0, 2);
2167 static SENSOR_DEVICE_ATTR_2(pwm2_step_down_time, S_IWUSR | S_IRUGO,
2168                             show_fan_time, store_fan_time, 1, 2);
2169 static SENSOR_DEVICE_ATTR_2(pwm3_step_down_time, S_IWUSR | S_IRUGO,
2170                             show_fan_time, store_fan_time, 2, 2);
2171 static SENSOR_DEVICE_ATTR_2(pwm4_step_down_time, S_IWUSR | S_IRUGO,
2172                             show_fan_time, store_fan_time, 3, 2);
2173 static SENSOR_DEVICE_ATTR_2(pwm5_step_down_time, S_IWUSR | S_IRUGO,
2174                             show_fan_time, store_fan_time, 4, 2);
2175
2176 static SENSOR_DEVICE_ATTR_2(pwm1_start_output, S_IWUSR | S_IRUGO, show_pwm,
2177                             store_pwm, 0, 1);
2178 static SENSOR_DEVICE_ATTR_2(pwm2_start_output, S_IWUSR | S_IRUGO, show_pwm,
2179                             store_pwm, 1, 1);
2180 static SENSOR_DEVICE_ATTR_2(pwm3_start_output, S_IWUSR | S_IRUGO, show_pwm,
2181                             store_pwm, 2, 1);
2182 static SENSOR_DEVICE_ATTR_2(pwm4_start_output, S_IWUSR | S_IRUGO, show_pwm,
2183                             store_pwm, 3, 1);
2184 static SENSOR_DEVICE_ATTR_2(pwm5_start_output, S_IWUSR | S_IRUGO, show_pwm,
2185                             store_pwm, 4, 1);
2186
2187 static SENSOR_DEVICE_ATTR_2(pwm1_stop_output, S_IWUSR | S_IRUGO, show_pwm,
2188                             store_pwm, 0, 2);
2189 static SENSOR_DEVICE_ATTR_2(pwm2_stop_output, S_IWUSR | S_IRUGO, show_pwm,
2190                             store_pwm, 1, 2);
2191 static SENSOR_DEVICE_ATTR_2(pwm3_stop_output, S_IWUSR | S_IRUGO, show_pwm,
2192                             store_pwm, 2, 2);
2193 static SENSOR_DEVICE_ATTR_2(pwm4_stop_output, S_IWUSR | S_IRUGO, show_pwm,
2194                             store_pwm, 3, 2);
2195 static SENSOR_DEVICE_ATTR_2(pwm5_stop_output, S_IWUSR | S_IRUGO, show_pwm,
2196                             store_pwm, 4, 2);
2197
2198 static struct attribute *nct6775_attributes_pwm[5][19] = {
2199         {
2200                 &sensor_dev_attr_temp7_input.dev_attr.attr,
2201                 &sensor_dev_attr_pwm1.dev_attr.attr,
2202                 &sensor_dev_attr_pwm1_mode.dev_attr.attr,
2203                 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
2204                 &sensor_dev_attr_pwm1_weight_enable.dev_attr.attr,
2205                 &sensor_dev_attr_pwm1_temp_sel.dev_attr.attr,
2206                 &sensor_dev_attr_pwm1_target.dev_attr.attr,
2207                 &sensor_dev_attr_pwm1_stop_time.dev_attr.attr,
2208                 &sensor_dev_attr_pwm1_step_up_time.dev_attr.attr,
2209                 &sensor_dev_attr_pwm1_step_down_time.dev_attr.attr,
2210                 &sensor_dev_attr_pwm1_start_output.dev_attr.attr,
2211                 &sensor_dev_attr_pwm1_stop_output.dev_attr.attr,
2212                 &sensor_dev_attr_pwm1_weight_temp_sel.dev_attr.attr,
2213                 &sensor_dev_attr_pwm1_weight_temp_step.dev_attr.attr,
2214                 &sensor_dev_attr_pwm1_weight_temp_step_tol.dev_attr.attr,
2215                 &sensor_dev_attr_pwm1_weight_temp_step_base.dev_attr.attr,
2216                 &sensor_dev_attr_pwm1_weight_duty_step.dev_attr.attr,
2217                 NULL
2218         },
2219         {
2220                 &sensor_dev_attr_temp8_input.dev_attr.attr,
2221                 &sensor_dev_attr_pwm2.dev_attr.attr,
2222                 &sensor_dev_attr_pwm2_mode.dev_attr.attr,
2223                 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
2224                 &sensor_dev_attr_pwm2_weight_enable.dev_attr.attr,
2225                 &sensor_dev_attr_pwm2_temp_sel.dev_attr.attr,
2226                 &sensor_dev_attr_pwm2_target.dev_attr.attr,
2227                 &sensor_dev_attr_pwm2_stop_time.dev_attr.attr,
2228                 &sensor_dev_attr_pwm2_step_up_time.dev_attr.attr,
2229                 &sensor_dev_attr_pwm2_step_down_time.dev_attr.attr,
2230                 &sensor_dev_attr_pwm2_start_output.dev_attr.attr,
2231                 &sensor_dev_attr_pwm2_stop_output.dev_attr.attr,
2232                 &sensor_dev_attr_pwm2_weight_temp_sel.dev_attr.attr,
2233                 &sensor_dev_attr_pwm2_weight_temp_step.dev_attr.attr,
2234                 &sensor_dev_attr_pwm2_weight_temp_step_tol.dev_attr.attr,
2235                 &sensor_dev_attr_pwm2_weight_temp_step_base.dev_attr.attr,
2236                 &sensor_dev_attr_pwm2_weight_duty_step.dev_attr.attr,
2237                 NULL
2238         },
2239         {
2240                 &sensor_dev_attr_temp9_input.dev_attr.attr,
2241                 &sensor_dev_attr_pwm3.dev_attr.attr,
2242                 &sensor_dev_attr_pwm3_mode.dev_attr.attr,
2243                 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
2244                 &sensor_dev_attr_pwm3_weight_enable.dev_attr.attr,
2245                 &sensor_dev_attr_pwm3_temp_sel.dev_attr.attr,
2246                 &sensor_dev_attr_pwm3_target.dev_attr.attr,
2247                 &sensor_dev_attr_pwm3_stop_time.dev_attr.attr,
2248                 &sensor_dev_attr_pwm3_step_up_time.dev_attr.attr,
2249                 &sensor_dev_attr_pwm3_step_down_time.dev_attr.attr,
2250                 &sensor_dev_attr_pwm3_start_output.dev_attr.attr,
2251                 &sensor_dev_attr_pwm3_stop_output.dev_attr.attr,
2252                 &sensor_dev_attr_pwm3_weight_temp_sel.dev_attr.attr,
2253                 &sensor_dev_attr_pwm3_weight_temp_step.dev_attr.attr,
2254                 &sensor_dev_attr_pwm3_weight_temp_step_tol.dev_attr.attr,
2255                 &sensor_dev_attr_pwm3_weight_temp_step_base.dev_attr.attr,
2256                 &sensor_dev_attr_pwm3_weight_duty_step.dev_attr.attr,
2257                 NULL
2258         },
2259         {
2260                 &sensor_dev_attr_temp10_input.dev_attr.attr,
2261                 &sensor_dev_attr_pwm4.dev_attr.attr,
2262                 &sensor_dev_attr_pwm4_mode.dev_attr.attr,
2263                 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
2264                 &sensor_dev_attr_pwm4_weight_enable.dev_attr.attr,
2265                 &sensor_dev_attr_pwm4_temp_sel.dev_attr.attr,
2266                 &sensor_dev_attr_pwm4_target.dev_attr.attr,
2267                 &sensor_dev_attr_pwm4_stop_time.dev_attr.attr,
2268                 &sensor_dev_attr_pwm4_step_up_time.dev_attr.attr,
2269                 &sensor_dev_attr_pwm4_step_down_time.dev_attr.attr,
2270                 &sensor_dev_attr_pwm4_start_output.dev_attr.attr,
2271                 &sensor_dev_attr_pwm4_stop_output.dev_attr.attr,
2272                 &sensor_dev_attr_pwm4_weight_temp_sel.dev_attr.attr,
2273                 &sensor_dev_attr_pwm4_weight_temp_step.dev_attr.attr,
2274                 &sensor_dev_attr_pwm4_weight_temp_step_tol.dev_attr.attr,
2275                 &sensor_dev_attr_pwm4_weight_temp_step_base.dev_attr.attr,
2276                 &sensor_dev_attr_pwm4_weight_duty_step.dev_attr.attr,
2277                 NULL
2278         },
2279         {
2280                 &sensor_dev_attr_temp11_input.dev_attr.attr,
2281                 &sensor_dev_attr_pwm5.dev_attr.attr,
2282                 &sensor_dev_attr_pwm5_mode.dev_attr.attr,
2283                 &sensor_dev_attr_pwm5_enable.dev_attr.attr,
2284                 &sensor_dev_attr_pwm5_weight_enable.dev_attr.attr,
2285                 &sensor_dev_attr_pwm5_temp_sel.dev_attr.attr,
2286                 &sensor_dev_attr_pwm5_target.dev_attr.attr,
2287                 &sensor_dev_attr_pwm5_stop_time.dev_attr.attr,
2288                 &sensor_dev_attr_pwm5_step_up_time.dev_attr.attr,
2289                 &sensor_dev_attr_pwm5_step_down_time.dev_attr.attr,
2290                 &sensor_dev_attr_pwm5_start_output.dev_attr.attr,
2291                 &sensor_dev_attr_pwm5_stop_output.dev_attr.attr,
2292                 &sensor_dev_attr_pwm5_weight_temp_sel.dev_attr.attr,
2293                 &sensor_dev_attr_pwm5_weight_temp_step.dev_attr.attr,
2294                 &sensor_dev_attr_pwm5_weight_temp_step_tol.dev_attr.attr,
2295                 &sensor_dev_attr_pwm5_weight_temp_step_base.dev_attr.attr,
2296                 &sensor_dev_attr_pwm5_weight_duty_step.dev_attr.attr,
2297                 NULL
2298         },
2299 };
2300
2301 static const struct attribute_group nct6775_group_pwm[5] = {
2302         { .attrs = nct6775_attributes_pwm[0] },
2303         { .attrs = nct6775_attributes_pwm[1] },
2304         { .attrs = nct6775_attributes_pwm[2] },
2305         { .attrs = nct6775_attributes_pwm[3] },
2306         { .attrs = nct6775_attributes_pwm[4] },
2307 };
2308
2309 static ssize_t show_auto_pwm(struct device *dev, struct device_attribute *attr,
2310                              char *buf)
2311 {
2312         struct nct6775_data *data = nct6775_update_device(dev);
2313         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2314
2315         return sprintf(buf, "%d\n", data->auto_pwm[sattr->nr][sattr->index]);
2316 }
2317
2318 static ssize_t store_auto_pwm(struct device *dev, struct device_attribute *attr,
2319                               const char *buf, size_t count)
2320 {
2321         struct nct6775_data *data = dev_get_drvdata(dev);
2322         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2323         int nr = sattr->nr;
2324         int point = sattr->index;
2325         unsigned long val;
2326         int err;
2327         u8 reg;
2328
2329         err = kstrtoul(buf, 10, &val);
2330         if (err < 0)
2331                 return err;
2332         if (val > 255)
2333                 return -EINVAL;
2334
2335         if (point == data->auto_pwm_num) {
2336                 if (data->kind != nct6775 && !val)
2337                         return -EINVAL;
2338                 if (data->kind != nct6779 && val)
2339                         val = 0xff;
2340         }
2341
2342         mutex_lock(&data->update_lock);
2343         data->auto_pwm[nr][point] = val;
2344         if (point < data->auto_pwm_num) {
2345                 nct6775_write_value(data,
2346                                     NCT6775_AUTO_PWM(data, nr, point),
2347                                     data->auto_pwm[nr][point]);
2348         } else {
2349                 switch (data->kind) {
2350                 case nct6775:
2351                         /* disable if needed (pwm == 0) */
2352                         reg = nct6775_read_value(data,
2353                                                  NCT6775_REG_CRITICAL_ENAB[nr]);
2354                         if (val)
2355                                 reg |= 0x02;
2356                         else
2357                                 reg &= ~0x02;
2358                         nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr],
2359                                             reg);
2360                         break;
2361                 case nct6776:
2362                         break; /* always enabled, nothing to do */
2363                 case nct6779:
2364                         nct6775_write_value(data, NCT6779_REG_CRITICAL_PWM[nr],
2365                                             val);
2366                         reg = nct6775_read_value(data,
2367                                         NCT6779_REG_CRITICAL_PWM_ENABLE[nr]);
2368                         if (val == 255)
2369                                 reg &= ~0x01;
2370                         else
2371                                 reg |= 0x01;
2372                         nct6775_write_value(data,
2373                                             NCT6779_REG_CRITICAL_PWM_ENABLE[nr],
2374                                             reg);
2375                         break;
2376                 }
2377         }
2378         mutex_unlock(&data->update_lock);
2379         return count;
2380 }
2381
2382 static ssize_t show_auto_temp(struct device *dev, struct device_attribute *attr,
2383                               char *buf)
2384 {
2385         struct nct6775_data *data = nct6775_update_device(dev);
2386         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2387         int nr = sattr->nr;
2388         int point = sattr->index;
2389
2390         /*
2391          * We don't know for sure if the temperature is signed or unsigned.
2392          * Assume it is unsigned.
2393          */
2394         return sprintf(buf, "%d\n", data->auto_temp[nr][point] * 1000);
2395 }
2396
2397 static ssize_t store_auto_temp(struct device *dev,
2398                                struct device_attribute *attr,
2399                                const char *buf, size_t count)
2400 {
2401         struct nct6775_data *data = dev_get_drvdata(dev);
2402         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2403         int nr = sattr->nr;
2404         int point = sattr->index;
2405         unsigned long val;
2406         int err;
2407
2408         err = kstrtoul(buf, 10, &val);
2409         if (err)
2410                 return err;
2411         if (val > 255000)
2412                 return -EINVAL;
2413
2414         mutex_lock(&data->update_lock);
2415         data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
2416         if (point < data->auto_pwm_num) {
2417                 nct6775_write_value(data,
2418                                     NCT6775_AUTO_TEMP(data, nr, point),
2419                                     data->auto_temp[nr][point]);
2420         } else {
2421                 nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr],
2422                                     data->auto_temp[nr][point]);
2423         }
2424         mutex_unlock(&data->update_lock);
2425         return count;
2426 }
2427
2428 /*
2429  * The number of auto-point trip points is chip dependent.
2430  * Need to check support while generating/removing attribute files.
2431  */
2432 static struct sensor_device_attribute_2 sda_auto_pwm_arrays[] = {
2433         SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
2434                           show_auto_pwm, store_auto_pwm, 0, 0),
2435         SENSOR_ATTR_2(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
2436                           show_auto_temp, store_auto_temp, 0, 0),
2437         SENSOR_ATTR_2(pwm1_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2438                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 0),
2439         SENSOR_ATTR_2(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
2440                           show_auto_pwm, store_auto_pwm, 0, 1),
2441         SENSOR_ATTR_2(pwm1_auto_point2_temp, S_IWUSR | S_IRUGO,
2442                           show_auto_temp, store_auto_temp, 0, 1),
2443         SENSOR_ATTR_2(pwm1_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2444                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 1),
2445         SENSOR_ATTR_2(pwm1_auto_point3_pwm, S_IWUSR | S_IRUGO,
2446                           show_auto_pwm, store_auto_pwm, 0, 2),
2447         SENSOR_ATTR_2(pwm1_auto_point3_temp, S_IWUSR | S_IRUGO,
2448                           show_auto_temp, store_auto_temp, 0, 2),
2449         SENSOR_ATTR_2(pwm1_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2450                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 2),
2451         SENSOR_ATTR_2(pwm1_auto_point4_pwm, S_IWUSR | S_IRUGO,
2452                           show_auto_pwm, store_auto_pwm, 0, 3),
2453         SENSOR_ATTR_2(pwm1_auto_point4_temp, S_IWUSR | S_IRUGO,
2454                           show_auto_temp, store_auto_temp, 0, 3),
2455         SENSOR_ATTR_2(pwm1_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2456                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 3),
2457         SENSOR_ATTR_2(pwm1_auto_point5_pwm, S_IWUSR | S_IRUGO,
2458                           show_auto_pwm, store_auto_pwm, 0, 4),
2459         SENSOR_ATTR_2(pwm1_auto_point5_temp, S_IWUSR | S_IRUGO,
2460                           show_auto_temp, store_auto_temp, 0, 4),
2461         SENSOR_ATTR_2(pwm1_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2462                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 4),
2463         SENSOR_ATTR_2(pwm1_auto_point6_pwm, S_IWUSR | S_IRUGO,
2464                           show_auto_pwm, store_auto_pwm, 0, 5),
2465         SENSOR_ATTR_2(pwm1_auto_point6_temp, S_IWUSR | S_IRUGO,
2466                           show_auto_temp, store_auto_temp, 0, 5),
2467         SENSOR_ATTR_2(pwm1_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2468                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 5),
2469         SENSOR_ATTR_2(pwm1_auto_point7_pwm, S_IWUSR | S_IRUGO,
2470                           show_auto_pwm, store_auto_pwm, 0, 6),
2471         SENSOR_ATTR_2(pwm1_auto_point7_temp, S_IWUSR | S_IRUGO,
2472                           show_auto_temp, store_auto_temp, 0, 6),
2473         SENSOR_ATTR_2(pwm1_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2474                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 6),
2475
2476         SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
2477                           show_auto_pwm, store_auto_pwm, 1, 0),
2478         SENSOR_ATTR_2(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO,
2479                           show_auto_temp, store_auto_temp, 1, 0),
2480         SENSOR_ATTR_2(pwm2_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2481                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 0),
2482         SENSOR_ATTR_2(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
2483                           show_auto_pwm, store_auto_pwm, 1, 1),
2484         SENSOR_ATTR_2(pwm2_auto_point2_temp, S_IWUSR | S_IRUGO,
2485                           show_auto_temp, store_auto_temp, 1, 1),
2486         SENSOR_ATTR_2(pwm2_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2487                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 1),
2488         SENSOR_ATTR_2(pwm2_auto_point3_pwm, S_IWUSR | S_IRUGO,
2489                           show_auto_pwm, store_auto_pwm, 1, 2),
2490         SENSOR_ATTR_2(pwm2_auto_point3_temp, S_IWUSR | S_IRUGO,
2491                           show_auto_temp, store_auto_temp, 1, 2),
2492         SENSOR_ATTR_2(pwm2_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2493                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 2),
2494         SENSOR_ATTR_2(pwm2_auto_point4_pwm, S_IWUSR | S_IRUGO,
2495                           show_auto_pwm, store_auto_pwm, 1, 3),
2496         SENSOR_ATTR_2(pwm2_auto_point4_temp, S_IWUSR | S_IRUGO,
2497                           show_auto_temp, store_auto_temp, 1, 3),
2498         SENSOR_ATTR_2(pwm2_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2499                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 3),
2500         SENSOR_ATTR_2(pwm2_auto_point5_pwm, S_IWUSR | S_IRUGO,
2501                           show_auto_pwm, store_auto_pwm, 1, 4),
2502         SENSOR_ATTR_2(pwm2_auto_point5_temp, S_IWUSR | S_IRUGO,
2503                           show_auto_temp, store_auto_temp, 1, 4),
2504         SENSOR_ATTR_2(pwm2_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2505                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 4),
2506         SENSOR_ATTR_2(pwm2_auto_point6_pwm, S_IWUSR | S_IRUGO,
2507                           show_auto_pwm, store_auto_pwm, 1, 5),
2508         SENSOR_ATTR_2(pwm2_auto_point6_temp, S_IWUSR | S_IRUGO,
2509                           show_auto_temp, store_auto_temp, 1, 5),
2510         SENSOR_ATTR_2(pwm2_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2511                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 5),
2512         SENSOR_ATTR_2(pwm2_auto_point7_pwm, S_IWUSR | S_IRUGO,
2513                           show_auto_pwm, store_auto_pwm, 1, 6),
2514         SENSOR_ATTR_2(pwm2_auto_point7_temp, S_IWUSR | S_IRUGO,
2515                           show_auto_temp, store_auto_temp, 1, 6),
2516         SENSOR_ATTR_2(pwm2_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2517                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 6),
2518
2519         SENSOR_ATTR_2(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
2520                           show_auto_pwm, store_auto_pwm, 2, 0),
2521         SENSOR_ATTR_2(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO,
2522                           show_auto_temp, store_auto_temp, 2, 0),
2523         SENSOR_ATTR_2(pwm3_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2524                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 0),
2525         SENSOR_ATTR_2(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
2526                           show_auto_pwm, store_auto_pwm, 2, 1),
2527         SENSOR_ATTR_2(pwm3_auto_point2_temp, S_IWUSR | S_IRUGO,
2528                           show_auto_temp, store_auto_temp, 2, 1),
2529         SENSOR_ATTR_2(pwm3_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2530                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 1),
2531         SENSOR_ATTR_2(pwm3_auto_point3_pwm, S_IWUSR | S_IRUGO,
2532                           show_auto_pwm, store_auto_pwm, 2, 2),
2533         SENSOR_ATTR_2(pwm3_auto_point3_temp, S_IWUSR | S_IRUGO,
2534                           show_auto_temp, store_auto_temp, 2, 2),
2535         SENSOR_ATTR_2(pwm3_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2536                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 2),
2537         SENSOR_ATTR_2(pwm3_auto_point4_pwm, S_IWUSR | S_IRUGO,
2538                           show_auto_pwm, store_auto_pwm, 2, 3),
2539         SENSOR_ATTR_2(pwm3_auto_point4_temp, S_IWUSR | S_IRUGO,
2540                           show_auto_temp, store_auto_temp, 2, 3),
2541         SENSOR_ATTR_2(pwm3_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2542                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 3),
2543         SENSOR_ATTR_2(pwm3_auto_point5_pwm, S_IWUSR | S_IRUGO,
2544                           show_auto_pwm, store_auto_pwm, 2, 4),
2545         SENSOR_ATTR_2(pwm3_auto_point5_temp, S_IWUSR | S_IRUGO,
2546                           show_auto_temp, store_auto_temp, 2, 4),
2547         SENSOR_ATTR_2(pwm3_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2548                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 4),
2549         SENSOR_ATTR_2(pwm3_auto_point6_pwm, S_IWUSR | S_IRUGO,
2550                           show_auto_pwm, store_auto_pwm, 2, 5),
2551         SENSOR_ATTR_2(pwm3_auto_point6_temp, S_IWUSR | S_IRUGO,
2552                           show_auto_temp, store_auto_temp, 2, 5),
2553         SENSOR_ATTR_2(pwm3_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2554                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 5),
2555         SENSOR_ATTR_2(pwm3_auto_point7_pwm, S_IWUSR | S_IRUGO,
2556                           show_auto_pwm, store_auto_pwm, 2, 6),
2557         SENSOR_ATTR_2(pwm3_auto_point7_temp, S_IWUSR | S_IRUGO,
2558                           show_auto_temp, store_auto_temp, 2, 6),
2559         SENSOR_ATTR_2(pwm3_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2560                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 6),
2561
2562         SENSOR_ATTR_2(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
2563                           show_auto_pwm, store_auto_pwm, 3, 0),
2564         SENSOR_ATTR_2(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO,
2565                           show_auto_temp, store_auto_temp, 3, 0),
2566         SENSOR_ATTR_2(pwm4_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2567                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 0),
2568         SENSOR_ATTR_2(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
2569                           show_auto_pwm, store_auto_pwm, 3, 1),
2570         SENSOR_ATTR_2(pwm4_auto_point2_temp, S_IWUSR | S_IRUGO,
2571                           show_auto_temp, store_auto_temp, 3, 1),
2572         SENSOR_ATTR_2(pwm4_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2573                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 1),
2574         SENSOR_ATTR_2(pwm4_auto_point3_pwm, S_IWUSR | S_IRUGO,
2575                           show_auto_pwm, store_auto_pwm, 3, 2),
2576         SENSOR_ATTR_2(pwm4_auto_point3_temp, S_IWUSR | S_IRUGO,
2577                           show_auto_temp, store_auto_temp, 3, 2),
2578         SENSOR_ATTR_2(pwm4_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2579                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 2),
2580         SENSOR_ATTR_2(pwm4_auto_point4_pwm, S_IWUSR | S_IRUGO,
2581                           show_auto_pwm, store_auto_pwm, 3, 3),
2582         SENSOR_ATTR_2(pwm4_auto_point4_temp, S_IWUSR | S_IRUGO,
2583                           show_auto_temp, store_auto_temp, 3, 3),
2584         SENSOR_ATTR_2(pwm4_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2585                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 3),
2586         SENSOR_ATTR_2(pwm4_auto_point5_pwm, S_IWUSR | S_IRUGO,
2587                           show_auto_pwm, store_auto_pwm, 3, 4),
2588         SENSOR_ATTR_2(pwm4_auto_point5_temp, S_IWUSR | S_IRUGO,
2589                           show_auto_temp, store_auto_temp, 3, 4),
2590         SENSOR_ATTR_2(pwm4_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2591                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 4),
2592         SENSOR_ATTR_2(pwm4_auto_point6_pwm, S_IWUSR | S_IRUGO,
2593                           show_auto_pwm, store_auto_pwm, 3, 5),
2594         SENSOR_ATTR_2(pwm4_auto_point6_temp, S_IWUSR | S_IRUGO,
2595                           show_auto_temp, store_auto_temp, 3, 5),
2596         SENSOR_ATTR_2(pwm4_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2597                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 5),
2598         SENSOR_ATTR_2(pwm4_auto_point7_pwm, S_IWUSR | S_IRUGO,
2599                           show_auto_pwm, store_auto_pwm, 3, 6),
2600         SENSOR_ATTR_2(pwm4_auto_point7_temp, S_IWUSR | S_IRUGO,
2601                           show_auto_temp, store_auto_temp, 3, 6),
2602         SENSOR_ATTR_2(pwm4_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2603                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 6),
2604
2605         SENSOR_ATTR_2(pwm5_auto_point1_pwm, S_IWUSR | S_IRUGO,
2606                           show_auto_pwm, store_auto_pwm, 4, 0),
2607         SENSOR_ATTR_2(pwm5_auto_point1_temp, S_IWUSR | S_IRUGO,
2608                           show_auto_temp, store_auto_temp, 4, 0),
2609         SENSOR_ATTR_2(pwm5_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2610                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 0),
2611         SENSOR_ATTR_2(pwm5_auto_point2_pwm, S_IWUSR | S_IRUGO,
2612                           show_auto_pwm, store_auto_pwm, 4, 1),
2613         SENSOR_ATTR_2(pwm5_auto_point2_temp, S_IWUSR | S_IRUGO,
2614                           show_auto_temp, store_auto_temp, 4, 1),
2615         SENSOR_ATTR_2(pwm5_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2616                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 1),
2617         SENSOR_ATTR_2(pwm5_auto_point3_pwm, S_IWUSR | S_IRUGO,
2618                           show_auto_pwm, store_auto_pwm, 4, 2),
2619         SENSOR_ATTR_2(pwm5_auto_point3_temp, S_IWUSR | S_IRUGO,
2620                           show_auto_temp, store_auto_temp, 4, 2),
2621         SENSOR_ATTR_2(pwm5_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2622                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 2),
2623         SENSOR_ATTR_2(pwm5_auto_point4_pwm, S_IWUSR | S_IRUGO,
2624                           show_auto_pwm, store_auto_pwm, 4, 3),
2625         SENSOR_ATTR_2(pwm5_auto_point4_temp, S_IWUSR | S_IRUGO,
2626                           show_auto_temp, store_auto_temp, 4, 3),
2627         SENSOR_ATTR_2(pwm5_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2628                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 3),
2629         SENSOR_ATTR_2(pwm5_auto_point5_pwm, S_IWUSR | S_IRUGO,
2630                           show_auto_pwm, store_auto_pwm, 4, 4),
2631         SENSOR_ATTR_2(pwm5_auto_point5_temp, S_IWUSR | S_IRUGO,
2632                           show_auto_temp, store_auto_temp, 4, 4),
2633         SENSOR_ATTR_2(pwm5_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2634                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 4),
2635         SENSOR_ATTR_2(pwm5_auto_point6_pwm, S_IWUSR | S_IRUGO,
2636                           show_auto_pwm, store_auto_pwm, 4, 5),
2637         SENSOR_ATTR_2(pwm5_auto_point6_temp, S_IWUSR | S_IRUGO,
2638                           show_auto_temp, store_auto_temp, 4, 5),
2639         SENSOR_ATTR_2(pwm5_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2640                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 5),
2641         SENSOR_ATTR_2(pwm5_auto_point7_pwm, S_IWUSR | S_IRUGO,
2642                           show_auto_pwm, store_auto_pwm, 4, 6),
2643         SENSOR_ATTR_2(pwm5_auto_point7_temp, S_IWUSR | S_IRUGO,
2644                           show_auto_temp, store_auto_temp, 4, 6),
2645         SENSOR_ATTR_2(pwm5_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2646                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 6),
2647 };
2648
2649 static ssize_t
2650 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
2651 {
2652         struct nct6775_data *data = dev_get_drvdata(dev);
2653         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
2654 }
2655 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
2656
2657
2658 /* Case open detection */
2659
2660 static ssize_t
2661 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
2662 {
2663         struct nct6775_data *data = nct6775_update_device(dev);
2664
2665         return sprintf(buf, "%d\n",
2666                 !!(data->caseopen & to_sensor_dev_attr_2(attr)->index));
2667 }
2668
2669 static ssize_t
2670 clear_caseopen(struct device *dev, struct device_attribute *attr,
2671                         const char *buf, size_t count)
2672 {
2673         struct nct6775_data *data = dev_get_drvdata(dev);
2674         struct nct6775_sio_data *sio_data = dev->platform_data;
2675         int nr = to_sensor_dev_attr(attr)->index;
2676         unsigned long val;
2677         u8 reg;
2678
2679         if (kstrtoul(buf, 10, &val) || val != 0)
2680                 return -EINVAL;
2681
2682         mutex_lock(&data->update_lock);
2683
2684         /*
2685          * Use CR registers to clear caseopen status.
2686          * The CR registers are the same for all chips, and not all chips
2687          * support clearing the caseopen status through "regular" registers.
2688          */
2689         superio_enter(sio_data->sioreg);
2690         superio_select(sio_data->sioreg, NCT6775_LD_ACPI);
2691         reg = superio_inb(sio_data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr]);
2692         reg |= NCT6775_CR_CASEOPEN_CLR_MASK[nr];
2693         superio_outb(sio_data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
2694         superio_exit(sio_data->sioreg);
2695
2696         data->valid = 0;        /* Force cache refresh */
2697
2698         mutex_unlock(&data->update_lock);
2699
2700         return count;
2701 }
2702
2703 static struct sensor_device_attribute sda_caseopen[] = {
2704         SENSOR_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
2705                     clear_caseopen, 0),
2706         SENSOR_ATTR(intrusion1_alarm, S_IWUSR | S_IRUGO, show_caseopen,
2707                     clear_caseopen, 1),
2708 };
2709
2710 /*
2711  * Driver and device management
2712  */
2713
2714 static void nct6775_device_remove_files(struct device *dev)
2715 {
2716         /*
2717          * some entries in the following arrays may not have been used in
2718          * device_create_file(), but device_remove_file() will ignore them
2719          */
2720         int i;
2721         struct nct6775_data *data = dev_get_drvdata(dev);
2722
2723         for (i = 0; i < data->pwm_num; i++)
2724                 sysfs_remove_group(&dev->kobj, &nct6775_group_pwm[i]);
2725
2726         for (i = 0; i < ARRAY_SIZE(sda_weight_duty_base); i++)
2727                 device_remove_file(dev, &sda_weight_duty_base[i].dev_attr);
2728
2729         for (i = 0; i < ARRAY_SIZE(sda_auto_pwm_arrays); i++)
2730                 device_remove_file(dev, &sda_auto_pwm_arrays[i].dev_attr);
2731
2732         for (i = 0; i < data->in_num; i++)
2733                 sysfs_remove_group(&dev->kobj, &nct6775_group_in[i]);
2734
2735         for (i = 0; i < 5; i++) {
2736                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
2737                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
2738                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
2739                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
2740         }
2741         for (i = 0; i < NUM_REG_TEMP; i++) {
2742                 if (!(data->have_temp & (1 << i)))
2743                         continue;
2744                 device_remove_file(dev, &sda_temp_input[i].dev_attr);
2745                 device_remove_file(dev, &sda_temp_label[i].dev_attr);
2746                 device_remove_file(dev, &sda_temp_max[i].dev_attr);
2747                 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
2748                 if (i > 2)
2749                         continue;
2750                 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
2751                 device_remove_file(dev, &sda_temp_type[i].dev_attr);
2752                 device_remove_file(dev, &sda_temp_offset[i].dev_attr);
2753         }
2754
2755         device_remove_file(dev, &sda_caseopen[0].dev_attr);
2756         device_remove_file(dev, &sda_caseopen[1].dev_attr);
2757
2758         device_remove_file(dev, &dev_attr_name);
2759         device_remove_file(dev, &dev_attr_cpu0_vid);
2760 }
2761
2762 /* Get the monitoring functions started */
2763 static inline void __devinit nct6775_init_device(struct nct6775_data *data)
2764 {
2765         int i;
2766         u8 tmp;
2767
2768         /* Start monitoring if needed */
2769         tmp = nct6775_read_value(data, NCT6775_REG_CONFIG);
2770         if (!(tmp & 0x01))
2771                 nct6775_write_value(data, NCT6775_REG_CONFIG,
2772                                       tmp | 0x01);
2773
2774         /* Enable temperature sensors if needed */
2775         for (i = 0; i < NUM_REG_TEMP; i++) {
2776                 if (!(data->have_temp & (1 << i)))
2777                         continue;
2778                 if (!data->reg_temp_config[i])
2779                         continue;
2780                 tmp = nct6775_read_value(data, data->reg_temp_config[i]);
2781                 if (tmp & 0x01)
2782                         nct6775_write_value(data, data->reg_temp_config[i],
2783                                             tmp & 0xfe);
2784         }
2785
2786         /* Enable VBAT monitoring if needed */
2787         tmp = nct6775_read_value(data, NCT6775_REG_VBAT);
2788         if (!(tmp & 0x01))
2789                 nct6775_write_value(data, NCT6775_REG_VBAT, tmp | 0x01);
2790
2791         for (i = 0; i < 3; i++) {
2792                 const char *label = NULL;
2793
2794                 if (data->temp_label)
2795                         label = data->temp_label[data->temp_src[i]];
2796
2797                 /* Digital source overrides analog type */
2798                 if (label && strncmp(label, "PECI", 4) == 0)
2799                         data->temp_type[i] = 6;
2800                 else if (label && strncmp(label, "AMD", 3) == 0)
2801                         data->temp_type[i] = 5;
2802                 else if ((tmp & (0x02 << i)))
2803                         data->temp_type[i] = 1; /* diode */
2804                 else
2805                         data->temp_type[i] = 4; /* thermistor */
2806         }
2807 }
2808
2809 static void w82627ehf_swap_tempreg(struct nct6775_data *data,
2810                                    int r1, int r2)
2811 {
2812         u16 tmp, i;
2813
2814         tmp = data->temp_src[r1];
2815         data->temp_src[r1] = data->temp_src[r2];
2816         data->temp_src[r2] = tmp;
2817
2818         for (i = 0; i < 3; i++) {
2819                 tmp = data->reg_temp[i][r1];
2820                 data->reg_temp[i][r1] = data->reg_temp[i][r2];
2821                 data->reg_temp[i][r2] = tmp;
2822         }
2823
2824         tmp = data->reg_temp_config[r1];
2825         data->reg_temp_config[r1] = data->reg_temp_config[r2];
2826         data->reg_temp_config[r2] = tmp;
2827 }
2828
2829 static void __devinit
2830 nct6775_check_fan_inputs(const struct nct6775_sio_data *sio_data,
2831                          struct nct6775_data *data)
2832 {
2833         int regval;
2834         bool fan3pin, fan3min, fan4pin, fan4min, fan5pin;
2835         bool pwm3pin, pwm4pin, pwm5pin;
2836
2837         superio_enter(sio_data->sioreg);
2838
2839         /* fan4 and fan5 share some pins with the GPIO and serial flash */
2840         if (data->kind == nct6775) {
2841                 regval = superio_inb(sio_data->sioreg, 0x2c);
2842
2843                 fan3pin = regval & (1 << 6);
2844                 fan3min = fan3pin;
2845                 pwm3pin = regval & (1 << 7);
2846
2847                 /* On NCT6775, fan4 shares pins with the fdc interface */
2848                 fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
2849                 fan4min = 0;
2850                 fan5pin = 0;
2851                 pwm4pin = 0;
2852                 pwm5pin = 0;
2853         } else if (data->kind == nct6776) {
2854                 bool gpok = superio_inb(sio_data->sioreg, 0x27) & 0x80;
2855
2856                 superio_select(sio_data->sioreg, NCT6775_LD_HWM);
2857                 regval = superio_inb(sio_data->sioreg, SIO_REG_ENABLE);
2858
2859                 if (regval & 0x80)
2860                         fan3pin = gpok;
2861                 else
2862                         fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
2863
2864                 if (regval & 0x40)
2865                         fan4pin = gpok;
2866                 else
2867                         fan4pin = superio_inb(sio_data->sioreg, 0x1C) & 0x01;
2868
2869                 if (regval & 0x20)
2870                         fan5pin = gpok;
2871                 else
2872                         fan5pin = superio_inb(sio_data->sioreg, 0x1C) & 0x02;
2873
2874                 fan4min = fan4pin;
2875                 fan3min = fan3pin;
2876                 pwm3pin = fan3pin;
2877                 pwm4pin = 0;
2878                 pwm5pin = 0;
2879         } else {        /* NCT6779D */
2880                 regval = superio_inb(sio_data->sioreg, 0x1c);
2881
2882                 fan3pin = !(regval & (1 << 5));
2883                 fan4pin = !(regval & (1 << 6));
2884                 fan5pin = !(regval & (1 << 7));
2885
2886                 pwm3pin = !(regval & (1 << 0));
2887                 pwm4pin = !(regval & (1 << 1));
2888                 pwm5pin = !(regval & (1 << 2));
2889
2890                 fan3min = 0;
2891                 fan4min = 0;
2892         }
2893
2894         superio_exit(sio_data->sioreg);
2895
2896         data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
2897         data->has_fan |= (fan3pin << 2);
2898         data->has_fan_min |= (fan3min << 2);
2899
2900         data->has_fan |= (fan4pin << 3) | (fan5pin << 4);
2901         data->has_fan_min |= (fan4min << 3) | (fan5pin << 4);
2902
2903         data->has_pwm = 0x03 | (pwm3pin << 2) | (pwm4pin << 3) | (pwm5pin << 4);
2904 }
2905
2906 static int __devinit nct6775_probe(struct platform_device *pdev)
2907 {
2908         struct device *dev = &pdev->dev;
2909         struct nct6775_sio_data *sio_data = dev->platform_data;
2910         struct nct6775_data *data;
2911         struct resource *res;
2912         int i, err = 0;
2913         int src, mask = 0;
2914         const u16 *reg_temp, *reg_temp_over, *reg_temp_hyst, *reg_temp_config;
2915
2916         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
2917         if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
2918                 err = -EBUSY;
2919                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
2920                         (unsigned long)res->start,
2921                         (unsigned long)res->start + IOREGION_LENGTH - 1);
2922                 goto exit;
2923         }
2924
2925         data = devm_kzalloc(&pdev->dev, sizeof(struct nct6775_data),
2926                             GFP_KERNEL);
2927         if (!data) {
2928                 err = -ENOMEM;
2929                 goto exit_release;
2930         }
2931
2932         data->kind = sio_data->kind;
2933         data->addr = res->start;
2934         mutex_init(&data->lock);
2935         mutex_init(&data->update_lock);
2936         data->name = nct6775_device_names[data->kind];
2937         platform_set_drvdata(pdev, data);
2938
2939         switch (data->kind) {
2940         case nct6775:
2941                 data->in_num = 9;
2942                 data->have_in = 0x1ff;
2943                 data->pwm_num = 3;
2944                 data->auto_pwm_num = 6;
2945                 data->has_fan_div = true;
2946
2947                 data->fan_from_reg = fan_from_reg16;
2948                 data->fan_from_reg_min = fan_from_reg8;
2949
2950                 data->REG_VIN = NCT6775_REG_IN;
2951                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
2952                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
2953                 data->REG_TARGET = NCT6775_REG_TARGET;
2954                 data->REG_FAN = NCT6775_REG_FAN;
2955                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
2956                 data->REG_FAN_MIN = NCT6775_REG_FAN_MIN;
2957                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
2958                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
2959                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
2960                 data->REG_PWM[0] = NCT6775_REG_PWM;
2961                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
2962                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
2963                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
2964                 data->REG_PWM_MODE = NCT6775_REG_PWM_MODE;
2965                 data->PWM_MODE_MASK = NCT6775_PWM_MODE_MASK;
2966                 data->REG_TEMP_MON = NCT6775_REG_TEMP_MON;
2967                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
2968                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
2969                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
2970                 data->REG_CRITICAL_TEMP_TOLERANCE
2971                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
2972                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
2973                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
2974                 data->REG_TEMP_SEL[0] = NCT6775_REG_TEMP_SEL;
2975                 data->REG_TEMP_SEL[1] = NCT6775_REG_WEIGHT_TEMP_SEL;
2976                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
2977                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
2978                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
2979                 data->REG_WEIGHT_DUTY[0] = NCT6775_REG_WEIGHT_DUTY_STEP;
2980                 data->REG_ALARM = NCT6775_REG_ALARM;
2981                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
2982                 data->CASEOPEN_MASK = NCT6775_CASEOPEN_MASK;
2983
2984                 reg_temp = NCT6775_REG_TEMP;
2985                 reg_temp_over = NCT6775_REG_TEMP_OVER;
2986                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
2987                 reg_temp_config = NCT6775_REG_TEMP_CONFIG;
2988
2989                 break;
2990         case nct6776:
2991                 data->in_num = 9;
2992                 data->have_in = 0x1ff;
2993                 data->pwm_num = 3;
2994                 data->auto_pwm_num = 4;
2995                 data->has_fan_div = false;
2996                 data->fan_from_reg = fan_from_reg13;
2997                 data->fan_from_reg_min = fan_from_reg13;
2998                 data->REG_VIN = NCT6775_REG_IN;
2999                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3000                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3001                 data->REG_TARGET = NCT6775_REG_TARGET;
3002                 data->REG_FAN = NCT6775_REG_FAN;
3003                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3004                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3005                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3006                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3007                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3008                 data->REG_PWM[0] = NCT6775_REG_PWM;
3009                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3010                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3011                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3012                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3013                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3014                 data->REG_TEMP_MON = NCT6775_REG_TEMP_MON;
3015                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3016                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3017                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3018                 data->REG_CRITICAL_TEMP_TOLERANCE
3019                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3020                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3021                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3022                 data->REG_TEMP_SEL[0] = NCT6775_REG_TEMP_SEL;
3023                 data->REG_TEMP_SEL[1] = NCT6775_REG_WEIGHT_TEMP_SEL;
3024                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3025                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3026                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3027                 data->REG_WEIGHT_DUTY[0] = NCT6775_REG_WEIGHT_DUTY_STEP;
3028                 data->REG_WEIGHT_DUTY[1] = NCT6776_REG_WEIGHT_DUTY_BASE;
3029                 data->REG_ALARM = NCT6775_REG_ALARM;
3030                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
3031                 data->CASEOPEN_MASK = NCT6776_CASEOPEN_MASK;
3032
3033                 reg_temp = NCT6775_REG_TEMP;
3034                 reg_temp_over = NCT6775_REG_TEMP_OVER;
3035                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
3036                 reg_temp_config = NCT6776_REG_TEMP_CONFIG;
3037
3038                 break;
3039         case nct6779:
3040                 data->in_num = 15;
3041                 data->have_in = 0x7fff;
3042                 data->pwm_num = 5;
3043                 data->auto_pwm_num = 4;
3044                 data->has_fan_div = false;
3045
3046                 data->fan_from_reg = fan_from_reg13;
3047                 data->fan_from_reg_min = fan_from_reg13;
3048
3049                 data->REG_VIN = NCT6779_REG_IN;
3050                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3051                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3052                 data->REG_TARGET = NCT6775_REG_TARGET;
3053                 data->REG_FAN = NCT6779_REG_FAN;
3054                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3055                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3056                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3057                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3058                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3059                 data->REG_PWM[0] = NCT6775_REG_PWM;
3060                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3061                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3062                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3063                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3064                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3065                 data->REG_TEMP_MON = NCT6775_REG_TEMP_MON;
3066                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3067                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3068                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3069                 data->REG_CRITICAL_TEMP_TOLERANCE
3070                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3071                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3072                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3073                 data->REG_TEMP_SEL[0] = NCT6775_REG_TEMP_SEL;
3074                 data->REG_TEMP_SEL[1] = NCT6775_REG_WEIGHT_TEMP_SEL;
3075                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3076                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3077                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3078                 data->REG_WEIGHT_DUTY[0] = NCT6775_REG_WEIGHT_DUTY_STEP;
3079                 data->REG_WEIGHT_DUTY[1] = NCT6776_REG_WEIGHT_DUTY_BASE;
3080                 data->REG_ALARM = NCT6779_REG_ALARM;
3081                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
3082                 data->CASEOPEN_MASK = NCT6776_CASEOPEN_MASK;
3083
3084                 reg_temp = NCT6779_REG_TEMP;
3085                 reg_temp_over = NCT6775_REG_TEMP_OVER;
3086                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
3087                 reg_temp_config = NCT6776_REG_TEMP_CONFIG;
3088
3089                 break;
3090         default:
3091                 err = -ENODEV;
3092                 goto exit_release;
3093         }
3094
3095         /* Default to no temperature inputs, code below will adjust as needed */
3096         data->have_temp = 0;
3097
3098         for (i = 0; i < NUM_REG_TEMP; i++) {
3099                 if (reg_temp[i] == 0)
3100                         continue;
3101
3102                 data->reg_temp[0][i] = reg_temp[i];
3103                 data->reg_temp[1][i] = reg_temp_over[i];
3104                 data->reg_temp[2][i] = reg_temp_hyst[i];
3105                 data->reg_temp_config[i] = reg_temp_config[i];
3106
3107                 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]);
3108                 src &= 0x1f;
3109
3110                 if (src && !(mask & (1 << src))) {
3111                         data->have_temp |= 1 << i;
3112                         mask |= 1 << src;
3113                 }
3114
3115                 data->temp_src[i] = src;
3116
3117                 /*
3118                  * Do some register swapping if index 0..2 don't
3119                  * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
3120                  * Idea is to have the first three attributes
3121                  * report SYSTIN, CPUIN, and AUXIN if possible
3122                  * without overriding the basic system configuration.
3123                  * Do this only for the first six temperature sources;
3124                  * the remaining temperatures are fan control sources,
3125                  * and we don't want to touch those.
3126                  */
3127                 if (i > 0 && data->temp_src[0] != 1
3128                             && data->temp_src[i] == 1)
3129                                 w82627ehf_swap_tempreg(data, 0, i);
3130                 if (i > 1 && data->temp_src[1] != 2
3131                             && data->temp_src[i] == 2)
3132                                 w82627ehf_swap_tempreg(data, 1, i);
3133                 if (i > 2 && data->temp_src[2] != 3
3134                             && data->temp_src[i] == 3)
3135                                 w82627ehf_swap_tempreg(data, 2, i);
3136         }
3137         data->have_temp_offset = data->have_temp & 0x07;
3138         for (i = 0; i < 3; i++) {
3139                 if (data->temp_src[i] > 3)
3140                         data->have_temp_offset &= ~(1 << i);
3141         }
3142
3143         switch (data->kind) {
3144         case nct6775:
3145                 data->temp_label = nct6775_temp_label;
3146                 break;
3147         case nct6776:
3148                 /*
3149                  * On NCT6776, AUXTIN and VIN3 pins are shared.
3150                  * Only way to detect it is to check if AUXTIN is used
3151                  * as a temperature source, and if that source is
3152                  * enabled.
3153                  *
3154                  * If that is the case, disable in6, which reports VIN3.
3155                  * Otherwise disable temp3.
3156                  */
3157                 if (data->temp_src[2] == 3) {
3158                         u8 reg;
3159
3160                         if (data->reg_temp_config[2])
3161                                 reg = nct6775_read_value(data,
3162                                         data->reg_temp_config[2]);
3163                         else
3164                                 reg = 0; /* Assume AUXTIN is used */
3165
3166                         if (reg & 0x01)
3167                                 data->have_temp &= ~(1 << 2);
3168                         else
3169                                 data->have_in &= ~(1 << 6);
3170                 }
3171                 data->temp_label = nct6776_temp_label;
3172                 break;
3173         case nct6779:
3174                 /*
3175                  * Shared pins:
3176                  *      VIN4 / AUXTIN0
3177                  *      VIN5 / AUXTIN1
3178                  *      VIN6 / AUXTIN2
3179                  *      VIN7 / AUXTIN3
3180                  * Assume voltage is disabled if the respective temperature is
3181                  * used as temperature source.
3182                  */
3183                 for (i = 0; i < ARRAY_SIZE(NCT6779_REG_TEMP); i++) {
3184                         if (!(data->have_temp & (1 << i)))
3185                                 continue;
3186                         if (data->temp_src[i] == 3)             /* AUXTIN0 */
3187                                 data->have_in &= ~(1 << 6);     /* no VIN4 */
3188                         if (data->temp_src[i] == 4)             /* AUXTIN1 */
3189                                 data->have_in &= ~(1 << 10);    /* no VIN5 */
3190                         if (data->temp_src[i] == 5)             /* AUXTIN2 */
3191                                 data->have_in &= ~(1 << 11);    /* no VIN6 */
3192                         if (data->temp_src[i] == 6)             /* AUXTIN0 */
3193                                 data->have_in &= ~(1 << 14);    /* no VIN7 */
3194                 }
3195                 data->temp_label = nct6779_temp_label;
3196                 break;
3197         }
3198
3199         /* Initialize the chip */
3200         nct6775_init_device(data);
3201
3202         data->vrm = vid_which_vrm();
3203         superio_enter(sio_data->sioreg);
3204         /*
3205          * Read VID value
3206          * We can get the VID input values directly at logical device D 0xe3.
3207          */
3208         superio_select(sio_data->sioreg, NCT6775_LD_VID);
3209         data->vid = superio_inb(sio_data->sioreg, 0xe3);
3210         err = device_create_file(dev, &dev_attr_cpu0_vid);
3211         if (err)
3212                 goto exit_release;
3213
3214         if (fan_debounce) {
3215                 u8 tmp;
3216
3217                 superio_select(sio_data->sioreg, NCT6775_LD_HWM);
3218                 tmp = superio_inb(sio_data->sioreg,
3219                                   NCT6775_REG_CR_FAN_DEBOUNCE);
3220                 switch (data->kind) {
3221                 case nct6775:
3222                         tmp |= 0x1e;
3223                         break;
3224                 case nct6776:
3225                 case nct6779:
3226                         tmp |= 0x3e;
3227                         break;
3228                 }
3229                 superio_outb(sio_data->sioreg, NCT6775_REG_CR_FAN_DEBOUNCE,
3230                              tmp);
3231                 pr_info("Enabled fan debounce for chip %s\n", data->name);
3232         }
3233
3234         superio_exit(sio_data->sioreg);
3235
3236         nct6775_check_fan_inputs(sio_data, data);
3237
3238         /* Read fan clock dividers immediately */
3239         nct6775_update_fan_div_common(dev, data);
3240
3241         /* Register sysfs hooks */
3242         for (i = 0; i < data->pwm_num; i++) {
3243                 if (!(data->has_pwm & (1 << i)))
3244                         continue;
3245
3246                 err = sysfs_create_group(&dev->kobj, &nct6775_group_pwm[i]);
3247                 if (err)
3248                         goto exit_remove;
3249
3250                 if (data->REG_WEIGHT_DUTY[1]) {
3251                         err = device_create_file(dev,
3252                                         &sda_weight_duty_base[i].dev_attr);
3253                         if (err)
3254                                 goto exit_remove;
3255                 }
3256         }
3257         for (i = 0; i < ARRAY_SIZE(sda_auto_pwm_arrays); i++) {
3258                 struct sensor_device_attribute_2 *attr =
3259                         &sda_auto_pwm_arrays[i];
3260
3261                 if (!(data->has_pwm & (1 << attr->nr)))
3262                         continue;
3263                 if (attr->index > data->auto_pwm_num)
3264                         continue;
3265                 err = device_create_file(dev, &attr->dev_attr);
3266                 if (err)
3267                         goto exit_remove;
3268         }
3269
3270         for (i = 0; i < data->in_num; i++) {
3271                 if (!(data->have_in & (1 << i)))
3272                         continue;
3273                 err = sysfs_create_group(&dev->kobj, &nct6775_group_in[i]);
3274                 if (err)
3275                         goto exit_remove;
3276         }
3277
3278         for (i = 0; i < 5; i++) {
3279                 if (data->has_fan & (1 << i)) {
3280                         err = device_create_file(dev,
3281                                                  &sda_fan_input[i].dev_attr);
3282                         if (err)
3283                                 goto exit_remove;
3284                         err = device_create_file(dev,
3285                                                  &sda_fan_alarm[i].dev_attr);
3286                         if (err)
3287                                 goto exit_remove;
3288                         if (data->kind != nct6776 &&
3289                             data->kind != nct6779) {
3290                                 err = device_create_file(dev,
3291                                                 &sda_fan_div[i].dev_attr);
3292                                 if (err)
3293                                         goto exit_remove;
3294                         }
3295                         if (data->has_fan_min & (1 << i)) {
3296                                 err = device_create_file(dev,
3297                                                 &sda_fan_min[i].dev_attr);
3298                                 if (err)
3299                                         goto exit_remove;
3300                         }
3301                 }
3302         }
3303
3304         for (i = 0; i < NUM_REG_TEMP; i++) {
3305                 if (!(data->have_temp & (1 << i)))
3306                         continue;
3307                 err = device_create_file(dev, &sda_temp_input[i].dev_attr);
3308                 if (err)
3309                         goto exit_remove;
3310                 if (data->temp_label) {
3311                         err = device_create_file(dev,
3312                                                  &sda_temp_label[i].dev_attr);
3313                         if (err)
3314                                 goto exit_remove;
3315                 }
3316                 if (data->reg_temp[1][i]) {
3317                         err = device_create_file(dev,
3318                                                  &sda_temp_max[i].dev_attr);
3319                         if (err)
3320                                 goto exit_remove;
3321                 }
3322                 if (data->reg_temp[2][i]) {
3323                         err = device_create_file(dev,
3324                                         &sda_temp_max_hyst[i].dev_attr);
3325                         if (err)
3326                                 goto exit_remove;
3327                 }
3328                 if (i > 2)
3329                         continue;
3330                 err = device_create_file(dev, &sda_temp_alarm[i].dev_attr);
3331                 if (err)
3332                         goto exit_remove;
3333                 err = device_create_file(dev, &sda_temp_type[i].dev_attr);
3334                 if (err)
3335                         goto exit_remove;
3336                 if (data->have_temp_offset & (1 << i)) {
3337                         err = device_create_file(dev,
3338                                                  &sda_temp_offset[i].dev_attr);
3339                         if (err)
3340                                 goto exit_remove;
3341                 }
3342         }
3343
3344         for (i = 0; i < ARRAY_SIZE(sda_caseopen); i++) {
3345                 if (!data->CASEOPEN_MASK[i])
3346                         continue;
3347                 err = device_create_file(dev, &sda_caseopen[i].dev_attr);
3348                 if (err)
3349                         goto exit_remove;
3350         }
3351
3352         err = device_create_file(dev, &dev_attr_name);
3353         if (err)
3354                 goto exit_remove;
3355
3356         data->hwmon_dev = hwmon_device_register(dev);
3357         if (IS_ERR(data->hwmon_dev)) {
3358                 err = PTR_ERR(data->hwmon_dev);
3359                 goto exit_remove;
3360         }
3361
3362         return 0;
3363
3364 exit_remove:
3365         nct6775_device_remove_files(dev);
3366 exit_release:
3367         release_region(res->start, IOREGION_LENGTH);
3368 exit:
3369         return err;
3370 }
3371
3372 static int __devexit nct6775_remove(struct platform_device *pdev)
3373 {
3374         struct nct6775_data *data = platform_get_drvdata(pdev);
3375
3376         hwmon_device_unregister(data->hwmon_dev);
3377         nct6775_device_remove_files(&pdev->dev);
3378         release_region(data->addr, IOREGION_LENGTH);
3379
3380         return 0;
3381 }
3382
3383 static struct platform_driver nct6775_driver = {
3384         .driver = {
3385                 .owner  = THIS_MODULE,
3386                 .name   = DRVNAME,
3387         },
3388         .probe          = nct6775_probe,
3389         .remove         = __devexit_p(nct6775_remove),
3390 };
3391
3392 /* nct6775_find() looks for a '627 in the Super-I/O config space */
3393 static int __init nct6775_find(int sioaddr, unsigned short *addr,
3394                                struct nct6775_sio_data *sio_data)
3395 {
3396         static const char __initdata sio_name_NCT6775[] = "NCT6775F";
3397         static const char __initdata sio_name_NCT6776[] = "NCT6776F";
3398         static const char __initdata sio_name_NCT6779[] = "NCT6779F";
3399
3400         u16 val;
3401         const char *sio_name;
3402
3403         superio_enter(sioaddr);
3404
3405         if (force_id)
3406                 val = force_id;
3407         else
3408                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
3409                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
3410         switch (val & SIO_ID_MASK) {
3411         case SIO_NCT6775_ID:
3412                 sio_data->kind = nct6775;
3413                 sio_name = sio_name_NCT6775;
3414                 break;
3415         case SIO_NCT6776_ID:
3416                 sio_data->kind = nct6776;
3417                 sio_name = sio_name_NCT6776;
3418                 break;
3419         case SIO_NCT6779_ID:
3420                 sio_data->kind = nct6779;
3421                 sio_name = sio_name_NCT6779;
3422                 break;
3423         default:
3424                 if (val != 0xffff)
3425                         pr_debug("unsupported chip ID: 0x%04x\n", val);
3426                 superio_exit(sioaddr);
3427                 return -ENODEV;
3428         }
3429
3430         /* We have a known chip, find the HWM I/O address */
3431         superio_select(sioaddr, NCT6775_LD_HWM);
3432         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
3433             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
3434         *addr = val & IOREGION_ALIGNMENT;
3435         if (*addr == 0) {
3436                 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n");
3437                 superio_exit(sioaddr);
3438                 return -ENODEV;
3439         }
3440
3441         /* Activate logical device if needed */
3442         val = superio_inb(sioaddr, SIO_REG_ENABLE);
3443         if (!(val & 0x01)) {
3444                 pr_warn("Forcibly enabling Super-I/O. "
3445                         "Sensor is probably unusable.\n");
3446                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
3447         }
3448
3449         superio_exit(sioaddr);
3450         pr_info("Found %s chip at %#x\n", sio_name, *addr);
3451         sio_data->sioreg = sioaddr;
3452
3453         return 0;
3454 }
3455
3456 /*
3457  * when Super-I/O functions move to a separate file, the Super-I/O
3458  * bus will manage the lifetime of the device and this module will only keep
3459  * track of the nct6775 driver. But since we platform_device_alloc(), we
3460  * must keep track of the device
3461  */
3462 static struct platform_device *pdev;
3463
3464 static int __init sensors_nct6775_init(void)
3465 {
3466         int err;
3467         unsigned short address;
3468         struct resource res;
3469         struct nct6775_sio_data sio_data;
3470
3471         /*
3472          * initialize sio_data->kind and sio_data->sioreg.
3473          *
3474          * when Super-I/O functions move to a separate file, the Super-I/O
3475          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
3476          * nct6775 hardware monitor, and call probe()
3477          */
3478         if (nct6775_find(0x2e, &address, &sio_data) &&
3479             nct6775_find(0x4e, &address, &sio_data))
3480                 return -ENODEV;
3481
3482         err = platform_driver_register(&nct6775_driver);
3483         if (err)
3484                 goto exit;
3485
3486         pdev = platform_device_alloc(DRVNAME, address);
3487         if (!pdev) {
3488                 err = -ENOMEM;
3489                 pr_err("Device allocation failed\n");
3490                 goto exit_unregister;
3491         }
3492
3493         err = platform_device_add_data(pdev, &sio_data,
3494                                        sizeof(struct nct6775_sio_data));
3495         if (err) {
3496                 pr_err("Platform data allocation failed\n");
3497                 goto exit_device_put;
3498         }
3499
3500         memset(&res, 0, sizeof(res));
3501         res.name = DRVNAME;
3502         res.start = address + IOREGION_OFFSET;
3503         res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
3504         res.flags = IORESOURCE_IO;
3505
3506         err = acpi_check_resource_conflict(&res);
3507         if (err)
3508                 goto exit_device_put;
3509
3510         err = platform_device_add_resources(pdev, &res, 1);
3511         if (err) {
3512                 pr_err("Device resource addition failed (%d)\n", err);
3513                 goto exit_device_put;
3514         }
3515
3516         /* platform_device_add calls probe() */
3517         err = platform_device_add(pdev);
3518         if (err) {
3519                 pr_err("Device addition failed (%d)\n", err);
3520                 goto exit_device_put;
3521         }
3522
3523         return 0;
3524
3525 exit_device_put:
3526         platform_device_put(pdev);
3527 exit_unregister:
3528         platform_driver_unregister(&nct6775_driver);
3529 exit:
3530         return err;
3531 }
3532
3533 static void __exit sensors_nct6775_exit(void)
3534 {
3535         platform_device_unregister(pdev);
3536         platform_driver_unregister(&nct6775_driver);
3537 }
3538
3539 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
3540 MODULE_DESCRIPTION("NCT677x driver");
3541 MODULE_LICENSE("GPL");
3542
3543 module_init(sensors_nct6775_init);
3544 module_exit(sensors_nct6775_exit);