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