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       9      0xb470 0xc1    0x5ca3
  37  * nct6776f     9      5       3       9      0xc330 0xc1    0x5ca3
  38  * nct6779d    15      5       5       7      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 enum kinds { nct6775, nct6776, nct6779 };
  58
  59 /* used to set data->name = nct6775_device_names[data->sio_kind] */
  60 static const char * const nct6775_device_names[] = {
  61         "nct6775",
  62         "nct6776",
  63         "nct6779",
  64 };
  65
  66 static unsigned short force_id;
  67 module_param(force_id, ushort, 0);
  68 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  69
  70 static unsigned short fan_debounce;
  71 module_param(fan_debounce, ushort, 0);
  72 MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
  73
  74 #define DRVNAME "nct6775"
  75
  76 /*
  77  * Super-I/O constants and functions
  78  */
  79
  80 #define NCT6775_LD_ACPI         0x0a
  81 #define NCT6775_LD_HWM          0x0b
  82 #define NCT6775_LD_VID          0x0d
  83
  84 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  85 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  86 #define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
  87 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  88 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  89 #define SIO_REG_VID_CTRL        0xF0    /* VID control */
  90 #define SIO_REG_VID_DATA        0xF1    /* VID data */
  91
  92 #define SIO_NCT6775_ID          0xb470
  93 #define SIO_NCT6776_ID          0xc330
  94 #define SIO_NCT6779_ID          0xc560
  95 #define SIO_ID_MASK             0xFFF0
  96
  97 static inline void
  98 superio_outb(int ioreg, int reg, int val)
  99 {
 100         outb(reg, ioreg);
 101         outb(val, ioreg + 1);
 102 }
 103
 104 static inline int
 105 superio_inb(int ioreg, int reg)
 106 {
 107         outb(reg, ioreg);
 108         return inb(ioreg + 1);
 109 }
 110
 111 static inline void
 112 superio_select(int ioreg, int ld)
 113 {
 114         outb(SIO_REG_LDSEL, ioreg);
 115         outb(ld, ioreg + 1);
 116 }
 117
 118 static inline void
 119 superio_enter(int ioreg)
 120 {
 121         outb(0x87, ioreg);
 122         outb(0x87, ioreg);
 123 }
 124
 125 static inline void
 126 superio_exit(int ioreg)
 127 {
 128         outb(0xaa, ioreg);
 129         outb(0x02, ioreg);
 130         outb(0x02, ioreg + 1);
 131 }
 132
 133 /*
 134  * ISA constants
 135  */
 136
 137 #define IOREGION_ALIGNMENT      (~7)
 138 #define IOREGION_OFFSET         5
 139 #define IOREGION_LENGTH         2
 140 #define ADDR_REG_OFFSET         0
 141 #define DATA_REG_OFFSET         1
 142
 143 #define NCT6775_REG_BANK        0x4E
 144 #define NCT6775_REG_CONFIG      0x40
 145
 146 /*
 147  * Not currently used:
 148  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
 149  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
 150  * REG_MAN_ID is at port 0x4f
 151  * REG_CHIP_ID is at port 0x58
 152  */
 153
 154 static const u16 NCT6775_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d };
 155
 156 /* Voltage min/max registers for nr=7..14 are in bank 5 */
 157
 158 static const u16 NCT6775_REG_IN_MAX[] = {
 159         0x2b, 0x2d, 0x2f, 0x31, 0x33, 0x35, 0x37, 0x554, 0x556 };
 160 static const u16 NCT6775_REG_IN_MIN[] = {
 161         0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x555, 0x557 };
 162 static const u16 NCT6775_REG_IN[] = {
 163         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x550, 0x551, 0x552
 164 };
 165
 166 static const u16 NCT6779_REG_IN[] = {
 167         0x480, 0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487,
 168         0x488, 0x489, 0x48a, 0x48b, 0x48c, 0x48d, 0x48e
 169 };
 170
 171 #define NCT6775_REG_VBAT                0x5D
 172
 173 #define NCT6775_REG_FANDIV1             0x506
 174 #define NCT6775_REG_FANDIV2             0x507
 175
 176 #define NCT6775_REG_CR_FAN_DEBOUNCE     0xf0
 177
 178 static const u16 NCT6775_REG_ALARM[6] = { 0x459, 0x45A, 0x45B };
 179 static const u16 NCT6779_REG_ALARM[6] = { 0x459, 0x45A, 0x45B, 0x568 };
 180
 181 #define NCT6775_REG_CASEOPEN            0x42
 182
 183 static const u8 NCT6775_CASEOPEN_MASK[] = { 0x10, 0x00 };
 184 static const u8 NCT6776_CASEOPEN_MASK[] = { 0x10, 0x40 };
 185
 186 static const u8 NCT6775_REG_CR_CASEOPEN_CLR[] = { 0xe6, 0xee };
 187 static const u8 NCT6775_CR_CASEOPEN_CLR_MASK[] = { 0x20, 0x01 };
 188
 189 /* DC or PWM output fan configuration */
 190 static const u8 NCT6775_REG_PWM_MODE[] = { 0x04, 0x04, 0x12 };
 191 static const u8 NCT6775_PWM_MODE_MASK[] = { 0x01, 0x02, 0x01 };
 192
 193 static const u8 NCT6776_REG_PWM_MODE[] = { 0x04, 0, 0 };
 194 static const u8 NCT6776_PWM_MODE_MASK[] = { 0x01, 0, 0 };
 195
 196 /* Advanced Fan control, some values are common for all fans */
 197
 198 static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301, 0x801, 0x901 };
 199 static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302, 0x802, 0x902 };
 200 static const u16 NCT6775_REG_FAN_STEP_DOWN_TIME[] = {
 201         0x103, 0x203, 0x303, 0x803, 0x903 };
 202 static const u16 NCT6775_REG_FAN_STEP_UP_TIME[] = {
 203         0x104, 0x204, 0x304, 0x804, 0x904 };
 204 static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = {
 205         0x105, 0x205, 0x305, 0x805, 0x905 };
 206 static const u16 NCT6775_REG_FAN_START_OUTPUT[]
 207         = { 0x106, 0x206, 0x306, 0x806, 0x906 };
 208 static const u16 NCT6775_REG_FAN_STOP_TIME[]
 209         = { 0x107, 0x207, 0x307, 0x807, 0x907 };
 210 static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309, 0x809, 0x909 };
 211 static const u16 NCT6775_REG_PWM_READ[] = { 0x01, 0x03, 0x11, 0x13, 0x15 };
 212
 213 static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
 214
 215 static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
 216
 217 static const u16 NCT6779_REG_TOLERANCE_H[]
 218         = { 0x10c, 0x20c, 0x30c, 0x40c, 0x50c };
 219
 220 static const u16 NCT6779_REG_FAN[] = { 0x4c0, 0x4c2, 0x4c4, 0x4c6, 0x4c8 };
 221
 222 static const u16 NCT6775_REG_TEMP[11]
 223         = { 0x27, 0x150, 0x250, 0x62b, 0x62c, 0x62d, 0x73, 0x75, 0x77 };
 224 static const u16 NCT6775_REG_TEMP_CONFIG[11]
 225         = { 0, 0x152, 0x252, 0x628, 0x629, 0x62A };
 226 static const u16 NCT6775_REG_TEMP_HYST[11]
 227         = { 0x3a, 0x153, 0x253, 0x673, 0x678, 0x67D };
 228 static const u16 NCT6775_REG_TEMP_OVER[11]
 229         = { 0x39, 0x155, 0x255, 0x672, 0x677, 0x67C };
 230 static const u16 NCT6775_REG_TEMP_SOURCE[11]
 231         = { 0x621, 0x622, 0x623, 0x624, 0x625, 0x626, 0x100, 0x200, 0x300,
 232             0x800, 0x900 };
 233 static const u16 NCT6775_REG_TEMP_OFFSET[] = { 0x454, 0x455, 0x456 };
 234
 235 static const u16 NCT6776_REG_TEMP_CONFIG[11]
 236         = { 0x18, 0x152, 0x252, 0x628, 0x629, 0x62A };
 237
 238 static const u16 NCT6779_REG_TEMP[11]
 239         = { 0x27, 0x150, 0, 0, 0, 0, 0x73, 0x75, 0x77, 0x79, 0x7b };
 240
 241 static const u16 NCT6775_REG_TEMP_SOURCE_2[11]
 242         = { 0, 0, 0, 0, 0, 0, 0x139, 0x239, 0x339, 0x839, 0x939 };
 243
 244 static const u16 NCT6775_REG_AUTO_TEMP[]
 245         = { 0x121, 0x221, 0x321, 0x821, 0x921 };
 246 static const u16 NCT6775_REG_AUTO_PWM[]
 247         = { 0x127, 0x227, 0x327, 0x827, 0x927 };
 248
 249 #define NCT6775_AUTO_TEMP(data, nr, p)  ((data)->REG_AUTO_TEMP[nr] + (p))
 250 #define NCT6775_AUTO_PWM(data, nr, p)   ((data)->REG_AUTO_PWM[nr] + (p))
 251
 252 static const u16 NCT6775_REG_CRITICAL_ENAB[] = { 0x134, 0x234, 0x334 };
 253
 254 static const u16 NCT6775_REG_CRITICAL_TEMP[] = {
 255         0x135, 0x235, 0x335, 0x835, 0x935 };
 256 static const u16 NCT6775_REG_CRITICAL_TEMP_TOLERANCE[] = {
 257         0x138, 0x238, 0x338, 0x838, 0x938 };
 258
 259 static const u16 NCT6779_REG_CRITICAL_PWM_ENABLE[] = {
 260         0x136, 0x236, 0x336, 0x836, 0x936 };
 261 static const u16 NCT6779_REG_CRITICAL_PWM[] = {
 262         0x137, 0x237, 0x337, 0x837, 0x937 };
 263
 264 static const char *const nct6775_temp_label[] = {
 265         "",
 266         "SYSTIN",
 267         "CPUTIN",
 268         "AUXTIN",
 269         "AMD SB-TSI",
 270         "PECI Agent 0",
 271         "PECI Agent 1",
 272         "PECI Agent 2",
 273         "PECI Agent 3",
 274         "PECI Agent 4",
 275         "PECI Agent 5",
 276         "PECI Agent 6",
 277         "PECI Agent 7",
 278         "PCH_CHIP_CPU_MAX_TEMP",
 279         "PCH_CHIP_TEMP",
 280         "PCH_CPU_TEMP",
 281         "PCH_MCH_TEMP",
 282         "PCH_DIM0_TEMP",
 283         "PCH_DIM1_TEMP",
 284         "PCH_DIM2_TEMP",
 285         "PCH_DIM3_TEMP"
 286 };
 287
 288 static const char *const nct6776_temp_label[] = {
 289         "",
 290         "SYSTIN",
 291         "CPUTIN",
 292         "AUXTIN",
 293         "SMBUSMASTER 0",
 294         "SMBUSMASTER 1",
 295         "SMBUSMASTER 2",
 296         "SMBUSMASTER 3",
 297         "SMBUSMASTER 4",
 298         "SMBUSMASTER 5",
 299         "SMBUSMASTER 6",
 300         "SMBUSMASTER 7",
 301         "PECI Agent 0",
 302         "PECI Agent 1",
 303         "PCH_CHIP_CPU_MAX_TEMP",
 304         "PCH_CHIP_TEMP",
 305         "PCH_CPU_TEMP",
 306         "PCH_MCH_TEMP",
 307         "PCH_DIM0_TEMP",
 308         "PCH_DIM1_TEMP",
 309         "PCH_DIM2_TEMP",
 310         "PCH_DIM3_TEMP",
 311         "BYTE_TEMP"
 312 };
 313
 314 static const char *const nct6779_temp_label[] = {
 315         "",
 316         "SYSTIN",
 317         "CPUTIN",
 318         "AUXTIN0",
 319         "AUXTIN1",
 320         "AUXTIN2",
 321         "AUXTIN3",
 322         "",
 323         "SMBUSMASTER 0",
 324         "SMBUSMASTER 1",
 325         "SMBUSMASTER 2",
 326         "SMBUSMASTER 3",
 327         "SMBUSMASTER 4",
 328         "SMBUSMASTER 5",
 329         "SMBUSMASTER 6",
 330         "SMBUSMASTER 7",
 331         "PECI Agent 0",
 332         "PECI Agent 1",
 333         "PCH_CHIP_CPU_MAX_TEMP",
 334         "PCH_CHIP_TEMP",
 335         "PCH_CPU_TEMP",
 336         "PCH_MCH_TEMP",
 337         "PCH_DIM0_TEMP",
 338         "PCH_DIM1_TEMP",
 339         "PCH_DIM2_TEMP",
 340         "PCH_DIM3_TEMP",
 341         "BYTE_TEMP"
 342 };
 343
 344 #define NUM_REG_TEMP    ARRAY_SIZE(NCT6775_REG_TEMP)
 345
 346 static inline int reg_to_pwm_enable(int pwm, int mode)
 347 {
 348         if (mode == 0 && pwm == 255)
 349                 return 0;       /* off  */
 350         if (mode == 3)          /* SmartFan III */
 351                 return 2;       /* convert to thermal cruise */
 352         if (mode < 3)
 353                 return mode + 1;
 354         return 4;               /* SmartFan IV */
 355 }
 356
 357 static inline int pwm_enable_to_reg(int mode)
 358 {
 359         if (mode == 0)
 360                 return 0;
 361         if (mode < 4)
 362                 return mode - 1;
 363         return 4;
 364 }
 365
 366 /*
 367  * Conversions
 368  */
 369
 370 /* 1 is DC mode, output in ms */
 371 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
 372 {
 373         return mode ? 400 * reg : 100 * reg;
 374 }
 375
 376 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
 377 {
 378         return SENSORS_LIMIT((mode ? (msec + 200) / 400 :
 379                                         (msec + 50) / 100), 1, 255);
 380 }
 381
 382 static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
 383 {
 384         if (reg == 0 || reg == 255)
 385                 return 0;
 386         return 1350000U / (reg << divreg);
 387 }
 388
 389 static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
 390 {
 391         if ((reg & 0xff1f) == 0xff1f)
 392                 return 0;
 393
 394         reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
 395
 396         if (reg == 0)
 397                 return 0;
 398
 399         return 1350000U / reg;
 400 }
 401
 402 static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
 403 {
 404         if (reg == 0 || reg == 0xffff)
 405                 return 0;
 406
 407         /*
 408          * Even though the registers are 16 bit wide, the fan divisor
 409          * still applies.
 410          */
 411         return 1350000U / (reg << divreg);
 412 }
 413
 414 static inline unsigned int
 415 div_from_reg(u8 reg)
 416 {
 417         return 1 << reg;
 418 }
 419
 420 /*
 421  * Some of the voltage inputs have internal scaling, the tables below
 422  * contain 8 (the ADC LSB in mV) * scaling factor * 100
 423  */
 424 static const u16 scale_in[15] = {
 425         800, 800, 1600, 1600, 800, 800, 800, 1600, 1600, 800, 800, 800, 800,
 426         800, 800
 427 };
 428
 429 static inline long in_from_reg(u8 reg, u8 nr)
 430 {
 431         return DIV_ROUND_CLOSEST(reg * scale_in[nr], 100);
 432 }
 433
 434 static inline u8 in_to_reg(u32 val, u8 nr)
 435 {
 436         return SENSORS_LIMIT(DIV_ROUND_CLOSEST(val * 100, scale_in[nr]), 0,
 437                              255);
 438 }
 439
 440 /*
 441  * Data structures and manipulation thereof
 442  */
 443
 444 struct nct6775_data {
 445         int addr;       /* IO base of hw monitor block */
 446         enum kinds kind;
 447         const char *name;
 448
 449         struct device *hwmon_dev;
 450         struct mutex lock;
 451
 452         u16 reg_temp[3][NUM_REG_TEMP]; /* 0=temp, 1=temp_over, 2=temp_hyst */
 453         u16 reg_temp_config[NUM_REG_TEMP];
 454         u8 temp_src[2][NUM_REG_TEMP];
 455         const char * const *temp_label;
 456
 457         const u16 *REG_VIN;
 458         const u16 *REG_IN_MINMAX[2];
 459
 460         const u16 *REG_TARGET;
 461         const u16 *REG_FAN;
 462         const u16 *REG_FAN_MODE;
 463         const u16 *REG_FAN_MIN;
 464         const u16 *REG_FAN_TIME[3];
 465
 466         const u8 *REG_PWM_MODE;
 467         const u8 *PWM_MODE_MASK;
 468
 469         const u16 *REG_PWM[3];
 470         const u16 *REG_PWM_READ;
 471
 472         const u16 *REG_AUTO_TEMP;
 473         const u16 *REG_AUTO_PWM;
 474
 475         const u16 *REG_CRITICAL_TEMP;
 476         const u16 *REG_CRITICAL_TEMP_TOLERANCE;
 477
 478         const u16 *REG_TEMP_SOURCE;
 479         const u16 *REG_TEMP_SOURCE_2;
 480
 481         const u16 *REG_TEMP_OFFSET;
 482
 483         const u16 *REG_ALARM;
 484
 485         u8 REG_CASEOPEN;
 486         const u8 *CASEOPEN_MASK;
 487
 488         unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
 489         unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
 490
 491         struct mutex update_lock;
 492         char valid;             /* !=0 if following fields are valid */
 493         unsigned long last_updated;     /* In jiffies */
 494
 495         /* Register values */
 496         u8 bank;                /* current register bank */
 497         u8 in_num;              /* number of in inputs we have */
 498         u8 in[15][3];           /* [0]=in, [1]=in_max, [2]=in_min */
 499         unsigned int rpm[5];
 500         u16 fan_min[5];
 501         u8 fan_div[5];
 502         u8 has_pwm;
 503         u8 has_fan;             /* some fan inputs can be disabled */
 504         u8 has_fan_min;         /* some fans don't have min register */
 505         bool has_fan_div;
 506         u8 temp_type[3];
 507         s8 temp_offset[3];
 508         s16 temp[3][11];        /* 0=temp, 1=temp_over, 2=temp_hyst */
 509         u64 alarms;
 510         u8 caseopen;
 511
 512         u8 pwm_mode[5]; /* 1->DC variable voltage, 0->PWM variable duty cycle */
 513         u8 pwm_enable[5]; /* 0->off
 514                            * 1->manual
 515                            * 2->thermal cruise mode (also called SmartFan I)
 516                            * 3->fan speed cruise mode
 517                            * 4->enhanced variable thermal cruise (also called
 518                            *    SmartFan IV)
 519                            */
 520         u8 pwm_num;     /* number of pwm */
 521         u8 pwm[3][5];   /* [0]=pwm, [1]=fan_start_output, [2]=fan_stop_output */
 522         u8 target_temp[5];
 523         u8 tolerance[5][2];
 524
 525         u8 fan_time[3][5]; /* 0 = stop_time, 1 = step_up, 2 = step_down */
 526
 527         /* Automatic fan speed control registers */
 528         int auto_pwm_num;
 529         u8 auto_pwm[5][7];
 530         u8 auto_temp[5][7];
 531
 532         u8 vid;
 533         u8 vrm;
 534
 535         u16 have_temp;
 536         u16 have_temp_offset;
 537         u16 have_in;
 538 };
 539
 540 struct nct6775_sio_data {
 541         int sioreg;
 542         enum kinds kind;
 543 };
 544
 545 static bool is_word_sized(struct nct6775_data *data, u16 reg)
 546 {
 547         switch (data->kind) {
 548         case nct6775:
 549         case nct6776:
 550                 return (((reg & 0xff00) == 0x100 ||
 551                     (reg & 0xff00) == 0x200) &&
 552                    ((reg & 0x00ff) == 0x50 ||
 553                     (reg & 0x00ff) == 0x53 ||
 554                     (reg & 0x00ff) == 0x55)) ||
 555                   (reg & 0xfff0) == 0x630 ||
 556                   reg == 0x640 || reg == 0x642 ||
 557                   ((reg & 0xfff0) == 0x650 && (reg & 0x000f) >= 0x06) ||
 558                   reg == 0x73 || reg == 0x75 || reg == 0x77;
 559         case nct6779:
 560                 return reg == 0x150 || reg == 0x153 || reg == 0x155 ||
 561                   ((reg & 0xfff0) == 0x4c0 && (reg & 0x000f) < 0x09) ||
 562                   reg == 0x63a || reg == 0x63c || reg == 0x63e ||
 563                   reg == 0x640 || reg == 0x642 ||
 564                   reg == 0x73 || reg == 0x75 || reg == 0x77 || reg == 0x79 ||
 565                   reg == 0x7b;
 566         }
 567         return false;
 568 }
 569
 570 /*
 571  * On older chips, only registers 0x50-0x5f are banked.
 572  * On more recent chips, all registers are banked.
 573  * Assume that is the case and set the bank number for each access.
 574  * Cache the bank number so it only needs to be set if it changes.
 575  */
 576 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg)
 577 {
 578         u8 bank = reg >> 8;
 579         if (data->bank != bank) {
 580                 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET);
 581                 outb_p(bank, data->addr + DATA_REG_OFFSET);
 582                 data->bank = bank;
 583         }
 584 }
 585
 586 static u16 nct6775_read_value(struct nct6775_data *data, u16 reg)
 587 {
 588         int res, word_sized = is_word_sized(data, reg);
 589
 590         mutex_lock(&data->lock);
 591
 592         nct6775_set_bank(data, reg);
 593         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 594         res = inb_p(data->addr + DATA_REG_OFFSET);
 595         if (word_sized) {
 596                 outb_p((reg & 0xff) + 1,
 597                        data->addr + ADDR_REG_OFFSET);
 598                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
 599         }
 600
 601         mutex_unlock(&data->lock);
 602         return res;
 603 }
 604
 605 static int nct6775_write_value(struct nct6775_data *data, u16 reg,
 606                                  u16 value)
 607 {
 608         int word_sized = is_word_sized(data, reg);
 609
 610         mutex_lock(&data->lock);
 611
 612         nct6775_set_bank(data, reg);
 613         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 614         if (word_sized) {
 615                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
 616                 outb_p((reg & 0xff) + 1,
 617                        data->addr + ADDR_REG_OFFSET);
 618         }
 619         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
 620
 621         mutex_unlock(&data->lock);
 622         return 0;
 623 }
 624
 625 /* We left-align 8-bit temperature values to make the code simpler */
 626 static u16 nct6775_read_temp(struct nct6775_data *data, u16 reg)
 627 {
 628         u16 res;
 629
 630         res = nct6775_read_value(data, reg);
 631         if (!is_word_sized(data, reg))
 632                 res <<= 8;
 633
 634         return res;
 635 }
 636
 637 static int nct6775_write_temp(struct nct6775_data *data, u16 reg,
 638                                        u16 value)
 639 {
 640         if (!is_word_sized(data, reg))
 641                 value >>= 8;
 642         return nct6775_write_value(data, reg, value);
 643 }
 644
 645 /* This function assumes that the caller holds data->update_lock */
 646 static void nct6775_write_fan_div(struct nct6775_data *data, int nr)
 647 {
 648         u8 reg;
 649
 650         switch (nr) {
 651         case 0:
 652                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
 653                     | (data->fan_div[0] & 0x7);
 654                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
 655                 break;
 656         case 1:
 657                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
 658                     | ((data->fan_div[1] << 4) & 0x70);
 659                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
 660         case 2:
 661                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
 662                     | (data->fan_div[2] & 0x7);
 663                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
 664                 break;
 665         case 3:
 666                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
 667                     | ((data->fan_div[3] << 4) & 0x70);
 668                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
 669                 break;
 670         }
 671 }
 672
 673 static void nct6775_write_fan_div_common(struct device *dev,
 674                                            struct nct6775_data *data, int nr)
 675 {
 676         if (data->kind == nct6775)
 677                 nct6775_write_fan_div(data, nr);
 678 }
 679
 680 static void nct6775_update_fan_div(struct nct6775_data *data)
 681 {
 682         u8 i;
 683
 684         i = nct6775_read_value(data, NCT6775_REG_FANDIV1);
 685         data->fan_div[0] = i & 0x7;
 686         data->fan_div[1] = (i & 0x70) >> 4;
 687         i = nct6775_read_value(data, NCT6775_REG_FANDIV2);
 688         data->fan_div[2] = i & 0x7;
 689         if (data->has_fan & (1<<3))
 690                 data->fan_div[3] = (i & 0x70) >> 4;
 691 }
 692
 693 static void nct6775_update_fan_div_common(struct device *dev,
 694                                             struct nct6775_data *data)
 695 {
 696         if (data->kind == nct6775)
 697                 nct6775_update_fan_div(data);
 698 }
 699
 700 static void nct6775_update_pwm(struct device *dev)
 701 {
 702         struct nct6775_data *data = dev_get_drvdata(dev);
 703         int i, j;
 704         int fanmodecfg, tol;
 705         bool duty_is_dc;
 706
 707         for (i = 0; i < data->pwm_num; i++) {
 708                 if (!(data->has_pwm & (1 << i)))
 709                         continue;
 710
 711                 duty_is_dc = data->REG_PWM_MODE[i] &&
 712                   (nct6775_read_value(data, data->REG_PWM_MODE[i])
 713                    & data->PWM_MODE_MASK[i]);
 714                 data->pwm_mode[i] = duty_is_dc;
 715
 716                 fanmodecfg = nct6775_read_value(data, data->REG_FAN_MODE[i]);
 717                 for (j = 0; j < 3; j++)
 718                         data->pwm[j][i]
 719                           = nct6775_read_value(data, data->REG_PWM[j][i]);
 720
 721                 data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],
 722                                                         (fanmodecfg >> 4) & 7);
 723
 724                 data->tolerance[i][0] = fanmodecfg & 0x0f;
 725                 if (data->kind == nct6779) {
 726                         tol = nct6775_read_value(data,
 727                                                  NCT6779_REG_TOLERANCE_H[i]);
 728                         data->tolerance[i][0] |= (tol & 0x70) >> 1;
 729                 }
 730                 data->tolerance[i][1] =
 731                         nct6775_read_value(data,
 732                                         data->REG_CRITICAL_TEMP_TOLERANCE[i]);
 733         }
 734 }
 735
 736 static void nct6775_update_pwm_limits(struct device *dev)
 737 {
 738         struct nct6775_data *data = dev_get_drvdata(dev);
 739         int i, j;
 740         u8 reg;
 741
 742         for (i = 0; i < data->pwm_num; i++) {
 743                 if (!(data->has_pwm & (1 << i)))
 744                         continue;
 745
 746                 for (j = 0; j < 3; j++) {
 747                         data->fan_time[j][i] =
 748                           nct6775_read_value(data, data->REG_FAN_TIME[j][i]);
 749                 }
 750
 751                 data->target_temp[i] =
 752                         nct6775_read_value(data, data->REG_TARGET[i]) &
 753                                         (data->pwm_mode[i] ? 0xff : 0x7f);
 754                 for (j = 0; j < data->auto_pwm_num; j++) {
 755                         data->auto_pwm[i][j] =
 756                           nct6775_read_value(data,
 757                                              NCT6775_AUTO_PWM(data, i, j));
 758                         data->auto_temp[i][j] =
 759                           nct6775_read_value(data,
 760                                              NCT6775_AUTO_TEMP(data, i, j));
 761                 }
 762                 /* handle critical auto_pwm temperature data */
 763                 data->auto_temp[i][data->auto_pwm_num] =
 764                         nct6775_read_value(data, data->REG_CRITICAL_TEMP[i]);
 765
 766                 switch (data->kind) {
 767                 case nct6775:
 768                         reg = nct6775_read_value(data,
 769                                                  NCT6775_REG_CRITICAL_ENAB[i]);
 770                         data->auto_pwm[i][data->auto_pwm_num] =
 771                                                 (reg & 0x02) ? 0xff : 0x00;
 772                         break;
 773                 case nct6776:
 774                         data->auto_pwm[i][data->auto_pwm_num] = 0xff;
 775                         break;
 776                 case nct6779:
 777                         reg = nct6775_read_value(data,
 778                                         NCT6779_REG_CRITICAL_PWM_ENABLE[i]);
 779                         if (reg & 1)
 780                                 data->auto_pwm[i][data->auto_pwm_num] =
 781                                   nct6775_read_value(data,
 782                                         NCT6779_REG_CRITICAL_PWM[i]);
 783                         else
 784                                 data->auto_pwm[i][data->auto_pwm_num] = 0xff;
 785                         break;
 786                 }
 787         }
 788 }
 789
 790 static struct nct6775_data *nct6775_update_device(struct device *dev)
 791 {
 792         struct nct6775_data *data = dev_get_drvdata(dev);
 793         int i, j;
 794
 795         mutex_lock(&data->update_lock);
 796
 797         if (time_after(jiffies, data->last_updated + HZ + HZ/2)
 798          || !data->valid) {
 799                 /* Fan clock dividers */
 800                 nct6775_update_fan_div_common(dev, data);
 801
 802                 /* Measured voltages and limits */
 803                 for (i = 0; i < data->in_num; i++) {
 804                         if (!(data->have_in & (1 << i)))
 805                                 continue;
 806
 807                         data->in[i][0] = nct6775_read_value(data,
 808                                                             data->REG_VIN[i]);
 809                         data->in[i][1] = nct6775_read_value(data,
 810                                           data->REG_IN_MINMAX[0][i]);
 811                         data->in[i][2] = nct6775_read_value(data,
 812                                           data->REG_IN_MINMAX[1][i]);
 813                 }
 814
 815                 /* Measured fan speeds and limits */
 816                 for (i = 0; i < 5; i++) {
 817                         u16 reg;
 818
 819                         if (!(data->has_fan & (1 << i)))
 820                                 continue;
 821
 822                         reg = nct6775_read_value(data, data->REG_FAN[i]);
 823                         data->rpm[i] = data->fan_from_reg(reg,
 824                                                           data->fan_div[i]);
 825
 826                         if (data->has_fan_min & (1 << i))
 827                                 data->fan_min[i] = nct6775_read_value(data,
 828                                            data->REG_FAN_MIN[i]);
 829
 830                         /*
 831                          * If we failed to measure the fan speed and clock
 832                          * divider can be increased, let's try that for next
 833                          * time
 834                          */
 835                         if (data->has_fan_div
 836                             && (reg >= 0xff || (data->kind == nct6775
 837                                                 && reg == 0x00))
 838                             && data->fan_div[i] < 0x07) {
 839                                 dev_dbg(dev, "Increasing fan%d "
 840                                         "clock divider from %u to %u\n",
 841                                         i + 1, div_from_reg(data->fan_div[i]),
 842                                         div_from_reg(data->fan_div[i] + 1));
 843                                 data->fan_div[i]++;
 844                                 nct6775_write_fan_div_common(dev, data, i);
 845                                 /* Preserve min limit if possible */
 846                                 if ((data->has_fan_min & (1 << i))
 847                                  && data->fan_min[i] >= 2
 848                                  && data->fan_min[i] != 255)
 849                                         nct6775_write_value(data,
 850                                                 data->REG_FAN_MIN[i],
 851                                                 (data->fan_min[i] /= 2));
 852                         }
 853                 }
 854
 855                 nct6775_update_pwm(dev);
 856                 nct6775_update_pwm_limits(dev);
 857
 858                 /* Measured temperatures and limits */
 859                 for (i = 0; i < NUM_REG_TEMP; i++) {
 860                         if (!(data->have_temp & (1 << i)))
 861                                 continue;
 862                         for (j = 0; j < 3; j++) {
 863                                 if (data->reg_temp[j][i])
 864                                         data->temp[j][i]
 865                                           = nct6775_read_temp(data,
 866                                                 data->reg_temp[j][i]);
 867                         }
 868                         if (!(data->have_temp_offset & (1 << i)))
 869                                 continue;
 870                         data->temp_offset[i]
 871                           = nct6775_read_value(data, data->REG_TEMP_OFFSET[i]);
 872                 }
 873
 874                 data->alarms = 0;
 875                 for (i = 0; i < 6; i++) {
 876                         u8 alarm;
 877                         if (!data->REG_ALARM[i])
 878                                 continue;
 879                         alarm = nct6775_read_value(data, data->REG_ALARM[i]);
 880                         data->alarms |= (((u64)alarm) << (i << 3));
 881                 }
 882
 883                 data->caseopen = nct6775_read_value(data, data->REG_CASEOPEN);
 884
 885                 data->last_updated = jiffies;
 886                 data->valid = 1;
 887         }
 888
 889         mutex_unlock(&data->update_lock);
 890         return data;
 891 }
 892
 893 /*
 894  * Sysfs callback functions
 895  */
 896 static ssize_t
 897 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
 898 {
 899         struct nct6775_data *data = nct6775_update_device(dev);
 900         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 901         int nr = sattr->nr;
 902         int index = sattr->index;
 903         return sprintf(buf, "%ld\n", in_from_reg(data->in[nr][index], nr));
 904 }
 905
 906 static ssize_t
 907 store_in_reg(struct device *dev, struct device_attribute *attr, const char *buf,
 908              size_t count)
 909 {
 910         struct nct6775_data *data = dev_get_drvdata(dev);
 911         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 912         int nr = sattr->nr;
 913         int index = sattr->index;
 914         unsigned long val;
 915         int err = kstrtoul(buf, 10, &val);
 916         if (err < 0)
 917                 return err;
 918         mutex_lock(&data->update_lock);
 919         data->in[nr][index] = in_to_reg(val, nr);
 920         nct6775_write_value(data, data->REG_IN_MINMAX[index-1][nr],
 921                             data->in[nr][index]);
 922         mutex_unlock(&data->update_lock);
 923         return count;
 924 }
 925
 926 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 927                           char *buf)
 928 {
 929         struct nct6775_data *data = nct6775_update_device(dev);
 930         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 931         int nr = sensor_attr->index;
 932         return sprintf(buf, "%u\n",
 933                        (unsigned int)((data->alarms >> nr) & 0x01));
 934 }
 935
 936 static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, show_in_reg, NULL, 0, 0);
 937 static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_in_reg, NULL, 1, 0);
 938 static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_in_reg, NULL, 2, 0);
 939 static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, show_in_reg, NULL, 3, 0);
 940 static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, show_in_reg, NULL, 4, 0);
 941 static SENSOR_DEVICE_ATTR_2(in5_input, S_IRUGO, show_in_reg, NULL, 5, 0);
 942 static SENSOR_DEVICE_ATTR_2(in6_input, S_IRUGO, show_in_reg, NULL, 6, 0);
 943 static SENSOR_DEVICE_ATTR_2(in7_input, S_IRUGO, show_in_reg, NULL, 7, 0);
 944 static SENSOR_DEVICE_ATTR_2(in8_input, S_IRUGO, show_in_reg, NULL, 8, 0);
 945 static SENSOR_DEVICE_ATTR_2(in9_input, S_IRUGO, show_in_reg, NULL, 9, 0);
 946 static SENSOR_DEVICE_ATTR_2(in10_input, S_IRUGO, show_in_reg, NULL, 10, 0);
 947 static SENSOR_DEVICE_ATTR_2(in11_input, S_IRUGO, show_in_reg, NULL, 11, 0);
 948 static SENSOR_DEVICE_ATTR_2(in12_input, S_IRUGO, show_in_reg, NULL, 12, 0);
 949 static SENSOR_DEVICE_ATTR_2(in13_input, S_IRUGO, show_in_reg, NULL, 13, 0);
 950 static SENSOR_DEVICE_ATTR_2(in14_input, S_IRUGO, show_in_reg, NULL, 14, 0);
 951
 952 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 953 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 954 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 955 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 956 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 957 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21);
 958 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20);
 959 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
 960 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
 961 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 24);
 962 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 25);
 963 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL, 26);
 964 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL, 27);
 965 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL, 28);
 966 static SENSOR_DEVICE_ATTR(in14_alarm, S_IRUGO, show_alarm, NULL, 29);
 967
 968 static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR | S_IRUGO, show_in_reg,
 969                             store_in_reg, 0, 1);
 970 static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR | S_IRUGO, show_in_reg,
 971                             store_in_reg, 1, 1);
 972 static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR | S_IRUGO, show_in_reg,
 973                             store_in_reg, 2, 1);
 974 static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR | S_IRUGO, show_in_reg,
 975                             store_in_reg, 3, 1);
 976 static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR | S_IRUGO, show_in_reg,
 977                             store_in_reg, 4, 1);
 978 static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR | S_IRUGO, show_in_reg,
 979                             store_in_reg, 5, 1);
 980 static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR | S_IRUGO, show_in_reg,
 981                             store_in_reg, 6, 1);
 982 static SENSOR_DEVICE_ATTR_2(in7_min, S_IWUSR | S_IRUGO, show_in_reg,
 983                             store_in_reg, 7, 1);
 984 static SENSOR_DEVICE_ATTR_2(in8_min, S_IWUSR | S_IRUGO, show_in_reg,
 985                             store_in_reg, 8, 1);
 986 static SENSOR_DEVICE_ATTR_2(in9_min, S_IWUSR | S_IRUGO, show_in_reg,
 987                             store_in_reg, 9, 1);
 988 static SENSOR_DEVICE_ATTR_2(in10_min, S_IWUSR | S_IRUGO, show_in_reg,
 989                             store_in_reg, 10, 1);
 990 static SENSOR_DEVICE_ATTR_2(in11_min, S_IWUSR | S_IRUGO, show_in_reg,
 991                             store_in_reg, 11, 1);
 992 static SENSOR_DEVICE_ATTR_2(in12_min, S_IWUSR | S_IRUGO, show_in_reg,
 993                             store_in_reg, 12, 1);
 994 static SENSOR_DEVICE_ATTR_2(in13_min, S_IWUSR | S_IRUGO, show_in_reg,
 995                             store_in_reg, 13, 1);
 996 static SENSOR_DEVICE_ATTR_2(in14_min, S_IWUSR | S_IRUGO, show_in_reg,
 997                             store_in_reg, 14, 1);
 998
 999 static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR | S_IRUGO, show_in_reg,
