[mirror_ubuntu-artful-kernel.git] / drivers / mfd / tps65090.c

/*
 * Core driver for TI TPS65090 PMIC family
 *
 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.

 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.

 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/mfd/core.h>
#include <linux/mfd/tps65090.h>
#include <linux/regmap.h>
#include <linux/err.h>

#define NUM_INT_REG 2
#define TOTAL_NUM_REG 0x18

/* interrupt status registers */
#define TPS65090_INT_STS	0x0
#define TPS65090_INT_STS2	0x1

/* interrupt mask registers */
#define TPS65090_INT_MSK	0x2
#define TPS65090_INT_MSK2	0x3

struct tps65090_irq_data {
	u8		mask_reg;
	u8		mask_pos;
};

#define TPS65090_IRQ(_reg, _mask_pos)		\
	{					\
		.mask_reg	= (_reg),	\
		.mask_pos	= (_mask_pos),	\
	}

static const struct tps65090_irq_data tps65090_irqs[] = {
	[0]		= TPS65090_IRQ(0, 0),
	[1]		= TPS65090_IRQ(0, 1),
	[2]		= TPS65090_IRQ(0, 2),
	[3]		= TPS65090_IRQ(0, 3),
	[4]		= TPS65090_IRQ(0, 4),
	[5]		= TPS65090_IRQ(0, 5),
	[6]		= TPS65090_IRQ(0, 6),
	[7]		= TPS65090_IRQ(0, 7),
	[8]		= TPS65090_IRQ(1, 0),
	[9]		= TPS65090_IRQ(1, 1),
	[10]		= TPS65090_IRQ(1, 2),
	[11]		= TPS65090_IRQ(1, 3),
	[12]		= TPS65090_IRQ(1, 4),
	[13]		= TPS65090_IRQ(1, 5),
	[14]		= TPS65090_IRQ(1, 6),
	[15]		= TPS65090_IRQ(1, 7),
};

static struct mfd_cell tps65090s[] = {
	{
		.name = "tps65910-pmic",
	},
	{
		.name = "tps65910-regulator",
	},
};

struct tps65090 {
	struct mutex		lock;
	struct device		*dev;
	struct i2c_client	*client;
	struct regmap		*rmap;
	struct irq_chip		irq_chip;
	struct mutex		irq_lock;
	int			irq_base;
	unsigned int		id;
};

int tps65090_write(struct device *dev, int reg, uint8_t val)
{
	struct tps65090 *tps = dev_get_drvdata(dev);
	return regmap_write(tps->rmap, reg, val);
}
EXPORT_SYMBOL_GPL(tps65090_write);

int tps65090_read(struct device *dev, int reg, uint8_t *val)
{
	struct tps65090 *tps = dev_get_drvdata(dev);
	unsigned int temp_val;
	int ret;
	ret = regmap_read(tps->rmap, reg, &temp_val);
	if (!ret)
		*val = temp_val;
	return ret;
}
EXPORT_SYMBOL_GPL(tps65090_read);

int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num)
{
	struct tps65090 *tps = dev_get_drvdata(dev);
	return regmap_update_bits(tps->rmap, reg, BIT(bit_num), ~0u);
}
EXPORT_SYMBOL_GPL(tps65090_set_bits);

int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num)
{
	struct tps65090 *tps = dev_get_drvdata(dev);
	return regmap_update_bits(tps->rmap, reg, BIT(bit_num), 0u);
}
EXPORT_SYMBOL_GPL(tps65090_clr_bits);

static void tps65090_irq_lock(struct irq_data *data)
{
	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);

	mutex_lock(&tps65090->irq_lock);
}

static void tps65090_irq_mask(struct irq_data *irq_data)
{
	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
	unsigned int __irq = irq_data->hwirq;
	const struct tps65090_irq_data *data = &tps65090_irqs[__irq];

	tps65090_set_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
		data->mask_pos);
}

static void tps65090_irq_unmask(struct irq_data *irq_data)
{
	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
	unsigned int __irq = irq_data->irq - tps65090->irq_base;
	const struct tps65090_irq_data *data = &tps65090_irqs[__irq];

	tps65090_clr_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
		data->mask_pos);
}

