drivers/hwmon/lm90.c

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