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