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

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