[mirror_ubuntu-zesty-kernel.git] / drivers / regulator / tps65023-regulator.c

/*
 * tps65023-regulator.c
 *
 * Supports TPS65023 Regulator
 *
 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
 *
 * 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 version 2.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
 * whether express or implied; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#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/i2c.h>
#include <linux/slab.h>
#include <linux/regmap.h>

/* Register definitions */
#define	TPS65023_REG_VERSION		0
#define	TPS65023_REG_PGOODZ		1
#define	TPS65023_REG_MASK		2
#define	TPS65023_REG_REG_CTRL		3
#define	TPS65023_REG_CON_CTRL		4
#define	TPS65023_REG_CON_CTRL2		5
#define	TPS65023_REG_DEF_CORE		6
#define	TPS65023_REG_DEFSLEW		7
#define	TPS65023_REG_LDO_CTRL		8

/* PGOODZ bitfields */
#define	TPS65023_PGOODZ_PWRFAILZ	BIT(7)
#define	TPS65023_PGOODZ_LOWBATTZ	BIT(6)
#define	TPS65023_PGOODZ_VDCDC1		BIT(5)
#define	TPS65023_PGOODZ_VDCDC2		BIT(4)
#define	TPS65023_PGOODZ_VDCDC3		BIT(3)
#define	TPS65023_PGOODZ_LDO2		BIT(2)
#define	TPS65023_PGOODZ_LDO1		BIT(1)

/* MASK bitfields */
#define	TPS65023_MASK_PWRFAILZ		BIT(7)
#define	TPS65023_MASK_LOWBATTZ		BIT(6)
#define	TPS65023_MASK_VDCDC1		BIT(5)
#define	TPS65023_MASK_VDCDC2		BIT(4)
#define	TPS65023_MASK_VDCDC3		BIT(3)
#define	TPS65023_MASK_LDO2		BIT(2)
#define	TPS65023_MASK_LDO1		BIT(1)

/* REG_CTRL bitfields */
#define TPS65023_REG_CTRL_VDCDC1_EN	BIT(5)
#define TPS65023_REG_CTRL_VDCDC2_EN	BIT(4)
#define TPS65023_REG_CTRL_VDCDC3_EN	BIT(3)
#define TPS65023_REG_CTRL_LDO2_EN	BIT(2)
#define TPS65023_REG_CTRL_LDO1_EN	BIT(1)

/* REG_CTRL2 bitfields */
#define TPS65023_REG_CTRL2_GO		BIT(7)
#define TPS65023_REG_CTRL2_CORE_ADJ	BIT(6)
#define TPS65023_REG_CTRL2_DCDC2	BIT(2)
#define TPS65023_REG_CTRL2_DCDC1	BIT(1)
#define TPS65023_REG_CTRL2_DCDC3	BIT(0)

/* Number of step-down converters available */
#define TPS65023_NUM_DCDC		3
/* Number of LDO voltage regulators  available */
#define TPS65023_NUM_LDO		2
/* Number of total regulators available */
#define TPS65023_NUM_REGULATOR	(TPS65023_NUM_DCDC + TPS65023_NUM_LDO)

/* DCDCs */
#define TPS65023_DCDC_1			0
#define TPS65023_DCDC_2			1
#define TPS65023_DCDC_3			2
/* LDOs */
#define TPS65023_LDO_1			3
#define TPS65023_LDO_2			4

#define TPS65023_MAX_REG_ID		TPS65023_LDO_2

