[mirror_ubuntu-artful-kernel.git] / drivers / regulator / tps6507x-regulator.c

/*
 * tps6507x-regulator.c
 *
 * Regulator driver for TPS65073 PMIC
 *
 * 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>

/* Register definitions */
#define	TPS6507X_REG_PPATH1				0X01
#define	TPS6507X_REG_INT				0X02
#define	TPS6507X_REG_CHGCONFIG0				0X03
#define	TPS6507X_REG_CHGCONFIG1				0X04
#define	TPS6507X_REG_CHGCONFIG2				0X05
#define	TPS6507X_REG_CHGCONFIG3				0X06
#define	TPS6507X_REG_REG_ADCONFIG			0X07
#define	TPS6507X_REG_TSCMODE				0X08
#define	TPS6507X_REG_ADRESULT_1				0X09
#define	TPS6507X_REG_ADRESULT_2				0X0A
#define	TPS6507X_REG_PGOOD				0X0B
#define	TPS6507X_REG_PGOODMASK				0X0C
#define	TPS6507X_REG_CON_CTRL1				0X0D
#define	TPS6507X_REG_CON_CTRL2				0X0E
#define	TPS6507X_REG_CON_CTRL3				0X0F
#define	TPS6507X_REG_DEFDCDC1				0X10
#define	TPS6507X_REG_DEFDCDC2_LOW			0X11
#define	TPS6507X_REG_DEFDCDC2_HIGH			0X12
#define	TPS6507X_REG_DEFDCDC3_LOW			0X13
#define	TPS6507X_REG_DEFDCDC3_HIGH			0X14
#define	TPS6507X_REG_DEFSLEW				0X15
#define	TPS6507X_REG_LDO_CTRL1				0X16
#define	TPS6507X_REG_DEFLDO2				0X17
#define	TPS6507X_REG_WLED_CTRL1				0X18
#define	TPS6507X_REG_WLED_CTRL2				0X19

/* CON_CTRL1 bitfields */
#define	TPS6507X_CON_CTRL1_DCDC1_ENABLE		BIT(4)
#define	TPS6507X_CON_CTRL1_DCDC2_ENABLE		BIT(3)
#define	TPS6507X_CON_CTRL1_DCDC3_ENABLE		BIT(2)
#define	TPS6507X_CON_CTRL1_LDO1_ENABLE		BIT(1)
#define	TPS6507X_CON_CTRL1_LDO2_ENABLE		BIT(0)

/* DEFDCDC1 bitfields */
#define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN	BIT(7)
#define TPS6507X_DEFDCDC1_DCDC1_MASK		0X3F

/* DEFDCDC2_LOW bitfields */
#define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK	0X3F

/* DEFDCDC2_HIGH bitfields */
#define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK	0X3F

/* DEFDCDC3_LOW bitfields */
#define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK	0X3F

/* DEFDCDC3_HIGH bitfields */
#define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK	0X3F

/* TPS6507X_REG_LDO_CTRL1 bitfields */
#define TPS6507X_REG_LDO_CTRL1_LDO1_MASK	0X0F

/* TPS6507X_REG_DEFLDO2 bitfields */
#define TPS6507X_REG_DEFLDO2_LDO2_MASK		0X3F

/* VDCDC MASK */
#define TPS6507X_DEFDCDCX_DCDC_MASK		0X3F

/* DCDC's */
#define TPS6507X_DCDC_1				0
#define TPS6507X_DCDC_2				1
#define TPS6507X_DCDC_3				2
/* LDOs */
#define TPS6507X_LDO_1				3
#define TPS6507X_LDO_2				4

#define TPS6507X_MAX_REG_ID			TPS6507X_LDO_2

/* Number of step-down converters available */
#define TPS6507X_NUM_DCDC			3
/* Number of LDO voltage regulators  available */
#define TPS6507X_NUM_LDO			2
/* Number of total regulators available */
#define TPS6507X_NUM_REGULATOR		(TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)

/* Supported voltage values for regulators (in milliVolts) */
static const u16 VDCDCx_VSEL_table[] = {
	725, 750, 775, 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,
	1550, 1600, 1650, 1700,
	1750, 1800, 1850, 1900,
	1950, 2000, 2050, 2100,
	2150, 2200, 2250, 2300,
	2350, 2400, 2450, 2500,
	2550, 2600, 2650, 2700,
	2750, 2800, 2850, 2900,
	3000, 3100, 3200, 3300,
};

static const u16 LDO1_VSEL_table[] = {
	1000, 1100, 1200, 1250,
	1300, 1350, 1400, 1500,
	1600, 1800, 2500, 2750,
	2800, 3000, 3100, 3300,
};

