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