[linux-2.6-block.git] / drivers / regulator / lp8788-buck.c

/*
 * TI LP8788 MFD - buck regulator driver
 *
 * Copyright 2012 Texas Instruments
 *
 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
 *
 * 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/module.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/mfd/lp8788.h>
#include <linux/gpio.h>

/* register address */
#define LP8788_EN_BUCK			0x0C
#define LP8788_BUCK_DVS_SEL		0x1D
#define LP8788_BUCK1_VOUT0		0x1E
#define LP8788_BUCK1_VOUT1		0x1F
#define LP8788_BUCK1_VOUT2		0x20
#define LP8788_BUCK1_VOUT3		0x21
#define LP8788_BUCK2_VOUT0		0x22
#define LP8788_BUCK2_VOUT1		0x23
#define LP8788_BUCK2_VOUT2		0x24
#define LP8788_BUCK2_VOUT3		0x25
#define LP8788_BUCK3_VOUT		0x26
#define LP8788_BUCK4_VOUT		0x27
#define LP8788_BUCK1_TIMESTEP		0x28
#define LP8788_BUCK_PWM			0x2D

/* mask/shift bits */
#define LP8788_EN_BUCK1_M		BIT(0)	/* Addr 0Ch */
#define LP8788_EN_BUCK2_M		BIT(1)
#define LP8788_EN_BUCK3_M		BIT(2)
#define LP8788_EN_BUCK4_M		BIT(3)
#define LP8788_BUCK1_DVS_SEL_M		0x04	/* Addr 1Dh */
#define LP8788_BUCK1_DVS_M		0x03
#define LP8788_BUCK1_DVS_S		0
#define LP8788_BUCK2_DVS_SEL_M		0x40
#define LP8788_BUCK2_DVS_M		0x30
#define LP8788_BUCK2_DVS_S		4
#define LP8788_BUCK1_DVS_I2C		BIT(2)
#define LP8788_BUCK2_DVS_I2C		BIT(6)
#define LP8788_BUCK1_DVS_PIN		(0 << 2)
#define LP8788_BUCK2_DVS_PIN		(0 << 6)
#define LP8788_VOUT_M			0x1F	/* Addr 1Eh ~ 27h */
#define LP8788_STARTUP_TIME_M		0xF8	/* Addr 28h ~ 2Bh */
#define LP8788_STARTUP_TIME_S		3
#define LP8788_FPWM_BUCK1_M		BIT(0)	/* Addr 2Dh */
#define LP8788_FPWM_BUCK1_S		0
#define LP8788_FPWM_BUCK2_M		BIT(1)
#define LP8788_FPWM_BUCK2_S		1
#define LP8788_FPWM_BUCK3_M		BIT(2)
#define LP8788_FPWM_BUCK3_S		2
#define LP8788_FPWM_BUCK4_M		BIT(3)
#define LP8788_FPWM_BUCK4_S		3

#define INVALID_ADDR			0xFF
#define LP8788_FORCE_PWM		1
#define LP8788_AUTO_PWM			0
#define PIN_LOW				0
#define PIN_HIGH			1
#define ENABLE_TIME_USEC		32

enum lp8788_dvs_state {
	DVS_LOW  = GPIOF_OUT_INIT_LOW,
	DVS_HIGH = GPIOF_OUT_INIT_HIGH,
};

enum lp8788_dvs_mode {
	REGISTER,
	EXTPIN,
};

enum lp8788_buck_id {
	BUCK1,
	BUCK2,
	BUCK3,
	BUCK4,
};

struct lp8788_pwm_map {
	u8 mask;
	u8 shift;
};

struct lp8788_buck {
	struct lp8788 *lp;
	struct regulator_dev *regulator;
	struct lp8788_pwm_map *pmap;
	void *dvs;
};

/* BUCK 1 ~ 4 voltage table */
static const int lp8788_buck_vtbl[] = {
	 500000,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
	1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
	1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
	1950000, 2000000,
};

/* buck pwm mode selection : used for set/get_mode in regulator ops
 * @forced pwm : fast mode
 * @auto pwm   : normal mode
 */
static struct lp8788_pwm_map buck_pmap[] = {
	[BUCK1] = {
		.mask = LP8788_FPWM_BUCK1_M,
		.shift = LP8788_FPWM_BUCK1_S,
	},
	[BUCK2] = {
		.mask = LP8788_FPWM_BUCK2_M,
		.shift = LP8788_FPWM_BUCK2_S,
	},
	[BUCK3] = {
		.mask = LP8788_FPWM_BUCK3_M,
		.shift = LP8788_FPWM_BUCK3_S,
	},
	[BUCK4] = {
		.mask = LP8788_FPWM_BUCK4_M,
		.shift = LP8788_FPWM_BUCK4_S,
	},
};

