[mirror_ubuntu-hirsute-kernel.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

#define BUCK_FPWM_MASK(x)		(1 << (x))
#define BUCK_FPWM_SHIFT(x)		(x)

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_buck {
	struct lp8788 *lp;
	struct regulator_dev *regulator;
	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,
};

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);
	enum lp8788_buck_id id = rdev_get_id(rdev);
	u8 mask, val;

	mask = BUCK_FPWM_MASK(id);
	switch (mode) {
	case REGULATOR_MODE_FAST:
		val = LP8788_FORCE_PWM << BUCK_FPWM_SHIFT(id);
		break;
	case REGULATOR_MODE_NORMAL:
		val = LP8788_AUTO_PWM << BUCK_FPWM_SHIFT(id);
		break;
	default:
		return -EINVAL;
	}

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

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

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

	return val & BUCK_FPWM_MASK(id) ?
				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_dvs_gpio_request(struct platform_device *pdev,
				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 = devm_gpio_request_one(&pdev->dev, gpio, DVS_LOW,
					    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 = devm_gpio_request_one(&pdev->dev, gpio,
						    DVS_LOW, b2_name[i]);
			if (ret)
				return ret;
		}
		buck->dvs = pdata->buck2_dvs;
		break;
	default:
		break;
	}

	return 0;
}

static int lp8788_init_dvs(struct platform_device *pdev,
			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 };
	u8 default_dvs_mode[] = { LP8788_BUCK1_DVS_I2C, LP8788_BUCK2_DVS_I2C };

	/* 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(pdev, 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_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
				  default_dvs_mode[id]);
}

static 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(&pdev->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
	if (!buck)
		return -ENOMEM;

	buck->lp = lp;

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

	cfg.dev = pdev->dev.parent;
	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(&pdev->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 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 = 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
0f4c46d2 AL	72	#define BUCK_FPWM_MASK(x) (1 << (x))
	73	#define BUCK_FPWM_SHIFT(x) (x)
	74
ade7515f KM	75	enum lp8788_dvs_state {
	76	DVS_LOW = GPIOF_OUT_INIT_LOW,
	77	DVS_HIGH = GPIOF_OUT_INIT_HIGH,
	78	};
	79
	80	enum lp8788_dvs_mode {
	81	REGISTER,
	82	EXTPIN,
	83	};
	84
	85	enum lp8788_buck_id {
	86	BUCK1,
	87	BUCK2,
	88	BUCK3,
	89	BUCK4,
	90	};
	91
ade7515f KM	92	struct lp8788_buck {
	93	struct lp8788 *lp;
	94	struct regulator_dev *regulator;
ade7515f KM	95	void *dvs;
	96	};
	97
	98	/* BUCK 1 ~ 4 voltage table */
	99	static const int lp8788_buck_vtbl[] = {
	100	500000, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
	101	1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
	102	1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
	103	1950000, 2000000,
	104	};
	105
