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