regmap: merge 7cccbdc84487616c3dbe493b04bfa1f362f4bc56
[linux-2.6.git] / drivers / mfd / wm831x-core.c
1 /*
2  * wm831x-core.c  --  Device access for Wolfson WM831x PMICs
3  *
4  * Copyright 2009 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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/module.h>
17 #include <linux/bcd.h>
18 #include <linux/delay.h>
19 #include <linux/mfd/core.h>
20 #include <linux/slab.h>
21 #include <linux/err.h>
22
23 #include <linux/mfd/wm831x/core.h>
24 #include <linux/mfd/wm831x/pdata.h>
25 #include <linux/mfd/wm831x/irq.h>
26 #include <linux/mfd/wm831x/auxadc.h>
27 #include <linux/mfd/wm831x/otp.h>
28 #include <linux/mfd/wm831x/pmu.h>
29 #include <linux/mfd/wm831x/regulator.h>
30
31 /* Current settings - values are 2*2^(reg_val/4) microamps.  These are
32  * exported since they are used by multiple drivers.
33  */
34 int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {
35         2,
36         2,
37         3,
38         3,
39         4,
40         5,
41         6,
42         7,
43         8,
44         10,
45         11,
46         13,
47         16,
48         19,
49         23,
50         27,
51         32,
52         38,
53         45,
54         54,
55         64,
56         76,
57         91,
58         108,
59         128,
60         152,
61         181,
62         215,
63         256,
64         304,
65         362,
66         431,
67         512,
68         609,
69         724,
70         861,
71         1024,
72         1218,
73         1448,
74         1722,
75         2048,
76         2435,
77         2896,
78         3444,
79         4096,
80         4871,
81         5793,
82         6889,
83         8192,
84         9742,
85         11585,
86         13777,
87         16384,
88         19484,
89         23170,
90         27554,
91 };
92 EXPORT_SYMBOL_GPL(wm831x_isinkv_values);
93
94 static int wm831x_reg_locked(struct wm831x *wm831x, unsigned short reg)
95 {
96         if (!wm831x->locked)
97                 return 0;
98
99         switch (reg) {
100         case WM831X_WATCHDOG:
101         case WM831X_DC4_CONTROL:
102         case WM831X_ON_PIN_CONTROL:
103         case WM831X_BACKUP_CHARGER_CONTROL:
104         case WM831X_CHARGER_CONTROL_1:
105         case WM831X_CHARGER_CONTROL_2:
106                 return 1;
107
108         default:
109                 return 0;
110         }
111 }
112
113 /**
114  * wm831x_reg_unlock: Unlock user keyed registers
115  *
116  * The WM831x has a user key preventing writes to particularly
117  * critical registers.  This function locks those registers,
118  * allowing writes to them.
119  */
120 void wm831x_reg_lock(struct wm831x *wm831x)
121 {
122         int ret;
123
124         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
125         if (ret == 0) {
126                 dev_vdbg(wm831x->dev, "Registers locked\n");
127
128                 mutex_lock(&wm831x->io_lock);
129                 WARN_ON(wm831x->locked);
130                 wm831x->locked = 1;
131                 mutex_unlock(&wm831x->io_lock);
132         } else {
133                 dev_err(wm831x->dev, "Failed to lock registers: %d\n", ret);
134         }
135
136 }
137 EXPORT_SYMBOL_GPL(wm831x_reg_lock);
138
139 /**
140  * wm831x_reg_unlock: Unlock user keyed registers
141  *
142  * The WM831x has a user key preventing writes to particularly
143  * critical registers.  This function locks those registers,
144  * preventing spurious writes.
145  */
146 int wm831x_reg_unlock(struct wm831x *wm831x)
147 {
148         int ret;
149
150         /* 0x9716 is the value required to unlock the registers */
151         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0x9716);
152         if (ret == 0) {
153                 dev_vdbg(wm831x->dev, "Registers unlocked\n");
154
155                 mutex_lock(&wm831x->io_lock);
156                 WARN_ON(!wm831x->locked);
157                 wm831x->locked = 0;
158                 mutex_unlock(&wm831x->io_lock);
159         }
160
161         return ret;
162 }
163 EXPORT_SYMBOL_GPL(wm831x_reg_unlock);
164
165 static bool wm831x_reg_readable(struct device *dev, unsigned int reg)
166 {
167         switch (reg) {
168         case WM831X_RESET_ID:
169         case WM831X_REVISION:
170         case WM831X_PARENT_ID:
171         case WM831X_SYSVDD_CONTROL:
172         case WM831X_THERMAL_MONITORING:
173         case WM831X_POWER_STATE:
174         case WM831X_WATCHDOG:
175         case WM831X_ON_PIN_CONTROL:
176         case WM831X_RESET_CONTROL:
177         case WM831X_CONTROL_INTERFACE:
178         case WM831X_SECURITY_KEY:
179         case WM831X_SOFTWARE_SCRATCH:
180         case WM831X_OTP_CONTROL:
181         case WM831X_GPIO_LEVEL:
182         case WM831X_SYSTEM_STATUS:
183         case WM831X_ON_SOURCE:
184         case WM831X_OFF_SOURCE:
185         case WM831X_SYSTEM_INTERRUPTS:
186         case WM831X_INTERRUPT_STATUS_1:
187         case WM831X_INTERRUPT_STATUS_2:
188         case WM831X_INTERRUPT_STATUS_3:
189         case WM831X_INTERRUPT_STATUS_4:
190         case WM831X_INTERRUPT_STATUS_5:
191         case WM831X_IRQ_CONFIG:
192         case WM831X_SYSTEM_INTERRUPTS_MASK:
193         case WM831X_INTERRUPT_STATUS_1_MASK:
194         case WM831X_INTERRUPT_STATUS_2_MASK:
195         case WM831X_INTERRUPT_STATUS_3_MASK:
196         case WM831X_INTERRUPT_STATUS_4_MASK:
197         case WM831X_INTERRUPT_STATUS_5_MASK:
198         case WM831X_RTC_WRITE_COUNTER:
199         case WM831X_RTC_TIME_1:
200         case WM831X_RTC_TIME_2:
201         case WM831X_RTC_ALARM_1:
202         case WM831X_RTC_ALARM_2:
203         case WM831X_RTC_CONTROL:
204         case WM831X_RTC_TRIM:
205         case WM831X_TOUCH_CONTROL_1:
206         case WM831X_TOUCH_CONTROL_2:
207         case WM831X_TOUCH_DATA_X:
208         case WM831X_TOUCH_DATA_Y:
209         case WM831X_TOUCH_DATA_Z:
210         case WM831X_AUXADC_DATA:
211         case WM831X_AUXADC_CONTROL:
212         case WM831X_AUXADC_SOURCE:
213         case WM831X_COMPARATOR_CONTROL:
214         case WM831X_COMPARATOR_1:
215         case WM831X_COMPARATOR_2:
216         case WM831X_COMPARATOR_3:
217         case WM831X_COMPARATOR_4:
218         case WM831X_GPIO1_CONTROL:
219         case WM831X_GPIO2_CONTROL:
220         case WM831X_GPIO3_CONTROL:
221         case WM831X_GPIO4_CONTROL:
222         case WM831X_GPIO5_CONTROL:
223         case WM831X_GPIO6_CONTROL:
224         case WM831X_GPIO7_CONTROL:
225         case WM831X_GPIO8_CONTROL:
226         case WM831X_GPIO9_CONTROL:
227         case WM831X_GPIO10_CONTROL:
228         case WM831X_GPIO11_CONTROL:
229         case WM831X_GPIO12_CONTROL:
230         case WM831X_GPIO13_CONTROL:
231         case WM831X_GPIO14_CONTROL:
232         case WM831X_GPIO15_CONTROL:
233         case WM831X_GPIO16_CONTROL:
234         case WM831X_CHARGER_CONTROL_1:
235         case WM831X_CHARGER_CONTROL_2:
236         case WM831X_CHARGER_STATUS:
237         case WM831X_BACKUP_CHARGER_CONTROL:
238         case WM831X_STATUS_LED_1:
239         case WM831X_STATUS_LED_2:
240         case WM831X_CURRENT_SINK_1:
241         case WM831X_CURRENT_SINK_2:
242         case WM831X_DCDC_ENABLE:
243         case WM831X_LDO_ENABLE:
244         case WM831X_DCDC_STATUS:
245         case WM831X_LDO_STATUS:
246         case WM831X_DCDC_UV_STATUS:
247         case WM831X_LDO_UV_STATUS:
248         case WM831X_DC1_CONTROL_1:
249         case WM831X_DC1_CONTROL_2:
250         case WM831X_DC1_ON_CONFIG:
251         case WM831X_DC1_SLEEP_CONTROL:
252         case WM831X_DC1_DVS_CONTROL:
253         case WM831X_DC2_CONTROL_1:
254         case WM831X_DC2_CONTROL_2:
255         case WM831X_DC2_ON_CONFIG:
256         case WM831X_DC2_SLEEP_CONTROL:
257         case WM831X_DC2_DVS_CONTROL:
258         case WM831X_DC3_CONTROL_1:
259         case WM831X_DC3_CONTROL_2:
260         case WM831X_DC3_ON_CONFIG:
261         case WM831X_DC3_SLEEP_CONTROL:
262         case WM831X_DC4_CONTROL:
263         case WM831X_DC4_SLEEP_CONTROL:
264         case WM831X_EPE1_CONTROL:
265         case WM831X_EPE2_CONTROL:
266         case WM831X_LDO1_CONTROL:
267         case WM831X_LDO1_ON_CONTROL:
268         case WM831X_LDO1_SLEEP_CONTROL:
269         case WM831X_LDO2_CONTROL:
270         case WM831X_LDO2_ON_CONTROL:
271         case WM831X_LDO2_SLEEP_CONTROL:
272         case WM831X_LDO3_CONTROL:
273         case WM831X_LDO3_ON_CONTROL:
274         case WM831X_LDO3_SLEEP_CONTROL:
275         case WM831X_LDO4_CONTROL:
276         case WM831X_LDO4_ON_CONTROL:
277         case WM831X_LDO4_SLEEP_CONTROL:
278         case WM831X_LDO5_CONTROL:
279         case WM831X_LDO5_ON_CONTROL:
280         case WM831X_LDO5_SLEEP_CONTROL:
281         case WM831X_LDO6_CONTROL:
282         case WM831X_LDO6_ON_CONTROL:
283         case WM831X_LDO6_SLEEP_CONTROL:
284         case WM831X_LDO7_CONTROL:
285         case WM831X_LDO7_ON_CONTROL:
286         case WM831X_LDO7_SLEEP_CONTROL:
287         case WM831X_LDO8_CONTROL:
288         case WM831X_LDO8_ON_CONTROL:
289         case WM831X_LDO8_SLEEP_CONTROL:
290         case WM831X_LDO9_CONTROL:
291         case WM831X_LDO9_ON_CONTROL:
292         case WM831X_LDO9_SLEEP_CONTROL:
293         case WM831X_LDO10_CONTROL:
294         case WM831X_LDO10_ON_CONTROL:
295         case WM831X_LDO10_SLEEP_CONTROL:
296         case WM831X_LDO11_ON_CONTROL:
297         case WM831X_LDO11_SLEEP_CONTROL:
298         case WM831X_POWER_GOOD_SOURCE_1:
299         case WM831X_POWER_GOOD_SOURCE_2:
300         case WM831X_CLOCK_CONTROL_1:
301         case WM831X_CLOCK_CONTROL_2:
302         case WM831X_FLL_CONTROL_1:
303         case WM831X_FLL_CONTROL_2:
304         case WM831X_FLL_CONTROL_3:
305         case WM831X_FLL_CONTROL_4:
306         case WM831X_FLL_CONTROL_5:
307         case WM831X_UNIQUE_ID_1:
308         case WM831X_UNIQUE_ID_2:
309         case WM831X_UNIQUE_ID_3:
310         case WM831X_UNIQUE_ID_4:
311         case WM831X_UNIQUE_ID_5:
312         case WM831X_UNIQUE_ID_6:
313         case WM831X_UNIQUE_ID_7:
314         case WM831X_UNIQUE_ID_8:
315         case WM831X_FACTORY_OTP_ID:
316         case WM831X_FACTORY_OTP_1:
317         case WM831X_FACTORY_OTP_2:
318         case WM831X_FACTORY_OTP_3:
319         case WM831X_FACTORY_OTP_4:
320         case WM831X_FACTORY_OTP_5:
321         case WM831X_CUSTOMER_OTP_ID:
322         case WM831X_DC1_OTP_CONTROL:
323         case WM831X_DC2_OTP_CONTROL:
324         case WM831X_DC3_OTP_CONTROL:
325         case WM831X_LDO1_2_OTP_CONTROL:
326         case WM831X_LDO3_4_OTP_CONTROL:
327         case WM831X_LDO5_6_OTP_CONTROL:
328         case WM831X_LDO7_8_OTP_CONTROL:
329         case WM831X_LDO9_10_OTP_CONTROL:
330         case WM831X_LDO11_EPE_CONTROL:
331         case WM831X_GPIO1_OTP_CONTROL:
332         case WM831X_GPIO2_OTP_CONTROL:
333         case WM831X_GPIO3_OTP_CONTROL:
334         case WM831X_GPIO4_OTP_CONTROL:
335         case WM831X_GPIO5_OTP_CONTROL:
336         case WM831X_GPIO6_OTP_CONTROL:
337         case WM831X_DBE_CHECK_DATA:
338                 return true;
339         default:
340                 return false;
341         }
342 }
343
344 static bool wm831x_reg_writeable(struct device *dev, unsigned int reg)
345 {
346         struct wm831x *wm831x = dev_get_drvdata(dev);
347
348         if (wm831x_reg_locked(wm831x, reg))
349                 return false;
350
351         switch (reg) {
352         case WM831X_SYSVDD_CONTROL:
353         case WM831X_THERMAL_MONITORING:
354         case WM831X_POWER_STATE:
355         case WM831X_WATCHDOG:
356         case WM831X_ON_PIN_CONTROL:
357         case WM831X_RESET_CONTROL:
358         case WM831X_CONTROL_INTERFACE:
359         case WM831X_SECURITY_KEY:
360         case WM831X_SOFTWARE_SCRATCH:
361         case WM831X_OTP_CONTROL:
362         case WM831X_GPIO_LEVEL:
363         case WM831X_INTERRUPT_STATUS_1:
364         case WM831X_INTERRUPT_STATUS_2:
365         case WM831X_INTERRUPT_STATUS_3:
366         case WM831X_INTERRUPT_STATUS_4:
367         case WM831X_INTERRUPT_STATUS_5:
368         case WM831X_IRQ_CONFIG:
369         case WM831X_SYSTEM_INTERRUPTS_MASK:
370         case WM831X_INTERRUPT_STATUS_1_MASK:
371         case WM831X_INTERRUPT_STATUS_2_MASK:
372         case WM831X_INTERRUPT_STATUS_3_MASK:
373         case WM831X_INTERRUPT_STATUS_4_MASK:
374         case WM831X_INTERRUPT_STATUS_5_MASK:
375         case WM831X_RTC_TIME_1:
376         case WM831X_RTC_TIME_2:
377         case WM831X_RTC_ALARM_1:
378         case WM831X_RTC_ALARM_2:
379         case WM831X_RTC_CONTROL:
380         case WM831X_RTC_TRIM:
381         case WM831X_TOUCH_CONTROL_1:
382         case WM831X_TOUCH_CONTROL_2:
383         case WM831X_AUXADC_CONTROL:
384         case WM831X_AUXADC_SOURCE:
385         case WM831X_COMPARATOR_CONTROL:
386         case WM831X_COMPARATOR_1:
387         case WM831X_COMPARATOR_2:
388         case WM831X_COMPARATOR_3:
389         case WM831X_COMPARATOR_4:
390         case WM831X_GPIO1_CONTROL:
391         case WM831X_GPIO2_CONTROL:
392         case WM831X_GPIO3_CONTROL:
393         case WM831X_GPIO4_CONTROL:
394         case WM831X_GPIO5_CONTROL:
395         case WM831X_GPIO6_CONTROL:
396         case WM831X_GPIO7_CONTROL:
397         case WM831X_GPIO8_CONTROL:
398         case WM831X_GPIO9_CONTROL:
399         case WM831X_GPIO10_CONTROL:
400         case WM831X_GPIO11_CONTROL:
401         case WM831X_GPIO12_CONTROL:
402         case WM831X_GPIO13_CONTROL:
403         case WM831X_GPIO14_CONTROL:
404         case WM831X_GPIO15_CONTROL:
405         case WM831X_GPIO16_CONTROL:
406         case WM831X_CHARGER_CONTROL_1:
407         case WM831X_CHARGER_CONTROL_2:
408         case WM831X_CHARGER_STATUS:
409         case WM831X_BACKUP_CHARGER_CONTROL:
410         case WM831X_STATUS_LED_1:
411         case WM831X_STATUS_LED_2:
412         case WM831X_CURRENT_SINK_1:
413         case WM831X_CURRENT_SINK_2:
414         case WM831X_DCDC_ENABLE:
415         case WM831X_LDO_ENABLE:
416         case WM831X_DC1_CONTROL_1:
417         case WM831X_DC1_CONTROL_2:
418         case WM831X_DC1_ON_CONFIG:
419         case WM831X_DC1_SLEEP_CONTROL:
420         case WM831X_DC1_DVS_CONTROL:
421         case WM831X_DC2_CONTROL_1:
422         case WM831X_DC2_CONTROL_2:
423         case WM831X_DC2_ON_CONFIG:
424         case WM831X_DC2_SLEEP_CONTROL:
425         case WM831X_DC2_DVS_CONTROL:
426         case WM831X_DC3_CONTROL_1:
427         case WM831X_DC3_CONTROL_2:
428         case WM831X_DC3_ON_CONFIG:
429         case WM831X_DC3_SLEEP_CONTROL:
430         case WM831X_DC4_CONTROL:
431         case WM831X_DC4_SLEEP_CONTROL:
432         case WM831X_EPE1_CONTROL:
433         case WM831X_EPE2_CONTROL:
434         case WM831X_LDO1_CONTROL:
435         case WM831X_LDO1_ON_CONTROL:
436         case WM831X_LDO1_SLEEP_CONTROL:
437         case WM831X_LDO2_CONTROL:
438         case WM831X_LDO2_ON_CONTROL:
439         case WM831X_LDO2_SLEEP_CONTROL:
440         case WM831X_LDO3_CONTROL:
441         case WM831X_LDO3_ON_CONTROL:
442         case WM831X_LDO3_SLEEP_CONTROL:
443         case WM831X_LDO4_CONTROL:
444         case WM831X_LDO4_ON_CONTROL:
445         case WM831X_LDO4_SLEEP_CONTROL:
446         case WM831X_LDO5_CONTROL:
447         case WM831X_LDO5_ON_CONTROL:
448         case WM831X_LDO5_SLEEP_CONTROL:
449         case WM831X_LDO6_CONTROL:
450         case WM831X_LDO6_ON_CONTROL:
451         case WM831X_LDO6_SLEEP_CONTROL:
452         case WM831X_LDO7_CONTROL:
453         case WM831X_LDO7_ON_CONTROL:
454         case WM831X_LDO7_SLEEP_CONTROL:
455         case WM831X_LDO8_CONTROL:
456         case WM831X_LDO8_ON_CONTROL:
457         case WM831X_LDO8_SLEEP_CONTROL:
458         case WM831X_LDO9_CONTROL:
459         case WM831X_LDO9_ON_CONTROL:
460         case WM831X_LDO9_SLEEP_CONTROL:
461         case WM831X_LDO10_CONTROL:
462         case WM831X_LDO10_ON_CONTROL:
463         case WM831X_LDO10_SLEEP_CONTROL:
464         case WM831X_LDO11_ON_CONTROL:
465         case WM831X_LDO11_SLEEP_CONTROL:
466         case WM831X_POWER_GOOD_SOURCE_1:
467         case WM831X_POWER_GOOD_SOURCE_2:
468         case WM831X_CLOCK_CONTROL_1:
469         case WM831X_CLOCK_CONTROL_2:
470         case WM831X_FLL_CONTROL_1:
471         case WM831X_FLL_CONTROL_2:
472         case WM831X_FLL_CONTROL_3:
473         case WM831X_FLL_CONTROL_4:
474         case WM831X_FLL_CONTROL_5:
475                 return true;
476         default:
477                 return false;
478         }
479 }
480
481 static bool wm831x_reg_volatile(struct device *dev, unsigned int reg)
482 {
483         switch (reg) {
484         case WM831X_SYSTEM_STATUS:
485         case WM831X_ON_SOURCE:
486         case WM831X_OFF_SOURCE:
487         case WM831X_GPIO_LEVEL:
488         case WM831X_SYSTEM_INTERRUPTS:
489         case WM831X_INTERRUPT_STATUS_1:
490         case WM831X_INTERRUPT_STATUS_2:
491         case WM831X_INTERRUPT_STATUS_3:
492         case WM831X_INTERRUPT_STATUS_4:
493         case WM831X_INTERRUPT_STATUS_5:
494         case WM831X_RTC_TIME_1:
495         case WM831X_RTC_TIME_2:
496         case WM831X_TOUCH_DATA_X:
497         case WM831X_TOUCH_DATA_Y:
498         case WM831X_TOUCH_DATA_Z:
499         case WM831X_AUXADC_DATA:
500         case WM831X_CHARGER_STATUS:
501         case WM831X_DCDC_STATUS:
502         case WM831X_LDO_STATUS:
503         case WM831X_DCDC_UV_STATUS:
504         case WM831X_LDO_UV_STATUS:
505                 return true;
506         default:
507                 return false;
508         }
509 }
510
511 /**
512  * wm831x_reg_read: Read a single WM831x register.
513  *
514  * @wm831x: Device to read from.
515  * @reg: Register to read.
516  */
517 int wm831x_reg_read(struct wm831x *wm831x, unsigned short reg)
518 {
519         unsigned int val;
520         int ret;
521
522         ret = regmap_read(wm831x->regmap, reg, &val);
523
524         if (ret < 0)
525                 return ret;
526         else
527                 return val;
528 }
529 EXPORT_SYMBOL_GPL(wm831x_reg_read);
530
531 /**
532  * wm831x_bulk_read: Read multiple WM831x registers
533  *
534  * @wm831x: Device to read from
535  * @reg: First register
536  * @count: Number of registers
537  * @buf: Buffer to fill.
538  */
539 int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
540                      int count, u16 *buf)
541 {
542         return regmap_bulk_read(wm831x->regmap, reg, buf, count);
543 }
544 EXPORT_SYMBOL_GPL(wm831x_bulk_read);
545
546 static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
547                         int bytes, void *src)
548 {
549         u16 *buf = src;
550         int i, ret;
551
552         BUG_ON(bytes % 2);
553         BUG_ON(bytes <= 0);
554
555         for (i = 0; i < bytes / 2; i++) {
556                 if (wm831x_reg_locked(wm831x, reg))
557                         return -EPERM;
558
559                 dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
560                          buf[i], reg + i, reg + i);
561                 ret = regmap_write(wm831x->regmap, reg + i, buf[i]);
562         }
563
564         return 0;
565 }
566
567 /**
568  * wm831x_reg_write: Write a single WM831x register.
569  *
570  * @wm831x: Device to write to.
571  * @reg: Register to write to.
572  * @val: Value to write.
573  */
574 int wm831x_reg_write(struct wm831x *wm831x, unsigned short reg,
575                      unsigned short val)
576 {
577         int ret;
578
579         mutex_lock(&wm831x->io_lock);
580
581         ret = wm831x_write(wm831x, reg, 2, &val);
582
583         mutex_unlock(&wm831x->io_lock);
584
585         return ret;
586 }
587 EXPORT_SYMBOL_GPL(wm831x_reg_write);
588
589 /**
590  * wm831x_set_bits: Set the value of a bitfield in a WM831x register
591  *
592  * @wm831x: Device to write to.
593  * @reg: Register to write to.
594  * @mask: Mask of bits to set.
595  * @val: Value to set (unshifted)
596  */
597 int wm831x_set_bits(struct wm831x *wm831x, unsigned short reg,
598                     unsigned short mask, unsigned short val)
599 {
600         int ret;
601
602         mutex_lock(&wm831x->io_lock);
603
604         if (!wm831x_reg_locked(wm831x, reg))
605                 ret = regmap_update_bits(wm831x->regmap, reg, mask, val);
606         else
607                 ret = -EPERM;
608
609         mutex_unlock(&wm831x->io_lock);
610
611         return ret;
612 }
613 EXPORT_SYMBOL_GPL(wm831x_set_bits);
614
615 static struct resource wm831x_dcdc1_resources[] = {
616         {
617                 .start = WM831X_DC1_CONTROL_1,
618                 .end   = WM831X_DC1_DVS_CONTROL,
619                 .flags = IORESOURCE_IO,
620         },
621         {
622                 .name  = "UV",
623                 .start = WM831X_IRQ_UV_DC1,
624                 .end   = WM831X_IRQ_UV_DC1,
625                 .flags = IORESOURCE_IRQ,
626         },
627         {
628                 .name  = "HC",
629                 .start = WM831X_IRQ_HC_DC1,
630                 .end   = WM831X_IRQ_HC_DC1,
631                 .flags = IORESOURCE_IRQ,
632         },
633 };
634
635
636 static struct resource wm831x_dcdc2_resources[] = {
637         {
638                 .start = WM831X_DC2_CONTROL_1,
639                 .end   = WM831X_DC2_DVS_CONTROL,
640                 .flags = IORESOURCE_IO,
641         },
642         {
643                 .name  = "UV",
644                 .start = WM831X_IRQ_UV_DC2,
645                 .end   = WM831X_IRQ_UV_DC2,
646                 .flags = IORESOURCE_IRQ,
647         },
648         {
649                 .name  = "HC",
650                 .start = WM831X_IRQ_HC_DC2,
651                 .end   = WM831X_IRQ_HC_DC2,
652                 .flags = IORESOURCE_IRQ,
653         },
654 };
655
656 static struct resource wm831x_dcdc3_resources[] = {
657         {
658                 .start = WM831X_DC3_CONTROL_1,
659                 .end   = WM831X_DC3_SLEEP_CONTROL,
660                 .flags = IORESOURCE_IO,
661         },
662         {
663                 .name  = "UV",
664                 .start = WM831X_IRQ_UV_DC3,
665                 .end   = WM831X_IRQ_UV_DC3,
666                 .flags = IORESOURCE_IRQ,
667         },
668 };
669
670 static struct resource wm831x_dcdc4_resources[] = {
671         {
672                 .start = WM831X_DC4_CONTROL,
673                 .end   = WM831X_DC4_SLEEP_CONTROL,
674                 .flags = IORESOURCE_IO,
675         },
676         {
677                 .name  = "UV",
678                 .start = WM831X_IRQ_UV_DC4,
679                 .end   = WM831X_IRQ_UV_DC4,
680                 .flags = IORESOURCE_IRQ,
681         },
682 };
683
684 static struct resource wm8320_dcdc4_buck_resources[] = {
685         {
686                 .start = WM831X_DC4_CONTROL,
687                 .end   = WM832X_DC4_SLEEP_CONTROL,
688                 .flags = IORESOURCE_IO,
689         },
690         {
691                 .name  = "UV",
692                 .start = WM831X_IRQ_UV_DC4,
693                 .end   = WM831X_IRQ_UV_DC4,
694                 .flags = IORESOURCE_IRQ,
695         },
696 };
697
698 static struct resource wm831x_gpio_resources[] = {
699         {
700                 .start = WM831X_IRQ_GPIO_1,
701                 .end   = WM831X_IRQ_GPIO_16,
702                 .flags = IORESOURCE_IRQ,
703         },
704 };
705
706 static struct resource wm831x_isink1_resources[] = {
707         {
708                 .start = WM831X_CURRENT_SINK_1,
709                 .end   = WM831X_CURRENT_SINK_1,
710                 .flags = IORESOURCE_IO,
711         },
712         {
713                 .start = WM831X_IRQ_CS1,
714                 .end   = WM831X_IRQ_CS1,
715                 .flags = IORESOURCE_IRQ,
716         },
717 };
718
719 static struct resource wm831x_isink2_resources[] = {
720         {
721                 .start = WM831X_CURRENT_SINK_2,
722                 .end   = WM831X_CURRENT_SINK_2,
723                 .flags = IORESOURCE_IO,
724         },
725         {
726                 .start = WM831X_IRQ_CS2,
727                 .end   = WM831X_IRQ_CS2,
728                 .flags = IORESOURCE_IRQ,
729         },
730 };
731
732 static struct resource wm831x_ldo1_resources[] = {
733         {
734                 .start = WM831X_LDO1_CONTROL,
735                 .end   = WM831X_LDO1_SLEEP_CONTROL,
736                 .flags = IORESOURCE_IO,
737         },
738         {
739                 .name  = "UV",
740                 .start = WM831X_IRQ_UV_LDO1,
741                 .end   = WM831X_IRQ_UV_LDO1,
742                 .flags = IORESOURCE_IRQ,
743         },
744 };
745
746 static struct resource wm831x_ldo2_resources[] = {
747         {
748                 .start = WM831X_LDO2_CONTROL,
749                 .end   = WM831X_LDO2_SLEEP_CONTROL,
750                 .flags = IORESOURCE_IO,
751         },
752         {
753                 .name  = "UV",
754                 .start = WM831X_IRQ_UV_LDO2,
755                 .end   = WM831X_IRQ_UV_LDO2,
756                 .flags = IORESOURCE_IRQ,
757         },
758 };
759
760 static struct resource wm831x_ldo3_resources[] = {
761         {
762                 .start = WM831X_LDO3_CONTROL,
763                 .end   = WM831X_LDO3_SLEEP_CONTROL,
764                 .flags = IORESOURCE_IO,
765         },
766         {
767                 .name  = "UV",
768                 .start = WM831X_IRQ_UV_LDO3,
769                 .end   = WM831X_IRQ_UV_LDO3,
770                 .flags = IORESOURCE_IRQ,
771         },
772 };
773
774 static struct resource wm831x_ldo4_resources[] = {
775         {
776                 .start = WM831X_LDO4_CONTROL,
777                 .end   = WM831X_LDO4_SLEEP_CONTROL,
778                 .flags = IORESOURCE_IO,
779         },
780         {
781                 .name  = "UV",
782                 .start = WM831X_IRQ_UV_LDO4,
783                 .end   = WM831X_IRQ_UV_LDO4,
784                 .flags = IORESOURCE_IRQ,
785         },
786 };
787
788 static struct resource wm831x_ldo5_resources[] = {
789         {
790                 .start = WM831X_LDO5_CONTROL,
791                 .end   = WM831X_LDO5_SLEEP_CONTROL,
792                 .flags = IORESOURCE_IO,
793         },
794         {
795                 .name  = "UV",
796                 .start = WM831X_IRQ_UV_LDO5,
797                 .end   = WM831X_IRQ_UV_LDO5,
798                 .flags = IORESOURCE_IRQ,
799         },
800 };
801
802 static struct resource wm831x_ldo6_resources[] = {
803         {
804                 .start = WM831X_LDO6_CONTROL,
805                 .end   = WM831X_LDO6_SLEEP_CONTROL,
806                 .flags = IORESOURCE_IO,
807         },
808         {
809                 .name  = "UV",
810                 .start = WM831X_IRQ_UV_LDO6,
811                 .end   = WM831X_IRQ_UV_LDO6,
812                 .flags = IORESOURCE_IRQ,
813         },
814 };
815
816 static struct resource wm831x_ldo7_resources[] = {
817         {
818                 .start = WM831X_LDO7_CONTROL,
819                 .end   = WM831X_LDO7_SLEEP_CONTROL,
820                 .flags = IORESOURCE_IO,
821         },
822         {
823                 .name  = "UV",
824                 .start = WM831X_IRQ_UV_LDO7,
825                 .end   = WM831X_IRQ_UV_LDO7,
826                 .flags = IORESOURCE_IRQ,
827         },
828 };
829
830 static struct resource wm831x_ldo8_resources[] = {
831         {
832                 .start = WM831X_LDO8_CONTROL,
833                 .end   = WM831X_LDO8_SLEEP_CONTROL,
834                 .flags = IORESOURCE_IO,
835         },
836         {
837                 .name  = "UV",
838                 .start = WM831X_IRQ_UV_LDO8,
839                 .end   = WM831X_IRQ_UV_LDO8,
840                 .flags = IORESOURCE_IRQ,
841         },
842 };
843
844 static struct resource wm831x_ldo9_resources[] = {
845         {
846                 .start = WM831X_LDO9_CONTROL,
847                 .end   = WM831X_LDO9_SLEEP_CONTROL,
848                 .flags = IORESOURCE_IO,
849         },
850         {
851                 .name  = "UV",
852                 .start = WM831X_IRQ_UV_LDO9,
853                 .end   = WM831X_IRQ_UV_LDO9,
854                 .flags = IORESOURCE_IRQ,
855         },
856 };
857
858 static struct resource wm831x_ldo10_resources[] = {
859         {
860                 .start = WM831X_LDO10_CONTROL,
861                 .end   = WM831X_LDO10_SLEEP_CONTROL,
862                 .flags = IORESOURCE_IO,
863         },
864         {
865                 .name  = "UV",
866                 .start = WM831X_IRQ_UV_LDO10,
867                 .end   = WM831X_IRQ_UV_LDO10,
868                 .flags = IORESOURCE_IRQ,
869         },
870 };
871
872 static struct resource wm831x_ldo11_resources[] = {
873         {
874                 .start = WM831X_LDO11_ON_CONTROL,
875                 .end   = WM831X_LDO11_SLEEP_CONTROL,
876                 .flags = IORESOURCE_IO,
877         },
878 };
879
880 static struct resource wm831x_on_resources[] = {
881         {
882                 .start = WM831X_IRQ_ON,
883                 .end   = WM831X_IRQ_ON,
884                 .flags = IORESOURCE_IRQ,
885         },
886 };
887
888
889 static struct resource wm831x_power_resources[] = {
890         {
891                 .name = "SYSLO",
892                 .start = WM831X_IRQ_PPM_SYSLO,
893                 .end   = WM831X_IRQ_PPM_SYSLO,
894                 .flags = IORESOURCE_IRQ,
895         },
896         {
897                 .name = "PWR SRC",
898                 .start = WM831X_IRQ_PPM_PWR_SRC,
899                 .end   = WM831X_IRQ_PPM_PWR_SRC,
900                 .flags = IORESOURCE_IRQ,
901         },
902         {
903                 .name = "USB CURR",
904                 .start = WM831X_IRQ_PPM_USB_CURR,
905                 .end   = WM831X_IRQ_PPM_USB_CURR,
906                 .flags = IORESOURCE_IRQ,
907         },
908         {
909                 .name = "BATT HOT",
910                 .start = WM831X_IRQ_CHG_BATT_HOT,
911                 .end   = WM831X_IRQ_CHG_BATT_HOT,
912                 .flags = IORESOURCE_IRQ,
913         },
914         {
915                 .name = "BATT COLD",
916                 .start = WM831X_IRQ_CHG_BATT_COLD,
917                 .end   = WM831X_IRQ_CHG_BATT_COLD,
918                 .flags = IORESOURCE_IRQ,
919         },
920         {
921                 .name = "BATT FAIL",
922                 .start = WM831X_IRQ_CHG_BATT_FAIL,
923                 .end   = WM831X_IRQ_CHG_BATT_FAIL,
924                 .flags = IORESOURCE_IRQ,
925         },
926         {
927                 .name = "OV",
928                 .start = WM831X_IRQ_CHG_OV,
929                 .end   = WM831X_IRQ_CHG_OV,
930                 .flags = IORESOURCE_IRQ,
931         },
932         {
933                 .name = "END",
934                 .start = WM831X_IRQ_CHG_END,
935                 .end   = WM831X_IRQ_CHG_END,
936                 .flags = IORESOURCE_IRQ,
937         },
938         {
939                 .name = "TO",
940                 .start = WM831X_IRQ_CHG_TO,
941                 .end   = WM831X_IRQ_CHG_TO,
942                 .flags = IORESOURCE_IRQ,
943         },
944         {
945                 .name = "MODE",
946                 .start = WM831X_IRQ_CHG_MODE,
947                 .end   = WM831X_IRQ_CHG_MODE,
948                 .flags = IORESOURCE_IRQ,
949         },
950         {
951                 .name = "START",
952                 .start = WM831X_IRQ_CHG_START,
953                 .end   = WM831X_IRQ_CHG_START,
954                 .flags = IORESOURCE_IRQ,
955         },
956 };
957
958 static struct resource wm831x_rtc_resources[] = {
959         {
960                 .name = "PER",
961                 .start = WM831X_IRQ_RTC_PER,
962                 .end   = WM831X_IRQ_RTC_PER,
963                 .flags = IORESOURCE_IRQ,
964         },
965         {
966                 .name = "ALM",
967                 .start = WM831X_IRQ_RTC_ALM,
968                 .end   = WM831X_IRQ_RTC_ALM,
969                 .flags = IORESOURCE_IRQ,
970         },
971 };
972
973 static struct resource wm831x_status1_resources[] = {
974         {
975                 .start = WM831X_STATUS_LED_1,
976                 .end   = WM831X_STATUS_LED_1,
977                 .flags = IORESOURCE_IO,
978         },
979 };
980
981 static struct resource wm831x_status2_resources[] = {
982         {
983                 .start = WM831X_STATUS_LED_2,
984                 .end   = WM831X_STATUS_LED_2,
985                 .flags = IORESOURCE_IO,
986         },
987 };
988
989 static struct resource wm831x_touch_resources[] = {
990         {
991                 .name = "TCHPD",
992                 .start = WM831X_IRQ_TCHPD,
993                 .end   = WM831X_IRQ_TCHPD,
994                 .flags = IORESOURCE_IRQ,
995         },
996         {
997                 .name = "TCHDATA",
998                 .start = WM831X_IRQ_TCHDATA,
999                 .end   = WM831X_IRQ_TCHDATA,
1000                 .flags = IORESOURCE_IRQ,
1001         },
1002 };
1003
1004 static struct resource wm831x_wdt_resources[] = {
1005         {
1006                 .start = WM831X_IRQ_WDOG_TO,
1007                 .end   = WM831X_IRQ_WDOG_TO,
1008                 .flags = IORESOURCE_IRQ,
1009         },
1010 };
1011
1012 static struct mfd_cell wm8310_devs[] = {
1013         {
1014                 .name = "wm831x-backup",
1015         },
1016         {
1017                 .name = "wm831x-buckv",
1018                 .id = 1,
1019                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1020                 .resources = wm831x_dcdc1_resources,
1021         },
1022         {
1023                 .name = "wm831x-buckv",
1024                 .id = 2,
1025                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1026                 .resources = wm831x_dcdc2_resources,
1027         },
1028         {
1029                 .name = "wm831x-buckp",
1030                 .id = 3,
1031                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1032                 .resources = wm831x_dcdc3_resources,
1033         },
1034         {
1035                 .name = "wm831x-boostp",
1036                 .id = 4,
1037                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1038                 .resources = wm831x_dcdc4_resources,
1039         },
1040         {
1041                 .name = "wm831x-clk",
1042         },
1043         {
1044                 .name = "wm831x-epe",
1045                 .id = 1,
1046         },
1047         {
1048                 .name = "wm831x-epe",
1049                 .id = 2,
1050         },
1051         {
1052                 .name = "wm831x-gpio",
1053                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1054                 .resources = wm831x_gpio_resources,
1055         },
1056         {
1057                 .name = "wm831x-hwmon",
1058         },
1059         {
1060                 .name = "wm831x-isink",
1061                 .id = 1,
1062                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1063                 .resources = wm831x_isink1_resources,
1064         },
1065         {
1066                 .name = "wm831x-isink",
1067                 .id = 2,
1068                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1069                 .resources = wm831x_isink2_resources,
1070         },
1071         {
1072                 .name = "wm831x-ldo",
1073                 .id = 1,
1074                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1075                 .resources = wm831x_ldo1_resources,
1076         },
1077         {
1078                 .name = "wm831x-ldo",
1079                 .id = 2,
1080                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1081                 .resources = wm831x_ldo2_resources,
1082         },
1083         {
1084                 .name = "wm831x-ldo",
1085                 .id = 3,
1086                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1087                 .resources = wm831x_ldo3_resources,
1088         },
1089         {
1090                 .name = "wm831x-ldo",
1091                 .id = 4,
1092                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1093                 .resources = wm831x_ldo4_resources,
1094         },
1095         {
1096                 .name = "wm831x-ldo",
1097                 .id = 5,
1098                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1099                 .resources = wm831x_ldo5_resources,
1100         },
1101         {
1102                 .name = "wm831x-ldo",
1103                 .id = 6,
1104                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1105                 .resources = wm831x_ldo6_resources,
1106         },
1107         {
1108                 .name = "wm831x-aldo",
1109                 .id = 7,
1110                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1111                 .resources = wm831x_ldo7_resources,
1112         },
1113         {
1114                 .name = "wm831x-aldo",
1115                 .id = 8,
1116                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1117                 .resources = wm831x_ldo8_resources,
1118         },
1119         {
1120                 .name = "wm831x-aldo",
1121                 .id = 9,
1122                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1123                 .resources = wm831x_ldo9_resources,
1124         },
1125         {
1126                 .name = "wm831x-aldo",
1127                 .id = 10,
1128                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1129                 .resources = wm831x_ldo10_resources,
1130         },
1131         {
1132                 .name = "wm831x-alive-ldo",
1133                 .id = 11,
1134                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1135                 .resources = wm831x_ldo11_resources,
1136         },
1137         {
1138                 .name = "wm831x-on",
1139                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1140                 .resources = wm831x_on_resources,
1141         },
1142         {
1143                 .name = "wm831x-power",
1144                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1145                 .resources = wm831x_power_resources,
1146         },
1147         {
1148                 .name = "wm831x-status",
1149                 .id = 1,
1150                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1151                 .resources = wm831x_status1_resources,
1152         },
1153         {
1154                 .name = "wm831x-status",
1155                 .id = 2,
1156                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1157                 .resources = wm831x_status2_resources,
1158         },
1159         {
1160                 .name = "wm831x-watchdog",
1161                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1162                 .resources = wm831x_wdt_resources,
1163         },
1164 };
1165
1166 static struct mfd_cell wm8311_devs[] = {
1167         {
1168                 .name = "wm831x-backup",
1169         },
1170         {
1171                 .name = "wm831x-buckv",
1172                 .id = 1,
1173                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1174                 .resources = wm831x_dcdc1_resources,
1175         },
1176         {
1177                 .name = "wm831x-buckv",
1178                 .id = 2,
1179                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1180                 .resources = wm831x_dcdc2_resources,
1181         },
1182         {
1183                 .name = "wm831x-buckp",
1184                 .id = 3,
1185                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1186                 .resources = wm831x_dcdc3_resources,
1187         },
1188         {
1189                 .name = "wm831x-boostp",
1190                 .id = 4,
1191                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1192                 .resources = wm831x_dcdc4_resources,
1193         },
1194         {
1195                 .name = "wm831x-clk",
1196         },
1197         {
1198                 .name = "wm831x-epe",
1199                 .id = 1,
1200         },
1201         {
1202                 .name = "wm831x-epe",
1203                 .id = 2,
1204         },
1205         {
1206                 .name = "wm831x-gpio",
1207                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1208                 .resources = wm831x_gpio_resources,
1209         },
1210         {
1211                 .name = "wm831x-hwmon",
1212         },
1213         {
1214                 .name = "wm831x-isink",
1215                 .id = 1,
1216                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1217                 .resources = wm831x_isink1_resources,
1218         },
1219         {
1220                 .name = "wm831x-isink",
1221                 .id = 2,
1222                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1223                 .resources = wm831x_isink2_resources,
1224         },
1225         {
1226                 .name = "wm831x-ldo",
1227                 .id = 1,
1228                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1229                 .resources = wm831x_ldo1_resources,
1230         },
1231         {
1232                 .name = "wm831x-ldo",
1233                 .id = 2,
1234                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1235                 .resources = wm831x_ldo2_resources,
1236         },
1237         {
1238                 .name = "wm831x-ldo",
1239                 .id = 3,
1240                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1241                 .resources = wm831x_ldo3_resources,
1242         },
1243         {
1244                 .name = "wm831x-ldo",
1245                 .id = 4,
1246                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1247                 .resources = wm831x_ldo4_resources,
1248         },
1249         {
1250                 .name = "wm831x-ldo",
1251                 .id = 5,
1252                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1253                 .resources = wm831x_ldo5_resources,
1254         },
1255         {
1256                 .name = "wm831x-aldo",
1257                 .id = 7,
1258                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1259                 .resources = wm831x_ldo7_resources,
1260         },
1261         {
1262                 .name = "wm831x-alive-ldo",
1263                 .id = 11,
1264                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1265                 .resources = wm831x_ldo11_resources,
1266         },
1267         {
1268                 .name = "wm831x-on",
1269                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1270                 .resources = wm831x_on_resources,
1271         },
1272         {
1273                 .name = "wm831x-power",
1274                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1275                 .resources = wm831x_power_resources,
1276         },
1277         {
1278                 .name = "wm831x-status",
1279                 .id = 1,
1280                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1281                 .resources = wm831x_status1_resources,
1282         },
1283         {
1284                 .name = "wm831x-status",
1285                 .id = 2,
1286                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1287                 .resources = wm831x_status2_resources,
1288         },
1289         {
1290                 .name = "wm831x-watchdog",
1291                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1292                 .resources = wm831x_wdt_resources,
1293         },
1294 };
1295
1296 static struct mfd_cell wm8312_devs[] = {
1297         {
1298                 .name = "wm831x-backup",
1299         },
1300         {
1301                 .name = "wm831x-buckv",
1302                 .id = 1,
1303                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1304                 .resources = wm831x_dcdc1_resources,
1305         },
1306         {
1307                 .name = "wm831x-buckv",
1308                 .id = 2,
1309                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1310                 .resources = wm831x_dcdc2_resources,
1311         },
1312         {
1313                 .name = "wm831x-buckp",
1314                 .id = 3,
1315                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1316                 .resources = wm831x_dcdc3_resources,
1317         },
1318         {
1319                 .name = "wm831x-boostp",
1320                 .id = 4,
1321                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1322                 .resources = wm831x_dcdc4_resources,
1323         },
1324         {
1325                 .name = "wm831x-clk",
1326         },
1327         {
1328                 .name = "wm831x-epe",
1329                 .id = 1,
1330         },
1331         {
1332                 .name = "wm831x-epe",
1333                 .id = 2,
1334         },
1335         {
1336                 .name = "wm831x-gpio",
1337                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1338                 .resources = wm831x_gpio_resources,
1339         },
1340         {
1341                 .name = "wm831x-hwmon",
1342         },
1343         {
1344                 .name = "wm831x-isink",
1345                 .id = 1,
1346                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1347                 .resources = wm831x_isink1_resources,
1348         },
1349         {
1350                 .name = "wm831x-isink",
1351                 .id = 2,
1352                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1353                 .resources = wm831x_isink2_resources,
1354         },
1355         {
1356                 .name = "wm831x-ldo",
1357                 .id = 1,
1358                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1359                 .resources = wm831x_ldo1_resources,
1360         },
1361         {
1362                 .name = "wm831x-ldo",
1363                 .id = 2,
1364                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1365                 .resources = wm831x_ldo2_resources,
1366         },
1367         {
1368                 .name = "wm831x-ldo",
1369                 .id = 3,
1370                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1371                 .resources = wm831x_ldo3_resources,
1372         },
1373         {
1374                 .name = "wm831x-ldo",
1375                 .id = 4,
1376                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1377                 .resources = wm831x_ldo4_resources,
1378         },
1379         {
1380                 .name = "wm831x-ldo",
1381                 .id = 5,
1382                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1383                 .resources = wm831x_ldo5_resources,
1384         },
1385         {
1386                 .name = "wm831x-ldo",
1387                 .id = 6,
1388                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1389                 .resources = wm831x_ldo6_resources,
1390         },
1391         {
1392                 .name = "wm831x-aldo",
1393                 .id = 7,
1394                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1395                 .resources = wm831x_ldo7_resources,
1396         },
1397         {
1398                 .name = "wm831x-aldo",
1399                 .id = 8,
1400                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1401                 .resources = wm831x_ldo8_resources,
1402         },
1403         {
1404                 .name = "wm831x-aldo",
1405                 .id = 9,
1406                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1407                 .resources = wm831x_ldo9_resources,
1408         },
1409         {
1410                 .name = "wm831x-aldo",
1411                 .id = 10,
1412                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1413                 .resources = wm831x_ldo10_resources,
1414         },
1415         {
1416                 .name = "wm831x-alive-ldo",
1417                 .id = 11,
1418                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1419                 .resources = wm831x_ldo11_resources,
1420         },
1421         {
1422                 .name = "wm831x-on",
1423                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1424                 .resources = wm831x_on_resources,
1425         },
1426         {
1427                 .name = "wm831x-power",
1428                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1429                 .resources = wm831x_power_resources,
1430         },
1431         {
1432                 .name = "wm831x-status",
1433                 .id = 1,
1434                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1435                 .resources = wm831x_status1_resources,
1436         },
1437         {
1438                 .name = "wm831x-status",
1439                 .id = 2,
1440                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1441                 .resources = wm831x_status2_resources,
1442         },
1443         {
1444                 .name = "wm831x-watchdog",
1445                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1446                 .resources = wm831x_wdt_resources,
1447         },
1448 };
1449
1450 static struct mfd_cell wm8320_devs[] = {
1451         {
1452                 .name = "wm831x-backup",
1453         },
1454         {
1455                 .name = "wm831x-buckv",
1456                 .id = 1,
1457                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1458                 .resources = wm831x_dcdc1_resources,
1459         },
1460         {
1461                 .name = "wm831x-buckv",
1462                 .id = 2,
1463                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1464                 .resources = wm831x_dcdc2_resources,
1465         },
1466         {
1467                 .name = "wm831x-buckp",
1468                 .id = 3,
1469                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1470                 .resources = wm831x_dcdc3_resources,
1471         },
1472         {
1473                 .name = "wm831x-buckp",
1474                 .id = 4,
1475                 .num_resources = ARRAY_SIZE(wm8320_dcdc4_buck_resources),
1476                 .resources = wm8320_dcdc4_buck_resources,
1477         },
1478         {
1479                 .name = "wm831x-clk",
1480         },
1481         {
1482                 .name = "wm831x-gpio",
1483                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1484                 .resources = wm831x_gpio_resources,
1485         },
1486         {
1487                 .name = "wm831x-hwmon",
1488         },
1489         {
1490                 .name = "wm831x-ldo",
1491                 .id = 1,
1492                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1493                 .resources = wm831x_ldo1_resources,
1494         },
1495         {
1496                 .name = "wm831x-ldo",
1497                 .id = 2,
1498                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1499                 .resources = wm831x_ldo2_resources,
1500         },
1501         {
1502                 .name = "wm831x-ldo",
1503                 .id = 3,
1504                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1505                 .resources = wm831x_ldo3_resources,
1506         },
1507         {
1508                 .name = "wm831x-ldo",
1509                 .id = 4,
1510                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1511                 .resources = wm831x_ldo4_resources,
1512         },
1513         {
1514                 .name = "wm831x-ldo",
1515                 .id = 5,
1516                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1517                 .resources = wm831x_ldo5_resources,
1518         },
1519         {
1520                 .name = "wm831x-ldo",
1521                 .id = 6,
1522                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1523                 .resources = wm831x_ldo6_resources,
1524         },
1525         {
1526                 .name = "wm831x-aldo",
1527                 .id = 7,
1528                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1529                 .resources = wm831x_ldo7_resources,
1530         },
1531         {
1532                 .name = "wm831x-aldo",
1533                 .id = 8,
1534                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1535                 .resources = wm831x_ldo8_resources,
1536         },
1537         {
1538                 .name = "wm831x-aldo",
1539                 .id = 9,
1540                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1541                 .resources = wm831x_ldo9_resources,
1542         },
1543         {
1544                 .name = "wm831x-aldo",
1545                 .id = 10,
1546                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1547                 .resources = wm831x_ldo10_resources,
1548         },
1549         {
1550                 .name = "wm831x-alive-ldo",
1551                 .id = 11,
1552                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1553                 .resources = wm831x_ldo11_resources,
1554         },
1555         {
1556                 .name = "wm831x-on",
1557                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1558                 .resources = wm831x_on_resources,
1559         },
1560         {
1561                 .name = "wm831x-status",
1562                 .id = 1,
1563                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1564                 .resources = wm831x_status1_resources,
1565         },
1566         {
1567                 .name = "wm831x-status",
1568                 .id = 2,
1569                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1570                 .resources = wm831x_status2_resources,
1571         },
1572         {
1573                 .name = "wm831x-watchdog",
1574                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1575                 .resources = wm831x_wdt_resources,
1576         },
1577 };
1578
1579 static struct mfd_cell touch_devs[] = {
1580         {
1581                 .name = "wm831x-touch",
1582                 .num_resources = ARRAY_SIZE(wm831x_touch_resources),
1583                 .resources = wm831x_touch_resources,
1584         },
1585 };
1586
1587 static struct mfd_cell rtc_devs[] = {
1588         {
1589                 .name = "wm831x-rtc",
1590                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
1591                 .resources = wm831x_rtc_resources,
1592         },
1593 };
1594
1595 static struct mfd_cell backlight_devs[] = {
1596         {
1597                 .name = "wm831x-backlight",
1598         },
1599 };
1600
1601 struct regmap_config wm831x_regmap_config = {
1602         .reg_bits = 16,
1603         .val_bits = 16,
1604
1605         .cache_type = REGCACHE_RBTREE,
1606
1607         .max_register = WM831X_DBE_CHECK_DATA,
1608         .readable_reg = wm831x_reg_readable,
1609         .writeable_reg = wm831x_reg_writeable,
1610         .volatile_reg = wm831x_reg_volatile,
1611 };
1612 EXPORT_SYMBOL_GPL(wm831x_regmap_config);
1613
1614 /*
1615  * Instantiate the generic non-control parts of the device.
1616  */
1617 int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
1618 {
1619         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
1620         int rev, wm831x_num;
1621         enum wm831x_parent parent;
1622         int ret, i;
1623
1624         mutex_init(&wm831x->io_lock);
1625         mutex_init(&wm831x->key_lock);
1626         dev_set_drvdata(wm831x->dev, wm831x);
1627         wm831x->soft_shutdown = pdata->soft_shutdown;
1628
1629         ret = wm831x_reg_read(wm831x, WM831X_PARENT_ID);
1630         if (ret < 0) {
1631                 dev_err(wm831x->dev, "Failed to read parent ID: %d\n", ret);
1632                 goto err_regmap;
1633         }
1634         switch (ret) {
1635         case 0x6204:
1636         case 0x6246:
1637                 break;
1638         default:
1639                 dev_err(wm831x->dev, "Device is not a WM831x: ID %x\n", ret);
1640                 ret = -EINVAL;
1641                 goto err_regmap;
1642         }
1643
1644         ret = wm831x_reg_read(wm831x, WM831X_REVISION);
1645         if (ret < 0) {
1646                 dev_err(wm831x->dev, "Failed to read revision: %d\n", ret);
1647                 goto err_regmap;
1648         }
1649         rev = (ret & WM831X_PARENT_REV_MASK) >> WM831X_PARENT_REV_SHIFT;
1650
1651         ret = wm831x_reg_read(wm831x, WM831X_RESET_ID);
1652         if (ret < 0) {
1653                 dev_err(wm831x->dev, "Failed to read device ID: %d\n", ret);
1654                 goto err_regmap;
1655         }
1656
1657         /* Some engineering samples do not have the ID set, rely on
1658          * the device being registered correctly.
1659          */
1660         if (ret == 0) {
1661                 dev_info(wm831x->dev, "Device is an engineering sample\n");
1662                 ret = id;
1663         }
1664
1665         switch (ret) {
1666         case WM8310:
1667                 parent = WM8310;
1668                 wm831x->num_gpio = 16;
1669                 wm831x->charger_irq_wake = 1;
1670                 if (rev > 0) {
1671                         wm831x->has_gpio_ena = 1;
1672                         wm831x->has_cs_sts = 1;
1673                 }
1674
1675                 dev_info(wm831x->dev, "WM8310 revision %c\n", 'A' + rev);
1676                 break;
1677
1678         case WM8311:
1679                 parent = WM8311;
1680                 wm831x->num_gpio = 16;
1681                 wm831x->charger_irq_wake = 1;
1682                 if (rev > 0) {
1683                         wm831x->has_gpio_ena = 1;
1684                         wm831x->has_cs_sts = 1;
1685                 }
1686
1687                 dev_info(wm831x->dev, "WM8311 revision %c\n", 'A' + rev);
1688                 break;
1689
1690         case WM8312:
1691                 parent = WM8312;
1692                 wm831x->num_gpio = 16;
1693                 wm831x->charger_irq_wake = 1;
1694                 if (rev > 0) {
1695                         wm831x->has_gpio_ena = 1;
1696                         wm831x->has_cs_sts = 1;
1697                 }
1698
1699                 dev_info(wm831x->dev, "WM8312 revision %c\n", 'A' + rev);
1700                 break;
1701
1702         case WM8320:
1703                 parent = WM8320;
1704                 wm831x->num_gpio = 12;
1705                 dev_info(wm831x->dev, "WM8320 revision %c\n", 'A' + rev);
1706                 break;
1707
1708         case WM8321:
1709                 parent = WM8321;
1710                 wm831x->num_gpio = 12;
1711                 dev_info(wm831x->dev, "WM8321 revision %c\n", 'A' + rev);
1712                 break;
1713
1714         case WM8325:
1715                 parent = WM8325;
1716                 wm831x->num_gpio = 12;
1717                 dev_info(wm831x->dev, "WM8325 revision %c\n", 'A' + rev);
1718                 break;
1719
1720         case WM8326:
1721                 parent = WM8326;
1722                 wm831x->num_gpio = 12;
1723                 dev_info(wm831x->dev, "WM8326 revision %c\n", 'A' + rev);
1724                 break;
1725
1726         default:
1727                 dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret);
1728                 ret = -EINVAL;
1729                 goto err_regmap;
1730         }
1731
1732         /* This will need revisiting in future but is OK for all
1733          * current parts.
1734          */
1735         if (parent != id)
1736                 dev_warn(wm831x->dev, "Device was registered as a WM%lx\n",
1737                          id);
1738
1739         /* Bootstrap the user key */
1740         ret = wm831x_reg_read(wm831x, WM831X_SECURITY_KEY);
1741         if (ret < 0) {
1742                 dev_err(wm831x->dev, "Failed to read security key: %d\n", ret);
1743                 goto err_regmap;
1744         }
1745         if (ret != 0) {
1746                 dev_warn(wm831x->dev, "Security key had non-zero value %x\n",
1747                          ret);
1748                 wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
1749         }
1750         wm831x->locked = 1;
1751
1752         if (pdata && pdata->pre_init) {
1753                 ret = pdata->pre_init(wm831x);
1754                 if (ret != 0) {
1755                         dev_err(wm831x->dev, "pre_init() failed: %d\n", ret);
1756                         goto err_regmap;
1757                 }
1758         }
1759
1760         if (pdata) {
1761                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
1762                         if (!pdata->gpio_defaults[i])
1763                                 continue;
1764
1765                         wm831x_reg_write(wm831x,
1766                                          WM831X_GPIO1_CONTROL + i,
1767                                          pdata->gpio_defaults[i] & 0xffff);
1768                 }
1769         }
1770
1771         /* Multiply by 10 as we have many subdevices of the same type */
1772         if (pdata && pdata->wm831x_num)
1773                 wm831x_num = pdata->wm831x_num * 10;
1774         else
1775                 wm831x_num = -1;
1776
1777         ret = wm831x_irq_init(wm831x, irq);
1778         if (ret != 0)
1779                 goto err_regmap;
1780
1781         wm831x_auxadc_init(wm831x);
1782
1783         /* The core device is up, instantiate the subdevices. */
1784         switch (parent) {
1785         case WM8310:
1786                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1787                                       wm8310_devs, ARRAY_SIZE(wm8310_devs),
1788                                       NULL, wm831x->irq_base);
1789                 break;
1790
1791         case WM8311:
1792                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1793                                       wm8311_devs, ARRAY_SIZE(wm8311_devs),
1794                                       NULL, wm831x->irq_base);
1795                 if (!pdata || !pdata->disable_touch)
1796                         mfd_add_devices(wm831x->dev, wm831x_num,
1797                                         touch_devs, ARRAY_SIZE(touch_devs),
1798                                         NULL, wm831x->irq_base);
1799                 break;
1800
1801         case WM8312:
1802                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1803                                       wm8312_devs, ARRAY_SIZE(wm8312_devs),
1804                                       NULL, wm831x->irq_base);
1805                 if (!pdata || !pdata->disable_touch)
1806                         mfd_add_devices(wm831x->dev, wm831x_num,
1807                                         touch_devs, ARRAY_SIZE(touch_devs),
1808                                         NULL, wm831x->irq_base);
1809                 break;
1810
1811         case WM8320:
1812         case WM8321:
1813         case WM8325:
1814         case WM8326:
1815                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1816                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
1817                                       NULL, wm831x->irq_base);
1818                 break;
1819
1820         default:
1821                 /* If this happens the bus probe function is buggy */
1822                 BUG();
1823         }
1824
1825         if (ret != 0) {
1826                 dev_err(wm831x->dev, "Failed to add children\n");
1827                 goto err_irq;
1828         }
1829
1830         /* The RTC can only be used if the 32.768kHz crystal is
1831          * enabled; this can't be controlled by software at runtime.
1832          */
1833         ret = wm831x_reg_read(wm831x, WM831X_CLOCK_CONTROL_2);
1834         if (ret < 0) {
1835                 dev_err(wm831x->dev, "Failed to read clock status: %d\n", ret);
1836                 goto err_irq;
1837         }
1838
1839         if (ret & WM831X_XTAL_ENA) {
1840                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1841                                       rtc_devs, ARRAY_SIZE(rtc_devs),
1842                                       NULL, wm831x->irq_base);
1843                 if (ret != 0) {
1844                         dev_err(wm831x->dev, "Failed to add RTC: %d\n", ret);
1845                         goto err_irq;
1846                 }
1847         } else {
1848                 dev_info(wm831x->dev, "32.768kHz clock disabled, no RTC\n");
1849         }
1850
1851         if (pdata && pdata->backlight) {
1852                 /* Treat errors as non-critical */
1853                 ret = mfd_add_devices(wm831x->dev, wm831x_num, backlight_devs,
1854                                       ARRAY_SIZE(backlight_devs), NULL,
1855                                       wm831x->irq_base);
1856                 if (ret < 0)
1857                         dev_err(wm831x->dev, "Failed to add backlight: %d\n",
1858                                 ret);
1859         }
1860
1861         wm831x_otp_init(wm831x);
1862
1863         if (pdata && pdata->post_init) {
1864                 ret = pdata->post_init(wm831x);
1865                 if (ret != 0) {
1866                         dev_err(wm831x->dev, "post_init() failed: %d\n", ret);
1867                         goto err_irq;
1868                 }
1869         }
1870
1871         return 0;
1872
1873 err_irq:
1874         wm831x_irq_exit(wm831x);
1875 err_regmap:
1876         mfd_remove_devices(wm831x->dev);
1877         regmap_exit(wm831x->regmap);
1878         kfree(wm831x);
1879         return ret;
1880 }
1881
1882 void wm831x_device_exit(struct wm831x *wm831x)
1883 {
1884         wm831x_otp_exit(wm831x);
1885         mfd_remove_devices(wm831x->dev);
1886         if (wm831x->irq_base)
1887                 free_irq(wm831x->irq_base + WM831X_IRQ_AUXADC_DATA, wm831x);
1888         wm831x_irq_exit(wm831x);
1889         regmap_exit(wm831x->regmap);
1890         kfree(wm831x);
1891 }
1892
1893 int wm831x_device_suspend(struct wm831x *wm831x)
1894 {
1895         int reg, mask;
1896
1897         /* If the charger IRQs are a wake source then make sure we ack
1898          * them even if they're not actively being used (eg, no power
1899          * driver or no IRQ line wired up) then acknowledge the
1900          * interrupts otherwise suspend won't last very long.
1901          */
1902         if (wm831x->charger_irq_wake) {
1903                 reg = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_2_MASK);
1904
1905                 mask = WM831X_CHG_BATT_HOT_EINT |
1906                         WM831X_CHG_BATT_COLD_EINT |
1907                         WM831X_CHG_BATT_FAIL_EINT |
1908                         WM831X_CHG_OV_EINT | WM831X_CHG_END_EINT |
1909                         WM831X_CHG_TO_EINT | WM831X_CHG_MODE_EINT |
1910                         WM831X_CHG_START_EINT;
1911
1912                 /* If any of the interrupts are masked read the statuses */
1913                 if (reg & mask)
1914                         reg = wm831x_reg_read(wm831x,
1915                                               WM831X_INTERRUPT_STATUS_2);
1916
1917                 if (reg & mask) {
1918                         dev_info(wm831x->dev,
1919                                  "Acknowledging masked charger IRQs: %x\n",
1920                                  reg & mask);
1921                         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_2,
1922                                          reg & mask);
1923                 }
1924         }
1925
1926         return 0;
1927 }
1928
1929 void wm831x_device_shutdown(struct wm831x *wm831x)
1930 {
1931         if (wm831x->soft_shutdown) {
1932                 dev_info(wm831x->dev, "Initiating shutdown...\n");
1933                 wm831x_set_bits(wm831x, WM831X_POWER_STATE, WM831X_CHIP_ON, 0);
1934         }
1935 }
1936 EXPORT_SYMBOL_GPL(wm831x_device_shutdown);
1937
1938 MODULE_DESCRIPTION("Core support for the WM831X AudioPlus PMIC");
1939 MODULE_LICENSE("GPL");
1940 MODULE_AUTHOR("Mark Brown");