projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'selinux/next'
[deliverable/linux.git] / drivers / mfd / arizona-core.c
1 /*
2 * Arizona core driver
3 *
4 * Copyright 2012 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
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/delay.h>
14 #include <linux/err.h>
15 #include <linux/gpio.h>
16 #include <linux/interrupt.h>
17 #include <linux/mfd/core.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/of_device.h>
21 #include <linux/of_gpio.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/regmap.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/regulator/machine.h>
26 #include <linux/slab.h>
27 #include <linux/platform_device.h>
28
29 #include <linux/mfd/arizona/core.h>
30 #include <linux/mfd/arizona/registers.h>
31
32 #include "arizona.h"
33
34 static const char * const wm5102_core_supplies[] = {
35 "AVDD",
36 "DBVDD1",
37 };
38
39 int arizona_clk32k_enable(struct arizona *arizona)
40 {
41 int ret = 0;
42
43 mutex_lock(&arizona->clk_lock);
44
45 arizona->clk32k_ref++;
46
47 if (arizona->clk32k_ref == 1) {
48 switch (arizona->pdata.clk32k_src) {
49 case ARIZONA_32KZ_MCLK1:
50 ret = pm_runtime_get_sync(arizona->dev);
51 if (ret != 0)
52 goto out;
53 break;
54 }
55
56 ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
57 ARIZONA_CLK_32K_ENA,
58 ARIZONA_CLK_32K_ENA);
59 }
60
61 out:
62 if (ret != 0)
63 arizona->clk32k_ref--;
64
65 mutex_unlock(&arizona->clk_lock);
66
67 return ret;
68 }
69 EXPORT_SYMBOL_GPL(arizona_clk32k_enable);
70
71 int arizona_clk32k_disable(struct arizona *arizona)
72 {
73 mutex_lock(&arizona->clk_lock);
74
75 BUG_ON(arizona->clk32k_ref <= 0);
76
77 arizona->clk32k_ref--;
78
79 if (arizona->clk32k_ref == 0) {
80 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
81 ARIZONA_CLK_32K_ENA, 0);
82
83 switch (arizona->pdata.clk32k_src) {
84 case ARIZONA_32KZ_MCLK1:
85 pm_runtime_put_sync(arizona->dev);
86 break;
87 }
88 }
89
90 mutex_unlock(&arizona->clk_lock);
91
92 return 0;
93 }
94 EXPORT_SYMBOL_GPL(arizona_clk32k_disable);
95
96 static irqreturn_t arizona_clkgen_err(int irq, void *data)
97 {
98 struct arizona *arizona = data;
99
100 dev_err(arizona->dev, "CLKGEN error\n");
101
102 return IRQ_HANDLED;
103 }
104
105 static irqreturn_t arizona_underclocked(int irq, void *data)
106 {
107 struct arizona *arizona = data;
108 unsigned int val;
109 int ret;
110
111 ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8,
112 &val);
113 if (ret != 0) {
114 dev_err(arizona->dev, "Failed to read underclock status: %d\n",
115 ret);
116 return IRQ_NONE;
117 }
118
119 if (val & ARIZONA_AIF3_UNDERCLOCKED_STS)
120 dev_err(arizona->dev, "AIF3 underclocked\n");
121 if (val & ARIZONA_AIF2_UNDERCLOCKED_STS)
122 dev_err(arizona->dev, "AIF2 underclocked\n");
123 if (val & ARIZONA_AIF1_UNDERCLOCKED_STS)
124 dev_err(arizona->dev, "AIF1 underclocked\n");
125 if (val & ARIZONA_ISRC3_UNDERCLOCKED_STS)
126 dev_err(arizona->dev, "ISRC3 underclocked\n");
127 if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS)
128 dev_err(arizona->dev, "ISRC2 underclocked\n");
129 if (val & ARIZONA_ISRC1_UNDERCLOCKED_STS)
130 dev_err(arizona->dev, "ISRC1 underclocked\n");
131 if (val & ARIZONA_FX_UNDERCLOCKED_STS)
132 dev_err(arizona->dev, "FX underclocked\n");
133 if (val & ARIZONA_ASRC_UNDERCLOCKED_STS)
134 dev_err(arizona->dev, "ASRC underclocked\n");
135 if (val & ARIZONA_DAC_UNDERCLOCKED_STS)
136 dev_err(arizona->dev, "DAC underclocked\n");
137 if (val & ARIZONA_ADC_UNDERCLOCKED_STS)
138 dev_err(arizona->dev, "ADC underclocked\n");
139 if (val & ARIZONA_MIXER_UNDERCLOCKED_STS)
140 dev_err(arizona->dev, "Mixer dropped sample\n");
141
142 return IRQ_HANDLED;
143 }
144
145 static irqreturn_t arizona_overclocked(int irq, void *data)
146 {
147 struct arizona *arizona = data;
148 unsigned int val[3];
149 int ret;
150
151 ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6,
152 &val[0], 3);
153 if (ret != 0) {
154 dev_err(arizona->dev, "Failed to read overclock status: %d\n",
155 ret);
156 return IRQ_NONE;
157 }
158
159 switch (arizona->type) {
160 case WM8998:
161 case WM1814:
162 /* Some bits are shifted on WM8998,
163 * rearrange to match the standard bit layout
164 */
165 val[0] = ((val[0] & 0x60e0) >> 1) |
166 ((val[0] & 0x1e00) >> 2) |
167 (val[0] & 0x000f);
168 break;
169 default:
170 break;
171 }
172
173 if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS)
174 dev_err(arizona->dev, "PWM overclocked\n");
175 if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS)
176 dev_err(arizona->dev, "FX core overclocked\n");
177 if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS)
178 dev_err(arizona->dev, "DAC SYS overclocked\n");
179 if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS)
180 dev_err(arizona->dev, "DAC WARP overclocked\n");
181 if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS)
182 dev_err(arizona->dev, "ADC overclocked\n");
183 if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS)
184 dev_err(arizona->dev, "Mixer overclocked\n");
185 if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS)
186 dev_err(arizona->dev, "AIF3 overclocked\n");
187 if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS)
188 dev_err(arizona->dev, "AIF2 overclocked\n");
189 if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS)
190 dev_err(arizona->dev, "AIF1 overclocked\n");
191 if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS)
192 dev_err(arizona->dev, "Pad control overclocked\n");
193
194 if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS)
195 dev_err(arizona->dev, "Slimbus subsystem overclocked\n");
196 if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS)
197 dev_err(arizona->dev, "Slimbus async overclocked\n");
198 if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS)
199 dev_err(arizona->dev, "Slimbus sync overclocked\n");
200 if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS)
201 dev_err(arizona->dev, "ASRC async system overclocked\n");
202 if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS)
203 dev_err(arizona->dev, "ASRC async WARP overclocked\n");
204 if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS)
205 dev_err(arizona->dev, "ASRC sync system overclocked\n");
206 if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS)
207 dev_err(arizona->dev, "ASRC sync WARP overclocked\n");
208 if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS)
209 dev_err(arizona->dev, "DSP1 overclocked\n");
210 if (val[1] & ARIZONA_ISRC3_OVERCLOCKED_STS)
211 dev_err(arizona->dev, "ISRC3 overclocked\n");
212 if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS)
213 dev_err(arizona->dev, "ISRC2 overclocked\n");
214 if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS)
215 dev_err(arizona->dev, "ISRC1 overclocked\n");
216
217 if (val[2] & ARIZONA_SPDIF_OVERCLOCKED_STS)
218 dev_err(arizona->dev, "SPDIF overclocked\n");
219
220 return IRQ_HANDLED;
221 }
222
223 static int arizona_poll_reg(struct arizona *arizona,
224 int timeout, unsigned int reg,
225 unsigned int mask, unsigned int target)
226 {
227 unsigned int val = 0;
228 int ret, i;
229
230 for (i = 0; i < timeout; i++) {
231 ret = regmap_read(arizona->regmap, reg, &val);
232 if (ret != 0) {
233 dev_err(arizona->dev, "Failed to read reg %u: %d\n",
234 reg, ret);
235 continue;
236 }
237
238 if ((val & mask) == target)
239 return 0;
240
241 usleep_range(1000, 5000);
242 }
243
244 dev_err(arizona->dev, "Polling reg %u timed out: %x\n", reg, val);
245 return -ETIMEDOUT;
246 }
247
248 static int arizona_wait_for_boot(struct arizona *arizona)
249 {
250 int ret;
251
252 /*
253 * We can't use an interrupt as we need to runtime resume to do so,
254 * we won't race with the interrupt handler as it'll be blocked on
255 * runtime resume.
256 */
257 ret = arizona_poll_reg(arizona, 5, ARIZONA_INTERRUPT_RAW_STATUS_5,
258 ARIZONA_BOOT_DONE_STS, ARIZONA_BOOT_DONE_STS);
259
260 if (!ret)
261 regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5,
262 ARIZONA_BOOT_DONE_STS);
263
264 pm_runtime_mark_last_busy(arizona->dev);
265
266 return ret;
267 }
268
269 static inline void arizona_enable_reset(struct arizona *arizona)
270 {
271 if (arizona->pdata.reset)
272 gpio_set_value_cansleep(arizona->pdata.reset, 0);
273 }
274
275 static void arizona_disable_reset(struct arizona *arizona)
276 {
277 if (arizona->pdata.reset) {
278 switch (arizona->type) {
279 case WM5110:
280 case WM8280:
281 /* Meet requirements for minimum reset duration */
282 usleep_range(5000, 10000);
283 break;
284 default:
285 break;
286 }
287
288 gpio_set_value_cansleep(arizona->pdata.reset, 1);
289 usleep_range(1000, 5000);
290 }
291 }
292
293 struct arizona_sysclk_state {
294 unsigned int fll;
295 unsigned int sysclk;
296 };
297
298 static int arizona_enable_freerun_sysclk(struct arizona *arizona,
299 struct arizona_sysclk_state *state)
300 {
301 int ret, err;
302
303 /* Cache existing FLL and SYSCLK settings */
304 ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &state->fll);
305 if (ret) {
306 dev_err(arizona->dev, "Failed to cache FLL settings: %d\n",
307 ret);
308 return ret;
309 }
310 ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
311 &state->sysclk);
312 if (ret) {
313 dev_err(arizona->dev, "Failed to cache SYSCLK settings: %d\n",
314 ret);
315 return ret;
316 }
317
318 /* Start up SYSCLK using the FLL in free running mode */
319 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1,
320 ARIZONA_FLL1_ENA | ARIZONA_FLL1_FREERUN);
321 if (ret) {
322 dev_err(arizona->dev,
323 "Failed to start FLL in freerunning mode: %d\n",
324 ret);
325 return ret;
326 }
327 ret = arizona_poll_reg(arizona, 25, ARIZONA_INTERRUPT_RAW_STATUS_5,
328 ARIZONA_FLL1_CLOCK_OK_STS,
329 ARIZONA_FLL1_CLOCK_OK_STS);
330 if (ret) {
331 ret = -ETIMEDOUT;
332 goto err_fll;
333 }
334
335 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144);
336 if (ret) {
337 dev_err(arizona->dev, "Failed to start SYSCLK: %d\n", ret);
338 goto err_fll;
339 }
340
341 return 0;
342
343 err_fll:
344 err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
345 if (err)
346 dev_err(arizona->dev,
347 "Failed to re-apply old FLL settings: %d\n", err);
348
349 return ret;
350 }
351
352 static int arizona_disable_freerun_sysclk(struct arizona *arizona,
353 struct arizona_sysclk_state *state)
354 {
355 int ret;
356
357 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1,
358 state->sysclk);
359 if (ret) {
360 dev_err(arizona->dev,
361 "Failed to re-apply old SYSCLK settings: %d\n", ret);
362 return ret;
363 }
364
365 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll);
366 if (ret) {
367 dev_err(arizona->dev,
368 "Failed to re-apply old FLL settings: %d\n", ret);
369 return ret;
370 }
371
372 return 0;
373 }
374
375 static int wm5102_apply_hardware_patch(struct arizona *arizona)
376 {
377 struct arizona_sysclk_state state;
378 int err, ret;
379
380 ret = arizona_enable_freerun_sysclk(arizona, &state);
381 if (ret)
382 return ret;
383
384 /* Start the write sequencer and wait for it to finish */
385 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
386 ARIZONA_WSEQ_ENA | ARIZONA_WSEQ_START | 160);
387 if (ret) {
388 dev_err(arizona->dev, "Failed to start write sequencer: %d\n",
389 ret);
390 goto err;
391 }
392
393 ret = arizona_poll_reg(arizona, 5, ARIZONA_WRITE_SEQUENCER_CTRL_1,
394 ARIZONA_WSEQ_BUSY, 0);
395 if (ret) {
396 regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0,
397 ARIZONA_WSEQ_ABORT);
398 ret = -ETIMEDOUT;
399 }
400
401 err:
402 err = arizona_disable_freerun_sysclk(arizona, &state);
403
404 return ret ?: err;
405 }
406
407 /*
408 * Register patch to some of the CODECs internal write sequences
409 * to ensure a clean exit from the low power sleep state.
410 */
411 static const struct reg_sequence wm5110_sleep_patch[] = {
412 { 0x337A, 0xC100 },
413 { 0x337B, 0x0041 },
414 { 0x3300, 0xA210 },
415 { 0x3301, 0x050C },
416 };
417
418 static int wm5110_apply_sleep_patch(struct arizona *arizona)
419 {
420 struct arizona_sysclk_state state;
421 int err, ret;
422
423 ret = arizona_enable_freerun_sysclk(arizona, &state);
424 if (ret)
425 return ret;
426
427 ret = regmap_multi_reg_write_bypassed(arizona->regmap,
428 wm5110_sleep_patch,
429 ARRAY_SIZE(wm5110_sleep_patch));
430
431 err = arizona_disable_freerun_sysclk(arizona, &state);
432
433 return ret ?: err;
434 }
435
436 static int wm5102_clear_write_sequencer(struct arizona *arizona)
437 {
438 int ret;
439
440 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_3,
441 0x0);
442 if (ret) {
443 dev_err(arizona->dev,
444 "Failed to clear write sequencer state: %d\n", ret);
445 return ret;
446 }
447
448 arizona_enable_reset(arizona);
449 regulator_disable(arizona->dcvdd);
450
451 msleep(20);
452
453 ret = regulator_enable(arizona->dcvdd);
454 if (ret) {
455 dev_err(arizona->dev, "Failed to re-enable DCVDD: %d\n", ret);
456 return ret;
457 }
458 arizona_disable_reset(arizona);
459
460 return 0;
461 }
462
463 #ifdef CONFIG_PM
464 static int arizona_isolate_dcvdd(struct arizona *arizona)
465 {
466 int ret;
467
468 ret = regmap_update_bits(arizona->regmap,
469 ARIZONA_ISOLATION_CONTROL,
470 ARIZONA_ISOLATE_DCVDD1,
471 ARIZONA_ISOLATE_DCVDD1);
472 if (ret != 0)
473 dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret);
474
475 return ret;
476 }
477
478 static int arizona_connect_dcvdd(struct arizona *arizona)
479 {
480 int ret;
481
482 ret = regmap_update_bits(arizona->regmap,
483 ARIZONA_ISOLATION_CONTROL,
484 ARIZONA_ISOLATE_DCVDD1, 0);
485 if (ret != 0)
486 dev_err(arizona->dev, "Failed to connect DCVDD: %d\n", ret);
487
488 return ret;
489 }
490
491 static int arizona_is_jack_det_active(struct arizona *arizona)
492 {
493 unsigned int val;
494 int ret;
495
496 ret = regmap_read(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, &val);
497 if (ret) {
498 dev_err(arizona->dev,
499 "Failed to check jack det status: %d\n", ret);
500 return ret;
501 } else if (val & ARIZONA_JD1_ENA) {
502 return 1;
503 } else {
504 return 0;
505 }
506 }
507
508 static int arizona_runtime_resume(struct device *dev)
509 {
510 struct arizona *arizona = dev_get_drvdata(dev);
511 int ret;
512
513 dev_dbg(arizona->dev, "Leaving AoD mode\n");
514
515 if (arizona->has_fully_powered_off) {
516 dev_dbg(arizona->dev, "Re-enabling core supplies\n");
517
518 ret = regulator_bulk_enable(arizona->num_core_supplies,
519 arizona->core_supplies);
520 if (ret) {
521 dev_err(dev, "Failed to enable core supplies: %d\n",
522 ret);
523 return ret;
524 }
525 }
526
527 ret = regulator_enable(arizona->dcvdd);
528 if (ret != 0) {
529 dev_err(arizona->dev, "Failed to enable DCVDD: %d\n", ret);
530 if (arizona->has_fully_powered_off)
531 regulator_bulk_disable(arizona->num_core_supplies,
532 arizona->core_supplies);
533 return ret;
534 }
535
536 if (arizona->has_fully_powered_off) {
537 arizona_disable_reset(arizona);
538 enable_irq(arizona->irq);
539 arizona->has_fully_powered_off = false;
540 }
541
542 regcache_cache_only(arizona->regmap, false);
543
544 switch (arizona->type) {
545 case WM5102:
546 if (arizona->external_dcvdd) {
547 ret = arizona_connect_dcvdd(arizona);
548 if (ret != 0)
549 goto err;
550 }
551
552 ret = wm5102_patch(arizona);
553 if (ret != 0) {
554 dev_err(arizona->dev, "Failed to apply patch: %d\n",
555 ret);
556 goto err;
557 }
558
559 ret = wm5102_apply_hardware_patch(arizona);
560 if (ret) {
561 dev_err(arizona->dev,
562 "Failed to apply hardware patch: %d\n",
563 ret);
564 goto err;
565 }
566 break;
567 case WM5110:
568 case WM8280:
569 ret = arizona_wait_for_boot(arizona);
570 if (ret)
571 goto err;
572
573 if (arizona->external_dcvdd) {
574 ret = arizona_connect_dcvdd(arizona);
575 if (ret != 0)
576 goto err;
577 } else {
578 /*
579 * As this is only called for the internal regulator
580 * (where we know voltage ranges available) it is ok
581 * to request an exact range.
582 */
583 ret = regulator_set_voltage(arizona->dcvdd,
584 1200000, 1200000);
585 if (ret < 0) {
586 dev_err(arizona->dev,
587 "Failed to set resume voltage: %d\n",
588 ret);
589 goto err;
590 }
591 }
592
593 ret = wm5110_apply_sleep_patch(arizona);
594 if (ret) {
595 dev_err(arizona->dev,
596 "Failed to re-apply sleep patch: %d\n",
597 ret);
598 goto err;
599 }
600 break;
601 case WM1831:
602 case CS47L24:
603 ret = arizona_wait_for_boot(arizona);
604 if (ret != 0)
605 goto err;
606 break;
607 default:
608 ret = arizona_wait_for_boot(arizona);
609 if (ret != 0)
610 goto err;
611
612 if (arizona->external_dcvdd) {
613 ret = arizona_connect_dcvdd(arizona);
614 if (ret != 0)
615 goto err;
616 }
617 break;
618 }
619
620 ret = regcache_sync(arizona->regmap);
621 if (ret != 0) {
622 dev_err(arizona->dev, "Failed to restore register cache\n");
623 goto err;
624 }
625
626 return 0;
627
628 err:
629 regcache_cache_only(arizona->regmap, true);
630 regulator_disable(arizona->dcvdd);
631 return ret;
632 }
633
634 static int arizona_runtime_suspend(struct device *dev)
635 {
636 struct arizona *arizona = dev_get_drvdata(dev);
637 int jd_active = 0;
638 int ret;
639
640 dev_dbg(arizona->dev, "Entering AoD mode\n");
641
642 switch (arizona->type) {
643 case WM5110:
644 case WM8280:
645 jd_active = arizona_is_jack_det_active(arizona);
646 if (jd_active < 0)
647 return jd_active;
648
649 if (arizona->external_dcvdd) {
650 ret = arizona_isolate_dcvdd(arizona);
651 if (ret != 0)
652 return ret;
653 } else {
654 /*
655 * As this is only called for the internal regulator
656 * (where we know voltage ranges available) it is ok
657 * to request an exact range.
658 */
659 ret = regulator_set_voltage(arizona->dcvdd,
660 1175000, 1175000);
661 if (ret < 0) {
662 dev_err(arizona->dev,
663 "Failed to set suspend voltage: %d\n",
664 ret);
665 return ret;
666 }
667 }
668 break;
669 case WM5102:
670 jd_active = arizona_is_jack_det_active(arizona);
671 if (jd_active < 0)
672 return jd_active;
673
674 if (arizona->external_dcvdd) {
675 ret = arizona_isolate_dcvdd(arizona);
676 if (ret != 0)
677 return ret;
678 }
679
680 if (!jd_active) {
681 ret = regmap_write(arizona->regmap,
682 ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0);
683 if (ret) {
684 dev_err(arizona->dev,
685 "Failed to clear write sequencer: %d\n",
686 ret);
687 return ret;
688 }
689 }
690 break;
691 case WM1831:
692 case CS47L24:
693 break;
694 default:
695 jd_active = arizona_is_jack_det_active(arizona);
696 if (jd_active < 0)
697 return jd_active;
698
699 if (arizona->external_dcvdd) {
700 ret = arizona_isolate_dcvdd(arizona);
701 if (ret != 0)
702 return ret;
703 }
704 break;
705 }
706
707 regcache_cache_only(arizona->regmap, true);
708 regcache_mark_dirty(arizona->regmap);
709 regulator_disable(arizona->dcvdd);
710
711 /* Allow us to completely power down if no jack detection */
712 if (!jd_active) {
713 dev_dbg(arizona->dev, "Fully powering off\n");
714
715 arizona->has_fully_powered_off = true;
716
717 disable_irq_nosync(arizona->irq);
718 arizona_enable_reset(arizona);
719 regulator_bulk_disable(arizona->num_core_supplies,
720 arizona->core_supplies);
721 }
722
723 return 0;
724 }
725 #endif
726
727 #ifdef CONFIG_PM_SLEEP
728 static int arizona_suspend(struct device *dev)
729 {
730 struct arizona *arizona = dev_get_drvdata(dev);
731
732 dev_dbg(arizona->dev, "Suspend, disabling IRQ\n");
733 disable_irq(arizona->irq);
734
735 return 0;
736 }
737
738 static int arizona_suspend_noirq(struct device *dev)
739 {
740 struct arizona *arizona = dev_get_drvdata(dev);
741
742 dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n");
743 enable_irq(arizona->irq);
744
745 return 0;
746 }
747
748 static int arizona_resume_noirq(struct device *dev)
749 {
750 struct arizona *arizona = dev_get_drvdata(dev);
751
752 dev_dbg(arizona->dev, "Early resume, disabling IRQ\n");
753 disable_irq(arizona->irq);
754
755 return 0;
756 }
757
758 static int arizona_resume(struct device *dev)
759 {
760 struct arizona *arizona = dev_get_drvdata(dev);
761
762 dev_dbg(arizona->dev, "Resume, reenabling IRQ\n");
763 enable_irq(arizona->irq);
764
765 return 0;
766 }
767 #endif
768
769 const struct dev_pm_ops arizona_pm_ops = {
770 SET_RUNTIME_PM_OPS(arizona_runtime_suspend,
771 arizona_runtime_resume,
772 NULL)
773 SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume)
774 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(arizona_suspend_noirq,
775 arizona_resume_noirq)
776 };
777 EXPORT_SYMBOL_GPL(arizona_pm_ops);
778
779 #ifdef CONFIG_OF
780 unsigned long arizona_of_get_type(struct device *dev)
781 {
782 const struct of_device_id *id = of_match_device(arizona_of_match, dev);
783
784 if (id)
785 return (unsigned long)id->data;
786 else
787 return 0;
788 }
789 EXPORT_SYMBOL_GPL(arizona_of_get_type);
790
791 int arizona_of_get_named_gpio(struct arizona *arizona, const char *prop,
792 bool mandatory)
793 {
794 int gpio;
795
796 gpio = of_get_named_gpio(arizona->dev->of_node, prop, 0);
797 if (gpio < 0) {
798 if (mandatory)
799 dev_err(arizona->dev,
800 "Mandatory DT gpio %s missing/malformed: %d\n",
801 prop, gpio);
802
803 gpio = 0;
804 }
805
806 return gpio;
807 }
808 EXPORT_SYMBOL_GPL(arizona_of_get_named_gpio);
809
810 static int arizona_of_get_core_pdata(struct arizona *arizona)
811 {
812 struct arizona_pdata *pdata = &arizona->pdata;
813 struct property *prop;
814 const __be32 *cur;
815 u32 val;
816 int ret, i;
817 int count = 0;
818
819 pdata->reset = arizona_of_get_named_gpio(arizona, "wlf,reset", true);
820
821 ret = of_property_read_u32_array(arizona->dev->of_node,
822 "wlf,gpio-defaults",
823 pdata->gpio_defaults,
824 ARRAY_SIZE(pdata->gpio_defaults));
825 if (ret >= 0) {
826 /*
827 * All values are literal except out of range values
828 * which are chip default, translate into platform
829 * data which uses 0 as chip default and out of range
830 * as zero.
831 */
832 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
833 if (pdata->gpio_defaults[i] > 0xffff)
834 pdata->gpio_defaults[i] = 0;
835 else if (pdata->gpio_defaults[i] == 0)
836 pdata->gpio_defaults[i] = 0x10000;
837 }
838 } else {
839 dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n",
840 ret);
841 }
842
843 of_property_for_each_u32(arizona->dev->of_node, "wlf,inmode", prop,
844 cur, val) {
845 if (count == ARRAY_SIZE(pdata->inmode))
846 break;
847
848 pdata->inmode[count] = val;
849 count++;
850 }
851
852 count = 0;
853 of_property_for_each_u32(arizona->dev->of_node, "wlf,dmic-ref", prop,
854 cur, val) {
855 if (count == ARRAY_SIZE(pdata->dmic_ref))
856 break;
857
858 pdata->dmic_ref[count] = val;
859 count++;
860 }
861
862 count = 0;
863 of_property_for_each_u32(arizona->dev->of_node, "wlf,out-mono", prop,
864 cur, val) {
865 if (count == ARRAY_SIZE(pdata->out_mono))
866 break;
867
868 pdata->out_mono[count] = !!val;
869 count++;
870 }
871
872 return 0;
873 }
874
875 const struct of_device_id arizona_of_match[] = {
876 { .compatible = "wlf,wm5102", .data = (void *)WM5102 },
877 { .compatible = "wlf,wm5110", .data = (void *)WM5110 },
878 { .compatible = "wlf,wm8280", .data = (void *)WM8280 },
879 { .compatible = "wlf,wm8997", .data = (void *)WM8997 },
880 { .compatible = "wlf,wm8998", .data = (void *)WM8998 },
881 { .compatible = "wlf,wm1814", .data = (void *)WM1814 },
882 { .compatible = "wlf,wm1831", .data = (void *)WM1831 },
883 { .compatible = "cirrus,cs47l24", .data = (void *)CS47L24 },
884 {},
885 };
886 EXPORT_SYMBOL_GPL(arizona_of_match);
887 #else
888 static inline int arizona_of_get_core_pdata(struct arizona *arizona)
889 {
890 return 0;
891 }
892 #endif
893
894 static const struct mfd_cell early_devs[] = {
895 { .name = "arizona-ldo1" },
896 };
897
898 static const char * const wm5102_supplies[] = {
899 "MICVDD",
900 "DBVDD2",
901 "DBVDD3",
902 "CPVDD",
903 "SPKVDDL",
904 "SPKVDDR",
905 };
906
907 static const struct mfd_cell wm5102_devs[] = {
908 { .name = "arizona-micsupp" },
909 { .name = "arizona-gpio" },
910 {
911 .name = "arizona-extcon",
912 .parent_supplies = wm5102_supplies,
913 .num_parent_supplies = 1, /* We only need MICVDD */
914 },
915 { .name = "arizona-haptics" },
916 { .name = "arizona-pwm" },
917 {
918 .name = "wm5102-codec",
919 .parent_supplies = wm5102_supplies,
920 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
921 },
922 };
923
924 static const struct mfd_cell wm5110_devs[] = {
925 { .name = "arizona-micsupp" },
926 { .name = "arizona-gpio" },
927 {
928 .name = "arizona-extcon",
929 .parent_supplies = wm5102_supplies,
930 .num_parent_supplies = 1, /* We only need MICVDD */
931 },
932 { .name = "arizona-haptics" },
933 { .name = "arizona-pwm" },
934 {
935 .name = "wm5110-codec",
936 .parent_supplies = wm5102_supplies,
937 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
938 },
939 };
940
941 static const char * const cs47l24_supplies[] = {
942 "MICVDD",
943 "CPVDD",
944 "SPKVDD",
945 };
946
947 static const struct mfd_cell cs47l24_devs[] = {
948 { .name = "arizona-gpio" },
949 { .name = "arizona-haptics" },
950 { .name = "arizona-pwm" },
951 {
952 .name = "cs47l24-codec",
953 .parent_supplies = cs47l24_supplies,
954 .num_parent_supplies = ARRAY_SIZE(cs47l24_supplies),
955 },
956 };
957
958 static const char * const wm8997_supplies[] = {
959 "MICVDD",
960 "DBVDD2",
961 "CPVDD",
962 "SPKVDD",
963 };
964
965 static const struct mfd_cell wm8997_devs[] = {
966 { .name = "arizona-micsupp" },
967 { .name = "arizona-gpio" },
968 {
969 .name = "arizona-extcon",
970 .parent_supplies = wm8997_supplies,
971 .num_parent_supplies = 1, /* We only need MICVDD */
972 },
973 { .name = "arizona-haptics" },
974 { .name = "arizona-pwm" },
975 {
976 .name = "wm8997-codec",
977 .parent_supplies = wm8997_supplies,
978 .num_parent_supplies = ARRAY_SIZE(wm8997_supplies),
979 },
980 };
981
982 static const struct mfd_cell wm8998_devs[] = {
983 { .name = "arizona-micsupp" },
984 { .name = "arizona-gpio" },
985 {
986 .name = "arizona-extcon",
987 .parent_supplies = wm5102_supplies,
988 .num_parent_supplies = 1, /* We only need MICVDD */
989 },
990 { .name = "arizona-haptics" },
991 { .name = "arizona-pwm" },
992 {
993 .name = "wm8998-codec",
994 .parent_supplies = wm5102_supplies,
995 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
996 },
997 };
998
999 int arizona_dev_init(struct arizona *arizona)
1000 {
1001 struct device *dev = arizona->dev;
1002 const char *type_name = NULL;
1003 unsigned int reg, val, mask;
1004 int (*apply_patch)(struct arizona *) = NULL;
1005 const struct mfd_cell *subdevs = NULL;
1006 int n_subdevs, ret, i;
1007
1008 dev_set_drvdata(arizona->dev, arizona);
1009 mutex_init(&arizona->clk_lock);
1010
1011 if (dev_get_platdata(arizona->dev))
1012 memcpy(&arizona->pdata, dev_get_platdata(arizona->dev),
1013 sizeof(arizona->pdata));
1014 else
1015 arizona_of_get_core_pdata(arizona);
1016
1017 regcache_cache_only(arizona->regmap, true);
1018
1019 switch (arizona->type) {
1020 case WM5102:
1021 case WM5110:
1022 case WM8280:
1023 case WM8997:
1024 case WM8998:
1025 case WM1814:
1026 case WM1831:
1027 case CS47L24:
1028 for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++)
1029 arizona->core_supplies[i].supply
1030 = wm5102_core_supplies[i];
1031 arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies);
1032 break;
1033 default:
1034 dev_err(arizona->dev, "Unknown device type %d\n",
1035 arizona->type);
1036 return -ENODEV;
1037 }
1038
1039 /* Mark DCVDD as external, LDO1 driver will clear if internal */
1040 arizona->external_dcvdd = true;
1041
1042 switch (arizona->type) {
1043 case WM1831:
1044 case CS47L24:
1045 break; /* No LDO1 regulator */
1046 default:
1047 ret = mfd_add_devices(arizona->dev, -1, early_devs,
1048 ARRAY_SIZE(early_devs), NULL, 0, NULL);
1049 if (ret != 0) {
1050 dev_err(dev, "Failed to add early children: %d\n", ret);
1051 return ret;
1052 }
1053 break;
1054 }
1055
1056 ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies,
1057 arizona->core_supplies);
1058 if (ret != 0) {
1059 dev_err(dev, "Failed to request core supplies: %d\n",
1060 ret);
1061 goto err_early;
1062 }
1063
1064 /**
1065 * Don't use devres here because the only device we have to get
1066 * against is the MFD device and DCVDD will likely be supplied by
1067 * one of its children. Meaning that the regulator will be
1068 * destroyed by the time devres calls regulator put.
1069 */
1070 arizona->dcvdd = regulator_get(arizona->dev, "DCVDD");
1071 if (IS_ERR(arizona->dcvdd)) {
1072 ret = PTR_ERR(arizona->dcvdd);
1073 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
1074 goto err_early;
1075 }
1076
1077 if (arizona->pdata.reset) {
1078 /* Start out with /RESET low to put the chip into reset */
1079 ret = devm_gpio_request_one(arizona->dev, arizona->pdata.reset,
1080 GPIOF_DIR_OUT | GPIOF_INIT_LOW,
1081 "arizona /RESET");
1082 if (ret != 0) {
1083 dev_err(dev, "Failed to request /RESET: %d\n", ret);
1084 goto err_dcvdd;
1085 }
1086 }
1087
1088 ret = regulator_bulk_enable(arizona->num_core_supplies,
1089 arizona->core_supplies);
1090 if (ret != 0) {
1091 dev_err(dev, "Failed to enable core supplies: %d\n",
1092 ret);
1093 goto err_dcvdd;
1094 }
1095
1096 ret = regulator_enable(arizona->dcvdd);
1097 if (ret != 0) {
1098 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
1099 goto err_enable;
1100 }
1101
1102 arizona_disable_reset(arizona);
1103
1104 regcache_cache_only(arizona->regmap, false);
1105
1106 /* Verify that this is a chip we know about */
1107 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1108 if (ret != 0) {
1109 dev_err(dev, "Failed to read ID register: %d\n", ret);
1110 goto err_reset;
1111 }
1112
1113 switch (reg) {
1114 case 0x5102:
1115 case 0x5110:
1116 case 0x6349:
1117 case 0x6363:
1118 case 0x8997:
1119 break;
1120 default:
1121 dev_err(arizona->dev, "Unknown device ID: %x\n", reg);
1122 ret = -ENODEV;
1123 goto err_reset;
1124 }
1125
1126 /* If we have a /RESET GPIO we'll already be reset */
1127 if (!arizona->pdata.reset) {
1128 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);
1129 if (ret != 0) {
1130 dev_err(dev, "Failed to reset device: %d\n", ret);
1131 goto err_reset;
1132 }
1133
1134 usleep_range(1000, 5000);
1135 }
1136
1137 /* Ensure device startup is complete */
1138 switch (arizona->type) {
1139 case WM5102:
1140 ret = regmap_read(arizona->regmap,
1141 ARIZONA_WRITE_SEQUENCER_CTRL_3, &val);
1142 if (ret) {
1143 dev_err(dev,
1144 "Failed to check write sequencer state: %d\n",
1145 ret);
1146 } else if (val & 0x01) {
1147 ret = wm5102_clear_write_sequencer(arizona);
1148 if (ret)
1149 return ret;
1150 }
1151 break;
1152 default:
1153 break;
1154 }
1155
1156 ret = arizona_wait_for_boot(arizona);
1157 if (ret) {
1158 dev_err(arizona->dev, "Device failed initial boot: %d\n", ret);
1159 goto err_reset;
1160 }
1161
1162 /* Read the device ID information & do device specific stuff */
1163 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1164 if (ret != 0) {
1165 dev_err(dev, "Failed to read ID register: %d\n", ret);
1166 goto err_reset;
1167 }
1168
1169 ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION,
1170 &arizona->rev);
1171 if (ret != 0) {
1172 dev_err(dev, "Failed to read revision register: %d\n", ret);
1173 goto err_reset;
1174 }
1175 arizona->rev &= ARIZONA_DEVICE_REVISION_MASK;
1176
1177 switch (reg) {
1178 case 0x5102:
1179 if (IS_ENABLED(CONFIG_MFD_WM5102)) {
1180 type_name = "WM5102";
1181 if (arizona->type != WM5102) {
1182 dev_warn(arizona->dev,
1183 "WM5102 registered as %d\n",
1184 arizona->type);
1185 arizona->type = WM5102;
1186 }
1187
1188 apply_patch = wm5102_patch;
1189 arizona->rev &= 0x7;
1190 subdevs = wm5102_devs;
1191 n_subdevs = ARRAY_SIZE(wm5102_devs);
1192 }
1193 break;
1194 case 0x5110:
1195 if (IS_ENABLED(CONFIG_MFD_WM5110)) {
1196 switch (arizona->type) {
1197 case WM5110:
1198 type_name = "WM5110";
1199 break;
1200 case WM8280:
1201 type_name = "WM8280";
1202 break;
1203 default:
1204 type_name = "WM5110";
1205 dev_warn(arizona->dev,
1206 "WM5110 registered as %d\n",
1207 arizona->type);
1208 arizona->type = WM5110;
1209 break;
1210 }
1211
1212 apply_patch = wm5110_patch;
1213 subdevs = wm5110_devs;
1214 n_subdevs = ARRAY_SIZE(wm5110_devs);
1215 }
1216 break;
1217 case 0x6363:
1218 if (IS_ENABLED(CONFIG_MFD_CS47L24)) {
1219 switch (arizona->type) {
1220 case CS47L24:
1221 type_name = "CS47L24";
1222 break;
1223
1224 case WM1831:
1225 type_name = "WM1831";
1226 break;
1227
1228 default:
1229 dev_warn(arizona->dev,
1230 "CS47L24 registered as %d\n",
1231 arizona->type);
1232 arizona->type = CS47L24;
1233 break;
1234 }
1235
1236 apply_patch = cs47l24_patch;
1237 subdevs = cs47l24_devs;
1238 n_subdevs = ARRAY_SIZE(cs47l24_devs);
1239 }
1240 break;
1241 case 0x8997:
1242 if (IS_ENABLED(CONFIG_MFD_WM8997)) {
1243 type_name = "WM8997";
1244 if (arizona->type != WM8997) {
1245 dev_warn(arizona->dev,
1246 "WM8997 registered as %d\n",
1247 arizona->type);
1248 arizona->type = WM8997;
1249 }
1250
1251 apply_patch = wm8997_patch;
1252 subdevs = wm8997_devs;
1253 n_subdevs = ARRAY_SIZE(wm8997_devs);
1254 }
1255 break;
1256 case 0x6349:
1257 if (IS_ENABLED(CONFIG_MFD_WM8998)) {
1258 switch (arizona->type) {
1259 case WM8998:
1260 type_name = "WM8998";
1261 break;
1262
1263 case WM1814:
1264 type_name = "WM1814";
1265 break;
1266
1267 default:
1268 type_name = "WM8998";
1269 dev_warn(arizona->dev,
1270 "WM8998 registered as %d\n",
1271 arizona->type);
1272 arizona->type = WM8998;
1273 }
1274
1275 apply_patch = wm8998_patch;
1276 subdevs = wm8998_devs;
1277 n_subdevs = ARRAY_SIZE(wm8998_devs);
1278 }
1279 break;
1280 default:
1281 dev_err(arizona->dev, "Unknown device ID %x\n", reg);
1282 ret = -ENODEV;
1283 goto err_reset;
1284 }
1285
1286 if (!subdevs) {
1287 dev_err(arizona->dev,
1288 "No kernel support for device ID %x\n", reg);
1289 ret = -ENODEV;
1290 goto err_reset;
1291 }
1292
1293 dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A');
1294
1295 if (apply_patch) {
1296 ret = apply_patch(arizona);
1297 if (ret != 0) {
1298 dev_err(arizona->dev, "Failed to apply patch: %d\n",
1299 ret);
1300 goto err_reset;
1301 }
1302
1303 switch (arizona->type) {
1304 case WM5102:
1305 ret = wm5102_apply_hardware_patch(arizona);
1306 if (ret) {
1307 dev_err(arizona->dev,
1308 "Failed to apply hardware patch: %d\n",
1309 ret);
1310 goto err_reset;
1311 }
1312 break;
1313 case WM5110:
1314 case WM8280:
1315 ret = wm5110_apply_sleep_patch(arizona);
1316 if (ret) {
1317 dev_err(arizona->dev,
1318 "Failed to apply sleep patch: %d\n",
1319 ret);
1320 goto err_reset;
1321 }
1322 break;
1323 default:
1324 break;
1325 }
1326 }
1327
1328 for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {
1329 if (!arizona->pdata.gpio_defaults[i])
1330 continue;
1331
1332 regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i,
1333 arizona->pdata.gpio_defaults[i]);
1334 }
1335
1336 /* Chip default */
1337 if (!arizona->pdata.clk32k_src)
1338 arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2;
1339
1340 switch (arizona->pdata.clk32k_src) {
1341 case ARIZONA_32KZ_MCLK1:
1342 case ARIZONA_32KZ_MCLK2:
1343 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1344 ARIZONA_CLK_32K_SRC_MASK,
1345 arizona->pdata.clk32k_src - 1);
1346 arizona_clk32k_enable(arizona);
1347 break;
1348 case ARIZONA_32KZ_NONE:
1349 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1350 ARIZONA_CLK_32K_SRC_MASK, 2);
1351 break;
1352 default:
1353 dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n",
1354 arizona->pdata.clk32k_src);
1355 ret = -EINVAL;
1356 goto err_reset;
1357 }
1358
1359 for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) {
1360 if (!arizona->pdata.micbias[i].mV &&
1361 !arizona->pdata.micbias[i].bypass)
1362 continue;
1363
1364 /* Apply default for bypass mode */
1365 if (!arizona->pdata.micbias[i].mV)
1366 arizona->pdata.micbias[i].mV = 2800;
1367
1368 val = (arizona->pdata.micbias[i].mV - 1500) / 100;
1369
1370 val <<= ARIZONA_MICB1_LVL_SHIFT;
1371
1372 if (arizona->pdata.micbias[i].ext_cap)
1373 val |= ARIZONA_MICB1_EXT_CAP;
1374
1375 if (arizona->pdata.micbias[i].discharge)
1376 val |= ARIZONA_MICB1_DISCH;
1377
1378 if (arizona->pdata.micbias[i].soft_start)
1379 val |= ARIZONA_MICB1_RATE;
1380
1381 if (arizona->pdata.micbias[i].bypass)
1382 val |= ARIZONA_MICB1_BYPASS;
1383
1384 regmap_update_bits(arizona->regmap,
1385 ARIZONA_MIC_BIAS_CTRL_1 + i,
1386 ARIZONA_MICB1_LVL_MASK |
1387 ARIZONA_MICB1_EXT_CAP |
1388 ARIZONA_MICB1_DISCH |
1389 ARIZONA_MICB1_BYPASS |
1390 ARIZONA_MICB1_RATE, val);
1391 }
1392
1393 for (i = 0; i < ARIZONA_MAX_INPUT; i++) {
1394 /* Default for both is 0 so noop with defaults */
1395 val = arizona->pdata.dmic_ref[i]
1396 << ARIZONA_IN1_DMIC_SUP_SHIFT;
1397 if (arizona->pdata.inmode[i] & ARIZONA_INMODE_DMIC)
1398 val |= 1 << ARIZONA_IN1_MODE_SHIFT;
1399
1400 switch (arizona->type) {
1401 case WM8998:
1402 case WM1814:
1403 regmap_update_bits(arizona->regmap,
1404 ARIZONA_ADC_DIGITAL_VOLUME_1L + (i * 8),
1405 ARIZONA_IN1L_SRC_SE_MASK,
1406 (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1407 << ARIZONA_IN1L_SRC_SE_SHIFT);
1408
1409 regmap_update_bits(arizona->regmap,
1410 ARIZONA_ADC_DIGITAL_VOLUME_1R + (i * 8),
1411 ARIZONA_IN1R_SRC_SE_MASK,
1412 (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1413 << ARIZONA_IN1R_SRC_SE_SHIFT);
1414
1415 mask = ARIZONA_IN1_DMIC_SUP_MASK |
1416 ARIZONA_IN1_MODE_MASK;
1417 break;
1418 default:
1419 if (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1420 val |= 1 << ARIZONA_IN1_SINGLE_ENDED_SHIFT;
1421
1422 mask = ARIZONA_IN1_DMIC_SUP_MASK |
1423 ARIZONA_IN1_MODE_MASK |
1424 ARIZONA_IN1_SINGLE_ENDED_MASK;
1425 break;
1426 }
1427
1428 regmap_update_bits(arizona->regmap,
1429 ARIZONA_IN1L_CONTROL + (i * 8),
1430 mask, val);
1431 }
1432
1433 for (i = 0; i < ARIZONA_MAX_OUTPUT; i++) {
1434 /* Default is 0 so noop with defaults */
1435 if (arizona->pdata.out_mono[i])
1436 val = ARIZONA_OUT1_MONO;
1437 else
1438 val = 0;
1439
1440 regmap_update_bits(arizona->regmap,
1441 ARIZONA_OUTPUT_PATH_CONFIG_1L + (i * 8),
1442 ARIZONA_OUT1_MONO, val);
1443 }
1444
1445 for (i = 0; i < ARIZONA_MAX_PDM_SPK; i++) {
1446 if (arizona->pdata.spk_mute[i])
1447 regmap_update_bits(arizona->regmap,
1448 ARIZONA_PDM_SPK1_CTRL_1 + (i * 2),
1449 ARIZONA_SPK1_MUTE_ENDIAN_MASK |
1450 ARIZONA_SPK1_MUTE_SEQ1_MASK,
1451 arizona->pdata.spk_mute[i]);
1452
1453 if (arizona->pdata.spk_fmt[i])
1454 regmap_update_bits(arizona->regmap,
1455 ARIZONA_PDM_SPK1_CTRL_2 + (i * 2),
1456 ARIZONA_SPK1_FMT_MASK,
1457 arizona->pdata.spk_fmt[i]);
1458 }
1459
1460 pm_runtime_set_active(arizona->dev);
1461 pm_runtime_enable(arizona->dev);
1462
1463 /* Set up for interrupts */
1464 ret = arizona_irq_init(arizona);
1465 if (ret != 0)
1466 goto err_pm;
1467
1468 pm_runtime_set_autosuspend_delay(arizona->dev, 100);
1469 pm_runtime_use_autosuspend(arizona->dev);
1470
1471 arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error",
1472 arizona_clkgen_err, arizona);
1473 arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked",
1474 arizona_overclocked, arizona);
1475 arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked",
1476 arizona_underclocked, arizona);
1477
1478 ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE,
1479 subdevs, n_subdevs, NULL, 0, NULL);
1480
1481 if (ret) {
1482 dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret);
1483 goto err_irq;
1484 }
1485
1486 return 0;
1487
1488 err_irq:
1489 arizona_irq_exit(arizona);
1490 err_pm:
1491 pm_runtime_disable(arizona->dev);
1492 err_reset:
1493 arizona_enable_reset(arizona);
1494 regulator_disable(arizona->dcvdd);
1495 err_enable:
1496 regulator_bulk_disable(arizona->num_core_supplies,
1497 arizona->core_supplies);
1498 err_dcvdd:
1499 regulator_put(arizona->dcvdd);
1500 err_early:
1501 mfd_remove_devices(dev);
1502 return ret;
1503 }
1504 EXPORT_SYMBOL_GPL(arizona_dev_init);
1505
1506 int arizona_dev_exit(struct arizona *arizona)
1507 {
1508 pm_runtime_disable(arizona->dev);
1509
1510 regulator_disable(arizona->dcvdd);
1511 regulator_put(arizona->dcvdd);
1512
1513 mfd_remove_devices(arizona->dev);
1514 arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona);
1515 arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona);
1516 arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona);
1517 arizona_irq_exit(arizona);
1518 arizona_enable_reset(arizona);
1519
1520 regulator_bulk_disable(arizona->num_core_supplies,
1521 arizona->core_supplies);
1522 return 0;
1523 }
1524 EXPORT_SYMBOL_GPL(arizona_dev_exit);
Linux kernel - Deliverables
This page took 0.065259 seconds and 5 git commands to generate.