static const u8 buck1_vout_addr[] = {
	LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
	LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
};

static const u8 buck2_vout_addr[] = {
	LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
	LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
};

static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
{
	struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
	enum lp8788_dvs_state pinstate;

	if (!dvs)
		return;

	pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
	if (gpio_is_valid(dvs->gpio))
		gpio_set_value(dvs->gpio, pinstate);
}

static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
{
	struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
	enum lp8788_dvs_state pin1, pin2;

	if (!dvs)
		return;

	switch (dvs->vsel) {
	case DVS_SEL_V0:
		pin1 = DVS_LOW;
		pin2 = DVS_LOW;
		break;
	case DVS_SEL_V1:
		pin1 = DVS_HIGH;
		pin2 = DVS_LOW;
		break;
	case DVS_SEL_V2:
		pin1 = DVS_LOW;
		pin2 = DVS_HIGH;
		break;
	case DVS_SEL_V3:
		pin1 = DVS_HIGH;
		pin2 = DVS_HIGH;
		break;
	default:
		return;
	}

	if (gpio_is_valid(dvs->gpio[0]))
		gpio_set_value(dvs->gpio[0], pin1);

	if (gpio_is_valid(dvs->gpio[1]))
		gpio_set_value(dvs->gpio[1], pin2);
}

static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
{
	switch (id) {
	case BUCK1:
		lp8788_buck1_set_dvs(buck);
		break;
	case BUCK2:
		lp8788_buck2_set_dvs(buck);
		break;
	default:
		break;
	}
}

static enum lp8788_dvs_mode
lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
{
	u8 val, mask;

	switch (id) {
	case BUCK1:
		mask = LP8788_BUCK1_DVS_SEL_M;
		break;
	case BUCK2:
		mask = LP8788_BUCK2_DVS_SEL_M;
		break;
	default:
		return REGISTER;
	}

	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);

	return val & mask ? REGISTER : EXTPIN;
}

static bool lp8788_is_valid_buck_addr(u8 addr)
{
	switch (addr) {
	case LP8788_BUCK1_VOUT0:
	case LP8788_BUCK1_VOUT1:
	case LP8788_BUCK1_VOUT2:
	case LP8788_BUCK1_VOUT3:
	case LP8788_BUCK2_VOUT0:
	case LP8788_BUCK2_VOUT1:
	case LP8788_BUCK2_VOUT2:
	case LP8788_BUCK2_VOUT3:
		return true;
	default:
		return false;
	}
}

static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
					enum lp8788_buck_id id)
{
	enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
	struct lp8788_buck1_dvs *b1_dvs;
	struct lp8788_buck2_dvs *b2_dvs;
	u8 val, idx, addr;
	int pin1, pin2;

	switch (id) {
	case BUCK1:
		if (mode == EXTPIN) {
			b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
			if (!b1_dvs)
				goto err;

			idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
		} else {
			lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
			idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
		}
		addr = buck1_vout_addr[idx];
		break;
	case BUCK2:
		if (mode == EXTPIN) {
			b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
			if (!b2_dvs)
				goto err;

			pin1 = gpio_get_value(b2_dvs->gpio[0]);
			pin2 = gpio_get_value(b2_dvs->gpio[1]);

			if (pin1 == PIN_LOW && pin2 == PIN_LOW)
				idx = 0;
			else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
				idx = 2;
			else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
				idx = 1;
			else
				idx = 3;
		} else {
			lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
			idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
		}
		addr = buck2_vout_addr[idx];
		break;
	default:
		goto err;
	}

	return addr;
err:
	return INVALID_ADDR;
}

static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
					unsigned selector)
{
	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
	enum lp8788_buck_id id = rdev_get_id(rdev);
	u8 addr;

	if (buck->dvs)
		lp8788_set_dvs(buck, id);

	addr = lp8788_select_buck_vout_addr(buck, id);
	if (!lp8788_is_valid_buck_addr(addr))
		return -EINVAL;

	return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
}

static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
{
	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
	enum lp8788_buck_id id = rdev_get_id(rdev);
	int ret;
	u8 val, addr;

	addr = lp8788_select_buck_vout_addr(buck, id);
	if (!lp8788_is_valid_buck_addr(addr))
		return -EINVAL;

	ret = lp8788_read_byte(buck->lp, addr, &val);
	if (ret)
		return ret;

	return val & LP8788_VOUT_M;
}

