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