add lvds1024*800

hc

2024-01-31 f70575805708cabdedea7498aaa3f710fde4d920

 kernel/sound/soc/fsl/fsl-asoc-card.c
..
..
@@ -15,6 +15,8 @@
15
15
 #endif
16
16
 #include <sound/pcm_params.h>
17
17
 #include <sound/soc.h>
18
+#include <sound/jack.h>
19
+#include <sound/simple_card_utils.h>
18
20
 
19
21
 #include "fsl_esai.h"
20
22
 #include "fsl_sai.h"
..
..
@@ -33,8 +35,7 @@
33
35
 #define DAI_FMT_BASE (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF)
34
36
 
35
37
 /**
36
- * CODEC private data
37
- *
38
+ * struct codec_priv - CODEC private data
38
39
  * @mclk_freq: Clock rate of MCLK
39
40
  * @mclk_id: MCLK (or main clock) id for set_sysclk()
40
41
  * @fll_id: FLL (or secordary clock) id for set_sysclk()
..
..
@@ -48,11 +49,10 @@
48
49
 };
49
50
 
50
51
 /**
51
- * CPU private data
52
- *
53
- * @sysclk_freq[2]: SYSCLK rates for set_sysclk()
54
- * @sysclk_dir[2]: SYSCLK directions for set_sysclk()
55
- * @sysclk_id[2]: SYSCLK ids for set_sysclk()
52
+ * struct cpu_priv - CPU private data
53
+ * @sysclk_freq: SYSCLK rates for set_sysclk()
54
+ * @sysclk_dir: SYSCLK directions for set_sysclk()
55
+ * @sysclk_id: SYSCLK ids for set_sysclk()
56
56
  * @slot_width: Slot width of each frame
57
57
  *
58
58
  * Note: [1] for tx and [0] for rx
..
..
@@ -65,13 +65,15 @@
65
65
 };
66
66
 
67
67
 /**
68
- * Freescale Generic ASOC card private data
69
- *
70
- * @dai_link[3]: DAI link structure including normal one and DPCM link
68
+ * struct fsl_asoc_card_priv - Freescale Generic ASOC card private data
69
+ * @dai_link: DAI link structure including normal one and DPCM link
70
+ * @hp_jack: Headphone Jack structure
71
+ * @mic_jack: Microphone Jack structure
71
72
  * @pdev: platform device pointer
72
73
  * @codec_priv: CODEC private data
73
74
  * @cpu_priv: CPU private data
74
75
  * @card: ASoC card structure
76
+ * @streams: Mask of current active streams
75
77
  * @sample_rate: Current sample rate
76
78
  * @sample_format: Current sample format
77
79
  * @asrc_rate: ASRC sample rate used by Back-Ends
..
..
@@ -82,10 +84,13 @@
82
84
 
83
85
 struct fsl_asoc_card_priv {
84
86
 	struct snd_soc_dai_link dai_link[3];
87
+	struct asoc_simple_jack hp_jack;
88
+	struct asoc_simple_jack mic_jack;
85
89
 	struct platform_device *pdev;
86
90
 	struct codec_priv codec_priv;
87
91
 	struct cpu_priv cpu_priv;
88
92
 	struct snd_soc_card card;
93
+	u8 streams;
89
94
 	u32 sample_rate;
90
95
 	snd_pcm_format_t sample_format;
91
96
 	u32 asrc_rate;
..
..
@@ -94,8 +99,8 @@
94
99
 	char name[32];
95
100
 };
96
101
 
97
-/**
98
- * This dapm route map exsits for DPCM link only.
102
+/*
103
+ * This dapm route map exists for DPCM link only.
99
104
  * The other routes shall go through Device Tree.
100
105
  *
101
106
  * Note: keep all ASRC routes in the second half
..
..
@@ -112,11 +117,18 @@
112
117
 
113
118
 static const struct snd_soc_dapm_route audio_map_ac97[] = {
114
119
 	/* 1st half -- Normal DAPM routes */
115
-	{"Playback",  NULL, "AC97 Playback"},
116
-	{"AC97 Capture",  NULL, "Capture"},
120
+	{"AC97 Playback",  NULL, "CPU AC97 Playback"},
121
+	{"CPU AC97 Capture",  NULL, "AC97 Capture"},
117
122
 	/* 2nd half -- ASRC DAPM routes */
118
-	{"AC97 Playback",  NULL, "ASRC-Playback"},
119
-	{"ASRC-Capture",  NULL, "AC97 Capture"},
123
+	{"CPU AC97 Playback",  NULL, "ASRC-Playback"},
124
+	{"ASRC-Capture",  NULL, "CPU AC97 Capture"},
125
+};
126
+
127
+static const struct snd_soc_dapm_route audio_map_tx[] = {
128
+	/* 1st half -- Normal DAPM routes */
129
+	{"Playback",  NULL, "CPU-Playback"},
130
+	/* 2nd half -- ASRC DAPM routes */
131
+	{"CPU-Playback",  NULL, "ASRC-Playback"},
120
132
 };
