[deliverable/linux.git] / drivers / regulator / lp3971.c

/*
 * Regulator driver for National Semiconductors LP3971 PMIC chip
 *
 *  Copyright (C) 2009 Samsung Electronics
 *  Author: Marek Szyprowski <m.szyprowski@samsung.com>
 *
 * Based on wm8350.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/bug.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/lp3971.h>
#include <linux/slab.h>

struct lp3971 {
	struct device *dev;
	struct mutex io_lock;
	struct i2c_client *i2c;
	int num_regulators;
	struct regulator_dev **rdev;
};

static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg);
static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val);

#define LP3971_SYS_CONTROL1_REG 0x07

/* System control register 1 initial value,
   bits 4 and 5 are EPROM programmable */
#define SYS_CONTROL1_INIT_VAL 0x40
#define SYS_CONTROL1_INIT_MASK 0xCF

#define LP3971_BUCK_VOL_ENABLE_REG 0x10
#define LP3971_BUCK_VOL_CHANGE_REG 0x20

/*	Voltage control registers shift:
	LP3971_BUCK1 -> 0
	LP3971_BUCK2 -> 4
	LP3971_BUCK3 -> 6
*/
#define BUCK_VOL_CHANGE_SHIFT(x) (((!!x) << 2) | (x & ~0x01))
#define BUCK_VOL_CHANGE_FLAG_GO 0x01
#define BUCK_VOL_CHANGE_FLAG_TARGET 0x02
#define BUCK_VOL_CHANGE_FLAG_MASK 0x03

#define LP3971_BUCK1_BASE 0x23
#define LP3971_BUCK2_BASE 0x29
#define LP3971_BUCK3_BASE 0x32

static const int buck_base_addr[] = {
	LP3971_BUCK1_BASE,
	LP3971_BUCK2_BASE,
	LP3971_BUCK3_BASE,
};

#define LP3971_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
#define LP3971_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)

static const int buck_voltage_map[] = {
	   0,  800,  850,  900,  950, 1000, 1050, 1100,
	1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
	1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
	3000, 3300,
};

#define BUCK_TARGET_VOL_MASK 0x3f
#define BUCK_TARGET_VOL_MIN_IDX 0x01
#define BUCK_TARGET_VOL_MAX_IDX 0x19

#define LP3971_BUCK_RAMP_REG(x)	(buck_base_addr[x]+2)

#define LP3971_LDO_ENABLE_REG 0x12
#define LP3971_LDO_VOL_CONTR_BASE 0x39

/*	Voltage control registers:
	LP3971_LDO1 -> LP3971_LDO_VOL_CONTR_BASE + 0
	LP3971_LDO2 -> LP3971_LDO_VOL_CONTR_BASE + 0
	LP3971_LDO3 -> LP3971_LDO_VOL_CONTR_BASE + 1
	LP3971_LDO4 -> LP3971_LDO_VOL_CONTR_BASE + 1
	LP3971_LDO5 -> LP3971_LDO_VOL_CONTR_BASE + 2
*/
#define LP3971_LDO_VOL_CONTR_REG(x)	(LP3971_LDO_VOL_CONTR_BASE + (x >> 1))

/*	Voltage control registers shift:
	LP3971_LDO1 -> 0, LP3971_LDO2 -> 4
	LP3971_LDO3 -> 0, LP3971_LDO4 -> 4
	LP3971_LDO5 -> 0
*/
#define LDO_VOL_CONTR_SHIFT(x) ((x & 1) << 2)
#define LDO_VOL_CONTR_MASK 0x0f

static const int ldo45_voltage_map[] = {
	1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
	1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
};

static const int ldo123_voltage_map[] = {
	1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
	2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
};

static const int *ldo_voltage_map[] = {
	ldo123_voltage_map, /* LDO1 */
	ldo123_voltage_map, /* LDO2 */
	ldo123_voltage_map, /* LDO3 */
	ldo45_voltage_map, /* LDO4 */
	ldo45_voltage_map, /* LDO5 */
};

#define LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[(x - LP3971_LDO1)])

#define LDO_VOL_MIN_IDX 0x00
#define LDO_VOL_MAX_IDX 0x0f

static int lp3971_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
{
	int ldo = rdev_get_id(dev) - LP3971_LDO1;

	if (index > LDO_VOL_MAX_IDX)
		return -EINVAL;

	return 1000 * LDO_VOL_VALUE_MAP(ldo)[index];
}