#define TPS65023_REGULATOR_DCDC(_num, _t, _em)			\
	{							\
		.name		= "VDCDC"#_num,			\
		.of_match	= of_match_ptr("VDCDC"#_num),	\
		.regulators_node = of_match_ptr("regulators"),	\
		.id		= TPS65023_DCDC_##_num,		\
		.n_voltages     = ARRAY_SIZE(_t),		\
		.ops		= &tps65023_dcdc_ops,		\
		.type		= REGULATOR_VOLTAGE,		\
		.owner		= THIS_MODULE,			\
		.volt_table	= _t,				\
		.vsel_reg	= TPS65023_REG_DEF_CORE,	\
		.vsel_mask	= ARRAY_SIZE(_t) - 1,		\
		.enable_mask	= _em,				\
		.enable_reg	= TPS65023_REG_REG_CTRL,	\
		.apply_reg	= TPS65023_REG_CON_CTRL2,	\
		.apply_bit	= TPS65023_REG_CTRL2_GO,	\
	}							\

#define TPS65023_REGULATOR_LDO(_num, _t, _vm)			\
	{							\
		.name		= "LDO"#_num,			\
		.of_match	= of_match_ptr("LDO"#_num),	\
		.regulators_node = of_match_ptr("regulators"),	\
		.id		= TPS65023_LDO_##_num,		\
		.n_voltages     = ARRAY_SIZE(_t),		\
		.ops		= &tps65023_ldo_ops,		\
		.type		= REGULATOR_VOLTAGE,		\
		.owner		= THIS_MODULE,			\
		.volt_table	= _t,				\
		.vsel_reg	= TPS65023_REG_LDO_CTRL,	\
		.vsel_mask	= _vm,				\
		.enable_mask	= 1 << (_num),			\
		.enable_reg	= TPS65023_REG_REG_CTRL,	\
	}							\

/* Supported voltage values for regulators */
static const unsigned int VCORE_VSEL_table[] = {
	800000, 825000, 850000, 875000,
	900000, 925000, 950000, 975000,
	1000000, 1025000, 1050000, 1075000,
	1100000, 1125000, 1150000, 1175000,
	1200000, 1225000, 1250000, 1275000,
	1300000, 1325000, 1350000, 1375000,
	1400000, 1425000, 1450000, 1475000,
	1500000, 1525000, 1550000, 1600000,
};

static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
	3300000,
};

static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
	1800000,
};

/* Supported voltage values for LDO regulators for tps65020 */
static const unsigned int TPS65020_LDO_VSEL_table[] = {
	1000000, 1050000, 1100000, 1300000,
	1800000, 2500000, 3000000, 3300000,
};

/* Supported voltage values for LDO regulators
 * for tps65021 and tps65023 */
static const unsigned int TPS65023_LDO1_VSEL_table[] = {
	1000000, 1100000, 1300000, 1800000,
	2200000, 2600000, 2800000, 3150000,
};

static const unsigned int TPS65023_LDO2_VSEL_table[] = {
	1050000, 1200000, 1300000, 1800000,
	2500000, 2800000, 3000000, 3300000,
};

/* PMIC details */
struct tps_pmic {
	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
	const struct tps_driver_data *driver_data;
	struct regmap *regmap;
};

/* Struct passed as driver data */
struct tps_driver_data {
	const struct regulator_desc *desc;
	u8 core_regulator;
};

static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);

	if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
		return -EINVAL;

	if (dcdc != tps->driver_data->core_regulator)
		return 0;

	return regulator_get_voltage_sel_regmap(dev);
}

static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
					 unsigned selector)
{
	struct tps_pmic *tps = rdev_get_drvdata(dev);
	int dcdc = rdev_get_id(dev);

	if (dcdc != tps->driver_data->core_regulator)
		return -EINVAL;

	return regulator_set_voltage_sel_regmap(dev, selector);
}

/* Operations permitted on VDCDCx */
static const struct regulator_ops tps65023_dcdc_ops = {
	.is_enabled = regulator_is_enabled_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.get_voltage_sel = tps65023_dcdc_get_voltage_sel,
	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
	.list_voltage = regulator_list_voltage_table,
	.map_voltage = regulator_map_voltage_ascend,
};

/* Operations permitted on LDOx */
static const struct regulator_ops tps65023_ldo_ops = {
	.is_enabled = regulator_is_enabled_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.list_voltage = regulator_list_voltage_table,
	.map_voltage = regulator_map_voltage_ascend,
};

static const struct regmap_config tps65023_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};

static const struct regulator_desc tps65020_regulators[] = {
	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
	TPS65023_REGULATOR_LDO(1, TPS65020_LDO_VSEL_table, 0x07),
	TPS65023_REGULATOR_LDO(2, TPS65020_LDO_VSEL_table, 0x70),
};

