drivers/regulator/max77802-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // max77802.c - Regulator driver for the Maxim 77802
   4 //
   5 // Copyright (C) 2013-2014 Google, Inc
   6 // Simon Glass <sjg@chromium.org>
   7 //
   8 // Copyright (C) 2012 Samsung Electronics
   9 // Chiwoong Byun <woong.byun@samsung.com>
  10 // Jonghwa Lee <jonghwa3.lee@samsung.com>
  11 //
  12 // This driver is based on max8997.c
  13
  14 #include <linux/kernel.h>
  15 #include <linux/bug.h>
  16 #include <linux/err.h>
  17 #include <linux/gpio.h>
  18 #include <linux/slab.h>
  19 #include <linux/gpio/consumer.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regulator/driver.h>
  23 #include <linux/regulator/machine.h>
  24 #include <linux/regulator/of_regulator.h>
  25 #include <linux/mfd/max77686.h>
  26 #include <linux/mfd/max77686-private.h>
  27 #include <dt-bindings/regulator/maxim,max77802.h>
  28
  29 /* Default ramp delay in case it is not manually set */
  30 #define MAX77802_RAMP_DELAY             100000          /* uV/us */
  31
  32 #define MAX77802_OPMODE_SHIFT_LDO       6
  33 #define MAX77802_OPMODE_BUCK234_SHIFT   4
  34 #define MAX77802_OPMODE_MASK            0x3
  35
  36 #define MAX77802_VSEL_MASK              0x3F
  37 #define MAX77802_DVS_VSEL_MASK          0xFF
  38
  39 #define MAX77802_RAMP_RATE_MASK_2BIT    0xC0
  40 #define MAX77802_RAMP_RATE_SHIFT_2BIT   6
  41 #define MAX77802_RAMP_RATE_MASK_4BIT    0xF0
  42 #define MAX77802_RAMP_RATE_SHIFT_4BIT   4
  43
  44 #define MAX77802_STATUS_OFF             0x0
  45 #define MAX77802_OFF_PWRREQ             0x1
  46 #define MAX77802_LP_PWRREQ              0x2
  47
  48 /* MAX77802 has two register formats: 2-bit and 4-bit */
  49 static const unsigned int ramp_table_77802_2bit[] = {
  50         12500,
  51         25000,
  52         50000,
  53         100000,
  54 };
  55
  56 static unsigned int ramp_table_77802_4bit[] = {
  57         1000,   2000,   3030,   4000,
  58         5000,   5880,   7140,   8330,
  59         9090,   10000,  11110,  12500,
  60         16670,  25000,  50000,  100000,
  61 };
  62
  63 struct max77802_regulator_prv {
  64         /* Array indexed by regulator id */
  65         unsigned int opmode[MAX77802_REG_MAX];
  66 };
  67
  68 static inline unsigned int max77802_map_mode(unsigned int mode)
  69 {
  70         return mode == MAX77802_OPMODE_NORMAL ?
  71                 REGULATOR_MODE_NORMAL : REGULATOR_MODE_STANDBY;
  72 }
  73
  74 static int max77802_get_opmode_shift(int id)
  75 {
  76         if (id == MAX77802_BUCK1 || (id >= MAX77802_BUCK5 &&
  77                                      id <= MAX77802_BUCK10))
  78                 return 0;
  79
  80         if (id >= MAX77802_BUCK2 && id <= MAX77802_BUCK4)
  81                 return MAX77802_OPMODE_BUCK234_SHIFT;
  82
  83         if (id >= MAX77802_LDO1 && id <= MAX77802_LDO35)
  84                 return MAX77802_OPMODE_SHIFT_LDO;
  85
  86         return -EINVAL;
  87 }
  88
  89 /**
  90  * max77802_set_suspend_disable - Disable the regulator during system suspend
  91  * @rdev: regulator to mark as disabled
  92  *
  93  * All regulators expect LDO 1, 3, 20 and 21 support OFF by PWRREQ.
  94  * Configure the regulator so the PMIC will turn it OFF during system suspend.
  95  */
  96 static int max77802_set_suspend_disable(struct regulator_dev *rdev)
  97 {
  98         unsigned int val = MAX77802_OFF_PWRREQ;
  99         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
 100         unsigned int id = rdev_get_id(rdev);
 101         int shift = max77802_get_opmode_shift(id);
 102
 103         if (WARN_ON_ONCE(id >= ARRAY_SIZE(max77802->opmode)))
 104                 return -EINVAL;
 105         max77802->opmode[id] = val;
 106         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 107                                   rdev->desc->enable_mask, val << shift);
 108 }
 109
 110 /*
 111  * Some LDOs support Low Power Mode while the system is running.
 112  *
 113  * LDOs 1, 3, 20, 21.
 114  */
 115 static int max77802_set_mode(struct regulator_dev *rdev, unsigned int mode)
 116 {
 117         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
 118         unsigned int id = rdev_get_id(rdev);
 119         unsigned int val;
 120         int shift = max77802_get_opmode_shift(id);
 121
 122         switch (mode) {
 123         case REGULATOR_MODE_STANDBY:
 124                 val = MAX77802_OPMODE_LP;       /* ON in Low Power Mode */
 125                 break;
 126         case REGULATOR_MODE_NORMAL:
 127                 val = MAX77802_OPMODE_NORMAL;   /* ON in Normal Mode */
 128                 break;
 129         default:
 130                 dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
 131                          rdev->desc->name, mode);
 132                 return -EINVAL;
 133         }
 134
 135         if (WARN_ON_ONCE(id >= ARRAY_SIZE(max77802->opmode)))
 136                 return -EINVAL;
 137
 138         max77802->opmode[id] = val;
 139         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 140                                   rdev->desc->enable_mask, val << shift);
 141 }
 142
 143 static unsigned max77802_get_mode(struct regulator_dev *rdev)
 144 {
 145         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
 146         unsigned int id = rdev_get_id(rdev);
 147
 148         if (WARN_ON_ONCE(id >= ARRAY_SIZE(max77802->opmode)))
 149                 return -EINVAL;
 150         return max77802_map_mode(max77802->opmode[id]);
 151 }
 152
 153 /**
 154  * max77802_set_suspend_mode - set regulator opmode when the system is suspended
 155  * @rdev: regulator to change mode
 156  * @mode: operating mode to be set
 157  *
 158  * Will set the operating mode for the regulators during system suspend.
 159  * This function is valid for the three different enable control logics:
 160  *
 161  * Enable Control Logic1 by PWRREQ (BUCK 2-4 and LDOs 2, 4-19, 22-35)
 162  * Enable Control Logic2 by PWRREQ (LDOs 1, 20, 21)
 163  * Enable Control Logic3 by PWRREQ (LDO 3)
 164  *
 165  * If setting the regulator mode fails, the function only warns but does
 166  * not return an error code to avoid the regulator core to stop setting
 167  * the operating mode for the remaining regulators.
 168  */
 169 static int max77802_set_suspend_mode(struct regulator_dev *rdev,
 170                                      unsigned int mode)
 171 {
 172         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
 173         unsigned int id = rdev_get_id(rdev);
 174         unsigned int val;
 175         int shift = max77802_get_opmode_shift(id);
 176
 177         if (WARN_ON_ONCE(id >= ARRAY_SIZE(max77802->opmode)))
 178                 return -EINVAL;
 179
 180         /*
 181          * If the regulator has been disabled for suspend
 182          * then is invalid to try setting a suspend mode.
 183          */
 184         if (max77802->opmode[id] == MAX77802_OFF_PWRREQ) {
 185                 dev_warn(&rdev->dev, "%s: is disabled, mode: 0x%x not set\n",
 186                          rdev->desc->name, mode);
 187                 return 0;
 188         }
 189
 190         switch (mode) {
 191         case REGULATOR_MODE_STANDBY:
 192                 /*
 193                  * If the regulator opmode is normal then enable
 194                  * ON in Low Power Mode by PWRREQ. If the mode is
 195                  * already Low Power then no action is required.
 196                  */
 197                 if (max77802->opmode[id] == MAX77802_OPMODE_NORMAL)
 198                         val = MAX77802_LP_PWRREQ;
 199                 else
 200                         return 0;
 201                 break;
 202         case REGULATOR_MODE_NORMAL:
 203                 /*
 204                  * If the regulator operating mode is Low Power then
 205                  * normal is not a valid opmode in suspend. If the
 206                  * mode is already normal then no action is required.
 207                  */
 208                 if (max77802->opmode[id] == MAX77802_OPMODE_LP)
 209                         dev_warn(&rdev->dev, "%s: in Low Power: 0x%x invalid\n",
 210                                  rdev->desc->name, mode);
 211                 return 0;
 212         default:
 213                 dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
 214                          rdev->desc->name, mode);
 215                 return -EINVAL;
 216         }
 217
 218         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 219                                   rdev->desc->enable_mask, val << shift);
 220 }
 221
 222 static int max77802_enable(struct regulator_dev *rdev)
 223 {
 224         struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
 225         unsigned int id = rdev_get_id(rdev);
 226         int shift = max77802_get_opmode_shift(id);
 227
 228         if (WARN_ON_ONCE(id >= ARRAY_SIZE(max77802->opmode)))
 229                 return -EINVAL;
 230         if (max77802->opmode[id] == MAX77802_OFF_PWRREQ)
 231                 max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
 232
 233         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 234                                   rdev->desc->enable_mask,
 235                                   max77802->opmode[id] << shift);
 236 }
 237
 238 static int max77802_find_ramp_value(struct regulator_dev *rdev,
 239                                     const unsigned int limits[], int size,
 240                                     unsigned int ramp_delay)
 241 {
 242         int i;
 243
 244         for (i = 0; i < size; i++) {
 245                 if (ramp_delay <= limits[i])
 246                         return i;
 247         }
 248
 249         /* Use maximum value for no ramp control */
 250         dev_warn(&rdev->dev, "%s: ramp_delay: %d not supported, setting 100000\n",
 251                  rdev->desc->name, ramp_delay);
 252         return size - 1;
 253 }
 254
 255 /* Used for BUCKs 2-4 */
 256 static int max77802_set_ramp_delay_2bit(struct regulator_dev *rdev,
 257                                         int ramp_delay)
 258 {
 259         int id = rdev_get_id(rdev);
 260         unsigned int ramp_value;
 261
 262         if (id > MAX77802_BUCK4) {
 263                         dev_warn(&rdev->dev,
 264                                  "%s: regulator: ramp delay not supported\n",
 265                                  rdev->desc->name);
 266                 return -EINVAL;
 267         }
 268         ramp_value = max77802_find_ramp_value(rdev, ramp_table_77802_2bit,
 269                                 ARRAY_SIZE(ramp_table_77802_2bit), ramp_delay);
 270
 271         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 272                                   MAX77802_RAMP_RATE_MASK_2BIT,
 273                                   ramp_value << MAX77802_RAMP_RATE_SHIFT_2BIT);
 274 }
 275
 276 /* For BUCK1, 6 */
 277 static int max77802_set_ramp_delay_4bit(struct regulator_dev *rdev,
 278                                             int ramp_delay)
 279 {
 280         unsigned int ramp_value;
 281
 282         ramp_value = max77802_find_ramp_value(rdev, ramp_table_77802_4bit,
 283                                 ARRAY_SIZE(ramp_table_77802_4bit), ramp_delay);
 284
 285         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 286                                   MAX77802_RAMP_RATE_MASK_4BIT,
 287                                   ramp_value << MAX77802_RAMP_RATE_SHIFT_4BIT);
 288 }
 289
 290 /*
 291  * LDOs 2, 4-19, 22-35
 292  */
 293 static const struct regulator_ops max77802_ldo_ops_logic1 = {
 294         .list_voltage           = regulator_list_voltage_linear,
 295         .map_voltage            = regulator_map_voltage_linear,
 296         .is_enabled             = regulator_is_enabled_regmap,
 297         .enable                 = max77802_enable,
 298         .disable                = regulator_disable_regmap,
 299         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 300         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 301         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 302         .set_suspend_disable    = max77802_set_suspend_disable,
 303         .set_suspend_mode       = max77802_set_suspend_mode,
 304 };
 305
 306 /*
 307  * LDOs 1, 20, 21, 3
 308  */
 309 static const struct regulator_ops max77802_ldo_ops_logic2 = {
 310         .list_voltage           = regulator_list_voltage_linear,
 311         .map_voltage            = regulator_map_voltage_linear,
 312         .is_enabled             = regulator_is_enabled_regmap,
 313         .enable                 = max77802_enable,
 314         .disable                = regulator_disable_regmap,
 315         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 316         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 317         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 318         .set_mode               = max77802_set_mode,
 319         .get_mode               = max77802_get_mode,
 320         .set_suspend_mode       = max77802_set_suspend_mode,
 321 };
 322
 323 /* BUCKS 1, 6 */
 324 static const struct regulator_ops max77802_buck_16_dvs_ops = {
 325         .list_voltage           = regulator_list_voltage_linear,
 326         .map_voltage            = regulator_map_voltage_linear,
 327         .is_enabled             = regulator_is_enabled_regmap,
 328         .enable                 = max77802_enable,
 329         .disable                = regulator_disable_regmap,
 330         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 331         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 332         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 333         .set_ramp_delay         = max77802_set_ramp_delay_4bit,
 334         .set_suspend_disable    = max77802_set_suspend_disable,
 335 };
 336
 337 /* BUCKs 2-4 */
 338 static const struct regulator_ops max77802_buck_234_ops = {
 339         .list_voltage           = regulator_list_voltage_linear,
 340         .map_voltage            = regulator_map_voltage_linear,
 341         .is_enabled             = regulator_is_enabled_regmap,
 342         .enable                 = max77802_enable,
 343         .disable                = regulator_disable_regmap,
 344         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 345         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 346         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 347         .set_ramp_delay         = max77802_set_ramp_delay_2bit,
 348         .set_suspend_disable    = max77802_set_suspend_disable,
 349         .set_suspend_mode       = max77802_set_suspend_mode,
 350 };
 351
 352 /* BUCKs 5, 7-10 */
 353 static const struct regulator_ops max77802_buck_dvs_ops = {
 354         .list_voltage           = regulator_list_voltage_linear,
 355         .map_voltage            = regulator_map_voltage_linear,
 356         .is_enabled             = regulator_is_enabled_regmap,
 357         .enable                 = max77802_enable,
 358         .disable                = regulator_disable_regmap,
 359         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 360         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 361         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 362         .set_ramp_delay         = max77802_set_ramp_delay_2bit,
 363         .set_suspend_disable    = max77802_set_suspend_disable,
 364 };
 365
 366 /* LDOs 3-7, 9-14, 18-26, 28, 29, 32-34 */
 367 #define regulator_77802_desc_p_ldo(num, supply, log)    {               \
 368         .name           = "LDO"#num,                                    \
 369         .of_match       = of_match_ptr("LDO"#num),                      \
 370         .regulators_node        = of_match_ptr("regulators"),           \
 371         .id             = MAX77802_LDO##num,                            \
 372         .supply_name    = "inl"#supply,                                 \
 373         .ops            = &max77802_ldo_ops_logic##log,                 \
 374         .type           = REGULATOR_VOLTAGE,                            \
 375         .owner          = THIS_MODULE,                                  \
 376         .min_uV         = 800000,                                       \
 377         .uV_step        = 50000,                                        \
 378         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 379         .n_voltages     = 1 << 6,                                       \
 380         .vsel_reg       = MAX77802_REG_LDO1CTRL1 + num - 1,             \
 381         .vsel_mask      = MAX77802_VSEL_MASK,                           \
 382         .enable_reg     = MAX77802_REG_LDO1CTRL1 + num - 1,             \
 383         .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
 384         .of_map_mode    = max77802_map_mode,                            \
 385 }
 386
 387 /* LDOs 1, 2, 8, 15, 17, 27, 30, 35 */
 388 #define regulator_77802_desc_n_ldo(num, supply, log)   {                \
 389         .name           = "LDO"#num,                                    \
 390         .of_match       = of_match_ptr("LDO"#num),                      \
 391         .regulators_node        = of_match_ptr("regulators"),           \
 392         .id             = MAX77802_LDO##num,                            \
 393         .supply_name    = "inl"#supply,                                 \
 394         .ops            = &max77802_ldo_ops_logic##log,                 \
 395         .type           = REGULATOR_VOLTAGE,                            \
 396         .owner          = THIS_MODULE,                                  \
 397         .min_uV         = 800000,                                       \
 398         .uV_step        = 25000,                                        \
 399         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 400         .n_voltages     = 1 << 6,                                       \
 401         .vsel_reg       = MAX77802_REG_LDO1CTRL1 + num - 1,             \
 402         .vsel_mask      = MAX77802_VSEL_MASK,                           \
 403         .enable_reg     = MAX77802_REG_LDO1CTRL1 + num - 1,             \
 404         .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
 405         .of_map_mode    = max77802_map_mode,                            \
 406 }
 407
 408 /* BUCKs 1, 6 */
 409 #define regulator_77802_desc_16_buck(num)       {               \
 410         .name           = "BUCK"#num,                                   \
 411         .of_match       = of_match_ptr("BUCK"#num),                     \
 412         .regulators_node        = of_match_ptr("regulators"),           \
 413         .id             = MAX77802_BUCK##num,                           \
 414         .supply_name    = "inb"#num,                                    \
 415         .ops            = &max77802_buck_16_dvs_ops,                    \
 416         .type           = REGULATOR_VOLTAGE,                            \
 417         .owner          = THIS_MODULE,                                  \
 418         .min_uV         = 612500,                                       \
 419         .uV_step        = 6250,                                         \
 420         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 421         .n_voltages     = 1 << 8,                                       \
 422         .vsel_reg       = MAX77802_REG_BUCK ## num ## DVS1,             \
 423         .vsel_mask      = MAX77802_DVS_VSEL_MASK,                       \
 424         .enable_reg     = MAX77802_REG_BUCK ## num ## CTRL,             \
 425         .enable_mask    = MAX77802_OPMODE_MASK,                         \
 426         .of_map_mode    = max77802_map_mode,                            \
 427 }
 428
 429 /* BUCKS 2-4 */
 430 #define regulator_77802_desc_234_buck(num)      {               \
 431         .name           = "BUCK"#num,                                   \
 432         .of_match       = of_match_ptr("BUCK"#num),                     \
 433         .regulators_node        = of_match_ptr("regulators"),           \
 434         .id             = MAX77802_BUCK##num,                           \
 435         .supply_name    = "inb"#num,                                    \
 436         .ops            = &max77802_buck_234_ops,                       \
 437         .type           = REGULATOR_VOLTAGE,                            \
 438         .owner          = THIS_MODULE,                                  \
 439         .min_uV         = 600000,                                       \
 440         .uV_step        = 6250,                                         \
 441         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 442         .n_voltages     = 0x91,                                         \
 443         .vsel_reg       = MAX77802_REG_BUCK ## num ## DVS1,             \
 444         .vsel_mask      = MAX77802_DVS_VSEL_MASK,                       \
 445         .enable_reg     = MAX77802_REG_BUCK ## num ## CTRL1,            \
 446         .enable_mask    = MAX77802_OPMODE_MASK <<                       \
 447                                 MAX77802_OPMODE_BUCK234_SHIFT,          \
 448         .of_map_mode    = max77802_map_mode,                            \
 449 }
 450
 451 /* BUCK 5 */
 452 #define regulator_77802_desc_buck5(num)         {               \
 453         .name           = "BUCK"#num,                                   \
 454         .of_match       = of_match_ptr("BUCK"#num),                     \
 455         .regulators_node        = of_match_ptr("regulators"),           \
 456         .id             = MAX77802_BUCK##num,                           \
 457         .supply_name    = "inb"#num,                                    \
 458         .ops            = &max77802_buck_dvs_ops,                       \
 459         .type           = REGULATOR_VOLTAGE,                            \
 460         .owner          = THIS_MODULE,                                  \
 461         .min_uV         = 750000,                                       \
 462         .uV_step        = 50000,                                        \
 463         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 464         .n_voltages     = 1 << 6,                                       \
 465         .vsel_reg       = MAX77802_REG_BUCK5OUT,                        \
 466         .vsel_mask      = MAX77802_VSEL_MASK,                           \
 467         .enable_reg     = MAX77802_REG_BUCK5CTRL,                       \
 468         .enable_mask    = MAX77802_OPMODE_MASK,                         \
 469         .of_map_mode    = max77802_map_mode,                            \
 470 }
 471
 472 /* BUCKs 7-10 */
 473 #define regulator_77802_desc_buck7_10(num)      {               \
 474         .name           = "BUCK"#num,                                   \
 475         .of_match       = of_match_ptr("BUCK"#num),                     \
 476         .regulators_node        = of_match_ptr("regulators"),           \
 477         .id             = MAX77802_BUCK##num,                           \
 478         .supply_name    = "inb"#num,                                    \
 479         .ops            = &max77802_buck_dvs_ops,                       \
 480         .type           = REGULATOR_VOLTAGE,                            \
 481         .owner          = THIS_MODULE,                                  \
 482         .min_uV         = 750000,                                       \
 483         .uV_step        = 50000,                                        \
 484         .ramp_delay     = MAX77802_RAMP_DELAY,                          \
 485         .n_voltages     = 1 << 6,                                       \
 486         .vsel_reg       = MAX77802_REG_BUCK7OUT + (num - 7) * 3,        \
 487         .vsel_mask      = MAX77802_VSEL_MASK,                           \
 488         .enable_reg     = MAX77802_REG_BUCK7CTRL + (num - 7) * 3,       \
 489         .enable_mask    = MAX77802_OPMODE_MASK,                         \
 490         .of_map_mode    = max77802_map_mode,                            \
 491 }
 492
 493 static const struct regulator_desc regulators[] = {
 494         regulator_77802_desc_16_buck(1),
 495         regulator_77802_desc_234_buck(2),
 496         regulator_77802_desc_234_buck(3),
 497         regulator_77802_desc_234_buck(4),
 498         regulator_77802_desc_buck5(5),
 499         regulator_77802_desc_16_buck(6),
 500         regulator_77802_desc_buck7_10(7),
 501         regulator_77802_desc_buck7_10(8),
 502         regulator_77802_desc_buck7_10(9),
 503         regulator_77802_desc_buck7_10(10),
 504         regulator_77802_desc_n_ldo(1, 10, 2),
 505         regulator_77802_desc_n_ldo(2, 10, 1),
 506         regulator_77802_desc_p_ldo(3, 3, 2),
 507         regulator_77802_desc_p_ldo(4, 6, 1),
 508         regulator_77802_desc_p_ldo(5, 3, 1),
 509         regulator_77802_desc_p_ldo(6, 3, 1),
 510         regulator_77802_desc_p_ldo(7, 3, 1),
 511         regulator_77802_desc_n_ldo(8, 1, 1),
 512         regulator_77802_desc_p_ldo(9, 5, 1),
 513         regulator_77802_desc_p_ldo(10, 4, 1),
 514         regulator_77802_desc_p_ldo(11, 4, 1),
 515         regulator_77802_desc_p_ldo(12, 9, 1),
 516         regulator_77802_desc_p_ldo(13, 4, 1),
 517         regulator_77802_desc_p_ldo(14, 4, 1),
 518         regulator_77802_desc_n_ldo(15, 1, 1),
 519         regulator_77802_desc_n_ldo(17, 2, 1),
 520         regulator_77802_desc_p_ldo(18, 7, 1),
 521         regulator_77802_desc_p_ldo(19, 5, 1),
 522         regulator_77802_desc_p_ldo(20, 7, 2),
 523         regulator_77802_desc_p_ldo(21, 6, 2),
 524         regulator_77802_desc_p_ldo(23, 9, 1),
 525         regulator_77802_desc_p_ldo(24, 6, 1),
 526         regulator_77802_desc_p_ldo(25, 9, 1),
 527         regulator_77802_desc_p_ldo(26, 9, 1),
 528         regulator_77802_desc_n_ldo(27, 2, 1),
 529         regulator_77802_desc_p_ldo(28, 7, 1),
 530         regulator_77802_desc_p_ldo(29, 7, 1),
 531         regulator_77802_desc_n_ldo(30, 2, 1),
 532         regulator_77802_desc_p_ldo(32, 9, 1),
 533         regulator_77802_desc_p_ldo(33, 6, 1),
 534         regulator_77802_desc_p_ldo(34, 9, 1),
 535         regulator_77802_desc_n_ldo(35, 2, 1),
 536 };
 537
 538 static int max77802_pmic_probe(struct platform_device *pdev)
 539 {
 540         struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 541         struct max77802_regulator_prv *max77802;
 542         int i, val;
 543         struct regulator_config config = { };
 544
 545         max77802 = devm_kzalloc(&pdev->dev,
 546                                 sizeof(struct max77802_regulator_prv),
 547                                 GFP_KERNEL);
 548         if (!max77802)
 549                 return -ENOMEM;
 550
 551         config.dev = iodev->dev;
 552         config.regmap = iodev->regmap;
 553         config.driver_data = max77802;
 554         platform_set_drvdata(pdev, max77802);
 555
 556         for (i = 0; i < MAX77802_REG_MAX; i++) {
 557                 struct regulator_dev *rdev;
 558                 unsigned int id = regulators[i].id;
 559                 int shift = max77802_get_opmode_shift(id);
 560                 int ret;
 561
 562                 ret = regmap_read(iodev->regmap, regulators[i].enable_reg, &val);
 563                 if (ret < 0) {
 564                         dev_warn(&pdev->dev,
 565                                 "cannot read current mode for %d\n", i);
 566                         val = MAX77802_OPMODE_NORMAL;
 567                 } else {
 568                         val = val >> shift & MAX77802_OPMODE_MASK;
 569                 }
 570
 571                 /*
 572                  * If the regulator is disabled and the system warm rebooted,
 573                  * the hardware reports OFF as the regulator operating mode.
 574                  * Default to operating mode NORMAL in that case.
 575                  */
 576                 if (id < ARRAY_SIZE(max77802->opmode)) {
 577                         if (val == MAX77802_STATUS_OFF)
 578                                 max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
 579                         else
 580                                 max77802->opmode[id] = val;
 581                 }
 582
 583                 rdev = devm_regulator_register(&pdev->dev,
 584                                                &regulators[i], &config);
 585                 if (IS_ERR(rdev)) {
 586                         ret = PTR_ERR(rdev);
 587                         dev_err(&pdev->dev,
 588                                 "regulator init failed for %d: %d\n", i, ret);
 589                         return ret;
 590                 }
 591         }
 592
 593         return 0;
 594 }
 595
 596 static const struct platform_device_id max77802_pmic_id[] = {
 597         {"max77802-pmic", 0},
 598         { },
 599 };
 600 MODULE_DEVICE_TABLE(platform, max77802_pmic_id);
 601
 602 static struct platform_driver max77802_pmic_driver = {
 603         .driver = {
 604                 .name = "max77802-pmic",
 605         },
 606         .probe = max77802_pmic_probe,
 607         .id_table = max77802_pmic_id,
 608 };
 609
 610 module_platform_driver(max77802_pmic_driver);
 611
 612 MODULE_DESCRIPTION("MAXIM 77802 Regulator Driver");
 613 MODULE_AUTHOR("Simon Glass <sjg@chromium.org>");
 614 MODULE_LICENSE("GPL");