static void tps65090_irq_sync_unlock(struct irq_data *data)
{
	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);

	mutex_unlock(&tps65090->irq_lock);
}

static irqreturn_t tps65090_irq(int irq, void *data)
{
	struct tps65090 *tps65090 = data;
	int ret = 0;
	u8 status, mask;
	unsigned long int acks = 0;
	int i;

	for (i = 0; i < NUM_INT_REG; i++) {
		ret = tps65090_read(tps65090->dev, TPS65090_INT_MSK + i, &mask);
		if (ret < 0) {
			dev_err(tps65090->dev,
				"failed to read mask reg [addr:%d]\n",
				TPS65090_INT_MSK + i);
			return IRQ_NONE;
		}
		ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + i,
			&status);
		if (ret < 0) {
			dev_err(tps65090->dev,
				"failed to read status reg [addr:%d]\n",
				 TPS65090_INT_STS + i);
			return IRQ_NONE;
		}
		if (status) {
			/* Ack only those interrupts which are not masked */
			status &= (~mask);
			ret = tps65090_write(tps65090->dev,
					TPS65090_INT_STS + i, status);
			if (ret < 0) {
				dev_err(tps65090->dev,
					"failed to write interrupt status\n");
				return IRQ_NONE;
			}
			acks |= (status << (i * 8));
		}
	}

	for_each_set_bit(i, &acks, ARRAY_SIZE(tps65090_irqs))
		handle_nested_irq(tps65090->irq_base + i);
	return acks ? IRQ_HANDLED : IRQ_NONE;
}

static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq,
	int irq_base)
{
	int i, ret;

	if (!irq_base) {
		dev_err(tps65090->dev, "IRQ base not set\n");
		return -EINVAL;
	}

	mutex_init(&tps65090->irq_lock);

	for (i = 0; i < NUM_INT_REG; i++)
		tps65090_write(tps65090->dev, TPS65090_INT_MSK + i, 0xFF);

	for (i = 0; i < NUM_INT_REG; i++)
		tps65090_write(tps65090->dev, TPS65090_INT_STS + i, 0xff);

	tps65090->irq_base = irq_base;
	tps65090->irq_chip.name = "tps65090";
	tps65090->irq_chip.irq_mask = tps65090_irq_mask;
	tps65090->irq_chip.irq_unmask = tps65090_irq_unmask;
	tps65090->irq_chip.irq_bus_lock = tps65090_irq_lock;
	tps65090->irq_chip.irq_bus_sync_unlock = tps65090_irq_sync_unlock;

	for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) {
		int __irq = i + tps65090->irq_base;
		irq_set_chip_data(__irq, tps65090);
		irq_set_chip_and_handler(__irq, &tps65090->irq_chip,
					 handle_simple_irq);
		irq_set_nested_thread(__irq, 1);
#ifdef CONFIG_ARM
		set_irq_flags(__irq, IRQF_VALID);
#endif
	}

	ret = request_threaded_irq(irq, NULL, tps65090_irq, IRQF_ONESHOT,
				"tps65090", tps65090);
	if (!ret) {
		device_init_wakeup(tps65090->dev, 1);
		enable_irq_wake(irq);
	}

	return ret;
}

static bool is_volatile_reg(struct device *dev, unsigned int reg)
{
	if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS))
		return true;
	else
		return false;
}

static const struct regmap_config tps65090_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = TOTAL_NUM_REG,
	.num_reg_defaults_raw = TOTAL_NUM_REG,
	.cache_type = REGCACHE_RBTREE,
	.volatile_reg = is_volatile_reg,
};