static int lp3971_ldo_is_enabled(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	u16 mask = 1 << (1 + ldo);
	u16 val;

	val = lp3971_reg_read(lp3971, LP3971_LDO_ENABLE_REG);
	return (val & mask) != 0;
}

static int lp3971_ldo_enable(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	u16 mask = 1 << (1 + ldo);

	return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, mask);
}

static int lp3971_ldo_disable(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	u16 mask = 1 << (1 + ldo);

	return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, 0);
}

static int lp3971_ldo_get_voltage(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	u16 val, reg;

	reg = lp3971_reg_read(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo));
	val = (reg >> LDO_VOL_CONTR_SHIFT(ldo)) & LDO_VOL_CONTR_MASK;

	return 1000 * LDO_VOL_VALUE_MAP(ldo)[val];
}

static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
				      unsigned int selector)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;

	return lp3971_set_bits(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo),
			LDO_VOL_CONTR_MASK << LDO_VOL_CONTR_SHIFT(ldo),
			selector << LDO_VOL_CONTR_SHIFT(ldo));
}

static struct regulator_ops lp3971_ldo_ops = {
	.list_voltage = lp3971_ldo_list_voltage,
	.is_enabled = lp3971_ldo_is_enabled,
	.enable = lp3971_ldo_enable,
	.disable = lp3971_ldo_disable,
	.get_voltage = lp3971_ldo_get_voltage,
	.set_voltage_sel = lp3971_ldo_set_voltage_sel,
};

static int lp3971_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
{
	if (index < BUCK_TARGET_VOL_MIN_IDX || index > BUCK_TARGET_VOL_MAX_IDX)
		return -EINVAL;

	return 1000 * buck_voltage_map[index];
}

static int lp3971_dcdc_is_enabled(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	u16 mask = 1 << (buck * 2);
	u16 val;

	val = lp3971_reg_read(lp3971, LP3971_BUCK_VOL_ENABLE_REG);
	return (val & mask) != 0;
}

static int lp3971_dcdc_enable(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	u16 mask = 1 << (buck * 2);

	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, mask);
}

static int lp3971_dcdc_disable(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	u16 mask = 1 << (buck * 2);

	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, 0);
}

static int lp3971_dcdc_get_voltage(struct regulator_dev *dev)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	u16 reg;
	int val;

	reg = lp3971_reg_read(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck));
	reg &= BUCK_TARGET_VOL_MASK;

	if (reg <= BUCK_TARGET_VOL_MAX_IDX)
		val = 1000 * buck_voltage_map[reg];
	else {
		val = 0;
		dev_warn(&dev->dev, "chip reported incorrect voltage value.\n");
	}

	return val;
}

static int lp3971_dcdc_set_voltage_sel(struct regulator_dev *dev,
				       unsigned int selector)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	int ret;

	ret = lp3971_set_bits(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck),
	       BUCK_TARGET_VOL_MASK, selector);
	if (ret)
		return ret;

	ret = lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
	       BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
	       BUCK_VOL_CHANGE_FLAG_GO << BUCK_VOL_CHANGE_SHIFT(buck));
	if (ret)
		return ret;

	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
	       BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
	       0 << BUCK_VOL_CHANGE_SHIFT(buck));
}

static struct regulator_ops lp3971_dcdc_ops = {
	.list_voltage = lp3971_dcdc_list_voltage,
	.is_enabled = lp3971_dcdc_is_enabled,
	.enable = lp3971_dcdc_enable,
	.disable = lp3971_dcdc_disable,
	.get_voltage = lp3971_dcdc_get_voltage,
	.set_voltage_sel = lp3971_dcdc_set_voltage_sel,
};

