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/dmi.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 detection on non-Intel boards");
  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
 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_CUSTOMER_ID         0x602
 169 #define NCT6683_CUSTOMER_ID_INTEL       0x805
 170
 171 #define NCT6683_REG_BUILD_YEAR          0x604
 172 #define NCT6683_REG_BUILD_MONTH         0x605
 173 #define NCT6683_REG_BUILD_DAY           0x606
 174 #define NCT6683_REG_SERIAL              0x607
 175 #define NCT6683_REG_VERSION_HI          0x608
 176 #define NCT6683_REG_VERSION_LO          0x609
 177
 178 #define NCT6683_REG_CR_CASEOPEN         0xe8
 179 #define NCT6683_CR_CASEOPEN_MASK        (1 << 7)
 180
 181 #define NCT6683_REG_CR_BEEP             0xe0
 182 #define NCT6683_CR_BEEP_MASK            (1 << 6)
 183
 184 static const char *const nct6683_mon_label[] = {
 185         NULL,   /* disabled */
 186         "Local",
 187         "Diode 0 (curr)",
 188         "Diode 1 (curr)",
 189         "Diode 2 (curr)",
 190         "Diode 0 (volt)",
 191         "Diode 1 (volt)",
 192         "Diode 2 (volt)",
 193         "Thermistor 14",
 194         "Thermistor 15",
 195         "Thermistor 16",
 196         "Thermistor 0",
 197         "Thermistor 1",
 198         "Thermistor 2",
 199         "Thermistor 3",
 200         "Thermistor 4",
 201         "Thermistor 5",         /* 0x10 */
 202         "Thermistor 6",
 203         "Thermistor 7",
 204         "Thermistor 8",
 205         "Thermistor 9",
 206         "Thermistor 10",
 207         "Thermistor 11",
 208         "Thermistor 12",
 209         "Thermistor 13",
 210         NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 211         "PECI 0.0",             /* 0x20 */
 212         "PECI 1.0",
 213         "PECI 2.0",
 214         "PECI 3.0",
 215         "PECI 0.1",
 216         "PECI 1.1",
 217         "PECI 2.1",
 218         "PECI 3.1",
 219         "PECI DIMM 0",
 220         "PECI DIMM 1",
 221         "PECI DIMM 2",
 222         "PECI DIMM 3",
 223         NULL, NULL, NULL, NULL,
 224         "PCH CPU",              /* 0x30 */
 225         "PCH CHIP",
 226         "PCH CHIP CPU MAX",
 227         "PCH MCH",
 228         "PCH DIMM 0",
 229         "PCH DIMM 1",
 230         "PCH DIMM 2",
 231         "PCH DIMM 3",
 232         "SMBus 0",
 233         "SMBus 1",
 234         "SMBus 2",
 235         "SMBus 3",
 236         "SMBus 4",
 237         "SMBus 5",
 238         "DIMM 0",
 239         "DIMM 1",
 240         "DIMM 2",               /* 0x40 */
 241         "DIMM 3",
 242         "AMD TSI Addr 90h",
 243         "AMD TSI Addr 92h",
 244         "AMD TSI Addr 94h",
 245         "AMD TSI Addr 96h",
 246         "AMD TSI Addr 98h",
 247         "AMD TSI Addr 9ah",
 248         "AMD TSI Addr 9ch",
 249         "AMD TSI Addr 9dh",
 250         NULL, NULL, NULL, NULL, NULL, NULL,
 251         "Virtual 0",            /* 0x50 */
 252         "Virtual 1",
 253         "Virtual 2",
 254         "Virtual 3",
 255         "Virtual 4",
 256         "Virtual 5",
 257         "Virtual 6",
 258         "Virtual 7",
 259         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 260         "VCC",                  /* 0x60 voltage sensors */
 261         "VSB",
 262         "AVSB",
 263         "VTT",
 264         "VBAT",
 265         "VREF",
 266         "VIN0",
 267         "VIN1",
 268         "VIN2",
 269         "VIN3",
 270         "VIN4",
 271         "VIN5",
 272         "VIN6",
 273         "VIN7",
 274         "VIN8",
 275         "VIN9",
 276         "VIN10",
 277         "VIN11",
 278         "VIN12",
 279         "VIN13",
 280         "VIN14",
 281         "VIN15",
 282         "VIN16",
 283 };
 284
 285 #define NUM_MON_LABELS          ARRAY_SIZE(nct6683_mon_label)
 286 #define MON_VOLTAGE_START       0x60
 287
 288 /* ------------------------------------------------------- */
 289
 290 struct nct6683_data {
 291         int addr;               /* IO base of EC space */
 292         int sioreg;             /* SIO register */
 293         enum kinds kind;
 294         u16 customer_id;
 295
 296         struct device *hwmon_dev;
 297         const struct attribute_group *groups[6];
 298
 299         int temp_num;                   /* number of temperature attributes */
 300         u8 temp_index[NCT6683_NUM_REG_MON];
 301         u8 temp_src[NCT6683_NUM_REG_MON];
 302
 303         u8 in_num;                      /* number of voltage attributes */
 304         u8 in_index[NCT6683_NUM_REG_MON];
 305         u8 in_src[NCT6683_NUM_REG_MON];
 306
 307         struct mutex update_lock;       /* used to protect sensor updates */
 308         bool valid;                     /* true if following fields are valid */
 309         unsigned long last_updated;     /* In jiffies */
 310
 311         /* Voltage attribute values */
 312         u8 in[3][NCT6683_NUM_REG_MON];  /* [0]=in, [1]=in_max, [2]=in_min */
 313
 314         /* Temperature attribute values */
 315         s16 temp_in[NCT6683_NUM_REG_MON];
 316         s8 temp[4][NCT6683_NUM_REG_MON];/* [0]=min, [1]=max, [2]=hyst,
 317                                          * [3]=crit
 318                                          */
 319
 320         /* Fan attribute values */
 321         unsigned int rpm[NCT6683_NUM_REG_FAN];
 322         u16 fan_min[NCT6683_NUM_REG_FAN];
 323         u8 fanin_cfg[NCT6683_NUM_REG_FAN];
 324         u8 fanout_cfg[NCT6683_NUM_REG_FAN];
 325         u16 have_fan;                   /* some fan inputs can be disabled */
 326
 327         u8 have_pwm;
 328         u8 pwm[NCT6683_NUM_REG_PWM];
 329
 330 #ifdef CONFIG_PM
 331         /* Remember extra register values over suspend/resume */
 332         u8 hwm_cfg;
 333 #endif
 334 };
 335
 336 struct nct6683_sio_data {
 337         int sioreg;
 338         enum kinds kind;
 339 };
 340
 341 struct sensor_device_template {
 342         struct device_attribute dev_attr;
 343         union {
 344                 struct {
 345                         u8 nr;
 346                         u8 index;
 347                 } s;
 348                 int index;
 349         } u;
 350         bool s2;        /* true if both index and nr are used */
 351 };
 352
 353 struct sensor_device_attr_u {
 354         union {
 355                 struct sensor_device_attribute a1;
 356                 struct sensor_device_attribute_2 a2;
 357         } u;
 358         char name[32];
 359 };
 360
 361 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) {      \
 362         .attr = {.name = _template, .mode = _mode },            \
 363         .show   = _show,                                        \
 364         .store  = _store,                                       \
 365 }
 366
 367 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
 368         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
 369           .u.index = _index,                                            \
 370           .s2 = false }
 371
 372 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,       \
 373                                  _nr, _index)                           \
 374         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
 375           .u.s.index = _index,                                          \
 376           .u.s.nr = _nr,                                                \
 377           .s2 = true }
 378
 379 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \
 380 static struct sensor_device_template sensor_dev_template_##_name        \
 381         = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store,       \
 382                                  _index)
 383
 384 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store,       \
 385                           _nr, _index)                                  \
 386 static struct sensor_device_template sensor_dev_template_##_name        \
 387         = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,     \
 388                                  _nr, _index)
 389
 390 struct sensor_template_group {
 391         struct sensor_device_template **templates;
 392         umode_t (*is_visible)(struct kobject *, struct attribute *, int);
 393         int base;
 394 };
 395
 396 static struct attribute_group *
 397 nct6683_create_attr_group(struct device *dev, struct sensor_template_group *tg,
 398                           int repeat)
 399 {
 400         struct sensor_device_attribute_2 *a2;
 401         struct sensor_device_attribute *a;
 402         struct sensor_device_template **t;
 403         struct sensor_device_attr_u *su;
 404         struct attribute_group *group;
 405         struct attribute **attrs;
 406         int i, j, count;
 407
 408         if (repeat <= 0)
 409                 return ERR_PTR(-EINVAL);
 410
 411         t = tg->templates;
 412         for (count = 0; *t; t++, count++)
 413                 ;
 414
 415         if (count == 0)
 416                 return ERR_PTR(-EINVAL);
 417
 418         group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
 419         if (group == NULL)
 420                 return ERR_PTR(-ENOMEM);
 421
 422         attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1),
 423                              GFP_KERNEL);
 424         if (attrs == NULL)
 425                 return ERR_PTR(-ENOMEM);
 426
 427         su = devm_kzalloc(dev, sizeof(*su) * repeat * count,
 428                           GFP_KERNEL);
 429         if (su == NULL)
 430                 return ERR_PTR(-ENOMEM);
 431
 432         group->attrs = attrs;
 433         group->is_visible = tg->is_visible;
 434
 435         for (i = 0; i < repeat; i++) {
 436                 t = tg->templates;
 437                 for (j = 0; *t != NULL; j++) {
 438                         snprintf(su->name, sizeof(su->name),
 439                                  (*t)->dev_attr.attr.name, tg->base + i);
 440                         if ((*t)->s2) {
 441                                 a2 = &su->u.a2;
 442                                 sysfs_attr_init(&a2->dev_attr.attr);
 443                                 a2->dev_attr.attr.name = su->name;
 444                                 a2->nr = (*t)->u.s.nr + i;
 445                                 a2->index = (*t)->u.s.index;
 446                                 a2->dev_attr.attr.mode =
 447                                   (*t)->dev_attr.attr.mode;
 448                                 a2->dev_attr.show = (*t)->dev_attr.show;
 449                                 a2->dev_attr.store = (*t)->dev_attr.store;
 450                                 *attrs = &a2->dev_attr.attr;
 451                         } else {
 452                                 a = &su->u.a1;
 453                                 sysfs_attr_init(&a->dev_attr.attr);
 454                                 a->dev_attr.attr.name = su->name;
 455                                 a->index = (*t)->u.index + i;
 456                                 a->dev_attr.attr.mode =
 457                                   (*t)->dev_attr.attr.mode;
 458                                 a->dev_attr.show = (*t)->dev_attr.show;
 459                                 a->dev_attr.store = (*t)->dev_attr.store;
 460                                 *attrs = &a->dev_attr.attr;
 461                         }
 462                         attrs++;
 463                         su++;
 464                         t++;
 465                 }
 466         }
 467
 468         return group;
 469 }
 470
 471 /* LSB is 16 mV, except for the following sources, where it is 32 mV */
 472 #define MON_SRC_VCC     0x60
 473 #define MON_SRC_VSB     0x61
 474 #define MON_SRC_AVSB    0x62
 475 #define MON_SRC_VBAT    0x64
 476
 477 static inline long in_from_reg(u16 reg, u8 src)
 478 {
 479         int scale = 16;
 480
 481         if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
 482             src == MON_SRC_VBAT)
 483                 scale <<= 1;
 484         return reg * scale;
 485 }
 486
 487 static inline u16 in_to_reg(u32 val, 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
 495         return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127);
 496 }
 497
 498 static u16 nct6683_read(struct nct6683_data *data, u16 reg)
 499 {
 500         int res;
 501
 502         outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 503         outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 504         outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 505         res = inb_p(data->addr + EC_DATA_REG);
 506         return res;
 507 }
 508
 509 static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
 510 {
 511         return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
 512 }
 513
 514 static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
 515 {
 516         outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 517         outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 518         outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 519         outb_p(value & 0xff, data->addr + EC_DATA_REG);
 520 }
 521
 522 static int get_in_reg(struct nct6683_data *data, int nr, int index)
 523 {
 524         int ch = data->in_index[index];
 525         int reg = -EINVAL;
 526
 527         switch (nr) {
 528         case 0:
 529                 reg = NCT6683_REG_MON(ch);
 530                 break;
 531         case 1:
 532                 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 533                         reg = NCT6683_REG_MON_LOW(ch);
 534                 break;
 535         case 2:
 536                 if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 537                         reg = NCT6683_REG_MON_HIGH(ch);
 538                 break;
 539         default:
 540                 break;
 541         }
 542         return reg;
 543 }
 544
 545 static int get_temp_reg(struct nct6683_data *data, int nr, int index)
 546 {
 547         int ch = data->temp_index[index];
 548         int reg = -EINVAL;
 549
 550         switch (data->customer_id) {
 551         case NCT6683_CUSTOMER_ID_INTEL:
 552                 switch (nr) {
 553                 default:
 554                 case 1: /* max */
 555                         reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
 556                         break;
 557                 case 3: /* crit */
 558                         reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
 559                         break;
 560                 }
 561                 break;
 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 = container_of(kobj, struct device, 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 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 = container_of(kobj, struct device, 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 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 = container_of(kobj, struct device, 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 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 SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, NULL, 0);
 922
 923 static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
 924                                       struct attribute *attr, int index)
 925 {
 926         struct device *dev = container_of(kobj, struct device, kobj);
 927         struct nct6683_data *data = dev_get_drvdata(dev);
 928         int pwm = index;        /* pwm index */
 929
 930         if (!(data->have_pwm & (1 << pwm)))
 931                 return 0;
 932
 933         return attr->mode;
 934 }
 935
 936 static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
 937         &sensor_dev_template_pwm,
 938         NULL
 939 };
 940
 941 static struct sensor_template_group nct6683_pwm_template_group = {
 942         .templates = nct6683_attributes_pwm_template,
 943         .is_visible = nct6683_pwm_is_visible,
 944         .base = 1,
 945 };
 946
 947 static ssize_t
 948 show_global_beep(struct device *dev, struct device_attribute *attr, char *buf)
 949 {
 950         struct nct6683_data *data = dev_get_drvdata(dev);
 951         int ret;
 952         u8 reg;
 953
 954         mutex_lock(&data->update_lock);
 955
 956         ret = superio_enter(data->sioreg);
 957         if (ret)
 958                 goto error;
 959         superio_select(data->sioreg, NCT6683_LD_HWM);
 960         reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
 961         superio_exit(data->sioreg);
 962
 963         mutex_unlock(&data->update_lock);
 964
 965         return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
 966
 967 error:
 968         mutex_unlock(&data->update_lock);
 969         return ret;
 970 }
 971
 972 static ssize_t
 973 store_global_beep(struct device *dev, struct device_attribute *attr,
 974                   const char *buf, size_t count)
 975 {
 976         struct nct6683_data *data = dev_get_drvdata(dev);
 977         unsigned long val;
 978         u8 reg;
 979         int ret;
 980
 981         if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
 982                 return -EINVAL;
 983
 984         mutex_lock(&data->update_lock);
 985
 986         ret = superio_enter(data->sioreg);
 987         if (ret) {
 988                 count = ret;
 989                 goto error;
 990         }
 991
 992         superio_select(data->sioreg, NCT6683_LD_HWM);
 993         reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
 994         if (val)
 995                 reg |= NCT6683_CR_BEEP_MASK;
 996         else
 997                 reg &= ~NCT6683_CR_BEEP_MASK;
 998         superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
 999         superio_exit(data->sioreg);
1000 error:
1001         mutex_unlock(&data->update_lock);
1002         return count;
1003 }
1004
1005 /* Case open detection */
1006
1007 static ssize_t
1008 show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
1009 {
1010         struct nct6683_data *data = dev_get_drvdata(dev);
1011         int ret;
1012         u8 reg;
1013
1014         mutex_lock(&data->update_lock);
1015
1016         ret = superio_enter(data->sioreg);
1017         if (ret)
1018                 goto error;
1019         superio_select(data->sioreg, NCT6683_LD_ACPI);
1020         reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1021         superio_exit(data->sioreg);
1022
1023         mutex_unlock(&data->update_lock);
1024
1025         return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1026
1027 error:
1028         mutex_unlock(&data->update_lock);
1029         return ret;
1030 }
1031
1032 static ssize_t
1033 clear_caseopen(struct device *dev, struct device_attribute *attr,
1034                const char *buf, size_t count)
1035 {
1036         struct nct6683_data *data = dev_get_drvdata(dev);
1037         unsigned long val;
1038         u8 reg;
1039         int ret;
1040
1041         if (kstrtoul(buf, 10, &val) || val != 0)
1042                 return -EINVAL;
1043
1044         mutex_lock(&data->update_lock);
1045
1046         /*
1047          * Use CR registers to clear caseopen status.
1048          * Caseopen is activ low, clear by writing 1 into the register.
1049          */
1050
1051         ret = superio_enter(data->sioreg);
1052         if (ret) {
1053                 count = ret;
1054                 goto error;
1055         }
1056
1057         superio_select(data->sioreg, NCT6683_LD_ACPI);
1058         reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1059         reg |= NCT6683_CR_CASEOPEN_MASK;
1060         superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1061         reg &= ~NCT6683_CR_CASEOPEN_MASK;
1062         superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1063         superio_exit(data->sioreg);
1064
1065         data->valid = false;    /* Force cache refresh */
1066 error:
1067         mutex_unlock(&data->update_lock);
1068         return count;
1069 }
1070
1071 static DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
1072                    clear_caseopen);
1073 static DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_global_beep,
1074                    store_global_beep);
1075
1076 static struct attribute *nct6683_attributes_other[] = {
1077         &dev_attr_intrusion0_alarm.attr,
1078         &dev_attr_beep_enable.attr,
1079         NULL
1080 };
1081
1082 static const struct attribute_group nct6683_group_other = {
1083         .attrs = nct6683_attributes_other,
1084 };
1085
1086 /* Get the monitoring functions started */
1087 static inline void nct6683_init_device(struct nct6683_data *data)
1088 {
1089         u8 tmp;
1090
1091         /* Start hardware monitoring if needed */
1092         tmp = nct6683_read(data, NCT6683_HWM_CFG);
1093         if (!(tmp & 0x80))
1094                 nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1095 }
1096
1097 /*
1098  * There are a total of 24 fan inputs. Each can be configured as input
1099  * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1100  */
1101 static void
1102 nct6683_setup_fans(struct nct6683_data *data)
1103 {
1104         int i;
1105         u8 reg;
1106
1107         for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1108                 reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1109                 if (reg & 0x80)
1110                         data->have_fan |= 1 << i;
1111                 data->fanin_cfg[i] = reg;
1112         }
1113         for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1114                 reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1115                 if (reg & 0x80)
1116                         data->have_pwm |= 1 << i;
1117                 data->fanout_cfg[i] = reg;
1118         }
1119 }
1120
1121 /*
1122  * Translation from monitoring register to temperature and voltage attributes
1123  * ==========================================================================
1124  *
1125  * There are a total of 32 monitoring registers. Each can be assigned to either
1126  * a temperature or voltage monitoring source.
1127  * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1128  *
1129  * Temperature and voltage attribute mapping is determined by walking through
1130  * the NCT6683_REG_MON_CFG registers. If the assigned source is
1131  * a temperature, temp_index[n] is set to the monitor register index, and
1132  * temp_src[n] is set to the temperature source. If the assigned source is
1133  * a voltage, the respective values are stored in in_index[] and in_src[],
1134  * respectively.
1135  */
1136
1137 static void nct6683_setup_sensors(struct nct6683_data *data)
1138 {
1139         u8 reg;
1140         int i;
1141
1142         data->temp_num = 0;
1143         data->in_num = 0;
1144         for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1145                 reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1146                 /* Ignore invalid assignments */
1147                 if (reg >= NUM_MON_LABELS)
1148                         continue;
1149                 /* Skip if disabled or reserved */
1150                 if (nct6683_mon_label[reg] == NULL)
1151                         continue;
1152                 if (reg < MON_VOLTAGE_START) {
1153                         data->temp_index[data->temp_num] = i;
1154                         data->temp_src[data->temp_num] = reg;
1155                         data->temp_num++;
1156                 } else {
1157                         data->in_index[data->in_num] = i;
1158                         data->in_src[data->in_num] = reg;
1159                         data->in_num++;
1160                 }
1161         }
1162 }
1163
1164 static int nct6683_probe(struct platform_device *pdev)
1165 {
1166         struct device *dev = &pdev->dev;
1167         struct nct6683_sio_data *sio_data = dev->platform_data;
1168         struct attribute_group *group;
1169         struct nct6683_data *data;
1170         struct device *hwmon_dev;
1171         struct resource *res;
1172         int groups = 0;
1173
1174         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1175         if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1176                 return -EBUSY;
1177
1178         data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1179         if (!data)
1180                 return -ENOMEM;
1181
1182         data->kind = sio_data->kind;
1183         data->sioreg = sio_data->sioreg;
1184         data->addr = res->start;
1185         mutex_init(&data->update_lock);
1186         platform_set_drvdata(pdev, data);
1187
1188         data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1189
1190         nct6683_init_device(data);
1191         nct6683_setup_fans(data);
1192         nct6683_setup_sensors(data);
1193
1194         /* Register sysfs hooks */
1195
1196         if (data->have_pwm) {
1197                 group = nct6683_create_attr_group(dev,
1198                                                   &nct6683_pwm_template_group,
1199                                                   fls(data->have_pwm));
1200                 if (IS_ERR(group))
1201                         return PTR_ERR(group);
1202                 data->groups[groups++] = group;
1203         }
1204
1205         if (data->in_num) {
1206                 group = nct6683_create_attr_group(dev,
1207                                                   &nct6683_in_template_group,
1208                                                   data->in_num);
1209                 if (IS_ERR(group))
1210                         return PTR_ERR(group);
1211                 data->groups[groups++] = group;
1212         }
1213
1214         if (data->have_fan) {
1215                 group = nct6683_create_attr_group(dev,
1216                                                   &nct6683_fan_template_group,
1217                                                   fls(data->have_fan));
1218                 if (IS_ERR(group))
1219                         return PTR_ERR(group);
1220                 data->groups[groups++] = group;
1221         }
1222
1223         if (data->temp_num) {
1224                 group = nct6683_create_attr_group(dev,
1225                                                   &nct6683_temp_template_group,
1226                                                   data->temp_num);
1227                 if (IS_ERR(group))
1228                         return PTR_ERR(group);
1229                 data->groups[groups++] = group;
1230         }
1231         data->groups[groups++] = &nct6683_group_other;
1232
1233         dev_info(dev, "%s EC firmware version %d.%d build %02x/%02x/%02x\n",
1234                  nct6683_chip_names[data->kind],
1235                  nct6683_read(data, NCT6683_REG_VERSION_HI),
1236                  nct6683_read(data, NCT6683_REG_VERSION_LO),
1237                  nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1238                  nct6683_read(data, NCT6683_REG_BUILD_DAY),
1239                  nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1240
1241         hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1242                         nct6683_device_names[data->kind], data, data->groups);
1243         return PTR_ERR_OR_ZERO(hwmon_dev);
1244 }
1245
1246 #ifdef CONFIG_PM
1247 static int nct6683_suspend(struct device *dev)
1248 {
1249         struct nct6683_data *data = nct6683_update_device(dev);
1250
1251         mutex_lock(&data->update_lock);
1252         data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1253         mutex_unlock(&data->update_lock);
1254
1255         return 0;
1256 }
1257
1258 static int nct6683_resume(struct device *dev)
1259 {
1260         struct nct6683_data *data = dev_get_drvdata(dev);
1261
1262         mutex_lock(&data->update_lock);
1263
1264         nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1265
1266         /* Force re-reading all values */
1267         data->valid = false;
1268         mutex_unlock(&data->update_lock);
1269
1270         return 0;
1271 }
1272
1273 static const struct dev_pm_ops nct6683_dev_pm_ops = {
1274         .suspend = nct6683_suspend,
1275         .resume = nct6683_resume,
1276         .freeze = nct6683_suspend,
1277         .restore = nct6683_resume,
1278 };
1279
1280 #define NCT6683_DEV_PM_OPS      (&nct6683_dev_pm_ops)
1281 #else
1282 #define NCT6683_DEV_PM_OPS      NULL
1283 #endif /* CONFIG_PM */
1284
1285 static struct platform_driver nct6683_driver = {
1286         .driver = {
1287                 .name   = DRVNAME,
1288                 .pm     = NCT6683_DEV_PM_OPS,
1289         },
1290         .probe          = nct6683_probe,
1291 };
1292
1293 static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1294 {
1295         const char *board_vendor;
1296         int addr;
1297         u16 val;
1298         int err;
1299
1300         /*
1301          * Only run on Intel boards unless the 'force' module parameter is set
1302          */
1303         if (!force) {
1304                 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1305                 if (!board_vendor || strcmp(board_vendor, "Intel Corporation"))
1306                         return -ENODEV;
1307         }
1308
1309         err = superio_enter(sioaddr);
1310         if (err)
1311                 return err;
1312
1313         val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1314                | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1315
1316         switch (val & SIO_ID_MASK) {
1317         case SIO_NCT6683_ID:
1318                 sio_data->kind = nct6683;
1319                 break;
1320         default:
1321                 if (val != 0xffff)
1322                         pr_debug("unsupported chip ID: 0x%04x\n", val);
1323                 goto fail;
1324         }
1325
1326         /* We have a known chip, find the HWM I/O address */
1327         superio_select(sioaddr, NCT6683_LD_HWM);
1328         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1329             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1330         addr = val & IOREGION_ALIGNMENT;
1331         if (addr == 0) {
1332                 pr_err("EC base I/O port unconfigured\n");
1333                 goto fail;
1334         }
1335
1336         /* Activate logical device if needed */
1337         val = superio_inb(sioaddr, SIO_REG_ENABLE);
1338         if (!(val & 0x01)) {
1339                 pr_err("EC is disabled\n");
1340                 goto fail;
1341         }
1342
1343         superio_exit(sioaddr);
1344         pr_info("Found %s or compatible chip at %#x:%#x\n",
1345                 nct6683_chip_names[sio_data->kind], sioaddr, addr);
1346         sio_data->sioreg = sioaddr;
1347
1348         return addr;
1349
1350 fail:
1351         superio_exit(sioaddr);
1352         return -ENODEV;
1353 }
1354
1355 /*
1356  * when Super-I/O functions move to a separate file, the Super-I/O
1357  * bus will manage the lifetime of the device and this module will only keep
1358  * track of the nct6683 driver. But since we use platform_device_alloc(), we
1359  * must keep track of the device
1360  */
1361 static struct platform_device *pdev[2];
1362
1363 static int __init sensors_nct6683_init(void)
1364 {
1365         struct nct6683_sio_data sio_data;
1366         int sioaddr[2] = { 0x2e, 0x4e };
1367         struct resource res;
1368         bool found = false;
1369         int address;
1370         int i, err;
1371
1372         err = platform_driver_register(&nct6683_driver);
1373         if (err)
1374                 return err;
1375
1376         /*
1377          * initialize sio_data->kind and sio_data->sioreg.
1378          *
1379          * when Super-I/O functions move to a separate file, the Super-I/O
1380          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1381          * nct6683 hardware monitor, and call probe()
1382          */
1383         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1384                 address = nct6683_find(sioaddr[i], &sio_data);
1385                 if (address <= 0)
1386                         continue;
1387
1388                 found = true;
1389
1390                 pdev[i] = platform_device_alloc(DRVNAME, address);
1391                 if (!pdev[i]) {
1392                         err = -ENOMEM;
1393                         goto exit_device_unregister;
1394                 }
1395
1396                 err = platform_device_add_data(pdev[i], &sio_data,
1397                                                sizeof(struct nct6683_sio_data));
1398                 if (err)
1399                         goto exit_device_put;
1400
1401                 memset(&res, 0, sizeof(res));
1402                 res.name = DRVNAME;
1403                 res.start = address + IOREGION_OFFSET;
1404                 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1405                 res.flags = IORESOURCE_IO;
1406
1407                 err = acpi_check_resource_conflict(&res);
1408                 if (err) {
1409                         platform_device_put(pdev[i]);
1410                         pdev[i] = NULL;
1411                         continue;
1412                 }
1413
1414                 err = platform_device_add_resources(pdev[i], &res, 1);
1415                 if (err)
1416                         goto exit_device_put;
1417
1418                 /* platform_device_add calls probe() */
1419                 err = platform_device_add(pdev[i]);
1420                 if (err)
1421                         goto exit_device_put;
1422         }
1423         if (!found) {
1424                 err = -ENODEV;
1425                 goto exit_unregister;
1426         }
1427
1428         return 0;
1429
1430 exit_device_put:
1431         platform_device_put(pdev[i]);
1432 exit_device_unregister:
1433         while (--i >= 0) {
1434                 if (pdev[i])
1435                         platform_device_unregister(pdev[i]);
1436         }
1437 exit_unregister:
1438         platform_driver_unregister(&nct6683_driver);
1439         return err;
1440 }
1441
1442 static void __exit sensors_nct6683_exit(void)
1443 {
1444         int i;
1445
1446         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1447                 if (pdev[i])
1448                         platform_device_unregister(pdev[i]);
1449         }
1450         platform_driver_unregister(&nct6683_driver);
1451 }
1452
1453 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1454 MODULE_DESCRIPTION("NCT6683D driver");
1455 MODULE_LICENSE("GPL");
1456
1457 module_init(sensors_nct6683_init);
1458 module_exit(sensors_nct6683_exit);