[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / regulator / tps65023-regulator.c

/*
 * tps65023-regulator.c
 *
 * Supports TPS65023 Regulator
 *
 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.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.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/regmap.h>

/* Register definitions */
#define	TPS65023_REG_VERSION		0
#define	TPS65023_REG_PGOODZ		1
#define	TPS65023_REG_MASK		2
#define	TPS65023_REG_REG_CTRL		3
#define	TPS65023_REG_CON_CTRL		4
#define	TPS65023_REG_CON_CTRL2		5
#define	TPS65023_REG_DEF_CORE		6
#define	TPS65023_REG_DEFSLEW		7
#define	TPS65023_REG_LDO_CTRL		8

/* PGOODZ bitfields */
#define	TPS65023_PGOODZ_PWRFAILZ	BIT(7)
#define	TPS65023_PGOODZ_LOWBATTZ	BIT(6)
#define	TPS65023_PGOODZ_VDCDC1		BIT(5)
#define	TPS65023_PGOODZ_VDCDC2		BIT(4)
#define	TPS65023_PGOODZ_VDCDC3		BIT(3)
#define	TPS65023_PGOODZ_LDO2		BIT(2)
#define	TPS65023_PGOODZ_LDO1		BIT(1)

/* MASK bitfields */
#define	TPS65023_MASK_PWRFAILZ		BIT(7)
#define	TPS65023_MASK_LOWBATTZ		BIT(6)
#define	TPS65023_MASK_VDCDC1		BIT(5)
#define	TPS65023_MASK_VDCDC2		BIT(4)
#define	TPS65023_MASK_VDCDC3		BIT(3)
#define	TPS65023_MASK_LDO2		BIT(2)
#define	TPS65023_MASK_LDO1		BIT(1)

/* REG_CTRL bitfields */
#define TPS65023_REG_CTRL_VDCDC1_EN	BIT(5)
#define TPS65023_REG_CTRL_VDCDC2_EN	BIT(4)
#define TPS65023_REG_CTRL_VDCDC3_EN	BIT(3)
#define TPS65023_REG_CTRL_LDO2_EN	BIT(2)
#define TPS65023_REG_CTRL_LDO1_EN	BIT(1)

/* REG_CTRL2 bitfields */
#define TPS65023_REG_CTRL2_GO		BIT(7)
#define TPS65023_REG_CTRL2_CORE_ADJ	BIT(6)
#define TPS65023_REG_CTRL2_DCDC2	BIT(2)
#define TPS65023_REG_CTRL2_DCDC1	BIT(1)
#define TPS65023_REG_CTRL2_DCDC3	BIT(0)

/* LDO_CTRL bitfields */
#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id)	((ldo_id)*4)
#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id)	(0x0F << ((ldo_id)*4))

/* Number of step-down converters available */
#define TPS65023_NUM_DCDC		3
/* Number of LDO voltage regulators  available */
#define TPS65023_NUM_LDO		2
/* Number of total regulators available */
#define TPS65023_NUM_REGULATOR	(TPS65023_NUM_DCDC + TPS65023_NUM_LDO)

/* DCDCs */
#define TPS65023_DCDC_1			0
#define TPS65023_DCDC_2			1
#define TPS65023_DCDC_3			2
/* LDOs */
#define TPS65023_LDO_1			3
#define TPS65023_LDO_2			4

#define TPS65023_MAX_REG_ID		TPS65023_LDO_2

/* Supported voltage values for regulators */
static const u16 VCORE_VSEL_table[] = {
	800, 825, 850, 875,
	900, 925, 950, 975,
	1000, 1025, 1050, 1075,
	1100, 1125, 1150, 1175,
	1200, 1225, 1250, 1275,
	1300, 1325, 1350, 1375,
	1400, 1425, 1450, 1475,
	1500, 1525, 1550, 1600,
};

/* Supported voltage values for LDO regulators for tps65020 */
static const u16 TPS65020_LDO1_VSEL_table[] = {
	1000, 1050, 1100, 1300,
	1800, 2500, 3000, 3300,
};

static const u16 TPS65020_LDO2_VSEL_table[] = {
	1000, 1050, 1100, 1300,
	1800, 2500, 3000, 3300,
};

/* Supported voltage values for LDO regulators
 * for tps65021 and tps65023 */
static const u16 TPS65023_LDO1_VSEL_table[] = {
	1000, 1100, 1300, 1800,
	2200, 2600, 2800, 3150,
};

static const u16 TPS65023_LDO2_VSEL_table[] = {
	1050, 1200, 1300, 1800,
	2500, 2800, 3000, 3300,
};

/* Regulator specific details */
struct tps_info {
	const char *name;
	unsigned min_uV;
	unsigned max_uV;
	bool fixed;
	u8 table_len;
	const u16 *table;
};

/* PMIC details */
struct tps_pmic {
	struct regulator_desc desc[TPS65023_NUM_REGULATOR];
	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
	const struct tps_info *info[TPS65023_NUM_REGULATOR];
	struct regmap *regmap;
	u8 core_regulator;
};

/* Struct passed as driver data */
struct tps_driver_data {
	const struct tps_info *info;
	u8 core_regulator;
};

static int tps65023_dcdc_is_enabled(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, dcdc = rdev_get_id(dev);
	int ret;
	u8 shift;

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	shift = TPS65023_NUM_REGULATOR - dcdc;
	ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);

	if (ret != 0)
		return ret;
	else
		return (data & 1<<shift) ? 1 : 0;
}

