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