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