Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // max77802.c - Regulator driver for the Maxim 77802
0004 //
0005 // Copyright (C) 2013-2014 Google, Inc
0006 // Simon Glass <sjg@chromium.org>
0007 //
0008 // Copyright (C) 2012 Samsung Electronics
0009 // Chiwoong Byun <woong.byun@samsung.com>
0010 // Jonghwa Lee <jonghwa3.lee@samsung.com>
0011 //
0012 // This driver is based on max8997.c
0013 
0014 #include <linux/kernel.h>
0015 #include <linux/bug.h>
0016 #include <linux/err.h>
0017 #include <linux/slab.h>
0018 #include <linux/module.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/regulator/driver.h>
0021 #include <linux/regulator/machine.h>
0022 #include <linux/regulator/of_regulator.h>
0023 #include <linux/mfd/max77686.h>
0024 #include <linux/mfd/max77686-private.h>
0025 #include <dt-bindings/regulator/maxim,max77802.h>
0026 
0027 /* Default ramp delay in case it is not manually set */
0028 #define MAX77802_RAMP_DELAY     100000      /* uV/us */
0029 
0030 #define MAX77802_OPMODE_SHIFT_LDO   6
0031 #define MAX77802_OPMODE_BUCK234_SHIFT   4
0032 #define MAX77802_OPMODE_MASK        0x3
0033 
0034 #define MAX77802_VSEL_MASK      0x3F
0035 #define MAX77802_DVS_VSEL_MASK      0xFF
0036 
0037 #define MAX77802_RAMP_RATE_MASK_2BIT    0xC0
0038 #define MAX77802_RAMP_RATE_SHIFT_2BIT   6
0039 #define MAX77802_RAMP_RATE_MASK_4BIT    0xF0
0040 #define MAX77802_RAMP_RATE_SHIFT_4BIT   4
0041 
0042 #define MAX77802_STATUS_OFF     0x0
0043 #define MAX77802_OFF_PWRREQ     0x1
0044 #define MAX77802_LP_PWRREQ      0x2
0045 
0046 static const unsigned int max77802_buck234_ramp_table[] = {
0047     12500,
0048     25000,
0049     50000,
0050     100000,
0051 };
0052 
0053 static const unsigned int max77802_buck16_ramp_table[] = {
0054     1000,   2000,   3030,   4000,
0055     5000,   5880,   7140,   8330,
0056     9090,   10000,  11110,  12500,
0057     16670,  25000,  50000,  100000,
0058 };
0059 
0060 struct max77802_regulator_prv {
0061     /* Array indexed by regulator id */
0062     unsigned int opmode[MAX77802_REG_MAX];
0063 };
0064 
0065 static inline unsigned int max77802_map_mode(unsigned int mode)
0066 {
0067     return mode == MAX77802_OPMODE_NORMAL ?
0068         REGULATOR_MODE_NORMAL : REGULATOR_MODE_STANDBY;
0069 }
0070 
0071 static int max77802_get_opmode_shift(int id)
0072 {
0073     if (id == MAX77802_BUCK1 || (id >= MAX77802_BUCK5 &&
0074                      id <= MAX77802_BUCK10))
0075         return 0;
0076 
0077     if (id >= MAX77802_BUCK2 && id <= MAX77802_BUCK4)
0078         return MAX77802_OPMODE_BUCK234_SHIFT;
0079 
0080     if (id >= MAX77802_LDO1 && id <= MAX77802_LDO35)
0081         return MAX77802_OPMODE_SHIFT_LDO;
0082 
0083     return -EINVAL;
0084 }
0085 
0086 /**
0087  * max77802_set_suspend_disable - Disable the regulator during system suspend
0088  * @rdev: regulator to mark as disabled
0089  *
0090  * All regulators expect LDO 1, 3, 20 and 21 support OFF by PWRREQ.
0091  * Configure the regulator so the PMIC will turn it OFF during system suspend.
0092  */
0093 static int max77802_set_suspend_disable(struct regulator_dev *rdev)
0094 {
0095     unsigned int val = MAX77802_OFF_PWRREQ;
0096     struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
0097     int id = rdev_get_id(rdev);
0098     int shift = max77802_get_opmode_shift(id);
0099 
0100     max77802->opmode[id] = val;
0101     return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0102                   rdev->desc->enable_mask, val << shift);
0103 }
0104 
0105 /*
0106  * Some LDOs support Low Power Mode while the system is running.
0107  *
0108  * LDOs 1, 3, 20, 21.
0109  */
0110 static int max77802_set_mode(struct regulator_dev *rdev, unsigned int mode)
0111 {
0112     struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
0113     int id = rdev_get_id(rdev);
0114     unsigned int val;
0115     int shift = max77802_get_opmode_shift(id);
0116 
0117     switch (mode) {
0118     case REGULATOR_MODE_STANDBY:
0119         val = MAX77802_OPMODE_LP;   /* ON in Low Power Mode */
0120         break;
0121     case REGULATOR_MODE_NORMAL:
0122         val = MAX77802_OPMODE_NORMAL;   /* ON in Normal Mode */
0123         break;
0124     default:
0125         dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
0126              rdev->desc->name, mode);
0127         return -EINVAL;
0128     }
0129 
0130     max77802->opmode[id] = val;
0131     return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0132                   rdev->desc->enable_mask, val << shift);
0133 }
0134 
0135 static unsigned max77802_get_mode(struct regulator_dev *rdev)
0136 {
0137     struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
0138     int id = rdev_get_id(rdev);
0139 
0140     return max77802_map_mode(max77802->opmode[id]);
0141 }
0142 
0143 /**
0144  * max77802_set_suspend_mode - set regulator opmode when the system is suspended
0145  * @rdev: regulator to change mode
0146  * @mode: operating mode to be set
0147  *
0148  * Will set the operating mode for the regulators during system suspend.
0149  * This function is valid for the three different enable control logics:
0150  *
0151  * Enable Control Logic1 by PWRREQ (BUCK 2-4 and LDOs 2, 4-19, 22-35)
0152  * Enable Control Logic2 by PWRREQ (LDOs 1, 20, 21)
0153  * Enable Control Logic3 by PWRREQ (LDO 3)
0154  *
0155  * If setting the regulator mode fails, the function only warns but does
0156  * not return an error code to avoid the regulator core to stop setting
0157  * the operating mode for the remaining regulators.
0158  */
0159 static int max77802_set_suspend_mode(struct regulator_dev *rdev,
0160                      unsigned int mode)
0161 {
0162     struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
0163     int id = rdev_get_id(rdev);
0164     unsigned int val;
0165     int shift = max77802_get_opmode_shift(id);
0166 
0167     /*
0168      * If the regulator has been disabled for suspend
0169      * then is invalid to try setting a suspend mode.
0170      */
0171     if (max77802->opmode[id] == MAX77802_OFF_PWRREQ) {
0172         dev_warn(&rdev->dev, "%s: is disabled, mode: 0x%x not set\n",
0173              rdev->desc->name, mode);
0174         return 0;
0175     }
0176 
0177     switch (mode) {
0178     case REGULATOR_MODE_STANDBY:
0179         /*
0180          * If the regulator opmode is normal then enable
0181          * ON in Low Power Mode by PWRREQ. If the mode is
0182          * already Low Power then no action is required.
0183          */
0184         if (max77802->opmode[id] == MAX77802_OPMODE_NORMAL)
0185             val = MAX77802_LP_PWRREQ;
0186         else
0187             return 0;
0188         break;
0189     case REGULATOR_MODE_NORMAL:
0190         /*
0191          * If the regulator operating mode is Low Power then
0192          * normal is not a valid opmode in suspend. If the
0193          * mode is already normal then no action is required.
0194          */
0195         if (max77802->opmode[id] == MAX77802_OPMODE_LP)
0196             dev_warn(&rdev->dev, "%s: in Low Power: 0x%x invalid\n",
0197                  rdev->desc->name, mode);
0198         return 0;
0199     default:
0200         dev_warn(&rdev->dev, "%s: regulator mode: 0x%x not supported\n",
0201              rdev->desc->name, mode);
0202         return -EINVAL;
0203     }
0204 
0205     return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0206                   rdev->desc->enable_mask, val << shift);
0207 }
0208 
0209 static int max77802_enable(struct regulator_dev *rdev)
0210 {
0211     struct max77802_regulator_prv *max77802 = rdev_get_drvdata(rdev);
0212     int id = rdev_get_id(rdev);
0213     int shift = max77802_get_opmode_shift(id);
0214 
0215     if (max77802->opmode[id] == MAX77802_OFF_PWRREQ)
0216         max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
0217 
0218     return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0219                   rdev->desc->enable_mask,
0220                   max77802->opmode[id] << shift);
0221 }
0222 
0223 /*
0224  * LDOs 2, 4-19, 22-35
0225  */
0226 static const struct regulator_ops max77802_ldo_ops_logic1 = {
0227     .list_voltage       = regulator_list_voltage_linear,
0228     .map_voltage        = regulator_map_voltage_linear,
0229     .is_enabled     = regulator_is_enabled_regmap,
0230     .enable         = max77802_enable,
0231     .disable        = regulator_disable_regmap,
0232     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0233     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0234     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0235     .set_suspend_disable    = max77802_set_suspend_disable,
0236     .set_suspend_mode   = max77802_set_suspend_mode,
0237 };
0238 
0239 /*
0240  * LDOs 1, 20, 21, 3
0241  */
0242 static const struct regulator_ops max77802_ldo_ops_logic2 = {
0243     .list_voltage       = regulator_list_voltage_linear,
0244     .map_voltage        = regulator_map_voltage_linear,
0245     .is_enabled     = regulator_is_enabled_regmap,
0246     .enable         = max77802_enable,
0247     .disable        = regulator_disable_regmap,
0248     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0249     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0250     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0251     .set_mode       = max77802_set_mode,
0252     .get_mode       = max77802_get_mode,
0253     .set_suspend_mode   = max77802_set_suspend_mode,
0254 };
0255 
0256 /* BUCKS 1, 6 */
0257 static const struct regulator_ops max77802_buck_16_dvs_ops = {
0258     .list_voltage       = regulator_list_voltage_linear,
0259     .map_voltage        = regulator_map_voltage_linear,
0260     .is_enabled     = regulator_is_enabled_regmap,
0261     .enable         = max77802_enable,
0262     .disable        = regulator_disable_regmap,
0263     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0264     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0265     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0266     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0267     .set_suspend_disable    = max77802_set_suspend_disable,
0268 };
0269 
0270 /* BUCKs 2-4 */
0271 static const struct regulator_ops max77802_buck_234_ops = {
0272     .list_voltage       = regulator_list_voltage_linear,
0273     .map_voltage        = regulator_map_voltage_linear,
0274     .is_enabled     = regulator_is_enabled_regmap,
0275     .enable         = max77802_enable,
0276     .disable        = regulator_disable_regmap,
0277     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0278     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0279     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0280     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0281     .set_suspend_disable    = max77802_set_suspend_disable,
0282     .set_suspend_mode   = max77802_set_suspend_mode,
0283 };
0284 
0285 /* BUCKs 5, 7-10 */
0286 static const struct regulator_ops max77802_buck_dvs_ops = {
0287     .list_voltage       = regulator_list_voltage_linear,
0288     .map_voltage        = regulator_map_voltage_linear,
0289     .is_enabled     = regulator_is_enabled_regmap,
0290     .enable         = max77802_enable,
0291     .disable        = regulator_disable_regmap,
0292     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0293     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0294     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0295     .set_suspend_disable    = max77802_set_suspend_disable,
0296 };
0297 
0298 /* LDOs 3-7, 9-14, 18-26, 28, 29, 32-34 */
0299 #define regulator_77802_desc_p_ldo(num, supply, log)    {       \
0300     .name       = "LDO"#num,                    \
0301     .of_match   = of_match_ptr("LDO"#num),          \
0302     .regulators_node    = of_match_ptr("regulators"),       \
0303     .id     = MAX77802_LDO##num,                \
0304     .supply_name    = "inl"#supply,                 \
0305     .ops        = &max77802_ldo_ops_logic##log,         \
0306     .type       = REGULATOR_VOLTAGE,                \
0307     .owner      = THIS_MODULE,                  \
0308     .min_uV     = 800000,                   \
0309     .uV_step    = 50000,                    \
0310     .ramp_delay = MAX77802_RAMP_DELAY,              \
0311     .n_voltages = 1 << 6,                   \
0312     .vsel_reg   = MAX77802_REG_LDO1CTRL1 + num - 1,     \
0313     .vsel_mask  = MAX77802_VSEL_MASK,               \
0314     .enable_reg = MAX77802_REG_LDO1CTRL1 + num - 1,     \
0315     .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
0316     .of_map_mode    = max77802_map_mode,                \
0317 }
0318 
0319 /* LDOs 1, 2, 8, 15, 17, 27, 30, 35 */
0320 #define regulator_77802_desc_n_ldo(num, supply, log)   {        \
0321     .name       = "LDO"#num,                    \
0322     .of_match   = of_match_ptr("LDO"#num),          \
0323     .regulators_node    = of_match_ptr("regulators"),       \
0324     .id     = MAX77802_LDO##num,                \
0325     .supply_name    = "inl"#supply,                 \
0326     .ops        = &max77802_ldo_ops_logic##log,         \
0327     .type       = REGULATOR_VOLTAGE,                \
0328     .owner      = THIS_MODULE,                  \
0329     .min_uV     = 800000,                   \
0330     .uV_step    = 25000,                    \
0331     .ramp_delay = MAX77802_RAMP_DELAY,              \
0332     .n_voltages = 1 << 6,                   \
0333     .vsel_reg   = MAX77802_REG_LDO1CTRL1 + num - 1,     \
0334     .vsel_mask  = MAX77802_VSEL_MASK,               \
0335     .enable_reg = MAX77802_REG_LDO1CTRL1 + num - 1,     \
0336     .enable_mask    = MAX77802_OPMODE_MASK << MAX77802_OPMODE_SHIFT_LDO, \
0337     .of_map_mode    = max77802_map_mode,                \
0338 }
0339 
0340 /* BUCKs 1, 6 */
0341 #define regulator_77802_desc_16_buck(num)   {       \
0342     .name       = "BUCK"#num,                   \
0343     .of_match   = of_match_ptr("BUCK"#num),         \
0344     .regulators_node    = of_match_ptr("regulators"),       \
0345     .id     = MAX77802_BUCK##num,               \
0346     .supply_name    = "inb"#num,                    \
0347     .ops        = &max77802_buck_16_dvs_ops,            \
0348     .type       = REGULATOR_VOLTAGE,                \
0349     .owner      = THIS_MODULE,                  \
0350     .min_uV     = 612500,                   \
0351     .uV_step    = 6250,                     \
0352     .ramp_delay = MAX77802_RAMP_DELAY,              \
0353     .n_voltages = 1 << 8,                   \
0354     .vsel_reg   = MAX77802_REG_BUCK ## num ## DVS1,     \
0355     .vsel_mask  = MAX77802_DVS_VSEL_MASK,           \
0356     .enable_reg = MAX77802_REG_BUCK ## num ## CTRL,     \
0357     .enable_mask    = MAX77802_OPMODE_MASK,             \
0358     .ramp_reg   = MAX77802_REG_BUCK ## num ## CTRL,     \
0359     .ramp_mask  = MAX77802_RAMP_RATE_MASK_4BIT,         \
0360     .ramp_delay_table = max77802_buck16_ramp_table,         \
0361     .n_ramp_values  = ARRAY_SIZE(max77802_buck16_ramp_table),   \
0362     .of_map_mode    = max77802_map_mode,                \
0363 }
0364 
0365 /* BUCKS 2-4 */
0366 #define regulator_77802_desc_234_buck(num)  {       \
0367     .name       = "BUCK"#num,                   \
0368     .of_match   = of_match_ptr("BUCK"#num),         \
0369     .regulators_node    = of_match_ptr("regulators"),       \
0370     .id     = MAX77802_BUCK##num,               \
0371     .supply_name    = "inb"#num,                    \
0372     .ops        = &max77802_buck_234_ops,           \
0373     .type       = REGULATOR_VOLTAGE,                \
0374     .owner      = THIS_MODULE,                  \
0375     .min_uV     = 600000,                   \
0376     .uV_step    = 6250,                     \
0377     .ramp_delay = MAX77802_RAMP_DELAY,              \
0378     .n_voltages = 0x91,                     \
0379     .vsel_reg   = MAX77802_REG_BUCK ## num ## DVS1,     \
0380     .vsel_mask  = MAX77802_DVS_VSEL_MASK,           \
0381     .enable_reg = MAX77802_REG_BUCK ## num ## CTRL1,        \
0382     .enable_mask    = MAX77802_OPMODE_MASK <<           \
0383                 MAX77802_OPMODE_BUCK234_SHIFT,      \
0384     .ramp_reg   = MAX77802_REG_BUCK ## num ## CTRL1,        \
0385     .ramp_mask  = MAX77802_RAMP_RATE_MASK_2BIT,         \
0386     .ramp_delay_table = max77802_buck234_ramp_table,        \
0387     .n_ramp_values  = ARRAY_SIZE(max77802_buck234_ramp_table),  \
0388     .of_map_mode    = max77802_map_mode,                \
0389 }
0390 
0391 /* BUCK 5 */
0392 #define regulator_77802_desc_buck5(num)     {       \
0393     .name       = "BUCK"#num,                   \
0394     .of_match   = of_match_ptr("BUCK"#num),         \
0395     .regulators_node    = of_match_ptr("regulators"),       \
0396     .id     = MAX77802_BUCK##num,               \
0397     .supply_name    = "inb"#num,                    \
0398     .ops        = &max77802_buck_dvs_ops,           \
0399     .type       = REGULATOR_VOLTAGE,                \
0400     .owner      = THIS_MODULE,                  \
0401     .min_uV     = 750000,                   \
0402     .uV_step    = 50000,                    \
0403     .ramp_delay = MAX77802_RAMP_DELAY,              \
0404     .n_voltages = 1 << 6,                   \
0405     .vsel_reg   = MAX77802_REG_BUCK5OUT,            \
0406     .vsel_mask  = MAX77802_VSEL_MASK,               \
0407     .enable_reg = MAX77802_REG_BUCK5CTRL,           \
0408     .enable_mask    = MAX77802_OPMODE_MASK,             \
0409     .of_map_mode    = max77802_map_mode,                \
0410 }
0411 
0412 /* BUCKs 7-10 */
0413 #define regulator_77802_desc_buck7_10(num)  {       \
0414     .name       = "BUCK"#num,                   \
0415     .of_match   = of_match_ptr("BUCK"#num),         \
0416     .regulators_node    = of_match_ptr("regulators"),       \
0417     .id     = MAX77802_BUCK##num,               \
0418     .supply_name    = "inb"#num,                    \
0419     .ops        = &max77802_buck_dvs_ops,           \
0420     .type       = REGULATOR_VOLTAGE,                \
0421     .owner      = THIS_MODULE,                  \
0422     .min_uV     = 750000,                   \
0423     .uV_step    = 50000,                    \
0424     .ramp_delay = MAX77802_RAMP_DELAY,              \
0425     .n_voltages = 1 << 6,                   \
0426     .vsel_reg   = MAX77802_REG_BUCK7OUT + (num - 7) * 3,    \
0427     .vsel_mask  = MAX77802_VSEL_MASK,               \
0428     .enable_reg = MAX77802_REG_BUCK7CTRL + (num - 7) * 3,   \
0429     .enable_mask    = MAX77802_OPMODE_MASK,             \
0430     .of_map_mode    = max77802_map_mode,                \
0431 }
0432 
0433 static const struct regulator_desc regulators[] = {
0434     regulator_77802_desc_16_buck(1),
0435     regulator_77802_desc_234_buck(2),
0436     regulator_77802_desc_234_buck(3),
0437     regulator_77802_desc_234_buck(4),
0438     regulator_77802_desc_buck5(5),
0439     regulator_77802_desc_16_buck(6),
0440     regulator_77802_desc_buck7_10(7),
0441     regulator_77802_desc_buck7_10(8),
0442     regulator_77802_desc_buck7_10(9),
0443     regulator_77802_desc_buck7_10(10),
0444     regulator_77802_desc_n_ldo(1, 10, 2),
0445     regulator_77802_desc_n_ldo(2, 10, 1),
0446     regulator_77802_desc_p_ldo(3, 3, 2),
0447     regulator_77802_desc_p_ldo(4, 6, 1),
0448     regulator_77802_desc_p_ldo(5, 3, 1),
0449     regulator_77802_desc_p_ldo(6, 3, 1),
0450     regulator_77802_desc_p_ldo(7, 3, 1),
0451     regulator_77802_desc_n_ldo(8, 1, 1),
0452     regulator_77802_desc_p_ldo(9, 5, 1),
0453     regulator_77802_desc_p_ldo(10, 4, 1),
0454     regulator_77802_desc_p_ldo(11, 4, 1),
0455     regulator_77802_desc_p_ldo(12, 9, 1),
0456     regulator_77802_desc_p_ldo(13, 4, 1),
0457     regulator_77802_desc_p_ldo(14, 4, 1),
0458     regulator_77802_desc_n_ldo(15, 1, 1),
0459     regulator_77802_desc_n_ldo(17, 2, 1),
0460     regulator_77802_desc_p_ldo(18, 7, 1),
0461     regulator_77802_desc_p_ldo(19, 5, 1),
0462     regulator_77802_desc_p_ldo(20, 7, 2),
0463     regulator_77802_desc_p_ldo(21, 6, 2),
0464     regulator_77802_desc_p_ldo(23, 9, 1),
0465     regulator_77802_desc_p_ldo(24, 6, 1),
0466     regulator_77802_desc_p_ldo(25, 9, 1),
0467     regulator_77802_desc_p_ldo(26, 9, 1),
0468     regulator_77802_desc_n_ldo(27, 2, 1),
0469     regulator_77802_desc_p_ldo(28, 7, 1),
0470     regulator_77802_desc_p_ldo(29, 7, 1),
0471     regulator_77802_desc_n_ldo(30, 2, 1),
0472     regulator_77802_desc_p_ldo(32, 9, 1),
0473     regulator_77802_desc_p_ldo(33, 6, 1),
0474     regulator_77802_desc_p_ldo(34, 9, 1),
0475     regulator_77802_desc_n_ldo(35, 2, 1),
0476 };
0477 
0478 static int max77802_pmic_probe(struct platform_device *pdev)
0479 {
0480     struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
0481     struct max77802_regulator_prv *max77802;
0482     int i, val;
0483     struct regulator_config config = { };
0484 
0485     max77802 = devm_kzalloc(&pdev->dev,
0486                 sizeof(struct max77802_regulator_prv),
0487                 GFP_KERNEL);
0488     if (!max77802)
0489         return -ENOMEM;
0490 
0491     config.dev = iodev->dev;
0492     config.regmap = iodev->regmap;
0493     config.driver_data = max77802;
0494     platform_set_drvdata(pdev, max77802);
0495 
0496     for (i = 0; i < MAX77802_REG_MAX; i++) {
0497         struct regulator_dev *rdev;
0498         int id = regulators[i].id;
0499         int shift = max77802_get_opmode_shift(id);
0500         int ret;
0501 
0502         ret = regmap_read(iodev->regmap, regulators[i].enable_reg, &val);
0503         if (ret < 0) {
0504             dev_warn(&pdev->dev,
0505                 "cannot read current mode for %d\n", i);
0506             val = MAX77802_OPMODE_NORMAL;
0507         } else {
0508             val = val >> shift & MAX77802_OPMODE_MASK;
0509         }
0510 
0511         /*
0512          * If the regulator is disabled and the system warm rebooted,
0513          * the hardware reports OFF as the regulator operating mode.
0514          * Default to operating mode NORMAL in that case.
0515          */
0516         if (val == MAX77802_STATUS_OFF)
0517             max77802->opmode[id] = MAX77802_OPMODE_NORMAL;
0518         else
0519             max77802->opmode[id] = val;
0520 
0521         rdev = devm_regulator_register(&pdev->dev,
0522                            &regulators[i], &config);
0523         if (IS_ERR(rdev)) {
0524             ret = PTR_ERR(rdev);
0525             dev_err(&pdev->dev,
0526                 "regulator init failed for %d: %d\n", i, ret);
0527             return ret;
0528         }
0529     }
0530 
0531     return 0;
0532 }
0533 
0534 static const struct platform_device_id max77802_pmic_id[] = {
0535     {"max77802-pmic", 0},
0536     { },
0537 };
0538 MODULE_DEVICE_TABLE(platform, max77802_pmic_id);
0539 
0540 static struct platform_driver max77802_pmic_driver = {
0541     .driver = {
0542         .name = "max77802-pmic",
0543     },
0544     .probe = max77802_pmic_probe,
0545     .id_table = max77802_pmic_id,
0546 };
0547 
0548 module_platform_driver(max77802_pmic_driver);
0549 
0550 MODULE_DESCRIPTION("MAXIM 77802 Regulator Driver");
0551 MODULE_AUTHOR("Simon Glass <sjg@chromium.org>");
0552 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!