static int tps65023_ldo_is_enabled(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, ldo = rdev_get_id(dev);
	int ret;
	u8 shift;

	if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
		return -EINVAL;

	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
	ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);

	if (ret != 0)
		return ret;
	else
		return (data & 1<<shift) ? 1 : 0;
}

static int tps65023_dcdc_enable(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);
	u8 shift;

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	shift = TPS65023_NUM_REGULATOR - dcdc;
	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
}

static int tps65023_dcdc_disable(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);
	u8 shift;

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	shift = TPS65023_NUM_REGULATOR - dcdc;
	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
}

static int tps65023_ldo_enable(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev);
	u8 shift;

	if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
		return -EINVAL;

	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
}

static int tps65023_ldo_disable(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev);
	u8 shift;

	if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
		return -EINVAL;

	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
}

static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int ret;
	int data, dcdc = rdev_get_id(dev);

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	if (dcdc == tps->core_regulator) {
		ret = regmap_read(tps->regmap, TPS65023_REG_DEF_CORE, &data);
		if (ret != 0)
			return ret;
		data &= (tps->info[dcdc]->table_len - 1);
		return tps->info[dcdc]->table[data] * 1000;
	} else
		return tps->info[dcdc]->min_uV;
}

static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
					 unsigned selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);
	int ret;

	if (dcdc != tps->core_regulator)
		return -EINVAL;

	ret = regmap_write(tps->regmap, TPS65023_REG_DEF_CORE, selector);
	if (ret)
		goto out;

	/* Tell the chip that we have changed the value in DEFCORE
	 * and its time to update the core voltage
	 */
	ret = regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
				 TPS65023_REG_CTRL2_GO, TPS65023_REG_CTRL2_GO);

out:
	return ret;
}

static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, ldo = rdev_get_id(dev);
	int ret;

	if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
		return -EINVAL;

	ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
	if (ret != 0)
		return ret;

	data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
	data &= (tps->info[ldo]->table_len - 1);
	return tps->info[ldo]->table[data] * 1000;
}

static int tps65023_ldo_set_voltage_sel(struct regulator_dev *dev,
					unsigned selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int ldo_index = rdev_get_id(dev) - TPS65023_LDO_1;

	return regmap_update_bits(tps->regmap, TPS65023_REG_LDO_CTRL,
			TPS65023_LDO_CTRL_LDOx_MASK(ldo_index),
			selector << TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_index));
}

static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
					unsigned selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	if (dcdc == tps->core_regulator) {
		if (selector >= tps->info[dcdc]->table_len)
			return -EINVAL;
		else
			return tps->info[dcdc]->table[selector] * 1000;
	} else
		return tps->info[dcdc]->min_uV;
}

static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
					unsigned selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev);

	if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
		return -EINVAL;

	if (selector >= tps->info[ldo]->table_len)
		return -EINVAL;
	else
		return tps->info[ldo]->table[selector] * 1000;
}

/* Operations permitted on VDCDCx */
static struct regulator_ops tps65023_dcdc_ops = {
	.is_enabled = tps65023_dcdc_is_enabled,
	.enable = tps65023_dcdc_enable,
	.disable = tps65023_dcdc_disable,
	.get_voltage = tps65023_dcdc_get_voltage,
	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
	.list_voltage = tps65023_dcdc_list_voltage,
};

/* Operations permitted on LDOx */
static struct regulator_ops tps65023_ldo_ops = {
	.is_enabled = tps65023_ldo_is_enabled,
	.enable = tps65023_ldo_enable,
	.disable = tps65023_ldo_disable,
	.get_voltage = tps65023_ldo_get_voltage,
	.set_voltage_sel = tps65023_ldo_set_voltage_sel,
	.list_voltage = tps65023_ldo_list_voltage,
};

static struct regmap_config tps65023_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};

