[net-next-2.6.git] / drivers / mfd / adp5520.c

/*
 * Base driver for Analog Devices ADP5520/ADP5501 MFD PMICs
 * LCD Backlight: drivers/video/backlight/adp5520_bl
 * LEDs		: drivers/led/leds-adp5520
 * GPIO		: drivers/gpio/adp5520-gpio (ADP5520 only)
 * Keys		: drivers/input/keyboard/adp5520-keys (ADP5520 only)
 *
 * Copyright 2009 Analog Devices Inc.
 *
 * Derived from da903x:
 * Copyright (C) 2008 Compulab, Ltd.
 * 	Mike Rapoport <mike@compulab.co.il>
 *
 * Copyright (C) 2006-2008 Marvell International Ltd.
 * 	Eric Miao <eric.miao@marvell.com>
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/err.h>
#include <linux/i2c.h>

#include <linux/mfd/adp5520.h>

struct adp5520_chip {
	struct i2c_client *client;
	struct device *dev;
	struct mutex lock;
	struct blocking_notifier_head notifier_list;
	int irq;
	unsigned long id;
};

static int __adp5520_read(struct i2c_client *client,
				int reg, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_read_byte_data(client, reg);
	if (ret < 0) {
		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
		return ret;
	}

	*val = (uint8_t)ret;
	return 0;
}

static int __adp5520_write(struct i2c_client *client,
				 int reg, uint8_t val)
{
	int ret;

	ret = i2c_smbus_write_byte_data(client, reg, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
				val, reg);
		return ret;
	}
	return 0;
}

int __adp5520_ack_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
{
	struct adp5520_chip *chip = i2c_get_clientdata(client);
	uint8_t reg_val;
	int ret;

	mutex_lock(&chip->lock);

	ret = __adp5520_read(client, reg, &reg_val);

	if (!ret) {
		reg_val |= bit_mask;
		ret = __adp5520_write(client, reg, reg_val);
	}

	mutex_unlock(&chip->lock);
	return ret;
}

int adp5520_write(struct device *dev, int reg, uint8_t val)
{
	return __adp5520_write(to_i2c_client(dev), reg, val);
}
EXPORT_SYMBOL_GPL(adp5520_write);

int adp5520_read(struct device *dev, int reg, uint8_t *val)
{
	return __adp5520_read(to_i2c_client(dev), reg, val);
}
EXPORT_SYMBOL_GPL(adp5520_read);

int adp5520_set_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct adp5520_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret;

	mutex_lock(&chip->lock);

	ret = __adp5520_read(chip->client, reg, &reg_val);

	if (!ret && ((reg_val & bit_mask) == 0)) {
		reg_val |= bit_mask;
		ret = __adp5520_write(chip->client, reg, reg_val);
	}

	mutex_unlock(&chip->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(adp5520_set_bits);

int adp5520_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct adp5520_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret;

	mutex_lock(&chip->lock);

	ret = __adp5520_read(chip->client, reg, &reg_val);

	if (!ret && (reg_val & bit_mask)) {
		reg_val &= ~bit_mask;
		ret = __adp5520_write(chip->client, reg, reg_val);
	}

	mutex_unlock(&chip->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(adp5520_clr_bits);

int adp5520_register_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct adp5520_chip *chip = dev_get_drvdata(dev);

	if (chip->irq) {
		adp5520_set_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
			events & (ADP5520_KP_IEN | ADP5520_KR_IEN |
			ADP5520_OVP_IEN | ADP5520_CMPR_IEN));

		return blocking_notifier_chain_register(&chip->notifier_list,
			 nb);
	}

	return -ENODEV;
}
EXPORT_SYMBOL_GPL(adp5520_register_notifier);

int adp5520_unregister_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct adp5520_chip *chip = dev_get_drvdata(dev);

	adp5520_clr_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
		events & (ADP5520_KP_IEN | ADP5520_KR_IEN |
		ADP5520_OVP_IEN | ADP5520_CMPR_IEN));

	return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
EXPORT_SYMBOL_GPL(adp5520_unregister_notifier);

static irqreturn_t adp5520_irq_thread(int irq, void *data)
{
	struct adp5520_chip *chip = data;
	unsigned int events;
	uint8_t reg_val;
	int ret;

	ret = __adp5520_read(chip->client, ADP5520_MODE_STATUS, &reg_val);
	if (ret)
		goto out;

	events =  reg_val & (ADP5520_OVP_INT | ADP5520_CMPR_INT |
		ADP5520_GPI_INT | ADP5520_KR_INT | ADP5520_KP_INT);

	blocking_notifier_call_chain(&chip->notifier_list, events, NULL);
	/* ACK, Sticky bits are W1C */
	__adp5520_ack_bits(chip->client, ADP5520_MODE_STATUS, events);