121
133
 
122
134
 /* Add all possible widgets into here without being redundant */
..
..
@@ -138,40 +150,98 @@
138
150
 static int fsl_asoc_card_hw_params(struct snd_pcm_substream *substream,
139
151
 				   struct snd_pcm_hw_params *params)
140
152
 {
141
-	struct snd_soc_pcm_runtime *rtd = substream->private_data;
153
+	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
142
154
 	struct fsl_asoc_card_priv *priv = snd_soc_card_get_drvdata(rtd->card);
143
155
 	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
156
+	struct codec_priv *codec_priv = &priv->codec_priv;
144
157
 	struct cpu_priv *cpu_priv = &priv->cpu_priv;
145
158
 	struct device *dev = rtd->card->dev;
159
+	unsigned int pll_out;
146
160
 	int ret;
147
161
 
148
162
 	priv->sample_rate = params_rate(params);
149
163
 	priv->sample_format = params_format(params);
164
+	priv->streams |= BIT(substream->stream);
150
165
 
151
-	/*
152
-	 * If codec-dai is DAI Master and all configurations are already in the
153
-	 * set_bias_level(), bypass the remaining settings in hw_params().
154
-	 * Note: (dai_fmt & CBM_CFM) includes CBM_CFM and CBM_CFS.
155
-	 */
156
-	if ((priv->card.set_bias_level &&
157
-	     priv->dai_fmt & SND_SOC_DAIFMT_CBM_CFM) ||
158
-	    fsl_asoc_card_is_ac97(priv))
166
+	if (fsl_asoc_card_is_ac97(priv))
159
167
 		return 0;
160
168
 
161
169
 	/* Specific configurations of DAIs starts from here */
162
-	ret = snd_soc_dai_set_sysclk(rtd->cpu_dai, cpu_priv->sysclk_id[tx],
170
+	ret = snd_soc_dai_set_sysclk(asoc_rtd_to_cpu(rtd, 0), cpu_priv->sysclk_id[tx],
163
171
 				     cpu_priv->sysclk_freq[tx],
164
172
 				     cpu_priv->sysclk_dir[tx]);
165
173
 	if (ret && ret != -ENOTSUPP) {
166
174
 		dev_err(dev, "failed to set sysclk for cpu dai\n");
167
-		return ret;
175
+		goto fail;
168
176
 	}
169
177
 
170
178
 	if (cpu_priv->slot_width) {
171
-		ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2,
179
+		ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2,
172
180
 					       cpu_priv->slot_width);
173
181
 		if (ret && ret != -ENOTSUPP) {
174
182
 			dev_err(dev, "failed to set TDM slot for cpu dai\n");
183
+			goto fail;
184
+		}
185
+	}
186
+
187
+	/* Specific configuration for PLL */
188
+	if (codec_priv->pll_id && codec_priv->fll_id) {
189
+		if (priv->sample_format == SNDRV_PCM_FORMAT_S24_LE)
190
+			pll_out = priv->sample_rate * 384;
191
+		else
192
+			pll_out = priv->sample_rate * 256;
193
+
194
+		ret = snd_soc_dai_set_pll(asoc_rtd_to_codec(rtd, 0),
195
+					  codec_priv->pll_id,
196
+					  codec_priv->mclk_id,
197
+					  codec_priv->mclk_freq, pll_out);
198
+		if (ret) {
199
+			dev_err(dev, "failed to start FLL: %d\n", ret);
200
+			goto fail;
201
+		}
202
+
203
+		ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(rtd, 0),
204
+					     codec_priv->fll_id,
205
+					     pll_out, SND_SOC_CLOCK_IN);
206
+
207
+		if (ret && ret != -ENOTSUPP) {
208
+			dev_err(dev, "failed to set SYSCLK: %d\n", ret);
209
+			goto fail;
210
+		}
211
+	}
212
+
213
+	return 0;
214
+
215
+fail:
216
+	priv->streams &= ~BIT(substream->stream);
217
+	return ret;
218
+}
219
+
220
+static int fsl_asoc_card_hw_free(struct snd_pcm_substream *substream)
221
+{
222
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
223
+	struct fsl_asoc_card_priv *priv = snd_soc_card_get_drvdata(rtd->card);
224
+	struct codec_priv *codec_priv = &priv->codec_priv;
225
+	struct device *dev = rtd->card->dev;
226
+	int ret;
227
+
228
+	priv->streams &= ~BIT(substream->stream);
229
+
230
+	if (!priv->streams && codec_priv->pll_id && codec_priv->fll_id) {
231
+		/* Force freq to be 0 to avoid error message in codec */
232
+		ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(rtd, 0),
233
+					     codec_priv->mclk_id,
234
+					     0,
235
+					     SND_SOC_CLOCK_IN);
236
+		if (ret) {
237
+			dev_err(dev, "failed to switch away from FLL: %d\n", ret);
238
+			return ret;
239
+		}
240
+
241
+		ret = snd_soc_dai_set_pll(asoc_rtd_to_codec(rtd, 0),
242
+					  codec_priv->pll_id, 0, 0, 0);
243
+		if (ret && ret != -ENOTSUPP) {
244
+			dev_err(dev, "failed to stop FLL: %d\n", ret);
175
245
 			return ret;
176
246
 		}
177
247
 	}
