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