1
2
3
4
5
6
7
8
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
23
24
25#define VOL_TWENTIETH_ROOT_OF_TEN 73533
26
27#define VOL_FORTIETH_ROOT_OF_TEN 69419
28
29
30
31
32#define VOLUME_FWL 16
33
34#define VOL_HALF_DB_STEP 50
35
36#define VOL_ZERO_DB BIT(VOLUME_FWL)
37
38
39#define TLV_ITEMS 3
40#define TLV_MIN 0
41#define TLV_STEP 1
42#define TLV_MUTE 2
43
44
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
222 if ((int)p[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
223 return -EINVAL;
224
225
226 tlv[TLV_MIN] = (int)p[SNDRV_CTL_TLVO_DB_SCALE_MIN] / 100;
227
228
229 tlv[TLV_STEP] = (int)(p[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] &
230 TLV_DB_SCALE_MASK);
231
232
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
244
245
246
247static inline u32 vol_shift_64(u64 i, u32 x)
248{
249
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
261
262
263
264
265
266
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
275 if (exp == 0)
276 return power;
277
278
279 if (exp < 0)
280 iter = exp * -1;
281 else
282 iter = exp;
283
284
285 for (i = 0; i < iter; i++) {
286
287
288
289
290 power = vol_shift_64((u64)power * a, fwl);
291 }
292
293 if (exp > 0) {
294
295 return power;
296 }
297
298
299 numerator = (u64)1 << (fwl << 1);
300 do_div(numerator, power);
301
302 return (u32)numerator;
303}
304
305
306
307
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
316 if (value == 0 && tlv[TLV_MUTE])
317 return 0;
318
319
320
321
322
323 dB_gain = tlv[TLV_MIN] + (value * tlv[TLV_STEP]) / 100;
324
325
326
327
328
329 linear_gain = vol_pow32(VOL_TWENTIETH_ROOT_OF_TEN, dB_gain, VOLUME_FWL);
330
331
332 f_step = tlv[TLV_STEP] - (tlv[TLV_STEP] / 100);
333
334
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
345
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
353 scontrol->volume_table = kcalloc(size, sizeof(u32), GFP_KERNEL);
354 if (!scontrol->volume_table)
355 return -ENOMEM;
356
357
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
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
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
463
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
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
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
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
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
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
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
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
594static const struct sof_topology_token tone_tokens[] = {
595};
596
597
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
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
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
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
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
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
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
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
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
720
721
722
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
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
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
785 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
786 elem = &array->uuid[i];
787
788
789 for (j = 0; j < count; j++) {
790
791 if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_UUID)
792 continue;
793
794
795 if (tokens[j].token != le32_to_cpu(elem->token))
796 continue;
797
798
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
822 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
823 elem = &array->string[i];
824
825
826 for (j = 0; j < count; j++) {
827
828 if (tokens[j].type != SND_SOC_TPLG_TUPLE_TYPE_STRING)
829 continue;
830
831
832 if (tokens[j].token != le32_to_cpu(elem->token))
833 continue;
834
835
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
859 for (i = 0; i < le32_to_cpu(array->num_elems); i++) {
860 elem = &array->value[i];
861
862
863 for (j = 0; j < count; j++) {
864
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
872 if (tokens[j].token != le32_to_cpu(elem->token))
873 continue;
874
875
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
889
890
891
892
893
894
895
896
897
898
899
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
917 if (asize < 0) {
918 dev_err(scomp->dev, "error: invalid array size 0x%x\n",
919 asize);
920 return -EINVAL;
921 }
922
923
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
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
955 array = (struct snd_soc_tplg_vendor_array *)((u8 *)array
956 + asize);
957
958
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
978
979
980
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
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
1012 if (le32_to_cpu(mc->num_channels) > SND_SOC_TPLG_MAX_CHAN) {
1013 ret = -EINVAL;
1014 goto out;
1015 }
1016
1017
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
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
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
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
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
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
1095 if (le32_to_cpu(ec->num_channels) > SND_SOC_TPLG_MAX_CHAN)
1096 return -EINVAL;
1097
1098
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
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
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
1272 return sof_ipc_tx_message(sdev->ipc,
1273 fcomp.hdr.cmd, &fcomp, sizeof(fcomp),
1274 NULL, 0);
1275}
1276
1277
1278
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
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
1307
1308
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
1329
1330
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
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
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
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
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
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
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
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
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
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
1572 sdev->enabled_cores_mask |= 1 << pipeline->core;
1573
1574
1575
1576
1577
1578 memset(&pm_core_config, 0, sizeof(pm_core_config));
1579 pm_core_config.enable_mask = sdev->enabled_cores_mask;
1580
1581
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
2052 if (wdata[i].pdata->magic != SOF_ABI_MAGIC)
2053 return -EINVAL;
2054
2055 *size += wdata[i].pdata->size;
2056
2057
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
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
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
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
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
2154
2155
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
2178 if (ipc_data_size)
2179 goto out;
2180
2181
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
2205
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
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
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
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
2253 switch (event_type) {
2254 case SOF_KEYWORD_DETECT_DAPM_EVENT:
2255
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
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
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
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
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
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
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
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
2456 kfree(dai->dai_config);
2457 list_del(&dai->list);
2458 }
2459 break;
2460 case snd_soc_dapm_scheduler:
2461
2462
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
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
2504 kfree(swidget->private);
2505
2506
2507 list_del(&swidget->list);
2508 kfree(swidget);
2509
2510 return ret;
2511}
2512
2513
2514
2515
2516
2517
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
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
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
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
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
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
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
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
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
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
2651 if (hw_config->bclk_master == SND_SOC_TPLG_BCLK_CM) {
2652
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
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
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
2681
2682
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
2701
2702
2703
2704
2705 config->dai_index = dai->comp_dai.dai_index;
2706
2707
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
2722 dai->cpu_dai_name = link->cpus->dai_name;
2723
2724 found = 1;
2725 }
2726 }
2727
2728
2729
2730
2731
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
2753 sof_dai_set_format(hw_config, config);
2754
2755
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
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
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
2818 sof_dai_set_format(hw_config, config);
2819
2820
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
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
2876 sof_dai_set_format(hw_config, config);
2877
2878
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
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
2935 memset(&config->dmic, 0, sizeof(struct sof_ipc_dai_dmic_params));
2936
2937
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
2949
2950
2951 sdev->private = kzalloc(sizeof(u32), GFP_KERNEL);
2952 if (!sdev->private)
2953 return -ENOMEM;
2954
2955
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
2969 config->hdr.size = size;
2970
2971
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
2999
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
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
3029 memset(&config->hda, 0, sizeof(struct sof_ipc_dai_hda_params));
3030 config->hdr.size = size;
3031
3032
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
3083 config->hdr.size = size;
3084
3085
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
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
3114
3115
3116 if (!link->no_pcm) {
3117 link->nonatomic = true;
3118
3119
3120
3121
3122
3123
3124
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
3132 return 0;
3133 }
3134
3135
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
3142 memset(&config, 0, sizeof(config));
3143
3144
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
3156
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
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
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
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
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
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
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
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
3332
3333
3334
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
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
3353
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
3363
3364
3365
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
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
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
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
3415
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
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
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
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
3504
3505
3506 snd_sof_cache_kcontrol_val(scomp);
3507}
3508
3509
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
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
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
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
3571 .control_load = sof_control_load,
3572 .control_unload = sof_control_unload,
3573
3574
3575 .dapm_route_load = sof_route_load,
3576 .dapm_route_unload = sof_route_unload,
3577
3578
3579
3580 .widget_ready = sof_widget_ready,
3581 .widget_unload = sof_widget_unload,
3582
3583
3584 .dai_load = sof_dai_load,
3585 .dai_unload = sof_dai_unload,
3586
3587
3588 .link_load = sof_link_load,
3589 .link_unload = sof_link_unload,
3590
3591
3592 .complete = sof_complete,
3593
3594
3595 .manifest = sof_manifest,
3596
3597
3598 .io_ops = sof_io_ops,
3599 .io_ops_count = ARRAY_SIZE(sof_io_ops),
3600
3601
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);
3633