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