[deliverable/linux.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)	(0xF0 >> ((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 i2c_client *client;
	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 tps_65023_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
{
	return regmap_update_bits(tps->regmap, reg, mask, mask);
}

static int tps_65023_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
{
	return regmap_update_bits(tps->regmap, reg, mask, 0);
}

static int tps_65023_reg_read(struct tps_pmic *tps, u8 reg)
{
	unsigned int val;
	int ret;

	ret = regmap_read(tps->regmap, reg, &val);

	if (ret != 0)
		return ret;
	else
		return val;
}

static int tps_65023_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
{
	return regmap_write(tps->regmap, reg, val);
}

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);
	u8 shift;

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

	shift = TPS65023_NUM_REGULATOR - dcdc;
	data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);

	if (data < 0)
		return data;
	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);
	u8 shift;

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

	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
	data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);

	if (data < 0)
		return data;
	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 tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 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 tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
}

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 tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 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 tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
}

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

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

	if (dcdc == tps->core_regulator) {
		data = tps_65023_reg_read(tps, TPS65023_REG_DEF_CORE);
		if (data < 0)
			return data;
		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(struct regulator_dev *dev,
				     int min_uV, int max_uV,
				     unsigned *selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);
	int vsel;
	int ret;

	if (dcdc != tps->core_regulator)
		return -EINVAL;
	if (min_uV < tps->info[dcdc]->min_uV
			|| min_uV > tps->info[dcdc]->max_uV)
		return -EINVAL;
	if (max_uV < tps->info[dcdc]->min_uV
			|| max_uV > tps->info[dcdc]->max_uV)
		return -EINVAL;

	for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
		int mV = tps->info[dcdc]->table[vsel];
		int uV = mV * 1000;

		/* Break at the first in-range value */
		if (min_uV <= uV && uV <= max_uV)
			break;
	}

	*selector = vsel;

	if (vsel == tps->info[dcdc]->table_len)
		goto failed;

	ret = tps_65023_reg_write(tps, TPS65023_REG_DEF_CORE, vsel);

	/* Tell the chip that we have changed the value in DEFCORE
	 * and its time to update the core voltage
	 */
	tps_65023_set_bits(tps, TPS65023_REG_CON_CTRL2,
						TPS65023_REG_CTRL2_GO);

	return ret;

failed:
	return -EINVAL;
}

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);

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

	data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
	if (data < 0)
		return data;

	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(struct regulator_dev *dev,
				    int min_uV, int max_uV, unsigned *selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, vsel, ldo = rdev_get_id(dev);

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

	if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV)
		return -EINVAL;
	if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV)
		return -EINVAL;

	for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
		int mV = tps->info[ldo]->table[vsel];
		int uV = mV * 1000;

		/* Break at the first in-range value */
		if (min_uV <= uV && uV <= max_uV)
			break;
	}

	if (vsel == tps->info[ldo]->table_len)
		return -EINVAL;

	*selector = vsel;

	data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
	if (data < 0)
		return data;

	data &= TPS65023_LDO_CTRL_LDOx_MASK(ldo - TPS65023_LDO_1);
	data |= (vsel << (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1)));
	return tps_65023_reg_write(tps, TPS65023_REG_LDO_CTRL, data);
}

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 = tps65023_dcdc_set_voltage,
	.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 = tps65023_ldo_set_voltage,
	.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_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 = kzalloc(sizeof(*tps), GFP_KERNEL);
	if (!tps)
		return -ENOMEM;

	tps->regmap = 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);
		goto fail_alloc;
	}

	/* common for all regulators */
	tps->client = client;
	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;

		/* Register the regulators */
		rdev = regulator_register(&tps->desc[i], &client->dev,
					  init_data, tps);
		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 */
	tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
						TPS65023_REG_CTRL2_CORE_ADJ);

	/* Enable setting output voltage by I2C */
	tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
						TPS65023_REG_CTRL2_CORE_ADJ);

	return 0;

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

	regmap_exit(tps->regmap);
 fail_alloc:
	kfree(tps);
	return error;
}

/**
 * tps_65023_remove - TPS65023 driver i2c remove handler
 * @client: i2c driver client device structure
 *
 * Unregister TPS driver as an i2c client device driver
 */
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]);

	regmap_exit(tps->regmap);
	kfree(tps);

	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,
};

