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