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