projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma
[deliverable/linux.git] / sound / soc / codecs / arizona.c
1 /*
2 * arizona.c - Wolfson Arizona class device shared support
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/gcd.h>
15 #include <linux/module.h>
16 #include <linux/pm_runtime.h>
17 #include <sound/pcm.h>
18 #include <sound/pcm_params.h>
19 #include <sound/tlv.h>
20
21 #include <linux/mfd/arizona/core.h>
22 #include <linux/mfd/arizona/registers.h>
23
24 #include "arizona.h"
25
26 #define ARIZONA_AIF_BCLK_CTRL 0x00
27 #define ARIZONA_AIF_TX_PIN_CTRL 0x01
28 #define ARIZONA_AIF_RX_PIN_CTRL 0x02
29 #define ARIZONA_AIF_RATE_CTRL 0x03
30 #define ARIZONA_AIF_FORMAT 0x04
31 #define ARIZONA_AIF_TX_BCLK_RATE 0x05
32 #define ARIZONA_AIF_RX_BCLK_RATE 0x06
33 #define ARIZONA_AIF_FRAME_CTRL_1 0x07
34 #define ARIZONA_AIF_FRAME_CTRL_2 0x08
35 #define ARIZONA_AIF_FRAME_CTRL_3 0x09
36 #define ARIZONA_AIF_FRAME_CTRL_4 0x0A
37 #define ARIZONA_AIF_FRAME_CTRL_5 0x0B
38 #define ARIZONA_AIF_FRAME_CTRL_6 0x0C
39 #define ARIZONA_AIF_FRAME_CTRL_7 0x0D
40 #define ARIZONA_AIF_FRAME_CTRL_8 0x0E
41 #define ARIZONA_AIF_FRAME_CTRL_9 0x0F
42 #define ARIZONA_AIF_FRAME_CTRL_10 0x10
43 #define ARIZONA_AIF_FRAME_CTRL_11 0x11
44 #define ARIZONA_AIF_FRAME_CTRL_12 0x12
45 #define ARIZONA_AIF_FRAME_CTRL_13 0x13
46 #define ARIZONA_AIF_FRAME_CTRL_14 0x14
47 #define ARIZONA_AIF_FRAME_CTRL_15 0x15
48 #define ARIZONA_AIF_FRAME_CTRL_16 0x16
49 #define ARIZONA_AIF_FRAME_CTRL_17 0x17
50 #define ARIZONA_AIF_FRAME_CTRL_18 0x18
51 #define ARIZONA_AIF_TX_ENABLES 0x19
52 #define ARIZONA_AIF_RX_ENABLES 0x1A
53 #define ARIZONA_AIF_FORCE_WRITE 0x1B
54
55 #define ARIZONA_FLL_VCO_CORNER 141900000
56 #define ARIZONA_FLL_MAX_FREF 13500000
57 #define ARIZONA_FLL_MIN_FVCO 90000000
58 #define ARIZONA_FLL_MAX_FRATIO 16
59 #define ARIZONA_FLL_MAX_REFDIV 8
60 #define ARIZONA_FLL_MIN_OUTDIV 2
61 #define ARIZONA_FLL_MAX_OUTDIV 7
62
63 #define ARIZONA_FMT_DSP_MODE_A 0
64 #define ARIZONA_FMT_DSP_MODE_B 1
65 #define ARIZONA_FMT_I2S_MODE 2
66 #define ARIZONA_FMT_LEFT_JUSTIFIED_MODE 3
67
68 #define arizona_fll_err(_fll, fmt, ...) \
69 dev_err(_fll->arizona->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
70 #define arizona_fll_warn(_fll, fmt, ...) \
71 dev_warn(_fll->arizona->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
72 #define arizona_fll_dbg(_fll, fmt, ...) \
73 dev_dbg(_fll->arizona->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
74
75 #define arizona_aif_err(_dai, fmt, ...) \
76 dev_err(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
77 #define arizona_aif_warn(_dai, fmt, ...) \
78 dev_warn(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
79 #define arizona_aif_dbg(_dai, fmt, ...) \
80 dev_dbg(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
81
82 static int arizona_spk_ev(struct snd_soc_dapm_widget *w,
83 struct snd_kcontrol *kcontrol,
84 int event)
85 {
86 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
87 struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
88 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
89 bool manual_ena = false;
90 int val;
91
92 switch (arizona->type) {
93 case WM5102:
94 switch (arizona->rev) {
95 case 0:
96 break;
97 default:
98 manual_ena = true;
99 break;
100 }
101 default:
102 break;
103 }
104
105 switch (event) {
106 case SND_SOC_DAPM_PRE_PMU:
107 if (!priv->spk_ena && manual_ena) {
108 regmap_write_async(arizona->regmap, 0x4f5, 0x25a);
109 priv->spk_ena_pending = true;
110 }
111 break;
112 case SND_SOC_DAPM_POST_PMU:
113 val = snd_soc_read(codec, ARIZONA_INTERRUPT_RAW_STATUS_3);
114 if (val & ARIZONA_SPK_OVERHEAT_STS) {
115 dev_crit(arizona->dev,
116 "Speaker not enabled due to temperature\n");
117 return -EBUSY;
118 }
119
120 regmap_update_bits_async(arizona->regmap,
121 ARIZONA_OUTPUT_ENABLES_1,
122 1 << w->shift, 1 << w->shift);
123
124 if (priv->spk_ena_pending) {
125 msleep(75);
126 regmap_write_async(arizona->regmap, 0x4f5, 0xda);
127 priv->spk_ena_pending = false;
128 priv->spk_ena++;
129 }
130 break;
131 case SND_SOC_DAPM_PRE_PMD:
132 if (manual_ena) {
133 priv->spk_ena--;
134 if (!priv->spk_ena)
135 regmap_write_async(arizona->regmap,
136 0x4f5, 0x25a);
137 }
138
139 regmap_update_bits_async(arizona->regmap,
140 ARIZONA_OUTPUT_ENABLES_1,
141 1 << w->shift, 0);
142 break;
143 case SND_SOC_DAPM_POST_PMD:
144 if (manual_ena) {
145 if (!priv->spk_ena)
146 regmap_write_async(arizona->regmap,
147 0x4f5, 0x0da);
148 }
149 break;
150 default:
151 break;
152 }
153
154 return 0;
155 }
156
157 static irqreturn_t arizona_thermal_warn(int irq, void *data)
158 {
159 struct arizona *arizona = data;
160 unsigned int val;
161 int ret;
162
163 ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_3,
164 &val);
165 if (ret != 0) {
166 dev_err(arizona->dev, "Failed to read thermal status: %d\n",
167 ret);
168 } else if (val & ARIZONA_SPK_OVERHEAT_WARN_STS) {
169 dev_crit(arizona->dev, "Thermal warning\n");
170 }
171
172 return IRQ_HANDLED;
173 }
174
175 static irqreturn_t arizona_thermal_shutdown(int irq, void *data)
176 {
177 struct arizona *arizona = data;
178 unsigned int val;
179 int ret;
180
181 ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_3,
182 &val);
183 if (ret != 0) {
184 dev_err(arizona->dev, "Failed to read thermal status: %d\n",
185 ret);
186 } else if (val & ARIZONA_SPK_OVERHEAT_STS) {
187 dev_crit(arizona->dev, "Thermal shutdown\n");
188 ret = regmap_update_bits(arizona->regmap,
189 ARIZONA_OUTPUT_ENABLES_1,
190 ARIZONA_OUT4L_ENA |
191 ARIZONA_OUT4R_ENA, 0);
192 if (ret != 0)
193 dev_crit(arizona->dev,
194 "Failed to disable speaker outputs: %d\n",
195 ret);
196 }
197
198 return IRQ_HANDLED;
199 }
200
201 static const struct snd_soc_dapm_widget arizona_spkl =
202 SND_SOC_DAPM_PGA_E("OUT4L", SND_SOC_NOPM,
203 ARIZONA_OUT4L_ENA_SHIFT, 0, NULL, 0, arizona_spk_ev,
204 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU);
205
206 static const struct snd_soc_dapm_widget arizona_spkr =
207 SND_SOC_DAPM_PGA_E("OUT4R", SND_SOC_NOPM,
208 ARIZONA_OUT4R_ENA_SHIFT, 0, NULL, 0, arizona_spk_ev,
209 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU);
210
211 int arizona_init_spk(struct snd_soc_codec *codec)
212 {
213 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
214 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
215 struct arizona *arizona = priv->arizona;
216 int ret;
217
218 ret = snd_soc_dapm_new_controls(dapm, &arizona_spkl, 1);
219 if (ret != 0)
220 return ret;
221
222 switch (arizona->type) {
223 case WM8997:
224 break;
225 default:
226 ret = snd_soc_dapm_new_controls(dapm, &arizona_spkr, 1);
227 if (ret != 0)
228 return ret;
229 break;
230 }
231
232 ret = arizona_request_irq(arizona, ARIZONA_IRQ_SPK_OVERHEAT_WARN,
233 "Thermal warning", arizona_thermal_warn,
234 arizona);
235 if (ret != 0)
236 dev_err(arizona->dev,
237 "Failed to get thermal warning IRQ: %d\n",
238 ret);
239
240 ret = arizona_request_irq(arizona, ARIZONA_IRQ_SPK_OVERHEAT,
241 "Thermal shutdown", arizona_thermal_shutdown,
242 arizona);
243 if (ret != 0)
244 dev_err(arizona->dev,
245 "Failed to get thermal shutdown IRQ: %d\n",
246 ret);
247
248 return 0;
249 }
250 EXPORT_SYMBOL_GPL(arizona_init_spk);
251
252 static const struct snd_soc_dapm_route arizona_mono_routes[] = {
253 { "OUT1R", NULL, "OUT1L" },
254 { "OUT2R", NULL, "OUT2L" },
255 { "OUT3R", NULL, "OUT3L" },
256 { "OUT4R", NULL, "OUT4L" },
257 { "OUT5R", NULL, "OUT5L" },
258 { "OUT6R", NULL, "OUT6L" },
259 };
260
261 int arizona_init_mono(struct snd_soc_codec *codec)
262 {
263 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
264 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
265 struct arizona *arizona = priv->arizona;
266 int i;
267
268 for (i = 0; i < ARIZONA_MAX_OUTPUT; ++i) {
269 if (arizona->pdata.out_mono[i])
270 snd_soc_dapm_add_routes(dapm,
271 &arizona_mono_routes[i], 1);
272 }
273
274 return 0;
275 }
276 EXPORT_SYMBOL_GPL(arizona_init_mono);
277
278 int arizona_init_gpio(struct snd_soc_codec *codec)
279 {
280 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
281 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
282 struct arizona *arizona = priv->arizona;
283 int i;
284
285 switch (arizona->type) {
286 case WM5110:
287 case WM8280:
288 snd_soc_dapm_disable_pin(dapm, "DRC2 Signal Activity");
289 break;
290 default:
291 break;
292 }
293
294 snd_soc_dapm_disable_pin(dapm, "DRC1 Signal Activity");
295
296 for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) {
297 switch (arizona->pdata.gpio_defaults[i] & ARIZONA_GPN_FN_MASK) {
298 case ARIZONA_GP_FN_DRC1_SIGNAL_DETECT:
299 snd_soc_dapm_enable_pin(dapm, "DRC1 Signal Activity");
300 break;
301 case ARIZONA_GP_FN_DRC2_SIGNAL_DETECT:
302 snd_soc_dapm_enable_pin(dapm, "DRC2 Signal Activity");
303 break;
304 default:
305 break;
306 }
307 }
308
309 return 0;
310 }
311 EXPORT_SYMBOL_GPL(arizona_init_gpio);
312
313 const char * const arizona_mixer_texts[ARIZONA_NUM_MIXER_INPUTS] = {
314 "None",
315 "Tone Generator 1",
316 "Tone Generator 2",
317 "Haptics",
318 "AEC",
319 "AEC2",
320 "Mic Mute Mixer",
321 "Noise Generator",
322 "IN1L",
323 "IN1R",
324 "IN2L",
325 "IN2R",
326 "IN3L",
327 "IN3R",
328 "IN4L",
329 "IN4R",
330 "AIF1RX1",
331 "AIF1RX2",
332 "AIF1RX3",
333 "AIF1RX4",
334 "AIF1RX5",
335 "AIF1RX6",
336 "AIF1RX7",
337 "AIF1RX8",
338 "AIF2RX1",
339 "AIF2RX2",
340 "AIF2RX3",
341 "AIF2RX4",
342 "AIF2RX5",
343 "AIF2RX6",
344 "AIF3RX1",
345 "AIF3RX2",
346 "SLIMRX1",
347 "SLIMRX2",
348 "SLIMRX3",
349 "SLIMRX4",
350 "SLIMRX5",
351 "SLIMRX6",
352 "SLIMRX7",
353 "SLIMRX8",
354 "EQ1",
355 "EQ2",
356 "EQ3",
357 "EQ4",
358 "DRC1L",
359 "DRC1R",
360 "DRC2L",
361 "DRC2R",
362 "LHPF1",
363 "LHPF2",
364 "LHPF3",
365 "LHPF4",
366 "DSP1.1",
367 "DSP1.2",
368 "DSP1.3",
369 "DSP1.4",
370 "DSP1.5",
371 "DSP1.6",
372 "DSP2.1",
373 "DSP2.2",
374 "DSP2.3",
375 "DSP2.4",
376 "DSP2.5",
377 "DSP2.6",
378 "DSP3.1",
379 "DSP3.2",
380 "DSP3.3",
381 "DSP3.4",
382 "DSP3.5",
383 "DSP3.6",
384 "DSP4.1",
385 "DSP4.2",
386 "DSP4.3",
387 "DSP4.4",
388 "DSP4.5",
389 "DSP4.6",
390 "ASRC1L",
391 "ASRC1R",
392 "ASRC2L",
393 "ASRC2R",
394 "ISRC1INT1",
395 "ISRC1INT2",
396 "ISRC1INT3",
397 "ISRC1INT4",
398 "ISRC1DEC1",
399 "ISRC1DEC2",
400 "ISRC1DEC3",
401 "ISRC1DEC4",
402 "ISRC2INT1",
403 "ISRC2INT2",
404 "ISRC2INT3",
405 "ISRC2INT4",
406 "ISRC2DEC1",
407 "ISRC2DEC2",
408 "ISRC2DEC3",
409 "ISRC2DEC4",
410 "ISRC3INT1",
411 "ISRC3INT2",
412 "ISRC3INT3",
413 "ISRC3INT4",
414 "ISRC3DEC1",
415 "ISRC3DEC2",
416 "ISRC3DEC3",
417 "ISRC3DEC4",
418 };
419 EXPORT_SYMBOL_GPL(arizona_mixer_texts);
420
421 unsigned int arizona_mixer_values[ARIZONA_NUM_MIXER_INPUTS] = {
422 0x00, /* None */
423 0x04, /* Tone */
424 0x05,
425 0x06, /* Haptics */
426 0x08, /* AEC */
427 0x09, /* AEC2 */
428 0x0c, /* Noise mixer */
429 0x0d, /* Comfort noise */
430 0x10, /* IN1L */
431 0x11,
432 0x12,
433 0x13,
434 0x14,
435 0x15,
436 0x16,
437 0x17,
438 0x20, /* AIF1RX1 */
439 0x21,
440 0x22,
441 0x23,
442 0x24,
443 0x25,
444 0x26,
445 0x27,
446 0x28, /* AIF2RX1 */
447 0x29,
448 0x2a,
449 0x2b,
450 0x2c,
451 0x2d,
452 0x30, /* AIF3RX1 */
453 0x31,
454 0x38, /* SLIMRX1 */
455 0x39,
456 0x3a,
457 0x3b,
458 0x3c,
459 0x3d,
460 0x3e,
461 0x3f,
462 0x50, /* EQ1 */
463 0x51,
464 0x52,
465 0x53,
466 0x58, /* DRC1L */
467 0x59,
468 0x5a,
469 0x5b,
470 0x60, /* LHPF1 */
471 0x61,
472 0x62,
473 0x63,
474 0x68, /* DSP1.1 */
475 0x69,
476 0x6a,
477 0x6b,
478 0x6c,
479 0x6d,
480 0x70, /* DSP2.1 */
481 0x71,
482 0x72,
483 0x73,
484 0x74,
485 0x75,
486 0x78, /* DSP3.1 */
487 0x79,
488 0x7a,
489 0x7b,
490 0x7c,
491 0x7d,
492 0x80, /* DSP4.1 */
493 0x81,
494 0x82,
495 0x83,
496 0x84,
497 0x85,
498 0x90, /* ASRC1L */
499 0x91,
500 0x92,
501 0x93,
502 0xa0, /* ISRC1INT1 */
503 0xa1,
504 0xa2,
505 0xa3,
506 0xa4, /* ISRC1DEC1 */
507 0xa5,
508 0xa6,
509 0xa7,
510 0xa8, /* ISRC2DEC1 */
511 0xa9,
512 0xaa,
513 0xab,
514 0xac, /* ISRC2INT1 */
515 0xad,
516 0xae,
517 0xaf,
518 0xb0, /* ISRC3DEC1 */
519 0xb1,
520 0xb2,
521 0xb3,
522 0xb4, /* ISRC3INT1 */
523 0xb5,
524 0xb6,
525 0xb7,
526 };
527 EXPORT_SYMBOL_GPL(arizona_mixer_values);
528
529 const DECLARE_TLV_DB_SCALE(arizona_mixer_tlv, -3200, 100, 0);
530 EXPORT_SYMBOL_GPL(arizona_mixer_tlv);
531
532 const char * const arizona_sample_rate_text[ARIZONA_SAMPLE_RATE_ENUM_SIZE] = {
533 "12kHz", "24kHz", "48kHz", "96kHz", "192kHz",
534 "11.025kHz", "22.05kHz", "44.1kHz", "88.2kHz", "176.4kHz",
535 "4kHz", "8kHz", "16kHz", "32kHz",
536 };
537 EXPORT_SYMBOL_GPL(arizona_sample_rate_text);
538
539 const unsigned int arizona_sample_rate_val[ARIZONA_SAMPLE_RATE_ENUM_SIZE] = {
540 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
541 0x10, 0x11, 0x12, 0x13,
542 };
543 EXPORT_SYMBOL_GPL(arizona_sample_rate_val);
544
545 const char *arizona_sample_rate_val_to_name(unsigned int rate_val)
546 {
547 int i;
548
549 for (i = 0; i < ARRAY_SIZE(arizona_sample_rate_val); ++i) {
550 if (arizona_sample_rate_val[i] == rate_val)
551 return arizona_sample_rate_text[i];
552 }
553
554 return "Illegal";
555 }
556 EXPORT_SYMBOL_GPL(arizona_sample_rate_val_to_name);
557
558 const char * const arizona_rate_text[ARIZONA_RATE_ENUM_SIZE] = {
559 "SYNCCLK rate", "8kHz", "16kHz", "ASYNCCLK rate",
560 };
561 EXPORT_SYMBOL_GPL(arizona_rate_text);
562
563 const unsigned int arizona_rate_val[ARIZONA_RATE_ENUM_SIZE] = {
564 0, 1, 2, 8,
565 };
566 EXPORT_SYMBOL_GPL(arizona_rate_val);
567
568
569 const struct soc_enum arizona_isrc_fsh[] = {
570 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_1_CTRL_1,
571 ARIZONA_ISRC1_FSH_SHIFT, 0xf,
572 ARIZONA_RATE_ENUM_SIZE,
573 arizona_rate_text, arizona_rate_val),
574 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_2_CTRL_1,
575 ARIZONA_ISRC2_FSH_SHIFT, 0xf,
576 ARIZONA_RATE_ENUM_SIZE,
577 arizona_rate_text, arizona_rate_val),
578 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_3_CTRL_1,
579 ARIZONA_ISRC3_FSH_SHIFT, 0xf,
580 ARIZONA_RATE_ENUM_SIZE,
581 arizona_rate_text, arizona_rate_val),
582 };
583 EXPORT_SYMBOL_GPL(arizona_isrc_fsh);
584
585 const struct soc_enum arizona_isrc_fsl[] = {
586 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_1_CTRL_2,
587 ARIZONA_ISRC1_FSL_SHIFT, 0xf,
588 ARIZONA_RATE_ENUM_SIZE,
589 arizona_rate_text, arizona_rate_val),
590 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_2_CTRL_2,
591 ARIZONA_ISRC2_FSL_SHIFT, 0xf,
592 ARIZONA_RATE_ENUM_SIZE,
593 arizona_rate_text, arizona_rate_val),
594 SOC_VALUE_ENUM_SINGLE(ARIZONA_ISRC_3_CTRL_2,
595 ARIZONA_ISRC3_FSL_SHIFT, 0xf,
596 ARIZONA_RATE_ENUM_SIZE,
597 arizona_rate_text, arizona_rate_val),
598 };
599 EXPORT_SYMBOL_GPL(arizona_isrc_fsl);
600
601 const struct soc_enum arizona_asrc_rate1 =
602 SOC_VALUE_ENUM_SINGLE(ARIZONA_ASRC_RATE1,
603 ARIZONA_ASRC_RATE1_SHIFT, 0xf,
604 ARIZONA_RATE_ENUM_SIZE - 1,
605 arizona_rate_text, arizona_rate_val);
606 EXPORT_SYMBOL_GPL(arizona_asrc_rate1);
607
608 static const char *arizona_vol_ramp_text[] = {
609 "0ms/6dB", "0.5ms/6dB", "1ms/6dB", "2ms/6dB", "4ms/6dB", "8ms/6dB",
610 "15ms/6dB", "30ms/6dB",
611 };
612
613 SOC_ENUM_SINGLE_DECL(arizona_in_vd_ramp,
614 ARIZONA_INPUT_VOLUME_RAMP,
615 ARIZONA_IN_VD_RAMP_SHIFT,
616 arizona_vol_ramp_text);
617 EXPORT_SYMBOL_GPL(arizona_in_vd_ramp);
618
619 SOC_ENUM_SINGLE_DECL(arizona_in_vi_ramp,
620 ARIZONA_INPUT_VOLUME_RAMP,
621 ARIZONA_IN_VI_RAMP_SHIFT,
622 arizona_vol_ramp_text);
623 EXPORT_SYMBOL_GPL(arizona_in_vi_ramp);
624
625 SOC_ENUM_SINGLE_DECL(arizona_out_vd_ramp,
626 ARIZONA_OUTPUT_VOLUME_RAMP,
627 ARIZONA_OUT_VD_RAMP_SHIFT,
628 arizona_vol_ramp_text);
629 EXPORT_SYMBOL_GPL(arizona_out_vd_ramp);
630
631 SOC_ENUM_SINGLE_DECL(arizona_out_vi_ramp,
632 ARIZONA_OUTPUT_VOLUME_RAMP,
633 ARIZONA_OUT_VI_RAMP_SHIFT,
634 arizona_vol_ramp_text);
635 EXPORT_SYMBOL_GPL(arizona_out_vi_ramp);
636
637 static const char *arizona_lhpf_mode_text[] = {
638 "Low-pass", "High-pass"
639 };
640
641 SOC_ENUM_SINGLE_DECL(arizona_lhpf1_mode,
642 ARIZONA_HPLPF1_1,
643 ARIZONA_LHPF1_MODE_SHIFT,
644 arizona_lhpf_mode_text);
645 EXPORT_SYMBOL_GPL(arizona_lhpf1_mode);
646
647 SOC_ENUM_SINGLE_DECL(arizona_lhpf2_mode,
648 ARIZONA_HPLPF2_1,
649 ARIZONA_LHPF2_MODE_SHIFT,
650 arizona_lhpf_mode_text);
651 EXPORT_SYMBOL_GPL(arizona_lhpf2_mode);
652
653 SOC_ENUM_SINGLE_DECL(arizona_lhpf3_mode,
654 ARIZONA_HPLPF3_1,
655 ARIZONA_LHPF3_MODE_SHIFT,
656 arizona_lhpf_mode_text);
657 EXPORT_SYMBOL_GPL(arizona_lhpf3_mode);
658
659 SOC_ENUM_SINGLE_DECL(arizona_lhpf4_mode,
660 ARIZONA_HPLPF4_1,
661 ARIZONA_LHPF4_MODE_SHIFT,
662 arizona_lhpf_mode_text);
663 EXPORT_SYMBOL_GPL(arizona_lhpf4_mode);
664
665 static const char *arizona_ng_hold_text[] = {
666 "30ms", "120ms", "250ms", "500ms",
667 };
668
669 SOC_ENUM_SINGLE_DECL(arizona_ng_hold,
670 ARIZONA_NOISE_GATE_CONTROL,
671 ARIZONA_NGATE_HOLD_SHIFT,
672 arizona_ng_hold_text);
673 EXPORT_SYMBOL_GPL(arizona_ng_hold);
674
675 static const char * const arizona_in_hpf_cut_text[] = {
676 "2.5Hz", "5Hz", "10Hz", "20Hz", "40Hz"
677 };
678
679 SOC_ENUM_SINGLE_DECL(arizona_in_hpf_cut_enum,
680 ARIZONA_HPF_CONTROL,
681 ARIZONA_IN_HPF_CUT_SHIFT,
682 arizona_in_hpf_cut_text);
683 EXPORT_SYMBOL_GPL(arizona_in_hpf_cut_enum);
684
685 static const char * const arizona_in_dmic_osr_text[] = {
686 "1.536MHz", "3.072MHz", "6.144MHz", "768kHz",
687 };
688
689 const struct soc_enum arizona_in_dmic_osr[] = {
690 SOC_ENUM_SINGLE(ARIZONA_IN1L_CONTROL, ARIZONA_IN1_OSR_SHIFT,
691 ARRAY_SIZE(arizona_in_dmic_osr_text),
692 arizona_in_dmic_osr_text),
693 SOC_ENUM_SINGLE(ARIZONA_IN2L_CONTROL, ARIZONA_IN2_OSR_SHIFT,
694 ARRAY_SIZE(arizona_in_dmic_osr_text),
695 arizona_in_dmic_osr_text),
696 SOC_ENUM_SINGLE(ARIZONA_IN3L_CONTROL, ARIZONA_IN3_OSR_SHIFT,
697 ARRAY_SIZE(arizona_in_dmic_osr_text),
698 arizona_in_dmic_osr_text),
699 SOC_ENUM_SINGLE(ARIZONA_IN4L_CONTROL, ARIZONA_IN4_OSR_SHIFT,
700 ARRAY_SIZE(arizona_in_dmic_osr_text),
701 arizona_in_dmic_osr_text),
702 };
703 EXPORT_SYMBOL_GPL(arizona_in_dmic_osr);
704
705 static const char * const arizona_anc_input_src_text[] = {
706 "None", "IN1", "IN2", "IN3", "IN4",
707 };
708
709 static const char * const arizona_anc_channel_src_text[] = {
710 "None", "Left", "Right", "Combine",
711 };
712
713 const struct soc_enum arizona_anc_input_src[] = {
714 SOC_ENUM_SINGLE(ARIZONA_ANC_SRC,
715 ARIZONA_IN_RXANCL_SEL_SHIFT,
716 ARRAY_SIZE(arizona_anc_input_src_text),
717 arizona_anc_input_src_text),
718 SOC_ENUM_SINGLE(ARIZONA_FCL_ADC_REFORMATTER_CONTROL,
719 ARIZONA_FCL_MIC_MODE_SEL,
720 ARRAY_SIZE(arizona_anc_channel_src_text),
721 arizona_anc_channel_src_text),
722 SOC_ENUM_SINGLE(ARIZONA_ANC_SRC,
723 ARIZONA_IN_RXANCR_SEL_SHIFT,
724 ARRAY_SIZE(arizona_anc_input_src_text),
725 arizona_anc_input_src_text),
726 SOC_ENUM_SINGLE(ARIZONA_FCR_ADC_REFORMATTER_CONTROL,
727 ARIZONA_FCR_MIC_MODE_SEL,
728 ARRAY_SIZE(arizona_anc_channel_src_text),
729 arizona_anc_channel_src_text),
730 };
731 EXPORT_SYMBOL_GPL(arizona_anc_input_src);
732
733 static const char * const arizona_anc_ng_texts[] = {
734 "None",
735 "Internal",
736 "External",
737 };
738
739 SOC_ENUM_SINGLE_DECL(arizona_anc_ng_enum, SND_SOC_NOPM, 0,
740 arizona_anc_ng_texts);
741 EXPORT_SYMBOL_GPL(arizona_anc_ng_enum);
742
743 static const char * const arizona_output_anc_src_text[] = {
744 "None", "RXANCL", "RXANCR",
745 };
746
747 const struct soc_enum arizona_output_anc_src[] = {
748 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_1L,
749 ARIZONA_OUT1L_ANC_SRC_SHIFT,
750 ARRAY_SIZE(arizona_output_anc_src_text),
751 arizona_output_anc_src_text),
752 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_1R,
753 ARIZONA_OUT1R_ANC_SRC_SHIFT,
754 ARRAY_SIZE(arizona_output_anc_src_text),
755 arizona_output_anc_src_text),
756 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_2L,
757 ARIZONA_OUT2L_ANC_SRC_SHIFT,
758 ARRAY_SIZE(arizona_output_anc_src_text),
759 arizona_output_anc_src_text),
760 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_2R,
761 ARIZONA_OUT2R_ANC_SRC_SHIFT,
762 ARRAY_SIZE(arizona_output_anc_src_text),
763 arizona_output_anc_src_text),
764 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_3L,
765 ARIZONA_OUT3L_ANC_SRC_SHIFT,
766 ARRAY_SIZE(arizona_output_anc_src_text),
767 arizona_output_anc_src_text),
768 SOC_ENUM_SINGLE(ARIZONA_DAC_VOLUME_LIMIT_3R,
769 ARIZONA_OUT3R_ANC_SRC_SHIFT,
770 ARRAY_SIZE(arizona_output_anc_src_text),
771 arizona_output_anc_src_text),
772 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_4L,
773 ARIZONA_OUT4L_ANC_SRC_SHIFT,
774 ARRAY_SIZE(arizona_output_anc_src_text),
775 arizona_output_anc_src_text),
776 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_4R,
777 ARIZONA_OUT4R_ANC_SRC_SHIFT,
778 ARRAY_SIZE(arizona_output_anc_src_text),
779 arizona_output_anc_src_text),
780 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_5L,
781 ARIZONA_OUT5L_ANC_SRC_SHIFT,
782 ARRAY_SIZE(arizona_output_anc_src_text),
783 arizona_output_anc_src_text),
784 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_5R,
785 ARIZONA_OUT5R_ANC_SRC_SHIFT,
786 ARRAY_SIZE(arizona_output_anc_src_text),
787 arizona_output_anc_src_text),
788 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_6L,
789 ARIZONA_OUT6L_ANC_SRC_SHIFT,
790 ARRAY_SIZE(arizona_output_anc_src_text),
791 arizona_output_anc_src_text),
792 SOC_ENUM_SINGLE(ARIZONA_OUTPUT_PATH_CONFIG_6R,
793 ARIZONA_OUT6R_ANC_SRC_SHIFT,
794 ARRAY_SIZE(arizona_output_anc_src_text),
795 arizona_output_anc_src_text),
796 };
797 EXPORT_SYMBOL_GPL(arizona_output_anc_src);
798
799 static void arizona_in_set_vu(struct snd_soc_codec *codec, int ena)
800 {
801 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
802 unsigned int val;
803 int i;
804
805 if (ena)
806 val = ARIZONA_IN_VU;
807 else
808 val = 0;
809
810 for (i = 0; i < priv->num_inputs; i++)
811 snd_soc_update_bits(codec,
812 ARIZONA_ADC_DIGITAL_VOLUME_1L + (i * 4),
813 ARIZONA_IN_VU, val);
814 }
815
816 bool arizona_input_analog(struct snd_soc_codec *codec, int shift)
817 {
818 unsigned int reg = ARIZONA_IN1L_CONTROL + ((shift / 2) * 8);
819 unsigned int val = snd_soc_read(codec, reg);
820
821 return !(val & ARIZONA_IN1_MODE_MASK);
822 }
823 EXPORT_SYMBOL_GPL(arizona_input_analog);
824
825 int arizona_in_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
826 int event)
827 {
828 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
829 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
830 unsigned int reg;
831
832 if (w->shift % 2)
833 reg = ARIZONA_ADC_DIGITAL_VOLUME_1L + ((w->shift / 2) * 8);
834 else
835 reg = ARIZONA_ADC_DIGITAL_VOLUME_1R + ((w->shift / 2) * 8);
836
837 switch (event) {
838 case SND_SOC_DAPM_PRE_PMU:
839 priv->in_pending++;
840 break;
841 case SND_SOC_DAPM_POST_PMU:
842 snd_soc_update_bits(codec, reg, ARIZONA_IN1L_MUTE, 0);
843
844 /* If this is the last input pending then allow VU */
845 priv->in_pending--;
846 if (priv->in_pending == 0) {
847 msleep(1);
848 arizona_in_set_vu(codec, 1);
849 }
850 break;
851 case SND_SOC_DAPM_PRE_PMD:
852 snd_soc_update_bits(codec, reg,
853 ARIZONA_IN1L_MUTE | ARIZONA_IN_VU,
854 ARIZONA_IN1L_MUTE | ARIZONA_IN_VU);
855 break;
856 case SND_SOC_DAPM_POST_PMD:
857 /* Disable volume updates if no inputs are enabled */
858 reg = snd_soc_read(codec, ARIZONA_INPUT_ENABLES);
859 if (reg == 0)
860 arizona_in_set_vu(codec, 0);
861 break;
862 default:
863 break;
864 }
865
866 return 0;
867 }
868 EXPORT_SYMBOL_GPL(arizona_in_ev);
869
870 int arizona_out_ev(struct snd_soc_dapm_widget *w,
871 struct snd_kcontrol *kcontrol,
872 int event)
873 {
874 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
875 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
876
877 switch (event) {
878 case SND_SOC_DAPM_PRE_PMU:
879 switch (w->shift) {
880 case ARIZONA_OUT1L_ENA_SHIFT:
881 case ARIZONA_OUT1R_ENA_SHIFT:
882 case ARIZONA_OUT2L_ENA_SHIFT:
883 case ARIZONA_OUT2R_ENA_SHIFT:
884 case ARIZONA_OUT3L_ENA_SHIFT:
885 case ARIZONA_OUT3R_ENA_SHIFT:
886 priv->out_up_pending++;
887 priv->out_up_delay += 17;
888 break;
889 default:
890 break;
891 }
892 break;
893 case SND_SOC_DAPM_POST_PMU:
894 switch (w->shift) {
895 case ARIZONA_OUT1L_ENA_SHIFT:
896 case ARIZONA_OUT1R_ENA_SHIFT:
897 case ARIZONA_OUT2L_ENA_SHIFT:
898 case ARIZONA_OUT2R_ENA_SHIFT:
899 case ARIZONA_OUT3L_ENA_SHIFT:
900 case ARIZONA_OUT3R_ENA_SHIFT:
901 priv->out_up_pending--;
902 if (!priv->out_up_pending) {
903 msleep(priv->out_up_delay);
904 priv->out_up_delay = 0;
905 }
906 break;
907
908 default:
909 break;
910 }
911 break;
912 case SND_SOC_DAPM_PRE_PMD:
913 switch (w->shift) {
914 case ARIZONA_OUT1L_ENA_SHIFT:
915 case ARIZONA_OUT1R_ENA_SHIFT:
916 case ARIZONA_OUT2L_ENA_SHIFT:
917 case ARIZONA_OUT2R_ENA_SHIFT:
918 case ARIZONA_OUT3L_ENA_SHIFT:
919 case ARIZONA_OUT3R_ENA_SHIFT:
920 priv->out_down_pending++;
921 priv->out_down_delay++;
922 break;
923 default:
924 break;
925 }
926 break;
927 case SND_SOC_DAPM_POST_PMD:
928 switch (w->shift) {
929 case ARIZONA_OUT1L_ENA_SHIFT:
930 case ARIZONA_OUT1R_ENA_SHIFT:
931 case ARIZONA_OUT2L_ENA_SHIFT:
932 case ARIZONA_OUT2R_ENA_SHIFT:
933 case ARIZONA_OUT3L_ENA_SHIFT:
934 case ARIZONA_OUT3R_ENA_SHIFT:
935 priv->out_down_pending--;
936 if (!priv->out_down_pending) {
937 msleep(priv->out_down_delay);
938 priv->out_down_delay = 0;
939 }
940 break;
941 default:
942 break;
943 }
944 break;
945 default:
946 break;
947 }
948
949 return 0;
950 }
951 EXPORT_SYMBOL_GPL(arizona_out_ev);
952
953 int arizona_hp_ev(struct snd_soc_dapm_widget *w,
954 struct snd_kcontrol *kcontrol,
955 int event)
956 {
957 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
958 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
959 struct arizona *arizona = priv->arizona;
960 unsigned int mask = 1 << w->shift;
961 unsigned int val;
962
963 switch (event) {
964 case SND_SOC_DAPM_POST_PMU:
965 val = mask;
966 break;
967 case SND_SOC_DAPM_PRE_PMD:
968 val = 0;
969 break;
970 case SND_SOC_DAPM_PRE_PMU:
971 case SND_SOC_DAPM_POST_PMD:
972 return arizona_out_ev(w, kcontrol, event);
973 default:
974 return -EINVAL;
975 }
976
977 /* Store the desired state for the HP outputs */
978 priv->arizona->hp_ena &= ~mask;
979 priv->arizona->hp_ena |= val;
980
981 /* Force off if HPDET clamp is active */
982 if (priv->arizona->hpdet_clamp)
983 val = 0;
984
985 regmap_update_bits_async(arizona->regmap, ARIZONA_OUTPUT_ENABLES_1,
986 mask, val);
987
988 return arizona_out_ev(w, kcontrol, event);
989 }
990 EXPORT_SYMBOL_GPL(arizona_hp_ev);
991
992 static int arizona_dvfs_enable(struct snd_soc_codec *codec)
993 {
994 const struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
995 struct arizona *arizona = priv->arizona;
996 int ret;
997
998 ret = regulator_set_voltage(arizona->dcvdd, 1800000, 1800000);
999 if (ret) {
1000 dev_err(codec->dev, "Failed to boost DCVDD: %d\n", ret);
1001 return ret;
1002 }
1003
1004 ret = regmap_update_bits(arizona->regmap,
1005 ARIZONA_DYNAMIC_FREQUENCY_SCALING_1,
1006 ARIZONA_SUBSYS_MAX_FREQ,
1007 ARIZONA_SUBSYS_MAX_FREQ);
1008 if (ret) {
1009 dev_err(codec->dev, "Failed to enable subsys max: %d\n", ret);
1010 regulator_set_voltage(arizona->dcvdd, 1200000, 1800000);
1011 return ret;
1012 }
1013
1014 return 0;
1015 }
1016
1017 static int arizona_dvfs_disable(struct snd_soc_codec *codec)
1018 {
1019 const struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1020 struct arizona *arizona = priv->arizona;
1021 int ret;
1022
1023 ret = regmap_update_bits(arizona->regmap,
1024 ARIZONA_DYNAMIC_FREQUENCY_SCALING_1,
1025 ARIZONA_SUBSYS_MAX_FREQ, 0);
1026 if (ret) {
1027 dev_err(codec->dev, "Failed to disable subsys max: %d\n", ret);
1028 return ret;
1029 }
1030
1031 ret = regulator_set_voltage(arizona->dcvdd, 1200000, 1800000);
1032 if (ret) {
1033 dev_err(codec->dev, "Failed to unboost DCVDD: %d\n", ret);
1034 return ret;
1035 }
1036
1037 return 0;
1038 }
1039
1040 int arizona_dvfs_up(struct snd_soc_codec *codec, unsigned int flags)
1041 {
1042 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1043 int ret = 0;
1044
1045 mutex_lock(&priv->dvfs_lock);
1046
1047 if (!priv->dvfs_cached && !priv->dvfs_reqs) {
1048 ret = arizona_dvfs_enable(codec);
1049 if (ret)
1050 goto err;
1051 }
1052
1053 priv->dvfs_reqs |= flags;
1054 err:
1055 mutex_unlock(&priv->dvfs_lock);
1056 return ret;
1057 }
1058 EXPORT_SYMBOL_GPL(arizona_dvfs_up);
1059
1060 int arizona_dvfs_down(struct snd_soc_codec *codec, unsigned int flags)
1061 {
1062 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1063 unsigned int old_reqs;
1064 int ret = 0;
1065
1066 mutex_lock(&priv->dvfs_lock);
1067
1068 old_reqs = priv->dvfs_reqs;
1069 priv->dvfs_reqs &= ~flags;
1070
1071 if (!priv->dvfs_cached && old_reqs && !priv->dvfs_reqs)
1072 ret = arizona_dvfs_disable(codec);
1073
1074 mutex_unlock(&priv->dvfs_lock);
1075 return ret;
1076 }
1077 EXPORT_SYMBOL_GPL(arizona_dvfs_down);
1078
1079 int arizona_dvfs_sysclk_ev(struct snd_soc_dapm_widget *w,
1080 struct snd_kcontrol *kcontrol, int event)
1081 {
1082 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1083 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1084 int ret = 0;
1085
1086 mutex_lock(&priv->dvfs_lock);
1087
1088 switch (event) {
1089 case SND_SOC_DAPM_POST_PMU:
1090 if (priv->dvfs_reqs)
1091 ret = arizona_dvfs_enable(codec);
1092
1093 priv->dvfs_cached = false;
1094 break;
1095 case SND_SOC_DAPM_PRE_PMD:
1096 /* We must ensure DVFS is disabled before the codec goes into
1097 * suspend so that we are never in an illegal state of DVFS
1098 * enabled without enough DCVDD
1099 */
1100 priv->dvfs_cached = true;
1101
1102 if (priv->dvfs_reqs)
1103 ret = arizona_dvfs_disable(codec);
1104 break;
1105 default:
1106 break;
1107 }
1108
1109 mutex_unlock(&priv->dvfs_lock);
1110 return ret;
1111 }
1112 EXPORT_SYMBOL_GPL(arizona_dvfs_sysclk_ev);
1113
1114 void arizona_init_dvfs(struct arizona_priv *priv)
1115 {
1116 mutex_init(&priv->dvfs_lock);
1117 }
1118 EXPORT_SYMBOL_GPL(arizona_init_dvfs);
1119
1120 int arizona_anc_ev(struct snd_soc_dapm_widget *w,
1121 struct snd_kcontrol *kcontrol,
1122 int event)
1123 {
1124 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1125 unsigned int mask = 0x3 << w->shift;
1126 unsigned int val;
1127
1128 switch (event) {
1129 case SND_SOC_DAPM_POST_PMU:
1130 val = 1 << w->shift;
1131 break;
1132 case SND_SOC_DAPM_PRE_PMD:
1133 val = 1 << (w->shift + 1);
1134 break;
1135 default:
1136 return 0;
1137 }
1138
1139 snd_soc_update_bits(codec, ARIZONA_CLOCK_CONTROL, mask, val);
1140
1141 return 0;
1142 }
1143 EXPORT_SYMBOL_GPL(arizona_anc_ev);
1144
1145 static unsigned int arizona_opclk_ref_48k_rates[] = {
1146 6144000,
1147 12288000,
1148 24576000,
1149 49152000,
1150 };
1151
1152 static unsigned int arizona_opclk_ref_44k1_rates[] = {
1153 5644800,
1154 11289600,
1155 22579200,
1156 45158400,
1157 };
1158
1159 static int arizona_set_opclk(struct snd_soc_codec *codec, unsigned int clk,
1160 unsigned int freq)
1161 {
1162 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1163 unsigned int reg;
1164 unsigned int *rates;
1165 int ref, div, refclk;
1166
1167 switch (clk) {
1168 case ARIZONA_CLK_OPCLK:
1169 reg = ARIZONA_OUTPUT_SYSTEM_CLOCK;
1170 refclk = priv->sysclk;
1171 break;
1172 case ARIZONA_CLK_ASYNC_OPCLK:
1173 reg = ARIZONA_OUTPUT_ASYNC_CLOCK;
1174 refclk = priv->asyncclk;
1175 break;
1176 default:
1177 return -EINVAL;
1178 }
1179
1180 if (refclk % 8000)
1181 rates = arizona_opclk_ref_44k1_rates;
1182 else
1183 rates = arizona_opclk_ref_48k_rates;
1184
1185 for (ref = 0; ref < ARRAY_SIZE(arizona_opclk_ref_48k_rates) &&
1186 rates[ref] <= refclk; ref++) {
1187 div = 1;
1188 while (rates[ref] / div >= freq && div < 32) {
1189 if (rates[ref] / div == freq) {
1190 dev_dbg(codec->dev, "Configured %dHz OPCLK\n",
1191 freq);
1192 snd_soc_update_bits(codec, reg,
1193 ARIZONA_OPCLK_DIV_MASK |
1194 ARIZONA_OPCLK_SEL_MASK,
1195 (div <<
1196 ARIZONA_OPCLK_DIV_SHIFT) |
1197 ref);
1198 return 0;
1199 }
1200 div++;
1201 }
1202 }
1203
1204 dev_err(codec->dev, "Unable to generate %dHz OPCLK\n", freq);
1205 return -EINVAL;
1206 }
1207
1208 int arizona_set_sysclk(struct snd_soc_codec *codec, int clk_id,
1209 int source, unsigned int freq, int dir)
1210 {
1211 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1212 struct arizona *arizona = priv->arizona;
1213 char *name;
1214 unsigned int reg;
1215 unsigned int mask = ARIZONA_SYSCLK_FREQ_MASK | ARIZONA_SYSCLK_SRC_MASK;
1216 unsigned int val = source << ARIZONA_SYSCLK_SRC_SHIFT;
1217 int *clk;
1218
1219 switch (clk_id) {
1220 case ARIZONA_CLK_SYSCLK:
1221 name = "SYSCLK";
1222 reg = ARIZONA_SYSTEM_CLOCK_1;
1223 clk = &priv->sysclk;
1224 mask |= ARIZONA_SYSCLK_FRAC;
1225 break;
1226 case ARIZONA_CLK_ASYNCCLK:
1227 name = "ASYNCCLK";
1228 reg = ARIZONA_ASYNC_CLOCK_1;
1229 clk = &priv->asyncclk;
1230 break;
1231 case ARIZONA_CLK_OPCLK:
1232 case ARIZONA_CLK_ASYNC_OPCLK:
1233 return arizona_set_opclk(codec, clk_id, freq);
1234 default:
1235 return -EINVAL;
1236 }
1237
1238 switch (freq) {
1239 case 5644800:
1240 case 6144000:
1241 break;
1242 case 11289600:
1243 case 12288000:
1244 val |= ARIZONA_CLK_12MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1245 break;
1246 case 22579200:
1247 case 24576000:
1248 val |= ARIZONA_CLK_24MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1249 break;
1250 case 45158400:
1251 case 49152000:
1252 val |= ARIZONA_CLK_49MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1253 break;
1254 case 67737600:
1255 case 73728000:
1256 val |= ARIZONA_CLK_73MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1257 break;
1258 case 90316800:
1259 case 98304000:
1260 val |= ARIZONA_CLK_98MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1261 break;
1262 case 135475200:
1263 case 147456000:
1264 val |= ARIZONA_CLK_147MHZ << ARIZONA_SYSCLK_FREQ_SHIFT;
1265 break;
1266 case 0:
1267 dev_dbg(arizona->dev, "%s cleared\n", name);
1268 *clk = freq;
1269 return 0;
1270 default:
1271 return -EINVAL;
1272 }
1273
1274 *clk = freq;
1275
1276 if (freq % 6144000)
1277 val |= ARIZONA_SYSCLK_FRAC;
1278
1279 dev_dbg(arizona->dev, "%s set to %uHz", name, freq);
1280
1281 return regmap_update_bits(arizona->regmap, reg, mask, val);
1282 }
1283 EXPORT_SYMBOL_GPL(arizona_set_sysclk);
1284
1285 static int arizona_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1286 {
1287 struct snd_soc_codec *codec = dai->codec;
1288 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1289 struct arizona *arizona = priv->arizona;
1290 int lrclk, bclk, mode, base;
1291
1292 base = dai->driver->base;
1293
1294 lrclk = 0;
1295 bclk = 0;
1296
1297 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1298 case SND_SOC_DAIFMT_DSP_A:
1299 mode = ARIZONA_FMT_DSP_MODE_A;
1300 break;
1301 case SND_SOC_DAIFMT_DSP_B:
1302 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK)
1303 != SND_SOC_DAIFMT_CBM_CFM) {
1304 arizona_aif_err(dai, "DSP_B not valid in slave mode\n");
1305 return -EINVAL;
1306 }
1307 mode = ARIZONA_FMT_DSP_MODE_B;
1308 break;
1309 case SND_SOC_DAIFMT_I2S:
1310 mode = ARIZONA_FMT_I2S_MODE;
1311 break;
1312 case SND_SOC_DAIFMT_LEFT_J:
1313 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK)
1314 != SND_SOC_DAIFMT_CBM_CFM) {
1315 arizona_aif_err(dai, "LEFT_J not valid in slave mode\n");
1316 return -EINVAL;
1317 }
1318 mode = ARIZONA_FMT_LEFT_JUSTIFIED_MODE;
1319 break;
1320 default:
1321 arizona_aif_err(dai, "Unsupported DAI format %d\n",
1322 fmt & SND_SOC_DAIFMT_FORMAT_MASK);
1323 return -EINVAL;
1324 }
1325
1326 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1327 case SND_SOC_DAIFMT_CBS_CFS:
1328 break;
1329 case SND_SOC_DAIFMT_CBS_CFM:
1330 lrclk |= ARIZONA_AIF1TX_LRCLK_MSTR;
1331 break;
1332 case SND_SOC_DAIFMT_CBM_CFS:
1333 bclk |= ARIZONA_AIF1_BCLK_MSTR;
1334 break;
1335 case SND_SOC_DAIFMT_CBM_CFM:
1336 bclk |= ARIZONA_AIF1_BCLK_MSTR;
1337 lrclk |= ARIZONA_AIF1TX_LRCLK_MSTR;
1338 break;
1339 default:
1340 arizona_aif_err(dai, "Unsupported master mode %d\n",
1341 fmt & SND_SOC_DAIFMT_MASTER_MASK);
1342 return -EINVAL;
1343 }
1344
1345 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1346 case SND_SOC_DAIFMT_NB_NF:
1347 break;
1348 case SND_SOC_DAIFMT_IB_IF:
1349 bclk |= ARIZONA_AIF1_BCLK_INV;
1350 lrclk |= ARIZONA_AIF1TX_LRCLK_INV;
1351 break;
1352 case SND_SOC_DAIFMT_IB_NF:
1353 bclk |= ARIZONA_AIF1_BCLK_INV;
1354 break;
1355 case SND_SOC_DAIFMT_NB_IF:
1356 lrclk |= ARIZONA_AIF1TX_LRCLK_INV;
1357 break;
1358 default:
1359 return -EINVAL;
1360 }
1361
1362 regmap_update_bits_async(arizona->regmap, base + ARIZONA_AIF_BCLK_CTRL,
1363 ARIZONA_AIF1_BCLK_INV |
1364 ARIZONA_AIF1_BCLK_MSTR,
1365 bclk);
1366 regmap_update_bits_async(arizona->regmap, base + ARIZONA_AIF_TX_PIN_CTRL,
1367 ARIZONA_AIF1TX_LRCLK_INV |
1368 ARIZONA_AIF1TX_LRCLK_MSTR, lrclk);
1369 regmap_update_bits_async(arizona->regmap,
1370 base + ARIZONA_AIF_RX_PIN_CTRL,
1371 ARIZONA_AIF1RX_LRCLK_INV |
1372 ARIZONA_AIF1RX_LRCLK_MSTR, lrclk);
1373 regmap_update_bits(arizona->regmap, base + ARIZONA_AIF_FORMAT,
1374 ARIZONA_AIF1_FMT_MASK, mode);
1375
1376 return 0;
1377 }
1378
1379 static const int arizona_48k_bclk_rates[] = {
1380 -1,
1381 48000,
1382 64000,
1383 96000,
1384 128000,
1385 192000,
1386 256000,
1387 384000,
1388 512000,
1389 768000,
1390 1024000,
1391 1536000,
1392 2048000,
1393 3072000,
1394 4096000,
1395 6144000,
1396 8192000,
1397 12288000,
1398 24576000,
1399 };
1400
1401 static const unsigned int arizona_48k_rates[] = {
1402 12000,
1403 24000,
1404 48000,
1405 96000,
1406 192000,
1407 384000,
1408 768000,
1409 4000,
1410 8000,
1411 16000,
1412 32000,
1413 64000,
1414 128000,
1415 256000,
1416 512000,
1417 };
1418
1419 static const struct snd_pcm_hw_constraint_list arizona_48k_constraint = {
1420 .count = ARRAY_SIZE(arizona_48k_rates),
1421 .list = arizona_48k_rates,
1422 };
1423
1424 static const int arizona_44k1_bclk_rates[] = {
1425 -1,
1426 44100,
1427 58800,
1428 88200,
1429 117600,
1430 177640,
1431 235200,
1432 352800,
1433 470400,
1434 705600,
1435 940800,
1436 1411200,
1437 1881600,
1438 2822400,
1439 3763200,
1440 5644800,
1441 7526400,
1442 11289600,
1443 22579200,
1444 };
1445
1446 static const unsigned int arizona_44k1_rates[] = {
1447 11025,
1448 22050,
1449 44100,
1450 88200,
1451 176400,
1452 352800,
1453 705600,
1454 };
1455
1456 static const struct snd_pcm_hw_constraint_list arizona_44k1_constraint = {
1457 .count = ARRAY_SIZE(arizona_44k1_rates),
1458 .list = arizona_44k1_rates,
1459 };
1460
1461 static int arizona_sr_vals[] = {
1462 0,
1463 12000,
1464 24000,
1465 48000,
1466 96000,
1467 192000,
1468 384000,
1469 768000,
1470 0,
1471 11025,
1472 22050,
1473 44100,
1474 88200,
1475 176400,
1476 352800,
1477 705600,
1478 4000,
1479 8000,
1480 16000,
1481 32000,
1482 64000,
1483 128000,
1484 256000,
1485 512000,
1486 };
1487
1488 static int arizona_startup(struct snd_pcm_substream *substream,
1489 struct snd_soc_dai *dai)
1490 {
1491 struct snd_soc_codec *codec = dai->codec;
1492 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1493 struct arizona_dai_priv *dai_priv = &priv->dai[dai->id - 1];
1494 const struct snd_pcm_hw_constraint_list *constraint;
1495 unsigned int base_rate;
1496
1497 if (!substream->runtime)
1498 return 0;
1499
1500 switch (dai_priv->clk) {
1501 case ARIZONA_CLK_SYSCLK:
1502 base_rate = priv->sysclk;
1503 break;
1504 case ARIZONA_CLK_ASYNCCLK:
1505 base_rate = priv->asyncclk;
1506 break;
1507 default:
1508 return 0;
1509 }
1510
1511 if (base_rate == 0)
1512 return 0;
1513
1514 if (base_rate % 8000)
1515 constraint = &arizona_44k1_constraint;
1516 else
1517 constraint = &arizona_48k_constraint;
1518
1519 return snd_pcm_hw_constraint_list(substream->runtime, 0,
1520 SNDRV_PCM_HW_PARAM_RATE,
1521 constraint);
1522 }
1523
1524 static void arizona_wm5102_set_dac_comp(struct snd_soc_codec *codec,
1525 unsigned int rate)
1526 {
1527 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1528 struct arizona *arizona = priv->arizona;
1529 struct reg_sequence dac_comp[] = {
1530 { 0x80, 0x3 },
1531 { ARIZONA_DAC_COMP_1, 0 },
1532 { ARIZONA_DAC_COMP_2, 0 },
1533 { 0x80, 0x0 },
1534 };
1535
1536 mutex_lock(&arizona->dac_comp_lock);
1537
1538 dac_comp[1].def = arizona->dac_comp_coeff;
1539 if (rate >= 176400)
1540 dac_comp[2].def = arizona->dac_comp_enabled;
1541
1542 mutex_unlock(&arizona->dac_comp_lock);
1543
1544 regmap_multi_reg_write(arizona->regmap,
1545 dac_comp,
1546 ARRAY_SIZE(dac_comp));
1547 }
1548
1549 static int arizona_hw_params_rate(struct snd_pcm_substream *substream,
1550 struct snd_pcm_hw_params *params,
1551 struct snd_soc_dai *dai)
1552 {
1553 struct snd_soc_codec *codec = dai->codec;
1554 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1555 struct arizona_dai_priv *dai_priv = &priv->dai[dai->id - 1];
1556 int base = dai->driver->base;
1557 int i, sr_val, ret;
1558
1559 /*
1560 * We will need to be more flexible than this in future,
1561 * currently we use a single sample rate for SYSCLK.
1562 */
1563 for (i = 0; i < ARRAY_SIZE(arizona_sr_vals); i++)
1564 if (arizona_sr_vals[i] == params_rate(params))
1565 break;
1566 if (i == ARRAY_SIZE(arizona_sr_vals)) {
1567 arizona_aif_err(dai, "Unsupported sample rate %dHz\n",
1568 params_rate(params));
1569 return -EINVAL;
1570 }
1571 sr_val = i;
1572
1573 switch (priv->arizona->type) {
1574 case WM5102:
1575 case WM8997:
1576 if (arizona_sr_vals[sr_val] >= 88200)
1577 ret = arizona_dvfs_up(codec, ARIZONA_DVFS_SR1_RQ);
1578 else
1579 ret = arizona_dvfs_down(codec, ARIZONA_DVFS_SR1_RQ);
1580
1581 if (ret) {
1582 arizona_aif_err(dai, "Failed to change DVFS %d\n", ret);
1583 return ret;
1584 }
1585 break;
1586 default:
1587 break;
1588 }
1589
1590 switch (dai_priv->clk) {
1591 case ARIZONA_CLK_SYSCLK:
1592 switch (priv->arizona->type) {
1593 case WM5102:
1594 arizona_wm5102_set_dac_comp(codec,
1595 params_rate(params));
1596 break;
1597 default:
1598 break;
1599 }
1600
1601 snd_soc_update_bits(codec, ARIZONA_SAMPLE_RATE_1,
1602 ARIZONA_SAMPLE_RATE_1_MASK, sr_val);
1603 if (base)
1604 snd_soc_update_bits(codec, base + ARIZONA_AIF_RATE_CTRL,
1605 ARIZONA_AIF1_RATE_MASK, 0);
1606 break;
1607 case ARIZONA_CLK_ASYNCCLK:
1608 snd_soc_update_bits(codec, ARIZONA_ASYNC_SAMPLE_RATE_1,
1609 ARIZONA_ASYNC_SAMPLE_RATE_1_MASK, sr_val);
1610 if (base)
1611 snd_soc_update_bits(codec, base + ARIZONA_AIF_RATE_CTRL,
1612 ARIZONA_AIF1_RATE_MASK,
1613 8 << ARIZONA_AIF1_RATE_SHIFT);
1614 break;
1615 default:
1616 arizona_aif_err(dai, "Invalid clock %d\n", dai_priv->clk);
1617 return -EINVAL;
1618 }
1619
1620 return 0;
1621 }
1622
1623 static bool arizona_aif_cfg_changed(struct snd_soc_codec *codec,
1624 int base, int bclk, int lrclk, int frame)
1625 {
1626 int val;
1627
1628 val = snd_soc_read(codec, base + ARIZONA_AIF_BCLK_CTRL);
1629 if (bclk != (val & ARIZONA_AIF1_BCLK_FREQ_MASK))
1630 return true;
1631
1632 val = snd_soc_read(codec, base + ARIZONA_AIF_TX_BCLK_RATE);
1633 if (lrclk != (val & ARIZONA_AIF1TX_BCPF_MASK))
1634 return true;
1635
1636 val = snd_soc_read(codec, base + ARIZONA_AIF_FRAME_CTRL_1);
1637 if (frame != (val & (ARIZONA_AIF1TX_WL_MASK |
1638 ARIZONA_AIF1TX_SLOT_LEN_MASK)))
1639 return true;
1640
1641 return false;
1642 }
1643
1644 static int arizona_hw_params(struct snd_pcm_substream *substream,
1645 struct snd_pcm_hw_params *params,
1646 struct snd_soc_dai *dai)
1647 {
1648 struct snd_soc_codec *codec = dai->codec;
1649 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1650 struct arizona *arizona = priv->arizona;
1651 int base = dai->driver->base;
1652 const int *rates;
1653 int i, ret, val;
1654 int channels = params_channels(params);
1655 int chan_limit = arizona->pdata.max_channels_clocked[dai->id - 1];
1656 int tdm_width = arizona->tdm_width[dai->id - 1];
1657 int tdm_slots = arizona->tdm_slots[dai->id - 1];
1658 int bclk, lrclk, wl, frame, bclk_target;
1659 bool reconfig;
1660 unsigned int aif_tx_state, aif_rx_state;
1661
1662 if (params_rate(params) % 4000)
1663 rates = &arizona_44k1_bclk_rates[0];
1664 else
1665 rates = &arizona_48k_bclk_rates[0];
1666
1667 wl = params_width(params);
1668
1669 if (tdm_slots) {
1670 arizona_aif_dbg(dai, "Configuring for %d %d bit TDM slots\n",
1671 tdm_slots, tdm_width);
1672 bclk_target = tdm_slots * tdm_width * params_rate(params);
1673 channels = tdm_slots;
1674 } else {
1675 bclk_target = snd_soc_params_to_bclk(params);
1676 tdm_width = wl;
1677 }
1678
1679 if (chan_limit && chan_limit < channels) {
1680 arizona_aif_dbg(dai, "Limiting to %d channels\n", chan_limit);
1681 bclk_target /= channels;
1682 bclk_target *= chan_limit;
1683 }
1684
1685 /* Force multiple of 2 channels for I2S mode */
1686 val = snd_soc_read(codec, base + ARIZONA_AIF_FORMAT);
1687 val &= ARIZONA_AIF1_FMT_MASK;
1688 if ((channels & 1) && (val == ARIZONA_FMT_I2S_MODE)) {
1689 arizona_aif_dbg(dai, "Forcing stereo mode\n");
1690 bclk_target /= channels;
1691 bclk_target *= channels + 1;
1692 }
1693
1694 for (i = 0; i < ARRAY_SIZE(arizona_44k1_bclk_rates); i++) {
1695 if (rates[i] >= bclk_target &&
1696 rates[i] % params_rate(params) == 0) {
1697 bclk = i;
1698 break;
1699 }
1700 }
1701 if (i == ARRAY_SIZE(arizona_44k1_bclk_rates)) {
1702 arizona_aif_err(dai, "Unsupported sample rate %dHz\n",
1703 params_rate(params));
1704 return -EINVAL;
1705 }
1706
1707 lrclk = rates[bclk] / params_rate(params);
1708
1709 arizona_aif_dbg(dai, "BCLK %dHz LRCLK %dHz\n",
1710 rates[bclk], rates[bclk] / lrclk);
1711
1712 frame = wl << ARIZONA_AIF1TX_WL_SHIFT | tdm_width;
1713
1714 reconfig = arizona_aif_cfg_changed(codec, base, bclk, lrclk, frame);
1715
1716 if (reconfig) {
1717 /* Save AIF TX/RX state */
1718 aif_tx_state = snd_soc_read(codec,
1719 base + ARIZONA_AIF_TX_ENABLES);
1720 aif_rx_state = snd_soc_read(codec,
1721 base + ARIZONA_AIF_RX_ENABLES);
1722 /* Disable AIF TX/RX before reconfiguring it */
1723 regmap_update_bits_async(arizona->regmap,
1724 base + ARIZONA_AIF_TX_ENABLES, 0xff, 0x0);
1725 regmap_update_bits(arizona->regmap,
1726 base + ARIZONA_AIF_RX_ENABLES, 0xff, 0x0);
1727 }
1728
1729 ret = arizona_hw_params_rate(substream, params, dai);
1730 if (ret != 0)
1731 goto restore_aif;
1732
1733 if (reconfig) {
1734 regmap_update_bits_async(arizona->regmap,
1735 base + ARIZONA_AIF_BCLK_CTRL,
1736 ARIZONA_AIF1_BCLK_FREQ_MASK, bclk);
1737 regmap_update_bits_async(arizona->regmap,
1738 base + ARIZONA_AIF_TX_BCLK_RATE,
1739 ARIZONA_AIF1TX_BCPF_MASK, lrclk);
1740 regmap_update_bits_async(arizona->regmap,
1741 base + ARIZONA_AIF_RX_BCLK_RATE,
1742 ARIZONA_AIF1RX_BCPF_MASK, lrclk);
1743 regmap_update_bits_async(arizona->regmap,
1744 base + ARIZONA_AIF_FRAME_CTRL_1,
1745 ARIZONA_AIF1TX_WL_MASK |
1746 ARIZONA_AIF1TX_SLOT_LEN_MASK, frame);
1747 regmap_update_bits(arizona->regmap,
1748 base + ARIZONA_AIF_FRAME_CTRL_2,
1749 ARIZONA_AIF1RX_WL_MASK |
1750 ARIZONA_AIF1RX_SLOT_LEN_MASK, frame);
1751 }
1752
1753 restore_aif:
1754 if (reconfig) {
1755 /* Restore AIF TX/RX state */
1756 regmap_update_bits_async(arizona->regmap,
1757 base + ARIZONA_AIF_TX_ENABLES,
1758 0xff, aif_tx_state);
1759 regmap_update_bits(arizona->regmap,
1760 base + ARIZONA_AIF_RX_ENABLES,
1761 0xff, aif_rx_state);
1762 }
1763 return ret;
1764 }
1765
1766 static const char *arizona_dai_clk_str(int clk_id)
1767 {
1768 switch (clk_id) {
1769 case ARIZONA_CLK_SYSCLK:
1770 return "SYSCLK";
1771 case ARIZONA_CLK_ASYNCCLK:
1772 return "ASYNCCLK";
1773 default:
1774 return "Unknown clock";
1775 }
1776 }
1777
1778 static int arizona_dai_set_sysclk(struct snd_soc_dai *dai,
1779 int clk_id, unsigned int freq, int dir)
1780 {
1781 struct snd_soc_codec *codec = dai->codec;
1782 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
1783 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1784 struct arizona_dai_priv *dai_priv = &priv->dai[dai->id - 1];
1785 struct snd_soc_dapm_route routes[2];
1786
1787 switch (clk_id) {
1788 case ARIZONA_CLK_SYSCLK:
1789 case ARIZONA_CLK_ASYNCCLK:
1790 break;
1791 default:
1792 return -EINVAL;
1793 }
1794
1795 if (clk_id == dai_priv->clk)
1796 return 0;
1797
1798 if (dai->active) {
1799 dev_err(codec->dev, "Can't change clock on active DAI %d\n",
1800 dai->id);
1801 return -EBUSY;
1802 }
1803
1804 dev_dbg(codec->dev, "Setting AIF%d to %s\n", dai->id + 1,
1805 arizona_dai_clk_str(clk_id));
1806
1807 memset(&routes, 0, sizeof(routes));
1808 routes[0].sink = dai->driver->capture.stream_name;
1809 routes[1].sink = dai->driver->playback.stream_name;
1810
1811 routes[0].source = arizona_dai_clk_str(dai_priv->clk);
1812 routes[1].source = arizona_dai_clk_str(dai_priv->clk);
1813 snd_soc_dapm_del_routes(dapm, routes, ARRAY_SIZE(routes));
1814
1815 routes[0].source = arizona_dai_clk_str(clk_id);
1816 routes[1].source = arizona_dai_clk_str(clk_id);
1817 snd_soc_dapm_add_routes(dapm, routes, ARRAY_SIZE(routes));
1818
1819 dai_priv->clk = clk_id;
1820
1821 return snd_soc_dapm_sync(dapm);
1822 }
1823
1824 static int arizona_set_tristate(struct snd_soc_dai *dai, int tristate)
1825 {
1826 struct snd_soc_codec *codec = dai->codec;
1827 int base = dai->driver->base;
1828 unsigned int reg;
1829
1830 if (tristate)
1831 reg = ARIZONA_AIF1_TRI;
1832 else
1833 reg = 0;
1834
1835 return snd_soc_update_bits(codec, base + ARIZONA_AIF_RATE_CTRL,
1836 ARIZONA_AIF1_TRI, reg);
1837 }
1838
1839 static void arizona_set_channels_to_mask(struct snd_soc_dai *dai,
1840 unsigned int base,
1841 int channels, unsigned int mask)
1842 {
1843 struct snd_soc_codec *codec = dai->codec;
1844 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1845 struct arizona *arizona = priv->arizona;
1846 int slot, i;
1847
1848 for (i = 0; i < channels; ++i) {
1849 slot = ffs(mask) - 1;
1850 if (slot < 0)
1851 return;
1852
1853 regmap_write(arizona->regmap, base + i, slot);
1854
1855 mask &= ~(1 << slot);
1856 }
1857
1858 if (mask)
1859 arizona_aif_warn(dai, "Too many channels in TDM mask\n");
1860 }
1861
1862 static int arizona_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
1863 unsigned int rx_mask, int slots, int slot_width)
1864 {
1865 struct snd_soc_codec *codec = dai->codec;
1866 struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
1867 struct arizona *arizona = priv->arizona;
1868 int base = dai->driver->base;
1869 int rx_max_chan = dai->driver->playback.channels_max;
1870 int tx_max_chan = dai->driver->capture.channels_max;
1871
1872 /* Only support TDM for the physical AIFs */
1873 if (dai->id > ARIZONA_MAX_AIF)
1874 return -ENOTSUPP;
1875
1876 if (slots == 0) {
1877 tx_mask = (1 << tx_max_chan) - 1;
1878 rx_mask = (1 << rx_max_chan) - 1;
1879 }
1880
1881 arizona_set_channels_to_mask(dai, base + ARIZONA_AIF_FRAME_CTRL_3,
1882 tx_max_chan, tx_mask);
1883 arizona_set_channels_to_mask(dai, base + ARIZONA_AIF_FRAME_CTRL_11,
1884 rx_max_chan, rx_mask);
1885
1886 arizona->tdm_width[dai->id - 1] = slot_width;
1887 arizona->tdm_slots[dai->id - 1] = slots;
1888
1889 return 0;
1890 }
1891
1892 const struct snd_soc_dai_ops arizona_dai_ops = {
1893 .startup = arizona_startup,
1894 .set_fmt = arizona_set_fmt,
1895 .set_tdm_slot = arizona_set_tdm_slot,
1896 .hw_params = arizona_hw_params,
1897 .set_sysclk = arizona_dai_set_sysclk,
1898 .set_tristate = arizona_set_tristate,
1899 };
1900 EXPORT_SYMBOL_GPL(arizona_dai_ops);
1901
1902 const struct snd_soc_dai_ops arizona_simple_dai_ops = {
1903 .startup = arizona_startup,
1904 .hw_params = arizona_hw_params_rate,
1905 .set_sysclk = arizona_dai_set_sysclk,
1906 };
1907 EXPORT_SYMBOL_GPL(arizona_simple_dai_ops);
1908
1909 int arizona_init_dai(struct arizona_priv *priv, int id)
1910 {
1911 struct arizona_dai_priv *dai_priv = &priv->dai[id];
1912
1913 dai_priv->clk = ARIZONA_CLK_SYSCLK;
1914
1915 return 0;
1916 }
1917 EXPORT_SYMBOL_GPL(arizona_init_dai);
1918
1919 static struct {
1920 unsigned int min;
1921 unsigned int max;
1922 u16 fratio;
1923 int ratio;
1924 } fll_fratios[] = {
1925 { 0, 64000, 4, 16 },
1926 { 64000, 128000, 3, 8 },
1927 { 128000, 256000, 2, 4 },
1928 { 256000, 1000000, 1, 2 },
1929 { 1000000, 13500000, 0, 1 },
1930 };
1931
1932 static const unsigned int pseudo_fref_max[ARIZONA_FLL_MAX_FRATIO] = {
1933 13500000,
1934 6144000,
1935 6144000,
1936 3072000,
1937 3072000,
1938 2822400,
1939 2822400,
1940 1536000,
1941 1536000,
1942 1536000,
1943 1536000,
1944 1536000,
1945 1536000,
1946 1536000,
1947 1536000,
1948 768000,
1949 };
1950
1951 static struct {
1952 unsigned int min;
1953 unsigned int max;
1954 u16 gain;
1955 } fll_gains[] = {
1956 { 0, 256000, 0 },
1957 { 256000, 1000000, 2 },
1958 { 1000000, 13500000, 4 },
1959 };
1960
1961 struct arizona_fll_cfg {
1962 int n;
1963 int theta;
1964 int lambda;
1965 int refdiv;
1966 int outdiv;
1967 int fratio;
1968 int gain;
1969 };
1970
1971 static int arizona_validate_fll(struct arizona_fll *fll,
1972 unsigned int Fref,
1973 unsigned int Fout)
1974 {
1975 unsigned int Fvco_min;
1976
1977 if (fll->fout && Fout != fll->fout) {
1978 arizona_fll_err(fll,
1979 "Can't change output on active FLL\n");
1980 return -EINVAL;
1981 }
1982
1983 if (Fref / ARIZONA_FLL_MAX_REFDIV > ARIZONA_FLL_MAX_FREF) {
1984 arizona_fll_err(fll,
1985 "Can't scale %dMHz in to <=13.5MHz\n",
1986 Fref);
1987 return -EINVAL;
1988 }
1989
1990 Fvco_min = ARIZONA_FLL_MIN_FVCO * fll->vco_mult;
1991 if (Fout * ARIZONA_FLL_MAX_OUTDIV < Fvco_min) {
1992 arizona_fll_err(fll, "No FLL_OUTDIV for Fout=%uHz\n",
1993 Fout);
1994 return -EINVAL;
1995 }
1996
1997 return 0;
1998 }
1999
2000 static int arizona_find_fratio(unsigned int Fref, int *fratio)
2001 {
2002 int i;
2003
2004 /* Find an appropriate FLL_FRATIO */
2005 for (i = 0; i < ARRAY_SIZE(fll_fratios); i++) {
2006 if (fll_fratios[i].min <= Fref && Fref <= fll_fratios[i].max) {
2007 if (fratio)
2008 *fratio = fll_fratios[i].fratio;
2009 return fll_fratios[i].ratio;
2010 }
2011 }
2012
2013 return -EINVAL;
2014 }
2015
2016 static int arizona_calc_fratio(struct arizona_fll *fll,
2017 struct arizona_fll_cfg *cfg,
2018 unsigned int target,
2019 unsigned int Fref, bool sync)
2020 {
2021 int init_ratio, ratio;
2022 int refdiv, div;
2023
2024 /* Fref must be <=13.5MHz, find initial refdiv */
2025 div = 1;
2026 cfg->refdiv = 0;
2027 while (Fref > ARIZONA_FLL_MAX_FREF) {
2028 div *= 2;
2029 Fref /= 2;
2030 cfg->refdiv++;
2031
2032 if (div > ARIZONA_FLL_MAX_REFDIV)
2033 return -EINVAL;
2034 }
2035
2036 /* Find an appropriate FLL_FRATIO */
2037 init_ratio = arizona_find_fratio(Fref, &cfg->fratio);
2038 if (init_ratio < 0) {
2039 arizona_fll_err(fll, "Unable to find FRATIO for Fref=%uHz\n",
2040 Fref);
2041 return init_ratio;
2042 }
2043
2044 switch (fll->arizona->type) {
2045 case WM5102:
2046 case WM8997:
2047 return init_ratio;
2048 case WM5110:
2049 case WM8280:
2050 if (fll->arizona->rev < 3 || sync)
2051 return init_ratio;
2052 break;
2053 default:
2054 if (sync)
2055 return init_ratio;
2056 break;
2057 }
2058
2059 cfg->fratio = init_ratio - 1;
2060
2061 /* Adjust FRATIO/refdiv to avoid integer mode if possible */
2062 refdiv = cfg->refdiv;
2063
2064 arizona_fll_dbg(fll, "pseudo: initial ratio=%u fref=%u refdiv=%u\n",
2065 init_ratio, Fref, refdiv);
2066
2067 while (div <= ARIZONA_FLL_MAX_REFDIV) {
2068 for (ratio = init_ratio; ratio <= ARIZONA_FLL_MAX_FRATIO;
2069 ratio++) {
2070 if ((ARIZONA_FLL_VCO_CORNER / 2) /
2071 (fll->vco_mult * ratio) < Fref) {
2072 arizona_fll_dbg(fll, "pseudo: hit VCO corner\n");
2073 break;
2074 }
2075
2076 if (Fref > pseudo_fref_max[ratio - 1]) {
2077 arizona_fll_dbg(fll,
2078 "pseudo: exceeded max fref(%u) for ratio=%u\n",
2079 pseudo_fref_max[ratio - 1],
2080 ratio);
2081 break;
2082 }
2083
2084 if (target % (ratio * Fref)) {
2085 cfg->refdiv = refdiv;
2086 cfg->fratio = ratio - 1;
2087 arizona_fll_dbg(fll,
2088 "pseudo: found fref=%u refdiv=%d(%d) ratio=%d\n",
2089 Fref, refdiv, div, ratio);
2090 return ratio;
2091 }
2092 }
2093
2094 for (ratio = init_ratio - 1; ratio > 0; ratio--) {
2095 if (target % (ratio * Fref)) {
2096 cfg->refdiv = refdiv;
2097 cfg->fratio = ratio - 1;
2098 arizona_fll_dbg(fll,
2099 "pseudo: found fref=%u refdiv=%d(%d) ratio=%d\n",
2100 Fref, refdiv, div, ratio);
2101 return ratio;
2102 }
2103 }
2104
2105 div *= 2;
2106 Fref /= 2;
2107 refdiv++;
2108 init_ratio = arizona_find_fratio(Fref, NULL);
2109 arizona_fll_dbg(fll,
2110 "pseudo: change fref=%u refdiv=%d(%d) ratio=%u\n",
2111 Fref, refdiv, div, init_ratio);
2112 }
2113
2114 arizona_fll_warn(fll, "Falling back to integer mode operation\n");
2115 return cfg->fratio + 1;
2116 }
2117
2118 static int arizona_calc_fll(struct arizona_fll *fll,
2119 struct arizona_fll_cfg *cfg,
2120 unsigned int Fref, bool sync)
2121 {
2122 unsigned int target, div, gcd_fll;
2123 int i, ratio;
2124
2125 arizona_fll_dbg(fll, "Fref=%u Fout=%u\n", Fref, fll->fout);
2126
2127 /* Fvco should be over the targt; don't check the upper bound */
2128 div = ARIZONA_FLL_MIN_OUTDIV;
2129 while (fll->fout * div < ARIZONA_FLL_MIN_FVCO * fll->vco_mult) {
2130 div++;
2131 if (div > ARIZONA_FLL_MAX_OUTDIV)
2132 return -EINVAL;
2133 }
2134 target = fll->fout * div / fll->vco_mult;
2135 cfg->outdiv = div;
2136
2137 arizona_fll_dbg(fll, "Fvco=%dHz\n", target);
2138
2139 /* Find an appropriate FLL_FRATIO and refdiv */
2140 ratio = arizona_calc_fratio(fll, cfg, target, Fref, sync);
2141 if (ratio < 0)
2142 return ratio;
2143
2144 /* Apply the division for our remaining calculations */
2145 Fref = Fref / (1 << cfg->refdiv);
2146
2147 cfg->n = target / (ratio * Fref);
2148
2149 if (target % (ratio * Fref)) {
2150 gcd_fll = gcd(target, ratio * Fref);
2151 arizona_fll_dbg(fll, "GCD=%u\n", gcd_fll);
2152
2153 cfg->theta = (target - (cfg->n * ratio * Fref))
2154 / gcd_fll;
2155 cfg->lambda = (ratio * Fref) / gcd_fll;
2156 } else {
2157 cfg->theta = 0;
2158 cfg->lambda = 0;
2159 }
2160
2161 /* Round down to 16bit range with cost of accuracy lost.
2162 * Denominator must be bigger than numerator so we only
2163 * take care of it.
2164 */
2165 while (cfg->lambda >= (1 << 16)) {
2166 cfg->theta >>= 1;
2167 cfg->lambda >>= 1;
2168 }
2169
2170 for (i = 0; i < ARRAY_SIZE(fll_gains); i++) {
2171 if (fll_gains[i].min <= Fref && Fref <= fll_gains[i].max) {
2172 cfg->gain = fll_gains[i].gain;
2173 break;
2174 }
2175 }
2176 if (i == ARRAY_SIZE(fll_gains)) {
2177 arizona_fll_err(fll, "Unable to find gain for Fref=%uHz\n",
2178 Fref);
2179 return -EINVAL;
2180 }
2181
2182 arizona_fll_dbg(fll, "N=%x THETA=%x LAMBDA=%x\n",
2183 cfg->n, cfg->theta, cfg->lambda);
2184 arizona_fll_dbg(fll, "FRATIO=%x(%d) OUTDIV=%x REFCLK_DIV=%x\n",
2185 cfg->fratio, cfg->fratio, cfg->outdiv, cfg->refdiv);
2186 arizona_fll_dbg(fll, "GAIN=%d\n", cfg->gain);
2187
2188 return 0;
2189
2190 }
2191
2192 static void arizona_apply_fll(struct arizona *arizona, unsigned int base,
2193 struct arizona_fll_cfg *cfg, int source,
2194 bool sync)
2195 {
2196 regmap_update_bits_async(arizona->regmap, base + 3,
2197 ARIZONA_FLL1_THETA_MASK, cfg->theta);
2198 regmap_update_bits_async(arizona->regmap, base + 4,
2199 ARIZONA_FLL1_LAMBDA_MASK, cfg->lambda);
2200 regmap_update_bits_async(arizona->regmap, base + 5,
2201 ARIZONA_FLL1_FRATIO_MASK,
2202 cfg->fratio << ARIZONA_FLL1_FRATIO_SHIFT);
2203 regmap_update_bits_async(arizona->regmap, base + 6,
2204 ARIZONA_FLL1_CLK_REF_DIV_MASK |
2205 ARIZONA_FLL1_CLK_REF_SRC_MASK,
2206 cfg->refdiv << ARIZONA_FLL1_CLK_REF_DIV_SHIFT |
2207 source << ARIZONA_FLL1_CLK_REF_SRC_SHIFT);
2208
2209 if (sync) {
2210 regmap_update_bits(arizona->regmap, base + 0x7,
2211 ARIZONA_FLL1_GAIN_MASK,
2212 cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
2213 } else {
2214 regmap_update_bits(arizona->regmap, base + 0x5,
2215 ARIZONA_FLL1_OUTDIV_MASK,
2216 cfg->outdiv << ARIZONA_FLL1_OUTDIV_SHIFT);
2217 regmap_update_bits(arizona->regmap, base + 0x9,
2218 ARIZONA_FLL1_GAIN_MASK,
2219 cfg->gain << ARIZONA_FLL1_GAIN_SHIFT);
2220 }
2221
2222 regmap_update_bits_async(arizona->regmap, base + 2,
2223 ARIZONA_FLL1_CTRL_UPD | ARIZONA_FLL1_N_MASK,
2224 ARIZONA_FLL1_CTRL_UPD | cfg->n);
2225 }
2226
2227 static int arizona_is_enabled_fll(struct arizona_fll *fll)
2228 {
2229 struct arizona *arizona = fll->arizona;
2230 unsigned int reg;
2231 int ret;
2232
2233 ret = regmap_read(arizona->regmap, fll->base + 1, &reg);
2234 if (ret != 0) {
2235 arizona_fll_err(fll, "Failed to read current state: %d\n",
2236 ret);
2237 return ret;
2238 }
2239
2240 return reg & ARIZONA_FLL1_ENA;
2241 }
2242
2243 static int arizona_enable_fll(struct arizona_fll *fll)
2244 {
2245 struct arizona *arizona = fll->arizona;
2246 bool use_sync = false;
2247 int already_enabled = arizona_is_enabled_fll(fll);
2248 struct arizona_fll_cfg cfg;
2249 int i;
2250 unsigned int val;
2251
2252 if (already_enabled < 0)
2253 return already_enabled;
2254
2255 if (already_enabled) {
2256 /* Facilitate smooth refclk across the transition */
2257 regmap_update_bits_async(fll->arizona->regmap, fll->base + 0x9,
2258 ARIZONA_FLL1_GAIN_MASK, 0);
2259 regmap_update_bits(fll->arizona->regmap, fll->base + 1,
2260 ARIZONA_FLL1_FREERUN, ARIZONA_FLL1_FREERUN);
2261 udelay(32);
2262 }
2263
2264 /*
2265 * If we have both REFCLK and SYNCCLK then enable both,
2266 * otherwise apply the SYNCCLK settings to REFCLK.
2267 */
2268 if (fll->ref_src >= 0 && fll->ref_freq &&
2269 fll->ref_src != fll->sync_src) {
2270 arizona_calc_fll(fll, &cfg, fll->ref_freq, false);
2271
2272 arizona_apply_fll(arizona, fll->base, &cfg, fll->ref_src,
2273 false);
2274 if (fll->sync_src >= 0) {
2275 arizona_calc_fll(fll, &cfg, fll->sync_freq, true);
2276
2277 arizona_apply_fll(arizona, fll->base + 0x10, &cfg,
2278 fll->sync_src, true);
2279 use_sync = true;
2280 }
2281 } else if (fll->sync_src >= 0) {
2282 arizona_calc_fll(fll, &cfg, fll->sync_freq, false);
2283
2284 arizona_apply_fll(arizona, fll->base, &cfg,
2285 fll->sync_src, false);
2286
2287 regmap_update_bits_async(arizona->regmap, fll->base + 0x11,
2288 ARIZONA_FLL1_SYNC_ENA, 0);
2289 } else {
2290 arizona_fll_err(fll, "No clocks provided\n");
2291 return -EINVAL;
2292 }
2293
2294 /*
2295 * Increase the bandwidth if we're not using a low frequency
2296 * sync source.
2297 */
2298 if (use_sync && fll->sync_freq > 100000)
2299 regmap_update_bits_async(arizona->regmap, fll->base + 0x17,
2300 ARIZONA_FLL1_SYNC_BW, 0);
2301 else
2302 regmap_update_bits_async(arizona->regmap, fll->base + 0x17,
2303 ARIZONA_FLL1_SYNC_BW,
2304 ARIZONA_FLL1_SYNC_BW);
2305
2306 if (!already_enabled)
2307 pm_runtime_get(arizona->dev);
2308
2309 regmap_update_bits_async(arizona->regmap, fll->base + 1,
2310 ARIZONA_FLL1_ENA, ARIZONA_FLL1_ENA);
2311 if (use_sync)
2312 regmap_update_bits_async(arizona->regmap, fll->base + 0x11,
2313 ARIZONA_FLL1_SYNC_ENA,
2314 ARIZONA_FLL1_SYNC_ENA);
2315
2316 if (already_enabled)
2317 regmap_update_bits_async(arizona->regmap, fll->base + 1,
2318 ARIZONA_FLL1_FREERUN, 0);
2319
2320 arizona_fll_dbg(fll, "Waiting for FLL lock...\n");
2321 val = 0;
2322 for (i = 0; i < 15; i++) {
2323 if (i < 5)
2324 usleep_range(200, 400);
2325 else
2326 msleep(20);
2327
2328 regmap_read(arizona->regmap,
2329 ARIZONA_INTERRUPT_RAW_STATUS_5,
2330 &val);
2331 if (val & (ARIZONA_FLL1_CLOCK_OK_STS << (fll->id - 1)))
2332 break;
2333 }
2334 if (i == 15)
2335 arizona_fll_warn(fll, "Timed out waiting for lock\n");
2336 else
2337 arizona_fll_dbg(fll, "FLL locked (%d polls)\n", i);
2338
2339 return 0;
2340 }
2341
2342 static void arizona_disable_fll(struct arizona_fll *fll)
2343 {
2344 struct arizona *arizona = fll->arizona;
2345 bool change;
2346
2347 regmap_update_bits_async(arizona->regmap, fll->base + 1,
2348 ARIZONA_FLL1_FREERUN, ARIZONA_FLL1_FREERUN);
2349 regmap_update_bits_check(arizona->regmap, fll->base + 1,
2350 ARIZONA_FLL1_ENA, 0, &change);
2351 regmap_update_bits(arizona->regmap, fll->base + 0x11,
2352 ARIZONA_FLL1_SYNC_ENA, 0);
2353 regmap_update_bits_async(arizona->regmap, fll->base + 1,
2354 ARIZONA_FLL1_FREERUN, 0);
2355
2356 if (change)
2357 pm_runtime_put_autosuspend(arizona->dev);
2358 }
2359
2360 int arizona_set_fll_refclk(struct arizona_fll *fll, int source,
2361 unsigned int Fref, unsigned int Fout)
2362 {
2363 int ret = 0;
2364
2365 if (fll->ref_src == source && fll->ref_freq == Fref)
2366 return 0;
2367
2368 if (fll->fout && Fref > 0) {
2369 ret = arizona_validate_fll(fll, Fref, fll->fout);
2370 if (ret != 0)
2371 return ret;
2372 }
2373
2374 fll->ref_src = source;
2375 fll->ref_freq = Fref;
2376
2377 if (fll->fout && Fref > 0) {
2378 ret = arizona_enable_fll(fll);
2379 }
2380
2381 return ret;
2382 }
2383 EXPORT_SYMBOL_GPL(arizona_set_fll_refclk);
2384
2385 int arizona_set_fll(struct arizona_fll *fll, int source,
2386 unsigned int Fref, unsigned int Fout)
2387 {
2388 int ret = 0;
2389
2390 if (fll->sync_src == source &&
2391 fll->sync_freq == Fref && fll->fout == Fout)
2392 return 0;
2393
2394 if (Fout) {
2395 if (fll->ref_src >= 0) {
2396 ret = arizona_validate_fll(fll, fll->ref_freq, Fout);
2397 if (ret != 0)
2398 return ret;
2399 }
2400
2401 ret = arizona_validate_fll(fll, Fref, Fout);
2402 if (ret != 0)
2403 return ret;
2404 }
2405
2406 fll->sync_src = source;
2407 fll->sync_freq = Fref;
2408 fll->fout = Fout;
2409
2410 if (Fout)
2411 ret = arizona_enable_fll(fll);
2412 else
2413 arizona_disable_fll(fll);
2414
2415 return ret;
2416 }
2417 EXPORT_SYMBOL_GPL(arizona_set_fll);
2418
2419 int arizona_init_fll(struct arizona *arizona, int id, int base, int lock_irq,
2420 int ok_irq, struct arizona_fll *fll)
2421 {
2422 unsigned int val;
2423
2424 fll->id = id;
2425 fll->base = base;
2426 fll->arizona = arizona;
2427 fll->sync_src = ARIZONA_FLL_SRC_NONE;
2428
2429 /* Configure default refclk to 32kHz if we have one */
2430 regmap_read(arizona->regmap, ARIZONA_CLOCK_32K_1, &val);
2431 switch (val & ARIZONA_CLK_32K_SRC_MASK) {
2432 case ARIZONA_CLK_SRC_MCLK1:
2433 case ARIZONA_CLK_SRC_MCLK2:
2434 fll->ref_src = val & ARIZONA_CLK_32K_SRC_MASK;
2435 break;
2436 default:
2437 fll->ref_src = ARIZONA_FLL_SRC_NONE;
2438 }
2439 fll->ref_freq = 32768;
2440
2441 snprintf(fll->lock_name, sizeof(fll->lock_name), "FLL%d lock", id);
2442 snprintf(fll->clock_ok_name, sizeof(fll->clock_ok_name),
2443 "FLL%d clock OK", id);
2444
2445 regmap_update_bits(arizona->regmap, fll->base + 1,
2446 ARIZONA_FLL1_FREERUN, 0);
2447
2448 return 0;
2449 }
2450 EXPORT_SYMBOL_GPL(arizona_init_fll);
2451
2452 /**
2453 * arizona_set_output_mode - Set the mode of the specified output
2454 *
2455 * @codec: Device to configure
2456 * @output: Output number
2457 * @diff: True to set the output to differential mode
2458 *
2459 * Some systems use external analogue switches to connect more
2460 * analogue devices to the CODEC than are supported by the device. In
2461 * some systems this requires changing the switched output from single
2462 * ended to differential mode dynamically at runtime, an operation
2463 * supported using this function.
2464 *
2465 * Most systems have a single static configuration and should use
2466 * platform data instead.
2467 */
2468 int arizona_set_output_mode(struct snd_soc_codec *codec, int output, bool diff)
2469 {
2470 unsigned int reg, val;
2471
2472 if (output < 1 || output > 6)
2473 return -EINVAL;
2474
2475 reg = ARIZONA_OUTPUT_PATH_CONFIG_1L + (output - 1) * 8;
2476
2477 if (diff)
2478 val = ARIZONA_OUT1_MONO;
2479 else
2480 val = 0;
2481
2482 return snd_soc_update_bits(codec, reg, ARIZONA_OUT1_MONO, val);
2483 }
2484 EXPORT_SYMBOL_GPL(arizona_set_output_mode);
2485
2486 static const struct soc_enum arizona_adsp2_rate_enum[] = {
2487 SOC_VALUE_ENUM_SINGLE(ARIZONA_DSP1_CONTROL_1,
2488 ARIZONA_DSP1_RATE_SHIFT, 0xf,
2489 ARIZONA_RATE_ENUM_SIZE,
2490 arizona_rate_text, arizona_rate_val),
2491 SOC_VALUE_ENUM_SINGLE(ARIZONA_DSP2_CONTROL_1,
2492 ARIZONA_DSP1_RATE_SHIFT, 0xf,
2493 ARIZONA_RATE_ENUM_SIZE,
2494 arizona_rate_text, arizona_rate_val),
2495 SOC_VALUE_ENUM_SINGLE(ARIZONA_DSP3_CONTROL_1,
2496 ARIZONA_DSP1_RATE_SHIFT, 0xf,
2497 ARIZONA_RATE_ENUM_SIZE,
2498 arizona_rate_text, arizona_rate_val),
2499 SOC_VALUE_ENUM_SINGLE(ARIZONA_DSP4_CONTROL_1,
2500 ARIZONA_DSP1_RATE_SHIFT, 0xf,
2501 ARIZONA_RATE_ENUM_SIZE,
2502 arizona_rate_text, arizona_rate_val),
2503 };
2504
2505 const struct snd_kcontrol_new arizona_adsp2_rate_controls[] = {
2506 SOC_ENUM("DSP1 Rate", arizona_adsp2_rate_enum[0]),
2507 SOC_ENUM("DSP2 Rate", arizona_adsp2_rate_enum[1]),
2508 SOC_ENUM("DSP3 Rate", arizona_adsp2_rate_enum[2]),
2509 SOC_ENUM("DSP4 Rate", arizona_adsp2_rate_enum[3]),
2510 };
2511 EXPORT_SYMBOL_GPL(arizona_adsp2_rate_controls);
2512
2513 static bool arizona_eq_filter_unstable(bool mode, __be16 _a, __be16 _b)
2514 {
2515 s16 a = be16_to_cpu(_a);
2516 s16 b = be16_to_cpu(_b);
2517
2518 if (!mode) {
2519 return abs(a) >= 4096;
2520 } else {
2521 if (abs(b) >= 4096)
2522 return true;
2523
2524 return (abs((a << 16) / (4096 - b)) >= 4096 << 4);
2525 }
2526 }
2527
2528 int arizona_eq_coeff_put(struct snd_kcontrol *kcontrol,
2529 struct snd_ctl_elem_value *ucontrol)
2530 {
2531 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
2532 struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
2533 struct soc_bytes *params = (void *)kcontrol->private_value;
2534 unsigned int val;
2535 __be16 *data;
2536 int len;
2537 int ret;
2538
2539 len = params->num_regs * regmap_get_val_bytes(arizona->regmap);
2540
2541 data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
2542 if (!data)
2543 return -ENOMEM;
2544
2545 data[0] &= cpu_to_be16(ARIZONA_EQ1_B1_MODE);
2546
2547 if (arizona_eq_filter_unstable(!!data[0], data[1], data[2]) ||
2548 arizona_eq_filter_unstable(true, data[4], data[5]) ||
2549 arizona_eq_filter_unstable(true, data[8], data[9]) ||
2550 arizona_eq_filter_unstable(true, data[12], data[13]) ||
2551 arizona_eq_filter_unstable(false, data[16], data[17])) {
2552 dev_err(arizona->dev, "Rejecting unstable EQ coefficients\n");
2553 ret = -EINVAL;
2554 goto out;
2555 }
2556
2557 ret = regmap_read(arizona->regmap, params->base, &val);
2558 if (ret != 0)
2559 goto out;
2560
2561 val &= ~ARIZONA_EQ1_B1_MODE;
2562 data[0] |= cpu_to_be16(val);
2563
2564 ret = regmap_raw_write(arizona->regmap, params->base, data, len);
2565
2566 out:
2567 kfree(data);
2568 return ret;
2569 }
2570 EXPORT_SYMBOL_GPL(arizona_eq_coeff_put);
2571
2572 int arizona_lhpf_coeff_put(struct snd_kcontrol *kcontrol,
2573 struct snd_ctl_elem_value *ucontrol)
2574 {
2575 struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
2576 struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
2577 __be16 *data = (__be16 *)ucontrol->value.bytes.data;
2578 s16 val = be16_to_cpu(*data);
2579
2580 if (abs(val) >= 4096) {
2581 dev_err(arizona->dev, "Rejecting unstable LHPF coefficients\n");
2582 return -EINVAL;
2583 }
2584
2585 return snd_soc_bytes_put(kcontrol, ucontrol);
2586 }
2587 EXPORT_SYMBOL_GPL(arizona_lhpf_coeff_put);
2588
2589 MODULE_DESCRIPTION("ASoC Wolfson Arizona class device support");
2590 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
2591 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.107669 seconds and 6 git commands to generate.