mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-05 16:37:50 +00:00
Code Issues Releases Wiki Activity

Merge remote-tracking branches 'regulator/topic/s5m8767', 'regulator/topic/stub', 'regulator/topic/tps65090', 'regulator/topic/tps65217' and 'regulator/topic/tps65218' into regulator-next

Browse source
This commit is contained in:
Mark Brown 2014-06-02 17:08:12 +01:00
commit b58e917bf9
8 changed files with 237 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Documentation/devicetree/bindings/regulator/tps65090.txt
View file

@ -21,6 +21,10 @@ Optional properties:
number should be provided. If it is externally controlled and no GPIO
entry then driver will just configure this rails as external control
and will not provide any enable/disable APIs.
- ti,overcurrent-wait: This is applicable to FET registers, which have a
poorly defined "overcurrent wait" field. If this property is present it
should be between 0 - 3. If this property isn't present we won't touch the
"overcurrent wait" field and we'll leave it to the BIOS/EC to deal with.
Each regulator is defined using the standard binding for regulators.

37
drivers/regulator/s5m8767.c
View file

@ -28,7 +28,6 @@ struct s5m8767_info {
struct device *dev;
struct sec_pmic_dev *iodev;
int num_regulators;
struct regulator_dev **rdev;
struct sec_opmode_data *opmode;
int ramp_delay;
@ -529,16 +528,6 @@ static int s5m8767_pmic_dt_parse_ds_gpio(struct sec_pmic_dev *iodev,
return 0;
}
static void s5m8767_pmic_dt_parse_ext_control_gpio(struct sec_pmic_dev *iodev,
struct sec_regulator_data *rdata,
struct device_node *reg_np)
{
rdata->ext_control_gpio = of_get_named_gpio(reg_np,
"s5m8767,pmic-ext-control-gpios", 0);
if (!gpio_is_valid(rdata->ext_control_gpio))
rdata->ext_control_gpio = 0;
}
static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
struct sec_platform_data *pdata)
{
@ -587,7 +576,8 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
continue;
}
s5m8767_pmic_dt_parse_ext_control_gpio(iodev, rdata, reg_np);
rdata->ext_control_gpio = of_get_named_gpio(reg_np,
"s5m8767,pmic-ext-control-gpios", 0);
rdata->id = i;
rdata->initdata = of_get_regulator_init_data(
@ -695,7 +685,6 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct sec_platform_data *pdata = iodev->pdata;
struct regulator_config config = { };
struct regulator_dev **rdev;
struct s5m8767_info *s5m8767;
int i, ret, size, buck_init;
@ -737,11 +726,7 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
return -ENOMEM;
size = sizeof(struct regulator_dev *) * (S5M8767_REG_MAX - 2);
s5m8767->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
if (!s5m8767->rdev)
return -ENOMEM;
rdev = s5m8767->rdev;
s5m8767->dev = &pdev->dev;
s5m8767->iodev = iodev;
s5m8767->num_regulators = pdata->num_regulators;
@ -938,6 +923,7 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
const struct sec_voltage_desc *desc;
int id = pdata->regulators[i].id;
int enable_reg, enable_val;
struct regulator_dev *rdev;
desc = reg_voltage_map[id];
if (desc) {
@ -964,26 +950,27 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
config.driver_data = s5m8767;
config.regmap = iodev->regmap_pmic;
config.of_node = pdata->regulators[i].reg_node;
config.ena_gpio = config.ena_gpio_flags = 0;
if (pdata->regulators[i].ext_control_gpio)
config.ena_gpio = -EINVAL;
config.ena_gpio_flags = 0;
if (gpio_is_valid(pdata->regulators[i].ext_control_gpio))
s5m8767_regulator_config_ext_control(s5m8767,
&pdata->regulators[i], &config);
rdev[i] = devm_regulator_register(&pdev->dev, &regulators[id],
rdev = devm_regulator_register(&pdev->dev, &regulators[id],
&config);
if (IS_ERR(rdev[i])) {
ret = PTR_ERR(rdev[i]);
if (IS_ERR(rdev)) {
ret = PTR_ERR(rdev);
dev_err(s5m8767->dev, "regulator init failed for %d\n",
id);
return ret;
}
if (pdata->regulators[i].ext_control_gpio) {
ret = s5m8767_enable_ext_control(s5m8767, rdev[i]);
if (gpio_is_valid(pdata->regulators[i].ext_control_gpio)) {
ret = s5m8767_enable_ext_control(s5m8767, rdev);
if (ret < 0) {
dev_err(s5m8767->dev,
"failed to enable gpio control over %s: %d\n",
rdev[i]->desc->name, ret);
rdev->desc->name, ret);
return ret;
}
}

214
drivers/regulator/tps65090-regulator.c
View file

@ -17,6 +17,7 @@
*/
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
@ -28,49 +29,216 @@
#include <linux/regulator/of_regulator.h>
#include <linux/mfd/tps65090.h>
#define MAX_CTRL_READ_TRIES 5
#define MAX_FET_ENABLE_TRIES 1000
#define CTRL_EN_BIT 0 /* Regulator enable bit, active high */
#define CTRL_WT_BIT 2 /* Regulator wait time 0 bit */
#define CTRL_PG_BIT 4 /* Regulator power good bit, 1=good */
#define CTRL_TO_BIT 7 /* Regulator timeout bit, 1=wait */
#define MAX_OVERCURRENT_WAIT 3 /* Overcurrent wait must be <= this */
/**
* struct tps65090_regulator - Per-regulator data for a tps65090 regulator
*
* @dev: Pointer to our device.
* @desc: The struct regulator_desc for the regulator.
* @rdev: The struct regulator_dev for the regulator.
* @overcurrent_wait_valid: True if overcurrent_wait is valid.
* @overcurrent_wait: For FETs, the value to put in the WTFET bitfield.
*/
struct tps65090_regulator {
struct device *dev;
struct regulator_desc *desc;
struct regulator_dev *rdev;
bool overcurrent_wait_valid;
int overcurrent_wait;
};
static struct regulator_ops tps65090_ext_control_ops = {
};
static struct regulator_ops tps65090_reg_contol_ops = {
/**
* tps65090_reg_set_overcurrent_wait - Setup overcurrent wait
*
* This will set the overcurrent wait time based on what's in the regulator
* info.
*
* @ri: Overall regulator data
* @rdev: Regulator device
*
* Return: 0 if no error, non-zero if there was an error writing the register.
*/
static int tps65090_reg_set_overcurrent_wait(struct tps65090_regulator *ri,
struct regulator_dev *rdev)
{
int ret;
ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
MAX_OVERCURRENT_WAIT << CTRL_WT_BIT,
ri->overcurrent_wait << CTRL_WT_BIT);
if (ret) {
dev_err(&rdev->dev, "Error updating overcurrent wait %#x\n",
rdev->desc->enable_reg);
}
return ret;
}
/**
* tps65090_try_enable_fet - Try to enable a FET
*
* @rdev: Regulator device
*
* Return: 0 if ok, -ENOTRECOVERABLE if the FET power good bit did not get
* set, or some other -ve value if another error occurred (e.g. i2c error)
*/
static int tps65090_try_enable_fet(struct regulator_dev *rdev)
{
unsigned int control;
int ret, i;
ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
rdev->desc->enable_mask,
rdev->desc->enable_mask);
if (ret < 0) {
dev_err(&rdev->dev, "Error in updating reg %#x\n",
rdev->desc->enable_reg);
return ret;
}
for (i = 0; i < MAX_CTRL_READ_TRIES; i++) {
ret = regmap_read(rdev->regmap, rdev->desc->enable_reg,
&control);
if (ret < 0)
return ret;
if (!(control & BIT(CTRL_TO_BIT)))
break;
usleep_range(1000, 1500);
}
if (!(control & BIT(CTRL_PG_BIT)))
return -ENOTRECOVERABLE;
return 0;
}
/**
* tps65090_fet_enable - Enable a FET, trying a few times if it fails
*
* Some versions of the tps65090 have issues when turning on the FETs.
* This function goes through several steps to ensure the best chance of the
* FET going on. Specifically:
* - We'll make sure that we bump the "overcurrent wait" to the maximum, which
* increases the chances that we'll turn on properly.
* - We'll retry turning the FET on multiple times (turning off in between).
*
* @rdev: Regulator device
*
* Return: 0 if ok, non-zero if it fails.
*/
static int tps65090_fet_enable(struct regulator_dev *rdev)
{
int ret, tries;
/*
* Try enabling multiple times until we succeed since sometimes the
* first try times out.
*/
tries = 0;
while (true) {
ret = tps65090_try_enable_fet(rdev);
if (!ret)
break;
if (ret != -ENOTRECOVERABLE || tries == MAX_FET_ENABLE_TRIES)
goto err;
/* Try turning the FET off (and then on again) */
ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
rdev->desc->enable_mask, 0);
if (ret)
goto err;
tries++;
}
if (tries)
dev_warn(&rdev->dev, "reg %#x enable ok after %d tries\n",
rdev->desc->enable_reg, tries);
return 0;
err:
dev_warn(&rdev->dev, "reg %#x enable failed\n", rdev->desc->enable_reg);
WARN_ON(1);
return ret;
}
static struct regulator_ops tps65090_reg_control_ops = {
.enable = regulator_enable_regmap,
.disable = regulator_disable_regmap,
.is_enabled = regulator_is_enabled_regmap,
};
static struct regulator_ops tps65090_fet_control_ops = {
.enable = tps65090_fet_enable,
.disable = regulator_disable_regmap,
.is_enabled = regulator_is_enabled_regmap,
};
static struct regulator_ops tps65090_ldo_ops = {
};
#define tps65090_REG_DESC(_id, _sname, _en_reg, _ops) \
#define tps65090_REG_DESC(_id, _sname, _en_reg, _en_bits, _ops) \
{ \
.name = "TPS65090_RAILS"#_id, \
.supply_name = _sname, \
.id = TPS65090_REGULATOR_##_id, \
.ops = &_ops, \
.enable_reg = _en_reg, \
.enable_mask = BIT(0), \
.enable_val = _en_bits, \
.enable_mask = _en_bits, \
.type = REGULATOR_VOLTAGE, \
.owner = THIS_MODULE, \
}
static struct regulator_desc tps65090_regulator_desc[] = {
tps65090_REG_DESC(DCDC1, "vsys1", 0x0C, tps65090_reg_contol_ops),
tps65090_REG_DESC(DCDC2, "vsys2", 0x0D, tps65090_reg_contol_ops),
tps65090_REG_DESC(DCDC3, "vsys3", 0x0E, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET1, "infet1", 0x0F, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET2, "infet2", 0x10, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET3, "infet3", 0x11, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET4, "infet4", 0x12, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET5, "infet5", 0x13, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET6, "infet6", 0x14, tps65090_reg_contol_ops),
tps65090_REG_DESC(FET7, "infet7", 0x15, tps65090_reg_contol_ops),
tps65090_REG_DESC(LDO1, "vsys-l1", 0, tps65090_ldo_ops),
tps65090_REG_DESC(LDO2, "vsys-l2", 0, tps65090_ldo_ops),
tps65090_REG_DESC(DCDC1, "vsys1", 0x0C, BIT(CTRL_EN_BIT),
tps65090_reg_control_ops),
tps65090_REG_DESC(DCDC2, "vsys2", 0x0D, BIT(CTRL_EN_BIT),
tps65090_reg_control_ops),
tps65090_REG_DESC(DCDC3, "vsys3", 0x0E, BIT(CTRL_EN_BIT),
tps65090_reg_control_ops),
tps65090_REG_DESC(FET1, "infet1", 0x0F,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET2, "infet2", 0x10,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET3, "infet3", 0x11,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET4, "infet4", 0x12,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET5, "infet5", 0x13,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET6, "infet6", 0x14,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(FET7, "infet7", 0x15,
BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
tps65090_fet_control_ops),
tps65090_REG_DESC(LDO1, "vsys-l1", 0, 0,
tps65090_ldo_ops),
tps65090_REG_DESC(LDO2, "vsys-l2", 0, 0,
tps65090_ldo_ops),
};
static inline bool is_dcdc(int id)
@ -209,6 +377,11 @@ static struct tps65090_platform_data *tps65090_parse_dt_reg_data(
rpdata->gpio = of_get_named_gpio(np,
"dcdc-ext-control-gpios", 0);
if (of_property_read_u32(tps65090_matches[idx].of_node,
"ti,overcurrent-wait",
&rpdata->overcurrent_wait) == 0)
rpdata->overcurrent_wait_valid = true;
tps65090_pdata->reg_pdata[idx] = rpdata;
}
return tps65090_pdata;
@ -258,6 +431,11 @@ static int tps65090_regulator_probe(struct platform_device *pdev)
ri = &pmic[num];
ri->dev = &pdev->dev;
ri->desc = &tps65090_regulator_desc[num];
if (tps_pdata) {
ri->overcurrent_wait_valid =
tps_pdata->overcurrent_wait_valid;
ri->overcurrent_wait = tps_pdata->overcurrent_wait;
}
/*
* TPS5090 DCDC support the control from external digital input.
@ -299,6 +477,12 @@ static int tps65090_regulator_probe(struct platform_device *pdev)
}
ri->rdev = rdev;
if (ri->overcurrent_wait_valid) {
ret = tps65090_reg_set_overcurrent_wait(ri, rdev);
if (ret < 0)
return ret;
}
/* Enable external control if it is require */
if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data &&
tps_pdata->enable_ext_control) {

4
drivers/regulator/tps65217-regulator.c
View file

@ -134,6 +134,7 @@ static struct regulator_ops tps65217_pmic_ldo1_ops = {
.get_voltage_sel = regulator_get_voltage_sel_regmap,
.set_voltage_sel = tps65217_pmic_set_voltage_sel,
.list_voltage = regulator_list_voltage_table,
.map_voltage = regulator_map_voltage_ascend,
};
static const struct regulator_desc regulators[] = {
@ -257,9 +258,6 @@ static int tps65217_regulator_probe(struct platform_device *pdev)
pdev->name);
return PTR_ERR(rdev);
}
/* Save regulator for cleanup */
tps->rdev[i] = rdev;
}
return 0;
}

