drivers/hwmon/lm90.c

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