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