static const struct regulator_desc regulators[] = {
	{
		.name = "LDO1",
		.id = LP3971_LDO1,
		.ops = &lp3971_ldo_ops,
		.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "LDO2",
		.id = LP3971_LDO2,
		.ops = &lp3971_ldo_ops,
		.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "LDO3",
		.id = LP3971_LDO3,
		.ops = &lp3971_ldo_ops,
		.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "LDO4",
		.id = LP3971_LDO4,
		.ops = &lp3971_ldo_ops,
		.n_voltages = ARRAY_SIZE(ldo45_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "LDO5",
		.id = LP3971_LDO5,
		.ops = &lp3971_ldo_ops,
		.n_voltages = ARRAY_SIZE(ldo45_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "DCDC1",
		.id = LP3971_DCDC1,
		.ops = &lp3971_dcdc_ops,
		.n_voltages = ARRAY_SIZE(buck_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "DCDC2",
		.id = LP3971_DCDC2,
		.ops = &lp3971_dcdc_ops,
		.n_voltages = ARRAY_SIZE(buck_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "DCDC3",
		.id = LP3971_DCDC3,
		.ops = &lp3971_dcdc_ops,
		.n_voltages = ARRAY_SIZE(buck_voltage_map),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
};

static int lp3971_i2c_read(struct i2c_client *i2c, char reg, int count,
	u16 *dest)
{
	int ret;

	if (count != 1)
		return -EIO;
	ret = i2c_smbus_read_byte_data(i2c, reg);
	if (ret < 0)
		return -EIO;

	*dest = ret;
	return 0;
}

static int lp3971_i2c_write(struct i2c_client *i2c, char reg, int count,
	const u16 *src)
{
	if (count != 1)
		return -EIO;
	return i2c_smbus_write_byte_data(i2c, reg, *src);
}

static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg)
{
	u16 val = 0;

	mutex_lock(&lp3971->io_lock);

	lp3971_i2c_read(lp3971->i2c, reg, 1, &val);

	dev_dbg(lp3971->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
		(unsigned)val&0xff);

	mutex_unlock(&lp3971->io_lock);

	return val & 0xff;
}

static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val)
{
	u16 tmp;
	int ret;

	mutex_lock(&lp3971->io_lock);

	ret = lp3971_i2c_read(lp3971->i2c, reg, 1, &tmp);
	tmp = (tmp & ~mask) | val;
	if (ret == 0) {
		ret = lp3971_i2c_write(lp3971->i2c, reg, 1, &tmp);
		dev_dbg(lp3971->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
			(unsigned)val&0xff);
	}
	mutex_unlock(&lp3971->io_lock);

	return ret;
}

static int __devinit setup_regulators(struct lp3971 *lp3971,
				      struct lp3971_platform_data *pdata)
{
	int i, err;

	lp3971->num_regulators = pdata->num_regulators;
	lp3971->rdev = kcalloc(pdata->num_regulators,
				sizeof(struct regulator_dev *), GFP_KERNEL);
	if (!lp3971->rdev) {
		err = -ENOMEM;
		goto err_nomem;
	}

	/* Instantiate the regulators */
	for (i = 0; i < pdata->num_regulators; i++) {
		struct regulator_config config = { };
		struct lp3971_regulator_subdev *reg = &pdata->regulators[i];

		config.dev = lp3971->dev;
		config.init_data = reg->initdata;
		config.driver_data = lp3971;

		lp3971->rdev[i] = regulator_register(&regulators[reg->id],
						     &config);
		if (IS_ERR(lp3971->rdev[i])) {
			err = PTR_ERR(lp3971->rdev[i]);
			dev_err(lp3971->dev, "regulator init failed: %d\n",
				err);
			goto error;
		}
	}

	return 0;

error:
	while (--i >= 0)
		regulator_unregister(lp3971->rdev[i]);
	kfree(lp3971->rdev);
	lp3971->rdev = NULL;
err_nomem:
	return err;
}

static int __devinit lp3971_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct lp3971 *lp3971;
	struct lp3971_platform_data *pdata = i2c->dev.platform_data;
	int ret;
	u16 val;

	if (!pdata) {
		dev_dbg(&i2c->dev, "No platform init data supplied\n");
		return -ENODEV;
	}

	lp3971 = kzalloc(sizeof(struct lp3971), GFP_KERNEL);
	if (lp3971 == NULL)
		return -ENOMEM;

	lp3971->i2c = i2c;
	lp3971->dev = &i2c->dev;

	mutex_init(&lp3971->io_lock);

	/* Detect LP3971 */
	ret = lp3971_i2c_read(i2c, LP3971_SYS_CONTROL1_REG, 1, &val);
	if (ret == 0 && (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL)
		ret = -ENODEV;
	if (ret < 0) {
		dev_err(&i2c->dev, "failed to detect device\n");
		goto err_detect;
	}

	ret = setup_regulators(lp3971, pdata);
	if (ret < 0)
		goto err_detect;

	i2c_set_clientdata(i2c, lp3971);
	return 0;

err_detect:
	kfree(lp3971);
	return ret;
}

static int __devexit lp3971_i2c_remove(struct i2c_client *i2c)
{
	struct lp3971 *lp3971 = i2c_get_clientdata(i2c);
	int i;

	for (i = 0; i < lp3971->num_regulators; i++)
		regulator_unregister(lp3971->rdev[i]);

	kfree(lp3971->rdev);
	kfree(lp3971);

	return 0;
}

static const struct i2c_device_id lp3971_i2c_id[] = {
       { "lp3971", 0 },
       { }
};
MODULE_DEVICE_TABLE(i2c, lp3971_i2c_id);

static struct i2c_driver lp3971_i2c_driver = {
	.driver = {
		.name = "LP3971",
		.owner = THIS_MODULE,
	},
	.probe    = lp3971_i2c_probe,
	.remove   = __devexit_p(lp3971_i2c_remove),
	.id_table = lp3971_i2c_id,
};

module_i2c_driver(lp3971_i2c_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Marek Szyprowski <m.szyprowski@samsung.com>");
MODULE_DESCRIPTION("LP3971 PMIC driver");
Commit	Line	Data
0cbdf7bc MS	1	/*
	2	* Regulator driver for National Semiconductors LP3971 PMIC chip
	3	*
	4	* Copyright (C) 2009 Samsung Electronics
	5	* Author: Marek Szyprowski <m.szyprowski@samsung.com>
	6	*
	7	* Based on wm8350.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	*/
	14
	15	#include <linux/bug.h>
	16	#include <linux/err.h>
	17	#include <linux/i2c.h>
	18	#include <linux/kernel.h>
65602c32	19	#include <linux/module.h>
0cbdf7bc MS	20	#include <linux/regulator/driver.h>
0cbdf7bc MS	21	#include <linux/regulator/lp3971.h>
5a0e3ad6	22	#include <linux/slab.h>
0cbdf7bc MS	23
	24	struct lp3971 {
	25	struct device *dev;
	26	struct mutex io_lock;
	27	struct i2c_client *i2c;
	28	int num_regulators;
	29	struct regulator_dev **rdev;
	30	};
	31
	32	static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg);
	33	static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val);
	34
	35	#define LP3971_SYS_CONTROL1_REG 0x07
	36
	37	/* System control register 1 initial value,
	38	bits 4 and 5 are EPROM programmable */
	39	#define SYS_CONTROL1_INIT_VAL 0x40
	40	#define SYS_CONTROL1_INIT_MASK 0xCF
	41
	42	#define LP3971_BUCK_VOL_ENABLE_REG 0x10
	43	#define LP3971_BUCK_VOL_CHANGE_REG 0x20
	44
	45	/* Voltage control registers shift:
	46	LP3971_BUCK1 -> 0
	47	LP3971_BUCK2 -> 4
	48	LP3971_BUCK3 -> 6
	49	*/
451a73cd	50	#define BUCK_VOL_CHANGE_SHIFT(x) (((!!x) << 2) \| (x & ~0x01))
0cbdf7bc MS	51	#define BUCK_VOL_CHANGE_FLAG_GO 0x01
	52	#define BUCK_VOL_CHANGE_FLAG_TARGET 0x02
	53	#define BUCK_VOL_CHANGE_FLAG_MASK 0x03
	54
	55	#define LP3971_BUCK1_BASE 0x23
	56	#define LP3971_BUCK2_BASE 0x29
	57	#define LP3971_BUCK3_BASE 0x32
	58
6faa7e0a	59	static const int buck_base_addr[] = {
0cbdf7bc MS	60	LP3971_BUCK1_BASE,
	61	LP3971_BUCK2_BASE,
	62	LP3971_BUCK3_BASE,
	63	};
	64
	65	#define LP3971_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
	66	#define LP3971_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
	67
6faa7e0a	68	static const int buck_voltage_map[] = {
0cbdf7bc MS	69	0, 800, 850, 900, 950, 1000, 1050, 1100,
	70	1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
	71	1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
	72	3000, 3300,
	73	};
	74
	75	#define BUCK_TARGET_VOL_MASK 0x3f
	76	#define BUCK_TARGET_VOL_MIN_IDX 0x01
	77	#define BUCK_TARGET_VOL_MAX_IDX 0x19
	78
	79	#define LP3971_BUCK_RAMP_REG(x) (buck_base_addr[x]+2)
	80
	81	#define LP3971_LDO_ENABLE_REG 0x12
	82	#define LP3971_LDO_VOL_CONTR_BASE 0x39
	83
	84	/* Voltage control registers:
	85	LP3971_LDO1 -> LP3971_LDO_VOL_CONTR_BASE + 0
	86	LP3971_LDO2 -> LP3971_LDO_VOL_CONTR_BASE + 0
	87	LP3971_LDO3 -> LP3971_LDO_VOL_CONTR_BASE + 1
	88	LP3971_LDO4 -> LP3971_LDO_VOL_CONTR_BASE + 1
	89	LP3971_LDO5 -> LP3971_LDO_VOL_CONTR_BASE + 2
	90	*/
	91	#define LP3971_LDO_VOL_CONTR_REG(x) (LP3971_LDO_VOL_CONTR_BASE + (x >> 1))
	92
	93	/* Voltage control registers shift:
	94	LP3971_LDO1 -> 0, LP3971_LDO2 -> 4
	95	LP3971_LDO3 -> 0, LP3971_LDO4 -> 4
	96	LP3971_LDO5 -> 0
	97	*/
	98	#define LDO_VOL_CONTR_SHIFT(x) ((x & 1) << 2)
	99	#define LDO_VOL_CONTR_MASK 0x0f
	100
6faa7e0a	101	static const int ldo45_voltage_map[] = {
0cbdf7bc MS	102	1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
	103	1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
	104	};
	105
6faa7e0a	106	static const int ldo123_voltage_map[] = {
0cbdf7bc MS	107	1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
	108	2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
	109	};
	110
6faa7e0a	111	static const int *ldo_voltage_map[] = {
0cbdf7bc MS	112	ldo123_voltage_map, /* LDO1 */
	113	ldo123_voltage_map, /* LDO2 */
	114	ldo123_voltage_map, /* LDO3 */
	115	ldo45_voltage_map, /* LDO4 */
	116	ldo45_voltage_map, /* LDO5 */
	117	};
	118
	119	#define LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[(x - LP3971_LDO1)])
	120
	121	#define LDO_VOL_MIN_IDX 0x00
	122	#define LDO_VOL_MAX_IDX 0x0f
	123
	124	static int lp3971_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
	125	{
	126	int ldo = rdev_get_id(dev) - LP3971_LDO1;
dd8e2314 AL	127
	128	if (index > LDO_VOL_MAX_IDX)
	129	return -EINVAL;
	130
0cbdf7bc MS	131	return 1000 * LDO_VOL_VALUE_MAP(ldo)[index];
	132	}
	133
	134	static int lp3971_ldo_is_enabled(struct regulator_dev *dev)
	135	{
	136	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	137	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	138	u16 mask = 1 << (1 + ldo);
	139	u16 val;
	140
	141	val = lp3971_reg_read(lp3971, LP3971_LDO_ENABLE_REG);
	142	return (val & mask) != 0;
	143	}
	144
	145	static int lp3971_ldo_enable(struct regulator_dev *dev)
	146	{
	147	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	148	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	149	u16 mask = 1 << (1 + ldo);
	150
	151	return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, mask);
	152	}
	153
	154	static int lp3971_ldo_disable(struct regulator_dev *dev)
	155	{
	156	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	157	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	158	u16 mask = 1 << (1 + ldo);
	159
	160	return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, 0);
	161	}
	162
	163	static int lp3971_ldo_get_voltage(struct regulator_dev *dev)
	164	{
	165	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	166	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	167	u16 val, reg;
	168
	169	reg = lp3971_reg_read(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo));
	170	val = (reg >> LDO_VOL_CONTR_SHIFT(ldo)) & LDO_VOL_CONTR_MASK;
	171
	172	return 1000 * LDO_VOL_VALUE_MAP(ldo)[val];
	173	}
	174
