[mirror_ubuntu-zesty-kernel.git] / drivers / mfd / tps65217.c

/*
 * tps65217.c
 *
 * TPS65217 chip family multi-function driver
 *
 * Copyright (C) 2011 Texas Instruments 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/device.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/regmap.h>
#include <linux/err.h>

#include <linux/mfd/core.h>
#include <linux/mfd/tps65217.h>

/**
 * tps65217_reg_read: Read a single tps65217 register.
 *
 * @tps: Device to read from.
 * @reg: Register to read.
 * @val: Contians the value
 */
int tps65217_reg_read(struct tps65217 *tps, unsigned int reg,
			unsigned int *val)
{
	return regmap_read(tps->regmap, reg, val);
}
EXPORT_SYMBOL_GPL(tps65217_reg_read);

/**
 * tps65217_reg_write: Write a single tps65217 register.
 *
 * @tps65217: Device to write to.
 * @reg: Register to write to.
 * @val: Value to write.
 * @level: Password protected level
 */
int tps65217_reg_write(struct tps65217 *tps, unsigned int reg,
			unsigned int val, unsigned int level)
{
	int ret;
	unsigned int xor_reg_val;

	switch (level) {
	case TPS65217_PROTECT_NONE:
		return regmap_write(tps->regmap, reg, val);
	case TPS65217_PROTECT_L1:
		xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
		ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
							xor_reg_val);
		if (ret < 0)
			return ret;

		return regmap_write(tps->regmap, reg, val);
	case TPS65217_PROTECT_L2:
		xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
		ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
							xor_reg_val);
		if (ret < 0)
			return ret;
		ret = regmap_write(tps->regmap, reg, val);
		if (ret < 0)
			return ret;
		ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
							xor_reg_val);
		if (ret < 0)
			return ret;
		return regmap_write(tps->regmap, reg, val);
	default:
		return -EINVAL;
	}
}
EXPORT_SYMBOL_GPL(tps65217_reg_write);

/**
 * tps65217_update_bits: Modify bits w.r.t mask, val and level.
 *
 * @tps65217: Device to write to.
 * @reg: Register to read-write to.
 * @mask: Mask.
 * @val: Value to write.
 * @level: Password protected level
 */
static int tps65217_update_bits(struct tps65217 *tps, unsigned int reg,
		unsigned int mask, unsigned int val, unsigned int level)
{
	int ret;
	unsigned int data;

	ret = tps65217_reg_read(tps, reg, &data);
	if (ret) {
		dev_err(tps->dev, "Read from reg 0x%x failed\n", reg);
		return ret;
	}

	data &= ~mask;
	data |= val & mask;

	ret = tps65217_reg_write(tps, reg, data, level);
	if (ret)
		dev_err(tps->dev, "Write for reg 0x%x failed\n", reg);

	return ret;
}

int tps65217_set_bits(struct tps65217 *tps, unsigned int reg,
		unsigned int mask, unsigned int val, unsigned int level)
{
	return tps65217_update_bits(tps, reg, mask, val, level);
}
EXPORT_SYMBOL_GPL(tps65217_set_bits);

int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
		unsigned int mask, unsigned int level)
{
	return tps65217_update_bits(tps, reg, mask, 0, level);
}
EXPORT_SYMBOL_GPL(tps65217_clear_bits);

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

static int __devinit tps65217_probe(struct i2c_client *client,
				const struct i2c_device_id *ids)
{
	struct tps65217 *tps;
	struct tps65217_board *pdata = client->dev.platform_data;
	int i, ret;
	unsigned int version;

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

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

	i2c_set_clientdata(client, tps);
	tps->dev = &client->dev;

	ret = tps65217_reg_read(tps, TPS65217_REG_CHIPID, &version);
	if (ret < 0) {
		dev_err(tps->dev, "Failed to read revision register: %d\n",
			ret);
		return ret;
	}

	dev_info(tps->dev, "TPS65217 ID %#x version 1.%d\n",
			(version & TPS65217_CHIPID_CHIP_MASK) >> 4,
			version & TPS65217_CHIPID_REV_MASK);

	for (i = 0; i < TPS65217_NUM_REGULATOR; i++) {
		struct platform_device *pdev;

		pdev = platform_device_alloc("tps65217-pmic", i);
		if (!pdev) {
			dev_err(tps->dev, "Cannot create regulator %d\n", i);
			continue;
		}

		pdev->dev.parent = tps->dev;
		platform_device_add_data(pdev, &pdata->tps65217_init_data[i],
					sizeof(pdata->tps65217_init_data[i]));
		tps->regulator_pdev[i] = pdev;

		platform_device_add(pdev);
	}

	return 0;
}

