4 * Copyright 2012 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
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>
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>
28 #include <linux/mfd/arizona/core.h>
29 #include <linux/mfd/arizona/registers.h>
33 static const char * const wm5102_core_supplies
[] = {
38 int arizona_clk32k_enable(struct arizona
*arizona
)
42 mutex_lock(&arizona
->clk_lock
);
44 arizona
->clk32k_ref
++;
46 if (arizona
->clk32k_ref
== 1) {
47 switch (arizona
->pdata
.clk32k_src
) {
48 case ARIZONA_32KZ_MCLK1
:
49 ret
= pm_runtime_get_sync(arizona
->dev
);
55 ret
= regmap_update_bits(arizona
->regmap
, ARIZONA_CLOCK_32K_1
,
62 arizona
->clk32k_ref
--;
64 mutex_unlock(&arizona
->clk_lock
);
68 EXPORT_SYMBOL_GPL(arizona_clk32k_enable
);
70 int arizona_clk32k_disable(struct arizona
*arizona
)
72 mutex_lock(&arizona
->clk_lock
);
74 BUG_ON(arizona
->clk32k_ref
<= 0);
76 arizona
->clk32k_ref
--;
78 if (arizona
->clk32k_ref
== 0) {
79 regmap_update_bits(arizona
->regmap
, ARIZONA_CLOCK_32K_1
,
80 ARIZONA_CLK_32K_ENA
, 0);
82 switch (arizona
->pdata
.clk32k_src
) {
83 case ARIZONA_32KZ_MCLK1
:
84 pm_runtime_put_sync(arizona
->dev
);
89 mutex_unlock(&arizona
->clk_lock
);
93 EXPORT_SYMBOL_GPL(arizona_clk32k_disable
);
95 static irqreturn_t
arizona_clkgen_err(int irq
, void *data
)
97 struct arizona
*arizona
= data
;
99 dev_err(arizona
->dev
, "CLKGEN error\n");
104 static irqreturn_t
arizona_underclocked(int irq
, void *data
)
106 struct arizona
*arizona
= data
;
110 ret
= regmap_read(arizona
->regmap
, ARIZONA_INTERRUPT_RAW_STATUS_8
,
113 dev_err(arizona
->dev
, "Failed to read underclock status: %d\n",
118 if (val
& ARIZONA_AIF3_UNDERCLOCKED_STS
)
119 dev_err(arizona
->dev
, "AIF3 underclocked\n");
120 if (val
& ARIZONA_AIF2_UNDERCLOCKED_STS
)
121 dev_err(arizona
->dev
, "AIF2 underclocked\n");
122 if (val
& ARIZONA_AIF1_UNDERCLOCKED_STS
)
123 dev_err(arizona
->dev
, "AIF1 underclocked\n");
124 if (val
& ARIZONA_ISRC3_UNDERCLOCKED_STS
)
125 dev_err(arizona
->dev
, "ISRC3 underclocked\n");
126 if (val
& ARIZONA_ISRC2_UNDERCLOCKED_STS
)
127 dev_err(arizona
->dev
, "ISRC2 underclocked\n");
128 if (val
& ARIZONA_ISRC1_UNDERCLOCKED_STS
)
129 dev_err(arizona
->dev
, "ISRC1 underclocked\n");
130 if (val
& ARIZONA_FX_UNDERCLOCKED_STS
)
131 dev_err(arizona
->dev
, "FX underclocked\n");
132 if (val
& ARIZONA_ASRC_UNDERCLOCKED_STS
)
133 dev_err(arizona
->dev
, "ASRC underclocked\n");
134 if (val
& ARIZONA_DAC_UNDERCLOCKED_STS
)
135 dev_err(arizona
->dev
, "DAC underclocked\n");
136 if (val
& ARIZONA_ADC_UNDERCLOCKED_STS
)
137 dev_err(arizona
->dev
, "ADC underclocked\n");
138 if (val
& ARIZONA_MIXER_UNDERCLOCKED_STS
)
139 dev_err(arizona
->dev
, "Mixer dropped sample\n");
144 static irqreturn_t
arizona_overclocked(int irq
, void *data
)
146 struct arizona
*arizona
= data
;
150 ret
= regmap_bulk_read(arizona
->regmap
, ARIZONA_INTERRUPT_RAW_STATUS_6
,
153 dev_err(arizona
->dev
, "Failed to read overclock status: %d\n",
158 switch (arizona
->type
) {
161 /* Some bits are shifted on WM8998,
162 * rearrange to match the standard bit layout
164 val
[0] = ((val
[0] & 0x60e0) >> 1) |
165 ((val
[0] & 0x1e00) >> 2) |
172 if (val
[0] & ARIZONA_PWM_OVERCLOCKED_STS
)
173 dev_err(arizona
->dev
, "PWM overclocked\n");
174 if (val
[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS
)
175 dev_err(arizona
->dev
, "FX core overclocked\n");
176 if (val
[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS
)
177 dev_err(arizona
->dev
, "DAC SYS overclocked\n");
178 if (val
[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS
)
179 dev_err(arizona
->dev
, "DAC WARP overclocked\n");
180 if (val
[0] & ARIZONA_ADC_OVERCLOCKED_STS
)
181 dev_err(arizona
->dev
, "ADC overclocked\n");
182 if (val
[0] & ARIZONA_MIXER_OVERCLOCKED_STS
)
183 dev_err(arizona
->dev
, "Mixer overclocked\n");
184 if (val
[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS
)
185 dev_err(arizona
->dev
, "AIF3 overclocked\n");
186 if (val
[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS
)
187 dev_err(arizona
->dev
, "AIF2 overclocked\n");
188 if (val
[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS
)
189 dev_err(arizona
->dev
, "AIF1 overclocked\n");
190 if (val
[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS
)
191 dev_err(arizona
->dev
, "Pad control overclocked\n");
193 if (val
[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS
)
194 dev_err(arizona
->dev
, "Slimbus subsystem overclocked\n");
195 if (val
[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS
)
196 dev_err(arizona
->dev
, "Slimbus async overclocked\n");
197 if (val
[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS
)
198 dev_err(arizona
->dev
, "Slimbus sync overclocked\n");
199 if (val
[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS
)
200 dev_err(arizona
->dev
, "ASRC async system overclocked\n");
201 if (val
[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS
)
202 dev_err(arizona
->dev
, "ASRC async WARP overclocked\n");
203 if (val
[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS
)
204 dev_err(arizona
->dev
, "ASRC sync system overclocked\n");
205 if (val
[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS
)
206 dev_err(arizona
->dev
, "ASRC sync WARP overclocked\n");
207 if (val
[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS
)
208 dev_err(arizona
->dev
, "DSP1 overclocked\n");
209 if (val
[1] & ARIZONA_ISRC3_OVERCLOCKED_STS
)
210 dev_err(arizona
->dev
, "ISRC3 overclocked\n");
211 if (val
[1] & ARIZONA_ISRC2_OVERCLOCKED_STS
)
212 dev_err(arizona
->dev
, "ISRC2 overclocked\n");
213 if (val
[1] & ARIZONA_ISRC1_OVERCLOCKED_STS
)
214 dev_err(arizona
->dev
, "ISRC1 overclocked\n");
216 if (val
[2] & ARIZONA_SPDIF_OVERCLOCKED_STS
)
217 dev_err(arizona
->dev
, "SPDIF overclocked\n");
222 static int arizona_poll_reg(struct arizona
*arizona
,
223 int timeout
, unsigned int reg
,
224 unsigned int mask
, unsigned int target
)
226 unsigned int val
= 0;
229 for (i
= 0; i
< timeout
; i
++) {
230 ret
= regmap_read(arizona
->regmap
, reg
, &val
);
232 dev_err(arizona
->dev
, "Failed to read reg %u: %d\n",
237 if ((val
& mask
) == target
)
243 dev_err(arizona
->dev
, "Polling reg %u timed out: %x\n", reg
, val
);
247 static int arizona_wait_for_boot(struct arizona
*arizona
)
252 * We can't use an interrupt as we need to runtime resume to do so,
253 * we won't race with the interrupt handler as it'll be blocked on
256 ret
= arizona_poll_reg(arizona
, 5, ARIZONA_INTERRUPT_RAW_STATUS_5
,
257 ARIZONA_BOOT_DONE_STS
, ARIZONA_BOOT_DONE_STS
);
260 regmap_write(arizona
->regmap
, ARIZONA_INTERRUPT_STATUS_5
,
261 ARIZONA_BOOT_DONE_STS
);
263 pm_runtime_mark_last_busy(arizona
->dev
);
268 static inline void arizona_enable_reset(struct arizona
*arizona
)
270 if (arizona
->pdata
.reset
)
271 gpio_set_value_cansleep(arizona
->pdata
.reset
, 0);
274 static void arizona_disable_reset(struct arizona
*arizona
)
276 if (arizona
->pdata
.reset
) {
277 switch (arizona
->type
) {
280 /* Meet requirements for minimum reset duration */
287 gpio_set_value_cansleep(arizona
->pdata
.reset
, 1);
292 struct arizona_sysclk_state
{
297 static int arizona_enable_freerun_sysclk(struct arizona
*arizona
,
298 struct arizona_sysclk_state
*state
)
302 /* Cache existing FLL and SYSCLK settings */
303 ret
= regmap_read(arizona
->regmap
, ARIZONA_FLL1_CONTROL_1
, &state
->fll
);
305 dev_err(arizona
->dev
, "Failed to cache FLL settings: %d\n",
309 ret
= regmap_read(arizona
->regmap
, ARIZONA_SYSTEM_CLOCK_1
,
312 dev_err(arizona
->dev
, "Failed to cache SYSCLK settings: %d\n",
317 /* Start up SYSCLK using the FLL in free running mode */
318 ret
= regmap_write(arizona
->regmap
, ARIZONA_FLL1_CONTROL_1
,
319 ARIZONA_FLL1_ENA
| ARIZONA_FLL1_FREERUN
);
321 dev_err(arizona
->dev
,
322 "Failed to start FLL in freerunning mode: %d\n",
326 ret
= arizona_poll_reg(arizona
, 25, ARIZONA_INTERRUPT_RAW_STATUS_5
,
327 ARIZONA_FLL1_CLOCK_OK_STS
,
328 ARIZONA_FLL1_CLOCK_OK_STS
);
334 ret
= regmap_write(arizona
->regmap
, ARIZONA_SYSTEM_CLOCK_1
, 0x0144);
336 dev_err(arizona
->dev
, "Failed to start SYSCLK: %d\n", ret
);
343 err
= regmap_write(arizona
->regmap
, ARIZONA_FLL1_CONTROL_1
, state
->fll
);
345 dev_err(arizona
->dev
,
346 "Failed to re-apply old FLL settings: %d\n", err
);
351 static int arizona_disable_freerun_sysclk(struct arizona
*arizona
,
352 struct arizona_sysclk_state
*state
)
356 ret
= regmap_write(arizona
->regmap
, ARIZONA_SYSTEM_CLOCK_1
,
359 dev_err(arizona
->dev
,
360 "Failed to re-apply old SYSCLK settings: %d\n", ret
);
364 ret
= regmap_write(arizona
->regmap
, ARIZONA_FLL1_CONTROL_1
, state
->fll
);
366 dev_err(arizona
->dev
,
367 "Failed to re-apply old FLL settings: %d\n", ret
);
374 static int wm5102_apply_hardware_patch(struct arizona
*arizona
)
376 struct arizona_sysclk_state state
;
379 ret
= arizona_enable_freerun_sysclk(arizona
, &state
);
383 /* Start the write sequencer and wait for it to finish */
384 ret
= regmap_write(arizona
->regmap
, ARIZONA_WRITE_SEQUENCER_CTRL_0
,
385 ARIZONA_WSEQ_ENA
| ARIZONA_WSEQ_START
| 160);
387 dev_err(arizona
->dev
, "Failed to start write sequencer: %d\n",
392 ret
= arizona_poll_reg(arizona
, 5, ARIZONA_WRITE_SEQUENCER_CTRL_1
,
393 ARIZONA_WSEQ_BUSY
, 0);
395 regmap_write(arizona
->regmap
, ARIZONA_WRITE_SEQUENCER_CTRL_0
,
401 err
= arizona_disable_freerun_sysclk(arizona
, &state
);
407 * Register patch to some of the CODECs internal write sequences
408 * to ensure a clean exit from the low power sleep state.
410 static const struct reg_sequence wm5110_sleep_patch
[] = {
417 static int wm5110_apply_sleep_patch(struct arizona
*arizona
)
419 struct arizona_sysclk_state state
;
422 ret
= arizona_enable_freerun_sysclk(arizona
, &state
);
426 ret
= regmap_multi_reg_write_bypassed(arizona
->regmap
,
428 ARRAY_SIZE(wm5110_sleep_patch
));
430 err
= arizona_disable_freerun_sysclk(arizona
, &state
);
435 static int wm5102_clear_write_sequencer(struct arizona
*arizona
)
439 ret
= regmap_write(arizona
->regmap
, ARIZONA_WRITE_SEQUENCER_CTRL_3
,
442 dev_err(arizona
->dev
,
443 "Failed to clear write sequencer state: %d\n", ret
);
447 arizona_enable_reset(arizona
);
448 regulator_disable(arizona
->dcvdd
);
452 ret
= regulator_enable(arizona
->dcvdd
);
454 dev_err(arizona
->dev
, "Failed to re-enable DCVDD: %d\n", ret
);
457 arizona_disable_reset(arizona
);
463 static int arizona_runtime_resume(struct device
*dev
)
465 struct arizona
*arizona
= dev_get_drvdata(dev
);
468 dev_dbg(arizona
->dev
, "Leaving AoD mode\n");
470 if (arizona
->has_fully_powered_off
) {
471 dev_dbg(arizona
->dev
, "Re-enabling core supplies\n");
473 ret
= regulator_bulk_enable(arizona
->num_core_supplies
,
474 arizona
->core_supplies
);
476 dev_err(dev
, "Failed to enable core supplies: %d\n",
482 ret
= regulator_enable(arizona
->dcvdd
);
484 dev_err(arizona
->dev
, "Failed to enable DCVDD: %d\n", ret
);
485 if (arizona
->has_fully_powered_off
)
486 regulator_bulk_disable(arizona
->num_core_supplies
,
487 arizona
->core_supplies
);
491 if (arizona
->has_fully_powered_off
) {
492 arizona_disable_reset(arizona
);
493 enable_irq(arizona
->irq
);
494 arizona
->has_fully_powered_off
= false;
497 regcache_cache_only(arizona
->regmap
, false);
499 switch (arizona
->type
) {
501 if (arizona
->external_dcvdd
) {
502 ret
= regmap_update_bits(arizona
->regmap
,
503 ARIZONA_ISOLATION_CONTROL
,
504 ARIZONA_ISOLATE_DCVDD1
, 0);
506 dev_err(arizona
->dev
,
507 "Failed to connect DCVDD: %d\n", ret
);
512 ret
= wm5102_patch(arizona
);
514 dev_err(arizona
->dev
, "Failed to apply patch: %d\n",
519 ret
= wm5102_apply_hardware_patch(arizona
);
521 dev_err(arizona
->dev
,
522 "Failed to apply hardware patch: %d\n",
529 ret
= arizona_wait_for_boot(arizona
);
533 if (arizona
->external_dcvdd
) {
534 ret
= regmap_update_bits(arizona
->regmap
,
535 ARIZONA_ISOLATION_CONTROL
,
536 ARIZONA_ISOLATE_DCVDD1
, 0);
538 dev_err(arizona
->dev
,
539 "Failed to connect DCVDD: %d\n", ret
);
544 * As this is only called for the internal regulator
545 * (where we know voltage ranges available) it is ok
546 * to request an exact range.
548 ret
= regulator_set_voltage(arizona
->dcvdd
,
551 dev_err(arizona
->dev
,
552 "Failed to set resume voltage: %d\n",
558 ret
= wm5110_apply_sleep_patch(arizona
);
560 dev_err(arizona
->dev
,
561 "Failed to re-apply sleep patch: %d\n",
567 ret
= arizona_wait_for_boot(arizona
);
571 if (arizona
->external_dcvdd
) {
572 ret
= regmap_update_bits(arizona
->regmap
,
573 ARIZONA_ISOLATION_CONTROL
,
574 ARIZONA_ISOLATE_DCVDD1
, 0);
576 dev_err(arizona
->dev
,
577 "Failed to connect DCVDD: %d\n", ret
);
584 ret
= regcache_sync(arizona
->regmap
);
586 dev_err(arizona
->dev
, "Failed to restore register cache\n");
593 regcache_cache_only(arizona
->regmap
, true);
594 regulator_disable(arizona
->dcvdd
);
598 static int arizona_runtime_suspend(struct device
*dev
)
600 struct arizona
*arizona
= dev_get_drvdata(dev
);
604 dev_dbg(arizona
->dev
, "Entering AoD mode\n");
606 ret
= regmap_read(arizona
->regmap
, ARIZONA_JACK_DETECT_ANALOGUE
, &val
);
608 dev_err(dev
, "Failed to check jack det status: %d\n", ret
);
612 if (arizona
->external_dcvdd
) {
613 ret
= regmap_update_bits(arizona
->regmap
,
614 ARIZONA_ISOLATION_CONTROL
,
615 ARIZONA_ISOLATE_DCVDD1
,
616 ARIZONA_ISOLATE_DCVDD1
);
618 dev_err(arizona
->dev
, "Failed to isolate DCVDD: %d\n",
624 switch (arizona
->type
) {
627 if (arizona
->external_dcvdd
)
631 * As this is only called for the internal regulator
632 * (where we know voltage ranges available) it is ok
633 * to request an exact range.
635 ret
= regulator_set_voltage(arizona
->dcvdd
, 1175000, 1175000);
637 dev_err(arizona
->dev
,
638 "Failed to set suspend voltage: %d\n", ret
);
643 if (!(val
& ARIZONA_JD1_ENA
)) {
644 ret
= regmap_write(arizona
->regmap
,
645 ARIZONA_WRITE_SEQUENCER_CTRL_3
, 0x0);
647 dev_err(arizona
->dev
,
648 "Failed to clear write sequencer: %d\n",
658 regcache_cache_only(arizona
->regmap
, true);
659 regcache_mark_dirty(arizona
->regmap
);
660 regulator_disable(arizona
->dcvdd
);
662 /* Allow us to completely power down if no jack detection */
663 if (!(val
& ARIZONA_JD1_ENA
)) {
664 dev_dbg(arizona
->dev
, "Fully powering off\n");
666 arizona
->has_fully_powered_off
= true;
668 disable_irq_nosync(arizona
->irq
);
669 arizona_enable_reset(arizona
);
670 regulator_bulk_disable(arizona
->num_core_supplies
,
671 arizona
->core_supplies
);
678 #ifdef CONFIG_PM_SLEEP
679 static int arizona_suspend(struct device
*dev
)
681 struct arizona
*arizona
= dev_get_drvdata(dev
);
683 dev_dbg(arizona
->dev
, "Suspend, disabling IRQ\n");
684 disable_irq(arizona
->irq
);
689 static int arizona_suspend_late(struct device
*dev
)
691 struct arizona
*arizona
= dev_get_drvdata(dev
);
693 dev_dbg(arizona
->dev
, "Late suspend, reenabling IRQ\n");
694 enable_irq(arizona
->irq
);
699 static int arizona_resume_noirq(struct device
*dev
)
701 struct arizona
*arizona
= dev_get_drvdata(dev
);
703 dev_dbg(arizona
->dev
, "Early resume, disabling IRQ\n");
704 disable_irq(arizona
->irq
);
709 static int arizona_resume(struct device
*dev
)
711 struct arizona
*arizona
= dev_get_drvdata(dev
);
713 dev_dbg(arizona
->dev
, "Late resume, reenabling IRQ\n");
714 enable_irq(arizona
->irq
);
720 const struct dev_pm_ops arizona_pm_ops
= {
721 SET_RUNTIME_PM_OPS(arizona_runtime_suspend
,
722 arizona_runtime_resume
,
724 SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend
, arizona_resume
)
725 #ifdef CONFIG_PM_SLEEP
726 .suspend_late
= arizona_suspend_late
,
727 .resume_noirq
= arizona_resume_noirq
,
730 EXPORT_SYMBOL_GPL(arizona_pm_ops
);
733 unsigned long arizona_of_get_type(struct device
*dev
)
735 const struct of_device_id
*id
= of_match_device(arizona_of_match
, dev
);
738 return (unsigned long)id
->data
;
742 EXPORT_SYMBOL_GPL(arizona_of_get_type
);
744 int arizona_of_get_named_gpio(struct arizona
*arizona
, const char *prop
,
749 gpio
= of_get_named_gpio(arizona
->dev
->of_node
, prop
, 0);
752 dev_err(arizona
->dev
,
753 "Mandatory DT gpio %s missing/malformed: %d\n",
761 EXPORT_SYMBOL_GPL(arizona_of_get_named_gpio
);
763 static int arizona_of_get_core_pdata(struct arizona
*arizona
)
765 struct arizona_pdata
*pdata
= &arizona
->pdata
;
766 struct property
*prop
;
772 pdata
->reset
= arizona_of_get_named_gpio(arizona
, "wlf,reset", true);
774 ret
= of_property_read_u32_array(arizona
->dev
->of_node
,
776 pdata
->gpio_defaults
,
777 ARRAY_SIZE(pdata
->gpio_defaults
));
780 * All values are literal except out of range values
781 * which are chip default, translate into platform
782 * data which uses 0 as chip default and out of range
785 for (i
= 0; i
< ARRAY_SIZE(pdata
->gpio_defaults
); i
++) {
786 if (pdata
->gpio_defaults
[i
] > 0xffff)
787 pdata
->gpio_defaults
[i
] = 0;
788 else if (pdata
->gpio_defaults
[i
] == 0)
789 pdata
->gpio_defaults
[i
] = 0x10000;
792 dev_err(arizona
->dev
, "Failed to parse GPIO defaults: %d\n",
796 of_property_for_each_u32(arizona
->dev
->of_node
, "wlf,inmode", prop
,
798 if (count
== ARRAY_SIZE(pdata
->inmode
))
801 pdata
->inmode
[count
] = val
;
806 of_property_for_each_u32(arizona
->dev
->of_node
, "wlf,dmic-ref", prop
,
808 if (count
== ARRAY_SIZE(pdata
->dmic_ref
))
811 pdata
->dmic_ref
[count
] = val
;
818 const struct of_device_id arizona_of_match
[] = {
819 { .compatible
= "wlf,wm5102", .data
= (void *)WM5102
},
820 { .compatible
= "wlf,wm5110", .data
= (void *)WM5110
},
821 { .compatible
= "wlf,wm8280", .data
= (void *)WM8280
},
822 { .compatible
= "wlf,wm8997", .data
= (void *)WM8997
},
823 { .compatible
= "wlf,wm8998", .data
= (void *)WM8998
},
824 { .compatible
= "wlf,wm1814", .data
= (void *)WM1814
},
827 EXPORT_SYMBOL_GPL(arizona_of_match
);
829 static inline int arizona_of_get_core_pdata(struct arizona
*arizona
)
835 static const struct mfd_cell early_devs
[] = {
836 { .name
= "arizona-ldo1" },
839 static const char * const wm5102_supplies
[] = {
848 static const struct mfd_cell wm5102_devs
[] = {
849 { .name
= "arizona-micsupp" },
851 .name
= "arizona-extcon",
852 .parent_supplies
= wm5102_supplies
,
853 .num_parent_supplies
= 1, /* We only need MICVDD */
855 { .name
= "arizona-gpio" },
856 { .name
= "arizona-haptics" },
857 { .name
= "arizona-pwm" },
859 .name
= "wm5102-codec",
860 .parent_supplies
= wm5102_supplies
,
861 .num_parent_supplies
= ARRAY_SIZE(wm5102_supplies
),
865 static const struct mfd_cell wm5110_devs
[] = {
866 { .name
= "arizona-micsupp" },
868 .name
= "arizona-extcon",
869 .parent_supplies
= wm5102_supplies
,
870 .num_parent_supplies
= 1, /* We only need MICVDD */
872 { .name
= "arizona-gpio" },
873 { .name
= "arizona-haptics" },
874 { .name
= "arizona-pwm" },
876 .name
= "wm5110-codec",
877 .parent_supplies
= wm5102_supplies
,
878 .num_parent_supplies
= ARRAY_SIZE(wm5102_supplies
),
882 static const char * const wm8997_supplies
[] = {
889 static const struct mfd_cell wm8997_devs
[] = {
890 { .name
= "arizona-micsupp" },
892 .name
= "arizona-extcon",
893 .parent_supplies
= wm8997_supplies
,
894 .num_parent_supplies
= 1, /* We only need MICVDD */
896 { .name
= "arizona-gpio" },
897 { .name
= "arizona-haptics" },
898 { .name
= "arizona-pwm" },
900 .name
= "wm8997-codec",
901 .parent_supplies
= wm8997_supplies
,
902 .num_parent_supplies
= ARRAY_SIZE(wm8997_supplies
),
906 static const struct mfd_cell wm8998_devs
[] = {
908 .name
= "arizona-extcon",
909 .parent_supplies
= wm5102_supplies
,
910 .num_parent_supplies
= 1, /* We only need MICVDD */
912 { .name
= "arizona-gpio" },
913 { .name
= "arizona-haptics" },
914 { .name
= "arizona-pwm" },
916 .name
= "wm8998-codec",
917 .parent_supplies
= wm5102_supplies
,
918 .num_parent_supplies
= ARRAY_SIZE(wm5102_supplies
),
920 { .name
= "arizona-micsupp" },
923 int arizona_dev_init(struct arizona
*arizona
)
925 struct device
*dev
= arizona
->dev
;
926 const char *type_name
;
927 unsigned int reg
, val
, mask
;
928 int (*apply_patch
)(struct arizona
*) = NULL
;
931 dev_set_drvdata(arizona
->dev
, arizona
);
932 mutex_init(&arizona
->clk_lock
);
934 if (dev_get_platdata(arizona
->dev
))
935 memcpy(&arizona
->pdata
, dev_get_platdata(arizona
->dev
),
936 sizeof(arizona
->pdata
));
938 arizona_of_get_core_pdata(arizona
);
940 regcache_cache_only(arizona
->regmap
, true);
942 switch (arizona
->type
) {
949 for (i
= 0; i
< ARRAY_SIZE(wm5102_core_supplies
); i
++)
950 arizona
->core_supplies
[i
].supply
951 = wm5102_core_supplies
[i
];
952 arizona
->num_core_supplies
= ARRAY_SIZE(wm5102_core_supplies
);
955 dev_err(arizona
->dev
, "Unknown device type %d\n",
960 /* Mark DCVDD as external, LDO1 driver will clear if internal */
961 arizona
->external_dcvdd
= true;
963 ret
= mfd_add_devices(arizona
->dev
, -1, early_devs
,
964 ARRAY_SIZE(early_devs
), NULL
, 0, NULL
);
966 dev_err(dev
, "Failed to add early children: %d\n", ret
);
970 ret
= devm_regulator_bulk_get(dev
, arizona
->num_core_supplies
,
971 arizona
->core_supplies
);
973 dev_err(dev
, "Failed to request core supplies: %d\n",
979 * Don't use devres here because the only device we have to get
980 * against is the MFD device and DCVDD will likely be supplied by
981 * one of its children. Meaning that the regulator will be
982 * destroyed by the time devres calls regulator put.
984 arizona
->dcvdd
= regulator_get(arizona
->dev
, "DCVDD");
985 if (IS_ERR(arizona
->dcvdd
)) {
986 ret
= PTR_ERR(arizona
->dcvdd
);
987 dev_err(dev
, "Failed to request DCVDD: %d\n", ret
);
991 if (arizona
->pdata
.reset
) {
992 /* Start out with /RESET low to put the chip into reset */
993 ret
= devm_gpio_request_one(arizona
->dev
, arizona
->pdata
.reset
,
994 GPIOF_DIR_OUT
| GPIOF_INIT_LOW
,
997 dev_err(dev
, "Failed to request /RESET: %d\n", ret
);
1002 ret
= regulator_bulk_enable(arizona
->num_core_supplies
,
1003 arizona
->core_supplies
);
1005 dev_err(dev
, "Failed to enable core supplies: %d\n",
1010 ret
= regulator_enable(arizona
->dcvdd
);
1012 dev_err(dev
, "Failed to enable DCVDD: %d\n", ret
);
1016 arizona_disable_reset(arizona
);
1018 regcache_cache_only(arizona
->regmap
, false);
1020 /* Verify that this is a chip we know about */
1021 ret
= regmap_read(arizona
->regmap
, ARIZONA_SOFTWARE_RESET
, ®
);
1023 dev_err(dev
, "Failed to read ID register: %d\n", ret
);
1034 dev_err(arizona
->dev
, "Unknown device ID: %x\n", reg
);
1038 /* If we have a /RESET GPIO we'll already be reset */
1039 if (!arizona
->pdata
.reset
) {
1040 ret
= regmap_write(arizona
->regmap
, ARIZONA_SOFTWARE_RESET
, 0);
1042 dev_err(dev
, "Failed to reset device: %d\n", ret
);
1049 /* Ensure device startup is complete */
1050 switch (arizona
->type
) {
1052 ret
= regmap_read(arizona
->regmap
,
1053 ARIZONA_WRITE_SEQUENCER_CTRL_3
, &val
);
1056 "Failed to check write sequencer state: %d\n",
1058 } else if (val
& 0x01) {
1059 ret
= wm5102_clear_write_sequencer(arizona
);
1068 ret
= arizona_wait_for_boot(arizona
);
1070 dev_err(arizona
->dev
, "Device failed initial boot: %d\n", ret
);
1074 /* Read the device ID information & do device specific stuff */
1075 ret
= regmap_read(arizona
->regmap
, ARIZONA_SOFTWARE_RESET
, ®
);
1077 dev_err(dev
, "Failed to read ID register: %d\n", ret
);
1081 ret
= regmap_read(arizona
->regmap
, ARIZONA_DEVICE_REVISION
,
1084 dev_err(dev
, "Failed to read revision register: %d\n", ret
);
1087 arizona
->rev
&= ARIZONA_DEVICE_REVISION_MASK
;
1090 #ifdef CONFIG_MFD_WM5102
1092 type_name
= "WM5102";
1093 if (arizona
->type
!= WM5102
) {
1094 dev_err(arizona
->dev
, "WM5102 registered as %d\n",
1096 arizona
->type
= WM5102
;
1098 apply_patch
= wm5102_patch
;
1099 arizona
->rev
&= 0x7;
1102 #ifdef CONFIG_MFD_WM5110
1104 switch (arizona
->type
) {
1106 type_name
= "WM5110";
1109 type_name
= "WM8280";
1112 type_name
= "WM5110";
1113 dev_err(arizona
->dev
, "WM5110 registered as %d\n",
1115 arizona
->type
= WM5110
;
1118 apply_patch
= wm5110_patch
;
1121 #ifdef CONFIG_MFD_WM8997
1123 type_name
= "WM8997";
1124 if (arizona
->type
!= WM8997
) {
1125 dev_err(arizona
->dev
, "WM8997 registered as %d\n",
1127 arizona
->type
= WM8997
;
1129 apply_patch
= wm8997_patch
;
1132 #ifdef CONFIG_MFD_WM8998
1134 switch (arizona
->type
) {
1136 type_name
= "WM8998";
1140 type_name
= "WM1814";
1144 type_name
= "WM8998";
1145 dev_err(arizona
->dev
, "WM8998 registered as %d\n",
1147 arizona
->type
= WM8998
;
1150 apply_patch
= wm8998_patch
;
1154 dev_err(arizona
->dev
, "Unknown device ID %x\n", reg
);
1158 dev_info(dev
, "%s revision %c\n", type_name
, arizona
->rev
+ 'A');
1161 ret
= apply_patch(arizona
);
1163 dev_err(arizona
->dev
, "Failed to apply patch: %d\n",
1168 switch (arizona
->type
) {
1170 ret
= wm5102_apply_hardware_patch(arizona
);
1172 dev_err(arizona
->dev
,
1173 "Failed to apply hardware patch: %d\n",
1180 ret
= wm5110_apply_sleep_patch(arizona
);
1182 dev_err(arizona
->dev
,
1183 "Failed to apply sleep patch: %d\n",
1193 for (i
= 0; i
< ARRAY_SIZE(arizona
->pdata
.gpio_defaults
); i
++) {
1194 if (!arizona
->pdata
.gpio_defaults
[i
])
1197 regmap_write(arizona
->regmap
, ARIZONA_GPIO1_CTRL
+ i
,
1198 arizona
->pdata
.gpio_defaults
[i
]);
1202 if (!arizona
->pdata
.clk32k_src
)
1203 arizona
->pdata
.clk32k_src
= ARIZONA_32KZ_MCLK2
;
1205 switch (arizona
->pdata
.clk32k_src
) {
1206 case ARIZONA_32KZ_MCLK1
:
1207 case ARIZONA_32KZ_MCLK2
:
1208 regmap_update_bits(arizona
->regmap
, ARIZONA_CLOCK_32K_1
,
1209 ARIZONA_CLK_32K_SRC_MASK
,
1210 arizona
->pdata
.clk32k_src
- 1);
1211 arizona_clk32k_enable(arizona
);
1213 case ARIZONA_32KZ_NONE
:
1214 regmap_update_bits(arizona
->regmap
, ARIZONA_CLOCK_32K_1
,
1215 ARIZONA_CLK_32K_SRC_MASK
, 2);
1218 dev_err(arizona
->dev
, "Invalid 32kHz clock source: %d\n",
1219 arizona
->pdata
.clk32k_src
);
1224 for (i
= 0; i
< ARIZONA_MAX_MICBIAS
; i
++) {
1225 if (!arizona
->pdata
.micbias
[i
].mV
&&
1226 !arizona
->pdata
.micbias
[i
].bypass
)
1229 /* Apply default for bypass mode */
1230 if (!arizona
->pdata
.micbias
[i
].mV
)
1231 arizona
->pdata
.micbias
[i
].mV
= 2800;
1233 val
= (arizona
->pdata
.micbias
[i
].mV
- 1500) / 100;
1235 val
<<= ARIZONA_MICB1_LVL_SHIFT
;
1237 if (arizona
->pdata
.micbias
[i
].ext_cap
)
1238 val
|= ARIZONA_MICB1_EXT_CAP
;
1240 if (arizona
->pdata
.micbias
[i
].discharge
)
1241 val
|= ARIZONA_MICB1_DISCH
;
1243 if (arizona
->pdata
.micbias
[i
].soft_start
)
1244 val
|= ARIZONA_MICB1_RATE
;
1246 if (arizona
->pdata
.micbias
[i
].bypass
)
1247 val
|= ARIZONA_MICB1_BYPASS
;
1249 regmap_update_bits(arizona
->regmap
,
1250 ARIZONA_MIC_BIAS_CTRL_1
+ i
,
1251 ARIZONA_MICB1_LVL_MASK
|
1252 ARIZONA_MICB1_EXT_CAP
|
1253 ARIZONA_MICB1_DISCH
|
1254 ARIZONA_MICB1_BYPASS
|
1255 ARIZONA_MICB1_RATE
, val
);
1258 for (i
= 0; i
< ARIZONA_MAX_INPUT
; i
++) {
1259 /* Default for both is 0 so noop with defaults */
1260 val
= arizona
->pdata
.dmic_ref
[i
]
1261 << ARIZONA_IN1_DMIC_SUP_SHIFT
;
1262 if (arizona
->pdata
.inmode
[i
] & ARIZONA_INMODE_DMIC
)
1263 val
|= 1 << ARIZONA_IN1_MODE_SHIFT
;
1265 switch (arizona
->type
) {
1268 regmap_update_bits(arizona
->regmap
,
1269 ARIZONA_ADC_DIGITAL_VOLUME_1L
+ (i
* 8),
1270 ARIZONA_IN1L_SRC_SE_MASK
,
1271 (arizona
->pdata
.inmode
[i
] & ARIZONA_INMODE_SE
)
1272 << ARIZONA_IN1L_SRC_SE_SHIFT
);
1274 regmap_update_bits(arizona
->regmap
,
1275 ARIZONA_ADC_DIGITAL_VOLUME_1R
+ (i
* 8),
1276 ARIZONA_IN1R_SRC_SE_MASK
,
1277 (arizona
->pdata
.inmode
[i
] & ARIZONA_INMODE_SE
)
1278 << ARIZONA_IN1R_SRC_SE_SHIFT
);
1280 mask
= ARIZONA_IN1_DMIC_SUP_MASK
|
1281 ARIZONA_IN1_MODE_MASK
;
1284 if (arizona
->pdata
.inmode
[i
] & ARIZONA_INMODE_SE
)
1285 val
|= 1 << ARIZONA_IN1_SINGLE_ENDED_SHIFT
;
1287 mask
= ARIZONA_IN1_DMIC_SUP_MASK
|
1288 ARIZONA_IN1_MODE_MASK
|
1289 ARIZONA_IN1_SINGLE_ENDED_MASK
;
1293 regmap_update_bits(arizona
->regmap
,
1294 ARIZONA_IN1L_CONTROL
+ (i
* 8),
1298 for (i
= 0; i
< ARIZONA_MAX_OUTPUT
; i
++) {
1299 /* Default is 0 so noop with defaults */
1300 if (arizona
->pdata
.out_mono
[i
])
1301 val
= ARIZONA_OUT1_MONO
;
1305 regmap_update_bits(arizona
->regmap
,
1306 ARIZONA_OUTPUT_PATH_CONFIG_1L
+ (i
* 8),
1307 ARIZONA_OUT1_MONO
, val
);
1310 for (i
= 0; i
< ARIZONA_MAX_PDM_SPK
; i
++) {
1311 if (arizona
->pdata
.spk_mute
[i
])
1312 regmap_update_bits(arizona
->regmap
,
1313 ARIZONA_PDM_SPK1_CTRL_1
+ (i
* 2),
1314 ARIZONA_SPK1_MUTE_ENDIAN_MASK
|
1315 ARIZONA_SPK1_MUTE_SEQ1_MASK
,
1316 arizona
->pdata
.spk_mute
[i
]);
1318 if (arizona
->pdata
.spk_fmt
[i
])
1319 regmap_update_bits(arizona
->regmap
,
1320 ARIZONA_PDM_SPK1_CTRL_2
+ (i
* 2),
1321 ARIZONA_SPK1_FMT_MASK
,
1322 arizona
->pdata
.spk_fmt
[i
]);
1325 pm_runtime_set_active(arizona
->dev
);
1326 pm_runtime_enable(arizona
->dev
);
1328 /* Set up for interrupts */
1329 ret
= arizona_irq_init(arizona
);
1333 pm_runtime_set_autosuspend_delay(arizona
->dev
, 100);
1334 pm_runtime_use_autosuspend(arizona
->dev
);
1336 arizona_request_irq(arizona
, ARIZONA_IRQ_CLKGEN_ERR
, "CLKGEN error",
1337 arizona_clkgen_err
, arizona
);
1338 arizona_request_irq(arizona
, ARIZONA_IRQ_OVERCLOCKED
, "Overclocked",
1339 arizona_overclocked
, arizona
);
1340 arizona_request_irq(arizona
, ARIZONA_IRQ_UNDERCLOCKED
, "Underclocked",
1341 arizona_underclocked
, arizona
);
1343 switch (arizona
->type
) {
1345 ret
= mfd_add_devices(arizona
->dev
, -1, wm5102_devs
,
1346 ARRAY_SIZE(wm5102_devs
), NULL
, 0, NULL
);
1350 ret
= mfd_add_devices(arizona
->dev
, -1, wm5110_devs
,
1351 ARRAY_SIZE(wm5110_devs
), NULL
, 0, NULL
);
1354 ret
= mfd_add_devices(arizona
->dev
, -1, wm8997_devs
,
1355 ARRAY_SIZE(wm8997_devs
), NULL
, 0, NULL
);
1359 ret
= mfd_add_devices(arizona
->dev
, -1, wm8998_devs
,
1360 ARRAY_SIZE(wm8998_devs
), NULL
, 0, NULL
);
1365 dev_err(arizona
->dev
, "Failed to add subdevices: %d\n", ret
);
1372 arizona_irq_exit(arizona
);
1374 arizona_enable_reset(arizona
);
1375 regulator_disable(arizona
->dcvdd
);
1377 regulator_bulk_disable(arizona
->num_core_supplies
,
1378 arizona
->core_supplies
);
1380 regulator_put(arizona
->dcvdd
);
1382 mfd_remove_devices(dev
);
1385 EXPORT_SYMBOL_GPL(arizona_dev_init
);
1387 int arizona_dev_exit(struct arizona
*arizona
)
1389 pm_runtime_disable(arizona
->dev
);
1391 regulator_disable(arizona
->dcvdd
);
1392 regulator_put(arizona
->dcvdd
);
1394 mfd_remove_devices(arizona
->dev
);
1395 arizona_free_irq(arizona
, ARIZONA_IRQ_UNDERCLOCKED
, arizona
);
1396 arizona_free_irq(arizona
, ARIZONA_IRQ_OVERCLOCKED
, arizona
);
1397 arizona_free_irq(arizona
, ARIZONA_IRQ_CLKGEN_ERR
, arizona
);
1398 arizona_irq_exit(arizona
);
1399 arizona_enable_reset(arizona
);
1401 regulator_bulk_disable(arizona
->num_core_supplies
,
1402 arizona
->core_supplies
);
1405 EXPORT_SYMBOL_GPL(arizona_dev_exit
);