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 if (data->kind == max6657 || data->kind == max6680)
 327                 data->temp11[nr] = TEMP1_TO_REG(val) << 8;
 328         else
 329                 data->temp11[nr] = TEMP2_TO_REG(val);
 330
 331         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
 332                                   data->temp11[nr] >> 8);
 333         if (data->kind != max6657 && data->kind != max6680)
 334                 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
 335                                           data->temp11[nr] & 0xff);
 336         mutex_unlock(&data->update_lock);
 337         return count;
 338 }
 339
 340 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
 341                              char *buf)
 342 {
 343         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 344         struct lm90_data *data = lm90_update_device(dev);
 345         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
 346                        - TEMP1_FROM_REG(data->temp_hyst));
 347 }
 348
 349 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 350                             const char *buf, size_t count)
 351 {
 352         struct i2c_client *client = to_i2c_client(dev);
 353         struct lm90_data *data = i2c_get_clientdata(client);
 354         long val = simple_strtol(buf, NULL, 10);
 355         long hyst;
 356
 357         mutex_lock(&data->update_lock);
 358         hyst = TEMP1_FROM_REG(data->temp8[2]) - val;
 359         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 360                                   HYST_TO_REG(hyst));
 361         mutex_unlock(&data->update_lock);
 362         return count;
 363 }
 364
 365 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 366                            char *buf)
 367 {
 368         struct lm90_data *data = lm90_update_device(dev);
 369         return sprintf(buf, "%d\n", data->alarms);
 370 }
 371
 372 static ssize_t show_alarm(struct device *dev, struct device_attribute
 373                           *devattr, char *buf)
 374 {
 375         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 376         struct lm90_data *data = lm90_update_device(dev);
 377         int bitnr = attr->index;
 378
 379         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 380 }
 381
 382 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
 383 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 384 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 385         set_temp8, 0);
 386 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 387         set_temp11, 1);
 388 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 389         set_temp8, 1);
 390 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 391         set_temp11, 2);
 392 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 393         set_temp8, 2);
 394 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 395         set_temp8, 3);
 396 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 397         set_temphyst, 2);
 398 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 399 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 400         set_temp11, 3);
 401
 402 /* Individual alarm files */
 403 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 404 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 405 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 406 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 407 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 408 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 409 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 410 /* Raw alarm file for compatibility */
 411 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 412
 413 static struct attribute *lm90_attributes[] = {
 414         &sensor_dev_attr_temp1_input.dev_attr.attr,
 415         &sensor_dev_attr_temp2_input.dev_attr.attr,
 416         &sensor_dev_attr_temp1_min.dev_attr.attr,
 417         &sensor_dev_attr_temp2_min.dev_attr.attr,
 418         &sensor_dev_attr_temp1_max.dev_attr.attr,
 419         &sensor_dev_attr_temp2_max.dev_attr.attr,
 420         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 421         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 422         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 423         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 424
 425         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 426         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 427         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 428         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 429         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 430         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 431         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 432         &dev_attr_alarms.attr,
 433         NULL
 434 };
 435
 436 static const struct attribute_group lm90_group = {
 437         .attrs = lm90_attributes,
 438 };
 439
 440 /* pec used for ADM1032 only */
 441 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 442                         char *buf)
 443 {
 444         struct i2c_client *client = to_i2c_client(dev);
 445         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 446 }
 447
 448 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 449                        const char *buf, size_t count)
 450 {
 451         struct i2c_client *client = to_i2c_client(dev);
 452         long val = simple_strtol(buf, NULL, 10);
 453
 454         switch (val) {
 455         case 0:
 456                 client->flags &= ~I2C_CLIENT_PEC;
 457                 break;
 458         case 1:
 459                 client->flags |= I2C_CLIENT_PEC;
 460                 break;
 461         default:
 462                 return -EINVAL;
 463         }
 464
 465         return count;
 466 }
 467
 468 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 469
 470 /*
 471  * Real code
 472  */
 473
 474 /* The ADM1032 supports PEC but not on write byte transactions, so we need
 475    to explicitly ask for a transaction without PEC. */
 476 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 477 {
 478         return i2c_smbus_xfer(client->adapter, client->addr,
 479                               client->flags & ~I2C_CLIENT_PEC,
 480                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 481 }
 482
 483 /* It is assumed that client->update_lock is held (unless we are in
 484    detection or initialization steps). This matters when PEC is enabled,
 485    because we don't want the address pointer to change between the write
 486    byte and the read byte transactions. */
 487 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
 488 {
 489         int err;
 490
 491         if (client->flags & I2C_CLIENT_PEC) {
 492                 err = adm1032_write_byte(client, reg);
 493                 if (err >= 0)
 494                         err = i2c_smbus_read_byte(client);
 495         } else
 496                 err = i2c_smbus_read_byte_data(client, reg);
 497
 498         if (err < 0) {
 499                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 500                          reg, err);
 501                 return err;
 502         }
 503         *value = err;
 504
 505         return 0;
 506 }
 507
 508 /* Return 0 if detection is successful, -ENODEV otherwise */
 509 static int lm90_detect(struct i2c_client *new_client, int kind,
 510                        struct i2c_board_info *info)
 511 {
 512         struct i2c_adapter *adapter = new_client->adapter;
 513         int address = new_client->addr;
 514         const char *name = "";
 515
 516         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 517                 return -ENODEV;
 518
 519         /*
 520          * Now we do the remaining detection. A negative kind means that
 521          * the driver was loaded with no force parameter (default), so we
 522          * must both detect and identify the chip. A zero kind means that
 523          * the driver was loaded with the force parameter, the detection
 524          * step shall be skipped. A positive kind means that the driver
 525          * was loaded with the force parameter and a given kind of chip is
 526          * requested, so both the detection and the identification steps
 527          * are skipped.
 528          */
 529
 530         /* Default to an LM90 if forced */
 531         if (kind == 0)
 532                 kind = lm90;
 533
 534         if (kind < 0) { /* detection and identification */
 535                 int man_id, chip_id, reg_config1, reg_convrate;
 536
 537                 if ((man_id = i2c_smbus_read_byte_data(new_client,
 538                                                 LM90_REG_R_MAN_ID)) < 0
 539                  || (chip_id = i2c_smbus_read_byte_data(new_client,
 540                                                 LM90_REG_R_CHIP_ID)) < 0
 541                  || (reg_config1 = i2c_smbus_read_byte_data(new_client,
 542                                                 LM90_REG_R_CONFIG1)) < 0
 543                  || (reg_convrate = i2c_smbus_read_byte_data(new_client,
 544                                                 LM90_REG_R_CONVRATE)) < 0)
 545                         return -ENODEV;
 546
 547                 if ((address == 0x4C || address == 0x4D)
 548                  && man_id == 0x01) { /* National Semiconductor */
 549                         int reg_config2;
 550
 551                         if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
 552                                                 LM90_REG_R_CONFIG2)) < 0)
 553                                 return -ENODEV;
 554
 555                         if ((reg_config1 & 0x2A) == 0x00
 556                          && (reg_config2 & 0xF8) == 0x00
 557                          && reg_convrate <= 0x09) {
 558                                 if (address == 0x4C
 559                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
 560                                         kind = lm90;
 561                                 } else
 562                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
 563                                         kind = lm99;
 564                                 } else
 565                                 if (address == 0x4C
 566                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
 567                                         kind = lm86;
 568                                 }
 569                         }
 570                 } else
 571                 if ((address == 0x4C || address == 0x4D)
 572                  && man_id == 0x41) { /* Analog Devices */
 573                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
 574                          && (reg_config1 & 0x3F) == 0x00
 575                          && reg_convrate <= 0x0A) {
 576                                 kind = adm1032;
 577                         } else
 578                         if (chip_id == 0x51 /* ADT7461 */
 579                          && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
 580                          && reg_convrate <= 0x0A) {
 581                                 kind = adt7461;
 582                         }
 583                 } else
 584                 if (man_id == 0x4D) { /* Maxim */
 585                         /*
 586                          * The MAX6657, MAX6658 and MAX6659 do NOT have a
 587                          * chip_id register. Reading from that address will
 588                          * return the last read value, which in our case is
 589                          * those of the man_id register. Likewise, the config1
 590                          * register seems to lack a low nibble, so the value
 591                          * will be those of the previous read, so in our case
 592                          * those of the man_id register.
 593                          */
 594                         if (chip_id == man_id
 595                          && (address == 0x4C || address == 0x4D)
 596                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
 597                          && reg_convrate <= 0x09) {
 598                                 kind = max6657;
 599                         } else
 600                         /* The chip_id register of the MAX6680 and MAX6681
 601                          * holds the revision of the chip.
 602                          * the lowest bit of the config1 register is unused
 603                          * and should return zero when read, so should the
 604                          * second to last bit of config1 (software reset)
 605                          */
 606                         if (chip_id == 0x01
 607                          && (reg_config1 & 0x03) == 0x00
 608                          && reg_convrate <= 0x07) {
 609                                 kind = max6680;
 610                         }
 611                 }
 612
 613                 if (kind <= 0) { /* identification failed */
 614                         dev_info(&adapter->dev,
 615                             "Unsupported chip (man_id=0x%02X, "
 616                             "chip_id=0x%02X).\n", man_id, chip_id);
 617                         return -ENODEV;
 618                 }
 619         }
 620
 621         /* Fill the i2c board info */
 622         if (kind == lm90) {
 623                 name = "lm90";
 624         } else if (kind == adm1032) {
 625                 name = "adm1032";
 626                 /* The ADM1032 supports PEC, but only if combined
 627                    transactions are not used. */
 628                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 629                         info->flags |= I2C_CLIENT_PEC;
 630         } else if (kind == lm99) {
 631                 name = "lm99";
 632         } else if (kind == lm86) {
 633                 name = "lm86";
 634         } else if (kind == max6657) {
 635                 name = "max6657";
 636         } else if (kind == max6680) {
 637                 name = "max6680";
 638         } else if (kind == adt7461) {
 639                 name = "adt7461";
 640         }
 641         strlcpy(info->type, name, I2C_NAME_SIZE);
 642
 643         return 0;
 644 }
 645
 646 static int lm90_probe(struct i2c_client *new_client,
 647                       const struct i2c_device_id *id)
 648 {
 649         struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
 650         struct lm90_data *data;
 651         int err;
 652
 653         data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
 654         if (!data) {
 655                 err = -ENOMEM;
 656                 goto exit;
 657         }
 658         i2c_set_clientdata(new_client, data);
 659         mutex_init(&data->update_lock);
 660
 661         /* Set the device type */
 662         data->kind = id->driver_data;
 663         if (data->kind == adm1032) {
 664                 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 665                         new_client->flags &= ~I2C_CLIENT_PEC;
 666         }
 667
 668         /* Initialize the LM90 chip */
 669         lm90_init_client(new_client);
 670
 671         /* Register sysfs hooks */
 672         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
 673                 goto exit_free;
 674         if (new_client->flags & I2C_CLIENT_PEC) {
 675                 if ((err = device_create_file(&new_client->dev,
 676                                               &dev_attr_pec)))
 677                         goto exit_remove_files;
 678         }
 679         if (data->kind != max6657) {
 680                 if ((err = device_create_file(&new_client->dev,
 681                                 &sensor_dev_attr_temp2_offset.dev_attr)))
 682                         goto exit_remove_files;
 683         }
 684
 685         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 686         if (IS_ERR(data->hwmon_dev)) {
 687                 err = PTR_ERR(data->hwmon_dev);
 688                 goto exit_remove_files;
 689         }
 690
 691         return 0;
 692
 693 exit_remove_files:
 694         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
 695         device_remove_file(&new_client->dev, &dev_attr_pec);
 696 exit_free:
 697         kfree(data);
 698 exit:
 699         return err;
 700 }
 701
 702 static void lm90_init_client(struct i2c_client *client)
 703 {
 704         u8 config, config_orig;
 705         struct lm90_data *data = i2c_get_clientdata(client);
 706
 707         /*
 708          * Start the conversions.
 709          */
 710         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 711                                   5); /* 2 Hz */
 712         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 713                 dev_warn(&client->dev, "Initialization failed!\n");
 714                 return;
 715         }
 716         config_orig = config;
 717
 718         /*
 719          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
 720          * 0.125 degree resolution) and range (0x08, extend range
 721          * to -64 degree) mode for the remote temperature sensor.
 722          */
 723         if (data->kind == max6680) {
 724                 config |= 0x18;
 725         }
 726
 727         config &= 0xBF; /* run */
 728         if (config != config_orig) /* Only write if changed */
 729                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 730 }
 731
 732 static int lm90_remove(struct i2c_client *client)
 733 {
 734         struct lm90_data *data = i2c_get_clientdata(client);
 735
 736         hwmon_device_unregister(data->hwmon_dev);
 737         sysfs_remove_group(&client->dev.kobj, &lm90_group);
 738         device_remove_file(&client->dev, &dev_attr_pec);
 739         if (data->kind != max6657)
 740                 device_remove_file(&client->dev,
 741                                    &sensor_dev_attr_temp2_offset.dev_attr);
 742
 743         kfree(data);
 744         return 0;
 745 }
 746
 747 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
 748 {
 749         int err;
 750         u8 oldh, newh, l;
 751
 752         /*
 753          * There is a trick here. We have to read two registers to have the
 754          * sensor temperature, but we have to beware a conversion could occur
 755          * inbetween the readings. The datasheet says we should either use
 756          * the one-shot conversion register, which we don't want to do
 757          * (disables hardware monitoring) or monitor the busy bit, which is
 758          * impossible (we can't read the values and monitor that bit at the
 759          * exact same time). So the solution used here is to read the high
 760          * byte once, then the low byte, then the high byte again. If the new
 761          * high byte matches the old one, then we have a valid reading. Else
 762          * we have to read the low byte again, and now we believe we have a
 763          * correct reading.
 764          */
 765         if ((err = lm90_read_reg(client, regh, &oldh))
 766          || (err = lm90_read_reg(client, regl, &l))
 767          || (err = lm90_read_reg(client, regh, &newh)))
 768                 return err;
 769         if (oldh != newh) {
 770                 err = lm90_read_reg(client, regl, &l);
 771                 if (err)
 772                         return err;
 773         }
 774         *value = (newh << 8) | l;
 775
 776         return 0;
 777 }
 778
 779 static struct lm90_data *lm90_update_device(struct device *dev)
 780 {
 781         struct i2c_client *client = to_i2c_client(dev);
 782         struct lm90_data *data = i2c_get_clientdata(client);
 783
 784         mutex_lock(&data->update_lock);
 785
 786         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 787                 u8 h, l;
 788
 789                 dev_dbg(&client->dev, "Updating lm90 data.\n");
 790                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
 791                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
 792                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
 793                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
 794                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 795
 796                 if (data->kind == max6657) {
 797                         lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
 798                                     MAX6657_REG_R_LOCAL_TEMPL,
 799                                     &data->temp11[4]);
 800                 } else {
 801                         if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
 802                                           &h) == 0)
 803                                 data->temp11[4] = h << 8;
 804                 }
 805                 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 806                             LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
 807
 808                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
 809                         data->temp11[1] = h << 8;
 810                         if (data->kind != max6657 && data->kind != max6680
 811                          && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
 812                                           &l) == 0)
 813                                 data->temp11[1] |= l;
 814                 }
 815                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
 816                         data->temp11[2] = h << 8;
 817                         if (data->kind != max6657 && data->kind != max6680
 818                          && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
 819                                           &l) == 0)
 820                                 data->temp11[2] |= l;
 821                 }
 822
 823                 if (data->kind != max6657) {
 824                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 825                                           &h) == 0
 826                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 827                                           &l) == 0)
 828                                 data->temp11[3] = (h << 8) | l;
 829                 }
 830                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 831
 832                 data->last_updated = jiffies;
 833                 data->valid = 1;
 834         }
 835
 836         mutex_unlock(&data->update_lock);
 837
 838         return data;
 839 }
 840
 841 static int __init sensors_lm90_init(void)
 842 {
 843         return i2c_add_driver(&lm90_driver);
 844 }
 845
 846 static void __exit sensors_lm90_exit(void)
 847 {
 848         i2c_del_driver(&lm90_driver);
 849 }
 850
 851 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 852 MODULE_DESCRIPTION("LM90/ADM1032 driver");
 853 MODULE_LICENSE("GPL");
 854
 855 module_init(sensors_lm90_init);
 856 module_exit(sensors_lm90_exit);