static int __devinit tps_65023_probe(struct i2c_client *client,
				     const struct i2c_device_id *id)
{
	const struct tps_driver_data *drv_data = (void *)id->driver_data;
	const struct tps_info *info = drv_data->info;
	struct regulator_config config = { };
	struct regulator_init_data *init_data;
	struct regulator_dev *rdev;
	struct tps_pmic *tps;
	int i;
	int error;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	/**
	 * init_data points to array of regulator_init structures
	 * coming from the board-evm file.
	 */
	init_data = client->dev.platform_data;
	if (!init_data)
		return -EIO;

	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
	if (!tps)
		return -ENOMEM;

	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
	if (IS_ERR(tps->regmap)) {
		error = PTR_ERR(tps->regmap);
		dev_err(&client->dev, "Failed to allocate register map: %d\n",
			error);
		return error;
	}

	/* common for all regulators */
	tps->core_regulator = drv_data->core_regulator;

	for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
		/* Store regulator specific information */
		tps->info[i] = info;

		tps->desc[i].name = info->name;
		tps->desc[i].id = i;
		tps->desc[i].n_voltages = info->table_len;
		tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
					&tps65023_ldo_ops : &tps65023_dcdc_ops);
		tps->desc[i].type = REGULATOR_VOLTAGE;
		tps->desc[i].owner = THIS_MODULE;

		config.dev = &client->dev;
		config.init_data = init_data;
		config.driver_data = tps;

		/* Register the regulators */
		rdev = regulator_register(&tps->desc[i], &config);
		if (IS_ERR(rdev)) {
			dev_err(&client->dev, "failed to register %s\n",
				id->name);
			error = PTR_ERR(rdev);
			goto fail;
		}

		/* Save regulator for cleanup */
		tps->rdev[i] = rdev;
	}

	i2c_set_clientdata(client, tps);

	/* Enable setting output voltage by I2C */
	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
			TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);

	return 0;

 fail:
	while (--i >= 0)
		regulator_unregister(tps->rdev[i]);
	return error;
}

static int __devexit tps_65023_remove(struct i2c_client *client)
{
	struct tps_pmic *tps = i2c_get_clientdata(client);
	int i;

	for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
		regulator_unregister(tps->rdev[i]);
	return 0;
}

static const struct tps_info tps65020_regs[] = {
	{
		.name = "VDCDC1",
		.min_uV = 3300000,
		.max_uV = 3300000,
		.fixed	= 1,
	},
	{
		.name = "VDCDC2",
		.min_uV =  1800000,
		.max_uV = 1800000,
		.fixed = 1,
	},
	{
		.name = "VDCDC3",
		.min_uV =  800000,
		.max_uV = 1600000,
		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
		.table = VCORE_VSEL_table,
	},

	{
		.name = "LDO1",
		.min_uV = 1000000,
		.max_uV = 3150000,
		.table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
		.table = TPS65020_LDO1_VSEL_table,
	},
	{
		.name = "LDO2",
		.min_uV = 1050000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
		.table = TPS65020_LDO2_VSEL_table,
	},
};

static const struct tps_info tps65021_regs[] = {
	{
		.name = "VDCDC1",
		.min_uV =  3300000,
		.max_uV = 3300000,
		.fixed = 1,
	},
	{
		.name = "VDCDC2",
		.min_uV =  1800000,
		.max_uV = 1800000,
		.fixed = 1,
	},
	{
		.name = "VDCDC3",
		.min_uV =  800000,
		.max_uV = 1600000,
		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
		.table = VCORE_VSEL_table,
	},
	{
		.name = "LDO1",
		.min_uV = 1000000,
		.max_uV = 3150000,
		.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
		.table = TPS65023_LDO1_VSEL_table,
	},
	{
		.name = "LDO2",
		.min_uV = 1050000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
		.table = TPS65023_LDO2_VSEL_table,
	},
};

static const struct tps_info tps65023_regs[] = {
	{
		.name = "VDCDC1",
		.min_uV =  800000,
		.max_uV = 1600000,
		.table_len = ARRAY_SIZE(VCORE_VSEL_table),
		.table = VCORE_VSEL_table,
	},
	{
		.name = "VDCDC2",
		.min_uV =  3300000,
		.max_uV = 3300000,
		.fixed = 1,
	},
	{
		.name = "VDCDC3",
		.min_uV =  1800000,
		.max_uV = 1800000,
		.fixed = 1,
	},
	{
		.name = "LDO1",
		.min_uV = 1000000,
		.max_uV = 3150000,
		.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
		.table = TPS65023_LDO1_VSEL_table,
	},
	{
		.name = "LDO2",
		.min_uV = 1050000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
		.table = TPS65023_LDO2_VSEL_table,
	},
};

static struct tps_driver_data tps65020_drv_data = {
	.info = tps65020_regs,
	.core_regulator = TPS65023_DCDC_3,
};

static struct tps_driver_data tps65021_drv_data = {
	.info = tps65021_regs,
	.core_regulator = TPS65023_DCDC_3,
};

static struct tps_driver_data tps65023_drv_data = {
	.info = tps65023_regs,
	.core_regulator = TPS65023_DCDC_1,
};

static const struct i2c_device_id tps_65023_id[] = {
	{.name = "tps65023",
	.driver_data = (unsigned long) &tps65023_drv_data},
	{.name = "tps65021",
	.driver_data = (unsigned long) &tps65021_drv_data,},
	{.name = "tps65020",
	.driver_data = (unsigned long) &tps65020_drv_data},
	{ },
};

