drivers/hwmon/lm90.c

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