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