dd8e2314 AL	175	static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
dd8e2314 AL	176	unsigned int selector)
0cbdf7bc MS	177	{
	178	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	179	int ldo = rdev_get_id(dev) - LP3971_LDO1;
3a93f2a9	180
0cbdf7bc	181	return lp3971_set_bits(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo),
cdb868f5	182	LDO_VOL_CONTR_MASK << LDO_VOL_CONTR_SHIFT(ldo),
dd8e2314	183	selector << LDO_VOL_CONTR_SHIFT(ldo));
0cbdf7bc MS	184	}
	185
	186	static struct regulator_ops lp3971_ldo_ops = {
	187	.list_voltage = lp3971_ldo_list_voltage,
	188	.is_enabled = lp3971_ldo_is_enabled,
	189	.enable = lp3971_ldo_enable,
	190	.disable = lp3971_ldo_disable,
	191	.get_voltage = lp3971_ldo_get_voltage,
dd8e2314	192	.set_voltage_sel = lp3971_ldo_set_voltage_sel,
0cbdf7bc MS	193	};
	194
	195	static int lp3971_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
	196	{
dd8e2314 AL	197	if (index < BUCK_TARGET_VOL_MIN_IDX \|\| index > BUCK_TARGET_VOL_MAX_IDX)
	198	return -EINVAL;
	199
0cbdf7bc MS	200	return 1000 * buck_voltage_map[index];
	201	}
	202
	203	static int lp3971_dcdc_is_enabled(struct regulator_dev *dev)
	204	{
	205	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	206	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	207	u16 mask = 1 << (buck * 2);
	208	u16 val;
	209
	210	val = lp3971_reg_read(lp3971, LP3971_BUCK_VOL_ENABLE_REG);
	211	return (val & mask) != 0;
	212	}
	213
	214	static int lp3971_dcdc_enable(struct regulator_dev *dev)
	215	{
	216	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	217	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	218	u16 mask = 1 << (buck * 2);
	219
	220	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, mask);
	221	}
	222
	223	static int lp3971_dcdc_disable(struct regulator_dev *dev)
	224	{
	225	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	226	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	227	u16 mask = 1 << (buck * 2);
	228
	229	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, 0);
	230	}
	231
	232	static int lp3971_dcdc_get_voltage(struct regulator_dev *dev)
	233	{
	234	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	235	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	236	u16 reg;
	237	int val;
	238
	239	reg = lp3971_reg_read(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck));
	240	reg &= BUCK_TARGET_VOL_MASK;
	241
	242	if (reg <= BUCK_TARGET_VOL_MAX_IDX)
	243	val = 1000 * buck_voltage_map[reg];
	244	else {
	245	val = 0;
	246	dev_warn(&dev->dev, "chip reported incorrect voltage value.\n");
	247	}
	248
	249	return val;
	250	}
	251
