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