Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Hardware monitoring driver for MPS Multi-phase Digital VR Controllers
0004  *
0005  * Copyright (C) 2020 Nvidia Technologies Ltd.
0006  */
0007 
0008 #include <linux/err.h>
0009 #include <linux/i2c.h>
0010 #include <linux/init.h>
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include "pmbus.h"
0014 
0015 /* Vendor specific registers. */
0016 #define MP2975_MFR_APS_HYS_R2       0x0d
0017 #define MP2975_MFR_SLOPE_TRIM3      0x1d
0018 #define MP2975_MFR_VR_MULTI_CONFIG_R1   0x0d
0019 #define MP2975_MFR_VR_MULTI_CONFIG_R2   0x1d
0020 #define MP2975_MFR_APS_DECAY_ADV    0x56
0021 #define MP2975_MFR_DC_LOOP_CTRL     0x59
0022 #define MP2975_MFR_OCP_UCP_PHASE_SET    0x65
0023 #define MP2975_MFR_VR_CONFIG1       0x68
0024 #define MP2975_MFR_READ_CS1_2       0x82
0025 #define MP2975_MFR_READ_CS3_4       0x83
0026 #define MP2975_MFR_READ_CS5_6       0x84
0027 #define MP2975_MFR_READ_CS7_8       0x85
0028 #define MP2975_MFR_READ_CS9_10      0x86
0029 #define MP2975_MFR_READ_CS11_12     0x87
0030 #define MP2975_MFR_READ_IOUT_PK     0x90
0031 #define MP2975_MFR_READ_POUT_PK     0x91
0032 #define MP2975_MFR_READ_VREF_R1     0xa1
0033 #define MP2975_MFR_READ_VREF_R2     0xa3
0034 #define MP2975_MFR_OVP_TH_SET       0xe5
0035 #define MP2975_MFR_UVP_SET      0xe6
0036 
0037 #define MP2975_VOUT_FORMAT      BIT(15)
0038 #define MP2975_VID_STEP_SEL_R1      BIT(4)
0039 #define MP2975_IMVP9_EN_R1      BIT(13)
0040 #define MP2975_VID_STEP_SEL_R2      BIT(3)
0041 #define MP2975_IMVP9_EN_R2      BIT(12)
0042 #define MP2975_PRT_THRES_DIV_OV_EN  BIT(14)
0043 #define MP2975_DRMOS_KCS        GENMASK(13, 12)
0044 #define MP2975_PROT_DEV_OV_OFF      10
0045 #define MP2975_PROT_DEV_OV_ON       5
0046 #define MP2975_SENSE_AMPL       BIT(11)
0047 #define MP2975_SENSE_AMPL_UNIT      1
0048 #define MP2975_SENSE_AMPL_HALF      2
0049 #define MP2975_VIN_UV_LIMIT_UNIT    8
0050 
0051 #define MP2975_MAX_PHASE_RAIL1  8
0052 #define MP2975_MAX_PHASE_RAIL2  4
0053 #define MP2975_PAGE_NUM     2
0054 
0055 #define MP2975_RAIL2_FUNC   (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | \
0056                  PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | \
0057                  PMBUS_HAVE_POUT | PMBUS_PHASE_VIRTUAL)
0058 
0059 struct mp2975_data {
0060     struct pmbus_driver_info info;
0061     int vout_scale;
0062     int vid_step[MP2975_PAGE_NUM];
0063     int vref[MP2975_PAGE_NUM];
0064     int vref_off[MP2975_PAGE_NUM];
0065     int vout_max[MP2975_PAGE_NUM];
0066     int vout_ov_fixed[MP2975_PAGE_NUM];
0067     int vout_format[MP2975_PAGE_NUM];
0068     int curr_sense_gain[MP2975_PAGE_NUM];
0069 };
0070 
0071 #define to_mp2975_data(x)  container_of(x, struct mp2975_data, info)
0072 
0073 static int mp2975_read_byte_data(struct i2c_client *client, int page, int reg)
0074 {
0075     switch (reg) {
0076     case PMBUS_VOUT_MODE:
0077         /*
0078          * Enforce VOUT direct format, since device allows to set the
0079          * different formats for the different rails. Conversion from
0080          * VID to direct provided by driver internally, in case it is
0081          * necessary.
0082          */
0083         return PB_VOUT_MODE_DIRECT;
0084     default:
0085         return -ENODATA;
0086     }
0087 }
0088 
0089 static int
0090 mp2975_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg,
0091             u16 mask)
0092 {
0093     int ret = pmbus_read_word_data(client, page, phase, reg);
0094 
0095     return (ret > 0) ? ret & mask : ret;
0096 }
0097 
0098 static int
0099 mp2975_vid2direct(int vrf, int val)
0100 {
0101     switch (vrf) {
0102     case vr12:
0103         if (val >= 0x01)
0104             return 250 + (val - 1) * 5;
0105         break;
0106     case vr13:
0107         if (val >= 0x01)
0108             return 500 + (val - 1) * 10;
0109         break;
0110     case imvp9:
0111         if (val >= 0x01)
0112             return 200 + (val - 1) * 10;
0113         break;
0114     default:
0115         return -EINVAL;
0116     }
0117     return 0;
0118 }
0119 
0120 static int
0121 mp2975_read_phase(struct i2c_client *client, struct mp2975_data *data,
0122           int page, int phase, u8 reg)
0123 {
0124     int ph_curr, ret;
0125 
0126     ret = pmbus_read_word_data(client, page, phase, reg);
0127     if (ret < 0)
0128         return ret;
0129 
0130     if (!((phase + 1) % MP2975_PAGE_NUM))
0131         ret >>= 8;
0132     ret &= 0xff;
0133 
0134     /*
0135      * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs)
0136      * where:
0137      * - Kcs is the DrMOS current sense gain of power stage, which is
0138      *   obtained from the register MP2975_MFR_VR_CONFIG1, bits 13-12 with
0139      *   the following selection of DrMOS (data->curr_sense_gain[page]):
0140      *   00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A.
0141      * - Rcs is the internal phase current sense resistor which is constant
0142      *   value 1kΩ.
0143      */
0144     ph_curr = ret * 100 - 9800;
0145 
0146     /*
0147      * Current phase sensing, providing by the device is not accurate
0148      * for the light load. This because sampling of current occurrence of
0149      * bit weight has a big deviation for light load. For handling such
0150      * case phase current is represented as the maximum between the value
0151      * calculated  above and total rail current divided by number phases.
0152      */
0153     ret = pmbus_read_word_data(client, page, phase, PMBUS_READ_IOUT);
0154     if (ret < 0)
0155         return ret;
0156 
0157     return max_t(int, DIV_ROUND_CLOSEST(ret, data->info.phases[page]),
0158              DIV_ROUND_CLOSEST(ph_curr, data->curr_sense_gain[page]));
0159 }
0160 
0161 static int
0162 mp2975_read_phases(struct i2c_client *client, struct mp2975_data *data,
0163            int page, int phase)
0164 {
0165     int ret;
0166 
0167     if (page) {
0168         switch (phase) {
0169         case 0 ... 1:
0170             ret = mp2975_read_phase(client, data, page, phase,
0171                         MP2975_MFR_READ_CS7_8);
0172             break;
0173         case 2 ... 3:
0174             ret = mp2975_read_phase(client, data, page, phase,
0175                         MP2975_MFR_READ_CS9_10);
0176             break;
0177         case 4 ... 5:
0178             ret = mp2975_read_phase(client, data, page, phase,
0179                         MP2975_MFR_READ_CS11_12);
0180             break;
0181         default:
0182             return -ENODATA;
0183         }
0184     } else {
0185         switch (phase) {
0186         case 0 ... 1:
0187             ret = mp2975_read_phase(client, data, page, phase,
0188                         MP2975_MFR_READ_CS1_2);
0189             break;
0190         case 2 ... 3:
0191             ret = mp2975_read_phase(client, data, page, phase,
0192                         MP2975_MFR_READ_CS3_4);
0193             break;
0194         case 4 ... 5:
0195             ret = mp2975_read_phase(client, data, page, phase,
0196                         MP2975_MFR_READ_CS5_6);
0197             break;
0198         case 6 ... 7:
0199             ret = mp2975_read_phase(client, data, page, phase,
0200                         MP2975_MFR_READ_CS7_8);
0201             break;
0202         case 8 ... 9:
0203             ret = mp2975_read_phase(client, data, page, phase,
0204                         MP2975_MFR_READ_CS9_10);
0205             break;
0206         case 10 ... 11:
0207             ret = mp2975_read_phase(client, data, page, phase,
0208                         MP2975_MFR_READ_CS11_12);
0209             break;
0210         default:
0211             return -ENODATA;
0212         }
0213     }
0214     return ret;
0215 }
0216 
0217 static int mp2975_read_word_data(struct i2c_client *client, int page,
0218                  int phase, int reg)
0219 {
0220     const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
0221     struct mp2975_data *data = to_mp2975_data(info);
0222     int ret;
0223 
0224     switch (reg) {
0225     case PMBUS_OT_FAULT_LIMIT:
0226         ret = mp2975_read_word_helper(client, page, phase, reg,
0227                           GENMASK(7, 0));
0228         break;
0229     case PMBUS_VIN_OV_FAULT_LIMIT:
0230         ret = mp2975_read_word_helper(client, page, phase, reg,
0231                           GENMASK(7, 0));
0232         if (ret < 0)
0233             return ret;
0234 
0235         ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT);
0236         break;
0237     case PMBUS_VOUT_OV_FAULT_LIMIT:
0238         /*
0239          * Register provides two values for over-voltage protection
0240          * threshold for fixed (ovp2) and tracking (ovp1) modes. The
0241          * minimum of these two values is provided as over-voltage
0242          * fault alarm.
0243          */
0244         ret = mp2975_read_word_helper(client, page, phase,
0245                           MP2975_MFR_OVP_TH_SET,
0246                           GENMASK(2, 0));
0247         if (ret < 0)
0248             return ret;
0249 
0250         ret = min_t(int, data->vout_max[page] + 50 * (ret + 1),
0251                 data->vout_ov_fixed[page]);
0252         break;
0253     case PMBUS_VOUT_UV_FAULT_LIMIT:
0254         ret = mp2975_read_word_helper(client, page, phase,
0255                           MP2975_MFR_UVP_SET,
0256                           GENMASK(2, 0));
0257         if (ret < 0)
0258             return ret;
0259 
0260         ret = DIV_ROUND_CLOSEST(data->vref[page] * 10 - 50 *
0261                     (ret + 1) * data->vout_scale, 10);
0262         break;
0263     case PMBUS_READ_VOUT:
0264         ret = mp2975_read_word_helper(client, page, phase, reg,
0265                           GENMASK(11, 0));
0266         if (ret < 0)
0267             return ret;
0268 
0269         /*
0270          * READ_VOUT can be provided in VID or direct format. The
0271          * format type is specified by bit 15 of the register
0272          * MP2975_MFR_DC_LOOP_CTRL. The driver enforces VOUT direct
0273          * format, since device allows to set the different formats for
0274          * the different rails and also all VOUT limits registers are
0275          * provided in a direct format. In case format is VID - convert
0276          * to direct.
0277          */
0278         if (data->vout_format[page] == vid)
0279             ret = mp2975_vid2direct(info->vrm_version[page], ret);
0280         break;
0281     case PMBUS_VIRT_READ_POUT_MAX:
0282         ret = mp2975_read_word_helper(client, page, phase,
0283                           MP2975_MFR_READ_POUT_PK,
0284                           GENMASK(12, 0));
0285         if (ret < 0)
0286             return ret;
0287 
0288         ret = DIV_ROUND_CLOSEST(ret, 4);
0289         break;
0290     case PMBUS_VIRT_READ_IOUT_MAX:
0291         ret = mp2975_read_word_helper(client, page, phase,
0292                           MP2975_MFR_READ_IOUT_PK,
0293                           GENMASK(12, 0));
0294         if (ret < 0)
0295             return ret;
0296 
0297         ret = DIV_ROUND_CLOSEST(ret, 4);
0298         break;
0299     case PMBUS_READ_IOUT:
0300         ret = mp2975_read_phases(client, data, page, phase);
0301         if (ret < 0)
0302             return ret;
0303 
0304         break;
0305     case PMBUS_UT_WARN_LIMIT:
0306     case PMBUS_UT_FAULT_LIMIT:
0307     case PMBUS_VIN_UV_WARN_LIMIT:
0308     case PMBUS_VIN_UV_FAULT_LIMIT:
0309     case PMBUS_VOUT_UV_WARN_LIMIT:
0310     case PMBUS_VOUT_OV_WARN_LIMIT:
0311     case PMBUS_VIN_OV_WARN_LIMIT:
0312     case PMBUS_IIN_OC_FAULT_LIMIT:
0313     case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
0314     case PMBUS_IIN_OC_WARN_LIMIT:
0315     case PMBUS_IOUT_OC_WARN_LIMIT:
0316     case PMBUS_IOUT_OC_FAULT_LIMIT:
0317     case PMBUS_IOUT_UC_FAULT_LIMIT:
0318     case PMBUS_POUT_OP_FAULT_LIMIT:
0319     case PMBUS_POUT_OP_WARN_LIMIT:
0320     case PMBUS_PIN_OP_WARN_LIMIT:
0321         return -ENXIO;
0322     default:
0323         return -ENODATA;
0324     }
0325 
0326     return ret;
0327 }
0328 
0329 static int mp2975_identify_multiphase_rail2(struct i2c_client *client)
0330 {
0331     int ret;
0332 
0333     /*
0334      * Identify multiphase for rail 2 - could be from 0 to 4.
0335      * In case phase number is zero – only page zero is supported
0336      */
0337     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
0338     if (ret < 0)
0339         return ret;
0340 
0341     /* Identify multiphase for rail 2 - could be from 0 to 4. */
0342     ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R2);
0343     if (ret < 0)
0344         return ret;
0345 
0346     ret &= GENMASK(2, 0);
0347     return (ret >= 4) ? 4 : ret;
0348 }
0349 
0350 static void mp2975_set_phase_rail1(struct pmbus_driver_info *info)
0351 {
0352     int i;
0353 
0354     for (i = 0 ; i < info->phases[0]; i++)
0355         info->pfunc[i] = PMBUS_HAVE_IOUT;
0356 }
0357 
0358 static void
0359 mp2975_set_phase_rail2(struct pmbus_driver_info *info, int num_phases)
0360 {
0361     int i;
0362 
0363     /* Set phases for rail 2 from upper to lower. */
0364     for (i = 1; i <= num_phases; i++)
0365         info->pfunc[MP2975_MAX_PHASE_RAIL1 - i] = PMBUS_HAVE_IOUT;
0366 }
0367 
0368 static int
0369 mp2975_identify_multiphase(struct i2c_client *client, struct mp2975_data *data,
0370                struct pmbus_driver_info *info)
0371 {
0372     int num_phases2, ret;
0373 
0374     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
0375     if (ret < 0)
0376         return ret;
0377 
0378     /* Identify multiphase for rail 1 - could be from 1 to 8. */
0379     ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R1);
0380     if (ret <= 0)
0381         return ret;
0382 
0383     info->phases[0] = ret & GENMASK(3, 0);
0384 
0385     /*
0386      * The device provides a total of 8 PWM pins, and can be configured
0387      * to different phase count applications for rail 1 and rail 2.
0388      * Rail 1 can be set to 8 phases, while rail 2 can only be set to 4
0389      * phases at most. When rail 1’s phase count is configured as 0, rail
0390      * 1 operates with 1-phase DCM. When rail 2 phase count is configured
0391      * as 0, rail 2 is disabled.
0392      */
0393     if (info->phases[0] > MP2975_MAX_PHASE_RAIL1)
0394         return -EINVAL;
0395 
0396     mp2975_set_phase_rail1(info);
0397     num_phases2 = min(MP2975_MAX_PHASE_RAIL1 - info->phases[0],
0398               MP2975_MAX_PHASE_RAIL2);
0399     if (info->phases[1] && info->phases[1] <= num_phases2)
0400         mp2975_set_phase_rail2(info, num_phases2);
0401 
0402     return 0;
0403 }
0404 
0405 static int
0406 mp2975_identify_vid(struct i2c_client *client, struct mp2975_data *data,
0407             struct pmbus_driver_info *info, u32 reg, int page,
0408             u32 imvp_bit, u32 vr_bit)
0409 {
0410     int ret;
0411 
0412     /* Identify VID mode and step selection. */
0413     ret = i2c_smbus_read_word_data(client, reg);
0414     if (ret < 0)
0415         return ret;
0416 
0417     if (ret & imvp_bit) {
0418         info->vrm_version[page] = imvp9;
0419         data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
0420     } else if (ret & vr_bit) {
0421         info->vrm_version[page] = vr12;
0422         data->vid_step[page] = MP2975_PROT_DEV_OV_ON;
0423     } else {
0424         info->vrm_version[page] = vr13;
0425         data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
0426     }
0427 
0428     return 0;
0429 }
0430 
0431 static int
0432 mp2975_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data,
0433               struct pmbus_driver_info *info)
0434 {
0435     int ret;
0436 
0437     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
0438     if (ret < 0)
0439         return ret;
0440 
0441     /* Identify VID mode for rail 1. */
0442     ret = mp2975_identify_vid(client, data, info,
0443                   MP2975_MFR_VR_MULTI_CONFIG_R1, 0,
0444                   MP2975_IMVP9_EN_R1, MP2975_VID_STEP_SEL_R1);
0445     if (ret < 0)
0446         return ret;
0447 
0448     /* Identify VID mode for rail 2, if connected. */
0449     if (info->phases[1])
0450         ret = mp2975_identify_vid(client, data, info,
0451                       MP2975_MFR_VR_MULTI_CONFIG_R2, 1,
0452                       MP2975_IMVP9_EN_R2,
0453                       MP2975_VID_STEP_SEL_R2);
0454     return ret;
0455 }
0456 
0457 static int
0458 mp2975_current_sense_gain_get(struct i2c_client *client,
0459                   struct mp2975_data *data)
0460 {
0461     int i, ret;
0462 
0463     /*
0464      * Obtain DrMOS current sense gain of power stage from the register
0465      * MP2975_MFR_VR_CONFIG1, bits 13-12. The value is selected as below:
0466      * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
0467      * values are invalid.
0468      */
0469     for (i = 0 ; i < data->info.pages; i++) {
0470         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
0471         if (ret < 0)
0472             return ret;
0473         ret = i2c_smbus_read_word_data(client,
0474                            MP2975_MFR_VR_CONFIG1);
0475         if (ret < 0)
0476             return ret;
0477 
0478         switch ((ret & MP2975_DRMOS_KCS) >> 12) {
0479         case 0:
0480             data->curr_sense_gain[i] = 50;
0481             break;
0482         case 1:
0483             data->curr_sense_gain[i] = 85;
0484             break;
0485         case 2:
0486             data->curr_sense_gain[i] = 97;
0487             break;
0488         default:
0489             data->curr_sense_gain[i] = 100;
0490             break;
0491         }
0492     }
0493 
0494     return 0;
0495 }
0496 
0497 static int
0498 mp2975_vref_get(struct i2c_client *client, struct mp2975_data *data,
0499         struct pmbus_driver_info *info)
0500 {
0501     int ret;
0502 
0503     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 3);
0504     if (ret < 0)
0505         return ret;
0506 
0507     /* Get voltage reference value for rail 1. */
0508     ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R1);
0509     if (ret < 0)
0510         return ret;
0511 
0512     data->vref[0] = ret * data->vid_step[0];
0513 
0514     /* Get voltage reference value for rail 2, if connected. */
0515     if (data->info.pages == MP2975_PAGE_NUM) {
0516         ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R2);
0517         if (ret < 0)
0518             return ret;
0519 
0520         data->vref[1] = ret * data->vid_step[1];
0521     }
0522     return 0;
0523 }
0524 
0525 static int
0526 mp2975_vref_offset_get(struct i2c_client *client, struct mp2975_data *data,
0527                int page)
0528 {
0529     int ret;
0530 
0531     ret = i2c_smbus_read_word_data(client, MP2975_MFR_OVP_TH_SET);
0532     if (ret < 0)
0533         return ret;
0534 
0535     switch ((ret & GENMASK(5, 3)) >> 3) {
0536     case 1:
0537         data->vref_off[page] = 140;
0538         break;
0539     case 2:
0540         data->vref_off[page] = 220;
0541         break;
0542     case 4:
0543         data->vref_off[page] = 400;
0544         break;
0545     default:
0546         return -EINVAL;
0547     }
0548     return 0;
0549 }
0550 
0551 static int
0552 mp2975_vout_max_get(struct i2c_client *client, struct mp2975_data *data,
0553             struct pmbus_driver_info *info, int page)
0554 {
0555     int ret;
0556 
0557     /* Get maximum reference voltage of VID-DAC in VID format. */
0558     ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_MAX);
0559     if (ret < 0)
0560         return ret;
0561 
0562     data->vout_max[page] = mp2975_vid2direct(info->vrm_version[page], ret &
0563                          GENMASK(8, 0));
0564     return 0;
0565 }
0566 
0567 static int
0568 mp2975_identify_vout_format(struct i2c_client *client,
0569                 struct mp2975_data *data, int page)
0570 {
0571     int ret;
0572 
0573     ret = i2c_smbus_read_word_data(client, MP2975_MFR_DC_LOOP_CTRL);
0574     if (ret < 0)
0575         return ret;
0576 
0577     if (ret & MP2975_VOUT_FORMAT)
0578         data->vout_format[page] = vid;
0579     else
0580         data->vout_format[page] = direct;
0581     return 0;
0582 }
0583 
0584 static int
0585 mp2975_vout_ov_scale_get(struct i2c_client *client, struct mp2975_data *data,
0586              struct pmbus_driver_info *info)
0587 {
0588     int thres_dev, sense_ampl, ret;
0589 
0590     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
0591     if (ret < 0)
0592         return ret;
0593 
0594     /*
0595      * Get divider for over- and under-voltage protection thresholds
0596      * configuration from the Advanced Options of Auto Phase Shedding and
0597      * decay register.
0598      */
0599     ret = i2c_smbus_read_word_data(client, MP2975_MFR_APS_DECAY_ADV);
0600     if (ret < 0)
0601         return ret;
0602     thres_dev = ret & MP2975_PRT_THRES_DIV_OV_EN ? MP2975_PROT_DEV_OV_ON :
0603                                                    MP2975_PROT_DEV_OV_OFF;
0604 
0605     /* Select the gain of remote sense amplifier. */
0606     ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_SCALE_LOOP);
0607     if (ret < 0)
0608         return ret;
0609     sense_ampl = ret & MP2975_SENSE_AMPL ? MP2975_SENSE_AMPL_HALF :
0610                            MP2975_SENSE_AMPL_UNIT;
0611 
0612     data->vout_scale = sense_ampl * thres_dev;
0613 
0614     return 0;
0615 }
0616 
0617 static int
0618 mp2975_vout_per_rail_config_get(struct i2c_client *client,
0619                 struct mp2975_data *data,
0620                 struct pmbus_driver_info *info)
0621 {
0622     int i, ret;
0623 
0624     for (i = 0; i < data->info.pages; i++) {
0625         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
0626         if (ret < 0)
0627             return ret;
0628 
0629         /* Obtain voltage reference offsets. */
0630         ret = mp2975_vref_offset_get(client, data, i);
0631         if (ret < 0)
0632             return ret;
0633 
0634         /* Obtain maximum voltage values. */
0635         ret = mp2975_vout_max_get(client, data, info, i);
0636         if (ret < 0)
0637             return ret;
0638 
0639         /*
0640          * Get VOUT format for READ_VOUT command : VID or direct.
0641          * Pages on same device can be configured with different
0642          * formats.
0643          */
0644         ret = mp2975_identify_vout_format(client, data, i);
0645         if (ret < 0)
0646             return ret;
0647 
0648         /*
0649          * Set over-voltage fixed value. Thresholds are provided as
0650          * fixed value, and tracking value. The minimum of them are
0651          * exposed as over-voltage critical threshold.
0652          */
0653         data->vout_ov_fixed[i] = data->vref[i] +
0654                      DIV_ROUND_CLOSEST(data->vref_off[i] *
0655                                data->vout_scale,
0656                                10);
0657     }
0658 
0659     return 0;
0660 }
0661 
0662 static struct pmbus_driver_info mp2975_info = {
0663     .pages = 1,
0664     .format[PSC_VOLTAGE_IN] = linear,
0665     .format[PSC_VOLTAGE_OUT] = direct,
0666     .format[PSC_TEMPERATURE] = direct,
0667     .format[PSC_CURRENT_IN] = linear,
0668     .format[PSC_CURRENT_OUT] = direct,
0669     .format[PSC_POWER] = direct,
0670     .m[PSC_TEMPERATURE] = 1,
0671     .m[PSC_VOLTAGE_OUT] = 1,
0672     .R[PSC_VOLTAGE_OUT] = 3,
0673     .m[PSC_CURRENT_OUT] = 1,
0674     .m[PSC_POWER] = 1,
0675     .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
0676         PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
0677         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
0678         PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | PMBUS_PHASE_VIRTUAL,
0679     .read_byte_data = mp2975_read_byte_data,
0680     .read_word_data = mp2975_read_word_data,
0681 };
0682 
0683 static int mp2975_probe(struct i2c_client *client)
0684 {
0685     struct pmbus_driver_info *info;
0686     struct mp2975_data *data;
0687     int ret;
0688 
0689     data = devm_kzalloc(&client->dev, sizeof(struct mp2975_data),
0690                 GFP_KERNEL);
0691     if (!data)
0692         return -ENOMEM;
0693 
0694     memcpy(&data->info, &mp2975_info, sizeof(*info));
0695     info = &data->info;
0696 
0697     /* Identify multiphase configuration for rail 2. */
0698     ret = mp2975_identify_multiphase_rail2(client);
0699     if (ret < 0)
0700         return ret;
0701 
0702     if (ret) {
0703         /* Two rails are connected. */
0704         data->info.pages = MP2975_PAGE_NUM;
0705         data->info.phases[1] = ret;
0706         data->info.func[1] = MP2975_RAIL2_FUNC;
0707     }
0708 
0709     /* Identify multiphase configuration. */
0710     ret = mp2975_identify_multiphase(client, data, info);
0711     if (ret)
0712         return ret;
0713 
0714     /* Identify VID setting per rail. */
0715     ret = mp2975_identify_rails_vid(client, data, info);
0716     if (ret < 0)
0717         return ret;
0718 
0719     /* Obtain current sense gain of power stage. */
0720     ret = mp2975_current_sense_gain_get(client, data);
0721     if (ret)
0722         return ret;
0723 
0724     /* Obtain voltage reference values. */
0725     ret = mp2975_vref_get(client, data, info);
0726     if (ret)
0727         return ret;
0728 
0729     /* Obtain vout over-voltage scales. */
0730     ret = mp2975_vout_ov_scale_get(client, data, info);
0731     if (ret < 0)
0732         return ret;
0733 
0734     /* Obtain offsets, maximum and format for vout. */
0735     ret = mp2975_vout_per_rail_config_get(client, data, info);
0736     if (ret)
0737         return ret;
0738 
0739     return pmbus_do_probe(client, info);
0740 }
0741 
0742 static const struct i2c_device_id mp2975_id[] = {
0743     {"mp2975", 0},
0744     {}
0745 };
0746 
0747 MODULE_DEVICE_TABLE(i2c, mp2975_id);
0748 
0749 static const struct of_device_id __maybe_unused mp2975_of_match[] = {
0750     {.compatible = "mps,mp2975"},
0751     {}
0752 };
0753 MODULE_DEVICE_TABLE(of, mp2975_of_match);
0754 
0755 static struct i2c_driver mp2975_driver = {
0756     .driver = {
0757         .name = "mp2975",
0758         .of_match_table = of_match_ptr(mp2975_of_match),
0759     },
0760     .probe_new = mp2975_probe,
0761     .id_table = mp2975_id,
0762 };
0763 
0764 module_i2c_driver(mp2975_driver);
0765 
0766 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
0767 MODULE_DESCRIPTION("PMBus driver for MPS MP2975 device");
0768 MODULE_LICENSE("GPL");
0769 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!