37
drivers/regulator/tps65218-regulator.c
View file

@ -27,12 +27,10 @@
#include <linux/regulator/machine.h>
#include <linux/mfd/tps65218.h>
static unsigned int tps65218_ramp_delay = 4000;
enum tps65218_regulators { DCDC1, DCDC2, DCDC3, DCDC4, DCDC5, DCDC6, LDO1 };
#define TPS65218_REGULATOR(_name, _id, _ops, _n, _vr, _vm, _er, _em, _t, \
_lr, _nlr) \
_lr, _nlr, _delay) \
{ \
.name = _name, \
.id = _id, \
@ -47,6 +45,7 @@ enum tps65218_regulators { DCDC1, DCDC2, DCDC3, DCDC4, DCDC5, DCDC6, LDO1 };
.volt_table = _t, \
.linear_ranges = _lr, \
.n_linear_ranges = _nlr, \
.ramp_delay = _delay, \
} \
#define TPS65218_INFO(_id, _nm, _min, _max) \
@ -152,22 +151,6 @@ static int tps65218_pmic_disable(struct regulator_dev *dev)
dev->desc->enable_mask, TPS65218_PROTECT_L1);
}
static int tps65218_set_voltage_time_sel(struct regulator_dev *rdev,
unsigned int old_selector, unsigned int new_selector)
{
int old_uv, new_uv;
old_uv = regulator_list_voltage_linear_range(rdev, old_selector);
if (old_uv < 0)
return old_uv;
new_uv = regulator_list_voltage_linear_range(rdev, new_selector);
if (new_uv < 0)
return new_uv;
return DIV_ROUND_UP(abs(old_uv - new_uv), tps65218_ramp_delay);
}
/* Operations permitted on DCDC1, DCDC2 */
static struct regulator_ops tps65218_dcdc12_ops = {
.is_enabled = regulator_is_enabled_regmap,
@ -177,7 +160,7 @@ static struct regulator_ops tps65218_dcdc12_ops = {
.set_voltage_sel = tps65218_pmic_set_voltage_sel,
.list_voltage = regulator_list_voltage_linear_range,
.map_voltage = regulator_map_voltage_linear_range,
.set_voltage_time_sel = tps65218_set_voltage_time_sel,
.set_voltage_time_sel = regulator_set_voltage_time_sel,
};
/* Operations permitted on DCDC3, DCDC4 and LDO1 */
@ -203,33 +186,33 @@ static const struct regulator_desc regulators[] = {
TPS65218_REG_CONTROL_DCDC1,
TPS65218_CONTROL_DCDC1_MASK,
TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC1_EN, NULL,
dcdc1_dcdc2_ranges, 2),
dcdc1_dcdc2_ranges, 2, 4000),
TPS65218_REGULATOR("DCDC2", TPS65218_DCDC_2, tps65218_dcdc12_ops, 64,
TPS65218_REG_CONTROL_DCDC2,
TPS65218_CONTROL_DCDC2_MASK,
TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC2_EN, NULL,
dcdc1_dcdc2_ranges, 2),
dcdc1_dcdc2_ranges, 2, 4000),
TPS65218_REGULATOR("DCDC3", TPS65218_DCDC_3, tps65218_ldo1_dcdc34_ops,
64, TPS65218_REG_CONTROL_DCDC3,
TPS65218_CONTROL_DCDC3_MASK, TPS65218_REG_ENABLE1,
TPS65218_ENABLE1_DC3_EN, NULL,
ldo1_dcdc3_ranges, 2),
ldo1_dcdc3_ranges, 2, 0),
TPS65218_REGULATOR("DCDC4", TPS65218_DCDC_4, tps65218_ldo1_dcdc34_ops,
53, TPS65218_REG_CONTROL_DCDC4,
TPS65218_CONTROL_DCDC4_MASK,
TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC4_EN, NULL,
dcdc4_ranges, 2),
dcdc4_ranges, 2, 0),
TPS65218_REGULATOR("DCDC5", TPS65218_DCDC_5, tps65218_dcdc56_pmic_ops,
1, -1, -1, TPS65218_REG_ENABLE1,
TPS65218_ENABLE1_DC5_EN, NULL, NULL, 0),
TPS65218_ENABLE1_DC5_EN, NULL, NULL, 0, 0),
TPS65218_REGULATOR("DCDC6", TPS65218_DCDC_6, tps65218_dcdc56_pmic_ops,
1, -1, -1, TPS65218_REG_ENABLE1,
TPS65218_ENABLE1_DC6_EN, NULL, NULL, 0),
TPS65218_ENABLE1_DC6_EN, NULL, NULL, 0, 0),
TPS65218_REGULATOR("LDO1", TPS65218_LDO_1, tps65218_ldo1_dcdc34_ops, 64,
TPS65218_REG_CONTROL_DCDC4,
TPS65218_CONTROL_LDO1_MASK, TPS65218_REG_ENABLE2,
TPS65218_ENABLE2_LDO1_EN, NULL, ldo1_dcdc3_ranges,
2),
2, 0),
};
static int tps65218_regulator_probe(struct platform_device *pdev)