static const struct regulator_desc tps65021_regulators[] = {
	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
};

static const struct regulator_desc tps65023_regulators[] = {
	TPS65023_REGULATOR_DCDC(1, VCORE_VSEL_table, 0x20),
	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_3300000_VSEL_table, 0x10),
	TPS65023_REGULATOR_DCDC(3, DCDC_FIXED_1800000_VSEL_table, 0x08),
	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
};

static struct tps_driver_data tps65020_drv_data = {
	.desc = tps65020_regulators,
	.core_regulator = TPS65023_DCDC_3,
};

static struct tps_driver_data tps65021_drv_data = {
	.desc = tps65021_regulators,
	.core_regulator = TPS65023_DCDC_3,
};

static struct tps_driver_data tps65023_drv_data = {
	.desc = tps65023_regulators,
	.core_regulator = TPS65023_DCDC_1,
};

static int tps_65023_probe(struct i2c_client *client,
				     const struct i2c_device_id *id)
{
	struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
	struct regulator_config config = { };
	struct tps_pmic *tps;
	int i;
	int error;

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

	tps->driver_data = (struct tps_driver_data *)id->driver_data;

	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
	if (IS_ERR(tps->regmap)) {
		error = PTR_ERR(tps->regmap);
		dev_err(&client->dev, "Failed to allocate register map: %d\n",
			error);
		return error;
	}

	/* common for all regulators */
	config.dev = &client->dev;
	config.driver_data = tps;
	config.regmap = tps->regmap;

	for (i = 0; i < TPS65023_NUM_REGULATOR; i++) {
		if (init_data)
			config.init_data = &init_data[i];

		/* Register the regulators */
		tps->rdev[i] = devm_regulator_register(&client->dev,
					&tps->driver_data->desc[i], &config);
		if (IS_ERR(tps->rdev[i])) {
			dev_err(&client->dev, "failed to register %s\n",
				id->name);
			return PTR_ERR(tps->rdev[i]);
		}
	}

	i2c_set_clientdata(client, tps);

	/* Enable setting output voltage by I2C */
	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
					TPS65023_REG_CTRL2_CORE_ADJ,
					TPS65023_REG_CTRL2_CORE_ADJ);

	return 0;
}

static const struct of_device_id tps65023_of_match[] = {
	{ .compatible = "ti,tps65020", .data = &tps65020_drv_data},
	{ .compatible = "ti,tps65021", .data = &tps65021_drv_data},
	{ .compatible = "ti,tps65023", .data = &tps65023_drv_data},
	{},
};
MODULE_DEVICE_TABLE(of, tps65023_of_match);

static const struct i2c_device_id tps_65023_id[] = {
	{
		.name = "tps65023",
		.driver_data = (kernel_ulong_t)&tps65023_drv_data
	}, {
		.name = "tps65021",
		.driver_data = (kernel_ulong_t)&tps65021_drv_data
	}, {
		.name = "tps65020",
		.driver_data = (kernel_ulong_t)&tps65020_drv_data
	},
	{ },
};
MODULE_DEVICE_TABLE(i2c, tps_65023_id);

static struct i2c_driver tps_65023_i2c_driver = {
	.driver = {
		.name = "tps65023",
		.of_match_table = of_match_ptr(tps65023_of_match),
	},
	.probe = tps_65023_probe,
	.id_table = tps_65023_id,
};

static int __init tps_65023_init(void)
{
	return i2c_add_driver(&tps_65023_i2c_driver);
}
subsys_initcall(tps_65023_init);

static void __exit tps_65023_cleanup(void)
{
	i2c_del_driver(&tps_65023_i2c_driver);
}
module_exit(tps_65023_cleanup);

