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