aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mfd
diff options
context:
space:
mode:
authorMichael Hennerich <michael.hennerich@analog.com>2009-10-12 11:22:38 -0400
committerSamuel Ortiz <sameo@linux.intel.com>2009-12-13 13:20:53 -0500
commita5736e0b62fcb7c1b20892c62e1c5fe5e9387c86 (patch)
tree7b7565145289029964bc8467ada3bcbe86a8a990 /drivers/mfd
parent7c29a47668a922bd99f3e69a833dc1000b603134 (diff)
mfd: Add ADP5520/ADP5501 driver
Base driver for Analog Devices ADP5520/ADP5501 MFD PMICs Subdevs: LCD Backlight : drivers/video/backlight/adp5520_bl.c LEDs : drivers/led/leds-adp5520.c GPIO : drivers/gpio/adp5520-gpio.c (ADP5520 only) Keys : drivers/input/keyboard/adp5520-keys.c (ADP5520 only) Signed-off-by: Michael Hennerich <michael.hennerich@analog.com> Signed-off-by: Bryan Wu <cooloney@kernel.org> Signed-off-by: Mike Frysinger <vapier@gentoo.org> Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
Diffstat (limited to 'drivers/mfd')
-rw-r--r--drivers/mfd/Kconfig10
-rw-r--r--drivers/mfd/Makefile1
-rw-r--r--drivers/mfd/adp5520.c378
3 files changed, 389 insertions, 0 deletions
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 7df3bcf79490..b1d537053faf 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -174,6 +174,16 @@ config PMIC_DA903X
174 individual components like LCD backlight, voltage regulators, 174 individual components like LCD backlight, voltage regulators,
175 LEDs and battery-charger under the corresponding menus. 175 LEDs and battery-charger under the corresponding menus.
176 176
177config PMIC_ADP5520
178 bool "Analog Devices ADP5520/01 MFD PMIC Core Support"
179 depends on I2C=y
180 help
181 Say yes here to add support for Analog Devices AD5520 and ADP5501,
182 Multifunction Power Management IC. This includes
183 the I2C driver and the core APIs _only_, you have to select
184 individual components like LCD backlight, LEDs, GPIOs and Kepad
185 under the corresponding menus.
186
177config MFD_WM8400 187config MFD_WM8400
178 tristate "Support Wolfson Microelectronics WM8400" 188 tristate "Support Wolfson Microelectronics WM8400"
179 select MFD_CORE 189 select MFD_CORE
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 1792b1ff8ffc..24558574a737 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -54,3 +54,4 @@ obj-$(CONFIG_AB3100_CORE) += ab3100-core.o
54obj-$(CONFIG_AB3100_OTP) += ab3100-otp.o 54obj-$(CONFIG_AB3100_OTP) += ab3100-otp.o
55obj-$(CONFIG_AB4500_CORE) += ab4500-core.o 55obj-$(CONFIG_AB4500_CORE) += ab4500-core.o
56obj-$(CONFIG_MFD_88PM8607) += 88pm8607.o 56obj-$(CONFIG_MFD_88PM8607) += 88pm8607.o
57obj-$(CONFIG_PMIC_ADP5520) += adp5520.o \ No newline at end of file
diff --git a/drivers/mfd/adp5520.c b/drivers/mfd/adp5520.c
new file mode 100644
index 000000000000..401a9b6029e3
--- /dev/null
+++ b/drivers/mfd/adp5520.c
@@ -0,0 +1,378 @@
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
31struct 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
40static 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
55static 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
69int __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
88int adp5520_write(struct device *dev, int reg, uint8_t val)
89{
90 return __adp5520_write(to_i2c_client(dev), reg, val);
91}
92EXPORT_SYMBOL_GPL(adp5520_write);
93
94int adp5520_read(struct device *dev, int reg, uint8_t *val)
95{
96 return __adp5520_read(to_i2c_client(dev), reg, val);
97}
98EXPORT_SYMBOL_GPL(adp5520_read);
99
100int 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}
118EXPORT_SYMBOL_GPL(adp5520_set_bits);
119
120int 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}
138EXPORT_SYMBOL_GPL(adp5520_clr_bits);
139
140int 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}
156EXPORT_SYMBOL_GPL(adp5520_register_notifier);
157
158int 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}
169EXPORT_SYMBOL_GPL(adp5520_unregister_notifier);
170
171static 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
189out:
190 return IRQ_HANDLED;
191}
192
193static int __remove_subdev(struct device *dev, void *unused)
194{
195 platform_device_unregister(to_platform_device(dev));
196 return 0;
197}
198
199static int adp5520_remove_subdevs(struct adp5520_chip *chip)
200{
201 return device_for_each_child(chip->dev, NULL, __remove_subdev);
202}
203
204static 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
295out_remove_subdevs:
296 adp5520_remove_subdevs(chip);
297
298out_free_irq:
299 if (chip->irq)
300 free_irq(chip->irq, chip);
301
302out_free_chip:
303 i2c_set_clientdata(client, NULL);
304 kfree(chip);
305
306 return ret;
307}
308
309static 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
324static 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
333static 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
345static const struct i2c_device_id adp5520_id[] = {
346 { "pmic-adp5520", ID_ADP5520 },
347 { "pmic-adp5501", ID_ADP5501 },
348 { }
349};
350MODULE_DEVICE_TABLE(i2c, adp5520_id);
351
352static 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
364static int __init adp5520_init(void)
365{
366 return i2c_add_driver(&adp5520_driver);
367}
368module_init(adp5520_init);
369
370static void __exit adp5520_exit(void)
371{
372 i2c_del_driver(&adp5520_driver);
373}
374module_exit(adp5520_exit);
375
376MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
377MODULE_DESCRIPTION("ADP5520(01) PMIC-MFD Driver");
378MODULE_LICENSE("GPL");