dd8e2314 AL	252	static int lp3971_dcdc_set_voltage_sel(struct regulator_dev *dev,
dd8e2314 AL	253	unsigned int selector)
0cbdf7bc MS	254	{
	255	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	256	int buck = rdev_get_id(dev) - LP3971_DCDC1;
0cbdf7bc MS	257	int ret;
0cbdf7bc MS	258
0cbdf7bc	259	ret = lp3971_set_bits(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck),
dd8e2314	260	BUCK_TARGET_VOL_MASK, selector);
0cbdf7bc MS	261	if (ret)
	262	return ret;
	263
	264	ret = lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
	265	BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
	266	BUCK_VOL_CHANGE_FLAG_GO << BUCK_VOL_CHANGE_SHIFT(buck));
	267	if (ret)
	268	return ret;
	269
	270	return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
	271	BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
	272	0 << BUCK_VOL_CHANGE_SHIFT(buck));
	273	}
	274
	275	static struct regulator_ops lp3971_dcdc_ops = {
	276	.list_voltage = lp3971_dcdc_list_voltage,
	277	.is_enabled = lp3971_dcdc_is_enabled,
	278	.enable = lp3971_dcdc_enable,
	279	.disable = lp3971_dcdc_disable,
	280	.get_voltage = lp3971_dcdc_get_voltage,
dd8e2314	281	.set_voltage_sel = lp3971_dcdc_set_voltage_sel,
0cbdf7bc MS	282	};
0cbdf7bc MS	283
14add4ff	284	static const struct regulator_desc regulators[] = {
0cbdf7bc MS	285	{
	286	.name = "LDO1",
	287	.id = LP3971_LDO1,
	288	.ops = &lp3971_ldo_ops,
	289	.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
	290	.type = REGULATOR_VOLTAGE,
	291	.owner = THIS_MODULE,
	292	},
	293	{
	294	.name = "LDO2",
	295	.id = LP3971_LDO2,
	296	.ops = &lp3971_ldo_ops,
	297	.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
	298	.type = REGULATOR_VOLTAGE,
	299	.owner = THIS_MODULE,
	300	},
	301	{
	302	.name = "LDO3",
	303	.id = LP3971_LDO3,
	304	.ops = &lp3971_ldo_ops,
	305	.n_voltages = ARRAY_SIZE(ldo123_voltage_map),
	306	.type = REGULATOR_VOLTAGE,
	307	.owner = THIS_MODULE,
	308	},
	309	{
	310	.name = "LDO4",
	311	.id = LP3971_LDO4,
	312	.ops = &lp3971_ldo_ops,
	313	.n_voltages = ARRAY_SIZE(ldo45_voltage_map),
	314	.type = REGULATOR_VOLTAGE,
	315	.owner = THIS_MODULE,
	316	},
	317	{
	318	.name = "LDO5",
	319	.id = LP3971_LDO5,
	320	.ops = &lp3971_ldo_ops,
	321	.n_voltages = ARRAY_SIZE(ldo45_voltage_map),
	322	.type = REGULATOR_VOLTAGE,
	323	.owner = THIS_MODULE,
	324	},
	325	{
	326	.name = "DCDC1",
	327	.id = LP3971_DCDC1,
	328	.ops = &lp3971_dcdc_ops,
	329	.n_voltages = ARRAY_SIZE(buck_voltage_map),
	330	.type = REGULATOR_VOLTAGE,
	331	.owner = THIS_MODULE,
	332	},
	333	{
	334	.name = "DCDC2",
	335	.id = LP3971_DCDC2,
	336	.ops = &lp3971_dcdc_ops,
	337	.n_voltages = ARRAY_SIZE(buck_voltage_map),
	338	.type = REGULATOR_VOLTAGE,
	339	.owner = THIS_MODULE,
	340	},
	341	{
	342	.name = "DCDC3",
	343	.id = LP3971_DCDC3,
	344	.ops = &lp3971_dcdc_ops,
	345	.n_voltages = ARRAY_SIZE(buck_voltage_map),
	346	.type = REGULATOR_VOLTAGE,
	347	.owner = THIS_MODULE,
	348	},
349	};
350
351	static int lp3971_i2c_read(struct i2c_client *i2c, char reg, int count,
352	u16 *dest)
353	{
354	int ret;
355
356	if (count != 1)
357	return -EIO;
358	ret = i2c_smbus_read_byte_data(i2c, reg);
27ef7f00	359	if (ret < 0)
0cbdf7bc MS	360	return -EIO;
	361
	362	*dest = ret;
	363	return 0;
	364	}
	365
	366	static int lp3971_i2c_write(struct i2c_client *i2c, char reg, int count,
	367	const u16 *src)
	368	{
0cbdf7bc MS	369	if (count != 1)
0cbdf7bc MS	370	return -EIO;
1bddc2f5	371	return i2c_smbus_write_byte_data(i2c, reg, *src);
0cbdf7bc MS	372	}
	373
	374	static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg)
	375	{
	376	u16 val = 0;
	377
	378	mutex_lock(&lp3971->io_lock);
	379
	380	lp3971_i2c_read(lp3971->i2c, reg, 1, &val);
	381
	382	dev_dbg(lp3971->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
	383	(unsigned)val&0xff);
	384
	385	mutex_unlock(&lp3971->io_lock);
	386
	387	return val & 0xff;
	388	}
	389
	390	static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val)
	391	{
	392	u16 tmp;
	393	int ret;
	394
	395	mutex_lock(&lp3971->io_lock);
	396
	397	ret = lp3971_i2c_read(lp3971->i2c, reg, 1, &tmp);
	398	tmp = (tmp & ~mask) \| val;
	399	if (ret == 0) {
	400	ret = lp3971_i2c_write(lp3971->i2c, reg, 1, &tmp);
	401	dev_dbg(lp3971->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
	402	(unsigned)val&0xff);
	403	}
	404	mutex_unlock(&lp3971->io_lock);
	405
	406	return ret;
	407	}
	408