static const u16 LDO2_VSEL_table[] = {
	725, 750, 775, 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,
	1550, 1600, 1650, 1700,
	1750, 1800, 1850, 1900,
	1950, 2000, 2050, 2100,
	2150, 2200, 2250, 2300,
	2350, 2400, 2450, 2500,
	2550, 2600, 2650, 2700,
	2750, 2800, 2850, 2900,
	3000, 3100, 3200, 3300,
};

static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table),
				ARRAY_SIZE(VDCDCx_VSEL_table),
				ARRAY_SIZE(VDCDCx_VSEL_table),
				ARRAY_SIZE(LDO1_VSEL_table),
				ARRAY_SIZE(LDO2_VSEL_table)};

struct tps_info {
	const char *name;
	unsigned min_uV;
	unsigned max_uV;
	u8 table_len;
	const u16 *table;
};

struct tps_pmic {
	struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
	struct i2c_client *client;
	struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
	const struct tps_info *info[TPS6507X_NUM_REGULATOR];
	struct mutex io_lock;
};

static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg)
{
	return i2c_smbus_read_byte_data(tps->client, reg);
}

static inline int tps_6507x_write(struct tps_pmic *tps, u8 reg, u8 val)
{
	return i2c_smbus_write_byte_data(tps->client, reg, val);
}

static int tps_6507x_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
{
	int err, data;

	mutex_lock(&tps->io_lock);

	data = tps_6507x_read(tps, reg);
	if (data < 0) {
		dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
		err = data;
		goto out;
	}

	data |= mask;
	err = tps_6507x_write(tps, reg, data);
	if (err)
		dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);

out:
	mutex_unlock(&tps->io_lock);
	return err;
}

static int tps_6507x_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
{
	int err, data;

	mutex_lock(&tps->io_lock);

	data = tps_6507x_read(tps, reg);
	if (data < 0) {
		dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
		err = data;
		goto out;
	}

	data &= ~mask;
	err = tps_6507x_write(tps, reg, data);
	if (err)
		dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);

out:
	mutex_unlock(&tps->io_lock);
	return err;
}

static int tps_6507x_reg_read(struct tps_pmic *tps, u8 reg)
{
	int data;

	mutex_lock(&tps->io_lock);

	data = tps_6507x_read(tps, reg);
	if (data < 0)
		dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);

	mutex_unlock(&tps->io_lock);
	return data;
}

static int tps_6507x_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
{
	int err;

	mutex_lock(&tps->io_lock);

	err = tps_6507x_write(tps, reg, val);
	if (err < 0)
		dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);

	mutex_unlock(&tps->io_lock);
	return err;
}

static int tps6507x_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 < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - dcdc;
	data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);

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

static int tps6507x_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 < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - ldo;
	data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);

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

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

	if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - dcdc;
	return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
}

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

	if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - dcdc;
	return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
}

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

	if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - ldo;
	return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
}

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

	if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
		return -EINVAL;

	shift = TPS6507X_MAX_REG_ID - ldo;
	return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
}

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

	switch (dcdc) {
	case TPS6507X_DCDC_1:
		reg = TPS6507X_REG_DEFDCDC1;
		break;
	case TPS6507X_DCDC_2:
		reg = TPS6507X_REG_DEFDCDC2_LOW;
		break;
	case TPS6507X_DCDC_3:
		reg = TPS6507X_REG_DEFDCDC3_LOW;
		break;
	default:
		return -EINVAL;
	}

	data = tps_6507x_reg_read(tps, reg);
	if (data < 0)
		return data;

	data &= TPS6507X_DEFDCDCX_DCDC_MASK;
	return tps->info[dcdc]->table[data] * 1000;
}

static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev,
				int min_uV, int max_uV)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, vsel, dcdc = rdev_get_id(dev);
	u8 reg;

	switch (dcdc) {
	case TPS6507X_DCDC_1:
		reg = TPS6507X_REG_DEFDCDC1;
		break;
	case TPS6507X_DCDC_2:
		reg = TPS6507X_REG_DEFDCDC2_LOW;
		break;
	case TPS6507X_DCDC_3:
		reg = TPS6507X_REG_DEFDCDC3_LOW;
		break;
	default:
		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;
	}

	/* write to the register in case we found a match */
	if (vsel == tps->info[dcdc]->table_len)
		return -EINVAL;

	data = tps_6507x_reg_read(tps, reg);
	if (data < 0)
		return data;

	data &= ~TPS6507X_DEFDCDCX_DCDC_MASK;
	data |= vsel;

	return tps_6507x_reg_write(tps, reg, data);
}

static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, ldo = rdev_get_id(dev);
	u8 reg, mask;

	if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
		return -EINVAL;
	else {
		reg = (ldo == TPS6507X_LDO_1 ?
			TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
		mask = (ldo == TPS6507X_LDO_1 ?
			TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
				TPS6507X_REG_DEFLDO2_LDO2_MASK);
	}

	data = tps_6507x_reg_read(tps, reg);
	if (data < 0)
		return data;

	data &= mask;
	return tps->info[ldo]->table[data] * 1000;
}