MODULE_DEVICE_TABLE(i2c, tps_65023_id);

static struct i2c_driver tps_65023_i2c_driver = {
	.driver = {
		.name = "tps65023",
		.owner = THIS_MODULE,
	},
	.probe = tps_65023_probe,
	.remove = __devexit_p(tps_65023_remove),
	.id_table = tps_65023_id,
};

static int __init tps_65023_init(void)
{
	return i2c_add_driver(&tps_65023_i2c_driver);
}
subsys_initcall(tps_65023_init);

static void __exit tps_65023_cleanup(void)
{
	i2c_del_driver(&tps_65023_i2c_driver);
}
module_exit(tps_65023_cleanup);

MODULE_AUTHOR("Texas Instruments");
MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
30e6599d AA	1	/*
	2	* tps65023-regulator.c
	3	*
	4	* Supports TPS65023 Regulator
	5	*
	6	* Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation version 2.
	11	*
	12	* This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
	13	* whether express or implied; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/init.h>
	21	#include <linux/err.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/regulator/driver.h>
	24	#include <linux/regulator/machine.h>
	25	#include <linux/i2c.h>
	26	#include <linux/delay.h>
5a0e3ad6	27	#include <linux/slab.h>
90923351	28	#include <linux/regmap.h>
30e6599d AA	29
	30	/* Register definitions */
	31	#define TPS65023_REG_VERSION 0
	32	#define TPS65023_REG_PGOODZ 1
	33	#define TPS65023_REG_MASK 2
	34	#define TPS65023_REG_REG_CTRL 3
	35	#define TPS65023_REG_CON_CTRL 4
	36	#define TPS65023_REG_CON_CTRL2 5
	37	#define TPS65023_REG_DEF_CORE 6
	38	#define TPS65023_REG_DEFSLEW 7
	39	#define TPS65023_REG_LDO_CTRL 8
	40
	41	/* PGOODZ bitfields */
	42	#define TPS65023_PGOODZ_PWRFAILZ BIT(7)
	43	#define TPS65023_PGOODZ_LOWBATTZ BIT(6)
	44	#define TPS65023_PGOODZ_VDCDC1 BIT(5)
	45	#define TPS65023_PGOODZ_VDCDC2 BIT(4)
	46	#define TPS65023_PGOODZ_VDCDC3 BIT(3)
	47	#define TPS65023_PGOODZ_LDO2 BIT(2)
	48	#define TPS65023_PGOODZ_LDO1 BIT(1)
	49
	50	/* MASK bitfields */
	51	#define TPS65023_MASK_PWRFAILZ BIT(7)
	52	#define TPS65023_MASK_LOWBATTZ BIT(6)
	53	#define TPS65023_MASK_VDCDC1 BIT(5)
	54	#define TPS65023_MASK_VDCDC2 BIT(4)
	55	#define TPS65023_MASK_VDCDC3 BIT(3)
	56	#define TPS65023_MASK_LDO2 BIT(2)
	57	#define TPS65023_MASK_LDO1 BIT(1)
	58
	59	/* REG_CTRL bitfields */
	60	#define TPS65023_REG_CTRL_VDCDC1_EN BIT(5)
	61	#define TPS65023_REG_CTRL_VDCDC2_EN BIT(4)
	62	#define TPS65023_REG_CTRL_VDCDC3_EN BIT(3)
	63	#define TPS65023_REG_CTRL_LDO2_EN BIT(2)
	64	#define TPS65023_REG_CTRL_LDO1_EN BIT(1)
	65
f068ad8c MF	66	/* REG_CTRL2 bitfields */
	67	#define TPS65023_REG_CTRL2_GO BIT(7)
	68	#define TPS65023_REG_CTRL2_CORE_ADJ BIT(6)
	69	#define TPS65023_REG_CTRL2_DCDC2 BIT(2)
	70	#define TPS65023_REG_CTRL2_DCDC1 BIT(1)
	71	#define TPS65023_REG_CTRL2_DCDC3 BIT(0)
	72
30e6599d AA	73	/* LDO_CTRL bitfields */
30e6599d AA	74	#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id) ((ldo_id)*4)
7061873f	75	#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id) (0x0F << ((ldo_id)*4))
30e6599d AA	76
	77	/* Number of step-down converters available */
	78	#define TPS65023_NUM_DCDC 3
	79	/* Number of LDO voltage regulators available */
	80	#define TPS65023_NUM_LDO 2
	81	/* Number of total regulators available */
	82	#define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
	83
	84	/* DCDCs */
	85	#define TPS65023_DCDC_1 0
	86	#define TPS65023_DCDC_2 1
	87	#define TPS65023_DCDC_3 2
	88	/* LDOs */
	89	#define TPS65023_LDO_1 3
	90	#define TPS65023_LDO_2 4
	91
	92	#define TPS65023_MAX_REG_ID TPS65023_LDO_2
	93
	94	/* Supported voltage values for regulators */
