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