linux/drivers/hwmon/lm90.c
<<
>>
Prefs
   1/*
   2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *          monitoring
   4 * Copyright (C) 2003-2010  Jean Delvare <khali@linux-fr.org>
   5 *
   6 * Based on the lm83 driver. The LM90 is a sensor chip made by National
   7 * Semiconductor. It reports up to two temperatures (its own plus up to
   8 * one external one) with a 0.125 deg resolution (1 deg for local
   9 * temperature) and a 3-4 deg accuracy.
  10 *
  11 * This driver also supports the LM89 and LM99, two other sensor chips
  12 * made by National Semiconductor. Both have an increased remote
  13 * temperature measurement accuracy (1 degree), and the LM99
  14 * additionally shifts remote temperatures (measured and limits) by 16
  15 * degrees, which allows for higher temperatures measurement.
  16 * Note that there is no way to differentiate between both chips.
  17 * When device is auto-detected, the driver will assume an LM99.
  18 *
  19 * This driver also supports the LM86, another sensor chip made by
  20 * National Semiconductor. It is exactly similar to the LM90 except it
  21 * has a higher accuracy.
  22 *
  23 * This driver also supports the ADM1032, a sensor chip made by Analog
  24 * Devices. That chip is similar to the LM90, with a few differences
  25 * that are not handled by this driver. Among others, it has a higher
  26 * accuracy than the LM90, much like the LM86 does.
  27 *
  28 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
  29 * chips made by Maxim. These chips are similar to the LM86.
  30 * Note that there is no easy way to differentiate between the three
  31 * variants. We use the device address to detect MAX6659, which will result
  32 * in a detection as max6657 if it is on address 0x4c. The extra address
  33 * and features of the MAX6659 are only supported if the chip is configured
  34 * explicitly as max6659, or if its address is not 0x4c.
  35 * These chips lack the remote temperature offset feature.
  36 *
  37 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
  38 * MAX6692 chips made by Maxim.  These are again similar to the LM86,
  39 * but they use unsigned temperature values and can report temperatures
  40 * from 0 to 145 degrees.
  41 *
  42 * This driver also supports the MAX6680 and MAX6681, two other sensor
  43 * chips made by Maxim. These are quite similar to the other Maxim
  44 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
  45 * be treated identically.
  46 *
  47 * This driver also supports the MAX6695 and MAX6696, two other sensor
  48 * chips made by Maxim. These are also quite similar to other Maxim
  49 * chips, but support three temperature sensors instead of two. MAX6695
  50 * and MAX6696 only differ in the pinout so they can be treated identically.
  51 *
  52 * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as
  53 * NCT1008 from ON Semiconductor. The chips are supported in both compatibility
  54 * and extended mode. They are mostly compatible with LM90 except for a data
  55 * format difference for the temperature value registers.
  56 *
  57 * This driver also supports the SA56004 from Philips. This device is
  58 * pin-compatible with the LM86, the ED/EDP parts are also address-compatible.
  59 *
  60 * This driver also supports the G781 from GMT. This device is compatible
  61 * with the ADM1032.
  62 *
  63 * Since the LM90 was the first chipset supported by this driver, most
  64 * comments will refer to this chipset, but are actually general and
  65 * concern all supported chipsets, unless mentioned otherwise.
  66 *
  67 * This program is free software; you can redistribute it and/or modify
  68 * it under the terms of the GNU General Public License as published by
  69 * the Free Software Foundation; either version 2 of the License, or
  70 * (at your option) any later version.
  71 *
  72 * This program is distributed in the hope that it will be useful,
  73 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  74 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  75 * GNU General Public License for more details.
  76 *
  77 * You should have received a copy of the GNU General Public License
  78 * along with this program; if not, write to the Free Software
  79 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  80 */
  81
  82#include <linux/module.h>
  83#include <linux/init.h>
  84#include <linux/slab.h>
  85#include <linux/jiffies.h>
  86#include <linux/i2c.h>
  87#include <linux/hwmon-sysfs.h>
  88#include <linux/hwmon.h>
  89#include <linux/err.h>
  90#include <linux/mutex.h>
  91#include <linux/sysfs.h>
  92
  93/*
  94 * Addresses to scan
  95 * Address is fully defined internally and cannot be changed except for
  96 * MAX6659, MAX6680 and MAX6681.
  97 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,
  98 * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.
  99 * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D
 100 * have address 0x4d.
 101 * MAX6647 has address 0x4e.
 102 * MAX6659 can have address 0x4c, 0x4d or 0x4e.
 103 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
 104 * 0x4c, 0x4d or 0x4e.
 105 * SA56004 can have address 0x48 through 0x4F.
 106 */
 107
 108static const unsigned short normal_i2c[] = {
 109        0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
 110        0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 111
 112enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
 113        max6646, w83l771, max6696, sa56004, g781 };
 114
 115/*
 116 * The LM90 registers
 117 */
 118
 119#define LM90_REG_R_MAN_ID               0xFE
 120#define LM90_REG_R_CHIP_ID              0xFF
 121#define LM90_REG_R_CONFIG1              0x03
 122#define LM90_REG_W_CONFIG1              0x09
 123#define LM90_REG_R_CONFIG2              0xBF
 124#define LM90_REG_W_CONFIG2              0xBF
 125#define LM90_REG_R_CONVRATE             0x04
 126#define LM90_REG_W_CONVRATE             0x0A
 127#define LM90_REG_R_STATUS               0x02
 128#define LM90_REG_R_LOCAL_TEMP           0x00
 129#define LM90_REG_R_LOCAL_HIGH           0x05
 130#define LM90_REG_W_LOCAL_HIGH           0x0B
 131#define LM90_REG_R_LOCAL_LOW            0x06
 132#define LM90_REG_W_LOCAL_LOW            0x0C
 133#define LM90_REG_R_LOCAL_CRIT           0x20
 134#define LM90_REG_W_LOCAL_CRIT           0x20
 135#define LM90_REG_R_REMOTE_TEMPH         0x01
 136#define LM90_REG_R_REMOTE_TEMPL         0x10
 137#define LM90_REG_R_REMOTE_OFFSH         0x11
 138#define LM90_REG_W_REMOTE_OFFSH         0x11
 139#define LM90_REG_R_REMOTE_OFFSL         0x12
 140#define LM90_REG_W_REMOTE_OFFSL         0x12
 141#define LM90_REG_R_REMOTE_HIGHH         0x07
 142#define LM90_REG_W_REMOTE_HIGHH         0x0D
 143#define LM90_REG_R_REMOTE_HIGHL         0x13
 144#define LM90_REG_W_REMOTE_HIGHL         0x13
 145#define LM90_REG_R_REMOTE_LOWH          0x08
 146#define LM90_REG_W_REMOTE_LOWH          0x0E
 147#define LM90_REG_R_REMOTE_LOWL          0x14
 148#define LM90_REG_W_REMOTE_LOWL          0x14
 149#define LM90_REG_R_REMOTE_CRIT          0x19
 150#define LM90_REG_W_REMOTE_CRIT          0x19
 151#define LM90_REG_R_TCRIT_HYST           0x21
 152#define LM90_REG_W_TCRIT_HYST           0x21
 153
 154/* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */
 155
 156#define MAX6657_REG_R_LOCAL_TEMPL       0x11
 157#define MAX6696_REG_R_STATUS2           0x12
 158#define MAX6659_REG_R_REMOTE_EMERG      0x16
 159#define MAX6659_REG_W_REMOTE_EMERG      0x16
 160#define MAX6659_REG_R_LOCAL_EMERG       0x17
 161#define MAX6659_REG_W_LOCAL_EMERG       0x17
 162
 163/*  SA56004 registers */
 164
 165#define SA56004_REG_R_LOCAL_TEMPL 0x22
 166
 167#define LM90_DEF_CONVRATE_RVAL  6       /* Def conversion rate register value */
 168#define LM90_MAX_CONVRATE_MS    16000   /* Maximum conversion rate in ms */
 169
 170/*
 171 * Device flags
 172 */
 173#define LM90_FLAG_ADT7461_EXT   (1 << 0) /* ADT7461 extended mode       */
 174/* Device features */
 175#define LM90_HAVE_OFFSET        (1 << 1) /* temperature offset register */
 176#define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit       */
 177#define LM90_HAVE_EMERGENCY     (1 << 4) /* 3rd upper (emergency) limit */
 178#define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm            */
 179#define LM90_HAVE_TEMP3         (1 << 6) /* 3rd temperature sensor      */
 180#define LM90_HAVE_BROKEN_ALERT  (1 << 7) /* Broken alert                */
 181
 182/*
 183 * Driver data (common to all clients)
 184 */
 185
 186static const struct i2c_device_id lm90_id[] = {
 187        { "adm1032", adm1032 },
 188        { "adt7461", adt7461 },
 189        { "adt7461a", adt7461 },
 190        { "g781", g781 },
 191        { "lm90", lm90 },
 192        { "lm86", lm86 },
 193        { "lm89", lm86 },
 194        { "lm99", lm99 },
 195        { "max6646", max6646 },
 196        { "max6647", max6646 },
 197        { "max6649", max6646 },
 198        { "max6657", max6657 },
 199        { "max6658", max6657 },
 200        { "max6659", max6659 },
 201        { "max6680", max6680 },
 202        { "max6681", max6680 },
 203        { "max6695", max6696 },
 204        { "max6696", max6696 },
 205        { "nct1008", adt7461 },
 206        { "w83l771", w83l771 },
 207        { "sa56004", sa56004 },
 208        { }
 209};
 210MODULE_DEVICE_TABLE(i2c, lm90_id);
 211
 212/*
 213 * chip type specific parameters
 214 */
 215struct lm90_params {
 216        u32 flags;              /* Capabilities */
 217        u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
 218                                /* Upper 8 bits for max6695/96 */
 219        u8 max_convrate;        /* Maximum conversion rate register value */
 220        u8 reg_local_ext;       /* Extended local temp register (optional) */
 221};
 222
 223static const struct lm90_params lm90_params[] = {
 224        [adm1032] = {
 225                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 226                  | LM90_HAVE_BROKEN_ALERT,
 227                .alert_alarms = 0x7c,
 228                .max_convrate = 10,
 229        },
 230        [adt7461] = {
 231                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 232                  | LM90_HAVE_BROKEN_ALERT,
 233                .alert_alarms = 0x7c,
 234                .max_convrate = 10,
 235        },
 236        [g781] = {
 237                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 238                  | LM90_HAVE_BROKEN_ALERT,
 239                .alert_alarms = 0x7c,
 240                .max_convrate = 8,
 241        },
 242        [lm86] = {
 243                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 244                .alert_alarms = 0x7b,
 245                .max_convrate = 9,
 246        },
 247        [lm90] = {
 248                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 249                .alert_alarms = 0x7b,
 250                .max_convrate = 9,
 251        },
 252        [lm99] = {
 253                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 254                .alert_alarms = 0x7b,
 255                .max_convrate = 9,
 256        },
 257        [max6646] = {
 258                .alert_alarms = 0x7c,
 259                .max_convrate = 6,
 260                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 261        },
 262        [max6657] = {
 263                .alert_alarms = 0x7c,
 264                .max_convrate = 8,
 265                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 266        },
 267        [max6659] = {
 268                .flags = LM90_HAVE_EMERGENCY,
 269                .alert_alarms = 0x7c,
 270                .max_convrate = 8,
 271                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 272        },
 273        [max6680] = {
 274                .flags = LM90_HAVE_OFFSET,
 275                .alert_alarms = 0x7c,
 276                .max_convrate = 7,
 277        },
 278        [max6696] = {
 279                .flags = LM90_HAVE_EMERGENCY
 280                  | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,
 281                .alert_alarms = 0x187c,
 282                .max_convrate = 6,
 283                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 284        },
 285        [w83l771] = {
 286                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 287                .alert_alarms = 0x7c,
 288                .max_convrate = 8,
 289        },
 290        [sa56004] = {
 291                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 292                .alert_alarms = 0x7b,
 293                .max_convrate = 9,
 294                .reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,
 295        },
 296};
 297
 298/*
 299 * Client data (each client gets its own)
 300 */
 301
 302struct lm90_data {
 303        struct device *hwmon_dev;
 304        struct mutex update_lock;
 305        char valid; /* zero until following fields are valid */
 306        unsigned long last_updated; /* in jiffies */
 307        int kind;
 308        u32 flags;
 309
 310        int update_interval;    /* in milliseconds */
 311
 312        u8 config_orig;         /* Original configuration register value */
 313        u8 convrate_orig;       /* Original conversion rate register value */
 314        u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
 315                                /* Upper 8 bits for max6695/96 */
 316        u8 max_convrate;        /* Maximum conversion rate */
 317        u8 reg_local_ext;       /* local extension register offset */
 318
 319        /* registers values */
 320        s8 temp8[8];    /* 0: local low limit
 321                         * 1: local high limit
 322                         * 2: local critical limit
 323                         * 3: remote critical limit
 324                         * 4: local emergency limit (max6659 and max6695/96)
 325                         * 5: remote emergency limit (max6659 and max6695/96)
 326                         * 6: remote 2 critical limit (max6695/96 only)
 327                         * 7: remote 2 emergency limit (max6695/96 only)
 328                         */
 329        s16 temp11[8];  /* 0: remote input
 330                         * 1: remote low limit
 331                         * 2: remote high limit
 332                         * 3: remote offset (except max6646, max6657/58/59,
 333                         *                   and max6695/96)
 334                         * 4: local input
 335                         * 5: remote 2 input (max6695/96 only)
 336                         * 6: remote 2 low limit (max6695/96 only)
 337                         * 7: remote 2 high limit (max6695/96 only)
 338                         */
 339        u8 temp_hyst;
 340        u16 alarms; /* bitvector (upper 8 bits for max6695/96) */
 341};
 342
 343/*
 344 * Support functions
 345 */
 346
 347/*
 348 * The ADM1032 supports PEC but not on write byte transactions, so we need
 349 * to explicitly ask for a transaction without PEC.
 350 */
 351static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 352{
 353        return i2c_smbus_xfer(client->adapter, client->addr,
 354                              client->flags & ~I2C_CLIENT_PEC,
 355                              I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 356}
 357
 358/*
 359 * It is assumed that client->update_lock is held (unless we are in
 360 * detection or initialization steps). This matters when PEC is enabled,
 361 * because we don't want the address pointer to change between the write
 362 * byte and the read byte transactions.
 363 */
 364static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)
 365{
 366        int err;
 367
 368        if (client->flags & I2C_CLIENT_PEC) {
 369                err = adm1032_write_byte(client, reg);
 370                if (err >= 0)
 371                        err = i2c_smbus_read_byte(client);
 372        } else
 373                err = i2c_smbus_read_byte_data(client, reg);
 374
 375        if (err < 0) {
 376                dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 377                         reg, err);
 378                return err;
 379        }
 380        *value = err;
 381
 382        return 0;
 383}
 384
 385static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
 386{
 387        int err;
 388        u8 oldh, newh, l;
 389
 390        /*
 391         * There is a trick here. We have to read two registers to have the
 392         * sensor temperature, but we have to beware a conversion could occur
 393         * between the readings. The datasheet says we should either use
 394         * the one-shot conversion register, which we don't want to do
 395         * (disables hardware monitoring) or monitor the busy bit, which is
 396         * impossible (we can't read the values and monitor that bit at the
 397         * exact same time). So the solution used here is to read the high
 398         * byte once, then the low byte, then the high byte again. If the new
 399         * high byte matches the old one, then we have a valid reading. Else
 400         * we have to read the low byte again, and now we believe we have a
 401         * correct reading.
 402         */
 403        if ((err = lm90_read_reg(client, regh, &oldh))
 404         || (err = lm90_read_reg(client, regl, &l))
 405         || (err = lm90_read_reg(client, regh, &newh)))
 406                return err;
 407        if (oldh != newh) {
 408                err = lm90_read_reg(client, regl, &l);
 409                if (err)
 410                        return err;
 411        }
 412        *value = (newh << 8) | l;
 413
 414        return 0;
 415}
 416
 417/*
 418 * client->update_lock must be held when calling this function (unless we are
 419 * in detection or initialization steps), and while a remote channel other
 420 * than channel 0 is selected. Also, calling code must make sure to re-select
 421 * external channel 0 before releasing the lock. This is necessary because
 422 * various registers have different meanings as a result of selecting a
 423 * non-default remote channel.
 424 */
 425static inline void lm90_select_remote_channel(struct i2c_client *client,
 426                                              struct lm90_data *data,
 427                                              int channel)
 428{
 429        u8 config;
 430
 431        if (data->kind == max6696) {
 432                lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
 433                config &= ~0x08;
 434                if (channel)
 435                        config |= 0x08;
 436                i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
 437                                          config);
 438        }
 439}
 440
 441/*
 442 * Set conversion rate.
 443 * client->update_lock must be held when calling this function (unless we are
 444 * in detection or initialization steps).
 445 */
 446static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
 447                              unsigned int interval)
 448{
 449        int i;
 450        unsigned int update_interval;
 451
 452        /* Shift calculations to avoid rounding errors */
 453        interval <<= 6;
 454
 455        /* find the nearest update rate */
 456        for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;
 457             i < data->max_convrate; i++, update_interval >>= 1)
 458                if (interval >= update_interval * 3 / 4)
 459                        break;
 460
 461        i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, i);
 462        data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);
 463}
 464
 465static struct lm90_data *lm90_update_device(struct device *dev)
 466{
 467        struct i2c_client *client = to_i2c_client(dev);
 468        struct lm90_data *data = i2c_get_clientdata(client);
 469        unsigned long next_update;
 470
 471        mutex_lock(&data->update_lock);
 472
 473        next_update = data->last_updated
 474          + msecs_to_jiffies(data->update_interval) + 1;
 475        if (time_after(jiffies, next_update) || !data->valid) {
 476                u8 h, l;
 477                u8 alarms;
 478
 479                dev_dbg(&client->dev, "Updating lm90 data.\n");
 480                lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
 481                lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
 482                lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
 483                lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
 484                lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 485
 486                if (data->reg_local_ext) {
 487                        lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
 488                                    data->reg_local_ext,
 489                                    &data->temp11[4]);
 490                } else {
 491                        if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
 492                                          &h) == 0)
 493                                data->temp11[4] = h << 8;
 494                }
 495                lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 496                            LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
 497
 498                if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
 499                        data->temp11[1] = h << 8;
 500                        if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
 501                         && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
 502                                          &l) == 0)
 503                                data->temp11[1] |= l;
 504                }
 505                if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
 506                        data->temp11[2] = h << 8;
 507                        if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
 508                         && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
 509                                          &l) == 0)
 510                                data->temp11[2] |= l;
 511                }
 512
 513                if (data->flags & LM90_HAVE_OFFSET) {
 514                        if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 515                                          &h) == 0
 516                         && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 517                                          &l) == 0)
 518                                data->temp11[3] = (h << 8) | l;
 519                }
 520                if (data->flags & LM90_HAVE_EMERGENCY) {
 521                        lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG,
 522                                      &data->temp8[4]);
 523                        lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,
 524                                      &data->temp8[5]);
 525                }
 526                lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
 527                data->alarms = alarms;  /* save as 16 bit value */
 528
 529                if (data->kind == max6696) {
 530                        lm90_select_remote_channel(client, data, 1);
 531                        lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT,
 532                                      &data->temp8[6]);
 533                        lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,
 534                                      &data->temp8[7]);
 535                        lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 536                                    LM90_REG_R_REMOTE_TEMPL, &data->temp11[5]);
 537                        if (!lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h))
 538                                data->temp11[6] = h << 8;
 539                        if (!lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h))
 540                                data->temp11[7] = h << 8;
 541                        lm90_select_remote_channel(client, data, 0);
 542
 543                        if (!lm90_read_reg(client, MAX6696_REG_R_STATUS2,
 544                                           &alarms))
 545                                data->alarms |= alarms << 8;
 546                }
 547
 548                /*
 549                 * Re-enable ALERT# output if it was originally enabled and
 550                 * relevant alarms are all clear
 551                 */
 552                if ((data->config_orig & 0x80) == 0
 553                 && (data->alarms & data->alert_alarms) == 0) {
 554                        u8 config;
 555
 556                        lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
 557                        if (config & 0x80) {
 558                                dev_dbg(&client->dev, "Re-enabling ALERT#\n");
 559                                i2c_smbus_write_byte_data(client,
 560                                                          LM90_REG_W_CONFIG1,
 561                                                          config & ~0x80);
 562                        }
 563                }
 564
 565                data->last_updated = jiffies;
 566                data->valid = 1;
 567        }
 568
 569        mutex_unlock(&data->update_lock);
 570
 571        return data;
 572}
 573
 574/*
 575 * Conversions
 576 * For local temperatures and limits, critical limits and the hysteresis
 577 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 578 * For remote temperatures and limits, it uses signed 11-bit values with
 579 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 580 * Maxim chips use unsigned values.
 581 */
 582
 583static inline int temp_from_s8(s8 val)
 584{
 585        return val * 1000;
 586}
 587
 588static inline int temp_from_u8(u8 val)
 589{
 590        return val * 1000;
 591}
 592
 593static inline int temp_from_s16(s16 val)
 594{
 595        return val / 32 * 125;
 596}
 597
 598static inline int temp_from_u16(u16 val)
 599{
 600        return val / 32 * 125;
 601}
 602
 603static s8 temp_to_s8(long val)
 604{
 605        if (val <= -128000)
 606                return -128;
 607        if (val >= 127000)
 608                return 127;
 609        if (val < 0)
 610                return (val - 500) / 1000;
 611        return (val + 500) / 1000;
 612}
 613
 614static u8 temp_to_u8(long val)
 615{
 616        if (val <= 0)
 617                return 0;
 618        if (val >= 255000)
 619                return 255;
 620        return (val + 500) / 1000;
 621}
 622
 623static s16 temp_to_s16(long val)
 624{
 625        if (val <= -128000)
 626                return 0x8000;
 627        if (val >= 127875)
 628                return 0x7FE0;
 629        if (val < 0)
 630                return (val - 62) / 125 * 32;
 631        return (val + 62) / 125 * 32;
 632}
 633
 634static u8 hyst_to_reg(long val)
 635{
 636        if (val <= 0)
 637                return 0;
 638        if (val >= 30500)
 639                return 31;
 640        return (val + 500) / 1000;
 641}
 642
 643/*
 644 * ADT7461 in compatibility mode is almost identical to LM90 except that
 645 * attempts to write values that are outside the range 0 < temp < 127 are
 646 * treated as the boundary value.
 647 *
 648 * ADT7461 in "extended mode" operation uses unsigned integers offset by
 649 * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
 650 */
 651static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
 652{
 653        if (data->flags & LM90_FLAG_ADT7461_EXT)
 654                return (val - 64) * 1000;
 655        else
 656                return temp_from_s8(val);
 657}
 658
 659static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
 660{
 661        if (data->flags & LM90_FLAG_ADT7461_EXT)
 662                return (val - 0x4000) / 64 * 250;
 663        else
 664                return temp_from_s16(val);
 665}
 666
 667static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
 668{
 669        if (data->flags & LM90_FLAG_ADT7461_EXT) {
 670                if (val <= -64000)
 671                        return 0;
 672                if (val >= 191000)
 673                        return 0xFF;
 674                return (val + 500 + 64000) / 1000;
 675        } else {
 676                if (val <= 0)
 677                        return 0;
 678                if (val >= 127000)
 679                        return 127;
 680                return (val + 500) / 1000;
 681        }
 682}
 683
 684static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
 685{
 686        if (data->flags & LM90_FLAG_ADT7461_EXT) {
 687                if (val <= -64000)
 688                        return 0;
 689                if (val >= 191750)
 690                        return 0xFFC0;
 691                return (val + 64000 + 125) / 250 * 64;
 692        } else {
 693                if (val <= 0)
 694                        return 0;
 695                if (val >= 127750)
 696                        return 0x7FC0;
 697                return (val + 125) / 250 * 64;
 698        }
 699}
 700
 701/*
 702 * Sysfs stuff
 703 */
 704
 705static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 706                          char *buf)
 707{
 708        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 709        struct lm90_data *data = lm90_update_device(dev);
 710        int temp;
 711
 712        if (data->kind == adt7461)
 713                temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 714        else if (data->kind == max6646)
 715                temp = temp_from_u8(data->temp8[attr->index]);
 716        else
 717                temp = temp_from_s8(data->temp8[attr->index]);
 718
 719        /* +16 degrees offset for temp2 for the LM99 */
 720        if (data->kind == lm99 && attr->index == 3)
 721                temp += 16000;
 722
 723        return sprintf(buf, "%d\n", temp);
 724}
 725
 726static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 727                         const char *buf, size_t count)
 728{
 729        static const u8 reg[8] = {
 730                LM90_REG_W_LOCAL_LOW,
 731                LM90_REG_W_LOCAL_HIGH,
 732                LM90_REG_W_LOCAL_CRIT,
 733                LM90_REG_W_REMOTE_CRIT,
 734                MAX6659_REG_W_LOCAL_EMERG,
 735                MAX6659_REG_W_REMOTE_EMERG,
 736                LM90_REG_W_REMOTE_CRIT,
 737                MAX6659_REG_W_REMOTE_EMERG,
 738        };
 739
 740        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 741        struct i2c_client *client = to_i2c_client(dev);
 742        struct lm90_data *data = i2c_get_clientdata(client);
 743        int nr = attr->index;
 744        long val;
 745        int err;
 746
 747        err = kstrtol(buf, 10, &val);
 748        if (err < 0)
 749                return err;
 750
 751        /* +16 degrees offset for temp2 for the LM99 */
 752        if (data->kind == lm99 && attr->index == 3)
 753                val -= 16000;
 754
 755        mutex_lock(&data->update_lock);
 756        if (data->kind == adt7461)
 757                data->temp8[nr] = temp_to_u8_adt7461(data, val);
 758        else if (data->kind == max6646)
 759                data->temp8[nr] = temp_to_u8(val);
 760        else
 761                data->temp8[nr] = temp_to_s8(val);
 762
 763        lm90_select_remote_channel(client, data, nr >= 6);
 764        i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
 765        lm90_select_remote_channel(client, data, 0);
 766
 767        mutex_unlock(&data->update_lock);
 768        return count;
 769}
 770
 771static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 772                           char *buf)
 773{
 774        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 775        struct lm90_data *data = lm90_update_device(dev);
 776        int temp;
 777
 778        if (data->kind == adt7461)
 779                temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
 780        else if (data->kind == max6646)
 781                temp = temp_from_u16(data->temp11[attr->index]);
 782        else
 783                temp = temp_from_s16(data->temp11[attr->index]);
 784
 785        /* +16 degrees offset for temp2 for the LM99 */
 786        if (data->kind == lm99 &&  attr->index <= 2)
 787                temp += 16000;
 788
 789        return sprintf(buf, "%d\n", temp);
 790}
 791
 792static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 793                          const char *buf, size_t count)
 794{
 795        struct {
 796                u8 high;
 797                u8 low;
 798                int channel;
 799        } reg[5] = {
 800                { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 0 },
 801                { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 0 },
 802                { LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL, 0 },
 803                { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 1 },
 804                { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 1 }
 805        };
 806
 807        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 808        struct i2c_client *client = to_i2c_client(dev);
 809        struct lm90_data *data = i2c_get_clientdata(client);
 810        int nr = attr->nr;
 811        int index = attr->index;
 812        long val;
 813        int err;
 814
 815        err = kstrtol(buf, 10, &val);
 816        if (err < 0)
 817                return err;
 818
 819        /* +16 degrees offset for temp2 for the LM99 */
 820        if (data->kind == lm99 && index <= 2)
 821                val -= 16000;
 822
 823        mutex_lock(&data->update_lock);
 824        if (data->kind == adt7461)
 825                data->temp11[index] = temp_to_u16_adt7461(data, val);
 826        else if (data->kind == max6646)
 827                data->temp11[index] = temp_to_u8(val) << 8;
 828        else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 829                data->temp11[index] = temp_to_s16(val);
 830        else
 831                data->temp11[index] = temp_to_s8(val) << 8;
 832
 833        lm90_select_remote_channel(client, data, reg[nr].channel);
 834        i2c_smbus_write_byte_data(client, reg[nr].high,
 835                                  data->temp11[index] >> 8);
 836        if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 837                i2c_smbus_write_byte_data(client, reg[nr].low,
 838                                          data->temp11[index] & 0xff);
 839        lm90_select_remote_channel(client, data, 0);
 840
 841        mutex_unlock(&data->update_lock);
 842        return count;
 843}
 844
 845static ssize_t show_temphyst(struct device *dev,
 846                             struct device_attribute *devattr,
 847                             char *buf)
 848{
 849        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 850        struct lm90_data *data = lm90_update_device(dev);
 851        int temp;
 852
 853        if (data->kind == adt7461)
 854                temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 855        else if (data->kind == max6646)
 856                temp = temp_from_u8(data->temp8[attr->index]);
 857        else
 858                temp = temp_from_s8(data->temp8[attr->index]);
 859
 860        /* +16 degrees offset for temp2 for the LM99 */
 861        if (data->kind == lm99 && attr->index == 3)
 862                temp += 16000;
 863
 864        return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
 865}
 866
 867static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 868                            const char *buf, size_t count)
 869{
 870        struct i2c_client *client = to_i2c_client(dev);
 871        struct lm90_data *data = i2c_get_clientdata(client);
 872        long val;
 873        int err;
 874        int temp;
 875
 876        err = kstrtol(buf, 10, &val);
 877        if (err < 0)
 878                return err;
 879
 880        mutex_lock(&data->update_lock);
 881        if (data->kind == adt7461)
 882                temp = temp_from_u8_adt7461(data, data->temp8[2]);
 883        else if (data->kind == max6646)
 884                temp = temp_from_u8(data->temp8[2]);
 885        else
 886                temp = temp_from_s8(data->temp8[2]);
 887
 888        data->temp_hyst = hyst_to_reg(temp - val);
 889        i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 890                                  data->temp_hyst);
 891        mutex_unlock(&data->update_lock);
 892        return count;
 893}
 894
 895static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 896                           char *buf)
 897{
 898        struct lm90_data *data = lm90_update_device(dev);
 899        return sprintf(buf, "%d\n", data->alarms);
 900}
 901
 902static ssize_t show_alarm(struct device *dev, struct device_attribute
 903                          *devattr, char *buf)
 904{
 905        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 906        struct lm90_data *data = lm90_update_device(dev);
 907        int bitnr = attr->index;
 908
 909        return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 910}
 911
 912static ssize_t show_update_interval(struct device *dev,
 913                                    struct device_attribute *attr, char *buf)
 914{
 915        struct lm90_data *data = dev_get_drvdata(dev);
 916
 917        return sprintf(buf, "%u\n", data->update_interval);
 918}
 919
 920static ssize_t set_update_interval(struct device *dev,
 921                                   struct device_attribute *attr,
 922                                   const char *buf, size_t count)
 923{
 924        struct i2c_client *client = to_i2c_client(dev);
 925        struct lm90_data *data = i2c_get_clientdata(client);
 926        unsigned long val;
 927        int err;
 928
 929        err = kstrtoul(buf, 10, &val);
 930        if (err)
 931                return err;
 932
 933        mutex_lock(&data->update_lock);
 934        lm90_set_convrate(client, data, clamp_val(val, 0, 100000));
 935        mutex_unlock(&data->update_lock);
 936
 937        return count;
 938}
 939
 940static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);
 941static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);
 942static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 943        set_temp8, 0);
 944static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 945        set_temp11, 0, 1);
 946static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 947        set_temp8, 1);
 948static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 949        set_temp11, 1, 2);
 950static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 951        set_temp8, 2);
 952static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 953        set_temp8, 3);
 954static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 955        set_temphyst, 2);
 956static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 957static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 958        set_temp11, 2, 3);
 959
 960/* Individual alarm files */
 961static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 962static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 963static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 964static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 965static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 966static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 967static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 968/* Raw alarm file for compatibility */
 969static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 970
 971static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
 972                   set_update_interval);
 973
 974static struct attribute *lm90_attributes[] = {
 975        &sensor_dev_attr_temp1_input.dev_attr.attr,
 976        &sensor_dev_attr_temp2_input.dev_attr.attr,
 977        &sensor_dev_attr_temp1_min.dev_attr.attr,
 978        &sensor_dev_attr_temp2_min.dev_attr.attr,
 979        &sensor_dev_attr_temp1_max.dev_attr.attr,
 980        &sensor_dev_attr_temp2_max.dev_attr.attr,
 981        &sensor_dev_attr_temp1_crit.dev_attr.attr,
 982        &sensor_dev_attr_temp2_crit.dev_attr.attr,
 983        &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 984        &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 985
 986        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 987        &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 988        &sensor_dev_attr_temp2_fault.dev_attr.attr,
 989        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 990        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 991        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 992        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 993        &dev_attr_alarms.attr,
 994        &dev_attr_update_interval.attr,
 995        NULL
 996};
 997
 998static const struct attribute_group lm90_group = {
 999        .attrs = lm90_attributes,
1000};
1001
1002/*
1003 * Additional attributes for devices with emergency sensors
1004 */
1005static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8,
1006        set_temp8, 4);
1007static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8,
1008        set_temp8, 5);
1009static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst,
1010                          NULL, 4);
1011static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst,
1012                          NULL, 5);
1013
1014static struct attribute *lm90_emergency_attributes[] = {
1015        &sensor_dev_attr_temp1_emergency.dev_attr.attr,
1016        &sensor_dev_attr_temp2_emergency.dev_attr.attr,
1017        &sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,
1018        &sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr,
1019        NULL
1020};
1021
1022static const struct attribute_group lm90_emergency_group = {
1023        .attrs = lm90_emergency_attributes,
1024};
1025
1026static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 15);
1027static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 13);
1028
1029static struct attribute *lm90_emergency_alarm_attributes[] = {
1030        &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
1031        &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
1032        NULL
1033};
1034
1035static const struct attribute_group lm90_emergency_alarm_group = {
1036        .attrs = lm90_emergency_alarm_attributes,
1037};
1038
1039/*
1040 * Additional attributes for devices with 3 temperature sensors
1041 */
1042static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp11, NULL, 0, 5);
1043static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp11,
1044        set_temp11, 3, 6);
1045static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp11,
1046        set_temp11, 4, 7);
1047static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp8,
1048        set_temp8, 6);
1049static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temphyst, NULL, 6);
1050static SENSOR_DEVICE_ATTR(temp3_emergency, S_IWUSR | S_IRUGO, show_temp8,
1051        set_temp8, 7);
1052static SENSOR_DEVICE_ATTR(temp3_emergency_hyst, S_IRUGO, show_temphyst,
1053                          NULL, 7);
1054
1055static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9);
1056static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 10);
1057static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
1058static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 12);
1059static SENSOR_DEVICE_ATTR(temp3_emergency_alarm, S_IRUGO, show_alarm, NULL, 14);
1060
1061static struct attribute *lm90_temp3_attributes[] = {
1062        &sensor_dev_attr_temp3_input.dev_attr.attr,
1063        &sensor_dev_attr_temp3_min.dev_attr.attr,
1064        &sensor_dev_attr_temp3_max.dev_attr.attr,
1065        &sensor_dev_attr_temp3_crit.dev_attr.attr,
1066        &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
1067        &sensor_dev_attr_temp3_emergency.dev_attr.attr,
1068        &sensor_dev_attr_temp3_emergency_hyst.dev_attr.attr,
1069
1070        &sensor_dev_attr_temp3_fault.dev_attr.attr,
1071        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
1072        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
1073        &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
1074        &sensor_dev_attr_temp3_emergency_alarm.dev_attr.attr,
1075        NULL
1076};
1077
1078static const struct attribute_group lm90_temp3_group = {
1079        .attrs = lm90_temp3_attributes,
1080};
1081
1082/* pec used for ADM1032 only */
1083static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
1084                        char *buf)
1085{
1086        struct i2c_client *client = to_i2c_client(dev);
1087        return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
1088}
1089
1090static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
1091                       const char *buf, size_t count)
1092{
1093        struct i2c_client *client = to_i2c_client(dev);
1094        long val;
1095        int err;
1096
1097        err = kstrtol(buf, 10, &val);
1098        if (err < 0)
1099                return err;
1100
1101        switch (val) {
1102        case 0:
1103                client->flags &= ~I2C_CLIENT_PEC;
1104                break;
1105        case 1:
1106                client->flags |= I2C_CLIENT_PEC;
1107                break;
1108        default:
1109                return -EINVAL;
1110        }
1111
1112        return count;
1113}
1114
1115static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
1116
1117/*
1118 * Real code
1119 */
1120
1121/* Return 0 if detection is successful, -ENODEV otherwise */
1122static int lm90_detect(struct i2c_client *client,
1123                       struct i2c_board_info *info)
1124{
1125        struct i2c_adapter *adapter = client->adapter;
1126        int address = client->addr;
1127        const char *name = NULL;
1128        int man_id, chip_id, config1, config2, convrate;
1129
1130        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1131                return -ENODEV;
1132
1133        /* detection and identification */
1134        man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID);
1135        chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID);
1136        config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1);
1137        convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE);
1138        if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0)
1139                return -ENODEV;
1140
1141        if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {
1142                config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2);
1143                if (config2 < 0)
1144                        return -ENODEV;
1145        } else
1146                config2 = 0;            /* Make compiler happy */
1147
1148        if ((address == 0x4C || address == 0x4D)
1149         && man_id == 0x01) { /* National Semiconductor */
1150                if ((config1 & 0x2A) == 0x00
1151                 && (config2 & 0xF8) == 0x00
1152                 && convrate <= 0x09) {
1153                        if (address == 0x4C
1154                         && (chip_id & 0xF0) == 0x20) { /* LM90 */
1155                                name = "lm90";
1156                        } else
1157                        if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
1158                                name = "lm99";
1159                                dev_info(&adapter->dev,
1160                                         "Assuming LM99 chip at 0x%02x\n",
1161                                         address);
1162                                dev_info(&adapter->dev,
1163                                         "If it is an LM89, instantiate it "
1164                                         "with the new_device sysfs "
1165                                         "interface\n");
1166                        } else
1167                        if (address == 0x4C
1168                         && (chip_id & 0xF0) == 0x10) { /* LM86 */
1169                                name = "lm86";
1170                        }
1171                }
1172        } else
1173        if ((address == 0x4C || address == 0x4D)
1174         && man_id == 0x41) { /* Analog Devices */
1175                if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
1176                 && (config1 & 0x3F) == 0x00
1177                 && convrate <= 0x0A) {
1178                        name = "adm1032";
1179                        /*
1180                         * The ADM1032 supports PEC, but only if combined
1181                         * transactions are not used.
1182                         */
1183                        if (i2c_check_functionality(adapter,
1184                                                    I2C_FUNC_SMBUS_BYTE))
1185                                info->flags |= I2C_CLIENT_PEC;
1186                } else
1187                if (chip_id == 0x51 /* ADT7461 */
1188                 && (config1 & 0x1B) == 0x00
1189                 && convrate <= 0x0A) {
1190                        name = "adt7461";
1191                } else
1192                if (chip_id == 0x57 /* ADT7461A, NCT1008 */
1193                 && (config1 & 0x1B) == 0x00
1194                 && convrate <= 0x0A) {
1195                        name = "adt7461a";
1196                }
1197        } else
1198        if (man_id == 0x4D) { /* Maxim */
1199                int emerg, emerg2, status2;
1200
1201                /*
1202                 * We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read
1203                 * LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG
1204                 * exists, both readings will reflect the same value. Otherwise,
1205                 * the readings will be different.
1206                 */
1207                emerg = i2c_smbus_read_byte_data(client,
1208                                                 MAX6659_REG_R_REMOTE_EMERG);
1209                man_id = i2c_smbus_read_byte_data(client,
1210                                                  LM90_REG_R_MAN_ID);
1211                emerg2 = i2c_smbus_read_byte_data(client,
1212                                                  MAX6659_REG_R_REMOTE_EMERG);
1213                status2 = i2c_smbus_read_byte_data(client,
1214                                                   MAX6696_REG_R_STATUS2);
1215                if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0)
1216                        return -ENODEV;
1217
1218                /*
1219                 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
1220                 * register. Reading from that address will return the last
1221                 * read value, which in our case is those of the man_id
1222                 * register. Likewise, the config1 register seems to lack a
1223                 * low nibble, so the value will be those of the previous
1224                 * read, so in our case those of the man_id register.
1225                 * MAX6659 has a third set of upper temperature limit registers.
1226                 * Those registers also return values on MAX6657 and MAX6658,
1227                 * thus the only way to detect MAX6659 is by its address.
1228                 * For this reason it will be mis-detected as MAX6657 if its
1229                 * address is 0x4C.
1230                 */
1231                if (chip_id == man_id
1232                 && (address == 0x4C || address == 0x4D || address == 0x4E)
1233                 && (config1 & 0x1F) == (man_id & 0x0F)
1234                 && convrate <= 0x09) {
1235                        if (address == 0x4C)
1236                                name = "max6657";
1237                        else
1238                                name = "max6659";
1239                } else
1240                /*
1241                 * Even though MAX6695 and MAX6696 do not have a chip ID
1242                 * register, reading it returns 0x01. Bit 4 of the config1
1243                 * register is unused and should return zero when read. Bit 0 of
1244                 * the status2 register is unused and should return zero when
1245                 * read.
1246                 *
1247                 * MAX6695 and MAX6696 have an additional set of temperature
1248                 * limit registers. We can detect those chips by checking if
1249                 * one of those registers exists.
1250                 */
1251                if (chip_id == 0x01
1252                 && (config1 & 0x10) == 0x00
1253                 && (status2 & 0x01) == 0x00
1254                 && emerg == emerg2
1255                 && convrate <= 0x07) {
1256                        name = "max6696";
1257                } else
1258                /*
1259                 * The chip_id register of the MAX6680 and MAX6681 holds the
1260                 * revision of the chip. The lowest bit of the config1 register
1261                 * is unused and should return zero when read, so should the
1262                 * second to last bit of config1 (software reset).
1263                 */
1264                if (chip_id == 0x01
1265                 && (config1 & 0x03) == 0x00
1266                 && convrate <= 0x07) {
1267                        name = "max6680";
1268                } else
1269                /*
1270                 * The chip_id register of the MAX6646/6647/6649 holds the
1271                 * revision of the chip. The lowest 6 bits of the config1
1272                 * register are unused and should return zero when read.
1273                 */
1274                if (chip_id == 0x59
1275                 && (config1 & 0x3f) == 0x00
1276                 && convrate <= 0x07) {
1277                        name = "max6646";
1278                }
1279        } else
1280        if (address == 0x4C
1281         && man_id == 0x5C) { /* Winbond/Nuvoton */
1282                if ((config1 & 0x2A) == 0x00
1283                 && (config2 & 0xF8) == 0x00) {
1284                        if (chip_id == 0x01 /* W83L771W/G */
1285                         && convrate <= 0x09) {
1286                                name = "w83l771";
1287                        } else
1288                        if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */
1289                         && convrate <= 0x08) {
1290                                name = "w83l771";
1291                        }
1292                }
1293        } else
1294        if (address >= 0x48 && address <= 0x4F
1295         && man_id == 0xA1) { /*  NXP Semiconductor/Philips */
1296                if (chip_id == 0x00
1297                 && (config1 & 0x2A) == 0x00
1298                 && (config2 & 0xFE) == 0x00
1299                 && convrate <= 0x09) {
1300                        name = "sa56004";
1301                }
1302        } else
1303        if ((address == 0x4C || address == 0x4D)
1304         && man_id == 0x47) { /* GMT */
1305                if (chip_id == 0x01 /* G781 */
1306                 && (config1 & 0x3F) == 0x00
1307                 && convrate <= 0x08)
1308                        name = "g781";
1309        }
1310
1311        if (!name) { /* identification failed */
1312                dev_dbg(&adapter->dev,
1313                        "Unsupported chip at 0x%02x (man_id=0x%02X, "
1314                        "chip_id=0x%02X)\n", address, man_id, chip_id);
1315                return -ENODEV;
1316        }
1317
1318        strlcpy(info->type, name, I2C_NAME_SIZE);
1319
1320        return 0;
1321}
1322
1323static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)
1324{
1325        struct device *dev = &client->dev;
1326
1327        if (data->flags & LM90_HAVE_TEMP3)
1328                sysfs_remove_group(&dev->kobj, &lm90_temp3_group);
1329        if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
1330                sysfs_remove_group(&dev->kobj, &lm90_emergency_alarm_group);
1331        if (data->flags & LM90_HAVE_EMERGENCY)
1332                sysfs_remove_group(&dev->kobj, &lm90_emergency_group);
1333        if (data->flags & LM90_HAVE_OFFSET)
1334                device_remove_file(dev, &sensor_dev_attr_temp2_offset.dev_attr);
1335        device_remove_file(dev, &dev_attr_pec);
1336        sysfs_remove_group(&dev->kobj, &lm90_group);
1337}
1338
1339static void lm90_restore_conf(struct i2c_client *client, struct lm90_data *data)
1340{
1341        /* Restore initial configuration */
1342        i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
1343                                  data->convrate_orig);
1344        i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
1345                                  data->config_orig);
1346}
1347
1348static void lm90_init_client(struct i2c_client *client)
1349{
1350        u8 config, convrate;
1351        struct lm90_data *data = i2c_get_clientdata(client);
1352
1353        if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) {
1354                dev_warn(&client->dev, "Failed to read convrate register!\n");
1355                convrate = LM90_DEF_CONVRATE_RVAL;
1356        }
1357        data->convrate_orig = convrate;
1358
1359        /*
1360         * Start the conversions.
1361         */
1362        lm90_set_convrate(client, data, 500);   /* 500ms; 2Hz conversion rate */
1363        if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
1364                dev_warn(&client->dev, "Initialization failed!\n");
1365                return;
1366        }
1367        data->config_orig = config;
1368
1369        /* Check Temperature Range Select */
1370        if (data->kind == adt7461) {
1371                if (config & 0x04)
1372                        data->flags |= LM90_FLAG_ADT7461_EXT;
1373        }
1374
1375        /*
1376         * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
1377         * 0.125 degree resolution) and range (0x08, extend range
1378         * to -64 degree) mode for the remote temperature sensor.
1379         */
1380        if (data->kind == max6680)
1381                config |= 0x18;
1382
1383        /*
1384         * Select external channel 0 for max6695/96
1385         */
1386        if (data->kind == max6696)
1387                config &= ~0x08;
1388
1389        config &= 0xBF; /* run */
1390        if (config != data->config_orig) /* Only write if changed */
1391                i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
1392}
1393
1394static int lm90_probe(struct i2c_client *client,
1395                      const struct i2c_device_id *id)
1396{
1397        struct device *dev = &client->dev;
1398        struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);
1399        struct lm90_data *data;
1400        int err;
1401
1402        data = devm_kzalloc(&client->dev, sizeof(struct lm90_data), GFP_KERNEL);
1403        if (!data)
1404                return -ENOMEM;
1405
1406        i2c_set_clientdata(client, data);
1407        mutex_init(&data->update_lock);
1408
1409        /* Set the device type */
1410        data->kind = id->driver_data;
1411        if (data->kind == adm1032) {
1412                if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
1413                        client->flags &= ~I2C_CLIENT_PEC;
1414        }
1415
1416        /*
1417         * Different devices have different alarm bits triggering the
1418         * ALERT# output
1419         */
1420        data->alert_alarms = lm90_params[data->kind].alert_alarms;
1421
1422        /* Set chip capabilities */
1423        data->flags = lm90_params[data->kind].flags;
1424        data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
1425
1426        /* Set maximum conversion rate */
1427        data->max_convrate = lm90_params[data->kind].max_convrate;
1428
1429        /* Initialize the LM90 chip */
1430        lm90_init_client(client);
1431
1432        /* Register sysfs hooks */
1433        err = sysfs_create_group(&dev->kobj, &lm90_group);
1434        if (err)
1435                goto exit_restore;
1436        if (client->flags & I2C_CLIENT_PEC) {
1437                err = device_create_file(dev, &dev_attr_pec);
1438                if (err)
1439                        goto exit_remove_files;
1440        }
1441        if (data->flags & LM90_HAVE_OFFSET) {
1442                err = device_create_file(dev,
1443                                        &sensor_dev_attr_temp2_offset.dev_attr);
1444                if (err)
1445                        goto exit_remove_files;
1446        }
1447        if (data->flags & LM90_HAVE_EMERGENCY) {
1448                err = sysfs_create_group(&dev->kobj, &lm90_emergency_group);
1449                if (err)
1450                        goto exit_remove_files;
1451        }
1452        if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
1453                err = sysfs_create_group(&dev->kobj,
1454                                         &lm90_emergency_alarm_group);
1455                if (err)
1456                        goto exit_remove_files;
1457        }
1458        if (data->flags & LM90_HAVE_TEMP3) {
1459                err = sysfs_create_group(&dev->kobj, &lm90_temp3_group);
1460                if (err)
1461                        goto exit_remove_files;
1462        }
1463
1464        data->hwmon_dev = hwmon_device_register(dev);
1465        if (IS_ERR(data->hwmon_dev)) {
1466                err = PTR_ERR(data->hwmon_dev);
1467                goto exit_remove_files;
1468        }
1469
1470        return 0;
1471
1472exit_remove_files:
1473        lm90_remove_files(client, data);
1474exit_restore:
1475        lm90_restore_conf(client, data);
1476        return err;
1477}
1478
1479static int lm90_remove(struct i2c_client *client)
1480{
1481        struct lm90_data *data = i2c_get_clientdata(client);
1482
1483        hwmon_device_unregister(data->hwmon_dev);
1484        lm90_remove_files(client, data);
1485        lm90_restore_conf(client, data);
1486
1487        return 0;
1488}
1489
1490static void lm90_alert(struct i2c_client *client, unsigned int flag)
1491{
1492        struct lm90_data *data = i2c_get_clientdata(client);
1493        u8 config, alarms, alarms2 = 0;
1494
1495        lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
1496
1497        if (data->kind == max6696)
1498                lm90_read_reg(client, MAX6696_REG_R_STATUS2, &alarms2);
1499
1500        if ((alarms & 0x7f) == 0 && (alarms2 & 0xfe) == 0) {
1501                dev_info(&client->dev, "Everything OK\n");
1502        } else {
1503                if (alarms & 0x61)
1504                        dev_warn(&client->dev,
1505                                 "temp%d out of range, please check!\n", 1);
1506                if (alarms & 0x1a)
1507                        dev_warn(&client->dev,
1508                                 "temp%d out of range, please check!\n", 2);
1509                if (alarms & 0x04)
1510                        dev_warn(&client->dev,
1511                                 "temp%d diode open, please check!\n", 2);
1512
1513                if (alarms2 & 0x18)
1514                        dev_warn(&client->dev,
1515                                 "temp%d out of range, please check!\n", 3);
1516
1517                /*
1518                 * Disable ALERT# output, because these chips don't implement
1519                 * SMBus alert correctly; they should only hold the alert line
1520                 * low briefly.
1521                 */
1522                if ((data->flags & LM90_HAVE_BROKEN_ALERT)
1523                 && (alarms & data->alert_alarms)) {
1524                        dev_dbg(&client->dev, "Disabling ALERT#\n");
1525                        lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
1526                        i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
1527                                                  config | 0x80);
1528                }
1529        }
1530}
1531
1532static struct i2c_driver lm90_driver = {
1533        .class          = I2C_CLASS_HWMON,
1534        .driver = {
1535                .name   = "lm90",
1536        },
1537        .probe          = lm90_probe,
1538        .remove         = lm90_remove,
1539        .alert          = lm90_alert,
1540        .id_table       = lm90_id,
1541        .detect         = lm90_detect,
1542        .address_list   = normal_i2c,
1543};
1544
1545module_i2c_driver(lm90_driver);
1546
1547MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1548MODULE_DESCRIPTION("LM90/ADM1032 driver");
1549MODULE_LICENSE("GPL");
1550
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.