drivers/hwmon/nct6683.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * nct6683 - Driver for the hardware monitoring functionality of
   4  *           Nuvoton NCT6683D/NCT6687D eSIO
   5  *
   6  * Copyright (C) 2013  Guenter Roeck <[email protected]>
   7  *
   8  * Derived from nct6775 driver
   9  * Copyright (C) 2012, 2013  Guenter Roeck <[email protected]>
  10  *
  11  * Supports the following chips:
  12  *
  13  * Chip        #vin    #fan    #pwm    #temp  chip ID
  14  * nct6683d     21(1)   16      8       32(1) 0xc730
  15  * nct6687d     21(1)   16      8       32(1) 0xd590
  16  *
  17  * Notes:
  18  *      (1) Total number of vin and temp inputs is 32.
  19  */
  20
  21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/acpi.h>
  24 #include <linux/delay.h>
  25 #include <linux/err.h>
  26 #include <linux/init.h>
  27 #include <linux/io.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/hwmon.h>
  30 #include <linux/hwmon-sysfs.h>
  31 #include <linux/module.h>
  32 #include <linux/mutex.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/slab.h>
  35
  36 enum kinds { nct6683, nct6687 };
  37
  38 static bool force;
  39 module_param(force, bool, 0);
  40 MODULE_PARM_DESC(force, "Set to one to enable support for unknown vendors");
  41
  42 static const char * const nct6683_device_names[] = {
  43         "nct6683",
  44         "nct6687",
  45 };
  46
  47 static const char * const nct6683_chip_names[] = {
  48         "NCT6683D",
  49         "NCT6687D",
  50 };
  51
  52 #define DRVNAME "nct6683"
  53
  54 /*
  55  * Super-I/O constants and functions
  56  */
  57
  58 #define NCT6683_LD_ACPI         0x0a
  59 #define NCT6683_LD_HWM          0x0b
  60 #define NCT6683_LD_VID          0x0d
  61
  62 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  63 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  64 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  65 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  66
  67 #define SIO_NCT6681_ID          0xb270  /* for later */
  68 #define SIO_NCT6683_ID          0xc730
  69 #define SIO_NCT6687_ID          0xd590
  70 #define SIO_ID_MASK             0xFFF0
  71
  72 static inline void
  73 superio_outb(int ioreg, int reg, int val)
  74 {
  75         outb(reg, ioreg);
  76         outb(val, ioreg + 1);
  77 }
  78
  79 static inline int
  80 superio_inb(int ioreg, int reg)
  81 {
  82         outb(reg, ioreg);
  83         return inb(ioreg + 1);
  84 }
  85
  86 static inline void
  87 superio_select(int ioreg, int ld)
  88 {
  89         outb(SIO_REG_LDSEL, ioreg);
  90         outb(ld, ioreg + 1);
  91 }
  92
  93 static inline int
  94 superio_enter(int ioreg)
  95 {
  96         /*
  97          * Try to reserve <ioreg> and <ioreg + 1> for exclusive access.
  98          */
  99         if (!request_muxed_region(ioreg, 2, DRVNAME))
 100                 return -EBUSY;
 101
 102         outb(0x87, ioreg);
 103         outb(0x87, ioreg);
 104
 105         return 0;
 106 }
 107
 108 static inline void
 109 superio_exit(int ioreg)
 110 {
 111         outb(0xaa, ioreg);
 112         outb(0x02, ioreg);
 113         outb(0x02, ioreg + 1);
 114         release_region(ioreg, 2);
 115 }
 116
 117 /*
 118  * ISA constants
 119  */
 120
 121 #define IOREGION_ALIGNMENT      (~7)
 122 #define IOREGION_OFFSET         4       /* Use EC port 1 */
 123 #define IOREGION_LENGTH         4
 124
 125 #define EC_PAGE_REG             0
 126 #define EC_INDEX_REG            1
 127 #define EC_DATA_REG             2
 128 #define EC_EVENT_REG            3
 129
 130 /* Common and NCT6683 specific data */
 131
 132 #define NCT6683_NUM_REG_MON             32
 133 #define NCT6683_NUM_REG_FAN             16
 134 #define NCT6683_NUM_REG_PWM             8
 135
 136 #define NCT6683_REG_MON(x)              (0x100 + (x) * 2)
 137 #define NCT6683_REG_FAN_RPM(x)          (0x140 + (x) * 2)
 138 #define NCT6683_REG_PWM(x)              (0x160 + (x))
 139 #define NCT6683_REG_PWM_WRITE(x)        (0xa28 + (x))
 140
 141 #define NCT6683_REG_MON_STS(x)          (0x174 + (x))
 142 #define NCT6683_REG_IDLE(x)             (0x178 + (x))
 143
 144 #define NCT6683_REG_FAN_STS(x)          (0x17c + (x))
 145 #define NCT6683_REG_FAN_ERRSTS          0x17e
 146 #define NCT6683_REG_FAN_INITSTS         0x17f
 147
 148 #define NCT6683_HWM_CFG                 0x180
 149
 150 #define NCT6683_REG_MON_CFG(x)          (0x1a0 + (x))
 151 #define NCT6683_REG_FANIN_CFG(x)        (0x1c0 + (x))
 152 #define NCT6683_REG_FANOUT_CFG(x)       (0x1d0 + (x))
 153
 154 #define NCT6683_REG_INTEL_TEMP_MAX(x)   (0x901 + (x) * 16)
 155 #define NCT6683_REG_INTEL_TEMP_CRIT(x)  (0x90d + (x) * 16)
 156
 157 #define NCT6683_REG_TEMP_HYST(x)        (0x330 + (x))           /* 8 bit */
 158 #define NCT6683_REG_TEMP_MAX(x)         (0x350 + (x))           /* 8 bit */
 159 #define NCT6683_REG_MON_HIGH(x)         (0x370 + (x) * 2)       /* 8 bit */
 160 #define NCT6683_REG_MON_LOW(x)          (0x371 + (x) * 2)       /* 8 bit */
 161
 162 #define NCT6683_REG_FAN_MIN(x)          (0x3b8 + (x) * 2)       /* 16 bit */
 163
 164 #define NCT6683_REG_FAN_CFG_CTRL        0xa01
 165 #define NCT6683_FAN_CFG_REQ             0x80
 166 #define NCT6683_FAN_CFG_DONE            0x40
 167
 168 #define NCT6683_REG_CUSTOMER_ID         0x602
 169 #define NCT6683_CUSTOMER_ID_INTEL       0x805
 170 #define NCT6683_CUSTOMER_ID_MITAC       0xa0e
 171 #define NCT6683_CUSTOMER_ID_MSI         0x201
 172 #define NCT6683_CUSTOMER_ID_ASROCK              0xe2c
 173
 174 #define NCT6683_REG_BUILD_YEAR          0x604
 175 #define NCT6683_REG_BUILD_MONTH         0x605
 176 #define NCT6683_REG_BUILD_DAY           0x606
 177 #define NCT6683_REG_SERIAL              0x607
 178 #define NCT6683_REG_VERSION_HI          0x608
 179 #define NCT6683_REG_VERSION_LO          0x609
 180
 181 #define NCT6683_REG_CR_CASEOPEN         0xe8
 182 #define NCT6683_CR_CASEOPEN_MASK        (1 << 7)
 183
 184 #define NCT6683_REG_CR_BEEP             0xe0
 185 #define NCT6683_CR_BEEP_MASK            (1 << 6)
 186
 187 static const char *const nct6683_mon_label[] = {
 188         NULL,   /* disabled */
 189         "Local",
 190         "Diode 0 (curr)",
 191         "Diode 1 (curr)",
 192         "Diode 2 (curr)",
 193         "Diode 0 (volt)",
 194         "Diode 1 (volt)",
 195         "Diode 2 (volt)",
 196         "Thermistor 14",
 197         "Thermistor 15",
 198         "Thermistor 16",
 199         "Thermistor 0",
 200         "Thermistor 1",
 201         "Thermistor 2",
 202         "Thermistor 3",
 203         "Thermistor 4",
 204         "Thermistor 5",         /* 0x10 */
 205         "Thermistor 6",
 206         "Thermistor 7",
 207         "Thermistor 8",
 208         "Thermistor 9",
 209         "Thermistor 10",
 210         "Thermistor 11",
 211         "Thermistor 12",
 212         "Thermistor 13",
 213         NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 214         "PECI 0.0",             /* 0x20 */
 215         "PECI 1.0",
 216         "PECI 2.0",
 217         "PECI 3.0",
 218         "PECI 0.1",
 219         "PECI 1.1",
 220         "PECI 2.1",
 221         "PECI 3.1",
 222         "PECI DIMM 0",
 223         "PECI DIMM 1",
 224         "PECI DIMM 2",
 225         "PECI DIMM 3",
 226         NULL, NULL, NULL, NULL,
 227         "PCH CPU",              /* 0x30 */
 228         "PCH CHIP",
 229         "PCH CHIP CPU MAX",
 230         "PCH MCH",
 231         "PCH DIMM 0",
 232         "PCH DIMM 1",
 233         "PCH DIMM 2",
 234         "PCH DIMM 3",
 235         "SMBus 0",
 236         "SMBus 1",
 237         "SMBus 2",
 238         "SMBus 3",
 239         "SMBus 4",
 240         "SMBus 5",
 241         "DIMM 0",
 242         "DIMM 1",
 243         "DIMM 2",               /* 0x40 */
 244         "DIMM 3",
 245         "AMD TSI Addr 90h",
 246         "AMD TSI Addr 92h",
 247         "AMD TSI Addr 94h",
 248         "AMD TSI Addr 96h",
 249         "AMD TSI Addr 98h",
 250         "AMD TSI Addr 9ah",
 251         "AMD TSI Addr 9ch",
 252         "AMD TSI Addr 9dh",
 253         NULL, NULL, NULL, NULL, NULL, NULL,
 254         "Virtual 0",            /* 0x50 */
 255         "Virtual 1",
 256         "Virtual 2",
 257         "Virtual 3",
 258         "Virtual 4",
 259         "Virtual 5",
 260         "Virtual 6",
 261         "Virtual 7",
 262         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 263         "VCC",                  /* 0x60 voltage sensors */
 264         "VSB",
 265         "AVSB",
 266         "VTT",
 267         "VBAT",
 268         "VREF",
 269         "VIN0",
 270         "VIN1",
 271         "VIN2",
 272         "VIN3",
 273         "VIN4",
 274         "VIN5",
 275         "VIN6",
 276         "VIN7",
 277         "VIN8",
 278         "VIN9",
 279         "VIN10",
 280         "VIN11",
 281         "VIN12",
 282         "VIN13",
 283         "VIN14",
 284         "VIN15",
 285         "VIN16",
 286 };
 287
 288 #define NUM_MON_LABELS          ARRAY_SIZE(nct6683_mon_label)
 289 #define MON_VOLTAGE_START       0x60
 290
 291 /* ------------------------------------------------------- */
 292
 293 struct nct6683_data {
 294         int addr;               /* IO base of EC space */
 295         int sioreg;             /* SIO register */
 296         enum kinds kind;
 297         u16 customer_id;
 298
 299         struct device *hwmon_dev;
 300         const struct attribute_group *groups[6];
 301
 302         int temp_num;                   /* number of temperature attributes */
 303         u8 temp_index[NCT6683_NUM_REG_MON];
 304         u8 temp_src[NCT6683_NUM_REG_MON];
 305
 306         u8 in_num;                      /* number of voltage attributes */
 307         u8 in_index[NCT6683_NUM_REG_MON];
 308         u8 in_src[NCT6683_NUM_REG_MON];
 309
 310         struct mutex update_lock;       /* used to protect sensor updates */
 311         bool valid;                     /* true if following fields are valid */
 312         unsigned long last_updated;     /* In jiffies */
 313
 314         /* Voltage attribute values */
 315         u8 in[3][NCT6683_NUM_REG_MON];  /* [0]=in, [1]=in_max, [2]=in_min */
 316
 317         /* Temperature attribute values */
 318         s16 temp_in[NCT6683_NUM_REG_MON];
 319         s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst,
 320                                          * [3]=crit
 321                                          */
 322
 323         /* Fan attribute values */
 324         unsigned int rpm[NCT6683_NUM_REG_FAN];
 325         u16 fan_min[NCT6683_NUM_REG_FAN];
 326         u8 fanin_cfg[NCT6683_NUM_REG_FAN];
 327         u8 fanout_cfg[NCT6683_NUM_REG_FAN];
 328         u16 have_fan;                   /* some fan inputs can be disabled */
 329
 330         u8 have_pwm;
 331         u8 pwm[NCT6683_NUM_REG_PWM];
 332
 333 #ifdef CONFIG_PM
 334         /* Remember extra register values over suspend/resume */
 335         u8 hwm_cfg;
 336 #endif
 337 };
 338
 339 struct nct6683_sio_data {
 340         int sioreg;
 341         enum kinds kind;
 342 };
 343
 344 struct sensor_device_template {
 345         struct device_attribute dev_attr;
 346         union {
 347                 struct {
 348                         u8 nr;
 349                         u8 index;
 350                 } s;
 351                 int index;
 352         } u;
 353         bool s2;        /* true if both index and nr are used */
 354 };
 355
 356 struct sensor_device_attr_u {
 357         union {
 358                 struct sensor_device_attribute a1;
 359                 struct sensor_device_attribute_2 a2;
 360         } u;
 361         char name[32];
 362 };
 363
 364 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) {      \
 365         .attr = {.name = _template, .mode = _mode },            \
 366         .show   = _show,                                        \
 367         .store  = _store,                                       \
 368 }
 369
 370 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
 371         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
 372           .u.index = _index,                                            \
 373           .s2 = false }
 374
 375 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,       \
 376                                  _nr, _index)                           \
 377         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
 378           .u.s.index = _index,                                          \
 379           .u.s.nr = _nr,                                                \
 380           .s2 = true }
 381
 382 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \
 383 static struct sensor_device_template sensor_dev_template_##_name        \
 384         = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store,       \
 385                                  _index)
 386
 387 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store,       \
 388                           _nr, _index)                                  \
 389 static struct sensor_device_template sensor_dev_template_##_name        \
 390         = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,     \
 391                                  _nr, _index)
 392
 393 struct sensor_template_group {
 394         struct sensor_device_template **templates;
 395         umode_t (*is_visible)(struct kobject *, struct attribute *, int);
 396         int base;
 397 };
 398
 399 static struct attribute_group *
 400 nct6683_create_attr_group(struct device *dev,
 401                           const struct sensor_template_group *tg,
 402                           int repeat)
 403 {
 404         struct sensor_device_attribute_2 *a2;
 405         struct sensor_device_attribute *a;
 406         struct sensor_device_template **t;
 407         struct sensor_device_attr_u *su;
 408         struct attribute_group *group;
 409         struct attribute **attrs;
 410         int i, j, count;
 411
 412         if (repeat <= 0)
 413                 return ERR_PTR(-EINVAL);
 414
 415         t = tg->templates;
 416         for (count = 0; *t; t++, count++)
 417                 ;
 418
 419         if (count == 0)
 420                 return ERR_PTR(-EINVAL);
 421
 422         group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
 423         if (group == NULL)
 424                 return ERR_PTR(-ENOMEM);
 425
 426         attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs),
 427                              GFP_KERNEL);
 428         if (attrs == NULL)
 429                 return ERR_PTR(-ENOMEM);
 430
 431         su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)),
 432                           GFP_KERNEL);
 433         if (su == NULL)
 434                 return ERR_PTR(-ENOMEM);
 435
 436         group->attrs = attrs;
 437         group->is_visible = tg->is_visible;
 438
 439         for (i = 0; i < repeat; i++) {
 440                 t = tg->templates;
 441                 for (j = 0; *t != NULL; j++) {
 442                         snprintf(su->name, sizeof(su->name),
 443                                  (*t)->dev_attr.attr.name, tg->base + i);
 444                         if ((*t)->s2) {
 445                                 a2 = &su->u.a2;
 446                                 sysfs_attr_init(&a2->dev_attr.attr);
 447                                 a2->dev_attr.attr.name = su->name;
 448                                 a2->nr = (*t)->u.s.nr + i;
 449                                 a2->index = (*t)->u.s.index;
 450                                 a2->dev_attr.attr.mode =
 451                                   (*t)->dev_attr.attr.mode;
 452                                 a2->dev_attr.show = (*t)->dev_attr.show;
 453                                 a2->dev_attr.store = (*t)->dev_attr.store;
 454                                 *attrs = &a2->dev_attr.attr;
 455                         } else {
 456                                 a = &su->u.a1;
 457                                 sysfs_attr_init(&a->dev_attr.attr);
 458                                 a->dev_attr.attr.name = su->name;
 459                                 a->index = (*t)->u.index + i;
 460                                 a->dev_attr.attr.mode =
 461                                   (*t)->dev_attr.attr.mode;
 462                                 a->dev_attr.show = (*t)->dev_attr.show;
 463                                 a->dev_attr.store = (*t)->dev_attr.store;
 464                                 *attrs = &a->dev_attr.attr;
 465                         }
 466                         attrs++;
 467                         su++;
 468                         t++;
 469                 }
 470         }
 471
 472         return group;
 473 }
 474
 475 /* LSB is 16 mV, except for the following sources, where it is 32 mV */
 476 #define MON_SRC_VCC     0x60
 477 #define MON_SRC_VSB     0x61
 478 #define MON_SRC_AVSB    0x62
 479 #define MON_SRC_VBAT    0x64
 480
 481 static inline long in_from_reg(u16 reg, u8 src)
 482 {
 483         int scale = 16;
 484
 485         if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
 486             src == MON_SRC_VBAT)
 487                 scale <<= 1;
 488         return reg * scale;
 489 }
 490
 491 static inline u16 in_to_reg(u32 val, u8 src)
 492 {
 493         int scale = 16;
 494
 495         if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
 496             src == MON_SRC_VBAT)
 497                 scale <<= 1;
 498
 499         return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127);
 500 }
 501
 502 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
 503 {
 504         int res;
 505
 506         outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 507         outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 508         outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 509         res = inb_p(data->addr + EC_DATA_REG);
 510         return res;
 511 }
 512
 513 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
 514 {
 515         return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
 516 }
 517
 518 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
 519 {
 520         outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 521         outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 522         outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 523         outb_p(value & 0xff, data->addr + EC_DATA_REG);
 524 }
 525
 526 static int get_in_reg(struct nct6683_data *data, int nr, int index)
 527 {
 528         int ch = data->in_index[index];
 529         int reg = -EINVAL;
 530
 531         switch (nr) {
 532         case 0:
 533                 reg = NCT6683_REG_MON(ch);
 534                 break;
 535         case 1:
 536                 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 537                         reg = NCT6683_REG_MON_LOW(ch);
 538                 break;
 539         case 2:
 540                 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 541                         reg = NCT6683_REG_MON_HIGH(ch);
 542                 break;
 543         default:
 544                 break;
 545         }
 546         return reg;
 547 }
 548
 549 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
 550 {
 551         int ch = data->temp_index[index];
 552         int reg = -EINVAL;
 553
 554         switch (data->customer_id) {
 555         case NCT6683_CUSTOMER_ID_INTEL:
 556                 switch (nr) {
 557                 default:
 558                 case 1: /* max */
 559                         reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
 560                         break;
 561                 case 3: /* crit */
 562                         reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
 563                         break;
 564                 }
 565                 break;
 566         case NCT6683_CUSTOMER_ID_MITAC:
 567         default:
 568                 switch (nr) {
 569                 default:
 570                 case 0: /* min */
 571                         reg = NCT6683_REG_MON_LOW(ch);
 572                         break;
 573                 case 1: /* max */
 574                         reg = NCT6683_REG_TEMP_MAX(ch);
 575                         break;
 576                 case 2: /* hyst */
 577                         reg = NCT6683_REG_TEMP_HYST(ch);
 578                         break;
 579                 case 3: /* crit */
 580                         reg = NCT6683_REG_MON_HIGH(ch);
 581                         break;
 582                 }
 583                 break;
 584         }
 585         return reg;
 586 }
 587
 588 static void nct6683_update_pwm(struct device *dev)
 589 {
 590         struct nct6683_data *data = dev_get_drvdata(dev);
 591         int i;
 592
 593         for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
 594                 if (!(data->have_pwm & (1 << i)))
 595                         continue;
 596                 data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));
 597         }
 598 }
 599
 600 static struct nct6683_data *nct6683_update_device(struct device *dev)
 601 {
 602         struct nct6683_data *data = dev_get_drvdata(dev);
 603         int i, j;
 604
 605         mutex_lock(&data->update_lock);
 606
 607         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 608                 /* Measured voltages and limits */
 609                 for (i = 0; i < data->in_num; i++) {
 610                         for (j = 0; j < 3; j++) {
 611                                 int reg = get_in_reg(data, j, i);
 612
 613                                 if (reg >= 0)
 614                                         data->in[j][i] =
 615                                                 nct6683_read(data, reg);
 616                         }
 617                 }
 618
 619                 /* Measured temperatures and limits */
 620                 for (i = 0; i < data->temp_num; i++) {
 621                         u8 ch = data->temp_index[i];
 622
 623                         data->temp_in[i] = nct6683_read16(data,
 624                                                           NCT6683_REG_MON(ch));
 625                         for (j = 0; j < 4; j++) {
 626                                 int reg = get_temp_reg(data, j, i);
 627
 628                                 if (reg >= 0)
 629                                         data->temp[j][i] =
 630                                                 nct6683_read(data, reg);
 631                         }
 632                 }
 633
 634                 /* Measured fan speeds and limits */
 635                 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
 636                         if (!(data->have_fan & (1 << i)))
 637                                 continue;
 638
 639                         data->rpm[i] = nct6683_read16(data,
 640                                                 NCT6683_REG_FAN_RPM(i));
 641                         data->fan_min[i] = nct6683_read16(data,
 642                                                 NCT6683_REG_FAN_MIN(i));
 643                 }
 644
 645                 nct6683_update_pwm(dev);
 646
 647                 data->last_updated = jiffies;
 648                 data->valid = true;
 649         }
 650
 651         mutex_unlock(&data->update_lock);
 652         return data;
 653 }
 654
 655 /*
 656  * Sysfs callback functions
 657  */
 658 static ssize_t
 659 show_in_label(struct device *dev, struct device_attribute *attr, char *buf)
 660 {
 661         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 662         struct nct6683_data *data = nct6683_update_device(dev);
 663         int nr = sattr->index;
 664
 665         return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]);
 666 }
 667
 668 static ssize_t
 669 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
 670 {
 671         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 672         struct nct6683_data *data = nct6683_update_device(dev);
 673         int index = sattr->index;
 674         int nr = sattr->nr;
 675
 676         return sprintf(buf, "%ld\n",
 677                        in_from_reg(data->in[index][nr], data->in_index[index]));
 678 }
 679
 680 static umode_t nct6683_in_is_visible(struct kobject *kobj,
 681                                      struct attribute *attr, int index)
 682 {
 683         struct device *dev = kobj_to_dev(kobj);
 684         struct nct6683_data *data = dev_get_drvdata(dev);
 685         int nr = index % 4;     /* attribute */
 686
 687         /*
 688          * Voltage limits exist for Intel boards,
 689          * but register location and encoding is unknown
 690          */
 691         if ((nr == 2 || nr == 3) &&
 692             data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 693                 return 0;
 694
 695         return attr->mode;
 696 }
 697
 698 SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0);
 699 SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0);
 700 SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1);
 701 SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2);
 702
 703 static struct sensor_device_template *nct6683_attributes_in_template[] = {
 704         &sensor_dev_template_in_label,
 705         &sensor_dev_template_in_input,
 706         &sensor_dev_template_in_min,
 707         &sensor_dev_template_in_max,
 708         NULL
 709 };
 710
 711 static const struct sensor_template_group nct6683_in_template_group = {
 712         .templates = nct6683_attributes_in_template,
 713         .is_visible = nct6683_in_is_visible,
 714 };
 715
 716 static ssize_t
 717 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 718 {
 719         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 720         struct nct6683_data *data = nct6683_update_device(dev);
 721
 722         return sprintf(buf, "%d\n", data->rpm[sattr->index]);
 723 }
 724
 725 static ssize_t
 726 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
 727 {
 728         struct nct6683_data *data = nct6683_update_device(dev);
 729         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 730         int nr = sattr->index;
 731
 732         return sprintf(buf, "%d\n", data->fan_min[nr]);
 733 }
 734
 735 static ssize_t
 736 show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
 737 {
 738         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 739         struct nct6683_data *data = nct6683_update_device(dev);
 740
 741         return sprintf(buf, "%d\n",
 742                        ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1);
 743 }
 744
 745 static umode_t nct6683_fan_is_visible(struct kobject *kobj,
 746                                       struct attribute *attr, int index)
 747 {
 748         struct device *dev = kobj_to_dev(kobj);
 749         struct nct6683_data *data = dev_get_drvdata(dev);
 750         int fan = index / 3;    /* fan index */
 751         int nr = index % 3;     /* attribute index */
 752
 753         if (!(data->have_fan & (1 << fan)))
 754                 return 0;
 755
 756         /*
 757          * Intel may have minimum fan speed limits,
 758          * but register location and encoding are unknown.
 759          */
 760         if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 761                 return 0;
 762
 763         return attr->mode;
 764 }
 765
 766 SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0);
 767 SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0);
 768 SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IRUGO, show_fan_min, NULL, 0);
 769
 770 /*
 771  * nct6683_fan_is_visible uses the index into the following array
 772  * to determine if attributes should be created or not.
 773  * Any change in order or content must be matched.
 774  */
 775 static struct sensor_device_template *nct6683_attributes_fan_template[] = {
 776         &sensor_dev_template_fan_input,
 777         &sensor_dev_template_fan_pulses,
 778         &sensor_dev_template_fan_min,
 779         NULL
 780 };
 781
 782 static const struct sensor_template_group nct6683_fan_template_group = {
 783         .templates = nct6683_attributes_fan_template,
 784         .is_visible = nct6683_fan_is_visible,
 785         .base = 1,
 786 };
 787
 788 static ssize_t
 789 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
 790 {
 791         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 792         struct nct6683_data *data = nct6683_update_device(dev);
 793         int nr = sattr->index;
 794
 795         return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]);
 796 }
 797
 798 static ssize_t
 799 show_temp8(struct device *dev, struct device_attribute *attr, char *buf)
 800 {
 801         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 802         struct nct6683_data *data = nct6683_update_device(dev);
 803         int index = sattr->index;
 804         int nr = sattr->nr;
 805
 806         return sprintf(buf, "%d\n", data->temp[index][nr] * 1000);
 807 }
 808
 809 static ssize_t
 810 show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
 811 {
 812         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 813         struct nct6683_data *data = nct6683_update_device(dev);
 814         int nr = sattr->index;
 815         int temp = data->temp[1][nr] - data->temp[2][nr];
 816
 817         return sprintf(buf, "%d\n", temp * 1000);
 818 }
 819
 820 static ssize_t
 821 show_temp16(struct device *dev, struct device_attribute *attr, char *buf)
 822 {
 823         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 824         struct nct6683_data *data = nct6683_update_device(dev);
 825         int index = sattr->index;
 826
 827         return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500);
 828 }
 829
 830 /*
 831  * Temperature sensor type is determined by temperature source
 832  * and can not be modified.
 833  * 0x02..0x07: Thermal diode
 834  * 0x08..0x18: Thermistor
 835  * 0x20..0x2b: Intel PECI
 836  * 0x42..0x49: AMD TSI
 837  * Others are unspecified (not visible)
 838  */
 839
 840 static int get_temp_type(u8 src)
 841 {
 842         if (src >= 0x02 && src <= 0x07)
 843                 return 3;       /* thermal diode */
 844         else if (src >= 0x08 && src <= 0x18)
 845                 return 4;       /* thermistor */
 846         else if (src >= 0x20 && src <= 0x2b)
 847                 return 6;       /* PECI */
 848         else if (src >= 0x42 && src <= 0x49)
 849                 return 5;
 850
 851         return 0;
 852 }
 853
 854 static ssize_t
 855 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
 856 {
 857         struct nct6683_data *data = nct6683_update_device(dev);
 858         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 859         int nr = sattr->index;
 860         return sprintf(buf, "%d\n", get_temp_type(data->temp_src[nr]));
 861 }
 862
 863 static umode_t nct6683_temp_is_visible(struct kobject *kobj,
 864                                        struct attribute *attr, int index)
 865 {
 866         struct device *dev = kobj_to_dev(kobj);
 867         struct nct6683_data *data = dev_get_drvdata(dev);
 868         int temp = index / 7;   /* temp index */
 869         int nr = index % 7;     /* attribute index */
 870
 871         /*
 872          * Intel does not have low temperature limits or temperature hysteresis
 873          * registers, or at least register location and encoding is unknown.
 874          */
 875         if ((nr == 2 || nr == 4) &&
 876             data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 877                 return 0;
 878
 879         if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0)
 880                 return 0;                               /* type */
 881
 882         return attr->mode;
 883 }
 884
 885 SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0);
 886 SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0);
 887 SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0);
 888 SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1);
 889 SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL,
 890                 0);
 891 SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3);
 892 SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO, show_temp_type, NULL, 0);
 893
 894 /*
 895  * nct6683_temp_is_visible uses the index into the following array
 896  * to determine if attributes should be created or not.
 897  * Any change in order or content must be matched.
 898  */
 899 static struct sensor_device_template *nct6683_attributes_temp_template[] = {
 900         &sensor_dev_template_temp_input,
 901         &sensor_dev_template_temp_label,
 902         &sensor_dev_template_temp_min,          /* 2 */
 903         &sensor_dev_template_temp_max,          /* 3 */
 904         &sensor_dev_template_temp_max_hyst,     /* 4 */
 905         &sensor_dev_template_temp_crit,         /* 5 */
 906         &sensor_dev_template_temp_type,         /* 6 */
 907         NULL
 908 };
 909
 910 static const struct sensor_template_group nct6683_temp_template_group = {
 911         .templates = nct6683_attributes_temp_template,
 912         .is_visible = nct6683_temp_is_visible,
 913         .base = 1,
 914 };
 915
 916 static ssize_t
 917 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 918 {
 919         struct nct6683_data *data = nct6683_update_device(dev);
 920         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 921         int index = sattr->index;
 922
 923         return sprintf(buf, "%d\n", data->pwm[index]);
 924 }
 925
 926 static ssize_t
 927 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
 928           size_t count)
 929 {
 930         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 931         struct nct6683_data *data = dev_get_drvdata(dev);
 932         int index = sattr->index;
 933         unsigned long val;
 934
 935         if (kstrtoul(buf, 10, &val) || val > 255)
 936                 return -EINVAL;
 937
 938         mutex_lock(&data->update_lock);
 939         nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_REQ);
 940         usleep_range(1000, 2000);
 941         nct6683_write(data, NCT6683_REG_PWM_WRITE(index), val);
 942         nct6683_write(data, NCT6683_REG_FAN_CFG_CTRL, NCT6683_FAN_CFG_DONE);
 943         mutex_unlock(&data->update_lock);
 944
 945         return count;
 946 }
 947
 948 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, store_pwm, 0);
 949
 950 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
 951                                       struct attribute *attr, int index)
 952 {
 953         struct device *dev = kobj_to_dev(kobj);
 954         struct nct6683_data *data = dev_get_drvdata(dev);
 955         int pwm = index;        /* pwm index */
 956
 957         if (!(data->have_pwm & (1 << pwm)))
 958                 return 0;
 959
 960         /* Only update pwm values for Mitac boards */
 961         if (data->customer_id == NCT6683_CUSTOMER_ID_MITAC)
 962                 return attr->mode | S_IWUSR;
 963
 964         return attr->mode;
 965 }
 966
 967 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
 968         &sensor_dev_template_pwm,
 969         NULL
 970 };
 971
 972 static const struct sensor_template_group nct6683_pwm_template_group = {
 973         .templates = nct6683_attributes_pwm_template,
 974         .is_visible = nct6683_pwm_is_visible,
 975         .base = 1,
 976 };
 977
 978 static ssize_t
 979 beep_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 980 {
 981         struct nct6683_data *data = dev_get_drvdata(dev);
 982         int ret;
 983         u8 reg;
 984
 985         mutex_lock(&data->update_lock);
 986
 987         ret = superio_enter(data->sioreg);
 988         if (ret)
 989                 goto error;
 990         superio_select(data->sioreg, NCT6683_LD_HWM);
 991         reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
 992         superio_exit(data->sioreg);
 993
 994         mutex_unlock(&data->update_lock);
 995
 996         return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
 997
 998 error:
 999         mutex_unlock(&data->update_lock);
1000         return ret;
1001 }
1002
1003 static ssize_t
1004 beep_enable_store(struct device *dev, struct device_attribute *attr,
1005                   const char *buf, size_t count)
1006 {
1007         struct nct6683_data *data = dev_get_drvdata(dev);
1008         unsigned long val;
1009         u8 reg;
1010         int ret;
1011
1012         if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
1013                 return -EINVAL;
1014
1015         mutex_lock(&data->update_lock);
1016
1017         ret = superio_enter(data->sioreg);
1018         if (ret) {
1019                 count = ret;
1020                 goto error;
1021         }
1022
1023         superio_select(data->sioreg, NCT6683_LD_HWM);
1024         reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
1025         if (val)
1026                 reg |= NCT6683_CR_BEEP_MASK;
1027         else
1028                 reg &= ~NCT6683_CR_BEEP_MASK;
1029         superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
1030         superio_exit(data->sioreg);
1031 error:
1032         mutex_unlock(&data->update_lock);
1033         return count;
1034 }
1035
1036 /* Case open detection */
1037
1038 static ssize_t
1039 intrusion0_alarm_show(struct device *dev, struct device_attribute *attr,
1040                       char *buf)
1041 {
1042         struct nct6683_data *data = dev_get_drvdata(dev);
1043         int ret;
1044         u8 reg;
1045
1046         mutex_lock(&data->update_lock);
1047
1048         ret = superio_enter(data->sioreg);
1049         if (ret)
1050                 goto error;
1051         superio_select(data->sioreg, NCT6683_LD_ACPI);
1052         reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1053         superio_exit(data->sioreg);
1054
1055         mutex_unlock(&data->update_lock);
1056
1057         return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1058
1059 error:
1060         mutex_unlock(&data->update_lock);
1061         return ret;
1062 }
1063
1064 static ssize_t
1065 intrusion0_alarm_store(struct device *dev, struct device_attribute *attr,
1066                        const char *buf, size_t count)
1067 {
1068         struct nct6683_data *data = dev_get_drvdata(dev);
1069         unsigned long val;
1070         u8 reg;
1071         int ret;
1072
1073         if (kstrtoul(buf, 10, &val) || val != 0)
1074                 return -EINVAL;
1075
1076         mutex_lock(&data->update_lock);
1077
1078         /*
1079          * Use CR registers to clear caseopen status.
1080          * Caseopen is activ low, clear by writing 1 into the register.
1081          */
1082
1083         ret = superio_enter(data->sioreg);
1084         if (ret) {
1085                 count = ret;
1086                 goto error;
1087         }
1088
1089         superio_select(data->sioreg, NCT6683_LD_ACPI);
1090         reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1091         reg |= NCT6683_CR_CASEOPEN_MASK;
1092         superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1093         reg &= ~NCT6683_CR_CASEOPEN_MASK;
1094         superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1095         superio_exit(data->sioreg);
1096
1097         data->valid = false;    /* Force cache refresh */
1098 error:
1099         mutex_unlock(&data->update_lock);
1100         return count;
1101 }
1102
1103 static DEVICE_ATTR_RW(intrusion0_alarm);
1104 static DEVICE_ATTR_RW(beep_enable);
1105
1106 static struct attribute *nct6683_attributes_other[] = {
1107         &dev_attr_intrusion0_alarm.attr,
1108         &dev_attr_beep_enable.attr,
1109         NULL
1110 };
1111
1112 static const struct attribute_group nct6683_group_other = {
1113         .attrs = nct6683_attributes_other,
1114 };
1115
1116 /* Get the monitoring functions started */
1117 static inline void nct6683_init_device(struct nct6683_data *data)
1118 {
1119         u8 tmp;
1120
1121         /* Start hardware monitoring if needed */
1122         tmp = nct6683_read(data, NCT6683_HWM_CFG);
1123         if (!(tmp & 0x80))
1124                 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1125 }
1126
1127 /*
1128  * There are a total of 24 fan inputs. Each can be configured as input
1129  * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1130  */
1131 static void
1132 nct6683_setup_fans(struct nct6683_data *data)
1133 {
1134         int i;
1135         u8 reg;
1136
1137         for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1138                 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1139                 if (reg & 0x80)
1140                         data->have_fan |= 1 << i;
1141                 data->fanin_cfg[i] = reg;
1142         }
1143         for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1144                 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1145                 if (reg & 0x80)
1146                         data->have_pwm |= 1 << i;
1147                 data->fanout_cfg[i] = reg;
1148         }
1149 }
1150
1151 /*
1152  * Translation from monitoring register to temperature and voltage attributes
1153  * ==========================================================================
1154  *
1155  * There are a total of 32 monitoring registers. Each can be assigned to either
1156  * a temperature or voltage monitoring source.
1157  * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1158  *
1159  * Temperature and voltage attribute mapping is determined by walking through
1160  * the NCT6683_REG_MON_CFG registers. If the assigned source is
1161  * a temperature, temp_index[n] is set to the monitor register index, and
1162  * temp_src[n] is set to the temperature source. If the assigned source is
1163  * a voltage, the respective values are stored in in_index[] and in_src[],
1164  * respectively.
1165  */
1166
1167 static void nct6683_setup_sensors(struct nct6683_data *data)
1168 {
1169         u8 reg;
1170         int i;
1171
1172         data->temp_num = 0;
1173         data->in_num = 0;
1174         for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1175                 reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1176                 /* Ignore invalid assignments */
1177                 if (reg >= NUM_MON_LABELS)
1178                         continue;
1179                 /* Skip if disabled or reserved */
1180                 if (nct6683_mon_label[reg] == NULL)
1181                         continue;
1182                 if (reg < MON_VOLTAGE_START) {
1183                         data->temp_index[data->temp_num] = i;
1184                         data->temp_src[data->temp_num] = reg;
1185                         data->temp_num++;
1186                 } else {
1187                         data->in_index[data->in_num] = i;
1188                         data->in_src[data->in_num] = reg;
1189                         data->in_num++;
1190                 }
1191         }
1192 }
1193
1194 static int nct6683_probe(struct platform_device *pdev)
1195 {
1196         struct device *dev = &pdev->dev;
1197         struct nct6683_sio_data *sio_data = dev->platform_data;
1198         struct attribute_group *group;
1199         struct nct6683_data *data;
1200         struct device *hwmon_dev;
1201         struct resource *res;
1202         int groups = 0;
1203         char build[16];
1204
1205         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1206         if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1207                 return -EBUSY;
1208
1209         data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1210         if (!data)
1211                 return -ENOMEM;
1212
1213         data->kind = sio_data->kind;
1214         data->sioreg = sio_data->sioreg;
1215         data->addr = res->start;
1216         mutex_init(&data->update_lock);
1217         platform_set_drvdata(pdev, data);
1218
1219         data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1220
1221         /* By default only instantiate driver if the customer ID is known */
1222         switch (data->customer_id) {
1223         case NCT6683_CUSTOMER_ID_INTEL:
1224                 break;
1225         case NCT6683_CUSTOMER_ID_MITAC:
1226                 break;
1227         case NCT6683_CUSTOMER_ID_MSI:
1228                 break;
1229         case NCT6683_CUSTOMER_ID_ASROCK:
1230                 break;
1231         default:
1232                 if (!force)
1233                         return -ENODEV;
1234         }
1235
1236         nct6683_init_device(data);
1237         nct6683_setup_fans(data);
1238         nct6683_setup_sensors(data);
1239
1240         /* Register sysfs hooks */
1241
1242         if (data->have_pwm) {
1243                 group = nct6683_create_attr_group(dev,
1244                                                   &nct6683_pwm_template_group,
1245                                                   fls(data->have_pwm));
1246                 if (IS_ERR(group))
1247                         return PTR_ERR(group);
1248                 data->groups[groups++] = group;
1249         }
1250
1251         if (data->in_num) {
1252                 group = nct6683_create_attr_group(dev,
1253                                                   &nct6683_in_template_group,
1254                                                   data->in_num);
1255                 if (IS_ERR(group))
1256                         return PTR_ERR(group);
1257                 data->groups[groups++] = group;
1258         }
1259
1260         if (data->have_fan) {
1261                 group = nct6683_create_attr_group(dev,
1262                                                   &nct6683_fan_template_group,
1263                                                   fls(data->have_fan));
1264                 if (IS_ERR(group))
1265                         return PTR_ERR(group);
1266                 data->groups[groups++] = group;
1267         }
1268
1269         if (data->temp_num) {
1270                 group = nct6683_create_attr_group(dev,
1271                                                   &nct6683_temp_template_group,
1272                                                   data->temp_num);
1273                 if (IS_ERR(group))
1274                         return PTR_ERR(group);
1275                 data->groups[groups++] = group;
1276         }
1277         data->groups[groups++] = &nct6683_group_other;
1278
1279         if (data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
1280                 scnprintf(build, sizeof(build), "%02x/%02x/%02x",
1281                           nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1282                           nct6683_read(data, NCT6683_REG_BUILD_DAY),
1283                           nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1284         else
1285                 scnprintf(build, sizeof(build), "%02d/%02d/%02d",
1286                           nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1287                           nct6683_read(data, NCT6683_REG_BUILD_DAY),
1288                           nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1289
1290         dev_info(dev, "%s EC firmware version %d.%d build %s\n",
1291                  nct6683_chip_names[data->kind],
1292                  nct6683_read(data, NCT6683_REG_VERSION_HI),
1293                  nct6683_read(data, NCT6683_REG_VERSION_LO),
1294                  build);
1295
1296         hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1297                         nct6683_device_names[data->kind], data, data->groups);
1298         return PTR_ERR_OR_ZERO(hwmon_dev);
1299 }
1300
1301 #ifdef CONFIG_PM
1302 static int nct6683_suspend(struct device *dev)
1303 {
1304         struct nct6683_data *data = nct6683_update_device(dev);
1305
1306         mutex_lock(&data->update_lock);
1307         data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1308         mutex_unlock(&data->update_lock);
1309
1310         return 0;
1311 }
1312
1313 static int nct6683_resume(struct device *dev)
1314 {
1315         struct nct6683_data *data = dev_get_drvdata(dev);
1316
1317         mutex_lock(&data->update_lock);
1318
1319         nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1320
1321         /* Force re-reading all values */
1322         data->valid = false;
1323         mutex_unlock(&data->update_lock);
1324
1325         return 0;
1326 }
1327
1328 static const struct dev_pm_ops nct6683_dev_pm_ops = {
1329         .suspend = nct6683_suspend,
1330         .resume = nct6683_resume,
1331         .freeze = nct6683_suspend,
1332         .restore = nct6683_resume,
1333 };
1334
1335 #define NCT6683_DEV_PM_OPS      (&nct6683_dev_pm_ops)
1336 #else
1337 #define NCT6683_DEV_PM_OPS      NULL
1338 #endif /* CONFIG_PM */
1339
1340 static struct platform_driver nct6683_driver = {
1341         .driver = {
1342                 .name   = DRVNAME,
1343                 .pm     = NCT6683_DEV_PM_OPS,
1344         },
1345         .probe          = nct6683_probe,
1346 };
1347
1348 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1349 {
1350         int addr;
1351         u16 val;
1352         int err;
1353
1354         err = superio_enter(sioaddr);
1355         if (err)
1356                 return err;
1357
1358         val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1359                | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1360
1361         switch (val & SIO_ID_MASK) {
1362         case SIO_NCT6683_ID:
1363                 sio_data->kind = nct6683;
1364                 break;
1365         case SIO_NCT6687_ID:
1366                 sio_data->kind = nct6687;
1367                 break;
1368         default:
1369                 if (val != 0xffff)
1370                         pr_debug("unsupported chip ID: 0x%04x\n", val);
1371                 goto fail;
1372         }
1373
1374         /* We have a known chip, find the HWM I/O address */
1375         superio_select(sioaddr, NCT6683_LD_HWM);
1376         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1377             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1378         addr = val & IOREGION_ALIGNMENT;
1379         if (addr == 0) {
1380                 pr_err("EC base I/O port unconfigured\n");
1381                 goto fail;
1382         }
1383
1384         /* Activate logical device if needed */
1385         val = superio_inb(sioaddr, SIO_REG_ENABLE);
1386         if (!(val & 0x01)) {
1387                 pr_warn("Forcibly enabling EC access. Data may be unusable.\n");
1388                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1389         }
1390
1391         superio_exit(sioaddr);
1392         pr_info("Found %s or compatible chip at %#x:%#x\n",
1393                 nct6683_chip_names[sio_data->kind], sioaddr, addr);
1394         sio_data->sioreg = sioaddr;
1395
1396         return addr;
1397
1398 fail:
1399         superio_exit(sioaddr);
1400         return -ENODEV;
1401 }
1402
1403 /*
1404  * when Super-I/O functions move to a separate file, the Super-I/O
1405  * bus will manage the lifetime of the device and this module will only keep
1406  * track of the nct6683 driver. But since we use platform_device_alloc(), we
1407  * must keep track of the device
1408  */
1409 static struct platform_device *pdev[2];
1410
1411 static int __init sensors_nct6683_init(void)
1412 {
1413         struct nct6683_sio_data sio_data;
1414         int sioaddr[2] = { 0x2e, 0x4e };
1415         struct resource res;
1416         bool found = false;
1417         int address;
1418         int i, err;
1419
1420         err = platform_driver_register(&nct6683_driver);
1421         if (err)
1422                 return err;
1423
1424         /*
1425          * initialize sio_data->kind and sio_data->sioreg.
1426          *
1427          * when Super-I/O functions move to a separate file, the Super-I/O
1428          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1429          * nct6683 hardware monitor, and call probe()
1430          */
1431         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1432                 address = nct6683_find(sioaddr[i], &sio_data);
1433                 if (address <= 0)
1434                         continue;
1435
1436                 found = true;
1437
1438                 pdev[i] = platform_device_alloc(DRVNAME, address);
1439                 if (!pdev[i]) {
1440                         err = -ENOMEM;
1441                         goto exit_device_unregister;
1442                 }
1443
1444                 err = platform_device_add_data(pdev[i], &sio_data,
1445                                                sizeof(struct nct6683_sio_data));
1446                 if (err)
1447                         goto exit_device_put;
1448
1449                 memset(&res, 0, sizeof(res));
1450                 res.name = DRVNAME;
1451                 res.start = address + IOREGION_OFFSET;
1452                 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1453                 res.flags = IORESOURCE_IO;
1454
1455                 err = acpi_check_resource_conflict(&res);
1456                 if (err) {
1457                         platform_device_put(pdev[i]);
1458                         pdev[i] = NULL;
1459                         continue;
1460                 }
1461
1462                 err = platform_device_add_resources(pdev[i], &res, 1);
1463                 if (err)
1464                         goto exit_device_put;
1465
1466                 /* platform_device_add calls probe() */
1467                 err = platform_device_add(pdev[i]);
1468                 if (err)
1469                         goto exit_device_put;
1470         }
1471         if (!found) {
1472                 err = -ENODEV;
1473                 goto exit_unregister;
1474         }
1475
1476         return 0;
1477
1478 exit_device_put:
1479         platform_device_put(pdev[i]);
1480 exit_device_unregister:
1481         while (--i >= 0) {
1482                 if (pdev[i])
1483                         platform_device_unregister(pdev[i]);
1484         }
1485 exit_unregister:
1486         platform_driver_unregister(&nct6683_driver);
1487         return err;
1488 }
1489
1490 static void __exit sensors_nct6683_exit(void)
1491 {
1492         int i;
1493
1494         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1495                 if (pdev[i])
1496                         platform_device_unregister(pdev[i]);
1497         }
1498         platform_driver_unregister(&nct6683_driver);
1499 }
1500
1501 MODULE_AUTHOR("Guenter Roeck <[email protected]>");
1502 MODULE_DESCRIPTION("NCT6683D driver");
1503 MODULE_LICENSE("GPL");
1504
1505 module_init(sensors_nct6683_init);
1506 module_exit(sensors_nct6683_exit);