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
hdac_hda_dai_set_stream(struct snd_soc_dai * dai,void * stream,int direction)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
hdac_hda_dai_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)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
hdac_hda_dai_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
hdac_hda_dai_prepare(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
hdac_hda_dai_open(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
hdac_hda_dai_close(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
snd_soc_find_pcm_from_dai(struct hdac_hda_priv * hda_pvt,struct snd_soc_dai * dai)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
is_hdmi_codec(struct hda_codec * hcodec)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
hdac_hda_codec_probe(struct snd_soc_component * component)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
hdac_hda_codec_remove(struct snd_soc_component * component)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
hdac_hda_dev_probe(struct hdac_device * hdev)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
hdac_hda_dev_remove(struct hdac_device * hdev)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
snd_soc_hdac_hda_get_ops(void)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