ebbed04f DT	409	static int __devinit setup_regulators(struct lp3971 *lp3971,
ebbed04f DT	410	struct lp3971_platform_data *pdata)
0cbdf7bc MS	411	{
0cbdf7bc MS	412	int i, err;
ebbed04f DT	413
	414	lp3971->num_regulators = pdata->num_regulators;
	415	lp3971->rdev = kcalloc(pdata->num_regulators,
	416	sizeof(struct regulator_dev *), GFP_KERNEL);
67e46f34 DC	417	if (!lp3971->rdev) {
	418	err = -ENOMEM;
	419	goto err_nomem;
	420	}
0cbdf7bc MS	421
0cbdf7bc MS	422	/* Instantiate the regulators */
ebbed04f	423	for (i = 0; i < pdata->num_regulators; i++) {
c172708d	424	struct regulator_config config = { };
ebbed04f	425	struct lp3971_regulator_subdev *reg = &pdata->regulators[i];
0cbdf7bc	426
c172708d MB	427	config.dev = lp3971->dev;
	428	config.init_data = reg->initdata;
	429	config.driver_data = lp3971;
	430
	431	lp3971->rdev[i] = regulator_register(&regulators[reg->id],
	432	&config);
d662fc82 JL	433	if (IS_ERR(lp3971->rdev[i])) {
d662fc82 JL	434	err = PTR_ERR(lp3971->rdev[i]);
0cbdf7bc MS	435	dev_err(lp3971->dev, "regulator init failed: %d\n",
	436	err);
	437	goto error;
	438	}
	439	}
	440
	441	return 0;
ebbed04f	442
0cbdf7bc	443	error:
ebbed04f DT	444	while (--i >= 0)
ebbed04f DT	445	regulator_unregister(lp3971->rdev[i]);
0cbdf7bc MS	446	kfree(lp3971->rdev);
0cbdf7bc MS	447	lp3971->rdev = NULL;
67e46f34	448	err_nomem:
0cbdf7bc MS	449	return err;
	450	}
	451
	452	static int __devinit lp3971_i2c_probe(struct i2c_client *i2c,
	453	const struct i2c_device_id *id)
	454	{
	455	struct lp3971 *lp3971;
	456	struct lp3971_platform_data *pdata = i2c->dev.platform_data;
	457	int ret;
	458	u16 val;
	459
ebbed04f DT	460	if (!pdata) {
	461	dev_dbg(&i2c->dev, "No platform init data supplied\n");
	462	return -ENODEV;
0cbdf7bc MS	463	}
0cbdf7bc MS	464
ebbed04f DT	465	lp3971 = kzalloc(sizeof(struct lp3971), GFP_KERNEL);
	466	if (lp3971 == NULL)
	467	return -ENOMEM;
	468
0cbdf7bc MS	469	lp3971->i2c = i2c;
0cbdf7bc MS	470	lp3971->dev = &i2c->dev;
0cbdf7bc MS	471
	472	mutex_init(&lp3971->io_lock);
	473
	474	/* Detect LP3971 */
	475	ret = lp3971_i2c_read(i2c, LP3971_SYS_CONTROL1_REG, 1, &val);
	476	if (ret == 0 && (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL)
	477	ret = -ENODEV;
	478	if (ret < 0) {
	479	dev_err(&i2c->dev, "failed to detect device\n");
	480	goto err_detect;
	481	}
	482
ebbed04f DT	483	ret = setup_regulators(lp3971, pdata);
	484	if (ret < 0)
	485	goto err_detect;
0cbdf7bc	486
ebbed04f	487	i2c_set_clientdata(i2c, lp3971);
0cbdf7bc MS	488	return 0;
	489
	490	err_detect:
0cbdf7bc	491	kfree(lp3971);
0cbdf7bc MS	492	return ret;
	493	}
	494
	495	static int __devexit lp3971_i2c_remove(struct i2c_client *i2c)
	496	{
	497	struct lp3971 *lp3971 = i2c_get_clientdata(i2c);
	498	int i;
ebbed04f	499
0cbdf7bc	500	for (i = 0; i < lp3971->num_regulators; i++)
ebbed04f DT	501	regulator_unregister(lp3971->rdev[i]);
ebbed04f DT	502
0cbdf7bc	503	kfree(lp3971->rdev);
0cbdf7bc MS	504	kfree(lp3971);
	505
	506	return 0;
	507	}
	508
	509	static const struct i2c_device_id lp3971_i2c_id[] = {
	510	{ "lp3971", 0 },
	511	{ }
	512	};
	513	MODULE_DEVICE_TABLE(i2c, lp3971_i2c_id);
	514
	515	static struct i2c_driver lp3971_i2c_driver = {
	516	.driver = {
	517	.name = "LP3971",
	518	.owner = THIS_MODULE,
	519	},
	520	.probe = lp3971_i2c_probe,
6113c3a5	521	.remove = __devexit_p(lp3971_i2c_remove),
0cbdf7bc MS	522	.id_table = lp3971_i2c_id,
	523	};
	524
5af34e60	525	module_i2c_driver(lp3971_i2c_driver);
0cbdf7bc MS	526
	527	MODULE_LICENSE("GPL");
	528	MODULE_AUTHOR("Marek Szyprowski <m.szyprowski@samsung.com>");
	529	MODULE_DESCRIPTION("LP3971 PMIC driver");