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