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