1 // SPDX-License-Identifier: GPL-2.0+
3 // soc-topology.c -- ALSA SoC Topology
5 // Copyright (C) 2012 Texas Instruments Inc.
6 // Copyright (C) 2015 Intel Corporation.
8 // Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com>
9 // K, Mythri P <mythri.p.k@intel.com>
10 // Prusty, Subhransu S <subhransu.s.prusty@intel.com>
11 // B, Jayachandran <jayachandran.b@intel.com>
12 // Abdullah, Omair M <omair.m.abdullah@intel.com>
13 // Jin, Yao <yao.jin@intel.com>
14 // Lin, Mengdong <mengdong.lin@intel.com>
16 // Add support to read audio firmware topology alongside firmware text. The
17 // topology data can contain kcontrols, DAPM graphs, widgets, DAIs, DAI links,
18 // equalizers, firmware, coefficients etc.
20 // This file only manages the core ALSA and ASoC components, all other bespoke
21 // firmware topology data is passed to component drivers for bespoke handling.
23 #include <linux/kernel.h>
24 #include <linux/export.h>
25 #include <linux/list.h>
26 #include <linux/firmware.h>
27 #include <linux/slab.h>
28 #include <sound/soc.h>
29 #include <sound/soc-dapm.h>
30 #include <sound/soc-topology.h>
31 #include <sound/tlv.h>
33 #define SOC_TPLG_MAGIC_BIG_ENDIAN 0x436F5341 /* ASoC in reverse */
36 * We make several passes over the data (since it wont necessarily be ordered)
37 * and process objects in the following order. This guarantees the component
38 * drivers will be ready with any vendor data before the mixers and DAPM objects
39 * are loaded (that may make use of the vendor data).
41 #define SOC_TPLG_PASS_MANIFEST 0
42 #define SOC_TPLG_PASS_VENDOR 1
43 #define SOC_TPLG_PASS_MIXER 2
44 #define SOC_TPLG_PASS_WIDGET 3
45 #define SOC_TPLG_PASS_PCM_DAI 4
46 #define SOC_TPLG_PASS_GRAPH 5
47 #define SOC_TPLG_PASS_PINS 6
48 #define SOC_TPLG_PASS_BE_DAI 7
49 #define SOC_TPLG_PASS_LINK 8
51 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST
52 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_LINK
54 /* topology context */
56 const struct firmware
*fw
;
58 /* runtime FW parsing */
59 const u8
*pos
; /* read postion */
60 const u8
*hdr_pos
; /* header position */
61 unsigned int pass
; /* pass number */
63 /* component caller */
65 struct snd_soc_component
*comp
;
66 u32 index
; /* current block index */
67 u32 req_index
; /* required index, only loaded/free matching blocks */
69 /* vendor specific kcontrol operations */
70 const struct snd_soc_tplg_kcontrol_ops
*io_ops
;
73 /* vendor specific bytes ext handlers, for TLV bytes controls */
74 const struct snd_soc_tplg_bytes_ext_ops
*bytes_ext_ops
;
75 int bytes_ext_ops_count
;
77 /* optional fw loading callbacks to component drivers */
78 struct snd_soc_tplg_ops
*ops
;
81 static int soc_tplg_process_headers(struct soc_tplg
*tplg
);
82 static void soc_tplg_complete(struct soc_tplg
*tplg
);
83 static void soc_tplg_denum_remove_texts(struct soc_enum
*se
);
84 static void soc_tplg_denum_remove_values(struct soc_enum
*se
);
86 /* check we dont overflow the data for this control chunk */
87 static int soc_tplg_check_elem_count(struct soc_tplg
*tplg
, size_t elem_size
,
88 unsigned int count
, size_t bytes
, const char *elem_type
)
90 const u8
*end
= tplg
->pos
+ elem_size
* count
;
92 if (end
> tplg
->fw
->data
+ tplg
->fw
->size
) {
93 dev_err(tplg
->dev
, "ASoC: %s overflow end of data\n",
98 /* check there is enough room in chunk for control.
99 extra bytes at the end of control are for vendor data here */
100 if (elem_size
* count
> bytes
) {
102 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
103 elem_type
, count
, elem_size
, bytes
);
110 static inline int soc_tplg_is_eof(struct soc_tplg
*tplg
)
112 const u8
*end
= tplg
->hdr_pos
;
114 if (end
>= tplg
->fw
->data
+ tplg
->fw
->size
)
119 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg
*tplg
)
121 return (unsigned long)(tplg
->hdr_pos
- tplg
->fw
->data
);
124 static inline unsigned long soc_tplg_get_offset(struct soc_tplg
*tplg
)
126 return (unsigned long)(tplg
->pos
- tplg
->fw
->data
);
129 /* mapping of Kcontrol types and associated operations. */
130 static const struct snd_soc_tplg_kcontrol_ops io_ops
[] = {
131 {SND_SOC_TPLG_CTL_VOLSW
, snd_soc_get_volsw
,
132 snd_soc_put_volsw
, snd_soc_info_volsw
},
133 {SND_SOC_TPLG_CTL_VOLSW_SX
, snd_soc_get_volsw_sx
,
134 snd_soc_put_volsw_sx
, NULL
},
135 {SND_SOC_TPLG_CTL_ENUM
, snd_soc_get_enum_double
,
136 snd_soc_put_enum_double
, snd_soc_info_enum_double
},
137 {SND_SOC_TPLG_CTL_ENUM_VALUE
, snd_soc_get_enum_double
,
138 snd_soc_put_enum_double
, NULL
},
139 {SND_SOC_TPLG_CTL_BYTES
, snd_soc_bytes_get
,
140 snd_soc_bytes_put
, snd_soc_bytes_info
},
141 {SND_SOC_TPLG_CTL_RANGE
, snd_soc_get_volsw_range
,
142 snd_soc_put_volsw_range
, snd_soc_info_volsw_range
},
143 {SND_SOC_TPLG_CTL_VOLSW_XR_SX
, snd_soc_get_xr_sx
,
144 snd_soc_put_xr_sx
, snd_soc_info_xr_sx
},
145 {SND_SOC_TPLG_CTL_STROBE
, snd_soc_get_strobe
,
146 snd_soc_put_strobe
, NULL
},
147 {SND_SOC_TPLG_DAPM_CTL_VOLSW
, snd_soc_dapm_get_volsw
,
148 snd_soc_dapm_put_volsw
, snd_soc_info_volsw
},
149 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
, snd_soc_dapm_get_enum_double
,
150 snd_soc_dapm_put_enum_double
, snd_soc_info_enum_double
},
151 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
, snd_soc_dapm_get_enum_double
,
152 snd_soc_dapm_put_enum_double
, NULL
},
153 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
, snd_soc_dapm_get_enum_double
,
154 snd_soc_dapm_put_enum_double
, NULL
},
155 {SND_SOC_TPLG_DAPM_CTL_PIN
, snd_soc_dapm_get_pin_switch
,
156 snd_soc_dapm_put_pin_switch
, snd_soc_dapm_info_pin_switch
},
159 struct soc_tplg_map
{
164 /* mapping of widget types from UAPI IDs to kernel IDs */
165 static const struct soc_tplg_map dapm_map
[] = {
166 {SND_SOC_TPLG_DAPM_INPUT
, snd_soc_dapm_input
},
167 {SND_SOC_TPLG_DAPM_OUTPUT
, snd_soc_dapm_output
},
168 {SND_SOC_TPLG_DAPM_MUX
, snd_soc_dapm_mux
},
169 {SND_SOC_TPLG_DAPM_MIXER
, snd_soc_dapm_mixer
},
170 {SND_SOC_TPLG_DAPM_PGA
, snd_soc_dapm_pga
},
171 {SND_SOC_TPLG_DAPM_OUT_DRV
, snd_soc_dapm_out_drv
},
172 {SND_SOC_TPLG_DAPM_ADC
, snd_soc_dapm_adc
},
173 {SND_SOC_TPLG_DAPM_DAC
, snd_soc_dapm_dac
},
174 {SND_SOC_TPLG_DAPM_SWITCH
, snd_soc_dapm_switch
},
175 {SND_SOC_TPLG_DAPM_PRE
, snd_soc_dapm_pre
},
176 {SND_SOC_TPLG_DAPM_POST
, snd_soc_dapm_post
},
177 {SND_SOC_TPLG_DAPM_AIF_IN
, snd_soc_dapm_aif_in
},
178 {SND_SOC_TPLG_DAPM_AIF_OUT
, snd_soc_dapm_aif_out
},
179 {SND_SOC_TPLG_DAPM_DAI_IN
, snd_soc_dapm_dai_in
},
180 {SND_SOC_TPLG_DAPM_DAI_OUT
, snd_soc_dapm_dai_out
},
181 {SND_SOC_TPLG_DAPM_DAI_LINK
, snd_soc_dapm_dai_link
},
182 {SND_SOC_TPLG_DAPM_BUFFER
, snd_soc_dapm_buffer
},
183 {SND_SOC_TPLG_DAPM_SCHEDULER
, snd_soc_dapm_scheduler
},
184 {SND_SOC_TPLG_DAPM_EFFECT
, snd_soc_dapm_effect
},
185 {SND_SOC_TPLG_DAPM_SIGGEN
, snd_soc_dapm_siggen
},
186 {SND_SOC_TPLG_DAPM_SRC
, snd_soc_dapm_src
},
187 {SND_SOC_TPLG_DAPM_ASRC
, snd_soc_dapm_asrc
},
188 {SND_SOC_TPLG_DAPM_ENCODER
, snd_soc_dapm_encoder
},
189 {SND_SOC_TPLG_DAPM_DECODER
, snd_soc_dapm_decoder
},
192 static int tplc_chan_get_reg(struct soc_tplg
*tplg
,
193 struct snd_soc_tplg_channel
*chan
, int map
)
197 for (i
= 0; i
< SND_SOC_TPLG_MAX_CHAN
; i
++) {
198 if (le32_to_cpu(chan
[i
].id
) == map
)
199 return le32_to_cpu(chan
[i
].reg
);
205 static int tplc_chan_get_shift(struct soc_tplg
*tplg
,
206 struct snd_soc_tplg_channel
*chan
, int map
)
210 for (i
= 0; i
< SND_SOC_TPLG_MAX_CHAN
; i
++) {
211 if (le32_to_cpu(chan
[i
].id
) == map
)
212 return le32_to_cpu(chan
[i
].shift
);
218 static int get_widget_id(int tplg_type
)
222 for (i
= 0; i
< ARRAY_SIZE(dapm_map
); i
++) {
223 if (tplg_type
== dapm_map
[i
].uid
)
224 return dapm_map
[i
].kid
;
230 static inline void soc_bind_err(struct soc_tplg
*tplg
,
231 struct snd_soc_tplg_ctl_hdr
*hdr
, int index
)
234 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n",
235 hdr
->ops
.get
, hdr
->ops
.put
, hdr
->ops
.info
, index
,
236 soc_tplg_get_offset(tplg
));
239 static inline void soc_control_err(struct soc_tplg
*tplg
,
240 struct snd_soc_tplg_ctl_hdr
*hdr
, const char *name
)
243 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n",
244 name
, hdr
->ops
.get
, hdr
->ops
.put
, hdr
->ops
.info
,
245 soc_tplg_get_offset(tplg
));
248 /* pass vendor data to component driver for processing */
249 static int soc_tplg_vendor_load_(struct soc_tplg
*tplg
,
250 struct snd_soc_tplg_hdr
*hdr
)
254 if (tplg
->ops
&& tplg
->ops
->vendor_load
)
255 ret
= tplg
->ops
->vendor_load(tplg
->comp
, tplg
->index
, hdr
);
257 dev_err(tplg
->dev
, "ASoC: no vendor load callback for ID %d\n",
264 "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n",
265 soc_tplg_get_hdr_offset(tplg
),
266 soc_tplg_get_hdr_offset(tplg
),
267 hdr
->type
, hdr
->vendor_type
);
271 /* pass vendor data to component driver for processing */
272 static int soc_tplg_vendor_load(struct soc_tplg
*tplg
,
273 struct snd_soc_tplg_hdr
*hdr
)
275 if (tplg
->pass
!= SOC_TPLG_PASS_VENDOR
)
278 return soc_tplg_vendor_load_(tplg
, hdr
);
281 /* optionally pass new dynamic widget to component driver. This is mainly for
282 * external widgets where we can assign private data/ops */
283 static int soc_tplg_widget_load(struct soc_tplg
*tplg
,
284 struct snd_soc_dapm_widget
*w
, struct snd_soc_tplg_dapm_widget
*tplg_w
)
286 if (tplg
->ops
&& tplg
->ops
->widget_load
)
287 return tplg
->ops
->widget_load(tplg
->comp
, tplg
->index
, w
,
293 /* optionally pass new dynamic widget to component driver. This is mainly for
294 * external widgets where we can assign private data/ops */
295 static int soc_tplg_widget_ready(struct soc_tplg
*tplg
,
296 struct snd_soc_dapm_widget
*w
, struct snd_soc_tplg_dapm_widget
*tplg_w
)
298 if (tplg
->ops
&& tplg
->ops
->widget_ready
)
299 return tplg
->ops
->widget_ready(tplg
->comp
, tplg
->index
, w
,
305 /* pass DAI configurations to component driver for extra initialization */
306 static int soc_tplg_dai_load(struct soc_tplg
*tplg
,
307 struct snd_soc_dai_driver
*dai_drv
,
308 struct snd_soc_tplg_pcm
*pcm
, struct snd_soc_dai
*dai
)
310 if (tplg
->ops
&& tplg
->ops
->dai_load
)
311 return tplg
->ops
->dai_load(tplg
->comp
, tplg
->index
, dai_drv
,
317 /* pass link configurations to component driver for extra initialization */
318 static int soc_tplg_dai_link_load(struct soc_tplg
*tplg
,
319 struct snd_soc_dai_link
*link
, struct snd_soc_tplg_link_config
*cfg
)
321 if (tplg
->ops
&& tplg
->ops
->link_load
)
322 return tplg
->ops
->link_load(tplg
->comp
, tplg
->index
, link
, cfg
);
327 /* tell the component driver that all firmware has been loaded in this request */
328 static void soc_tplg_complete(struct soc_tplg
*tplg
)
330 if (tplg
->ops
&& tplg
->ops
->complete
)
331 tplg
->ops
->complete(tplg
->comp
);
334 /* add a dynamic kcontrol */
335 static int soc_tplg_add_dcontrol(struct snd_card
*card
, struct device
*dev
,
336 const struct snd_kcontrol_new
*control_new
, const char *prefix
,
337 void *data
, struct snd_kcontrol
**kcontrol
)
341 *kcontrol
= snd_soc_cnew(control_new
, data
, control_new
->name
, prefix
);
342 if (*kcontrol
== NULL
) {
343 dev_err(dev
, "ASoC: Failed to create new kcontrol %s\n",
348 err
= snd_ctl_add(card
, *kcontrol
);
350 dev_err(dev
, "ASoC: Failed to add %s: %d\n",
351 control_new
->name
, err
);
358 /* add a dynamic kcontrol for component driver */
359 static int soc_tplg_add_kcontrol(struct soc_tplg
*tplg
,
360 struct snd_kcontrol_new
*k
, struct snd_kcontrol
**kcontrol
)
362 struct snd_soc_component
*comp
= tplg
->comp
;
364 return soc_tplg_add_dcontrol(comp
->card
->snd_card
,
365 comp
->dev
, k
, comp
->name_prefix
, comp
, kcontrol
);
368 /* remove a mixer kcontrol */
369 static void remove_mixer(struct snd_soc_component
*comp
,
370 struct snd_soc_dobj
*dobj
, int pass
)
372 struct snd_card
*card
= comp
->card
->snd_card
;
373 struct soc_mixer_control
*sm
=
374 container_of(dobj
, struct soc_mixer_control
, dobj
);
375 const unsigned int *p
= NULL
;
377 if (pass
!= SOC_TPLG_PASS_MIXER
)
380 if (dobj
->ops
&& dobj
->ops
->control_unload
)
381 dobj
->ops
->control_unload(comp
, dobj
);
383 if (dobj
->control
.kcontrol
->tlv
.p
)
384 p
= dobj
->control
.kcontrol
->tlv
.p
;
385 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
386 list_del(&dobj
->list
);
391 /* remove an enum kcontrol */
392 static void remove_enum(struct snd_soc_component
*comp
,
393 struct snd_soc_dobj
*dobj
, int pass
)
395 struct snd_card
*card
= comp
->card
->snd_card
;
396 struct soc_enum
*se
= container_of(dobj
, struct soc_enum
, dobj
);
398 if (pass
!= SOC_TPLG_PASS_MIXER
)
401 if (dobj
->ops
&& dobj
->ops
->control_unload
)
402 dobj
->ops
->control_unload(comp
, dobj
);
404 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
405 list_del(&dobj
->list
);
407 soc_tplg_denum_remove_values(se
);
408 soc_tplg_denum_remove_texts(se
);
412 /* remove a byte kcontrol */
413 static void remove_bytes(struct snd_soc_component
*comp
,
414 struct snd_soc_dobj
*dobj
, int pass
)
416 struct snd_card
*card
= comp
->card
->snd_card
;
417 struct soc_bytes_ext
*sb
=
418 container_of(dobj
, struct soc_bytes_ext
, dobj
);
420 if (pass
!= SOC_TPLG_PASS_MIXER
)
423 if (dobj
->ops
&& dobj
->ops
->control_unload
)
424 dobj
->ops
->control_unload(comp
, dobj
);
426 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
427 list_del(&dobj
->list
);
432 static void remove_route(struct snd_soc_component
*comp
,
433 struct snd_soc_dobj
*dobj
, int pass
)
435 struct snd_soc_dapm_route
*route
=
436 container_of(dobj
, struct snd_soc_dapm_route
, dobj
);
438 if (pass
!= SOC_TPLG_PASS_GRAPH
)
441 if (dobj
->ops
&& dobj
->ops
->dapm_route_unload
)
442 dobj
->ops
->dapm_route_unload(comp
, dobj
);
444 list_del(&dobj
->list
);
448 /* remove a widget and it's kcontrols - routes must be removed first */
449 static void remove_widget(struct snd_soc_component
*comp
,
450 struct snd_soc_dobj
*dobj
, int pass
)
452 struct snd_card
*card
= comp
->card
->snd_card
;
453 struct snd_soc_dapm_widget
*w
=
454 container_of(dobj
, struct snd_soc_dapm_widget
, dobj
);
457 if (pass
!= SOC_TPLG_PASS_WIDGET
)
460 if (dobj
->ops
&& dobj
->ops
->widget_unload
)
461 dobj
->ops
->widget_unload(comp
, dobj
);
467 * Dynamic Widgets either have 1..N enum kcontrols or mixers.
468 * The enum may either have an array of values or strings.
470 if (dobj
->widget
.kcontrol_type
== SND_SOC_TPLG_TYPE_ENUM
) {
471 /* enumerated widget mixer */
472 for (i
= 0; w
->kcontrols
!= NULL
&& i
< w
->num_kcontrols
; i
++) {
473 struct snd_kcontrol
*kcontrol
= w
->kcontrols
[i
];
474 struct soc_enum
*se
=
475 (struct soc_enum
*)kcontrol
->private_value
;
477 snd_ctl_remove(card
, kcontrol
);
479 /* free enum kcontrol's dvalues and dtexts */
480 soc_tplg_denum_remove_values(se
);
481 soc_tplg_denum_remove_texts(se
);
484 kfree(w
->kcontrol_news
[i
].name
);
487 /* volume mixer or bytes controls */
488 for (i
= 0; w
->kcontrols
!= NULL
&& i
< w
->num_kcontrols
; i
++) {
489 struct snd_kcontrol
*kcontrol
= w
->kcontrols
[i
];
491 if (dobj
->widget
.kcontrol_type
492 == SND_SOC_TPLG_TYPE_MIXER
)
493 kfree(kcontrol
->tlv
.p
);
495 /* Private value is used as struct soc_mixer_control
496 * for volume mixers or soc_bytes_ext for bytes
499 kfree((void *)kcontrol
->private_value
);
500 snd_ctl_remove(card
, kcontrol
);
501 kfree(w
->kcontrol_news
[i
].name
);
506 kfree(w
->kcontrol_news
);
508 list_del(&dobj
->list
);
510 /* widget w is freed by soc-dapm.c */
513 /* remove DAI configurations */
514 static void remove_dai(struct snd_soc_component
*comp
,
515 struct snd_soc_dobj
*dobj
, int pass
)
517 struct snd_soc_dai_driver
*dai_drv
=
518 container_of(dobj
, struct snd_soc_dai_driver
, dobj
);
519 struct snd_soc_dai
*dai
;
521 if (pass
!= SOC_TPLG_PASS_PCM_DAI
)
524 if (dobj
->ops
&& dobj
->ops
->dai_unload
)
525 dobj
->ops
->dai_unload(comp
, dobj
);
527 for_each_component_dais(comp
, dai
)
528 if (dai
->driver
== dai_drv
)
531 kfree(dai_drv
->playback
.stream_name
);
532 kfree(dai_drv
->capture
.stream_name
);
533 kfree(dai_drv
->name
);
534 list_del(&dobj
->list
);
538 /* remove link configurations */
539 static void remove_link(struct snd_soc_component
*comp
,
540 struct snd_soc_dobj
*dobj
, int pass
)
542 struct snd_soc_dai_link
*link
=
543 container_of(dobj
, struct snd_soc_dai_link
, dobj
);
545 if (pass
!= SOC_TPLG_PASS_PCM_DAI
)
548 if (dobj
->ops
&& dobj
->ops
->link_unload
)
549 dobj
->ops
->link_unload(comp
, dobj
);
551 list_del(&dobj
->list
);
552 snd_soc_remove_pcm_runtime(comp
->card
,
553 snd_soc_get_pcm_runtime(comp
->card
, link
));
556 kfree(link
->stream_name
);
557 kfree(link
->cpus
->dai_name
);
561 /* unload dai link */
562 static void remove_backend_link(struct snd_soc_component
*comp
,
563 struct snd_soc_dobj
*dobj
, int pass
)
565 if (pass
!= SOC_TPLG_PASS_LINK
)
568 if (dobj
->ops
&& dobj
->ops
->link_unload
)
569 dobj
->ops
->link_unload(comp
, dobj
);
572 * We don't free the link here as what remove_link() do since BE
573 * links are not allocated by topology.
574 * We however need to reset the dobj type to its initial values
576 dobj
->type
= SND_SOC_DOBJ_NONE
;
577 list_del(&dobj
->list
);
580 /* bind a kcontrol to it's IO handlers */
581 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr
*hdr
,
582 struct snd_kcontrol_new
*k
,
583 const struct soc_tplg
*tplg
)
585 const struct snd_soc_tplg_kcontrol_ops
*ops
;
586 const struct snd_soc_tplg_bytes_ext_ops
*ext_ops
;
589 if (le32_to_cpu(hdr
->ops
.info
) == SND_SOC_TPLG_CTL_BYTES
590 && k
->iface
& SNDRV_CTL_ELEM_IFACE_MIXER
591 && k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
592 && k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
) {
593 struct soc_bytes_ext
*sbe
;
594 struct snd_soc_tplg_bytes_control
*be
;
596 sbe
= (struct soc_bytes_ext
*)k
->private_value
;
597 be
= container_of(hdr
, struct snd_soc_tplg_bytes_control
, hdr
);
599 /* TLV bytes controls need standard kcontrol info handler,
600 * TLV callback and extended put/get handlers.
602 k
->info
= snd_soc_bytes_info_ext
;
603 k
->tlv
.c
= snd_soc_bytes_tlv_callback
;
605 ext_ops
= tplg
->bytes_ext_ops
;
606 num_ops
= tplg
->bytes_ext_ops_count
;
607 for (i
= 0; i
< num_ops
; i
++) {
609 ext_ops
[i
].id
== le32_to_cpu(be
->ext_ops
.put
))
610 sbe
->put
= ext_ops
[i
].put
;
612 ext_ops
[i
].id
== le32_to_cpu(be
->ext_ops
.get
))
613 sbe
->get
= ext_ops
[i
].get
;
616 if (sbe
->put
&& sbe
->get
)
622 /* try and map vendor specific kcontrol handlers first */
624 num_ops
= tplg
->io_ops_count
;
625 for (i
= 0; i
< num_ops
; i
++) {
627 if (k
->put
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.put
))
629 if (k
->get
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.get
))
631 if (k
->info
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.info
))
632 k
->info
= ops
[i
].info
;
635 /* vendor specific handlers found ? */
636 if (k
->put
&& k
->get
&& k
->info
)
639 /* none found so try standard kcontrol handlers */
641 num_ops
= ARRAY_SIZE(io_ops
);
642 for (i
= 0; i
< num_ops
; i
++) {
644 if (k
->put
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.put
))
646 if (k
->get
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.get
))
648 if (k
->info
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.info
))
649 k
->info
= ops
[i
].info
;
652 /* standard handlers found ? */
653 if (k
->put
&& k
->get
&& k
->info
)
656 /* nothing to bind */
660 /* bind a widgets to it's evnt handlers */
661 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget
*w
,
662 const struct snd_soc_tplg_widget_events
*events
,
663 int num_events
, u16 event_type
)
669 for (i
= 0; i
< num_events
; i
++) {
670 if (event_type
== events
[i
].type
) {
672 /* found - so assign event */
673 w
->event
= events
[i
].event_handler
;
681 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event
);
683 /* optionally pass new dynamic kcontrol to component driver. */
684 static int soc_tplg_init_kcontrol(struct soc_tplg
*tplg
,
685 struct snd_kcontrol_new
*k
, struct snd_soc_tplg_ctl_hdr
*hdr
)
687 if (tplg
->ops
&& tplg
->ops
->control_load
)
688 return tplg
->ops
->control_load(tplg
->comp
, tplg
->index
, k
,
695 static int soc_tplg_create_tlv_db_scale(struct soc_tplg
*tplg
,
696 struct snd_kcontrol_new
*kc
, struct snd_soc_tplg_tlv_dbscale
*scale
)
698 unsigned int item_len
= 2 * sizeof(unsigned int);
701 p
= kzalloc(item_len
+ 2 * sizeof(unsigned int), GFP_KERNEL
);
705 p
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
707 p
[2] = le32_to_cpu(scale
->min
);
708 p
[3] = (le32_to_cpu(scale
->step
) & TLV_DB_SCALE_MASK
)
709 | (le32_to_cpu(scale
->mute
) ? TLV_DB_SCALE_MUTE
: 0);
711 kc
->tlv
.p
= (void *)p
;
715 static int soc_tplg_create_tlv(struct soc_tplg
*tplg
,
716 struct snd_kcontrol_new
*kc
, struct snd_soc_tplg_ctl_hdr
*tc
)
718 struct snd_soc_tplg_ctl_tlv
*tplg_tlv
;
719 u32 access
= le32_to_cpu(tc
->access
);
721 if (!(access
& SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
))
724 if (!(access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
)) {
726 switch (le32_to_cpu(tplg_tlv
->type
)) {
727 case SNDRV_CTL_TLVT_DB_SCALE
:
728 return soc_tplg_create_tlv_db_scale(tplg
, kc
,
731 /* TODO: add support for other TLV types */
733 dev_dbg(tplg
->dev
, "Unsupported TLV type %d\n",
742 static inline void soc_tplg_free_tlv(struct soc_tplg
*tplg
,
743 struct snd_kcontrol_new
*kc
)
748 static int soc_tplg_dbytes_create(struct soc_tplg
*tplg
, unsigned int count
,
751 struct snd_soc_tplg_bytes_control
*be
;
752 struct soc_bytes_ext
*sbe
;
753 struct snd_kcontrol_new kc
;
756 if (soc_tplg_check_elem_count(tplg
,
757 sizeof(struct snd_soc_tplg_bytes_control
), count
,
758 size
, "mixer bytes")) {
759 dev_err(tplg
->dev
, "ASoC: Invalid count %d for byte control\n",
764 for (i
= 0; i
< count
; i
++) {
765 be
= (struct snd_soc_tplg_bytes_control
*)tplg
->pos
;
767 /* validate kcontrol */
768 if (strnlen(be
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
769 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
772 sbe
= kzalloc(sizeof(*sbe
), GFP_KERNEL
);
776 tplg
->pos
+= (sizeof(struct snd_soc_tplg_bytes_control
) +
777 le32_to_cpu(be
->priv
.size
));
780 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
781 be
->hdr
.name
, be
->hdr
.access
);
783 memset(&kc
, 0, sizeof(kc
));
784 kc
.name
= be
->hdr
.name
;
785 kc
.private_value
= (long)sbe
;
786 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
787 kc
.access
= le32_to_cpu(be
->hdr
.access
);
789 sbe
->max
= le32_to_cpu(be
->max
);
790 sbe
->dobj
.type
= SND_SOC_DOBJ_BYTES
;
791 sbe
->dobj
.ops
= tplg
->ops
;
792 INIT_LIST_HEAD(&sbe
->dobj
.list
);
794 /* map io handlers */
795 err
= soc_tplg_kcontrol_bind_io(&be
->hdr
, &kc
, tplg
);
797 soc_control_err(tplg
, &be
->hdr
, be
->hdr
.name
);
802 /* pass control to driver for optional further init */
803 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
804 (struct snd_soc_tplg_ctl_hdr
*)be
);
806 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
812 /* register control here */
813 err
= soc_tplg_add_kcontrol(tplg
, &kc
,
814 &sbe
->dobj
.control
.kcontrol
);
816 dev_err(tplg
->dev
, "ASoC: failed to add %s\n",
822 list_add(&sbe
->dobj
.list
, &tplg
->comp
->dobj_list
);
828 static int soc_tplg_dmixer_create(struct soc_tplg
*tplg
, unsigned int count
,
831 struct snd_soc_tplg_mixer_control
*mc
;
832 struct soc_mixer_control
*sm
;
833 struct snd_kcontrol_new kc
;
836 if (soc_tplg_check_elem_count(tplg
,
837 sizeof(struct snd_soc_tplg_mixer_control
),
838 count
, size
, "mixers")) {
840 dev_err(tplg
->dev
, "ASoC: invalid count %d for controls\n",
845 for (i
= 0; i
< count
; i
++) {
846 mc
= (struct snd_soc_tplg_mixer_control
*)tplg
->pos
;
848 /* validate kcontrol */
849 if (strnlen(mc
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
850 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
853 sm
= kzalloc(sizeof(*sm
), GFP_KERNEL
);
856 tplg
->pos
+= (sizeof(struct snd_soc_tplg_mixer_control
) +
857 le32_to_cpu(mc
->priv
.size
));
860 "ASoC: adding mixer kcontrol %s with access 0x%x\n",
861 mc
->hdr
.name
, mc
->hdr
.access
);
863 memset(&kc
, 0, sizeof(kc
));
864 kc
.name
= mc
->hdr
.name
;
865 kc
.private_value
= (long)sm
;
866 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
867 kc
.access
= le32_to_cpu(mc
->hdr
.access
);
869 /* we only support FL/FR channel mapping atm */
870 sm
->reg
= tplc_chan_get_reg(tplg
, mc
->channel
,
872 sm
->rreg
= tplc_chan_get_reg(tplg
, mc
->channel
,
874 sm
->shift
= tplc_chan_get_shift(tplg
, mc
->channel
,
876 sm
->rshift
= tplc_chan_get_shift(tplg
, mc
->channel
,
879 sm
->max
= le32_to_cpu(mc
->max
);
880 sm
->min
= le32_to_cpu(mc
->min
);
881 sm
->invert
= le32_to_cpu(mc
->invert
);
882 sm
->platform_max
= le32_to_cpu(mc
->platform_max
);
883 sm
->dobj
.index
= tplg
->index
;
884 sm
->dobj
.ops
= tplg
->ops
;
885 sm
->dobj
.type
= SND_SOC_DOBJ_MIXER
;
886 INIT_LIST_HEAD(&sm
->dobj
.list
);
888 /* map io handlers */
889 err
= soc_tplg_kcontrol_bind_io(&mc
->hdr
, &kc
, tplg
);
891 soc_control_err(tplg
, &mc
->hdr
, mc
->hdr
.name
);
896 /* create any TLV data */
897 err
= soc_tplg_create_tlv(tplg
, &kc
, &mc
->hdr
);
899 dev_err(tplg
->dev
, "ASoC: failed to create TLV %s\n",
905 /* pass control to driver for optional further init */
906 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
907 (struct snd_soc_tplg_ctl_hdr
*) mc
);
909 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
911 soc_tplg_free_tlv(tplg
, &kc
);
916 /* register control here */
917 err
= soc_tplg_add_kcontrol(tplg
, &kc
,
918 &sm
->dobj
.control
.kcontrol
);
920 dev_err(tplg
->dev
, "ASoC: failed to add %s\n",
922 soc_tplg_free_tlv(tplg
, &kc
);
927 list_add(&sm
->dobj
.list
, &tplg
->comp
->dobj_list
);
933 static int soc_tplg_denum_create_texts(struct soc_enum
*se
,
934 struct snd_soc_tplg_enum_control
*ec
)
938 se
->dobj
.control
.dtexts
=
939 kcalloc(le32_to_cpu(ec
->items
), sizeof(char *), GFP_KERNEL
);
940 if (se
->dobj
.control
.dtexts
== NULL
)
943 for (i
= 0; i
< le32_to_cpu(ec
->items
); i
++) {
945 if (strnlen(ec
->texts
[i
], SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
946 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
951 se
->dobj
.control
.dtexts
[i
] = kstrdup(ec
->texts
[i
], GFP_KERNEL
);
952 if (!se
->dobj
.control
.dtexts
[i
]) {
958 se
->items
= le32_to_cpu(ec
->items
);
959 se
->texts
= (const char * const *)se
->dobj
.control
.dtexts
;
964 soc_tplg_denum_remove_texts(se
);
968 static inline void soc_tplg_denum_remove_texts(struct soc_enum
*se
)
972 for (--i
; i
>= 0; i
--)
973 kfree(se
->dobj
.control
.dtexts
[i
]);
974 kfree(se
->dobj
.control
.dtexts
);
977 static int soc_tplg_denum_create_values(struct soc_enum
*se
,
978 struct snd_soc_tplg_enum_control
*ec
)
982 if (le32_to_cpu(ec
->items
) > sizeof(*ec
->values
))
985 se
->dobj
.control
.dvalues
= kzalloc(le32_to_cpu(ec
->items
) *
988 if (!se
->dobj
.control
.dvalues
)
991 /* convert from little-endian */
992 for (i
= 0; i
< le32_to_cpu(ec
->items
); i
++) {
993 se
->dobj
.control
.dvalues
[i
] = le32_to_cpu(ec
->values
[i
]);
999 static inline void soc_tplg_denum_remove_values(struct soc_enum
*se
)
1001 kfree(se
->dobj
.control
.dvalues
);
1004 static int soc_tplg_denum_create(struct soc_tplg
*tplg
, unsigned int count
,
1007 struct snd_soc_tplg_enum_control
*ec
;
1008 struct soc_enum
*se
;
1009 struct snd_kcontrol_new kc
;
1012 if (soc_tplg_check_elem_count(tplg
,
1013 sizeof(struct snd_soc_tplg_enum_control
),
1014 count
, size
, "enums")) {
1016 dev_err(tplg
->dev
, "ASoC: invalid count %d for enum controls\n",
1021 for (i
= 0; i
< count
; i
++) {
1022 ec
= (struct snd_soc_tplg_enum_control
*)tplg
->pos
;
1024 /* validate kcontrol */
1025 if (strnlen(ec
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1026 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1029 se
= kzalloc((sizeof(*se
)), GFP_KERNEL
);
1033 tplg
->pos
+= (sizeof(struct snd_soc_tplg_enum_control
) +
1034 le32_to_cpu(ec
->priv
.size
));
1036 dev_dbg(tplg
->dev
, "ASoC: adding enum kcontrol %s size %d\n",
1037 ec
->hdr
.name
, ec
->items
);
1039 memset(&kc
, 0, sizeof(kc
));
1040 kc
.name
= ec
->hdr
.name
;
1041 kc
.private_value
= (long)se
;
1042 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1043 kc
.access
= le32_to_cpu(ec
->hdr
.access
);
1045 se
->reg
= tplc_chan_get_reg(tplg
, ec
->channel
, SNDRV_CHMAP_FL
);
1046 se
->shift_l
= tplc_chan_get_shift(tplg
, ec
->channel
,
1048 se
->shift_r
= tplc_chan_get_shift(tplg
, ec
->channel
,
1051 se
->mask
= le32_to_cpu(ec
->mask
);
1052 se
->dobj
.index
= tplg
->index
;
1053 se
->dobj
.type
= SND_SOC_DOBJ_ENUM
;
1054 se
->dobj
.ops
= tplg
->ops
;
1055 INIT_LIST_HEAD(&se
->dobj
.list
);
1057 switch (le32_to_cpu(ec
->hdr
.ops
.info
)) {
1058 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1059 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1060 err
= soc_tplg_denum_create_values(se
, ec
);
1063 "ASoC: could not create values for %s\n",
1069 case SND_SOC_TPLG_CTL_ENUM
:
1070 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1071 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1072 err
= soc_tplg_denum_create_texts(se
, ec
);
1075 "ASoC: could not create texts for %s\n",
1083 "ASoC: invalid enum control type %d for %s\n",
1084 ec
->hdr
.ops
.info
, ec
->hdr
.name
);
1089 /* map io handlers */
1090 err
= soc_tplg_kcontrol_bind_io(&ec
->hdr
, &kc
, tplg
);
1092 soc_control_err(tplg
, &ec
->hdr
, ec
->hdr
.name
);
1097 /* pass control to driver for optional further init */
1098 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
1099 (struct snd_soc_tplg_ctl_hdr
*) ec
);
1101 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1107 /* register control here */
1108 ret
= soc_tplg_add_kcontrol(tplg
,
1109 &kc
, &se
->dobj
.control
.kcontrol
);
1111 dev_err(tplg
->dev
, "ASoC: could not add kcontrol %s\n",
1117 list_add(&se
->dobj
.list
, &tplg
->comp
->dobj_list
);
1123 static int soc_tplg_kcontrol_elems_load(struct soc_tplg
*tplg
,
1124 struct snd_soc_tplg_hdr
*hdr
)
1126 struct snd_soc_tplg_ctl_hdr
*control_hdr
;
1130 if (tplg
->pass
!= SOC_TPLG_PASS_MIXER
) {
1131 tplg
->pos
+= le32_to_cpu(hdr
->size
) +
1132 le32_to_cpu(hdr
->payload_size
);
1136 dev_dbg(tplg
->dev
, "ASoC: adding %d kcontrols at 0x%lx\n", hdr
->count
,
1137 soc_tplg_get_offset(tplg
));
1139 for (i
= 0; i
< le32_to_cpu(hdr
->count
); i
++) {
1141 control_hdr
= (struct snd_soc_tplg_ctl_hdr
*)tplg
->pos
;
1143 if (le32_to_cpu(control_hdr
->size
) != sizeof(*control_hdr
)) {
1144 dev_err(tplg
->dev
, "ASoC: invalid control size\n");
1148 switch (le32_to_cpu(control_hdr
->ops
.info
)) {
1149 case SND_SOC_TPLG_CTL_VOLSW
:
1150 case SND_SOC_TPLG_CTL_STROBE
:
1151 case SND_SOC_TPLG_CTL_VOLSW_SX
:
1152 case SND_SOC_TPLG_CTL_VOLSW_XR_SX
:
1153 case SND_SOC_TPLG_CTL_RANGE
:
1154 case SND_SOC_TPLG_DAPM_CTL_VOLSW
:
1155 case SND_SOC_TPLG_DAPM_CTL_PIN
:
1156 ret
= soc_tplg_dmixer_create(tplg
, 1,
1157 le32_to_cpu(hdr
->payload_size
));
1159 case SND_SOC_TPLG_CTL_ENUM
:
1160 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1161 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1162 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1163 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1164 ret
= soc_tplg_denum_create(tplg
, 1,
1165 le32_to_cpu(hdr
->payload_size
));
1167 case SND_SOC_TPLG_CTL_BYTES
:
1168 ret
= soc_tplg_dbytes_create(tplg
, 1,
1169 le32_to_cpu(hdr
->payload_size
));
1172 soc_bind_err(tplg
, control_hdr
, i
);
1176 dev_err(tplg
->dev
, "ASoC: invalid control\n");
1185 /* optionally pass new dynamic kcontrol to component driver. */
1186 static int soc_tplg_add_route(struct soc_tplg
*tplg
,
1187 struct snd_soc_dapm_route
*route
)
1189 if (tplg
->ops
&& tplg
->ops
->dapm_route_load
)
1190 return tplg
->ops
->dapm_route_load(tplg
->comp
, tplg
->index
,
1196 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg
*tplg
,
1197 struct snd_soc_tplg_hdr
*hdr
)
1199 struct snd_soc_dapm_context
*dapm
= &tplg
->comp
->dapm
;
1200 struct snd_soc_tplg_dapm_graph_elem
*elem
;
1201 struct snd_soc_dapm_route
**routes
;
1205 count
= le32_to_cpu(hdr
->count
);
1207 if (tplg
->pass
!= SOC_TPLG_PASS_GRAPH
) {
1209 le32_to_cpu(hdr
->size
) +
1210 le32_to_cpu(hdr
->payload_size
);
1215 if (soc_tplg_check_elem_count(tplg
,
1216 sizeof(struct snd_soc_tplg_dapm_graph_elem
),
1217 count
, le32_to_cpu(hdr
->payload_size
), "graph")) {
1219 dev_err(tplg
->dev
, "ASoC: invalid count %d for DAPM routes\n",
1224 dev_dbg(tplg
->dev
, "ASoC: adding %d DAPM routes for index %d\n", count
,
1227 /* allocate memory for pointer to array of dapm routes */
1228 routes
= kcalloc(count
, sizeof(struct snd_soc_dapm_route
*),
1234 * allocate memory for each dapm route in the array.
1235 * This needs to be done individually so that
1236 * each route can be freed when it is removed in remove_route().
1238 for (i
= 0; i
< count
; i
++) {
1239 routes
[i
] = kzalloc(sizeof(*routes
[i
]), GFP_KERNEL
);
1241 /* free previously allocated memory */
1242 for (j
= 0; j
< i
; j
++)
1250 for (i
= 0; i
< count
; i
++) {
1251 elem
= (struct snd_soc_tplg_dapm_graph_elem
*)tplg
->pos
;
1252 tplg
->pos
+= sizeof(struct snd_soc_tplg_dapm_graph_elem
);
1254 /* validate routes */
1255 if (strnlen(elem
->source
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1256 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1260 if (strnlen(elem
->sink
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1261 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1265 if (strnlen(elem
->control
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1266 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1271 routes
[i
]->source
= elem
->source
;
1272 routes
[i
]->sink
= elem
->sink
;
1274 /* set to NULL atm for tplg users */
1275 routes
[i
]->connected
= NULL
;
1276 if (strnlen(elem
->control
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) == 0)
1277 routes
[i
]->control
= NULL
;
1279 routes
[i
]->control
= elem
->control
;
1281 /* add route dobj to dobj_list */
1282 routes
[i
]->dobj
.type
= SND_SOC_DOBJ_GRAPH
;
1283 routes
[i
]->dobj
.ops
= tplg
->ops
;
1284 routes
[i
]->dobj
.index
= tplg
->index
;
1285 list_add(&routes
[i
]->dobj
.list
, &tplg
->comp
->dobj_list
);
1287 ret
= soc_tplg_add_route(tplg
, routes
[i
]);
1291 /* add route, but keep going if some fail */
1292 snd_soc_dapm_add_routes(dapm
, routes
[i
], 1);
1295 /* free memory allocated for all dapm routes in case of error */
1297 for (i
= 0; i
< count
; i
++)
1301 * free pointer to array of dapm routes as this is no longer needed.
1302 * The memory allocated for each dapm route will be freed
1303 * when it is removed in remove_route().
1310 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_dmixer_create(
1311 struct soc_tplg
*tplg
, int num_kcontrols
)
1313 struct snd_kcontrol_new
*kc
;
1314 struct soc_mixer_control
*sm
;
1315 struct snd_soc_tplg_mixer_control
*mc
;
1318 kc
= kcalloc(num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1322 for (i
= 0; i
< num_kcontrols
; i
++) {
1323 mc
= (struct snd_soc_tplg_mixer_control
*)tplg
->pos
;
1325 /* validate kcontrol */
1326 if (strnlen(mc
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1327 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1330 sm
= kzalloc(sizeof(*sm
), GFP_KERNEL
);
1334 tplg
->pos
+= (sizeof(struct snd_soc_tplg_mixer_control
) +
1335 le32_to_cpu(mc
->priv
.size
));
1337 dev_dbg(tplg
->dev
, " adding DAPM widget mixer control %s at %d\n",
1340 kc
[i
].private_value
= (long)sm
;
1341 kc
[i
].name
= kstrdup(mc
->hdr
.name
, GFP_KERNEL
);
1342 if (kc
[i
].name
== NULL
)
1344 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1345 kc
[i
].access
= le32_to_cpu(mc
->hdr
.access
);
1347 /* we only support FL/FR channel mapping atm */
1348 sm
->reg
= tplc_chan_get_reg(tplg
, mc
->channel
,
1350 sm
->rreg
= tplc_chan_get_reg(tplg
, mc
->channel
,
1352 sm
->shift
= tplc_chan_get_shift(tplg
, mc
->channel
,
1354 sm
->rshift
= tplc_chan_get_shift(tplg
, mc
->channel
,
1357 sm
->max
= le32_to_cpu(mc
->max
);
1358 sm
->min
= le32_to_cpu(mc
->min
);
1359 sm
->invert
= le32_to_cpu(mc
->invert
);
1360 sm
->platform_max
= le32_to_cpu(mc
->platform_max
);
1361 sm
->dobj
.index
= tplg
->index
;
1362 INIT_LIST_HEAD(&sm
->dobj
.list
);
1364 /* map io handlers */
1365 err
= soc_tplg_kcontrol_bind_io(&mc
->hdr
, &kc
[i
], tplg
);
1367 soc_control_err(tplg
, &mc
->hdr
, mc
->hdr
.name
);
1371 /* create any TLV data */
1372 err
= soc_tplg_create_tlv(tplg
, &kc
[i
], &mc
->hdr
);
1374 dev_err(tplg
->dev
, "ASoC: failed to create TLV %s\n",
1380 /* pass control to driver for optional further init */
1381 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1382 (struct snd_soc_tplg_ctl_hdr
*)mc
);
1384 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1386 soc_tplg_free_tlv(tplg
, &kc
[i
]);
1393 for (; i
>= 0; i
--) {
1394 sm
= (struct soc_mixer_control
*)kc
[i
].private_value
;
1403 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_denum_create(
1404 struct soc_tplg
*tplg
, int num_kcontrols
)
1406 struct snd_kcontrol_new
*kc
;
1407 struct snd_soc_tplg_enum_control
*ec
;
1408 struct soc_enum
*se
;
1411 kc
= kcalloc(num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1415 for (i
= 0; i
< num_kcontrols
; i
++) {
1416 ec
= (struct snd_soc_tplg_enum_control
*)tplg
->pos
;
1417 /* validate kcontrol */
1418 if (strnlen(ec
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1419 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1422 se
= kzalloc(sizeof(*se
), GFP_KERNEL
);
1426 tplg
->pos
+= (sizeof(struct snd_soc_tplg_enum_control
) +
1427 le32_to_cpu(ec
->priv
.size
));
1429 dev_dbg(tplg
->dev
, " adding DAPM widget enum control %s\n",
1432 kc
[i
].private_value
= (long)se
;
1433 kc
[i
].name
= kstrdup(ec
->hdr
.name
, GFP_KERNEL
);
1434 if (kc
[i
].name
== NULL
)
1436 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1437 kc
[i
].access
= le32_to_cpu(ec
->hdr
.access
);
1439 /* we only support FL/FR channel mapping atm */
1440 se
->reg
= tplc_chan_get_reg(tplg
, ec
->channel
, SNDRV_CHMAP_FL
);
1441 se
->shift_l
= tplc_chan_get_shift(tplg
, ec
->channel
,
1443 se
->shift_r
= tplc_chan_get_shift(tplg
, ec
->channel
,
1446 se
->items
= le32_to_cpu(ec
->items
);
1447 se
->mask
= le32_to_cpu(ec
->mask
);
1448 se
->dobj
.index
= tplg
->index
;
1450 switch (le32_to_cpu(ec
->hdr
.ops
.info
)) {
1451 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1452 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1453 err
= soc_tplg_denum_create_values(se
, ec
);
1455 dev_err(tplg
->dev
, "ASoC: could not create values for %s\n",
1460 case SND_SOC_TPLG_CTL_ENUM
:
1461 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1462 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1463 err
= soc_tplg_denum_create_texts(se
, ec
);
1465 dev_err(tplg
->dev
, "ASoC: could not create texts for %s\n",
1471 dev_err(tplg
->dev
, "ASoC: invalid enum control type %d for %s\n",
1472 ec
->hdr
.ops
.info
, ec
->hdr
.name
);
1476 /* map io handlers */
1477 err
= soc_tplg_kcontrol_bind_io(&ec
->hdr
, &kc
[i
], tplg
);
1479 soc_control_err(tplg
, &ec
->hdr
, ec
->hdr
.name
);
1483 /* pass control to driver for optional further init */
1484 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1485 (struct snd_soc_tplg_ctl_hdr
*)ec
);
1487 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1496 for (; i
>= 0; i
--) {
1497 /* free values and texts */
1498 se
= (struct soc_enum
*)kc
[i
].private_value
;
1501 soc_tplg_denum_remove_values(se
);
1502 soc_tplg_denum_remove_texts(se
);
1513 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_dbytes_create(
1514 struct soc_tplg
*tplg
, int num_kcontrols
)
1516 struct snd_soc_tplg_bytes_control
*be
;
1517 struct soc_bytes_ext
*sbe
;
1518 struct snd_kcontrol_new
*kc
;
1521 kc
= kcalloc(num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1525 for (i
= 0; i
< num_kcontrols
; i
++) {
1526 be
= (struct snd_soc_tplg_bytes_control
*)tplg
->pos
;
1528 /* validate kcontrol */
1529 if (strnlen(be
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1530 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1533 sbe
= kzalloc(sizeof(*sbe
), GFP_KERNEL
);
1537 tplg
->pos
+= (sizeof(struct snd_soc_tplg_bytes_control
) +
1538 le32_to_cpu(be
->priv
.size
));
1541 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1542 be
->hdr
.name
, be
->hdr
.access
);
1544 kc
[i
].private_value
= (long)sbe
;
1545 kc
[i
].name
= kstrdup(be
->hdr
.name
, GFP_KERNEL
);
1546 if (kc
[i
].name
== NULL
)
1548 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1549 kc
[i
].access
= le32_to_cpu(be
->hdr
.access
);
1551 sbe
->max
= le32_to_cpu(be
->max
);
1552 INIT_LIST_HEAD(&sbe
->dobj
.list
);
1554 /* map standard io handlers and check for external handlers */
1555 err
= soc_tplg_kcontrol_bind_io(&be
->hdr
, &kc
[i
], tplg
);
1557 soc_control_err(tplg
, &be
->hdr
, be
->hdr
.name
);
1561 /* pass control to driver for optional further init */
1562 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1563 (struct snd_soc_tplg_ctl_hdr
*)be
);
1565 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1574 for (; i
>= 0; i
--) {
1575 sbe
= (struct soc_bytes_ext
*)kc
[i
].private_value
;
1584 static int soc_tplg_dapm_widget_create(struct soc_tplg
*tplg
,
1585 struct snd_soc_tplg_dapm_widget
*w
)
1587 struct snd_soc_dapm_context
*dapm
= &tplg
->comp
->dapm
;
1588 struct snd_soc_dapm_widget
template, *widget
;
1589 struct snd_soc_tplg_ctl_hdr
*control_hdr
;
1590 struct snd_soc_card
*card
= tplg
->comp
->card
;
1591 unsigned int kcontrol_type
;
1594 if (strnlen(w
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1595 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1597 if (strnlen(w
->sname
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1598 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1601 dev_dbg(tplg
->dev
, "ASoC: creating DAPM widget %s id %d\n",
1604 memset(&template, 0, sizeof(template));
1606 /* map user to kernel widget ID */
1607 template.id
= get_widget_id(le32_to_cpu(w
->id
));
1608 if ((int)template.id
< 0)
1611 /* strings are allocated here, but used and freed by the widget */
1612 template.name
= kstrdup(w
->name
, GFP_KERNEL
);
1615 template.sname
= kstrdup(w
->sname
, GFP_KERNEL
);
1616 if (!template.sname
) {
1620 template.reg
= le32_to_cpu(w
->reg
);
1621 template.shift
= le32_to_cpu(w
->shift
);
1622 template.mask
= le32_to_cpu(w
->mask
);
1623 template.subseq
= le32_to_cpu(w
->subseq
);
1624 template.on_val
= w
->invert
? 0 : 1;
1625 template.off_val
= w
->invert
? 1 : 0;
1626 template.ignore_suspend
= le32_to_cpu(w
->ignore_suspend
);
1627 template.event_flags
= le16_to_cpu(w
->event_flags
);
1628 template.dobj
.index
= tplg
->index
;
1631 (sizeof(struct snd_soc_tplg_dapm_widget
) +
1632 le32_to_cpu(w
->priv
.size
));
1634 if (w
->num_kcontrols
== 0) {
1636 template.num_kcontrols
= 0;
1640 control_hdr
= (struct snd_soc_tplg_ctl_hdr
*)tplg
->pos
;
1641 dev_dbg(tplg
->dev
, "ASoC: template %s has %d controls of type %x\n",
1642 w
->name
, w
->num_kcontrols
, control_hdr
->type
);
1644 switch (le32_to_cpu(control_hdr
->ops
.info
)) {
1645 case SND_SOC_TPLG_CTL_VOLSW
:
1646 case SND_SOC_TPLG_CTL_STROBE
:
1647 case SND_SOC_TPLG_CTL_VOLSW_SX
:
1648 case SND_SOC_TPLG_CTL_VOLSW_XR_SX
:
1649 case SND_SOC_TPLG_CTL_RANGE
:
1650 case SND_SOC_TPLG_DAPM_CTL_VOLSW
:
1651 kcontrol_type
= SND_SOC_TPLG_TYPE_MIXER
; /* volume mixer */
1652 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1653 template.kcontrol_news
=
1654 soc_tplg_dapm_widget_dmixer_create(tplg
,
1655 template.num_kcontrols
);
1656 if (!template.kcontrol_news
) {
1661 case SND_SOC_TPLG_CTL_ENUM
:
1662 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1663 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1664 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1665 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1666 kcontrol_type
= SND_SOC_TPLG_TYPE_ENUM
; /* enumerated mixer */
1667 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1668 template.kcontrol_news
=
1669 soc_tplg_dapm_widget_denum_create(tplg
,
1670 template.num_kcontrols
);
1671 if (!template.kcontrol_news
) {
1676 case SND_SOC_TPLG_CTL_BYTES
:
1677 kcontrol_type
= SND_SOC_TPLG_TYPE_BYTES
; /* bytes control */
1678 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1679 template.kcontrol_news
=
1680 soc_tplg_dapm_widget_dbytes_create(tplg
,
1681 template.num_kcontrols
);
1682 if (!template.kcontrol_news
) {
1688 dev_err(tplg
->dev
, "ASoC: invalid widget control type %d:%d:%d\n",
1689 control_hdr
->ops
.get
, control_hdr
->ops
.put
,
1690 le32_to_cpu(control_hdr
->ops
.info
));
1696 ret
= soc_tplg_widget_load(tplg
, &template, w
);
1700 /* card dapm mutex is held by the core if we are loading topology
1701 * data during sound card init. */
1702 if (card
->instantiated
)
1703 widget
= snd_soc_dapm_new_control(dapm
, &template);
1705 widget
= snd_soc_dapm_new_control_unlocked(dapm
, &template);
1706 if (IS_ERR(widget
)) {
1707 ret
= PTR_ERR(widget
);
1711 widget
->dobj
.type
= SND_SOC_DOBJ_WIDGET
;
1712 widget
->dobj
.widget
.kcontrol_type
= kcontrol_type
;
1713 widget
->dobj
.ops
= tplg
->ops
;
1714 widget
->dobj
.index
= tplg
->index
;
1715 list_add(&widget
->dobj
.list
, &tplg
->comp
->dobj_list
);
1717 ret
= soc_tplg_widget_ready(tplg
, widget
, w
);
1721 kfree(template.sname
);
1722 kfree(template.name
);
1727 snd_soc_tplg_widget_remove(widget
);
1728 snd_soc_dapm_free_widget(widget
);
1730 kfree(template.sname
);
1732 kfree(template.name
);
1736 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg
*tplg
,
1737 struct snd_soc_tplg_hdr
*hdr
)
1739 struct snd_soc_tplg_dapm_widget
*widget
;
1742 count
= le32_to_cpu(hdr
->count
);
1744 if (tplg
->pass
!= SOC_TPLG_PASS_WIDGET
)
1747 dev_dbg(tplg
->dev
, "ASoC: adding %d DAPM widgets\n", count
);
1749 for (i
= 0; i
< count
; i
++) {
1750 widget
= (struct snd_soc_tplg_dapm_widget
*) tplg
->pos
;
1751 if (le32_to_cpu(widget
->size
) != sizeof(*widget
)) {
1752 dev_err(tplg
->dev
, "ASoC: invalid widget size\n");
1756 ret
= soc_tplg_dapm_widget_create(tplg
, widget
);
1758 dev_err(tplg
->dev
, "ASoC: failed to load widget %s\n",
1767 static int soc_tplg_dapm_complete(struct soc_tplg
*tplg
)
1769 struct snd_soc_card
*card
= tplg
->comp
->card
;
1772 /* Card might not have been registered at this point.
1773 * If so, just return success.
1775 if (!card
|| !card
->instantiated
) {
1776 dev_warn(tplg
->dev
, "ASoC: Parent card not yet available,"
1777 " widget card binding deferred\n");
1781 ret
= snd_soc_dapm_new_widgets(card
);
1783 dev_err(tplg
->dev
, "ASoC: failed to create new widgets %d\n",
1789 static int set_stream_info(struct snd_soc_pcm_stream
*stream
,
1790 struct snd_soc_tplg_stream_caps
*caps
)
1792 stream
->stream_name
= kstrdup(caps
->name
, GFP_KERNEL
);
1793 if (!stream
->stream_name
)
1796 stream
->channels_min
= le32_to_cpu(caps
->channels_min
);
1797 stream
->channels_max
= le32_to_cpu(caps
->channels_max
);
1798 stream
->rates
= le32_to_cpu(caps
->rates
);
1799 stream
->rate_min
= le32_to_cpu(caps
->rate_min
);
1800 stream
->rate_max
= le32_to_cpu(caps
->rate_max
);
1801 stream
->formats
= le64_to_cpu(caps
->formats
);
1802 stream
->sig_bits
= le32_to_cpu(caps
->sig_bits
);
1807 static void set_dai_flags(struct snd_soc_dai_driver
*dai_drv
,
1808 unsigned int flag_mask
, unsigned int flags
)
1810 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES
)
1811 dai_drv
->symmetric_rates
=
1812 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES
? 1 : 0;
1814 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS
)
1815 dai_drv
->symmetric_channels
=
1816 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS
?
1819 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS
)
1820 dai_drv
->symmetric_samplebits
=
1821 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS
?
1825 static int soc_tplg_dai_create(struct soc_tplg
*tplg
,
1826 struct snd_soc_tplg_pcm
*pcm
)
1828 struct snd_soc_dai_driver
*dai_drv
;
1829 struct snd_soc_pcm_stream
*stream
;
1830 struct snd_soc_tplg_stream_caps
*caps
;
1831 struct snd_soc_dai
*dai
;
1832 struct snd_soc_dapm_context
*dapm
=
1833 snd_soc_component_get_dapm(tplg
->comp
);
1836 dai_drv
= kzalloc(sizeof(struct snd_soc_dai_driver
), GFP_KERNEL
);
1837 if (dai_drv
== NULL
)
1840 if (strlen(pcm
->dai_name
)) {
1841 dai_drv
->name
= kstrdup(pcm
->dai_name
, GFP_KERNEL
);
1842 if (!dai_drv
->name
) {
1847 dai_drv
->id
= le32_to_cpu(pcm
->dai_id
);
1849 if (pcm
->playback
) {
1850 stream
= &dai_drv
->playback
;
1851 caps
= &pcm
->caps
[SND_SOC_TPLG_STREAM_PLAYBACK
];
1852 ret
= set_stream_info(stream
, caps
);
1858 stream
= &dai_drv
->capture
;
1859 caps
= &pcm
->caps
[SND_SOC_TPLG_STREAM_CAPTURE
];
1860 ret
= set_stream_info(stream
, caps
);
1866 dai_drv
->compress_new
= snd_soc_new_compress
;
1868 /* pass control to component driver for optional further init */
1869 ret
= soc_tplg_dai_load(tplg
, dai_drv
, pcm
, NULL
);
1871 dev_err(tplg
->comp
->dev
, "ASoC: DAI loading failed\n");
1875 dai_drv
->dobj
.index
= tplg
->index
;
1876 dai_drv
->dobj
.ops
= tplg
->ops
;
1877 dai_drv
->dobj
.type
= SND_SOC_DOBJ_PCM
;
1878 list_add(&dai_drv
->dobj
.list
, &tplg
->comp
->dobj_list
);
1880 /* register the DAI to the component */
1881 dai
= snd_soc_register_dai(tplg
->comp
, dai_drv
, false);
1885 /* Create the DAI widgets here */
1886 ret
= snd_soc_dapm_new_dai_widgets(dapm
, dai
);
1888 dev_err(dai
->dev
, "Failed to create DAI widgets %d\n", ret
);
1889 snd_soc_unregister_dai(dai
);
1896 kfree(dai_drv
->playback
.stream_name
);
1897 kfree(dai_drv
->capture
.stream_name
);
1898 kfree(dai_drv
->name
);
1904 static void set_link_flags(struct snd_soc_dai_link
*link
,
1905 unsigned int flag_mask
, unsigned int flags
)
1907 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES
)
1908 link
->symmetric_rates
=
1909 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES
? 1 : 0;
1911 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS
)
1912 link
->symmetric_channels
=
1913 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS
?
1916 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS
)
1917 link
->symmetric_samplebits
=
1918 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS
?
1921 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP
)
1922 link
->ignore_suspend
=
1923 flags
& SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP
?
1927 /* create the FE DAI link */
1928 static int soc_tplg_fe_link_create(struct soc_tplg
*tplg
,
1929 struct snd_soc_tplg_pcm
*pcm
)
1931 struct snd_soc_dai_link
*link
;
1932 struct snd_soc_dai_link_component
*dlc
;
1935 /* link + cpu + codec + platform */
1936 link
= kzalloc(sizeof(*link
) + (3 * sizeof(*dlc
)), GFP_KERNEL
);
1940 dlc
= (struct snd_soc_dai_link_component
*)(link
+ 1);
1942 link
->cpus
= &dlc
[0];
1943 link
->codecs
= &dlc
[1];
1944 link
->platforms
= &dlc
[2];
1947 link
->num_codecs
= 1;
1948 link
->num_platforms
= 1;
1950 link
->dobj
.index
= tplg
->index
;
1951 link
->dobj
.ops
= tplg
->ops
;
1952 link
->dobj
.type
= SND_SOC_DOBJ_DAI_LINK
;
1954 if (strlen(pcm
->pcm_name
)) {
1955 link
->name
= kstrdup(pcm
->pcm_name
, GFP_KERNEL
);
1956 link
->stream_name
= kstrdup(pcm
->pcm_name
, GFP_KERNEL
);
1957 if (!link
->name
|| !link
->stream_name
) {
1962 link
->id
= le32_to_cpu(pcm
->pcm_id
);
1964 if (strlen(pcm
->dai_name
)) {
1965 link
->cpus
->dai_name
= kstrdup(pcm
->dai_name
, GFP_KERNEL
);
1966 if (!link
->cpus
->dai_name
) {
1972 link
->codecs
->name
= "snd-soc-dummy";
1973 link
->codecs
->dai_name
= "snd-soc-dummy-dai";
1975 link
->platforms
->name
= "snd-soc-dummy";
1979 link
->dpcm_playback
= le32_to_cpu(pcm
->playback
);
1980 link
->dpcm_capture
= le32_to_cpu(pcm
->capture
);
1982 set_link_flags(link
,
1983 le32_to_cpu(pcm
->flag_mask
),
1984 le32_to_cpu(pcm
->flags
));
1986 /* pass control to component driver for optional further init */
1987 ret
= soc_tplg_dai_link_load(tplg
, link
, NULL
);
1989 dev_err(tplg
->comp
->dev
, "ASoC: FE link loading failed\n");
1993 ret
= snd_soc_add_pcm_runtime(tplg
->comp
->card
, link
);
1995 dev_err(tplg
->comp
->dev
, "ASoC: adding FE link failed\n");
1999 list_add(&link
->dobj
.list
, &tplg
->comp
->dobj_list
);
2004 kfree(link
->stream_name
);
2005 kfree(link
->cpus
->dai_name
);
2010 /* create a FE DAI and DAI link from the PCM object */
2011 static int soc_tplg_pcm_create(struct soc_tplg
*tplg
,
2012 struct snd_soc_tplg_pcm
*pcm
)
2016 ret
= soc_tplg_dai_create(tplg
, pcm
);
2020 return soc_tplg_fe_link_create(tplg
, pcm
);
2023 /* copy stream caps from the old version 4 of source */
2024 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps
*dest
,
2025 struct snd_soc_tplg_stream_caps_v4
*src
)
2027 dest
->size
= cpu_to_le32(sizeof(*dest
));
2028 memcpy(dest
->name
, src
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2029 dest
->formats
= src
->formats
;
2030 dest
->rates
= src
->rates
;
2031 dest
->rate_min
= src
->rate_min
;
2032 dest
->rate_max
= src
->rate_max
;
2033 dest
->channels_min
= src
->channels_min
;
2034 dest
->channels_max
= src
->channels_max
;
2035 dest
->periods_min
= src
->periods_min
;
2036 dest
->periods_max
= src
->periods_max
;
2037 dest
->period_size_min
= src
->period_size_min
;
2038 dest
->period_size_max
= src
->period_size_max
;
2039 dest
->buffer_size_min
= src
->buffer_size_min
;
2040 dest
->buffer_size_max
= src
->buffer_size_max
;
2044 * pcm_new_ver - Create the new version of PCM from the old version.
2045 * @tplg: topology context
2046 * @src: older version of pcm as a source
2047 * @pcm: latest version of pcm created from the source
2049 * Support from vesion 4. User should free the returned pcm manually.
2051 static int pcm_new_ver(struct soc_tplg
*tplg
,
2052 struct snd_soc_tplg_pcm
*src
,
2053 struct snd_soc_tplg_pcm
**pcm
)
2055 struct snd_soc_tplg_pcm
*dest
;
2056 struct snd_soc_tplg_pcm_v4
*src_v4
;
2061 if (le32_to_cpu(src
->size
) != sizeof(*src_v4
)) {
2062 dev_err(tplg
->dev
, "ASoC: invalid PCM size\n");
2066 dev_warn(tplg
->dev
, "ASoC: old version of PCM\n");
2067 src_v4
= (struct snd_soc_tplg_pcm_v4
*)src
;
2068 dest
= kzalloc(sizeof(*dest
), GFP_KERNEL
);
2072 dest
->size
= cpu_to_le32(sizeof(*dest
)); /* size of latest abi version */
2073 memcpy(dest
->pcm_name
, src_v4
->pcm_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2074 memcpy(dest
->dai_name
, src_v4
->dai_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2075 dest
->pcm_id
= src_v4
->pcm_id
;
2076 dest
->dai_id
= src_v4
->dai_id
;
2077 dest
->playback
= src_v4
->playback
;
2078 dest
->capture
= src_v4
->capture
;
2079 dest
->compress
= src_v4
->compress
;
2080 dest
->num_streams
= src_v4
->num_streams
;
2081 for (i
= 0; i
< le32_to_cpu(dest
->num_streams
); i
++)
2082 memcpy(&dest
->stream
[i
], &src_v4
->stream
[i
],
2083 sizeof(struct snd_soc_tplg_stream
));
2085 for (i
= 0; i
< 2; i
++)
2086 stream_caps_new_ver(&dest
->caps
[i
], &src_v4
->caps
[i
]);
2092 static int soc_tplg_pcm_elems_load(struct soc_tplg
*tplg
,
2093 struct snd_soc_tplg_hdr
*hdr
)
2095 struct snd_soc_tplg_pcm
*pcm
, *_pcm
;
2102 count
= le32_to_cpu(hdr
->count
);
2104 if (tplg
->pass
!= SOC_TPLG_PASS_PCM_DAI
)
2107 /* check the element size and count */
2108 pcm
= (struct snd_soc_tplg_pcm
*)tplg
->pos
;
2109 size
= le32_to_cpu(pcm
->size
);
2110 if (size
> sizeof(struct snd_soc_tplg_pcm
)
2111 || size
< sizeof(struct snd_soc_tplg_pcm_v4
)) {
2112 dev_err(tplg
->dev
, "ASoC: invalid size %d for PCM elems\n",
2117 if (soc_tplg_check_elem_count(tplg
,
2119 le32_to_cpu(hdr
->payload_size
),
2121 dev_err(tplg
->dev
, "ASoC: invalid count %d for PCM DAI elems\n",
2126 for (i
= 0; i
< count
; i
++) {
2127 pcm
= (struct snd_soc_tplg_pcm
*)tplg
->pos
;
2128 size
= le32_to_cpu(pcm
->size
);
2130 /* check ABI version by size, create a new version of pcm
2133 if (size
== sizeof(*pcm
)) {
2138 ret
= pcm_new_ver(tplg
, pcm
, &_pcm
);
2143 /* create the FE DAIs and DAI links */
2144 ret
= soc_tplg_pcm_create(tplg
, _pcm
);
2151 /* offset by version-specific struct size and
2152 * real priv data size
2154 tplg
->pos
+= size
+ le32_to_cpu(_pcm
->priv
.size
);
2157 kfree(_pcm
); /* free the duplicated one */
2160 dev_dbg(tplg
->dev
, "ASoC: adding %d PCM DAIs\n", count
);
2166 * set_link_hw_format - Set the HW audio format of the physical DAI link.
2167 * @link: &snd_soc_dai_link which should be updated
2168 * @cfg: physical link configs.
2170 * Topology context contains a list of supported HW formats (configs) and
2171 * a default format ID for the physical link. This function will use this
2172 * default ID to choose the HW format to set the link's DAI format for init.
2174 static void set_link_hw_format(struct snd_soc_dai_link
*link
,
2175 struct snd_soc_tplg_link_config
*cfg
)
2177 struct snd_soc_tplg_hw_config
*hw_config
;
2178 unsigned char bclk_master
, fsync_master
;
2179 unsigned char invert_bclk
, invert_fsync
;
2182 for (i
= 0; i
< le32_to_cpu(cfg
->num_hw_configs
); i
++) {
2183 hw_config
= &cfg
->hw_config
[i
];
2184 if (hw_config
->id
!= cfg
->default_hw_config_id
)
2187 link
->dai_fmt
= le32_to_cpu(hw_config
->fmt
) &
2188 SND_SOC_DAIFMT_FORMAT_MASK
;
2191 switch (hw_config
->clock_gated
) {
2192 case SND_SOC_TPLG_DAI_CLK_GATE_GATED
:
2193 link
->dai_fmt
|= SND_SOC_DAIFMT_GATED
;
2196 case SND_SOC_TPLG_DAI_CLK_GATE_CONT
:
2197 link
->dai_fmt
|= SND_SOC_DAIFMT_CONT
;
2201 /* ignore the value */
2205 /* clock signal polarity */
2206 invert_bclk
= hw_config
->invert_bclk
;
2207 invert_fsync
= hw_config
->invert_fsync
;
2208 if (!invert_bclk
&& !invert_fsync
)
2209 link
->dai_fmt
|= SND_SOC_DAIFMT_NB_NF
;
2210 else if (!invert_bclk
&& invert_fsync
)
2211 link
->dai_fmt
|= SND_SOC_DAIFMT_NB_IF
;
2212 else if (invert_bclk
&& !invert_fsync
)
2213 link
->dai_fmt
|= SND_SOC_DAIFMT_IB_NF
;
2215 link
->dai_fmt
|= SND_SOC_DAIFMT_IB_IF
;
2218 bclk_master
= (hw_config
->bclk_master
==
2219 SND_SOC_TPLG_BCLK_CM
);
2220 fsync_master
= (hw_config
->fsync_master
==
2221 SND_SOC_TPLG_FSYNC_CM
);
2222 if (bclk_master
&& fsync_master
)
2223 link
->dai_fmt
|= SND_SOC_DAIFMT_CBM_CFM
;
2224 else if (!bclk_master
&& fsync_master
)
2225 link
->dai_fmt
|= SND_SOC_DAIFMT_CBS_CFM
;
2226 else if (bclk_master
&& !fsync_master
)
2227 link
->dai_fmt
|= SND_SOC_DAIFMT_CBM_CFS
;
2229 link
->dai_fmt
|= SND_SOC_DAIFMT_CBS_CFS
;
2234 * link_new_ver - Create a new physical link config from the old
2235 * version of source.
2236 * @tplg: topology context
2237 * @src: old version of phyical link config as a source
2238 * @link: latest version of physical link config created from the source
2240 * Support from vesion 4. User need free the returned link config manually.
2242 static int link_new_ver(struct soc_tplg
*tplg
,
2243 struct snd_soc_tplg_link_config
*src
,
2244 struct snd_soc_tplg_link_config
**link
)
2246 struct snd_soc_tplg_link_config
*dest
;
2247 struct snd_soc_tplg_link_config_v4
*src_v4
;
2252 if (le32_to_cpu(src
->size
) !=
2253 sizeof(struct snd_soc_tplg_link_config_v4
)) {
2254 dev_err(tplg
->dev
, "ASoC: invalid physical link config size\n");
2258 dev_warn(tplg
->dev
, "ASoC: old version of physical link config\n");
2260 src_v4
= (struct snd_soc_tplg_link_config_v4
*)src
;
2261 dest
= kzalloc(sizeof(*dest
), GFP_KERNEL
);
2265 dest
->size
= cpu_to_le32(sizeof(*dest
));
2266 dest
->id
= src_v4
->id
;
2267 dest
->num_streams
= src_v4
->num_streams
;
2268 for (i
= 0; i
< le32_to_cpu(dest
->num_streams
); i
++)
2269 memcpy(&dest
->stream
[i
], &src_v4
->stream
[i
],
2270 sizeof(struct snd_soc_tplg_stream
));
2277 * snd_soc_find_dai_link - Find a DAI link
2280 * @id: DAI link ID to match
2281 * @name: DAI link name to match, optional
2282 * @stream_name: DAI link stream name to match, optional
2284 * This function will search all existing DAI links of the soc card to
2285 * find the link of the same ID. Since DAI links may not have their
2286 * unique ID, so name and stream name should also match if being
2289 * Return: pointer of DAI link, or NULL if not found.
2291 static struct snd_soc_dai_link
*snd_soc_find_dai_link(struct snd_soc_card
*card
,
2292 int id
, const char *name
,
2293 const char *stream_name
)
2295 struct snd_soc_pcm_runtime
*rtd
;
2296 struct snd_soc_dai_link
*link
;
2298 for_each_card_rtds(card
, rtd
) {
2299 link
= rtd
->dai_link
;
2304 if (name
&& (!link
->name
|| strcmp(name
, link
->name
)))
2307 if (stream_name
&& (!link
->stream_name
2308 || strcmp(stream_name
, link
->stream_name
)))
2317 /* Find and configure an existing physical DAI link */
2318 static int soc_tplg_link_config(struct soc_tplg
*tplg
,
2319 struct snd_soc_tplg_link_config
*cfg
)
2321 struct snd_soc_dai_link
*link
;
2322 const char *name
, *stream_name
;
2326 len
= strnlen(cfg
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2327 if (len
== SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
2334 len
= strnlen(cfg
->stream_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2335 if (len
== SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
2338 stream_name
= cfg
->stream_name
;
2342 link
= snd_soc_find_dai_link(tplg
->comp
->card
, le32_to_cpu(cfg
->id
),
2345 dev_err(tplg
->dev
, "ASoC: physical link %s (id %d) not exist\n",
2351 if (cfg
->num_hw_configs
)
2352 set_link_hw_format(link
, cfg
);
2356 set_link_flags(link
,
2357 le32_to_cpu(cfg
->flag_mask
),
2358 le32_to_cpu(cfg
->flags
));
2360 /* pass control to component driver for optional further init */
2361 ret
= soc_tplg_dai_link_load(tplg
, link
, cfg
);
2363 dev_err(tplg
->dev
, "ASoC: physical link loading failed\n");
2367 /* for unloading it in snd_soc_tplg_component_remove */
2368 link
->dobj
.index
= tplg
->index
;
2369 link
->dobj
.ops
= tplg
->ops
;
2370 link
->dobj
.type
= SND_SOC_DOBJ_BACKEND_LINK
;
2371 list_add(&link
->dobj
.list
, &tplg
->comp
->dobj_list
);
2377 /* Load physical link config elements from the topology context */
2378 static int soc_tplg_link_elems_load(struct soc_tplg
*tplg
,
2379 struct snd_soc_tplg_hdr
*hdr
)
2381 struct snd_soc_tplg_link_config
*link
, *_link
;
2387 count
= le32_to_cpu(hdr
->count
);
2389 if (tplg
->pass
!= SOC_TPLG_PASS_LINK
) {
2390 tplg
->pos
+= le32_to_cpu(hdr
->size
) +
2391 le32_to_cpu(hdr
->payload_size
);
2395 /* check the element size and count */
2396 link
= (struct snd_soc_tplg_link_config
*)tplg
->pos
;
2397 size
= le32_to_cpu(link
->size
);
2398 if (size
> sizeof(struct snd_soc_tplg_link_config
)
2399 || size
< sizeof(struct snd_soc_tplg_link_config_v4
)) {
2400 dev_err(tplg
->dev
, "ASoC: invalid size %d for physical link elems\n",
2405 if (soc_tplg_check_elem_count(tplg
,
2407 le32_to_cpu(hdr
->payload_size
),
2408 "physical link config")) {
2409 dev_err(tplg
->dev
, "ASoC: invalid count %d for physical link elems\n",
2414 /* config physical DAI links */
2415 for (i
= 0; i
< count
; i
++) {
2416 link
= (struct snd_soc_tplg_link_config
*)tplg
->pos
;
2417 size
= le32_to_cpu(link
->size
);
2418 if (size
== sizeof(*link
)) {
2423 ret
= link_new_ver(tplg
, link
, &_link
);
2428 ret
= soc_tplg_link_config(tplg
, _link
);
2435 /* offset by version-specific struct size and
2436 * real priv data size
2438 tplg
->pos
+= size
+ le32_to_cpu(_link
->priv
.size
);
2441 kfree(_link
); /* free the duplicated one */
2448 * soc_tplg_dai_config - Find and configure an existing physical DAI.
2449 * @tplg: topology context
2450 * @d: physical DAI configs.
2452 * The physical dai should already be registered by the platform driver.
2453 * The platform driver should specify the DAI name and ID for matching.
2455 static int soc_tplg_dai_config(struct soc_tplg
*tplg
,
2456 struct snd_soc_tplg_dai
*d
)
2458 struct snd_soc_dai_link_component dai_component
;
2459 struct snd_soc_dai
*dai
;
2460 struct snd_soc_dai_driver
*dai_drv
;
2461 struct snd_soc_pcm_stream
*stream
;
2462 struct snd_soc_tplg_stream_caps
*caps
;
2465 memset(&dai_component
, 0, sizeof(dai_component
));
2467 dai_component
.dai_name
= d
->dai_name
;
2468 dai
= snd_soc_find_dai(&dai_component
);
2470 dev_err(tplg
->dev
, "ASoC: physical DAI %s not registered\n",
2475 if (le32_to_cpu(d
->dai_id
) != dai
->id
) {
2476 dev_err(tplg
->dev
, "ASoC: physical DAI %s id mismatch\n",
2481 dai_drv
= dai
->driver
;
2486 stream
= &dai_drv
->playback
;
2487 caps
= &d
->caps
[SND_SOC_TPLG_STREAM_PLAYBACK
];
2488 ret
= set_stream_info(stream
, caps
);
2494 stream
= &dai_drv
->capture
;
2495 caps
= &d
->caps
[SND_SOC_TPLG_STREAM_CAPTURE
];
2496 ret
= set_stream_info(stream
, caps
);
2502 set_dai_flags(dai_drv
,
2503 le32_to_cpu(d
->flag_mask
),
2504 le32_to_cpu(d
->flags
));
2506 /* pass control to component driver for optional further init */
2507 ret
= soc_tplg_dai_load(tplg
, dai_drv
, NULL
, dai
);
2509 dev_err(tplg
->comp
->dev
, "ASoC: DAI loading failed\n");
2516 kfree(dai_drv
->playback
.stream_name
);
2517 kfree(dai_drv
->capture
.stream_name
);
2521 /* load physical DAI elements */
2522 static int soc_tplg_dai_elems_load(struct soc_tplg
*tplg
,
2523 struct snd_soc_tplg_hdr
*hdr
)
2525 struct snd_soc_tplg_dai
*dai
;
2529 count
= le32_to_cpu(hdr
->count
);
2531 if (tplg
->pass
!= SOC_TPLG_PASS_BE_DAI
)
2534 /* config the existing BE DAIs */
2535 for (i
= 0; i
< count
; i
++) {
2536 dai
= (struct snd_soc_tplg_dai
*)tplg
->pos
;
2537 if (le32_to_cpu(dai
->size
) != sizeof(*dai
)) {
2538 dev_err(tplg
->dev
, "ASoC: invalid physical DAI size\n");
2542 ret
= soc_tplg_dai_config(tplg
, dai
);
2544 dev_err(tplg
->dev
, "ASoC: failed to configure DAI\n");
2548 tplg
->pos
+= (sizeof(*dai
) + le32_to_cpu(dai
->priv
.size
));
2551 dev_dbg(tplg
->dev
, "ASoC: Configure %d BE DAIs\n", count
);
2556 * manifest_new_ver - Create a new version of manifest from the old version
2558 * @tplg: topology context
2559 * @src: old version of manifest as a source
2560 * @manifest: latest version of manifest created from the source
2562 * Support from vesion 4. Users need free the returned manifest manually.
2564 static int manifest_new_ver(struct soc_tplg
*tplg
,
2565 struct snd_soc_tplg_manifest
*src
,
2566 struct snd_soc_tplg_manifest
**manifest
)
2568 struct snd_soc_tplg_manifest
*dest
;
2569 struct snd_soc_tplg_manifest_v4
*src_v4
;
2574 size
= le32_to_cpu(src
->size
);
2575 if (size
!= sizeof(*src_v4
)) {
2576 dev_warn(tplg
->dev
, "ASoC: invalid manifest size %d\n",
2580 src
->size
= cpu_to_le32(sizeof(*src_v4
));
2583 dev_warn(tplg
->dev
, "ASoC: old version of manifest\n");
2585 src_v4
= (struct snd_soc_tplg_manifest_v4
*)src
;
2586 dest
= kzalloc(sizeof(*dest
) + le32_to_cpu(src_v4
->priv
.size
),
2591 dest
->size
= cpu_to_le32(sizeof(*dest
)); /* size of latest abi version */
2592 dest
->control_elems
= src_v4
->control_elems
;
2593 dest
->widget_elems
= src_v4
->widget_elems
;
2594 dest
->graph_elems
= src_v4
->graph_elems
;
2595 dest
->pcm_elems
= src_v4
->pcm_elems
;
2596 dest
->dai_link_elems
= src_v4
->dai_link_elems
;
2597 dest
->priv
.size
= src_v4
->priv
.size
;
2598 if (dest
->priv
.size
)
2599 memcpy(dest
->priv
.data
, src_v4
->priv
.data
,
2600 le32_to_cpu(src_v4
->priv
.size
));
2606 static int soc_tplg_manifest_load(struct soc_tplg
*tplg
,
2607 struct snd_soc_tplg_hdr
*hdr
)
2609 struct snd_soc_tplg_manifest
*manifest
, *_manifest
;
2613 if (tplg
->pass
!= SOC_TPLG_PASS_MANIFEST
)
2616 manifest
= (struct snd_soc_tplg_manifest
*)tplg
->pos
;
2618 /* check ABI version by size, create a new manifest if abi not match */
2619 if (le32_to_cpu(manifest
->size
) == sizeof(*manifest
)) {
2621 _manifest
= manifest
;
2624 ret
= manifest_new_ver(tplg
, manifest
, &_manifest
);
2629 /* pass control to component driver for optional further init */
2630 if (tplg
->ops
&& tplg
->ops
->manifest
)
2631 ret
= tplg
->ops
->manifest(tplg
->comp
, tplg
->index
, _manifest
);
2633 if (!abi_match
) /* free the duplicated one */
2639 /* validate header magic, size and type */
2640 static int soc_valid_header(struct soc_tplg
*tplg
,
2641 struct snd_soc_tplg_hdr
*hdr
)
2643 if (soc_tplg_get_hdr_offset(tplg
) >= tplg
->fw
->size
)
2646 if (le32_to_cpu(hdr
->size
) != sizeof(*hdr
)) {
2648 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n",
2649 le32_to_cpu(hdr
->type
), soc_tplg_get_hdr_offset(tplg
),
2654 /* big endian firmware objects not supported atm */
2655 if (le32_to_cpu(hdr
->magic
) == SOC_TPLG_MAGIC_BIG_ENDIAN
) {
2657 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n",
2658 tplg
->pass
, hdr
->magic
,
2659 soc_tplg_get_hdr_offset(tplg
), tplg
->fw
->size
);
2663 if (le32_to_cpu(hdr
->magic
) != SND_SOC_TPLG_MAGIC
) {
2665 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n",
2666 tplg
->pass
, hdr
->magic
,
2667 soc_tplg_get_hdr_offset(tplg
), tplg
->fw
->size
);
2671 /* Support ABI from version 4 */
2672 if (le32_to_cpu(hdr
->abi
) > SND_SOC_TPLG_ABI_VERSION
||
2673 le32_to_cpu(hdr
->abi
) < SND_SOC_TPLG_ABI_VERSION_MIN
) {
2675 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n",
2676 tplg
->pass
, hdr
->abi
,
2677 SND_SOC_TPLG_ABI_VERSION
, soc_tplg_get_hdr_offset(tplg
),
2682 if (hdr
->payload_size
== 0) {
2683 dev_err(tplg
->dev
, "ASoC: header has 0 size at offset 0x%lx.\n",
2684 soc_tplg_get_hdr_offset(tplg
));
2688 if (tplg
->pass
== le32_to_cpu(hdr
->type
))
2690 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n",
2691 hdr
->payload_size
, hdr
->type
, hdr
->version
,
2692 hdr
->vendor_type
, tplg
->pass
);
2697 /* check header type and call appropriate handler */
2698 static int soc_tplg_load_header(struct soc_tplg
*tplg
,
2699 struct snd_soc_tplg_hdr
*hdr
)
2701 tplg
->pos
= tplg
->hdr_pos
+ sizeof(struct snd_soc_tplg_hdr
);
2703 /* check for matching ID */
2704 if (le32_to_cpu(hdr
->index
) != tplg
->req_index
&&
2705 tplg
->req_index
!= SND_SOC_TPLG_INDEX_ALL
)
2708 tplg
->index
= le32_to_cpu(hdr
->index
);
2710 switch (le32_to_cpu(hdr
->type
)) {
2711 case SND_SOC_TPLG_TYPE_MIXER
:
2712 case SND_SOC_TPLG_TYPE_ENUM
:
2713 case SND_SOC_TPLG_TYPE_BYTES
:
2714 return soc_tplg_kcontrol_elems_load(tplg
, hdr
);
2715 case SND_SOC_TPLG_TYPE_DAPM_GRAPH
:
2716 return soc_tplg_dapm_graph_elems_load(tplg
, hdr
);
2717 case SND_SOC_TPLG_TYPE_DAPM_WIDGET
:
2718 return soc_tplg_dapm_widget_elems_load(tplg
, hdr
);
2719 case SND_SOC_TPLG_TYPE_PCM
:
2720 return soc_tplg_pcm_elems_load(tplg
, hdr
);
2721 case SND_SOC_TPLG_TYPE_DAI
:
2722 return soc_tplg_dai_elems_load(tplg
, hdr
);
2723 case SND_SOC_TPLG_TYPE_DAI_LINK
:
2724 case SND_SOC_TPLG_TYPE_BACKEND_LINK
:
2725 /* physical link configurations */
2726 return soc_tplg_link_elems_load(tplg
, hdr
);
2727 case SND_SOC_TPLG_TYPE_MANIFEST
:
2728 return soc_tplg_manifest_load(tplg
, hdr
);
2730 /* bespoke vendor data object */
2731 return soc_tplg_vendor_load(tplg
, hdr
);
2737 /* process the topology file headers */
2738 static int soc_tplg_process_headers(struct soc_tplg
*tplg
)
2740 struct snd_soc_tplg_hdr
*hdr
;
2743 tplg
->pass
= SOC_TPLG_PASS_START
;
2745 /* process the header types from start to end */
2746 while (tplg
->pass
<= SOC_TPLG_PASS_END
) {
2748 tplg
->hdr_pos
= tplg
->fw
->data
;
2749 hdr
= (struct snd_soc_tplg_hdr
*)tplg
->hdr_pos
;
2751 while (!soc_tplg_is_eof(tplg
)) {
2753 /* make sure header is valid before loading */
2754 ret
= soc_valid_header(tplg
, hdr
);
2760 /* load the header object */
2761 ret
= soc_tplg_load_header(tplg
, hdr
);
2765 /* goto next header */
2766 tplg
->hdr_pos
+= le32_to_cpu(hdr
->payload_size
) +
2767 sizeof(struct snd_soc_tplg_hdr
);
2768 hdr
= (struct snd_soc_tplg_hdr
*)tplg
->hdr_pos
;
2771 /* next data type pass */
2775 /* signal DAPM we are complete */
2776 ret
= soc_tplg_dapm_complete(tplg
);
2779 "ASoC: failed to initialise DAPM from Firmware\n");
2784 static int soc_tplg_load(struct soc_tplg
*tplg
)
2788 ret
= soc_tplg_process_headers(tplg
);
2790 soc_tplg_complete(tplg
);
2795 /* load audio component topology from "firmware" file */
2796 int snd_soc_tplg_component_load(struct snd_soc_component
*comp
,
2797 struct snd_soc_tplg_ops
*ops
, const struct firmware
*fw
, u32 id
)
2799 struct soc_tplg tplg
;
2802 /* component needs to exist to keep and reference data while parsing */
2806 /* setup parsing context */
2807 memset(&tplg
, 0, sizeof(tplg
));
2809 tplg
.dev
= comp
->dev
;
2812 tplg
.req_index
= id
;
2813 tplg
.io_ops
= ops
->io_ops
;
2814 tplg
.io_ops_count
= ops
->io_ops_count
;
2815 tplg
.bytes_ext_ops
= ops
->bytes_ext_ops
;
2816 tplg
.bytes_ext_ops_count
= ops
->bytes_ext_ops_count
;
2818 ret
= soc_tplg_load(&tplg
);
2819 /* free the created components if fail to load topology */
2821 snd_soc_tplg_component_remove(comp
, SND_SOC_TPLG_INDEX_ALL
);
2825 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load
);
2827 /* remove this dynamic widget */
2828 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget
*w
)
2830 /* make sure we are a widget */
2831 if (w
->dobj
.type
!= SND_SOC_DOBJ_WIDGET
)
2834 remove_widget(w
->dapm
->component
, &w
->dobj
, SOC_TPLG_PASS_WIDGET
);
2836 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove
);
2838 /* remove all dynamic widgets from this DAPM context */
2839 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context
*dapm
,
2842 struct snd_soc_dapm_widget
*w
, *next_w
;
2844 for_each_card_widgets_safe(dapm
->card
, w
, next_w
) {
2846 /* make sure we are a widget with correct context */
2847 if (w
->dobj
.type
!= SND_SOC_DOBJ_WIDGET
|| w
->dapm
!= dapm
)
2851 if (w
->dobj
.index
!= index
&&
2852 w
->dobj
.index
!= SND_SOC_TPLG_INDEX_ALL
)
2854 /* check and free and dynamic widget kcontrols */
2855 snd_soc_tplg_widget_remove(w
);
2856 snd_soc_dapm_free_widget(w
);
2858 snd_soc_dapm_reset_cache(dapm
);
2860 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all
);
2862 /* remove dynamic controls from the component driver */
2863 int snd_soc_tplg_component_remove(struct snd_soc_component
*comp
, u32 index
)
2865 struct snd_soc_dobj
*dobj
, *next_dobj
;
2866 int pass
= SOC_TPLG_PASS_END
;
2868 /* process the header types from end to start */
2869 while (pass
>= SOC_TPLG_PASS_START
) {
2871 /* remove mixer controls */
2872 list_for_each_entry_safe(dobj
, next_dobj
, &comp
->dobj_list
,
2876 if (dobj
->index
!= index
&&
2877 index
!= SND_SOC_TPLG_INDEX_ALL
)
2880 switch (dobj
->type
) {
2881 case SND_SOC_DOBJ_MIXER
:
2882 remove_mixer(comp
, dobj
, pass
);
2884 case SND_SOC_DOBJ_ENUM
:
2885 remove_enum(comp
, dobj
, pass
);
2887 case SND_SOC_DOBJ_BYTES
:
2888 remove_bytes(comp
, dobj
, pass
);
2890 case SND_SOC_DOBJ_GRAPH
:
2891 remove_route(comp
, dobj
, pass
);
2893 case SND_SOC_DOBJ_WIDGET
:
2894 remove_widget(comp
, dobj
, pass
);
2896 case SND_SOC_DOBJ_PCM
:
2897 remove_dai(comp
, dobj
, pass
);
2899 case SND_SOC_DOBJ_DAI_LINK
:
2900 remove_link(comp
, dobj
, pass
);
2902 case SND_SOC_DOBJ_BACKEND_LINK
:
2904 * call link_unload ops if extra
2905 * deinitialization is needed.
2907 remove_backend_link(comp
, dobj
, pass
);
2910 dev_err(comp
->dev
, "ASoC: invalid component type %d for removal\n",
2918 /* let caller know if FW can be freed when no objects are left */
2919 return !list_empty(&comp
->dobj_list
);
2921 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove
);