1c3ede05	95	static const u16 VCORE_VSEL_table[] = {
30e6599d AA	96	800, 825, 850, 875,
	97	900, 925, 950, 975,
	98	1000, 1025, 1050, 1075,
	99	1100, 1125, 1150, 1175,
	100	1200, 1225, 1250, 1275,
	101	1300, 1325, 1350, 1375,
	102	1400, 1425, 1450, 1475,
	103	1500, 1525, 1550, 1600,
	104	};
	105
437afd2a MF	106	/* Supported voltage values for LDO regulators for tps65020 */
	107	static const u16 TPS65020_LDO1_VSEL_table[] = {
	108	1000, 1050, 1100, 1300,
	109	1800, 2500, 3000, 3300,
	110	};
1c3ede05	111
437afd2a MF	112	static const u16 TPS65020_LDO2_VSEL_table[] = {
	113	1000, 1050, 1100, 1300,
	114	1800, 2500, 3000, 3300,
	115	};
1c3ede05 MF	116
	117	/* Supported voltage values for LDO regulators
	118	* for tps65021 and tps65023 */
	119	static const u16 TPS65023_LDO1_VSEL_table[] = {
30e6599d AA	120	1000, 1100, 1300, 1800,
	121	2200, 2600, 2800, 3150,
	122	};
	123
1c3ede05	124	static const u16 TPS65023_LDO2_VSEL_table[] = {
30e6599d AA	125	1050, 1200, 1300, 1800,
	126	2500, 2800, 3000, 3300,
	127	};
	128
30e6599d AA	129	/* Regulator specific details */
	130	struct tps_info {
	131	const char *name;
	132	unsigned min_uV;
	133	unsigned max_uV;
	134	bool fixed;
	135	u8 table_len;
	136	const u16 *table;
	137	};
	138
	139	/* PMIC details */
	140	struct tps_pmic {
	141	struct regulator_desc desc[TPS65023_NUM_REGULATOR];
30e6599d AA	142	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
30e6599d AA	143	const struct tps_info *info[TPS65023_NUM_REGULATOR];
90923351	144	struct regmap *regmap;
1c3ede05 MF	145	u8 core_regulator;
	146	};
	147
	148	/* Struct passed as driver data */
	149	struct tps_driver_data {
	150	const struct tps_info *info;
	151	u8 core_regulator;
30e6599d AA	152	};
30e6599d AA	153
30e6599d AA	154	static int tps65023_dcdc_is_enabled(struct regulator_dev *dev)
	155	{
	156	struct tps_pmic *tps = rdev_get_drvdata(dev);
	157	int data, dcdc = rdev_get_id(dev);
43530b69	158	int ret;
30e6599d AA	159	u8 shift;
	160
	161	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	162	return -EINVAL;
	163
	164	shift = TPS65023_NUM_REGULATOR - dcdc;
43530b69	165	ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);
30e6599d	166
43530b69 JC	167	if (ret != 0)
43530b69 JC	168	return ret;
30e6599d AA	169	else
	170	return (data & 1<<shift) ? 1 : 0;
	171	}
	172
	173	static int tps65023_ldo_is_enabled(struct regulator_dev *dev)
	174	{
	175	struct tps_pmic *tps = rdev_get_drvdata(dev);
	176	int data, ldo = rdev_get_id(dev);
43530b69	177	int ret;
30e6599d AA	178	u8 shift;
	179
	180	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	181	return -EINVAL;
	182
	183	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
43530b69	184	ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);
30e6599d	185
43530b69 JC	186	if (ret != 0)
43530b69 JC	187	return ret;
30e6599d AA	188	else
	189	return (data & 1<<shift) ? 1 : 0;
	190	}
	191
	192	static int tps65023_dcdc_enable(struct regulator_dev *dev)
	193	{
	194	struct tps_pmic *tps = rdev_get_drvdata(dev);
	195	int dcdc = rdev_get_id(dev);
	196	u8 shift;
	197
	198	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	199	return -EINVAL;
	200
	201	shift = TPS65023_NUM_REGULATOR - dcdc;
43530b69	202	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
30e6599d AA	203	}
	204
	205	static int tps65023_dcdc_disable(struct regulator_dev *dev)
	206	{
	207	struct tps_pmic *tps = rdev_get_drvdata(dev);
	208	int dcdc = rdev_get_id(dev);
	209	u8 shift;
	210
	211	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	212	return -EINVAL;
	213
	214	shift = TPS65023_NUM_REGULATOR - dcdc;
43530b69	215	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
30e6599d AA	216	}
	217
	218	static int tps65023_ldo_enable(struct regulator_dev *dev)
	219	{
	220	struct tps_pmic *tps = rdev_get_drvdata(dev);
	221	int ldo = rdev_get_id(dev);
	222	u8 shift;
	223
	224	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	225	return -EINVAL;
	226
	227	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
43530b69	228	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
30e6599d AA	229	}
	230
	231	static int tps65023_ldo_disable(struct regulator_dev *dev)
	232	{
	233	struct tps_pmic *tps = rdev_get_drvdata(dev);
	234	int ldo = rdev_get_id(dev);
	235	u8 shift;
	236
	237	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	238	return -EINVAL;
	239
	240	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
43530b69	241	return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
30e6599d AA	242	}
	243
	244	static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
	245	{
	246	struct tps_pmic *tps = rdev_get_drvdata(dev);
43530b69	247	int ret;
30e6599d AA	248	int data, dcdc = rdev_get_id(dev);
	249
	250	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	251	return -EINVAL;
	252
1c3ede05	253	if (dcdc == tps->core_regulator) {
43530b69 JC	254	ret = regmap_read(tps->regmap, TPS65023_REG_DEF_CORE, &data);
	255	if (ret != 0)
	256	return ret;
30e6599d AA	257	data &= (tps->info[dcdc]->table_len - 1);
	258	return tps->info[dcdc]->table[data] * 1000;
	259	} else
	260	return tps->info[dcdc]->min_uV;
	261	}
	262
