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