MODULE_AUTHOR("Texas Instruments");
MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
30e6599d AA	1	/*
	2	* tps65023-regulator.c
	3	*
	4	* Supports TPS65023 Regulator
	5	*
	6	* Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation version 2.
	11	*
	12	* This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
	13	* whether express or implied; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/init.h>
	21	#include <linux/err.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/regulator/driver.h>
	24	#include <linux/regulator/machine.h>
	25	#include <linux/i2c.h>
5a0e3ad6	26	#include <linux/slab.h>
90923351	27	#include <linux/regmap.h>
30e6599d AA	28
	29	/* Register definitions */
	30	#define TPS65023_REG_VERSION 0
	31	#define TPS65023_REG_PGOODZ 1
	32	#define TPS65023_REG_MASK 2
	33	#define TPS65023_REG_REG_CTRL 3
	34	#define TPS65023_REG_CON_CTRL 4
	35	#define TPS65023_REG_CON_CTRL2 5
	36	#define TPS65023_REG_DEF_CORE 6
	37	#define TPS65023_REG_DEFSLEW 7
	38	#define TPS65023_REG_LDO_CTRL 8
	39
	40	/* PGOODZ bitfields */
	41	#define TPS65023_PGOODZ_PWRFAILZ BIT(7)
	42	#define TPS65023_PGOODZ_LOWBATTZ BIT(6)
	43	#define TPS65023_PGOODZ_VDCDC1 BIT(5)
	44	#define TPS65023_PGOODZ_VDCDC2 BIT(4)
	45	#define TPS65023_PGOODZ_VDCDC3 BIT(3)
	46	#define TPS65023_PGOODZ_LDO2 BIT(2)
	47	#define TPS65023_PGOODZ_LDO1 BIT(1)
	48
	49	/* MASK bitfields */
	50	#define TPS65023_MASK_PWRFAILZ BIT(7)
	51	#define TPS65023_MASK_LOWBATTZ BIT(6)
	52	#define TPS65023_MASK_VDCDC1 BIT(5)
	53	#define TPS65023_MASK_VDCDC2 BIT(4)
	54	#define TPS65023_MASK_VDCDC3 BIT(3)
	55	#define TPS65023_MASK_LDO2 BIT(2)
	56	#define TPS65023_MASK_LDO1 BIT(1)
	57
	58	/* REG_CTRL bitfields */
	59	#define TPS65023_REG_CTRL_VDCDC1_EN BIT(5)
	60	#define TPS65023_REG_CTRL_VDCDC2_EN BIT(4)
	61	#define TPS65023_REG_CTRL_VDCDC3_EN BIT(3)
	62	#define TPS65023_REG_CTRL_LDO2_EN BIT(2)
	63	#define TPS65023_REG_CTRL_LDO1_EN BIT(1)
	64
f068ad8c MF	65	/* REG_CTRL2 bitfields */
	66	#define TPS65023_REG_CTRL2_GO BIT(7)
	67	#define TPS65023_REG_CTRL2_CORE_ADJ BIT(6)
	68	#define TPS65023_REG_CTRL2_DCDC2 BIT(2)
	69	#define TPS65023_REG_CTRL2_DCDC1 BIT(1)
	70	#define TPS65023_REG_CTRL2_DCDC3 BIT(0)
	71
30e6599d AA	72	/* Number of step-down converters available */
	73	#define TPS65023_NUM_DCDC 3
	74	/* Number of LDO voltage regulators available */
	75	#define TPS65023_NUM_LDO 2
	76	/* Number of total regulators available */
	77	#define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
	78
	79	/* DCDCs */
	80	#define TPS65023_DCDC_1 0
	81	#define TPS65023_DCDC_2 1
	82	#define TPS65023_DCDC_3 2
	83	/* LDOs */
	84	#define TPS65023_LDO_1 3
	85	#define TPS65023_LDO_2 4
	86
	87	#define TPS65023_MAX_REG_ID TPS65023_LDO_2
	88
