1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for LTC2978 and compatible chips. 4 * 5 * Copyright (c) 2011 Ericsson AB. 6 * Copyright (c) 2013, 2014, 2015 Guenter Roeck 7 * Copyright (c) 2015 Linear Technology 8 * Copyright (c) 2018 Analog Devices Inc. 9 */ 10 11 #include <linux/delay.h> 12 #include <linux/jiffies.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/err.h> 17 #include <linux/slab.h> 18 #include <linux/i2c.h> 19 #include <linux/regulator/driver.h> 20 #include "pmbus.h" 21 22 enum chips { 23 /* Managers */ 24 ltc2972, ltc2974, ltc2975, ltc2977, ltc2978, ltc2979, ltc2980, 25 /* Controllers */ 26 lt7170, lt7171, ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887, 27 ltc3889, ltc7132, ltc7841, ltc7880, 28 /* Modules */ 29 ltm2987, ltm4664, ltm4673, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680, 30 ltm4686, ltm4700, 31 }; 32 33 /* Common for all chips */ 34 #define LTC2978_MFR_VOUT_PEAK 0xdd 35 #define LTC2978_MFR_VIN_PEAK 0xde 36 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf 37 #define LTC2978_MFR_SPECIAL_ID 0xe7 /* Undocumented on LTC3882 */ 38 #define LTC2978_MFR_COMMON 0xef 39 40 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */ 41 #define LTC2978_MFR_VOUT_MIN 0xfb 42 #define LTC2978_MFR_VIN_MIN 0xfc 43 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd 44 45 /* LTC2974, LTC2975 */ 46 #define LTC2974_MFR_IOUT_PEAK 0xd7 47 #define LTC2974_MFR_IOUT_MIN 0xd8 48 49 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, LTM4676, LTC7132 */ 50 #define LTC3880_MFR_IOUT_PEAK 0xd7 51 #define LTC3880_MFR_CLEAR_PEAKS 0xe3 52 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4 53 54 /* LTC3883, LTC3884, LTC3886, LTC3889, LTC7132, LTC7841 and LTC7880 only */ 55 #define LTC3883_MFR_IIN_PEAK 0xe1 56 57 /* LTC2975 only */ 58 #define LTC2975_MFR_IIN_PEAK 0xc4 59 #define LTC2975_MFR_IIN_MIN 0xc5 60 #define LTC2975_MFR_PIN_PEAK 0xc6 61 #define LTC2975_MFR_PIN_MIN 0xc7 62 63 #define LTC2978_ID_MASK 0xfff0 64 65 #define LT7170_ID 0x1C10 66 #define LTC2972_ID 0x0310 67 #define LTC2974_ID 0x0210 68 #define LTC2975_ID 0x0220 69 #define LTC2977_ID 0x0130 70 #define LTC2978_ID_REV1 0x0110 /* Early revision */ 71 #define LTC2978_ID_REV2 0x0120 72 #define LTC2979_ID_A 0x8060 73 #define LTC2979_ID_B 0x8070 74 #define LTC2980_ID_A 0x8030 /* A/B for two die IDs */ 75 #define LTC2980_ID_B 0x8040 76 #define LTC3880_ID 0x4020 77 #define LTC3882_ID 0x4200 78 #define LTC3882_ID_D1 0x4240 /* Dash 1 */ 79 #define LTC3883_ID 0x4300 80 #define LTC3884_ID 0x4C00 81 #define LTC3886_ID 0x4600 82 #define LTC3887_ID 0x4700 83 #define LTC3889_ID 0x4900 84 #define LTC7132_ID 0x4CE0 85 #define LTC7841_ID 0x40D0 86 #define LTC7880_ID 0x49E0 87 #define LTM2987_ID_A 0x8010 /* A/B for two die IDs */ 88 #define LTM2987_ID_B 0x8020 89 #define LTM4664_ID 0x4120 90 #define LTM4673_ID_REV1 0x0230 91 #define LTM4673_ID 0x4480 92 #define LTM4675_ID 0x47a0 93 #define LTM4676_ID_REV1 0x4400 94 #define LTM4676_ID_REV2 0x4480 95 #define LTM4676A_ID 0x47e0 96 #define LTM4677_ID_REV1 0x47B0 97 #define LTM4677_ID_REV2 0x47D0 98 #define LTM4678_ID_REV1 0x4100 99 #define LTM4678_ID_REV2 0x4110 100 #define LTM4680_ID 0x4140 101 #define LTM4686_ID 0x4770 102 #define LTM4700_ID 0x4130 103 104 #define LTC2972_NUM_PAGES 2 105 #define LTC2974_NUM_PAGES 4 106 #define LTC2978_NUM_PAGES 8 107 #define LTC3880_NUM_PAGES 2 108 #define LTC3883_NUM_PAGES 1 109 110 #define LTC_POLL_TIMEOUT 100 /* in milli-seconds */ 111 112 #define LTC_NOT_BUSY BIT(6) 113 #define LTC_NOT_PENDING BIT(5) 114 115 /* 116 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which 117 * happens pretty much each time chip data is updated. Raw peak data therefore 118 * does not provide much value. To be able to provide useful peak data, keep an 119 * internal cache of measured peak data, which is only cleared if an explicit 120 * "clear peak" command is executed for the sensor in question. 121 */ 122 123 struct ltc2978_data { 124 enum chips id; 125 u16 vin_min, vin_max; 126 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES]; 127 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES]; 128 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES]; 129 u16 iin_min, iin_max; 130 u16 pin_min, pin_max; 131 u16 temp2_max; 132 struct pmbus_driver_info info; 133 u32 features; 134 }; 135 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info) 136 137 #define FEAT_CLEAR_PEAKS BIT(0) 138 #define FEAT_NEEDS_POLLING BIT(1) 139 140 #define has_clear_peaks(d) ((d)->features & FEAT_CLEAR_PEAKS) 141 #define needs_polling(d) ((d)->features & FEAT_NEEDS_POLLING) 142 143 static int ltc_wait_ready(struct i2c_client *client) 144 { 145 unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT); 146 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 147 struct ltc2978_data *data = to_ltc2978_data(info); 148 int status; 149 u8 mask; 150 151 if (!needs_polling(data)) 152 return 0; 153 154 /* 155 * LTC3883 does not support LTC_NOT_PENDING, even though 156 * the datasheet claims that it does. 157 */ 158 mask = LTC_NOT_BUSY; 159 if (data->id != ltc3883) 160 mask |= LTC_NOT_PENDING; 161 162 do { 163 status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON); 164 if (status == -EBADMSG || status == -ENXIO) { 165 /* PEC error or NACK: chip may be busy, try again */ 166 usleep_range(50, 100); 167 continue; 168 } 169 if (status < 0) 170 return status; 171 172 if ((status & mask) == mask) 173 return 0; 174 175 usleep_range(50, 100); 176 } while (time_before(jiffies, timeout)); 177 178 return -ETIMEDOUT; 179 } 180 181 static int ltc_read_word_data(struct i2c_client *client, int page, int phase, 182 int reg) 183 { 184 int ret; 185 186 ret = ltc_wait_ready(client); 187 if (ret < 0) 188 return ret; 189 190 return pmbus_read_word_data(client, page, 0xff, reg); 191 } 192 193 static int ltc_read_byte_data(struct i2c_client *client, int page, int reg) 194 { 195 int ret; 196 197 ret = ltc_wait_ready(client); 198 if (ret < 0) 199 return ret; 200 201 return pmbus_read_byte_data(client, page, reg); 202 } 203 204 static int ltc_write_byte_data(struct i2c_client *client, int page, int reg, u8 value) 205 { 206 int ret; 207 208 ret = ltc_wait_ready(client); 209 if (ret < 0) 210 return ret; 211 212 return pmbus_write_byte_data(client, page, reg, value); 213 } 214 215 static int ltc_write_byte(struct i2c_client *client, int page, u8 byte) 216 { 217 int ret; 218 219 ret = ltc_wait_ready(client); 220 if (ret < 0) 221 return ret; 222 223 return pmbus_write_byte(client, page, byte); 224 } 225 226 static inline int lin11_to_val(int data) 227 { 228 s16 e = ((s16)data) >> 11; 229 s32 m = (((s16)(data << 5)) >> 5); 230 231 /* 232 * mantissa is 10 bit + sign, exponent adds up to 15 bit. 233 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31). 234 */ 235 e += 6; 236 return (e < 0 ? m >> -e : m << e); 237 } 238 239 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client, 240 int page, int reg, u16 *pmax) 241 { 242 int ret; 243 244 ret = ltc_read_word_data(client, page, 0xff, reg); 245 if (ret >= 0) { 246 if (lin11_to_val(ret) > lin11_to_val(*pmax)) 247 *pmax = ret; 248 ret = *pmax; 249 } 250 return ret; 251 } 252 253 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client, 254 int page, int reg, u16 *pmin) 255 { 256 int ret; 257 258 ret = ltc_read_word_data(client, page, 0xff, reg); 259 if (ret >= 0) { 260 if (lin11_to_val(ret) < lin11_to_val(*pmin)) 261 *pmin = ret; 262 ret = *pmin; 263 } 264 return ret; 265 } 266 267 static int ltc2978_read_word_data_common(struct i2c_client *client, int page, 268 int reg) 269 { 270 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 271 struct ltc2978_data *data = to_ltc2978_data(info); 272 int ret; 273 274 switch (reg) { 275 case PMBUS_VIRT_READ_VIN_MAX: 276 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK, 277 &data->vin_max); 278 break; 279 case PMBUS_VIRT_READ_VOUT_MAX: 280 ret = ltc_read_word_data(client, page, 0xff, 281 LTC2978_MFR_VOUT_PEAK); 282 if (ret >= 0) { 283 /* 284 * VOUT is 16 bit unsigned with fixed exponent, 285 * so we can compare it directly 286 */ 287 if (ret > data->vout_max[page]) 288 data->vout_max[page] = ret; 289 ret = data->vout_max[page]; 290 } 291 break; 292 case PMBUS_VIRT_READ_TEMP_MAX: 293 ret = ltc_get_max(data, client, page, 294 LTC2978_MFR_TEMPERATURE_PEAK, 295 &data->temp_max[page]); 296 break; 297 case PMBUS_VIRT_RESET_VOUT_HISTORY: 298 case PMBUS_VIRT_RESET_VIN_HISTORY: 299 case PMBUS_VIRT_RESET_TEMP_HISTORY: 300 ret = 0; 301 break; 302 default: 303 ret = ltc_wait_ready(client); 304 if (ret < 0) 305 return ret; 306 ret = -ENODATA; 307 break; 308 } 309 return ret; 310 } 311 312 static int ltc2978_read_word_data(struct i2c_client *client, int page, 313 int phase, int reg) 314 { 315 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 316 struct ltc2978_data *data = to_ltc2978_data(info); 317 int ret; 318 319 switch (reg) { 320 case PMBUS_VIRT_READ_VIN_MIN: 321 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN, 322 &data->vin_min); 323 break; 324 case PMBUS_VIRT_READ_VOUT_MIN: 325 ret = ltc_read_word_data(client, page, phase, 326 LTC2978_MFR_VOUT_MIN); 327 if (ret >= 0) { 328 /* 329 * VOUT_MIN is known to not be supported on some lots 330 * of LTC2978 revision 1, and will return the maximum 331 * possible voltage if read. If VOUT_MAX is valid and 332 * lower than the reading of VOUT_MIN, use it instead. 333 */ 334 if (data->vout_max[page] && ret > data->vout_max[page]) 335 ret = data->vout_max[page]; 336 if (ret < data->vout_min[page]) 337 data->vout_min[page] = ret; 338 ret = data->vout_min[page]; 339 } 340 break; 341 case PMBUS_VIRT_READ_TEMP_MIN: 342 ret = ltc_get_min(data, client, page, 343 LTC2978_MFR_TEMPERATURE_MIN, 344 &data->temp_min[page]); 345 break; 346 case PMBUS_VIRT_READ_IOUT_MAX: 347 case PMBUS_VIRT_RESET_IOUT_HISTORY: 348 case PMBUS_VIRT_READ_TEMP2_MAX: 349 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 350 ret = -ENXIO; 351 break; 352 default: 353 ret = ltc2978_read_word_data_common(client, page, reg); 354 break; 355 } 356 return ret; 357 } 358 359 static int ltc2974_read_word_data(struct i2c_client *client, int page, 360 int phase, int reg) 361 { 362 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 363 struct ltc2978_data *data = to_ltc2978_data(info); 364 int ret; 365 366 switch (reg) { 367 case PMBUS_VIRT_READ_IOUT_MAX: 368 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK, 369 &data->iout_max[page]); 370 break; 371 case PMBUS_VIRT_READ_IOUT_MIN: 372 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN, 373 &data->iout_min[page]); 374 break; 375 case PMBUS_VIRT_RESET_IOUT_HISTORY: 376 ret = 0; 377 break; 378 default: 379 ret = ltc2978_read_word_data(client, page, phase, reg); 380 break; 381 } 382 return ret; 383 } 384 385 static int ltc2975_read_word_data(struct i2c_client *client, int page, 386 int phase, int reg) 387 { 388 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 389 struct ltc2978_data *data = to_ltc2978_data(info); 390 int ret; 391 392 switch (reg) { 393 case PMBUS_VIRT_READ_IIN_MAX: 394 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK, 395 &data->iin_max); 396 break; 397 case PMBUS_VIRT_READ_IIN_MIN: 398 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN, 399 &data->iin_min); 400 break; 401 case PMBUS_VIRT_READ_PIN_MAX: 402 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK, 403 &data->pin_max); 404 break; 405 case PMBUS_VIRT_READ_PIN_MIN: 406 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN, 407 &data->pin_min); 408 break; 409 case PMBUS_VIRT_RESET_IIN_HISTORY: 410 case PMBUS_VIRT_RESET_PIN_HISTORY: 411 ret = 0; 412 break; 413 default: 414 ret = ltc2978_read_word_data(client, page, phase, reg); 415 break; 416 } 417 return ret; 418 } 419 420 static int ltc3880_read_word_data(struct i2c_client *client, int page, 421 int phase, int reg) 422 { 423 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 424 struct ltc2978_data *data = to_ltc2978_data(info); 425 int ret; 426 427 switch (reg) { 428 case PMBUS_VIRT_READ_IOUT_MAX: 429 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK, 430 &data->iout_max[page]); 431 break; 432 case PMBUS_VIRT_READ_TEMP2_MAX: 433 ret = ltc_get_max(data, client, page, 434 LTC3880_MFR_TEMPERATURE2_PEAK, 435 &data->temp2_max); 436 break; 437 case PMBUS_VIRT_READ_VIN_MIN: 438 case PMBUS_VIRT_READ_VOUT_MIN: 439 case PMBUS_VIRT_READ_TEMP_MIN: 440 ret = -ENXIO; 441 break; 442 case PMBUS_VIRT_RESET_IOUT_HISTORY: 443 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 444 ret = 0; 445 break; 446 default: 447 ret = ltc2978_read_word_data_common(client, page, reg); 448 break; 449 } 450 return ret; 451 } 452 453 static int ltc3883_read_word_data(struct i2c_client *client, int page, 454 int phase, int reg) 455 { 456 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 457 struct ltc2978_data *data = to_ltc2978_data(info); 458 int ret; 459 460 switch (reg) { 461 case PMBUS_VIRT_READ_IIN_MAX: 462 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK, 463 &data->iin_max); 464 break; 465 case PMBUS_VIRT_RESET_IIN_HISTORY: 466 ret = 0; 467 break; 468 default: 469 ret = ltc3880_read_word_data(client, page, phase, reg); 470 break; 471 } 472 return ret; 473 } 474 475 static int ltc2978_clear_peaks(struct ltc2978_data *data, 476 struct i2c_client *client, int page) 477 { 478 int ret; 479 480 if (has_clear_peaks(data)) 481 ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS); 482 else 483 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS); 484 485 return ret; 486 } 487 488 static int ltc2978_write_word_data(struct i2c_client *client, int page, 489 int reg, u16 word) 490 { 491 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 492 struct ltc2978_data *data = to_ltc2978_data(info); 493 int ret; 494 495 switch (reg) { 496 case PMBUS_VIRT_RESET_IIN_HISTORY: 497 data->iin_max = 0x7c00; 498 data->iin_min = 0x7bff; 499 ret = ltc2978_clear_peaks(data, client, 0); 500 break; 501 case PMBUS_VIRT_RESET_PIN_HISTORY: 502 data->pin_max = 0x7c00; 503 data->pin_min = 0x7bff; 504 ret = ltc2978_clear_peaks(data, client, 0); 505 break; 506 case PMBUS_VIRT_RESET_IOUT_HISTORY: 507 data->iout_max[page] = 0x7c00; 508 data->iout_min[page] = 0xfbff; 509 ret = ltc2978_clear_peaks(data, client, page); 510 break; 511 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 512 data->temp2_max = 0x7c00; 513 ret = ltc2978_clear_peaks(data, client, page); 514 break; 515 case PMBUS_VIRT_RESET_VOUT_HISTORY: 516 data->vout_min[page] = 0xffff; 517 data->vout_max[page] = 0; 518 ret = ltc2978_clear_peaks(data, client, page); 519 break; 520 case PMBUS_VIRT_RESET_VIN_HISTORY: 521 data->vin_min = 0x7bff; 522 data->vin_max = 0x7c00; 523 ret = ltc2978_clear_peaks(data, client, page); 524 break; 525 case PMBUS_VIRT_RESET_TEMP_HISTORY: 526 data->temp_min[page] = 0x7bff; 527 data->temp_max[page] = 0x7c00; 528 ret = ltc2978_clear_peaks(data, client, page); 529 break; 530 default: 531 ret = ltc_wait_ready(client); 532 if (ret < 0) 533 return ret; 534 ret = -ENODATA; 535 break; 536 } 537 return ret; 538 } 539 540 static const struct i2c_device_id ltc2978_id[] = { 541 { .name = "lt7170", .driver_data = lt7170 }, 542 { .name = "lt7171", .driver_data = lt7171 }, 543 { .name = "ltc2972", .driver_data = ltc2972 }, 544 { .name = "ltc2974", .driver_data = ltc2974 }, 545 { .name = "ltc2975", .driver_data = ltc2975 }, 546 { .name = "ltc2977", .driver_data = ltc2977 }, 547 { .name = "ltc2978", .driver_data = ltc2978 }, 548 { .name = "ltc2979", .driver_data = ltc2979 }, 549 { .name = "ltc2980", .driver_data = ltc2980 }, 550 { .name = "ltc3880", .driver_data = ltc3880 }, 551 { .name = "ltc3882", .driver_data = ltc3882 }, 552 { .name = "ltc3883", .driver_data = ltc3883 }, 553 { .name = "ltc3884", .driver_data = ltc3884 }, 554 { .name = "ltc3886", .driver_data = ltc3886 }, 555 { .name = "ltc3887", .driver_data = ltc3887 }, 556 { .name = "ltc3889", .driver_data = ltc3889 }, 557 { .name = "ltc7132", .driver_data = ltc7132 }, 558 { .name = "ltc7841", .driver_data = ltc7841 }, 559 { .name = "ltc7880", .driver_data = ltc7880 }, 560 { .name = "ltm2987", .driver_data = ltm2987 }, 561 { .name = "ltm4664", .driver_data = ltm4664 }, 562 { .name = "ltm4673", .driver_data = ltm4673 }, 563 { .name = "ltm4675", .driver_data = ltm4675 }, 564 { .name = "ltm4676", .driver_data = ltm4676 }, 565 { .name = "ltm4677", .driver_data = ltm4677 }, 566 { .name = "ltm4678", .driver_data = ltm4678 }, 567 { .name = "ltm4680", .driver_data = ltm4680 }, 568 { .name = "ltm4686", .driver_data = ltm4686 }, 569 { .name = "ltm4700", .driver_data = ltm4700 }, 570 { } 571 }; 572 MODULE_DEVICE_TABLE(i2c, ltc2978_id); 573 574 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR) 575 #define LTC2978_ADC_RES 0xFFFF 576 #define LTC2978_N_ADC 122 577 #define LTC2978_MAX_UV (LTC2978_ADC_RES * LTC2978_N_ADC) 578 #define LTC2978_UV_STEP 1000 579 #define LTC2978_N_VOLTAGES ((LTC2978_MAX_UV / LTC2978_UV_STEP) + 1) 580 581 static const struct regulator_desc ltc2978_reg_desc[] = { 582 PMBUS_REGULATOR_STEP("vout", 0, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 583 PMBUS_REGULATOR_STEP("vout", 1, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 584 PMBUS_REGULATOR_STEP("vout", 2, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 585 PMBUS_REGULATOR_STEP("vout", 3, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 586 PMBUS_REGULATOR_STEP("vout", 4, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 587 PMBUS_REGULATOR_STEP("vout", 5, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 588 PMBUS_REGULATOR_STEP("vout", 6, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 589 PMBUS_REGULATOR_STEP("vout", 7, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0), 590 }; 591 592 static const struct regulator_desc ltc2978_reg_desc_default[] = { 593 PMBUS_REGULATOR("vout", 0), 594 PMBUS_REGULATOR("vout", 1), 595 PMBUS_REGULATOR("vout", 2), 596 PMBUS_REGULATOR("vout", 3), 597 PMBUS_REGULATOR("vout", 4), 598 PMBUS_REGULATOR("vout", 5), 599 PMBUS_REGULATOR("vout", 6), 600 PMBUS_REGULATOR("vout", 7), 601 }; 602 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */ 603 604 static int ltc2978_get_id(struct i2c_client *client) 605 { 606 int chip_id; 607 608 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID); 609 if (chip_id < 0) { 610 const struct i2c_device_id *id; 611 u8 buf[I2C_SMBUS_BLOCK_MAX]; 612 int ret; 613 614 ret = pmbus_read_smbus_i2c_block_data(client, PMBUS_MFR_ID, buf); 615 if (ret < 0) 616 return ret; 617 if (ret < 3 || (strncmp(buf, "LTC", 3) && strncmp(buf, "ADI", 3))) 618 return -ENODEV; 619 620 ret = pmbus_read_smbus_i2c_block_data(client, PMBUS_MFR_MODEL, buf); 621 if (ret < 0) 622 return ret; 623 for (id = <c2978_id[0]; strlen(id->name); id++) { 624 if (!strncasecmp(id->name, buf, strlen(id->name))) 625 return (int)id->driver_data; 626 } 627 return -ENODEV; 628 } 629 630 chip_id &= LTC2978_ID_MASK; 631 632 if (chip_id == LT7170_ID) { 633 u8 buf[I2C_SMBUS_BLOCK_MAX]; 634 int ret; 635 636 ret = pmbus_read_smbus_i2c_block_data(client, PMBUS_IC_DEVICE_ID, 637 buf); 638 if (ret < 0) 639 return ret; 640 641 if (ret < 6) 642 return -ENODEV; 643 644 if (!strncmp(buf, "LT7170", 6)) 645 return lt7170; 646 if (!strncmp(buf, "LT7171", 6)) 647 return lt7171; 648 649 return -ENODEV; 650 } 651 652 if (chip_id == LTC2972_ID) 653 return ltc2972; 654 else if (chip_id == LTC2974_ID) 655 return ltc2974; 656 else if (chip_id == LTC2975_ID) 657 return ltc2975; 658 else if (chip_id == LTC2977_ID) 659 return ltc2977; 660 else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2) 661 return ltc2978; 662 else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B) 663 return ltc2979; 664 else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B) 665 return ltc2980; 666 else if (chip_id == LTC3880_ID) 667 return ltc3880; 668 else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1) 669 return ltc3882; 670 else if (chip_id == LTC3883_ID) 671 return ltc3883; 672 else if (chip_id == LTC3884_ID) 673 return ltc3884; 674 else if (chip_id == LTC3886_ID) 675 return ltc3886; 676 else if (chip_id == LTC3887_ID) 677 return ltc3887; 678 else if (chip_id == LTC3889_ID) 679 return ltc3889; 680 else if (chip_id == LTC7132_ID) 681 return ltc7132; 682 else if (chip_id == LTC7841_ID) 683 return ltc7841; 684 else if (chip_id == LTC7880_ID) 685 return ltc7880; 686 else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B) 687 return ltm2987; 688 else if (chip_id == LTM4664_ID) 689 return ltm4664; 690 else if (chip_id == LTM4673_ID || chip_id == LTM4673_ID_REV1) 691 return ltm4673; 692 else if (chip_id == LTM4675_ID) 693 return ltm4675; 694 else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 || 695 chip_id == LTM4676A_ID) 696 return ltm4676; 697 else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2) 698 return ltm4677; 699 else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2) 700 return ltm4678; 701 else if (chip_id == LTM4680_ID) 702 return ltm4680; 703 else if (chip_id == LTM4686_ID) 704 return ltm4686; 705 else if (chip_id == LTM4700_ID) 706 return ltm4700; 707 708 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id); 709 return -ENODEV; 710 } 711 712 static int ltc2978_probe(struct i2c_client *client) 713 { 714 int i, chip_id; 715 struct ltc2978_data *data; 716 struct pmbus_driver_info *info; 717 const struct i2c_device_id *id; 718 719 if (!i2c_check_functionality(client->adapter, 720 I2C_FUNC_SMBUS_READ_WORD_DATA)) 721 return -ENODEV; 722 723 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data), 724 GFP_KERNEL); 725 if (!data) 726 return -ENOMEM; 727 728 chip_id = ltc2978_get_id(client); 729 if (chip_id < 0) 730 return chip_id; 731 732 data->id = chip_id; 733 id = i2c_client_get_device_id(client); 734 if (data->id != id->driver_data) 735 dev_warn(&client->dev, 736 "Device mismatch: Configured %s (%d), detected %d\n", 737 id->name, 738 (int) id->driver_data, 739 chip_id); 740 741 info = &data->info; 742 info->write_word_data = ltc2978_write_word_data; 743 info->write_byte = ltc_write_byte; 744 info->write_byte_data = ltc_write_byte_data; 745 info->read_word_data = ltc_read_word_data; 746 info->read_byte_data = ltc_read_byte_data; 747 748 data->vin_min = 0x7bff; 749 data->vin_max = 0x7c00; 750 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++) 751 data->vout_min[i] = 0xffff; 752 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++) 753 data->iout_min[i] = 0xfbff; 754 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++) 755 data->iout_max[i] = 0x7c00; 756 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++) 757 data->temp_min[i] = 0x7bff; 758 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++) 759 data->temp_max[i] = 0x7c00; 760 data->temp2_max = 0x7c00; 761 762 switch (data->id) { 763 case lt7170: 764 case lt7171: 765 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 766 info->read_word_data = ltc3883_read_word_data; 767 info->pages = LTC3883_NUM_PAGES; 768 info->format[PSC_VOLTAGE_IN] = ieee754; 769 info->format[PSC_VOLTAGE_OUT] = ieee754; 770 info->format[PSC_CURRENT_OUT] = ieee754; 771 info->format[PSC_TEMPERATURE] = ieee754; 772 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 773 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 774 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 775 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 776 break; 777 case ltc2972: 778 info->read_word_data = ltc2975_read_word_data; 779 info->pages = LTC2972_NUM_PAGES; 780 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN 781 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 782 | PMBUS_HAVE_TEMP2; 783 for (i = 0; i < info->pages; i++) { 784 info->func[i] |= PMBUS_HAVE_VOUT 785 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 786 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 787 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 788 } 789 break; 790 case ltc2974: 791 info->read_word_data = ltc2974_read_word_data; 792 info->pages = LTC2974_NUM_PAGES; 793 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 794 | PMBUS_HAVE_TEMP2; 795 for (i = 0; i < info->pages; i++) { 796 info->func[i] |= PMBUS_HAVE_VOUT 797 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 798 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 799 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 800 } 801 break; 802 case ltc2975: 803 info->read_word_data = ltc2975_read_word_data; 804 info->pages = LTC2974_NUM_PAGES; 805 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN 806 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 807 | PMBUS_HAVE_TEMP2; 808 for (i = 0; i < info->pages; i++) { 809 info->func[i] |= PMBUS_HAVE_VOUT 810 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 811 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 812 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 813 } 814 break; 815 816 case ltc2977: 817 case ltc2978: 818 case ltc2979: 819 case ltc2980: 820 case ltm2987: 821 info->read_word_data = ltc2978_read_word_data; 822 info->pages = LTC2978_NUM_PAGES; 823 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 824 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 825 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 826 for (i = 1; i < LTC2978_NUM_PAGES; i++) { 827 info->func[i] = PMBUS_HAVE_VOUT 828 | PMBUS_HAVE_STATUS_VOUT; 829 } 830 break; 831 case ltc3880: 832 case ltc3887: 833 case ltm4675: 834 case ltm4676: 835 case ltm4677: 836 case ltm4686: 837 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 838 info->read_word_data = ltc3880_read_word_data; 839 info->pages = LTC3880_NUM_PAGES; 840 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 841 | PMBUS_HAVE_STATUS_INPUT 842 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 843 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 844 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 845 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 846 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 847 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 848 | PMBUS_HAVE_POUT 849 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 850 break; 851 case ltc3882: 852 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 853 info->read_word_data = ltc3880_read_word_data; 854 info->pages = LTC3880_NUM_PAGES; 855 info->func[0] = PMBUS_HAVE_VIN 856 | PMBUS_HAVE_STATUS_INPUT 857 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 858 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 859 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 860 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 861 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 862 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 863 | PMBUS_HAVE_POUT 864 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 865 break; 866 case ltc3883: 867 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 868 info->read_word_data = ltc3883_read_word_data; 869 info->pages = LTC3883_NUM_PAGES; 870 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 871 | PMBUS_HAVE_STATUS_INPUT 872 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 873 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 874 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 875 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 876 break; 877 case ltc3884: 878 case ltc3886: 879 case ltc3889: 880 case ltc7132: 881 case ltc7880: 882 case ltm4664: 883 case ltm4678: 884 case ltm4680: 885 case ltm4700: 886 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING; 887 info->read_word_data = ltc3883_read_word_data; 888 info->pages = LTC3880_NUM_PAGES; 889 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 890 | PMBUS_HAVE_STATUS_INPUT 891 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 892 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 893 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 894 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 895 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 896 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 897 | PMBUS_HAVE_POUT 898 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 899 break; 900 case ltc7841: 901 data->features |= FEAT_CLEAR_PEAKS; 902 info->read_word_data = ltc3883_read_word_data; 903 info->pages = LTC3883_NUM_PAGES; 904 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 905 | PMBUS_HAVE_STATUS_INPUT 906 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 907 | PMBUS_HAVE_IOUT 908 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 909 break; 910 case ltm4673: 911 data->features |= FEAT_NEEDS_POLLING; 912 info->read_word_data = ltc2975_read_word_data; 913 info->pages = LTC2974_NUM_PAGES; 914 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 915 | PMBUS_HAVE_TEMP2; 916 for (i = 0; i < info->pages; i++) { 917 info->func[i] |= PMBUS_HAVE_IIN 918 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 919 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 920 | PMBUS_HAVE_PIN 921 | PMBUS_HAVE_POUT 922 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 923 } 924 break; 925 default: 926 return -ENODEV; 927 } 928 929 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR) 930 info->num_regulators = info->pages; 931 switch (data->id) { 932 case ltc2972: 933 case ltc2974: 934 case ltc2975: 935 case ltc2977: 936 case ltc2978: 937 case ltc2979: 938 case ltc2980: 939 case ltm2987: 940 info->reg_desc = ltc2978_reg_desc; 941 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) { 942 dev_warn(&client->dev, "num_regulators too large!"); 943 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc); 944 } 945 break; 946 default: 947 info->reg_desc = ltc2978_reg_desc_default; 948 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc_default)) { 949 dev_warn(&client->dev, "num_regulators too large!"); 950 info->num_regulators = 951 ARRAY_SIZE(ltc2978_reg_desc_default); 952 } 953 break; 954 } 955 #endif 956 957 return pmbus_do_probe(client, info); 958 } 959 960 961 #ifdef CONFIG_OF 962 static const struct of_device_id ltc2978_of_match[] = { 963 { .compatible = "lltc,lt7170" }, 964 { .compatible = "lltc,lt7171" }, 965 { .compatible = "lltc,ltc2972" }, 966 { .compatible = "lltc,ltc2974" }, 967 { .compatible = "lltc,ltc2975" }, 968 { .compatible = "lltc,ltc2977" }, 969 { .compatible = "lltc,ltc2978" }, 970 { .compatible = "lltc,ltc2979" }, 971 { .compatible = "lltc,ltc2980" }, 972 { .compatible = "lltc,ltc3880" }, 973 { .compatible = "lltc,ltc3882" }, 974 { .compatible = "lltc,ltc3883" }, 975 { .compatible = "lltc,ltc3884" }, 976 { .compatible = "lltc,ltc3886" }, 977 { .compatible = "lltc,ltc3887" }, 978 { .compatible = "lltc,ltc3889" }, 979 { .compatible = "lltc,ltc7132" }, 980 { .compatible = "lltc,ltc7841" }, 981 { .compatible = "lltc,ltc7880" }, 982 { .compatible = "lltc,ltm2987" }, 983 { .compatible = "lltc,ltm4664" }, 984 { .compatible = "lltc,ltm4673" }, 985 { .compatible = "lltc,ltm4675" }, 986 { .compatible = "lltc,ltm4676" }, 987 { .compatible = "lltc,ltm4677" }, 988 { .compatible = "lltc,ltm4678" }, 989 { .compatible = "lltc,ltm4680" }, 990 { .compatible = "lltc,ltm4686" }, 991 { .compatible = "lltc,ltm4700" }, 992 { } 993 }; 994 MODULE_DEVICE_TABLE(of, ltc2978_of_match); 995 #endif 996 997 static struct i2c_driver ltc2978_driver = { 998 .driver = { 999 .name = "ltc2978", 1000 .of_match_table = of_match_ptr(ltc2978_of_match), 1001 }, 1002 .probe = ltc2978_probe, 1003 .id_table = ltc2978_id, 1004 }; 1005 1006 module_i2c_driver(ltc2978_driver); 1007 1008 MODULE_AUTHOR("Guenter Roeck"); 1009 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips"); 1010 MODULE_LICENSE("GPL"); 1011 MODULE_IMPORT_NS("PMBUS"); 1012