Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Hardware monitoring driver for LTC2978 and compatible chips.
0004  *
0005  * Copyright (c) 2011 Ericsson AB.
0006  * Copyright (c) 2013, 2014, 2015 Guenter Roeck
0007  * Copyright (c) 2015 Linear Technology
0008  * Copyright (c) 2018 Analog Devices Inc.
0009  */
0010 
0011 #include <linux/delay.h>
0012 #include <linux/jiffies.h>
0013 #include <linux/kernel.h>
0014 #include <linux/module.h>
0015 #include <linux/init.h>
0016 #include <linux/err.h>
0017 #include <linux/slab.h>
0018 #include <linux/i2c.h>
0019 #include <linux/regulator/driver.h>
0020 #include "pmbus.h"
0021 
0022 enum chips {
0023     /* Managers */
0024     ltc2972, ltc2974, ltc2975, ltc2977, ltc2978, ltc2979, ltc2980,
0025     /* Controllers */
0026     ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887, ltc3889, ltc7880,
0027     /* Modules */
0028     ltm2987, ltm4664, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680, ltm4686,
0029     ltm4700,
0030 };
0031 
0032 /* Common for all chips */
0033 #define LTC2978_MFR_VOUT_PEAK       0xdd
0034 #define LTC2978_MFR_VIN_PEAK        0xde
0035 #define LTC2978_MFR_TEMPERATURE_PEAK    0xdf
0036 #define LTC2978_MFR_SPECIAL_ID      0xe7    /* Undocumented on LTC3882 */
0037 #define LTC2978_MFR_COMMON      0xef
0038 
0039 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */
0040 #define LTC2978_MFR_VOUT_MIN        0xfb
0041 #define LTC2978_MFR_VIN_MIN     0xfc
0042 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
0043 
0044 /* LTC2974, LTC2975 */
0045 #define LTC2974_MFR_IOUT_PEAK       0xd7
0046 #define LTC2974_MFR_IOUT_MIN        0xd8
0047 
0048 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, and LTM4676 */
0049 #define LTC3880_MFR_IOUT_PEAK       0xd7
0050 #define LTC3880_MFR_CLEAR_PEAKS     0xe3
0051 #define LTC3880_MFR_TEMPERATURE2_PEAK   0xf4
0052 
0053 /* LTC3883, LTC3884, LTC3886, LTC3889 and LTC7880 only */
0054 #define LTC3883_MFR_IIN_PEAK        0xe1
0055 
0056 
0057 /* LTC2975 only */
0058 #define LTC2975_MFR_IIN_PEAK        0xc4
0059 #define LTC2975_MFR_IIN_MIN     0xc5
0060 #define LTC2975_MFR_PIN_PEAK        0xc6
0061 #define LTC2975_MFR_PIN_MIN     0xc7
0062 
0063 #define LTC2978_ID_MASK         0xfff0
0064 
0065 #define LTC2972_ID          0x0310
0066 #define LTC2974_ID          0x0210
0067 #define LTC2975_ID          0x0220
0068 #define LTC2977_ID          0x0130
0069 #define LTC2978_ID_REV1         0x0110  /* Early revision */
0070 #define LTC2978_ID_REV2         0x0120
0071 #define LTC2979_ID_A            0x8060
0072 #define LTC2979_ID_B            0x8070
0073 #define LTC2980_ID_A            0x8030  /* A/B for two die IDs */
0074 #define LTC2980_ID_B            0x8040
0075 #define LTC3880_ID          0x4020
0076 #define LTC3882_ID          0x4200
0077 #define LTC3882_ID_D1           0x4240  /* Dash 1 */
0078 #define LTC3883_ID          0x4300
0079 #define LTC3884_ID          0x4C00
0080 #define LTC3886_ID          0x4600
0081 #define LTC3887_ID          0x4700
0082 #define LTM2987_ID_A            0x8010  /* A/B for two die IDs */
0083 #define LTM2987_ID_B            0x8020
0084 #define LTC3889_ID          0x4900
0085 #define LTC7880_ID          0x49E0
0086 #define LTM4664_ID          0x4120
0087 #define LTM4675_ID          0x47a0
0088 #define LTM4676_ID_REV1         0x4400
0089 #define LTM4676_ID_REV2         0x4480
0090 #define LTM4676A_ID         0x47e0
0091 #define LTM4677_ID_REV1         0x47B0
0092 #define LTM4677_ID_REV2         0x47D0
0093 #define LTM4678_ID_REV1         0x4100
0094 #define LTM4678_ID_REV2         0x4110
0095 #define LTM4680_ID          0x4140
0096 #define LTM4686_ID          0x4770
0097 #define LTM4700_ID          0x4130
0098 
0099 #define LTC2972_NUM_PAGES       2
0100 #define LTC2974_NUM_PAGES       4
0101 #define LTC2978_NUM_PAGES       8
0102 #define LTC3880_NUM_PAGES       2
0103 #define LTC3883_NUM_PAGES       1
0104 
0105 #define LTC_POLL_TIMEOUT        100 /* in milli-seconds */
0106 
0107 #define LTC_NOT_BUSY            BIT(6)
0108 #define LTC_NOT_PENDING         BIT(5)
0109 
0110 /*
0111  * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
0112  * happens pretty much each time chip data is updated. Raw peak data therefore
0113  * does not provide much value. To be able to provide useful peak data, keep an
0114  * internal cache of measured peak data, which is only cleared if an explicit
0115  * "clear peak" command is executed for the sensor in question.
0116  */
0117 
0118 struct ltc2978_data {
0119     enum chips id;
0120     u16 vin_min, vin_max;
0121     u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
0122     u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
0123     u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
0124     u16 iin_min, iin_max;
0125     u16 pin_min, pin_max;
0126     u16 temp2_max;
0127     struct pmbus_driver_info info;
0128     u32 features;
0129 };
0130 #define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)
0131 
0132 #define FEAT_CLEAR_PEAKS    BIT(0)
0133 #define FEAT_NEEDS_POLLING  BIT(1)
0134 
0135 #define has_clear_peaks(d)  ((d)->features & FEAT_CLEAR_PEAKS)
0136 #define needs_polling(d)    ((d)->features & FEAT_NEEDS_POLLING)
0137 
0138 static int ltc_wait_ready(struct i2c_client *client)
0139 {
0140     unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT);
0141     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0142     struct ltc2978_data *data = to_ltc2978_data(info);
0143     int status;
0144     u8 mask;
0145 
0146     if (!needs_polling(data))
0147         return 0;
0148 
0149     /*
0150      * LTC3883 does not support LTC_NOT_PENDING, even though
0151      * the datasheet claims that it does.
0152      */
0153     mask = LTC_NOT_BUSY;
0154     if (data->id != ltc3883)
0155         mask |= LTC_NOT_PENDING;
0156 
0157     do {
0158         status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON);
0159         if (status == -EBADMSG || status == -ENXIO) {
0160             /* PEC error or NACK: chip may be busy, try again */
0161             usleep_range(50, 100);
0162             continue;
0163         }
0164         if (status < 0)
0165             return status;
0166 
0167         if ((status & mask) == mask)
0168             return 0;
0169 
0170         usleep_range(50, 100);
0171     } while (time_before(jiffies, timeout));
0172 
0173     return -ETIMEDOUT;
0174 }
0175 
0176 static int ltc_read_word_data(struct i2c_client *client, int page, int phase,
0177                   int reg)
0178 {
0179     int ret;
0180 
0181     ret = ltc_wait_ready(client);
0182     if (ret < 0)
0183         return ret;
0184 
0185     return pmbus_read_word_data(client, page, 0xff, reg);
0186 }
0187 
0188 static int ltc_read_byte_data(struct i2c_client *client, int page, int reg)
0189 {
0190     int ret;
0191 
0192     ret = ltc_wait_ready(client);
0193     if (ret < 0)
0194         return ret;
0195 
0196     return pmbus_read_byte_data(client, page, reg);
0197 }
0198 
0199 static int ltc_write_byte_data(struct i2c_client *client, int page, int reg, u8 value)
0200 {
0201     int ret;
0202 
0203     ret = ltc_wait_ready(client);
0204     if (ret < 0)
0205         return ret;
0206 
0207     return pmbus_write_byte_data(client, page, reg, value);
0208 }
0209 
0210 static int ltc_write_byte(struct i2c_client *client, int page, u8 byte)
0211 {
0212     int ret;
0213 
0214     ret = ltc_wait_ready(client);
0215     if (ret < 0)
0216         return ret;
0217 
0218     return pmbus_write_byte(client, page, byte);
0219 }
0220 
0221 static inline int lin11_to_val(int data)
0222 {
0223     s16 e = ((s16)data) >> 11;
0224     s32 m = (((s16)(data << 5)) >> 5);
0225 
0226     /*
0227      * mantissa is 10 bit + sign, exponent adds up to 15 bit.
0228      * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
0229      */
0230     e += 6;
0231     return (e < 0 ? m >> -e : m << e);
0232 }
0233 
0234 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
0235                int page, int reg, u16 *pmax)
0236 {
0237     int ret;
0238 
0239     ret = ltc_read_word_data(client, page, 0xff, reg);
0240     if (ret >= 0) {
0241         if (lin11_to_val(ret) > lin11_to_val(*pmax))
0242             *pmax = ret;
0243         ret = *pmax;
0244     }
0245     return ret;
0246 }
0247 
0248 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
0249                int page, int reg, u16 *pmin)
0250 {
0251     int ret;
0252 
0253     ret = ltc_read_word_data(client, page, 0xff, reg);
0254     if (ret >= 0) {
0255         if (lin11_to_val(ret) < lin11_to_val(*pmin))
0256             *pmin = ret;
0257         ret = *pmin;
0258     }
0259     return ret;
0260 }
0261 
0262 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
0263                      int reg)
0264 {
0265     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0266     struct ltc2978_data *data = to_ltc2978_data(info);
0267     int ret;
0268 
0269     switch (reg) {
0270     case PMBUS_VIRT_READ_VIN_MAX:
0271         ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
0272                   &data->vin_max);
0273         break;
0274     case PMBUS_VIRT_READ_VOUT_MAX:
0275         ret = ltc_read_word_data(client, page, 0xff,
0276                      LTC2978_MFR_VOUT_PEAK);
0277         if (ret >= 0) {
0278             /*
0279              * VOUT is 16 bit unsigned with fixed exponent,
0280              * so we can compare it directly
0281              */
0282             if (ret > data->vout_max[page])
0283                 data->vout_max[page] = ret;
0284             ret = data->vout_max[page];
0285         }
0286         break;
0287     case PMBUS_VIRT_READ_TEMP_MAX:
0288         ret = ltc_get_max(data, client, page,
0289                   LTC2978_MFR_TEMPERATURE_PEAK,
0290                   &data->temp_max[page]);
0291         break;
0292     case PMBUS_VIRT_RESET_VOUT_HISTORY:
0293     case PMBUS_VIRT_RESET_VIN_HISTORY:
0294     case PMBUS_VIRT_RESET_TEMP_HISTORY:
0295         ret = 0;
0296         break;
0297     default:
0298         ret = ltc_wait_ready(client);
0299         if (ret < 0)
0300             return ret;
0301         ret = -ENODATA;
0302         break;
0303     }
0304     return ret;
0305 }
0306 
0307 static int ltc2978_read_word_data(struct i2c_client *client, int page,
0308                   int phase, int reg)
0309 {
0310     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0311     struct ltc2978_data *data = to_ltc2978_data(info);
0312     int ret;
0313 
0314     switch (reg) {
0315     case PMBUS_VIRT_READ_VIN_MIN:
0316         ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
0317                   &data->vin_min);
0318         break;
0319     case PMBUS_VIRT_READ_VOUT_MIN:
0320         ret = ltc_read_word_data(client, page, phase,
0321                      LTC2978_MFR_VOUT_MIN);
0322         if (ret >= 0) {
0323             /*
0324              * VOUT_MIN is known to not be supported on some lots
0325              * of LTC2978 revision 1, and will return the maximum
0326              * possible voltage if read. If VOUT_MAX is valid and
0327              * lower than the reading of VOUT_MIN, use it instead.
0328              */
0329             if (data->vout_max[page] && ret > data->vout_max[page])
0330                 ret = data->vout_max[page];
0331             if (ret < data->vout_min[page])
0332                 data->vout_min[page] = ret;
0333             ret = data->vout_min[page];
0334         }
0335         break;
0336     case PMBUS_VIRT_READ_TEMP_MIN:
0337         ret = ltc_get_min(data, client, page,
0338                   LTC2978_MFR_TEMPERATURE_MIN,
0339                   &data->temp_min[page]);
0340         break;
0341     case PMBUS_VIRT_READ_IOUT_MAX:
0342     case PMBUS_VIRT_RESET_IOUT_HISTORY:
0343     case PMBUS_VIRT_READ_TEMP2_MAX:
0344     case PMBUS_VIRT_RESET_TEMP2_HISTORY:
0345         ret = -ENXIO;
0346         break;
0347     default:
0348         ret = ltc2978_read_word_data_common(client, page, reg);
0349         break;
0350     }
0351     return ret;
0352 }
0353 
0354 static int ltc2974_read_word_data(struct i2c_client *client, int page,
0355                   int phase, int reg)
0356 {
0357     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0358     struct ltc2978_data *data = to_ltc2978_data(info);
0359     int ret;
0360 
0361     switch (reg) {
0362     case PMBUS_VIRT_READ_IOUT_MAX:
0363         ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
0364                   &data->iout_max[page]);
0365         break;
0366     case PMBUS_VIRT_READ_IOUT_MIN:
0367         ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
0368                   &data->iout_min[page]);
0369         break;
0370     case PMBUS_VIRT_RESET_IOUT_HISTORY:
0371         ret = 0;
0372         break;
0373     default:
0374         ret = ltc2978_read_word_data(client, page, phase, reg);
0375         break;
0376     }
0377     return ret;
0378 }
0379 
0380 static int ltc2975_read_word_data(struct i2c_client *client, int page,
0381                   int phase, int reg)
0382 {
0383     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0384     struct ltc2978_data *data = to_ltc2978_data(info);
0385     int ret;
0386 
0387     switch (reg) {
0388     case PMBUS_VIRT_READ_IIN_MAX:
0389         ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
0390                   &data->iin_max);
0391         break;
0392     case PMBUS_VIRT_READ_IIN_MIN:
0393         ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
0394                   &data->iin_min);
0395         break;
0396     case PMBUS_VIRT_READ_PIN_MAX:
0397         ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
0398                   &data->pin_max);
0399         break;
0400     case PMBUS_VIRT_READ_PIN_MIN:
0401         ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
0402                   &data->pin_min);
0403         break;
0404     case PMBUS_VIRT_RESET_IIN_HISTORY:
0405     case PMBUS_VIRT_RESET_PIN_HISTORY:
0406         ret = 0;
0407         break;
0408     default:
0409         ret = ltc2978_read_word_data(client, page, phase, reg);
0410         break;
0411     }
0412     return ret;
0413 }
0414 
0415 static int ltc3880_read_word_data(struct i2c_client *client, int page,
0416                   int phase, int reg)
0417 {
0418     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0419     struct ltc2978_data *data = to_ltc2978_data(info);
0420     int ret;
0421 
0422     switch (reg) {
0423     case PMBUS_VIRT_READ_IOUT_MAX:
0424         ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
0425                   &data->iout_max[page]);
0426         break;
0427     case PMBUS_VIRT_READ_TEMP2_MAX:
0428         ret = ltc_get_max(data, client, page,
0429                   LTC3880_MFR_TEMPERATURE2_PEAK,
0430                   &data->temp2_max);
0431         break;
0432     case PMBUS_VIRT_READ_VIN_MIN:
0433     case PMBUS_VIRT_READ_VOUT_MIN:
0434     case PMBUS_VIRT_READ_TEMP_MIN:
0435         ret = -ENXIO;
0436         break;
0437     case PMBUS_VIRT_RESET_IOUT_HISTORY:
0438     case PMBUS_VIRT_RESET_TEMP2_HISTORY:
0439         ret = 0;
0440         break;
0441     default:
0442         ret = ltc2978_read_word_data_common(client, page, reg);
0443         break;
0444     }
0445     return ret;
0446 }
0447 
0448 static int ltc3883_read_word_data(struct i2c_client *client, int page,
0449                   int phase, int reg)
0450 {
0451     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0452     struct ltc2978_data *data = to_ltc2978_data(info);
0453     int ret;
0454 
0455     switch (reg) {
0456     case PMBUS_VIRT_READ_IIN_MAX:
0457         ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
0458                   &data->iin_max);
0459         break;
0460     case PMBUS_VIRT_RESET_IIN_HISTORY:
0461         ret = 0;
0462         break;
0463     default:
0464         ret = ltc3880_read_word_data(client, page, phase, reg);
0465         break;
0466     }
0467     return ret;
0468 }
0469 
0470 static int ltc2978_clear_peaks(struct ltc2978_data *data,
0471                    struct i2c_client *client, int page)
0472 {
0473     int ret;
0474 
0475     if (has_clear_peaks(data))
0476         ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
0477     else
0478         ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
0479 
0480     return ret;
0481 }
0482 
0483 static int ltc2978_write_word_data(struct i2c_client *client, int page,
0484                     int reg, u16 word)
0485 {
0486     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0487     struct ltc2978_data *data = to_ltc2978_data(info);
0488     int ret;
0489 
0490     switch (reg) {
0491     case PMBUS_VIRT_RESET_IIN_HISTORY:
0492         data->iin_max = 0x7c00;
0493         data->iin_min = 0x7bff;
0494         ret = ltc2978_clear_peaks(data, client, 0);
0495         break;
0496     case PMBUS_VIRT_RESET_PIN_HISTORY:
0497         data->pin_max = 0x7c00;
0498         data->pin_min = 0x7bff;
0499         ret = ltc2978_clear_peaks(data, client, 0);
0500         break;
0501     case PMBUS_VIRT_RESET_IOUT_HISTORY:
0502         data->iout_max[page] = 0x7c00;
0503         data->iout_min[page] = 0xfbff;
0504         ret = ltc2978_clear_peaks(data, client, page);
0505         break;
0506     case PMBUS_VIRT_RESET_TEMP2_HISTORY:
0507         data->temp2_max = 0x7c00;
0508         ret = ltc2978_clear_peaks(data, client, page);
0509         break;
0510     case PMBUS_VIRT_RESET_VOUT_HISTORY:
0511         data->vout_min[page] = 0xffff;
0512         data->vout_max[page] = 0;
0513         ret = ltc2978_clear_peaks(data, client, page);
0514         break;
0515     case PMBUS_VIRT_RESET_VIN_HISTORY:
0516         data->vin_min = 0x7bff;
0517         data->vin_max = 0x7c00;
0518         ret = ltc2978_clear_peaks(data, client, page);
0519         break;
0520     case PMBUS_VIRT_RESET_TEMP_HISTORY:
0521         data->temp_min[page] = 0x7bff;
0522         data->temp_max[page] = 0x7c00;
0523         ret = ltc2978_clear_peaks(data, client, page);
0524         break;
0525     default:
0526         ret = ltc_wait_ready(client);
0527         if (ret < 0)
0528             return ret;
0529         ret = -ENODATA;
0530         break;
0531     }
0532     return ret;
0533 }
0534 
0535 static const struct i2c_device_id ltc2978_id[] = {
0536     {"ltc2972", ltc2972},
0537     {"ltc2974", ltc2974},
0538     {"ltc2975", ltc2975},
0539     {"ltc2977", ltc2977},
0540     {"ltc2978", ltc2978},
0541     {"ltc2979", ltc2979},
0542     {"ltc2980", ltc2980},
0543     {"ltc3880", ltc3880},
0544     {"ltc3882", ltc3882},
0545     {"ltc3883", ltc3883},
0546     {"ltc3884", ltc3884},
0547     {"ltc3886", ltc3886},
0548     {"ltc3887", ltc3887},
0549     {"ltc3889", ltc3889},
0550     {"ltc7880", ltc7880},
0551     {"ltm2987", ltm2987},
0552     {"ltm4664", ltm4664},
0553     {"ltm4675", ltm4675},
0554     {"ltm4676", ltm4676},
0555     {"ltm4677", ltm4677},
0556     {"ltm4678", ltm4678},
0557     {"ltm4680", ltm4680},
0558     {"ltm4686", ltm4686},
0559     {"ltm4700", ltm4700},
0560     {}
0561 };
0562 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
0563 
0564 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
0565 #define LTC2978_ADC_RES 0xFFFF
0566 #define LTC2978_N_ADC   122
0567 #define LTC2978_MAX_UV  (LTC2978_ADC_RES * LTC2978_N_ADC)
0568 #define LTC2978_UV_STEP 1000
0569 #define LTC2978_N_VOLTAGES  ((LTC2978_MAX_UV / LTC2978_UV_STEP) + 1)
0570 
0571 static const struct regulator_desc ltc2978_reg_desc[] = {
0572     PMBUS_REGULATOR_STEP("vout", 0, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0573     PMBUS_REGULATOR_STEP("vout", 1, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0574     PMBUS_REGULATOR_STEP("vout", 2, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0575     PMBUS_REGULATOR_STEP("vout", 3, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0576     PMBUS_REGULATOR_STEP("vout", 4, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0577     PMBUS_REGULATOR_STEP("vout", 5, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0578     PMBUS_REGULATOR_STEP("vout", 6, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0579     PMBUS_REGULATOR_STEP("vout", 7, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
0580 };
0581 
0582 static const struct regulator_desc ltc2978_reg_desc_default[] = {
0583     PMBUS_REGULATOR("vout", 0),
0584     PMBUS_REGULATOR("vout", 1),
0585     PMBUS_REGULATOR("vout", 2),
0586     PMBUS_REGULATOR("vout", 3),
0587     PMBUS_REGULATOR("vout", 4),
0588     PMBUS_REGULATOR("vout", 5),
0589     PMBUS_REGULATOR("vout", 6),
0590     PMBUS_REGULATOR("vout", 7),
0591 };
0592 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
0593 
0594 static int ltc2978_get_id(struct i2c_client *client)
0595 {
0596     int chip_id;
0597 
0598     chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
0599     if (chip_id < 0) {
0600         const struct i2c_device_id *id;
0601         u8 buf[I2C_SMBUS_BLOCK_MAX];
0602         int ret;
0603 
0604         if (!i2c_check_functionality(client->adapter,
0605                          I2C_FUNC_SMBUS_READ_BLOCK_DATA))
0606             return -ENODEV;
0607 
0608         ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
0609         if (ret < 0)
0610             return ret;
0611         if (ret < 3 || strncmp(buf, "LTC", 3))
0612             return -ENODEV;
0613 
0614         ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
0615         if (ret < 0)
0616             return ret;
0617         for (id = &ltc2978_id[0]; strlen(id->name); id++) {
0618             if (!strncasecmp(id->name, buf, strlen(id->name)))
0619                 return (int)id->driver_data;
0620         }
0621         return -ENODEV;
0622     }
0623 
0624     chip_id &= LTC2978_ID_MASK;
0625 
0626     if (chip_id == LTC2972_ID)
0627         return ltc2972;
0628     else if (chip_id == LTC2974_ID)
0629         return ltc2974;
0630     else if (chip_id == LTC2975_ID)
0631         return ltc2975;
0632     else if (chip_id == LTC2977_ID)
0633         return ltc2977;
0634     else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
0635         return ltc2978;
0636     else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
0637         return ltc2979;
0638     else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
0639         return ltc2980;
0640     else if (chip_id == LTC3880_ID)
0641         return ltc3880;
0642     else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
0643         return ltc3882;
0644     else if (chip_id == LTC3883_ID)
0645         return ltc3883;
0646     else if (chip_id == LTC3884_ID)
0647         return ltc3884;
0648     else if (chip_id == LTC3886_ID)
0649         return ltc3886;
0650     else if (chip_id == LTC3887_ID)
0651         return ltc3887;
0652     else if (chip_id == LTC3889_ID)
0653         return ltc3889;
0654     else if (chip_id == LTC7880_ID)
0655         return ltc7880;
0656     else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
0657         return ltm2987;
0658     else if (chip_id == LTM4664_ID)
0659         return ltm4664;
0660     else if (chip_id == LTM4675_ID)
0661         return ltm4675;
0662     else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
0663          chip_id == LTM4676A_ID)
0664         return ltm4676;
0665     else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2)
0666         return ltm4677;
0667     else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2)
0668         return ltm4678;
0669     else if (chip_id == LTM4680_ID)
0670         return ltm4680;
0671     else if (chip_id == LTM4686_ID)
0672         return ltm4686;
0673     else if (chip_id == LTM4700_ID)
0674         return ltm4700;
0675 
0676     dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
0677     return -ENODEV;
0678 }
0679 
0680 static int ltc2978_probe(struct i2c_client *client)
0681 {
0682     int i, chip_id;
0683     struct ltc2978_data *data;
0684     struct pmbus_driver_info *info;
0685     const struct i2c_device_id *id;
0686 
0687     if (!i2c_check_functionality(client->adapter,
0688                      I2C_FUNC_SMBUS_READ_WORD_DATA))
0689         return -ENODEV;
0690 
0691     data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
0692                 GFP_KERNEL);
0693     if (!data)
0694         return -ENOMEM;
0695 
0696     chip_id = ltc2978_get_id(client);
0697     if (chip_id < 0)
0698         return chip_id;
0699 
0700     data->id = chip_id;
0701     id = i2c_match_id(ltc2978_id, client);
0702     if (data->id != id->driver_data)
0703         dev_warn(&client->dev,
0704              "Device mismatch: Configured %s (%d), detected %d\n",
0705              id->name,
0706              (int) id->driver_data,
0707              chip_id);
0708 
0709     info = &data->info;
0710     info->write_word_data = ltc2978_write_word_data;
0711     info->write_byte = ltc_write_byte;
0712     info->write_byte_data = ltc_write_byte_data;
0713     info->read_word_data = ltc_read_word_data;
0714     info->read_byte_data = ltc_read_byte_data;
0715 
0716     data->vin_min = 0x7bff;
0717     data->vin_max = 0x7c00;
0718     for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
0719         data->vout_min[i] = 0xffff;
0720     for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
0721         data->iout_min[i] = 0xfbff;
0722     for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
0723         data->iout_max[i] = 0x7c00;
0724     for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
0725         data->temp_min[i] = 0x7bff;
0726     for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
0727         data->temp_max[i] = 0x7c00;
0728     data->temp2_max = 0x7c00;
0729 
0730     switch (data->id) {
0731     case ltc2972:
0732         info->read_word_data = ltc2975_read_word_data;
0733         info->pages = LTC2972_NUM_PAGES;
0734         info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
0735           | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
0736           | PMBUS_HAVE_TEMP2;
0737         for (i = 0; i < info->pages; i++) {
0738             info->func[i] |= PMBUS_HAVE_VOUT
0739               | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
0740               | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
0741               | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
0742         }
0743         break;
0744     case ltc2974:
0745         info->read_word_data = ltc2974_read_word_data;
0746         info->pages = LTC2974_NUM_PAGES;
0747         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
0748           | PMBUS_HAVE_TEMP2;
0749         for (i = 0; i < info->pages; i++) {
0750             info->func[i] |= PMBUS_HAVE_VOUT
0751               | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
0752               | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
0753               | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
0754         }
0755         break;
0756     case ltc2975:
0757         info->read_word_data = ltc2975_read_word_data;
0758         info->pages = LTC2974_NUM_PAGES;
0759         info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
0760           | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
0761           | PMBUS_HAVE_TEMP2;
0762         for (i = 0; i < info->pages; i++) {
0763             info->func[i] |= PMBUS_HAVE_VOUT
0764               | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
0765               | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
0766               | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
0767         }
0768         break;
0769 
0770     case ltc2977:
0771     case ltc2978:
0772     case ltc2979:
0773     case ltc2980:
0774     case ltm2987:
0775         info->read_word_data = ltc2978_read_word_data;
0776         info->pages = LTC2978_NUM_PAGES;
0777         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
0778           | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0779           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
0780         for (i = 1; i < LTC2978_NUM_PAGES; i++) {
0781             info->func[i] = PMBUS_HAVE_VOUT
0782               | PMBUS_HAVE_STATUS_VOUT;
0783         }
0784         break;
0785     case ltc3880:
0786     case ltc3887:
0787     case ltm4675:
0788     case ltm4676:
0789     case ltm4677:
0790     case ltm4686:
0791         data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
0792         info->read_word_data = ltc3880_read_word_data;
0793         info->pages = LTC3880_NUM_PAGES;
0794         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
0795           | PMBUS_HAVE_STATUS_INPUT
0796           | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0797           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0798           | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
0799           | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
0800         info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0801           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0802           | PMBUS_HAVE_POUT
0803           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
0804         break;
0805     case ltc3882:
0806         data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
0807         info->read_word_data = ltc3880_read_word_data;
0808         info->pages = LTC3880_NUM_PAGES;
0809         info->func[0] = PMBUS_HAVE_VIN
0810           | PMBUS_HAVE_STATUS_INPUT
0811           | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0812           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0813           | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
0814           | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
0815         info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0816           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0817           | PMBUS_HAVE_POUT
0818           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
0819         break;
0820     case ltc3883:
0821         data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
0822         info->read_word_data = ltc3883_read_word_data;
0823         info->pages = LTC3883_NUM_PAGES;
0824         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
0825           | PMBUS_HAVE_STATUS_INPUT
0826           | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0827           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0828           | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
0829           | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
0830         break;
0831     case ltc3884:
0832     case ltc3886:
0833     case ltc3889:
0834     case ltc7880:
0835     case ltm4664:
0836     case ltm4678:
0837     case ltm4680:
0838     case ltm4700:
0839         data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
0840         info->read_word_data = ltc3883_read_word_data;
0841         info->pages = LTC3880_NUM_PAGES;
0842         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
0843           | PMBUS_HAVE_STATUS_INPUT
0844           | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0845           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0846           | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
0847           | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
0848         info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
0849           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
0850           | PMBUS_HAVE_POUT
0851           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
0852         break;
0853     default:
0854         return -ENODEV;
0855     }
0856 
0857 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
0858     info->num_regulators = info->pages;
0859     switch (data->id) {
0860     case ltc2972:
0861     case ltc2974:
0862     case ltc2975:
0863     case ltc2977:
0864     case ltc2978:
0865     case ltc2979:
0866     case ltc2980:
0867     case ltm2987:
0868         info->reg_desc = ltc2978_reg_desc;
0869         if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
0870             dev_warn(&client->dev, "num_regulators too large!");
0871             info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
0872         }
0873         break;
0874     default:
0875         info->reg_desc = ltc2978_reg_desc_default;
0876         if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc_default)) {
0877             dev_warn(&client->dev, "num_regulators too large!");
0878             info->num_regulators =
0879                 ARRAY_SIZE(ltc2978_reg_desc_default);
0880         }
0881         break;
0882     }
0883 #endif
0884 
0885     return pmbus_do_probe(client, info);
0886 }
0887 
0888 
0889 #ifdef CONFIG_OF
0890 static const struct of_device_id ltc2978_of_match[] = {
0891     { .compatible = "lltc,ltc2972" },
0892     { .compatible = "lltc,ltc2974" },
0893     { .compatible = "lltc,ltc2975" },
0894     { .compatible = "lltc,ltc2977" },
0895     { .compatible = "lltc,ltc2978" },
0896     { .compatible = "lltc,ltc2979" },
0897     { .compatible = "lltc,ltc2980" },
0898     { .compatible = "lltc,ltc3880" },
0899     { .compatible = "lltc,ltc3882" },
0900     { .compatible = "lltc,ltc3883" },
0901     { .compatible = "lltc,ltc3884" },
0902     { .compatible = "lltc,ltc3886" },
0903     { .compatible = "lltc,ltc3887" },
0904     { .compatible = "lltc,ltc3889" },
0905     { .compatible = "lltc,ltc7880" },
0906     { .compatible = "lltc,ltm2987" },
0907     { .compatible = "lltc,ltm4664" },
0908     { .compatible = "lltc,ltm4675" },
0909     { .compatible = "lltc,ltm4676" },
0910     { .compatible = "lltc,ltm4677" },
0911     { .compatible = "lltc,ltm4678" },
0912     { .compatible = "lltc,ltm4680" },
0913     { .compatible = "lltc,ltm4686" },
0914     { .compatible = "lltc,ltm4700" },
0915     { }
0916 };
0917 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
0918 #endif
0919 
0920 static struct i2c_driver ltc2978_driver = {
0921     .driver = {
0922            .name = "ltc2978",
0923            .of_match_table = of_match_ptr(ltc2978_of_match),
0924            },
0925     .probe_new = ltc2978_probe,
0926     .id_table = ltc2978_id,
0927 };
0928 
0929 module_i2c_driver(ltc2978_driver);
0930 
0931 MODULE_AUTHOR("Guenter Roeck");
0932 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
0933 MODULE_LICENSE("GPL");
0934 MODULE_IMPORT_NS(PMBUS);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!