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