5
include/linux/mfd/tps65090.h
View file

@ -92,11 +92,16 @@ struct tps65090 {
* DCDC1, DCDC2 and DCDC3.
* @gpio: Gpio number if external control is enabled and controlled through
* gpio.
* @overcurrent_wait_valid: True if the overcurrent_wait should be applied.
* @overcurrent_wait: Value to set as the overcurrent wait time. This is the
* actual bitfield value, not a time in ms (valid value are 0 - 3).
*/
struct tps65090_regulator_plat_data {
struct regulator_init_data *reg_init_data;
bool enable_ext_control;
int gpio;
bool overcurrent_wait_valid;
int overcurrent_wait;
};
struct tps65090_platform_data {

1
include/linux/mfd/tps65217.h
View file

@ -254,7 +254,6 @@ struct tps65217 {
struct tps65217_board *pdata;
unsigned long id;
struct regulator_desc desc[TPS65217_NUM_REGULATOR];
struct regulator_dev *rdev[TPS65217_NUM_REGULATOR];
struct regmap *regmap;
};

6
include/linux/regulator/consumer.h
View file

@ -401,6 +401,12 @@ static inline int regulator_set_voltage(struct regulator *regulator,
return 0;
}
static inline int regulator_set_voltage_time(struct regulator *regulator,
int old_uV, int new_uV)
{
return 0;
}
static inline int regulator_get_voltage(struct regulator *regulator)
{
return -EINVAL;