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 int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
 264                                                 struct skl_sst *ctx)
 265 {
 266         struct skl_module_cfg *m_cfg = w->priv;
 267         int link_type, dir;
 268         u32 ch, s_freq, s_fmt;
 269         struct nhlt_specific_cfg *cfg;
 270         struct skl *skl = get_skl_ctx(ctx->dev);
 271
 272         /* check if we already have blob */
 273         if (m_cfg->formats_config.caps_size > 0)
 274                 return 0;
 275
 276         dev_dbg(ctx->dev, "Applying default cfg blob\n");
 277         switch (m_cfg->dev_type) {
 278         case SKL_DEVICE_DMIC:
 279                 link_type = NHLT_LINK_DMIC;
 280                 dir = SNDRV_PCM_STREAM_CAPTURE;
 281                 s_freq = m_cfg->in_fmt[0].s_freq;
 282                 s_fmt = m_cfg->in_fmt[0].bit_depth;
 283                 ch = m_cfg->in_fmt[0].channels;
 284                 break;
 285
 286         case SKL_DEVICE_I2S:
 287                 link_type = NHLT_LINK_SSP;
 288                 if (m_cfg->hw_conn_type == SKL_CONN_SOURCE) {
 289                         dir = SNDRV_PCM_STREAM_PLAYBACK;
 290                         s_freq = m_cfg->out_fmt[0].s_freq;
 291                         s_fmt = m_cfg->out_fmt[0].bit_depth;
 292                         ch = m_cfg->out_fmt[0].channels;
 293                 } else {
 294                         dir = SNDRV_PCM_STREAM_CAPTURE;
 295                         s_freq = m_cfg->in_fmt[0].s_freq;
 296                         s_fmt = m_cfg->in_fmt[0].bit_depth;
 297                         ch = m_cfg->in_fmt[0].channels;
 298                 }
 299                 break;
 300
 301         default:
 302                 return -EINVAL;
 303         }
 304
 305         /* update the blob based on virtual bus_id and default params */
 306         cfg = skl_get_ep_blob(skl, m_cfg->vbus_id, link_type,
 307                                         s_fmt, ch, s_freq, dir);
 308         if (cfg) {
 309                 m_cfg->formats_config.caps_size = cfg->size;
 310                 m_cfg->formats_config.caps = (u32 *) &cfg->caps;
 311         } else {
 312                 dev_err(ctx->dev, "Blob NULL for id %x type %d dirn %d\n",
 313                                         m_cfg->vbus_id, link_type, dir);
 314                 dev_err(ctx->dev, "PCM: ch %d, freq %d, fmt %d\n",
 315                                         ch, s_freq, s_fmt);
 316                 return -EIO;
 317         }
 318
 319         return 0;
 320 }
 321
 322 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
 323                                                         struct skl_sst *ctx)
 324 {
 325         struct skl_module_cfg *m_cfg = w->priv;
 326         struct skl_pipe_params *params = m_cfg->pipe->p_params;
 327         int p_conn_type = m_cfg->pipe->conn_type;
 328         bool is_fe;
 329
 330         if (!m_cfg->params_fixup)
 331                 return;
 332
 333         dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
 334                                 w->name);
 335
 336         skl_dump_mconfig(ctx, m_cfg);
 337
 338         if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
 339                 is_fe = true;
 340         else
 341                 is_fe = false;
 342
 343         skl_tplg_update_params_fixup(m_cfg, params, is_fe);
 344         skl_tplg_update_buffer_size(ctx, m_cfg);
 345
 346         dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
 347                                 w->name);
 348
 349         skl_dump_mconfig(ctx, m_cfg);
 350 }
 351
 352 /*
 353  * A pipe can have multiple modules, each of them will be a DAPM widget as
 354  * well. While managing a pipeline we need to get the list of all the
 355  * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps
 356  * to get the SKL type widgets in that pipeline
 357  */
 358 static int skl_tplg_alloc_pipe_widget(struct device *dev,
 359         struct snd_soc_dapm_widget *w, struct skl_pipe *pipe)
 360 {
 361         struct skl_module_cfg *src_module = NULL;
 362         struct snd_soc_dapm_path *p = NULL;
 363         struct skl_pipe_module *p_module = NULL;
 364
 365         p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL);
 366         if (!p_module)
 367                 return -ENOMEM;
 368
 369         p_module->w = w;
 370         list_add_tail(&p_module->node, &pipe->w_list);
 371
 372         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 373                 if ((p->sink->priv == NULL)
 374                                 && (!is_skl_dsp_widget_type(w)))
 375                         continue;
 376
 377                 if ((p->sink->priv != NULL) && p->connect
 378                                 && is_skl_dsp_widget_type(p->sink)) {
 379
 380                         src_module = p->sink->priv;
 381                         if (pipe->ppl_id == src_module->pipe->ppl_id)
 382                                 skl_tplg_alloc_pipe_widget(dev,
 383                                                         p->sink, pipe);
 384                 }
 385         }
 386         return 0;
 387 }
 388
 389 /*
 390  * some modules can have multiple params set from user control and
 391  * need to be set after module is initialized. If set_param flag is
 392  * set module params will be done after module is initialised.
 393  */
 394 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
 395                                                 struct skl_sst *ctx)
 396 {
 397         int i, ret;
 398         struct skl_module_cfg *mconfig = w->priv;
 399         const struct snd_kcontrol_new *k;
 400         struct soc_bytes_ext *sb;
 401         struct skl_algo_data *bc;
 402         struct skl_specific_cfg *sp_cfg;
 403
 404         if (mconfig->formats_config.caps_size > 0 &&
 405                 mconfig->formats_config.set_params == SKL_PARAM_SET) {
 406                 sp_cfg = &mconfig->formats_config;
 407                 ret = skl_set_module_params(ctx, sp_cfg->caps,
 408                                         sp_cfg->caps_size,
 409                                         sp_cfg->param_id, mconfig);
 410                 if (ret < 0)
 411                         return ret;
 412         }
 413
 414         for (i = 0; i < w->num_kcontrols; i++) {
 415                 k = &w->kcontrol_news[i];
 416                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 417                         sb = (void *) k->private_value;
 418                         bc = (struct skl_algo_data *)sb->dobj.private;
 419
 420                         if (bc->set_params == SKL_PARAM_SET) {
 421                                 ret = skl_set_module_params(ctx,
 422                                                 (u32 *)bc->params, bc->max,
 423                                                 bc->param_id, mconfig);
 424                                 if (ret < 0)
 425                                         return ret;
 426                         }
 427                 }
 428         }
 429
 430         return 0;
 431 }
 432
 433 /*
 434  * some module param can set from user control and this is required as
 435  * when module is initailzed. if module param is required in init it is
 436  * identifed by set_param flag. if set_param flag is not set, then this
 437  * parameter needs to set as part of module init.
 438  */
 439 static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
 440 {
 441         const struct snd_kcontrol_new *k;
 442         struct soc_bytes_ext *sb;
 443         struct skl_algo_data *bc;
 444         struct skl_module_cfg *mconfig = w->priv;
 445         int i;
 446
 447         for (i = 0; i < w->num_kcontrols; i++) {
 448                 k = &w->kcontrol_news[i];
 449                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 450                         sb = (struct soc_bytes_ext *)k->private_value;
 451                         bc = (struct skl_algo_data *)sb->dobj.private;
 452
 453                         if (bc->set_params != SKL_PARAM_INIT)
 454                                 continue;
 455
 456                         mconfig->formats_config.caps = (u32 *)&bc->params;
 457                         mconfig->formats_config.caps_size = bc->max;
 458
 459                         break;
 460                 }
 461         }
 462
 463         return 0;
 464 }
 465
 466 /*
 467  * Inside a pipe instance, we can have various modules. These modules need
 468  * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
 469  * skl_init_module() routine, so invoke that for all modules in a pipeline
 470  */
 471 static int
 472 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
 473 {
 474         struct skl_pipe_module *w_module;
 475         struct snd_soc_dapm_widget *w;
 476         struct skl_module_cfg *mconfig;
 477         struct skl_sst *ctx = skl->skl_sst;
 478         int ret = 0;
 479
 480         list_for_each_entry(w_module, &pipe->w_list, node) {
 481                 w = w_module->w;
 482                 mconfig = w->priv;
 483
 484                 /* check resource available */
 485                 if (!skl_is_pipe_mcps_avail(skl, mconfig))
 486                         return -ENOMEM;
 487
 488                 if (mconfig->is_loadable && ctx->dsp->fw_ops.load_mod) {
 489                         ret = ctx->dsp->fw_ops.load_mod(ctx->dsp,
 490                                 mconfig->id.module_id, mconfig->guid);
 491                         if (ret < 0)
 492                                 return ret;
 493                 }
 494
 495                 /* update blob if blob is null for be with default value */
 496                 skl_tplg_update_be_blob(w, ctx);
 497
 498                 /*
 499                  * apply fix/conversion to module params based on
 500                  * FE/BE params
 501                  */
 502                 skl_tplg_update_module_params(w, ctx);
 503
 504                 skl_tplg_set_module_init_data(w);
 505                 ret = skl_init_module(ctx, mconfig);
 506                 if (ret < 0)
 507                         return ret;
 508
 509                 ret = skl_tplg_set_module_params(w, ctx);
 510                 if (ret < 0)
 511                         return ret;
 512                 skl_tplg_alloc_pipe_mcps(skl, mconfig);
 513         }
 514
 515         return 0;
 516 }
 517
 518 static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
 519          struct skl_pipe *pipe)
 520 {
 521         struct skl_pipe_module *w_module = NULL;
 522         struct skl_module_cfg *mconfig = NULL;
 523
 524         list_for_each_entry(w_module, &pipe->w_list, node) {
 525                 mconfig  = w_module->w->priv;
 526
 527                 if (mconfig->is_loadable && ctx->dsp->fw_ops.unload_mod)
 528                         return ctx->dsp->fw_ops.unload_mod(ctx->dsp,
 529                                                 mconfig->id.module_id);
 530         }
 531
 532         /* no modules to unload in this path, so return */
 533         return 0;
 534 }
 535
 536 /*
 537  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
 538  * need create the pipeline. So we do following:
 539  *   - check the resources
 540  *   - Create the pipeline
 541  *   - Initialize the modules in pipeline
 542  *   - finally bind all modules together
 543  */
 544 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 545                                                         struct skl *skl)
 546 {
 547         int ret;
 548         struct skl_module_cfg *mconfig = w->priv;
 549         struct skl_pipe_module *w_module;
 550         struct skl_pipe *s_pipe = mconfig->pipe;
 551         struct skl_module_cfg *src_module = NULL, *dst_module;
 552         struct skl_sst *ctx = skl->skl_sst;
 553
 554         /* check resource available */
 555         if (!skl_is_pipe_mcps_avail(skl, mconfig))
 556                 return -EBUSY;
 557
 558         if (!skl_is_pipe_mem_avail(skl, mconfig))
 559                 return -ENOMEM;
 560
 561         /*
 562          * Create a list of modules for pipe.
 563          * This list contains modules from source to sink
 564          */
 565         ret = skl_create_pipeline(ctx, mconfig->pipe);
 566         if (ret < 0)
 567                 return ret;
 568
 569         /*
 570          * we create a w_list of all widgets in that pipe. This list is not
 571          * freed on PMD event as widgets within a pipe are static. This
 572          * saves us cycles to get widgets in pipe every time.
 573          *
 574          * So if we have already initialized all the widgets of a pipeline
 575          * we skip, so check for list_empty and create the list if empty
 576          */
 577         if (list_empty(&s_pipe->w_list)) {
 578                 ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe);
 579                 if (ret < 0)
 580                         return ret;
 581         }
 582
 583         /* Init all pipe modules from source to sink */
 584         ret = skl_tplg_init_pipe_modules(skl, s_pipe);
 585         if (ret < 0)
 586                 return ret;
 587
 588         /* Bind modules from source to sink */
 589         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 590                 dst_module = w_module->w->priv;
 591
 592                 if (src_module == NULL) {
 593                         src_module = dst_module;
 594                         continue;
 595                 }
 596
 597                 ret = skl_bind_modules(ctx, src_module, dst_module);
 598                 if (ret < 0)
 599                         return ret;
 600
 601                 src_module = dst_module;
 602         }
 603
 604         skl_tplg_alloc_pipe_mem(skl, mconfig);
 605         skl_tplg_alloc_pipe_mcps(skl, mconfig);
 606
 607         return 0;
 608 }
 609
 610 /*
 611  * Some modules require params to be set after the module is bound to
 612  * all pins connected.
 613  *
 614  * The module provider initializes set_param flag for such modules and we
 615  * send params after binding
 616  */
 617 static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
 618                         struct skl_module_cfg *mcfg, struct skl_sst *ctx)
 619 {
 620         int i, ret;
 621         struct skl_module_cfg *mconfig = w->priv;
 622         const struct snd_kcontrol_new *k;
 623         struct soc_bytes_ext *sb;
 624         struct skl_algo_data *bc;
 625         struct skl_specific_cfg *sp_cfg;
 626
 627         /*
 628          * check all out/in pins are in bind state.
 629          * if so set the module param
 630          */
 631         for (i = 0; i < mcfg->max_out_queue; i++) {
 632                 if (mcfg->m_out_pin[i].pin_state != SKL_PIN_BIND_DONE)
 633                         return 0;
 634         }
 635
 636         for (i = 0; i < mcfg->max_in_queue; i++) {
 637                 if (mcfg->m_in_pin[i].pin_state != SKL_PIN_BIND_DONE)
 638                         return 0;
 639         }
 640
 641         if (mconfig->formats_config.caps_size > 0 &&
 642                 mconfig->formats_config.set_params == SKL_PARAM_BIND) {
 643                 sp_cfg = &mconfig->formats_config;
 644                 ret = skl_set_module_params(ctx, sp_cfg->caps,
 645                                         sp_cfg->caps_size,
 646                                         sp_cfg->param_id, mconfig);
 647                 if (ret < 0)
 648                         return ret;
 649         }
 650
 651         for (i = 0; i < w->num_kcontrols; i++) {
 652                 k = &w->kcontrol_news[i];
 653                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 654                         sb = (void *) k->private_value;
 655                         bc = (struct skl_algo_data *)sb->dobj.private;
 656
 657                         if (bc->set_params == SKL_PARAM_BIND) {
 658                                 ret = skl_set_module_params(ctx,
 659                                                 (u32 *)bc->params, bc->max,
 660                                                 bc->param_id, mconfig);
 661                                 if (ret < 0)
 662                                         return ret;
 663                         }
 664                 }
 665         }
 666
 667         return 0;
 668 }
 669
 670 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
 671                                 struct skl *skl,
 672                                 struct snd_soc_dapm_widget *src_w,
 673                                 struct skl_module_cfg *src_mconfig)
 674 {
 675         struct snd_soc_dapm_path *p;
 676         struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
 677         struct skl_module_cfg *sink_mconfig;
 678         struct skl_sst *ctx = skl->skl_sst;
 679         int ret;
 680
 681         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 682                 if (!p->connect)
 683                         continue;
 684
 685                 dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
 686                 dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
 687
 688                 next_sink = p->sink;
 689
 690                 if (!is_skl_dsp_widget_type(p->sink))
 691                         return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
 692
 693                 /*
 694                  * here we will check widgets in sink pipelines, so that
 695                  * can be any widgets type and we are only interested if
 696                  * they are ones used for SKL so check that first
 697                  */
 698                 if ((p->sink->priv != NULL) &&
 699                                         is_skl_dsp_widget_type(p->sink)) {
 700
 701                         sink = p->sink;
 702                         sink_mconfig = sink->priv;
 703
 704                         if (src_mconfig->m_state == SKL_MODULE_UNINIT ||
 705                                 sink_mconfig->m_state == SKL_MODULE_UNINIT)
 706                                 continue;
 707
 708                         /* Bind source to sink, mixin is always source */
 709                         ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
 710                         if (ret)
 711                                 return ret;
 712
 713                         /* set module params after bind */
 714                         skl_tplg_set_module_bind_params(src_w, src_mconfig, ctx);
 715                         skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
 716
 717                         /* Start sinks pipe first */
 718                         if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
 719                                 if (sink_mconfig->pipe->conn_type !=
 720                                                         SKL_PIPE_CONN_TYPE_FE)
 721                                         ret = skl_run_pipe(ctx,
 722                                                         sink_mconfig->pipe);
 723                                 if (ret)
 724                                         return ret;
 725                         }
 726                 }
 727         }
 728
 729         if (!sink)
 730                 return skl_tplg_bind_sinks(next_sink, skl, src_w, src_mconfig);
 731
 732         return 0;
 733 }
 734
 735 /*
 736  * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
 737  * we need to do following:
 738  *   - Bind to sink pipeline
 739  *      Since the sink pipes can be running and we don't get mixer event on
 740  *      connect for already running mixer, we need to find the sink pipes
 741  *      here and bind to them. This way dynamic connect works.
 742  *   - Start sink pipeline, if not running
 743  *   - Then run current pipe
 744  */
 745 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 746                                                                 struct skl *skl)
 747 {
 748         struct skl_module_cfg *src_mconfig;
 749         struct skl_sst *ctx = skl->skl_sst;
 750         int ret = 0;
 751
 752         src_mconfig = w->priv;
 753
 754         /*
 755          * find which sink it is connected to, bind with the sink,
 756          * if sink is not started, start sink pipe first, then start
 757          * this pipe
 758          */
 759         ret = skl_tplg_bind_sinks(w, skl, w, src_mconfig);
 760         if (ret)
 761                 return ret;
 762
 763         /* Start source pipe last after starting all sinks */
 764         if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
 765                 return skl_run_pipe(ctx, src_mconfig->pipe);
 766
 767         return 0;
 768 }
 769
 770 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
 771                 struct snd_soc_dapm_widget *w, struct skl *skl)
 772 {
 773         struct snd_soc_dapm_path *p;
 774         struct snd_soc_dapm_widget *src_w = NULL;
 775         struct skl_sst *ctx = skl->skl_sst;
 776
 777         snd_soc_dapm_widget_for_each_source_path(w, p) {
 778                 src_w = p->source;
 779                 if (!p->connect)
 780                         continue;
 781
 782                 dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
 783                 dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
 784
 785                 /*
 786                  * here we will check widgets in sink pipelines, so that can
 787                  * be any widgets type and we are only interested if they are
 788                  * ones used for SKL so check that first
 789                  */
 790                 if ((p->source->priv != NULL) &&
 791                                         is_skl_dsp_widget_type(p->source)) {
 792                         return p->source;
 793                 }
 794         }
 795
 796         if (src_w != NULL)
 797                 return skl_get_src_dsp_widget(src_w, skl);
 798
 799         return NULL;
 800 }
 801
 802 /*
 803  * in the Post-PMU event of mixer we need to do following:
 804  *   - Check if this pipe is running
 805  *   - if not, then
 806  *      - bind this pipeline to its source pipeline
 807  *        if source pipe is already running, this means it is a dynamic
 808  *        connection and we need to bind only to that pipe
 809  *      - start this pipeline
 810  */
 811 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
 812                                                         struct skl *skl)
 813 {
 814         int ret = 0;
 815         struct snd_soc_dapm_widget *source, *sink;
 816         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 817         struct skl_sst *ctx = skl->skl_sst;
 818         int src_pipe_started = 0;
 819
 820         sink = w;
 821         sink_mconfig = sink->priv;
 822
 823         /*
 824          * If source pipe is already started, that means source is driving
 825          * one more sink before this sink got connected, Since source is
 826          * started, bind this sink to source and start this pipe.
 827          */
 828         source = skl_get_src_dsp_widget(w, skl);
 829         if (source != NULL) {
 830                 src_mconfig = source->priv;
 831                 sink_mconfig = sink->priv;
 832                 src_pipe_started = 1;
 833
 834                 /*
 835                  * check pipe state, then no need to bind or start the
 836                  * pipe
 837                  */
 838                 if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
 839                         src_pipe_started = 0;
 840         }
 841
 842         if (src_pipe_started) {
 843                 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
 844                 if (ret)
 845                         return ret;
 846
 847                 /* set module params after bind */
 848                 skl_tplg_set_module_bind_params(source, src_mconfig, ctx);
 849                 skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
 850
 851                 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
 852                         ret = skl_run_pipe(ctx, sink_mconfig->pipe);
 853         }
 854
 855         return ret;
 856 }
 857
 858 /*
 859  * in the Pre-PMD event of mixer we need to do following:
 860  *   - Stop the pipe
 861  *   - find the source connections and remove that from dapm_path_list
 862  *   - unbind with source pipelines if still connected
 863  */
 864 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
 865                                                         struct skl *skl)
 866 {
 867         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 868         int ret = 0, i;
 869         struct skl_sst *ctx = skl->skl_sst;
 870
 871         sink_mconfig = w->priv;
 872
 873         /* Stop the pipe */
 874         ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
 875         if (ret)
 876                 return ret;
 877
 878         for (i = 0; i < sink_mconfig->max_in_queue; i++) {
 879                 if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
 880                         src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
 881                         if (!src_mconfig)
 882                                 continue;
 883                         /*
 884                          * If path_found == 1, that means pmd for source
 885                          * pipe has not occurred, source is connected to
 886                          * some other sink. so its responsibility of sink
 887                          * to unbind itself from source.
 888                          */
 889                         ret = skl_stop_pipe(ctx, src_mconfig->pipe);
 890                         if (ret < 0)
 891                                 return ret;
 892
 893                         ret = skl_unbind_modules(ctx,
 894                                                 src_mconfig, sink_mconfig);
 895                 }
 896         }
 897
 898         return ret;
 899 }
 900
 901 /*
 902  * in the Post-PMD event of mixer we need to do following:
 903  *   - Free the mcps used
 904  *   - Free the mem used
 905  *   - Unbind the modules within the pipeline
 906  *   - Delete the pipeline (modules are not required to be explicitly
 907  *     deleted, pipeline delete is enough here
 908  */
 909 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
 910                                                         struct skl *skl)
 911 {
 912         struct skl_module_cfg *mconfig = w->priv;
 913         struct skl_pipe_module *w_module;
 914         struct skl_module_cfg *src_module = NULL, *dst_module;
 915         struct skl_sst *ctx = skl->skl_sst;
 916         struct skl_pipe *s_pipe = mconfig->pipe;
 917         int ret = 0;
 918
 919         skl_tplg_free_pipe_mcps(skl, mconfig);
 920         skl_tplg_free_pipe_mem(skl, mconfig);
 921
 922         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 923                 dst_module = w_module->w->priv;
 924
 925                 skl_tplg_free_pipe_mcps(skl, dst_module);
 926                 if (src_module == NULL) {
 927                         src_module = dst_module;
 928                         continue;
 929                 }
 930
 931                 skl_unbind_modules(ctx, src_module, dst_module);
 932                 src_module = dst_module;
 933         }
 934
 935         ret = skl_delete_pipe(ctx, mconfig->pipe);
 936
 937         return skl_tplg_unload_pipe_modules(ctx, s_pipe);
 938 }
 939
 940 /*
 941  * in the Post-PMD event of PGA we need to do following:
 942  *   - Free the mcps used
 943  *   - Stop the pipeline
 944  *   - In source pipe is connected, unbind with source pipelines
 945  */
 946 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
 947                                                                 struct skl *skl)
 948 {
 949         struct skl_module_cfg *src_mconfig, *sink_mconfig;
 950         int ret = 0, i;
 951         struct skl_sst *ctx = skl->skl_sst;
 952
 953         src_mconfig = w->priv;
 954
 955         /* Stop the pipe since this is a mixin module */
 956         ret = skl_stop_pipe(ctx, src_mconfig->pipe);
 957         if (ret)
 958                 return ret;
 959
 960         for (i = 0; i < src_mconfig->max_out_queue; i++) {
 961                 if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
 962                         sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
 963                         if (!sink_mconfig)
 964                                 continue;
 965                         /*
 966                          * This is a connecter and if path is found that means
 967                          * unbind between source and sink has not happened yet
 968                          */
 969                         ret = skl_unbind_modules(ctx, src_mconfig,
 970                                                         sink_mconfig);
 971                 }
 972         }
 973
 974         return ret;
 975 }
 976
 977 /*
 978  * In modelling, we assume there will be ONLY one mixer in a pipeline.  If
 979  * mixer is not required then it is treated as static mixer aka vmixer with
 980  * a hard path to source module
 981  * So we don't need to check if source is started or not as hard path puts
 982  * dependency on each other
 983  */
 984 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
 985                                 struct snd_kcontrol *k, int event)
 986 {
 987         struct snd_soc_dapm_context *dapm = w->dapm;
 988         struct skl *skl = get_skl_ctx(dapm->dev);
 989
 990         switch (event) {
 991         case SND_SOC_DAPM_PRE_PMU:
 992                 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
 993
 994         case SND_SOC_DAPM_POST_PMU:
 995                 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
 996
 997         case SND_SOC_DAPM_PRE_PMD:
 998                 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
 999
1000         case SND_SOC_DAPM_POST_PMD:
1001                 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
1002         }
1003
1004         return 0;
1005 }
1006
1007 /*
1008  * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
1009  * second one is required that is created as another pipe entity.
1010  * The mixer is responsible for pipe management and represent a pipeline
1011  * instance
1012  */
1013 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
1014                                 struct snd_kcontrol *k, int event)
1015 {
1016         struct snd_soc_dapm_context *dapm = w->dapm;
1017         struct skl *skl = get_skl_ctx(dapm->dev);
1018
1019         switch (event) {
1020         case SND_SOC_DAPM_PRE_PMU:
1021                 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
1022
1023         case SND_SOC_DAPM_POST_PMU:
1024                 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
1025
1026         case SND_SOC_DAPM_PRE_PMD:
1027                 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
1028
1029         case SND_SOC_DAPM_POST_PMD:
1030                 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
1031         }
1032
1033         return 0;
1034 }
1035
1036 /*
1037  * In modelling, we assumed rest of the modules in pipeline are PGA. But we
1038  * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
1039  * the sink when it is running (two FE to one BE or one FE to two BE)
1040  * scenarios
1041  */
1042 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
1043                         struct snd_kcontrol *k, int event)
1044
1045 {
1046         struct snd_soc_dapm_context *dapm = w->dapm;
1047         struct skl *skl = get_skl_ctx(dapm->dev);
1048
1049         switch (event) {
1050         case SND_SOC_DAPM_PRE_PMU:
1051                 return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
1052
1053         case SND_SOC_DAPM_POST_PMD:
1054                 return skl_tplg_pga_dapm_post_pmd_event(w, skl);
1055         }
1056
1057         return 0;
1058 }
1059
1060 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
1061                         unsigned int __user *data, unsigned int size)
1062 {
1063         struct soc_bytes_ext *sb =
1064                         (struct soc_bytes_ext *)kcontrol->private_value;
1065         struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
1066         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1067         struct skl_module_cfg *mconfig = w->priv;
1068         struct skl *skl = get_skl_ctx(w->dapm->dev);
1069
1070         if (w->power)
1071                 skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
1072                                       bc->max, bc->param_id, mconfig);
1073
1074         /* decrement size for TLV header */
1075         size -= 2 * sizeof(u32);
1076
1077         /* check size as we don't want to send kernel data */
1078         if (size > bc->max)
1079                 size = bc->max;
1080
1081         if (bc->params) {
1082                 if (copy_to_user(data, &bc->param_id, sizeof(u32)))
1083                         return -EFAULT;
1084                 if (copy_to_user(data + 1, &size, sizeof(u32)))
1085                         return -EFAULT;
1086                 if (copy_to_user(data + 2, bc->params, size))
1087                         return -EFAULT;
1088         }
1089
1090         return 0;
1091 }
1092
1093 #define SKL_PARAM_VENDOR_ID 0xff
1094
1095 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
1096                         const unsigned int __user *data, unsigned int size)
1097 {
1098         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1099         struct skl_module_cfg *mconfig = w->priv;
1100         struct soc_bytes_ext *sb =
1101                         (struct soc_bytes_ext *)kcontrol->private_value;
1102         struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
1103         struct skl *skl = get_skl_ctx(w->dapm->dev);
1104
1105         if (ac->params) {
1106                 /*
1107                  * if the param_is is of type Vendor, firmware expects actual
1108                  * parameter id and size from the control.
1109                  */
1110                 if (ac->param_id == SKL_PARAM_VENDOR_ID) {
1111                         if (copy_from_user(ac->params, data, size))
1112                                 return -EFAULT;
1113                 } else {
1114                         if (copy_from_user(ac->params,
1115                                            data + 2, size))
1116                                 return -EFAULT;
1117                 }
1118
1119                 if (w->power)
1120                         return skl_set_module_params(skl->skl_sst,
1121                                                 (u32 *)ac->params, ac->max,
1122                                                 ac->param_id, mconfig);
1123         }
1124
1125         return 0;
1126 }
1127
1128 /*
1129  * The FE params are passed by hw_params of the DAI.
1130  * On hw_params, the params are stored in Gateway module of the FE and we
1131  * need to calculate the format in DSP module configuration, that
1132  * conversion is done here
1133  */
1134 int skl_tplg_update_pipe_params(struct device *dev,
1135                         struct skl_module_cfg *mconfig,
1136                         struct skl_pipe_params *params)
1137 {
1138         struct skl_pipe *pipe = mconfig->pipe;
1139         struct skl_module_fmt *format = NULL;
1140
1141         memcpy(pipe->p_params, params, sizeof(*params));
1142
1143         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
1144                 format = &mconfig->in_fmt[0];
1145         else
1146                 format = &mconfig->out_fmt[0];
1147
1148         /* set the hw_params */
1149         format->s_freq = params->s_freq;
1150         format->channels = params->ch;
1151         format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1152
1153         /*
1154          * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1155          * container so update bit depth accordingly
1156          */
1157         switch (format->valid_bit_depth) {
1158         case SKL_DEPTH_16BIT:
1159                 format->bit_depth = format->valid_bit_depth;
1160                 break;
1161
1162         case SKL_DEPTH_24BIT:
1163         case SKL_DEPTH_32BIT:
1164                 format->bit_depth = SKL_DEPTH_32BIT;
1165                 break;
1166
1167         default:
1168                 dev_err(dev, "Invalid bit depth %x for pipe\n",
1169                                 format->valid_bit_depth);
1170                 return -EINVAL;
1171         }
1172
1173         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1174                 mconfig->ibs = (format->s_freq / 1000) *
1175                                 (format->channels) *
1176                                 (format->bit_depth >> 3);
1177         } else {
1178                 mconfig->obs = (format->s_freq / 1000) *
1179                                 (format->channels) *
1180                                 (format->bit_depth >> 3);
1181         }
1182
1183         return 0;
1184 }
1185
1186 /*
1187  * Query the module config for the FE DAI
1188  * This is used to find the hw_params set for that DAI and apply to FE
1189  * pipeline
1190  */
1191 struct skl_module_cfg *
1192 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1193 {
1194         struct snd_soc_dapm_widget *w;
1195         struct snd_soc_dapm_path *p = NULL;
1196
1197         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1198                 w = dai->playback_widget;
1199                 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1200                         if (p->connect && p->sink->power &&
1201                                         !is_skl_dsp_widget_type(p->sink))
1202                                 continue;
1203
1204                         if (p->sink->priv) {
1205                                 dev_dbg(dai->dev, "set params for %s\n",
1206                                                 p->sink->name);
1207                                 return p->sink->priv;
1208                         }
1209                 }
1210         } else {
1211                 w = dai->capture_widget;
1212                 snd_soc_dapm_widget_for_each_source_path(w, p) {
1213                         if (p->connect && p->source->power &&
1214                                         !is_skl_dsp_widget_type(p->source))
1215                                 continue;
1216
1217                         if (p->source->priv) {
1218                                 dev_dbg(dai->dev, "set params for %s\n",
1219                                                 p->source->name);
1220                                 return p->source->priv;
1221                         }
1222                 }
1223         }
1224
1225         return NULL;
1226 }
1227
1228 static struct skl_module_cfg *skl_get_mconfig_pb_cpr(
1229                 struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1230 {
1231         struct snd_soc_dapm_path *p;
1232         struct skl_module_cfg *mconfig = NULL;
1233
1234         snd_soc_dapm_widget_for_each_source_path(w, p) {
1235                 if (w->endpoints[SND_SOC_DAPM_DIR_OUT] > 0) {
1236                         if (p->connect &&
1237                                     (p->sink->id == snd_soc_dapm_aif_out) &&
1238                                     p->source->priv) {
1239                                 mconfig = p->source->priv;
1240                                 return mconfig;
1241                         }
1242                         mconfig = skl_get_mconfig_pb_cpr(dai, p->source);
1243                         if (mconfig)
1244                                 return mconfig;
1245                 }
1246         }
1247         return mconfig;
1248 }
1249
1250 static struct skl_module_cfg *skl_get_mconfig_cap_cpr(
1251                 struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1252 {
1253         struct snd_soc_dapm_path *p;
1254         struct skl_module_cfg *mconfig = NULL;
1255
1256         snd_soc_dapm_widget_for_each_sink_path(w, p) {
1257                 if (w->endpoints[SND_SOC_DAPM_DIR_IN] > 0) {
1258                         if (p->connect &&
1259                                     (p->source->id == snd_soc_dapm_aif_in) &&
1260                                     p->sink->priv) {
1261                                 mconfig = p->sink->priv;
1262                                 return mconfig;
1263                         }
1264                         mconfig = skl_get_mconfig_cap_cpr(dai, p->sink);
1265                         if (mconfig)
1266                                 return mconfig;
1267                 }
1268         }
1269         return mconfig;
1270 }
1271
1272 struct skl_module_cfg *
1273 skl_tplg_be_get_cpr_module(struct snd_soc_dai *dai, int stream)
1274 {
1275         struct snd_soc_dapm_widget *w;
1276         struct skl_module_cfg *mconfig;
1277
1278         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1279                 w = dai->playback_widget;
1280                 mconfig = skl_get_mconfig_pb_cpr(dai, w);
1281         } else {
1282                 w = dai->capture_widget;
1283                 mconfig = skl_get_mconfig_cap_cpr(dai, w);
1284         }
1285         return mconfig;
1286 }
1287
1288 static u8 skl_tplg_be_link_type(int dev_type)
1289 {
1290         int ret;
1291
1292         switch (dev_type) {
1293         case SKL_DEVICE_BT:
1294                 ret = NHLT_LINK_SSP;
1295                 break;
1296
1297         case SKL_DEVICE_DMIC:
1298                 ret = NHLT_LINK_DMIC;
1299                 break;
1300
1301         case SKL_DEVICE_I2S:
1302                 ret = NHLT_LINK_SSP;
1303                 break;
1304
1305         case SKL_DEVICE_HDALINK:
1306                 ret = NHLT_LINK_HDA;
1307                 break;
1308
1309         default:
1310                 ret = NHLT_LINK_INVALID;
1311                 break;
1312         }
1313
1314         return ret;
1315 }
1316
1317 /*
1318  * Fill the BE gateway parameters
1319  * The BE gateway expects a blob of parameters which are kept in the ACPI
1320  * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1321  * The port can have multiple settings so pick based on the PCM
1322  * parameters
1323  */
1324 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1325                                 struct skl_module_cfg *mconfig,
1326                                 struct skl_pipe_params *params)
1327 {
1328         struct skl_pipe *pipe = mconfig->pipe;
1329         struct nhlt_specific_cfg *cfg;
1330         struct skl *skl = get_skl_ctx(dai->dev);
1331         int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1332
1333         memcpy(pipe->p_params, params, sizeof(*params));
1334
1335         if (link_type == NHLT_LINK_HDA)
1336                 return 0;
1337
1338         /* update the blob based on virtual bus_id*/
1339         cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1340                                         params->s_fmt, params->ch,
1341                                         params->s_freq, params->stream);
1342         if (cfg) {
1343                 mconfig->formats_config.caps_size = cfg->size;
1344                 mconfig->formats_config.caps = (u32 *) &cfg->caps;
1345         } else {
1346                 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1347                                         mconfig->vbus_id, link_type,
1348                                         params->stream);
1349                 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1350                                  params->ch, params->s_freq, params->s_fmt);
1351                 return -EINVAL;
1352         }
1353
1354         return 0;
1355 }
1356
1357 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1358                                 struct snd_soc_dapm_widget *w,
1359                                 struct skl_pipe_params *params)
1360 {
1361         struct snd_soc_dapm_path *p;
1362         int ret = -EIO;
1363
1364         snd_soc_dapm_widget_for_each_source_path(w, p) {
1365                 if (p->connect && is_skl_dsp_widget_type(p->source) &&
1366                                                 p->source->priv) {
1367
1368                         ret = skl_tplg_be_fill_pipe_params(dai,
1369                                                 p->source->priv, params);
1370                         if (ret < 0)
1371                                 return ret;
1372                 } else {
1373                         ret = skl_tplg_be_set_src_pipe_params(dai,
1374                                                 p->source, params);
1375                         if (ret < 0)
1376                                 return ret;
1377                 }
1378         }
1379
1380         return ret;
1381 }
1382
1383 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1384         struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1385 {
1386         struct snd_soc_dapm_path *p = NULL;
1387         int ret = -EIO;
1388
1389         snd_soc_dapm_widget_for_each_sink_path(w, p) {
1390                 if (p->connect && is_skl_dsp_widget_type(p->sink) &&
1391                                                 p->sink->priv) {
1392
1393                         ret = skl_tplg_be_fill_pipe_params(dai,
1394                                                 p->sink->priv, params);
1395                         if (ret < 0)
1396                                 return ret;
1397                 } else {
1398                         ret = skl_tplg_be_set_sink_pipe_params(
1399                                                 dai, p->sink, params);
1400                         if (ret < 0)
1401                                 return ret;
1402                 }
1403         }
1404
1405         return ret;
1406 }
1407
1408 /*
1409  * BE hw_params can be a source parameters (capture) or sink parameters
1410  * (playback). Based on sink and source we need to either find the source
1411  * list or the sink list and set the pipeline parameters
1412  */
1413 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1414                                 struct skl_pipe_params *params)
1415 {
1416         struct snd_soc_dapm_widget *w;
1417
1418         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1419                 w = dai->playback_widget;
1420
1421                 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1422
1423         } else {
1424                 w = dai->capture_widget;
1425
1426                 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1427         }
1428
1429         return 0;
1430 }
1431
1432 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1433         {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1434         {SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1435         {SKL_PGA_EVENT, skl_tplg_pga_event},
1436 };
1437
1438 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1439         {SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1440                                         skl_tplg_tlv_control_set},
1441 };
1442
1443 /*
1444  * The topology binary passes the pin info for a module so initialize the pin
1445  * info passed into module instance
1446  */
1447 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1448                                                 struct skl_module_pin *m_pin,
1449                                                 bool is_dynamic, int max_pin)
1450 {
1451         int i;
1452
1453         for (i = 0; i < max_pin; i++) {
1454                 m_pin[i].id.module_id = dfw_pin[i].module_id;
1455                 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1456                 m_pin[i].in_use = false;
1457                 m_pin[i].is_dynamic = is_dynamic;
1458                 m_pin[i].pin_state = SKL_PIN_UNBIND;
1459         }
1460 }
1461
1462 /*
1463  * Add pipeline from topology binary into driver pipeline list
1464  *
1465  * If already added we return that instance
1466  * Otherwise we create a new instance and add into driver list
1467  */
1468 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1469                         struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1470 {
1471         struct skl_pipeline *ppl;
1472         struct skl_pipe *pipe;
1473         struct skl_pipe_params *params;
1474
1475         list_for_each_entry(ppl, &skl->ppl_list, node) {
1476                 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1477                         return ppl->pipe;
1478         }
1479
1480         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1481         if (!ppl)
1482                 return NULL;
1483
1484         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1485         if (!pipe)
1486                 return NULL;
1487
1488         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1489         if (!params)
1490                 return NULL;
1491
1492         pipe->ppl_id = dfw_pipe->pipe_id;
1493         pipe->memory_pages = dfw_pipe->memory_pages;
1494         pipe->pipe_priority = dfw_pipe->pipe_priority;
1495         pipe->conn_type = dfw_pipe->conn_type;
1496         pipe->state = SKL_PIPE_INVALID;
1497         pipe->p_params = params;
1498         INIT_LIST_HEAD(&pipe->w_list);
1499
1500         ppl->pipe = pipe;
1501         list_add(&ppl->node, &skl->ppl_list);
1502
1503         return ppl->pipe;
1504 }
1505
1506 static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
1507                                 struct skl_dfw_module_fmt *src_fmt,
1508                                 int pins)
1509 {
1510         int i;
1511
1512         for (i = 0; i < pins; i++) {
1513                 dst_fmt[i].channels  = src_fmt[i].channels;
1514                 dst_fmt[i].s_freq = src_fmt[i].freq;
1515                 dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
1516                 dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
1517                 dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
1518                 dst_fmt[i].ch_map = src_fmt[i].ch_map;
1519                 dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
1520                 dst_fmt[i].sample_type = src_fmt[i].sample_type;
1521         }
1522 }
1523
1524 /*
1525  * Topology core widget load callback
1526  *
1527  * This is used to save the private data for each widget which gives
1528  * information to the driver about module and pipeline parameters which DSP
1529  * FW expects like ids, resource values, formats etc
1530  */
1531 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1532                                 struct snd_soc_dapm_widget *w,
1533                                 struct snd_soc_tplg_dapm_widget *tplg_w)
1534 {
1535         int ret;
1536         struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1537         struct skl *skl = ebus_to_skl(ebus);
1538         struct hdac_bus *bus = ebus_to_hbus(ebus);
1539         struct skl_module_cfg *mconfig;
1540         struct skl_pipe *pipe;
1541         struct skl_dfw_module *dfw_config =
1542                                 (struct skl_dfw_module *)tplg_w->priv.data;
1543
1544         if (!tplg_w->priv.size)
1545                 goto bind_event;
1546
1547         mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1548
1549         if (!mconfig)
1550                 return -ENOMEM;
1551
1552         w->priv = mconfig;
1553         mconfig->id.module_id = dfw_config->module_id;
1554         mconfig->id.instance_id = dfw_config->instance_id;
1555         mconfig->mcps = dfw_config->max_mcps;
1556         mconfig->ibs = dfw_config->ibs;
1557         mconfig->obs = dfw_config->obs;
1558         mconfig->core_id = dfw_config->core_id;
1559         mconfig->max_in_queue = dfw_config->max_in_queue;
1560         mconfig->max_out_queue = dfw_config->max_out_queue;
1561         mconfig->is_loadable = dfw_config->is_loadable;
1562         skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
1563                                                 MODULE_MAX_IN_PINS);
1564         skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
1565                                                 MODULE_MAX_OUT_PINS);
1566
1567         mconfig->params_fixup = dfw_config->params_fixup;
1568         mconfig->converter = dfw_config->converter;
1569         mconfig->m_type = dfw_config->module_type;
1570         mconfig->vbus_id = dfw_config->vbus_id;
1571         mconfig->mem_pages = dfw_config->mem_pages;
1572
1573         pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1574         if (pipe)
1575                 mconfig->pipe = pipe;
1576
1577         mconfig->dev_type = dfw_config->dev_type;
1578         mconfig->hw_conn_type = dfw_config->hw_conn_type;
1579         mconfig->time_slot = dfw_config->time_slot;
1580         mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1581
1582         if (dfw_config->is_loadable)
1583                 memcpy(mconfig->guid, dfw_config->uuid,
1584                                         ARRAY_SIZE(dfw_config->uuid));
1585
1586         mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
1587                                                 sizeof(*mconfig->m_in_pin),
1588                                                 GFP_KERNEL);
1589         if (!mconfig->m_in_pin)
1590                 return -ENOMEM;
1591
1592         mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1593                                                 sizeof(*mconfig->m_out_pin),
1594                                                 GFP_KERNEL);
1595         if (!mconfig->m_out_pin)
1596                 return -ENOMEM;
1597
1598         skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1599                                                 dfw_config->is_dynamic_in_pin,
1600                                                 mconfig->max_in_queue);
1601
1602         skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1603                                                  dfw_config->is_dynamic_out_pin,
1604                                                         mconfig->max_out_queue);
1605
1606
1607         if (mconfig->formats_config.caps_size == 0)
1608                 goto bind_event;
1609
1610         mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1611                         mconfig->formats_config.caps_size, GFP_KERNEL);
1612
1613         if (mconfig->formats_config.caps == NULL)
1614                 return -ENOMEM;
1615
1616         memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1617                                                  dfw_config->caps.caps_size);
1618         mconfig->formats_config.param_id = dfw_config->caps.param_id;
1619         mconfig->formats_config.set_params = dfw_config->caps.set_params;
1620
1621 bind_event:
1622         if (tplg_w->event_type == 0) {
1623                 dev_dbg(bus->dev, "ASoC: No event handler required\n");
1624                 return 0;
1625         }
1626
1627         ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1628                                         ARRAY_SIZE(skl_tplg_widget_ops),
1629                                         tplg_w->event_type);
1630
1631         if (ret) {
1632                 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1633                                         __func__, tplg_w->event_type);
1634                 return -EINVAL;
1635         }
1636
1637         return 0;
1638 }
1639
1640 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
1641                                         struct snd_soc_tplg_bytes_control *bc)
1642 {
1643         struct skl_algo_data *ac;
1644         struct skl_dfw_algo_data *dfw_ac =
1645                                 (struct skl_dfw_algo_data *)bc->priv.data;
1646
1647         ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
1648         if (!ac)
1649                 return -ENOMEM;
1650
1651         /* Fill private data */
1652         ac->max = dfw_ac->max;
1653         ac->param_id = dfw_ac->param_id;
1654         ac->set_params = dfw_ac->set_params;
1655
1656         if (ac->max) {
1657                 ac->params = (char *) devm_kzalloc(dev, ac->max, GFP_KERNEL);
1658                 if (!ac->params)
1659                         return -ENOMEM;
1660
1661                 memcpy(ac->params, dfw_ac->params, ac->max);
1662         }
1663
1664         be->dobj.private  = ac;
1665         return 0;
1666 }
1667
1668 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
1669                                 struct snd_kcontrol_new *kctl,
1670                                 struct snd_soc_tplg_ctl_hdr *hdr)
1671 {
1672         struct soc_bytes_ext *sb;
1673         struct snd_soc_tplg_bytes_control *tplg_bc;
1674         struct hdac_ext_bus *ebus  = snd_soc_component_get_drvdata(cmpnt);
1675         struct hdac_bus *bus = ebus_to_hbus(ebus);
1676
1677         switch (hdr->ops.info) {
1678         case SND_SOC_TPLG_CTL_BYTES:
1679                 tplg_bc = container_of(hdr,
1680                                 struct snd_soc_tplg_bytes_control, hdr);
1681                 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1682                         sb = (struct soc_bytes_ext *)kctl->private_value;
1683                         if (tplg_bc->priv.size)
1684                                 return skl_init_algo_data(
1685                                                 bus->dev, sb, tplg_bc);
1686                 }
1687                 break;
1688
1689         default:
1690                 dev_warn(bus->dev, "Control load not supported %d:%d:%d\n",
1691                         hdr->ops.get, hdr->ops.put, hdr->ops.info);
1692                 break;
1693         }
1694
1695         return 0;
1696 }
1697
1698 static struct snd_soc_tplg_ops skl_tplg_ops  = {
1699         .widget_load = skl_tplg_widget_load,
1700         .control_load = skl_tplg_control_load,
1701         .bytes_ext_ops = skl_tlv_ops,
1702         .bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
1703 };
1704
1705 /* This will be read from topology manifest, currently defined here */
1706 #define SKL_MAX_MCPS 30000000
1707 #define SKL_FW_MAX_MEM 1000000
1708
1709 /*
1710  * SKL topology init routine
1711  */
1712 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1713 {
1714         int ret;
1715         const struct firmware *fw;
1716         struct hdac_bus *bus = ebus_to_hbus(ebus);
1717         struct skl *skl = ebus_to_skl(ebus);
1718
1719         ret = request_firmware(&fw, skl->tplg_name, bus->dev);
1720         if (ret < 0) {
1721                 dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1722                                 skl->tplg_name, ret);
1723                 ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1724                 if (ret < 0) {
1725                         dev_err(bus->dev, "Fallback tplg fw %s load failed with %d\n",
1726                                         "dfw_sst.bin", ret);
1727                         return ret;
1728                 }
1729         }
1730
1731         /*
1732          * The complete tplg for SKL is loaded as index 0, we don't use
1733          * any other index
1734          */
1735         ret = snd_soc_tplg_component_load(&platform->component,
1736                                         &skl_tplg_ops, fw, 0);
1737         if (ret < 0) {
1738                 dev_err(bus->dev, "tplg component load failed%d\n", ret);
1739                 release_firmware(fw);
1740                 return -EINVAL;
1741         }
1742
1743         skl->resource.max_mcps = SKL_MAX_MCPS;
1744         skl->resource.max_mem = SKL_FW_MAX_MEM;
1745
1746         skl->tplg = fw;
1747
1748         return 0;
1749 }