1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Rockchip machine ASoC driver for boards using a MAX90809 CODEC.
4 *
5 * Copyright (c) 2014, ROCKCHIP CORPORATION. All rights reserved.
6 */
7
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/platform_device.h>
11 #include <linux/slab.h>
12 #include <sound/core.h>
13 #include <sound/jack.h>
14 #include <sound/pcm.h>
15 #include <sound/pcm_params.h>
16 #include <sound/soc.h>
17
18 #include "rockchip_i2s.h"
19 #include "../codecs/ts3a227e.h"
20
21 #define DRV_NAME "rockchip-snd-max98090"
22
23 static struct snd_soc_jack headset_jack;
24
25 /* Headset jack detection DAPM pins */
26 static struct snd_soc_jack_pin headset_jack_pins[] = {
27 {
28 .pin = "Headphone",
29 .mask = SND_JACK_HEADPHONE,
30 },
31 {
32 .pin = "Headset Mic",
33 .mask = SND_JACK_MICROPHONE,
34 },
35
36 };
37
38 #define RK_MAX98090_WIDGETS \
39 SND_SOC_DAPM_HP("Headphone", NULL), \
40 SND_SOC_DAPM_MIC("Headset Mic", NULL), \
41 SND_SOC_DAPM_MIC("Int Mic", NULL), \
42 SND_SOC_DAPM_SPK("Speaker", NULL)
43
44 #define RK_HDMI_WIDGETS \
45 SND_SOC_DAPM_LINE("HDMI", NULL)
46
47 static const struct snd_soc_dapm_widget rk_max98090_dapm_widgets[] = {
48 RK_MAX98090_WIDGETS,
49 };
50
51 static const struct snd_soc_dapm_widget rk_hdmi_dapm_widgets[] = {
52 RK_HDMI_WIDGETS,
53 };
54
55 static const struct snd_soc_dapm_widget rk_max98090_hdmi_dapm_widgets[] = {
56 RK_MAX98090_WIDGETS,
57 RK_HDMI_WIDGETS,
58 };
59
60 #define RK_MAX98090_AUDIO_MAP \
61 {"IN34", NULL, "Headset Mic"}, \
62 {"Headset Mic", NULL, "MICBIAS"}, \
63 {"DMICL", NULL, "Int Mic"}, \
64 {"Headphone", NULL, "HPL"}, \
65 {"Headphone", NULL, "HPR"}, \
66 {"Speaker", NULL, "SPKL"}, \
67 {"Speaker", NULL, "SPKR"}
68
69 #define RK_HDMI_AUDIO_MAP \
70 {"HDMI", NULL, "TX"}
71
72 static const struct snd_soc_dapm_route rk_max98090_audio_map[] = {
73 RK_MAX98090_AUDIO_MAP,
74 };
75
76 static const struct snd_soc_dapm_route rk_hdmi_audio_map[] = {
77 RK_HDMI_AUDIO_MAP,
78 };
79
80 static const struct snd_soc_dapm_route rk_max98090_hdmi_audio_map[] = {
81 RK_MAX98090_AUDIO_MAP,
82 RK_HDMI_AUDIO_MAP,
83 };
84
85 #define RK_MAX98090_CONTROLS \
86 SOC_DAPM_PIN_SWITCH("Headphone"), \
87 SOC_DAPM_PIN_SWITCH("Headset Mic"), \
88 SOC_DAPM_PIN_SWITCH("Int Mic"), \
89 SOC_DAPM_PIN_SWITCH("Speaker")
90
91 #define RK_HDMI_CONTROLS \
92 SOC_DAPM_PIN_SWITCH("HDMI")
93
94 static const struct snd_kcontrol_new rk_max98090_controls[] = {
95 RK_MAX98090_CONTROLS,
96 };
97
98 static const struct snd_kcontrol_new rk_hdmi_controls[] = {
99 RK_HDMI_CONTROLS,
100 };
101
102 static const struct snd_kcontrol_new rk_max98090_hdmi_controls[] = {
103 RK_MAX98090_CONTROLS,
104 RK_HDMI_CONTROLS,
105 };
106
rk_jack_event(struct notifier_block * nb,unsigned long event,void * data)107 static int rk_jack_event(struct notifier_block *nb, unsigned long event,
108 void *data)
109 {
110 struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
111 struct snd_soc_dapm_context *dapm = &jack->card->dapm;
112
113 if (event & SND_JACK_MICROPHONE) {
114 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
115 snd_soc_dapm_force_enable_pin(dapm, "SHDN");
116 } else {
117 snd_soc_dapm_disable_pin(dapm, "MICBIAS");
118 snd_soc_dapm_disable_pin(dapm, "SHDN");
119 }
120
121 snd_soc_dapm_sync(dapm);
122
123 return 0;
124 }
125
126 static struct notifier_block rk_jack_nb = {
127 .notifier_call = rk_jack_event,
128 };
129
rk_init(struct snd_soc_pcm_runtime * runtime)130 static int rk_init(struct snd_soc_pcm_runtime *runtime)
131 {
132 /*
133 * The jack has already been created in the rk_98090_headset_init()
134 * function.
135 */
136 snd_soc_jack_notifier_register(&headset_jack, &rk_jack_nb);
137
138 return 0;
139 }
140
rk_aif1_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)141 static int rk_aif1_hw_params(struct snd_pcm_substream *substream,
142 struct snd_pcm_hw_params *params)
143 {
144 int ret = 0;
145 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
146 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
147 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
148 int mclk;
149
150 switch (params_rate(params)) {
151 case 8000:
152 case 16000:
153 case 24000:
154 case 32000:
155 case 48000:
156 case 64000:
157 case 96000:
158 mclk = 12288000;
159 break;
160 case 11025:
161 case 22050:
162 case 44100:
163 case 88200:
164 mclk = 11289600;
165 break;
166 default:
167 return -EINVAL;
168 }
169
170 ret = snd_soc_dai_set_sysclk(cpu_dai, 0, mclk,
171 SND_SOC_CLOCK_OUT);
172 if (ret) {
173 dev_err(cpu_dai->dev, "Can't set cpu dai clock %d\n", ret);
174 return ret;
175 }
176
177 ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
178 SND_SOC_CLOCK_IN);
179
180 /* HDMI codec dai does not need to set sysclk. */
181 if (!strcmp(rtd->dai_link->name, "HDMI"))
182 return 0;
183
184 if (ret) {
185 dev_err(codec_dai->dev, "Can't set codec dai clock %d\n", ret);
186 return ret;
187 }
188
189 return ret;
190 }
191
rk_aif1_startup(struct snd_pcm_substream * substream)192 static int rk_aif1_startup(struct snd_pcm_substream *substream)
193 {
194 /*
195 * Set period size to 240 because pl330 has issue
196 * dealing with larger period in stress testing.
197 */
198 return snd_pcm_hw_constraint_minmax(substream->runtime,
199 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 240, 240);
200 }
201
202 static const struct snd_soc_ops rk_aif1_ops = {
203 .hw_params = rk_aif1_hw_params,
204 .startup = rk_aif1_startup,
205 };
206
207 SND_SOC_DAILINK_DEFS(analog,
208 DAILINK_COMP_ARRAY(COMP_EMPTY()),
209 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "HiFi")),
210 DAILINK_COMP_ARRAY(COMP_EMPTY()));
211
212 SND_SOC_DAILINK_DEFS(hdmi,
213 DAILINK_COMP_ARRAY(COMP_EMPTY()),
214 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "i2s-hifi")),
215 DAILINK_COMP_ARRAY(COMP_EMPTY()));
216
217 enum {
218 DAILINK_MAX98090,
219 DAILINK_HDMI,
220 };
221
222 static struct snd_soc_jack rk_hdmi_jack;
223
rk_hdmi_init(struct snd_soc_pcm_runtime * runtime)224 static int rk_hdmi_init(struct snd_soc_pcm_runtime *runtime)
225 {
226 struct snd_soc_card *card = runtime->card;
227 struct snd_soc_component *component = snd_soc_rtd_to_codec(runtime, 0)->component;
228 int ret;
229
230 /* enable jack detection */
231 ret = snd_soc_card_jack_new(card, "HDMI Jack", SND_JACK_LINEOUT,
232 &rk_hdmi_jack);
233 if (ret) {
234 dev_err(card->dev, "Can't new HDMI Jack %d\n", ret);
235 return ret;
236 }
237
238 return snd_soc_component_set_jack(component, &rk_hdmi_jack, NULL);
239 }
240
241 /* max98090 dai_link */
242 static struct snd_soc_dai_link rk_max98090_dailinks[] = {
243 {
244 .name = "max98090",
245 .stream_name = "Analog",
246 .init = rk_init,
247 .ops = &rk_aif1_ops,
248 /* set max98090 as slave */
249 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
250 SND_SOC_DAIFMT_CBS_CFS,
251 SND_SOC_DAILINK_REG(analog),
252 },
253 };
254
255 /* HDMI codec dai_link */
256 static struct snd_soc_dai_link rk_hdmi_dailinks[] = {
257 {
258 .name = "HDMI",
259 .stream_name = "HDMI",
260 .init = rk_hdmi_init,
261 .ops = &rk_aif1_ops,
262 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
263 SND_SOC_DAIFMT_CBS_CFS,
264 SND_SOC_DAILINK_REG(hdmi),
265 }
266 };
267
268 /* max98090 and HDMI codec dai_link */
269 static struct snd_soc_dai_link rk_max98090_hdmi_dailinks[] = {
270 [DAILINK_MAX98090] = {
271 .name = "max98090",
272 .stream_name = "Analog",
273 .init = rk_init,
274 .ops = &rk_aif1_ops,
275 /* set max98090 as slave */
276 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
277 SND_SOC_DAIFMT_CBS_CFS,
278 SND_SOC_DAILINK_REG(analog),
279 },
280 [DAILINK_HDMI] = {
281 .name = "HDMI",
282 .stream_name = "HDMI",
283 .init = rk_hdmi_init,
284 .ops = &rk_aif1_ops,
285 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
286 SND_SOC_DAIFMT_CBS_CFS,
287 SND_SOC_DAILINK_REG(hdmi),
288 }
289 };
290
291 static int rk_98090_headset_init(struct snd_soc_component *component);
292
293 static struct snd_soc_aux_dev rk_98090_headset_dev = {
294 .dlc = COMP_EMPTY(),
295 .init = rk_98090_headset_init,
296 };
297
298 static struct snd_soc_card rockchip_max98090_card = {
299 .name = "ROCKCHIP-I2S",
300 .owner = THIS_MODULE,
301 .dai_link = rk_max98090_dailinks,
302 .num_links = ARRAY_SIZE(rk_max98090_dailinks),
303 .aux_dev = &rk_98090_headset_dev,
304 .num_aux_devs = 1,
305 .dapm_widgets = rk_max98090_dapm_widgets,
306 .num_dapm_widgets = ARRAY_SIZE(rk_max98090_dapm_widgets),
307 .dapm_routes = rk_max98090_audio_map,
308 .num_dapm_routes = ARRAY_SIZE(rk_max98090_audio_map),
309 .controls = rk_max98090_controls,
310 .num_controls = ARRAY_SIZE(rk_max98090_controls),
311 };
312
313 static struct snd_soc_card rockchip_hdmi_card = {
314 .name = "ROCKCHIP-HDMI",
315 .owner = THIS_MODULE,
316 .dai_link = rk_hdmi_dailinks,
317 .num_links = ARRAY_SIZE(rk_hdmi_dailinks),
318 .dapm_widgets = rk_hdmi_dapm_widgets,
319 .num_dapm_widgets = ARRAY_SIZE(rk_hdmi_dapm_widgets),
320 .dapm_routes = rk_hdmi_audio_map,
321 .num_dapm_routes = ARRAY_SIZE(rk_hdmi_audio_map),
322 .controls = rk_hdmi_controls,
323 .num_controls = ARRAY_SIZE(rk_hdmi_controls),
324 };
325
326 static struct snd_soc_card rockchip_max98090_hdmi_card = {
327 .name = "ROCKCHIP-MAX98090-HDMI",
328 .owner = THIS_MODULE,
329 .dai_link = rk_max98090_hdmi_dailinks,
330 .num_links = ARRAY_SIZE(rk_max98090_hdmi_dailinks),
331 .aux_dev = &rk_98090_headset_dev,
332 .num_aux_devs = 1,
333 .dapm_widgets = rk_max98090_hdmi_dapm_widgets,
334 .num_dapm_widgets = ARRAY_SIZE(rk_max98090_hdmi_dapm_widgets),
335 .dapm_routes = rk_max98090_hdmi_audio_map,
336 .num_dapm_routes = ARRAY_SIZE(rk_max98090_hdmi_audio_map),
337 .controls = rk_max98090_hdmi_controls,
338 .num_controls = ARRAY_SIZE(rk_max98090_hdmi_controls),
339 };
340
rk_98090_headset_init(struct snd_soc_component * component)341 static int rk_98090_headset_init(struct snd_soc_component *component)
342 {
343 int ret;
344
345 /* Enable Headset and 4 Buttons Jack detection */
346 ret = snd_soc_card_jack_new_pins(component->card, "Headset Jack",
347 SND_JACK_HEADSET |
348 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
349 SND_JACK_BTN_2 | SND_JACK_BTN_3,
350 &headset_jack,
351 headset_jack_pins,
352 ARRAY_SIZE(headset_jack_pins));
353 if (ret)
354 return ret;
355
356 ret = ts3a227e_enable_jack_detect(component, &headset_jack);
357
358 return ret;
359 }
360
rk_parse_headset_from_of(struct device * dev,struct device_node * np)361 static int rk_parse_headset_from_of(struct device *dev, struct device_node *np)
362 {
363 rk_98090_headset_dev.dlc.of_node = of_parse_phandle(
364 np, "rockchip,headset-codec", 0);
365 if (!rk_98090_headset_dev.dlc.of_node) {
366 dev_err(dev,
367 "Property 'rockchip,headset-codec' missing/invalid\n");
368 return -EINVAL;
369 }
370 return 0;
371 }
372
snd_rk_mc_probe(struct platform_device * pdev)373 static int snd_rk_mc_probe(struct platform_device *pdev)
374 {
375 int ret = 0;
376 struct snd_soc_card *card;
377 struct device *dev = &pdev->dev;
378 struct device_node *np = pdev->dev.of_node;
379 struct device_node *np_cpu;
380 struct device_node *np_audio, *np_hdmi;
381
382 /* Parse DTS for I2S controller. */
383 np_cpu = of_parse_phandle(np, "rockchip,i2s-controller", 0);
384
385 if (!np_cpu) {
386 dev_err(&pdev->dev,
387 "Property 'rockchip,i2s-controller missing or invalid\n");
388 return -EINVAL;
389 }
390
391 /*
392 * Find the card to use based on the presences of audio codec
393 * and hdmi codec in device property. Set their of_node accordingly.
394 */
395 np_audio = of_parse_phandle(np, "rockchip,audio-codec", 0);
396 np_hdmi = of_parse_phandle(np, "rockchip,hdmi-codec", 0);
397 if (np_audio && np_hdmi) {
398 card = &rockchip_max98090_hdmi_card;
399 card->dai_link[DAILINK_MAX98090].codecs->of_node = np_audio;
400 card->dai_link[DAILINK_HDMI].codecs->of_node = np_hdmi;
401 card->dai_link[DAILINK_MAX98090].cpus->of_node = np_cpu;
402 card->dai_link[DAILINK_MAX98090].platforms->of_node = np_cpu;
403 card->dai_link[DAILINK_HDMI].cpus->of_node = np_cpu;
404 card->dai_link[DAILINK_HDMI].platforms->of_node = np_cpu;
405 } else if (np_audio) {
406 card = &rockchip_max98090_card;
407 card->dai_link[0].codecs->of_node = np_audio;
408 card->dai_link[0].cpus->of_node = np_cpu;
409 card->dai_link[0].platforms->of_node = np_cpu;
410 } else if (np_hdmi) {
411 card = &rockchip_hdmi_card;
412 card->dai_link[0].codecs->of_node = np_hdmi;
413 card->dai_link[0].cpus->of_node = np_cpu;
414 card->dai_link[0].platforms->of_node = np_cpu;
415 } else {
416 dev_err(dev, "At least one of codecs should be specified\n");
417 return -EINVAL;
418 }
419
420 card->dev = dev;
421
422 /* Parse headset detection codec. */
423 if (np_audio) {
424 ret = rk_parse_headset_from_of(dev, np);
425 if (ret)
426 return ret;
427 }
428
429 /* Parse card name. */
430 ret = snd_soc_of_parse_card_name(card, "rockchip,model");
431 if (ret) {
432 dev_err(&pdev->dev,
433 "Soc parse card name failed %d\n", ret);
434 return ret;
435 }
436
437 /* register the soc card */
438 ret = devm_snd_soc_register_card(&pdev->dev, card);
439 if (ret) {
440 dev_err(&pdev->dev,
441 "Soc register card failed %d\n", ret);
442 return ret;
443 }
444
445 return ret;
446 }
447
448 static const struct of_device_id rockchip_max98090_of_match[] = {
449 { .compatible = "rockchip,rockchip-audio-max98090", },
450 {},
451 };
452
453 MODULE_DEVICE_TABLE(of, rockchip_max98090_of_match);
454
455 static struct platform_driver snd_rk_mc_driver = {
456 .probe = snd_rk_mc_probe,
457 .driver = {
458 .name = DRV_NAME,
459 .pm = &snd_soc_pm_ops,
460 .of_match_table = rockchip_max98090_of_match,
461 },
462 };
463
464 module_platform_driver(snd_rk_mc_driver);
465
466 MODULE_AUTHOR("jianqun <jay.xu@rock-chips.com>");
467 MODULE_DESCRIPTION("Rockchip max98090 machine ASoC driver");
468 MODULE_LICENSE("GPL v2");
469 MODULE_ALIAS("platform:" DRV_NAME);
470