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_attach_adapter(struct i2c_adapter *adapter); 191 static int lm90_detect(struct i2c_adapter *adapter, int address, 192 int kind); 193 static void lm90_init_client(struct i2c_client *client); 194 static int lm90_detach_client(struct i2c_client *client); 195 static struct lm90_data *lm90_update_device(struct device *dev); 196 197 /* 198 * Driver data (common to all clients) 199 */ 200 201 static struct i2c_driver lm90_driver = { 202 .driver = { 203 .name = "lm90", 204 }, 205 .attach_adapter = lm90_attach_adapter, 206 .detach_client = lm90_detach_client, 207 }; 208 209 /* 210 * Client data (each client gets its own) 211 */ 212 213 struct lm90_data { 214 struct i2c_client client; 215 struct device *hwmon_dev; 216 struct mutex update_lock; 217 char valid; /* zero until following fields are valid */ 218 unsigned long last_updated; /* in jiffies */ 219 int kind; 220 221 /* registers values */ 222 s8 temp8[5]; /* 0: local input 223 1: local low limit 224 2: local high limit 225 3: local critical limit 226 4: remote critical limit */ 227 s16 temp11[4]; /* 0: remote input 228 1: remote low limit 229 2: remote high limit 230 3: remote offset (except max6657) */ 231 u8 temp_hyst; 232 u8 alarms; /* bitvector */ 233 }; 234 235 /* 236 * Sysfs stuff 237 */ 238 239 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr, 240 char *buf) 241 { 242 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 243 struct lm90_data *data = lm90_update_device(dev); 244 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])); 245 } 246 247 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr, 248 const char *buf, size_t count) 249 { 250 static const u8 reg[4] = { 251 LM90_REG_W_LOCAL_LOW, 252 LM90_REG_W_LOCAL_HIGH, 253 LM90_REG_W_LOCAL_CRIT, 254 LM90_REG_W_REMOTE_CRIT, 255 }; 256 257 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 258 struct i2c_client *client = to_i2c_client(dev); 259 struct lm90_data *data = i2c_get_clientdata(client); 260 long val = simple_strtol(buf, NULL, 10); 261 int nr = attr->index; 262 263 mutex_lock(&data->update_lock); 264 if (data->kind == adt7461) 265 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val); 266 else 267 data->temp8[nr] = TEMP1_TO_REG(val); 268 i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]); 269 mutex_unlock(&data->update_lock); 270 return count; 271 } 272 273 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr, 274 char *buf) 275 { 276 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 277 struct lm90_data *data = lm90_update_device(dev); 278 return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index])); 279 } 280 281 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr, 282 const char *buf, size_t count) 283 { 284 static const u8 reg[6] = { 285 LM90_REG_W_REMOTE_LOWH, 286 LM90_REG_W_REMOTE_LOWL, 287 LM90_REG_W_REMOTE_HIGHH, 288 LM90_REG_W_REMOTE_HIGHL, 289 LM90_REG_W_REMOTE_OFFSH, 290 LM90_REG_W_REMOTE_OFFSL, 291 }; 292 293 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 294 struct i2c_client *client = to_i2c_client(dev); 295 struct lm90_data *data = i2c_get_clientdata(client); 296 long val = simple_strtol(buf, NULL, 10); 297 int nr = attr->index; 298 299 mutex_lock(&data->update_lock); 300 if (data->kind == adt7461) 301 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val); 302 else 303 data->temp11[nr] = TEMP2_TO_REG(val); 304 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2], 305 data->temp11[nr] >> 8); 306 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1], 307 data->temp11[nr] & 0xff); 308 mutex_unlock(&data->update_lock); 309 return count; 310 } 311 312 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr, 313 char *buf) 314 { 315 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 316 struct lm90_data *data = lm90_update_device(dev); 317 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]) 318 - TEMP1_FROM_REG(data->temp_hyst)); 319 } 320 321 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy, 322 const char *buf, size_t count) 323 { 324 struct i2c_client *client = to_i2c_client(dev); 325 struct lm90_data *data = i2c_get_clientdata(client); 326 long val = simple_strtol(buf, NULL, 10); 327 long hyst; 328 329 mutex_lock(&data->update_lock); 330 hyst = TEMP1_FROM_REG(data->temp8[3]) - val; 331 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST, 332 HYST_TO_REG(hyst)); 333 mutex_unlock(&data->update_lock); 334 return count; 335 } 336 337 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy, 338 char *buf) 339 { 340 struct lm90_data *data = lm90_update_device(dev); 341 return sprintf(buf, "%d\n", data->alarms); 342 } 343 344 static ssize_t show_alarm(struct device *dev, struct device_attribute 345 *devattr, char *buf) 346 { 347 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 348 struct lm90_data *data = lm90_update_device(dev); 349 int bitnr = attr->index; 350 351 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1); 352 } 353 354 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0); 355 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0); 356 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8, 357 set_temp8, 1); 358 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11, 359 set_temp11, 1); 360 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8, 361 set_temp8, 2); 362 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11, 363 set_temp11, 2); 364 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8, 365 set_temp8, 3); 366 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8, 367 set_temp8, 4); 368 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst, 369 set_temphyst, 3); 370 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4); 371 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11, 372 set_temp11, 3); 373 374 /* Individual alarm files */ 375 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0); 376 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1); 377 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2); 378 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 379 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4); 380 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5); 381 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 382 /* Raw alarm file for compatibility */ 383 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 384 385 static struct attribute *lm90_attributes[] = { 386 &sensor_dev_attr_temp1_input.dev_attr.attr, 387 &sensor_dev_attr_temp2_input.dev_attr.attr, 388 &sensor_dev_attr_temp1_min.dev_attr.attr, 389 &sensor_dev_attr_temp2_min.dev_attr.attr, 390 &sensor_dev_attr_temp1_max.dev_attr.attr, 391 &sensor_dev_attr_temp2_max.dev_attr.attr, 392 &sensor_dev_attr_temp1_crit.dev_attr.attr, 393 &sensor_dev_attr_temp2_crit.dev_attr.attr, 394 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 395 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, 396 397 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 398 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 399 &sensor_dev_attr_temp2_fault.dev_attr.attr, 400 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 401 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 402 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 403 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 404 &dev_attr_alarms.attr, 405 NULL 406 }; 407 408 static const struct attribute_group lm90_group = { 409 .attrs = lm90_attributes, 410 }; 411 412 /* pec used for ADM1032 only */ 413 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy, 414 char *buf) 415 { 416 struct i2c_client *client = to_i2c_client(dev); 417 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC)); 418 } 419 420 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy, 421 const char *buf, size_t count) 422 { 423 struct i2c_client *client = to_i2c_client(dev); 424 long val = simple_strtol(buf, NULL, 10); 425 426 switch (val) { 427 case 0: 428 client->flags &= ~I2C_CLIENT_PEC; 429 break; 430 case 1: 431 client->flags |= I2C_CLIENT_PEC; 432 break; 433 default: 434 return -EINVAL; 435 } 436 437 return count; 438 } 439 440 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec); 441 442 /* 443 * Real code 444 */ 445 446 /* The ADM1032 supports PEC but not on write byte transactions, so we need 447 to explicitly ask for a transaction without PEC. */ 448 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value) 449 { 450 return i2c_smbus_xfer(client->adapter, client->addr, 451 client->flags & ~I2C_CLIENT_PEC, 452 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL); 453 } 454 455 /* It is assumed that client->update_lock is held (unless we are in 456 detection or initialization steps). This matters when PEC is enabled, 457 because we don't want the address pointer to change between the write 458 byte and the read byte transactions. */ 459 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value) 460 { 461 int err; 462 463 if (client->flags & I2C_CLIENT_PEC) { 464 err = adm1032_write_byte(client, reg); 465 if (err >= 0) 466 err = i2c_smbus_read_byte(client); 467 } else 468 err = i2c_smbus_read_byte_data(client, reg); 469 470 if (err < 0) { 471 dev_warn(&client->dev, "Register %#02x read failed (%d)\n", 472 reg, err); 473 return err; 474 } 475 *value = err; 476 477 return 0; 478 } 479 480 static int lm90_attach_adapter(struct i2c_adapter *adapter) 481 { 482 if (!(adapter->class & I2C_CLASS_HWMON)) 483 return 0; 484 return i2c_probe(adapter, &addr_data, lm90_detect); 485 } 486 487 /* 488 * The following function does more than just detection. If detection 489 * succeeds, it also registers the new chip. 490 */ 491 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind) 492 { 493 struct i2c_client *new_client; 494 struct lm90_data *data; 495 int err = 0; 496 const char *name = ""; 497 498 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 499 goto exit; 500 501 if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) { 502 err = -ENOMEM; 503 goto exit; 504 } 505 506 /* The common I2C client data is placed right before the 507 LM90-specific data. */ 508 new_client = &data->client; 509 i2c_set_clientdata(new_client, data); 510 new_client->addr = address; 511 new_client->adapter = adapter; 512 new_client->driver = &lm90_driver; 513 new_client->flags = 0; 514 515 /* 516 * Now we do the remaining detection. A negative kind means that 517 * the driver was loaded with no force parameter (default), so we 518 * must both detect and identify the chip. A zero kind means that 519 * the driver was loaded with the force parameter, the detection 520 * step shall be skipped. A positive kind means that the driver 521 * was loaded with the force parameter and a given kind of chip is 522 * requested, so both the detection and the identification steps 523 * are skipped. 524 */ 525 526 /* Default to an LM90 if forced */ 527 if (kind == 0) 528 kind = lm90; 529 530 if (kind < 0) { /* detection and identification */ 531 int man_id, chip_id, reg_config1, reg_convrate; 532 533 if ((man_id = i2c_smbus_read_byte_data(new_client, 534 LM90_REG_R_MAN_ID)) < 0 535 || (chip_id = i2c_smbus_read_byte_data(new_client, 536 LM90_REG_R_CHIP_ID)) < 0 537 || (reg_config1 = i2c_smbus_read_byte_data(new_client, 538 LM90_REG_R_CONFIG1)) < 0 539 || (reg_convrate = i2c_smbus_read_byte_data(new_client, 540 LM90_REG_R_CONVRATE)) < 0) 541 goto exit_free; 542 543 if ((address == 0x4C || address == 0x4D) 544 && man_id == 0x01) { /* National Semiconductor */ 545 int reg_config2; 546 547 if ((reg_config2 = i2c_smbus_read_byte_data(new_client, 548 LM90_REG_R_CONFIG2)) < 0) 549 goto exit_free; 550 551 if ((reg_config1 & 0x2A) == 0x00 552 && (reg_config2 & 0xF8) == 0x00 553 && reg_convrate <= 0x09) { 554 if (address == 0x4C 555 && (chip_id & 0xF0) == 0x20) { /* LM90 */ 556 kind = lm90; 557 } else 558 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */ 559 kind = lm99; 560 } else 561 if (address == 0x4C 562 && (chip_id & 0xF0) == 0x10) { /* LM86 */ 563 kind = lm86; 564 } 565 } 566 } else 567 if ((address == 0x4C || address == 0x4D) 568 && man_id == 0x41) { /* Analog Devices */ 569 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */ 570 && (reg_config1 & 0x3F) == 0x00 571 && reg_convrate <= 0x0A) { 572 kind = adm1032; 573 } else 574 if (chip_id == 0x51 /* ADT7461 */ 575 && (reg_config1 & 0x1F) == 0x00 /* check compat mode */ 576 && reg_convrate <= 0x0A) { 577 kind = adt7461; 578 } 579 } else 580 if (man_id == 0x4D) { /* Maxim */ 581 /* 582 * The MAX6657, MAX6658 and MAX6659 do NOT have a 583 * chip_id register. Reading from that address will 584 * return the last read value, which in our case is 585 * those of the man_id register. Likewise, the config1 586 * register seems to lack a low nibble, so the value 587 * will be those of the previous read, so in our case 588 * those of the man_id register. 589 */ 590 if (chip_id == man_id 591 && (address == 0x4C || address == 0x4D) 592 && (reg_config1 & 0x1F) == (man_id & 0x0F) 593 && reg_convrate <= 0x09) { 594 kind = max6657; 595 } else 596 /* The chip_id register of the MAX6680 and MAX6681 597 * holds the revision of the chip. 598 * the lowest bit of the config1 register is unused 599 * and should return zero when read, so should the 600 * second to last bit of config1 (software reset) 601 */ 602 if (chip_id == 0x01 603 && (reg_config1 & 0x03) == 0x00 604 && reg_convrate <= 0x07) { 605 kind = max6680; 606 } 607 } 608 609 if (kind <= 0) { /* identification failed */ 610 dev_info(&adapter->dev, 611 "Unsupported chip (man_id=0x%02X, " 612 "chip_id=0x%02X).\n", man_id, chip_id); 613 goto exit_free; 614 } 615 } 616 617 if (kind == lm90) { 618 name = "lm90"; 619 } else if (kind == adm1032) { 620 name = "adm1032"; 621 /* The ADM1032 supports PEC, but only if combined 622 transactions are not used. */ 623 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) 624 new_client->flags |= I2C_CLIENT_PEC; 625 } else if (kind == lm99) { 626 name = "lm99"; 627 } else if (kind == lm86) { 628 name = "lm86"; 629 } else if (kind == max6657) { 630 name = "max6657"; 631 } else if (kind == max6680) { 632 name = "max6680"; 633 } else if (kind == adt7461) { 634 name = "adt7461"; 635 } 636 637 /* We can fill in the remaining client fields */ 638 strlcpy(new_client->name, name, I2C_NAME_SIZE); 639 data->valid = 0; 640 data->kind = kind; 641 mutex_init(&data->update_lock); 642 643 /* Tell the I2C layer a new client has arrived */ 644 if ((err = i2c_attach_client(new_client))) 645 goto exit_free; 646 647 /* Initialize the LM90 chip */ 648 lm90_init_client(new_client); 649 650 /* Register sysfs hooks */ 651 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group))) 652 goto exit_detach; 653 if (new_client->flags & I2C_CLIENT_PEC) { 654 if ((err = device_create_file(&new_client->dev, 655 &dev_attr_pec))) 656 goto exit_remove_files; 657 } 658 if (data->kind != max6657) { 659 if ((err = device_create_file(&new_client->dev, 660 &sensor_dev_attr_temp2_offset.dev_attr))) 661 goto exit_remove_files; 662 } 663 664 data->hwmon_dev = hwmon_device_register(&new_client->dev); 665 if (IS_ERR(data->hwmon_dev)) { 666 err = PTR_ERR(data->hwmon_dev); 667 goto exit_remove_files; 668 } 669 670 return 0; 671 672 exit_remove_files: 673 sysfs_remove_group(&new_client->dev.kobj, &lm90_group); 674 device_remove_file(&new_client->dev, &dev_attr_pec); 675 exit_detach: 676 i2c_detach_client(new_client); 677 exit_free: 678 kfree(data); 679 exit: 680 return err; 681 } 682 683 static void lm90_init_client(struct i2c_client *client) 684 { 685 u8 config, config_orig; 686 struct lm90_data *data = i2c_get_clientdata(client); 687 688 /* 689 * Start the conversions. 690 */ 691 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, 692 5); /* 2 Hz */ 693 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) { 694 dev_warn(&client->dev, "Initialization failed!\n"); 695 return; 696 } 697 config_orig = config; 698 699 /* 700 * Put MAX6680/MAX8881 into extended resolution (bit 0x10, 701 * 0.125 degree resolution) and range (0x08, extend range 702 * to -64 degree) mode for the remote temperature sensor. 703 */ 704 if (data->kind == max6680) { 705 config |= 0x18; 706 } 707 708 config &= 0xBF; /* run */ 709 if (config != config_orig) /* Only write if changed */ 710 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config); 711 } 712 713 static int lm90_detach_client(struct i2c_client *client) 714 { 715 struct lm90_data *data = i2c_get_clientdata(client); 716 int err; 717 718 hwmon_device_unregister(data->hwmon_dev); 719 sysfs_remove_group(&client->dev.kobj, &lm90_group); 720 device_remove_file(&client->dev, &dev_attr_pec); 721 if (data->kind != max6657) 722 device_remove_file(&client->dev, 723 &sensor_dev_attr_temp2_offset.dev_attr); 724 725 if ((err = i2c_detach_client(client))) 726 return err; 727 728 kfree(data); 729 return 0; 730 } 731 732 static struct lm90_data *lm90_update_device(struct device *dev) 733 { 734 struct i2c_client *client = to_i2c_client(dev); 735 struct lm90_data *data = i2c_get_clientdata(client); 736 737 mutex_lock(&data->update_lock); 738 739 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) { 740 u8 oldh, newh, l; 741 742 dev_dbg(&client->dev, "Updating lm90 data.\n"); 743 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]); 744 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]); 745 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]); 746 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]); 747 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]); 748 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst); 749 750 /* 751 * There is a trick here. We have to read two registers to 752 * have the remote sensor temperature, but we have to beware 753 * a conversion could occur inbetween the readings. The 754 * datasheet says we should either use the one-shot 755 * conversion register, which we don't want to do (disables 756 * hardware monitoring) or monitor the busy bit, which is 757 * impossible (we can't read the values and monitor that bit 758 * at the exact same time). So the solution used here is to 759 * read the high byte once, then the low byte, then the high 760 * byte again. If the new high byte matches the old one, 761 * then we have a valid reading. Else we have to read the low 762 * byte again, and now we believe we have a correct reading. 763 */ 764 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0 765 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0 766 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0 767 && (newh == oldh 768 || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0)) 769 data->temp11[0] = (newh << 8) | l; 770 771 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0 772 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0) 773 data->temp11[1] = (newh << 8) | l; 774 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0 775 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0) 776 data->temp11[2] = (newh << 8) | l; 777 if (data->kind != max6657) { 778 if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH, 779 &newh) == 0 780 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL, 781 &l) == 0) 782 data->temp11[3] = (newh << 8) | l; 783 } 784 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms); 785 786 data->last_updated = jiffies; 787 data->valid = 1; 788 } 789 790 mutex_unlock(&data->update_lock); 791 792 return data; 793 } 794 795 static int __init sensors_lm90_init(void) 796 { 797 return i2c_add_driver(&lm90_driver); 798 } 799 800 static void __exit sensors_lm90_exit(void) 801 { 802 i2c_del_driver(&lm90_driver); 803 } 804 805 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 806 MODULE_DESCRIPTION("LM90/ADM1032 driver"); 807 MODULE_LICENSE("GPL"); 808 809 module_init(sensors_lm90_init); 810 module_exit(sensors_lm90_exit); 811