/**
 * tps_65023_init
 *
 * Module init function
 */
static int __init tps_65023_init(void)
{
	return i2c_add_driver(&tps_65023_i2c_driver);
}
subsys_initcall(tps_65023_init);

/**
 * tps_65023_cleanup
 *
 * Module exit function
 */
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 */
	74	#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id) ((ldo_id)*4)
	75	#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id) (0xF0 >> ((ldo_id)*4))
	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];
	142	struct i2c_client *client;
	143	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
	144	const struct tps_info *info[TPS65023_NUM_REGULATOR];
90923351	145	struct regmap *regmap;
1c3ede05 MF	146	u8 core_regulator;
	147	};
	148
	149	/* Struct passed as driver data */
	150	struct tps_driver_data {
	151	const struct tps_info *info;
	152	u8 core_regulator;
30e6599d AA	153	};
30e6599d AA	154
30e6599d AA	155	static int tps_65023_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
30e6599d AA	156	{
90923351	157	return regmap_update_bits(tps->regmap, reg, mask, mask);
30e6599d AA	158	}
	159
	160	static int tps_65023_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
	161	{
90923351	162	return regmap_update_bits(tps->regmap, reg, mask, 0);
30e6599d AA	163	}
	164
	165	static int tps_65023_reg_read(struct tps_pmic *tps, u8 reg)
	166	{
90923351 MB	167	unsigned int val;
90923351 MB	168	int ret;
30e6599d	169
90923351	170	ret = regmap_read(tps->regmap, reg, &val);
30e6599d	171
90923351 MB	172	if (ret != 0)
	173	return ret;
	174	else
	175	return val;
30e6599d AA	176	}
	177
	178	static int tps_65023_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
	179	{
90923351	180	return regmap_write(tps->regmap, reg, val);
30e6599d AA	181	}
	182
	183	static int tps65023_dcdc_is_enabled(struct regulator_dev *dev)
	184	{
	185	struct tps_pmic *tps = rdev_get_drvdata(dev);
	186	int data, dcdc = rdev_get_id(dev);
	187	u8 shift;
	188
	189	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	190	return -EINVAL;
	191
	192	shift = TPS65023_NUM_REGULATOR - dcdc;
	193	data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);
	194
	195	if (data < 0)
	196	return data;
	197	else
	198	return (data & 1<<shift) ? 1 : 0;
	199	}
	200
	201	static int tps65023_ldo_is_enabled(struct regulator_dev *dev)
	202	{
	203	struct tps_pmic *tps = rdev_get_drvdata(dev);
	204	int data, ldo = rdev_get_id(dev);
	205	u8 shift;
	206
	207	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	208	return -EINVAL;
	209
	210	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
	211	data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);
	212
	213	if (data < 0)
	214	return data;
	215	else
	216	return (data & 1<<shift) ? 1 : 0;
	217	}
	218
	219	static int tps65023_dcdc_enable(struct regulator_dev *dev)
	220	{
	221	struct tps_pmic *tps = rdev_get_drvdata(dev);
	222	int dcdc = rdev_get_id(dev);
	223	u8 shift;
	224
	225	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	226	return -EINVAL;
	227
	228	shift = TPS65023_NUM_REGULATOR - dcdc;
	229	return tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
	230	}
	231
	232	static int tps65023_dcdc_disable(struct regulator_dev *dev)
	233	{
	234	struct tps_pmic *tps = rdev_get_drvdata(dev);
	235	int dcdc = rdev_get_id(dev);
	236	u8 shift;
	237
	238	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	239	return -EINVAL;
	240
	241	shift = TPS65023_NUM_REGULATOR - dcdc;
	242	return tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
	243	}
	244
