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