..
..
@@ -181,6 +251,7 @@
181
251
 
182
252
 static const struct snd_soc_ops fsl_asoc_card_ops = {
183
253
 	.hw_params = fsl_asoc_card_hw_params,
254
+	.hw_free = fsl_asoc_card_hw_free,
184
255
 };
185
256
 
186
257
 static int be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
..
..
@@ -200,103 +271,49 @@
200
271
 	return 0;
201
272
 }
202
273
 
274
+SND_SOC_DAILINK_DEFS(hifi,
275
+	DAILINK_COMP_ARRAY(COMP_EMPTY()),
276
+	DAILINK_COMP_ARRAY(COMP_EMPTY()),
277
+	DAILINK_COMP_ARRAY(COMP_EMPTY()));
278
+
279
+SND_SOC_DAILINK_DEFS(hifi_fe,
280
+	DAILINK_COMP_ARRAY(COMP_EMPTY()),
281
+	DAILINK_COMP_ARRAY(COMP_DUMMY()),
282
+	DAILINK_COMP_ARRAY(COMP_EMPTY()));
283
+
284
+SND_SOC_DAILINK_DEFS(hifi_be,
285
+	DAILINK_COMP_ARRAY(COMP_EMPTY()),
286
+	DAILINK_COMP_ARRAY(COMP_EMPTY()),
287
+	DAILINK_COMP_ARRAY(COMP_DUMMY()));
288
+
203
289
 static struct snd_soc_dai_link fsl_asoc_card_dai[] = {
204
290
 	/* Default ASoC DAI Link*/
205
291
 	{
206
292
 		.name = "HiFi",
207
293
 		.stream_name = "HiFi",
208
294
 		.ops = &fsl_asoc_card_ops,
295
+		SND_SOC_DAILINK_REG(hifi),
209
296
 	},
210
297
 	/* DPCM Link between Front-End and Back-End (Optional) */
211
298
 	{
212
299
 		.name = "HiFi-ASRC-FE",
213
300
 		.stream_name = "HiFi-ASRC-FE",
214
-		.codec_name = "snd-soc-dummy",
215
-		.codec_dai_name = "snd-soc-dummy-dai",
216
301
 		.dpcm_playback = 1,
217
302
 		.dpcm_capture = 1,
218
303
 		.dynamic = 1,
304
+		SND_SOC_DAILINK_REG(hifi_fe),
219
305
 	},
220
306
 	{
221
307
 		.name = "HiFi-ASRC-BE",
222
308
 		.stream_name = "HiFi-ASRC-BE",
223
-		.platform_name = "snd-soc-dummy",
224
309
 		.be_hw_params_fixup = be_hw_params_fixup,
225
310
 		.ops = &fsl_asoc_card_ops,
226
311
 		.dpcm_playback = 1,
227
312
 		.dpcm_capture = 1,
228
313
 		.no_pcm = 1,
314
+		SND_SOC_DAILINK_REG(hifi_be),
229
315
 	},
230
316
 };
