git.sur5r.net Git - groeck-nct6775/blob - nct6775.c

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