ade7515f KM	106	static const u8 buck1_vout_addr[] = {
	107	LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
	108	LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
	109	};
	110
	111	static const u8 buck2_vout_addr[] = {
	112	LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
	113	LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
	114	};
	115
	116	static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
	117	{
	118	struct lp8788_buck1_dvs dvs = (struct lp8788_buck1_dvs )buck->dvs;
	119	enum lp8788_dvs_state pinstate;
	120
	121	if (!dvs)
	122	return;
	123
	124	pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
	125	if (gpio_is_valid(dvs->gpio))
	126	gpio_set_value(dvs->gpio, pinstate);
	127	}
	128
	129	static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
	130	{
	131	struct lp8788_buck2_dvs dvs = (struct lp8788_buck2_dvs )buck->dvs;
	132	enum lp8788_dvs_state pin1, pin2;
	133
	134	if (!dvs)
	135	return;
	136
	137	switch (dvs->vsel) {
	138	case DVS_SEL_V0:
	139	pin1 = DVS_LOW;
	140	pin2 = DVS_LOW;
	141	break;
	142	case DVS_SEL_V1:
	143	pin1 = DVS_HIGH;
	144	pin2 = DVS_LOW;
	145	break;
	146	case DVS_SEL_V2:
	147	pin1 = DVS_LOW;
	148	pin2 = DVS_HIGH;
	149	break;
	150	case DVS_SEL_V3:
	151	pin1 = DVS_HIGH;
	152	pin2 = DVS_HIGH;
	153	break;
	154	default:
	155	return;
	156	}
	157
	158	if (gpio_is_valid(dvs->gpio[0]))
	159	gpio_set_value(dvs->gpio[0], pin1);
	160
	161	if (gpio_is_valid(dvs->gpio[1]))
	162	gpio_set_value(dvs->gpio[1], pin2);
	163	}
	164
	165	static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
	166	{
	167	switch (id) {
	168	case BUCK1:
	169	lp8788_buck1_set_dvs(buck);
170	break;
171	case BUCK2:
172	lp8788_buck2_set_dvs(buck);
173	break;
174	default:
175	break;
176	}
177	}
178
179	static enum lp8788_dvs_mode
180	lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
181	{
182	u8 val, mask;
183
184	switch (id) {
185	case BUCK1:
186	mask = LP8788_BUCK1_DVS_SEL_M;
187	break;
188	case BUCK2:
189	mask = LP8788_BUCK2_DVS_SEL_M;
190	break;
191	default:
192	return REGISTER;
193	}
194
195	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
196
197	return val & mask ? REGISTER : EXTPIN;
198	}
199
200	static bool lp8788_is_valid_buck_addr(u8 addr)
201	{
202	switch (addr) {
203	case LP8788_BUCK1_VOUT0:
204	case LP8788_BUCK1_VOUT1:
205	case LP8788_BUCK1_VOUT2:
206	case LP8788_BUCK1_VOUT3:
207	case LP8788_BUCK2_VOUT0:
208	case LP8788_BUCK2_VOUT1:
209	case LP8788_BUCK2_VOUT2:
210	case LP8788_BUCK2_VOUT3:
211	return true;
212	default:
213	return false;
214	}
215	}
216
217	static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
218	enum lp8788_buck_id id)
219	{
220	enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
221	struct lp8788_buck1_dvs *b1_dvs;
222	struct lp8788_buck2_dvs *b2_dvs;
223	u8 val, idx, addr;
224	int pin1, pin2;
225
226	switch (id) {
227	case BUCK1:
228	if (mode == EXTPIN) {
229	b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
230	if (!b1_dvs)
231	goto err;
232
233	idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
234	} else {
235	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
236	idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
237	}
238	addr = buck1_vout_addr[idx];
239	break;
240	case BUCK2:
241	if (mode == EXTPIN) {
242	b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
243	if (!b2_dvs)
244	goto err;
245
246	pin1 = gpio_get_value(b2_dvs->gpio[0]);
247	pin2 = gpio_get_value(b2_dvs->gpio[1]);
248
249	if (pin1 == PIN_LOW && pin2 == PIN_LOW)
250	idx = 0;
251	else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
252	idx = 2;
253	else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
254	idx = 1;
255	else
256	idx = 3;
257	} else {
258	lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
259	idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
260	}
261	addr = buck2_vout_addr[idx];
262	break;
263	default:
264	goto err;
265	}
266
267	return addr;
268	err:
269	return INVALID_ADDR;
270	}
271
272	static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
273	unsigned selector)
274	{
275	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
276	enum lp8788_buck_id id = rdev_get_id(rdev);
277	u8 addr;
278
279	if (buck->dvs)
280	lp8788_set_dvs(buck, id);
281
282	addr = lp8788_select_buck_vout_addr(buck, id);
283	if (!lp8788_is_valid_buck_addr(addr))
284	return -EINVAL;
285
286	return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
287	}
288
289	static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
290	{
291	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
292	enum lp8788_buck_id id = rdev_get_id(rdev);
293	int ret;
294	u8 val, addr;
295
296	addr = lp8788_select_buck_vout_addr(buck, id);
297	if (!lp8788_is_valid_buck_addr(addr))
298	return -EINVAL;
299
300	ret = lp8788_read_byte(buck->lp, addr, &val);
301	if (ret)
302	return ret;
303
304	return val & LP8788_VOUT_M;
305	}
306
307	static int lp8788_buck_enable_time(struct regulator_dev *rdev)
308	{
309	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
310	enum lp8788_buck_id id = rdev_get_id(rdev);
311	u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
312
313	if (lp8788_read_byte(buck->lp, addr, &val))
314	return -EINVAL;
315
316	val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
317
318	return ENABLE_TIME_USEC * val;
319	}
320
321	static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
322	{
323	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
0f4c46d2 AL	324	enum lp8788_buck_id id = rdev_get_id(rdev);
0f4c46d2 AL	325	u8 mask, val;
ade7515f	326
0f4c46d2	327	mask = BUCK_FPWM_MASK(id);
ade7515f KM	328	switch (mode) {
ade7515f KM	329	case REGULATOR_MODE_FAST:
0f4c46d2	330	val = LP8788_FORCE_PWM << BUCK_FPWM_SHIFT(id);
ade7515f KM	331	break;
ade7515f KM	332	case REGULATOR_MODE_NORMAL:
0f4c46d2	333	val = LP8788_AUTO_PWM << BUCK_FPWM_SHIFT(id);
ade7515f KM	334	break;
	335	default:
	336	return -EINVAL;
	337	}
	338
0f4c46d2	339	return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, mask, val);
ade7515f KM	340	}
	341
	342	static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
	343	{
	344	struct lp8788_buck *buck = rdev_get_drvdata(rdev);
0f4c46d2	345	enum lp8788_buck_id id = rdev_get_id(rdev);
ade7515f KM	346	u8 val;
	347	int ret;
	348
ade7515f KM	349	ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
	350	if (ret)
	351	return ret;
	352
0f4c46d2 AL	353	return val & BUCK_FPWM_MASK(id) ?
0f4c46d2 AL	354	REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
ade7515f KM	355	}
	356
	357	static struct regulator_ops lp8788_buck12_ops = {
	358	.list_voltage = regulator_list_voltage_table,
	359	.set_voltage_sel = lp8788_buck12_set_voltage_sel,
	360	.get_voltage_sel = lp8788_buck12_get_voltage_sel,
	361	.enable = regulator_enable_regmap,
	362	.disable = regulator_disable_regmap,
	363	.is_enabled = regulator_is_enabled_regmap,
	364	.enable_time = lp8788_buck_enable_time,
	365	.set_mode = lp8788_buck_set_mode,
	366	.get_mode = lp8788_buck_get_mode,
	367	};
	368
	369	static struct regulator_ops lp8788_buck34_ops = {
	370	.list_voltage = regulator_list_voltage_table,
	371	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	372	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	373	.enable = regulator_enable_regmap,
	374	.disable = regulator_disable_regmap,
	375	.is_enabled = regulator_is_enabled_regmap,
	376	.enable_time = lp8788_buck_enable_time,
	377	.set_mode = lp8788_buck_set_mode,
	378	.get_mode = lp8788_buck_get_mode,
	379	};
	380
	381	static struct regulator_desc lp8788_buck_desc[] = {
	382	{
	383	.name = "buck1",
	384	.id = BUCK1,
	385	.ops = &lp8788_buck12_ops,
	386	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
	387	.volt_table = lp8788_buck_vtbl,
	388	.type = REGULATOR_VOLTAGE,
	389	.owner = THIS_MODULE,
	390	.enable_reg = LP8788_EN_BUCK,
	391	.enable_mask = LP8788_EN_BUCK1_M,
	392	},
	393	{
	394	.name = "buck2",
	395	.id = BUCK2,
	396	.ops = &lp8788_buck12_ops,
	397	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
	398	.volt_table = lp8788_buck_vtbl,
	399	.type = REGULATOR_VOLTAGE,
	400	.owner = THIS_MODULE,
	401	.enable_reg = LP8788_EN_BUCK,
	402	.enable_mask = LP8788_EN_BUCK2_M,
	403	},
	404	{
	405	.name = "buck3",
	406	.id = BUCK3,
	407	.ops = &lp8788_buck34_ops,
	408	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
	409	.volt_table = lp8788_buck_vtbl,
	410	.type = REGULATOR_VOLTAGE,
	411	.owner = THIS_MODULE,
	412	.vsel_reg = LP8788_BUCK3_VOUT,
	413	.vsel_mask = LP8788_VOUT_M,
	414	.enable_reg = LP8788_EN_BUCK,
	415	.enable_mask = LP8788_EN_BUCK3_M,
	416	},
	417	{
	418	.name = "buck4",
419	.id = BUCK4,
420	.ops = &lp8788_buck34_ops,
421	.n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
422	.volt_table = lp8788_buck_vtbl,
423	.type = REGULATOR_VOLTAGE,
424	.owner = THIS_MODULE,
425	.vsel_reg = LP8788_BUCK4_VOUT,
426	.vsel_mask = LP8788_VOUT_M,
427	.enable_reg = LP8788_EN_BUCK,
428	.enable_mask = LP8788_EN_BUCK4_M,
429	},
430	};
431
38d8f67c KM	432	static int lp8788_dvs_gpio_request(struct platform_device *pdev,
38d8f67c KM	433	struct lp8788_buck *buck,
ade7515f KM	434	enum lp8788_buck_id id)
	435	{
	436	struct lp8788_platform_data *pdata = buck->lp->pdata;
	437	char *b1_name = "LP8788_B1_DVS";
	438	char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
	439	int i, gpio, ret;
	440
	441	switch (id) {
	442	case BUCK1:
	443	gpio = pdata->buck1_dvs->gpio;
38d8f67c	444	ret = devm_gpio_request_one(&pdev->dev, gpio, DVS_LOW,
131a5b9d	445	b1_name);
ade7515f KM	446	if (ret)
	447	return ret;
	448
	449	buck->dvs = pdata->buck1_dvs;
	450	break;
	451	case BUCK2:
	452	for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
	453	gpio = pdata->buck2_dvs->gpio[i];
38d8f67c	454	ret = devm_gpio_request_one(&pdev->dev, gpio,
131a5b9d	455	DVS_LOW, b2_name[i]);
ade7515f KM	456	if (ret)
	457	return ret;
	458	}
	459	buck->dvs = pdata->buck2_dvs;
	460	break;
	461	default:
	462	break;
	463	}
	464
	465	return 0;
	466	}
	467