1000                           store_in_reg, 0, 2);
1001 static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR | S_IRUGO, show_in_reg,
1002                           store_in_reg, 1, 2);
1003 static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR | S_IRUGO, show_in_reg,
1004                           store_in_reg, 2, 2);
1005 static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR | S_IRUGO, show_in_reg,
1006                           store_in_reg, 3, 2);
1007 static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR | S_IRUGO, show_in_reg,
1008                           store_in_reg, 4, 2);
1009 static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR | S_IRUGO, show_in_reg,
1010                           store_in_reg, 5, 2);
1011 static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR | S_IRUGO, show_in_reg,
1012                           store_in_reg, 6, 2);
1013 static SENSOR_DEVICE_ATTR_2(in7_max, S_IWUSR | S_IRUGO, show_in_reg,
1014                           store_in_reg, 7, 2);
1015 static SENSOR_DEVICE_ATTR_2(in8_max, S_IWUSR | S_IRUGO, show_in_reg,
1016                           store_in_reg, 8, 2);
1017 static SENSOR_DEVICE_ATTR_2(in9_max, S_IWUSR | S_IRUGO, show_in_reg,
1018                           store_in_reg, 9, 2);
1019 static SENSOR_DEVICE_ATTR_2(in10_max, S_IWUSR | S_IRUGO, show_in_reg,
1020                           store_in_reg, 10, 2);
1021 static SENSOR_DEVICE_ATTR_2(in11_max, S_IWUSR | S_IRUGO, show_in_reg,
1022                           store_in_reg, 11, 2);
1023 static SENSOR_DEVICE_ATTR_2(in12_max, S_IWUSR | S_IRUGO, show_in_reg,
1024                           store_in_reg, 12, 2);
1025 static SENSOR_DEVICE_ATTR_2(in13_max, S_IWUSR | S_IRUGO, show_in_reg,
1026                           store_in_reg, 13, 2);
1027 static SENSOR_DEVICE_ATTR_2(in14_max, S_IWUSR | S_IRUGO, show_in_reg,
1028                           store_in_reg, 14, 2);
1029
1030 static struct attribute *nct6775_attributes_in[15][5] = {
1031         {
1032                 &sensor_dev_attr_in0_input.dev_attr.attr,
1033                 &sensor_dev_attr_in0_min.dev_attr.attr,
1034                 &sensor_dev_attr_in0_max.dev_attr.attr,
1035                 &sensor_dev_attr_in0_alarm.dev_attr.attr,
1036                 NULL
1037         },
1038         {
1039                 &sensor_dev_attr_in1_input.dev_attr.attr,
1040                 &sensor_dev_attr_in1_min.dev_attr.attr,
1041                 &sensor_dev_attr_in1_max.dev_attr.attr,
1042                 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1043                 NULL
1044         },
1045         {
1046                 &sensor_dev_attr_in2_input.dev_attr.attr,
1047                 &sensor_dev_attr_in2_min.dev_attr.attr,
1048                 &sensor_dev_attr_in2_max.dev_attr.attr,
1049                 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1050                 NULL
1051         },
1052         {
1053                 &sensor_dev_attr_in3_input.dev_attr.attr,
1054                 &sensor_dev_attr_in3_min.dev_attr.attr,
1055                 &sensor_dev_attr_in3_max.dev_attr.attr,
1056                 &sensor_dev_attr_in3_alarm.dev_attr.attr,
1057                 NULL
1058         },
1059         {
1060                 &sensor_dev_attr_in4_input.dev_attr.attr,
1061                 &sensor_dev_attr_in4_min.dev_attr.attr,
1062                 &sensor_dev_attr_in4_max.dev_attr.attr,
1063                 &sensor_dev_attr_in4_alarm.dev_attr.attr,
1064                 NULL
1065         },
1066         {
1067                 &sensor_dev_attr_in5_input.dev_attr.attr,
1068                 &sensor_dev_attr_in5_min.dev_attr.attr,
1069                 &sensor_dev_attr_in5_max.dev_attr.attr,
1070                 &sensor_dev_attr_in5_alarm.dev_attr.attr,
1071                 NULL
1072         },
1073         {
1074                 &sensor_dev_attr_in6_input.dev_attr.attr,
1075                 &sensor_dev_attr_in6_min.dev_attr.attr,
1076                 &sensor_dev_attr_in6_max.dev_attr.attr,
1077                 &sensor_dev_attr_in6_alarm.dev_attr.attr,
1078                 NULL
1079         },
1080         {
1081                 &sensor_dev_attr_in7_input.dev_attr.attr,
1082                 &sensor_dev_attr_in7_min.dev_attr.attr,
1083                 &sensor_dev_attr_in7_max.dev_attr.attr,
1084                 &sensor_dev_attr_in7_alarm.dev_attr.attr,
1085                 NULL
1086         },
1087         {
1088                 &sensor_dev_attr_in8_input.dev_attr.attr,
1089                 &sensor_dev_attr_in8_min.dev_attr.attr,
1090                 &sensor_dev_attr_in8_max.dev_attr.attr,
1091                 &sensor_dev_attr_in8_alarm.dev_attr.attr,
1092                 NULL
1093         },
1094         {
1095                 &sensor_dev_attr_in9_input.dev_attr.attr,
1096                 &sensor_dev_attr_in9_min.dev_attr.attr,
1097                 &sensor_dev_attr_in9_max.dev_attr.attr,
1098                 &sensor_dev_attr_in9_alarm.dev_attr.attr,
1099                 NULL
1100         },
1101         {
1102                 &sensor_dev_attr_in10_input.dev_attr.attr,
1103                 &sensor_dev_attr_in10_min.dev_attr.attr,
1104                 &sensor_dev_attr_in10_max.dev_attr.attr,
1105                 &sensor_dev_attr_in10_alarm.dev_attr.attr,
1106                 NULL
1107         },
1108         {
1109                 &sensor_dev_attr_in11_input.dev_attr.attr,
1110                 &sensor_dev_attr_in11_min.dev_attr.attr,
1111                 &sensor_dev_attr_in11_max.dev_attr.attr,
1112                 &sensor_dev_attr_in11_alarm.dev_attr.attr,
1113                 NULL
1114         },
1115         {
1116                 &sensor_dev_attr_in12_input.dev_attr.attr,
1117                 &sensor_dev_attr_in12_min.dev_attr.attr,
1118                 &sensor_dev_attr_in12_max.dev_attr.attr,
1119                 &sensor_dev_attr_in12_alarm.dev_attr.attr,
1120                 NULL
1121         },
1122         {
1123                 &sensor_dev_attr_in13_input.dev_attr.attr,
1124                 &sensor_dev_attr_in13_min.dev_attr.attr,
1125                 &sensor_dev_attr_in13_max.dev_attr.attr,
1126                 &sensor_dev_attr_in13_alarm.dev_attr.attr,
1127                 NULL
1128         },
1129         {
1130                 &sensor_dev_attr_in14_input.dev_attr.attr,
1131                 &sensor_dev_attr_in14_min.dev_attr.attr,
1132                 &sensor_dev_attr_in14_max.dev_attr.attr,
1133                 &sensor_dev_attr_in14_alarm.dev_attr.attr,
1134                 NULL
1135         },
1136 };
1137
1138 static const struct attribute_group nct6775_group_in[15] = {
1139         { .attrs = nct6775_attributes_in[0] },
1140         { .attrs = nct6775_attributes_in[1] },
1141         { .attrs = nct6775_attributes_in[2] },
1142         { .attrs = nct6775_attributes_in[3] },
1143         { .attrs = nct6775_attributes_in[4] },
1144         { .attrs = nct6775_attributes_in[5] },
1145         { .attrs = nct6775_attributes_in[6] },
1146         { .attrs = nct6775_attributes_in[7] },
1147         { .attrs = nct6775_attributes_in[8] },
1148         { .attrs = nct6775_attributes_in[9] },
1149         { .attrs = nct6775_attributes_in[10] },
1150         { .attrs = nct6775_attributes_in[11] },
1151         { .attrs = nct6775_attributes_in[12] },
1152         { .attrs = nct6775_attributes_in[13] },
1153         { .attrs = nct6775_attributes_in[14] },
1154 };
1155
1156 static ssize_t
1157 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
1158 {
1159         struct nct6775_data *data = nct6775_update_device(dev);
1160         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1161         int nr = sensor_attr->index;
1162         return sprintf(buf, "%d\n", data->rpm[nr]);
1163 }
1164
1165 static ssize_t
1166 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
1167 {
1168         struct nct6775_data *data = nct6775_update_device(dev);
1169         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1170         int nr = sensor_attr->index;
1171         return sprintf(buf, "%d\n",
1172                        data->fan_from_reg_min(data->fan_min[nr],
1173                                               data->fan_div[nr]));
1174 }
1175
1176 static ssize_t
1177 show_fan_div(struct device *dev, struct device_attribute *attr,
1178              char *buf)
1179 {
1180         struct nct6775_data *data = nct6775_update_device(dev);
1181         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1182         int nr = sensor_attr->index;
1183         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1184 }
1185
1186 static ssize_t
1187 store_fan_min(struct device *dev, struct device_attribute *attr,
1188               const char *buf, size_t count)
1189 {
1190         struct nct6775_data *data = dev_get_drvdata(dev);
1191         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1192         int nr = sensor_attr->index;
1193         unsigned long val;
1194         int err;
1195         unsigned int reg;
1196         u8 new_div;
1197
1198         err = kstrtoul(buf, 10, &val);
1199         if (err < 0)
1200                 return err;
1201
1202         mutex_lock(&data->update_lock);
1203         if (!data->has_fan_div) {
1204                 /*
1205                  * Only NCT6776F for now, so we know that this is a 13 bit
1206                  * register
1207                  */
1208                 if (!val) {
1209                         val = 0xff1f;
1210                 } else {
1211                         if (val > 1350000U)
1212                                 val = 135000U;
1213                         val = 1350000U / val;
1214                         val = (val & 0x1f) | ((val << 3) & 0xff00);
1215                 }
1216                 data->fan_min[nr] = val;
1217                 goto write_min; /* Leave fan divider alone */
1218         }
1219         if (!val) {
1220                 /* No min limit, alarm disabled */
1221                 data->fan_min[nr] = 255;
1222                 new_div = data->fan_div[nr]; /* No change */
1223                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
1224                 goto write_div;
1225         }
1226         reg = 1350000U / val;
1227         if (reg >= 128 * 255) {
1228                 /*
1229                  * Speed below this value cannot possibly be represented,
1230                  * even with the highest divider (128)
1231                  */
1232                 data->fan_min[nr] = 254;
1233                 new_div = 7; /* 128 == (1 << 7) */
1234                 dev_warn(dev, "fan%u low limit %lu below minimum %u, set to "
1235                          "minimum\n", nr + 1, val,
1236                          data->fan_from_reg_min(254, 7));
1237         } else if (!reg) {
1238                 /*
1239                  * Speed above this value cannot possibly be represented,
1240                  * even with the lowest divider (1)
1241                  */
1242                 data->fan_min[nr] = 1;
1243                 new_div = 0; /* 1 == (1 << 0) */
1244                 dev_warn(dev, "fan%u low limit %lu above maximum %u, set to "
1245                          "maximum\n", nr + 1, val,
1246                          data->fan_from_reg_min(1, 0));
1247         } else {
1248                 /*
1249                  * Automatically pick the best divider, i.e. the one such
1250                  * that the min limit will correspond to a register value
1251                  * in the 96..192 range
1252                  */
1253                 new_div = 0;
1254                 while (reg > 192 && new_div < 7) {
1255                         reg >>= 1;
1256                         new_div++;
1257                 }
1258                 data->fan_min[nr] = reg;
1259         }
1260
1261 write_div:
1262         /*
1263          * Write both the fan clock divider (if it changed) and the new
1264          * fan min (unconditionally)
1265          */
1266         if (new_div != data->fan_div[nr]) {
1267                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1268                         nr + 1, div_from_reg(data->fan_div[nr]),
1269                         div_from_reg(new_div));
1270                 data->fan_div[nr] = new_div;
1271                 nct6775_write_fan_div_common(dev, data, nr);
1272                 /* Give the chip time to sample a new speed value */
1273                 data->last_updated = jiffies;
1274         }
1275 write_min:
1276         nct6775_write_value(data, data->REG_FAN_MIN[nr],
1277                               data->fan_min[nr]);
1278         mutex_unlock(&data->update_lock);
1279
1280         return count;
1281 }
1282
1283 static struct sensor_device_attribute sda_fan_input[] = {
1284         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
1285         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
1286         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
1287         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
1288         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
1289 };
1290
1291 static struct sensor_device_attribute sda_fan_alarm[] = {
1292         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
1293         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
1294         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
1295         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
1296         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
1297 };
1298
1299 static struct sensor_device_attribute sda_fan_min[] = {
1300         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1301                     store_fan_min, 0),
1302         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1303                     store_fan_min, 1),
1304         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1305                     store_fan_min, 2),
1306         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1307                     store_fan_min, 3),
1308         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1309                     store_fan_min, 4),
1310 };
1311
1312 static struct sensor_device_attribute sda_fan_div[] = {
1313         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
1314         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
1315         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
1316         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
1317         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
1318 };
1319
1320 static ssize_t
1321 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
1322 {
1323         struct nct6775_data *data = nct6775_update_device(dev);
1324         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1325         int nr = sensor_attr->index;
1326         return sprintf(buf, "%s\n", data->temp_label[data->temp_src[0][nr]]);
1327 }
1328
1329 static ssize_t
1330 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
1331 {
1332         struct nct6775_data *data = nct6775_update_device(dev);
1333         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1334         int nr = sattr->nr;
1335         int index = sattr->index;
1336
1337         return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->temp[index][nr]));
1338 }
1339
1340 static ssize_t
1341 store_temp(struct device *dev, struct device_attribute *attr, const char *buf,
1342            size_t count)
1343 {
1344         struct nct6775_data *data = dev_get_drvdata(dev);
1345         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1346         int nr = sattr->nr;
1347         int index = sattr->index;
1348         int err;
1349         long val;
1350
1351         err = kstrtol(buf, 10, &val);
1352         if (err < 0)
1353                 return err;
1354
1355         mutex_lock(&data->update_lock);
1356         data->temp[index][nr] = LM75_TEMP_TO_REG(val);
1357         nct6775_write_temp(data, data->reg_temp[index][nr],
1358                            data->temp[index][nr]);
1359         mutex_unlock(&data->update_lock);
1360         return count;
1361 }
1362
1363 static ssize_t
1364 show_temp_offset(struct device *dev, struct device_attribute *attr, char *buf)
1365 {
1366         struct nct6775_data *data = nct6775_update_device(dev);
1367         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1368
1369         return sprintf(buf, "%d\n", data->temp_offset[sensor_attr->index] * 1000);
1370 }
1371
1372 static ssize_t
1373 store_temp_offset(struct device *dev, struct device_attribute *attr,
1374                   const char *buf, size_t count)
1375 {
1376         struct nct6775_data *data = dev_get_drvdata(dev);
1377         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1378         int nr = sensor_attr->index;
1379         long val;
1380         int err;
1381
1382         err = kstrtol(buf, 10, &val);
1383         if (err < 0)
1384                 return err;
1385
1386         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
1387
1388         mutex_lock(&data->update_lock);
1389         data->temp_offset[nr] = val;
1390         nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val);
1391         mutex_unlock(&data->update_lock);
1392
1393         return count;
1394 }
1395
1396 static ssize_t
1397 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
1398 {
1399         struct nct6775_data *data = nct6775_update_device(dev);
1400         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1401         int nr = sensor_attr->index;
1402         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
1403 }
1404
1405 static struct sensor_device_attribute_2 sda_temp_input[] = {
1406         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0),
1407         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 1, 0),
1408         SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 2, 0),
1409         SENSOR_ATTR_2(temp4_input, S_IRUGO, show_temp, NULL, 3, 0),
1410         SENSOR_ATTR_2(temp5_input, S_IRUGO, show_temp, NULL, 4, 0),
1411         SENSOR_ATTR_2(temp6_input, S_IRUGO, show_temp, NULL, 5, 0),
1412         SENSOR_ATTR_2(temp7_input, S_IRUGO, show_temp, NULL, 6, 0),
1413         SENSOR_ATTR_2(temp8_input, S_IRUGO, show_temp, NULL, 7, 0),
1414         SENSOR_ATTR_2(temp9_input, S_IRUGO, show_temp, NULL, 8, 0),
1415         SENSOR_ATTR_2(temp10_input, S_IRUGO, show_temp, NULL, 9, 0),
1416         SENSOR_ATTR_2(temp11_input, S_IRUGO, show_temp, NULL, 10, 0),
1417 };
1418
1419 static struct sensor_device_attribute sda_temp_label[] = {
1420         SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
1421         SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
1422         SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
1423         SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
1424         SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
1425         SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
1426 };
1427
1428 static struct sensor_device_attribute_2 sda_temp_max[] = {
1429         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1430                       0, 1),
1431         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1432                       1, 1),
1433         SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1434                       2, 1),
1435         SENSOR_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1436                       3, 1),
1437         SENSOR_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1438                       4, 1),
1439         SENSOR_ATTR_2(temp6_max, S_IRUGO | S_IWUSR, show_temp, store_temp,
1440                       5, 1),
1441 };
1442
1443 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
1444         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1445                       0, 2),
1446         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1447                       1, 2),
1448         SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1449                       2, 2),
1450         SENSOR_ATTR_2(temp4_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1451                       3, 2),
1452         SENSOR_ATTR_2(temp5_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1453                       4, 2),
1454         SENSOR_ATTR_2(temp6_max_hyst, S_IRUGO | S_IWUSR, show_temp, store_temp,
1455                       5, 2),
1456 };
1457
1458 static struct sensor_device_attribute sda_temp_offset[] = {
1459         SENSOR_ATTR(temp1_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1460                     store_temp_offset, 0),
1461         SENSOR_ATTR(temp2_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1462                     store_temp_offset, 1),
1463         SENSOR_ATTR(temp3_offset, S_IRUGO | S_IWUSR, show_temp_offset,
1464                     store_temp_offset, 2),
1465 };
1466
1467 static struct sensor_device_attribute sda_temp_alarm[] = {
1468         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
1469         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1470         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1471 };
1472
1473 static struct sensor_device_attribute sda_temp_type[] = {
1474         SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
1475         SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
1476         SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
1477 };
1478
1479 static ssize_t
1480 show_pwm_mode(struct device *dev, struct device_attribute *attr, char *buf)
1481 {
1482         struct nct6775_data *data = nct6775_update_device(dev);
1483         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1484
1485         return sprintf(buf, "%d\n", !data->pwm_mode[sensor_attr->index]);
1486 }
1487
1488 static ssize_t
1489 store_pwm_mode(struct device *dev, struct device_attribute *attr,
1490                         const char *buf, size_t count)
1491 {
1492         struct nct6775_data *data = dev_get_drvdata(dev);
1493         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1494         int nr = sensor_attr->index;
1495         unsigned long val;
1496         int err;
1497         u8 reg;
1498
1499         err = kstrtoul(buf, 10, &val);
1500         if (err < 0)
1501                 return err;
1502
1503         if (val > 1)
1504                 return -EINVAL;
1505
1506         /* Setting DC mode is not supported for all chips/channels */
1507         if (data->REG_PWM_MODE[nr] == 0) {
1508                 if (val)
1509                         return -EINVAL;
1510                 return count;
1511         }
1512
1513         mutex_lock(&data->update_lock);
1514         data->pwm_mode[nr] = val;
1515         reg = nct6775_read_value(data, data->REG_PWM_MODE[nr]);
1516         reg &= ~data->PWM_MODE_MASK[nr];
1517         if (val)
1518                 reg |= data->PWM_MODE_MASK[nr];
1519         nct6775_write_value(data, data->REG_PWM_MODE[nr], reg);
1520         mutex_unlock(&data->update_lock);
1521         return count;
1522 }
1523
1524 static ssize_t
1525 show_pwm_enable(struct device *dev, struct device_attribute *attr, char *buf)
1526 {
1527         struct nct6775_data *data = nct6775_update_device(dev);
1528         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1529
1530         return sprintf(buf, "%d\n", data->pwm_enable[sensor_attr->index]);
1531 }
1532
1533 static ssize_t
1534 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
1535 {
1536         struct nct6775_data *data = nct6775_update_device(dev);
1537         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1538         int nr = sattr->nr;
1539         int index = sattr->index;
1540         int pwm;
1541
1542         /*
1543          * For automatic fan control modes, show current pwm readings.
1544          * Otherwise, show the configured value.
1545          */
1546         if (index == 0 && data->pwm_enable[nr] > 1)
1547                 pwm = nct6775_read_value(data, data->REG_PWM_READ[nr]);
1548         else
1549                 pwm = data->pwm[index][nr];
1550
1551         return sprintf(buf, "%d\n", pwm);
1552 }
1553
1554 static ssize_t
1555 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
1556           size_t count)
1557 {
1558         struct nct6775_data *data = dev_get_drvdata(dev);
1559         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1560         int nr = sattr->nr;
1561         int index = sattr->index;
1562         unsigned long val;
1563         int err;
1564
1565         err = kstrtoul(buf, 10, &val);
1566         if (err < 0)
1567                 return err;
1568         if (val > 255 || (index && val == 0))
1569                 return -EINVAL;
1570
1571         mutex_lock(&data->update_lock);
1572         data->pwm[index][nr] = val;
1573         nct6775_write_value(data, data->REG_PWM[index][nr], val);
1574         mutex_unlock(&data->update_lock);
1575         return count;
1576 }
1577
1578 /* Returns 0 if OK, -EINVAL otherwise */
1579 static int check_trip_points(struct nct6775_data *data, int nr)
1580 {
1581         int i;
1582
1583         for (i = 0; i < data->auto_pwm_num - 1; i++) {
1584                 if (data->auto_temp[nr][i] > data->auto_temp[nr][i + 1])
1585                         return -EINVAL;
1586         }
1587         for (i = 0; i < data->auto_pwm_num - 1; i++) {
1588                 if (data->auto_pwm[nr][i] > data->auto_pwm[nr][i + 1])
1589                         return -EINVAL;
1590         }
1591         /* validate critical temperature and pwm if enabled (pwm > 0) */
1592         if (data->auto_pwm[nr][data->auto_pwm_num]) {
1593                 if (data->auto_temp[nr][data->auto_pwm_num - 1] >
1594                                 data->auto_temp[nr][data->auto_pwm_num] ||
1595                     data->auto_pwm[nr][data->auto_pwm_num - 1] >
1596                                 data->auto_pwm[nr][data->auto_pwm_num])
1597                         return -EINVAL;
1598         }
1599         return 0;
1600 }
1601
1602 static ssize_t
1603 store_pwm_enable(struct device *dev, struct device_attribute *attr,
1604                         const char *buf, size_t count)
1605 {
1606         struct nct6775_data *data = dev_get_drvdata(dev);
1607         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1608         int nr = sensor_attr->index;
1609         unsigned long val;
1610         int err;
1611         u16 reg;
1612
1613         err = kstrtoul(buf, 10, &val);
1614         if (err < 0)
1615                 return err;
1616
1617         if (val > 4)
1618                 return -EINVAL;
1619
1620         if (val == 4 && check_trip_points(data, nr)) {
1621                 dev_err(dev, "Inconsistent trip points, not switching to SmartFan IV mode\n");
1622                 dev_err(dev, "Adjust trip points and try again\n");
1623                 return -EINVAL;
1624         }
1625
1626         mutex_lock(&data->update_lock);
1627         data->pwm_enable[nr] = val;
1628         if (!val) {
1629                 /*
1630                  * turn off pwm control: select manual mode, set pwm to maximum
1631                  */
1632                 data->pwm[0][nr] = 255;
1633                 nct6775_write_value(data, data->REG_PWM[0][nr], 255);
1634         }
1635         reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
1636         reg &= 0x0f;
1637         reg |= (pwm_enable_to_reg(val) << 4);
1638         nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
1639         mutex_unlock(&data->update_lock);
1640         return count;
1641 }
1642
1643 static ssize_t
1644 show_pwm_temp_src(struct device *dev, struct device_attribute *attr, char *buf)
1645 {
1646         struct nct6775_data *data = nct6775_update_device(dev);
1647         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1648
1649         return sprintf(buf, "%d\n", data->temp_src[sattr->index][sattr->nr]);
1650 }
1651
1652 static ssize_t
1653 store_pwm_temp_src(struct device *dev, struct device_attribute *attr,
1654                    const char *buf, size_t count)
1655 {
1656         struct nct6775_data *data = nct6775_update_device(dev);
1657         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1658         int nr = sattr->nr;
1659         int index = sattr->index;
1660         unsigned long val;
1661         int err;
1662         int reg;
1663         static const int max_src[] = {
1664             ARRAY_SIZE(nct6775_temp_label),
1665             ARRAY_SIZE(nct6776_temp_label),
1666             ARRAY_SIZE(nct6779_temp_label)
1667         };
1668
1669         err = kstrtoul(buf, 10, &val);
1670         if (err < 0)
1671                 return err;
1672         if ((!index && val == 0) || val >= max_src[data->kind])
1673                 return -EINVAL;
1674
1675         if (!strlen(data->temp_label[val]))
1676                 return -EINVAL;
1677
1678         mutex_lock(&data->update_lock);
1679         data->temp_src[index][nr] = val;
1680         if (!index) {
1681                 reg = nct6775_read_value(data, data->REG_TEMP_SOURCE[nr]);
1682                 reg &= 0xe0;
1683                 reg |= val;
1684                 nct6775_write_value(data, data->REG_TEMP_SOURCE[nr], reg);
1685         } else {
1686                 reg = nct6775_read_value(data, data->REG_TEMP_SOURCE_2[nr]);
1687                 reg &= 0x60;
1688                 if (val)
1689                         reg |= (val | 0x80);
1690                 nct6775_write_value(data, data->REG_TEMP_SOURCE_2[nr], reg);
1691         }
1692         mutex_unlock(&data->update_lock);
1693
1694         return count;
1695 }
1696
1697 static ssize_t
1698 show_target_temp(struct device *dev, struct device_attribute *attr, char *buf)
1699 {
1700         struct nct6775_data *data = nct6775_update_device(dev);
1701         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1702
1703         return sprintf(buf, "%d\n",
1704                        data->target_temp[sensor_attr->index] * 1000);
1705 }
1706
1707 static ssize_t
1708 store_target_temp(struct device *dev, struct device_attribute *attr,
1709                         const char *buf, size_t count)
1710 {
1711         struct nct6775_data *data = dev_get_drvdata(dev);
1712         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1713         int nr = sensor_attr->index;
1714         long val;
1715         int err;
1716
1717         err = kstrtol(buf, 10, &val);
1718         if (err < 0)
1719                 return err;
1720
1721         val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 127);
1722
1723         mutex_lock(&data->update_lock);
1724         data->target_temp[nr] = val;
1725         nct6775_write_value(data, data->REG_TARGET[nr], val);
1726         mutex_unlock(&data->update_lock);
1727         return count;
1728 }
1729
1730 static ssize_t
1731 show_auto_temp_hyst(struct device *dev, struct device_attribute *attr,
1732                     char *buf)
1733 {
1734         struct nct6775_data *data = nct6775_update_device(dev);
1735         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1736         int nr = sattr->nr;
1737         int point = sattr->index >= data->auto_pwm_num ? 1 : 0;
1738         int tolerance = data->tolerance[nr][point];
1739         int temp = data->auto_temp[nr][sattr->index];
1740
1741         return sprintf(buf, "%d\n", (temp - tolerance) * 1000);
1742 }
1743
1744 static ssize_t
1745 store_auto_temp_hyst(struct device *dev, struct device_attribute *attr,
1746                      const char *buf, size_t count)
1747 {
1748         struct nct6775_data *data = dev_get_drvdata(dev);
1749         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1750         int nr = sattr->nr;
1751         int point = sattr->index >= data->auto_pwm_num ? 1 : 0;
1752         u16 reg;
1753         long val;
1754         int err;
1755         int maxlimit[2][3] = { { 15, 7, 63 }, { 15, 7, 7 } };
1756         int mask[] = { 0x0f, 0x07, 0x07 };
1757         int temp;
1758
1759         err = kstrtol(buf, 10, &val);
1760         if (err < 0)
1761                 return err;
1762
1763         temp = data->auto_temp[nr][sattr->index];
1764         val = temp - DIV_ROUND_CLOSEST(val, 1000);
1765
1766         /* Limit tolerance as needed */
1767         val = SENSORS_LIMIT(val, 0, maxlimit[point][data->kind]);
1768
1769         mutex_lock(&data->update_lock);
1770         if (point) {
1771                 nct6775_write_value(data,
1772                                     data->REG_CRITICAL_TEMP_TOLERANCE[nr],
1773                                     val);
1774         } else {
1775                 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
1776                 reg = (reg & ~mask[nr]) | (val & mask[nr]);
1777                 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
1778                 if (data->kind == nct6779) {
1779                         reg = nct6775_read_value(data,
1780                                                  NCT6779_REG_TOLERANCE_H[nr]);
1781                         reg = (reg & 0x70) | ((val & 0x38) << 1);
1782                         nct6775_write_value(data,
1783                                             NCT6779_REG_TOLERANCE_H[nr], reg);
1784                 }
1785         }
1786
1787         data->tolerance[nr][point] = val;
1788         mutex_unlock(&data->update_lock);
1789         return count;
1790 }
1791
1792 static SENSOR_DEVICE_ATTR_2(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0, 0);
1793 static SENSOR_DEVICE_ATTR_2(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1, 0);
1794 static SENSOR_DEVICE_ATTR_2(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2, 0);
1795 static SENSOR_DEVICE_ATTR_2(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3, 0);
1796 static SENSOR_DEVICE_ATTR_2(pwm5, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 4, 0);
1797
1798 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1799                           store_pwm_mode, 0);
1800 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1801                           store_pwm_mode, 1);
1802 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1803                           store_pwm_mode, 2);
1804 static SENSOR_DEVICE_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1805                           store_pwm_mode, 3);
1806 static SENSOR_DEVICE_ATTR(pwm5_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1807                           store_pwm_mode, 4);
1808
1809 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1810                           store_pwm_enable, 0);
1811 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1812                           store_pwm_enable, 1);
1813 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1814                           store_pwm_enable, 2);
1815 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1816                           store_pwm_enable, 3);
1817 static SENSOR_DEVICE_ATTR(pwm5_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1818                           store_pwm_enable, 4);
1819
1820 static SENSOR_DEVICE_ATTR_2(pwm1_temp_src1, S_IWUSR | S_IRUGO,
1821                             show_pwm_temp_src, store_pwm_temp_src, 6, 0);
1822 static SENSOR_DEVICE_ATTR_2(pwm2_temp_src1, S_IWUSR | S_IRUGO,
1823                             show_pwm_temp_src, store_pwm_temp_src, 7, 0);
1824 static SENSOR_DEVICE_ATTR_2(pwm3_temp_src1, S_IWUSR | S_IRUGO,
1825                             show_pwm_temp_src, store_pwm_temp_src, 8, 0);
1826 static SENSOR_DEVICE_ATTR_2(pwm4_temp_src1, S_IWUSR | S_IRUGO,
1827                             show_pwm_temp_src, store_pwm_temp_src, 9, 0);
1828 static SENSOR_DEVICE_ATTR_2(pwm5_temp_src1, S_IWUSR | S_IRUGO,
1829                             show_pwm_temp_src, store_pwm_temp_src, 10, 0);
1830
1831 static struct sensor_device_attribute_2 pwm_temp_src2[] = {
1832         SENSOR_ATTR_2(pwm1_temp_src2, S_IWUSR | S_IRUGO, show_pwm_temp_src,
1833                       store_pwm_temp_src, 6, 1),
1834         SENSOR_ATTR_2(pwm2_temp_src2, S_IWUSR | S_IRUGO, show_pwm_temp_src,
1835                       store_pwm_temp_src, 7, 1),
1836         SENSOR_ATTR_2(pwm3_temp_src2, S_IWUSR | S_IRUGO, show_pwm_temp_src,
1837                       store_pwm_temp_src, 8, 1),
1838         SENSOR_ATTR_2(pwm4_temp_src2, S_IWUSR | S_IRUGO, show_pwm_temp_src,
1839                       store_pwm_temp_src, 9, 1),
1840         SENSOR_ATTR_2(pwm5_temp_src2, S_IWUSR | S_IRUGO, show_pwm_temp_src,
1841                       store_pwm_temp_src, 10, 1),
1842 };
1843
1844 static SENSOR_DEVICE_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1845                           store_target_temp, 0);
1846 static SENSOR_DEVICE_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1847                           store_target_temp, 1);
1848 static SENSOR_DEVICE_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1849                           store_target_temp, 2);
1850 static SENSOR_DEVICE_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1851                           store_target_temp, 3);
1852 static SENSOR_DEVICE_ATTR(pwm5_target, S_IWUSR | S_IRUGO, show_target_temp,
1853                           store_target_temp, 4);
1854
1855 /* Smart Fan registers */
1856
1857 static ssize_t
1858 show_fan_time(struct device *dev, struct device_attribute *attr, char *buf)
1859 {
1860         struct nct6775_data *data = nct6775_update_device(dev);
1861         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1862         int nr = sattr->nr;
1863         int index = sattr->index;
1864
1865         return sprintf(buf, "%d\n",
1866                        step_time_from_reg(data->fan_time[index][nr],
1867                                           data->pwm_mode[nr]));
1868 }
1869
1870 static ssize_t
1871 store_fan_time(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_2 *sattr = to_sensor_dev_attr_2(attr);
1876         int nr = sattr->nr;
1877         int index = sattr->index;
1878         unsigned long val;
1879         int err;
1880
1881         err = kstrtoul(buf, 10, &val);
1882         if (err < 0)
1883                 return err;
1884
1885         val = step_time_to_reg(val, data->pwm_mode[nr]);
1886         mutex_lock(&data->update_lock);
1887         data->fan_time[index][nr] = val;
1888         nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val);
1889         mutex_unlock(&data->update_lock);
1890         return count;
1891 }
1892
1893 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1894                          char *buf)
1895 {
1896         struct nct6775_data *data = dev_get_drvdata(dev);
1897
1898         return sprintf(buf, "%s\n", data->name);
1899 }
1900 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1901
1902 static SENSOR_DEVICE_ATTR_2(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
1903                             store_fan_time, 0, 0);
1904 static SENSOR_DEVICE_ATTR_2(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
1905                             store_fan_time, 1, 0);
1906 static SENSOR_DEVICE_ATTR_2(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
1907                             store_fan_time, 2, 0);
1908 static SENSOR_DEVICE_ATTR_2(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
1909                             store_fan_time, 3, 0);
1910 static SENSOR_DEVICE_ATTR_2(pwm5_stop_time, S_IWUSR | S_IRUGO, show_fan_time,
1911                             store_fan_time, 4, 0);
1912
1913 static SENSOR_DEVICE_ATTR_2(pwm1_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
1914                             store_fan_time, 0, 1);
1915 static SENSOR_DEVICE_ATTR_2(pwm2_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
1916                             store_fan_time, 1, 1);
1917 static SENSOR_DEVICE_ATTR_2(pwm3_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
1918                             store_fan_time, 2, 1);
1919 static SENSOR_DEVICE_ATTR_2(pwm4_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
1920                             store_fan_time, 3, 1);
1921 static SENSOR_DEVICE_ATTR_2(pwm5_step_up_time, S_IWUSR | S_IRUGO, show_fan_time,
1922                             store_fan_time, 4, 1);
1923
1924 static SENSOR_DEVICE_ATTR_2(pwm1_step_down_time, S_IWUSR | S_IRUGO,
1925                             show_fan_time, store_fan_time, 0, 2);
1926 static SENSOR_DEVICE_ATTR_2(pwm2_step_down_time, S_IWUSR | S_IRUGO,
1927                             show_fan_time, store_fan_time, 1, 2);
1928 static SENSOR_DEVICE_ATTR_2(pwm3_step_down_time, S_IWUSR | S_IRUGO,
1929                             show_fan_time, store_fan_time, 2, 2);
1930 static SENSOR_DEVICE_ATTR_2(pwm4_step_down_time, S_IWUSR | S_IRUGO,
1931                             show_fan_time, store_fan_time, 3, 2);
1932 static SENSOR_DEVICE_ATTR_2(pwm5_step_down_time, S_IWUSR | S_IRUGO,
1933                             show_fan_time, store_fan_time, 4, 2);
1934
1935 static SENSOR_DEVICE_ATTR_2(pwm1_start_output, S_IWUSR | S_IRUGO, show_pwm,
1936                             store_pwm, 0, 1);
1937 static SENSOR_DEVICE_ATTR_2(pwm2_start_output, S_IWUSR | S_IRUGO, show_pwm,
1938                             store_pwm, 1, 1);
1939 static SENSOR_DEVICE_ATTR_2(pwm3_start_output, S_IWUSR | S_IRUGO, show_pwm,
1940                             store_pwm, 2, 1);
1941 static SENSOR_DEVICE_ATTR_2(pwm4_start_output, S_IWUSR | S_IRUGO, show_pwm,
1942                             store_pwm, 3, 1);
1943 static SENSOR_DEVICE_ATTR_2(pwm5_start_output, S_IWUSR | S_IRUGO, show_pwm,
1944                             store_pwm, 4, 1);
1945
1946 static SENSOR_DEVICE_ATTR_2(pwm1_stop_output, S_IWUSR | S_IRUGO, show_pwm,
1947                             store_pwm, 0, 2);
1948 static SENSOR_DEVICE_ATTR_2(pwm2_stop_output, S_IWUSR | S_IRUGO, show_pwm,
1949                             store_pwm, 1, 2);
1950 static SENSOR_DEVICE_ATTR_2(pwm3_stop_output, S_IWUSR | S_IRUGO, show_pwm,
1951                             store_pwm, 2, 2);
1952 static SENSOR_DEVICE_ATTR_2(pwm4_stop_output, S_IWUSR | S_IRUGO, show_pwm,
1953                             store_pwm, 3, 2);
1954 static SENSOR_DEVICE_ATTR_2(pwm5_stop_output, S_IWUSR | S_IRUGO, show_pwm,
1955                             store_pwm, 4, 2);
1956
1957 static struct attribute *nct6775_attributes_pwm[5][11] = {
1958         {
1959                 &sensor_dev_attr_pwm1.dev_attr.attr,
1960                 &sensor_dev_attr_pwm1_mode.dev_attr.attr,
1961                 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1962                 &sensor_dev_attr_pwm1_temp_src1.dev_attr.attr,
1963                 &sensor_dev_attr_pwm1_target.dev_attr.attr,
1964                 &sensor_dev_attr_pwm1_stop_time.dev_attr.attr,
1965                 &sensor_dev_attr_pwm1_step_up_time.dev_attr.attr,
1966                 &sensor_dev_attr_pwm1_step_down_time.dev_attr.attr,
1967                 &sensor_dev_attr_pwm1_start_output.dev_attr.attr,
1968                 &sensor_dev_attr_pwm1_stop_output.dev_attr.attr,
1969                 NULL
1970         },
1971         {
1972                 &sensor_dev_attr_pwm2.dev_attr.attr,
1973                 &sensor_dev_attr_pwm2_mode.dev_attr.attr,
1974                 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1975                 &sensor_dev_attr_pwm2_temp_src1.dev_attr.attr,
1976                 &sensor_dev_attr_pwm2_target.dev_attr.attr,
1977                 &sensor_dev_attr_pwm2_stop_time.dev_attr.attr,
1978                 &sensor_dev_attr_pwm2_step_up_time.dev_attr.attr,
1979                 &sensor_dev_attr_pwm2_step_down_time.dev_attr.attr,
1980                 &sensor_dev_attr_pwm2_start_output.dev_attr.attr,
1981                 &sensor_dev_attr_pwm2_stop_output.dev_attr.attr,
1982                 NULL
1983         },
1984         {
1985                 &sensor_dev_attr_pwm3.dev_attr.attr,
1986                 &sensor_dev_attr_pwm3_mode.dev_attr.attr,
1987                 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1988                 &sensor_dev_attr_pwm3_temp_src1.dev_attr.attr,
1989                 &sensor_dev_attr_pwm3_target.dev_attr.attr,
1990                 &sensor_dev_attr_pwm3_stop_time.dev_attr.attr,
1991                 &sensor_dev_attr_pwm3_step_up_time.dev_attr.attr,
1992                 &sensor_dev_attr_pwm3_step_down_time.dev_attr.attr,
1993                 &sensor_dev_attr_pwm3_start_output.dev_attr.attr,
1994                 &sensor_dev_attr_pwm3_stop_output.dev_attr.attr,
1995                 NULL
1996         },
1997         {
1998                 &sensor_dev_attr_pwm4.dev_attr.attr,
1999                 &sensor_dev_attr_pwm4_mode.dev_attr.attr,
2000                 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
2001                 &sensor_dev_attr_pwm4_temp_src1.dev_attr.attr,
2002                 &sensor_dev_attr_pwm4_target.dev_attr.attr,
2003                 &sensor_dev_attr_pwm4_stop_time.dev_attr.attr,
2004                 &sensor_dev_attr_pwm4_step_up_time.dev_attr.attr,
2005                 &sensor_dev_attr_pwm4_step_down_time.dev_attr.attr,
2006                 &sensor_dev_attr_pwm4_start_output.dev_attr.attr,
2007                 &sensor_dev_attr_pwm4_stop_output.dev_attr.attr,
2008                 NULL
2009         },
2010         {
2011                 &sensor_dev_attr_pwm5.dev_attr.attr,
2012                 &sensor_dev_attr_pwm5_mode.dev_attr.attr,
2013                 &sensor_dev_attr_pwm5_enable.dev_attr.attr,
2014                 &sensor_dev_attr_pwm5_temp_src1.dev_attr.attr,
2015                 &sensor_dev_attr_pwm5_target.dev_attr.attr,
2016                 &sensor_dev_attr_pwm5_stop_time.dev_attr.attr,
2017                 &sensor_dev_attr_pwm5_step_up_time.dev_attr.attr,
2018                 &sensor_dev_attr_pwm5_step_down_time.dev_attr.attr,
2019                 &sensor_dev_attr_pwm5_start_output.dev_attr.attr,
2020                 &sensor_dev_attr_pwm5_stop_output.dev_attr.attr,
2021                 NULL
2022         },
2023 };
2024
2025 static const struct attribute_group nct6775_group_pwm[5] = {
2026         { .attrs = nct6775_attributes_pwm[0] },
2027         { .attrs = nct6775_attributes_pwm[1] },
2028         { .attrs = nct6775_attributes_pwm[2] },
2029         { .attrs = nct6775_attributes_pwm[3] },
2030         { .attrs = nct6775_attributes_pwm[4] },
2031 };
2032
2033 static ssize_t show_auto_pwm(struct device *dev, struct device_attribute *attr,
2034                              char *buf)
2035 {
2036         struct nct6775_data *data = nct6775_update_device(dev);
2037         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2038
2039         return sprintf(buf, "%d\n", data->auto_pwm[sattr->nr][sattr->index]);
2040 }
2041
2042 static ssize_t store_auto_pwm(struct device *dev, struct device_attribute *attr,
2043                               const char *buf, size_t count)
2044 {
2045         struct nct6775_data *data = dev_get_drvdata(dev);
2046         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2047         int nr = sattr->nr;
2048         int point = sattr->index;
2049         unsigned long val;
2050         int err;
2051         u8 reg;
2052
2053         err = kstrtoul(buf, 10, &val);
2054         if (err < 0)
2055                 return err;
2056         if (val > 255)
2057                 return -EINVAL;
2058
2059         if (point == data->auto_pwm_num) {
2060                 if (data->kind != nct6775 && !val)
2061                         return -EINVAL;
2062                 if (data->kind != nct6779 && val)
2063                         val = 0xff;
2064         }
2065
2066         mutex_lock(&data->update_lock);
2067         data->auto_pwm[nr][point] = val;
2068         if (point < data->auto_pwm_num) {
2069                 nct6775_write_value(data,
2070                                     NCT6775_AUTO_PWM(data, nr, point),
2071                                     data->auto_pwm[nr][point]);
2072         } else {
2073                 switch (data->kind) {
2074                 case nct6775:
2075                         /* disable if needed (pwm == 0) */
2076                         reg = nct6775_read_value(data,
2077                                                  NCT6775_REG_CRITICAL_ENAB[nr]);
2078                         if (val)
2079                                 reg |= 0x02;
2080                         else
2081                                 reg &= ~0x02;
2082                         nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr],
2083                                             reg);
2084                         break;
2085                 case nct6776:
2086                         break; /* always enabled, nothing to do */
2087                 case nct6779:
2088                         nct6775_write_value(data, NCT6779_REG_CRITICAL_PWM[nr],
2089                                             val);
2090                         reg = nct6775_read_value(data,
2091                                         NCT6779_REG_CRITICAL_PWM_ENABLE[nr]);
2092                         if (val == 255)
2093                                 reg &= ~0x01;
2094                         else
2095                                 reg |= 0x01;
2096                         nct6775_write_value(data,
2097                                             NCT6779_REG_CRITICAL_PWM_ENABLE[nr],
2098                                             reg);
2099                         break;
2100                 }
2101         }
2102         mutex_unlock(&data->update_lock);
2103         return count;
2104 }
2105
2106 static ssize_t show_auto_temp(struct device *dev, struct device_attribute *attr,
2107                               char *buf)
2108 {
2109         struct nct6775_data *data = nct6775_update_device(dev);
2110         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2111         int nr = sattr->nr;
2112         int point = sattr->index;
2113
2114         /*
2115          * We don't know for sure if the temperature is signed or unsigned.
2116          * Assume it is unsigned.
2117          */
2118         return sprintf(buf, "%d\n", data->auto_temp[nr][point] * 1000);
2119 }
2120
2121 static ssize_t store_auto_temp(struct device *dev,
2122                                struct device_attribute *attr,
2123                                const char *buf, size_t count)
2124 {
2125         struct nct6775_data *data = dev_get_drvdata(dev);
2126         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2127         int nr = sattr->nr;
2128         int point = sattr->index;
2129         unsigned long val;
2130         int err;
2131
2132         err = kstrtoul(buf, 10, &val);
2133         if (err)
2134                 return err;
2135         if (val > 255000)
2136                 return -EINVAL;
2137
2138         mutex_lock(&data->update_lock);
2139         data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
2140         if (point < data->auto_pwm_num) {
2141                 nct6775_write_value(data,
2142                                     NCT6775_AUTO_TEMP(data, nr, point),
2143                                     data->auto_temp[nr][point]);
2144         } else {
2145                 nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr],
2146                                     data->auto_temp[nr][point]);
2147         }
2148         mutex_unlock(&data->update_lock);
2149         return count;
2150 }
2151
2152 /*
2153  * The number of auto-point trip points is chip dependent.
2154  * Need to check support while generating/removing attribute files.
2155  */
2156 static struct sensor_device_attribute_2 sda_auto_pwm_arrays[] = {
2157         SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
2158                           show_auto_pwm, store_auto_pwm, 0, 0),
2159         SENSOR_ATTR_2(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
2160                           show_auto_temp, store_auto_temp, 0, 0),
2161         SENSOR_ATTR_2(pwm1_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2162                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 0),
2163         SENSOR_ATTR_2(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
2164                           show_auto_pwm, store_auto_pwm, 0, 1),
2165         SENSOR_ATTR_2(pwm1_auto_point2_temp, S_IWUSR | S_IRUGO,
2166                           show_auto_temp, store_auto_temp, 0, 1),
2167         SENSOR_ATTR_2(pwm1_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2168                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 1),
2169         SENSOR_ATTR_2(pwm1_auto_point3_pwm, S_IWUSR | S_IRUGO,
2170                           show_auto_pwm, store_auto_pwm, 0, 2),
2171         SENSOR_ATTR_2(pwm1_auto_point3_temp, S_IWUSR | S_IRUGO,
2172                           show_auto_temp, store_auto_temp, 0, 2),
2173         SENSOR_ATTR_2(pwm1_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2174                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 2),
2175         SENSOR_ATTR_2(pwm1_auto_point4_pwm, S_IWUSR | S_IRUGO,
2176                           show_auto_pwm, store_auto_pwm, 0, 3),
2177         SENSOR_ATTR_2(pwm1_auto_point4_temp, S_IWUSR | S_IRUGO,
2178                           show_auto_temp, store_auto_temp, 0, 3),
2179         SENSOR_ATTR_2(pwm1_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2180                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 3),
2181         SENSOR_ATTR_2(pwm1_auto_point5_pwm, S_IWUSR | S_IRUGO,
2182                           show_auto_pwm, store_auto_pwm, 0, 4),
2183         SENSOR_ATTR_2(pwm1_auto_point5_temp, S_IWUSR | S_IRUGO,
2184                           show_auto_temp, store_auto_temp, 0, 4),
2185         SENSOR_ATTR_2(pwm1_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2186                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 4),
2187         SENSOR_ATTR_2(pwm1_auto_point6_pwm, S_IWUSR | S_IRUGO,
2188                           show_auto_pwm, store_auto_pwm, 0, 5),
2189         SENSOR_ATTR_2(pwm1_auto_point6_temp, S_IWUSR | S_IRUGO,
2190                           show_auto_temp, store_auto_temp, 0, 5),
2191         SENSOR_ATTR_2(pwm1_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2192                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 5),
2193         SENSOR_ATTR_2(pwm1_auto_point7_pwm, S_IWUSR | S_IRUGO,
2194                           show_auto_pwm, store_auto_pwm, 0, 6),
2195         SENSOR_ATTR_2(pwm1_auto_point7_temp, S_IWUSR | S_IRUGO,
2196                           show_auto_temp, store_auto_temp, 0, 6),
2197         SENSOR_ATTR_2(pwm1_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2198                           show_auto_temp_hyst, store_auto_temp_hyst, 0, 6),
2199
2200         SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
2201                           show_auto_pwm, store_auto_pwm, 1, 0),
2202         SENSOR_ATTR_2(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO,
2203                           show_auto_temp, store_auto_temp, 1, 0),
2204         SENSOR_ATTR_2(pwm2_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2205                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 0),
2206         SENSOR_ATTR_2(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
2207                           show_auto_pwm, store_auto_pwm, 1, 1),
2208         SENSOR_ATTR_2(pwm2_auto_point2_temp, S_IWUSR | S_IRUGO,
2209                           show_auto_temp, store_auto_temp, 1, 1),
2210         SENSOR_ATTR_2(pwm2_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2211                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 1),
2212         SENSOR_ATTR_2(pwm2_auto_point3_pwm, S_IWUSR | S_IRUGO,
2213                           show_auto_pwm, store_auto_pwm, 1, 2),
2214         SENSOR_ATTR_2(pwm2_auto_point3_temp, S_IWUSR | S_IRUGO,
2215                           show_auto_temp, store_auto_temp, 1, 2),
2216         SENSOR_ATTR_2(pwm2_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2217                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 2),
2218         SENSOR_ATTR_2(pwm2_auto_point4_pwm, S_IWUSR | S_IRUGO,
2219                           show_auto_pwm, store_auto_pwm, 1, 3),
2220         SENSOR_ATTR_2(pwm2_auto_point4_temp, S_IWUSR | S_IRUGO,
2221                           show_auto_temp, store_auto_temp, 1, 3),
2222         SENSOR_ATTR_2(pwm2_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2223                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 3),
2224         SENSOR_ATTR_2(pwm2_auto_point5_pwm, S_IWUSR | S_IRUGO,
2225                           show_auto_pwm, store_auto_pwm, 1, 4),
2226         SENSOR_ATTR_2(pwm2_auto_point5_temp, S_IWUSR | S_IRUGO,
2227                           show_auto_temp, store_auto_temp, 1, 4),
2228         SENSOR_ATTR_2(pwm2_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2229                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 4),
2230         SENSOR_ATTR_2(pwm2_auto_point6_pwm, S_IWUSR | S_IRUGO,
2231                           show_auto_pwm, store_auto_pwm, 1, 5),
2232         SENSOR_ATTR_2(pwm2_auto_point6_temp, S_IWUSR | S_IRUGO,
2233                           show_auto_temp, store_auto_temp, 1, 5),
2234         SENSOR_ATTR_2(pwm2_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2235                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 5),
2236         SENSOR_ATTR_2(pwm2_auto_point7_pwm, S_IWUSR | S_IRUGO,
2237                           show_auto_pwm, store_auto_pwm, 1, 6),
2238         SENSOR_ATTR_2(pwm2_auto_point7_temp, S_IWUSR | S_IRUGO,
2239                           show_auto_temp, store_auto_temp, 1, 6),
2240         SENSOR_ATTR_2(pwm2_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2241                           show_auto_temp_hyst, store_auto_temp_hyst, 1, 6),
2242
2243         SENSOR_ATTR_2(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
2244                           show_auto_pwm, store_auto_pwm, 2, 0),
2245         SENSOR_ATTR_2(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO,
2246                           show_auto_temp, store_auto_temp, 2, 0),
2247         SENSOR_ATTR_2(pwm3_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2248                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 0),
2249         SENSOR_ATTR_2(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
2250                           show_auto_pwm, store_auto_pwm, 2, 1),
2251         SENSOR_ATTR_2(pwm3_auto_point2_temp, S_IWUSR | S_IRUGO,
2252                           show_auto_temp, store_auto_temp, 2, 1),
2253         SENSOR_ATTR_2(pwm3_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2254                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 1),
2255         SENSOR_ATTR_2(pwm3_auto_point3_pwm, S_IWUSR | S_IRUGO,
2256                           show_auto_pwm, store_auto_pwm, 2, 2),
2257         SENSOR_ATTR_2(pwm3_auto_point3_temp, S_IWUSR | S_IRUGO,
2258                           show_auto_temp, store_auto_temp, 2, 2),
2259         SENSOR_ATTR_2(pwm3_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2260                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 2),
2261         SENSOR_ATTR_2(pwm3_auto_point4_pwm, S_IWUSR | S_IRUGO,
2262                           show_auto_pwm, store_auto_pwm, 2, 3),
2263         SENSOR_ATTR_2(pwm3_auto_point4_temp, S_IWUSR | S_IRUGO,
2264                           show_auto_temp, store_auto_temp, 2, 3),
2265         SENSOR_ATTR_2(pwm3_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2266                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 3),
2267         SENSOR_ATTR_2(pwm3_auto_point5_pwm, S_IWUSR | S_IRUGO,
2268                           show_auto_pwm, store_auto_pwm, 2, 4),
2269         SENSOR_ATTR_2(pwm3_auto_point5_temp, S_IWUSR | S_IRUGO,
2270                           show_auto_temp, store_auto_temp, 2, 4),
2271         SENSOR_ATTR_2(pwm3_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2272                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 4),
2273         SENSOR_ATTR_2(pwm3_auto_point6_pwm, S_IWUSR | S_IRUGO,
2274                           show_auto_pwm, store_auto_pwm, 2, 5),
2275         SENSOR_ATTR_2(pwm3_auto_point6_temp, S_IWUSR | S_IRUGO,
2276                           show_auto_temp, store_auto_temp, 2, 5),
2277         SENSOR_ATTR_2(pwm3_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2278                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 5),
2279         SENSOR_ATTR_2(pwm3_auto_point7_pwm, S_IWUSR | S_IRUGO,
2280                           show_auto_pwm, store_auto_pwm, 2, 6),
2281         SENSOR_ATTR_2(pwm3_auto_point7_temp, S_IWUSR | S_IRUGO,
2282                           show_auto_temp, store_auto_temp, 2, 6),
2283         SENSOR_ATTR_2(pwm3_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2284                           show_auto_temp_hyst, store_auto_temp_hyst, 2, 6),
2285
2286         SENSOR_ATTR_2(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
2287                           show_auto_pwm, store_auto_pwm, 3, 0),
2288         SENSOR_ATTR_2(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO,
2289                           show_auto_temp, store_auto_temp, 3, 0),
2290         SENSOR_ATTR_2(pwm4_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2291                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 0),
2292         SENSOR_ATTR_2(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
2293                           show_auto_pwm, store_auto_pwm, 3, 1),
2294         SENSOR_ATTR_2(pwm4_auto_point2_temp, S_IWUSR | S_IRUGO,
2295                           show_auto_temp, store_auto_temp, 3, 1),
2296         SENSOR_ATTR_2(pwm4_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2297                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 1),
2298         SENSOR_ATTR_2(pwm4_auto_point3_pwm, S_IWUSR | S_IRUGO,
2299                           show_auto_pwm, store_auto_pwm, 3, 2),
2300         SENSOR_ATTR_2(pwm4_auto_point3_temp, S_IWUSR | S_IRUGO,
2301                           show_auto_temp, store_auto_temp, 3, 2),
2302         SENSOR_ATTR_2(pwm4_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2303                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 2),
2304         SENSOR_ATTR_2(pwm4_auto_point4_pwm, S_IWUSR | S_IRUGO,
2305                           show_auto_pwm, store_auto_pwm, 3, 3),
2306         SENSOR_ATTR_2(pwm4_auto_point4_temp, S_IWUSR | S_IRUGO,
2307                           show_auto_temp, store_auto_temp, 3, 3),
2308         SENSOR_ATTR_2(pwm4_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2309                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 3),
2310         SENSOR_ATTR_2(pwm4_auto_point5_pwm, S_IWUSR | S_IRUGO,
2311                           show_auto_pwm, store_auto_pwm, 3, 4),
2312         SENSOR_ATTR_2(pwm4_auto_point5_temp, S_IWUSR | S_IRUGO,
2313                           show_auto_temp, store_auto_temp, 3, 4),
2314         SENSOR_ATTR_2(pwm4_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2315                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 4),
2316         SENSOR_ATTR_2(pwm4_auto_point6_pwm, S_IWUSR | S_IRUGO,
2317                           show_auto_pwm, store_auto_pwm, 3, 5),
2318         SENSOR_ATTR_2(pwm4_auto_point6_temp, S_IWUSR | S_IRUGO,
2319                           show_auto_temp, store_auto_temp, 3, 5),
2320         SENSOR_ATTR_2(pwm4_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2321                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 5),
2322         SENSOR_ATTR_2(pwm4_auto_point7_pwm, S_IWUSR | S_IRUGO,
2323                           show_auto_pwm, store_auto_pwm, 3, 6),
2324         SENSOR_ATTR_2(pwm4_auto_point7_temp, S_IWUSR | S_IRUGO,
2325                           show_auto_temp, store_auto_temp, 3, 6),
2326         SENSOR_ATTR_2(pwm4_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2327                           show_auto_temp_hyst, store_auto_temp_hyst, 3, 6),
2328
2329         SENSOR_ATTR_2(pwm5_auto_point1_pwm, S_IWUSR | S_IRUGO,
2330                           show_auto_pwm, store_auto_pwm, 4, 0),
2331         SENSOR_ATTR_2(pwm5_auto_point1_temp, S_IWUSR | S_IRUGO,
2332                           show_auto_temp, store_auto_temp, 4, 0),
2333         SENSOR_ATTR_2(pwm5_auto_point1_temp_hyst, S_IWUSR | S_IRUGO,
2334                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 0),
2335         SENSOR_ATTR_2(pwm5_auto_point2_pwm, S_IWUSR | S_IRUGO,
2336                           show_auto_pwm, store_auto_pwm, 4, 1),
2337         SENSOR_ATTR_2(pwm5_auto_point2_temp, S_IWUSR | S_IRUGO,
2338                           show_auto_temp, store_auto_temp, 4, 1),
2339         SENSOR_ATTR_2(pwm5_auto_point2_temp_hyst, S_IWUSR | S_IRUGO,
2340                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 1),
2341         SENSOR_ATTR_2(pwm5_auto_point3_pwm, S_IWUSR | S_IRUGO,
2342                           show_auto_pwm, store_auto_pwm, 4, 2),
2343         SENSOR_ATTR_2(pwm5_auto_point3_temp, S_IWUSR | S_IRUGO,
2344                           show_auto_temp, store_auto_temp, 4, 2),
2345         SENSOR_ATTR_2(pwm5_auto_point3_temp_hyst, S_IWUSR | S_IRUGO,
2346                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 2),
2347         SENSOR_ATTR_2(pwm5_auto_point4_pwm, S_IWUSR | S_IRUGO,
2348                           show_auto_pwm, store_auto_pwm, 4, 3),
2349         SENSOR_ATTR_2(pwm5_auto_point4_temp, S_IWUSR | S_IRUGO,
2350                           show_auto_temp, store_auto_temp, 4, 3),
2351         SENSOR_ATTR_2(pwm5_auto_point4_temp_hyst, S_IWUSR | S_IRUGO,
2352                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 3),
2353         SENSOR_ATTR_2(pwm5_auto_point5_pwm, S_IWUSR | S_IRUGO,
2354                           show_auto_pwm, store_auto_pwm, 4, 4),
2355         SENSOR_ATTR_2(pwm5_auto_point5_temp, S_IWUSR | S_IRUGO,
2356                           show_auto_temp, store_auto_temp, 4, 4),
2357         SENSOR_ATTR_2(pwm5_auto_point5_temp_hyst, S_IWUSR | S_IRUGO,
2358                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 4),
2359         SENSOR_ATTR_2(pwm5_auto_point6_pwm, S_IWUSR | S_IRUGO,
2360                           show_auto_pwm, store_auto_pwm, 4, 5),
2361         SENSOR_ATTR_2(pwm5_auto_point6_temp, S_IWUSR | S_IRUGO,
2362                           show_auto_temp, store_auto_temp, 4, 5),
2363         SENSOR_ATTR_2(pwm5_auto_point6_temp_hyst, S_IWUSR | S_IRUGO,
2364                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 5),
2365         SENSOR_ATTR_2(pwm5_auto_point7_pwm, S_IWUSR | S_IRUGO,
2366                           show_auto_pwm, store_auto_pwm, 4, 6),
2367         SENSOR_ATTR_2(pwm5_auto_point7_temp, S_IWUSR | S_IRUGO,
2368                           show_auto_temp, store_auto_temp, 4, 6),
2369         SENSOR_ATTR_2(pwm5_auto_point7_temp_hyst, S_IWUSR | S_IRUGO,
2370                           show_auto_temp_hyst, store_auto_temp_hyst, 4, 6),
2371 };
2372
2373 static ssize_t
2374 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
2375 {
2376         struct nct6775_data *data = dev_get_drvdata(dev);
2377         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
2378 }
2379 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
2380
2381
2382 /* Case open detection */
2383
2384 static ssize_t
2385 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
2386 {
2387         struct nct6775_data *data = nct6775_update_device(dev);
2388
2389         return sprintf(buf, "%d\n",
2390                 !!(data->caseopen & to_sensor_dev_attr_2(attr)->index));
2391 }
2392
2393 static ssize_t
2394 clear_caseopen(struct device *dev, struct device_attribute *attr,
2395                         const char *buf, size_t count)
2396 {
2397         struct nct6775_data *data = dev_get_drvdata(dev);
2398         struct nct6775_sio_data *sio_data = dev->platform_data;
2399         int nr = to_sensor_dev_attr(attr)->index;
2400         unsigned long val;
2401         u8 reg;
2402
2403         if (kstrtoul(buf, 10, &val) || val != 0)
2404                 return -EINVAL;
2405
2406         mutex_lock(&data->update_lock);
2407
2408         /*
2409          * Use CR registers to clear caseopen status.
2410          * The CR registers are the same for all chips, and not all chips
2411          * support clearing the caseopen status through "regular" registers.
2412          */
2413         superio_enter(sio_data->sioreg);
2414         superio_select(sio_data->sioreg, NCT6775_LD_ACPI);
2415         reg = superio_inb(sio_data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr]);
2416         reg |= NCT6775_CR_CASEOPEN_CLR_MASK[nr];
2417         superio_outb(sio_data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
2418         superio_exit(sio_data->sioreg);
2419
2420         data->valid = 0;        /* Force cache refresh */
2421
2422         mutex_unlock(&data->update_lock);
2423
2424         return count;
2425 }
2426
2427 static struct sensor_device_attribute sda_caseopen[] = {
2428         SENSOR_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
2429                     clear_caseopen, 0),
2430         SENSOR_ATTR(intrusion1_alarm, S_IWUSR | S_IRUGO, show_caseopen,
2431                     clear_caseopen, 1),
2432 };
2433
2434 /*
2435  * Driver and device management
2436  */
2437
2438 static void nct6775_device_remove_files(struct device *dev)
2439 {
2440         /*
2441          * some entries in the following arrays may not have been used in
2442          * device_create_file(), but device_remove_file() will ignore them
2443          */
2444         int i, j;
2445         struct nct6775_data *data = dev_get_drvdata(dev);
2446
2447         for (i = 0; i < data->pwm_num; i++) {
2448                 sysfs_remove_group(&dev->kobj, &nct6775_group_pwm[i]);
2449                 for (j = 0; j < ARRAY_SIZE(sda_auto_pwm_arrays); j++)
2450                         device_remove_file(dev,
2451                                            &sda_auto_pwm_arrays[j].dev_attr);
2452                 device_remove_file(dev, &pwm_temp_src2[i].dev_attr);
2453         }
2454
2455         for (i = 0; i < data->in_num; i++)
2456                 sysfs_remove_group(&dev->kobj, &nct6775_group_in[i]);
2457
2458         for (i = 0; i < 5; i++) {
2459                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
2460                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
2461                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
2462                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
2463         }
2464         for (i = 0; i < NUM_REG_TEMP; i++) {
2465                 if (!(data->have_temp & (1 << i)))
2466                         continue;
2467                 device_remove_file(dev, &sda_temp_input[i].dev_attr);
2468                 if (i > 5)
2469                         continue;
2470                 device_remove_file(dev, &sda_temp_label[i].dev_attr);
2471                 device_remove_file(dev, &sda_temp_max[i].dev_attr);
2472                 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
2473                 if (i > 2)
2474                         continue;
2475                 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
2476                 device_remove_file(dev, &sda_temp_type[i].dev_attr);
2477                 device_remove_file(dev, &sda_temp_offset[i].dev_attr);
2478         }
2479
2480         device_remove_file(dev, &sda_caseopen[0].dev_attr);
2481         device_remove_file(dev, &sda_caseopen[1].dev_attr);
2482
2483         device_remove_file(dev, &dev_attr_name);
2484         device_remove_file(dev, &dev_attr_cpu0_vid);
2485 }
2486
2487 /* Get the monitoring functions started */
2488 static inline void __devinit nct6775_init_device(struct nct6775_data *data)
2489 {
2490         int i;
2491         u8 tmp;
2492
2493         /* Start monitoring if needed */
2494         tmp = nct6775_read_value(data, NCT6775_REG_CONFIG);
2495         if (!(tmp & 0x01))
2496                 nct6775_write_value(data, NCT6775_REG_CONFIG,
2497                                       tmp | 0x01);
2498
2499         /* Enable temperature sensors if needed */
2500         for (i = 0; i < NUM_REG_TEMP; i++) {
2501                 if (!(data->have_temp & (1 << i)))
2502                         continue;
2503                 if (!data->reg_temp_config[i])
2504                         continue;
2505                 tmp = nct6775_read_value(data, data->reg_temp_config[i]);
2506                 if (tmp & 0x01)
2507                         nct6775_write_value(data, data->reg_temp_config[i],
2508                                             tmp & 0xfe);
2509         }
2510
2511         /* Enable VBAT monitoring if needed */
2512         tmp = nct6775_read_value(data, NCT6775_REG_VBAT);
2513         if (!(tmp & 0x01))
2514                 nct6775_write_value(data, NCT6775_REG_VBAT, tmp | 0x01);
2515
2516         for (i = 0; i < 3; i++) {
2517                 const char *label = NULL;
2518
2519                 if (data->temp_label)
2520                         label = data->temp_label[data->temp_src[0][i]];
2521
2522                 /* Digital source overrides analog type */
2523                 if (label && strncmp(label, "PECI", 4) == 0)
2524                         data->temp_type[i] = 6;
2525                 else if (label && strncmp(label, "AMD", 3) == 0)
2526                         data->temp_type[i] = 5;
2527                 else if ((tmp & (0x02 << i)))
2528                         data->temp_type[i] = 1; /* diode */
2529                 else
2530                         data->temp_type[i] = 4; /* thermistor */
2531         }
2532 }
2533
2534 static void w82627ehf_swap_tempreg(struct nct6775_data *data,
2535                                    int r1, int r2)
2536 {
2537         u16 tmp, i;
2538
2539         tmp = data->temp_src[0][r1];
2540         data->temp_src[0][r1] = data->temp_src[0][r2];
2541         data->temp_src[0][r2] = tmp;
2542
2543         for (i = 0; i < 3; i++) {
2544                 tmp = data->reg_temp[i][r1];
2545                 data->reg_temp[i][r1] = data->reg_temp[i][r2];
2546                 data->reg_temp[i][r2] = tmp;
2547         }
2548
2549         tmp = data->reg_temp_config[r1];
2550         data->reg_temp_config[r1] = data->reg_temp_config[r2];
2551         data->reg_temp_config[r2] = tmp;
2552 }
2553
2554 static void __devinit
2555 nct6775_check_fan_inputs(const struct nct6775_sio_data *sio_data,
2556                          struct nct6775_data *data)
2557 {
2558         int regval;
2559         bool fan3pin, fan3min, fan4pin, fan4min, fan5pin;
2560         bool pwm3pin, pwm4pin, pwm5pin;
2561
2562         superio_enter(sio_data->sioreg);
2563
2564         /* fan4 and fan5 share some pins with the GPIO and serial flash */
2565         if (data->kind == nct6775) {
2566                 regval = superio_inb(sio_data->sioreg, 0x2c);
2567
2568                 fan3pin = regval & (1 << 6);
2569                 fan3min = fan3pin;
2570                 pwm3pin = regval & (1 << 7);
2571
2572                 /* On NCT6775, fan4 shares pins with the fdc interface */
2573                 fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
2574                 fan4min = 0;
2575                 fan5pin = 0;
2576                 pwm4pin = 0;
2577                 pwm5pin = 0;
2578         } else if (data->kind == nct6776) {
2579                 bool gpok = superio_inb(sio_data->sioreg, 0x27) & 0x80;
2580
2581                 superio_select(sio_data->sioreg, NCT6775_LD_HWM);
2582                 regval = superio_inb(sio_data->sioreg, SIO_REG_ENABLE);
2583
2584                 if (regval & 0x80)
2585                         fan3pin = gpok;
2586                 else
2587                         fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
2588
2589                 if (regval & 0x40)
2590                         fan4pin = gpok;
2591                 else
2592                         fan4pin = superio_inb(sio_data->sioreg, 0x1C) & 0x01;
2593
2594                 if (regval & 0x20)
2595                         fan5pin = gpok;
2596                 else
2597                         fan5pin = superio_inb(sio_data->sioreg, 0x1C) & 0x02;
2598
2599                 fan4min = fan4pin;
2600                 fan3min = fan3pin;
2601                 pwm3pin = fan3pin;
2602                 pwm4pin = 0;
2603                 pwm5pin = 0;
2604         } else {        /* NCT6779D */
2605                 regval = superio_inb(sio_data->sioreg, 0x1c);
2606
2607                 fan3pin = !(regval & (1 << 5));
2608                 fan4pin = !(regval & (1 << 6));
2609                 fan5pin = !(regval & (1 << 7));
2610
2611                 pwm3pin = !(regval & (1 << 0));
2612                 pwm4pin = !(regval & (1 << 1));
2613                 pwm5pin = !(regval & (1 << 2));
2614
2615                 fan3min = 0;
2616                 fan4min = 0;
2617         }
2618
2619         superio_exit(sio_data->sioreg);
2620
2621         data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
2622         data->has_fan |= (fan3pin << 2);
2623         data->has_fan_min |= (fan3min << 2);
2624
2625         data->has_fan |= (fan4pin << 3) | (fan5pin << 4);
2626         data->has_fan_min |= (fan4min << 3) | (fan5pin << 4);
2627
2628         data->has_pwm = 0x03 | (pwm3pin << 2) | (pwm4pin << 3) | (pwm5pin << 4);
2629 }
2630
2631 static int __devinit nct6775_probe(struct platform_device *pdev)
2632 {
2633         struct device *dev = &pdev->dev;
2634         struct nct6775_sio_data *sio_data = dev->platform_data;
2635         struct nct6775_data *data;
2636         struct resource *res;
2637         int i, err = 0;
2638         int src, mask = 0;
2639         const u16 *reg_temp, *reg_temp_over, *reg_temp_hyst, *reg_temp_config;
2640
2641         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
2642         if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
2643                 err = -EBUSY;
2644                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
2645                         (unsigned long)res->start,
2646                         (unsigned long)res->start + IOREGION_LENGTH - 1);
2647                 goto exit;
2648         }
2649
2650         data = devm_kzalloc(&pdev->dev, sizeof(struct nct6775_data),
2651                             GFP_KERNEL);
2652         if (!data) {
2653                 err = -ENOMEM;
2654                 goto exit_release;
2655         }
2656
2657         data->kind = sio_data->kind;
2658         data->addr = res->start;
2659         mutex_init(&data->lock);
2660         mutex_init(&data->update_lock);
2661         data->name = nct6775_device_names[data->kind];
2662         platform_set_drvdata(pdev, data);
2663
2664         switch (data->kind) {
2665         case nct6775:
2666                 data->in_num = 9;
2667                 data->have_in = 0x1ff;
2668                 data->pwm_num = 3;
2669                 data->auto_pwm_num = 6;
2670                 data->has_fan_div = true;
2671
2672                 data->fan_from_reg = fan_from_reg16;
2673                 data->fan_from_reg_min = fan_from_reg8;
2674
2675                 data->REG_VIN = NCT6775_REG_IN;
2676                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
2677                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
2678                 data->REG_TARGET = NCT6775_REG_TARGET;
2679                 data->REG_FAN = NCT6775_REG_FAN;
2680                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
2681                 data->REG_FAN_MIN = NCT6775_REG_FAN_MIN;
2682                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
2683                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
2684                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
2685                 data->REG_PWM[0] = NCT6775_REG_PWM;
2686                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
2687                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
2688                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
2689                 data->REG_PWM_MODE = NCT6775_REG_PWM_MODE;
2690                 data->PWM_MODE_MASK = NCT6775_PWM_MODE_MASK;
2691                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
2692                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
2693                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
2694                 data->REG_CRITICAL_TEMP_TOLERANCE
2695                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
2696                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
2697                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
2698                 data->REG_TEMP_SOURCE_2 = NCT6775_REG_TEMP_SOURCE_2;
2699                 data->REG_ALARM = NCT6775_REG_ALARM;
2700                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
2701                 data->CASEOPEN_MASK = NCT6775_CASEOPEN_MASK;
2702
2703                 reg_temp = NCT6775_REG_TEMP;
2704                 reg_temp_over = NCT6775_REG_TEMP_OVER;
2705                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
2706                 reg_temp_config = NCT6775_REG_TEMP_CONFIG;
2707
2708                 break;
2709         case nct6776:
2710                 data->in_num = 9;
2711                 data->have_in = 0x1ff;
2712                 data->pwm_num = 3;
2713                 data->auto_pwm_num = 4;
2714                 data->has_fan_div = false;
2715                 data->fan_from_reg = fan_from_reg13;
2716                 data->fan_from_reg_min = fan_from_reg13;
2717                 data->REG_VIN = NCT6775_REG_IN;
2718                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
2719                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
2720                 data->REG_TARGET = NCT6775_REG_TARGET;
2721                 data->REG_FAN = NCT6775_REG_FAN;
2722                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
2723                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
2724                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
2725                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
2726                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
2727                 data->REG_PWM[0] = NCT6775_REG_PWM;
2728                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
2729                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
2730                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
2731                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
2732                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
2733                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
2734                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
2735                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
2736                 data->REG_CRITICAL_TEMP_TOLERANCE
2737                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
2738                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
2739                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
2740                 data->REG_TEMP_SOURCE_2 = NCT6775_REG_TEMP_SOURCE_2;
2741                 data->REG_ALARM = NCT6775_REG_ALARM;
2742                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
2743                 data->CASEOPEN_MASK = NCT6776_CASEOPEN_MASK;
2744
2745                 reg_temp = NCT6775_REG_TEMP;
2746                 reg_temp_over = NCT6775_REG_TEMP_OVER;
2747                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
2748                 reg_temp_config = NCT6776_REG_TEMP_CONFIG;
2749
2750                 break;
2751         case nct6779:
2752                 data->in_num = 15;
2753                 data->have_in = 0x7fff;
2754                 data->pwm_num = 5;
2755                 data->auto_pwm_num = 4;
2756                 data->has_fan_div = false;
2757
2758                 data->fan_from_reg = fan_from_reg13;
2759                 data->fan_from_reg_min = fan_from_reg13;
2760
2761                 data->REG_VIN = NCT6779_REG_IN;
2762                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
2763                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
2764                 data->REG_TARGET = NCT6775_REG_TARGET;
2765                 data->REG_FAN = NCT6779_REG_FAN;
2766                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
2767                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
2768                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
2769                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
2770                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
2771                 data->REG_PWM[0] = NCT6775_REG_PWM;
2772                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
2773                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
2774                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
2775                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
2776                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
2777                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
2778                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
2779                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
2780                 data->REG_CRITICAL_TEMP_TOLERANCE
2781                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
2782                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
2783                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
2784                 data->REG_TEMP_SOURCE_2 = NCT6775_REG_TEMP_SOURCE_2;
2785                 data->REG_ALARM = NCT6779_REG_ALARM;
2786                 data->REG_CASEOPEN = NCT6775_REG_CASEOPEN;
2787                 data->CASEOPEN_MASK = NCT6776_CASEOPEN_MASK;
2788
2789                 reg_temp = NCT6779_REG_TEMP;
2790                 reg_temp_over = NCT6775_REG_TEMP_OVER;
2791                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
2792                 reg_temp_config = NCT6776_REG_TEMP_CONFIG;
2793
2794                 break;
2795         default:
2796                 err = -ENODEV;
2797                 goto exit_release;
2798         }
2799
2800         /* Default to no temperature inputs, code below will adjust as needed */
2801         data->have_temp = 0;
2802
2803         for (i = 0; i < NUM_REG_TEMP; i++) {
2804                 if (reg_temp[i] == 0)
2805                         continue;
2806
2807                 data->reg_temp[0][i] = reg_temp[i];
2808                 data->reg_temp[1][i] = reg_temp_over[i];
2809                 data->reg_temp[2][i] = reg_temp_hyst[i];
2810                 data->reg_temp_config[i] = reg_temp_config[i];
2811
2812                 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]);
2813                 src &= 0x1f;
2814
2815                 /* Always display temp6..10 (fan control sources) if enabled */
2816                 if (src && (i > 5 || !(mask & (1 << src)))) {
2817                         data->have_temp |= 1 << i;
2818                         mask |= 1 << src;
2819                 }
2820
2821                 data->temp_src[0][i] = src;
2822
2823                 if (data->REG_TEMP_SOURCE_2[i]) {
2824                         src = nct6775_read_value(data,
2825                                                  data->REG_TEMP_SOURCE_2[i]);
2826                         data->temp_src[1][i] = src & 0x1f;
2827                 }
2828
2829                 if (i < 6) {
2830                         /*
2831                          * Do some register swapping if index 0..2 don't
2832                          * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
2833                          * Idea is to have the first three attributes
2834                          * report SYSTIN, CPUIN, and AUXIN if possible
2835                          * without overriding the basic system configuration.
2836                          * Do this only for the first six temperature sources;
2837                          * the remaining temperatures are fan control sources,
2838                          * and we don't want to touch those.
2839                          */
2840                         if (i > 0 && data->temp_src[0][0] != 1
2841                             && data->temp_src[0][i] == 1)
2842                                 w82627ehf_swap_tempreg(data, 0, i);
2843                         if (i > 1 && data->temp_src[0][1] != 2
2844                             && data->temp_src[0][i] == 2)
2845                                 w82627ehf_swap_tempreg(data, 1, i);
2846                         if (i > 2 && data->temp_src[0][2] != 3
2847                             && data->temp_src[0][i] == 3)
2848                                 w82627ehf_swap_tempreg(data, 2, i);
2849                 }
2850         }
2851         data->have_temp_offset = data->have_temp & 0x07;
2852         for (i = 0; i < 3; i++) {
2853                 if (data->temp_src[0][i] > 3)
2854                         data->have_temp_offset &= ~(1 << i);
2855         }
2856
2857         switch (data->kind) {
2858         case nct6775:
2859                 data->temp_label = nct6775_temp_label;
2860                 break;
2861         case nct6776:
2862                 /*
2863                  * On NCT6776, AUXTIN and VIN3 pins are shared.
2864                  * Only way to detect it is to check if AUXTIN is used
2865                  * as a temperature source, and if that source is
2866                  * enabled.
2867                  *
2868                  * If that is the case, disable in6, which reports VIN3.
2869                  * Otherwise disable temp3.
2870                  */
2871                 if (data->temp_src[0][2] == 3) {
2872                         u8 reg;
2873
2874                         if (data->reg_temp_config[2])
2875                                 reg = nct6775_read_value(data,
2876                                         data->reg_temp_config[2]);
2877                         else
2878                                 reg = 0; /* Assume AUXTIN is used */
2879
2880                         if (reg & 0x01)
2881                                 data->have_temp &= ~(1 << 2);
2882                         else
2883                                 data->have_in &= ~(1 << 6);
2884                 }
2885                 data->temp_label = nct6776_temp_label;
2886                 break;
2887         case nct6779:
2888                 /*
2889                  * Shared pins:
2890                  *      VIN4 / AUXTIN0
2891                  *      VIN5 / AUXTIN1
2892                  *      VIN6 / AUXTIN2
2893                  *      VIN7 / AUXTIN3
2894                  * Assume voltage is disabled if the respective temperature is
2895                  * used as temperature source.
2896                  */
2897                 for (i = 0; i < ARRAY_SIZE(NCT6779_REG_TEMP); i++) {
2898                         if (!(data->have_temp & (1 << i)))
2899                                 continue;
2900                         if (data->temp_src[0][i] == 3)          /* AUXTIN0 */
2901                                 data->have_in &= ~(1 << 6);     /* no VIN4 */
2902                         if (data->temp_src[0][i] == 4)          /* AUXTIN1 */
2903                                 data->have_in &= ~(1 << 10);    /* no VIN5 */
2904                         if (data->temp_src[0][i] == 5)          /* AUXTIN2 */
2905                                 data->have_in &= ~(1 << 11);    /* no VIN6 */
2906                         if (data->temp_src[0][i] == 6)          /* AUXTIN0 */
2907                                 data->have_in &= ~(1 << 14);    /* no VIN7 */
2908                 }
2909                 data->temp_label = nct6779_temp_label;
2910                 break;
2911         }
2912
2913         /* Initialize the chip */
2914         nct6775_init_device(data);
2915
2916         data->vrm = vid_which_vrm();
2917         superio_enter(sio_data->sioreg);
2918         /*
2919          * Read VID value
2920          * We can get the VID input values directly at logical device D 0xe3.
2921          */
2922         superio_select(sio_data->sioreg, NCT6775_LD_VID);
2923         data->vid = superio_inb(sio_data->sioreg, 0xe3);
2924         err = device_create_file(dev, &dev_attr_cpu0_vid);
2925         if (err)
2926                 goto exit_release;
2927
2928         if (fan_debounce) {
2929                 u8 tmp;
2930
2931                 superio_select(sio_data->sioreg, NCT6775_LD_HWM);
2932                 tmp = superio_inb(sio_data->sioreg,
2933                                   NCT6775_REG_CR_FAN_DEBOUNCE);
2934                 switch (data->kind) {
2935                 case nct6775:
2936                         tmp |= 0x1e;
2937                         break;
2938                 case nct6776:
2939                 case nct6779:
2940                         tmp |= 0x3e;
2941                         break;
2942                 }
2943                 superio_outb(sio_data->sioreg, NCT6775_REG_CR_FAN_DEBOUNCE,
2944                              tmp);
2945                 pr_info("Enabled fan debounce for chip %s\n", data->name);
2946         }
2947
2948         superio_exit(sio_data->sioreg);
2949
2950         nct6775_check_fan_inputs(sio_data, data);
2951
2952         /* Read fan clock dividers immediately */
2953         nct6775_update_fan_div_common(dev, data);
2954
2955         /* Register sysfs hooks */
2956         for (i = 0; i < data->pwm_num; i++) {
2957                 if (!(data->has_pwm & (1 << i)))
2958                         continue;
2959                 err = sysfs_create_group(&dev->kobj, &nct6775_group_pwm[i]);
2960                 if (err)
2961                         goto exit_remove;
2962                 if (data->REG_TEMP_SOURCE_2)
2963                         device_create_file(dev, &pwm_temp_src2[i].dev_attr);
2964         }
2965         for (i = 0; i < ARRAY_SIZE(sda_auto_pwm_arrays); i++) {
2966                 struct sensor_device_attribute_2 *attr =
2967                         &sda_auto_pwm_arrays[i];
2968
2969                 if (!(data->has_pwm & (1 << attr->nr)))
2970                         continue;
2971                 if (attr->index > data->auto_pwm_num)
2972                         continue;
2973                 err = device_create_file(dev, &attr->dev_attr);
2974                 if (err)
2975                         goto exit_remove;
2976         }
2977
2978         for (i = 0; i < data->in_num; i++) {
2979                 if (!(data->have_in & (1 << i)))
2980                         continue;
2981                 err = sysfs_create_group(&dev->kobj, &nct6775_group_in[i]);
2982                 if (err)
2983                         goto exit_remove;
2984         }
2985
2986         for (i = 0; i < 5; i++) {
2987                 if (data->has_fan & (1 << i)) {
2988                         err = device_create_file(dev,
2989                                                  &sda_fan_input[i].dev_attr);
2990                         if (err)
2991                                 goto exit_remove;
2992                         err = device_create_file(dev,
2993                                                  &sda_fan_alarm[i].dev_attr);
2994                         if (err)
2995                                 goto exit_remove;
2996                         if (data->kind != nct6776 &&
2997                             data->kind != nct6779) {
2998                                 err = device_create_file(dev,
2999                                                 &sda_fan_div[i].dev_attr);
3000                                 if (err)
3001                                         goto exit_remove;
3002                         }
3003                         if (data->has_fan_min & (1 << i)) {
3004                                 err = device_create_file(dev,
3005                                                 &sda_fan_min[i].dev_attr);
3006                                 if (err)
3007                                         goto exit_remove;
3008                         }
3009                 }
3010         }
3011
3012         for (i = 0; i < NUM_REG_TEMP; i++) {
3013                 if (!(data->have_temp & (1 << i)))
3014                         continue;
3015                 err = device_create_file(dev, &sda_temp_input[i].dev_attr);
3016                 if (err)
3017                         goto exit_remove;
3018                 if (i > 5)
3019                         continue;
3020                 if (data->temp_label) {
3021                         err = device_create_file(dev,
3022                                                  &sda_temp_label[i].dev_attr);
3023                         if (err)
3024                                 goto exit_remove;
3025                 }
3026                 if (data->reg_temp[1][i]) {
3027                         err = device_create_file(dev,
3028                                                  &sda_temp_max[i].dev_attr);
3029                         if (err)
3030                                 goto exit_remove;
3031                 }
3032                 if (data->reg_temp[2][i]) {
3033                         err = device_create_file(dev,
3034                                         &sda_temp_max_hyst[i].dev_attr);
3035                         if (err)
3036                                 goto exit_remove;
3037                 }
3038                 if (i > 2)
3039                         continue;
3040                 err = device_create_file(dev, &sda_temp_alarm[i].dev_attr);
3041                 if (err)
3042                         goto exit_remove;
3043                 err = device_create_file(dev, &sda_temp_type[i].dev_attr);
3044                 if (err)
3045                         goto exit_remove;
3046                 if (data->have_temp_offset & (1 << i)) {
3047                         err = device_create_file(dev,
3048                                                  &sda_temp_offset[i].dev_attr);
3049                         if (err)
3050                                 goto exit_remove;
3051                 }
3052         }
3053
3054         for (i = 0; i < ARRAY_SIZE(sda_caseopen); i++) {
3055                 if (!data->CASEOPEN_MASK[i])
3056                         continue;
3057                 err = device_create_file(dev, &sda_caseopen[i].dev_attr);
3058                 if (err)
3059                         goto exit_remove;
3060         }
3061
3062         err = device_create_file(dev, &dev_attr_name);
3063         if (err)
3064                 goto exit_remove;
3065
3066         data->hwmon_dev = hwmon_device_register(dev);
3067         if (IS_ERR(data->hwmon_dev)) {
3068                 err = PTR_ERR(data->hwmon_dev);
3069                 goto exit_remove;
3070         }
3071
3072         return 0;
3073
3074 exit_remove:
3075         nct6775_device_remove_files(dev);
3076 exit_release:
3077         release_region(res->start, IOREGION_LENGTH);
3078 exit:
3079         return err;
3080 }
3081
3082 static int __devexit nct6775_remove(struct platform_device *pdev)
3083 {
3084         struct nct6775_data *data = platform_get_drvdata(pdev);
3085
3086         hwmon_device_unregister(data->hwmon_dev);
3087         nct6775_device_remove_files(&pdev->dev);
3088         release_region(data->addr, IOREGION_LENGTH);
3089
3090         return 0;
3091 }
3092
3093 static struct platform_driver nct6775_driver = {
3094         .driver = {
3095                 .owner  = THIS_MODULE,
3096                 .name   = DRVNAME,
3097         },
3098         .probe          = nct6775_probe,
3099         .remove         = __devexit_p(nct6775_remove),
3100 };
3101
3102 /* nct6775_find() looks for a '627 in the Super-I/O config space */
3103 static int __init nct6775_find(int sioaddr, unsigned short *addr,
3104                                struct nct6775_sio_data *sio_data)
3105 {
3106         static const char __initdata sio_name_NCT6775[] = "NCT6775F";
3107         static const char __initdata sio_name_NCT6776[] = "NCT6776F";
3108         static const char __initdata sio_name_NCT6779[] = "NCT6779F";
3109
3110         u16 val;
3111         const char *sio_name;
3112
3113         superio_enter(sioaddr);
3114
3115         if (force_id)
3116                 val = force_id;
3117         else
3118                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
3119                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
3120         switch (val & SIO_ID_MASK) {
3121         case SIO_NCT6775_ID:
3122                 sio_data->kind = nct6775;
3123                 sio_name = sio_name_NCT6775;
3124                 break;
3125         case SIO_NCT6776_ID:
3126                 sio_data->kind = nct6776;
3127                 sio_name = sio_name_NCT6776;
3128                 break;
3129         case SIO_NCT6779_ID:
3130                 sio_data->kind = nct6779;
3131                 sio_name = sio_name_NCT6779;
3132                 break;
3133         default:
3134                 if (val != 0xffff)
3135                         pr_debug("unsupported chip ID: 0x%04x\n", val);
3136                 superio_exit(sioaddr);
3137                 return -ENODEV;
3138         }
3139
3140         /* We have a known chip, find the HWM I/O address */
3141         superio_select(sioaddr, NCT6775_LD_HWM);
3142         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
3143             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
3144         *addr = val & IOREGION_ALIGNMENT;
3145         if (*addr == 0) {
3146                 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n");
3147                 superio_exit(sioaddr);
3148                 return -ENODEV;
3149         }
3150
3151         /* Activate logical device if needed */
3152         val = superio_inb(sioaddr, SIO_REG_ENABLE);
3153         if (!(val & 0x01)) {
3154                 pr_warn("Forcibly enabling Super-I/O. "
3155                         "Sensor is probably unusable.\n");
3156                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
3157         }
3158
3159         superio_exit(sioaddr);
3160         pr_info("Found %s chip at %#x\n", sio_name, *addr);
3161         sio_data->sioreg = sioaddr;
3162
3163         return 0;
3164 }
3165
3166 /*
3167  * when Super-I/O functions move to a separate file, the Super-I/O
3168  * bus will manage the lifetime of the device and this module will only keep
3169  * track of the nct6775 driver. But since we platform_device_alloc(), we
3170  * must keep track of the device
3171  */
3172 static struct platform_device *pdev;
3173
3174 static int __init sensors_nct6775_init(void)
3175 {
3176         int err;
3177         unsigned short address;
3178         struct resource res;
3179         struct nct6775_sio_data sio_data;
3180
3181         /*
3182          * initialize sio_data->kind and sio_data->sioreg.
3183          *
3184          * when Super-I/O functions move to a separate file, the Super-I/O
3185          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
3186          * nct6775 hardware monitor, and call probe()
3187          */
3188         if (nct6775_find(0x2e, &address, &sio_data) &&
3189             nct6775_find(0x4e, &address, &sio_data))
3190                 return -ENODEV;
3191
3192         err = platform_driver_register(&nct6775_driver);
3193         if (err)
3194                 goto exit;
3195
3196         pdev = platform_device_alloc(DRVNAME, address);
3197         if (!pdev) {
3198                 err = -ENOMEM;
3199                 pr_err("Device allocation failed\n");
3200                 goto exit_unregister;
3201         }
3202
3203         err = platform_device_add_data(pdev, &sio_data,
3204                                        sizeof(struct nct6775_sio_data));
3205         if (err) {
3206                 pr_err("Platform data allocation failed\n");
3207                 goto exit_device_put;
3208         }
3209
3210         memset(&res, 0, sizeof(res));
3211         res.name = DRVNAME;
3212         res.start = address + IOREGION_OFFSET;
3213         res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
3214         res.flags = IORESOURCE_IO;
3215
3216         err = acpi_check_resource_conflict(&res);
3217         if (err)
3218                 goto exit_device_put;
3219
3220         err = platform_device_add_resources(pdev, &res, 1);
3221         if (err) {
3222                 pr_err("Device resource addition failed (%d)\n", err);
3223                 goto exit_device_put;
3224         }
3225
3226         /* platform_device_add calls probe() */
3227         err = platform_device_add(pdev);
3228         if (err) {
3229                 pr_err("Device addition failed (%d)\n", err);
3230                 goto exit_device_put;
3231         }
3232
3233         return 0;
3234
3235 exit_device_put:
3236         platform_device_put(pdev);
3237 exit_unregister:
3238         platform_driver_unregister(&nct6775_driver);
3239 exit:
3240         return err;
3241 }
3242
3243 static void __exit sensors_nct6775_exit(void)
3244 {
3245         platform_device_unregister(pdev);
3246         platform_driver_unregister(&nct6775_driver);
3247 }
3248
3249 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
3250 MODULE_DESCRIPTION("NCT677x driver");
3251 MODULE_LICENSE("GPL");
3252
3253 module_init(sensors_nct6775_init);
3254 module_exit(sensors_nct6775_exit);