static int tps6507x_ldo_set_voltage(struct regulator_dev *dev,
				int min_uV, int max_uV)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int data, vsel, ldo = rdev_get_id(dev);
	u8 reg, mask;

	if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
		return -EINVAL;
	else {
		reg = (ldo == TPS6507X_LDO_1 ?
			TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
		mask = (ldo == TPS6507X_LDO_1 ?
			TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
				TPS6507X_REG_DEFLDO2_LDO2_MASK);
	}

	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;

	data = tps_6507x_reg_read(tps, reg);
	if (data < 0)
		return data;

	data &= ~mask;
	data |= vsel;

	return tps_6507x_reg_write(tps, reg, data);
}

static int tps6507x_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 < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
		return -EINVAL;

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

static int tps6507x_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 < TPS6507X_LDO_1 || ldo > TPS6507X_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 tps6507x_dcdc_ops = {
	.is_enabled = tps6507x_dcdc_is_enabled,
	.enable = tps6507x_dcdc_enable,
	.disable = tps6507x_dcdc_disable,
	.get_voltage = tps6507x_dcdc_get_voltage,
	.set_voltage = tps6507x_dcdc_set_voltage,
	.list_voltage = tps6507x_dcdc_list_voltage,
};

/* Operations permitted on LDOx */
static struct regulator_ops tps6507x_ldo_ops = {
	.is_enabled = tps6507x_ldo_is_enabled,
	.enable = tps6507x_ldo_enable,
	.disable = tps6507x_ldo_disable,
	.get_voltage = tps6507x_ldo_get_voltage,
	.set_voltage = tps6507x_ldo_set_voltage,
	.list_voltage = tps6507x_ldo_list_voltage,
};

static
int tps_6507x_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	static int desc_id;
	const struct tps_info *info = (void *)id->driver_data;
	struct regulator_init_data *init_data;
	struct regulator_dev *rdev;
	struct tps_pmic *tps;
	int i;

	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;

	mutex_init(&tps->io_lock);

	/* common for all regulators */
	tps->client = client;

	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
		/* Register the regulators */
		tps->info[i] = info;
		tps->desc[i].name = info->name;
		tps->desc[i].id = desc_id++;
		tps->desc[i].n_voltages = num_voltages[i];
		tps->desc[i].ops = (i > TPS6507X_DCDC_3 ?
				&tps6507x_ldo_ops : &tps6507x_dcdc_ops);
		tps->desc[i].type = REGULATOR_VOLTAGE;
		tps->desc[i].owner = THIS_MODULE;

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

			/* Unregister */
			while (i)
				regulator_unregister(tps->rdev[--i]);

			tps->client = NULL;

			/* clear the client data in i2c */
			i2c_set_clientdata(client, NULL);

			kfree(tps);
			return PTR_ERR(rdev);
		}

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

	i2c_set_clientdata(client, tps);

	return 0;
}

/**
 * tps_6507x_remove - TPS6507x driver i2c remove handler
 * @client: i2c driver client device structure
 *
 * Unregister TPS driver as an i2c client device driver
 */
static int __devexit tps_6507x_remove(struct i2c_client *client)
{
	struct tps_pmic *tps = i2c_get_clientdata(client);
	int i;

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

	tps->client = NULL;

	/* clear the client data in i2c */
	i2c_set_clientdata(client, NULL);
	kfree(tps);

	return 0;
}

static const struct tps_info tps6507x_regs[] = {
	{
		.name = "VDCDC1",
		.min_uV = 725000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
		.table = VDCDCx_VSEL_table,
	},
	{
		.name = "VDCDC2",
		.min_uV = 725000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
		.table = VDCDCx_VSEL_table,
	},
	{
		.name = "VDCDC3",
		.min_uV = 725000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
		.table = VDCDCx_VSEL_table,
	},
	{
		.name = "LDO1",
		.min_uV = 1000000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(LDO1_VSEL_table),
		.table = LDO1_VSEL_table,
	},
	{
		.name = "LDO2",
		.min_uV = 725000,
		.max_uV = 3300000,
		.table_len = ARRAY_SIZE(LDO2_VSEL_table),
		.table = LDO2_VSEL_table,
	},
};

static const struct i2c_device_id tps_6507x_id[] = {
	{.name = "tps6507x",
	.driver_data = (unsigned long) tps6507x_regs,},
	{ },
};
MODULE_DEVICE_TABLE(i2c, tps_6507x_id);

static struct i2c_driver tps_6507x_i2c_driver = {
	.driver = {
		.name = "tps6507x",
		.owner = THIS_MODULE,
	},
	.probe = tps_6507x_probe,
	.remove = __devexit_p(tps_6507x_remove),
	.id_table = tps_6507x_id,
};

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

