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