7061873f AL	263	static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
7061873f AL	264	unsigned selector)
30e6599d AA	265	{
	266	struct tps_pmic *tps = rdev_get_drvdata(dev);
	267	int dcdc = rdev_get_id(dev);
cc17ef3f	268	int ret;
30e6599d	269
1c3ede05	270	if (dcdc != tps->core_regulator)
30e6599d	271	return -EINVAL;
30e6599d	272
7061873f AL	273	ret = regmap_write(tps->regmap, TPS65023_REG_DEF_CORE, selector);
	274	if (ret)
	275	goto out;
cc17ef3f MF	276
	277	/* Tell the chip that we have changed the value in DEFCORE
	278	* and its time to update the core voltage
	279	*/
7061873f AL	280	ret = regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
7061873f AL	281	TPS65023_REG_CTRL2_GO, TPS65023_REG_CTRL2_GO);
cc17ef3f	282
7061873f	283	out:
cc17ef3f	284	return ret;
30e6599d AA	285	}
	286
	287	static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
	288	{
	289	struct tps_pmic *tps = rdev_get_drvdata(dev);
	290	int data, ldo = rdev_get_id(dev);
43530b69	291	int ret;
30e6599d AA	292
	293	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	294	return -EINVAL;
	295
43530b69 JC	296	ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
	297	if (ret != 0)
	298	return ret;
30e6599d AA	299
	300	data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
	301	data &= (tps->info[ldo]->table_len - 1);
	302	return tps->info[ldo]->table[data] * 1000;
	303	}
	304
7061873f AL	305	static int tps65023_ldo_set_voltage_sel(struct regulator_dev *dev,
7061873f AL	306	unsigned selector)
30e6599d AA	307	{
30e6599d AA	308	struct tps_pmic *tps = rdev_get_drvdata(dev);
7061873f	309	int ldo_index = rdev_get_id(dev) - TPS65023_LDO_1;
30e6599d	310
7061873f AL	311	return regmap_update_bits(tps->regmap, TPS65023_REG_LDO_CTRL,
	312	TPS65023_LDO_CTRL_LDOx_MASK(ldo_index),
	313	selector << TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_index));
30e6599d AA	314	}
	315
	316	static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
	317	unsigned selector)
	318	{
	319	struct tps_pmic *tps = rdev_get_drvdata(dev);
	320	int dcdc = rdev_get_id(dev);
	321
	322	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	323	return -EINVAL;
	324
1c3ede05	325	if (dcdc == tps->core_regulator) {
30e6599d AA	326	if (selector >= tps->info[dcdc]->table_len)
	327	return -EINVAL;
	328	else
	329	return tps->info[dcdc]->table[selector] * 1000;
	330	} else
	331	return tps->info[dcdc]->min_uV;
	332	}
	333
	334	static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
	335	unsigned selector)
	336	{
	337	struct tps_pmic *tps = rdev_get_drvdata(dev);
	338	int ldo = rdev_get_id(dev);
	339
	340	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	341	return -EINVAL;
	342
	343	if (selector >= tps->info[ldo]->table_len)
	344	return -EINVAL;
	345	else
	346	return tps->info[ldo]->table[selector] * 1000;
	347	}
	348
	349	/* Operations permitted on VDCDCx */
	350	static struct regulator_ops tps65023_dcdc_ops = {
	351	.is_enabled = tps65023_dcdc_is_enabled,
	352	.enable = tps65023_dcdc_enable,
	353	.disable = tps65023_dcdc_disable,
	354	.get_voltage = tps65023_dcdc_get_voltage,
7061873f	355	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
30e6599d AA	356	.list_voltage = tps65023_dcdc_list_voltage,
	357	};
	358
	359	/* Operations permitted on LDOx */
	360	static struct regulator_ops tps65023_ldo_ops = {
	361	.is_enabled = tps65023_ldo_is_enabled,
	362	.enable = tps65023_ldo_enable,
	363	.disable = tps65023_ldo_disable,
	364	.get_voltage = tps65023_ldo_get_voltage,
7061873f	365	.set_voltage_sel = tps65023_ldo_set_voltage_sel,
30e6599d AA	366	.list_voltage = tps65023_ldo_list_voltage,
	367	};
	368
