mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 10:57:46 +00:00
Merge branch 'topic/min' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator into regulator-change
This commit is contained in:
Mark Brown
commit
b17fc86cc5
11 changed files with 1115 additions and 202 deletions
|
|
@ -109,6 +109,16 @@ config REGULATOR_DA9052
|
|||
This driver supports the voltage regulators of DA9052-BC and
|
||||
DA9053-AA/Bx PMIC.
|
||||
|
||||
config REGULATOR_DA9055
|
||||
tristate "Dialog Semiconductor DA9055 regulators"
|
||||
depends on MFD_DA9055
|
||||
help
|
||||
Say y here to support the BUCKs and LDOs regulators found on
|
||||
Dialog Semiconductor DA9055 PMIC.
|
||||
|
||||
This driver can also be built as a module. If so, the module
|
||||
will be called da9055-regulator.
|
||||
|
||||
config REGULATOR_FAN53555
|
||||
tristate "Fairchild FAN53555 Regulator"
|
||||
depends on I2C
|
||||
|
|
@ -335,6 +345,17 @@ config REGULATOR_PALMAS
|
|||
on the muxing. This is handled automatically in the driver by
|
||||
reading the mux info from OTP.
|
||||
|
||||
config REGULATOR_TPS51632
|
||||
tristate "TI TPS51632 Power Regulator"
|
||||
depends on I2C
|
||||
select REGMAP_I2C
|
||||
help
|
||||
This driver supports TPS51632 voltage regulator chip.
|
||||
The TPS51632 is 3-2-1 Phase D-Cap+ Step Down Driverless Controller
|
||||
with Serial VID control and DVFS.
|
||||
The voltage output can be configure through I2C interface or PWM
|
||||
interface.
|
||||
|
||||
config REGULATOR_TPS6105X
|
||||
tristate "TI TPS6105X Power regulators"
|
||||
depends on TPS6105X
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o
|
|||
obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o
|
||||
obj-$(CONFIG_REGULATOR_DA903X) += da903x.o
|
||||
obj-$(CONFIG_REGULATOR_DA9052) += da9052-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_DA9055) += da9055-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_DBX500_PRCMU) += dbx500-prcmu.o
|
||||
obj-$(CONFIG_REGULATOR_DB8500_PRCMU) += db8500-prcmu.o
|
||||
obj-$(CONFIG_REGULATOR_FAN53555) += fan53555.o
|
||||
|
|
@ -41,6 +42,7 @@ obj-$(CONFIG_REGULATOR_MC13783) += mc13783-regulator.o
|
|||
obj-$(CONFIG_REGULATOR_MC13892) += mc13892-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_MC13XXX_CORE) += mc13xxx-regulator-core.o
|
||||
obj-$(CONFIG_REGULATOR_PALMAS) += palmas-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_TPS51632) += tps51632-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
|
||||
obj-$(CONFIG_REGULATOR_RC5T583) += rc5t583-regulator.o
|
||||
|
|
|
|||
|
|
@ -48,36 +48,21 @@ static int anatop_regmap_set_voltage_sel(struct regulator_dev *reg,
|
|||
unsigned selector)
|
||||
{
|
||||
struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
|
||||
u32 val, mask;
|
||||
|
||||
if (!anatop_reg->control_reg)
|
||||
return -ENOTSUPP;
|
||||
|
||||
val = anatop_reg->min_bit_val + selector;
|
||||
dev_dbg(®->dev, "%s: calculated val %d\n", __func__, val);
|
||||
mask = ((1 << anatop_reg->vol_bit_width) - 1) <<
|
||||
anatop_reg->vol_bit_shift;
|
||||
val <<= anatop_reg->vol_bit_shift;
|
||||
regmap_update_bits(anatop_reg->anatop, anatop_reg->control_reg,
|
||||
mask, val);
|
||||
|
||||
return 0;
|
||||
return regulator_set_voltage_sel_regmap(reg, selector);
|
||||
}
|
||||
|
||||
static int anatop_regmap_get_voltage_sel(struct regulator_dev *reg)
|
||||
{
|
||||
struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
|
||||
u32 val, mask;
|
||||
|
||||
if (!anatop_reg->control_reg)
|
||||
return -ENOTSUPP;
|
||||
|
||||
regmap_read(anatop_reg->anatop, anatop_reg->control_reg, &val);
|
||||
mask = ((1 << anatop_reg->vol_bit_width) - 1) <<
|
||||
anatop_reg->vol_bit_shift;
|
||||
val = (val & mask) >> anatop_reg->vol_bit_shift;
|
||||
|
||||
return val - anatop_reg->min_bit_val;
|
||||
return regulator_get_voltage_sel_regmap(reg);
|
||||
}
|
||||
|
||||
static struct regulator_ops anatop_rops = {
|
||||
|
|
@ -158,15 +143,20 @@ static int __devinit anatop_regulator_probe(struct platform_device *pdev)
|
|||
goto anatop_probe_end;
|
||||
}
|
||||
|
||||
rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage)
|
||||
/ 25000 + 1;
|
||||
rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage) / 25000 + 1
|
||||
+ sreg->min_bit_val;
|
||||
rdesc->min_uV = sreg->min_voltage;
|
||||
rdesc->uV_step = 25000;
|
||||
rdesc->linear_min_sel = sreg->min_bit_val;
|
||||
rdesc->vsel_reg = sreg->control_reg;
|
||||
rdesc->vsel_mask = ((1 << sreg->vol_bit_width) - 1) <<
|
||||
sreg->vol_bit_shift;
|
||||
|
||||
config.dev = &pdev->dev;
|
||||
config.init_data = initdata;
|
||||
config.driver_data = sreg;
|
||||
config.of_node = pdev->dev.of_node;
|
||||
config.regmap = sreg->anatop;
|
||||
|
||||
/* register regulator */
|
||||
rdev = regulator_register(rdesc, &config);
|
||||
|
|
|
|||
|
|
@ -1919,6 +1919,10 @@ int regulator_list_voltage_linear(struct regulator_dev *rdev,
|
|||
{
|
||||
if (selector >= rdev->desc->n_voltages)
|
||||
return -EINVAL;
|
||||
if (selector < rdev->desc->linear_min_sel)
|
||||
return 0;
|
||||
|
||||
selector -= rdev->desc->linear_min_sel;
|
||||
|
||||
return rdev->desc->min_uV + (rdev->desc->uV_step * selector);
|
||||
}
|
||||
|
|
@ -2142,6 +2146,8 @@ int regulator_map_voltage_linear(struct regulator_dev *rdev,
|
|||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret += rdev->desc->linear_min_sel;
|
||||
|
||||
/* Map back into a voltage to verify we're still in bounds */
|
||||
voltage = rdev->desc->ops->list_voltage(rdev, ret);
|
||||
if (voltage < min_uV || voltage > max_uV)
|
||||
|
|
|
|||
644
drivers/regulator/da9055-regulator.c
Normal file
644
drivers/regulator/da9055-regulator.c
Normal file
|
|
@ -0,0 +1,644 @@
|
|||
/*
|
||||
* Regulator driver for DA9055 PMIC
|
||||
*
|
||||
* Copyright(c) 2012 Dialog Semiconductor Ltd.
|
||||
*
|
||||
* Author: David Dajun Chen <dchen@diasemi.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/regulator/driver.h>
|
||||
#include <linux/regulator/machine.h>
|
||||
|
||||
#include <linux/mfd/da9055/core.h>
|
||||
#include <linux/mfd/da9055/reg.h>
|
||||
#include <linux/mfd/da9055/pdata.h>
|
||||
|
||||
#define DA9055_MIN_UA 0
|
||||
#define DA9055_MAX_UA 3
|
||||
|
||||
#define DA9055_LDO_MODE_SYNC 0
|
||||
#define DA9055_LDO_MODE_SLEEP 1
|
||||
|
||||
#define DA9055_BUCK_MODE_SLEEP 1
|
||||
#define DA9055_BUCK_MODE_SYNC 2
|
||||
#define DA9055_BUCK_MODE_AUTO 3
|
||||
|
||||
/* DA9055 REGULATOR IDs */
|
||||
#define DA9055_ID_BUCK1 0
|
||||
#define DA9055_ID_BUCK2 1
|
||||
#define DA9055_ID_LDO1 2
|
||||
#define DA9055_ID_LDO2 3
|
||||
#define DA9055_ID_LDO3 4
|
||||
#define DA9055_ID_LDO4 5
|
||||
#define DA9055_ID_LDO5 6
|
||||
#define DA9055_ID_LDO6 7
|
||||
|
||||
/* DA9055 BUCK current limit */
|
||||
static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 };
|
||||
|
||||
struct da9055_conf_reg {
|
||||
int reg;
|
||||
int sel_mask;
|
||||
int en_mask;
|
||||
};
|
||||
|
||||
struct da9055_volt_reg {
|
||||
int reg_a;
|
||||
int reg_b;
|
||||
int sl_shift;
|
||||
int v_mask;
|
||||
int v_shift;
|
||||
};
|
||||
|
||||
struct da9055_mode_reg {
|
||||
int reg;
|
||||
int mask;
|
||||
int shift;
|
||||
};
|
||||
|
||||
struct da9055_regulator_info {
|
||||
struct regulator_desc reg_desc;
|
||||
struct da9055_conf_reg conf;
|
||||
struct da9055_volt_reg volt;
|
||||
struct da9055_mode_reg mode;
|
||||
};
|
||||
|
||||
struct da9055_regulator {
|
||||
struct da9055 *da9055;
|
||||
struct da9055_regulator_info *info;
|
||||
struct regulator_dev *rdev;
|
||||
enum gpio_select reg_rselect;
|
||||
};
|
||||
|
||||
static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret, mode = 0;
|
||||
|
||||
ret = da9055_reg_read(regulator->da9055, info->mode.reg);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
switch ((ret & info->mode.mask) >> info->mode.shift) {
|
||||
case DA9055_BUCK_MODE_SYNC:
|
||||
mode = REGULATOR_MODE_FAST;
|
||||
break;
|
||||
case DA9055_BUCK_MODE_AUTO:
|
||||
mode = REGULATOR_MODE_NORMAL;
|
||||
break;
|
||||
case DA9055_BUCK_MODE_SLEEP:
|
||||
mode = REGULATOR_MODE_STANDBY;
|
||||
break;
|
||||
}
|
||||
|
||||
return mode;
|
||||
}
|
||||
|
||||
static int da9055_buck_set_mode(struct regulator_dev *rdev,
|
||||
unsigned int mode)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int val = 0;
|
||||
|
||||
switch (mode) {
|
||||
case REGULATOR_MODE_FAST:
|
||||
val = DA9055_BUCK_MODE_SYNC << info->mode.shift;
|
||||
break;
|
||||
case REGULATOR_MODE_NORMAL:
|
||||
val = DA9055_BUCK_MODE_AUTO << info->mode.shift;
|
||||
break;
|
||||
case REGULATOR_MODE_STANDBY:
|
||||
val = DA9055_BUCK_MODE_SLEEP << info->mode.shift;
|
||||
break;
|
||||
}
|
||||
|
||||
return da9055_reg_update(regulator->da9055, info->mode.reg,
|
||||
info->mode.mask, val);
|
||||
}
|
||||
|
||||
static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret;
|
||||
|
||||
ret = da9055_reg_read(regulator->da9055, info->volt.reg_b);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (ret >> info->volt.sl_shift)
|
||||
return REGULATOR_MODE_STANDBY;
|
||||
else
|
||||
return REGULATOR_MODE_NORMAL;
|
||||
}
|
||||
|
||||
static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
struct da9055_volt_reg volt = info->volt;
|
||||
int val = 0;
|
||||
|
||||
switch (mode) {
|
||||
case REGULATOR_MODE_NORMAL:
|
||||
case REGULATOR_MODE_FAST:
|
||||
val = DA9055_LDO_MODE_SYNC;
|
||||
break;
|
||||
case REGULATOR_MODE_STANDBY:
|
||||
val = DA9055_LDO_MODE_SLEEP;
|
||||
break;
|
||||
}
|
||||
|
||||
return da9055_reg_update(regulator->da9055, volt.reg_b,
|
||||
1 << volt.sl_shift,
|
||||
val << volt.sl_shift);
|
||||
}
|
||||
|
||||
static int da9055_buck_get_current_limit(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret;
|
||||
|
||||
ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret &= info->mode.mask;
|
||||
return da9055_current_limits[ret >> info->mode.shift];
|
||||
}
|
||||
|
||||
static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA,
|
||||
int max_uA)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int i, val = 0;
|
||||
|
||||
if (min_uA > da9055_current_limits[DA9055_MAX_UA] ||
|
||||
max_uA < da9055_current_limits[DA9055_MIN_UA])
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(da9055_current_limits); i++) {
|
||||
if (min_uA <= da9055_current_limits[i]) {
|
||||
val = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return da9055_reg_update(regulator->da9055, DA9055_REG_BUCK_LIM,
|
||||
info->mode.mask, val << info->mode.shift);
|
||||
}
|
||||
|
||||
static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
struct da9055_volt_reg volt = info->volt;
|
||||
int ret, sel;
|
||||
|
||||
/*
|
||||
* There are two voltage register set A & B for voltage ramping but
|
||||
* either one of then can be active therefore we first determine
|
||||
* the active register set.
|
||||
*/
|
||||
ret = da9055_reg_read(regulator->da9055, info->conf.reg);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret &= info->conf.sel_mask;
|
||||
|
||||
/* Get the voltage for the active register set A/B */
|
||||
if (ret == DA9055_REGUALTOR_SET_A)
|
||||
ret = da9055_reg_read(regulator->da9055, volt.reg_a);
|
||||
else
|
||||
ret = da9055_reg_read(regulator->da9055, volt.reg_b);
|
||||
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
sel = (ret & volt.v_mask);
|
||||
return sel;
|
||||
}
|
||||
|
||||
static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev,
|
||||
unsigned int selector)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* Regulator register set A/B is not selected through GPIO therefore
|
||||
* we use default register set A for voltage ramping.
|
||||
*/
|
||||
if (regulator->reg_rselect == NO_GPIO) {
|
||||
/* Select register set A */
|
||||
ret = da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
info->conf.sel_mask, DA9055_SEL_REG_A);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
/* Set the voltage */
|
||||
return da9055_reg_update(regulator->da9055, info->volt.reg_a,
|
||||
info->volt.v_mask, selector);
|
||||
}
|
||||
|
||||
/*
|
||||
* Here regulator register set A/B is selected through GPIO.
|
||||
* Therefore we first determine the selected register set A/B and
|
||||
* then set the desired voltage for that register set A/B.
|
||||
*/
|
||||
ret = da9055_reg_read(regulator->da9055, info->conf.reg);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret &= info->conf.sel_mask;
|
||||
|
||||
/* Set the voltage */
|
||||
if (ret == DA9055_REGUALTOR_SET_A)
|
||||
return da9055_reg_update(regulator->da9055, info->volt.reg_a,
|
||||
info->volt.v_mask, selector);
|
||||
else
|
||||
return da9055_reg_update(regulator->da9055, info->volt.reg_b,
|
||||
info->volt.v_mask, selector);
|
||||
}
|
||||
|
||||
static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev,
|
||||
int uV)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret;
|
||||
|
||||
/* Select register set B for suspend voltage ramping. */
|
||||
if (regulator->reg_rselect == NO_GPIO) {
|
||||
ret = da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
info->conf.sel_mask, DA9055_SEL_REG_B);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = regulator_map_voltage_linear(rdev, uV, uV);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return da9055_reg_update(regulator->da9055, info->volt.reg_b,
|
||||
info->volt.v_mask, ret);
|
||||
}
|
||||
|
||||
static int da9055_suspend_enable(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
|
||||
/* Select register set B for voltage ramping. */
|
||||
if (regulator->reg_rselect == NO_GPIO)
|
||||
return da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
info->conf.sel_mask, DA9055_SEL_REG_B);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int da9055_suspend_disable(struct regulator_dev *rdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
|
||||
/* Diselect register set B. */
|
||||
if (regulator->reg_rselect == NO_GPIO)
|
||||
return da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
info->conf.sel_mask, DA9055_SEL_REG_A);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct regulator_ops da9055_buck_ops = {
|
||||
.get_mode = da9055_buck_get_mode,
|
||||
.set_mode = da9055_buck_set_mode,
|
||||
|
||||
.get_current_limit = da9055_buck_get_current_limit,
|
||||
.set_current_limit = da9055_buck_set_current_limit,
|
||||
|
||||
.get_voltage_sel = da9055_regulator_get_voltage_sel,
|
||||
.set_voltage_sel = da9055_regulator_set_voltage_sel,
|
||||
.list_voltage = regulator_list_voltage_linear,
|
||||
.map_voltage = regulator_map_voltage_linear,
|
||||
.is_enabled = regulator_is_enabled_regmap,
|
||||
.enable = regulator_enable_regmap,
|
||||
.disable = regulator_disable_regmap,
|
||||
|
||||
.set_suspend_voltage = da9055_regulator_set_suspend_voltage,
|
||||
.set_suspend_enable = da9055_suspend_enable,
|
||||
.set_suspend_disable = da9055_suspend_disable,
|
||||
.set_suspend_mode = da9055_buck_set_mode,
|
||||
};
|
||||
|
||||
static struct regulator_ops da9055_ldo_ops = {
|
||||
.get_mode = da9055_ldo_get_mode,
|
||||
.set_mode = da9055_ldo_set_mode,
|
||||
|
||||
.get_voltage_sel = da9055_regulator_get_voltage_sel,
|
||||
.set_voltage_sel = da9055_regulator_set_voltage_sel,
|
||||
.list_voltage = regulator_list_voltage_linear,
|
||||
.map_voltage = regulator_map_voltage_linear,
|
||||
.is_enabled = regulator_is_enabled_regmap,
|
||||
.enable = regulator_enable_regmap,
|
||||
.disable = regulator_disable_regmap,
|
||||
|
||||
.set_suspend_voltage = da9055_regulator_set_suspend_voltage,
|
||||
.set_suspend_enable = da9055_suspend_enable,
|
||||
.set_suspend_disable = da9055_suspend_disable,
|
||||
.set_suspend_mode = da9055_ldo_set_mode,
|
||||
|
||||
};
|
||||
|
||||
#define DA9055_LDO(_id, step, min, max, vbits, voffset) \
|
||||
{\
|
||||
.reg_desc = {\
|
||||
.name = #_id,\
|
||||
.ops = &da9055_ldo_ops,\
|
||||
.type = REGULATOR_VOLTAGE,\
|
||||
.id = DA9055_ID_##_id,\
|
||||
.n_voltages = (max - min) / step + 1 + (voffset), \
|
||||
.enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
|
||||
.enable_mask = 1, \
|
||||
.min_uV = (min) * 1000,\
|
||||
.uV_step = (step) * 1000,\
|
||||
.linear_min_sel = (voffset),\
|
||||
.owner = THIS_MODULE,\
|
||||
},\
|
||||
.conf = {\
|
||||
.reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
|
||||
.sel_mask = (1 << 4),\
|
||||
.en_mask = 1,\
|
||||
},\
|
||||
.volt = {\
|
||||
.reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
|
||||
.reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
|
||||
.sl_shift = 7,\
|
||||
.v_mask = (1 << (vbits)) - 1,\
|
||||
.v_shift = (vbits),\
|
||||
},\
|
||||
}
|
||||
|
||||
#define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \
|
||||
{\
|
||||
.reg_desc = {\
|
||||
.name = #_id,\
|
||||
.ops = &da9055_buck_ops,\
|
||||
.type = REGULATOR_VOLTAGE,\
|
||||
.id = DA9055_ID_##_id,\
|
||||
.n_voltages = (max - min) / step + 1 + (voffset), \
|
||||
.enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
|
||||
.enable_mask = 1,\
|
||||
.min_uV = (min) * 1000,\
|
||||
.uV_step = (step) * 1000,\
|
||||
.linear_min_sel = (voffset),\
|
||||
.owner = THIS_MODULE,\
|
||||
},\
|
||||
.conf = {\
|
||||
.reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
|
||||
.sel_mask = (1 << 4),\
|
||||
.en_mask = 1,\
|
||||
},\
|
||||
.volt = {\
|
||||
.reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
|
||||
.reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
|
||||
.sl_shift = 7,\
|
||||
.v_mask = (1 << (vbits)) - 1,\
|
||||
.v_shift = (vbits),\
|
||||
},\
|
||||
.mode = {\
|
||||
.reg = DA9055_REG_BCORE_MODE,\
|
||||
.mask = (mbits),\
|
||||
.shift = (sbits),\
|
||||
},\
|
||||
}
|
||||
|
||||
static struct da9055_regulator_info da9055_regulator_info[] = {
|
||||
DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2),
|
||||
DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0),
|
||||
DA9055_LDO(LDO1, 50, 900, 3300, 6, 2),
|
||||
DA9055_LDO(LDO2, 50, 900, 3300, 6, 3),
|
||||
DA9055_LDO(LDO3, 50, 900, 3300, 6, 2),
|
||||
DA9055_LDO(LDO4, 50, 900, 3300, 6, 2),
|
||||
DA9055_LDO(LDO5, 50, 900, 2750, 6, 2),
|
||||
DA9055_LDO(LDO6, 20, 900, 3300, 7, 0),
|
||||
};
|
||||
|
||||
/*
|
||||
* Configures regulator to be controlled either through GPIO 1 or 2.
|
||||
* GPIO can control regulator state and/or select the regulator register
|
||||
* set A/B for voltage ramping.
|
||||
*/
|
||||
static __devinit int da9055_gpio_init(struct da9055_regulator *regulator,
|
||||
struct regulator_config *config,
|
||||
struct da9055_pdata *pdata, int id)
|
||||
{
|
||||
struct da9055_regulator_info *info = regulator->info;
|
||||
int ret = 0;
|
||||
|
||||
if (pdata->gpio_ren && pdata->gpio_ren[id]) {
|
||||
char name[18];
|
||||
int gpio_mux = pdata->gpio_ren[id];
|
||||
|
||||
config->ena_gpio = pdata->ena_gpio[id];
|
||||
config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
|
||||
config->ena_gpio_invert = 1;
|
||||
|
||||
/*
|
||||
* GPI pin is muxed with regulator to control the
|
||||
* regulator state.
|
||||
*/
|
||||
sprintf(name, "DA9055 GPI %d", gpio_mux);
|
||||
ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
|
||||
name);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* Let the regulator know that its state is controlled
|
||||
* through GPI.
|
||||
*/
|
||||
ret = da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
DA9055_E_GPI_MASK,
|
||||
pdata->reg_ren[id]
|
||||
<< DA9055_E_GPI_SHIFT);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (pdata->gpio_rsel && pdata->gpio_rsel[id]) {
|
||||
char name[18];
|
||||
int gpio_mux = pdata->gpio_rsel[id];
|
||||
|
||||
regulator->reg_rselect = pdata->reg_rsel[id];
|
||||
|
||||
/*
|
||||
* GPI pin is muxed with regulator to select the
|
||||
* regulator register set A/B for voltage ramping.
|
||||
*/
|
||||
sprintf(name, "DA9055 GPI %d", gpio_mux);
|
||||
ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
|
||||
name);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* Let the regulator know that its register set A/B
|
||||
* will be selected through GPI for voltage ramping.
|
||||
*/
|
||||
ret = da9055_reg_update(regulator->da9055, info->conf.reg,
|
||||
DA9055_V_GPI_MASK,
|
||||
pdata->reg_rsel[id]
|
||||
<< DA9055_V_GPI_SHIFT);
|
||||
}
|
||||
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data)
|
||||
{
|
||||
struct da9055_regulator *regulator = data;
|
||||
|
||||
regulator_notifier_call_chain(regulator->rdev,
|
||||
REGULATOR_EVENT_OVER_CURRENT, NULL);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static inline struct da9055_regulator_info *find_regulator_info(int id)
|
||||
{
|
||||
struct da9055_regulator_info *info;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) {
|
||||
info = &da9055_regulator_info[i];
|
||||
if (info->reg_desc.id == id)
|
||||
return info;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int __devinit da9055_regulator_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct regulator_config config = { };
|
||||
struct da9055_regulator *regulator;
|
||||
struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
|
||||
struct da9055_pdata *pdata = da9055->dev->platform_data;
|
||||
int ret, irq;
|
||||
|
||||
if (pdata == NULL || pdata->regulators[pdev->id] == NULL)
|
||||
return -ENODEV;
|
||||
|
||||
regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
|
||||
GFP_KERNEL);
|
||||
if (!regulator)
|
||||
return -ENOMEM;
|
||||
|
||||
regulator->info = find_regulator_info(pdev->id);
|
||||
if (regulator->info == NULL) {
|
||||
dev_err(&pdev->dev, "invalid regulator ID specified\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
regulator->da9055 = da9055;
|
||||
config.dev = &pdev->dev;
|
||||
config.driver_data = regulator;
|
||||
config.regmap = da9055->regmap;
|
||||
|
||||
if (pdata && pdata->regulators)
|
||||
config.init_data = pdata->regulators[pdev->id];
|
||||
|
||||
ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
regulator->rdev = regulator_register(®ulator->info->reg_desc,
|
||||
&config);
|
||||
if (IS_ERR(regulator->rdev)) {
|
||||
dev_err(&pdev->dev, "Failed to register regulator %s\n",
|
||||
regulator->info->reg_desc.name);
|
||||
ret = PTR_ERR(regulator->rdev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Only LDO 5 and 6 has got the over current interrupt */
|
||||
if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) {
|
||||
irq = platform_get_irq_byname(pdev, "REGULATOR");
|
||||
irq = regmap_irq_get_virq(da9055->irq_data, irq);
|
||||
ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
|
||||
da9055_ldo5_6_oc_irq,
|
||||
IRQF_TRIGGER_HIGH |
|
||||
IRQF_ONESHOT |
|
||||
IRQF_PROBE_SHARED,
|
||||
pdev->name, regulator);
|
||||
if (ret != 0) {
|
||||
if (ret != -EBUSY) {
|
||||
dev_err(&pdev->dev,
|
||||
"Failed to request Regulator IRQ %d: %d\n",
|
||||
irq, ret);
|
||||
goto err_regulator;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, regulator);
|
||||
|
||||
return 0;
|
||||
|
||||
err_regulator:
|
||||
regulator_unregister(regulator->rdev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __devexit da9055_regulator_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct da9055_regulator *regulator = platform_get_drvdata(pdev);
|
||||
|
||||
regulator_unregister(regulator->rdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver da9055_regulator_driver = {
|
||||
.probe = da9055_regulator_probe,
|
||||
.remove = __devexit_p(da9055_regulator_remove),
|
||||
.driver = {
|
||||
.name = "da9055-regulator",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init da9055_regulator_init(void)
|
||||
{
|
||||
return platform_driver_register(&da9055_regulator_driver);
|
||||
}
|
||||
subsys_initcall(da9055_regulator_init);
|
||||
|
||||
static void __exit da9055_regulator_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&da9055_regulator_driver);
|
||||
}
|
||||
module_exit(da9055_regulator_exit);
|
||||
|
||||
MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
|
||||
MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("platform:da9055-regulator");
|
||||
|
|
@ -436,44 +436,14 @@ static int palmas_is_enabled_ldo(struct regulator_dev *dev)
|
|||
return !!(reg);
|
||||
}
|
||||
|
||||
static int palmas_list_voltage_ldo(struct regulator_dev *dev,
|
||||
unsigned selector)
|
||||
{
|
||||
if (!selector)
|
||||
return 0;
|
||||
|
||||
/* voltage is 0.85V + (selector * 0.05v) */
|
||||
return 850000 + (selector * 50000);
|
||||
}
|
||||
|
||||
static int palmas_map_voltage_ldo(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV)
|
||||
{
|
||||
int ret, voltage;
|
||||
|
||||
if (min_uV == 0)
|
||||
return 0;
|
||||
|
||||
if (min_uV < 900000)
|
||||
min_uV = 900000;
|
||||
ret = DIV_ROUND_UP(min_uV - 900000, 50000) + 1;
|
||||
|
||||
/* Map back into a voltage to verify we're still in bounds */
|
||||
voltage = palmas_list_voltage_ldo(rdev, ret);
|
||||
if (voltage < min_uV || voltage > max_uV)
|
||||
return -EINVAL;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct regulator_ops palmas_ops_ldo = {
|
||||
.is_enabled = palmas_is_enabled_ldo,
|
||||
.enable = regulator_enable_regmap,
|
||||
.disable = regulator_disable_regmap,
|
||||
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
||||
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
||||
.list_voltage = palmas_list_voltage_ldo,
|
||||
.map_voltage = palmas_map_voltage_ldo,
|
||||
.list_voltage = regulator_list_voltage_linear,
|
||||
.map_voltage = regulator_map_voltage_linear,
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -821,6 +791,9 @@ static __devinit int palmas_probe(struct platform_device *pdev)
|
|||
|
||||
pmic->desc[id].type = REGULATOR_VOLTAGE;
|
||||
pmic->desc[id].owner = THIS_MODULE;
|
||||
pmic->desc[id].min_uV = 900000;
|
||||
pmic->desc[id].uV_step = 50000;
|
||||
pmic->desc[id].linear_min_sel = 1;
|
||||
pmic->desc[id].vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
|
||||
palmas_regs_info[id].vsel_addr);
|
||||
pmic->desc[id].vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK;
|
||||
|
|
|
|||
|
|
@ -24,12 +24,15 @@
|
|||
#include <linux/mfd/pcf50633/core.h>
|
||||
#include <linux/mfd/pcf50633/pmic.h>
|
||||
|
||||
#define PCF50633_REGULATOR(_name, _id, _n) \
|
||||
#define PCF50633_REGULATOR(_name, _id, _min_uV, _uV_step, _min_sel, _n) \
|
||||
{ \
|
||||
.name = _name, \
|
||||
.id = PCF50633_REGULATOR_##_id, \
|
||||
.ops = &pcf50633_regulator_ops, \
|
||||
.n_voltages = _n, \
|
||||
.min_uV = _min_uV, \
|
||||
.uV_step = _uV_step, \
|
||||
.linear_min_sel = _min_sel, \
|
||||
.type = REGULATOR_VOLTAGE, \
|
||||
.owner = THIS_MODULE, \
|
||||
.vsel_reg = PCF50633_REG_##_id##OUT, \
|
||||
|
|
@ -38,162 +41,39 @@
|
|||
.enable_mask = PCF50633_REGULATOR_ON, \
|
||||
}
|
||||
|
||||
/* Bits from voltage value */
|
||||
static u8 auto_voltage_bits(unsigned int millivolts)
|
||||
{
|
||||
if (millivolts < 1800)
|
||||
return 0x2f;
|
||||
if (millivolts > 3800)
|
||||
return 0xff;
|
||||
|
||||
millivolts -= 625;
|
||||
|
||||
return millivolts / 25;
|
||||
}
|
||||
|
||||
static u8 down_voltage_bits(unsigned int millivolts)
|
||||
{
|
||||
if (millivolts < 625)
|
||||
return 0;
|
||||
else if (millivolts > 3000)
|
||||
return 0xff;
|
||||
|
||||
millivolts -= 625;
|
||||
|
||||
return millivolts / 25;
|
||||
}
|
||||
|
||||
static u8 ldo_voltage_bits(unsigned int millivolts)
|
||||
{
|
||||
if (millivolts < 900)
|
||||
return 0;
|
||||
else if (millivolts > 3600)
|
||||
return 0x1f;
|
||||
|
||||
millivolts -= 900;
|
||||
return millivolts / 100;
|
||||
}
|
||||
|
||||
/* Obtain voltage value from bits */
|
||||
static unsigned int auto_voltage_value(u8 bits)
|
||||
{
|
||||
/* AUTOOUT: 00000000 to 00101110 are reserved.
|
||||
* Return 0 for bits in reserved range, which means this selector code
|
||||
* can't be used on this system */
|
||||
if (bits < 0x2f)
|
||||
return 0;
|
||||
|
||||
return 625 + (bits * 25);
|
||||
}
|
||||
|
||||
|
||||
static unsigned int down_voltage_value(u8 bits)
|
||||
{
|
||||
return 625 + (bits * 25);
|
||||
}
|
||||
|
||||
|
||||
static unsigned int ldo_voltage_value(u8 bits)
|
||||
{
|
||||
bits &= 0x1f;
|
||||
|
||||
return 900 + (bits * 100);
|
||||
}
|
||||
|
||||
static int pcf50633_regulator_map_voltage(struct regulator_dev *rdev,
|
||||
int min_uV, int max_uV)
|
||||
{
|
||||
struct pcf50633 *pcf;
|
||||
int regulator_id, millivolts;
|
||||
u8 volt_bits;
|
||||
|
||||
pcf = rdev_get_drvdata(rdev);
|
||||
|
||||
regulator_id = rdev_get_id(rdev);
|
||||
if (regulator_id >= PCF50633_NUM_REGULATORS)
|
||||
return -EINVAL;
|
||||
|
||||
millivolts = min_uV / 1000;
|
||||
|
||||
switch (regulator_id) {
|
||||
case PCF50633_REGULATOR_AUTO:
|
||||
volt_bits = auto_voltage_bits(millivolts);
|
||||
break;
|
||||
case PCF50633_REGULATOR_DOWN1:
|
||||
case PCF50633_REGULATOR_DOWN2:
|
||||
volt_bits = down_voltage_bits(millivolts);
|
||||
break;
|
||||
case PCF50633_REGULATOR_LDO1:
|
||||
case PCF50633_REGULATOR_LDO2:
|
||||
case PCF50633_REGULATOR_LDO3:
|
||||
case PCF50633_REGULATOR_LDO4:
|
||||
case PCF50633_REGULATOR_LDO5:
|
||||
case PCF50633_REGULATOR_LDO6:
|
||||
case PCF50633_REGULATOR_HCLDO:
|
||||
case PCF50633_REGULATOR_MEMLDO:
|
||||
volt_bits = ldo_voltage_bits(millivolts);
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return volt_bits;
|
||||
}
|
||||
|
||||
static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
|
||||
unsigned int index)
|
||||
{
|
||||
int regulator_id = rdev_get_id(rdev);
|
||||
|
||||
int millivolts;
|
||||
|
||||
switch (regulator_id) {
|
||||
case PCF50633_REGULATOR_AUTO:
|
||||
millivolts = auto_voltage_value(index);
|
||||
break;
|
||||
case PCF50633_REGULATOR_DOWN1:
|
||||
case PCF50633_REGULATOR_DOWN2:
|
||||
millivolts = down_voltage_value(index);
|
||||
break;
|
||||
case PCF50633_REGULATOR_LDO1:
|
||||
case PCF50633_REGULATOR_LDO2:
|
||||
case PCF50633_REGULATOR_LDO3:
|
||||
case PCF50633_REGULATOR_LDO4:
|
||||
case PCF50633_REGULATOR_LDO5:
|
||||
case PCF50633_REGULATOR_LDO6:
|
||||
case PCF50633_REGULATOR_HCLDO:
|
||||
case PCF50633_REGULATOR_MEMLDO:
|
||||
millivolts = ldo_voltage_value(index);
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return millivolts * 1000;
|
||||
}
|
||||
|
||||
static struct regulator_ops pcf50633_regulator_ops = {
|
||||
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
||||
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
||||
.list_voltage = pcf50633_regulator_list_voltage,
|
||||
.map_voltage = pcf50633_regulator_map_voltage,
|
||||
.list_voltage = regulator_list_voltage_linear,
|
||||
.map_voltage = regulator_map_voltage_linear,
|
||||
.enable = regulator_enable_regmap,
|
||||
.disable = regulator_disable_regmap,
|
||||
.is_enabled = regulator_is_enabled_regmap,
|
||||
};
|
||||
|
||||
static const struct regulator_desc regulators[] = {
|
||||
[PCF50633_REGULATOR_AUTO] = PCF50633_REGULATOR("auto", AUTO, 128),
|
||||
[PCF50633_REGULATOR_DOWN1] = PCF50633_REGULATOR("down1", DOWN1, 96),
|
||||
[PCF50633_REGULATOR_DOWN2] = PCF50633_REGULATOR("down2", DOWN2, 96),
|
||||
[PCF50633_REGULATOR_LDO1] = PCF50633_REGULATOR("ldo1", LDO1, 28),
|
||||
[PCF50633_REGULATOR_LDO2] = PCF50633_REGULATOR("ldo2", LDO2, 28),
|
||||
[PCF50633_REGULATOR_LDO3] = PCF50633_REGULATOR("ldo3", LDO3, 28),
|
||||
[PCF50633_REGULATOR_LDO4] = PCF50633_REGULATOR("ldo4", LDO4, 28),
|
||||
[PCF50633_REGULATOR_LDO5] = PCF50633_REGULATOR("ldo5", LDO5, 28),
|
||||
[PCF50633_REGULATOR_LDO6] = PCF50633_REGULATOR("ldo6", LDO6, 28),
|
||||
[PCF50633_REGULATOR_HCLDO] = PCF50633_REGULATOR("hcldo", HCLDO, 28),
|
||||
[PCF50633_REGULATOR_MEMLDO] = PCF50633_REGULATOR("memldo", MEMLDO, 28),
|
||||
[PCF50633_REGULATOR_AUTO] =
|
||||
PCF50633_REGULATOR("auto", AUTO, 1800000, 25000, 0x2f, 128),
|
||||
[PCF50633_REGULATOR_DOWN1] =
|
||||
PCF50633_REGULATOR("down1", DOWN1, 625000, 25000, 0, 96),
|
||||
[PCF50633_REGULATOR_DOWN2] =
|
||||
PCF50633_REGULATOR("down2", DOWN2, 625000, 25000, 0, 96),
|
||||
[PCF50633_REGULATOR_LDO1] =
|
||||
PCF50633_REGULATOR("ldo1", LDO1, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_LDO2] =
|
||||
PCF50633_REGULATOR("ldo2", LDO2, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_LDO3] =
|
||||
PCF50633_REGULATOR("ldo3", LDO3, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_LDO4] =
|
||||
PCF50633_REGULATOR("ldo4", LDO4, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_LDO5] =
|
||||
PCF50633_REGULATOR("ldo5", LDO5, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_LDO6] =
|
||||
PCF50633_REGULATOR("ldo6", LDO6, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_HCLDO] =
|
||||
PCF50633_REGULATOR("hcldo", HCLDO, 900000, 100000, 0, 28),
|
||||
[PCF50633_REGULATOR_MEMLDO] =
|
||||
PCF50633_REGULATOR("memldo", MEMLDO, 900000, 100000, 0, 28),
|
||||
};
|
||||
|
||||
static int __devinit pcf50633_regulator_probe(struct platform_device *pdev)
|
||||
|
|
|
|||
327
drivers/regulator/tps51632-regulator.c
Normal file
327
drivers/regulator/tps51632-regulator.c
Normal file
|
|
@ -0,0 +1,327 @@
|
|||
/*
|
||||
* tps51632-regulator.c -- TI TPS51632
|
||||
*
|
||||
* Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
|
||||
* Controller with serial VID control and DVFS.
|
||||
*
|
||||
* Copyright (c) 2012, NVIDIA Corporation.
|
||||
*
|
||||
* Author: Laxman Dewangan <ldewangan@nvidia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
|
||||
* whether express or implied; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
* 02111-1307, USA
|
||||
*/
|
||||
|
||||
#include <linux/err.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/regulator/driver.h>
|
||||
#include <linux/regulator/machine.h>
|
||||
#include <linux/regulator/tps51632-regulator.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
/* Register definitions */
|
||||
#define TPS51632_VOLTAGE_SELECT_REG 0x0
|
||||
#define TPS51632_VOLTAGE_BASE_REG 0x1
|
||||
#define TPS51632_OFFSET_REG 0x2
|
||||
#define TPS51632_IMON_REG 0x3
|
||||
#define TPS51632_VMAX_REG 0x4
|
||||
#define TPS51632_DVFS_CONTROL_REG 0x5
|
||||
#define TPS51632_POWER_STATE_REG 0x6
|
||||
#define TPS51632_SLEW_REGS 0x7
|
||||
#define TPS51632_FAULT_REG 0x14
|
||||
|
||||
#define TPS51632_MAX_REG 0x15
|
||||
|
||||
#define TPS51632_VOUT_MASK 0x7F
|
||||
#define TPS51632_VOUT_OFFSET_MASK 0x1F
|
||||
#define TPS51632_VMAX_MASK 0x7F
|
||||
#define TPS51632_VMAX_LOCK 0x80
|
||||
|
||||
/* TPS51632_DVFS_CONTROL_REG */
|
||||
#define TPS51632_DVFS_PWMEN 0x1
|
||||
#define TPS51632_DVFS_STEP_20 0x2
|
||||
#define TPS51632_DVFS_VMAX_PG 0x4
|
||||
#define TPS51632_DVFS_PWMRST 0x8
|
||||
#define TPS51632_DVFS_OCA_EN 0x10
|
||||
#define TPS51632_DVFS_FCCM 0x20
|
||||
|
||||
/* TPS51632_POWER_STATE_REG */
|
||||
#define TPS51632_POWER_STATE_MASK 0x03
|
||||
#define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0
|
||||
#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
|
||||
#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
|
||||
|
||||
#define TPS51632_MIN_VOLATGE 500000
|
||||
#define TPS51632_MAX_VOLATGE 1520000
|
||||
#define TPS51632_VOLATGE_STEP_10mV 10000
|
||||
#define TPS51632_VOLATGE_STEP_20mV 20000
|
||||
#define TPS51632_MAX_VSEL 0x7F
|
||||
#define TPS51632_MIN_VSEL 0x19
|
||||
#define TPS51632_DEFAULT_RAMP_DELAY 6000
|
||||
#define TPS51632_VOLT_VSEL(uV) \
|
||||
(DIV_ROUND_UP(uV - TPS51632_MIN_VOLATGE, \
|
||||
TPS51632_VOLATGE_STEP_10mV) + \
|
||||
TPS51632_MIN_VSEL)
|
||||
|
||||
/* TPS51632 chip information */
|
||||
struct tps51632_chip {
|
||||
struct device *dev;
|
||||
struct regulator_desc desc;
|
||||
struct regulator_dev *rdev;
|
||||
struct regmap *regmap;
|
||||
bool enable_pwm_dvfs;
|
||||
};
|
||||
|
||||
static int tps51632_dcdc_get_voltage_sel(struct regulator_dev *rdev)
|
||||
{
|
||||
struct tps51632_chip *tps = rdev_get_drvdata(rdev);
|
||||
unsigned int data;
|
||||
int ret;
|
||||
unsigned int reg = TPS51632_VOLTAGE_SELECT_REG;
|
||||
int vsel;
|
||||
|
||||
if (tps->enable_pwm_dvfs)
|
||||
reg = TPS51632_VOLTAGE_BASE_REG;
|
||||
|
||||
ret = regmap_read(tps->regmap, reg, &data);
|
||||
if (ret < 0) {
|
||||
dev_err(tps->dev, "reg read failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
vsel = data & TPS51632_VOUT_MASK;
|
||||
return vsel;
|
||||
}
|
||||
|
||||
static int tps51632_dcdc_set_voltage_sel(struct regulator_dev *rdev,
|
||||
unsigned selector)
|
||||
{
|
||||
struct tps51632_chip *tps = rdev_get_drvdata(rdev);
|
||||
int ret;
|
||||
unsigned int reg = TPS51632_VOLTAGE_SELECT_REG;
|
||||
|
||||
if (tps->enable_pwm_dvfs)
|
||||
reg = TPS51632_VOLTAGE_BASE_REG;
|
||||
|
||||
if (selector > TPS51632_MAX_VSEL)
|
||||
return -EINVAL;
|
||||
|
||||
ret = regmap_write(tps->regmap, reg, selector);
|
||||
if (ret < 0)
|
||||
dev_err(tps->dev, "reg write failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
|
||||
int ramp_delay)
|
||||
{
|
||||
struct tps51632_chip *tps = rdev_get_drvdata(rdev);
|
||||
int bit = ramp_delay/6000;
|
||||
int ret;
|
||||
|
||||
if (bit)
|
||||
bit--;
|
||||
ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
|
||||
if (ret < 0)
|
||||
dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct regulator_ops tps51632_dcdc_ops = {
|
||||
.get_voltage_sel = tps51632_dcdc_get_voltage_sel,
|
||||
.set_voltage_sel = tps51632_dcdc_set_voltage_sel,
|
||||
.list_voltage = regulator_list_voltage_linear,
|
||||
.set_voltage_time_sel = regulator_set_voltage_time_sel,
|
||||
.set_ramp_delay = tps51632_dcdc_set_ramp_delay,
|
||||
};
|
||||
|
||||
static int __devinit tps51632_init_dcdc(struct tps51632_chip *tps,
|
||||
struct tps51632_regulator_platform_data *pdata)
|
||||
{
|
||||
int ret;
|
||||
uint8_t control = 0;
|
||||
int vsel;
|
||||
|
||||
if (!pdata->enable_pwm_dvfs)
|
||||
goto skip_pwm_config;
|
||||
|
||||
control |= TPS51632_DVFS_PWMEN;
|
||||
tps->enable_pwm_dvfs = pdata->enable_pwm_dvfs;
|
||||
vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
|
||||
ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
|
||||
if (ret < 0) {
|
||||
dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (pdata->dvfs_step_20mV)
|
||||
control |= TPS51632_DVFS_STEP_20;
|
||||
|
||||
if (pdata->max_voltage_uV) {
|
||||
unsigned int vmax;
|
||||
/**
|
||||
* TPS51632 hw behavior: VMAX register can be write only
|
||||
* once as it get locked after first write. The lock get
|
||||
* reset only when device is power-reset.
|
||||
* Write register only when lock bit is not enabled.
|
||||
*/
|
||||
ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
|
||||
if (ret < 0) {
|
||||
dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
if (!(vmax & TPS51632_VMAX_LOCK)) {
|
||||
vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
|
||||
ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
|
||||
vsel);
|
||||
if (ret < 0) {
|
||||
dev_err(tps->dev,
|
||||
"VMAX write failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
skip_pwm_config:
|
||||
ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
|
||||
if (ret < 0)
|
||||
dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool rd_wr_reg(struct device *dev, unsigned int reg)
|
||||
{
|
||||
if ((reg >= 0x8) && (reg <= 0x10))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static const struct regmap_config tps51632_regmap_config = {
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
.writeable_reg = rd_wr_reg,
|
||||
.readable_reg = rd_wr_reg,
|
||||
.max_register = TPS51632_MAX_REG - 1,
|
||||
.cache_type = REGCACHE_RBTREE,
|
||||
};
|
||||
|
||||
static int __devinit tps51632_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct tps51632_regulator_platform_data *pdata;
|
||||
struct regulator_dev *rdev;
|
||||
struct tps51632_chip *tps;
|
||||
int ret;
|
||||
struct regulator_config config = { };
|
||||
|
||||
pdata = client->dev.platform_data;
|
||||
if (!pdata) {
|
||||
dev_err(&client->dev, "No Platform data\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
|
||||
if (!tps) {
|
||||
dev_err(&client->dev, "Memory allocation failed\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
tps->dev = &client->dev;
|
||||
tps->desc.name = id->name;
|
||||
tps->desc.id = 0;
|
||||
tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
|
||||
tps->desc.min_uV = TPS51632_MIN_VOLATGE;
|
||||
tps->desc.uV_step = TPS51632_VOLATGE_STEP_10mV;
|
||||
tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
|
||||
tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
|
||||
tps->desc.ops = &tps51632_dcdc_ops;
|
||||
tps->desc.type = REGULATOR_VOLTAGE;
|
||||
tps->desc.owner = THIS_MODULE;
|
||||
|
||||
tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
|
||||
if (IS_ERR(tps->regmap)) {
|
||||
ret = PTR_ERR(tps->regmap);
|
||||
dev_err(&client->dev, "regmap init failed, err %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
i2c_set_clientdata(client, tps);
|
||||
|
||||
ret = tps51632_init_dcdc(tps, pdata);
|
||||
if (ret < 0) {
|
||||
dev_err(tps->dev, "Init failed, err = %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Register the regulators */
|
||||
config.dev = &client->dev;
|
||||
config.init_data = pdata->reg_init_data;
|
||||
config.driver_data = tps;
|
||||
config.regmap = tps->regmap;
|
||||
config.of_node = client->dev.of_node;
|
||||
|
||||
rdev = regulator_register(&tps->desc, &config);
|
||||
if (IS_ERR(rdev)) {
|
||||
dev_err(tps->dev, "regulator register failed\n");
|
||||
return PTR_ERR(rdev);
|
||||
}
|
||||
|
||||
tps->rdev = rdev;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __devexit tps51632_remove(struct i2c_client *client)
|
||||
{
|
||||
struct tps51632_chip *tps = i2c_get_clientdata(client);
|
||||
|
||||
regulator_unregister(tps->rdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct i2c_device_id tps51632_id[] = {
|
||||
{.name = "tps51632",},
|
||||
{},
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(i2c, tps51632_id);
|
||||
|
||||
static struct i2c_driver tps51632_i2c_driver = {
|
||||
.driver = {
|
||||
.name = "tps51632",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.probe = tps51632_probe,
|
||||
.remove = __devexit_p(tps51632_remove),
|
||||
.id_table = tps51632_id,
|
||||
};
|
||||
|
||||
static int __init tps51632_init(void)
|
||||
{
|
||||
return i2c_add_driver(&tps51632_i2c_driver);
|
||||
}
|
||||
subsys_initcall(tps51632_init);
|
||||
|
||||
static void __exit tps51632_cleanup(void)
|
||||
{
|
||||
i2c_del_driver(&tps51632_i2c_driver);
|
||||
}
|
||||
module_exit(tps51632_cleanup);
|
||||
|
||||
MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
|
||||
MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
@ -25,8 +25,29 @@ struct da9055_pdata {
|
|||
int gpio_base;
|
||||
|
||||
struct regulator_init_data *regulators[DA9055_MAX_REGULATORS];
|
||||
bool reset_enable; /* Enable RTC in RESET Mode */
|
||||
enum gpio_select *gpio_rsel; /* Select regulator set thru GPIO 1/2 */
|
||||
enum gpio_select *gpio_ren; /* Enable regulator thru GPIO 1/2 */
|
||||
/* Enable RTC in RESET Mode */
|
||||
bool reset_enable;
|
||||
/*
|
||||
* GPI muxed pin to control
|
||||
* regulator state A/B, 0 if not available.
|
||||
*/
|
||||
int *gpio_ren;
|
||||
/*
|
||||
* GPI muxed pin to control
|
||||
* regulator set, 0 if not available.
|
||||
*/
|
||||
int *gpio_rsel;
|
||||
/*
|
||||
* Regulator mode control bits value (GPI offset) that
|
||||
* that controls the regulator state, 0 if not available.
|
||||
*/
|
||||
enum gpio_select *reg_ren;
|
||||
/*
|
||||
* Regulator mode control bits value (GPI offset) that
|
||||
* controls the regulator set A/B, 0 if not available.
|
||||
*/
|
||||
enum gpio_select *reg_rsel;
|
||||
/* GPIOs to enable regulator, 0 if not available */
|
||||
int *ena_gpio;
|
||||
};
|
||||
#endif /* __DA9055_PDATA_H */
|
||||
|
|
|
|||
|
|
@ -185,6 +185,7 @@ enum regulator_type {
|
|||
*
|
||||
* @min_uV: Voltage given by the lowest selector (if linear mapping)
|
||||
* @uV_step: Voltage increase with each selector (if linear mapping)
|
||||
* @linear_min_sel: Minimal selector for starting linear mapping
|
||||
* @ramp_delay: Time to settle down after voltage change (unit: uV/us)
|
||||
* @volt_table: Voltage mapping table (if table based mapping)
|
||||
*
|
||||
|
|
@ -207,6 +208,7 @@ struct regulator_desc {
|
|||
|
||||
unsigned int min_uV;
|
||||
unsigned int uV_step;
|
||||
unsigned int linear_min_sel;
|
||||
unsigned int ramp_delay;
|
||||
|
||||
const unsigned int *volt_table;
|
||||
|
|
|
|||
47
include/linux/regulator/tps51632-regulator.h
Normal file
47
include/linux/regulator/tps51632-regulator.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*
|
||||
* tps51632-regulator.h -- TPS51632 regulator
|
||||
*
|
||||
* Interface for regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down
|
||||
* Driverless Controller with serial VID control and DVFS.
|
||||
*
|
||||
* Copyright (C) 2012 NVIDIA Corporation
|
||||
|
||||
* Author: Laxman Dewangan <ldewangan@nvidia.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_REGULATOR_TPS51632_H
|
||||
#define __LINUX_REGULATOR_TPS51632_H
|
||||
|
||||
/*
|
||||
* struct tps51632_regulator_platform_data - tps51632 regulator platform data.
|
||||
*
|
||||
* @reg_init_data: The regulator init data.
|
||||
* @enable_pwm_dvfs: Enable PWM DVFS or not.
|
||||
* @dvfs_step_20mV: Step for DVFS is 20mV or 10mV.
|
||||
* @max_voltage_uV: Maximum possible voltage in PWM-DVFS mode.
|
||||
* @base_voltage_uV: Base voltage when PWM-DVFS enabled.
|
||||
*/
|
||||
struct tps51632_regulator_platform_data {
|
||||
struct regulator_init_data *reg_init_data;
|
||||
bool enable_pwm_dvfs;
|
||||
bool dvfs_step_20mV;
|
||||
int max_voltage_uV;
|
||||
int base_voltage_uV;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_REGULATOR_TPS51632_H */
|
||||
Loading…
Reference in a new issue