1 /* 2 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/init.h> 23 #include <linux/slab.h> 24 #include <linux/jiffies.h> 25 #include <linux/i2c.h> 26 #include <linux/hwmon.h> 27 #include <linux/hwmon-sysfs.h> 28 #include <linux/err.h> 29 #include <linux/of.h> 30 #include <linux/regmap.h> 31 #include "lm75.h" 32 33 34 /* 35 * This driver handles the LM75 and compatible digital temperature sensors. 36 */ 37 38 enum lm75_type { /* keep sorted in alphabetical order */ 39 adt75, 40 ds1775, 41 ds75, 42 ds7505, 43 g751, 44 lm75, 45 lm75a, 46 lm75b, 47 max6625, 48 max6626, 49 mcp980x, 50 stds75, 51 tcn75, 52 tmp100, 53 tmp101, 54 tmp105, 55 tmp112, 56 tmp175, 57 tmp275, 58 tmp75, 59 tmp75c, 60 }; 61 62 /* Addresses scanned */ 63 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 64 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 65 66 67 /* The LM75 registers */ 68 #define LM75_REG_TEMP 0x00 69 #define LM75_REG_CONF 0x01 70 #define LM75_REG_HYST 0x02 71 #define LM75_REG_MAX 0x03 72 73 /* Each client has this additional data */ 74 struct lm75_data { 75 struct i2c_client *client; 76 struct regmap *regmap; 77 u8 orig_conf; 78 u8 resolution; /* In bits, between 9 and 12 */ 79 u8 resolution_limits; 80 unsigned int sample_time; /* In ms */ 81 }; 82 83 /*-----------------------------------------------------------------------*/ 84 85 static inline long lm75_reg_to_mc(s16 temp, u8 resolution) 86 { 87 return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8); 88 } 89 90 static int lm75_read(struct device *dev, enum hwmon_sensor_types type, 91 u32 attr, int channel, long *val) 92 { 93 struct lm75_data *data = dev_get_drvdata(dev); 94 unsigned int regval; 95 int err, reg; 96 97 switch (type) { 98 case hwmon_chip: 99 switch (attr) { 100 case hwmon_chip_update_interval: 101 *val = data->sample_time; 102 break;; 103 default: 104 return -EINVAL; 105 } 106 break; 107 case hwmon_temp: 108 switch (attr) { 109 case hwmon_temp_input: 110 reg = LM75_REG_TEMP; 111 break; 112 case hwmon_temp_max: 113 reg = LM75_REG_MAX; 114 break; 115 case hwmon_temp_max_hyst: 116 reg = LM75_REG_HYST; 117 break; 118 default: 119 return -EINVAL; 120 } 121 err = regmap_read(data->regmap, reg, ®val); 122 if (err < 0) 123 return err; 124 125 *val = lm75_reg_to_mc(regval, data->resolution); 126 break; 127 default: 128 return -EINVAL; 129 } 130 return 0; 131 } 132 133 static int lm75_write(struct device *dev, enum hwmon_sensor_types type, 134 u32 attr, int channel, long temp) 135 { 136 struct lm75_data *data = dev_get_drvdata(dev); 137 u8 resolution; 138 int reg; 139 140 if (type != hwmon_temp) 141 return -EINVAL; 142 143 switch (attr) { 144 case hwmon_temp_max: 145 reg = LM75_REG_MAX; 146 break; 147 case hwmon_temp_max_hyst: 148 reg = LM75_REG_HYST; 149 break; 150 default: 151 return -EINVAL; 152 } 153 154 /* 155 * Resolution of limit registers is assumed to be the same as the 156 * temperature input register resolution unless given explicitly. 157 */ 158 if (data->resolution_limits) 159 resolution = data->resolution_limits; 160 else 161 resolution = data->resolution; 162 163 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX); 164 temp = DIV_ROUND_CLOSEST(temp << (resolution - 8), 165 1000) << (16 - resolution); 166 167 return regmap_write(data->regmap, reg, temp); 168 } 169 170 static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type, 171 u32 attr, int channel) 172 { 173 switch (type) { 174 case hwmon_chip: 175 switch (attr) { 176 case hwmon_chip_update_interval: 177 return S_IRUGO; 178 } 179 break; 180 case hwmon_temp: 181 switch (attr) { 182 case hwmon_temp_input: 183 return S_IRUGO; 184 case hwmon_temp_max: 185 case hwmon_temp_max_hyst: 186 return S_IRUGO | S_IWUSR; 187 } 188 break; 189 default: 190 break; 191 } 192 return 0; 193 } 194 195 /*-----------------------------------------------------------------------*/ 196 197 /* device probe and removal */ 198 199 /* chip configuration */ 200 201 static const u32 lm75_chip_config[] = { 202 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL, 203 0 204 }; 205 206 static const struct hwmon_channel_info lm75_chip = { 207 .type = hwmon_chip, 208 .config = lm75_chip_config, 209 }; 210 211 static const u32 lm75_temp_config[] = { 212 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST, 213 0 214 }; 215 216 static const struct hwmon_channel_info lm75_temp = { 217 .type = hwmon_temp, 218 .config = lm75_temp_config, 219 }; 220 221 static const struct hwmon_channel_info *lm75_info[] = { 222 &lm75_chip, 223 &lm75_temp, 224 NULL 225 }; 226 227 static const struct hwmon_ops lm75_hwmon_ops = { 228 .is_visible = lm75_is_visible, 229 .read = lm75_read, 230 .write = lm75_write, 231 }; 232 233 static const struct hwmon_chip_info lm75_chip_info = { 234 .ops = &lm75_hwmon_ops, 235 .info = lm75_info, 236 }; 237 238 static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg) 239 { 240 return reg != LM75_REG_TEMP; 241 } 242 243 static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg) 244 { 245 return reg == LM75_REG_TEMP; 246 } 247 248 static const struct regmap_config lm75_regmap_config = { 249 .reg_bits = 8, 250 .val_bits = 16, 251 .max_register = LM75_REG_MAX, 252 .writeable_reg = lm75_is_writeable_reg, 253 .volatile_reg = lm75_is_volatile_reg, 254 .val_format_endian = REGMAP_ENDIAN_BIG, 255 .cache_type = REGCACHE_RBTREE, 256 .use_single_rw = true, 257 }; 258 259 static void lm75_remove(void *data) 260 { 261 struct lm75_data *lm75 = data; 262 struct i2c_client *client = lm75->client; 263 264 i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf); 265 } 266 267 static int 268 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) 269 { 270 struct device *dev = &client->dev; 271 struct device *hwmon_dev; 272 struct lm75_data *data; 273 int status, err; 274 u8 set_mask, clr_mask; 275 int new; 276 enum lm75_type kind = id->driver_data; 277 278 if (!i2c_check_functionality(client->adapter, 279 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 280 return -EIO; 281 282 data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL); 283 if (!data) 284 return -ENOMEM; 285 286 data->client = client; 287 288 data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config); 289 if (IS_ERR(data->regmap)) 290 return PTR_ERR(data->regmap); 291 292 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 293 * Then tweak to be more precise when appropriate. 294 */ 295 set_mask = 0; 296 clr_mask = LM75_SHUTDOWN; /* continuous conversions */ 297 298 switch (kind) { 299 case adt75: 300 clr_mask |= 1 << 5; /* not one-shot mode */ 301 data->resolution = 12; 302 data->sample_time = MSEC_PER_SEC / 8; 303 break; 304 case ds1775: 305 case ds75: 306 case stds75: 307 clr_mask |= 3 << 5; 308 set_mask |= 2 << 5; /* 11-bit mode */ 309 data->resolution = 11; 310 data->sample_time = MSEC_PER_SEC; 311 break; 312 case ds7505: 313 set_mask |= 3 << 5; /* 12-bit mode */ 314 data->resolution = 12; 315 data->sample_time = MSEC_PER_SEC / 4; 316 break; 317 case g751: 318 case lm75: 319 case lm75a: 320 data->resolution = 9; 321 data->sample_time = MSEC_PER_SEC / 2; 322 break; 323 case lm75b: 324 data->resolution = 11; 325 data->sample_time = MSEC_PER_SEC / 4; 326 break; 327 case max6625: 328 data->resolution = 9; 329 data->sample_time = MSEC_PER_SEC / 4; 330 break; 331 case max6626: 332 data->resolution = 12; 333 data->resolution_limits = 9; 334 data->sample_time = MSEC_PER_SEC / 4; 335 break; 336 case tcn75: 337 data->resolution = 9; 338 data->sample_time = MSEC_PER_SEC / 8; 339 break; 340 case mcp980x: 341 data->resolution_limits = 9; 342 /* fall through */ 343 case tmp100: 344 case tmp101: 345 set_mask |= 3 << 5; /* 12-bit mode */ 346 data->resolution = 12; 347 data->sample_time = MSEC_PER_SEC; 348 clr_mask |= 1 << 7; /* not one-shot mode */ 349 break; 350 case tmp112: 351 set_mask |= 3 << 5; /* 12-bit mode */ 352 clr_mask |= 1 << 7; /* not one-shot mode */ 353 data->resolution = 12; 354 data->sample_time = MSEC_PER_SEC / 4; 355 break; 356 case tmp105: 357 case tmp175: 358 case tmp275: 359 case tmp75: 360 set_mask |= 3 << 5; /* 12-bit mode */ 361 clr_mask |= 1 << 7; /* not one-shot mode */ 362 data->resolution = 12; 363 data->sample_time = MSEC_PER_SEC / 2; 364 break; 365 case tmp75c: 366 clr_mask |= 1 << 5; /* not one-shot mode */ 367 data->resolution = 12; 368 data->sample_time = MSEC_PER_SEC / 4; 369 break; 370 } 371 372 /* configure as specified */ 373 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 374 if (status < 0) { 375 dev_dbg(dev, "Can't read config? %d\n", status); 376 return status; 377 } 378 data->orig_conf = status; 379 new = status & ~clr_mask; 380 new |= set_mask; 381 if (status != new) 382 i2c_smbus_write_byte_data(client, LM75_REG_CONF, new); 383 384 err = devm_add_action_or_reset(dev, lm75_remove, data); 385 if (err) 386 return err; 387 388 dev_dbg(dev, "Config %02x\n", new); 389 390 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 391 data, &lm75_chip_info, 392 NULL); 393 if (IS_ERR(hwmon_dev)) 394 return PTR_ERR(hwmon_dev); 395 396 dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name); 397 398 return 0; 399 } 400 401 static const struct i2c_device_id lm75_ids[] = { 402 { "adt75", adt75, }, 403 { "ds1775", ds1775, }, 404 { "ds75", ds75, }, 405 { "ds7505", ds7505, }, 406 { "g751", g751, }, 407 { "lm75", lm75, }, 408 { "lm75a", lm75a, }, 409 { "lm75b", lm75b, }, 410 { "max6625", max6625, }, 411 { "max6626", max6626, }, 412 { "mcp980x", mcp980x, }, 413 { "stds75", stds75, }, 414 { "tcn75", tcn75, }, 415 { "tmp100", tmp100, }, 416 { "tmp101", tmp101, }, 417 { "tmp105", tmp105, }, 418 { "tmp112", tmp112, }, 419 { "tmp175", tmp175, }, 420 { "tmp275", tmp275, }, 421 { "tmp75", tmp75, }, 422 { "tmp75c", tmp75c, }, 423 { /* LIST END */ } 424 }; 425 MODULE_DEVICE_TABLE(i2c, lm75_ids); 426 427 #define LM75A_ID 0xA1 428 429 /* Return 0 if detection is successful, -ENODEV otherwise */ 430 static int lm75_detect(struct i2c_client *new_client, 431 struct i2c_board_info *info) 432 { 433 struct i2c_adapter *adapter = new_client->adapter; 434 int i; 435 int conf, hyst, os; 436 bool is_lm75a = 0; 437 438 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 439 I2C_FUNC_SMBUS_WORD_DATA)) 440 return -ENODEV; 441 442 /* 443 * Now, we do the remaining detection. There is no identification- 444 * dedicated register so we have to rely on several tricks: 445 * unused bits, registers cycling over 8-address boundaries, 446 * addresses 0x04-0x07 returning the last read value. 447 * The cycling+unused addresses combination is not tested, 448 * since it would significantly slow the detection down and would 449 * hardly add any value. 450 * 451 * The National Semiconductor LM75A is different than earlier 452 * LM75s. It has an ID byte of 0xaX (where X is the chip 453 * revision, with 1 being the only revision in existence) in 454 * register 7, and unused registers return 0xff rather than the 455 * last read value. 456 * 457 * Note that this function only detects the original National 458 * Semiconductor LM75 and the LM75A. Clones from other vendors 459 * aren't detected, on purpose, because they are typically never 460 * found on PC hardware. They are found on embedded designs where 461 * they can be instantiated explicitly so detection is not needed. 462 * The absence of identification registers on all these clones 463 * would make their exhaustive detection very difficult and weak, 464 * and odds are that the driver would bind to unsupported devices. 465 */ 466 467 /* Unused bits */ 468 conf = i2c_smbus_read_byte_data(new_client, 1); 469 if (conf & 0xe0) 470 return -ENODEV; 471 472 /* First check for LM75A */ 473 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { 474 /* LM75A returns 0xff on unused registers so 475 just to be sure we check for that too. */ 476 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff 477 || i2c_smbus_read_byte_data(new_client, 5) != 0xff 478 || i2c_smbus_read_byte_data(new_client, 6) != 0xff) 479 return -ENODEV; 480 is_lm75a = 1; 481 hyst = i2c_smbus_read_byte_data(new_client, 2); 482 os = i2c_smbus_read_byte_data(new_client, 3); 483 } else { /* Traditional style LM75 detection */ 484 /* Unused addresses */ 485 hyst = i2c_smbus_read_byte_data(new_client, 2); 486 if (i2c_smbus_read_byte_data(new_client, 4) != hyst 487 || i2c_smbus_read_byte_data(new_client, 5) != hyst 488 || i2c_smbus_read_byte_data(new_client, 6) != hyst 489 || i2c_smbus_read_byte_data(new_client, 7) != hyst) 490 return -ENODEV; 491 os = i2c_smbus_read_byte_data(new_client, 3); 492 if (i2c_smbus_read_byte_data(new_client, 4) != os 493 || i2c_smbus_read_byte_data(new_client, 5) != os 494 || i2c_smbus_read_byte_data(new_client, 6) != os 495 || i2c_smbus_read_byte_data(new_client, 7) != os) 496 return -ENODEV; 497 } 498 /* 499 * It is very unlikely that this is a LM75 if both 500 * hysteresis and temperature limit registers are 0. 501 */ 502 if (hyst == 0 && os == 0) 503 return -ENODEV; 504 505 /* Addresses cycling */ 506 for (i = 8; i <= 248; i += 40) { 507 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 508 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst 509 || i2c_smbus_read_byte_data(new_client, i + 3) != os) 510 return -ENODEV; 511 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) 512 != LM75A_ID) 513 return -ENODEV; 514 } 515 516 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); 517 518 return 0; 519 } 520 521 #ifdef CONFIG_PM 522 static int lm75_suspend(struct device *dev) 523 { 524 int status; 525 struct i2c_client *client = to_i2c_client(dev); 526 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 527 if (status < 0) { 528 dev_dbg(&client->dev, "Can't read config? %d\n", status); 529 return status; 530 } 531 status = status | LM75_SHUTDOWN; 532 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 533 return 0; 534 } 535 536 static int lm75_resume(struct device *dev) 537 { 538 int status; 539 struct i2c_client *client = to_i2c_client(dev); 540 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 541 if (status < 0) { 542 dev_dbg(&client->dev, "Can't read config? %d\n", status); 543 return status; 544 } 545 status = status & ~LM75_SHUTDOWN; 546 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 547 return 0; 548 } 549 550 static const struct dev_pm_ops lm75_dev_pm_ops = { 551 .suspend = lm75_suspend, 552 .resume = lm75_resume, 553 }; 554 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) 555 #else 556 #define LM75_DEV_PM_OPS NULL 557 #endif /* CONFIG_PM */ 558 559 static struct i2c_driver lm75_driver = { 560 .class = I2C_CLASS_HWMON, 561 .driver = { 562 .name = "lm75", 563 .pm = LM75_DEV_PM_OPS, 564 }, 565 .probe = lm75_probe, 566 .id_table = lm75_ids, 567 .detect = lm75_detect, 568 .address_list = normal_i2c, 569 }; 570 571 module_i2c_driver(lm75_driver); 572 573 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 574 MODULE_DESCRIPTION("LM75 driver"); 575 MODULE_LICENSE("GPL"); 576