38d8f67c KM	468	static int lp8788_init_dvs(struct platform_device *pdev,
38d8f67c KM	469	struct lp8788_buck *buck, enum lp8788_buck_id id)
ade7515f KM	470	{
	471	struct lp8788_platform_data *pdata = buck->lp->pdata;
	472	u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
	473	u8 val[] = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
c42ea5cd	474	u8 default_dvs_mode[] = { LP8788_BUCK1_DVS_I2C, LP8788_BUCK2_DVS_I2C };
ade7515f KM	475
	476	/* no dvs for buck3, 4 */
	477	if (id == BUCK3 \|\| id == BUCK4)
	478	return 0;
	479
	480	/* no dvs platform data, then dvs will be selected by I2C registers */
	481	if (!pdata)
	482	goto set_default_dvs_mode;
	483
	484	if ((id == BUCK1 && !pdata->buck1_dvs) \|\|
	485	(id == BUCK2 && !pdata->buck2_dvs))
	486	goto set_default_dvs_mode;
	487
38d8f67c	488	if (lp8788_dvs_gpio_request(pdev, buck, id))
ade7515f KM	489	goto set_default_dvs_mode;
	490
	491	return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
	492	val[id]);
	493
	494	set_default_dvs_mode:
c42ea5cd AL	495	return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
c42ea5cd AL	496	default_dvs_mode[id]);
ade7515f KM	497	}
ade7515f KM	498
a5023574	499	static int lp8788_buck_probe(struct platform_device *pdev)
ade7515f KM	500	{
	501	struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
	502	int id = pdev->id;
	503	struct lp8788_buck *buck;
	504	struct regulator_config cfg = { };
	505	struct regulator_dev *rdev;
	506	int ret;
	507
3b0e8f12	508	buck = devm_kzalloc(&pdev->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
ade7515f KM	509	if (!buck)
	510	return -ENOMEM;
	511
	512	buck->lp = lp;
ade7515f	513
38d8f67c	514	ret = lp8788_init_dvs(pdev, buck, id);
ade7515f KM	515	if (ret)
	516	return ret;
	517
3b0e8f12	518	cfg.dev = pdev->dev.parent;
ade7515f KM	519	cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
	520	cfg.driver_data = buck;
	521	cfg.regmap = lp->regmap;
	522
	523	rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
	524	if (IS_ERR(rdev)) {
	525	ret = PTR_ERR(rdev);
3b0e8f12	526	dev_err(&pdev->dev, "BUCK%d regulator register err = %d\n",
ade7515f KM	527	id + 1, ret);
	528	return ret;
	529	}
	530
	531	buck->regulator = rdev;
	532	platform_set_drvdata(pdev, buck);
	533
	534	return 0;
	535	}
	536
8dc995f5	537	static int lp8788_buck_remove(struct platform_device *pdev)
ade7515f KM	538	{
	539	struct lp8788_buck *buck = platform_get_drvdata(pdev);
	540
	541	platform_set_drvdata(pdev, NULL);
	542	regulator_unregister(buck->regulator);
	543
	544	return 0;
	545	}
	546
	547	static struct platform_driver lp8788_buck_driver = {
	548	.probe = lp8788_buck_probe,
5eb9f2b9	549	.remove = lp8788_buck_remove,
ade7515f KM	550	.driver = {
	551	.name = LP8788_DEV_BUCK,
	552	.owner = THIS_MODULE,
	553	},
	554	};
	555
	556	static int __init lp8788_buck_init(void)
	557	{
	558	return platform_driver_register(&lp8788_buck_driver);
	559	}
	560	subsys_initcall(lp8788_buck_init);
	561
	562	static void __exit lp8788_buck_exit(void)
	563	{
	564	platform_driver_unregister(&lp8788_buck_driver);
	565	}
	566	module_exit(lp8788_buck_exit);
	567
	568	MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
	569	MODULE_AUTHOR("Milo Kim");
	570	MODULE_LICENSE("GPL");
	571	MODULE_ALIAS("platform:lp8788-buck");