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