drivers/hwmon/lm90.c

   1 /*
   2  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *          monitoring
   4  * Copyright (C) 2003-2008  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. Complete datasheet can be
  10  * obtained from National's website at:
  11  *   http://www.national.com/pf/LM/LM90.html
  12  *
  13  * This driver also supports the LM89 and LM99, two other sensor chips
  14  * made by National Semiconductor. Both have an increased remote
  15  * temperature measurement accuracy (1 degree), and the LM99
  16  * additionally shifts remote temperatures (measured and limits) by 16
  17  * degrees, which allows for higher temperatures measurement. The
  18  * driver doesn't handle it since it can be done easily in user-space.
  19  * Complete datasheets can be obtained from National's website at:
  20  *   http://www.national.com/pf/LM/LM89.html
  21  *   http://www.national.com/pf/LM/LM99.html
  22  * Note that there is no way to differentiate between both chips.
  23  *
  24  * This driver also supports the LM86, another sensor chip made by
  25  * National Semiconductor. It is exactly similar to the LM90 except it
  26  * has a higher accuracy.
  27  * Complete datasheet can be obtained from National's website at:
  28  *   http://www.national.com/pf/LM/LM86.html
  29  *
  30  * This driver also supports the ADM1032, a sensor chip made by Analog
  31  * Devices. That chip is similar to the LM90, with a few differences
  32  * that are not handled by this driver. Complete datasheet can be
  33  * obtained from Analog's website at:
  34  *   http://www.analog.com/en/prod/0,2877,ADM1032,00.html
  35  * Among others, it has a higher accuracy than the LM90, much like the
  36  * LM86 does.
  37  *
  38  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
  39  * chips made by Maxim. These chips are similar to the LM86. Complete
  40  * datasheet can be obtained at Maxim's website at:
  41  *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
  42  * Note that there is no easy way to differentiate between the three
  43  * variants. The extra address and features of the MAX6659 are not
  44  * supported by this driver. These chips lack the remote temperature
  45  * offset feature.
  46  *
  47  * This driver also supports the MAX6680 and MAX6681, two other sensor
  48  * chips made by Maxim. These are quite similar to the other Maxim
  49  * chips. Complete datasheet can be obtained at:
  50  *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/3370
  51  * The MAX6680 and MAX6681 only differ in the pinout so they can be
  52  * treated identically.
  53  *
  54  * This driver also supports the ADT7461 chip from Analog Devices but
  55  * only in its "compatability mode". If an ADT7461 chip is found but
  56  * is configured in non-compatible mode (where its temperature
  57  * register values are decoded differently) it is ignored by this
  58  * driver. Complete datasheet can be obtained from Analog's website
  59  * at:
  60  *   http://www.analog.com/en/prod/0,2877,ADT7461,00.html
  61  *
  62  * Since the LM90 was the first chipset supported by this driver, most
  63  * comments will refer to this chipset, but are actually general and
  64  * concern all supported chipsets, unless mentioned otherwise.
  65  *
  66  * This program is free software; you can redistribute it and/or modify
  67  * it under the terms of the GNU General Public License as published by
  68  * the Free Software Foundation; either version 2 of the License, or
  69  * (at your option) any later version.
  70  *
  71  * This program is distributed in the hope that it will be useful,
  72  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  73  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  74  * GNU General Public License for more details.
  75  *
  76  * You should have received a copy of the GNU General Public License
  77  * along with this program; if not, write to the Free Software
  78  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  79  */
  80
  81 #include <linux/module.h>
  82 #include <linux/init.h>
  83 #include <linux/slab.h>
  84 #include <linux/jiffies.h>
  85 #include <linux/i2c.h>
  86 #include <linux/hwmon-sysfs.h>
  87 #include <linux/hwmon.h>
  88 #include <linux/err.h>
  89 #include <linux/mutex.h>
  90 #include <linux/sysfs.h>
  91
  92 /*
  93  * Addresses to scan
  94  * Address is fully defined internally and cannot be changed except for
  95  * MAX6659, MAX6680 and MAX6681.
  96  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
  97  * have address 0x4c.
  98  * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
  99  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
 100  * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
 101  * 0x4c, 0x4d or 0x4e.
 102  */
 103
 104 static const unsigned short normal_i2c[] = {
 105         0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
 106
 107 /*
 108  * Insmod parameters
 109  */
 110
 111 I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
 112
 113 /*
 114  * The LM90 registers
 115  */
 116
 117 #define LM90_REG_R_MAN_ID               0xFE
 118 #define LM90_REG_R_CHIP_ID              0xFF
 119 #define LM90_REG_R_CONFIG1              0x03
 120 #define LM90_REG_W_CONFIG1              0x09
 121 #define LM90_REG_R_CONFIG2              0xBF
 122 #define LM90_REG_W_CONFIG2              0xBF
 123 #define LM90_REG_R_CONVRATE             0x04
 124 #define LM90_REG_W_CONVRATE             0x0A
 125 #define LM90_REG_R_STATUS               0x02
 126 #define LM90_REG_R_LOCAL_TEMP           0x00
 127 #define LM90_REG_R_LOCAL_HIGH           0x05
 128 #define LM90_REG_W_LOCAL_HIGH           0x0B
 129 #define LM90_REG_R_LOCAL_LOW            0x06
 130 #define LM90_REG_W_LOCAL_LOW            0x0C
 131 #define LM90_REG_R_LOCAL_CRIT           0x20
 132 #define LM90_REG_W_LOCAL_CRIT           0x20
 133 #define LM90_REG_R_REMOTE_TEMPH         0x01
 134 #define LM90_REG_R_REMOTE_TEMPL         0x10
 135 #define LM90_REG_R_REMOTE_OFFSH         0x11
 136 #define LM90_REG_W_REMOTE_OFFSH         0x11
 137 #define LM90_REG_R_REMOTE_OFFSL         0x12
 138 #define LM90_REG_W_REMOTE_OFFSL         0x12
 139 #define LM90_REG_R_REMOTE_HIGHH         0x07
 140 #define LM90_REG_W_REMOTE_HIGHH         0x0D
 141 #define LM90_REG_R_REMOTE_HIGHL         0x13
 142 #define LM90_REG_W_REMOTE_HIGHL         0x13
 143 #define LM90_REG_R_REMOTE_LOWH          0x08
 144 #define LM90_REG_W_REMOTE_LOWH          0x0E
 145 #define LM90_REG_R_REMOTE_LOWL          0x14
 146 #define LM90_REG_W_REMOTE_LOWL          0x14
 147 #define LM90_REG_R_REMOTE_CRIT          0x19
 148 #define LM90_REG_W_REMOTE_CRIT          0x19
 149 #define LM90_REG_R_TCRIT_HYST           0x21
 150 #define LM90_REG_W_TCRIT_HYST           0x21
 151
 152 /* MAX6657-specific registers */
 153
 154 #define MAX6657_REG_R_LOCAL_TEMPL       0x11
 155
 156 /*
 157  * Conversions and various macros
 158  * For local temperatures and limits, critical limits and the hysteresis
 159  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 160  * For remote temperatures and limits, it uses signed 11-bit values with
 161  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
 162  */
 163
 164 #define TEMP1_FROM_REG(val)     ((val) * 1000)
 165 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
 166                                  (val) >= 127000 ? 127 : \
 167                                  (val) < 0 ? ((val) - 500) / 1000 : \
 168                                  ((val) + 500) / 1000)
 169 #define TEMP2_FROM_REG(val)     ((val) / 32 * 125)
 170 #define TEMP2_TO_REG(val)       ((val) <= -128000 ? 0x8000 : \
 171                                  (val) >= 127875 ? 0x7FE0 : \
 172                                  (val) < 0 ? ((val) - 62) / 125 * 32 : \
 173                                  ((val) + 62) / 125 * 32)
 174 #define HYST_TO_REG(val)        ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
 175                                  ((val) + 500) / 1000)
 176
 177 /*
 178  * ADT7461 is almost identical to LM90 except that attempts to write
 179  * values that are outside the range 0 < temp < 127 are treated as
 180  * the boundary value.
 181  */
 182
 183 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 184                                  (val) >= 127000 ? 127 : \
 185                                  ((val) + 500) / 1000)
 186 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 187                                  (val) >= 127750 ? 0x7FC0 : \
 188                                  ((val) + 125) / 250 * 64)
 189
 190 /*
 191  * Functions declaration
 192  */
 193
 194 static int lm90_detect(struct i2c_client *client, int kind,
 195                        struct i2c_board_info *info);
 196 static int lm90_probe(struct i2c_client *client,
 197                       const struct i2c_device_id *id);
 198 static void lm90_init_client(struct i2c_client *client);
 199 static int lm90_remove(struct i2c_client *client);
 200 static struct lm90_data *lm90_update_device(struct device *dev);
 201
 202 /*
 203  * Driver data (common to all clients)
 204  */
 205
 206 static const struct i2c_device_id lm90_id[] = {
 207         { "adm1032", adm1032 },
 208         { "adt7461", adt7461 },
 209         { "lm90", lm90 },
 210         { "lm86", lm86 },
 211         { "lm89", lm99 },
 212         { "lm99", lm99 },       /* Missing temperature offset */
 213         { "max6657", max6657 },
 214         { "max6658", max6657 },
 215         { "max6659", max6657 },
 216         { "max6680", max6680 },
 217         { "max6681", max6680 },
 218         { }
 219 };
 220 MODULE_DEVICE_TABLE(i2c, lm90_id);
 221
 222 static struct i2c_driver lm90_driver = {
 223         .class          = I2C_CLASS_HWMON,
 224         .driver = {
 225                 .name   = "lm90",
 226         },
 227         .probe          = lm90_probe,
 228         .remove         = lm90_remove,
 229         .id_table       = lm90_id,
 230         .detect         = lm90_detect,
 231         .address_data   = &addr_data,
 232 };
 233
 234 /*
 235  * Client data (each client gets its own)
 236  */
 237
 238 struct lm90_data {
 239         struct device *hwmon_dev;
 240         struct mutex update_lock;
 241         char valid; /* zero until following fields are valid */
 242         unsigned long last_updated; /* in jiffies */
 243         int kind;
 244
 245         /* registers values */
 246         s8 temp8[4];    /* 0: local low limit
 247                            1: local high limit
 248                            2: local critical limit
 249                            3: remote critical limit */
 250         s16 temp11[5];  /* 0: remote input
 251                            1: remote low limit
 252                            2: remote high limit
 253                            3: remote offset (except max6657)
 254                            4: local input */
 255         u8 temp_hyst;
 256         u8 alarms; /* bitvector */
 257 };
 258
 259 /*
 260  * Sysfs stuff
 261  */
 262
 263 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 264                           char *buf)
 265 {
 266         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 267         struct lm90_data *data = lm90_update_device(dev);
 268         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
 269 }
 270
 271 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 272                          const char *buf, size_t count)
 273 {
 274         static const u8 reg[4] = {
 275                 LM90_REG_W_LOCAL_LOW,
 276                 LM90_REG_W_LOCAL_HIGH,
 277                 LM90_REG_W_LOCAL_CRIT,
 278                 LM90_REG_W_REMOTE_CRIT,
 279         };
 280
 281         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 282         struct i2c_client *client = to_i2c_client(dev);
 283         struct lm90_data *data = i2c_get_clientdata(client);
 284         long val = simple_strtol(buf, NULL, 10);
 285         int nr = attr->index;
 286
 287         mutex_lock(&data->update_lock);
 288         if (data->kind == adt7461)
 289                 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
 290         else
 291                 data->temp8[nr] = TEMP1_TO_REG(val);
 292         i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
 293         mutex_unlock(&data->update_lock);
 294         return count;
 295 }
 296
 297 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 298                            char *buf)
 299 {
 300         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 301         struct lm90_data *data = lm90_update_device(dev);
 302         return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
 303 }
 304
 305 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 306                           const char *buf, size_t count)
 307 {
 308         static const u8 reg[6] = {
 309                 LM90_REG_W_REMOTE_LOWH,
 310                 LM90_REG_W_REMOTE_LOWL,
 311                 LM90_REG_W_REMOTE_HIGHH,
 312                 LM90_REG_W_REMOTE_HIGHL,
 313                 LM90_REG_W_REMOTE_OFFSH,
 314                 LM90_REG_W_REMOTE_OFFSL,
 315         };
 316
 317         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 318         struct i2c_client *client = to_i2c_client(dev);
 319         struct lm90_data *data = i2c_get_clientdata(client);
 320         long val = simple_strtol(buf, NULL, 10);
 321         int nr = attr->index;
 322
 323         mutex_lock(&data->update_lock);
 324         if (data->kind == adt7461)
 325                 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
 326         else
 327                 data->temp11[nr] = TEMP2_TO_REG(val);
 328         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
 329                                   data->temp11[nr] >> 8);
 330         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
 331                                   data->temp11[nr] & 0xff);
 332         mutex_unlock(&data->update_lock);
 333         return count;
 334 }
 335
 336 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
 337                              char *buf)
 338 {
 339         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 340         struct lm90_data *data = lm90_update_device(dev);
 341         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
 342                        - TEMP1_FROM_REG(data->temp_hyst));
 343 }
 344
 345 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 346                             const char *buf, size_t count)
 347 {
 348         struct i2c_client *client = to_i2c_client(dev);
 349         struct lm90_data *data = i2c_get_clientdata(client);
 350         long val = simple_strtol(buf, NULL, 10);
 351         long hyst;
 352
 353         mutex_lock(&data->update_lock);
 354         hyst = TEMP1_FROM_REG(data->temp8[2]) - val;
 355         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 356                                   HYST_TO_REG(hyst));
 357         mutex_unlock(&data->update_lock);
 358         return count;
 359 }
 360
 361 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 362                            char *buf)
 363 {
 364         struct lm90_data *data = lm90_update_device(dev);
 365         return sprintf(buf, "%d\n", data->alarms);
 366 }
 367
 368 static ssize_t show_alarm(struct device *dev, struct device_attribute
 369                           *devattr, char *buf)
 370 {
 371         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 372         struct lm90_data *data = lm90_update_device(dev);
 373         int bitnr = attr->index;
 374
 375         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 376 }
 377
 378 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
 379 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 380 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 381         set_temp8, 0);
 382 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 383         set_temp11, 1);
 384 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 385         set_temp8, 1);
 386 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 387         set_temp11, 2);
 388 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 389         set_temp8, 2);
 390 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 391         set_temp8, 3);
 392 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 393         set_temphyst, 2);
 394 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 395 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 396         set_temp11, 3);
 397
 398 /* Individual alarm files */
 399 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 400 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 401 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 402 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 403 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 404 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 405 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 406 /* Raw alarm file for compatibility */
 407 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 408
 409 static struct attribute *lm90_attributes[] = {
 410         &sensor_dev_attr_temp1_input.dev_attr.attr,
 411         &sensor_dev_attr_temp2_input.dev_attr.attr,
 412         &sensor_dev_attr_temp1_min.dev_attr.attr,
 413         &sensor_dev_attr_temp2_min.dev_attr.attr,
 414         &sensor_dev_attr_temp1_max.dev_attr.attr,
 415         &sensor_dev_attr_temp2_max.dev_attr.attr,
 416         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 417         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 418         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 419         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 420
 421         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 422         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 423         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 424         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 425         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 426         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 427         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 428         &dev_attr_alarms.attr,
 429         NULL
 430 };
 431
 432 static const struct attribute_group lm90_group = {
 433         .attrs = lm90_attributes,
 434 };
 435
 436 /* pec used for ADM1032 only */
 437 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 438                         char *buf)
 439 {
 440         struct i2c_client *client = to_i2c_client(dev);
 441         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 442 }
 443
 444 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 445                        const char *buf, size_t count)
 446 {
 447         struct i2c_client *client = to_i2c_client(dev);
 448         long val = simple_strtol(buf, NULL, 10);
 449
 450         switch (val) {
 451         case 0:
 452                 client->flags &= ~I2C_CLIENT_PEC;
 453                 break;
 454         case 1:
 455                 client->flags |= I2C_CLIENT_PEC;
 456                 break;
 457         default:
 458                 return -EINVAL;
 459         }
 460
 461         return count;
 462 }
 463
 464 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 465
 466 /*
 467  * Real code
 468  */
 469
 470 /* The ADM1032 supports PEC but not on write byte transactions, so we need
 471    to explicitly ask for a transaction without PEC. */
 472 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 473 {
 474         return i2c_smbus_xfer(client->adapter, client->addr,
 475                               client->flags & ~I2C_CLIENT_PEC,
 476                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 477 }
 478
 479 /* It is assumed that client->update_lock is held (unless we are in
 480    detection or initialization steps). This matters when PEC is enabled,
 481    because we don't want the address pointer to change between the write
 482    byte and the read byte transactions. */
 483 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
 484 {
 485         int err;
 486
 487         if (client->flags & I2C_CLIENT_PEC) {
 488                 err = adm1032_write_byte(client, reg);
 489                 if (err >= 0)
 490                         err = i2c_smbus_read_byte(client);
 491         } else
 492                 err = i2c_smbus_read_byte_data(client, reg);
 493
 494         if (err < 0) {
 495                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 496                          reg, err);
 497                 return err;
 498         }
 499         *value = err;
 500
 501         return 0;
 502 }
 503
 504 /* Return 0 if detection is successful, -ENODEV otherwise */
 505 static int lm90_detect(struct i2c_client *new_client, int kind,
 506                        struct i2c_board_info *info)
 507 {
 508         struct i2c_adapter *adapter = new_client->adapter;
 509         int address = new_client->addr;
 510         const char *name = "";
 511
 512         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 513                 return -ENODEV;
 514
 515         /*
 516          * Now we do the remaining detection. A negative kind means that
 517          * the driver was loaded with no force parameter (default), so we
 518          * must both detect and identify the chip. A zero kind means that
 519          * the driver was loaded with the force parameter, the detection
 520          * step shall be skipped. A positive kind means that the driver
 521          * was loaded with the force parameter and a given kind of chip is
 522          * requested, so both the detection and the identification steps
 523          * are skipped.
 524          */
 525
 526         /* Default to an LM90 if forced */
 527         if (kind == 0)
 528                 kind = lm90;
 529
 530         if (kind < 0) { /* detection and identification */
 531                 int man_id, chip_id, reg_config1, reg_convrate;
 532
 533                 if ((man_id = i2c_smbus_read_byte_data(new_client,
 534                                                 LM90_REG_R_MAN_ID)) < 0
 535                  || (chip_id = i2c_smbus_read_byte_data(new_client,
 536                                                 LM90_REG_R_CHIP_ID)) < 0
 537                  || (reg_config1 = i2c_smbus_read_byte_data(new_client,
 538                                                 LM90_REG_R_CONFIG1)) < 0
 539                  || (reg_convrate = i2c_smbus_read_byte_data(new_client,
 540                                                 LM90_REG_R_CONVRATE)) < 0)
 541                         return -ENODEV;
 542
 543                 if ((address == 0x4C || address == 0x4D)
 544                  && man_id == 0x01) { /* National Semiconductor */
 545                         int reg_config2;
 546
 547                         if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
 548                                                 LM90_REG_R_CONFIG2)) < 0)
 549                                 return -ENODEV;
 550
 551                         if ((reg_config1 & 0x2A) == 0x00
 552                          && (reg_config2 & 0xF8) == 0x00
 553                          && reg_convrate <= 0x09) {
 554                                 if (address == 0x4C
 555                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
 556                                         kind = lm90;
 557                                 } else
 558                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
 559                                         kind = lm99;
 560                                 } else
 561                                 if (address == 0x4C
 562                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
 563                                         kind = lm86;
 564                                 }
 565                         }
 566                 } else
 567                 if ((address == 0x4C || address == 0x4D)
 568                  && man_id == 0x41) { /* Analog Devices */
 569                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
 570                          && (reg_config1 & 0x3F) == 0x00
 571                          && reg_convrate <= 0x0A) {
 572                                 kind = adm1032;
 573                         } else
 574                         if (chip_id == 0x51 /* ADT7461 */
 575                          && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
 576                          && reg_convrate <= 0x0A) {
 577                                 kind = adt7461;
 578                         }
 579                 } else
 580                 if (man_id == 0x4D) { /* Maxim */
 581                         /*
 582                          * The MAX6657, MAX6658 and MAX6659 do NOT have a
 583                          * chip_id register. Reading from that address will
 584                          * return the last read value, which in our case is
 585                          * those of the man_id register. Likewise, the config1
 586                          * register seems to lack a low nibble, so the value
 587                          * will be those of the previous read, so in our case
 588                          * those of the man_id register.
 589                          */
 590                         if (chip_id == man_id
 591                          && (address == 0x4C || address == 0x4D)
 592                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
 593                          && reg_convrate <= 0x09) {
 594                                 kind = max6657;
 595                         } else
 596                         /* The chip_id register of the MAX6680 and MAX6681
 597                          * holds the revision of the chip.
 598                          * the lowest bit of the config1 register is unused
 599                          * and should return zero when read, so should the
 600                          * second to last bit of config1 (software reset)
 601                          */
 602                         if (chip_id == 0x01
 603                          && (reg_config1 & 0x03) == 0x00
 604                          && reg_convrate <= 0x07) {
 605                                 kind = max6680;
 606                         }
 607                 }
 608
 609                 if (kind <= 0) { /* identification failed */
 610                         dev_info(&adapter->dev,
 611                             "Unsupported chip (man_id=0x%02X, "
 612                             "chip_id=0x%02X).\n", man_id, chip_id);
 613                         return -ENODEV;
 614                 }
 615         }
 616
 617         /* Fill the i2c board info */
 618         if (kind == lm90) {
 619                 name = "lm90";
 620         } else if (kind == adm1032) {
 621                 name = "adm1032";
 622                 /* The ADM1032 supports PEC, but only if combined
 623                    transactions are not used. */
 624                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 625                         info->flags |= I2C_CLIENT_PEC;
 626         } else if (kind == lm99) {
 627                 name = "lm99";
 628         } else if (kind == lm86) {
 629                 name = "lm86";
 630         } else if (kind == max6657) {
 631                 name = "max6657";
 632         } else if (kind == max6680) {
 633                 name = "max6680";
 634         } else if (kind == adt7461) {
 635                 name = "adt7461";
 636         }
 637         strlcpy(info->type, name, I2C_NAME_SIZE);
 638
 639         return 0;
 640 }
 641
 642 static int lm90_probe(struct i2c_client *new_client,
 643                       const struct i2c_device_id *id)
 644 {
 645         struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
 646         struct lm90_data *data;
 647         int err;
 648
 649         data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
 650         if (!data) {
 651                 err = -ENOMEM;
 652                 goto exit;
 653         }
 654         i2c_set_clientdata(new_client, data);
 655         mutex_init(&data->update_lock);
 656
 657         /* Set the device type */
 658         data->kind = id->driver_data;
 659         if (data->kind == adm1032) {
 660                 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 661                         new_client->flags &= ~I2C_CLIENT_PEC;
 662         }
 663
 664         /* Initialize the LM90 chip */
 665         lm90_init_client(new_client);
 666
 667         /* Register sysfs hooks */
 668         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
 669                 goto exit_free;
 670         if (new_client->flags & I2C_CLIENT_PEC) {
 671                 if ((err = device_create_file(&new_client->dev,
 672                                               &dev_attr_pec)))
 673                         goto exit_remove_files;
 674         }
 675         if (data->kind != max6657) {
 676                 if ((err = device_create_file(&new_client->dev,
 677                                 &sensor_dev_attr_temp2_offset.dev_attr)))
 678                         goto exit_remove_files;
 679         }
 680
 681         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 682         if (IS_ERR(data->hwmon_dev)) {
 683                 err = PTR_ERR(data->hwmon_dev);
 684                 goto exit_remove_files;
 685         }
 686
 687         return 0;
 688
 689 exit_remove_files:
 690         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
 691         device_remove_file(&new_client->dev, &dev_attr_pec);
 692 exit_free:
 693         kfree(data);
 694 exit:
 695         return err;
 696 }
 697
 698 static void lm90_init_client(struct i2c_client *client)
 699 {
 700         u8 config, config_orig;
 701         struct lm90_data *data = i2c_get_clientdata(client);
 702
 703         /*
 704          * Start the conversions.
 705          */
 706         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 707                                   5); /* 2 Hz */
 708         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 709                 dev_warn(&client->dev, "Initialization failed!\n");
 710                 return;
 711         }
 712         config_orig = config;
 713
 714         /*
 715          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
 716          * 0.125 degree resolution) and range (0x08, extend range
 717          * to -64 degree) mode for the remote temperature sensor.
 718          */
 719         if (data->kind == max6680) {
 720                 config |= 0x18;
 721         }
 722
 723         config &= 0xBF; /* run */
 724         if (config != config_orig) /* Only write if changed */
 725                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 726 }
 727
 728 static int lm90_remove(struct i2c_client *client)
 729 {
 730         struct lm90_data *data = i2c_get_clientdata(client);
 731
 732         hwmon_device_unregister(data->hwmon_dev);
 733         sysfs_remove_group(&client->dev.kobj, &lm90_group);
 734         device_remove_file(&client->dev, &dev_attr_pec);
 735         if (data->kind != max6657)
 736                 device_remove_file(&client->dev,
 737                                    &sensor_dev_attr_temp2_offset.dev_attr);
 738
 739         kfree(data);
 740         return 0;
 741 }
 742
 743 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
 744 {
 745         int err;
 746         u8 oldh, newh, l;
 747
 748         /*
 749          * There is a trick here. We have to read two registers to have the
 750          * sensor temperature, but we have to beware a conversion could occur
 751          * inbetween the readings. The datasheet says we should either use
 752          * the one-shot conversion register, which we don't want to do
 753          * (disables hardware monitoring) or monitor the busy bit, which is
 754          * impossible (we can't read the values and monitor that bit at the
 755          * exact same time). So the solution used here is to read the high
 756          * byte once, then the low byte, then the high byte again. If the new
 757          * high byte matches the old one, then we have a valid reading. Else
 758          * we have to read the low byte again, and now we believe we have a
 759          * correct reading.
 760          */
 761         if ((err = lm90_read_reg(client, regh, &oldh))
 762          || (err = lm90_read_reg(client, regl, &l))
 763          || (err = lm90_read_reg(client, regh, &newh)))
 764                 return err;
 765         if (oldh != newh) {
 766                 err = lm90_read_reg(client, regl, &l);
 767                 if (err)
 768                         return err;
 769         }
 770         *value = (newh << 8) | l;
 771
 772         return 0;
 773 }
 774
 775 static struct lm90_data *lm90_update_device(struct device *dev)
 776 {
 777         struct i2c_client *client = to_i2c_client(dev);
 778         struct lm90_data *data = i2c_get_clientdata(client);
 779
 780         mutex_lock(&data->update_lock);
 781
 782         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 783                 u8 h, l;
 784
 785                 dev_dbg(&client->dev, "Updating lm90 data.\n");
 786                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
 787                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
 788                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
 789                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
 790                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 791
 792                 if (data->kind == max6657) {
 793                         lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
 794                                     MAX6657_REG_R_LOCAL_TEMPL,
 795                                     &data->temp11[4]);
 796                 } else {
 797                         if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
 798                                           &h) == 0)
 799                                 data->temp11[4] = h << 8;
 800                 }
 801                 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 802                             LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
 803
 804                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0
 805                  && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
 806                         data->temp11[1] = (h << 8) | l;
 807                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0
 808                  && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
 809                         data->temp11[2] = (h << 8) | l;
 810                 if (data->kind != max6657) {
 811                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 812                                           &h) == 0
 813                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 814                                           &l) == 0)
 815                                 data->temp11[3] = (h << 8) | l;
 816                 }
 817                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 818
 819                 data->last_updated = jiffies;
 820                 data->valid = 1;
 821         }
 822
 823         mutex_unlock(&data->update_lock);
 824
 825         return data;
 826 }
 827
 828 static int __init sensors_lm90_init(void)
 829 {
 830         return i2c_add_driver(&lm90_driver);
 831 }
 832
 833 static void __exit sensors_lm90_exit(void)
 834 {
 835         i2c_del_driver(&lm90_driver);
 836 }
 837
 838 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 839 MODULE_DESCRIPTION("LM90/ADM1032 driver");
 840 MODULE_LICENSE("GPL");
 841
 842 module_init(sensors_lm90_init);
 843 module_exit(sensors_lm90_exit);