static int __devexit tps65217_remove(struct i2c_client *client)
{
	struct tps65217 *tps = i2c_get_clientdata(client);
	int i;

	for (i = 0; i < TPS65217_NUM_REGULATOR; i++)
		platform_device_unregister(tps->regulator_pdev[i]);

	return 0;
}

static const struct i2c_device_id tps65217_id_table[] = {
	{"tps65217", 0xF0},
	{/* end of list */}
};
MODULE_DEVICE_TABLE(i2c, tps65217_id_table);

static struct i2c_driver tps65217_driver = {
	.driver		= {
		.name	= "tps65217",
	},
	.id_table	= tps65217_id_table,
	.probe		= tps65217_probe,
	.remove		= __devexit_p(tps65217_remove),
};

static int __init tps65217_init(void)
{
	return i2c_add_driver(&tps65217_driver);
}
subsys_initcall(tps65217_init);

static void __exit tps65217_exit(void)
{
	i2c_del_driver(&tps65217_driver);
}
module_exit(tps65217_exit);

MODULE_AUTHOR("AnilKumar Ch <anilkumar@ti.com>");
MODULE_DESCRIPTION("TPS65217 chip family multi-function driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d48f411c AC	1	/*
	2	* tps65217.c
	3	*
	4	* TPS65217 chip family multi-function driver
	5	*
	6	* Copyright (C) 2011 Texas Instruments 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
	13	* kind, whether express or implied; without even the implied warranty
	14	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*/
	17
	18	#include <linux/kernel.h>
	19	#include <linux/device.h>
	20	#include <linux/module.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/init.h>
	23	#include <linux/i2c.h>
	24	#include <linux/slab.h>
	25	#include <linux/regmap.h>
	26	#include <linux/err.h>
	27
	28	#include <linux/mfd/core.h>
	29	#include <linux/mfd/tps65217.h>
	30
	31	/**
	32	* tps65217_reg_read: Read a single tps65217 register.
	33	*
	34	* @tps: Device to read from.
	35	* @reg: Register to read.
	36	* @val: Contians the value
	37	*/
	38	int tps65217_reg_read(struct tps65217 *tps, unsigned int reg,
	39	unsigned int *val)
	40	{
	41	return regmap_read(tps->regmap, reg, val);
	42	}
	43	EXPORT_SYMBOL_GPL(tps65217_reg_read);
	44
	45	/**
	46	* tps65217_reg_write: Write a single tps65217 register.
	47	*
	48	* @tps65217: Device to write to.
	49	* @reg: Register to write to.
	50	* @val: Value to write.
	51	* @level: Password protected level
	52	*/
	53	int tps65217_reg_write(struct tps65217 *tps, unsigned int reg,
	54	unsigned int val, unsigned int level)
	55	{
	56	int ret;
	57	unsigned int xor_reg_val;
	58
	59	switch (level) {
	60	case TPS65217_PROTECT_NONE:
	61	return regmap_write(tps->regmap, reg, val);
	62	case TPS65217_PROTECT_L1:
	63	xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
	64	ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
65	xor_reg_val);
66	if (ret < 0)
67	return ret;
68
69	return regmap_write(tps->regmap, reg, val);
70	case TPS65217_PROTECT_L2:
71	xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
72	ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
73	xor_reg_val);
74	if (ret < 0)
75	return ret;
76	ret = regmap_write(tps->regmap, reg, val);
77	if (ret < 0)
78	return ret;
79	ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
80	xor_reg_val);
81	if (ret < 0)
82	return ret;
83	return regmap_write(tps->regmap, reg, val);
84	default:
85	return -EINVAL;
86	}
87	}
88	EXPORT_SYMBOL_GPL(tps65217_reg_write);
89
90	/**
91	* tps65217_update_bits: Modify bits w.r.t mask, val and level.
92	*
93	* @tps65217: Device to write to.
94	* @reg: Register to read-write to.
95	* @mask: Mask.
96	* @val: Value to write.
97	* @level: Password protected level
98	*/
27757e82	99	static int tps65217_update_bits(struct tps65217 *tps, unsigned int reg,
d48f411c AC	100	unsigned int mask, unsigned int val, unsigned int level)
	101	{
	102	int ret;
	103	unsigned int data;
	104
	105	ret = tps65217_reg_read(tps, reg, &data);
	106	if (ret) {
	107	dev_err(tps->dev, "Read from reg 0x%x failed\n", reg);
	108	return ret;
	109	}
	110
	111	data &= ~mask;
	112	data \|= val & mask;
	113
	114	ret = tps65217_reg_write(tps, reg, data, level);
	115	if (ret)
	116	dev_err(tps->dev, "Write for reg 0x%x failed\n", reg);
	117
	118	return ret;
	119	}
	120
	121	int tps65217_set_bits(struct tps65217 *tps, unsigned int reg,
	122	unsigned int mask, unsigned int val, unsigned int level)
	123	{
	124	return tps65217_update_bits(tps, reg, mask, val, level);
	125	}
	126	EXPORT_SYMBOL_GPL(tps65217_set_bits);
	127
	128	int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
	129	unsigned int mask, unsigned int level)
	130	{
	131	return tps65217_update_bits(tps, reg, mask, 0, level);
	132	}
	133	EXPORT_SYMBOL_GPL(tps65217_clear_bits);
	134
	135	static struct regmap_config tps65217_regmap_config = {
	136	.reg_bits = 8,
	137	.val_bits = 8,
	138	};
	139
	140	static int __devinit tps65217_probe(struct i2c_client *client,
	141	const struct i2c_device_id *ids)
	142	{
	143	struct tps65217 *tps;
	144	struct tps65217_board *pdata = client->dev.platform_data;
	145	int i, ret;
	146	unsigned int version;
	147
	148	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
	149	if (!tps)
	150	return -ENOMEM;
	151
	152	tps->pdata = pdata;
0ef4619c	153	tps->regmap = devm_regmap_init_i2c(client, &tps65217_regmap_config);
d48f411c AC	154	if (IS_ERR(tps->regmap)) {
	155	ret = PTR_ERR(tps->regmap);
	156	dev_err(tps->dev, "Failed to allocate register map: %d\n",
	157	ret);
	158	return ret;
	159	}
	160
	161	i2c_set_clientdata(client, tps);
	162	tps->dev = &client->dev;
	163
	164	ret = tps65217_reg_read(tps, TPS65217_REG_CHIPID, &version);
	165	if (ret < 0) {
0ef4619c AL	166	dev_err(tps->dev, "Failed to read revision register: %d\n",
	167	ret);
	168	return ret;
d48f411c AC	169	}
	170
	171	dev_info(tps->dev, "TPS65217 ID %#x version 1.%d\n",
	172	(version & TPS65217_CHIPID_CHIP_MASK) >> 4,
	173	version & TPS65217_CHIPID_REV_MASK);
	174
	175	for (i = 0; i < TPS65217_NUM_REGULATOR; i++) {
	176	struct platform_device *pdev;
	177
	178	pdev = platform_device_alloc("tps65217-pmic", i);
	179	if (!pdev) {
	180	dev_err(tps->dev, "Cannot create regulator %d\n", i);
	181	continue;
	182	}
	183
	184	pdev->dev.parent = tps->dev;
	185	platform_device_add_data(pdev, &pdata->tps65217_init_data[i],
	186	sizeof(pdata->tps65217_init_data[i]));
	187	tps->regulator_pdev[i] = pdev;
	188
	189	platform_device_add(pdev);
	190	}
	191
	192	return 0;
d48f411c AC	193	}
	194
	195	static int __devexit tps65217_remove(struct i2c_client *client)
	196	{
	197	struct tps65217 *tps = i2c_get_clientdata(client);
	198	int i;
	199
	200	for (i = 0; i < TPS65217_NUM_REGULATOR; i++)
	201	platform_device_unregister(tps->regulator_pdev[i]);
	202
d48f411c AC	203	return 0;
	204	}
	205
	206	static const struct i2c_device_id tps65217_id_table[] = {
	207	{"tps65217", 0xF0},
	208	{/* end of list */}
	209	};
	210	MODULE_DEVICE_TABLE(i2c, tps65217_id_table);
	211
	212	static struct i2c_driver tps65217_driver = {
	213	.driver = {
	214	.name = "tps65217",
	215	},
	216	.id_table = tps65217_id_table,
	217	.probe = tps65217_probe,
	218	.remove = __devexit_p(tps65217_remove),
	219	};
	220
	221	static int __init tps65217_init(void)
	222	{
	223	return i2c_add_driver(&tps65217_driver);
	224	}
	225	subsys_initcall(tps65217_init);
	226
	227	static void __exit tps65217_exit(void)
	228	{
	229	i2c_del_driver(&tps65217_driver);
	230	}
	231	module_exit(tps65217_exit);
	232
	233	MODULE_AUTHOR("AnilKumar Ch <anilkumar@ti.com>");
	234	MODULE_DESCRIPTION("TPS65217 chip family multi-function driver");
	235	MODULE_LICENSE("GPL v2");