static int __devinit tps65090_i2c_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct tps65090_platform_data *pdata = client->dev.platform_data;
	struct tps65090 *tps65090;
	int ret;

	if (!pdata) {
		dev_err(&client->dev, "tps65090 requires platform data\n");
		return -EINVAL;
	}

	tps65090 = devm_kzalloc(&client->dev, sizeof(struct tps65090),
		GFP_KERNEL);
	if (tps65090 == NULL)
		return -ENOMEM;

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

	mutex_init(&tps65090->lock);

	if (client->irq) {
		ret = tps65090_irq_init(tps65090, client->irq, pdata->irq_base);
		if (ret) {
			dev_err(&client->dev, "IRQ init failed with err: %d\n",
				ret);
			goto err_exit;
		}
	}

	tps65090->rmap = regmap_init_i2c(tps65090->client,
		&tps65090_regmap_config);
	if (IS_ERR(tps65090->rmap)) {
		dev_err(&client->dev, "regmap_init failed with err: %ld\n",
			PTR_ERR(tps65090->rmap));
		goto err_irq_exit;
	};

	ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
		ARRAY_SIZE(tps65090s), NULL, 0);
	if (ret) {
		dev_err(&client->dev, "add mfd devices failed with err: %d\n",
			ret);
		goto err_regmap_exit;
	}

	return 0;

err_regmap_exit:
	regmap_exit(tps65090->rmap);

err_irq_exit:
	if (client->irq)
		free_irq(client->irq, tps65090);
err_exit:
	return ret;
}

static int __devexit tps65090_i2c_remove(struct i2c_client *client)
{
	struct tps65090 *tps65090 = i2c_get_clientdata(client);

	mfd_remove_devices(tps65090->dev);
	regmap_exit(tps65090->rmap);
	if (client->irq)
		free_irq(client->irq, tps65090);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int tps65090_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	if (client->irq)
		disable_irq(client->irq);
	return 0;
}

static int tps65090_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	if (client->irq)
		enable_irq(client->irq);
	return 0;
}
#endif

static const struct dev_pm_ops tps65090_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(tps65090_suspend, tps65090_resume)
};

static const struct i2c_device_id tps65090_id_table[] = {
	{ "tps65090", 0 },
	{ },
};
MODULE_DEVICE_TABLE(i2c, tps65090_id_table);

static struct i2c_driver tps65090_driver = {
	.driver	= {
		.name	= "tps65090",
		.owner	= THIS_MODULE,
		.pm	= &tps65090_pm_ops,
	},
	.probe		= tps65090_i2c_probe,
	.remove		= __devexit_p(tps65090_i2c_remove),
	.id_table	= tps65090_id_table,
};

static int __init tps65090_init(void)
{
	return i2c_add_driver(&tps65090_driver);
}
subsys_initcall(tps65090_init);

static void __exit tps65090_exit(void)
{
	i2c_del_driver(&tps65090_driver);
}
module_exit(tps65090_exit);

