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