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