90923351 MB	369	static struct regmap_config tps65023_regmap_config = {
	370	.reg_bits = 8,
	371	.val_bits = 8,
	372	};
	373
54d13ab1 DT	374	static int __devinit tps_65023_probe(struct i2c_client *client,
54d13ab1 DT	375	const struct i2c_device_id *id)
30e6599d	376	{
1c3ede05 MF	377	const struct tps_driver_data drv_data = (void )id->driver_data;
1c3ede05 MF	378	const struct tps_info *info = drv_data->info;
c172708d	379	struct regulator_config config = { };
30e6599d AA	380	struct regulator_init_data *init_data;
	381	struct regulator_dev *rdev;
	382	struct tps_pmic *tps;
	383	int i;
54d13ab1	384	int error;
30e6599d AA	385
	386	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	387	return -EIO;
	388
	389	/**
	390	* init_data points to array of regulator_init structures
	391	* coming from the board-evm file.
	392	*/
	393	init_data = client->dev.platform_data;
30e6599d AA	394	if (!init_data)
	395	return -EIO;
	396
19a8da21	397	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
30e6599d AA	398	if (!tps)
	399	return -ENOMEM;
	400
19a8da21	401	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
90923351 MB	402	if (IS_ERR(tps->regmap)) {
	403	error = PTR_ERR(tps->regmap);
	404	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	405	error);
19a8da21	406	return error;
90923351	407	}
30e6599d AA	408
30e6599d AA	409	/* common for all regulators */
1c3ede05	410	tps->core_regulator = drv_data->core_regulator;
30e6599d AA	411
	412	for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
	413	/* Store regulator specific information */
	414	tps->info[i] = info;
	415
	416	tps->desc[i].name = info->name;
77fa44d0	417	tps->desc[i].id = i;
1c3ede05	418	tps->desc[i].n_voltages = info->table_len;
30e6599d AA	419	tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
	420	&tps65023_ldo_ops : &tps65023_dcdc_ops);
	421	tps->desc[i].type = REGULATOR_VOLTAGE;
	422	tps->desc[i].owner = THIS_MODULE;
	423
c172708d MB	424	config.dev = &client->dev;
	425	config.init_data = init_data;
	426	config.driver_data = tps;
	427
30e6599d	428	/* Register the regulators */
c172708d	429	rdev = regulator_register(&tps->desc[i], &config);
30e6599d AA	430	if (IS_ERR(rdev)) {
	431	dev_err(&client->dev, "failed to register %s\n",
	432	id->name);
54d13ab1 DT	433	error = PTR_ERR(rdev);
54d13ab1 DT	434	goto fail;
30e6599d AA	435	}
	436
	437	/* Save regulator for cleanup */
	438	tps->rdev[i] = rdev;
	439	}
	440
	441	i2c_set_clientdata(client, tps);
	442
fc999b83	443	/* Enable setting output voltage by I2C */
43530b69 JC	444	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
43530b69 JC	445	TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);
fc999b83	446
30e6599d	447	return 0;
54d13ab1 DT	448
	449	fail:
	450	while (--i >= 0)
	451	regulator_unregister(tps->rdev[i]);
54d13ab1	452	return error;
30e6599d AA	453	}
30e6599d AA	454
30e6599d AA	455	static int __devexit tps_65023_remove(struct i2c_client *client)
	456	{
	457	struct tps_pmic *tps = i2c_get_clientdata(client);
	458	int i;
	459
	460	for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
	461	regulator_unregister(tps->rdev[i]);
30e6599d AA	462	return 0;
	463	}
	464
437afd2a MF	465	static const struct tps_info tps65020_regs[] = {
	466	{
	467	.name = "VDCDC1",
	468	.min_uV = 3300000,
	469	.max_uV = 3300000,
	470	.fixed = 1,
	471	},
	472	{
	473	.name = "VDCDC2",
	474	.min_uV = 1800000,
	475	.max_uV = 1800000,
	476	.fixed = 1,
	477	},
	478	{
	479	.name = "VDCDC3",
	480	.min_uV = 800000,
	481	.max_uV = 1600000,
	482	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
	483	.table = VCORE_VSEL_table,
	484	},
	485
	486	{
	487	.name = "LDO1",
	488	.min_uV = 1000000,
	489	.max_uV = 3150000,
	490	.table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
	491	.table = TPS65020_LDO1_VSEL_table,
	492	},
	493	{
	494	.name = "LDO2",
	495	.min_uV = 1050000,
	496	.max_uV = 3300000,
	497	.table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
	498	.table = TPS65020_LDO2_VSEL_table,
	499	},
	500	};
	501
