drivers/regulator/max77650-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Copyright (C) 2018 BayLibre SAS
   4 // Author: Bartosz Golaszewski <[email protected]>
   5 //
   6 // Regulator driver for MAXIM 77650/77651 charger/power-supply.
   7
   8 #include <linux/of.h>
   9 #include <linux/mfd/max77650.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/regmap.h>
  13 #include <linux/regulator/driver.h>
  14
  15 #define MAX77650_REGULATOR_EN_CTRL_MASK         GENMASK(3, 0)
  16 #define MAX77650_REGULATOR_EN_CTRL_BITS(_reg) \
  17                 ((_reg) & MAX77650_REGULATOR_EN_CTRL_MASK)
  18 #define MAX77650_REGULATOR_ENABLED              GENMASK(2, 1)
  19 #define MAX77650_REGULATOR_DISABLED             BIT(2)
  20
  21 #define MAX77650_REGULATOR_V_LDO_MASK           GENMASK(6, 0)
  22 #define MAX77650_REGULATOR_V_SBB_MASK           GENMASK(5, 0)
  23
  24 #define MAX77650_REGULATOR_AD_MASK              BIT(3)
  25 #define MAX77650_REGULATOR_AD_DISABLED          0x00
  26 #define MAX77650_REGULATOR_AD_ENABLED           BIT(3)
  27
  28 #define MAX77650_REGULATOR_CURR_LIM_MASK        GENMASK(7, 6)
  29
  30 enum {
  31         MAX77650_REGULATOR_ID_LDO = 0,
  32         MAX77650_REGULATOR_ID_SBB0,
  33         MAX77650_REGULATOR_ID_SBB1,
  34         MAX77650_REGULATOR_ID_SBB2,
  35         MAX77650_REGULATOR_NUM_REGULATORS,
  36 };
  37
  38 struct max77650_regulator_desc {
  39         struct regulator_desc desc;
  40         unsigned int regA;
  41         unsigned int regB;
  42 };
  43
  44 static const u32 max77651_sbb1_regulator_volt_table[] = {
  45         2400000, 3200000, 4000000, 4800000,
  46         2450000, 3250000, 4050000, 4850000,
  47         2500000, 3300000, 4100000, 4900000,
  48         2550000, 3350000, 4150000, 4950000,
  49         2600000, 3400000, 4200000, 5000000,
  50         2650000, 3450000, 4250000, 5050000,
  51         2700000, 3500000, 4300000, 5100000,
  52         2750000, 3550000, 4350000, 5150000,
  53         2800000, 3600000, 4400000, 5200000,
  54         2850000, 3650000, 4450000, 5250000,
  55         2900000, 3700000, 4500000,       0,
  56         2950000, 3750000, 4550000,       0,
  57         3000000, 3800000, 4600000,       0,
  58         3050000, 3850000, 4650000,       0,
  59         3100000, 3900000, 4700000,       0,
  60         3150000, 3950000, 4750000,       0,
  61 };
  62
  63 #define MAX77651_REGULATOR_SBB1_SEL_DEC(_val) \
  64                 (((_val & 0x3c) >> 2) | ((_val & 0x03) << 4))
  65 #define MAX77651_REGULATOR_SBB1_SEL_ENC(_val) \
  66                 (((_val & 0x30) >> 4) | ((_val & 0x0f) << 2))
  67
  68 #define MAX77650_REGULATOR_SBB1_SEL_DECR(_val)                          \
  69         do {                                                            \
  70                 _val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val);           \
  71                 _val--;                                                 \
  72                 _val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val);           \
  73         } while (0)
  74
  75 #define MAX77650_REGULATOR_SBB1_SEL_INCR(_val)                          \
  76         do {                                                            \
  77                 _val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val);           \
  78                 _val++;                                                 \
  79                 _val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val);           \
  80         } while (0)
  81
  82 static const unsigned int max77650_current_limit_table[] = {
  83         1000000, 866000, 707000, 500000,
  84 };
  85
  86 static int max77650_regulator_is_enabled(struct regulator_dev *rdev)
  87 {
  88         struct max77650_regulator_desc *rdesc;
  89         struct regmap *map;
  90         int val, rv, en;
  91
  92         rdesc = rdev_get_drvdata(rdev);
  93         map = rdev_get_regmap(rdev);
  94
  95         rv = regmap_read(map, rdesc->regB, &val);
  96         if (rv)
  97                 return rv;
  98
  99         en = MAX77650_REGULATOR_EN_CTRL_BITS(val);
 100
 101         return en != MAX77650_REGULATOR_DISABLED;
 102 }
 103
 104 static int max77650_regulator_enable(struct regulator_dev *rdev)
 105 {
 106         struct max77650_regulator_desc *rdesc;
 107         struct regmap *map;
 108
 109         rdesc = rdev_get_drvdata(rdev);
 110         map = rdev_get_regmap(rdev);
 111
 112         return regmap_update_bits(map, rdesc->regB,
 113                                   MAX77650_REGULATOR_EN_CTRL_MASK,
 114                                   MAX77650_REGULATOR_ENABLED);
 115 }
 116
 117 static int max77650_regulator_disable(struct regulator_dev *rdev)
 118 {
 119         struct max77650_regulator_desc *rdesc;
 120         struct regmap *map;
 121
 122         rdesc = rdev_get_drvdata(rdev);
 123         map = rdev_get_regmap(rdev);
 124
 125         return regmap_update_bits(map, rdesc->regB,
 126                                   MAX77650_REGULATOR_EN_CTRL_MASK,
 127                                   MAX77650_REGULATOR_DISABLED);
 128 }
 129
 130 static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev,
 131                                               unsigned int sel)
 132 {
 133         int rv = 0, curr, diff;
 134         bool ascending;
 135
 136         /*
 137          * If the regulator is disabled, we can program the desired
 138          * voltage right away.
 139          */
 140         if (!max77650_regulator_is_enabled(rdev))
 141                 return regulator_set_voltage_sel_regmap(rdev, sel);
 142
 143         /*
 144          * Otherwise we need to manually ramp the output voltage up/down
 145          * one step at a time.
 146          */
 147
 148         curr = regulator_get_voltage_sel_regmap(rdev);
 149         if (curr < 0)
 150                 return curr;
 151
 152         diff = curr - sel;
 153         if (diff == 0)
 154                 return 0; /* Already there. */
 155         else if (diff > 0)
 156                 ascending = false;
 157         else
 158                 ascending = true;
 159
 160         /*
 161          * Make sure we'll get to the right voltage and break the loop even if
 162          * the selector equals 0.
 163          */
 164         for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) {
 165                 rv = regulator_set_voltage_sel_regmap(rdev, curr);
 166                 if (rv)
 167                         return rv;
 168
 169                 if (curr == sel)
 170                         break;
 171         }
 172
 173         return 0;
 174 }
 175
 176 /*
 177  * Special case: non-linear voltage table for max77651 SBB1 - software
 178  * must ensure the voltage is ramped in 50mV increments.
 179  */
 180 static int max77651_regulator_sbb1_set_voltage_sel(struct regulator_dev *rdev,
 181                                                    unsigned int sel)
 182 {
 183         int rv = 0, curr, vcurr, vdest, vdiff;
 184
 185         /*
 186          * If the regulator is disabled, we can program the desired
 187          * voltage right away.
 188          */
 189         if (!max77650_regulator_is_enabled(rdev))
 190                 return regulator_set_voltage_sel_regmap(rdev, sel);
 191
 192         curr = regulator_get_voltage_sel_regmap(rdev);
 193         if (curr < 0)
 194                 return curr;
 195
 196         if (curr == sel)
 197                 return 0; /* Already there. */
 198
 199         vcurr = max77651_sbb1_regulator_volt_table[curr];
 200         vdest = max77651_sbb1_regulator_volt_table[sel];
 201         vdiff = vcurr - vdest;
 202
 203         for (;;) {
 204                 if (vdiff > 0)
 205                         MAX77650_REGULATOR_SBB1_SEL_DECR(curr);
 206                 else
 207                         MAX77650_REGULATOR_SBB1_SEL_INCR(curr);
 208
 209                 rv = regulator_set_voltage_sel_regmap(rdev, curr);
 210                 if (rv)
 211                         return rv;
 212
 213                 if (curr == sel)
 214                         break;
 215         };
 216
 217         return 0;
 218 }
 219
 220 static const struct regulator_ops max77650_regulator_LDO_ops = {
 221         .is_enabled             = max77650_regulator_is_enabled,
 222         .enable                 = max77650_regulator_enable,
 223         .disable                = max77650_regulator_disable,
 224         .list_voltage           = regulator_list_voltage_linear,
 225         .map_voltage            = regulator_map_voltage_linear,
 226         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 227         .set_voltage_sel        = max77650_regulator_set_voltage_sel,
 228         .set_active_discharge   = regulator_set_active_discharge_regmap,
 229 };
 230
 231 static const struct regulator_ops max77650_regulator_SBB_ops = {
 232         .is_enabled             = max77650_regulator_is_enabled,
 233         .enable                 = max77650_regulator_enable,
 234         .disable                = max77650_regulator_disable,
 235         .list_voltage           = regulator_list_voltage_linear,
 236         .map_voltage            = regulator_map_voltage_linear,
 237         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 238         .set_voltage_sel        = max77650_regulator_set_voltage_sel,
 239         .get_current_limit      = regulator_get_current_limit_regmap,
 240         .set_current_limit      = regulator_set_current_limit_regmap,
 241         .set_active_discharge   = regulator_set_active_discharge_regmap,
 242 };
 243
 244 /* Special case for max77651 SBB1 - non-linear voltage mapping. */
 245 static const struct regulator_ops max77651_SBB1_regulator_ops = {
 246         .is_enabled             = max77650_regulator_is_enabled,
 247         .enable                 = max77650_regulator_enable,
 248         .disable                = max77650_regulator_disable,
 249         .list_voltage           = regulator_list_voltage_table,
 250         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 251         .set_voltage_sel        = max77651_regulator_sbb1_set_voltage_sel,
 252         .get_current_limit      = regulator_get_current_limit_regmap,
 253         .set_current_limit      = regulator_set_current_limit_regmap,
 254         .set_active_discharge   = regulator_set_active_discharge_regmap,
 255 };
 256
 257 static struct max77650_regulator_desc max77650_LDO_desc = {
 258         .desc = {
 259                 .name                   = "ldo",
 260                 .of_match               = of_match_ptr("ldo"),
 261                 .regulators_node        = of_match_ptr("regulators"),
 262                 .supply_name            = "in-ldo",
 263                 .id                     = MAX77650_REGULATOR_ID_LDO,
 264                 .ops                    = &max77650_regulator_LDO_ops,
 265                 .min_uV                 = 1350000,
 266                 .uV_step                = 12500,
 267                 .n_voltages             = 128,
 268                 .vsel_mask              = MAX77650_REGULATOR_V_LDO_MASK,
 269                 .vsel_reg               = MAX77650_REG_CNFG_LDO_A,
 270                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 271                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 272                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 273                 .active_discharge_reg   = MAX77650_REG_CNFG_LDO_B,
 274                 .enable_time            = 100,
 275                 .type                   = REGULATOR_VOLTAGE,
 276                 .owner                  = THIS_MODULE,
 277         },
 278         .regA           = MAX77650_REG_CNFG_LDO_A,
 279         .regB           = MAX77650_REG_CNFG_LDO_B,
 280 };
 281
 282 static struct max77650_regulator_desc max77650_SBB0_desc = {
 283         .desc = {
 284                 .name                   = "sbb0",
 285                 .of_match               = of_match_ptr("sbb0"),
 286                 .regulators_node        = of_match_ptr("regulators"),
 287                 .supply_name            = "in-sbb0",
 288                 .id                     = MAX77650_REGULATOR_ID_SBB0,
 289                 .ops                    = &max77650_regulator_SBB_ops,
 290                 .min_uV                 = 800000,
 291                 .uV_step                = 25000,
 292                 .n_voltages             = 64,
 293                 .vsel_mask              = MAX77650_REGULATOR_V_SBB_MASK,
 294                 .vsel_reg               = MAX77650_REG_CNFG_SBB0_A,
 295                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 296                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 297                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 298                 .active_discharge_reg   = MAX77650_REG_CNFG_SBB0_B,
 299                 .enable_time            = 100,
 300                 .type                   = REGULATOR_VOLTAGE,
 301                 .owner                  = THIS_MODULE,
 302                 .csel_reg               = MAX77650_REG_CNFG_SBB0_A,
 303                 .csel_mask              = MAX77650_REGULATOR_CURR_LIM_MASK,
 304                 .curr_table             = max77650_current_limit_table,
 305                 .n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 306         },
 307         .regA           = MAX77650_REG_CNFG_SBB0_A,
 308         .regB           = MAX77650_REG_CNFG_SBB0_B,
 309 };
 310
 311 static struct max77650_regulator_desc max77650_SBB1_desc = {
 312         .desc = {
 313                 .name                   = "sbb1",
 314                 .of_match               = of_match_ptr("sbb1"),
 315                 .regulators_node        = of_match_ptr("regulators"),
 316                 .supply_name            = "in-sbb1",
 317                 .id                     = MAX77650_REGULATOR_ID_SBB1,
 318                 .ops                    = &max77650_regulator_SBB_ops,
 319                 .min_uV                 = 800000,
 320                 .uV_step                = 12500,
 321                 .n_voltages             = 64,
 322                 .vsel_mask              = MAX77650_REGULATOR_V_SBB_MASK,
 323                 .vsel_reg               = MAX77650_REG_CNFG_SBB1_A,
 324                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 325                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 326                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 327                 .active_discharge_reg   = MAX77650_REG_CNFG_SBB1_B,
 328                 .enable_time            = 100,
 329                 .type                   = REGULATOR_VOLTAGE,
 330                 .owner                  = THIS_MODULE,
 331                 .csel_reg               = MAX77650_REG_CNFG_SBB1_A,
 332                 .csel_mask              = MAX77650_REGULATOR_CURR_LIM_MASK,
 333                 .curr_table             = max77650_current_limit_table,
 334                 .n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 335         },
 336         .regA           = MAX77650_REG_CNFG_SBB1_A,
 337         .regB           = MAX77650_REG_CNFG_SBB1_B,
 338 };
 339
 340 static struct max77650_regulator_desc max77651_SBB1_desc = {
 341         .desc = {
 342                 .name                   = "sbb1",
 343                 .of_match               = of_match_ptr("sbb1"),
 344                 .regulators_node        = of_match_ptr("regulators"),
 345                 .supply_name            = "in-sbb1",
 346                 .id                     = MAX77650_REGULATOR_ID_SBB1,
 347                 .ops                    = &max77651_SBB1_regulator_ops,
 348                 .volt_table             = max77651_sbb1_regulator_volt_table,
 349                 .n_voltages = ARRAY_SIZE(max77651_sbb1_regulator_volt_table),
 350                 .vsel_mask              = MAX77650_REGULATOR_V_SBB_MASK,
 351                 .vsel_reg               = MAX77650_REG_CNFG_SBB1_A,
 352                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 353                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 354                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 355                 .active_discharge_reg   = MAX77650_REG_CNFG_SBB1_B,
 356                 .enable_time            = 100,
 357                 .type                   = REGULATOR_VOLTAGE,
 358                 .owner                  = THIS_MODULE,
 359                 .csel_reg               = MAX77650_REG_CNFG_SBB1_A,
 360                 .csel_mask              = MAX77650_REGULATOR_CURR_LIM_MASK,
 361                 .curr_table             = max77650_current_limit_table,
 362                 .n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 363         },
 364         .regA           = MAX77650_REG_CNFG_SBB1_A,
 365         .regB           = MAX77650_REG_CNFG_SBB1_B,
 366 };
 367
 368 static struct max77650_regulator_desc max77650_SBB2_desc = {
 369         .desc = {
 370                 .name                   = "sbb2",
 371                 .of_match               = of_match_ptr("sbb2"),
 372                 .regulators_node        = of_match_ptr("regulators"),
 373                 .supply_name            = "in-sbb0",
 374                 .id                     = MAX77650_REGULATOR_ID_SBB2,
 375                 .ops                    = &max77650_regulator_SBB_ops,
 376                 .min_uV                 = 800000,
 377                 .uV_step                = 50000,
 378                 .n_voltages             = 64,
 379                 .vsel_mask              = MAX77650_REGULATOR_V_SBB_MASK,
 380                 .vsel_reg               = MAX77650_REG_CNFG_SBB2_A,
 381                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 382                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 383                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 384                 .active_discharge_reg   = MAX77650_REG_CNFG_SBB2_B,
 385                 .enable_time            = 100,
 386                 .type                   = REGULATOR_VOLTAGE,
 387                 .owner                  = THIS_MODULE,
 388                 .csel_reg               = MAX77650_REG_CNFG_SBB2_A,
 389                 .csel_mask              = MAX77650_REGULATOR_CURR_LIM_MASK,
 390                 .curr_table             = max77650_current_limit_table,
 391                 .n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 392         },
 393         .regA           = MAX77650_REG_CNFG_SBB2_A,
 394         .regB           = MAX77650_REG_CNFG_SBB2_B,
 395 };
 396
 397 static struct max77650_regulator_desc max77651_SBB2_desc = {
 398         .desc = {
 399                 .name                   = "sbb2",
 400                 .of_match               = of_match_ptr("sbb2"),
 401                 .regulators_node        = of_match_ptr("regulators"),
 402                 .supply_name            = "in-sbb0",
 403                 .id                     = MAX77650_REGULATOR_ID_SBB2,
 404                 .ops                    = &max77650_regulator_SBB_ops,
 405                 .min_uV                 = 2400000,
 406                 .uV_step                = 50000,
 407                 .n_voltages             = 64,
 408                 .vsel_mask              = MAX77650_REGULATOR_V_SBB_MASK,
 409                 .vsel_reg               = MAX77650_REG_CNFG_SBB2_A,
 410                 .active_discharge_off   = MAX77650_REGULATOR_AD_DISABLED,
 411                 .active_discharge_on    = MAX77650_REGULATOR_AD_ENABLED,
 412                 .active_discharge_mask  = MAX77650_REGULATOR_AD_MASK,
 413                 .active_discharge_reg   = MAX77650_REG_CNFG_SBB2_B,
 414                 .enable_time            = 100,
 415                 .type                   = REGULATOR_VOLTAGE,
 416                 .owner                  = THIS_MODULE,
 417                 .csel_reg               = MAX77650_REG_CNFG_SBB2_A,
 418                 .csel_mask              = MAX77650_REGULATOR_CURR_LIM_MASK,
 419                 .curr_table             = max77650_current_limit_table,
 420                 .n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 421         },
 422         .regA           = MAX77650_REG_CNFG_SBB2_A,
 423         .regB           = MAX77650_REG_CNFG_SBB2_B,
 424 };
 425
 426 static int max77650_regulator_probe(struct platform_device *pdev)
 427 {
 428         struct max77650_regulator_desc **rdescs;
 429         struct max77650_regulator_desc *rdesc;
 430         struct regulator_config config = { };
 431         struct device *dev, *parent;
 432         struct regulator_dev *rdev;
 433         struct regmap *map;
 434         unsigned int val;
 435         int i, rv;
 436
 437         dev = &pdev->dev;
 438         parent = dev->parent;
 439
 440         if (!dev->of_node)
 441                 dev->of_node = parent->of_node;
 442
 443         rdescs = devm_kcalloc(dev, MAX77650_REGULATOR_NUM_REGULATORS,
 444                               sizeof(*rdescs), GFP_KERNEL);
 445         if (!rdescs)
 446                 return -ENOMEM;
 447
 448         map = dev_get_regmap(parent, NULL);
 449         if (!map)
 450                 return -ENODEV;
 451
 452         rv = regmap_read(map, MAX77650_REG_CID, &val);
 453         if (rv)
 454                 return rv;
 455
 456         rdescs[MAX77650_REGULATOR_ID_LDO] = &max77650_LDO_desc;
 457         rdescs[MAX77650_REGULATOR_ID_SBB0] = &max77650_SBB0_desc;
 458
 459         switch (MAX77650_CID_BITS(val)) {
 460         case MAX77650_CID_77650A:
 461         case MAX77650_CID_77650C:
 462                 rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77650_SBB1_desc;
 463                 rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77650_SBB2_desc;
 464                 break;
 465         case MAX77650_CID_77651A:
 466         case MAX77650_CID_77651B:
 467                 rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77651_SBB1_desc;
 468                 rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77651_SBB2_desc;
 469                 break;
 470         default:
 471                 return -ENODEV;
 472         }
 473
 474         config.dev = parent;
 475
 476         for (i = 0; i < MAX77650_REGULATOR_NUM_REGULATORS; i++) {
 477                 rdesc = rdescs[i];
 478                 config.driver_data = rdesc;
 479
 480                 rdev = devm_regulator_register(dev, &rdesc->desc, &config);
 481                 if (IS_ERR(rdev))
 482                         return PTR_ERR(rdev);
 483         }
 484
 485         return 0;
 486 }
 487
 488 static struct platform_driver max77650_regulator_driver = {
 489         .driver = {
 490                 .name = "max77650-regulator",
 491         },
 492         .probe = max77650_regulator_probe,
 493 };
 494 module_platform_driver(max77650_regulator_driver);
 495
 496 MODULE_DESCRIPTION("MAXIM 77650/77651 regulator driver");
 497 MODULE_AUTHOR("Bartosz Golaszewski <[email protected]>");
 498 MODULE_LICENSE("GPL v2");