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