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