xref: /openbmc/linux/drivers/mfd/arizona-core.c (revision abfbd895)
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 		msleep(1);
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 			msleep(5);
283 			break;
284 		default:
285 			break;
286 		}
287 
288 		gpio_set_value_cansleep(arizona->pdata.reset, 1);
289 		msleep(1);
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 	default:
602 		ret = arizona_wait_for_boot(arizona);
603 		if (ret != 0)
604 			goto err;
605 
606 		if (arizona->external_dcvdd) {
607 			ret = arizona_connect_dcvdd(arizona);
608 			if (ret != 0)
609 				goto err;
610 		}
611 		break;
612 	}
613 
614 	ret = regcache_sync(arizona->regmap);
615 	if (ret != 0) {
616 		dev_err(arizona->dev, "Failed to restore register cache\n");
617 		goto err;
618 	}
619 
620 	return 0;
621 
622 err:
623 	regcache_cache_only(arizona->regmap, true);
624 	regulator_disable(arizona->dcvdd);
625 	return ret;
626 }
627 
628 static int arizona_runtime_suspend(struct device *dev)
629 {
630 	struct arizona *arizona = dev_get_drvdata(dev);
631 	int jd_active = 0;
632 	int ret;
633 
634 	dev_dbg(arizona->dev, "Entering AoD mode\n");
635 
636 	switch (arizona->type) {
637 	case WM5110:
638 	case WM8280:
639 		jd_active = arizona_is_jack_det_active(arizona);
640 		if (jd_active < 0)
641 			return jd_active;
642 
643 		if (arizona->external_dcvdd) {
644 			ret = arizona_isolate_dcvdd(arizona);
645 			if (ret != 0)
646 				return ret;
647 		} else {
648 			/*
649 			 * As this is only called for the internal regulator
650 			 * (where we know voltage ranges available) it is ok
651 			 * to request an exact range.
652 			 */
653 			ret = regulator_set_voltage(arizona->dcvdd,
654 						    1175000, 1175000);
655 			if (ret < 0) {
656 				dev_err(arizona->dev,
657 					"Failed to set suspend voltage: %d\n",
658 					ret);
659 				return ret;
660 			}
661 		}
662 		break;
663 	case WM5102:
664 		jd_active = arizona_is_jack_det_active(arizona);
665 		if (jd_active < 0)
666 			return jd_active;
667 
668 		if (arizona->external_dcvdd) {
669 			ret = arizona_isolate_dcvdd(arizona);
670 			if (ret != 0)
671 				return ret;
672 		}
673 
674 		if (!jd_active) {
675 			ret = regmap_write(arizona->regmap,
676 					   ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0);
677 			if (ret) {
678 				dev_err(arizona->dev,
679 					"Failed to clear write sequencer: %d\n",
680 					ret);
681 				return ret;
682 			}
683 		}
684 		break;
685 	default:
686 		jd_active = arizona_is_jack_det_active(arizona);
687 		if (jd_active < 0)
688 			return jd_active;
689 
690 		if (arizona->external_dcvdd) {
691 			ret = arizona_isolate_dcvdd(arizona);
692 			if (ret != 0)
693 				return ret;
694 		}
695 		break;
696 	}
697 
698 	regcache_cache_only(arizona->regmap, true);
699 	regcache_mark_dirty(arizona->regmap);
700 	regulator_disable(arizona->dcvdd);
701 
702 	/* Allow us to completely power down if no jack detection */
703 	if (!jd_active) {
704 		dev_dbg(arizona->dev, "Fully powering off\n");
705 
706 		arizona->has_fully_powered_off = true;
707 
708 		disable_irq_nosync(arizona->irq);
709 		arizona_enable_reset(arizona);
710 		regulator_bulk_disable(arizona->num_core_supplies,
711 				       arizona->core_supplies);
712 	}
713 
714 	return 0;
715 }
716 #endif
717 
718 #ifdef CONFIG_PM_SLEEP
719 static int arizona_suspend(struct device *dev)
720 {
721 	struct arizona *arizona = dev_get_drvdata(dev);
722 
723 	dev_dbg(arizona->dev, "Suspend, disabling IRQ\n");
724 	disable_irq(arizona->irq);
725 
726 	return 0;
727 }
728 
729 static int arizona_suspend_late(struct device *dev)
730 {
731 	struct arizona *arizona = dev_get_drvdata(dev);
732 
733 	dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n");
734 	enable_irq(arizona->irq);
735 
736 	return 0;
737 }
738 
739 static int arizona_resume_noirq(struct device *dev)
740 {
741 	struct arizona *arizona = dev_get_drvdata(dev);
742 
743 	dev_dbg(arizona->dev, "Early resume, disabling IRQ\n");
744 	disable_irq(arizona->irq);
745 
746 	return 0;
747 }
748 
749 static int arizona_resume(struct device *dev)
750 {
751 	struct arizona *arizona = dev_get_drvdata(dev);
752 
753 	dev_dbg(arizona->dev, "Late resume, reenabling IRQ\n");
754 	enable_irq(arizona->irq);
755 
756 	return 0;
757 }
758 #endif
759 
760 const struct dev_pm_ops arizona_pm_ops = {
761 	SET_RUNTIME_PM_OPS(arizona_runtime_suspend,
762 			   arizona_runtime_resume,
763 			   NULL)
764 	SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume)
765 #ifdef CONFIG_PM_SLEEP
766 	.suspend_late = arizona_suspend_late,
767 	.resume_noirq = arizona_resume_noirq,
768 #endif
769 };
770 EXPORT_SYMBOL_GPL(arizona_pm_ops);
771 
772 #ifdef CONFIG_OF
773 unsigned long arizona_of_get_type(struct device *dev)
774 {
775 	const struct of_device_id *id = of_match_device(arizona_of_match, dev);
776 
777 	if (id)
778 		return (unsigned long)id->data;
779 	else
780 		return 0;
781 }
782 EXPORT_SYMBOL_GPL(arizona_of_get_type);
783 
784 int arizona_of_get_named_gpio(struct arizona *arizona, const char *prop,
785 			      bool mandatory)
786 {
787 	int gpio;
788 
789 	gpio = of_get_named_gpio(arizona->dev->of_node, prop, 0);
790 	if (gpio < 0) {
791 		if (mandatory)
792 			dev_err(arizona->dev,
793 				"Mandatory DT gpio %s missing/malformed: %d\n",
794 				prop, gpio);
795 
796 		gpio = 0;
797 	}
798 
799 	return gpio;
800 }
801 EXPORT_SYMBOL_GPL(arizona_of_get_named_gpio);
802 
803 static int arizona_of_get_core_pdata(struct arizona *arizona)
804 {
805 	struct arizona_pdata *pdata = &arizona->pdata;
806 	struct property *prop;
807 	const __be32 *cur;
808 	u32 val;
809 	int ret, i;
810 	int count = 0;
811 
812 	pdata->reset = arizona_of_get_named_gpio(arizona, "wlf,reset", true);
813 
814 	ret = of_property_read_u32_array(arizona->dev->of_node,
815 					 "wlf,gpio-defaults",
816 					 pdata->gpio_defaults,
817 					 ARRAY_SIZE(pdata->gpio_defaults));
818 	if (ret >= 0) {
819 		/*
820 		 * All values are literal except out of range values
821 		 * which are chip default, translate into platform
822 		 * data which uses 0 as chip default and out of range
823 		 * as zero.
824 		 */
825 		for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
826 			if (pdata->gpio_defaults[i] > 0xffff)
827 				pdata->gpio_defaults[i] = 0;
828 			else if (pdata->gpio_defaults[i] == 0)
829 				pdata->gpio_defaults[i] = 0x10000;
830 		}
831 	} else {
832 		dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n",
833 			ret);
834 	}
835 
836 	of_property_for_each_u32(arizona->dev->of_node, "wlf,inmode", prop,
837 				 cur, val) {
838 		if (count == ARRAY_SIZE(pdata->inmode))
839 			break;
840 
841 		pdata->inmode[count] = val;
842 		count++;
843 	}
844 
845 	count = 0;
846 	of_property_for_each_u32(arizona->dev->of_node, "wlf,dmic-ref", prop,
847 				 cur, val) {
848 		if (count == ARRAY_SIZE(pdata->dmic_ref))
849 			break;
850 
851 		pdata->dmic_ref[count] = val;
852 		count++;
853 	}
854 
855 	return 0;
856 }
857 
858 const struct of_device_id arizona_of_match[] = {
859 	{ .compatible = "wlf,wm5102", .data = (void *)WM5102 },
860 	{ .compatible = "wlf,wm5110", .data = (void *)WM5110 },
861 	{ .compatible = "wlf,wm8280", .data = (void *)WM8280 },
862 	{ .compatible = "wlf,wm8997", .data = (void *)WM8997 },
863 	{ .compatible = "wlf,wm8998", .data = (void *)WM8998 },
864 	{ .compatible = "wlf,wm1814", .data = (void *)WM1814 },
865 	{},
866 };
867 EXPORT_SYMBOL_GPL(arizona_of_match);
868 #else
869 static inline int arizona_of_get_core_pdata(struct arizona *arizona)
870 {
871 	return 0;
872 }
873 #endif
874 
875 static const struct mfd_cell early_devs[] = {
876 	{ .name = "arizona-ldo1" },
877 };
878 
879 static const char * const wm5102_supplies[] = {
880 	"MICVDD",
881 	"DBVDD2",
882 	"DBVDD3",
883 	"CPVDD",
884 	"SPKVDDL",
885 	"SPKVDDR",
886 };
887 
888 static const struct mfd_cell wm5102_devs[] = {
889 	{ .name = "arizona-micsupp" },
890 	{
891 		.name = "arizona-extcon",
892 		.parent_supplies = wm5102_supplies,
893 		.num_parent_supplies = 1, /* We only need MICVDD */
894 	},
895 	{ .name = "arizona-gpio" },
896 	{ .name = "arizona-haptics" },
897 	{ .name = "arizona-pwm" },
898 	{
899 		.name = "wm5102-codec",
900 		.parent_supplies = wm5102_supplies,
901 		.num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
902 	},
903 };
904 
905 static const struct mfd_cell wm5110_devs[] = {
906 	{ .name = "arizona-micsupp" },
907 	{
908 		.name = "arizona-extcon",
909 		.parent_supplies = wm5102_supplies,
910 		.num_parent_supplies = 1, /* We only need MICVDD */
911 	},
912 	{ .name = "arizona-gpio" },
913 	{ .name = "arizona-haptics" },
914 	{ .name = "arizona-pwm" },
915 	{
916 		.name = "wm5110-codec",
917 		.parent_supplies = wm5102_supplies,
918 		.num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
919 	},
920 };
921 
922 static const char * const wm8997_supplies[] = {
923 	"MICVDD",
924 	"DBVDD2",
925 	"CPVDD",
926 	"SPKVDD",
927 };
928 
929 static const struct mfd_cell wm8997_devs[] = {
930 	{ .name = "arizona-micsupp" },
931 	{
932 		.name = "arizona-extcon",
933 		.parent_supplies = wm8997_supplies,
934 		.num_parent_supplies = 1, /* We only need MICVDD */
935 	},
936 	{ .name = "arizona-gpio" },
937 	{ .name = "arizona-haptics" },
938 	{ .name = "arizona-pwm" },
939 	{
940 		.name = "wm8997-codec",
941 		.parent_supplies = wm8997_supplies,
942 		.num_parent_supplies = ARRAY_SIZE(wm8997_supplies),
943 	},
944 };
945 
946 static const struct mfd_cell wm8998_devs[] = {
947 	{
948 		.name = "arizona-extcon",
949 		.parent_supplies = wm5102_supplies,
950 		.num_parent_supplies = 1, /* We only need MICVDD */
951 	},
952 	{ .name = "arizona-gpio" },
953 	{ .name = "arizona-haptics" },
954 	{ .name = "arizona-pwm" },
955 	{
956 		.name = "wm8998-codec",
957 		.parent_supplies = wm5102_supplies,
958 		.num_parent_supplies = ARRAY_SIZE(wm5102_supplies),
959 	},
960 	{ .name = "arizona-micsupp" },
961 };
962 
963 int arizona_dev_init(struct arizona *arizona)
964 {
965 	struct device *dev = arizona->dev;
966 	const char *type_name;
967 	unsigned int reg, val, mask;
968 	int (*apply_patch)(struct arizona *) = NULL;
969 	const struct mfd_cell *subdevs = NULL;
970 	int n_subdevs, ret, i;
971 
972 	dev_set_drvdata(arizona->dev, arizona);
973 	mutex_init(&arizona->clk_lock);
974 
975 	if (dev_get_platdata(arizona->dev))
976 		memcpy(&arizona->pdata, dev_get_platdata(arizona->dev),
977 		       sizeof(arizona->pdata));
978 	else
979 		arizona_of_get_core_pdata(arizona);
980 
981 	regcache_cache_only(arizona->regmap, true);
982 
983 	switch (arizona->type) {
984 	case WM5102:
985 	case WM5110:
986 	case WM8280:
987 	case WM8997:
988 	case WM8998:
989 	case WM1814:
990 		for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++)
991 			arizona->core_supplies[i].supply
992 				= wm5102_core_supplies[i];
993 		arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies);
994 		break;
995 	default:
996 		dev_err(arizona->dev, "Unknown device type %d\n",
997 			arizona->type);
998 		return -EINVAL;
999 	}
1000 
1001 	/* Mark DCVDD as external, LDO1 driver will clear if internal */
1002 	arizona->external_dcvdd = true;
1003 
1004 	ret = mfd_add_devices(arizona->dev, -1, early_devs,
1005 			      ARRAY_SIZE(early_devs), NULL, 0, NULL);
1006 	if (ret != 0) {
1007 		dev_err(dev, "Failed to add early children: %d\n", ret);
1008 		return ret;
1009 	}
1010 
1011 	ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies,
1012 				      arizona->core_supplies);
1013 	if (ret != 0) {
1014 		dev_err(dev, "Failed to request core supplies: %d\n",
1015 			ret);
1016 		goto err_early;
1017 	}
1018 
1019 	/**
1020 	 * Don't use devres here because the only device we have to get
1021 	 * against is the MFD device and DCVDD will likely be supplied by
1022 	 * one of its children. Meaning that the regulator will be
1023 	 * destroyed by the time devres calls regulator put.
1024 	 */
1025 	arizona->dcvdd = regulator_get(arizona->dev, "DCVDD");
1026 	if (IS_ERR(arizona->dcvdd)) {
1027 		ret = PTR_ERR(arizona->dcvdd);
1028 		dev_err(dev, "Failed to request DCVDD: %d\n", ret);
1029 		goto err_early;
1030 	}
1031 
1032 	if (arizona->pdata.reset) {
1033 		/* Start out with /RESET low to put the chip into reset */
1034 		ret = devm_gpio_request_one(arizona->dev, arizona->pdata.reset,
1035 					    GPIOF_DIR_OUT | GPIOF_INIT_LOW,
1036 					    "arizona /RESET");
1037 		if (ret != 0) {
1038 			dev_err(dev, "Failed to request /RESET: %d\n", ret);
1039 			goto err_dcvdd;
1040 		}
1041 	}
1042 
1043 	ret = regulator_bulk_enable(arizona->num_core_supplies,
1044 				    arizona->core_supplies);
1045 	if (ret != 0) {
1046 		dev_err(dev, "Failed to enable core supplies: %d\n",
1047 			ret);
1048 		goto err_dcvdd;
1049 	}
1050 
1051 	ret = regulator_enable(arizona->dcvdd);
1052 	if (ret != 0) {
1053 		dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
1054 		goto err_enable;
1055 	}
1056 
1057 	arizona_disable_reset(arizona);
1058 
1059 	regcache_cache_only(arizona->regmap, false);
1060 
1061 	/* Verify that this is a chip we know about */
1062 	ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1063 	if (ret != 0) {
1064 		dev_err(dev, "Failed to read ID register: %d\n", ret);
1065 		goto err_reset;
1066 	}
1067 
1068 	switch (reg) {
1069 	case 0x5102:
1070 	case 0x5110:
1071 	case 0x6349:
1072 	case 0x8997:
1073 		break;
1074 	default:
1075 		dev_err(arizona->dev, "Unknown device ID: %x\n", reg);
1076 		goto err_reset;
1077 	}
1078 
1079 	/* If we have a /RESET GPIO we'll already be reset */
1080 	if (!arizona->pdata.reset) {
1081 		ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0);
1082 		if (ret != 0) {
1083 			dev_err(dev, "Failed to reset device: %d\n", ret);
1084 			goto err_reset;
1085 		}
1086 
1087 		msleep(1);
1088 	}
1089 
1090 	/* Ensure device startup is complete */
1091 	switch (arizona->type) {
1092 	case WM5102:
1093 		ret = regmap_read(arizona->regmap,
1094 				  ARIZONA_WRITE_SEQUENCER_CTRL_3, &val);
1095 		if (ret) {
1096 			dev_err(dev,
1097 				"Failed to check write sequencer state: %d\n",
1098 				ret);
1099 		} else if (val & 0x01) {
1100 			ret = wm5102_clear_write_sequencer(arizona);
1101 			if (ret)
1102 				return ret;
1103 		}
1104 		break;
1105 	default:
1106 		break;
1107 	}
1108 
1109 	ret = arizona_wait_for_boot(arizona);
1110 	if (ret) {
1111 		dev_err(arizona->dev, "Device failed initial boot: %d\n", ret);
1112 		goto err_reset;
1113 	}
1114 
1115 	/* Read the device ID information & do device specific stuff */
1116 	ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg);
1117 	if (ret != 0) {
1118 		dev_err(dev, "Failed to read ID register: %d\n", ret);
1119 		goto err_reset;
1120 	}
1121 
1122 	ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION,
1123 			  &arizona->rev);
1124 	if (ret != 0) {
1125 		dev_err(dev, "Failed to read revision register: %d\n", ret);
1126 		goto err_reset;
1127 	}
1128 	arizona->rev &= ARIZONA_DEVICE_REVISION_MASK;
1129 
1130 	switch (reg) {
1131 	case 0x5102:
1132 		if (IS_ENABLED(CONFIG_MFD_WM5102)) {
1133 			type_name = "WM5102";
1134 			if (arizona->type != WM5102) {
1135 				dev_warn(arizona->dev,
1136 					 "WM5102 registered as %d\n",
1137 					 arizona->type);
1138 				arizona->type = WM5102;
1139 			}
1140 
1141 			apply_patch = wm5102_patch;
1142 			arizona->rev &= 0x7;
1143 			subdevs = wm5102_devs;
1144 			n_subdevs = ARRAY_SIZE(wm5102_devs);
1145 		}
1146 		break;
1147 	case 0x5110:
1148 		if (IS_ENABLED(CONFIG_MFD_WM5110)) {
1149 			switch (arizona->type) {
1150 			case WM5110:
1151 				type_name = "WM5110";
1152 				break;
1153 			case WM8280:
1154 				type_name = "WM8280";
1155 				break;
1156 			default:
1157 				type_name = "WM5110";
1158 				dev_warn(arizona->dev,
1159 					 "WM5110 registered as %d\n",
1160 					 arizona->type);
1161 				arizona->type = WM5110;
1162 				break;
1163 			}
1164 
1165 			apply_patch = wm5110_patch;
1166 			subdevs = wm5110_devs;
1167 			n_subdevs = ARRAY_SIZE(wm5110_devs);
1168 		}
1169 		break;
1170 	case 0x8997:
1171 		if (IS_ENABLED(CONFIG_MFD_WM8997)) {
1172 			type_name = "WM8997";
1173 			if (arizona->type != WM8997) {
1174 				dev_warn(arizona->dev,
1175 					 "WM8997 registered as %d\n",
1176 					 arizona->type);
1177 				arizona->type = WM8997;
1178 			}
1179 
1180 			apply_patch = wm8997_patch;
1181 			subdevs = wm8997_devs;
1182 			n_subdevs = ARRAY_SIZE(wm8997_devs);
1183 		}
1184 		break;
1185 	case 0x6349:
1186 		if (IS_ENABLED(CONFIG_MFD_WM8998)) {
1187 			switch (arizona->type) {
1188 			case WM8998:
1189 				type_name = "WM8998";
1190 				break;
1191 
1192 			case WM1814:
1193 				type_name = "WM1814";
1194 				break;
1195 
1196 			default:
1197 				type_name = "WM8998";
1198 				dev_warn(arizona->dev,
1199 					 "WM8998 registered as %d\n",
1200 					 arizona->type);
1201 				arizona->type = WM8998;
1202 			}
1203 
1204 			apply_patch = wm8998_patch;
1205 			subdevs = wm8998_devs;
1206 			n_subdevs = ARRAY_SIZE(wm8998_devs);
1207 		}
1208 		break;
1209 	default:
1210 		dev_err(arizona->dev, "Unknown device ID %x\n", reg);
1211 		goto err_reset;
1212 	}
1213 
1214 	if (!subdevs) {
1215 		dev_err(arizona->dev,
1216 			"No kernel support for device ID %x\n", reg);
1217 		goto err_reset;
1218 	}
1219 
1220 	dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A');
1221 
1222 	if (apply_patch) {
1223 		ret = apply_patch(arizona);
1224 		if (ret != 0) {
1225 			dev_err(arizona->dev, "Failed to apply patch: %d\n",
1226 				ret);
1227 			goto err_reset;
1228 		}
1229 
1230 		switch (arizona->type) {
1231 		case WM5102:
1232 			ret = wm5102_apply_hardware_patch(arizona);
1233 			if (ret) {
1234 				dev_err(arizona->dev,
1235 					"Failed to apply hardware patch: %d\n",
1236 					ret);
1237 				goto err_reset;
1238 			}
1239 			break;
1240 		case WM5110:
1241 		case WM8280:
1242 			ret = wm5110_apply_sleep_patch(arizona);
1243 			if (ret) {
1244 				dev_err(arizona->dev,
1245 					"Failed to apply sleep patch: %d\n",
1246 					ret);
1247 				goto err_reset;
1248 			}
1249 			break;
1250 		default:
1251 			break;
1252 		}
1253 	}
1254 
1255 	for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {
1256 		if (!arizona->pdata.gpio_defaults[i])
1257 			continue;
1258 
1259 		regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i,
1260 			     arizona->pdata.gpio_defaults[i]);
1261 	}
1262 
1263 	/* Chip default */
1264 	if (!arizona->pdata.clk32k_src)
1265 		arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2;
1266 
1267 	switch (arizona->pdata.clk32k_src) {
1268 	case ARIZONA_32KZ_MCLK1:
1269 	case ARIZONA_32KZ_MCLK2:
1270 		regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1271 				   ARIZONA_CLK_32K_SRC_MASK,
1272 				   arizona->pdata.clk32k_src - 1);
1273 		arizona_clk32k_enable(arizona);
1274 		break;
1275 	case ARIZONA_32KZ_NONE:
1276 		regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1,
1277 				   ARIZONA_CLK_32K_SRC_MASK, 2);
1278 		break;
1279 	default:
1280 		dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n",
1281 			arizona->pdata.clk32k_src);
1282 		ret = -EINVAL;
1283 		goto err_reset;
1284 	}
1285 
1286 	for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) {
1287 		if (!arizona->pdata.micbias[i].mV &&
1288 		    !arizona->pdata.micbias[i].bypass)
1289 			continue;
1290 
1291 		/* Apply default for bypass mode */
1292 		if (!arizona->pdata.micbias[i].mV)
1293 			arizona->pdata.micbias[i].mV = 2800;
1294 
1295 		val = (arizona->pdata.micbias[i].mV - 1500) / 100;
1296 
1297 		val <<= ARIZONA_MICB1_LVL_SHIFT;
1298 
1299 		if (arizona->pdata.micbias[i].ext_cap)
1300 			val |= ARIZONA_MICB1_EXT_CAP;
1301 
1302 		if (arizona->pdata.micbias[i].discharge)
1303 			val |= ARIZONA_MICB1_DISCH;
1304 
1305 		if (arizona->pdata.micbias[i].soft_start)
1306 			val |= ARIZONA_MICB1_RATE;
1307 
1308 		if (arizona->pdata.micbias[i].bypass)
1309 			val |= ARIZONA_MICB1_BYPASS;
1310 
1311 		regmap_update_bits(arizona->regmap,
1312 				   ARIZONA_MIC_BIAS_CTRL_1 + i,
1313 				   ARIZONA_MICB1_LVL_MASK |
1314 				   ARIZONA_MICB1_EXT_CAP |
1315 				   ARIZONA_MICB1_DISCH |
1316 				   ARIZONA_MICB1_BYPASS |
1317 				   ARIZONA_MICB1_RATE, val);
1318 	}
1319 
1320 	for (i = 0; i < ARIZONA_MAX_INPUT; i++) {
1321 		/* Default for both is 0 so noop with defaults */
1322 		val = arizona->pdata.dmic_ref[i]
1323 			<< ARIZONA_IN1_DMIC_SUP_SHIFT;
1324 		if (arizona->pdata.inmode[i] & ARIZONA_INMODE_DMIC)
1325 			val |= 1 << ARIZONA_IN1_MODE_SHIFT;
1326 
1327 		switch (arizona->type) {
1328 		case WM8998:
1329 		case WM1814:
1330 			regmap_update_bits(arizona->regmap,
1331 				ARIZONA_ADC_DIGITAL_VOLUME_1L + (i * 8),
1332 				ARIZONA_IN1L_SRC_SE_MASK,
1333 				(arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1334 					<< ARIZONA_IN1L_SRC_SE_SHIFT);
1335 
1336 			regmap_update_bits(arizona->regmap,
1337 				ARIZONA_ADC_DIGITAL_VOLUME_1R + (i * 8),
1338 				ARIZONA_IN1R_SRC_SE_MASK,
1339 				(arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1340 					<< ARIZONA_IN1R_SRC_SE_SHIFT);
1341 
1342 			mask = ARIZONA_IN1_DMIC_SUP_MASK |
1343 				ARIZONA_IN1_MODE_MASK;
1344 			break;
1345 		default:
1346 			if (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE)
1347 				val |= 1 << ARIZONA_IN1_SINGLE_ENDED_SHIFT;
1348 
1349 			mask = ARIZONA_IN1_DMIC_SUP_MASK |
1350 				ARIZONA_IN1_MODE_MASK |
1351 				ARIZONA_IN1_SINGLE_ENDED_MASK;
1352 			break;
1353 		}
1354 
1355 		regmap_update_bits(arizona->regmap,
1356 				   ARIZONA_IN1L_CONTROL + (i * 8),
1357 				   mask, val);
1358 	}
1359 
1360 	for (i = 0; i < ARIZONA_MAX_OUTPUT; i++) {
1361 		/* Default is 0 so noop with defaults */
1362 		if (arizona->pdata.out_mono[i])
1363 			val = ARIZONA_OUT1_MONO;
1364 		else
1365 			val = 0;
1366 
1367 		regmap_update_bits(arizona->regmap,
1368 				   ARIZONA_OUTPUT_PATH_CONFIG_1L + (i * 8),
1369 				   ARIZONA_OUT1_MONO, val);
1370 	}
1371 
1372 	for (i = 0; i < ARIZONA_MAX_PDM_SPK; i++) {
1373 		if (arizona->pdata.spk_mute[i])
1374 			regmap_update_bits(arizona->regmap,
1375 					   ARIZONA_PDM_SPK1_CTRL_1 + (i * 2),
1376 					   ARIZONA_SPK1_MUTE_ENDIAN_MASK |
1377 					   ARIZONA_SPK1_MUTE_SEQ1_MASK,
1378 					   arizona->pdata.spk_mute[i]);
1379 
1380 		if (arizona->pdata.spk_fmt[i])
1381 			regmap_update_bits(arizona->regmap,
1382 					   ARIZONA_PDM_SPK1_CTRL_2 + (i * 2),
1383 					   ARIZONA_SPK1_FMT_MASK,
1384 					   arizona->pdata.spk_fmt[i]);
1385 	}
1386 
1387 	pm_runtime_set_active(arizona->dev);
1388 	pm_runtime_enable(arizona->dev);
1389 
1390 	/* Set up for interrupts */
1391 	ret = arizona_irq_init(arizona);
1392 	if (ret != 0)
1393 		goto err_reset;
1394 
1395 	pm_runtime_set_autosuspend_delay(arizona->dev, 100);
1396 	pm_runtime_use_autosuspend(arizona->dev);
1397 
1398 	arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error",
1399 			    arizona_clkgen_err, arizona);
1400 	arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked",
1401 			    arizona_overclocked, arizona);
1402 	arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked",
1403 			    arizona_underclocked, arizona);
1404 
1405 	ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE,
1406 			      subdevs, n_subdevs, NULL, 0, NULL);
1407 
1408 	if (ret) {
1409 		dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret);
1410 		goto err_irq;
1411 	}
1412 
1413 	return 0;
1414 
1415 err_irq:
1416 	arizona_irq_exit(arizona);
1417 err_reset:
1418 	arizona_enable_reset(arizona);
1419 	regulator_disable(arizona->dcvdd);
1420 err_enable:
1421 	regulator_bulk_disable(arizona->num_core_supplies,
1422 			       arizona->core_supplies);
1423 err_dcvdd:
1424 	regulator_put(arizona->dcvdd);
1425 err_early:
1426 	mfd_remove_devices(dev);
1427 	return ret;
1428 }
1429 EXPORT_SYMBOL_GPL(arizona_dev_init);
1430 
1431 int arizona_dev_exit(struct arizona *arizona)
1432 {
1433 	pm_runtime_disable(arizona->dev);
1434 
1435 	regulator_disable(arizona->dcvdd);
1436 	regulator_put(arizona->dcvdd);
1437 
1438 	mfd_remove_devices(arizona->dev);
1439 	arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona);
1440 	arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona);
1441 	arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona);
1442 	arizona_irq_exit(arizona);
1443 	arizona_enable_reset(arizona);
1444 
1445 	regulator_bulk_disable(arizona->num_core_supplies,
1446 			       arizona->core_supplies);
1447 	return 0;
1448 }
1449 EXPORT_SYMBOL_GPL(arizona_dev_exit);
1450