Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // Regulator driver for DA9063 PMIC series
0004 //
0005 // Copyright 2012 Dialog Semiconductors Ltd.
0006 // Copyright 2013 Philipp Zabel, Pengutronix
0007 //
0008 // Author: Krystian Garbaciak <krystian.garbaciak@diasemi.com>
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/init.h>
0013 #include <linux/err.h>
0014 #include <linux/slab.h>
0015 #include <linux/of.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/regmap.h>
0018 #include <linux/regulator/driver.h>
0019 #include <linux/regulator/machine.h>
0020 #include <linux/regulator/of_regulator.h>
0021 #include <linux/mfd/da9063/core.h>
0022 #include <linux/mfd/da9063/registers.h>
0023 
0024 
0025 /* Definition for registering regmap bit fields using a mask */
0026 #define BFIELD(_reg, _mask) \
0027     REG_FIELD(_reg, __builtin_ffs((int)_mask) - 1, \
0028         sizeof(unsigned int) * 8 - __builtin_clz((_mask)) - 1)
0029 
0030 /* DA9063 and DA9063L regulator IDs */
0031 enum {
0032     /* BUCKs */
0033     DA9063_ID_BCORE1,
0034     DA9063_ID_BCORE2,
0035     DA9063_ID_BPRO,
0036     DA9063_ID_BMEM,
0037     DA9063_ID_BIO,
0038     DA9063_ID_BPERI,
0039 
0040     /* BCORE1 and BCORE2 in merged mode */
0041     DA9063_ID_BCORES_MERGED,
0042     /* BMEM and BIO in merged mode */
0043     DA9063_ID_BMEM_BIO_MERGED,
0044     /* When two BUCKs are merged, they cannot be reused separately */
0045 
0046     /* LDOs on both DA9063 and DA9063L */
0047     DA9063_ID_LDO3,
0048     DA9063_ID_LDO7,
0049     DA9063_ID_LDO8,
0050     DA9063_ID_LDO9,
0051     DA9063_ID_LDO11,
0052 
0053     /* DA9063-only LDOs */
0054     DA9063_ID_LDO1,
0055     DA9063_ID_LDO2,
0056     DA9063_ID_LDO4,
0057     DA9063_ID_LDO5,
0058     DA9063_ID_LDO6,
0059     DA9063_ID_LDO10,
0060 };
0061 
0062 /* Old regulator platform data */
0063 struct da9063_regulator_data {
0064     int             id;
0065     struct regulator_init_data  *initdata;
0066 };
0067 
0068 struct da9063_regulators_pdata {
0069     unsigned int            n_regulators;
0070     struct da9063_regulator_data    *regulator_data;
0071 };
0072 
0073 /* Regulator capabilities and registers description */
0074 struct da9063_regulator_info {
0075     struct regulator_desc desc;
0076 
0077     /* DA9063 main register fields */
0078     struct reg_field mode;      /* buck mode of operation */
0079     struct reg_field suspend;
0080     struct reg_field sleep;
0081     struct reg_field suspend_sleep;
0082     unsigned int suspend_vsel_reg;
0083 
0084     /* DA9063 event detection bit */
0085     struct reg_field oc_event;
0086 };
0087 
0088 /* Macros for LDO */
0089 #define DA9063_LDO(chip, regl_name, min_mV, step_mV, max_mV) \
0090     .desc.id = chip##_ID_##regl_name, \
0091     .desc.name = __stringify(chip##_##regl_name), \
0092     .desc.ops = &da9063_ldo_ops, \
0093     .desc.min_uV = (min_mV) * 1000, \
0094     .desc.uV_step = (step_mV) * 1000, \
0095     .desc.n_voltages = (((max_mV) - (min_mV))/(step_mV) + 1 \
0096         + (DA9063_V##regl_name##_BIAS)), \
0097     .desc.enable_reg = DA9063_REG_##regl_name##_CONT, \
0098     .desc.enable_mask = DA9063_LDO_EN, \
0099     .desc.vsel_reg = DA9063_REG_V##regl_name##_A, \
0100     .desc.vsel_mask = DA9063_V##regl_name##_MASK, \
0101     .desc.linear_min_sel = DA9063_V##regl_name##_BIAS, \
0102     .sleep = BFIELD(DA9063_REG_V##regl_name##_A, DA9063_LDO_SL), \
0103     .suspend = BFIELD(DA9063_REG_##regl_name##_CONT, DA9063_LDO_CONF), \
0104     .suspend_sleep = BFIELD(DA9063_REG_V##regl_name##_B, DA9063_LDO_SL), \
0105     .suspend_vsel_reg = DA9063_REG_V##regl_name##_B
0106 
0107 /* Macros for voltage DC/DC converters (BUCKs) */
0108 #define DA9063_BUCK(chip, regl_name, min_mV, step_mV, max_mV, limits_array, \
0109             creg, cmask) \
0110     .desc.id = chip##_ID_##regl_name, \
0111     .desc.name = __stringify(chip##_##regl_name), \
0112     .desc.ops = &da9063_buck_ops, \
0113     .desc.min_uV = (min_mV) * 1000, \
0114     .desc.uV_step = (step_mV) * 1000, \
0115     .desc.n_voltages = ((max_mV) - (min_mV))/(step_mV) + 1, \
0116     .desc.csel_reg = (creg), \
0117     .desc.csel_mask = (cmask), \
0118     .desc.curr_table = limits_array, \
0119     .desc.n_current_limits = ARRAY_SIZE(limits_array)
0120 
0121 #define DA9063_BUCK_COMMON_FIELDS(regl_name) \
0122     .desc.enable_reg = DA9063_REG_##regl_name##_CONT, \
0123     .desc.enable_mask = DA9063_BUCK_EN, \
0124     .desc.vsel_reg = DA9063_REG_V##regl_name##_A, \
0125     .desc.vsel_mask = DA9063_VBUCK_MASK, \
0126     .desc.linear_min_sel = DA9063_VBUCK_BIAS, \
0127     .sleep = BFIELD(DA9063_REG_V##regl_name##_A, DA9063_BUCK_SL), \
0128     .suspend = BFIELD(DA9063_REG_##regl_name##_CONT, DA9063_BUCK_CONF), \
0129     .suspend_sleep = BFIELD(DA9063_REG_V##regl_name##_B, DA9063_BUCK_SL), \
0130     .suspend_vsel_reg = DA9063_REG_V##regl_name##_B, \
0131     .mode = BFIELD(DA9063_REG_##regl_name##_CFG, DA9063_BUCK_MODE_MASK)
0132 
0133 /* Defines asignment of regulators info table to chip model */
0134 struct da9063_dev_model {
0135     const struct da9063_regulator_info  *regulator_info;
0136     unsigned int                n_regulators;
0137     enum da9063_type            type;
0138 };
0139 
0140 /* Single regulator settings */
0141 struct da9063_regulator {
0142     struct regulator_desc           desc;
0143     struct regulator_dev            *rdev;
0144     struct da9063               *hw;
0145     const struct da9063_regulator_info  *info;
0146 
0147     struct regmap_field         *mode;
0148     struct regmap_field         *suspend;
0149     struct regmap_field         *sleep;
0150     struct regmap_field         *suspend_sleep;
0151 };
0152 
0153 /* Encapsulates all information for the regulators driver */
0154 struct da9063_regulators {
0155     unsigned int                n_regulators;
0156     /* Array size to be defined during init. Keep at end. */
0157     struct da9063_regulator         regulator[];
0158 };
0159 
0160 /* BUCK modes for DA9063 */
0161 enum {
0162     BUCK_MODE_MANUAL,   /* 0 */
0163     BUCK_MODE_SLEEP,    /* 1 */
0164     BUCK_MODE_SYNC,     /* 2 */
0165     BUCK_MODE_AUTO      /* 3 */
0166 };
0167 
0168 /* Regulator operations */
0169 
0170 /*
0171  * Current limits array (in uA) for BCORE1, BCORE2, BPRO.
0172  * Entry indexes corresponds to register values.
0173  */
0174 static const unsigned int da9063_buck_a_limits[] = {
0175      500000,  600000,  700000,  800000,  900000, 1000000, 1100000, 1200000,
0176     1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000
0177 };
0178 
0179 /*
0180  * Current limits array (in uA) for BMEM, BIO, BPERI.
0181  * Entry indexes corresponds to register values.
0182  */
0183 static const unsigned int da9063_buck_b_limits[] = {
0184     1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
0185     2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
0186 };
0187 
0188 /*
0189  * Current limits array (in uA) for merged BCORE1 and BCORE2.
0190  * Entry indexes corresponds to register values.
0191  */
0192 static const unsigned int da9063_bcores_merged_limits[] = {
0193     1000000, 1200000, 1400000, 1600000, 1800000, 2000000, 2200000, 2400000,
0194     2600000, 2800000, 3000000, 3200000, 3400000, 3600000, 3800000, 4000000
0195 };
0196 
0197 /*
0198  * Current limits array (in uA) for merged BMEM and BIO.
0199  * Entry indexes corresponds to register values.
0200  */
0201 static const unsigned int da9063_bmem_bio_merged_limits[] = {
0202     3000000, 3200000, 3400000, 3600000, 3800000, 4000000, 4200000, 4400000,
0203     4600000, 4800000, 5000000, 5200000, 5400000, 5600000, 5800000, 6000000
0204 };
0205 
0206 static int da9063_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
0207 {
0208     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0209     unsigned int val;
0210 
0211     switch (mode) {
0212     case REGULATOR_MODE_FAST:
0213         val = BUCK_MODE_SYNC;
0214         break;
0215     case REGULATOR_MODE_NORMAL:
0216         val = BUCK_MODE_AUTO;
0217         break;
0218     case REGULATOR_MODE_STANDBY:
0219         val = BUCK_MODE_SLEEP;
0220         break;
0221     default:
0222         return -EINVAL;
0223     }
0224 
0225     return regmap_field_write(regl->mode, val);
0226 }
0227 
0228 /*
0229  * Bucks use single mode register field for normal operation
0230  * and suspend state.
0231  * There are 3 modes to map to: FAST, NORMAL, and STANDBY.
0232  */
0233 
0234 static unsigned int da9063_buck_get_mode(struct regulator_dev *rdev)
0235 {
0236     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0237     unsigned int val;
0238     int ret;
0239 
0240     ret = regmap_field_read(regl->mode, &val);
0241     if (ret < 0)
0242         return ret;
0243 
0244     switch (val) {
0245     default:
0246     case BUCK_MODE_MANUAL:
0247         /* Sleep flag bit decides the mode */
0248         break;
0249     case BUCK_MODE_SLEEP:
0250         return REGULATOR_MODE_STANDBY;
0251     case BUCK_MODE_SYNC:
0252         return REGULATOR_MODE_FAST;
0253     case BUCK_MODE_AUTO:
0254         return REGULATOR_MODE_NORMAL;
0255     }
0256 
0257     ret = regmap_field_read(regl->sleep, &val);
0258     if (ret < 0)
0259         return 0;
0260 
0261     if (val)
0262         return REGULATOR_MODE_STANDBY;
0263     else
0264         return REGULATOR_MODE_FAST;
0265 }
0266 
0267 /*
0268  * LDOs use sleep flags - one for normal and one for suspend state.
0269  * There are 2 modes to map to: NORMAL and STANDBY (sleep) for each state.
0270  */
0271 
0272 static int da9063_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
0273 {
0274     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0275     unsigned int val;
0276 
0277     switch (mode) {
0278     case REGULATOR_MODE_NORMAL:
0279         val = 0;
0280         break;
0281     case REGULATOR_MODE_STANDBY:
0282         val = 1;
0283         break;
0284     default:
0285         return -EINVAL;
0286     }
0287 
0288     return regmap_field_write(regl->sleep, val);
0289 }
0290 
0291 static unsigned int da9063_ldo_get_mode(struct regulator_dev *rdev)
0292 {
0293     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0294     int ret, val;
0295 
0296     ret = regmap_field_read(regl->sleep, &val);
0297     if (ret < 0)
0298         return 0;
0299 
0300     if (val)
0301         return REGULATOR_MODE_STANDBY;
0302     else
0303         return REGULATOR_MODE_NORMAL;
0304 }
0305 
0306 static int da9063_buck_get_status(struct regulator_dev *rdev)
0307 {
0308     int ret = regulator_is_enabled_regmap(rdev);
0309 
0310     if (ret == 0) {
0311         ret = REGULATOR_STATUS_OFF;
0312     } else if (ret > 0) {
0313         ret = da9063_buck_get_mode(rdev);
0314         if (ret > 0)
0315             ret = regulator_mode_to_status(ret);
0316         else if (ret == 0)
0317             ret = -EIO;
0318     }
0319 
0320     return ret;
0321 }
0322 
0323 static int da9063_ldo_get_status(struct regulator_dev *rdev)
0324 {
0325     int ret = regulator_is_enabled_regmap(rdev);
0326 
0327     if (ret == 0) {
0328         ret = REGULATOR_STATUS_OFF;
0329     } else if (ret > 0) {
0330         ret = da9063_ldo_get_mode(rdev);
0331         if (ret > 0)
0332             ret = regulator_mode_to_status(ret);
0333         else if (ret == 0)
0334             ret = -EIO;
0335     }
0336 
0337     return ret;
0338 }
0339 
0340 static int da9063_set_suspend_voltage(struct regulator_dev *rdev, int uV)
0341 {
0342     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0343     const struct da9063_regulator_info *rinfo = regl->info;
0344     int ret, sel;
0345 
0346     sel = regulator_map_voltage_linear(rdev, uV, uV);
0347     if (sel < 0)
0348         return sel;
0349 
0350     sel <<= ffs(rdev->desc->vsel_mask) - 1;
0351 
0352     ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg,
0353                  rdev->desc->vsel_mask, sel);
0354 
0355     return ret;
0356 }
0357 
0358 static int da9063_suspend_enable(struct regulator_dev *rdev)
0359 {
0360     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0361 
0362     return regmap_field_write(regl->suspend, 1);
0363 }
0364 
0365 static int da9063_suspend_disable(struct regulator_dev *rdev)
0366 {
0367     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0368 
0369     return regmap_field_write(regl->suspend, 0);
0370 }
0371 
0372 static int da9063_buck_set_suspend_mode(struct regulator_dev *rdev,
0373                 unsigned int mode)
0374 {
0375     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0376     int val;
0377 
0378     switch (mode) {
0379     case REGULATOR_MODE_FAST:
0380         val = BUCK_MODE_SYNC;
0381         break;
0382     case REGULATOR_MODE_NORMAL:
0383         val = BUCK_MODE_AUTO;
0384         break;
0385     case REGULATOR_MODE_STANDBY:
0386         val = BUCK_MODE_SLEEP;
0387         break;
0388     default:
0389         return -EINVAL;
0390     }
0391 
0392     return regmap_field_write(regl->mode, val);
0393 }
0394 
0395 static int da9063_ldo_set_suspend_mode(struct regulator_dev *rdev,
0396                 unsigned int mode)
0397 {
0398     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0399     unsigned int val;
0400 
0401     switch (mode) {
0402     case REGULATOR_MODE_NORMAL:
0403         val = 0;
0404         break;
0405     case REGULATOR_MODE_STANDBY:
0406         val = 1;
0407         break;
0408     default:
0409         return -EINVAL;
0410     }
0411 
0412     return regmap_field_write(regl->suspend_sleep, val);
0413 }
0414 
0415 static unsigned int da9063_get_overdrive_mask(const struct regulator_desc *desc)
0416 {
0417     switch (desc->id) {
0418     case DA9063_ID_BCORES_MERGED:
0419     case DA9063_ID_BCORE1:
0420         return DA9063_BCORE1_OD;
0421     case DA9063_ID_BCORE2:
0422         return DA9063_BCORE2_OD;
0423     case DA9063_ID_BPRO:
0424         return DA9063_BPRO_OD;
0425     default:
0426         return 0;
0427     }
0428 }
0429 
0430 static int da9063_buck_set_limit_set_overdrive(struct regulator_dev *rdev,
0431                            int min_uA, int max_uA,
0432                            unsigned int overdrive_mask)
0433 {
0434     /*
0435      * When enabling overdrive, do it before changing the current limit to
0436      * ensure sufficient supply throughout the switch.
0437      */
0438     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0439     int ret;
0440     unsigned int orig_overdrive;
0441 
0442     ret = regmap_read(regl->hw->regmap, DA9063_REG_CONFIG_H,
0443               &orig_overdrive);
0444     if (ret < 0)
0445         return ret;
0446     orig_overdrive &= overdrive_mask;
0447 
0448     if (orig_overdrive == 0) {
0449         ret = regmap_set_bits(regl->hw->regmap, DA9063_REG_CONFIG_H,
0450                 overdrive_mask);
0451         if (ret < 0)
0452             return ret;
0453     }
0454 
0455     ret = regulator_set_current_limit_regmap(rdev, min_uA / 2, max_uA / 2);
0456     if (ret < 0 && orig_overdrive == 0)
0457         /*
0458          * regulator_set_current_limit_regmap may have rejected the
0459          * change because of unusable min_uA and/or max_uA inputs.
0460          * Attempt to restore original overdrive state, ignore failure-
0461          * on-failure.
0462          */
0463         regmap_clear_bits(regl->hw->regmap, DA9063_REG_CONFIG_H,
0464                   overdrive_mask);
0465 
0466     return ret;
0467 }
0468 
0469 static int da9063_buck_set_limit_clear_overdrive(struct regulator_dev *rdev,
0470                          int min_uA, int max_uA,
0471                          unsigned int overdrive_mask)
0472 {
0473     /*
0474      * When disabling overdrive, do it after changing the current limit to
0475      * ensure sufficient supply throughout the switch.
0476      */
0477     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0478     int ret, orig_limit;
0479 
0480     ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &orig_limit);
0481     if (ret < 0)
0482         return ret;
0483 
0484     ret = regulator_set_current_limit_regmap(rdev, min_uA, max_uA);
0485     if (ret < 0)
0486         return ret;
0487 
0488     ret = regmap_clear_bits(regl->hw->regmap, DA9063_REG_CONFIG_H,
0489                 overdrive_mask);
0490     if (ret < 0)
0491         /*
0492          * Attempt to restore original current limit, ignore failure-
0493          * on-failure.
0494          */
0495         regmap_write(rdev->regmap, rdev->desc->csel_reg, orig_limit);
0496 
0497     return ret;
0498 }
0499 
0500 static int da9063_buck_set_current_limit(struct regulator_dev *rdev,
0501                      int min_uA, int max_uA)
0502 {
0503     unsigned int overdrive_mask, n_currents;
0504 
0505     overdrive_mask = da9063_get_overdrive_mask(rdev->desc);
0506     if (overdrive_mask) {
0507         n_currents = rdev->desc->n_current_limits;
0508         if (n_currents == 0)
0509             return -EINVAL;
0510 
0511         if (max_uA > rdev->desc->curr_table[n_currents - 1])
0512             return da9063_buck_set_limit_set_overdrive(rdev, min_uA,
0513                                    max_uA,
0514                                    overdrive_mask);
0515 
0516         return da9063_buck_set_limit_clear_overdrive(rdev, min_uA,
0517                                  max_uA,
0518                                  overdrive_mask);
0519     }
0520     return regulator_set_current_limit_regmap(rdev, min_uA, max_uA);
0521 }
0522 
0523 static int da9063_buck_get_current_limit(struct regulator_dev *rdev)
0524 {
0525     struct da9063_regulator *regl = rdev_get_drvdata(rdev);
0526     int val, ret, limit;
0527     unsigned int mask;
0528 
0529     limit = regulator_get_current_limit_regmap(rdev);
0530     if (limit < 0)
0531         return limit;
0532     mask = da9063_get_overdrive_mask(rdev->desc);
0533     if (mask) {
0534         ret = regmap_read(regl->hw->regmap, DA9063_REG_CONFIG_H, &val);
0535         if (ret < 0)
0536             return ret;
0537         if (val & mask)
0538             limit *= 2;
0539     }
0540     return limit;
0541 }
0542 
0543 static const struct regulator_ops da9063_buck_ops = {
0544     .enable         = regulator_enable_regmap,
0545     .disable        = regulator_disable_regmap,
0546     .is_enabled     = regulator_is_enabled_regmap,
0547     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0548     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0549     .list_voltage       = regulator_list_voltage_linear,
0550     .set_current_limit  = da9063_buck_set_current_limit,
0551     .get_current_limit  = da9063_buck_get_current_limit,
0552     .set_mode       = da9063_buck_set_mode,
0553     .get_mode       = da9063_buck_get_mode,
0554     .get_status     = da9063_buck_get_status,
0555     .set_suspend_voltage    = da9063_set_suspend_voltage,
0556     .set_suspend_enable = da9063_suspend_enable,
0557     .set_suspend_disable    = da9063_suspend_disable,
0558     .set_suspend_mode   = da9063_buck_set_suspend_mode,
0559 };
0560 
0561 static const struct regulator_ops da9063_ldo_ops = {
0562     .enable         = regulator_enable_regmap,
0563     .disable        = regulator_disable_regmap,
0564     .is_enabled     = regulator_is_enabled_regmap,
0565     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0566     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0567     .list_voltage       = regulator_list_voltage_linear,
0568     .set_mode       = da9063_ldo_set_mode,
0569     .get_mode       = da9063_ldo_get_mode,
0570     .get_status     = da9063_ldo_get_status,
0571     .set_suspend_voltage    = da9063_set_suspend_voltage,
0572     .set_suspend_enable = da9063_suspend_enable,
0573     .set_suspend_disable    = da9063_suspend_disable,
0574     .set_suspend_mode   = da9063_ldo_set_suspend_mode,
0575 };
0576 
0577 /* Info of regulators for DA9063 */
0578 static const struct da9063_regulator_info da9063_regulator_info[] = {
0579     {
0580         DA9063_BUCK(DA9063, BCORE1, 300, 10, 1570,
0581                 da9063_buck_a_limits,
0582                 DA9063_REG_BUCK_ILIM_C, DA9063_BCORE1_ILIM_MASK),
0583         DA9063_BUCK_COMMON_FIELDS(BCORE1),
0584     },
0585     {
0586         DA9063_BUCK(DA9063, BCORE2, 300, 10, 1570,
0587                 da9063_buck_a_limits,
0588                 DA9063_REG_BUCK_ILIM_C, DA9063_BCORE2_ILIM_MASK),
0589         DA9063_BUCK_COMMON_FIELDS(BCORE2),
0590     },
0591     {
0592         DA9063_BUCK(DA9063, BPRO, 530, 10, 1800,
0593                 da9063_buck_a_limits,
0594                 DA9063_REG_BUCK_ILIM_B, DA9063_BPRO_ILIM_MASK),
0595         DA9063_BUCK_COMMON_FIELDS(BPRO),
0596     },
0597     {
0598         DA9063_BUCK(DA9063, BMEM, 800, 20, 3340,
0599                 da9063_buck_b_limits,
0600                 DA9063_REG_BUCK_ILIM_A, DA9063_BMEM_ILIM_MASK),
0601         DA9063_BUCK_COMMON_FIELDS(BMEM),
0602     },
0603     {
0604         DA9063_BUCK(DA9063, BIO, 800, 20, 3340,
0605                 da9063_buck_b_limits,
0606                 DA9063_REG_BUCK_ILIM_A, DA9063_BIO_ILIM_MASK),
0607         DA9063_BUCK_COMMON_FIELDS(BIO),
0608     },
0609     {
0610         DA9063_BUCK(DA9063, BPERI, 800, 20, 3340,
0611                 da9063_buck_b_limits,
0612                 DA9063_REG_BUCK_ILIM_B, DA9063_BPERI_ILIM_MASK),
0613         DA9063_BUCK_COMMON_FIELDS(BPERI),
0614     },
0615     {
0616         DA9063_BUCK(DA9063, BCORES_MERGED, 300, 10, 1570,
0617                 da9063_bcores_merged_limits,
0618                 DA9063_REG_BUCK_ILIM_C, DA9063_BCORE1_ILIM_MASK),
0619         /* BCORES_MERGED uses the same register fields as BCORE1 */
0620         DA9063_BUCK_COMMON_FIELDS(BCORE1),
0621     },
0622     {
0623         DA9063_BUCK(DA9063, BMEM_BIO_MERGED, 800, 20, 3340,
0624                 da9063_bmem_bio_merged_limits,
0625                 DA9063_REG_BUCK_ILIM_A, DA9063_BMEM_ILIM_MASK),
0626         /* BMEM_BIO_MERGED uses the same register fields as BMEM */
0627         DA9063_BUCK_COMMON_FIELDS(BMEM),
0628     },
0629     {
0630         DA9063_LDO(DA9063, LDO3, 900, 20, 3440),
0631         .oc_event = BFIELD(DA9063_REG_STATUS_D, DA9063_LDO3_LIM),
0632     },
0633     {
0634         DA9063_LDO(DA9063, LDO7, 900, 50, 3600),
0635         .oc_event = BFIELD(DA9063_REG_STATUS_D, DA9063_LDO7_LIM),
0636     },
0637     {
0638         DA9063_LDO(DA9063, LDO8, 900, 50, 3600),
0639         .oc_event = BFIELD(DA9063_REG_STATUS_D, DA9063_LDO8_LIM),
0640     },
0641     {
0642         DA9063_LDO(DA9063, LDO9, 950, 50, 3600),
0643     },
0644     {
0645         DA9063_LDO(DA9063, LDO11, 900, 50, 3600),
0646         .oc_event = BFIELD(DA9063_REG_STATUS_D, DA9063_LDO11_LIM),
0647     },
0648 
0649     /* The following LDOs are present only on DA9063, not on DA9063L */
0650     {
0651         DA9063_LDO(DA9063, LDO1, 600, 20, 1860),
0652     },
0653     {
0654         DA9063_LDO(DA9063, LDO2, 600, 20, 1860),
0655     },
0656     {
0657         DA9063_LDO(DA9063, LDO4, 900, 20, 3440),
0658         .oc_event = BFIELD(DA9063_REG_STATUS_D, DA9063_LDO4_LIM),
0659     },
0660     {
0661         DA9063_LDO(DA9063, LDO5, 900, 50, 3600),
0662     },
0663     {
0664         DA9063_LDO(DA9063, LDO6, 900, 50, 3600),
0665     },
0666 
0667     {
0668         DA9063_LDO(DA9063, LDO10, 900, 50, 3600),
0669     },
0670 };
0671 
0672 /* Link chip model with regulators info table */
0673 static struct da9063_dev_model regulators_models[] = {
0674     {
0675         .regulator_info = da9063_regulator_info,
0676         .n_regulators = ARRAY_SIZE(da9063_regulator_info),
0677         .type = PMIC_TYPE_DA9063,
0678     },
0679     {
0680         .regulator_info = da9063_regulator_info,
0681         .n_regulators = ARRAY_SIZE(da9063_regulator_info) - 6,
0682         .type = PMIC_TYPE_DA9063L,
0683     },
0684     { }
0685 };
0686 
0687 /* Regulator interrupt handlers */
0688 static irqreturn_t da9063_ldo_lim_event(int irq, void *data)
0689 {
0690     struct da9063_regulators *regulators = data;
0691     struct da9063 *hw = regulators->regulator[0].hw;
0692     struct da9063_regulator *regl;
0693     int bits, i, ret;
0694 
0695     ret = regmap_read(hw->regmap, DA9063_REG_STATUS_D, &bits);
0696     if (ret < 0)
0697         return IRQ_NONE;
0698 
0699     for (i = regulators->n_regulators - 1; i >= 0; i--) {
0700         regl = &regulators->regulator[i];
0701         if (regl->info->oc_event.reg != DA9063_REG_STATUS_D)
0702             continue;
0703 
0704         if (BIT(regl->info->oc_event.lsb) & bits) {
0705             regulator_notifier_call_chain(regl->rdev,
0706                     REGULATOR_EVENT_OVER_CURRENT, NULL);
0707         }
0708     }
0709 
0710     return IRQ_HANDLED;
0711 }
0712 
0713 /*
0714  * Probing and Initialisation functions
0715  */
0716 static const struct regulator_init_data *da9063_get_regulator_initdata(
0717         const struct da9063_regulators_pdata *regl_pdata, int id)
0718 {
0719     int i;
0720 
0721     for (i = 0; i < regl_pdata->n_regulators; i++) {
0722         if (id == regl_pdata->regulator_data[i].id)
0723             return regl_pdata->regulator_data[i].initdata;
0724     }
0725 
0726     return NULL;
0727 }
0728 
0729 static struct of_regulator_match da9063_matches[] = {
0730     [DA9063_ID_BCORE1]           = { .name = "bcore1"           },
0731     [DA9063_ID_BCORE2]           = { .name = "bcore2"           },
0732     [DA9063_ID_BPRO]             = { .name = "bpro",            },
0733     [DA9063_ID_BMEM]             = { .name = "bmem",            },
0734     [DA9063_ID_BIO]              = { .name = "bio",             },
0735     [DA9063_ID_BPERI]            = { .name = "bperi",           },
0736     [DA9063_ID_BCORES_MERGED]    = { .name = "bcores-merged"    },
0737     [DA9063_ID_BMEM_BIO_MERGED]  = { .name = "bmem-bio-merged", },
0738     [DA9063_ID_LDO3]             = { .name = "ldo3",            },
0739     [DA9063_ID_LDO7]             = { .name = "ldo7",            },
0740     [DA9063_ID_LDO8]             = { .name = "ldo8",            },
0741     [DA9063_ID_LDO9]             = { .name = "ldo9",            },
0742     [DA9063_ID_LDO11]            = { .name = "ldo11",           },
0743     /* The following LDOs are present only on DA9063, not on DA9063L */
0744     [DA9063_ID_LDO1]             = { .name = "ldo1",            },
0745     [DA9063_ID_LDO2]             = { .name = "ldo2",            },
0746     [DA9063_ID_LDO4]             = { .name = "ldo4",            },
0747     [DA9063_ID_LDO5]             = { .name = "ldo5",            },
0748     [DA9063_ID_LDO6]             = { .name = "ldo6",            },
0749     [DA9063_ID_LDO10]            = { .name = "ldo10",           },
0750 };
0751 
0752 static struct da9063_regulators_pdata *da9063_parse_regulators_dt(
0753         struct platform_device *pdev,
0754         struct of_regulator_match **da9063_reg_matches)
0755 {
0756     struct da9063 *da9063 = dev_get_drvdata(pdev->dev.parent);
0757     struct da9063_regulators_pdata *pdata;
0758     struct da9063_regulator_data *rdata;
0759     struct device_node *node;
0760     int da9063_matches_len = ARRAY_SIZE(da9063_matches);
0761     int i, n, num;
0762 
0763     if (da9063->type == PMIC_TYPE_DA9063L)
0764         da9063_matches_len -= 6;
0765 
0766     node = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
0767     if (!node) {
0768         dev_err(&pdev->dev, "Regulators device node not found\n");
0769         return ERR_PTR(-ENODEV);
0770     }
0771 
0772     num = of_regulator_match(&pdev->dev, node, da9063_matches,
0773                  da9063_matches_len);
0774     of_node_put(node);
0775     if (num < 0) {
0776         dev_err(&pdev->dev, "Failed to match regulators\n");
0777         return ERR_PTR(-EINVAL);
0778     }
0779 
0780     pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
0781     if (!pdata)
0782         return ERR_PTR(-ENOMEM);
0783 
0784     pdata->regulator_data = devm_kcalloc(&pdev->dev,
0785                     num, sizeof(*pdata->regulator_data),
0786                     GFP_KERNEL);
0787     if (!pdata->regulator_data)
0788         return ERR_PTR(-ENOMEM);
0789     pdata->n_regulators = num;
0790 
0791     n = 0;
0792     for (i = 0; i < da9063_matches_len; i++) {
0793         if (!da9063_matches[i].init_data)
0794             continue;
0795 
0796         rdata = &pdata->regulator_data[n];
0797         rdata->id = i;
0798         rdata->initdata = da9063_matches[i].init_data;
0799 
0800         n++;
0801     }
0802 
0803     *da9063_reg_matches = da9063_matches;
0804     return pdata;
0805 }
0806 
0807 static int da9063_regulator_probe(struct platform_device *pdev)
0808 {
0809     struct da9063 *da9063 = dev_get_drvdata(pdev->dev.parent);
0810     struct of_regulator_match *da9063_reg_matches = NULL;
0811     struct da9063_regulators_pdata *regl_pdata;
0812     const struct da9063_dev_model *model;
0813     struct da9063_regulators *regulators;
0814     struct da9063_regulator *regl;
0815     struct regulator_config config;
0816     bool bcores_merged, bmem_bio_merged;
0817     int id, irq, n, n_regulators, ret, val;
0818 
0819     regl_pdata = da9063_parse_regulators_dt(pdev, &da9063_reg_matches);
0820 
0821     if (IS_ERR(regl_pdata) || regl_pdata->n_regulators == 0) {
0822         dev_err(&pdev->dev,
0823             "No regulators defined for the platform\n");
0824         return -ENODEV;
0825     }
0826 
0827     /* Find regulators set for particular device model */
0828     for (model = regulators_models; model->regulator_info; model++) {
0829         if (model->type == da9063->type)
0830             break;
0831     }
0832     if (!model->regulator_info) {
0833         dev_err(&pdev->dev, "Chip model not recognised (%u)\n",
0834             da9063->type);
0835         return -ENODEV;
0836     }
0837 
0838     ret = regmap_read(da9063->regmap, DA9063_REG_CONFIG_H, &val);
0839     if (ret < 0) {
0840         dev_err(&pdev->dev,
0841             "Error while reading BUCKs configuration\n");
0842         return ret;
0843     }
0844     bcores_merged = val & DA9063_BCORE_MERGE;
0845     bmem_bio_merged = val & DA9063_BUCK_MERGE;
0846 
0847     n_regulators = model->n_regulators;
0848     if (bcores_merged)
0849         n_regulators -= 2; /* remove BCORE1, BCORE2 */
0850     else
0851         n_regulators--;    /* remove BCORES_MERGED */
0852     if (bmem_bio_merged)
0853         n_regulators -= 2; /* remove BMEM, BIO */
0854     else
0855         n_regulators--;    /* remove BMEM_BIO_MERGED */
0856 
0857     /* Allocate memory required by usable regulators */
0858     regulators = devm_kzalloc(&pdev->dev, struct_size(regulators,
0859                   regulator, n_regulators), GFP_KERNEL);
0860     if (!regulators)
0861         return -ENOMEM;
0862 
0863     regulators->n_regulators = n_regulators;
0864     platform_set_drvdata(pdev, regulators);
0865 
0866     /* Register all regulators declared in platform information */
0867     n = 0;
0868     id = 0;
0869     while (n < regulators->n_regulators) {
0870         /* Skip regulator IDs depending on merge mode configuration */
0871         switch (id) {
0872         case DA9063_ID_BCORE1:
0873         case DA9063_ID_BCORE2:
0874             if (bcores_merged) {
0875                 id++;
0876                 continue;
0877             }
0878             break;
0879         case DA9063_ID_BMEM:
0880         case DA9063_ID_BIO:
0881             if (bmem_bio_merged) {
0882                 id++;
0883                 continue;
0884             }
0885             break;
0886         case DA9063_ID_BCORES_MERGED:
0887             if (!bcores_merged) {
0888                 id++;
0889                 continue;
0890             }
0891             break;
0892         case DA9063_ID_BMEM_BIO_MERGED:
0893             if (!bmem_bio_merged) {
0894                 id++;
0895                 continue;
0896             }
0897             break;
0898         }
0899 
0900         /* Initialise regulator structure */
0901         regl = &regulators->regulator[n];
0902         regl->hw = da9063;
0903         regl->info = &model->regulator_info[id];
0904         regl->desc = regl->info->desc;
0905         regl->desc.type = REGULATOR_VOLTAGE;
0906         regl->desc.owner = THIS_MODULE;
0907 
0908         if (regl->info->mode.reg) {
0909             regl->mode = devm_regmap_field_alloc(&pdev->dev,
0910                     da9063->regmap, regl->info->mode);
0911             if (IS_ERR(regl->mode))
0912                 return PTR_ERR(regl->mode);
0913         }
0914 
0915         if (regl->info->suspend.reg) {
0916             regl->suspend = devm_regmap_field_alloc(&pdev->dev,
0917                     da9063->regmap, regl->info->suspend);
0918             if (IS_ERR(regl->suspend))
0919                 return PTR_ERR(regl->suspend);
0920         }
0921 
0922         if (regl->info->sleep.reg) {
0923             regl->sleep = devm_regmap_field_alloc(&pdev->dev,
0924                     da9063->regmap, regl->info->sleep);
0925             if (IS_ERR(regl->sleep))
0926                 return PTR_ERR(regl->sleep);
0927         }
0928 
0929         if (regl->info->suspend_sleep.reg) {
0930             regl->suspend_sleep = devm_regmap_field_alloc(&pdev->dev,
0931                 da9063->regmap, regl->info->suspend_sleep);
0932             if (IS_ERR(regl->suspend_sleep))
0933                 return PTR_ERR(regl->suspend_sleep);
0934         }
0935 
0936         /* Register regulator */
0937         memset(&config, 0, sizeof(config));
0938         config.dev = &pdev->dev;
0939         config.init_data = da9063_get_regulator_initdata(regl_pdata, id);
0940         config.driver_data = regl;
0941         if (da9063_reg_matches)
0942             config.of_node = da9063_reg_matches[id].of_node;
0943         config.regmap = da9063->regmap;
0944         regl->rdev = devm_regulator_register(&pdev->dev, &regl->desc,
0945                              &config);
0946         if (IS_ERR(regl->rdev)) {
0947             dev_err(&pdev->dev,
0948                 "Failed to register %s regulator\n",
0949                 regl->desc.name);
0950             return PTR_ERR(regl->rdev);
0951         }
0952         id++;
0953         n++;
0954     }
0955 
0956     /* LDOs overcurrent event support */
0957     irq = platform_get_irq_byname(pdev, "LDO_LIM");
0958     if (irq < 0)
0959         return irq;
0960 
0961     ret = devm_request_threaded_irq(&pdev->dev, irq,
0962                 NULL, da9063_ldo_lim_event,
0963                 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
0964                 "LDO_LIM", regulators);
0965     if (ret)
0966         dev_err(&pdev->dev, "Failed to request LDO_LIM IRQ.\n");
0967 
0968     return ret;
0969 }
0970 
0971 static struct platform_driver da9063_regulator_driver = {
0972     .driver = {
0973         .name = DA9063_DRVNAME_REGULATORS,
0974     },
0975     .probe = da9063_regulator_probe,
0976 };
0977 
0978 static int __init da9063_regulator_init(void)
0979 {
0980     return platform_driver_register(&da9063_regulator_driver);
0981 }
0982 subsys_initcall(da9063_regulator_init);
0983 
0984 static void __exit da9063_regulator_cleanup(void)
0985 {
0986     platform_driver_unregister(&da9063_regulator_driver);
0987 }
0988 module_exit(da9063_regulator_cleanup);
0989 
0990 
0991 /* Module information */
0992 MODULE_AUTHOR("Krystian Garbaciak <krystian.garbaciak@diasemi.com>");
0993 MODULE_DESCRIPTION("DA9063 regulators driver");
0994 MODULE_LICENSE("GPL");
0995 MODULE_ALIAS("platform:" DA9063_DRVNAME_REGULATORS);
[ 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!