231
-
232
-static int fsl_asoc_card_set_bias_level(struct snd_soc_card *card,
233
-					struct snd_soc_dapm_context *dapm,
234
-					enum snd_soc_bias_level level)
235
-{
236
-	struct fsl_asoc_card_priv *priv = snd_soc_card_get_drvdata(card);
237
-	struct snd_soc_pcm_runtime *rtd;
238
-	struct snd_soc_dai *codec_dai;
239
-	struct codec_priv *codec_priv = &priv->codec_priv;
240
-	struct device *dev = card->dev;
241
-	unsigned int pll_out;
242
-	int ret;
243
-
244
-	rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name);
245
-	codec_dai = rtd->codec_dai;
246
-	if (dapm->dev != codec_dai->dev)
247
-		return 0;
248
-
249
-	switch (level) {
250
-	case SND_SOC_BIAS_PREPARE:
251
-		if (dapm->bias_level != SND_SOC_BIAS_STANDBY)
252
-			break;
253
-
254
-		if (priv->sample_format == SNDRV_PCM_FORMAT_S24_LE)
255
-			pll_out = priv->sample_rate * 384;
256
-		else
257
-			pll_out = priv->sample_rate * 256;
258
-
259
-		ret = snd_soc_dai_set_pll(codec_dai, codec_priv->pll_id,
260
-					  codec_priv->mclk_id,
261
-					  codec_priv->mclk_freq, pll_out);
262
-		if (ret) {
263
-			dev_err(dev, "failed to start FLL: %d\n", ret);
264
-			return ret;
265
-		}
266
-
267
-		ret = snd_soc_dai_set_sysclk(codec_dai, codec_priv->fll_id,
268
-					     pll_out, SND_SOC_CLOCK_IN);
269
-		if (ret && ret != -ENOTSUPP) {
270
-			dev_err(dev, "failed to set SYSCLK: %d\n", ret);
271
-			return ret;
272
-		}
273
-		break;
274
-
275
-	case SND_SOC_BIAS_STANDBY:
276
-		if (dapm->bias_level != SND_SOC_BIAS_PREPARE)
277
-			break;
278
-
279
-		ret = snd_soc_dai_set_sysclk(codec_dai, codec_priv->mclk_id,
280
-					     codec_priv->mclk_freq,
281
-					     SND_SOC_CLOCK_IN);
282
-		if (ret && ret != -ENOTSUPP) {
283
-			dev_err(dev, "failed to switch away from FLL: %d\n", ret);
284
-			return ret;
285
-		}
286
-
287
-		ret = snd_soc_dai_set_pll(codec_dai, codec_priv->pll_id, 0, 0, 0);
288
-		if (ret) {
289
-			dev_err(dev, "failed to stop FLL: %d\n", ret);
290
-			return ret;
291
-		}
292
-		break;
293
-
294
-	default:
295
-		break;
296
-	}
297
-
298
-	return 0;
299
-}
300
317
 
301
318
 static int fsl_asoc_card_audmux_init(struct device_node *np,
302
319
 				     struct fsl_asoc_card_priv *priv)
..
..
@@ -426,19 +443,57 @@
426
443
 	return 0;
427
444
 }
428
445
 
446
+static int hp_jack_event(struct notifier_block *nb, unsigned long event,
447
+			 void *data)
448
+{
449
+	struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
450
+	struct snd_soc_dapm_context *dapm = &jack->card->dapm;
451
+
452
+	if (event & SND_JACK_HEADPHONE)
453
+		/* Disable speaker if headphone is plugged in */
454
+		snd_soc_dapm_disable_pin(dapm, "Ext Spk");
455
+	else
456
+		snd_soc_dapm_enable_pin(dapm, "Ext Spk");
457
+
458
+	return 0;
459
+}
460
+
461
+static struct notifier_block hp_jack_nb = {
462
+	.notifier_call = hp_jack_event,
463
+};
464
+
465
+static int mic_jack_event(struct notifier_block *nb, unsigned long event,
466
+			  void *data)
467
+{
468
+	struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
469
+	struct snd_soc_dapm_context *dapm = &jack->card->dapm;
470
+
471
+	if (event & SND_JACK_MICROPHONE)
472
+		/* Disable dmic if microphone is plugged in */
473
+		snd_soc_dapm_disable_pin(dapm, "DMIC");
474
+	else
475
+		snd_soc_dapm_enable_pin(dapm, "DMIC");
476
+
477
+	return 0;
478
+}
479
+
480
+static struct notifier_block mic_jack_nb = {
481
+	.notifier_call = mic_jack_event,
482
+};
483
+
429
484
 static int fsl_asoc_card_late_probe(struct snd_soc_card *card)
