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