linux/drivers/hwmon/adm9240.c
<<
>>
Prefs
   1/*
   2 * adm9240.c    Part of lm_sensors, Linux kernel modules for hardware
   3 *              monitoring
   4 *
   5 * Copyright (C) 1999   Frodo Looijaard <frodol@dds.nl>
   6 *                      Philip Edelbrock <phil@netroedge.com>
   7 * Copyright (C) 2003   Michiel Rook <michiel@grendelproject.nl>
   8 * Copyright (C) 2005   Grant Coady <gcoady.lk@gmail.com> with valuable
   9 *                              guidance from Jean Delvare
  10 *
  11 * Driver supports      Analog Devices          ADM9240
  12 *                      Dallas Semiconductor    DS1780
  13 *                      National Semiconductor  LM81
  14 *
  15 * ADM9240 is the reference, DS1780 and LM81 are register compatibles
  16 *
  17 * Voltage      Six inputs are scaled by chip, VID also reported
  18 * Temperature  Chip temperature to 0.5'C, maximum and max_hysteris
  19 * Fans         2 fans, low speed alarm, automatic fan clock divider
  20 * Alarms       16-bit map of active alarms
  21 * Analog Out   0..1250 mV output
  22 *
  23 * Chassis Intrusion: clear CI latch with 'echo 0 > intrusion0_alarm'
  24 *
  25 * Test hardware: Intel SE440BX-2 desktop motherboard --Grant
  26 *
  27 * LM81 extended temp reading not implemented
  28 *
  29 * This program is free software; you can redistribute it and/or modify
  30 * it under the terms of the GNU General Public License as published by
  31 * the Free Software Foundation; either version 2 of the License, or
  32 * (at your option) any later version.
  33 *
  34 * This program is distributed in the hope that it will be useful,
  35 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  37 * GNU General Public License for more details.
  38 *
  39 * You should have received a copy of the GNU General Public License
  40 * along with this program; if not, write to the Free Software
  41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  42 */
  43
  44#include <linux/init.h>
  45#include <linux/module.h>
  46#include <linux/slab.h>
  47#include <linux/i2c.h>
  48#include <linux/hwmon-sysfs.h>
  49#include <linux/hwmon.h>
  50#include <linux/hwmon-vid.h>
  51#include <linux/err.h>
  52#include <linux/mutex.h>
  53
  54/* Addresses to scan */
  55static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  56                                        I2C_CLIENT_END };
  57
  58enum chips { adm9240, ds1780, lm81 };
  59
  60/* ADM9240 registers */
  61#define ADM9240_REG_MAN_ID              0x3e
  62#define ADM9240_REG_DIE_REV             0x3f
  63#define ADM9240_REG_CONFIG              0x40
  64
  65#define ADM9240_REG_IN(nr)              (0x20 + (nr))   /* 0..5 */
  66#define ADM9240_REG_IN_MAX(nr)          (0x2b + (nr) * 2)
  67#define ADM9240_REG_IN_MIN(nr)          (0x2c + (nr) * 2)
  68#define ADM9240_REG_FAN(nr)             (0x28 + (nr))   /* 0..1 */
  69#define ADM9240_REG_FAN_MIN(nr)         (0x3b + (nr))
  70#define ADM9240_REG_INT(nr)             (0x41 + (nr))
  71#define ADM9240_REG_INT_MASK(nr)        (0x43 + (nr))
  72#define ADM9240_REG_TEMP                0x27
  73#define ADM9240_REG_TEMP_MAX(nr)        (0x39 + (nr)) /* 0, 1 = high, hyst */
  74#define ADM9240_REG_ANALOG_OUT          0x19
  75#define ADM9240_REG_CHASSIS_CLEAR       0x46
  76#define ADM9240_REG_VID_FAN_DIV         0x47
  77#define ADM9240_REG_I2C_ADDR            0x48
  78#define ADM9240_REG_VID4                0x49
  79#define ADM9240_REG_TEMP_CONF           0x4b
  80
  81/* generalised scaling with integer rounding */
  82static inline int SCALE(long val, int mul, int div)
  83{
  84        if (val < 0)
  85                return (val * mul - div / 2) / div;
  86        else
  87                return (val * mul + div / 2) / div;
  88}
  89
  90/* adm9240 internally scales voltage measurements */
  91static const u16 nom_mv[] = { 2500, 2700, 3300, 5000, 12000, 2700 };
  92
  93static inline unsigned int IN_FROM_REG(u8 reg, int n)
  94{
  95        return SCALE(reg, nom_mv[n], 192);
  96}
  97
  98static inline u8 IN_TO_REG(unsigned long val, int n)
  99{
 100        return SENSORS_LIMIT(SCALE(val, 192, nom_mv[n]), 0, 255);
 101}
 102
 103/* temperature range: -40..125, 127 disables temperature alarm */
 104static inline s8 TEMP_TO_REG(long val)
 105{
 106        return SENSORS_LIMIT(SCALE(val, 1, 1000), -40, 127);
 107}
 108
 109/* two fans, each with low fan speed limit */
 110static inline unsigned int FAN_FROM_REG(u8 reg, u8 div)
 111{
 112        if (!reg) /* error */
 113                return -1;
 114
 115        if (reg == 255)
 116                return 0;
 117
 118        return SCALE(1350000, 1, reg * div);
 119}
 120
 121/* analog out 0..1250mV */
 122static inline u8 AOUT_TO_REG(unsigned long val)
 123{
 124        return SENSORS_LIMIT(SCALE(val, 255, 1250), 0, 255);
 125}
 126
 127static inline unsigned int AOUT_FROM_REG(u8 reg)
 128{
 129        return SCALE(reg, 1250, 255);
 130}
 131
 132static int adm9240_probe(struct i2c_client *client,
 133                         const struct i2c_device_id *id);
 134static int adm9240_detect(struct i2c_client *client,
 135                          struct i2c_board_info *info);
 136static void adm9240_init_client(struct i2c_client *client);
 137static int adm9240_remove(struct i2c_client *client);
 138static struct adm9240_data *adm9240_update_device(struct device *dev);
 139
 140/* driver data */
 141static const struct i2c_device_id adm9240_id[] = {
 142        { "adm9240", adm9240 },
 143        { "ds1780", ds1780 },
 144        { "lm81", lm81 },
 145        { }
 146};
 147MODULE_DEVICE_TABLE(i2c, adm9240_id);
 148
 149static struct i2c_driver adm9240_driver = {
 150        .class          = I2C_CLASS_HWMON,
 151        .driver = {
 152                .name   = "adm9240",
 153        },
 154        .probe          = adm9240_probe,
 155        .remove         = adm9240_remove,
 156        .id_table       = adm9240_id,
 157        .detect         = adm9240_detect,
 158        .address_list   = normal_i2c,
 159};
 160
 161/* per client data */
 162struct adm9240_data {
 163        struct device *hwmon_dev;
 164        struct mutex update_lock;
 165        char valid;
 166        unsigned long last_updated_measure;
 167        unsigned long last_updated_config;
 168
 169        u8 in[6];               /* ro   in0_input */
 170        u8 in_max[6];           /* rw   in0_max */
 171        u8 in_min[6];           /* rw   in0_min */
 172        u8 fan[2];              /* ro   fan1_input */
 173        u8 fan_min[2];          /* rw   fan1_min */
 174        u8 fan_div[2];          /* rw   fan1_div, read-only accessor */
 175        s16 temp;               /* ro   temp1_input, 9-bit sign-extended */
 176        s8 temp_max[2];         /* rw   0 -> temp_max, 1 -> temp_max_hyst */
 177        u16 alarms;             /* ro   alarms */
 178        u8 aout;                /* rw   aout_output */
 179        u8 vid;                 /* ro   vid */
 180        u8 vrm;                 /* --   vrm set on startup, no accessor */
 181};
 182
 183/*** sysfs accessors ***/
 184
 185/* temperature */
 186static ssize_t show_temp(struct device *dev, struct device_attribute *dummy,
 187                char *buf)
 188{
 189        struct adm9240_data *data = adm9240_update_device(dev);
 190        return sprintf(buf, "%d\n", data->temp * 500); /* 9-bit value */
 191}
 192
 193static ssize_t show_max(struct device *dev, struct device_attribute *devattr,
 194                char *buf)
 195{
 196        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 197        struct adm9240_data *data = adm9240_update_device(dev);
 198        return sprintf(buf, "%d\n", data->temp_max[attr->index] * 1000);
 199}
 200
 201static ssize_t set_max(struct device *dev, struct device_attribute *devattr,
 202                const char *buf, size_t count)
 203{
 204        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 205        struct i2c_client *client = to_i2c_client(dev);
 206        struct adm9240_data *data = i2c_get_clientdata(client);
 207        long val;
 208        int err;
 209
 210        err = kstrtol(buf, 10, &val);
 211        if (err)
 212                return err;
 213
 214        mutex_lock(&data->update_lock);
 215        data->temp_max[attr->index] = TEMP_TO_REG(val);
 216        i2c_smbus_write_byte_data(client, ADM9240_REG_TEMP_MAX(attr->index),
 217                        data->temp_max[attr->index]);
 218        mutex_unlock(&data->update_lock);
 219        return count;
 220}
 221
 222static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 223static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
 224                show_max, set_max, 0);
 225static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
 226                show_max, set_max, 1);
 227
 228/* voltage */
 229static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
 230                char *buf)
 231{
 232        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 233        struct adm9240_data *data = adm9240_update_device(dev);
 234        return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index],
 235                                attr->index));
 236}
 237
 238static ssize_t show_in_min(struct device *dev,
 239                struct device_attribute *devattr, char *buf)
 240{
 241        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 242        struct adm9240_data *data = adm9240_update_device(dev);
 243        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index],
 244                                attr->index));
 245}
 246
 247static ssize_t show_in_max(struct device *dev,
 248                struct device_attribute *devattr, char *buf)
 249{
 250        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 251        struct adm9240_data *data = adm9240_update_device(dev);
 252        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index],
 253                                attr->index));
 254}
 255
 256static ssize_t set_in_min(struct device *dev,
 257                struct device_attribute *devattr,
 258                const char *buf, size_t count)
 259{
 260        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 261        struct i2c_client *client = to_i2c_client(dev);
 262        struct adm9240_data *data = i2c_get_clientdata(client);
 263        unsigned long val;
 264        int err;
 265
 266        err = kstrtoul(buf, 10, &val);
 267        if (err)
 268                return err;
 269
 270        mutex_lock(&data->update_lock);
 271        data->in_min[attr->index] = IN_TO_REG(val, attr->index);
 272        i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MIN(attr->index),
 273                        data->in_min[attr->index]);
 274        mutex_unlock(&data->update_lock);
 275        return count;
 276}
 277
 278static ssize_t set_in_max(struct device *dev,
 279                struct device_attribute *devattr,
 280                const char *buf, size_t count)
 281{
 282        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 283        struct i2c_client *client = to_i2c_client(dev);
 284        struct adm9240_data *data = i2c_get_clientdata(client);
 285        unsigned long val;
 286        int err;
 287
 288        err = kstrtoul(buf, 10, &val);
 289        if (err)
 290                return err;
 291
 292        mutex_lock(&data->update_lock);
 293        data->in_max[attr->index] = IN_TO_REG(val, attr->index);
 294        i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MAX(attr->index),
 295                        data->in_max[attr->index]);
 296        mutex_unlock(&data->update_lock);
 297        return count;
 298}
 299
 300#define vin(nr)                                                 \
 301static SENSOR_DEVICE_ATTR(in##nr##_input, S_IRUGO,              \
 302                show_in, NULL, nr);                             \
 303static SENSOR_DEVICE_ATTR(in##nr##_min, S_IRUGO | S_IWUSR,      \
 304                show_in_min, set_in_min, nr);                   \
 305static SENSOR_DEVICE_ATTR(in##nr##_max, S_IRUGO | S_IWUSR,      \
 306                show_in_max, set_in_max, nr);
 307
 308vin(0);
 309vin(1);
 310vin(2);
 311vin(3);
 312vin(4);
 313vin(5);
 314
 315/* fans */
 316static ssize_t show_fan(struct device *dev,
 317                struct device_attribute *devattr, char *buf)
 318{
 319        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 320        struct adm9240_data *data = adm9240_update_device(dev);
 321        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
 322                                1 << data->fan_div[attr->index]));
 323}
 324
 325static ssize_t show_fan_min(struct device *dev,
 326                struct device_attribute *devattr, char *buf)
 327{
 328        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 329        struct adm9240_data *data = adm9240_update_device(dev);
 330        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[attr->index],
 331                                1 << data->fan_div[attr->index]));
 332}
 333
 334static ssize_t show_fan_div(struct device *dev,
 335                struct device_attribute *devattr, char *buf)
 336{
 337        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 338        struct adm9240_data *data = adm9240_update_device(dev);
 339        return sprintf(buf, "%d\n", 1 << data->fan_div[attr->index]);
 340}
 341
 342/* write new fan div, callers must hold data->update_lock */
 343static void adm9240_write_fan_div(struct i2c_client *client, int nr,
 344                u8 fan_div)
 345{
 346        u8 reg, old, shift = (nr + 2) * 2;
 347
 348        reg = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV);
 349        old = (reg >> shift) & 3;
 350        reg &= ~(3 << shift);
 351        reg |= (fan_div << shift);
 352        i2c_smbus_write_byte_data(client, ADM9240_REG_VID_FAN_DIV, reg);
 353        dev_dbg(&client->dev, "fan%d clock divider changed from %u "
 354                        "to %u\n", nr + 1, 1 << old, 1 << fan_div);
 355}
 356
 357/*
 358 * set fan speed low limit:
 359 *
 360 * - value is zero: disable fan speed low limit alarm
 361 *
 362 * - value is below fan speed measurement range: enable fan speed low
 363 *   limit alarm to be asserted while fan speed too slow to measure
 364 *
 365 * - otherwise: select fan clock divider to suit fan speed low limit,
 366 *   measurement code may adjust registers to ensure fan speed reading
 367 */
 368static ssize_t set_fan_min(struct device *dev,
 369                struct device_attribute *devattr,
 370                const char *buf, size_t count)
 371{
 372        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 373        struct i2c_client *client = to_i2c_client(dev);
 374        struct adm9240_data *data = i2c_get_clientdata(client);
 375        int nr = attr->index;
 376        u8 new_div;
 377        unsigned long val;
 378        int err;
 379
 380        err = kstrtoul(buf, 10, &val);
 381        if (err)
 382                return err;
 383
 384        mutex_lock(&data->update_lock);
 385
 386        if (!val) {
 387                data->fan_min[nr] = 255;
 388                new_div = data->fan_div[nr];
 389
 390                dev_dbg(&client->dev, "fan%u low limit set disabled\n",
 391                                nr + 1);
 392
 393        } else if (val < 1350000 / (8 * 254)) {
 394                new_div = 3;
 395                data->fan_min[nr] = 254;
 396
 397                dev_dbg(&client->dev, "fan%u low limit set minimum %u\n",
 398                                nr + 1, FAN_FROM_REG(254, 1 << new_div));
 399
 400        } else {
 401                unsigned int new_min = 1350000 / val;
 402
 403                new_div = 0;
 404                while (new_min > 192 && new_div < 3) {
 405                        new_div++;
 406                        new_min /= 2;
 407                }
 408                if (!new_min) /* keep > 0 */
 409                        new_min++;
 410
 411                data->fan_min[nr] = new_min;
 412
 413                dev_dbg(&client->dev, "fan%u low limit set fan speed %u\n",
 414                                nr + 1, FAN_FROM_REG(new_min, 1 << new_div));
 415        }
 416
 417        if (new_div != data->fan_div[nr]) {
 418                data->fan_div[nr] = new_div;
 419                adm9240_write_fan_div(client, nr, new_div);
 420        }
 421        i2c_smbus_write_byte_data(client, ADM9240_REG_FAN_MIN(nr),
 422                        data->fan_min[nr]);
 423
 424        mutex_unlock(&data->update_lock);
 425        return count;
 426}
 427
 428#define fan(nr)                                                 \
 429static SENSOR_DEVICE_ATTR(fan##nr##_input, S_IRUGO,             \
 430                show_fan, NULL, nr - 1);                        \
 431static SENSOR_DEVICE_ATTR(fan##nr##_div, S_IRUGO,               \
 432                show_fan_div, NULL, nr - 1);                    \
 433static SENSOR_DEVICE_ATTR(fan##nr##_min, S_IRUGO | S_IWUSR,     \
 434                show_fan_min, set_fan_min, nr - 1);
 435
 436fan(1);
 437fan(2);
 438
 439/* alarms */
 440static ssize_t show_alarms(struct device *dev,
 441                struct device_attribute *attr, char *buf)
 442{
 443        struct adm9240_data *data = adm9240_update_device(dev);
 444        return sprintf(buf, "%u\n", data->alarms);
 445}
 446static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 447
 448static ssize_t show_alarm(struct device *dev,
 449                struct device_attribute *attr, char *buf)
 450{
 451        int bitnr = to_sensor_dev_attr(attr)->index;
 452        struct adm9240_data *data = adm9240_update_device(dev);
 453        return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 454}
 455static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 456static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 457static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 458static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 459static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 460static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 461static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 462static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 463static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 464
 465/* vid */
 466static ssize_t show_vid(struct device *dev,
 467                struct device_attribute *attr, char *buf)
 468{
 469        struct adm9240_data *data = adm9240_update_device(dev);
 470        return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 471}
 472static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 473
 474/* analog output */
 475static ssize_t show_aout(struct device *dev,
 476                struct device_attribute *attr, char *buf)
 477{
 478        struct adm9240_data *data = adm9240_update_device(dev);
 479        return sprintf(buf, "%d\n", AOUT_FROM_REG(data->aout));
 480}
 481
 482static ssize_t set_aout(struct device *dev,
 483                struct device_attribute *attr,
 484                const char *buf, size_t count)
 485{
 486        struct i2c_client *client = to_i2c_client(dev);
 487        struct adm9240_data *data = i2c_get_clientdata(client);
 488        long val;
 489        int err;
 490
 491        err = kstrtol(buf, 10, &val);
 492        if (err)
 493                return err;
 494
 495        mutex_lock(&data->update_lock);
 496        data->aout = AOUT_TO_REG(val);
 497        i2c_smbus_write_byte_data(client, ADM9240_REG_ANALOG_OUT, data->aout);
 498        mutex_unlock(&data->update_lock);
 499        return count;
 500}
 501static DEVICE_ATTR(aout_output, S_IRUGO | S_IWUSR, show_aout, set_aout);
 502
 503/* chassis_clear */
 504static ssize_t chassis_clear_legacy(struct device *dev,
 505                struct device_attribute *attr,
 506                const char *buf, size_t count)
 507{
 508        struct i2c_client *client = to_i2c_client(dev);
 509        long val;
 510        int err;
 511
 512        err = kstrtol(buf, 10, &val);
 513        if (err)
 514                return err;
 515
 516        dev_warn(dev, "Attribute chassis_clear is deprecated, "
 517                 "use intrusion0_alarm instead\n");
 518
 519        if (val == 1) {
 520                i2c_smbus_write_byte_data(client,
 521                                ADM9240_REG_CHASSIS_CLEAR, 0x80);
 522                dev_dbg(&client->dev, "chassis intrusion latch cleared\n");
 523        }
 524        return count;
 525}
 526static DEVICE_ATTR(chassis_clear, S_IWUSR, NULL, chassis_clear_legacy);
 527
 528static ssize_t chassis_clear(struct device *dev,
 529                struct device_attribute *attr,
 530                const char *buf, size_t count)
 531{
 532        struct i2c_client *client = to_i2c_client(dev);
 533        struct adm9240_data *data = i2c_get_clientdata(client);
 534        unsigned long val;
 535
 536        if (kstrtoul(buf, 10, &val) || val != 0)
 537                return -EINVAL;
 538
 539        mutex_lock(&data->update_lock);
 540        i2c_smbus_write_byte_data(client, ADM9240_REG_CHASSIS_CLEAR, 0x80);
 541        data->valid = 0;                /* Force cache refresh */
 542        mutex_unlock(&data->update_lock);
 543        dev_dbg(&client->dev, "chassis intrusion latch cleared\n");
 544
 545        return count;
 546}
 547static SENSOR_DEVICE_ATTR(intrusion0_alarm, S_IRUGO | S_IWUSR, show_alarm,
 548                chassis_clear, 12);
 549
 550static struct attribute *adm9240_attributes[] = {
 551        &sensor_dev_attr_in0_input.dev_attr.attr,
 552        &sensor_dev_attr_in0_min.dev_attr.attr,
 553        &sensor_dev_attr_in0_max.dev_attr.attr,
 554        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 555        &sensor_dev_attr_in1_input.dev_attr.attr,
 556        &sensor_dev_attr_in1_min.dev_attr.attr,
 557        &sensor_dev_attr_in1_max.dev_attr.attr,
 558        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 559        &sensor_dev_attr_in2_input.dev_attr.attr,
 560        &sensor_dev_attr_in2_min.dev_attr.attr,
 561        &sensor_dev_attr_in2_max.dev_attr.attr,
 562        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 563        &sensor_dev_attr_in3_input.dev_attr.attr,
 564        &sensor_dev_attr_in3_min.dev_attr.attr,
 565        &sensor_dev_attr_in3_max.dev_attr.attr,
 566        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 567        &sensor_dev_attr_in4_input.dev_attr.attr,
 568        &sensor_dev_attr_in4_min.dev_attr.attr,
 569        &sensor_dev_attr_in4_max.dev_attr.attr,
 570        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 571        &sensor_dev_attr_in5_input.dev_attr.attr,
 572        &sensor_dev_attr_in5_min.dev_attr.attr,
 573        &sensor_dev_attr_in5_max.dev_attr.attr,
 574        &sensor_dev_attr_in5_alarm.dev_attr.attr,
 575        &dev_attr_temp1_input.attr,
 576        &sensor_dev_attr_temp1_max.dev_attr.attr,
 577        &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
 578        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 579        &sensor_dev_attr_fan1_input.dev_attr.attr,
 580        &sensor_dev_attr_fan1_div.dev_attr.attr,
 581        &sensor_dev_attr_fan1_min.dev_attr.attr,
 582        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 583        &sensor_dev_attr_fan2_input.dev_attr.attr,
 584        &sensor_dev_attr_fan2_div.dev_attr.attr,
 585        &sensor_dev_attr_fan2_min.dev_attr.attr,
 586        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 587        &dev_attr_alarms.attr,
 588        &dev_attr_aout_output.attr,
 589        &dev_attr_chassis_clear.attr,
 590        &sensor_dev_attr_intrusion0_alarm.dev_attr.attr,
 591        &dev_attr_cpu0_vid.attr,
 592        NULL
 593};
 594
 595static const struct attribute_group adm9240_group = {
 596        .attrs = adm9240_attributes,
 597};
 598
 599
 600/*** sensor chip detect and driver install ***/
 601
 602/* Return 0 if detection is successful, -ENODEV otherwise */
 603static int adm9240_detect(struct i2c_client *new_client,
 604                          struct i2c_board_info *info)
 605{
 606        struct i2c_adapter *adapter = new_client->adapter;
 607        const char *name = "";
 608        int address = new_client->addr;
 609        u8 man_id, die_rev;
 610
 611        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 612                return -ENODEV;
 613
 614        /* verify chip: reg address should match i2c address */
 615        if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR)
 616                        != address) {
 617                dev_err(&adapter->dev, "detect fail: address match, 0x%02x\n",
 618                        address);
 619                return -ENODEV;
 620        }
 621
 622        /* check known chip manufacturer */
 623        man_id = i2c_smbus_read_byte_data(new_client, ADM9240_REG_MAN_ID);
 624        if (man_id == 0x23) {
 625                name = "adm9240";
 626        } else if (man_id == 0xda) {
 627                name = "ds1780";
 628        } else if (man_id == 0x01) {
 629                name = "lm81";
 630        } else {
 631                dev_err(&adapter->dev, "detect fail: unknown manuf, 0x%02x\n",
 632                        man_id);
 633                return -ENODEV;
 634        }
 635
 636        /* successful detect, print chip info */
 637        die_rev = i2c_smbus_read_byte_data(new_client, ADM9240_REG_DIE_REV);
 638        dev_info(&adapter->dev, "found %s revision %u\n",
 639                 man_id == 0x23 ? "ADM9240" :
 640                 man_id == 0xda ? "DS1780" : "LM81", die_rev);
 641
 642        strlcpy(info->type, name, I2C_NAME_SIZE);
 643
 644        return 0;
 645}
 646
 647static int adm9240_probe(struct i2c_client *new_client,
 648                         const struct i2c_device_id *id)
 649{
 650        struct adm9240_data *data;
 651        int err;
 652
 653        data = devm_kzalloc(&new_client->dev, sizeof(*data), GFP_KERNEL);
 654        if (!data)
 655                return -ENOMEM;
 656
 657        i2c_set_clientdata(new_client, data);
 658        mutex_init(&data->update_lock);
 659
 660        adm9240_init_client(new_client);
 661
 662        /* populate sysfs filesystem */
 663        err = sysfs_create_group(&new_client->dev.kobj, &adm9240_group);
 664        if (err)
 665                return err;
 666
 667        data->hwmon_dev = hwmon_device_register(&new_client->dev);
 668        if (IS_ERR(data->hwmon_dev)) {
 669                err = PTR_ERR(data->hwmon_dev);
 670                goto exit_remove;
 671        }
 672
 673        return 0;
 674
 675exit_remove:
 676        sysfs_remove_group(&new_client->dev.kobj, &adm9240_group);
 677        return err;
 678}
 679
 680static int adm9240_remove(struct i2c_client *client)
 681{
 682        struct adm9240_data *data = i2c_get_clientdata(client);
 683
 684        hwmon_device_unregister(data->hwmon_dev);
 685        sysfs_remove_group(&client->dev.kobj, &adm9240_group);
 686
 687        return 0;
 688}
 689
 690static void adm9240_init_client(struct i2c_client *client)
 691{
 692        struct adm9240_data *data = i2c_get_clientdata(client);
 693        u8 conf = i2c_smbus_read_byte_data(client, ADM9240_REG_CONFIG);
 694        u8 mode = i2c_smbus_read_byte_data(client, ADM9240_REG_TEMP_CONF) & 3;
 695
 696        data->vrm = vid_which_vrm(); /* need this to report vid as mV */
 697
 698        dev_info(&client->dev, "Using VRM: %d.%d\n", data->vrm / 10,
 699                        data->vrm % 10);
 700
 701        if (conf & 1) { /* measurement cycle running: report state */
 702
 703                dev_info(&client->dev, "status: config 0x%02x mode %u\n",
 704                                conf, mode);
 705
 706        } else { /* cold start: open limits before starting chip */
 707                int i;
 708
 709                for (i = 0; i < 6; i++) {
 710                        i2c_smbus_write_byte_data(client,
 711                                        ADM9240_REG_IN_MIN(i), 0);
 712                        i2c_smbus_write_byte_data(client,
 713                                        ADM9240_REG_IN_MAX(i), 255);
 714                }
 715                i2c_smbus_write_byte_data(client,
 716                                ADM9240_REG_FAN_MIN(0), 255);
 717                i2c_smbus_write_byte_data(client,
 718                                ADM9240_REG_FAN_MIN(1), 255);
 719                i2c_smbus_write_byte_data(client,
 720                                ADM9240_REG_TEMP_MAX(0), 127);
 721                i2c_smbus_write_byte_data(client,
 722                                ADM9240_REG_TEMP_MAX(1), 127);
 723
 724                /* start measurement cycle */
 725                i2c_smbus_write_byte_data(client, ADM9240_REG_CONFIG, 1);
 726
 727                dev_info(&client->dev, "cold start: config was 0x%02x "
 728                                "mode %u\n", conf, mode);
 729        }
 730}
 731
 732static struct adm9240_data *adm9240_update_device(struct device *dev)
 733{
 734        struct i2c_client *client = to_i2c_client(dev);
 735        struct adm9240_data *data = i2c_get_clientdata(client);
 736        int i;
 737
 738        mutex_lock(&data->update_lock);
 739
 740        /* minimum measurement cycle: 1.75 seconds */
 741        if (time_after(jiffies, data->last_updated_measure + (HZ * 7 / 4))
 742                        || !data->valid) {
 743
 744                for (i = 0; i < 6; i++) { /* read voltages */
 745                        data->in[i] = i2c_smbus_read_byte_data(client,
 746                                        ADM9240_REG_IN(i));
 747                }
 748                data->alarms = i2c_smbus_read_byte_data(client,
 749                                        ADM9240_REG_INT(0)) |
 750                                        i2c_smbus_read_byte_data(client,
 751                                        ADM9240_REG_INT(1)) << 8;
 752
 753                /*
 754                 * read temperature: assume temperature changes less than
 755                 * 0.5'C per two measurement cycles thus ignore possible
 756                 * but unlikely aliasing error on lsb reading. --Grant
 757                 */
 758                data->temp = ((i2c_smbus_read_byte_data(client,
 759                                        ADM9240_REG_TEMP) << 8) |
 760                                        i2c_smbus_read_byte_data(client,
 761                                        ADM9240_REG_TEMP_CONF)) / 128;
 762
 763                for (i = 0; i < 2; i++) { /* read fans */
 764                        data->fan[i] = i2c_smbus_read_byte_data(client,
 765                                        ADM9240_REG_FAN(i));
 766
 767                        /* adjust fan clock divider on overflow */
 768                        if (data->valid && data->fan[i] == 255 &&
 769                                        data->fan_div[i] < 3) {
 770
 771                                adm9240_write_fan_div(client, i,
 772                                                ++data->fan_div[i]);
 773
 774                                /* adjust fan_min if active, but not to 0 */
 775                                if (data->fan_min[i] < 255 &&
 776                                                data->fan_min[i] >= 2)
 777                                        data->fan_min[i] /= 2;
 778                        }
 779                }
 780                data->last_updated_measure = jiffies;
 781        }
 782
 783        /* minimum config reading cycle: 300 seconds */
 784        if (time_after(jiffies, data->last_updated_config + (HZ * 300))
 785                        || !data->valid) {
 786
 787                for (i = 0; i < 6; i++) {
 788                        data->in_min[i] = i2c_smbus_read_byte_data(client,
 789                                        ADM9240_REG_IN_MIN(i));
 790                        data->in_max[i] = i2c_smbus_read_byte_data(client,
 791                                        ADM9240_REG_IN_MAX(i));
 792                }
 793                for (i = 0; i < 2; i++) {
 794                        data->fan_min[i] = i2c_smbus_read_byte_data(client,
 795                                        ADM9240_REG_FAN_MIN(i));
 796                }
 797                data->temp_max[0] = i2c_smbus_read_byte_data(client,
 798                                ADM9240_REG_TEMP_MAX(0));
 799                data->temp_max[1] = i2c_smbus_read_byte_data(client,
 800                                ADM9240_REG_TEMP_MAX(1));
 801
 802                /* read fan divs and 5-bit VID */
 803                i = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV);
 804                data->fan_div[0] = (i >> 4) & 3;
 805                data->fan_div[1] = (i >> 6) & 3;
 806                data->vid = i & 0x0f;
 807                data->vid |= (i2c_smbus_read_byte_data(client,
 808                                        ADM9240_REG_VID4) & 1) << 4;
 809                /* read analog out */
 810                data->aout = i2c_smbus_read_byte_data(client,
 811                                ADM9240_REG_ANALOG_OUT);
 812
 813                data->last_updated_config = jiffies;
 814                data->valid = 1;
 815        }
 816        mutex_unlock(&data->update_lock);
 817        return data;
 818}
 819
 820module_i2c_driver(adm9240_driver);
 821
 822MODULE_AUTHOR("Michiel Rook <michiel@grendelproject.nl>, "
 823                "Grant Coady <gcoady.lk@gmail.com> and others");
 824MODULE_DESCRIPTION("ADM9240/DS1780/LM81 driver");
 825MODULE_LICENSE("GPL");
 826
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.