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