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