[deliverable/linux.git] / drivers / regulator / tps65912-regulator.c

/*
 * tps65912.c  --  TI tps65912
 *
 * Copyright 2011 Texas Instruments Inc.
 *
 * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under  the terms of the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the License, or (at your
 *  option) any later version.
 *
 * This driver is based on wm8350 implementation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/mfd/tps65912.h>

/* DCDC's */
#define TPS65912_REG_DCDC1	0
#define TPS65912_REG_DCDC2	1
#define TPS65912_REG_DCDC3	2
#define TPS65912_REG_DCDC4	3

/* LDOs */
#define TPS65912_REG_LDO1	4
#define TPS65912_REG_LDO2	5
#define TPS65912_REG_LDO3	6
#define TPS65912_REG_LDO4	7
#define TPS65912_REG_LDO5	8
#define TPS65912_REG_LDO6	9
#define TPS65912_REG_LDO7	10
#define TPS65912_REG_LDO8	11
#define TPS65912_REG_LDO9	12
#define TPS65912_REG_LDO10	13

/* Number of step-down converters available */
#define TPS65912_NUM_DCDC	4

/* Number of LDO voltage regulators  available */
#define TPS65912_NUM_LDO	10

/* Number of total regulators available */
#define TPS65912_NUM_REGULATOR		(TPS65912_NUM_DCDC + TPS65912_NUM_LDO)

#define TPS65912_REG_ENABLED	0x80
#define OP_SELREG_MASK		0x40
#define OP_SELREG_SHIFT		6

struct tps_info {
	const char *name;
};

static struct tps_info tps65912_regs[] = {
	{
		.name = "DCDC1",
	},
	{
		.name = "DCDC2",
	},
	{
		.name = "DCDC3",
	},
	{
		.name = "DCDC4",
	},
	{
		.name = "LDO1",
	},
	{
		.name = "LDO2",
	},
	{
		.name = "LDO3",
	},
	{
		.name = "LDO4",
	},
	{
		.name = "LDO5",
	},
	{
		.name = "LDO6",
	},
	{
		.name = "LDO7",
	},
	{
		.name = "LDO8",
	},
	{
		.name = "LDO9",
	},
	{
		.name = "LDO10",
	},
};

struct tps65912_reg {
	struct regulator_desc desc[TPS65912_NUM_REGULATOR];
	struct tps65912 *mfd;
	struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
	struct tps_info *info[TPS65912_NUM_REGULATOR];
	/* for read/write access */
	struct mutex io_lock;
	int mode;
	int (*get_ctrl_reg)(int);
	int dcdc_range[TPS65912_NUM_DCDC];
	int pwm_mode_reg;
	int eco_reg;
};

static const struct regulator_linear_range tps65912_ldo_ranges[] = {
	{ .min_uV = 800000, .max_uV = 1600000, .min_sel =  0, .max_sel = 32,
	  .uV_step = 25000 },
	{ .min_uV = 1650000, .max_uV = 3000000, .min_sel = 33, .max_sel = 60,
	  .uV_step = 50000 },
	{ .min_uV = 3100000, .max_uV = 3300000, .min_sel = 61, .max_sel = 63,
	  .uV_step = 100000 },
};

static int tps65912_get_range(struct tps65912_reg *pmic, int id)
{
	struct tps65912 *mfd = pmic->mfd;
	int range;

	switch (id) {
	case TPS65912_REG_DCDC1:
		range = tps65912_reg_read(mfd, TPS65912_DCDC1_LIMIT);
		break;
	case TPS65912_REG_DCDC2:
		range = tps65912_reg_read(mfd, TPS65912_DCDC2_LIMIT);
		break;
	case TPS65912_REG_DCDC3:
		range = tps65912_reg_read(mfd, TPS65912_DCDC3_LIMIT);
		break;
	case TPS65912_REG_DCDC4:
		range = tps65912_reg_read(mfd, TPS65912_DCDC4_LIMIT);
		break;
	default:
		return 0;
	}

	if (range >= 0)
		range = (range & DCDC_LIMIT_RANGE_MASK)
			>> DCDC_LIMIT_RANGE_SHIFT;

	pmic->dcdc_range[id] = range;
	return range;
}

