Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // Copyright (c) 2013 Samsung Electronics Co., Ltd
0004 //      http://www.samsung.com
0005 
0006 #include <linux/bug.h>
0007 #include <linux/err.h>
0008 #include <linux/gpio.h>
0009 #include <linux/slab.h>
0010 #include <linux/module.h>
0011 #include <linux/of.h>
0012 #include <linux/regmap.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/regulator/driver.h>
0015 #include <linux/regulator/machine.h>
0016 #include <linux/regulator/of_regulator.h>
0017 #include <linux/mfd/samsung/core.h>
0018 #include <linux/mfd/samsung/s2mpa01.h>
0019 
0020 struct s2mpa01_info {
0021     int ramp_delay24;
0022     int ramp_delay3;
0023     int ramp_delay5;
0024     int ramp_delay16;
0025     int ramp_delay7;
0026     int ramp_delay8910;
0027 };
0028 
0029 static int get_ramp_delay(int ramp_delay)
0030 {
0031     unsigned char cnt = 0;
0032 
0033     ramp_delay /= 6250;
0034 
0035     while (true) {
0036         ramp_delay = ramp_delay >> 1;
0037         if (ramp_delay == 0)
0038             break;
0039         cnt++;
0040     }
0041 
0042     if (cnt > 3)
0043         cnt = 3;
0044 
0045     return cnt;
0046 }
0047 
0048 static int s2mpa01_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
0049                    unsigned int old_selector,
0050                    unsigned int new_selector)
0051 {
0052     struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
0053     unsigned int ramp_delay = 0;
0054     int old_volt, new_volt;
0055 
0056     switch (rdev_get_id(rdev)) {
0057     case S2MPA01_BUCK2:
0058     case S2MPA01_BUCK4:
0059         ramp_delay = s2mpa01->ramp_delay24;
0060         break;
0061     case S2MPA01_BUCK3:
0062         ramp_delay = s2mpa01->ramp_delay3;
0063         break;
0064     case S2MPA01_BUCK5:
0065         ramp_delay = s2mpa01->ramp_delay5;
0066         break;
0067     case S2MPA01_BUCK1:
0068     case S2MPA01_BUCK6:
0069         ramp_delay = s2mpa01->ramp_delay16;
0070         break;
0071     case S2MPA01_BUCK7:
0072         ramp_delay = s2mpa01->ramp_delay7;
0073         break;
0074     case S2MPA01_BUCK8:
0075     case S2MPA01_BUCK9:
0076     case S2MPA01_BUCK10:
0077         ramp_delay = s2mpa01->ramp_delay8910;
0078         break;
0079     }
0080 
0081     if (ramp_delay == 0)
0082         ramp_delay = rdev->desc->ramp_delay;
0083 
0084     old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
0085     new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
0086 
0087     return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
0088 }
0089 
0090 static int s2mpa01_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
0091 {
0092     struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
0093     unsigned int ramp_val, ramp_shift, ramp_reg = S2MPA01_REG_RAMP2;
0094     unsigned int ramp_enable = 1, enable_shift = 0;
0095     int ret;
0096 
0097     switch (rdev_get_id(rdev)) {
0098     case S2MPA01_BUCK1:
0099         enable_shift = S2MPA01_BUCK1_RAMP_EN_SHIFT;
0100         if (!ramp_delay) {
0101             ramp_enable = 0;
0102             break;
0103         }
0104 
0105         if (ramp_delay > s2mpa01->ramp_delay16)
0106             s2mpa01->ramp_delay16 = ramp_delay;
0107         else
0108             ramp_delay = s2mpa01->ramp_delay16;
0109 
0110         ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
0111         break;
0112     case S2MPA01_BUCK2:
0113         enable_shift = S2MPA01_BUCK2_RAMP_EN_SHIFT;
0114         if (!ramp_delay) {
0115             ramp_enable = 0;
0116             break;
0117         }
0118 
0119         if (ramp_delay > s2mpa01->ramp_delay24)
0120             s2mpa01->ramp_delay24 = ramp_delay;
0121         else
0122             ramp_delay = s2mpa01->ramp_delay24;
0123 
0124         ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
0125         ramp_reg = S2MPA01_REG_RAMP1;
0126         break;
0127     case S2MPA01_BUCK3:
0128         enable_shift = S2MPA01_BUCK3_RAMP_EN_SHIFT;
0129         if (!ramp_delay) {
0130             ramp_enable = 0;
0131             break;
0132         }
0133 
0134         s2mpa01->ramp_delay3 = ramp_delay;
0135         ramp_shift = S2MPA01_BUCK3_RAMP_SHIFT;
0136         ramp_reg = S2MPA01_REG_RAMP1;
0137         break;
0138     case S2MPA01_BUCK4:
0139         enable_shift = S2MPA01_BUCK4_RAMP_EN_SHIFT;
0140         if (!ramp_delay) {
0141             ramp_enable = 0;
0142             break;
0143         }
0144 
0145         if (ramp_delay > s2mpa01->ramp_delay24)
0146             s2mpa01->ramp_delay24 = ramp_delay;
0147         else
0148             ramp_delay = s2mpa01->ramp_delay24;
0149 
0150         ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
0151         ramp_reg = S2MPA01_REG_RAMP1;
0152         break;
0153     case S2MPA01_BUCK5:
0154         s2mpa01->ramp_delay5 = ramp_delay;
0155         ramp_shift = S2MPA01_BUCK5_RAMP_SHIFT;
0156         break;
0157     case S2MPA01_BUCK6:
0158         if (ramp_delay > s2mpa01->ramp_delay16)
0159             s2mpa01->ramp_delay16 = ramp_delay;
0160         else
0161             ramp_delay = s2mpa01->ramp_delay16;
0162 
0163         ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
0164         break;
0165     case S2MPA01_BUCK7:
0166         s2mpa01->ramp_delay7 = ramp_delay;
0167         ramp_shift = S2MPA01_BUCK7_RAMP_SHIFT;
0168         break;
0169     case S2MPA01_BUCK8:
0170     case S2MPA01_BUCK9:
0171     case S2MPA01_BUCK10:
0172         if (ramp_delay > s2mpa01->ramp_delay8910)
0173             s2mpa01->ramp_delay8910 = ramp_delay;
0174         else
0175             ramp_delay = s2mpa01->ramp_delay8910;
0176 
0177         ramp_shift = S2MPA01_BUCK8910_RAMP_SHIFT;
0178         break;
0179     default:
0180         return 0;
0181     }
0182 
0183     if (!ramp_enable)
0184         goto ramp_disable;
0185 
0186     /* Ramp delay can be enabled/disabled only for buck[1234] */
0187     if (rdev_get_id(rdev) >= S2MPA01_BUCK1 &&
0188             rdev_get_id(rdev) <= S2MPA01_BUCK4) {
0189         ret = regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
0190                      1 << enable_shift, 1 << enable_shift);
0191         if (ret) {
0192             dev_err(&rdev->dev, "failed to enable ramp rate\n");
0193             return ret;
0194         }
0195     }
0196 
0197     ramp_val = get_ramp_delay(ramp_delay);
0198 
0199     return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
0200                   ramp_val << ramp_shift);
0201 
0202 ramp_disable:
0203     return regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
0204                   1 << enable_shift, 0);
0205 }
0206 
0207 static const struct regulator_ops s2mpa01_ldo_ops = {
0208     .list_voltage       = regulator_list_voltage_linear,
0209     .map_voltage        = regulator_map_voltage_linear,
0210     .is_enabled     = regulator_is_enabled_regmap,
0211     .enable         = regulator_enable_regmap,
0212     .disable        = regulator_disable_regmap,
0213     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0214     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0215     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0216 };
0217 
0218 static const struct regulator_ops s2mpa01_buck_ops = {
0219     .list_voltage       = regulator_list_voltage_linear,
0220     .map_voltage        = regulator_map_voltage_linear,
0221     .is_enabled     = regulator_is_enabled_regmap,
0222     .enable         = regulator_enable_regmap,
0223     .disable        = regulator_disable_regmap,
0224     .get_voltage_sel    = regulator_get_voltage_sel_regmap,
0225     .set_voltage_sel    = regulator_set_voltage_sel_regmap,
0226     .set_voltage_time_sel   = s2mpa01_regulator_set_voltage_time_sel,
0227     .set_ramp_delay     = s2mpa01_set_ramp_delay,
0228 };
0229 
0230 #define regulator_desc_ldo(num, step) {         \
0231     .name       = "LDO"#num,            \
0232     .of_match   = of_match_ptr("LDO"#num),  \
0233     .regulators_node = of_match_ptr("regulators"),  \
0234     .id     = S2MPA01_LDO##num,     \
0235     .ops        = &s2mpa01_ldo_ops,     \
0236     .type       = REGULATOR_VOLTAGE,        \
0237     .owner      = THIS_MODULE,          \
0238     .min_uV     = MIN_800_MV,           \
0239     .uV_step    = step,             \
0240     .n_voltages = S2MPA01_LDO_N_VOLTAGES,   \
0241     .vsel_reg   = S2MPA01_REG_L1CTRL + num - 1, \
0242     .vsel_mask  = S2MPA01_LDO_VSEL_MASK,    \
0243     .enable_reg = S2MPA01_REG_L1CTRL + num - 1, \
0244     .enable_mask    = S2MPA01_ENABLE_MASK       \
0245 }
0246 
0247 #define regulator_desc_buck1_4(num) {           \
0248     .name       = "BUCK"#num,               \
0249     .of_match   = of_match_ptr("BUCK"#num),     \
0250     .regulators_node = of_match_ptr("regulators"),      \
0251     .id     = S2MPA01_BUCK##num,            \
0252     .ops        = &s2mpa01_buck_ops,            \
0253     .type       = REGULATOR_VOLTAGE,            \
0254     .owner      = THIS_MODULE,              \
0255     .min_uV     = MIN_600_MV,               \
0256     .uV_step    = STEP_6_25_MV,             \
0257     .n_voltages = S2MPA01_BUCK_N_VOLTAGES,      \
0258     .ramp_delay = S2MPA01_RAMP_DELAY,           \
0259     .vsel_reg   = S2MPA01_REG_B1CTRL2 + (num - 1) * 2,  \
0260     .vsel_mask  = S2MPA01_BUCK_VSEL_MASK,       \
0261     .enable_reg = S2MPA01_REG_B1CTRL1 + (num - 1) * 2,  \
0262     .enable_mask    = S2MPA01_ENABLE_MASK           \
0263 }
0264 
0265 #define regulator_desc_buck5    {               \
0266     .name       = "BUCK5",              \
0267     .of_match   = of_match_ptr("BUCK5"),        \
0268     .regulators_node = of_match_ptr("regulators"),      \
0269     .id     = S2MPA01_BUCK5,            \
0270     .ops        = &s2mpa01_buck_ops,            \
0271     .type       = REGULATOR_VOLTAGE,            \
0272     .owner      = THIS_MODULE,              \
0273     .min_uV     = MIN_800_MV,               \
0274     .uV_step    = STEP_6_25_MV,             \
0275     .n_voltages = S2MPA01_BUCK_N_VOLTAGES,      \
0276     .ramp_delay = S2MPA01_RAMP_DELAY,           \
0277     .vsel_reg   = S2MPA01_REG_B5CTRL2,          \
0278     .vsel_mask  = S2MPA01_BUCK_VSEL_MASK,       \
0279     .enable_reg = S2MPA01_REG_B5CTRL1,          \
0280     .enable_mask    = S2MPA01_ENABLE_MASK           \
0281 }
0282 
0283 #define regulator_desc_buck6_10(num, min, step) {           \
0284     .name       = "BUCK"#num,               \
0285     .of_match   = of_match_ptr("BUCK"#num),     \
0286     .regulators_node = of_match_ptr("regulators"),      \
0287     .id     = S2MPA01_BUCK##num,            \
0288     .ops        = &s2mpa01_buck_ops,            \
0289     .type       = REGULATOR_VOLTAGE,            \
0290     .owner      = THIS_MODULE,              \
0291     .min_uV     = min,                  \
0292     .uV_step    = step,                 \
0293     .n_voltages = S2MPA01_BUCK_N_VOLTAGES,      \
0294     .ramp_delay = S2MPA01_RAMP_DELAY,           \
0295     .vsel_reg   = S2MPA01_REG_B6CTRL2 + (num - 6) * 2,  \
0296     .vsel_mask  = S2MPA01_BUCK_VSEL_MASK,       \
0297     .enable_reg = S2MPA01_REG_B6CTRL1 + (num - 6) * 2,  \
0298     .enable_mask    = S2MPA01_ENABLE_MASK           \
0299 }
0300 
0301 static const struct regulator_desc regulators[] = {
0302     regulator_desc_ldo(1, STEP_25_MV),
0303     regulator_desc_ldo(2, STEP_50_MV),
0304     regulator_desc_ldo(3, STEP_50_MV),
0305     regulator_desc_ldo(4, STEP_50_MV),
0306     regulator_desc_ldo(5, STEP_25_MV),
0307     regulator_desc_ldo(6, STEP_25_MV),
0308     regulator_desc_ldo(7, STEP_50_MV),
0309     regulator_desc_ldo(8, STEP_50_MV),
0310     regulator_desc_ldo(9, STEP_50_MV),
0311     regulator_desc_ldo(10, STEP_50_MV),
0312     regulator_desc_ldo(11, STEP_50_MV),
0313     regulator_desc_ldo(12, STEP_50_MV),
0314     regulator_desc_ldo(13, STEP_50_MV),
0315     regulator_desc_ldo(14, STEP_50_MV),
0316     regulator_desc_ldo(15, STEP_50_MV),
0317     regulator_desc_ldo(16, STEP_50_MV),
0318     regulator_desc_ldo(17, STEP_50_MV),
0319     regulator_desc_ldo(18, STEP_50_MV),
0320     regulator_desc_ldo(19, STEP_50_MV),
0321     regulator_desc_ldo(20, STEP_50_MV),
0322     regulator_desc_ldo(21, STEP_50_MV),
0323     regulator_desc_ldo(22, STEP_50_MV),
0324     regulator_desc_ldo(23, STEP_50_MV),
0325     regulator_desc_ldo(24, STEP_50_MV),
0326     regulator_desc_ldo(25, STEP_50_MV),
0327     regulator_desc_ldo(26, STEP_25_MV),
0328     regulator_desc_buck1_4(1),
0329     regulator_desc_buck1_4(2),
0330     regulator_desc_buck1_4(3),
0331     regulator_desc_buck1_4(4),
0332     regulator_desc_buck5,
0333     regulator_desc_buck6_10(6, MIN_600_MV, STEP_6_25_MV),
0334     regulator_desc_buck6_10(7, MIN_600_MV, STEP_6_25_MV),
0335     regulator_desc_buck6_10(8, MIN_800_MV, STEP_12_5_MV),
0336     regulator_desc_buck6_10(9, MIN_1500_MV, STEP_12_5_MV),
0337     regulator_desc_buck6_10(10, MIN_1000_MV, STEP_12_5_MV),
0338 };
0339 
0340 static int s2mpa01_pmic_probe(struct platform_device *pdev)
0341 {
0342     struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
0343     struct regulator_config config = { };
0344     struct s2mpa01_info *s2mpa01;
0345     int i;
0346 
0347     s2mpa01 = devm_kzalloc(&pdev->dev, sizeof(*s2mpa01), GFP_KERNEL);
0348     if (!s2mpa01)
0349         return -ENOMEM;
0350 
0351     config.dev = iodev->dev;
0352     config.regmap = iodev->regmap_pmic;
0353     config.driver_data = s2mpa01;
0354 
0355     for (i = 0; i < S2MPA01_REGULATOR_MAX; i++) {
0356         struct regulator_dev *rdev;
0357 
0358         rdev = devm_regulator_register(&pdev->dev,
0359                         &regulators[i], &config);
0360         if (IS_ERR(rdev)) {
0361             dev_err(&pdev->dev, "regulator init failed for %d\n",
0362                 i);
0363             return PTR_ERR(rdev);
0364         }
0365     }
0366 
0367     return 0;
0368 }
0369 
0370 static const struct platform_device_id s2mpa01_pmic_id[] = {
0371     { "s2mpa01-pmic", 0},
0372     { },
0373 };
0374 MODULE_DEVICE_TABLE(platform, s2mpa01_pmic_id);
0375 
0376 static struct platform_driver s2mpa01_pmic_driver = {
0377     .driver = {
0378         .name = "s2mpa01-pmic",
0379     },
0380     .probe = s2mpa01_pmic_probe,
0381     .id_table = s2mpa01_pmic_id,
0382 };
0383 
0384 module_platform_driver(s2mpa01_pmic_driver);
0385 
0386 /* Module information */
0387 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
0388 MODULE_AUTHOR("Sachin Kamat <sachin.kamat@samsung.com>");
0389 MODULE_DESCRIPTION("Samsung S2MPA01 Regulator Driver");
0390 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!