This source file includes following definitions.
- cz_da7219_init
- da7219_clk_enable
- da7219_clk_disable
- cz_da7219_play_startup
- cz_da7219_cap_startup
- cz_max_startup
- cz_dmic0_startup
- cz_dmic1_startup
- cz_da7219_params
- cz_da7219_shutdown
- cz_probe
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <sound/core.h>
27 #include <sound/soc.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc-dapm.h>
31 #include <sound/jack.h>
32 #include <linux/clk.h>
33 #include <linux/gpio.h>
34 #include <linux/module.h>
35 #include <linux/regulator/machine.h>
36 #include <linux/regulator/driver.h>
37 #include <linux/i2c.h>
38 #include <linux/input.h>
39 #include <linux/acpi.h>
40
41 #include "acp.h"
42 #include "../codecs/da7219.h"
43 #include "../codecs/da7219-aad.h"
44
45 #define CZ_PLAT_CLK 48000000
46 #define DUAL_CHANNEL 2
47
48 static struct snd_soc_jack cz_jack;
49 static struct clk *da7219_dai_wclk;
50 static struct clk *da7219_dai_bclk;
51 extern bool bt_uart_enable;
52
53 static int cz_da7219_init(struct snd_soc_pcm_runtime *rtd)
54 {
55 int ret;
56 struct snd_soc_card *card = rtd->card;
57 struct snd_soc_dai *codec_dai = rtd->codec_dai;
58 struct snd_soc_component *component = codec_dai->component;
59
60 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
61
62 ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK,
63 CZ_PLAT_CLK, SND_SOC_CLOCK_IN);
64 if (ret < 0) {
65 dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
66 return ret;
67 }
68
69 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL,
70 CZ_PLAT_CLK, DA7219_PLL_FREQ_OUT_98304);
71 if (ret < 0) {
72 dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
73 return ret;
74 }
75
76 da7219_dai_wclk = clk_get(component->dev, "da7219-dai-wclk");
77 da7219_dai_bclk = clk_get(component->dev, "da7219-dai-bclk");
78
79 ret = snd_soc_card_jack_new(card, "Headset Jack",
80 SND_JACK_HEADSET | SND_JACK_LINEOUT |
81 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
82 SND_JACK_BTN_2 | SND_JACK_BTN_3,
83 &cz_jack, NULL, 0);
84 if (ret) {
85 dev_err(card->dev, "HP jack creation failed %d\n", ret);
86 return ret;
87 }
88
89 snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
90 snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
91 snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
92 snd_jack_set_key(cz_jack.jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
93
94 da7219_aad_jack_det(component, &cz_jack);
95
96 return 0;
97 }
98
99 static int da7219_clk_enable(struct snd_pcm_substream *substream,
100 int wclk_rate, int bclk_rate)
101 {
102 int ret = 0;
103 struct snd_soc_pcm_runtime *rtd = substream->private_data;
104
105 clk_set_rate(da7219_dai_wclk, wclk_rate);
106 clk_set_rate(da7219_dai_bclk, bclk_rate);
107 ret = clk_prepare_enable(da7219_dai_bclk);
108 if (ret < 0) {
109 dev_err(rtd->dev, "can't enable master clock %d\n", ret);
110 return ret;
111 }
112
113 return ret;
114 }
115
116 static void da7219_clk_disable(void)
117 {
118 clk_disable_unprepare(da7219_dai_bclk);
119 }
120
121 static const unsigned int channels[] = {
122 DUAL_CHANNEL,
123 };
124
125 static const unsigned int rates[] = {
126 48000,
127 };
128
129 static const struct snd_pcm_hw_constraint_list constraints_rates = {
130 .count = ARRAY_SIZE(rates),
131 .list = rates,
132 .mask = 0,
133 };
134
135 static const struct snd_pcm_hw_constraint_list constraints_channels = {
136 .count = ARRAY_SIZE(channels),
137 .list = channels,
138 .mask = 0,
139 };
140
141 static int cz_da7219_play_startup(struct snd_pcm_substream *substream)
142 {
143 struct snd_pcm_runtime *runtime = substream->runtime;
144 struct snd_soc_pcm_runtime *rtd = substream->private_data;
145 struct snd_soc_card *card = rtd->card;
146 struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
147
148
149
150
151
152 runtime->hw.channels_max = DUAL_CHANNEL;
153 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
154 &constraints_channels);
155 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
156 &constraints_rates);
157
158 machine->play_i2s_instance = I2S_SP_INSTANCE;
159 return 0;
160 }
161
162 static int cz_da7219_cap_startup(struct snd_pcm_substream *substream)
163 {
164 struct snd_pcm_runtime *runtime = substream->runtime;
165 struct snd_soc_pcm_runtime *rtd = substream->private_data;
166 struct snd_soc_card *card = rtd->card;
167 struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
168
169
170
171
172
173 runtime->hw.channels_max = DUAL_CHANNEL;
174 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
175 &constraints_channels);
176 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
177 &constraints_rates);
178
179 machine->cap_i2s_instance = I2S_SP_INSTANCE;
180 machine->capture_channel = CAP_CHANNEL1;
181 return 0;
182 }
183
184 static int cz_max_startup(struct snd_pcm_substream *substream)
185 {
186 struct snd_pcm_runtime *runtime = substream->runtime;
187 struct snd_soc_pcm_runtime *rtd = substream->private_data;
188 struct snd_soc_card *card = rtd->card;
189 struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
190
191
192
193
194
195 runtime->hw.channels_max = DUAL_CHANNEL;
196 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
197 &constraints_channels);
198 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
199 &constraints_rates);
200
201 machine->play_i2s_instance = I2S_BT_INSTANCE;
202 return 0;
203 }
204
205 static int cz_dmic0_startup(struct snd_pcm_substream *substream)
206 {
207 struct snd_pcm_runtime *runtime = substream->runtime;
208 struct snd_soc_pcm_runtime *rtd = substream->private_data;
209 struct snd_soc_card *card = rtd->card;
210 struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
211
212
213
214
215
216 runtime->hw.channels_max = DUAL_CHANNEL;
217 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
218 &constraints_channels);
219 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
220 &constraints_rates);
221
222 machine->cap_i2s_instance = I2S_BT_INSTANCE;
223 return 0;
224 }
225
226 static int cz_dmic1_startup(struct snd_pcm_substream *substream)
227 {
228 struct snd_pcm_runtime *runtime = substream->runtime;
229 struct snd_soc_pcm_runtime *rtd = substream->private_data;
230 struct snd_soc_card *card = rtd->card;
231 struct acp_platform_info *machine = snd_soc_card_get_drvdata(card);
232
233
234
235
236
237 runtime->hw.channels_max = DUAL_CHANNEL;
238 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
239 &constraints_channels);
240 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
241 &constraints_rates);
242
243 machine->cap_i2s_instance = I2S_SP_INSTANCE;
244 machine->capture_channel = CAP_CHANNEL0;
245 return 0;
246 }
247
248 static int cz_da7219_params(struct snd_pcm_substream *substream,
249 struct snd_pcm_hw_params *params)
250 {
251 int wclk, bclk;
252
253 wclk = params_rate(params);
254 bclk = wclk * params_channels(params) *
255 snd_pcm_format_width(params_format(params));
256
257
258
259
260
261 if (bclk < (wclk * 64))
262 bclk = wclk * 64;
263 return da7219_clk_enable(substream, wclk, bclk);
264 }
265
266 static void cz_da7219_shutdown(struct snd_pcm_substream *substream)
267 {
268 da7219_clk_disable();
269 }
270
271 static const struct snd_soc_ops cz_da7219_play_ops = {
272 .startup = cz_da7219_play_startup,
273 .shutdown = cz_da7219_shutdown,
274 .hw_params = cz_da7219_params,
275 };
276
277 static const struct snd_soc_ops cz_da7219_cap_ops = {
278 .startup = cz_da7219_cap_startup,
279 .shutdown = cz_da7219_shutdown,
280 .hw_params = cz_da7219_params,
281 };
282
283 static const struct snd_soc_ops cz_max_play_ops = {
284 .startup = cz_max_startup,
285 .shutdown = cz_da7219_shutdown,
286 .hw_params = cz_da7219_params,
287 };
288
289 static const struct snd_soc_ops cz_dmic0_cap_ops = {
290 .startup = cz_dmic0_startup,
291 .shutdown = cz_da7219_shutdown,
292 .hw_params = cz_da7219_params,
293 };
294
295 static const struct snd_soc_ops cz_dmic1_cap_ops = {
296 .startup = cz_dmic1_startup,
297 .shutdown = cz_da7219_shutdown,
298 .hw_params = cz_da7219_params,
299 };
300
301 SND_SOC_DAILINK_DEF(designware1,
302 DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.1.auto")));
303 SND_SOC_DAILINK_DEF(designware2,
304 DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.2.auto")));
305 SND_SOC_DAILINK_DEF(designware3,
306 DAILINK_COMP_ARRAY(COMP_CPU("designware-i2s.3.auto")));
307
308 SND_SOC_DAILINK_DEF(dlgs,
309 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00", "da7219-hifi")));
310 SND_SOC_DAILINK_DEF(mx,
311 DAILINK_COMP_ARRAY(COMP_CODEC("MX98357A:00", "HiFi")));
312 SND_SOC_DAILINK_DEF(adau,
313 DAILINK_COMP_ARRAY(COMP_CODEC("ADAU7002:00", "adau7002-hifi")));
314
315 SND_SOC_DAILINK_DEF(platform,
316 DAILINK_COMP_ARRAY(COMP_PLATFORM("acp_audio_dma.0.auto")));
317
318 static struct snd_soc_dai_link cz_dai_7219_98357[] = {
319 {
320 .name = "amd-da7219-play",
321 .stream_name = "Playback",
322 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
323 | SND_SOC_DAIFMT_CBM_CFM,
324 .init = cz_da7219_init,
325 .dpcm_playback = 1,
326 .ops = &cz_da7219_play_ops,
327 SND_SOC_DAILINK_REG(designware1, dlgs, platform),
328 },
329 {
330 .name = "amd-da7219-cap",
331 .stream_name = "Capture",
332 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
333 | SND_SOC_DAIFMT_CBM_CFM,
334 .dpcm_capture = 1,
335 .ops = &cz_da7219_cap_ops,
336 SND_SOC_DAILINK_REG(designware2, dlgs, platform),
337 },
338 {
339 .name = "amd-max98357-play",
340 .stream_name = "HiFi Playback",
341 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
342 | SND_SOC_DAIFMT_CBM_CFM,
343 .dpcm_playback = 1,
344 .ops = &cz_max_play_ops,
345 SND_SOC_DAILINK_REG(designware3, mx, platform),
346 },
347 {
348
349 .name = "dmic0",
350 .stream_name = "DMIC0 Capture",
351 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
352 | SND_SOC_DAIFMT_CBM_CFM,
353 .dpcm_capture = 1,
354 .ops = &cz_dmic0_cap_ops,
355 SND_SOC_DAILINK_REG(designware3, adau, platform),
356 },
357 {
358
359 .name = "dmic1",
360 .stream_name = "DMIC1 Capture",
361 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
362 | SND_SOC_DAIFMT_CBM_CFM,
363 .dpcm_capture = 1,
364 .ops = &cz_dmic1_cap_ops,
365 SND_SOC_DAILINK_REG(designware2, adau, platform),
366 },
367 };
368
369 static const struct snd_soc_dapm_widget cz_widgets[] = {
370 SND_SOC_DAPM_HP("Headphones", NULL),
371 SND_SOC_DAPM_SPK("Speakers", NULL),
372 SND_SOC_DAPM_MIC("Headset Mic", NULL),
373 SND_SOC_DAPM_MIC("Int Mic", NULL),
374 };
375
376 static const struct snd_soc_dapm_route cz_audio_route[] = {
377 {"Headphones", NULL, "HPL"},
378 {"Headphones", NULL, "HPR"},
379 {"MIC", NULL, "Headset Mic"},
380 {"Speakers", NULL, "Speaker"},
381 {"PDM_DAT", NULL, "Int Mic"},
382 };
383
384 static const struct snd_kcontrol_new cz_mc_controls[] = {
385 SOC_DAPM_PIN_SWITCH("Headphones"),
386 SOC_DAPM_PIN_SWITCH("Speakers"),
387 SOC_DAPM_PIN_SWITCH("Headset Mic"),
388 SOC_DAPM_PIN_SWITCH("Int Mic"),
389 };
390
391 static struct snd_soc_card cz_card = {
392 .name = "acpd7219m98357",
393 .owner = THIS_MODULE,
394 .dai_link = cz_dai_7219_98357,
395 .num_links = ARRAY_SIZE(cz_dai_7219_98357),
396 .dapm_widgets = cz_widgets,
397 .num_dapm_widgets = ARRAY_SIZE(cz_widgets),
398 .dapm_routes = cz_audio_route,
399 .num_dapm_routes = ARRAY_SIZE(cz_audio_route),
400 .controls = cz_mc_controls,
401 .num_controls = ARRAY_SIZE(cz_mc_controls),
402 };
403
404 static struct regulator_consumer_supply acp_da7219_supplies[] = {
405 REGULATOR_SUPPLY("VDD", "i2c-DLGS7219:00"),
406 REGULATOR_SUPPLY("VDDMIC", "i2c-DLGS7219:00"),
407 REGULATOR_SUPPLY("VDDIO", "i2c-DLGS7219:00"),
408 REGULATOR_SUPPLY("IOVDD", "ADAU7002:00"),
409 };
410
411 static struct regulator_init_data acp_da7219_data = {
412 .constraints = {
413 .always_on = 1,
414 },
415 .num_consumer_supplies = ARRAY_SIZE(acp_da7219_supplies),
416 .consumer_supplies = acp_da7219_supplies,
417 };
418
419 static struct regulator_config acp_da7219_cfg = {
420 .init_data = &acp_da7219_data,
421 };
422
423 static struct regulator_ops acp_da7219_ops = {
424 };
425
426 static const struct regulator_desc acp_da7219_desc = {
427 .name = "reg-fixed-1.8V",
428 .type = REGULATOR_VOLTAGE,
429 .owner = THIS_MODULE,
430 .ops = &acp_da7219_ops,
431 .fixed_uV = 1800000,
432 .n_voltages = 1,
433 };
434
435 static int cz_probe(struct platform_device *pdev)
436 {
437 int ret;
438 struct snd_soc_card *card;
439 struct acp_platform_info *machine;
440 struct regulator_dev *rdev;
441
442 acp_da7219_cfg.dev = &pdev->dev;
443 rdev = devm_regulator_register(&pdev->dev, &acp_da7219_desc,
444 &acp_da7219_cfg);
445 if (IS_ERR(rdev)) {
446 dev_err(&pdev->dev, "Failed to register regulator: %d\n",
447 (int)PTR_ERR(rdev));
448 return -EINVAL;
449 }
450
451 machine = devm_kzalloc(&pdev->dev, sizeof(struct acp_platform_info),
452 GFP_KERNEL);
453 if (!machine)
454 return -ENOMEM;
455 card = &cz_card;
456 cz_card.dev = &pdev->dev;
457 platform_set_drvdata(pdev, card);
458 snd_soc_card_set_drvdata(card, machine);
459 ret = devm_snd_soc_register_card(&pdev->dev, &cz_card);
460 if (ret) {
461 dev_err(&pdev->dev,
462 "devm_snd_soc_register_card(%s) failed: %d\n",
463 cz_card.name, ret);
464 return ret;
465 }
466 bt_uart_enable = !device_property_read_bool(&pdev->dev,
467 "bt-pad-enable");
468 return 0;
469 }
470
471 static const struct acpi_device_id cz_audio_acpi_match[] = {
472 { "AMD7219", 0 },
473 {},
474 };
475 MODULE_DEVICE_TABLE(acpi, cz_audio_acpi_match);
476
477 static struct platform_driver cz_pcm_driver = {
478 .driver = {
479 .name = "cz-da7219-max98357a",
480 .acpi_match_table = ACPI_PTR(cz_audio_acpi_match),
481 .pm = &snd_soc_pm_ops,
482 },
483 .probe = cz_probe,
484 };
485
486 module_platform_driver(cz_pcm_driver);
487
488 MODULE_AUTHOR("akshu.agrawal@amd.com");
489 MODULE_DESCRIPTION("DA7219 & MAX98357A audio support");
490 MODULE_LICENSE("GPL v2");