245	static int tps65023_ldo_enable(struct regulator_dev *dev)
246	{
247	struct tps_pmic *tps = rdev_get_drvdata(dev);
248	int ldo = rdev_get_id(dev);
249	u8 shift;
250
251	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
252	return -EINVAL;
253
254	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
255	return tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
256	}
257
258	static int tps65023_ldo_disable(struct regulator_dev *dev)
259	{
260	struct tps_pmic *tps = rdev_get_drvdata(dev);
261	int ldo = rdev_get_id(dev);
262	u8 shift;
263
264	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
265	return -EINVAL;
266
267	shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
268	return tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
269	}
270
271	static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
272	{
273	struct tps_pmic *tps = rdev_get_drvdata(dev);
274	int data, dcdc = rdev_get_id(dev);
275
276	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
277	return -EINVAL;
278
1c3ede05	279	if (dcdc == tps->core_regulator) {
30e6599d AA	280	data = tps_65023_reg_read(tps, TPS65023_REG_DEF_CORE);
	281	if (data < 0)
	282	return data;
	283	data &= (tps->info[dcdc]->table_len - 1);
	284	return tps->info[dcdc]->table[data] * 1000;
	285	} else
	286	return tps->info[dcdc]->min_uV;
	287	}
	288
	289	static int tps65023_dcdc_set_voltage(struct regulator_dev *dev,
3a93f2a9 MB	290	int min_uV, int max_uV,
3a93f2a9 MB	291	unsigned *selector)
30e6599d AA	292	{
	293	struct tps_pmic *tps = rdev_get_drvdata(dev);
	294	int dcdc = rdev_get_id(dev);
	295	int vsel;
cc17ef3f	296	int ret;
30e6599d	297
1c3ede05	298	if (dcdc != tps->core_regulator)
30e6599d	299	return -EINVAL;
30e6599d AA	300	if (min_uV < tps->info[dcdc]->min_uV
	301	\|\| min_uV > tps->info[dcdc]->max_uV)
	302	return -EINVAL;
	303	if (max_uV < tps->info[dcdc]->min_uV
	304	\|\| max_uV > tps->info[dcdc]->max_uV)
	305	return -EINVAL;
	306
	307	for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
	308	int mV = tps->info[dcdc]->table[vsel];
	309	int uV = mV * 1000;
	310
	311	/* Break at the first in-range value */
	312	if (min_uV <= uV && uV <= max_uV)
	313	break;
	314	}
	315
3a93f2a9 MB	316	*selector = vsel;
3a93f2a9 MB	317
30e6599d	318	if (vsel == tps->info[dcdc]->table_len)
cc17ef3f MF	319	goto failed;
	320
	321	ret = tps_65023_reg_write(tps, TPS65023_REG_DEF_CORE, vsel);
	322
	323	/* Tell the chip that we have changed the value in DEFCORE
	324	* and its time to update the core voltage
	325	*/
	326	tps_65023_set_bits(tps, TPS65023_REG_CON_CTRL2,
	327	TPS65023_REG_CTRL2_GO);
	328
	329	return ret;
	330
	331	failed:
	332	return -EINVAL;
30e6599d AA	333	}
	334
	335	static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
	336	{
	337	struct tps_pmic *tps = rdev_get_drvdata(dev);
	338	int data, ldo = rdev_get_id(dev);
	339
	340	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	341	return -EINVAL;
	342
	343	data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
	344	if (data < 0)
	345	return data;
	346
	347	data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
	348	data &= (tps->info[ldo]->table_len - 1);
	349	return tps->info[ldo]->table[data] * 1000;
	350	}
	351
	352	static int tps65023_ldo_set_voltage(struct regulator_dev *dev,
3a93f2a9	353	int min_uV, int max_uV, unsigned *selector)
30e6599d AA	354	{
	355	struct tps_pmic *tps = rdev_get_drvdata(dev);
	356	int data, vsel, ldo = rdev_get_id(dev);
	357
	358	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	359	return -EINVAL;
	360
	361	if (min_uV < tps->info[ldo]->min_uV \|\| min_uV > tps->info[ldo]->max_uV)
	362	return -EINVAL;
	363	if (max_uV < tps->info[ldo]->min_uV \|\| max_uV > tps->info[ldo]->max_uV)
	364	return -EINVAL;
	365
	366	for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
	367	int mV = tps->info[ldo]->table[vsel];
	368	int uV = mV * 1000;
	369
	370	/* Break at the first in-range value */
	371	if (min_uV <= uV && uV <= max_uV)
	372	break;
	373	}
	374
	375	if (vsel == tps->info[ldo]->table_len)
	376	return -EINVAL;
	377