static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
{
	unsigned long uv;

	uv = ((vsel * 12500) + 500000);
	return uv;
}

static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
{
	unsigned long uv;

	 uv = ((vsel * 12500) + 700000);
	return uv;
}

static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
{
	unsigned long uv;

	uv = ((vsel * 25000) + 500000);
	return uv;
}

static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
{
	unsigned long uv;

	if (vsel == 0x3f)
		uv = 3800000;
	else
		uv = ((vsel * 50000) + 500000);

	return uv;
}

static int tps65912_get_ctrl_register(int id)
{
	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4)
		return id * 3 + TPS65912_DCDC1_AVS;
	else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10)
		return id - TPS65912_REG_LDO5 + TPS65912_LDO5;
	else
		return -EINVAL;
}

static int tps65912_get_sel_register(struct tps65912_reg *pmic, int id)
{
	struct tps65912 *mfd = pmic->mfd;
	int opvsel;
	u8 reg = 0;

	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4) {
		opvsel = tps65912_reg_read(mfd, id * 3 + TPS65912_DCDC1_OP);
		if (opvsel & OP_SELREG_MASK)
			reg = id * 3 + TPS65912_DCDC1_AVS;
		else
			reg = id * 3 + TPS65912_DCDC1_OP;
	} else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10) {
		reg = id - TPS65912_REG_LDO5 + TPS65912_LDO5;
	} else {
		return -EINVAL;
	}

	return reg;
}

static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
{
	switch (id) {
	case TPS65912_REG_DCDC1:
		pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
		pmic->eco_reg = TPS65912_DCDC1_AVS;
		break;
	case TPS65912_REG_DCDC2:
		pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
		pmic->eco_reg = TPS65912_DCDC2_AVS;
		break;
	case TPS65912_REG_DCDC3:
		pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
		pmic->eco_reg = TPS65912_DCDC3_AVS;
		break;
	case TPS65912_REG_DCDC4:
		pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
		pmic->eco_reg = TPS65912_DCDC4_AVS;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int tps65912_reg_is_enabled(struct regulator_dev *dev)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int reg, value, id = rdev_get_id(dev);

	if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
		return -EINVAL;

	reg = pmic->get_ctrl_reg(id);
	if (reg < 0)
		return reg;

	value = tps65912_reg_read(mfd, reg);
	if (value < 0)
		return value;

	return value & TPS65912_REG_ENABLED;
}

static int tps65912_reg_enable(struct regulator_dev *dev)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int id = rdev_get_id(dev);
	int reg;

	if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
		return -EINVAL;

	reg = pmic->get_ctrl_reg(id);
	if (reg < 0)
		return reg;

	return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
}

static int tps65912_reg_disable(struct regulator_dev *dev)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int id = rdev_get_id(dev), reg;

	reg = pmic->get_ctrl_reg(id);
	if (reg < 0)
		return reg;

	return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
}

static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int pwm_mode, eco, id = rdev_get_id(dev);

	tps65912_get_mode_regiters(pmic, id);

	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
	eco = tps65912_reg_read(mfd, pmic->eco_reg);

	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
	eco &= DCDC_AVS_ECO_MASK;

	switch (mode) {
	case REGULATOR_MODE_FAST:
		/* Verify if mode alredy set */
		if (pwm_mode && !eco)
			break;
		tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
		tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
		break;
	case REGULATOR_MODE_NORMAL:
	case REGULATOR_MODE_IDLE:
		if (!pwm_mode && !eco)
			break;
		tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
		tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
		break;
	case REGULATOR_MODE_STANDBY:
		if (!pwm_mode && eco)
			break;
		tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
		tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static unsigned int tps65912_get_mode(struct regulator_dev *dev)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);

	tps65912_get_mode_regiters(pmic, id);

	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
	eco = tps65912_reg_read(mfd, pmic->eco_reg);

	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
	eco &= DCDC_AVS_ECO_MASK;

	if (pwm_mode && !eco)
		mode = REGULATOR_MODE_FAST;
	else if (!pwm_mode && !eco)
		mode = REGULATOR_MODE_NORMAL;
	else if (!pwm_mode && eco)
		mode = REGULATOR_MODE_STANDBY;

	return mode;
}

