1 /* 2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (C) 2003-2010 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. 10 * 11 * This driver also supports the LM89 and LM99, two other sensor chips 12 * made by National Semiconductor. Both have an increased remote 13 * temperature measurement accuracy (1 degree), and the LM99 14 * additionally shifts remote temperatures (measured and limits) by 16 15 * degrees, which allows for higher temperatures measurement. 16 * Note that there is no way to differentiate between both chips. 17 * When device is auto-detected, the driver will assume an LM99. 18 * 19 * This driver also supports the LM86, another sensor chip made by 20 * National Semiconductor. It is exactly similar to the LM90 except it 21 * has a higher accuracy. 22 * 23 * This driver also supports the ADM1032, a sensor chip made by Analog 24 * Devices. That chip is similar to the LM90, with a few differences 25 * that are not handled by this driver. Among others, it has a higher 26 * accuracy than the LM90, much like the LM86 does. 27 * 28 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor 29 * chips made by Maxim. These chips are similar to the LM86. 30 * Note that there is no easy way to differentiate between the three 31 * variants. We use the device address to detect MAX6659, which will result 32 * in a detection as max6657 if it is on address 0x4c. The extra address 33 * and features of the MAX6659 are only supported if the chip is configured 34 * explicitly as max6659, or if its address is not 0x4c. 35 * These chips lack the remote temperature offset feature. 36 * 37 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and 38 * MAX6692 chips made by Maxim. These are again similar to the LM86, 39 * but they use unsigned temperature values and can report temperatures 40 * from 0 to 145 degrees. 41 * 42 * This driver also supports the MAX6680 and MAX6681, two other sensor 43 * chips made by Maxim. These are quite similar to the other Maxim 44 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can 45 * be treated identically. 46 * 47 * This driver also supports the MAX6695 and MAX6696, two other sensor 48 * chips made by Maxim. These are also quite similar to other Maxim 49 * chips, but support three temperature sensors instead of two. MAX6695 50 * and MAX6696 only differ in the pinout so they can be treated identically. 51 * 52 * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as 53 * NCT1008 from ON Semiconductor. The chips are supported in both compatibility 54 * and extended mode. They are mostly compatible with LM90 except for a data 55 * format difference for the temperature value registers. 56 * 57 * This driver also supports the SA56004 from Philips. This device is 58 * pin-compatible with the LM86, the ED/EDP parts are also address-compatible. 59 * 60 * This driver also supports the G781 from GMT. This device is compatible 61 * with the ADM1032. 62 * 63 * This driver also supports TMP451 from Texas Instruments. This device is 64 * supported in both compatibility and extended mode. It's mostly compatible 65 * with ADT7461 except for local temperature low byte register and max 66 * conversion rate. 67 * 68 * Since the LM90 was the first chipset supported by this driver, most 69 * comments will refer to this chipset, but are actually general and 70 * concern all supported chipsets, unless mentioned otherwise. 71 * 72 * This program is free software; you can redistribute it and/or modify 73 * it under the terms of the GNU General Public License as published by 74 * the Free Software Foundation; either version 2 of the License, or 75 * (at your option) any later version. 76 * 77 * This program is distributed in the hope that it will be useful, 78 * but WITHOUT ANY WARRANTY; without even the implied warranty of 79 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 80 * GNU General Public License for more details. 81 * 82 * You should have received a copy of the GNU General Public License 83 * along with this program; if not, write to the Free Software 84 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 85 */ 86 87 #include <linux/module.h> 88 #include <linux/init.h> 89 #include <linux/slab.h> 90 #include <linux/jiffies.h> 91 #include <linux/i2c.h> 92 #include <linux/hwmon-sysfs.h> 93 #include <linux/hwmon.h> 94 #include <linux/err.h> 95 #include <linux/mutex.h> 96 #include <linux/sysfs.h> 97 #include <linux/interrupt.h> 98 #include <linux/regulator/consumer.h> 99 100 /* 101 * Addresses to scan 102 * Address is fully defined internally and cannot be changed except for 103 * MAX6659, MAX6680 and MAX6681. 104 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649, 105 * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c. 106 * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D 107 * have address 0x4d. 108 * MAX6647 has address 0x4e. 109 * MAX6659 can have address 0x4c, 0x4d or 0x4e. 110 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 111 * 0x4c, 0x4d or 0x4e. 112 * SA56004 can have address 0x48 through 0x4F. 113 */ 114 115 static const unsigned short normal_i2c[] = { 116 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 117 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 118 119 enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680, 120 max6646, w83l771, max6696, sa56004, g781, tmp451 }; 121 122 /* 123 * The LM90 registers 124 */ 125 126 #define LM90_REG_R_MAN_ID 0xFE 127 #define LM90_REG_R_CHIP_ID 0xFF 128 #define LM90_REG_R_CONFIG1 0x03 129 #define LM90_REG_W_CONFIG1 0x09 130 #define LM90_REG_R_CONFIG2 0xBF 131 #define LM90_REG_W_CONFIG2 0xBF 132 #define LM90_REG_R_CONVRATE 0x04 133 #define LM90_REG_W_CONVRATE 0x0A 134 #define LM90_REG_R_STATUS 0x02 135 #define LM90_REG_R_LOCAL_TEMP 0x00 136 #define LM90_REG_R_LOCAL_HIGH 0x05 137 #define LM90_REG_W_LOCAL_HIGH 0x0B 138 #define LM90_REG_R_LOCAL_LOW 0x06 139 #define LM90_REG_W_LOCAL_LOW 0x0C 140 #define LM90_REG_R_LOCAL_CRIT 0x20 141 #define LM90_REG_W_LOCAL_CRIT 0x20 142 #define LM90_REG_R_REMOTE_TEMPH 0x01 143 #define LM90_REG_R_REMOTE_TEMPL 0x10 144 #define LM90_REG_R_REMOTE_OFFSH 0x11 145 #define LM90_REG_W_REMOTE_OFFSH 0x11 146 #define LM90_REG_R_REMOTE_OFFSL 0x12 147 #define LM90_REG_W_REMOTE_OFFSL 0x12 148 #define LM90_REG_R_REMOTE_HIGHH 0x07 149 #define LM90_REG_W_REMOTE_HIGHH 0x0D 150 #define LM90_REG_R_REMOTE_HIGHL 0x13 151 #define LM90_REG_W_REMOTE_HIGHL 0x13 152 #define LM90_REG_R_REMOTE_LOWH 0x08 153 #define LM90_REG_W_REMOTE_LOWH 0x0E 154 #define LM90_REG_R_REMOTE_LOWL 0x14 155 #define LM90_REG_W_REMOTE_LOWL 0x14 156 #define LM90_REG_R_REMOTE_CRIT 0x19 157 #define LM90_REG_W_REMOTE_CRIT 0x19 158 #define LM90_REG_R_TCRIT_HYST 0x21 159 #define LM90_REG_W_TCRIT_HYST 0x21 160 161 /* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */ 162 163 #define MAX6657_REG_R_LOCAL_TEMPL 0x11 164 #define MAX6696_REG_R_STATUS2 0x12 165 #define MAX6659_REG_R_REMOTE_EMERG 0x16 166 #define MAX6659_REG_W_REMOTE_EMERG 0x16 167 #define MAX6659_REG_R_LOCAL_EMERG 0x17 168 #define MAX6659_REG_W_LOCAL_EMERG 0x17 169 170 /* SA56004 registers */ 171 172 #define SA56004_REG_R_LOCAL_TEMPL 0x22 173 174 #define LM90_DEF_CONVRATE_RVAL 6 /* Def conversion rate register value */ 175 #define LM90_MAX_CONVRATE_MS 16000 /* Maximum conversion rate in ms */ 176 177 /* TMP451 registers */ 178 #define TMP451_REG_R_LOCAL_TEMPL 0x15 179 180 /* 181 * Device flags 182 */ 183 #define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */ 184 /* Device features */ 185 #define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */ 186 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */ 187 #define LM90_HAVE_EMERGENCY (1 << 4) /* 3rd upper (emergency) limit */ 188 #define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm */ 189 #define LM90_HAVE_TEMP3 (1 << 6) /* 3rd temperature sensor */ 190 #define LM90_HAVE_BROKEN_ALERT (1 << 7) /* Broken alert */ 191 192 /* LM90 status */ 193 #define LM90_STATUS_LTHRM (1 << 0) /* local THERM limit tripped */ 194 #define LM90_STATUS_RTHRM (1 << 1) /* remote THERM limit tripped */ 195 #define LM90_STATUS_ROPEN (1 << 2) /* remote is an open circuit */ 196 #define LM90_STATUS_RLOW (1 << 3) /* remote low temp limit tripped */ 197 #define LM90_STATUS_RHIGH (1 << 4) /* remote high temp limit tripped */ 198 #define LM90_STATUS_LLOW (1 << 5) /* local low temp limit tripped */ 199 #define LM90_STATUS_LHIGH (1 << 6) /* local high temp limit tripped */ 200 201 #define MAX6696_STATUS2_R2THRM (1 << 1) /* remote2 THERM limit tripped */ 202 #define MAX6696_STATUS2_R2OPEN (1 << 2) /* remote2 is an open circuit */ 203 #define MAX6696_STATUS2_R2LOW (1 << 3) /* remote2 low temp limit tripped */ 204 #define MAX6696_STATUS2_R2HIGH (1 << 4) /* remote2 high temp limit tripped */ 205 #define MAX6696_STATUS2_ROT2 (1 << 5) /* remote emergency limit tripped */ 206 #define MAX6696_STATUS2_R2OT2 (1 << 6) /* remote2 emergency limit tripped */ 207 #define MAX6696_STATUS2_LOT2 (1 << 7) /* local emergency limit tripped */ 208 209 /* 210 * Driver data (common to all clients) 211 */ 212 213 static const struct i2c_device_id lm90_id[] = { 214 { "adm1032", adm1032 }, 215 { "adt7461", adt7461 }, 216 { "adt7461a", adt7461 }, 217 { "g781", g781 }, 218 { "lm90", lm90 }, 219 { "lm86", lm86 }, 220 { "lm89", lm86 }, 221 { "lm99", lm99 }, 222 { "max6646", max6646 }, 223 { "max6647", max6646 }, 224 { "max6649", max6646 }, 225 { "max6657", max6657 }, 226 { "max6658", max6657 }, 227 { "max6659", max6659 }, 228 { "max6680", max6680 }, 229 { "max6681", max6680 }, 230 { "max6695", max6696 }, 231 { "max6696", max6696 }, 232 { "nct1008", adt7461 }, 233 { "w83l771", w83l771 }, 234 { "sa56004", sa56004 }, 235 { "tmp451", tmp451 }, 236 { } 237 }; 238 MODULE_DEVICE_TABLE(i2c, lm90_id); 239 240 /* 241 * chip type specific parameters 242 */ 243 struct lm90_params { 244 u32 flags; /* Capabilities */ 245 u16 alert_alarms; /* Which alarm bits trigger ALERT# */ 246 /* Upper 8 bits for max6695/96 */ 247 u8 max_convrate; /* Maximum conversion rate register value */ 248 u8 reg_local_ext; /* Extended local temp register (optional) */ 249 }; 250 251 static const struct lm90_params lm90_params[] = { 252 [adm1032] = { 253 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 254 | LM90_HAVE_BROKEN_ALERT, 255 .alert_alarms = 0x7c, 256 .max_convrate = 10, 257 }, 258 [adt7461] = { 259 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 260 | LM90_HAVE_BROKEN_ALERT, 261 .alert_alarms = 0x7c, 262 .max_convrate = 10, 263 }, 264 [g781] = { 265 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 266 | LM90_HAVE_BROKEN_ALERT, 267 .alert_alarms = 0x7c, 268 .max_convrate = 8, 269 }, 270 [lm86] = { 271 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 272 .alert_alarms = 0x7b, 273 .max_convrate = 9, 274 }, 275 [lm90] = { 276 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 277 .alert_alarms = 0x7b, 278 .max_convrate = 9, 279 }, 280 [lm99] = { 281 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 282 .alert_alarms = 0x7b, 283 .max_convrate = 9, 284 }, 285 [max6646] = { 286 .alert_alarms = 0x7c, 287 .max_convrate = 6, 288 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 289 }, 290 [max6657] = { 291 .alert_alarms = 0x7c, 292 .max_convrate = 8, 293 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 294 }, 295 [max6659] = { 296 .flags = LM90_HAVE_EMERGENCY, 297 .alert_alarms = 0x7c, 298 .max_convrate = 8, 299 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 300 }, 301 [max6680] = { 302 .flags = LM90_HAVE_OFFSET, 303 .alert_alarms = 0x7c, 304 .max_convrate = 7, 305 }, 306 [max6696] = { 307 .flags = LM90_HAVE_EMERGENCY 308 | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3, 309 .alert_alarms = 0x1c7c, 310 .max_convrate = 6, 311 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 312 }, 313 [w83l771] = { 314 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 315 .alert_alarms = 0x7c, 316 .max_convrate = 8, 317 }, 318 [sa56004] = { 319 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 320 .alert_alarms = 0x7b, 321 .max_convrate = 9, 322 .reg_local_ext = SA56004_REG_R_LOCAL_TEMPL, 323 }, 324 [tmp451] = { 325 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 326 | LM90_HAVE_BROKEN_ALERT, 327 .alert_alarms = 0x7c, 328 .max_convrate = 9, 329 .reg_local_ext = TMP451_REG_R_LOCAL_TEMPL, 330 } 331 }; 332 333 /* 334 * TEMP8 register index 335 */ 336 enum lm90_temp8_reg_index { 337 LOCAL_LOW = 0, 338 LOCAL_HIGH, 339 LOCAL_CRIT, 340 REMOTE_CRIT, 341 LOCAL_EMERG, /* max6659 and max6695/96 */ 342 REMOTE_EMERG, /* max6659 and max6695/96 */ 343 REMOTE2_CRIT, /* max6695/96 only */ 344 REMOTE2_EMERG, /* max6695/96 only */ 345 TEMP8_REG_NUM 346 }; 347 348 /* 349 * TEMP11 register index 350 */ 351 enum lm90_temp11_reg_index { 352 REMOTE_TEMP = 0, 353 REMOTE_LOW, 354 REMOTE_HIGH, 355 REMOTE_OFFSET, /* except max6646, max6657/58/59, and max6695/96 */ 356 LOCAL_TEMP, 357 REMOTE2_TEMP, /* max6695/96 only */ 358 REMOTE2_LOW, /* max6695/96 only */ 359 REMOTE2_HIGH, /* max6695/96 only */ 360 TEMP11_REG_NUM 361 }; 362 363 /* 364 * Client data (each client gets its own) 365 */ 366 367 struct lm90_data { 368 struct device *hwmon_dev; 369 struct mutex update_lock; 370 struct regulator *regulator; 371 char valid; /* zero until following fields are valid */ 372 unsigned long last_updated; /* in jiffies */ 373 int kind; 374 u32 flags; 375 376 int update_interval; /* in milliseconds */ 377 378 u8 config_orig; /* Original configuration register value */ 379 u8 convrate_orig; /* Original conversion rate register value */ 380 u16 alert_alarms; /* Which alarm bits trigger ALERT# */ 381 /* Upper 8 bits for max6695/96 */ 382 u8 max_convrate; /* Maximum conversion rate */ 383 u8 reg_local_ext; /* local extension register offset */ 384 385 /* registers values */ 386 s8 temp8[TEMP8_REG_NUM]; 387 s16 temp11[TEMP11_REG_NUM]; 388 u8 temp_hyst; 389 u16 alarms; /* bitvector (upper 8 bits for max6695/96) */ 390 }; 391 392 /* 393 * Support functions 394 */ 395 396 /* 397 * The ADM1032 supports PEC but not on write byte transactions, so we need 398 * to explicitly ask for a transaction without PEC. 399 */ 400 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value) 401 { 402 return i2c_smbus_xfer(client->adapter, client->addr, 403 client->flags & ~I2C_CLIENT_PEC, 404 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL); 405 } 406 407 /* 408 * It is assumed that client->update_lock is held (unless we are in 409 * detection or initialization steps). This matters when PEC is enabled, 410 * because we don't want the address pointer to change between the write 411 * byte and the read byte transactions. 412 */ 413 static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value) 414 { 415 int err; 416 417 if (client->flags & I2C_CLIENT_PEC) { 418 err = adm1032_write_byte(client, reg); 419 if (err >= 0) 420 err = i2c_smbus_read_byte(client); 421 } else 422 err = i2c_smbus_read_byte_data(client, reg); 423 424 if (err < 0) { 425 dev_warn(&client->dev, "Register %#02x read failed (%d)\n", 426 reg, err); 427 return err; 428 } 429 *value = err; 430 431 return 0; 432 } 433 434 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value) 435 { 436 int err; 437 u8 oldh, newh, l; 438 439 /* 440 * There is a trick here. We have to read two registers to have the 441 * sensor temperature, but we have to beware a conversion could occur 442 * between the readings. The datasheet says we should either use 443 * the one-shot conversion register, which we don't want to do 444 * (disables hardware monitoring) or monitor the busy bit, which is 445 * impossible (we can't read the values and monitor that bit at the 446 * exact same time). So the solution used here is to read the high 447 * byte once, then the low byte, then the high byte again. If the new 448 * high byte matches the old one, then we have a valid reading. Else 449 * we have to read the low byte again, and now we believe we have a 450 * correct reading. 451 */ 452 if ((err = lm90_read_reg(client, regh, &oldh)) 453 || (err = lm90_read_reg(client, regl, &l)) 454 || (err = lm90_read_reg(client, regh, &newh))) 455 return err; 456 if (oldh != newh) { 457 err = lm90_read_reg(client, regl, &l); 458 if (err) 459 return err; 460 } 461 *value = (newh << 8) | l; 462 463 return 0; 464 } 465 466 /* 467 * client->update_lock must be held when calling this function (unless we are 468 * in detection or initialization steps), and while a remote channel other 469 * than channel 0 is selected. Also, calling code must make sure to re-select 470 * external channel 0 before releasing the lock. This is necessary because 471 * various registers have different meanings as a result of selecting a 472 * non-default remote channel. 473 */ 474 static inline void lm90_select_remote_channel(struct i2c_client *client, 475 struct lm90_data *data, 476 int channel) 477 { 478 u8 config; 479 480 if (data->kind == max6696) { 481 lm90_read_reg(client, LM90_REG_R_CONFIG1, &config); 482 config &= ~0x08; 483 if (channel) 484 config |= 0x08; 485 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, 486 config); 487 } 488 } 489 490 /* 491 * Set conversion rate. 492 * client->update_lock must be held when calling this function (unless we are 493 * in detection or initialization steps). 494 */ 495 static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data, 496 unsigned int interval) 497 { 498 int i; 499 unsigned int update_interval; 500 501 /* Shift calculations to avoid rounding errors */ 502 interval <<= 6; 503 504 /* find the nearest update rate */ 505 for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6; 506 i < data->max_convrate; i++, update_interval >>= 1) 507 if (interval >= update_interval * 3 / 4) 508 break; 509 510 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, i); 511 data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64); 512 } 513 514 static struct lm90_data *lm90_update_device(struct device *dev) 515 { 516 struct i2c_client *client = to_i2c_client(dev); 517 struct lm90_data *data = i2c_get_clientdata(client); 518 unsigned long next_update; 519 520 mutex_lock(&data->update_lock); 521 522 next_update = data->last_updated + 523 msecs_to_jiffies(data->update_interval); 524 if (time_after(jiffies, next_update) || !data->valid) { 525 u8 h, l; 526 u8 alarms; 527 528 dev_dbg(&client->dev, "Updating lm90 data.\n"); 529 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, 530 &data->temp8[LOCAL_LOW]); 531 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, 532 &data->temp8[LOCAL_HIGH]); 533 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, 534 &data->temp8[LOCAL_CRIT]); 535 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, 536 &data->temp8[REMOTE_CRIT]); 537 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst); 538 539 if (data->reg_local_ext) { 540 lm90_read16(client, LM90_REG_R_LOCAL_TEMP, 541 data->reg_local_ext, 542 &data->temp11[LOCAL_TEMP]); 543 } else { 544 if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, 545 &h) == 0) 546 data->temp11[LOCAL_TEMP] = h << 8; 547 } 548 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH, 549 LM90_REG_R_REMOTE_TEMPL, 550 &data->temp11[REMOTE_TEMP]); 551 552 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) { 553 data->temp11[REMOTE_LOW] = h << 8; 554 if ((data->flags & LM90_HAVE_REM_LIMIT_EXT) 555 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, 556 &l) == 0) 557 data->temp11[REMOTE_LOW] |= l; 558 } 559 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) { 560 data->temp11[REMOTE_HIGH] = h << 8; 561 if ((data->flags & LM90_HAVE_REM_LIMIT_EXT) 562 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, 563 &l) == 0) 564 data->temp11[REMOTE_HIGH] |= l; 565 } 566 567 if (data->flags & LM90_HAVE_OFFSET) { 568 if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH, 569 &h) == 0 570 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL, 571 &l) == 0) 572 data->temp11[REMOTE_OFFSET] = (h << 8) | l; 573 } 574 if (data->flags & LM90_HAVE_EMERGENCY) { 575 lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG, 576 &data->temp8[LOCAL_EMERG]); 577 lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG, 578 &data->temp8[REMOTE_EMERG]); 579 } 580 lm90_read_reg(client, LM90_REG_R_STATUS, &alarms); 581 data->alarms = alarms; /* save as 16 bit value */ 582 583 if (data->kind == max6696) { 584 lm90_select_remote_channel(client, data, 1); 585 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, 586 &data->temp8[REMOTE2_CRIT]); 587 lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG, 588 &data->temp8[REMOTE2_EMERG]); 589 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH, 590 LM90_REG_R_REMOTE_TEMPL, 591 &data->temp11[REMOTE2_TEMP]); 592 if (!lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h)) 593 data->temp11[REMOTE2_LOW] = h << 8; 594 if (!lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h)) 595 data->temp11[REMOTE2_HIGH] = h << 8; 596 lm90_select_remote_channel(client, data, 0); 597 598 if (!lm90_read_reg(client, MAX6696_REG_R_STATUS2, 599 &alarms)) 600 data->alarms |= alarms << 8; 601 } 602 603 /* 604 * Re-enable ALERT# output if it was originally enabled and 605 * relevant alarms are all clear 606 */ 607 if ((data->config_orig & 0x80) == 0 608 && (data->alarms & data->alert_alarms) == 0) { 609 u8 config; 610 611 lm90_read_reg(client, LM90_REG_R_CONFIG1, &config); 612 if (config & 0x80) { 613 dev_dbg(&client->dev, "Re-enabling ALERT#\n"); 614 i2c_smbus_write_byte_data(client, 615 LM90_REG_W_CONFIG1, 616 config & ~0x80); 617 } 618 } 619 620 data->last_updated = jiffies; 621 data->valid = 1; 622 } 623 624 mutex_unlock(&data->update_lock); 625 626 return data; 627 } 628 629 /* 630 * Conversions 631 * For local temperatures and limits, critical limits and the hysteresis 632 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius. 633 * For remote temperatures and limits, it uses signed 11-bit values with 634 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some 635 * Maxim chips use unsigned values. 636 */ 637 638 static inline int temp_from_s8(s8 val) 639 { 640 return val * 1000; 641 } 642 643 static inline int temp_from_u8(u8 val) 644 { 645 return val * 1000; 646 } 647 648 static inline int temp_from_s16(s16 val) 649 { 650 return val / 32 * 125; 651 } 652 653 static inline int temp_from_u16(u16 val) 654 { 655 return val / 32 * 125; 656 } 657 658 static s8 temp_to_s8(long val) 659 { 660 if (val <= -128000) 661 return -128; 662 if (val >= 127000) 663 return 127; 664 if (val < 0) 665 return (val - 500) / 1000; 666 return (val + 500) / 1000; 667 } 668 669 static u8 temp_to_u8(long val) 670 { 671 if (val <= 0) 672 return 0; 673 if (val >= 255000) 674 return 255; 675 return (val + 500) / 1000; 676 } 677 678 static s16 temp_to_s16(long val) 679 { 680 if (val <= -128000) 681 return 0x8000; 682 if (val >= 127875) 683 return 0x7FE0; 684 if (val < 0) 685 return (val - 62) / 125 * 32; 686 return (val + 62) / 125 * 32; 687 } 688 689 static u8 hyst_to_reg(long val) 690 { 691 if (val <= 0) 692 return 0; 693 if (val >= 30500) 694 return 31; 695 return (val + 500) / 1000; 696 } 697 698 /* 699 * ADT7461 in compatibility mode is almost identical to LM90 except that 700 * attempts to write values that are outside the range 0 < temp < 127 are 701 * treated as the boundary value. 702 * 703 * ADT7461 in "extended mode" operation uses unsigned integers offset by 704 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC. 705 */ 706 static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val) 707 { 708 if (data->flags & LM90_FLAG_ADT7461_EXT) 709 return (val - 64) * 1000; 710 else 711 return temp_from_s8(val); 712 } 713 714 static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val) 715 { 716 if (data->flags & LM90_FLAG_ADT7461_EXT) 717 return (val - 0x4000) / 64 * 250; 718 else 719 return temp_from_s16(val); 720 } 721 722 static u8 temp_to_u8_adt7461(struct lm90_data *data, long val) 723 { 724 if (data->flags & LM90_FLAG_ADT7461_EXT) { 725 if (val <= -64000) 726 return 0; 727 if (val >= 191000) 728 return 0xFF; 729 return (val + 500 + 64000) / 1000; 730 } else { 731 if (val <= 0) 732 return 0; 733 if (val >= 127000) 734 return 127; 735 return (val + 500) / 1000; 736 } 737 } 738 739 static u16 temp_to_u16_adt7461(struct lm90_data *data, long val) 740 { 741 if (data->flags & LM90_FLAG_ADT7461_EXT) { 742 if (val <= -64000) 743 return 0; 744 if (val >= 191750) 745 return 0xFFC0; 746 return (val + 64000 + 125) / 250 * 64; 747 } else { 748 if (val <= 0) 749 return 0; 750 if (val >= 127750) 751 return 0x7FC0; 752 return (val + 125) / 250 * 64; 753 } 754 } 755 756 /* 757 * Sysfs stuff 758 */ 759 760 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr, 761 char *buf) 762 { 763 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 764 struct lm90_data *data = lm90_update_device(dev); 765 int temp; 766 767 if (data->kind == adt7461 || data->kind == tmp451) 768 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]); 769 else if (data->kind == max6646) 770 temp = temp_from_u8(data->temp8[attr->index]); 771 else 772 temp = temp_from_s8(data->temp8[attr->index]); 773 774 /* +16 degrees offset for temp2 for the LM99 */ 775 if (data->kind == lm99 && attr->index == 3) 776 temp += 16000; 777 778 return sprintf(buf, "%d\n", temp); 779 } 780 781 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr, 782 const char *buf, size_t count) 783 { 784 static const u8 reg[TEMP8_REG_NUM] = { 785 LM90_REG_W_LOCAL_LOW, 786 LM90_REG_W_LOCAL_HIGH, 787 LM90_REG_W_LOCAL_CRIT, 788 LM90_REG_W_REMOTE_CRIT, 789 MAX6659_REG_W_LOCAL_EMERG, 790 MAX6659_REG_W_REMOTE_EMERG, 791 LM90_REG_W_REMOTE_CRIT, 792 MAX6659_REG_W_REMOTE_EMERG, 793 }; 794 795 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 796 struct i2c_client *client = to_i2c_client(dev); 797 struct lm90_data *data = i2c_get_clientdata(client); 798 int nr = attr->index; 799 long val; 800 int err; 801 802 err = kstrtol(buf, 10, &val); 803 if (err < 0) 804 return err; 805 806 /* +16 degrees offset for temp2 for the LM99 */ 807 if (data->kind == lm99 && attr->index == 3) 808 val -= 16000; 809 810 mutex_lock(&data->update_lock); 811 if (data->kind == adt7461 || data->kind == tmp451) 812 data->temp8[nr] = temp_to_u8_adt7461(data, val); 813 else if (data->kind == max6646) 814 data->temp8[nr] = temp_to_u8(val); 815 else 816 data->temp8[nr] = temp_to_s8(val); 817 818 lm90_select_remote_channel(client, data, nr >= 6); 819 i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]); 820 lm90_select_remote_channel(client, data, 0); 821 822 mutex_unlock(&data->update_lock); 823 return count; 824 } 825 826 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr, 827 char *buf) 828 { 829 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 830 struct lm90_data *data = lm90_update_device(dev); 831 int temp; 832 833 if (data->kind == adt7461 || data->kind == tmp451) 834 temp = temp_from_u16_adt7461(data, data->temp11[attr->index]); 835 else if (data->kind == max6646) 836 temp = temp_from_u16(data->temp11[attr->index]); 837 else 838 temp = temp_from_s16(data->temp11[attr->index]); 839 840 /* +16 degrees offset for temp2 for the LM99 */ 841 if (data->kind == lm99 && attr->index <= 2) 842 temp += 16000; 843 844 return sprintf(buf, "%d\n", temp); 845 } 846 847 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr, 848 const char *buf, size_t count) 849 { 850 struct { 851 u8 high; 852 u8 low; 853 int channel; 854 } reg[5] = { 855 { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 0 }, 856 { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 0 }, 857 { LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL, 0 }, 858 { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 1 }, 859 { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 1 } 860 }; 861 862 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 863 struct i2c_client *client = to_i2c_client(dev); 864 struct lm90_data *data = i2c_get_clientdata(client); 865 int nr = attr->nr; 866 int index = attr->index; 867 long val; 868 int err; 869 870 err = kstrtol(buf, 10, &val); 871 if (err < 0) 872 return err; 873 874 /* +16 degrees offset for temp2 for the LM99 */ 875 if (data->kind == lm99 && index <= 2) 876 val -= 16000; 877 878 mutex_lock(&data->update_lock); 879 if (data->kind == adt7461 || data->kind == tmp451) 880 data->temp11[index] = temp_to_u16_adt7461(data, val); 881 else if (data->kind == max6646) 882 data->temp11[index] = temp_to_u8(val) << 8; 883 else if (data->flags & LM90_HAVE_REM_LIMIT_EXT) 884 data->temp11[index] = temp_to_s16(val); 885 else 886 data->temp11[index] = temp_to_s8(val) << 8; 887 888 lm90_select_remote_channel(client, data, reg[nr].channel); 889 i2c_smbus_write_byte_data(client, reg[nr].high, 890 data->temp11[index] >> 8); 891 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) 892 i2c_smbus_write_byte_data(client, reg[nr].low, 893 data->temp11[index] & 0xff); 894 lm90_select_remote_channel(client, data, 0); 895 896 mutex_unlock(&data->update_lock); 897 return count; 898 } 899 900 static ssize_t show_temphyst(struct device *dev, 901 struct device_attribute *devattr, 902 char *buf) 903 { 904 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 905 struct lm90_data *data = lm90_update_device(dev); 906 int temp; 907 908 if (data->kind == adt7461 || data->kind == tmp451) 909 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]); 910 else if (data->kind == max6646) 911 temp = temp_from_u8(data->temp8[attr->index]); 912 else 913 temp = temp_from_s8(data->temp8[attr->index]); 914 915 /* +16 degrees offset for temp2 for the LM99 */ 916 if (data->kind == lm99 && attr->index == 3) 917 temp += 16000; 918 919 return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst)); 920 } 921 922 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy, 923 const char *buf, size_t count) 924 { 925 struct i2c_client *client = to_i2c_client(dev); 926 struct lm90_data *data = i2c_get_clientdata(client); 927 long val; 928 int err; 929 int temp; 930 931 err = kstrtol(buf, 10, &val); 932 if (err < 0) 933 return err; 934 935 mutex_lock(&data->update_lock); 936 if (data->kind == adt7461 || data->kind == tmp451) 937 temp = temp_from_u8_adt7461(data, data->temp8[LOCAL_CRIT]); 938 else if (data->kind == max6646) 939 temp = temp_from_u8(data->temp8[LOCAL_CRIT]); 940 else 941 temp = temp_from_s8(data->temp8[LOCAL_CRIT]); 942 943 data->temp_hyst = hyst_to_reg(temp - val); 944 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST, 945 data->temp_hyst); 946 mutex_unlock(&data->update_lock); 947 return count; 948 } 949 950 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy, 951 char *buf) 952 { 953 struct lm90_data *data = lm90_update_device(dev); 954 return sprintf(buf, "%d\n", data->alarms); 955 } 956 957 static ssize_t show_alarm(struct device *dev, struct device_attribute 958 *devattr, char *buf) 959 { 960 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 961 struct lm90_data *data = lm90_update_device(dev); 962 int bitnr = attr->index; 963 964 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1); 965 } 966 967 static ssize_t show_update_interval(struct device *dev, 968 struct device_attribute *attr, char *buf) 969 { 970 struct lm90_data *data = dev_get_drvdata(dev); 971 972 return sprintf(buf, "%u\n", data->update_interval); 973 } 974 975 static ssize_t set_update_interval(struct device *dev, 976 struct device_attribute *attr, 977 const char *buf, size_t count) 978 { 979 struct i2c_client *client = to_i2c_client(dev); 980 struct lm90_data *data = i2c_get_clientdata(client); 981 unsigned long val; 982 int err; 983 984 err = kstrtoul(buf, 10, &val); 985 if (err) 986 return err; 987 988 mutex_lock(&data->update_lock); 989 lm90_set_convrate(client, data, clamp_val(val, 0, 100000)); 990 mutex_unlock(&data->update_lock); 991 992 return count; 993 } 994 995 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 996 0, LOCAL_TEMP); 997 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 998 0, REMOTE_TEMP); 999 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8, 1000 set_temp8, LOCAL_LOW); 1001 static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11, 1002 set_temp11, 0, REMOTE_LOW); 1003 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8, 1004 set_temp8, LOCAL_HIGH); 1005 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11, 1006 set_temp11, 1, REMOTE_HIGH); 1007 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8, 1008 set_temp8, LOCAL_CRIT); 1009 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8, 1010 set_temp8, REMOTE_CRIT); 1011 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst, 1012 set_temphyst, LOCAL_CRIT); 1013 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 1014 REMOTE_CRIT); 1015 static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11, 1016 set_temp11, 2, REMOTE_OFFSET); 1017 1018 /* Individual alarm files */ 1019 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0); 1020 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1); 1021 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2); 1022 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 1023 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4); 1024 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5); 1025 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 1026 /* Raw alarm file for compatibility */ 1027 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 1028 1029 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval, 1030 set_update_interval); 1031 1032 static struct attribute *lm90_attributes[] = { 1033 &sensor_dev_attr_temp1_input.dev_attr.attr, 1034 &sensor_dev_attr_temp2_input.dev_attr.attr, 1035 &sensor_dev_attr_temp1_min.dev_attr.attr, 1036 &sensor_dev_attr_temp2_min.dev_attr.attr, 1037 &sensor_dev_attr_temp1_max.dev_attr.attr, 1038 &sensor_dev_attr_temp2_max.dev_attr.attr, 1039 &sensor_dev_attr_temp1_crit.dev_attr.attr, 1040 &sensor_dev_attr_temp2_crit.dev_attr.attr, 1041 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 1042 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, 1043 1044 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 1045 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 1046 &sensor_dev_attr_temp2_fault.dev_attr.attr, 1047 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 1048 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 1049 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 1050 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 1051 &dev_attr_alarms.attr, 1052 &dev_attr_update_interval.attr, 1053 NULL 1054 }; 1055 1056 static const struct attribute_group lm90_group = { 1057 .attrs = lm90_attributes, 1058 }; 1059 1060 /* 1061 * Additional attributes for devices with emergency sensors 1062 */ 1063 static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8, 1064 set_temp8, LOCAL_EMERG); 1065 static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8, 1066 set_temp8, REMOTE_EMERG); 1067 static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst, 1068 NULL, LOCAL_EMERG); 1069 static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst, 1070 NULL, REMOTE_EMERG); 1071 1072 static struct attribute *lm90_emergency_attributes[] = { 1073 &sensor_dev_attr_temp1_emergency.dev_attr.attr, 1074 &sensor_dev_attr_temp2_emergency.dev_attr.attr, 1075 &sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr, 1076 &sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr, 1077 NULL 1078 }; 1079 1080 static const struct attribute_group lm90_emergency_group = { 1081 .attrs = lm90_emergency_attributes, 1082 }; 1083 1084 static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 15); 1085 static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 13); 1086 1087 static struct attribute *lm90_emergency_alarm_attributes[] = { 1088 &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr, 1089 &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr, 1090 NULL 1091 }; 1092 1093 static const struct attribute_group lm90_emergency_alarm_group = { 1094 .attrs = lm90_emergency_alarm_attributes, 1095 }; 1096 1097 /* 1098 * Additional attributes for devices with 3 temperature sensors 1099 */ 1100 static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp11, NULL, 1101 0, REMOTE2_TEMP); 1102 static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp11, 1103 set_temp11, 3, REMOTE2_LOW); 1104 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp11, 1105 set_temp11, 4, REMOTE2_HIGH); 1106 static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp8, 1107 set_temp8, REMOTE2_CRIT); 1108 static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temphyst, NULL, 1109 REMOTE2_CRIT); 1110 static SENSOR_DEVICE_ATTR(temp3_emergency, S_IWUSR | S_IRUGO, show_temp8, 1111 set_temp8, REMOTE2_EMERG); 1112 static SENSOR_DEVICE_ATTR(temp3_emergency_hyst, S_IRUGO, show_temphyst, 1113 NULL, REMOTE2_EMERG); 1114 1115 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9); 1116 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 10); 1117 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11); 1118 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 12); 1119 static SENSOR_DEVICE_ATTR(temp3_emergency_alarm, S_IRUGO, show_alarm, NULL, 14); 1120 1121 static struct attribute *lm90_temp3_attributes[] = { 1122 &sensor_dev_attr_temp3_input.dev_attr.attr, 1123 &sensor_dev_attr_temp3_min.dev_attr.attr, 1124 &sensor_dev_attr_temp3_max.dev_attr.attr, 1125 &sensor_dev_attr_temp3_crit.dev_attr.attr, 1126 &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr, 1127 &sensor_dev_attr_temp3_emergency.dev_attr.attr, 1128 &sensor_dev_attr_temp3_emergency_hyst.dev_attr.attr, 1129 1130 &sensor_dev_attr_temp3_fault.dev_attr.attr, 1131 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 1132 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 1133 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 1134 &sensor_dev_attr_temp3_emergency_alarm.dev_attr.attr, 1135 NULL 1136 }; 1137 1138 static const struct attribute_group lm90_temp3_group = { 1139 .attrs = lm90_temp3_attributes, 1140 }; 1141 1142 /* pec used for ADM1032 only */ 1143 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy, 1144 char *buf) 1145 { 1146 struct i2c_client *client = to_i2c_client(dev); 1147 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC)); 1148 } 1149 1150 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy, 1151 const char *buf, size_t count) 1152 { 1153 struct i2c_client *client = to_i2c_client(dev); 1154 long val; 1155 int err; 1156 1157 err = kstrtol(buf, 10, &val); 1158 if (err < 0) 1159 return err; 1160 1161 switch (val) { 1162 case 0: 1163 client->flags &= ~I2C_CLIENT_PEC; 1164 break; 1165 case 1: 1166 client->flags |= I2C_CLIENT_PEC; 1167 break; 1168 default: 1169 return -EINVAL; 1170 } 1171 1172 return count; 1173 } 1174 1175 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec); 1176 1177 /* 1178 * Real code 1179 */ 1180 1181 /* Return 0 if detection is successful, -ENODEV otherwise */ 1182 static int lm90_detect(struct i2c_client *client, 1183 struct i2c_board_info *info) 1184 { 1185 struct i2c_adapter *adapter = client->adapter; 1186 int address = client->addr; 1187 const char *name = NULL; 1188 int man_id, chip_id, config1, config2, convrate; 1189 1190 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1191 return -ENODEV; 1192 1193 /* detection and identification */ 1194 man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID); 1195 chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID); 1196 config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1); 1197 convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE); 1198 if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0) 1199 return -ENODEV; 1200 1201 if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) { 1202 config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2); 1203 if (config2 < 0) 1204 return -ENODEV; 1205 } else 1206 config2 = 0; /* Make compiler happy */ 1207 1208 if ((address == 0x4C || address == 0x4D) 1209 && man_id == 0x01) { /* National Semiconductor */ 1210 if ((config1 & 0x2A) == 0x00 1211 && (config2 & 0xF8) == 0x00 1212 && convrate <= 0x09) { 1213 if (address == 0x4C 1214 && (chip_id & 0xF0) == 0x20) { /* LM90 */ 1215 name = "lm90"; 1216 } else 1217 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */ 1218 name = "lm99"; 1219 dev_info(&adapter->dev, 1220 "Assuming LM99 chip at 0x%02x\n", 1221 address); 1222 dev_info(&adapter->dev, 1223 "If it is an LM89, instantiate it " 1224 "with the new_device sysfs " 1225 "interface\n"); 1226 } else 1227 if (address == 0x4C 1228 && (chip_id & 0xF0) == 0x10) { /* LM86 */ 1229 name = "lm86"; 1230 } 1231 } 1232 } else 1233 if ((address == 0x4C || address == 0x4D) 1234 && man_id == 0x41) { /* Analog Devices */ 1235 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */ 1236 && (config1 & 0x3F) == 0x00 1237 && convrate <= 0x0A) { 1238 name = "adm1032"; 1239 /* 1240 * The ADM1032 supports PEC, but only if combined 1241 * transactions are not used. 1242 */ 1243 if (i2c_check_functionality(adapter, 1244 I2C_FUNC_SMBUS_BYTE)) 1245 info->flags |= I2C_CLIENT_PEC; 1246 } else 1247 if (chip_id == 0x51 /* ADT7461 */ 1248 && (config1 & 0x1B) == 0x00 1249 && convrate <= 0x0A) { 1250 name = "adt7461"; 1251 } else 1252 if (chip_id == 0x57 /* ADT7461A, NCT1008 */ 1253 && (config1 & 0x1B) == 0x00 1254 && convrate <= 0x0A) { 1255 name = "adt7461a"; 1256 } 1257 } else 1258 if (man_id == 0x4D) { /* Maxim */ 1259 int emerg, emerg2, status2; 1260 1261 /* 1262 * We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read 1263 * LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG 1264 * exists, both readings will reflect the same value. Otherwise, 1265 * the readings will be different. 1266 */ 1267 emerg = i2c_smbus_read_byte_data(client, 1268 MAX6659_REG_R_REMOTE_EMERG); 1269 man_id = i2c_smbus_read_byte_data(client, 1270 LM90_REG_R_MAN_ID); 1271 emerg2 = i2c_smbus_read_byte_data(client, 1272 MAX6659_REG_R_REMOTE_EMERG); 1273 status2 = i2c_smbus_read_byte_data(client, 1274 MAX6696_REG_R_STATUS2); 1275 if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0) 1276 return -ENODEV; 1277 1278 /* 1279 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id 1280 * register. Reading from that address will return the last 1281 * read value, which in our case is those of the man_id 1282 * register. Likewise, the config1 register seems to lack a 1283 * low nibble, so the value will be those of the previous 1284 * read, so in our case those of the man_id register. 1285 * MAX6659 has a third set of upper temperature limit registers. 1286 * Those registers also return values on MAX6657 and MAX6658, 1287 * thus the only way to detect MAX6659 is by its address. 1288 * For this reason it will be mis-detected as MAX6657 if its 1289 * address is 0x4C. 1290 */ 1291 if (chip_id == man_id 1292 && (address == 0x4C || address == 0x4D || address == 0x4E) 1293 && (config1 & 0x1F) == (man_id & 0x0F) 1294 && convrate <= 0x09) { 1295 if (address == 0x4C) 1296 name = "max6657"; 1297 else 1298 name = "max6659"; 1299 } else 1300 /* 1301 * Even though MAX6695 and MAX6696 do not have a chip ID 1302 * register, reading it returns 0x01. Bit 4 of the config1 1303 * register is unused and should return zero when read. Bit 0 of 1304 * the status2 register is unused and should return zero when 1305 * read. 1306 * 1307 * MAX6695 and MAX6696 have an additional set of temperature 1308 * limit registers. We can detect those chips by checking if 1309 * one of those registers exists. 1310 */ 1311 if (chip_id == 0x01 1312 && (config1 & 0x10) == 0x00 1313 && (status2 & 0x01) == 0x00 1314 && emerg == emerg2 1315 && convrate <= 0x07) { 1316 name = "max6696"; 1317 } else 1318 /* 1319 * The chip_id register of the MAX6680 and MAX6681 holds the 1320 * revision of the chip. The lowest bit of the config1 register 1321 * is unused and should return zero when read, so should the 1322 * second to last bit of config1 (software reset). 1323 */ 1324 if (chip_id == 0x01 1325 && (config1 & 0x03) == 0x00 1326 && convrate <= 0x07) { 1327 name = "max6680"; 1328 } else 1329 /* 1330 * The chip_id register of the MAX6646/6647/6649 holds the 1331 * revision of the chip. The lowest 6 bits of the config1 1332 * register are unused and should return zero when read. 1333 */ 1334 if (chip_id == 0x59 1335 && (config1 & 0x3f) == 0x00 1336 && convrate <= 0x07) { 1337 name = "max6646"; 1338 } 1339 } else 1340 if (address == 0x4C 1341 && man_id == 0x5C) { /* Winbond/Nuvoton */ 1342 if ((config1 & 0x2A) == 0x00 1343 && (config2 & 0xF8) == 0x00) { 1344 if (chip_id == 0x01 /* W83L771W/G */ 1345 && convrate <= 0x09) { 1346 name = "w83l771"; 1347 } else 1348 if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */ 1349 && convrate <= 0x08) { 1350 name = "w83l771"; 1351 } 1352 } 1353 } else 1354 if (address >= 0x48 && address <= 0x4F 1355 && man_id == 0xA1) { /* NXP Semiconductor/Philips */ 1356 if (chip_id == 0x00 1357 && (config1 & 0x2A) == 0x00 1358 && (config2 & 0xFE) == 0x00 1359 && convrate <= 0x09) { 1360 name = "sa56004"; 1361 } 1362 } else 1363 if ((address == 0x4C || address == 0x4D) 1364 && man_id == 0x47) { /* GMT */ 1365 if (chip_id == 0x01 /* G781 */ 1366 && (config1 & 0x3F) == 0x00 1367 && convrate <= 0x08) 1368 name = "g781"; 1369 } else 1370 if (address == 0x4C 1371 && man_id == 0x55) { /* Texas Instruments */ 1372 int local_ext; 1373 1374 local_ext = i2c_smbus_read_byte_data(client, 1375 TMP451_REG_R_LOCAL_TEMPL); 1376 1377 if (chip_id == 0x00 /* TMP451 */ 1378 && (config1 & 0x1B) == 0x00 1379 && convrate <= 0x09 1380 && (local_ext & 0x0F) == 0x00) 1381 name = "tmp451"; 1382 } 1383 1384 if (!name) { /* identification failed */ 1385 dev_dbg(&adapter->dev, 1386 "Unsupported chip at 0x%02x (man_id=0x%02X, " 1387 "chip_id=0x%02X)\n", address, man_id, chip_id); 1388 return -ENODEV; 1389 } 1390 1391 strlcpy(info->type, name, I2C_NAME_SIZE); 1392 1393 return 0; 1394 } 1395 1396 static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data) 1397 { 1398 struct device *dev = &client->dev; 1399 1400 if (data->flags & LM90_HAVE_TEMP3) 1401 sysfs_remove_group(&dev->kobj, &lm90_temp3_group); 1402 if (data->flags & LM90_HAVE_EMERGENCY_ALARM) 1403 sysfs_remove_group(&dev->kobj, &lm90_emergency_alarm_group); 1404 if (data->flags & LM90_HAVE_EMERGENCY) 1405 sysfs_remove_group(&dev->kobj, &lm90_emergency_group); 1406 if (data->flags & LM90_HAVE_OFFSET) 1407 device_remove_file(dev, &sensor_dev_attr_temp2_offset.dev_attr); 1408 device_remove_file(dev, &dev_attr_pec); 1409 sysfs_remove_group(&dev->kobj, &lm90_group); 1410 } 1411 1412 static void lm90_restore_conf(struct i2c_client *client, struct lm90_data *data) 1413 { 1414 /* Restore initial configuration */ 1415 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, 1416 data->convrate_orig); 1417 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, 1418 data->config_orig); 1419 } 1420 1421 static void lm90_init_client(struct i2c_client *client) 1422 { 1423 u8 config, convrate; 1424 struct lm90_data *data = i2c_get_clientdata(client); 1425 1426 if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) { 1427 dev_warn(&client->dev, "Failed to read convrate register!\n"); 1428 convrate = LM90_DEF_CONVRATE_RVAL; 1429 } 1430 data->convrate_orig = convrate; 1431 1432 /* 1433 * Start the conversions. 1434 */ 1435 lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */ 1436 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) { 1437 dev_warn(&client->dev, "Initialization failed!\n"); 1438 return; 1439 } 1440 data->config_orig = config; 1441 1442 /* Check Temperature Range Select */ 1443 if (data->kind == adt7461 || data->kind == tmp451) { 1444 if (config & 0x04) 1445 data->flags |= LM90_FLAG_ADT7461_EXT; 1446 } 1447 1448 /* 1449 * Put MAX6680/MAX8881 into extended resolution (bit 0x10, 1450 * 0.125 degree resolution) and range (0x08, extend range 1451 * to -64 degree) mode for the remote temperature sensor. 1452 */ 1453 if (data->kind == max6680) 1454 config |= 0x18; 1455 1456 /* 1457 * Select external channel 0 for max6695/96 1458 */ 1459 if (data->kind == max6696) 1460 config &= ~0x08; 1461 1462 config &= 0xBF; /* run */ 1463 if (config != data->config_orig) /* Only write if changed */ 1464 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config); 1465 } 1466 1467 static bool lm90_is_tripped(struct i2c_client *client, u16 *status) 1468 { 1469 struct lm90_data *data = i2c_get_clientdata(client); 1470 u8 st, st2 = 0; 1471 1472 lm90_read_reg(client, LM90_REG_R_STATUS, &st); 1473 1474 if (data->kind == max6696) 1475 lm90_read_reg(client, MAX6696_REG_R_STATUS2, &st2); 1476 1477 *status = st | (st2 << 8); 1478 1479 if ((st & 0x7f) == 0 && (st2 & 0xfe) == 0) 1480 return false; 1481 1482 if ((st & (LM90_STATUS_LLOW | LM90_STATUS_LHIGH | LM90_STATUS_LTHRM)) || 1483 (st2 & MAX6696_STATUS2_LOT2)) 1484 dev_warn(&client->dev, 1485 "temp%d out of range, please check!\n", 1); 1486 if ((st & (LM90_STATUS_RLOW | LM90_STATUS_RHIGH | LM90_STATUS_RTHRM)) || 1487 (st2 & MAX6696_STATUS2_ROT2)) 1488 dev_warn(&client->dev, 1489 "temp%d out of range, please check!\n", 2); 1490 if (st & LM90_STATUS_ROPEN) 1491 dev_warn(&client->dev, 1492 "temp%d diode open, please check!\n", 2); 1493 if (st2 & (MAX6696_STATUS2_R2LOW | MAX6696_STATUS2_R2HIGH | 1494 MAX6696_STATUS2_R2THRM | MAX6696_STATUS2_R2OT2)) 1495 dev_warn(&client->dev, 1496 "temp%d out of range, please check!\n", 3); 1497 if (st2 & MAX6696_STATUS2_R2OPEN) 1498 dev_warn(&client->dev, 1499 "temp%d diode open, please check!\n", 3); 1500 1501 return true; 1502 } 1503 1504 static irqreturn_t lm90_irq_thread(int irq, void *dev_id) 1505 { 1506 struct i2c_client *client = dev_id; 1507 u16 status; 1508 1509 if (lm90_is_tripped(client, &status)) 1510 return IRQ_HANDLED; 1511 else 1512 return IRQ_NONE; 1513 } 1514 1515 static int lm90_probe(struct i2c_client *client, 1516 const struct i2c_device_id *id) 1517 { 1518 struct device *dev = &client->dev; 1519 struct i2c_adapter *adapter = to_i2c_adapter(dev->parent); 1520 struct lm90_data *data; 1521 struct regulator *regulator; 1522 int err; 1523 1524 regulator = devm_regulator_get(dev, "vcc"); 1525 if (IS_ERR(regulator)) 1526 return PTR_ERR(regulator); 1527 1528 err = regulator_enable(regulator); 1529 if (err < 0) { 1530 dev_err(&client->dev, 1531 "Failed to enable regulator: %d\n", err); 1532 return err; 1533 } 1534 1535 data = devm_kzalloc(&client->dev, sizeof(struct lm90_data), GFP_KERNEL); 1536 if (!data) 1537 return -ENOMEM; 1538 1539 i2c_set_clientdata(client, data); 1540 mutex_init(&data->update_lock); 1541 1542 data->regulator = regulator; 1543 1544 /* Set the device type */ 1545 data->kind = id->driver_data; 1546 if (data->kind == adm1032) { 1547 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) 1548 client->flags &= ~I2C_CLIENT_PEC; 1549 } 1550 1551 /* 1552 * Different devices have different alarm bits triggering the 1553 * ALERT# output 1554 */ 1555 data->alert_alarms = lm90_params[data->kind].alert_alarms; 1556 1557 /* Set chip capabilities */ 1558 data->flags = lm90_params[data->kind].flags; 1559 data->reg_local_ext = lm90_params[data->kind].reg_local_ext; 1560 1561 /* Set maximum conversion rate */ 1562 data->max_convrate = lm90_params[data->kind].max_convrate; 1563 1564 /* Initialize the LM90 chip */ 1565 lm90_init_client(client); 1566 1567 /* Register sysfs hooks */ 1568 err = sysfs_create_group(&dev->kobj, &lm90_group); 1569 if (err) 1570 goto exit_restore; 1571 if (client->flags & I2C_CLIENT_PEC) { 1572 err = device_create_file(dev, &dev_attr_pec); 1573 if (err) 1574 goto exit_remove_files; 1575 } 1576 if (data->flags & LM90_HAVE_OFFSET) { 1577 err = device_create_file(dev, 1578 &sensor_dev_attr_temp2_offset.dev_attr); 1579 if (err) 1580 goto exit_remove_files; 1581 } 1582 if (data->flags & LM90_HAVE_EMERGENCY) { 1583 err = sysfs_create_group(&dev->kobj, &lm90_emergency_group); 1584 if (err) 1585 goto exit_remove_files; 1586 } 1587 if (data->flags & LM90_HAVE_EMERGENCY_ALARM) { 1588 err = sysfs_create_group(&dev->kobj, 1589 &lm90_emergency_alarm_group); 1590 if (err) 1591 goto exit_remove_files; 1592 } 1593 if (data->flags & LM90_HAVE_TEMP3) { 1594 err = sysfs_create_group(&dev->kobj, &lm90_temp3_group); 1595 if (err) 1596 goto exit_remove_files; 1597 } 1598 1599 data->hwmon_dev = hwmon_device_register(dev); 1600 if (IS_ERR(data->hwmon_dev)) { 1601 err = PTR_ERR(data->hwmon_dev); 1602 goto exit_remove_files; 1603 } 1604 1605 if (client->irq) { 1606 dev_dbg(dev, "IRQ: %d\n", client->irq); 1607 err = devm_request_threaded_irq(dev, client->irq, 1608 NULL, lm90_irq_thread, 1609 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 1610 "lm90", client); 1611 if (err < 0) { 1612 dev_err(dev, "cannot request IRQ %d\n", client->irq); 1613 goto exit_remove_files; 1614 } 1615 } 1616 1617 return 0; 1618 1619 exit_remove_files: 1620 lm90_remove_files(client, data); 1621 exit_restore: 1622 lm90_restore_conf(client, data); 1623 regulator_disable(data->regulator); 1624 1625 return err; 1626 } 1627 1628 static int lm90_remove(struct i2c_client *client) 1629 { 1630 struct lm90_data *data = i2c_get_clientdata(client); 1631 1632 hwmon_device_unregister(data->hwmon_dev); 1633 lm90_remove_files(client, data); 1634 lm90_restore_conf(client, data); 1635 regulator_disable(data->regulator); 1636 1637 return 0; 1638 } 1639 1640 static void lm90_alert(struct i2c_client *client, unsigned int flag) 1641 { 1642 u16 alarms; 1643 1644 if (lm90_is_tripped(client, &alarms)) { 1645 /* 1646 * Disable ALERT# output, because these chips don't implement 1647 * SMBus alert correctly; they should only hold the alert line 1648 * low briefly. 1649 */ 1650 struct lm90_data *data = i2c_get_clientdata(client); 1651 1652 if ((data->flags & LM90_HAVE_BROKEN_ALERT) 1653 && (alarms & data->alert_alarms)) { 1654 u8 config; 1655 dev_dbg(&client->dev, "Disabling ALERT#\n"); 1656 lm90_read_reg(client, LM90_REG_R_CONFIG1, &config); 1657 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, 1658 config | 0x80); 1659 } 1660 } else { 1661 dev_info(&client->dev, "Everything OK\n"); 1662 } 1663 } 1664 1665 static struct i2c_driver lm90_driver = { 1666 .class = I2C_CLASS_HWMON, 1667 .driver = { 1668 .name = "lm90", 1669 }, 1670 .probe = lm90_probe, 1671 .remove = lm90_remove, 1672 .alert = lm90_alert, 1673 .id_table = lm90_id, 1674 .detect = lm90_detect, 1675 .address_list = normal_i2c, 1676 }; 1677 1678 module_i2c_driver(lm90_driver); 1679 1680 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 1681 MODULE_DESCRIPTION("LM90/ADM1032 driver"); 1682 MODULE_LICENSE("GPL"); 1683