linux/drivers/hwmon/nct6683.c
<<
>>
Prefs
   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
  44enum kinds { nct6683 };
  45
  46static bool force;
  47module_param(force, bool, 0);
  48MODULE_PARM_DESC(force, "Set to one to enable detection on non-Intel boards");
  49
  50static const char * const nct6683_device_names[] = {
  51        "nct6683",
  52};
  53
  54static 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
  77static inline void
  78superio_outb(int ioreg, int reg, int val)
  79{
  80        outb(reg, ioreg);
  81        outb(val, ioreg + 1);
  82}
  83
  84static inline int
  85superio_inb(int ioreg, int reg)
  86{
  87        outb(reg, ioreg);
  88        return inb(ioreg + 1);
  89}
  90
  91static inline void
  92superio_select(int ioreg, int ld)
  93{
  94        outb(SIO_REG_LDSEL, ioreg);
  95        outb(ld, ioreg + 1);
  96}
  97
  98static inline int
  99superio_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
 113static inline void
 114superio_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
 184static 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
 290struct 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
 336struct nct6683_sio_data {
 337        int sioreg;
 338        enum kinds kind;
 339};
 340
 341struct 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
 353struct 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) \
 380static 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)                                  \
 386static struct sensor_device_template sensor_dev_template_##_name        \
 387        = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,     \
 388                                 _nr, _index)
 389
 390struct sensor_template_group {
 391        struct sensor_device_template **templates;
 392        umode_t (*is_visible)(struct kobject *, struct attribute *, int);
 393        int base;
 394};
 395
 396static struct attribute_group *
 397nct6683_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                                a2->dev_attr.attr.name = su->name;
 443                                a2->nr = (*t)->u.s.nr + i;
 444                                a2->index = (*t)->u.s.index;
 445                                a2->dev_attr.attr.mode =
 446                                  (*t)->dev_attr.attr.mode;
 447                                a2->dev_attr.show = (*t)->dev_attr.show;
 448                                a2->dev_attr.store = (*t)->dev_attr.store;
 449                                *attrs = &a2->dev_attr.attr;
 450                        } else {
 451                                a = &su->u.a1;
 452                                a->dev_attr.attr.name = su->name;
 453                                a->index = (*t)->u.index + i;
 454                                a->dev_attr.attr.mode =
 455                                  (*t)->dev_attr.attr.mode;
 456                                a->dev_attr.show = (*t)->dev_attr.show;
 457                                a->dev_attr.store = (*t)->dev_attr.store;
 458                                *attrs = &a->dev_attr.attr;
 459                        }
 460                        attrs++;
 461                        su++;
 462                        t++;
 463                }
 464        }
 465
 466        return group;
 467}
 468
 469/* LSB is 16 mV, except for the following sources, where it is 32 mV */
 470#define MON_SRC_VCC     0x60
 471#define MON_SRC_VSB     0x61
 472#define MON_SRC_AVSB    0x62
 473#define MON_SRC_VBAT    0x64
 474
 475static inline long in_from_reg(u16 reg, u8 src)
 476{
 477        int scale = 16;
 478
 479        if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
 480            src == MON_SRC_VBAT)
 481                scale <<= 1;
 482        return reg * scale;
 483}
 484
 485static inline u16 in_to_reg(u32 val, u8 src)
 486{
 487        int scale = 16;
 488
 489        if (src == MON_SRC_VCC || src == MON_SRC_VSB || src == MON_SRC_AVSB ||
 490            src == MON_SRC_VBAT)
 491                scale <<= 1;
 492
 493        return clamp_val(DIV_ROUND_CLOSEST(val, scale), 0, 127);
 494}
 495
 496static u16 nct6683_read(struct nct6683_data *data, u16 reg)
 497{
 498        int res;
 499
 500        outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 501        outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 502        outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 503        res = inb_p(data->addr + EC_DATA_REG);
 504        return res;
 505}
 506
 507static u16 nct6683_read16(struct nct6683_data *data, u16 reg)
 508{
 509        return (nct6683_read(data, reg) << 8) | nct6683_read(data, reg + 1);
 510}
 511
 512static void nct6683_write(struct nct6683_data *data, u16 reg, u16 value)
 513{
 514        outb_p(0xff, data->addr + EC_PAGE_REG);         /* unlock */
 515        outb_p(reg >> 8, data->addr + EC_PAGE_REG);
 516        outb_p(reg & 0xff, data->addr + EC_INDEX_REG);
 517        outb_p(value & 0xff, data->addr + EC_DATA_REG);
 518}
 519
 520static int get_in_reg(struct nct6683_data *data, int nr, int index)
 521{
 522        int ch = data->in_index[index];
 523        int reg = -EINVAL;
 524
 525        switch (nr) {
 526        case 0:
 527                reg = NCT6683_REG_MON(ch);
 528                break;
 529        case 1:
 530                if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 531                        reg = NCT6683_REG_MON_LOW(ch);
 532                break;
 533        case 2:
 534                if (data->customer_id != NCT6683_CUSTOMER_ID_INTEL)
 535                        reg = NCT6683_REG_MON_HIGH(ch);
 536                break;
 537        default:
 538                break;
 539        }
 540        return reg;
 541}
 542
 543static int get_temp_reg(struct nct6683_data *data, int nr, int index)
 544{
 545        int ch = data->temp_index[index];
 546        int reg = -EINVAL;
 547
 548        switch (data->customer_id) {
 549        case NCT6683_CUSTOMER_ID_INTEL:
 550                switch (nr) {
 551                default:
 552                case 1: /* max */
 553                        reg = NCT6683_REG_INTEL_TEMP_MAX(ch);
 554                        break;
 555                case 3: /* crit */
 556                        reg = NCT6683_REG_INTEL_TEMP_CRIT(ch);
 557                        break;
 558                }
 559                break;
 560        default:
 561                switch (nr) {
 562                default:
 563                case 0: /* min */
 564                        reg = NCT6683_REG_MON_LOW(ch);
 565                        break;
 566                case 1: /* max */
 567                        reg = NCT6683_REG_TEMP_MAX(ch);
 568                        break;
 569                case 2: /* hyst */
 570                        reg = NCT6683_REG_TEMP_HYST(ch);
 571                        break;
 572                case 3: /* crit */
 573                        reg = NCT6683_REG_MON_HIGH(ch);
 574                        break;
 575                }
 576                break;
 577        }
 578        return reg;
 579}
 580
 581static void nct6683_update_pwm(struct device *dev)
 582{
 583        struct nct6683_data *data = dev_get_drvdata(dev);
 584        int i;
 585
 586        for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
 587                if (!(data->have_pwm & (1 << i)))
 588                        continue;
 589                data->pwm[i] = nct6683_read(data, NCT6683_REG_PWM(i));
 590        }
 591}
 592
 593static struct nct6683_data *nct6683_update_device(struct device *dev)
 594{
 595        struct nct6683_data *data = dev_get_drvdata(dev);
 596        int i, j;
 597
 598        mutex_lock(&data->update_lock);
 599
 600        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 601                /* Measured voltages and limits */
 602                for (i = 0; i < data->in_num; i++) {
 603                        for (j = 0; j < 3; j++) {
 604                                int reg = get_in_reg(data, j, i);
 605
 606                                if (reg >= 0)
 607                                        data->in[j][i] =
 608                                                nct6683_read(data, reg);
 609                        }
 610                }
 611
 612                /* Measured temperatures and limits */
 613                for (i = 0; i < data->temp_num; i++) {
 614                        u8 ch = data->temp_index[i];
 615
 616                        data->temp_in[i] = nct6683_read16(data,
 617                                                          NCT6683_REG_MON(ch));
 618                        for (j = 0; j < 4; j++) {
 619                                int reg = get_temp_reg(data, j, i);
 620
 621                                if (reg >= 0)
 622                                        data->temp[j][i] =
 623                                                nct6683_read(data, reg);
 624                        }
 625                }
 626
 627                /* Measured fan speeds and limits */
 628                for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
 629                        if (!(data->have_fan & (1 << i)))
 630                                continue;
 631
 632                        data->rpm[i] = nct6683_read16(data,
 633                                                NCT6683_REG_FAN_RPM(i));
 634                        data->fan_min[i] = nct6683_read16(data,
 635                                                NCT6683_REG_FAN_MIN(i));
 636                }
 637
 638                nct6683_update_pwm(dev);
 639
 640                data->last_updated = jiffies;
 641                data->valid = true;
 642        }
 643
 644        mutex_unlock(&data->update_lock);
 645        return data;
 646}
 647
 648/*
 649 * Sysfs callback functions
 650 */
 651static ssize_t
 652show_in_label(struct device *dev, struct device_attribute *attr, char *buf)
 653{
 654        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 655        struct nct6683_data *data = nct6683_update_device(dev);
 656        int nr = sattr->index;
 657
 658        return sprintf(buf, "%s\n", nct6683_mon_label[data->in_src[nr]]);
 659}
 660
 661static ssize_t
 662show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
 663{
 664        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 665        struct nct6683_data *data = nct6683_update_device(dev);
 666        int index = sattr->index;
 667        int nr = sattr->nr;
 668
 669        return sprintf(buf, "%ld\n",
 670                       in_from_reg(data->in[index][nr], data->in_index[index]));
 671}
 672
 673static umode_t nct6683_in_is_visible(struct kobject *kobj,
 674                                     struct attribute *attr, int index)
 675{
 676        struct device *dev = container_of(kobj, struct device, kobj);
 677        struct nct6683_data *data = dev_get_drvdata(dev);
 678        int nr = index % 4;     /* attribute */
 679
 680        /*
 681         * Voltage limits exist for Intel boards,
 682         * but register location and encoding is unknown
 683         */
 684        if ((nr == 2 || nr == 3) &&
 685            data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 686                return 0;
 687
 688        return attr->mode;
 689}
 690
 691SENSOR_TEMPLATE(in_label, "in%d_label", S_IRUGO, show_in_label, NULL, 0);
 692SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0);
 693SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IRUGO, show_in_reg, NULL, 0, 1);
 694SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IRUGO, show_in_reg, NULL, 0, 2);
 695
 696static struct sensor_device_template *nct6683_attributes_in_template[] = {
 697        &sensor_dev_template_in_label,
 698        &sensor_dev_template_in_input,
 699        &sensor_dev_template_in_min,
 700        &sensor_dev_template_in_max,
 701        NULL
 702};
 703
 704static struct sensor_template_group nct6683_in_template_group = {
 705        .templates = nct6683_attributes_in_template,
 706        .is_visible = nct6683_in_is_visible,
 707};
 708
 709static ssize_t
 710show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 711{
 712        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 713        struct nct6683_data *data = nct6683_update_device(dev);
 714
 715        return sprintf(buf, "%d\n", data->rpm[sattr->index]);
 716}
 717
 718static ssize_t
 719show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
 720{
 721        struct nct6683_data *data = nct6683_update_device(dev);
 722        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 723        int nr = sattr->index;
 724
 725        return sprintf(buf, "%d\n", data->fan_min[nr]);
 726}
 727
 728static ssize_t
 729show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
 730{
 731        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 732        struct nct6683_data *data = nct6683_update_device(dev);
 733
 734        return sprintf(buf, "%d\n",
 735                       ((data->fanin_cfg[sattr->index] >> 5) & 0x03) + 1);
 736}
 737
 738static umode_t nct6683_fan_is_visible(struct kobject *kobj,
 739                                      struct attribute *attr, int index)
 740{
 741        struct device *dev = container_of(kobj, struct device, kobj);
 742        struct nct6683_data *data = dev_get_drvdata(dev);
 743        int fan = index / 3;    /* fan index */
 744        int nr = index % 3;     /* attribute index */
 745
 746        if (!(data->have_fan & (1 << fan)))
 747                return 0;
 748
 749        /*
 750         * Intel may have minimum fan speed limits,
 751         * but register location and encoding are unknown.
 752         */
 753        if (nr == 2 && data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 754                return 0;
 755
 756        return attr->mode;
 757}
 758
 759SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0);
 760SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IRUGO, show_fan_pulses, NULL, 0);
 761SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IRUGO, show_fan_min, NULL, 0);
 762
 763/*
 764 * nct6683_fan_is_visible uses the index into the following array
 765 * to determine if attributes should be created or not.
 766 * Any change in order or content must be matched.
 767 */
 768static struct sensor_device_template *nct6683_attributes_fan_template[] = {
 769        &sensor_dev_template_fan_input,
 770        &sensor_dev_template_fan_pulses,
 771        &sensor_dev_template_fan_min,
 772        NULL
 773};
 774
 775static struct sensor_template_group nct6683_fan_template_group = {
 776        .templates = nct6683_attributes_fan_template,
 777        .is_visible = nct6683_fan_is_visible,
 778        .base = 1,
 779};
 780
 781static ssize_t
 782show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
 783{
 784        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 785        struct nct6683_data *data = nct6683_update_device(dev);
 786        int nr = sattr->index;
 787
 788        return sprintf(buf, "%s\n", nct6683_mon_label[data->temp_src[nr]]);
 789}
 790
 791static ssize_t
 792show_temp8(struct device *dev, struct device_attribute *attr, char *buf)
 793{
 794        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 795        struct nct6683_data *data = nct6683_update_device(dev);
 796        int index = sattr->index;
 797        int nr = sattr->nr;
 798
 799        return sprintf(buf, "%d\n", data->temp[index][nr] * 1000);
 800}
 801
 802static ssize_t
 803show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
 804{
 805        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 806        struct nct6683_data *data = nct6683_update_device(dev);
 807        int nr = sattr->index;
 808        int temp = data->temp[1][nr] - data->temp[2][nr];
 809
 810        return sprintf(buf, "%d\n", temp * 1000);
 811}
 812
 813static ssize_t
 814show_temp16(struct device *dev, struct device_attribute *attr, char *buf)
 815{
 816        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 817        struct nct6683_data *data = nct6683_update_device(dev);
 818        int index = sattr->index;
 819
 820        return sprintf(buf, "%d\n", (data->temp_in[index] / 128) * 500);
 821}
 822
 823/*
 824 * Temperature sensor type is determined by temperature source
 825 * and can not be modified.
 826 * 0x02..0x07: Thermal diode
 827 * 0x08..0x18: Thermistor
 828 * 0x20..0x2b: Intel PECI
 829 * 0x42..0x49: AMD TSI
 830 * Others are unspecified (not visible)
 831 */
 832
 833static int get_temp_type(u8 src)
 834{
 835        if (src >= 0x02 && src <= 0x07)
 836                return 3;       /* thermal diode */
 837        else if (src >= 0x08 && src <= 0x18)
 838                return 4;       /* thermistor */
 839        else if (src >= 0x20 && src <= 0x2b)
 840                return 6;       /* PECI */
 841        else if (src >= 0x42 && src <= 0x49)
 842                return 5;
 843
 844        return 0;
 845}
 846
 847static ssize_t
 848show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
 849{
 850        struct nct6683_data *data = nct6683_update_device(dev);
 851        struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
 852        int nr = sattr->index;
 853        return sprintf(buf, "%d\n", get_temp_type(data->temp_src[nr]));
 854}
 855
 856static umode_t nct6683_temp_is_visible(struct kobject *kobj,
 857                                       struct attribute *attr, int index)
 858{
 859        struct device *dev = container_of(kobj, struct device, kobj);
 860        struct nct6683_data *data = dev_get_drvdata(dev);
 861        int temp = index / 7;   /* temp index */
 862        int nr = index % 7;     /* attribute index */
 863
 864        /*
 865         * Intel does not have low temperature limits or temperature hysteresis
 866         * registers, or at least register location and encoding is unknown.
 867         */
 868        if ((nr == 2 || nr == 4) &&
 869            data->customer_id == NCT6683_CUSTOMER_ID_INTEL)
 870                return 0;
 871
 872        if (nr == 6 && get_temp_type(data->temp_src[temp]) == 0)
 873                return 0;                               /* type */
 874
 875        return attr->mode;
 876}
 877
 878SENSOR_TEMPLATE(temp_input, "temp%d_input", S_IRUGO, show_temp16, NULL, 0);
 879SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0);
 880SENSOR_TEMPLATE_2(temp_min, "temp%d_min", S_IRUGO, show_temp8, NULL, 0, 0);
 881SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO, show_temp8, NULL, 0, 1);
 882SENSOR_TEMPLATE(temp_max_hyst, "temp%d_max_hyst", S_IRUGO, show_temp_hyst, NULL,
 883                0);
 884SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO, show_temp8, NULL, 0, 3);
 885SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO, show_temp_type, NULL, 0);
 886
 887/*
 888 * nct6683_temp_is_visible uses the index into the following array
 889 * to determine if attributes should be created or not.
 890 * Any change in order or content must be matched.
 891 */
 892static struct sensor_device_template *nct6683_attributes_temp_template[] = {
 893        &sensor_dev_template_temp_input,
 894        &sensor_dev_template_temp_label,
 895        &sensor_dev_template_temp_min,          /* 2 */
 896        &sensor_dev_template_temp_max,          /* 3 */
 897        &sensor_dev_template_temp_max_hyst,     /* 4 */
 898        &sensor_dev_template_temp_crit,         /* 5 */
 899        &sensor_dev_template_temp_type,         /* 6 */
 900        NULL
 901};
 902
 903static struct sensor_template_group nct6683_temp_template_group = {
 904        .templates = nct6683_attributes_temp_template,
 905        .is_visible = nct6683_temp_is_visible,
 906        .base = 1,
 907};
 908
 909static ssize_t
 910show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 911{
 912        struct nct6683_data *data = nct6683_update_device(dev);
 913        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 914        int index = sattr->index;
 915
 916        return sprintf(buf, "%d\n", data->pwm[index]);
 917}
 918
 919SENSOR_TEMPLATE(pwm, "pwm%d", S_IRUGO, show_pwm, NULL, 0);
 920
 921static umode_t nct6683_pwm_is_visible(struct kobject *kobj,
 922                                      struct attribute *attr, int index)
 923{
 924        struct device *dev = container_of(kobj, struct device, kobj);
 925        struct nct6683_data *data = dev_get_drvdata(dev);
 926        int pwm = index;        /* pwm index */
 927
 928        if (!(data->have_pwm & (1 << pwm)))
 929                return 0;
 930
 931        return attr->mode;
 932}
 933
 934static struct sensor_device_template *nct6683_attributes_pwm_template[] = {
 935        &sensor_dev_template_pwm,
 936        NULL
 937};
 938
 939static struct sensor_template_group nct6683_pwm_template_group = {
 940        .templates = nct6683_attributes_pwm_template,
 941        .is_visible = nct6683_pwm_is_visible,
 942        .base = 1,
 943};
 944
 945static ssize_t
 946show_global_beep(struct device *dev, struct device_attribute *attr, char *buf)
 947{
 948        struct nct6683_data *data = dev_get_drvdata(dev);
 949        int ret;
 950        u8 reg;
 951
 952        mutex_lock(&data->update_lock);
 953
 954        ret = superio_enter(data->sioreg);
 955        if (ret)
 956                goto error;
 957        superio_select(data->sioreg, NCT6683_LD_HWM);
 958        reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
 959        superio_exit(data->sioreg);
 960
 961        mutex_unlock(&data->update_lock);
 962
 963        return sprintf(buf, "%u\n", !!(reg & NCT6683_CR_BEEP_MASK));
 964
 965error:
 966        mutex_unlock(&data->update_lock);
 967        return ret;
 968}
 969
 970static ssize_t
 971store_global_beep(struct device *dev, struct device_attribute *attr,
 972                  const char *buf, size_t count)
 973{
 974        struct nct6683_data *data = dev_get_drvdata(dev);
 975        unsigned long val;
 976        u8 reg;
 977        int ret;
 978
 979        if (kstrtoul(buf, 10, &val) || (val != 0 && val != 1))
 980                return -EINVAL;
 981
 982        mutex_lock(&data->update_lock);
 983
 984        ret = superio_enter(data->sioreg);
 985        if (ret) {
 986                count = ret;
 987                goto error;
 988        }
 989
 990        superio_select(data->sioreg, NCT6683_LD_HWM);
 991        reg = superio_inb(data->sioreg, NCT6683_REG_CR_BEEP);
 992        if (val)
 993                reg |= NCT6683_CR_BEEP_MASK;
 994        else
 995                reg &= ~NCT6683_CR_BEEP_MASK;
 996        superio_outb(data->sioreg, NCT6683_REG_CR_BEEP, reg);
 997        superio_exit(data->sioreg);
 998error:
 999        mutex_unlock(&data->update_lock);
1000        return count;
1001}
1002
1003/* Case open detection */
1004
1005static ssize_t
1006show_caseopen(struct device *dev, struct device_attribute *attr, char *buf)
1007{
1008        struct nct6683_data *data = dev_get_drvdata(dev);
1009        int ret;
1010        u8 reg;
1011
1012        mutex_lock(&data->update_lock);
1013
1014        ret = superio_enter(data->sioreg);
1015        if (ret)
1016                goto error;
1017        superio_select(data->sioreg, NCT6683_LD_ACPI);
1018        reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1019        superio_exit(data->sioreg);
1020
1021        mutex_unlock(&data->update_lock);
1022
1023        return sprintf(buf, "%u\n", !(reg & NCT6683_CR_CASEOPEN_MASK));
1024
1025error:
1026        mutex_unlock(&data->update_lock);
1027        return ret;
1028}
1029
1030static ssize_t
1031clear_caseopen(struct device *dev, struct device_attribute *attr,
1032               const char *buf, size_t count)
1033{
1034        struct nct6683_data *data = dev_get_drvdata(dev);
1035        unsigned long val;
1036        u8 reg;
1037        int ret;
1038
1039        if (kstrtoul(buf, 10, &val) || val != 0)
1040                return -EINVAL;
1041
1042        mutex_lock(&data->update_lock);
1043
1044        /*
1045         * Use CR registers to clear caseopen status.
1046         * Caseopen is activ low, clear by writing 1 into the register.
1047         */
1048
1049        ret = superio_enter(data->sioreg);
1050        if (ret) {
1051                count = ret;
1052                goto error;
1053        }
1054
1055        superio_select(data->sioreg, NCT6683_LD_ACPI);
1056        reg = superio_inb(data->sioreg, NCT6683_REG_CR_CASEOPEN);
1057        reg |= NCT6683_CR_CASEOPEN_MASK;
1058        superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1059        reg &= ~NCT6683_CR_CASEOPEN_MASK;
1060        superio_outb(data->sioreg, NCT6683_REG_CR_CASEOPEN, reg);
1061        superio_exit(data->sioreg);
1062
1063        data->valid = false;    /* Force cache refresh */
1064error:
1065        mutex_unlock(&data->update_lock);
1066        return count;
1067}
1068
1069static DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_caseopen,
1070                   clear_caseopen);
1071static DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_global_beep,
1072                   store_global_beep);
1073
1074static struct attribute *nct6683_attributes_other[] = {
1075        &dev_attr_intrusion0_alarm.attr,
1076        &dev_attr_beep_enable.attr,
1077        NULL
1078};
1079
1080static const struct attribute_group nct6683_group_other = {
1081        .attrs = nct6683_attributes_other,
1082};
1083
1084/* Get the monitoring functions started */
1085static inline void nct6683_init_device(struct nct6683_data *data)
1086{
1087        u8 tmp;
1088
1089        /* Start hardware monitoring if needed */
1090        tmp = nct6683_read(data, NCT6683_HWM_CFG);
1091        if (!(tmp & 0x80))
1092                nct6683_write(data, NCT6683_HWM_CFG, tmp | 0x80);
1093}
1094
1095/*
1096 * There are a total of 24 fan inputs. Each can be configured as input
1097 * or as output. A maximum of 16 inputs and 8 outputs is configurable.
1098 */
1099static void
1100nct6683_setup_fans(struct nct6683_data *data)
1101{
1102        int i;
1103        u8 reg;
1104
1105        for (i = 0; i < NCT6683_NUM_REG_FAN; i++) {
1106                reg = nct6683_read(data, NCT6683_REG_FANIN_CFG(i));
1107                if (reg & 0x80)
1108                        data->have_fan |= 1 << i;
1109                data->fanin_cfg[i] = reg;
1110        }
1111        for (i = 0; i < NCT6683_NUM_REG_PWM; i++) {
1112                reg = nct6683_read(data, NCT6683_REG_FANOUT_CFG(i));
1113                if (reg & 0x80)
1114                        data->have_pwm |= 1 << i;
1115                data->fanout_cfg[i] = reg;
1116        }
1117}
1118
1119/*
1120 * Translation from monitoring register to temperature and voltage attributes
1121 * ==========================================================================
1122 *
1123 * There are a total of 32 monitoring registers. Each can be assigned to either
1124 * a temperature or voltage monitoring source.
1125 * NCT6683_REG_MON_CFG(x) defines assignment for each monitoring source.
1126 *
1127 * Temperature and voltage attribute mapping is determined by walking through
1128 * the NCT6683_REG_MON_CFG registers. If the assigned source is
1129 * a temperature, temp_index[n] is set to the monitor register index, and
1130 * temp_src[n] is set to the temperature source. If the assigned source is
1131 * a voltage, the respective values are stored in in_index[] and in_src[],
1132 * respectively.
1133 */
1134
1135static void nct6683_setup_sensors(struct nct6683_data *data)
1136{
1137        u8 reg;
1138        int i;
1139
1140        data->temp_num = 0;
1141        data->in_num = 0;
1142        for (i = 0; i < NCT6683_NUM_REG_MON; i++) {
1143                reg = nct6683_read(data, NCT6683_REG_MON_CFG(i)) & 0x7f;
1144                /* Ignore invalid assignments */
1145                if (reg >= NUM_MON_LABELS)
1146                        continue;
1147                /* Skip if disabled or reserved */
1148                if (nct6683_mon_label[reg] == NULL)
1149                        continue;
1150                if (reg < MON_VOLTAGE_START) {
1151                        data->temp_index[data->temp_num] = i;
1152                        data->temp_src[data->temp_num] = reg;
1153                        data->temp_num++;
1154                } else {
1155                        data->in_index[data->in_num] = i;
1156                        data->in_src[data->in_num] = reg;
1157                        data->in_num++;
1158                }
1159        }
1160}
1161
1162static int nct6683_probe(struct platform_device *pdev)
1163{
1164        struct device *dev = &pdev->dev;
1165        struct nct6683_sio_data *sio_data = dev->platform_data;
1166        struct attribute_group *group;
1167        struct nct6683_data *data;
1168        struct device *hwmon_dev;
1169        struct resource *res;
1170        int groups = 0;
1171
1172        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1173        if (!devm_request_region(dev, res->start, IOREGION_LENGTH, DRVNAME))
1174                return -EBUSY;
1175
1176        data = devm_kzalloc(dev, sizeof(struct nct6683_data), GFP_KERNEL);
1177        if (!data)
1178                return -ENOMEM;
1179
1180        data->kind = sio_data->kind;
1181        data->sioreg = sio_data->sioreg;
1182        data->addr = res->start;
1183        mutex_init(&data->update_lock);
1184        platform_set_drvdata(pdev, data);
1185
1186        data->customer_id = nct6683_read16(data, NCT6683_REG_CUSTOMER_ID);
1187
1188        nct6683_init_device(data);
1189        nct6683_setup_fans(data);
1190        nct6683_setup_sensors(data);
1191
1192        /* Register sysfs hooks */
1193
1194        if (data->have_pwm) {
1195                group = nct6683_create_attr_group(dev,
1196                                                  &nct6683_pwm_template_group,
1197                                                  fls(data->have_pwm));
1198                if (IS_ERR(group))
1199                        return PTR_ERR(group);
1200                data->groups[groups++] = group;
1201        }
1202
1203        if (data->in_num) {
1204                group = nct6683_create_attr_group(dev,
1205                                                  &nct6683_in_template_group,
1206                                                  data->in_num);
1207                if (IS_ERR(group))
1208                        return PTR_ERR(group);
1209                data->groups[groups++] = group;
1210        }
1211
1212        if (data->have_fan) {
1213                group = nct6683_create_attr_group(dev,
1214                                                  &nct6683_fan_template_group,
1215                                                  fls(data->have_fan));
1216                if (IS_ERR(group))
1217                        return PTR_ERR(group);
1218                data->groups[groups++] = group;
1219        }
1220
1221        if (data->temp_num) {
1222                group = nct6683_create_attr_group(dev,
1223                                                  &nct6683_temp_template_group,
1224                                                  data->temp_num);
1225                if (IS_ERR(group))
1226                        return PTR_ERR(group);
1227                data->groups[groups++] = group;
1228        }
1229        data->groups[groups++] = &nct6683_group_other;
1230
1231        dev_info(dev, "%s EC firmware version %d.%d build %02x/%02x/%02x\n",
1232                 nct6683_chip_names[data->kind],
1233                 nct6683_read(data, NCT6683_REG_VERSION_HI),
1234                 nct6683_read(data, NCT6683_REG_VERSION_LO),
1235                 nct6683_read(data, NCT6683_REG_BUILD_MONTH),
1236                 nct6683_read(data, NCT6683_REG_BUILD_DAY),
1237                 nct6683_read(data, NCT6683_REG_BUILD_YEAR));
1238
1239        hwmon_dev = devm_hwmon_device_register_with_groups(dev,
1240                        nct6683_device_names[data->kind], data, data->groups);
1241        return PTR_ERR_OR_ZERO(hwmon_dev);
1242}
1243
1244#ifdef CONFIG_PM
1245static int nct6683_suspend(struct device *dev)
1246{
1247        struct nct6683_data *data = nct6683_update_device(dev);
1248
1249        mutex_lock(&data->update_lock);
1250        data->hwm_cfg = nct6683_read(data, NCT6683_HWM_CFG);
1251        mutex_unlock(&data->update_lock);
1252
1253        return 0;
1254}
1255
1256static int nct6683_resume(struct device *dev)
1257{
1258        struct nct6683_data *data = dev_get_drvdata(dev);
1259
1260        mutex_lock(&data->update_lock);
1261
1262        nct6683_write(data, NCT6683_HWM_CFG, data->hwm_cfg);
1263
1264        /* Force re-reading all values */
1265        data->valid = false;
1266        mutex_unlock(&data->update_lock);
1267
1268        return 0;
1269}
1270
1271static const struct dev_pm_ops nct6683_dev_pm_ops = {
1272        .suspend = nct6683_suspend,
1273        .resume = nct6683_resume,
1274        .freeze = nct6683_suspend,
1275        .restore = nct6683_resume,
1276};
1277
1278#define NCT6683_DEV_PM_OPS      (&nct6683_dev_pm_ops)
1279#else
1280#define NCT6683_DEV_PM_OPS      NULL
1281#endif /* CONFIG_PM */
1282
1283static struct platform_driver nct6683_driver = {
1284        .driver = {
1285                .name   = DRVNAME,
1286                .pm     = NCT6683_DEV_PM_OPS,
1287        },
1288        .probe          = nct6683_probe,
1289};
1290
1291static int __init nct6683_find(int sioaddr, struct nct6683_sio_data *sio_data)
1292{
1293        const char *board_vendor;
1294        int addr;
1295        u16 val;
1296        int err;
1297
1298        /*
1299         * Only run on Intel boards unless the 'force' module parameter is set
1300         */
1301        if (!force) {
1302                board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1303                if (!board_vendor || strcmp(board_vendor, "Intel Corporation"))
1304                        return -ENODEV;
1305        }
1306
1307        err = superio_enter(sioaddr);
1308        if (err)
1309                return err;
1310
1311        val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1312               | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1313
1314        switch (val & SIO_ID_MASK) {
1315        case SIO_NCT6683_ID:
1316                sio_data->kind = nct6683;
1317                break;
1318        default:
1319                if (val != 0xffff)
1320                        pr_debug("unsupported chip ID: 0x%04x\n", val);
1321                goto fail;
1322        }
1323
1324        /* We have a known chip, find the HWM I/O address */
1325        superio_select(sioaddr, NCT6683_LD_HWM);
1326        val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1327            | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1328        addr = val & IOREGION_ALIGNMENT;
1329        if (addr == 0) {
1330                pr_err("EC base I/O port unconfigured\n");
1331                goto fail;
1332        }
1333
1334        /* Activate logical device if needed */
1335        val = superio_inb(sioaddr, SIO_REG_ENABLE);
1336        if (!(val & 0x01)) {
1337                pr_err("EC is disabled\n");
1338                goto fail;
1339        }
1340
1341        superio_exit(sioaddr);
1342        pr_info("Found %s or compatible chip at %#x:%#x\n",
1343                nct6683_chip_names[sio_data->kind], sioaddr, addr);
1344        sio_data->sioreg = sioaddr;
1345
1346        return addr;
1347
1348fail:
1349        superio_exit(sioaddr);
1350        return -ENODEV;
1351}
1352
1353/*
1354 * when Super-I/O functions move to a separate file, the Super-I/O
1355 * bus will manage the lifetime of the device and this module will only keep
1356 * track of the nct6683 driver. But since we use platform_device_alloc(), we
1357 * must keep track of the device
1358 */
1359static struct platform_device *pdev[2];
1360
1361static int __init sensors_nct6683_init(void)
1362{
1363        struct nct6683_sio_data sio_data;
1364        int sioaddr[2] = { 0x2e, 0x4e };
1365        struct resource res;
1366        bool found = false;
1367        int address;
1368        int i, err;
1369
1370        err = platform_driver_register(&nct6683_driver);
1371        if (err)
1372                return err;
1373
1374        /*
1375         * initialize sio_data->kind and sio_data->sioreg.
1376         *
1377         * when Super-I/O functions move to a separate file, the Super-I/O
1378         * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1379         * nct6683 hardware monitor, and call probe()
1380         */
1381        for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1382                address = nct6683_find(sioaddr[i], &sio_data);
1383                if (address <= 0)
1384                        continue;
1385
1386                found = true;
1387
1388                pdev[i] = platform_device_alloc(DRVNAME, address);
1389                if (!pdev[i]) {
1390                        err = -ENOMEM;
1391                        goto exit_device_unregister;
1392                }
1393
1394                err = platform_device_add_data(pdev[i], &sio_data,
1395                                               sizeof(struct nct6683_sio_data));
1396                if (err)
1397                        goto exit_device_put;
1398
1399                memset(&res, 0, sizeof(res));
1400                res.name = DRVNAME;
1401                res.start = address + IOREGION_OFFSET;
1402                res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1403                res.flags = IORESOURCE_IO;
1404
1405                err = acpi_check_resource_conflict(&res);
1406                if (err) {
1407                        platform_device_put(pdev[i]);
1408                        pdev[i] = NULL;
1409                        continue;
1410                }
1411
1412                err = platform_device_add_resources(pdev[i], &res, 1);
1413                if (err)
1414                        goto exit_device_put;
1415
1416                /* platform_device_add calls probe() */
1417                err = platform_device_add(pdev[i]);
1418                if (err)
1419                        goto exit_device_put;
1420        }
1421        if (!found) {
1422                err = -ENODEV;
1423                goto exit_unregister;
1424        }
1425
1426        return 0;
1427
1428exit_device_put:
1429        platform_device_put(pdev[i]);
1430exit_device_unregister:
1431        while (--i >= 0) {
1432                if (pdev[i])
1433                        platform_device_unregister(pdev[i]);
1434        }
1435exit_unregister:
1436        platform_driver_unregister(&nct6683_driver);
1437        return err;
1438}
1439
1440static void __exit sensors_nct6683_exit(void)
1441{
1442        int i;
1443
1444        for (i = 0; i < ARRAY_SIZE(pdev); i++) {
1445                if (pdev[i])
1446                        platform_device_unregister(pdev[i]);
1447        }
1448        platform_driver_unregister(&nct6683_driver);
1449}
1450
1451MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
1452MODULE_DESCRIPTION("NCT6683D driver");
1453MODULE_LICENSE("GPL");
1454
1455module_init(sensors_nct6683_init);
1456module_exit(sensors_nct6683_exit);
1457
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.