/**
 * tps_6507x_cleanup
 *
 * Module exit function
 */
static void __exit tps_6507x_cleanup(void)
{
	i2c_del_driver(&tps_6507x_i2c_driver);
}
module_exit(tps_6507x_cleanup);

MODULE_AUTHOR("Texas Instruments");
MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
3fa5b8e0 AA	1	/*
	2	* tps6507x-regulator.c
	3	*
	4	* Regulator driver for TPS65073 PMIC
	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>
	27
	28	/* Register definitions */
	29	#define TPS6507X_REG_PPATH1 0X01
	30	#define TPS6507X_REG_INT 0X02
	31	#define TPS6507X_REG_CHGCONFIG0 0X03
	32	#define TPS6507X_REG_CHGCONFIG1 0X04
	33	#define TPS6507X_REG_CHGCONFIG2 0X05
	34	#define TPS6507X_REG_CHGCONFIG3 0X06
	35	#define TPS6507X_REG_REG_ADCONFIG 0X07
	36	#define TPS6507X_REG_TSCMODE 0X08
	37	#define TPS6507X_REG_ADRESULT_1 0X09
	38	#define TPS6507X_REG_ADRESULT_2 0X0A
	39	#define TPS6507X_REG_PGOOD 0X0B
	40	#define TPS6507X_REG_PGOODMASK 0X0C
	41	#define TPS6507X_REG_CON_CTRL1 0X0D
	42	#define TPS6507X_REG_CON_CTRL2 0X0E
	43	#define TPS6507X_REG_CON_CTRL3 0X0F
	44	#define TPS6507X_REG_DEFDCDC1 0X10
	45	#define TPS6507X_REG_DEFDCDC2_LOW 0X11
	46	#define TPS6507X_REG_DEFDCDC2_HIGH 0X12
	47	#define TPS6507X_REG_DEFDCDC3_LOW 0X13
	48	#define TPS6507X_REG_DEFDCDC3_HIGH 0X14
	49	#define TPS6507X_REG_DEFSLEW 0X15
	50	#define TPS6507X_REG_LDO_CTRL1 0X16
	51	#define TPS6507X_REG_DEFLDO2 0X17
	52	#define TPS6507X_REG_WLED_CTRL1 0X18
	53	#define TPS6507X_REG_WLED_CTRL2 0X19
	54
	55	/* CON_CTRL1 bitfields */
	56	#define TPS6507X_CON_CTRL1_DCDC1_ENABLE BIT(4)
	57	#define TPS6507X_CON_CTRL1_DCDC2_ENABLE BIT(3)
	58	#define TPS6507X_CON_CTRL1_DCDC3_ENABLE BIT(2)
	59	#define TPS6507X_CON_CTRL1_LDO1_ENABLE BIT(1)
	60	#define TPS6507X_CON_CTRL1_LDO2_ENABLE BIT(0)
	61
	62	/* DEFDCDC1 bitfields */
	63	#define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN BIT(7)
	64	#define TPS6507X_DEFDCDC1_DCDC1_MASK 0X3F
