389 lines
10 KiB
C
389 lines
10 KiB
C
/*
|
|
* 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/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/regmap.h>
|
|
#include <linux/regulator/driver.h>
|
|
#include <linux/regulator/machine.h>
|
|
#include <linux/regulator/of_regulator.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_VOLTAGE 500000
|
|
#define TPS51632_MAX_VOLTAGE 1520000
|
|
#define TPS51632_VOLTAGE_STEP_10mV 10000
|
|
#define TPS51632_VOLTAGE_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_VOLTAGE, \
|
|
TPS51632_VOLTAGE_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;
|
|
};
|
|
|
|
static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
|
|
int ramp_delay)
|
|
{
|
|
struct tps51632_chip *tps = rdev_get_drvdata(rdev);
|
|
int bit;
|
|
int ret;
|
|
|
|
if (ramp_delay == 0)
|
|
bit = 0;
|
|
else
|
|
bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;
|
|
|
|
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 = regulator_get_voltage_sel_regmap,
|
|
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
|
.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 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;
|
|
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 is_volatile_reg(struct device *dev, unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case TPS51632_OFFSET_REG:
|
|
case TPS51632_FAULT_REG:
|
|
case TPS51632_IMON_REG:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool is_read_reg(struct device *dev, unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case 0x08 ... 0x0F:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool is_write_reg(struct device *dev, unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case TPS51632_VOLTAGE_SELECT_REG:
|
|
case TPS51632_VOLTAGE_BASE_REG:
|
|
case TPS51632_VMAX_REG:
|
|
case TPS51632_DVFS_CONTROL_REG:
|
|
case TPS51632_POWER_STATE_REG:
|
|
case TPS51632_SLEW_REGS:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static const struct regmap_config tps51632_regmap_config = {
|
|
.reg_bits = 8,
|
|
.val_bits = 8,
|
|
.writeable_reg = is_write_reg,
|
|
.readable_reg = is_read_reg,
|
|
.volatile_reg = is_volatile_reg,
|
|
.max_register = TPS51632_MAX_REG - 1,
|
|
.cache_type = REGCACHE_RBTREE,
|
|
};
|
|
|
|
#if defined(CONFIG_OF)
|
|
static const struct of_device_id tps51632_of_match[] = {
|
|
{ .compatible = "ti,tps51632",},
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, tps51632_of_match);
|
|
|
|
static struct tps51632_regulator_platform_data *
|
|
of_get_tps51632_platform_data(struct device *dev,
|
|
const struct regulator_desc *desc)
|
|
{
|
|
struct tps51632_regulator_platform_data *pdata;
|
|
struct device_node *np = dev->of_node;
|
|
|
|
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
|
|
if (!pdata)
|
|
return NULL;
|
|
|
|
pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
|
|
desc);
|
|
if (!pdata->reg_init_data) {
|
|
dev_err(dev, "Not able to get OF regulator init data\n");
|
|
return NULL;
|
|
}
|
|
|
|
pdata->enable_pwm_dvfs =
|
|
of_property_read_bool(np, "ti,enable-pwm-dvfs");
|
|
pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
|
|
|
|
pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
|
|
TPS51632_MIN_VOLTAGE;
|
|
pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
|
|
TPS51632_MAX_VOLTAGE;
|
|
return pdata;
|
|
}
|
|
#else
|
|
static struct tps51632_regulator_platform_data *
|
|
of_get_tps51632_platform_data(struct device *dev,
|
|
const struct regulator_desc *desc)
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static int 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 = { };
|
|
|
|
if (client->dev.of_node) {
|
|
const struct of_device_id *match;
|
|
match = of_match_device(of_match_ptr(tps51632_of_match),
|
|
&client->dev);
|
|
if (!match) {
|
|
dev_err(&client->dev, "Error: No device match found\n");
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
|
|
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
|
|
if (!tps)
|
|
return -ENOMEM;
|
|
|
|
tps->dev = &client->dev;
|
|
tps->desc.name = client->name;
|
|
tps->desc.id = 0;
|
|
tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
|
|
tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
|
|
tps->desc.uV_step = TPS51632_VOLTAGE_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;
|
|
|
|
pdata = dev_get_platdata(&client->dev);
|
|
if (!pdata && client->dev.of_node)
|
|
pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
|
|
if (!pdata) {
|
|
dev_err(&client->dev, "No Platform data\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (pdata->enable_pwm_dvfs) {
|
|
if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
|
|
(pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
|
|
dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ((pdata->max_voltage_uV) &&
|
|
((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
|
|
(pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
|
|
dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
if (pdata->enable_pwm_dvfs)
|
|
tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
|
|
else
|
|
tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
|
|
tps->desc.vsel_mask = TPS51632_VOUT_MASK;
|
|
|
|
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 = devm_regulator_register(&client->dev, &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 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",
|
|
.of_match_table = of_match_ptr(tps51632_of_match),
|
|
},
|
|
.probe = tps51632_probe,
|
|
.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");
|