?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux/fpc-iii.git] / sound / soc / codecs / adau17x1.c
blobfcf05b254ecd5c37a91dbff5a3ccc3de1069e2f0
1 /*
2 * Common code for ADAU1X61 and ADAU1X81 codecs
3 *
4 * Copyright 2011-2014 Analog Devices Inc.
5 * Author: Lars-Peter Clausen <lars@metafoo.de>
6 *
7 * Licensed under the GPL-2 or later.
8 */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/delay.h>
13 #include <linux/slab.h>
14 #include <sound/core.h>
15 #include <sound/pcm.h>
16 #include <sound/pcm_params.h>
17 #include <sound/soc.h>
18 #include <sound/tlv.h>
19 #include <linux/gcd.h>
20 #include <linux/i2c.h>
21 #include <linux/spi/spi.h>
22 #include <linux/regmap.h>
23
24 #include "sigmadsp.h"
25 #include "adau17x1.h"
26
27 static const char * const adau17x1_capture_mixer_boost_text[] = {
28 "Normal operation", "Boost Level 1", "Boost Level 2", "Boost Level 3",
29 };
30
31 static SOC_ENUM_SINGLE_DECL(adau17x1_capture_boost_enum,
32 ADAU17X1_REC_POWER_MGMT, 5, adau17x1_capture_mixer_boost_text);
33
34 static const char * const adau17x1_mic_bias_mode_text[] = {
35 "Normal operation", "High performance",
36 };
37
38 static SOC_ENUM_SINGLE_DECL(adau17x1_mic_bias_mode_enum,
39 ADAU17X1_MICBIAS, 3, adau17x1_mic_bias_mode_text);
40
41 static const DECLARE_TLV_DB_MINMAX(adau17x1_digital_tlv, -9563, 0);
42
43 static const struct snd_kcontrol_new adau17x1_controls[] = {
44 SOC_DOUBLE_R_TLV("Digital Capture Volume",
45 ADAU17X1_LEFT_INPUT_DIGITAL_VOL,
46 ADAU17X1_RIGHT_INPUT_DIGITAL_VOL,
47 0, 0xff, 1, adau17x1_digital_tlv),
48 SOC_DOUBLE_R_TLV("Digital Playback Volume", ADAU17X1_DAC_CONTROL1,
49 ADAU17X1_DAC_CONTROL2, 0, 0xff, 1, adau17x1_digital_tlv),
50
51 SOC_SINGLE("ADC High Pass Filter Switch", ADAU17X1_ADC_CONTROL,
52 5, 1, 0),
53 SOC_SINGLE("Playback De-emphasis Switch", ADAU17X1_DAC_CONTROL0,
54 2, 1, 0),
55
56 SOC_ENUM("Capture Boost", adau17x1_capture_boost_enum),
57
58 SOC_ENUM("Mic Bias Mode", adau17x1_mic_bias_mode_enum),
59 };
60
61 static int adau17x1_pll_event(struct snd_soc_dapm_widget *w,
62 struct snd_kcontrol *kcontrol, int event)
63 {
64 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
65 struct adau *adau = snd_soc_codec_get_drvdata(codec);
66 int ret;
67
68 if (SND_SOC_DAPM_EVENT_ON(event)) {
69 adau->pll_regs[5] = 1;
70 } else {
71 adau->pll_regs[5] = 0;
72 /* Bypass the PLL when disabled, otherwise registers will become
73 * inaccessible. */
74 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,
75 ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL, 0);
76 }
77
78 /* The PLL register is 6 bytes long and can only be written at once. */
79 ret = regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL,
80 adau->pll_regs, ARRAY_SIZE(adau->pll_regs));
81
82 if (SND_SOC_DAPM_EVENT_ON(event)) {
83 mdelay(5);
84 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,
85 ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL,
86 ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL);
87 }
88
89 return 0;
90 }
91
92 static const char * const adau17x1_mono_stereo_text[] = {
93 "Stereo",
94 "Mono Left Channel (L+R)",
95 "Mono Right Channel (L+R)",
96 "Mono (L+R)",
97 };
98
99 static SOC_ENUM_SINGLE_DECL(adau17x1_dac_mode_enum,
100 ADAU17X1_DAC_CONTROL0, 6, adau17x1_mono_stereo_text);
101
102 static const struct snd_kcontrol_new adau17x1_dac_mode_mux =
103 SOC_DAPM_ENUM("DAC Mono-Stereo-Mode", adau17x1_dac_mode_enum);
104
105 static const struct snd_soc_dapm_widget adau17x1_dapm_widgets[] = {
106 SND_SOC_DAPM_SUPPLY_S("PLL", 3, SND_SOC_NOPM, 0, 0, adau17x1_pll_event,
107 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
108
109 SND_SOC_DAPM_SUPPLY("AIFCLK", SND_SOC_NOPM, 0, 0, NULL, 0),
110
111 SND_SOC_DAPM_SUPPLY("MICBIAS", ADAU17X1_MICBIAS, 0, 0, NULL, 0),
112
113 SND_SOC_DAPM_SUPPLY("Left Playback Enable", ADAU17X1_PLAY_POWER_MGMT,
114 0, 0, NULL, 0),
115 SND_SOC_DAPM_SUPPLY("Right Playback Enable", ADAU17X1_PLAY_POWER_MGMT,
116 1, 0, NULL, 0),
117
118 SND_SOC_DAPM_MUX("Left DAC Mode Mux", SND_SOC_NOPM, 0, 0,
119 &adau17x1_dac_mode_mux),
120 SND_SOC_DAPM_MUX("Right DAC Mode Mux", SND_SOC_NOPM, 0, 0,
121 &adau17x1_dac_mode_mux),
122
123 SND_SOC_DAPM_ADC("Left Decimator", NULL, ADAU17X1_ADC_CONTROL, 0, 0),
124 SND_SOC_DAPM_ADC("Right Decimator", NULL, ADAU17X1_ADC_CONTROL, 1, 0),
125 SND_SOC_DAPM_DAC("Left DAC", NULL, ADAU17X1_DAC_CONTROL0, 0, 0),
126 SND_SOC_DAPM_DAC("Right DAC", NULL, ADAU17X1_DAC_CONTROL0, 1, 0),
127 };
128
129 static const struct snd_soc_dapm_route adau17x1_dapm_routes[] = {
130 { "Left Decimator", NULL, "SYSCLK" },
131 { "Right Decimator", NULL, "SYSCLK" },
132 { "Left DAC", NULL, "SYSCLK" },
133 { "Right DAC", NULL, "SYSCLK" },
134 { "Capture", NULL, "SYSCLK" },
135 { "Playback", NULL, "SYSCLK" },
136
137 { "Left DAC", NULL, "Left DAC Mode Mux" },
138 { "Right DAC", NULL, "Right DAC Mode Mux" },
139
140 { "Capture", NULL, "AIFCLK" },
141 { "Playback", NULL, "AIFCLK" },
142 };
143
144 static const struct snd_soc_dapm_route adau17x1_dapm_pll_route = {
145 "SYSCLK", NULL, "PLL",
146 };
147
148 /*
149 * The MUX register for the Capture and Playback MUXs selects either DSP as
150 * source/destination or one of the TDM slots. The TDM slot is selected via
151 * snd_soc_dai_set_tdm_slot(), so we only expose whether to go to the DSP or
152 * directly to the DAI interface with this control.
153 */
154 static int adau17x1_dsp_mux_enum_put(struct snd_kcontrol *kcontrol,
155 struct snd_ctl_elem_value *ucontrol)
156 {
157 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol);
158 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
159 struct adau *adau = snd_soc_codec_get_drvdata(codec);
160 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
161 struct snd_soc_dapm_update update;
162 unsigned int stream = e->shift_l;
163 unsigned int val, change;
164 int reg;
165
166 if (ucontrol->value.enumerated.item[0] >= e->items)
167 return -EINVAL;
168
169 switch (ucontrol->value.enumerated.item[0]) {
170 case 0:
171 val = 0;
172 adau->dsp_bypass[stream] = false;
173 break;
174 default:
175 val = (adau->tdm_slot[stream] * 2) + 1;
176 adau->dsp_bypass[stream] = true;
177 break;
178 }
179
180 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
181 reg = ADAU17X1_SERIAL_INPUT_ROUTE;
182 else
183 reg = ADAU17X1_SERIAL_OUTPUT_ROUTE;
184
185 change = snd_soc_test_bits(codec, reg, 0xff, val);
186 if (change) {
187 update.kcontrol = kcontrol;
188 update.mask = 0xff;
189 update.reg = reg;
190 update.val = val;
191
192 snd_soc_dapm_mux_update_power(dapm, kcontrol,
193 ucontrol->value.enumerated.item[0], e, &update);
194 }
195
196 return change;
197 }
198
199 static int adau17x1_dsp_mux_enum_get(struct snd_kcontrol *kcontrol,
200 struct snd_ctl_elem_value *ucontrol)
201 {
202 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol);
203 struct adau *adau = snd_soc_codec_get_drvdata(codec);
204 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
205 unsigned int stream = e->shift_l;
206 unsigned int reg, val;
207 int ret;
208
209 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
210 reg = ADAU17X1_SERIAL_INPUT_ROUTE;
211 else
212 reg = ADAU17X1_SERIAL_OUTPUT_ROUTE;
213
214 ret = regmap_read(adau->regmap, reg, &val);
215 if (ret)
216 return ret;
217
218 if (val != 0)
219 val = 1;
220 ucontrol->value.enumerated.item[0] = val;
221
222 return 0;
223 }
224
225 #define DECLARE_ADAU17X1_DSP_MUX_CTRL(_name, _label, _stream, _text) \
226 const struct snd_kcontrol_new _name = \
227 SOC_DAPM_ENUM_EXT(_label, (const struct soc_enum)\
228 SOC_ENUM_SINGLE(SND_SOC_NOPM, _stream, \
229 ARRAY_SIZE(_text), _text), \
230 adau17x1_dsp_mux_enum_get, adau17x1_dsp_mux_enum_put)
231
232 static const char * const adau17x1_dac_mux_text[] = {
233 "DSP",
234 "AIFIN",
235 };
236
237 static const char * const adau17x1_capture_mux_text[] = {
238 "DSP",
239 "Decimator",
240 };
241
242 static DECLARE_ADAU17X1_DSP_MUX_CTRL(adau17x1_dac_mux, "DAC Playback Mux",
243 SNDRV_PCM_STREAM_PLAYBACK, adau17x1_dac_mux_text);
244
245 static DECLARE_ADAU17X1_DSP_MUX_CTRL(adau17x1_capture_mux, "Capture Mux",
246 SNDRV_PCM_STREAM_CAPTURE, adau17x1_capture_mux_text);
247
248 static const struct snd_soc_dapm_widget adau17x1_dsp_dapm_widgets[] = {
249 SND_SOC_DAPM_PGA("DSP", ADAU17X1_DSP_RUN, 0, 0, NULL, 0),
250 SND_SOC_DAPM_SIGGEN("DSP Siggen"),
251
252 SND_SOC_DAPM_MUX("DAC Playback Mux", SND_SOC_NOPM, 0, 0,
253 &adau17x1_dac_mux),
254 SND_SOC_DAPM_MUX("Capture Mux", SND_SOC_NOPM, 0, 0,
255 &adau17x1_capture_mux),
256 };
257
258 static const struct snd_soc_dapm_route adau17x1_dsp_dapm_routes[] = {
259 { "DAC Playback Mux", "DSP", "DSP" },
260 { "DAC Playback Mux", "AIFIN", "Playback" },
261
262 { "Left DAC Mode Mux", "Stereo", "DAC Playback Mux" },
263 { "Left DAC Mode Mux", "Mono (L+R)", "DAC Playback Mux" },
264 { "Left DAC Mode Mux", "Mono Left Channel (L+R)", "DAC Playback Mux" },
265 { "Right DAC Mode Mux", "Stereo", "DAC Playback Mux" },
266 { "Right DAC Mode Mux", "Mono (L+R)", "DAC Playback Mux" },
267 { "Right DAC Mode Mux", "Mono Right Channel (L+R)", "DAC Playback Mux" },
268
269 { "Capture Mux", "DSP", "DSP" },
270 { "Capture Mux", "Decimator", "Left Decimator" },
271 { "Capture Mux", "Decimator", "Right Decimator" },
272
273 { "Capture", NULL, "Capture Mux" },
274
275 { "DSP", NULL, "DSP Siggen" },
276
277 { "DSP", NULL, "Left Decimator" },
278 { "DSP", NULL, "Right Decimator" },
279 };
280
281 static const struct snd_soc_dapm_route adau17x1_no_dsp_dapm_routes[] = {
282 { "Left DAC Mode Mux", "Stereo", "Playback" },
283 { "Left DAC Mode Mux", "Mono (L+R)", "Playback" },
284 { "Left DAC Mode Mux", "Mono Left Channel (L+R)", "Playback" },
285 { "Right DAC Mode Mux", "Stereo", "Playback" },
286 { "Right DAC Mode Mux", "Mono (L+R)", "Playback" },
287 { "Right DAC Mode Mux", "Mono Right Channel (L+R)", "Playback" },
288 { "Capture", NULL, "Left Decimator" },
289 { "Capture", NULL, "Right Decimator" },
290 };
291
292 bool adau17x1_has_dsp(struct adau *adau)
293 {
294 switch (adau->type) {
295 case ADAU1761:
296 case ADAU1381:
297 case ADAU1781:
298 return true;
299 default:
300 return false;
301 }
302 }
303 EXPORT_SYMBOL_GPL(adau17x1_has_dsp);
304
305 static int adau17x1_hw_params(struct snd_pcm_substream *substream,
306 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
307 {
308 struct snd_soc_codec *codec = dai->codec;
309 struct adau *adau = snd_soc_codec_get_drvdata(codec);
310 unsigned int val, div, dsp_div;
311 unsigned int freq;
312 int ret;
313
314 if (adau->clk_src == ADAU17X1_CLK_SRC_PLL)
315 freq = adau->pll_freq;
316 else
317 freq = adau->sysclk;
318
319 if (freq % params_rate(params) != 0)
320 return -EINVAL;
321
322 switch (freq / params_rate(params)) {
323 case 1024: /* fs */
324 div = 0;
325 dsp_div = 1;
326 break;
327 case 6144: /* fs / 6 */
328 div = 1;
329 dsp_div = 6;
330 break;
331 case 4096: /* fs / 4 */
332 div = 2;
333 dsp_div = 5;
334 break;
335 case 3072: /* fs / 3 */
336 div = 3;
337 dsp_div = 4;
338 break;
339 case 2048: /* fs / 2 */
340 div = 4;
341 dsp_div = 3;
342 break;
343 case 1536: /* fs / 1.5 */
344 div = 5;
345 dsp_div = 2;
346 break;
347 case 512: /* fs / 0.5 */
348 div = 6;
349 dsp_div = 0;
350 break;
351 default:
352 return -EINVAL;
353 }
354
355 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
356 ADAU17X1_CONVERTER0_CONVSR_MASK, div);
357 if (adau17x1_has_dsp(adau)) {
358 regmap_write(adau->regmap, ADAU17X1_SERIAL_SAMPLING_RATE, div);
359 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dsp_div);
360 }
361
362 if (adau->sigmadsp) {
363 ret = adau17x1_setup_firmware(adau, params_rate(params));
364 if (ret < 0)
365 return ret;
366 }
367
368 if (adau->dai_fmt != SND_SOC_DAIFMT_RIGHT_J)
369 return 0;
370
371 switch (params_width(params)) {
372 case 16:
373 val = ADAU17X1_SERIAL_PORT1_DELAY16;
374 break;
375 case 24:
376 val = ADAU17X1_SERIAL_PORT1_DELAY8;
377 break;
378 case 32:
379 val = ADAU17X1_SERIAL_PORT1_DELAY0;
380 break;
381 default:
382 return -EINVAL;
383 }
384
385 return regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1,
386 ADAU17X1_SERIAL_PORT1_DELAY_MASK, val);
387 }
388
389 static int adau17x1_set_dai_pll(struct snd_soc_dai *dai, int pll_id,
390 int source, unsigned int freq_in, unsigned int freq_out)
391 {
392 struct snd_soc_codec *codec = dai->codec;
393 struct adau *adau = snd_soc_codec_get_drvdata(codec);
394 unsigned int r, n, m, i, j;
395 unsigned int div;
396 int ret;
397
398 if (freq_in < 8000000 || freq_in > 27000000)
399 return -EINVAL;
400
401 if (!freq_out) {
402 r = 0;
403 n = 0;
404 m = 0;
405 div = 0;
406 } else {
407 if (freq_out % freq_in != 0) {
408 div = DIV_ROUND_UP(freq_in, 13500000);
409 freq_in /= div;
410 r = freq_out / freq_in;
411 i = freq_out % freq_in;
412 j = gcd(i, freq_in);
413 n = i / j;
414 m = freq_in / j;
415 div--;
416 } else {
417 r = freq_out / freq_in;
418 n = 0;
419 m = 0;
420 div = 0;
421 }
422 if (n > 0xffff || m > 0xffff || div > 3 || r > 8 || r < 2)
423 return -EINVAL;
424 }
425
426 adau->pll_regs[0] = m >> 8;
427 adau->pll_regs[1] = m & 0xff;
428 adau->pll_regs[2] = n >> 8;
429 adau->pll_regs[3] = n & 0xff;
430 adau->pll_regs[4] = (r << 3) | (div << 1);
431 if (m != 0)
432 adau->pll_regs[4] |= 1; /* Fractional mode */
433
434 /* The PLL register is 6 bytes long and can only be written at once. */
435 ret = regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL,
436 adau->pll_regs, ARRAY_SIZE(adau->pll_regs));
437 if (ret)
438 return ret;
439
440 adau->pll_freq = freq_out;
441
442 return 0;
443 }
444
445 static int adau17x1_set_dai_sysclk(struct snd_soc_dai *dai,
446 int clk_id, unsigned int freq, int dir)
447 {
448 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(dai->codec);
449 struct adau *adau = snd_soc_codec_get_drvdata(dai->codec);
450
451 switch (clk_id) {
452 case ADAU17X1_CLK_SRC_MCLK:
453 case ADAU17X1_CLK_SRC_PLL:
454 break;
455 default:
456 return -EINVAL;
457 }
458
459 adau->sysclk = freq;
460
461 if (adau->clk_src != clk_id) {
462 if (clk_id == ADAU17X1_CLK_SRC_PLL) {
463 snd_soc_dapm_add_routes(dapm,
464 &adau17x1_dapm_pll_route, 1);
465 } else {
466 snd_soc_dapm_del_routes(dapm,
467 &adau17x1_dapm_pll_route, 1);
468 }
469 }
470
471 adau->clk_src = clk_id;
472
473 return 0;
474 }
475
476 static int adau17x1_set_dai_fmt(struct snd_soc_dai *dai,
477 unsigned int fmt)
478 {
479 struct adau *adau = snd_soc_codec_get_drvdata(dai->codec);
480 unsigned int ctrl0, ctrl1;
481 int lrclk_pol;
482
483 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
484 case SND_SOC_DAIFMT_CBM_CFM:
485 ctrl0 = ADAU17X1_SERIAL_PORT0_MASTER;
486 adau->master = true;
487 break;
488 case SND_SOC_DAIFMT_CBS_CFS:
489 ctrl0 = 0;
490 adau->master = false;
491 break;
492 default:
493 return -EINVAL;
494 }
495
496 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
497 case SND_SOC_DAIFMT_I2S:
498 lrclk_pol = 0;
499 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY1;
500 break;
501 case SND_SOC_DAIFMT_LEFT_J:
502 case SND_SOC_DAIFMT_RIGHT_J:
503 lrclk_pol = 1;
504 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY0;
505 break;
506 case SND_SOC_DAIFMT_DSP_A:
507 lrclk_pol = 1;
508 ctrl0 |= ADAU17X1_SERIAL_PORT0_PULSE_MODE;
509 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY1;
510 break;
511 case SND_SOC_DAIFMT_DSP_B:
512 lrclk_pol = 1;
513 ctrl0 |= ADAU17X1_SERIAL_PORT0_PULSE_MODE;
514 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY0;
515 break;
516 default:
517 return -EINVAL;
518 }
519
520 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
521 case SND_SOC_DAIFMT_NB_NF:
522 break;
523 case SND_SOC_DAIFMT_IB_NF:
524 ctrl0 |= ADAU17X1_SERIAL_PORT0_BCLK_POL;
525 break;
526 case SND_SOC_DAIFMT_NB_IF:
527 lrclk_pol = !lrclk_pol;
528 break;
529 case SND_SOC_DAIFMT_IB_IF:
530 ctrl0 |= ADAU17X1_SERIAL_PORT0_BCLK_POL;
531 lrclk_pol = !lrclk_pol;
532 break;
533 default:
534 return -EINVAL;
535 }
536
537 if (lrclk_pol)
538 ctrl0 |= ADAU17X1_SERIAL_PORT0_LRCLK_POL;
539
540 regmap_write(adau->regmap, ADAU17X1_SERIAL_PORT0, ctrl0);
541 regmap_write(adau->regmap, ADAU17X1_SERIAL_PORT1, ctrl1);
542
543 adau->dai_fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
544
545 return 0;
546 }
547
548 static int adau17x1_set_dai_tdm_slot(struct snd_soc_dai *dai,
549 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
550 {
551 struct adau *adau = snd_soc_codec_get_drvdata(dai->codec);
552 unsigned int ser_ctrl0, ser_ctrl1;
553 unsigned int conv_ctrl0, conv_ctrl1;
554
555 /* I2S mode */
556 if (slots == 0) {
557 slots = 2;
558 rx_mask = 3;
559 tx_mask = 3;
560 slot_width = 32;
561 }
562
563 switch (slots) {
564 case 2:
565 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_STEREO;
566 break;
567 case 4:
568 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_TDM4;
569 break;
570 case 8:
571 if (adau->type == ADAU1361)
572 return -EINVAL;
573
574 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_TDM8;
575 break;
576 default:
577 return -EINVAL;
578 }
579
580 switch (slot_width * slots) {
581 case 32:
582 if (adau->type == ADAU1761)
583 return -EINVAL;
584
585 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK32;
586 break;
587 case 64:
588 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK64;
589 break;
590 case 48:
591 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK48;
592 break;
593 case 128:
594 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK128;
595 break;
596 case 256:
597 if (adau->type == ADAU1361)
598 return -EINVAL;
599
600 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK256;
601 break;
602 default:
603 return -EINVAL;
604 }
605
606 switch (rx_mask) {
607 case 0x03:
608 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(1);
609 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 0;
610 break;
611 case 0x0c:
612 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(2);
613 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 1;
614 break;
615 case 0x30:
616 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(3);
617 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 2;
618 break;
619 case 0xc0:
620 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(4);
621 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 3;
622 break;
623 default:
624 return -EINVAL;
625 }
626
627 switch (tx_mask) {
628 case 0x03:
629 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(1);
630 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 0;
631 break;
632 case 0x0c:
633 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(2);
634 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 1;
635 break;
636 case 0x30:
637 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(3);
638 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 2;
639 break;
640 case 0xc0:
641 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(4);
642 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 3;
643 break;
644 default:
645 return -EINVAL;
646 }
647
648 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
649 ADAU17X1_CONVERTER0_DAC_PAIR_MASK, conv_ctrl0);
650 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER1,
651 ADAU17X1_CONVERTER1_ADC_PAIR_MASK, conv_ctrl1);
652 regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT0,
653 ADAU17X1_SERIAL_PORT0_TDM_MASK, ser_ctrl0);
654 regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1,
655 ADAU17X1_SERIAL_PORT1_BCLK_MASK, ser_ctrl1);
656
657 if (!adau17x1_has_dsp(adau))
658 return 0;
659
660 if (adau->dsp_bypass[SNDRV_PCM_STREAM_PLAYBACK]) {
661 regmap_write(adau->regmap, ADAU17X1_SERIAL_INPUT_ROUTE,
662 (adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] * 2) + 1);
663 }
664
665 if (adau->dsp_bypass[SNDRV_PCM_STREAM_CAPTURE]) {
666 regmap_write(adau->regmap, ADAU17X1_SERIAL_OUTPUT_ROUTE,
667 (adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] * 2) + 1);
668 }
669
670 return 0;
671 }
672
673 static int adau17x1_startup(struct snd_pcm_substream *substream,
674 struct snd_soc_dai *dai)
675 {
676 struct adau *adau = snd_soc_codec_get_drvdata(dai->codec);
677
678 if (adau->sigmadsp)
679 return sigmadsp_restrict_params(adau->sigmadsp, substream);
680
681 return 0;
682 }
683
684 const struct snd_soc_dai_ops adau17x1_dai_ops = {
685 .hw_params = adau17x1_hw_params,
686 .set_sysclk = adau17x1_set_dai_sysclk,
687 .set_fmt = adau17x1_set_dai_fmt,
688 .set_pll = adau17x1_set_dai_pll,
689 .set_tdm_slot = adau17x1_set_dai_tdm_slot,
690 .startup = adau17x1_startup,
691 };
692 EXPORT_SYMBOL_GPL(adau17x1_dai_ops);
693
694 int adau17x1_set_micbias_voltage(struct snd_soc_codec *codec,
695 enum adau17x1_micbias_voltage micbias)
696 {
697 struct adau *adau = snd_soc_codec_get_drvdata(codec);
698
699 switch (micbias) {
700 case ADAU17X1_MICBIAS_0_90_AVDD:
701 case ADAU17X1_MICBIAS_0_65_AVDD:
702 break;
703 default:
704 return -EINVAL;
705 }
706
707 return regmap_write(adau->regmap, ADAU17X1_MICBIAS, micbias << 2);
708 }
709 EXPORT_SYMBOL_GPL(adau17x1_set_micbias_voltage);
710
711 bool adau17x1_precious_register(struct device *dev, unsigned int reg)
712 {
713 /* SigmaDSP parameter memory */
714 if (reg < 0x400)
715 return true;
716
717 return false;
718 }
719 EXPORT_SYMBOL_GPL(adau17x1_precious_register);
720
721 bool adau17x1_readable_register(struct device *dev, unsigned int reg)
722 {
723 /* SigmaDSP parameter memory */
724 if (reg < 0x400)
725 return true;
726
727 switch (reg) {
728 case ADAU17X1_CLOCK_CONTROL:
729 case ADAU17X1_PLL_CONTROL:
730 case ADAU17X1_REC_POWER_MGMT:
731 case ADAU17X1_MICBIAS:
732 case ADAU17X1_SERIAL_PORT0:
733 case ADAU17X1_SERIAL_PORT1:
734 case ADAU17X1_CONVERTER0:
735 case ADAU17X1_CONVERTER1:
736 case ADAU17X1_LEFT_INPUT_DIGITAL_VOL:
737 case ADAU17X1_RIGHT_INPUT_DIGITAL_VOL:
738 case ADAU17X1_ADC_CONTROL:
739 case ADAU17X1_PLAY_POWER_MGMT:
740 case ADAU17X1_DAC_CONTROL0:
741 case ADAU17X1_DAC_CONTROL1:
742 case ADAU17X1_DAC_CONTROL2:
743 case ADAU17X1_SERIAL_PORT_PAD:
744 case ADAU17X1_CONTROL_PORT_PAD0:
745 case ADAU17X1_CONTROL_PORT_PAD1:
746 case ADAU17X1_DSP_SAMPLING_RATE:
747 case ADAU17X1_SERIAL_INPUT_ROUTE:
748 case ADAU17X1_SERIAL_OUTPUT_ROUTE:
749 case ADAU17X1_DSP_ENABLE:
750 case ADAU17X1_DSP_RUN:
751 case ADAU17X1_SERIAL_SAMPLING_RATE:
752 return true;
753 default:
754 break;
755 }
756 return false;
757 }
758 EXPORT_SYMBOL_GPL(adau17x1_readable_register);
759
760 bool adau17x1_volatile_register(struct device *dev, unsigned int reg)
761 {
762 /* SigmaDSP parameter and program memory */
763 if (reg < 0x4000)
764 return true;
765
766 switch (reg) {
767 /* The PLL register is 6 bytes long */
768 case ADAU17X1_PLL_CONTROL:
769 case ADAU17X1_PLL_CONTROL + 1:
770 case ADAU17X1_PLL_CONTROL + 2:
771 case ADAU17X1_PLL_CONTROL + 3:
772 case ADAU17X1_PLL_CONTROL + 4:
773 case ADAU17X1_PLL_CONTROL + 5:
774 return true;
775 default:
776 break;
777 }
778
779 return false;
780 }
781 EXPORT_SYMBOL_GPL(adau17x1_volatile_register);
782
783 int adau17x1_setup_firmware(struct adau *adau, unsigned int rate)
784 {
785 int ret;
786 int dspsr;
787
788 ret = regmap_read(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, &dspsr);
789 if (ret)
790 return ret;
791
792 regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 1);
793 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, 0xf);
794
795 ret = sigmadsp_setup(adau->sigmadsp, rate);
796 if (ret) {
797 regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 0);
798 return ret;
799 }
800 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dspsr);
801
802 return 0;
803 }
804 EXPORT_SYMBOL_GPL(adau17x1_setup_firmware);
805
806 int adau17x1_add_widgets(struct snd_soc_codec *codec)
807 {
808 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
809 struct adau *adau = snd_soc_codec_get_drvdata(codec);
810 int ret;
811
812 ret = snd_soc_add_codec_controls(codec, adau17x1_controls,
813 ARRAY_SIZE(adau17x1_controls));
814 if (ret)
815 return ret;
816 ret = snd_soc_dapm_new_controls(dapm, adau17x1_dapm_widgets,
817 ARRAY_SIZE(adau17x1_dapm_widgets));
818 if (ret)
819 return ret;
820
821 if (adau17x1_has_dsp(adau)) {
822 ret = snd_soc_dapm_new_controls(dapm, adau17x1_dsp_dapm_widgets,
823 ARRAY_SIZE(adau17x1_dsp_dapm_widgets));
824 if (ret)
825 return ret;
826
827 if (!adau->sigmadsp)
828 return 0;
829
830 ret = sigmadsp_attach(adau->sigmadsp, &codec->component);
831 if (ret) {
832 dev_err(codec->dev, "Failed to attach firmware: %d\n",
833 ret);
834 return ret;
835 }
836 }
837
838 return 0;
839 }
840 EXPORT_SYMBOL_GPL(adau17x1_add_widgets);
841
842 int adau17x1_add_routes(struct snd_soc_codec *codec)
843 {
844 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
845 struct adau *adau = snd_soc_codec_get_drvdata(codec);
846 int ret;
847
848 ret = snd_soc_dapm_add_routes(dapm, adau17x1_dapm_routes,
849 ARRAY_SIZE(adau17x1_dapm_routes));
850 if (ret)
851 return ret;
852
853 if (adau17x1_has_dsp(adau)) {
854 ret = snd_soc_dapm_add_routes(dapm, adau17x1_dsp_dapm_routes,
855 ARRAY_SIZE(adau17x1_dsp_dapm_routes));
856 } else {
857 ret = snd_soc_dapm_add_routes(dapm, adau17x1_no_dsp_dapm_routes,
858 ARRAY_SIZE(adau17x1_no_dsp_dapm_routes));
859 }
860 return ret;
861 }
862 EXPORT_SYMBOL_GPL(adau17x1_add_routes);
863
864 int adau17x1_resume(struct snd_soc_codec *codec)
865 {
866 struct adau *adau = snd_soc_codec_get_drvdata(codec);
867
868 if (adau->switch_mode)
869 adau->switch_mode(codec->dev);
870
871 regcache_sync(adau->regmap);
872
873 return 0;
874 }
875 EXPORT_SYMBOL_GPL(adau17x1_resume);
876
877 int adau17x1_probe(struct device *dev, struct regmap *regmap,
878 enum adau17x1_type type, void (*switch_mode)(struct device *dev),
879 const char *firmware_name)
880 {
881 struct adau *adau;
882
883 if (IS_ERR(regmap))
884 return PTR_ERR(regmap);
885
886 adau = devm_kzalloc(dev, sizeof(*adau), GFP_KERNEL);
887 if (!adau)
888 return -ENOMEM;
889
890 adau->regmap = regmap;
891 adau->switch_mode = switch_mode;
892 adau->type = type;
893
894 dev_set_drvdata(dev, adau);
895
896 if (firmware_name) {
897 adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap, NULL,
898 firmware_name);
899 if (IS_ERR(adau->sigmadsp)) {
900 dev_warn(dev, "Could not find firmware file: %ld\n",
901 PTR_ERR(adau->sigmadsp));
902 adau->sigmadsp = NULL;
903 }
904 }
905
906 if (switch_mode)
907 switch_mode(dev);
908
909 return 0;
910 }
911 EXPORT_SYMBOL_GPL(adau17x1_probe);
912
913 MODULE_DESCRIPTION("ASoC ADAU1X61/ADAU1X81 common code");
914 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
915 MODULE_LICENSE("GPL");
Linux with added FPC-III support