drivers/hwmon/nct6683.c

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