1c3ede05 MF	502	static const struct tps_info tps65021_regs[] = {
	503	{
	504	.name = "VDCDC1",
	505	.min_uV = 3300000,
	506	.max_uV = 3300000,
	507	.fixed = 1,
	508	},
	509	{
	510	.name = "VDCDC2",
	511	.min_uV = 1800000,
	512	.max_uV = 1800000,
	513	.fixed = 1,
	514	},
	515	{
	516	.name = "VDCDC3",
	517	.min_uV = 800000,
	518	.max_uV = 1600000,
	519	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
	520	.table = VCORE_VSEL_table,
	521	},
	522	{
	523	.name = "LDO1",
	524	.min_uV = 1000000,
	525	.max_uV = 3150000,
	526	.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
	527	.table = TPS65023_LDO1_VSEL_table,
	528	},
	529	{
	530	.name = "LDO2",
	531	.min_uV = 1050000,
	532	.max_uV = 3300000,
	533	.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
	534	.table = TPS65023_LDO2_VSEL_table,
	535	},
	536	};
	537
30e6599d AA	538	static const struct tps_info tps65023_regs[] = {
	539	{
	540	.name = "VDCDC1",
	541	.min_uV = 800000,
	542	.max_uV = 1600000,
1c3ede05 MF	543	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
1c3ede05 MF	544	.table = VCORE_VSEL_table,
30e6599d AA	545	},
	546	{
	547	.name = "VDCDC2",
	548	.min_uV = 3300000,
	549	.max_uV = 3300000,
	550	.fixed = 1,
	551	},
	552	{
	553	.name = "VDCDC3",
	554	.min_uV = 1800000,
	555	.max_uV = 1800000,
	556	.fixed = 1,
	557	},
	558	{
	559	.name = "LDO1",
	560	.min_uV = 1000000,
	561	.max_uV = 3150000,
1c3ede05 MF	562	.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
1c3ede05 MF	563	.table = TPS65023_LDO1_VSEL_table,
30e6599d AA	564	},
	565	{
	566	.name = "LDO2",
	567	.min_uV = 1050000,
	568	.max_uV = 3300000,
1c3ede05 MF	569	.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
1c3ede05 MF	570	.table = TPS65023_LDO2_VSEL_table,
30e6599d AA	571	},
	572	};
	573
437afd2a MF	574	static struct tps_driver_data tps65020_drv_data = {
	575	.info = tps65020_regs,
	576	.core_regulator = TPS65023_DCDC_3,
	577	};
	578
1c3ede05	579	static struct tps_driver_data tps65021_drv_data = {
7061873f AL	580	.info = tps65021_regs,
7061873f AL	581	.core_regulator = TPS65023_DCDC_3,
1c3ede05 MF	582	};
	583
	584	static struct tps_driver_data tps65023_drv_data = {
7061873f AL	585	.info = tps65023_regs,
7061873f AL	586	.core_regulator = TPS65023_DCDC_1,
1c3ede05 MF	587	};
1c3ede05 MF	588
9e108d33 LG	589	static const struct i2c_device_id tps_65023_id[] = {
9e108d33 LG	590	{.name = "tps65023",
1c3ede05	591	.driver_data = (unsigned long) &tps65023_drv_data},
1880a2fc	592	{.name = "tps65021",
1c3ede05	593	.driver_data = (unsigned long) &tps65021_drv_data,},
437afd2a MF	594	{.name = "tps65020",
437afd2a MF	595	.driver_data = (unsigned long) &tps65020_drv_data},
9e108d33	596	{ },
30e6599d AA	597	};
	598
	599	MODULE_DEVICE_TABLE(i2c, tps_65023_id);
	600
	601	static struct i2c_driver tps_65023_i2c_driver = {
	602	.driver = {
	603	.name = "tps65023",
	604	.owner = THIS_MODULE,
	605	},
	606	.probe = tps_65023_probe,
	607	.remove = __devexit_p(tps_65023_remove),
9e108d33	608	.id_table = tps_65023_id,
30e6599d AA	609	};
30e6599d AA	610
30e6599d AA	611	static int __init tps_65023_init(void)
	612	{
	613	return i2c_add_driver(&tps_65023_i2c_driver);
	614	}
	615	subsys_initcall(tps_65023_init);
	616
30e6599d AA	617	static void __exit tps_65023_cleanup(void)
	618	{
	619	i2c_del_driver(&tps_65023_i2c_driver);
	620	}
	621	module_exit(tps_65023_cleanup);
	622
	623	MODULE_AUTHOR("Texas Instruments");
	624	MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
9e108d33	625	MODULE_LICENSE("GPL v2");