3a93f2a9 MB	378	*selector = vsel;
3a93f2a9 MB	379
30e6599d AA	380	data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
	381	if (data < 0)
	382	return data;
	383
	384	data &= TPS65023_LDO_CTRL_LDOx_MASK(ldo - TPS65023_LDO_1);
	385	data \|= (vsel << (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1)));
	386	return tps_65023_reg_write(tps, TPS65023_REG_LDO_CTRL, data);
	387	}
	388
	389	static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
	390	unsigned selector)
	391	{
	392	struct tps_pmic *tps = rdev_get_drvdata(dev);
	393	int dcdc = rdev_get_id(dev);
	394
	395	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	396	return -EINVAL;
	397
1c3ede05	398	if (dcdc == tps->core_regulator) {
30e6599d AA	399	if (selector >= tps->info[dcdc]->table_len)
	400	return -EINVAL;
	401	else
	402	return tps->info[dcdc]->table[selector] * 1000;
	403	} else
	404	return tps->info[dcdc]->min_uV;
	405	}
	406
	407	static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
	408	unsigned selector)
	409	{
	410	struct tps_pmic *tps = rdev_get_drvdata(dev);
	411	int ldo = rdev_get_id(dev);
	412
	413	if (ldo < TPS65023_LDO_1 \|\| ldo > TPS65023_LDO_2)
	414	return -EINVAL;
	415
	416	if (selector >= tps->info[ldo]->table_len)
	417	return -EINVAL;
	418	else
	419	return tps->info[ldo]->table[selector] * 1000;
	420	}
	421
	422	/* Operations permitted on VDCDCx */
	423	static struct regulator_ops tps65023_dcdc_ops = {
	424	.is_enabled = tps65023_dcdc_is_enabled,
	425	.enable = tps65023_dcdc_enable,
	426	.disable = tps65023_dcdc_disable,
	427	.get_voltage = tps65023_dcdc_get_voltage,
	428	.set_voltage = tps65023_dcdc_set_voltage,
	429	.list_voltage = tps65023_dcdc_list_voltage,
	430	};
	431
	432	/* Operations permitted on LDOx */
	433	static struct regulator_ops tps65023_ldo_ops = {
	434	.is_enabled = tps65023_ldo_is_enabled,
	435	.enable = tps65023_ldo_enable,
	436	.disable = tps65023_ldo_disable,
	437	.get_voltage = tps65023_ldo_get_voltage,
	438	.set_voltage = tps65023_ldo_set_voltage,
	439	.list_voltage = tps65023_ldo_list_voltage,
	440	};
	441
90923351 MB	442	static struct regmap_config tps65023_regmap_config = {
	443	.reg_bits = 8,
	444	.val_bits = 8,
	445	};
	446
54d13ab1 DT	447	static int __devinit tps_65023_probe(struct i2c_client *client,
54d13ab1 DT	448	const struct i2c_device_id *id)
30e6599d	449	{
1c3ede05 MF	450	const struct tps_driver_data drv_data = (void )id->driver_data;
1c3ede05 MF	451	const struct tps_info *info = drv_data->info;
30e6599d AA	452	struct regulator_init_data *init_data;
	453	struct regulator_dev *rdev;
	454	struct tps_pmic *tps;
	455	int i;
54d13ab1	456	int error;
30e6599d AA	457
	458	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	459	return -EIO;
	460
	461	/**
	462	* init_data points to array of regulator_init structures
	463	* coming from the board-evm file.
	464	*/
	465	init_data = client->dev.platform_data;
30e6599d AA	466	if (!init_data)
	467	return -EIO;
	468
	469	tps = kzalloc(sizeof(*tps), GFP_KERNEL);
	470	if (!tps)
	471	return -ENOMEM;
	472
90923351 MB	473	tps->regmap = regmap_init_i2c(client, &tps65023_regmap_config);
	474	if (IS_ERR(tps->regmap)) {
	475	error = PTR_ERR(tps->regmap);
	476	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	477	error);
	478	goto fail_alloc;
	479	}
30e6599d AA	480
	481	/* common for all regulators */
	482	tps->client = client;
