sound/soc/sof/ipc3-topology.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license.  When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2021 Intel Corporation. All rights reserved.
   7 //
   8 //
   9
  10 #include <uapi/sound/sof/tokens.h>
  11 #include <sound/pcm_params.h>
  12 #include "sof-priv.h"
  13 #include "sof-audio.h"
  14 #include "ipc3-priv.h"
  15 #include "ops.h"
  16
  17 /* Full volume for default values */
  18 #define VOL_ZERO_DB     BIT(VOLUME_FWL)
  19
  20 /* size of tplg ABI in bytes */
  21 #define SOF_IPC3_TPLG_ABI_SIZE 3
  22
  23 struct sof_widget_data {
  24         int ctrl_type;
  25         int ipc_cmd;
  26         void *pdata;
  27         size_t pdata_size;
  28         struct snd_sof_control *control;
  29 };
  30
  31 struct sof_process_types {
  32         const char *name;
  33         enum sof_ipc_process_type type;
  34         enum sof_comp_type comp_type;
  35 };
  36
  37 static const struct sof_process_types sof_process[] = {
  38         {"EQFIR", SOF_PROCESS_EQFIR, SOF_COMP_EQ_FIR},
  39         {"EQIIR", SOF_PROCESS_EQIIR, SOF_COMP_EQ_IIR},
  40         {"KEYWORD_DETECT", SOF_PROCESS_KEYWORD_DETECT, SOF_COMP_KEYWORD_DETECT},
  41         {"KPB", SOF_PROCESS_KPB, SOF_COMP_KPB},
  42         {"CHAN_SELECTOR", SOF_PROCESS_CHAN_SELECTOR, SOF_COMP_SELECTOR},
  43         {"MUX", SOF_PROCESS_MUX, SOF_COMP_MUX},
  44         {"DEMUX", SOF_PROCESS_DEMUX, SOF_COMP_DEMUX},
  45         {"DCBLOCK", SOF_PROCESS_DCBLOCK, SOF_COMP_DCBLOCK},
  46         {"SMART_AMP", SOF_PROCESS_SMART_AMP, SOF_COMP_SMART_AMP},
  47 };
  48
  49 static enum sof_ipc_process_type find_process(const char *name)
  50 {
  51         int i;
  52
  53         for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
  54                 if (strcmp(name, sof_process[i].name) == 0)
  55                         return sof_process[i].type;
  56         }
  57
  58         return SOF_PROCESS_NONE;
  59 }
  60
  61 static int get_token_process_type(void *elem, void *object, u32 offset)
  62 {
  63         u32 *val = (u32 *)((u8 *)object + offset);
  64
  65         *val = find_process((const char *)elem);
  66         return 0;
  67 }
  68
  69 /* Buffers */
  70 static const struct sof_topology_token buffer_tokens[] = {
  71         {SOF_TKN_BUF_SIZE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  72                 offsetof(struct sof_ipc_buffer, size)},
  73         {SOF_TKN_BUF_CAPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  74                 offsetof(struct sof_ipc_buffer, caps)},
  75 };
  76
  77 /* DAI */
  78 static const struct sof_topology_token dai_tokens[] = {
  79         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
  80                 offsetof(struct sof_ipc_comp_dai, type)},
  81         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  82                 offsetof(struct sof_ipc_comp_dai, dai_index)},
  83         {SOF_TKN_DAI_DIRECTION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  84                 offsetof(struct sof_ipc_comp_dai, direction)},
  85 };
  86
  87 /* BE DAI link */
  88 static const struct sof_topology_token dai_link_tokens[] = {
  89         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
  90                 offsetof(struct sof_ipc_dai_config, type)},
  91         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  92                 offsetof(struct sof_ipc_dai_config, dai_index)},
  93 };
  94
  95 /* scheduling */
  96 static const struct sof_topology_token sched_tokens[] = {
  97         {SOF_TKN_SCHED_PERIOD, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  98                 offsetof(struct sof_ipc_pipe_new, period)},
  99         {SOF_TKN_SCHED_PRIORITY, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 100                 offsetof(struct sof_ipc_pipe_new, priority)},
 101         {SOF_TKN_SCHED_MIPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 102                 offsetof(struct sof_ipc_pipe_new, period_mips)},
 103         {SOF_TKN_SCHED_CORE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 104                 offsetof(struct sof_ipc_pipe_new, core)},
 105         {SOF_TKN_SCHED_FRAMES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 106                 offsetof(struct sof_ipc_pipe_new, frames_per_sched)},
 107         {SOF_TKN_SCHED_TIME_DOMAIN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 108                 offsetof(struct sof_ipc_pipe_new, time_domain)},
 109 };
 110
 111 static const struct sof_topology_token pipeline_tokens[] = {
 112         {SOF_TKN_SCHED_DYNAMIC_PIPELINE, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
 113                 offsetof(struct snd_sof_widget, dynamic_pipeline_widget)},
 114
 115 };
 116
 117 /* volume */
 118 static const struct sof_topology_token volume_tokens[] = {
 119         {SOF_TKN_VOLUME_RAMP_STEP_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 120                 offsetof(struct sof_ipc_comp_volume, ramp)},
 121         {SOF_TKN_VOLUME_RAMP_STEP_MS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 122                 offsetof(struct sof_ipc_comp_volume, initial_ramp)},
 123 };
 124
 125 /* SRC */
 126 static const struct sof_topology_token src_tokens[] = {
 127         {SOF_TKN_SRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 128                 offsetof(struct sof_ipc_comp_src, source_rate)},
 129         {SOF_TKN_SRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 130                 offsetof(struct sof_ipc_comp_src, sink_rate)},
 131 };
 132
 133 /* ASRC */
 134 static const struct sof_topology_token asrc_tokens[] = {
 135         {SOF_TKN_ASRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 136                 offsetof(struct sof_ipc_comp_asrc, source_rate)},
 137         {SOF_TKN_ASRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 138                 offsetof(struct sof_ipc_comp_asrc, sink_rate)},
 139         {SOF_TKN_ASRC_ASYNCHRONOUS_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 140                 offsetof(struct sof_ipc_comp_asrc, asynchronous_mode)},
 141         {SOF_TKN_ASRC_OPERATION_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 142                 offsetof(struct sof_ipc_comp_asrc, operation_mode)},
 143 };
 144
 145 /* EFFECT */
 146 static const struct sof_topology_token process_tokens[] = {
 147         {SOF_TKN_PROCESS_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_process_type,
 148                 offsetof(struct sof_ipc_comp_process, type)},
 149 };
 150
 151 /* PCM */
 152 static const struct sof_topology_token pcm_tokens[] = {
 153         {SOF_TKN_PCM_DMAC_CONFIG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 154                 offsetof(struct sof_ipc_comp_host, dmac_config)},
 155 };
 156
 157 /* Generic components */
 158 static const struct sof_topology_token comp_tokens[] = {
 159         {SOF_TKN_COMP_PERIOD_SINK_COUNT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 160                 offsetof(struct sof_ipc_comp_config, periods_sink)},
 161         {SOF_TKN_COMP_PERIOD_SOURCE_COUNT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 162                 offsetof(struct sof_ipc_comp_config, periods_source)},
 163         {SOF_TKN_COMP_FORMAT,
 164                 SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_comp_format,
 165                 offsetof(struct sof_ipc_comp_config, frame_fmt)},
 166 };
 167
 168 /* SSP */
 169 static const struct sof_topology_token ssp_tokens[] = {
 170         {SOF_TKN_INTEL_SSP_CLKS_CONTROL, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 171                 offsetof(struct sof_ipc_dai_ssp_params, clks_control)},
 172         {SOF_TKN_INTEL_SSP_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 173                 offsetof(struct sof_ipc_dai_ssp_params, mclk_id)},
 174         {SOF_TKN_INTEL_SSP_SAMPLE_BITS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 175                 offsetof(struct sof_ipc_dai_ssp_params, sample_valid_bits)},
 176         {SOF_TKN_INTEL_SSP_FRAME_PULSE_WIDTH, SND_SOC_TPLG_TUPLE_TYPE_SHORT,    get_token_u16,
 177                 offsetof(struct sof_ipc_dai_ssp_params, frame_pulse_width)},
 178         {SOF_TKN_INTEL_SSP_QUIRKS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 179                 offsetof(struct sof_ipc_dai_ssp_params, quirks)},
 180         {SOF_TKN_INTEL_SSP_TDM_PADDING_PER_SLOT, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
 181                 offsetof(struct sof_ipc_dai_ssp_params, tdm_per_slot_padding_flag)},
 182         {SOF_TKN_INTEL_SSP_BCLK_DELAY, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 183                 offsetof(struct sof_ipc_dai_ssp_params, bclk_delay)},
 184 };
 185
 186 /* ALH */
 187 static const struct sof_topology_token alh_tokens[] = {
 188         {SOF_TKN_INTEL_ALH_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 189                 offsetof(struct sof_ipc_dai_alh_params, rate)},
 190         {SOF_TKN_INTEL_ALH_CH,  SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 191                 offsetof(struct sof_ipc_dai_alh_params, channels)},
 192 };
 193
 194 /* DMIC */
 195 static const struct sof_topology_token dmic_tokens[] = {
 196         {SOF_TKN_INTEL_DMIC_DRIVER_VERSION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 197                 offsetof(struct sof_ipc_dai_dmic_params, driver_ipc_version)},
 198         {SOF_TKN_INTEL_DMIC_CLK_MIN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 199                 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_min)},
 200         {SOF_TKN_INTEL_DMIC_CLK_MAX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 201                 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_max)},
 202         {SOF_TKN_INTEL_DMIC_SAMPLE_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 203                 offsetof(struct sof_ipc_dai_dmic_params, fifo_fs)},
 204         {SOF_TKN_INTEL_DMIC_DUTY_MIN, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 205                 offsetof(struct sof_ipc_dai_dmic_params, duty_min)},
 206         {SOF_TKN_INTEL_DMIC_DUTY_MAX, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 207                 offsetof(struct sof_ipc_dai_dmic_params, duty_max)},
 208         {SOF_TKN_INTEL_DMIC_NUM_PDM_ACTIVE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 209                 offsetof(struct sof_ipc_dai_dmic_params, num_pdm_active)},
 210         {SOF_TKN_INTEL_DMIC_FIFO_WORD_LENGTH, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 211                 offsetof(struct sof_ipc_dai_dmic_params, fifo_bits)},
 212         {SOF_TKN_INTEL_DMIC_UNMUTE_RAMP_TIME_MS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 213                 offsetof(struct sof_ipc_dai_dmic_params, unmute_ramp_time)},
 214 };
 215
 216 /* ESAI */
 217 static const struct sof_topology_token esai_tokens[] = {
 218         {SOF_TKN_IMX_ESAI_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 219                 offsetof(struct sof_ipc_dai_esai_params, mclk_id)},
 220 };
 221
 222 /* SAI */
 223 static const struct sof_topology_token sai_tokens[] = {
 224         {SOF_TKN_IMX_SAI_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 225                 offsetof(struct sof_ipc_dai_sai_params, mclk_id)},
 226 };
 227
 228 /*
 229  * DMIC PDM Tokens
 230  * SOF_TKN_INTEL_DMIC_PDM_CTRL_ID should be the first token
 231  * as it increments the index while parsing the array of pdm tokens
 232  * and determines the correct offset
 233  */
 234 static const struct sof_topology_token dmic_pdm_tokens[] = {
 235         {SOF_TKN_INTEL_DMIC_PDM_CTRL_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 236                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, id)},
 237         {SOF_TKN_INTEL_DMIC_PDM_MIC_A_Enable, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 238                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_a)},
 239         {SOF_TKN_INTEL_DMIC_PDM_MIC_B_Enable, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 240                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_b)},
 241         {SOF_TKN_INTEL_DMIC_PDM_POLARITY_A, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 242                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_a)},
 243         {SOF_TKN_INTEL_DMIC_PDM_POLARITY_B, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 244                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_b)},
 245         {SOF_TKN_INTEL_DMIC_PDM_CLK_EDGE, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 246                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, clk_edge)},
 247         {SOF_TKN_INTEL_DMIC_PDM_SKEW, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 248                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, skew)},
 249 };
 250
 251 /* HDA */
 252 static const struct sof_topology_token hda_tokens[] = {
 253         {SOF_TKN_INTEL_HDA_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 254                 offsetof(struct sof_ipc_dai_hda_params, rate)},
 255         {SOF_TKN_INTEL_HDA_CH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 256                 offsetof(struct sof_ipc_dai_hda_params, channels)},
 257 };
 258
 259 /* AFE */
 260 static const struct sof_topology_token afe_tokens[] = {
 261         {SOF_TKN_MEDIATEK_AFE_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 262                 offsetof(struct sof_ipc_dai_mtk_afe_params, rate)},
 263         {SOF_TKN_MEDIATEK_AFE_CH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 264                 offsetof(struct sof_ipc_dai_mtk_afe_params, channels)},
 265         {SOF_TKN_MEDIATEK_AFE_FORMAT, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_comp_format,
 266                 offsetof(struct sof_ipc_dai_mtk_afe_params, format)},
 267 };
 268
 269 /* ACPDMIC */
 270 static const struct sof_topology_token acpdmic_tokens[] = {
 271         {SOF_TKN_AMD_ACPDMIC_RATE,
 272                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 273                 offsetof(struct sof_ipc_dai_acpdmic_params, pdm_rate)},
 274         {SOF_TKN_AMD_ACPDMIC_CH,
 275                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 276                 offsetof(struct sof_ipc_dai_acpdmic_params, pdm_ch)},
 277 };
 278
 279 /* Core tokens */
 280 static const struct sof_topology_token core_tokens[] = {
 281         {SOF_TKN_COMP_CORE_ID, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 282                 offsetof(struct sof_ipc_comp, core)},
 283 };
 284
 285 /* Component extended tokens */
 286 static const struct sof_topology_token comp_ext_tokens[] = {
 287         {SOF_TKN_COMP_UUID, SND_SOC_TPLG_TUPLE_TYPE_UUID, get_token_uuid,
 288                 offsetof(struct snd_sof_widget, uuid)},
 289 };
 290
 291 static const struct sof_token_info ipc3_token_list[SOF_TOKEN_COUNT] = {
 292         [SOF_PCM_TOKENS] = {"PCM tokens", pcm_tokens, ARRAY_SIZE(pcm_tokens)},
 293         [SOF_PIPELINE_TOKENS] = {"Pipeline tokens", pipeline_tokens, ARRAY_SIZE(pipeline_tokens)},
 294         [SOF_SCHED_TOKENS] = {"Scheduler tokens", sched_tokens, ARRAY_SIZE(sched_tokens)},
 295         [SOF_COMP_TOKENS] = {"Comp tokens", comp_tokens, ARRAY_SIZE(comp_tokens)},
 296         [SOF_CORE_TOKENS] = {"Core tokens", core_tokens, ARRAY_SIZE(core_tokens)},
 297         [SOF_COMP_EXT_TOKENS] = {"AFE tokens", comp_ext_tokens, ARRAY_SIZE(comp_ext_tokens)},
 298         [SOF_BUFFER_TOKENS] = {"Buffer tokens", buffer_tokens, ARRAY_SIZE(buffer_tokens)},
 299         [SOF_VOLUME_TOKENS] = {"Volume tokens", volume_tokens, ARRAY_SIZE(volume_tokens)},
 300         [SOF_SRC_TOKENS] = {"SRC tokens", src_tokens, ARRAY_SIZE(src_tokens)},
 301         [SOF_ASRC_TOKENS] = {"ASRC tokens", asrc_tokens, ARRAY_SIZE(asrc_tokens)},
 302         [SOF_PROCESS_TOKENS] = {"Process tokens", process_tokens, ARRAY_SIZE(process_tokens)},
 303         [SOF_DAI_TOKENS] = {"DAI tokens", dai_tokens, ARRAY_SIZE(dai_tokens)},
 304         [SOF_DAI_LINK_TOKENS] = {"DAI link tokens", dai_link_tokens, ARRAY_SIZE(dai_link_tokens)},
 305         [SOF_HDA_TOKENS] = {"HDA tokens", hda_tokens, ARRAY_SIZE(hda_tokens)},
 306         [SOF_SSP_TOKENS] = {"SSP tokens", ssp_tokens, ARRAY_SIZE(ssp_tokens)},
 307         [SOF_ALH_TOKENS] = {"ALH tokens", alh_tokens, ARRAY_SIZE(alh_tokens)},
 308         [SOF_DMIC_TOKENS] = {"DMIC tokens", dmic_tokens, ARRAY_SIZE(dmic_tokens)},
 309         [SOF_DMIC_PDM_TOKENS] = {"DMIC PDM tokens", dmic_pdm_tokens, ARRAY_SIZE(dmic_pdm_tokens)},
 310         [SOF_ESAI_TOKENS] = {"ESAI tokens", esai_tokens, ARRAY_SIZE(esai_tokens)},
 311         [SOF_SAI_TOKENS] = {"SAI tokens", sai_tokens, ARRAY_SIZE(sai_tokens)},
 312         [SOF_AFE_TOKENS] = {"AFE tokens", afe_tokens, ARRAY_SIZE(afe_tokens)},
 313         [SOF_ACPDMIC_TOKENS] = {"ACPDMIC tokens", acpdmic_tokens, ARRAY_SIZE(acpdmic_tokens)},
 314 };
 315
 316 /**
 317  * sof_comp_alloc - allocate and initialize buffer for a new component
 318  * @swidget: pointer to struct snd_sof_widget containing extended data
 319  * @ipc_size: IPC payload size that will be updated depending on valid
 320  *  extended data.
 321  * @index: ID of the pipeline the component belongs to
 322  *
 323  * Return: The pointer to the new allocated component, NULL if failed.
 324  */
 325 static void *sof_comp_alloc(struct snd_sof_widget *swidget, size_t *ipc_size,
 326                             int index)
 327 {
 328         struct sof_ipc_comp *comp;
 329         size_t total_size = *ipc_size;
 330         size_t ext_size = sizeof(swidget->uuid);
 331
 332         /* only non-zero UUID is valid */
 333         if (!guid_is_null(&swidget->uuid))
 334                 total_size += ext_size;
 335
 336         comp = kzalloc(total_size, GFP_KERNEL);
 337         if (!comp)
 338                 return NULL;
 339
 340         /* configure comp new IPC message */
 341         comp->hdr.size = total_size;
 342         comp->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
 343         comp->id = swidget->comp_id;
 344         comp->pipeline_id = index;
 345         comp->core = swidget->core;
 346
 347         /* handle the extended data if needed */
 348         if (total_size > *ipc_size) {
 349                 /* append extended data to the end of the component */
 350                 memcpy((u8 *)comp + *ipc_size, &swidget->uuid, ext_size);
 351                 comp->ext_data_length = ext_size;
 352         }
 353
 354         /* update ipc_size and return */
 355         *ipc_size = total_size;
 356         return comp;
 357 }
 358
 359 static void sof_dbg_comp_config(struct snd_soc_component *scomp, struct sof_ipc_comp_config *config)
 360 {
 361         dev_dbg(scomp->dev, " config: periods snk %d src %d fmt %d\n",
 362                 config->periods_sink, config->periods_source,
 363                 config->frame_fmt);
 364 }
 365
 366 static int sof_ipc3_widget_setup_comp_host(struct snd_sof_widget *swidget)
 367 {
 368         struct snd_soc_component *scomp = swidget->scomp;
 369         struct sof_ipc_comp_host *host;
 370         size_t ipc_size = sizeof(*host);
 371         int ret;
 372
 373         host = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 374         if (!host)
 375                 return -ENOMEM;
 376         swidget->private = host;
 377
 378         /* configure host comp IPC message */
 379         host->comp.type = SOF_COMP_HOST;
 380         host->config.hdr.size = sizeof(host->config);
 381
 382         if (swidget->id == snd_soc_dapm_aif_out)
 383                 host->direction = SOF_IPC_STREAM_CAPTURE;
 384         else
 385                 host->direction = SOF_IPC_STREAM_PLAYBACK;
 386
 387         /* parse one set of pcm_tokens */
 388         ret = sof_update_ipc_object(scomp, host, SOF_PCM_TOKENS, swidget->tuples,
 389                                     swidget->num_tuples, sizeof(*host), 1);
 390         if (ret < 0)
 391                 goto err;
 392
 393         /* parse one set of comp_tokens */
 394         ret = sof_update_ipc_object(scomp, &host->config, SOF_COMP_TOKENS, swidget->tuples,
 395                                     swidget->num_tuples, sizeof(host->config), 1);
 396         if (ret < 0)
 397                 goto err;
 398
 399         dev_dbg(scomp->dev, "loaded host %s\n", swidget->widget->name);
 400         sof_dbg_comp_config(scomp, &host->config);
 401
 402         return 0;
 403 err:
 404         kfree(swidget->private);
 405         swidget->private = NULL;
 406
 407         return ret;
 408 }
 409
 410 static void sof_ipc3_widget_free_comp(struct snd_sof_widget *swidget)
 411 {
 412         kfree(swidget->private);
 413 }
 414
 415 static int sof_ipc3_widget_setup_comp_tone(struct snd_sof_widget *swidget)
 416 {
 417         struct snd_soc_component *scomp = swidget->scomp;
 418         struct sof_ipc_comp_tone *tone;
 419         size_t ipc_size = sizeof(*tone);
 420         int ret;
 421
 422         tone = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 423         if (!tone)
 424                 return -ENOMEM;
 425
 426         swidget->private = tone;
 427
 428         /* configure siggen IPC message */
 429         tone->comp.type = SOF_COMP_TONE;
 430         tone->config.hdr.size = sizeof(tone->config);
 431
 432         /* parse one set of comp tokens */
 433         ret = sof_update_ipc_object(scomp, &tone->config, SOF_COMP_TOKENS, swidget->tuples,
 434                                     swidget->num_tuples, sizeof(tone->config), 1);
 435         if (ret < 0) {
 436                 kfree(swidget->private);
 437                 swidget->private = NULL;
 438                 return ret;
 439         }
 440
 441         dev_dbg(scomp->dev, "tone %s: frequency %d amplitude %d\n",
 442                 swidget->widget->name, tone->frequency, tone->amplitude);
 443         sof_dbg_comp_config(scomp, &tone->config);
 444
 445         return 0;
 446 }
 447
 448 static int sof_ipc3_widget_setup_comp_mixer(struct snd_sof_widget *swidget)
 449 {
 450         struct snd_soc_component *scomp = swidget->scomp;
 451         struct sof_ipc_comp_mixer *mixer;
 452         size_t ipc_size = sizeof(*mixer);
 453         int ret;
 454
 455         mixer = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 456         if (!mixer)
 457                 return -ENOMEM;
 458
 459         swidget->private = mixer;
 460
 461         /* configure mixer IPC message */
 462         mixer->comp.type = SOF_COMP_MIXER;
 463         mixer->config.hdr.size = sizeof(mixer->config);
 464
 465         /* parse one set of comp tokens */
 466         ret = sof_update_ipc_object(scomp, &mixer->config, SOF_COMP_TOKENS,
 467                                     swidget->tuples, swidget->num_tuples,
 468                                     sizeof(mixer->config), 1);
 469         if (ret < 0) {
 470                 kfree(swidget->private);
 471                 swidget->private = NULL;
 472
 473                 return ret;
 474         }
 475
 476         dev_dbg(scomp->dev, "loaded mixer %s\n", swidget->widget->name);
 477         sof_dbg_comp_config(scomp, &mixer->config);
 478
 479         return 0;
 480 }
 481
 482 static int sof_ipc3_widget_setup_comp_pipeline(struct snd_sof_widget *swidget)
 483 {
 484         struct snd_soc_component *scomp = swidget->scomp;
 485         struct sof_ipc_pipe_new *pipeline;
 486         struct snd_sof_widget *comp_swidget;
 487         int ret;
 488
 489         pipeline = kzalloc(sizeof(*pipeline), GFP_KERNEL);
 490         if (!pipeline)
 491                 return -ENOMEM;
 492
 493         /* configure pipeline IPC message */
 494         pipeline->hdr.size = sizeof(*pipeline);
 495         pipeline->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_NEW;
 496         pipeline->pipeline_id = swidget->pipeline_id;
 497         pipeline->comp_id = swidget->comp_id;
 498
 499         swidget->private = pipeline;
 500
 501         /* component at start of pipeline is our stream id */
 502         comp_swidget = snd_sof_find_swidget(scomp, swidget->widget->sname);
 503         if (!comp_swidget) {
 504                 dev_err(scomp->dev, "scheduler %s refers to non existent widget %s\n",
 505                         swidget->widget->name, swidget->widget->sname);
 506                 ret = -EINVAL;
 507                 goto err;
 508         }
 509
 510         pipeline->sched_id = comp_swidget->comp_id;
 511
 512         /* parse one set of scheduler tokens */
 513         ret = sof_update_ipc_object(scomp, pipeline, SOF_SCHED_TOKENS, swidget->tuples,
 514                                     swidget->num_tuples, sizeof(*pipeline), 1);
 515         if (ret < 0)
 516                 goto err;
 517
 518         /* parse one set of pipeline tokens */
 519         ret = sof_update_ipc_object(scomp, swidget, SOF_PIPELINE_TOKENS, swidget->tuples,
 520                                     swidget->num_tuples, sizeof(*swidget), 1);
 521         if (ret < 0)
 522                 goto err;
 523
 524         if (sof_debug_check_flag(SOF_DBG_DISABLE_MULTICORE))
 525                 pipeline->core = SOF_DSP_PRIMARY_CORE;
 526
 527         if (sof_debug_check_flag(SOF_DBG_DYNAMIC_PIPELINES_OVERRIDE))
 528                 swidget->dynamic_pipeline_widget =
 529                         sof_debug_check_flag(SOF_DBG_DYNAMIC_PIPELINES_ENABLE);
 530
 531         dev_dbg(scomp->dev, "pipeline %s: period %d pri %d mips %d core %d frames %d dynamic %d\n",
 532                 swidget->widget->name, pipeline->period, pipeline->priority,
 533                 pipeline->period_mips, pipeline->core, pipeline->frames_per_sched,
 534                 swidget->dynamic_pipeline_widget);
 535
 536         swidget->core = pipeline->core;
 537
 538         return 0;
 539
 540 err:
 541         kfree(swidget->private);
 542         swidget->private = NULL;
 543
 544         return ret;
 545 }
 546
 547 static int sof_ipc3_widget_setup_comp_buffer(struct snd_sof_widget *swidget)
 548 {
 549         struct snd_soc_component *scomp = swidget->scomp;
 550         struct sof_ipc_buffer *buffer;
 551         int ret;
 552
 553         buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
 554         if (!buffer)
 555                 return -ENOMEM;
 556
 557         swidget->private = buffer;
 558
 559         /* configure dai IPC message */
 560         buffer->comp.hdr.size = sizeof(*buffer);
 561         buffer->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_BUFFER_NEW;
 562         buffer->comp.id = swidget->comp_id;
 563         buffer->comp.type = SOF_COMP_BUFFER;
 564         buffer->comp.pipeline_id = swidget->pipeline_id;
 565         buffer->comp.core = swidget->core;
 566
 567         /* parse one set of buffer tokens */
 568         ret = sof_update_ipc_object(scomp, buffer, SOF_BUFFER_TOKENS, swidget->tuples,
 569                                     swidget->num_tuples, sizeof(*buffer), 1);
 570         if (ret < 0) {
 571                 kfree(swidget->private);
 572                 swidget->private = NULL;
 573                 return ret;
 574         }
 575
 576         dev_dbg(scomp->dev, "buffer %s: size %d caps 0x%x\n",
 577                 swidget->widget->name, buffer->size, buffer->caps);
 578
 579         return 0;
 580 }
 581
 582 static int sof_ipc3_widget_setup_comp_src(struct snd_sof_widget *swidget)
 583 {
 584         struct snd_soc_component *scomp = swidget->scomp;
 585         struct sof_ipc_comp_src *src;
 586         size_t ipc_size = sizeof(*src);
 587         int ret;
 588
 589         src = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 590         if (!src)
 591                 return -ENOMEM;
 592
 593         swidget->private = src;
 594
 595         /* configure src IPC message */
 596         src->comp.type = SOF_COMP_SRC;
 597         src->config.hdr.size = sizeof(src->config);
 598
 599         /* parse one set of src tokens */
 600         ret = sof_update_ipc_object(scomp, src, SOF_SRC_TOKENS, swidget->tuples,
 601                                     swidget->num_tuples, sizeof(*src), 1);
 602         if (ret < 0)
 603                 goto err;
 604
 605         /* parse one set of comp tokens */
 606         ret = sof_update_ipc_object(scomp, &src->config, SOF_COMP_TOKENS,
 607                                     swidget->tuples, swidget->num_tuples, sizeof(src->config), 1);
 608         if (ret < 0)
 609                 goto err;
 610
 611         dev_dbg(scomp->dev, "src %s: source rate %d sink rate %d\n",
 612                 swidget->widget->name, src->source_rate, src->sink_rate);
 613         sof_dbg_comp_config(scomp, &src->config);
 614
 615         return 0;
 616 err:
 617         kfree(swidget->private);
 618         swidget->private = NULL;
 619
 620         return ret;
 621 }
 622
 623 static int sof_ipc3_widget_setup_comp_asrc(struct snd_sof_widget *swidget)
 624 {
 625         struct snd_soc_component *scomp = swidget->scomp;
 626         struct sof_ipc_comp_asrc *asrc;
 627         size_t ipc_size = sizeof(*asrc);
 628         int ret;
 629
 630         asrc = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 631         if (!asrc)
 632                 return -ENOMEM;
 633
 634         swidget->private = asrc;
 635
 636         /* configure ASRC IPC message */
 637         asrc->comp.type = SOF_COMP_ASRC;
 638         asrc->config.hdr.size = sizeof(asrc->config);
 639
 640         /* parse one set of asrc tokens */
 641         ret = sof_update_ipc_object(scomp, asrc, SOF_ASRC_TOKENS, swidget->tuples,
 642                                     swidget->num_tuples, sizeof(*asrc), 1);
 643         if (ret < 0)
 644                 goto err;
 645
 646         /* parse one set of comp tokens */
 647         ret = sof_update_ipc_object(scomp, &asrc->config, SOF_COMP_TOKENS,
 648                                     swidget->tuples, swidget->num_tuples, sizeof(asrc->config), 1);
 649         if (ret < 0)
 650                 goto err;
 651
 652         dev_dbg(scomp->dev, "asrc %s: source rate %d sink rate %d asynch %d operation %d\n",
 653                 swidget->widget->name, asrc->source_rate, asrc->sink_rate,
 654                 asrc->asynchronous_mode, asrc->operation_mode);
 655
 656         sof_dbg_comp_config(scomp, &asrc->config);
 657
 658         return 0;
 659 err:
 660         kfree(swidget->private);
 661         swidget->private = NULL;
 662
 663         return ret;
 664 }
 665
 666 /*
 667  * Mux topology
 668  */
 669 static int sof_ipc3_widget_setup_comp_mux(struct snd_sof_widget *swidget)
 670 {
 671         struct snd_soc_component *scomp = swidget->scomp;
 672         struct sof_ipc_comp_mux *mux;
 673         size_t ipc_size = sizeof(*mux);
 674         int ret;
 675
 676         mux = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 677         if (!mux)
 678                 return -ENOMEM;
 679
 680         swidget->private = mux;
 681
 682         /* configure mux IPC message */
 683         mux->comp.type = SOF_COMP_MUX;
 684         mux->config.hdr.size = sizeof(mux->config);
 685
 686         /* parse one set of comp tokens */
 687         ret = sof_update_ipc_object(scomp, &mux->config, SOF_COMP_TOKENS,
 688                                     swidget->tuples, swidget->num_tuples, sizeof(mux->config), 1);
 689         if (ret < 0) {
 690                 kfree(swidget->private);
 691                 swidget->private = NULL;
 692                 return ret;
 693         }
 694
 695         dev_dbg(scomp->dev, "loaded mux %s\n", swidget->widget->name);
 696         sof_dbg_comp_config(scomp, &mux->config);
 697
 698         return 0;
 699 }
 700
 701 /*
 702  * PGA Topology
 703  */
 704
 705 static int sof_ipc3_widget_setup_comp_pga(struct snd_sof_widget *swidget)
 706 {
 707         struct snd_soc_component *scomp = swidget->scomp;
 708         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 709         struct sof_ipc_comp_volume *volume;
 710         struct snd_sof_control *scontrol;
 711         size_t ipc_size = sizeof(*volume);
 712         int min_step, max_step;
 713         int ret;
 714
 715         volume = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 716         if (!volume)
 717                 return -ENOMEM;
 718
 719         swidget->private = volume;
 720
 721         /* configure volume IPC message */
 722         volume->comp.type = SOF_COMP_VOLUME;
 723         volume->config.hdr.size = sizeof(volume->config);
 724
 725         /* parse one set of volume tokens */
 726         ret = sof_update_ipc_object(scomp, volume, SOF_VOLUME_TOKENS, swidget->tuples,
 727                                     swidget->num_tuples, sizeof(*volume), 1);
 728         if (ret < 0)
 729                 goto err;
 730
 731         /* parse one set of comp tokens */
 732         ret = sof_update_ipc_object(scomp, &volume->config, SOF_COMP_TOKENS,
 733                                     swidget->tuples, swidget->num_tuples,
 734                                     sizeof(volume->config), 1);
 735         if (ret < 0)
 736                 goto err;
 737
 738         dev_dbg(scomp->dev, "loaded PGA %s\n", swidget->widget->name);
 739         sof_dbg_comp_config(scomp, &volume->config);
 740
 741         list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
 742                 if (scontrol->comp_id == swidget->comp_id &&
 743                     scontrol->volume_table) {
 744                         min_step = scontrol->min_volume_step;
 745                         max_step = scontrol->max_volume_step;
 746                         volume->min_value = scontrol->volume_table[min_step];
 747                         volume->max_value = scontrol->volume_table[max_step];
 748                         volume->channels = scontrol->num_channels;
 749                         break;
 750                 }
 751         }
 752
 753         return 0;
 754 err:
 755         kfree(swidget->private);
 756         swidget->private = NULL;
 757
 758         return ret;
 759 }
 760
 761 static int sof_get_control_data(struct snd_soc_component *scomp,
 762                                 struct snd_soc_dapm_widget *widget,
 763                                 struct sof_widget_data *wdata, size_t *size)
 764 {
 765         const struct snd_kcontrol_new *kc;
 766         struct sof_ipc_ctrl_data *cdata;
 767         struct soc_mixer_control *sm;
 768         struct soc_bytes_ext *sbe;
 769         struct soc_enum *se;
 770         int i;
 771
 772         *size = 0;
 773
 774         for (i = 0; i < widget->num_kcontrols; i++) {
 775                 kc = &widget->kcontrol_news[i];
 776
 777                 switch (widget->dobj.widget.kcontrol_type[i]) {
 778                 case SND_SOC_TPLG_TYPE_MIXER:
 779                         sm = (struct soc_mixer_control *)kc->private_value;
 780                         wdata[i].control = sm->dobj.private;
 781                         break;
 782                 case SND_SOC_TPLG_TYPE_BYTES:
 783                         sbe = (struct soc_bytes_ext *)kc->private_value;
 784                         wdata[i].control = sbe->dobj.private;
 785                         break;
 786                 case SND_SOC_TPLG_TYPE_ENUM:
 787                         se = (struct soc_enum *)kc->private_value;
 788                         wdata[i].control = se->dobj.private;
 789                         break;
 790                 default:
 791                         dev_err(scomp->dev, "Unknown kcontrol type %u in widget %s\n",
 792                                 widget->dobj.widget.kcontrol_type[i], widget->name);
 793                         return -EINVAL;
 794                 }
 795
 796                 if (!wdata[i].control) {
 797                         dev_err(scomp->dev, "No scontrol for widget %s\n", widget->name);
 798                         return -EINVAL;
 799                 }
 800
 801                 cdata = wdata[i].control->ipc_control_data;
 802
 803                 if (widget->dobj.widget.kcontrol_type[i] == SND_SOC_TPLG_TYPE_BYTES) {
 804                         /* make sure data is valid - data can be updated at runtime */
 805                         if (cdata->data->magic != SOF_ABI_MAGIC)
 806                                 return -EINVAL;
 807
 808                         wdata[i].pdata = cdata->data->data;
 809                         wdata[i].pdata_size = cdata->data->size;
 810                 } else {
 811                         /* points to the control data union */
 812                         wdata[i].pdata = cdata->chanv;
 813                         /*
 814                          * wdata[i].control->size is calculated with struct_size
 815                          * and includes the size of struct sof_ipc_ctrl_data
 816                          */
 817                         wdata[i].pdata_size = wdata[i].control->size -
 818                                               sizeof(struct sof_ipc_ctrl_data);
 819                 }
 820
 821                 *size += wdata[i].pdata_size;
 822
 823                 /* get data type */
 824                 switch (cdata->cmd) {
 825                 case SOF_CTRL_CMD_VOLUME:
 826                 case SOF_CTRL_CMD_ENUM:
 827                 case SOF_CTRL_CMD_SWITCH:
 828                         wdata[i].ipc_cmd = SOF_IPC_COMP_SET_VALUE;
 829                         wdata[i].ctrl_type = SOF_CTRL_TYPE_VALUE_CHAN_SET;
 830                         break;
 831                 case SOF_CTRL_CMD_BINARY:
 832                         wdata[i].ipc_cmd = SOF_IPC_COMP_SET_DATA;
 833                         wdata[i].ctrl_type = SOF_CTRL_TYPE_DATA_SET;
 834                         break;
 835                 default:
 836                         break;
 837                 }
 838         }
 839
 840         return 0;
 841 }
 842
 843 static int sof_process_load(struct snd_soc_component *scomp,
 844                             struct snd_sof_widget *swidget, int type)
 845 {
 846         struct snd_soc_dapm_widget *widget = swidget->widget;
 847         struct sof_ipc_comp_process *process;
 848         struct sof_widget_data *wdata = NULL;
 849         size_t ipc_data_size = 0;
 850         size_t ipc_size;
 851         int offset = 0;
 852         int ret;
 853         int i;
 854
 855         /* allocate struct for widget control data sizes and types */
 856         if (widget->num_kcontrols) {
 857                 wdata = kcalloc(widget->num_kcontrols, sizeof(*wdata), GFP_KERNEL);
 858                 if (!wdata)
 859                         return -ENOMEM;
 860
 861                 /* get possible component controls and get size of all pdata */
 862                 ret = sof_get_control_data(scomp, widget, wdata, &ipc_data_size);
 863                 if (ret < 0)
 864                         goto out;
 865         }
 866
 867         ipc_size = sizeof(struct sof_ipc_comp_process) + ipc_data_size;
 868
 869         /* we are exceeding max ipc size, config needs to be sent separately */
 870         if (ipc_size > SOF_IPC_MSG_MAX_SIZE) {
 871                 ipc_size -= ipc_data_size;
 872                 ipc_data_size = 0;
 873         }
 874
 875         process = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
 876         if (!process) {
 877                 ret = -ENOMEM;
 878                 goto out;
 879         }
 880
 881         swidget->private = process;
 882
 883         /* configure iir IPC message */
 884         process->comp.type = type;
 885         process->config.hdr.size = sizeof(process->config);
 886
 887         /* parse one set of comp tokens */
 888         ret = sof_update_ipc_object(scomp, &process->config, SOF_COMP_TOKENS,
 889                                     swidget->tuples, swidget->num_tuples,
 890                                     sizeof(process->config), 1);
 891         if (ret < 0)
 892                 goto err;
 893
 894         dev_dbg(scomp->dev, "loaded process %s\n", swidget->widget->name);
 895         sof_dbg_comp_config(scomp, &process->config);
 896
 897         /*
 898          * found private data in control, so copy it.
 899          * get possible component controls - get size of all pdata,
 900          * then memcpy with headers
 901          */
 902         if (ipc_data_size) {
 903                 for (i = 0; i < widget->num_kcontrols; i++) {
 904                         if (!wdata[i].pdata_size)
 905                                 continue;
 906
 907                         memcpy(&process->data[offset], wdata[i].pdata,
 908                                wdata[i].pdata_size);
 909                         offset += wdata[i].pdata_size;
 910                 }
 911         }
 912
 913         process->size = ipc_data_size;
 914
 915         kfree(wdata);
 916
 917         return 0;
 918 err:
 919         kfree(swidget->private);
 920         swidget->private = NULL;
 921 out:
 922         kfree(wdata);
 923         return ret;
 924 }
 925
 926 static enum sof_comp_type find_process_comp_type(enum sof_ipc_process_type type)
 927 {
 928         int i;
 929
 930         for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
 931                 if (sof_process[i].type == type)
 932                         return sof_process[i].comp_type;
 933         }
 934
 935         return SOF_COMP_NONE;
 936 }
 937
 938 /*
 939  * Processing Component Topology - can be "effect", "codec", or general
 940  * "processing".
 941  */
 942
 943 static int sof_widget_update_ipc_comp_process(struct snd_sof_widget *swidget)
 944 {
 945         struct snd_soc_component *scomp = swidget->scomp;
 946         struct sof_ipc_comp_process config;
 947         int ret;
 948
 949         memset(&config, 0, sizeof(config));
 950         config.comp.core = swidget->core;
 951
 952         /* parse one set of process tokens */
 953         ret = sof_update_ipc_object(scomp, &config, SOF_PROCESS_TOKENS, swidget->tuples,
 954                                     swidget->num_tuples, sizeof(config), 1);
 955         if (ret < 0)
 956                 return ret;
 957
 958         /* now load process specific data and send IPC */
 959         return sof_process_load(scomp, swidget, find_process_comp_type(config.type));
 960 }
 961
 962 static int sof_link_hda_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
 963                              struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
 964 {
 965         struct sof_dai_private_data *private = dai->private;
 966         u32 size = sizeof(*config);
 967         int ret;
 968
 969         /* init IPC */
 970         memset(&config->hda, 0, sizeof(config->hda));
 971         config->hdr.size = size;
 972
 973         /* parse one set of HDA tokens */
 974         ret = sof_update_ipc_object(scomp, &config->hda, SOF_HDA_TOKENS, slink->tuples,
 975                                     slink->num_tuples, size, 1);
 976         if (ret < 0)
 977                 return ret;
 978
 979         dev_dbg(scomp->dev, "HDA config rate %d channels %d\n",
 980                 config->hda.rate, config->hda.channels);
 981
 982         config->hda.link_dma_ch = DMA_CHAN_INVALID;
 983
 984         dai->number_configs = 1;
 985         dai->current_config = 0;
 986         private->dai_config = kmemdup(config, size, GFP_KERNEL);
 987         if (!private->dai_config)
 988                 return -ENOMEM;
 989
 990         return 0;
 991 }
 992
 993 static void sof_dai_set_format(struct snd_soc_tplg_hw_config *hw_config,
 994                                struct sof_ipc_dai_config *config)
 995 {
 996         /* clock directions wrt codec */
 997         config->format &= ~SOF_DAI_FMT_CLOCK_PROVIDER_MASK;
 998         if (hw_config->bclk_provider == SND_SOC_TPLG_BCLK_CP) {
 999                 /* codec is bclk provider */
1000                 if (hw_config->fsync_provider == SND_SOC_TPLG_FSYNC_CP)
1001                         config->format |= SOF_DAI_FMT_CBP_CFP;
1002                 else
1003                         config->format |= SOF_DAI_FMT_CBP_CFC;
1004         } else {
1005                 /* codec is bclk consumer */
1006                 if (hw_config->fsync_provider == SND_SOC_TPLG_FSYNC_CP)
1007                         config->format |= SOF_DAI_FMT_CBC_CFP;
1008                 else
1009                         config->format |= SOF_DAI_FMT_CBC_CFC;
1010         }
1011
1012         /* inverted clocks ? */
1013         config->format &= ~SOF_DAI_FMT_INV_MASK;
1014         if (hw_config->invert_bclk) {
1015                 if (hw_config->invert_fsync)
1016                         config->format |= SOF_DAI_FMT_IB_IF;
1017                 else
1018                         config->format |= SOF_DAI_FMT_IB_NF;
1019         } else {
1020                 if (hw_config->invert_fsync)
1021                         config->format |= SOF_DAI_FMT_NB_IF;
1022                 else
1023                         config->format |= SOF_DAI_FMT_NB_NF;
1024         }
1025 }
1026
1027 static int sof_link_sai_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1028                              struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1029 {
1030         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1031         struct sof_dai_private_data *private = dai->private;
1032         u32 size = sizeof(*config);
1033         int ret;
1034
1035         /* handle master/slave and inverted clocks */
1036         sof_dai_set_format(hw_config, config);
1037
1038         /* init IPC */
1039         memset(&config->sai, 0, sizeof(config->sai));
1040         config->hdr.size = size;
1041
1042         /* parse one set of SAI tokens */
1043         ret = sof_update_ipc_object(scomp, &config->sai, SOF_SAI_TOKENS, slink->tuples,
1044                                     slink->num_tuples, size, 1);
1045         if (ret < 0)
1046                 return ret;
1047
1048         config->sai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
1049         config->sai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
1050         config->sai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1051         config->sai.mclk_direction = hw_config->mclk_direction;
1052
1053         config->sai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1054         config->sai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
1055         config->sai.rx_slots = le32_to_cpu(hw_config->rx_slots);
1056         config->sai.tx_slots = le32_to_cpu(hw_config->tx_slots);
1057
1058         dev_info(scomp->dev,
1059                  "tplg: config SAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
1060                 config->dai_index, config->format,
1061                 config->sai.mclk_rate, config->sai.tdm_slot_width,
1062                 config->sai.tdm_slots, config->sai.mclk_id);
1063
1064         if (config->sai.tdm_slots < 1 || config->sai.tdm_slots > 8) {
1065                 dev_err(scomp->dev, "Invalid channel count for SAI%d\n", config->dai_index);
1066                 return -EINVAL;
1067         }
1068
1069         dai->number_configs = 1;
1070         dai->current_config = 0;
1071         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1072         if (!private->dai_config)
1073                 return -ENOMEM;
1074
1075         return 0;
1076 }
1077
1078 static int sof_link_esai_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1079                               struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1080 {
1081         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1082         struct sof_dai_private_data *private = dai->private;
1083         u32 size = sizeof(*config);
1084         int ret;
1085
1086         /* handle master/slave and inverted clocks */
1087         sof_dai_set_format(hw_config, config);
1088
1089         /* init IPC */
1090         memset(&config->esai, 0, sizeof(config->esai));
1091         config->hdr.size = size;
1092
1093         /* parse one set of ESAI tokens */
1094         ret = sof_update_ipc_object(scomp, &config->esai, SOF_ESAI_TOKENS, slink->tuples,
1095                                     slink->num_tuples, size, 1);
1096         if (ret < 0)
1097                 return ret;
1098
1099         config->esai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
1100         config->esai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
1101         config->esai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1102         config->esai.mclk_direction = hw_config->mclk_direction;
1103         config->esai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1104         config->esai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
1105         config->esai.rx_slots = le32_to_cpu(hw_config->rx_slots);
1106         config->esai.tx_slots = le32_to_cpu(hw_config->tx_slots);
1107
1108         dev_info(scomp->dev,
1109                  "tplg: config ESAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
1110                 config->dai_index, config->format,
1111                 config->esai.mclk_rate, config->esai.tdm_slot_width,
1112                 config->esai.tdm_slots, config->esai.mclk_id);
1113
1114         if (config->esai.tdm_slots < 1 || config->esai.tdm_slots > 8) {
1115                 dev_err(scomp->dev, "Invalid channel count for ESAI%d\n", config->dai_index);
1116                 return -EINVAL;
1117         }
1118
1119         dai->number_configs = 1;
1120         dai->current_config = 0;
1121         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1122         if (!private->dai_config)
1123                 return -ENOMEM;
1124
1125         return 0;
1126 }
1127
1128 static int sof_link_acp_dmic_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1129                                   struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1130 {
1131         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1132         struct sof_dai_private_data *private = dai->private;
1133         u32 size = sizeof(*config);
1134         int ret;
1135
1136        /* handle master/slave and inverted clocks */
1137         sof_dai_set_format(hw_config, config);
1138
1139         config->hdr.size = size;
1140
1141         /* parse the required set of ACPDMIC tokens based on num_hw_cfgs */
1142         ret = sof_update_ipc_object(scomp, &config->acpdmic, SOF_ACPDMIC_TOKENS, slink->tuples,
1143                                     slink->num_tuples, size, slink->num_hw_configs);
1144         if (ret < 0)
1145                 return ret;
1146
1147         dev_info(scomp->dev, "ACP_DMIC config ACP%d channel %d rate %d\n",
1148                  config->dai_index, config->acpdmic.pdm_ch,
1149                  config->acpdmic.pdm_rate);
1150
1151         dai->number_configs = 1;
1152         dai->current_config = 0;
1153         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1154         if (!private->dai_config)
1155                 return -ENOMEM;
1156
1157         return 0;
1158 }
1159
1160 static int sof_link_acp_bt_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1161                                 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1162 {
1163         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1164         struct sof_dai_private_data *private = dai->private;
1165         u32 size = sizeof(*config);
1166
1167         /* handle master/slave and inverted clocks */
1168         sof_dai_set_format(hw_config, config);
1169
1170         /* init IPC */
1171         memset(&config->acpbt, 0, sizeof(config->acpbt));
1172         config->hdr.size = size;
1173
1174         config->acpbt.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1175         config->acpbt.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1176
1177         dev_info(scomp->dev, "ACP_BT config ACP%d channel %d rate %d\n",
1178                  config->dai_index, config->acpbt.tdm_slots,
1179                  config->acpbt.fsync_rate);
1180
1181         dai->number_configs = 1;
1182         dai->current_config = 0;
1183         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1184         if (!private->dai_config)
1185                 return -ENOMEM;
1186
1187         return 0;
1188 }
1189
1190 static int sof_link_acp_sp_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1191                                 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1192 {
1193         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1194         struct sof_dai_private_data *private = dai->private;
1195         u32 size = sizeof(*config);
1196
1197         /* handle master/slave and inverted clocks */
1198         sof_dai_set_format(hw_config, config);
1199
1200         /* init IPC */
1201         memset(&config->acpsp, 0, sizeof(config->acpsp));
1202         config->hdr.size = size;
1203
1204         config->acpsp.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1205         config->acpsp.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1206
1207         dev_info(scomp->dev, "ACP_SP config ACP%d channel %d rate %d\n",
1208                  config->dai_index, config->acpsp.tdm_slots,
1209                  config->acpsp.fsync_rate);
1210
1211         dai->number_configs = 1;
1212         dai->current_config = 0;
1213         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1214         if (!private->dai_config)
1215                 return -ENOMEM;
1216
1217         return 0;
1218 }
1219
1220 static int sof_link_acp_hs_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1221                                 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1222 {
1223         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1224         struct sof_dai_private_data *private = dai->private;
1225         u32 size = sizeof(*config);
1226
1227         /* Configures the DAI hardware format and inverted clocks */
1228         sof_dai_set_format(hw_config, config);
1229
1230         /* init IPC */
1231         memset(&config->acphs, 0, sizeof(config->acphs));
1232         config->hdr.size = size;
1233
1234         config->acphs.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1235         config->acphs.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1236
1237         dev_info(scomp->dev, "ACP_HS config ACP%d channel %d rate %d\n",
1238                  config->dai_index, config->acphs.tdm_slots,
1239                  config->acphs.fsync_rate);
1240
1241         dai->number_configs = 1;
1242         dai->current_config = 0;
1243         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1244         if (!private->dai_config)
1245                 return -ENOMEM;
1246
1247         return 0;
1248 }
1249
1250 static int sof_link_afe_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1251                              struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1252 {
1253         struct sof_dai_private_data *private = dai->private;
1254         u32 size = sizeof(*config);
1255         int ret;
1256
1257         config->hdr.size = size;
1258
1259         /* parse the required set of AFE tokens based on num_hw_cfgs */
1260         ret = sof_update_ipc_object(scomp, &config->afe, SOF_AFE_TOKENS, slink->tuples,
1261                                     slink->num_tuples, size, slink->num_hw_configs);
1262         if (ret < 0)
1263                 return ret;
1264
1265         dev_dbg(scomp->dev, "AFE config rate %d channels %d format:%d\n",
1266                 config->afe.rate, config->afe.channels, config->afe.format);
1267
1268         config->afe.stream_id = DMA_CHAN_INVALID;
1269
1270         dai->number_configs = 1;
1271         dai->current_config = 0;
1272         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1273         if (!private->dai_config)
1274                 return -ENOMEM;
1275
1276         return 0;
1277 }
1278
1279 static int sof_link_ssp_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1280                              struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1281 {
1282         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1283         struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1284         struct sof_dai_private_data *private = dai->private;
1285         u32 size = sizeof(*config);
1286         int current_config = 0;
1287         int i, ret;
1288
1289         /*
1290          * Parse common data, we should have 1 common data per hw_config.
1291          */
1292         ret = sof_update_ipc_object(scomp, &config->ssp, SOF_SSP_TOKENS, slink->tuples,
1293                                     slink->num_tuples, size, slink->num_hw_configs);
1294         if (ret < 0)
1295                 return ret;
1296
1297         /* process all possible hw configs */
1298         for (i = 0; i < slink->num_hw_configs; i++) {
1299                 if (le32_to_cpu(hw_config[i].id) == slink->default_hw_cfg_id)
1300                         current_config = i;
1301
1302                 /* handle master/slave and inverted clocks */
1303                 sof_dai_set_format(&hw_config[i], &config[i]);
1304
1305                 config[i].hdr.size = size;
1306
1307                 if (sdev->mclk_id_override) {
1308                         dev_dbg(scomp->dev, "tplg: overriding topology mclk_id %d by quirk %d\n",
1309                                 config[i].ssp.mclk_id, sdev->mclk_id_quirk);
1310                         config[i].ssp.mclk_id = sdev->mclk_id_quirk;
1311                 }
1312
1313                 /* copy differentiating hw configs to ipc structs */
1314                 config[i].ssp.mclk_rate = le32_to_cpu(hw_config[i].mclk_rate);
1315                 config[i].ssp.bclk_rate = le32_to_cpu(hw_config[i].bclk_rate);
1316                 config[i].ssp.fsync_rate = le32_to_cpu(hw_config[i].fsync_rate);
1317                 config[i].ssp.tdm_slots = le32_to_cpu(hw_config[i].tdm_slots);
1318                 config[i].ssp.tdm_slot_width = le32_to_cpu(hw_config[i].tdm_slot_width);
1319                 config[i].ssp.mclk_direction = hw_config[i].mclk_direction;
1320                 config[i].ssp.rx_slots = le32_to_cpu(hw_config[i].rx_slots);
1321                 config[i].ssp.tx_slots = le32_to_cpu(hw_config[i].tx_slots);
1322
1323                 dev_dbg(scomp->dev, "tplg: config SSP%d fmt %#x mclk %d bclk %d fclk %d width (%d)%d slots %d mclk id %d quirks %d clks_control %#x\n",
1324                         config[i].dai_index, config[i].format,
1325                         config[i].ssp.mclk_rate, config[i].ssp.bclk_rate,
1326                         config[i].ssp.fsync_rate, config[i].ssp.sample_valid_bits,
1327                         config[i].ssp.tdm_slot_width, config[i].ssp.tdm_slots,
1328                         config[i].ssp.mclk_id, config[i].ssp.quirks, config[i].ssp.clks_control);
1329
1330                 /* validate SSP fsync rate and channel count */
1331                 if (config[i].ssp.fsync_rate < 8000 || config[i].ssp.fsync_rate > 192000) {
1332                         dev_err(scomp->dev, "Invalid fsync rate for SSP%d\n", config[i].dai_index);
1333                         return -EINVAL;
1334                 }
1335
1336                 if (config[i].ssp.tdm_slots < 1 || config[i].ssp.tdm_slots > 8) {
1337                         dev_err(scomp->dev, "Invalid channel count for SSP%d\n",
1338                                 config[i].dai_index);
1339                         return -EINVAL;
1340                 }
1341         }
1342
1343         dai->number_configs = slink->num_hw_configs;
1344         dai->current_config = current_config;
1345         private->dai_config = kmemdup(config, size * slink->num_hw_configs, GFP_KERNEL);
1346         if (!private->dai_config)
1347                 return -ENOMEM;
1348
1349         return 0;
1350 }
1351
1352 static int sof_link_dmic_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1353                               struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1354 {
1355         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1356         struct sof_dai_private_data *private = dai->private;
1357         struct sof_ipc_fw_ready *ready = &sdev->fw_ready;
1358         struct sof_ipc_fw_version *v = &ready->version;
1359         size_t size = sizeof(*config);
1360         int i, ret;
1361
1362         /* Ensure the entire DMIC config struct is zeros */
1363         memset(&config->dmic, 0, sizeof(config->dmic));
1364
1365         /* parse the required set of DMIC tokens based on num_hw_cfgs */
1366         ret = sof_update_ipc_object(scomp, &config->dmic, SOF_DMIC_TOKENS, slink->tuples,
1367                                     slink->num_tuples, size, slink->num_hw_configs);
1368         if (ret < 0)
1369                 return ret;
1370
1371         /* parse the required set of DMIC PDM tokens based on number of active PDM's */
1372         ret = sof_update_ipc_object(scomp, &config->dmic.pdm[0], SOF_DMIC_PDM_TOKENS,
1373                                     slink->tuples, slink->num_tuples,
1374                                     sizeof(struct sof_ipc_dai_dmic_pdm_ctrl),
1375                                     config->dmic.num_pdm_active);
1376         if (ret < 0)
1377                 return ret;
1378
1379         /* set IPC header size */
1380         config->hdr.size = size;
1381
1382         /* debug messages */
1383         dev_dbg(scomp->dev, "tplg: config DMIC%d driver version %d\n",
1384                 config->dai_index, config->dmic.driver_ipc_version);
1385         dev_dbg(scomp->dev, "pdmclk_min %d pdm_clkmax %d duty_min %d\n",
1386                 config->dmic.pdmclk_min, config->dmic.pdmclk_max,
1387                 config->dmic.duty_min);
1388         dev_dbg(scomp->dev, "duty_max %d fifo_fs %d num_pdms active %d\n",
1389                 config->dmic.duty_max, config->dmic.fifo_fs,
1390                 config->dmic.num_pdm_active);
1391         dev_dbg(scomp->dev, "fifo word length %d\n", config->dmic.fifo_bits);
1392
1393         for (i = 0; i < config->dmic.num_pdm_active; i++) {
1394                 dev_dbg(scomp->dev, "pdm %d mic a %d mic b %d\n",
1395                         config->dmic.pdm[i].id,
1396                         config->dmic.pdm[i].enable_mic_a,
1397                         config->dmic.pdm[i].enable_mic_b);
1398                 dev_dbg(scomp->dev, "pdm %d polarity a %d polarity b %d\n",
1399                         config->dmic.pdm[i].id,
1400                         config->dmic.pdm[i].polarity_mic_a,
1401                         config->dmic.pdm[i].polarity_mic_b);
1402                 dev_dbg(scomp->dev, "pdm %d clk_edge %d skew %d\n",
1403                         config->dmic.pdm[i].id,
1404                         config->dmic.pdm[i].clk_edge,
1405                         config->dmic.pdm[i].skew);
1406         }
1407
1408         /*
1409          * this takes care of backwards compatible handling of fifo_bits_b.
1410          * It is deprecated since firmware ABI version 3.0.1.
1411          */
1412         if (SOF_ABI_VER(v->major, v->minor, v->micro) < SOF_ABI_VER(3, 0, 1))
1413                 config->dmic.fifo_bits_b = config->dmic.fifo_bits;
1414
1415         dai->number_configs = 1;
1416         dai->current_config = 0;
1417         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1418         if (!private->dai_config)
1419                 return -ENOMEM;
1420
1421         return 0;
1422 }
1423
1424 static int sof_link_alh_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1425                              struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1426 {
1427         struct sof_dai_private_data *private = dai->private;
1428         u32 size = sizeof(*config);
1429         int ret;
1430
1431         /* parse the required set of ALH tokens based on num_hw_cfgs */
1432         ret = sof_update_ipc_object(scomp, &config->alh, SOF_ALH_TOKENS, slink->tuples,
1433                                     slink->num_tuples, size, slink->num_hw_configs);
1434         if (ret < 0)
1435                 return ret;
1436
1437         /* init IPC */
1438         config->hdr.size = size;
1439
1440         /* set config for all DAI's with name matching the link name */
1441         dai->number_configs = 1;
1442         dai->current_config = 0;
1443         private->dai_config = kmemdup(config, size, GFP_KERNEL);
1444         if (!private->dai_config)
1445                 return -ENOMEM;
1446
1447         return 0;
1448 }
1449
1450 static int sof_ipc3_widget_setup_comp_dai(struct snd_sof_widget *swidget)
1451 {
1452         struct snd_soc_component *scomp = swidget->scomp;
1453         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1454         struct snd_sof_dai *dai = swidget->private;
1455         struct sof_dai_private_data *private;
1456         struct sof_ipc_comp_dai *comp_dai;
1457         size_t ipc_size = sizeof(*comp_dai);
1458         struct sof_ipc_dai_config *config;
1459         struct snd_sof_dai_link *slink;
1460         int ret;
1461
1462         private = kzalloc(sizeof(*private), GFP_KERNEL);
1463         if (!private)
1464                 return -ENOMEM;
1465
1466         dai->private = private;
1467
1468         private->comp_dai = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
1469         if (!private->comp_dai) {
1470                 ret = -ENOMEM;
1471                 goto free;
1472         }
1473
1474         /* configure dai IPC message */
1475         comp_dai = private->comp_dai;
1476         comp_dai->comp.type = SOF_COMP_DAI;
1477         comp_dai->config.hdr.size = sizeof(comp_dai->config);
1478
1479         /* parse one set of DAI tokens */
1480         ret = sof_update_ipc_object(scomp, comp_dai, SOF_DAI_TOKENS, swidget->tuples,
1481                                     swidget->num_tuples, sizeof(*comp_dai), 1);
1482         if (ret < 0)
1483                 goto free;
1484
1485         /* update comp_tokens */
1486         ret = sof_update_ipc_object(scomp, &comp_dai->config, SOF_COMP_TOKENS,
1487                                     swidget->tuples, swidget->num_tuples,
1488                                     sizeof(comp_dai->config), 1);
1489         if (ret < 0)
1490                 goto free;
1491
1492         dev_dbg(scomp->dev, "dai %s: type %d index %d\n",
1493                 swidget->widget->name, comp_dai->type, comp_dai->dai_index);
1494         sof_dbg_comp_config(scomp, &comp_dai->config);
1495
1496         /* now update DAI config */
1497         list_for_each_entry(slink, &sdev->dai_link_list, list) {
1498                 struct sof_ipc_dai_config common_config;
1499                 int i;
1500
1501                 if (strcmp(slink->link->name, dai->name))
1502                         continue;
1503
1504                 /* Reserve memory for all hw configs, eventually freed by widget */
1505                 config = kcalloc(slink->num_hw_configs, sizeof(*config), GFP_KERNEL);
1506                 if (!config) {
1507                         ret = -ENOMEM;
1508                         goto free_comp;
1509                 }
1510
1511                 /* parse one set of DAI link tokens */
1512                 ret = sof_update_ipc_object(scomp, &common_config, SOF_DAI_LINK_TOKENS,
1513                                             slink->tuples, slink->num_tuples,
1514                                             sizeof(common_config), 1);
1515                 if (ret < 0)
1516                         goto free_config;
1517
1518                 for (i = 0; i < slink->num_hw_configs; i++) {
1519                         config[i].hdr.cmd = SOF_IPC_GLB_DAI_MSG | SOF_IPC_DAI_CONFIG;
1520                         config[i].format = le32_to_cpu(slink->hw_configs[i].fmt);
1521                         config[i].type = common_config.type;
1522                         config[i].dai_index = comp_dai->dai_index;
1523                 }
1524
1525                 switch (common_config.type) {
1526                 case SOF_DAI_INTEL_SSP:
1527                         ret = sof_link_ssp_load(scomp, slink, config, dai);
1528                         break;
1529                 case SOF_DAI_INTEL_DMIC:
1530                         ret = sof_link_dmic_load(scomp, slink, config, dai);
1531                         break;
1532                 case SOF_DAI_INTEL_HDA:
1533                         ret = sof_link_hda_load(scomp, slink, config, dai);
1534                         break;
1535                 case SOF_DAI_INTEL_ALH:
1536                         ret = sof_link_alh_load(scomp, slink, config, dai);
1537                         break;
1538                 case SOF_DAI_IMX_SAI:
1539                         ret = sof_link_sai_load(scomp, slink, config, dai);
1540                         break;
1541                 case SOF_DAI_IMX_ESAI:
1542                         ret = sof_link_esai_load(scomp, slink, config, dai);
1543                         break;
1544                 case SOF_DAI_AMD_BT:
1545                         ret = sof_link_acp_bt_load(scomp, slink, config, dai);
1546                         break;
1547                 case SOF_DAI_AMD_SP:
1548                         ret = sof_link_acp_sp_load(scomp, slink, config, dai);
1549                         break;
1550                 case SOF_DAI_AMD_HS:
1551                         ret = sof_link_acp_hs_load(scomp, slink, config, dai);
1552                         break;
1553                 case SOF_DAI_AMD_DMIC:
1554                         ret = sof_link_acp_dmic_load(scomp, slink, config, dai);
1555                         break;
1556                 case SOF_DAI_MEDIATEK_AFE:
1557                         ret = sof_link_afe_load(scomp, slink, config, dai);
1558                         break;
1559                 default:
1560                         break;
1561                 }
1562                 if (ret < 0) {
1563                         dev_err(scomp->dev, "failed to load config for dai %s\n", dai->name);
1564                         goto free_config;
1565                 }
1566
1567                 kfree(config);
1568         }
1569
1570         return 0;
1571 free_config:
1572         kfree(config);
1573 free_comp:
1574         kfree(comp_dai);
1575 free:
1576         kfree(private);
1577         dai->private = NULL;
1578         return ret;
1579 }
1580
1581 static void sof_ipc3_widget_free_comp_dai(struct snd_sof_widget *swidget)
1582 {
1583         switch (swidget->id) {
1584         case snd_soc_dapm_dai_in:
1585         case snd_soc_dapm_dai_out:
1586         {
1587                 struct snd_sof_dai *dai = swidget->private;
1588                 struct sof_dai_private_data *dai_data;
1589
1590                 if (!dai)
1591                         return;
1592
1593                 dai_data = dai->private;
1594                 if (dai_data) {
1595                         kfree(dai_data->comp_dai);
1596                         kfree(dai_data->dai_config);
1597                         kfree(dai_data);
1598                 }
1599                 kfree(dai);
1600                 break;
1601         }
1602         default:
1603                 break;
1604         }
1605 }
1606
1607 static int sof_ipc3_route_setup(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
1608 {
1609         struct sof_ipc_pipe_comp_connect connect;
1610         struct sof_ipc_reply reply;
1611         int ret;
1612
1613         connect.hdr.size = sizeof(connect);
1614         connect.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_CONNECT;
1615         connect.source_id = sroute->src_widget->comp_id;
1616         connect.sink_id = sroute->sink_widget->comp_id;
1617
1618         dev_dbg(sdev->dev, "setting up route %s -> %s\n",
1619                 sroute->src_widget->widget->name,
1620                 sroute->sink_widget->widget->name);
1621
1622         /* send ipc */
1623         ret = sof_ipc_tx_message(sdev->ipc, &connect, sizeof(connect), &reply, sizeof(reply));
1624         if (ret < 0)
1625                 dev_err(sdev->dev, "%s: route %s -> %s failed\n", __func__,
1626                         sroute->src_widget->widget->name, sroute->sink_widget->widget->name);
1627
1628         return ret;
1629 }
1630
1631 static int sof_ipc3_control_load_bytes(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1632 {
1633         struct sof_ipc_ctrl_data *cdata;
1634         int ret;
1635
1636         if (scontrol->max_size < (sizeof(*cdata) + sizeof(struct sof_abi_hdr))) {
1637                 dev_err(sdev->dev, "%s: insufficient size for a bytes control: %zu.\n",
1638                         __func__, scontrol->max_size);
1639                 return -EINVAL;
1640         }
1641
1642         if (scontrol->priv_size > scontrol->max_size - sizeof(*cdata)) {
1643                 dev_err(sdev->dev,
1644                         "%s: bytes data size %zu exceeds max %zu.\n", __func__,
1645                         scontrol->priv_size, scontrol->max_size - sizeof(*cdata));
1646                 return -EINVAL;
1647         }
1648
1649         scontrol->ipc_control_data = kzalloc(scontrol->max_size, GFP_KERNEL);
1650         if (!scontrol->ipc_control_data)
1651                 return -ENOMEM;
1652
1653         scontrol->size = sizeof(struct sof_ipc_ctrl_data) + scontrol->priv_size;
1654
1655         cdata = scontrol->ipc_control_data;
1656         cdata->cmd = SOF_CTRL_CMD_BINARY;
1657         cdata->index = scontrol->index;
1658
1659         if (scontrol->priv_size > 0) {
1660                 memcpy(cdata->data, scontrol->priv, scontrol->priv_size);
1661                 kfree(scontrol->priv);
1662                 scontrol->priv = NULL;
1663
1664                 if (cdata->data->magic != SOF_ABI_MAGIC) {
1665                         dev_err(sdev->dev, "Wrong ABI magic 0x%08x.\n", cdata->data->magic);
1666                         ret = -EINVAL;
1667                         goto err;
1668                 }
1669
1670                 if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, cdata->data->abi)) {
1671                         dev_err(sdev->dev, "Incompatible ABI version 0x%08x.\n",
1672                                 cdata->data->abi);
1673                         ret = -EINVAL;
1674                         goto err;
1675                 }
1676
1677                 if (cdata->data->size + sizeof(struct sof_abi_hdr) != scontrol->priv_size) {
1678                         dev_err(sdev->dev, "Conflict in bytes vs. priv size.\n");
1679                         ret = -EINVAL;
1680                         goto err;
1681                 }
1682         }
1683
1684         return 0;
1685 err:
1686         kfree(scontrol->ipc_control_data);
1687         scontrol->ipc_control_data = NULL;
1688         return ret;
1689 }
1690
1691 static int sof_ipc3_control_load_volume(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1692 {
1693         struct sof_ipc_ctrl_data *cdata;
1694         int i;
1695
1696         /* init the volume get/put data */
1697         scontrol->size = struct_size(cdata, chanv, scontrol->num_channels);
1698
1699         scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
1700         if (!scontrol->ipc_control_data)
1701                 return -ENOMEM;
1702
1703         cdata = scontrol->ipc_control_data;
1704         cdata->index = scontrol->index;
1705
1706         /* set cmd for mixer control */
1707         if (scontrol->max == 1) {
1708                 cdata->cmd = SOF_CTRL_CMD_SWITCH;
1709                 return 0;
1710         }
1711
1712         cdata->cmd = SOF_CTRL_CMD_VOLUME;
1713
1714         /* set default volume values to 0dB in control */
1715         for (i = 0; i < scontrol->num_channels; i++) {
1716                 cdata->chanv[i].channel = i;
1717                 cdata->chanv[i].value = VOL_ZERO_DB;
1718         }
1719
1720         return 0;
1721 }
1722
1723 static int sof_ipc3_control_load_enum(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1724 {
1725         struct sof_ipc_ctrl_data *cdata;
1726
1727         /* init the enum get/put data */
1728         scontrol->size = struct_size(cdata, chanv, scontrol->num_channels);
1729
1730         scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
1731         if (!scontrol->ipc_control_data)
1732                 return -ENOMEM;
1733
1734         cdata = scontrol->ipc_control_data;
1735         cdata->index = scontrol->index;
1736         cdata->cmd = SOF_CTRL_CMD_ENUM;
1737
1738         return 0;
1739 }
1740
1741 static int sof_ipc3_control_setup(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1742 {
1743         switch (scontrol->info_type) {
1744         case SND_SOC_TPLG_CTL_VOLSW:
1745         case SND_SOC_TPLG_CTL_VOLSW_SX:
1746         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1747                 return sof_ipc3_control_load_volume(sdev, scontrol);
1748         case SND_SOC_TPLG_CTL_BYTES:
1749                 return sof_ipc3_control_load_bytes(sdev, scontrol);
1750         case SND_SOC_TPLG_CTL_ENUM:
1751         case SND_SOC_TPLG_CTL_ENUM_VALUE:
1752                 return sof_ipc3_control_load_enum(sdev, scontrol);
1753         default:
1754                 break;
1755         }
1756
1757         return 0;
1758 }
1759
1760 static int sof_ipc3_control_free(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1761 {
1762         struct sof_ipc_free fcomp;
1763
1764         fcomp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_FREE;
1765         fcomp.hdr.size = sizeof(fcomp);
1766         fcomp.id = scontrol->comp_id;
1767
1768         /* send IPC to the DSP */
1769         return sof_ipc_tx_message(sdev->ipc, &fcomp, sizeof(fcomp), NULL, 0);
1770 }
1771
1772 /* send pcm params ipc */
1773 static int sof_ipc3_keyword_detect_pcm_params(struct snd_sof_widget *swidget, int dir)
1774 {
1775         struct snd_soc_component *scomp = swidget->scomp;
1776         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1777         struct sof_ipc_pcm_params_reply ipc_params_reply;
1778         struct snd_pcm_hw_params *params;
1779         struct sof_ipc_pcm_params pcm;
1780         struct snd_sof_pcm *spcm;
1781         int ret;
1782
1783         /* get runtime PCM params using widget's stream name */
1784         spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
1785         if (!spcm) {
1786                 dev_err(scomp->dev, "Cannot find PCM for %s\n", swidget->widget->name);
1787                 return -EINVAL;
1788         }
1789
1790         params = &spcm->params[dir];
1791
1792         /* set IPC PCM params */
1793         memset(&pcm, 0, sizeof(pcm));
1794         pcm.hdr.size = sizeof(pcm);
1795         pcm.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | SOF_IPC_STREAM_PCM_PARAMS;
1796         pcm.comp_id = swidget->comp_id;
1797         pcm.params.hdr.size = sizeof(pcm.params);
1798         pcm.params.direction = dir;
1799         pcm.params.sample_valid_bytes = params_width(params) >> 3;
1800         pcm.params.buffer_fmt = SOF_IPC_BUFFER_INTERLEAVED;
1801         pcm.params.rate = params_rate(params);
1802         pcm.params.channels = params_channels(params);
1803         pcm.params.host_period_bytes = params_period_bytes(params);
1804
1805         /* set format */
1806         switch (params_format(params)) {
1807         case SNDRV_PCM_FORMAT_S16:
1808                 pcm.params.frame_fmt = SOF_IPC_FRAME_S16_LE;
1809                 break;
1810         case SNDRV_PCM_FORMAT_S24:
1811                 pcm.params.frame_fmt = SOF_IPC_FRAME_S24_4LE;
1812                 break;
1813         case SNDRV_PCM_FORMAT_S32:
1814                 pcm.params.frame_fmt = SOF_IPC_FRAME_S32_LE;
1815                 break;
1816         default:
1817                 return -EINVAL;
1818         }
1819
1820         /* send IPC to the DSP */
1821         ret = sof_ipc_tx_message(sdev->ipc, &pcm, sizeof(pcm),
1822                                  &ipc_params_reply, sizeof(ipc_params_reply));
1823         if (ret < 0)
1824                 dev_err(scomp->dev, "%s: PCM params failed for %s\n", __func__,
1825                         swidget->widget->name);
1826
1827         return ret;
1828 }
1829
1830  /* send stream trigger ipc */
1831 static int sof_ipc3_keyword_detect_trigger(struct snd_sof_widget *swidget, int cmd)
1832 {
1833         struct snd_soc_component *scomp = swidget->scomp;
1834         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1835         struct sof_ipc_stream stream;
1836         struct sof_ipc_reply reply;
1837         int ret;
1838
1839         /* set IPC stream params */
1840         stream.hdr.size = sizeof(stream);
1841         stream.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | cmd;
1842         stream.comp_id = swidget->comp_id;
1843
1844         /* send IPC to the DSP */
1845         ret = sof_ipc_tx_message(sdev->ipc, &stream, sizeof(stream), &reply, sizeof(reply));
1846         if (ret < 0)
1847                 dev_err(scomp->dev, "%s: Failed to trigger %s\n", __func__, swidget->widget->name);
1848
1849         return ret;
1850 }
1851
1852 static int sof_ipc3_keyword_dapm_event(struct snd_soc_dapm_widget *w,
1853                                        struct snd_kcontrol *k, int event)
1854 {
1855         struct snd_sof_widget *swidget = w->dobj.private;
1856         struct snd_soc_component *scomp;
1857         int stream = SNDRV_PCM_STREAM_CAPTURE;
1858         struct snd_sof_pcm *spcm;
1859         int ret = 0;
1860
1861         if (!swidget)
1862                 return 0;
1863
1864         scomp = swidget->scomp;
1865
1866         dev_dbg(scomp->dev, "received event %d for widget %s\n",
1867                 event, w->name);
1868
1869         /* get runtime PCM params using widget's stream name */
1870         spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
1871         if (!spcm) {
1872                 dev_err(scomp->dev, "%s: Cannot find PCM for %s\n", __func__,
1873                         swidget->widget->name);
1874                 return -EINVAL;
1875         }
1876
1877         /* process events */
1878         switch (event) {
1879         case SND_SOC_DAPM_PRE_PMU:
1880                 if (spcm->stream[stream].suspend_ignored) {
1881                         dev_dbg(scomp->dev, "PRE_PMU event ignored, KWD pipeline is already RUNNING\n");
1882                         return 0;
1883                 }
1884
1885                 /* set pcm params */
1886                 ret = sof_ipc3_keyword_detect_pcm_params(swidget, stream);
1887                 if (ret < 0) {
1888                         dev_err(scomp->dev, "%s: Failed to set pcm params for widget %s\n",
1889                                 __func__, swidget->widget->name);
1890                         break;
1891                 }
1892
1893                 /* start trigger */
1894                 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_TRIG_START);
1895                 if (ret < 0)
1896                         dev_err(scomp->dev, "%s: Failed to trigger widget %s\n", __func__,
1897                                 swidget->widget->name);
1898                 break;
1899         case SND_SOC_DAPM_POST_PMD:
1900                 if (spcm->stream[stream].suspend_ignored) {
1901                         dev_dbg(scomp->dev,
1902                                 "POST_PMD event ignored, KWD pipeline will remain RUNNING\n");
1903                         return 0;
1904                 }
1905
1906                 /* stop trigger */
1907                 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_TRIG_STOP);
1908                 if (ret < 0)
1909                         dev_err(scomp->dev, "%s: Failed to trigger widget %s\n", __func__,
1910                                 swidget->widget->name);
1911
1912                 /* pcm free */
1913                 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_PCM_FREE);
1914                 if (ret < 0)
1915                         dev_err(scomp->dev, "%s: Failed to free PCM for widget %s\n", __func__,
1916                                 swidget->widget->name);
1917                 break;
1918         default:
1919                 break;
1920         }
1921
1922         return ret;
1923 }
1924
1925 /* event handlers for keyword detect component */
1926 static const struct snd_soc_tplg_widget_events sof_kwd_events[] = {
1927         {SOF_KEYWORD_DETECT_DAPM_EVENT, sof_ipc3_keyword_dapm_event},
1928 };
1929
1930 static int sof_ipc3_widget_bind_event(struct snd_soc_component *scomp,
1931                                       struct snd_sof_widget *swidget, u16 event_type)
1932 {
1933         struct sof_ipc_comp *ipc_comp;
1934
1935         /* validate widget event type */
1936         switch (event_type) {
1937         case SOF_KEYWORD_DETECT_DAPM_EVENT:
1938                 /* only KEYWORD_DETECT comps should handle this */
1939                 if (swidget->id != snd_soc_dapm_effect)
1940                         break;
1941
1942                 ipc_comp = swidget->private;
1943                 if (ipc_comp && ipc_comp->type != SOF_COMP_KEYWORD_DETECT)
1944                         break;
1945
1946                 /* bind event to keyword detect comp */
1947                 return snd_soc_tplg_widget_bind_event(swidget->widget, sof_kwd_events,
1948                                                       ARRAY_SIZE(sof_kwd_events), event_type);
1949         default:
1950                 break;
1951         }
1952
1953         dev_err(scomp->dev, "Invalid event type %d for widget %s\n", event_type,
1954                 swidget->widget->name);
1955
1956         return -EINVAL;
1957 }
1958
1959 static int sof_ipc3_complete_pipeline(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1960 {
1961         struct sof_ipc_pipe_ready ready;
1962         struct sof_ipc_reply reply;
1963         int ret;
1964
1965         dev_dbg(sdev->dev, "tplg: complete pipeline %s id %d\n",
1966                 swidget->widget->name, swidget->comp_id);
1967
1968         memset(&ready, 0, sizeof(ready));
1969         ready.hdr.size = sizeof(ready);
1970         ready.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_COMPLETE;
1971         ready.comp_id = swidget->comp_id;
1972
1973         ret = sof_ipc_tx_message(sdev->ipc, &ready, sizeof(ready), &reply, sizeof(reply));
1974         if (ret < 0)
1975                 return ret;
1976
1977         return 1;
1978 }
1979
1980 static int sof_ipc3_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1981 {
1982         struct sof_ipc_free ipc_free = {
1983                 .hdr = {
1984                         .size = sizeof(ipc_free),
1985                         .cmd = SOF_IPC_GLB_TPLG_MSG,
1986                 },
1987                 .id = swidget->comp_id,
1988         };
1989         struct sof_ipc_reply reply;
1990         int ret;
1991
1992         if (!swidget->private)
1993                 return 0;
1994
1995         switch (swidget->id) {
1996         case snd_soc_dapm_scheduler:
1997         {
1998                 ipc_free.hdr.cmd |= SOF_IPC_TPLG_PIPE_FREE;
1999                 break;
2000         }
2001         case snd_soc_dapm_buffer:
2002                 ipc_free.hdr.cmd |= SOF_IPC_TPLG_BUFFER_FREE;
2003                 break;
2004         default:
2005                 ipc_free.hdr.cmd |= SOF_IPC_TPLG_COMP_FREE;
2006                 break;
2007         }
2008
2009         ret = sof_ipc_tx_message(sdev->ipc, &ipc_free, sizeof(ipc_free),
2010                                  &reply, sizeof(reply));
2011         if (ret < 0)
2012                 dev_err(sdev->dev, "failed to free widget %s\n", swidget->widget->name);
2013
2014         return ret;
2015 }
2016
2017 static int sof_ipc3_dai_config(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
2018                                unsigned int flags, struct snd_sof_dai_config_data *data)
2019 {
2020         struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2021         struct snd_sof_dai *dai = swidget->private;
2022         struct sof_dai_private_data *private;
2023         struct sof_ipc_dai_config *config;
2024         struct sof_ipc_reply reply;
2025         int ret = 0;
2026
2027         if (!dai || !dai->private) {
2028                 dev_err(sdev->dev, "No private data for DAI %s\n", swidget->widget->name);
2029                 return -EINVAL;
2030         }
2031
2032         private = dai->private;
2033         if (!private->dai_config) {
2034                 dev_err(sdev->dev, "No config for DAI %s\n", dai->name);
2035                 return -EINVAL;
2036         }
2037
2038         config = &private->dai_config[dai->current_config];
2039         if (!config) {
2040                 dev_err(sdev->dev, "Invalid current config for DAI %s\n", dai->name);
2041                 return -EINVAL;
2042         }
2043
2044         switch (config->type) {
2045         case SOF_DAI_INTEL_SSP:
2046                 /*
2047                  * DAI_CONFIG IPC during hw_params/hw_free for SSP DAI's is not supported in older
2048                  * firmware
2049                  */
2050                 if (v->abi_version < SOF_ABI_VER(3, 18, 0) &&
2051                     ((flags & SOF_DAI_CONFIG_FLAGS_HW_PARAMS) ||
2052                      (flags & SOF_DAI_CONFIG_FLAGS_HW_FREE)))
2053                         return 0;
2054                 break;
2055         case SOF_DAI_INTEL_HDA:
2056                 if (data)
2057                         config->hda.link_dma_ch = data->dai_data;
2058                 break;
2059         case SOF_DAI_INTEL_ALH:
2060                 if (data) {
2061                         config->dai_index = data->dai_index;
2062                         config->alh.stream_id = data->dai_data;
2063                 }
2064                 break;
2065         default:
2066                 break;
2067         }
2068
2069         config->flags = flags;
2070
2071         /* only send the IPC if the widget is set up in the DSP */
2072         if (swidget->use_count > 0) {
2073                 ret = sof_ipc_tx_message(sdev->ipc, config, config->hdr.size,
2074                                          &reply, sizeof(reply));
2075                 if (ret < 0)
2076                         dev_err(sdev->dev, "Failed to set dai config for %s\n", dai->name);
2077         }
2078
2079         return ret;
2080 }
2081
2082 static int sof_ipc3_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
2083 {
2084         struct sof_ipc_comp_reply reply;
2085         int ret;
2086
2087         if (!swidget->private)
2088                 return 0;
2089
2090         switch (swidget->id) {
2091         case snd_soc_dapm_dai_in:
2092         case snd_soc_dapm_dai_out:
2093         {
2094                 struct snd_sof_dai *dai = swidget->private;
2095                 struct sof_dai_private_data *dai_data = dai->private;
2096                 struct sof_ipc_comp *comp = &dai_data->comp_dai->comp;
2097
2098                 ret = sof_ipc_tx_message(sdev->ipc, dai_data->comp_dai,
2099                                          comp->hdr.size, &reply, sizeof(reply));
2100                 break;
2101         }
2102         case snd_soc_dapm_scheduler:
2103         {
2104                 struct sof_ipc_pipe_new *pipeline;
2105
2106                 pipeline = swidget->private;
2107                 ret = sof_ipc_tx_message(sdev->ipc, pipeline, sizeof(*pipeline),
2108                                          &reply, sizeof(reply));
2109                 break;
2110         }
2111         default:
2112         {
2113                 struct sof_ipc_cmd_hdr *hdr;
2114
2115                 hdr = swidget->private;
2116                 ret = sof_ipc_tx_message(sdev->ipc, swidget->private, hdr->size,
2117                                          &reply, sizeof(reply));
2118                 break;
2119         }
2120         }
2121         if (ret < 0)
2122                 dev_err(sdev->dev, "Failed to setup widget %s\n", swidget->widget->name);
2123
2124         return ret;
2125 }
2126
2127 static int sof_ipc3_set_up_all_pipelines(struct snd_sof_dev *sdev, bool verify)
2128 {
2129         struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2130         struct snd_sof_widget *swidget;
2131         struct snd_sof_route *sroute;
2132         int ret;
2133
2134         /* restore pipeline components */
2135         list_for_each_entry(swidget, &sdev->widget_list, list) {
2136                 /* only set up the widgets belonging to static pipelines */
2137                 if (!verify && swidget->dynamic_pipeline_widget)
2138                         continue;
2139
2140                 /*
2141                  * For older firmware, skip scheduler widgets in this loop,
2142                  * sof_widget_setup() will be called in the 'complete pipeline' loop
2143                  */
2144                 if (v->abi_version < SOF_ABI_VER(3, 19, 0) &&
2145                     swidget->id == snd_soc_dapm_scheduler)
2146                         continue;
2147
2148                 /* update DAI config. The IPC will be sent in sof_widget_setup() */
2149                 if (WIDGET_IS_DAI(swidget->id)) {
2150                         struct snd_sof_dai *dai = swidget->private;
2151                         struct sof_dai_private_data *private;
2152                         struct sof_ipc_dai_config *config;
2153
2154                         if (!dai || !dai->private)
2155                                 continue;
2156                         private = dai->private;
2157                         if (!private->dai_config)
2158                                 continue;
2159
2160                         config = private->dai_config;
2161                         /*
2162                          * The link DMA channel would be invalidated for running
2163                          * streams but not for streams that were in the PAUSED
2164                          * state during suspend. So invalidate it here before setting
2165                          * the dai config in the DSP.
2166                          */
2167                         if (config->type == SOF_DAI_INTEL_HDA)
2168                                 config->hda.link_dma_ch = DMA_CHAN_INVALID;
2169                 }
2170
2171                 ret = sof_widget_setup(sdev, swidget);
2172                 if (ret < 0)
2173                         return ret;
2174         }
2175
2176         /* restore pipeline connections */
2177         list_for_each_entry(sroute, &sdev->route_list, list) {
2178                 /* only set up routes belonging to static pipelines */
2179                 if (!verify && (sroute->src_widget->dynamic_pipeline_widget ||
2180                                 sroute->sink_widget->dynamic_pipeline_widget))
2181                         continue;
2182
2183                 /*
2184                  * For virtual routes, both sink and source are not buffer. IPC3 only supports
2185                  * connections between a buffer and a component. Ignore the rest.
2186                  */
2187                 if (sroute->src_widget->id != snd_soc_dapm_buffer &&
2188                     sroute->sink_widget->id != snd_soc_dapm_buffer)
2189                         continue;
2190
2191                 ret = sof_route_setup(sdev, sroute->src_widget->widget,
2192                                       sroute->sink_widget->widget);
2193                 if (ret < 0) {
2194                         dev_err(sdev->dev, "%s: route set up failed\n", __func__);
2195                         return ret;
2196                 }
2197         }
2198
2199         /* complete pipeline */
2200         list_for_each_entry(swidget, &sdev->widget_list, list) {
2201                 switch (swidget->id) {
2202                 case snd_soc_dapm_scheduler:
2203                         /* only complete static pipelines */
2204                         if (!verify && swidget->dynamic_pipeline_widget)
2205                                 continue;
2206
2207                         if (v->abi_version < SOF_ABI_VER(3, 19, 0)) {
2208                                 ret = sof_widget_setup(sdev, swidget);
2209                                 if (ret < 0)
2210                                         return ret;
2211                         }
2212
2213                         swidget->complete = sof_ipc3_complete_pipeline(sdev, swidget);
2214                         if (swidget->complete < 0)
2215                                 return swidget->complete;
2216                         break;
2217                 default:
2218                         break;
2219                 }
2220         }
2221
2222         return 0;
2223 }
2224
2225 /*
2226  * Free the PCM, its associated widgets and set the prepared flag to false for all PCMs that
2227  * did not get suspended(ex: paused streams) so the widgets can be set up again during resume.
2228  */
2229 static int sof_tear_down_left_over_pipelines(struct snd_sof_dev *sdev)
2230 {
2231         struct snd_sof_widget *swidget;
2232         struct snd_sof_pcm *spcm;
2233         int dir, ret;
2234
2235         /*
2236          * free all PCMs and their associated DAPM widgets if their connected DAPM widget
2237          * list is not NULL. This should only be true for paused streams at this point.
2238          * This is equivalent to the handling of FE DAI suspend trigger for running streams.
2239          */
2240         list_for_each_entry(spcm, &sdev->pcm_list, list) {
2241                 for_each_pcm_streams(dir) {
2242                         struct snd_pcm_substream *substream = spcm->stream[dir].substream;
2243
2244                         if (!substream || !substream->runtime)
2245                                 continue;
2246
2247                         if (spcm->stream[dir].list) {
2248                                 ret = sof_pcm_stream_free(sdev, substream, spcm, dir, true);
2249                                 if (ret < 0)
2250                                         return ret;
2251                         }
2252                 }
2253         }
2254
2255         /*
2256          * free any left over DAI widgets. This is equivalent to the handling of suspend trigger
2257          * for the BE DAI for running streams.
2258          */
2259         list_for_each_entry(swidget, &sdev->widget_list, list)
2260                 if (WIDGET_IS_DAI(swidget->id) && swidget->use_count == 1) {
2261                         ret = sof_widget_free(sdev, swidget);
2262                         if (ret < 0)
2263                                 return ret;
2264                 }
2265
2266         return 0;
2267 }
2268
2269 /*
2270  * For older firmware, this function doesn't free widgets for static pipelines during suspend.
2271  * It only resets use_count for all widgets.
2272  */
2273 static int sof_ipc3_tear_down_all_pipelines(struct snd_sof_dev *sdev, bool verify)
2274 {
2275         struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2276         struct snd_sof_widget *swidget;
2277         struct snd_sof_route *sroute;
2278         bool dyn_widgets = false;
2279         int ret;
2280
2281         /*
2282          * This function is called during suspend and for one-time topology verification during
2283          * first boot. In both cases, there is no need to protect swidget->use_count and
2284          * sroute->setup because during suspend all running streams are suspended and during
2285          * topology loading the sound card unavailable to open PCMs.
2286          */
2287         list_for_each_entry(swidget, &sdev->widget_list, list) {
2288                 if (swidget->dynamic_pipeline_widget) {
2289                         dyn_widgets = true;
2290                         continue;
2291                 }
2292
2293                 /* Do not free widgets for static pipelines with FW older than SOF2.2 */
2294                 if (!verify && !swidget->dynamic_pipeline_widget &&
2295                     SOF_FW_VER(v->major, v->minor, v->micro) < SOF_FW_VER(2, 2, 0)) {
2296                         swidget->use_count = 0;
2297                         swidget->complete = 0;
2298                         continue;
2299                 }
2300
2301                 ret = sof_widget_free(sdev, swidget);
2302                 if (ret < 0)
2303                         return ret;
2304         }
2305
2306         /*
2307          * Tear down all pipelines associated with PCMs that did not get suspended
2308          * and unset the prepare flag so that they can be set up again during resume.
2309          * Skip this step for older firmware unless topology has any
2310          * dynamic pipeline (in which case the step is mandatory).
2311          */
2312         if (!verify && (dyn_widgets || SOF_FW_VER(v->major, v->minor, v->micro) >=
2313             SOF_FW_VER(2, 2, 0))) {
2314                 ret = sof_tear_down_left_over_pipelines(sdev);
2315                 if (ret < 0) {
2316                         dev_err(sdev->dev, "failed to tear down paused pipelines\n");
2317                         return ret;
2318                 }
2319         }
2320
2321         list_for_each_entry(sroute, &sdev->route_list, list)
2322                 sroute->setup = false;
2323
2324         /*
2325          * before suspending, make sure the refcounts are all zeroed out. There's no way
2326          * to recover at this point but this will help root cause bad sequences leading to
2327          * more issues on resume
2328          */
2329         list_for_each_entry(swidget, &sdev->widget_list, list) {
2330                 if (swidget->use_count != 0) {
2331                         dev_err(sdev->dev, "%s: widget %s is still in use: count %d\n",
2332                                 __func__, swidget->widget->name, swidget->use_count);
2333                 }
2334         }
2335
2336         return 0;
2337 }
2338
2339 static int sof_ipc3_dai_get_clk(struct snd_sof_dev *sdev, struct snd_sof_dai *dai, int clk_type)
2340 {
2341         struct sof_dai_private_data *private = dai->private;
2342
2343         if (!private || !private->dai_config)
2344                 return 0;
2345
2346         switch (private->dai_config->type) {
2347         case SOF_DAI_INTEL_SSP:
2348                 switch (clk_type) {
2349                 case SOF_DAI_CLK_INTEL_SSP_MCLK:
2350                         return private->dai_config->ssp.mclk_rate;
2351                 case SOF_DAI_CLK_INTEL_SSP_BCLK:
2352                         return private->dai_config->ssp.bclk_rate;
2353                 default:
2354                         break;
2355                 }
2356                 dev_err(sdev->dev, "fail to get SSP clk %d rate\n", clk_type);
2357                 break;
2358         default:
2359                 /* not yet implemented for platforms other than the above */
2360                 dev_err(sdev->dev, "DAI type %d not supported yet!\n", private->dai_config->type);
2361                 break;
2362         }
2363
2364         return -EINVAL;
2365 }
2366
2367 static int sof_ipc3_parse_manifest(struct snd_soc_component *scomp, int index,
2368                                    struct snd_soc_tplg_manifest *man)
2369 {
2370         u32 size = le32_to_cpu(man->priv.size);
2371         u32 abi_version;
2372
2373         /* backward compatible with tplg without ABI info */
2374         if (!size) {
2375                 dev_dbg(scomp->dev, "No topology ABI info\n");
2376                 return 0;
2377         }
2378
2379         if (size != SOF_IPC3_TPLG_ABI_SIZE) {
2380                 dev_err(scomp->dev, "%s: Invalid topology ABI size: %u\n",
2381                         __func__, size);
2382                 return -EINVAL;
2383         }
2384
2385         dev_info(scomp->dev,
2386                  "Topology: ABI %d:%d:%d Kernel ABI %d:%d:%d\n",
2387                  man->priv.data[0], man->priv.data[1], man->priv.data[2],
2388                  SOF_ABI_MAJOR, SOF_ABI_MINOR, SOF_ABI_PATCH);
2389
2390         abi_version = SOF_ABI_VER(man->priv.data[0], man->priv.data[1], man->priv.data[2]);
2391
2392         if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, abi_version)) {
2393                 dev_err(scomp->dev, "%s: Incompatible topology ABI version\n", __func__);
2394                 return -EINVAL;
2395         }
2396
2397         if (IS_ENABLED(CONFIG_SND_SOC_SOF_STRICT_ABI_CHECKS) &&
2398             SOF_ABI_VERSION_MINOR(abi_version) > SOF_ABI_MINOR) {
2399                 dev_err(scomp->dev, "%s: Topology ABI is more recent than kernel\n", __func__);
2400                 return -EINVAL;
2401         }
2402
2403         return 0;
2404 }
2405
2406 /* token list for each topology object */
2407 static enum sof_tokens host_token_list[] = {
2408         SOF_CORE_TOKENS,
2409         SOF_COMP_EXT_TOKENS,
2410         SOF_PCM_TOKENS,
2411         SOF_COMP_TOKENS,
2412 };
2413
2414 static enum sof_tokens comp_generic_token_list[] = {
2415         SOF_CORE_TOKENS,
2416         SOF_COMP_EXT_TOKENS,
2417         SOF_COMP_TOKENS,
2418 };
2419
2420 static enum sof_tokens buffer_token_list[] = {
2421         SOF_BUFFER_TOKENS,
2422 };
2423
2424 static enum sof_tokens pipeline_token_list[] = {
2425         SOF_CORE_TOKENS,
2426         SOF_COMP_EXT_TOKENS,
2427         SOF_PIPELINE_TOKENS,
2428         SOF_SCHED_TOKENS,
2429 };
2430
2431 static enum sof_tokens asrc_token_list[] = {
2432         SOF_CORE_TOKENS,
2433         SOF_COMP_EXT_TOKENS,
2434         SOF_ASRC_TOKENS,
2435         SOF_COMP_TOKENS,
2436 };
2437
2438 static enum sof_tokens src_token_list[] = {
2439         SOF_CORE_TOKENS,
2440         SOF_COMP_EXT_TOKENS,
2441         SOF_SRC_TOKENS,
2442         SOF_COMP_TOKENS
2443 };
2444
2445 static enum sof_tokens pga_token_list[] = {
2446         SOF_CORE_TOKENS,
2447         SOF_COMP_EXT_TOKENS,
2448         SOF_VOLUME_TOKENS,
2449         SOF_COMP_TOKENS,
2450 };
2451
2452 static enum sof_tokens dai_token_list[] = {
2453         SOF_CORE_TOKENS,
2454         SOF_COMP_EXT_TOKENS,
2455         SOF_DAI_TOKENS,
2456         SOF_COMP_TOKENS,
2457 };
2458
2459 static enum sof_tokens process_token_list[] = {
2460         SOF_CORE_TOKENS,
2461         SOF_COMP_EXT_TOKENS,
2462         SOF_PROCESS_TOKENS,
2463         SOF_COMP_TOKENS,
2464 };
2465
2466 static const struct sof_ipc_tplg_widget_ops tplg_ipc3_widget_ops[SND_SOC_DAPM_TYPE_COUNT] = {
2467         [snd_soc_dapm_aif_in] =  {sof_ipc3_widget_setup_comp_host, sof_ipc3_widget_free_comp,
2468                                   host_token_list, ARRAY_SIZE(host_token_list), NULL},
2469         [snd_soc_dapm_aif_out] = {sof_ipc3_widget_setup_comp_host, sof_ipc3_widget_free_comp,
2470                                   host_token_list, ARRAY_SIZE(host_token_list), NULL},
2471
2472         [snd_soc_dapm_dai_in] = {sof_ipc3_widget_setup_comp_dai, sof_ipc3_widget_free_comp_dai,
2473                                  dai_token_list, ARRAY_SIZE(dai_token_list), NULL},
2474         [snd_soc_dapm_dai_out] = {sof_ipc3_widget_setup_comp_dai, sof_ipc3_widget_free_comp_dai,
2475                                   dai_token_list, ARRAY_SIZE(dai_token_list), NULL},
2476         [snd_soc_dapm_buffer] = {sof_ipc3_widget_setup_comp_buffer, sof_ipc3_widget_free_comp,
2477                                  buffer_token_list, ARRAY_SIZE(buffer_token_list), NULL},
2478         [snd_soc_dapm_mixer] = {sof_ipc3_widget_setup_comp_mixer, sof_ipc3_widget_free_comp,
2479                                 comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2480                                 NULL},
2481         [snd_soc_dapm_src] = {sof_ipc3_widget_setup_comp_src, sof_ipc3_widget_free_comp,
2482                               src_token_list, ARRAY_SIZE(src_token_list), NULL},
2483         [snd_soc_dapm_asrc] = {sof_ipc3_widget_setup_comp_asrc, sof_ipc3_widget_free_comp,
2484                                asrc_token_list, ARRAY_SIZE(asrc_token_list), NULL},
2485         [snd_soc_dapm_siggen] = {sof_ipc3_widget_setup_comp_tone, sof_ipc3_widget_free_comp,
2486                                  comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2487                                  NULL},
2488         [snd_soc_dapm_scheduler] = {sof_ipc3_widget_setup_comp_pipeline, sof_ipc3_widget_free_comp,
2489                                     pipeline_token_list, ARRAY_SIZE(pipeline_token_list), NULL},
2490         [snd_soc_dapm_pga] = {sof_ipc3_widget_setup_comp_pga, sof_ipc3_widget_free_comp,
2491                               pga_token_list, ARRAY_SIZE(pga_token_list), NULL},
2492         [snd_soc_dapm_mux] = {sof_ipc3_widget_setup_comp_mux, sof_ipc3_widget_free_comp,
2493                               comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list), NULL},
2494         [snd_soc_dapm_demux] = {sof_ipc3_widget_setup_comp_mux, sof_ipc3_widget_free_comp,
2495                                  comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2496                                  NULL},
2497         [snd_soc_dapm_effect] = {sof_widget_update_ipc_comp_process, sof_ipc3_widget_free_comp,
2498                                  process_token_list, ARRAY_SIZE(process_token_list),
2499                                  sof_ipc3_widget_bind_event},
2500 };
2501
2502 const struct sof_ipc_tplg_ops ipc3_tplg_ops = {
2503         .widget = tplg_ipc3_widget_ops,
2504         .control = &tplg_ipc3_control_ops,
2505         .route_setup = sof_ipc3_route_setup,
2506         .control_setup = sof_ipc3_control_setup,
2507         .control_free = sof_ipc3_control_free,
2508         .pipeline_complete = sof_ipc3_complete_pipeline,
2509         .token_list = ipc3_token_list,
2510         .widget_free = sof_ipc3_widget_free,
2511         .widget_setup = sof_ipc3_widget_setup,
2512         .dai_config = sof_ipc3_dai_config,
2513         .dai_get_clk = sof_ipc3_dai_get_clk,
2514         .set_up_all_pipelines = sof_ipc3_set_up_all_pipelines,
2515         .tear_down_all_pipelines = sof_ipc3_tear_down_all_pipelines,
2516         .parse_manifest = sof_ipc3_parse_manifest,
2517 };