mfd: Fix twl-core oops while calling twl_i2c_* for unbound driver
[linux-2.6.git] / drivers / mfd / pcf50633-core.c
1 /* NXP PCF50633 Power Management Unit (PMU) driver
2  *
3  * (C) 2006-2008 by Openmoko, Inc.
4  * Author: Harald Welte <laforge@openmoko.org>
5  *         Balaji Rao <balajirrao@openmoko.org>
6  * All rights reserved.
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  *
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/device.h>
17 #include <linux/sysfs.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/interrupt.h>
21 #include <linux/workqueue.h>
22 #include <linux/platform_device.h>
23 #include <linux/i2c.h>
24 #include <linux/pm.h>
25 #include <linux/slab.h>
26
27 #include <linux/mfd/pcf50633/core.h>
28
29 static int __pcf50633_read(struct pcf50633 *pcf, u8 reg, int num, u8 *data)
30 {
31         int ret;
32
33         ret = i2c_smbus_read_i2c_block_data(pcf->i2c_client, reg,
34                                 num, data);
35         if (ret < 0)
36                 dev_err(pcf->dev, "Error reading %d regs at %d\n", num, reg);
37
38         return ret;
39 }
40
41 static int __pcf50633_write(struct pcf50633 *pcf, u8 reg, int num, u8 *data)
42 {
43         int ret;
44
45         ret = i2c_smbus_write_i2c_block_data(pcf->i2c_client, reg,
46                                 num, data);
47         if (ret < 0)
48                 dev_err(pcf->dev, "Error writing %d regs at %d\n", num, reg);
49
50         return ret;
51
52 }
53
54 /* Read a block of up to 32 regs  */
55 int pcf50633_read_block(struct pcf50633 *pcf, u8 reg,
56                                         int nr_regs, u8 *data)
57 {
58         int ret;
59
60         mutex_lock(&pcf->lock);
61         ret = __pcf50633_read(pcf, reg, nr_regs, data);
62         mutex_unlock(&pcf->lock);
63
64         return ret;
65 }
66 EXPORT_SYMBOL_GPL(pcf50633_read_block);
67
68 /* Write a block of up to 32 regs  */
69 int pcf50633_write_block(struct pcf50633 *pcf , u8 reg,
70                                         int nr_regs, u8 *data)
71 {
72         int ret;
73
74         mutex_lock(&pcf->lock);
75         ret = __pcf50633_write(pcf, reg, nr_regs, data);
76         mutex_unlock(&pcf->lock);
77
78         return ret;
79 }
80 EXPORT_SYMBOL_GPL(pcf50633_write_block);
81
82 u8 pcf50633_reg_read(struct pcf50633 *pcf, u8 reg)
83 {
84         u8 val;
85
86         mutex_lock(&pcf->lock);
87         __pcf50633_read(pcf, reg, 1, &val);
88         mutex_unlock(&pcf->lock);
89
90         return val;
91 }
92 EXPORT_SYMBOL_GPL(pcf50633_reg_read);
93
94 int pcf50633_reg_write(struct pcf50633 *pcf, u8 reg, u8 val)
95 {
96         int ret;
97
98         mutex_lock(&pcf->lock);
99         ret = __pcf50633_write(pcf, reg, 1, &val);
100         mutex_unlock(&pcf->lock);
101
102         return ret;
103 }
104 EXPORT_SYMBOL_GPL(pcf50633_reg_write);
105
106 int pcf50633_reg_set_bit_mask(struct pcf50633 *pcf, u8 reg, u8 mask, u8 val)
107 {
108         int ret;
109         u8 tmp;
110
111         val &= mask;
112
113         mutex_lock(&pcf->lock);
114         ret = __pcf50633_read(pcf, reg, 1, &tmp);
115         if (ret < 0)
116                 goto out;
117
118         tmp &= ~mask;
119         tmp |= val;
120         ret = __pcf50633_write(pcf, reg, 1, &tmp);
121
122 out:
123         mutex_unlock(&pcf->lock);
124
125         return ret;
126 }
127 EXPORT_SYMBOL_GPL(pcf50633_reg_set_bit_mask);
128
129 int pcf50633_reg_clear_bits(struct pcf50633 *pcf, u8 reg, u8 val)
130 {
131         int ret;
132         u8 tmp;
133
134         mutex_lock(&pcf->lock);
135         ret = __pcf50633_read(pcf, reg, 1, &tmp);
136         if (ret < 0)
137                 goto out;
138
139         tmp &= ~val;
140         ret = __pcf50633_write(pcf, reg, 1, &tmp);
141
142 out:
143         mutex_unlock(&pcf->lock);
144
145         return ret;
146 }
147 EXPORT_SYMBOL_GPL(pcf50633_reg_clear_bits);
148
149 /* sysfs attributes */
150 static ssize_t show_dump_regs(struct device *dev, struct device_attribute *attr,
151                             char *buf)
152 {
153         struct pcf50633 *pcf = dev_get_drvdata(dev);
154         u8 dump[16];
155         int n, n1, idx = 0;
156         char *buf1 = buf;
157         static u8 address_no_read[] = { /* must be ascending */
158                 PCF50633_REG_INT1,
159                 PCF50633_REG_INT2,
160                 PCF50633_REG_INT3,
161                 PCF50633_REG_INT4,
162                 PCF50633_REG_INT5,
163                 0 /* terminator */
164         };
165
166         for (n = 0; n < 256; n += sizeof(dump)) {
167                 for (n1 = 0; n1 < sizeof(dump); n1++)
168                         if (n == address_no_read[idx]) {
169                                 idx++;
170                                 dump[n1] = 0x00;
171                         } else
172                                 dump[n1] = pcf50633_reg_read(pcf, n + n1);
173
174                 hex_dump_to_buffer(dump, sizeof(dump), 16, 1, buf1, 128, 0);
175                 buf1 += strlen(buf1);
176                 *buf1++ = '\n';
177                 *buf1 = '\0';
178         }
179
180         return buf1 - buf;
181 }
182 static DEVICE_ATTR(dump_regs, 0400, show_dump_regs, NULL);
183
184 static ssize_t show_resume_reason(struct device *dev,
185                                 struct device_attribute *attr, char *buf)
186 {
187         struct pcf50633 *pcf = dev_get_drvdata(dev);
188         int n;
189
190         n = sprintf(buf, "%02x%02x%02x%02x%02x\n",
191                                 pcf->resume_reason[0],
192                                 pcf->resume_reason[1],
193                                 pcf->resume_reason[2],
194                                 pcf->resume_reason[3],
195                                 pcf->resume_reason[4]);
196
197         return n;
198 }
199 static DEVICE_ATTR(resume_reason, 0400, show_resume_reason, NULL);
200
201 static struct attribute *pcf_sysfs_entries[] = {
202         &dev_attr_dump_regs.attr,
203         &dev_attr_resume_reason.attr,
204         NULL,
205 };
206
207 static struct attribute_group pcf_attr_group = {
208         .name   = NULL,                 /* put in device directory */
209         .attrs  = pcf_sysfs_entries,
210 };
211
212 static void
213 pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,
214                                                 struct platform_device **pdev)
215 {
216         int ret;
217
218         *pdev = platform_device_alloc(name, -1);
219         if (!*pdev) {
220                 dev_err(pcf->dev, "Falied to allocate %s\n", name);
221                 return;
222         }
223
224         (*pdev)->dev.parent = pcf->dev;
225
226         ret = platform_device_add(*pdev);
227         if (ret) {
228                 dev_err(pcf->dev, "Failed to register %s: %d\n", name, ret);
229                 platform_device_put(*pdev);
230                 *pdev = NULL;
231         }
232 }
233
234 #ifdef CONFIG_PM_SLEEP
235 static int pcf50633_suspend(struct device *dev)
236 {
237         struct i2c_client *client = to_i2c_client(dev);
238         struct pcf50633 *pcf = i2c_get_clientdata(client);
239
240         return pcf50633_irq_suspend(pcf);
241 }
242
243 static int pcf50633_resume(struct device *dev)
244 {
245         struct i2c_client *client = to_i2c_client(dev);
246         struct pcf50633 *pcf = i2c_get_clientdata(client);
247
248         return pcf50633_irq_resume(pcf);
249 }
250 #endif
251
252 static SIMPLE_DEV_PM_OPS(pcf50633_pm, pcf50633_suspend, pcf50633_resume);
253
254 static int __devinit pcf50633_probe(struct i2c_client *client,
255                                 const struct i2c_device_id *ids)
256 {
257         struct pcf50633 *pcf;
258         struct pcf50633_platform_data *pdata = client->dev.platform_data;
259         int i, ret;
260         int version, variant;
261
262         if (!client->irq) {
263                 dev_err(&client->dev, "Missing IRQ\n");
264                 return -ENOENT;
265         }
266
267         pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
268         if (!pcf)
269                 return -ENOMEM;
270
271         pcf->pdata = pdata;
272
273         mutex_init(&pcf->lock);
274
275         i2c_set_clientdata(client, pcf);
276         pcf->dev = &client->dev;
277         pcf->i2c_client = client;
278
279         version = pcf50633_reg_read(pcf, 0);
280         variant = pcf50633_reg_read(pcf, 1);
281         if (version < 0 || variant < 0) {
282                 dev_err(pcf->dev, "Unable to probe pcf50633\n");
283                 ret = -ENODEV;
284                 goto err_free;
285         }
286
287         dev_info(pcf->dev, "Probed device version %d variant %d\n",
288                                                         version, variant);
289
290         pcf50633_irq_init(pcf, client->irq);
291
292         /* Create sub devices */
293         pcf50633_client_dev_register(pcf, "pcf50633-input",
294                                                 &pcf->input_pdev);
295         pcf50633_client_dev_register(pcf, "pcf50633-rtc",
296                                                 &pcf->rtc_pdev);
297         pcf50633_client_dev_register(pcf, "pcf50633-mbc",
298                                                 &pcf->mbc_pdev);
299         pcf50633_client_dev_register(pcf, "pcf50633-adc",
300                                                 &pcf->adc_pdev);
301         pcf50633_client_dev_register(pcf, "pcf50633-backlight",
302                                                 &pcf->bl_pdev);
303
304
305         for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
306                 struct platform_device *pdev;
307
308                 pdev = platform_device_alloc("pcf50633-regltr", i);
309                 if (!pdev) {
310                         dev_err(pcf->dev, "Cannot create regulator %d\n", i);
311                         continue;
312                 }
313
314                 pdev->dev.parent = pcf->dev;
315                 platform_device_add_data(pdev, &pdata->reg_init_data[i],
316                                         sizeof(pdata->reg_init_data[i]));
317                 pcf->regulator_pdev[i] = pdev;
318
319                 platform_device_add(pdev);
320         }
321
322         ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
323         if (ret)
324                 dev_err(pcf->dev, "error creating sysfs entries\n");
325
326         if (pdata->probe_done)
327                 pdata->probe_done(pcf);
328
329         return 0;
330
331 err_free:
332         kfree(pcf);
333
334         return ret;
335 }
336
337 static int __devexit pcf50633_remove(struct i2c_client *client)
338 {
339         struct pcf50633 *pcf = i2c_get_clientdata(client);
340         int i;
341
342         sysfs_remove_group(&client->dev.kobj, &pcf_attr_group);
343         pcf50633_irq_free(pcf);
344
345         platform_device_unregister(pcf->input_pdev);
346         platform_device_unregister(pcf->rtc_pdev);
347         platform_device_unregister(pcf->mbc_pdev);
348         platform_device_unregister(pcf->adc_pdev);
349         platform_device_unregister(pcf->bl_pdev);
350
351         for (i = 0; i < PCF50633_NUM_REGULATORS; i++)
352                 platform_device_unregister(pcf->regulator_pdev[i]);
353
354         kfree(pcf);
355
356         return 0;
357 }
358
359 static const struct i2c_device_id pcf50633_id_table[] = {
360         {"pcf50633", 0x73},
361         {/* end of list */}
362 };
363 MODULE_DEVICE_TABLE(i2c, pcf50633_id_table);
364
365 static struct i2c_driver pcf50633_driver = {
366         .driver = {
367                 .name   = "pcf50633",
368                 .pm     = &pcf50633_pm,
369         },
370         .id_table = pcf50633_id_table,
371         .probe = pcf50633_probe,
372         .remove = __devexit_p(pcf50633_remove),
373 };
374
375 static int __init pcf50633_init(void)
376 {
377         return i2c_add_driver(&pcf50633_driver);
378 }
379
380 static void __exit pcf50633_exit(void)
381 {
382         i2c_del_driver(&pcf50633_driver);
383 }
384
385 MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 PMU");
386 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
387 MODULE_LICENSE("GPL");
388
389 subsys_initcall(pcf50633_init);
390 module_exit(pcf50633_exit);