430
485
 {
431
486
 	struct fsl_asoc_card_priv *priv = snd_soc_card_get_drvdata(card);
432
487
 	struct snd_soc_pcm_runtime *rtd = list_first_entry(
433
488
 			&card->rtd_list, struct snd_soc_pcm_runtime, list);
434
-	struct snd_soc_dai *codec_dai = rtd->codec_dai;
489
+	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
435
490
 	struct codec_priv *codec_priv = &priv->codec_priv;
436
491
 	struct device *dev = card->dev;
437
492
 	int ret;
438
493
 
439
494
 	if (fsl_asoc_card_is_ac97(priv)) {
440
495
 #if IS_ENABLED(CONFIG_SND_AC97_CODEC)
441
-		struct snd_soc_component *component = rtd->codec_dai->component;
496
+		struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
442
497
 		struct snd_ac97 *ac97 = snd_soc_component_get_drvdata(component);
443
498
 
444
499
 		/*
..
..
@@ -468,10 +523,14 @@
468
523
 	struct device_node *cpu_np, *codec_np, *asrc_np;
469
524
 	struct device_node *np = pdev->dev.of_node;
470
525
 	struct platform_device *asrc_pdev = NULL;
526
+	struct device_node *bitclkmaster = NULL;
527
+	struct device_node *framemaster = NULL;
471
528
 	struct platform_device *cpu_pdev;
472
529
 	struct fsl_asoc_card_priv *priv;
473
-	struct i2c_client *codec_dev;
530
+	struct device *codec_dev = NULL;
474
531
 	const char *codec_dai_name;
532
+	const char *codec_dev_name;
533
+	unsigned int daifmt;
475
534
 	u32 width;
476
535
 	int ret;
477
536
 
..
..
@@ -497,10 +556,23 @@
497
556
 	}
498
557
 
499
558
 	codec_np = of_parse_phandle(np, "audio-codec", 0);
500
-	if (codec_np)
501
-		codec_dev = of_find_i2c_device_by_node(codec_np);
502
-	else
503
-		codec_dev = NULL;
559
+	if (codec_np) {
560
+		struct platform_device *codec_pdev;
561
+		struct i2c_client *codec_i2c;
562
+
563
+		codec_i2c = of_find_i2c_device_by_node(codec_np);
564
+		if (codec_i2c) {
565
+			codec_dev = &codec_i2c->dev;
566
+			codec_dev_name = codec_i2c->name;
567
+		}
568
+		if (!codec_dev) {
569
+			codec_pdev = of_find_device_by_node(codec_np);
570
+			if (codec_pdev) {
571
+				codec_dev = &codec_pdev->dev;
572
+				codec_dev_name = codec_pdev->name;
573
+			}
574
+		}
575
+	}
504
576
 
505
577
 	asrc_np = of_parse_phandle(np, "audio-asrc", 0);
506
578
 	if (asrc_np)
..
..
@@ -508,7 +580,7 @@
508
580
 
509
581
 	/* Get the MCLK rate only, and leave it controlled by CODEC drivers */
510
582
 	if (codec_dev) {
511
-		struct clk *codec_clk = clk_get(&codec_dev->dev, NULL);
583
+		struct clk *codec_clk = clk_get(codec_dev, NULL);
512
584
 
513
585
 		if (!IS_ERR(codec_clk)) {
514
586
 			priv->codec_priv.mclk_freq = clk_get_rate(codec_clk);
..
..
@@ -523,10 +595,14 @@
523
595
 	/* Assign a default DAI format, and allow each card to overwrite it */
524
596
 	priv->dai_fmt = DAI_FMT_BASE;
525
597
 
598
+	memcpy(priv->dai_link, fsl_asoc_card_dai,
599
+	       sizeof(struct snd_soc_dai_link) * ARRAY_SIZE(priv->dai_link));
600
+
601
+	priv->card.dapm_routes = audio_map;
602
+	priv->card.num_dapm_routes = ARRAY_SIZE(audio_map);
526
603
 	/* Diversify the card configurations */
527
604
 	if (of_device_is_compatible(np, "fsl,imx-audio-cs42888")) {
528
605
 		codec_dai_name = "cs42888";
529
-		priv->card.set_bias_level = NULL;
530
606
 		priv->cpu_priv.sysclk_freq[TX] = priv->codec_priv.mclk_freq;
531
607
 		priv->cpu_priv.sysclk_freq[RX] = priv->codec_priv.mclk_freq;
532
608
 		priv->cpu_priv.sysclk_dir[TX] = SND_SOC_CLOCK_OUT;
..
..
@@ -541,64 +617,118 @@
541
617
 		codec_dai_name = "sgtl5000";
542
618
 		priv->codec_priv.mclk_id = SGTL5000_SYSCLK;
543
619
 		priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
620
+	} else if (of_device_is_compatible(np, "fsl,imx-audio-tlv320aic32x4")) {
621
+		codec_dai_name = "tlv320aic32x4-hifi";
622
+		priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
544
623
 	} else if (of_device_is_compatible(np, "fsl,imx-audio-wm8962")) {
545
624
 		codec_dai_name = "wm8962";
546
-		priv->card.set_bias_level = fsl_asoc_card_set_bias_level;
547
625
 		priv->codec_priv.mclk_id = WM8962_SYSCLK_MCLK;
548
626
 		priv->codec_priv.fll_id = WM8962_SYSCLK_FLL;
549
627
 		priv->codec_priv.pll_id = WM8962_FLL;
550
628
 		priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
551
629
 	} else if (of_device_is_compatible(np, "fsl,imx-audio-wm8960")) {
552
630
 		codec_dai_name = "wm8960-hifi";
553
-		priv->card.set_bias_level = fsl_asoc_card_set_bias_level;
554
631
 		priv->codec_priv.fll_id = WM8960_SYSCLK_AUTO;
555
632
 		priv->codec_priv.pll_id = WM8960_SYSCLK_AUTO;
556
633
 		priv->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
557
634
 	} else if (of_device_is_compatible(np, "fsl,imx-audio-ac97")) {
558
635
 		codec_dai_name = "ac97-hifi";
559
-		priv->card.set_bias_level = NULL;
560
636
 		priv->dai_fmt = SND_SOC_DAIFMT_AC97;
637
+		priv->card.dapm_routes = audio_map_ac97;
638
+		priv->card.num_dapm_routes = ARRAY_SIZE(audio_map_ac97);
639
+	} else if (of_device_is_compatible(np, "fsl,imx-audio-mqs")) {
640
+		codec_dai_name = "fsl-mqs-dai";
641
+		priv->dai_fmt = SND_SOC_DAIFMT_LEFT_J |
642
+				SND_SOC_DAIFMT_CBS_CFS |
643
+				SND_SOC_DAIFMT_NB_NF;
644
+		priv->dai_link[1].dpcm_capture = 0;
645
+		priv->dai_link[2].dpcm_capture = 0;
646
+		priv->card.dapm_routes = audio_map_tx;
647
+		priv->card.num_dapm_routes = ARRAY_SIZE(audio_map_tx);
648
+	} else if (of_device_is_compatible(np, "fsl,imx-audio-wm8524")) {
649
+		codec_dai_name = "wm8524-hifi";
650
+		priv->dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
651
+		priv->dai_link[1].dpcm_capture = 0;
652
+		priv->dai_link[2].dpcm_capture = 0;
653
+		priv->cpu_priv.slot_width = 32;
654
+		priv->card.dapm_routes = audio_map_tx;
655
+		priv->card.num_dapm_routes = ARRAY_SIZE(audio_map_tx);
561
656
 	} else {
562
657
 		dev_err(&pdev->dev, "unknown Device Tree compatible\n");
563
658
 		ret = -EINVAL;
564
659
 		goto asrc_fail;
565
660
 	}
566
661
 
662
+	/* Format info from DT is optional. */
663
+	daifmt = snd_soc_of_parse_daifmt(np, NULL,
664
+					 &bitclkmaster, &framemaster);
665
+	daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
666
+	if (bitclkmaster || framemaster) {
667
+		if (codec_np == bitclkmaster)
668
+			daifmt |= (codec_np == framemaster) ?
669
+				SND_SOC_DAIFMT_CBM_CFM : SND_SOC_DAIFMT_CBM_CFS;
670
+		else
671
+			daifmt |= (codec_np == framemaster) ?
672
+				SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
673
+
674
+		/* Override dai_fmt with value from DT */
675
+		priv->dai_fmt = daifmt;
676
+	}
677
+
678
+	/* Change direction according to format */
679
+	if (priv->dai_fmt & SND_SOC_DAIFMT_CBM_CFM) {
680
+		priv->cpu_priv.sysclk_dir[TX] = SND_SOC_CLOCK_IN;
681
+		priv->cpu_priv.sysclk_dir[RX] = SND_SOC_CLOCK_IN;
682
+	}
683
+
684
+	of_node_put(bitclkmaster);
685
+	of_node_put(framemaster);
686
+
567
687
 	if (!fsl_asoc_card_is_ac97(priv) && !codec_dev) {
568
688
 		dev_err(&pdev->dev, "failed to find codec device\n");
569
-		ret = -EINVAL;
689
+		ret = -EPROBE_DEFER;
570
690
 		goto asrc_fail;
571
691
 	}
572
692
 
573
693
 	/* Common settings for corresponding Freescale CPU DAI driver */
574
-	if (strstr(cpu_np->name, "ssi")) {
694
+	if (of_node_name_eq(cpu_np, "ssi")) {
575
695
 		/* Only SSI needs to configure AUDMUX */
576
696
 		ret = fsl_asoc_card_audmux_init(np, priv);
577
697
 		if (ret) {
578
698
 			dev_err(&pdev->dev, "failed to init audmux\n");
579
699
 			goto asrc_fail;
580
700
 		}
581
-	} else if (strstr(cpu_np->name, "esai")) {
701
+	} else if (of_node_name_eq(cpu_np, "esai")) {
702
+		struct clk *esai_clk = clk_get(&cpu_pdev->dev, "extal");
703
+
704
+		if (!IS_ERR(esai_clk)) {
705
+			priv->cpu_priv.sysclk_freq[TX] = clk_get_rate(esai_clk);
706
+			priv->cpu_priv.sysclk_freq[RX] = clk_get_rate(esai_clk);
707
+			clk_put(esai_clk);
708
+		} else if (PTR_ERR(esai_clk) == -EPROBE_DEFER) {
709
+			ret = -EPROBE_DEFER;
710
+			goto asrc_fail;
711
+		}
712
+
582
713
 		priv->cpu_priv.sysclk_id[1] = ESAI_HCKT_EXTAL;
583
714
 		priv->cpu_priv.sysclk_id[0] = ESAI_HCKR_EXTAL;
584
-	} else if (strstr(cpu_np->name, "sai")) {
715
+	} else if (of_node_name_eq(cpu_np, "sai")) {
585
716
 		priv->cpu_priv.sysclk_id[1] = FSL_SAI_CLK_MAST1;
586
717
 		priv->cpu_priv.sysclk_id[0] = FSL_SAI_CLK_MAST1;
587
718
 	}
588
719
 
589
-	snprintf(priv->name, sizeof(priv->name), "%s-audio",
590
-		 fsl_asoc_card_is_ac97(priv) ? "ac97" :
591
-		 codec_dev->name);
592
-
593
720
 	/* Initialize sound card */
594
721
 	priv->pdev = pdev;
595
722
 	priv->card.dev = &pdev->dev;
596
-	priv->card.name = priv->name;
723
+	priv->card.owner = THIS_MODULE;
724
+	ret = snd_soc_of_parse_card_name(&priv->card, "model");
725
+	if (ret) {
726
+		snprintf(priv->name, sizeof(priv->name), "%s-audio",
727
+			 fsl_asoc_card_is_ac97(priv) ? "ac97" : codec_dev_name);
728
+		priv->card.name = priv->name;
729
+	}
597
730
 	priv->card.dai_link = priv->dai_link;
598
-	priv->card.dapm_routes = fsl_asoc_card_is_ac97(priv) ?
599
-				 audio_map_ac97 : audio_map;
600
731
 	priv->card.late_probe = fsl_asoc_card_late_probe;
601
-	priv->card.num_dapm_routes = ARRAY_SIZE(audio_map);
602
732
 	priv->card.dapm_widgets = fsl_asoc_card_dapm_widgets;
603
733
 	priv->card.num_dapm_widgets = ARRAY_SIZE(fsl_asoc_card_dapm_widgets);
604
734
 
..
..
@@ -606,21 +736,20 @@
606
736
 	if (!asrc_pdev)
607
737
 		priv->card.num_dapm_routes /= 2;
608
738
 
609
-	memcpy(priv->dai_link, fsl_asoc_card_dai,
610
-	       sizeof(struct snd_soc_dai_link) * ARRAY_SIZE(priv->dai_link));
611
-
612
-	ret = snd_soc_of_parse_audio_routing(&priv->card, "audio-routing");
613
-	if (ret) {
614
-		dev_err(&pdev->dev, "failed to parse audio-routing: %d\n", ret);
615
-		goto asrc_fail;
739
+	if (of_property_read_bool(np, "audio-routing")) {
740
+		ret = snd_soc_of_parse_audio_routing(&priv->card, "audio-routing");
741
+		if (ret) {
742
+			dev_err(&pdev->dev, "failed to parse audio-routing: %d\n", ret);
743
+			goto asrc_fail;
744
+		}
616
745
 	}
617
746
 
618
747
 	/* Normal DAI Link */
619
-	priv->dai_link[0].cpu_of_node = cpu_np;
620
-	priv->dai_link[0].codec_dai_name = codec_dai_name;
748
+	priv->dai_link[0].cpus->of_node = cpu_np;
749
+	priv->dai_link[0].codecs->dai_name = codec_dai_name;
621
750
 
622
751
 	if (!fsl_asoc_card_is_ac97(priv))
623
-		priv->dai_link[0].codec_of_node = codec_np;
752
+		priv->dai_link[0].codecs->of_node = codec_np;
624
753
 	else {
625
754
 		u32 idx;
626
755
 
..
..
@@ -631,29 +760,29 @@
631
760
 			goto asrc_fail;
632
761
 		}
633
762
 
634
-		priv->dai_link[0].codec_name =
763
+		priv->dai_link[0].codecs->name =
635
764
 				devm_kasprintf(&pdev->dev, GFP_KERNEL,
636
765
 					       "ac97-codec.%u",
637
766
 					       (unsigned int)idx);
638
-		if (!priv->dai_link[0].codec_name) {
767
+		if (!priv->dai_link[0].codecs->name) {
639
768
 			ret = -ENOMEM;
640
769
 			goto asrc_fail;
641
770
 		}
642
771
 	}
643
772
 
644
-	priv->dai_link[0].platform_of_node = cpu_np;
773
+	priv->dai_link[0].platforms->of_node = cpu_np;
645
774
 	priv->dai_link[0].dai_fmt = priv->dai_fmt;
646
775
 	priv->card.num_links = 1;
647
776
 
648
777
 	if (asrc_pdev) {
649
778
 		/* DPCM DAI Links only if ASRC exsits */
650
-		priv->dai_link[1].cpu_of_node = asrc_np;
651
-		priv->dai_link[1].platform_of_node = asrc_np;
652
-		priv->dai_link[2].codec_dai_name = codec_dai_name;
653
-		priv->dai_link[2].codec_of_node = codec_np;
654
-		priv->dai_link[2].codec_name =
655
-				priv->dai_link[0].codec_name;
656
-		priv->dai_link[2].cpu_of_node = cpu_np;
779
+		priv->dai_link[1].cpus->of_node = asrc_np;
780
+		priv->dai_link[1].platforms->of_node = asrc_np;
781
+		priv->dai_link[2].codecs->dai_name = codec_dai_name;
782
+		priv->dai_link[2].codecs->of_node = codec_np;
783
+		priv->dai_link[2].codecs->name =
784
+				priv->dai_link[0].codecs->name;
785
+		priv->dai_link[2].cpus->of_node = cpu_np;
657
786
 		priv->dai_link[2].dai_fmt = priv->dai_fmt;
658
787
 		priv->card.num_links = 3;
659
788
 
..
..
@@ -665,17 +794,23 @@
665
794
 			goto asrc_fail;
666
795
 		}
667
796
 
668
-		ret = of_property_read_u32(asrc_np, "fsl,asrc-width", &width);
797
+		ret = of_property_read_u32(asrc_np, "fsl,asrc-format",
798
+					   &priv->asrc_format);
669
799
 		if (ret) {
670
-			dev_err(&pdev->dev, "failed to get output rate\n");
671
-			ret = -EINVAL;
672
-			goto asrc_fail;
673
-		}
800
+			/* Fallback to old binding; translate to asrc_format */
801
+			ret = of_property_read_u32(asrc_np, "fsl,asrc-width",
802
+						   &width);
803
+			if (ret) {
804
+				dev_err(&pdev->dev,
805
+					"failed to decide output format\n");
806
+				goto asrc_fail;
807
+			}
674
808
 
675
-		if (width == 24)
676
-			priv->asrc_format = SNDRV_PCM_FORMAT_S24_LE;
677
-		else
678
-			priv->asrc_format = SNDRV_PCM_FORMAT_S16_LE;
809
+			if (width == 24)
810
+				priv->asrc_format = SNDRV_PCM_FORMAT_S24_LE;
811
+			else
812
+				priv->asrc_format = SNDRV_PCM_FORMAT_S16_LE;
813
+		}
679
814
 	}
680
815
 
681
816
 	/* Finish card registering */
..
..
@@ -683,8 +818,37 @@
683
818
 	snd_soc_card_set_drvdata(&priv->card, priv);
684
819
 
685
820
 	ret = devm_snd_soc_register_card(&pdev->dev, &priv->card);
686
-	if (ret && ret != -EPROBE_DEFER)
687
-		dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);
821
+	if (ret) {
822
+		if (ret != -EPROBE_DEFER)
823
+			dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);
824
+		goto asrc_fail;
825
+	}
826
+
827
+	/*
828
+	 * Properties "hp-det-gpio" and "mic-det-gpio" are optional, and
829
+	 * asoc_simple_init_jack uses these properties for creating
830
+	 * Headphone Jack and Microphone Jack.
831
+	 *
832
+	 * The notifier is initialized in snd_soc_card_jack_new(), then
833
+	 * snd_soc_jack_notifier_register can be called.
834
+	 */
835
+	if (of_property_read_bool(np, "hp-det-gpio")) {
836
+		ret = asoc_simple_init_jack(&priv->card, &priv->hp_jack,
837
+					    1, NULL, "Headphone Jack");
838
+		if (ret)
839
+			goto asrc_fail;
840
+
841
+		snd_soc_jack_notifier_register(&priv->hp_jack.jack, &hp_jack_nb);
842
+	}
843
+
844
+	if (of_property_read_bool(np, "mic-det-gpio")) {
845
+		ret = asoc_simple_init_jack(&priv->card, &priv->mic_jack,
846
+					    0, NULL, "Mic Jack");
847
+		if (ret)
848
+			goto asrc_fail;
849
+
850
+		snd_soc_jack_notifier_register(&priv->mic_jack.jack, &mic_jack_nb);
851
+	}
688
852
 
689
853
 asrc_fail:
690
854
 	of_node_put(asrc_np);
..
..
@@ -700,9 +864,12 @@
700
864
 	{ .compatible = "fsl,imx-audio-ac97", },
701
865
 	{ .compatible = "fsl,imx-audio-cs42888", },
702
866
 	{ .compatible = "fsl,imx-audio-cs427x", },
867
+	{ .compatible = "fsl,imx-audio-tlv320aic32x4", },
703
868
 	{ .compatible = "fsl,imx-audio-sgtl5000", },
704
869
 	{ .compatible = "fsl,imx-audio-wm8962", },
705
870
 	{ .compatible = "fsl,imx-audio-wm8960", },
871
+	{ .compatible = "fsl,imx-audio-mqs", },
872
+	{ .compatible = "fsl,imx-audio-wm8524", },
706
873
 	{}
707
874
 };
708
875
 MODULE_DEVICE_TABLE(of, fsl_asoc_card_dt_ids);