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