Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // max77686.c - Regulator driver for the Maxim 77686
0004 //
0005 // Copyright (C) 2012 Samsung Electronics
0006 // Chiwoong Byun <woong.byun@samsung.com>
0007 // Jonghwa Lee <jonghwa3.lee@samsung.com>
0008 //
0009 // This driver is based on max8997.c
0010 
0011 #include <linux/kernel.h>
0012 #include <linux/bug.h>
0013 #include <linux/err.h>
0014 #include <linux/gpio/consumer.h>
0015 #include <linux/slab.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/regulator/driver.h>
0018 #include <linux/regulator/machine.h>
0019 #include <linux/regulator/of_regulator.h>
0020 #include <linux/mfd/max77686.h>
0021 #include <linux/mfd/max77686-private.h>
0022 
0023 #define MAX77686_LDO_MINUV  800000
0024 #define MAX77686_LDO_UVSTEP 50000
0025 #define MAX77686_LDO_LOW_MINUV  800000
0026 #define MAX77686_LDO_LOW_UVSTEP 25000
0027 #define MAX77686_BUCK_MINUV 750000
0028 #define MAX77686_BUCK_UVSTEP    50000
0029 #define MAX77686_BUCK_ENABLE_TIME   40      /* us */
0030 #define MAX77686_DVS_ENABLE_TIME    22      /* us */
0031 #define MAX77686_RAMP_DELAY 100000          /* uV/us */
0032 #define MAX77686_DVS_RAMP_DELAY 27500           /* uV/us */
0033 #define MAX77686_DVS_MINUV  600000
0034 #define MAX77686_DVS_UVSTEP 12500
0035 
0036 /*
0037  * Value for configuring buck[89] and LDO{20,21,22} as GPIO control.
0038  * It is the same as 'off' for other regulators.
0039  */
0040 #define MAX77686_GPIO_CONTROL       0x0
0041 /*
0042  * Values used for configuring LDOs and bucks.
0043  * Forcing low power mode: LDO1, 3-5, 9, 13, 17-26
0044  */
0045 #define MAX77686_LDO_LOWPOWER       0x1
0046 /*
0047  * On/off controlled by PWRREQ:
0048  *  - LDO2, 6-8, 10-12, 14-16
0049  *  - buck[1234]
0050  */
0051 #define MAX77686_OFF_PWRREQ     0x1
0052 /* Low power mode controlled by PWRREQ: All LDOs */
0053 #define MAX77686_LDO_LOWPOWER_PWRREQ    0x2
0054 /* Forcing low power mode: buck[234] */
0055 #define MAX77686_BUCK_LOWPOWER      0x2
0056 #define MAX77686_NORMAL         0x3
0057 
0058 #define MAX77686_OPMODE_SHIFT   6
0059 #define MAX77686_OPMODE_BUCK234_SHIFT   4
0060 #define MAX77686_OPMODE_MASK    0x3
0061 
0062 #define MAX77686_VSEL_MASK  0x3F
0063 #define MAX77686_DVS_VSEL_MASK  0xFF
0064 
0065 #define MAX77686_RAMP_RATE_MASK 0xC0
0066 
0067 #define MAX77686_REGULATORS MAX77686_REG_MAX
0068 #define MAX77686_LDOS       26
0069 
0070 struct max77686_data {
0071     struct device *dev;
0072     DECLARE_BITMAP(gpio_enabled, MAX77686_REGULATORS);
0073 
0074     /* Array indexed by regulator id */
0075     unsigned int opmode[MAX77686_REGULATORS];
0076 };
0077 
0078 static unsigned int max77686_get_opmode_shift(int id)
0079 {
0080     switch (id) {
0081     case MAX77686_BUCK1:
0082     case MAX77686_BUCK5 ... MAX77686_BUCK9:
0083         return 0;
0084     case MAX77686_BUCK2 ... MAX77686_BUCK4:
0085         return MAX77686_OPMODE_BUCK234_SHIFT;
0086     default:
0087         /* all LDOs */
0088         return MAX77686_OPMODE_SHIFT;
0089     }
0090 }
0091 
0092 /*
0093  * When regulator is configured for GPIO control then it
0094  * replaces "normal" mode. Any change from low power mode to normal
0095  * should actually change to GPIO control.
0096  * Map normal mode to proper value for such regulators.
0097  */
0098 static unsigned int max77686_map_normal_mode(struct max77686_data *max77686,
0099                          int id)
0100 {
0101     switch (id) {
0102     case MAX77686_BUCK8:
0103     case MAX77686_BUCK9:
0104     case MAX77686_LDO20 ... MAX77686_LDO22:
0105         if (test_bit(id, max77686->gpio_enabled))
0106             return MAX77686_GPIO_CONTROL;
0107     }
0108 
0109     return MAX77686_NORMAL;
0110 }
0111 
0112 /* Some BUCKs and LDOs supports Normal[ON/OFF] mode during suspend */
0113 static int max77686_set_suspend_disable(struct regulator_dev *rdev)
0114 {
0115     unsigned int val, shift;
0116     struct max77686_data *max77686 = rdev_get_drvdata(rdev);
0117     int ret, id = rdev_get_id(rdev);
0118 
0119     shift = max77686_get_opmode_shift(id);
0120     val = MAX77686_OFF_PWRREQ;
0121 
0122     ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0123                  rdev->desc->enable_mask, val << shift);
0124     if (ret)
0125         return ret;
0126 
0127     max77686->opmode[id] = val;
0128     return 0;
0129 }
0130 
0131 /* Some LDOs supports [LPM/Normal]ON mode during suspend state */
0132 static int max77686_set_suspend_mode(struct regulator_dev *rdev,
0133                      unsigned int mode)
0134 {
0135     struct max77686_data *max77686 = rdev_get_drvdata(rdev);
0136     unsigned int val;
0137     int ret, id = rdev_get_id(rdev);
0138 
0139     /* BUCK[5-9] doesn't support this feature */
0140     if (id >= MAX77686_BUCK5)
0141         return 0;
0142 
0143     switch (mode) {
0144     case REGULATOR_MODE_IDLE:           /* ON in LP Mode */
0145         val = MAX77686_LDO_LOWPOWER_PWRREQ;
0146         break;
0147     case REGULATOR_MODE_NORMAL:         /* ON in Normal Mode */
0148         val = max77686_map_normal_mode(max77686, id);
0149         break;
0150     default:
0151         pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
0152             rdev->desc->name, mode);
0153         return -EINVAL;
0154     }
0155 
0156     ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0157                   rdev->desc->enable_mask,
0158                   val << MAX77686_OPMODE_SHIFT);
0159     if (ret)
0160         return ret;
0161 
0162     max77686->opmode[id] = val;
0163     return 0;
0164 }
0165 
0166 /* Some LDOs supports LPM-ON/OFF/Normal-ON mode during suspend state */
0167 static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
0168                      unsigned int mode)
0169 {
0170     unsigned int val;
0171     struct max77686_data *max77686 = rdev_get_drvdata(rdev);
0172     int ret, id = rdev_get_id(rdev);
0173 
0174     switch (mode) {
0175     case REGULATOR_MODE_STANDBY:            /* switch off */
0176         val = MAX77686_OFF_PWRREQ;
0177         break;
0178     case REGULATOR_MODE_IDLE:           /* ON in LP Mode */
0179         val = MAX77686_LDO_LOWPOWER_PWRREQ;
0180         break;
0181     case REGULATOR_MODE_NORMAL:         /* ON in Normal Mode */
0182         val = max77686_map_normal_mode(max77686, id);
0183         break;
0184     default:
0185         pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
0186             rdev->desc->name, mode);
0187         return -EINVAL;
0188     }
0189 
0190     ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0191                  rdev->desc->enable_mask,
0192                  val << MAX77686_OPMODE_SHIFT);
0193     if (ret)
0194         return ret;
0195 
0196     max77686->opmode[id] = val;
0197     return 0;
0198 }
0199 
0200 static int max77686_enable(struct regulator_dev *rdev)
0201 {
0202     struct max77686_data *max77686 = rdev_get_drvdata(rdev);
0203     unsigned int shift;
0204     int id = rdev_get_id(rdev);
0205 
0206     shift = max77686_get_opmode_shift(id);
0207 
0208     if (max77686->opmode[id] == MAX77686_OFF_PWRREQ)
0209         max77686->opmode[id] = max77686_map_normal_mode(max77686, id);
0210 
0211     return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
0212                   rdev->desc->enable_mask,
0213                   max77686->opmode[id] << shift);
0214 }
0215 
0216 static int max77686_of_parse_cb(struct device_node *np,
0217         const struct regulator_desc *desc,
0218         struct regulator_config *config)
0219 {
0220     struct max77686_data *max77686 = config->driver_data;
0221     int ret;
0222 
0223     switch (desc->id) {
0224     case MAX77686_BUCK8:
0225     case MAX77686_BUCK9:
0226     case MAX77686_LDO20 ... MAX77686_LDO22:
0227         config->ena_gpiod = fwnode_gpiod_get_index(
0228                 of_fwnode_handle(np),
0229                 "maxim,ena",
0230                 0,
0231                 GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_NONEXCLUSIVE,
0232                 "max77686-regulator");
0233         if (IS_ERR(config->ena_gpiod))
0234             config->ena_gpiod = NULL;
0235         break;
0236     default:
0237         return 0;
0238     }
0239 
0240     if (config->ena_gpiod) {
0241         set_bit(desc->id, max77686->gpio_enabled);
0242 
0243         ret = regmap_update_bits(config->regmap, desc->enable_reg,
0244                      desc->enable_mask,
0245                      MAX77686_GPIO_CONTROL);
0246         if (ret) {
0247             gpiod_put(config->ena_gpiod);
0248             config->ena_gpiod = NULL;
0249         }
0250     }
0251 
0252     return 0;
0253 }
0254 
0255 static const unsigned int max77686_buck_dvs_ramp_table[] = {
0256     13750, 27500, 55000, 100000
0257 };
0258 
0259 static const struct regulator_ops max77686_ops = {
0260     .list_voltage       = regulator_list_voltage_linear,
0261     .map_voltage        = regulator_map_voltage_linear,
0262     .is_enabled     = regulator_is_enabled_regmap,
0263     .enable         = max77686_enable,
0264     .disable        = regulator_disable_regmap,
0265     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0266     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0267     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0268     .set_suspend_mode   = max77686_set_suspend_mode,
0269 };
0270 
0271 static const struct regulator_ops max77686_ldo_ops = {
0272     .list_voltage       = regulator_list_voltage_linear,
0273     .map_voltage        = regulator_map_voltage_linear,
0274     .is_enabled     = regulator_is_enabled_regmap,
0275     .enable         = max77686_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_suspend_mode   = max77686_ldo_set_suspend_mode,
0281     .set_suspend_disable    = max77686_set_suspend_disable,
0282 };
0283 
0284 static const struct regulator_ops max77686_buck1_ops = {
0285     .list_voltage       = regulator_list_voltage_linear,
0286     .map_voltage        = regulator_map_voltage_linear,
0287     .is_enabled     = regulator_is_enabled_regmap,
0288     .enable         = max77686_enable,
0289     .disable        = regulator_disable_regmap,
0290     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0291     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0292     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0293     .set_suspend_disable    = max77686_set_suspend_disable,
0294 };
0295 
0296 static const struct regulator_ops max77686_buck_dvs_ops = {
0297     .list_voltage       = regulator_list_voltage_linear,
0298     .map_voltage        = regulator_map_voltage_linear,
0299     .is_enabled     = regulator_is_enabled_regmap,
0300     .enable         = max77686_enable,
0301     .disable        = regulator_disable_regmap,
0302     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0303     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0304     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0305     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0306     .set_suspend_disable    = max77686_set_suspend_disable,
0307 };
0308 
0309 #define regulator_desc_ldo(num)     {               \
0310     .name       = "LDO"#num,                    \
0311     .of_match   = of_match_ptr("LDO"#num),          \
0312     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0313     .of_parse_cb    = max77686_of_parse_cb,             \
0314     .id     = MAX77686_LDO##num,                \
0315     .ops        = &max77686_ops,                \
0316     .type       = REGULATOR_VOLTAGE,                \
0317     .owner      = THIS_MODULE,                  \
0318     .min_uV     = MAX77686_LDO_MINUV,               \
0319     .uV_step    = MAX77686_LDO_UVSTEP,              \
0320     .ramp_delay = MAX77686_RAMP_DELAY,              \
0321     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0322     .vsel_reg   = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0323     .vsel_mask  = MAX77686_VSEL_MASK,               \
0324     .enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0325     .enable_mask    = MAX77686_OPMODE_MASK              \
0326             << MAX77686_OPMODE_SHIFT,           \
0327 }
0328 #define regulator_desc_lpm_ldo(num) {               \
0329     .name       = "LDO"#num,                    \
0330     .of_match   = of_match_ptr("LDO"#num),          \
0331     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0332     .id     = MAX77686_LDO##num,                \
0333     .ops        = &max77686_ldo_ops,                \
0334     .type       = REGULATOR_VOLTAGE,                \
0335     .owner      = THIS_MODULE,                  \
0336     .min_uV     = MAX77686_LDO_MINUV,               \
0337     .uV_step    = MAX77686_LDO_UVSTEP,              \
0338     .ramp_delay = MAX77686_RAMP_DELAY,              \
0339     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0340     .vsel_reg   = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0341     .vsel_mask  = MAX77686_VSEL_MASK,               \
0342     .enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0343     .enable_mask    = MAX77686_OPMODE_MASK              \
0344             << MAX77686_OPMODE_SHIFT,           \
0345 }
0346 #define regulator_desc_ldo_low(num)     {           \
0347     .name       = "LDO"#num,                    \
0348     .of_match   = of_match_ptr("LDO"#num),          \
0349     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0350     .id     = MAX77686_LDO##num,                \
0351     .ops        = &max77686_ldo_ops,                \
0352     .type       = REGULATOR_VOLTAGE,                \
0353     .owner      = THIS_MODULE,                  \
0354     .min_uV     = MAX77686_LDO_LOW_MINUV,           \
0355     .uV_step    = MAX77686_LDO_LOW_UVSTEP,          \
0356     .ramp_delay = MAX77686_RAMP_DELAY,              \
0357     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0358     .vsel_reg   = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0359     .vsel_mask  = MAX77686_VSEL_MASK,               \
0360     .enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0361     .enable_mask    = MAX77686_OPMODE_MASK              \
0362             << MAX77686_OPMODE_SHIFT,           \
0363 }
0364 #define regulator_desc_ldo1_low(num)        {           \
0365     .name       = "LDO"#num,                    \
0366     .of_match   = of_match_ptr("LDO"#num),          \
0367     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0368     .id     = MAX77686_LDO##num,                \
0369     .ops        = &max77686_ops,                \
0370     .type       = REGULATOR_VOLTAGE,                \
0371     .owner      = THIS_MODULE,                  \
0372     .min_uV     = MAX77686_LDO_LOW_MINUV,           \
0373     .uV_step    = MAX77686_LDO_LOW_UVSTEP,          \
0374     .ramp_delay = MAX77686_RAMP_DELAY,              \
0375     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0376     .vsel_reg   = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0377     .vsel_mask  = MAX77686_VSEL_MASK,               \
0378     .enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1,     \
0379     .enable_mask    = MAX77686_OPMODE_MASK              \
0380             << MAX77686_OPMODE_SHIFT,           \
0381 }
0382 #define regulator_desc_buck(num)        {           \
0383     .name       = "BUCK"#num,                   \
0384     .of_match   = of_match_ptr("BUCK"#num),         \
0385     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0386     .of_parse_cb    = max77686_of_parse_cb,             \
0387     .id     = MAX77686_BUCK##num,               \
0388     .ops        = &max77686_ops,                \
0389     .type       = REGULATOR_VOLTAGE,                \
0390     .owner      = THIS_MODULE,                  \
0391     .min_uV     = MAX77686_BUCK_MINUV,              \
0392     .uV_step    = MAX77686_BUCK_UVSTEP,             \
0393     .ramp_delay = MAX77686_RAMP_DELAY,              \
0394     .enable_time    = MAX77686_BUCK_ENABLE_TIME,            \
0395     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0396     .vsel_reg   = MAX77686_REG_BUCK5OUT + (num - 5) * 2,    \
0397     .vsel_mask  = MAX77686_VSEL_MASK,               \
0398     .enable_reg = MAX77686_REG_BUCK5CTRL + (num - 5) * 2,   \
0399     .enable_mask    = MAX77686_OPMODE_MASK,             \
0400 }
0401 #define regulator_desc_buck1(num)       {           \
0402     .name       = "BUCK"#num,                   \
0403     .of_match   = of_match_ptr("BUCK"#num),         \
0404     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0405     .id     = MAX77686_BUCK##num,               \
0406     .ops        = &max77686_buck1_ops,              \
0407     .type       = REGULATOR_VOLTAGE,                \
0408     .owner      = THIS_MODULE,                  \
0409     .min_uV     = MAX77686_BUCK_MINUV,              \
0410     .uV_step    = MAX77686_BUCK_UVSTEP,             \
0411     .ramp_delay = MAX77686_RAMP_DELAY,              \
0412     .enable_time    = MAX77686_BUCK_ENABLE_TIME,            \
0413     .n_voltages = MAX77686_VSEL_MASK + 1,           \
0414     .vsel_reg   = MAX77686_REG_BUCK1OUT,            \
0415     .vsel_mask  = MAX77686_VSEL_MASK,               \
0416     .enable_reg = MAX77686_REG_BUCK1CTRL,           \
0417     .enable_mask    = MAX77686_OPMODE_MASK,             \
0418 }
0419 #define regulator_desc_buck_dvs(num)        {           \
0420     .name       = "BUCK"#num,                   \
0421     .of_match   = of_match_ptr("BUCK"#num),         \
0422     .regulators_node    = of_match_ptr("voltage-regulators"),   \
0423     .id     = MAX77686_BUCK##num,               \
0424     .ops        = &max77686_buck_dvs_ops,           \
0425     .type       = REGULATOR_VOLTAGE,                \
0426     .owner      = THIS_MODULE,                  \
0427     .min_uV     = MAX77686_DVS_MINUV,               \
0428     .uV_step    = MAX77686_DVS_UVSTEP,              \
0429     .ramp_delay = MAX77686_DVS_RAMP_DELAY,          \
0430     .enable_time    = MAX77686_DVS_ENABLE_TIME,         \
0431     .n_voltages = MAX77686_DVS_VSEL_MASK + 1,           \
0432     .vsel_reg   = MAX77686_REG_BUCK2DVS1 + (num - 2) * 10,  \
0433     .vsel_mask  = MAX77686_DVS_VSEL_MASK,           \
0434     .enable_reg = MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10, \
0435     .enable_mask    = MAX77686_OPMODE_MASK              \
0436             << MAX77686_OPMODE_BUCK234_SHIFT,       \
0437     .ramp_reg   = MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10, \
0438     .ramp_mask  = MAX77686_RAMP_RATE_MASK,          \
0439     .ramp_delay_table = max77686_buck_dvs_ramp_table,       \
0440     .n_ramp_values  = ARRAY_SIZE(max77686_buck_dvs_ramp_table), \
0441 }
0442 
0443 static const struct regulator_desc regulators[] = {
0444     regulator_desc_ldo1_low(1),
0445     regulator_desc_ldo_low(2),
0446     regulator_desc_ldo(3),
0447     regulator_desc_ldo(4),
0448     regulator_desc_ldo(5),
0449     regulator_desc_ldo_low(6),
0450     regulator_desc_ldo_low(7),
0451     regulator_desc_ldo_low(8),
0452     regulator_desc_ldo(9),
0453     regulator_desc_lpm_ldo(10),
0454     regulator_desc_lpm_ldo(11),
0455     regulator_desc_lpm_ldo(12),
0456     regulator_desc_ldo(13),
0457     regulator_desc_lpm_ldo(14),
0458     regulator_desc_ldo_low(15),
0459     regulator_desc_lpm_ldo(16),
0460     regulator_desc_ldo(17),
0461     regulator_desc_ldo(18),
0462     regulator_desc_ldo(19),
0463     regulator_desc_ldo(20),
0464     regulator_desc_ldo(21),
0465     regulator_desc_ldo(22),
0466     regulator_desc_ldo(23),
0467     regulator_desc_ldo(24),
0468     regulator_desc_ldo(25),
0469     regulator_desc_ldo(26),
0470     regulator_desc_buck1(1),
0471     regulator_desc_buck_dvs(2),
0472     regulator_desc_buck_dvs(3),
0473     regulator_desc_buck_dvs(4),
0474     regulator_desc_buck(5),
0475     regulator_desc_buck(6),
0476     regulator_desc_buck(7),
0477     regulator_desc_buck(8),
0478     regulator_desc_buck(9),
0479 };
0480 
0481 static int max77686_pmic_probe(struct platform_device *pdev)
0482 {
0483     struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
0484     struct max77686_data *max77686;
0485     int i;
0486     struct regulator_config config = { };
0487 
0488     dev_dbg(&pdev->dev, "%s\n", __func__);
0489 
0490     max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
0491                 GFP_KERNEL);
0492     if (!max77686)
0493         return -ENOMEM;
0494 
0495     max77686->dev = &pdev->dev;
0496     config.dev = iodev->dev;
0497     config.regmap = iodev->regmap;
0498     config.driver_data = max77686;
0499     platform_set_drvdata(pdev, max77686);
0500 
0501     for (i = 0; i < MAX77686_REGULATORS; i++) {
0502         struct regulator_dev *rdev;
0503         int id = regulators[i].id;
0504 
0505         max77686->opmode[id] = MAX77686_NORMAL;
0506         rdev = devm_regulator_register(&pdev->dev,
0507                         &regulators[i], &config);
0508         if (IS_ERR(rdev)) {
0509             int ret = PTR_ERR(rdev);
0510             dev_err(&pdev->dev,
0511                 "regulator init failed for %d: %d\n", i, ret);
0512             return ret;
0513         }
0514     }
0515 
0516     return 0;
0517 }
0518 
0519 static const struct platform_device_id max77686_pmic_id[] = {
0520     {"max77686-pmic", 0},
0521     { },
0522 };
0523 MODULE_DEVICE_TABLE(platform, max77686_pmic_id);
0524 
0525 static struct platform_driver max77686_pmic_driver = {
0526     .driver = {
0527         .name = "max77686-pmic",
0528     },
0529     .probe = max77686_pmic_probe,
0530     .id_table = max77686_pmic_id,
0531 };
0532 
0533 module_platform_driver(max77686_pmic_driver);
0534 
0535 MODULE_DESCRIPTION("MAXIM 77686 Regulator Driver");
0536 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
0537 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!