1c3ede05	483	tps->core_regulator = drv_data->core_regulator;
30e6599d AA	484
	485	for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
	486	/* Store regulator specific information */
	487	tps->info[i] = info;
	488
	489	tps->desc[i].name = info->name;
77fa44d0	490	tps->desc[i].id = i;
1c3ede05	491	tps->desc[i].n_voltages = info->table_len;
30e6599d AA	492	tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
	493	&tps65023_ldo_ops : &tps65023_dcdc_ops);
	494	tps->desc[i].type = REGULATOR_VOLTAGE;
	495	tps->desc[i].owner = THIS_MODULE;
	496
	497	/* Register the regulators */
	498	rdev = regulator_register(&tps->desc[i], &client->dev,
54d13ab1	499	init_data, tps);
30e6599d AA	500	if (IS_ERR(rdev)) {
	501	dev_err(&client->dev, "failed to register %s\n",
	502	id->name);
54d13ab1 DT	503	error = PTR_ERR(rdev);
54d13ab1 DT	504	goto fail;
30e6599d AA	505	}
	506
	507	/* Save regulator for cleanup */
	508	tps->rdev[i] = rdev;
	509	}
	510
	511	i2c_set_clientdata(client, tps);
	512
f068ad8c MF	513	/* Enable setting output voltage by I2C */
	514	tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
	515	TPS65023_REG_CTRL2_CORE_ADJ);
	516
fc999b83 MF	517	/* Enable setting output voltage by I2C */
	518	tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
	519	TPS65023_REG_CTRL2_CORE_ADJ);
	520
30e6599d	521	return 0;
54d13ab1 DT	522
	523	fail:
	524	while (--i >= 0)
	525	regulator_unregister(tps->rdev[i]);
	526
90923351 MB	527	regmap_exit(tps->regmap);
90923351 MB	528	fail_alloc:
54d13ab1 DT	529	kfree(tps);
54d13ab1 DT	530	return error;
30e6599d AA	531	}
	532
	533	/**
	534	* tps_65023_remove - TPS65023 driver i2c remove handler
	535	* @client: i2c driver client device structure
	536	*
	537	* Unregister TPS driver as an i2c client device driver
	538	*/
	539	static int __devexit tps_65023_remove(struct i2c_client *client)
	540	{
	541	struct tps_pmic *tps = i2c_get_clientdata(client);
	542	int i;
	543
	544	for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
	545	regulator_unregister(tps->rdev[i]);
	546
90923351	547	regmap_exit(tps->regmap);
30e6599d AA	548	kfree(tps);
	549
	550	return 0;
	551	}
	552
437afd2a MF	553	static const struct tps_info tps65020_regs[] = {
	554	{
	555	.name = "VDCDC1",
	556	.min_uV = 3300000,
	557	.max_uV = 3300000,
	558	.fixed = 1,
	559	},
	560	{
	561	.name = "VDCDC2",
	562	.min_uV = 1800000,
	563	.max_uV = 1800000,
	564	.fixed = 1,
	565	},
	566	{
	567	.name = "VDCDC3",
	568	.min_uV = 800000,
	569	.max_uV = 1600000,
	570	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
	571	.table = VCORE_VSEL_table,
	572	},
	573
	574	{
	575	.name = "LDO1",
	576	.min_uV = 1000000,
	577	.max_uV = 3150000,
	578	.table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
	579	.table = TPS65020_LDO1_VSEL_table,
	580	},
	581	{
	582	.name = "LDO2",
	583	.min_uV = 1050000,
	584	.max_uV = 3300000,
	585	.table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
	586	.table = TPS65020_LDO2_VSEL_table,
	587	},
	588	};
	589
1c3ede05 MF	590	static const struct tps_info tps65021_regs[] = {
	591	{
	592	.name = "VDCDC1",
	593	.min_uV = 3300000,
	594	.max_uV = 3300000,
	595	.fixed = 1,
	596	},
	597	{
	598	.name = "VDCDC2",
	599	.min_uV = 1800000,
	600	.max_uV = 1800000,
	601	.fixed = 1,
	602	},
	603	{
	604	.name = "VDCDC3",
	605	.min_uV = 800000,
	606	.max_uV = 1600000,
	607	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
	608	.table = VCORE_VSEL_table,
	609	},
	610	{
	611	.name = "LDO1",
	612	.min_uV = 1000000,
	613	.max_uV = 3150000,
	614	.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
	615	.table = TPS65023_LDO1_VSEL_table,
	616	},
	617	{
	618	.name = "LDO2",
	619	.min_uV = 1050000,
	620	.max_uV = 3300000,
	621	.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
	622	.table = TPS65023_LDO2_VSEL_table,
	623	},
	624	};
	625
