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