static int lp8788_buck_enable_time(struct regulator_dev *rdev)
{
	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
	enum lp8788_buck_id id = rdev_get_id(rdev);
	u8 val, addr = LP8788_BUCK1_TIMESTEP + id;

	if (lp8788_read_byte(buck->lp, addr, &val))
		return -EINVAL;

	val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;

	return ENABLE_TIME_USEC * val;
}

static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
{
	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
	struct lp8788_pwm_map *pmap = buck->pmap;
	u8 val;

	if (!pmap)
		return -EINVAL;

	switch (mode) {
	case REGULATOR_MODE_FAST:
		val = LP8788_FORCE_PWM << pmap->shift;
		break;
	case REGULATOR_MODE_NORMAL:
		val = LP8788_AUTO_PWM << pmap->shift;
		break;
	default:
		return -EINVAL;
	}

	return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
}

static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
{
	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
	struct lp8788_pwm_map *pmap = buck->pmap;
	u8 val;
	int ret;

	if (!pmap)
		return -EINVAL;

	ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
	if (ret)
		return ret;

	return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
}

static struct regulator_ops lp8788_buck12_ops = {
	.list_voltage = regulator_list_voltage_table,
	.set_voltage_sel = lp8788_buck12_set_voltage_sel,
	.get_voltage_sel = lp8788_buck12_get_voltage_sel,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.enable_time = lp8788_buck_enable_time,
	.set_mode = lp8788_buck_set_mode,
	.get_mode = lp8788_buck_get_mode,
};

static struct regulator_ops lp8788_buck34_ops = {
	.list_voltage = regulator_list_voltage_table,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.enable_time = lp8788_buck_enable_time,
	.set_mode = lp8788_buck_set_mode,
	.get_mode = lp8788_buck_get_mode,
};

static struct regulator_desc lp8788_buck_desc[] = {
	{
		.name = "buck1",
		.id = BUCK1,
		.ops = &lp8788_buck12_ops,
		.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
		.volt_table = lp8788_buck_vtbl,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_reg = LP8788_EN_BUCK,
		.enable_mask = LP8788_EN_BUCK1_M,
	},
	{
		.name = "buck2",
		.id = BUCK2,
		.ops = &lp8788_buck12_ops,
		.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
		.volt_table = lp8788_buck_vtbl,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_reg = LP8788_EN_BUCK,
		.enable_mask = LP8788_EN_BUCK2_M,
	},
	{
		.name = "buck3",
		.id = BUCK3,
		.ops = &lp8788_buck34_ops,
		.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
		.volt_table = lp8788_buck_vtbl,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.vsel_reg = LP8788_BUCK3_VOUT,
		.vsel_mask = LP8788_VOUT_M,
		.enable_reg = LP8788_EN_BUCK,
		.enable_mask = LP8788_EN_BUCK3_M,
	},
	{
		.name = "buck4",
		.id = BUCK4,
		.ops = &lp8788_buck34_ops,
		.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
		.volt_table = lp8788_buck_vtbl,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.vsel_reg = LP8788_BUCK4_VOUT,
		.vsel_mask = LP8788_VOUT_M,
		.enable_reg = LP8788_EN_BUCK,
		.enable_mask = LP8788_EN_BUCK4_M,
	},
};

static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
					enum lp8788_buck_id id)
{
	u8 mask, val;

	switch (id) {
	case BUCK1:
		mask = LP8788_BUCK1_DVS_SEL_M;
		val  = LP8788_BUCK1_DVS_I2C;
		break;
	case BUCK2:
		mask = LP8788_BUCK2_DVS_SEL_M;
		val  = LP8788_BUCK2_DVS_I2C;
		break;
	default:
		return 0;
	}

	return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
}

static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name)
{
	struct device *dev = buck->lp->dev;

	if (!gpio_is_valid(gpio)) {
		dev_err(dev, "invalid gpio: %d\n", gpio);
		return -EINVAL;
	}

	return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
}

static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
				enum lp8788_buck_id id)
{
	struct lp8788_platform_data *pdata = buck->lp->pdata;
	char *b1_name = "LP8788_B1_DVS";
	char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
	int i, gpio, ret;