static int tps65912_list_voltage(struct regulator_dev *dev, unsigned selector)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	int range, voltage = 0, id = rdev_get_id(dev);

	if (id > TPS65912_REG_DCDC4)
		return -EINVAL;

	range = pmic->dcdc_range[id];

	switch (range) {
	case 0:
		/* 0.5 - 1.2875V in 12.5mV steps */
		voltage = tps65912_vsel_to_uv_range0(selector);
		break;
	case 1:
		/* 0.7 - 1.4875V in 12.5mV steps */
		voltage = tps65912_vsel_to_uv_range1(selector);
		break;
	case 2:
		/* 0.5 - 2.075V in 25mV steps */
		voltage = tps65912_vsel_to_uv_range2(selector);
		break;
	case 3:
		/* 0.5 - 3.8V in 50mV steps */
		voltage = tps65912_vsel_to_uv_range3(selector);
		break;
	}
	return voltage;
}

static int tps65912_get_voltage_sel(struct regulator_dev *dev)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int id = rdev_get_id(dev);
	int reg, vsel;

	reg = tps65912_get_sel_register(pmic, id);
	if (reg < 0)
		return reg;

	vsel = tps65912_reg_read(mfd, reg);
	vsel &= 0x3F;

	return vsel;
}

static int tps65912_set_voltage_sel(struct regulator_dev *dev,
					 unsigned selector)
{
	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	struct tps65912 *mfd = pmic->mfd;
	int id = rdev_get_id(dev);
	int value;
	u8 reg;

	reg = tps65912_get_sel_register(pmic, id);
	value = tps65912_reg_read(mfd, reg);
	value &= 0xC0;
	return tps65912_reg_write(mfd, reg, selector | value);
}

/* Operations permitted on DCDCx */
static struct regulator_ops tps65912_ops_dcdc = {
	.is_enabled = tps65912_reg_is_enabled,
	.enable = tps65912_reg_enable,
	.disable = tps65912_reg_disable,
	.set_mode = tps65912_set_mode,
	.get_mode = tps65912_get_mode,
	.get_voltage_sel = tps65912_get_voltage_sel,
	.set_voltage_sel = tps65912_set_voltage_sel,
	.list_voltage = tps65912_list_voltage,
};

/* Operations permitted on LDOx */
static struct regulator_ops tps65912_ops_ldo = {
	.is_enabled = tps65912_reg_is_enabled,
	.enable = tps65912_reg_enable,
	.disable = tps65912_reg_disable,
	.get_voltage_sel = tps65912_get_voltage_sel,
	.set_voltage_sel = tps65912_set_voltage_sel,
	.list_voltage = regulator_list_voltage_linear_range,
	.map_voltage = regulator_map_voltage_linear_range,
};

static int tps65912_probe(struct platform_device *pdev)
{
	struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
	struct regulator_config config = { };
	struct tps_info *info;
	struct regulator_init_data *reg_data;
	struct regulator_dev *rdev;
	struct tps65912_reg *pmic;
	struct tps65912_board *pmic_plat_data;
	int i, err;

	pmic_plat_data = dev_get_platdata(tps65912->dev);
	if (!pmic_plat_data)
		return -EINVAL;

	reg_data = pmic_plat_data->tps65912_pmic_init_data;

	pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
	if (!pmic)
		return -ENOMEM;

	mutex_init(&pmic->io_lock);
	pmic->mfd = tps65912;
	platform_set_drvdata(pdev, pmic);

	pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
	info = tps65912_regs;

	for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
		int range = 0;
		/* Register the regulators */
		pmic->info[i] = info;

		pmic->desc[i].name = info->name;
		pmic->desc[i].id = i;
		pmic->desc[i].n_voltages = 64;
		if (i > TPS65912_REG_DCDC4) {
			pmic->desc[i].ops = &tps65912_ops_ldo;
			pmic->desc[i].linear_ranges = tps65912_ldo_ranges;
			pmic->desc[i].n_linear_ranges =
					ARRAY_SIZE(tps65912_ldo_ranges);
		} else {
			pmic->desc[i].ops = &tps65912_ops_dcdc;
		}
		pmic->desc[i].type = REGULATOR_VOLTAGE;
		pmic->desc[i].owner = THIS_MODULE;
		range = tps65912_get_range(pmic, i);

		config.dev = tps65912->dev;
		config.init_data = reg_data;
		config.driver_data = pmic;

		rdev = regulator_register(&pmic->desc[i], &config);
		if (IS_ERR(rdev)) {
			dev_err(tps65912->dev,
				"failed to register %s regulator\n",
				pdev->name);
			err = PTR_ERR(rdev);
			goto err;
		}

		/* Save regulator for cleanup */
		pmic->rdev[i] = rdev;
	}
	return 0;

