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