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