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