1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * tegra_asoc_machine.c - Universal ASoC machine driver for NVIDIA Tegra boards.
4  */
5 
6 #include <linux/clk.h>
7 #include <linux/export.h>
8 #include <linux/gpio/consumer.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_device.h>
12 #include <linux/platform_device.h>
13 #include <linux/slab.h>
14 
15 #include <sound/core.h>
16 #include <sound/jack.h>
17 #include <sound/pcm.h>
18 #include <sound/pcm_params.h>
19 #include <sound/soc.h>
20 
21 #include "tegra_asoc_machine.h"
22 
23 /* Headphones Jack */
24 
25 static struct snd_soc_jack tegra_machine_hp_jack;
26 
27 static struct snd_soc_jack_pin tegra_machine_hp_jack_pins[] = {
28 	{ .pin = "Headphone",  .mask = SND_JACK_HEADPHONE },
29 	{ .pin = "Headphones", .mask = SND_JACK_HEADPHONE },
30 };
31 
32 static struct snd_soc_jack_gpio tegra_machine_hp_jack_gpio = {
33 	.name = "Headphones detection",
34 	.report = SND_JACK_HEADPHONE,
35 	.debounce_time = 150,
36 };
37 
38 /* Headset Jack */
39 
40 static struct snd_soc_jack tegra_machine_headset_jack;
41 
42 static struct snd_soc_jack_pin tegra_machine_headset_jack_pins[] = {
43 	{ .pin = "Headset Mic", .mask = SND_JACK_MICROPHONE },
44 	{ .pin = "Headset Stereophone", .mask = SND_JACK_HEADPHONE },
45 };
46 
47 static struct snd_soc_jack_gpio tegra_machine_headset_jack_gpio = {
48 	.name = "Headset detection",
49 	.report = SND_JACK_HEADSET,
50 	.debounce_time = 150,
51 };
52 
53 /* Mic Jack */
54 static int coupled_mic_hp_check(void *data)
55 {
56 	struct tegra_machine *machine = (struct tegra_machine *)data;
57 
58 	/* Detect mic insertion only if 3.5 jack is in */
59 	if (gpiod_get_value_cansleep(machine->gpiod_hp_det) &&
60 	    gpiod_get_value_cansleep(machine->gpiod_mic_det))
61 		return SND_JACK_MICROPHONE;
62 
63 	return 0;
64 }
65 
66 static struct snd_soc_jack tegra_machine_mic_jack;
67 
68 static struct snd_soc_jack_pin tegra_machine_mic_jack_pins[] = {
69 	{ .pin = "Mic Jack",    .mask = SND_JACK_MICROPHONE },
70 	{ .pin = "Headset Mic", .mask = SND_JACK_MICROPHONE },
71 };
72 
73 static struct snd_soc_jack_gpio tegra_machine_mic_jack_gpio = {
74 	.name = "Mic detection",
75 	.report = SND_JACK_MICROPHONE,
76 	.debounce_time = 150,
77 };
78 
79 static int tegra_machine_event(struct snd_soc_dapm_widget *w,
80 			       struct snd_kcontrol *k, int event)
81 {
82 	struct snd_soc_dapm_context *dapm = w->dapm;
83 	struct tegra_machine *machine = snd_soc_card_get_drvdata(dapm->card);
84 
85 	if (!strcmp(w->name, "Int Spk") || !strcmp(w->name, "Speakers"))
86 		gpiod_set_value_cansleep(machine->gpiod_spkr_en,
87 					 SND_SOC_DAPM_EVENT_ON(event));
88 
89 	if (!strcmp(w->name, "Mic Jack") || !strcmp(w->name, "Headset Mic"))
90 		gpiod_set_value_cansleep(machine->gpiod_ext_mic_en,
91 					 SND_SOC_DAPM_EVENT_ON(event));
92 
93 	if (!strcmp(w->name, "Int Mic") || !strcmp(w->name, "Internal Mic 2"))
94 		gpiod_set_value_cansleep(machine->gpiod_int_mic_en,
95 					 SND_SOC_DAPM_EVENT_ON(event));
96 
97 	if (!strcmp(w->name, "Headphone") || !strcmp(w->name, "Headphone Jack"))
98 		gpiod_set_value_cansleep(machine->gpiod_hp_mute,
99 					 !SND_SOC_DAPM_EVENT_ON(event));
100 
101 	return 0;
102 }
103 
104 static const struct snd_soc_dapm_widget tegra_machine_dapm_widgets[] = {
105 	SND_SOC_DAPM_HP("Headphone Jack", tegra_machine_event),
106 	SND_SOC_DAPM_HP("Headphone", tegra_machine_event),
107 	SND_SOC_DAPM_HP("Headset Stereophone", NULL),
108 	SND_SOC_DAPM_HP("Headphones", NULL),
109 	SND_SOC_DAPM_SPK("Speakers", tegra_machine_event),
110 	SND_SOC_DAPM_SPK("Int Spk", tegra_machine_event),
111 	SND_SOC_DAPM_SPK("Earpiece", NULL),
112 	SND_SOC_DAPM_MIC("Int Mic", tegra_machine_event),
113 	SND_SOC_DAPM_MIC("Mic Jack", tegra_machine_event),
114 	SND_SOC_DAPM_MIC("Internal Mic 1", NULL),
115 	SND_SOC_DAPM_MIC("Internal Mic 2", tegra_machine_event),
116 	SND_SOC_DAPM_MIC("Headset Mic", tegra_machine_event),
117 	SND_SOC_DAPM_MIC("Digital Mic", NULL),
118 	SND_SOC_DAPM_MIC("Mic", NULL),
119 	SND_SOC_DAPM_LINE("Line In Jack", NULL),
120 	SND_SOC_DAPM_LINE("Line In", NULL),
121 	SND_SOC_DAPM_LINE("LineIn", NULL),
122 };
123 
124 static const struct snd_kcontrol_new tegra_machine_controls[] = {
125 	SOC_DAPM_PIN_SWITCH("Speakers"),
126 	SOC_DAPM_PIN_SWITCH("Int Spk"),
127 	SOC_DAPM_PIN_SWITCH("Earpiece"),
128 	SOC_DAPM_PIN_SWITCH("Int Mic"),
129 	SOC_DAPM_PIN_SWITCH("Headset Mic"),
130 	SOC_DAPM_PIN_SWITCH("Internal Mic 1"),
131 	SOC_DAPM_PIN_SWITCH("Internal Mic 2"),
132 	SOC_DAPM_PIN_SWITCH("Headphones"),
133 	SOC_DAPM_PIN_SWITCH("Mic Jack"),
134 };
135 
136 int tegra_asoc_machine_init(struct snd_soc_pcm_runtime *rtd)
137 {
138 	struct snd_soc_card *card = rtd->card;
139 	struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
140 	const char *jack_name;
141 	int err;
142 
143 	if (machine->gpiod_hp_det && machine->asoc->add_hp_jack) {
144 		if (machine->asoc->hp_jack_name)
145 			jack_name = machine->asoc->hp_jack_name;
146 		else
147 			jack_name = "Headphones Jack";
148 
149 		err = snd_soc_card_jack_new_pins(card, jack_name,
150 						 SND_JACK_HEADPHONE,
151 						 &tegra_machine_hp_jack,
152 						 tegra_machine_hp_jack_pins,
153 						 ARRAY_SIZE(tegra_machine_hp_jack_pins));
154 		if (err) {
155 			dev_err(rtd->dev,
156 				"Headphones Jack creation failed: %d\n", err);
157 			return err;
158 		}
159 
160 		tegra_machine_hp_jack_gpio.desc = machine->gpiod_hp_det;
161 
162 		err = snd_soc_jack_add_gpios(&tegra_machine_hp_jack, 1,
163 					     &tegra_machine_hp_jack_gpio);
164 		if (err)
165 			dev_err(rtd->dev, "HP GPIOs not added: %d\n", err);
166 	}
167 
168 	if (machine->gpiod_hp_det && machine->asoc->add_headset_jack) {
169 		err = snd_soc_card_jack_new_pins(card, "Headset Jack",
170 						 SND_JACK_HEADSET,
171 						 &tegra_machine_headset_jack,
172 						 tegra_machine_headset_jack_pins,
173 						 ARRAY_SIZE(tegra_machine_headset_jack_pins));
174 		if (err) {
175 			dev_err(rtd->dev,
176 				"Headset Jack creation failed: %d\n", err);
177 			return err;
178 		}
179 
180 		tegra_machine_headset_jack_gpio.desc = machine->gpiod_hp_det;
181 
182 		err = snd_soc_jack_add_gpios(&tegra_machine_headset_jack, 1,
183 					     &tegra_machine_headset_jack_gpio);
184 		if (err)
185 			dev_err(rtd->dev, "Headset GPIOs not added: %d\n", err);
186 	}
187 
188 	if (machine->gpiod_mic_det && machine->asoc->add_mic_jack) {
189 		err = snd_soc_card_jack_new_pins(rtd->card, "Mic Jack",
190 						 SND_JACK_MICROPHONE,
191 						 &tegra_machine_mic_jack,
192 						 tegra_machine_mic_jack_pins,
193 						 ARRAY_SIZE(tegra_machine_mic_jack_pins));
194 		if (err) {
195 			dev_err(rtd->dev, "Mic Jack creation failed: %d\n", err);
196 			return err;
197 		}
198 
199 		tegra_machine_mic_jack_gpio.data = machine;
200 		tegra_machine_mic_jack_gpio.desc = machine->gpiod_mic_det;
201 
202 		if (of_property_read_bool(card->dev->of_node,
203 					  "nvidia,coupled-mic-hp-det")) {
204 			tegra_machine_mic_jack_gpio.desc = machine->gpiod_hp_det;
205 			tegra_machine_mic_jack_gpio.jack_status_check = coupled_mic_hp_check;
206 		}
207 
208 		err = snd_soc_jack_add_gpios(&tegra_machine_mic_jack, 1,
209 					     &tegra_machine_mic_jack_gpio);
210 		if (err)
211 			dev_err(rtd->dev, "Mic GPIOs not added: %d\n", err);
212 	}
213 
214 	return 0;
215 }
216 EXPORT_SYMBOL_GPL(tegra_asoc_machine_init);
217 
218 static unsigned int tegra_machine_mclk_rate_128(unsigned int srate)
219 {
220 	return 128 * srate;
221 }
222 
223 static unsigned int tegra_machine_mclk_rate_256(unsigned int srate)
224 {
225 	return 256 * srate;
226 }
227 
228 static unsigned int tegra_machine_mclk_rate_512(unsigned int srate)
229 {
230 	return 512 * srate;
231 }
232 
233 static unsigned int tegra_machine_mclk_rate_12mhz(unsigned int srate)
234 {
235 	unsigned int mclk;
236 
237 	switch (srate) {
238 	case 8000:
239 	case 16000:
240 	case 24000:
241 	case 32000:
242 	case 48000:
243 	case 64000:
244 	case 96000:
245 		mclk = 12288000;
246 		break;
247 	case 11025:
248 	case 22050:
249 	case 44100:
250 	case 88200:
251 		mclk = 11289600;
252 		break;
253 	default:
254 		mclk = 12000000;
255 		break;
256 	}
257 
258 	return mclk;
259 }
260 
261 static unsigned int tegra_machine_mclk_rate_6mhz(unsigned int srate)
262 {
263 	unsigned int mclk;
264 
265 	switch (srate) {
266 	case 8000:
267 	case 16000:
268 	case 64000:
269 		mclk = 8192000;
270 		break;
271 	case 11025:
272 	case 22050:
273 	case 88200:
274 		mclk = 11289600;
275 		break;
276 	case 96000:
277 		mclk = 12288000;
278 		break;
279 	default:
280 		mclk = 256 * srate;
281 		break;
282 	}
283 
284 	return mclk;
285 }
286 
287 static int tegra_machine_hw_params(struct snd_pcm_substream *substream,
288 				   struct snd_pcm_hw_params *params)
289 {
290 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
291 	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
292 	struct snd_soc_card *card = rtd->card;
293 	struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
294 	unsigned int srate = params_rate(params);
295 	unsigned int mclk = machine->asoc->mclk_rate(srate);
296 	unsigned int clk_id = machine->asoc->mclk_id;
297 	unsigned int new_baseclock;
298 	int err;
299 
300 	switch (srate) {
301 	case 11025:
302 	case 22050:
303 	case 44100:
304 	case 88200:
305 		if (of_machine_is_compatible("nvidia,tegra20"))
306 			new_baseclock = 56448000;
307 		else if (of_machine_is_compatible("nvidia,tegra30"))
308 			new_baseclock = 564480000;
309 		else
310 			new_baseclock = 282240000;
311 		break;
312 	case 8000:
313 	case 16000:
314 	case 32000:
315 	case 48000:
316 	case 64000:
317 	case 96000:
318 		if (of_machine_is_compatible("nvidia,tegra20"))
319 			new_baseclock = 73728000;
320 		else if (of_machine_is_compatible("nvidia,tegra30"))
321 			new_baseclock = 552960000;
322 		else
323 			new_baseclock = 368640000;
324 		break;
325 	default:
326 		dev_err(card->dev, "Invalid sound rate: %u\n", srate);
327 		return -EINVAL;
328 	}
329 
330 	if (new_baseclock != machine->set_baseclock ||
331 	    mclk != machine->set_mclk) {
332 		machine->set_baseclock = 0;
333 		machine->set_mclk = 0;
334 
335 		clk_disable_unprepare(machine->clk_cdev1);
336 
337 		err = clk_set_rate(machine->clk_pll_a, new_baseclock);
338 		if (err) {
339 			dev_err(card->dev, "Can't set pll_a rate: %d\n", err);
340 			return err;
341 		}
342 
343 		err = clk_set_rate(machine->clk_pll_a_out0, mclk);
344 		if (err) {
345 			dev_err(card->dev, "Can't set pll_a_out0 rate: %d\n", err);
346 			return err;
347 		}
348 
349 		/* Don't set cdev1/extern1 rate; it's locked to pll_a_out0 */
350 
351 		err = clk_prepare_enable(machine->clk_cdev1);
352 		if (err) {
353 			dev_err(card->dev, "Can't enable cdev1: %d\n", err);
354 			return err;
355 		}
356 
357 		machine->set_baseclock = new_baseclock;
358 		machine->set_mclk = mclk;
359 	}
360 
361 	err = snd_soc_dai_set_sysclk(codec_dai, clk_id, mclk, SND_SOC_CLOCK_IN);
362 	if (err < 0) {
363 		dev_err(card->dev, "codec_dai clock not set: %d\n", err);
364 		return err;
365 	}
366 
367 	return 0;
368 }
369 
370 static const struct snd_soc_ops tegra_machine_snd_ops = {
371 	.hw_params = tegra_machine_hw_params,
372 };
373 
374 static void tegra_machine_node_release(void *of_node)
375 {
376 	of_node_put(of_node);
377 }
378 
379 static struct device_node *
380 tegra_machine_parse_phandle(struct device *dev, const char *name)
381 {
382 	struct device_node *np;
383 	int err;
384 
385 	np = of_parse_phandle(dev->of_node, name, 0);
386 	if (!np) {
387 		dev_err(dev, "Property '%s' missing or invalid\n", name);
388 		return ERR_PTR(-EINVAL);
389 	}
390 
391 	err = devm_add_action_or_reset(dev, tegra_machine_node_release, np);
392 	if (err)
393 		return ERR_PTR(err);
394 
395 	return np;
396 }
397 
398 static void tegra_machine_unregister_codec(void *pdev)
399 {
400 	platform_device_unregister(pdev);
401 }
402 
403 static int tegra_machine_register_codec(struct device *dev, const char *name)
404 {
405 	struct platform_device *pdev;
406 	int err;
407 
408 	if (!name)
409 		return 0;
410 
411 	pdev = platform_device_register_simple(name, -1, NULL, 0);
412 	if (IS_ERR(pdev))
413 		return PTR_ERR(pdev);
414 
415 	err = devm_add_action_or_reset(dev, tegra_machine_unregister_codec,
416 				       pdev);
417 	if (err)
418 		return err;
419 
420 	return 0;
421 }
422 
423 int tegra_asoc_machine_probe(struct platform_device *pdev)
424 {
425 	struct device_node *np_codec, *np_i2s, *np_ac97;
426 	const struct tegra_asoc_data *asoc;
427 	struct device *dev = &pdev->dev;
428 	struct tegra_machine *machine;
429 	struct snd_soc_card *card;
430 	struct gpio_desc *gpiod;
431 	int err;
432 
433 	machine = devm_kzalloc(dev, sizeof(*machine), GFP_KERNEL);
434 	if (!machine)
435 		return -ENOMEM;
436 
437 	asoc = of_device_get_match_data(dev);
438 	card = asoc->card;
439 	card->dev = dev;
440 
441 	machine->asoc = asoc;
442 	machine->mic_jack = &tegra_machine_mic_jack;
443 	machine->hp_jack_gpio = &tegra_machine_hp_jack_gpio;
444 	snd_soc_card_set_drvdata(card, machine);
445 
446 	gpiod = devm_gpiod_get_optional(dev, "nvidia,hp-mute", GPIOD_OUT_HIGH);
447 	machine->gpiod_hp_mute = gpiod;
448 	if (IS_ERR(gpiod))
449 		return PTR_ERR(gpiod);
450 
451 	gpiod = devm_gpiod_get_optional(dev, "nvidia,hp-det", GPIOD_IN);
452 	machine->gpiod_hp_det = gpiod;
453 	if (IS_ERR(gpiod))
454 		return PTR_ERR(gpiod);
455 
456 	gpiod = devm_gpiod_get_optional(dev, "nvidia,mic-det", GPIOD_IN);
457 	machine->gpiod_mic_det = gpiod;
458 	if (IS_ERR(gpiod))
459 		return PTR_ERR(gpiod);
460 
461 	gpiod = devm_gpiod_get_optional(dev, "nvidia,spkr-en", GPIOD_OUT_LOW);
462 	machine->gpiod_spkr_en = gpiod;
463 	if (IS_ERR(gpiod))
464 		return PTR_ERR(gpiod);
465 
466 	gpiod = devm_gpiod_get_optional(dev, "nvidia,int-mic-en", GPIOD_OUT_LOW);
467 	machine->gpiod_int_mic_en = gpiod;
468 	if (IS_ERR(gpiod))
469 		return PTR_ERR(gpiod);
470 
471 	gpiod = devm_gpiod_get_optional(dev, "nvidia,ext-mic-en", GPIOD_OUT_LOW);
472 	machine->gpiod_ext_mic_en = gpiod;
473 	if (IS_ERR(gpiod))
474 		return PTR_ERR(gpiod);
475 
476 	err = snd_soc_of_parse_card_name(card, "nvidia,model");
477 	if (err)
478 		return err;
479 
480 	if (!card->dapm_routes) {
481 		err = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");
482 		if (err)
483 			return err;
484 	}
485 
486 	if (asoc->set_ac97) {
487 		err = tegra_machine_register_codec(dev, asoc->codec_dev_name);
488 		if (err)
489 			return err;
490 
491 		np_ac97 = tegra_machine_parse_phandle(dev, "nvidia,ac97-controller");
492 		if (IS_ERR(np_ac97))
493 			return PTR_ERR(np_ac97);
494 
495 		card->dai_link->cpus->of_node = np_ac97;
496 		card->dai_link->platforms->of_node = np_ac97;
497 	} else {
498 		np_codec = tegra_machine_parse_phandle(dev, "nvidia,audio-codec");
499 		if (IS_ERR(np_codec))
500 			return PTR_ERR(np_codec);
501 
502 		np_i2s = tegra_machine_parse_phandle(dev, "nvidia,i2s-controller");
503 		if (IS_ERR(np_i2s))
504 			return PTR_ERR(np_i2s);
505 
506 		card->dai_link->cpus->of_node = np_i2s;
507 		card->dai_link->codecs->of_node = np_codec;
508 		card->dai_link->platforms->of_node = np_i2s;
509 	}
510 
511 	if (asoc->add_common_controls) {
512 		card->controls = tegra_machine_controls;
513 		card->num_controls = ARRAY_SIZE(tegra_machine_controls);
514 	}
515 
516 	if (asoc->add_common_dapm_widgets) {
517 		card->dapm_widgets = tegra_machine_dapm_widgets;
518 		card->num_dapm_widgets = ARRAY_SIZE(tegra_machine_dapm_widgets);
519 	}
520 
521 	if (asoc->add_common_snd_ops)
522 		card->dai_link->ops = &tegra_machine_snd_ops;
523 
524 	if (!card->owner)
525 		card->owner = THIS_MODULE;
526 	if (!card->driver_name)
527 		card->driver_name = "tegra";
528 
529 	machine->clk_pll_a = devm_clk_get(dev, "pll_a");
530 	if (IS_ERR(machine->clk_pll_a)) {
531 		dev_err(dev, "Can't retrieve clk pll_a\n");
532 		return PTR_ERR(machine->clk_pll_a);
533 	}
534 
535 	machine->clk_pll_a_out0 = devm_clk_get(dev, "pll_a_out0");
536 	if (IS_ERR(machine->clk_pll_a_out0)) {
537 		dev_err(dev, "Can't retrieve clk pll_a_out0\n");
538 		return PTR_ERR(machine->clk_pll_a_out0);
539 	}
540 
541 	machine->clk_cdev1 = devm_clk_get(dev, "mclk");
542 	if (IS_ERR(machine->clk_cdev1)) {
543 		dev_err(dev, "Can't retrieve clk cdev1\n");
544 		return PTR_ERR(machine->clk_cdev1);
545 	}
546 
547 	/*
548 	 * If clock parents are not set in DT, configure here to use clk_out_1
549 	 * as mclk and extern1 as parent for Tegra30 and higher.
550 	 */
551 	if (!of_property_present(dev->of_node, "assigned-clock-parents") &&
552 	    !of_machine_is_compatible("nvidia,tegra20")) {
553 		struct clk *clk_out_1, *clk_extern1;
554 
555 		dev_warn(dev, "Configuring clocks for a legacy device-tree\n");
556 		dev_warn(dev, "Please update DT to use assigned-clock-parents\n");
557 
558 		clk_extern1 = devm_clk_get(dev, "extern1");
559 		if (IS_ERR(clk_extern1)) {
560 			dev_err(dev, "Can't retrieve clk extern1\n");
561 			return PTR_ERR(clk_extern1);
562 		}
563 
564 		err = clk_set_parent(clk_extern1, machine->clk_pll_a_out0);
565 		if (err < 0) {
566 			dev_err(dev, "Set parent failed for clk extern1\n");
567 			return err;
568 		}
569 
570 		clk_out_1 = devm_clk_get(dev, "pmc_clk_out_1");
571 		if (IS_ERR(clk_out_1)) {
572 			dev_err(dev, "Can't retrieve pmc_clk_out_1\n");
573 			return PTR_ERR(clk_out_1);
574 		}
575 
576 		err = clk_set_parent(clk_out_1, clk_extern1);
577 		if (err < 0) {
578 			dev_err(dev, "Set parent failed for pmc_clk_out_1\n");
579 			return err;
580 		}
581 
582 		machine->clk_cdev1 = clk_out_1;
583 	}
584 
585 	if (asoc->set_ac97) {
586 		/*
587 		 * AC97 rate is fixed at 24.576MHz and is used for both the
588 		 * host controller and the external codec
589 		 */
590 		err = clk_set_rate(machine->clk_pll_a, 73728000);
591 		if (err) {
592 			dev_err(dev, "Can't set pll_a rate: %d\n", err);
593 			return err;
594 		}
595 
596 		err = clk_set_rate(machine->clk_pll_a_out0, 24576000);
597 		if (err) {
598 			dev_err(dev, "Can't set pll_a_out0 rate: %d\n", err);
599 			return err;
600 		}
601 
602 		machine->set_baseclock = 73728000;
603 		machine->set_mclk = 24576000;
604 	}
605 
606 	/*
607 	 * FIXME: There is some unknown dependency between audio MCLK disable
608 	 * and suspend-resume functionality on Tegra30, although audio MCLK is
609 	 * only needed for audio.
610 	 */
611 	err = clk_prepare_enable(machine->clk_cdev1);
612 	if (err) {
613 		dev_err(dev, "Can't enable cdev1: %d\n", err);
614 		return err;
615 	}
616 
617 	err = devm_snd_soc_register_card(dev, card);
618 	if (err)
619 		return err;
620 
621 	return 0;
622 }
623 EXPORT_SYMBOL_GPL(tegra_asoc_machine_probe);
624 
625 /* WM8753 machine */
626 
627 SND_SOC_DAILINK_DEFS(wm8753_hifi,
628 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
629 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm8753-hifi")),
630 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
631 
632 static struct snd_soc_dai_link tegra_wm8753_dai = {
633 	.name = "WM8753",
634 	.stream_name = "WM8753 PCM",
635 	.dai_fmt = SND_SOC_DAIFMT_I2S |
636 		   SND_SOC_DAIFMT_NB_NF |
637 		   SND_SOC_DAIFMT_CBS_CFS,
638 	SND_SOC_DAILINK_REG(wm8753_hifi),
639 };
640 
641 static struct snd_soc_card snd_soc_tegra_wm8753 = {
642 	.components = "codec:wm8753",
643 	.dai_link = &tegra_wm8753_dai,
644 	.num_links = 1,
645 	.fully_routed = true,
646 };
647 
648 static const struct tegra_asoc_data tegra_wm8753_data = {
649 	.mclk_rate = tegra_machine_mclk_rate_12mhz,
650 	.card = &snd_soc_tegra_wm8753,
651 	.add_common_dapm_widgets = true,
652 	.add_common_snd_ops = true,
653 };
654 
655 /* WM9712 machine */
656 
657 static int tegra_wm9712_init(struct snd_soc_pcm_runtime *rtd)
658 {
659 	return snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "Mic Bias");
660 }
661 
662 SND_SOC_DAILINK_DEFS(wm9712_hifi,
663 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
664 	DAILINK_COMP_ARRAY(COMP_CODEC("wm9712-codec", "wm9712-hifi")),
665 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
666 
667 static struct snd_soc_dai_link tegra_wm9712_dai = {
668 	.name = "AC97 HiFi",
669 	.stream_name = "AC97 HiFi",
670 	.init = tegra_wm9712_init,
671 	SND_SOC_DAILINK_REG(wm9712_hifi),
672 };
673 
674 static struct snd_soc_card snd_soc_tegra_wm9712 = {
675 	.components = "codec:wm9712",
676 	.dai_link = &tegra_wm9712_dai,
677 	.num_links = 1,
678 	.fully_routed = true,
679 };
680 
681 static const struct tegra_asoc_data tegra_wm9712_data = {
682 	.card = &snd_soc_tegra_wm9712,
683 	.add_common_dapm_widgets = true,
684 	.codec_dev_name = "wm9712-codec",
685 	.set_ac97 = true,
686 };
687 
688 /* MAX98090 machine */
689 
690 SND_SOC_DAILINK_DEFS(max98090_hifi,
691 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
692 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "HiFi")),
693 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
694 
695 static struct snd_soc_dai_link tegra_max98090_dai = {
696 	.name = "max98090",
697 	.stream_name = "max98090 PCM",
698 	.init = tegra_asoc_machine_init,
699 	.dai_fmt = SND_SOC_DAIFMT_I2S |
700 		   SND_SOC_DAIFMT_NB_NF |
701 		   SND_SOC_DAIFMT_CBS_CFS,
702 	SND_SOC_DAILINK_REG(max98090_hifi),
703 };
704 
705 static struct snd_soc_card snd_soc_tegra_max98090 = {
706 	.components = "codec:max98090",
707 	.dai_link = &tegra_max98090_dai,
708 	.num_links = 1,
709 	.fully_routed = true,
710 };
711 
712 static const struct tegra_asoc_data tegra_max98090_data = {
713 	.mclk_rate = tegra_machine_mclk_rate_12mhz,
714 	.card = &snd_soc_tegra_max98090,
715 	.hp_jack_name = "Headphones",
716 	.add_common_dapm_widgets = true,
717 	.add_common_controls = true,
718 	.add_common_snd_ops = true,
719 	.add_mic_jack = true,
720 	.add_hp_jack = true,
721 };
722 
723 /* MAX98088 machine */
724 
725 SND_SOC_DAILINK_DEFS(max98088_hifi,
726 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
727 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "HiFi")),
728 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
729 
730 static struct snd_soc_dai_link tegra_max98088_dai = {
731 	.name = "MAX98088",
732 	.stream_name = "MAX98088 PCM",
733 	.init = tegra_asoc_machine_init,
734 	.dai_fmt = SND_SOC_DAIFMT_I2S |
735 		   SND_SOC_DAIFMT_NB_NF |
736 		   SND_SOC_DAIFMT_CBS_CFS,
737 	SND_SOC_DAILINK_REG(max98088_hifi),
738 };
739 
740 static struct snd_soc_card snd_soc_tegra_max98088 = {
741 	.components = "codec:max98088",
742 	.dai_link = &tegra_max98088_dai,
743 	.num_links = 1,
744 	.fully_routed = true,
745 };
746 
747 static const struct tegra_asoc_data tegra_max98088_data = {
748 	.mclk_rate = tegra_machine_mclk_rate_12mhz,
749 	.card = &snd_soc_tegra_max98088,
750 	.add_common_dapm_widgets = true,
751 	.add_common_controls = true,
752 	.add_common_snd_ops = true,
753 	.add_mic_jack = true,
754 	.add_hp_jack = true,
755 };
756 
757 /* SGTL5000 machine */
758 
759 SND_SOC_DAILINK_DEFS(sgtl5000_hifi,
760 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
761 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "sgtl5000")),
762 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
763 
764 static struct snd_soc_dai_link tegra_sgtl5000_dai = {
765 	.name = "sgtl5000",
766 	.stream_name = "HiFi",
767 	.dai_fmt = SND_SOC_DAIFMT_I2S |
768 		   SND_SOC_DAIFMT_NB_NF |
769 		   SND_SOC_DAIFMT_CBS_CFS,
770 	SND_SOC_DAILINK_REG(sgtl5000_hifi),
771 };
772 
773 static struct snd_soc_card snd_soc_tegra_sgtl5000 = {
774 	.components = "codec:sgtl5000",
775 	.dai_link = &tegra_sgtl5000_dai,
776 	.num_links = 1,
777 	.fully_routed = true,
778 };
779 
780 static const struct tegra_asoc_data tegra_sgtl5000_data = {
781 	.mclk_rate = tegra_machine_mclk_rate_12mhz,
782 	.card = &snd_soc_tegra_sgtl5000,
783 	.add_common_dapm_widgets = true,
784 	.add_common_snd_ops = true,
785 };
786 
787 /* TLV320AIC23 machine */
788 
789 static const struct snd_soc_dapm_widget trimslice_dapm_widgets[] = {
790 	SND_SOC_DAPM_HP("Line Out", NULL),
791 	SND_SOC_DAPM_LINE("Line In", NULL),
792 };
793 
794 static const struct snd_soc_dapm_route trimslice_audio_map[] = {
795 	{"Line Out", NULL, "LOUT"},
796 	{"Line Out", NULL, "ROUT"},
797 
798 	{"LLINEIN", NULL, "Line In"},
799 	{"RLINEIN", NULL, "Line In"},
800 };
801 
802 SND_SOC_DAILINK_DEFS(tlv320aic23_hifi,
803 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
804 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "tlv320aic23-hifi")),
805 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
806 
807 static struct snd_soc_dai_link tegra_tlv320aic23_dai = {
808 	.name = "TLV320AIC23",
809 	.stream_name = "AIC23",
810 	.dai_fmt = SND_SOC_DAIFMT_I2S |
811 		   SND_SOC_DAIFMT_NB_NF |
812 		   SND_SOC_DAIFMT_CBS_CFS,
813 	SND_SOC_DAILINK_REG(tlv320aic23_hifi),
814 };
815 
816 static struct snd_soc_card snd_soc_tegra_trimslice = {
817 	.name = "tegra-trimslice",
818 	.components = "codec:tlv320aic23",
819 	.dai_link = &tegra_tlv320aic23_dai,
820 	.num_links = 1,
821 	.dapm_widgets = trimslice_dapm_widgets,
822 	.num_dapm_widgets = ARRAY_SIZE(trimslice_dapm_widgets),
823 	.dapm_routes = trimslice_audio_map,
824 	.num_dapm_routes = ARRAY_SIZE(trimslice_audio_map),
825 	.fully_routed = true,
826 };
827 
828 static const struct tegra_asoc_data tegra_trimslice_data = {
829 	.mclk_rate = tegra_machine_mclk_rate_128,
830 	.card = &snd_soc_tegra_trimslice,
831 	.add_common_snd_ops = true,
832 };
833 
834 /* RT5677 machine */
835 
836 static int tegra_rt5677_init(struct snd_soc_pcm_runtime *rtd)
837 {
838 	struct snd_soc_card *card = rtd->card;
839 	int err;
840 
841 	err = tegra_asoc_machine_init(rtd);
842 	if (err)
843 		return err;
844 
845 	snd_soc_dapm_force_enable_pin(&card->dapm, "MICBIAS1");
846 
847 	return 0;
848 }
849 
850 SND_SOC_DAILINK_DEFS(rt5677_aif1,
851 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
852 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5677-aif1")),
853 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
854 
855 static struct snd_soc_dai_link tegra_rt5677_dai = {
856 	.name = "RT5677",
857 	.stream_name = "RT5677 PCM",
858 	.init = tegra_rt5677_init,
859 	.dai_fmt = SND_SOC_DAIFMT_I2S |
860 		   SND_SOC_DAIFMT_NB_NF |
861 		   SND_SOC_DAIFMT_CBS_CFS,
862 	SND_SOC_DAILINK_REG(rt5677_aif1),
863 };
864 
865 static struct snd_soc_card snd_soc_tegra_rt5677 = {
866 	.components = "codec:rt5677",
867 	.dai_link = &tegra_rt5677_dai,
868 	.num_links = 1,
869 	.fully_routed = true,
870 };
871 
872 static const struct tegra_asoc_data tegra_rt5677_data = {
873 	.mclk_rate = tegra_machine_mclk_rate_256,
874 	.card = &snd_soc_tegra_rt5677,
875 	.add_common_dapm_widgets = true,
876 	.add_common_controls = true,
877 	.add_common_snd_ops = true,
878 	.add_mic_jack = true,
879 	.add_hp_jack = true,
880 };
881 
882 /* RT5640 machine */
883 
884 SND_SOC_DAILINK_DEFS(rt5640_aif1,
885 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
886 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5640-aif1")),
887 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
888 
889 static struct snd_soc_dai_link tegra_rt5640_dai = {
890 	.name = "RT5640",
891 	.stream_name = "RT5640 PCM",
892 	.init = tegra_asoc_machine_init,
893 	.dai_fmt = SND_SOC_DAIFMT_I2S |
894 		   SND_SOC_DAIFMT_NB_NF |
895 		   SND_SOC_DAIFMT_CBS_CFS,
896 	SND_SOC_DAILINK_REG(rt5640_aif1),
897 };
898 
899 static struct snd_soc_card snd_soc_tegra_rt5640 = {
900 	.components = "codec:rt5640",
901 	.dai_link = &tegra_rt5640_dai,
902 	.num_links = 1,
903 	.fully_routed = true,
904 };
905 
906 static const struct tegra_asoc_data tegra_rt5640_data = {
907 	.mclk_rate = tegra_machine_mclk_rate_256,
908 	.card = &snd_soc_tegra_rt5640,
909 	.add_common_dapm_widgets = true,
910 	.add_common_controls = true,
911 	.add_common_snd_ops = true,
912 	.add_hp_jack = true,
913 };
914 
915 /* RT5632 machine */
916 
917 SND_SOC_DAILINK_DEFS(rt5632_hifi,
918 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
919 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "alc5632-hifi")),
920 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
921 
922 static struct snd_soc_dai_link tegra_rt5632_dai = {
923 	.name = "ALC5632",
924 	.stream_name = "ALC5632 PCM",
925 	.init = tegra_rt5677_init,
926 	.dai_fmt = SND_SOC_DAIFMT_I2S |
927 		   SND_SOC_DAIFMT_NB_NF |
928 		   SND_SOC_DAIFMT_CBS_CFS,
929 	SND_SOC_DAILINK_REG(rt5632_hifi),
930 };
931 
932 static struct snd_soc_card snd_soc_tegra_rt5632 = {
933 	.components = "codec:rt5632",
934 	.dai_link = &tegra_rt5632_dai,
935 	.num_links = 1,
936 	.fully_routed = true,
937 };
938 
939 static const struct tegra_asoc_data tegra_rt5632_data = {
940 	.mclk_rate = tegra_machine_mclk_rate_512,
941 	.card = &snd_soc_tegra_rt5632,
942 	.add_common_dapm_widgets = true,
943 	.add_common_controls = true,
944 	.add_common_snd_ops = true,
945 	.add_headset_jack = true,
946 };
947 
948 /* RT5631 machine */
949 
950 SND_SOC_DAILINK_DEFS(rt5631_hifi,
951 	DAILINK_COMP_ARRAY(COMP_EMPTY()),
952 	DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5631-hifi")),
953 	DAILINK_COMP_ARRAY(COMP_EMPTY()));
954 
955 static struct snd_soc_dai_link tegra_rt5631_dai = {
956 	.name = "RT5631",
957 	.stream_name = "RT5631 PCM",
958 	.init = tegra_asoc_machine_init,
959 	.dai_fmt = SND_SOC_DAIFMT_I2S |
960 		   SND_SOC_DAIFMT_NB_NF |
961 		   SND_SOC_DAIFMT_CBS_CFS,
962 	SND_SOC_DAILINK_REG(rt5631_hifi),
963 };
964 
965 static struct snd_soc_card snd_soc_tegra_rt5631 = {
966 	.components = "codec:rt5631",
967 	.dai_link = &tegra_rt5631_dai,
968 	.num_links = 1,
969 	.fully_routed = true,
970 };
971 
972 static const struct tegra_asoc_data tegra_rt5631_data = {
973 	.mclk_rate = tegra_machine_mclk_rate_6mhz,
974 	.card = &snd_soc_tegra_rt5631,
975 	.add_common_dapm_widgets = true,
976 	.add_common_controls = true,
977 	.add_common_snd_ops = true,
978 	.add_mic_jack = true,
979 	.add_hp_jack = true,
980 };
981 
982 static const struct of_device_id tegra_machine_of_match[] = {
983 	{ .compatible = "nvidia,tegra-audio-trimslice", .data = &tegra_trimslice_data },
984 	{ .compatible = "nvidia,tegra-audio-max98090", .data = &tegra_max98090_data },
985 	{ .compatible = "nvidia,tegra-audio-max98088", .data = &tegra_max98088_data },
986 	{ .compatible = "nvidia,tegra-audio-max98089", .data = &tegra_max98088_data },
987 	{ .compatible = "nvidia,tegra-audio-sgtl5000", .data = &tegra_sgtl5000_data },
988 	{ .compatible = "nvidia,tegra-audio-wm9712", .data = &tegra_wm9712_data },
989 	{ .compatible = "nvidia,tegra-audio-wm8753", .data = &tegra_wm8753_data },
990 	{ .compatible = "nvidia,tegra-audio-rt5677", .data = &tegra_rt5677_data },
991 	{ .compatible = "nvidia,tegra-audio-rt5640", .data = &tegra_rt5640_data },
992 	{ .compatible = "nvidia,tegra-audio-alc5632", .data = &tegra_rt5632_data },
993 	{ .compatible = "nvidia,tegra-audio-rt5631", .data = &tegra_rt5631_data },
994 	{},
995 };
996 MODULE_DEVICE_TABLE(of, tegra_machine_of_match);
997 
998 static struct platform_driver tegra_asoc_machine_driver = {
999 	.driver = {
1000 		.name = "tegra-audio",
1001 		.of_match_table = tegra_machine_of_match,
1002 		.pm = &snd_soc_pm_ops,
1003 	},
1004 	.probe = tegra_asoc_machine_probe,
1005 };
1006 module_platform_driver(tegra_asoc_machine_driver);
1007 
1008 MODULE_AUTHOR("Anatol Pomozov <anatol@google.com>");
1009 MODULE_AUTHOR("Andrey Danin <danindrey@mail.ru>");
1010 MODULE_AUTHOR("Dmitry Osipenko <digetx@gmail.com>");
1011 MODULE_AUTHOR("Ion Agorria <ion@agorria.com>");
1012 MODULE_AUTHOR("Leon Romanovsky <leon@leon.nu>");
1013 MODULE_AUTHOR("Lucas Stach <dev@lynxeye.de>");
1014 MODULE_AUTHOR("Marc Dietrich <marvin24@gmx.de>");
1015 MODULE_AUTHOR("Marcel Ziswiler <marcel@ziswiler.com>");
1016 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
1017 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
1018 MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>");
1019 MODULE_DESCRIPTION("Tegra machine ASoC driver");
1020 MODULE_LICENSE("GPL");
1021