1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright(c) 2021-2022 Intel Corporation 4 // 5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com> 6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com> 7 // 8 9 #include <linux/debugfs.h> 10 #include <linux/device.h> 11 #include <sound/hda_register.h> 12 #include <sound/hdaudio_ext.h> 13 #include <sound/pcm_params.h> 14 #include <sound/soc-acpi.h> 15 #include <sound/soc-acpi-intel-match.h> 16 #include <sound/soc-component.h> 17 #include "avs.h" 18 #include "path.h" 19 #include "pcm.h" 20 #include "topology.h" 21 #include "../../codecs/hda.h" 22 23 struct avs_dma_data { 24 struct avs_tplg_path_template *template; 25 struct avs_path *path; 26 struct avs_dev *adev; 27 28 /* LINK-stream utilized in BE operations while HOST in FE ones. */ 29 union { 30 struct hdac_ext_stream *link_stream; 31 struct hdac_ext_stream *host_stream; 32 }; 33 34 struct work_struct period_elapsed_work; 35 struct snd_pcm_substream *substream; 36 }; 37 38 static struct avs_tplg_path_template * 39 avs_dai_find_path_template(struct snd_soc_dai *dai, bool is_fe, int direction) 40 { 41 struct snd_soc_dapm_widget *dw = snd_soc_dai_get_widget(dai, direction); 42 struct snd_soc_dapm_path *dp; 43 enum snd_soc_dapm_direction dir; 44 45 if (direction == SNDRV_PCM_STREAM_CAPTURE) { 46 dir = is_fe ? SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN; 47 } else { 48 dir = is_fe ? SND_SOC_DAPM_DIR_IN : SND_SOC_DAPM_DIR_OUT; 49 } 50 51 dp = list_first_entry_or_null(&dw->edges[dir], typeof(*dp), list_node[dir]); 52 if (!dp) 53 return NULL; 54 55 /* Get the other widget, with actual path template data */ 56 dw = (dp->source == dw) ? dp->sink : dp->source; 57 58 return dw->priv; 59 } 60 61 static void avs_period_elapsed_work(struct work_struct *work) 62 { 63 struct avs_dma_data *data = container_of(work, struct avs_dma_data, period_elapsed_work); 64 65 snd_pcm_period_elapsed(data->substream); 66 } 67 68 void avs_period_elapsed(struct snd_pcm_substream *substream) 69 { 70 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 71 struct snd_soc_dai *dai = snd_soc_rtd_to_cpu(rtd, 0); 72 struct avs_dma_data *data = snd_soc_dai_get_dma_data(dai, substream); 73 74 schedule_work(&data->period_elapsed_work); 75 } 76 77 static int avs_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 78 { 79 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 80 struct avs_dev *adev = to_avs_dev(dai->component->dev); 81 struct avs_tplg_path_template *template; 82 struct avs_dma_data *data; 83 84 template = avs_dai_find_path_template(dai, !rtd->dai_link->no_pcm, substream->stream); 85 if (!template) { 86 dev_err(dai->dev, "no %s path for dai %s, invalid tplg?\n", 87 snd_pcm_stream_str(substream), dai->name); 88 return -EINVAL; 89 } 90 91 data = kzalloc(sizeof(*data), GFP_KERNEL); 92 if (!data) 93 return -ENOMEM; 94 95 data->substream = substream; 96 data->template = template; 97 data->adev = adev; 98 INIT_WORK(&data->period_elapsed_work, avs_period_elapsed_work); 99 snd_soc_dai_set_dma_data(dai, substream, data); 100 101 if (rtd->dai_link->ignore_suspend) 102 adev->num_lp_paths++; 103 104 return 0; 105 } 106 107 static void avs_dai_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 108 { 109 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 110 struct avs_dma_data *data; 111 112 data = snd_soc_dai_get_dma_data(dai, substream); 113 114 if (rtd->dai_link->ignore_suspend) 115 data->adev->num_lp_paths--; 116 117 snd_soc_dai_set_dma_data(dai, substream, NULL); 118 kfree(data); 119 } 120 121 static int avs_dai_hw_params(struct snd_pcm_substream *substream, 122 struct snd_pcm_hw_params *fe_hw_params, 123 struct snd_pcm_hw_params *be_hw_params, struct snd_soc_dai *dai, 124 int dma_id) 125 { 126 struct avs_dma_data *data; 127 struct avs_path *path; 128 int ret; 129 130 data = snd_soc_dai_get_dma_data(dai, substream); 131 132 dev_dbg(dai->dev, "%s FE hw_params str %p rtd %p", 133 __func__, substream, substream->runtime); 134 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n", 135 params_rate(fe_hw_params), params_channels(fe_hw_params), 136 params_width(fe_hw_params), params_physical_width(fe_hw_params)); 137 138 dev_dbg(dai->dev, "%s BE hw_params str %p rtd %p", 139 __func__, substream, substream->runtime); 140 dev_dbg(dai->dev, "rate %d chn %d vbd %d bd %d\n", 141 params_rate(be_hw_params), params_channels(be_hw_params), 142 params_width(be_hw_params), params_physical_width(be_hw_params)); 143 144 path = avs_path_create(data->adev, dma_id, data->template, fe_hw_params, be_hw_params); 145 if (IS_ERR(path)) { 146 ret = PTR_ERR(path); 147 dev_err(dai->dev, "create path failed: %d\n", ret); 148 return ret; 149 } 150 151 data->path = path; 152 return 0; 153 } 154 155 static int avs_dai_be_hw_params(struct snd_pcm_substream *substream, 156 struct snd_pcm_hw_params *be_hw_params, struct snd_soc_dai *dai, 157 int dma_id) 158 { 159 struct snd_pcm_hw_params *fe_hw_params = NULL; 160 struct snd_soc_pcm_runtime *fe, *be; 161 struct snd_soc_dpcm *dpcm; 162 163 be = snd_soc_substream_to_rtd(substream); 164 /* dpcm_fe_dai_open() guarantees the list is not empty at this point. */ 165 for_each_dpcm_fe(be, substream->stream, dpcm) { 166 fe = dpcm->fe; 167 fe_hw_params = &fe->dpcm[substream->stream].hw_params; 168 } 169 170 return avs_dai_hw_params(substream, fe_hw_params, be_hw_params, dai, dma_id); 171 } 172 173 static int avs_dai_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 174 { 175 struct avs_dma_data *data; 176 int ret; 177 178 data = snd_soc_dai_get_dma_data(dai, substream); 179 if (!data->path) 180 return 0; 181 182 ret = avs_path_reset(data->path); 183 if (ret < 0) { 184 dev_err(dai->dev, "reset path failed: %d\n", ret); 185 return ret; 186 } 187 188 ret = avs_path_pause(data->path); 189 if (ret < 0) 190 dev_err(dai->dev, "pause path failed: %d\n", ret); 191 return ret; 192 } 193 194 static int avs_dai_nonhda_be_hw_params(struct snd_pcm_substream *substream, 195 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai) 196 { 197 struct avs_dma_data *data; 198 199 data = snd_soc_dai_get_dma_data(dai, substream); 200 if (data->path) 201 return 0; 202 203 /* Actual port-id comes from topology. */ 204 return avs_dai_be_hw_params(substream, hw_params, dai, 0); 205 } 206 207 static int avs_dai_nonhda_be_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 208 { 209 struct avs_dma_data *data; 210 211 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name); 212 213 data = snd_soc_dai_get_dma_data(dai, substream); 214 if (data->path) { 215 avs_path_free(data->path); 216 data->path = NULL; 217 } 218 219 return 0; 220 } 221 222 static int avs_dai_nonhda_be_trigger(struct snd_pcm_substream *substream, int cmd, 223 struct snd_soc_dai *dai) 224 { 225 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 226 struct avs_dma_data *data; 227 int ret = 0; 228 229 data = snd_soc_dai_get_dma_data(dai, substream); 230 231 switch (cmd) { 232 case SNDRV_PCM_TRIGGER_RESUME: 233 if (rtd->dai_link->ignore_suspend) 234 break; 235 fallthrough; 236 case SNDRV_PCM_TRIGGER_START: 237 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 238 ret = avs_path_pause(data->path); 239 if (ret < 0) { 240 dev_err(dai->dev, "pause BE path failed: %d\n", ret); 241 break; 242 } 243 244 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO); 245 if (ret < 0) 246 dev_err(dai->dev, "run BE path failed: %d\n", ret); 247 break; 248 249 case SNDRV_PCM_TRIGGER_SUSPEND: 250 if (rtd->dai_link->ignore_suspend) 251 break; 252 fallthrough; 253 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 254 case SNDRV_PCM_TRIGGER_STOP: 255 ret = avs_path_pause(data->path); 256 if (ret < 0) 257 dev_err(dai->dev, "pause BE path failed: %d\n", ret); 258 259 ret = avs_path_reset(data->path); 260 if (ret < 0) 261 dev_err(dai->dev, "reset BE path failed: %d\n", ret); 262 break; 263 264 default: 265 ret = -EINVAL; 266 break; 267 } 268 269 return ret; 270 } 271 272 static const struct snd_soc_dai_ops avs_dai_nonhda_be_ops = { 273 .startup = avs_dai_startup, 274 .shutdown = avs_dai_shutdown, 275 .hw_params = avs_dai_nonhda_be_hw_params, 276 .hw_free = avs_dai_nonhda_be_hw_free, 277 .prepare = avs_dai_prepare, 278 .trigger = avs_dai_nonhda_be_trigger, 279 }; 280 281 static int avs_dai_hda_be_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 282 { 283 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 284 struct hdac_ext_stream *link_stream; 285 struct avs_dma_data *data; 286 struct hda_codec *codec; 287 int ret; 288 289 ret = avs_dai_startup(substream, dai); 290 if (ret) 291 return ret; 292 293 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev); 294 link_stream = snd_hdac_ext_stream_assign(&codec->bus->core, substream, 295 HDAC_EXT_STREAM_TYPE_LINK); 296 if (!link_stream) { 297 avs_dai_shutdown(substream, dai); 298 return -EBUSY; 299 } 300 301 data = snd_soc_dai_get_dma_data(dai, substream); 302 data->link_stream = link_stream; 303 substream->runtime->private_data = link_stream; 304 return 0; 305 } 306 307 static void avs_dai_hda_be_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 308 { 309 struct avs_dma_data *data = snd_soc_dai_get_dma_data(dai, substream); 310 311 snd_hdac_ext_stream_release(data->link_stream, HDAC_EXT_STREAM_TYPE_LINK); 312 substream->runtime->private_data = NULL; 313 avs_dai_shutdown(substream, dai); 314 } 315 316 static int avs_dai_hda_be_hw_params(struct snd_pcm_substream *substream, 317 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai) 318 { 319 struct avs_dma_data *data; 320 321 data = snd_soc_dai_get_dma_data(dai, substream); 322 if (data->path) 323 return 0; 324 325 return avs_dai_be_hw_params(substream, hw_params, dai, 326 hdac_stream(data->link_stream)->stream_tag - 1); 327 } 328 329 static int avs_dai_hda_be_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 330 { 331 struct avs_dma_data *data; 332 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 333 struct hdac_ext_stream *link_stream; 334 struct hdac_ext_link *link; 335 struct hda_codec *codec; 336 337 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name); 338 339 data = snd_soc_dai_get_dma_data(dai, substream); 340 if (!data->path) 341 return 0; 342 343 link_stream = data->link_stream; 344 link_stream->link_prepared = false; 345 avs_path_free(data->path); 346 data->path = NULL; 347 348 /* clear link <-> stream mapping */ 349 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev); 350 link = snd_hdac_ext_bus_get_hlink_by_addr(&codec->bus->core, codec->core.addr); 351 if (!link) 352 return -EINVAL; 353 354 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 355 snd_hdac_ext_bus_link_clear_stream_id(link, hdac_stream(link_stream)->stream_tag); 356 357 return 0; 358 } 359 360 static int avs_dai_hda_be_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 361 { 362 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 363 struct snd_pcm_runtime *runtime = substream->runtime; 364 const struct snd_soc_pcm_stream *stream_info; 365 struct hdac_ext_stream *link_stream; 366 struct hdac_ext_link *link; 367 struct avs_dma_data *data; 368 struct hda_codec *codec; 369 struct hdac_bus *bus; 370 unsigned int format_val; 371 unsigned int bits; 372 int ret; 373 374 data = snd_soc_dai_get_dma_data(dai, substream); 375 link_stream = data->link_stream; 376 377 if (link_stream->link_prepared) 378 return 0; 379 380 codec = dev_to_hda_codec(snd_soc_rtd_to_codec(rtd, 0)->dev); 381 bus = &codec->bus->core; 382 stream_info = snd_soc_dai_get_pcm_stream(dai, substream->stream); 383 bits = snd_hdac_stream_format_bits(runtime->format, runtime->subformat, 384 stream_info->sig_bits); 385 format_val = snd_hdac_stream_format(runtime->channels, bits, runtime->rate); 386 387 snd_hdac_ext_stream_decouple(bus, link_stream, true); 388 snd_hdac_ext_stream_reset(link_stream); 389 snd_hdac_ext_stream_setup(link_stream, format_val); 390 391 link = snd_hdac_ext_bus_get_hlink_by_addr(bus, codec->core.addr); 392 if (!link) 393 return -EINVAL; 394 395 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 396 snd_hdac_ext_bus_link_set_stream_id(link, hdac_stream(link_stream)->stream_tag); 397 398 ret = avs_dai_prepare(substream, dai); 399 if (ret) 400 return ret; 401 402 link_stream->link_prepared = true; 403 return 0; 404 } 405 406 static int avs_dai_hda_be_trigger(struct snd_pcm_substream *substream, int cmd, 407 struct snd_soc_dai *dai) 408 { 409 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 410 struct avs_dma_data *data; 411 int ret = 0; 412 413 dev_dbg(dai->dev, "entry %s cmd=%d\n", __func__, cmd); 414 415 data = snd_soc_dai_get_dma_data(dai, substream); 416 417 switch (cmd) { 418 case SNDRV_PCM_TRIGGER_RESUME: 419 if (rtd->dai_link->ignore_suspend) 420 break; 421 fallthrough; 422 case SNDRV_PCM_TRIGGER_START: 423 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 424 snd_hdac_ext_stream_start(data->link_stream); 425 426 ret = avs_path_pause(data->path); 427 if (ret < 0) { 428 dev_err(dai->dev, "pause BE path failed: %d\n", ret); 429 break; 430 } 431 432 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO); 433 if (ret < 0) 434 dev_err(dai->dev, "run BE path failed: %d\n", ret); 435 break; 436 437 case SNDRV_PCM_TRIGGER_SUSPEND: 438 if (rtd->dai_link->ignore_suspend) 439 break; 440 fallthrough; 441 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 442 case SNDRV_PCM_TRIGGER_STOP: 443 ret = avs_path_pause(data->path); 444 if (ret < 0) 445 dev_err(dai->dev, "pause BE path failed: %d\n", ret); 446 447 snd_hdac_ext_stream_clear(data->link_stream); 448 449 ret = avs_path_reset(data->path); 450 if (ret < 0) 451 dev_err(dai->dev, "reset BE path failed: %d\n", ret); 452 break; 453 454 default: 455 ret = -EINVAL; 456 break; 457 } 458 459 return ret; 460 } 461 462 static const struct snd_soc_dai_ops avs_dai_hda_be_ops = { 463 .startup = avs_dai_hda_be_startup, 464 .shutdown = avs_dai_hda_be_shutdown, 465 .hw_params = avs_dai_hda_be_hw_params, 466 .hw_free = avs_dai_hda_be_hw_free, 467 .prepare = avs_dai_hda_be_prepare, 468 .trigger = avs_dai_hda_be_trigger, 469 }; 470 471 static int hw_rule_param_size(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) 472 { 473 struct snd_interval *interval = hw_param_interval(params, rule->var); 474 struct snd_interval to; 475 476 snd_interval_any(&to); 477 to.integer = interval->integer; 478 to.max = interval->max; 479 /* 480 * Commonly 2ms buffer size is used in HDA scenarios whereas 4ms is used 481 * when streaming through GPDMA. Align to the latter to account for both. 482 */ 483 to.min = params_rate(params) / 1000 * 4; 484 485 if (rule->var == SNDRV_PCM_HW_PARAM_PERIOD_SIZE) 486 to.min /= params_periods(params); 487 488 return snd_interval_refine(interval, &to); 489 } 490 491 static int avs_pcm_hw_constraints_init(struct snd_pcm_substream *substream) 492 { 493 struct snd_pcm_runtime *runtime = substream->runtime; 494 int ret; 495 496 ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 497 if (ret < 0) 498 return ret; 499 500 /* Avoid wrap-around with wall-clock. */ 501 ret = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 20, 178000000); 502 if (ret < 0) 503 return ret; 504 505 /* Adjust buffer and period size based on the audio format. */ 506 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, hw_rule_param_size, NULL, 507 SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_CHANNELS, 508 SNDRV_PCM_HW_PARAM_RATE, -1); 509 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, hw_rule_param_size, NULL, 510 SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_CHANNELS, 511 SNDRV_PCM_HW_PARAM_RATE, -1); 512 513 return 0; 514 } 515 516 static int avs_dai_fe_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 517 { 518 struct hdac_ext_stream *host_stream; 519 struct avs_dma_data *data; 520 struct hdac_bus *bus; 521 int ret; 522 523 ret = avs_pcm_hw_constraints_init(substream); 524 if (ret) 525 return ret; 526 527 ret = avs_dai_startup(substream, dai); 528 if (ret) 529 return ret; 530 531 data = snd_soc_dai_get_dma_data(dai, substream); 532 bus = &data->adev->base.core; 533 534 host_stream = snd_hdac_ext_stream_assign(bus, substream, HDAC_EXT_STREAM_TYPE_HOST); 535 if (!host_stream) { 536 avs_dai_shutdown(substream, dai); 537 return -EBUSY; 538 } 539 540 data->host_stream = host_stream; 541 snd_pcm_set_sync(substream); 542 543 dev_dbg(dai->dev, "%s fe STARTUP tag %d str %p", 544 __func__, hdac_stream(host_stream)->stream_tag, substream); 545 546 return 0; 547 } 548 549 static void avs_dai_fe_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 550 { 551 struct avs_dma_data *data; 552 553 data = snd_soc_dai_get_dma_data(dai, substream); 554 555 snd_hdac_ext_stream_release(data->host_stream, HDAC_EXT_STREAM_TYPE_HOST); 556 avs_dai_shutdown(substream, dai); 557 } 558 559 static int avs_dai_fe_hw_params(struct snd_pcm_substream *substream, 560 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai) 561 { 562 struct snd_pcm_hw_params *be_hw_params = NULL; 563 struct snd_soc_pcm_runtime *fe, *be; 564 struct snd_soc_dpcm *dpcm; 565 struct avs_dma_data *data; 566 struct hdac_ext_stream *host_stream; 567 int ret; 568 569 data = snd_soc_dai_get_dma_data(dai, substream); 570 if (data->path) 571 return 0; 572 573 host_stream = data->host_stream; 574 575 hdac_stream(host_stream)->bufsize = 0; 576 hdac_stream(host_stream)->period_bytes = 0; 577 hdac_stream(host_stream)->format_val = 0; 578 579 fe = snd_soc_substream_to_rtd(substream); 580 /* dpcm_fe_dai_open() guarantees the list is not empty at this point. */ 581 for_each_dpcm_be(fe, substream->stream, dpcm) { 582 be = dpcm->be; 583 be_hw_params = &be->dpcm[substream->stream].hw_params; 584 } 585 586 ret = avs_dai_hw_params(substream, hw_params, be_hw_params, dai, 587 hdac_stream(host_stream)->stream_tag - 1); 588 if (ret) 589 goto create_err; 590 591 ret = avs_path_bind(data->path); 592 if (ret < 0) { 593 dev_err(dai->dev, "bind FE <-> BE failed: %d\n", ret); 594 goto bind_err; 595 } 596 597 return 0; 598 599 bind_err: 600 avs_path_free(data->path); 601 data->path = NULL; 602 create_err: 603 snd_pcm_lib_free_pages(substream); 604 return ret; 605 } 606 607 static int __avs_dai_fe_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 608 { 609 struct avs_dma_data *data; 610 struct hdac_ext_stream *host_stream; 611 int ret; 612 613 dev_dbg(dai->dev, "%s fe HW_FREE str %p rtd %p", 614 __func__, substream, substream->runtime); 615 616 data = snd_soc_dai_get_dma_data(dai, substream); 617 if (!data->path) 618 return 0; 619 620 host_stream = data->host_stream; 621 622 ret = avs_path_unbind(data->path); 623 if (ret < 0) 624 dev_err(dai->dev, "unbind FE <-> BE failed: %d\n", ret); 625 626 avs_path_free(data->path); 627 data->path = NULL; 628 snd_hdac_stream_cleanup(hdac_stream(host_stream)); 629 hdac_stream(host_stream)->prepared = false; 630 631 return ret; 632 } 633 634 static int avs_dai_fe_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 635 { 636 int ret; 637 638 ret = __avs_dai_fe_hw_free(substream, dai); 639 snd_pcm_lib_free_pages(substream); 640 641 return ret; 642 } 643 644 static int avs_dai_fe_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) 645 { 646 struct snd_pcm_runtime *runtime = substream->runtime; 647 const struct snd_soc_pcm_stream *stream_info; 648 struct avs_dma_data *data; 649 struct hdac_ext_stream *host_stream; 650 unsigned int format_val; 651 struct hdac_bus *bus; 652 unsigned int bits; 653 int ret; 654 655 data = snd_soc_dai_get_dma_data(dai, substream); 656 host_stream = data->host_stream; 657 658 if (hdac_stream(host_stream)->prepared) 659 return 0; 660 661 bus = hdac_stream(host_stream)->bus; 662 snd_hdac_ext_stream_decouple(bus, data->host_stream, true); 663 snd_hdac_stream_reset(hdac_stream(host_stream)); 664 665 stream_info = snd_soc_dai_get_pcm_stream(dai, substream->stream); 666 bits = snd_hdac_stream_format_bits(runtime->format, runtime->subformat, 667 stream_info->sig_bits); 668 format_val = snd_hdac_stream_format(runtime->channels, bits, runtime->rate); 669 670 ret = snd_hdac_stream_set_params(hdac_stream(host_stream), format_val); 671 if (ret < 0) 672 return ret; 673 674 ret = snd_hdac_ext_host_stream_setup(host_stream, false); 675 if (ret < 0) 676 return ret; 677 678 ret = avs_dai_prepare(substream, dai); 679 if (ret) 680 return ret; 681 682 hdac_stream(host_stream)->prepared = true; 683 return 0; 684 } 685 686 static void avs_hda_stream_start(struct hdac_bus *bus, struct hdac_ext_stream *host_stream) 687 { 688 struct hdac_stream *first_running = NULL; 689 struct hdac_stream *pos; 690 struct avs_dev *adev = hdac_to_avs(bus); 691 692 list_for_each_entry(pos, &bus->stream_list, list) { 693 if (pos->running) { 694 if (first_running) 695 break; /* more than one running */ 696 first_running = pos; 697 } 698 } 699 700 /* 701 * If host_stream is a CAPTURE stream and will be the only one running, 702 * disable L1SEN to avoid sound clipping. 703 */ 704 if (!first_running) { 705 if (hdac_stream(host_stream)->direction == SNDRV_PCM_STREAM_CAPTURE) 706 avs_hda_l1sen_enable(adev, false); 707 snd_hdac_stream_start(hdac_stream(host_stream)); 708 return; 709 } 710 711 snd_hdac_stream_start(hdac_stream(host_stream)); 712 /* 713 * If host_stream is the first stream to break the rule above, 714 * re-enable L1SEN. 715 */ 716 if (list_entry_is_head(pos, &bus->stream_list, list) && 717 first_running->direction == SNDRV_PCM_STREAM_CAPTURE) 718 avs_hda_l1sen_enable(adev, true); 719 } 720 721 static void avs_hda_stream_stop(struct hdac_bus *bus, struct hdac_ext_stream *host_stream) 722 { 723 struct hdac_stream *first_running = NULL; 724 struct hdac_stream *pos; 725 struct avs_dev *adev = hdac_to_avs(bus); 726 727 list_for_each_entry(pos, &bus->stream_list, list) { 728 if (pos == hdac_stream(host_stream)) 729 continue; /* ignore stream that is about to be stopped */ 730 if (pos->running) { 731 if (first_running) 732 break; /* more than one running */ 733 first_running = pos; 734 } 735 } 736 737 /* 738 * If host_stream is a CAPTURE stream and is the only one running, 739 * re-enable L1SEN. 740 */ 741 if (!first_running) { 742 snd_hdac_stream_stop(hdac_stream(host_stream)); 743 if (hdac_stream(host_stream)->direction == SNDRV_PCM_STREAM_CAPTURE) 744 avs_hda_l1sen_enable(adev, true); 745 return; 746 } 747 748 /* 749 * If by stopping host_stream there is only a single, CAPTURE stream running 750 * left, disable L1SEN to avoid sound clipping. 751 */ 752 if (list_entry_is_head(pos, &bus->stream_list, list) && 753 first_running->direction == SNDRV_PCM_STREAM_CAPTURE) 754 avs_hda_l1sen_enable(adev, false); 755 756 snd_hdac_stream_stop(hdac_stream(host_stream)); 757 } 758 759 static int avs_dai_fe_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai) 760 { 761 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 762 struct avs_dma_data *data; 763 struct hdac_ext_stream *host_stream; 764 struct hdac_bus *bus; 765 unsigned long flags; 766 int ret = 0; 767 768 data = snd_soc_dai_get_dma_data(dai, substream); 769 host_stream = data->host_stream; 770 bus = hdac_stream(host_stream)->bus; 771 772 switch (cmd) { 773 case SNDRV_PCM_TRIGGER_RESUME: 774 if (rtd->dai_link->ignore_suspend) 775 break; 776 fallthrough; 777 case SNDRV_PCM_TRIGGER_START: 778 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 779 spin_lock_irqsave(&bus->reg_lock, flags); 780 avs_hda_stream_start(bus, host_stream); 781 spin_unlock_irqrestore(&bus->reg_lock, flags); 782 783 /* Timeout on DRSM poll shall not stop the resume so ignore the result. */ 784 if (cmd == SNDRV_PCM_TRIGGER_RESUME) 785 snd_hdac_stream_wait_drsm(hdac_stream(host_stream)); 786 787 ret = avs_path_pause(data->path); 788 if (ret < 0) { 789 dev_err(dai->dev, "pause FE path failed: %d\n", ret); 790 break; 791 } 792 793 ret = avs_path_run(data->path, AVS_TPLG_TRIGGER_AUTO); 794 if (ret < 0) 795 dev_err(dai->dev, "run FE path failed: %d\n", ret); 796 797 break; 798 799 case SNDRV_PCM_TRIGGER_SUSPEND: 800 if (rtd->dai_link->ignore_suspend) 801 break; 802 fallthrough; 803 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 804 case SNDRV_PCM_TRIGGER_STOP: 805 ret = avs_path_pause(data->path); 806 if (ret < 0) 807 dev_err(dai->dev, "pause FE path failed: %d\n", ret); 808 809 spin_lock_irqsave(&bus->reg_lock, flags); 810 avs_hda_stream_stop(bus, host_stream); 811 spin_unlock_irqrestore(&bus->reg_lock, flags); 812 813 ret = avs_path_reset(data->path); 814 if (ret < 0) 815 dev_err(dai->dev, "reset FE path failed: %d\n", ret); 816 break; 817 818 default: 819 ret = -EINVAL; 820 break; 821 } 822 823 return ret; 824 } 825 826 const struct snd_soc_dai_ops avs_dai_fe_ops = { 827 .startup = avs_dai_fe_startup, 828 .shutdown = avs_dai_fe_shutdown, 829 .hw_params = avs_dai_fe_hw_params, 830 .hw_free = avs_dai_fe_hw_free, 831 .prepare = avs_dai_fe_prepare, 832 .trigger = avs_dai_fe_trigger, 833 }; 834 835 static ssize_t topology_name_read(struct file *file, char __user *user_buf, size_t count, 836 loff_t *ppos) 837 { 838 struct snd_soc_component *component = file->private_data; 839 struct snd_soc_card *card = component->card; 840 struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev); 841 char buf[64]; 842 size_t len; 843 844 len = scnprintf(buf, sizeof(buf), "%s/%s\n", component->driver->topology_name_prefix, 845 mach->tplg_filename); 846 847 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 848 } 849 850 static const struct file_operations topology_name_fops = { 851 .open = simple_open, 852 .read = topology_name_read, 853 .llseek = default_llseek, 854 }; 855 856 static int avs_component_load_libraries(struct avs_soc_component *acomp) 857 { 858 struct avs_tplg *tplg = acomp->tplg; 859 struct avs_dev *adev = to_avs_dev(acomp->base.dev); 860 int ret; 861 862 if (!tplg->num_libs) 863 return 0; 864 865 /* Parent device may be asleep and library loading involves IPCs. */ 866 ret = pm_runtime_resume_and_get(adev->dev); 867 if (ret < 0) 868 return ret; 869 870 avs_hda_power_gating_enable(adev, false); 871 avs_hda_clock_gating_enable(adev, false); 872 avs_hda_l1sen_enable(adev, false); 873 874 ret = avs_dsp_load_libraries(adev, tplg->libs, tplg->num_libs); 875 876 avs_hda_l1sen_enable(adev, true); 877 avs_hda_clock_gating_enable(adev, true); 878 avs_hda_power_gating_enable(adev, true); 879 880 if (!ret) 881 ret = avs_module_info_init(adev, false); 882 883 pm_runtime_mark_last_busy(adev->dev); 884 pm_runtime_put_autosuspend(adev->dev); 885 886 return ret; 887 } 888 889 static int avs_component_probe(struct snd_soc_component *component) 890 { 891 struct snd_soc_card *card = component->card; 892 struct snd_soc_acpi_mach *mach; 893 struct avs_soc_component *acomp; 894 struct avs_dev *adev; 895 char *filename; 896 int ret; 897 898 dev_dbg(card->dev, "probing %s card %s\n", component->name, card->name); 899 mach = dev_get_platdata(card->dev); 900 acomp = to_avs_soc_component(component); 901 adev = to_avs_dev(component->dev); 902 903 acomp->tplg = avs_tplg_new(component); 904 if (!acomp->tplg) 905 return -ENOMEM; 906 907 if (!mach->tplg_filename) 908 goto finalize; 909 910 /* Load specified topology and create debugfs for it. */ 911 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix, 912 mach->tplg_filename); 913 if (!filename) 914 return -ENOMEM; 915 916 ret = avs_load_topology(component, filename); 917 kfree(filename); 918 if (ret == -ENOENT && !strncmp(mach->tplg_filename, "hda-", 4)) { 919 unsigned int vendor_id; 920 921 if (sscanf(mach->tplg_filename, "hda-%08x-tplg.bin", &vendor_id) != 1) 922 return ret; 923 924 if (((vendor_id >> 16) & 0xFFFF) == 0x8086) 925 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, 926 "hda-8086-generic-tplg.bin"); 927 else 928 mach->tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, 929 "hda-generic-tplg.bin"); 930 931 filename = kasprintf(GFP_KERNEL, "%s/%s", component->driver->topology_name_prefix, 932 mach->tplg_filename); 933 if (!filename) 934 return -ENOMEM; 935 936 dev_info(card->dev, "trying to load fallback topology %s\n", mach->tplg_filename); 937 ret = avs_load_topology(component, filename); 938 kfree(filename); 939 } 940 if (ret < 0) 941 return ret; 942 943 ret = avs_component_load_libraries(acomp); 944 if (ret < 0) { 945 dev_err(card->dev, "libraries loading failed: %d\n", ret); 946 goto err_load_libs; 947 } 948 949 finalize: 950 debugfs_create_file("topology_name", 0444, component->debugfs_root, component, 951 &topology_name_fops); 952 953 mutex_lock(&adev->comp_list_mutex); 954 list_add_tail(&acomp->node, &adev->comp_list); 955 mutex_unlock(&adev->comp_list_mutex); 956 957 return 0; 958 959 err_load_libs: 960 avs_remove_topology(component); 961 return ret; 962 } 963 964 static void avs_component_remove(struct snd_soc_component *component) 965 { 966 struct avs_soc_component *acomp = to_avs_soc_component(component); 967 struct snd_soc_acpi_mach *mach; 968 struct avs_dev *adev = to_avs_dev(component->dev); 969 int ret; 970 971 mach = dev_get_platdata(component->card->dev); 972 973 mutex_lock(&adev->comp_list_mutex); 974 list_del(&acomp->node); 975 mutex_unlock(&adev->comp_list_mutex); 976 977 if (mach->tplg_filename) { 978 ret = avs_remove_topology(component); 979 if (ret < 0) 980 dev_err(component->dev, "unload topology failed: %d\n", ret); 981 } 982 } 983 984 static int avs_dai_resume_hw_params(struct snd_soc_dai *dai, struct avs_dma_data *data) 985 { 986 struct snd_pcm_substream *substream; 987 struct snd_soc_pcm_runtime *rtd; 988 int ret; 989 990 substream = data->substream; 991 rtd = snd_soc_substream_to_rtd(substream); 992 993 ret = dai->driver->ops->hw_params(substream, &rtd->dpcm[substream->stream].hw_params, dai); 994 if (ret) 995 dev_err(dai->dev, "hw_params on resume failed: %d\n", ret); 996 997 return ret; 998 } 999 1000 static int avs_dai_resume_fe_prepare(struct snd_soc_dai *dai, struct avs_dma_data *data) 1001 { 1002 struct hdac_ext_stream *host_stream; 1003 struct hdac_stream *hstream; 1004 struct hdac_bus *bus; 1005 int ret; 1006 1007 host_stream = data->host_stream; 1008 hstream = hdac_stream(host_stream); 1009 bus = hdac_stream(host_stream)->bus; 1010 1011 /* Set DRSM before programming stream and position registers. */ 1012 snd_hdac_stream_drsm_enable(bus, true, hstream->index); 1013 1014 ret = dai->driver->ops->prepare(data->substream, dai); 1015 if (ret) { 1016 dev_err(dai->dev, "prepare FE on resume failed: %d\n", ret); 1017 return ret; 1018 } 1019 1020 writel(host_stream->pphcllpl, host_stream->pphc_addr + AZX_REG_PPHCLLPL); 1021 writel(host_stream->pphcllpu, host_stream->pphc_addr + AZX_REG_PPHCLLPU); 1022 writel(host_stream->pphcldpl, host_stream->pphc_addr + AZX_REG_PPHCLDPL); 1023 writel(host_stream->pphcldpu, host_stream->pphc_addr + AZX_REG_PPHCLDPU); 1024 1025 /* As per HW spec recommendation, program LPIB and DPIB to the same value. */ 1026 snd_hdac_stream_set_lpib(hstream, hstream->lpib); 1027 snd_hdac_stream_set_dpibr(bus, hstream, hstream->lpib); 1028 1029 return 0; 1030 } 1031 1032 static int avs_dai_resume_be_prepare(struct snd_soc_dai *dai, struct avs_dma_data *data) 1033 { 1034 int ret; 1035 1036 ret = dai->driver->ops->prepare(data->substream, dai); 1037 if (ret) 1038 dev_err(dai->dev, "prepare BE on resume failed: %d\n", ret); 1039 1040 return ret; 1041 } 1042 1043 static int avs_dai_suspend_fe_hw_free(struct snd_soc_dai *dai, struct avs_dma_data *data) 1044 { 1045 struct hdac_ext_stream *host_stream; 1046 int ret; 1047 1048 host_stream = data->host_stream; 1049 1050 /* Store position addresses so we can resume from them later on. */ 1051 hdac_stream(host_stream)->lpib = snd_hdac_stream_get_pos_lpib(hdac_stream(host_stream)); 1052 host_stream->pphcllpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPL); 1053 host_stream->pphcllpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLLPU); 1054 host_stream->pphcldpl = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPL); 1055 host_stream->pphcldpu = readl(host_stream->pphc_addr + AZX_REG_PPHCLDPU); 1056 1057 ret = __avs_dai_fe_hw_free(data->substream, dai); 1058 if (ret < 0) 1059 dev_err(dai->dev, "hw_free FE on suspend failed: %d\n", ret); 1060 1061 return ret; 1062 } 1063 1064 static int avs_dai_suspend_be_hw_free(struct snd_soc_dai *dai, struct avs_dma_data *data) 1065 { 1066 int ret; 1067 1068 ret = dai->driver->ops->hw_free(data->substream, dai); 1069 if (ret < 0) 1070 dev_err(dai->dev, "hw_free BE on suspend failed: %d\n", ret); 1071 1072 return ret; 1073 } 1074 1075 static int avs_component_pm_op(struct snd_soc_component *component, bool be, 1076 int (*op)(struct snd_soc_dai *, struct avs_dma_data *)) 1077 { 1078 struct snd_soc_pcm_runtime *rtd; 1079 struct avs_dma_data *data; 1080 struct snd_soc_dai *dai; 1081 int ret; 1082 1083 for_each_component_dais(component, dai) { 1084 data = snd_soc_dai_dma_data_get_playback(dai); 1085 if (data) { 1086 rtd = snd_soc_substream_to_rtd(data->substream); 1087 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) { 1088 ret = op(dai, data); 1089 if (ret < 0) { 1090 __snd_pcm_set_state(data->substream->runtime, 1091 SNDRV_PCM_STATE_DISCONNECTED); 1092 return ret; 1093 } 1094 } 1095 } 1096 1097 data = snd_soc_dai_dma_data_get_capture(dai); 1098 if (data) { 1099 rtd = snd_soc_substream_to_rtd(data->substream); 1100 if (rtd->dai_link->no_pcm == be && !rtd->dai_link->ignore_suspend) { 1101 ret = op(dai, data); 1102 if (ret < 0) { 1103 __snd_pcm_set_state(data->substream->runtime, 1104 SNDRV_PCM_STATE_DISCONNECTED); 1105 return ret; 1106 } 1107 } 1108 } 1109 } 1110 1111 return 0; 1112 } 1113 1114 static int avs_component_resume_hw_params(struct snd_soc_component *component, bool be) 1115 { 1116 return avs_component_pm_op(component, be, &avs_dai_resume_hw_params); 1117 } 1118 1119 static int avs_component_resume_prepare(struct snd_soc_component *component, bool be) 1120 { 1121 int (*prepare_cb)(struct snd_soc_dai *dai, struct avs_dma_data *data); 1122 1123 if (be) 1124 prepare_cb = &avs_dai_resume_be_prepare; 1125 else 1126 prepare_cb = &avs_dai_resume_fe_prepare; 1127 1128 return avs_component_pm_op(component, be, prepare_cb); 1129 } 1130 1131 static int avs_component_suspend_hw_free(struct snd_soc_component *component, bool be) 1132 { 1133 int (*hw_free_cb)(struct snd_soc_dai *dai, struct avs_dma_data *data); 1134 1135 if (be) 1136 hw_free_cb = &avs_dai_suspend_be_hw_free; 1137 else 1138 hw_free_cb = &avs_dai_suspend_fe_hw_free; 1139 1140 return avs_component_pm_op(component, be, hw_free_cb); 1141 } 1142 1143 static int avs_component_suspend(struct snd_soc_component *component) 1144 { 1145 int ret; 1146 1147 /* 1148 * When freeing paths, FEs need to be first as they perform 1149 * path unbinding. 1150 */ 1151 ret = avs_component_suspend_hw_free(component, false); 1152 if (ret) 1153 return ret; 1154 1155 return avs_component_suspend_hw_free(component, true); 1156 } 1157 1158 static int avs_component_resume(struct snd_soc_component *component) 1159 { 1160 int ret; 1161 1162 /* 1163 * When creating paths, FEs need to be last as they perform 1164 * path binding. 1165 */ 1166 ret = avs_component_resume_hw_params(component, true); 1167 if (ret) 1168 return ret; 1169 1170 ret = avs_component_resume_hw_params(component, false); 1171 if (ret) 1172 return ret; 1173 1174 /* It is expected that the LINK stream is prepared first. */ 1175 ret = avs_component_resume_prepare(component, true); 1176 if (ret) 1177 return ret; 1178 1179 return avs_component_resume_prepare(component, false); 1180 } 1181 1182 static const struct snd_pcm_hardware avs_pcm_hardware = { 1183 .info = SNDRV_PCM_INFO_MMAP | 1184 SNDRV_PCM_INFO_MMAP_VALID | 1185 SNDRV_PCM_INFO_INTERLEAVED | 1186 SNDRV_PCM_INFO_PAUSE | 1187 SNDRV_PCM_INFO_RESUME | 1188 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP, 1189 .formats = SNDRV_PCM_FMTBIT_S16_LE | 1190 SNDRV_PCM_FMTBIT_S32_LE, 1191 .subformats = SNDRV_PCM_SUBFMTBIT_MSBITS_20 | 1192 SNDRV_PCM_SUBFMTBIT_MSBITS_24 | 1193 SNDRV_PCM_SUBFMTBIT_MSBITS_MAX, 1194 .buffer_bytes_max = AZX_MAX_BUF_SIZE, 1195 .period_bytes_min = 128, 1196 .period_bytes_max = AZX_MAX_BUF_SIZE / 2, 1197 .periods_min = 2, 1198 .periods_max = AZX_MAX_FRAG, 1199 .fifo_size = 0, 1200 }; 1201 1202 static int avs_component_open(struct snd_soc_component *component, 1203 struct snd_pcm_substream *substream) 1204 { 1205 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 1206 1207 /* only FE DAI links are handled here */ 1208 if (rtd->dai_link->no_pcm) 1209 return 0; 1210 1211 return snd_soc_set_runtime_hwparams(substream, &avs_pcm_hardware); 1212 } 1213 1214 static unsigned int avs_hda_stream_dpib_read(struct hdac_ext_stream *stream) 1215 { 1216 return readl(hdac_stream(stream)->bus->remap_addr + AZX_REG_VS_SDXDPIB_XBASE + 1217 (AZX_REG_VS_SDXDPIB_XINTERVAL * hdac_stream(stream)->index)); 1218 } 1219 1220 static snd_pcm_uframes_t 1221 avs_component_pointer(struct snd_soc_component *component, struct snd_pcm_substream *substream) 1222 { 1223 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 1224 struct avs_dma_data *data; 1225 struct hdac_ext_stream *host_stream; 1226 unsigned int pos; 1227 1228 data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream); 1229 if (!data->host_stream) 1230 return 0; 1231 1232 host_stream = data->host_stream; 1233 pos = avs_hda_stream_dpib_read(host_stream); 1234 1235 if (pos >= hdac_stream(host_stream)->bufsize) 1236 pos = 0; 1237 1238 return bytes_to_frames(substream->runtime, pos); 1239 } 1240 1241 static int avs_component_mmap(struct snd_soc_component *component, 1242 struct snd_pcm_substream *substream, 1243 struct vm_area_struct *vma) 1244 { 1245 return snd_pcm_lib_default_mmap(substream, vma); 1246 } 1247 1248 #define MAX_PREALLOC_SIZE (32 * 1024 * 1024) 1249 1250 static int avs_component_construct(struct snd_soc_component *component, 1251 struct snd_soc_pcm_runtime *rtd) 1252 { 1253 struct snd_soc_dai *dai = snd_soc_rtd_to_cpu(rtd, 0); 1254 struct snd_pcm *pcm = rtd->pcm; 1255 1256 if (dai->driver->playback.channels_min) 1257 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, 1258 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0, 1259 MAX_PREALLOC_SIZE); 1260 1261 if (dai->driver->capture.channels_min) 1262 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 1263 SNDRV_DMA_TYPE_DEV_SG, component->dev, 0, 1264 MAX_PREALLOC_SIZE); 1265 1266 return 0; 1267 } 1268 1269 static const struct snd_soc_component_driver avs_component_driver = { 1270 .name = "avs-pcm", 1271 .probe = avs_component_probe, 1272 .remove = avs_component_remove, 1273 .suspend = avs_component_suspend, 1274 .resume = avs_component_resume, 1275 .open = avs_component_open, 1276 .pointer = avs_component_pointer, 1277 .mmap = avs_component_mmap, 1278 .pcm_construct = avs_component_construct, 1279 .module_get_upon_open = 1, /* increment refcount when a pcm is opened */ 1280 .topology_name_prefix = "intel/avs", 1281 }; 1282 1283 int avs_soc_component_register(struct device *dev, const char *name, 1284 const struct snd_soc_component_driver *drv, 1285 struct snd_soc_dai_driver *cpu_dais, int num_cpu_dais) 1286 { 1287 struct avs_soc_component *acomp; 1288 int ret; 1289 1290 acomp = devm_kzalloc(dev, sizeof(*acomp), GFP_KERNEL); 1291 if (!acomp) 1292 return -ENOMEM; 1293 1294 ret = snd_soc_component_initialize(&acomp->base, drv, dev); 1295 if (ret < 0) 1296 return ret; 1297 1298 /* force name change after ASoC is done with its init */ 1299 acomp->base.name = name; 1300 INIT_LIST_HEAD(&acomp->node); 1301 1302 return snd_soc_add_component(&acomp->base, cpu_dais, num_cpu_dais); 1303 } 1304 1305 static struct snd_soc_dai_driver dmic_cpu_dais[] = { 1306 { 1307 .name = "DMIC Pin", 1308 .ops = &avs_dai_nonhda_be_ops, 1309 .capture = { 1310 .stream_name = "DMIC Rx", 1311 .channels_min = 1, 1312 .channels_max = 4, 1313 .rates = SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_48000, 1314 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE, 1315 }, 1316 }, 1317 { 1318 .name = "DMIC WoV Pin", 1319 .ops = &avs_dai_nonhda_be_ops, 1320 .capture = { 1321 .stream_name = "DMIC WoV Rx", 1322 .channels_min = 1, 1323 .channels_max = 4, 1324 .rates = SNDRV_PCM_RATE_16000, 1325 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1326 }, 1327 }, 1328 }; 1329 1330 int avs_dmic_platform_register(struct avs_dev *adev, const char *name) 1331 { 1332 return avs_soc_component_register(adev->dev, name, &avs_component_driver, dmic_cpu_dais, 1333 ARRAY_SIZE(dmic_cpu_dais)); 1334 } 1335 1336 static const struct snd_soc_dai_driver i2s_dai_template = { 1337 .ops = &avs_dai_nonhda_be_ops, 1338 .playback = { 1339 .channels_min = 1, 1340 .channels_max = 8, 1341 .rates = SNDRV_PCM_RATE_8000_192000 | 1342 SNDRV_PCM_RATE_12000 | 1343 SNDRV_PCM_RATE_24000 | 1344 SNDRV_PCM_RATE_128000, 1345 .formats = SNDRV_PCM_FMTBIT_S16_LE | 1346 SNDRV_PCM_FMTBIT_S32_LE, 1347 .subformats = SNDRV_PCM_SUBFMTBIT_MSBITS_20 | 1348 SNDRV_PCM_SUBFMTBIT_MSBITS_24 | 1349 SNDRV_PCM_SUBFMTBIT_MSBITS_MAX, 1350 }, 1351 .capture = { 1352 .channels_min = 1, 1353 .channels_max = 8, 1354 .rates = SNDRV_PCM_RATE_8000_192000 | 1355 SNDRV_PCM_RATE_12000 | 1356 SNDRV_PCM_RATE_24000 | 1357 SNDRV_PCM_RATE_128000, 1358 .formats = SNDRV_PCM_FMTBIT_S16_LE | 1359 SNDRV_PCM_FMTBIT_S32_LE, 1360 .subformats = SNDRV_PCM_SUBFMTBIT_MSBITS_20 | 1361 SNDRV_PCM_SUBFMTBIT_MSBITS_24 | 1362 SNDRV_PCM_SUBFMTBIT_MSBITS_MAX, 1363 }, 1364 }; 1365 1366 int avs_i2s_platform_register(struct avs_dev *adev, const char *name, unsigned long port_mask, 1367 unsigned long *tdms) 1368 { 1369 struct snd_soc_dai_driver *cpus, *dai; 1370 size_t ssp_count, cpu_count; 1371 int i, j; 1372 1373 ssp_count = adev->hw_cfg.i2s_caps.ctrl_count; 1374 1375 cpu_count = 0; 1376 for_each_set_bit(i, &port_mask, ssp_count) 1377 if (!tdms || test_bit(0, &tdms[i])) 1378 cpu_count++; 1379 if (tdms) 1380 for_each_set_bit(i, &port_mask, ssp_count) 1381 cpu_count += hweight_long(tdms[i]); 1382 1383 cpus = devm_kzalloc(adev->dev, sizeof(*cpus) * cpu_count, GFP_KERNEL); 1384 if (!cpus) 1385 return -ENOMEM; 1386 1387 dai = cpus; 1388 for_each_set_bit(i, &port_mask, ssp_count) { 1389 if (!tdms || test_bit(0, &tdms[i])) { 1390 memcpy(dai, &i2s_dai_template, sizeof(*dai)); 1391 1392 dai->name = 1393 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d Pin", i); 1394 dai->playback.stream_name = 1395 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Tx", i); 1396 dai->capture.stream_name = 1397 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d Rx", i); 1398 1399 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name) 1400 return -ENOMEM; 1401 dai++; 1402 } 1403 } 1404 1405 if (!tdms) 1406 goto plat_register; 1407 1408 for_each_set_bit(i, &port_mask, ssp_count) { 1409 for_each_set_bit(j, &tdms[i], ssp_count) { 1410 memcpy(dai, &i2s_dai_template, sizeof(*dai)); 1411 1412 dai->name = 1413 devm_kasprintf(adev->dev, GFP_KERNEL, "SSP%d:%d Pin", i, j); 1414 dai->playback.stream_name = 1415 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Tx", i, j); 1416 dai->capture.stream_name = 1417 devm_kasprintf(adev->dev, GFP_KERNEL, "ssp%d:%d Rx", i, j); 1418 1419 if (!dai->name || !dai->playback.stream_name || !dai->capture.stream_name) 1420 return -ENOMEM; 1421 dai++; 1422 } 1423 } 1424 1425 plat_register: 1426 return avs_soc_component_register(adev->dev, name, &avs_component_driver, cpus, cpu_count); 1427 } 1428 1429 /* HD-Audio CPU DAI template */ 1430 static const struct snd_soc_dai_driver hda_cpu_dai = { 1431 .ops = &avs_dai_hda_be_ops, 1432 .playback = { 1433 .channels_min = 1, 1434 .channels_max = 8, 1435 .rates = SNDRV_PCM_RATE_8000_192000, 1436 .formats = SNDRV_PCM_FMTBIT_S16_LE | 1437 SNDRV_PCM_FMTBIT_S32_LE, 1438 .subformats = SNDRV_PCM_SUBFMTBIT_MSBITS_20 | 1439 SNDRV_PCM_SUBFMTBIT_MSBITS_24 | 1440 SNDRV_PCM_SUBFMTBIT_MSBITS_MAX, 1441 }, 1442 .capture = { 1443 .channels_min = 1, 1444 .channels_max = 8, 1445 .rates = SNDRV_PCM_RATE_8000_192000, 1446 .formats = SNDRV_PCM_FMTBIT_S16_LE | 1447 SNDRV_PCM_FMTBIT_S32_LE, 1448 .subformats = SNDRV_PCM_SUBFMTBIT_MSBITS_20 | 1449 SNDRV_PCM_SUBFMTBIT_MSBITS_24 | 1450 SNDRV_PCM_SUBFMTBIT_MSBITS_MAX, 1451 }, 1452 }; 1453 1454 static void avs_component_hda_unregister_dais(struct snd_soc_component *component) 1455 { 1456 struct snd_soc_acpi_mach *mach; 1457 struct snd_soc_dai *dai, *save; 1458 struct hda_codec *codec; 1459 char name[32]; 1460 1461 mach = dev_get_platdata(component->card->dev); 1462 codec = mach->pdata; 1463 snprintf(name, sizeof(name), "%s-cpu", dev_name(&codec->core.dev)); 1464 1465 for_each_component_dais_safe(component, dai, save) { 1466 int stream; 1467 1468 if (!strstr(dai->driver->name, name)) 1469 continue; 1470 1471 for_each_pcm_streams(stream) 1472 snd_soc_dapm_free_widget(snd_soc_dai_get_widget(dai, stream)); 1473 1474 snd_soc_unregister_dai(dai); 1475 } 1476 } 1477 1478 static int avs_component_hda_probe(struct snd_soc_component *component) 1479 { 1480 struct snd_soc_dapm_context *dapm; 1481 struct snd_soc_dai_driver *dais; 1482 struct snd_soc_acpi_mach *mach; 1483 struct hda_codec *codec; 1484 struct hda_pcm *pcm; 1485 const char *cname; 1486 int pcm_count = 0, ret, i; 1487 1488 mach = dev_get_platdata(component->card->dev); 1489 if (!mach) 1490 return -EINVAL; 1491 1492 codec = mach->pdata; 1493 if (list_empty(&codec->pcm_list_head)) 1494 return -EINVAL; 1495 list_for_each_entry(pcm, &codec->pcm_list_head, list) 1496 pcm_count++; 1497 1498 dais = devm_kcalloc(component->dev, pcm_count, sizeof(*dais), 1499 GFP_KERNEL); 1500 if (!dais) 1501 return -ENOMEM; 1502 1503 cname = dev_name(&codec->core.dev); 1504 dapm = snd_soc_component_get_dapm(component); 1505 pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list); 1506 1507 for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) { 1508 struct snd_soc_dai *dai; 1509 1510 memcpy(&dais[i], &hda_cpu_dai, sizeof(*dais)); 1511 dais[i].id = i; 1512 dais[i].name = devm_kasprintf(component->dev, GFP_KERNEL, 1513 "%s-cpu%d", cname, i); 1514 if (!dais[i].name) { 1515 ret = -ENOMEM; 1516 goto exit; 1517 } 1518 1519 if (pcm->stream[0].substreams) { 1520 dais[i].playback.stream_name = 1521 devm_kasprintf(component->dev, GFP_KERNEL, 1522 "%s-cpu%d Tx", cname, i); 1523 if (!dais[i].playback.stream_name) { 1524 ret = -ENOMEM; 1525 goto exit; 1526 } 1527 1528 if (!hda_codec_is_display(codec)) { 1529 dais[i].playback.formats = pcm->stream[0].formats; 1530 dais[i].playback.subformats = pcm->stream[0].subformats; 1531 dais[i].playback.rates = pcm->stream[0].rates; 1532 dais[i].playback.channels_min = pcm->stream[0].channels_min; 1533 dais[i].playback.channels_max = pcm->stream[0].channels_max; 1534 dais[i].playback.sig_bits = pcm->stream[0].maxbps; 1535 } 1536 } 1537 1538 if (pcm->stream[1].substreams) { 1539 dais[i].capture.stream_name = 1540 devm_kasprintf(component->dev, GFP_KERNEL, 1541 "%s-cpu%d Rx", cname, i); 1542 if (!dais[i].capture.stream_name) { 1543 ret = -ENOMEM; 1544 goto exit; 1545 } 1546 1547 if (!hda_codec_is_display(codec)) { 1548 dais[i].capture.formats = pcm->stream[1].formats; 1549 dais[i].capture.subformats = pcm->stream[1].subformats; 1550 dais[i].capture.rates = pcm->stream[1].rates; 1551 dais[i].capture.channels_min = pcm->stream[1].channels_min; 1552 dais[i].capture.channels_max = pcm->stream[1].channels_max; 1553 dais[i].capture.sig_bits = pcm->stream[1].maxbps; 1554 } 1555 } 1556 1557 dai = snd_soc_register_dai(component, &dais[i], false); 1558 if (!dai) { 1559 dev_err(component->dev, "register dai for %s failed\n", 1560 pcm->name); 1561 ret = -EINVAL; 1562 goto exit; 1563 } 1564 1565 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 1566 if (ret < 0) { 1567 dev_err(component->dev, "create widgets failed: %d\n", 1568 ret); 1569 snd_soc_unregister_dai(dai); 1570 goto exit; 1571 } 1572 } 1573 1574 ret = avs_component_probe(component); 1575 exit: 1576 if (ret) 1577 avs_component_hda_unregister_dais(component); 1578 1579 return ret; 1580 } 1581 1582 static void avs_component_hda_remove(struct snd_soc_component *component) 1583 { 1584 avs_component_remove(component); 1585 avs_component_hda_unregister_dais(component); 1586 } 1587 1588 static int avs_component_hda_open(struct snd_soc_component *component, 1589 struct snd_pcm_substream *substream) 1590 { 1591 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 1592 1593 if (!rtd->dai_link->no_pcm) { 1594 struct snd_pcm_hardware hwparams = avs_pcm_hardware; 1595 struct snd_soc_pcm_runtime *be; 1596 struct snd_soc_dpcm *dpcm; 1597 int dir = substream->stream; 1598 1599 /* 1600 * Support the DPCM reparenting while still fulfilling expectations of HDAudio 1601 * common code - a valid stream pointer at substream->runtime->private_data - 1602 * by having all FEs point to the same private data. 1603 */ 1604 for_each_dpcm_be(rtd, dir, dpcm) { 1605 struct snd_pcm_substream *be_substream; 1606 1607 be = dpcm->be; 1608 if (be->dpcm[dir].users == 1) 1609 break; 1610 1611 be_substream = snd_soc_dpcm_get_substream(be, dir); 1612 substream->runtime->private_data = be_substream->runtime->private_data; 1613 break; 1614 } 1615 1616 /* RESUME unsupported for de-coupled HD-Audio capture. */ 1617 if (dir == SNDRV_PCM_STREAM_CAPTURE) 1618 hwparams.info &= ~SNDRV_PCM_INFO_RESUME; 1619 1620 return snd_soc_set_runtime_hwparams(substream, &hwparams); 1621 } 1622 1623 return 0; 1624 } 1625 1626 static const struct snd_soc_component_driver avs_hda_component_driver = { 1627 .name = "avs-hda-pcm", 1628 .probe = avs_component_hda_probe, 1629 .remove = avs_component_hda_remove, 1630 .suspend = avs_component_suspend, 1631 .resume = avs_component_resume, 1632 .open = avs_component_hda_open, 1633 .pointer = avs_component_pointer, 1634 .mmap = avs_component_mmap, 1635 .pcm_construct = avs_component_construct, 1636 /* 1637 * hda platform component's probe() is dependent on 1638 * codec->pcm_list_head, it needs to be initialized after codec 1639 * component. remove_order is here for completeness sake 1640 */ 1641 .probe_order = SND_SOC_COMP_ORDER_LATE, 1642 .remove_order = SND_SOC_COMP_ORDER_EARLY, 1643 .module_get_upon_open = 1, 1644 .topology_name_prefix = "intel/avs", 1645 }; 1646 1647 int avs_hda_platform_register(struct avs_dev *adev, const char *name) 1648 { 1649 return avs_soc_component_register(adev->dev, name, 1650 &avs_hda_component_driver, NULL, 0); 1651 } 1652