ASoC: Intel: Skylake: Parse vendor tokens to build module data

Skl topology data is preceded by a descriptor for number of data
blocks, the size of the data block and type of data block. The
type of the data block can be either a tuple or a binary blob.

Private data is parsed based on data block type and module data
is filled accordingly.

Signed-off-by: Shreyas NC <shreyas.nc@intel.com>
Signed-off-by: Vinod Koul <vinod.koul@intel.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

2 files changed, 545 insertions, 110 deletions

diff --git a/sound/soc/intel/skylake/skl-topology.c b/sound/soc/intel/skylake/skl-topology.c
index 4bc8f9c269db..000482e6e2f7 100644
--- a/sound/soc/intel/skylake/skl-topology.c
+++ b/sound/soc/intel/skylake/skl-topology.c
@@ -21,6 +21,7 @@
 #include <linux/firmware.h>
 #include <sound/soc.h>
 #include <sound/soc-topology.h>
+#include <uapi/sound/snd_sst_tokens.h>
 #include "skl-sst-dsp.h"
 #include "skl-sst-ipc.h"
 #include "skl-topology.h"
@@ -32,6 +33,8 @@
 #define SKL_CH_FIXUP_MASK               (1 << 0)
 #define SKL_RATE_FIXUP_MASK             (1 << 1)
 #define SKL_FMT_FIXUP_MASK              (1 << 2)
