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 #include "../common/sst-dsp.h"
  30 #include "../common/sst-dsp-priv.h"
  31
  32 #define SKL_CH_FIXUP_MASK               (1 << 0)
  33 #define SKL_RATE_FIXUP_MASK             (1 << 1)
  34 #define SKL_FMT_FIXUP_MASK              (1 << 2)
  35
  36 /*
  37  * SKL DSP driver modelling uses only few DAPM widgets so for rest we will
  38  * ignore. This helpers checks if the SKL driver handles this widget type
  39  */
  40 static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w)
  41 {
  42         switch (w->id) {
  43         case snd_soc_dapm_dai_link:
  44         case snd_soc_dapm_dai_in:
  45         case snd_soc_dapm_aif_in:
  46         case snd_soc_dapm_aif_out:
  47         case snd_soc_dapm_dai_out:
  48         case snd_soc_dapm_switch:
  49                 return false;
  50         default:
  51                 return true;
  52         }
  53 }
  54
  55 /*
  56  * Each pipelines needs memory to be allocated. Check if we have free memory
  57  * from available pool.
  58  */
  59 static bool skl_is_pipe_mem_avail(struct skl *skl,
  60                                 struct skl_module_cfg *mconfig)
  61 {
  62         struct skl_sst *ctx = skl->skl_sst;
  63
  64         if (skl->resource.mem + mconfig->pipe->memory_pages >
  65                                 skl->resource.max_mem) {
  66                 dev_err(ctx->dev,
  67                                 "%s: module_id %d instance %d\n", __func__,
  68                                 mconfig->id.module_id,
  69                                 mconfig->id.instance_id);
  70                 dev_err(ctx->dev,
  71                                 "exceeds ppl memory available %d mem %d\n",
  72                                 skl->resource.max_mem, skl->resource.mem);
  73                 return false;
  74         } else {
  75                 return true;
  76         }
  77 }
  78
  79 /*
  80  * Add the mem to the mem pool. This is freed when pipe is deleted.
  81  * Note: DSP does actual memory management we only keep track for complete
  82  * pool
  83  */
  84 static void skl_tplg_alloc_pipe_mem(struct skl *skl,
  85                                 struct skl_module_cfg *mconfig)
  86 {
  87         skl->resource.mem += mconfig->pipe->memory_pages;
  88 }
  89
  90 /*
  91  * Pipeline needs needs DSP CPU resources for computation, this is
  92  * quantified in MCPS (Million Clocks Per Second) required for module/pipe
  93  *
  94  * Each pipelines needs mcps to be allocated. Check if we have mcps for this
  95  * pipe.
  96  */
  97
  98 static bool skl_is_pipe_mcps_avail(struct skl *skl,
  99                                 struct skl_module_cfg *mconfig)
 100 {
 101         struct skl_sst *ctx = skl->skl_sst;
 102
 103         if (skl->resource.mcps + mconfig->mcps > skl->resource.max_mcps) {
 104                 dev_err(ctx->dev,
 105                         "%s: module_id %d instance %d\n", __func__,
 106                         mconfig->id.module_id, mconfig->id.instance_id);
 107                 dev_err(ctx->dev,
 108                         "exceeds ppl mcps available %d > mem %d\n",
 109                         skl->resource.max_mcps, skl->resource.mcps);
 110                 return false;
 111         } else {
 112                 return true;
 113         }
 114 }
 115
 116 static void skl_tplg_alloc_pipe_mcps(struct skl *skl,
 117                                 struct skl_module_cfg *mconfig)
 118 {
 119         skl->resource.mcps += mconfig->mcps;
 120 }
 121
 122 /*
 123  * Free the mcps when tearing down
 124  */
 125 static void
 126 skl_tplg_free_pipe_mcps(struct skl *skl, struct skl_module_cfg *mconfig)
 127 {
 128         skl->resource.mcps -= mconfig->mcps;
 129 }
 130
 131 /*
 132  * Free the memory when tearing down
 133  */
 134 static void
 135 skl_tplg_free_pipe_mem(struct skl *skl, struct skl_module_cfg *mconfig)
 136 {
 137         skl->resource.mem -= mconfig->pipe->memory_pages;
 138 }
 139
 140
 141 static void skl_dump_mconfig(struct skl_sst *ctx,
 142                                         struct skl_module_cfg *mcfg)
 143 {
 144         dev_dbg(ctx->dev, "Dumping config\n");
 145         dev_dbg(ctx->dev, "Input Format:\n");
 146         dev_dbg(ctx->dev, "channels = %d\n", mcfg->in_fmt[0].channels);
 147         dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->in_fmt[0].s_freq);
 148         dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->in_fmt[0].ch_cfg);
 149         dev_dbg(ctx->dev, "valid bit depth = %d\n", mcfg->in_fmt[0].valid_bit_depth);
 150         dev_dbg(ctx->dev, "Output Format:\n");
 151         dev_dbg(ctx->dev, "channels = %d\n", mcfg->out_fmt[0].channels);
 152         dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->out_fmt[0].s_freq);
 153         dev_dbg(ctx->dev, "valid bit depth = %d\n", mcfg->out_fmt[0].valid_bit_depth);
 154         dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->out_fmt[0].ch_cfg);
 155 }
 156
 157 static void skl_tplg_update_params(struct skl_module_fmt *fmt,
 158                         struct skl_pipe_params *params, int fixup)
 159 {
 160         if (fixup & SKL_RATE_FIXUP_MASK)
 161                 fmt->s_freq = params->s_freq;
 162         if (fixup & SKL_CH_FIXUP_MASK)
 163                 fmt->channels = params->ch;
 164         if (fixup & SKL_FMT_FIXUP_MASK) {
 165                 fmt->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
 166
 167                 /*
 168                  * 16 bit is 16 bit container whereas 24 bit is in 32 bit
 169                  * container so update bit depth accordingly
 170                  */
 171                 switch (fmt->valid_bit_depth) {
 172                 case SKL_DEPTH_16BIT:
 173                         fmt->bit_depth = fmt->valid_bit_depth;
 174                         break;
 175
 176                 default:
 177                         fmt->bit_depth = SKL_DEPTH_32BIT;
 178                         break;
 179                 }
 180         }
 181
 182 }
 183
 184 /*
 185  * A pipeline may have modules which impact the pcm parameters, like SRC,
 186  * channel converter, format converter.
 187  * We need to calculate the output params by applying the 'fixup'
 188  * Topology will tell driver which type of fixup is to be applied by
 189  * supplying the fixup mask, so based on that we calculate the output
 190  *
 191  * Now In FE the pcm hw_params is source/target format. Same is applicable
 192  * for BE with its hw_params invoked.
 193  * here based on FE, BE pipeline and direction we calculate the input and
 194  * outfix and then apply that for a module
 195  */
 196 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
 197                 struct skl_pipe_params *params, bool is_fe)
 198 {
 199         int in_fixup, out_fixup;
 200         struct skl_module_fmt *in_fmt, *out_fmt;
 201
 202         /* Fixups will be applied to pin 0 only */
 203         in_fmt = &m_cfg->in_fmt[0];
 204         out_fmt = &m_cfg->out_fmt[0];
 205
 206         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 207                 if (is_fe) {
 208                         in_fixup = m_cfg->params_fixup;
 209                         out_fixup = (~m_cfg->converter) &
 210                                         m_cfg->params_fixup;
 211                 } else {
 212                         out_fixup = m_cfg->params_fixup;
 213                         in_fixup = (~m_cfg->converter) &
 214                                         m_cfg->params_fixup;
 215                 }
 216         } else {
 217                 if (is_fe) {
 218                         out_fixup = m_cfg->params_fixup;
 219                         in_fixup = (~m_cfg->converter) &
 220                                         m_cfg->params_fixup;
 221                 } else {
 222                         in_fixup = m_cfg->params_fixup;
 223                         out_fixup = (~m_cfg->converter) &
 224                                         m_cfg->params_fixup;
 225                 }
 226         }
 227
 228         skl_tplg_update_params(in_fmt, params, in_fixup);
 229         skl_tplg_update_params(out_fmt, params, out_fixup);
 230 }
 231
 232 /*
 233  * A module needs input and output buffers, which are dependent upon pcm
 234  * params, so once we have calculate params, we need buffer calculation as
 235  * well.
 236  */
 237 static void skl_tplg_update_buffer_size(struct skl_sst *ctx,
 238                                 struct skl_module_cfg *mcfg)
 239 {
 240         int multiplier = 1;
 241         struct skl_module_fmt *in_fmt, *out_fmt;
 242
 243
 244         /* Since fixups is applied to pin 0 only, ibs, obs needs
 245          * change for pin 0 only
 246          */
 247         in_fmt = &mcfg->in_fmt[0];
 248         out_fmt = &mcfg->out_fmt[0];
 249
 250         if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT)
 251                 multiplier = 5;
 252         mcfg->ibs = (in_fmt->s_freq / 1000) *
 253                                 (mcfg->in_fmt->channels) *
 254                                 (mcfg->in_fmt->bit_depth >> 3) *
 255                                 multiplier;
 256
 257         mcfg->obs = (mcfg->out_fmt->s_freq / 1000) *
 258                                 (mcfg->out_fmt->channels) *
 259                                 (mcfg->out_fmt->bit_depth >> 3) *
 260                                 multiplier;
 261 }
 262
 263 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
 264                                                         struct skl_sst *ctx)
 265 {
 266         struct skl_module_cfg *m_cfg = w->priv;
 267         struct skl_pipe_params *params = m_cfg->pipe->p_params;
 268         int p_conn_type = m_cfg->pipe->conn_type;
 269         bool is_fe;
 270
 271         if (!m_cfg->params_fixup)
 272                 return;
 273
 274         dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
 275                                 w->name);
 276
 277         skl_dump_mconfig(ctx, m_cfg);
 278
 279         if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
 280                 is_fe = true;
 281         else
 282                 is_fe = false;
 283
 284         skl_tplg_update_params_fixup(m_cfg, params, is_fe);
 285         skl_tplg_update_buffer_size(ctx, m_cfg);
 286
 287         dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
 288                                 w->name);
 289
 290         skl_dump_mconfig(ctx, m_cfg);
 291 }
 292
 293 /*
 294  * A pipe can have multiple modules, each of them will be a DAPM widget as
 295  * well. While managing a pipeline we need to get the list of all the
 296  * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps
 297  * to get the SKL type widgets in that pipeline
 298  */
 299 static int skl_tplg_alloc_pipe_widget(struct device *dev,
 300         struct snd_soc_dapm_widget *w, struct skl_pipe *pipe)
 301 {
 302         struct skl_module_cfg *src_module = NULL;
 303         struct snd_soc_dapm_path *p = NULL;
 304         struct skl_pipe_module *p_module = NULL;
 305
 306         p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL);
 307         if (!p_module)
 308                 return -ENOMEM;
 309
 310         p_module->w = w;
 311         list_add_tail(&p_module->node, &pipe->w_list);
 312
 313         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 314                 if ((p->sink->priv == NULL)
 315                                 && (!is_skl_dsp_widget_type(w)))
 316                         continue;
 317
 318                 if ((p->sink->priv != NULL) && p->connect
 319                                 && is_skl_dsp_widget_type(p->sink)) {
 320
 321                         src_module = p->sink->priv;
 322                         if (pipe->ppl_id == src_module->pipe->ppl_id)
 323                                 skl_tplg_alloc_pipe_widget(dev,
 324                                                         p->sink, pipe);
 325                 }
 326         }
 327         return 0;
 328 }
 329
 330 /*
 331  * some modules can have multiple params set from user control and
 332  * need to be set after module is initialized. If set_param flag is
 333  * set module params will be done after module is initialised.
 334  */
 335 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
 336                                                 struct skl_sst *ctx)
 337 {
 338         int i, ret;
 339         struct skl_module_cfg *mconfig = w->priv;
 340         const struct snd_kcontrol_new *k;
 341         struct soc_bytes_ext *sb;
 342         struct skl_algo_data *bc;
 343         struct skl_specific_cfg *sp_cfg;
 344
 345         if (mconfig->formats_config.caps_size > 0 &&
 346                 mconfig->formats_config.set_params == SKL_PARAM_SET) {
 347                 sp_cfg = &mconfig->formats_config;
 348                 ret = skl_set_module_params(ctx, sp_cfg->caps,
 349                                         sp_cfg->caps_size,
 350                                         sp_cfg->param_id, mconfig);
 351                 if (ret < 0)
 352                         return ret;
 353         }
 354
 355         for (i = 0; i < w->num_kcontrols; i++) {
 356                 k = &w->kcontrol_news[i];
 357                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 358                         sb = (void *) k->private_value;
 359                         bc = (struct skl_algo_data *)sb->dobj.private;
 360
 361                         if (bc->set_params == SKL_PARAM_SET) {
 362                                 ret = skl_set_module_params(ctx,
 363                                                 (u32 *)bc->params, bc->max,
 364                                                 bc->param_id, mconfig);
 365                                 if (ret < 0)
 366                                         return ret;
 367                         }
 368                 }
 369         }
 370
 371         return 0;
 372 }
 373
 374 /*
 375  * some module param can set from user control and this is required as
 376  * when module is initailzed. if module param is required in init it is
 377  * identifed by set_param flag. if set_param flag is not set, then this
 378  * parameter needs to set as part of module init.
 379  */
 380 static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
 381 {
 382         const struct snd_kcontrol_new *k;
 383         struct soc_bytes_ext *sb;
 384         struct skl_algo_data *bc;
 385         struct skl_module_cfg *mconfig = w->priv;
 386         int i;
 387
 388         for (i = 0; i < w->num_kcontrols; i++) {
 389                 k = &w->kcontrol_news[i];
 390                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 391                         sb = (struct soc_bytes_ext *)k->private_value;
 392                         bc = (struct skl_algo_data *)sb->dobj.private;
 393
 394                         if (bc->set_params != SKL_PARAM_INIT)
 395                                 continue;
 396
 397                         mconfig->formats_config.caps = (u32 *)&bc->params;
 398                         mconfig->formats_config.caps_size = bc->max;
 399
 400                         break;
 401                 }
 402         }
 403
 404         return 0;
 405 }
 406
 407 /*
 408  * Inside a pipe instance, we can have various modules. These modules need
 409  * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
 410  * skl_init_module() routine, so invoke that for all modules in a pipeline
 411  */
 412 static int
 413 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
 414 {
 415         struct skl_pipe_module *w_module;
 416         struct snd_soc_dapm_widget *w;
 417         struct skl_module_cfg *mconfig;
 418         struct skl_sst *ctx = skl->skl_sst;
 419         int ret = 0;
 420
 421         list_for_each_entry(w_module, &pipe->w_list, node) {
 422                 w = w_module->w;
 423                 mconfig = w->priv;
 424
 425                 /* check resource available */
 426                 if (!skl_is_pipe_mcps_avail(skl, mconfig))
 427                         return -ENOMEM;
 428
 429                 if (mconfig->is_loadable && ctx->dsp->fw_ops.load_mod) {
 430                         ret = ctx->dsp->fw_ops.load_mod(ctx->dsp,
 431                                 mconfig->id.module_id, mconfig->guid);
 432                         if (ret < 0)
 433                                 return ret;
 434                 }
 435
 436                 /*
 437                  * apply fix/conversion to module params based on
 438                  * FE/BE params
 439                  */
 440                 skl_tplg_update_module_params(w, ctx);
 441
 442                 skl_tplg_set_module_init_data(w);
 443                 ret = skl_init_module(ctx, mconfig);
 444                 if (ret < 0)
 445                         return ret;
 446
 447                 ret = skl_tplg_set_module_params(w, ctx);
 448                 if (ret < 0)
 449                         return ret;
 450                 skl_tplg_alloc_pipe_mcps(skl, mconfig);
 451         }
 452
 453         return 0;
 454 }
 455
 456 static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
 457          struct skl_pipe *pipe)
 458 {
 459         struct skl_pipe_module *w_module = NULL;
 460         struct skl_module_cfg *mconfig = NULL;
 461
 462         list_for_each_entry(w_module, &pipe->w_list, node) {
 463                 mconfig  = w_module->w->priv;
 464
 465                 if (mconfig->is_loadable && ctx->dsp->fw_ops.unload_mod)
 466                         return ctx->dsp->fw_ops.unload_mod(ctx->dsp,
 467                                                 mconfig->id.module_id);
 468         }
 469
 470         /* no modules to unload in this path, so return */
 471         return 0;
 472 }
 473
 474 /*
 475  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
 476  * need create the pipeline. So we do following:
 477  *   - check the resources
 478  *   - Create the pipeline
 479  *   - Initialize the modules in pipeline
 480  *   - finally bind all modules together
 481  */
 482 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 483                                                         struct skl *skl)
 484 {
 485         int ret;
 486         struct skl_module_cfg *mconfig = w->priv;
 487         struct skl_pipe_module *w_module;
 488         struct skl_pipe *s_pipe = mconfig->pipe;
 489         struct skl_module_cfg *src_module = NULL, *dst_module;
 490         struct skl_sst *ctx = skl->skl_sst;
 491
 492         /* check resource available */
 493         if (!skl_is_pipe_mcps_avail(skl, mconfig))
 494                 return -EBUSY;
 495
 496         if (!skl_is_pipe_mem_avail(skl, mconfig))
 497                 return -ENOMEM;
 498
 499         /*
 500          * Create a list of modules for pipe.
 501          * This list contains modules from source to sink
 502          */
 503         ret = skl_create_pipeline(ctx, mconfig->pipe);
 504         if (ret < 0)
 505                 return ret;
 506
 507         /*
 508          * we create a w_list of all widgets in that pipe. This list is not
 509          * freed on PMD event as widgets within a pipe are static. This
 510          * saves us cycles to get widgets in pipe every time.
 511          *
 512          * So if we have already initialized all the widgets of a pipeline
 513          * we skip, so check for list_empty and create the list if empty
 514          */
 515         if (list_empty(&s_pipe->w_list)) {
 516                 ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe);
 517                 if (ret < 0)
 518                         return ret;
 519         }
 520
 521         /* Init all pipe modules from source to sink */
 522         ret = skl_tplg_init_pipe_modules(skl, s_pipe);
 523         if (ret < 0)
 524                 return ret;
 525
 526         /* Bind modules from source to sink */
 527         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 528                 dst_module = w_module->w->priv;
 529
 530                 if (src_module == NULL) {
 531                         src_module = dst_module;
 532                         continue;
 533                 }
 534
 535                 ret = skl_bind_modules(ctx, src_module, dst_module);
 536                 if (ret < 0)
 537                         return ret;
 538
 539                 src_module = dst_module;
 540         }
 541
 542         skl_tplg_alloc_pipe_mem(skl, mconfig);
 543         skl_tplg_alloc_pipe_mcps(skl, mconfig);
 544
 545         return 0;
 546 }
 547
 548 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
 549                                 struct skl *skl,
 550                                 struct snd_soc_dapm_widget *src_w,
 551                                 struct skl_module_cfg *src_mconfig)
 552 {
 553         struct snd_soc_dapm_path *p;
 554         struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
 555         struct skl_module_cfg *sink_mconfig;
 556         struct skl_sst *ctx = skl->skl_sst;
 557         int ret;
 558
 559         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 560                 if (!p->connect)
 561                         continue;
 562
 563                 dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
 564                 dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
 565
 566                 next_sink = p->sink;
 567
 568                 if (!is_skl_dsp_widget_type(p->sink))
 569                         return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
 570
 571                 /*
 572                  * here we will check widgets in sink pipelines, so that
 573                  * can be any widgets type and we are only interested if
 574                  * they are ones used for SKL so check that first
 575                  */
 576                 if ((p->sink->priv != NULL) &&
 577                                         is_skl_dsp_widget_type(p->sink)) {
 578
 579                         sink = p->sink;
 580                         sink_mconfig = sink->priv;
 581
 582                         /* Bind source to sink, mixin is always source */
 583                         ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
 584                         if (ret)
 585                                 return ret;
 586
 587                         /* Start sinks pipe first */
 588                         if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
 589                                 if (sink_mconfig->pipe->conn_type !=
 590                                                         SKL_PIPE_CONN_TYPE_FE)
 591                                         ret = skl_run_pipe(ctx,
 592                                                         sink_mconfig->pipe);
 593                                 if (ret)
 594                                         return ret;
 595                         }
 596                 }
 597         }
 598
 599         if (!sink)
 600                 return skl_tplg_bind_sinks(next_sink, skl, src_w, src_mconfig);
 601
 602         return 0;
 603 }
 604
 605 /*
 606  * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
 607  * we need to do following:
 608  *   - Bind to sink pipeline
 609  *      Since the sink pipes can be running and we don't get mixer event on
 610  *      connect for already running mixer, we need to find the sink pipes
 611  *      here and bind to them. This way dynamic connect works.
 612  *   - Start sink pipeline, if not running
 613  *   - Then run current pipe
 614  */
 615 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 616                                                                 struct skl *skl)
 617 {
 618         struct skl_module_cfg *src_mconfig;
 619         struct skl_sst *ctx = skl->skl_sst;
 620         int ret = 0;
 621
 622         src_mconfig = w->priv;
 623
 624         /*
 625          * find which sink it is connected to, bind with the sink,
 626          * if sink is not started, start sink pipe first, then start
 627          * this pipe
 628          */
 629         ret = skl_tplg_bind_sinks(w, skl, w, src_mconfig);
 630         if (ret)
 631                 return ret;
 632
 633         /* Start source pipe last after starting all sinks */
 634         if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
 635                 return skl_run_pipe(ctx, src_mconfig->pipe);
 636
 637         return 0;
 638 }
 639
 640 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
 641                 struct snd_soc_dapm_widget *w, struct skl *skl)
 642 {
 643         struct snd_soc_dapm_path *p;
 644         struct snd_soc_dapm_widget *src_w = NULL;
 645         struct skl_sst *ctx = skl->skl_sst;
 646
 647         snd_soc_dapm_widget_for_each_source_path(w, p) {
 648                 src_w = p->source;
 649                 if (!p->connect)
 650                         continue;
 651
 652                 dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
 653                 dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
 654
 655                 /*
 656                  * here we will check widgets in sink pipelines, so that can
 657                  * be any widgets type and we are only interested if they are
 658                  * ones used for SKL so check that first
 659                  */
 660                 if ((p->source->priv != NULL) &&
 661                                         is_skl_dsp_widget_type(p->source)) {
 662                         return p->source;
 663                 }
 664         }
 665
 666         if (src_w != NULL)
 667                 return skl_get_src_dsp_widget(src_w, skl);
 668
 669         return NULL;
 670 }
 671
 672 /*
 673  * in the Post-PMU event of mixer we need to do following:
 674  *   - Check if this pipe is running
 675  *   - if not, then
 676  *      - bind this pipeline to its source pipeline
 677  *        if source pipe is already running, this means it is a dynamic
 678  *        connection and we need to bind only to that pipe
 679  *      - start this pipeline
 680  */
 681 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
 682                                                         struct skl *skl)
 683 {
 684         int ret = 0;
 685         struct snd_soc_dapm_widget *source, *sink;
 686         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 687         struct skl_sst *ctx = skl->skl_sst;
 688         int src_pipe_started = 0;
 689
 690         sink = w;
 691         sink_mconfig = sink->priv;
 692
 693         /*
 694          * If source pipe is already started, that means source is driving
 695          * one more sink before this sink got connected, Since source is
 696          * started, bind this sink to source and start this pipe.
 697          */
 698         source = skl_get_src_dsp_widget(w, skl);
 699         if (source != NULL) {
 700                 src_mconfig = source->priv;
 701                 sink_mconfig = sink->priv;
 702                 src_pipe_started = 1;
 703
 704                 /*
 705                  * check pipe state, then no need to bind or start the
 706                  * pipe
 707                  */
 708                 if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
 709                         src_pipe_started = 0;
 710         }
 711
 712         if (src_pipe_started) {
 713                 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
 714                 if (ret)
 715                         return ret;
 716
 717                 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
 718                         ret = skl_run_pipe(ctx, sink_mconfig->pipe);
 719         }
 720
 721         return ret;
 722 }
 723
 724 /*
 725  * in the Pre-PMD event of mixer we need to do following:
 726  *   - Stop the pipe
 727  *   - find the source connections and remove that from dapm_path_list
 728  *   - unbind with source pipelines if still connected
 729  */
 730 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
 731                                                         struct skl *skl)
 732 {
 733         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 734         int ret = 0, i;
 735         struct skl_sst *ctx = skl->skl_sst;
 736
 737         sink_mconfig = w->priv;
 738
 739         /* Stop the pipe */
 740         ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
 741         if (ret)
 742                 return ret;
 743
 744         for (i = 0; i < sink_mconfig->max_in_queue; i++) {
 745                 if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
 746                         src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
 747                         if (!src_mconfig)
 748                                 continue;
 749                         /*
 750                          * If path_found == 1, that means pmd for source
 751                          * pipe has not occurred, source is connected to
 752                          * some other sink. so its responsibility of sink
 753                          * to unbind itself from source.
 754                          */
 755                         ret = skl_stop_pipe(ctx, src_mconfig->pipe);
 756                         if (ret < 0)
 757                                 return ret;
 758
 759                         ret = skl_unbind_modules(ctx,
 760                                                 src_mconfig, sink_mconfig);
 761                 }
 762         }
 763
 764         return ret;
 765 }
 766
 767 /*
 768  * in the Post-PMD event of mixer we need to do following:
 769  *   - Free the mcps used
 770  *   - Free the mem used
 771  *   - Unbind the modules within the pipeline
 772  *   - Delete the pipeline (modules are not required to be explicitly
 773  *     deleted, pipeline delete is enough here
 774  */
 775 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
 776                                                         struct skl *skl)
 777 {
 778         struct skl_module_cfg *mconfig = w->priv;
 779         struct skl_pipe_module *w_module;
 780         struct skl_module_cfg *src_module = NULL, *dst_module;
 781         struct skl_sst *ctx = skl->skl_sst;
 782         struct skl_pipe *s_pipe = mconfig->pipe;
 783         int ret = 0;
 784
 785         skl_tplg_free_pipe_mcps(skl, mconfig);
 786         skl_tplg_free_pipe_mem(skl, mconfig);
 787
 788         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 789                 dst_module = w_module->w->priv;
 790
 791                 skl_tplg_free_pipe_mcps(skl, dst_module);
 792                 if (src_module == NULL) {
 793                         src_module = dst_module;
 794                         continue;
 795                 }
 796
 797                 skl_unbind_modules(ctx, src_module, dst_module);
 798                 src_module = dst_module;
 799         }
 800
 801         ret = skl_delete_pipe(ctx, mconfig->pipe);
 802
 803         return skl_tplg_unload_pipe_modules(ctx, s_pipe);
 804 }
 805
 806 /*
 807  * in the Post-PMD event of PGA we need to do following:
 808  *   - Free the mcps used
 809  *   - Stop the pipeline
 810  *   - In source pipe is connected, unbind with source pipelines
 811  */
 812 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
 813                                                                 struct skl *skl)
 814 {
 815         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 816         int ret = 0, i;
 817         struct skl_sst *ctx = skl->skl_sst;
 818
 819         src_mconfig = w->priv;
 820
 821         /* Stop the pipe since this is a mixin module */
 822         ret = skl_stop_pipe(ctx, src_mconfig->pipe);
 823         if (ret)
 824                 return ret;
 825
 826         for (i = 0; i < src_mconfig->max_out_queue; i++) {
 827                 if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
 828                         sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
 829                         if (!sink_mconfig)
 830                                 continue;
 831                         /*
 832                          * This is a connecter and if path is found that means
 833                          * unbind between source and sink has not happened yet
 834                          */
 835                         ret = skl_unbind_modules(ctx, src_mconfig,
 836                                                         sink_mconfig);
 837                 }
 838         }
 839
 840         return ret;
 841 }
 842
 843 /*
 844  * In modelling, we assume there will be ONLY one mixer in a pipeline.  If
 845  * mixer is not required then it is treated as static mixer aka vmixer with
 846  * a hard path to source module
 847  * So we don't need to check if source is started or not as hard path puts
 848  * dependency on each other
 849  */
 850 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
 851                                 struct snd_kcontrol *k, int event)
 852 {
 853         struct snd_soc_dapm_context *dapm = w->dapm;
 854         struct skl *skl = get_skl_ctx(dapm->dev);
 855
 856         switch (event) {
 857         case SND_SOC_DAPM_PRE_PMU:
 858                 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
 859
 860         case SND_SOC_DAPM_POST_PMU:
 861                 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
 862
 863         case SND_SOC_DAPM_PRE_PMD:
 864                 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
 865
 866         case SND_SOC_DAPM_POST_PMD:
 867                 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
 868         }
 869
 870         return 0;
 871 }
 872
 873 /*
 874  * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
 875  * second one is required that is created as another pipe entity.
 876  * The mixer is responsible for pipe management and represent a pipeline
 877  * instance
 878  */
 879 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
 880                                 struct snd_kcontrol *k, int event)
 881 {
 882         struct snd_soc_dapm_context *dapm = w->dapm;
 883         struct skl *skl = get_skl_ctx(dapm->dev);
 884
 885         switch (event) {
 886         case SND_SOC_DAPM_PRE_PMU:
 887                 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
 888
 889         case SND_SOC_DAPM_POST_PMU:
 890                 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
 891
 892         case SND_SOC_DAPM_PRE_PMD:
 893                 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
 894
 895         case SND_SOC_DAPM_POST_PMD:
 896                 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
 897         }
 898
 899         return 0;
 900 }
 901
 902 /*
 903  * In modelling, we assumed rest of the modules in pipeline are PGA. But we
 904  * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
 905  * the sink when it is running (two FE to one BE or one FE to two BE)
 906  * scenarios
 907  */
 908 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
 909                         struct snd_kcontrol *k, int event)
 910
 911 {
 912         struct snd_soc_dapm_context *dapm = w->dapm;
 913         struct skl *skl = get_skl_ctx(dapm->dev);
 914
 915         switch (event) {
 916         case SND_SOC_DAPM_PRE_PMU:
 917                 return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
 918
 919         case SND_SOC_DAPM_POST_PMD:
 920                 return skl_tplg_pga_dapm_post_pmd_event(w, skl);
 921         }
 922
 923         return 0;
 924 }
 925
 926 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
 927                         unsigned int __user *data, unsigned int size)
 928 {
 929         struct soc_bytes_ext *sb =
 930                         (struct soc_bytes_ext *)kcontrol->private_value;
 931         struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
 932         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
 933         struct skl_module_cfg *mconfig = w->priv;
 934         struct skl *skl = get_skl_ctx(w->dapm->dev);
 935
 936         if (w->power)
 937                 skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
 938                                       bc->max, bc->param_id, mconfig);
 939
 940         /* decrement size for TLV header */
 941         size -= 2 * sizeof(u32);
 942
 943         /* check size as we don't want to send kernel data */
 944         if (size > bc->max)
 945                 size = bc->max;
 946
 947         if (bc->params) {
 948                 if (copy_to_user(data, &bc->param_id, sizeof(u32)))
 949                         return -EFAULT;
 950                 if (copy_to_user(data + 1, &size, sizeof(u32)))
 951                         return -EFAULT;
 952                 if (copy_to_user(data + 2, bc->params, size))
 953                         return -EFAULT;
 954         }
 955
 956         return 0;
 957 }
 958
 959 #define SKL_PARAM_VENDOR_ID 0xff
 960
 961 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
 962                         const unsigned int __user *data, unsigned int size)
 963 {
 964         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
 965         struct skl_module_cfg *mconfig = w->priv;
 966         struct soc_bytes_ext *sb =
 967                         (struct soc_bytes_ext *)kcontrol->private_value;
 968         struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
 969         struct skl *skl = get_skl_ctx(w->dapm->dev);
 970
 971         if (ac->params) {
 972                 /*
 973                  * if the param_is is of type Vendor, firmware expects actual
 974                  * parameter id and size from the control.
 975                  */
 976                 if (ac->param_id == SKL_PARAM_VENDOR_ID) {
 977                         if (copy_from_user(ac->params, data, size))
 978                                 return -EFAULT;
 979                 } else {
 980                         if (copy_from_user(ac->params,
 981                                            data + 2 * sizeof(u32), size))
 982                                 return -EFAULT;
 983                 }
 984
 985                 if (w->power)
 986                         return skl_set_module_params(skl->skl_sst,
 987                                                 (u32 *)ac->params, ac->max,
 988                                                 ac->param_id, mconfig);
 989         }
 990
 991         return 0;
 992 }
 993
 994 /*
 995  * The FE params are passed by hw_params of the DAI.
 996  * On hw_params, the params are stored in Gateway module of the FE and we
 997  * need to calculate the format in DSP module configuration, that
 998  * conversion is done here
 999  */
