Merge remote-tracking branches 'regulator/topic/mode', 'regulator/topic/notifier', 'regulator/topic/palmas', 'regulator/topic/qcom' and 'regulator/topic/stw481x' into regulator-next
Mark Brown
commit
bea3672833
|
|
@ -137,7 +137,7 @@ Indirect operating mode control.
|
|||
Consumer drivers can request a change in their supply regulator operating mode
|
||||
by calling :-
|
||||
|
||||
int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
|
||||
int regulator_set_load(struct regulator *regulator, int load_uA);
|
||||
|
||||
This will cause the core to recalculate the total load on the regulator (based
|
||||
on all its consumers) and change operating mode (if necessary and permitted)
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ static int edp_regulator_enable(struct edp_ctrl *ctrl)
|
|||
goto vdda_set_fail;
|
||||
}
|
||||
|
||||
ret = regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_ON_LOAD);
|
||||
ret = regulator_set_load(ctrl->vdda_vreg, VDDA_UA_ON_LOAD);
|
||||
if (ret < 0) {
|
||||
pr_err("%s: vdda_vreg set regulator mode failed.\n", __func__);
|
||||
goto vdda_set_fail;
|
||||
|
|
@ -356,7 +356,7 @@ static int edp_regulator_enable(struct edp_ctrl *ctrl)
|
|||
lvl_enable_fail:
|
||||
regulator_disable(ctrl->vdda_vreg);
|
||||
vdda_enable_fail:
|
||||
regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
|
||||
regulator_set_load(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
|
||||
vdda_set_fail:
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -365,7 +365,7 @@ static void edp_regulator_disable(struct edp_ctrl *ctrl)
|
|||
{
|
||||
regulator_disable(ctrl->lvl_vreg);
|
||||
regulator_disable(ctrl->vdda_vreg);
|
||||
regulator_set_optimum_mode(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
|
||||
regulator_set_load(ctrl->vdda_vreg, VDDA_UA_OFF_LOAD);
|
||||
}
|
||||
|
||||
static int edp_gpio_config(struct edp_ctrl *ctrl)
|
||||
|
|
|
|||
|
|
@ -346,10 +346,10 @@ int ufs_qcom_phy_cfg_vreg(struct phy *phy,
|
|||
goto out;
|
||||
}
|
||||
uA_load = on ? vreg->max_uA : 0;
|
||||
ret = regulator_set_optimum_mode(reg, uA_load);
|
||||
ret = regulator_set_load(reg, uA_load);
|
||||
if (ret >= 0) {
|
||||
/*
|
||||
* regulator_set_optimum_mode() returns new regulator
|
||||
* regulator_set_load() returns new regulator
|
||||
* mode upon success.
|
||||
*/
|
||||
ret = 0;
|
||||
|
|
|
|||
|
|
@ -3061,7 +3061,7 @@ unsigned int regulator_get_mode(struct regulator *regulator)
|
|||
EXPORT_SYMBOL_GPL(regulator_get_mode);
|
||||
|
||||
/**
|
||||
* regulator_set_optimum_mode - set regulator optimum operating mode
|
||||
* regulator_set_load - set regulator load
|
||||
* @regulator: regulator source
|
||||
* @uA_load: load current
|
||||
*
|
||||
|
|
@ -3084,9 +3084,9 @@ EXPORT_SYMBOL_GPL(regulator_get_mode);
|
|||
* DRMS will sum the total requested load on the regulator and change
|
||||
* to the most efficient operating mode if platform constraints allow.
|
||||
*
|
||||
* Returns the new regulator mode or error.
|
||||
* On error a negative errno is returned.
|
||||
*/
|
||||
int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
|
||||
int regulator_set_load(struct regulator *regulator, int uA_load)
|
||||
{
|
||||
struct regulator_dev *rdev = regulator->rdev;
|
||||
int ret;
|
||||
|
|
@ -3098,7 +3098,7 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
|
|||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
|
||||
EXPORT_SYMBOL_GPL(regulator_set_load);
|
||||
|
||||
/**
|
||||
* regulator_allow_bypass - allow the regulator to go into bypass mode
|
||||
|
|
|
|||
|
|
@ -413,3 +413,88 @@ void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
|
|||
devm_regulator_unregister_supply_alias(dev, id[i]);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_supply_alias);
|
||||
|
||||
struct regulator_notifier_match {
|
||||
struct regulator *regulator;
|
||||
struct notifier_block *nb;
|
||||
};
|
||||
|
||||
static int devm_regulator_match_notifier(struct device *dev, void *res,
|
||||
void *data)
|
||||
{
|
||||
struct regulator_notifier_match *match = res;
|
||||
struct regulator_notifier_match *target = data;
|
||||
|
||||
return match->regulator == target->regulator && match->nb == target->nb;
|
||||
}
|
||||
|
||||
static void devm_regulator_destroy_notifier(struct device *dev, void *res)
|
||||
{
|
||||
struct regulator_notifier_match *match = res;
|
||||
|
||||
regulator_unregister_notifier(match->regulator, match->nb);
|
||||
}
|
||||
|
||||
/**
|
||||
* devm_regulator_register_notifier - Resource managed
|
||||
* regulator_register_notifier
|
||||
*
|
||||
* @regulator: regulator source
|
||||
* @nb: notifier block
|
||||
*
|
||||
* The notifier will be registers under the consumer device and be
|
||||
* automatically be unregistered when the source device is unbound.
|
||||
*/
|
||||
int devm_regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
struct regulator_notifier_match *match;
|
||||
int ret;
|
||||
|
||||
match = devres_alloc(devm_regulator_destroy_notifier,
|
||||
sizeof(struct regulator_notifier_match),
|
||||
GFP_KERNEL);
|
||||
if (!match)
|
||||
return -ENOMEM;
|
||||
|
||||
match->regulator = regulator;
|
||||
match->nb = nb;
|
||||
|
||||
ret = regulator_register_notifier(regulator, nb);
|
||||
if (ret < 0) {
|
||||
devres_free(match);
|
||||
return ret;
|
||||
}
|
||||
|
||||
devres_add(regulator->dev, match);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
|
||||
|
||||
/**
|
||||
* devm_regulator_unregister_notifier - Resource managed
|
||||
* regulator_unregister_notifier()
|
||||
*
|
||||
* @regulator: regulator source
|
||||
* @nb: notifier block
|
||||
*
|
||||
* Unregister a notifier registered with devm_regulator_register_notifier().
|
||||
* Normally this function will not need to be called and the resource
|
||||
* management code will ensure that the resource is freed.
|
||||
*/
|
||||
void devm_regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
struct regulator_notifier_match match;
|
||||
int rc;
|
||||
|
||||
match.regulator = regulator;
|
||||
match.nb = nb;
|
||||
|
||||
rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
|
||||
devm_regulator_match_notifier, &match);
|
||||
if (rc != 0)
|
||||
WARN_ON(rc);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);
|
||||
|
|
|
|||
|
|
@ -916,6 +916,9 @@ static int palmas_ldo_registration(struct palmas_pmic *pmic,
|
|||
(id == PALMAS_REG_LDO6))
|
||||
desc->enable_time = 2000;
|
||||
} else {
|
||||
if (!ddata->has_regen3 && id == PALMAS_REG_REGEN3)
|
||||
continue;
|
||||
|
||||
desc->n_voltages = 1;
|
||||
if (reg_init && reg_init->roof_floor)
|
||||
desc->ops = &palmas_ops_ext_control_extreg;
|
||||
|
|
@ -1398,6 +1401,7 @@ static struct palmas_pmic_driver_data palmas_ddata = {
|
|||
.ldo_begin = PALMAS_REG_LDO1,
|
||||
.ldo_end = PALMAS_REG_LDOUSB,
|
||||
.max_reg = PALMAS_NUM_REGS,
|
||||
.has_regen3 = true,
|
||||
.palmas_regs_info = palmas_generic_regs_info,
|
||||
.palmas_matches = palmas_matches,
|
||||
.sleep_req_info = palma_sleep_req_info,
|
||||
|
|
@ -1411,6 +1415,7 @@ static struct palmas_pmic_driver_data tps65917_ddata = {
|
|||
.ldo_begin = TPS65917_REG_LDO1,
|
||||
.ldo_end = TPS65917_REG_LDO5,
|
||||
.max_reg = TPS65917_NUM_REGS,
|
||||
.has_regen3 = true,
|
||||
.palmas_regs_info = tps65917_regs_info,
|
||||
.palmas_matches = tps65917_matches,
|
||||
.sleep_req_info = tps65917_sleep_req_info,
|
||||
|
|
@ -1505,7 +1510,7 @@ static void palmas_dt_to_pdata(struct device *dev,
|
|||
pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
|
||||
}
|
||||
|
||||
static struct of_device_id of_palmas_match_tbl[] = {
|
||||
static const struct of_device_id of_palmas_match_tbl[] = {
|
||||
{
|
||||
.compatible = "ti,palmas-pmic",
|
||||
.data = &palmas_ddata,
|
||||
|
|
@ -1572,9 +1577,11 @@ static int palmas_regulators_probe(struct platform_device *pdev)
|
|||
if (!pmic)
|
||||
return -ENOMEM;
|
||||
|
||||
if (of_device_is_compatible(node, "ti,tps659038-pmic"))
|
||||
if (of_device_is_compatible(node, "ti,tps659038-pmic")) {
|
||||
palmas_generic_regs_info[PALMAS_REG_REGEN2].ctrl_addr =
|
||||
TPS659038_REGEN2_CTRL;
|
||||
palmas_ddata.has_regen3 = false;
|
||||
}
|
||||
|
||||
pmic->dev = &pdev->dev;
|
||||
pmic->palmas = palmas;
|
||||
|
|
|
|||
|
|
@ -607,31 +607,6 @@ static const struct qcom_rpm_reg smb208_smps = {
|
|||
.supports_force_mode_bypass = false,
|
||||
};
|
||||
|
||||
static const struct of_device_id rpm_of_match[] = {
|
||||
{ .compatible = "qcom,rpm-pm8058-pldo", .data = &pm8058_pldo },
|
||||
{ .compatible = "qcom,rpm-pm8058-nldo", .data = &pm8058_nldo },
|
||||
{ .compatible = "qcom,rpm-pm8058-smps", .data = &pm8058_smps },
|
||||
{ .compatible = "qcom,rpm-pm8058-ncp", .data = &pm8058_ncp },
|
||||
{ .compatible = "qcom,rpm-pm8058-switch", .data = &pm8058_switch },
|
||||
|
||||
{ .compatible = "qcom,rpm-pm8901-pldo", .data = &pm8901_pldo },
|
||||
{ .compatible = "qcom,rpm-pm8901-nldo", .data = &pm8901_nldo },
|
||||
{ .compatible = "qcom,rpm-pm8901-ftsmps", .data = &pm8901_ftsmps },
|
||||
{ .compatible = "qcom,rpm-pm8901-switch", .data = &pm8901_switch },
|
||||
|
||||
{ .compatible = "qcom,rpm-pm8921-pldo", .data = &pm8921_pldo },
|
||||
{ .compatible = "qcom,rpm-pm8921-nldo", .data = &pm8921_nldo },
|
||||
{ .compatible = "qcom,rpm-pm8921-nldo1200", .data = &pm8921_nldo1200 },
|
||||
{ .compatible = "qcom,rpm-pm8921-smps", .data = &pm8921_smps },
|
||||
{ .compatible = "qcom,rpm-pm8921-ftsmps", .data = &pm8921_ftsmps },
|
||||
{ .compatible = "qcom,rpm-pm8921-ncp", .data = &pm8921_ncp },
|
||||
{ .compatible = "qcom,rpm-pm8921-switch", .data = &pm8921_switch },
|
||||
|
||||
{ .compatible = "qcom,rpm-smb208", .data = &smb208_smps },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, rpm_of_match);
|
||||
|
||||
static int rpm_reg_set(struct qcom_rpm_reg *vreg,
|
||||
const struct request_member *req,
|
||||
const int value)
|
||||
|
|
@ -645,7 +620,9 @@ static int rpm_reg_set(struct qcom_rpm_reg *vreg,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int rpm_reg_of_parse_freq(struct device *dev, struct qcom_rpm_reg *vreg)
|
||||
static int rpm_reg_of_parse_freq(struct device *dev,
|
||||
struct device_node *node,
|
||||
struct qcom_rpm_reg *vreg)
|
||||
{
|
||||
static const int freq_table[] = {
|
||||
19200000, 9600000, 6400000, 4800000, 3840000, 3200000, 2740000,
|
||||
|
|
@ -659,7 +636,7 @@ static int rpm_reg_of_parse_freq(struct device *dev, struct qcom_rpm_reg *vreg)
|
|||
int i;
|
||||
|
||||
key = "qcom,switch-mode-frequency";
|
||||
ret = of_property_read_u32(dev->of_node, key, &freq);
|
||||
ret = of_property_read_u32(node, key, &freq);
|
||||
if (ret) {
|
||||
dev_err(dev, "regulator requires %s property\n", key);
|
||||
return -EINVAL;
|
||||
|
|
@ -676,88 +653,40 @@ static int rpm_reg_of_parse_freq(struct device *dev, struct qcom_rpm_reg *vreg)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int rpm_reg_probe(struct platform_device *pdev)
|
||||
static int rpm_reg_of_parse(struct device_node *node,
|
||||
const struct regulator_desc *desc,
|
||||
struct regulator_config *config)
|
||||
{
|
||||
struct regulator_init_data *initdata;
|
||||
const struct qcom_rpm_reg *template;
|
||||
const struct of_device_id *match;
|
||||
struct regulator_config config = { };
|
||||
struct regulator_dev *rdev;
|
||||
struct qcom_rpm_reg *vreg;
|
||||
struct qcom_rpm_reg *vreg = config->driver_data;
|
||||
struct device *dev = config->dev;
|
||||
const char *key;
|
||||
u32 force_mode;
|
||||
bool pwm;
|
||||
u32 val;
|
||||
int ret;
|
||||
|
||||
match = of_match_device(rpm_of_match, &pdev->dev);
|
||||
template = match->data;
|
||||
|
||||
vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
|
||||
if (!vreg) {
|
||||
dev_err(&pdev->dev, "failed to allocate vreg\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
memcpy(vreg, template, sizeof(*vreg));
|
||||
mutex_init(&vreg->lock);
|
||||
vreg->dev = &pdev->dev;
|
||||
vreg->desc.id = -1;
|
||||
vreg->desc.owner = THIS_MODULE;
|
||||
vreg->desc.type = REGULATOR_VOLTAGE;
|
||||
vreg->desc.name = pdev->dev.of_node->name;
|
||||
vreg->desc.supply_name = "vin";
|
||||
|
||||
vreg->rpm = dev_get_drvdata(pdev->dev.parent);
|
||||
if (!vreg->rpm) {
|
||||
dev_err(&pdev->dev, "unable to retrieve handle to rpm\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
|
||||
&vreg->desc);
|
||||
if (!initdata)
|
||||
return -EINVAL;
|
||||
|
||||
key = "reg";
|
||||
ret = of_property_read_u32(pdev->dev.of_node, key, &val);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "failed to read %s\n", key);
|
||||
return ret;
|
||||
}
|
||||
vreg->resource = val;
|
||||
|
||||
if ((vreg->parts->uV.mask || vreg->parts->mV.mask) &&
|
||||
(!initdata->constraints.min_uV || !initdata->constraints.max_uV)) {
|
||||
dev_err(&pdev->dev, "no voltage specified for regulator\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Regulators with ia property suppports drms */
|
||||
if (vreg->parts->ia.mask)
|
||||
initdata->constraints.valid_ops_mask |= REGULATOR_CHANGE_DRMS;
|
||||
|
||||
key = "bias-pull-down";
|
||||
if (of_property_read_bool(pdev->dev.of_node, key)) {
|
||||
if (of_property_read_bool(node, key)) {
|
||||
ret = rpm_reg_set(vreg, &vreg->parts->pd, 1);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "%s is invalid", key);
|
||||
dev_err(dev, "%s is invalid", key);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (vreg->parts->freq.mask) {
|
||||
ret = rpm_reg_of_parse_freq(&pdev->dev, vreg);
|
||||
ret = rpm_reg_of_parse_freq(dev, node, vreg);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (vreg->parts->pm.mask) {
|
||||
key = "qcom,power-mode-hysteretic";
|
||||
pwm = !of_property_read_bool(pdev->dev.of_node, key);
|
||||
pwm = !of_property_read_bool(node, key);
|
||||
|
||||
ret = rpm_reg_set(vreg, &vreg->parts->pm, pwm);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "failed to set power mode\n");
|
||||
dev_err(dev, "failed to set power mode\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
|
@ -766,11 +695,11 @@ static int rpm_reg_probe(struct platform_device *pdev)
|
|||
force_mode = -1;
|
||||
|
||||
key = "qcom,force-mode";
|
||||
ret = of_property_read_u32(pdev->dev.of_node, key, &val);
|
||||
ret = of_property_read_u32(node, key, &val);
|
||||
if (ret == -EINVAL) {
|
||||
val = QCOM_RPM_FORCE_MODE_NONE;
|
||||
} else if (ret < 0) {
|
||||
dev_err(&pdev->dev, "failed to read %s\n", key);
|
||||
dev_err(dev, "failed to read %s\n", key);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -805,25 +734,192 @@ static int rpm_reg_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
if (force_mode == -1) {
|
||||
dev_err(&pdev->dev, "invalid force mode\n");
|
||||
dev_err(dev, "invalid force mode\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = rpm_reg_set(vreg, &vreg->parts->fm, force_mode);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "failed to set force mode\n");
|
||||
dev_err(dev, "failed to set force mode\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
config.dev = &pdev->dev;
|
||||
config.init_data = initdata;
|
||||
config.driver_data = vreg;
|
||||
config.of_node = pdev->dev.of_node;
|
||||
rdev = devm_regulator_register(&pdev->dev, &vreg->desc, &config);
|
||||
if (IS_ERR(rdev)) {
|
||||
dev_err(&pdev->dev, "can't register regulator\n");
|
||||
return PTR_ERR(rdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct rpm_regulator_data {
|
||||
const char *name;
|
||||
int resource;
|
||||
const struct qcom_rpm_reg *template;
|
||||
const char *supply;
|
||||
};
|
||||
|
||||
static const struct rpm_regulator_data rpm_pm8058_regulators[] = {
|
||||
{ "l0", QCOM_RPM_PM8058_LDO0, &pm8058_nldo, "vdd_l0_l1_lvs" },
|
||||
{ "l1", QCOM_RPM_PM8058_LDO1, &pm8058_nldo, "vdd_l0_l1_lvs" },
|
||||
{ "l2", QCOM_RPM_PM8058_LDO2, &pm8058_pldo, "vdd_l2_l11_l12" },
|
||||
{ "l3", QCOM_RPM_PM8058_LDO3, &pm8058_pldo, "vdd_l3_l4_l5" },
|
||||
{ "l4", QCOM_RPM_PM8058_LDO4, &pm8058_pldo, "vdd_l3_l4_l5" },
|
||||
{ "l5", QCOM_RPM_PM8058_LDO5, &pm8058_pldo, "vdd_l3_l4_l5" },
|
||||
{ "l6", QCOM_RPM_PM8058_LDO6, &pm8058_pldo, "vdd_l6_l7" },
|
||||
{ "l7", QCOM_RPM_PM8058_LDO7, &pm8058_pldo, "vdd_l6_l7" },
|
||||
{ "l8", QCOM_RPM_PM8058_LDO8, &pm8058_pldo, "vdd_l8" },
|
||||
{ "l9", QCOM_RPM_PM8058_LDO9, &pm8058_pldo, "vdd_l9" },
|
||||
{ "l10", QCOM_RPM_PM8058_LDO10, &pm8058_pldo, "vdd_l10" },
|
||||
{ "l11", QCOM_RPM_PM8058_LDO11, &pm8058_pldo, "vdd_l2_l11_l12" },
|
||||
{ "l12", QCOM_RPM_PM8058_LDO12, &pm8058_pldo, "vdd_l2_l11_l12" },
|
||||
{ "l13", QCOM_RPM_PM8058_LDO13, &pm8058_pldo, "vdd_l13_l16" },
|
||||
{ "l14", QCOM_RPM_PM8058_LDO14, &pm8058_pldo, "vdd_l14_l15" },
|
||||
{ "l15", QCOM_RPM_PM8058_LDO15, &pm8058_pldo, "vdd_l14_l15" },
|
||||
{ "l16", QCOM_RPM_PM8058_LDO16, &pm8058_pldo, "vdd_l13_l16" },
|
||||
{ "l17", QCOM_RPM_PM8058_LDO17, &pm8058_pldo, "vdd_l17_l18" },
|
||||
{ "l18", QCOM_RPM_PM8058_LDO18, &pm8058_pldo, "vdd_l17_l18" },
|
||||
{ "l19", QCOM_RPM_PM8058_LDO19, &pm8058_pldo, "vdd_l19_l20" },
|
||||
{ "l20", QCOM_RPM_PM8058_LDO20, &pm8058_pldo, "vdd_l19_l20" },
|
||||
{ "l21", QCOM_RPM_PM8058_LDO21, &pm8058_nldo, "vdd_l21" },
|
||||
{ "l22", QCOM_RPM_PM8058_LDO22, &pm8058_nldo, "vdd_l22" },
|
||||
{ "l23", QCOM_RPM_PM8058_LDO23, &pm8058_nldo, "vdd_l23_l24_l25" },
|
||||
{ "l24", QCOM_RPM_PM8058_LDO24, &pm8058_nldo, "vdd_l23_l24_l25" },
|
||||
{ "l25", QCOM_RPM_PM8058_LDO25, &pm8058_nldo, "vdd_l23_l24_l25" },
|
||||
|
||||
{ "s0", QCOM_RPM_PM8058_SMPS0, &pm8058_smps, "vdd_s0" },
|
||||
{ "s1", QCOM_RPM_PM8058_SMPS1, &pm8058_smps, "vdd_s1" },
|
||||
{ "s2", QCOM_RPM_PM8058_SMPS2, &pm8058_smps, "vdd_s2" },
|
||||
{ "s3", QCOM_RPM_PM8058_SMPS3, &pm8058_smps, "vdd_s3" },
|
||||
{ "s4", QCOM_RPM_PM8058_SMPS4, &pm8058_smps, "vdd_s4" },
|
||||
|
||||
{ "lvs0", QCOM_RPM_PM8058_LVS0, &pm8058_switch, "vdd_l0_l1_lvs" },
|
||||
{ "lvs1", QCOM_RPM_PM8058_LVS1, &pm8058_switch, "vdd_l0_l1_lvs" },
|
||||
|
||||
{ "ncp", QCOM_RPM_PM8058_NCP, &pm8058_ncp, "vdd_ncp" },
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct rpm_regulator_data rpm_pm8901_regulators[] = {
|
||||
{ "l0", QCOM_RPM_PM8901_LDO0, &pm8901_nldo, "vdd_l0" },
|
||||
{ "l1", QCOM_RPM_PM8901_LDO1, &pm8901_pldo, "vdd_l1" },
|
||||
{ "l2", QCOM_RPM_PM8901_LDO2, &pm8901_pldo, "vdd_l2" },
|
||||
{ "l3", QCOM_RPM_PM8901_LDO3, &pm8901_pldo, "vdd_l3" },
|
||||
{ "l4", QCOM_RPM_PM8901_LDO4, &pm8901_pldo, "vdd_l4" },
|
||||
{ "l5", QCOM_RPM_PM8901_LDO5, &pm8901_pldo, "vdd_l5" },
|
||||
{ "l6", QCOM_RPM_PM8901_LDO6, &pm8901_pldo, "vdd_l6" },
|
||||
|
||||
{ "s0", QCOM_RPM_PM8901_SMPS0, &pm8901_ftsmps, "vdd_s0" },
|
||||
{ "s1", QCOM_RPM_PM8901_SMPS1, &pm8901_ftsmps, "vdd_s1" },
|
||||
{ "s2", QCOM_RPM_PM8901_SMPS2, &pm8901_ftsmps, "vdd_s2" },
|
||||
{ "s3", QCOM_RPM_PM8901_SMPS3, &pm8901_ftsmps, "vdd_s3" },
|
||||
{ "s4", QCOM_RPM_PM8901_SMPS4, &pm8901_ftsmps, "vdd_s4" },
|
||||
|
||||
{ "lvs0", QCOM_RPM_PM8901_LVS0, &pm8901_switch, "lvs0_in" },
|
||||
{ "lvs1", QCOM_RPM_PM8901_LVS1, &pm8901_switch, "lvs1_in" },
|
||||
{ "lvs2", QCOM_RPM_PM8901_LVS2, &pm8901_switch, "lvs2_in" },
|
||||
{ "lvs3", QCOM_RPM_PM8901_LVS3, &pm8901_switch, "lvs3_in" },
|
||||
|
||||
{ "mvs", QCOM_RPM_PM8901_MVS, &pm8901_switch, "mvs_in" },
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct rpm_regulator_data rpm_pm8921_regulators[] = {
|
||||
{ "s1", QCOM_RPM_PM8921_SMPS1, &pm8921_smps, "vdd_s1" },
|
||||
{ "s2", QCOM_RPM_PM8921_SMPS2, &pm8921_smps, "vdd_s2" },
|
||||
{ "s3", QCOM_RPM_PM8921_SMPS3, &pm8921_smps },
|
||||
{ "s4", QCOM_RPM_PM8921_SMPS4, &pm8921_smps, "vdd_s4" },
|
||||
{ "s7", QCOM_RPM_PM8921_SMPS7, &pm8921_smps, "vdd_s7" },
|
||||
{ "s8", QCOM_RPM_PM8921_SMPS8, &pm8921_smps, "vdd_s8" },
|
||||
|
||||
{ "l1", QCOM_RPM_PM8921_LDO1, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
|
||||
{ "l2", QCOM_RPM_PM8921_LDO2, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
|
||||
{ "l3", QCOM_RPM_PM8921_LDO3, &pm8921_pldo, "vdd_l3_l15_l17" },
|
||||
{ "l4", QCOM_RPM_PM8921_LDO4, &pm8921_pldo, "vdd_l4_l14" },
|
||||
{ "l5", QCOM_RPM_PM8921_LDO5, &pm8921_pldo, "vdd_l5_l8_l16" },
|
||||
{ "l6", QCOM_RPM_PM8921_LDO6, &pm8921_pldo, "vdd_l6_l7" },
|
||||
{ "l7", QCOM_RPM_PM8921_LDO7, &pm8921_pldo, "vdd_l6_l7" },
|
||||
{ "l8", QCOM_RPM_PM8921_LDO8, &pm8921_pldo, "vdd_l5_l8_l16" },
|
||||
{ "l9", QCOM_RPM_PM8921_LDO9, &pm8921_pldo, "vdd_l9_l11" },
|
||||
{ "l10", QCOM_RPM_PM8921_LDO10, &pm8921_pldo, "vdd_l10_l22" },
|
||||
{ "l11", QCOM_RPM_PM8921_LDO11, &pm8921_pldo, "vdd_l9_l11" },
|
||||
{ "l12", QCOM_RPM_PM8921_LDO12, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
|
||||
{ "l14", QCOM_RPM_PM8921_LDO14, &pm8921_pldo, "vdd_l4_l14" },
|
||||
{ "l15", QCOM_RPM_PM8921_LDO15, &pm8921_pldo, "vdd_l3_l15_l17" },
|
||||
{ "l16", QCOM_RPM_PM8921_LDO16, &pm8921_pldo, "vdd_l5_l8_l16" },
|
||||
{ "l17", QCOM_RPM_PM8921_LDO17, &pm8921_pldo, "vdd_l3_l15_l17" },
|
||||
{ "l18", QCOM_RPM_PM8921_LDO18, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
|
||||
{ "l21", QCOM_RPM_PM8921_LDO21, &pm8921_pldo, "vdd_l21_l23_l29" },
|
||||
{ "l22", QCOM_RPM_PM8921_LDO22, &pm8921_pldo, "vdd_l10_l22" },
|
||||
{ "l23", QCOM_RPM_PM8921_LDO23, &pm8921_pldo, "vdd_l21_l23_l29" },
|
||||
{ "l24", QCOM_RPM_PM8921_LDO24, &pm8921_nldo1200, "vdd_l24" },
|
||||
{ "l25", QCOM_RPM_PM8921_LDO25, &pm8921_nldo1200, "vdd_l25" },
|
||||
{ "l26", QCOM_RPM_PM8921_LDO26, &pm8921_nldo1200, "vdd_l26" },
|
||||
{ "l27", QCOM_RPM_PM8921_LDO27, &pm8921_nldo1200, "vdd_l27" },
|
||||
{ "l28", QCOM_RPM_PM8921_LDO28, &pm8921_nldo1200, "vdd_l28" },
|
||||
{ "l29", QCOM_RPM_PM8921_LDO29, &pm8921_pldo, "vdd_l21_l23_l29" },
|
||||
|
||||
{ "lvs1", QCOM_RPM_PM8921_LVS1, &pm8921_switch, "vin_lvs1_3_6" },
|
||||
{ "lvs2", QCOM_RPM_PM8921_LVS2, &pm8921_switch, "vin_lvs2" },
|
||||
{ "lvs3", QCOM_RPM_PM8921_LVS3, &pm8921_switch, "vin_lvs1_3_6" },
|
||||
{ "lvs4", QCOM_RPM_PM8921_LVS4, &pm8921_switch, "vin_lvs4_5_7" },
|
||||
{ "lvs5", QCOM_RPM_PM8921_LVS5, &pm8921_switch, "vin_lvs4_5_7" },
|
||||
{ "lvs6", QCOM_RPM_PM8921_LVS6, &pm8921_switch, "vin_lvs1_3_6" },
|
||||
{ "lvs7", QCOM_RPM_PM8921_LVS7, &pm8921_switch, "vin_lvs4_5_7" },
|
||||
|
||||
{ "usb-switch", QCOM_RPM_USB_OTG_SWITCH, &pm8921_switch, "vin_5vs" },
|
||||
{ "hdmi-switch", QCOM_RPM_HDMI_SWITCH, &pm8921_switch, "vin_5vs" },
|
||||
{ "ncp", QCOM_RPM_PM8921_NCP, &pm8921_ncp, "vdd_ncp" },
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct of_device_id rpm_of_match[] = {
|
||||
{ .compatible = "qcom,rpm-pm8058-regulators", .data = &rpm_pm8058_regulators },
|
||||
{ .compatible = "qcom,rpm-pm8901-regulators", .data = &rpm_pm8901_regulators },
|
||||
{ .compatible = "qcom,rpm-pm8921-regulators", .data = &rpm_pm8921_regulators },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, rpm_of_match);
|
||||
|
||||
static int rpm_reg_probe(struct platform_device *pdev)
|
||||
{
|
||||
const struct rpm_regulator_data *reg;
|
||||
const struct of_device_id *match;
|
||||
struct regulator_config config = { };
|
||||
struct regulator_dev *rdev;
|
||||
struct qcom_rpm_reg *vreg;
|
||||
struct qcom_rpm *rpm;
|
||||
|
||||
rpm = dev_get_drvdata(pdev->dev.parent);
|
||||
if (!rpm) {
|
||||
dev_err(&pdev->dev, "unable to retrieve handle to rpm\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
match = of_match_device(rpm_of_match, &pdev->dev);
|
||||
for (reg = match->data; reg->name; reg++) {
|
||||
vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
|
||||
if (!vreg)
|
||||
return -ENOMEM;
|
||||
|
||||
memcpy(vreg, reg->template, sizeof(*vreg));
|
||||
mutex_init(&vreg->lock);
|
||||
|
||||
vreg->dev = &pdev->dev;
|
||||
vreg->resource = reg->resource;
|
||||
vreg->rpm = rpm;
|
||||
|
||||
vreg->desc.id = -1;
|
||||
vreg->desc.owner = THIS_MODULE;
|
||||
vreg->desc.type = REGULATOR_VOLTAGE;
|
||||
vreg->desc.name = reg->name;
|
||||
vreg->desc.supply_name = reg->supply;
|
||||
vreg->desc.of_match = reg->name;
|
||||
vreg->desc.of_parse_cb = rpm_reg_of_parse;
|
||||
|
||||
config.dev = &pdev->dev;
|
||||
config.driver_data = vreg;
|
||||
rdev = devm_regulator_register(&pdev->dev, &vreg->desc, &config);
|
||||
if (IS_ERR(rdev)) {
|
||||
dev_err(&pdev->dev, "failed to register %s\n", reg->name);
|
||||
return PTR_ERR(rdev);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
|
|||
{
|
||||
struct stw481x *stw481x = dev_get_platdata(&pdev->dev);
|
||||
struct regulator_config config = { };
|
||||
struct regulator_dev *rdev;
|
||||
int ret;
|
||||
|
||||
/* First disable the external VMMC if it's active */
|
||||
|
|
@ -75,12 +76,11 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
|
|||
pdev->dev.of_node,
|
||||
&vmmc_regulator);
|
||||
|
||||
stw481x->vmmc_regulator = devm_regulator_register(&pdev->dev,
|
||||
&vmmc_regulator, &config);
|
||||
if (IS_ERR(stw481x->vmmc_regulator)) {
|
||||
rdev = devm_regulator_register(&pdev->dev, &vmmc_regulator, &config);
|
||||
if (IS_ERR(rdev)) {
|
||||
dev_err(&pdev->dev,
|
||||
"error initializing STw481x VMMC regulator\n");
|
||||
return PTR_ERR(stw481x->vmmc_regulator);
|
||||
return PTR_ERR(rdev);
|
||||
}
|
||||
|
||||
dev_info(&pdev->dev, "initialized STw481x VMMC regulator\n");
|
||||
|
|
|
|||
|
|
@ -4225,22 +4225,15 @@ static struct scsi_host_template ufshcd_driver_template = {
|
|||
static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
|
||||
int ua)
|
||||
{
|
||||
int ret = 0;
|
||||
struct regulator *reg = vreg->reg;
|
||||
const char *name = vreg->name;
|
||||
int ret;
|
||||
|
||||
BUG_ON(!vreg);
|
||||
if (!vreg)
|
||||
return 0;
|
||||
|
||||
ret = regulator_set_optimum_mode(reg, ua);
|
||||
if (ret >= 0) {
|
||||
/*
|
||||
* regulator_set_optimum_mode() returns new regulator
|
||||
* mode upon success.
|
||||
*/
|
||||
ret = 0;
|
||||
} else {
|
||||
dev_err(dev, "%s: %s set optimum mode(ua=%d) failed, err=%d\n",
|
||||
__func__, name, ua, ret);
|
||||
ret = regulator_set_load(vreg->reg, ua);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "%s: %s set load (ua=%d) failed, err=%d\n",
|
||||
__func__, vreg->name, ua, ret);
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
@ -4249,18 +4242,12 @@ static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
|
|||
static inline int ufshcd_config_vreg_lpm(struct ufs_hba *hba,
|
||||
struct ufs_vreg *vreg)
|
||||
{
|
||||
if (!vreg)
|
||||
return 0;
|
||||
|
||||
return ufshcd_config_vreg_load(hba->dev, vreg, UFS_VREG_LPM_LOAD_UA);
|
||||
}
|
||||
|
||||
static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
|
||||
struct ufs_vreg *vreg)
|
||||
{
|
||||
if (!vreg)
|
||||
return 0;
|
||||
|
||||
return ufshcd_config_vreg_load(hba->dev, vreg, vreg->max_uA);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -277,7 +277,7 @@ static void ab8500_usb_regulator_enable(struct ab8500_usb *ab)
|
|||
dev_err(ab->dev, "Failed to set the Vintcore to 1.3V, ret=%d\n",
|
||||
ret);
|
||||
|
||||
ret = regulator_set_optimum_mode(ab->v_ulpi, 28000);
|
||||
ret = regulator_set_load(ab->v_ulpi, 28000);
|
||||
if (ret < 0)
|
||||
dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
|
||||
ret);
|
||||
|
|
@ -317,7 +317,7 @@ static void ab8500_usb_regulator_disable(struct ab8500_usb *ab)
|
|||
ab->saved_v_ulpi, ret);
|
||||
}
|
||||
|
||||
ret = regulator_set_optimum_mode(ab->v_ulpi, 0);
|
||||
ret = regulator_set_load(ab->v_ulpi, 0);
|
||||
if (ret < 0)
|
||||
dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
|
||||
ret);
|
||||
|
|
|
|||
|
|
@ -142,27 +142,22 @@ static int msm_hsusb_ldo_set_mode(struct msm_otg *motg, int on)
|
|||
int ret = 0;
|
||||
|
||||
if (on) {
|
||||
ret = regulator_set_optimum_mode(motg->v1p8,
|
||||
USB_PHY_1P8_HPM_LOAD);
|
||||
ret = regulator_set_load(motg->v1p8, USB_PHY_1P8_HPM_LOAD);
|
||||
if (ret < 0) {
|
||||
pr_err("Could not set HPM for v1p8\n");
|
||||
return ret;
|
||||
}
|
||||
ret = regulator_set_optimum_mode(motg->v3p3,
|
||||
USB_PHY_3P3_HPM_LOAD);
|
||||
ret = regulator_set_load(motg->v3p3, USB_PHY_3P3_HPM_LOAD);
|
||||
if (ret < 0) {
|
||||
pr_err("Could not set HPM for v3p3\n");
|
||||
regulator_set_optimum_mode(motg->v1p8,
|
||||
USB_PHY_1P8_LPM_LOAD);
|
||||
regulator_set_load(motg->v1p8, USB_PHY_1P8_LPM_LOAD);
|
||||
return ret;
|
||||
}
|
||||
} else {
|
||||
ret = regulator_set_optimum_mode(motg->v1p8,
|
||||
USB_PHY_1P8_LPM_LOAD);
|
||||
ret = regulator_set_load(motg->v1p8, USB_PHY_1P8_LPM_LOAD);
|
||||
if (ret < 0)
|
||||
pr_err("Could not set LPM for v1p8\n");
|
||||
ret = regulator_set_optimum_mode(motg->v3p3,
|
||||
USB_PHY_3P3_LPM_LOAD);
|
||||
ret = regulator_set_load(motg->v3p3, USB_PHY_3P3_LPM_LOAD);
|
||||
if (ret < 0)
|
||||
pr_err("Could not set LPM for v3p3\n");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -117,6 +117,7 @@ struct palmas_pmic_driver_data {
|
|||
int ldo_begin;
|
||||
int ldo_end;
|
||||
int max_reg;
|
||||
bool has_regen3;
|
||||
struct palmas_regs_info *palmas_regs_info;
|
||||
struct of_regulator_match *palmas_matches;
|
||||
struct palmas_sleep_requestor_info *sleep_req_info;
|
||||
|
|
|
|||
|
|
@ -41,15 +41,11 @@
|
|||
|
||||
/**
|
||||
* struct stw481x - state holder for the Stw481x drivers
|
||||
* @mutex: mutex to serialize I2C accesses
|
||||
* @i2c_client: corresponding I2C client
|
||||
* @regulator: regulator device for regulator children
|
||||
* @map: regmap handle to access device registers
|
||||
*/
|
||||
struct stw481x {
|
||||
struct mutex lock;
|
||||
struct i2c_client *client;
|
||||
struct regulator_dev *vmmc_regulator;
|
||||
struct regmap *map;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -238,7 +238,7 @@ int regulator_get_current_limit(struct regulator *regulator);
|
|||
|
||||
int regulator_set_mode(struct regulator *regulator, unsigned int mode);
|
||||
unsigned int regulator_get_mode(struct regulator *regulator);
|
||||
int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
|
||||
int regulator_set_load(struct regulator *regulator, int load_uA);
|
||||
|
||||
int regulator_allow_bypass(struct regulator *regulator, bool allow);
|
||||
|
||||
|
|
@ -252,8 +252,12 @@ int regulator_list_hardware_vsel(struct regulator *regulator,
|
|||
/* regulator notifier block */
|
||||
int regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
int devm_regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
int regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
void devm_regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb);
|
||||
|
||||
/* driver data - core doesn't touch */
|
||||
void *regulator_get_drvdata(struct regulator *regulator);
|
||||
|
|
@ -479,8 +483,7 @@ static inline unsigned int regulator_get_mode(struct regulator *regulator)
|
|||
return REGULATOR_MODE_NORMAL;
|
||||
}
|
||||
|
||||
static inline int regulator_set_optimum_mode(struct regulator *regulator,
|
||||
int load_uA)
|
||||
static inline int regulator_set_load(struct regulator *regulator, int load_uA)
|
||||
{
|
||||
return REGULATOR_MODE_NORMAL;
|
||||
}
|
||||
|
|
@ -515,12 +518,24 @@ static inline int regulator_register_notifier(struct regulator *regulator,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static inline int devm_regulator_register_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int devm_regulator_unregister_notifier(struct regulator *regulator,
|
||||
struct notifier_block *nb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void *regulator_get_drvdata(struct regulator *regulator)
|
||||
{
|
||||
return NULL;
|
||||
|
|
|
|||
Loading…
Reference in New Issue