2d3eda67 TE	89	#define TPS65023_REGULATOR_DCDC(_num, _t, _em) \
	90	{ \
	91	.name = "VDCDC"#_num, \
	92	.of_match = of_match_ptr("VDCDC"#_num), \
	93	.regulators_node = of_match_ptr("regulators"), \
	94	.id = TPS65023_DCDC_##_num, \
	95	.n_voltages = ARRAY_SIZE(_t), \
	96	.ops = &tps65023_dcdc_ops, \
	97	.type = REGULATOR_VOLTAGE, \
	98	.owner = THIS_MODULE, \
	99	.volt_table = _t, \
	100	.vsel_reg = TPS65023_REG_DEF_CORE, \
	101	.vsel_mask = ARRAY_SIZE(_t) - 1, \
	102	.enable_mask = _em, \
	103	.enable_reg = TPS65023_REG_REG_CTRL, \
	104	.apply_reg = TPS65023_REG_CON_CTRL2, \
	105	.apply_bit = TPS65023_REG_CTRL2_GO, \
	106	} \
	107
	108	#define TPS65023_REGULATOR_LDO(_num, _t, _vm) \
	109	{ \
	110	.name = "LDO"#_num, \
	111	.of_match = of_match_ptr("LDO"#_num), \
	112	.regulators_node = of_match_ptr("regulators"), \
	113	.id = TPS65023_LDO_##_num, \
	114	.n_voltages = ARRAY_SIZE(_t), \
	115	.ops = &tps65023_ldo_ops, \
	116	.type = REGULATOR_VOLTAGE, \
	117	.owner = THIS_MODULE, \
	118	.volt_table = _t, \
	119	.vsel_reg = TPS65023_REG_LDO_CTRL, \
	120	.vsel_mask = _vm, \
	121	.enable_mask = 1 << (_num), \
	122	.enable_reg = TPS65023_REG_REG_CTRL, \
	123	} \
	124
30e6599d	125	/* Supported voltage values for regulators */
ba3bd8a3 AL	126	static const unsigned int VCORE_VSEL_table[] = {
	127	800000, 825000, 850000, 875000,
	128	900000, 925000, 950000, 975000,
	129	1000000, 1025000, 1050000, 1075000,
	130	1100000, 1125000, 1150000, 1175000,
	131	1200000, 1225000, 1250000, 1275000,
	132	1300000, 1325000, 1350000, 1375000,
	133	1400000, 1425000, 1450000, 1475000,
	134	1500000, 1525000, 1550000, 1600000,
	135	};
	136
	137	static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
	138	3300000,
	139	};
	140
	141	static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
	142	1800000,
30e6599d AA	143	};
30e6599d AA	144
437afd2a	145	/* Supported voltage values for LDO regulators for tps65020 */
2040541a	146	static const unsigned int TPS65020_LDO_VSEL_table[] = {
ba3bd8a3 AL	147	1000000, 1050000, 1100000, 1300000,
ba3bd8a3 AL	148	1800000, 2500000, 3000000, 3300000,
437afd2a	149	};
1c3ede05 MF	150
	151	/* Supported voltage values for LDO regulators
	152	* for tps65021 and tps65023 */
ba3bd8a3 AL	153	static const unsigned int TPS65023_LDO1_VSEL_table[] = {
	154	1000000, 1100000, 1300000, 1800000,
	155	2200000, 2600000, 2800000, 3150000,
30e6599d AA	156	};
30e6599d AA	157
ba3bd8a3 AL	158	static const unsigned int TPS65023_LDO2_VSEL_table[] = {
	159	1050000, 1200000, 1300000, 1800000,
	160	2500000, 2800000, 3000000, 3300000,
30e6599d AA	161	};
30e6599d AA	162
30e6599d AA	163	/* PMIC details */
30e6599d AA	164	struct tps_pmic {
30e6599d	165	struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
2d3eda67	166	const struct tps_driver_data *driver_data;
90923351	167	struct regmap *regmap;
1c3ede05 MF	168	};
	169
	170	/* Struct passed as driver data */
	171	struct tps_driver_data {
2d3eda67	172	const struct regulator_desc *desc;
1c3ede05	173	u8 core_regulator;
30e6599d AA	174	};
30e6599d AA	175
a133829e	176	static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
30e6599d AA	177	{
30e6599d AA	178	struct tps_pmic *tps = rdev_get_drvdata(dev);
46bcb006	179	int dcdc = rdev_get_id(dev);
30e6599d AA	180
	181	if (dcdc < TPS65023_DCDC_1 \|\| dcdc > TPS65023_DCDC_3)
	182	return -EINVAL;
	183
2d3eda67	184	if (dcdc != tps->driver_data->core_regulator)
a133829e	185	return 0;
46bcb006 AL	186
46bcb006 AL	187	return regulator_get_voltage_sel_regmap(dev);
30e6599d AA	188	}
30e6599d AA	189
7061873f AL	190	static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
7061873f AL	191	unsigned selector)
30e6599d AA	192	{
	193	struct tps_pmic *tps = rdev_get_drvdata(dev);
	194	int dcdc = rdev_get_id(dev);
30e6599d	195
2d3eda67	196	if (dcdc != tps->driver_data->core_regulator)
30e6599d	197	return -EINVAL;
30e6599d	198
46bcb006	199	return regulator_set_voltage_sel_regmap(dev, selector);
30e6599d AA	200	}
30e6599d AA	201
30e6599d	202	/* Operations permitted on VDCDCx */
4604a061	203	static const struct regulator_ops tps65023_dcdc_ops = {
ee7b1914 AL	204	.is_enabled = regulator_is_enabled_regmap,
	205	.enable = regulator_enable_regmap,
	206	.disable = regulator_disable_regmap,
a133829e	207	.get_voltage_sel = tps65023_dcdc_get_voltage_sel,
7061873f	208	.set_voltage_sel = tps65023_dcdc_set_voltage_sel,
ba3bd8a3	209	.list_voltage = regulator_list_voltage_table,
c4bbfbd5	210	.map_voltage = regulator_map_voltage_ascend,
30e6599d AA	211	};
	212
	213	/* Operations permitted on LDOx */
