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); 1036