out:
	return IRQ_HANDLED;
}

static int __remove_subdev(struct device *dev, void *unused)
{
	platform_device_unregister(to_platform_device(dev));
	return 0;
}

static int adp5520_remove_subdevs(struct adp5520_chip *chip)
{
	return device_for_each_child(chip->dev, NULL, __remove_subdev);
}

static int __devinit adp5520_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct adp5520_platform_data *pdata = client->dev.platform_data;
	struct platform_device *pdev;
	struct adp5520_chip *chip;
	int ret;

	if (!i2c_check_functionality(client->adapter,
					I2C_FUNC_SMBUS_BYTE_DATA)) {
		dev_err(&client->dev, "SMBUS Word Data not Supported\n");
		return -EIO;
	}

	if (pdata == NULL) {
		dev_err(&client->dev, "missing platform data\n");
		return -ENODEV;
	}

	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	i2c_set_clientdata(client, chip);
	chip->client = client;

	chip->dev = &client->dev;
	chip->irq = client->irq;
	chip->id = id->driver_data;
	mutex_init(&chip->lock);

	if (chip->irq) {
		BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);

		ret = request_threaded_irq(chip->irq, NULL, adp5520_irq_thread,
				IRQF_TRIGGER_LOW | IRQF_ONESHOT,
				"adp5520", chip);
		if (ret) {
			dev_err(&client->dev, "failed to request irq %d\n",
					chip->irq);
			goto out_free_chip;
		}
	}

	ret = adp5520_write(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
	if (ret) {
		dev_err(&client->dev, "failed to write\n");
		goto out_free_irq;
	}

	if (pdata->keys) {
		pdev = platform_device_register_data(chip->dev, "adp5520-keys",
				chip->id, pdata->keys, sizeof(*pdata->keys));
		if (IS_ERR(pdev)) {
			ret = PTR_ERR(pdev);
			goto out_remove_subdevs;
		}
	}

	if (pdata->gpio) {
		pdev = platform_device_register_data(chip->dev, "adp5520-gpio",
				chip->id, pdata->gpio, sizeof(*pdata->gpio));
		if (IS_ERR(pdev)) {
			ret = PTR_ERR(pdev);
			goto out_remove_subdevs;
		}
	}

	if (pdata->leds) {
		pdev = platform_device_register_data(chip->dev, "adp5520-led",
				chip->id, pdata->leds, sizeof(*pdata->leds));
		if (IS_ERR(pdev)) {
			ret = PTR_ERR(pdev);
			goto out_remove_subdevs;
		}
	}

	if (pdata->backlight) {
		pdev = platform_device_register_data(chip->dev,
						"adp5520-backlight",
						chip->id,
						pdata->backlight,
						sizeof(*pdata->backlight));
		if (IS_ERR(pdev)) {
			ret = PTR_ERR(pdev);
			goto out_remove_subdevs;
		}
	}

	return 0;

out_remove_subdevs:
	adp5520_remove_subdevs(chip);

out_free_irq:
	if (chip->irq)
		free_irq(chip->irq, chip);

out_free_chip:
	i2c_set_clientdata(client, NULL);
	kfree(chip);

	return ret;
}

static int __devexit adp5520_remove(struct i2c_client *client)
{
	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);

	if (chip->irq)
		free_irq(chip->irq, chip);

	adp5520_remove_subdevs(chip);
	adp5520_write(chip->dev, ADP5520_MODE_STATUS, 0);
	i2c_set_clientdata(client, NULL);
	kfree(chip);
	return 0;
}

#ifdef CONFIG_PM
static int adp5520_suspend(struct i2c_client *client,
				 pm_message_t state)
{
	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);

	adp5520_clr_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
	return 0;
}

static int adp5520_resume(struct i2c_client *client)
{
	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);

	adp5520_set_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
	return 0;
}
#else
#define adp5520_suspend	NULL
#define adp5520_resume	NULL
#endif

