drivers/hwmon/lm90.c

   1 /*
   2  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *          monitoring
   4  * Copyright (C) 2003-2006  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 /*
 153  * Conversions and various macros
 154  * For local temperatures and limits, critical limits and the hysteresis
 155  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 156  * For remote temperatures and limits, it uses signed 11-bit values with
 157  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
 158  */
 159
 160 #define TEMP1_FROM_REG(val)     ((val) * 1000)
 161 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
 162                                  (val) >= 127000 ? 127 : \
 163                                  (val) < 0 ? ((val) - 500) / 1000 : \
 164                                  ((val) + 500) / 1000)
 165 #define TEMP2_FROM_REG(val)     ((val) / 32 * 125)
 166 #define TEMP2_TO_REG(val)       ((val) <= -128000 ? 0x8000 : \
 167                                  (val) >= 127875 ? 0x7FE0 : \
 168                                  (val) < 0 ? ((val) - 62) / 125 * 32 : \
 169                                  ((val) + 62) / 125 * 32)
 170 #define HYST_TO_REG(val)        ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
 171                                  ((val) + 500) / 1000)
 172
 173 /*
 174  * ADT7461 is almost identical to LM90 except that attempts to write
 175  * values that are outside the range 0 < temp < 127 are treated as
 176  * the boundary value.
 177  */
 178
 179 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 180                                  (val) >= 127000 ? 127 : \
 181                                  ((val) + 500) / 1000)
 182 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 183                                  (val) >= 127750 ? 0x7FC0 : \
 184                                  ((val) + 125) / 250 * 64)
 185
 186 /*
 187  * Functions declaration
 188  */
 189
 190 static int lm90_attach_adapter(struct i2c_adapter *adapter);
 191 static int lm90_detect(struct i2c_adapter *adapter, int address,
 192         int kind);
 193 static void lm90_init_client(struct i2c_client *client);
 194 static int lm90_detach_client(struct i2c_client *client);
 195 static struct lm90_data *lm90_update_device(struct device *dev);
 196
 197 /*
 198  * Driver data (common to all clients)
 199  */
 200
 201 static struct i2c_driver lm90_driver = {
 202         .driver = {
 203                 .name   = "lm90",
 204         },
 205         .attach_adapter = lm90_attach_adapter,
 206         .detach_client  = lm90_detach_client,
 207 };
 208
 209 /*
 210  * Client data (each client gets its own)
 211  */
 212
 213 struct lm90_data {
 214         struct i2c_client client;
 215         struct device *hwmon_dev;
 216         struct mutex update_lock;
 217         char valid; /* zero until following fields are valid */
 218         unsigned long last_updated; /* in jiffies */
 219         int kind;
 220
 221         /* registers values */
 222         s8 temp8[5];    /* 0: local input
 223                            1: local low limit
 224                            2: local high limit
 225                            3: local critical limit
 226                            4: remote critical limit */
 227         s16 temp11[4];  /* 0: remote input
 228                            1: remote low limit
 229                            2: remote high limit
 230                            3: remote offset (except max6657) */
 231         u8 temp_hyst;
 232         u8 alarms; /* bitvector */
 233 };
 234
 235 /*
 236  * Sysfs stuff
 237  */
 238
 239 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 240                           char *buf)
 241 {
 242         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 243         struct lm90_data *data = lm90_update_device(dev);
 244         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
 245 }
 246
 247 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 248                          const char *buf, size_t count)
 249 {
 250         static const u8 reg[4] = {
 251                 LM90_REG_W_LOCAL_LOW,
 252                 LM90_REG_W_LOCAL_HIGH,
 253                 LM90_REG_W_LOCAL_CRIT,
 254                 LM90_REG_W_REMOTE_CRIT,
 255         };
 256
 257         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 258         struct i2c_client *client = to_i2c_client(dev);
 259         struct lm90_data *data = i2c_get_clientdata(client);
 260         long val = simple_strtol(buf, NULL, 10);
 261         int nr = attr->index;
 262
 263         mutex_lock(&data->update_lock);
 264         if (data->kind == adt7461)
 265                 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
 266         else
 267                 data->temp8[nr] = TEMP1_TO_REG(val);
 268         i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
 269         mutex_unlock(&data->update_lock);
 270         return count;
 271 }
 272
 273 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 274                            char *buf)
 275 {
 276         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 277         struct lm90_data *data = lm90_update_device(dev);
 278         return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
 279 }
 280
 281 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 282                           const char *buf, size_t count)
 283 {
 284         static const u8 reg[6] = {
 285                 LM90_REG_W_REMOTE_LOWH,
 286                 LM90_REG_W_REMOTE_LOWL,
 287                 LM90_REG_W_REMOTE_HIGHH,
 288                 LM90_REG_W_REMOTE_HIGHL,
 289                 LM90_REG_W_REMOTE_OFFSH,
 290                 LM90_REG_W_REMOTE_OFFSL,
 291         };
 292
 293         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 294         struct i2c_client *client = to_i2c_client(dev);
 295         struct lm90_data *data = i2c_get_clientdata(client);
 296         long val = simple_strtol(buf, NULL, 10);
 297         int nr = attr->index;
 298
 299         mutex_lock(&data->update_lock);
 300         if (data->kind == adt7461)
 301                 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
 302         else
 303                 data->temp11[nr] = TEMP2_TO_REG(val);
 304         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
 305                                   data->temp11[nr] >> 8);
 306         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
 307                                   data->temp11[nr] & 0xff);
 308         mutex_unlock(&data->update_lock);
 309         return count;
 310 }
 311
 312 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
 313                              char *buf)
 314 {
 315         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 316         struct lm90_data *data = lm90_update_device(dev);
 317         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
 318                        - TEMP1_FROM_REG(data->temp_hyst));
 319 }
 320
 321 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 322                             const char *buf, size_t count)
 323 {
 324         struct i2c_client *client = to_i2c_client(dev);
 325         struct lm90_data *data = i2c_get_clientdata(client);
 326         long val = simple_strtol(buf, NULL, 10);
 327         long hyst;
 328
 329         mutex_lock(&data->update_lock);
 330         hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
 331         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 332                                   HYST_TO_REG(hyst));
 333         mutex_unlock(&data->update_lock);
 334         return count;
 335 }
 336
 337 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 338                            char *buf)
 339 {
 340         struct lm90_data *data = lm90_update_device(dev);
 341         return sprintf(buf, "%d\n", data->alarms);
 342 }
 343
 344 static ssize_t show_alarm(struct device *dev, struct device_attribute
 345                           *devattr, char *buf)
 346 {
 347         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 348         struct lm90_data *data = lm90_update_device(dev);
 349         int bitnr = attr->index;
 350
 351         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 352 }
 353
 354 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
 355 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 356 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 357         set_temp8, 1);
 358 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 359         set_temp11, 1);
 360 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 361         set_temp8, 2);
 362 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 363         set_temp11, 2);
 364 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 365         set_temp8, 3);
 366 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 367         set_temp8, 4);
 368 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 369         set_temphyst, 3);
 370 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
 371 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 372         set_temp11, 3);
 373
 374 /* Individual alarm files */
 375 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 376 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 377 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 378 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 379 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 380 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 381 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 382 /* Raw alarm file for compatibility */
 383 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 384
 385 static struct attribute *lm90_attributes[] = {
 386         &sensor_dev_attr_temp1_input.dev_attr.attr,
 387         &sensor_dev_attr_temp2_input.dev_attr.attr,
 388         &sensor_dev_attr_temp1_min.dev_attr.attr,
 389         &sensor_dev_attr_temp2_min.dev_attr.attr,
 390         &sensor_dev_attr_temp1_max.dev_attr.attr,
 391         &sensor_dev_attr_temp2_max.dev_attr.attr,
 392         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 393         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 394         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 395         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 396
 397         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 398         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 399         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 400         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 401         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 402         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 403         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 404         &dev_attr_alarms.attr,
 405         NULL
 406 };
 407
 408 static const struct attribute_group lm90_group = {
 409         .attrs = lm90_attributes,
 410 };
 411
 412 /* pec used for ADM1032 only */
 413 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 414                         char *buf)
 415 {
 416         struct i2c_client *client = to_i2c_client(dev);
 417         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 418 }
 419
 420 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 421                        const char *buf, size_t count)
 422 {
 423         struct i2c_client *client = to_i2c_client(dev);
 424         long val = simple_strtol(buf, NULL, 10);
 425
 426         switch (val) {
 427         case 0:
 428                 client->flags &= ~I2C_CLIENT_PEC;
 429                 break;
 430         case 1:
 431                 client->flags |= I2C_CLIENT_PEC;
 432                 break;
 433         default:
 434                 return -EINVAL;
 435         }
 436
 437         return count;
 438 }
 439
 440 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 441
 442 /*
 443  * Real code
 444  */
 445
 446 /* The ADM1032 supports PEC but not on write byte transactions, so we need
 447    to explicitly ask for a transaction without PEC. */
 448 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 449 {
 450         return i2c_smbus_xfer(client->adapter, client->addr,
 451                               client->flags & ~I2C_CLIENT_PEC,
 452                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 453 }
 454
 455 /* It is assumed that client->update_lock is held (unless we are in
 456    detection or initialization steps). This matters when PEC is enabled,
 457    because we don't want the address pointer to change between the write
 458    byte and the read byte transactions. */
 459 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
 460 {
 461         int err;
 462
 463         if (client->flags & I2C_CLIENT_PEC) {
 464                 err = adm1032_write_byte(client, reg);
 465                 if (err >= 0)
 466                         err = i2c_smbus_read_byte(client);
 467         } else
 468                 err = i2c_smbus_read_byte_data(client, reg);
 469
 470         if (err < 0) {
 471                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 472                          reg, err);
 473                 return err;
 474         }
 475         *value = err;
 476
 477         return 0;
 478 }
 479
 480 static int lm90_attach_adapter(struct i2c_adapter *adapter)
 481 {
 482         if (!(adapter->class & I2C_CLASS_HWMON))
 483                 return 0;
 484         return i2c_probe(adapter, &addr_data, lm90_detect);
 485 }
 486
 487 /*
 488  * The following function does more than just detection. If detection
 489  * succeeds, it also registers the new chip.
 490  */
 491 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
 492 {
 493         struct i2c_client *new_client;
 494         struct lm90_data *data;
 495         int err = 0;
 496         const char *name = "";
 497
 498         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 499                 goto exit;
 500
 501         if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
 502                 err = -ENOMEM;
 503                 goto exit;
 504         }
 505
 506         /* The common I2C client data is placed right before the
 507            LM90-specific data. */
 508         new_client = &data->client;
 509         i2c_set_clientdata(new_client, data);
 510         new_client->addr = address;
 511         new_client->adapter = adapter;
 512         new_client->driver = &lm90_driver;
 513         new_client->flags = 0;
 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                         goto exit_free;
 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                                 goto exit_free;
 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                         goto exit_free;
 614                 }
 615         }
 616
 617         if (kind == lm90) {
 618                 name = "lm90";
 619         } else if (kind == adm1032) {
 620                 name = "adm1032";
 621                 /* The ADM1032 supports PEC, but only if combined
 622                    transactions are not used. */
 623                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 624                         new_client->flags |= I2C_CLIENT_PEC;
 625         } else if (kind == lm99) {
 626                 name = "lm99";
 627         } else if (kind == lm86) {
 628                 name = "lm86";
 629         } else if (kind == max6657) {
 630                 name = "max6657";
 631         } else if (kind == max6680) {
 632                 name = "max6680";
 633         } else if (kind == adt7461) {
 634                 name = "adt7461";
 635         }
 636
 637         /* We can fill in the remaining client fields */
 638         strlcpy(new_client->name, name, I2C_NAME_SIZE);
 639         data->valid = 0;
 640         data->kind = kind;
 641         mutex_init(&data->update_lock);
 642
 643         /* Tell the I2C layer a new client has arrived */
 644         if ((err = i2c_attach_client(new_client)))
 645                 goto exit_free;
 646
 647         /* Initialize the LM90 chip */
 648         lm90_init_client(new_client);
 649
 650         /* Register sysfs hooks */
 651         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
 652                 goto exit_detach;
 653         if (new_client->flags & I2C_CLIENT_PEC) {
 654                 if ((err = device_create_file(&new_client->dev,
 655                                               &dev_attr_pec)))
 656                         goto exit_remove_files;
 657         }
 658         if (data->kind != max6657) {
 659                 if ((err = device_create_file(&new_client->dev,
 660                                 &sensor_dev_attr_temp2_offset.dev_attr)))
 661                         goto exit_remove_files;
 662         }
 663
 664         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 665         if (IS_ERR(data->hwmon_dev)) {
 666                 err = PTR_ERR(data->hwmon_dev);
 667                 goto exit_remove_files;
 668         }
 669
 670         return 0;
 671
 672 exit_remove_files:
 673         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
 674         device_remove_file(&new_client->dev, &dev_attr_pec);
 675 exit_detach:
 676         i2c_detach_client(new_client);
 677 exit_free:
 678         kfree(data);
 679 exit:
 680         return err;
 681 }
 682
 683 static void lm90_init_client(struct i2c_client *client)
 684 {
 685         u8 config, config_orig;
 686         struct lm90_data *data = i2c_get_clientdata(client);
 687
 688         /*
 689          * Start the conversions.
 690          */
 691         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 692                                   5); /* 2 Hz */
 693         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 694                 dev_warn(&client->dev, "Initialization failed!\n");
 695                 return;
 696         }
 697         config_orig = config;
 698
 699         /*
 700          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
 701          * 0.125 degree resolution) and range (0x08, extend range
 702          * to -64 degree) mode for the remote temperature sensor.
 703          */
 704         if (data->kind == max6680) {
 705                 config |= 0x18;
 706         }
 707
 708         config &= 0xBF; /* run */
 709         if (config != config_orig) /* Only write if changed */
 710                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 711 }
 712
 713 static int lm90_detach_client(struct i2c_client *client)
 714 {
 715         struct lm90_data *data = i2c_get_clientdata(client);
 716         int err;
 717
 718         hwmon_device_unregister(data->hwmon_dev);
 719         sysfs_remove_group(&client->dev.kobj, &lm90_group);
 720         device_remove_file(&client->dev, &dev_attr_pec);
 721         if (data->kind != max6657)
 722                 device_remove_file(&client->dev,
 723                                    &sensor_dev_attr_temp2_offset.dev_attr);
 724
 725         if ((err = i2c_detach_client(client)))
 726                 return err;
 727
 728         kfree(data);
 729         return 0;
 730 }
 731
 732 static struct lm90_data *lm90_update_device(struct device *dev)
 733 {
 734         struct i2c_client *client = to_i2c_client(dev);
 735         struct lm90_data *data = i2c_get_clientdata(client);
 736
 737         mutex_lock(&data->update_lock);
 738
 739         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 740                 u8 oldh, newh, l;
 741
 742                 dev_dbg(&client->dev, "Updating lm90 data.\n");
 743                 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
 744                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
 745                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
 746                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
 747                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
 748                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 749
 750                 /*
 751                  * There is a trick here. We have to read two registers to
 752                  * have the remote sensor temperature, but we have to beware
 753                  * a conversion could occur inbetween the readings. The
 754                  * datasheet says we should either use the one-shot
 755                  * conversion register, which we don't want to do (disables
 756                  * hardware monitoring) or monitor the busy bit, which is
 757                  * impossible (we can't read the values and monitor that bit
 758                  * at the exact same time). So the solution used here is to
 759                  * read the high byte once, then the low byte, then the high
 760                  * byte again. If the new high byte matches the old one,
 761                  * then we have a valid reading. Else we have to read the low
 762                  * byte again, and now we believe we have a correct reading.
 763                  */
 764                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
 765                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
 766                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
 767                  && (newh == oldh
 768                   || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
 769                         data->temp11[0] = (newh << 8) | l;
 770
 771                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
 772                  && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
 773                         data->temp11[1] = (newh << 8) | l;
 774                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
 775                  && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
 776                         data->temp11[2] = (newh << 8) | l;
 777                 if (data->kind != max6657) {
 778                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 779                                           &newh) == 0
 780                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 781                                           &l) == 0)
 782                                 data->temp11[3] = (newh << 8) | l;
 783                 }
 784                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 785
 786                 data->last_updated = jiffies;
 787                 data->valid = 1;
 788         }
 789
 790         mutex_unlock(&data->update_lock);
 791
 792         return data;
 793 }
 794
 795 static int __init sensors_lm90_init(void)
 796 {
 797         return i2c_add_driver(&lm90_driver);
 798 }
 799
 800 static void __exit sensors_lm90_exit(void)
 801 {
 802         i2c_del_driver(&lm90_driver);
 803 }
 804
 805 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 806 MODULE_DESCRIPTION("LM90/ADM1032 driver");
 807 MODULE_LICENSE("GPL");
 808
 809 module_init(sensors_lm90_init);
 810 module_exit(sensors_lm90_exit);