SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/hwmon/lm90.c

   1 /*
   2  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *          monitoring
   4  * Copyright (C) 2003-2005  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 SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
 331 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 332 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 333         set_temp8, 1);
 334 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 335         set_temp11, 1);
 336 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 337         set_temp8, 2);
 338 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 339         set_temp11, 2);
 340 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 341         set_temp8, 3);
 342 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 343         set_temp8, 4);
 344 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 345         set_temphyst, 3);
 346 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
 347 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 348
 349 /* pec used for ADM1032 only */
 350 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
 351                         char *buf)
 352 {
 353         struct i2c_client *client = to_i2c_client(dev);
 354         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
 355 }
 356
 357 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
 358                        const char *buf, size_t count)
 359 {
 360         struct i2c_client *client = to_i2c_client(dev);
 361         long val = simple_strtol(buf, NULL, 10);
 362
 363         switch (val) {
 364         case 0:
 365                 client->flags &= ~I2C_CLIENT_PEC;
 366                 break;
 367         case 1:
 368                 client->flags |= I2C_CLIENT_PEC;
 369                 break;
 370         default:
 371                 return -EINVAL;
 372         }
 373
 374         return count;
 375 }
 376
 377 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
 378
 379 /*
 380  * Real code
 381  */
 382
 383 /* The ADM1032 supports PEC but not on write byte transactions, so we need
 384    to explicitely ask for a transaction without PEC. */
 385 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 386 {
 387         return i2c_smbus_xfer(client->adapter, client->addr,
 388                               client->flags & ~I2C_CLIENT_PEC,
 389                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 390 }
 391
 392 /* It is assumed that client->update_lock is held (unless we are in
 393    detection or initialization steps). This matters when PEC is enabled,
 394    because we don't want the address pointer to change between the write
 395    byte and the read byte transactions. */
 396 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
 397 {
 398         int err;
 399
 400         if (client->flags & I2C_CLIENT_PEC) {
 401                 err = adm1032_write_byte(client, reg);
 402                 if (err >= 0)
 403                         err = i2c_smbus_read_byte(client);
 404         } else
 405                 err = i2c_smbus_read_byte_data(client, reg);
 406
 407         if (err < 0) {
 408                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 409                          reg, err);
 410                 return err;
 411         }
 412         *value = err;
 413
 414         return 0;
 415 }
 416
 417 static int lm90_attach_adapter(struct i2c_adapter *adapter)
 418 {
 419         if (!(adapter->class & I2C_CLASS_HWMON))
 420                 return 0;
 421         return i2c_probe(adapter, &addr_data, lm90_detect);
 422 }
 423
 424 /*
 425  * The following function does more than just detection. If detection
 426  * succeeds, it also registers the new chip.
 427  */
 428 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
 429 {
 430         struct i2c_client *new_client;
 431         struct lm90_data *data;
 432         int err = 0;
 433         const char *name = "";
 434
 435         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 436                 goto exit;
 437
 438         if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
 439                 err = -ENOMEM;
 440                 goto exit;
 441         }
 442
 443         /* The common I2C client data is placed right before the
 444            LM90-specific data. */
 445         new_client = &data->client;
 446         i2c_set_clientdata(new_client, data);
 447         new_client->addr = address;
 448         new_client->adapter = adapter;
 449         new_client->driver = &lm90_driver;
 450         new_client->flags = 0;
 451
 452         /*
 453          * Now we do the remaining detection. A negative kind means that
 454          * the driver was loaded with no force parameter (default), so we
 455          * must both detect and identify the chip. A zero kind means that
 456          * the driver was loaded with the force parameter, the detection
 457          * step shall be skipped. A positive kind means that the driver
 458          * was loaded with the force parameter and a given kind of chip is
 459          * requested, so both the detection and the identification steps
 460          * are skipped.
 461          */
 462
 463         /* Default to an LM90 if forced */
 464         if (kind == 0)
 465                 kind = lm90;
 466
 467         if (kind < 0) { /* detection and identification */
 468                 u8 man_id, chip_id, reg_config1, reg_convrate;
 469
 470                 if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
 471                                   &man_id) < 0
 472                  || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
 473                                   &chip_id) < 0
 474                  || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
 475                                   &reg_config1) < 0
 476                  || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
 477                                   &reg_convrate) < 0)
 478                         goto exit_free;
 479
 480                 if (man_id == 0x01) { /* National Semiconductor */
 481                         u8 reg_config2;
 482
 483                         if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
 484                                           &reg_config2) < 0)
 485                                 goto exit_free;
 486
 487                         if ((reg_config1 & 0x2A) == 0x00
 488                          && (reg_config2 & 0xF8) == 0x00
 489                          && reg_convrate <= 0x09) {
 490                                 if (address == 0x4C
 491                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
 492                                         kind = lm90;
 493                                 } else
 494                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
 495                                         kind = lm99;
 496                                 } else
 497                                 if (address == 0x4C
 498                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
 499                                         kind = lm86;
 500                                 }
 501                         }
 502                 } else
 503                 if (man_id == 0x41) { /* Analog Devices */
 504                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
 505                          && (reg_config1 & 0x3F) == 0x00
 506                          && reg_convrate <= 0x0A) {
 507                                 kind = adm1032;
 508                         } else
 509                         if (chip_id == 0x51 /* ADT7461 */
 510                          && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
 511                          && reg_convrate <= 0x0A) {
 512                                 kind = adt7461;
 513                         }
 514                 } else
 515                 if (man_id == 0x4D) { /* Maxim */
 516                         /*
 517                          * The Maxim variants do NOT have a chip_id register.
 518                          * Reading from that address will return the last read
 519                          * value, which in our case is those of the man_id
 520                          * register. Likewise, the config1 register seems to
 521                          * lack a low nibble, so the value will be those of the
 522                          * previous read, so in our case those of the man_id
 523                          * register.
 524                          */
 525                         if (chip_id == man_id
 526                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
 527                          && reg_convrate <= 0x09) {
 528                                 kind = max6657;
 529                         }
 530                 }
 531
 532                 if (kind <= 0) { /* identification failed */
 533                         dev_info(&adapter->dev,
 534                             "Unsupported chip (man_id=0x%02X, "
 535                             "chip_id=0x%02X).\n", man_id, chip_id);
 536                         goto exit_free;
 537                 }
 538         }
 539
 540         if (kind == lm90) {
 541                 name = "lm90";
 542         } else if (kind == adm1032) {
 543                 name = "adm1032";
 544                 /* The ADM1032 supports PEC, but only if combined
 545                    transactions are not used. */
 546                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 547                         new_client->flags |= I2C_CLIENT_PEC;
 548         } else if (kind == lm99) {
 549                 name = "lm99";
 550         } else if (kind == lm86) {
 551                 name = "lm86";
 552         } else if (kind == max6657) {
 553                 name = "max6657";
 554         } else if (kind == adt7461) {
 555                 name = "adt7461";
 556         }
 557
 558         /* We can fill in the remaining client fields */
 559         strlcpy(new_client->name, name, I2C_NAME_SIZE);
 560         data->valid = 0;
 561         data->kind = kind;
 562         mutex_init(&data->update_lock);
 563
 564         /* Tell the I2C layer a new client has arrived */
 565         if ((err = i2c_attach_client(new_client)))
 566                 goto exit_free;
 567
 568         /* Initialize the LM90 chip */
 569         lm90_init_client(new_client);
 570
 571         /* Register sysfs hooks */
 572         data->class_dev = hwmon_device_register(&new_client->dev);
 573         if (IS_ERR(data->class_dev)) {
 574                 err = PTR_ERR(data->class_dev);
 575                 goto exit_detach;
 576         }
 577
 578         device_create_file(&new_client->dev,
 579                            &sensor_dev_attr_temp1_input.dev_attr);
 580         device_create_file(&new_client->dev,
 581                            &sensor_dev_attr_temp2_input.dev_attr);
 582         device_create_file(&new_client->dev,
 583                            &sensor_dev_attr_temp1_min.dev_attr);
 584         device_create_file(&new_client->dev,
 585                            &sensor_dev_attr_temp2_min.dev_attr);
 586         device_create_file(&new_client->dev,
 587                            &sensor_dev_attr_temp1_max.dev_attr);
 588         device_create_file(&new_client->dev,
 589                            &sensor_dev_attr_temp2_max.dev_attr);
 590         device_create_file(&new_client->dev,
 591                            &sensor_dev_attr_temp1_crit.dev_attr);
 592         device_create_file(&new_client->dev,
 593                            &sensor_dev_attr_temp2_crit.dev_attr);
 594         device_create_file(&new_client->dev,
 595                            &sensor_dev_attr_temp1_crit_hyst.dev_attr);
 596         device_create_file(&new_client->dev,
 597                            &sensor_dev_attr_temp2_crit_hyst.dev_attr);
 598         device_create_file(&new_client->dev, &dev_attr_alarms);
 599
 600         if (new_client->flags & I2C_CLIENT_PEC)
 601                 device_create_file(&new_client->dev, &dev_attr_pec);
 602
 603         return 0;
 604
 605 exit_detach:
 606         i2c_detach_client(new_client);
 607 exit_free:
 608         kfree(data);
 609 exit:
 610         return err;
 611 }
 612
 613 static void lm90_init_client(struct i2c_client *client)
 614 {
 615         u8 config;
 616
 617         /*
 618          * Start the conversions.
 619          */
 620         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
 621                                   5); /* 2 Hz */
 622         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
 623                 dev_warn(&client->dev, "Initialization failed!\n");
 624                 return;
 625         }
 626         if (config & 0x40)
 627                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
 628                                           config & 0xBF); /* run */
 629 }
 630
 631 static int lm90_detach_client(struct i2c_client *client)
 632 {
 633         struct lm90_data *data = i2c_get_clientdata(client);
 634         int err;
 635
 636         hwmon_device_unregister(data->class_dev);
 637
 638         if ((err = i2c_detach_client(client)))
 639                 return err;
 640
 641         kfree(data);
 642         return 0;
 643 }
 644
 645 static struct lm90_data *lm90_update_device(struct device *dev)
 646 {
 647         struct i2c_client *client = to_i2c_client(dev);
 648         struct lm90_data *data = i2c_get_clientdata(client);
 649
 650         mutex_lock(&data->update_lock);
 651
 652         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 653                 u8 oldh, newh, l;
 654
 655                 dev_dbg(&client->dev, "Updating lm90 data.\n");
 656                 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
 657                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
 658                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
 659                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
 660                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
 661                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 662
 663                 /*
 664                  * There is a trick here. We have to read two registers to
 665                  * have the remote sensor temperature, but we have to beware
 666                  * a conversion could occur inbetween the readings. The
 667                  * datasheet says we should either use the one-shot
 668                  * conversion register, which we don't want to do (disables
 669                  * hardware monitoring) or monitor the busy bit, which is
 670                  * impossible (we can't read the values and monitor that bit
 671                  * at the exact same time). So the solution used here is to
 672                  * read the high byte once, then the low byte, then the high
 673                  * byte again. If the new high byte matches the old one,
 674                  * then we have a valid reading. Else we have to read the low
 675                  * byte again, and now we believe we have a correct reading.
 676                  */
 677                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
 678                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
 679                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
 680                  && (newh == oldh
 681                   || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
 682                         data->temp11[0] = (newh << 8) | l;
 683
 684                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
 685                  && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
 686                         data->temp11[1] = (newh << 8) | l;
 687                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
 688                  && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
 689                         data->temp11[2] = (newh << 8) | l;
 690                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 691
 692                 data->last_updated = jiffies;
 693                 data->valid = 1;
 694         }
 695
 696         mutex_unlock(&data->update_lock);
 697
 698         return data;
 699 }
 700
 701 static int __init sensors_lm90_init(void)
 702 {
 703         return i2c_add_driver(&lm90_driver);
 704 }
 705
 706 static void __exit sensors_lm90_exit(void)
 707 {
 708         i2c_del_driver(&lm90_driver);
 709 }
 710
 711 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 712 MODULE_DESCRIPTION("LM90/ADM1032 driver");
 713 MODULE_LICENSE("GPL");
 714
 715 module_init(sensors_lm90_init);
 716 module_exit(sensors_lm90_exit);