sound/soc/sof/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) 2018 Intel Corporation. All rights reserved.
   7 //
   8 // Author: Liam Girdwood <[email protected]>
   9 //
  10
  11 #include <linux/firmware.h>
  12 #include <linux/workqueue.h>
  13 #include <sound/tlv.h>
  14 #include <sound/pcm_params.h>
  15 #include <uapi/sound/sof/tokens.h>
  16 #include "sof-priv.h"
  17 #include "sof-audio.h"
  18 #include "ops.h"
  19
  20 #define COMP_ID_UNASSIGNED              0xffffffff
  21 /*
  22  * Constants used in the computation of linear volume gain
  23  * from dB gain 20th root of 10 in Q1.16 fixed-point notation
  24  */
  25 #define VOL_TWENTIETH_ROOT_OF_TEN       73533
  26 /* 40th root of 10 in Q1.16 fixed-point notation*/
  27 #define VOL_FORTIETH_ROOT_OF_TEN        69419
  28 /*
  29  * Volume fractional word length define to 16 sets
  30  * the volume linear gain value to use Qx.16 format
  31  */
  32 #define VOLUME_FWL      16
  33 /* 0.5 dB step value in topology TLV */
  34 #define VOL_HALF_DB_STEP        50
  35 /* Full volume for default values */
  36 #define VOL_ZERO_DB     BIT(VOLUME_FWL)
  37
  38 /* TLV data items */
  39 #define TLV_ITEMS       3
  40 #define TLV_MIN         0
  41 #define TLV_STEP        1
  42 #define TLV_MUTE        2
  43
  44 /* size of tplg abi in byte */
  45 #define SOF_TPLG_ABI_SIZE 3
  46
  47 struct sof_widget_data {
  48         int ctrl_type;
  49         int ipc_cmd;
  50         struct sof_abi_hdr *pdata;
  51         struct snd_sof_control *control;
  52 };
  53
  54 /* send pcm params ipc */
  55 static int ipc_pcm_params(struct snd_sof_widget *swidget, int dir)
  56 {
  57         struct sof_ipc_pcm_params_reply ipc_params_reply;
  58         struct snd_soc_component *scomp = swidget->scomp;
  59         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
  60         struct sof_ipc_pcm_params pcm;
  61         struct snd_pcm_hw_params *params;
  62         struct snd_sof_pcm *spcm;
  63         int ret = 0;
  64
  65         memset(&pcm, 0, sizeof(pcm));
  66
  67         /* get runtime PCM params using widget's stream name */
  68         spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
  69         if (!spcm) {
  70                 dev_err(scomp->dev, "error: cannot find PCM for %s\n",
  71                         swidget->widget->name);
  72                 return -EINVAL;
  73         }
  74
  75         params = &spcm->params[dir];
  76
  77         /* set IPC PCM params */
  78         pcm.hdr.size = sizeof(pcm);
  79         pcm.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | SOF_IPC_STREAM_PCM_PARAMS;
  80         pcm.comp_id = swidget->comp_id;
  81         pcm.params.hdr.size = sizeof(pcm.params);
  82         pcm.params.direction = dir;
  83         pcm.params.sample_valid_bytes = params_width(params) >> 3;
  84         pcm.params.buffer_fmt = SOF_IPC_BUFFER_INTERLEAVED;
  85         pcm.params.rate = params_rate(params);
  86         pcm.params.channels = params_channels(params);
  87         pcm.params.host_period_bytes = params_period_bytes(params);
  88
  89         /* set format */
  90         switch (params_format(params)) {
  91         case SNDRV_PCM_FORMAT_S16:
  92                 pcm.params.frame_fmt = SOF_IPC_FRAME_S16_LE;
  93                 break;
  94         case SNDRV_PCM_FORMAT_S24:
  95                 pcm.params.frame_fmt = SOF_IPC_FRAME_S24_4LE;
  96                 break;
  97         case SNDRV_PCM_FORMAT_S32:
  98                 pcm.params.frame_fmt = SOF_IPC_FRAME_S32_LE;
  99                 break;
 100         default:
 101                 return -EINVAL;
 102         }
 103
 104         /* send IPC to the DSP */
 105         ret = sof_ipc_tx_message(sdev->ipc, pcm.hdr.cmd, &pcm, sizeof(pcm),
 106                                  &ipc_params_reply, sizeof(ipc_params_reply));
 107         if (ret < 0)
 108                 dev_err(scomp->dev, "error: pcm params failed for %s\n",
 109                         swidget->widget->name);
 110
 111         return ret;
 112 }
 113
 114  /* send stream trigger ipc */
 115 static int ipc_trigger(struct snd_sof_widget *swidget, int cmd)
 116 {
 117         struct snd_soc_component *scomp = swidget->scomp;
 118         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 119         struct sof_ipc_stream stream;
 120         struct sof_ipc_reply reply;
 121         int ret = 0;
 122
 123         /* set IPC stream params */
 124         stream.hdr.size = sizeof(stream);
 125         stream.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | cmd;
 126         stream.comp_id = swidget->comp_id;
 127
 128         /* send IPC to the DSP */
 129         ret = sof_ipc_tx_message(sdev->ipc, stream.hdr.cmd, &stream,
 130                                  sizeof(stream), &reply, sizeof(reply));
 131         if (ret < 0)
 132                 dev_err(scomp->dev, "error: failed to trigger %s\n",
 133                         swidget->widget->name);
 134
 135         return ret;
 136 }
 137
 138 static int sof_keyword_dapm_event(struct snd_soc_dapm_widget *w,
 139                                   struct snd_kcontrol *k, int event)
 140 {
 141         struct snd_sof_widget *swidget = w->dobj.private;
 142         struct snd_soc_component *scomp;
 143         int stream = SNDRV_PCM_STREAM_CAPTURE;
 144         struct snd_sof_pcm *spcm;
 145         int ret = 0;
 146
 147         if (!swidget)
 148                 return 0;
 149
 150         scomp = swidget->scomp;
 151
 152         dev_dbg(scomp->dev, "received event %d for widget %s\n",
 153                 event, w->name);
 154
 155         /* get runtime PCM params using widget's stream name */
 156         spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
 157         if (!spcm) {
 158                 dev_err(scomp->dev, "error: cannot find PCM for %s\n",
 159                         swidget->widget->name);
 160                 return -EINVAL;
 161         }
 162
 163         /* process events */
 164         switch (event) {
 165         case SND_SOC_DAPM_PRE_PMU:
 166                 if (spcm->stream[stream].suspend_ignored) {
 167                         dev_dbg(scomp->dev, "PRE_PMU event ignored, KWD pipeline is already RUNNING\n");
 168                         return 0;
 169                 }
 170
 171                 /* set pcm params */
 172                 ret = ipc_pcm_params(swidget, stream);
 173                 if (ret < 0) {
 174                         dev_err(scomp->dev,
 175                                 "error: failed to set pcm params for widget %s\n",
 176                                 swidget->widget->name);
 177                         break;
 178                 }
 179
 180                 /* start trigger */
 181                 ret = ipc_trigger(swidget, SOF_IPC_STREAM_TRIG_START);
 182                 if (ret < 0)
 183                         dev_err(scomp->dev,
 184                                 "error: failed to trigger widget %s\n",
 185                                 swidget->widget->name);
 186                 break;
 187         case SND_SOC_DAPM_POST_PMD:
 188                 if (spcm->stream[stream].suspend_ignored) {
 189                         dev_dbg(scomp->dev, "POST_PMD even ignored, KWD pipeline will remain RUNNING\n");
 190                         return 0;
 191                 }
 192
 193                 /* stop trigger */
 194                 ret = ipc_trigger(swidget, SOF_IPC_STREAM_TRIG_STOP);
 195                 if (ret < 0)
 196                         dev_err(scomp->dev,
 197                                 "error: failed to trigger widget %s\n",
 198                                 swidget->widget->name);
 199
 200                 /* pcm free */
 201                 ret = ipc_trigger(swidget, SOF_IPC_STREAM_PCM_FREE);
 202                 if (ret < 0)
 203                         dev_err(scomp->dev,
 204                                 "error: failed to trigger widget %s\n",
 205                                 swidget->widget->name);
 206                 break;
 207         default:
 208                 break;
 209         }
 210
 211         return ret;
 212 }
 213
 214 /* event handlers for keyword detect component */
 215 static const struct snd_soc_tplg_widget_events sof_kwd_events[] = {
 216         {SOF_KEYWORD_DETECT_DAPM_EVENT, sof_keyword_dapm_event},
 217 };
 218
 219 static inline int get_tlv_data(const int *p, int tlv[TLV_ITEMS])
 220 {
 221         /* we only support dB scale TLV type at the moment */
 222         if ((int)p[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
 223                 return -EINVAL;
 224
 225         /* min value in topology tlv data is multiplied by 100 */
 226         tlv[TLV_MIN] = (int)p[SNDRV_CTL_TLVO_DB_SCALE_MIN] / 100;
 227
 228         /* volume steps */
 229         tlv[TLV_STEP] = (int)(p[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] &
 230                                 TLV_DB_SCALE_MASK);
 231
 232         /* mute ON/OFF */
 233         if ((p[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] &
 234                 TLV_DB_SCALE_MUTE) == 0)
 235                 tlv[TLV_MUTE] = 0;
 236         else
 237                 tlv[TLV_MUTE] = 1;
 238
 239         return 0;
 240 }
 241
 242 /*
 243  * Function to truncate an unsigned 64-bit number
 244  * by x bits and return 32-bit unsigned number. This
 245  * function also takes care of rounding while truncating
 246  */
 247 static inline u32 vol_shift_64(u64 i, u32 x)
 248 {
 249         /* do not truncate more than 32 bits */
 250         if (x > 32)
 251                 x = 32;
 252
 253         if (x == 0)
 254                 return (u32)i;
 255
 256         return (u32)(((i >> (x - 1)) + 1) >> 1);
 257 }
 258
 259 /*
 260  * Function to compute a ^ exp where,
 261  * a is a fractional number represented by a fixed-point
 262  * integer with a fractional world length of "fwl"
 263  * exp is an integer
 264  * fwl is the fractional word length
 265  * Return value is a fractional number represented by a
 266  * fixed-point integer with a fractional word length of "fwl"
 267  */
 268 static u32 vol_pow32(u32 a, int exp, u32 fwl)
 269 {
 270         int i, iter;
 271         u32 power = 1 << fwl;
 272         u64 numerator;
 273
 274         /* if exponent is 0, return 1 */
 275         if (exp == 0)
 276                 return power;
 277
 278         /* determine the number of iterations based on the exponent */
 279         if (exp < 0)
 280                 iter = exp * -1;
 281         else
 282                 iter = exp;
 283
 284         /* mutiply a "iter" times to compute power */
 285         for (i = 0; i < iter; i++) {
 286                 /*
 287                  * Product of 2 Qx.fwl fixed-point numbers yields a Q2*x.2*fwl
 288                  * Truncate product back to fwl fractional bits with rounding
 289                  */
 290                 power = vol_shift_64((u64)power * a, fwl);
 291         }
 292
 293         if (exp > 0) {
 294                 /* if exp is positive, return the result */
 295                 return power;
 296         }
 297
 298         /* if exp is negative, return the multiplicative inverse */
 299         numerator = (u64)1 << (fwl << 1);
 300         do_div(numerator, power);
 301
 302         return (u32)numerator;
 303 }
 304
 305 /*
 306  * Function to calculate volume gain from TLV data.
 307  * This function can only handle gain steps that are multiples of 0.5 dB
 308  */
 309 static u32 vol_compute_gain(u32 value, int *tlv)
 310 {
 311         int dB_gain;
 312         u32 linear_gain;
 313         int f_step;
 314
 315         /* mute volume */
 316         if (value == 0 && tlv[TLV_MUTE])
 317                 return 0;
 318
 319         /*
 320          * compute dB gain from tlv. tlv_step
 321          * in topology is multiplied by 100
 322          */
 323         dB_gain = tlv[TLV_MIN] + (value * tlv[TLV_STEP]) / 100;
 324
 325         /*
 326          * compute linear gain represented by fixed-point
 327          * int with VOLUME_FWL fractional bits
 328          */
 329         linear_gain = vol_pow32(VOL_TWENTIETH_ROOT_OF_TEN, dB_gain, VOLUME_FWL);
 330
 331         /* extract the fractional part of volume step */
 332         f_step = tlv[TLV_STEP] - (tlv[TLV_STEP] / 100);
 333
 334         /* if volume step is an odd multiple of 0.5 dB */
 335         if (f_step == VOL_HALF_DB_STEP && (value & 1))
 336                 linear_gain = vol_shift_64((u64)linear_gain *
 337                                                   VOL_FORTIETH_ROOT_OF_TEN,
 338                                                   VOLUME_FWL);
 339
 340         return linear_gain;
 341 }
 342
 343 /*
 344  * Set up volume table for kcontrols from tlv data
 345  * "size" specifies the number of entries in the table
 346  */
 347 static int set_up_volume_table(struct snd_sof_control *scontrol,
 348                                int tlv[TLV_ITEMS], int size)
 349 {
 350         int j;
 351
 352         /* init the volume table */
 353         scontrol->volume_table = kcalloc(size, sizeof(u32), GFP_KERNEL);
 354         if (!scontrol->volume_table)
 355                 return -ENOMEM;
 356
 357         /* populate the volume table */
 358         for (j = 0; j < size ; j++)
 359                 scontrol->volume_table[j] = vol_compute_gain(j, tlv);
 360
 361         return 0;
 362 }
 363
 364 struct sof_dai_types {
 365         const char *name;
 366         enum sof_ipc_dai_type type;
 367 };
 368
 369 static const struct sof_dai_types sof_dais[] = {
 370         {"SSP", SOF_DAI_INTEL_SSP},
 371         {"HDA", SOF_DAI_INTEL_HDA},
 372         {"DMIC", SOF_DAI_INTEL_DMIC},
 373         {"ALH", SOF_DAI_INTEL_ALH},
 374         {"SAI", SOF_DAI_IMX_SAI},
 375         {"ESAI", SOF_DAI_IMX_ESAI},
 376 };
 377
 378 static enum sof_ipc_dai_type find_dai(const char *name)
 379 {
 380         int i;
 381
 382         for (i = 0; i < ARRAY_SIZE(sof_dais); i++) {
 383                 if (strcmp(name, sof_dais[i].name) == 0)
 384                         return sof_dais[i].type;
 385         }
 386
 387         return SOF_DAI_INTEL_NONE;
 388 }
 389
 390 /*
 391  * Supported Frame format types and lookup, add new ones to end of list.
 392  */
 393
 394 struct sof_frame_types {
 395         const char *name;
 396         enum sof_ipc_frame frame;
 397 };
 398
 399 static const struct sof_frame_types sof_frames[] = {
 400         {"s16le", SOF_IPC_FRAME_S16_LE},
 401         {"s24le", SOF_IPC_FRAME_S24_4LE},
 402         {"s32le", SOF_IPC_FRAME_S32_LE},
 403         {"float", SOF_IPC_FRAME_FLOAT},
 404 };
 405
 406 static enum sof_ipc_frame find_format(const char *name)
 407 {
 408         int i;
 409
 410         for (i = 0; i < ARRAY_SIZE(sof_frames); i++) {
 411                 if (strcmp(name, sof_frames[i].name) == 0)
 412                         return sof_frames[i].frame;
 413         }
 414
 415         /* use s32le if nothing is specified */
 416         return SOF_IPC_FRAME_S32_LE;
 417 }
 418
 419 struct sof_process_types {
 420         const char *name;
 421         enum sof_ipc_process_type type;
 422         enum sof_comp_type comp_type;
 423 };
 424
 425 static const struct sof_process_types sof_process[] = {
 426         {"EQFIR", SOF_PROCESS_EQFIR, SOF_COMP_EQ_FIR},
 427         {"EQIIR", SOF_PROCESS_EQIIR, SOF_COMP_EQ_IIR},
 428         {"KEYWORD_DETECT", SOF_PROCESS_KEYWORD_DETECT, SOF_COMP_KEYWORD_DETECT},
 429         {"KPB", SOF_PROCESS_KPB, SOF_COMP_KPB},
 430         {"CHAN_SELECTOR", SOF_PROCESS_CHAN_SELECTOR, SOF_COMP_SELECTOR},
 431         {"MUX", SOF_PROCESS_MUX, SOF_COMP_MUX},
 432         {"DEMUX", SOF_PROCESS_DEMUX, SOF_COMP_DEMUX},
 433         {"DCBLOCK", SOF_PROCESS_DCBLOCK, SOF_COMP_DCBLOCK},
 434         {"SMART_AMP", SOF_PROCESS_SMART_AMP, SOF_COMP_SMART_AMP},
 435 };
 436
 437 static enum sof_ipc_process_type find_process(const char *name)
 438 {
 439         int i;
 440
 441         for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
 442                 if (strcmp(name, sof_process[i].name) == 0)
 443                         return sof_process[i].type;
 444         }
 445
 446         return SOF_PROCESS_NONE;
 447 }
 448
 449 static enum sof_comp_type find_process_comp_type(enum sof_ipc_process_type type)
 450 {
 451         int i;
 452
 453         for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
 454                 if (sof_process[i].type == type)
 455                         return sof_process[i].comp_type;
 456         }
 457
 458         return SOF_COMP_NONE;
 459 }
 460
 461 /*
 462  * Topology Token Parsing.
 463  * New tokens should be added to headers and parsing tables below.
 464  */
 465
 466 struct sof_topology_token {
 467         u32 token;
 468         u32 type;
 469         int (*get_token)(void *elem, void *object, u32 offset, u32 size);
 470         u32 offset;
 471         u32 size;
 472 };
 473
 474 static int get_token_u32(void *elem, void *object, u32 offset, u32 size)
 475 {
 476         struct snd_soc_tplg_vendor_value_elem *velem = elem;
 477         u32 *val = (u32 *)((u8 *)object + offset);
 478
 479         *val = le32_to_cpu(velem->value);
 480         return 0;
 481 }
 482
 483 static int get_token_u16(void *elem, void *object, u32 offset, u32 size)
 484 {
 485         struct snd_soc_tplg_vendor_value_elem *velem = elem;
 486         u16 *val = (u16 *)((u8 *)object + offset);
 487
 488         *val = (u16)le32_to_cpu(velem->value);
 489         return 0;
 490 }
 491
 492 static int get_token_comp_format(void *elem, void *object, u32 offset, u32 size)
 493 {
 494         struct snd_soc_tplg_vendor_string_elem *velem = elem;
 495         u32 *val = (u32 *)((u8 *)object + offset);
 496
 497         *val = find_format(velem->string);
 498         return 0;
 499 }
 500
 501 static int get_token_dai_type(void *elem, void *object, u32 offset, u32 size)
 502 {
 503         struct snd_soc_tplg_vendor_string_elem *velem = elem;
 504         u32 *val = (u32 *)((u8 *)object + offset);
 505
 506         *val = find_dai(velem->string);
 507         return 0;
 508 }
 509
 510 static int get_token_process_type(void *elem, void *object, u32 offset,
 511                                   u32 size)
 512 {
 513         struct snd_soc_tplg_vendor_string_elem *velem = elem;
 514         u32 *val = (u32 *)((u8 *)object + offset);
 515
 516         *val = find_process(velem->string);
 517         return 0;
 518 }
 519
 520 /* Buffers */
 521 static const struct sof_topology_token buffer_tokens[] = {
 522         {SOF_TKN_BUF_SIZE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 523                 offsetof(struct sof_ipc_buffer, size), 0},
 524         {SOF_TKN_BUF_CAPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 525                 offsetof(struct sof_ipc_buffer, caps), 0},
 526 };
 527
 528 /* DAI */
 529 static const struct sof_topology_token dai_tokens[] = {
 530         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
 531                 offsetof(struct sof_ipc_comp_dai, type), 0},
 532         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 533                 offsetof(struct sof_ipc_comp_dai, dai_index), 0},
 534         {SOF_TKN_DAI_DIRECTION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 535                 offsetof(struct sof_ipc_comp_dai, direction), 0},
 536 };
 537
 538 /* BE DAI link */
 539 static const struct sof_topology_token dai_link_tokens[] = {
 540         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
 541                 offsetof(struct sof_ipc_dai_config, type), 0},
 542         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 543                 offsetof(struct sof_ipc_dai_config, dai_index), 0},
 544 };
 545
 546 /* scheduling */
 547 static const struct sof_topology_token sched_tokens[] = {
 548         {SOF_TKN_SCHED_PERIOD, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 549                 offsetof(struct sof_ipc_pipe_new, period), 0},
 550         {SOF_TKN_SCHED_PRIORITY, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 551                 offsetof(struct sof_ipc_pipe_new, priority), 0},
 552         {SOF_TKN_SCHED_MIPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 553                 offsetof(struct sof_ipc_pipe_new, period_mips), 0},
 554         {SOF_TKN_SCHED_CORE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 555                 offsetof(struct sof_ipc_pipe_new, core), 0},
 556         {SOF_TKN_SCHED_FRAMES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 557                 offsetof(struct sof_ipc_pipe_new, frames_per_sched), 0},
 558         {SOF_TKN_SCHED_TIME_DOMAIN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 559                 offsetof(struct sof_ipc_pipe_new, time_domain), 0},
 560 };
 561
 562 /* volume */
 563 static const struct sof_topology_token volume_tokens[] = {
 564         {SOF_TKN_VOLUME_RAMP_STEP_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 565                 get_token_u32, offsetof(struct sof_ipc_comp_volume, ramp), 0},
 566         {SOF_TKN_VOLUME_RAMP_STEP_MS,
 567                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 568                 offsetof(struct sof_ipc_comp_volume, initial_ramp), 0},
 569 };
 570
 571 /* SRC */
 572 static const struct sof_topology_token src_tokens[] = {
 573         {SOF_TKN_SRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 574                 offsetof(struct sof_ipc_comp_src, source_rate), 0},
 575         {SOF_TKN_SRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 576                 offsetof(struct sof_ipc_comp_src, sink_rate), 0},
 577 };
 578
 579 /* ASRC */
 580 static const struct sof_topology_token asrc_tokens[] = {
 581         {SOF_TKN_ASRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 582                 offsetof(struct sof_ipc_comp_asrc, source_rate), 0},
 583         {SOF_TKN_ASRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 584                 offsetof(struct sof_ipc_comp_asrc, sink_rate), 0},
 585         {SOF_TKN_ASRC_ASYNCHRONOUS_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 586                 get_token_u32,
 587                 offsetof(struct sof_ipc_comp_asrc, asynchronous_mode), 0},
 588         {SOF_TKN_ASRC_OPERATION_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 589                 get_token_u32,
 590                 offsetof(struct sof_ipc_comp_asrc, operation_mode), 0},
 591 };
 592
 593 /* Tone */
 594 static const struct sof_topology_token tone_tokens[] = {
 595 };
 596
 597 /* EFFECT */
 598 static const struct sof_topology_token process_tokens[] = {
 599         {SOF_TKN_PROCESS_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING,
 600                 get_token_process_type,
 601                 offsetof(struct sof_ipc_comp_process, type), 0},
 602 };
 603
 604 /* PCM */
 605 static const struct sof_topology_token pcm_tokens[] = {
 606         {SOF_TKN_PCM_DMAC_CONFIG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 607                 offsetof(struct sof_ipc_comp_host, dmac_config), 0},
 608 };
 609
 610 /* PCM */
 611 static const struct sof_topology_token stream_tokens[] = {
 612         {SOF_TKN_STREAM_PLAYBACK_COMPATIBLE_D0I3,
 613                 SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
 614                 offsetof(struct snd_sof_pcm, stream[0].d0i3_compatible), 0},
 615         {SOF_TKN_STREAM_CAPTURE_COMPATIBLE_D0I3,
 616                 SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
 617                 offsetof(struct snd_sof_pcm, stream[1].d0i3_compatible), 0},
 618 };
 619
 620 /* Generic components */
 621 static const struct sof_topology_token comp_tokens[] = {
 622         {SOF_TKN_COMP_PERIOD_SINK_COUNT,
 623                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 624                 offsetof(struct sof_ipc_comp_config, periods_sink), 0},
 625         {SOF_TKN_COMP_PERIOD_SOURCE_COUNT,
 626                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 627                 offsetof(struct sof_ipc_comp_config, periods_source), 0},
 628         {SOF_TKN_COMP_FORMAT,
 629                 SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_comp_format,
 630                 offsetof(struct sof_ipc_comp_config, frame_fmt), 0},
 631 };
 632
 633 /* SSP */
 634 static const struct sof_topology_token ssp_tokens[] = {
 635         {SOF_TKN_INTEL_SSP_CLKS_CONTROL,
 636                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 637                 offsetof(struct sof_ipc_dai_ssp_params, clks_control), 0},
 638         {SOF_TKN_INTEL_SSP_MCLK_ID,
 639                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 640                 offsetof(struct sof_ipc_dai_ssp_params, mclk_id), 0},
 641         {SOF_TKN_INTEL_SSP_SAMPLE_BITS, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 642                 get_token_u32,
 643                 offsetof(struct sof_ipc_dai_ssp_params, sample_valid_bits), 0},
 644         {SOF_TKN_INTEL_SSP_FRAME_PULSE_WIDTH, SND_SOC_TPLG_TUPLE_TYPE_SHORT,
 645                 get_token_u16,
 646                 offsetof(struct sof_ipc_dai_ssp_params, frame_pulse_width), 0},
 647         {SOF_TKN_INTEL_SSP_QUIRKS, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 648                 get_token_u32,
 649                 offsetof(struct sof_ipc_dai_ssp_params, quirks), 0},
 650         {SOF_TKN_INTEL_SSP_TDM_PADDING_PER_SLOT, SND_SOC_TPLG_TUPLE_TYPE_BOOL,
 651                 get_token_u16,
 652                 offsetof(struct sof_ipc_dai_ssp_params,
 653                          tdm_per_slot_padding_flag), 0},
 654         {SOF_TKN_INTEL_SSP_BCLK_DELAY, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 655                 get_token_u32,
 656                 offsetof(struct sof_ipc_dai_ssp_params, bclk_delay), 0},
 657
 658 };
 659
 660 /* ALH */
 661 static const struct sof_topology_token alh_tokens[] = {
 662         {SOF_TKN_INTEL_ALH_RATE,
 663                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 664                 offsetof(struct sof_ipc_dai_alh_params, rate), 0},
 665         {SOF_TKN_INTEL_ALH_CH,
 666                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 667                 offsetof(struct sof_ipc_dai_alh_params, channels), 0},
 668 };
 669
 670 /* DMIC */
 671 static const struct sof_topology_token dmic_tokens[] = {
 672         {SOF_TKN_INTEL_DMIC_DRIVER_VERSION,
 673                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 674                 offsetof(struct sof_ipc_dai_dmic_params, driver_ipc_version),
 675                 0},
 676         {SOF_TKN_INTEL_DMIC_CLK_MIN,
 677                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 678                 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_min), 0},
 679         {SOF_TKN_INTEL_DMIC_CLK_MAX,
 680                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 681                 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_max), 0},
 682         {SOF_TKN_INTEL_DMIC_SAMPLE_RATE,
 683                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 684                 offsetof(struct sof_ipc_dai_dmic_params, fifo_fs), 0},
 685         {SOF_TKN_INTEL_DMIC_DUTY_MIN,
 686                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 687                 offsetof(struct sof_ipc_dai_dmic_params, duty_min), 0},
 688         {SOF_TKN_INTEL_DMIC_DUTY_MAX,
 689                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 690                 offsetof(struct sof_ipc_dai_dmic_params, duty_max), 0},
 691         {SOF_TKN_INTEL_DMIC_NUM_PDM_ACTIVE,
 692                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 693                 offsetof(struct sof_ipc_dai_dmic_params,
 694                          num_pdm_active), 0},
 695         {SOF_TKN_INTEL_DMIC_FIFO_WORD_LENGTH,
 696                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 697                 offsetof(struct sof_ipc_dai_dmic_params, fifo_bits), 0},
 698         {SOF_TKN_INTEL_DMIC_UNMUTE_RAMP_TIME_MS,
 699                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 700                 offsetof(struct sof_ipc_dai_dmic_params, unmute_ramp_time), 0},
 701
 702 };
 703
 704 /* ESAI */
 705 static const struct sof_topology_token esai_tokens[] = {
 706         {SOF_TKN_IMX_ESAI_MCLK_ID,
 707                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 708                 offsetof(struct sof_ipc_dai_esai_params, mclk_id), 0},
 709 };
 710
 711 /* SAI */
 712 static const struct sof_topology_token sai_tokens[] = {
 713         {SOF_TKN_IMX_SAI_MCLK_ID,
 714                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 715                 offsetof(struct sof_ipc_dai_sai_params, mclk_id), 0},
 716 };
 717
 718 /*
 719  * DMIC PDM Tokens
 720  * SOF_TKN_INTEL_DMIC_PDM_CTRL_ID should be the first token
 721  * as it increments the index while parsing the array of pdm tokens
 722  * and determines the correct offset
 723  */
 724 static const struct sof_topology_token dmic_pdm_tokens[] = {
 725         {SOF_TKN_INTEL_DMIC_PDM_CTRL_ID,
 726                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 727                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, id),
 728                 0},
 729         {SOF_TKN_INTEL_DMIC_PDM_MIC_A_Enable,
 730                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 731                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_a),
 732                 0},
 733         {SOF_TKN_INTEL_DMIC_PDM_MIC_B_Enable,
 734                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 735                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_b),
 736                 0},
 737         {SOF_TKN_INTEL_DMIC_PDM_POLARITY_A,
 738                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 739                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_a),
 740                 0},
 741         {SOF_TKN_INTEL_DMIC_PDM_POLARITY_B,
 742                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 743                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_b),
 744                 0},
 745         {SOF_TKN_INTEL_DMIC_PDM_CLK_EDGE,
 746                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 747                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, clk_edge),
 748                 0},
 749         {SOF_TKN_INTEL_DMIC_PDM_SKEW,
 750                 SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
 751                 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, skew),
 752                 0},
 753 };
 754
 755 /* HDA */
 756 static const struct sof_topology_token hda_tokens[] = {
 757         {SOF_TKN_INTEL_HDA_RATE,
 758                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 759                 offsetof(struct sof_ipc_dai_hda_params, rate), 0},
 760         {SOF_TKN_INTEL_HDA_CH,
 761                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 762                 offsetof(struct sof_ipc_dai_hda_params, channels), 0},
 763 };
 764
 765 /* Leds */
 766 static const struct sof_topology_token led_tokens[] = {
 767         {SOF_TKN_MUTE_LED_USE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 768          offsetof(struct snd_sof_led_control, use_led), 0},
 769         {SOF_TKN_MUTE_LED_DIRECTION, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 770          get_token_u32, offsetof(struct snd_sof_led_control, direction), 0},
 771 };
 772
 773 static int sof_parse_uuid_tokens(struct snd_soc_component *scomp,
 774                                  void *object,
 775                                  const struct sof_topology_token *tokens,
 776                                  int count,
 777                                  struct snd_soc_tplg_vendor_array *array,
 778                                  size_t offset)
 779 {
 780         struct snd_soc_tplg_vendor_uuid_elem *elem;
 781         int found = 0;
 782         int i, j;
 783
 784         /* parse element by element */
 785         for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
 786                 elem = &array->uuid[i];
 787
 788                 /* search for token */
 789                 for (j = 0; j < count; j++) {
 790                         /* match token type */
 791                         if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_UUID)
 792                                 continue;
 793
 794                         /* match token id */
 795                         if (tokens[j].token != le32_to_cpu(elem->token))
 796                                 continue;
 797
 798                         /* matched - now load token */
 799                         tokens[j].get_token(elem, object,
 800                                             offset + tokens[j].offset,
 801                                             tokens[j].size);
 802
 803                         found++;
 804                 }
 805         }
 806
 807         return found;
 808 }
 809
 810 static int sof_parse_string_tokens(struct snd_soc_component *scomp,
 811                                    void *object,
 812                                    const struct sof_topology_token *tokens,
 813                                    int count,
 814                                    struct snd_soc_tplg_vendor_array *array,
 815                                    size_t offset)
 816 {
 817         struct snd_soc_tplg_vendor_string_elem *elem;
 818         int found = 0;
 819         int i, j;
 820
 821         /* parse element by element */
 822         for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
 823                 elem = &array->string[i];
 824
 825                 /* search for token */
 826                 for (j = 0; j < count; j++) {
 827                         /* match token type */
 828                         if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_STRING)
 829                                 continue;
 830
 831                         /* match token id */
 832                         if (tokens[j].token != le32_to_cpu(elem->token))
 833                                 continue;
 834
 835                         /* matched - now load token */
 836                         tokens[j].get_token(elem, object,
 837                                             offset + tokens[j].offset,
 838                                             tokens[j].size);
 839
 840                         found++;
 841                 }
 842         }
 843
 844         return found;
 845 }
 846
 847 static int sof_parse_word_tokens(struct snd_soc_component *scomp,
 848                                  void *object,
 849                                  const struct sof_topology_token *tokens,
 850                                  int count,
 851                                  struct snd_soc_tplg_vendor_array *array,
 852                                  size_t offset)
 853 {
 854         struct snd_soc_tplg_vendor_value_elem *elem;
 855         int found = 0;
 856         int i, j;
 857
 858         /* parse element by element */
 859         for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
 860                 elem = &array->value[i];
 861
 862                 /* search for token */
 863                 for (j = 0; j < count; j++) {
 864                         /* match token type */
 865                         if (!(tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_WORD ||
 866                               tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_SHORT ||
 867                               tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BYTE ||
 868                               tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BOOL))
 869                                 continue;
 870
 871                         /* match token id */
 872                         if (tokens[j].token != le32_to_cpu(elem->token))
 873                                 continue;
 874
 875                         /* load token */
 876                         tokens[j].get_token(elem, object,
 877                                             offset + tokens[j].offset,
 878                                             tokens[j].size);
 879
 880                         found++;
 881                 }
 882         }
 883
 884         return found;
 885 }
 886
 887 /**
 888  * sof_parse_token_sets - Parse multiple sets of tokens
 889  * @scomp: pointer to soc component
 890  * @object: target ipc struct for parsed values
 891  * @tokens: token definition array describing what tokens to parse
 892  * @count: number of tokens in definition array
 893  * @array: source pointer to consecutive vendor arrays to be parsed
 894  * @priv_size: total size of the consecutive source arrays
 895  * @sets: number of similar token sets to be parsed, 1 set has count elements
 896  * @object_size: offset to next target ipc struct with multiple sets
 897  *
 898  * This function parses multiple sets of tokens in vendor arrays into
 899  * consecutive ipc structs.
 900  */
 901 static int sof_parse_token_sets(struct snd_soc_component *scomp,
 902                                 void *object,
 903                                 const struct sof_topology_token *tokens,
 904                                 int count,
 905                                 struct snd_soc_tplg_vendor_array *array,
 906                                 int priv_size, int sets, size_t object_size)
 907 {
 908         size_t offset = 0;
 909         int found = 0;
 910         int total = 0;
 911         int asize;
 912
 913         while (priv_size > 0 && total < count * sets) {
 914                 asize = le32_to_cpu(array->size);
 915
 916                 /* validate asize */
 917                 if (asize < 0) { /* FIXME: A zero-size array makes no sense */
 918                         dev_err(scomp->dev, "error: invalid array size 0x%x\n",
 919                                 asize);
 920                         return -EINVAL;
 921                 }
 922
 923                 /* make sure there is enough data before parsing */
 924                 priv_size -= asize;
 925                 if (priv_size < 0) {
 926                         dev_err(scomp->dev, "error: invalid array size 0x%x\n",
 927                                 asize);
 928                         return -EINVAL;
 929                 }
 930
 931                 /* call correct parser depending on type */
 932                 switch (le32_to_cpu(array->type)) {
 933                 case SND_SOC_TPLG_TUPLE_TYPE_UUID:
 934                         found += sof_parse_uuid_tokens(scomp, object, tokens,
 935                                                        count, array, offset);
 936                         break;
 937                 case SND_SOC_TPLG_TUPLE_TYPE_STRING:
 938                         found += sof_parse_string_tokens(scomp, object, tokens,
 939                                                          count, array, offset);
 940                         break;
 941                 case SND_SOC_TPLG_TUPLE_TYPE_BOOL:
 942                 case SND_SOC_TPLG_TUPLE_TYPE_BYTE:
 943                 case SND_SOC_TPLG_TUPLE_TYPE_WORD:
 944                 case SND_SOC_TPLG_TUPLE_TYPE_SHORT:
 945                         found += sof_parse_word_tokens(scomp, object, tokens,
 946                                                        count, array, offset);
 947                         break;
 948                 default:
 949                         dev_err(scomp->dev, "error: unknown token type %d\n",
 950                                 array->type);
 951                         return -EINVAL;
 952                 }
 953
 954                 /* next array */
 955                 array = (struct snd_soc_tplg_vendor_array *)((u8 *)array
 956                         + asize);
 957
 958                 /* move to next target struct */
 959                 if (found >= count) {
 960                         offset += object_size;
 961                         total += found;
 962                         found = 0;
 963                 }
 964         }
 965
 966         return 0;
 967 }
 968
 969 static int sof_parse_tokens(struct snd_soc_component *scomp,
 970                             void *object,
 971                             const struct sof_topology_token *tokens,
 972                             int count,
 973                             struct snd_soc_tplg_vendor_array *array,
 974                             int priv_size)
 975 {
 976         /*
 977          * sof_parse_tokens is used when topology contains only a single set of
 978          * identical tuples arrays. So additional parameters to
 979          * sof_parse_token_sets are sets = 1 (only 1 set) and
 980          * object_size = 0 (irrelevant).
 981          */
 982         return sof_parse_token_sets(scomp, object, tokens, count, array,
 983                                     priv_size, 1, 0);
 984 }
 985
 986 static void sof_dbg_comp_config(struct snd_soc_component *scomp,
 987                                 struct sof_ipc_comp_config *config)
 988 {
 989         dev_dbg(scomp->dev, " config: periods snk %d src %d fmt %d\n",
 990                 config->periods_sink, config->periods_source,
 991                 config->frame_fmt);
 992 }
 993
 994 /*
 995  * Standard Kcontrols.
 996  */
 997
 998 static int sof_control_load_volume(struct snd_soc_component *scomp,
 999                                    struct snd_sof_control *scontrol,
1000                                    struct snd_kcontrol_new *kc,
1001                                    struct snd_soc_tplg_ctl_hdr *hdr)
1002 {
1003         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1004         struct snd_soc_tplg_mixer_control *mc =
1005                 container_of(hdr, struct snd_soc_tplg_mixer_control, hdr);
1006         struct sof_ipc_ctrl_data *cdata;
1007         int tlv[TLV_ITEMS];
1008         unsigned int i;
1009         int ret = 0;
1010
1011         /* validate topology data */
1012         if (le32_to_cpu(mc->num_channels) > SND_SOC_TPLG_MAX_CHAN) {
1013                 ret = -EINVAL;
1014                 goto out;
1015         }
1016
1017         /* init the volume get/put data */
1018         scontrol->size = struct_size(scontrol->control_data, chanv,
1019                                      le32_to_cpu(mc->num_channels));
1020         scontrol->control_data = kzalloc(scontrol->size, GFP_KERNEL);
1021         if (!scontrol->control_data) {
1022                 ret = -ENOMEM;
1023                 goto out;
1024         }
1025
1026         scontrol->comp_id = sdev->next_comp_id;
1027         scontrol->min_volume_step = le32_to_cpu(mc->min);
1028         scontrol->max_volume_step = le32_to_cpu(mc->max);
1029         scontrol->num_channels = le32_to_cpu(mc->num_channels);
1030
1031         /* set cmd for mixer control */
1032         if (le32_to_cpu(mc->max) == 1) {
1033                 scontrol->cmd = SOF_CTRL_CMD_SWITCH;
1034                 goto skip;
1035         }
1036
1037         scontrol->cmd = SOF_CTRL_CMD_VOLUME;
1038
1039         /* extract tlv data */
1040         if (get_tlv_data(kc->tlv.p, tlv) < 0) {
1041                 dev_err(scomp->dev, "error: invalid TLV data\n");
1042                 ret = -EINVAL;
1043                 goto out_free;
1044         }
1045
1046         /* set up volume table */
1047         ret = set_up_volume_table(scontrol, tlv, le32_to_cpu(mc->max) + 1);
1048         if (ret < 0) {
1049                 dev_err(scomp->dev, "error: setting up volume table\n");
1050                 goto out_free;
1051         }
1052
1053         /* set default volume values to 0dB in control */
1054         cdata = scontrol->control_data;
1055         for (i = 0; i < scontrol->num_channels; i++) {
1056                 cdata->chanv[i].channel = i;
1057                 cdata->chanv[i].value = VOL_ZERO_DB;
1058         }
1059
1060 skip:
1061         /* set up possible led control from mixer private data */
1062         ret = sof_parse_tokens(scomp, &scontrol->led_ctl, led_tokens,
1063                                ARRAY_SIZE(led_tokens), mc->priv.array,
1064                                le32_to_cpu(mc->priv.size));
1065         if (ret != 0) {
1066                 dev_err(scomp->dev, "error: parse led tokens failed %d\n",
1067                         le32_to_cpu(mc->priv.size));
1068                 goto out_free_table;
1069         }
1070
1071         dev_dbg(scomp->dev, "tplg: load kcontrol index %d chans %d\n",
1072                 scontrol->comp_id, scontrol->num_channels);
1073
1074         return ret;
1075
1076 out_free_table:
1077         if (le32_to_cpu(mc->max) > 1)
1078                 kfree(scontrol->volume_table);
1079 out_free:
1080         kfree(scontrol->control_data);
1081 out:
1082         return ret;
1083 }
1084
1085 static int sof_control_load_enum(struct snd_soc_component *scomp,
1086                                  struct snd_sof_control *scontrol,
1087                                  struct snd_kcontrol_new *kc,
1088                                  struct snd_soc_tplg_ctl_hdr *hdr)
1089 {
1090         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1091         struct snd_soc_tplg_enum_control *ec =
1092                 container_of(hdr, struct snd_soc_tplg_enum_control, hdr);
1093
1094         /* validate topology data */
1095         if (le32_to_cpu(ec->num_channels) > SND_SOC_TPLG_MAX_CHAN)
1096                 return -EINVAL;
1097
1098         /* init the enum get/put data */
1099         scontrol->size = struct_size(scontrol->control_data, chanv,
1100                                      le32_to_cpu(ec->num_channels));
1101         scontrol->control_data = kzalloc(scontrol->size, GFP_KERNEL);
1102         if (!scontrol->control_data)
1103                 return -ENOMEM;
1104
1105         scontrol->comp_id = sdev->next_comp_id;
1106         scontrol->num_channels = le32_to_cpu(ec->num_channels);
1107
1108         scontrol->cmd = SOF_CTRL_CMD_ENUM;
1109
1110         dev_dbg(scomp->dev, "tplg: load kcontrol index %d chans %d comp_id %d\n",
1111                 scontrol->comp_id, scontrol->num_channels, scontrol->comp_id);
1112
1113         return 0;
1114 }
1115
1116 static int sof_control_load_bytes(struct snd_soc_component *scomp,
1117                                   struct snd_sof_control *scontrol,
1118                                   struct snd_kcontrol_new *kc,
1119                                   struct snd_soc_tplg_ctl_hdr *hdr)
1120 {
1121         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1122         struct sof_ipc_ctrl_data *cdata;
1123         struct snd_soc_tplg_bytes_control *control =
1124                 container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
1125         struct soc_bytes_ext *sbe = (struct soc_bytes_ext *)kc->private_value;
1126         int max_size = sbe->max;
1127         int ret = 0;
1128
1129         /* init the get/put bytes data */
1130         scontrol->size = sizeof(struct sof_ipc_ctrl_data) +
1131                 le32_to_cpu(control->priv.size);
1132
1133         if (scontrol->size > max_size) {
1134                 dev_err(scomp->dev, "err: bytes data size %d exceeds max %d.\n",
1135                         scontrol->size, max_size);
1136                 ret = -EINVAL;
1137                 goto out;
1138         }
1139
1140         scontrol->control_data = kzalloc(max_size, GFP_KERNEL);
1141         cdata = scontrol->control_data;
1142         if (!scontrol->control_data) {
1143                 ret = -ENOMEM;
1144                 goto out;
1145         }
1146
1147         scontrol->comp_id = sdev->next_comp_id;
1148         scontrol->cmd = SOF_CTRL_CMD_BINARY;
1149
1150         dev_dbg(scomp->dev, "tplg: load kcontrol index %d chans %d\n",
1151                 scontrol->comp_id, scontrol->num_channels);
1152
1153         if (le32_to_cpu(control->priv.size) > 0) {
1154                 memcpy(cdata->data, control->priv.data,
1155                        le32_to_cpu(control->priv.size));
1156
1157                 if (cdata->data->magic != SOF_ABI_MAGIC) {
1158                         dev_err(scomp->dev, "error: Wrong ABI magic 0x%08x.\n",
1159                                 cdata->data->magic);
1160                         ret = -EINVAL;
1161                         goto out_free;
1162                 }
1163                 if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION,
1164                                                  cdata->data->abi)) {
1165                         dev_err(scomp->dev,
1166                                 "error: Incompatible ABI version 0x%08x.\n",
1167                                 cdata->data->abi);
1168                         ret = -EINVAL;
1169                         goto out_free;
1170                 }
1171                 if (cdata->data->size + sizeof(const struct sof_abi_hdr) !=
1172                     le32_to_cpu(control->priv.size)) {
1173                         dev_err(scomp->dev,
1174                                 "error: Conflict in bytes vs. priv size.\n");
1175                         ret = -EINVAL;
1176                         goto out_free;
1177                 }
1178         }
1179
1180         return ret;
1181
1182 out_free:
1183         kfree(scontrol->control_data);
1184 out:
1185         return ret;
1186 }
1187
1188 /* external kcontrol init - used for any driver specific init */
1189 static int sof_control_load(struct snd_soc_component *scomp, int index,
1190                             struct snd_kcontrol_new *kc,
1191                             struct snd_soc_tplg_ctl_hdr *hdr)
1192 {
1193         struct soc_mixer_control *sm;
1194         struct soc_bytes_ext *sbe;
1195         struct soc_enum *se;
1196         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1197         struct snd_soc_dobj *dobj;
1198         struct snd_sof_control *scontrol;
1199         int ret = -EINVAL;
1200
1201         dev_dbg(scomp->dev, "tplg: load control type %d name : %s\n",
1202                 hdr->type, hdr->name);
1203
1204         scontrol = kzalloc(sizeof(*scontrol), GFP_KERNEL);
1205         if (!scontrol)
1206                 return -ENOMEM;
1207
1208         scontrol->scomp = scomp;
1209
1210         switch (le32_to_cpu(hdr->ops.info)) {
1211         case SND_SOC_TPLG_CTL_VOLSW:
1212         case SND_SOC_TPLG_CTL_VOLSW_SX:
1213         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1214                 sm = (struct soc_mixer_control *)kc->private_value;
1215                 dobj = &sm->dobj;
1216                 ret = sof_control_load_volume(scomp, scontrol, kc, hdr);
1217                 break;
1218         case SND_SOC_TPLG_CTL_BYTES:
1219                 sbe = (struct soc_bytes_ext *)kc->private_value;
1220                 dobj = &sbe->dobj;
1221                 ret = sof_control_load_bytes(scomp, scontrol, kc, hdr);
1222                 break;
1223         case SND_SOC_TPLG_CTL_ENUM:
1224         case SND_SOC_TPLG_CTL_ENUM_VALUE:
1225                 se = (struct soc_enum *)kc->private_value;
1226                 dobj = &se->dobj;
1227                 ret = sof_control_load_enum(scomp, scontrol, kc, hdr);
1228                 break;
1229         case SND_SOC_TPLG_CTL_RANGE:
1230         case SND_SOC_TPLG_CTL_STROBE:
1231         case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1232         case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1233         case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1234         case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1235         case SND_SOC_TPLG_DAPM_CTL_PIN:
1236         default:
1237                 dev_warn(scomp->dev, "control type not supported %d:%d:%d\n",
1238                          hdr->ops.get, hdr->ops.put, hdr->ops.info);
1239                 kfree(scontrol);
1240                 return 0;
1241         }
1242
1243         if (ret < 0) {
1244                 kfree(scontrol);
1245                 return ret;
1246         }
1247
1248         scontrol->led_ctl.led_value = -1;
1249
1250         dobj->private = scontrol;
1251         list_add(&scontrol->list, &sdev->kcontrol_list);
1252         return ret;
1253 }
1254
1255 static int sof_control_unload(struct snd_soc_component *scomp,
1256                               struct snd_soc_dobj *dobj)
1257 {
1258         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1259         struct sof_ipc_free fcomp;
1260         struct snd_sof_control *scontrol = dobj->private;
1261
1262         dev_dbg(scomp->dev, "tplg: unload control name : %s\n", scomp->name);
1263
1264         fcomp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_FREE;
1265         fcomp.hdr.size = sizeof(fcomp);
1266         fcomp.id = scontrol->comp_id;
1267
1268         kfree(scontrol->control_data);
1269         list_del(&scontrol->list);
1270         kfree(scontrol);
1271         /* send IPC to the DSP */
1272         return sof_ipc_tx_message(sdev->ipc,
1273                                   fcomp.hdr.cmd, &fcomp, sizeof(fcomp),
1274                                   NULL, 0);
1275 }
1276
1277 /*
1278  * DAI Topology
1279  */
1280
1281 static int sof_connect_dai_widget(struct snd_soc_component *scomp,
1282                                   struct snd_soc_dapm_widget *w,
1283                                   struct snd_soc_tplg_dapm_widget *tw,
1284                                   struct snd_sof_dai *dai)
1285 {
1286         struct snd_soc_card *card = scomp->card;
1287         struct snd_soc_pcm_runtime *rtd;
1288         struct snd_soc_dai *cpu_dai;
1289         int i;
1290
1291         list_for_each_entry(rtd, &card->rtd_list, list) {
1292                 dev_vdbg(scomp->dev, "tplg: check widget: %s stream: %s dai stream: %s\n",
1293                          w->name,  w->sname, rtd->dai_link->stream_name);
1294
1295                 if (!w->sname || !rtd->dai_link->stream_name)
1296                         continue;
1297
1298                 /* does stream match DAI link ? */
1299                 if (strcmp(w->sname, rtd->dai_link->stream_name))
1300                         continue;
1301
1302                 switch (w->id) {
1303                 case snd_soc_dapm_dai_out:
1304                         for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1305                                 /*
1306                                  * Please create DAI widget in the right order
1307                                  * to ensure BE will connect to the right DAI
1308                                  * widget.
1309                                  */
1310                                 if (!cpu_dai->capture_widget) {
1311                                         cpu_dai->capture_widget = w;
1312                                         break;
1313                                 }
1314                         }
1315                         if (i == rtd->num_cpus) {
1316                                 dev_err(scomp->dev, "error: can't find BE for DAI %s\n",
1317                                         w->name);
1318
1319                                 return -EINVAL;
1320                         }
1321                         dai->name = rtd->dai_link->name;
1322                         dev_dbg(scomp->dev, "tplg: connected widget %s -> DAI link %s\n",
1323                                 w->name, rtd->dai_link->name);
1324                         break;
1325                 case snd_soc_dapm_dai_in:
1326                         for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1327                                 /*
1328                                  * Please create DAI widget in the right order
1329                                  * to ensure BE will connect to the right DAI
1330                                  * widget.
1331                                  */
1332                                 if (!cpu_dai->playback_widget) {
1333                                         cpu_dai->playback_widget = w;
1334                                         break;
1335                                 }
1336                         }
1337                         if (i == rtd->num_cpus) {
1338                                 dev_err(scomp->dev, "error: can't find BE for DAI %s\n",
1339                                         w->name);
1340
1341                                 return -EINVAL;
1342                         }
1343                         dai->name = rtd->dai_link->name;
1344                         dev_dbg(scomp->dev, "tplg: connected widget %s -> DAI link %s\n",
1345                                 w->name, rtd->dai_link->name);
1346                         break;
1347                 default:
1348                         break;
1349                 }
1350         }
1351
1352         /* check we have a connection */
1353         if (!dai->name) {
1354                 dev_err(scomp->dev, "error: can't connect DAI %s stream %s\n",
1355                         w->name, w->sname);
1356                 return -EINVAL;
1357         }
1358
1359         return 0;
1360 }
1361
1362 static int sof_widget_load_dai(struct snd_soc_component *scomp, int index,
1363                                struct snd_sof_widget *swidget,
1364                                struct snd_soc_tplg_dapm_widget *tw,
1365                                struct sof_ipc_comp_reply *r,
1366                                struct snd_sof_dai *dai)
1367 {
1368         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1369         struct snd_soc_tplg_private *private = &tw->priv;
1370         struct sof_ipc_comp_dai comp_dai;
1371         int ret;
1372
1373         /* configure dai IPC message */
1374         memset(&comp_dai, 0, sizeof(comp_dai));
1375         comp_dai.comp.hdr.size = sizeof(comp_dai);
1376         comp_dai.comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1377         comp_dai.comp.id = swidget->comp_id;
1378         comp_dai.comp.type = SOF_COMP_DAI;
1379         comp_dai.comp.pipeline_id = index;
1380         comp_dai.config.hdr.size = sizeof(comp_dai.config);
1381
1382         ret = sof_parse_tokens(scomp, &comp_dai, dai_tokens,
1383                                ARRAY_SIZE(dai_tokens), private->array,
1384                                le32_to_cpu(private->size));
1385         if (ret != 0) {
1386                 dev_err(scomp->dev, "error: parse dai tokens failed %d\n",
1387                         le32_to_cpu(private->size));
1388                 return ret;
1389         }
1390
1391         ret = sof_parse_tokens(scomp, &comp_dai.config, comp_tokens,
1392                                ARRAY_SIZE(comp_tokens), private->array,
1393                                le32_to_cpu(private->size));
1394         if (ret != 0) {
1395                 dev_err(scomp->dev, "error: parse dai.cfg tokens failed %d\n",
1396                         private->size);
1397                 return ret;
1398         }
1399
1400         dev_dbg(scomp->dev, "dai %s: type %d index %d\n",
1401                 swidget->widget->name, comp_dai.type, comp_dai.dai_index);
1402         sof_dbg_comp_config(scomp, &comp_dai.config);
1403
1404         ret = sof_ipc_tx_message(sdev->ipc, comp_dai.comp.hdr.cmd,
1405                                  &comp_dai, sizeof(comp_dai), r, sizeof(*r));
1406
1407         if (ret == 0 && dai) {
1408                 dai->scomp = scomp;
1409                 memcpy(&dai->comp_dai, &comp_dai, sizeof(comp_dai));
1410         }
1411
1412         return ret;
1413 }
1414
1415 /*
1416  * Buffer topology
1417  */
1418
1419 static int sof_widget_load_buffer(struct snd_soc_component *scomp, int index,
1420                                   struct snd_sof_widget *swidget,
1421                                   struct snd_soc_tplg_dapm_widget *tw,
1422                                   struct sof_ipc_comp_reply *r)
1423 {
1424         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1425         struct snd_soc_tplg_private *private = &tw->priv;
1426         struct sof_ipc_buffer *buffer;
1427         int ret;
1428
1429         buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
1430         if (!buffer)
1431                 return -ENOMEM;
1432
1433         /* configure dai IPC message */
1434         buffer->comp.hdr.size = sizeof(*buffer);
1435         buffer->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_BUFFER_NEW;
1436         buffer->comp.id = swidget->comp_id;
1437         buffer->comp.type = SOF_COMP_BUFFER;
1438         buffer->comp.pipeline_id = index;
1439
1440         ret = sof_parse_tokens(scomp, buffer, buffer_tokens,
1441                                ARRAY_SIZE(buffer_tokens), private->array,
1442                                le32_to_cpu(private->size));
1443         if (ret != 0) {
1444                 dev_err(scomp->dev, "error: parse buffer tokens failed %d\n",
1445                         private->size);
1446                 kfree(buffer);
1447                 return ret;
1448         }
1449
1450         dev_dbg(scomp->dev, "buffer %s: size %d caps 0x%x\n",
1451                 swidget->widget->name, buffer->size, buffer->caps);
1452
1453         swidget->private = buffer;
1454
1455         ret = sof_ipc_tx_message(sdev->ipc, buffer->comp.hdr.cmd, buffer,
1456                                  sizeof(*buffer), r, sizeof(*r));
1457         if (ret < 0) {
1458                 dev_err(scomp->dev, "error: buffer %s load failed\n",
1459                         swidget->widget->name);
1460                 kfree(buffer);
1461         }
1462
1463         return ret;
1464 }
1465
1466 /* bind PCM ID to host component ID */
1467 static int spcm_bind(struct snd_soc_component *scomp, struct snd_sof_pcm *spcm,
1468                      int dir)
1469 {
1470         struct snd_sof_widget *host_widget;
1471
1472         host_widget = snd_sof_find_swidget_sname(scomp,
1473                                                  spcm->pcm.caps[dir].name,
1474                                                  dir);
1475         if (!host_widget) {
1476                 dev_err(scomp->dev, "can't find host comp to bind pcm\n");
1477                 return -EINVAL;
1478         }
1479
1480         spcm->stream[dir].comp_id = host_widget->comp_id;
1481
1482         return 0;
1483 }
1484
1485 /*
1486  * PCM Topology
1487  */
1488
1489 static int sof_widget_load_pcm(struct snd_soc_component *scomp, int index,
1490                                struct snd_sof_widget *swidget,
1491                                enum sof_ipc_stream_direction dir,
1492                                struct snd_soc_tplg_dapm_widget *tw,
1493                                struct sof_ipc_comp_reply *r)
1494 {
1495         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1496         struct snd_soc_tplg_private *private = &tw->priv;
1497         struct sof_ipc_comp_host *host;
1498         int ret;
1499
1500         host = kzalloc(sizeof(*host), GFP_KERNEL);
1501         if (!host)
1502                 return -ENOMEM;
1503
1504         /* configure host comp IPC message */
1505         host->comp.hdr.size = sizeof(*host);
1506         host->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1507         host->comp.id = swidget->comp_id;
1508         host->comp.type = SOF_COMP_HOST;
1509         host->comp.pipeline_id = index;
1510         host->direction = dir;
1511         host->config.hdr.size = sizeof(host->config);
1512
1513         ret = sof_parse_tokens(scomp, host, pcm_tokens,
1514                                ARRAY_SIZE(pcm_tokens), private->array,
1515                                le32_to_cpu(private->size));
1516         if (ret != 0) {
1517                 dev_err(scomp->dev, "error: parse host tokens failed %d\n",
1518                         private->size);
1519                 goto err;
1520         }
1521
1522         ret = sof_parse_tokens(scomp, &host->config, comp_tokens,
1523                                ARRAY_SIZE(comp_tokens), private->array,
1524                                le32_to_cpu(private->size));
1525         if (ret != 0) {
1526                 dev_err(scomp->dev, "error: parse host.cfg tokens failed %d\n",
1527                         le32_to_cpu(private->size));
1528                 goto err;
1529         }
1530
1531         dev_dbg(scomp->dev, "loaded host %s\n", swidget->widget->name);
1532         sof_dbg_comp_config(scomp, &host->config);
1533
1534         swidget->private = host;
1535
1536         ret = sof_ipc_tx_message(sdev->ipc, host->comp.hdr.cmd, host,
1537                                  sizeof(*host), r, sizeof(*r));
1538         if (ret >= 0)
1539                 return ret;
1540 err:
1541         kfree(host);
1542         return ret;
1543 }
1544
1545 /*
1546  * Pipeline Topology
1547  */
1548 int sof_load_pipeline_ipc(struct device *dev,
1549                           struct sof_ipc_pipe_new *pipeline,
1550                           struct sof_ipc_comp_reply *r)
1551 {
1552         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
1553         struct sof_ipc_pm_core_config pm_core_config;
1554         int ret;
1555
1556         ret = sof_ipc_tx_message(sdev->ipc, pipeline->hdr.cmd, pipeline,
1557                                  sizeof(*pipeline), r, sizeof(*r));
1558         if (ret < 0) {
1559                 dev_err(dev, "error: load pipeline ipc failure\n");
1560                 return ret;
1561         }
1562
1563         /* power up the core that this pipeline is scheduled on */
1564         ret = snd_sof_dsp_core_power_up(sdev, 1 << pipeline->core);
1565         if (ret < 0) {
1566                 dev_err(dev, "error: powering up pipeline schedule core %d\n",
1567                         pipeline->core);
1568                 return ret;
1569         }
1570
1571         /* update enabled cores mask */
1572         sdev->enabled_cores_mask |= 1 << pipeline->core;
1573
1574         /*
1575          * Now notify DSP that the core that this pipeline is scheduled on
1576          * has been powered up
1577          */
1578         memset(&pm_core_config, 0, sizeof(pm_core_config));
1579         pm_core_config.enable_mask = sdev->enabled_cores_mask;
1580
1581         /* configure CORE_ENABLE ipc message */
1582         pm_core_config.hdr.size = sizeof(pm_core_config);
1583         pm_core_config.hdr.cmd = SOF_IPC_GLB_PM_MSG | SOF_IPC_PM_CORE_ENABLE;
1584
1585         /* send ipc */
1586         ret = sof_ipc_tx_message(sdev->ipc, pm_core_config.hdr.cmd,
1587                                  &pm_core_config, sizeof(pm_core_config),
1588                                  &pm_core_config, sizeof(pm_core_config));
1589         if (ret < 0)
1590                 dev_err(dev, "error: core enable ipc failure\n");
1591
1592         return ret;
1593 }
1594
1595 static int sof_widget_load_pipeline(struct snd_soc_component *scomp,
1596                                     int index, struct snd_sof_widget *swidget,
1597                                     struct snd_soc_tplg_dapm_widget *tw,
1598                                     struct sof_ipc_comp_reply *r)
1599 {
1600         struct snd_soc_tplg_private *private = &tw->priv;
1601         struct sof_ipc_pipe_new *pipeline;
1602         struct snd_sof_widget *comp_swidget;
1603         int ret;
1604
1605         pipeline = kzalloc(sizeof(*pipeline), GFP_KERNEL);
1606         if (!pipeline)
1607                 return -ENOMEM;
1608
1609         /* configure dai IPC message */
1610         pipeline->hdr.size = sizeof(*pipeline);
1611         pipeline->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_NEW;
1612         pipeline->pipeline_id = index;
1613         pipeline->comp_id = swidget->comp_id;
1614
1615         /* component at start of pipeline is our stream id */
1616         comp_swidget = snd_sof_find_swidget(scomp, tw->sname);
1617         if (!comp_swidget) {
1618                 dev_err(scomp->dev, "error: widget %s refers to non existent widget %s\n",
1619                         tw->name, tw->sname);
1620                 ret = -EINVAL;
1621                 goto err;
1622         }
1623
1624         pipeline->sched_id = comp_swidget->comp_id;
1625
1626         dev_dbg(scomp->dev, "tplg: pipeline id %d comp %d scheduling comp id %d\n",
1627                 pipeline->pipeline_id, pipeline->comp_id, pipeline->sched_id);
1628
1629         ret = sof_parse_tokens(scomp, pipeline, sched_tokens,
1630                                ARRAY_SIZE(sched_tokens), private->array,
1631                                le32_to_cpu(private->size));
1632         if (ret != 0) {
1633                 dev_err(scomp->dev, "error: parse pipeline tokens failed %d\n",
1634                         private->size);
1635                 goto err;
1636         }
1637
1638         dev_dbg(scomp->dev, "pipeline %s: period %d pri %d mips %d core %d frames %d\n",
1639                 swidget->widget->name, pipeline->period, pipeline->priority,
1640                 pipeline->period_mips, pipeline->core, pipeline->frames_per_sched);
1641
1642         swidget->private = pipeline;
1643
1644         /* send ipc's to create pipeline comp and power up schedule core */
1645         ret = sof_load_pipeline_ipc(scomp->dev, pipeline, r);
1646         if (ret >= 0)
1647                 return ret;
1648 err:
1649         kfree(pipeline);
1650         return ret;
1651 }
1652
1653 /*
1654  * Mixer topology
1655  */
1656
1657 static int sof_widget_load_mixer(struct snd_soc_component *scomp, int index,
1658                                  struct snd_sof_widget *swidget,
1659                                  struct snd_soc_tplg_dapm_widget *tw,
1660                                  struct sof_ipc_comp_reply *r)
1661 {
1662         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1663         struct snd_soc_tplg_private *private = &tw->priv;
1664         struct sof_ipc_comp_mixer *mixer;
1665         int ret;
1666
1667         mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
1668         if (!mixer)
1669                 return -ENOMEM;
1670
1671         /* configure mixer IPC message */
1672         mixer->comp.hdr.size = sizeof(*mixer);
1673         mixer->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1674         mixer->comp.id = swidget->comp_id;
1675         mixer->comp.type = SOF_COMP_MIXER;
1676         mixer->comp.pipeline_id = index;
1677         mixer->config.hdr.size = sizeof(mixer->config);
1678
1679         ret = sof_parse_tokens(scomp, &mixer->config, comp_tokens,
1680                                ARRAY_SIZE(comp_tokens), private->array,
1681                                le32_to_cpu(private->size));
1682         if (ret != 0) {
1683                 dev_err(scomp->dev, "error: parse mixer.cfg tokens failed %d\n",
1684                         private->size);
1685                 kfree(mixer);
1686                 return ret;
1687         }
1688
1689         sof_dbg_comp_config(scomp, &mixer->config);
1690
1691         swidget->private = mixer;
1692
1693         ret = sof_ipc_tx_message(sdev->ipc, mixer->comp.hdr.cmd, mixer,
1694                                  sizeof(*mixer), r, sizeof(*r));
1695         if (ret < 0)
1696                 kfree(mixer);
1697
1698         return ret;
1699 }
1700
1701 /*
1702  * Mux topology
1703  */
1704 static int sof_widget_load_mux(struct snd_soc_component *scomp, int index,
1705                                struct snd_sof_widget *swidget,
1706                                struct snd_soc_tplg_dapm_widget *tw,
1707                                struct sof_ipc_comp_reply *r)
1708 {
1709         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1710         struct snd_soc_tplg_private *private = &tw->priv;
1711         struct sof_ipc_comp_mux *mux;
1712         int ret;
1713
1714         mux = kzalloc(sizeof(*mux), GFP_KERNEL);
1715         if (!mux)
1716                 return -ENOMEM;
1717
1718         /* configure mux IPC message */
1719         mux->comp.hdr.size = sizeof(*mux);
1720         mux->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1721         mux->comp.id = swidget->comp_id;
1722         mux->comp.type = SOF_COMP_MUX;
1723         mux->comp.pipeline_id = index;
1724         mux->config.hdr.size = sizeof(mux->config);
1725
1726         ret = sof_parse_tokens(scomp, &mux->config, comp_tokens,
1727                                ARRAY_SIZE(comp_tokens), private->array,
1728                                le32_to_cpu(private->size));
1729         if (ret != 0) {
1730                 dev_err(scomp->dev, "error: parse mux.cfg tokens failed %d\n",
1731                         private->size);
1732                 kfree(mux);
1733                 return ret;
1734         }
1735
1736         sof_dbg_comp_config(scomp, &mux->config);
1737
1738         swidget->private = mux;
1739
1740         ret = sof_ipc_tx_message(sdev->ipc, mux->comp.hdr.cmd, mux,
1741                                  sizeof(*mux), r, sizeof(*r));
1742         if (ret < 0)
1743                 kfree(mux);
1744
1745         return ret;
1746 }
1747
1748 /*
1749  * PGA Topology
1750  */
1751
1752 static int sof_widget_load_pga(struct snd_soc_component *scomp, int index,
1753                                struct snd_sof_widget *swidget,
1754                                struct snd_soc_tplg_dapm_widget *tw,
1755                                struct sof_ipc_comp_reply *r)
1756 {
1757         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1758         struct snd_soc_tplg_private *private = &tw->priv;
1759         struct sof_ipc_comp_volume *volume;
1760         struct snd_sof_control *scontrol;
1761         int min_step;
1762         int max_step;
1763         int ret;
1764
1765         volume = kzalloc(sizeof(*volume), GFP_KERNEL);
1766         if (!volume)
1767                 return -ENOMEM;
1768
1769         if (!le32_to_cpu(tw->num_kcontrols)) {
1770                 dev_err(scomp->dev, "error: invalid kcontrol count %d for volume\n",
1771                         tw->num_kcontrols);
1772                 ret = -EINVAL;
1773                 goto err;
1774         }
1775
1776         /* configure volume IPC message */
1777         volume->comp.hdr.size = sizeof(*volume);
1778         volume->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1779         volume->comp.id = swidget->comp_id;
1780         volume->comp.type = SOF_COMP_VOLUME;
1781         volume->comp.pipeline_id = index;
1782         volume->config.hdr.size = sizeof(volume->config);
1783
1784         ret = sof_parse_tokens(scomp, volume, volume_tokens,
1785                                ARRAY_SIZE(volume_tokens), private->array,
1786                                le32_to_cpu(private->size));
1787         if (ret != 0) {
1788                 dev_err(scomp->dev, "error: parse volume tokens failed %d\n",
1789                         private->size);
1790                 goto err;
1791         }
1792         ret = sof_parse_tokens(scomp, &volume->config, comp_tokens,
1793                                ARRAY_SIZE(comp_tokens), private->array,
1794                                le32_to_cpu(private->size));
1795         if (ret != 0) {
1796                 dev_err(scomp->dev, "error: parse volume.cfg tokens failed %d\n",
1797                         le32_to_cpu(private->size));
1798                 goto err;
1799         }
1800
1801         sof_dbg_comp_config(scomp, &volume->config);
1802
1803         swidget->private = volume;
1804
1805         list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
1806                 if (scontrol->comp_id == swidget->comp_id &&
1807                     scontrol->volume_table) {
1808                         min_step = scontrol->min_volume_step;
1809                         max_step = scontrol->max_volume_step;
1810                         volume->min_value = scontrol->volume_table[min_step];
1811                         volume->max_value = scontrol->volume_table[max_step];
1812                         volume->channels = scontrol->num_channels;
1813                         break;
1814                 }
1815         }
1816
1817         ret = sof_ipc_tx_message(sdev->ipc, volume->comp.hdr.cmd, volume,
1818                                  sizeof(*volume), r, sizeof(*r));
1819         if (ret >= 0)
1820                 return ret;
1821 err:
1822         kfree(volume);
1823         return ret;
1824 }
1825
1826 /*
1827  * SRC Topology
1828  */
1829
1830 static int sof_widget_load_src(struct snd_soc_component *scomp, int index,
1831                                struct snd_sof_widget *swidget,
1832                                struct snd_soc_tplg_dapm_widget *tw,
1833                                struct sof_ipc_comp_reply *r)
1834 {
1835         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1836         struct snd_soc_tplg_private *private = &tw->priv;
1837         struct sof_ipc_comp_src *src;
1838         int ret;
1839
1840         src = kzalloc(sizeof(*src), GFP_KERNEL);
1841         if (!src)
1842                 return -ENOMEM;
1843
1844         /* configure src IPC message */
1845         src->comp.hdr.size = sizeof(*src);
1846         src->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1847         src->comp.id = swidget->comp_id;
1848         src->comp.type = SOF_COMP_SRC;
1849         src->comp.pipeline_id = index;
1850         src->config.hdr.size = sizeof(src->config);
1851
1852         ret = sof_parse_tokens(scomp, src, src_tokens,
1853                                ARRAY_SIZE(src_tokens), private->array,
1854                                le32_to_cpu(private->size));
1855         if (ret != 0) {
1856                 dev_err(scomp->dev, "error: parse src tokens failed %d\n",
1857                         private->size);
1858                 goto err;
1859         }
1860
1861         ret = sof_parse_tokens(scomp, &src->config, comp_tokens,
1862                                ARRAY_SIZE(comp_tokens), private->array,
1863                                le32_to_cpu(private->size));
1864         if (ret != 0) {
1865                 dev_err(scomp->dev, "error: parse src.cfg tokens failed %d\n",
1866                         le32_to_cpu(private->size));
1867                 goto err;
1868         }
1869
1870         dev_dbg(scomp->dev, "src %s: source rate %d sink rate %d\n",
1871                 swidget->widget->name, src->source_rate, src->sink_rate);
1872         sof_dbg_comp_config(scomp, &src->config);
1873
1874         swidget->private = src;
1875
1876         ret = sof_ipc_tx_message(sdev->ipc, src->comp.hdr.cmd, src,
1877                                  sizeof(*src), r, sizeof(*r));
1878         if (ret >= 0)
1879                 return ret;
1880 err:
1881         kfree(src);
1882         return ret;
1883 }
1884
1885 /*
1886  * ASRC Topology
1887  */
1888
1889 static int sof_widget_load_asrc(struct snd_soc_component *scomp, int index,
1890                                 struct snd_sof_widget *swidget,
1891                                 struct snd_soc_tplg_dapm_widget *tw,
1892                                 struct sof_ipc_comp_reply *r)
1893 {
1894         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1895         struct snd_soc_tplg_private *private = &tw->priv;
1896         struct sof_ipc_comp_asrc *asrc;
1897         int ret;
1898
1899         asrc = kzalloc(sizeof(*asrc), GFP_KERNEL);
1900         if (!asrc)
1901                 return -ENOMEM;
1902
1903         /* configure ASRC IPC message */
1904         asrc->comp.hdr.size = sizeof(*asrc);
1905         asrc->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1906         asrc->comp.id = swidget->comp_id;
1907         asrc->comp.type = SOF_COMP_ASRC;
1908         asrc->comp.pipeline_id = index;
1909         asrc->config.hdr.size = sizeof(asrc->config);
1910
1911         ret = sof_parse_tokens(scomp, asrc, asrc_tokens,
1912                                ARRAY_SIZE(asrc_tokens), private->array,
1913                                le32_to_cpu(private->size));
1914         if (ret != 0) {
1915                 dev_err(scomp->dev, "error: parse asrc tokens failed %d\n",
1916                         private->size);
1917                 goto err;
1918         }
1919
1920         ret = sof_parse_tokens(scomp, &asrc->config, comp_tokens,
1921                                ARRAY_SIZE(comp_tokens), private->array,
1922                                le32_to_cpu(private->size));
1923         if (ret != 0) {
1924                 dev_err(scomp->dev, "error: parse asrc.cfg tokens failed %d\n",
1925                         le32_to_cpu(private->size));
1926                 goto err;
1927         }
1928
1929         dev_dbg(scomp->dev, "asrc %s: source rate %d sink rate %d "
1930                 "asynch %d operation %d\n",
1931                 swidget->widget->name, asrc->source_rate, asrc->sink_rate,
1932                 asrc->asynchronous_mode, asrc->operation_mode);
1933         sof_dbg_comp_config(scomp, &asrc->config);
1934
1935         swidget->private = asrc;
1936
1937         ret = sof_ipc_tx_message(sdev->ipc, asrc->comp.hdr.cmd, asrc,
1938                                  sizeof(*asrc), r, sizeof(*r));
1939         if (ret >= 0)
1940                 return ret;
1941 err:
1942         kfree(asrc);
1943         return ret;
1944 }
1945
1946 /*
1947  * Signal Generator Topology
1948  */
1949
1950 static int sof_widget_load_siggen(struct snd_soc_component *scomp, int index,
1951                                   struct snd_sof_widget *swidget,
1952                                   struct snd_soc_tplg_dapm_widget *tw,
1953                                   struct sof_ipc_comp_reply *r)
1954 {
1955         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1956         struct snd_soc_tplg_private *private = &tw->priv;
1957         struct sof_ipc_comp_tone *tone;
1958         int ret;
1959
1960         tone = kzalloc(sizeof(*tone), GFP_KERNEL);
1961         if (!tone)
1962                 return -ENOMEM;
1963
1964         /* configure siggen IPC message */
1965         tone->comp.hdr.size = sizeof(*tone);
1966         tone->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
1967         tone->comp.id = swidget->comp_id;
1968         tone->comp.type = SOF_COMP_TONE;
1969         tone->comp.pipeline_id = index;
1970         tone->config.hdr.size = sizeof(tone->config);
1971
1972         ret = sof_parse_tokens(scomp, tone, tone_tokens,
1973                                ARRAY_SIZE(tone_tokens), private->array,
1974                                le32_to_cpu(private->size));
1975         if (ret != 0) {
1976                 dev_err(scomp->dev, "error: parse tone tokens failed %d\n",
1977                         le32_to_cpu(private->size));
1978                 goto err;
1979         }
1980
1981         ret = sof_parse_tokens(scomp, &tone->config, comp_tokens,
1982                                ARRAY_SIZE(comp_tokens), private->array,
1983                                le32_to_cpu(private->size));
1984         if (ret != 0) {
1985                 dev_err(scomp->dev, "error: parse tone.cfg tokens failed %d\n",
1986                         le32_to_cpu(private->size));
1987                 goto err;
1988         }
1989
1990         dev_dbg(scomp->dev, "tone %s: frequency %d amplitude %d\n",
1991                 swidget->widget->name, tone->frequency, tone->amplitude);
1992         sof_dbg_comp_config(scomp, &tone->config);
1993
1994         swidget->private = tone;
1995
1996         ret = sof_ipc_tx_message(sdev->ipc, tone->comp.hdr.cmd, tone,
1997                                  sizeof(*tone), r, sizeof(*r));
1998         if (ret >= 0)
1999                 return ret;
2000 err:
2001         kfree(tone);
2002         return ret;
2003 }
2004
2005 static int sof_get_control_data(struct snd_soc_component *scomp,
2006                                 struct snd_soc_dapm_widget *widget,
2007                                 struct sof_widget_data *wdata,
2008                                 size_t *size)
2009 {
2010         const struct snd_kcontrol_new *kc;
2011         struct soc_mixer_control *sm;
2012         struct soc_bytes_ext *sbe;
2013         struct soc_enum *se;
2014         int i;
2015
2016         *size = 0;
2017
2018         for (i = 0; i < widget->num_kcontrols; i++) {
2019                 kc = &widget->kcontrol_news[i];
2020
2021                 switch (widget->dobj.widget.kcontrol_type) {
2022                 case SND_SOC_TPLG_TYPE_MIXER:
2023                         sm = (struct soc_mixer_control *)kc->private_value;
2024                         wdata[i].control = sm->dobj.private;
2025                         break;
2026                 case SND_SOC_TPLG_TYPE_BYTES:
2027                         sbe = (struct soc_bytes_ext *)kc->private_value;
2028                         wdata[i].control = sbe->dobj.private;
2029                         break;
2030                 case SND_SOC_TPLG_TYPE_ENUM:
2031                         se = (struct soc_enum *)kc->private_value;
2032                         wdata[i].control = se->dobj.private;
2033                         break;
2034                 default:
2035                         dev_err(scomp->dev, "error: unknown kcontrol type %d in widget %s\n",
2036                                 widget->dobj.widget.kcontrol_type,
2037                                 widget->name);
2038                         return -EINVAL;
2039                 }
2040
2041                 if (!wdata[i].control) {
2042                         dev_err(scomp->dev, "error: no scontrol for widget %s\n",
2043                                 widget->name);
2044                         return -EINVAL;
2045                 }
2046
2047                 wdata[i].pdata = wdata[i].control->control_data->data;
2048                 if (!wdata[i].pdata)
2049                         return -EINVAL;
2050
2051                 /* make sure data is valid - data can be updated at runtime */
2052                 if (wdata[i].pdata->magic != SOF_ABI_MAGIC)
2053                         return -EINVAL;
2054
2055                 *size += wdata[i].pdata->size;
2056
2057                 /* get data type */
2058                 switch (wdata[i].control->cmd) {
2059                 case SOF_CTRL_CMD_VOLUME:
2060                 case SOF_CTRL_CMD_ENUM:
2061                 case SOF_CTRL_CMD_SWITCH:
2062                         wdata[i].ipc_cmd = SOF_IPC_COMP_SET_VALUE;
2063                         wdata[i].ctrl_type = SOF_CTRL_TYPE_VALUE_CHAN_SET;
2064                         break;
2065                 case SOF_CTRL_CMD_BINARY:
2066                         wdata[i].ipc_cmd = SOF_IPC_COMP_SET_DATA;
2067                         wdata[i].ctrl_type = SOF_CTRL_TYPE_DATA_SET;
2068                         break;
2069                 default:
2070                         break;
2071                 }
2072         }
2073
2074         return 0;
2075 }
2076
2077 static int sof_process_load(struct snd_soc_component *scomp, int index,
2078                             struct snd_sof_widget *swidget,
2079                             struct snd_soc_tplg_dapm_widget *tw,
2080                             struct sof_ipc_comp_reply *r,
2081                             int type)
2082 {
2083         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2084         struct snd_soc_dapm_widget *widget = swidget->widget;
2085         struct snd_soc_tplg_private *private = &tw->priv;
2086         struct sof_ipc_comp_process *process = NULL;
2087         struct sof_widget_data *wdata = NULL;
2088         size_t ipc_data_size = 0;
2089         size_t ipc_size;
2090         int offset = 0;
2091         int ret = 0;
2092         int i;
2093
2094         if (type == SOF_COMP_NONE) {
2095                 dev_err(scomp->dev, "error: invalid process comp type %d\n",
2096                         type);
2097                 return -EINVAL;
2098         }
2099
2100         /* allocate struct for widget control data sizes and types */
2101         if (widget->num_kcontrols) {
2102                 wdata = kcalloc(widget->num_kcontrols,
2103                                 sizeof(*wdata),
2104                                 GFP_KERNEL);
2105
2106                 if (!wdata)
2107                         return -ENOMEM;
2108
2109                 /* get possible component controls and get size of all pdata */
2110                 ret = sof_get_control_data(scomp, widget, wdata,
2111                                            &ipc_data_size);
2112
2113                 if (ret < 0)
2114                         goto out;
2115         }
2116
2117         ipc_size = sizeof(struct sof_ipc_comp_process) +
2118                 le32_to_cpu(private->size) +
2119                 ipc_data_size;
2120
2121         /* we are exceeding max ipc size, config needs to be sent separately */
2122         if (ipc_size > SOF_IPC_MSG_MAX_SIZE) {
2123                 ipc_size -= ipc_data_size;
2124                 ipc_data_size = 0;
2125         }
2126
2127         process = kzalloc(ipc_size, GFP_KERNEL);
2128         if (!process) {
2129                 ret = -ENOMEM;
2130                 goto out;
2131         }
2132
2133         /* configure iir IPC message */
2134         process->comp.hdr.size = ipc_size;
2135         process->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
2136         process->comp.id = swidget->comp_id;
2137         process->comp.type = type;
2138         process->comp.pipeline_id = index;
2139         process->config.hdr.size = sizeof(process->config);
2140
2141         ret = sof_parse_tokens(scomp, &process->config, comp_tokens,
2142                                ARRAY_SIZE(comp_tokens), private->array,
2143                                le32_to_cpu(private->size));
2144         if (ret != 0) {
2145                 dev_err(scomp->dev, "error: parse process.cfg tokens failed %d\n",
2146                         le32_to_cpu(private->size));
2147                 goto err;
2148         }
2149
2150         sof_dbg_comp_config(scomp, &process->config);
2151
2152         /*
2153          * found private data in control, so copy it.
2154          * get possible component controls - get size of all pdata,
2155          * then memcpy with headers
2156          */
2157         if (ipc_data_size) {
2158                 for (i = 0; i < widget->num_kcontrols; i++) {
2159                         memcpy(&process->data + offset,
2160                                wdata[i].pdata->data,
2161                                wdata[i].pdata->size);
2162                         offset += wdata[i].pdata->size;
2163                 }
2164         }
2165
2166         process->size = ipc_data_size;
2167         swidget->private = process;
2168
2169         ret = sof_ipc_tx_message(sdev->ipc, process->comp.hdr.cmd, process,
2170                                  ipc_size, r, sizeof(*r));
2171
2172         if (ret < 0) {
2173                 dev_err(scomp->dev, "error: create process failed\n");
2174                 goto err;
2175         }
2176
2177         /* we sent the data in single message so return */
2178         if (ipc_data_size)
2179                 goto out;
2180
2181         /* send control data with large message supported method */
2182         for (i = 0; i < widget->num_kcontrols; i++) {
2183                 wdata[i].control->readback_offset = 0;
2184                 ret = snd_sof_ipc_set_get_comp_data(wdata[i].control,
2185                                                     wdata[i].ipc_cmd,
2186                                                     wdata[i].ctrl_type,
2187                                                     wdata[i].control->cmd,
2188                                                     true);
2189                 if (ret != 0) {
2190                         dev_err(scomp->dev, "error: send control failed\n");
2191                         break;
2192                 }
2193         }
2194
2195 err:
2196         if (ret < 0)
2197                 kfree(process);
2198 out:
2199         kfree(wdata);
2200         return ret;
2201 }
2202
2203 /*
2204  * Processing Component Topology - can be "effect", "codec", or general
2205  * "processing".
2206  */
2207
2208 static int sof_widget_load_process(struct snd_soc_component *scomp, int index,
2209                                    struct snd_sof_widget *swidget,
2210                                    struct snd_soc_tplg_dapm_widget *tw,
2211                                    struct sof_ipc_comp_reply *r)
2212 {
2213         struct snd_soc_tplg_private *private = &tw->priv;
2214         struct sof_ipc_comp_process config;
2215         int ret;
2216
2217         /* check we have some tokens - we need at least process type */
2218         if (le32_to_cpu(private->size) == 0) {
2219                 dev_err(scomp->dev, "error: process tokens not found\n");
2220                 return -EINVAL;
2221         }
2222
2223         memset(&config, 0, sizeof(config));
2224
2225         /* get the process token */
2226         ret = sof_parse_tokens(scomp, &config, process_tokens,
2227                                ARRAY_SIZE(process_tokens), private->array,
2228                                le32_to_cpu(private->size));
2229         if (ret != 0) {
2230                 dev_err(scomp->dev, "error: parse process tokens failed %d\n",
2231                         le32_to_cpu(private->size));
2232                 return ret;
2233         }
2234
2235         /* now load process specific data and send IPC */
2236         ret = sof_process_load(scomp, index, swidget, tw, r,
2237                                find_process_comp_type(config.type));
2238         if (ret < 0) {
2239                 dev_err(scomp->dev, "error: process loading failed\n");
2240                 return ret;
2241         }
2242
2243         return 0;
2244 }
2245
2246 static int sof_widget_bind_event(struct snd_soc_component *scomp,
2247                                  struct snd_sof_widget *swidget,
2248                                  u16 event_type)
2249 {
2250         struct sof_ipc_comp *ipc_comp;
2251
2252         /* validate widget event type */
2253         switch (event_type) {
2254         case SOF_KEYWORD_DETECT_DAPM_EVENT:
2255                 /* only KEYWORD_DETECT comps should handle this */
2256                 if (swidget->id != snd_soc_dapm_effect)
2257                         break;
2258
2259                 ipc_comp = swidget->private;
2260                 if (ipc_comp && ipc_comp->type != SOF_COMP_KEYWORD_DETECT)
2261                         break;
2262
2263                 /* bind event to keyword detect comp */
2264                 return snd_soc_tplg_widget_bind_event(swidget->widget,
2265                                                       sof_kwd_events,
2266                                                       ARRAY_SIZE(sof_kwd_events),
2267                                                       event_type);
2268         default:
2269                 break;
2270         }
2271
2272         dev_err(scomp->dev,
2273                 "error: invalid event type %d for widget %s\n",
2274                 event_type, swidget->widget->name);
2275         return -EINVAL;
2276 }
2277
2278 /* external widget init - used for any driver specific init */
2279 static int sof_widget_ready(struct snd_soc_component *scomp, int index,
2280                             struct snd_soc_dapm_widget *w,
2281                             struct snd_soc_tplg_dapm_widget *tw)
2282 {
2283         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2284         struct snd_sof_widget *swidget;
2285         struct snd_sof_dai *dai;
2286         struct sof_ipc_comp_reply reply;
2287         struct snd_sof_control *scontrol;
2288         int ret = 0;
2289
2290         swidget = kzalloc(sizeof(*swidget), GFP_KERNEL);
2291         if (!swidget)
2292                 return -ENOMEM;
2293
2294         swidget->scomp = scomp;
2295         swidget->widget = w;
2296         swidget->comp_id = sdev->next_comp_id++;
2297         swidget->complete = 0;
2298         swidget->id = w->id;
2299         swidget->pipeline_id = index;
2300         swidget->private = NULL;
2301         memset(&reply, 0, sizeof(reply));
2302
2303         dev_dbg(scomp->dev, "tplg: ready widget id %d pipe %d type %d name : %s stream %s\n",
2304                 swidget->comp_id, index, swidget->id, tw->name,
2305                 strnlen(tw->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) > 0
2306                         ? tw->sname : "none");
2307
2308         /* handle any special case widgets */
2309         switch (w->id) {
2310         case snd_soc_dapm_dai_in:
2311         case snd_soc_dapm_dai_out:
2312                 dai = kzalloc(sizeof(*dai), GFP_KERNEL);
2313                 if (!dai) {
2314                         kfree(swidget);
2315                         return -ENOMEM;
2316                 }
2317
2318                 ret = sof_widget_load_dai(scomp, index, swidget, tw, &reply,
2319                                           dai);
2320                 if (ret == 0) {
2321                         sof_connect_dai_widget(scomp, w, tw, dai);
2322                         list_add(&dai->list, &sdev->dai_list);
2323                         swidget->private = dai;
2324                 } else {
2325                         kfree(dai);
2326                 }
2327                 break;
2328         case snd_soc_dapm_mixer:
2329                 ret = sof_widget_load_mixer(scomp, index, swidget, tw, &reply);
2330                 break;
2331         case snd_soc_dapm_pga:
2332                 ret = sof_widget_load_pga(scomp, index, swidget, tw, &reply);
2333                 /* Find scontrol for this pga and set readback offset*/
2334                 list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
2335                         if (scontrol->comp_id == swidget->comp_id) {
2336                                 scontrol->readback_offset = reply.offset;
2337                                 break;
2338                         }
2339                 }
2340                 break;
2341         case snd_soc_dapm_buffer:
2342                 ret = sof_widget_load_buffer(scomp, index, swidget, tw, &reply);
2343                 break;
2344         case snd_soc_dapm_scheduler:
2345                 ret = sof_widget_load_pipeline(scomp, index, swidget, tw,
2346                                                &reply);
2347                 break;
2348         case snd_soc_dapm_aif_out:
2349                 ret = sof_widget_load_pcm(scomp, index, swidget,
2350                                           SOF_IPC_STREAM_CAPTURE, tw, &reply);
2351                 break;
2352         case snd_soc_dapm_aif_in:
2353                 ret = sof_widget_load_pcm(scomp, index, swidget,
2354                                           SOF_IPC_STREAM_PLAYBACK, tw, &reply);
2355                 break;
2356         case snd_soc_dapm_src:
2357                 ret = sof_widget_load_src(scomp, index, swidget, tw, &reply);
2358                 break;
2359         case snd_soc_dapm_asrc:
2360                 ret = sof_widget_load_asrc(scomp, index, swidget, tw, &reply);
2361                 break;
2362         case snd_soc_dapm_siggen:
2363                 ret = sof_widget_load_siggen(scomp, index, swidget, tw, &reply);
2364                 break;
2365         case snd_soc_dapm_effect:
2366                 ret = sof_widget_load_process(scomp, index, swidget, tw,
2367                                               &reply);
2368                 break;
2369         case snd_soc_dapm_mux:
2370         case snd_soc_dapm_demux:
2371                 ret = sof_widget_load_mux(scomp, index, swidget, tw, &reply);
2372                 break;
2373         case snd_soc_dapm_switch:
2374         case snd_soc_dapm_dai_link:
2375         case snd_soc_dapm_kcontrol:
2376         default:
2377                 dev_warn(scomp->dev, "warning: widget type %d name %s not handled\n",
2378                          swidget->id, tw->name);
2379                 break;
2380         }
2381
2382         /* check IPC reply */
2383         if (ret < 0 || reply.rhdr.error < 0) {
2384                 dev_err(scomp->dev,
2385                         "error: DSP failed to add widget id %d type %d name : %s stream %s reply %d\n",
2386                         tw->shift, swidget->id, tw->name,
2387                         strnlen(tw->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) > 0
2388                                 ? tw->sname : "none", reply.rhdr.error);
2389                 kfree(swidget);
2390                 return ret;
2391         }
2392
2393         /* bind widget to external event */
2394         if (tw->event_type) {
2395                 ret = sof_widget_bind_event(scomp, swidget,
2396                                             le16_to_cpu(tw->event_type));
2397                 if (ret) {
2398                         dev_err(scomp->dev, "error: widget event binding failed\n");
2399                         kfree(swidget->private);
2400                         kfree(swidget);
2401                         return ret;
2402                 }
2403         }
2404
2405         w->dobj.private = swidget;
2406         list_add(&swidget->list, &sdev->widget_list);
2407         return ret;
2408 }
2409
2410 static int sof_route_unload(struct snd_soc_component *scomp,
2411                             struct snd_soc_dobj *dobj)
2412 {
2413         struct snd_sof_route *sroute;
2414
2415         sroute = dobj->private;
2416         if (!sroute)
2417                 return 0;
2418
2419         /* free sroute and its private data */
2420         kfree(sroute->private);
2421         list_del(&sroute->list);
2422         kfree(sroute);
2423
2424         return 0;
2425 }
2426
2427 static int sof_widget_unload(struct snd_soc_component *scomp,
2428                              struct snd_soc_dobj *dobj)
2429 {
2430         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2431         const struct snd_kcontrol_new *kc;
2432         struct snd_soc_dapm_widget *widget;
2433         struct sof_ipc_pipe_new *pipeline;
2434         struct snd_sof_control *scontrol;
2435         struct snd_sof_widget *swidget;
2436         struct soc_mixer_control *sm;
2437         struct soc_bytes_ext *sbe;
2438         struct snd_sof_dai *dai;
2439         struct soc_enum *se;
2440         int ret = 0;
2441         int i;
2442
2443         swidget = dobj->private;
2444         if (!swidget)
2445                 return 0;
2446
2447         widget = swidget->widget;
2448
2449         switch (swidget->id) {
2450         case snd_soc_dapm_dai_in:
2451         case snd_soc_dapm_dai_out:
2452                 dai = swidget->private;
2453
2454                 if (dai) {
2455                         /* free dai config */
2456                         kfree(dai->dai_config);
2457                         list_del(&dai->list);
2458                 }
2459                 break;
2460         case snd_soc_dapm_scheduler:
2461
2462                 /* power down the pipeline schedule core */
2463                 pipeline = swidget->private;
2464                 ret = snd_sof_dsp_core_power_down(sdev, 1 << pipeline->core);
2465                 if (ret < 0)
2466                         dev_err(scomp->dev, "error: powering down pipeline schedule core %d\n",
2467                                 pipeline->core);
2468
2469                 /* update enabled cores mask */
2470                 sdev->enabled_cores_mask &= ~(1 << pipeline->core);
2471
2472                 break;
2473         default:
2474                 break;
2475         }
2476         for (i = 0; i < widget->num_kcontrols; i++) {
2477                 kc = &widget->kcontrol_news[i];
2478                 switch (dobj->widget.kcontrol_type) {
2479                 case SND_SOC_TPLG_TYPE_MIXER:
2480                         sm = (struct soc_mixer_control *)kc->private_value;
2481                         scontrol = sm->dobj.private;
2482                         if (sm->max > 1)
2483                                 kfree(scontrol->volume_table);
2484                         break;
2485                 case SND_SOC_TPLG_TYPE_ENUM:
2486                         se = (struct soc_enum *)kc->private_value;
2487                         scontrol = se->dobj.private;
2488                         break;
2489                 case SND_SOC_TPLG_TYPE_BYTES:
2490                         sbe = (struct soc_bytes_ext *)kc->private_value;
2491                         scontrol = sbe->dobj.private;
2492                         break;
2493                 default:
2494                         dev_warn(scomp->dev, "unsupported kcontrol_type\n");
2495                         goto out;
2496                 }
2497                 kfree(scontrol->control_data);
2498                 list_del(&scontrol->list);
2499                 kfree(scontrol);
2500         }
2501
2502 out:
2503         /* free private value */
2504         kfree(swidget->private);
2505
2506         /* remove and free swidget object */
2507         list_del(&swidget->list);
2508         kfree(swidget);
2509
2510         return ret;
2511 }
2512
2513 /*
2514  * DAI HW configuration.
2515  */
2516
2517 /* FE DAI - used for any driver specific init */
2518 static int sof_dai_load(struct snd_soc_component *scomp, int index,
2519                         struct snd_soc_dai_driver *dai_drv,
2520                         struct snd_soc_tplg_pcm *pcm, struct snd_soc_dai *dai)
2521 {
2522         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2523         struct snd_soc_tplg_stream_caps *caps;
2524         struct snd_soc_tplg_private *private = &pcm->priv;
2525         struct snd_sof_pcm *spcm;
2526         int stream;
2527         int ret = 0;
2528
2529         /* nothing to do for BEs atm */
2530         if (!pcm)
2531                 return 0;
2532
2533         spcm = kzalloc(sizeof(*spcm), GFP_KERNEL);
2534         if (!spcm)
2535                 return -ENOMEM;
2536
2537         spcm->scomp = scomp;
2538
2539         for_each_pcm_streams(stream) {
2540                 spcm->stream[stream].comp_id = COMP_ID_UNASSIGNED;
2541                 INIT_WORK(&spcm->stream[stream].period_elapsed_work,
2542                           snd_sof_pcm_period_elapsed_work);
2543         }
2544
2545         spcm->pcm = *pcm;
2546         dev_dbg(scomp->dev, "tplg: load pcm %s\n", pcm->dai_name);
2547
2548         dai_drv->dobj.private = spcm;
2549         list_add(&spcm->list, &sdev->pcm_list);
2550
2551         ret = sof_parse_tokens(scomp, spcm, stream_tokens,
2552                                ARRAY_SIZE(stream_tokens), private->array,
2553                                le32_to_cpu(private->size));
2554         if (ret) {
2555                 dev_err(scomp->dev, "error: parse stream tokens failed %d\n",
2556                         le32_to_cpu(private->size));
2557                 return ret;
2558         }
2559
2560         /* do we need to allocate playback PCM DMA pages */
2561         if (!spcm->pcm.playback)
2562                 goto capture;
2563
2564         stream = SNDRV_PCM_STREAM_PLAYBACK;
2565
2566         dev_vdbg(scomp->dev, "tplg: pcm %s stream tokens: playback d0i3:%d\n",
2567                  spcm->pcm.pcm_name, spcm->stream[stream].d0i3_compatible);
2568
2569         caps = &spcm->pcm.caps[stream];
2570
2571         /* allocate playback page table buffer */
2572         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, sdev->dev,
2573                                   PAGE_SIZE, &spcm->stream[stream].page_table);
2574         if (ret < 0) {
2575                 dev_err(scomp->dev, "error: can't alloc page table for %s %d\n",
2576                         caps->name, ret);
2577
2578                 return ret;
2579         }
2580
2581         /* bind pcm to host comp */
2582         ret = spcm_bind(scomp, spcm, stream);
2583         if (ret) {
2584                 dev_err(scomp->dev,
2585                         "error: can't bind pcm to host\n");
2586                 goto free_playback_tables;
2587         }
2588
2589 capture:
2590         stream = SNDRV_PCM_STREAM_CAPTURE;
2591
2592         /* do we need to allocate capture PCM DMA pages */
2593         if (!spcm->pcm.capture)
2594                 return ret;
2595
2596         dev_vdbg(scomp->dev, "tplg: pcm %s stream tokens: capture d0i3:%d\n",
2597                  spcm->pcm.pcm_name, spcm->stream[stream].d0i3_compatible);
2598
2599         caps = &spcm->pcm.caps[stream];
2600
2601         /* allocate capture page table buffer */
2602         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, sdev->dev,
2603                                   PAGE_SIZE, &spcm->stream[stream].page_table);
2604         if (ret < 0) {
2605                 dev_err(scomp->dev, "error: can't alloc page table for %s %d\n",
2606                         caps->name, ret);
2607                 goto free_playback_tables;
2608         }
2609
2610         /* bind pcm to host comp */
2611         ret = spcm_bind(scomp, spcm, stream);
2612         if (ret) {
2613                 dev_err(scomp->dev,
2614                         "error: can't bind pcm to host\n");
2615                 snd_dma_free_pages(&spcm->stream[stream].page_table);
2616                 goto free_playback_tables;
2617         }
2618
2619         return ret;
2620
2621 free_playback_tables:
2622         if (spcm->pcm.playback)
2623                 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_PLAYBACK].page_table);
2624
2625         return ret;
2626 }
2627
2628 static int sof_dai_unload(struct snd_soc_component *scomp,
2629                           struct snd_soc_dobj *dobj)
2630 {
2631         struct snd_sof_pcm *spcm = dobj->private;
2632
2633         /* free PCM DMA pages */
2634         if (spcm->pcm.playback)
2635                 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_PLAYBACK].page_table);
2636
2637         if (spcm->pcm.capture)
2638                 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_CAPTURE].page_table);
2639
2640         /* remove from list and free spcm */
2641         list_del(&spcm->list);
2642         kfree(spcm);
2643
2644         return 0;
2645 }
2646
2647 static void sof_dai_set_format(struct snd_soc_tplg_hw_config *hw_config,
2648                                struct sof_ipc_dai_config *config)
2649 {
2650         /* clock directions wrt codec */
2651         if (hw_config->bclk_master == SND_SOC_TPLG_BCLK_CM) {
2652                 /* codec is bclk master */
2653                 if (hw_config->fsync_master == SND_SOC_TPLG_FSYNC_CM)
2654                         config->format |= SOF_DAI_FMT_CBM_CFM;
2655                 else
2656                         config->format |= SOF_DAI_FMT_CBM_CFS;
2657         } else {
2658                 /* codec is bclk slave */
2659                 if (hw_config->fsync_master == SND_SOC_TPLG_FSYNC_CM)
2660                         config->format |= SOF_DAI_FMT_CBS_CFM;
2661                 else
2662                         config->format |= SOF_DAI_FMT_CBS_CFS;
2663         }
2664
2665         /* inverted clocks ? */
2666         if (hw_config->invert_bclk) {
2667                 if (hw_config->invert_fsync)
2668                         config->format |= SOF_DAI_FMT_IB_IF;
2669                 else
2670                         config->format |= SOF_DAI_FMT_IB_NF;
2671         } else {
2672                 if (hw_config->invert_fsync)
2673                         config->format |= SOF_DAI_FMT_NB_IF;
2674                 else
2675                         config->format |= SOF_DAI_FMT_NB_NF;
2676         }
2677 }
2678
2679 /*
2680  * Send IPC and set the same config for all DAIs with name matching the link
2681  * name. Note that the function can only be used for the case that all DAIs
2682  * have a common DAI config for now.
2683  */
2684 static int sof_set_dai_config(struct snd_sof_dev *sdev, u32 size,
2685                               struct snd_soc_dai_link *link,
2686                               struct sof_ipc_dai_config *config)
2687 {
2688         struct snd_sof_dai *dai;
2689         int found = 0;
2690
2691         list_for_each_entry(dai, &sdev->dai_list, list) {
2692                 if (!dai->name)
2693                         continue;
2694
2695                 if (strcmp(link->name, dai->name) == 0) {
2696                         struct sof_ipc_reply reply;
2697                         int ret;
2698
2699                         /*
2700                          * the same dai config will be applied to all DAIs in
2701                          * the same dai link. We have to ensure that the ipc
2702                          * dai config's dai_index match to the component's
2703                          * dai_index.
2704                          */
2705                         config->dai_index = dai->comp_dai.dai_index;
2706
2707                         /* send message to DSP */
2708                         ret = sof_ipc_tx_message(sdev->ipc,
2709                                                  config->hdr.cmd, config, size,
2710                                                  &reply, sizeof(reply));
2711
2712                         if (ret < 0) {
2713                                 dev_err(sdev->dev, "error: failed to set DAI config for %s index %d\n",
2714                                         dai->name, config->dai_index);
2715                                 return ret;
2716                         }
2717                         dai->dai_config = kmemdup(config, size, GFP_KERNEL);
2718                         if (!dai->dai_config)
2719                                 return -ENOMEM;
2720
2721                         /* set cpu_dai_name */
2722                         dai->cpu_dai_name = link->cpus->dai_name;
2723
2724                         found = 1;
2725                 }
2726         }
2727
2728         /*
2729          * machine driver may define a dai link with playback and capture
2730          * dai enabled, but the dai link in topology would support both, one
2731          * or none of them. Here print a warning message to notify user
2732          */
2733         if (!found) {
2734                 dev_warn(sdev->dev, "warning: failed to find dai for dai link %s",
2735                          link->name);
2736         }
2737
2738         return 0;
2739 }
2740
2741 static int sof_link_ssp_load(struct snd_soc_component *scomp, int index,
2742                              struct snd_soc_dai_link *link,
2743                              struct snd_soc_tplg_link_config *cfg,
2744                              struct snd_soc_tplg_hw_config *hw_config,
2745                              struct sof_ipc_dai_config *config)
2746 {
2747         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2748         struct snd_soc_tplg_private *private = &cfg->priv;
2749         u32 size = sizeof(*config);
2750         int ret;
2751
2752         /* handle master/slave and inverted clocks */
2753         sof_dai_set_format(hw_config, config);
2754
2755         /* init IPC */
2756         memset(&config->ssp, 0, sizeof(struct sof_ipc_dai_ssp_params));
2757         config->hdr.size = size;
2758
2759         ret = sof_parse_tokens(scomp, &config->ssp, ssp_tokens,
2760                                ARRAY_SIZE(ssp_tokens), private->array,
2761                                le32_to_cpu(private->size));
2762         if (ret != 0) {
2763                 dev_err(scomp->dev, "error: parse ssp tokens failed %d\n",
2764                         le32_to_cpu(private->size));
2765                 return ret;
2766         }
2767
2768         config->ssp.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
2769         config->ssp.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
2770         config->ssp.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
2771         config->ssp.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
2772         config->ssp.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
2773         config->ssp.mclk_direction = hw_config->mclk_direction;
2774         config->ssp.rx_slots = le32_to_cpu(hw_config->rx_slots);
2775         config->ssp.tx_slots = le32_to_cpu(hw_config->tx_slots);
2776
2777         dev_dbg(scomp->dev, "tplg: config SSP%d fmt 0x%x mclk %d bclk %d fclk %d width (%d)%d slots %d mclk id %d quirks %d\n",
2778                 config->dai_index, config->format,
2779                 config->ssp.mclk_rate, config->ssp.bclk_rate,
2780                 config->ssp.fsync_rate, config->ssp.sample_valid_bits,
2781                 config->ssp.tdm_slot_width, config->ssp.tdm_slots,
2782                 config->ssp.mclk_id, config->ssp.quirks);
2783
2784         /* validate SSP fsync rate and channel count */
2785         if (config->ssp.fsync_rate < 8000 || config->ssp.fsync_rate > 192000) {
2786                 dev_err(scomp->dev, "error: invalid fsync rate for SSP%d\n",
2787                         config->dai_index);
2788                 return -EINVAL;
2789         }
2790
2791         if (config->ssp.tdm_slots < 1 || config->ssp.tdm_slots > 8) {
2792                 dev_err(scomp->dev, "error: invalid channel count for SSP%d\n",
2793                         config->dai_index);
2794                 return -EINVAL;
2795         }
2796
2797         /* set config for all DAI's with name matching the link name */
2798         ret = sof_set_dai_config(sdev, size, link, config);
2799         if (ret < 0)
2800                 dev_err(scomp->dev, "error: failed to save DAI config for SSP%d\n",
2801                         config->dai_index);
2802
2803         return ret;
2804 }
2805
2806 static int sof_link_sai_load(struct snd_soc_component *scomp, int index,
2807                              struct snd_soc_dai_link *link,
2808                              struct snd_soc_tplg_link_config *cfg,
2809                              struct snd_soc_tplg_hw_config *hw_config,
2810                              struct sof_ipc_dai_config *config)
2811 {
2812         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2813         struct snd_soc_tplg_private *private = &cfg->priv;
2814         u32 size = sizeof(*config);
2815         int ret;
2816
2817         /* handle master/slave and inverted clocks */
2818         sof_dai_set_format(hw_config, config);
2819
2820         /* init IPC */
2821         memset(&config->sai, 0, sizeof(struct sof_ipc_dai_sai_params));
2822         config->hdr.size = size;
2823
2824         ret = sof_parse_tokens(scomp, &config->sai, sai_tokens,
2825                                ARRAY_SIZE(sai_tokens), private->array,
2826                                le32_to_cpu(private->size));
2827         if (ret != 0) {
2828                 dev_err(scomp->dev, "error: parse sai tokens failed %d\n",
2829                         le32_to_cpu(private->size));
2830                 return ret;
2831         }
2832
2833         config->sai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
2834         config->sai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
2835         config->sai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
2836         config->sai.mclk_direction = hw_config->mclk_direction;
2837
2838         config->sai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
2839         config->sai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
2840         config->sai.rx_slots = le32_to_cpu(hw_config->rx_slots);
2841         config->sai.tx_slots = le32_to_cpu(hw_config->tx_slots);
2842
2843         dev_info(scomp->dev,
2844                  "tplg: config SAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
2845                 config->dai_index, config->format,
2846                 config->sai.mclk_rate, config->sai.tdm_slot_width,
2847                 config->sai.tdm_slots, config->sai.mclk_id);
2848
2849         if (config->sai.tdm_slots < 1 || config->sai.tdm_slots > 8) {
2850                 dev_err(scomp->dev, "error: invalid channel count for SAI%d\n",
2851                         config->dai_index);
2852                 return -EINVAL;
2853         }
2854
2855         /* set config for all DAI's with name matching the link name */
2856         ret = sof_set_dai_config(sdev, size, link, config);
2857         if (ret < 0)
2858                 dev_err(scomp->dev, "error: failed to save DAI config for SAI%d\n",
2859                         config->dai_index);
2860
2861         return ret;
2862 }
2863
2864 static int sof_link_esai_load(struct snd_soc_component *scomp, int index,
2865                               struct snd_soc_dai_link *link,
2866                               struct snd_soc_tplg_link_config *cfg,
2867                               struct snd_soc_tplg_hw_config *hw_config,
2868                               struct sof_ipc_dai_config *config)
2869 {
2870         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2871         struct snd_soc_tplg_private *private = &cfg->priv;
2872         u32 size = sizeof(*config);
2873         int ret;
2874
2875         /* handle master/slave and inverted clocks */
2876         sof_dai_set_format(hw_config, config);
2877
2878         /* init IPC */
2879         memset(&config->esai, 0, sizeof(struct sof_ipc_dai_esai_params));
2880         config->hdr.size = size;
2881
2882         ret = sof_parse_tokens(scomp, &config->esai, esai_tokens,
2883                                ARRAY_SIZE(esai_tokens), private->array,
2884                                le32_to_cpu(private->size));
2885         if (ret != 0) {
2886                 dev_err(scomp->dev, "error: parse esai tokens failed %d\n",
2887                         le32_to_cpu(private->size));
2888                 return ret;
2889         }
2890
2891         config->esai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
2892         config->esai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
2893         config->esai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
2894         config->esai.mclk_direction = hw_config->mclk_direction;
2895         config->esai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
2896         config->esai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
2897         config->esai.rx_slots = le32_to_cpu(hw_config->rx_slots);
2898         config->esai.tx_slots = le32_to_cpu(hw_config->tx_slots);
2899
2900         dev_info(scomp->dev,
2901                  "tplg: config ESAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
2902                 config->dai_index, config->format,
2903                 config->esai.mclk_rate, config->esai.tdm_slot_width,
2904                 config->esai.tdm_slots, config->esai.mclk_id);
2905
2906         if (config->esai.tdm_slots < 1 || config->esai.tdm_slots > 8) {
2907                 dev_err(scomp->dev, "error: invalid channel count for ESAI%d\n",
2908                         config->dai_index);
2909                 return -EINVAL;
2910         }
2911
2912         /* set config for all DAI's with name matching the link name */
2913         ret = sof_set_dai_config(sdev, size, link, config);
2914         if (ret < 0)
2915                 dev_err(scomp->dev, "error: failed to save DAI config for ESAI%d\n",
2916                         config->dai_index);
2917
2918         return ret;
2919 }
2920
2921 static int sof_link_dmic_load(struct snd_soc_component *scomp, int index,
2922                               struct snd_soc_dai_link *link,
2923                               struct snd_soc_tplg_link_config *cfg,
2924                               struct snd_soc_tplg_hw_config *hw_config,
2925                               struct sof_ipc_dai_config *config)
2926 {
2927         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2928         struct snd_soc_tplg_private *private = &cfg->priv;
2929         struct sof_ipc_fw_ready *ready = &sdev->fw_ready;
2930         struct sof_ipc_fw_version *v = &ready->version;
2931         size_t size = sizeof(*config);
2932         int ret, j;
2933
2934         /* Ensure the entire DMIC config struct is zeros */
2935         memset(&config->dmic, 0, sizeof(struct sof_ipc_dai_dmic_params));
2936
2937         /* get DMIC tokens */
2938         ret = sof_parse_tokens(scomp, &config->dmic, dmic_tokens,
2939                                ARRAY_SIZE(dmic_tokens), private->array,
2940                                le32_to_cpu(private->size));
2941         if (ret != 0) {
2942                 dev_err(scomp->dev, "error: parse dmic tokens failed %d\n",
2943                         le32_to_cpu(private->size));
2944                 return ret;
2945         }
2946
2947         /*
2948          * alloc memory for private member
2949          * Used to track the pdm config array index currently being parsed
2950          */
2951         sdev->private = kzalloc(sizeof(u32), GFP_KERNEL);
2952         if (!sdev->private)
2953                 return -ENOMEM;
2954
2955         /* get DMIC PDM tokens */
2956         ret = sof_parse_token_sets(scomp, &config->dmic.pdm[0], dmic_pdm_tokens,
2957                                ARRAY_SIZE(dmic_pdm_tokens), private->array,
2958                                le32_to_cpu(private->size),
2959                                config->dmic.num_pdm_active,
2960                                sizeof(struct sof_ipc_dai_dmic_pdm_ctrl));
2961
2962         if (ret != 0) {
2963                 dev_err(scomp->dev, "error: parse dmic pdm tokens failed %d\n",
2964                         le32_to_cpu(private->size));
2965                 goto err;
2966         }
2967
2968         /* set IPC header size */
2969         config->hdr.size = size;
2970
2971         /* debug messages */
2972         dev_dbg(scomp->dev, "tplg: config DMIC%d driver version %d\n",
2973                 config->dai_index, config->dmic.driver_ipc_version);
2974         dev_dbg(scomp->dev, "pdmclk_min %d pdm_clkmax %d duty_min %hd\n",
2975                 config->dmic.pdmclk_min, config->dmic.pdmclk_max,
2976                 config->dmic.duty_min);
2977         dev_dbg(scomp->dev, "duty_max %hd fifo_fs %d num_pdms active %d\n",
2978                 config->dmic.duty_max, config->dmic.fifo_fs,
2979                 config->dmic.num_pdm_active);
2980         dev_dbg(scomp->dev, "fifo word length %hd\n", config->dmic.fifo_bits);
2981
2982         for (j = 0; j < config->dmic.num_pdm_active; j++) {
2983                 dev_dbg(scomp->dev, "pdm %hd mic a %hd mic b %hd\n",
2984                         config->dmic.pdm[j].id,
2985                         config->dmic.pdm[j].enable_mic_a,
2986                         config->dmic.pdm[j].enable_mic_b);
2987                 dev_dbg(scomp->dev, "pdm %hd polarity a %hd polarity b %hd\n",
2988                         config->dmic.pdm[j].id,
2989                         config->dmic.pdm[j].polarity_mic_a,
2990                         config->dmic.pdm[j].polarity_mic_b);
2991                 dev_dbg(scomp->dev, "pdm %hd clk_edge %hd skew %hd\n",
2992                         config->dmic.pdm[j].id,
2993                         config->dmic.pdm[j].clk_edge,
2994                         config->dmic.pdm[j].skew);
2995         }
2996
2997         /*
2998          * this takes care of backwards compatible handling of fifo_bits_b.
2999          * It is deprecated since firmware ABI version 3.0.1.
3000          */
3001         if (SOF_ABI_VER(v->major, v->minor, v->micro) < SOF_ABI_VER(3, 0, 1))
3002                 config->dmic.fifo_bits_b = config->dmic.fifo_bits;
3003
3004         /* set config for all DAI's with name matching the link name */
3005         ret = sof_set_dai_config(sdev, size, link, config);
3006         if (ret < 0)
3007                 dev_err(scomp->dev, "error: failed to save DAI config for DMIC%d\n",
3008                         config->dai_index);
3009
3010 err:
3011         kfree(sdev->private);
3012
3013         return ret;
3014 }
3015
3016 static int sof_link_hda_load(struct snd_soc_component *scomp, int index,
3017                              struct snd_soc_dai_link *link,
3018                              struct snd_soc_tplg_link_config *cfg,
3019                              struct snd_soc_tplg_hw_config *hw_config,
3020                              struct sof_ipc_dai_config *config)
3021 {
3022         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3023         struct snd_soc_tplg_private *private = &cfg->priv;
3024         struct snd_soc_dai *dai;
3025         u32 size = sizeof(*config);
3026         int ret;
3027
3028         /* init IPC */
3029         memset(&config->hda, 0, sizeof(struct sof_ipc_dai_hda_params));
3030         config->hdr.size = size;
3031
3032         /* get any bespoke DAI tokens */
3033         ret = sof_parse_tokens(scomp, &config->hda, hda_tokens,
3034                                ARRAY_SIZE(hda_tokens), private->array,
3035                                le32_to_cpu(private->size));
3036         if (ret != 0) {
3037                 dev_err(scomp->dev, "error: parse hda tokens failed %d\n",
3038                         le32_to_cpu(private->size));
3039                 return ret;
3040         }
3041
3042         dev_dbg(scomp->dev, "HDA config rate %d channels %d\n",
3043                 config->hda.rate, config->hda.channels);
3044
3045         dai = snd_soc_find_dai(link->cpus);
3046         if (!dai) {
3047                 dev_err(scomp->dev, "error: failed to find dai %s in %s",
3048                         link->cpus->dai_name, __func__);
3049                 return -EINVAL;
3050         }
3051
3052         config->hda.link_dma_ch = DMA_CHAN_INVALID;
3053
3054         ret = sof_set_dai_config(sdev, size, link, config);
3055         if (ret < 0)
3056                 dev_err(scomp->dev, "error: failed to process hda dai link %s",
3057                         link->name);
3058
3059         return ret;
3060 }
3061
3062 static int sof_link_alh_load(struct snd_soc_component *scomp, int index,
3063                              struct snd_soc_dai_link *link,
3064                              struct snd_soc_tplg_link_config *cfg,
3065                              struct snd_soc_tplg_hw_config *hw_config,
3066                              struct sof_ipc_dai_config *config)
3067 {
3068         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3069         struct snd_soc_tplg_private *private = &cfg->priv;
3070         u32 size = sizeof(*config);
3071         int ret;
3072
3073         ret = sof_parse_tokens(scomp, &config->alh, alh_tokens,
3074                                ARRAY_SIZE(alh_tokens), private->array,
3075                                le32_to_cpu(private->size));
3076         if (ret != 0) {
3077                 dev_err(scomp->dev, "error: parse alh tokens failed %d\n",
3078                         le32_to_cpu(private->size));
3079                 return ret;
3080         }
3081
3082         /* init IPC */
3083         config->hdr.size = size;
3084
3085         /* set config for all DAI's with name matching the link name */
3086         ret = sof_set_dai_config(sdev, size, link, config);
3087         if (ret < 0)
3088                 dev_err(scomp->dev, "error: failed to save DAI config for ALH %d\n",
3089                         config->dai_index);
3090
3091         return ret;
3092 }
3093
3094 /* DAI link - used for any driver specific init */
3095 static int sof_link_load(struct snd_soc_component *scomp, int index,
3096                          struct snd_soc_dai_link *link,
3097                          struct snd_soc_tplg_link_config *cfg)
3098 {
3099         struct snd_soc_tplg_private *private = &cfg->priv;
3100         struct sof_ipc_dai_config config;
3101         struct snd_soc_tplg_hw_config *hw_config;
3102         int num_hw_configs;
3103         int ret;
3104         int i = 0;
3105
3106         if (!link->platforms) {
3107                 dev_err(scomp->dev, "error: no platforms\n");
3108                 return -EINVAL;
3109         }
3110         link->platforms->name = dev_name(scomp->dev);
3111
3112         /*
3113          * Set nonatomic property for FE dai links as their trigger action
3114          * involves IPC's.
3115          */
3116         if (!link->no_pcm) {
3117                 link->nonatomic = true;
3118
3119                 /*
3120                  * set default trigger order for all links. Exceptions to
3121                  * the rule will be handled in sof_pcm_dai_link_fixup()
3122                  * For playback, the sequence is the following: start FE,
3123                  * start BE, stop BE, stop FE; for Capture the sequence is
3124                  * inverted start BE, start FE, stop FE, stop BE
3125                  */
3126                 link->trigger[SNDRV_PCM_STREAM_PLAYBACK] =
3127                                         SND_SOC_DPCM_TRIGGER_PRE;
3128                 link->trigger[SNDRV_PCM_STREAM_CAPTURE] =
3129                                         SND_SOC_DPCM_TRIGGER_POST;
3130
3131                 /* nothing more to do for FE dai links */
3132                 return 0;
3133         }
3134
3135         /* check we have some tokens - we need at least DAI type */
3136         if (le32_to_cpu(private->size) == 0) {
3137                 dev_err(scomp->dev, "error: expected tokens for DAI, none found\n");
3138                 return -EINVAL;
3139         }
3140
3141         /* Send BE DAI link configurations to DSP */
3142         memset(&config, 0, sizeof(config));
3143
3144         /* get any common DAI tokens */
3145         ret = sof_parse_tokens(scomp, &config, dai_link_tokens,
3146                                ARRAY_SIZE(dai_link_tokens), private->array,
3147                                le32_to_cpu(private->size));
3148         if (ret != 0) {
3149                 dev_err(scomp->dev, "error: parse link tokens failed %d\n",
3150                         le32_to_cpu(private->size));
3151                 return ret;
3152         }
3153
3154         /*
3155          * DAI links are expected to have at least 1 hw_config.
3156          * But some older topologies might have no hw_config for HDA dai links.
3157          */
3158         num_hw_configs = le32_to_cpu(cfg->num_hw_configs);
3159         if (!num_hw_configs) {
3160                 if (config.type != SOF_DAI_INTEL_HDA) {
3161                         dev_err(scomp->dev, "error: unexpected DAI config count %d!\n",
3162                                 le32_to_cpu(cfg->num_hw_configs));
3163                         return -EINVAL;
3164                 }
3165         } else {
3166                 dev_dbg(scomp->dev, "tplg: %d hw_configs found, default id: %d!\n",
3167                         cfg->num_hw_configs, le32_to_cpu(cfg->default_hw_config_id));
3168
3169                 for (i = 0; i < num_hw_configs; i++) {
3170                         if (cfg->hw_config[i].id == cfg->default_hw_config_id)
3171                                 break;
3172                 }
3173
3174                 if (i == num_hw_configs) {
3175                         dev_err(scomp->dev, "error: default hw_config id: %d not found!\n",
3176                                 le32_to_cpu(cfg->default_hw_config_id));
3177                         return -EINVAL;
3178                 }
3179         }
3180
3181         /* configure dai IPC message */
3182         hw_config = &cfg->hw_config[i];
3183
3184         config.hdr.cmd = SOF_IPC_GLB_DAI_MSG | SOF_IPC_DAI_CONFIG;
3185         config.format = le32_to_cpu(hw_config->fmt);
3186
3187         /* now load DAI specific data and send IPC - type comes from token */
3188         switch (config.type) {
3189         case SOF_DAI_INTEL_SSP:
3190                 ret = sof_link_ssp_load(scomp, index, link, cfg, hw_config,
3191                                         &config);
3192                 break;
3193         case SOF_DAI_INTEL_DMIC:
3194                 ret = sof_link_dmic_load(scomp, index, link, cfg, hw_config,
3195                                          &config);
3196                 break;
3197         case SOF_DAI_INTEL_HDA:
3198                 ret = sof_link_hda_load(scomp, index, link, cfg, hw_config,
3199                                         &config);
3200                 break;
3201         case SOF_DAI_INTEL_ALH:
3202                 ret = sof_link_alh_load(scomp, index, link, cfg, hw_config,
3203                                         &config);
3204                 break;
3205         case SOF_DAI_IMX_SAI:
3206                 ret = sof_link_sai_load(scomp, index, link, cfg, hw_config,
3207                                         &config);
3208                 break;
3209         case SOF_DAI_IMX_ESAI:
3210                 ret = sof_link_esai_load(scomp, index, link, cfg, hw_config,
3211                                          &config);
3212                 break;
3213         default:
3214                 dev_err(scomp->dev, "error: invalid DAI type %d\n",
3215                         config.type);
3216                 ret = -EINVAL;
3217                 break;
3218         }
3219         if (ret < 0)
3220                 return ret;
3221
3222         return 0;
3223 }
3224
3225 static int sof_link_hda_unload(struct snd_sof_dev *sdev,
3226                                struct snd_soc_dai_link *link)
3227 {
3228         struct snd_soc_dai *dai;
3229         int ret = 0;
3230
3231         dai = snd_soc_find_dai(link->cpus);
3232         if (!dai) {
3233                 dev_err(sdev->dev, "error: failed to find dai %s in %s",
3234                         link->cpus->dai_name, __func__);
3235                 return -EINVAL;
3236         }
3237
3238         return ret;
3239 }
3240
3241 static int sof_link_unload(struct snd_soc_component *scomp,
3242                            struct snd_soc_dobj *dobj)
3243 {
3244         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3245         struct snd_soc_dai_link *link =
3246                 container_of(dobj, struct snd_soc_dai_link, dobj);
3247
3248         struct snd_sof_dai *sof_dai;
3249         int ret = 0;
3250
3251         /* only BE link is loaded by sof */
3252         if (!link->no_pcm)
3253                 return 0;
3254
3255         list_for_each_entry(sof_dai, &sdev->dai_list, list) {
3256                 if (!sof_dai->name)
3257                         continue;
3258
3259                 if (strcmp(link->name, sof_dai->name) == 0)
3260                         goto found;
3261         }
3262
3263         dev_err(scomp->dev, "error: failed to find dai %s in %s",
3264                 link->name, __func__);
3265         return -EINVAL;
3266 found:
3267
3268         switch (sof_dai->dai_config->type) {
3269         case SOF_DAI_INTEL_SSP:
3270         case SOF_DAI_INTEL_DMIC:
3271         case SOF_DAI_INTEL_ALH:
3272         case SOF_DAI_IMX_SAI:
3273         case SOF_DAI_IMX_ESAI:
3274                 /* no resource needs to be released for all cases above */
3275                 break;
3276         case SOF_DAI_INTEL_HDA:
3277                 ret = sof_link_hda_unload(sdev, link);
3278                 break;
3279         default:
3280                 dev_err(scomp->dev, "error: invalid DAI type %d\n",
3281                         sof_dai->dai_config->type);
3282                 ret = -EINVAL;
3283                 break;
3284         }
3285
3286         return ret;
3287 }
3288
3289 /* DAI link - used for any driver specific init */
3290 static int sof_route_load(struct snd_soc_component *scomp, int index,
3291                           struct snd_soc_dapm_route *route)
3292 {
3293         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3294         struct sof_ipc_pipe_comp_connect *connect;
3295         struct snd_sof_widget *source_swidget, *sink_swidget;
3296         struct snd_soc_dobj *dobj = &route->dobj;
3297         struct snd_sof_route *sroute;
3298         struct sof_ipc_reply reply;
3299         int ret = 0;
3300
3301         /* allocate memory for sroute and connect */
3302         sroute = kzalloc(sizeof(*sroute), GFP_KERNEL);
3303         if (!sroute)
3304                 return -ENOMEM;
3305
3306         sroute->scomp = scomp;
3307
3308         connect = kzalloc(sizeof(*connect), GFP_KERNEL);
3309         if (!connect) {
3310                 kfree(sroute);
3311                 return -ENOMEM;
3312         }
3313
3314         connect->hdr.size = sizeof(*connect);
3315         connect->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_CONNECT;
3316
3317         dev_dbg(scomp->dev, "sink %s control %s source %s\n",
3318                 route->sink, route->control ? route->control : "none",
3319                 route->source);
3320
3321         /* source component */
3322         source_swidget = snd_sof_find_swidget(scomp, (char *)route->source);
3323         if (!source_swidget) {
3324                 dev_err(scomp->dev, "error: source %s not found\n",
3325                         route->source);
3326                 ret = -EINVAL;
3327                 goto err;
3328         }
3329
3330         /*
3331          * Virtual widgets of type output/out_drv may be added in topology
3332          * for compatibility. These are not handled by the FW.
3333          * So, don't send routes whose source/sink widget is of such types
3334          * to the DSP.
3335          */
3336         if (source_swidget->id == snd_soc_dapm_out_drv ||
3337             source_swidget->id == snd_soc_dapm_output)
3338                 goto err;
3339
3340         connect->source_id = source_swidget->comp_id;
3341
3342         /* sink component */
3343         sink_swidget = snd_sof_find_swidget(scomp, (char *)route->sink);
3344         if (!sink_swidget) {
3345                 dev_err(scomp->dev, "error: sink %s not found\n",
3346                         route->sink);
3347                 ret = -EINVAL;
3348                 goto err;
3349         }
3350
3351         /*
3352          * Don't send routes whose sink widget is of type
3353          * output or out_drv to the DSP
3354          */
3355         if (sink_swidget->id == snd_soc_dapm_out_drv ||
3356             sink_swidget->id == snd_soc_dapm_output)
3357                 goto err;
3358
3359         connect->sink_id = sink_swidget->comp_id;
3360
3361         /*
3362          * For virtual routes, both sink and source are not
3363          * buffer. Since only buffer linked to component is supported by
3364          * FW, others are reported as error, add check in route function,
3365          * do not send it to FW when both source and sink are not buffer
3366          */
3367         if (source_swidget->id != snd_soc_dapm_buffer &&
3368             sink_swidget->id != snd_soc_dapm_buffer) {
3369                 dev_dbg(scomp->dev, "warning: neither Linked source component %s nor sink component %s is of buffer type, ignoring link\n",
3370                         route->source, route->sink);
3371                 ret = 0;
3372                 goto err;
3373         } else {
3374                 ret = sof_ipc_tx_message(sdev->ipc,
3375                                          connect->hdr.cmd,
3376                                          connect, sizeof(*connect),
3377                                          &reply, sizeof(reply));
3378
3379                 /* check IPC return value */
3380                 if (ret < 0) {
3381                         dev_err(scomp->dev, "error: failed to add route sink %s control %s source %s\n",
3382                                 route->sink,
3383                                 route->control ? route->control : "none",
3384                                 route->source);
3385                         goto err;
3386                 }
3387
3388                 /* check IPC reply */
3389                 if (reply.error < 0) {
3390                         dev_err(scomp->dev, "error: DSP failed to add route sink %s control %s source %s result %d\n",
3391                                 route->sink,
3392                                 route->control ? route->control : "none",
3393                                 route->source, reply.error);
3394                         ret = reply.error;
3395                         goto err;
3396                 }
3397
3398                 sroute->route = route;
3399                 dobj->private = sroute;
3400                 sroute->private = connect;
3401
3402                 /* add route to route list */
3403                 list_add(&sroute->list, &sdev->route_list);
3404
3405                 return ret;
3406         }
3407
3408 err:
3409         kfree(connect);
3410         kfree(sroute);
3411         return ret;
3412 }
3413
3414 /* Function to set the initial value of SOF kcontrols.
3415  * The value will be stored in scontrol->control_data
3416  */
3417 static int snd_sof_cache_kcontrol_val(struct snd_soc_component *scomp)
3418 {
3419         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3420         struct snd_sof_control *scontrol = NULL;
3421         int ipc_cmd, ctrl_type;
3422         int ret = 0;
3423
3424         list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
3425
3426                 /* notify DSP of kcontrol values */
3427                 switch (scontrol->cmd) {
3428                 case SOF_CTRL_CMD_VOLUME:
3429                 case SOF_CTRL_CMD_ENUM:
3430                 case SOF_CTRL_CMD_SWITCH:
3431                         ipc_cmd = SOF_IPC_COMP_GET_VALUE;
3432                         ctrl_type = SOF_CTRL_TYPE_VALUE_CHAN_GET;
3433                         break;
3434                 case SOF_CTRL_CMD_BINARY:
3435                         ipc_cmd = SOF_IPC_COMP_GET_DATA;
3436                         ctrl_type = SOF_CTRL_TYPE_DATA_GET;
3437                         break;
3438                 default:
3439                         dev_err(scomp->dev,
3440                                 "error: Invalid scontrol->cmd: %d\n",
3441                                 scontrol->cmd);
3442                         return -EINVAL;
3443                 }
3444                 ret = snd_sof_ipc_set_get_comp_data(scontrol,
3445                                                     ipc_cmd, ctrl_type,
3446                                                     scontrol->cmd,
3447                                                     false);
3448                 if (ret < 0) {
3449                         dev_warn(scomp->dev,
3450                                  "error: kcontrol value get for widget: %d\n",
3451                                  scontrol->comp_id);
3452                 }
3453         }
3454
3455         return ret;
3456 }
3457
3458 int snd_sof_complete_pipeline(struct device *dev,
3459                               struct snd_sof_widget *swidget)
3460 {
3461         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
3462         struct sof_ipc_pipe_ready ready;
3463         struct sof_ipc_reply reply;
3464         int ret;
3465
3466         dev_dbg(dev, "tplg: complete pipeline %s id %d\n",
3467                 swidget->widget->name, swidget->comp_id);
3468
3469         memset(&ready, 0, sizeof(ready));
3470         ready.hdr.size = sizeof(ready);
3471         ready.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_COMPLETE;
3472         ready.comp_id = swidget->comp_id;
3473
3474         ret = sof_ipc_tx_message(sdev->ipc,
3475                                  ready.hdr.cmd, &ready, sizeof(ready), &reply,
3476                                  sizeof(reply));
3477         if (ret < 0)
3478                 return ret;
3479         return 1;
3480 }
3481
3482 /* completion - called at completion of firmware loading */
3483 static void sof_complete(struct snd_soc_component *scomp)
3484 {
3485         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
3486         struct snd_sof_widget *swidget;
3487
3488         /* some widget types require completion notificattion */
3489         list_for_each_entry(swidget, &sdev->widget_list, list) {
3490                 if (swidget->complete)
3491                         continue;
3492
3493                 switch (swidget->id) {
3494                 case snd_soc_dapm_scheduler:
3495                         swidget->complete =
3496                                 snd_sof_complete_pipeline(scomp->dev, swidget);
3497                         break;
3498                 default:
3499                         break;
3500                 }
3501         }
3502         /*
3503          * cache initial values of SOF kcontrols by reading DSP value over
3504          * IPC. It may be overwritten by alsa-mixer after booting up
3505          */
3506         snd_sof_cache_kcontrol_val(scomp);
3507 }
3508
3509 /* manifest - optional to inform component of manifest */
3510 static int sof_manifest(struct snd_soc_component *scomp, int index,
3511                         struct snd_soc_tplg_manifest *man)
3512 {
3513         u32 size;
3514         u32 abi_version;
3515
3516         size = le32_to_cpu(man->priv.size);
3517
3518         /* backward compatible with tplg without ABI info */
3519         if (!size) {
3520                 dev_dbg(scomp->dev, "No topology ABI info\n");
3521                 return 0;
3522         }
3523
3524         if (size != SOF_TPLG_ABI_SIZE) {
3525                 dev_err(scomp->dev, "error: invalid topology ABI size\n");
3526                 return -EINVAL;
3527         }
3528
3529         dev_info(scomp->dev,
3530                  "Topology: ABI %d:%d:%d Kernel ABI %d:%d:%d\n",
3531                  man->priv.data[0], man->priv.data[1],
3532                  man->priv.data[2], SOF_ABI_MAJOR, SOF_ABI_MINOR,
3533                  SOF_ABI_PATCH);
3534
3535         abi_version = SOF_ABI_VER(man->priv.data[0],
3536                                   man->priv.data[1],
3537                                   man->priv.data[2]);
3538
3539         if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, abi_version)) {
3540                 dev_err(scomp->dev, "error: incompatible topology ABI version\n");
3541                 return -EINVAL;
3542         }
3543
3544         if (abi_version > SOF_ABI_VERSION) {
3545                 if (!IS_ENABLED(CONFIG_SND_SOC_SOF_STRICT_ABI_CHECKS)) {
3546                         dev_warn(scomp->dev, "warn: topology ABI is more recent than kernel\n");
3547                 } else {
3548                         dev_err(scomp->dev, "error: topology ABI is more recent than kernel\n");
3549                         return -EINVAL;
3550                 }
3551         }
3552
3553         return 0;
3554 }
3555
3556 /* vendor specific kcontrol handlers available for binding */
3557 static const struct snd_soc_tplg_kcontrol_ops sof_io_ops[] = {
3558         {SOF_TPLG_KCTL_VOL_ID, snd_sof_volume_get, snd_sof_volume_put},
3559         {SOF_TPLG_KCTL_BYTES_ID, snd_sof_bytes_get, snd_sof_bytes_put},
3560         {SOF_TPLG_KCTL_ENUM_ID, snd_sof_enum_get, snd_sof_enum_put},
3561         {SOF_TPLG_KCTL_SWITCH_ID, snd_sof_switch_get, snd_sof_switch_put},
3562 };
3563
3564 /* vendor specific bytes ext handlers available for binding */
3565 static const struct snd_soc_tplg_bytes_ext_ops sof_bytes_ext_ops[] = {
3566         {SOF_TPLG_KCTL_BYTES_ID, snd_sof_bytes_ext_get, snd_sof_bytes_ext_put},
3567 };
3568
3569 static struct snd_soc_tplg_ops sof_tplg_ops = {
3570         /* external kcontrol init - used for any driver specific init */
3571         .control_load   = sof_control_load,
3572         .control_unload = sof_control_unload,
3573
3574         /* external kcontrol init - used for any driver specific init */
3575         .dapm_route_load        = sof_route_load,
3576         .dapm_route_unload      = sof_route_unload,
3577
3578         /* external widget init - used for any driver specific init */
3579         /* .widget_load is not currently used */
3580         .widget_ready   = sof_widget_ready,
3581         .widget_unload  = sof_widget_unload,
3582
3583         /* FE DAI - used for any driver specific init */
3584         .dai_load       = sof_dai_load,
3585         .dai_unload     = sof_dai_unload,
3586
3587         /* DAI link - used for any driver specific init */
3588         .link_load      = sof_link_load,
3589         .link_unload    = sof_link_unload,
3590
3591         /* completion - called at completion of firmware loading */
3592         .complete       = sof_complete,
3593
3594         /* manifest - optional to inform component of manifest */
3595         .manifest       = sof_manifest,
3596
3597         /* vendor specific kcontrol handlers available for binding */
3598         .io_ops         = sof_io_ops,
3599         .io_ops_count   = ARRAY_SIZE(sof_io_ops),
3600
3601         /* vendor specific bytes ext handlers available for binding */
3602         .bytes_ext_ops  = sof_bytes_ext_ops,
3603         .bytes_ext_ops_count    = ARRAY_SIZE(sof_bytes_ext_ops),
3604 };
3605
3606 int snd_sof_load_topology(struct snd_soc_component *scomp, const char *file)
3607 {
3608         const struct firmware *fw;
3609         int ret;
3610
3611         dev_dbg(scomp->dev, "loading topology:%s\n", file);
3612
3613         ret = request_firmware(&fw, file, scomp->dev);
3614         if (ret < 0) {
3615                 dev_err(scomp->dev, "error: tplg request firmware %s failed err: %d\n",
3616                         file, ret);
3617                 return ret;
3618         }
3619
3620         ret = snd_soc_tplg_component_load(scomp,
3621                                           &sof_tplg_ops, fw,
3622                                           SND_SOC_TPLG_INDEX_ALL);
3623         if (ret < 0) {
3624                 dev_err(scomp->dev, "error: tplg component load failed %d\n",
3625                         ret);
3626                 ret = -EINVAL;
3627         }
3628
3629         release_firmware(fw);
3630         return ret;
3631 }
3632 EXPORT_SYMBOL(snd_sof_load_topology);