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