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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  skl-topology.c - Implements Platform component ALSA controls/widget
   4  *  handlers.
   5  *
   6  *  Copyright (C) 2014-2015 Intel Corp
   7  *  Author: Jeeja KP <jeeja.kp@intel.com>
   8  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  */
  10
  11 #include <linux/slab.h>
  12 #include <linux/types.h>
  13 #include <linux/firmware.h>
  14 #include <linux/uuid.h>
  15 #include <sound/intel-nhlt.h>
  16 #include <sound/soc.h>
  17 #include <sound/soc-acpi.h>
  18 #include <sound/soc-topology.h>
  19 #include <uapi/sound/snd_sst_tokens.h>
  20 #include <uapi/sound/skl-tplg-interface.h>
  21 #include "skl-sst-dsp.h"
  22 #include "skl-sst-ipc.h"
  23 #include "skl-topology.h"
  24 #include "skl.h"
  25 #include "../common/sst-dsp.h"
  26 #include "../common/sst-dsp-priv.h"
  27
  28 #define SKL_CH_FIXUP_MASK               (1 << 0)
  29 #define SKL_RATE_FIXUP_MASK             (1 << 1)
  30 #define SKL_FMT_FIXUP_MASK              (1 << 2)
  31 #define SKL_IN_DIR_BIT_MASK             BIT(0)
  32 #define SKL_PIN_COUNT_MASK              GENMASK(7, 4)
  33
  34 static const int mic_mono_list[] = {
  35 0, 1, 2, 3,
  36 };
  37 static const int mic_stereo_list[][SKL_CH_STEREO] = {
  38 {0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3},
  39 };
  40 static const int mic_trio_list[][SKL_CH_TRIO] = {
  41 {0, 1, 2}, {0, 1, 3}, {0, 2, 3}, {1, 2, 3},
  42 };
  43 static const int mic_quatro_list[][SKL_CH_QUATRO] = {
  44 {0, 1, 2, 3},
  45 };
  46
  47 #define CHECK_HW_PARAMS(ch, freq, bps, prm_ch, prm_freq, prm_bps) \
  48         ((ch == prm_ch) && (bps == prm_bps) && (freq == prm_freq))
  49
  50 void skl_tplg_d0i3_get(struct skl_dev *skl, enum d0i3_capability caps)
  51 {
  52         struct skl_d0i3_data *d0i3 =  &skl->d0i3;
  53
  54         switch (caps) {
  55         case SKL_D0I3_NONE:
  56                 d0i3->non_d0i3++;
  57                 break;
  58
  59         case SKL_D0I3_STREAMING:
  60                 d0i3->streaming++;
  61                 break;
  62
  63         case SKL_D0I3_NON_STREAMING:
  64                 d0i3->non_streaming++;
  65                 break;
  66         }
  67 }
  68
  69 void skl_tplg_d0i3_put(struct skl_dev *skl, enum d0i3_capability caps)
  70 {
  71         struct skl_d0i3_data *d0i3 =  &skl->d0i3;
  72
  73         switch (caps) {
  74         case SKL_D0I3_NONE:
  75                 d0i3->non_d0i3--;
  76                 break;
  77
  78         case SKL_D0I3_STREAMING:
  79                 d0i3->streaming--;
  80                 break;
  81
  82         case SKL_D0I3_NON_STREAMING:
  83                 d0i3->non_streaming--;
  84                 break;
  85         }
  86 }
  87
  88 /*
  89  * SKL DSP driver modelling uses only few DAPM widgets so for rest we will
  90  * ignore. This helpers checks if the SKL driver handles this widget type
  91  */
  92 static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w,
  93                                   struct device *dev)
  94 {
  95         if (w->dapm->dev != dev)
  96                 return false;
  97
  98         switch (w->id) {
  99         case snd_soc_dapm_dai_link:
 100         case snd_soc_dapm_dai_in:
 101         case snd_soc_dapm_aif_in:
 102         case snd_soc_dapm_aif_out:
 103         case snd_soc_dapm_dai_out:
 104         case snd_soc_dapm_switch:
 105         case snd_soc_dapm_output:
 106         case snd_soc_dapm_mux:
 107
 108                 return false;
 109         default:
 110                 return true;
 111         }
 112 }
 113
 114 static void skl_dump_mconfig(struct skl_dev *skl, struct skl_module_cfg *mcfg)
 115 {
 116         struct skl_module_iface *iface = &mcfg->module->formats[mcfg->fmt_idx];
 117
 118         dev_dbg(skl->dev, "Dumping config\n");
 119         dev_dbg(skl->dev, "Input Format:\n");
 120         dev_dbg(skl->dev, "channels = %d\n", iface->inputs[0].fmt.channels);
 121         dev_dbg(skl->dev, "s_freq = %d\n", iface->inputs[0].fmt.s_freq);
 122         dev_dbg(skl->dev, "ch_cfg = %d\n", iface->inputs[0].fmt.ch_cfg);
 123         dev_dbg(skl->dev, "valid bit depth = %d\n",
 124                                 iface->inputs[0].fmt.valid_bit_depth);
 125         dev_dbg(skl->dev, "Output Format:\n");
 126         dev_dbg(skl->dev, "channels = %d\n", iface->outputs[0].fmt.channels);
 127         dev_dbg(skl->dev, "s_freq = %d\n", iface->outputs[0].fmt.s_freq);
 128         dev_dbg(skl->dev, "valid bit depth = %d\n",
 129                                 iface->outputs[0].fmt.valid_bit_depth);
 130         dev_dbg(skl->dev, "ch_cfg = %d\n", iface->outputs[0].fmt.ch_cfg);
 131 }
 132
 133 static void skl_tplg_update_chmap(struct skl_module_fmt *fmt, int chs)
 134 {
 135         int slot_map = 0xFFFFFFFF;
 136         int start_slot = 0;
 137         int i;
 138
 139         for (i = 0; i < chs; i++) {
 140                 /*
 141                  * For 2 channels with starting slot as 0, slot map will
 142                  * look like 0xFFFFFF10.
 143                  */
 144                 slot_map &= (~(0xF << (4 * i)) | (start_slot << (4 * i)));
 145                 start_slot++;
 146         }
 147         fmt->ch_map = slot_map;
 148 }
 149
 150 static void skl_tplg_update_params(struct skl_module_fmt *fmt,
 151                         struct skl_pipe_params *params, int fixup)
 152 {
 153         if (fixup & SKL_RATE_FIXUP_MASK)
 154                 fmt->s_freq = params->s_freq;
 155         if (fixup & SKL_CH_FIXUP_MASK) {
 156                 fmt->channels = params->ch;
 157                 skl_tplg_update_chmap(fmt, fmt->channels);
 158         }
 159         if (fixup & SKL_FMT_FIXUP_MASK) {
 160                 fmt->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
 161
 162                 /*
 163                  * 16 bit is 16 bit container whereas 24 bit is in 32 bit
 164                  * container so update bit depth accordingly
 165                  */
 166                 switch (fmt->valid_bit_depth) {
 167                 case SKL_DEPTH_16BIT:
 168                         fmt->bit_depth = fmt->valid_bit_depth;
 169                         break;
 170
 171                 default:
 172                         fmt->bit_depth = SKL_DEPTH_32BIT;
 173                         break;
 174                 }
 175         }
 176
 177 }
 178
 179 /*
 180  * A pipeline may have modules which impact the pcm parameters, like SRC,
 181  * channel converter, format converter.
 182  * We need to calculate the output params by applying the 'fixup'
 183  * Topology will tell driver which type of fixup is to be applied by
 184  * supplying the fixup mask, so based on that we calculate the output
 185  *
 186  * Now In FE the pcm hw_params is source/target format. Same is applicable
 187  * for BE with its hw_params invoked.
 188  * here based on FE, BE pipeline and direction we calculate the input and
 189  * outfix and then apply that for a module
 190  */
 191 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
 192                 struct skl_pipe_params *params, bool is_fe)
 193 {
 194         int in_fixup, out_fixup;
 195         struct skl_module_fmt *in_fmt, *out_fmt;
 196
 197         /* Fixups will be applied to pin 0 only */
 198         in_fmt = &m_cfg->module->formats[m_cfg->fmt_idx].inputs[0].fmt;
 199         out_fmt = &m_cfg->module->formats[m_cfg->fmt_idx].outputs[0].fmt;
 200
 201         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 202                 if (is_fe) {
 203                         in_fixup = m_cfg->params_fixup;
 204                         out_fixup = (~m_cfg->converter) &
 205                                         m_cfg->params_fixup;
 206                 } else {
 207                         out_fixup = m_cfg->params_fixup;
 208                         in_fixup = (~m_cfg->converter) &
 209                                         m_cfg->params_fixup;
 210                 }
 211         } else {
 212                 if (is_fe) {
 213                         out_fixup = m_cfg->params_fixup;
 214                         in_fixup = (~m_cfg->converter) &
 215                                         m_cfg->params_fixup;
 216                 } else {
 217                         in_fixup = m_cfg->params_fixup;
 218                         out_fixup = (~m_cfg->converter) &
 219                                         m_cfg->params_fixup;
 220                 }
 221         }
 222
 223         skl_tplg_update_params(in_fmt, params, in_fixup);
 224         skl_tplg_update_params(out_fmt, params, out_fixup);
 225 }
 226
 227 /*
 228  * A module needs input and output buffers, which are dependent upon pcm
 229  * params, so once we have calculate params, we need buffer calculation as
 230  * well.
 231  */
 232 static void skl_tplg_update_buffer_size(struct skl_dev *skl,
 233                                 struct skl_module_cfg *mcfg)
 234 {
 235         int multiplier = 1;
 236         struct skl_module_fmt *in_fmt, *out_fmt;
 237         struct skl_module_res *res;
 238
 239         /* Since fixups is applied to pin 0 only, ibs, obs needs
 240          * change for pin 0 only
 241          */
 242         res = &mcfg->module->resources[mcfg->res_idx];
 243         in_fmt = &mcfg->module->formats[mcfg->fmt_idx].inputs[0].fmt;
 244         out_fmt = &mcfg->module->formats[mcfg->fmt_idx].outputs[0].fmt;
 245
 246         if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT)
 247                 multiplier = 5;
 248
 249         res->ibs = DIV_ROUND_UP(in_fmt->s_freq, 1000) *
 250                         in_fmt->channels * (in_fmt->bit_depth >> 3) *
 251                         multiplier;
 252
 253         res->obs = DIV_ROUND_UP(out_fmt->s_freq, 1000) *
 254                         out_fmt->channels * (out_fmt->bit_depth >> 3) *
 255                         multiplier;
 256 }
 257
 258 static u8 skl_tplg_be_dev_type(int dev_type)
 259 {
 260         int ret;
 261
 262         switch (dev_type) {
 263         case SKL_DEVICE_BT:
 264                 ret = NHLT_DEVICE_BT;
 265                 break;
 266
 267         case SKL_DEVICE_DMIC:
 268                 ret = NHLT_DEVICE_DMIC;
 269                 break;
 270
 271         case SKL_DEVICE_I2S:
 272                 ret = NHLT_DEVICE_I2S;
 273                 break;
 274
 275         default:
 276                 ret = NHLT_DEVICE_INVALID;
 277                 break;
 278         }
 279
 280         return ret;
 281 }
 282
 283 static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
 284                                                 struct skl_dev *skl)
 285 {
 286         struct skl_module_cfg *m_cfg = w->priv;
 287         int link_type, dir;
 288         u32 ch, s_freq, s_fmt;
 289         struct nhlt_specific_cfg *cfg;
 290         u8 dev_type = skl_tplg_be_dev_type(m_cfg->dev_type);
 291         int fmt_idx = m_cfg->fmt_idx;
 292         struct skl_module_iface *m_iface = &m_cfg->module->formats[fmt_idx];
 293
 294         /* check if we already have blob */
 295         if (m_cfg->formats_config.caps_size > 0)
 296                 return 0;
 297
 298         dev_dbg(skl->dev, "Applying default cfg blob\n");
 299         switch (m_cfg->dev_type) {
 300         case SKL_DEVICE_DMIC:
 301                 link_type = NHLT_LINK_DMIC;
 302                 dir = SNDRV_PCM_STREAM_CAPTURE;
 303                 s_freq = m_iface->inputs[0].fmt.s_freq;
 304                 s_fmt = m_iface->inputs[0].fmt.bit_depth;
 305                 ch = m_iface->inputs[0].fmt.channels;
 306                 break;
 307
 308         case SKL_DEVICE_I2S:
 309                 link_type = NHLT_LINK_SSP;
 310                 if (m_cfg->hw_conn_type == SKL_CONN_SOURCE) {
 311                         dir = SNDRV_PCM_STREAM_PLAYBACK;
 312                         s_freq = m_iface->outputs[0].fmt.s_freq;
 313                         s_fmt = m_iface->outputs[0].fmt.bit_depth;
 314                         ch = m_iface->outputs[0].fmt.channels;
 315                 } else {
 316                         dir = SNDRV_PCM_STREAM_CAPTURE;
 317                         s_freq = m_iface->inputs[0].fmt.s_freq;
 318                         s_fmt = m_iface->inputs[0].fmt.bit_depth;
 319                         ch = m_iface->inputs[0].fmt.channels;
 320                 }
 321                 break;
 322
 323         default:
 324                 return -EINVAL;
 325         }
 326
 327         /* update the blob based on virtual bus_id and default params */
 328         cfg = skl_get_ep_blob(skl, m_cfg->vbus_id, link_type,
 329                                         s_fmt, ch, s_freq, dir, dev_type);
 330         if (cfg) {
 331                 m_cfg->formats_config.caps_size = cfg->size;
 332                 m_cfg->formats_config.caps = (u32 *) &cfg->caps;
 333         } else {
 334                 dev_err(skl->dev, "Blob NULL for id %x type %d dirn %d\n",
 335                                         m_cfg->vbus_id, link_type, dir);
 336                 dev_err(skl->dev, "PCM: ch %d, freq %d, fmt %d\n",
 337                                         ch, s_freq, s_fmt);
 338                 return -EIO;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
 345                                                         struct skl_dev *skl)
 346 {
 347         struct skl_module_cfg *m_cfg = w->priv;
 348         struct skl_pipe_params *params = m_cfg->pipe->p_params;
 349         int p_conn_type = m_cfg->pipe->conn_type;
 350         bool is_fe;
 351
 352         if (!m_cfg->params_fixup)
 353                 return;
 354
 355         dev_dbg(skl->dev, "Mconfig for widget=%s BEFORE updation\n",
 356                                 w->name);
 357
 358         skl_dump_mconfig(skl, m_cfg);
 359
 360         if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
 361                 is_fe = true;
 362         else
 363                 is_fe = false;
 364
 365         skl_tplg_update_params_fixup(m_cfg, params, is_fe);
 366         skl_tplg_update_buffer_size(skl, m_cfg);
 367
 368         dev_dbg(skl->dev, "Mconfig for widget=%s AFTER updation\n",
 369                                 w->name);
 370
 371         skl_dump_mconfig(skl, m_cfg);
 372 }
 373
 374 /*
 375  * some modules can have multiple params set from user control and
 376  * need to be set after module is initialized. If set_param flag is
 377  * set module params will be done after module is initialised.
 378  */
 379 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
 380                                                 struct skl_dev *skl)
 381 {
 382         int i, ret;
 383         struct skl_module_cfg *mconfig = w->priv;
 384         const struct snd_kcontrol_new *k;
 385         struct soc_bytes_ext *sb;
 386         struct skl_algo_data *bc;
 387         struct skl_specific_cfg *sp_cfg;
 388
 389         if (mconfig->formats_config.caps_size > 0 &&
 390                 mconfig->formats_config.set_params == SKL_PARAM_SET) {
 391                 sp_cfg = &mconfig->formats_config;
 392                 ret = skl_set_module_params(skl, sp_cfg->caps,
 393                                         sp_cfg->caps_size,
 394                                         sp_cfg->param_id, mconfig);
 395                 if (ret < 0)
 396                         return ret;
 397         }
 398
 399         for (i = 0; i < w->num_kcontrols; i++) {
 400                 k = &w->kcontrol_news[i];
 401                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 402                         sb = (void *) k->private_value;
 403                         bc = (struct skl_algo_data *)sb->dobj.private;
 404
 405                         if (bc->set_params == SKL_PARAM_SET) {
 406                                 ret = skl_set_module_params(skl,
 407                                                 (u32 *)bc->params, bc->size,
 408                                                 bc->param_id, mconfig);
 409                                 if (ret < 0)
 410                                         return ret;
 411                         }
 412                 }
 413         }
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * some module param can set from user control and this is required as
 420  * when module is initailzed. if module param is required in init it is
 421  * identifed by set_param flag. if set_param flag is not set, then this
 422  * parameter needs to set as part of module init.
 423  */
 424 static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
 425 {
 426         const struct snd_kcontrol_new *k;
 427         struct soc_bytes_ext *sb;
 428         struct skl_algo_data *bc;
 429         struct skl_module_cfg *mconfig = w->priv;
 430         int i;
 431
 432         for (i = 0; i < w->num_kcontrols; i++) {
 433                 k = &w->kcontrol_news[i];
 434                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 435                         sb = (struct soc_bytes_ext *)k->private_value;
 436                         bc = (struct skl_algo_data *)sb->dobj.private;
 437
 438                         if (bc->set_params != SKL_PARAM_INIT)
 439                                 continue;
 440
 441                         mconfig->formats_config.caps = (u32 *)bc->params;
 442                         mconfig->formats_config.caps_size = bc->size;
 443
 444                         break;
 445                 }
 446         }
 447
 448         return 0;
 449 }
 450
 451 static int skl_tplg_module_prepare(struct skl_dev *skl, struct skl_pipe *pipe,
 452                 struct snd_soc_dapm_widget *w, struct skl_module_cfg *mcfg)
 453 {
 454         switch (mcfg->dev_type) {
 455         case SKL_DEVICE_HDAHOST:
 456                 return skl_pcm_host_dma_prepare(skl->dev, pipe->p_params);
 457
 458         case SKL_DEVICE_HDALINK:
 459                 return skl_pcm_link_dma_prepare(skl->dev, pipe->p_params);
 460         }
 461
 462         return 0;
 463 }
 464
 465 /*
 466  * Inside a pipe instance, we can have various modules. These modules need
 467  * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
 468  * skl_init_module() routine, so invoke that for all modules in a pipeline
 469  */
 470 static int
 471 skl_tplg_init_pipe_modules(struct skl_dev *skl, struct skl_pipe *pipe)
 472 {
 473         struct skl_pipe_module *w_module;
 474         struct snd_soc_dapm_widget *w;
 475         struct skl_module_cfg *mconfig;
 476         u8 cfg_idx;
 477         int ret = 0;
 478
 479         list_for_each_entry(w_module, &pipe->w_list, node) {
 480                 guid_t *uuid_mod;
 481                 w = w_module->w;
 482                 mconfig = w->priv;
 483
 484                 /* check if module ids are populated */
 485                 if (mconfig->id.module_id < 0) {
 486                         dev_err(skl->dev,
 487                                         "module %pUL id not populated\n",
 488                                         (guid_t *)mconfig->guid);
 489                         return -EIO;
 490                 }
 491
 492                 cfg_idx = mconfig->pipe->cur_config_idx;
 493                 mconfig->fmt_idx = mconfig->mod_cfg[cfg_idx].fmt_idx;
 494                 mconfig->res_idx = mconfig->mod_cfg[cfg_idx].res_idx;
 495
 496                 if (mconfig->module->loadable && skl->dsp->fw_ops.load_mod) {
 497                         ret = skl->dsp->fw_ops.load_mod(skl->dsp,
 498                                 mconfig->id.module_id, mconfig->guid);
 499                         if (ret < 0)
 500                                 return ret;
 501
 502                         mconfig->m_state = SKL_MODULE_LOADED;
 503                 }
 504
 505                 /* prepare the DMA if the module is gateway cpr */
 506                 ret = skl_tplg_module_prepare(skl, pipe, w, mconfig);
 507                 if (ret < 0)
 508                         return ret;
 509
 510                 /* update blob if blob is null for be with default value */
 511                 skl_tplg_update_be_blob(w, skl);
 512
 513                 /*
 514                  * apply fix/conversion to module params based on
 515                  * FE/BE params
 516                  */
 517                 skl_tplg_update_module_params(w, skl);
 518                 uuid_mod = (guid_t *)mconfig->guid;
 519                 mconfig->id.pvt_id = skl_get_pvt_id(skl, uuid_mod,
 520                                                 mconfig->id.instance_id);
 521                 if (mconfig->id.pvt_id < 0)
 522                         return ret;
 523                 skl_tplg_set_module_init_data(w);
 524
 525                 ret = skl_dsp_get_core(skl->dsp, mconfig->core_id);
 526                 if (ret < 0) {
 527                         dev_err(skl->dev, "Failed to wake up core %d ret=%d\n",
 528                                                 mconfig->core_id, ret);
 529                         return ret;
 530                 }
 531
 532                 ret = skl_init_module(skl, mconfig);
 533                 if (ret < 0) {
 534                         skl_put_pvt_id(skl, uuid_mod, &mconfig->id.pvt_id);
 535                         goto err;
 536                 }
 537
 538                 ret = skl_tplg_set_module_params(w, skl);
 539                 if (ret < 0)
 540                         goto err;
 541         }
 542
 543         return 0;
 544 err:
 545         skl_dsp_put_core(skl->dsp, mconfig->core_id);
 546         return ret;
 547 }
 548
 549 static int skl_tplg_unload_pipe_modules(struct skl_dev *skl,
 550          struct skl_pipe *pipe)
 551 {
 552         int ret = 0;
 553         struct skl_pipe_module *w_module;
 554         struct skl_module_cfg *mconfig;
 555
 556         list_for_each_entry(w_module, &pipe->w_list, node) {
 557                 guid_t *uuid_mod;
 558                 mconfig  = w_module->w->priv;
 559                 uuid_mod = (guid_t *)mconfig->guid;
 560
 561                 if (mconfig->module->loadable && skl->dsp->fw_ops.unload_mod &&
 562                         mconfig->m_state > SKL_MODULE_UNINIT) {
 563                         ret = skl->dsp->fw_ops.unload_mod(skl->dsp,
 564                                                 mconfig->id.module_id);
 565                         if (ret < 0)
 566                                 return -EIO;
 567                 }
 568                 skl_put_pvt_id(skl, uuid_mod, &mconfig->id.pvt_id);
 569
 570                 ret = skl_dsp_put_core(skl->dsp, mconfig->core_id);
 571                 if (ret < 0) {
 572                         /* don't return; continue with other modules */
 573                         dev_err(skl->dev, "Failed to sleep core %d ret=%d\n",
 574                                 mconfig->core_id, ret);
 575                 }
 576         }
 577
 578         /* no modules to unload in this path, so return */
 579         return ret;
 580 }
 581
 582 static bool skl_tplg_is_multi_fmt(struct skl_dev *skl, struct skl_pipe *pipe)
 583 {
 584         struct skl_pipe_fmt *cur_fmt;
 585         struct skl_pipe_fmt *next_fmt;
 586         int i;
 587
 588         if (pipe->nr_cfgs <= 1)
 589                 return false;
 590
 591         if (pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
 592                 return true;
 593
 594         for (i = 0; i < pipe->nr_cfgs - 1; i++) {
 595                 if (pipe->direction == SNDRV_PCM_STREAM_PLAYBACK) {
 596                         cur_fmt = &pipe->configs[i].out_fmt;
 597                         next_fmt = &pipe->configs[i + 1].out_fmt;
 598                 } else {
 599                         cur_fmt = &pipe->configs[i].in_fmt;
 600                         next_fmt = &pipe->configs[i + 1].in_fmt;
 601                 }
 602
 603                 if (!CHECK_HW_PARAMS(cur_fmt->channels, cur_fmt->freq,
 604                                      cur_fmt->bps,
 605                                      next_fmt->channels,
 606                                      next_fmt->freq,
 607                                      next_fmt->bps))
 608                         return true;
 609         }
 610
 611         return false;
 612 }
 613
 614 /*
 615  * Here, we select pipe format based on the pipe type and pipe
 616  * direction to determine the current config index for the pipeline.
 617  * The config index is then used to select proper module resources.
 618  * Intermediate pipes currently have a fixed format hence we select the
 619  * 0th configuratation by default for such pipes.
 620  */
 621 static int
 622 skl_tplg_get_pipe_config(struct skl_dev *skl, struct skl_module_cfg *mconfig)
 623 {
 624         struct skl_pipe *pipe = mconfig->pipe;
 625         struct skl_pipe_params *params = pipe->p_params;
 626         struct skl_path_config *pconfig = &pipe->configs[0];
 627         struct skl_pipe_fmt *fmt = NULL;
 628         bool in_fmt = false;
 629         int i;
 630
 631         if (pipe->nr_cfgs == 0) {
 632                 pipe->cur_config_idx = 0;
 633                 return 0;
 634         }
 635
 636         if (skl_tplg_is_multi_fmt(skl, pipe)) {
 637                 pipe->cur_config_idx = pipe->pipe_config_idx;
 638                 pipe->memory_pages = pconfig->mem_pages;
 639                 dev_dbg(skl->dev, "found pipe config idx:%d\n",
 640                         pipe->cur_config_idx);
 641                 return 0;
 642         }
 643
 644         if (pipe->conn_type == SKL_PIPE_CONN_TYPE_NONE) {
 645                 dev_dbg(skl->dev, "No conn_type detected, take 0th config\n");
 646                 pipe->cur_config_idx = 0;
 647                 pipe->memory_pages = pconfig->mem_pages;
 648
 649                 return 0;
 650         }
 651
 652         if ((pipe->conn_type == SKL_PIPE_CONN_TYPE_FE &&
 653              pipe->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
 654              (pipe->conn_type == SKL_PIPE_CONN_TYPE_BE &&
 655              pipe->direction == SNDRV_PCM_STREAM_CAPTURE))
 656                 in_fmt = true;
 657
 658         for (i = 0; i < pipe->nr_cfgs; i++) {
 659                 pconfig = &pipe->configs[i];
 660                 if (in_fmt)
 661                         fmt = &pconfig->in_fmt;
 662                 else
 663                         fmt = &pconfig->out_fmt;
 664
 665                 if (CHECK_HW_PARAMS(params->ch, params->s_freq, params->s_fmt,
 666                                     fmt->channels, fmt->freq, fmt->bps)) {
 667                         pipe->cur_config_idx = i;
 668                         pipe->memory_pages = pconfig->mem_pages;
 669                         dev_dbg(skl->dev, "Using pipe config: %d\n", i);
 670
 671                         return 0;
 672                 }
 673         }
 674
 675         dev_err(skl->dev, "Invalid pipe config: %d %d %d for pipe: %d\n",
 676                 params->ch, params->s_freq, params->s_fmt, pipe->ppl_id);
 677         return -EINVAL;
 678 }
 679
 680 /*
 681  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
 682  * need create the pipeline. So we do following:
 683  *   - Create the pipeline
 684  *   - Initialize the modules in pipeline
 685  *   - finally bind all modules together
 686  */
 687 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 688                                                         struct skl_dev *skl)
 689 {
 690         int ret;
 691         struct skl_module_cfg *mconfig = w->priv;
 692         struct skl_pipe_module *w_module;
 693         struct skl_pipe *s_pipe = mconfig->pipe;
 694         struct skl_module_cfg *src_module = NULL, *dst_module, *module;
 695         struct skl_module_deferred_bind *modules;
 696
 697         ret = skl_tplg_get_pipe_config(skl, mconfig);
 698         if (ret < 0)
 699                 return ret;
 700
 701         /*
 702          * Create a list of modules for pipe.
 703          * This list contains modules from source to sink
 704          */
 705         ret = skl_create_pipeline(skl, mconfig->pipe);
 706         if (ret < 0)
 707                 return ret;
 708
 709         /* Init all pipe modules from source to sink */
 710         ret = skl_tplg_init_pipe_modules(skl, s_pipe);
 711         if (ret < 0)
 712                 return ret;
 713
 714         /* Bind modules from source to sink */
 715         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 716                 dst_module = w_module->w->priv;
 717
 718                 if (src_module == NULL) {
 719                         src_module = dst_module;
 720                         continue;
 721                 }
 722
 723                 ret = skl_bind_modules(skl, src_module, dst_module);
 724                 if (ret < 0)
 725                         return ret;
 726
 727                 src_module = dst_module;
 728         }
 729
 730         /*
 731          * When the destination module is initialized, check for these modules
 732          * in deferred bind list. If found, bind them.
 733          */
 734         list_for_each_entry(w_module, &s_pipe->w_list, node) {
 735                 if (list_empty(&skl->bind_list))
 736                         break;
 737
 738                 list_for_each_entry(modules, &skl->bind_list, node) {
 739                         module = w_module->w->priv;
 740                         if (modules->dst == module)
 741                                 skl_bind_modules(skl, modules->src,
 742                                                         modules->dst);
 743                 }
 744         }
 745
 746         return 0;
 747 }
 748
 749 static int skl_fill_sink_instance_id(struct skl_dev *skl, u32 *params,
 750                                 int size, struct skl_module_cfg *mcfg)
 751 {
 752         int i, pvt_id;
 753
 754         if (mcfg->m_type == SKL_MODULE_TYPE_KPB) {
 755                 struct skl_kpb_params *kpb_params =
 756                                 (struct skl_kpb_params *)params;
 757                 struct skl_mod_inst_map *inst = kpb_params->u.map;
 758
 759                 for (i = 0; i < kpb_params->num_modules; i++) {
 760                         pvt_id = skl_get_pvt_instance_id_map(skl, inst->mod_id,
 761                                                                 inst->inst_id);
 762                         if (pvt_id < 0)
 763                                 return -EINVAL;
 764
 765                         inst->inst_id = pvt_id;
 766                         inst++;
 767                 }
 768         }
 769
 770         return 0;
 771 }
 772 /*
 773  * Some modules require params to be set after the module is bound to
 774  * all pins connected.
 775  *
 776  * The module provider initializes set_param flag for such modules and we
 777  * send params after binding
 778  */
 779 static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
 780                         struct skl_module_cfg *mcfg, struct skl_dev *skl)
 781 {
 782         int i, ret;
 783         struct skl_module_cfg *mconfig = w->priv;
 784         const struct snd_kcontrol_new *k;
 785         struct soc_bytes_ext *sb;
 786         struct skl_algo_data *bc;
 787         struct skl_specific_cfg *sp_cfg;
 788         u32 *params;
 789
 790         /*
 791          * check all out/in pins are in bind state.
 792          * if so set the module param
 793          */
 794         for (i = 0; i < mcfg->module->max_output_pins; i++) {
 795                 if (mcfg->m_out_pin[i].pin_state != SKL_PIN_BIND_DONE)
 796                         return 0;
 797         }
 798
 799         for (i = 0; i < mcfg->module->max_input_pins; i++) {
 800                 if (mcfg->m_in_pin[i].pin_state != SKL_PIN_BIND_DONE)
 801                         return 0;
 802         }
 803
 804         if (mconfig->formats_config.caps_size > 0 &&
 805                 mconfig->formats_config.set_params == SKL_PARAM_BIND) {
 806                 sp_cfg = &mconfig->formats_config;
 807                 ret = skl_set_module_params(skl, sp_cfg->caps,
 808                                         sp_cfg->caps_size,
 809                                         sp_cfg->param_id, mconfig);
 810                 if (ret < 0)
 811                         return ret;
 812         }
 813
 814         for (i = 0; i < w->num_kcontrols; i++) {
 815                 k = &w->kcontrol_news[i];
 816                 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 817                         sb = (void *) k->private_value;
 818                         bc = (struct skl_algo_data *)sb->dobj.private;
 819
 820                         if (bc->set_params == SKL_PARAM_BIND) {
 821                                 params = kmemdup(bc->params, bc->max, GFP_KERNEL);
 822                                 if (!params)
 823                                         return -ENOMEM;
 824
 825                                 skl_fill_sink_instance_id(skl, params, bc->max,
 826                                                                 mconfig);
 827
 828                                 ret = skl_set_module_params(skl, params,
 829                                                 bc->max, bc->param_id, mconfig);
 830                                 kfree(params);
 831
 832                                 if (ret < 0)
 833                                         return ret;
 834                         }
 835                 }
 836         }
 837
 838         return 0;
 839 }
 840
 841 static int skl_get_module_id(struct skl_dev *skl, guid_t *uuid)
 842 {
 843         struct uuid_module *module;
 844
 845         list_for_each_entry(module, &skl->uuid_list, list) {
 846                 if (guid_equal(uuid, &module->uuid))
 847                         return module->id;
 848         }
 849
 850         return -EINVAL;
 851 }
 852
 853 static int skl_tplg_find_moduleid_from_uuid(struct skl_dev *skl,
 854                                         const struct snd_kcontrol_new *k)
 855 {
 856         struct soc_bytes_ext *sb = (void *) k->private_value;
 857         struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
 858         struct skl_kpb_params *uuid_params, *params;
 859         struct hdac_bus *bus = skl_to_bus(skl);
 860         int i, size, module_id;
 861
 862         if (bc->set_params == SKL_PARAM_BIND && bc->max) {
 863                 uuid_params = (struct skl_kpb_params *)bc->params;
 864                 size = struct_size(params, u.map, uuid_params->num_modules);
 865
 866                 params = devm_kzalloc(bus->dev, size, GFP_KERNEL);
 867                 if (!params)
 868                         return -ENOMEM;
 869
 870                 params->num_modules = uuid_params->num_modules;
 871
 872                 for (i = 0; i < uuid_params->num_modules; i++) {
 873                         module_id = skl_get_module_id(skl,
 874                                 &uuid_params->u.map_uuid[i].mod_uuid);
 875                         if (module_id < 0) {
 876                                 devm_kfree(bus->dev, params);
 877                                 return -EINVAL;
 878                         }
 879
 880                         params->u.map[i].mod_id = module_id;
 881                         params->u.map[i].inst_id =
 882                                 uuid_params->u.map_uuid[i].inst_id;
 883                 }
 884
 885                 devm_kfree(bus->dev, bc->params);
 886                 bc->params = (char *)params;
 887                 bc->max = size;
 888         }
 889
 890         return 0;
 891 }
 892
 893 /*
 894  * Retrieve the module id from UUID mentioned in the
 895  * post bind params
 896  */
 897 void skl_tplg_add_moduleid_in_bind_params(struct skl_dev *skl,
 898                                 struct snd_soc_dapm_widget *w)
 899 {
 900         struct skl_module_cfg *mconfig = w->priv;
 901         int i;
 902
 903         /*
 904          * Post bind params are used for only for KPB
 905          * to set copier instances to drain the data
 906          * in fast mode
 907          */
 908         if (mconfig->m_type != SKL_MODULE_TYPE_KPB)
 909                 return;
 910
 911         for (i = 0; i < w->num_kcontrols; i++)
 912                 if ((w->kcontrol_news[i].access &
 913                         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) &&
 914                         (skl_tplg_find_moduleid_from_uuid(skl,
 915                         &w->kcontrol_news[i]) < 0))
 916                         dev_err(skl->dev,
 917                                 "%s: invalid kpb post bind params\n",
 918                                 __func__);
 919 }
 920
 921 static int skl_tplg_module_add_deferred_bind(struct skl_dev *skl,
 922         struct skl_module_cfg *src, struct skl_module_cfg *dst)
 923 {
 924         struct skl_module_deferred_bind *m_list, *modules;
 925         int i;
 926
 927         /* only supported for module with static pin connection */
 928         for (i = 0; i < dst->module->max_input_pins; i++) {
 929                 struct skl_module_pin *pin = &dst->m_in_pin[i];
 930
 931                 if (pin->is_dynamic)
 932                         continue;
 933
 934                 if ((pin->id.module_id  == src->id.module_id) &&
 935                         (pin->id.instance_id  == src->id.instance_id)) {
 936
 937                         if (!list_empty(&skl->bind_list)) {
 938                                 list_for_each_entry(modules, &skl->bind_list, node) {
 939                                         if (modules->src == src && modules->dst == dst)
 940                                                 return 0;
 941                                 }
 942                         }
 943
 944                         m_list = kzalloc(sizeof(*m_list), GFP_KERNEL);
 945                         if (!m_list)
 946                                 return -ENOMEM;
 947
 948                         m_list->src = src;
 949                         m_list->dst = dst;
 950
 951                         list_add(&m_list->node, &skl->bind_list);
 952                 }
 953         }
 954
 955         return 0;
 956 }
 957
 958 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
 959                                 struct skl_dev *skl,
 960                                 struct snd_soc_dapm_widget *src_w,
 961                                 struct skl_module_cfg *src_mconfig)
 962 {
 963         struct snd_soc_dapm_path *p;
 964         struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
 965         struct skl_module_cfg *sink_mconfig;
 966         int ret;
 967
 968         snd_soc_dapm_widget_for_each_sink_path(w, p) {
 969                 if (!p->connect)
 970                         continue;
 971
 972                 dev_dbg(skl->dev,
 973                         "%s: src widget=%s\n", __func__, w->name);
 974                 dev_dbg(skl->dev,
 975                         "%s: sink widget=%s\n", __func__, p->sink->name);
 976
 977                 next_sink = p->sink;
 978
 979                 if (!is_skl_dsp_widget_type(p->sink, skl->dev))
 980                         return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
 981
 982                 /*
 983                  * here we will check widgets in sink pipelines, so that
 984                  * can be any widgets type and we are only interested if
 985                  * they are ones used for SKL so check that first
 986                  */
 987                 if ((p->sink->priv != NULL) &&
 988                                 is_skl_dsp_widget_type(p->sink, skl->dev)) {
 989
 990                         sink = p->sink;
 991                         sink_mconfig = sink->priv;
 992
 993                         /*
 994                          * Modules other than PGA leaf can be connected
 995                          * directly or via switch to a module in another
 996                          * pipeline. EX: reference path
 997                          * when the path is enabled, the dst module that needs
 998                          * to be bound may not be initialized. if the module is
 999                          * not initialized, add these modules in the deferred
1000                          * bind list and when the dst module is initialised,
1001                          * bind this module to the dst_module in deferred list.
1002                          */
1003                         if (((src_mconfig->m_state == SKL_MODULE_INIT_DONE)
1004                                 && (sink_mconfig->m_state == SKL_MODULE_UNINIT))) {
1005
1006                                 ret = skl_tplg_module_add_deferred_bind(skl,
1007                                                 src_mconfig, sink_mconfig);
1008
1009                                 if (ret < 0)
1010                                         return ret;
1011
1012                         }
1013
1014
1015                         if (src_mconfig->m_state == SKL_MODULE_UNINIT ||
1016                                 sink_mconfig->m_state == SKL_MODULE_UNINIT)
1017                                 continue;
1018
1019                         /* Bind source to sink, mixin is always source */
1020                         ret = skl_bind_modules(skl, src_mconfig, sink_mconfig);
1021                         if (ret)
1022                                 return ret;
1023
1024                         /* set module params after bind */
1025                         skl_tplg_set_module_bind_params(src_w,
1026                                         src_mconfig, skl);
1027                         skl_tplg_set_module_bind_params(sink,
1028                                         sink_mconfig, skl);
1029
1030                         /* Start sinks pipe first */
1031                         if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
1032                                 if (sink_mconfig->pipe->conn_type !=
1033                                                         SKL_PIPE_CONN_TYPE_FE)
1034                                         ret = skl_run_pipe(skl,
1035                                                         sink_mconfig->pipe);
1036                                 if (ret)
1037                                         return ret;
1038                         }
1039                 }
1040         }
1041
1042         if (!sink && next_sink)
1043                 return skl_tplg_bind_sinks(next_sink, skl, src_w, src_mconfig);
1044
1045         return 0;
1046 }
1047
1048 /*
1049  * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
1050  * we need to do following:
1051  *   - Bind to sink pipeline
1052  *      Since the sink pipes can be running and we don't get mixer event on
1053  *      connect for already running mixer, we need to find the sink pipes
1054  *      here and bind to them. This way dynamic connect works.
1055  *   - Start sink pipeline, if not running
1056  *   - Then run current pipe
1057  */
1058 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
1059                                                         struct skl_dev *skl)
1060 {
1061         struct skl_module_cfg *src_mconfig;
1062         int ret = 0;
1063
1064         src_mconfig = w->priv;
1065
1066         /*
1067          * find which sink it is connected to, bind with the sink,
1068          * if sink is not started, start sink pipe first, then start
1069          * this pipe
1070          */
1071         ret = skl_tplg_bind_sinks(w, skl, w, src_mconfig);
1072         if (ret)
1073                 return ret;
1074
1075         /* Start source pipe last after starting all sinks */
1076         if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
1077                 return skl_run_pipe(skl, src_mconfig->pipe);
1078
1079         return 0;
1080 }
1081
1082 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
1083                 struct snd_soc_dapm_widget *w, struct skl_dev *skl)
1084 {
1085         struct snd_soc_dapm_path *p;
1086         struct snd_soc_dapm_widget *src_w = NULL;
1087
1088         snd_soc_dapm_widget_for_each_source_path(w, p) {
1089                 src_w = p->source;
1090                 if (!p->connect)
1091                         continue;
1092
1093                 dev_dbg(skl->dev, "sink widget=%s\n", w->name);
1094                 dev_dbg(skl->dev, "src widget=%s\n", p->source->name);
1095
1096                 /*
1097                  * here we will check widgets in sink pipelines, so that can
1098                  * be any widgets type and we are only interested if they are
1099                  * ones used for SKL so check that first
1100                  */
1101                 if ((p->source->priv != NULL) &&
1102                                 is_skl_dsp_widget_type(p->source, skl->dev)) {
1103                         return p->source;
1104                 }
1105         }
1106
1107         if (src_w != NULL)
1108                 return skl_get_src_dsp_widget(src_w, skl);
1109
1110         return NULL;
1111 }
1112
1113 /*
1114  * in the Post-PMU event of mixer we need to do following:
1115  *   - Check if this pipe is running
1116  *   - if not, then
1117  *      - bind this pipeline to its source pipeline
1118  *        if source pipe is already running, this means it is a dynamic
1119  *        connection and we need to bind only to that pipe
1120  *      - start this pipeline
1121  */
1122 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
1123                                                         struct skl_dev *skl)
1124 {
1125         int ret = 0;
1126         struct snd_soc_dapm_widget *source, *sink;
1127         struct skl_module_cfg *src_mconfig, *sink_mconfig;
1128         int src_pipe_started = 0;
1129
1130         sink = w;
1131         sink_mconfig = sink->priv;
1132
1133         /*
1134          * If source pipe is already started, that means source is driving
1135          * one more sink before this sink got connected, Since source is
1136          * started, bind this sink to source and start this pipe.
1137          */
1138         source = skl_get_src_dsp_widget(w, skl);
1139         if (source != NULL) {
1140                 src_mconfig = source->priv;
1141                 sink_mconfig = sink->priv;
1142                 src_pipe_started = 1;
1143
1144                 /*
1145                  * check pipe state, then no need to bind or start the
1146                  * pipe
1147                  */
1148                 if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
1149                         src_pipe_started = 0;
1150         }
1151
1152         if (src_pipe_started) {
1153                 ret = skl_bind_modules(skl, src_mconfig, sink_mconfig);
1154                 if (ret)
1155                         return ret;
1156
1157                 /* set module params after bind */
1158                 skl_tplg_set_module_bind_params(source, src_mconfig, skl);
1159                 skl_tplg_set_module_bind_params(sink, sink_mconfig, skl);
1160
1161                 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
1162                         ret = skl_run_pipe(skl, sink_mconfig->pipe);
1163         }
1164
1165         return ret;
1166 }
1167
1168 /*
1169  * in the Pre-PMD event of mixer we need to do following:
1170  *   - Stop the pipe
1171  *   - find the source connections and remove that from dapm_path_list
1172  *   - unbind with source pipelines if still connected
1173  */
1174 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
1175                                                         struct skl_dev *skl)
1176 {
1177         struct skl_module_cfg *src_mconfig, *sink_mconfig;
1178         int ret = 0, i;
1179
1180         sink_mconfig = w->priv;
1181
1182         /* Stop the pipe */
1183         ret = skl_stop_pipe(skl, sink_mconfig->pipe);
1184         if (ret)
1185                 return ret;
1186
1187         for (i = 0; i < sink_mconfig->module->max_input_pins; i++) {
1188                 if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
1189                         src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
1190                         if (!src_mconfig)
1191                                 continue;
1192
1193                         ret = skl_unbind_modules(skl,
1194                                                 src_mconfig, sink_mconfig);
1195                 }
1196         }
1197
1198         return ret;
1199 }
1200
1201 /*
1202  * in the Post-PMD event of mixer we need to do following:
1203  *   - Unbind the modules within the pipeline
1204  *   - Delete the pipeline (modules are not required to be explicitly
1205  *     deleted, pipeline delete is enough here
1206  */
1207 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
1208                                                         struct skl_dev *skl)
1209 {
1210         struct skl_module_cfg *mconfig = w->priv;
1211         struct skl_pipe_module *w_module;
1212         struct skl_module_cfg *src_module = NULL, *dst_module;
1213         struct skl_pipe *s_pipe = mconfig->pipe;
1214         struct skl_module_deferred_bind *modules, *tmp;
1215
1216         if (s_pipe->state == SKL_PIPE_INVALID)
1217                 return -EINVAL;
1218
1219         list_for_each_entry(w_module, &s_pipe->w_list, node) {
1220                 if (list_empty(&skl->bind_list))
1221                         break;
1222
1223                 src_module = w_module->w->priv;
1224
1225                 list_for_each_entry_safe(modules, tmp, &skl->bind_list, node) {
1226                         /*
1227                          * When the destination module is deleted, Unbind the
1228                          * modules from deferred bind list.
1229                          */
1230                         if (modules->dst == src_module) {
1231                                 skl_unbind_modules(skl, modules->src,
1232                                                 modules->dst);
1233                         }
1234
1235                         /*
1236                          * When the source module is deleted, remove this entry
1237                          * from the deferred bind list.
1238                          */
1239                         if (modules->src == src_module) {
1240                                 list_del(&modules->node);
1241                                 modules->src = NULL;
1242                                 modules->dst = NULL;
1243                                 kfree(modules);
1244                         }
1245                 }
1246         }
1247
1248         list_for_each_entry(w_module, &s_pipe->w_list, node) {
1249                 dst_module = w_module->w->priv;
1250
1251                 if (src_module == NULL) {
1252                         src_module = dst_module;
1253                         continue;
1254                 }
1255
1256                 skl_unbind_modules(skl, src_module, dst_module);
1257                 src_module = dst_module;
1258         }
1259
1260         skl_delete_pipe(skl, mconfig->pipe);
1261
1262         list_for_each_entry(w_module, &s_pipe->w_list, node) {
1263                 src_module = w_module->w->priv;
1264                 src_module->m_state = SKL_MODULE_UNINIT;
1265         }
1266
1267         return skl_tplg_unload_pipe_modules(skl, s_pipe);
1268 }
1269
1270 /*
1271  * in the Post-PMD event of PGA we need to do following:
1272  *   - Stop the pipeline
1273  *   - In source pipe is connected, unbind with source pipelines
1274  */
1275 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
1276                                                         struct skl_dev *skl)
1277 {
1278         struct skl_module_cfg *src_mconfig, *sink_mconfig;
1279         int ret = 0, i;
1280
1281         src_mconfig = w->priv;
1282
1283         /* Stop the pipe since this is a mixin module */
1284         ret = skl_stop_pipe(skl, src_mconfig->pipe);
1285         if (ret)
1286                 return ret;
1287
1288         for (i = 0; i < src_mconfig->module->max_output_pins; i++) {
1289                 if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
1290                         sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
1291                         if (!sink_mconfig)
1292                                 continue;
1293                         /*
1294                          * This is a connecter and if path is found that means
1295                          * unbind between source and sink has not happened yet
1296                          */
1297                         ret = skl_unbind_modules(skl, src_mconfig,
1298                                                         sink_mconfig);
1299                 }
1300         }
1301
1302         return ret;
1303 }
1304
1305 /*
1306  * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
1307  * second one is required that is created as another pipe entity.
1308  * The mixer is responsible for pipe management and represent a pipeline
1309  * instance
1310  */
1311 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
1312                                 struct snd_kcontrol *k, int event)
1313 {
1314         struct snd_soc_dapm_context *dapm = w->dapm;
1315         struct skl_dev *skl = get_skl_ctx(dapm->dev);
1316
1317         switch (event) {
1318         case SND_SOC_DAPM_PRE_PMU:
1319                 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
1320
1321         case SND_SOC_DAPM_POST_PMU:
1322                 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
1323
1324         case SND_SOC_DAPM_PRE_PMD:
1325                 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
1326
1327         case SND_SOC_DAPM_POST_PMD:
1328                 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
1329         }
1330
1331         return 0;
1332 }
1333
1334 /*
1335  * In modelling, we assumed rest of the modules in pipeline are PGA. But we
1336  * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
1337  * the sink when it is running (two FE to one BE or one FE to two BE)
1338  * scenarios
1339  */
1340 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
1341                         struct snd_kcontrol *k, int event)
1342
1343 {
1344         struct snd_soc_dapm_context *dapm = w->dapm;
1345         struct skl_dev *skl = get_skl_ctx(dapm->dev);
1346
1347         switch (event) {
1348         case SND_SOC_DAPM_PRE_PMU:
1349                 return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
1350
1351         case SND_SOC_DAPM_POST_PMD:
1352                 return skl_tplg_pga_dapm_post_pmd_event(w, skl);
1353         }
1354
1355         return 0;
1356 }
1357
1358 static int skl_tplg_multi_config_set_get(struct snd_kcontrol *kcontrol,
1359                                          struct snd_ctl_elem_value *ucontrol,
1360                                          bool is_set)
1361 {
1362         struct snd_soc_component *component =
1363                 snd_soc_kcontrol_component(kcontrol);
1364         struct hdac_bus *bus = snd_soc_component_get_drvdata(component);
1365         struct skl_dev *skl = bus_to_skl(bus);
1366         struct skl_pipeline *ppl;
1367         struct skl_pipe *pipe = NULL;
1368         struct soc_enum *ec = (struct soc_enum *)kcontrol->private_value;
1369         u32 *pipe_id;
1370
1371         if (!ec)
1372                 return -EINVAL;
1373
1374         if (is_set && ucontrol->value.enumerated.item[0] > ec->items)
1375                 return -EINVAL;
1376
1377         pipe_id = ec->dobj.private;
1378
1379         list_for_each_entry(ppl, &skl->ppl_list, node) {
1380                 if (ppl->pipe->ppl_id == *pipe_id) {
1381                         pipe = ppl->pipe;
1382                         break;
1383                 }
1384         }
1385         if (!pipe)
1386                 return -EIO;
1387
1388         if (is_set)
1389                 pipe->pipe_config_idx = ucontrol->value.enumerated.item[0];
1390         else
1391                 ucontrol->value.enumerated.item[0]  =  pipe->pipe_config_idx;
1392
1393         return 0;
1394 }
1395
1396 static int skl_tplg_multi_config_get(struct snd_kcontrol *kcontrol,
1397                                      struct snd_ctl_elem_value *ucontrol)
1398 {
1399         return skl_tplg_multi_config_set_get(kcontrol, ucontrol, false);
1400 }
1401
1402 static int skl_tplg_multi_config_set(struct snd_kcontrol *kcontrol,
1403                                      struct snd_ctl_elem_value *ucontrol)
1404 {
1405         return skl_tplg_multi_config_set_get(kcontrol, ucontrol, true);
1406 }
1407
1408 static int skl_tplg_multi_config_get_dmic(struct snd_kcontrol *kcontrol,
1409                                           struct snd_ctl_elem_value *ucontrol)
1410 {
1411         return skl_tplg_multi_config_set_get(kcontrol, ucontrol, false);
1412 }
1413
1414 static int skl_tplg_multi_config_set_dmic(struct snd_kcontrol *kcontrol,
1415                                           struct snd_ctl_elem_value *ucontrol)
1416 {
1417         return skl_tplg_multi_config_set_get(kcontrol, ucontrol, true);
1418 }
1419
1420 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
1421                         unsigned int __user *data, unsigned int size)
1422 {
1423         struct soc_bytes_ext *sb =
1424                         (struct soc_bytes_ext *)kcontrol->private_value;
1425         struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
1426         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1427         struct skl_module_cfg *mconfig = w->priv;
1428         struct skl_dev *skl = get_skl_ctx(w->dapm->dev);
1429
1430         if (w->power)
1431                 skl_get_module_params(skl, (u32 *)bc->params,
1432                                       bc->size, bc->param_id, mconfig);
1433
1434         /* decrement size for TLV header */
1435         size -= 2 * sizeof(u32);
1436
1437         /* check size as we don't want to send kernel data */
1438         if (size > bc->max)
1439                 size = bc->max;
1440
1441         if (bc->params) {
1442                 if (copy_to_user(data, &bc->param_id, sizeof(u32)))
1443                         return -EFAULT;
1444                 if (copy_to_user(data + 1, &size, sizeof(u32)))
1445                         return -EFAULT;
1446                 if (copy_to_user(data + 2, bc->params, size))
1447                         return -EFAULT;
1448         }
1449
1450         return 0;
1451 }
1452
1453 #define SKL_PARAM_VENDOR_ID 0xff
1454
1455 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
1456                         const unsigned int __user *data, unsigned int size)
1457 {
1458         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1459         struct skl_module_cfg *mconfig = w->priv;
1460         struct soc_bytes_ext *sb =
1461                         (struct soc_bytes_ext *)kcontrol->private_value;
1462         struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
1463         struct skl_dev *skl = get_skl_ctx(w->dapm->dev);
1464
1465         if (ac->params) {
1466                 if (size > ac->max)
1467                         return -EINVAL;
1468                 ac->size = size;
1469
1470                 if (copy_from_user(ac->params, data, size))
1471                         return -EFAULT;
1472
1473                 if (w->power)
1474                         return skl_set_module_params(skl,
1475                                                 (u32 *)ac->params, ac->size,
1476                                                 ac->param_id, mconfig);
1477         }
1478
1479         return 0;
1480 }
1481
1482 static int skl_tplg_mic_control_get(struct snd_kcontrol *kcontrol,
1483                 struct snd_ctl_elem_value *ucontrol)
1484 {
1485         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1486         struct skl_module_cfg *mconfig = w->priv;
1487         struct soc_enum *ec = (struct soc_enum *)kcontrol->private_value;
1488         u32 ch_type = *((u32 *)ec->dobj.private);
1489
1490         if (mconfig->dmic_ch_type == ch_type)
1491                 ucontrol->value.enumerated.item[0] =
1492                                         mconfig->dmic_ch_combo_index;
1493         else
1494                 ucontrol->value.enumerated.item[0] = 0;
1495
1496         return 0;
1497 }
1498
1499 static int skl_fill_mic_sel_params(struct skl_module_cfg *mconfig,
1500         struct skl_mic_sel_config *mic_cfg, struct device *dev)
1501 {
1502         struct skl_specific_cfg *sp_cfg = &mconfig->formats_config;
1503
1504         sp_cfg->caps_size = sizeof(struct skl_mic_sel_config);
1505         sp_cfg->set_params = SKL_PARAM_SET;
1506         sp_cfg->param_id = 0x00;
1507         if (!sp_cfg->caps) {
1508                 sp_cfg->caps = devm_kzalloc(dev, sp_cfg->caps_size, GFP_KERNEL);
1509                 if (!sp_cfg->caps)
1510                         return -ENOMEM;
1511         }
1512
1513         mic_cfg->mic_switch = SKL_MIC_SEL_SWITCH;
1514         mic_cfg->flags = 0;
1515         memcpy(sp_cfg->caps, mic_cfg, sp_cfg->caps_size);
1516
1517         return 0;
1518 }
1519
1520 static int skl_tplg_mic_control_set(struct snd_kcontrol *kcontrol,
1521                         struct snd_ctl_elem_value *ucontrol)
1522 {
1523         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1524         struct skl_module_cfg *mconfig = w->priv;
1525         struct skl_mic_sel_config mic_cfg = {0};
1526         struct soc_enum *ec = (struct soc_enum *)kcontrol->private_value;
1527         u32 ch_type = *((u32 *)ec->dobj.private);
1528         const int *list;
1529         u8 in_ch, out_ch, index;
1530
1531         mconfig->dmic_ch_type = ch_type;
1532         mconfig->dmic_ch_combo_index = ucontrol->value.enumerated.item[0];
1533
1534         /* enum control index 0 is INVALID, so no channels to be set */
1535         if (mconfig->dmic_ch_combo_index == 0)
1536                 return 0;
1537
1538         /* No valid channel selection map for index 0, so offset by 1 */
1539         index = mconfig->dmic_ch_combo_index - 1;
1540
1541         switch (ch_type) {
1542         case SKL_CH_MONO:
1543                 if (mconfig->dmic_ch_combo_index > ARRAY_SIZE(mic_mono_list))
1544                         return -EINVAL;
1545
1546                 list = &mic_mono_list[index];
1547                 break;
1548
1549         case SKL_CH_STEREO:
1550                 if (mconfig->dmic_ch_combo_index > ARRAY_SIZE(mic_stereo_list))
1551                         return -EINVAL;
1552
1553                 list = mic_stereo_list[index];
1554                 break;
1555
1556         case SKL_CH_TRIO:
1557                 if (mconfig->dmic_ch_combo_index > ARRAY_SIZE(mic_trio_list))
1558                         return -EINVAL;
1559
1560                 list = mic_trio_list[index];
1561                 break;
1562
1563         case SKL_CH_QUATRO:
1564                 if (mconfig->dmic_ch_combo_index > ARRAY_SIZE(mic_quatro_list))
1565                         return -EINVAL;
1566
1567                 list = mic_quatro_list[index];
1568                 break;
1569
1570         default:
1571                 dev_err(w->dapm->dev,
1572                                 "Invalid channel %d for mic_select module\n",
1573                                 ch_type);
1574                 return -EINVAL;
1575
1576         }
1577
1578         /* channel type enum map to number of chanels for that type */
1579         for (out_ch = 0; out_ch < ch_type; out_ch++) {
1580                 in_ch = list[out_ch];
1581                 mic_cfg.blob[out_ch][in_ch] = SKL_DEFAULT_MIC_SEL_GAIN;
1582         }
1583
1584         return skl_fill_mic_sel_params(mconfig, &mic_cfg, w->dapm->dev);
1585 }
1586
1587 /*
1588  * Fill the dma id for host and link. In case of passthrough
1589  * pipeline, this will both host and link in the same
1590  * pipeline, so need to copy the link and host based on dev_type
1591  */
1592 static void skl_tplg_fill_dma_id(struct skl_module_cfg *mcfg,
1593                                 struct skl_pipe_params *params)
1594 {
1595         struct skl_pipe *pipe = mcfg->pipe;
1596
1597         if (pipe->passthru) {
1598                 switch (mcfg->dev_type) {
1599                 case SKL_DEVICE_HDALINK:
1600                         pipe->p_params->link_dma_id = params->link_dma_id;
1601                         pipe->p_params->link_index = params->link_index;
1602                         pipe->p_params->link_bps = params->link_bps;
1603                         break;
1604
1605                 case SKL_DEVICE_HDAHOST:
1606                         pipe->p_params->host_dma_id = params->host_dma_id;
1607                         pipe->p_params->host_bps = params->host_bps;
1608                         break;
1609
1610                 default:
1611                         break;
1612                 }
1613                 pipe->p_params->s_fmt = params->s_fmt;
1614                 pipe->p_params->ch = params->ch;
1615                 pipe->p_params->s_freq = params->s_freq;
1616                 pipe->p_params->stream = params->stream;
1617                 pipe->p_params->format = params->format;
1618
1619         } else {
1620                 memcpy(pipe->p_params, params, sizeof(*params));
1621         }
1622 }
1623
1624 /*
1625  * The FE params are passed by hw_params of the DAI.
1626  * On hw_params, the params are stored in Gateway module of the FE and we
1627  * need to calculate the format in DSP module configuration, that
1628  * conversion is done here
1629  */
1630 int skl_tplg_update_pipe_params(struct device *dev,
1631                         struct skl_module_cfg *mconfig,
1632                         struct skl_pipe_params *params)
1633 {
1634         struct skl_module_res *res;
1635         struct skl_dev *skl = get_skl_ctx(dev);
1636         struct skl_module_fmt *format = NULL;
1637         u8 cfg_idx = mconfig->pipe->cur_config_idx;
1638
1639         res = &mconfig->module->resources[mconfig->res_idx];
1640         skl_tplg_fill_dma_id(mconfig, params);
1641         mconfig->fmt_idx = mconfig->mod_cfg[cfg_idx].fmt_idx;
1642         mconfig->res_idx = mconfig->mod_cfg[cfg_idx].res_idx;
1643
1644         if (skl->nr_modules)
1645                 return 0;
1646
1647         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
1648                 format = &mconfig->module->formats[mconfig->fmt_idx].inputs[0].fmt;
1649         else
1650                 format = &mconfig->module->formats[mconfig->fmt_idx].outputs[0].fmt;
1651
1652         /* set the hw_params */
1653         format->s_freq = params->s_freq;
1654         format->channels = params->ch;
1655         format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1656
1657         /*
1658          * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1659          * container so update bit depth accordingly
1660          */
1661         switch (format->valid_bit_depth) {
1662         case SKL_DEPTH_16BIT:
1663                 format->bit_depth = format->valid_bit_depth;
1664                 break;
1665
1666         case SKL_DEPTH_24BIT:
1667         case SKL_DEPTH_32BIT:
1668                 format->bit_depth = SKL_DEPTH_32BIT;
1669                 break;
1670
1671         default:
1672                 dev_err(dev, "Invalid bit depth %x for pipe\n",
1673                                 format->valid_bit_depth);
1674                 return -EINVAL;
1675         }
1676
1677         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1678                 res->ibs = (format->s_freq / 1000) *
1679                                 (format->channels) *
1680                                 (format->bit_depth >> 3);
1681         } else {
1682                 res->obs = (format->s_freq / 1000) *
1683                                 (format->channels) *
1684                                 (format->bit_depth >> 3);
1685         }
1686
1687         return 0;
1688 }
1689
1690 /*
1691  * Query the module config for the FE DAI
1692  * This is used to find the hw_params set for that DAI and apply to FE
1693  * pipeline
1694  */
1695 struct skl_module_cfg *
1696 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1697 {
1698         struct snd_soc_dapm_widget *w;
1699         struct snd_soc_dapm_path *p = NULL;
1700
1701         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1702                 w = dai->playback_widget;
1703                 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1704                         if (p->connect && p->sink->power &&
1705                                 !is_skl_dsp_widget_type(p->sink, dai->dev))
1706                                 continue;
1707
1708                         if (p->sink->priv) {
1709                                 dev_dbg(dai->dev, "set params for %s\n",
1710                                                 p->sink->name);
1711                                 return p->sink->priv;
1712                         }
1713                 }
1714         } else {
1715                 w = dai->capture_widget;
1716                 snd_soc_dapm_widget_for_each_source_path(w, p) {
1717                         if (p->connect && p->source->power &&
1718                                 !is_skl_dsp_widget_type(p->source, dai->dev))
1719                                 continue;
1720
1721                         if (p->source->priv) {
1722                                 dev_dbg(dai->dev, "set params for %s\n",
1723                                                 p->source->name);
1724                                 return p->source->priv;
1725                         }
1726                 }
1727         }
1728
1729         return NULL;
1730 }
1731
1732 static struct skl_module_cfg *skl_get_mconfig_pb_cpr(
1733                 struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1734 {
1735         struct snd_soc_dapm_path *p;
1736         struct skl_module_cfg *mconfig = NULL;
1737
1738         snd_soc_dapm_widget_for_each_source_path(w, p) {
1739                 if (w->endpoints[SND_SOC_DAPM_DIR_OUT] > 0) {
1740                         if (p->connect &&
1741                                     (p->sink->id == snd_soc_dapm_aif_out) &&
1742                                     p->source->priv) {
1743                                 mconfig = p->source->priv;
1744                                 return mconfig;
1745                         }
1746                         mconfig = skl_get_mconfig_pb_cpr(dai, p->source);
1747                         if (mconfig)
1748                                 return mconfig;
1749                 }
1750         }
1751         return mconfig;
1752 }
1753
1754 static struct skl_module_cfg *skl_get_mconfig_cap_cpr(
1755                 struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1756 {
1757         struct snd_soc_dapm_path *p;
1758         struct skl_module_cfg *mconfig = NULL;
1759
1760         snd_soc_dapm_widget_for_each_sink_path(w, p) {
1761                 if (w->endpoints[SND_SOC_DAPM_DIR_IN] > 0) {
1762                         if (p->connect &&
1763                                     (p->source->id == snd_soc_dapm_aif_in) &&
1764                                     p->sink->priv) {
1765                                 mconfig = p->sink->priv;
1766                                 return mconfig;
1767                         }
1768                         mconfig = skl_get_mconfig_cap_cpr(dai, p->sink);
1769                         if (mconfig)
1770                                 return mconfig;
1771                 }
1772         }
1773         return mconfig;
1774 }
1775
1776 struct skl_module_cfg *
1777 skl_tplg_be_get_cpr_module(struct snd_soc_dai *dai, int stream)
1778 {
1779         struct snd_soc_dapm_widget *w;
1780         struct skl_module_cfg *mconfig;
1781
1782         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1783                 w = dai->playback_widget;
1784                 mconfig = skl_get_mconfig_pb_cpr(dai, w);
1785         } else {
1786                 w = dai->capture_widget;
1787                 mconfig = skl_get_mconfig_cap_cpr(dai, w);
1788         }
1789         return mconfig;
1790 }
1791
1792 static u8 skl_tplg_be_link_type(int dev_type)
1793 {
1794         int ret;
1795
1796         switch (dev_type) {
1797         case SKL_DEVICE_BT:
1798                 ret = NHLT_LINK_SSP;
1799                 break;
1800
1801         case SKL_DEVICE_DMIC:
1802                 ret = NHLT_LINK_DMIC;
1803                 break;
1804
1805         case SKL_DEVICE_I2S:
1806                 ret = NHLT_LINK_SSP;
1807                 break;
1808
1809         case SKL_DEVICE_HDALINK:
1810                 ret = NHLT_LINK_HDA;
1811                 break;
1812
1813         default:
1814                 ret = NHLT_LINK_INVALID;
1815                 break;
1816         }
1817
1818         return ret;
1819 }
1820
1821 /*
1822  * Fill the BE gateway parameters
1823  * The BE gateway expects a blob of parameters which are kept in the ACPI
1824  * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1825  * The port can have multiple settings so pick based on the PCM
1826  * parameters
1827  */
1828 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1829                                 struct skl_module_cfg *mconfig,
1830                                 struct skl_pipe_params *params)
1831 {
1832         struct nhlt_specific_cfg *cfg;
1833         struct skl_dev *skl = get_skl_ctx(dai->dev);
1834         int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1835         u8 dev_type = skl_tplg_be_dev_type(mconfig->dev_type);
1836
1837         skl_tplg_fill_dma_id(mconfig, params);
1838
1839         if (link_type == NHLT_LINK_HDA)
1840                 return 0;
1841
1842         /* update the blob based on virtual bus_id*/
1843         cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1844                                         params->s_fmt, params->ch,
1845                                         params->s_freq, params->stream,
1846                                         dev_type);
1847         if (cfg) {
1848                 mconfig->formats_config.caps_size = cfg->size;
1849                 mconfig->formats_config.caps = (u32 *) &cfg->caps;
1850         } else {
1851                 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1852                                         mconfig->vbus_id, link_type,
1853                                         params->stream);
1854                 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1855                                  params->ch, params->s_freq, params->s_fmt);
1856                 return -EINVAL;
1857         }
1858
1859         return 0;
1860 }
1861
1862 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1863                                 struct snd_soc_dapm_widget *w,
1864                                 struct skl_pipe_params *params)
1865 {
1866         struct snd_soc_dapm_path *p;
1867         int ret = -EIO;
1868
1869         snd_soc_dapm_widget_for_each_source_path(w, p) {
1870                 if (p->connect && is_skl_dsp_widget_type(p->source, dai->dev) &&
1871                                                 p->source->priv) {
1872
1873                         ret = skl_tplg_be_fill_pipe_params(dai,
1874                                                 p->source->priv, params);
1875                         if (ret < 0)
1876                                 return ret;
1877                 } else {
1878                         ret = skl_tplg_be_set_src_pipe_params(dai,
1879                                                 p->source, params);
1880                         if (ret < 0)
1881                                 return ret;
1882                 }
1883         }
1884
1885         return ret;
1886 }
1887
1888 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1889         struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1890 {
1891         struct snd_soc_dapm_path *p;
1892         int ret = -EIO;
1893
1894         snd_soc_dapm_widget_for_each_sink_path(w, p) {
1895                 if (p->connect && is_skl_dsp_widget_type(p->sink, dai->dev) &&
1896                                                 p->sink->priv) {
1897
1898                         ret = skl_tplg_be_fill_pipe_params(dai,
1899                                                 p->sink->priv, params);
1900                         if (ret < 0)
1901                                 return ret;
1902                 } else {
1903                         ret = skl_tplg_be_set_sink_pipe_params(
1904                                                 dai, p->sink, params);
1905                         if (ret < 0)
1906                                 return ret;
1907                 }
1908         }
1909
1910         return ret;
1911 }
1912
1913 /*
1914  * BE hw_params can be a source parameters (capture) or sink parameters
1915  * (playback). Based on sink and source we need to either find the source
1916  * list or the sink list and set the pipeline parameters
1917  */
1918 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1919                                 struct skl_pipe_params *params)
1920 {
1921         struct snd_soc_dapm_widget *w;
1922
1923         if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1924                 w = dai->playback_widget;
1925
1926                 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1927
1928         } else {
1929                 w = dai->capture_widget;
1930
1931                 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1932         }
1933
1934         return 0;
1935 }
1936
1937 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1938         {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1939         {SKL_VMIXER_EVENT, skl_tplg_mixer_event},
1940         {SKL_PGA_EVENT, skl_tplg_pga_event},
1941 };
1942
1943 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1944         {SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1945                                         skl_tplg_tlv_control_set},
1946 };
1947
1948 static const struct snd_soc_tplg_kcontrol_ops skl_tplg_kcontrol_ops[] = {
1949         {
1950                 .id = SKL_CONTROL_TYPE_MIC_SELECT,
1951                 .get = skl_tplg_mic_control_get,
1952                 .put = skl_tplg_mic_control_set,
1953         },
1954         {
1955                 .id = SKL_CONTROL_TYPE_MULTI_IO_SELECT,
1956                 .get = skl_tplg_multi_config_get,
1957                 .put = skl_tplg_multi_config_set,
1958         },
1959         {
1960                 .id = SKL_CONTROL_TYPE_MULTI_IO_SELECT_DMIC,
1961                 .get = skl_tplg_multi_config_get_dmic,
1962                 .put = skl_tplg_multi_config_set_dmic,
1963         }
1964 };
1965
1966 static int skl_tplg_fill_pipe_cfg(struct device *dev,
1967                         struct skl_pipe *pipe, u32 tkn,
1968                         u32 tkn_val, int conf_idx, int dir)
1969 {
1970         struct skl_pipe_fmt *fmt;
1971         struct skl_path_config *config;
1972
1973         switch (dir) {
1974         case SKL_DIR_IN:
1975                 fmt = &pipe->configs[conf_idx].in_fmt;
1976                 break;
1977
1978         case SKL_DIR_OUT:
1979                 fmt = &pipe->configs[conf_idx].out_fmt;
1980                 break;
1981
1982         default:
1983                 dev_err(dev, "Invalid direction: %d\n", dir);
1984                 return -EINVAL;
1985         }
1986
1987         config = &pipe->configs[conf_idx];
1988
1989         switch (tkn) {
1990         case SKL_TKN_U32_CFG_FREQ:
1991                 fmt->freq = tkn_val;
1992                 break;
1993
1994         case SKL_TKN_U8_CFG_CHAN:
1995                 fmt->channels = tkn_val;
1996                 break;
1997
1998         case SKL_TKN_U8_CFG_BPS:
1999                 fmt->bps = tkn_val;
2000                 break;
2001
2002         case SKL_TKN_U32_PATH_MEM_PGS:
2003                 config->mem_pages = tkn_val;
2004                 break;
2005
2006         default:
2007                 dev_err(dev, "Invalid token config: %d\n", tkn);
2008                 return -EINVAL;
2009         }
2010
2011         return 0;
2012 }
2013
2014 static int skl_tplg_fill_pipe_tkn(struct device *dev,
2015                         struct skl_pipe *pipe, u32 tkn,
2016                         u32 tkn_val)
2017 {
2018
2019         switch (tkn) {
2020         case SKL_TKN_U32_PIPE_CONN_TYPE:
2021                 pipe->conn_type = tkn_val;
2022                 break;
2023
2024         case SKL_TKN_U32_PIPE_PRIORITY:
2025                 pipe->pipe_priority = tkn_val;
2026                 break;
2027
2028         case SKL_TKN_U32_PIPE_MEM_PGS:
2029                 pipe->memory_pages = tkn_val;
2030                 break;
2031
2032         case SKL_TKN_U32_PMODE:
2033                 pipe->lp_mode = tkn_val;
2034                 break;
2035
2036         case SKL_TKN_U32_PIPE_DIRECTION:
2037                 pipe->direction = tkn_val;
2038                 break;
2039
2040         case SKL_TKN_U32_NUM_CONFIGS:
2041                 pipe->nr_cfgs = tkn_val;
2042                 break;
2043
2044         default:
2045                 dev_err(dev, "Token not handled %d\n", tkn);
2046                 return -EINVAL;
2047         }
2048
2049         return 0;
2050 }
2051
2052 /*
2053  * Add pipeline by parsing the relevant tokens
2054  * Return an existing pipe if the pipe already exists.
2055  */
2056 static int skl_tplg_add_pipe(struct device *dev,
2057                 struct skl_module_cfg *mconfig, struct skl_dev *skl,
2058                 struct snd_soc_tplg_vendor_value_elem *tkn_elem)
2059 {
2060         struct skl_pipeline *ppl;
2061         struct skl_pipe *pipe;
2062         struct skl_pipe_params *params;
2063
2064         list_for_each_entry(ppl, &skl->ppl_list, node) {
2065                 if (ppl->pipe->ppl_id == tkn_elem->value) {
2066                         mconfig->pipe = ppl->pipe;
2067                         return -EEXIST;
2068                 }
2069         }
2070
2071         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
2072         if (!ppl)
2073                 return -ENOMEM;
2074
2075         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
2076         if (!pipe)
2077                 return -ENOMEM;
2078
2079         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
2080         if (!params)
2081                 return -ENOMEM;
2082
2083         pipe->p_params = params;
2084         pipe->ppl_id = tkn_elem->value;
2085         INIT_LIST_HEAD(&pipe->w_list);
2086
2087         ppl->pipe = pipe;
2088         list_add(&ppl->node, &skl->ppl_list);
2089
2090         mconfig->pipe = pipe;
2091         mconfig->pipe->state = SKL_PIPE_INVALID;
2092
2093         return 0;
2094 }
2095
2096 static int skl_tplg_get_uuid(struct device *dev, guid_t *guid,
2097               struct snd_soc_tplg_vendor_uuid_elem *uuid_tkn)
2098 {
2099         if (uuid_tkn->token == SKL_TKN_UUID) {
2100                 import_guid(guid, uuid_tkn->uuid);
2101                 return 0;
2102         }
2103
2104         dev_err(dev, "Not an UUID token %d\n", uuid_tkn->token);
2105
2106         return -EINVAL;
2107 }
2108
2109 static int skl_tplg_fill_pin(struct device *dev,
2110                         struct snd_soc_tplg_vendor_value_elem *tkn_elem,
2111                         struct skl_module_pin *m_pin,
2112                         int pin_index)
2113 {
2114         int ret;
2115
2116         switch (tkn_elem->token) {
2117         case SKL_TKN_U32_PIN_MOD_ID:
2118                 m_pin[pin_index].id.module_id = tkn_elem->value;
2119                 break;
2120
2121         case SKL_TKN_U32_PIN_INST_ID:
2122                 m_pin[pin_index].id.instance_id = tkn_elem->value;
2123                 break;
2124
2125         case SKL_TKN_UUID:
2126                 ret = skl_tplg_get_uuid(dev, &m_pin[pin_index].id.mod_uuid,
2127                         (struct snd_soc_tplg_vendor_uuid_elem *)tkn_elem);
2128                 if (ret < 0)
2129                         return ret;
2130
2131                 break;
2132
2133         default:
2134                 dev_err(dev, "%d Not a pin token\n", tkn_elem->token);
2135                 return -EINVAL;
2136         }
2137
2138         return 0;
2139 }
2140
2141 /*
2142  * Parse for pin config specific tokens to fill up the
2143  * module private data
2144  */
2145 static int skl_tplg_fill_pins_info(struct device *dev,
2146                 struct skl_module_cfg *mconfig,
2147                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
2148                 int dir, int pin_count)
2149 {
2150         int ret;
2151         struct skl_module_pin *m_pin;
2152
2153         switch (dir) {
2154         case SKL_DIR_IN:
2155                 m_pin = mconfig->m_in_pin;
2156                 break;
2157
2158         case SKL_DIR_OUT:
2159                 m_pin = mconfig->m_out_pin;
2160                 break;
2161
2162         default:
2163                 dev_err(dev, "Invalid direction value\n");
2164                 return -EINVAL;
2165         }
2166
2167         ret = skl_tplg_fill_pin(dev, tkn_elem, m_pin, pin_count);
2168         if (ret < 0)
2169                 return ret;
2170
2171         m_pin[pin_count].in_use = false;
2172         m_pin[pin_count].pin_state = SKL_PIN_UNBIND;
2173
2174         return 0;
2175 }
2176
2177 /*
2178  * Fill up input/output module config format based
2179  * on the direction
2180  */
2181 static int skl_tplg_fill_fmt(struct device *dev,
2182                 struct skl_module_fmt *dst_fmt,
2183                 u32 tkn, u32 value)
2184 {
2185         switch (tkn) {
2186         case SKL_TKN_U32_FMT_CH:
2187                 dst_fmt->channels  = value;
2188                 break;
2189
2190         case SKL_TKN_U32_FMT_FREQ:
2191                 dst_fmt->s_freq = value;
2192                 break;
2193
2194         case SKL_TKN_U32_FMT_BIT_DEPTH:
2195                 dst_fmt->bit_depth = value;
2196                 break;
2197
2198         case SKL_TKN_U32_FMT_SAMPLE_SIZE:
2199                 dst_fmt->valid_bit_depth = value;
2200                 break;
2201
2202         case SKL_TKN_U32_FMT_CH_CONFIG:
2203                 dst_fmt->ch_cfg = value;
2204                 break;
2205
2206         case SKL_TKN_U32_FMT_INTERLEAVE:
2207                 dst_fmt->interleaving_style = value;
2208                 break;
2209
2210         case SKL_TKN_U32_FMT_SAMPLE_TYPE:
2211                 dst_fmt->sample_type = value;
2212                 break;
2213
2214         case SKL_TKN_U32_FMT_CH_MAP:
2215                 dst_fmt->ch_map = value;
2216                 break;
2217
2218         default:
2219                 dev_err(dev, "Invalid token %d\n", tkn);
2220                 return -EINVAL;
2221         }
2222
2223         return 0;
2224 }
2225
2226 static int skl_tplg_widget_fill_fmt(struct device *dev,
2227                 struct skl_module_iface *fmt,
2228                 u32 tkn, u32 val, u32 dir, int fmt_idx)
2229 {
2230         struct skl_module_fmt *dst_fmt;
2231
2232         if (!fmt)
2233                 return -EINVAL;
2234
2235         switch (dir) {
2236         case SKL_DIR_IN:
2237                 dst_fmt = &fmt->inputs[fmt_idx].fmt;
2238                 break;
2239
2240         case SKL_DIR_OUT:
2241                 dst_fmt = &fmt->outputs[fmt_idx].fmt;
2242                 break;
2243
2244         default:
2245                 dev_err(dev, "Invalid direction: %d\n", dir);
2246                 return -EINVAL;
2247         }
2248
2249         return skl_tplg_fill_fmt(dev, dst_fmt, tkn, val);
2250 }
2251
2252 static void skl_tplg_fill_pin_dynamic_val(
2253                 struct skl_module_pin *mpin, u32 pin_count, u32 value)
2254 {
2255         int i;
2256
2257         for (i = 0; i < pin_count; i++)
2258                 mpin[i].is_dynamic = value;
2259 }
2260
2261 /*
2262  * Resource table in the manifest has pin specific resources
2263  * like pin and pin buffer size
2264  */
2265 static int skl_tplg_manifest_pin_res_tkn(struct device *dev,
2266                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
2267                 struct skl_module_res *res, int pin_idx, int dir)
2268 {
2269         struct skl_module_pin_resources *m_pin;
2270
2271         switch (dir) {
2272         case SKL_DIR_IN:
2273                 m_pin = &res->input[pin_idx];
2274                 break;
2275
2276         case SKL_DIR_OUT:
2277                 m_pin = &res->output[pin_idx];
2278                 break;
2279
2280         default:
2281                 dev_err(dev, "Invalid pin direction: %d\n", dir);
2282                 return -EINVAL;
2283         }
2284
2285         switch (tkn_elem->token) {
2286         case SKL_TKN_MM_U32_RES_PIN_ID:
2287                 m_pin->pin_index = tkn_elem->value;
2288                 break;
2289
2290         case SKL_TKN_MM_U32_PIN_BUF:
2291                 m_pin->buf_size = tkn_elem->value;
2292                 break;
2293
2294         default:
2295                 dev_err(dev, "Invalid token: %d\n", tkn_elem->token);
2296                 return -EINVAL;
2297         }
2298
2299         return 0;
2300 }
2301
2302 /*
2303  * Fill module specific resources from the manifest's resource
2304  * table like CPS, DMA size, mem_pages.
2305  */
2306 static int skl_tplg_fill_res_tkn(struct device *dev,
2307                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
2308                 struct skl_module_res *res,
2309                 int pin_idx, int dir)
2310 {
2311         int ret, tkn_count = 0;
2312
2313         if (!res)
2314                 return -EINVAL;
2315
2316         switch (tkn_elem->token) {
2317         case SKL_TKN_MM_U32_DMA_SIZE:
2318                 res->dma_buffer_size = tkn_elem->value;
2319                 break;
2320
2321         case SKL_TKN_MM_U32_CPC:
2322                 res->cpc = tkn_elem->value;
2323                 break;
2324
2325         case SKL_TKN_U32_MEM_PAGES:
2326                 res->is_pages = tkn_elem->value;
2327                 break;
2328
2329         case SKL_TKN_U32_OBS:
2330                 res->obs = tkn_elem->value;
2331                 break;
2332
2333         case SKL_TKN_U32_IBS:
2334                 res->ibs = tkn_elem->value;
2335                 break;
2336
2337         case SKL_TKN_MM_U32_RES_PIN_ID:
2338         case SKL_TKN_MM_U32_PIN_BUF:
2339                 ret = skl_tplg_manifest_pin_res_tkn(dev, tkn_elem, res,
2340                                                     pin_idx, dir);
2341                 if (ret < 0)
2342                         return ret;
2343                 break;
2344
2345         case SKL_TKN_MM_U32_CPS:
2346         case SKL_TKN_U32_MAX_MCPS:
2347                 /* ignore unused tokens */
2348                 break;
2349
2350         default:
2351                 dev_err(dev, "Not a res type token: %d", tkn_elem->token);
2352                 return -EINVAL;
2353
2354         }
2355         tkn_count++;
2356
2357         return tkn_count;
2358 }
2359
2360 /*
2361  * Parse tokens to fill up the module private data
2362  */
2363 static int skl_tplg_get_token(struct device *dev,
2364                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
2365                 struct skl_dev *skl, struct skl_module_cfg *mconfig)
2366 {
2367         int tkn_count = 0;
2368         int ret;
2369         static int is_pipe_exists;
2370         static int pin_index, dir, conf_idx;
2371         struct skl_module_iface *iface = NULL;
2372         struct skl_module_res *res = NULL;
2373         int res_idx = mconfig->res_idx;
2374         int fmt_idx = mconfig->fmt_idx;
2375
2376         /*
2377          * If the manifest structure contains no modules, fill all
2378          * the module data to 0th index.
2379          * res_idx and fmt_idx are default set to 0.
2380          */
2381         if (skl->nr_modules == 0) {
2382                 res = &mconfig->module->resources[res_idx];
2383                 iface = &mconfig->module->formats[fmt_idx];
2384         }
2385
2386         if (tkn_elem->token > SKL_TKN_MAX)
2387                 return -EINVAL;
2388
2389         switch (tkn_elem->token) {
2390         case SKL_TKN_U8_IN_QUEUE_COUNT:
2391                 mconfig->module->max_input_pins = tkn_elem->value;
2392                 break;
2393
2394         case SKL_TKN_U8_OUT_QUEUE_COUNT:
2395                 mconfig->module->max_output_pins = tkn_elem->value;
2396                 break;
2397
2398         case SKL_TKN_U8_DYN_IN_PIN:
2399                 if (!mconfig->m_in_pin)
2400                         mconfig->m_in_pin =
2401                                 devm_kcalloc(dev, MAX_IN_QUEUE,
2402                                              sizeof(*mconfig->m_in_pin),
2403                                              GFP_KERNEL);
2404                 if (!mconfig->m_in_pin)
2405                         return -ENOMEM;
2406
2407                 skl_tplg_fill_pin_dynamic_val(mconfig->m_in_pin, MAX_IN_QUEUE,
2408                                               tkn_elem->value);
2409                 break;
2410
2411         case SKL_TKN_U8_DYN_OUT_PIN:
2412                 if (!mconfig->m_out_pin)
2413                         mconfig->m_out_pin =
2414                                 devm_kcalloc(dev, MAX_IN_QUEUE,
2415                                              sizeof(*mconfig->m_in_pin),
2416                                              GFP_KERNEL);
2417                 if (!mconfig->m_out_pin)
2418                         return -ENOMEM;
2419
2420                 skl_tplg_fill_pin_dynamic_val(mconfig->m_out_pin, MAX_OUT_QUEUE,
2421                                               tkn_elem->value);
2422                 break;
2423
2424         case SKL_TKN_U8_TIME_SLOT:
2425                 mconfig->time_slot = tkn_elem->value;
2426                 break;
2427
2428         case SKL_TKN_U8_CORE_ID:
2429                 mconfig->core_id = tkn_elem->value;
2430                 break;
2431
2432         case SKL_TKN_U8_MOD_TYPE:
2433                 mconfig->m_type = tkn_elem->value;
2434                 break;
2435
2436         case SKL_TKN_U8_DEV_TYPE:
2437                 mconfig->dev_type = tkn_elem->value;
2438                 break;
2439
2440         case SKL_TKN_U8_HW_CONN_TYPE:
2441                 mconfig->hw_conn_type = tkn_elem->value;
2442                 break;
2443
2444         case SKL_TKN_U16_MOD_INST_ID:
2445                 mconfig->id.instance_id =
2446                 tkn_elem->value;
2447                 break;
2448
2449         case SKL_TKN_U32_MEM_PAGES:
2450         case SKL_TKN_U32_MAX_MCPS:
2451         case SKL_TKN_U32_OBS:
2452         case SKL_TKN_U32_IBS:
2453                 ret = skl_tplg_fill_res_tkn(dev, tkn_elem, res, pin_index, dir);
2454                 if (ret < 0)
2455                         return ret;
2456
2457                 break;
2458
2459         case SKL_TKN_U32_VBUS_ID:
2460                 mconfig->vbus_id = tkn_elem->value;
2461                 break;
2462
2463         case SKL_TKN_U32_PARAMS_FIXUP:
2464                 mconfig->params_fixup = tkn_elem->value;
2465                 break;
2466
2467         case SKL_TKN_U32_CONVERTER:
2468                 mconfig->converter = tkn_elem->value;
2469                 break;
2470
2471         case SKL_TKN_U32_D0I3_CAPS:
2472                 mconfig->d0i3_caps = tkn_elem->value;
2473                 break;
2474
2475         case SKL_TKN_U32_PIPE_ID:
2476                 ret = skl_tplg_add_pipe(dev,
2477                                 mconfig, skl, tkn_elem);
2478
2479                 if (ret < 0) {
2480                         if (ret == -EEXIST) {
2481                                 is_pipe_exists = 1;
2482                                 break;
2483                         }
2484                         return is_pipe_exists;
2485                 }
2486
2487                 break;
2488
2489         case SKL_TKN_U32_PIPE_CONFIG_ID:
2490                 conf_idx = tkn_elem->value;
2491                 break;
2492
2493         case SKL_TKN_U32_PIPE_CONN_TYPE:
2494         case SKL_TKN_U32_PIPE_PRIORITY:
2495         case SKL_TKN_U32_PIPE_MEM_PGS:
2496         case SKL_TKN_U32_PMODE:
2497         case SKL_TKN_U32_PIPE_DIRECTION:
2498         case SKL_TKN_U32_NUM_CONFIGS:
2499                 if (is_pipe_exists) {
2500                         ret = skl_tplg_fill_pipe_tkn(dev, mconfig->pipe,
2501                                         tkn_elem->token, tkn_elem->value);
2502                         if (ret < 0)
2503                                 return ret;
2504                 }
2505
2506                 break;
2507
2508         case SKL_TKN_U32_PATH_MEM_PGS:
2509         case SKL_TKN_U32_CFG_FREQ:
2510         case SKL_TKN_U8_CFG_CHAN:
2511         case SKL_TKN_U8_CFG_BPS:
2512                 if (mconfig->pipe->nr_cfgs) {
2513                         ret = skl_tplg_fill_pipe_cfg(dev, mconfig->pipe,
2514                                         tkn_elem->token, tkn_elem->value,
2515                                         conf_idx, dir);
2516                         if (ret < 0)
2517                                 return ret;
2518                 }
2519                 break;
2520
2521         case SKL_TKN_CFG_MOD_RES_ID:
2522                 mconfig->mod_cfg[conf_idx].res_idx = tkn_elem->value;
2523                 break;
2524
2525         case SKL_TKN_CFG_MOD_FMT_ID:
2526                 mconfig->mod_cfg[conf_idx].fmt_idx = tkn_elem->value;
2527                 break;
2528
2529         /*
2530          * SKL_TKN_U32_DIR_PIN_COUNT token has the value for both
2531          * direction and the pin count. The first four bits represent
2532          * direction and next four the pin count.
2533          */
2534         case SKL_TKN_U32_DIR_PIN_COUNT:
2535                 dir = tkn_elem->value & SKL_IN_DIR_BIT_MASK;
2536                 pin_index = (tkn_elem->value &
2537                         SKL_PIN_COUNT_MASK) >> 4;
2538
2539                 break;
2540
2541         case SKL_TKN_U32_FMT_CH:
2542         case SKL_TKN_U32_FMT_FREQ:
2543         case SKL_TKN_U32_FMT_BIT_DEPTH:
2544         case SKL_TKN_U32_FMT_SAMPLE_SIZE:
2545         case SKL_TKN_U32_FMT_CH_CONFIG:
2546         case SKL_TKN_U32_FMT_INTERLEAVE:
2547         case SKL_TKN_U32_FMT_SAMPLE_TYPE:
2548         case SKL_TKN_U32_FMT_CH_MAP:
2549                 ret = skl_tplg_widget_fill_fmt(dev, iface, tkn_elem->token,
2550                                 tkn_elem->value, dir, pin_index);
2551
2552                 if (ret < 0)
2553                         return ret;
2554
2555                 break;
2556
2557         case SKL_TKN_U32_PIN_MOD_ID:
2558         case SKL_TKN_U32_PIN_INST_ID:
2559         case SKL_TKN_UUID:
2560                 ret = skl_tplg_fill_pins_info(dev,
2561                                 mconfig, tkn_elem, dir,
2562                                 pin_index);
2563                 if (ret < 0)
2564                         return ret;
2565
2566                 break;
2567
2568         case SKL_TKN_U32_CAPS_SIZE:
2569                 mconfig->formats_config.caps_size =
2570                         tkn_elem->value;
2571
2572                 break;
2573
2574         case SKL_TKN_U32_CAPS_SET_PARAMS:
2575                 mconfig->formats_config.set_params =
2576                                 tkn_elem->value;
2577                 break;
2578
2579         case SKL_TKN_U32_CAPS_PARAMS_ID:
2580                 mconfig->formats_config.param_id =
2581                                 tkn_elem->value;
2582                 break;
2583
2584         case SKL_TKN_U32_PROC_DOMAIN:
2585                 mconfig->domain =
2586                         tkn_elem->value;
2587
2588                 break;
2589
2590         case SKL_TKN_U32_DMA_BUF_SIZE:
2591                 mconfig->dma_buffer_size = tkn_elem->value;
2592                 break;
2593
2594         case SKL_TKN_U8_IN_PIN_TYPE:
2595         case SKL_TKN_U8_OUT_PIN_TYPE:
2596         case SKL_TKN_U8_CONN_TYPE:
2597                 break;
2598
2599         default:
2600                 dev_err(dev, "Token %d not handled\n",
2601                                 tkn_elem->token);
2602                 return -EINVAL;
2603         }
2604
2605         tkn_count++;
2606
2607         return tkn_count;
2608 }
2609
2610 /*
2611  * Parse the vendor array for specific tokens to construct
2612  * module private data
2613  */
2614 static int skl_tplg_get_tokens(struct device *dev,
2615                 char *pvt_data, struct skl_dev *skl,
2616                 struct skl_module_cfg *mconfig, int block_size)
2617 {
2618         struct snd_soc_tplg_vendor_array *array;
2619         struct snd_soc_tplg_vendor_value_elem *tkn_elem;
2620         int tkn_count = 0, ret;
2621         int off = 0, tuple_size = 0;
2622         bool is_module_guid = true;
2623
2624         if (block_size <= 0)
2625                 return -EINVAL;
2626
2627         while (tuple_size < block_size) {
2628                 array = (struct snd_soc_tplg_vendor_array *)(pvt_data + off);
2629
2630                 off += array->size;
2631
2632                 switch (array->type) {
2633                 case SND_SOC_TPLG_TUPLE_TYPE_STRING:
2634                         dev_warn(dev, "no string tokens expected for skl tplg\n");
2635                         continue;
2636
2637                 case SND_SOC_TPLG_TUPLE_TYPE_UUID:
2638                         if (is_module_guid) {
2639                                 ret = skl_tplg_get_uuid(dev, (guid_t *)mconfig->guid,
2640                                                         array->uuid);
2641                                 is_module_guid = false;
2642                         } else {
2643                                 ret = skl_tplg_get_token(dev, array->value, skl,
2644                                                          mconfig);
2645                         }
2646
2647                         if (ret < 0)
2648                                 return ret;
2649
2650                         tuple_size += sizeof(*array->uuid);
2651
2652                         continue;
2653
2654                 default:
2655                         tkn_elem = array->value;
2656                         tkn_count = 0;
2657                         break;
2658                 }
2659
2660                 while (tkn_count <= (array->num_elems - 1)) {
2661                         ret = skl_tplg_get_token(dev, tkn_elem,
2662                                         skl, mconfig);
2663
2664                         if (ret < 0)
2665                                 return ret;
2666
2667                         tkn_count = tkn_count + ret;
2668                         tkn_elem++;
2669                 }
2670
2671                 tuple_size += tkn_count * sizeof(*tkn_elem);
2672         }
2673
2674         return off;
2675 }
2676
2677 /*
2678  * Every data block is preceded by a descriptor to read the number
2679  * of data blocks, they type of the block and it's size
2680  */
2681 static int skl_tplg_get_desc_blocks(struct device *dev,
2682                 struct snd_soc_tplg_vendor_array *array)
2683 {
2684         struct snd_soc_tplg_vendor_value_elem *tkn_elem;
2685
2686         tkn_elem = array->value;
2687
2688         switch (tkn_elem->token) {
2689         case SKL_TKN_U8_NUM_BLOCKS:
2690         case SKL_TKN_U8_BLOCK_TYPE:
2691         case SKL_TKN_U16_BLOCK_SIZE:
2692                 return tkn_elem->value;
2693
2694         default:
2695                 dev_err(dev, "Invalid descriptor token %d\n", tkn_elem->token);
2696                 break;
2697         }
2698
2699         return -EINVAL;
2700 }
2701
2702 /* Functions to parse private data from configuration file format v4 */
2703
2704 /*
2705  * Add pipeline from topology binary into driver pipeline list
2706  *
2707  * If already added we return that instance
2708  * Otherwise we create a new instance and add into driver list
2709  */
2710 static int skl_tplg_add_pipe_v4(struct device *dev,
2711                         struct skl_module_cfg *mconfig, struct skl_dev *skl,
2712                         struct skl_dfw_v4_pipe *dfw_pipe)
2713 {
2714         struct skl_pipeline *ppl;
2715         struct skl_pipe *pipe;
2716         struct skl_pipe_params *params;
2717
2718         list_for_each_entry(ppl, &skl->ppl_list, node) {
2719                 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id) {
2720                         mconfig->pipe = ppl->pipe;
2721                         return 0;
2722                 }
2723         }
2724
2725         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
2726         if (!ppl)
2727                 return -ENOMEM;
2728
2729         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
2730         if (!pipe)
2731                 return -ENOMEM;
2732
2733         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
2734         if (!params)
2735                 return -ENOMEM;
2736
2737         pipe->ppl_id = dfw_pipe->pipe_id;
2738         pipe->memory_pages = dfw_pipe->memory_pages;
2739         pipe->pipe_priority = dfw_pipe->pipe_priority;
2740         pipe->conn_type = dfw_pipe->conn_type;
2741         pipe->state = SKL_PIPE_INVALID;
2742         pipe->p_params = params;
2743         INIT_LIST_HEAD(&pipe->w_list);
2744
2745         ppl->pipe = pipe;
2746         list_add(&ppl->node, &skl->ppl_list);
2747
2748         mconfig->pipe = pipe;
2749
2750         return 0;
2751 }
2752
2753 static void skl_fill_module_pin_info_v4(struct skl_dfw_v4_module_pin *dfw_pin,
2754                                         struct skl_module_pin *m_pin,
2755                                         bool is_dynamic, int max_pin)
2756 {
2757         int i;
2758
2759         for (i = 0; i < max_pin; i++) {
2760                 m_pin[i].id.module_id = dfw_pin[i].module_id;
2761                 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
2762                 m_pin[i].in_use = false;
2763                 m_pin[i].is_dynamic = is_dynamic;
2764                 m_pin[i].pin_state = SKL_PIN_UNBIND;
2765         }
2766 }
2767
2768 static void skl_tplg_fill_fmt_v4(struct skl_module_pin_fmt *dst_fmt,
2769                                  struct skl_dfw_v4_module_fmt *src_fmt,
2770                                  int pins)
2771 {
2772         int i;
2773
2774         for (i = 0; i < pins; i++) {
2775                 dst_fmt[i].fmt.channels  = src_fmt[i].channels;
2776                 dst_fmt[i].fmt.s_freq = src_fmt[i].freq;
2777                 dst_fmt[i].fmt.bit_depth = src_fmt[i].bit_depth;
2778                 dst_fmt[i].fmt.valid_bit_depth = src_fmt[i].valid_bit_depth;
2779                 dst_fmt[i].fmt.ch_cfg = src_fmt[i].ch_cfg;
2780                 dst_fmt[i].fmt.ch_map = src_fmt[i].ch_map;
2781                 dst_fmt[i].fmt.interleaving_style =
2782                                                 src_fmt[i].interleaving_style;
2783                 dst_fmt[i].fmt.sample_type = src_fmt[i].sample_type;
2784         }
2785 }
2786
2787 static int skl_tplg_get_pvt_data_v4(struct snd_soc_tplg_dapm_widget *tplg_w,
2788                                     struct skl_dev *skl, struct device *dev,
2789                                     struct skl_module_cfg *mconfig)
2790 {
2791         struct skl_dfw_v4_module *dfw =
2792                                 (struct skl_dfw_v4_module *)tplg_w->priv.data;
2793         int ret;
2794
2795         dev_dbg(dev, "Parsing Skylake v4 widget topology data\n");
2796
2797         ret = guid_parse(dfw->uuid, (guid_t *)mconfig->guid);
2798         if (ret)
2799                 return ret;
2800         mconfig->id.module_id = -1;
2801         mconfig->id.instance_id = dfw->instance_id;
2802         mconfig->module->resources[0].cpc = dfw->max_mcps / 1000;
2803         mconfig->module->resources[0].ibs = dfw->ibs;
2804         mconfig->module->resources[0].obs = dfw->obs;
2805         mconfig->core_id = dfw->core_id;
2806         mconfig->module->max_input_pins = dfw->max_in_queue;
2807         mconfig->module->max_output_pins = dfw->max_out_queue;
2808         mconfig->module->loadable = dfw->is_loadable;
2809         skl_tplg_fill_fmt_v4(mconfig->module->formats[0].inputs, dfw->in_fmt,
2810                              MAX_IN_QUEUE);
2811         skl_tplg_fill_fmt_v4(mconfig->module->formats[0].outputs, dfw->out_fmt,
2812                              MAX_OUT_QUEUE);
2813
2814         mconfig->params_fixup = dfw->params_fixup;
2815         mconfig->converter = dfw->converter;
2816         mconfig->m_type = dfw->module_type;
2817         mconfig->vbus_id = dfw->vbus_id;
2818         mconfig->module->resources[0].is_pages = dfw->mem_pages;
2819
2820         ret = skl_tplg_add_pipe_v4(dev, mconfig, skl, &dfw->pipe);
2821         if (ret)
2822                 return ret;
2823
2824         mconfig->dev_type = dfw->dev_type;
2825         mconfig->hw_conn_type = dfw->hw_conn_type;
2826         mconfig->time_slot = dfw->time_slot;
2827         mconfig->formats_config.caps_size = dfw->caps.caps_size;
2828
2829         mconfig->m_in_pin = devm_kcalloc(dev,
2830                                 MAX_IN_QUEUE, sizeof(*mconfig->m_in_pin),
2831                                 GFP_KERNEL);
2832         if (!mconfig->m_in_pin)
2833                 return -ENOMEM;
2834
2835         mconfig->m_out_pin = devm_kcalloc(dev,
2836                                 MAX_OUT_QUEUE, sizeof(*mconfig->m_out_pin),
2837                                 GFP_KERNEL);
2838         if (!mconfig->m_out_pin)
2839                 return -ENOMEM;
2840
2841         skl_fill_module_pin_info_v4(dfw->in_pin, mconfig->m_in_pin,
2842                                     dfw->is_dynamic_in_pin,
2843                                     mconfig->module->max_input_pins);
2844         skl_fill_module_pin_info_v4(dfw->out_pin, mconfig->m_out_pin,
2845                                     dfw->is_dynamic_out_pin,
2846                                     mconfig->module->max_output_pins);
2847
2848         if (mconfig->formats_config.caps_size) {
2849                 mconfig->formats_config.set_params = dfw->caps.set_params;
2850                 mconfig->formats_config.param_id = dfw->caps.param_id;
2851                 mconfig->formats_config.caps =
2852                 devm_kzalloc(dev, mconfig->formats_config.caps_size,
2853                              GFP_KERNEL);
2854                 if (!mconfig->formats_config.caps)
2855                         return -ENOMEM;
2856                 memcpy(mconfig->formats_config.caps, dfw->caps.caps,
2857                        dfw->caps.caps_size);
2858         }
2859
2860         return 0;
2861 }
2862
2863 /*
2864  * Parse the private data for the token and corresponding value.
2865  * The private data can have multiple data blocks. So, a data block
2866  * is preceded by a descriptor for number of blocks and a descriptor
2867  * for the type and size of the suceeding data block.
2868  */
2869 static int skl_tplg_get_pvt_data(struct snd_soc_tplg_dapm_widget *tplg_w,
2870                                 struct skl_dev *skl, struct device *dev,
2871                                 struct skl_module_cfg *mconfig)
2872 {
2873         struct snd_soc_tplg_vendor_array *array;
2874         int num_blocks, block_size, block_type, off = 0;
2875         char *data;
2876         int ret;
2877
2878         /*
2879          * v4 configuration files have a valid UUID at the start of
2880          * the widget's private data.
2881          */
2882         if (uuid_is_valid((char *)tplg_w->priv.data))
2883                 return skl_tplg_get_pvt_data_v4(tplg_w, skl, dev, mconfig);
2884
2885         /* Read the NUM_DATA_BLOCKS descriptor */
2886         array = (struct snd_soc_tplg_vendor_array *)tplg_w->priv.data;
2887         ret = skl_tplg_get_desc_blocks(dev, array);
2888         if (ret < 0)
2889                 return ret;
2890         num_blocks = ret;
2891
2892         off += array->size;
2893         /* Read the BLOCK_TYPE and BLOCK_SIZE descriptor */
2894         while (num_blocks > 0) {
2895                 array = (struct snd_soc_tplg_vendor_array *)
2896                                 (tplg_w->priv.data + off);
2897
2898                 ret = skl_tplg_get_desc_blocks(dev, array);
2899
2900                 if (ret < 0)
2901                         return ret;
2902                 block_type = ret;
2903                 off += array->size;
2904
2905                 array = (struct snd_soc_tplg_vendor_array *)
2906                         (tplg_w->priv.data + off);
2907
2908                 ret = skl_tplg_get_desc_blocks(dev, array);
2909
2910                 if (ret < 0)
2911                         return ret;
2912                 block_size = ret;
2913                 off += array->size;
2914
2915                 array = (struct snd_soc_tplg_vendor_array *)
2916                         (tplg_w->priv.data + off);
2917
2918                 data = (tplg_w->priv.data + off);
2919
2920                 if (block_type == SKL_TYPE_TUPLE) {
2921                         ret = skl_tplg_get_tokens(dev, data,
2922                                         skl, mconfig, block_size);
2923
2924                         if (ret < 0)
2925                                 return ret;
2926
2927                         --num_blocks;
2928                 } else {
2929                         if (mconfig->formats_config.caps_size > 0)
2930                                 memcpy(mconfig->formats_config.caps, data,
2931                                         mconfig->formats_config.caps_size);
2932                         --num_blocks;
2933                         ret = mconfig->formats_config.caps_size;
2934                 }
2935                 off += ret;
2936         }
2937
2938         return 0;
2939 }
2940
2941 static void skl_clear_pin_config(struct snd_soc_component *component,
2942                                 struct snd_soc_dapm_widget *w)
2943 {
2944         int i;
2945         struct skl_module_cfg *mconfig;
2946         struct skl_pipe *pipe;
2947
2948         if (!strncmp(w->dapm->component->name, component->name,
2949                                         strlen(component->name))) {
2950                 mconfig = w->priv;
2951                 pipe = mconfig->pipe;
2952                 for (i = 0; i < mconfig->module->max_input_pins; i++) {
2953                         mconfig->m_in_pin[i].in_use = false;
2954                         mconfig->m_in_pin[i].pin_state = SKL_PIN_UNBIND;
2955                 }
2956                 for (i = 0; i < mconfig->module->max_output_pins; i++) {
2957                         mconfig->m_out_pin[i].in_use = false;
2958                         mconfig->m_out_pin[i].pin_state = SKL_PIN_UNBIND;
2959                 }
2960                 pipe->state = SKL_PIPE_INVALID;
2961                 mconfig->m_state = SKL_MODULE_UNINIT;
2962         }
2963 }
2964
2965 void skl_cleanup_resources(struct skl_dev *skl)
2966 {
2967         struct snd_soc_component *soc_component = skl->component;
2968         struct snd_soc_dapm_widget *w;
2969         struct snd_soc_card *card;
2970
2971         if (soc_component == NULL)
2972                 return;
2973
2974         card = soc_component->card;
2975         if (!card || !card->instantiated)
2976                 return;
2977
2978         list_for_each_entry(w, &card->widgets, list) {
2979                 if (is_skl_dsp_widget_type(w, skl->dev) && w->priv != NULL)
2980                         skl_clear_pin_config(soc_component, w);
2981         }
2982
2983         skl_clear_module_cnt(skl->dsp);
2984 }
2985
2986 /*
2987  * Topology core widget load callback
2988  *
2989  * This is used to save the private data for each widget which gives
2990  * information to the driver about module and pipeline parameters which DSP
2991  * FW expects like ids, resource values, formats etc
2992  */
2993 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt, int index,
2994                                 struct snd_soc_dapm_widget *w,
2995                                 struct snd_soc_tplg_dapm_widget *tplg_w)
2996 {
2997         int ret;
2998         struct hdac_bus *bus = snd_soc_component_get_drvdata(cmpnt);
2999         struct skl_dev *skl = bus_to_skl(bus);
3000         struct skl_module_cfg *mconfig;
3001
3002         if (!tplg_w->priv.size)
3003                 goto bind_event;
3004
3005         mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
3006
3007         if (!mconfig)
3008                 return -ENOMEM;
3009
3010         if (skl->nr_modules == 0) {
3011                 mconfig->module = devm_kzalloc(bus->dev,
3012                                 sizeof(*mconfig->module), GFP_KERNEL);
3013                 if (!mconfig->module)
3014                         return -ENOMEM;
3015         }
3016
3017         w->priv = mconfig;
3018
3019         /*
3020          * module binary can be loaded later, so set it to query when
3021          * module is load for a use case
3022          */
3023         mconfig->id.module_id = -1;
3024
3025         /* Parse private data for tuples */
3026         ret = skl_tplg_get_pvt_data(tplg_w, skl, bus->dev, mconfig);
3027         if (ret < 0)
3028                 return ret;
3029
3030         skl_debug_init_module(skl->debugfs, w, mconfig);
3031
3032 bind_event:
3033         if (tplg_w->event_type == 0) {
3034                 dev_dbg(bus->dev, "ASoC: No event handler required\n");
3035                 return 0;
3036         }
3037
3038         ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
3039                                         ARRAY_SIZE(skl_tplg_widget_ops),
3040                                         tplg_w->event_type);
3041
3042         if (ret) {
3043                 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
3044                                         __func__, tplg_w->event_type);
3045                 return -EINVAL;
3046         }
3047
3048         return 0;
3049 }
3050
3051 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
3052                                         struct snd_soc_tplg_bytes_control *bc)
3053 {
3054         struct skl_algo_data *ac;
3055         struct skl_dfw_algo_data *dfw_ac =
3056                                 (struct skl_dfw_algo_data *)bc->priv.data;
3057
3058         ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
3059         if (!ac)
3060                 return -ENOMEM;
3061
3062         /* Fill private data */
3063         ac->max = dfw_ac->max;
3064         ac->param_id = dfw_ac->param_id;
3065         ac->set_params = dfw_ac->set_params;
3066         ac->size = dfw_ac->max;
3067
3068         if (ac->max) {
3069                 ac->params = devm_kzalloc(dev, ac->max, GFP_KERNEL);
3070                 if (!ac->params)
3071                         return -ENOMEM;
3072
3073                 memcpy(ac->params, dfw_ac->params, ac->max);
3074         }
3075
3076         be->dobj.private  = ac;
3077         return 0;
3078 }
3079
3080 static int skl_init_enum_data(struct device *dev, struct soc_enum *se,
3081                                 struct snd_soc_tplg_enum_control *ec)
3082 {
3083
3084         void *data;
3085
3086         if (ec->priv.size) {
3087                 data = devm_kzalloc(dev, sizeof(ec->priv.size), GFP_KERNEL);
3088                 if (!data)
3089                         return -ENOMEM;
3090                 memcpy(data, ec->priv.data, ec->priv.size);
3091                 se->dobj.private = data;
3092         }
3093
3094         return 0;
3095
3096 }
3097
3098 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
3099                                 int index,
3100                                 struct snd_kcontrol_new *kctl,
3101                                 struct snd_soc_tplg_ctl_hdr *hdr)
3102 {
3103         struct soc_bytes_ext *sb;
3104         struct snd_soc_tplg_bytes_control *tplg_bc;
3105         struct snd_soc_tplg_enum_control *tplg_ec;
3106         struct hdac_bus *bus  = snd_soc_component_get_drvdata(cmpnt);
3107         struct soc_enum *se;
3108
3109         switch (hdr->ops.info) {
3110         case SND_SOC_TPLG_CTL_BYTES:
3111                 tplg_bc = container_of(hdr,
3112                                 struct snd_soc_tplg_bytes_control, hdr);
3113                 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
3114                         sb = (struct soc_bytes_ext *)kctl->private_value;
3115                         if (tplg_bc->priv.size)
3116                                 return skl_init_algo_data(
3117                                                 bus->dev, sb, tplg_bc);
3118                 }
3119                 break;
3120
3121         case SND_SOC_TPLG_CTL_ENUM:
3122                 tplg_ec = container_of(hdr,
3123                                 struct snd_soc_tplg_enum_control, hdr);
3124                 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_READ) {
3125                         se = (struct soc_enum *)kctl->private_value;
3126                         if (tplg_ec->priv.size)
3127                                 skl_init_enum_data(bus->dev, se, tplg_ec);
3128                 }
3129
3130                 /*
3131                  * now that the control initializations are done, remove
3132                  * write permission for the DMIC configuration enums to
3133                  * avoid conflicts between NHLT settings and user interaction
3134                  */
3135
3136                 if (hdr->ops.get == SKL_CONTROL_TYPE_MULTI_IO_SELECT_DMIC)
3137                         kctl->access = SNDRV_CTL_ELEM_ACCESS_READ;
3138
3139                 break;
3140
3141         default:
3142                 dev_dbg(bus->dev, "Control load not supported %d:%d:%d\n",
3143                         hdr->ops.get, hdr->ops.put, hdr->ops.info);
3144                 break;
3145         }
3146
3147         return 0;
3148 }
3149
3150 static int skl_tplg_fill_str_mfest_tkn(struct device *dev,
3151                 struct snd_soc_tplg_vendor_string_elem *str_elem,
3152                 struct skl_dev *skl)
3153 {
3154         int tkn_count = 0;
3155         static int ref_count;
3156
3157         switch (str_elem->token) {
3158         case SKL_TKN_STR_LIB_NAME:
3159                 if (ref_count > skl->lib_count - 1) {
3160                         ref_count = 0;
3161                         return -EINVAL;
3162                 }
3163
3164                 strncpy(skl->lib_info[ref_count].name,
3165                         str_elem->string,
3166                         ARRAY_SIZE(skl->lib_info[ref_count].name));
3167                 ref_count++;
3168                 break;
3169
3170         default:
3171                 dev_err(dev, "Not a string token %d\n", str_elem->token);
3172                 break;
3173         }
3174         tkn_count++;
3175
3176         return tkn_count;
3177 }
3178
3179 static int skl_tplg_get_str_tkn(struct device *dev,
3180                 struct snd_soc_tplg_vendor_array *array,
3181                 struct skl_dev *skl)
3182 {
3183         int tkn_count = 0, ret;
3184         struct snd_soc_tplg_vendor_string_elem *str_elem;
3185
3186         str_elem = (struct snd_soc_tplg_vendor_string_elem *)array->value;
3187         while (tkn_count < array->num_elems) {
3188                 ret = skl_tplg_fill_str_mfest_tkn(dev, str_elem, skl);
3189                 str_elem++;
3190
3191                 if (ret < 0)
3192                         return ret;
3193
3194                 tkn_count = tkn_count + ret;
3195         }
3196
3197         return tkn_count;
3198 }
3199
3200 static int skl_tplg_manifest_fill_fmt(struct device *dev,
3201                 struct skl_module_iface *fmt,
3202                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
3203                 u32 dir, int fmt_idx)
3204 {
3205         struct skl_module_pin_fmt *dst_fmt;
3206         struct skl_module_fmt *mod_fmt;
3207         int ret;
3208
3209         if (!fmt)
3210                 return -EINVAL;
3211
3212         switch (dir) {
3213         case SKL_DIR_IN:
3214                 dst_fmt = &fmt->inputs[fmt_idx];
3215                 break;
3216
3217         case SKL_DIR_OUT:
3218                 dst_fmt = &fmt->outputs[fmt_idx];
3219                 break;
3220
3221         default:
3222                 dev_err(dev, "Invalid direction: %d\n", dir);
3223                 return -EINVAL;
3224         }
3225
3226         mod_fmt = &dst_fmt->fmt;
3227
3228         switch (tkn_elem->token) {
3229         case SKL_TKN_MM_U32_INTF_PIN_ID:
3230                 dst_fmt->id = tkn_elem->value;
3231                 break;
3232
3233         default:
3234                 ret = skl_tplg_fill_fmt(dev, mod_fmt, tkn_elem->token,
3235                                         tkn_elem->value);
3236                 if (ret < 0)
3237                         return ret;
3238                 break;
3239         }
3240
3241         return 0;
3242 }
3243
3244 static int skl_tplg_fill_mod_info(struct device *dev,
3245                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
3246                 struct skl_module *mod)
3247 {
3248
3249         if (!mod)
3250                 return -EINVAL;
3251
3252         switch (tkn_elem->token) {
3253         case SKL_TKN_U8_IN_PIN_TYPE:
3254                 mod->input_pin_type = tkn_elem->value;
3255                 break;
3256
3257         case SKL_TKN_U8_OUT_PIN_TYPE:
3258                 mod->output_pin_type = tkn_elem->value;
3259                 break;
3260
3261         case SKL_TKN_U8_IN_QUEUE_COUNT:
3262                 mod->max_input_pins = tkn_elem->value;
3263                 break;
3264
3265         case SKL_TKN_U8_OUT_QUEUE_COUNT:
3266                 mod->max_output_pins = tkn_elem->value;
3267                 break;
3268
3269         case SKL_TKN_MM_U8_NUM_RES:
3270                 mod->nr_resources = tkn_elem->value;
3271                 break;
3272
3273         case SKL_TKN_MM_U8_NUM_INTF:
3274                 mod->nr_interfaces = tkn_elem->value;
3275                 break;
3276
3277         default:
3278                 dev_err(dev, "Invalid mod info token %d", tkn_elem->token);
3279                 return -EINVAL;
3280         }
3281
3282         return 0;
3283 }
3284
3285
3286 static int skl_tplg_get_int_tkn(struct device *dev,
3287                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
3288                 struct skl_dev *skl)
3289 {
3290         int tkn_count = 0, ret;
3291         static int mod_idx, res_val_idx, intf_val_idx, dir, pin_idx;
3292         struct skl_module_res *res = NULL;
3293         struct skl_module_iface *fmt = NULL;
3294         struct skl_module *mod = NULL;
3295         static struct skl_astate_param *astate_table;
3296         static int astate_cfg_idx, count;
3297         int i;
3298         size_t size;
3299
3300         if (skl->modules) {
3301                 mod = skl->modules[mod_idx];
3302                 res = &mod->resources[res_val_idx];
3303                 fmt = &mod->formats[intf_val_idx];
3304         }
3305
3306         switch (tkn_elem->token) {
3307         case SKL_TKN_U32_LIB_COUNT:
3308                 skl->lib_count = tkn_elem->value;
3309                 break;
3310
3311         case SKL_TKN_U8_NUM_MOD:
3312                 skl->nr_modules = tkn_elem->value;
3313                 skl->modules = devm_kcalloc(dev, skl->nr_modules,
3314                                 sizeof(*skl->modules), GFP_KERNEL);
3315                 if (!skl->modules)
3316                         return -ENOMEM;
3317
3318                 for (i = 0; i < skl->nr_modules; i++) {
3319                         skl->modules[i] = devm_kzalloc(dev,
3320                                         sizeof(struct skl_module), GFP_KERNEL);
3321                         if (!skl->modules[i])
3322                                 return -ENOMEM;
3323                 }
3324                 break;
3325
3326         case SKL_TKN_MM_U8_MOD_IDX:
3327                 mod_idx = tkn_elem->value;
3328                 break;
3329
3330         case SKL_TKN_U32_ASTATE_COUNT:
3331                 if (astate_table != NULL) {
3332                         dev_err(dev, "More than one entry for A-State count");
3333                         return -EINVAL;
3334                 }
3335
3336                 if (tkn_elem->value > SKL_MAX_ASTATE_CFG) {
3337                         dev_err(dev, "Invalid A-State count %d\n",
3338                                 tkn_elem->value);
3339                         return -EINVAL;
3340                 }
3341
3342                 size = struct_size(skl->cfg.astate_cfg, astate_table,
3343                                    tkn_elem->value);
3344                 skl->cfg.astate_cfg = devm_kzalloc(dev, size, GFP_KERNEL);
3345                 if (!skl->cfg.astate_cfg)
3346                         return -ENOMEM;
3347
3348                 astate_table = skl->cfg.astate_cfg->astate_table;
3349                 count = skl->cfg.astate_cfg->count = tkn_elem->value;
3350                 break;
3351
3352         case SKL_TKN_U32_ASTATE_IDX:
3353                 if (tkn_elem->value >= count) {
3354                         dev_err(dev, "Invalid A-State index %d\n",
3355                                 tkn_elem->value);
3356                         return -EINVAL;
3357                 }
3358
3359                 astate_cfg_idx = tkn_elem->value;
3360                 break;
3361
3362         case SKL_TKN_U32_ASTATE_KCPS:
3363                 astate_table[astate_cfg_idx].kcps = tkn_elem->value;
3364                 break;
3365
3366         case SKL_TKN_U32_ASTATE_CLK_SRC:
3367                 astate_table[astate_cfg_idx].clk_src = tkn_elem->value;
3368                 break;
3369
3370         case SKL_TKN_U8_IN_PIN_TYPE:
3371         case SKL_TKN_U8_OUT_PIN_TYPE:
3372         case SKL_TKN_U8_IN_QUEUE_COUNT:
3373         case SKL_TKN_U8_OUT_QUEUE_COUNT:
3374         case SKL_TKN_MM_U8_NUM_RES:
3375         case SKL_TKN_MM_U8_NUM_INTF:
3376                 ret = skl_tplg_fill_mod_info(dev, tkn_elem, mod);
3377                 if (ret < 0)
3378                         return ret;
3379                 break;
3380
3381         case SKL_TKN_U32_DIR_PIN_COUNT:
3382                 dir = tkn_elem->value & SKL_IN_DIR_BIT_MASK;
3383                 pin_idx = (tkn_elem->value & SKL_PIN_COUNT_MASK) >> 4;
3384                 break;
3385
3386         case SKL_TKN_MM_U32_RES_ID:
3387                 if (!res)
3388                         return -EINVAL;
3389
3390                 res->id = tkn_elem->value;
3391                 res_val_idx = tkn_elem->value;
3392                 break;
3393
3394         case SKL_TKN_MM_U32_FMT_ID:
3395                 if (!fmt)
3396                         return -EINVAL;
3397
3398                 fmt->fmt_idx = tkn_elem->value;
3399                 intf_val_idx = tkn_elem->value;
3400                 break;
3401
3402         case SKL_TKN_MM_U32_CPS:
3403         case SKL_TKN_MM_U32_DMA_SIZE:
3404         case SKL_TKN_MM_U32_CPC:
3405         case SKL_TKN_U32_MEM_PAGES:
3406         case SKL_TKN_U32_OBS:
3407         case SKL_TKN_U32_IBS:
3408         case SKL_TKN_MM_U32_RES_PIN_ID:
3409         case SKL_TKN_MM_U32_PIN_BUF:
3410                 ret = skl_tplg_fill_res_tkn(dev, tkn_elem, res, pin_idx, dir);
3411                 if (ret < 0)
3412                         return ret;
3413
3414                 break;
3415
3416         case SKL_TKN_MM_U32_NUM_IN_FMT:
3417                 if (!fmt)
3418                         return -EINVAL;
3419
3420                 res->nr_input_pins = tkn_elem->value;
3421                 break;
3422
3423         case SKL_TKN_MM_U32_NUM_OUT_FMT:
3424                 if (!fmt)
3425                         return -EINVAL;
3426
3427                 res->nr_output_pins = tkn_elem->value;
3428                 break;
3429
3430         case SKL_TKN_U32_FMT_CH:
3431         case SKL_TKN_U32_FMT_FREQ:
3432         case SKL_TKN_U32_FMT_BIT_DEPTH:
3433         case SKL_TKN_U32_FMT_SAMPLE_SIZE:
3434         case SKL_TKN_U32_FMT_CH_CONFIG:
3435         case SKL_TKN_U32_FMT_INTERLEAVE:
3436         case SKL_TKN_U32_FMT_SAMPLE_TYPE:
3437         case SKL_TKN_U32_FMT_CH_MAP:
3438         case SKL_TKN_MM_U32_INTF_PIN_ID:
3439                 ret = skl_tplg_manifest_fill_fmt(dev, fmt, tkn_elem,
3440                                                  dir, pin_idx);
3441                 if (ret < 0)
3442                         return ret;
3443                 break;
3444
3445         default:
3446                 dev_err(dev, "Not a manifest token %d\n", tkn_elem->token);
3447                 return -EINVAL;
3448         }
3449         tkn_count++;
3450
3451         return tkn_count;
3452 }
3453
3454 /*
3455  * Fill the manifest structure by parsing the tokens based on the
3456  * type.
3457  */
3458 static int skl_tplg_get_manifest_tkn(struct device *dev,
3459                 char *pvt_data, struct skl_dev *skl,
3460                 int block_size)
3461 {
3462         int tkn_count = 0, ret;
3463         int off = 0, tuple_size = 0;
3464         u8 uuid_index = 0;
3465         struct snd_soc_tplg_vendor_array *array;
3466         struct snd_soc_tplg_vendor_value_elem *tkn_elem;
3467
3468         if (block_size <= 0)
3469                 return -EINVAL;
3470
3471         while (tuple_size < block_size) {
3472                 array = (struct snd_soc_tplg_vendor_array *)(pvt_data + off);
3473                 off += array->size;
3474                 switch (array->type) {
3475                 case SND_SOC_TPLG_TUPLE_TYPE_STRING:
3476                         ret = skl_tplg_get_str_tkn(dev, array, skl);
3477
3478                         if (ret < 0)
3479                                 return ret;
3480                         tkn_count = ret;
3481
3482                         tuple_size += tkn_count *
3483                                 sizeof(struct snd_soc_tplg_vendor_string_elem);
3484                         continue;
3485
3486                 case SND_SOC_TPLG_TUPLE_TYPE_UUID:
3487                         if (array->uuid->token != SKL_TKN_UUID) {
3488                                 dev_err(dev, "Not an UUID token: %d\n",
3489                                         array->uuid->token);
3490                                 return -EINVAL;
3491                         }
3492                         if (uuid_index >= skl->nr_modules) {
3493                                 dev_err(dev, "Too many UUID tokens\n");
3494                                 return -EINVAL;
3495                         }
3496                         import_guid(&skl->modules[uuid_index++]->uuid,
3497                                     array->uuid->uuid);
3498
3499                         tuple_size += sizeof(*array->uuid);
3500                         continue;
3501
3502                 default:
3503                         tkn_elem = array->value;
3504                         tkn_count = 0;
3505                         break;
3506                 }
3507
3508                 while (tkn_count <= array->num_elems - 1) {
3509                         ret = skl_tplg_get_int_tkn(dev,
3510                                         tkn_elem, skl);
3511                         if (ret < 0)
3512                                 return ret;
3513
3514                         tkn_count = tkn_count + ret;
3515                         tkn_elem++;
3516                 }
3517                 tuple_size += (tkn_count * sizeof(*tkn_elem));
3518                 tkn_count = 0;
3519         }
3520
3521         return off;
3522 }
3523
3524 /*
3525  * Parse manifest private data for tokens. The private data block is
3526  * preceded by descriptors for type and size of data block.
3527  */
3528 static int skl_tplg_get_manifest_data(struct snd_soc_tplg_manifest *manifest,
3529                         struct device *dev, struct skl_dev *skl)
3530 {
3531         struct snd_soc_tplg_vendor_array *array;
3532         int num_blocks, block_size = 0, block_type, off = 0;
3533         char *data;
3534         int ret;
3535
3536         /* Read the NUM_DATA_BLOCKS descriptor */
3537         array = (struct snd_soc_tplg_vendor_array *)manifest->priv.data;
3538         ret = skl_tplg_get_desc_blocks(dev, array);
3539         if (ret < 0)
3540                 return ret;
3541         num_blocks = ret;
3542
3543         off += array->size;
3544         /* Read the BLOCK_TYPE and BLOCK_SIZE descriptor */
3545         while (num_blocks > 0) {
3546                 array = (struct snd_soc_tplg_vendor_array *)
3547                                 (manifest->priv.data + off);
3548                 ret = skl_tplg_get_desc_blocks(dev, array);
3549
3550                 if (ret < 0)
3551                         return ret;
3552                 block_type = ret;
3553                 off += array->size;
3554
3555                 array = (struct snd_soc_tplg_vendor_array *)
3556                         (manifest->priv.data + off);
3557
3558                 ret = skl_tplg_get_desc_blocks(dev, array);
3559
3560                 if (ret < 0)
3561                         return ret;
3562                 block_size = ret;
3563                 off += array->size;
3564
3565                 array = (struct snd_soc_tplg_vendor_array *)
3566                         (manifest->priv.data + off);
3567
3568                 data = (manifest->priv.data + off);
3569
3570                 if (block_type == SKL_TYPE_TUPLE) {
3571                         ret = skl_tplg_get_manifest_tkn(dev, data, skl,
3572                                         block_size);
3573
3574                         if (ret < 0)
3575                                 return ret;
3576
3577                         --num_blocks;
3578                 } else {
3579                         return -EINVAL;
3580                 }
3581                 off += ret;
3582         }
3583
3584         return 0;
3585 }
3586
3587 static int skl_manifest_load(struct snd_soc_component *cmpnt, int index,
3588                                 struct snd_soc_tplg_manifest *manifest)
3589 {
3590         struct hdac_bus *bus = snd_soc_component_get_drvdata(cmpnt);
3591         struct skl_dev *skl = bus_to_skl(bus);
3592
3593         /* proceed only if we have private data defined */
3594         if (manifest->priv.size == 0)
3595                 return 0;
3596
3597         skl_tplg_get_manifest_data(manifest, bus->dev, skl);
3598
3599         if (skl->lib_count > SKL_MAX_LIB) {
3600                 dev_err(bus->dev, "Exceeding max Library count. Got:%d\n",
3601                                         skl->lib_count);
3602                 return  -EINVAL;
3603         }
3604
3605         return 0;
3606 }
3607
3608 static void skl_tplg_complete(struct snd_soc_component *component)
3609 {
3610         struct snd_soc_dobj *dobj;
3611         struct snd_soc_acpi_mach *mach =
3612                 dev_get_platdata(component->card->dev);
3613         int i;
3614
3615         list_for_each_entry(dobj, &component->dobj_list, list) {
3616                 struct snd_kcontrol *kcontrol = dobj->control.kcontrol;
3617                 struct soc_enum *se;
3618                 char **texts;
3619                 char chan_text[4];
3620
3621                 if (dobj->type != SND_SOC_DOBJ_ENUM || !kcontrol ||
3622                     kcontrol->put != skl_tplg_multi_config_set_dmic)
3623                         continue;
3624
3625                 se = (struct soc_enum *)kcontrol->private_value;
3626                 texts = dobj->control.dtexts;
3627                 sprintf(chan_text, "c%d", mach->mach_params.dmic_num);
3628
3629                 for (i = 0; i < se->items; i++) {
3630                         struct snd_ctl_elem_value val = {};
3631
3632                         if (strstr(texts[i], chan_text)) {
3633                                 val.value.enumerated.item[0] = i;
3634                                 kcontrol->put(kcontrol, &val);
3635                         }
3636                 }
3637         }
3638 }
3639
3640 static struct snd_soc_tplg_ops skl_tplg_ops  = {
3641         .widget_load = skl_tplg_widget_load,
3642         .control_load = skl_tplg_control_load,
3643         .bytes_ext_ops = skl_tlv_ops,
3644         .bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
3645         .io_ops = skl_tplg_kcontrol_ops,
3646         .io_ops_count = ARRAY_SIZE(skl_tplg_kcontrol_ops),
3647         .manifest = skl_manifest_load,
3648         .dai_load = skl_dai_load,
3649         .complete = skl_tplg_complete,
3650 };
3651
3652 /*
3653  * A pipe can have multiple modules, each of them will be a DAPM widget as
3654  * well. While managing a pipeline we need to get the list of all the
3655  * widgets in a pipelines, so this helper - skl_tplg_create_pipe_widget_list()
3656  * helps to get the SKL type widgets in that pipeline
3657  */
3658 static int skl_tplg_create_pipe_widget_list(struct snd_soc_component *component)
3659 {
3660         struct snd_soc_dapm_widget *w;
3661         struct skl_module_cfg *mcfg = NULL;
3662         struct skl_pipe_module *p_module = NULL;
3663         struct skl_pipe *pipe;
3664
3665         list_for_each_entry(w, &component->card->widgets, list) {
3666                 if (is_skl_dsp_widget_type(w, component->dev) && w->priv) {
3667                         mcfg = w->priv;
3668                         pipe = mcfg->pipe;
3669
3670                         p_module = devm_kzalloc(component->dev,
3671                                                 sizeof(*p_module), GFP_KERNEL);
3672                         if (!p_module)
3673                                 return -ENOMEM;
3674
3675                         p_module->w = w;
3676                         list_add_tail(&p_module->node, &pipe->w_list);
3677                 }
3678         }
3679
3680         return 0;
3681 }
3682
3683 static void skl_tplg_set_pipe_type(struct skl_dev *skl, struct skl_pipe *pipe)
3684 {
3685         struct skl_pipe_module *w_module;
3686         struct snd_soc_dapm_widget *w;
3687         struct skl_module_cfg *mconfig;
3688         bool host_found = false, link_found = false;
3689
3690         list_for_each_entry(w_module, &pipe->w_list, node) {
3691                 w = w_module->w;
3692                 mconfig = w->priv;
3693
3694                 if (mconfig->dev_type == SKL_DEVICE_HDAHOST)
3695                         host_found = true;
3696                 else if (mconfig->dev_type != SKL_DEVICE_NONE)
3697                         link_found = true;
3698         }
3699
3700         if (host_found && link_found)
3701                 pipe->passthru = true;
3702         else
3703                 pipe->passthru = false;
3704 }
3705
3706 /*
3707  * SKL topology init routine
3708  */
3709 int skl_tplg_init(struct snd_soc_component *component, struct hdac_bus *bus)
3710 {
3711         int ret;
3712         const struct firmware *fw;
3713         struct skl_dev *skl = bus_to_skl(bus);
3714         struct skl_pipeline *ppl;
3715
3716         ret = reject_firmware(&fw, skl->tplg_name, bus->dev);
3717         if (ret < 0) {
3718                 char alt_tplg_name[64];
3719
3720                 snprintf(alt_tplg_name, sizeof(alt_tplg_name), "/*(DEBLOBBED)*/",
3721                          skl->mach->drv_name);
3722                 dev_info(bus->dev, "tplg fw %s load failed with %d, trying alternative tplg name %s",
3723                          skl->tplg_name, ret, alt_tplg_name);
3724
3725                 ret = reject_firmware(&fw, alt_tplg_name, bus->dev);
3726                 if (!ret)
3727                         goto component_load;
3728
3729                 dev_info(bus->dev, "tplg %s failed with %d, falling back to /*(DEBLOBBED)*/",
3730                          alt_tplg_name, ret);
3731
3732                 ret = reject_firmware(&fw, "/*(DEBLOBBED)*/", bus->dev);
3733                 if (ret < 0) {
3734                         dev_err(bus->dev, "Fallback tplg fw %s load failed with %d\n",
3735                                         "/*(DEBLOBBED)*/", ret);
3736                         return ret;
3737                 }
3738         }
3739
3740 component_load:
3741
3742         /*
3743          * The complete tplg for SKL is loaded as index 0, we don't use
3744          * any other index
3745          */
3746         ret = snd_soc_tplg_component_load(component, &skl_tplg_ops, fw, 0);
3747         if (ret < 0) {
3748                 dev_err(bus->dev, "tplg component load failed%d\n", ret);
3749                 goto err;
3750         }
3751
3752         ret = skl_tplg_create_pipe_widget_list(component);
3753         if (ret < 0) {
3754                 dev_err(bus->dev, "tplg create pipe widget list failed%d\n",
3755                                 ret);
3756                 goto err;
3757         }
3758
3759         list_for_each_entry(ppl, &skl->ppl_list, node)
3760                 skl_tplg_set_pipe_type(skl, ppl->pipe);
3761
3762 err:
3763         release_firmware(fw);
3764         return ret;
3765 }
3766
3767 void skl_tplg_exit(struct snd_soc_component *component, struct hdac_bus *bus)
3768 {
3769         struct skl_dev *skl = bus_to_skl(bus);
3770         struct skl_pipeline *ppl, *tmp;
3771
3772         list_for_each_entry_safe(ppl, tmp, &skl->ppl_list, node)
3773                 list_del(&ppl->node);
3774
3775         /* clean up topology */
3776         snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
3777 }