[mirror_ubuntu-bionic-kernel.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/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;
	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(struct regulator_dev *dev,
				  int min_uV, int max_uV,
				  unsigned int *selector)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int ldo = rdev_get_id(dev) - LP3971_LDO1;
	int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
	const int *vol_map = LDO_VOL_VALUE_MAP(ldo);
	u16 val;

	if (min_vol < vol_map[LDO_VOL_MIN_IDX] ||
	    min_vol > vol_map[LDO_VOL_MAX_IDX])
		return -EINVAL;

	for (val = LDO_VOL_MIN_IDX; val <= LDO_VOL_MAX_IDX; val++)
		if (vol_map[val] >= min_vol)
			break;

	if (val > LDO_VOL_MAX_IDX || vol_map[val] > max_vol)
		return -EINVAL;

	*selector = val;

	return lp3971_set_bits(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo),
			LDO_VOL_CONTR_MASK << LDO_VOL_CONTR_SHIFT(ldo),
			val << 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 = lp3971_ldo_set_voltage,
};

static int lp3971_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
{
	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(struct regulator_dev *dev,
				   int min_uV, int max_uV,
				   unsigned int *selector)
{
	struct lp3971 *lp3971 = rdev_get_drvdata(dev);
	int buck = rdev_get_id(dev) - LP3971_DCDC1;
	int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
	const int *vol_map = buck_voltage_map;
	u16 val;
	int ret;

	if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
	    min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
		return -EINVAL;

	for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
	     val++)
		if (vol_map[val] >= min_vol)
			break;

	if (val > BUCK_TARGET_VOL_MAX_IDX || vol_map[val] > max_vol)
		return -EINVAL;

	*selector = val;

	ret = lp3971_set_bits(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck),
	       BUCK_TARGET_VOL_MASK, val);
	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 = lp3971_dcdc_set_voltage,
};

static 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 lp3971_regulator_subdev *reg = &pdata->regulators[i];
		lp3971->rdev[i] = regulator_register(&regulators[reg->id],
					lp3971->dev, reg->initdata, lp3971);

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

static int __init lp3971_module_init(void)
{
	int ret;

	ret = i2c_add_driver(&lp3971_i2c_driver);
	if (ret != 0)
		pr_err("Failed to register I2C driver: %d\n", ret);

	return ret;
}
module_init(lp3971_module_init);

static void __exit lp3971_module_exit(void)
{
	i2c_del_driver(&lp3971_i2c_driver);
}
module_exit(lp3971_module_exit);

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