1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring 5 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 6 */ 7 8 #include <linux/module.h> 9 #include <linux/init.h> 10 #include <linux/slab.h> 11 #include <linux/jiffies.h> 12 #include <linux/i2c.h> 13 #include <linux/hwmon.h> 14 #include <linux/hwmon-sysfs.h> 15 #include <linux/err.h> 16 #include <linux/of_device.h> 17 #include <linux/of.h> 18 #include <linux/regmap.h> 19 #include <linux/util_macros.h> 20 #include <linux/regulator/consumer.h> 21 #include "lm75.h" 22 23 /* 24 * This driver handles the LM75 and compatible digital temperature sensors. 25 */ 26 27 enum lm75_type { /* keep sorted in alphabetical order */ 28 adt75, 29 ds1775, 30 ds75, 31 ds7505, 32 g751, 33 lm75, 34 lm75a, 35 lm75b, 36 max6625, 37 max6626, 38 max31725, 39 mcp980x, 40 pct2075, 41 stds75, 42 stlm75, 43 tcn75, 44 tmp100, 45 tmp101, 46 tmp105, 47 tmp112, 48 tmp175, 49 tmp275, 50 tmp75, 51 tmp75b, 52 tmp75c, 53 }; 54 55 /** 56 * struct lm75_params - lm75 configuration parameters. 57 * @set_mask: Bits to set in configuration register when configuring 58 * the chip. 59 * @clr_mask: Bits to clear in configuration register when configuring 60 * the chip. 61 * @default_resolution: Default number of bits to represent the temperature 62 * value. 63 * @resolution_limits: Limit register resolution. Optional. Should be set if 64 * the resolution of limit registers does not match the 65 * resolution of the temperature register. 66 * @resolutions: List of resolutions associated with sample times. 67 * Optional. Should be set if num_sample_times is larger 68 * than 1, and if the resolution changes with sample times. 69 * If set, number of entries must match num_sample_times. 70 * @default_sample_time:Sample time to be set by default. 71 * @num_sample_times: Number of possible sample times to be set. Optional. 72 * Should be set if the number of sample times is larger 73 * than one. 74 * @sample_times: All the possible sample times to be set. Mandatory if 75 * num_sample_times is larger than 1. If set, number of 76 * entries must match num_sample_times. 77 */ 78 79 struct lm75_params { 80 u8 set_mask; 81 u8 clr_mask; 82 u8 default_resolution; 83 u8 resolution_limits; 84 const u8 *resolutions; 85 unsigned int default_sample_time; 86 u8 num_sample_times; 87 const unsigned int *sample_times; 88 }; 89 90 /* Addresses scanned */ 91 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 92 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 93 94 /* The LM75 registers */ 95 #define LM75_REG_TEMP 0x00 96 #define LM75_REG_CONF 0x01 97 #define LM75_REG_HYST 0x02 98 #define LM75_REG_MAX 0x03 99 #define PCT2075_REG_IDLE 0x04 100 101 /* Each client has this additional data */ 102 struct lm75_data { 103 struct i2c_client *client; 104 struct regmap *regmap; 105 struct regulator *vs; 106 u8 orig_conf; 107 u8 current_conf; 108 u8 resolution; /* In bits, 9 to 16 */ 109 unsigned int sample_time; /* In ms */ 110 enum lm75_type kind; 111 const struct lm75_params *params; 112 }; 113 114 /*-----------------------------------------------------------------------*/ 115 116 static const u8 lm75_sample_set_masks[] = { 0 << 5, 1 << 5, 2 << 5, 3 << 5 }; 117 118 #define LM75_SAMPLE_CLEAR_MASK (3 << 5) 119 120 /* The structure below stores the configuration values of the supported devices. 121 * In case of being supported multiple configurations, the default one must 122 * always be the first element of the array 123 */ 124 static const struct lm75_params device_params[] = { 125 [adt75] = { 126 .clr_mask = 1 << 5, /* not one-shot mode */ 127 .default_resolution = 12, 128 .default_sample_time = MSEC_PER_SEC / 10, 129 }, 130 [ds1775] = { 131 .clr_mask = 3 << 5, 132 .set_mask = 2 << 5, /* 11-bit mode */ 133 .default_resolution = 11, 134 .default_sample_time = 500, 135 .num_sample_times = 4, 136 .sample_times = (unsigned int []){ 125, 250, 500, 1000 }, 137 .resolutions = (u8 []) {9, 10, 11, 12 }, 138 }, 139 [ds75] = { 140 .clr_mask = 3 << 5, 141 .set_mask = 2 << 5, /* 11-bit mode */ 142 .default_resolution = 11, 143 .default_sample_time = 600, 144 .num_sample_times = 4, 145 .sample_times = (unsigned int []){ 150, 300, 600, 1200 }, 146 .resolutions = (u8 []) {9, 10, 11, 12 }, 147 }, 148 [stds75] = { 149 .clr_mask = 3 << 5, 150 .set_mask = 2 << 5, /* 11-bit mode */ 151 .default_resolution = 11, 152 .default_sample_time = 600, 153 .num_sample_times = 4, 154 .sample_times = (unsigned int []){ 150, 300, 600, 1200 }, 155 .resolutions = (u8 []) {9, 10, 11, 12 }, 156 }, 157 [stlm75] = { 158 .default_resolution = 9, 159 .default_sample_time = MSEC_PER_SEC / 6, 160 }, 161 [ds7505] = { 162 .set_mask = 3 << 5, /* 12-bit mode*/ 163 .default_resolution = 12, 164 .default_sample_time = 200, 165 .num_sample_times = 4, 166 .sample_times = (unsigned int []){ 25, 50, 100, 200 }, 167 .resolutions = (u8 []) {9, 10, 11, 12 }, 168 }, 169 [g751] = { 170 .default_resolution = 9, 171 .default_sample_time = MSEC_PER_SEC / 10, 172 }, 173 [lm75] = { 174 .default_resolution = 9, 175 .default_sample_time = MSEC_PER_SEC / 10, 176 }, 177 [lm75a] = { 178 .default_resolution = 9, 179 .default_sample_time = MSEC_PER_SEC / 10, 180 }, 181 [lm75b] = { 182 .default_resolution = 11, 183 .default_sample_time = MSEC_PER_SEC / 10, 184 }, 185 [max6625] = { 186 .default_resolution = 9, 187 .default_sample_time = MSEC_PER_SEC / 7, 188 }, 189 [max6626] = { 190 .default_resolution = 12, 191 .default_sample_time = MSEC_PER_SEC / 7, 192 .resolution_limits = 9, 193 }, 194 [max31725] = { 195 .default_resolution = 16, 196 .default_sample_time = MSEC_PER_SEC / 20, 197 }, 198 [tcn75] = { 199 .default_resolution = 9, 200 .default_sample_time = MSEC_PER_SEC / 18, 201 }, 202 [pct2075] = { 203 .default_resolution = 11, 204 .default_sample_time = MSEC_PER_SEC / 10, 205 .num_sample_times = 31, 206 .sample_times = (unsigned int []){ 100, 200, 300, 400, 500, 600, 207 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 208 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700, 209 2800, 2900, 3000, 3100 }, 210 }, 211 [mcp980x] = { 212 .set_mask = 3 << 5, /* 12-bit mode */ 213 .clr_mask = 1 << 7, /* not one-shot mode */ 214 .default_resolution = 12, 215 .resolution_limits = 9, 216 .default_sample_time = 240, 217 .num_sample_times = 4, 218 .sample_times = (unsigned int []){ 30, 60, 120, 240 }, 219 .resolutions = (u8 []) {9, 10, 11, 12 }, 220 }, 221 [tmp100] = { 222 .set_mask = 3 << 5, /* 12-bit mode */ 223 .clr_mask = 1 << 7, /* not one-shot mode */ 224 .default_resolution = 12, 225 .default_sample_time = 320, 226 .num_sample_times = 4, 227 .sample_times = (unsigned int []){ 40, 80, 160, 320 }, 228 .resolutions = (u8 []) {9, 10, 11, 12 }, 229 }, 230 [tmp101] = { 231 .set_mask = 3 << 5, /* 12-bit mode */ 232 .clr_mask = 1 << 7, /* not one-shot mode */ 233 .default_resolution = 12, 234 .default_sample_time = 320, 235 .num_sample_times = 4, 236 .sample_times = (unsigned int []){ 40, 80, 160, 320 }, 237 .resolutions = (u8 []) {9, 10, 11, 12 }, 238 }, 239 [tmp105] = { 240 .set_mask = 3 << 5, /* 12-bit mode */ 241 .clr_mask = 1 << 7, /* not one-shot mode*/ 242 .default_resolution = 12, 243 .default_sample_time = 220, 244 .num_sample_times = 4, 245 .sample_times = (unsigned int []){ 28, 55, 110, 220 }, 246 .resolutions = (u8 []) {9, 10, 11, 12 }, 247 }, 248 [tmp112] = { 249 .set_mask = 3 << 5, /* 8 samples / second */ 250 .clr_mask = 1 << 7, /* no one-shot mode*/ 251 .default_resolution = 12, 252 .default_sample_time = 125, 253 .num_sample_times = 4, 254 .sample_times = (unsigned int []){ 125, 250, 1000, 4000 }, 255 }, 256 [tmp175] = { 257 .set_mask = 3 << 5, /* 12-bit mode */ 258 .clr_mask = 1 << 7, /* not one-shot mode*/ 259 .default_resolution = 12, 260 .default_sample_time = 220, 261 .num_sample_times = 4, 262 .sample_times = (unsigned int []){ 28, 55, 110, 220 }, 263 .resolutions = (u8 []) {9, 10, 11, 12 }, 264 }, 265 [tmp275] = { 266 .set_mask = 3 << 5, /* 12-bit mode */ 267 .clr_mask = 1 << 7, /* not one-shot mode*/ 268 .default_resolution = 12, 269 .default_sample_time = 220, 270 .num_sample_times = 4, 271 .sample_times = (unsigned int []){ 28, 55, 110, 220 }, 272 .resolutions = (u8 []) {9, 10, 11, 12 }, 273 }, 274 [tmp75] = { 275 .set_mask = 3 << 5, /* 12-bit mode */ 276 .clr_mask = 1 << 7, /* not one-shot mode*/ 277 .default_resolution = 12, 278 .default_sample_time = 220, 279 .num_sample_times = 4, 280 .sample_times = (unsigned int []){ 28, 55, 110, 220 }, 281 .resolutions = (u8 []) {9, 10, 11, 12 }, 282 }, 283 [tmp75b] = { /* not one-shot mode, Conversion rate 37Hz */ 284 .clr_mask = 1 << 7 | 3 << 5, 285 .default_resolution = 12, 286 .default_sample_time = MSEC_PER_SEC / 37, 287 .sample_times = (unsigned int []){ MSEC_PER_SEC / 37, 288 MSEC_PER_SEC / 18, 289 MSEC_PER_SEC / 9, MSEC_PER_SEC / 4 }, 290 .num_sample_times = 4, 291 }, 292 [tmp75c] = { 293 .clr_mask = 1 << 5, /*not one-shot mode*/ 294 .default_resolution = 12, 295 .default_sample_time = MSEC_PER_SEC / 12, 296 } 297 }; 298 299 static inline long lm75_reg_to_mc(s16 temp, u8 resolution) 300 { 301 return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8); 302 } 303 304 static int lm75_write_config(struct lm75_data *data, u8 set_mask, 305 u8 clr_mask) 306 { 307 u8 value; 308 309 clr_mask |= LM75_SHUTDOWN; 310 value = data->current_conf & ~clr_mask; 311 value |= set_mask; 312 313 if (data->current_conf != value) { 314 s32 err; 315 316 err = i2c_smbus_write_byte_data(data->client, LM75_REG_CONF, 317 value); 318 if (err) 319 return err; 320 data->current_conf = value; 321 } 322 return 0; 323 } 324 325 static int lm75_read(struct device *dev, enum hwmon_sensor_types type, 326 u32 attr, int channel, long *val) 327 { 328 struct lm75_data *data = dev_get_drvdata(dev); 329 unsigned int regval; 330 int err, reg; 331 332 switch (type) { 333 case hwmon_chip: 334 switch (attr) { 335 case hwmon_chip_update_interval: 336 *val = data->sample_time; 337 break; 338 default: 339 return -EINVAL; 340 } 341 break; 342 case hwmon_temp: 343 switch (attr) { 344 case hwmon_temp_input: 345 reg = LM75_REG_TEMP; 346 break; 347 case hwmon_temp_max: 348 reg = LM75_REG_MAX; 349 break; 350 case hwmon_temp_max_hyst: 351 reg = LM75_REG_HYST; 352 break; 353 default: 354 return -EINVAL; 355 } 356 err = regmap_read(data->regmap, reg, ®val); 357 if (err < 0) 358 return err; 359 360 *val = lm75_reg_to_mc(regval, data->resolution); 361 break; 362 default: 363 return -EINVAL; 364 } 365 return 0; 366 } 367 368 static int lm75_write_temp(struct device *dev, u32 attr, long temp) 369 { 370 struct lm75_data *data = dev_get_drvdata(dev); 371 u8 resolution; 372 int reg; 373 374 switch (attr) { 375 case hwmon_temp_max: 376 reg = LM75_REG_MAX; 377 break; 378 case hwmon_temp_max_hyst: 379 reg = LM75_REG_HYST; 380 break; 381 default: 382 return -EINVAL; 383 } 384 385 /* 386 * Resolution of limit registers is assumed to be the same as the 387 * temperature input register resolution unless given explicitly. 388 */ 389 if (data->params->resolution_limits) 390 resolution = data->params->resolution_limits; 391 else 392 resolution = data->resolution; 393 394 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX); 395 temp = DIV_ROUND_CLOSEST(temp << (resolution - 8), 396 1000) << (16 - resolution); 397 398 return regmap_write(data->regmap, reg, (u16)temp); 399 } 400 401 static int lm75_update_interval(struct device *dev, long val) 402 { 403 struct lm75_data *data = dev_get_drvdata(dev); 404 unsigned int reg; 405 u8 index; 406 s32 err; 407 408 index = find_closest(val, data->params->sample_times, 409 (int)data->params->num_sample_times); 410 411 switch (data->kind) { 412 default: 413 err = lm75_write_config(data, lm75_sample_set_masks[index], 414 LM75_SAMPLE_CLEAR_MASK); 415 if (err) 416 return err; 417 418 data->sample_time = data->params->sample_times[index]; 419 if (data->params->resolutions) 420 data->resolution = data->params->resolutions[index]; 421 break; 422 case tmp112: 423 err = regmap_read(data->regmap, LM75_REG_CONF, ®); 424 if (err < 0) 425 return err; 426 reg &= ~0x00c0; 427 reg |= (3 - index) << 6; 428 err = regmap_write(data->regmap, LM75_REG_CONF, reg); 429 if (err < 0) 430 return err; 431 data->sample_time = data->params->sample_times[index]; 432 break; 433 case pct2075: 434 err = i2c_smbus_write_byte_data(data->client, PCT2075_REG_IDLE, 435 index + 1); 436 if (err) 437 return err; 438 data->sample_time = data->params->sample_times[index]; 439 break; 440 } 441 return 0; 442 } 443 444 static int lm75_write_chip(struct device *dev, u32 attr, long val) 445 { 446 switch (attr) { 447 case hwmon_chip_update_interval: 448 return lm75_update_interval(dev, val); 449 default: 450 return -EINVAL; 451 } 452 return 0; 453 } 454 455 static int lm75_write(struct device *dev, enum hwmon_sensor_types type, 456 u32 attr, int channel, long val) 457 { 458 switch (type) { 459 case hwmon_chip: 460 return lm75_write_chip(dev, attr, val); 461 case hwmon_temp: 462 return lm75_write_temp(dev, attr, val); 463 default: 464 return -EINVAL; 465 } 466 return 0; 467 } 468 469 static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type, 470 u32 attr, int channel) 471 { 472 const struct lm75_data *config_data = data; 473 474 switch (type) { 475 case hwmon_chip: 476 switch (attr) { 477 case hwmon_chip_update_interval: 478 if (config_data->params->num_sample_times > 1) 479 return 0644; 480 return 0444; 481 } 482 break; 483 case hwmon_temp: 484 switch (attr) { 485 case hwmon_temp_input: 486 return 0444; 487 case hwmon_temp_max: 488 case hwmon_temp_max_hyst: 489 return 0644; 490 } 491 break; 492 default: 493 break; 494 } 495 return 0; 496 } 497 498 static const struct hwmon_channel_info *lm75_info[] = { 499 HWMON_CHANNEL_INFO(chip, 500 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL), 501 HWMON_CHANNEL_INFO(temp, 502 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST), 503 NULL 504 }; 505 506 static const struct hwmon_ops lm75_hwmon_ops = { 507 .is_visible = lm75_is_visible, 508 .read = lm75_read, 509 .write = lm75_write, 510 }; 511 512 static const struct hwmon_chip_info lm75_chip_info = { 513 .ops = &lm75_hwmon_ops, 514 .info = lm75_info, 515 }; 516 517 static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg) 518 { 519 return reg != LM75_REG_TEMP; 520 } 521 522 static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg) 523 { 524 return reg == LM75_REG_TEMP || reg == LM75_REG_CONF; 525 } 526 527 static const struct regmap_config lm75_regmap_config = { 528 .reg_bits = 8, 529 .val_bits = 16, 530 .max_register = PCT2075_REG_IDLE, 531 .writeable_reg = lm75_is_writeable_reg, 532 .volatile_reg = lm75_is_volatile_reg, 533 .val_format_endian = REGMAP_ENDIAN_BIG, 534 .cache_type = REGCACHE_RBTREE, 535 .use_single_read = true, 536 .use_single_write = true, 537 }; 538 539 static void lm75_disable_regulator(void *data) 540 { 541 struct lm75_data *lm75 = data; 542 543 regulator_disable(lm75->vs); 544 } 545 546 static void lm75_remove(void *data) 547 { 548 struct lm75_data *lm75 = data; 549 struct i2c_client *client = lm75->client; 550 551 i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf); 552 } 553 554 static const struct i2c_device_id lm75_ids[]; 555 556 static int lm75_probe(struct i2c_client *client) 557 { 558 struct device *dev = &client->dev; 559 struct device *hwmon_dev; 560 struct lm75_data *data; 561 int status, err; 562 enum lm75_type kind; 563 564 if (client->dev.of_node) 565 kind = (enum lm75_type)of_device_get_match_data(&client->dev); 566 else 567 kind = i2c_match_id(lm75_ids, client)->driver_data; 568 569 if (!i2c_check_functionality(client->adapter, 570 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 571 return -EIO; 572 573 data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL); 574 if (!data) 575 return -ENOMEM; 576 577 data->client = client; 578 data->kind = kind; 579 580 data->vs = devm_regulator_get(dev, "vs"); 581 if (IS_ERR(data->vs)) 582 return PTR_ERR(data->vs); 583 584 data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config); 585 if (IS_ERR(data->regmap)) 586 return PTR_ERR(data->regmap); 587 588 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 589 * Then tweak to be more precise when appropriate. 590 */ 591 592 data->params = &device_params[data->kind]; 593 594 /* Save default sample time and resolution*/ 595 data->sample_time = data->params->default_sample_time; 596 data->resolution = data->params->default_resolution; 597 598 /* Enable the power */ 599 err = regulator_enable(data->vs); 600 if (err) { 601 dev_err(dev, "failed to enable regulator: %d\n", err); 602 return err; 603 } 604 605 err = devm_add_action_or_reset(dev, lm75_disable_regulator, data); 606 if (err) 607 return err; 608 609 /* Cache original configuration */ 610 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 611 if (status < 0) { 612 dev_dbg(dev, "Can't read config? %d\n", status); 613 return status; 614 } 615 data->orig_conf = status; 616 data->current_conf = status; 617 618 err = lm75_write_config(data, data->params->set_mask, 619 data->params->clr_mask); 620 if (err) 621 return err; 622 623 err = devm_add_action_or_reset(dev, lm75_remove, data); 624 if (err) 625 return err; 626 627 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 628 data, &lm75_chip_info, 629 NULL); 630 if (IS_ERR(hwmon_dev)) 631 return PTR_ERR(hwmon_dev); 632 633 dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name); 634 635 return 0; 636 } 637 638 static const struct i2c_device_id lm75_ids[] = { 639 { "adt75", adt75, }, 640 { "ds1775", ds1775, }, 641 { "ds75", ds75, }, 642 { "ds7505", ds7505, }, 643 { "g751", g751, }, 644 { "lm75", lm75, }, 645 { "lm75a", lm75a, }, 646 { "lm75b", lm75b, }, 647 { "max6625", max6625, }, 648 { "max6626", max6626, }, 649 { "max31725", max31725, }, 650 { "max31726", max31725, }, 651 { "mcp980x", mcp980x, }, 652 { "pct2075", pct2075, }, 653 { "stds75", stds75, }, 654 { "stlm75", stlm75, }, 655 { "tcn75", tcn75, }, 656 { "tmp100", tmp100, }, 657 { "tmp101", tmp101, }, 658 { "tmp105", tmp105, }, 659 { "tmp112", tmp112, }, 660 { "tmp175", tmp175, }, 661 { "tmp275", tmp275, }, 662 { "tmp75", tmp75, }, 663 { "tmp75b", tmp75b, }, 664 { "tmp75c", tmp75c, }, 665 { /* LIST END */ } 666 }; 667 MODULE_DEVICE_TABLE(i2c, lm75_ids); 668 669 static const struct of_device_id __maybe_unused lm75_of_match[] = { 670 { 671 .compatible = "adi,adt75", 672 .data = (void *)adt75 673 }, 674 { 675 .compatible = "dallas,ds1775", 676 .data = (void *)ds1775 677 }, 678 { 679 .compatible = "dallas,ds75", 680 .data = (void *)ds75 681 }, 682 { 683 .compatible = "dallas,ds7505", 684 .data = (void *)ds7505 685 }, 686 { 687 .compatible = "gmt,g751", 688 .data = (void *)g751 689 }, 690 { 691 .compatible = "national,lm75", 692 .data = (void *)lm75 693 }, 694 { 695 .compatible = "national,lm75a", 696 .data = (void *)lm75a 697 }, 698 { 699 .compatible = "national,lm75b", 700 .data = (void *)lm75b 701 }, 702 { 703 .compatible = "maxim,max6625", 704 .data = (void *)max6625 705 }, 706 { 707 .compatible = "maxim,max6626", 708 .data = (void *)max6626 709 }, 710 { 711 .compatible = "maxim,max31725", 712 .data = (void *)max31725 713 }, 714 { 715 .compatible = "maxim,max31726", 716 .data = (void *)max31725 717 }, 718 { 719 .compatible = "maxim,mcp980x", 720 .data = (void *)mcp980x 721 }, 722 { 723 .compatible = "nxp,pct2075", 724 .data = (void *)pct2075 725 }, 726 { 727 .compatible = "st,stds75", 728 .data = (void *)stds75 729 }, 730 { 731 .compatible = "st,stlm75", 732 .data = (void *)stlm75 733 }, 734 { 735 .compatible = "microchip,tcn75", 736 .data = (void *)tcn75 737 }, 738 { 739 .compatible = "ti,tmp100", 740 .data = (void *)tmp100 741 }, 742 { 743 .compatible = "ti,tmp101", 744 .data = (void *)tmp101 745 }, 746 { 747 .compatible = "ti,tmp105", 748 .data = (void *)tmp105 749 }, 750 { 751 .compatible = "ti,tmp112", 752 .data = (void *)tmp112 753 }, 754 { 755 .compatible = "ti,tmp175", 756 .data = (void *)tmp175 757 }, 758 { 759 .compatible = "ti,tmp275", 760 .data = (void *)tmp275 761 }, 762 { 763 .compatible = "ti,tmp75", 764 .data = (void *)tmp75 765 }, 766 { 767 .compatible = "ti,tmp75b", 768 .data = (void *)tmp75b 769 }, 770 { 771 .compatible = "ti,tmp75c", 772 .data = (void *)tmp75c 773 }, 774 { }, 775 }; 776 MODULE_DEVICE_TABLE(of, lm75_of_match); 777 778 #define LM75A_ID 0xA1 779 780 /* Return 0 if detection is successful, -ENODEV otherwise */ 781 static int lm75_detect(struct i2c_client *new_client, 782 struct i2c_board_info *info) 783 { 784 struct i2c_adapter *adapter = new_client->adapter; 785 int i; 786 int conf, hyst, os; 787 bool is_lm75a = 0; 788 789 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 790 I2C_FUNC_SMBUS_WORD_DATA)) 791 return -ENODEV; 792 793 /* 794 * Now, we do the remaining detection. There is no identification- 795 * dedicated register so we have to rely on several tricks: 796 * unused bits, registers cycling over 8-address boundaries, 797 * addresses 0x04-0x07 returning the last read value. 798 * The cycling+unused addresses combination is not tested, 799 * since it would significantly slow the detection down and would 800 * hardly add any value. 801 * 802 * The National Semiconductor LM75A is different than earlier 803 * LM75s. It has an ID byte of 0xaX (where X is the chip 804 * revision, with 1 being the only revision in existence) in 805 * register 7, and unused registers return 0xff rather than the 806 * last read value. 807 * 808 * Note that this function only detects the original National 809 * Semiconductor LM75 and the LM75A. Clones from other vendors 810 * aren't detected, on purpose, because they are typically never 811 * found on PC hardware. They are found on embedded designs where 812 * they can be instantiated explicitly so detection is not needed. 813 * The absence of identification registers on all these clones 814 * would make their exhaustive detection very difficult and weak, 815 * and odds are that the driver would bind to unsupported devices. 816 */ 817 818 /* Unused bits */ 819 conf = i2c_smbus_read_byte_data(new_client, 1); 820 if (conf & 0xe0) 821 return -ENODEV; 822 823 /* First check for LM75A */ 824 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) { 825 /* 826 * LM75A returns 0xff on unused registers so 827 * just to be sure we check for that too. 828 */ 829 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff 830 || i2c_smbus_read_byte_data(new_client, 5) != 0xff 831 || i2c_smbus_read_byte_data(new_client, 6) != 0xff) 832 return -ENODEV; 833 is_lm75a = 1; 834 hyst = i2c_smbus_read_byte_data(new_client, 2); 835 os = i2c_smbus_read_byte_data(new_client, 3); 836 } else { /* Traditional style LM75 detection */ 837 /* Unused addresses */ 838 hyst = i2c_smbus_read_byte_data(new_client, 2); 839 if (i2c_smbus_read_byte_data(new_client, 4) != hyst 840 || i2c_smbus_read_byte_data(new_client, 5) != hyst 841 || i2c_smbus_read_byte_data(new_client, 6) != hyst 842 || i2c_smbus_read_byte_data(new_client, 7) != hyst) 843 return -ENODEV; 844 os = i2c_smbus_read_byte_data(new_client, 3); 845 if (i2c_smbus_read_byte_data(new_client, 4) != os 846 || i2c_smbus_read_byte_data(new_client, 5) != os 847 || i2c_smbus_read_byte_data(new_client, 6) != os 848 || i2c_smbus_read_byte_data(new_client, 7) != os) 849 return -ENODEV; 850 } 851 /* 852 * It is very unlikely that this is a LM75 if both 853 * hysteresis and temperature limit registers are 0. 854 */ 855 if (hyst == 0 && os == 0) 856 return -ENODEV; 857 858 /* Addresses cycling */ 859 for (i = 8; i <= 248; i += 40) { 860 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 861 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst 862 || i2c_smbus_read_byte_data(new_client, i + 3) != os) 863 return -ENODEV; 864 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7) 865 != LM75A_ID) 866 return -ENODEV; 867 } 868 869 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE); 870 871 return 0; 872 } 873 874 #ifdef CONFIG_PM 875 static int lm75_suspend(struct device *dev) 876 { 877 int status; 878 struct i2c_client *client = to_i2c_client(dev); 879 880 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 881 if (status < 0) { 882 dev_dbg(&client->dev, "Can't read config? %d\n", status); 883 return status; 884 } 885 status = status | LM75_SHUTDOWN; 886 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 887 return 0; 888 } 889 890 static int lm75_resume(struct device *dev) 891 { 892 int status; 893 struct i2c_client *client = to_i2c_client(dev); 894 895 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF); 896 if (status < 0) { 897 dev_dbg(&client->dev, "Can't read config? %d\n", status); 898 return status; 899 } 900 status = status & ~LM75_SHUTDOWN; 901 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status); 902 return 0; 903 } 904 905 static const struct dev_pm_ops lm75_dev_pm_ops = { 906 .suspend = lm75_suspend, 907 .resume = lm75_resume, 908 }; 909 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops) 910 #else 911 #define LM75_DEV_PM_OPS NULL 912 #endif /* CONFIG_PM */ 913 914 static struct i2c_driver lm75_driver = { 915 .class = I2C_CLASS_HWMON, 916 .driver = { 917 .name = "lm75", 918 .of_match_table = of_match_ptr(lm75_of_match), 919 .pm = LM75_DEV_PM_OPS, 920 }, 921 .probe_new = lm75_probe, 922 .id_table = lm75_ids, 923 .detect = lm75_detect, 924 .address_list = normal_i2c, 925 }; 926 927 module_i2c_driver(lm75_driver); 928 929 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 930 MODULE_DESCRIPTION("LM75 driver"); 931 MODULE_LICENSE("GPL"); 932