1 /* 2 * Hardware monitoring driver for LTC2978 and compatible chips. 3 * 4 * Copyright (c) 2011 Ericsson AB. 5 * Copyright (c) 2013, 2014, 2015 Guenter Roeck 6 * Copyright (c) 2015 Linear Technology 7 * Copyright (c) 2018 Analog Devices Inc. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 */ 19 20 #include <linux/delay.h> 21 #include <linux/jiffies.h> 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/err.h> 26 #include <linux/slab.h> 27 #include <linux/i2c.h> 28 #include <linux/regulator/driver.h> 29 #include "pmbus.h" 30 31 enum chips { ltc2974, ltc2975, ltc2977, ltc2978, ltc2980, ltc3880, ltc3882, 32 ltc3883, ltc3886, ltc3887, ltm2987, ltm4675, ltm4676, ltm4686 }; 33 34 /* Common for all chips */ 35 #define LTC2978_MFR_VOUT_PEAK 0xdd 36 #define LTC2978_MFR_VIN_PEAK 0xde 37 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf 38 #define LTC2978_MFR_SPECIAL_ID 0xe7 /* Undocumented on LTC3882 */ 39 #define LTC2978_MFR_COMMON 0xef 40 41 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */ 42 #define LTC2978_MFR_VOUT_MIN 0xfb 43 #define LTC2978_MFR_VIN_MIN 0xfc 44 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd 45 46 /* LTC2974, LTC2975 */ 47 #define LTC2974_MFR_IOUT_PEAK 0xd7 48 #define LTC2974_MFR_IOUT_MIN 0xd8 49 50 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, and LTM4676 */ 51 #define LTC3880_MFR_IOUT_PEAK 0xd7 52 #define LTC3880_MFR_CLEAR_PEAKS 0xe3 53 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4 54 55 /* LTC3883 and LTC3886 only */ 56 #define LTC3883_MFR_IIN_PEAK 0xe1 57 58 /* LTC2975 only */ 59 #define LTC2975_MFR_IIN_PEAK 0xc4 60 #define LTC2975_MFR_IIN_MIN 0xc5 61 #define LTC2975_MFR_PIN_PEAK 0xc6 62 #define LTC2975_MFR_PIN_MIN 0xc7 63 64 #define LTC2978_ID_MASK 0xfff0 65 66 #define LTC2974_ID 0x0210 67 #define LTC2975_ID 0x0220 68 #define LTC2977_ID 0x0130 69 #define LTC2978_ID_REV1 0x0110 /* Early revision */ 70 #define LTC2978_ID_REV2 0x0120 71 #define LTC2980_ID_A 0x8030 /* A/B for two die IDs */ 72 #define LTC2980_ID_B 0x8040 73 #define LTC3880_ID 0x4020 74 #define LTC3882_ID 0x4200 75 #define LTC3882_ID_D1 0x4240 /* Dash 1 */ 76 #define LTC3883_ID 0x4300 77 #define LTC3886_ID 0x4600 78 #define LTC3887_ID 0x4700 79 #define LTM2987_ID_A 0x8010 /* A/B for two die IDs */ 80 #define LTM2987_ID_B 0x8020 81 #define LTM4675_ID 0x47a0 82 #define LTM4676_ID_REV1 0x4400 83 #define LTM4676_ID_REV2 0x4480 84 #define LTM4676A_ID 0x47e0 85 #define LTM4686_ID 0x4770 86 87 #define LTC2974_NUM_PAGES 4 88 #define LTC2978_NUM_PAGES 8 89 #define LTC3880_NUM_PAGES 2 90 #define LTC3883_NUM_PAGES 1 91 92 #define LTC_POLL_TIMEOUT 100 /* in milli-seconds */ 93 94 #define LTC_NOT_BUSY BIT(5) 95 #define LTC_NOT_PENDING BIT(4) 96 97 /* 98 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which 99 * happens pretty much each time chip data is updated. Raw peak data therefore 100 * does not provide much value. To be able to provide useful peak data, keep an 101 * internal cache of measured peak data, which is only cleared if an explicit 102 * "clear peak" command is executed for the sensor in question. 103 */ 104 105 struct ltc2978_data { 106 enum chips id; 107 u16 vin_min, vin_max; 108 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES]; 109 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES]; 110 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES]; 111 u16 iin_min, iin_max; 112 u16 pin_min, pin_max; 113 u16 temp2_max; 114 struct pmbus_driver_info info; 115 u32 features; 116 }; 117 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info) 118 119 #define FEAT_CLEAR_PEAKS BIT(0) 120 #define FEAT_NEEDS_POLLING BIT(1) 121 122 #define has_clear_peaks(d) ((d)->features & FEAT_CLEAR_PEAKS) 123 #define needs_polling(d) ((d)->features & FEAT_NEEDS_POLLING) 124 125 static int ltc_wait_ready(struct i2c_client *client) 126 { 127 unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT); 128 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 129 struct ltc2978_data *data = to_ltc2978_data(info); 130 int status; 131 u8 mask; 132 133 if (!needs_polling(data)) 134 return 0; 135 136 /* 137 * LTC3883 does not support LTC_NOT_PENDING, even though 138 * the datasheet claims that it does. 139 */ 140 mask = LTC_NOT_BUSY; 141 if (data->id != ltc3883) 142 mask |= LTC_NOT_PENDING; 143 144 do { 145 status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON); 146 if (status == -EBADMSG || status == -ENXIO) { 147 /* PEC error or NACK: chip may be busy, try again */ 148 usleep_range(50, 100); 149 continue; 150 } 151 if (status < 0) 152 return status; 153 154 if ((status & mask) == mask) 155 return 0; 156 157 usleep_range(50, 100); 158 } while (time_before(jiffies, timeout)); 159 160 return -ETIMEDOUT; 161 } 162 163 static int ltc_read_word_data(struct i2c_client *client, int page, int reg) 164 { 165 int ret; 166 167 ret = ltc_wait_ready(client); 168 if (ret < 0) 169 return ret; 170 171 return pmbus_read_word_data(client, page, reg); 172 } 173 174 static int ltc_read_byte_data(struct i2c_client *client, int page, int reg) 175 { 176 int ret; 177 178 ret = ltc_wait_ready(client); 179 if (ret < 0) 180 return ret; 181 182 return pmbus_read_byte_data(client, page, reg); 183 } 184 185 static int ltc_write_byte(struct i2c_client *client, int page, u8 byte) 186 { 187 int ret; 188 189 ret = ltc_wait_ready(client); 190 if (ret < 0) 191 return ret; 192 193 return pmbus_write_byte(client, page, byte); 194 } 195 196 static inline int lin11_to_val(int data) 197 { 198 s16 e = ((s16)data) >> 11; 199 s32 m = (((s16)(data << 5)) >> 5); 200 201 /* 202 * mantissa is 10 bit + sign, exponent adds up to 15 bit. 203 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31). 204 */ 205 e += 6; 206 return (e < 0 ? m >> -e : m << e); 207 } 208 209 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client, 210 int page, int reg, u16 *pmax) 211 { 212 int ret; 213 214 ret = ltc_read_word_data(client, page, reg); 215 if (ret >= 0) { 216 if (lin11_to_val(ret) > lin11_to_val(*pmax)) 217 *pmax = ret; 218 ret = *pmax; 219 } 220 return ret; 221 } 222 223 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client, 224 int page, int reg, u16 *pmin) 225 { 226 int ret; 227 228 ret = ltc_read_word_data(client, page, reg); 229 if (ret >= 0) { 230 if (lin11_to_val(ret) < lin11_to_val(*pmin)) 231 *pmin = ret; 232 ret = *pmin; 233 } 234 return ret; 235 } 236 237 static int ltc2978_read_word_data_common(struct i2c_client *client, int page, 238 int reg) 239 { 240 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 241 struct ltc2978_data *data = to_ltc2978_data(info); 242 int ret; 243 244 switch (reg) { 245 case PMBUS_VIRT_READ_VIN_MAX: 246 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK, 247 &data->vin_max); 248 break; 249 case PMBUS_VIRT_READ_VOUT_MAX: 250 ret = ltc_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK); 251 if (ret >= 0) { 252 /* 253 * VOUT is 16 bit unsigned with fixed exponent, 254 * so we can compare it directly 255 */ 256 if (ret > data->vout_max[page]) 257 data->vout_max[page] = ret; 258 ret = data->vout_max[page]; 259 } 260 break; 261 case PMBUS_VIRT_READ_TEMP_MAX: 262 ret = ltc_get_max(data, client, page, 263 LTC2978_MFR_TEMPERATURE_PEAK, 264 &data->temp_max[page]); 265 break; 266 case PMBUS_VIRT_RESET_VOUT_HISTORY: 267 case PMBUS_VIRT_RESET_VIN_HISTORY: 268 case PMBUS_VIRT_RESET_TEMP_HISTORY: 269 ret = 0; 270 break; 271 default: 272 ret = ltc_wait_ready(client); 273 if (ret < 0) 274 return ret; 275 ret = -ENODATA; 276 break; 277 } 278 return ret; 279 } 280 281 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg) 282 { 283 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 284 struct ltc2978_data *data = to_ltc2978_data(info); 285 int ret; 286 287 switch (reg) { 288 case PMBUS_VIRT_READ_VIN_MIN: 289 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN, 290 &data->vin_min); 291 break; 292 case PMBUS_VIRT_READ_VOUT_MIN: 293 ret = ltc_read_word_data(client, page, LTC2978_MFR_VOUT_MIN); 294 if (ret >= 0) { 295 /* 296 * VOUT_MIN is known to not be supported on some lots 297 * of LTC2978 revision 1, and will return the maximum 298 * possible voltage if read. If VOUT_MAX is valid and 299 * lower than the reading of VOUT_MIN, use it instead. 300 */ 301 if (data->vout_max[page] && ret > data->vout_max[page]) 302 ret = data->vout_max[page]; 303 if (ret < data->vout_min[page]) 304 data->vout_min[page] = ret; 305 ret = data->vout_min[page]; 306 } 307 break; 308 case PMBUS_VIRT_READ_TEMP_MIN: 309 ret = ltc_get_min(data, client, page, 310 LTC2978_MFR_TEMPERATURE_MIN, 311 &data->temp_min[page]); 312 break; 313 case PMBUS_VIRT_READ_IOUT_MAX: 314 case PMBUS_VIRT_RESET_IOUT_HISTORY: 315 case PMBUS_VIRT_READ_TEMP2_MAX: 316 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 317 ret = -ENXIO; 318 break; 319 default: 320 ret = ltc2978_read_word_data_common(client, page, reg); 321 break; 322 } 323 return ret; 324 } 325 326 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg) 327 { 328 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 329 struct ltc2978_data *data = to_ltc2978_data(info); 330 int ret; 331 332 switch (reg) { 333 case PMBUS_VIRT_READ_IOUT_MAX: 334 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK, 335 &data->iout_max[page]); 336 break; 337 case PMBUS_VIRT_READ_IOUT_MIN: 338 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN, 339 &data->iout_min[page]); 340 break; 341 case PMBUS_VIRT_RESET_IOUT_HISTORY: 342 ret = 0; 343 break; 344 default: 345 ret = ltc2978_read_word_data(client, page, reg); 346 break; 347 } 348 return ret; 349 } 350 351 static int ltc2975_read_word_data(struct i2c_client *client, int page, int reg) 352 { 353 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 354 struct ltc2978_data *data = to_ltc2978_data(info); 355 int ret; 356 357 switch (reg) { 358 case PMBUS_VIRT_READ_IIN_MAX: 359 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK, 360 &data->iin_max); 361 break; 362 case PMBUS_VIRT_READ_IIN_MIN: 363 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN, 364 &data->iin_min); 365 break; 366 case PMBUS_VIRT_READ_PIN_MAX: 367 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK, 368 &data->pin_max); 369 break; 370 case PMBUS_VIRT_READ_PIN_MIN: 371 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN, 372 &data->pin_min); 373 break; 374 case PMBUS_VIRT_RESET_IIN_HISTORY: 375 case PMBUS_VIRT_RESET_PIN_HISTORY: 376 ret = 0; 377 break; 378 default: 379 ret = ltc2978_read_word_data(client, page, reg); 380 break; 381 } 382 return ret; 383 } 384 385 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg) 386 { 387 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 388 struct ltc2978_data *data = to_ltc2978_data(info); 389 int ret; 390 391 switch (reg) { 392 case PMBUS_VIRT_READ_IOUT_MAX: 393 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK, 394 &data->iout_max[page]); 395 break; 396 case PMBUS_VIRT_READ_TEMP2_MAX: 397 ret = ltc_get_max(data, client, page, 398 LTC3880_MFR_TEMPERATURE2_PEAK, 399 &data->temp2_max); 400 break; 401 case PMBUS_VIRT_READ_VIN_MIN: 402 case PMBUS_VIRT_READ_VOUT_MIN: 403 case PMBUS_VIRT_READ_TEMP_MIN: 404 ret = -ENXIO; 405 break; 406 case PMBUS_VIRT_RESET_IOUT_HISTORY: 407 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 408 ret = 0; 409 break; 410 default: 411 ret = ltc2978_read_word_data_common(client, page, reg); 412 break; 413 } 414 return ret; 415 } 416 417 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg) 418 { 419 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 420 struct ltc2978_data *data = to_ltc2978_data(info); 421 int ret; 422 423 switch (reg) { 424 case PMBUS_VIRT_READ_IIN_MAX: 425 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK, 426 &data->iin_max); 427 break; 428 case PMBUS_VIRT_RESET_IIN_HISTORY: 429 ret = 0; 430 break; 431 default: 432 ret = ltc3880_read_word_data(client, page, reg); 433 break; 434 } 435 return ret; 436 } 437 438 static int ltc2978_clear_peaks(struct ltc2978_data *data, 439 struct i2c_client *client, int page) 440 { 441 int ret; 442 443 if (has_clear_peaks(data)) 444 ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS); 445 else 446 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS); 447 448 return ret; 449 } 450 451 static int ltc2978_write_word_data(struct i2c_client *client, int page, 452 int reg, u16 word) 453 { 454 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 455 struct ltc2978_data *data = to_ltc2978_data(info); 456 int ret; 457 458 switch (reg) { 459 case PMBUS_VIRT_RESET_IIN_HISTORY: 460 data->iin_max = 0x7c00; 461 data->iin_min = 0x7bff; 462 ret = ltc2978_clear_peaks(data, client, 0); 463 break; 464 case PMBUS_VIRT_RESET_PIN_HISTORY: 465 data->pin_max = 0x7c00; 466 data->pin_min = 0x7bff; 467 ret = ltc2978_clear_peaks(data, client, 0); 468 break; 469 case PMBUS_VIRT_RESET_IOUT_HISTORY: 470 data->iout_max[page] = 0x7c00; 471 data->iout_min[page] = 0xfbff; 472 ret = ltc2978_clear_peaks(data, client, page); 473 break; 474 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 475 data->temp2_max = 0x7c00; 476 ret = ltc2978_clear_peaks(data, client, page); 477 break; 478 case PMBUS_VIRT_RESET_VOUT_HISTORY: 479 data->vout_min[page] = 0xffff; 480 data->vout_max[page] = 0; 481 ret = ltc2978_clear_peaks(data, client, page); 482 break; 483 case PMBUS_VIRT_RESET_VIN_HISTORY: 484 data->vin_min = 0x7bff; 485 data->vin_max = 0x7c00; 486 ret = ltc2978_clear_peaks(data, client, page); 487 break; 488 case PMBUS_VIRT_RESET_TEMP_HISTORY: 489 data->temp_min[page] = 0x7bff; 490 data->temp_max[page] = 0x7c00; 491 ret = ltc2978_clear_peaks(data, client, page); 492 break; 493 default: 494 ret = ltc_wait_ready(client); 495 if (ret < 0) 496 return ret; 497 ret = -ENODATA; 498 break; 499 } 500 return ret; 501 } 502 503 static const struct i2c_device_id ltc2978_id[] = { 504 {"ltc2974", ltc2974}, 505 {"ltc2975", ltc2975}, 506 {"ltc2977", ltc2977}, 507 {"ltc2978", ltc2978}, 508 {"ltc2980", ltc2980}, 509 {"ltc3880", ltc3880}, 510 {"ltc3882", ltc3882}, 511 {"ltc3883", ltc3883}, 512 {"ltc3886", ltc3886}, 513 {"ltc3887", ltc3887}, 514 {"ltm2987", ltm2987}, 515 {"ltm4675", ltm4675}, 516 {"ltm4676", ltm4676}, 517 {"ltm4686", ltm4686}, 518 {} 519 }; 520 MODULE_DEVICE_TABLE(i2c, ltc2978_id); 521 522 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR) 523 static const struct regulator_desc ltc2978_reg_desc[] = { 524 PMBUS_REGULATOR("vout", 0), 525 PMBUS_REGULATOR("vout", 1), 526 PMBUS_REGULATOR("vout", 2), 527 PMBUS_REGULATOR("vout", 3), 528 PMBUS_REGULATOR("vout", 4), 529 PMBUS_REGULATOR("vout", 5), 530 PMBUS_REGULATOR("vout", 6), 531 PMBUS_REGULATOR("vout", 7), 532 }; 533 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */ 534 535 static int ltc2978_get_id(struct i2c_client *client) 536 { 537 int chip_id; 538 539 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID); 540 if (chip_id < 0) { 541 const struct i2c_device_id *id; 542 u8 buf[I2C_SMBUS_BLOCK_MAX]; 543 int ret; 544 545 if (!i2c_check_functionality(client->adapter, 546 I2C_FUNC_SMBUS_READ_BLOCK_DATA)) 547 return -ENODEV; 548 549 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf); 550 if (ret < 0) 551 return ret; 552 if (ret < 3 || strncmp(buf, "LTC", 3)) 553 return -ENODEV; 554 555 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf); 556 if (ret < 0) 557 return ret; 558 for (id = <c2978_id[0]; strlen(id->name); id++) { 559 if (!strncasecmp(id->name, buf, strlen(id->name))) 560 return (int)id->driver_data; 561 } 562 return -ENODEV; 563 } 564 565 chip_id &= LTC2978_ID_MASK; 566 567 if (chip_id == LTC2974_ID) 568 return ltc2974; 569 else if (chip_id == LTC2975_ID) 570 return ltc2975; 571 else if (chip_id == LTC2977_ID) 572 return ltc2977; 573 else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2) 574 return ltc2978; 575 else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B) 576 return ltc2980; 577 else if (chip_id == LTC3880_ID) 578 return ltc3880; 579 else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1) 580 return ltc3882; 581 else if (chip_id == LTC3883_ID) 582 return ltc3883; 583 else if (chip_id == LTC3886_ID) 584 return ltc3886; 585 else if (chip_id == LTC3887_ID) 586 return ltc3887; 587 else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B) 588 return ltm2987; 589 else if (chip_id == LTM4675_ID) 590 return ltm4675; 591 else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 || 592 chip_id == LTM4676A_ID) 593 return ltm4676; 594 else if (chip_id == LTM4686_ID) 595 return ltm4686; 596 597 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id); 598 return -ENODEV; 599 } 600 601 static int ltc2978_probe(struct i2c_client *client, 602 const struct i2c_device_id *id) 603 { 604 int i, chip_id; 605 struct ltc2978_data *data; 606 struct pmbus_driver_info *info; 607 608 if (!i2c_check_functionality(client->adapter, 609 I2C_FUNC_SMBUS_READ_WORD_DATA)) 610 return -ENODEV; 611 612 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data), 613 GFP_KERNEL); 614 if (!data) 615 return -ENOMEM; 616 617 chip_id = ltc2978_get_id(client); 618 if (chip_id < 0) 619 return chip_id; 620 621 data->id = chip_id; 622 if (data->id != id->driver_data) 623 dev_warn(&client->dev, 624 "Device mismatch: Configured %s, detected %s\n", 625 id->name, 626 ltc2978_id[data->id].name); 627 628 info = &data->info; 629 info->write_word_data = ltc2978_write_word_data; 630 info->write_byte = ltc_write_byte; 631 info->read_word_data = ltc_read_word_data; 632 info->read_byte_data = ltc_read_byte_data; 633 634 data->vin_min = 0x7bff; 635 data->vin_max = 0x7c00; 636 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++) 637 data->vout_min[i] = 0xffff; 638 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++) 639 data->iout_min[i] = 0xfbff; 640 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++) 641 data->iout_max[i] = 0x7c00; 642 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++) 643 data->temp_min[i] = 0x7bff; 644 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++) 645 data->temp_max[i] = 0x7c00; 646 data->temp2_max = 0x7c00; 647 648 switch (data->id) { 649 case ltc2974: 650 info->read_word_data = ltc2974_read_word_data; 651 info->pages = LTC2974_NUM_PAGES; 652 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 653 | PMBUS_HAVE_TEMP2; 654 for (i = 0; i < info->pages; i++) { 655 info->func[i] |= PMBUS_HAVE_VOUT 656 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 657 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 658 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 659 } 660 break; 661 case ltc2975: 662 info->read_word_data = ltc2975_read_word_data; 663 info->pages = LTC2974_NUM_PAGES; 664 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN 665 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 666 | PMBUS_HAVE_TEMP2; 667 for (i = 0; i < info->pages; i++) { 668 info->func[i] |= PMBUS_HAVE_VOUT 669 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 670 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 671 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 672 } 673 break; 674 case ltc2977: 675 case ltc2978: 676 case ltc2980: 677 case ltm2987: 678 info->read_word_data = ltc2978_read_word_data; 679 info->pages = LTC2978_NUM_PAGES; 680 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 681 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 682 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 683 for (i = 1; i < LTC2978_NUM_PAGES; i++) { 684 info->func[i] = PMBUS_HAVE_VOUT 685 | PMBUS_HAVE_STATUS_VOUT; 686 } 687 break; 688 case ltc3880: 689 case ltc3887: 690 case ltm4675: 691 case ltm4676: 692 case ltm4686: 693 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 694 info->read_word_data = ltc3880_read_word_data; 695 info->pages = LTC3880_NUM_PAGES; 696 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 697 | PMBUS_HAVE_STATUS_INPUT 698 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 699 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 700 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 701 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 702 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 703 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 704 | PMBUS_HAVE_POUT 705 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 706 break; 707 case ltc3882: 708 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 709 info->read_word_data = ltc3880_read_word_data; 710 info->pages = LTC3880_NUM_PAGES; 711 info->func[0] = PMBUS_HAVE_VIN 712 | PMBUS_HAVE_STATUS_INPUT 713 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 714 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 715 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 716 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 717 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 718 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 719 | PMBUS_HAVE_POUT 720 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 721 break; 722 case ltc3883: 723 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 724 info->read_word_data = ltc3883_read_word_data; 725 info->pages = LTC3883_NUM_PAGES; 726 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 727 | PMBUS_HAVE_STATUS_INPUT 728 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 729 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 730 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 731 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 732 break; 733 case ltc3886: 734 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 735 info->read_word_data = ltc3883_read_word_data; 736 info->pages = LTC3880_NUM_PAGES; 737 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 738 | PMBUS_HAVE_STATUS_INPUT 739 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 740 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 741 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 742 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 743 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 744 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 745 | PMBUS_HAVE_POUT 746 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 747 break; 748 default: 749 return -ENODEV; 750 } 751 752 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR) 753 info->num_regulators = info->pages; 754 info->reg_desc = ltc2978_reg_desc; 755 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) { 756 dev_err(&client->dev, "num_regulators too large!"); 757 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc); 758 } 759 #endif 760 761 return pmbus_do_probe(client, id, info); 762 } 763 764 #ifdef CONFIG_OF 765 static const struct of_device_id ltc2978_of_match[] = { 766 { .compatible = "lltc,ltc2974" }, 767 { .compatible = "lltc,ltc2975" }, 768 { .compatible = "lltc,ltc2977" }, 769 { .compatible = "lltc,ltc2978" }, 770 { .compatible = "lltc,ltc2980" }, 771 { .compatible = "lltc,ltc3880" }, 772 { .compatible = "lltc,ltc3882" }, 773 { .compatible = "lltc,ltc3883" }, 774 { .compatible = "lltc,ltc3886" }, 775 { .compatible = "lltc,ltc3887" }, 776 { .compatible = "lltc,ltm2987" }, 777 { .compatible = "lltc,ltm4675" }, 778 { .compatible = "lltc,ltm4676" }, 779 { .compatible = "lltc,ltm4686" }, 780 { } 781 }; 782 MODULE_DEVICE_TABLE(of, ltc2978_of_match); 783 #endif 784 785 static struct i2c_driver ltc2978_driver = { 786 .driver = { 787 .name = "ltc2978", 788 .of_match_table = of_match_ptr(ltc2978_of_match), 789 }, 790 .probe = ltc2978_probe, 791 .remove = pmbus_do_remove, 792 .id_table = ltc2978_id, 793 }; 794 795 module_i2c_driver(ltc2978_driver); 796 797 MODULE_AUTHOR("Guenter Roeck"); 798 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips"); 799 MODULE_LICENSE("GPL"); 800