mirror of https://gitee.com/openkylin/linux.git
519 lines
15 KiB
C
519 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
//
|
|
// Copyright (C) 2018 BayLibre SAS
|
|
// Author: Bartosz Golaszewski <bgolaszewski@baylibre.com>
|
|
//
|
|
// Regulator driver for MAXIM 77650/77651 charger/power-supply.
|
|
|
|
#include <linux/of.h>
|
|
#include <linux/mfd/max77650.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/regmap.h>
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#define MAX77650_REGULATOR_EN_CTRL_MASK GENMASK(3, 0)
|
|
#define MAX77650_REGULATOR_EN_CTRL_BITS(_reg) \
|
|
((_reg) & MAX77650_REGULATOR_EN_CTRL_MASK)
|
|
#define MAX77650_REGULATOR_ENABLED GENMASK(2, 1)
|
|
#define MAX77650_REGULATOR_DISABLED BIT(2)
|
|
|
|
#define MAX77650_REGULATOR_V_LDO_MASK GENMASK(6, 0)
|
|
#define MAX77650_REGULATOR_V_SBB_MASK GENMASK(5, 0)
|
|
|
|
#define MAX77650_REGULATOR_AD_MASK BIT(3)
|
|
#define MAX77650_REGULATOR_AD_DISABLED 0x00
|
|
#define MAX77650_REGULATOR_AD_ENABLED BIT(3)
|
|
|
|
#define MAX77650_REGULATOR_CURR_LIM_MASK GENMASK(7, 6)
|
|
#define MAX77650_REGULATOR_CURR_LIM_BITS(_reg) \
|
|
(((_reg) & MAX77650_REGULATOR_CURR_LIM_MASK) >> 6)
|
|
#define MAX77650_REGULATOR_CURR_LIM_SHIFT(_val) ((_val) << 6)
|
|
|
|
enum {
|
|
MAX77650_REGULATOR_ID_LDO = 0,
|
|
MAX77650_REGULATOR_ID_SBB0,
|
|
MAX77650_REGULATOR_ID_SBB1,
|
|
MAX77650_REGULATOR_ID_SBB2,
|
|
MAX77650_REGULATOR_NUM_REGULATORS,
|
|
};
|
|
|
|
struct max77650_regulator_desc {
|
|
struct regulator_desc desc;
|
|
unsigned int regA;
|
|
unsigned int regB;
|
|
};
|
|
|
|
static const u32 max77651_sbb1_regulator_volt_table[] = {
|
|
2400000, 3200000, 4000000, 4800000,
|
|
2450000, 3250000, 4050000, 4850000,
|
|
2500000, 3300000, 4100000, 4900000,
|
|
2550000, 3350000, 4150000, 4950000,
|
|
2600000, 3400000, 4200000, 5000000,
|
|
2650000, 3450000, 4250000, 5050000,
|
|
2700000, 3500000, 4300000, 5100000,
|
|
2750000, 3550000, 4350000, 5150000,
|
|
2800000, 3600000, 4400000, 5200000,
|
|
2850000, 3650000, 4450000, 5250000,
|
|
2900000, 3700000, 4500000, 0,
|
|
2950000, 3750000, 4550000, 0,
|
|
3000000, 3800000, 4600000, 0,
|
|
3050000, 3850000, 4650000, 0,
|
|
3100000, 3900000, 4700000, 0,
|
|
3150000, 3950000, 4750000, 0,
|
|
};
|
|
|
|
#define MAX77651_REGULATOR_SBB1_SEL_DEC(_val) \
|
|
(((_val & 0x3c) >> 2) | ((_val & 0x03) << 4))
|
|
#define MAX77651_REGULATOR_SBB1_SEL_ENC(_val) \
|
|
(((_val & 0x30) >> 4) | ((_val & 0x0f) << 2))
|
|
|
|
#define MAX77650_REGULATOR_SBB1_SEL_DECR(_val) \
|
|
do { \
|
|
_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \
|
|
_val--; \
|
|
_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \
|
|
} while (0)
|
|
|
|
#define MAX77650_REGULATOR_SBB1_SEL_INCR(_val) \
|
|
do { \
|
|
_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \
|
|
_val++; \
|
|
_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \
|
|
} while (0)
|
|
|
|
static const int max77650_current_limit_table[] = {
|
|
1000000, 866000, 707000, 500000,
|
|
};
|
|
|
|
static int max77650_regulator_is_enabled(struct regulator_dev *rdev)
|
|
{
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regmap *map;
|
|
int val, rv, en;
|
|
|
|
rdesc = rdev_get_drvdata(rdev);
|
|
map = rdev_get_regmap(rdev);
|
|
|
|
rv = regmap_read(map, rdesc->regB, &val);
|
|
if (rv)
|
|
return rv;
|
|
|
|
en = MAX77650_REGULATOR_EN_CTRL_BITS(val);
|
|
|
|
return en != MAX77650_REGULATOR_DISABLED;
|
|
}
|
|
|
|
static int max77650_regulator_enable(struct regulator_dev *rdev)
|
|
{
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regmap *map;
|
|
|
|
rdesc = rdev_get_drvdata(rdev);
|
|
map = rdev_get_regmap(rdev);
|
|
|
|
return regmap_update_bits(map, rdesc->regB,
|
|
MAX77650_REGULATOR_EN_CTRL_MASK,
|
|
MAX77650_REGULATOR_ENABLED);
|
|
}
|
|
|
|
static int max77650_regulator_disable(struct regulator_dev *rdev)
|
|
{
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regmap *map;
|
|
|
|
rdesc = rdev_get_drvdata(rdev);
|
|
map = rdev_get_regmap(rdev);
|
|
|
|
return regmap_update_bits(map, rdesc->regB,
|
|
MAX77650_REGULATOR_EN_CTRL_MASK,
|
|
MAX77650_REGULATOR_DISABLED);
|
|
}
|
|
|
|
static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev,
|
|
unsigned int sel)
|
|
{
|
|
int rv = 0, curr, diff;
|
|
bool ascending;
|
|
|
|
/*
|
|
* If the regulator is disabled, we can program the desired
|
|
* voltage right away.
|
|
*/
|
|
if (!max77650_regulator_is_enabled(rdev))
|
|
return regulator_set_voltage_sel_regmap(rdev, sel);
|
|
|
|
/*
|
|
* Otherwise we need to manually ramp the output voltage up/down
|
|
* one step at a time.
|
|
*/
|
|
|
|
curr = regulator_get_voltage_sel_regmap(rdev);
|
|
if (curr < 0)
|
|
return curr;
|
|
|
|
diff = curr - sel;
|
|
if (diff == 0)
|
|
return 0; /* Already there. */
|
|
else if (diff > 0)
|
|
ascending = false;
|
|
else
|
|
ascending = true;
|
|
|
|
/*
|
|
* Make sure we'll get to the right voltage and break the loop even if
|
|
* the selector equals 0.
|
|
*/
|
|
for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) {
|
|
rv = regulator_set_voltage_sel_regmap(rdev, curr);
|
|
if (rv)
|
|
return rv;
|
|
|
|
if (curr == sel)
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Special case: non-linear voltage table for max77651 SBB1 - software
|
|
* must ensure the voltage is ramped in 50mV increments.
|
|
*/
|
|
static int max77651_regulator_sbb1_set_voltage_sel(struct regulator_dev *rdev,
|
|
unsigned int sel)
|
|
{
|
|
int rv = 0, curr, vcurr, vdest, vdiff;
|
|
|
|
/*
|
|
* If the regulator is disabled, we can program the desired
|
|
* voltage right away.
|
|
*/
|
|
if (!max77650_regulator_is_enabled(rdev))
|
|
return regulator_set_voltage_sel_regmap(rdev, sel);
|
|
|
|
curr = regulator_get_voltage_sel_regmap(rdev);
|
|
if (curr < 0)
|
|
return curr;
|
|
|
|
if (curr == sel)
|
|
return 0; /* Already there. */
|
|
|
|
vcurr = max77651_sbb1_regulator_volt_table[curr];
|
|
vdest = max77651_sbb1_regulator_volt_table[sel];
|
|
vdiff = vcurr - vdest;
|
|
|
|
for (;;) {
|
|
if (vdiff > 0)
|
|
MAX77650_REGULATOR_SBB1_SEL_DECR(curr);
|
|
else
|
|
MAX77650_REGULATOR_SBB1_SEL_INCR(curr);
|
|
|
|
rv = regulator_set_voltage_sel_regmap(rdev, curr);
|
|
if (rv)
|
|
return rv;
|
|
|
|
if (curr == sel)
|
|
break;
|
|
};
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max77650_regulator_get_current_limit(struct regulator_dev *rdev)
|
|
{
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regmap *map;
|
|
int val, rv, limit;
|
|
|
|
rdesc = rdev_get_drvdata(rdev);
|
|
map = rdev_get_regmap(rdev);
|
|
|
|
rv = regmap_read(map, rdesc->regA, &val);
|
|
if (rv)
|
|
return rv;
|
|
|
|
limit = MAX77650_REGULATOR_CURR_LIM_BITS(val);
|
|
|
|
return max77650_current_limit_table[limit];
|
|
}
|
|
|
|
static int max77650_regulator_set_current_limit(struct regulator_dev *rdev,
|
|
int min_uA, int max_uA)
|
|
{
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regmap *map;
|
|
int rv, i, limit;
|
|
|
|
rdesc = rdev_get_drvdata(rdev);
|
|
map = rdev_get_regmap(rdev);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(max77650_current_limit_table); i++) {
|
|
limit = max77650_current_limit_table[i];
|
|
|
|
if (limit >= min_uA && limit <= max_uA) {
|
|
rv = regmap_update_bits(map, rdesc->regA,
|
|
MAX77650_REGULATOR_CURR_LIM_MASK,
|
|
MAX77650_REGULATOR_CURR_LIM_SHIFT(i));
|
|
if (rv)
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct regulator_ops max77650_regulator_LDO_ops = {
|
|
.is_enabled = max77650_regulator_is_enabled,
|
|
.enable = max77650_regulator_enable,
|
|
.disable = max77650_regulator_disable,
|
|
.list_voltage = regulator_list_voltage_linear,
|
|
.map_voltage = regulator_map_voltage_linear,
|
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
|
.set_voltage_sel = max77650_regulator_set_voltage_sel,
|
|
.set_active_discharge = regulator_set_active_discharge_regmap,
|
|
};
|
|
|
|
static const struct regulator_ops max77650_regulator_SBB_ops = {
|
|
.is_enabled = max77650_regulator_is_enabled,
|
|
.enable = max77650_regulator_enable,
|
|
.disable = max77650_regulator_disable,
|
|
.list_voltage = regulator_list_voltage_linear,
|
|
.map_voltage = regulator_map_voltage_linear,
|
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
|
.set_voltage_sel = max77650_regulator_set_voltage_sel,
|
|
.get_current_limit = max77650_regulator_get_current_limit,
|
|
.set_current_limit = max77650_regulator_set_current_limit,
|
|
.set_active_discharge = regulator_set_active_discharge_regmap,
|
|
};
|
|
|
|
/* Special case for max77651 SBB1 - non-linear voltage mapping. */
|
|
static const struct regulator_ops max77651_SBB1_regulator_ops = {
|
|
.is_enabled = max77650_regulator_is_enabled,
|
|
.enable = max77650_regulator_enable,
|
|
.disable = max77650_regulator_disable,
|
|
.list_voltage = regulator_list_voltage_table,
|
|
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
|
.set_voltage_sel = max77651_regulator_sbb1_set_voltage_sel,
|
|
.get_current_limit = max77650_regulator_get_current_limit,
|
|
.set_current_limit = max77650_regulator_set_current_limit,
|
|
.set_active_discharge = regulator_set_active_discharge_regmap,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77650_LDO_desc = {
|
|
.desc = {
|
|
.name = "ldo",
|
|
.of_match = of_match_ptr("ldo"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-ldo",
|
|
.id = MAX77650_REGULATOR_ID_LDO,
|
|
.ops = &max77650_regulator_LDO_ops,
|
|
.min_uV = 1350000,
|
|
.uV_step = 12500,
|
|
.n_voltages = 128,
|
|
.vsel_mask = MAX77650_REGULATOR_V_LDO_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_LDO_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_LDO_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_LDO_A,
|
|
.regB = MAX77650_REG_CNFG_LDO_B,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77650_SBB0_desc = {
|
|
.desc = {
|
|
.name = "sbb0",
|
|
.of_match = of_match_ptr("sbb0"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-sbb0",
|
|
.id = MAX77650_REGULATOR_ID_SBB0,
|
|
.ops = &max77650_regulator_SBB_ops,
|
|
.min_uV = 800000,
|
|
.uV_step = 25000,
|
|
.n_voltages = 64,
|
|
.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_SBB0_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_SBB0_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_SBB0_A,
|
|
.regB = MAX77650_REG_CNFG_SBB0_B,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77650_SBB1_desc = {
|
|
.desc = {
|
|
.name = "sbb1",
|
|
.of_match = of_match_ptr("sbb1"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-sbb1",
|
|
.id = MAX77650_REGULATOR_ID_SBB1,
|
|
.ops = &max77650_regulator_SBB_ops,
|
|
.min_uV = 800000,
|
|
.uV_step = 12500,
|
|
.n_voltages = 64,
|
|
.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_SBB1_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_SBB1_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_SBB1_A,
|
|
.regB = MAX77650_REG_CNFG_SBB1_B,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77651_SBB1_desc = {
|
|
.desc = {
|
|
.name = "sbb1",
|
|
.of_match = of_match_ptr("sbb1"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-sbb1",
|
|
.id = MAX77650_REGULATOR_ID_SBB1,
|
|
.ops = &max77651_SBB1_regulator_ops,
|
|
.volt_table = max77651_sbb1_regulator_volt_table,
|
|
.n_voltages = ARRAY_SIZE(max77651_sbb1_regulator_volt_table),
|
|
.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_SBB1_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_SBB1_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_SBB1_A,
|
|
.regB = MAX77650_REG_CNFG_SBB1_B,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77650_SBB2_desc = {
|
|
.desc = {
|
|
.name = "sbb2",
|
|
.of_match = of_match_ptr("sbb2"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-sbb0",
|
|
.id = MAX77650_REGULATOR_ID_SBB2,
|
|
.ops = &max77650_regulator_SBB_ops,
|
|
.min_uV = 800000,
|
|
.uV_step = 50000,
|
|
.n_voltages = 64,
|
|
.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_SBB2_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_SBB2_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_SBB2_A,
|
|
.regB = MAX77650_REG_CNFG_SBB2_B,
|
|
};
|
|
|
|
static struct max77650_regulator_desc max77651_SBB2_desc = {
|
|
.desc = {
|
|
.name = "sbb2",
|
|
.of_match = of_match_ptr("sbb2"),
|
|
.regulators_node = of_match_ptr("regulators"),
|
|
.supply_name = "in-sbb0",
|
|
.id = MAX77650_REGULATOR_ID_SBB2,
|
|
.ops = &max77650_regulator_SBB_ops,
|
|
.min_uV = 2400000,
|
|
.uV_step = 50000,
|
|
.n_voltages = 64,
|
|
.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
|
|
.vsel_reg = MAX77650_REG_CNFG_SBB2_A,
|
|
.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
|
|
.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
|
|
.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
|
|
.active_discharge_reg = MAX77650_REG_CNFG_SBB2_B,
|
|
.enable_time = 100,
|
|
.type = REGULATOR_VOLTAGE,
|
|
},
|
|
.regA = MAX77650_REG_CNFG_SBB2_A,
|
|
.regB = MAX77650_REG_CNFG_SBB2_B,
|
|
};
|
|
|
|
static int max77650_regulator_probe(struct platform_device *pdev)
|
|
{
|
|
struct max77650_regulator_desc **rdescs;
|
|
struct max77650_regulator_desc *rdesc;
|
|
struct regulator_config config = { };
|
|
struct device *dev, *parent;
|
|
struct regulator_dev *rdev;
|
|
struct regmap *map;
|
|
unsigned int val;
|
|
int i, rv;
|
|
|
|
dev = &pdev->dev;
|
|
parent = dev->parent;
|
|
|
|
if (!dev->of_node)
|
|
dev->of_node = parent->of_node;
|
|
|
|
rdescs = devm_kcalloc(dev, MAX77650_REGULATOR_NUM_REGULATORS,
|
|
sizeof(*rdescs), GFP_KERNEL);
|
|
if (!rdescs)
|
|
return -ENOMEM;
|
|
|
|
map = dev_get_regmap(parent, NULL);
|
|
if (!map)
|
|
return -ENODEV;
|
|
|
|
rv = regmap_read(map, MAX77650_REG_CID, &val);
|
|
if (rv)
|
|
return rv;
|
|
|
|
rdescs[MAX77650_REGULATOR_ID_LDO] = &max77650_LDO_desc;
|
|
rdescs[MAX77650_REGULATOR_ID_SBB0] = &max77650_SBB0_desc;
|
|
|
|
switch (MAX77650_CID_BITS(val)) {
|
|
case MAX77650_CID_77650A:
|
|
case MAX77650_CID_77650C:
|
|
rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77650_SBB1_desc;
|
|
rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77650_SBB2_desc;
|
|
break;
|
|
case MAX77650_CID_77651A:
|
|
case MAX77650_CID_77651B:
|
|
rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77651_SBB1_desc;
|
|
rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77651_SBB2_desc;
|
|
break;
|
|
default:
|
|
return -ENODEV;
|
|
}
|
|
|
|
config.dev = parent;
|
|
|
|
for (i = 0; i < MAX77650_REGULATOR_NUM_REGULATORS; i++) {
|
|
rdesc = rdescs[i];
|
|
config.driver_data = rdesc;
|
|
|
|
rdev = devm_regulator_register(dev, &rdesc->desc, &config);
|
|
if (IS_ERR(rdev))
|
|
return PTR_ERR(rdev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver max77650_regulator_driver = {
|
|
.driver = {
|
|
.name = "max77650-regulator",
|
|
},
|
|
.probe = max77650_regulator_probe,
|
|
};
|
|
module_platform_driver(max77650_regulator_driver);
|
|
|
|
MODULE_DESCRIPTION("MAXIM 77650/77651 regulator driver");
|
|
MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>");
|
|
MODULE_LICENSE("GPL v2");
|