sound/soc/intel/skylake/skl-topology.c

   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         int ret = -EIO;
 948
 949         snd_soc_dapm_widget_for_each_source_path(w, p) {
 950                 if (p->connect && is_skl_dsp_widget_type(p->source) &&
 951                                                 p->source->priv) {
 952
 953                         if (!p->source->power) {
 954                                 ret = skl_tplg_be_fill_pipe_params(
 955                                                 dai, p->source->priv,
 956                                                 params);
 957                                 if (ret < 0)
 958                                         return ret;
 959                         } else {
 960                                 return -EBUSY;
 961                         }
 962                 } else {
 963                         ret = skl_tplg_be_set_src_pipe_params(
 964                                                 dai, p->source, params);
 965                         if (ret < 0)
 966                                 return ret;
 967                 }
 968         }
 969
 970         return ret;
 971 }
 972
 973 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
 974         struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
 975 {
 976         struct snd_soc_dapm_path *p = NULL;
 977         int ret = -EIO;
 978
 979         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 980                 if (p->connect && is_skl_dsp_widget_type(p->sink) &&
 981                                                 p->sink->priv) {
 982
 983                         if (!p->sink->power) {
 984                                 ret = skl_tplg_be_fill_pipe_params(
 985                                                 dai, p->sink->priv, params);
 986                                 if (ret < 0)
 987                                         return ret;
 988                         } else {
 989                                 return -EBUSY;
 990                         }
 991
 992                 } else {
 993                         ret = skl_tplg_be_set_sink_pipe_params(
 994                                                 dai, p->sink, params);
 995                         if (ret < 0)
 996                                 return ret;
 997                 }
 998         }
 999