err:
	while (--i >= 0)
		regulator_unregister(pmic->rdev[i]);
	return err;
}

static int tps65912_remove(struct platform_device *pdev)
{
	struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
		regulator_unregister(tps65912_reg->rdev[i]);
	return 0;
}

static struct platform_driver tps65912_driver = {
	.driver = {
		.name = "tps65912-pmic",
		.owner = THIS_MODULE,
	},
	.probe = tps65912_probe,
	.remove = tps65912_remove,
};

static int __init tps65912_init(void)
{
	return platform_driver_register(&tps65912_driver);
}
subsys_initcall(tps65912_init);

static void __exit tps65912_cleanup(void)
{
	platform_driver_unregister(&tps65912_driver);
}
module_exit(tps65912_cleanup);

MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:tps65912-pmic");
Commit	Line	Data
9260ad98 MO	1	/*
	2	* tps65912.c -- TI tps65912
	3	*
	4	* Copyright 2011 Texas Instruments Inc.
	5	*
	6	* Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	* This driver is based on wm8350 implementation.
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/init.h>
	19	#include <linux/err.h>
	20	#include <linux/platform_device.h>
	21	#include <linux/regulator/driver.h>
	22	#include <linux/regulator/machine.h>
9260ad98 MO	23	#include <linux/slab.h>
	24	#include <linux/gpio.h>
	25	#include <linux/mfd/tps65912.h>
	26
	27	/* DCDC's */
	28	#define TPS65912_REG_DCDC1 0
	29	#define TPS65912_REG_DCDC2 1
	30	#define TPS65912_REG_DCDC3 2
	31	#define TPS65912_REG_DCDC4 3
	32
	33	/* LDOs */
	34	#define TPS65912_REG_LDO1 4
	35	#define TPS65912_REG_LDO2 5
	36	#define TPS65912_REG_LDO3 6
	37	#define TPS65912_REG_LDO4 7
	38	#define TPS65912_REG_LDO5 8
	39	#define TPS65912_REG_LDO6 9
	40	#define TPS65912_REG_LDO7 10
	41	#define TPS65912_REG_LDO8 11
	42	#define TPS65912_REG_LDO9 12
	43	#define TPS65912_REG_LDO10 13
	44
9260ad98 MO	45	/* Number of step-down converters available */
	46	#define TPS65912_NUM_DCDC 4
	47
	48	/* Number of LDO voltage regulators available */
	49	#define TPS65912_NUM_LDO 10
	50
	51	/* Number of total regulators available */
	52	#define TPS65912_NUM_REGULATOR (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
	53
	54	#define TPS65912_REG_ENABLED 0x80
	55	#define OP_SELREG_MASK 0x40
	56	#define OP_SELREG_SHIFT 6
	57
	58	struct tps_info {
	59	const char *name;
	60	};
	61
	62	static struct tps_info tps65912_regs[] = {
	63	{
	64	.name = "DCDC1",
	65	},
	66	{
	67	.name = "DCDC2",
	68	},
	69	{
	70	.name = "DCDC3",
	71	},
	72	{
	73	.name = "DCDC4",
	74	},
	75	{
	76	.name = "LDO1",
	77	},
	78	{
	79	.name = "LDO2",
	80	},
	81	{
	82	.name = "LDO3",
	83	},
	84	{
	85	.name = "LDO4",
	86	},
	87	{
	88	.name = "LDO5",
	89	},
	90	{
	91	.name = "LDO6",
	92	},
	93	{
	94	.name = "LDO7",
	95	},
	96	{
	97	.name = "LDO8",
	98	},
	99	{
	100	.name = "LDO9",
	101	},
	102	{
	103	.name = "LDO10",
	104	},
	105	};
	106
	107	struct tps65912_reg {
	108	struct regulator_desc desc[TPS65912_NUM_REGULATOR];
109	struct tps65912 *mfd;
110	struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
111	struct tps_info *info[TPS65912_NUM_REGULATOR];
112	/* for read/write access */
113	struct mutex io_lock;
114	int mode;
115	int (*get_ctrl_reg)(int);
85c5d86d	116	int dcdc_range[TPS65912_NUM_DCDC];
9260ad98 MO	117	int pwm_mode_reg;
	118	int eco_reg;
	119	};
	120