MODULE_DESCRIPTION("TPS65090 core driver");
MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
3c33be06 VB	1	/*
	2	* Core driver for TI TPS65090 PMIC family
	3	*
	4	* Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
	5
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms and conditions of the GNU General Public License,
	8	* version 2, as published by the Free Software Foundation.
	9
	10	* This program is distributed in the hope it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <linux/interrupt.h>
	20	#include <linux/irq.h>
	21	#include <linux/kernel.h>
	22	#include <linux/module.h>
	23	#include <linux/mutex.h>
	24	#include <linux/slab.h>
	25	#include <linux/i2c.h>
	26	#include <linux/mfd/core.h>
	27	#include <linux/mfd/tps65090.h>
	28	#include <linux/regmap.h>
	29	#include <linux/err.h>
	30
	31	#define NUM_INT_REG 2
	32	#define TOTAL_NUM_REG 0x18
	33
	34	/* interrupt status registers */
	35	#define TPS65090_INT_STS 0x0
	36	#define TPS65090_INT_STS2 0x1
	37
	38	/* interrupt mask registers */
	39	#define TPS65090_INT_MSK 0x2
	40	#define TPS65090_INT_MSK2 0x3
	41
	42	struct tps65090_irq_data {
	43	u8 mask_reg;
	44	u8 mask_pos;
	45	};
	46
	47	#define TPS65090_IRQ(_reg, _mask_pos) \
	48	{ \
	49	.mask_reg = (_reg), \
	50	.mask_pos = (_mask_pos), \
	51	}
	52
	53	static const struct tps65090_irq_data tps65090_irqs[] = {
	54	[0] = TPS65090_IRQ(0, 0),
	55	[1] = TPS65090_IRQ(0, 1),
	56	[2] = TPS65090_IRQ(0, 2),
	57	[3] = TPS65090_IRQ(0, 3),
	58	[4] = TPS65090_IRQ(0, 4),
	59	[5] = TPS65090_IRQ(0, 5),
	60	[6] = TPS65090_IRQ(0, 6),
	61	[7] = TPS65090_IRQ(0, 7),
	62	[8] = TPS65090_IRQ(1, 0),
	63	[9] = TPS65090_IRQ(1, 1),
	64	[10] = TPS65090_IRQ(1, 2),
65	[11] = TPS65090_IRQ(1, 3),
66	[12] = TPS65090_IRQ(1, 4),
67	[13] = TPS65090_IRQ(1, 5),
68	[14] = TPS65090_IRQ(1, 6),
69	[15] = TPS65090_IRQ(1, 7),
70	};
71
72	static struct mfd_cell tps65090s[] = {
73	{
74	.name = "tps65910-pmic",
75	},
76	{
77	.name = "tps65910-regulator",
78	},
79	};
80
81	struct tps65090 {
82	struct mutex lock;
83	struct device *dev;
84	struct i2c_client *client;
85	struct regmap *rmap;
86	struct irq_chip irq_chip;
87	struct mutex irq_lock;
88	int irq_base;
89	unsigned int id;
90	};
91
92	int tps65090_write(struct device *dev, int reg, uint8_t val)
93	{
94	struct tps65090 *tps = dev_get_drvdata(dev);
95	return regmap_write(tps->rmap, reg, val);
96	}
97	EXPORT_SYMBOL_GPL(tps65090_write);
98
99	int tps65090_read(struct device dev, int reg, uint8_t val)
100	{
101	struct tps65090 *tps = dev_get_drvdata(dev);
102	unsigned int temp_val;
103	int ret;
104	ret = regmap_read(tps->rmap, reg, &temp_val);
105	if (!ret)
106	*val = temp_val;
107	return ret;
108	}
109	EXPORT_SYMBOL_GPL(tps65090_read);
110
111	int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num)
112	{
113	struct tps65090 *tps = dev_get_drvdata(dev);
114	return regmap_update_bits(tps->rmap, reg, BIT(bit_num), ~0u);
115	}
116	EXPORT_SYMBOL_GPL(tps65090_set_bits);
117
118	int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num)
119	{
120	struct tps65090 *tps = dev_get_drvdata(dev);
121	return regmap_update_bits(tps->rmap, reg, BIT(bit_num), 0u);
122	}
123	EXPORT_SYMBOL_GPL(tps65090_clr_bits);
124
125	static void tps65090_irq_lock(struct irq_data *data)
126	{
127	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
128
129	mutex_lock(&tps65090->irq_lock);
130	}
131
132	static void tps65090_irq_mask(struct irq_data *irq_data)
133	{
134	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
135	unsigned int __irq = irq_data->hwirq;
136	const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
137
138	tps65090_set_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
139	data->mask_pos);
140	}
141
142	static void tps65090_irq_unmask(struct irq_data *irq_data)
143	{
144	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data);
145	unsigned int __irq = irq_data->irq - tps65090->irq_base;
146	const struct tps65090_irq_data *data = &tps65090_irqs[__irq];
147
148	tps65090_clr_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg),
149	data->mask_pos);
150	}
151
152	static void tps65090_irq_sync_unlock(struct irq_data *data)
153	{
154	struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data);
155
156	mutex_unlock(&tps65090->irq_lock);
157	}
158
159	static irqreturn_t tps65090_irq(int irq, void *data)
160	{
161	struct tps65090 *tps65090 = data;
162	int ret = 0;
163	u8 status, mask;
164	unsigned long int acks = 0;
165	int i;
166
167	for (i = 0; i < NUM_INT_REG; i++) {
168	ret = tps65090_read(tps65090->dev, TPS65090_INT_MSK + i, &mask);
169	if (ret < 0) {
170	dev_err(tps65090->dev,
171	"failed to read mask reg [addr:%d]\n",
172	TPS65090_INT_MSK + i);
173	return IRQ_NONE;
174	}
175	ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + i,
176	&status);
177	if (ret < 0) {
178	dev_err(tps65090->dev,
179	"failed to read status reg [addr:%d]\n",
180	TPS65090_INT_STS + i);
181	return IRQ_NONE;
182	}
183	if (status) {
184	/* Ack only those interrupts which are not masked */
185	status &= (~mask);
186	ret = tps65090_write(tps65090->dev,
187	TPS65090_INT_STS + i, status);
188	if (ret < 0) {
189	dev_err(tps65090->dev,
190	"failed to write interrupt status\n");
191	return IRQ_NONE;
192	}
193	acks \|= (status << (i * 8));
194	}
195	}
196
197	for_each_set_bit(i, &acks, ARRAY_SIZE(tps65090_irqs))
198	handle_nested_irq(tps65090->irq_base + i);
199	return acks ? IRQ_HANDLED : IRQ_NONE;
200	}
201
202	static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq,
203	int irq_base)
204	{
205	int i, ret;
206
207	if (!irq_base) {
208	dev_err(tps65090->dev, "IRQ base not set\n");
209	return -EINVAL;
210	}
211
212	mutex_init(&tps65090->irq_lock);
213
214	for (i = 0; i < NUM_INT_REG; i++)
215	tps65090_write(tps65090->dev, TPS65090_INT_MSK + i, 0xFF);
216
217	for (i = 0; i < NUM_INT_REG; i++)
218	tps65090_write(tps65090->dev, TPS65090_INT_STS + i, 0xff);
219
220	tps65090->irq_base = irq_base;
221	tps65090->irq_chip.name = "tps65090";
222	tps65090->irq_chip.irq_mask = tps65090_irq_mask;
223	tps65090->irq_chip.irq_unmask = tps65090_irq_unmask;
224	tps65090->irq_chip.irq_bus_lock = tps65090_irq_lock;
225	tps65090->irq_chip.irq_bus_sync_unlock = tps65090_irq_sync_unlock;
226
227	for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) {
228	int __irq = i + tps65090->irq_base;
229	irq_set_chip_data(__irq, tps65090);
230	irq_set_chip_and_handler(__irq, &tps65090->irq_chip,
231	handle_simple_irq);
232	irq_set_nested_thread(__irq, 1);
233	#ifdef CONFIG_ARM
234	set_irq_flags(__irq, IRQF_VALID);
235	#endif
236	}
237
238	ret = request_threaded_irq(irq, NULL, tps65090_irq, IRQF_ONESHOT,
239	"tps65090", tps65090);
240	if (!ret) {
241	device_init_wakeup(tps65090->dev, 1);
242	enable_irq_wake(irq);
243	}
244
245	return ret;
246	}
247
248	static bool is_volatile_reg(struct device *dev, unsigned int reg)
249	{
250	if ((reg == TPS65090_INT_STS) \|\| (reg == TPS65090_INT_STS))
251	return true;
252	else
253	return false;
254	}
255
256	static const struct regmap_config tps65090_regmap_config = {
257	.reg_bits = 8,
258	.val_bits = 8,
259	.max_register = TOTAL_NUM_REG,
260	.num_reg_defaults_raw = TOTAL_NUM_REG,
261	.cache_type = REGCACHE_RBTREE,
262	.volatile_reg = is_volatile_reg,
263	};
264
265	static int __devinit tps65090_i2c_probe(struct i2c_client *client,
266	const struct i2c_device_id *id)
267	{
268	struct tps65090_platform_data *pdata = client->dev.platform_data;
269	struct tps65090 *tps65090;
270	int ret;
271
272	if (!pdata) {
273	dev_err(&client->dev, "tps65090 requires platform data\n");
274	return -EINVAL;
275	}
276
277	tps65090 = devm_kzalloc(&client->dev, sizeof(struct tps65090),
278	GFP_KERNEL);
279	if (tps65090 == NULL)
280	return -ENOMEM;
281
282	tps65090->client = client;
283	tps65090->dev = &client->dev;
284	i2c_set_clientdata(client, tps65090);
285
286	mutex_init(&tps65090->lock);
287
288	if (client->irq) {
289	ret = tps65090_irq_init(tps65090, client->irq, pdata->irq_base);
290	if (ret) {
291	dev_err(&client->dev, "IRQ init failed with err: %d\n",
292	ret);
293	goto err_exit;
294	}
295	}
296
297	tps65090->rmap = regmap_init_i2c(tps65090->client,
298	&tps65090_regmap_config);
299	if (IS_ERR(tps65090->rmap)) {
300	dev_err(&client->dev, "regmap_init failed with err: %ld\n",
301	PTR_ERR(tps65090->rmap));
302	goto err_irq_exit;
303	};
304
305	ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
306	ARRAY_SIZE(tps65090s), NULL, 0);
307	if (ret) {
308	dev_err(&client->dev, "add mfd devices failed with err: %d\n",
309	ret);
310	goto err_regmap_exit;
311	}
312
313	return 0;
314
315	err_regmap_exit:
316	regmap_exit(tps65090->rmap);
317
318	err_irq_exit:
319	if (client->irq)
320	free_irq(client->irq, tps65090);
321	err_exit:
322	return ret;
323	}
324
325	static int __devexit tps65090_i2c_remove(struct i2c_client *client)
326	{
327	struct tps65090 *tps65090 = i2c_get_clientdata(client);
328
329	mfd_remove_devices(tps65090->dev);
330	regmap_exit(tps65090->rmap);
331	if (client->irq)
332	free_irq(client->irq, tps65090);
333
334	return 0;
335	}
336
1ca5513a	337	#ifdef CONFIG_PM_SLEEP
b6c9eeef	338	static int tps65090_suspend(struct device *dev)
3c33be06	339	{
b6c9eeef	340	struct i2c_client *client = to_i2c_client(dev);
3c33be06 VB	341	if (client->irq)
	342	disable_irq(client->irq);
	343	return 0;
	344	}
	345