1000         return ret;
1001 }
1002
1003 /*
1004  * BE hw_params can be a source parameters (capture) or sink parameters
1005  * (playback). Based on sink and source we need to either find the source
1006  * list or the sink list and set the pipeline parameters
1007  */
1008 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1009                                 struct skl_pipe_params *params)
1010 {
1011         struct snd_soc_dapm_widget *w;
1012
1013         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1014                 w = dai->playback_widget;
1015
1016                 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1017
1018         } else {
1019                 w = dai->capture_widget;
1020
1021                 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1022         }
1023
1024         return 0;
1025 }
1026
1027 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1028         {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1029         {SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1030         {SKL_PGA_EVENT, skl_tplg_pga_event},
1031 };
1032
1033 /*
1034  * The topology binary passes the pin info for a module so initialize the pin
1035  * info passed into module instance
1036  */
1037 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1038                                                 struct skl_module_pin *m_pin,
1039                                                 bool is_dynamic, int max_pin)
1040 {
1041         int i;
1042
1043         for (i = 0; i < max_pin; i++) {
1044                 m_pin[i].id.module_id = dfw_pin[i].module_id;
1045                 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1046                 m_pin[i].in_use = false;
1047                 m_pin[i].is_dynamic = is_dynamic;
1048         }
1049 }
1050
1051 /*
1052  * Add pipeline from topology binary into driver pipeline list
1053  *
1054  * If already added we return that instance
1055  * Otherwise we create a new instance and add into driver list
1056  */
1057 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1058                         struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1059 {
1060         struct skl_pipeline *ppl;
1061         struct skl_pipe *pipe;
1062         struct skl_pipe_params *params;
1063
1064         list_for_each_entry(ppl, &skl->ppl_list, node) {
1065                 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1066                         return ppl->pipe;
1067         }
1068
1069         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1070         if (!ppl)
1071                 return NULL;
1072
1073         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1074         if (!pipe)
1075                 return NULL;
1076
1077         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1078         if (!params)
1079                 return NULL;
1080
1081         pipe->ppl_id = dfw_pipe->pipe_id;
1082         pipe->memory_pages = dfw_pipe->memory_pages;
1083         pipe->pipe_priority = dfw_pipe->pipe_priority;
1084         pipe->conn_type = dfw_pipe->conn_type;
1085         pipe->state = SKL_PIPE_INVALID;
1086         pipe->p_params = params;
1087         INIT_LIST_HEAD(&pipe->w_list);
1088
1089         ppl->pipe = pipe;
1090         list_add(&ppl->node, &skl->ppl_list);
1091
1092         return ppl->pipe;
1093 }
1094
1095 /*
1096  * Topology core widget load callback
1097  *
1098  * This is used to save the private data for each widget which gives
1099  * information to the driver about module and pipeline parameters which DSP
1100  * FW expects like ids, resource values, formats etc
1101  */
1102 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1103                                 struct snd_soc_dapm_widget *w,
1104                                 struct snd_soc_tplg_dapm_widget *tplg_w)
1105 {
1106         int ret;
1107         struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1108         struct skl *skl = ebus_to_skl(ebus);
1109         struct hdac_bus *bus = ebus_to_hbus(ebus);
1110         struct skl_module_cfg *mconfig;
1111         struct skl_pipe *pipe;
1112         struct skl_dfw_module *dfw_config =
1113                                 (struct skl_dfw_module *)tplg_w->priv.data;
1114
1115         if (!tplg_w->priv.size)
1116                 goto bind_event;
1117
1118         mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1119
1120         if (!mconfig)
1121                 return -ENOMEM;
1122
1123         w->priv = mconfig;
1124         mconfig->id.module_id = dfw_config->module_id;
1125         mconfig->id.instance_id = dfw_config->instance_id;
1126         mconfig->mcps = dfw_config->max_mcps;
1127         mconfig->ibs = dfw_config->ibs;
1128         mconfig->obs = dfw_config->obs;
1129         mconfig->core_id = dfw_config->core_id;
1130         mconfig->max_in_queue = dfw_config->max_in_queue;
1131         mconfig->max_out_queue = dfw_config->max_out_queue;
1132         mconfig->is_loadable = dfw_config->is_loadable;
1133         mconfig->in_fmt.channels = dfw_config->in_fmt.channels;
1134         mconfig->in_fmt.s_freq = dfw_config->in_fmt.freq;
1135         mconfig->in_fmt.bit_depth = dfw_config->in_fmt.bit_depth;
1136         mconfig->in_fmt.valid_bit_depth =
1137                                 dfw_config->in_fmt.valid_bit_depth;
1138         mconfig->in_fmt.ch_cfg = dfw_config->in_fmt.ch_cfg;
1139         mconfig->out_fmt.channels = dfw_config->out_fmt.channels;
1140         mconfig->out_fmt.s_freq = dfw_config->out_fmt.freq;
1141         mconfig->out_fmt.bit_depth = dfw_config->out_fmt.bit_depth;
1142         mconfig->out_fmt.valid_bit_depth =
1143                                 dfw_config->out_fmt.valid_bit_depth;
1144         mconfig->out_fmt.ch_cfg = dfw_config->out_fmt.ch_cfg;
1145         mconfig->params_fixup = dfw_config->params_fixup;
1146         mconfig->converter = dfw_config->converter;
1147         mconfig->m_type = dfw_config->module_type;
1148         mconfig->vbus_id = dfw_config->vbus_id;
1149
1150         pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1151         if (pipe)
1152                 mconfig->pipe = pipe;
1153
1154         mconfig->dev_type = dfw_config->dev_type;
1155         mconfig->hw_conn_type = dfw_config->hw_conn_type;
1156         mconfig->time_slot = dfw_config->time_slot;
1157         mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1158
1159         mconfig->m_in_pin = devm_kzalloc(bus->dev,
1160                                 (mconfig->max_in_queue) *
1161                                         sizeof(*mconfig->m_in_pin),
1162                                 GFP_KERNEL);
1163         if (!mconfig->m_in_pin)
1164                 return -ENOMEM;
1165
1166         mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1167                                                 sizeof(*mconfig->m_out_pin),
1168                                                 GFP_KERNEL);
1169         if (!mconfig->m_out_pin)
1170                 return -ENOMEM;
1171
1172         skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1173                                                 dfw_config->is_dynamic_in_pin,
1174                                                 mconfig->max_in_queue);
1175
1176         skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1177                                                  dfw_config->is_dynamic_out_pin,
1178                                                         mconfig->max_out_queue);
1179
1180
1181         if (mconfig->formats_config.caps_size == 0)
1182                 goto bind_event;
1183
1184         mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1185                         mconfig->formats_config.caps_size, GFP_KERNEL);
1186
1187         if (mconfig->formats_config.caps == NULL)
1188                 return -ENOMEM;
1189
1190         memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1191                                          dfw_config->caps.caps_size);
1192
1193 bind_event:
1194         if (tplg_w->event_type == 0) {
1195                 dev_dbg(bus->dev, "ASoC: No event handler required\n");
1196                 return 0;
1197         }
1198
1199         ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1200                                         ARRAY_SIZE(skl_tplg_widget_ops),
1201                                         tplg_w->event_type);
1202
1203         if (ret) {
1204                 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1205                                         __func__, tplg_w->event_type);
1206                 return -EINVAL;
1207         }
1208
1209         return 0;
1210 }
1211
1212 static struct snd_soc_tplg_ops skl_tplg_ops  = {
1213         .widget_load = skl_tplg_widget_load,
1214 };
1215
1216 /* This will be read from topology manifest, currently defined here */
1217 #define SKL_MAX_MCPS 30000000
1218 #define SKL_FW_MAX_MEM 1000000
1219
1220 /*
1221  * SKL topology init routine
1222  */
1223 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1224 {
1225         int ret;
1226         const struct firmware *fw;
1227         struct hdac_bus *bus = ebus_to_hbus(ebus);
1228         struct skl *skl = ebus_to_skl(ebus);
1229
1230         ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1231         if (ret < 0) {
1232                 dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1233                                 "dfw_sst.bin", ret);
1234                 return ret;
1235         }
1236
1237         /*
1238          * The complete tplg for SKL is loaded as index 0, we don't use
1239          * any other index
1240          */
1241         ret = snd_soc_tplg_component_load(&platform->component,
1242                                         &skl_tplg_ops, fw, 0);
1243         if (ret < 0) {
1244                 dev_err(bus->dev, "tplg component load failed%d\n", ret);
1245                 return -EINVAL;
1246         }
1247
1248         skl->resource.max_mcps = SKL_MAX_MCPS;
1249         skl->resource.max_mem = SKL_FW_MAX_MEM;
1250
1251         return 0;
1252 }