drivers/hwmon/lm90.c

   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. The extra address and features of the MAX6659 are not
  32  * supported by this driver. These chips lack the remote temperature
  33  * offset feature.
  34  *
  35  * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
  36  * MAX6692 chips made by Maxim.  These are again similar to the LM86,
  37  * but they use unsigned temperature values and can report temperatures
  38  * from 0 to 145 degrees.
  39  *
  40  * This driver also supports the MAX6680 and MAX6681, two other sensor
  41  * chips made by Maxim. These are quite similar to the other Maxim
  42  * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
  43  * be treated identically.
  44  *
  45  * This driver also supports the ADT7461 chip from Analog Devices.
  46  * It's supported in both compatibility and extended mode. It is mostly
  47  * compatible with LM90 except for a data format difference for the
  48  * temperature value registers.
  49  *
  50  * Since the LM90 was the first chipset supported by this driver, most
  51  * comments will refer to this chipset, but are actually general and
  52  * concern all supported chipsets, unless mentioned otherwise.
  53  *
  54  * This program is free software; you can redistribute it and/or modify
  55  * it under the terms of the GNU General Public License as published by
  56  * the Free Software Foundation; either version 2 of the License, or
  57  * (at your option) any later version.
  58  *
  59  * This program is distributed in the hope that it will be useful,
  60  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  61  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  62  * GNU General Public License for more details.
  63  *
  64  * You should have received a copy of the GNU General Public License
  65  * along with this program; if not, write to the Free Software
  66  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  67  */
  68
  69 #include <linux/module.h>
  70 #include <linux/init.h>
  71 #include <linux/slab.h>
  72 #include <linux/jiffies.h>
  73 #include <linux/i2c.h>
  74 #include <linux/hwmon-sysfs.h>
  75 #include <linux/hwmon.h>
  76 #include <linux/err.h>
  77 #include <linux/mutex.h>
  78 #include <linux/sysfs.h>
  79
  80 /*
  81  * Addresses to scan
  82  * Address is fully defined internally and cannot be changed except for
  83  * MAX6659, MAX6680 and MAX6681.
  84  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
  85  * and MAX6658 have address 0x4c.
  86  * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
  87  * MAX6647 has address 0x4e.
  88  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
  89  * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
  90  * 0x4c, 0x4d or 0x4e.
  91  */
  92
  93 static const unsigned short normal_i2c[] = {
  94         0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
  95
  96 enum chips { lm90, adm1032, lm99, lm86, max6657, adt7461, max6680, max6646,
  97         w83l771 };
  98
  99 /*
 100  * The LM90 registers
 101  */
 102
 103 #define LM90_REG_R_MAN_ID               0xFE
 104 #define LM90_REG_R_CHIP_ID              0xFF
 105 #define LM90_REG_R_CONFIG1              0x03
 106 #define LM90_REG_W_CONFIG1              0x09
 107 #define LM90_REG_R_CONFIG2              0xBF
 108 #define LM90_REG_W_CONFIG2              0xBF
 109 #define LM90_REG_R_CONVRATE             0x04
 110 #define LM90_REG_W_CONVRATE             0x0A
 111 #define LM90_REG_R_STATUS               0x02
 112 #define LM90_REG_R_LOCAL_TEMP           0x00
 113 #define LM90_REG_R_LOCAL_HIGH           0x05
 114 #define LM90_REG_W_LOCAL_HIGH           0x0B
 115 #define LM90_REG_R_LOCAL_LOW            0x06
 116 #define LM90_REG_W_LOCAL_LOW            0x0C
 117 #define LM90_REG_R_LOCAL_CRIT           0x20
 118 #define LM90_REG_W_LOCAL_CRIT           0x20
 119 #define LM90_REG_R_REMOTE_TEMPH         0x01
 120 #define LM90_REG_R_REMOTE_TEMPL         0x10
 121 #define LM90_REG_R_REMOTE_OFFSH         0x11
 122 #define LM90_REG_W_REMOTE_OFFSH         0x11
 123 #define LM90_REG_R_REMOTE_OFFSL         0x12
 124 #define LM90_REG_W_REMOTE_OFFSL         0x12
 125 #define LM90_REG_R_REMOTE_HIGHH         0x07
 126 #define LM90_REG_W_REMOTE_HIGHH         0x0D
 127 #define LM90_REG_R_REMOTE_HIGHL         0x13
 128 #define LM90_REG_W_REMOTE_HIGHL         0x13
 129 #define LM90_REG_R_REMOTE_LOWH          0x08
 130 #define LM90_REG_W_REMOTE_LOWH          0x0E
 131 #define LM90_REG_R_REMOTE_LOWL          0x14
 132 #define LM90_REG_W_REMOTE_LOWL          0x14
 133 #define LM90_REG_R_REMOTE_CRIT          0x19
 134 #define LM90_REG_W_REMOTE_CRIT          0x19
 135 #define LM90_REG_R_TCRIT_HYST           0x21
 136 #define LM90_REG_W_TCRIT_HYST           0x21
 137
 138 /* MAX6646/6647/6649/6657/6658/6659 registers */
 139
 140 #define MAX6657_REG_R_LOCAL_TEMPL       0x11
 141
 142 /*
 143  * Device flags
 144  */
 145 #define LM90_FLAG_ADT7461_EXT   (1 << 0) /* ADT7461 extended mode       */
 146 /* Device features */
 147 #define LM90_HAVE_OFFSET        (1 << 1) /* temperature offset register */
 148 #define LM90_HAVE_LOCAL_EXT     (1 << 2) /* extended local temperature  */
 149 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit       */
 150
 151 /*
 152  * Functions declaration
 153  */
 154
 155 static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info);
 156 static int lm90_probe(struct i2c_client *client,
 157                       const struct i2c_device_id *id);
 158 static void lm90_init_client(struct i2c_client *client);
 159 static void lm90_alert(struct i2c_client *client, unsigned int flag);
 160 static int lm90_remove(struct i2c_client *client);
 161 static struct lm90_data *lm90_update_device(struct device *dev);
 162
 163 /*
 164  * Driver data (common to all clients)
 165  */
 166
 167 static const struct i2c_device_id lm90_id[] = {
 168         { "adm1032", adm1032 },
 169         { "adt7461", adt7461 },
 170         { "lm90", lm90 },
 171         { "lm86", lm86 },
 172         { "lm89", lm86 },
 173         { "lm99", lm99 },
 174         { "max6646", max6646 },
 175         { "max6647", max6646 },
 176         { "max6649", max6646 },
 177         { "max6657", max6657 },
 178         { "max6658", max6657 },
 179         { "max6659", max6657 },
 180         { "max6680", max6680 },
 181         { "max6681", max6680 },
 182         { "w83l771", w83l771 },
 183         { }
 184 };
 185 MODULE_DEVICE_TABLE(i2c, lm90_id);
 186
 187 static struct i2c_driver lm90_driver = {
 188         .class          = I2C_CLASS_HWMON,
 189         .driver = {
 190                 .name   = "lm90",
 191         },
 192         .probe          = lm90_probe,
 193         .remove         = lm90_remove,
 194         .alert          = lm90_alert,
 195         .id_table       = lm90_id,
 196         .detect         = lm90_detect,
 197         .address_list   = normal_i2c,
 198 };
 199
 200 /*
 201  * Client data (each client gets its own)
 202  */
 203
 204 struct lm90_data {
 205         struct device *hwmon_dev;
 206         struct mutex update_lock;
 207         char valid; /* zero until following fields are valid */
 208         unsigned long last_updated; /* in jiffies */
 209         int kind;
 210         int flags;
 211
 212         u8 config_orig;         /* Original configuration register value */
 213         u8 alert_alarms;        /* Which alarm bits trigger ALERT# */
 214
 215         /* registers values */
 216         s8 temp8[4];    /* 0: local low limit
 217                            1: local high limit
 218                            2: local critical limit
 219                            3: remote critical limit */
 220         s16 temp11[5];  /* 0: remote input
 221                            1: remote low limit
 222                            2: remote high limit
 223                            3: remote offset (except max6646 and max6657)
 224                            4: local input */
 225         u8 temp_hyst;
 226         u8 alarms; /* bitvector */
 227 };
 228
 229 /*
 230  * Conversions
 231  * For local temperatures and limits, critical limits and the hysteresis
 232  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 233  * For remote temperatures and limits, it uses signed 11-bit values with
 234  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 235  * Maxim chips use unsigned values.
 236  */
 237
 238 static inline int temp_from_s8(s8 val)
 239 {
 240         return val * 1000;
 241 }
 242
 243 static inline int temp_from_u8(u8 val)
 244 {
 245         return val * 1000;
 246 }
 247
 248 static inline int temp_from_s16(s16 val)
 249 {
 250         return val / 32 * 125;
 251 }
 252
 253 static inline int temp_from_u16(u16 val)
 254 {
 255         return val / 32 * 125;
 256 }
 257
 258 static s8 temp_to_s8(long val)
 259 {
 260         if (val <= -128000)
 261                 return -128;
 262         if (val >= 127000)
 263                 return 127;
 264         if (val < 0)
 265                 return (val - 500) / 1000;
 266         return (val + 500) / 1000;
 267 }
 268
 269 static u8 temp_to_u8(long val)
 270 {
 271         if (val <= 0)
 272                 return 0;
 273         if (val >= 255000)
 274                 return 255;
 275         return (val + 500) / 1000;
 276 }
 277
 278 static s16 temp_to_s16(long val)
 279 {
 280         if (val <= -128000)
 281                 return 0x8000;
 282         if (val >= 127875)
 283                 return 0x7FE0;
 284         if (val < 0)
 285                 return (val - 62) / 125 * 32;
 286         return (val + 62) / 125 * 32;
 287 }
 288
 289 static u8 hyst_to_reg(long val)
 290 {
 291         if (val <= 0)
 292                 return 0;
 293         if (val >= 30500)
 294                 return 31;
 295         return (val + 500) / 1000;
 296 }
 297
 298 /*
 299  * ADT7461 in compatibility mode is almost identical to LM90 except that
 300  * attempts to write values that are outside the range 0 < temp < 127 are
 301  * treated as the boundary value.
 302  *
 303  * ADT7461 in "extended mode" operation uses unsigned integers offset by
 304  * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
 305  */
 306 static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
 307 {
 308         if (data->flags & LM90_FLAG_ADT7461_EXT)
 309                 return (val - 64) * 1000;
 310         else
 311                 return temp_from_s8(val);
 312 }
 313
 314 static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
 315 {
 316         if (data->flags & LM90_FLAG_ADT7461_EXT)
 317                 return (val - 0x4000) / 64 * 250;
 318         else
 319                 return temp_from_s16(val);
 320 }
 321
 322 static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
 323 {
 324         if (data->flags & LM90_FLAG_ADT7461_EXT) {
 325                 if (val <= -64000)
 326                         return 0;
 327                 if (val >= 191000)
 328                         return 0xFF;
 329                 return (val + 500 + 64000) / 1000;
 330         } else {
 331                 if (val <= 0)
 332                         return 0;
 333                 if (val >= 127000)
 334                         return 127;
 335                 return (val + 500) / 1000;
 336         }
 337 }
 338
 339 static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
 340 {
 341         if (data->flags & LM90_FLAG_ADT7461_EXT) {
 342                 if (val <= -64000)
 343                         return 0;
 344                 if (val >= 191750)
 345                         return 0xFFC0;
 346                 return (val + 64000 + 125) / 250 * 64;
 347         } else {
 348                 if (val <= 0)
 349                         return 0;
 350                 if (val >= 127750)
 351                         return 0x7FC0;
 352                 return (val + 125) / 250 * 64;
 353         }
 354 }
 355
 356 /*
 357  * Sysfs stuff
 358  */
 359
 360 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 361                           char *buf)
 362 {
 363         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 364         struct lm90_data *data = lm90_update_device(dev);
 365         int temp;
 366
 367         if (data->kind == adt7461)
 368                 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 369         else if (data->kind == max6646)
 370                 temp = temp_from_u8(data->temp8[attr->index]);
 371         else
 372                 temp = temp_from_s8(data->temp8[attr->index]);
 373
 374         /* +16 degrees offset for temp2 for the LM99 */
 375         if (data->kind == lm99 && attr->index == 3)
 376                 temp += 16000;
 377
 378         return sprintf(buf, "%d\n", temp);
 379 }
 380
 381 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 382                          const char *buf, size_t count)
 383 {
 384         static const u8 reg[4] = {
 385                 LM90_REG_W_LOCAL_LOW,
 386                 LM90_REG_W_LOCAL_HIGH,
 387                 LM90_REG_W_LOCAL_CRIT,
 388                 LM90_REG_W_REMOTE_CRIT,
 389         };
 390
 391         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 392         struct i2c_client *client = to_i2c_client(dev);
 393         struct lm90_data *data = i2c_get_clientdata(client);
 394         int nr = attr->index;
 395         long val;
 396         int err;
 397
 398         err = strict_strtol(buf, 10, &val);
 399         if (err < 0)
 400                 return err;
 401
 402         /* +16 degrees offset for temp2 for the LM99 */
 403         if (data->kind == lm99 && attr->index == 3)
 404                 val -= 16000;
 405
 406         mutex_lock(&data->update_lock);
 407         if (data->kind == adt7461)
 408                 data->temp8[nr] = temp_to_u8_adt7461(data, val);
 409         else if (data->kind == max6646)
 410                 data->temp8[nr] = temp_to_u8(val);
 411         else
 412                 data->temp8[nr] = temp_to_s8(val);
 413         i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
 414         mutex_unlock(&data->update_lock);
 415         return count;
 416 }
 417
 418 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 419                            char *buf)
 420 {
 421         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 422         struct lm90_data *data = lm90_update_device(dev);
 423         int temp;
 424
 425         if (data->kind == adt7461)
 426                 temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
 427         else if (data->kind == max6646)
 428                 temp = temp_from_u16(data->temp11[attr->index]);
 429         else
 430                 temp = temp_from_s16(data->temp11[attr->index]);
 431
 432         /* +16 degrees offset for temp2 for the LM99 */
 433         if (data->kind == lm99 &&  attr->index <= 2)
 434                 temp += 16000;
 435
 436         return sprintf(buf, "%d\n", temp);
 437 }
 438
 439 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 440                           const char *buf, size_t count)
 441 {
 442         struct {
 443                 u8 high;
 444                 u8 low;
 445         } reg[3] = {
 446                 { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL },
 447                 { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL },
 448                 { LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL }
 449         };
 450
 451         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 452         struct i2c_client *client = to_i2c_client(dev);
 453         struct lm90_data *data = i2c_get_clientdata(client);
 454         int nr = attr->nr;
 455         int index = attr->index;
 456         long val;
 457         int err;
 458
 459         err = strict_strtol(buf, 10, &val);
 460         if (err < 0)
 461                 return err;
 462
 463         /* +16 degrees offset for temp2 for the LM99 */
 464         if (data->kind == lm99 && index <= 2)
 465                 val -= 16000;
 466
 467         mutex_lock(&data->update_lock);
 468         if (data->kind == adt7461)
 469                 data->temp11[index] = temp_to_u16_adt7461(data, val);
 470         else if (data->kind == max6646)
 471                 data->temp11[index] = temp_to_u8(val) << 8;
 472         else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 473                 data->temp11[index] = temp_to_s16(val);
 474         else
 475                 data->temp11[index] = temp_to_s8(val) << 8;
 476
 477         i2c_smbus_write_byte_data(client, reg[nr].high,
 478                                   data->temp11[index] >> 8);
 479         if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 480                 i2c_smbus_write_byte_data(client, reg[nr].low,
 481                                           data->temp11[index] & 0xff);
 482         mutex_unlock(&data->update_lock);
 483         return count;
 484 }
 485
 486 static ssize_t show_temphyst(struct device *dev,
 487                              struct device_attribute *devattr,
 488                              char *buf)
 489 {
 490         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 491         struct lm90_data *data = lm90_update_device(dev);
 492         int temp;
 493
 494         if (data->kind == adt7461)
 495                 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 496         else if (data->kind == max6646)
 497                 temp = temp_from_u8(data->temp8[attr->index]);
 498         else
 499                 temp = temp_from_s8(data->temp8[attr->index]);
 500
 501         /* +16 degrees offset for temp2 for the LM99 */
 502         if (data->kind == lm99 && attr->index == 3)
 503                 temp += 16000;
 504
 505         return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
 506 }
 507
 508 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 509                             const char *buf, size_t count)
 510 {
 511         struct i2c_client *client = to_i2c_client(dev);
 512         struct lm90_data *data = i2c_get_clientdata(client);
 513         long val;
 514         int err;
 515         int temp;
 516
 517         err = strict_strtol(buf, 10, &val);
 518         if (err < 0)
 519                 return err;
 520
 521         mutex_lock(&data->update_lock);
 522         if (data->kind == adt7461)
 523                 temp = temp_from_u8_adt7461(data, data->temp8[2]);
 524         else if (data->kind == max6646)
 525                 temp = temp_from_u8(data->temp8[2]);
 526         else
 527                 temp = temp_from_s8(data->temp8[2]);
 528
 529         data->temp_hyst = hyst_to_reg(temp - val);
 530         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 531                                   data->temp_hyst);
 532         mutex_unlock(&data->update_lock);
 533         return count;
 534 }
 535
 536 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 537                            char *buf)
 538 {
 539         struct lm90_data *data = lm90_update_device(dev);
 540         return sprintf(buf, "%d\n", data->alarms);
 541 }
 542
 543 static ssize_t show_alarm(struct device *dev, struct device_attribute
 544                           *devattr, char *buf)
 545 {
 546         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 547         struct lm90_data *data = lm90_update_device(dev);
 548         int bitnr = attr->index;
 549
 550         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 551 }
 552
 553 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);
 554 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);
 555 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 556         set_temp8, 0);
 557 static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 558         set_temp11, 0, 1);
 559 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 560         set_temp8, 1);
 561 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 562         set_temp11, 1, 2);
 563 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 564         set_temp8, 2);
 565 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 566         set_temp8, 3);
 567 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 568         set_temphyst, 2);
 569 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 570 static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 571         set_temp11, 2, 3);
 572
 573 /* Individual alarm files */
 574 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 575 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 576 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 577 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 578 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 579 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 580 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 581 /* Raw alarm file for compatibility */
 582 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 583
 584 static struct attribute *lm90_attributes[] = {
 585         &sensor_dev_attr_temp1_input.dev_attr.attr,
 586         &sensor_dev_attr_temp2_input.dev_attr.attr,
 587         &sensor_dev_attr_temp1_min.dev_attr.attr,
 588         &sensor_dev_attr_temp2_min.dev_attr.attr,
 589         &sensor_dev_attr_temp1_max.dev_attr.attr,
 590         &sensor_dev_attr_temp2_max.dev_attr.attr,
 591         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 592         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 593         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 594         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 595
 596         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 597         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 598         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 599         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 600         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 601         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 602         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 603         &dev_attr_alarms.attr,
 604         NULL
 605 };
 606
 607 static const struct attribute_group lm90_group = {
 608         .attrs = lm90_attributes,
 609 };
 610
 611 /* pec used for ADM1032 only */
 612 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 613                         char *buf)
 614 {
 615         struct i2c_client *client = to_i2c_client(dev);
 616         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 617 }
 618
 619 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 620                        const char *buf, size_t count)
 621 {
 622         struct i2c_client *client = to_i2c_client(dev);
 623         long val;
 624         int err;
 625
 626         err = strict_strtol(buf, 10, &val);
 627         if (err < 0)
 628                 return err;
 629
 630         switch (val) {
 631         case 0:
 632                 client->flags &= ~I2C_CLIENT_PEC;
 633                 break;
 634         case 1:
 635                 client->flags |= I2C_CLIENT_PEC;
 636                 break;
 637         default:
 638                 return -EINVAL;
 639         }
 640
 641         return count;
 642 }
 643
 644 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 645
 646 /*
 647  * Real code
 648  */
 649
 650 /*
 651  * The ADM1032 supports PEC but not on write byte transactions, so we need
 652  * to explicitly ask for a transaction without PEC.
 653  */
 654 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 655 {
 656         return i2c_smbus_xfer(client->adapter, client->addr,
 657                               client->flags & ~I2C_CLIENT_PEC,
 658                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 659 }
 660
 661 /*
 662  * It is assumed that client->update_lock is held (unless we are in
 663  * detection or initialization steps). This matters when PEC is enabled,
 664  * because we don't want the address pointer to change between the write
 665  * byte and the read byte transactions.
 666  */
 667 static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)
 668 {
 669         int err;
 670
 671         if (client->flags & I2C_CLIENT_PEC) {
 672                 err = adm1032_write_byte(client, reg);
 673                 if (err >= 0)
 674                         err = i2c_smbus_read_byte(client);
 675         } else
 676                 err = i2c_smbus_read_byte_data(client, reg);
 677
 678         if (err < 0) {
 679                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 680                          reg, err);
 681                 return err;
 682         }
 683         *value = err;
 684
 685         return 0;
 686 }
 687
 688 /* Return 0 if detection is successful, -ENODEV otherwise */
 689 static int lm90_detect(struct i2c_client *new_client,
 690                        struct i2c_board_info *info)
 691 {
 692         struct i2c_adapter *adapter = new_client->adapter;
 693         int address = new_client->addr;
 694         const char *name = NULL;
 695         int man_id, chip_id, reg_config1, reg_convrate;
 696
 697         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 698                 return -ENODEV;
 699
 700         /* detection and identification */
 701         if ((man_id = i2c_smbus_read_byte_data(new_client,
 702                                                 LM90_REG_R_MAN_ID)) < 0
 703          || (chip_id = i2c_smbus_read_byte_data(new_client,
 704                                                 LM90_REG_R_CHIP_ID)) < 0
 705          || (reg_config1 = i2c_smbus_read_byte_data(new_client,
 706                                                 LM90_REG_R_CONFIG1)) < 0
 707          || (reg_convrate = i2c_smbus_read_byte_data(new_client,
 708                                                 LM90_REG_R_CONVRATE)) < 0)
 709                 return -ENODEV;
 710
 711         if ((address == 0x4C || address == 0x4D)
 712          && man_id == 0x01) { /* National Semiconductor */
 713                 int reg_config2;
 714
 715                 reg_config2 = i2c_smbus_read_byte_data(new_client,
 716                                                 LM90_REG_R_CONFIG2);
 717                 if (reg_config2 < 0)
 718                         return -ENODEV;
 719
 720                 if ((reg_config1 & 0x2A) == 0x00
 721                  && (reg_config2 & 0xF8) == 0x00
 722                  && reg_convrate <= 0x09) {
 723                         if (address == 0x4C
 724                          && (chip_id & 0xF0) == 0x20) { /* LM90 */
 725                                 name = "lm90";
 726                         } else
 727                         if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
 728                                 name = "lm99";
 729                                 dev_info(&adapter->dev,
 730                                          "Assuming LM99 chip at 0x%02x\n",
 731                                          address);
 732                                 dev_info(&adapter->dev,
 733                                          "If it is an LM89, instantiate it "
 734                                          "with the new_device sysfs "
 735                                          "interface\n");
 736                         } else
 737                         if (address == 0x4C
 738                          && (chip_id & 0xF0) == 0x10) { /* LM86 */
 739                                 name = "lm86";
 740                         }
 741                 }
 742         } else
 743         if ((address == 0x4C || address == 0x4D)
 744          && man_id == 0x41) { /* Analog Devices */
 745                 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
 746                  && (reg_config1 & 0x3F) == 0x00
 747                  && reg_convrate <= 0x0A) {
 748                         name = "adm1032";
 749                         /* The ADM1032 supports PEC, but only if combined
 750                            transactions are not used. */
 751                         if (i2c_check_functionality(adapter,
 752                                                     I2C_FUNC_SMBUS_BYTE))
 753                                 info->flags |= I2C_CLIENT_PEC;
 754                 } else
 755                 if (chip_id == 0x51 /* ADT7461 */
 756                  && (reg_config1 & 0x1B) == 0x00
 757                  && reg_convrate <= 0x0A) {
 758                         name = "adt7461";
 759                 }
 760         } else
 761         if (man_id == 0x4D) { /* Maxim */
 762                 /*
 763                  * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
 764                  * register. Reading from that address will return the last
 765                  * read value, which in our case is those of the man_id
 766                  * register. Likewise, the config1 register seems to lack a
 767                  * low nibble, so the value will be those of the previous
 768                  * read, so in our case those of the man_id register.
 769                  */
 770                 if (chip_id == man_id
 771                  && (address == 0x4C || address == 0x4D)
 772                  && (reg_config1 & 0x1F) == (man_id & 0x0F)
 773                  && reg_convrate <= 0x09) {
 774                         name = "max6657";
 775                 } else
 776                 /*
 777                  * The chip_id register of the MAX6680 and MAX6681 holds the
 778                  * revision of the chip. The lowest bit of the config1 register
 779                  * is unused and should return zero when read, so should the
 780                  * second to last bit of config1 (software reset).
 781                  */
 782                 if (chip_id == 0x01
 783                  && (reg_config1 & 0x03) == 0x00
 784                  && reg_convrate <= 0x07) {
 785                         name = "max6680";
 786                 } else
 787                 /*
 788                  * The chip_id register of the MAX6646/6647/6649 holds the
 789                  * revision of the chip. The lowest 6 bits of the config1
 790                  * register are unused and should return zero when read.
 791                  */
 792                 if (chip_id == 0x59
 793                  && (reg_config1 & 0x3f) == 0x00
 794                  && reg_convrate <= 0x07) {
 795                         name = "max6646";
 796                 }
 797         } else
 798         if (address == 0x4C
 799          && man_id == 0x5C) { /* Winbond/Nuvoton */
 800                 if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */
 801                  && (reg_config1 & 0x2A) == 0x00
 802                  && reg_convrate <= 0x08) {
 803                         name = "w83l771";
 804                 }
 805         }
 806
 807         if (!name) { /* identification failed */
 808                 dev_dbg(&adapter->dev,
 809                         "Unsupported chip at 0x%02x (man_id=0x%02X, "
 810                         "chip_id=0x%02X)\n", address, man_id, chip_id);
 811                 return -ENODEV;
 812         }
 813
 814         strlcpy(info->type, name, I2C_NAME_SIZE);
 815
 816         return 0;
 817 }
 818
 819 static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)
 820 {
 821         if (data->flags & LM90_HAVE_OFFSET)
 822                 device_remove_file(&client->dev,
 823                                    &sensor_dev_attr_temp2_offset.dev_attr);
 824         device_remove_file(&client->dev, &dev_attr_pec);
 825         sysfs_remove_group(&client->dev.kobj, &lm90_group);
 826 }
 827
 828 static int lm90_probe(struct i2c_client *new_client,
 829                       const struct i2c_device_id *id)
 830 {
 831         struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
 832         struct lm90_data *data;
 833         int err;
 834
 835         data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
 836         if (!data) {
 837                 err = -ENOMEM;
 838                 goto exit;
 839         }
 840         i2c_set_clientdata(new_client, data);
 841         mutex_init(&data->update_lock);
 842
 843         /* Set the device type */
 844         data->kind = id->driver_data;
 845         if (data->kind == adm1032) {
 846                 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 847                         new_client->flags &= ~I2C_CLIENT_PEC;
 848         }
 849
 850         /* Different devices have different alarm bits triggering the
 851          * ALERT# output */
 852         switch (data->kind) {
 853         case lm90:
 854         case lm99:
 855         case lm86:
 856                 data->alert_alarms = 0x7b;
 857                 break;
 858         default:
 859                 data->alert_alarms = 0x7c;
 860                 break;
 861         }
 862
 863         /* Set chip capabilities */
 864         if (data->kind != max6657 && data->kind != max6646)
 865                 data->flags |= LM90_HAVE_OFFSET;
 866
 867         if (data->kind == max6657 || data->kind == max6646)
 868                 data->flags |= LM90_HAVE_LOCAL_EXT;
 869
 870         if (data->kind != max6657 && data->kind != max6646
 871             && data->kind != max6680)
 872                 data->flags |= LM90_HAVE_REM_LIMIT_EXT;
 873
 874         /* Initialize the LM90 chip */
 875         lm90_init_client(new_client);
 876
 877         /* Register sysfs hooks */
 878         err = sysfs_create_group(&new_client->dev.kobj, &lm90_group);
 879         if (err)
 880                 goto exit_free;
 881         if (new_client->flags & I2C_CLIENT_PEC) {
 882                 err = device_create_file(&new_client->dev, &dev_attr_pec);
 883                 if (err)
 884                         goto exit_remove_files;
 885         }
 886         if (data->flags & LM90_HAVE_OFFSET) {
 887                 err = device_create_file(&new_client->dev,
 888                                         &sensor_dev_attr_temp2_offset.dev_attr);
 889                 if (err)
 890                         goto exit_remove_files;
 891         }
 892
 893         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 894         if (IS_ERR(data->hwmon_dev)) {
 895                 err = PTR_ERR(data->hwmon_dev);
 896                 goto exit_remove_files;
 897         }
 898
 899         return 0;
 900
 901 exit_remove_files:
 902         lm90_remove_files(new_client, data);
 903 exit_free:
 904         kfree(data);
 905 exit:
 906         return err;
 907 }
 908
 909 static void lm90_init_client(struct i2c_client *client)
 910 {
 911         u8 config;
 912         struct lm90_data *data = i2c_get_clientdata(client);
 913
 914         /*
 915          * Start the conversions.
 916          */
 917         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 918                                   5); /* 2 Hz */
 919         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 920                 dev_warn(&client->dev, "Initialization failed!\n");
 921                 return;
 922         }
 923         data->config_orig = config;
 924
 925         /* Check Temperature Range Select */
 926         if (data->kind == adt7461) {
 927                 if (config & 0x04)
 928                         data->flags |= LM90_FLAG_ADT7461_EXT;
 929         }
 930
 931         /*
 932          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
 933          * 0.125 degree resolution) and range (0x08, extend range
 934          * to -64 degree) mode for the remote temperature sensor.
 935          */
 936         if (data->kind == max6680)
 937                 config |= 0x18;
 938
 939         config &= 0xBF; /* run */
 940         if (config != data->config_orig) /* Only write if changed */
 941                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 942 }
 943
 944 static int lm90_remove(struct i2c_client *client)
 945 {
 946         struct lm90_data *data = i2c_get_clientdata(client);
 947
 948         hwmon_device_unregister(data->hwmon_dev);
 949         lm90_remove_files(client, data);
 950
 951         /* Restore initial configuration */
 952         i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
 953                                   data->config_orig);
 954
 955         kfree(data);
 956         return 0;
 957 }
 958
 959 static void lm90_alert(struct i2c_client *client, unsigned int flag)
 960 {
 961         struct lm90_data *data = i2c_get_clientdata(client);
 962         u8 config, alarms;
 963
 964         lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
 965         if ((alarms & 0x7f) == 0) {
 966                 dev_info(&client->dev, "Everything OK\n");
 967         } else {
 968                 if (alarms & 0x61)
 969                         dev_warn(&client->dev,
 970                                  "temp%d out of range, please check!\n", 1);
 971                 if (alarms & 0x1a)
 972                         dev_warn(&client->dev,
 973                                  "temp%d out of range, please check!\n", 2);
 974                 if (alarms & 0x04)
 975                         dev_warn(&client->dev,
 976                                  "temp%d diode open, please check!\n", 2);
 977
 978                 /* Disable ALERT# output, because these chips don't implement
 979                   SMBus alert correctly; they should only hold the alert line
 980                   low briefly. */
 981                 if ((data->kind == adm1032 || data->kind == adt7461)
 982                  && (alarms & data->alert_alarms)) {
 983                         dev_dbg(&client->dev, "Disabling ALERT#\n");
 984                         lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
 985                         i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
 986                                                   config | 0x80);
 987                 }
 988         }
 989 }
 990
 991 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
 992 {
 993         int err;
 994         u8 oldh, newh, l;
 995
 996         /*
 997          * There is a trick here. We have to read two registers to have the
 998          * sensor temperature, but we have to beware a conversion could occur
 999          * inbetween the readings. The datasheet says we should either use
1000          * the one-shot conversion register, which we don't want to do
1001          * (disables hardware monitoring) or monitor the busy bit, which is
1002          * impossible (we can't read the values and monitor that bit at the
1003          * exact same time). So the solution used here is to read the high
1004          * byte once, then the low byte, then the high byte again. If the new
1005          * high byte matches the old one, then we have a valid reading. Else
1006          * we have to read the low byte again, and now we believe we have a
1007          * correct reading.
1008          */
1009         if ((err = lm90_read_reg(client, regh, &oldh))
1010          || (err = lm90_read_reg(client, regl, &l))
1011          || (err = lm90_read_reg(client, regh, &newh)))
1012                 return err;
1013         if (oldh != newh) {
1014                 err = lm90_read_reg(client, regl, &l);
1015                 if (err)
1016                         return err;
1017         }
1018         *value = (newh << 8) | l;
1019
1020         return 0;
1021 }
1022
1023 static struct lm90_data *lm90_update_device(struct device *dev)
1024 {
1025         struct i2c_client *client = to_i2c_client(dev);
1026         struct lm90_data *data = i2c_get_clientdata(client);
1027
1028         mutex_lock(&data->update_lock);
1029
1030         if (time_after(jiffies, data->last_updated + HZ / 2 + HZ / 10)
1031          || !data->valid) {
1032                 u8 h, l;
1033
1034                 dev_dbg(&client->dev, "Updating lm90 data.\n");
1035                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
1036                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
1037                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
1038                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
1039                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
1040
1041                 if (data->flags & LM90_HAVE_LOCAL_EXT) {
1042                         lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
1043                                     MAX6657_REG_R_LOCAL_TEMPL,
1044                                     &data->temp11[4]);
1045                 } else {
1046                         if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
1047                                           &h) == 0)
1048                                 data->temp11[4] = h << 8;
1049                 }
1050                 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
1051                             LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
1052
1053                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
1054                         data->temp11[1] = h << 8;
1055                         if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
1056                          && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
1057                                           &l) == 0)
1058                                 data->temp11[1] |= l;
1059                 }
1060                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
1061                         data->temp11[2] = h << 8;
1062                         if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
1063                          && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
1064                                           &l) == 0)
1065                                 data->temp11[2] |= l;
1066                 }
1067
1068                 if (data->flags & LM90_HAVE_OFFSET) {
1069                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
1070                                           &h) == 0
1071                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
1072                                           &l) == 0)
1073                                 data->temp11[3] = (h << 8) | l;
1074                 }
1075                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
1076
1077                 /* Re-enable ALERT# output if it was originally enabled and
1078                  * relevant alarms are all clear */
1079                 if ((data->config_orig & 0x80) == 0
1080                  && (data->alarms & data->alert_alarms) == 0) {
1081                         u8 config;
1082
1083                         lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
1084                         if (config & 0x80) {
1085                                 dev_dbg(&client->dev, "Re-enabling ALERT#\n");
1086                                 i2c_smbus_write_byte_data(client,
1087                                                           LM90_REG_W_CONFIG1,
1088                                                           config & ~0x80);
1089                         }
1090                 }
1091
1092                 data->last_updated = jiffies;
1093                 data->valid = 1;
1094         }
1095
1096         mutex_unlock(&data->update_lock);
1097
1098         return data;
1099 }
1100
1101 static int __init sensors_lm90_init(void)
1102 {
1103         return i2c_add_driver(&lm90_driver);
1104 }
1105
1106 static void __exit sensors_lm90_exit(void)
1107 {
1108         i2c_del_driver(&lm90_driver);
1109 }
1110
1111 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1112 MODULE_DESCRIPTION("LM90/ADM1032 driver");
1113 MODULE_LICENSE("GPL");
1114
1115 module_init(sensors_lm90_init);
1116 module_exit(sensors_lm90_exit);