drivers/hwmon/nct6775-core.c

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