fba6583b AL	121	static const struct regulator_linear_range tps65912_ldo_ranges[] = {
	122	{ .min_uV = 800000, .max_uV = 1600000, .min_sel = 0, .max_sel = 32,
	123	.uV_step = 25000 },
	124	{ .min_uV = 1650000, .max_uV = 3000000, .min_sel = 33, .max_sel = 60,
	125	.uV_step = 50000 },
	126	{ .min_uV = 3100000, .max_uV = 3300000, .min_sel = 61, .max_sel = 63,
	127	.uV_step = 100000 },
	128	};
	129
9260ad98 MO	130	static int tps65912_get_range(struct tps65912_reg *pmic, int id)
	131	{
	132	struct tps65912 *mfd = pmic->mfd;
85c5d86d	133	int range;
9260ad98 MO	134
	135	switch (id) {
	136	case TPS65912_REG_DCDC1:
85c5d86d AL	137	range = tps65912_reg_read(mfd, TPS65912_DCDC1_LIMIT);
85c5d86d AL	138	break;
9260ad98	139	case TPS65912_REG_DCDC2:
85c5d86d AL	140	range = tps65912_reg_read(mfd, TPS65912_DCDC2_LIMIT);
85c5d86d AL	141	break;
9260ad98	142	case TPS65912_REG_DCDC3:
85c5d86d AL	143	range = tps65912_reg_read(mfd, TPS65912_DCDC3_LIMIT);
85c5d86d AL	144	break;
9260ad98	145	case TPS65912_REG_DCDC4:
85c5d86d AL	146	range = tps65912_reg_read(mfd, TPS65912_DCDC4_LIMIT);
85c5d86d AL	147	break;
9260ad98 MO	148	default:
	149	return 0;
	150	}
85c5d86d AL	151
	152	if (range >= 0)
	153	range = (range & DCDC_LIMIT_RANGE_MASK)
	154	>> DCDC_LIMIT_RANGE_SHIFT;
	155
	156	pmic->dcdc_range[id] = range;
	157	return range;
9260ad98 MO	158	}
	159
	160	static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
	161	{
	162	unsigned long uv;
	163
	164	uv = ((vsel * 12500) + 500000);
	165	return uv;
	166	}
	167
	168	static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
	169	{
	170	unsigned long uv;
	171
	172	uv = ((vsel * 12500) + 700000);
	173	return uv;
	174	}
	175
	176	static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
	177	{
	178	unsigned long uv;
	179
	180	uv = ((vsel * 25000) + 500000);
	181	return uv;
	182	}
	183
	184	static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
	185	{
	186	unsigned long uv;
	187
	188	if (vsel == 0x3f)
	189	uv = 3800000;
	190	else
	191	uv = ((vsel * 50000) + 500000);
	192
	193	return uv;
	194	}
	195
9260ad98 MO	196	static int tps65912_get_ctrl_register(int id)
9260ad98 MO	197	{
42b5efe4 AL	198	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4)
	199	return id * 3 + TPS65912_DCDC1_AVS;
	200	else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10)
	201	return id - TPS65912_REG_LDO5 + TPS65912_LDO5;
	202	else