static const struct i2c_device_id adp5520_id[] = {
	{ "pmic-adp5520", ID_ADP5520 },
	{ "pmic-adp5501", ID_ADP5501 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, adp5520_id);

static struct i2c_driver adp5520_driver = {
	.driver = {
		.name	= "adp5520",
		.owner	= THIS_MODULE,
	},
	.probe		= adp5520_probe,
	.remove		= __devexit_p(adp5520_remove),
	.suspend	= adp5520_suspend,
	.resume		= adp5520_resume,
	.id_table 	= adp5520_id,
};

static int __init adp5520_init(void)
{
	return i2c_add_driver(&adp5520_driver);
}
module_init(adp5520_init);

static void __exit adp5520_exit(void)
{
	i2c_del_driver(&adp5520_driver);
}
module_exit(adp5520_exit);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("ADP5520(01) PMIC-MFD Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
a5736e0b MH	1	/*
	2	* Base driver for Analog Devices ADP5520/ADP5501 MFD PMICs
	3	* LCD Backlight: drivers/video/backlight/adp5520_bl
	4	* LEDs : drivers/led/leds-adp5520
	5	* GPIO : drivers/gpio/adp5520-gpio (ADP5520 only)
	6	* Keys : drivers/input/keyboard/adp5520-keys (ADP5520 only)
	7	*
	8	* Copyright 2009 Analog Devices Inc.
	9	*
	10	* Derived from da903x:
	11	* Copyright (C) 2008 Compulab, Ltd.
	12	* Mike Rapoport <mike@compulab.co.il>
	13	*
	14	* Copyright (C) 2006-2008 Marvell International Ltd.
	15	* Eric Miao <eric.miao@marvell.com>
	16	*
	17	* Licensed under the GPL-2 or later.
	18	*/
	19
	20	#include <linux/kernel.h>
	21	#include <linux/module.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/init.h>
	24	#include <linux/interrupt.h>
	25	#include <linux/irq.h>
	26	#include <linux/err.h>
	27	#include <linux/i2c.h>
	28
	29	#include <linux/mfd/adp5520.h>
	30
	31	struct adp5520_chip {
	32	struct i2c_client *client;
	33	struct device *dev;
	34	struct mutex lock;
	35	struct blocking_notifier_head notifier_list;
	36	int irq;
	37	unsigned long id;
	38	};
	39
	40	static int __adp5520_read(struct i2c_client *client,
	41	int reg, uint8_t *val)
	42	{
	43	int ret;
	44
	45	ret = i2c_smbus_read_byte_data(client, reg);
	46	if (ret < 0) {
	47	dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
	48	return ret;
	49	}
	50
	51	*val = (uint8_t)ret;
	52	return 0;
	53	}
	54
	55	static int __adp5520_write(struct i2c_client *client,
	56	int reg, uint8_t val)
	57	{
	58	int ret;
	59
	60	ret = i2c_smbus_write_byte_data(client, reg, val);
	61	if (ret < 0) {
	62	dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
	63	val, reg);
	64	return ret;
65	}
66	return 0;
67	}
68
69	int __adp5520_ack_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
70	{
71	struct adp5520_chip *chip = i2c_get_clientdata(client);
72	uint8_t reg_val;
73	int ret;
74
75	mutex_lock(&chip->lock);
76
77	ret = __adp5520_read(client, reg, &reg_val);
78
79	if (!ret) {
80	reg_val \|= bit_mask;
81	ret = __adp5520_write(client, reg, reg_val);
82	}
83
84	mutex_unlock(&chip->lock);
85	return ret;
86	}
87
88	int adp5520_write(struct device *dev, int reg, uint8_t val)
89	{
90	return __adp5520_write(to_i2c_client(dev), reg, val);
91	}
92	EXPORT_SYMBOL_GPL(adp5520_write);
93
94	int adp5520_read(struct device dev, int reg, uint8_t val)
95	{
96	return __adp5520_read(to_i2c_client(dev), reg, val);
97	}
98	EXPORT_SYMBOL_GPL(adp5520_read);
99
100	int adp5520_set_bits(struct device *dev, int reg, uint8_t bit_mask)
101	{
102	struct adp5520_chip *chip = dev_get_drvdata(dev);
103	uint8_t reg_val;
104	int ret;
105
106	mutex_lock(&chip->lock);
107
108	ret = __adp5520_read(chip->client, reg, &reg_val);
109
110	if (!ret && ((reg_val & bit_mask) == 0)) {
111	reg_val \|= bit_mask;
112	ret = __adp5520_write(chip->client, reg, reg_val);
113	}
114
115	mutex_unlock(&chip->lock);
116	return ret;
117	}
118	EXPORT_SYMBOL_GPL(adp5520_set_bits);
119
120	int adp5520_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
121	{
122	struct adp5520_chip *chip = dev_get_drvdata(dev);
123	uint8_t reg_val;
124	int ret;
125
126	mutex_lock(&chip->lock);
127
128	ret = __adp5520_read(chip->client, reg, &reg_val);
129
130	if (!ret && (reg_val & bit_mask)) {
131	reg_val &= ~bit_mask;
132	ret = __adp5520_write(chip->client, reg, reg_val);
133	}
134
135	mutex_unlock(&chip->lock);
136	return ret;
137	}
138	EXPORT_SYMBOL_GPL(adp5520_clr_bits);
139
140	int adp5520_register_notifier(struct device dev, struct notifier_block nb,
141	unsigned int events)
142	{
143	struct adp5520_chip *chip = dev_get_drvdata(dev);
144
145	if (chip->irq) {
146	adp5520_set_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
147	events & (ADP5520_KP_IEN \| ADP5520_KR_IEN \|
148	ADP5520_OVP_IEN \| ADP5520_CMPR_IEN));
149
150	return blocking_notifier_chain_register(&chip->notifier_list,
151	nb);
152	}
153
154	return -ENODEV;
155	}
156	EXPORT_SYMBOL_GPL(adp5520_register_notifier);
157
158	int adp5520_unregister_notifier(struct device dev, struct notifier_block nb,
159	unsigned int events)
160	{
161	struct adp5520_chip *chip = dev_get_drvdata(dev);
162
163	adp5520_clr_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
164	events & (ADP5520_KP_IEN \| ADP5520_KR_IEN \|
165	ADP5520_OVP_IEN \| ADP5520_CMPR_IEN));
166
167	return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
168	}
169	EXPORT_SYMBOL_GPL(adp5520_unregister_notifier);
170
171	static irqreturn_t adp5520_irq_thread(int irq, void *data)
172	{
173	struct adp5520_chip *chip = data;
174	unsigned int events;
175	uint8_t reg_val;
176	int ret;
177
178	ret = __adp5520_read(chip->client, ADP5520_MODE_STATUS, &reg_val);
179	if (ret)
180	goto out;
181
182	events = reg_val & (ADP5520_OVP_INT \| ADP5520_CMPR_INT \|
183	ADP5520_GPI_INT \| ADP5520_KR_INT \| ADP5520_KP_INT);
184
185	blocking_notifier_call_chain(&chip->notifier_list, events, NULL);
186	/* ACK, Sticky bits are W1C */
187	__adp5520_ack_bits(chip->client, ADP5520_MODE_STATUS, events);
188
189	out:
190	return IRQ_HANDLED;
191	}
192
193	static int __remove_subdev(struct device dev, void unused)
194	{
195	platform_device_unregister(to_platform_device(dev));
196	return 0;
197	}
198
199	static int adp5520_remove_subdevs(struct adp5520_chip *chip)
200	{
201	return device_for_each_child(chip->dev, NULL, __remove_subdev);
202	}
203
204	static int __devinit adp5520_probe(struct i2c_client *client,
205	const struct i2c_device_id *id)
206	{
207	struct adp5520_platform_data *pdata = client->dev.platform_data;
208	struct platform_device *pdev;
209	struct adp5520_chip *chip;
210	int ret;
211
212	if (!i2c_check_functionality(client->adapter,
213	I2C_FUNC_SMBUS_BYTE_DATA)) {
214	dev_err(&client->dev, "SMBUS Word Data not Supported\n");
215	return -EIO;
216	}
217
218	if (pdata == NULL) {
219	dev_err(&client->dev, "missing platform data\n");
220	return -ENODEV;
221	}
222
223	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
224	if (!chip)
225	return -ENOMEM;
226
227	i2c_set_clientdata(client, chip);
228	chip->client = client;
229
230	chip->dev = &client->dev;
231	chip->irq = client->irq;
232	chip->id = id->driver_data;
233	mutex_init(&chip->lock);
234
235	if (chip->irq) {
236	BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
237
238	ret = request_threaded_irq(chip->irq, NULL, adp5520_irq_thread,
239	IRQF_TRIGGER_LOW \| IRQF_ONESHOT,
240	"adp5520", chip);
241	if (ret) {
242	dev_err(&client->dev, "failed to request irq %d\n",
243	chip->irq);
244	goto out_free_chip;
245	}
246	}
247
248	ret = adp5520_write(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
249	if (ret) {
250	dev_err(&client->dev, "failed to write\n");
251	goto out_free_irq;
252	}
253
254	if (pdata->keys) {
255	pdev = platform_device_register_data(chip->dev, "adp5520-keys",
256	chip->id, pdata->keys, sizeof(*pdata->keys));
257	if (IS_ERR(pdev)) {
258	ret = PTR_ERR(pdev);
259	goto out_remove_subdevs;
260	}
261	}
262
263	if (pdata->gpio) {
264	pdev = platform_device_register_data(chip->dev, "adp5520-gpio",
265	chip->id, pdata->gpio, sizeof(*pdata->gpio));
266	if (IS_ERR(pdev)) {
267	ret = PTR_ERR(pdev);
268	goto out_remove_subdevs;
269	}
270	}
271
272	if (pdata->leds) {
273	pdev = platform_device_register_data(chip->dev, "adp5520-led",
274	chip->id, pdata->leds, sizeof(*pdata->leds));
275	if (IS_ERR(pdev)) {
276	ret = PTR_ERR(pdev);
277	goto out_remove_subdevs;
278	}
279	}
280
281	if (pdata->backlight) {
282	pdev = platform_device_register_data(chip->dev,
283	"adp5520-backlight",
284	chip->id,
285	pdata->backlight,
286	sizeof(*pdata->backlight));
287	if (IS_ERR(pdev)) {
288	ret = PTR_ERR(pdev);
289	goto out_remove_subdevs;
290	}
291	}
292
293	return 0;
294
295	out_remove_subdevs:
296	adp5520_remove_subdevs(chip);
297
298	out_free_irq:
299	if (chip->irq)
300	free_irq(chip->irq, chip);
301
302	out_free_chip:
303	i2c_set_clientdata(client, NULL);
304	kfree(chip);
305
306	return ret;
307	}
308
309	static int __devexit adp5520_remove(struct i2c_client *client)
310	{
311	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
312
313	if (chip->irq)
314	free_irq(chip->irq, chip);
315
316	adp5520_remove_subdevs(chip);
317	adp5520_write(chip->dev, ADP5520_MODE_STATUS, 0);
318	i2c_set_clientdata(client, NULL);
319	kfree(chip);
320	return 0;
321	}
322
323	#ifdef CONFIG_PM
324	static int adp5520_suspend(struct i2c_client *client,
325	pm_message_t state)
326	{
327	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
328
329	adp5520_clr_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
330	return 0;
331	}
332
333	static int adp5520_resume(struct i2c_client *client)
334	{
335	struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
336
337	adp5520_set_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
338	return 0;
339	}
340	#else
341	#define adp5520_suspend NULL
342	#define adp5520_resume NULL
343	#endif
344
345	static const struct i2c_device_id adp5520_id[] = {
346	{ "pmic-adp5520", ID_ADP5520 },
347	{ "pmic-adp5501", ID_ADP5501 },
348	{ }
349	};
350	MODULE_DEVICE_TABLE(i2c, adp5520_id);
351
352	static struct i2c_driver adp5520_driver = {
353	.driver = {
354	.name = "adp5520",
355	.owner = THIS_MODULE,
356	},
357	.probe = adp5520_probe,
358	.remove = __devexit_p(adp5520_remove),
359	.suspend = adp5520_suspend,
360	.resume = adp5520_resume,
361	.id_table = adp5520_id,
362	};
363
364	static int __init adp5520_init(void)
365	{
366	return i2c_add_driver(&adp5520_driver);
367	}
368	module_init(adp5520_init);
369
370	static void __exit adp5520_exit(void)
371	{
372	i2c_del_driver(&adp5520_driver);
373	}
374	module_exit(adp5520_exit);
375
376	MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
377	MODULE_DESCRIPTION("ADP5520(01) PMIC-MFD Driver");
378	MODULE_LICENSE("GPL");