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 unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a,
 105                                        0x29, 0x2a, 0x2b,
 106                                        0x4c, 0x4d, 0x4e,
 107                                        I2C_CLIENT_END };
 108
 109 /*
 110  * Insmod parameters
 111  */
 112
 113 I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
 114
 115 /*
 116  * The LM90 registers
 117  */
 118
 119 #define LM90_REG_R_MAN_ID               0xFE
 120 #define LM90_REG_R_CHIP_ID              0xFF
 121 #define LM90_REG_R_CONFIG1              0x03
 122 #define LM90_REG_W_CONFIG1              0x09
 123 #define LM90_REG_R_CONFIG2              0xBF
 124 #define LM90_REG_W_CONFIG2              0xBF
 125 #define LM90_REG_R_CONVRATE             0x04
 126 #define LM90_REG_W_CONVRATE             0x0A
 127 #define LM90_REG_R_STATUS               0x02
 128 #define LM90_REG_R_LOCAL_TEMP           0x00
 129 #define LM90_REG_R_LOCAL_HIGH           0x05
 130 #define LM90_REG_W_LOCAL_HIGH           0x0B
 131 #define LM90_REG_R_LOCAL_LOW            0x06
 132 #define LM90_REG_W_LOCAL_LOW            0x0C
 133 #define LM90_REG_R_LOCAL_CRIT           0x20
 134 #define LM90_REG_W_LOCAL_CRIT           0x20
 135 #define LM90_REG_R_REMOTE_TEMPH         0x01
 136 #define LM90_REG_R_REMOTE_TEMPL         0x10
 137 #define LM90_REG_R_REMOTE_OFFSH         0x11
 138 #define LM90_REG_W_REMOTE_OFFSH         0x11
 139 #define LM90_REG_R_REMOTE_OFFSL         0x12
 140 #define LM90_REG_W_REMOTE_OFFSL         0x12
 141 #define LM90_REG_R_REMOTE_HIGHH         0x07
 142 #define LM90_REG_W_REMOTE_HIGHH         0x0D
 143 #define LM90_REG_R_REMOTE_HIGHL         0x13
 144 #define LM90_REG_W_REMOTE_HIGHL         0x13
 145 #define LM90_REG_R_REMOTE_LOWH          0x08
 146 #define LM90_REG_W_REMOTE_LOWH          0x0E
 147 #define LM90_REG_R_REMOTE_LOWL          0x14
 148 #define LM90_REG_W_REMOTE_LOWL          0x14
 149 #define LM90_REG_R_REMOTE_CRIT          0x19
 150 #define LM90_REG_W_REMOTE_CRIT          0x19
 151 #define LM90_REG_R_TCRIT_HYST           0x21
 152 #define LM90_REG_W_TCRIT_HYST           0x21
 153
 154 /*
 155  * Conversions and various macros
 156  * For local temperatures and limits, critical limits and the hysteresis
 157  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 158  * For remote temperatures and limits, it uses signed 11-bit values with
 159  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
 160  */
 161
 162 #define TEMP1_FROM_REG(val)     ((val) * 1000)
 163 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
 164                                  (val) >= 127000 ? 127 : \
 165                                  (val) < 0 ? ((val) - 500) / 1000 : \
 166                                  ((val) + 500) / 1000)
 167 #define TEMP2_FROM_REG(val)     ((val) / 32 * 125)
 168 #define TEMP2_TO_REG(val)       ((val) <= -128000 ? 0x8000 : \
 169                                  (val) >= 127875 ? 0x7FE0 : \
 170                                  (val) < 0 ? ((val) - 62) / 125 * 32 : \
 171                                  ((val) + 62) / 125 * 32)
 172 #define HYST_TO_REG(val)        ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
 173                                  ((val) + 500) / 1000)
 174
 175 /*
 176  * ADT7461 is almost identical to LM90 except that attempts to write
 177  * values that are outside the range 0 < temp < 127 are treated as
 178  * the boundary value.
 179  */
 180
 181 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 182                                  (val) >= 127000 ? 127 : \
 183                                  ((val) + 500) / 1000)
 184 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
 185                                  (val) >= 127750 ? 0x7FC0 : \
 186                                  ((val) + 125) / 250 * 64)
 187
 188 /*
 189  * Functions declaration
 190  */
 191
 192 static int lm90_attach_adapter(struct i2c_adapter *adapter);
 193 static int lm90_detect(struct i2c_adapter *adapter, int address,
 194         int kind);
 195 static void lm90_init_client(struct i2c_client *client);
 196 static int lm90_detach_client(struct i2c_client *client);
 197 static struct lm90_data *lm90_update_device(struct device *dev);
 198
 199 /*
 200  * Driver data (common to all clients)
 201  */
 202
 203 static struct i2c_driver lm90_driver = {
 204         .driver = {
 205                 .name   = "lm90",
 206         },
 207         .id             = I2C_DRIVERID_LM90,
 208         .attach_adapter = lm90_attach_adapter,
 209         .detach_client  = lm90_detach_client,
 210 };
 211
 212 /*
 213  * Client data (each client gets its own)
 214  */
 215
 216 struct lm90_data {
 217         struct i2c_client client;
 218         struct device *hwmon_dev;
 219         struct mutex update_lock;
 220         char valid; /* zero until following fields are valid */
 221         unsigned long last_updated; /* in jiffies */
 222         int kind;
 223
 224         /* registers values */
 225         s8 temp8[5];    /* 0: local input
 226                            1: local low limit
 227                            2: local high limit
 228                            3: local critical limit
 229                            4: remote critical limit */
 230         s16 temp11[4];  /* 0: remote input
 231                            1: remote low limit
 232                            2: remote high limit
 233                            3: remote offset (except max6657) */
 234         u8 temp_hyst;
 235         u8 alarms; /* bitvector */
 236 };
 237
 238 /*
 239  * Sysfs stuff
 240  */
 241
 242 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 243                           char *buf)
 244 {
 245         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 246         struct lm90_data *data = lm90_update_device(dev);
 247         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
 248 }
 249
 250 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 251                          const char *buf, size_t count)
 252 {
 253         static const u8 reg[4] = {
 254                 LM90_REG_W_LOCAL_LOW,
 255                 LM90_REG_W_LOCAL_HIGH,
 256                 LM90_REG_W_LOCAL_CRIT,
 257                 LM90_REG_W_REMOTE_CRIT,
 258         };
 259
 260         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 261         struct i2c_client *client = to_i2c_client(dev);
 262         struct lm90_data *data = i2c_get_clientdata(client);
 263         long val = simple_strtol(buf, NULL, 10);
 264         int nr = attr->index;
 265
 266         mutex_lock(&data->update_lock);
 267         if (data->kind == adt7461)
 268                 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
 269         else
 270                 data->temp8[nr] = TEMP1_TO_REG(val);
 271         i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
 272         mutex_unlock(&data->update_lock);
 273         return count;
 274 }
 275
 276 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 277                            char *buf)
 278 {
 279         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 280         struct lm90_data *data = lm90_update_device(dev);
 281         return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
 282 }
 283
 284 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 285                           const char *buf, size_t count)
 286 {
 287         static const u8 reg[6] = {
 288                 LM90_REG_W_REMOTE_LOWH,
 289                 LM90_REG_W_REMOTE_LOWL,
 290                 LM90_REG_W_REMOTE_HIGHH,
 291                 LM90_REG_W_REMOTE_HIGHL,
 292                 LM90_REG_W_REMOTE_OFFSH,
 293                 LM90_REG_W_REMOTE_OFFSL,
 294         };
 295
 296         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 297         struct i2c_client *client = to_i2c_client(dev);
 298         struct lm90_data *data = i2c_get_clientdata(client);
 299         long val = simple_strtol(buf, NULL, 10);
 300         int nr = attr->index;
 301
 302         mutex_lock(&data->update_lock);
 303         if (data->kind == adt7461)
 304                 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
 305         else
 306                 data->temp11[nr] = TEMP2_TO_REG(val);
 307         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
 308                                   data->temp11[nr] >> 8);
 309         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
 310                                   data->temp11[nr] & 0xff);
 311         mutex_unlock(&data->update_lock);
 312         return count;
 313 }
 314
 315 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
 316                              char *buf)
 317 {
 318         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 319         struct lm90_data *data = lm90_update_device(dev);
 320         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
 321                        - TEMP1_FROM_REG(data->temp_hyst));
 322 }
 323
 324 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 325                             const char *buf, size_t count)
 326 {
 327         struct i2c_client *client = to_i2c_client(dev);
 328         struct lm90_data *data = i2c_get_clientdata(client);
 329         long val = simple_strtol(buf, NULL, 10);
 330         long hyst;
 331
 332         mutex_lock(&data->update_lock);
 333         hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
 334         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 335                                   HYST_TO_REG(hyst));
 336         mutex_unlock(&data->update_lock);
 337         return count;
 338 }
 339
 340 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 341                            char *buf)
 342 {
 343         struct lm90_data *data = lm90_update_device(dev);
 344         return sprintf(buf, "%d\n", data->alarms);
 345 }
 346
 347 static ssize_t show_alarm(struct device *dev, struct device_attribute
 348                           *devattr, char *buf)
 349 {
 350         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 351         struct lm90_data *data = lm90_update_device(dev);
 352         int bitnr = attr->index;
 353
 354         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 355 }
 356
 357 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
 358 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 359 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 360         set_temp8, 1);
 361 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 362         set_temp11, 1);
 363 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 364         set_temp8, 2);
 365 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 366         set_temp11, 2);
 367 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 368         set_temp8, 3);
 369 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 370         set_temp8, 4);
 371 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 372         set_temphyst, 3);
 373 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
 374 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 375         set_temp11, 3);
 376
 377 /* Individual alarm files */
 378 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 379 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 380 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 381 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 382 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 383 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 384 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 385 /* Raw alarm file for compatibility */
 386 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 387
 388 static struct attribute *lm90_attributes[] = {
 389         &sensor_dev_attr_temp1_input.dev_attr.attr,
 390         &sensor_dev_attr_temp2_input.dev_attr.attr,
 391         &sensor_dev_attr_temp1_min.dev_attr.attr,
 392         &sensor_dev_attr_temp2_min.dev_attr.attr,
 393         &sensor_dev_attr_temp1_max.dev_attr.attr,
 394         &sensor_dev_attr_temp2_max.dev_attr.attr,
 395         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 396         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 397         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 398         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 399
 400         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 401         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 402         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 403         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 404         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 405         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 406         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 407         &dev_attr_alarms.attr,
 408         NULL
 409 };
 410
 411 static const struct attribute_group lm90_group = {
 412         .attrs = lm90_attributes,
 413 };
 414
 415 /* pec used for ADM1032 only */
 416 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 417                         char *buf)
 418 {
 419         struct i2c_client *client = to_i2c_client(dev);
 420         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 421 }
 422
 423 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 424                        const char *buf, size_t count)
 425 {
 426         struct i2c_client *client = to_i2c_client(dev);
 427         long val = simple_strtol(buf, NULL, 10);
 428
 429         switch (val) {
 430         case 0:
 431                 client->flags &= ~I2C_CLIENT_PEC;
 432                 break;
 433         case 1:
 434                 client->flags |= I2C_CLIENT_PEC;
 435                 break;
 436         default:
 437                 return -EINVAL;
 438         }
 439
 440         return count;
 441 }
 442
 443 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 444
 445 /*
 446  * Real code
 447  */
 448
 449 /* The ADM1032 supports PEC but not on write byte transactions, so we need
 450    to explicitly ask for a transaction without PEC. */
 451 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 452 {
 453         return i2c_smbus_xfer(client->adapter, client->addr,
 454                               client->flags & ~I2C_CLIENT_PEC,
 455                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 456 }
 457
 458 /* It is assumed that client->update_lock is held (unless we are in
 459    detection or initialization steps). This matters when PEC is enabled,
 460    because we don't want the address pointer to change between the write
 461    byte and the read byte transactions. */
 462 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
 463 {
 464         int err;
 465
 466         if (client->flags & I2C_CLIENT_PEC) {
 467                 err = adm1032_write_byte(client, reg);
 468                 if (err >= 0)
 469                         err = i2c_smbus_read_byte(client);
 470         } else
 471                 err = i2c_smbus_read_byte_data(client, reg);
 472
 473         if (err < 0) {
 474                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 475                          reg, err);
 476                 return err;
 477         }
 478         *value = err;
 479
 480         return 0;
 481 }
 482
 483 static int lm90_attach_adapter(struct i2c_adapter *adapter)
 484 {
 485         if (!(adapter->class & I2C_CLASS_HWMON))
 486                 return 0;
 487         return i2c_probe(adapter, &addr_data, lm90_detect);
 488 }
 489
 490 /*
 491  * The following function does more than just detection. If detection
 492  * succeeds, it also registers the new chip.
 493  */
 494 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
 495 {
 496         struct i2c_client *new_client;
 497         struct lm90_data *data;
 498         int err = 0;
 499         const char *name = "";
 500
 501         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 502                 goto exit;
 503
 504         if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
 505                 err = -ENOMEM;
 506                 goto exit;
 507         }
 508
 509         /* The common I2C client data is placed right before the
 510            LM90-specific data. */
 511         new_client = &data->client;
 512         i2c_set_clientdata(new_client, data);
 513         new_client->addr = address;
 514         new_client->adapter = adapter;
 515         new_client->driver = &lm90_driver;
 516         new_client->flags = 0;
 517
 518         /*
 519          * Now we do the remaining detection. A negative kind means that
 520          * the driver was loaded with no force parameter (default), so we
 521          * must both detect and identify the chip. A zero kind means that
 522          * the driver was loaded with the force parameter, the detection
 523          * step shall be skipped. A positive kind means that the driver
 524          * was loaded with the force parameter and a given kind of chip is
 525          * requested, so both the detection and the identification steps
 526          * are skipped.
 527          */
 528
 529         /* Default to an LM90 if forced */
 530         if (kind == 0)
 531                 kind = lm90;
 532
 533         if (kind < 0) { /* detection and identification */
 534                 u8 man_id, chip_id, reg_config1, reg_convrate;
 535
 536                 if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
 537                                   &man_id) < 0
 538                  || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
 539                                   &chip_id) < 0
 540                  || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
 541                                   &reg_config1) < 0
 542                  || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
 543                                   &reg_convrate) < 0)
 544                         goto exit_free;
 545
 546                 if ((address == 0x4C || address == 0x4D)
 547                  && man_id == 0x01) { /* National Semiconductor */
 548                         u8 reg_config2;
 549
 550                         if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
 551                                           &reg_config2) < 0)
 552                                 goto exit_free;
 553
 554                         if ((reg_config1 & 0x2A) == 0x00
 555                          && (reg_config2 & 0xF8) == 0x00
 556                          && reg_convrate <= 0x09) {
 557                                 if (address == 0x4C
 558                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
 559                                         kind = lm90;
 560                                 } else
 561                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
 562                                         kind = lm99;
 563                                 } else
 564                                 if (address == 0x4C
 565                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
 566                                         kind = lm86;
 567                                 }
 568                         }
 569                 } else
 570                 if ((address == 0x4C || address == 0x4D)
 571                  && man_id == 0x41) { /* Analog Devices */
 572                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
 573                          && (reg_config1 & 0x3F) == 0x00
 574                          && reg_convrate <= 0x0A) {
 575                                 kind = adm1032;
 576                         } else
 577                         if (chip_id == 0x51 /* ADT7461 */
 578                          && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
 579                          && reg_convrate <= 0x0A) {
 580                                 kind = adt7461;
 581                         }
 582                 } else
 583                 if (man_id == 0x4D) { /* Maxim */
 584                         /*
 585                          * The MAX6657, MAX6658 and MAX6659 do NOT have a
 586                          * chip_id register. Reading from that address will
 587                          * return the last read value, which in our case is
 588                          * those of the man_id register. Likewise, the config1
 589                          * register seems to lack a low nibble, so the value
 590                          * will be those of the previous read, so in our case
 591                          * those of the man_id register.
 592                          */
 593                         if (chip_id == man_id
 594                          && (address == 0x4C || address == 0x4D)
 595                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
 596                          && reg_convrate <= 0x09) {
 597                                 kind = max6657;
 598                         } else
 599                         /* The chip_id register of the MAX6680 and MAX6681
 600                          * holds the revision of the chip.
 601                          * the lowest bit of the config1 register is unused
 602                          * and should return zero when read, so should the
 603                          * second to last bit of config1 (software reset)
 604                          */
 605                         if (chip_id == 0x01
 606                          && (reg_config1 & 0x03) == 0x00
 607                          && reg_convrate <= 0x07) {
 608                                 kind = max6680;
 609                         }
 610                 }
 611
 612                 if (kind <= 0) { /* identification failed */
 613                         dev_info(&adapter->dev,
 614                             "Unsupported chip (man_id=0x%02X, "
 615                             "chip_id=0x%02X).\n", man_id, chip_id);
 616                         goto exit_free;
 617                 }
 618         }
 619
 620         if (kind == lm90) {
 621                 name = "lm90";
 622         } else if (kind == adm1032) {
 623                 name = "adm1032";
 624                 /* The ADM1032 supports PEC, but only if combined
 625                    transactions are not used. */
 626                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 627                         new_client->flags |= I2C_CLIENT_PEC;
 628         } else if (kind == lm99) {
 629                 name = "lm99";
 630         } else if (kind == lm86) {
 631                 name = "lm86";
 632         } else if (kind == max6657) {
 633                 name = "max6657";
 634         } else if (kind == max6680) {
 635                 name = "max6680";
 636         } else if (kind == adt7461) {
 637                 name = "adt7461";
 638         }
 639
 640         /* We can fill in the remaining client fields */
 641         strlcpy(new_client->name, name, I2C_NAME_SIZE);
 642         data->valid = 0;
 643         data->kind = kind;
 644         mutex_init(&data->update_lock);
 645
 646         /* Tell the I2C layer a new client has arrived */
 647         if ((err = i2c_attach_client(new_client)))
 648                 goto exit_free;
 649
 650         /* Initialize the LM90 chip */
 651         lm90_init_client(new_client);
 652
 653         /* Register sysfs hooks */
 654         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
 655                 goto exit_detach;
 656         if (new_client->flags & I2C_CLIENT_PEC) {
 657                 if ((err = device_create_file(&new_client->dev,
 658                                               &dev_attr_pec)))
 659                         goto exit_remove_files;
 660         }
 661         if (data->kind != max6657) {
 662                 if ((err = device_create_file(&new_client->dev,
 663                                 &sensor_dev_attr_temp2_offset.dev_attr)))
 664                         goto exit_remove_files;
 665         }
 666
 667         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 668         if (IS_ERR(data->hwmon_dev)) {
 669                 err = PTR_ERR(data->hwmon_dev);
 670                 goto exit_remove_files;
 671         }
 672
 673         return 0;
 674
 675 exit_remove_files:
 676         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
 677         device_remove_file(&new_client->dev, &dev_attr_pec);
 678 exit_detach:
 679         i2c_detach_client(new_client);
 680 exit_free:
 681         kfree(data);
 682 exit:
 683         return err;
 684 }
 685
 686 static void lm90_init_client(struct i2c_client *client)
 687 {
 688         u8 config, config_orig;
 689         struct lm90_data *data = i2c_get_clientdata(client);
 690
 691         /*
 692          * Start the conversions.
 693          */
 694         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 695                                   5); /* 2 Hz */
 696         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 697                 dev_warn(&client->dev, "Initialization failed!\n");
 698                 return;
 699         }
 700         config_orig = config;
 701
 702         /*
 703          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
 704          * 0.125 degree resolution) and range (0x08, extend range
 705          * to -64 degree) mode for the remote temperature sensor.
 706          */
 707         if (data->kind == max6680) {
 708                 config |= 0x18;
 709         }
 710
 711         config &= 0xBF; /* run */
 712         if (config != config_orig) /* Only write if changed */
 713                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 714 }
 715
 716 static int lm90_detach_client(struct i2c_client *client)
 717 {
 718         struct lm90_data *data = i2c_get_clientdata(client);
 719         int err;
 720
 721         hwmon_device_unregister(data->hwmon_dev);
 722         sysfs_remove_group(&client->dev.kobj, &lm90_group);
 723         device_remove_file(&client->dev, &dev_attr_pec);
 724         if (data->kind != max6657)
 725                 device_remove_file(&client->dev,
 726                                    &sensor_dev_attr_temp2_offset.dev_attr);
 727
 728         if ((err = i2c_detach_client(client)))
 729                 return err;
 730
 731         kfree(data);
 732         return 0;
 733 }
 734
 735 static struct lm90_data *lm90_update_device(struct device *dev)
 736 {
 737         struct i2c_client *client = to_i2c_client(dev);
 738         struct lm90_data *data = i2c_get_clientdata(client);
 739
 740         mutex_lock(&data->update_lock);
 741
 742         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 743                 u8 oldh, newh, l;
 744
 745                 dev_dbg(&client->dev, "Updating lm90 data.\n");
 746                 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
 747                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
 748                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
 749                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
 750                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
 751                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 752
 753                 /*
 754                  * There is a trick here. We have to read two registers to
 755                  * have the remote sensor temperature, but we have to beware
 756                  * a conversion could occur inbetween the readings. The
 757                  * datasheet says we should either use the one-shot
 758                  * conversion register, which we don't want to do (disables
 759                  * hardware monitoring) or monitor the busy bit, which is
 760                  * impossible (we can't read the values and monitor that bit
 761                  * at the exact same time). So the solution used here is to
 762                  * read the high byte once, then the low byte, then the high
 763                  * byte again. If the new high byte matches the old one,
 764                  * then we have a valid reading. Else we have to read the low
 765                  * byte again, and now we believe we have a correct reading.
 766                  */
 767                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
 768                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
 769                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
 770                  && (newh == oldh
 771                   || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
 772                         data->temp11[0] = (newh << 8) | l;
 773
 774                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
 775                  && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
 776                         data->temp11[1] = (newh << 8) | l;
 777                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
 778                  && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
 779                         data->temp11[2] = (newh << 8) | l;
 780                 if (data->kind != max6657) {
 781                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 782                                           &newh) == 0
 783                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 784                                           &l) == 0)
 785                                 data->temp11[3] = (newh << 8) | l;
 786                 }
 787                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 788
 789                 data->last_updated = jiffies;
 790                 data->valid = 1;
 791         }
 792
 793         mutex_unlock(&data->update_lock);
 794
 795         return data;
 796 }
 797
 798 static int __init sensors_lm90_init(void)
 799 {
 800         return i2c_add_driver(&lm90_driver);
 801 }
 802
 803 static void __exit sensors_lm90_exit(void)
 804 {
 805         i2c_del_driver(&lm90_driver);
 806 }
 807
 808 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 809 MODULE_DESCRIPTION("LM90/ADM1032 driver");
 810 MODULE_LICENSE("GPL");
 811
 812 module_init(sensors_lm90_init);
 813 module_exit(sensors_lm90_exit);