	switch (id) {
	case BUCK1:
		gpio = pdata->buck1_dvs->gpio;
		ret = _gpio_request(buck, gpio, b1_name);
		if (ret)
			return ret;

		buck->dvs = pdata->buck1_dvs;
		break;
	case BUCK2:
		for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
			gpio = pdata->buck2_dvs->gpio[i];
			ret = _gpio_request(buck, gpio, b2_name[i]);
			if (ret)
				return ret;
		}
		buck->dvs = pdata->buck2_dvs;
		break;
	default:
		break;
	}

	return 0;
}

static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
{
	struct lp8788_platform_data *pdata = buck->lp->pdata;
	u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
	u8 val[]  = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };

	/* no dvs for buck3, 4 */
	if (id == BUCK3 || id == BUCK4)
		return 0;

	/* no dvs platform data, then dvs will be selected by I2C registers */
	if (!pdata)
		goto set_default_dvs_mode;

	if ((id == BUCK1 && !pdata->buck1_dvs) ||
		(id == BUCK2 && !pdata->buck2_dvs))
		goto set_default_dvs_mode;

	if (lp8788_dvs_gpio_request(buck, id))
		goto set_default_dvs_mode;

	return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
				val[id]);

set_default_dvs_mode:
	return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
}

static __devinit int lp8788_buck_probe(struct platform_device *pdev)
{
	struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
	int id = pdev->id;
	struct lp8788_buck *buck;
	struct regulator_config cfg = { };
	struct regulator_dev *rdev;
	int ret;

	buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
	if (!buck)
		return -ENOMEM;

	buck->lp = lp;
	buck->pmap = &buck_pmap[id];

	ret = lp8788_init_dvs(buck, id);
	if (ret)
		return ret;

	cfg.dev = lp->dev;
	cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
	cfg.driver_data = buck;
	cfg.regmap = lp->regmap;

	rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
	if (IS_ERR(rdev)) {
		ret = PTR_ERR(rdev);
		dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
				id + 1, ret);
		return ret;
	}

	buck->regulator = rdev;
	platform_set_drvdata(pdev, buck);

	return 0;
}

static int __devexit lp8788_buck_remove(struct platform_device *pdev)
{
	struct lp8788_buck *buck = platform_get_drvdata(pdev);

	platform_set_drvdata(pdev, NULL);
	regulator_unregister(buck->regulator);

	return 0;
}

static struct platform_driver lp8788_buck_driver = {
	.probe = lp8788_buck_probe,
	.remove = __devexit_p(lp8788_buck_remove),
	.driver = {
		.name = LP8788_DEV_BUCK,
		.owner = THIS_MODULE,
	},
};

static int __init lp8788_buck_init(void)
{
	return platform_driver_register(&lp8788_buck_driver);
}
subsys_initcall(lp8788_buck_init);

static void __exit lp8788_buck_exit(void)
{
	platform_driver_unregister(&lp8788_buck_driver);
}
module_exit(lp8788_buck_exit);

MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
MODULE_AUTHOR("Milo Kim");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:lp8788-buck");
Commit	Line	Data
ade7515f KM	1	/*
	2	* TI LP8788 MFD - buck regulator driver
	3	*
	4	* Copyright 2012 Texas Instruments
	5	*
	6	* Author: Milo(Woogyom) Kim <milo.kim@ti.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/slab.h>
	16	#include <linux/err.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/regulator/driver.h>
	19	#include <linux/mfd/lp8788.h>
	20	#include <linux/gpio.h>
	21
	22	/* register address */
	23	#define LP8788_EN_BUCK 0x0C
	24	#define LP8788_BUCK_DVS_SEL 0x1D
	25	#define LP8788_BUCK1_VOUT0 0x1E
	26	#define LP8788_BUCK1_VOUT1 0x1F
	27	#define LP8788_BUCK1_VOUT2 0x20
	28	#define LP8788_BUCK1_VOUT3 0x21
	29	#define LP8788_BUCK2_VOUT0 0x22
	30	#define LP8788_BUCK2_VOUT1 0x23
	31	#define LP8788_BUCK2_VOUT2 0x24
	32	#define LP8788_BUCK2_VOUT3 0x25
	33	#define LP8788_BUCK3_VOUT 0x26
	34	#define LP8788_BUCK4_VOUT 0x27
	35	#define LP8788_BUCK1_TIMESTEP 0x28
	36	#define LP8788_BUCK_PWM 0x2D
	37
	38	/* mask/shift bits */
	39	#define LP8788_EN_BUCK1_M BIT(0) /* Addr 0Ch */
	40	#define LP8788_EN_BUCK2_M BIT(1)
	41	#define LP8788_EN_BUCK3_M BIT(2)
	42	#define LP8788_EN_BUCK4_M BIT(3)
	43	#define LP8788_BUCK1_DVS_SEL_M 0x04 /* Addr 1Dh */
	44	#define LP8788_BUCK1_DVS_M 0x03
	45	#define LP8788_BUCK1_DVS_S 0
	46	#define LP8788_BUCK2_DVS_SEL_M 0x40
	47	#define LP8788_BUCK2_DVS_M 0x30
	48	#define LP8788_BUCK2_DVS_S 4
	49	#define LP8788_BUCK1_DVS_I2C BIT(2)
	50	#define LP8788_BUCK2_DVS_I2C BIT(6)
	51	#define LP8788_BUCK1_DVS_PIN (0 << 2)
	52	#define LP8788_BUCK2_DVS_PIN (0 << 6)
	53	#define LP8788_VOUT_M 0x1F /* Addr 1Eh ~ 27h */
	54	#define LP8788_STARTUP_TIME_M 0xF8 /* Addr 28h ~ 2Bh */
	55	#define LP8788_STARTUP_TIME_S 3
	56	#define LP8788_FPWM_BUCK1_M BIT(0) /* Addr 2Dh */
	57	#define LP8788_FPWM_BUCK1_S 0
	58	#define LP8788_FPWM_BUCK2_M BIT(1)
	59	#define LP8788_FPWM_BUCK2_S 1
	60	#define LP8788_FPWM_BUCK3_M BIT(2)
	61	#define LP8788_FPWM_BUCK3_S 2
	62	#define LP8788_FPWM_BUCK4_M BIT(3)
	63	#define LP8788_FPWM_BUCK4_S 3
	64