9260ad98	203	return -EINVAL;
9260ad98 MO	204	}
9260ad98 MO	205
42b5efe4	206	static int tps65912_get_sel_register(struct tps65912_reg *pmic, int id)
9260ad98 MO	207	{
9260ad98 MO	208	struct tps65912 *mfd = pmic->mfd;
42b5efe4	209	int opvsel;
9260ad98 MO	210	u8 reg = 0;
9260ad98 MO	211
42b5efe4 AL	212	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4) {
	213	opvsel = tps65912_reg_read(mfd, id * 3 + TPS65912_DCDC1_OP);
	214	if (opvsel & OP_SELREG_MASK)
	215	reg = id * 3 + TPS65912_DCDC1_AVS;
9260ad98	216	else
42b5efe4 AL	217	reg = id * 3 + TPS65912_DCDC1_OP;
	218	} else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10) {
	219	reg = id - TPS65912_REG_LDO5 + TPS65912_LDO5;
	220	} else {
9260ad98	221	return -EINVAL;
9260ad98 MO	222	}
	223
	224	return reg;
	225	}
	226
	227	static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
	228	{
	229	switch (id) {
	230	case TPS65912_REG_DCDC1:
	231	pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
	232	pmic->eco_reg = TPS65912_DCDC1_AVS;
	233	break;
	234	case TPS65912_REG_DCDC2:
	235	pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
	236	pmic->eco_reg = TPS65912_DCDC2_AVS;
	237	break;
	238	case TPS65912_REG_DCDC3:
	239	pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
	240	pmic->eco_reg = TPS65912_DCDC3_AVS;
	241	break;
	242	case TPS65912_REG_DCDC4:
	243	pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
	244	pmic->eco_reg = TPS65912_DCDC4_AVS;
	245	break;
	246	default:
	247	return -EINVAL;
	248	}
	249
	250	return 0;
	251	}
	252
	253	static int tps65912_reg_is_enabled(struct regulator_dev *dev)
	254	{
	255	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	256	struct tps65912 *mfd = pmic->mfd;
	257	int reg, value, id = rdev_get_id(dev);
	258
	259	if (id < TPS65912_REG_DCDC1 \|\| id > TPS65912_REG_LDO10)
	260	return -EINVAL;
	261
	262	reg = pmic->get_ctrl_reg(id);
	263	if (reg < 0)
	264	return reg;
	265
	266	value = tps65912_reg_read(mfd, reg);
	267	if (value < 0)
	268	return value;
	269
	270	return value & TPS65912_REG_ENABLED;
	271	}
	272
	273	static int tps65912_reg_enable(struct regulator_dev *dev)
	274	{
	275	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	276	struct tps65912 *mfd = pmic->mfd;
	277	int id = rdev_get_id(dev);
6daa663d	278	int reg;
9260ad98 MO	279
	280	if (id < TPS65912_REG_DCDC1 \|\| id > TPS65912_REG_LDO10)
	281	return -EINVAL;
	282
	283	reg = pmic->get_ctrl_reg(id);
	284	if (reg < 0)
	285	return reg;
	286
	287	return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
	288	}
	289
	290	static int tps65912_reg_disable(struct regulator_dev *dev)
	291	{
	292	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	293	struct tps65912 *mfd = pmic->mfd;
	294	int id = rdev_get_id(dev), reg;
	295
	296	reg = pmic->get_ctrl_reg(id);
	297	if (reg < 0)
	298	return reg;
	299
	300	return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
	301	}
	302
	303	static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
	304	{
	305	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	306	struct tps65912 *mfd = pmic->mfd;
	307	int pwm_mode, eco, id = rdev_get_id(dev);
	308
	309	tps65912_get_mode_regiters(pmic, id);
	310
	311	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
	312	eco = tps65912_reg_read(mfd, pmic->eco_reg);
	313
	314	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
	315	eco &= DCDC_AVS_ECO_MASK;
	316
	317	switch (mode) {
	318	case REGULATOR_MODE_FAST:
	319	/* Verify if mode alredy set */
	320	if (pwm_mode && !eco)
	321	break;
	322	tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
	323	tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
	324	break;
	325	case REGULATOR_MODE_NORMAL:
	326	case REGULATOR_MODE_IDLE:
	327	if (!pwm_mode && !eco)
	328	break;
	329	tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
	330	tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
	331	break;
	332	case REGULATOR_MODE_STANDBY:
	333	if (!pwm_mode && eco)
	334	break;
	335	tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
	336	tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
	337	break;
	338	default:
	339	return -EINVAL;
	340	}
	341
	342	return 0;
343	}
344
345	static unsigned int tps65912_get_mode(struct regulator_dev *dev)
346	{
347	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
348	struct tps65912 *mfd = pmic->mfd;
349	int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
350
351	tps65912_get_mode_regiters(pmic, id);
352
353	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
354	eco = tps65912_reg_read(mfd, pmic->eco_reg);
355
356	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
357	eco &= DCDC_AVS_ECO_MASK;
358
359	if (pwm_mode && !eco)
360	mode = REGULATOR_MODE_FAST;
361	else if (!pwm_mode && !eco)
362	mode = REGULATOR_MODE_NORMAL;
363	else if (!pwm_mode && eco)
364	mode = REGULATOR_MODE_STANDBY;
365
366	return mode;
367	}
368
f72d643e	369	static int tps65912_list_voltage(struct regulator_dev *dev, unsigned selector)
9260ad98 MO	370	{
9260ad98 MO	371	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
844775ef	372	int range, voltage = 0, id = rdev_get_id(dev);
9260ad98	373
85c5d86d	374	if (id > TPS65912_REG_DCDC4)
9260ad98	375	return -EINVAL;
85c5d86d AL	376
85c5d86d AL	377	range = pmic->dcdc_range[id];
9260ad98	378
9260ad98 MO	379	switch (range) {
	380	case 0:
	381	/* 0.5 - 1.2875V in 12.5mV steps */
844775ef	382	voltage = tps65912_vsel_to_uv_range0(selector);
9260ad98 MO	383	break;
	384	case 1:
	385	/* 0.7 - 1.4875V in 12.5mV steps */
844775ef	386	voltage = tps65912_vsel_to_uv_range1(selector);
9260ad98 MO	387	break;
	388	case 2:
	389	/* 0.5 - 2.075V in 25mV steps */
844775ef	390	voltage = tps65912_vsel_to_uv_range2(selector);
9260ad98 MO	391	break;
	392	case 3:
	393	/* 0.5 - 3.8V in 50mV steps */
844775ef	394	voltage = tps65912_vsel_to_uv_range3(selector);
9260ad98 MO	395	break;
	396	}
	397	return voltage;
	398	}
	399