b6c9eeef	346	static int tps65090_resume(struct device *dev)
3c33be06	347	{
b6c9eeef	348	struct i2c_client *client = to_i2c_client(dev);
3c33be06 VB	349	if (client->irq)
	350	enable_irq(client->irq);
	351	return 0;
	352	}
	353	#endif
	354
b6c9eeef MB	355	static const struct dev_pm_ops tps65090_pm_ops = {
	356	SET_SYSTEM_SLEEP_PM_OPS(tps65090_suspend, tps65090_resume)
	357	};
	358
3c33be06 VB	359	static const struct i2c_device_id tps65090_id_table[] = {
	360	{ "tps65090", 0 },
	361	{ },
	362	};
	363	MODULE_DEVICE_TABLE(i2c, tps65090_id_table);
	364
	365	static struct i2c_driver tps65090_driver = {
	366	.driver = {
	367	.name = "tps65090",
	368	.owner = THIS_MODULE,
b6c9eeef	369	.pm = &tps65090_pm_ops,
3c33be06 VB	370	},
	371	.probe = tps65090_i2c_probe,
	372	.remove = __devexit_p(tps65090_i2c_remove),
3c33be06 VB	373	.id_table = tps65090_id_table,
	374	};
	375
	376	static int __init tps65090_init(void)
	377	{
	378	return i2c_add_driver(&tps65090_driver);
	379	}
	380	subsys_initcall(tps65090_init);
	381
	382	static void __exit tps65090_exit(void)
	383	{
	384	i2c_del_driver(&tps65090_driver);
	385	}
	386	module_exit(tps65090_exit);
	387
	388	MODULE_DESCRIPTION("TPS65090 core driver");
	389	MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
	390	MODULE_LICENSE("GPL v2");