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