9db7f056	400	static int tps65912_get_voltage_sel(struct regulator_dev *dev)
844775ef AL	401	{
	402	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	403	struct tps65912 *mfd = pmic->mfd;
	404	int id = rdev_get_id(dev);
c567556e	405	int reg, vsel;
844775ef	406
c567556e AL	407	reg = tps65912_get_sel_register(pmic, id);
	408	if (reg < 0)
	409	return reg;
844775ef	410
c567556e	411	vsel = tps65912_reg_read(mfd, reg);
844775ef AL	412	vsel &= 0x3F;
844775ef AL	413
9db7f056	414	return vsel;
844775ef AL	415	}
844775ef AL	416
831c986f	417	static int tps65912_set_voltage_sel(struct regulator_dev *dev,
94732b97	418	unsigned selector)
9260ad98 MO	419	{
	420	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
	421	struct tps65912 *mfd = pmic->mfd;
	422	int id = rdev_get_id(dev);
	423	int value;
	424	u8 reg;
	425
42b5efe4	426	reg = tps65912_get_sel_register(pmic, id);
9260ad98 MO	427	value = tps65912_reg_read(mfd, reg);
	428	value &= 0xC0;
	429	return tps65912_reg_write(mfd, reg, selector \| value);
	430	}
	431
9260ad98 MO	432	/* Operations permitted on DCDCx */
	433	static struct regulator_ops tps65912_ops_dcdc = {
	434	.is_enabled = tps65912_reg_is_enabled,
	435	.enable = tps65912_reg_enable,
	436	.disable = tps65912_reg_disable,
	437	.set_mode = tps65912_set_mode,
	438	.get_mode = tps65912_get_mode,
9db7f056	439	.get_voltage_sel = tps65912_get_voltage_sel,
831c986f	440	.set_voltage_sel = tps65912_set_voltage_sel,
f72d643e	441	.list_voltage = tps65912_list_voltage,
9260ad98 MO	442	};
	443
	444	/* Operations permitted on LDOx */
	445	static struct regulator_ops tps65912_ops_ldo = {
	446	.is_enabled = tps65912_reg_is_enabled,
	447	.enable = tps65912_reg_enable,
	448	.disable = tps65912_reg_disable,
9db7f056	449	.get_voltage_sel = tps65912_get_voltage_sel,
831c986f	450	.set_voltage_sel = tps65912_set_voltage_sel,
fba6583b AL	451	.list_voltage = regulator_list_voltage_linear_range,
fba6583b AL	452	.map_voltage = regulator_map_voltage_linear_range,
9260ad98 MO	453	};
9260ad98 MO	454
a5023574	455	static int tps65912_probe(struct platform_device *pdev)
9260ad98 MO	456	{
9260ad98 MO	457	struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
c172708d	458	struct regulator_config config = { };
9260ad98 MO	459	struct tps_info *info;
	460	struct regulator_init_data *reg_data;
	461	struct regulator_dev *rdev;
	462	struct tps65912_reg *pmic;
	463	struct tps65912_board *pmic_plat_data;
	464	int i, err;
	465
	466	pmic_plat_data = dev_get_platdata(tps65912->dev);
	467	if (!pmic_plat_data)
	468	return -EINVAL;
	469
	470	reg_data = pmic_plat_data->tps65912_pmic_init_data;
	471
9eb0c421	472	pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
9260ad98 MO	473	if (!pmic)
	474	return -ENOMEM;
	475
	476	mutex_init(&pmic->io_lock);
	477	pmic->mfd = tps65912;
	478	platform_set_drvdata(pdev, pmic);
	479
	480	pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
	481	info = tps65912_regs;
	482
	483	for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
	484	int range = 0;
	485	/* Register the regulators */
	486	pmic->info[i] = info;
	487
	488	pmic->desc[i].name = info->name;
	489	pmic->desc[i].id = i;
	490	pmic->desc[i].n_voltages = 64;
fba6583b AL	491	if (i > TPS65912_REG_DCDC4) {
	492	pmic->desc[i].ops = &tps65912_ops_ldo;
	493	pmic->desc[i].linear_ranges = tps65912_ldo_ranges;
	494	pmic->desc[i].n_linear_ranges =
	495	ARRAY_SIZE(tps65912_ldo_ranges);
	496	} else {
	497	pmic->desc[i].ops = &tps65912_ops_dcdc;
	498	}
9260ad98 MO	499	pmic->desc[i].type = REGULATOR_VOLTAGE;
	500	pmic->desc[i].owner = THIS_MODULE;
	501	range = tps65912_get_range(pmic, i);
c172708d MB	502
	503	config.dev = tps65912->dev;
	504	config.init_data = reg_data;
	505	config.driver_data = pmic;
	506
	507	rdev = regulator_register(&pmic->desc[i], &config);
9260ad98 MO	508	if (IS_ERR(rdev)) {
	509	dev_err(tps65912->dev,
	510	"failed to register %s regulator\n",
	511	pdev->name);
	512	err = PTR_ERR(rdev);
	513	goto err;
	514	}
	515
	516	/* Save regulator for cleanup */
	517	pmic->rdev[i] = rdev;
	518	}
	519	return 0;
	520
	521	err:
	522	while (--i >= 0)
	523	regulator_unregister(pmic->rdev[i]);
9260ad98 MO	524	return err;
	525	}
	526
8dc995f5	527	static int tps65912_remove(struct platform_device *pdev)
9260ad98 MO	528	{
	529	struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
	530	int i;
	531
	532	for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
	533	regulator_unregister(tps65912_reg->rdev[i]);
9260ad98 MO	534	return 0;
	535	}
	536
	537	static struct platform_driver tps65912_driver = {
	538	.driver = {
	539	.name = "tps65912-pmic",
	540	.owner = THIS_MODULE,
	541	},
	542	.probe = tps65912_probe,
5eb9f2b9	543	.remove = tps65912_remove,
9260ad98 MO	544	};
9260ad98 MO	545
9260ad98 MO	546	static int __init tps65912_init(void)
	547	{
	548	return platform_driver_register(&tps65912_driver);
	549	}
	550	subsys_initcall(tps65912_init);
	551
9260ad98 MO	552	static void __exit tps65912_cleanup(void)
	553	{
	554	platform_driver_unregister(&tps65912_driver);
	555	}
	556	module_exit(tps65912_cleanup);
	557
	558	MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
	559	MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
	560	MODULE_LICENSE("GPL v2");
	561	MODULE_ALIAS("platform:tps65912-pmic");