1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring 5 * Copyright (C) 2003-2010 Jean Delvare <jdelvare@suse.de> 6 * 7 * Based on the lm83 driver. The LM90 is a sensor chip made by National 8 * Semiconductor. It reports up to two temperatures (its own plus up to 9 * one external one) with a 0.125 deg resolution (1 deg for local 10 * temperature) and a 3-4 deg accuracy. 11 * 12 * This driver also supports the LM89 and LM99, two other sensor chips 13 * made by National Semiconductor. Both have an increased remote 14 * temperature measurement accuracy (1 degree), and the LM99 15 * additionally shifts remote temperatures (measured and limits) by 16 16 * degrees, which allows for higher temperatures measurement. 17 * Note that there is no way to differentiate between both chips. 18 * When device is auto-detected, the driver will assume an LM99. 19 * 20 * This driver also supports the LM86, another sensor chip made by 21 * National Semiconductor. It is exactly similar to the LM90 except it 22 * has a higher accuracy. 23 * 24 * This driver also supports the ADM1032, a sensor chip made by Analog 25 * Devices. That chip is similar to the LM90, with a few differences 26 * that are not handled by this driver. Among others, it has a higher 27 * accuracy than the LM90, much like the LM86 does. 28 * 29 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor 30 * chips made by Maxim. These chips are similar to the LM86. 31 * Note that there is no easy way to differentiate between the three 32 * variants. We use the device address to detect MAX6659, which will result 33 * in a detection as max6657 if it is on address 0x4c. The extra address 34 * and features of the MAX6659 are only supported if the chip is configured 35 * explicitly as max6659, or if its address is not 0x4c. 36 * These chips lack the remote temperature offset feature. 37 * 38 * This driver also supports the MAX6654 chip made by Maxim. This chip can 39 * be at 9 different addresses, similar to MAX6680/MAX6681. The MAX6654 is 40 * otherwise similar to MAX6657/MAX6658/MAX6659. Extended range is available 41 * by setting the configuration register accordingly, and is done during 42 * initialization. Extended precision is only available at conversion rates 43 * of 1 Hz and slower. Note that extended precision is not enabled by 44 * default, as this driver initializes all chips to 2 Hz by design. 45 * 46 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and 47 * MAX6692 chips made by Maxim. These are again similar to the LM86, 48 * but they use unsigned temperature values and can report temperatures 49 * from 0 to 145 degrees. 50 * 51 * This driver also supports the MAX6680 and MAX6681, two other sensor 52 * chips made by Maxim. These are quite similar to the other Maxim 53 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can 54 * be treated identically. 55 * 56 * This driver also supports the MAX6695 and MAX6696, two other sensor 57 * chips made by Maxim. These are also quite similar to other Maxim 58 * chips, but support three temperature sensors instead of two. MAX6695 59 * and MAX6696 only differ in the pinout so they can be treated identically. 60 * 61 * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as 62 * NCT1008 from ON Semiconductor. The chips are supported in both compatibility 63 * and extended mode. They are mostly compatible with LM90 except for a data 64 * format difference for the temperature value registers. 65 * 66 * This driver also supports the SA56004 from Philips. This device is 67 * pin-compatible with the LM86, the ED/EDP parts are also address-compatible. 68 * 69 * This driver also supports the G781 from GMT. This device is compatible 70 * with the ADM1032. 71 * 72 * This driver also supports TMP451 from Texas Instruments. This device is 73 * supported in both compatibility and extended mode. It's mostly compatible 74 * with ADT7461 except for local temperature low byte register and max 75 * conversion rate. 76 * 77 * Since the LM90 was the first chipset supported by this driver, most 78 * comments will refer to this chipset, but are actually general and 79 * concern all supported chipsets, unless mentioned otherwise. 80 */ 81 82 #include <linux/module.h> 83 #include <linux/init.h> 84 #include <linux/slab.h> 85 #include <linux/jiffies.h> 86 #include <linux/i2c.h> 87 #include <linux/hwmon.h> 88 #include <linux/err.h> 89 #include <linux/mutex.h> 90 #include <linux/of_device.h> 91 #include <linux/sysfs.h> 92 #include <linux/interrupt.h> 93 #include <linux/regulator/consumer.h> 94 95 /* 96 * Addresses to scan 97 * Address is fully defined internally and cannot be changed except for 98 * MAX6659, MAX6680 and MAX6681. 99 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649, 100 * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c. 101 * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D 102 * have address 0x4d. 103 * MAX6647 has address 0x4e. 104 * MAX6659 can have address 0x4c, 0x4d or 0x4e. 105 * MAX6654, MAX6680, and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 106 * 0x2a, 0x2b, 0x4c, 0x4d or 0x4e. 107 * SA56004 can have address 0x48 through 0x4F. 108 */ 109 110 static const unsigned short normal_i2c[] = { 111 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 112 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 113 114 enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680, 115 max6646, w83l771, max6696, sa56004, g781, tmp451, max6654 }; 116 117 /* 118 * The LM90 registers 119 */ 120 121 #define LM90_REG_R_MAN_ID 0xFE 122 #define LM90_REG_R_CHIP_ID 0xFF 123 #define LM90_REG_R_CONFIG1 0x03 124 #define LM90_REG_W_CONFIG1 0x09 125 #define LM90_REG_R_CONFIG2 0xBF 126 #define LM90_REG_W_CONFIG2 0xBF 127 #define LM90_REG_R_CONVRATE 0x04 128 #define LM90_REG_W_CONVRATE 0x0A 129 #define LM90_REG_R_STATUS 0x02 130 #define LM90_REG_R_LOCAL_TEMP 0x00 131 #define LM90_REG_R_LOCAL_HIGH 0x05 132 #define LM90_REG_W_LOCAL_HIGH 0x0B 133 #define LM90_REG_R_LOCAL_LOW 0x06 134 #define LM90_REG_W_LOCAL_LOW 0x0C 135 #define LM90_REG_R_LOCAL_CRIT 0x20 136 #define LM90_REG_W_LOCAL_CRIT 0x20 137 #define LM90_REG_R_REMOTE_TEMPH 0x01 138 #define LM90_REG_R_REMOTE_TEMPL 0x10 139 #define LM90_REG_R_REMOTE_OFFSH 0x11 140 #define LM90_REG_W_REMOTE_OFFSH 0x11 141 #define LM90_REG_R_REMOTE_OFFSL 0x12 142 #define LM90_REG_W_REMOTE_OFFSL 0x12 143 #define LM90_REG_R_REMOTE_HIGHH 0x07 144 #define LM90_REG_W_REMOTE_HIGHH 0x0D 145 #define LM90_REG_R_REMOTE_HIGHL 0x13 146 #define LM90_REG_W_REMOTE_HIGHL 0x13 147 #define LM90_REG_R_REMOTE_LOWH 0x08 148 #define LM90_REG_W_REMOTE_LOWH 0x0E 149 #define LM90_REG_R_REMOTE_LOWL 0x14 150 #define LM90_REG_W_REMOTE_LOWL 0x14 151 #define LM90_REG_R_REMOTE_CRIT 0x19 152 #define LM90_REG_W_REMOTE_CRIT 0x19 153 #define LM90_REG_R_TCRIT_HYST 0x21 154 #define LM90_REG_W_TCRIT_HYST 0x21 155 156 /* MAX6646/6647/6649/6654/6657/6658/6659/6695/6696 registers */ 157 158 #define MAX6657_REG_R_LOCAL_TEMPL 0x11 159 #define MAX6696_REG_R_STATUS2 0x12 160 #define MAX6659_REG_R_REMOTE_EMERG 0x16 161 #define MAX6659_REG_W_REMOTE_EMERG 0x16 162 #define MAX6659_REG_R_LOCAL_EMERG 0x17 163 #define MAX6659_REG_W_LOCAL_EMERG 0x17 164 165 /* SA56004 registers */ 166 167 #define SA56004_REG_R_LOCAL_TEMPL 0x22 168 169 #define LM90_MAX_CONVRATE_MS 16000 /* Maximum conversion rate in ms */ 170 171 /* TMP451 registers */ 172 #define TMP451_REG_R_LOCAL_TEMPL 0x15 173 174 /* 175 * Device flags 176 */ 177 #define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */ 178 /* Device features */ 179 #define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */ 180 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */ 181 #define LM90_HAVE_EMERGENCY (1 << 4) /* 3rd upper (emergency) limit */ 182 #define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm */ 183 #define LM90_HAVE_TEMP3 (1 << 6) /* 3rd temperature sensor */ 184 #define LM90_HAVE_BROKEN_ALERT (1 << 7) /* Broken alert */ 185 #define LM90_PAUSE_FOR_CONFIG (1 << 8) /* Pause conversion for config */ 186 187 /* LM90 status */ 188 #define LM90_STATUS_LTHRM (1 << 0) /* local THERM limit tripped */ 189 #define LM90_STATUS_RTHRM (1 << 1) /* remote THERM limit tripped */ 190 #define LM90_STATUS_ROPEN (1 << 2) /* remote is an open circuit */ 191 #define LM90_STATUS_RLOW (1 << 3) /* remote low temp limit tripped */ 192 #define LM90_STATUS_RHIGH (1 << 4) /* remote high temp limit tripped */ 193 #define LM90_STATUS_LLOW (1 << 5) /* local low temp limit tripped */ 194 #define LM90_STATUS_LHIGH (1 << 6) /* local high temp limit tripped */ 195 196 #define MAX6696_STATUS2_R2THRM (1 << 1) /* remote2 THERM limit tripped */ 197 #define MAX6696_STATUS2_R2OPEN (1 << 2) /* remote2 is an open circuit */ 198 #define MAX6696_STATUS2_R2LOW (1 << 3) /* remote2 low temp limit tripped */ 199 #define MAX6696_STATUS2_R2HIGH (1 << 4) /* remote2 high temp limit tripped */ 200 #define MAX6696_STATUS2_ROT2 (1 << 5) /* remote emergency limit tripped */ 201 #define MAX6696_STATUS2_R2OT2 (1 << 6) /* remote2 emergency limit tripped */ 202 #define MAX6696_STATUS2_LOT2 (1 << 7) /* local emergency limit tripped */ 203 204 /* 205 * Driver data (common to all clients) 206 */ 207 208 static const struct i2c_device_id lm90_id[] = { 209 { "adm1032", adm1032 }, 210 { "adt7461", adt7461 }, 211 { "adt7461a", adt7461 }, 212 { "g781", g781 }, 213 { "lm90", lm90 }, 214 { "lm86", lm86 }, 215 { "lm89", lm86 }, 216 { "lm99", lm99 }, 217 { "max6646", max6646 }, 218 { "max6647", max6646 }, 219 { "max6649", max6646 }, 220 { "max6654", max6654 }, 221 { "max6657", max6657 }, 222 { "max6658", max6657 }, 223 { "max6659", max6659 }, 224 { "max6680", max6680 }, 225 { "max6681", max6680 }, 226 { "max6695", max6696 }, 227 { "max6696", max6696 }, 228 { "nct1008", adt7461 }, 229 { "w83l771", w83l771 }, 230 { "sa56004", sa56004 }, 231 { "tmp451", tmp451 }, 232 { } 233 }; 234 MODULE_DEVICE_TABLE(i2c, lm90_id); 235 236 static const struct of_device_id __maybe_unused lm90_of_match[] = { 237 { 238 .compatible = "adi,adm1032", 239 .data = (void *)adm1032 240 }, 241 { 242 .compatible = "adi,adt7461", 243 .data = (void *)adt7461 244 }, 245 { 246 .compatible = "adi,adt7461a", 247 .data = (void *)adt7461 248 }, 249 { 250 .compatible = "gmt,g781", 251 .data = (void *)g781 252 }, 253 { 254 .compatible = "national,lm90", 255 .data = (void *)lm90 256 }, 257 { 258 .compatible = "national,lm86", 259 .data = (void *)lm86 260 }, 261 { 262 .compatible = "national,lm89", 263 .data = (void *)lm86 264 }, 265 { 266 .compatible = "national,lm99", 267 .data = (void *)lm99 268 }, 269 { 270 .compatible = "dallas,max6646", 271 .data = (void *)max6646 272 }, 273 { 274 .compatible = "dallas,max6647", 275 .data = (void *)max6646 276 }, 277 { 278 .compatible = "dallas,max6649", 279 .data = (void *)max6646 280 }, 281 { 282 .compatible = "dallas,max6654", 283 .data = (void *)max6654 284 }, 285 { 286 .compatible = "dallas,max6657", 287 .data = (void *)max6657 288 }, 289 { 290 .compatible = "dallas,max6658", 291 .data = (void *)max6657 292 }, 293 { 294 .compatible = "dallas,max6659", 295 .data = (void *)max6659 296 }, 297 { 298 .compatible = "dallas,max6680", 299 .data = (void *)max6680 300 }, 301 { 302 .compatible = "dallas,max6681", 303 .data = (void *)max6680 304 }, 305 { 306 .compatible = "dallas,max6695", 307 .data = (void *)max6696 308 }, 309 { 310 .compatible = "dallas,max6696", 311 .data = (void *)max6696 312 }, 313 { 314 .compatible = "onnn,nct1008", 315 .data = (void *)adt7461 316 }, 317 { 318 .compatible = "winbond,w83l771", 319 .data = (void *)w83l771 320 }, 321 { 322 .compatible = "nxp,sa56004", 323 .data = (void *)sa56004 324 }, 325 { 326 .compatible = "ti,tmp451", 327 .data = (void *)tmp451 328 }, 329 { }, 330 }; 331 MODULE_DEVICE_TABLE(of, lm90_of_match); 332 333 /* 334 * chip type specific parameters 335 */ 336 struct lm90_params { 337 u32 flags; /* Capabilities */ 338 u16 alert_alarms; /* Which alarm bits trigger ALERT# */ 339 /* Upper 8 bits for max6695/96 */ 340 u8 max_convrate; /* Maximum conversion rate register value */ 341 u8 reg_local_ext; /* Extended local temp register (optional) */ 342 }; 343 344 static const struct lm90_params lm90_params[] = { 345 [adm1032] = { 346 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 347 | LM90_HAVE_BROKEN_ALERT, 348 .alert_alarms = 0x7c, 349 .max_convrate = 10, 350 }, 351 [adt7461] = { 352 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 353 | LM90_HAVE_BROKEN_ALERT, 354 .alert_alarms = 0x7c, 355 .max_convrate = 10, 356 }, 357 [g781] = { 358 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 359 | LM90_HAVE_BROKEN_ALERT, 360 .alert_alarms = 0x7c, 361 .max_convrate = 8, 362 }, 363 [lm86] = { 364 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 365 .alert_alarms = 0x7b, 366 .max_convrate = 9, 367 }, 368 [lm90] = { 369 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 370 .alert_alarms = 0x7b, 371 .max_convrate = 9, 372 }, 373 [lm99] = { 374 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 375 .alert_alarms = 0x7b, 376 .max_convrate = 9, 377 }, 378 [max6646] = { 379 .alert_alarms = 0x7c, 380 .max_convrate = 6, 381 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 382 }, 383 [max6654] = { 384 .alert_alarms = 0x7c, 385 .max_convrate = 7, 386 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 387 }, 388 [max6657] = { 389 .flags = LM90_PAUSE_FOR_CONFIG, 390 .alert_alarms = 0x7c, 391 .max_convrate = 8, 392 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 393 }, 394 [max6659] = { 395 .flags = LM90_HAVE_EMERGENCY, 396 .alert_alarms = 0x7c, 397 .max_convrate = 8, 398 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 399 }, 400 [max6680] = { 401 .flags = LM90_HAVE_OFFSET, 402 .alert_alarms = 0x7c, 403 .max_convrate = 7, 404 }, 405 [max6696] = { 406 .flags = LM90_HAVE_EMERGENCY 407 | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3, 408 .alert_alarms = 0x1c7c, 409 .max_convrate = 6, 410 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL, 411 }, 412 [w83l771] = { 413 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 414 .alert_alarms = 0x7c, 415 .max_convrate = 8, 416 }, 417 [sa56004] = { 418 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT, 419 .alert_alarms = 0x7b, 420 .max_convrate = 9, 421 .reg_local_ext = SA56004_REG_R_LOCAL_TEMPL, 422 }, 423 [tmp451] = { 424 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT 425 | LM90_HAVE_BROKEN_ALERT, 426 .alert_alarms = 0x7c, 427 .max_convrate = 9, 428 .reg_local_ext = TMP451_REG_R_LOCAL_TEMPL, 429 }, 430 }; 431 432 /* 433 * TEMP8 register index 434 */ 435 enum lm90_temp8_reg_index { 436 LOCAL_LOW = 0, 437 LOCAL_HIGH, 438 LOCAL_CRIT, 439 REMOTE_CRIT, 440 LOCAL_EMERG, /* max6659 and max6695/96 */ 441 REMOTE_EMERG, /* max6659 and max6695/96 */ 442 REMOTE2_CRIT, /* max6695/96 only */ 443 REMOTE2_EMERG, /* max6695/96 only */ 444 TEMP8_REG_NUM 445 }; 446 447 /* 448 * TEMP11 register index 449 */ 450 enum lm90_temp11_reg_index { 451 REMOTE_TEMP = 0, 452 REMOTE_LOW, 453 REMOTE_HIGH, 454 REMOTE_OFFSET, /* except max6646, max6657/58/59, and max6695/96 */ 455 LOCAL_TEMP, 456 REMOTE2_TEMP, /* max6695/96 only */ 457 REMOTE2_LOW, /* max6695/96 only */ 458 REMOTE2_HIGH, /* max6695/96 only */ 459 TEMP11_REG_NUM 460 }; 461 462 /* 463 * Client data (each client gets its own) 464 */ 465 466 struct lm90_data { 467 struct i2c_client *client; 468 struct device *hwmon_dev; 469 u32 channel_config[4]; 470 struct hwmon_channel_info temp_info; 471 const struct hwmon_channel_info *info[3]; 472 struct hwmon_chip_info chip; 473 struct mutex update_lock; 474 bool valid; /* true if register values are valid */ 475 unsigned long last_updated; /* in jiffies */ 476 int kind; 477 u32 flags; 478 479 unsigned int update_interval; /* in milliseconds */ 480 481 u8 config; /* Current configuration register value */ 482 u8 config_orig; /* Original configuration register value */ 483 u8 convrate_orig; /* Original conversion rate register value */ 484 u16 alert_alarms; /* Which alarm bits trigger ALERT# */ 485 /* Upper 8 bits for max6695/96 */ 486 u8 max_convrate; /* Maximum conversion rate */ 487 u8 reg_local_ext; /* local extension register offset */ 488 489 /* registers values */ 490 s8 temp8[TEMP8_REG_NUM]; 491 s16 temp11[TEMP11_REG_NUM]; 492 u8 temp_hyst; 493 u16 alarms; /* bitvector (upper 8 bits for max6695/96) */ 494 }; 495 496 /* 497 * Support functions 498 */ 499 500 /* 501 * The ADM1032 supports PEC but not on write byte transactions, so we need 502 * to explicitly ask for a transaction without PEC. 503 */ 504 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value) 505 { 506 return i2c_smbus_xfer(client->adapter, client->addr, 507 client->flags & ~I2C_CLIENT_PEC, 508 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL); 509 } 510 511 /* 512 * It is assumed that client->update_lock is held (unless we are in 513 * detection or initialization steps). This matters when PEC is enabled, 514 * because we don't want the address pointer to change between the write 515 * byte and the read byte transactions. 516 */ 517 static int lm90_read_reg(struct i2c_client *client, u8 reg) 518 { 519 int err; 520 521 if (client->flags & I2C_CLIENT_PEC) { 522 err = adm1032_write_byte(client, reg); 523 if (err >= 0) 524 err = i2c_smbus_read_byte(client); 525 } else 526 err = i2c_smbus_read_byte_data(client, reg); 527 528 return err; 529 } 530 531 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl) 532 { 533 int oldh, newh, l; 534 535 /* 536 * There is a trick here. We have to read two registers to have the 537 * sensor temperature, but we have to beware a conversion could occur 538 * between the readings. The datasheet says we should either use 539 * the one-shot conversion register, which we don't want to do 540 * (disables hardware monitoring) or monitor the busy bit, which is 541 * impossible (we can't read the values and monitor that bit at the 542 * exact same time). So the solution used here is to read the high 543 * byte once, then the low byte, then the high byte again. If the new 544 * high byte matches the old one, then we have a valid reading. Else 545 * we have to read the low byte again, and now we believe we have a 546 * correct reading. 547 */ 548 oldh = lm90_read_reg(client, regh); 549 if (oldh < 0) 550 return oldh; 551 l = lm90_read_reg(client, regl); 552 if (l < 0) 553 return l; 554 newh = lm90_read_reg(client, regh); 555 if (newh < 0) 556 return newh; 557 if (oldh != newh) { 558 l = lm90_read_reg(client, regl); 559 if (l < 0) 560 return l; 561 } 562 return (newh << 8) | l; 563 } 564 565 static int lm90_update_confreg(struct lm90_data *data, u8 config) 566 { 567 if (data->config != config) { 568 int err; 569 570 err = i2c_smbus_write_byte_data(data->client, 571 LM90_REG_W_CONFIG1, 572 config); 573 if (err) 574 return err; 575 data->config = config; 576 } 577 return 0; 578 } 579 580 /* 581 * client->update_lock must be held when calling this function (unless we are 582 * in detection or initialization steps), and while a remote channel other 583 * than channel 0 is selected. Also, calling code must make sure to re-select 584 * external channel 0 before releasing the lock. This is necessary because 585 * various registers have different meanings as a result of selecting a 586 * non-default remote channel. 587 */ 588 static int lm90_select_remote_channel(struct lm90_data *data, int channel) 589 { 590 int err = 0; 591 592 if (data->kind == max6696) { 593 u8 config = data->config & ~0x08; 594 595 if (channel) 596 config |= 0x08; 597 err = lm90_update_confreg(data, config); 598 } 599 return err; 600 } 601 602 static int lm90_write_convrate(struct lm90_data *data, int val) 603 { 604 u8 config = data->config; 605 int err; 606 607 /* Save config and pause conversion */ 608 if (data->flags & LM90_PAUSE_FOR_CONFIG) { 609 err = lm90_update_confreg(data, config | 0x40); 610 if (err < 0) 611 return err; 612 } 613 614 /* Set conv rate */ 615 err = i2c_smbus_write_byte_data(data->client, LM90_REG_W_CONVRATE, val); 616 617 /* Revert change to config */ 618 lm90_update_confreg(data, config); 619 620 return err; 621 } 622 623 /* 624 * Set conversion rate. 625 * client->update_lock must be held when calling this function (unless we are 626 * in detection or initialization steps). 627 */ 628 static int lm90_set_convrate(struct i2c_client *client, struct lm90_data *data, 629 unsigned int interval) 630 { 631 unsigned int update_interval; 632 int i, err; 633 634 /* Shift calculations to avoid rounding errors */ 635 interval <<= 6; 636 637 /* find the nearest update rate */ 638 for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6; 639 i < data->max_convrate; i++, update_interval >>= 1) 640 if (interval >= update_interval * 3 / 4) 641 break; 642 643 err = lm90_write_convrate(data, i); 644 data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64); 645 return err; 646 } 647 648 static int lm90_update_limits(struct device *dev) 649 { 650 struct lm90_data *data = dev_get_drvdata(dev); 651 struct i2c_client *client = data->client; 652 int val; 653 654 val = lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT); 655 if (val < 0) 656 return val; 657 data->temp8[LOCAL_CRIT] = val; 658 659 val = lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT); 660 if (val < 0) 661 return val; 662 data->temp8[REMOTE_CRIT] = val; 663 664 val = lm90_read_reg(client, LM90_REG_R_TCRIT_HYST); 665 if (val < 0) 666 return val; 667 data->temp_hyst = val; 668 669 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH); 670 if (val < 0) 671 return val; 672 data->temp11[REMOTE_LOW] = val << 8; 673 674 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) { 675 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL); 676 if (val < 0) 677 return val; 678 data->temp11[REMOTE_LOW] |= val; 679 } 680 681 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH); 682 if (val < 0) 683 return val; 684 data->temp11[REMOTE_HIGH] = val << 8; 685 686 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) { 687 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL); 688 if (val < 0) 689 return val; 690 data->temp11[REMOTE_HIGH] |= val; 691 } 692 693 if (data->flags & LM90_HAVE_OFFSET) { 694 val = lm90_read16(client, LM90_REG_R_REMOTE_OFFSH, 695 LM90_REG_R_REMOTE_OFFSL); 696 if (val < 0) 697 return val; 698 data->temp11[REMOTE_OFFSET] = val; 699 } 700 701 if (data->flags & LM90_HAVE_EMERGENCY) { 702 val = lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG); 703 if (val < 0) 704 return val; 705 data->temp8[LOCAL_EMERG] = val; 706 707 val = lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG); 708 if (val < 0) 709 return val; 710 data->temp8[REMOTE_EMERG] = val; 711 } 712 713 if (data->kind == max6696) { 714 val = lm90_select_remote_channel(data, 1); 715 if (val < 0) 716 return val; 717 718 val = lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT); 719 if (val < 0) 720 return val; 721 data->temp8[REMOTE2_CRIT] = val; 722 723 val = lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG); 724 if (val < 0) 725 return val; 726 data->temp8[REMOTE2_EMERG] = val; 727 728 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH); 729 if (val < 0) 730 return val; 731 data->temp11[REMOTE2_LOW] = val << 8; 732 733 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH); 734 if (val < 0) 735 return val; 736 data->temp11[REMOTE2_HIGH] = val << 8; 737 738 lm90_select_remote_channel(data, 0); 739 } 740 741 return 0; 742 } 743 744 static int lm90_update_device(struct device *dev) 745 { 746 struct lm90_data *data = dev_get_drvdata(dev); 747 struct i2c_client *client = data->client; 748 unsigned long next_update; 749 int val; 750 751 if (!data->valid) { 752 val = lm90_update_limits(dev); 753 if (val < 0) 754 return val; 755 } 756 757 next_update = data->last_updated + 758 msecs_to_jiffies(data->update_interval); 759 if (time_after(jiffies, next_update) || !data->valid) { 760 dev_dbg(&client->dev, "Updating lm90 data.\n"); 761 762 data->valid = false; 763 764 val = lm90_read_reg(client, LM90_REG_R_LOCAL_LOW); 765 if (val < 0) 766 return val; 767 data->temp8[LOCAL_LOW] = val; 768 769 val = lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH); 770 if (val < 0) 771 return val; 772 data->temp8[LOCAL_HIGH] = val; 773 774 if (data->reg_local_ext) { 775 val = lm90_read16(client, LM90_REG_R_LOCAL_TEMP, 776 data->reg_local_ext); 777 if (val < 0) 778 return val; 779 data->temp11[LOCAL_TEMP] = val; 780 } else { 781 val = lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP); 782 if (val < 0) 783 return val; 784 data->temp11[LOCAL_TEMP] = val << 8; 785 } 786 val = lm90_read16(client, LM90_REG_R_REMOTE_TEMPH, 787 LM90_REG_R_REMOTE_TEMPL); 788 if (val < 0) 789 return val; 790 data->temp11[REMOTE_TEMP] = val; 791 792 val = lm90_read_reg(client, LM90_REG_R_STATUS); 793 if (val < 0) 794 return val; 795 data->alarms = val; /* lower 8 bit of alarms */ 796 797 if (data->kind == max6696) { 798 val = lm90_select_remote_channel(data, 1); 799 if (val < 0) 800 return val; 801 802 val = lm90_read16(client, LM90_REG_R_REMOTE_TEMPH, 803 LM90_REG_R_REMOTE_TEMPL); 804 if (val < 0) { 805 lm90_select_remote_channel(data, 0); 806 return val; 807 } 808 data->temp11[REMOTE2_TEMP] = val; 809 810 lm90_select_remote_channel(data, 0); 811 812 val = lm90_read_reg(client, MAX6696_REG_R_STATUS2); 813 if (val < 0) 814 return val; 815 data->alarms |= val << 8; 816 } 817 818 /* 819 * Re-enable ALERT# output if it was originally enabled and 820 * relevant alarms are all clear 821 */ 822 if (!(data->config_orig & 0x80) && 823 !(data->alarms & data->alert_alarms)) { 824 if (data->config & 0x80) { 825 dev_dbg(&client->dev, "Re-enabling ALERT#\n"); 826 lm90_update_confreg(data, data->config & ~0x80); 827 } 828 } 829 830 data->last_updated = jiffies; 831 data->valid = true; 832 } 833 834 return 0; 835 } 836 837 /* 838 * Conversions 839 * For local temperatures and limits, critical limits and the hysteresis 840 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius. 841 * For remote temperatures and limits, it uses signed 11-bit values with 842 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some 843 * Maxim chips use unsigned values. 844 */ 845 846 static inline int temp_from_s8(s8 val) 847 { 848 return val * 1000; 849 } 850 851 static inline int temp_from_u8(u8 val) 852 { 853 return val * 1000; 854 } 855 856 static inline int temp_from_s16(s16 val) 857 { 858 return val / 32 * 125; 859 } 860 861 static inline int temp_from_u16(u16 val) 862 { 863 return val / 32 * 125; 864 } 865 866 static s8 temp_to_s8(long val) 867 { 868 if (val <= -128000) 869 return -128; 870 if (val >= 127000) 871 return 127; 872 if (val < 0) 873 return (val - 500) / 1000; 874 return (val + 500) / 1000; 875 } 876 877 static u8 temp_to_u8(long val) 878 { 879 if (val <= 0) 880 return 0; 881 if (val >= 255000) 882 return 255; 883 return (val + 500) / 1000; 884 } 885 886 static s16 temp_to_s16(long val) 887 { 888 if (val <= -128000) 889 return 0x8000; 890 if (val >= 127875) 891 return 0x7FE0; 892 if (val < 0) 893 return (val - 62) / 125 * 32; 894 return (val + 62) / 125 * 32; 895 } 896 897 static u8 hyst_to_reg(long val) 898 { 899 if (val <= 0) 900 return 0; 901 if (val >= 30500) 902 return 31; 903 return (val + 500) / 1000; 904 } 905 906 /* 907 * ADT7461 in compatibility mode is almost identical to LM90 except that 908 * attempts to write values that are outside the range 0 < temp < 127 are 909 * treated as the boundary value. 910 * 911 * ADT7461 in "extended mode" operation uses unsigned integers offset by 912 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC. 913 */ 914 static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val) 915 { 916 if (data->flags & LM90_FLAG_ADT7461_EXT) 917 return (val - 64) * 1000; 918 return temp_from_s8(val); 919 } 920 921 static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val) 922 { 923 if (data->flags & LM90_FLAG_ADT7461_EXT) 924 return (val - 0x4000) / 64 * 250; 925 return temp_from_s16(val); 926 } 927 928 static u8 temp_to_u8_adt7461(struct lm90_data *data, long val) 929 { 930 if (data->flags & LM90_FLAG_ADT7461_EXT) { 931 if (val <= -64000) 932 return 0; 933 if (val >= 191000) 934 return 0xFF; 935 return (val + 500 + 64000) / 1000; 936 } 937 if (val <= 0) 938 return 0; 939 if (val >= 127000) 940 return 127; 941 return (val + 500) / 1000; 942 } 943 944 static u16 temp_to_u16_adt7461(struct lm90_data *data, long val) 945 { 946 if (data->flags & LM90_FLAG_ADT7461_EXT) { 947 if (val <= -64000) 948 return 0; 949 if (val >= 191750) 950 return 0xFFC0; 951 return (val + 64000 + 125) / 250 * 64; 952 } 953 if (val <= 0) 954 return 0; 955 if (val >= 127750) 956 return 0x7FC0; 957 return (val + 125) / 250 * 64; 958 } 959 960 /* pec used for ADM1032 only */ 961 static ssize_t pec_show(struct device *dev, struct device_attribute *dummy, 962 char *buf) 963 { 964 struct i2c_client *client = to_i2c_client(dev); 965 966 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC)); 967 } 968 969 static ssize_t pec_store(struct device *dev, struct device_attribute *dummy, 970 const char *buf, size_t count) 971 { 972 struct i2c_client *client = to_i2c_client(dev); 973 long val; 974 int err; 975 976 err = kstrtol(buf, 10, &val); 977 if (err < 0) 978 return err; 979 980 switch (val) { 981 case 0: 982 client->flags &= ~I2C_CLIENT_PEC; 983 break; 984 case 1: 985 client->flags |= I2C_CLIENT_PEC; 986 break; 987 default: 988 return -EINVAL; 989 } 990 991 return count; 992 } 993 994 static DEVICE_ATTR_RW(pec); 995 996 static int lm90_get_temp11(struct lm90_data *data, int index) 997 { 998 s16 temp11 = data->temp11[index]; 999 int temp; 1000 1001 if (data->kind == adt7461 || data->kind == tmp451) 1002 temp = temp_from_u16_adt7461(data, temp11); 1003 else if (data->kind == max6646) 1004 temp = temp_from_u16(temp11); 1005 else 1006 temp = temp_from_s16(temp11); 1007 1008 /* +16 degrees offset for temp2 for the LM99 */ 1009 if (data->kind == lm99 && index <= 2) 1010 temp += 16000; 1011 1012 return temp; 1013 } 1014 1015 static int lm90_set_temp11(struct lm90_data *data, int index, long val) 1016 { 1017 static struct reg { 1018 u8 high; 1019 u8 low; 1020 } reg[] = { 1021 [REMOTE_LOW] = { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL }, 1022 [REMOTE_HIGH] = { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL }, 1023 [REMOTE_OFFSET] = { LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL }, 1024 [REMOTE2_LOW] = { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL }, 1025 [REMOTE2_HIGH] = { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL } 1026 }; 1027 struct i2c_client *client = data->client; 1028 struct reg *regp = ®[index]; 1029 int err; 1030 1031 /* +16 degrees offset for temp2 for the LM99 */ 1032 if (data->kind == lm99 && index <= 2) { 1033 /* prevent integer underflow */ 1034 val = max(val, -128000l); 1035 val -= 16000; 1036 } 1037 1038 if (data->kind == adt7461 || data->kind == tmp451) 1039 data->temp11[index] = temp_to_u16_adt7461(data, val); 1040 else if (data->kind == max6646) 1041 data->temp11[index] = temp_to_u8(val) << 8; 1042 else if (data->flags & LM90_HAVE_REM_LIMIT_EXT) 1043 data->temp11[index] = temp_to_s16(val); 1044 else 1045 data->temp11[index] = temp_to_s8(val) << 8; 1046 1047 lm90_select_remote_channel(data, index >= 3); 1048 err = i2c_smbus_write_byte_data(client, regp->high, 1049 data->temp11[index] >> 8); 1050 if (err < 0) 1051 return err; 1052 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) 1053 err = i2c_smbus_write_byte_data(client, regp->low, 1054 data->temp11[index] & 0xff); 1055 1056 lm90_select_remote_channel(data, 0); 1057 return err; 1058 } 1059 1060 static int lm90_get_temp8(struct lm90_data *data, int index) 1061 { 1062 s8 temp8 = data->temp8[index]; 1063 int temp; 1064 1065 if (data->kind == adt7461 || data->kind == tmp451) 1066 temp = temp_from_u8_adt7461(data, temp8); 1067 else if (data->kind == max6646) 1068 temp = temp_from_u8(temp8); 1069 else 1070 temp = temp_from_s8(temp8); 1071 1072 /* +16 degrees offset for temp2 for the LM99 */ 1073 if (data->kind == lm99 && index == 3) 1074 temp += 16000; 1075 1076 return temp; 1077 } 1078 1079 static int lm90_set_temp8(struct lm90_data *data, int index, long val) 1080 { 1081 static const u8 reg[TEMP8_REG_NUM] = { 1082 LM90_REG_W_LOCAL_LOW, 1083 LM90_REG_W_LOCAL_HIGH, 1084 LM90_REG_W_LOCAL_CRIT, 1085 LM90_REG_W_REMOTE_CRIT, 1086 MAX6659_REG_W_LOCAL_EMERG, 1087 MAX6659_REG_W_REMOTE_EMERG, 1088 LM90_REG_W_REMOTE_CRIT, 1089 MAX6659_REG_W_REMOTE_EMERG, 1090 }; 1091 struct i2c_client *client = data->client; 1092 int err; 1093 1094 /* +16 degrees offset for temp2 for the LM99 */ 1095 if (data->kind == lm99 && index == 3) { 1096 /* prevent integer underflow */ 1097 val = max(val, -128000l); 1098 val -= 16000; 1099 } 1100 1101 if (data->kind == adt7461 || data->kind == tmp451) 1102 data->temp8[index] = temp_to_u8_adt7461(data, val); 1103 else if (data->kind == max6646) 1104 data->temp8[index] = temp_to_u8(val); 1105 else 1106 data->temp8[index] = temp_to_s8(val); 1107 1108 lm90_select_remote_channel(data, index >= 6); 1109 err = i2c_smbus_write_byte_data(client, reg[index], data->temp8[index]); 1110 lm90_select_remote_channel(data, 0); 1111 1112 return err; 1113 } 1114 1115 static int lm90_get_temphyst(struct lm90_data *data, int index) 1116 { 1117 int temp; 1118 1119 if (data->kind == adt7461 || data->kind == tmp451) 1120 temp = temp_from_u8_adt7461(data, data->temp8[index]); 1121 else if (data->kind == max6646) 1122 temp = temp_from_u8(data->temp8[index]); 1123 else 1124 temp = temp_from_s8(data->temp8[index]); 1125 1126 /* +16 degrees offset for temp2 for the LM99 */ 1127 if (data->kind == lm99 && index == 3) 1128 temp += 16000; 1129 1130 return temp - temp_from_s8(data->temp_hyst); 1131 } 1132 1133 static int lm90_set_temphyst(struct lm90_data *data, long val) 1134 { 1135 struct i2c_client *client = data->client; 1136 int temp; 1137 int err; 1138 1139 if (data->kind == adt7461 || data->kind == tmp451) 1140 temp = temp_from_u8_adt7461(data, data->temp8[LOCAL_CRIT]); 1141 else if (data->kind == max6646) 1142 temp = temp_from_u8(data->temp8[LOCAL_CRIT]); 1143 else 1144 temp = temp_from_s8(data->temp8[LOCAL_CRIT]); 1145 1146 /* prevent integer underflow */ 1147 val = max(val, -128000l); 1148 1149 data->temp_hyst = hyst_to_reg(temp - val); 1150 err = i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST, 1151 data->temp_hyst); 1152 return err; 1153 } 1154 1155 static const u8 lm90_temp_index[3] = { 1156 LOCAL_TEMP, REMOTE_TEMP, REMOTE2_TEMP 1157 }; 1158 1159 static const u8 lm90_temp_min_index[3] = { 1160 LOCAL_LOW, REMOTE_LOW, REMOTE2_LOW 1161 }; 1162 1163 static const u8 lm90_temp_max_index[3] = { 1164 LOCAL_HIGH, REMOTE_HIGH, REMOTE2_HIGH 1165 }; 1166 1167 static const u8 lm90_temp_crit_index[3] = { 1168 LOCAL_CRIT, REMOTE_CRIT, REMOTE2_CRIT 1169 }; 1170 1171 static const u8 lm90_temp_emerg_index[3] = { 1172 LOCAL_EMERG, REMOTE_EMERG, REMOTE2_EMERG 1173 }; 1174 1175 static const u8 lm90_min_alarm_bits[3] = { 5, 3, 11 }; 1176 static const u8 lm90_max_alarm_bits[3] = { 6, 4, 12 }; 1177 static const u8 lm90_crit_alarm_bits[3] = { 0, 1, 9 }; 1178 static const u8 lm90_emergency_alarm_bits[3] = { 15, 13, 14 }; 1179 static const u8 lm90_fault_bits[3] = { 0, 2, 10 }; 1180 1181 static int lm90_temp_read(struct device *dev, u32 attr, int channel, long *val) 1182 { 1183 struct lm90_data *data = dev_get_drvdata(dev); 1184 int err; 1185 1186 mutex_lock(&data->update_lock); 1187 err = lm90_update_device(dev); 1188 mutex_unlock(&data->update_lock); 1189 if (err) 1190 return err; 1191 1192 switch (attr) { 1193 case hwmon_temp_input: 1194 *val = lm90_get_temp11(data, lm90_temp_index[channel]); 1195 break; 1196 case hwmon_temp_min_alarm: 1197 *val = (data->alarms >> lm90_min_alarm_bits[channel]) & 1; 1198 break; 1199 case hwmon_temp_max_alarm: 1200 *val = (data->alarms >> lm90_max_alarm_bits[channel]) & 1; 1201 break; 1202 case hwmon_temp_crit_alarm: 1203 *val = (data->alarms >> lm90_crit_alarm_bits[channel]) & 1; 1204 break; 1205 case hwmon_temp_emergency_alarm: 1206 *val = (data->alarms >> lm90_emergency_alarm_bits[channel]) & 1; 1207 break; 1208 case hwmon_temp_fault: 1209 *val = (data->alarms >> lm90_fault_bits[channel]) & 1; 1210 break; 1211 case hwmon_temp_min: 1212 if (channel == 0) 1213 *val = lm90_get_temp8(data, 1214 lm90_temp_min_index[channel]); 1215 else 1216 *val = lm90_get_temp11(data, 1217 lm90_temp_min_index[channel]); 1218 break; 1219 case hwmon_temp_max: 1220 if (channel == 0) 1221 *val = lm90_get_temp8(data, 1222 lm90_temp_max_index[channel]); 1223 else 1224 *val = lm90_get_temp11(data, 1225 lm90_temp_max_index[channel]); 1226 break; 1227 case hwmon_temp_crit: 1228 *val = lm90_get_temp8(data, lm90_temp_crit_index[channel]); 1229 break; 1230 case hwmon_temp_crit_hyst: 1231 *val = lm90_get_temphyst(data, lm90_temp_crit_index[channel]); 1232 break; 1233 case hwmon_temp_emergency: 1234 *val = lm90_get_temp8(data, lm90_temp_emerg_index[channel]); 1235 break; 1236 case hwmon_temp_emergency_hyst: 1237 *val = lm90_get_temphyst(data, lm90_temp_emerg_index[channel]); 1238 break; 1239 case hwmon_temp_offset: 1240 *val = lm90_get_temp11(data, REMOTE_OFFSET); 1241 break; 1242 default: 1243 return -EOPNOTSUPP; 1244 } 1245 return 0; 1246 } 1247 1248 static int lm90_temp_write(struct device *dev, u32 attr, int channel, long val) 1249 { 1250 struct lm90_data *data = dev_get_drvdata(dev); 1251 int err; 1252 1253 mutex_lock(&data->update_lock); 1254 1255 err = lm90_update_device(dev); 1256 if (err) 1257 goto error; 1258 1259 switch (attr) { 1260 case hwmon_temp_min: 1261 if (channel == 0) 1262 err = lm90_set_temp8(data, 1263 lm90_temp_min_index[channel], 1264 val); 1265 else 1266 err = lm90_set_temp11(data, 1267 lm90_temp_min_index[channel], 1268 val); 1269 break; 1270 case hwmon_temp_max: 1271 if (channel == 0) 1272 err = lm90_set_temp8(data, 1273 lm90_temp_max_index[channel], 1274 val); 1275 else 1276 err = lm90_set_temp11(data, 1277 lm90_temp_max_index[channel], 1278 val); 1279 break; 1280 case hwmon_temp_crit: 1281 err = lm90_set_temp8(data, lm90_temp_crit_index[channel], val); 1282 break; 1283 case hwmon_temp_crit_hyst: 1284 err = lm90_set_temphyst(data, val); 1285 break; 1286 case hwmon_temp_emergency: 1287 err = lm90_set_temp8(data, lm90_temp_emerg_index[channel], val); 1288 break; 1289 case hwmon_temp_offset: 1290 err = lm90_set_temp11(data, REMOTE_OFFSET, val); 1291 break; 1292 default: 1293 err = -EOPNOTSUPP; 1294 break; 1295 } 1296 error: 1297 mutex_unlock(&data->update_lock); 1298 1299 return err; 1300 } 1301 1302 static umode_t lm90_temp_is_visible(const void *data, u32 attr, int channel) 1303 { 1304 switch (attr) { 1305 case hwmon_temp_input: 1306 case hwmon_temp_min_alarm: 1307 case hwmon_temp_max_alarm: 1308 case hwmon_temp_crit_alarm: 1309 case hwmon_temp_emergency_alarm: 1310 case hwmon_temp_emergency_hyst: 1311 case hwmon_temp_fault: 1312 return 0444; 1313 case hwmon_temp_min: 1314 case hwmon_temp_max: 1315 case hwmon_temp_crit: 1316 case hwmon_temp_emergency: 1317 case hwmon_temp_offset: 1318 return 0644; 1319 case hwmon_temp_crit_hyst: 1320 if (channel == 0) 1321 return 0644; 1322 return 0444; 1323 default: 1324 return 0; 1325 } 1326 } 1327 1328 static int lm90_chip_read(struct device *dev, u32 attr, int channel, long *val) 1329 { 1330 struct lm90_data *data = dev_get_drvdata(dev); 1331 int err; 1332 1333 mutex_lock(&data->update_lock); 1334 err = lm90_update_device(dev); 1335 mutex_unlock(&data->update_lock); 1336 if (err) 1337 return err; 1338 1339 switch (attr) { 1340 case hwmon_chip_update_interval: 1341 *val = data->update_interval; 1342 break; 1343 case hwmon_chip_alarms: 1344 *val = data->alarms; 1345 break; 1346 default: 1347 return -EOPNOTSUPP; 1348 } 1349 1350 return 0; 1351 } 1352 1353 static int lm90_chip_write(struct device *dev, u32 attr, int channel, long val) 1354 { 1355 struct lm90_data *data = dev_get_drvdata(dev); 1356 struct i2c_client *client = data->client; 1357 int err; 1358 1359 mutex_lock(&data->update_lock); 1360 1361 err = lm90_update_device(dev); 1362 if (err) 1363 goto error; 1364 1365 switch (attr) { 1366 case hwmon_chip_update_interval: 1367 err = lm90_set_convrate(client, data, 1368 clamp_val(val, 0, 100000)); 1369 break; 1370 default: 1371 err = -EOPNOTSUPP; 1372 break; 1373 } 1374 error: 1375 mutex_unlock(&data->update_lock); 1376 1377 return err; 1378 } 1379 1380 static umode_t lm90_chip_is_visible(const void *data, u32 attr, int channel) 1381 { 1382 switch (attr) { 1383 case hwmon_chip_update_interval: 1384 return 0644; 1385 case hwmon_chip_alarms: 1386 return 0444; 1387 default: 1388 return 0; 1389 } 1390 } 1391 1392 static int lm90_read(struct device *dev, enum hwmon_sensor_types type, 1393 u32 attr, int channel, long *val) 1394 { 1395 switch (type) { 1396 case hwmon_chip: 1397 return lm90_chip_read(dev, attr, channel, val); 1398 case hwmon_temp: 1399 return lm90_temp_read(dev, attr, channel, val); 1400 default: 1401 return -EOPNOTSUPP; 1402 } 1403 } 1404 1405 static int lm90_write(struct device *dev, enum hwmon_sensor_types type, 1406 u32 attr, int channel, long val) 1407 { 1408 switch (type) { 1409 case hwmon_chip: 1410 return lm90_chip_write(dev, attr, channel, val); 1411 case hwmon_temp: 1412 return lm90_temp_write(dev, attr, channel, val); 1413 default: 1414 return -EOPNOTSUPP; 1415 } 1416 } 1417 1418 static umode_t lm90_is_visible(const void *data, enum hwmon_sensor_types type, 1419 u32 attr, int channel) 1420 { 1421 switch (type) { 1422 case hwmon_chip: 1423 return lm90_chip_is_visible(data, attr, channel); 1424 case hwmon_temp: 1425 return lm90_temp_is_visible(data, attr, channel); 1426 default: 1427 return 0; 1428 } 1429 } 1430 1431 /* Return 0 if detection is successful, -ENODEV otherwise */ 1432 static int lm90_detect(struct i2c_client *client, 1433 struct i2c_board_info *info) 1434 { 1435 struct i2c_adapter *adapter = client->adapter; 1436 int address = client->addr; 1437 const char *name = NULL; 1438 int man_id, chip_id, config1, config2, convrate; 1439 1440 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1441 return -ENODEV; 1442 1443 /* detection and identification */ 1444 man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID); 1445 chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID); 1446 config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1); 1447 convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE); 1448 if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0) 1449 return -ENODEV; 1450 1451 if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) { 1452 config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2); 1453 if (config2 < 0) 1454 return -ENODEV; 1455 } else 1456 config2 = 0; /* Make compiler happy */ 1457 1458 if ((address == 0x4C || address == 0x4D) 1459 && man_id == 0x01) { /* National Semiconductor */ 1460 if ((config1 & 0x2A) == 0x00 1461 && (config2 & 0xF8) == 0x00 1462 && convrate <= 0x09) { 1463 if (address == 0x4C 1464 && (chip_id & 0xF0) == 0x20) { /* LM90 */ 1465 name = "lm90"; 1466 } else 1467 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */ 1468 name = "lm99"; 1469 dev_info(&adapter->dev, 1470 "Assuming LM99 chip at 0x%02x\n", 1471 address); 1472 dev_info(&adapter->dev, 1473 "If it is an LM89, instantiate it " 1474 "with the new_device sysfs " 1475 "interface\n"); 1476 } else 1477 if (address == 0x4C 1478 && (chip_id & 0xF0) == 0x10) { /* LM86 */ 1479 name = "lm86"; 1480 } 1481 } 1482 } else 1483 if ((address == 0x4C || address == 0x4D) 1484 && man_id == 0x41) { /* Analog Devices */ 1485 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */ 1486 && (config1 & 0x3F) == 0x00 1487 && convrate <= 0x0A) { 1488 name = "adm1032"; 1489 /* 1490 * The ADM1032 supports PEC, but only if combined 1491 * transactions are not used. 1492 */ 1493 if (i2c_check_functionality(adapter, 1494 I2C_FUNC_SMBUS_BYTE)) 1495 info->flags |= I2C_CLIENT_PEC; 1496 } else 1497 if (chip_id == 0x51 /* ADT7461 */ 1498 && (config1 & 0x1B) == 0x00 1499 && convrate <= 0x0A) { 1500 name = "adt7461"; 1501 } else 1502 if (chip_id == 0x57 /* ADT7461A, NCT1008 */ 1503 && (config1 & 0x1B) == 0x00 1504 && convrate <= 0x0A) { 1505 name = "adt7461a"; 1506 } 1507 } else 1508 if (man_id == 0x4D) { /* Maxim */ 1509 int emerg, emerg2, status2; 1510 1511 /* 1512 * We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read 1513 * LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG 1514 * exists, both readings will reflect the same value. Otherwise, 1515 * the readings will be different. 1516 */ 1517 emerg = i2c_smbus_read_byte_data(client, 1518 MAX6659_REG_R_REMOTE_EMERG); 1519 man_id = i2c_smbus_read_byte_data(client, 1520 LM90_REG_R_MAN_ID); 1521 emerg2 = i2c_smbus_read_byte_data(client, 1522 MAX6659_REG_R_REMOTE_EMERG); 1523 status2 = i2c_smbus_read_byte_data(client, 1524 MAX6696_REG_R_STATUS2); 1525 if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0) 1526 return -ENODEV; 1527 1528 /* 1529 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id 1530 * register. Reading from that address will return the last 1531 * read value, which in our case is those of the man_id 1532 * register. Likewise, the config1 register seems to lack a 1533 * low nibble, so the value will be those of the previous 1534 * read, so in our case those of the man_id register. 1535 * MAX6659 has a third set of upper temperature limit registers. 1536 * Those registers also return values on MAX6657 and MAX6658, 1537 * thus the only way to detect MAX6659 is by its address. 1538 * For this reason it will be mis-detected as MAX6657 if its 1539 * address is 0x4C. 1540 */ 1541 if (chip_id == man_id 1542 && (address == 0x4C || address == 0x4D || address == 0x4E) 1543 && (config1 & 0x1F) == (man_id & 0x0F) 1544 && convrate <= 0x09) { 1545 if (address == 0x4C) 1546 name = "max6657"; 1547 else 1548 name = "max6659"; 1549 } else 1550 /* 1551 * Even though MAX6695 and MAX6696 do not have a chip ID 1552 * register, reading it returns 0x01. Bit 4 of the config1 1553 * register is unused and should return zero when read. Bit 0 of 1554 * the status2 register is unused and should return zero when 1555 * read. 1556 * 1557 * MAX6695 and MAX6696 have an additional set of temperature 1558 * limit registers. We can detect those chips by checking if 1559 * one of those registers exists. 1560 */ 1561 if (chip_id == 0x01 1562 && (config1 & 0x10) == 0x00 1563 && (status2 & 0x01) == 0x00 1564 && emerg == emerg2 1565 && convrate <= 0x07) { 1566 name = "max6696"; 1567 } else 1568 /* 1569 * The chip_id register of the MAX6680 and MAX6681 holds the 1570 * revision of the chip. The lowest bit of the config1 register 1571 * is unused and should return zero when read, so should the 1572 * second to last bit of config1 (software reset). 1573 */ 1574 if (chip_id == 0x01 1575 && (config1 & 0x03) == 0x00 1576 && convrate <= 0x07) { 1577 name = "max6680"; 1578 } else 1579 /* 1580 * The chip_id register of the MAX6646/6647/6649 holds the 1581 * revision of the chip. The lowest 6 bits of the config1 1582 * register are unused and should return zero when read. 1583 */ 1584 if (chip_id == 0x59 1585 && (config1 & 0x3f) == 0x00 1586 && convrate <= 0x07) { 1587 name = "max6646"; 1588 } else 1589 /* 1590 * The chip_id of the MAX6654 holds the revision of the chip. 1591 * The lowest 3 bits of the config1 register are unused and 1592 * should return zero when read. 1593 */ 1594 if (chip_id == 0x08 1595 && (config1 & 0x07) == 0x00 1596 && convrate <= 0x07) { 1597 name = "max6654"; 1598 } 1599 } else 1600 if (address == 0x4C 1601 && man_id == 0x5C) { /* Winbond/Nuvoton */ 1602 if ((config1 & 0x2A) == 0x00 1603 && (config2 & 0xF8) == 0x00) { 1604 if (chip_id == 0x01 /* W83L771W/G */ 1605 && convrate <= 0x09) { 1606 name = "w83l771"; 1607 } else 1608 if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */ 1609 && convrate <= 0x08) { 1610 name = "w83l771"; 1611 } 1612 } 1613 } else 1614 if (address >= 0x48 && address <= 0x4F 1615 && man_id == 0xA1) { /* NXP Semiconductor/Philips */ 1616 if (chip_id == 0x00 1617 && (config1 & 0x2A) == 0x00 1618 && (config2 & 0xFE) == 0x00 1619 && convrate <= 0x09) { 1620 name = "sa56004"; 1621 } 1622 } else 1623 if ((address == 0x4C || address == 0x4D) 1624 && man_id == 0x47) { /* GMT */ 1625 if (chip_id == 0x01 /* G781 */ 1626 && (config1 & 0x3F) == 0x00 1627 && convrate <= 0x08) 1628 name = "g781"; 1629 } else 1630 if (address == 0x4C 1631 && man_id == 0x55) { /* Texas Instruments */ 1632 int local_ext; 1633 1634 local_ext = i2c_smbus_read_byte_data(client, 1635 TMP451_REG_R_LOCAL_TEMPL); 1636 1637 if (chip_id == 0x00 /* TMP451 */ 1638 && (config1 & 0x1B) == 0x00 1639 && convrate <= 0x09 1640 && (local_ext & 0x0F) == 0x00) 1641 name = "tmp451"; 1642 } 1643 1644 if (!name) { /* identification failed */ 1645 dev_dbg(&adapter->dev, 1646 "Unsupported chip at 0x%02x (man_id=0x%02X, " 1647 "chip_id=0x%02X)\n", address, man_id, chip_id); 1648 return -ENODEV; 1649 } 1650 1651 strlcpy(info->type, name, I2C_NAME_SIZE); 1652 1653 return 0; 1654 } 1655 1656 static void lm90_restore_conf(void *_data) 1657 { 1658 struct lm90_data *data = _data; 1659 struct i2c_client *client = data->client; 1660 1661 /* Restore initial configuration */ 1662 lm90_write_convrate(data, data->convrate_orig); 1663 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, 1664 data->config_orig); 1665 } 1666 1667 static int lm90_init_client(struct i2c_client *client, struct lm90_data *data) 1668 { 1669 int config, convrate; 1670 1671 convrate = lm90_read_reg(client, LM90_REG_R_CONVRATE); 1672 if (convrate < 0) 1673 return convrate; 1674 data->convrate_orig = convrate; 1675 1676 /* 1677 * Start the conversions. 1678 */ 1679 config = lm90_read_reg(client, LM90_REG_R_CONFIG1); 1680 if (config < 0) 1681 return config; 1682 data->config_orig = config; 1683 data->config = config; 1684 1685 lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */ 1686 1687 /* Check Temperature Range Select */ 1688 if (data->kind == adt7461 || data->kind == tmp451) { 1689 if (config & 0x04) 1690 data->flags |= LM90_FLAG_ADT7461_EXT; 1691 } 1692 1693 /* 1694 * Put MAX6680/MAX8881 into extended resolution (bit 0x10, 1695 * 0.125 degree resolution) and range (0x08, extend range 1696 * to -64 degree) mode for the remote temperature sensor. 1697 */ 1698 if (data->kind == max6680) 1699 config |= 0x18; 1700 1701 /* 1702 * Put MAX6654 into extended range (0x20, extend minimum range from 1703 * 0 degrees to -64 degrees). Note that extended resolution is not 1704 * possible on the MAX6654 unless conversion rate is set to 1 Hz or 1705 * slower, which is intentionally not done by default. 1706 */ 1707 if (data->kind == max6654) 1708 config |= 0x20; 1709 1710 /* 1711 * Select external channel 0 for max6695/96 1712 */ 1713 if (data->kind == max6696) 1714 config &= ~0x08; 1715 1716 /* 1717 * Interrupt is enabled by default on reset, but it may be disabled 1718 * by bootloader, unmask it. 1719 */ 1720 if (client->irq) 1721 config &= ~0x80; 1722 1723 config &= 0xBF; /* run */ 1724 lm90_update_confreg(data, config); 1725 1726 return devm_add_action_or_reset(&client->dev, lm90_restore_conf, data); 1727 } 1728 1729 static bool lm90_is_tripped(struct i2c_client *client, u16 *status) 1730 { 1731 struct lm90_data *data = i2c_get_clientdata(client); 1732 int st, st2 = 0; 1733 1734 st = lm90_read_reg(client, LM90_REG_R_STATUS); 1735 if (st < 0) 1736 return false; 1737 1738 if (data->kind == max6696) { 1739 st2 = lm90_read_reg(client, MAX6696_REG_R_STATUS2); 1740 if (st2 < 0) 1741 return false; 1742 } 1743 1744 *status = st | (st2 << 8); 1745 1746 if ((st & 0x7f) == 0 && (st2 & 0xfe) == 0) 1747 return false; 1748 1749 if ((st & (LM90_STATUS_LLOW | LM90_STATUS_LHIGH | LM90_STATUS_LTHRM)) || 1750 (st2 & MAX6696_STATUS2_LOT2)) 1751 dev_dbg(&client->dev, 1752 "temp%d out of range, please check!\n", 1); 1753 if ((st & (LM90_STATUS_RLOW | LM90_STATUS_RHIGH | LM90_STATUS_RTHRM)) || 1754 (st2 & MAX6696_STATUS2_ROT2)) 1755 dev_dbg(&client->dev, 1756 "temp%d out of range, please check!\n", 2); 1757 if (st & LM90_STATUS_ROPEN) 1758 dev_dbg(&client->dev, 1759 "temp%d diode open, please check!\n", 2); 1760 if (st2 & (MAX6696_STATUS2_R2LOW | MAX6696_STATUS2_R2HIGH | 1761 MAX6696_STATUS2_R2THRM | MAX6696_STATUS2_R2OT2)) 1762 dev_dbg(&client->dev, 1763 "temp%d out of range, please check!\n", 3); 1764 if (st2 & MAX6696_STATUS2_R2OPEN) 1765 dev_dbg(&client->dev, 1766 "temp%d diode open, please check!\n", 3); 1767 1768 if (st & LM90_STATUS_LLOW) 1769 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1770 hwmon_temp_min, 0); 1771 if (st & LM90_STATUS_RLOW) 1772 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1773 hwmon_temp_min, 1); 1774 if (st2 & MAX6696_STATUS2_R2LOW) 1775 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1776 hwmon_temp_min, 2); 1777 if (st & LM90_STATUS_LHIGH) 1778 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1779 hwmon_temp_max, 0); 1780 if (st & LM90_STATUS_RHIGH) 1781 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1782 hwmon_temp_max, 1); 1783 if (st2 & MAX6696_STATUS2_R2HIGH) 1784 hwmon_notify_event(data->hwmon_dev, hwmon_temp, 1785 hwmon_temp_max, 2); 1786 1787 return true; 1788 } 1789 1790 static irqreturn_t lm90_irq_thread(int irq, void *dev_id) 1791 { 1792 struct i2c_client *client = dev_id; 1793 u16 status; 1794 1795 if (lm90_is_tripped(client, &status)) 1796 return IRQ_HANDLED; 1797 else 1798 return IRQ_NONE; 1799 } 1800 1801 static void lm90_remove_pec(void *dev) 1802 { 1803 device_remove_file(dev, &dev_attr_pec); 1804 } 1805 1806 static void lm90_regulator_disable(void *regulator) 1807 { 1808 regulator_disable(regulator); 1809 } 1810 1811 1812 static const struct hwmon_ops lm90_ops = { 1813 .is_visible = lm90_is_visible, 1814 .read = lm90_read, 1815 .write = lm90_write, 1816 }; 1817 1818 static int lm90_probe(struct i2c_client *client) 1819 { 1820 struct device *dev = &client->dev; 1821 struct i2c_adapter *adapter = client->adapter; 1822 struct hwmon_channel_info *info; 1823 struct regulator *regulator; 1824 struct device *hwmon_dev; 1825 struct lm90_data *data; 1826 int err; 1827 1828 regulator = devm_regulator_get(dev, "vcc"); 1829 if (IS_ERR(regulator)) 1830 return PTR_ERR(regulator); 1831 1832 err = regulator_enable(regulator); 1833 if (err < 0) { 1834 dev_err(dev, "Failed to enable regulator: %d\n", err); 1835 return err; 1836 } 1837 1838 err = devm_add_action_or_reset(dev, lm90_regulator_disable, regulator); 1839 if (err) 1840 return err; 1841 1842 data = devm_kzalloc(dev, sizeof(struct lm90_data), GFP_KERNEL); 1843 if (!data) 1844 return -ENOMEM; 1845 1846 data->client = client; 1847 i2c_set_clientdata(client, data); 1848 mutex_init(&data->update_lock); 1849 1850 /* Set the device type */ 1851 if (client->dev.of_node) 1852 data->kind = (enum chips)of_device_get_match_data(&client->dev); 1853 else 1854 data->kind = i2c_match_id(lm90_id, client)->driver_data; 1855 if (data->kind == adm1032) { 1856 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) 1857 client->flags &= ~I2C_CLIENT_PEC; 1858 } 1859 1860 /* 1861 * Different devices have different alarm bits triggering the 1862 * ALERT# output 1863 */ 1864 data->alert_alarms = lm90_params[data->kind].alert_alarms; 1865 1866 /* Set chip capabilities */ 1867 data->flags = lm90_params[data->kind].flags; 1868 1869 data->chip.ops = &lm90_ops; 1870 data->chip.info = data->info; 1871 1872 data->info[0] = HWMON_CHANNEL_INFO(chip, 1873 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL | HWMON_C_ALARMS); 1874 data->info[1] = &data->temp_info; 1875 1876 info = &data->temp_info; 1877 info->type = hwmon_temp; 1878 info->config = data->channel_config; 1879 1880 data->channel_config[0] = HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 1881 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 1882 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM; 1883 data->channel_config[1] = HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 1884 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 1885 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT; 1886 1887 if (data->flags & LM90_HAVE_OFFSET) 1888 data->channel_config[1] |= HWMON_T_OFFSET; 1889 1890 if (data->flags & LM90_HAVE_EMERGENCY) { 1891 data->channel_config[0] |= HWMON_T_EMERGENCY | 1892 HWMON_T_EMERGENCY_HYST; 1893 data->channel_config[1] |= HWMON_T_EMERGENCY | 1894 HWMON_T_EMERGENCY_HYST; 1895 } 1896 1897 if (data->flags & LM90_HAVE_EMERGENCY_ALARM) { 1898 data->channel_config[0] |= HWMON_T_EMERGENCY_ALARM; 1899 data->channel_config[1] |= HWMON_T_EMERGENCY_ALARM; 1900 } 1901 1902 if (data->flags & LM90_HAVE_TEMP3) { 1903 data->channel_config[2] = HWMON_T_INPUT | 1904 HWMON_T_MIN | HWMON_T_MAX | 1905 HWMON_T_CRIT | HWMON_T_CRIT_HYST | 1906 HWMON_T_EMERGENCY | HWMON_T_EMERGENCY_HYST | 1907 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM | 1908 HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY_ALARM | 1909 HWMON_T_FAULT; 1910 } 1911 1912 data->reg_local_ext = lm90_params[data->kind].reg_local_ext; 1913 1914 /* Set maximum conversion rate */ 1915 data->max_convrate = lm90_params[data->kind].max_convrate; 1916 1917 /* Initialize the LM90 chip */ 1918 err = lm90_init_client(client, data); 1919 if (err < 0) { 1920 dev_err(dev, "Failed to initialize device\n"); 1921 return err; 1922 } 1923 1924 /* 1925 * The 'pec' attribute is attached to the i2c device and thus created 1926 * separately. 1927 */ 1928 if (client->flags & I2C_CLIENT_PEC) { 1929 err = device_create_file(dev, &dev_attr_pec); 1930 if (err) 1931 return err; 1932 err = devm_add_action_or_reset(dev, lm90_remove_pec, dev); 1933 if (err) 1934 return err; 1935 } 1936 1937 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 1938 data, &data->chip, 1939 NULL); 1940 if (IS_ERR(hwmon_dev)) 1941 return PTR_ERR(hwmon_dev); 1942 1943 data->hwmon_dev = hwmon_dev; 1944 1945 if (client->irq) { 1946 dev_dbg(dev, "IRQ: %d\n", client->irq); 1947 err = devm_request_threaded_irq(dev, client->irq, 1948 NULL, lm90_irq_thread, 1949 IRQF_ONESHOT, "lm90", client); 1950 if (err < 0) { 1951 dev_err(dev, "cannot request IRQ %d\n", client->irq); 1952 return err; 1953 } 1954 } 1955 1956 return 0; 1957 } 1958 1959 static void lm90_alert(struct i2c_client *client, enum i2c_alert_protocol type, 1960 unsigned int flag) 1961 { 1962 u16 alarms; 1963 1964 if (type != I2C_PROTOCOL_SMBUS_ALERT) 1965 return; 1966 1967 if (lm90_is_tripped(client, &alarms)) { 1968 /* 1969 * Disable ALERT# output, because these chips don't implement 1970 * SMBus alert correctly; they should only hold the alert line 1971 * low briefly. 1972 */ 1973 struct lm90_data *data = i2c_get_clientdata(client); 1974 1975 if ((data->flags & LM90_HAVE_BROKEN_ALERT) && 1976 (alarms & data->alert_alarms)) { 1977 dev_dbg(&client->dev, "Disabling ALERT#\n"); 1978 lm90_update_confreg(data, data->config | 0x80); 1979 } 1980 } else { 1981 dev_dbg(&client->dev, "Everything OK\n"); 1982 } 1983 } 1984 1985 static int __maybe_unused lm90_suspend(struct device *dev) 1986 { 1987 struct lm90_data *data = dev_get_drvdata(dev); 1988 struct i2c_client *client = data->client; 1989 1990 if (client->irq) 1991 disable_irq(client->irq); 1992 1993 return 0; 1994 } 1995 1996 static int __maybe_unused lm90_resume(struct device *dev) 1997 { 1998 struct lm90_data *data = dev_get_drvdata(dev); 1999 struct i2c_client *client = data->client; 2000 2001 if (client->irq) 2002 enable_irq(client->irq); 2003 2004 return 0; 2005 } 2006 2007 static SIMPLE_DEV_PM_OPS(lm90_pm_ops, lm90_suspend, lm90_resume); 2008 2009 static struct i2c_driver lm90_driver = { 2010 .class = I2C_CLASS_HWMON, 2011 .driver = { 2012 .name = "lm90", 2013 .of_match_table = of_match_ptr(lm90_of_match), 2014 .pm = &lm90_pm_ops, 2015 }, 2016 .probe_new = lm90_probe, 2017 .alert = lm90_alert, 2018 .id_table = lm90_id, 2019 .detect = lm90_detect, 2020 .address_list = normal_i2c, 2021 }; 2022 2023 module_i2c_driver(lm90_driver); 2024 2025 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>"); 2026 MODULE_DESCRIPTION("LM90/ADM1032 driver"); 2027 MODULE_LICENSE("GPL"); 2028