[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>
#include <linux/slab.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 __devinit 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;
	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;

	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);
			error = PTR_ERR(rdev);
			goto fail;
		}

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

	i2c_set_clientdata(client, tps);

	return 0;

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

	kfree(tps);
	return error;
}

/**
 * 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;

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

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

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