drivers/hwmon/pmbus/mp2975.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Hardware monitoring driver for MPS Multi-phase Digital VR Controllers
   4  *
   5  * Copyright (C) 2020 Nvidia Technologies Ltd.
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/i2c.h>
  10 #include <linux/init.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/of_device.h>
  14 #include "pmbus.h"
  15
  16 /* Vendor specific registers. */
  17 #define MP2975_MFR_APS_HYS_R2           0x0d
  18 #define MP2975_MFR_SLOPE_TRIM3          0x1d
  19 #define MP2975_MFR_VR_MULTI_CONFIG_R1   0x0d
  20 #define MP2975_MFR_VR_MULTI_CONFIG_R2   0x1d
  21 #define MP2975_MFR_APS_DECAY_ADV        0x56
  22 #define MP2975_MFR_DC_LOOP_CTRL         0x59
  23 #define MP2975_MFR_OCP_UCP_PHASE_SET    0x65
  24 #define MP2975_MFR_VR_CONFIG1           0x68
  25 #define MP2975_MFR_READ_CS1_2           0x82
  26 #define MP2975_MFR_READ_CS3_4           0x83
  27 #define MP2975_MFR_READ_CS5_6           0x84
  28 #define MP2975_MFR_READ_CS7_8           0x85
  29 #define MP2975_MFR_READ_CS9_10          0x86
  30 #define MP2975_MFR_READ_CS11_12         0x87
  31 #define MP2975_MFR_READ_IOUT_PK         0x90
  32 #define MP2975_MFR_READ_POUT_PK         0x91
  33 #define MP2975_MFR_READ_VREF_R1         0xa1
  34 #define MP2975_MFR_READ_VREF_R2         0xa3
  35 #define MP2975_MFR_OVP_TH_SET           0xe5
  36 #define MP2975_MFR_UVP_SET              0xe6
  37
  38 #define MP2973_MFR_RESO_SET             0xc7
  39
  40 #define MP2975_VOUT_FORMAT              BIT(15)
  41 #define MP2975_VID_STEP_SEL_R1          BIT(4)
  42 #define MP2975_IMVP9_EN_R1              BIT(13)
  43 #define MP2975_VID_STEP_SEL_R2          BIT(3)
  44 #define MP2975_IMVP9_EN_R2              BIT(12)
  45 #define MP2975_PRT_THRES_DIV_OV_EN      BIT(14)
  46 #define MP2975_DRMOS_KCS                GENMASK(13, 12)
  47 #define MP2975_PROT_DEV_OV_OFF          10
  48 #define MP2975_PROT_DEV_OV_ON           5
  49 #define MP2975_SENSE_AMPL               BIT(11)
  50 #define MP2975_SENSE_AMPL_UNIT          1
  51 #define MP2975_SENSE_AMPL_HALF          2
  52 #define MP2975_VIN_UV_LIMIT_UNIT        8
  53
  54 #define MP2973_VOUT_FORMAT_R1           GENMASK(7, 6)
  55 #define MP2973_VOUT_FORMAT_R2           GENMASK(4, 3)
  56 #define MP2973_VOUT_FORMAT_DIRECT_R1    BIT(7)
  57 #define MP2973_VOUT_FORMAT_LINEAR_R1    BIT(6)
  58 #define MP2973_VOUT_FORMAT_DIRECT_R2    BIT(4)
  59 #define MP2973_VOUT_FORMAT_LINEAR_R2    BIT(3)
  60
  61 #define MP2973_MFR_VR_MULTI_CONFIG_R1   0x0d
  62 #define MP2973_MFR_VR_MULTI_CONFIG_R2   0x1d
  63 #define MP2973_VID_STEP_SEL_R1          BIT(4)
  64 #define MP2973_IMVP9_EN_R1              BIT(14)
  65 #define MP2973_VID_STEP_SEL_R2          BIT(3)
  66 #define MP2973_IMVP9_EN_R2              BIT(13)
  67
  68 #define MP2973_MFR_OCP_TOTAL_SET        0x5f
  69 #define MP2973_OCP_TOTAL_CUR_MASK       GENMASK(6, 0)
  70 #define MP2973_MFR_OCP_LEVEL_RES        BIT(15)
  71
  72 #define MP2973_MFR_READ_IOUT_PK         0x90
  73 #define MP2973_MFR_READ_POUT_PK         0x91
  74
  75 #define MP2975_MAX_PHASE_RAIL1  8
  76 #define MP2975_MAX_PHASE_RAIL2  4
  77
  78 #define MP2973_MAX_PHASE_RAIL1  14
  79 #define MP2973_MAX_PHASE_RAIL2  6
  80
  81 #define MP2971_MAX_PHASE_RAIL1  8
  82 #define MP2971_MAX_PHASE_RAIL2  3
  83
  84 #define MP2975_PAGE_NUM         2
  85
  86 #define MP2975_RAIL2_FUNC       (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | \
  87                                  PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | \
  88                                  PMBUS_HAVE_POUT | PMBUS_PHASE_VIRTUAL)
  89
  90 enum chips {
  91         mp2971, mp2973, mp2975
  92 };
  93
  94 static const int mp2975_max_phases[][MP2975_PAGE_NUM] = {
  95         [mp2975] = { MP2975_MAX_PHASE_RAIL1, MP2975_MAX_PHASE_RAIL2 },
  96         [mp2973] = { MP2973_MAX_PHASE_RAIL1, MP2973_MAX_PHASE_RAIL2 },
  97         [mp2971] = { MP2971_MAX_PHASE_RAIL1, MP2971_MAX_PHASE_RAIL2 },
  98 };
  99
 100 struct mp2975_data {
 101         struct pmbus_driver_info info;
 102         enum chips chip_id;
 103         int vout_scale;
 104         int max_phases[MP2975_PAGE_NUM];
 105         int vid_step[MP2975_PAGE_NUM];
 106         int vref[MP2975_PAGE_NUM];
 107         int vref_off[MP2975_PAGE_NUM];
 108         int vout_max[MP2975_PAGE_NUM];
 109         int vout_ov_fixed[MP2975_PAGE_NUM];
 110         int curr_sense_gain[MP2975_PAGE_NUM];
 111 };
 112
 113 static const struct i2c_device_id mp2975_id[] = {
 114         {"mp2971", mp2971},
 115         {"mp2973", mp2973},
 116         {"mp2975", mp2975},
 117         {}
 118 };
 119
 120 MODULE_DEVICE_TABLE(i2c, mp2975_id);
 121
 122 static const struct regulator_desc __maybe_unused mp2975_reg_desc[] = {
 123         PMBUS_REGULATOR("vout", 0),
 124         PMBUS_REGULATOR("vout", 1),
 125 };
 126
 127 #define to_mp2975_data(x)  container_of(x, struct mp2975_data, info)
 128
 129 static int mp2975_read_byte_data(struct i2c_client *client, int page, int reg)
 130 {
 131         switch (reg) {
 132         case PMBUS_VOUT_MODE:
 133                 /*
 134                  * Report direct format as configured by MFR_DC_LOOP_CTRL.
 135                  * Unlike on MP2971/MP2973 the reported VOUT_MODE isn't automatically
 136                  * internally updated, but always reads as PB_VOUT_MODE_VID.
 137                  */
 138                 return PB_VOUT_MODE_DIRECT;
 139         default:
 140                 return -ENODATA;
 141         }
 142 }
 143
 144 static int
 145 mp2975_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg,
 146                         u16 mask)
 147 {
 148         int ret = pmbus_read_word_data(client, page, phase, reg);
 149
 150         return (ret > 0) ? ret & mask : ret;
 151 }
 152
 153 static int
 154 mp2975_vid2direct(int vrf, int val)
 155 {
 156         switch (vrf) {
 157         case vr12:
 158                 if (val >= 0x01)
 159                         return 250 + (val - 1) * 5;
 160                 break;
 161         case vr13:
 162                 if (val >= 0x01)
 163                         return 500 + (val - 1) * 10;
 164                 break;
 165         case imvp9:
 166                 if (val >= 0x01)
 167                         return 200 + (val - 1) * 10;
 168                 break;
 169         default:
 170                 return -EINVAL;
 171         }
 172         return 0;
 173 }
 174
 175 #define MAX_LIN_MANTISSA        (1023 * 1000)
 176 #define MIN_LIN_MANTISSA        (511 * 1000)
 177
 178 /* Converts a milli-unit DIRECT value to LINEAR11 format */
 179 static u16 mp2975_data2reg_linear11(s64 val)
 180 {
 181         s16 exponent = 0, mantissa;
 182         bool negative = false;
 183
 184         /* simple case */
 185         if (val == 0)
 186                 return 0;
 187
 188         /* Reduce large mantissa until it fits into 10 bit */
 189         while (val >= MAX_LIN_MANTISSA && exponent < 15) {
 190                 exponent++;
 191                 val >>= 1;
 192         }
 193         /* Increase small mantissa to improve precision */
 194         while (val < MIN_LIN_MANTISSA && exponent > -15) {
 195                 exponent--;
 196                 val <<= 1;
 197         }
 198
 199         /* Convert mantissa from milli-units to units */
 200         mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
 201
 202         /* restore sign */
 203         if (negative)
 204                 mantissa = -mantissa;
 205
 206         /* Convert to 5 bit exponent, 11 bit mantissa */
 207         return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
 208 }
 209
 210 static int
 211 mp2975_read_phase(struct i2c_client *client, struct mp2975_data *data,
 212                   int page, int phase, u8 reg)
 213 {
 214         int ph_curr, ret;
 215
 216         ret = pmbus_read_word_data(client, page, phase, reg);
 217         if (ret < 0)
 218                 return ret;
 219
 220         if (!((phase + 1) % MP2975_PAGE_NUM))
 221                 ret >>= 8;
 222         ret &= 0xff;
 223
 224         /*
 225          * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs)
 226          * where:
 227          * - Kcs is the DrMOS current sense gain of power stage, which is
 228          *   obtained from the register MP2975_MFR_VR_CONFIG1, bits 13-12 with
 229          *   the following selection of DrMOS (data->curr_sense_gain[page]):
 230          *   00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A.
 231          * - Rcs is the internal phase current sense resistor which is constant
 232          *   value 1kΩ.
 233          */
 234         ph_curr = ret * 100 - 9800;
 235
 236         /*
 237          * Current phase sensing, providing by the device is not accurate
 238          * for the light load. This because sampling of current occurrence of
 239          * bit weight has a big deviation for light load. For handling such
 240          * case phase current is represented as the maximum between the value
 241          * calculated  above and total rail current divided by number phases.
 242          */
 243         ret = pmbus_read_word_data(client, page, phase, PMBUS_READ_IOUT);
 244         if (ret < 0)
 245                 return ret;
 246
 247         return max_t(int, DIV_ROUND_CLOSEST(ret, data->info.phases[page]),
 248                      DIV_ROUND_CLOSEST(ph_curr, data->curr_sense_gain[page]));
 249 }
 250
 251 static int
 252 mp2975_read_phases(struct i2c_client *client, struct mp2975_data *data,
 253                    int page, int phase)
 254 {
 255         int ret;
 256
 257         if (page) {
 258                 switch (phase) {
 259                 case 0 ... 1:
 260                         ret = mp2975_read_phase(client, data, page, phase,
 261                                                 MP2975_MFR_READ_CS7_8);
 262                         break;
 263                 case 2 ... 3:
 264                         ret = mp2975_read_phase(client, data, page, phase,
 265                                                 MP2975_MFR_READ_CS9_10);
 266                         break;
 267                 case 4 ... 5:
 268                         ret = mp2975_read_phase(client, data, page, phase,
 269                                                 MP2975_MFR_READ_CS11_12);
 270                         break;
 271                 default:
 272                         return -ENODATA;
 273                 }
 274         } else {
 275                 switch (phase) {
 276                 case 0 ... 1:
 277                         ret = mp2975_read_phase(client, data, page, phase,
 278                                                 MP2975_MFR_READ_CS1_2);
 279                         break;
 280                 case 2 ... 3:
 281                         ret = mp2975_read_phase(client, data, page, phase,
 282                                                 MP2975_MFR_READ_CS3_4);
 283                         break;
 284                 case 4 ... 5:
 285                         ret = mp2975_read_phase(client, data, page, phase,
 286                                                 MP2975_MFR_READ_CS5_6);
 287                         break;
 288                 case 6 ... 7:
 289                         ret = mp2975_read_phase(client, data, page, phase,
 290                                                 MP2975_MFR_READ_CS7_8);
 291                         break;
 292                 case 8 ... 9:
 293                         ret = mp2975_read_phase(client, data, page, phase,
 294                                                 MP2975_MFR_READ_CS9_10);
 295                         break;
 296                 case 10 ... 11:
 297                         ret = mp2975_read_phase(client, data, page, phase,
 298                                                 MP2975_MFR_READ_CS11_12);
 299                         break;
 300                 default:
 301                         return -ENODATA;
 302                 }
 303         }
 304         return ret;
 305 }
 306
 307 static int mp2973_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 mp2975_data *data = to_mp2975_data(info);
 312         int ret;
 313
 314         switch (reg) {
 315         case PMBUS_STATUS_WORD:
 316                 /* MP2973 & MP2971 return PGOOD instead of PB_STATUS_POWER_GOOD_N. */
 317                 ret = pmbus_read_word_data(client, page, phase, reg);
 318                 ret ^= PB_STATUS_POWER_GOOD_N;
 319                 break;
 320         case PMBUS_OT_FAULT_LIMIT:
 321                 ret = mp2975_read_word_helper(client, page, phase, reg,
 322                                               GENMASK(7, 0));
 323                 break;
 324         case PMBUS_VIN_OV_FAULT_LIMIT:
 325                 ret = mp2975_read_word_helper(client, page, phase, reg,
 326                                               GENMASK(7, 0));
 327                 if (ret < 0)
 328                         return ret;
 329
 330                 ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT);
 331                 break;
 332         case PMBUS_VOUT_OV_FAULT_LIMIT:
 333                 /*
 334                  * MP2971 and mp2973 only supports tracking (ovp1) mode.
 335                  */
 336                 ret = mp2975_read_word_helper(client, page, phase,
 337                                               MP2975_MFR_OVP_TH_SET,
 338                                               GENMASK(2, 0));
 339                 if (ret < 0)
 340                         return ret;
 341
 342                 ret = data->vout_max[page] + 50 * (ret + 1);
 343                 break;
 344         case PMBUS_VOUT_UV_FAULT_LIMIT:
 345                 ret = mp2975_read_word_helper(client, page, phase, reg,
 346                                               GENMASK(8, 0));
 347                 if (ret < 0)
 348                         return ret;
 349                 ret = mp2975_vid2direct(info->vrm_version[page], ret);
 350                 break;
 351         case PMBUS_VIRT_READ_POUT_MAX:
 352                 ret = pmbus_read_word_data(client, page, phase,
 353                                            MP2973_MFR_READ_POUT_PK);
 354                 break;
 355         case PMBUS_VIRT_READ_IOUT_MAX:
 356                 ret = pmbus_read_word_data(client, page, phase,
 357                                            MP2973_MFR_READ_IOUT_PK);
 358                 break;
 359         case PMBUS_IOUT_OC_FAULT_LIMIT:
 360                 ret = mp2975_read_word_helper(client, page, phase,
 361                                               MP2973_MFR_OCP_TOTAL_SET,
 362                                               GENMASK(15, 0));
 363                 if (ret < 0)
 364                         return ret;
 365
 366                 if (ret & MP2973_MFR_OCP_LEVEL_RES)
 367                         ret = 2 * (ret & MP2973_OCP_TOTAL_CUR_MASK);
 368                 else
 369                         ret = ret & MP2973_OCP_TOTAL_CUR_MASK;
 370
 371                 ret = mp2975_data2reg_linear11(ret * info->phases[page] * 1000);
 372                 break;
 373         case PMBUS_UT_WARN_LIMIT:
 374         case PMBUS_UT_FAULT_LIMIT:
 375         case PMBUS_VIN_UV_WARN_LIMIT:
 376         case PMBUS_VIN_UV_FAULT_LIMIT:
 377         case PMBUS_VOUT_UV_WARN_LIMIT:
 378         case PMBUS_VOUT_OV_WARN_LIMIT:
 379         case PMBUS_VIN_OV_WARN_LIMIT:
 380         case PMBUS_IIN_OC_FAULT_LIMIT:
 381         case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
 382         case PMBUS_IOUT_OC_WARN_LIMIT:
 383         case PMBUS_IOUT_UC_FAULT_LIMIT:
 384         case PMBUS_POUT_OP_FAULT_LIMIT:
 385         case PMBUS_POUT_OP_WARN_LIMIT:
 386         case PMBUS_PIN_OP_WARN_LIMIT:
 387                 return -ENXIO;
 388         default:
 389                 return -ENODATA;
 390         }
 391
 392         return ret;
 393 }
 394
 395 static int mp2975_read_word_data(struct i2c_client *client, int page,
 396                                  int phase, int reg)
 397 {
 398         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 399         struct mp2975_data *data = to_mp2975_data(info);
 400         int ret;
 401
 402         switch (reg) {
 403         case PMBUS_OT_FAULT_LIMIT:
 404                 ret = mp2975_read_word_helper(client, page, phase, reg,
 405                                               GENMASK(7, 0));
 406                 break;
 407         case PMBUS_VIN_OV_FAULT_LIMIT:
 408                 ret = mp2975_read_word_helper(client, page, phase, reg,
 409                                               GENMASK(7, 0));
 410                 if (ret < 0)
 411                         return ret;
 412
 413                 ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT);
 414                 break;
 415         case PMBUS_VOUT_OV_FAULT_LIMIT:
 416                 /*
 417                  * Register provides two values for over-voltage protection
 418                  * threshold for fixed (ovp2) and tracking (ovp1) modes. The
 419                  * minimum of these two values is provided as over-voltage
 420                  * fault alarm.
 421                  */
 422                 ret = mp2975_read_word_helper(client, page, phase,
 423                                               MP2975_MFR_OVP_TH_SET,
 424                                               GENMASK(2, 0));
 425                 if (ret < 0)
 426                         return ret;
 427
 428                 ret = min_t(int, data->vout_max[page] + 50 * (ret + 1),
 429                             data->vout_ov_fixed[page]);
 430                 break;
 431         case PMBUS_VOUT_UV_FAULT_LIMIT:
 432                 ret = mp2975_read_word_helper(client, page, phase,
 433                                               MP2975_MFR_UVP_SET,
 434                                               GENMASK(2, 0));
 435                 if (ret < 0)
 436                         return ret;
 437
 438                 ret = DIV_ROUND_CLOSEST(data->vref[page] * 10 - 50 *
 439                                         (ret + 1) * data->vout_scale, 10);
 440                 break;
 441         case PMBUS_VIRT_READ_POUT_MAX:
 442                 ret = mp2975_read_word_helper(client, page, phase,
 443                                               MP2975_MFR_READ_POUT_PK,
 444                                               GENMASK(12, 0));
 445                 if (ret < 0)
 446                         return ret;
 447
 448                 ret = DIV_ROUND_CLOSEST(ret, 4);
 449                 break;
 450         case PMBUS_VIRT_READ_IOUT_MAX:
 451                 ret = mp2975_read_word_helper(client, page, phase,
 452                                               MP2975_MFR_READ_IOUT_PK,
 453                                               GENMASK(12, 0));
 454                 if (ret < 0)
 455                         return ret;
 456
 457                 ret = DIV_ROUND_CLOSEST(ret, 4);
 458                 break;
 459         case PMBUS_READ_IOUT:
 460                 ret = mp2975_read_phases(client, data, page, phase);
 461                 if (ret < 0)
 462                         return ret;
 463
 464                 break;
 465         case PMBUS_UT_WARN_LIMIT:
 466         case PMBUS_UT_FAULT_LIMIT:
 467         case PMBUS_VIN_UV_WARN_LIMIT:
 468         case PMBUS_VIN_UV_FAULT_LIMIT:
 469         case PMBUS_VOUT_UV_WARN_LIMIT:
 470         case PMBUS_VOUT_OV_WARN_LIMIT:
 471         case PMBUS_VIN_OV_WARN_LIMIT:
 472         case PMBUS_IIN_OC_FAULT_LIMIT:
 473         case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
 474         case PMBUS_IIN_OC_WARN_LIMIT:
 475         case PMBUS_IOUT_OC_WARN_LIMIT:
 476         case PMBUS_IOUT_OC_FAULT_LIMIT:
 477         case PMBUS_IOUT_UC_FAULT_LIMIT:
 478         case PMBUS_POUT_OP_FAULT_LIMIT:
 479         case PMBUS_POUT_OP_WARN_LIMIT:
 480         case PMBUS_PIN_OP_WARN_LIMIT:
 481                 return -ENXIO;
 482         default:
 483                 return -ENODATA;
 484         }
 485
 486         return ret;
 487 }
 488
 489 static int mp2975_identify_multiphase_rail2(struct i2c_client *client,
 490                                             struct mp2975_data *data)
 491 {
 492         int ret;
 493
 494         /*
 495          * Identify multiphase for rail 2 - could be from 0 to data->max_phases[1].
 496          * In case phase number is zero – only page zero is supported
 497          */
 498         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
 499         if (ret < 0)
 500                 return ret;
 501
 502         ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R2);
 503         if (ret < 0)
 504                 return ret;
 505
 506         ret &= GENMASK(2, 0);
 507         return (ret >= data->max_phases[1]) ? data->max_phases[1] : ret;
 508 }
 509
 510 static void mp2975_set_phase_rail1(struct pmbus_driver_info *info)
 511 {
 512         int i;
 513
 514         for (i = 0 ; i < info->phases[0]; i++)
 515                 info->pfunc[i] = PMBUS_HAVE_IOUT;
 516 }
 517
 518 static void
 519 mp2975_set_phase_rail2(struct pmbus_driver_info *info, int num_phases)
 520 {
 521         int i;
 522
 523         /* Set phases for rail 2 from upper to lower. */
 524         for (i = 1; i <= num_phases; i++)
 525                 info->pfunc[MP2975_MAX_PHASE_RAIL1 - i] = PMBUS_HAVE_IOUT;
 526 }
 527
 528 static int
 529 mp2975_identify_multiphase(struct i2c_client *client, struct mp2975_data *data,
 530                            struct pmbus_driver_info *info)
 531 {
 532         int num_phases2, ret;
 533
 534         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
 535         if (ret < 0)
 536                 return ret;
 537
 538         /* Identify multiphase for rail 1 - could be from 1 to data->max_phases[0]. */
 539         ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R1);
 540         if (ret <= 0)
 541                 return ret;
 542
 543         info->phases[0] = ret & GENMASK(3, 0);
 544
 545         /*
 546          * The device provides a total of $n PWM pins, and can be configured
 547          * to different phase count applications for rail 1 and rail 2.
 548          * Rail 1 can be set to $n phases, while rail 2 can be set to less than
 549          * that. When rail 1’s phase count is configured as 0, rail
 550          * 1 operates with 1-phase DCM. When rail 2 phase count is configured
 551          * as 0, rail 2 is disabled.
 552          */
 553         if (info->phases[0] > data->max_phases[0])
 554                 return -EINVAL;
 555
 556         if (data->chip_id == mp2975) {
 557                 mp2975_set_phase_rail1(info);
 558                 num_phases2 = min(data->max_phases[0] - info->phases[0],
 559                                   data->max_phases[1]);
 560                 if (info->phases[1] && info->phases[1] <= num_phases2)
 561                         mp2975_set_phase_rail2(info, num_phases2);
 562         }
 563
 564         return 0;
 565 }
 566
 567 static int
 568 mp2975_identify_vid(struct i2c_client *client, struct mp2975_data *data,
 569                     struct pmbus_driver_info *info, u32 reg, int page,
 570                     u32 imvp_bit, u32 vr_bit)
 571 {
 572         int ret;
 573
 574         /* Identify VID mode and step selection. */
 575         ret = i2c_smbus_read_word_data(client, reg);
 576         if (ret < 0)
 577                 return ret;
 578
 579         if (ret & imvp_bit) {
 580                 info->vrm_version[page] = imvp9;
 581                 data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
 582         } else if (ret & vr_bit) {
 583                 info->vrm_version[page] = vr12;
 584                 data->vid_step[page] = MP2975_PROT_DEV_OV_ON;
 585         } else {
 586                 info->vrm_version[page] = vr13;
 587                 data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
 588         }
 589
 590         return 0;
 591 }
 592
 593 static int
 594 mp2975_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data,
 595                           struct pmbus_driver_info *info)
 596 {
 597         int ret;
 598
 599         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
 600         if (ret < 0)
 601                 return ret;
 602
 603         /* Identify VID mode for rail 1. */
 604         ret = mp2975_identify_vid(client, data, info,
 605                                   MP2975_MFR_VR_MULTI_CONFIG_R1, 0,
 606                                   MP2975_IMVP9_EN_R1, MP2975_VID_STEP_SEL_R1);
 607         if (ret < 0)
 608                 return ret;
 609
 610         /* Identify VID mode for rail 2, if connected. */
 611         if (info->phases[1])
 612                 ret = mp2975_identify_vid(client, data, info,
 613                                           MP2975_MFR_VR_MULTI_CONFIG_R2, 1,
 614                                           MP2975_IMVP9_EN_R2,
 615                                           MP2975_VID_STEP_SEL_R2);
 616
 617         return ret;
 618 }
 619
 620 static int
 621 mp2973_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data,
 622                           struct pmbus_driver_info *info)
 623 {
 624         int ret;
 625
 626         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
 627         if (ret < 0)
 628                 return ret;
 629
 630         /* Identify VID mode for rail 1. */
 631         ret = mp2975_identify_vid(client, data, info,
 632                                   MP2973_MFR_VR_MULTI_CONFIG_R1, 0,
 633                                   MP2973_IMVP9_EN_R1, MP2973_VID_STEP_SEL_R1);
 634
 635         if (ret < 0)
 636                 return ret;
 637
 638         /* Identify VID mode for rail 2, if connected. */
 639         if (info->phases[1])
 640                 ret = mp2975_identify_vid(client, data, info,
 641                                           MP2973_MFR_VR_MULTI_CONFIG_R2, 1,
 642                                           MP2973_IMVP9_EN_R2,
 643                                           MP2973_VID_STEP_SEL_R2);
 644
 645         return ret;
 646 }
 647
 648 static int
 649 mp2975_current_sense_gain_get(struct i2c_client *client,
 650                               struct mp2975_data *data)
 651 {
 652         int i, ret;
 653
 654         /*
 655          * Obtain DrMOS current sense gain of power stage from the register
 656          * MP2975_MFR_VR_CONFIG1, bits 13-12. The value is selected as below:
 657          * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
 658          * values are invalid.
 659          */
 660         for (i = 0 ; i < data->info.pages; i++) {
 661                 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
 662                 if (ret < 0)
 663                         return ret;
 664                 ret = i2c_smbus_read_word_data(client,
 665                                                MP2975_MFR_VR_CONFIG1);
 666                 if (ret < 0)
 667                         return ret;
 668
 669                 switch ((ret & MP2975_DRMOS_KCS) >> 12) {
 670                 case 0:
 671                         data->curr_sense_gain[i] = 50;
 672                         break;
 673                 case 1:
 674                         data->curr_sense_gain[i] = 85;
 675                         break;
 676                 case 2:
 677                         data->curr_sense_gain[i] = 97;
 678                         break;
 679                 default:
 680                         data->curr_sense_gain[i] = 100;
 681                         break;
 682                 }
 683         }
 684
 685         return 0;
 686 }
 687
 688 static int
 689 mp2975_vref_get(struct i2c_client *client, struct mp2975_data *data,
 690                 struct pmbus_driver_info *info)
 691 {
 692         int ret;
 693
 694         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 3);
 695         if (ret < 0)
 696                 return ret;
 697
 698         /* Get voltage reference value for rail 1. */
 699         ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R1);
 700         if (ret < 0)
 701                 return ret;
 702
 703         data->vref[0] = ret * data->vid_step[0];
 704
 705         /* Get voltage reference value for rail 2, if connected. */
 706         if (data->info.pages == MP2975_PAGE_NUM) {
 707                 ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R2);
 708                 if (ret < 0)
 709                         return ret;
 710
 711                 data->vref[1] = ret * data->vid_step[1];
 712         }
 713         return 0;
 714 }
 715
 716 static int
 717 mp2975_vref_offset_get(struct i2c_client *client, struct mp2975_data *data,
 718                        int page)
 719 {
 720         int ret;
 721
 722         ret = i2c_smbus_read_word_data(client, MP2975_MFR_OVP_TH_SET);
 723         if (ret < 0)
 724                 return ret;
 725
 726         switch ((ret & GENMASK(5, 3)) >> 3) {
 727         case 1:
 728                 data->vref_off[page] = 140;
 729                 break;
 730         case 2:
 731                 data->vref_off[page] = 220;
 732                 break;
 733         case 4:
 734                 data->vref_off[page] = 400;
 735                 break;
 736         default:
 737                 return -EINVAL;
 738         }
 739         return 0;
 740 }
 741
 742 static int
 743 mp2975_vout_max_get(struct i2c_client *client, struct mp2975_data *data,
 744                     struct pmbus_driver_info *info, int page)
 745 {
 746         int ret;
 747
 748         /* Get maximum reference voltage of VID-DAC in VID format. */
 749         ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_MAX);
 750         if (ret < 0)
 751                 return ret;
 752
 753         data->vout_max[page] = mp2975_vid2direct(info->vrm_version[page], ret &
 754                                                  GENMASK(8, 0));
 755         return 0;
 756 }
 757
 758 static int
 759 mp2975_set_vout_format(struct i2c_client *client,
 760                        struct mp2975_data *data, int page)
 761 {
 762         int ret, i;
 763
 764         /* Enable DIRECT VOUT format 1mV/LSB */
 765         if (data->chip_id == mp2975) {
 766                 ret = i2c_smbus_read_word_data(client, MP2975_MFR_DC_LOOP_CTRL);
 767                 if (ret < 0)
 768                         return ret;
 769                 if (ret & MP2975_VOUT_FORMAT) {
 770                         ret &= ~MP2975_VOUT_FORMAT;
 771                         ret = i2c_smbus_write_word_data(client, MP2975_MFR_DC_LOOP_CTRL, ret);
 772                 }
 773         } else {
 774                 ret = i2c_smbus_read_word_data(client, MP2973_MFR_RESO_SET);
 775                 if (ret < 0)
 776                         return ret;
 777                 i = ret;
 778
 779                 if (page == 0) {
 780                         i &= ~MP2973_VOUT_FORMAT_R1;
 781                         i |= MP2973_VOUT_FORMAT_DIRECT_R1;
 782                 } else {
 783                         i &= ~MP2973_VOUT_FORMAT_R2;
 784                         i |= MP2973_VOUT_FORMAT_DIRECT_R2;
 785                 }
 786                 if (i != ret)
 787                         ret = i2c_smbus_write_word_data(client, MP2973_MFR_RESO_SET, i);
 788         }
 789         return ret;
 790 }
 791
 792 static int
 793 mp2975_vout_ov_scale_get(struct i2c_client *client, struct mp2975_data *data,
 794                          struct pmbus_driver_info *info)
 795 {
 796         int thres_dev, sense_ampl, ret;
 797
 798         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
 799         if (ret < 0)
 800                 return ret;
 801
 802         /*
 803          * Get divider for over- and under-voltage protection thresholds
 804          * configuration from the Advanced Options of Auto Phase Shedding and
 805          * decay register.
 806          */
 807         ret = i2c_smbus_read_word_data(client, MP2975_MFR_APS_DECAY_ADV);
 808         if (ret < 0)
 809                 return ret;
 810         thres_dev = ret & MP2975_PRT_THRES_DIV_OV_EN ? MP2975_PROT_DEV_OV_ON :
 811                                                        MP2975_PROT_DEV_OV_OFF;
 812
 813         /* Select the gain of remote sense amplifier. */
 814         ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_SCALE_LOOP);
 815         if (ret < 0)
 816                 return ret;
 817         sense_ampl = ret & MP2975_SENSE_AMPL ? MP2975_SENSE_AMPL_HALF :
 818                                                MP2975_SENSE_AMPL_UNIT;
 819
 820         data->vout_scale = sense_ampl * thres_dev;
 821
 822         return 0;
 823 }
 824
 825 static int
 826 mp2975_vout_per_rail_config_get(struct i2c_client *client,
 827                                 struct mp2975_data *data,
 828                                 struct pmbus_driver_info *info)
 829 {
 830         int i, ret;
 831
 832         for (i = 0; i < data->info.pages; i++) {
 833                 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
 834                 if (ret < 0)
 835                         continue;
 836
 837                 /* Set VOUT format for READ_VOUT command : direct. */
 838                 ret = mp2975_set_vout_format(client, data, i);
 839                 if (ret < 0)
 840                         return ret;
 841
 842                 /* Obtain maximum voltage values. */
 843                 ret = mp2975_vout_max_get(client, data, info, i);
 844                 if (ret < 0)
 845                         return ret;
 846
 847                 /* Skip if reading Vref is unsupported */
 848                 if (data->chip_id != mp2975)
 849                         continue;
 850
 851                 /* Obtain voltage reference offsets. */
 852                 ret = mp2975_vref_offset_get(client, data, i);
 853                 if (ret < 0)
 854                         return ret;
 855
 856                 /*
 857                  * Set over-voltage fixed value. Thresholds are provided as
 858                  * fixed value, and tracking value. The minimum of them are
 859                  * exposed as over-voltage critical threshold.
 860                  */
 861                 data->vout_ov_fixed[i] = data->vref[i] +
 862                                          DIV_ROUND_CLOSEST(data->vref_off[i] *
 863                                                            data->vout_scale,
 864                                                            10);
 865         }
 866
 867         return 0;
 868 }
 869
 870 static struct pmbus_driver_info mp2975_info = {
 871         .pages = 1,
 872         .format[PSC_VOLTAGE_IN] = linear,
 873         .format[PSC_VOLTAGE_OUT] = direct,
 874         .format[PSC_TEMPERATURE] = direct,
 875         .format[PSC_CURRENT_IN] = linear,
 876         .format[PSC_CURRENT_OUT] = direct,
 877         .format[PSC_POWER] = direct,
 878         .m[PSC_TEMPERATURE] = 1,
 879         .m[PSC_VOLTAGE_OUT] = 1,
 880         .R[PSC_VOLTAGE_OUT] = 3,
 881         .m[PSC_CURRENT_OUT] = 1,
 882         .m[PSC_POWER] = 1,
 883         .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 884                 PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 885                 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
 886                 PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | PMBUS_PHASE_VIRTUAL,
 887         .read_byte_data = mp2975_read_byte_data,
 888         .read_word_data = mp2975_read_word_data,
 889 #if IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR)
 890         .num_regulators = 1,
 891         .reg_desc = mp2975_reg_desc,
 892 #endif
 893 };
 894
 895 static struct pmbus_driver_info mp2973_info = {
 896         .pages = 1,
 897         .format[PSC_VOLTAGE_IN] = linear,
 898         .format[PSC_VOLTAGE_OUT] = direct,
 899         .format[PSC_TEMPERATURE] = linear,
 900         .format[PSC_CURRENT_IN] = linear,
 901         .format[PSC_CURRENT_OUT] = linear,
 902         .format[PSC_POWER] = linear,
 903         .m[PSC_VOLTAGE_OUT] = 1,
 904         .R[PSC_VOLTAGE_OUT] = 3,
 905         .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 906                 PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 907                 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
 908                 PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT,
 909         .read_word_data = mp2973_read_word_data,
 910 #if IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR)
 911         .num_regulators = 1,
 912         .reg_desc = mp2975_reg_desc,
 913 #endif
 914 };
 915
 916 static int mp2975_probe(struct i2c_client *client)
 917 {
 918         struct pmbus_driver_info *info;
 919         struct mp2975_data *data;
 920         int ret;
 921
 922         data = devm_kzalloc(&client->dev, sizeof(struct mp2975_data),
 923                             GFP_KERNEL);
 924         if (!data)
 925                 return -ENOMEM;
 926
 927         if (client->dev.of_node)
 928                 data->chip_id = (enum chips)(unsigned long)of_device_get_match_data(&client->dev);
 929         else
 930                 data->chip_id = i2c_match_id(mp2975_id, client)->driver_data;
 931
 932         memcpy(data->max_phases, mp2975_max_phases[data->chip_id],
 933                sizeof(data->max_phases));
 934
 935         if (data->chip_id == mp2975)
 936                 memcpy(&data->info, &mp2975_info, sizeof(*info));
 937         else
 938                 memcpy(&data->info, &mp2973_info, sizeof(*info));
 939
 940         info = &data->info;
 941
 942         /* Identify multiphase configuration for rail 2. */
 943         ret = mp2975_identify_multiphase_rail2(client, data);
 944         if (ret < 0)
 945                 return ret;
 946
 947         if (ret) {
 948                 /* Two rails are connected. */
 949                 data->info.pages = MP2975_PAGE_NUM;
 950                 data->info.phases[1] = ret;
 951                 data->info.func[1] = MP2975_RAIL2_FUNC;
 952                 if (IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR))
 953                         data->info.num_regulators = MP2975_PAGE_NUM;
 954         }
 955
 956         /* Identify multiphase configuration. */
 957         ret = mp2975_identify_multiphase(client, data, info);
 958         if (ret)
 959                 return ret;
 960
 961         if (data->chip_id == mp2975) {
 962                 /* Identify VID setting per rail. */
 963                 ret = mp2975_identify_rails_vid(client, data, info);
 964                 if (ret < 0)
 965                         return ret;
 966
 967                 /* Obtain current sense gain of power stage. */
 968                 ret = mp2975_current_sense_gain_get(client, data);
 969                 if (ret)
 970                         return ret;
 971
 972                 /* Obtain voltage reference values. */
 973                 ret = mp2975_vref_get(client, data, info);
 974                 if (ret)
 975                         return ret;
 976
 977                 /* Obtain vout over-voltage scales. */
 978                 ret = mp2975_vout_ov_scale_get(client, data, info);
 979                 if (ret < 0)
 980                         return ret;
 981         } else {
 982                 /* Identify VID setting per rail. */
 983                 ret = mp2973_identify_rails_vid(client, data, info);
 984                 if (ret < 0)
 985                         return ret;
 986         }
 987
 988         /* Obtain offsets, maximum and format for vout. */
 989         ret = mp2975_vout_per_rail_config_get(client, data, info);
 990         if (ret)
 991                 return ret;
 992
 993         return pmbus_do_probe(client, info);
 994 }
 995
 996 static const struct of_device_id __maybe_unused mp2975_of_match[] = {
 997         {.compatible = "mps,mp2971", .data = (void *)mp2971},
 998         {.compatible = "mps,mp2973", .data = (void *)mp2973},
 999         {.compatible = "mps,mp2975", .data = (void *)mp2975},
1000         {}
1001 };
1002 MODULE_DEVICE_TABLE(of, mp2975_of_match);
1003
1004 static struct i2c_driver mp2975_driver = {
1005         .driver = {
1006                 .name = "mp2975",
1007                 .of_match_table = of_match_ptr(mp2975_of_match),
1008         },
1009         .probe = mp2975_probe,
1010         .id_table = mp2975_id,
1011 };
1012
1013 module_i2c_driver(mp2975_driver);
1014
1015 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
1016 MODULE_DESCRIPTION("PMBus driver for MPS MP2975 device");
1017 MODULE_LICENSE("GPL");
1018 MODULE_IMPORT_NS(PMBUS);