30e6599d AA	626	static const struct tps_info tps65023_regs[] = {
	627	{
	628	.name = "VDCDC1",
	629	.min_uV = 800000,
	630	.max_uV = 1600000,
1c3ede05 MF	631	.table_len = ARRAY_SIZE(VCORE_VSEL_table),
1c3ede05 MF	632	.table = VCORE_VSEL_table,
30e6599d AA	633	},
	634	{
	635	.name = "VDCDC2",
	636	.min_uV = 3300000,
	637	.max_uV = 3300000,
	638	.fixed = 1,
	639	},
	640	{
	641	.name = "VDCDC3",
	642	.min_uV = 1800000,
	643	.max_uV = 1800000,
	644	.fixed = 1,
	645	},
	646	{
	647	.name = "LDO1",
	648	.min_uV = 1000000,
	649	.max_uV = 3150000,
1c3ede05 MF	650	.table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
1c3ede05 MF	651	.table = TPS65023_LDO1_VSEL_table,
30e6599d AA	652	},
	653	{
	654	.name = "LDO2",
	655	.min_uV = 1050000,
	656	.max_uV = 3300000,
1c3ede05 MF	657	.table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
1c3ede05 MF	658	.table = TPS65023_LDO2_VSEL_table,
30e6599d AA	659	},
	660	};
	661
437afd2a MF	662	static struct tps_driver_data tps65020_drv_data = {
	663	.info = tps65020_regs,
	664	.core_regulator = TPS65023_DCDC_3,
	665	};
	666
1c3ede05 MF	667	static struct tps_driver_data tps65021_drv_data = {
	668	.info = tps65021_regs,
	669	.core_regulator = TPS65023_DCDC_3,
	670	};
	671
	672	static struct tps_driver_data tps65023_drv_data = {
	673	.info = tps65023_regs,
	674	.core_regulator = TPS65023_DCDC_1,
	675	};
	676
9e108d33 LG	677	static const struct i2c_device_id tps_65023_id[] = {
9e108d33 LG	678	{.name = "tps65023",
1c3ede05	679	.driver_data = (unsigned long) &tps65023_drv_data},
1880a2fc	680	{.name = "tps65021",
1c3ede05	681	.driver_data = (unsigned long) &tps65021_drv_data,},
437afd2a MF	682	{.name = "tps65020",
437afd2a MF	683	.driver_data = (unsigned long) &tps65020_drv_data},
9e108d33	684	{ },
30e6599d AA	685	};
	686
	687	MODULE_DEVICE_TABLE(i2c, tps_65023_id);
	688
	689	static struct i2c_driver tps_65023_i2c_driver = {
	690	.driver = {
	691	.name = "tps65023",
	692	.owner = THIS_MODULE,
	693	},
	694	.probe = tps_65023_probe,
	695	.remove = __devexit_p(tps_65023_remove),
9e108d33	696	.id_table = tps_65023_id,
30e6599d AA	697	};
	698
	699	/**
	700	* tps_65023_init
	701	*
	702	* Module init function
	703	*/
	704	static int __init tps_65023_init(void)
	705	{
	706	return i2c_add_driver(&tps_65023_i2c_driver);
	707	}
	708	subsys_initcall(tps_65023_init);
	709
	710	/**
	711	* tps_65023_cleanup
	712	*
	713	* Module exit function
	714	*/
	715	static void __exit tps_65023_cleanup(void)
	716	{
	717	i2c_del_driver(&tps_65023_i2c_driver);
	718	}
	719	module_exit(tps_65023_cleanup);
	720
	721	MODULE_AUTHOR("Texas Instruments");
	722	MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
9e108d33	723	MODULE_LICENSE("GPL v2");