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 mcp980x, 51 stds75, 52 tcn75, 53 tmp100, 54 tmp101, 55 tmp105, 56 tmp112, 57 tmp175, 58 tmp275, 59 tmp75, 60 tmp75c, 61 }; 62 63 /* Addresses scanned */ 64 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 65 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 66 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 12 */ 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_rw = true, 258 }; 259 260 static void lm75_remove(void *data) 261 { 262 struct lm75_data *lm75 = data; 263 struct i2c_client *client = lm75->client; 264 265 i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf); 266 } 267 268 static int 269 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) 270 { 271 struct device *dev = &client->dev; 272 struct device *hwmon_dev; 273 struct lm75_data *data; 274 int status, err; 275 u8 set_mask, clr_mask; 276 int new; 277 enum lm75_type kind; 278 279 if (client->dev.of_node) 280 kind = (enum lm75_type)of_device_get_match_data(&client->dev); 281 else 282 kind = id->driver_data; 283 284 if (!i2c_check_functionality(client->adapter, 285 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 286 return -EIO; 287 288 data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL); 289 if (!data) 290 return -ENOMEM; 291 292 data->client = client; 293 294 data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config); 295 if (IS_ERR(data->regmap)) 296 return PTR_ERR(data->regmap); 297 298 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 299 * Then tweak to be more precise when appropriate. 300 */ 301 set_mask = 0; 302 clr_mask = LM75_SHUTDOWN; /* continuous conversions */ 303 304 switch (kind) { 305 case adt75: 306 clr_mask |= 1 << 5; /* not one-shot mode */ 307 data->resolution = 12; 308 data->sample_time = MSEC_PER_SEC / 8; 309 break; 310 case ds1775: 311 case ds75: 312 case stds75: 313 clr_mask |= 3 << 5; 314 set_mask |= 2 << 5; /* 11-bit mode */ 315 data->resolution = 11; 316 data->sample_time = MSEC_PER_SEC; 317 break; 318 case ds7505: 319 set_mask |= 3 << 5; /* 12-bit mode */ 320 data->resolution = 12; 321 data->sample_time = MSEC_PER_SEC / 4; 322 break; 323 case g751: 324 case lm75: 325 case lm75a: 326 data->resolution = 9; 327 data->sample_time = MSEC_PER_SEC / 2; 328 break; 329 case lm75b: 330 data->resolution = 11; 331 data->sample_time = MSEC_PER_SEC / 4; 332 break; 333 case max6625: 334 data->resolution = 9; 335 data->sample_time = MSEC_PER_SEC / 4; 336 break; 337 case max6626: 338 data->resolution = 12; 339 data->resolution_limits = 9; 340 data->sample_time = MSEC_PER_SEC / 4; 341 break; 342 case tcn75: 343 data->resolution = 9; 344 data->sample_time = MSEC_PER_SEC / 8; 345 break; 346 case mcp980x: 347 data->resolution_limits = 9; 348 /* fall through */ 349 case tmp100: 350 case tmp101: 351 set_mask |= 3 << 5; /* 12-bit mode */ 352 data->resolution = 12; 353 data->sample_time = MSEC_PER_SEC; 354 clr_mask |= 1 << 7; /* not one-shot mode */ 355 break; 356 case tmp112: 357 set_mask |= 3 << 5; /* 12-bit mode */ 358 clr_mask |= 1 << 7; /* not one-shot mode */ 359 data->resolution = 12; 360 data->sample_time = MSEC_PER_SEC / 4; 361 break; 362 case tmp105: 363 case tmp175: 364 case tmp275: 365 case tmp75: 366 set_mask |= 3 << 5; /* 12-bit mode */ 367 clr_mask |= 1 << 7; /* not one-shot mode */ 368 data->resolution = 12; 369 data->sample_time = MSEC_PER_SEC / 2; 370 break; 371 case tmp75c: 372 clr_mask |= 1 << 5; /* not one-shot mode */ 373 data->resolution = 12; 374 data->sample_time = MSEC_PER_SEC / 4; 375 break; 376 } 377 378 /* configure as specified */ 379 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 380 if (status < 0) { 381 dev_dbg(dev, "Can't read config? %d\n", status); 382 return status; 383 } 384 data->orig_conf = status; 385 new = status & ~clr_mask; 386 new |= set_mask; 387 if (status != new) 388 i2c_smbus_write_byte_data(client, LM75_REG_CONF, new); 389 390 err = devm_add_action_or_reset(dev, lm75_remove, data); 391 if (err) 392 return err; 393 394 dev_dbg(dev, "Config %02x\n", new); 395 396 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 397 data, &lm75_chip_info, 398 NULL); 399 if (IS_ERR(hwmon_dev)) 400 return PTR_ERR(hwmon_dev); 401 402 dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name); 403 404 return 0; 405 } 406 407 static const struct i2c_device_id lm75_ids[] = { 408 { "adt75", adt75, }, 409 { "ds1775", ds1775, }, 410 { "ds75", ds75, }, 411 { "ds7505", ds7505, }, 412 { "g751", g751, }, 413 { "lm75", lm75, }, 414 { "lm75a", lm75a, }, 415 { "lm75b", lm75b, }, 416 { "max6625", max6625, }, 417 { "max6626", max6626, }, 418 { "mcp980x", mcp980x, }, 419 { "stds75", stds75, }, 420 { "tcn75", tcn75, }, 421 { "tmp100", tmp100, }, 422 { "tmp101", tmp101, }, 423 { "tmp105", tmp105, }, 424 { "tmp112", tmp112, }, 425 { "tmp175", tmp175, }, 426 { "tmp275", tmp275, }, 427 { "tmp75", tmp75, }, 428 { "tmp75c", tmp75c, }, 429 { /* LIST END */ } 430 }; 431 MODULE_DEVICE_TABLE(i2c, lm75_ids); 432 433 static const struct of_device_id lm75_of_match[] = { 434 { 435 .compatible = "adi,adt75", 436 .data = (void *)adt75 437 }, 438 { 439 .compatible = "dallas,ds1775", 440 .data = (void *)ds1775 441 }, 442 { 443 .compatible = "dallas,ds75", 444 .data = (void *)ds75 445 }, 446 { 447 .compatible = "dallas,ds7505", 448 .data = (void *)ds7505 449 }, 450 { 451 .compatible = "gmt,g751", 452 .data = (void *)g751 453 }, 454 { 455 .compatible = "national,lm75", 456 .data = (void *)lm75 457 }, 458 { 459 .compatible = "national,lm75a", 460 .data = (void *)lm75a 461 }, 462 { 463 .compatible = "national,lm75b", 464 .data = (void *)lm75b 465 }, 466 { 467 .compatible = "maxim,max6625", 468 .data = (void *)max6625 469 }, 470 { 471 .compatible = "maxim,max6626", 472 .data = (void *)max6626 473 }, 474 { 475 .compatible = "maxim,mcp980x", 476 .data = (void *)mcp980x 477 }, 478 { 479 .compatible = "st,stds75", 480 .data = (void *)stds75 481 }, 482 { 483 .compatible = "microchip,tcn75", 484 .data = (void *)tcn75 485 }, 486 { 487 .compatible = "ti,tmp100", 488 .data = (void *)tmp100 489 }, 490 { 491 .compatible = "ti,tmp101", 492 .data = (void *)tmp101 493 }, 494 { 495 .compatible = "ti,tmp105", 496 .data = (void *)tmp105 497 }, 498 { 499 .compatible = "ti,tmp112", 500 .data = (void *)tmp112 501 }, 502 { 503 .compatible = "ti,tmp175", 504 .data = (void *)tmp175 505 }, 506 { 507 .compatible = "ti,tmp275", 508 .data = (void *)tmp275 509 }, 510 { 511 .compatible = "ti,tmp75", 512 .data = (void *)tmp75 513 }, 514 { 515 .compatible = "ti,tmp75c", 516 .data = (void *)tmp75c 517 }, 518 { }, 519 }; 520 MODULE_DEVICE_TABLE(of, lm75_of_match); 521 522 #define LM75A_ID 0xA1 523 524 /* Return 0 if detection is successful, -ENODEV otherwise */ 525 static int lm75_detect(struct i2c_client *new_client, 526 struct i2c_board_info *info) 527 { 528 struct i2c_adapter *adapter = new_client->adapter; 529 int i; 530 int conf, hyst, os; 531 bool is_lm75a = 0; 532 533 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 534 I2C_FUNC_SMBUS_WORD_DATA)) 535 return -ENODEV; 536 537 /* 538 * Now, we do the remaining detection. There is no identification- 539 * dedicated register so we have to rely on several tricks: 540 * unused bits, registers cycling over 8-address boundaries, 541 * addresses 0x04-0x07 returning the last read value. 542 * The cycling+unused addresses combination is not tested, 543 * since it would significantly slow the detection down and would 544 * hardly add any value. 545 * 546 * The National Semiconductor LM75A is different than earlier 547 * LM75s. It has an ID byte of 0xaX (where X is the chip 548 * revision, with 1 being the only revision in existence) in 549 * register 7, and unused registers return 0xff rather than the 550 * last read value. 551 * 552 * Note that this function only detects the original National 553 * Semiconductor LM75 and the LM75A. Clones from other vendors 554 * aren't detected, on purpose, because they are typically never 555 * found on PC hardware. They are found on embedded designs where 556 * they can be instantiated explicitly so detection is not needed. 557 * The absence of identification registers on all these clones 558 * would make their exhaustive detection very difficult and weak, 559 * and odds are that the driver would bind to unsupported devices. 560 */ 561 562 /* Unused bits */ 563 conf = i2c_smbus_read_byte_data(new_client, 1); 564 if (conf & 0xe0) 565 return -ENODEV; 566 567 /* First check for LM75A */ 568 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { 569 /* LM75A returns 0xff on unused registers so 570 just to be sure we check for that too. */ 571 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff 572 || i2c_smbus_read_byte_data(new_client, 5) != 0xff 573 || i2c_smbus_read_byte_data(new_client, 6) != 0xff) 574 return -ENODEV; 575 is_lm75a = 1; 576 hyst = i2c_smbus_read_byte_data(new_client, 2); 577 os = i2c_smbus_read_byte_data(new_client, 3); 578 } else { /* Traditional style LM75 detection */ 579 /* Unused addresses */ 580 hyst = i2c_smbus_read_byte_data(new_client, 2); 581 if (i2c_smbus_read_byte_data(new_client, 4) != hyst 582 || i2c_smbus_read_byte_data(new_client, 5) != hyst 583 || i2c_smbus_read_byte_data(new_client, 6) != hyst 584 || i2c_smbus_read_byte_data(new_client, 7) != hyst) 585 return -ENODEV; 586 os = i2c_smbus_read_byte_data(new_client, 3); 587 if (i2c_smbus_read_byte_data(new_client, 4) != os 588 || i2c_smbus_read_byte_data(new_client, 5) != os 589 || i2c_smbus_read_byte_data(new_client, 6) != os 590 || i2c_smbus_read_byte_data(new_client, 7) != os) 591 return -ENODEV; 592 } 593 /* 594 * It is very unlikely that this is a LM75 if both 595 * hysteresis and temperature limit registers are 0. 596 */ 597 if (hyst == 0 && os == 0) 598 return -ENODEV; 599 600 /* Addresses cycling */ 601 for (i = 8; i <= 248; i += 40) { 602 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 603 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst 604 || i2c_smbus_read_byte_data(new_client, i + 3) != os) 605 return -ENODEV; 606 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) 607 != LM75A_ID) 608 return -ENODEV; 609 } 610 611 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); 612 613 return 0; 614 } 615 616 #ifdef CONFIG_PM 617 static int lm75_suspend(struct device *dev) 618 { 619 int status; 620 struct i2c_client *client = to_i2c_client(dev); 621 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 622 if (status < 0) { 623 dev_dbg(&client->dev, "Can't read config? %d\n", status); 624 return status; 625 } 626 status = status | LM75_SHUTDOWN; 627 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 628 return 0; 629 } 630 631 static int lm75_resume(struct device *dev) 632 { 633 int status; 634 struct i2c_client *client = to_i2c_client(dev); 635 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 636 if (status < 0) { 637 dev_dbg(&client->dev, "Can't read config? %d\n", status); 638 return status; 639 } 640 status = status & ~LM75_SHUTDOWN; 641 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 642 return 0; 643 } 644 645 static const struct dev_pm_ops lm75_dev_pm_ops = { 646 .suspend = lm75_suspend, 647 .resume = lm75_resume, 648 }; 649 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) 650 #else 651 #define LM75_DEV_PM_OPS NULL 652 #endif /* CONFIG_PM */ 653 654 static struct i2c_driver lm75_driver = { 655 .class = I2C_CLASS_HWMON, 656 .driver = { 657 .name = "lm75", 658 .of_match_table = of_match_ptr(lm75_of_match), 659 .pm = LM75_DEV_PM_OPS, 660 }, 661 .probe = lm75_probe, 662 .id_table = lm75_ids, 663 .detect = lm75_detect, 664 .address_list = normal_i2c, 665 }; 666 667 module_i2c_driver(lm75_driver); 668 669 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 670 MODULE_DESCRIPTION("LM75 driver"); 671 MODULE_LICENSE("GPL"); 672