1000 int skl_tplg_update_pipe_params(struct device *dev,
1001                         struct skl_module_cfg *mconfig,
1002                         struct skl_pipe_params *params)
1003 {
1004         struct skl_pipe *pipe = mconfig->pipe;
1005         struct skl_module_fmt *format = NULL;
1006
1007         memcpy(pipe->p_params, params, sizeof(*params));
1008
1009         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
1010                 format = &mconfig->in_fmt[0];
1011         else
1012                 format = &mconfig->out_fmt[0];
1013
1014         /* set the hw_params */
1015         format->s_freq = params->s_freq;
1016         format->channels = params->ch;
1017         format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1018
1019         /*
1020          * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1021          * container so update bit depth accordingly
1022          */
1023         switch (format->valid_bit_depth) {
1024         case SKL_DEPTH_16BIT:
1025                 format->bit_depth = format->valid_bit_depth;
1026                 break;
1027
1028         case SKL_DEPTH_24BIT:
1029         case SKL_DEPTH_32BIT:
1030                 format->bit_depth = SKL_DEPTH_32BIT;
1031                 break;
1032
1033         default:
1034                 dev_err(dev, "Invalid bit depth %x for pipe\n",
1035                                 format->valid_bit_depth);
1036                 return -EINVAL;
1037         }
1038
1039         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1040                 mconfig->ibs = (format->s_freq / 1000) *
1041                                 (format->channels) *
1042                                 (format->bit_depth >> 3);
1043         } else {
1044                 mconfig->obs = (format->s_freq / 1000) *
1045                                 (format->channels) *
1046                                 (format->bit_depth >> 3);
1047         }
1048
1049         return 0;
1050 }
1051
1052 /*
1053  * Query the module config for the FE DAI
1054  * This is used to find the hw_params set for that DAI and apply to FE
1055  * pipeline
1056  */
1057 struct skl_module_cfg *
1058 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1059 {
1060         struct snd_soc_dapm_widget *w;
1061         struct snd_soc_dapm_path *p = NULL;
1062
1063         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1064                 w = dai->playback_widget;
1065                 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1066                         if (p->connect && p->sink->power &&
1067                                         !is_skl_dsp_widget_type(p->sink))
1068                                 continue;
1069
1070                         if (p->sink->priv) {
1071                                 dev_dbg(dai->dev, "set params for %s\n",
1072                                                 p->sink->name);
1073                                 return p->sink->priv;
1074                         }
1075                 }
1076         } else {
1077                 w = dai->capture_widget;
1078                 snd_soc_dapm_widget_for_each_source_path(w, p) {
1079                         if (p->connect && p->source->power &&
1080                                         !is_skl_dsp_widget_type(p->source))
1081                                 continue;
1082
1083                         if (p->source->priv) {
1084                                 dev_dbg(dai->dev, "set params for %s\n",
1085                                                 p->source->name);
1086                                 return p->source->priv;
1087                         }
1088                 }
1089         }
1090
1091         return NULL;
1092 }
1093
1094 static u8 skl_tplg_be_link_type(int dev_type)
1095 {
1096         int ret;
1097
1098         switch (dev_type) {
1099         case SKL_DEVICE_BT:
1100                 ret = NHLT_LINK_SSP;
1101                 break;
1102
1103         case SKL_DEVICE_DMIC:
1104                 ret = NHLT_LINK_DMIC;
1105                 break;
1106
1107         case SKL_DEVICE_I2S:
1108                 ret = NHLT_LINK_SSP;
1109                 break;
1110
1111         case SKL_DEVICE_HDALINK:
1112                 ret = NHLT_LINK_HDA;
1113                 break;
1114
1115         default:
1116                 ret = NHLT_LINK_INVALID;
1117                 break;
1118         }
1119
1120         return ret;
1121 }
1122
1123 /*
1124  * Fill the BE gateway parameters
1125  * The BE gateway expects a blob of parameters which are kept in the ACPI
1126  * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1127  * The port can have multiple settings so pick based on the PCM
1128  * parameters
1129  */
1130 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1131                                 struct skl_module_cfg *mconfig,
1132                                 struct skl_pipe_params *params)
1133 {
1134         struct skl_pipe *pipe = mconfig->pipe;
1135         struct nhlt_specific_cfg *cfg;
1136         struct skl *skl = get_skl_ctx(dai->dev);
1137         int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1138
1139         memcpy(pipe->p_params, params, sizeof(*params));
1140
1141         if (link_type == NHLT_LINK_HDA)
1142                 return 0;
1143
1144         /* update the blob based on virtual bus_id*/
1145         cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1146                                         params->s_fmt, params->ch,
1147                                         params->s_freq, params->stream);
1148         if (cfg) {
1149                 mconfig->formats_config.caps_size = cfg->size;
1150                 mconfig->formats_config.caps = (u32 *) &cfg->caps;
1151         } else {
1152                 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1153                                         mconfig->vbus_id, link_type,
1154                                         params->stream);
1155                 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1156                                  params->ch, params->s_freq, params->s_fmt);
1157                 return -EINVAL;
1158         }
1159
1160         return 0;
1161 }
1162
1163 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1164                                 struct snd_soc_dapm_widget *w,
1165                                 struct skl_pipe_params *params)
1166 {
1167         struct snd_soc_dapm_path *p;
1168         int ret = -EIO;
1169
1170         snd_soc_dapm_widget_for_each_source_path(w, p) {
1171                 if (p->connect && is_skl_dsp_widget_type(p->source) &&
1172                                                 p->source->priv) {
1173
1174                         ret = skl_tplg_be_fill_pipe_params(dai,
1175                                                 p->source->priv, params);
1176                         if (ret < 0)
1177                                 return ret;
1178                 } else {
1179                         ret = skl_tplg_be_set_src_pipe_params(dai,
1180                                                 p->source, params);
1181                         if (ret < 0)
1182                                 return ret;
1183                 }
1184         }
1185
1186         return ret;
1187 }
1188
1189 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1190         struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1191 {
1192         struct snd_soc_dapm_path *p = NULL;
1193         int ret = -EIO;
1194
1195         snd_soc_dapm_widget_for_each_sink_path(w, p) {
1196                 if (p->connect && is_skl_dsp_widget_type(p->sink) &&
1197                                                 p->sink->priv) {
1198
1199                         ret = skl_tplg_be_fill_pipe_params(dai,
1200                                                 p->sink->priv, params);
1201                         if (ret < 0)
1202                                 return ret;
1203                 } else {
1204                         ret = skl_tplg_be_set_sink_pipe_params(
1205                                                 dai, p->sink, params);
1206                         if (ret < 0)
1207                                 return ret;
1208                 }
1209         }
1210
1211         return ret;
1212 }
1213
1214 /*
1215  * BE hw_params can be a source parameters (capture) or sink parameters
1216  * (playback). Based on sink and source we need to either find the source
1217  * list or the sink list and set the pipeline parameters
1218  */
1219 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1220                                 struct skl_pipe_params *params)
1221 {
1222         struct snd_soc_dapm_widget *w;
1223
1224         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1225                 w = dai->playback_widget;
1226
1227                 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1228
1229         } else {
1230                 w = dai->capture_widget;
1231
1232                 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1233         }
1234
1235         return 0;
1236 }
1237
1238 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1239         {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1240         {SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1241         {SKL_PGA_EVENT, skl_tplg_pga_event},
1242 };
1243
1244 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1245         {SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1246                                         skl_tplg_tlv_control_set},
1247 };
1248
1249 /*
1250  * The topology binary passes the pin info for a module so initialize the pin
1251  * info passed into module instance
1252  */
1253 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1254                                                 struct skl_module_pin *m_pin,
1255                                                 bool is_dynamic, int max_pin)
1256 {
1257         int i;
1258
1259         for (i = 0; i < max_pin; i++) {
1260                 m_pin[i].id.module_id = dfw_pin[i].module_id;
1261                 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1262                 m_pin[i].in_use = false;
1263                 m_pin[i].is_dynamic = is_dynamic;
1264                 m_pin[i].pin_state = SKL_PIN_UNBIND;
1265         }
1266 }
1267
1268 /*
1269  * Add pipeline from topology binary into driver pipeline list
1270  *
1271  * If already added we return that instance
1272  * Otherwise we create a new instance and add into driver list
1273  */
1274 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1275                         struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1276 {
1277         struct skl_pipeline *ppl;
1278         struct skl_pipe *pipe;
1279         struct skl_pipe_params *params;
1280
1281         list_for_each_entry(ppl, &skl->ppl_list, node) {
1282                 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1283                         return ppl->pipe;
1284         }
1285
1286         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1287         if (!ppl)
1288                 return NULL;
1289
1290         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1291         if (!pipe)
1292                 return NULL;
1293
1294         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1295         if (!params)
1296                 return NULL;
1297
1298         pipe->ppl_id = dfw_pipe->pipe_id;
1299         pipe->memory_pages = dfw_pipe->memory_pages;
1300         pipe->pipe_priority = dfw_pipe->pipe_priority;
1301         pipe->conn_type = dfw_pipe->conn_type;
1302         pipe->state = SKL_PIPE_INVALID;
1303         pipe->p_params = params;
1304         INIT_LIST_HEAD(&pipe->w_list);
1305
1306         ppl->pipe = pipe;
1307         list_add(&ppl->node, &skl->ppl_list);
1308
1309         return ppl->pipe;
1310 }
1311
1312 static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
1313                                 struct skl_dfw_module_fmt *src_fmt,
1314                                 int pins)
1315 {
1316         int i;
1317
1318         for (i = 0; i < pins; i++) {
1319                 dst_fmt[i].channels  = src_fmt[i].channels;
1320                 dst_fmt[i].s_freq = src_fmt[i].freq;
1321                 dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
1322                 dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
1323                 dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
1324                 dst_fmt[i].ch_map = src_fmt[i].ch_map;
1325                 dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
1326                 dst_fmt[i].sample_type = src_fmt[i].sample_type;
1327         }
1328 }
1329
1330 /*
1331  * Topology core widget load callback
1332  *
1333  * This is used to save the private data for each widget which gives
1334  * information to the driver about module and pipeline parameters which DSP
1335  * FW expects like ids, resource values, formats etc
1336  */
1337 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1338                                 struct snd_soc_dapm_widget *w,
1339                                 struct snd_soc_tplg_dapm_widget *tplg_w)
1340 {
1341         int ret;
1342         struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1343         struct skl *skl = ebus_to_skl(ebus);
1344         struct hdac_bus *bus = ebus_to_hbus(ebus);
1345         struct skl_module_cfg *mconfig;
1346         struct skl_pipe *pipe;
1347         struct skl_dfw_module *dfw_config =
1348                                 (struct skl_dfw_module *)tplg_w->priv.data;
1349
1350         if (!tplg_w->priv.size)
1351                 goto bind_event;
1352
1353         mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1354
1355         if (!mconfig)
1356                 return -ENOMEM;
1357
1358         w->priv = mconfig;
1359         mconfig->id.module_id = dfw_config->module_id;
1360         mconfig->id.instance_id = dfw_config->instance_id;
1361         mconfig->mcps = dfw_config->max_mcps;
1362         mconfig->ibs = dfw_config->ibs;
1363         mconfig->obs = dfw_config->obs;
1364         mconfig->core_id = dfw_config->core_id;
1365         mconfig->max_in_queue = dfw_config->max_in_queue;
1366         mconfig->max_out_queue = dfw_config->max_out_queue;
1367         mconfig->is_loadable = dfw_config->is_loadable;
1368         skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
1369                                                 MODULE_MAX_IN_PINS);
1370         skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
1371                                                 MODULE_MAX_OUT_PINS);
1372
1373         mconfig->params_fixup = dfw_config->params_fixup;
1374         mconfig->converter = dfw_config->converter;
1375         mconfig->m_type = dfw_config->module_type;
1376         mconfig->vbus_id = dfw_config->vbus_id;
1377         mconfig->mem_pages = dfw_config->mem_pages;
1378
1379         pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1380         if (pipe)
1381                 mconfig->pipe = pipe;
1382
1383         mconfig->dev_type = dfw_config->dev_type;
1384         mconfig->hw_conn_type = dfw_config->hw_conn_type;
1385         mconfig->time_slot = dfw_config->time_slot;
1386         mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1387
1388         if (dfw_config->is_loadable)
1389                 memcpy(mconfig->guid, dfw_config->uuid,
1390                                         ARRAY_SIZE(dfw_config->uuid));
1391
1392         mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
1393                                                 sizeof(*mconfig->m_in_pin),
1394                                                 GFP_KERNEL);
1395         if (!mconfig->m_in_pin)
1396                 return -ENOMEM;
1397
1398         mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1399                                                 sizeof(*mconfig->m_out_pin),
1400                                                 GFP_KERNEL);
1401         if (!mconfig->m_out_pin)
1402                 return -ENOMEM;
1403
1404         skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1405                                                 dfw_config->is_dynamic_in_pin,
1406                                                 mconfig->max_in_queue);
1407
1408         skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1409                                                  dfw_config->is_dynamic_out_pin,
1410                                                         mconfig->max_out_queue);
1411
1412
1413         if (mconfig->formats_config.caps_size == 0)
1414                 goto bind_event;
1415
1416         mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1417                         mconfig->formats_config.caps_size, GFP_KERNEL);
1418
1419         if (mconfig->formats_config.caps == NULL)
1420                 return -ENOMEM;
1421
1422         memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1423                                                  dfw_config->caps.caps_size);
1424         mconfig->formats_config.param_id = dfw_config->caps.param_id;
1425         mconfig->formats_config.set_params = dfw_config->caps.set_params;
1426
1427 bind_event:
1428         if (tplg_w->event_type == 0) {
1429                 dev_dbg(bus->dev, "ASoC: No event handler required\n");
1430                 return 0;
1431         }
1432
1433         ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1434                                         ARRAY_SIZE(skl_tplg_widget_ops),
1435                                         tplg_w->event_type);
1436
1437         if (ret) {
1438                 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1439                                         __func__, tplg_w->event_type);
1440                 return -EINVAL;
1441         }
1442
1443         return 0;
1444 }
1445
1446 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
1447                                         struct snd_soc_tplg_bytes_control *bc)
1448 {
1449         struct skl_algo_data *ac;
1450         struct skl_dfw_algo_data *dfw_ac =
1451                                 (struct skl_dfw_algo_data *)bc->priv.data;
1452
1453         ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
1454         if (!ac)
1455                 return -ENOMEM;
1456
1457         /* Fill private data */
1458         ac->max = dfw_ac->max;
1459         ac->param_id = dfw_ac->param_id;
1460         ac->set_params = dfw_ac->set_params;
1461
1462         if (ac->max) {
1463                 ac->params = (char *) devm_kzalloc(dev, ac->max, GFP_KERNEL);
1464                 if (!ac->params)
1465                         return -ENOMEM;
1466
1467                 if (dfw_ac->params)
1468                         memcpy(ac->params, dfw_ac->params, ac->max);
1469         }
1470
1471         be->dobj.private  = ac;
1472         return 0;
1473 }
1474
1475 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
1476                                 struct snd_kcontrol_new *kctl,
1477                                 struct snd_soc_tplg_ctl_hdr *hdr)
1478 {
1479         struct soc_bytes_ext *sb;
1480         struct snd_soc_tplg_bytes_control *tplg_bc;
1481         struct hdac_ext_bus *ebus  = snd_soc_component_get_drvdata(cmpnt);
1482         struct hdac_bus *bus = ebus_to_hbus(ebus);
1483
1484         switch (hdr->ops.info) {
1485         case SND_SOC_TPLG_CTL_BYTES:
1486                 tplg_bc = container_of(hdr,
1487                                 struct snd_soc_tplg_bytes_control, hdr);
1488                 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1489                         sb = (struct soc_bytes_ext *)kctl->private_value;
1490                         if (tplg_bc->priv.size)
1491                                 return skl_init_algo_data(
1492                                                 bus->dev, sb, tplg_bc);
1493                 }
1494                 break;
1495
1496         default:
1497                 dev_warn(bus->dev, "Control load not supported %d:%d:%d\n",
1498                         hdr->ops.get, hdr->ops.put, hdr->ops.info);
1499                 break;
1500         }
1501
1502         return 0;
1503 }
1504
1505 static struct snd_soc_tplg_ops skl_tplg_ops  = {
1506         .widget_load = skl_tplg_widget_load,
1507         .control_load = skl_tplg_control_load,
1508         .bytes_ext_ops = skl_tlv_ops,
1509         .bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
1510 };
1511
1512 /* This will be read from topology manifest, currently defined here */
1513 #define SKL_MAX_MCPS 30000000
1514 #define SKL_FW_MAX_MEM 1000000
1515
1516 /*
1517  * SKL topology init routine
1518  */
1519 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1520 {
1521         int ret;
1522         const struct firmware *fw;
1523         struct hdac_bus *bus = ebus_to_hbus(ebus);
1524         struct skl *skl = ebus_to_skl(ebus);
1525
1526         ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1527         if (ret < 0) {
1528                 dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1529                                 "dfw_sst.bin", ret);
1530                 return ret;
1531         }
1532
1533         /*
1534          * The complete tplg for SKL is loaded as index 0, we don't use
1535          * any other index
1536          */
1537         ret = snd_soc_tplg_component_load(&platform->component,
1538                                         &skl_tplg_ops, fw, 0);
1539         release_firmware(fw);
1540         if (ret < 0) {
1541                 dev_err(bus->dev, "tplg component load failed%d\n", ret);
1542                 release_firmware(fw);
1543                 return -EINVAL;
1544         }
1545
1546         skl->resource.max_mcps = SKL_MAX_MCPS;
1547         skl->resource.max_mem = SKL_FW_MAX_MEM;
1548
1549         return 0;
1550 }