xref: /linux/sound/soc/codecs/hdac_hda.c (revision 2da68a77) 
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright(c) 2015-18 Intel Corporation.
3 
4 /*
5  * hdac_hda.c - ASoC extensions to reuse the legacy HDA codec drivers
6  * with ASoC platform drivers. These APIs are called by the legacy HDA
7  * codec drivers using hdac_ext_bus_ops ops.
8  */
9 
10 #include <linux/init.h>
11 #include <linux/delay.h>
12 #include <linux/module.h>
13 #include <linux/pm_runtime.h>
14 #include <sound/pcm_params.h>
15 #include <sound/soc.h>
16 #include <sound/hdaudio_ext.h>
17 #include <sound/hda_i915.h>
18 #include <sound/hda_codec.h>
19 #include <sound/hda_register.h>
20 
21 #include "hdac_hda.h"
22 
23 #define STUB_FORMATS	(SNDRV_PCM_FMTBIT_S8 | \
24 			SNDRV_PCM_FMTBIT_U8 | \
25 			SNDRV_PCM_FMTBIT_S16_LE | \
26 			SNDRV_PCM_FMTBIT_U16_LE | \
27 			SNDRV_PCM_FMTBIT_S24_LE | \
28 			SNDRV_PCM_FMTBIT_U24_LE | \
29 			SNDRV_PCM_FMTBIT_S32_LE | \
30 			SNDRV_PCM_FMTBIT_U32_LE | \
31 			SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
32 
33 #define STUB_HDMI_RATES	(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
34 				 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
35 				 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
36 				 SNDRV_PCM_RATE_192000)
37 
38 static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
39 			     struct snd_soc_dai *dai);
40 static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
41 			       struct snd_soc_dai *dai);
42 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
43 				struct snd_soc_dai *dai);
44 static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
45 				  struct snd_pcm_hw_params *params,
46 				  struct snd_soc_dai *dai);
47 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
48 				struct snd_soc_dai *dai);
49 static int hdac_hda_dai_set_stream(struct snd_soc_dai *dai, void *stream,
50 				   int direction);
51 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt,
52 						 struct snd_soc_dai *dai);
53 
54 static const struct snd_soc_dai_ops hdac_hda_dai_ops = {
55 	.startup = hdac_hda_dai_open,
56 	.shutdown = hdac_hda_dai_close,
57 	.prepare = hdac_hda_dai_prepare,
58 	.hw_params = hdac_hda_dai_hw_params,
59 	.hw_free = hdac_hda_dai_hw_free,
60 	.set_stream = hdac_hda_dai_set_stream,
61 };
62 
63 static struct snd_soc_dai_driver hdac_hda_dais[] = {
64 {
65 	.id = HDAC_ANALOG_DAI_ID,
66 	.name = "Analog Codec DAI",
67 	.ops = &hdac_hda_dai_ops,
68 	.playback = {
69 		.stream_name	= "Analog Codec Playback",
70 		.channels_min	= 1,
71 		.channels_max	= 16,
72 		.rates		= SNDRV_PCM_RATE_8000_192000,
73 		.formats	= STUB_FORMATS,
74 		.sig_bits	= 24,
75 	},
76 	.capture = {
77 		.stream_name    = "Analog Codec Capture",
78 		.channels_min   = 1,
79 		.channels_max   = 16,
80 		.rates = SNDRV_PCM_RATE_8000_192000,
81 		.formats = STUB_FORMATS,
82 		.sig_bits = 24,
83 	},
84 },
85 {
86 	.id = HDAC_DIGITAL_DAI_ID,
87 	.name = "Digital Codec DAI",
88 	.ops = &hdac_hda_dai_ops,
89 	.playback = {
90 		.stream_name    = "Digital Codec Playback",
91 		.channels_min   = 1,
92 		.channels_max   = 16,
93 		.rates          = SNDRV_PCM_RATE_8000_192000,
94 		.formats        = STUB_FORMATS,
95 		.sig_bits = 24,
96 	},
97 	.capture = {
98 		.stream_name    = "Digital Codec Capture",
99 		.channels_min   = 1,
100 		.channels_max   = 16,
101 		.rates = SNDRV_PCM_RATE_8000_192000,
102 		.formats = STUB_FORMATS,
103 		.sig_bits = 24,
104 	},
105 },
106 {
107 	.id = HDAC_ALT_ANALOG_DAI_ID,
108 	.name = "Alt Analog Codec DAI",
109 	.ops = &hdac_hda_dai_ops,
110 	.playback = {
111 		.stream_name	= "Alt Analog Codec Playback",
112 		.channels_min	= 1,
113 		.channels_max	= 16,
114 		.rates		= SNDRV_PCM_RATE_8000_192000,
115 		.formats	= STUB_FORMATS,
116 		.sig_bits	= 24,
117 	},
118 	.capture = {
119 		.stream_name    = "Alt Analog Codec Capture",
120 		.channels_min   = 1,
121 		.channels_max   = 16,
122 		.rates = SNDRV_PCM_RATE_8000_192000,
123 		.formats = STUB_FORMATS,
124 		.sig_bits = 24,
125 	},
126 },
127 {
128 	.id = HDAC_HDMI_0_DAI_ID,
129 	.name = "intel-hdmi-hifi1",
130 	.ops = &hdac_hda_dai_ops,
131 	.playback = {
132 		.stream_name    = "hifi1",
133 		.channels_min   = 1,
134 		.channels_max   = 32,
135 		.rates          = STUB_HDMI_RATES,
136 		.formats        = STUB_FORMATS,
137 		.sig_bits = 24,
138 	},
139 },
140 {
141 	.id = HDAC_HDMI_1_DAI_ID,
142 	.name = "intel-hdmi-hifi2",
143 	.ops = &hdac_hda_dai_ops,
144 	.playback = {
145 		.stream_name    = "hifi2",
146 		.channels_min   = 1,
147 		.channels_max   = 32,
148 		.rates          = STUB_HDMI_RATES,
149 		.formats        = STUB_FORMATS,
150 		.sig_bits = 24,
151 	},
152 },
153 {
154 	.id = HDAC_HDMI_2_DAI_ID,
155 	.name = "intel-hdmi-hifi3",
156 	.ops = &hdac_hda_dai_ops,
157 	.playback = {
158 		.stream_name    = "hifi3",
159 		.channels_min   = 1,
160 		.channels_max   = 32,
161 		.rates          = STUB_HDMI_RATES,
162 		.formats        = STUB_FORMATS,
163 		.sig_bits = 24,
164 	},
165 },
166 {
167 	.id = HDAC_HDMI_3_DAI_ID,
168 	.name = "intel-hdmi-hifi4",
169 	.ops = &hdac_hda_dai_ops,
170 	.playback = {
171 		.stream_name    = "hifi4",
172 		.channels_min   = 1,
173 		.channels_max   = 32,
174 		.rates          = STUB_HDMI_RATES,
175 		.formats        = STUB_FORMATS,
176 		.sig_bits = 24,
177 	},
178 },
179 
180 };
181 
182 static int hdac_hda_dai_set_stream(struct snd_soc_dai *dai,
183 				   void *stream, int direction)
184 {
185 	struct snd_soc_component *component = dai->component;
186 	struct hdac_hda_priv *hda_pvt;
187 	struct hdac_hda_pcm *pcm;
188 	struct hdac_stream *hstream;
189 
190 	if (!stream)
191 		return -EINVAL;
192 
193 	hda_pvt = snd_soc_component_get_drvdata(component);
194 	pcm = &hda_pvt->pcm[dai->id];
195 	hstream = (struct hdac_stream *)stream;
196 
197 	pcm->stream_tag[direction] = hstream->stream_tag;
198 
199 	return 0;
200 }
201 
202 static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
203 				  struct snd_pcm_hw_params *params,
204 				  struct snd_soc_dai *dai)
205 {
206 	struct snd_soc_component *component = dai->component;
207 	struct hdac_hda_priv *hda_pvt;
208 	unsigned int format_val;
209 	unsigned int maxbps;
210 
211 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
212 		maxbps = dai->driver->playback.sig_bits;
213 	else
214 		maxbps = dai->driver->capture.sig_bits;
215 
216 	hda_pvt = snd_soc_component_get_drvdata(component);
217 	format_val = snd_hdac_calc_stream_format(params_rate(params),
218 						 params_channels(params),
219 						 params_format(params),
220 						 maxbps,
221 						 0);
222 	if (!format_val) {
223 		dev_err(dai->dev,
224 			"invalid format_val, rate=%d, ch=%d, format=%d, maxbps=%d\n",
225 			params_rate(params), params_channels(params),
226 			params_format(params), maxbps);
227 
228 		return -EINVAL;
229 	}
230 
231 	hda_pvt->pcm[dai->id].format_val[substream->stream] = format_val;
232 	return 0;
233 }
234 
235 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
236 				struct snd_soc_dai *dai)
237 {
238 	struct snd_soc_component *component = dai->component;
239 	struct hdac_hda_priv *hda_pvt;
240 	struct hda_pcm_stream *hda_stream;
241 	struct hda_pcm *pcm;
242 
243 	hda_pvt = snd_soc_component_get_drvdata(component);
244 	pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
245 	if (!pcm)
246 		return -EINVAL;
247 
248 	hda_stream = &pcm->stream[substream->stream];
249 	snd_hda_codec_cleanup(hda_pvt->codec, hda_stream, substream);
250 
251 	return 0;
252 }
253 
254 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
255 				struct snd_soc_dai *dai)
256 {
257 	struct snd_soc_component *component = dai->component;
258 	struct hda_pcm_stream *hda_stream;
259 	struct hdac_hda_priv *hda_pvt;
260 	struct hdac_device *hdev;
261 	unsigned int format_val;
262 	struct hda_pcm *pcm;
263 	unsigned int stream;
264 	int ret = 0;
265 
266 	hda_pvt = snd_soc_component_get_drvdata(component);
267 	hdev = &hda_pvt->codec->core;
268 	pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
269 	if (!pcm)
270 		return -EINVAL;
271 
272 	hda_stream = &pcm->stream[substream->stream];
273 
274 	stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream];
275 	format_val = hda_pvt->pcm[dai->id].format_val[substream->stream];
276 
277 	ret = snd_hda_codec_prepare(hda_pvt->codec, hda_stream,
278 				    stream, format_val, substream);
279 	if (ret < 0)
280 		dev_err(&hdev->dev, "codec prepare failed %d\n", ret);
281 
282 	return ret;
283 }
284 
285 static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
286 			     struct snd_soc_dai *dai)
287 {
288 	struct snd_soc_component *component = dai->component;
289 	struct hdac_hda_priv *hda_pvt;
290 	struct hda_pcm_stream *hda_stream;
291 	struct hda_pcm *pcm;
292 
293 	hda_pvt = snd_soc_component_get_drvdata(component);
294 	pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
295 	if (!pcm)
296 		return -EINVAL;
297 
298 	snd_hda_codec_pcm_get(pcm);
299 
300 	hda_stream = &pcm->stream[substream->stream];
301 
302 	return hda_stream->ops.open(hda_stream, hda_pvt->codec, substream);
303 }
304 
305 static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
306 			       struct snd_soc_dai *dai)
307 {
308 	struct snd_soc_component *component = dai->component;
309 	struct hdac_hda_priv *hda_pvt;
310 	struct hda_pcm_stream *hda_stream;
311 	struct hda_pcm *pcm;
312 
313 	hda_pvt = snd_soc_component_get_drvdata(component);
314 	pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
315 	if (!pcm)
316 		return;
317 
318 	hda_stream = &pcm->stream[substream->stream];
319 
320 	hda_stream->ops.close(hda_stream, hda_pvt->codec, substream);
321 
322 	snd_hda_codec_pcm_put(pcm);
323 }
324 
325 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt,
326 						 struct snd_soc_dai *dai)
327 {
328 	struct hda_codec *hcodec = hda_pvt->codec;
329 	struct hda_pcm *cpcm;
330 	const char *pcm_name;
331 
332 	/*
333 	 * map DAI ID to the closest matching PCM name, using the naming
334 	 * scheme used by hda-codec snd_hda_gen_build_pcms() and for
335 	 * HDMI in hda_codec patch_hdmi.c)
336 	 */
337 
338 	switch (dai->id) {
339 	case HDAC_ANALOG_DAI_ID:
340 		pcm_name = "Analog";
341 		break;
342 	case HDAC_DIGITAL_DAI_ID:
343 		pcm_name = "Digital";
344 		break;
345 	case HDAC_ALT_ANALOG_DAI_ID:
346 		pcm_name = "Alt Analog";
347 		break;
348 	case HDAC_HDMI_0_DAI_ID:
349 		pcm_name = "HDMI 0";
350 		break;
351 	case HDAC_HDMI_1_DAI_ID:
352 		pcm_name = "HDMI 1";
353 		break;
354 	case HDAC_HDMI_2_DAI_ID:
355 		pcm_name = "HDMI 2";
356 		break;
357 	case HDAC_HDMI_3_DAI_ID:
358 		pcm_name = "HDMI 3";
359 		break;
360 	default:
361 		dev_err(&hcodec->core.dev, "invalid dai id %d\n", dai->id);
362 		return NULL;
363 	}
364 
365 	list_for_each_entry(cpcm, &hcodec->pcm_list_head, list) {
366 		if (strstr(cpcm->name, pcm_name)) {
367 			if (strcmp(pcm_name, "Analog") == 0) {
368 				if (strstr(cpcm->name, "Alt Analog"))
369 					continue;
370 			}
371 			return cpcm;
372 		}
373 	}
374 
375 	dev_err(&hcodec->core.dev, "didn't find PCM for DAI %s\n", dai->name);
376 	return NULL;
377 }
378 
379 static bool is_hdmi_codec(struct hda_codec *hcodec)
380 {
381 	struct hda_pcm *cpcm;
382 
383 	list_for_each_entry(cpcm, &hcodec->pcm_list_head, list) {
384 		if (cpcm->pcm_type == HDA_PCM_TYPE_HDMI)
385 			return true;
386 	}
387 
388 	return false;
389 }
390 
391 static int hdac_hda_codec_probe(struct snd_soc_component *component)
392 {
393 	struct hdac_hda_priv *hda_pvt =
394 			snd_soc_component_get_drvdata(component);
395 	struct snd_soc_dapm_context *dapm =
396 			snd_soc_component_get_dapm(component);
397 	struct hdac_device *hdev = &hda_pvt->codec->core;
398 	struct hda_codec *hcodec = hda_pvt->codec;
399 	struct hdac_ext_link *hlink;
400 	hda_codec_patch_t patch;
401 	int ret;
402 
403 	hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
404 	if (!hlink) {
405 		dev_err(&hdev->dev, "hdac link not found\n");
406 		return -EIO;
407 	}
408 
409 	snd_hdac_ext_bus_link_get(hdev->bus, hlink);
410 
411 	/*
412 	 * Ensure any HDA display is powered at codec probe.
413 	 * After snd_hda_codec_device_new(), display power is
414 	 * managed by runtime PM.
415 	 */
416 	if (hda_pvt->need_display_power)
417 		snd_hdac_display_power(hdev->bus,
418 				       HDA_CODEC_IDX_CONTROLLER, true);
419 
420 	ret = snd_hda_codec_device_new(hcodec->bus, component->card->snd_card,
421 				       hdev->addr, hcodec, true);
422 	if (ret < 0) {
423 		dev_err(&hdev->dev, "failed to create hda codec %d\n", ret);
424 		goto error_no_pm;
425 	}
426 	/*
427 	 * Overwrite type to HDA_DEV_ASOC since it is a ASoC driver
428 	 * hda_codec.c will check this flag to determine if unregister
429 	 * device is needed.
430 	 */
431 	hdev->type = HDA_DEV_ASOC;
432 
433 	/*
434 	 * snd_hda_codec_device_new decrements the usage count so call get pm
435 	 * else the device will be powered off
436 	 */
437 	pm_runtime_get_noresume(&hdev->dev);
438 
439 	hcodec->bus->card = dapm->card->snd_card;
440 
441 	ret = snd_hda_codec_set_name(hcodec, hcodec->preset->name);
442 	if (ret < 0) {
443 		dev_err(&hdev->dev, "name failed %s\n", hcodec->preset->name);
444 		goto error_pm;
445 	}
446 
447 	ret = snd_hdac_regmap_init(&hcodec->core);
448 	if (ret < 0) {
449 		dev_err(&hdev->dev, "regmap init failed\n");
450 		goto error_pm;
451 	}
452 
453 	patch = (hda_codec_patch_t)hcodec->preset->driver_data;
454 	if (patch) {
455 		ret = patch(hcodec);
456 		if (ret < 0) {
457 			dev_err(&hdev->dev, "patch failed %d\n", ret);
458 			goto error_regmap;
459 		}
460 	} else {
461 		dev_dbg(&hdev->dev, "no patch file found\n");
462 	}
463 
464 	ret = snd_hda_codec_parse_pcms(hcodec);
465 	if (ret < 0) {
466 		dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret);
467 		goto error_patch;
468 	}
469 
470 	/* HDMI controls need to be created in machine drivers */
471 	if (!is_hdmi_codec(hcodec)) {
472 		ret = snd_hda_codec_build_controls(hcodec);
473 		if (ret < 0) {
474 			dev_err(&hdev->dev, "unable to create controls %d\n",
475 				ret);
476 			goto error_patch;
477 		}
478 	}
479 
480 	hcodec->core.lazy_cache = true;
481 
482 	if (hda_pvt->need_display_power)
483 		snd_hdac_display_power(hdev->bus,
484 				       HDA_CODEC_IDX_CONTROLLER, false);
485 
486 	/* match for forbid call in snd_hda_codec_device_new() */
487 	pm_runtime_allow(&hdev->dev);
488 
489 	/*
490 	 * hdac_device core already sets the state to active and calls
491 	 * get_noresume. So enable runtime and set the device to suspend.
492 	 * pm_runtime_enable is also called during codec registeration
493 	 */
494 	pm_runtime_put(&hdev->dev);
495 	pm_runtime_suspend(&hdev->dev);
496 
497 	return 0;
498 
499 error_patch:
500 	if (hcodec->patch_ops.free)
501 		hcodec->patch_ops.free(hcodec);
502 error_regmap:
503 	snd_hdac_regmap_exit(hdev);
504 error_pm:
505 	pm_runtime_put(&hdev->dev);
506 error_no_pm:
507 	snd_hdac_ext_bus_link_put(hdev->bus, hlink);
508 	return ret;
509 }
510 
511 static void hdac_hda_codec_remove(struct snd_soc_component *component)
512 {
513 	struct hdac_hda_priv *hda_pvt =
514 		      snd_soc_component_get_drvdata(component);
515 	struct hdac_device *hdev = &hda_pvt->codec->core;
516 	struct hda_codec *codec = hda_pvt->codec;
517 	struct hdac_ext_link *hlink = NULL;
518 
519 	hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
520 	if (!hlink) {
521 		dev_err(&hdev->dev, "hdac link not found\n");
522 		return;
523 	}
524 
525 	pm_runtime_disable(&hdev->dev);
526 	snd_hdac_ext_bus_link_put(hdev->bus, hlink);
527 
528 	if (codec->patch_ops.free)
529 		codec->patch_ops.free(codec);
530 
531 	snd_hda_codec_cleanup_for_unbind(codec);
532 }
533 
534 static const struct snd_soc_dapm_route hdac_hda_dapm_routes[] = {
535 	{"AIF1TX", NULL, "Codec Input Pin1"},
536 	{"AIF2TX", NULL, "Codec Input Pin2"},
537 	{"AIF3TX", NULL, "Codec Input Pin3"},
538 
539 	{"Codec Output Pin1", NULL, "AIF1RX"},
540 	{"Codec Output Pin2", NULL, "AIF2RX"},
541 	{"Codec Output Pin3", NULL, "AIF3RX"},
542 };
543 
544 static const struct snd_soc_dapm_widget hdac_hda_dapm_widgets[] = {
545 	/* Audio Interface */
546 	SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0,
547 			    SND_SOC_NOPM, 0, 0),
548 	SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0,
549 			    SND_SOC_NOPM, 0, 0),
550 	SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0,
551 			    SND_SOC_NOPM, 0, 0),
552 	SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0,
553 			     SND_SOC_NOPM, 0, 0),
554 	SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0,
555 			     SND_SOC_NOPM, 0, 0),
556 	SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0,
557 			     SND_SOC_NOPM, 0, 0),
558 
559 	/* Input Pins */
560 	SND_SOC_DAPM_INPUT("Codec Input Pin1"),
561 	SND_SOC_DAPM_INPUT("Codec Input Pin2"),
562 	SND_SOC_DAPM_INPUT("Codec Input Pin3"),
563 
564 	/* Output Pins */
565 	SND_SOC_DAPM_OUTPUT("Codec Output Pin1"),
566 	SND_SOC_DAPM_OUTPUT("Codec Output Pin2"),
567 	SND_SOC_DAPM_OUTPUT("Codec Output Pin3"),
568 };
569 
570 static const struct snd_soc_component_driver hdac_hda_codec = {
571 	.probe			= hdac_hda_codec_probe,
572 	.remove			= hdac_hda_codec_remove,
573 	.dapm_widgets		= hdac_hda_dapm_widgets,
574 	.num_dapm_widgets	= ARRAY_SIZE(hdac_hda_dapm_widgets),
575 	.dapm_routes		= hdac_hda_dapm_routes,
576 	.num_dapm_routes	= ARRAY_SIZE(hdac_hda_dapm_routes),
577 	.idle_bias_on		= false,
578 	.endianness		= 1,
579 };
580 
581 static int hdac_hda_dev_probe(struct hdac_device *hdev)
582 {
583 	struct hdac_ext_link *hlink;
584 	int ret;
585 
586 	/* hold the ref while we probe */
587 	hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
588 	if (!hlink) {
589 		dev_err(&hdev->dev, "hdac link not found\n");
590 		return -EIO;
591 	}
592 	snd_hdac_ext_bus_link_get(hdev->bus, hlink);
593 
594 	/* ASoC specific initialization */
595 	ret = devm_snd_soc_register_component(&hdev->dev,
596 					 &hdac_hda_codec, hdac_hda_dais,
597 					 ARRAY_SIZE(hdac_hda_dais));
598 	if (ret < 0) {
599 		dev_err(&hdev->dev, "failed to register HDA codec %d\n", ret);
600 		return ret;
601 	}
602 
603 	snd_hdac_ext_bus_link_put(hdev->bus, hlink);
604 
605 	return ret;
606 }
607 
608 static int hdac_hda_dev_remove(struct hdac_device *hdev)
609 {
610 	/*
611 	 * Resources are freed in hdac_hda_codec_remove(). This
612 	 * function is kept to keep hda_codec_driver_remove() happy.
613 	 */
614 	return 0;
615 }
616 
617 static struct hdac_ext_bus_ops hdac_ops = {
618 	.hdev_attach = hdac_hda_dev_probe,
619 	.hdev_detach = hdac_hda_dev_remove,
620 };
621 
622 struct hdac_ext_bus_ops *snd_soc_hdac_hda_get_ops(void)
623 {
624 	return &hdac_ops;
625 }
626 EXPORT_SYMBOL_GPL(snd_soc_hdac_hda_get_ops);
627 
628 MODULE_LICENSE("GPL v2");
629 MODULE_DESCRIPTION("ASoC Extensions for legacy HDA Drivers");
630 MODULE_AUTHOR("Rakesh Ughreja<rakesh.a.ughreja@intel.com>");
631