65	#define INVALID_ADDR 0xFF
66	#define LP8788_FORCE_PWM 1
67	#define LP8788_AUTO_PWM 0
68	#define PIN_LOW 0
69	#define PIN_HIGH 1
70	#define ENABLE_TIME_USEC 32
71
72	enum lp8788_dvs_state {
73	DVS_LOW = GPIOF_OUT_INIT_LOW,
74	DVS_HIGH = GPIOF_OUT_INIT_HIGH,
75	};
76
77	enum lp8788_dvs_mode {
78	REGISTER,
79	EXTPIN,
80	};
81
82	enum lp8788_buck_id {
83	BUCK1,
84	BUCK2,
85	BUCK3,
86	BUCK4,
87	};
88
89	struct lp8788_pwm_map {
90	u8 mask;
91	u8 shift;
92	};
93
94	struct lp8788_buck {
95	struct lp8788 *lp;
96	struct regulator_dev *regulator;
97	struct lp8788_pwm_map *pmap;
98	void *dvs;
99	};
100
101	/* BUCK 1 ~ 4 voltage table */
102	static const int lp8788_buck_vtbl[] = {
103	500000, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
104	1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
105	1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
106	1950000, 2000000,
107	};
108
109	/* buck pwm mode selection : used for set/get_mode in regulator ops
110	* @forced pwm : fast mode
111	* @auto pwm : normal mode
112	*/
113	static struct lp8788_pwm_map buck_pmap[] = {
114	[BUCK1] = {
115	.mask = LP8788_FPWM_BUCK1_M,
116	.shift = LP8788_FPWM_BUCK1_S,
117	},
118	[BUCK2] = {
119	.mask = LP8788_FPWM_BUCK2_M,
120	.shift = LP8788_FPWM_BUCK2_S,
121	},
122	[BUCK3] = {
123	.mask = LP8788_FPWM_BUCK3_M,
124	.shift = LP8788_FPWM_BUCK3_S,
125	},
126	[BUCK4] = {
127	.mask = LP8788_FPWM_BUCK4_M,
128	.shift = LP8788_FPWM_BUCK4_S,
129	},
130	};
131
132	static const u8 buck1_vout_addr[] = {
133	LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
134	LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
135	};
136
137	static const u8 buck2_vout_addr[] = {
138	LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
139	LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
140	};
141
142	static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
143	{
144	struct lp8788_buck1_dvs dvs = (struct lp8788_buck1_dvs )buck->dvs;
145	enum lp8788_dvs_state pinstate;
146
147	if (!dvs)
148	return;
149
150	pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
151	if (gpio_is_valid(dvs->gpio))
152	gpio_set_value(dvs->gpio, pinstate);
153	}
154
155	static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
156	{
157	struct lp8788_buck2_dvs dvs = (struct lp8788_buck2_dvs )buck->dvs;
158	enum lp8788_dvs_state pin1, pin2;
159
160	if (!dvs)
161	return;
162
163	switch (dvs->vsel) {
164	case DVS_SEL_V0:
165	pin1 = DVS_LOW;
166	pin2 = DVS_LOW;
167	break;
168	case DVS_SEL_V1:
169	pin1 = DVS_HIGH;
170	pin2 = DVS_LOW;
171	break;
172	case DVS_SEL_V2:
173	pin1 = DVS_LOW;
174	pin2 = DVS_HIGH;
175	break;
176	case DVS_SEL_V3:
177	pin1 = DVS_HIGH;
178	pin2 = DVS_HIGH;
179	break;
180	default:
181	return;
182	}
183
184	if (gpio_is_valid(dvs->gpio[0]))
185	gpio_set_value(dvs->gpio[0], pin1);
186
187	if (gpio_is_valid(dvs->gpio[1]))
188	gpio_set_value(dvs->gpio[1], pin2);
189	}
190
191	static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
192	{
193	switch (id) {
194	case BUCK1:
195	lp8788_buck1_set_dvs(buck);
196	break;
197	case BUCK2:
198	lp8788_buck2_set_dvs(buck);
199	break;
200	default:
201	break;
202	}
203	}
204
205	static enum lp8788_dvs_mode
206	lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
207	{
208	u8 val, mask;
209
210	switch (id) {
211	case BUCK1:
212	mask = LP8788_BUCK1_DVS_SEL_M;
213	break;
214	case BUCK2:
215	mask = LP8788_BUCK2_DVS_SEL_M;
216	break;
217	default:
218	return REGISTER;
219	}
220
221	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
222
223	return val & mask ? REGISTER : EXTPIN;
224	}
225
226	static bool lp8788_is_valid_buck_addr(u8 addr)
227	{
228	switch (addr) {
229	case LP8788_BUCK1_VOUT0:
230	case LP8788_BUCK1_VOUT1:
231	case LP8788_BUCK1_VOUT2:
232	case LP8788_BUCK1_VOUT3:
233	case LP8788_BUCK2_VOUT0:
234	case LP8788_BUCK2_VOUT1:
235	case LP8788_BUCK2_VOUT2:
236	case LP8788_BUCK2_VOUT3:
237	return true;
238	default:
239	return false;
240	}
241	}
242
243	static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
244	enum lp8788_buck_id id)
245	{
246	enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
247	struct lp8788_buck1_dvs *b1_dvs;
248	struct lp8788_buck2_dvs *b2_dvs;
249	u8 val, idx, addr;
250	int pin1, pin2;
251
252	switch (id) {
253	case BUCK1:
254	if (mode == EXTPIN) {
255	b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
256	if (!b1_dvs)
257	goto err;
258
259	idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
260	} else {
261	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
262	idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
263	}
264	addr = buck1_vout_addr[idx];
265	break;
266	case BUCK2:
267	if (mode == EXTPIN) {
268	b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
269	if (!b2_dvs)
270	goto err;
271
272	pin1 = gpio_get_value(b2_dvs->gpio[0]);
273	pin2 = gpio_get_value(b2_dvs->gpio[1]);
274
275	if (pin1 == PIN_LOW && pin2 == PIN_LOW)
276	idx = 0;
277	else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
278	idx = 2;
279	else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
280	idx = 1;
281	else
282	idx = 3;
283	} else {
284	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
285	idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
286	}
287	addr = buck2_vout_addr[idx];
288	break;
289	default:
290	goto err;
291	}
292
293	return addr;
294	err:
295	return INVALID_ADDR;
296	}
297
298	static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
299	unsigned selector)
300	{
301	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
302	enum lp8788_buck_id id = rdev_get_id(rdev);
303	u8 addr;
304
305	if (buck->dvs)
306	lp8788_set_dvs(buck, id);
307
308	addr = lp8788_select_buck_vout_addr(buck, id);
309	if (!lp8788_is_valid_buck_addr(addr))
310	return -EINVAL;
311
312	return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
313	}
314
315	static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
316	{
317	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
318	enum lp8788_buck_id id = rdev_get_id(rdev);
319	int ret;
320	u8 val, addr;
321
322	addr = lp8788_select_buck_vout_addr(buck, id);
323	if (!lp8788_is_valid_buck_addr(addr))
324	return -EINVAL;
325
326	ret = lp8788_read_byte(buck->lp, addr, &val);
327	if (ret)
328	return ret;
329
330	return val & LP8788_VOUT_M;
331	}
332
333	static int lp8788_buck_enable_time(struct regulator_dev *rdev)
334	{
335	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
336	enum lp8788_buck_id id = rdev_get_id(rdev);
337	u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
338
339	if (lp8788_read_byte(buck->lp, addr, &val))
340	return -EINVAL;
341
342	val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
343
344	return ENABLE_TIME_USEC * val;
345	}
346
347	static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
348	{
349	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
350	struct lp8788_pwm_map *pmap = buck->pmap;
351	u8 val;
352
353	if (!pmap)
354	return -EINVAL;
355
356	switch (mode) {
357	case REGULATOR_MODE_FAST:
358	val = LP8788_FORCE_PWM << pmap->shift;
359	break;
360	case REGULATOR_MODE_NORMAL:
361	val = LP8788_AUTO_PWM << pmap->shift;
362	break;
363	default:
364	return -EINVAL;
365	}
366
367	return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
368	}
369
370	static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
371	{
372	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
373	struct lp8788_pwm_map *pmap = buck->pmap;
374	u8 val;
375	int ret;
376
377	if (!pmap)
378	return -EINVAL;
379
380	ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
381	if (ret)
382	return ret;
383
384	return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
385	}
386
387	static struct regulator_ops lp8788_buck12_ops = {
388	.list_voltage = regulator_list_voltage_table,
389	.set_voltage_sel = lp8788_buck12_set_voltage_sel,
390	.get_voltage_sel = lp8788_buck12_get_voltage_sel,
391	.enable = regulator_enable_regmap,
392	.disable = regulator_disable_regmap,
393	.is_enabled = regulator_is_enabled_regmap,
394	.enable_time = lp8788_buck_enable_time,
395	.set_mode = lp8788_buck_set_mode,
396	.get_mode = lp8788_buck_get_mode,
397	};
398
399	static struct regulator_ops lp8788_buck34_ops = {
400	.list_voltage = regulator_list_voltage_table,
401	.set_voltage_sel = regulator_set_voltage_sel_regmap,
402	.get_voltage_sel = regulator_get_voltage_sel_regmap,
403	.enable = regulator_enable_regmap,
404	.disable = regulator_disable_regmap,
405	.is_enabled = regulator_is_enabled_regmap,
406	.enable_time = lp8788_buck_enable_time,
407	.set_mode = lp8788_buck_set_mode,
408	.get_mode = lp8788_buck_get_mode,
409	};
410
411	static struct regulator_desc lp8788_buck_desc[] = {
412	{
413	.name = "buck1",
414	.id = BUCK1,
415	.ops = &lp8788_buck12_ops,
416	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
417	.volt_table = lp8788_buck_vtbl,
418	.type = REGULATOR_VOLTAGE,
419	.owner = THIS_MODULE,
420	.enable_reg = LP8788_EN_BUCK,
421	.enable_mask = LP8788_EN_BUCK1_M,
422	},
423	{
424	.name = "buck2",
425	.id = BUCK2,
426	.ops = &lp8788_buck12_ops,
427	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
428	.volt_table = lp8788_buck_vtbl,
429	.type = REGULATOR_VOLTAGE,
430	.owner = THIS_MODULE,
431	.enable_reg = LP8788_EN_BUCK,
432	.enable_mask = LP8788_EN_BUCK2_M,
433	},
434	{
435	.name = "buck3",
436	.id = BUCK3,
437	.ops = &lp8788_buck34_ops,
438	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
439	.volt_table = lp8788_buck_vtbl,
440	.type = REGULATOR_VOLTAGE,
441	.owner = THIS_MODULE,
442	.vsel_reg = LP8788_BUCK3_VOUT,
443	.vsel_mask = LP8788_VOUT_M,
444	.enable_reg = LP8788_EN_BUCK,
445	.enable_mask = LP8788_EN_BUCK3_M,
446	},
447	{
448	.name = "buck4",
449	.id = BUCK4,
450	.ops = &lp8788_buck34_ops,
451	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
452	.volt_table = lp8788_buck_vtbl,
453	.type = REGULATOR_VOLTAGE,
454	.owner = THIS_MODULE,
455	.vsel_reg = LP8788_BUCK4_VOUT,
456	.vsel_mask = LP8788_VOUT_M,
457	.enable_reg = LP8788_EN_BUCK,
458	.enable_mask = LP8788_EN_BUCK4_M,
459	},
460	};
461
462	static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
463	enum lp8788_buck_id id)
464	{
465	u8 mask, val;
466
467	switch (id) {
468	case BUCK1:
469	mask = LP8788_BUCK1_DVS_SEL_M;
470	val = LP8788_BUCK1_DVS_I2C;
471	break;
472	case BUCK2:
473	mask = LP8788_BUCK2_DVS_SEL_M;
474	val = LP8788_BUCK2_DVS_I2C;
475	break;
476	default:
477	return 0;
478	}
479
480	return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
481	}
482
483	static int _gpio_request(struct lp8788_buck buck, int gpio, char name)
484	{
485	struct device *dev = buck->lp->dev;
486
487	if (!gpio_is_valid(gpio)) {
488	dev_err(dev, "invalid gpio: %d\n", gpio);
489	return -EINVAL;
490	}
491
492	return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
493	}
494
495	static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
496	enum lp8788_buck_id id)
497	{
498	struct lp8788_platform_data *pdata = buck->lp->pdata;
499	char *b1_name = "LP8788_B1_DVS";
500	char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
501	int i, gpio, ret;
502
503	switch (id) {
504	case BUCK1:
505	gpio = pdata->buck1_dvs->gpio;
506	ret = _gpio_request(buck, gpio, b1_name);
507	if (ret)
508	return ret;
509
510	buck->dvs = pdata->buck1_dvs;
511	break;
512	case BUCK2:
513	for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
514	gpio = pdata->buck2_dvs->gpio[i];
515	ret = _gpio_request(buck, gpio, b2_name[i]);
516	if (ret)
517	return ret;
518	}
519	buck->dvs = pdata->buck2_dvs;
520	break;
521	default:
522	break;
523	}
524
525	return 0;
526	}
527
528	static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
529	{
530	struct lp8788_platform_data *pdata = buck->lp->pdata;
531	u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
532	u8 val[] = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
533
534	/* no dvs for buck3, 4 */
535	if (id == BUCK3 \|\| id == BUCK4)
536	return 0;
537
538	/* no dvs platform data, then dvs will be selected by I2C registers */
539	if (!pdata)
540	goto set_default_dvs_mode;
541
542	if ((id == BUCK1 && !pdata->buck1_dvs) \|\|
543	(id == BUCK2 && !pdata->buck2_dvs))
544	goto set_default_dvs_mode;
545
546	if (lp8788_dvs_gpio_request(buck, id))
547	goto set_default_dvs_mode;
548
549	return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
550	val[id]);
551
552	set_default_dvs_mode:
553	return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
554	}
555
556	static __devinit int lp8788_buck_probe(struct platform_device *pdev)
557	{
558	struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
559	int id = pdev->id;
560	struct lp8788_buck *buck;
561	struct regulator_config cfg = { };
562	struct regulator_dev *rdev;
563	int ret;
564
565	buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
566	if (!buck)
567	return -ENOMEM;
568
569	buck->lp = lp;
570	buck->pmap = &buck_pmap[id];
571
572	ret = lp8788_init_dvs(buck, id);
573	if (ret)
574	return ret;
575
576	cfg.dev = lp->dev;
577	cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
578	cfg.driver_data = buck;
579	cfg.regmap = lp->regmap;
580
581	rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
582	if (IS_ERR(rdev)) {
583	ret = PTR_ERR(rdev);
584	dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
585	id + 1, ret);
586	return ret;
587	}
588
589	buck->regulator = rdev;
590	platform_set_drvdata(pdev, buck);
591
592	return 0;
593	}
594
595	static int __devexit lp8788_buck_remove(struct platform_device *pdev)
596	{
597	struct lp8788_buck *buck = platform_get_drvdata(pdev);
598
599	platform_set_drvdata(pdev, NULL);
600	regulator_unregister(buck->regulator);
601
602	return 0;
603	}
604
605	static struct platform_driver lp8788_buck_driver = {
606	.probe = lp8788_buck_probe,
607	.remove = __devexit_p(lp8788_buck_remove),
608	.driver = {
609	.name = LP8788_DEV_BUCK,
610	.owner = THIS_MODULE,
611	},
612	};
613
614	static int __init lp8788_buck_init(void)
615	{
616	return platform_driver_register(&lp8788_buck_driver);
617	}
618	subsys_initcall(lp8788_buck_init);
619
620	static void __exit lp8788_buck_exit(void)
621	{
622	platform_driver_unregister(&lp8788_buck_driver);
623	}
624	module_exit(lp8788_buck_exit);
625
626	MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
627	MODULE_AUTHOR("Milo Kim");
628	MODULE_LICENSE("GPL");
629	MODULE_ALIAS("platform:lp8788-buck");