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

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