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