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 format->bit_depth = SKL_DEPTH_32BIT; 813 break; 814 815 default: 816 dev_err(dev, "Invalid bit depth %x for pipe\n", 817 format->valid_bit_depth); 818 return -EINVAL; 819 } 820 821 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) { 822 mconfig->ibs = (format->s_freq / 1000) * 823 (format->channels) * 824 (format->bit_depth >> 3); 825 } else { 826 mconfig->obs = (format->s_freq / 1000) * 827 (format->channels) * 828 (format->bit_depth >> 3); 829 } 830 831 return 0; 832 } 833 834 /* 835 * Query the module config for the FE DAI 836 * This is used to find the hw_params set for that DAI and apply to FE 837 * pipeline 838 */ 839 struct skl_module_cfg * 840 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream) 841 { 842 struct snd_soc_dapm_widget *w; 843 struct snd_soc_dapm_path *p = NULL; 844 845 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 846 w = dai->playback_widget; 847 snd_soc_dapm_widget_for_each_sink_path(w, p) { 848 if (p->connect && p->sink->power && 849 is_skl_dsp_widget_type(p->sink)) 850 continue; 851 852 if (p->sink->priv) { 853 dev_dbg(dai->dev, "set params for %s\n", 854 p->sink->name); 855 return p->sink->priv; 856 } 857 } 858 } else { 859 w = dai->capture_widget; 860 snd_soc_dapm_widget_for_each_source_path(w, p) { 861 if (p->connect && p->source->power && 862 is_skl_dsp_widget_type(p->source)) 863 continue; 864 865 if (p->source->priv) { 866 dev_dbg(dai->dev, "set params for %s\n", 867 p->source->name); 868 return p->source->priv; 869 } 870 } 871 } 872 873 return NULL; 874 } 875 876 static u8 skl_tplg_be_link_type(int dev_type) 877 { 878 int ret; 879 880 switch (dev_type) { 881 case SKL_DEVICE_BT: 882 ret = NHLT_LINK_SSP; 883 break; 884 885 case SKL_DEVICE_DMIC: 886 ret = NHLT_LINK_DMIC; 887 break; 888 889 case SKL_DEVICE_I2S: 890 ret = NHLT_LINK_SSP; 891 break; 892 893 case SKL_DEVICE_HDALINK: 894 ret = NHLT_LINK_HDA; 895 break; 896 897 default: 898 ret = NHLT_LINK_INVALID; 899 break; 900 } 901 902 return ret; 903 } 904 905 /* 906 * Fill the BE gateway parameters 907 * The BE gateway expects a blob of parameters which are kept in the ACPI 908 * NHLT blob, so query the blob for interface type (i2s/pdm) and instance. 909 * The port can have multiple settings so pick based on the PCM 910 * parameters 911 */ 912 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai, 913 struct skl_module_cfg *mconfig, 914 struct skl_pipe_params *params) 915 { 916 struct skl_pipe *pipe = mconfig->pipe; 917 struct nhlt_specific_cfg *cfg; 918 struct skl *skl = get_skl_ctx(dai->dev); 919 int link_type = skl_tplg_be_link_type(mconfig->dev_type); 920 921 memcpy(pipe->p_params, params, sizeof(*params)); 922 923 /* update the blob based on virtual bus_id*/ 924 cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type, 925 params->s_fmt, params->ch, 926 params->s_freq, params->stream); 927 if (cfg) { 928 mconfig->formats_config.caps_size = cfg->size; 929 mconfig->formats_config.caps = (u32 *) &cfg->caps; 930 } else { 931 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n", 932 mconfig->vbus_id, link_type, 933 params->stream); 934 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n", 935 params->ch, params->s_freq, params->s_fmt); 936 return -EINVAL; 937 } 938 939 return 0; 940 } 941 942 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai, 943 struct snd_soc_dapm_widget *w, 944 struct skl_pipe_params *params) 945 { 946 struct snd_soc_dapm_path *p; 947 948 snd_soc_dapm_widget_for_each_source_path(w, p) { 949 if (p->connect && is_skl_dsp_widget_type(p->source) && 950 p->source->priv) { 951 952 if (!p->source->power) 953 return skl_tplg_be_fill_pipe_params( 954 dai, p->source->priv, 955 params); 956 else 957 return -EBUSY; 958 } else { 959 return skl_tplg_be_set_src_pipe_params( 960 dai, p->source, params); 961 } 962 } 963 964 return -EIO; 965 } 966 967 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai, 968 struct snd_soc_dapm_widget *w, struct skl_pipe_params *params) 969 { 970 struct snd_soc_dapm_path *p = NULL; 971 972 snd_soc_dapm_widget_for_each_sink_path(w, p) { 973 if (p->connect && is_skl_dsp_widget_type(p->sink) && 974 p->sink->priv) { 975 976 if (!p->sink->power) 977 return skl_tplg_be_fill_pipe_params( 978 dai, p->sink->priv, params); 979 else 980 return -EBUSY; 981 982 } else { 983 return skl_tplg_be_set_sink_pipe_params( 984 dai, p->sink, params); 985 } 986 } 987 988 return -EIO; 989 } 990 991 /* 992 * BE hw_params can be a source parameters (capture) or sink parameters 993 * (playback). Based on sink and source we need to either find the source 994 * list or the sink list and set the pipeline parameters 995 */ 996 int skl_tplg_be_update_params(struct snd_soc_dai *dai, 997 struct skl_pipe_params *params) 998 { 999 struct snd_soc_dapm_widget *w; 1000 1001 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1002 w = dai->playback_widget; 1003 1004 return skl_tplg_be_set_src_pipe_params(dai, w, params); 1005 1006 } else { 1007 w = dai->capture_widget; 1008 1009 return skl_tplg_be_set_sink_pipe_params(dai, w, params); 1010 } 1011 1012 return 0; 1013 } 1014 1015 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = { 1016 {SKL_MIXER_EVENT, skl_tplg_mixer_event}, 1017 {SKL_VMIXER_EVENT, skl_tplg_vmixer_event}, 1018 {SKL_PGA_EVENT, skl_tplg_pga_event}, 1019 }; 1020 1021 /* 1022 * The topology binary passes the pin info for a module so initialize the pin 1023 * info passed into module instance 1024 */ 1025 static void skl_fill_module_pin_info(struct device *dev, 1026 struct skl_module_pin *m_pin, 1027 int max_pin) 1028 { 1029 int i; 1030 1031 for (i = 0; i < max_pin; i++) { 1032 m_pin[i].id.module_id = 0; 1033 m_pin[i].id.instance_id = 0; 1034 m_pin[i].in_use = false; 1035 m_pin[i].is_dynamic = true; 1036 m_pin[i].pin_index = i; 1037 } 1038 } 1039 1040 /* 1041 * Add pipeline from topology binary into driver pipeline list 1042 * 1043 * If already added we return that instance 1044 * Otherwise we create a new instance and add into driver list 1045 */ 1046 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev, 1047 struct skl *skl, struct skl_dfw_pipe *dfw_pipe) 1048 { 1049 struct skl_pipeline *ppl; 1050 struct skl_pipe *pipe; 1051 struct skl_pipe_params *params; 1052 1053 list_for_each_entry(ppl, &skl->ppl_list, node) { 1054 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id) 1055 return ppl->pipe; 1056 } 1057 1058 ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL); 1059 if (!ppl) 1060 return NULL; 1061 1062 pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL); 1063 if (!pipe) 1064 return NULL; 1065 1066 params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL); 1067 if (!params) 1068 return NULL; 1069 1070 pipe->ppl_id = dfw_pipe->pipe_id; 1071 pipe->memory_pages = dfw_pipe->memory_pages; 1072 pipe->pipe_priority = dfw_pipe->pipe_priority; 1073 pipe->conn_type = dfw_pipe->conn_type; 1074 pipe->state = SKL_PIPE_INVALID; 1075 pipe->p_params = params; 1076 INIT_LIST_HEAD(&pipe->w_list); 1077 1078 ppl->pipe = pipe; 1079 list_add(&ppl->node, &skl->ppl_list); 1080 1081 return ppl->pipe; 1082 } 1083 1084 /* 1085 * Topology core widget load callback 1086 * 1087 * This is used to save the private data for each widget which gives 1088 * information to the driver about module and pipeline parameters which DSP 1089 * FW expects like ids, resource values, formats etc 1090 */ 1091 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt, 1092 struct snd_soc_dapm_widget *w, 1093 struct snd_soc_tplg_dapm_widget *tplg_w) 1094 { 1095 int ret; 1096 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt); 1097 struct skl *skl = ebus_to_skl(ebus); 1098 struct hdac_bus *bus = ebus_to_hbus(ebus); 1099 struct skl_module_cfg *mconfig; 1100 struct skl_pipe *pipe; 1101 struct skl_dfw_module *dfw_config = 1102 (struct skl_dfw_module *)tplg_w->priv.data; 1103 1104 if (!tplg_w->priv.size) 1105 goto bind_event; 1106 1107 mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL); 1108 1109 if (!mconfig) 1110 return -ENOMEM; 1111 1112 w->priv = mconfig; 1113 mconfig->id.module_id = dfw_config->module_id; 1114 mconfig->id.instance_id = dfw_config->instance_id; 1115 mconfig->mcps = dfw_config->max_mcps; 1116 mconfig->ibs = dfw_config->ibs; 1117 mconfig->obs = dfw_config->obs; 1118 mconfig->core_id = dfw_config->core_id; 1119 mconfig->max_in_queue = dfw_config->max_in_queue; 1120 mconfig->max_out_queue = dfw_config->max_out_queue; 1121 mconfig->is_loadable = dfw_config->is_loadable; 1122 mconfig->in_fmt.channels = dfw_config->in_fmt.channels; 1123 mconfig->in_fmt.s_freq = dfw_config->in_fmt.freq; 1124 mconfig->in_fmt.bit_depth = dfw_config->in_fmt.bit_depth; 1125 mconfig->in_fmt.valid_bit_depth = 1126 dfw_config->in_fmt.valid_bit_depth; 1127 mconfig->in_fmt.ch_cfg = dfw_config->in_fmt.ch_cfg; 1128 mconfig->out_fmt.channels = dfw_config->out_fmt.channels; 1129 mconfig->out_fmt.s_freq = dfw_config->out_fmt.freq; 1130 mconfig->out_fmt.bit_depth = dfw_config->out_fmt.bit_depth; 1131 mconfig->out_fmt.valid_bit_depth = 1132 dfw_config->out_fmt.valid_bit_depth; 1133 mconfig->out_fmt.ch_cfg = dfw_config->out_fmt.ch_cfg; 1134 mconfig->params_fixup = dfw_config->params_fixup; 1135 mconfig->converter = dfw_config->converter; 1136 mconfig->m_type = dfw_config->module_type; 1137 mconfig->vbus_id = dfw_config->vbus_id; 1138 1139 pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe); 1140 if (pipe) 1141 mconfig->pipe = pipe; 1142 1143 mconfig->dev_type = dfw_config->dev_type; 1144 mconfig->hw_conn_type = dfw_config->hw_conn_type; 1145 mconfig->time_slot = dfw_config->time_slot; 1146 mconfig->formats_config.caps_size = dfw_config->caps.caps_size; 1147 1148 mconfig->m_in_pin = devm_kzalloc(bus->dev, 1149 (mconfig->max_in_queue) * 1150 sizeof(*mconfig->m_in_pin), 1151 GFP_KERNEL); 1152 if (!mconfig->m_in_pin) 1153 return -ENOMEM; 1154 1155 mconfig->m_out_pin = devm_kzalloc(bus->dev, 1156 (mconfig->max_in_queue) * 1157 sizeof(*mconfig->m_out_pin), 1158 GFP_KERNEL); 1159 if (!mconfig->m_out_pin) 1160 return -ENOMEM; 1161 1162 skl_fill_module_pin_info(bus->dev, mconfig->m_in_pin, 1163 mconfig->max_in_queue); 1164 skl_fill_module_pin_info(bus->dev, mconfig->m_out_pin, 1165 mconfig->max_out_queue); 1166 1167 if (mconfig->formats_config.caps_size == 0) 1168 goto bind_event; 1169 1170 mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev, 1171 mconfig->formats_config.caps_size, GFP_KERNEL); 1172 1173 if (mconfig->formats_config.caps == NULL) 1174 return -ENOMEM; 1175 1176 memcpy(mconfig->formats_config.caps, dfw_config->caps.caps, 1177 dfw_config->caps.caps_size); 1178 1179 bind_event: 1180 if (tplg_w->event_type == 0) { 1181 dev_dbg(bus->dev, "ASoC: No event handler required\n"); 1182 return 0; 1183 } 1184 1185 ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops, 1186 ARRAY_SIZE(skl_tplg_widget_ops), 1187 tplg_w->event_type); 1188 1189 if (ret) { 1190 dev_err(bus->dev, "%s: No matching event handlers found for %d\n", 1191 __func__, tplg_w->event_type); 1192 return -EINVAL; 1193 } 1194 1195 return 0; 1196 } 1197 1198 static struct snd_soc_tplg_ops skl_tplg_ops = { 1199 .widget_load = skl_tplg_widget_load, 1200 }; 1201 1202 /* This will be read from topology manifest, currently defined here */ 1203 #define SKL_MAX_MCPS 30000000 1204 #define SKL_FW_MAX_MEM 1000000 1205 1206 /* 1207 * SKL topology init routine 1208 */ 1209 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus) 1210 { 1211 int ret; 1212 const struct firmware *fw; 1213 struct hdac_bus *bus = ebus_to_hbus(ebus); 1214 struct skl *skl = ebus_to_skl(ebus); 1215 1216 ret = request_firmware(&fw, "dfw_sst.bin", bus->dev); 1217 if (ret < 0) { 1218 dev_err(bus->dev, "tplg fw %s load failed with %d\n", 1219 "dfw_sst.bin", ret); 1220 return ret; 1221 } 1222 1223 /* 1224 * The complete tplg for SKL is loaded as index 0, we don't use 1225 * any other index 1226 */ 1227 ret = snd_soc_tplg_component_load(&platform->component, 1228 &skl_tplg_ops, fw, 0); 1229 if (ret < 0) { 1230 dev_err(bus->dev, "tplg component load failed%d\n", ret); 1231 return -EINVAL; 1232 } 1233 1234 skl->resource.max_mcps = SKL_MAX_MCPS; 1235 skl->resource.max_mem = SKL_FW_MAX_MEM; 1236 1237 return 0; 1238 } 1239