4604a061	214	static const struct regulator_ops tps65023_ldo_ops = {
ee7b1914 AL	215	.is_enabled = regulator_is_enabled_regmap,
	216	.enable = regulator_enable_regmap,
	217	.disable = regulator_disable_regmap,
e90a8447 AL	218	.get_voltage_sel = regulator_get_voltage_sel_regmap,
e90a8447 AL	219	.set_voltage_sel = regulator_set_voltage_sel_regmap,
ba3bd8a3	220	.list_voltage = regulator_list_voltage_table,
c4bbfbd5	221	.map_voltage = regulator_map_voltage_ascend,
30e6599d AA	222	};
30e6599d AA	223
4604a061	224	static const struct regmap_config tps65023_regmap_config = {
90923351 MB	225	.reg_bits = 8,
	226	.val_bits = 8,
	227	};
	228
2d3eda67 TE	229	static const struct regulator_desc tps65020_regulators[] = {
	230	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
	231	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
	232	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
	233	TPS65023_REGULATOR_LDO(1, TPS65020_LDO_VSEL_table, 0x07),
	234	TPS65023_REGULATOR_LDO(2, TPS65020_LDO_VSEL_table, 0x70),
	235	};
	236
	237	static const struct regulator_desc tps65021_regulators[] = {
	238	TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
	239	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
	240	TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
	241	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
	242	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
	243	};
	244
	245	static const struct regulator_desc tps65023_regulators[] = {
	246	TPS65023_REGULATOR_DCDC(1, VCORE_VSEL_table, 0x20),
	247	TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_3300000_VSEL_table, 0x10),
	248	TPS65023_REGULATOR_DCDC(3, DCDC_FIXED_1800000_VSEL_table, 0x08),
	249	TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
	250	TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
	251	};
	252
	253	static struct tps_driver_data tps65020_drv_data = {
	254	.desc = tps65020_regulators,
	255	.core_regulator = TPS65023_DCDC_3,
	256	};
	257
	258	static struct tps_driver_data tps65021_drv_data = {
	259	.desc = tps65021_regulators,
	260	.core_regulator = TPS65023_DCDC_3,
	261	};
	262
	263	static struct tps_driver_data tps65023_drv_data = {
	264	.desc = tps65023_regulators,
	265	.core_regulator = TPS65023_DCDC_1,
	266	};
	267