65
66	/* DEFDCDC2_LOW bitfields */
67	#define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK 0X3F
68
69	/* DEFDCDC2_HIGH bitfields */
70	#define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK 0X3F
71
72	/* DEFDCDC3_LOW bitfields */
73	#define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK 0X3F
74
75	/* DEFDCDC3_HIGH bitfields */
76	#define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK 0X3F
77
78	/* TPS6507X_REG_LDO_CTRL1 bitfields */
79	#define TPS6507X_REG_LDO_CTRL1_LDO1_MASK 0X0F
80
81	/* TPS6507X_REG_DEFLDO2 bitfields */
82	#define TPS6507X_REG_DEFLDO2_LDO2_MASK 0X3F
83
84	/* VDCDC MASK */
85	#define TPS6507X_DEFDCDCX_DCDC_MASK 0X3F
86
87	/* DCDC's */
88	#define TPS6507X_DCDC_1 0
89	#define TPS6507X_DCDC_2 1
90	#define TPS6507X_DCDC_3 2
91	/* LDOs */
92	#define TPS6507X_LDO_1 3
93	#define TPS6507X_LDO_2 4
94
95	#define TPS6507X_MAX_REG_ID TPS6507X_LDO_2
96
97	/* Number of step-down converters available */
98	#define TPS6507X_NUM_DCDC 3
99	/* Number of LDO voltage regulators available */
100	#define TPS6507X_NUM_LDO 2
101	/* Number of total regulators available */
102	#define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
103
104	/* Supported voltage values for regulators (in milliVolts) */
105	static const u16 VDCDCx_VSEL_table[] = {
106	725, 750, 775, 800,
107	825, 850, 875, 900,
108	925, 950, 975, 1000,
109	1025, 1050, 1075, 1100,
110	1125, 1150, 1175, 1200,
111	1225, 1250, 1275, 1300,
112	1325, 1350, 1375, 1400,
113	1425, 1450, 1475, 1500,
114	1550, 1600, 1650, 1700,
115	1750, 1800, 1850, 1900,
116	1950, 2000, 2050, 2100,
117	2150, 2200, 2250, 2300,
118	2350, 2400, 2450, 2500,
119	2550, 2600, 2650, 2700,
120	2750, 2800, 2850, 2900,
121	3000, 3100, 3200, 3300,
122	};
123
124	static const u16 LDO1_VSEL_table[] = {
125	1000, 1100, 1200, 1250,
126	1300, 1350, 1400, 1500,
127	1600, 1800, 2500, 2750,
128	2800, 3000, 3100, 3300,
129	};
130
131	static const u16 LDO2_VSEL_table[] = {
132	725, 750, 775, 800,
133	825, 850, 875, 900,
134	925, 950, 975, 1000,
135	1025, 1050, 1075, 1100,
136	1125, 1150, 1175, 1200,
137	1225, 1250, 1275, 1300,
138	1325, 1350, 1375, 1400,
139	1425, 1450, 1475, 1500,
140	1550, 1600, 1650, 1700,
141	1750, 1800, 1850, 1900,
142	1950, 2000, 2050, 2100,
143	2150, 2200, 2250, 2300,
144	2350, 2400, 2450, 2500,
145	2550, 2600, 2650, 2700,
146	2750, 2800, 2850, 2900,
147	3000, 3100, 3200, 3300,
148	};
149
150	static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table),
151	ARRAY_SIZE(VDCDCx_VSEL_table),
152	ARRAY_SIZE(VDCDCx_VSEL_table),
153	ARRAY_SIZE(LDO1_VSEL_table),
154	ARRAY_SIZE(LDO2_VSEL_table)};
155
156	struct tps_info {
157	const char *name;
158	unsigned min_uV;
159	unsigned max_uV;
160	u8 table_len;
161	const u16 *table;
162	};
163
164	struct tps_pmic {
165	struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
166	struct i2c_client *client;
167	struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
168	const struct tps_info *info[TPS6507X_NUM_REGULATOR];
169	struct mutex io_lock;
170	};
171
172	static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg)
173	{
174	return i2c_smbus_read_byte_data(tps->client, reg);
175	}
176
177	static inline int tps_6507x_write(struct tps_pmic *tps, u8 reg, u8 val)
178	{
179	return i2c_smbus_write_byte_data(tps->client, reg, val);
180	}
181
182	static int tps_6507x_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
183	{
184	int err, data;
185
186	mutex_lock(&tps->io_lock);
187
188	data = tps_6507x_read(tps, reg);
189	if (data < 0) {
190	dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
191	err = data;
192	goto out;
193	}
194
195	data \|= mask;
196	err = tps_6507x_write(tps, reg, data);
197	if (err)
198	dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
199
200	out:
201	mutex_unlock(&tps->io_lock);
202	return err;
203	}
204
205	static int tps_6507x_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
206	{
207	int err, data;
208
209	mutex_lock(&tps->io_lock);
210
211	data = tps_6507x_read(tps, reg);
212	if (data < 0) {
213	dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
214	err = data;
215	goto out;
216	}
217
218	data &= ~mask;
219	err = tps_6507x_write(tps, reg, data);
220	if (err)
221	dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
222
223	out:
224	mutex_unlock(&tps->io_lock);
225	return err;
226	}
227
228	static int tps_6507x_reg_read(struct tps_pmic *tps, u8 reg)
229	{
230	int data;
231
232	mutex_lock(&tps->io_lock);
233
234	data = tps_6507x_read(tps, reg);
235	if (data < 0)
236	dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
237
238	mutex_unlock(&tps->io_lock);
239	return data;
240	}
241
242	static int tps_6507x_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
243	{
244	int err;
245
246	mutex_lock(&tps->io_lock);
247
248	err = tps_6507x_write(tps, reg, val);
249	if (err < 0)
250	dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
251
252	mutex_unlock(&tps->io_lock);
253	return err;
254	}
255
256	static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev)
257	{
258	struct tps_pmic *tps = rdev_get_drvdata(dev);
259	int data, dcdc = rdev_get_id(dev);
260	u8 shift;
261
262	if (dcdc < TPS6507X_DCDC_1 \|\| dcdc > TPS6507X_DCDC_3)
263	return -EINVAL;
264
265	shift = TPS6507X_MAX_REG_ID - dcdc;
266	data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
267
268	if (data < 0)
269	return data;
270	else
271	return (data & 1<<shift) ? 1 : 0;
272	}
273
274	static int tps6507x_ldo_is_enabled(struct regulator_dev *dev)
275	{
276	struct tps_pmic *tps = rdev_get_drvdata(dev);
277	int data, ldo = rdev_get_id(dev);
278	u8 shift;
279
280	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
281	return -EINVAL;
282
283	shift = TPS6507X_MAX_REG_ID - ldo;
284	data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
285
286	if (data < 0)
287	return data;
288	else
289	return (data & 1<<shift) ? 1 : 0;
290	}
291
292	static int tps6507x_dcdc_enable(struct regulator_dev *dev)
293	{
294	struct tps_pmic *tps = rdev_get_drvdata(dev);
295	int dcdc = rdev_get_id(dev);
296	u8 shift;
297
298	if (dcdc < TPS6507X_DCDC_1 \|\| dcdc > TPS6507X_DCDC_3)
299	return -EINVAL;
300
301	shift = TPS6507X_MAX_REG_ID - dcdc;
302	return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
303	}
304
305	static int tps6507x_dcdc_disable(struct regulator_dev *dev)
306	{
307	struct tps_pmic *tps = rdev_get_drvdata(dev);
308	int dcdc = rdev_get_id(dev);
309	u8 shift;
310
311	if (dcdc < TPS6507X_DCDC_1 \|\| dcdc > TPS6507X_DCDC_3)
312	return -EINVAL;
313
314	shift = TPS6507X_MAX_REG_ID - dcdc;
315	return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
316	}
317
318	static int tps6507x_ldo_enable(struct regulator_dev *dev)
319	{
320	struct tps_pmic *tps = rdev_get_drvdata(dev);
321	int ldo = rdev_get_id(dev);
322	u8 shift;
323
324	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
325	return -EINVAL;
326
327	shift = TPS6507X_MAX_REG_ID - ldo;
328	return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
329	}
330
331	static int tps6507x_ldo_disable(struct regulator_dev *dev)
332	{
333	struct tps_pmic *tps = rdev_get_drvdata(dev);
334	int ldo = rdev_get_id(dev);
335	u8 shift;
336
337	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
338	return -EINVAL;
339
340	shift = TPS6507X_MAX_REG_ID - ldo;
341	return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
342	}
343
344	static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev)
345	{
346	struct tps_pmic *tps = rdev_get_drvdata(dev);
347	int data, dcdc = rdev_get_id(dev);
348	u8 reg;
349
350	switch (dcdc) {
351	case TPS6507X_DCDC_1:
352	reg = TPS6507X_REG_DEFDCDC1;
353	break;
354	case TPS6507X_DCDC_2:
355	reg = TPS6507X_REG_DEFDCDC2_LOW;
356	break;
357	case TPS6507X_DCDC_3:
358	reg = TPS6507X_REG_DEFDCDC3_LOW;
359	break;
360	default:
361	return -EINVAL;
362	}
363
364	data = tps_6507x_reg_read(tps, reg);
365	if (data < 0)
366	return data;
367
368	data &= TPS6507X_DEFDCDCX_DCDC_MASK;
369	return tps->info[dcdc]->table[data] * 1000;
370	}
371
372	static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev,
373	int min_uV, int max_uV)
374	{
375	struct tps_pmic *tps = rdev_get_drvdata(dev);
376	int data, vsel, dcdc = rdev_get_id(dev);
377	u8 reg;
378
379	switch (dcdc) {
380	case TPS6507X_DCDC_1:
381	reg = TPS6507X_REG_DEFDCDC1;
382	break;
383	case TPS6507X_DCDC_2:
384	reg = TPS6507X_REG_DEFDCDC2_LOW;
385	break;
386	case TPS6507X_DCDC_3:
387	reg = TPS6507X_REG_DEFDCDC3_LOW;
388	break;
389	default:
390	return -EINVAL;
391	}
392
393	if (min_uV < tps->info[dcdc]->min_uV
394	\|\| min_uV > tps->info[dcdc]->max_uV)
395	return -EINVAL;
396	if (max_uV < tps->info[dcdc]->min_uV
397	\|\| max_uV > tps->info[dcdc]->max_uV)
398	return -EINVAL;
399
400	for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
401	int mV = tps->info[dcdc]->table[vsel];
402	int uV = mV * 1000;
403
404	/* Break at the first in-range value */
405	if (min_uV <= uV && uV <= max_uV)
406	break;
407	}
408
409	/* write to the register in case we found a match */
410	if (vsel == tps->info[dcdc]->table_len)
411	return -EINVAL;
412
413	data = tps_6507x_reg_read(tps, reg);
414	if (data < 0)
415	return data;
416
417	data &= ~TPS6507X_DEFDCDCX_DCDC_MASK;
418	data \|= vsel;
419
420	return tps_6507x_reg_write(tps, reg, data);
421	}
422
423	static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
424	{
425	struct tps_pmic *tps = rdev_get_drvdata(dev);
426	int data, ldo = rdev_get_id(dev);
427	u8 reg, mask;
428
429	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
430	return -EINVAL;
431	else {
432	reg = (ldo == TPS6507X_LDO_1 ?
433	TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
434	mask = (ldo == TPS6507X_LDO_1 ?
435	TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
436	TPS6507X_REG_DEFLDO2_LDO2_MASK);
437	}
438
439	data = tps_6507x_reg_read(tps, reg);
440	if (data < 0)
441	return data;
442
443	data &= mask;
444	return tps->info[ldo]->table[data] * 1000;
445	}
446
447	static int tps6507x_ldo_set_voltage(struct regulator_dev *dev,
448	int min_uV, int max_uV)
449	{
450	struct tps_pmic *tps = rdev_get_drvdata(dev);
451	int data, vsel, ldo = rdev_get_id(dev);
452	u8 reg, mask;
453
454	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
455	return -EINVAL;
456	else {
457	reg = (ldo == TPS6507X_LDO_1 ?
458	TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
459	mask = (ldo == TPS6507X_LDO_1 ?
460	TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
461	TPS6507X_REG_DEFLDO2_LDO2_MASK);
462	}
463
464	if (min_uV < tps->info[ldo]->min_uV \|\| min_uV > tps->info[ldo]->max_uV)
465	return -EINVAL;
466	if (max_uV < tps->info[ldo]->min_uV \|\| max_uV > tps->info[ldo]->max_uV)
467	return -EINVAL;
468
469	for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
470	int mV = tps->info[ldo]->table[vsel];
471	int uV = mV * 1000;
472
473	/* Break at the first in-range value */
474	if (min_uV <= uV && uV <= max_uV)
475	break;
476	}
477
478	if (vsel == tps->info[ldo]->table_len)
479	return -EINVAL;
480
481	data = tps_6507x_reg_read(tps, reg);
482	if (data < 0)
483	return data;
484
485	data &= ~mask;
486	data \|= vsel;
487
488	return tps_6507x_reg_write(tps, reg, data);
489	}
490
491	static int tps6507x_dcdc_list_voltage(struct regulator_dev *dev,
492	unsigned selector)
493	{
494	struct tps_pmic *tps = rdev_get_drvdata(dev);
495	int dcdc = rdev_get_id(dev);
496
497	if (dcdc < TPS6507X_DCDC_1 \|\| dcdc > TPS6507X_DCDC_3)
498	return -EINVAL;
499
500	if (selector >= tps->info[dcdc]->table_len)
501	return -EINVAL;
502	else
503	return tps->info[dcdc]->table[selector] * 1000;
504	}
505
506	static int tps6507x_ldo_list_voltage(struct regulator_dev *dev,
507	unsigned selector)
508	{
509	struct tps_pmic *tps = rdev_get_drvdata(dev);
510	int ldo = rdev_get_id(dev);
511
512	if (ldo < TPS6507X_LDO_1 \|\| ldo > TPS6507X_LDO_2)
513	return -EINVAL;
514
515	if (selector >= tps->info[ldo]->table_len)
516	return -EINVAL;
517	else
518	return tps->info[ldo]->table[selector] * 1000;
519	}
520
521	/* Operations permitted on VDCDCx */
522	static struct regulator_ops tps6507x_dcdc_ops = {
523	.is_enabled = tps6507x_dcdc_is_enabled,
524	.enable = tps6507x_dcdc_enable,
525	.disable = tps6507x_dcdc_disable,
526	.get_voltage = tps6507x_dcdc_get_voltage,
527	.set_voltage = tps6507x_dcdc_set_voltage,
528	.list_voltage = tps6507x_dcdc_list_voltage,
529	};
530
531	/* Operations permitted on LDOx */
532	static struct regulator_ops tps6507x_ldo_ops = {
533	.is_enabled = tps6507x_ldo_is_enabled,
534	.enable = tps6507x_ldo_enable,
535	.disable = tps6507x_ldo_disable,
536	.get_voltage = tps6507x_ldo_get_voltage,
537	.set_voltage = tps6507x_ldo_set_voltage,
538	.list_voltage = tps6507x_ldo_list_voltage,
539	};
540
541	static
542	int tps_6507x_probe(struct i2c_client client, const struct i2c_device_id id)
543	{
544	static int desc_id;
545	const struct tps_info info = (void )id->driver_data;
546	struct regulator_init_data *init_data;
547	struct regulator_dev *rdev;
548	struct tps_pmic *tps;
549	int i;
550
551	if (!i2c_check_functionality(client->adapter,
552	I2C_FUNC_SMBUS_BYTE_DATA))
553	return -EIO;
554
555	/**
556	* init_data points to array of regulator_init structures
557	* coming from the board-evm file.
558	*/
559	init_data = client->dev.platform_data;
560
561	if (!init_data)
562	return -EIO;
563
564	tps = kzalloc(sizeof(*tps), GFP_KERNEL);
565	if (!tps)
566	return -ENOMEM;
567
568	mutex_init(&tps->io_lock);
569
570	/* common for all regulators */
571	tps->client = client;
572
573	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
574	/* Register the regulators */
575	tps->info[i] = info;
576	tps->desc[i].name = info->name;
577	tps->desc[i].id = desc_id++;
578	tps->desc[i].n_voltages = num_voltages[i];
579	tps->desc[i].ops = (i > TPS6507X_DCDC_3 ?
580	&tps6507x_ldo_ops : &tps6507x_dcdc_ops);
581	tps->desc[i].type = REGULATOR_VOLTAGE;
582	tps->desc[i].owner = THIS_MODULE;
583
584	rdev = regulator_register(&tps->desc[i],
585	&client->dev, init_data, tps);
586	if (IS_ERR(rdev)) {
587	dev_err(&client->dev, "failed to register %s\n",
588	id->name);
589
590	/* Unregister */
591	while (i)
592	regulator_unregister(tps->rdev[--i]);
593
594	tps->client = NULL;
595
596	/* clear the client data in i2c */
597	i2c_set_clientdata(client, NULL);
598
599	kfree(tps);
600	return PTR_ERR(rdev);
601	}
602
603	/* Save regulator for cleanup */
604	tps->rdev[i] = rdev;
605	}
606
607	i2c_set_clientdata(client, tps);
608
609	return 0;
610	}
611
612	/**
613	* tps_6507x_remove - TPS6507x driver i2c remove handler
614	* @client: i2c driver client device structure
615	*
616	* Unregister TPS driver as an i2c client device driver
617	*/
618	static int __devexit tps_6507x_remove(struct i2c_client *client)
619	{
620	struct tps_pmic *tps = i2c_get_clientdata(client);
621	int i;
622
623	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
624	regulator_unregister(tps->rdev[i]);
625
626	tps->client = NULL;
627
628	/* clear the client data in i2c */
629	i2c_set_clientdata(client, NULL);
630	kfree(tps);
631
632	return 0;
633	}
634
635	static const struct tps_info tps6507x_regs[] = {
636	{
637	.name = "VDCDC1",
638	.min_uV = 725000,
639	.max_uV = 3300000,
640	.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
641	.table = VDCDCx_VSEL_table,
642	},
643	{
644	.name = "VDCDC2",
645	.min_uV = 725000,
646	.max_uV = 3300000,
647	.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
648	.table = VDCDCx_VSEL_table,
649	},
650	{
651	.name = "VDCDC3",
652	.min_uV = 725000,
653	.max_uV = 3300000,
654	.table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
655	.table = VDCDCx_VSEL_table,
656	},
657	{
658	.name = "LDO1",
659	.min_uV = 1000000,
660	.max_uV = 3300000,
661	.table_len = ARRAY_SIZE(LDO1_VSEL_table),
662	.table = LDO1_VSEL_table,
663	},
664	{
665	.name = "LDO2",
666	.min_uV = 725000,
667	.max_uV = 3300000,
668	.table_len = ARRAY_SIZE(LDO2_VSEL_table),
669	.table = LDO2_VSEL_table,
670	},
671	};
672
9e108d33 LG	673	static const struct i2c_device_id tps_6507x_id[] = {
	674	{.name = "tps6507x",
	675	.driver_data = (unsigned long) tps6507x_regs,},
	676	{ },
3fa5b8e0 AA	677	};
	678	MODULE_DEVICE_TABLE(i2c, tps_6507x_id);
	679
	680	static struct i2c_driver tps_6507x_i2c_driver = {
	681	.driver = {
	682	.name = "tps6507x",
	683	.owner = THIS_MODULE,
	684	},
	685	.probe = tps_6507x_probe,
	686	.remove = __devexit_p(tps_6507x_remove),
9e108d33	687	.id_table = tps_6507x_id,
3fa5b8e0 AA	688	};
	689
	690	/**
	691	* tps_6507x_init
	692	*
	693	* Module init function
	694	*/
	695	static int __init tps_6507x_init(void)
	696	{
	697	return i2c_add_driver(&tps_6507x_i2c_driver);
	698	}
	699	subsys_initcall(tps_6507x_init);
	700
	701	/**
	702	* tps_6507x_cleanup
	703	*
	704	* Module exit function
	705	*/
	706	static void __exit tps_6507x_cleanup(void)
	707	{
	708	i2c_del_driver(&tps_6507x_i2c_driver);
	709	}
	710	module_exit(tps_6507x_cleanup);
	711
	712	MODULE_AUTHOR("Texas Instruments");
	713	MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
9e108d33	714	MODULE_LICENSE("GPL v2");