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