a5023574	268	static int tps_65023_probe(struct i2c_client *client,
54d13ab1	269	const struct i2c_device_id *id)
30e6599d	270	{
2d3eda67	271	struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
c172708d	272	struct regulator_config config = { };
30e6599d AA	273	struct tps_pmic *tps;
30e6599d AA	274	int i;
54d13ab1	275	int error;
30e6599d	276
19a8da21	277	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
30e6599d AA	278	if (!tps)
	279	return -ENOMEM;
	280
2d3eda67 TE	281	tps->driver_data = (struct tps_driver_data *)id->driver_data;
2d3eda67 TE	282
19a8da21	283	tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
90923351 MB	284	if (IS_ERR(tps->regmap)) {
	285	error = PTR_ERR(tps->regmap);
	286	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	287	error);
19a8da21	288	return error;
90923351	289	}
30e6599d AA	290
30e6599d AA	291	/* common for all regulators */
2d3eda67 TE	292	config.dev = &client->dev;
	293	config.driver_data = tps;
	294	config.regmap = tps->regmap;
ee7b1914	295
2d3eda67 TE	296	for (i = 0; i < TPS65023_NUM_REGULATOR; i++) {
	297	if (init_data)
	298	config.init_data = &init_data[i];
c172708d	299
30e6599d	300	/* Register the regulators */
2d3eda67 TE	301	tps->rdev[i] = devm_regulator_register(&client->dev,
	302	&tps->driver_data->desc[i], &config);
	303	if (IS_ERR(tps->rdev[i])) {
30e6599d AA	304	dev_err(&client->dev, "failed to register %s\n",
30e6599d AA	305	id->name);
2d3eda67	306	return PTR_ERR(tps->rdev[i]);
30e6599d	307	}
30e6599d AA	308	}
	309
	310	i2c_set_clientdata(client, tps);
	311
fc999b83	312	/* Enable setting output voltage by I2C */
43530b69	313	regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
5ee034e6 JH	314	TPS65023_REG_CTRL2_CORE_ADJ,
5ee034e6 JH	315	TPS65023_REG_CTRL2_CORE_ADJ);
fc999b83	316
30e6599d	317	return 0;
30e6599d AA	318	}
30e6599d AA	319
2d3eda67 TE	320	static const struct of_device_id tps65023_of_match[] = {
	321	{ .compatible = "ti,tps65020", .data = &tps65020_drv_data},
	322	{ .compatible = "ti,tps65021", .data = &tps65021_drv_data},
	323	{ .compatible = "ti,tps65023", .data = &tps65023_drv_data},
	324	{},
1c3ede05	325	};
2d3eda67	326	MODULE_DEVICE_TABLE(of, tps65023_of_match);
1c3ede05	327
2d3eda67	328	static const struct i2c_device_id tps_65023_id[] = {
30e6599d	329	{
2d3eda67 TE	330	.name = "tps65023",
	331	.driver_data = (kernel_ulong_t)&tps65023_drv_data
	332	}, {
	333	.name = "tps65021",
	334	.driver_data = (kernel_ulong_t)&tps65021_drv_data
	335	}, {
	336	.name = "tps65020",
	337	.driver_data = (kernel_ulong_t)&tps65020_drv_data
30e6599d	338	},
9e108d33	339	{ },
30e6599d	340	};
30e6599d AA	341	MODULE_DEVICE_TABLE(i2c, tps_65023_id);
	342
	343	static struct i2c_driver tps_65023_i2c_driver = {
	344	.driver = {
	345	.name = "tps65023",
2d3eda67	346	.of_match_table = of_match_ptr(tps65023_of_match),
30e6599d AA	347	},
30e6599d AA	348	.probe = tps_65023_probe,
9e108d33	349	.id_table = tps_65023_id,
30e6599d AA	350	};
30e6599d AA	351
30e6599d AA	352	static int __init tps_65023_init(void)
	353	{
	354	return i2c_add_driver(&tps_65023_i2c_driver);
	355	}
	356	subsys_initcall(tps_65023_init);
	357
30e6599d AA	358	static void __exit tps_65023_cleanup(void)
	359	{
	360	i2c_del_driver(&tps_65023_i2c_driver);
	361	}
	362	module_exit(tps_65023_cleanup);
	363
	364	MODULE_AUTHOR("Texas Instruments");
	365	MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
9e108d33	366	MODULE_LICENSE("GPL v2");