940 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Hardware monitoring driver for LTC2978 and compatible chips.4 *5 * Copyright (c) 2011 Ericsson AB.6 * Copyright (c) 2013, 2014, 2015 Guenter Roeck7 * Copyright (c) 2015 Linear Technology8 * 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 22enum 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 0xdd34#define LTC2978_MFR_VIN_PEAK 0xde35#define LTC2978_MFR_TEMPERATURE_PEAK 0xdf36#define LTC2978_MFR_SPECIAL_ID 0xe7 /* Undocumented on LTC3882 */37#define LTC2978_MFR_COMMON 0xef38 39/* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */40#define LTC2978_MFR_VOUT_MIN 0xfb41#define LTC2978_MFR_VIN_MIN 0xfc42#define LTC2978_MFR_TEMPERATURE_MIN 0xfd43 44/* LTC2974, LTC2975 */45#define LTC2974_MFR_IOUT_PEAK 0xd746#define LTC2974_MFR_IOUT_MIN 0xd847 48/* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, LTM4676, LTC7132 */49#define LTC3880_MFR_IOUT_PEAK 0xd750#define LTC3880_MFR_CLEAR_PEAKS 0xe351#define LTC3880_MFR_TEMPERATURE2_PEAK 0xf452 53/* LTC3883, LTC3884, LTC3886, LTC3889, LTC7132, LTC7880 */54#define LTC3883_MFR_IIN_PEAK 0xe155 56/* LTC2975 only */57#define LTC2975_MFR_IIN_PEAK 0xc458#define LTC2975_MFR_IIN_MIN 0xc559#define LTC2975_MFR_PIN_PEAK 0xc660#define LTC2975_MFR_PIN_MIN 0xc761 62#define LTC2978_ID_MASK 0xfff063 64#define LTC2972_ID 0x031065#define LTC2974_ID 0x021066#define LTC2975_ID 0x022067#define LTC2977_ID 0x013068#define LTC2978_ID_REV1 0x0110 /* Early revision */69#define LTC2978_ID_REV2 0x012070#define LTC2979_ID_A 0x806071#define LTC2979_ID_B 0x807072#define LTC2980_ID_A 0x8030 /* A/B for two die IDs */73#define LTC2980_ID_B 0x804074#define LTC3880_ID 0x402075#define LTC3882_ID 0x420076#define LTC3882_ID_D1 0x4240 /* Dash 1 */77#define LTC3883_ID 0x430078#define LTC3884_ID 0x4C0079#define LTC3886_ID 0x460080#define LTC3887_ID 0x470081#define LTC3889_ID 0x490082#define LTC7132_ID 0x4CE083#define LTC7880_ID 0x49E084#define LTM2987_ID_A 0x8010 /* A/B for two die IDs */85#define LTM2987_ID_B 0x802086#define LTM4664_ID 0x412087#define LTM4675_ID 0x47a088#define LTM4676_ID_REV1 0x440089#define LTM4676_ID_REV2 0x448090#define LTM4676A_ID 0x47e091#define LTM4677_ID_REV1 0x47B092#define LTM4677_ID_REV2 0x47D093#define LTM4678_ID_REV1 0x410094#define LTM4678_ID_REV2 0x411095#define LTM4680_ID 0x414096#define LTM4686_ID 0x477097#define LTM4700_ID 0x413098 99#define LTC2972_NUM_PAGES 2100#define LTC2974_NUM_PAGES 4101#define LTC2978_NUM_PAGES 8102#define LTC3880_NUM_PAGES 2103#define LTC3883_NUM_PAGES 1104 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, which112 * happens pretty much each time chip data is updated. Raw peak data therefore113 * does not provide much value. To be able to provide useful peak data, keep an114 * internal cache of measured peak data, which is only cleared if an explicit115 * "clear peak" command is executed for the sensor in question.116 */117 118struct 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 138static 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 though151 * 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 176static 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 188static 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 199static 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 210static 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 221static 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 234static 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 248static 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 262static 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 directly281 */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 307static 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 lots325 * of LTC2978 revision 1, and will return the maximum326 * possible voltage if read. If VOUT_MAX is valid and327 * 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 354static 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 380static 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 415static 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 448static 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 470static 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 else478 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);479 480 return ret;481}482 483static 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 535static 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};563MODULE_DEVICE_TABLE(i2c, ltc2978_id);564 565#if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)566#define LTC2978_ADC_RES 0xFFFF567#define LTC2978_N_ADC 122568#define LTC2978_MAX_UV (LTC2978_ADC_RES * LTC2978_N_ADC)569#define LTC2978_UV_STEP 1000570#define LTC2978_N_VOLTAGES ((LTC2978_MAX_UV / LTC2978_UV_STEP) + 1)571 572static 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 583static 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 595static 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 683static 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_PIN738 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT739 | PMBUS_HAVE_TEMP2;740 for (i = 0; i < info->pages; i++) {741 info->func[i] |= PMBUS_HAVE_VOUT742 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT743 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP744 | 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_INPUT751 | PMBUS_HAVE_TEMP2;752 for (i = 0; i < info->pages; i++) {753 info->func[i] |= PMBUS_HAVE_VOUT754 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT755 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP756 | 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_PIN763 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT764 | PMBUS_HAVE_TEMP2;765 for (i = 0; i < info->pages; i++) {766 info->func[i] |= PMBUS_HAVE_VOUT767 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT768 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP769 | 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_INPUT781 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT782 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;783 for (i = 1; i < LTC2978_NUM_PAGES; i++) {784 info->func[i] = PMBUS_HAVE_VOUT785 | 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_IIN798 | PMBUS_HAVE_STATUS_INPUT799 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT800 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT801 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP802 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;803 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT804 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT805 | PMBUS_HAVE_POUT806 | 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_VIN813 | PMBUS_HAVE_STATUS_INPUT814 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT815 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT816 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP817 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;818 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT819 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT820 | PMBUS_HAVE_POUT821 | 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_IIN828 | PMBUS_HAVE_STATUS_INPUT829 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT830 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT831 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP832 | 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_IIN847 | PMBUS_HAVE_STATUS_INPUT848 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT849 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT850 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP851 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;852 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT853 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT854 | PMBUS_HAVE_POUT855 | 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#endif888 889 return pmbus_do_probe(client, info);890}891 892 893#ifdef CONFIG_OF894static 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};922MODULE_DEVICE_TABLE(of, ltc2978_of_match);923#endif924 925static struct i2c_driver ltc2978_driver = {926 .driver = {927 .name = "ltc2978",928 .of_match_table = of_match_ptr(ltc2978_of_match),929 },930 .probe = ltc2978_probe,931 .id_table = ltc2978_id,932};933 934module_i2c_driver(ltc2978_driver);935 936MODULE_AUTHOR("Guenter Roeck");937MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");938MODULE_LICENSE("GPL");939MODULE_IMPORT_NS(PMBUS);940