1 /* 2 * skl-topology.c - Implements Platform component ALSA controls/widget 3 * handlers. 4 * 5 * Copyright (C) 2014-2015 Intel Corp 6 * Author: Jeeja KP <jeeja.kp@intel.com> 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 */ 18 19 #include <linux/slab.h> 20 #include <linux/types.h> 21 #include <linux/firmware.h> 22 #include <sound/soc.h> 23 #include <sound/soc-topology.h> 24 #include "skl-sst-dsp.h" 25 #include "skl-sst-ipc.h" 26 #include "skl-topology.h" 27 #include "skl.h" 28 #include "skl-tplg-interface.h" 29 30 #define SKL_CH_FIXUP_MASK (1 << 0) 31 #define SKL_RATE_FIXUP_MASK (1 << 1) 32 #define SKL_FMT_FIXUP_MASK (1 << 2) 33 34 /* 35 * SKL DSP driver modelling uses only few DAPM widgets so for rest we will 36 * ignore. This helpers checks if the SKL driver handles this widget type 37 */ 38 static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w) 39 { 40 switch (w->id) { 41 case snd_soc_dapm_dai_link: 42 case snd_soc_dapm_dai_in: 43 case snd_soc_dapm_aif_in: 44 case snd_soc_dapm_aif_out: 45 case snd_soc_dapm_dai_out: 46 case snd_soc_dapm_switch: 47 return false; 48 default: 49 return true; 50 } 51 } 52 53 /* 54 * Each pipelines needs memory to be allocated. Check if we have free memory 55 * from available pool. Then only add this to pool 56 * This is freed when pipe is deleted 57 * Note: DSP does actual memory management we only keep track for complete 58 * pool 59 */ 60 static bool skl_tplg_alloc_pipe_mem(struct skl *skl, 61 struct skl_module_cfg *mconfig) 62 { 63 struct skl_sst *ctx = skl->skl_sst; 64 65 if (skl->resource.mem + mconfig->pipe->memory_pages > 66 skl->resource.max_mem) { 67 dev_err(ctx->dev, 68 "%s: module_id %d instance %d\n", __func__, 69 mconfig->id.module_id, 70 mconfig->id.instance_id); 71 dev_err(ctx->dev, 72 "exceeds ppl memory available %d mem %d\n", 73 skl->resource.max_mem, skl->resource.mem); 74 return false; 75 } 76 77 skl->resource.mem += mconfig->pipe->memory_pages; 78 return true; 79 } 80 81 /* 82 * Pipeline needs needs DSP CPU resources for computation, this is 83 * quantified in MCPS (Million Clocks Per Second) required for module/pipe 84 * 85 * Each pipelines needs mcps to be allocated. Check if we have mcps for this 86 * pipe. This adds the mcps to driver counter 87 * This is removed on pipeline delete 88 */ 89 static bool skl_tplg_alloc_pipe_mcps(struct skl *skl, 90 struct skl_module_cfg *mconfig) 91 { 92 struct skl_sst *ctx = skl->skl_sst; 93 94 if (skl->resource.mcps + mconfig->mcps > skl->resource.max_mcps) { 95 dev_err(ctx->dev, 96 "%s: module_id %d instance %d\n", __func__, 97 mconfig->id.module_id, mconfig->id.instance_id); 98 dev_err(ctx->dev, 99 "exceeds ppl memory available %d > mem %d\n", 100 skl->resource.max_mcps, skl->resource.mcps); 101 return false; 102 } 103 104 skl->resource.mcps += mconfig->mcps; 105 return true; 106 } 107 108 /* 109 * Free the mcps when tearing down 110 */ 111 static void 112 skl_tplg_free_pipe_mcps(struct skl *skl, struct skl_module_cfg *mconfig) 113 { 114 skl->resource.mcps -= mconfig->mcps; 115 } 116 117 /* 118 * Free the memory when tearing down 119 */ 120 static void 121 skl_tplg_free_pipe_mem(struct skl *skl, struct skl_module_cfg *mconfig) 122 { 123 skl->resource.mem -= mconfig->pipe->memory_pages; 124 } 125 126 127 static void skl_dump_mconfig(struct skl_sst *ctx, 128 struct skl_module_cfg *mcfg) 129 { 130 dev_dbg(ctx->dev, "Dumping config\n"); 131 dev_dbg(ctx->dev, "Input Format:\n"); 132 dev_dbg(ctx->dev, "channels = %d\n", mcfg->in_fmt.channels); 133 dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->in_fmt.s_freq); 134 dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->in_fmt.ch_cfg); 135 dev_dbg(ctx->dev, "valid bit depth = %d\n", 136 mcfg->in_fmt.valid_bit_depth); 137 dev_dbg(ctx->dev, "Output Format:\n"); 138 dev_dbg(ctx->dev, "channels = %d\n", mcfg->out_fmt.channels); 139 dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->out_fmt.s_freq); 140 dev_dbg(ctx->dev, "valid bit depth = %d\n", 141 mcfg->out_fmt.valid_bit_depth); 142 dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->out_fmt.ch_cfg); 143 } 144 145 static void skl_tplg_update_params(struct skl_module_fmt *fmt, 146 struct skl_pipe_params *params, int fixup) 147 { 148 if (fixup & SKL_RATE_FIXUP_MASK) 149 fmt->s_freq = params->s_freq; 150 if (fixup & SKL_CH_FIXUP_MASK) 151 fmt->channels = params->ch; 152 if (fixup & SKL_FMT_FIXUP_MASK) 153 fmt->valid_bit_depth = params->s_fmt; 154 } 155 156 /* 157 * A pipeline may have modules which impact the pcm parameters, like SRC, 158 * channel converter, format converter. 159 * We need to calculate the output params by applying the 'fixup' 160 * Topology will tell driver which type of fixup is to be applied by 161 * supplying the fixup mask, so based on that we calculate the output 162 * 163 * Now In FE the pcm hw_params is source/target format. Same is applicable 164 * for BE with its hw_params invoked. 165 * here based on FE, BE pipeline and direction we calculate the input and 166 * outfix and then apply that for a module 167 */ 168 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg, 169 struct skl_pipe_params *params, bool is_fe) 170 { 171 int in_fixup, out_fixup; 172 struct skl_module_fmt *in_fmt, *out_fmt; 173 174 in_fmt = &m_cfg->in_fmt; 175 out_fmt = &m_cfg->out_fmt; 176 177 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) { 178 if (is_fe) { 179 in_fixup = m_cfg->params_fixup; 180 out_fixup = (~m_cfg->converter) & 181 m_cfg->params_fixup; 182 } else { 183 out_fixup = m_cfg->params_fixup; 184 in_fixup = (~m_cfg->converter) & 185 m_cfg->params_fixup; 186 } 187 } else { 188 if (is_fe) { 189 out_fixup = m_cfg->params_fixup; 190 in_fixup = (~m_cfg->converter) & 191 m_cfg->params_fixup; 192 } else { 193 in_fixup = m_cfg->params_fixup; 194 out_fixup = (~m_cfg->converter) & 195 m_cfg->params_fixup; 196 } 197 } 198 199 skl_tplg_update_params(in_fmt, params, in_fixup); 200 skl_tplg_update_params(out_fmt, params, out_fixup); 201 } 202 203 /* 204 * A module needs input and output buffers, which are dependent upon pcm 205 * params, so once we have calculate params, we need buffer calculation as 206 * well. 207 */ 208 static void skl_tplg_update_buffer_size(struct skl_sst *ctx, 209 struct skl_module_cfg *mcfg) 210 { 211 int multiplier = 1; 212 213 if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT) 214 multiplier = 5; 215 216 mcfg->ibs = (mcfg->in_fmt.s_freq / 1000) * 217 (mcfg->in_fmt.channels) * 218 (mcfg->in_fmt.bit_depth >> 3) * 219 multiplier; 220 221 mcfg->obs = (mcfg->out_fmt.s_freq / 1000) * 222 (mcfg->out_fmt.channels) * 223 (mcfg->out_fmt.bit_depth >> 3) * 224 multiplier; 225 } 226 227 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w, 228 struct skl_sst *ctx) 229 { 230 struct skl_module_cfg *m_cfg = w->priv; 231 struct skl_pipe_params *params = m_cfg->pipe->p_params; 232 int p_conn_type = m_cfg->pipe->conn_type; 233 bool is_fe; 234 235 if (!m_cfg->params_fixup) 236 return; 237 238 dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n", 239 w->name); 240 241 skl_dump_mconfig(ctx, m_cfg); 242 243 if (p_conn_type == SKL_PIPE_CONN_TYPE_FE) 244 is_fe = true; 245 else 246 is_fe = false; 247 248 skl_tplg_update_params_fixup(m_cfg, params, is_fe); 249 skl_tplg_update_buffer_size(ctx, m_cfg); 250 251 dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n", 252 w->name); 253 254 skl_dump_mconfig(ctx, m_cfg); 255 } 256 257 /* 258 * A pipe can have multiple modules, each of them will be a DAPM widget as 259 * well. While managing a pipeline we need to get the list of all the 260 * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps 261 * to get the SKL type widgets in that pipeline 262 */ 263 static int skl_tplg_alloc_pipe_widget(struct device *dev, 264 struct snd_soc_dapm_widget *w, struct skl_pipe *pipe) 265 { 266 struct skl_module_cfg *src_module = NULL; 267 struct snd_soc_dapm_path *p = NULL; 268 struct skl_pipe_module *p_module = NULL; 269 270 p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL); 271 if (!p_module) 272 return -ENOMEM; 273 274 p_module->w = w; 275 list_add_tail(&p_module->node, &pipe->w_list); 276 277 snd_soc_dapm_widget_for_each_sink_path(w, p) { 278 if ((p->sink->priv == NULL) 279 && (!is_skl_dsp_widget_type(w))) 280 continue; 281 282 if ((p->sink->priv != NULL) && p->connect 283 && is_skl_dsp_widget_type(p->sink)) { 284 285 src_module = p->sink->priv; 286 if (pipe->ppl_id == src_module->pipe->ppl_id) 287 skl_tplg_alloc_pipe_widget(dev, 288 p->sink, pipe); 289 } 290 } 291 return 0; 292 } 293 294 /* 295 * Inside a pipe instance, we can have various modules. These modules need 296 * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by 297 * skl_init_module() routine, so invoke that for all modules in a pipeline 298 */ 299 static int 300 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe) 301 { 302 struct skl_pipe_module *w_module; 303 struct snd_soc_dapm_widget *w; 304 struct skl_module_cfg *mconfig; 305 struct skl_sst *ctx = skl->skl_sst; 306 int ret = 0; 307 308 list_for_each_entry(w_module, &pipe->w_list, node) { 309 w = w_module->w; 310 mconfig = w->priv; 311 312 /* check resource available */ 313 if (!skl_tplg_alloc_pipe_mcps(skl, mconfig)) 314 return -ENOMEM; 315 316 /* 317 * apply fix/conversion to module params based on 318 * FE/BE params 319 */ 320 skl_tplg_update_module_params(w, ctx); 321 ret = skl_init_module(ctx, mconfig, NULL); 322 if (ret < 0) 323 return ret; 324 } 325 326 return 0; 327 } 328 329 /* 330 * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we 331 * need create the pipeline. So we do following: 332 * - check the resources 333 * - Create the pipeline 334 * - Initialize the modules in pipeline 335 * - finally bind all modules together 336 */ 337 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w, 338 struct skl *skl) 339 { 340 int ret; 341 struct skl_module_cfg *mconfig = w->priv; 342 struct skl_pipe_module *w_module; 343 struct skl_pipe *s_pipe = mconfig->pipe; 344 struct skl_module_cfg *src_module = NULL, *dst_module; 345 struct skl_sst *ctx = skl->skl_sst; 346 347 /* check resource available */ 348 if (!skl_tplg_alloc_pipe_mcps(skl, mconfig)) 349 return -EBUSY; 350 351 if (!skl_tplg_alloc_pipe_mem(skl, mconfig)) 352 return -ENOMEM; 353 354 /* 355 * Create a list of modules for pipe. 356 * This list contains modules from source to sink 357 */ 358 ret = skl_create_pipeline(ctx, mconfig->pipe); 359 if (ret < 0) 360 return ret; 361 362 /* 363 * we create a w_list of all widgets in that pipe. This list is not 364 * freed on PMD event as widgets within a pipe are static. This 365 * saves us cycles to get widgets in pipe every time. 366 * 367 * So if we have already initialized all the widgets of a pipeline 368 * we skip, so check for list_empty and create the list if empty 369 */ 370 if (list_empty(&s_pipe->w_list)) { 371 ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe); 372 if (ret < 0) 373 return ret; 374 } 375 376 /* Init all pipe modules from source to sink */ 377 ret = skl_tplg_init_pipe_modules(skl, s_pipe); 378 if (ret < 0) 379 return ret; 380 381 /* Bind modules from source to sink */ 382 list_for_each_entry(w_module, &s_pipe->w_list, node) { 383 dst_module = w_module->w->priv; 384 385 if (src_module == NULL) { 386 src_module = dst_module; 387 continue; 388 } 389 390 ret = skl_bind_modules(ctx, src_module, dst_module); 391 if (ret < 0) 392 return ret; 393 394 src_module = dst_module; 395 } 396 397 return 0; 398 } 399 400 /* 401 * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA 402 * we need to do following: 403 * - Bind to sink pipeline 404 * Since the sink pipes can be running and we don't get mixer event on 405 * connect for already running mixer, we need to find the sink pipes 406 * here and bind to them. This way dynamic connect works. 407 * - Start sink pipeline, if not running 408 * - Then run current pipe 409 */ 410 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w, 411 struct skl *skl) 412 { 413 struct snd_soc_dapm_path *p; 414 struct skl_dapm_path_list *path_list; 415 struct snd_soc_dapm_widget *source, *sink; 416 struct skl_module_cfg *src_mconfig, *sink_mconfig; 417 struct skl_sst *ctx = skl->skl_sst; 418 int ret = 0; 419 420 source = w; 421 src_mconfig = source->priv; 422 423 /* 424 * find which sink it is connected to, bind with the sink, 425 * if sink is not started, start sink pipe first, then start 426 * this pipe 427 */ 428 snd_soc_dapm_widget_for_each_source_path(w, p) { 429 if (!p->connect) 430 continue; 431 432 dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name); 433 dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name); 434 435 /* 436 * here we will check widgets in sink pipelines, so that 437 * can be any widgets type and we are only interested if 438 * they are ones used for SKL so check that first 439 */ 440 if ((p->sink->priv != NULL) && 441 is_skl_dsp_widget_type(p->sink)) { 442 443 sink = p->sink; 444 src_mconfig = source->priv; 445 sink_mconfig = sink->priv; 446 447 /* Bind source to sink, mixin is always source */ 448 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig); 449 if (ret) 450 return ret; 451 452 /* Start sinks pipe first */ 453 if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) { 454 ret = skl_run_pipe(ctx, sink_mconfig->pipe); 455 if (ret) 456 return ret; 457 } 458 459 path_list = kzalloc( 460 sizeof(struct skl_dapm_path_list), 461 GFP_KERNEL); 462 if (path_list == NULL) 463 return -ENOMEM; 464 465 /* Add connected path to one global list */ 466 path_list->dapm_path = p; 467 list_add_tail(&path_list->node, &skl->dapm_path_list); 468 break; 469 } 470 } 471 472 /* Start source pipe last after starting all sinks */ 473 ret = skl_run_pipe(ctx, src_mconfig->pipe); 474 if (ret) 475 return ret; 476 477 return 0; 478 } 479 480 /* 481 * in the Post-PMU event of mixer we need to do following: 482 * - Check if this pipe is running 483 * - if not, then 484 * - bind this pipeline to its source pipeline 485 * if source pipe is already running, this means it is a dynamic 486 * connection and we need to bind only to that pipe 487 * - start this pipeline 488 */ 489 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w, 490 struct skl *skl) 491 { 492 int ret = 0; 493 struct snd_soc_dapm_path *p; 494 struct snd_soc_dapm_widget *source, *sink; 495 struct skl_module_cfg *src_mconfig, *sink_mconfig; 496 struct skl_sst *ctx = skl->skl_sst; 497 int src_pipe_started = 0; 498 499 sink = w; 500 sink_mconfig = sink->priv; 501 502 /* 503 * If source pipe is already started, that means source is driving 504 * one more sink before this sink got connected, Since source is 505 * started, bind this sink to source and start this pipe. 506 */ 507 snd_soc_dapm_widget_for_each_sink_path(w, p) { 508 if (!p->connect) 509 continue; 510 511 dev_dbg(ctx->dev, "sink widget=%s\n", w->name); 512 dev_dbg(ctx->dev, "src widget=%s\n", p->source->name); 513 514 /* 515 * here we will check widgets in sink pipelines, so that 516 * can be any widgets type and we are only interested if 517 * they are ones used for SKL so check that first 518 */ 519 if ((p->source->priv != NULL) && 520 is_skl_dsp_widget_type(p->source)) { 521 source = p->source; 522 src_mconfig = source->priv; 523 sink_mconfig = sink->priv; 524 src_pipe_started = 1; 525 526 /* 527 * check pipe state, then no need to bind or start 528 * the pipe 529 */ 530 if (src_mconfig->pipe->state != SKL_PIPE_STARTED) 531 src_pipe_started = 0; 532 } 533 } 534 535 if (src_pipe_started) { 536 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig); 537 if (ret) 538 return ret; 539 540 ret = skl_run_pipe(ctx, sink_mconfig->pipe); 541 } 542 543 return ret; 544 } 545 546 /* 547 * in the Pre-PMD event of mixer we need to do following: 548 * - Stop the pipe 549 * - find the source connections and remove that from dapm_path_list 550 * - unbind with source pipelines if still connected 551 */ 552 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w, 553 struct skl *skl) 554 { 555 struct snd_soc_dapm_widget *source, *sink; 556 struct skl_module_cfg *src_mconfig, *sink_mconfig; 557 int ret = 0, path_found = 0; 558 struct skl_dapm_path_list *path_list, *tmp_list; 559 struct skl_sst *ctx = skl->skl_sst; 560 561 sink = w; 562 sink_mconfig = sink->priv; 563 564 /* Stop the pipe */ 565 ret = skl_stop_pipe(ctx, sink_mconfig->pipe); 566 if (ret) 567 return ret; 568 569 /* 570 * This list, dapm_path_list handling here does not need any locks 571 * as we are under dapm lock while handling widget events. 572 * List can be manipulated safely only under dapm widgets handler 573 * routines 574 */ 575 list_for_each_entry_safe(path_list, tmp_list, 576 &skl->dapm_path_list, node) { 577 if (path_list->dapm_path->sink == sink) { 578 dev_dbg(ctx->dev, "Path found = %s\n", 579 path_list->dapm_path->name); 580 source = path_list->dapm_path->source; 581 src_mconfig = source->priv; 582 path_found = 1; 583 584 list_del(&path_list->node); 585 kfree(path_list); 586 break; 587 } 588 } 589 590 /* 591 * If path_found == 1, that means pmd for source pipe has 592 * not occurred, source is connected to some other sink. 593 * so its responsibility of sink to unbind itself from source. 594 */ 595 if (path_found) { 596 ret = skl_stop_pipe(ctx, src_mconfig->pipe); 597 if (ret < 0) 598 return ret; 599 600 ret = skl_unbind_modules(ctx, src_mconfig, sink_mconfig); 601 } 602 603 return ret; 604 } 605 606 /* 607 * in the Post-PMD event of mixer we need to do following: 608 * - Free the mcps used 609 * - Free the mem used 610 * - Unbind the modules within the pipeline 611 * - Delete the pipeline (modules are not required to be explicitly 612 * deleted, pipeline delete is enough here 613 */ 614 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w, 615 struct skl *skl) 616 { 617 struct skl_module_cfg *mconfig = w->priv; 618 struct skl_pipe_module *w_module; 619 struct skl_module_cfg *src_module = NULL, *dst_module; 620 struct skl_sst *ctx = skl->skl_sst; 621 struct skl_pipe *s_pipe = mconfig->pipe; 622 int ret = 0; 623 624 skl_tplg_free_pipe_mcps(skl, mconfig); 625 626 list_for_each_entry(w_module, &s_pipe->w_list, node) { 627 dst_module = w_module->w->priv; 628 629 if (src_module == NULL) { 630 src_module = dst_module; 631 continue; 632 } 633 634 ret = skl_unbind_modules(ctx, src_module, dst_module); 635 if (ret < 0) 636 return ret; 637 638 src_module = dst_module; 639 } 640 641 ret = skl_delete_pipe(ctx, mconfig->pipe); 642 skl_tplg_free_pipe_mem(skl, mconfig); 643 644 return ret; 645 } 646 647 /* 648 * in the Post-PMD event of PGA we need to do following: 649 * - Free the mcps used 650 * - Stop the pipeline 651 * - In source pipe is connected, unbind with source pipelines 652 */ 653 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w, 654 struct skl *skl) 655 { 656 struct snd_soc_dapm_widget *source, *sink; 657 struct skl_module_cfg *src_mconfig, *sink_mconfig; 658 int ret = 0, path_found = 0; 659 struct skl_dapm_path_list *path_list, *tmp_path_list; 660 struct skl_sst *ctx = skl->skl_sst; 661 662 source = w; 663 src_mconfig = source->priv; 664 665 skl_tplg_free_pipe_mcps(skl, src_mconfig); 666 /* Stop the pipe since this is a mixin module */ 667 ret = skl_stop_pipe(ctx, src_mconfig->pipe); 668 if (ret) 669 return ret; 670 671 list_for_each_entry_safe(path_list, tmp_path_list, &skl->dapm_path_list, node) { 672 if (path_list->dapm_path->source == source) { 673 dev_dbg(ctx->dev, "Path found = %s\n", 674 path_list->dapm_path->name); 675 sink = path_list->dapm_path->sink; 676 sink_mconfig = sink->priv; 677 path_found = 1; 678 679 list_del(&path_list->node); 680 kfree(path_list); 681 break; 682 } 683 } 684 685 /* 686 * This is a connector and if path is found that means 687 * unbind between source and sink has not happened yet 688 */ 689 if (path_found) { 690 ret = skl_stop_pipe(ctx, src_mconfig->pipe); 691 if (ret < 0) 692 return ret; 693 694 ret = skl_unbind_modules(ctx, src_mconfig, sink_mconfig); 695 } 696 697 return ret; 698 } 699 700 /* 701 * In modelling, we assume there will be ONLY one mixer in a pipeline. If 702 * mixer is not required then it is treated as static mixer aka vmixer with 703 * a hard path to source module 704 * So we don't need to check if source is started or not as hard path puts 705 * dependency on each other 706 */ 707 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w, 708 struct snd_kcontrol *k, int event) 709 { 710 struct snd_soc_dapm_context *dapm = w->dapm; 711 struct skl *skl = get_skl_ctx(dapm->dev); 712 713 switch (event) { 714 case SND_SOC_DAPM_PRE_PMU: 715 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl); 716 717 case SND_SOC_DAPM_POST_PMD: 718 return skl_tplg_mixer_dapm_post_pmd_event(w, skl); 719 } 720 721 return 0; 722 } 723 724 /* 725 * In modelling, we assume there will be ONLY one mixer in a pipeline. If a 726 * second one is required that is created as another pipe entity. 727 * The mixer is responsible for pipe management and represent a pipeline 728 * instance 729 */ 730 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w, 731 struct snd_kcontrol *k, int event) 732 { 733 struct snd_soc_dapm_context *dapm = w->dapm; 734 struct skl *skl = get_skl_ctx(dapm->dev); 735 736 switch (event) { 737 case SND_SOC_DAPM_PRE_PMU: 738 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl); 739 740 case SND_SOC_DAPM_POST_PMU: 741 return skl_tplg_mixer_dapm_post_pmu_event(w, skl); 742 743 case SND_SOC_DAPM_PRE_PMD: 744 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl); 745 746 case SND_SOC_DAPM_POST_PMD: 747 return skl_tplg_mixer_dapm_post_pmd_event(w, skl); 748 } 749 750 return 0; 751 } 752 753 /* 754 * In modelling, we assumed rest of the modules in pipeline are PGA. But we 755 * are interested in last PGA (leaf PGA) in a pipeline to disconnect with 756 * the sink when it is running (two FE to one BE or one FE to two BE) 757 * scenarios 758 */ 759 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w, 760 struct snd_kcontrol *k, int event) 761 762 { 763 struct snd_soc_dapm_context *dapm = w->dapm; 764 struct skl *skl = get_skl_ctx(dapm->dev); 765 766 switch (event) { 767 case SND_SOC_DAPM_PRE_PMU: 768 return skl_tplg_pga_dapm_pre_pmu_event(w, skl); 769 770 case SND_SOC_DAPM_POST_PMD: 771 return skl_tplg_pga_dapm_post_pmd_event(w, skl); 772 } 773 774 return 0; 775 } 776 777 /* 778 * The FE params are passed by hw_params of the DAI. 779 * On hw_params, the params are stored in Gateway module of the FE and we 780 * need to calculate the format in DSP module configuration, that 781 * conversion is done here 782 */ 783 int skl_tplg_update_pipe_params(struct device *dev, 784 struct skl_module_cfg *mconfig, 785 struct skl_pipe_params *params) 786 { 787 struct skl_pipe *pipe = mconfig->pipe; 788 struct skl_module_fmt *format = NULL; 789 790 memcpy(pipe->p_params, params, sizeof(*params)); 791 792 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) 793 format = &mconfig->in_fmt; 794 else 795 format = &mconfig->out_fmt; 796 797 /* set the hw_params */ 798 format->s_freq = params->s_freq; 799 format->channels = params->ch; 800 format->valid_bit_depth = skl_get_bit_depth(params->s_fmt); 801 802 /* 803 * 16 bit is 16 bit container whereas 24 bit is in 32 bit 804 * container so update bit depth accordingly 805 */ 806 switch (format->valid_bit_depth) { 807 case SKL_DEPTH_16BIT: 808 format->bit_depth = format->valid_bit_depth; 809 break; 810 811 case SKL_DEPTH_24BIT: 812 case SKL_DEPTH_32BIT: 813 format->bit_depth = SKL_DEPTH_32BIT; 814 break; 815 816 default: 817 dev_err(dev, "Invalid bit depth %x for pipe\n", 818 format->valid_bit_depth); 819 return -EINVAL; 820 } 821 822 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) { 823 mconfig->ibs = (format->s_freq / 1000) * 824 (format->channels) * 825 (format->bit_depth >> 3); 826 } else { 827 mconfig->obs = (format->s_freq / 1000) * 828 (format->channels) * 829 (format->bit_depth >> 3); 830 } 831 832 return 0; 833 } 834 835 /* 836 * Query the module config for the FE DAI 837 * This is used to find the hw_params set for that DAI and apply to FE 838 * pipeline 839 */ 840 struct skl_module_cfg * 841 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream) 842 { 843 struct snd_soc_dapm_widget *w; 844 struct snd_soc_dapm_path *p = NULL; 845 846 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 847 w = dai->playback_widget; 848 snd_soc_dapm_widget_for_each_sink_path(w, p) { 849 if (p->connect && p->sink->power && 850 !is_skl_dsp_widget_type(p->sink)) 851 continue; 852 853 if (p->sink->priv) { 854 dev_dbg(dai->dev, "set params for %s\n", 855 p->sink->name); 856 return p->sink->priv; 857 } 858 } 859 } else { 860 w = dai->capture_widget; 861 snd_soc_dapm_widget_for_each_source_path(w, p) { 862 if (p->connect && p->source->power && 863 !is_skl_dsp_widget_type(p->source)) 864 continue; 865 866 if (p->source->priv) { 867 dev_dbg(dai->dev, "set params for %s\n", 868 p->source->name); 869 return p->source->priv; 870 } 871 } 872 } 873 874 return NULL; 875 } 876 877 static u8 skl_tplg_be_link_type(int dev_type) 878 { 879 int ret; 880 881 switch (dev_type) { 882 case SKL_DEVICE_BT: 883 ret = NHLT_LINK_SSP; 884 break; 885 886 case SKL_DEVICE_DMIC: 887 ret = NHLT_LINK_DMIC; 888 break; 889 890 case SKL_DEVICE_I2S: 891 ret = NHLT_LINK_SSP; 892 break; 893 894 case SKL_DEVICE_HDALINK: 895 ret = NHLT_LINK_HDA; 896 break; 897 898 default: 899 ret = NHLT_LINK_INVALID; 900 break; 901 } 902 903 return ret; 904 } 905 906 /* 907 * Fill the BE gateway parameters 908 * The BE gateway expects a blob of parameters which are kept in the ACPI 909 * NHLT blob, so query the blob for interface type (i2s/pdm) and instance. 910 * The port can have multiple settings so pick based on the PCM 911 * parameters 912 */ 913 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai, 914 struct skl_module_cfg *mconfig, 915 struct skl_pipe_params *params) 916 { 917 struct skl_pipe *pipe = mconfig->pipe; 918 struct nhlt_specific_cfg *cfg; 919 struct skl *skl = get_skl_ctx(dai->dev); 920 int link_type = skl_tplg_be_link_type(mconfig->dev_type); 921 922 memcpy(pipe->p_params, params, sizeof(*params)); 923 924 if (link_type == NHLT_LINK_HDA) 925 return 0; 926 927 /* update the blob based on virtual bus_id*/ 928 cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type, 929 params->s_fmt, params->ch, 930 params->s_freq, params->stream); 931 if (cfg) { 932 mconfig->formats_config.caps_size = cfg->size; 933 mconfig->formats_config.caps = (u32 *) &cfg->caps; 934 } else { 935 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n", 936 mconfig->vbus_id, link_type, 937 params->stream); 938 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n", 939 params->ch, params->s_freq, params->s_fmt); 940 return -EINVAL; 941 } 942 943 return 0; 944 } 945 946 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai, 947 struct snd_soc_dapm_widget *w, 948 struct skl_pipe_params *params) 949 { 950 struct snd_soc_dapm_path *p; 951 int ret = -EIO; 952 953 snd_soc_dapm_widget_for_each_source_path(w, p) { 954 if (p->connect && is_skl_dsp_widget_type(p->source) && 955 p->source->priv) { 956 957 if (!p->source->power) { 958 ret = skl_tplg_be_fill_pipe_params( 959 dai, p->source->priv, 960 params); 961 if (ret < 0) 962 return ret; 963 } else { 964 return -EBUSY; 965 } 966 } else { 967 ret = skl_tplg_be_set_src_pipe_params( 968 dai, p->source, params); 969 if (ret < 0) 970 return ret; 971 } 972 } 973 974 return ret; 975 } 976 977 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai, 978 struct snd_soc_dapm_widget *w, struct skl_pipe_params *params) 979 { 980 struct snd_soc_dapm_path *p = NULL; 981 int ret = -EIO; 982 983 snd_soc_dapm_widget_for_each_sink_path(w, p) { 984 if (p->connect && is_skl_dsp_widget_type(p->sink) && 985 p->sink->priv) { 986 987 if (!p->sink->power) { 988 ret = skl_tplg_be_fill_pipe_params( 989 dai, p->sink->priv, params); 990 if (ret < 0) 991 return ret; 992 } else { 993 return -EBUSY; 994 } 995 996 } else { 997 ret = skl_tplg_be_set_sink_pipe_params( 998 dai, p->sink, params); 999 if (ret < 0) 1000 return ret; 1001 } 1002 } 1003 1004 return ret; 1005 } 1006 1007 /* 1008 * BE hw_params can be a source parameters (capture) or sink parameters 1009 * (playback). Based on sink and source we need to either find the source 1010 * list or the sink list and set the pipeline parameters 1011 */ 1012 int skl_tplg_be_update_params(struct snd_soc_dai *dai, 1013 struct skl_pipe_params *params) 1014 { 1015 struct snd_soc_dapm_widget *w; 1016 1017 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1018 w = dai->playback_widget; 1019 1020 return skl_tplg_be_set_src_pipe_params(dai, w, params); 1021 1022 } else { 1023 w = dai->capture_widget; 1024 1025 return skl_tplg_be_set_sink_pipe_params(dai, w, params); 1026 } 1027 1028 return 0; 1029 } 1030 1031 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = { 1032 {SKL_MIXER_EVENT, skl_tplg_mixer_event}, 1033 {SKL_VMIXER_EVENT, skl_tplg_vmixer_event}, 1034 {SKL_PGA_EVENT, skl_tplg_pga_event}, 1035 }; 1036 1037 /* 1038 * The topology binary passes the pin info for a module so initialize the pin 1039 * info passed into module instance 1040 */ 1041 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin, 1042 struct skl_module_pin *m_pin, 1043 bool is_dynamic, int max_pin) 1044 { 1045 int i; 1046 1047 for (i = 0; i < max_pin; i++) { 1048 m_pin[i].id.module_id = dfw_pin[i].module_id; 1049 m_pin[i].id.instance_id = dfw_pin[i].instance_id; 1050 m_pin[i].in_use = false; 1051 m_pin[i].is_dynamic = is_dynamic; 1052 } 1053 } 1054 1055 /* 1056 * Add pipeline from topology binary into driver pipeline list 1057 * 1058 * If already added we return that instance 1059 * Otherwise we create a new instance and add into driver list 1060 */ 1061 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev, 1062 struct skl *skl, struct skl_dfw_pipe *dfw_pipe) 1063 { 1064 struct skl_pipeline *ppl; 1065 struct skl_pipe *pipe; 1066 struct skl_pipe_params *params; 1067 1068 list_for_each_entry(ppl, &skl->ppl_list, node) { 1069 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id) 1070 return ppl->pipe; 1071 } 1072 1073 ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL); 1074 if (!ppl) 1075 return NULL; 1076 1077 pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL); 1078 if (!pipe) 1079 return NULL; 1080 1081 params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL); 1082 if (!params) 1083 return NULL; 1084 1085 pipe->ppl_id = dfw_pipe->pipe_id; 1086 pipe->memory_pages = dfw_pipe->memory_pages; 1087 pipe->pipe_priority = dfw_pipe->pipe_priority; 1088 pipe->conn_type = dfw_pipe->conn_type; 1089 pipe->state = SKL_PIPE_INVALID; 1090 pipe->p_params = params; 1091 INIT_LIST_HEAD(&pipe->w_list); 1092 1093 ppl->pipe = pipe; 1094 list_add(&ppl->node, &skl->ppl_list); 1095 1096 return ppl->pipe; 1097 } 1098 1099 /* 1100 * Topology core widget load callback 1101 * 1102 * This is used to save the private data for each widget which gives 1103 * information to the driver about module and pipeline parameters which DSP 1104 * FW expects like ids, resource values, formats etc 1105 */ 1106 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt, 1107 struct snd_soc_dapm_widget *w, 1108 struct snd_soc_tplg_dapm_widget *tplg_w) 1109 { 1110 int ret; 1111 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt); 1112 struct skl *skl = ebus_to_skl(ebus); 1113 struct hdac_bus *bus = ebus_to_hbus(ebus); 1114 struct skl_module_cfg *mconfig; 1115 struct skl_pipe *pipe; 1116 struct skl_dfw_module *dfw_config = 1117 (struct skl_dfw_module *)tplg_w->priv.data; 1118 1119 if (!tplg_w->priv.size) 1120 goto bind_event; 1121 1122 mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL); 1123 1124 if (!mconfig) 1125 return -ENOMEM; 1126 1127 w->priv = mconfig; 1128 mconfig->id.module_id = dfw_config->module_id; 1129 mconfig->id.instance_id = dfw_config->instance_id; 1130 mconfig->mcps = dfw_config->max_mcps; 1131 mconfig->ibs = dfw_config->ibs; 1132 mconfig->obs = dfw_config->obs; 1133 mconfig->core_id = dfw_config->core_id; 1134 mconfig->max_in_queue = dfw_config->max_in_queue; 1135 mconfig->max_out_queue = dfw_config->max_out_queue; 1136 mconfig->is_loadable = dfw_config->is_loadable; 1137 mconfig->in_fmt.channels = dfw_config->in_fmt.channels; 1138 mconfig->in_fmt.s_freq = dfw_config->in_fmt.freq; 1139 mconfig->in_fmt.bit_depth = dfw_config->in_fmt.bit_depth; 1140 mconfig->in_fmt.valid_bit_depth = 1141 dfw_config->in_fmt.valid_bit_depth; 1142 mconfig->in_fmt.ch_cfg = dfw_config->in_fmt.ch_cfg; 1143 mconfig->out_fmt.channels = dfw_config->out_fmt.channels; 1144 mconfig->out_fmt.s_freq = dfw_config->out_fmt.freq; 1145 mconfig->out_fmt.bit_depth = dfw_config->out_fmt.bit_depth; 1146 mconfig->out_fmt.valid_bit_depth = 1147 dfw_config->out_fmt.valid_bit_depth; 1148 mconfig->out_fmt.ch_cfg = dfw_config->out_fmt.ch_cfg; 1149 mconfig->params_fixup = dfw_config->params_fixup; 1150 mconfig->converter = dfw_config->converter; 1151 mconfig->m_type = dfw_config->module_type; 1152 mconfig->vbus_id = dfw_config->vbus_id; 1153 1154 pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe); 1155 if (pipe) 1156 mconfig->pipe = pipe; 1157 1158 mconfig->dev_type = dfw_config->dev_type; 1159 mconfig->hw_conn_type = dfw_config->hw_conn_type; 1160 mconfig->time_slot = dfw_config->time_slot; 1161 mconfig->formats_config.caps_size = dfw_config->caps.caps_size; 1162 1163 mconfig->m_in_pin = devm_kzalloc(bus->dev, 1164 (mconfig->max_in_queue) * 1165 sizeof(*mconfig->m_in_pin), 1166 GFP_KERNEL); 1167 if (!mconfig->m_in_pin) 1168 return -ENOMEM; 1169 1170 mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) * 1171 sizeof(*mconfig->m_out_pin), 1172 GFP_KERNEL); 1173 if (!mconfig->m_out_pin) 1174 return -ENOMEM; 1175 1176 skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin, 1177 dfw_config->is_dynamic_in_pin, 1178 mconfig->max_in_queue); 1179 1180 skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin, 1181 dfw_config->is_dynamic_out_pin, 1182 mconfig->max_out_queue); 1183 1184 1185 if (mconfig->formats_config.caps_size == 0) 1186 goto bind_event; 1187 1188 mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev, 1189 mconfig->formats_config.caps_size, GFP_KERNEL); 1190 1191 if (mconfig->formats_config.caps == NULL) 1192 return -ENOMEM; 1193 1194 memcpy(mconfig->formats_config.caps, dfw_config->caps.caps, 1195 dfw_config->caps.caps_size); 1196 1197 bind_event: 1198 if (tplg_w->event_type == 0) { 1199 dev_dbg(bus->dev, "ASoC: No event handler required\n"); 1200 return 0; 1201 } 1202 1203 ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops, 1204 ARRAY_SIZE(skl_tplg_widget_ops), 1205 tplg_w->event_type); 1206 1207 if (ret) { 1208 dev_err(bus->dev, "%s: No matching event handlers found for %d\n", 1209 __func__, tplg_w->event_type); 1210 return -EINVAL; 1211 } 1212 1213 return 0; 1214 } 1215 1216 static struct snd_soc_tplg_ops skl_tplg_ops = { 1217 .widget_load = skl_tplg_widget_load, 1218 }; 1219 1220 /* This will be read from topology manifest, currently defined here */ 1221 #define SKL_MAX_MCPS 30000000 1222 #define SKL_FW_MAX_MEM 1000000 1223 1224 /* 1225 * SKL topology init routine 1226 */ 1227 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus) 1228 { 1229 int ret; 1230 const struct firmware *fw; 1231 struct hdac_bus *bus = ebus_to_hbus(ebus); 1232 struct skl *skl = ebus_to_skl(ebus); 1233 1234 ret = request_firmware(&fw, "dfw_sst.bin", bus->dev); 1235 if (ret < 0) { 1236 dev_err(bus->dev, "tplg fw %s load failed with %d\n", 1237 "dfw_sst.bin", ret); 1238 return ret; 1239 } 1240 1241 /* 1242 * The complete tplg for SKL is loaded as index 0, we don't use 1243 * any other index 1244 */ 1245 ret = snd_soc_tplg_component_load(&platform->component, 1246 &skl_tplg_ops, fw, 0); 1247 if (ret < 0) { 1248 dev_err(bus->dev, "tplg component load failed%d\n", ret); 1249 return -EINVAL; 1250 } 1251 1252 skl->resource.max_mcps = SKL_MAX_MCPS; 1253 skl->resource.max_mem = SKL_FW_MAX_MEM; 1254 1255 return 0; 1256 } 1257