Loading...
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 <liam.r.girdwood@linux.intel.com>
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
47struct 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 */
55static 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 */
115static 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
138static 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 */
215static const struct snd_soc_tplg_widget_events sof_kwd_events[] = {
216 {SOF_KEYWORD_DETECT_DAPM_EVENT, sof_keyword_dapm_event},
217};
218
219static 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 */
247static 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 */
268static 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 */
309static 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 */
347static 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
364struct sof_dai_types {
365 const char *name;
366 enum sof_ipc_dai_type type;
367};
368
369static 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
378static 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
394struct sof_frame_types {
395 const char *name;
396 enum sof_ipc_frame frame;
397};
398
399static 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
406static 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
419struct sof_process_types {
420 const char *name;
421 enum sof_ipc_process_type type;
422 enum sof_comp_type comp_type;
423};
424
425static 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
437static 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
449static 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
466struct 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
474static 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
483static 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
492static 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
501static 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
510static 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 */
521static 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 */
529static 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 */
539static 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 */
547static 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 */
563static 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 */
572static 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 */
580static 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 */
594static const struct sof_topology_token tone_tokens[] = {
595};
596
597/* EFFECT */
598static 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 */
605static 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 */
611static 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 */
621static 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 */
634static 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 */
661static 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 */
671static 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 */
705static 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 */
712static 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 */
724static 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 */
756static 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 */
766static 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
773static 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
810static 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
847static 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 */
901static 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
969static 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
986static 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
998static 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
1060skip:
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
1076out_free_table:
1077 if (le32_to_cpu(mc->max) > 1)
1078 kfree(scontrol->volume_table);
1079out_free:
1080 kfree(scontrol->control_data);
1081out:
1082 return ret;
1083}
1084
1085static 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
1116static 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
1182out_free:
1183 kfree(scontrol->control_data);
1184out:
1185 return ret;
1186}
1187
1188/* external kcontrol init - used for any driver specific init */
1189static 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
1255static 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
1281static 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
1362static 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
1419static 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 */
1467static 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
1489static 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;
1540err:
1541 kfree(host);
1542 return ret;
1543}
1544
1545/*
1546 * Pipeline Topology
1547 */
1548int 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
1595static 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;
1648err:
1649 kfree(pipeline);
1650 return ret;
1651}
1652
1653/*
1654 * Mixer topology
1655 */
1656
1657static 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 */
1704static 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
1752static 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;
1821err:
1822 kfree(volume);
1823 return ret;
1824}
1825
1826/*
1827 * SRC Topology
1828 */
1829
1830static 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;
1880err:
1881 kfree(src);
1882 return ret;
1883}
1884
1885/*
1886 * ASRC Topology
1887 */
1888
1889static 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;
1941err:
1942 kfree(asrc);
1943 return ret;
1944}
1945
1946/*
1947 * Signal Generator Topology
1948 */
1949
1950static 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;
2000err:
2001 kfree(tone);
2002 return ret;
2003}
2004
2005static 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
2077static 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
2195err:
2196 if (ret < 0)
2197 kfree(process);
2198out:
2199 kfree(wdata);
2200 return ret;
2201}
2202
2203/*
2204 * Processing Component Topology - can be "effect", "codec", or general
2205 * "processing".
2206 */
2207
2208static 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
2246static 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 */
2279static 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
2410static 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
2427static 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
2502out:
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 */
2518static 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
2589capture:
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
2621free_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
2628static 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
2647static 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 */
2684static 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
2741static 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
2806static 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
2864static 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
2921static 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
3010err:
3011 kfree(sdev->private);
3012
3013 return ret;
3014}
3015
3016static 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
3062static 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 */
3095static 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
3225static 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
3241static 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;
3266found:
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 */
3290static 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
3408err:
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 */
3417static 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
3458int 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 */
3483static 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 */
3510static 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 */
3557static 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 */
3565static 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
3569static 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
3606int 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}
3632EXPORT_SYMBOL(snd_sof_load_topology);
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 <liam.r.girdwood@linux.intel.com>
9//
10
11#include <linux/bits.h>
12#include <linux/device.h>
13#include <linux/errno.h>
14#include <linux/firmware.h>
15#include <linux/workqueue.h>
16#include <sound/tlv.h>
17#include <uapi/sound/sof/tokens.h>
18#include "sof-priv.h"
19#include "sof-audio.h"
20#include "ops.h"
21
22#define COMP_ID_UNASSIGNED 0xffffffff
23/*
24 * Constants used in the computation of linear volume gain
25 * from dB gain 20th root of 10 in Q1.16 fixed-point notation
26 */
27#define VOL_TWENTIETH_ROOT_OF_TEN 73533
28/* 40th root of 10 in Q1.16 fixed-point notation*/
29#define VOL_FORTIETH_ROOT_OF_TEN 69419
30
31/* 0.5 dB step value in topology TLV */
32#define VOL_HALF_DB_STEP 50
33
34/* TLV data items */
35#define TLV_MIN 0
36#define TLV_STEP 1
37#define TLV_MUTE 2
38
39/**
40 * sof_update_ipc_object - Parse multiple sets of tokens within the token array associated with the
41 * token ID.
42 * @scomp: pointer to SOC component
43 * @object: target IPC struct to save the parsed values
44 * @token_id: token ID for the token array to be searched
45 * @tuples: pointer to the tuples array
46 * @num_tuples: number of tuples in the tuples array
47 * @object_size: size of the object
48 * @token_instance_num: number of times the same @token_id needs to be parsed i.e. the function
49 * looks for @token_instance_num of each token in the token array associated
50 * with the @token_id
51 */
52int sof_update_ipc_object(struct snd_soc_component *scomp, void *object, enum sof_tokens token_id,
53 struct snd_sof_tuple *tuples, int num_tuples,
54 size_t object_size, int token_instance_num)
55{
56 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
57 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
58 const struct sof_token_info *token_list = ipc_tplg_ops->token_list;
59 const struct sof_topology_token *tokens;
60 int i, j;
61
62 if (token_list[token_id].count < 0) {
63 dev_err(scomp->dev, "Invalid token count for token ID: %d\n", token_id);
64 return -EINVAL;
65 }
66
67 /* No tokens to match */
68 if (!token_list[token_id].count)
69 return 0;
70
71 tokens = token_list[token_id].tokens;
72 if (!tokens) {
73 dev_err(scomp->dev, "Invalid tokens for token id: %d\n", token_id);
74 return -EINVAL;
75 }
76
77 for (i = 0; i < token_list[token_id].count; i++) {
78 int offset = 0;
79 int num_tokens_matched = 0;
80
81 for (j = 0; j < num_tuples; j++) {
82 if (tokens[i].token == tuples[j].token) {
83 switch (tokens[i].type) {
84 case SND_SOC_TPLG_TUPLE_TYPE_WORD:
85 {
86 u32 *val = (u32 *)((u8 *)object + tokens[i].offset +
87 offset);
88
89 *val = tuples[j].value.v;
90 break;
91 }
92 case SND_SOC_TPLG_TUPLE_TYPE_SHORT:
93 case SND_SOC_TPLG_TUPLE_TYPE_BOOL:
94 {
95 u16 *val = (u16 *)((u8 *)object + tokens[i].offset +
96 offset);
97
98 *val = (u16)tuples[j].value.v;
99 break;
100 }
101 case SND_SOC_TPLG_TUPLE_TYPE_STRING:
102 {
103 if (!tokens[i].get_token) {
104 dev_err(scomp->dev,
105 "get_token not defined for token %d in %s\n",
106 tokens[i].token, token_list[token_id].name);
107 return -EINVAL;
108 }
109
110 tokens[i].get_token((void *)tuples[j].value.s, object,
111 tokens[i].offset + offset);
112 break;
113 }
114 default:
115 break;
116 }
117
118 num_tokens_matched++;
119
120 /* found all required sets of current token. Move to the next one */
121 if (!(num_tokens_matched % token_instance_num))
122 break;
123
124 /* move to the next object */
125 offset += object_size;
126 }
127 }
128 }
129
130 return 0;
131}
132
133static inline int get_tlv_data(const int *p, int tlv[SOF_TLV_ITEMS])
134{
135 /* we only support dB scale TLV type at the moment */
136 if ((int)p[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
137 return -EINVAL;
138
139 /* min value in topology tlv data is multiplied by 100 */
140 tlv[TLV_MIN] = (int)p[SNDRV_CTL_TLVO_DB_SCALE_MIN] / 100;
141
142 /* volume steps */
143 tlv[TLV_STEP] = (int)(p[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] &
144 TLV_DB_SCALE_MASK);
145
146 /* mute ON/OFF */
147 if ((p[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] &
148 TLV_DB_SCALE_MUTE) == 0)
149 tlv[TLV_MUTE] = 0;
150 else
151 tlv[TLV_MUTE] = 1;
152
153 return 0;
154}
155
156/*
157 * Function to truncate an unsigned 64-bit number
158 * by x bits and return 32-bit unsigned number. This
159 * function also takes care of rounding while truncating
160 */
161static inline u32 vol_shift_64(u64 i, u32 x)
162{
163 /* do not truncate more than 32 bits */
164 if (x > 32)
165 x = 32;
166
167 if (x == 0)
168 return (u32)i;
169
170 return (u32)(((i >> (x - 1)) + 1) >> 1);
171}
172
173/*
174 * Function to compute a ^ exp where,
175 * a is a fractional number represented by a fixed-point
176 * integer with a fractional world length of "fwl"
177 * exp is an integer
178 * fwl is the fractional word length
179 * Return value is a fractional number represented by a
180 * fixed-point integer with a fractional word length of "fwl"
181 */
182static u32 vol_pow32(u32 a, int exp, u32 fwl)
183{
184 int i, iter;
185 u32 power = 1 << fwl;
186 u64 numerator;
187
188 /* if exponent is 0, return 1 */
189 if (exp == 0)
190 return power;
191
192 /* determine the number of iterations based on the exponent */
193 if (exp < 0)
194 iter = exp * -1;
195 else
196 iter = exp;
197
198 /* mutiply a "iter" times to compute power */
199 for (i = 0; i < iter; i++) {
200 /*
201 * Product of 2 Qx.fwl fixed-point numbers yields a Q2*x.2*fwl
202 * Truncate product back to fwl fractional bits with rounding
203 */
204 power = vol_shift_64((u64)power * a, fwl);
205 }
206
207 if (exp > 0) {
208 /* if exp is positive, return the result */
209 return power;
210 }
211
212 /* if exp is negative, return the multiplicative inverse */
213 numerator = (u64)1 << (fwl << 1);
214 do_div(numerator, power);
215
216 return (u32)numerator;
217}
218
219/*
220 * Function to calculate volume gain from TLV data.
221 * This function can only handle gain steps that are multiples of 0.5 dB
222 */
223u32 vol_compute_gain(u32 value, int *tlv)
224{
225 int dB_gain;
226 u32 linear_gain;
227 int f_step;
228
229 /* mute volume */
230 if (value == 0 && tlv[TLV_MUTE])
231 return 0;
232
233 /*
234 * compute dB gain from tlv. tlv_step
235 * in topology is multiplied by 100
236 */
237 dB_gain = tlv[TLV_MIN] + (value * tlv[TLV_STEP]) / 100;
238
239 /*
240 * compute linear gain represented by fixed-point
241 * int with VOLUME_FWL fractional bits
242 */
243 linear_gain = vol_pow32(VOL_TWENTIETH_ROOT_OF_TEN, dB_gain, VOLUME_FWL);
244
245 /* extract the fractional part of volume step */
246 f_step = tlv[TLV_STEP] - (tlv[TLV_STEP] / 100);
247
248 /* if volume step is an odd multiple of 0.5 dB */
249 if (f_step == VOL_HALF_DB_STEP && (value & 1))
250 linear_gain = vol_shift_64((u64)linear_gain *
251 VOL_FORTIETH_ROOT_OF_TEN,
252 VOLUME_FWL);
253
254 return linear_gain;
255}
256
257/*
258 * Set up volume table for kcontrols from tlv data
259 * "size" specifies the number of entries in the table
260 */
261static int set_up_volume_table(struct snd_sof_control *scontrol,
262 int tlv[SOF_TLV_ITEMS], int size)
263{
264 struct snd_soc_component *scomp = scontrol->scomp;
265 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
266 const struct sof_ipc_tplg_ops *tplg_ops = sdev->ipc->ops->tplg;
267
268 if (tplg_ops->control->set_up_volume_table)
269 return tplg_ops->control->set_up_volume_table(scontrol, tlv, size);
270
271 dev_err(scomp->dev, "Mandatory op %s not set\n", __func__);
272 return -EINVAL;
273}
274
275struct sof_dai_types {
276 const char *name;
277 enum sof_ipc_dai_type type;
278};
279
280static const struct sof_dai_types sof_dais[] = {
281 {"SSP", SOF_DAI_INTEL_SSP},
282 {"HDA", SOF_DAI_INTEL_HDA},
283 {"DMIC", SOF_DAI_INTEL_DMIC},
284 {"ALH", SOF_DAI_INTEL_ALH},
285 {"SAI", SOF_DAI_IMX_SAI},
286 {"ESAI", SOF_DAI_IMX_ESAI},
287 {"ACP", SOF_DAI_AMD_BT},
288 {"ACPSP", SOF_DAI_AMD_SP},
289 {"ACPDMIC", SOF_DAI_AMD_DMIC},
290 {"ACPHS", SOF_DAI_AMD_HS},
291 {"AFE", SOF_DAI_MEDIATEK_AFE},
292 {"ACPSP_VIRTUAL", SOF_DAI_AMD_SP_VIRTUAL},
293 {"ACPHS_VIRTUAL", SOF_DAI_AMD_HS_VIRTUAL},
294
295};
296
297static enum sof_ipc_dai_type find_dai(const char *name)
298{
299 int i;
300
301 for (i = 0; i < ARRAY_SIZE(sof_dais); i++) {
302 if (strcmp(name, sof_dais[i].name) == 0)
303 return sof_dais[i].type;
304 }
305
306 return SOF_DAI_INTEL_NONE;
307}
308
309/*
310 * Supported Frame format types and lookup, add new ones to end of list.
311 */
312
313struct sof_frame_types {
314 const char *name;
315 enum sof_ipc_frame frame;
316};
317
318static const struct sof_frame_types sof_frames[] = {
319 {"s16le", SOF_IPC_FRAME_S16_LE},
320 {"s24le", SOF_IPC_FRAME_S24_4LE},
321 {"s32le", SOF_IPC_FRAME_S32_LE},
322 {"float", SOF_IPC_FRAME_FLOAT},
323};
324
325static enum sof_ipc_frame find_format(const char *name)
326{
327 int i;
328
329 for (i = 0; i < ARRAY_SIZE(sof_frames); i++) {
330 if (strcmp(name, sof_frames[i].name) == 0)
331 return sof_frames[i].frame;
332 }
333
334 /* use s32le if nothing is specified */
335 return SOF_IPC_FRAME_S32_LE;
336}
337
338int get_token_u32(void *elem, void *object, u32 offset)
339{
340 struct snd_soc_tplg_vendor_value_elem *velem = elem;
341 u32 *val = (u32 *)((u8 *)object + offset);
342
343 *val = le32_to_cpu(velem->value);
344 return 0;
345}
346
347int get_token_u16(void *elem, void *object, u32 offset)
348{
349 struct snd_soc_tplg_vendor_value_elem *velem = elem;
350 u16 *val = (u16 *)((u8 *)object + offset);
351
352 *val = (u16)le32_to_cpu(velem->value);
353 return 0;
354}
355
356int get_token_uuid(void *elem, void *object, u32 offset)
357{
358 struct snd_soc_tplg_vendor_uuid_elem *velem = elem;
359 u8 *dst = (u8 *)object + offset;
360
361 memcpy(dst, velem->uuid, UUID_SIZE);
362
363 return 0;
364}
365
366/*
367 * The string gets from topology will be stored in heap, the owner only
368 * holds a char* member point to the heap.
369 */
370int get_token_string(void *elem, void *object, u32 offset)
371{
372 /* "dst" here points to the char* member of the owner */
373 char **dst = (char **)((u8 *)object + offset);
374
375 *dst = kstrdup(elem, GFP_KERNEL);
376 if (!*dst)
377 return -ENOMEM;
378 return 0;
379};
380
381int get_token_comp_format(void *elem, void *object, u32 offset)
382{
383 u32 *val = (u32 *)((u8 *)object + offset);
384
385 *val = find_format((const char *)elem);
386 return 0;
387}
388
389int get_token_dai_type(void *elem, void *object, u32 offset)
390{
391 u32 *val = (u32 *)((u8 *)object + offset);
392
393 *val = find_dai((const char *)elem);
394 return 0;
395}
396
397/* PCM */
398static const struct sof_topology_token stream_tokens[] = {
399 {SOF_TKN_STREAM_PLAYBACK_COMPATIBLE_D0I3, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
400 offsetof(struct snd_sof_pcm, stream[0].d0i3_compatible)},
401 {SOF_TKN_STREAM_CAPTURE_COMPATIBLE_D0I3, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
402 offsetof(struct snd_sof_pcm, stream[1].d0i3_compatible)},
403};
404
405/* Leds */
406static const struct sof_topology_token led_tokens[] = {
407 {SOF_TKN_MUTE_LED_USE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
408 offsetof(struct snd_sof_led_control, use_led)},
409 {SOF_TKN_MUTE_LED_DIRECTION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
410 offsetof(struct snd_sof_led_control, direction)},
411};
412
413static const struct sof_topology_token comp_pin_tokens[] = {
414 {SOF_TKN_COMP_NUM_SINK_PINS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
415 offsetof(struct snd_sof_widget, num_sink_pins)},
416 {SOF_TKN_COMP_NUM_SOURCE_PINS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
417 offsetof(struct snd_sof_widget, num_source_pins)},
418};
419
420static const struct sof_topology_token comp_sink_pin_binding_tokens[] = {
421 {SOF_TKN_COMP_SINK_PIN_BINDING_WNAME, SND_SOC_TPLG_TUPLE_TYPE_STRING,
422 get_token_string, 0},
423};
424
425static const struct sof_topology_token comp_src_pin_binding_tokens[] = {
426 {SOF_TKN_COMP_SRC_PIN_BINDING_WNAME, SND_SOC_TPLG_TUPLE_TYPE_STRING,
427 get_token_string, 0},
428};
429
430/**
431 * sof_parse_uuid_tokens - Parse multiple sets of UUID tokens
432 * @scomp: pointer to soc component
433 * @object: target ipc struct for parsed values
434 * @offset: offset within the object pointer
435 * @tokens: array of struct sof_topology_token containing the tokens to be matched
436 * @num_tokens: number of tokens in tokens array
437 * @array: source pointer to consecutive vendor arrays in topology
438 *
439 * This function parses multiple sets of string type tokens in vendor arrays
440 */
441static int sof_parse_uuid_tokens(struct snd_soc_component *scomp,
442 void *object, size_t offset,
443 const struct sof_topology_token *tokens, int num_tokens,
444 struct snd_soc_tplg_vendor_array *array)
445{
446 struct snd_soc_tplg_vendor_uuid_elem *elem;
447 int found = 0;
448 int i, j;
449
450 /* parse element by element */
451 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
452 elem = &array->uuid[i];
453
454 /* search for token */
455 for (j = 0; j < num_tokens; j++) {
456 /* match token type */
457 if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_UUID)
458 continue;
459
460 /* match token id */
461 if (tokens[j].token != le32_to_cpu(elem->token))
462 continue;
463
464 /* matched - now load token */
465 tokens[j].get_token(elem, object,
466 offset + tokens[j].offset);
467
468 found++;
469 }
470 }
471
472 return found;
473}
474
475/**
476 * sof_copy_tuples - Parse tokens and copy them to the @tuples array
477 * @sdev: pointer to struct snd_sof_dev
478 * @array: source pointer to consecutive vendor arrays in topology
479 * @array_size: size of @array
480 * @token_id: Token ID associated with a token array
481 * @token_instance_num: number of times the same @token_id needs to be parsed i.e. the function
482 * looks for @token_instance_num of each token in the token array associated
483 * with the @token_id
484 * @tuples: tuples array to copy the matched tuples to
485 * @tuples_size: size of @tuples
486 * @num_copied_tuples: pointer to the number of copied tuples in the tuples array
487 *
488 */
489static int sof_copy_tuples(struct snd_sof_dev *sdev, struct snd_soc_tplg_vendor_array *array,
490 int array_size, u32 token_id, int token_instance_num,
491 struct snd_sof_tuple *tuples, int tuples_size, int *num_copied_tuples)
492{
493 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
494 const struct sof_token_info *token_list = ipc_tplg_ops->token_list;
495 const struct sof_topology_token *tokens;
496 int found = 0;
497 int num_tokens, asize;
498 int i, j;
499
500 /* nothing to do if token_list is NULL */
501 if (!token_list)
502 return 0;
503
504 if (!tuples || !num_copied_tuples) {
505 dev_err(sdev->dev, "Invalid tuples array\n");
506 return -EINVAL;
507 }
508
509 tokens = token_list[token_id].tokens;
510 num_tokens = token_list[token_id].count;
511
512 if (!tokens) {
513 dev_err(sdev->dev, "No token array defined for token ID: %d\n", token_id);
514 return -EINVAL;
515 }
516
517 /* check if there's space in the tuples array for new tokens */
518 if (*num_copied_tuples >= tuples_size) {
519 dev_err(sdev->dev, "No space in tuples array for new tokens from %s",
520 token_list[token_id].name);
521 return -EINVAL;
522 }
523
524 while (array_size > 0 && found < num_tokens * token_instance_num) {
525 asize = le32_to_cpu(array->size);
526
527 /* validate asize */
528 if (asize < 0) {
529 dev_err(sdev->dev, "Invalid array size 0x%x\n", asize);
530 return -EINVAL;
531 }
532
533 /* make sure there is enough data before parsing */
534 array_size -= asize;
535 if (array_size < 0) {
536 dev_err(sdev->dev, "Invalid array size 0x%x\n", asize);
537 return -EINVAL;
538 }
539
540 /* parse element by element */
541 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
542 /* search for token */
543 for (j = 0; j < num_tokens; j++) {
544 /* match token type */
545 if (!(tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_WORD ||
546 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_SHORT ||
547 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BYTE ||
548 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BOOL ||
549 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_STRING))
550 continue;
551
552 if (tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_STRING) {
553 struct snd_soc_tplg_vendor_string_elem *elem;
554
555 elem = &array->string[i];
556
557 /* match token id */
558 if (tokens[j].token != le32_to_cpu(elem->token))
559 continue;
560
561 tuples[*num_copied_tuples].token = tokens[j].token;
562 tuples[*num_copied_tuples].value.s = elem->string;
563 } else {
564 struct snd_soc_tplg_vendor_value_elem *elem;
565
566 elem = &array->value[i];
567
568 /* match token id */
569 if (tokens[j].token != le32_to_cpu(elem->token))
570 continue;
571
572 tuples[*num_copied_tuples].token = tokens[j].token;
573 tuples[*num_copied_tuples].value.v =
574 le32_to_cpu(elem->value);
575 }
576 found++;
577 (*num_copied_tuples)++;
578
579 /* stop if there's no space for any more new tuples */
580 if (*num_copied_tuples == tuples_size)
581 return 0;
582 }
583 }
584
585 /* next array */
586 array = (struct snd_soc_tplg_vendor_array *)((u8 *)array + asize);
587 }
588
589 return 0;
590}
591
592/**
593 * sof_parse_string_tokens - Parse multiple sets of tokens
594 * @scomp: pointer to soc component
595 * @object: target ipc struct for parsed values
596 * @offset: offset within the object pointer
597 * @tokens: array of struct sof_topology_token containing the tokens to be matched
598 * @num_tokens: number of tokens in tokens array
599 * @array: source pointer to consecutive vendor arrays in topology
600 *
601 * This function parses multiple sets of string type tokens in vendor arrays
602 */
603static int sof_parse_string_tokens(struct snd_soc_component *scomp,
604 void *object, int offset,
605 const struct sof_topology_token *tokens, int num_tokens,
606 struct snd_soc_tplg_vendor_array *array)
607{
608 struct snd_soc_tplg_vendor_string_elem *elem;
609 int found = 0;
610 int i, j, ret;
611
612 /* parse element by element */
613 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
614 elem = &array->string[i];
615
616 /* search for token */
617 for (j = 0; j < num_tokens; j++) {
618 /* match token type */
619 if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_STRING)
620 continue;
621
622 /* match token id */
623 if (tokens[j].token != le32_to_cpu(elem->token))
624 continue;
625
626 /* matched - now load token */
627 ret = tokens[j].get_token(elem->string, object, offset + tokens[j].offset);
628 if (ret < 0)
629 return ret;
630
631 found++;
632 }
633 }
634
635 return found;
636}
637
638/**
639 * sof_parse_word_tokens - Parse multiple sets of tokens
640 * @scomp: pointer to soc component
641 * @object: target ipc struct for parsed values
642 * @offset: offset within the object pointer
643 * @tokens: array of struct sof_topology_token containing the tokens to be matched
644 * @num_tokens: number of tokens in tokens array
645 * @array: source pointer to consecutive vendor arrays in topology
646 *
647 * This function parses multiple sets of word type tokens in vendor arrays
648 */
649static int sof_parse_word_tokens(struct snd_soc_component *scomp,
650 void *object, int offset,
651 const struct sof_topology_token *tokens, int num_tokens,
652 struct snd_soc_tplg_vendor_array *array)
653{
654 struct snd_soc_tplg_vendor_value_elem *elem;
655 int found = 0;
656 int i, j;
657
658 /* parse element by element */
659 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
660 elem = &array->value[i];
661
662 /* search for token */
663 for (j = 0; j < num_tokens; j++) {
664 /* match token type */
665 if (!(tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_WORD ||
666 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_SHORT ||
667 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BYTE ||
668 tokens[j].type == SND_SOC_TPLG_TUPLE_TYPE_BOOL))
669 continue;
670
671 /* match token id */
672 if (tokens[j].token != le32_to_cpu(elem->token))
673 continue;
674
675 /* load token */
676 tokens[j].get_token(elem, object, offset + tokens[j].offset);
677
678 found++;
679 }
680 }
681
682 return found;
683}
684
685/**
686 * sof_parse_token_sets - Parse multiple sets of tokens
687 * @scomp: pointer to soc component
688 * @object: target ipc struct for parsed values
689 * @tokens: token definition array describing what tokens to parse
690 * @count: number of tokens in definition array
691 * @array: source pointer to consecutive vendor arrays in topology
692 * @array_size: total size of @array
693 * @token_instance_num: number of times the same tokens needs to be parsed i.e. the function
694 * looks for @token_instance_num of each token in the @tokens
695 * @object_size: offset to next target ipc struct with multiple sets
696 *
697 * This function parses multiple sets of tokens in vendor arrays into
698 * consecutive ipc structs.
699 */
700static int sof_parse_token_sets(struct snd_soc_component *scomp,
701 void *object, const struct sof_topology_token *tokens,
702 int count, struct snd_soc_tplg_vendor_array *array,
703 int array_size, int token_instance_num, size_t object_size)
704{
705 size_t offset = 0;
706 int found = 0;
707 int total = 0;
708 int asize;
709 int ret;
710
711 while (array_size > 0 && total < count * token_instance_num) {
712 asize = le32_to_cpu(array->size);
713
714 /* validate asize */
715 if (asize < 0) { /* FIXME: A zero-size array makes no sense */
716 dev_err(scomp->dev, "error: invalid array size 0x%x\n",
717 asize);
718 return -EINVAL;
719 }
720
721 /* make sure there is enough data before parsing */
722 array_size -= asize;
723 if (array_size < 0) {
724 dev_err(scomp->dev, "error: invalid array size 0x%x\n",
725 asize);
726 return -EINVAL;
727 }
728
729 /* call correct parser depending on type */
730 switch (le32_to_cpu(array->type)) {
731 case SND_SOC_TPLG_TUPLE_TYPE_UUID:
732 found += sof_parse_uuid_tokens(scomp, object, offset, tokens, count,
733 array);
734 break;
735 case SND_SOC_TPLG_TUPLE_TYPE_STRING:
736
737 ret = sof_parse_string_tokens(scomp, object, offset, tokens, count,
738 array);
739 if (ret < 0) {
740 dev_err(scomp->dev, "error: no memory to copy string token\n");
741 return ret;
742 }
743
744 found += ret;
745 break;
746 case SND_SOC_TPLG_TUPLE_TYPE_BOOL:
747 case SND_SOC_TPLG_TUPLE_TYPE_BYTE:
748 case SND_SOC_TPLG_TUPLE_TYPE_WORD:
749 case SND_SOC_TPLG_TUPLE_TYPE_SHORT:
750 found += sof_parse_word_tokens(scomp, object, offset, tokens, count,
751 array);
752 break;
753 default:
754 dev_err(scomp->dev, "error: unknown token type %d\n",
755 array->type);
756 return -EINVAL;
757 }
758
759 /* next array */
760 array = (struct snd_soc_tplg_vendor_array *)((u8 *)array
761 + asize);
762
763 /* move to next target struct */
764 if (found >= count) {
765 offset += object_size;
766 total += found;
767 found = 0;
768 }
769 }
770
771 return 0;
772}
773
774/**
775 * sof_parse_tokens - Parse one set of tokens
776 * @scomp: pointer to soc component
777 * @object: target ipc struct for parsed values
778 * @tokens: token definition array describing what tokens to parse
779 * @num_tokens: number of tokens in definition array
780 * @array: source pointer to consecutive vendor arrays in topology
781 * @array_size: total size of @array
782 *
783 * This function parses a single set of tokens in vendor arrays into
784 * consecutive ipc structs.
785 */
786static int sof_parse_tokens(struct snd_soc_component *scomp, void *object,
787 const struct sof_topology_token *tokens, int num_tokens,
788 struct snd_soc_tplg_vendor_array *array,
789 int array_size)
790
791{
792 /*
793 * sof_parse_tokens is used when topology contains only a single set of
794 * identical tuples arrays. So additional parameters to
795 * sof_parse_token_sets are sets = 1 (only 1 set) and
796 * object_size = 0 (irrelevant).
797 */
798 return sof_parse_token_sets(scomp, object, tokens, num_tokens, array,
799 array_size, 1, 0);
800}
801
802/*
803 * Standard Kcontrols.
804 */
805
806static int sof_control_load_volume(struct snd_soc_component *scomp,
807 struct snd_sof_control *scontrol,
808 struct snd_kcontrol_new *kc,
809 struct snd_soc_tplg_ctl_hdr *hdr)
810{
811 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
812 struct snd_soc_tplg_mixer_control *mc =
813 container_of(hdr, struct snd_soc_tplg_mixer_control, hdr);
814 int tlv[SOF_TLV_ITEMS];
815 unsigned int mask;
816 int ret;
817
818 /* validate topology data */
819 if (le32_to_cpu(mc->num_channels) > SND_SOC_TPLG_MAX_CHAN)
820 return -EINVAL;
821
822 /*
823 * If control has more than 2 channels we need to override the info. This is because even if
824 * ASoC layer has defined topology's max channel count to SND_SOC_TPLG_MAX_CHAN = 8, the
825 * pre-defined dapm control types (and related functions) creating the actual control
826 * restrict the channels only to mono or stereo.
827 */
828 if (le32_to_cpu(mc->num_channels) > 2)
829 kc->info = snd_sof_volume_info;
830
831 scontrol->comp_id = sdev->next_comp_id;
832 scontrol->min_volume_step = le32_to_cpu(mc->min);
833 scontrol->max_volume_step = le32_to_cpu(mc->max);
834 scontrol->num_channels = le32_to_cpu(mc->num_channels);
835
836 scontrol->max = le32_to_cpu(mc->max);
837 if (le32_to_cpu(mc->max) == 1)
838 goto skip;
839
840 /* extract tlv data */
841 if (!kc->tlv.p || get_tlv_data(kc->tlv.p, tlv) < 0) {
842 dev_err(scomp->dev, "error: invalid TLV data\n");
843 return -EINVAL;
844 }
845
846 /* set up volume table */
847 ret = set_up_volume_table(scontrol, tlv, le32_to_cpu(mc->max) + 1);
848 if (ret < 0) {
849 dev_err(scomp->dev, "error: setting up volume table\n");
850 return ret;
851 }
852
853skip:
854 /* set up possible led control from mixer private data */
855 ret = sof_parse_tokens(scomp, &scontrol->led_ctl, led_tokens,
856 ARRAY_SIZE(led_tokens), mc->priv.array,
857 le32_to_cpu(mc->priv.size));
858 if (ret != 0) {
859 dev_err(scomp->dev, "error: parse led tokens failed %d\n",
860 le32_to_cpu(mc->priv.size));
861 goto err;
862 }
863
864 if (scontrol->led_ctl.use_led) {
865 mask = scontrol->led_ctl.direction ? SNDRV_CTL_ELEM_ACCESS_MIC_LED :
866 SNDRV_CTL_ELEM_ACCESS_SPK_LED;
867 scontrol->access &= ~SNDRV_CTL_ELEM_ACCESS_LED_MASK;
868 scontrol->access |= mask;
869 kc->access &= ~SNDRV_CTL_ELEM_ACCESS_LED_MASK;
870 kc->access |= mask;
871 sdev->led_present = true;
872 }
873
874 dev_dbg(scomp->dev, "tplg: load kcontrol index %d chans %d\n",
875 scontrol->comp_id, scontrol->num_channels);
876
877 return 0;
878
879err:
880 if (le32_to_cpu(mc->max) > 1)
881 kfree(scontrol->volume_table);
882
883 return ret;
884}
885
886static int sof_control_load_enum(struct snd_soc_component *scomp,
887 struct snd_sof_control *scontrol,
888 struct snd_kcontrol_new *kc,
889 struct snd_soc_tplg_ctl_hdr *hdr)
890{
891 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
892 struct snd_soc_tplg_enum_control *ec =
893 container_of(hdr, struct snd_soc_tplg_enum_control, hdr);
894
895 /* validate topology data */
896 if (le32_to_cpu(ec->num_channels) > SND_SOC_TPLG_MAX_CHAN)
897 return -EINVAL;
898
899 scontrol->comp_id = sdev->next_comp_id;
900 scontrol->num_channels = le32_to_cpu(ec->num_channels);
901
902 dev_dbg(scomp->dev, "tplg: load kcontrol index %d chans %d comp_id %d\n",
903 scontrol->comp_id, scontrol->num_channels, scontrol->comp_id);
904
905 return 0;
906}
907
908static int sof_control_load_bytes(struct snd_soc_component *scomp,
909 struct snd_sof_control *scontrol,
910 struct snd_kcontrol_new *kc,
911 struct snd_soc_tplg_ctl_hdr *hdr)
912{
913 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
914 struct snd_soc_tplg_bytes_control *control =
915 container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
916 struct soc_bytes_ext *sbe = (struct soc_bytes_ext *)kc->private_value;
917 size_t priv_size = le32_to_cpu(control->priv.size);
918
919 scontrol->max_size = sbe->max;
920 scontrol->comp_id = sdev->next_comp_id;
921
922 dev_dbg(scomp->dev, "tplg: load kcontrol index %d\n", scontrol->comp_id);
923
924 /* copy the private data */
925 if (priv_size > 0) {
926 scontrol->priv = kmemdup(control->priv.data, priv_size, GFP_KERNEL);
927 if (!scontrol->priv)
928 return -ENOMEM;
929
930 scontrol->priv_size = priv_size;
931 }
932
933 return 0;
934}
935
936/* external kcontrol init - used for any driver specific init */
937static int sof_control_load(struct snd_soc_component *scomp, int index,
938 struct snd_kcontrol_new *kc,
939 struct snd_soc_tplg_ctl_hdr *hdr)
940{
941 struct soc_mixer_control *sm;
942 struct soc_bytes_ext *sbe;
943 struct soc_enum *se;
944 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
945 struct snd_soc_dobj *dobj;
946 struct snd_sof_control *scontrol;
947 int ret;
948
949 dev_dbg(scomp->dev, "tplg: load control type %d name : %s\n",
950 hdr->type, hdr->name);
951
952 scontrol = kzalloc(sizeof(*scontrol), GFP_KERNEL);
953 if (!scontrol)
954 return -ENOMEM;
955
956 scontrol->name = kstrdup(hdr->name, GFP_KERNEL);
957 if (!scontrol->name) {
958 kfree(scontrol);
959 return -ENOMEM;
960 }
961
962 scontrol->scomp = scomp;
963 scontrol->access = kc->access;
964 scontrol->info_type = le32_to_cpu(hdr->ops.info);
965 scontrol->index = kc->index;
966
967 switch (le32_to_cpu(hdr->ops.info)) {
968 case SND_SOC_TPLG_CTL_VOLSW:
969 case SND_SOC_TPLG_CTL_VOLSW_SX:
970 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
971 sm = (struct soc_mixer_control *)kc->private_value;
972 dobj = &sm->dobj;
973 ret = sof_control_load_volume(scomp, scontrol, kc, hdr);
974 break;
975 case SND_SOC_TPLG_CTL_BYTES:
976 sbe = (struct soc_bytes_ext *)kc->private_value;
977 dobj = &sbe->dobj;
978 ret = sof_control_load_bytes(scomp, scontrol, kc, hdr);
979 break;
980 case SND_SOC_TPLG_CTL_ENUM:
981 case SND_SOC_TPLG_CTL_ENUM_VALUE:
982 se = (struct soc_enum *)kc->private_value;
983 dobj = &se->dobj;
984 ret = sof_control_load_enum(scomp, scontrol, kc, hdr);
985 break;
986 case SND_SOC_TPLG_CTL_RANGE:
987 case SND_SOC_TPLG_CTL_STROBE:
988 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
989 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
990 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
991 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
992 case SND_SOC_TPLG_DAPM_CTL_PIN:
993 default:
994 dev_warn(scomp->dev, "control type not supported %d:%d:%d\n",
995 hdr->ops.get, hdr->ops.put, hdr->ops.info);
996 kfree(scontrol->name);
997 kfree(scontrol);
998 return 0;
999 }
1000
1001 if (ret < 0) {
1002 kfree(scontrol->name);
1003 kfree(scontrol);
1004 return ret;
1005 }
1006
1007 scontrol->led_ctl.led_value = -1;
1008
1009 dobj->private = scontrol;
1010 list_add(&scontrol->list, &sdev->kcontrol_list);
1011 return 0;
1012}
1013
1014static int sof_control_unload(struct snd_soc_component *scomp,
1015 struct snd_soc_dobj *dobj)
1016{
1017 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1018 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
1019 struct snd_sof_control *scontrol = dobj->private;
1020 int ret = 0;
1021
1022 dev_dbg(scomp->dev, "tplg: unload control name : %s\n", scontrol->name);
1023
1024 if (ipc_tplg_ops->control_free) {
1025 ret = ipc_tplg_ops->control_free(sdev, scontrol);
1026 if (ret < 0)
1027 dev_err(scomp->dev, "failed to free control: %s\n", scontrol->name);
1028 }
1029
1030 /* free all data before returning in case of error too */
1031 kfree(scontrol->ipc_control_data);
1032 kfree(scontrol->priv);
1033 kfree(scontrol->name);
1034 list_del(&scontrol->list);
1035 kfree(scontrol);
1036
1037 return ret;
1038}
1039
1040/*
1041 * DAI Topology
1042 */
1043
1044static int sof_connect_dai_widget(struct snd_soc_component *scomp,
1045 struct snd_soc_dapm_widget *w,
1046 struct snd_soc_tplg_dapm_widget *tw,
1047 struct snd_sof_dai *dai)
1048{
1049 struct snd_soc_card *card = scomp->card;
1050 struct snd_soc_pcm_runtime *rtd;
1051 struct snd_soc_dai *cpu_dai;
1052 int i;
1053
1054 if (!w->sname) {
1055 dev_err(scomp->dev, "Widget %s does not have stream\n", w->name);
1056 return -EINVAL;
1057 }
1058
1059 list_for_each_entry(rtd, &card->rtd_list, list) {
1060 /* does stream match DAI link ? */
1061 if (!rtd->dai_link->stream_name ||
1062 strcmp(w->sname, rtd->dai_link->stream_name))
1063 continue;
1064
1065 switch (w->id) {
1066 case snd_soc_dapm_dai_out:
1067 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1068 /*
1069 * Please create DAI widget in the right order
1070 * to ensure BE will connect to the right DAI
1071 * widget.
1072 */
1073 if (!cpu_dai->capture_widget) {
1074 cpu_dai->capture_widget = w;
1075 break;
1076 }
1077 }
1078 if (i == rtd->dai_link->num_cpus) {
1079 dev_err(scomp->dev, "error: can't find BE for DAI %s\n",
1080 w->name);
1081
1082 return -EINVAL;
1083 }
1084 dai->name = rtd->dai_link->name;
1085 dev_dbg(scomp->dev, "tplg: connected widget %s -> DAI link %s\n",
1086 w->name, rtd->dai_link->name);
1087 break;
1088 case snd_soc_dapm_dai_in:
1089 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1090 /*
1091 * Please create DAI widget in the right order
1092 * to ensure BE will connect to the right DAI
1093 * widget.
1094 */
1095 if (!cpu_dai->playback_widget) {
1096 cpu_dai->playback_widget = w;
1097 break;
1098 }
1099 }
1100 if (i == rtd->dai_link->num_cpus) {
1101 dev_err(scomp->dev, "error: can't find BE for DAI %s\n",
1102 w->name);
1103
1104 return -EINVAL;
1105 }
1106 dai->name = rtd->dai_link->name;
1107 dev_dbg(scomp->dev, "tplg: connected widget %s -> DAI link %s\n",
1108 w->name, rtd->dai_link->name);
1109 break;
1110 default:
1111 break;
1112 }
1113 }
1114
1115 /* check we have a connection */
1116 if (!dai->name) {
1117 dev_err(scomp->dev, "error: can't connect DAI %s stream %s\n",
1118 w->name, w->sname);
1119 return -EINVAL;
1120 }
1121
1122 return 0;
1123}
1124
1125static void sof_disconnect_dai_widget(struct snd_soc_component *scomp,
1126 struct snd_soc_dapm_widget *w)
1127{
1128 struct snd_soc_card *card = scomp->card;
1129 struct snd_soc_pcm_runtime *rtd;
1130 struct snd_soc_dai *cpu_dai;
1131 int i;
1132
1133 if (!w->sname)
1134 return;
1135
1136 list_for_each_entry(rtd, &card->rtd_list, list) {
1137 /* does stream match DAI link ? */
1138 if (!rtd->dai_link->stream_name ||
1139 strcmp(w->sname, rtd->dai_link->stream_name))
1140 continue;
1141
1142 switch (w->id) {
1143 case snd_soc_dapm_dai_out:
1144 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1145 if (cpu_dai->capture_widget == w) {
1146 cpu_dai->capture_widget = NULL;
1147 break;
1148 }
1149 }
1150 break;
1151 case snd_soc_dapm_dai_in:
1152 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1153 if (cpu_dai->playback_widget == w) {
1154 cpu_dai->playback_widget = NULL;
1155 break;
1156 }
1157 }
1158 break;
1159 default:
1160 break;
1161 }
1162 }
1163}
1164
1165/* bind PCM ID to host component ID */
1166static int spcm_bind(struct snd_soc_component *scomp, struct snd_sof_pcm *spcm,
1167 int dir)
1168{
1169 struct snd_sof_widget *host_widget;
1170
1171 host_widget = snd_sof_find_swidget_sname(scomp,
1172 spcm->pcm.caps[dir].name,
1173 dir);
1174 if (!host_widget) {
1175 dev_err(scomp->dev, "can't find host comp to bind pcm\n");
1176 return -EINVAL;
1177 }
1178
1179 spcm->stream[dir].comp_id = host_widget->comp_id;
1180
1181 return 0;
1182}
1183
1184static int sof_get_token_value(u32 token_id, struct snd_sof_tuple *tuples, int num_tuples)
1185{
1186 int i;
1187
1188 if (!tuples)
1189 return -EINVAL;
1190
1191 for (i = 0; i < num_tuples; i++) {
1192 if (tuples[i].token == token_id)
1193 return tuples[i].value.v;
1194 }
1195
1196 return -EINVAL;
1197}
1198
1199static int sof_widget_parse_tokens(struct snd_soc_component *scomp, struct snd_sof_widget *swidget,
1200 struct snd_soc_tplg_dapm_widget *tw,
1201 enum sof_tokens *object_token_list, int count)
1202{
1203 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1204 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
1205 const struct sof_token_info *token_list = ipc_tplg_ops->token_list;
1206 struct snd_soc_tplg_private *private = &tw->priv;
1207 int num_tuples = 0;
1208 int ret, i;
1209
1210 if (count > 0 && !object_token_list) {
1211 dev_err(scomp->dev, "No token list for widget %s\n", swidget->widget->name);
1212 return -EINVAL;
1213 }
1214
1215 /* calculate max size of tuples array */
1216 for (i = 0; i < count; i++)
1217 num_tuples += token_list[object_token_list[i]].count;
1218
1219 /* allocate memory for tuples array */
1220 swidget->tuples = kcalloc(num_tuples, sizeof(*swidget->tuples), GFP_KERNEL);
1221 if (!swidget->tuples)
1222 return -ENOMEM;
1223
1224 /* parse token list for widget */
1225 for (i = 0; i < count; i++) {
1226 int num_sets = 1;
1227
1228 if (object_token_list[i] >= SOF_TOKEN_COUNT) {
1229 dev_err(scomp->dev, "Invalid token id %d for widget %s\n",
1230 object_token_list[i], swidget->widget->name);
1231 ret = -EINVAL;
1232 goto err;
1233 }
1234
1235 switch (object_token_list[i]) {
1236 case SOF_COMP_EXT_TOKENS:
1237 /* parse and save UUID in swidget */
1238 ret = sof_parse_tokens(scomp, swidget,
1239 token_list[object_token_list[i]].tokens,
1240 token_list[object_token_list[i]].count,
1241 private->array, le32_to_cpu(private->size));
1242 if (ret < 0) {
1243 dev_err(scomp->dev, "Failed parsing %s for widget %s\n",
1244 token_list[object_token_list[i]].name,
1245 swidget->widget->name);
1246 goto err;
1247 }
1248
1249 continue;
1250 case SOF_IN_AUDIO_FORMAT_TOKENS:
1251 case SOF_OUT_AUDIO_FORMAT_TOKENS:
1252 case SOF_COPIER_GATEWAY_CFG_TOKENS:
1253 case SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS:
1254 num_sets = sof_get_token_value(SOF_TKN_COMP_NUM_AUDIO_FORMATS,
1255 swidget->tuples, swidget->num_tuples);
1256
1257 if (num_sets < 0) {
1258 dev_err(sdev->dev, "Invalid audio format count for %s\n",
1259 swidget->widget->name);
1260 ret = num_sets;
1261 goto err;
1262 }
1263
1264 if (num_sets > 1) {
1265 struct snd_sof_tuple *new_tuples;
1266
1267 num_tuples += token_list[object_token_list[i]].count * num_sets;
1268 new_tuples = krealloc(swidget->tuples,
1269 sizeof(*new_tuples) * num_tuples, GFP_KERNEL);
1270 if (!new_tuples) {
1271 ret = -ENOMEM;
1272 goto err;
1273 }
1274
1275 swidget->tuples = new_tuples;
1276 }
1277 break;
1278 default:
1279 break;
1280 }
1281
1282 /* copy one set of tuples per token ID into swidget->tuples */
1283 ret = sof_copy_tuples(sdev, private->array, le32_to_cpu(private->size),
1284 object_token_list[i], num_sets, swidget->tuples,
1285 num_tuples, &swidget->num_tuples);
1286 if (ret < 0) {
1287 dev_err(scomp->dev, "Failed parsing %s for widget %s err: %d\n",
1288 token_list[object_token_list[i]].name, swidget->widget->name, ret);
1289 goto err;
1290 }
1291 }
1292
1293 return 0;
1294err:
1295 kfree(swidget->tuples);
1296 return ret;
1297}
1298
1299static void sof_free_pin_binding(struct snd_sof_widget *swidget,
1300 bool pin_type)
1301{
1302 char **pin_binding;
1303 u32 num_pins;
1304 int i;
1305
1306 if (pin_type == SOF_PIN_TYPE_SINK) {
1307 pin_binding = swidget->sink_pin_binding;
1308 num_pins = swidget->num_sink_pins;
1309 } else {
1310 pin_binding = swidget->src_pin_binding;
1311 num_pins = swidget->num_source_pins;
1312 }
1313
1314 if (pin_binding) {
1315 for (i = 0; i < num_pins; i++)
1316 kfree(pin_binding[i]);
1317 }
1318
1319 kfree(pin_binding);
1320}
1321
1322static int sof_parse_pin_binding(struct snd_sof_widget *swidget,
1323 struct snd_soc_tplg_private *priv, bool pin_type)
1324{
1325 const struct sof_topology_token *pin_binding_token;
1326 char *pin_binding[SOF_WIDGET_MAX_NUM_PINS];
1327 int token_count;
1328 u32 num_pins;
1329 char **pb;
1330 int ret;
1331 int i;
1332
1333 if (pin_type == SOF_PIN_TYPE_SINK) {
1334 num_pins = swidget->num_sink_pins;
1335 pin_binding_token = comp_sink_pin_binding_tokens;
1336 token_count = ARRAY_SIZE(comp_sink_pin_binding_tokens);
1337 } else {
1338 num_pins = swidget->num_source_pins;
1339 pin_binding_token = comp_src_pin_binding_tokens;
1340 token_count = ARRAY_SIZE(comp_src_pin_binding_tokens);
1341 }
1342
1343 memset(pin_binding, 0, SOF_WIDGET_MAX_NUM_PINS * sizeof(char *));
1344 ret = sof_parse_token_sets(swidget->scomp, pin_binding, pin_binding_token,
1345 token_count, priv->array, le32_to_cpu(priv->size),
1346 num_pins, sizeof(char *));
1347 if (ret < 0)
1348 goto err;
1349
1350 /* copy pin binding array to swidget only if it is defined in topology */
1351 if (pin_binding[0]) {
1352 pb = kmemdup(pin_binding, num_pins * sizeof(char *), GFP_KERNEL);
1353 if (!pb) {
1354 ret = -ENOMEM;
1355 goto err;
1356 }
1357 if (pin_type == SOF_PIN_TYPE_SINK)
1358 swidget->sink_pin_binding = pb;
1359 else
1360 swidget->src_pin_binding = pb;
1361 }
1362
1363 return 0;
1364
1365err:
1366 for (i = 0; i < num_pins; i++)
1367 kfree(pin_binding[i]);
1368
1369 return ret;
1370}
1371
1372/* external widget init - used for any driver specific init */
1373static int sof_widget_ready(struct snd_soc_component *scomp, int index,
1374 struct snd_soc_dapm_widget *w,
1375 struct snd_soc_tplg_dapm_widget *tw)
1376{
1377 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1378 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
1379 const struct sof_ipc_tplg_widget_ops *widget_ops = ipc_tplg_ops->widget;
1380 struct snd_soc_tplg_private *priv = &tw->priv;
1381 struct snd_sof_widget *swidget;
1382 struct snd_sof_dai *dai;
1383 enum sof_tokens *token_list;
1384 int token_list_size;
1385 int ret = 0;
1386
1387 swidget = kzalloc(sizeof(*swidget), GFP_KERNEL);
1388 if (!swidget)
1389 return -ENOMEM;
1390
1391 swidget->scomp = scomp;
1392 swidget->widget = w;
1393 swidget->comp_id = sdev->next_comp_id++;
1394 swidget->complete = 0;
1395 swidget->id = w->id;
1396 swidget->pipeline_id = index;
1397 swidget->private = NULL;
1398 ida_init(&swidget->src_queue_ida);
1399 ida_init(&swidget->sink_queue_ida);
1400
1401 ret = sof_parse_tokens(scomp, swidget, comp_pin_tokens,
1402 ARRAY_SIZE(comp_pin_tokens), priv->array,
1403 le32_to_cpu(priv->size));
1404 if (ret < 0) {
1405 dev_err(scomp->dev, "failed to parse component pin tokens for %s\n",
1406 w->name);
1407 return ret;
1408 }
1409
1410 if (swidget->num_sink_pins > SOF_WIDGET_MAX_NUM_PINS ||
1411 swidget->num_source_pins > SOF_WIDGET_MAX_NUM_PINS) {
1412 dev_err(scomp->dev, "invalid pins for %s: [sink: %d, src: %d]\n",
1413 swidget->widget->name, swidget->num_sink_pins, swidget->num_source_pins);
1414 return -EINVAL;
1415 }
1416
1417 if (swidget->num_sink_pins > 1) {
1418 ret = sof_parse_pin_binding(swidget, priv, SOF_PIN_TYPE_SINK);
1419 /* on parsing error, pin binding is not allocated, nothing to free. */
1420 if (ret < 0) {
1421 dev_err(scomp->dev, "failed to parse sink pin binding for %s\n",
1422 w->name);
1423 return ret;
1424 }
1425 }
1426
1427 if (swidget->num_source_pins > 1) {
1428 ret = sof_parse_pin_binding(swidget, priv, SOF_PIN_TYPE_SOURCE);
1429 /* on parsing error, pin binding is not allocated, nothing to free. */
1430 if (ret < 0) {
1431 dev_err(scomp->dev, "failed to parse source pin binding for %s\n",
1432 w->name);
1433 return ret;
1434 }
1435 }
1436
1437 dev_dbg(scomp->dev,
1438 "tplg: widget %d (%s) is ready [type: %d, pipe: %d, pins: %d / %d, stream: %s]\n",
1439 swidget->comp_id, w->name, swidget->id, index,
1440 swidget->num_sink_pins, swidget->num_source_pins,
1441 strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) > 0 ? w->sname : "none");
1442
1443 token_list = widget_ops[w->id].token_list;
1444 token_list_size = widget_ops[w->id].token_list_size;
1445
1446 /* handle any special case widgets */
1447 switch (w->id) {
1448 case snd_soc_dapm_dai_in:
1449 case snd_soc_dapm_dai_out:
1450 dai = kzalloc(sizeof(*dai), GFP_KERNEL);
1451 if (!dai) {
1452 kfree(swidget);
1453 return -ENOMEM;
1454
1455 }
1456
1457 ret = sof_widget_parse_tokens(scomp, swidget, tw, token_list, token_list_size);
1458 if (!ret)
1459 ret = sof_connect_dai_widget(scomp, w, tw, dai);
1460 if (ret < 0) {
1461 kfree(dai);
1462 break;
1463 }
1464 list_add(&dai->list, &sdev->dai_list);
1465 swidget->private = dai;
1466 break;
1467 case snd_soc_dapm_effect:
1468 /* check we have some tokens - we need at least process type */
1469 if (le32_to_cpu(tw->priv.size) == 0) {
1470 dev_err(scomp->dev, "error: process tokens not found\n");
1471 ret = -EINVAL;
1472 break;
1473 }
1474 ret = sof_widget_parse_tokens(scomp, swidget, tw, token_list, token_list_size);
1475 break;
1476 case snd_soc_dapm_pga:
1477 if (!le32_to_cpu(tw->num_kcontrols)) {
1478 dev_err(scomp->dev, "invalid kcontrol count %d for volume\n",
1479 tw->num_kcontrols);
1480 ret = -EINVAL;
1481 break;
1482 }
1483
1484 fallthrough;
1485 case snd_soc_dapm_mixer:
1486 case snd_soc_dapm_buffer:
1487 case snd_soc_dapm_scheduler:
1488 case snd_soc_dapm_aif_out:
1489 case snd_soc_dapm_aif_in:
1490 case snd_soc_dapm_src:
1491 case snd_soc_dapm_asrc:
1492 case snd_soc_dapm_siggen:
1493 case snd_soc_dapm_mux:
1494 case snd_soc_dapm_demux:
1495 ret = sof_widget_parse_tokens(scomp, swidget, tw, token_list, token_list_size);
1496 break;
1497 case snd_soc_dapm_switch:
1498 case snd_soc_dapm_dai_link:
1499 case snd_soc_dapm_kcontrol:
1500 default:
1501 dev_dbg(scomp->dev, "widget type %d name %s not handled\n", swidget->id, tw->name);
1502 break;
1503 }
1504
1505 /* check token parsing reply */
1506 if (ret < 0) {
1507 dev_err(scomp->dev,
1508 "error: failed to add widget id %d type %d name : %s stream %s\n",
1509 tw->shift, swidget->id, tw->name,
1510 strnlen(tw->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) > 0
1511 ? tw->sname : "none");
1512 kfree(swidget);
1513 return ret;
1514 }
1515
1516 if (sof_debug_check_flag(SOF_DBG_DISABLE_MULTICORE)) {
1517 swidget->core = SOF_DSP_PRIMARY_CORE;
1518 } else {
1519 int core = sof_get_token_value(SOF_TKN_COMP_CORE_ID, swidget->tuples,
1520 swidget->num_tuples);
1521
1522 if (core >= 0)
1523 swidget->core = core;
1524 }
1525
1526 /* bind widget to external event */
1527 if (tw->event_type) {
1528 if (widget_ops[w->id].bind_event) {
1529 ret = widget_ops[w->id].bind_event(scomp, swidget,
1530 le16_to_cpu(tw->event_type));
1531 if (ret) {
1532 dev_err(scomp->dev, "widget event binding failed for %s\n",
1533 swidget->widget->name);
1534 kfree(swidget->private);
1535 kfree(swidget->tuples);
1536 kfree(swidget);
1537 return ret;
1538 }
1539 }
1540 }
1541
1542 w->dobj.private = swidget;
1543 list_add(&swidget->list, &sdev->widget_list);
1544 return ret;
1545}
1546
1547static int sof_route_unload(struct snd_soc_component *scomp,
1548 struct snd_soc_dobj *dobj)
1549{
1550 struct snd_sof_route *sroute;
1551
1552 sroute = dobj->private;
1553 if (!sroute)
1554 return 0;
1555
1556 /* free sroute and its private data */
1557 kfree(sroute->private);
1558 list_del(&sroute->list);
1559 kfree(sroute);
1560
1561 return 0;
1562}
1563
1564static int sof_widget_unload(struct snd_soc_component *scomp,
1565 struct snd_soc_dobj *dobj)
1566{
1567 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1568 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
1569 const struct sof_ipc_tplg_widget_ops *widget_ops = ipc_tplg_ops->widget;
1570 const struct snd_kcontrol_new *kc;
1571 struct snd_soc_dapm_widget *widget;
1572 struct snd_sof_control *scontrol;
1573 struct snd_sof_widget *swidget;
1574 struct soc_mixer_control *sm;
1575 struct soc_bytes_ext *sbe;
1576 struct snd_sof_dai *dai;
1577 struct soc_enum *se;
1578 int i;
1579
1580 swidget = dobj->private;
1581 if (!swidget)
1582 return 0;
1583
1584 widget = swidget->widget;
1585
1586 switch (swidget->id) {
1587 case snd_soc_dapm_dai_in:
1588 case snd_soc_dapm_dai_out:
1589 dai = swidget->private;
1590
1591 if (dai)
1592 list_del(&dai->list);
1593
1594 sof_disconnect_dai_widget(scomp, widget);
1595
1596 break;
1597 default:
1598 break;
1599 }
1600 for (i = 0; i < widget->num_kcontrols; i++) {
1601 kc = &widget->kcontrol_news[i];
1602 switch (widget->dobj.widget.kcontrol_type[i]) {
1603 case SND_SOC_TPLG_TYPE_MIXER:
1604 sm = (struct soc_mixer_control *)kc->private_value;
1605 scontrol = sm->dobj.private;
1606 if (sm->max > 1)
1607 kfree(scontrol->volume_table);
1608 break;
1609 case SND_SOC_TPLG_TYPE_ENUM:
1610 se = (struct soc_enum *)kc->private_value;
1611 scontrol = se->dobj.private;
1612 break;
1613 case SND_SOC_TPLG_TYPE_BYTES:
1614 sbe = (struct soc_bytes_ext *)kc->private_value;
1615 scontrol = sbe->dobj.private;
1616 break;
1617 default:
1618 dev_warn(scomp->dev, "unsupported kcontrol_type\n");
1619 goto out;
1620 }
1621 kfree(scontrol->ipc_control_data);
1622 list_del(&scontrol->list);
1623 kfree(scontrol->name);
1624 kfree(scontrol);
1625 }
1626
1627out:
1628 /* free IPC related data */
1629 if (widget_ops[swidget->id].ipc_free)
1630 widget_ops[swidget->id].ipc_free(swidget);
1631
1632 ida_destroy(&swidget->src_queue_ida);
1633 ida_destroy(&swidget->sink_queue_ida);
1634
1635 sof_free_pin_binding(swidget, SOF_PIN_TYPE_SINK);
1636 sof_free_pin_binding(swidget, SOF_PIN_TYPE_SOURCE);
1637
1638 kfree(swidget->tuples);
1639
1640 /* remove and free swidget object */
1641 list_del(&swidget->list);
1642 kfree(swidget);
1643
1644 return 0;
1645}
1646
1647/*
1648 * DAI HW configuration.
1649 */
1650
1651/* FE DAI - used for any driver specific init */
1652static int sof_dai_load(struct snd_soc_component *scomp, int index,
1653 struct snd_soc_dai_driver *dai_drv,
1654 struct snd_soc_tplg_pcm *pcm, struct snd_soc_dai *dai)
1655{
1656 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1657 struct snd_soc_tplg_stream_caps *caps;
1658 struct snd_soc_tplg_private *private = &pcm->priv;
1659 struct snd_sof_pcm *spcm;
1660 int stream;
1661 int ret;
1662
1663 /* nothing to do for BEs atm */
1664 if (!pcm)
1665 return 0;
1666
1667 spcm = kzalloc(sizeof(*spcm), GFP_KERNEL);
1668 if (!spcm)
1669 return -ENOMEM;
1670
1671 spcm->scomp = scomp;
1672
1673 for_each_pcm_streams(stream) {
1674 spcm->stream[stream].comp_id = COMP_ID_UNASSIGNED;
1675 if (pcm->compress)
1676 snd_sof_compr_init_elapsed_work(&spcm->stream[stream].period_elapsed_work);
1677 else
1678 snd_sof_pcm_init_elapsed_work(&spcm->stream[stream].period_elapsed_work);
1679 }
1680
1681 spcm->pcm = *pcm;
1682 dev_dbg(scomp->dev, "tplg: load pcm %s\n", pcm->dai_name);
1683
1684 dai_drv->dobj.private = spcm;
1685 list_add(&spcm->list, &sdev->pcm_list);
1686
1687 ret = sof_parse_tokens(scomp, spcm, stream_tokens,
1688 ARRAY_SIZE(stream_tokens), private->array,
1689 le32_to_cpu(private->size));
1690 if (ret) {
1691 dev_err(scomp->dev, "error: parse stream tokens failed %d\n",
1692 le32_to_cpu(private->size));
1693 return ret;
1694 }
1695
1696 /* do we need to allocate playback PCM DMA pages */
1697 if (!spcm->pcm.playback)
1698 goto capture;
1699
1700 stream = SNDRV_PCM_STREAM_PLAYBACK;
1701
1702 caps = &spcm->pcm.caps[stream];
1703
1704 /* allocate playback page table buffer */
1705 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, sdev->dev,
1706 PAGE_SIZE, &spcm->stream[stream].page_table);
1707 if (ret < 0) {
1708 dev_err(scomp->dev, "error: can't alloc page table for %s %d\n",
1709 caps->name, ret);
1710
1711 return ret;
1712 }
1713
1714 /* bind pcm to host comp */
1715 ret = spcm_bind(scomp, spcm, stream);
1716 if (ret) {
1717 dev_err(scomp->dev,
1718 "error: can't bind pcm to host\n");
1719 goto free_playback_tables;
1720 }
1721
1722capture:
1723 stream = SNDRV_PCM_STREAM_CAPTURE;
1724
1725 /* do we need to allocate capture PCM DMA pages */
1726 if (!spcm->pcm.capture)
1727 return ret;
1728
1729 caps = &spcm->pcm.caps[stream];
1730
1731 /* allocate capture page table buffer */
1732 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, sdev->dev,
1733 PAGE_SIZE, &spcm->stream[stream].page_table);
1734 if (ret < 0) {
1735 dev_err(scomp->dev, "error: can't alloc page table for %s %d\n",
1736 caps->name, ret);
1737 goto free_playback_tables;
1738 }
1739
1740 /* bind pcm to host comp */
1741 ret = spcm_bind(scomp, spcm, stream);
1742 if (ret) {
1743 dev_err(scomp->dev,
1744 "error: can't bind pcm to host\n");
1745 snd_dma_free_pages(&spcm->stream[stream].page_table);
1746 goto free_playback_tables;
1747 }
1748
1749 return ret;
1750
1751free_playback_tables:
1752 if (spcm->pcm.playback)
1753 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_PLAYBACK].page_table);
1754
1755 return ret;
1756}
1757
1758static int sof_dai_unload(struct snd_soc_component *scomp,
1759 struct snd_soc_dobj *dobj)
1760{
1761 struct snd_sof_pcm *spcm = dobj->private;
1762
1763 /* free PCM DMA pages */
1764 if (spcm->pcm.playback)
1765 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_PLAYBACK].page_table);
1766
1767 if (spcm->pcm.capture)
1768 snd_dma_free_pages(&spcm->stream[SNDRV_PCM_STREAM_CAPTURE].page_table);
1769
1770 /* remove from list and free spcm */
1771 list_del(&spcm->list);
1772 kfree(spcm);
1773
1774 return 0;
1775}
1776
1777static const struct sof_topology_token common_dai_link_tokens[] = {
1778 {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
1779 offsetof(struct snd_sof_dai_link, type)},
1780};
1781
1782/* DAI link - used for any driver specific init */
1783static int sof_link_load(struct snd_soc_component *scomp, int index, struct snd_soc_dai_link *link,
1784 struct snd_soc_tplg_link_config *cfg)
1785{
1786 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1787 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
1788 const struct sof_token_info *token_list = ipc_tplg_ops->token_list;
1789 struct snd_soc_tplg_private *private = &cfg->priv;
1790 struct snd_sof_dai_link *slink;
1791 u32 token_id = 0;
1792 int num_tuples = 0;
1793 int ret, num_sets;
1794
1795 if (!link->platforms) {
1796 dev_err(scomp->dev, "error: no platforms\n");
1797 return -EINVAL;
1798 }
1799 link->platforms->name = dev_name(scomp->dev);
1800
1801 /*
1802 * Set nonatomic property for FE dai links as their trigger action
1803 * involves IPC's.
1804 */
1805 if (!link->no_pcm) {
1806 link->nonatomic = true;
1807
1808 /*
1809 * set default trigger order for all links. Exceptions to
1810 * the rule will be handled in sof_pcm_dai_link_fixup()
1811 * For playback, the sequence is the following: start FE,
1812 * start BE, stop BE, stop FE; for Capture the sequence is
1813 * inverted start BE, start FE, stop FE, stop BE
1814 */
1815 link->trigger[SNDRV_PCM_STREAM_PLAYBACK] =
1816 SND_SOC_DPCM_TRIGGER_PRE;
1817 link->trigger[SNDRV_PCM_STREAM_CAPTURE] =
1818 SND_SOC_DPCM_TRIGGER_POST;
1819
1820 /* nothing more to do for FE dai links */
1821 return 0;
1822 }
1823
1824 /* check we have some tokens - we need at least DAI type */
1825 if (le32_to_cpu(private->size) == 0) {
1826 dev_err(scomp->dev, "error: expected tokens for DAI, none found\n");
1827 return -EINVAL;
1828 }
1829
1830 slink = kzalloc(sizeof(*slink), GFP_KERNEL);
1831 if (!slink)
1832 return -ENOMEM;
1833
1834 slink->num_hw_configs = le32_to_cpu(cfg->num_hw_configs);
1835 slink->hw_configs = kmemdup(cfg->hw_config,
1836 sizeof(*slink->hw_configs) * slink->num_hw_configs,
1837 GFP_KERNEL);
1838 if (!slink->hw_configs) {
1839 kfree(slink);
1840 return -ENOMEM;
1841 }
1842
1843 slink->default_hw_cfg_id = le32_to_cpu(cfg->default_hw_config_id);
1844 slink->link = link;
1845
1846 dev_dbg(scomp->dev, "tplg: %d hw_configs found, default id: %d for dai link %s!\n",
1847 slink->num_hw_configs, slink->default_hw_cfg_id, link->name);
1848
1849 ret = sof_parse_tokens(scomp, slink, common_dai_link_tokens,
1850 ARRAY_SIZE(common_dai_link_tokens),
1851 private->array, le32_to_cpu(private->size));
1852 if (ret < 0) {
1853 dev_err(scomp->dev, "Failed tp parse common DAI link tokens\n");
1854 kfree(slink->hw_configs);
1855 kfree(slink);
1856 return ret;
1857 }
1858
1859 if (!token_list)
1860 goto out;
1861
1862 /* calculate size of tuples array */
1863 num_tuples += token_list[SOF_DAI_LINK_TOKENS].count;
1864 num_sets = slink->num_hw_configs;
1865 switch (slink->type) {
1866 case SOF_DAI_INTEL_SSP:
1867 token_id = SOF_SSP_TOKENS;
1868 num_tuples += token_list[SOF_SSP_TOKENS].count * slink->num_hw_configs;
1869 break;
1870 case SOF_DAI_INTEL_DMIC:
1871 token_id = SOF_DMIC_TOKENS;
1872 num_tuples += token_list[SOF_DMIC_TOKENS].count;
1873
1874 /* Allocate memory for max PDM controllers */
1875 num_tuples += token_list[SOF_DMIC_PDM_TOKENS].count * SOF_DAI_INTEL_DMIC_NUM_CTRL;
1876 break;
1877 case SOF_DAI_INTEL_HDA:
1878 token_id = SOF_HDA_TOKENS;
1879 num_tuples += token_list[SOF_HDA_TOKENS].count;
1880 break;
1881 case SOF_DAI_INTEL_ALH:
1882 token_id = SOF_ALH_TOKENS;
1883 num_tuples += token_list[SOF_ALH_TOKENS].count;
1884 break;
1885 case SOF_DAI_IMX_SAI:
1886 token_id = SOF_SAI_TOKENS;
1887 num_tuples += token_list[SOF_SAI_TOKENS].count;
1888 break;
1889 case SOF_DAI_IMX_ESAI:
1890 token_id = SOF_ESAI_TOKENS;
1891 num_tuples += token_list[SOF_ESAI_TOKENS].count;
1892 break;
1893 case SOF_DAI_MEDIATEK_AFE:
1894 token_id = SOF_AFE_TOKENS;
1895 num_tuples += token_list[SOF_AFE_TOKENS].count;
1896 break;
1897 case SOF_DAI_AMD_DMIC:
1898 token_id = SOF_ACPDMIC_TOKENS;
1899 num_tuples += token_list[SOF_ACPDMIC_TOKENS].count;
1900 break;
1901 case SOF_DAI_AMD_SP:
1902 case SOF_DAI_AMD_HS:
1903 case SOF_DAI_AMD_SP_VIRTUAL:
1904 case SOF_DAI_AMD_HS_VIRTUAL:
1905 token_id = SOF_ACPI2S_TOKENS;
1906 num_tuples += token_list[SOF_ACPI2S_TOKENS].count;
1907 break;
1908 default:
1909 break;
1910 }
1911
1912 /* allocate memory for tuples array */
1913 slink->tuples = kcalloc(num_tuples, sizeof(*slink->tuples), GFP_KERNEL);
1914 if (!slink->tuples) {
1915 kfree(slink->hw_configs);
1916 kfree(slink);
1917 return -ENOMEM;
1918 }
1919
1920 if (token_list[SOF_DAI_LINK_TOKENS].tokens) {
1921 /* parse one set of DAI link tokens */
1922 ret = sof_copy_tuples(sdev, private->array, le32_to_cpu(private->size),
1923 SOF_DAI_LINK_TOKENS, 1, slink->tuples,
1924 num_tuples, &slink->num_tuples);
1925 if (ret < 0) {
1926 dev_err(scomp->dev, "failed to parse %s for dai link %s\n",
1927 token_list[SOF_DAI_LINK_TOKENS].name, link->name);
1928 goto err;
1929 }
1930 }
1931
1932 /* nothing more to do if there are no DAI type-specific tokens defined */
1933 if (!token_id || !token_list[token_id].tokens)
1934 goto out;
1935
1936 /* parse "num_sets" sets of DAI-specific tokens */
1937 ret = sof_copy_tuples(sdev, private->array, le32_to_cpu(private->size),
1938 token_id, num_sets, slink->tuples, num_tuples, &slink->num_tuples);
1939 if (ret < 0) {
1940 dev_err(scomp->dev, "failed to parse %s for dai link %s\n",
1941 token_list[token_id].name, link->name);
1942 goto err;
1943 }
1944
1945 /* for DMIC, also parse all sets of DMIC PDM tokens based on active PDM count */
1946 if (token_id == SOF_DMIC_TOKENS) {
1947 num_sets = sof_get_token_value(SOF_TKN_INTEL_DMIC_NUM_PDM_ACTIVE,
1948 slink->tuples, slink->num_tuples);
1949
1950 if (num_sets < 0) {
1951 dev_err(sdev->dev, "Invalid active PDM count for %s\n", link->name);
1952 ret = num_sets;
1953 goto err;
1954 }
1955
1956 ret = sof_copy_tuples(sdev, private->array, le32_to_cpu(private->size),
1957 SOF_DMIC_PDM_TOKENS, num_sets, slink->tuples,
1958 num_tuples, &slink->num_tuples);
1959 if (ret < 0) {
1960 dev_err(scomp->dev, "failed to parse %s for dai link %s\n",
1961 token_list[SOF_DMIC_PDM_TOKENS].name, link->name);
1962 goto err;
1963 }
1964 }
1965out:
1966 link->dobj.private = slink;
1967 list_add(&slink->list, &sdev->dai_link_list);
1968
1969 return 0;
1970
1971err:
1972 kfree(slink->tuples);
1973 kfree(slink->hw_configs);
1974 kfree(slink);
1975
1976 return ret;
1977}
1978
1979static int sof_link_unload(struct snd_soc_component *scomp, struct snd_soc_dobj *dobj)
1980{
1981 struct snd_sof_dai_link *slink = dobj->private;
1982
1983 if (!slink)
1984 return 0;
1985
1986 kfree(slink->tuples);
1987 list_del(&slink->list);
1988 kfree(slink->hw_configs);
1989 kfree(slink);
1990 dobj->private = NULL;
1991
1992 return 0;
1993}
1994
1995/* DAI link - used for any driver specific init */
1996static int sof_route_load(struct snd_soc_component *scomp, int index,
1997 struct snd_soc_dapm_route *route)
1998{
1999 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2000 struct snd_sof_widget *source_swidget, *sink_swidget;
2001 struct snd_soc_dobj *dobj = &route->dobj;
2002 struct snd_sof_route *sroute;
2003 int ret = 0;
2004
2005 /* allocate memory for sroute and connect */
2006 sroute = kzalloc(sizeof(*sroute), GFP_KERNEL);
2007 if (!sroute)
2008 return -ENOMEM;
2009
2010 sroute->scomp = scomp;
2011 dev_dbg(scomp->dev, "sink %s control %s source %s\n",
2012 route->sink, route->control ? route->control : "none",
2013 route->source);
2014
2015 /* source component */
2016 source_swidget = snd_sof_find_swidget(scomp, (char *)route->source);
2017 if (!source_swidget) {
2018 dev_err(scomp->dev, "error: source %s not found\n",
2019 route->source);
2020 ret = -EINVAL;
2021 goto err;
2022 }
2023
2024 /*
2025 * Virtual widgets of type output/out_drv may be added in topology
2026 * for compatibility. These are not handled by the FW.
2027 * So, don't send routes whose source/sink widget is of such types
2028 * to the DSP.
2029 */
2030 if (source_swidget->id == snd_soc_dapm_out_drv ||
2031 source_swidget->id == snd_soc_dapm_output)
2032 goto err;
2033
2034 /* sink component */
2035 sink_swidget = snd_sof_find_swidget(scomp, (char *)route->sink);
2036 if (!sink_swidget) {
2037 dev_err(scomp->dev, "error: sink %s not found\n",
2038 route->sink);
2039 ret = -EINVAL;
2040 goto err;
2041 }
2042
2043 /*
2044 * Don't send routes whose sink widget is of type
2045 * output or out_drv to the DSP
2046 */
2047 if (sink_swidget->id == snd_soc_dapm_out_drv ||
2048 sink_swidget->id == snd_soc_dapm_output)
2049 goto err;
2050
2051 sroute->route = route;
2052 dobj->private = sroute;
2053 sroute->src_widget = source_swidget;
2054 sroute->sink_widget = sink_swidget;
2055
2056 /* add route to route list */
2057 list_add(&sroute->list, &sdev->route_list);
2058
2059 return 0;
2060err:
2061 kfree(sroute);
2062 return ret;
2063}
2064
2065/**
2066 * sof_set_pipe_widget - Set pipe_widget for a component
2067 * @sdev: pointer to struct snd_sof_dev
2068 * @pipe_widget: pointer to struct snd_sof_widget of type snd_soc_dapm_scheduler
2069 * @swidget: pointer to struct snd_sof_widget that has the same pipeline ID as @pipe_widget
2070 *
2071 * Return: 0 if successful, -EINVAL on error.
2072 * The function checks if @swidget is associated with any volatile controls. If so, setting
2073 * the dynamic_pipeline_widget is disallowed.
2074 */
2075static int sof_set_pipe_widget(struct snd_sof_dev *sdev, struct snd_sof_widget *pipe_widget,
2076 struct snd_sof_widget *swidget)
2077{
2078 struct snd_sof_control *scontrol;
2079
2080 if (pipe_widget->dynamic_pipeline_widget) {
2081 /* dynamic widgets cannot have volatile kcontrols */
2082 list_for_each_entry(scontrol, &sdev->kcontrol_list, list)
2083 if (scontrol->comp_id == swidget->comp_id &&
2084 (scontrol->access & SNDRV_CTL_ELEM_ACCESS_VOLATILE)) {
2085 dev_err(sdev->dev,
2086 "error: volatile control found for dynamic widget %s\n",
2087 swidget->widget->name);
2088 return -EINVAL;
2089 }
2090 }
2091
2092 /* set the pipe_widget and apply the dynamic_pipeline_widget_flag */
2093 swidget->pipe_widget = pipe_widget;
2094 swidget->dynamic_pipeline_widget = pipe_widget->dynamic_pipeline_widget;
2095
2096 return 0;
2097}
2098
2099/* completion - called at completion of firmware loading */
2100static int sof_complete(struct snd_soc_component *scomp)
2101{
2102 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2103 struct snd_sof_widget *swidget, *comp_swidget;
2104 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
2105 const struct sof_ipc_tplg_widget_ops *widget_ops = ipc_tplg_ops->widget;
2106 struct snd_sof_control *scontrol;
2107 int ret;
2108
2109 /* first update all control IPC structures based on the IPC version */
2110 if (ipc_tplg_ops->control_setup)
2111 list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
2112 ret = ipc_tplg_ops->control_setup(sdev, scontrol);
2113 if (ret < 0) {
2114 dev_err(sdev->dev, "failed updating IPC struct for control %s\n",
2115 scontrol->name);
2116 return ret;
2117 }
2118 }
2119
2120 /*
2121 * then update all widget IPC structures. If any of the ipc_setup callbacks fail, the
2122 * topology will be removed and all widgets will be unloaded resulting in freeing all
2123 * associated memories.
2124 */
2125 list_for_each_entry(swidget, &sdev->widget_list, list) {
2126 if (widget_ops[swidget->id].ipc_setup) {
2127 ret = widget_ops[swidget->id].ipc_setup(swidget);
2128 if (ret < 0) {
2129 dev_err(sdev->dev, "failed updating IPC struct for %s\n",
2130 swidget->widget->name);
2131 return ret;
2132 }
2133 }
2134 }
2135
2136 /* set the pipe_widget and apply the dynamic_pipeline_widget_flag */
2137 list_for_each_entry(swidget, &sdev->widget_list, list) {
2138 switch (swidget->id) {
2139 case snd_soc_dapm_scheduler:
2140 /*
2141 * Apply the dynamic_pipeline_widget flag and set the pipe_widget field
2142 * for all widgets that have the same pipeline ID as the scheduler widget
2143 */
2144 list_for_each_entry(comp_swidget, &sdev->widget_list, list)
2145 if (comp_swidget->pipeline_id == swidget->pipeline_id) {
2146 ret = sof_set_pipe_widget(sdev, swidget, comp_swidget);
2147 if (ret < 0)
2148 return ret;
2149 }
2150 break;
2151 default:
2152 break;
2153 }
2154 }
2155
2156 /* verify topology components loading including dynamic pipelines */
2157 if (sof_debug_check_flag(SOF_DBG_VERIFY_TPLG)) {
2158 if (ipc_tplg_ops->set_up_all_pipelines && ipc_tplg_ops->tear_down_all_pipelines) {
2159 ret = ipc_tplg_ops->set_up_all_pipelines(sdev, true);
2160 if (ret < 0) {
2161 dev_err(sdev->dev, "Failed to set up all topology pipelines: %d\n",
2162 ret);
2163 return ret;
2164 }
2165
2166 ret = ipc_tplg_ops->tear_down_all_pipelines(sdev, true);
2167 if (ret < 0) {
2168 dev_err(sdev->dev, "Failed to tear down topology pipelines: %d\n",
2169 ret);
2170 return ret;
2171 }
2172 }
2173 }
2174
2175 /* set up static pipelines */
2176 if (ipc_tplg_ops->set_up_all_pipelines)
2177 return ipc_tplg_ops->set_up_all_pipelines(sdev, false);
2178
2179 return 0;
2180}
2181
2182/* manifest - optional to inform component of manifest */
2183static int sof_manifest(struct snd_soc_component *scomp, int index,
2184 struct snd_soc_tplg_manifest *man)
2185{
2186 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2187 const struct sof_ipc_tplg_ops *ipc_tplg_ops = sdev->ipc->ops->tplg;
2188
2189 if (ipc_tplg_ops->parse_manifest)
2190 return ipc_tplg_ops->parse_manifest(scomp, index, man);
2191
2192 return 0;
2193}
2194
2195/* vendor specific kcontrol handlers available for binding */
2196static const struct snd_soc_tplg_kcontrol_ops sof_io_ops[] = {
2197 {SOF_TPLG_KCTL_VOL_ID, snd_sof_volume_get, snd_sof_volume_put},
2198 {SOF_TPLG_KCTL_BYTES_ID, snd_sof_bytes_get, snd_sof_bytes_put},
2199 {SOF_TPLG_KCTL_ENUM_ID, snd_sof_enum_get, snd_sof_enum_put},
2200 {SOF_TPLG_KCTL_SWITCH_ID, snd_sof_switch_get, snd_sof_switch_put},
2201};
2202
2203/* vendor specific bytes ext handlers available for binding */
2204static const struct snd_soc_tplg_bytes_ext_ops sof_bytes_ext_ops[] = {
2205 {SOF_TPLG_KCTL_BYTES_ID, snd_sof_bytes_ext_get, snd_sof_bytes_ext_put},
2206 {SOF_TPLG_KCTL_BYTES_VOLATILE_RO, snd_sof_bytes_ext_volatile_get},
2207};
2208
2209static struct snd_soc_tplg_ops sof_tplg_ops = {
2210 /* external kcontrol init - used for any driver specific init */
2211 .control_load = sof_control_load,
2212 .control_unload = sof_control_unload,
2213
2214 /* external kcontrol init - used for any driver specific init */
2215 .dapm_route_load = sof_route_load,
2216 .dapm_route_unload = sof_route_unload,
2217
2218 /* external widget init - used for any driver specific init */
2219 /* .widget_load is not currently used */
2220 .widget_ready = sof_widget_ready,
2221 .widget_unload = sof_widget_unload,
2222
2223 /* FE DAI - used for any driver specific init */
2224 .dai_load = sof_dai_load,
2225 .dai_unload = sof_dai_unload,
2226
2227 /* DAI link - used for any driver specific init */
2228 .link_load = sof_link_load,
2229 .link_unload = sof_link_unload,
2230
2231 /* completion - called at completion of firmware loading */
2232 .complete = sof_complete,
2233
2234 /* manifest - optional to inform component of manifest */
2235 .manifest = sof_manifest,
2236
2237 /* vendor specific kcontrol handlers available for binding */
2238 .io_ops = sof_io_ops,
2239 .io_ops_count = ARRAY_SIZE(sof_io_ops),
2240
2241 /* vendor specific bytes ext handlers available for binding */
2242 .bytes_ext_ops = sof_bytes_ext_ops,
2243 .bytes_ext_ops_count = ARRAY_SIZE(sof_bytes_ext_ops),
2244};
2245
2246int snd_sof_load_topology(struct snd_soc_component *scomp, const char *file)
2247{
2248 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2249 const struct firmware *fw;
2250 int ret;
2251
2252 dev_dbg(scomp->dev, "loading topology:%s\n", file);
2253
2254 ret = request_firmware(&fw, file, scomp->dev);
2255 if (ret < 0) {
2256 dev_err(scomp->dev, "error: tplg request firmware %s failed err: %d\n",
2257 file, ret);
2258 dev_err(scomp->dev,
2259 "you may need to download the firmware from https://github.com/thesofproject/sof-bin/\n");
2260 return ret;
2261 }
2262
2263 ret = snd_soc_tplg_component_load(scomp, &sof_tplg_ops, fw);
2264 if (ret < 0) {
2265 dev_err(scomp->dev, "error: tplg component load failed %d\n",
2266 ret);
2267 ret = -EINVAL;
2268 }
2269
2270 release_firmware(fw);
2271
2272 if (ret >= 0 && sdev->led_present)
2273 ret = snd_ctl_led_request();
2274
2275 return ret;
2276}
2277EXPORT_SYMBOL(snd_sof_load_topology);