0001
0002
0003
0004
0005
0006 #include <linux/kernel.h>
0007 #include <linux/module.h>
0008 #include <linux/init.h>
0009 #include <linux/err.h>
0010 #include <linux/slab.h>
0011 #include <linux/of.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/regmap.h>
0014 #include <linux/regulator/driver.h>
0015 #include <linux/regulator/machine.h>
0016 #include <linux/regulator/of_regulator.h>
0017 #include <linux/mfd/da9062/core.h>
0018 #include <linux/mfd/da9062/registers.h>
0019 #include <dt-bindings/regulator/dlg,da9063-regulator.h>
0020
0021
0022 enum {
0023 DA9061_ID_BUCK1,
0024 DA9061_ID_BUCK2,
0025 DA9061_ID_BUCK3,
0026 DA9061_ID_LDO1,
0027 DA9061_ID_LDO2,
0028 DA9061_ID_LDO3,
0029 DA9061_ID_LDO4,
0030 DA9061_MAX_REGULATORS,
0031 };
0032
0033 enum {
0034 DA9062_ID_BUCK1,
0035 DA9062_ID_BUCK2,
0036 DA9062_ID_BUCK3,
0037 DA9062_ID_BUCK4,
0038 DA9062_ID_LDO1,
0039 DA9062_ID_LDO2,
0040 DA9062_ID_LDO3,
0041 DA9062_ID_LDO4,
0042 DA9062_MAX_REGULATORS,
0043 };
0044
0045
0046 struct da9062_regulator_info {
0047 struct regulator_desc desc;
0048
0049 struct reg_field mode;
0050 struct reg_field suspend;
0051 struct reg_field sleep;
0052 struct reg_field suspend_sleep;
0053 unsigned int suspend_vsel_reg;
0054
0055 struct reg_field oc_event;
0056 };
0057
0058
0059 struct da9062_regulator {
0060 struct regulator_desc desc;
0061 struct regulator_dev *rdev;
0062 struct da9062 *hw;
0063 const struct da9062_regulator_info *info;
0064
0065 struct regmap_field *mode;
0066 struct regmap_field *suspend;
0067 struct regmap_field *sleep;
0068 struct regmap_field *suspend_sleep;
0069 };
0070
0071
0072 struct da9062_regulators {
0073 int irq_ldo_lim;
0074 unsigned n_regulators;
0075
0076 struct da9062_regulator regulator[];
0077 };
0078
0079
0080
0081
0082
0083
0084
0085
0086 static const unsigned int da9062_buck_a_limits[] = {
0087 500000, 600000, 700000, 800000, 900000, 1000000, 1100000, 1200000,
0088 1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000
0089 };
0090
0091
0092
0093
0094
0095
0096 static const unsigned int da9062_buck_b_limits[] = {
0097 1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
0098 2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
0099 };
0100
0101 static unsigned int da9062_map_buck_mode(unsigned int mode)
0102 {
0103 switch (mode) {
0104 case DA9063_BUCK_MODE_SLEEP:
0105 return REGULATOR_MODE_STANDBY;
0106 case DA9063_BUCK_MODE_SYNC:
0107 return REGULATOR_MODE_FAST;
0108 case DA9063_BUCK_MODE_AUTO:
0109 return REGULATOR_MODE_NORMAL;
0110 default:
0111 return REGULATOR_MODE_INVALID;
0112 }
0113 }
0114
0115 static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
0116 {
0117 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0118 unsigned val;
0119
0120 switch (mode) {
0121 case REGULATOR_MODE_FAST:
0122 val = DA9063_BUCK_MODE_SYNC;
0123 break;
0124 case REGULATOR_MODE_NORMAL:
0125 val = DA9063_BUCK_MODE_AUTO;
0126 break;
0127 case REGULATOR_MODE_STANDBY:
0128 val = DA9063_BUCK_MODE_SLEEP;
0129 break;
0130 default:
0131 return -EINVAL;
0132 }
0133
0134 return regmap_field_write(regl->mode, val);
0135 }
0136
0137
0138
0139
0140
0141
0142
0143 static unsigned da9062_buck_get_mode(struct regulator_dev *rdev)
0144 {
0145 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0146 unsigned int val;
0147 int ret;
0148
0149 ret = regmap_field_read(regl->mode, &val);
0150 if (ret < 0)
0151 return ret;
0152
0153 switch (val) {
0154 default:
0155
0156 break;
0157 case DA9063_BUCK_MODE_SLEEP:
0158 return REGULATOR_MODE_STANDBY;
0159 case DA9063_BUCK_MODE_SYNC:
0160 return REGULATOR_MODE_FAST;
0161 case DA9063_BUCK_MODE_AUTO:
0162 return REGULATOR_MODE_NORMAL;
0163 }
0164
0165 ret = regmap_field_read(regl->sleep, &val);
0166 if (ret < 0)
0167 return 0;
0168
0169 if (val)
0170 return REGULATOR_MODE_STANDBY;
0171 else
0172 return REGULATOR_MODE_FAST;
0173 }
0174
0175
0176
0177
0178
0179
0180 static int da9062_ldo_set_mode(struct regulator_dev *rdev, unsigned mode)
0181 {
0182 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0183 unsigned val;
0184
0185 switch (mode) {
0186 case REGULATOR_MODE_NORMAL:
0187 val = 0;
0188 break;
0189 case REGULATOR_MODE_STANDBY:
0190 val = 1;
0191 break;
0192 default:
0193 return -EINVAL;
0194 }
0195
0196 return regmap_field_write(regl->sleep, val);
0197 }
0198
0199 static unsigned da9062_ldo_get_mode(struct regulator_dev *rdev)
0200 {
0201 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0202 int ret, val;
0203
0204 ret = regmap_field_read(regl->sleep, &val);
0205 if (ret < 0)
0206 return 0;
0207
0208 if (val)
0209 return REGULATOR_MODE_STANDBY;
0210 else
0211 return REGULATOR_MODE_NORMAL;
0212 }
0213
0214 static int da9062_buck_get_status(struct regulator_dev *rdev)
0215 {
0216 int ret = regulator_is_enabled_regmap(rdev);
0217
0218 if (ret == 0) {
0219 ret = REGULATOR_STATUS_OFF;
0220 } else if (ret > 0) {
0221 ret = da9062_buck_get_mode(rdev);
0222 if (ret > 0)
0223 ret = regulator_mode_to_status(ret);
0224 else if (ret == 0)
0225 ret = -EIO;
0226 }
0227
0228 return ret;
0229 }
0230
0231 static int da9062_ldo_get_status(struct regulator_dev *rdev)
0232 {
0233 int ret = regulator_is_enabled_regmap(rdev);
0234
0235 if (ret == 0) {
0236 ret = REGULATOR_STATUS_OFF;
0237 } else if (ret > 0) {
0238 ret = da9062_ldo_get_mode(rdev);
0239 if (ret > 0)
0240 ret = regulator_mode_to_status(ret);
0241 else if (ret == 0)
0242 ret = -EIO;
0243 }
0244
0245 return ret;
0246 }
0247
0248 static int da9062_set_suspend_voltage(struct regulator_dev *rdev, int uv)
0249 {
0250 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0251 const struct da9062_regulator_info *rinfo = regl->info;
0252 int ret, sel;
0253
0254 sel = regulator_map_voltage_linear(rdev, uv, uv);
0255 if (sel < 0)
0256 return sel;
0257
0258 sel <<= ffs(rdev->desc->vsel_mask) - 1;
0259
0260 ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg,
0261 rdev->desc->vsel_mask, sel);
0262
0263 return ret;
0264 }
0265
0266 static int da9062_suspend_enable(struct regulator_dev *rdev)
0267 {
0268 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0269
0270 return regmap_field_write(regl->suspend, 1);
0271 }
0272
0273 static int da9062_suspend_disable(struct regulator_dev *rdev)
0274 {
0275 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0276
0277 return regmap_field_write(regl->suspend, 0);
0278 }
0279
0280 static int da9062_buck_set_suspend_mode(struct regulator_dev *rdev,
0281 unsigned mode)
0282 {
0283 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0284 int val;
0285
0286 switch (mode) {
0287 case REGULATOR_MODE_FAST:
0288 val = DA9063_BUCK_MODE_SYNC;
0289 break;
0290 case REGULATOR_MODE_NORMAL:
0291 val = DA9063_BUCK_MODE_AUTO;
0292 break;
0293 case REGULATOR_MODE_STANDBY:
0294 val = DA9063_BUCK_MODE_SLEEP;
0295 break;
0296 default:
0297 return -EINVAL;
0298 }
0299
0300 return regmap_field_write(regl->mode, val);
0301 }
0302
0303 static int da9062_ldo_set_suspend_mode(struct regulator_dev *rdev,
0304 unsigned mode)
0305 {
0306 struct da9062_regulator *regl = rdev_get_drvdata(rdev);
0307 unsigned val;
0308
0309 switch (mode) {
0310 case REGULATOR_MODE_NORMAL:
0311 val = 0;
0312 break;
0313 case REGULATOR_MODE_STANDBY:
0314 val = 1;
0315 break;
0316 default:
0317 return -EINVAL;
0318 }
0319
0320 return regmap_field_write(regl->suspend_sleep, val);
0321 }
0322
0323 static const struct regulator_ops da9062_buck_ops = {
0324 .enable = regulator_enable_regmap,
0325 .disable = regulator_disable_regmap,
0326 .is_enabled = regulator_is_enabled_regmap,
0327 .get_voltage_sel = regulator_get_voltage_sel_regmap,
0328 .set_voltage_sel = regulator_set_voltage_sel_regmap,
0329 .list_voltage = regulator_list_voltage_linear,
0330 .set_current_limit = regulator_set_current_limit_regmap,
0331 .get_current_limit = regulator_get_current_limit_regmap,
0332 .set_mode = da9062_buck_set_mode,
0333 .get_mode = da9062_buck_get_mode,
0334 .get_status = da9062_buck_get_status,
0335 .set_suspend_voltage = da9062_set_suspend_voltage,
0336 .set_suspend_enable = da9062_suspend_enable,
0337 .set_suspend_disable = da9062_suspend_disable,
0338 .set_suspend_mode = da9062_buck_set_suspend_mode,
0339 };
0340
0341 static const struct regulator_ops da9062_ldo_ops = {
0342 .enable = regulator_enable_regmap,
0343 .disable = regulator_disable_regmap,
0344 .is_enabled = regulator_is_enabled_regmap,
0345 .get_voltage_sel = regulator_get_voltage_sel_regmap,
0346 .set_voltage_sel = regulator_set_voltage_sel_regmap,
0347 .list_voltage = regulator_list_voltage_linear,
0348 .set_mode = da9062_ldo_set_mode,
0349 .get_mode = da9062_ldo_get_mode,
0350 .get_status = da9062_ldo_get_status,
0351 .set_suspend_voltage = da9062_set_suspend_voltage,
0352 .set_suspend_enable = da9062_suspend_enable,
0353 .set_suspend_disable = da9062_suspend_disable,
0354 .set_suspend_mode = da9062_ldo_set_suspend_mode,
0355 };
0356
0357
0358 static const struct da9062_regulator_info local_da9061_regulator_info[] = {
0359 {
0360 .desc.id = DA9061_ID_BUCK1,
0361 .desc.name = "DA9061 BUCK1",
0362 .desc.of_match = of_match_ptr("buck1"),
0363 .desc.regulators_node = of_match_ptr("regulators"),
0364 .desc.ops = &da9062_buck_ops,
0365 .desc.min_uV = (300) * 1000,
0366 .desc.uV_step = (10) * 1000,
0367 .desc.n_voltages = ((1570) - (300))/(10) + 1,
0368 .desc.curr_table = da9062_buck_a_limits,
0369 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
0370 .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
0371 .desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
0372 .desc.enable_reg = DA9062AA_BUCK1_CONT,
0373 .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
0374 .desc.vsel_reg = DA9062AA_VBUCK1_A,
0375 .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
0376 .desc.linear_min_sel = 0,
0377 .desc.of_map_mode = da9062_map_buck_mode,
0378 .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
0379 __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
0380 sizeof(unsigned int) * 8 -
0381 __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
0382 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
0383 __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
0384 sizeof(unsigned int) * 8 -
0385 __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
0386 .suspend_vsel_reg = DA9062AA_VBUCK1_B,
0387 .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
0388 __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
0389 sizeof(unsigned int) * 8 -
0390 __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
0391 .suspend = REG_FIELD(DA9062AA_BUCK1_CONT,
0392 __builtin_ffs((int)DA9062AA_BUCK1_CONF_MASK) - 1,
0393 sizeof(unsigned int) * 8 -
0394 __builtin_clz(DA9062AA_BUCK1_CONF_MASK) - 1),
0395 },
0396 {
0397 .desc.id = DA9061_ID_BUCK2,
0398 .desc.name = "DA9061 BUCK2",
0399 .desc.of_match = of_match_ptr("buck2"),
0400 .desc.regulators_node = of_match_ptr("regulators"),
0401 .desc.ops = &da9062_buck_ops,
0402 .desc.min_uV = (800) * 1000,
0403 .desc.uV_step = (20) * 1000,
0404 .desc.n_voltages = ((3340) - (800))/(20) + 1,
0405 .desc.curr_table = da9062_buck_b_limits,
0406 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
0407 .desc.csel_reg = DA9062AA_BUCK_ILIM_A,
0408 .desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
0409 .desc.enable_reg = DA9062AA_BUCK3_CONT,
0410 .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
0411 .desc.vsel_reg = DA9062AA_VBUCK3_A,
0412 .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
0413 .desc.linear_min_sel = 0,
0414 .desc.of_map_mode = da9062_map_buck_mode,
0415 .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
0416 __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
0417 sizeof(unsigned int) * 8 -
0418 __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
0419 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
0420 __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
0421 sizeof(unsigned int) * 8 -
0422 __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
0423 .suspend_vsel_reg = DA9062AA_VBUCK3_B,
0424 .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
0425 __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
0426 sizeof(unsigned int) * 8 -
0427 __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
0428 .suspend = REG_FIELD(DA9062AA_BUCK3_CONT,
0429 __builtin_ffs((int)DA9062AA_BUCK3_CONF_MASK) - 1,
0430 sizeof(unsigned int) * 8 -
0431 __builtin_clz(DA9062AA_BUCK3_CONF_MASK) - 1),
0432 },
0433 {
0434 .desc.id = DA9061_ID_BUCK3,
0435 .desc.name = "DA9061 BUCK3",
0436 .desc.of_match = of_match_ptr("buck3"),
0437 .desc.regulators_node = of_match_ptr("regulators"),
0438 .desc.ops = &da9062_buck_ops,
0439 .desc.min_uV = (530) * 1000,
0440 .desc.uV_step = (10) * 1000,
0441 .desc.n_voltages = ((1800) - (530))/(10) + 1,
0442 .desc.curr_table = da9062_buck_a_limits,
0443 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
0444 .desc.csel_reg = DA9062AA_BUCK_ILIM_B,
0445 .desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
0446 .desc.enable_reg = DA9062AA_BUCK4_CONT,
0447 .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
0448 .desc.vsel_reg = DA9062AA_VBUCK4_A,
0449 .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
0450 .desc.linear_min_sel = 0,
0451 .desc.of_map_mode = da9062_map_buck_mode,
0452 .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
0453 __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
0454 sizeof(unsigned int) * 8 -
0455 __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
0456 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
0457 __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
0458 sizeof(unsigned int) * 8 -
0459 __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
0460 .suspend_vsel_reg = DA9062AA_VBUCK4_B,
0461 .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
0462 __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
0463 sizeof(unsigned int) * 8 -
0464 __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
0465 .suspend = REG_FIELD(DA9062AA_BUCK4_CONT,
0466 __builtin_ffs((int)DA9062AA_BUCK4_CONF_MASK) - 1,
0467 sizeof(unsigned int) * 8 -
0468 __builtin_clz(DA9062AA_BUCK4_CONF_MASK) - 1),
0469 },
0470 {
0471 .desc.id = DA9061_ID_LDO1,
0472 .desc.name = "DA9061 LDO1",
0473 .desc.of_match = of_match_ptr("ldo1"),
0474 .desc.regulators_node = of_match_ptr("regulators"),
0475 .desc.ops = &da9062_ldo_ops,
0476 .desc.min_uV = (900) * 1000,
0477 .desc.uV_step = (50) * 1000,
0478 .desc.n_voltages = ((3600) - (900))/(50) + 1
0479 + DA9062AA_VLDO_A_MIN_SEL,
0480 .desc.enable_reg = DA9062AA_LDO1_CONT,
0481 .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
0482 .desc.vsel_reg = DA9062AA_VLDO1_A,
0483 .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
0484 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0485 .sleep = REG_FIELD(DA9062AA_VLDO1_A,
0486 __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
0487 sizeof(unsigned int) * 8 -
0488 __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
0489 .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
0490 __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
0491 sizeof(unsigned int) * 8 -
0492 __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
0493 .suspend_vsel_reg = DA9062AA_VLDO1_B,
0494 .suspend = REG_FIELD(DA9062AA_LDO1_CONT,
0495 __builtin_ffs((int)DA9062AA_LDO1_CONF_MASK) - 1,
0496 sizeof(unsigned int) * 8 -
0497 __builtin_clz(DA9062AA_LDO1_CONF_MASK) - 1),
0498 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0499 __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
0500 sizeof(unsigned int) * 8 -
0501 __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
0502 },
0503 {
0504 .desc.id = DA9061_ID_LDO2,
0505 .desc.name = "DA9061 LDO2",
0506 .desc.of_match = of_match_ptr("ldo2"),
0507 .desc.regulators_node = of_match_ptr("regulators"),
0508 .desc.ops = &da9062_ldo_ops,
0509 .desc.min_uV = (900) * 1000,
0510 .desc.uV_step = (50) * 1000,
0511 .desc.n_voltages = ((3600) - (900))/(50) + 1
0512 + DA9062AA_VLDO_A_MIN_SEL,
0513 .desc.enable_reg = DA9062AA_LDO2_CONT,
0514 .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
0515 .desc.vsel_reg = DA9062AA_VLDO2_A,
0516 .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
0517 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0518 .sleep = REG_FIELD(DA9062AA_VLDO2_A,
0519 __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
0520 sizeof(unsigned int) * 8 -
0521 __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
0522 .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
0523 __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
0524 sizeof(unsigned int) * 8 -
0525 __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
0526 .suspend_vsel_reg = DA9062AA_VLDO2_B,
0527 .suspend = REG_FIELD(DA9062AA_LDO2_CONT,
0528 __builtin_ffs((int)DA9062AA_LDO2_CONF_MASK) - 1,
0529 sizeof(unsigned int) * 8 -
0530 __builtin_clz(DA9062AA_LDO2_CONF_MASK) - 1),
0531 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0532 __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
0533 sizeof(unsigned int) * 8 -
0534 __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
0535 },
0536 {
0537 .desc.id = DA9061_ID_LDO3,
0538 .desc.name = "DA9061 LDO3",
0539 .desc.of_match = of_match_ptr("ldo3"),
0540 .desc.regulators_node = of_match_ptr("regulators"),
0541 .desc.ops = &da9062_ldo_ops,
0542 .desc.min_uV = (900) * 1000,
0543 .desc.uV_step = (50) * 1000,
0544 .desc.n_voltages = ((3600) - (900))/(50) + 1
0545 + DA9062AA_VLDO_A_MIN_SEL,
0546 .desc.enable_reg = DA9062AA_LDO3_CONT,
0547 .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
0548 .desc.vsel_reg = DA9062AA_VLDO3_A,
0549 .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
0550 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0551 .sleep = REG_FIELD(DA9062AA_VLDO3_A,
0552 __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
0553 sizeof(unsigned int) * 8 -
0554 __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
0555 .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
0556 __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
0557 sizeof(unsigned int) * 8 -
0558 __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
0559 .suspend_vsel_reg = DA9062AA_VLDO3_B,
0560 .suspend = REG_FIELD(DA9062AA_LDO3_CONT,
0561 __builtin_ffs((int)DA9062AA_LDO3_CONF_MASK) - 1,
0562 sizeof(unsigned int) * 8 -
0563 __builtin_clz(DA9062AA_LDO3_CONF_MASK) - 1),
0564 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0565 __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
0566 sizeof(unsigned int) * 8 -
0567 __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
0568 },
0569 {
0570 .desc.id = DA9061_ID_LDO4,
0571 .desc.name = "DA9061 LDO4",
0572 .desc.of_match = of_match_ptr("ldo4"),
0573 .desc.regulators_node = of_match_ptr("regulators"),
0574 .desc.ops = &da9062_ldo_ops,
0575 .desc.min_uV = (900) * 1000,
0576 .desc.uV_step = (50) * 1000,
0577 .desc.n_voltages = ((3600) - (900))/(50) + 1
0578 + DA9062AA_VLDO_A_MIN_SEL,
0579 .desc.enable_reg = DA9062AA_LDO4_CONT,
0580 .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
0581 .desc.vsel_reg = DA9062AA_VLDO4_A,
0582 .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
0583 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0584 .sleep = REG_FIELD(DA9062AA_VLDO4_A,
0585 __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
0586 sizeof(unsigned int) * 8 -
0587 __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
0588 .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
0589 __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
0590 sizeof(unsigned int) * 8 -
0591 __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
0592 .suspend_vsel_reg = DA9062AA_VLDO4_B,
0593 .suspend = REG_FIELD(DA9062AA_LDO4_CONT,
0594 __builtin_ffs((int)DA9062AA_LDO4_CONF_MASK) - 1,
0595 sizeof(unsigned int) * 8 -
0596 __builtin_clz(DA9062AA_LDO4_CONF_MASK) - 1),
0597 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0598 __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
0599 sizeof(unsigned int) * 8 -
0600 __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
0601 },
0602 };
0603
0604
0605 static const struct da9062_regulator_info local_da9062_regulator_info[] = {
0606 {
0607 .desc.id = DA9062_ID_BUCK1,
0608 .desc.name = "DA9062 BUCK1",
0609 .desc.of_match = of_match_ptr("buck1"),
0610 .desc.regulators_node = of_match_ptr("regulators"),
0611 .desc.ops = &da9062_buck_ops,
0612 .desc.min_uV = (300) * 1000,
0613 .desc.uV_step = (10) * 1000,
0614 .desc.n_voltages = ((1570) - (300))/(10) + 1,
0615 .desc.curr_table = da9062_buck_a_limits,
0616 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
0617 .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
0618 .desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
0619 .desc.enable_reg = DA9062AA_BUCK1_CONT,
0620 .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
0621 .desc.vsel_reg = DA9062AA_VBUCK1_A,
0622 .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
0623 .desc.linear_min_sel = 0,
0624 .desc.of_map_mode = da9062_map_buck_mode,
0625 .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
0626 __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
0627 sizeof(unsigned int) * 8 -
0628 __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
0629 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
0630 __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
0631 sizeof(unsigned int) * 8 -
0632 __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
0633 .suspend_vsel_reg = DA9062AA_VBUCK1_B,
0634 .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
0635 __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
0636 sizeof(unsigned int) * 8 -
0637 __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
0638 .suspend = REG_FIELD(DA9062AA_BUCK1_CONT,
0639 __builtin_ffs((int)DA9062AA_BUCK1_CONF_MASK) - 1,
0640 sizeof(unsigned int) * 8 -
0641 __builtin_clz(DA9062AA_BUCK1_CONF_MASK) - 1),
0642 },
0643 {
0644 .desc.id = DA9062_ID_BUCK2,
0645 .desc.name = "DA9062 BUCK2",
0646 .desc.of_match = of_match_ptr("buck2"),
0647 .desc.regulators_node = of_match_ptr("regulators"),
0648 .desc.ops = &da9062_buck_ops,
0649 .desc.min_uV = (300) * 1000,
0650 .desc.uV_step = (10) * 1000,
0651 .desc.n_voltages = ((1570) - (300))/(10) + 1,
0652 .desc.curr_table = da9062_buck_a_limits,
0653 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
0654 .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
0655 .desc.csel_mask = DA9062AA_BUCK2_ILIM_MASK,
0656 .desc.enable_reg = DA9062AA_BUCK2_CONT,
0657 .desc.enable_mask = DA9062AA_BUCK2_EN_MASK,
0658 .desc.vsel_reg = DA9062AA_VBUCK2_A,
0659 .desc.vsel_mask = DA9062AA_VBUCK2_A_MASK,
0660 .desc.linear_min_sel = 0,
0661 .desc.of_map_mode = da9062_map_buck_mode,
0662 .sleep = REG_FIELD(DA9062AA_VBUCK2_A,
0663 __builtin_ffs((int)DA9062AA_BUCK2_SL_A_MASK) - 1,
0664 sizeof(unsigned int) * 8 -
0665 __builtin_clz((DA9062AA_BUCK2_SL_A_MASK)) - 1),
0666 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK2_B,
0667 __builtin_ffs((int)DA9062AA_BUCK2_SL_B_MASK) - 1,
0668 sizeof(unsigned int) * 8 -
0669 __builtin_clz((DA9062AA_BUCK2_SL_B_MASK)) - 1),
0670 .suspend_vsel_reg = DA9062AA_VBUCK2_B,
0671 .mode = REG_FIELD(DA9062AA_BUCK2_CFG,
0672 __builtin_ffs((int)DA9062AA_BUCK2_MODE_MASK) - 1,
0673 sizeof(unsigned int) * 8 -
0674 __builtin_clz((DA9062AA_BUCK2_MODE_MASK)) - 1),
0675 .suspend = REG_FIELD(DA9062AA_BUCK2_CONT,
0676 __builtin_ffs((int)DA9062AA_BUCK2_CONF_MASK) - 1,
0677 sizeof(unsigned int) * 8 -
0678 __builtin_clz(DA9062AA_BUCK2_CONF_MASK) - 1),
0679 },
0680 {
0681 .desc.id = DA9062_ID_BUCK3,
0682 .desc.name = "DA9062 BUCK3",
0683 .desc.of_match = of_match_ptr("buck3"),
0684 .desc.regulators_node = of_match_ptr("regulators"),
0685 .desc.ops = &da9062_buck_ops,
0686 .desc.min_uV = (800) * 1000,
0687 .desc.uV_step = (20) * 1000,
0688 .desc.n_voltages = ((3340) - (800))/(20) + 1,
0689 .desc.curr_table = da9062_buck_b_limits,
0690 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
0691 .desc.csel_reg = DA9062AA_BUCK_ILIM_A,
0692 .desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
0693 .desc.enable_reg = DA9062AA_BUCK3_CONT,
0694 .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
0695 .desc.vsel_reg = DA9062AA_VBUCK3_A,
0696 .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
0697 .desc.linear_min_sel = 0,
0698 .desc.of_map_mode = da9062_map_buck_mode,
0699 .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
0700 __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
0701 sizeof(unsigned int) * 8 -
0702 __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
0703 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
0704 __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
0705 sizeof(unsigned int) * 8 -
0706 __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
0707 .suspend_vsel_reg = DA9062AA_VBUCK3_B,
0708 .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
0709 __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
0710 sizeof(unsigned int) * 8 -
0711 __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
0712 .suspend = REG_FIELD(DA9062AA_BUCK3_CONT,
0713 __builtin_ffs((int)DA9062AA_BUCK3_CONF_MASK) - 1,
0714 sizeof(unsigned int) * 8 -
0715 __builtin_clz(DA9062AA_BUCK3_CONF_MASK) - 1),
0716 },
0717 {
0718 .desc.id = DA9062_ID_BUCK4,
0719 .desc.name = "DA9062 BUCK4",
0720 .desc.of_match = of_match_ptr("buck4"),
0721 .desc.regulators_node = of_match_ptr("regulators"),
0722 .desc.ops = &da9062_buck_ops,
0723 .desc.min_uV = (530) * 1000,
0724 .desc.uV_step = (10) * 1000,
0725 .desc.n_voltages = ((1800) - (530))/(10) + 1,
0726 .desc.curr_table = da9062_buck_a_limits,
0727 .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
0728 .desc.csel_reg = DA9062AA_BUCK_ILIM_B,
0729 .desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
0730 .desc.enable_reg = DA9062AA_BUCK4_CONT,
0731 .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
0732 .desc.vsel_reg = DA9062AA_VBUCK4_A,
0733 .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
0734 .desc.linear_min_sel = 0,
0735 .desc.of_map_mode = da9062_map_buck_mode,
0736 .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
0737 __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
0738 sizeof(unsigned int) * 8 -
0739 __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
0740 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
0741 __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
0742 sizeof(unsigned int) * 8 -
0743 __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
0744 .suspend_vsel_reg = DA9062AA_VBUCK4_B,
0745 .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
0746 __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
0747 sizeof(unsigned int) * 8 -
0748 __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
0749 .suspend = REG_FIELD(DA9062AA_BUCK4_CONT,
0750 __builtin_ffs((int)DA9062AA_BUCK4_CONF_MASK) - 1,
0751 sizeof(unsigned int) * 8 -
0752 __builtin_clz(DA9062AA_BUCK4_CONF_MASK) - 1),
0753 },
0754 {
0755 .desc.id = DA9062_ID_LDO1,
0756 .desc.name = "DA9062 LDO1",
0757 .desc.of_match = of_match_ptr("ldo1"),
0758 .desc.regulators_node = of_match_ptr("regulators"),
0759 .desc.ops = &da9062_ldo_ops,
0760 .desc.min_uV = (900) * 1000,
0761 .desc.uV_step = (50) * 1000,
0762 .desc.n_voltages = ((3600) - (900))/(50) + 1
0763 + DA9062AA_VLDO_A_MIN_SEL,
0764 .desc.enable_reg = DA9062AA_LDO1_CONT,
0765 .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
0766 .desc.vsel_reg = DA9062AA_VLDO1_A,
0767 .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
0768 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0769 .sleep = REG_FIELD(DA9062AA_VLDO1_A,
0770 __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
0771 sizeof(unsigned int) * 8 -
0772 __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
0773 .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
0774 __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
0775 sizeof(unsigned int) * 8 -
0776 __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
0777 .suspend_vsel_reg = DA9062AA_VLDO1_B,
0778 .suspend = REG_FIELD(DA9062AA_LDO1_CONT,
0779 __builtin_ffs((int)DA9062AA_LDO1_CONF_MASK) - 1,
0780 sizeof(unsigned int) * 8 -
0781 __builtin_clz(DA9062AA_LDO1_CONF_MASK) - 1),
0782 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0783 __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
0784 sizeof(unsigned int) * 8 -
0785 __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
0786 },
0787 {
0788 .desc.id = DA9062_ID_LDO2,
0789 .desc.name = "DA9062 LDO2",
0790 .desc.of_match = of_match_ptr("ldo2"),
0791 .desc.regulators_node = of_match_ptr("regulators"),
0792 .desc.ops = &da9062_ldo_ops,
0793 .desc.min_uV = (900) * 1000,
0794 .desc.uV_step = (50) * 1000,
0795 .desc.n_voltages = ((3600) - (900))/(50) + 1
0796 + DA9062AA_VLDO_A_MIN_SEL,
0797 .desc.enable_reg = DA9062AA_LDO2_CONT,
0798 .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
0799 .desc.vsel_reg = DA9062AA_VLDO2_A,
0800 .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
0801 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0802 .sleep = REG_FIELD(DA9062AA_VLDO2_A,
0803 __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
0804 sizeof(unsigned int) * 8 -
0805 __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
0806 .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
0807 __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
0808 sizeof(unsigned int) * 8 -
0809 __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
0810 .suspend_vsel_reg = DA9062AA_VLDO2_B,
0811 .suspend = REG_FIELD(DA9062AA_LDO2_CONT,
0812 __builtin_ffs((int)DA9062AA_LDO2_CONF_MASK) - 1,
0813 sizeof(unsigned int) * 8 -
0814 __builtin_clz(DA9062AA_LDO2_CONF_MASK) - 1),
0815 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0816 __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
0817 sizeof(unsigned int) * 8 -
0818 __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
0819 },
0820 {
0821 .desc.id = DA9062_ID_LDO3,
0822 .desc.name = "DA9062 LDO3",
0823 .desc.of_match = of_match_ptr("ldo3"),
0824 .desc.regulators_node = of_match_ptr("regulators"),
0825 .desc.ops = &da9062_ldo_ops,
0826 .desc.min_uV = (900) * 1000,
0827 .desc.uV_step = (50) * 1000,
0828 .desc.n_voltages = ((3600) - (900))/(50) + 1
0829 + DA9062AA_VLDO_A_MIN_SEL,
0830 .desc.enable_reg = DA9062AA_LDO3_CONT,
0831 .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
0832 .desc.vsel_reg = DA9062AA_VLDO3_A,
0833 .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
0834 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0835 .sleep = REG_FIELD(DA9062AA_VLDO3_A,
0836 __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
0837 sizeof(unsigned int) * 8 -
0838 __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
0839 .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
0840 __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
0841 sizeof(unsigned int) * 8 -
0842 __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
0843 .suspend_vsel_reg = DA9062AA_VLDO3_B,
0844 .suspend = REG_FIELD(DA9062AA_LDO3_CONT,
0845 __builtin_ffs((int)DA9062AA_LDO3_CONF_MASK) - 1,
0846 sizeof(unsigned int) * 8 -
0847 __builtin_clz(DA9062AA_LDO3_CONF_MASK) - 1),
0848 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0849 __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
0850 sizeof(unsigned int) * 8 -
0851 __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
0852 },
0853 {
0854 .desc.id = DA9062_ID_LDO4,
0855 .desc.name = "DA9062 LDO4",
0856 .desc.of_match = of_match_ptr("ldo4"),
0857 .desc.regulators_node = of_match_ptr("regulators"),
0858 .desc.ops = &da9062_ldo_ops,
0859 .desc.min_uV = (900) * 1000,
0860 .desc.uV_step = (50) * 1000,
0861 .desc.n_voltages = ((3600) - (900))/(50) + 1
0862 + DA9062AA_VLDO_A_MIN_SEL,
0863 .desc.enable_reg = DA9062AA_LDO4_CONT,
0864 .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
0865 .desc.vsel_reg = DA9062AA_VLDO4_A,
0866 .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
0867 .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
0868 .sleep = REG_FIELD(DA9062AA_VLDO4_A,
0869 __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
0870 sizeof(unsigned int) * 8 -
0871 __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
0872 .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
0873 __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
0874 sizeof(unsigned int) * 8 -
0875 __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
0876 .suspend_vsel_reg = DA9062AA_VLDO4_B,
0877 .suspend = REG_FIELD(DA9062AA_LDO4_CONT,
0878 __builtin_ffs((int)DA9062AA_LDO4_CONF_MASK) - 1,
0879 sizeof(unsigned int) * 8 -
0880 __builtin_clz(DA9062AA_LDO4_CONF_MASK) - 1),
0881 .oc_event = REG_FIELD(DA9062AA_STATUS_D,
0882 __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
0883 sizeof(unsigned int) * 8 -
0884 __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
0885 },
0886 };
0887
0888
0889 static irqreturn_t da9062_ldo_lim_event(int irq, void *data)
0890 {
0891 struct da9062_regulators *regulators = data;
0892 struct da9062 *hw = regulators->regulator[0].hw;
0893 struct da9062_regulator *regl;
0894 int handled = IRQ_NONE;
0895 int bits, i, ret;
0896
0897 ret = regmap_read(hw->regmap, DA9062AA_STATUS_D, &bits);
0898 if (ret < 0) {
0899 dev_err(hw->dev,
0900 "Failed to read LDO overcurrent indicator\n");
0901 goto ldo_lim_error;
0902 }
0903
0904 for (i = regulators->n_regulators - 1; i >= 0; i--) {
0905 regl = ®ulators->regulator[i];
0906 if (regl->info->oc_event.reg != DA9062AA_STATUS_D)
0907 continue;
0908
0909 if (BIT(regl->info->oc_event.lsb) & bits) {
0910 regulator_notifier_call_chain(regl->rdev,
0911 REGULATOR_EVENT_OVER_CURRENT, NULL);
0912 handled = IRQ_HANDLED;
0913 }
0914 }
0915
0916 ldo_lim_error:
0917 return handled;
0918 }
0919
0920 static int da9062_regulator_probe(struct platform_device *pdev)
0921 {
0922 struct da9062 *chip = dev_get_drvdata(pdev->dev.parent);
0923 struct da9062_regulators *regulators;
0924 struct da9062_regulator *regl;
0925 struct regulator_config config = { };
0926 const struct da9062_regulator_info *rinfo;
0927 int irq, n, ret;
0928 int max_regulators;
0929
0930 switch (chip->chip_type) {
0931 case COMPAT_TYPE_DA9061:
0932 max_regulators = DA9061_MAX_REGULATORS;
0933 rinfo = local_da9061_regulator_info;
0934 break;
0935 case COMPAT_TYPE_DA9062:
0936 max_regulators = DA9062_MAX_REGULATORS;
0937 rinfo = local_da9062_regulator_info;
0938 break;
0939 default:
0940 dev_err(chip->dev, "Unrecognised chip type\n");
0941 return -ENODEV;
0942 }
0943
0944
0945 regulators = devm_kzalloc(&pdev->dev, struct_size(regulators, regulator,
0946 max_regulators), GFP_KERNEL);
0947 if (!regulators)
0948 return -ENOMEM;
0949
0950 regulators->n_regulators = max_regulators;
0951 platform_set_drvdata(pdev, regulators);
0952
0953 for (n = 0; n < regulators->n_regulators; n++) {
0954
0955 regl = ®ulators->regulator[n];
0956 regl->hw = chip;
0957 regl->info = &rinfo[n];
0958 regl->desc = regl->info->desc;
0959 regl->desc.type = REGULATOR_VOLTAGE;
0960 regl->desc.owner = THIS_MODULE;
0961
0962 if (regl->info->mode.reg) {
0963 regl->mode = devm_regmap_field_alloc(
0964 &pdev->dev,
0965 chip->regmap,
0966 regl->info->mode);
0967 if (IS_ERR(regl->mode))
0968 return PTR_ERR(regl->mode);
0969 }
0970
0971 if (regl->info->suspend.reg) {
0972 regl->suspend = devm_regmap_field_alloc(
0973 &pdev->dev,
0974 chip->regmap,
0975 regl->info->suspend);
0976 if (IS_ERR(regl->suspend))
0977 return PTR_ERR(regl->suspend);
0978 }
0979
0980 if (regl->info->sleep.reg) {
0981 regl->sleep = devm_regmap_field_alloc(
0982 &pdev->dev,
0983 chip->regmap,
0984 regl->info->sleep);
0985 if (IS_ERR(regl->sleep))
0986 return PTR_ERR(regl->sleep);
0987 }
0988
0989 if (regl->info->suspend_sleep.reg) {
0990 regl->suspend_sleep = devm_regmap_field_alloc(
0991 &pdev->dev,
0992 chip->regmap,
0993 regl->info->suspend_sleep);
0994 if (IS_ERR(regl->suspend_sleep))
0995 return PTR_ERR(regl->suspend_sleep);
0996 }
0997
0998
0999 memset(&config, 0, sizeof(config));
1000 config.dev = chip->dev;
1001 config.driver_data = regl;
1002 config.regmap = chip->regmap;
1003
1004 regl->rdev = devm_regulator_register(&pdev->dev, ®l->desc,
1005 &config);
1006 if (IS_ERR(regl->rdev)) {
1007 dev_err(&pdev->dev,
1008 "Failed to register %s regulator\n",
1009 regl->desc.name);
1010 return PTR_ERR(regl->rdev);
1011 }
1012 }
1013
1014
1015 irq = platform_get_irq_byname(pdev, "LDO_LIM");
1016 if (irq < 0)
1017 return irq;
1018 regulators->irq_ldo_lim = irq;
1019
1020 ret = devm_request_threaded_irq(&pdev->dev, irq,
1021 NULL, da9062_ldo_lim_event,
1022 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1023 "LDO_LIM", regulators);
1024 if (ret) {
1025 dev_warn(&pdev->dev,
1026 "Failed to request LDO_LIM IRQ.\n");
1027 regulators->irq_ldo_lim = -ENXIO;
1028 }
1029
1030 return 0;
1031 }
1032
1033 static struct platform_driver da9062_regulator_driver = {
1034 .driver = {
1035 .name = "da9062-regulators",
1036 },
1037 .probe = da9062_regulator_probe,
1038 };
1039
1040 static int __init da9062_regulator_init(void)
1041 {
1042 return platform_driver_register(&da9062_regulator_driver);
1043 }
1044 subsys_initcall(da9062_regulator_init);
1045
1046 static void __exit da9062_regulator_cleanup(void)
1047 {
1048 platform_driver_unregister(&da9062_regulator_driver);
1049 }
1050 module_exit(da9062_regulator_cleanup);
1051
1052
1053 MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
1054 MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062 and DA9061");
1055 MODULE_LICENSE("GPL");
1056 MODULE_ALIAS("platform:da9062-regulators");