+#define SKL_IN_DIR_BIT_MASK             BIT(0)
+#define SKL_PIN_COUNT_MASK              GENMASK(7, 4)
 
 /*
  * SKL DSP driver modelling uses only few DAPM widgets so for rest we will
@@ -1468,85 +1471,570 @@ static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
                                         skl_tplg_tlv_control_set},
 };
 
-/*
- * The topology binary passes the pin info for a module so initialize the pin
- * info passed into module instance
- */
-static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
-                                                struct skl_module_pin *m_pin,
-                                                bool is_dynamic, int max_pin)
+static int skl_tplg_fill_pipe_tkn(struct device *dev,
+                        struct skl_pipe *pipe, u32 tkn,
+                        u32 tkn_val)
 {
-        int i;
 
-        for (i = 0; i < max_pin; i++) {
-                m_pin[i].id.module_id = dfw_pin[i].module_id;
-                m_pin[i].id.instance_id = dfw_pin[i].instance_id;
-                m_pin[i].in_use = false;
-                m_pin[i].is_dynamic = is_dynamic;
-                m_pin[i].pin_state = SKL_PIN_UNBIND;
+        switch (tkn) {
+        case SKL_TKN_U32_PIPE_CONN_TYPE:
+                pipe->conn_type = tkn_val;
+                break;
+
+        case SKL_TKN_U32_PIPE_PRIORITY:
+                pipe->pipe_priority = tkn_val;
+                break;
+
+        case SKL_TKN_U32_PIPE_MEM_PGS:
+                pipe->memory_pages = tkn_val;
+                break;
+
+        default:
+                dev_err(dev, "Token not handled %d\n", tkn);
+                return -EINVAL;
         }
+
+        return 0;
 }
 
 /*
- * Add pipeline from topology binary into driver pipeline list
- *
- * If already added we return that instance
- * Otherwise we create a new instance and add into driver list
+ * Add pipeline by parsing the relevant tokens
+ * Return an existing pipe if the pipe already exists.
  */
-static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
-                        struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
+static int skl_tplg_add_pipe(struct device *dev,
+                struct skl_module_cfg *mconfig, struct skl *skl,
+                struct snd_soc_tplg_vendor_value_elem *tkn_elem)
 {
         struct skl_pipeline *ppl;
         struct skl_pipe *pipe;
         struct skl_pipe_params *params;
 
         list_for_each_entry(ppl, &skl->ppl_list, node) {
-                if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
-                        return ppl->pipe;
+                if (ppl->pipe->ppl_id == tkn_elem->value) {
+                        mconfig->pipe = ppl->pipe;
+                        return EEXIST;
+                }
         }
 
         ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
         if (!ppl)
-                return NULL;
+                return -ENOMEM;
 
         pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
         if (!pipe)
-                return NULL;
+                return -ENOMEM;
 
         params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
         if (!params)
-                return NULL;
+                return -ENOMEM;
 
-        pipe->ppl_id = dfw_pipe->pipe_id;
-        pipe->memory_pages = dfw_pipe->memory_pages;
-        pipe->pipe_priority = dfw_pipe->pipe_priority;
-        pipe->conn_type = dfw_pipe->conn_type;
-        pipe->state = SKL_PIPE_INVALID;
         pipe->p_params = params;
+        pipe->ppl_id = tkn_elem->value;
         INIT_LIST_HEAD(&pipe->w_list);
 
         ppl->pipe = pipe;
         list_add(&ppl->node, &skl->ppl_list);
 
-        return ppl->pipe;
+        mconfig->pipe = pipe;
+        mconfig->pipe->state = SKL_PIPE_INVALID;
+
+        return 0;
+}
+
+static int skl_tplg_fill_pin(struct device *dev, u32 tkn,
+                        struct skl_module_pin *m_pin,
+                        int pin_index, u32 value)
+{
+        switch (tkn) {
+        case SKL_TKN_U32_PIN_MOD_ID:
+                m_pin[pin_index].id.module_id = value;
+                break;
+
+        case SKL_TKN_U32_PIN_INST_ID:
+                m_pin[pin_index].id.instance_id = value;
+                break;
+
+        default:
+                dev_err(dev, "%d Not a pin token\n", value);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/*
+ * Parse for pin config specific tokens to fill up the
+ * module private data
+ */
+static int skl_tplg_fill_pins_info(struct device *dev,
+                struct skl_module_cfg *mconfig,
+                struct snd_soc_tplg_vendor_value_elem *tkn_elem,
+                int dir, int pin_count)
+{
+        int ret;
+        struct skl_module_pin *m_pin;
+
+        switch (dir) {
+        case SKL_DIR_IN:
+                m_pin = mconfig->m_in_pin;
+                break;
+
+        case SKL_DIR_OUT:
+                m_pin = mconfig->m_out_pin;
+                break;
+
+        default:
+                dev_err(dev, "Invalid direction value");
+                return -EINVAL;
+        }
+
+        ret = skl_tplg_fill_pin(dev, tkn_elem->token,
+                        m_pin, pin_count, tkn_elem->value);
+
+        if (ret < 0)
+                return ret;
+
+        m_pin[pin_count].in_use = false;
+        m_pin[pin_count].pin_state = SKL_PIN_UNBIND;
+
+        return 0;
 }
 
-static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
-                                struct skl_dfw_module_fmt *src_fmt,
-                                int pins)
+/*
+ * Fill up input/output module config format based
+ * on the direction
+ */
+static int skl_tplg_fill_fmt(struct device *dev,
+                struct skl_module_cfg *mconfig, u32 tkn,
+                u32 value, u32 dir, u32 pin_count)
+{
+        struct skl_module_fmt *dst_fmt;
+
+        switch (dir) {
+        case SKL_DIR_IN:
+                dst_fmt = mconfig->in_fmt;
+                dst_fmt += pin_count;
+                break;
+
+        case SKL_DIR_OUT:
+                dst_fmt = mconfig->out_fmt;
+                dst_fmt += pin_count;
+                break;
+
+        default:
+                dev_err(dev, "Invalid direction value");
+                return -EINVAL;
+        }
+
+        switch (tkn) {
+        case SKL_TKN_U32_FMT_CH:
+                dst_fmt->channels  = value;
+                break;
+
+        case SKL_TKN_U32_FMT_FREQ:
+                dst_fmt->s_freq = value;
+                break;
+
+        case SKL_TKN_U32_FMT_BIT_DEPTH:
+                dst_fmt->bit_depth = value;
+                break;
+
+        case SKL_TKN_U32_FMT_SAMPLE_SIZE:
+                dst_fmt->valid_bit_depth = value;
+                break;
+
+        case SKL_TKN_U32_FMT_CH_CONFIG:
+                dst_fmt->ch_cfg = value;
+                break;
+
+        case SKL_TKN_U32_FMT_INTERLEAVE:
+                dst_fmt->interleaving_style = value;
+                break;
+
+        case SKL_TKN_U32_FMT_SAMPLE_TYPE:
+                dst_fmt->sample_type = value;
+                break;
+
+        case SKL_TKN_U32_FMT_CH_MAP:
+                dst_fmt->ch_map = value;
+                break;
+
+        default:
+                dev_err(dev, "Invalid token %d", tkn);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int skl_tplg_get_uuid(struct device *dev, struct skl_module_cfg *mconfig,
+              struct snd_soc_tplg_vendor_uuid_elem *uuid_tkn)
+{
+        if (uuid_tkn->token == SKL_TKN_UUID)
+                memcpy(&mconfig->guid, &uuid_tkn->uuid, 16);
+        else {
+                dev_err(dev, "Not an UUID token tkn %d", uuid_tkn->token);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void skl_tplg_fill_pin_dynamic_val(
+                struct skl_module_pin *mpin, u32 pin_count, u32 value)
 {
         int i;
 
-        for (i = 0; i < pins; i++) {
-                dst_fmt[i].channels  = src_fmt[i].channels;
-                dst_fmt[i].s_freq = src_fmt[i].freq;
-                dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
-                dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
-                dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
-                dst_fmt[i].ch_map = src_fmt[i].ch_map;
-                dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
-                dst_fmt[i].sample_type = src_fmt[i].sample_type;
+        for (i = 0; i < pin_count; i++)
+                mpin[i].is_dynamic = value;
+}
+
+/*
+ * Parse tokens to fill up the module private data
+ */
+static int skl_tplg_get_token(struct device *dev,
+                struct snd_soc_tplg_vendor_value_elem *tkn_elem,
+                struct skl *skl, struct skl_module_cfg *mconfig)
+{
+        int tkn_count = 0;
+        int ret;
+        static int is_pipe_exists;
+        static int pin_index, dir;
+
+        if (tkn_elem->token > SKL_TKN_MAX)
+                return -EINVAL;
+
+        switch (tkn_elem->token) {
+        case SKL_TKN_U8_IN_QUEUE_COUNT:
+                mconfig->max_in_queue = tkn_elem->value;
+                mconfig->m_in_pin = devm_kzalloc(dev, mconfig->max_in_queue *
+                                        sizeof(*mconfig->m_in_pin),
+                                        GFP_KERNEL);
+                if (!mconfig->m_in_pin)
+                        return -ENOMEM;
+
+                break;
+
+        case SKL_TKN_U8_OUT_QUEUE_COUNT:
+                mconfig->max_out_queue = tkn_elem->value;
+                mconfig->m_out_pin = devm_kzalloc(dev, mconfig->max_out_queue *
+                                        sizeof(*mconfig->m_out_pin),
+                                        GFP_KERNEL);
+
+                if (!mconfig->m_out_pin)
+                        return -ENOMEM;
+
+                break;
+
+        case SKL_TKN_U8_DYN_IN_PIN:
+                if (!mconfig->m_in_pin)
+                        return -ENOMEM;
+
+                skl_tplg_fill_pin_dynamic_val(mconfig->m_in_pin,
+                        mconfig->max_in_queue, tkn_elem->value);
+
+                break;
+
+        case SKL_TKN_U8_DYN_OUT_PIN:
+                if (!mconfig->m_out_pin)
+                        return -ENOMEM;
+
+                skl_tplg_fill_pin_dynamic_val(mconfig->m_out_pin,
+                        mconfig->max_out_queue, tkn_elem->value);
+
+                break;
+
+        case SKL_TKN_U8_TIME_SLOT:
+                mconfig->time_slot = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U8_CORE_ID:
+                mconfig->core_id = tkn_elem->value;
+
+        case SKL_TKN_U8_MOD_TYPE:
+                mconfig->m_type = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U8_DEV_TYPE:
+                mconfig->dev_type = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U8_HW_CONN_TYPE:
+                mconfig->hw_conn_type = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U16_MOD_INST_ID:
+                mconfig->id.instance_id =
+                tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_MEM_PAGES:
+                mconfig->mem_pages = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_MAX_MCPS:
+                mconfig->mcps = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_OBS:
+                mconfig->obs = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_IBS:
+                mconfig->ibs = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_VBUS_ID:
+                mconfig->vbus_id = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_PARAMS_FIXUP:
+                mconfig->params_fixup = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_CONVERTER:
+                mconfig->converter = tkn_elem->value;
+                break;
+
+        case SKL_TKN_U32_PIPE_ID:
+                ret = skl_tplg_add_pipe(dev,
+                                mconfig, skl, tkn_elem);
+
+                if (ret < 0)
+                        return is_pipe_exists;
+
+                if (ret == EEXIST)
+                        is_pipe_exists = 1;
+
+                break;
+
+        case SKL_TKN_U32_PIPE_CONN_TYPE:
+        case SKL_TKN_U32_PIPE_PRIORITY:
+        case SKL_TKN_U32_PIPE_MEM_PGS:
+                if (is_pipe_exists) {
+                        ret = skl_tplg_fill_pipe_tkn(dev, mconfig->pipe,
+                                        tkn_elem->token, tkn_elem->value);
+                        if (ret < 0)
+                                return ret;
+                }
+
+                break;
+
+        /*
+         * SKL_TKN_U32_DIR_PIN_COUNT token has the value for both
+         * direction and the pin count. The first four bits represent
+         * direction and next four the pin count.
+         */
+        case SKL_TKN_U32_DIR_PIN_COUNT:
+                dir = tkn_elem->value & SKL_IN_DIR_BIT_MASK;
+                pin_index = (tkn_elem->value &
+                        SKL_PIN_COUNT_MASK) >> 4;
+
+                break;
+
+        case SKL_TKN_U32_FMT_CH:
+        case SKL_TKN_U32_FMT_FREQ:
+        case SKL_TKN_U32_FMT_BIT_DEPTH:
+        case SKL_TKN_U32_FMT_SAMPLE_SIZE:
+        case SKL_TKN_U32_FMT_CH_CONFIG:
+        case SKL_TKN_U32_FMT_INTERLEAVE:
+        case SKL_TKN_U32_FMT_SAMPLE_TYPE:
+        case SKL_TKN_U32_FMT_CH_MAP:
+                ret = skl_tplg_fill_fmt(dev, mconfig, tkn_elem->token,
+                                tkn_elem->value, dir, pin_index);
+
+                if (ret < 0)
+                        return ret;
+
+                break;
+
+        case SKL_TKN_U32_PIN_MOD_ID:
+        case SKL_TKN_U32_PIN_INST_ID:
+                ret = skl_tplg_fill_pins_info(dev,
+                                mconfig, tkn_elem, dir,
+                                pin_index);
+                if (ret < 0)
+                        return ret;
+
+                break;
+
+        case SKL_TKN_U32_CAPS_SIZE:
+                mconfig->formats_config.caps_size =
+                        tkn_elem->value;
+
+                break;
+
+        case SKL_TKN_U32_PROC_DOMAIN:
+                mconfig->domain =
+                        tkn_elem->value;
+
+                break;
+
+        case SKL_TKN_U8_IN_PIN_TYPE:
+        case SKL_TKN_U8_OUT_PIN_TYPE:
+        case SKL_TKN_U8_CONN_TYPE:
+                break;
+
+        default:
+                dev_err(dev, "Token %d not handled\n",
+                                tkn_elem->token);
+                return -EINVAL;
         }
+
+        tkn_count++;
+
+        return tkn_count;
+}
+
+/*
+ * Parse the vendor array for specific tokens to construct
+ * module private data
+ */
+static int skl_tplg_get_tokens(struct device *dev,
+                char *pvt_data, struct skl *skl,
+                struct skl_module_cfg *mconfig, int block_size)
+{
+        struct snd_soc_tplg_vendor_array *array;
+        struct snd_soc_tplg_vendor_value_elem *tkn_elem;
+        int tkn_count = 0, ret;
+        int off = 0, tuple_size = 0;
+
+        if (block_size <= 0)
+                return -EINVAL;
+
+        while (tuple_size < block_size) {
+                array = (struct snd_soc_tplg_vendor_array *)(pvt_data + off);
+
+                off += array->size;
+
+                switch (array->type) {
+                case SND_SOC_TPLG_TUPLE_TYPE_STRING:
+                        dev_warn(dev, "no string tokens expected for skl tplg");
+                        continue;
+
+                case SND_SOC_TPLG_TUPLE_TYPE_UUID:
+                        ret = skl_tplg_get_uuid(dev, mconfig, array->uuid);
+                        if (ret < 0)
+                                return ret;
+
+                        tuple_size += sizeof(*array->uuid);
+
+                        continue;
+
+                default:
+                        tkn_elem = array->value;
+                        tkn_count = 0;
+                        break;
+                }
+
+                while (tkn_count <= (array->num_elems - 1)) {
+                        ret = skl_tplg_get_token(dev, tkn_elem,
+                                        skl, mconfig);
+
+                        if (ret < 0)
+                                return ret;
+
+                        tkn_count = tkn_count + ret;
+                        tkn_elem++;
+                }
+
+                tuple_size += tkn_count * sizeof(*tkn_elem);
+        }
+
+        return 0;
+}
+
+/*
+ * Every data block is preceded by a descriptor to read the number
+ * of data blocks, they type of the block and it's size
+ */
+static int skl_tplg_get_desc_blocks(struct device *dev,
+                struct snd_soc_tplg_vendor_array *array)
+{
+        struct snd_soc_tplg_vendor_value_elem *tkn_elem;
+
+        tkn_elem = array->value;
+
+        switch (tkn_elem->token) {
+        case SKL_TKN_U8_NUM_BLOCKS:
+        case SKL_TKN_U8_BLOCK_TYPE:
+        case SKL_TKN_U16_BLOCK_SIZE:
+                return tkn_elem->value;
+
+        default:
+                dev_err(dev, "Invalid descriptor token %d", tkn_elem->token);
+                break;
+        }
+
+        return -EINVAL;
+}
+
+/*
+ * Parse the private data for the token and corresponding value.
+ * The private data can have multiple data blocks. So, a data block
+ * is preceded by a descriptor for number of blocks and a descriptor
+ * for the type and size of the suceeding data block.
+ */
+static int skl_tplg_get_pvt_data(struct snd_soc_tplg_dapm_widget *tplg_w,
+                                struct skl *skl, struct device *dev,
+                                struct skl_module_cfg *mconfig)
+{
+        struct snd_soc_tplg_vendor_array *array;
+        int num_blocks, block_size = 0, block_type, off = 0;
+        char *data;
+        int ret;
+
+        /* Read the NUM_DATA_BLOCKS descriptor */
+        array = (struct snd_soc_tplg_vendor_array *)tplg_w->priv.data;
+        ret = skl_tplg_get_desc_blocks(dev, array);
+        if (ret < 0)
+                return ret;
+        num_blocks = ret;
+
+        off += array->size;
+        array = (struct snd_soc_tplg_vendor_array *)(tplg_w->priv.data + off);
+
+        /* Read the BLOCK_TYPE and BLOCK_SIZE descriptor */
+        while (num_blocks > 0) {
+                ret = skl_tplg_get_desc_blocks(dev, array);
+
+                if (ret < 0)
+                        return ret;
+                block_type = ret;
+                off += array->size;
+
+                array = (struct snd_soc_tplg_vendor_array *)
+                        (tplg_w->priv.data + off);
+
+                ret = skl_tplg_get_desc_blocks(dev, array);
+
+                if (ret < 0)
+                        return ret;
+                block_size = ret;
+                off += array->size;
+
+                array = (struct snd_soc_tplg_vendor_array *)
+                        (tplg_w->priv.data + off);
+
+                data = (tplg_w->priv.data + off);
+
+                if (block_type == SKL_TYPE_TUPLE) {
+                        ret = skl_tplg_get_tokens(dev, data,
+                                        skl, mconfig, block_size);
+
+                        if (ret < 0)
+                                return ret;
+
+                        --num_blocks;
+                } else {
+                        if (mconfig->formats_config.caps_size > 0)
+                                memcpy(mconfig->formats_config.caps, data,
+                                        mconfig->formats_config.caps_size);
+                        --num_blocks;
+                }
+        }
+
+        return 0;
 }
 
 static void skl_clear_pin_config(struct snd_soc_platform *platform,
@@ -1614,9 +2102,6 @@ static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
         struct skl *skl = ebus_to_skl(ebus);
         struct hdac_bus *bus = ebus_to_hbus(ebus);
         struct skl_module_cfg *mconfig;
-        struct skl_pipe *pipe;
-        struct skl_dfw_module *dfw_config =
-                                (struct skl_dfw_module *)tplg_w->priv.data;
 
         if (!tplg_w->priv.size)
                 goto bind_event;
@@ -1627,77 +2112,17 @@ static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
                 return -ENOMEM;
 
         w->priv = mconfig;
-        memcpy(&mconfig->guid, &dfw_config->uuid, 16);
 
         /*
          * module binary can be loaded later, so set it to query when
          * module is load for a use case
          */
         mconfig->id.module_id = -1;
-        mconfig->id.instance_id = dfw_config->instance_id;
-        mconfig->mcps = dfw_config->max_mcps;
-        mconfig->ibs = dfw_config->ibs;
-        mconfig->obs = dfw_config->obs;
-        mconfig->core_id = dfw_config->core_id;
-        mconfig->max_in_queue = dfw_config->max_in_queue;
-        mconfig->max_out_queue = dfw_config->max_out_queue;
-        mconfig->is_loadable = dfw_config->is_loadable;
-        mconfig->domain = dfw_config->proc_domain;
-        skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
-                                                MODULE_MAX_IN_PINS);
-        skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
-                                                MODULE_MAX_OUT_PINS);
-
-        mconfig->params_fixup = dfw_config->params_fixup;
-        mconfig->converter = dfw_config->converter;
-        mconfig->m_type = dfw_config->module_type;
-        mconfig->vbus_id = dfw_config->vbus_id;
-        mconfig->mem_pages = dfw_config->mem_pages;
-
-        pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
-        if (pipe)
-                mconfig->pipe = pipe;
-
-        mconfig->dev_type = dfw_config->dev_type;
-        mconfig->hw_conn_type = dfw_config->hw_conn_type;
-        mconfig->time_slot = dfw_config->time_slot;
-        mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
-
-        mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
-                                                sizeof(*mconfig->m_in_pin),
-                                                GFP_KERNEL);
-        if (!mconfig->m_in_pin)
-                return -ENOMEM;
-
-        mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
-                                                sizeof(*mconfig->m_out_pin),
-                                                GFP_KERNEL);
-        if (!mconfig->m_out_pin)
-                return -ENOMEM;
-
-        skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
-                                                dfw_config->is_dynamic_in_pin,
-                                                mconfig->max_in_queue);
-
-        skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
-                                                 dfw_config->is_dynamic_out_pin,
-                                                        mconfig->max_out_queue);
-
-
-        if (mconfig->formats_config.caps_size == 0)
-                goto bind_event;
-
-        mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
-                        mconfig->formats_config.caps_size, GFP_KERNEL);
-
-        if (mconfig->formats_config.caps == NULL)
-                return -ENOMEM;
-
-        memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
-                                                 dfw_config->caps.caps_size);
-        mconfig->formats_config.param_id = dfw_config->caps.param_id;
-        mconfig->formats_config.set_params = dfw_config->caps.set_params;
 
+        /* Parse private data for tuples */
+        ret = skl_tplg_get_pvt_data(tplg_w, skl, bus->dev, mconfig);
+        if (ret < 0)
+                return ret;
 bind_event:
         if (tplg_w->event_type == 0) {
                 dev_dbg(bus->dev, "ASoC: No event handler required\n");
diff --git a/sound/soc/intel/skylake/skl-tplg-interface.h b/sound/soc/intel/skylake/skl-tplg-interface.h
index bd8b4ae43557..281762eca0ab 100644
--- a/sound/soc/intel/skylake/skl-tplg-interface.h
+++ b/sound/soc/intel/skylake/skl-tplg-interface.h
@@ -241,4 +241,14 @@ struct skl_dfw_manifest {
         struct lib_info lib[HDA_MAX_LIB];
 } __packed;
 
+enum skl_tkn_dir {
+        SKL_DIR_IN,
+        SKL_DIR_OUT
+};
+
+enum skl_tuple_type {
+        SKL_TYPE_TUPLE,
+        SKL_TYPE_DATA
+};
+
 #endif