42dc30231b
This patch adds primitive DT support to the max8973 regulator driver. None of the configuration parameters, supported in the platform data are yet available in DT, therefore no configuration is performed if booting with no platform data. This means, that DT instantiation can only be used on boards, where no run-time configuration of the chip is required. In such cases the driver can be used to scale its output voltage. In the future support for configuration parameters should be added. Signed-off-by: Guennadi Liakhovetski <g.liakhovetski+renesas@gmail.com> Signed-off-by: Mark Brown <broonie@linaro.org>
521 lines
14 KiB
C
521 lines
14 KiB
C
/*
|
|
* max8973-regulator.c -- Maxim max8973
|
|
*
|
|
* Regulator driver for MAXIM 8973 DC-DC step-down switching regulator.
|
|
*
|
|
* 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/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/err.h>
|
|
#include <linux/of.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/regulator/driver.h>
|
|
#include <linux/regulator/machine.h>
|
|
#include <linux/regulator/max8973-regulator.h>
|
|
#include <linux/regulator/of_regulator.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/regmap.h>
|
|
|
|
/* Register definitions */
|
|
#define MAX8973_VOUT 0x0
|
|
#define MAX8973_VOUT_DVS 0x1
|
|
#define MAX8973_CONTROL1 0x2
|
|
#define MAX8973_CONTROL2 0x3
|
|
#define MAX8973_CHIPID1 0x4
|
|
#define MAX8973_CHIPID2 0x5
|
|
|
|
#define MAX8973_MAX_VOUT_REG 2
|
|
|
|
/* MAX8973_VOUT */
|
|
#define MAX8973_VOUT_ENABLE BIT(7)
|
|
#define MAX8973_VOUT_MASK 0x7F
|
|
|
|
/* MAX8973_VOUT_DVS */
|
|
#define MAX8973_DVS_VOUT_MASK 0x7F
|
|
|
|
/* MAX8973_CONTROL1 */
|
|
#define MAX8973_SNS_ENABLE BIT(7)
|
|
#define MAX8973_FPWM_EN_M BIT(6)
|
|
#define MAX8973_NFSR_ENABLE BIT(5)
|
|
#define MAX8973_AD_ENABLE BIT(4)
|
|
#define MAX8973_BIAS_ENABLE BIT(3)
|
|
#define MAX8973_FREQSHIFT_9PER BIT(2)
|
|
|
|
#define MAX8973_RAMP_12mV_PER_US 0x0
|
|
#define MAX8973_RAMP_25mV_PER_US 0x1
|
|
#define MAX8973_RAMP_50mV_PER_US 0x2
|
|
#define MAX8973_RAMP_200mV_PER_US 0x3
|
|
|
|
/* MAX8973_CONTROL2 */
|
|
#define MAX8973_WDTMR_ENABLE BIT(6)
|
|
#define MAX8973_DISCH_ENBABLE BIT(5)
|
|
#define MAX8973_FT_ENABLE BIT(4)
|
|
|
|
#define MAX8973_CKKADV_TRIP_DISABLE 0xC
|
|
#define MAX8973_CKKADV_TRIP_75mV_PER_US 0x0
|
|
#define MAX8973_CKKADV_TRIP_150mV_PER_US 0x4
|
|
#define MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS 0x8
|
|
#define MAX8973_CONTROL_CLKADV_TRIP_MASK 0x00030000
|
|
|
|
#define MAX8973_INDUCTOR_MIN_30_PER 0x0
|
|
#define MAX8973_INDUCTOR_NOMINAL 0x1
|
|
#define MAX8973_INDUCTOR_PLUS_30_PER 0x2
|
|
#define MAX8973_INDUCTOR_PLUS_60_PER 0x3
|
|
#define MAX8973_CONTROL_INDUCTOR_VALUE_MASK 0x00300000
|
|
|
|
#define MAX8973_MIN_VOLATGE 606250
|
|
#define MAX8973_MAX_VOLATGE 1400000
|
|
#define MAX8973_VOLATGE_STEP 6250
|
|
#define MAX8973_BUCK_N_VOLTAGE 0x80
|
|
|
|
/* Maxim 8973 chip information */
|
|
struct max8973_chip {
|
|
struct device *dev;
|
|
struct regulator_desc desc;
|
|
struct regulator_dev *rdev;
|
|
struct regmap *regmap;
|
|
bool enable_external_control;
|
|
int dvs_gpio;
|
|
int lru_index[MAX8973_MAX_VOUT_REG];
|
|
int curr_vout_val[MAX8973_MAX_VOUT_REG];
|
|
int curr_vout_reg;
|
|
int curr_gpio_val;
|
|
bool valid_dvs_gpio;
|
|
struct regulator_ops ops;
|
|
};
|
|
|
|
/*
|
|
* find_voltage_set_register: Find new voltage configuration register (VOUT).
|
|
* The finding of the new VOUT register will be based on the LRU mechanism.
|
|
* Each VOUT register will have different voltage configured . This
|
|
* Function will look if any of the VOUT register have requested voltage set
|
|
* or not.
|
|
* - If it is already there then it will make that register as most
|
|
* recently used and return as found so that caller need not to set
|
|
* the VOUT register but need to set the proper gpios to select this
|
|
* VOUT register.
|
|
* - If requested voltage is not found then it will use the least
|
|
* recently mechanism to get new VOUT register for new configuration
|
|
* and will return not_found so that caller need to set new VOUT
|
|
* register and then gpios (both).
|
|
*/
|
|
static bool find_voltage_set_register(struct max8973_chip *tps,
|
|
int req_vsel, int *vout_reg, int *gpio_val)
|
|
{
|
|
int i;
|
|
bool found = false;
|
|
int new_vout_reg = tps->lru_index[MAX8973_MAX_VOUT_REG - 1];
|
|
int found_index = MAX8973_MAX_VOUT_REG - 1;
|
|
|
|
for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) {
|
|
if (tps->curr_vout_val[tps->lru_index[i]] == req_vsel) {
|
|
new_vout_reg = tps->lru_index[i];
|
|
found_index = i;
|
|
found = true;
|
|
goto update_lru_index;
|
|
}
|
|
}
|
|
|
|
update_lru_index:
|
|
for (i = found_index; i > 0; i--)
|
|
tps->lru_index[i] = tps->lru_index[i - 1];
|
|
|
|
tps->lru_index[0] = new_vout_reg;
|
|
*gpio_val = new_vout_reg;
|
|
*vout_reg = MAX8973_VOUT + new_vout_reg;
|
|
return found;
|
|
}
|
|
|
|
static int max8973_dcdc_get_voltage_sel(struct regulator_dev *rdev)
|
|
{
|
|
struct max8973_chip *max = rdev_get_drvdata(rdev);
|
|
unsigned int data;
|
|
int ret;
|
|
|
|
ret = regmap_read(max->regmap, max->curr_vout_reg, &data);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "register %d read failed, err = %d\n",
|
|
max->curr_vout_reg, ret);
|
|
return ret;
|
|
}
|
|
return data & MAX8973_VOUT_MASK;
|
|
}
|
|
|
|
static int max8973_dcdc_set_voltage_sel(struct regulator_dev *rdev,
|
|
unsigned vsel)
|
|
{
|
|
struct max8973_chip *max = rdev_get_drvdata(rdev);
|
|
int ret;
|
|
bool found = false;
|
|
int vout_reg = max->curr_vout_reg;
|
|
int gpio_val = max->curr_gpio_val;
|
|
|
|
/*
|
|
* If gpios are available to select the VOUT register then least
|
|
* recently used register for new configuration.
|
|
*/
|
|
if (max->valid_dvs_gpio)
|
|
found = find_voltage_set_register(max, vsel,
|
|
&vout_reg, &gpio_val);
|
|
|
|
if (!found) {
|
|
ret = regmap_update_bits(max->regmap, vout_reg,
|
|
MAX8973_VOUT_MASK, vsel);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "register %d update failed, err %d\n",
|
|
vout_reg, ret);
|
|
return ret;
|
|
}
|
|
max->curr_vout_reg = vout_reg;
|
|
max->curr_vout_val[gpio_val] = vsel;
|
|
}
|
|
|
|
/* Select proper VOUT register vio gpios */
|
|
if (max->valid_dvs_gpio) {
|
|
gpio_set_value_cansleep(max->dvs_gpio, gpio_val & 0x1);
|
|
max->curr_gpio_val = gpio_val;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int max8973_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
|
|
{
|
|
struct max8973_chip *max = rdev_get_drvdata(rdev);
|
|
int ret;
|
|
int pwm;
|
|
|
|
/* Enable force PWM mode in FAST mode only. */
|
|
switch (mode) {
|
|
case REGULATOR_MODE_FAST:
|
|
pwm = MAX8973_FPWM_EN_M;
|
|
break;
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
pwm = 0;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = regmap_update_bits(max->regmap, MAX8973_CONTROL1,
|
|
MAX8973_FPWM_EN_M, pwm);
|
|
if (ret < 0)
|
|
dev_err(max->dev, "register %d update failed, err %d\n",
|
|
MAX8973_CONTROL1, ret);
|
|
return ret;
|
|
}
|
|
|
|
static unsigned int max8973_dcdc_get_mode(struct regulator_dev *rdev)
|
|
{
|
|
struct max8973_chip *max = rdev_get_drvdata(rdev);
|
|
unsigned int data;
|
|
int ret;
|
|
|
|
ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "register %d read failed, err %d\n",
|
|
MAX8973_CONTROL1, ret);
|
|
return ret;
|
|
}
|
|
return (data & MAX8973_FPWM_EN_M) ?
|
|
REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
|
|
}
|
|
|
|
static const struct regulator_ops max8973_dcdc_ops = {
|
|
.get_voltage_sel = max8973_dcdc_get_voltage_sel,
|
|
.set_voltage_sel = max8973_dcdc_set_voltage_sel,
|
|
.list_voltage = regulator_list_voltage_linear,
|
|
.set_mode = max8973_dcdc_set_mode,
|
|
.get_mode = max8973_dcdc_get_mode,
|
|
};
|
|
|
|
static int max8973_init_dcdc(struct max8973_chip *max,
|
|
struct max8973_regulator_platform_data *pdata)
|
|
{
|
|
int ret;
|
|
uint8_t control1 = 0;
|
|
uint8_t control2 = 0;
|
|
|
|
if (pdata->control_flags & MAX8973_CONTROL_REMOTE_SENSE_ENABLE)
|
|
control1 |= MAX8973_SNS_ENABLE;
|
|
|
|
if (!(pdata->control_flags & MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE))
|
|
control1 |= MAX8973_NFSR_ENABLE;
|
|
|
|
if (pdata->control_flags & MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE)
|
|
control1 |= MAX8973_AD_ENABLE;
|
|
|
|
if (pdata->control_flags & MAX8973_CONTROL_BIAS_ENABLE)
|
|
control1 |= MAX8973_BIAS_ENABLE;
|
|
|
|
if (pdata->control_flags & MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE)
|
|
control1 |= MAX8973_FREQSHIFT_9PER;
|
|
|
|
/* Set ramp delay */
|
|
if (pdata->reg_init_data &&
|
|
pdata->reg_init_data->constraints.ramp_delay) {
|
|
if (pdata->reg_init_data->constraints.ramp_delay < 25000)
|
|
control1 |= MAX8973_RAMP_12mV_PER_US;
|
|
else if (pdata->reg_init_data->constraints.ramp_delay < 50000)
|
|
control1 |= MAX8973_RAMP_25mV_PER_US;
|
|
else if (pdata->reg_init_data->constraints.ramp_delay < 200000)
|
|
control1 |= MAX8973_RAMP_50mV_PER_US;
|
|
else
|
|
control1 |= MAX8973_RAMP_200mV_PER_US;
|
|
} else {
|
|
control1 |= MAX8973_RAMP_12mV_PER_US;
|
|
max->desc.ramp_delay = 12500;
|
|
}
|
|
|
|
if (!(pdata->control_flags & MAX8973_CONTROL_PULL_DOWN_ENABLE))
|
|
control2 |= MAX8973_DISCH_ENBABLE;
|
|
|
|
/* Clock advance trip configuration */
|
|
switch (pdata->control_flags & MAX8973_CONTROL_CLKADV_TRIP_MASK) {
|
|
case MAX8973_CONTROL_CLKADV_TRIP_DISABLED:
|
|
control2 |= MAX8973_CKKADV_TRIP_DISABLE;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US:
|
|
control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US:
|
|
control2 |= MAX8973_CKKADV_TRIP_150mV_PER_US;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US_HIST_DIS:
|
|
control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS;
|
|
break;
|
|
}
|
|
|
|
/* Configure inductor value */
|
|
switch (pdata->control_flags & MAX8973_CONTROL_INDUCTOR_VALUE_MASK) {
|
|
case MAX8973_CONTROL_INDUCTOR_VALUE_NOMINAL:
|
|
control2 |= MAX8973_INDUCTOR_NOMINAL;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_INDUCTOR_VALUE_MINUS_30_PER:
|
|
control2 |= MAX8973_INDUCTOR_MIN_30_PER;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_30_PER:
|
|
control2 |= MAX8973_INDUCTOR_PLUS_30_PER;
|
|
break;
|
|
|
|
case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER:
|
|
control2 |= MAX8973_INDUCTOR_PLUS_60_PER;
|
|
break;
|
|
}
|
|
|
|
ret = regmap_write(max->regmap, MAX8973_CONTROL1, control1);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "register %d write failed, err = %d",
|
|
MAX8973_CONTROL1, ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = regmap_write(max->regmap, MAX8973_CONTROL2, control2);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "register %d write failed, err = %d",
|
|
MAX8973_CONTROL2, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* If external control is enabled then disable EN bit */
|
|
if (max->enable_external_control) {
|
|
ret = regmap_update_bits(max->regmap, MAX8973_VOUT,
|
|
MAX8973_VOUT_ENABLE, 0);
|
|
if (ret < 0)
|
|
dev_err(max->dev, "register %d update failed, err = %d",
|
|
MAX8973_VOUT, ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const struct regmap_config max8973_regmap_config = {
|
|
.reg_bits = 8,
|
|
.val_bits = 8,
|
|
.max_register = MAX8973_CHIPID2,
|
|
.cache_type = REGCACHE_RBTREE,
|
|
};
|
|
|
|
static int max8973_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct max8973_regulator_platform_data *pdata;
|
|
struct regulator_config config = { };
|
|
struct regulator_dev *rdev;
|
|
struct max8973_chip *max;
|
|
int ret;
|
|
|
|
pdata = client->dev.platform_data;
|
|
|
|
if (!pdata && !client->dev.of_node) {
|
|
dev_err(&client->dev, "No Platform data");
|
|
return -EIO;
|
|
}
|
|
|
|
max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL);
|
|
if (!max) {
|
|
dev_err(&client->dev, "Memory allocation for max failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config);
|
|
if (IS_ERR(max->regmap)) {
|
|
ret = PTR_ERR(max->regmap);
|
|
dev_err(&client->dev, "regmap init failed, err %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
i2c_set_clientdata(client, max);
|
|
max->ops = max8973_dcdc_ops;
|
|
max->dev = &client->dev;
|
|
max->desc.name = id->name;
|
|
max->desc.id = 0;
|
|
max->desc.ops = &max->ops;
|
|
max->desc.type = REGULATOR_VOLTAGE;
|
|
max->desc.owner = THIS_MODULE;
|
|
max->desc.min_uV = MAX8973_MIN_VOLATGE;
|
|
max->desc.uV_step = MAX8973_VOLATGE_STEP;
|
|
max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE;
|
|
|
|
if (!pdata || !pdata->enable_ext_control) {
|
|
max->desc.enable_reg = MAX8973_VOUT;
|
|
max->desc.enable_mask = MAX8973_VOUT_ENABLE;
|
|
max->ops.enable = regulator_enable_regmap;
|
|
max->ops.disable = regulator_disable_regmap;
|
|
max->ops.is_enabled = regulator_is_enabled_regmap;
|
|
}
|
|
|
|
if (pdata) {
|
|
max->dvs_gpio = pdata->dvs_gpio;
|
|
max->enable_external_control = pdata->enable_ext_control;
|
|
max->curr_gpio_val = pdata->dvs_def_state;
|
|
max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state;
|
|
} else {
|
|
max->dvs_gpio = -EINVAL;
|
|
max->curr_vout_reg = MAX8973_VOUT;
|
|
}
|
|
|
|
max->lru_index[0] = max->curr_vout_reg;
|
|
|
|
if (gpio_is_valid(max->dvs_gpio)) {
|
|
int gpio_flags;
|
|
int i;
|
|
|
|
gpio_flags = (pdata->dvs_def_state) ?
|
|
GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
|
|
ret = devm_gpio_request_one(&client->dev, max->dvs_gpio,
|
|
gpio_flags, "max8973-dvs");
|
|
if (ret) {
|
|
dev_err(&client->dev,
|
|
"gpio_request for gpio %d failed, err = %d\n",
|
|
max->dvs_gpio, ret);
|
|
return ret;
|
|
}
|
|
max->valid_dvs_gpio = true;
|
|
|
|
/*
|
|
* Initialize the lru index with vout_reg id
|
|
* The index 0 will be most recently used and
|
|
* set with the max->curr_vout_reg */
|
|
for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i)
|
|
max->lru_index[i] = i;
|
|
max->lru_index[0] = max->curr_vout_reg;
|
|
max->lru_index[max->curr_vout_reg] = 0;
|
|
} else {
|
|
max->valid_dvs_gpio = false;
|
|
}
|
|
|
|
if (pdata) {
|
|
ret = max8973_init_dcdc(max, pdata);
|
|
if (ret < 0) {
|
|
dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
config.dev = &client->dev;
|
|
config.init_data = pdata ? pdata->reg_init_data :
|
|
of_get_regulator_init_data(&client->dev, client->dev.of_node);
|
|
config.driver_data = max;
|
|
config.of_node = client->dev.of_node;
|
|
config.regmap = max->regmap;
|
|
|
|
/* Register the regulators */
|
|
rdev = regulator_register(&max->desc, &config);
|
|
if (IS_ERR(rdev)) {
|
|
ret = PTR_ERR(rdev);
|
|
dev_err(max->dev, "regulator register failed, err %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
max->rdev = rdev;
|
|
return 0;
|
|
}
|
|
|
|
static int max8973_remove(struct i2c_client *client)
|
|
{
|
|
struct max8973_chip *max = i2c_get_clientdata(client);
|
|
|
|
regulator_unregister(max->rdev);
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_device_id max8973_id[] = {
|
|
{.name = "max8973",},
|
|
{},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(i2c, max8973_id);
|
|
|
|
static struct i2c_driver max8973_i2c_driver = {
|
|
.driver = {
|
|
.name = "max8973",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = max8973_probe,
|
|
.remove = max8973_remove,
|
|
.id_table = max8973_id,
|
|
};
|
|
|
|
static int __init max8973_init(void)
|
|
{
|
|
return i2c_add_driver(&max8973_i2c_driver);
|
|
}
|
|
subsys_initcall(max8973_init);
|
|
|
|
static void __exit max8973_cleanup(void)
|
|
{
|
|
i2c_del_driver(&max8973_i2c_driver);
|
|
}
|
|
module_exit(max8973_cleanup);
|
|
|
|
MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
|
|
MODULE_DESCRIPTION("MAX8973 voltage regulator driver");
|
|
MODULE_LICENSE("GPL v2");
|