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