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 */
68 /* vendor specific kcontrol operations */
69 const struct snd_soc_tplg_kcontrol_ops
*io_ops
;
72 /* vendor specific bytes ext handlers, for TLV bytes controls */
73 const struct snd_soc_tplg_bytes_ext_ops
*bytes_ext_ops
;
74 int bytes_ext_ops_count
;
76 /* optional fw loading callbacks to component drivers */
77 struct snd_soc_tplg_ops
*ops
;
80 static int soc_tplg_process_headers(struct soc_tplg
*tplg
);
81 static void soc_tplg_complete(struct soc_tplg
*tplg
);
83 /* check we dont overflow the data for this control chunk */
84 static int soc_tplg_check_elem_count(struct soc_tplg
*tplg
, size_t elem_size
,
85 unsigned int count
, size_t bytes
, const char *elem_type
)
87 const u8
*end
= tplg
->pos
+ elem_size
* count
;
89 if (end
> tplg
->fw
->data
+ tplg
->fw
->size
) {
90 dev_err(tplg
->dev
, "ASoC: %s overflow end of data\n",
95 /* check there is enough room in chunk for control.
96 extra bytes at the end of control are for vendor data here */
97 if (elem_size
* count
> bytes
) {
99 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
100 elem_type
, count
, elem_size
, bytes
);
107 static inline int soc_tplg_is_eof(struct soc_tplg
*tplg
)
109 const u8
*end
= tplg
->hdr_pos
;
111 if (end
>= tplg
->fw
->data
+ tplg
->fw
->size
)
116 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg
*tplg
)
118 return (unsigned long)(tplg
->hdr_pos
- tplg
->fw
->data
);
121 static inline unsigned long soc_tplg_get_offset(struct soc_tplg
*tplg
)
123 return (unsigned long)(tplg
->pos
- tplg
->fw
->data
);
126 /* mapping of Kcontrol types and associated operations. */
127 static const struct snd_soc_tplg_kcontrol_ops io_ops
[] = {
128 {SND_SOC_TPLG_CTL_VOLSW
, snd_soc_get_volsw
,
129 snd_soc_put_volsw
, snd_soc_info_volsw
},
130 {SND_SOC_TPLG_CTL_VOLSW_SX
, snd_soc_get_volsw_sx
,
131 snd_soc_put_volsw_sx
, NULL
},
132 {SND_SOC_TPLG_CTL_ENUM
, snd_soc_get_enum_double
,
133 snd_soc_put_enum_double
, snd_soc_info_enum_double
},
134 {SND_SOC_TPLG_CTL_ENUM_VALUE
, snd_soc_get_enum_double
,
135 snd_soc_put_enum_double
, NULL
},
136 {SND_SOC_TPLG_CTL_BYTES
, snd_soc_bytes_get
,
137 snd_soc_bytes_put
, snd_soc_bytes_info
},
138 {SND_SOC_TPLG_CTL_RANGE
, snd_soc_get_volsw_range
,
139 snd_soc_put_volsw_range
, snd_soc_info_volsw_range
},
140 {SND_SOC_TPLG_CTL_VOLSW_XR_SX
, snd_soc_get_xr_sx
,
141 snd_soc_put_xr_sx
, snd_soc_info_xr_sx
},
142 {SND_SOC_TPLG_CTL_STROBE
, snd_soc_get_strobe
,
143 snd_soc_put_strobe
, NULL
},
144 {SND_SOC_TPLG_DAPM_CTL_VOLSW
, snd_soc_dapm_get_volsw
,
145 snd_soc_dapm_put_volsw
, snd_soc_info_volsw
},
146 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
, snd_soc_dapm_get_enum_double
,
147 snd_soc_dapm_put_enum_double
, snd_soc_info_enum_double
},
148 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
, snd_soc_dapm_get_enum_double
,
149 snd_soc_dapm_put_enum_double
, NULL
},
150 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
, snd_soc_dapm_get_enum_double
,
151 snd_soc_dapm_put_enum_double
, NULL
},
152 {SND_SOC_TPLG_DAPM_CTL_PIN
, snd_soc_dapm_get_pin_switch
,
153 snd_soc_dapm_put_pin_switch
, snd_soc_dapm_info_pin_switch
},
156 struct soc_tplg_map
{
161 /* mapping of widget types from UAPI IDs to kernel IDs */
162 static const struct soc_tplg_map dapm_map
[] = {
163 {SND_SOC_TPLG_DAPM_INPUT
, snd_soc_dapm_input
},
164 {SND_SOC_TPLG_DAPM_OUTPUT
, snd_soc_dapm_output
},
165 {SND_SOC_TPLG_DAPM_MUX
, snd_soc_dapm_mux
},
166 {SND_SOC_TPLG_DAPM_MIXER
, snd_soc_dapm_mixer
},
167 {SND_SOC_TPLG_DAPM_PGA
, snd_soc_dapm_pga
},
168 {SND_SOC_TPLG_DAPM_OUT_DRV
, snd_soc_dapm_out_drv
},
169 {SND_SOC_TPLG_DAPM_ADC
, snd_soc_dapm_adc
},
170 {SND_SOC_TPLG_DAPM_DAC
, snd_soc_dapm_dac
},
171 {SND_SOC_TPLG_DAPM_SWITCH
, snd_soc_dapm_switch
},
172 {SND_SOC_TPLG_DAPM_PRE
, snd_soc_dapm_pre
},
173 {SND_SOC_TPLG_DAPM_POST
, snd_soc_dapm_post
},
174 {SND_SOC_TPLG_DAPM_AIF_IN
, snd_soc_dapm_aif_in
},
175 {SND_SOC_TPLG_DAPM_AIF_OUT
, snd_soc_dapm_aif_out
},
176 {SND_SOC_TPLG_DAPM_DAI_IN
, snd_soc_dapm_dai_in
},
177 {SND_SOC_TPLG_DAPM_DAI_OUT
, snd_soc_dapm_dai_out
},
178 {SND_SOC_TPLG_DAPM_DAI_LINK
, snd_soc_dapm_dai_link
},
179 {SND_SOC_TPLG_DAPM_BUFFER
, snd_soc_dapm_buffer
},
180 {SND_SOC_TPLG_DAPM_SCHEDULER
, snd_soc_dapm_scheduler
},
181 {SND_SOC_TPLG_DAPM_EFFECT
, snd_soc_dapm_effect
},
182 {SND_SOC_TPLG_DAPM_SIGGEN
, snd_soc_dapm_siggen
},
183 {SND_SOC_TPLG_DAPM_SRC
, snd_soc_dapm_src
},
184 {SND_SOC_TPLG_DAPM_ASRC
, snd_soc_dapm_asrc
},
185 {SND_SOC_TPLG_DAPM_ENCODER
, snd_soc_dapm_encoder
},
186 {SND_SOC_TPLG_DAPM_DECODER
, snd_soc_dapm_decoder
},
189 static int tplc_chan_get_reg(struct soc_tplg
*tplg
,
190 struct snd_soc_tplg_channel
*chan
, int map
)
194 for (i
= 0; i
< SND_SOC_TPLG_MAX_CHAN
; i
++) {
195 if (le32_to_cpu(chan
[i
].id
) == map
)
196 return le32_to_cpu(chan
[i
].reg
);
202 static int tplc_chan_get_shift(struct soc_tplg
*tplg
,
203 struct snd_soc_tplg_channel
*chan
, int map
)
207 for (i
= 0; i
< SND_SOC_TPLG_MAX_CHAN
; i
++) {
208 if (le32_to_cpu(chan
[i
].id
) == map
)
209 return le32_to_cpu(chan
[i
].shift
);
215 static int get_widget_id(int tplg_type
)
219 for (i
= 0; i
< ARRAY_SIZE(dapm_map
); i
++) {
220 if (tplg_type
== dapm_map
[i
].uid
)
221 return dapm_map
[i
].kid
;
227 static inline void soc_bind_err(struct soc_tplg
*tplg
,
228 struct snd_soc_tplg_ctl_hdr
*hdr
, int index
)
231 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n",
232 hdr
->ops
.get
, hdr
->ops
.put
, hdr
->ops
.info
, index
,
233 soc_tplg_get_offset(tplg
));
236 static inline void soc_control_err(struct soc_tplg
*tplg
,
237 struct snd_soc_tplg_ctl_hdr
*hdr
, const char *name
)
240 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n",
241 name
, hdr
->ops
.get
, hdr
->ops
.put
, hdr
->ops
.info
,
242 soc_tplg_get_offset(tplg
));
245 /* pass vendor data to component driver for processing */
246 static int soc_tplg_vendor_load(struct soc_tplg
*tplg
,
247 struct snd_soc_tplg_hdr
*hdr
)
251 if (tplg
->ops
&& tplg
->ops
->vendor_load
)
252 ret
= tplg
->ops
->vendor_load(tplg
->comp
, tplg
->index
, hdr
);
254 dev_err(tplg
->dev
, "ASoC: no vendor load callback for ID %d\n",
261 "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n",
262 soc_tplg_get_hdr_offset(tplg
),
263 soc_tplg_get_hdr_offset(tplg
),
264 hdr
->type
, hdr
->vendor_type
);
268 /* optionally pass new dynamic widget to component driver. This is mainly for
269 * external widgets where we can assign private data/ops */
270 static int soc_tplg_widget_load(struct soc_tplg
*tplg
,
271 struct snd_soc_dapm_widget
*w
, struct snd_soc_tplg_dapm_widget
*tplg_w
)
273 if (tplg
->ops
&& tplg
->ops
->widget_load
)
274 return tplg
->ops
->widget_load(tplg
->comp
, tplg
->index
, w
,
280 /* optionally pass new dynamic widget to component driver. This is mainly for
281 * external widgets where we can assign private data/ops */
282 static int soc_tplg_widget_ready(struct soc_tplg
*tplg
,
283 struct snd_soc_dapm_widget
*w
, struct snd_soc_tplg_dapm_widget
*tplg_w
)
285 if (tplg
->ops
&& tplg
->ops
->widget_ready
)
286 return tplg
->ops
->widget_ready(tplg
->comp
, tplg
->index
, w
,
292 /* pass DAI configurations to component driver for extra initialization */
293 static int soc_tplg_dai_load(struct soc_tplg
*tplg
,
294 struct snd_soc_dai_driver
*dai_drv
,
295 struct snd_soc_tplg_pcm
*pcm
, struct snd_soc_dai
*dai
)
297 if (tplg
->ops
&& tplg
->ops
->dai_load
)
298 return tplg
->ops
->dai_load(tplg
->comp
, tplg
->index
, dai_drv
,
304 /* pass link configurations to component driver for extra initialization */
305 static int soc_tplg_dai_link_load(struct soc_tplg
*tplg
,
306 struct snd_soc_dai_link
*link
, struct snd_soc_tplg_link_config
*cfg
)
308 if (tplg
->ops
&& tplg
->ops
->link_load
)
309 return tplg
->ops
->link_load(tplg
->comp
, tplg
->index
, link
, cfg
);
314 /* tell the component driver that all firmware has been loaded in this request */
315 static void soc_tplg_complete(struct soc_tplg
*tplg
)
317 if (tplg
->ops
&& tplg
->ops
->complete
)
318 tplg
->ops
->complete(tplg
->comp
);
321 /* add a dynamic kcontrol */
322 static int soc_tplg_add_dcontrol(struct snd_card
*card
, struct device
*dev
,
323 const struct snd_kcontrol_new
*control_new
, const char *prefix
,
324 void *data
, struct snd_kcontrol
**kcontrol
)
328 *kcontrol
= snd_soc_cnew(control_new
, data
, control_new
->name
, prefix
);
329 if (*kcontrol
== NULL
) {
330 dev_err(dev
, "ASoC: Failed to create new kcontrol %s\n",
335 err
= snd_ctl_add(card
, *kcontrol
);
337 dev_err(dev
, "ASoC: Failed to add %s: %d\n",
338 control_new
->name
, err
);
345 /* add a dynamic kcontrol for component driver */
346 static int soc_tplg_add_kcontrol(struct soc_tplg
*tplg
,
347 struct snd_kcontrol_new
*k
, struct snd_kcontrol
**kcontrol
)
349 struct snd_soc_component
*comp
= tplg
->comp
;
351 return soc_tplg_add_dcontrol(comp
->card
->snd_card
,
352 comp
->dev
, k
, comp
->name_prefix
, comp
, kcontrol
);
355 /* remove a mixer kcontrol */
356 static void remove_mixer(struct snd_soc_component
*comp
,
357 struct snd_soc_dobj
*dobj
, int pass
)
359 struct snd_card
*card
= comp
->card
->snd_card
;
361 if (pass
!= SOC_TPLG_PASS_MIXER
)
364 if (dobj
->ops
&& dobj
->ops
->control_unload
)
365 dobj
->ops
->control_unload(comp
, dobj
);
367 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
368 list_del(&dobj
->list
);
371 /* remove an enum kcontrol */
372 static void remove_enum(struct snd_soc_component
*comp
,
373 struct snd_soc_dobj
*dobj
, int pass
)
375 struct snd_card
*card
= comp
->card
->snd_card
;
377 if (pass
!= SOC_TPLG_PASS_MIXER
)
380 if (dobj
->ops
&& dobj
->ops
->control_unload
)
381 dobj
->ops
->control_unload(comp
, dobj
);
383 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
384 list_del(&dobj
->list
);
387 /* remove a byte kcontrol */
388 static void remove_bytes(struct snd_soc_component
*comp
,
389 struct snd_soc_dobj
*dobj
, int pass
)
391 struct snd_card
*card
= comp
->card
->snd_card
;
393 if (pass
!= SOC_TPLG_PASS_MIXER
)
396 if (dobj
->ops
&& dobj
->ops
->control_unload
)
397 dobj
->ops
->control_unload(comp
, dobj
);
399 snd_ctl_remove(card
, dobj
->control
.kcontrol
);
400 list_del(&dobj
->list
);
404 static void remove_route(struct snd_soc_component
*comp
,
405 struct snd_soc_dobj
*dobj
, int pass
)
407 if (pass
!= SOC_TPLG_PASS_GRAPH
)
410 if (dobj
->ops
&& dobj
->ops
->dapm_route_unload
)
411 dobj
->ops
->dapm_route_unload(comp
, dobj
);
413 list_del(&dobj
->list
);
416 /* remove a widget and it's kcontrols - routes must be removed first */
417 static void remove_widget(struct snd_soc_component
*comp
,
418 struct snd_soc_dobj
*dobj
, int pass
)
420 struct snd_card
*card
= comp
->card
->snd_card
;
421 struct snd_soc_dapm_widget
*w
=
422 container_of(dobj
, struct snd_soc_dapm_widget
, dobj
);
425 if (pass
!= SOC_TPLG_PASS_WIDGET
)
428 if (dobj
->ops
&& dobj
->ops
->widget_unload
)
429 dobj
->ops
->widget_unload(comp
, dobj
);
434 for (i
= 0; w
->kcontrols
&& i
< w
->num_kcontrols
; i
++)
435 snd_ctl_remove(card
, w
->kcontrols
[i
]);
439 list_del(&dobj
->list
);
441 /* widget w is freed by soc-dapm.c */
444 /* remove DAI configurations */
445 static void remove_dai(struct snd_soc_component
*comp
,
446 struct snd_soc_dobj
*dobj
, int pass
)
448 struct snd_soc_dai_driver
*dai_drv
=
449 container_of(dobj
, struct snd_soc_dai_driver
, dobj
);
450 struct snd_soc_dai
*dai
, *_dai
;
452 if (pass
!= SOC_TPLG_PASS_PCM_DAI
)
455 if (dobj
->ops
&& dobj
->ops
->dai_unload
)
456 dobj
->ops
->dai_unload(comp
, dobj
);
458 for_each_component_dais_safe(comp
, dai
, _dai
)
459 if (dai
->driver
== dai_drv
)
460 snd_soc_unregister_dai(dai
);
462 list_del(&dobj
->list
);
465 /* remove link configurations */
466 static void remove_link(struct snd_soc_component
*comp
,
467 struct snd_soc_dobj
*dobj
, int pass
)
469 struct snd_soc_dai_link
*link
=
470 container_of(dobj
, struct snd_soc_dai_link
, dobj
);
472 if (pass
!= SOC_TPLG_PASS_PCM_DAI
)
475 if (dobj
->ops
&& dobj
->ops
->link_unload
)
476 dobj
->ops
->link_unload(comp
, dobj
);
478 list_del(&dobj
->list
);
479 snd_soc_remove_pcm_runtime(comp
->card
,
480 snd_soc_get_pcm_runtime(comp
->card
, link
));
483 /* unload dai link */
484 static void remove_backend_link(struct snd_soc_component
*comp
,
485 struct snd_soc_dobj
*dobj
, int pass
)
487 if (pass
!= SOC_TPLG_PASS_LINK
)
490 if (dobj
->ops
&& dobj
->ops
->link_unload
)
491 dobj
->ops
->link_unload(comp
, dobj
);
494 * We don't free the link here as what remove_link() do since BE
495 * links are not allocated by topology.
496 * We however need to reset the dobj type to its initial values
498 dobj
->type
= SND_SOC_DOBJ_NONE
;
499 list_del(&dobj
->list
);
502 /* bind a kcontrol to it's IO handlers */
503 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr
*hdr
,
504 struct snd_kcontrol_new
*k
,
505 const struct soc_tplg
*tplg
)
507 const struct snd_soc_tplg_kcontrol_ops
*ops
;
508 const struct snd_soc_tplg_bytes_ext_ops
*ext_ops
;
511 if (le32_to_cpu(hdr
->ops
.info
) == SND_SOC_TPLG_CTL_BYTES
512 && k
->iface
& SNDRV_CTL_ELEM_IFACE_MIXER
513 && k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
514 && k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
) {
515 struct soc_bytes_ext
*sbe
;
516 struct snd_soc_tplg_bytes_control
*be
;
518 sbe
= (struct soc_bytes_ext
*)k
->private_value
;
519 be
= container_of(hdr
, struct snd_soc_tplg_bytes_control
, hdr
);
521 /* TLV bytes controls need standard kcontrol info handler,
522 * TLV callback and extended put/get handlers.
524 k
->info
= snd_soc_bytes_info_ext
;
525 k
->tlv
.c
= snd_soc_bytes_tlv_callback
;
528 * When a topology-based implementation abuses the
529 * control interface and uses bytes_ext controls of
530 * more than 512 bytes, we need to disable the size
531 * checks, otherwise accesses to such controls will
532 * return an -EINVAL error and prevent the card from
535 if (IS_ENABLED(CONFIG_SND_CTL_VALIDATION
) && sbe
->max
> 512)
536 k
->access
|= SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK
;
538 ext_ops
= tplg
->bytes_ext_ops
;
539 num_ops
= tplg
->bytes_ext_ops_count
;
540 for (i
= 0; i
< num_ops
; i
++) {
542 ext_ops
[i
].id
== le32_to_cpu(be
->ext_ops
.put
))
543 sbe
->put
= ext_ops
[i
].put
;
545 ext_ops
[i
].id
== le32_to_cpu(be
->ext_ops
.get
))
546 sbe
->get
= ext_ops
[i
].get
;
549 if ((k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_READ
) && !sbe
->get
)
551 if ((k
->access
& SNDRV_CTL_ELEM_ACCESS_TLV_WRITE
) && !sbe
->put
)
556 /* try and map vendor specific kcontrol handlers first */
558 num_ops
= tplg
->io_ops_count
;
559 for (i
= 0; i
< num_ops
; i
++) {
561 if (k
->put
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.put
))
563 if (k
->get
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.get
))
565 if (k
->info
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.info
))
566 k
->info
= ops
[i
].info
;
569 /* vendor specific handlers found ? */
570 if (k
->put
&& k
->get
&& k
->info
)
573 /* none found so try standard kcontrol handlers */
575 num_ops
= ARRAY_SIZE(io_ops
);
576 for (i
= 0; i
< num_ops
; i
++) {
578 if (k
->put
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.put
))
580 if (k
->get
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.get
))
582 if (k
->info
== NULL
&& ops
[i
].id
== le32_to_cpu(hdr
->ops
.info
))
583 k
->info
= ops
[i
].info
;
586 /* standard handlers found ? */
587 if (k
->put
&& k
->get
&& k
->info
)
590 /* nothing to bind */
594 /* bind a widgets to it's evnt handlers */
595 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget
*w
,
596 const struct snd_soc_tplg_widget_events
*events
,
597 int num_events
, u16 event_type
)
603 for (i
= 0; i
< num_events
; i
++) {
604 if (event_type
== events
[i
].type
) {
606 /* found - so assign event */
607 w
->event
= events
[i
].event_handler
;
615 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event
);
617 /* optionally pass new dynamic kcontrol to component driver. */
618 static int soc_tplg_init_kcontrol(struct soc_tplg
*tplg
,
619 struct snd_kcontrol_new
*k
, struct snd_soc_tplg_ctl_hdr
*hdr
)
621 if (tplg
->ops
&& tplg
->ops
->control_load
)
622 return tplg
->ops
->control_load(tplg
->comp
, tplg
->index
, k
,
629 static int soc_tplg_create_tlv_db_scale(struct soc_tplg
*tplg
,
630 struct snd_kcontrol_new
*kc
, struct snd_soc_tplg_tlv_dbscale
*scale
)
632 unsigned int item_len
= 2 * sizeof(unsigned int);
635 p
= devm_kzalloc(tplg
->dev
, item_len
+ 2 * sizeof(unsigned int), GFP_KERNEL
);
639 p
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
641 p
[2] = le32_to_cpu(scale
->min
);
642 p
[3] = (le32_to_cpu(scale
->step
) & TLV_DB_SCALE_MASK
)
643 | (le32_to_cpu(scale
->mute
) ? TLV_DB_SCALE_MUTE
: 0);
645 kc
->tlv
.p
= (void *)p
;
649 static int soc_tplg_create_tlv(struct soc_tplg
*tplg
,
650 struct snd_kcontrol_new
*kc
, struct snd_soc_tplg_ctl_hdr
*tc
)
652 struct snd_soc_tplg_ctl_tlv
*tplg_tlv
;
653 u32 access
= le32_to_cpu(tc
->access
);
655 if (!(access
& SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
))
658 if (!(access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
)) {
660 switch (le32_to_cpu(tplg_tlv
->type
)) {
661 case SNDRV_CTL_TLVT_DB_SCALE
:
662 return soc_tplg_create_tlv_db_scale(tplg
, kc
,
665 /* TODO: add support for other TLV types */
667 dev_dbg(tplg
->dev
, "Unsupported TLV type %d\n",
676 static int soc_tplg_dbytes_create(struct soc_tplg
*tplg
, unsigned int count
,
679 struct snd_soc_tplg_bytes_control
*be
;
680 struct soc_bytes_ext
*sbe
;
681 struct snd_kcontrol_new kc
;
685 if (soc_tplg_check_elem_count(tplg
,
686 sizeof(struct snd_soc_tplg_bytes_control
), count
,
687 size
, "mixer bytes")) {
688 dev_err(tplg
->dev
, "ASoC: Invalid count %d for byte control\n",
693 for (i
= 0; i
< count
; i
++) {
694 be
= (struct snd_soc_tplg_bytes_control
*)tplg
->pos
;
696 /* validate kcontrol */
697 if (strnlen(be
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
698 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
701 sbe
= devm_kzalloc(tplg
->dev
, sizeof(*sbe
), GFP_KERNEL
);
705 tplg
->pos
+= (sizeof(struct snd_soc_tplg_bytes_control
) +
706 le32_to_cpu(be
->priv
.size
));
709 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
710 be
->hdr
.name
, be
->hdr
.access
);
712 memset(&kc
, 0, sizeof(kc
));
713 kc
.name
= be
->hdr
.name
;
714 kc
.private_value
= (long)sbe
;
715 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
716 kc
.access
= le32_to_cpu(be
->hdr
.access
);
718 sbe
->max
= le32_to_cpu(be
->max
);
719 sbe
->dobj
.type
= SND_SOC_DOBJ_BYTES
;
720 sbe
->dobj
.ops
= tplg
->ops
;
721 INIT_LIST_HEAD(&sbe
->dobj
.list
);
723 /* map io handlers */
724 err
= soc_tplg_kcontrol_bind_io(&be
->hdr
, &kc
, tplg
);
726 soc_control_err(tplg
, &be
->hdr
, be
->hdr
.name
);
730 /* pass control to driver for optional further init */
731 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
732 (struct snd_soc_tplg_ctl_hdr
*)be
);
734 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
739 /* register control here */
740 err
= soc_tplg_add_kcontrol(tplg
, &kc
,
741 &sbe
->dobj
.control
.kcontrol
);
743 dev_err(tplg
->dev
, "ASoC: failed to add %s\n",
748 list_add(&sbe
->dobj
.list
, &tplg
->comp
->dobj_list
);
754 static int soc_tplg_dmixer_create(struct soc_tplg
*tplg
, unsigned int count
,
757 struct snd_soc_tplg_mixer_control
*mc
;
758 struct soc_mixer_control
*sm
;
759 struct snd_kcontrol_new kc
;
763 if (soc_tplg_check_elem_count(tplg
,
764 sizeof(struct snd_soc_tplg_mixer_control
),
765 count
, size
, "mixers")) {
767 dev_err(tplg
->dev
, "ASoC: invalid count %d for controls\n",
772 for (i
= 0; i
< count
; i
++) {
773 mc
= (struct snd_soc_tplg_mixer_control
*)tplg
->pos
;
775 /* validate kcontrol */
776 if (strnlen(mc
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
777 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
780 sm
= devm_kzalloc(tplg
->dev
, sizeof(*sm
), GFP_KERNEL
);
783 tplg
->pos
+= (sizeof(struct snd_soc_tplg_mixer_control
) +
784 le32_to_cpu(mc
->priv
.size
));
787 "ASoC: adding mixer kcontrol %s with access 0x%x\n",
788 mc
->hdr
.name
, mc
->hdr
.access
);
790 memset(&kc
, 0, sizeof(kc
));
791 kc
.name
= mc
->hdr
.name
;
792 kc
.private_value
= (long)sm
;
793 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
794 kc
.access
= le32_to_cpu(mc
->hdr
.access
);
796 /* we only support FL/FR channel mapping atm */
797 sm
->reg
= tplc_chan_get_reg(tplg
, mc
->channel
,
799 sm
->rreg
= tplc_chan_get_reg(tplg
, mc
->channel
,
801 sm
->shift
= tplc_chan_get_shift(tplg
, mc
->channel
,
803 sm
->rshift
= tplc_chan_get_shift(tplg
, mc
->channel
,
806 sm
->max
= le32_to_cpu(mc
->max
);
807 sm
->min
= le32_to_cpu(mc
->min
);
808 sm
->invert
= le32_to_cpu(mc
->invert
);
809 sm
->platform_max
= le32_to_cpu(mc
->platform_max
);
810 sm
->dobj
.index
= tplg
->index
;
811 sm
->dobj
.ops
= tplg
->ops
;
812 sm
->dobj
.type
= SND_SOC_DOBJ_MIXER
;
813 INIT_LIST_HEAD(&sm
->dobj
.list
);
815 /* map io handlers */
816 err
= soc_tplg_kcontrol_bind_io(&mc
->hdr
, &kc
, tplg
);
818 soc_control_err(tplg
, &mc
->hdr
, mc
->hdr
.name
);
822 /* create any TLV data */
823 err
= soc_tplg_create_tlv(tplg
, &kc
, &mc
->hdr
);
825 dev_err(tplg
->dev
, "ASoC: failed to create TLV %s\n",
830 /* pass control to driver for optional further init */
831 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
832 (struct snd_soc_tplg_ctl_hdr
*) mc
);
834 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
839 /* register control here */
840 err
= soc_tplg_add_kcontrol(tplg
, &kc
,
841 &sm
->dobj
.control
.kcontrol
);
843 dev_err(tplg
->dev
, "ASoC: failed to add %s\n",
848 list_add(&sm
->dobj
.list
, &tplg
->comp
->dobj_list
);
854 static int soc_tplg_denum_create_texts(struct soc_tplg
*tplg
, struct soc_enum
*se
,
855 struct snd_soc_tplg_enum_control
*ec
)
859 if (le32_to_cpu(ec
->items
) > ARRAY_SIZE(ec
->texts
))
862 se
->dobj
.control
.dtexts
=
863 devm_kcalloc(tplg
->dev
, le32_to_cpu(ec
->items
), sizeof(char *), GFP_KERNEL
);
864 if (se
->dobj
.control
.dtexts
== NULL
)
867 for (i
= 0; i
< le32_to_cpu(ec
->items
); i
++) {
869 if (strnlen(ec
->texts
[i
], SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
870 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
875 se
->dobj
.control
.dtexts
[i
] = devm_kstrdup(tplg
->dev
, ec
->texts
[i
], GFP_KERNEL
);
876 if (!se
->dobj
.control
.dtexts
[i
]) {
882 se
->items
= le32_to_cpu(ec
->items
);
883 se
->texts
= (const char * const *)se
->dobj
.control
.dtexts
;
890 static int soc_tplg_denum_create_values(struct soc_tplg
*tplg
, struct soc_enum
*se
,
891 struct snd_soc_tplg_enum_control
*ec
)
896 * Following "if" checks if we have at most SND_SOC_TPLG_NUM_TEXTS
897 * values instead of using ARRAY_SIZE(ec->values) due to the fact that
898 * it is oversized for its purpose. Additionally it is done so because
899 * it is defined in UAPI header where it can't be easily changed.
901 if (le32_to_cpu(ec
->items
) > SND_SOC_TPLG_NUM_TEXTS
)
904 se
->dobj
.control
.dvalues
= devm_kcalloc(tplg
->dev
, le32_to_cpu(ec
->items
),
905 sizeof(*se
->dobj
.control
.dvalues
),
907 if (!se
->dobj
.control
.dvalues
)
910 /* convert from little-endian */
911 for (i
= 0; i
< le32_to_cpu(ec
->items
); i
++) {
912 se
->dobj
.control
.dvalues
[i
] = le32_to_cpu(ec
->values
[i
]);
918 static int soc_tplg_denum_create(struct soc_tplg
*tplg
, unsigned int count
,
921 struct snd_soc_tplg_enum_control
*ec
;
923 struct snd_kcontrol_new kc
;
927 if (soc_tplg_check_elem_count(tplg
,
928 sizeof(struct snd_soc_tplg_enum_control
),
929 count
, size
, "enums")) {
931 dev_err(tplg
->dev
, "ASoC: invalid count %d for enum controls\n",
936 for (i
= 0; i
< count
; i
++) {
937 ec
= (struct snd_soc_tplg_enum_control
*)tplg
->pos
;
939 /* validate kcontrol */
940 if (strnlen(ec
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
941 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
944 se
= devm_kzalloc(tplg
->dev
, (sizeof(*se
)), GFP_KERNEL
);
948 tplg
->pos
+= (sizeof(struct snd_soc_tplg_enum_control
) +
949 le32_to_cpu(ec
->priv
.size
));
951 dev_dbg(tplg
->dev
, "ASoC: adding enum kcontrol %s size %d\n",
952 ec
->hdr
.name
, ec
->items
);
954 memset(&kc
, 0, sizeof(kc
));
955 kc
.name
= ec
->hdr
.name
;
956 kc
.private_value
= (long)se
;
957 kc
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
958 kc
.access
= le32_to_cpu(ec
->hdr
.access
);
960 se
->reg
= tplc_chan_get_reg(tplg
, ec
->channel
, SNDRV_CHMAP_FL
);
961 se
->shift_l
= tplc_chan_get_shift(tplg
, ec
->channel
,
963 se
->shift_r
= tplc_chan_get_shift(tplg
, ec
->channel
,
966 se
->mask
= le32_to_cpu(ec
->mask
);
967 se
->dobj
.index
= tplg
->index
;
968 se
->dobj
.type
= SND_SOC_DOBJ_ENUM
;
969 se
->dobj
.ops
= tplg
->ops
;
970 INIT_LIST_HEAD(&se
->dobj
.list
);
972 switch (le32_to_cpu(ec
->hdr
.ops
.info
)) {
973 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
974 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
975 err
= soc_tplg_denum_create_values(tplg
, se
, ec
);
978 "ASoC: could not create values for %s\n",
983 case SND_SOC_TPLG_CTL_ENUM
:
984 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
985 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
986 err
= soc_tplg_denum_create_texts(tplg
, se
, ec
);
989 "ASoC: could not create texts for %s\n",
997 "ASoC: invalid enum control type %d for %s\n",
998 ec
->hdr
.ops
.info
, ec
->hdr
.name
);
1002 /* map io handlers */
1003 err
= soc_tplg_kcontrol_bind_io(&ec
->hdr
, &kc
, tplg
);
1005 soc_control_err(tplg
, &ec
->hdr
, ec
->hdr
.name
);
1009 /* pass control to driver for optional further init */
1010 err
= soc_tplg_init_kcontrol(tplg
, &kc
,
1011 (struct snd_soc_tplg_ctl_hdr
*) ec
);
1013 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1018 /* register control here */
1019 err
= soc_tplg_add_kcontrol(tplg
,
1020 &kc
, &se
->dobj
.control
.kcontrol
);
1022 dev_err(tplg
->dev
, "ASoC: could not add kcontrol %s\n",
1027 list_add(&se
->dobj
.list
, &tplg
->comp
->dobj_list
);
1035 static int soc_tplg_kcontrol_elems_load(struct soc_tplg
*tplg
,
1036 struct snd_soc_tplg_hdr
*hdr
)
1038 struct snd_soc_tplg_ctl_hdr
*control_hdr
;
1042 dev_dbg(tplg
->dev
, "ASoC: adding %d kcontrols at 0x%lx\n", hdr
->count
,
1043 soc_tplg_get_offset(tplg
));
1045 for (i
= 0; i
< le32_to_cpu(hdr
->count
); i
++) {
1047 control_hdr
= (struct snd_soc_tplg_ctl_hdr
*)tplg
->pos
;
1049 if (le32_to_cpu(control_hdr
->size
) != sizeof(*control_hdr
)) {
1050 dev_err(tplg
->dev
, "ASoC: invalid control size\n");
1054 switch (le32_to_cpu(control_hdr
->ops
.info
)) {
1055 case SND_SOC_TPLG_CTL_VOLSW
:
1056 case SND_SOC_TPLG_CTL_STROBE
:
1057 case SND_SOC_TPLG_CTL_VOLSW_SX
:
1058 case SND_SOC_TPLG_CTL_VOLSW_XR_SX
:
1059 case SND_SOC_TPLG_CTL_RANGE
:
1060 case SND_SOC_TPLG_DAPM_CTL_VOLSW
:
1061 case SND_SOC_TPLG_DAPM_CTL_PIN
:
1062 ret
= soc_tplg_dmixer_create(tplg
, 1,
1063 le32_to_cpu(hdr
->payload_size
));
1065 case SND_SOC_TPLG_CTL_ENUM
:
1066 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1067 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1068 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1069 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1070 ret
= soc_tplg_denum_create(tplg
, 1,
1071 le32_to_cpu(hdr
->payload_size
));
1073 case SND_SOC_TPLG_CTL_BYTES
:
1074 ret
= soc_tplg_dbytes_create(tplg
, 1,
1075 le32_to_cpu(hdr
->payload_size
));
1078 soc_bind_err(tplg
, control_hdr
, i
);
1082 dev_err(tplg
->dev
, "ASoC: invalid control\n");
1091 /* optionally pass new dynamic kcontrol to component driver. */
1092 static int soc_tplg_add_route(struct soc_tplg
*tplg
,
1093 struct snd_soc_dapm_route
*route
)
1095 if (tplg
->ops
&& tplg
->ops
->dapm_route_load
)
1096 return tplg
->ops
->dapm_route_load(tplg
->comp
, tplg
->index
,
1102 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg
*tplg
,
1103 struct snd_soc_tplg_hdr
*hdr
)
1105 struct snd_soc_dapm_context
*dapm
= &tplg
->comp
->dapm
;
1106 struct snd_soc_tplg_dapm_graph_elem
*elem
;
1107 struct snd_soc_dapm_route
**routes
;
1111 count
= le32_to_cpu(hdr
->count
);
1113 if (soc_tplg_check_elem_count(tplg
,
1114 sizeof(struct snd_soc_tplg_dapm_graph_elem
),
1115 count
, le32_to_cpu(hdr
->payload_size
), "graph")) {
1117 dev_err(tplg
->dev
, "ASoC: invalid count %d for DAPM routes\n",
1122 dev_dbg(tplg
->dev
, "ASoC: adding %d DAPM routes for index %d\n", count
,
1125 /* allocate memory for pointer to array of dapm routes */
1126 routes
= kcalloc(count
, sizeof(struct snd_soc_dapm_route
*),
1132 * allocate memory for each dapm route in the array.
1133 * This needs to be done individually so that
1134 * each route can be freed when it is removed in remove_route().
1136 for (i
= 0; i
< count
; i
++) {
1137 routes
[i
] = devm_kzalloc(tplg
->dev
, sizeof(*routes
[i
]), GFP_KERNEL
);
1142 for (i
= 0; i
< count
; i
++) {
1143 elem
= (struct snd_soc_tplg_dapm_graph_elem
*)tplg
->pos
;
1144 tplg
->pos
+= sizeof(struct snd_soc_tplg_dapm_graph_elem
);
1146 /* validate routes */
1147 if (strnlen(elem
->source
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1148 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1152 if (strnlen(elem
->sink
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1153 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1157 if (strnlen(elem
->control
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1158 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) {
1163 routes
[i
]->source
= elem
->source
;
1164 routes
[i
]->sink
= elem
->sink
;
1166 /* set to NULL atm for tplg users */
1167 routes
[i
]->connected
= NULL
;
1168 if (strnlen(elem
->control
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) == 0)
1169 routes
[i
]->control
= NULL
;
1171 routes
[i
]->control
= elem
->control
;
1173 /* add route dobj to dobj_list */
1174 routes
[i
]->dobj
.type
= SND_SOC_DOBJ_GRAPH
;
1175 routes
[i
]->dobj
.ops
= tplg
->ops
;
1176 routes
[i
]->dobj
.index
= tplg
->index
;
1177 list_add(&routes
[i
]->dobj
.list
, &tplg
->comp
->dobj_list
);
1179 ret
= soc_tplg_add_route(tplg
, routes
[i
]);
1181 dev_err(tplg
->dev
, "ASoC: topology: add_route failed: %d\n", ret
);
1183 * this route was added to the list, it will
1184 * be freed in remove_route() so increment the
1185 * counter to skip it in the error handling
1192 /* add route, but keep going if some fail */
1193 snd_soc_dapm_add_routes(dapm
, routes
[i
], 1);
1197 * free pointer to array of dapm routes as this is no longer needed.
1198 * The memory allocated for each dapm route will be freed
1199 * when it is removed in remove_route().
1206 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_dmixer_create(
1207 struct soc_tplg
*tplg
, int num_kcontrols
)
1209 struct snd_kcontrol_new
*kc
;
1210 struct soc_mixer_control
*sm
;
1211 struct snd_soc_tplg_mixer_control
*mc
;
1214 kc
= devm_kcalloc(tplg
->dev
, num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1218 for (i
= 0; i
< num_kcontrols
; i
++) {
1219 mc
= (struct snd_soc_tplg_mixer_control
*)tplg
->pos
;
1221 /* validate kcontrol */
1222 if (strnlen(mc
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1223 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1226 sm
= devm_kzalloc(tplg
->dev
, sizeof(*sm
), GFP_KERNEL
);
1230 tplg
->pos
+= (sizeof(struct snd_soc_tplg_mixer_control
) +
1231 le32_to_cpu(mc
->priv
.size
));
1233 dev_dbg(tplg
->dev
, " adding DAPM widget mixer control %s at %d\n",
1236 kc
[i
].private_value
= (long)sm
;
1237 kc
[i
].name
= devm_kstrdup(tplg
->dev
, mc
->hdr
.name
, GFP_KERNEL
);
1238 if (kc
[i
].name
== NULL
)
1240 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1241 kc
[i
].access
= le32_to_cpu(mc
->hdr
.access
);
1243 /* we only support FL/FR channel mapping atm */
1244 sm
->reg
= tplc_chan_get_reg(tplg
, mc
->channel
,
1246 sm
->rreg
= tplc_chan_get_reg(tplg
, mc
->channel
,
1248 sm
->shift
= tplc_chan_get_shift(tplg
, mc
->channel
,
1250 sm
->rshift
= tplc_chan_get_shift(tplg
, mc
->channel
,
1253 sm
->max
= le32_to_cpu(mc
->max
);
1254 sm
->min
= le32_to_cpu(mc
->min
);
1255 sm
->invert
= le32_to_cpu(mc
->invert
);
1256 sm
->platform_max
= le32_to_cpu(mc
->platform_max
);
1257 sm
->dobj
.index
= tplg
->index
;
1258 INIT_LIST_HEAD(&sm
->dobj
.list
);
1260 /* map io handlers */
1261 err
= soc_tplg_kcontrol_bind_io(&mc
->hdr
, &kc
[i
], tplg
);
1263 soc_control_err(tplg
, &mc
->hdr
, mc
->hdr
.name
);
1267 /* create any TLV data */
1268 err
= soc_tplg_create_tlv(tplg
, &kc
[i
], &mc
->hdr
);
1270 dev_err(tplg
->dev
, "ASoC: failed to create TLV %s\n",
1275 /* pass control to driver for optional further init */
1276 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1277 (struct snd_soc_tplg_ctl_hdr
*)mc
);
1279 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1290 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_denum_create(
1291 struct soc_tplg
*tplg
, int num_kcontrols
)
1293 struct snd_kcontrol_new
*kc
;
1294 struct snd_soc_tplg_enum_control
*ec
;
1295 struct soc_enum
*se
;
1298 kc
= devm_kcalloc(tplg
->dev
, num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1302 for (i
= 0; i
< num_kcontrols
; i
++) {
1303 ec
= (struct snd_soc_tplg_enum_control
*)tplg
->pos
;
1304 /* validate kcontrol */
1305 if (strnlen(ec
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1306 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1309 se
= devm_kzalloc(tplg
->dev
, sizeof(*se
), GFP_KERNEL
);
1313 tplg
->pos
+= (sizeof(struct snd_soc_tplg_enum_control
) +
1314 le32_to_cpu(ec
->priv
.size
));
1316 dev_dbg(tplg
->dev
, " adding DAPM widget enum control %s\n",
1319 kc
[i
].private_value
= (long)se
;
1320 kc
[i
].name
= devm_kstrdup(tplg
->dev
, ec
->hdr
.name
, GFP_KERNEL
);
1321 if (kc
[i
].name
== NULL
)
1323 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1324 kc
[i
].access
= le32_to_cpu(ec
->hdr
.access
);
1326 /* we only support FL/FR channel mapping atm */
1327 se
->reg
= tplc_chan_get_reg(tplg
, ec
->channel
, SNDRV_CHMAP_FL
);
1328 se
->shift_l
= tplc_chan_get_shift(tplg
, ec
->channel
,
1330 se
->shift_r
= tplc_chan_get_shift(tplg
, ec
->channel
,
1333 se
->items
= le32_to_cpu(ec
->items
);
1334 se
->mask
= le32_to_cpu(ec
->mask
);
1335 se
->dobj
.index
= tplg
->index
;
1337 switch (le32_to_cpu(ec
->hdr
.ops
.info
)) {
1338 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1339 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1340 err
= soc_tplg_denum_create_values(tplg
, se
, ec
);
1342 dev_err(tplg
->dev
, "ASoC: could not create values for %s\n",
1347 case SND_SOC_TPLG_CTL_ENUM
:
1348 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1349 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1350 err
= soc_tplg_denum_create_texts(tplg
, se
, ec
);
1352 dev_err(tplg
->dev
, "ASoC: could not create texts for %s\n",
1358 dev_err(tplg
->dev
, "ASoC: invalid enum control type %d for %s\n",
1359 ec
->hdr
.ops
.info
, ec
->hdr
.name
);
1363 /* map io handlers */
1364 err
= soc_tplg_kcontrol_bind_io(&ec
->hdr
, &kc
[i
], tplg
);
1366 soc_control_err(tplg
, &ec
->hdr
, ec
->hdr
.name
);
1370 /* pass control to driver for optional further init */
1371 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1372 (struct snd_soc_tplg_ctl_hdr
*)ec
);
1374 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1386 static struct snd_kcontrol_new
*soc_tplg_dapm_widget_dbytes_create(
1387 struct soc_tplg
*tplg
, int num_kcontrols
)
1389 struct snd_soc_tplg_bytes_control
*be
;
1390 struct soc_bytes_ext
*sbe
;
1391 struct snd_kcontrol_new
*kc
;
1394 kc
= devm_kcalloc(tplg
->dev
, num_kcontrols
, sizeof(*kc
), GFP_KERNEL
);
1398 for (i
= 0; i
< num_kcontrols
; i
++) {
1399 be
= (struct snd_soc_tplg_bytes_control
*)tplg
->pos
;
1401 /* validate kcontrol */
1402 if (strnlen(be
->hdr
.name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1403 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1406 sbe
= devm_kzalloc(tplg
->dev
, sizeof(*sbe
), GFP_KERNEL
);
1410 tplg
->pos
+= (sizeof(struct snd_soc_tplg_bytes_control
) +
1411 le32_to_cpu(be
->priv
.size
));
1414 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1415 be
->hdr
.name
, be
->hdr
.access
);
1417 kc
[i
].private_value
= (long)sbe
;
1418 kc
[i
].name
= devm_kstrdup(tplg
->dev
, be
->hdr
.name
, GFP_KERNEL
);
1419 if (kc
[i
].name
== NULL
)
1421 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1422 kc
[i
].access
= le32_to_cpu(be
->hdr
.access
);
1424 sbe
->max
= le32_to_cpu(be
->max
);
1425 INIT_LIST_HEAD(&sbe
->dobj
.list
);
1427 /* map standard io handlers and check for external handlers */
1428 err
= soc_tplg_kcontrol_bind_io(&be
->hdr
, &kc
[i
], tplg
);
1430 soc_control_err(tplg
, &be
->hdr
, be
->hdr
.name
);
1434 /* pass control to driver for optional further init */
1435 err
= soc_tplg_init_kcontrol(tplg
, &kc
[i
],
1436 (struct snd_soc_tplg_ctl_hdr
*)be
);
1438 dev_err(tplg
->dev
, "ASoC: failed to init %s\n",
1451 static int soc_tplg_dapm_widget_create(struct soc_tplg
*tplg
,
1452 struct snd_soc_tplg_dapm_widget
*w
)
1454 struct snd_soc_dapm_context
*dapm
= &tplg
->comp
->dapm
;
1455 struct snd_soc_dapm_widget
template, *widget
;
1456 struct snd_soc_tplg_ctl_hdr
*control_hdr
;
1457 struct snd_soc_card
*card
= tplg
->comp
->card
;
1458 unsigned int kcontrol_type
;
1461 if (strnlen(w
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1462 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1464 if (strnlen(w
->sname
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
) ==
1465 SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
1468 dev_dbg(tplg
->dev
, "ASoC: creating DAPM widget %s id %d\n",
1471 memset(&template, 0, sizeof(template));
1473 /* map user to kernel widget ID */
1474 template.id
= get_widget_id(le32_to_cpu(w
->id
));
1475 if ((int)template.id
< 0)
1478 /* strings are allocated here, but used and freed by the widget */
1479 template.name
= kstrdup(w
->name
, GFP_KERNEL
);
1482 template.sname
= kstrdup(w
->sname
, GFP_KERNEL
);
1483 if (!template.sname
) {
1487 template.reg
= le32_to_cpu(w
->reg
);
1488 template.shift
= le32_to_cpu(w
->shift
);
1489 template.mask
= le32_to_cpu(w
->mask
);
1490 template.subseq
= le32_to_cpu(w
->subseq
);
1491 template.on_val
= w
->invert
? 0 : 1;
1492 template.off_val
= w
->invert
? 1 : 0;
1493 template.ignore_suspend
= le32_to_cpu(w
->ignore_suspend
);
1494 template.event_flags
= le16_to_cpu(w
->event_flags
);
1495 template.dobj
.index
= tplg
->index
;
1498 (sizeof(struct snd_soc_tplg_dapm_widget
) +
1499 le32_to_cpu(w
->priv
.size
));
1501 if (w
->num_kcontrols
== 0) {
1503 template.num_kcontrols
= 0;
1507 control_hdr
= (struct snd_soc_tplg_ctl_hdr
*)tplg
->pos
;
1508 dev_dbg(tplg
->dev
, "ASoC: template %s has %d controls of type %x\n",
1509 w
->name
, w
->num_kcontrols
, control_hdr
->type
);
1511 switch (le32_to_cpu(control_hdr
->ops
.info
)) {
1512 case SND_SOC_TPLG_CTL_VOLSW
:
1513 case SND_SOC_TPLG_CTL_STROBE
:
1514 case SND_SOC_TPLG_CTL_VOLSW_SX
:
1515 case SND_SOC_TPLG_CTL_VOLSW_XR_SX
:
1516 case SND_SOC_TPLG_CTL_RANGE
:
1517 case SND_SOC_TPLG_DAPM_CTL_VOLSW
:
1518 kcontrol_type
= SND_SOC_TPLG_TYPE_MIXER
; /* volume mixer */
1519 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1520 template.kcontrol_news
=
1521 soc_tplg_dapm_widget_dmixer_create(tplg
,
1522 template.num_kcontrols
);
1523 if (!template.kcontrol_news
) {
1528 case SND_SOC_TPLG_CTL_ENUM
:
1529 case SND_SOC_TPLG_CTL_ENUM_VALUE
:
1530 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE
:
1531 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT
:
1532 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE
:
1533 kcontrol_type
= SND_SOC_TPLG_TYPE_ENUM
; /* enumerated mixer */
1534 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1535 template.kcontrol_news
=
1536 soc_tplg_dapm_widget_denum_create(tplg
,
1537 template.num_kcontrols
);
1538 if (!template.kcontrol_news
) {
1543 case SND_SOC_TPLG_CTL_BYTES
:
1544 kcontrol_type
= SND_SOC_TPLG_TYPE_BYTES
; /* bytes control */
1545 template.num_kcontrols
= le32_to_cpu(w
->num_kcontrols
);
1546 template.kcontrol_news
=
1547 soc_tplg_dapm_widget_dbytes_create(tplg
,
1548 template.num_kcontrols
);
1549 if (!template.kcontrol_news
) {
1555 dev_err(tplg
->dev
, "ASoC: invalid widget control type %d:%d:%d\n",
1556 control_hdr
->ops
.get
, control_hdr
->ops
.put
,
1557 le32_to_cpu(control_hdr
->ops
.info
));
1563 ret
= soc_tplg_widget_load(tplg
, &template, w
);
1567 /* card dapm mutex is held by the core if we are loading topology
1568 * data during sound card init. */
1569 if (card
->instantiated
)
1570 widget
= snd_soc_dapm_new_control(dapm
, &template);
1572 widget
= snd_soc_dapm_new_control_unlocked(dapm
, &template);
1573 if (IS_ERR(widget
)) {
1574 ret
= PTR_ERR(widget
);
1578 widget
->dobj
.type
= SND_SOC_DOBJ_WIDGET
;
1579 widget
->dobj
.widget
.kcontrol_type
= kcontrol_type
;
1580 widget
->dobj
.ops
= tplg
->ops
;
1581 widget
->dobj
.index
= tplg
->index
;
1582 list_add(&widget
->dobj
.list
, &tplg
->comp
->dobj_list
);
1584 ret
= soc_tplg_widget_ready(tplg
, widget
, w
);
1588 kfree(template.sname
);
1589 kfree(template.name
);
1594 remove_widget(widget
->dapm
->component
, &widget
->dobj
, SOC_TPLG_PASS_WIDGET
);
1595 snd_soc_dapm_free_widget(widget
);
1597 kfree(template.sname
);
1599 kfree(template.name
);
1603 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg
*tplg
,
1604 struct snd_soc_tplg_hdr
*hdr
)
1606 struct snd_soc_tplg_dapm_widget
*widget
;
1609 count
= le32_to_cpu(hdr
->count
);
1611 dev_dbg(tplg
->dev
, "ASoC: adding %d DAPM widgets\n", count
);
1613 for (i
= 0; i
< count
; i
++) {
1614 widget
= (struct snd_soc_tplg_dapm_widget
*) tplg
->pos
;
1615 if (le32_to_cpu(widget
->size
) != sizeof(*widget
)) {
1616 dev_err(tplg
->dev
, "ASoC: invalid widget size\n");
1620 ret
= soc_tplg_dapm_widget_create(tplg
, widget
);
1622 dev_err(tplg
->dev
, "ASoC: failed to load widget %s\n",
1631 static int soc_tplg_dapm_complete(struct soc_tplg
*tplg
)
1633 struct snd_soc_card
*card
= tplg
->comp
->card
;
1636 /* Card might not have been registered at this point.
1637 * If so, just return success.
1639 if (!card
|| !card
->instantiated
) {
1640 dev_warn(tplg
->dev
, "ASoC: Parent card not yet available,"
1641 " widget card binding deferred\n");
1645 ret
= snd_soc_dapm_new_widgets(card
);
1647 dev_err(tplg
->dev
, "ASoC: failed to create new widgets %d\n",
1653 static int set_stream_info(struct soc_tplg
*tplg
, struct snd_soc_pcm_stream
*stream
,
1654 struct snd_soc_tplg_stream_caps
*caps
)
1656 stream
->stream_name
= devm_kstrdup(tplg
->dev
, caps
->name
, GFP_KERNEL
);
1657 if (!stream
->stream_name
)
1660 stream
->channels_min
= le32_to_cpu(caps
->channels_min
);
1661 stream
->channels_max
= le32_to_cpu(caps
->channels_max
);
1662 stream
->rates
= le32_to_cpu(caps
->rates
);
1663 stream
->rate_min
= le32_to_cpu(caps
->rate_min
);
1664 stream
->rate_max
= le32_to_cpu(caps
->rate_max
);
1665 stream
->formats
= le64_to_cpu(caps
->formats
);
1666 stream
->sig_bits
= le32_to_cpu(caps
->sig_bits
);
1671 static void set_dai_flags(struct snd_soc_dai_driver
*dai_drv
,
1672 unsigned int flag_mask
, unsigned int flags
)
1674 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES
)
1675 dai_drv
->symmetric_rate
=
1676 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES
? 1 : 0;
1678 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS
)
1679 dai_drv
->symmetric_channels
=
1680 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS
?
1683 if (flag_mask
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS
)
1684 dai_drv
->symmetric_sample_bits
=
1685 flags
& SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS
?
1689 static int soc_tplg_dai_create(struct soc_tplg
*tplg
,
1690 struct snd_soc_tplg_pcm
*pcm
)
1692 struct snd_soc_dai_driver
*dai_drv
;
1693 struct snd_soc_pcm_stream
*stream
;
1694 struct snd_soc_tplg_stream_caps
*caps
;
1695 struct snd_soc_dai
*dai
;
1696 struct snd_soc_dapm_context
*dapm
=
1697 snd_soc_component_get_dapm(tplg
->comp
);
1700 dai_drv
= devm_kzalloc(tplg
->dev
, sizeof(struct snd_soc_dai_driver
), GFP_KERNEL
);
1701 if (dai_drv
== NULL
)
1704 if (strlen(pcm
->dai_name
)) {
1705 dai_drv
->name
= devm_kstrdup(tplg
->dev
, pcm
->dai_name
, GFP_KERNEL
);
1706 if (!dai_drv
->name
) {
1711 dai_drv
->id
= le32_to_cpu(pcm
->dai_id
);
1713 if (pcm
->playback
) {
1714 stream
= &dai_drv
->playback
;
1715 caps
= &pcm
->caps
[SND_SOC_TPLG_STREAM_PLAYBACK
];
1716 ret
= set_stream_info(tplg
, stream
, caps
);
1722 stream
= &dai_drv
->capture
;
1723 caps
= &pcm
->caps
[SND_SOC_TPLG_STREAM_CAPTURE
];
1724 ret
= set_stream_info(tplg
, stream
, caps
);
1730 dai_drv
->compress_new
= snd_soc_new_compress
;
1732 /* pass control to component driver for optional further init */
1733 ret
= soc_tplg_dai_load(tplg
, dai_drv
, pcm
, NULL
);
1735 dev_err(tplg
->dev
, "ASoC: DAI loading failed\n");
1739 dai_drv
->dobj
.index
= tplg
->index
;
1740 dai_drv
->dobj
.ops
= tplg
->ops
;
1741 dai_drv
->dobj
.type
= SND_SOC_DOBJ_PCM
;
1742 list_add(&dai_drv
->dobj
.list
, &tplg
->comp
->dobj_list
);
1744 /* register the DAI to the component */
1745 dai
= snd_soc_register_dai(tplg
->comp
, dai_drv
, false);
1749 /* Create the DAI widgets here */
1750 ret
= snd_soc_dapm_new_dai_widgets(dapm
, dai
);
1752 dev_err(dai
->dev
, "Failed to create DAI widgets %d\n", ret
);
1753 snd_soc_unregister_dai(dai
);
1763 static void set_link_flags(struct snd_soc_dai_link
*link
,
1764 unsigned int flag_mask
, unsigned int flags
)
1766 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES
)
1767 link
->symmetric_rate
=
1768 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES
? 1 : 0;
1770 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS
)
1771 link
->symmetric_channels
=
1772 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS
?
1775 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS
)
1776 link
->symmetric_sample_bits
=
1777 flags
& SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS
?
1780 if (flag_mask
& SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP
)
1781 link
->ignore_suspend
=
1782 flags
& SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP
?
1786 /* create the FE DAI link */
1787 static int soc_tplg_fe_link_create(struct soc_tplg
*tplg
,
1788 struct snd_soc_tplg_pcm
*pcm
)
1790 struct snd_soc_dai_link
*link
;
1791 struct snd_soc_dai_link_component
*dlc
;
1794 /* link + cpu + codec + platform */
1795 link
= devm_kzalloc(tplg
->dev
, sizeof(*link
) + (3 * sizeof(*dlc
)), GFP_KERNEL
);
1799 dlc
= (struct snd_soc_dai_link_component
*)(link
+ 1);
1801 link
->cpus
= &dlc
[0];
1802 link
->codecs
= &dlc
[1];
1803 link
->platforms
= &dlc
[2];
1806 link
->num_codecs
= 1;
1807 link
->num_platforms
= 1;
1809 link
->dobj
.index
= tplg
->index
;
1810 link
->dobj
.ops
= tplg
->ops
;
1811 link
->dobj
.type
= SND_SOC_DOBJ_DAI_LINK
;
1813 if (strlen(pcm
->pcm_name
)) {
1814 link
->name
= devm_kstrdup(tplg
->dev
, pcm
->pcm_name
, GFP_KERNEL
);
1815 link
->stream_name
= devm_kstrdup(tplg
->dev
, pcm
->pcm_name
, GFP_KERNEL
);
1816 if (!link
->name
|| !link
->stream_name
) {
1821 link
->id
= le32_to_cpu(pcm
->pcm_id
);
1823 if (strlen(pcm
->dai_name
)) {
1824 link
->cpus
->dai_name
= devm_kstrdup(tplg
->dev
, pcm
->dai_name
, GFP_KERNEL
);
1825 if (!link
->cpus
->dai_name
) {
1831 link
->codecs
->name
= "snd-soc-dummy";
1832 link
->codecs
->dai_name
= "snd-soc-dummy-dai";
1834 link
->platforms
->name
= "snd-soc-dummy";
1838 link
->dpcm_playback
= le32_to_cpu(pcm
->playback
);
1839 link
->dpcm_capture
= le32_to_cpu(pcm
->capture
);
1841 set_link_flags(link
,
1842 le32_to_cpu(pcm
->flag_mask
),
1843 le32_to_cpu(pcm
->flags
));
1845 /* pass control to component driver for optional further init */
1846 ret
= soc_tplg_dai_link_load(tplg
, link
, NULL
);
1848 dev_err(tplg
->dev
, "ASoC: FE link loading failed\n");
1852 ret
= snd_soc_add_pcm_runtime(tplg
->comp
->card
, link
);
1854 dev_err(tplg
->dev
, "ASoC: adding FE link failed\n");
1858 list_add(&link
->dobj
.list
, &tplg
->comp
->dobj_list
);
1865 /* create a FE DAI and DAI link from the PCM object */
1866 static int soc_tplg_pcm_create(struct soc_tplg
*tplg
,
1867 struct snd_soc_tplg_pcm
*pcm
)
1871 ret
= soc_tplg_dai_create(tplg
, pcm
);
1875 return soc_tplg_fe_link_create(tplg
, pcm
);
1878 /* copy stream caps from the old version 4 of source */
1879 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps
*dest
,
1880 struct snd_soc_tplg_stream_caps_v4
*src
)
1882 dest
->size
= cpu_to_le32(sizeof(*dest
));
1883 memcpy(dest
->name
, src
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
1884 dest
->formats
= src
->formats
;
1885 dest
->rates
= src
->rates
;
1886 dest
->rate_min
= src
->rate_min
;
1887 dest
->rate_max
= src
->rate_max
;
1888 dest
->channels_min
= src
->channels_min
;
1889 dest
->channels_max
= src
->channels_max
;
1890 dest
->periods_min
= src
->periods_min
;
1891 dest
->periods_max
= src
->periods_max
;
1892 dest
->period_size_min
= src
->period_size_min
;
1893 dest
->period_size_max
= src
->period_size_max
;
1894 dest
->buffer_size_min
= src
->buffer_size_min
;
1895 dest
->buffer_size_max
= src
->buffer_size_max
;
1899 * pcm_new_ver - Create the new version of PCM from the old version.
1900 * @tplg: topology context
1901 * @src: older version of pcm as a source
1902 * @pcm: latest version of pcm created from the source
1904 * Support from vesion 4. User should free the returned pcm manually.
1906 static int pcm_new_ver(struct soc_tplg
*tplg
,
1907 struct snd_soc_tplg_pcm
*src
,
1908 struct snd_soc_tplg_pcm
**pcm
)
1910 struct snd_soc_tplg_pcm
*dest
;
1911 struct snd_soc_tplg_pcm_v4
*src_v4
;
1916 if (le32_to_cpu(src
->size
) != sizeof(*src_v4
)) {
1917 dev_err(tplg
->dev
, "ASoC: invalid PCM size\n");
1921 dev_warn(tplg
->dev
, "ASoC: old version of PCM\n");
1922 src_v4
= (struct snd_soc_tplg_pcm_v4
*)src
;
1923 dest
= kzalloc(sizeof(*dest
), GFP_KERNEL
);
1927 dest
->size
= cpu_to_le32(sizeof(*dest
)); /* size of latest abi version */
1928 memcpy(dest
->pcm_name
, src_v4
->pcm_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
1929 memcpy(dest
->dai_name
, src_v4
->dai_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
1930 dest
->pcm_id
= src_v4
->pcm_id
;
1931 dest
->dai_id
= src_v4
->dai_id
;
1932 dest
->playback
= src_v4
->playback
;
1933 dest
->capture
= src_v4
->capture
;
1934 dest
->compress
= src_v4
->compress
;
1935 dest
->num_streams
= src_v4
->num_streams
;
1936 for (i
= 0; i
< le32_to_cpu(dest
->num_streams
); i
++)
1937 memcpy(&dest
->stream
[i
], &src_v4
->stream
[i
],
1938 sizeof(struct snd_soc_tplg_stream
));
1940 for (i
= 0; i
< 2; i
++)
1941 stream_caps_new_ver(&dest
->caps
[i
], &src_v4
->caps
[i
]);
1947 static int soc_tplg_pcm_elems_load(struct soc_tplg
*tplg
,
1948 struct snd_soc_tplg_hdr
*hdr
)
1950 struct snd_soc_tplg_pcm
*pcm
, *_pcm
;
1957 count
= le32_to_cpu(hdr
->count
);
1959 /* check the element size and count */
1960 pcm
= (struct snd_soc_tplg_pcm
*)tplg
->pos
;
1961 size
= le32_to_cpu(pcm
->size
);
1962 if (size
> sizeof(struct snd_soc_tplg_pcm
)
1963 || size
< sizeof(struct snd_soc_tplg_pcm_v4
)) {
1964 dev_err(tplg
->dev
, "ASoC: invalid size %d for PCM elems\n",
1969 if (soc_tplg_check_elem_count(tplg
,
1971 le32_to_cpu(hdr
->payload_size
),
1973 dev_err(tplg
->dev
, "ASoC: invalid count %d for PCM DAI elems\n",
1978 for (i
= 0; i
< count
; i
++) {
1979 pcm
= (struct snd_soc_tplg_pcm
*)tplg
->pos
;
1980 size
= le32_to_cpu(pcm
->size
);
1982 /* check ABI version by size, create a new version of pcm
1985 if (size
== sizeof(*pcm
)) {
1990 ret
= pcm_new_ver(tplg
, pcm
, &_pcm
);
1995 /* create the FE DAIs and DAI links */
1996 ret
= soc_tplg_pcm_create(tplg
, _pcm
);
2003 /* offset by version-specific struct size and
2004 * real priv data size
2006 tplg
->pos
+= size
+ le32_to_cpu(_pcm
->priv
.size
);
2009 kfree(_pcm
); /* free the duplicated one */
2012 dev_dbg(tplg
->dev
, "ASoC: adding %d PCM DAIs\n", count
);
2018 * set_link_hw_format - Set the HW audio format of the physical DAI link.
2019 * @link: &snd_soc_dai_link which should be updated
2020 * @cfg: physical link configs.
2022 * Topology context contains a list of supported HW formats (configs) and
2023 * a default format ID for the physical link. This function will use this
2024 * default ID to choose the HW format to set the link's DAI format for init.
2026 static void set_link_hw_format(struct snd_soc_dai_link
*link
,
2027 struct snd_soc_tplg_link_config
*cfg
)
2029 struct snd_soc_tplg_hw_config
*hw_config
;
2030 unsigned char bclk_provider
, fsync_provider
;
2031 unsigned char invert_bclk
, invert_fsync
;
2034 for (i
= 0; i
< le32_to_cpu(cfg
->num_hw_configs
); i
++) {
2035 hw_config
= &cfg
->hw_config
[i
];
2036 if (hw_config
->id
!= cfg
->default_hw_config_id
)
2039 link
->dai_fmt
= le32_to_cpu(hw_config
->fmt
) &
2040 SND_SOC_DAIFMT_FORMAT_MASK
;
2043 switch (hw_config
->clock_gated
) {
2044 case SND_SOC_TPLG_DAI_CLK_GATE_GATED
:
2045 link
->dai_fmt
|= SND_SOC_DAIFMT_GATED
;
2048 case SND_SOC_TPLG_DAI_CLK_GATE_CONT
:
2049 link
->dai_fmt
|= SND_SOC_DAIFMT_CONT
;
2053 /* ignore the value */
2057 /* clock signal polarity */
2058 invert_bclk
= hw_config
->invert_bclk
;
2059 invert_fsync
= hw_config
->invert_fsync
;
2060 if (!invert_bclk
&& !invert_fsync
)
2061 link
->dai_fmt
|= SND_SOC_DAIFMT_NB_NF
;
2062 else if (!invert_bclk
&& invert_fsync
)
2063 link
->dai_fmt
|= SND_SOC_DAIFMT_NB_IF
;
2064 else if (invert_bclk
&& !invert_fsync
)
2065 link
->dai_fmt
|= SND_SOC_DAIFMT_IB_NF
;
2067 link
->dai_fmt
|= SND_SOC_DAIFMT_IB_IF
;
2070 bclk_provider
= (hw_config
->bclk_provider
==
2071 SND_SOC_TPLG_BCLK_CP
);
2072 fsync_provider
= (hw_config
->fsync_provider
==
2073 SND_SOC_TPLG_FSYNC_CP
);
2074 if (bclk_provider
&& fsync_provider
)
2075 link
->dai_fmt
|= SND_SOC_DAIFMT_CBP_CFP
;
2076 else if (!bclk_provider
&& fsync_provider
)
2077 link
->dai_fmt
|= SND_SOC_DAIFMT_CBC_CFP
;
2078 else if (bclk_provider
&& !fsync_provider
)
2079 link
->dai_fmt
|= SND_SOC_DAIFMT_CBP_CFC
;
2081 link
->dai_fmt
|= SND_SOC_DAIFMT_CBC_CFC
;
2086 * link_new_ver - Create a new physical link config from the old
2087 * version of source.
2088 * @tplg: topology context
2089 * @src: old version of phyical link config as a source
2090 * @link: latest version of physical link config created from the source
2092 * Support from vesion 4. User need free the returned link config manually.
2094 static int link_new_ver(struct soc_tplg
*tplg
,
2095 struct snd_soc_tplg_link_config
*src
,
2096 struct snd_soc_tplg_link_config
**link
)
2098 struct snd_soc_tplg_link_config
*dest
;
2099 struct snd_soc_tplg_link_config_v4
*src_v4
;
2104 if (le32_to_cpu(src
->size
) !=
2105 sizeof(struct snd_soc_tplg_link_config_v4
)) {
2106 dev_err(tplg
->dev
, "ASoC: invalid physical link config size\n");
2110 dev_warn(tplg
->dev
, "ASoC: old version of physical link config\n");
2112 src_v4
= (struct snd_soc_tplg_link_config_v4
*)src
;
2113 dest
= kzalloc(sizeof(*dest
), GFP_KERNEL
);
2117 dest
->size
= cpu_to_le32(sizeof(*dest
));
2118 dest
->id
= src_v4
->id
;
2119 dest
->num_streams
= src_v4
->num_streams
;
2120 for (i
= 0; i
< le32_to_cpu(dest
->num_streams
); i
++)
2121 memcpy(&dest
->stream
[i
], &src_v4
->stream
[i
],
2122 sizeof(struct snd_soc_tplg_stream
));
2129 * snd_soc_find_dai_link - Find a DAI link
2132 * @id: DAI link ID to match
2133 * @name: DAI link name to match, optional
2134 * @stream_name: DAI link stream name to match, optional
2136 * This function will search all existing DAI links of the soc card to
2137 * find the link of the same ID. Since DAI links may not have their
2138 * unique ID, so name and stream name should also match if being
2141 * Return: pointer of DAI link, or NULL if not found.
2143 static struct snd_soc_dai_link
*snd_soc_find_dai_link(struct snd_soc_card
*card
,
2144 int id
, const char *name
,
2145 const char *stream_name
)
2147 struct snd_soc_pcm_runtime
*rtd
;
2148 struct snd_soc_dai_link
*link
;
2150 for_each_card_rtds(card
, rtd
) {
2151 link
= rtd
->dai_link
;
2156 if (name
&& (!link
->name
|| strcmp(name
, link
->name
)))
2159 if (stream_name
&& (!link
->stream_name
2160 || strcmp(stream_name
, link
->stream_name
)))
2169 /* Find and configure an existing physical DAI link */
2170 static int soc_tplg_link_config(struct soc_tplg
*tplg
,
2171 struct snd_soc_tplg_link_config
*cfg
)
2173 struct snd_soc_dai_link
*link
;
2174 const char *name
, *stream_name
;
2178 len
= strnlen(cfg
->name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2179 if (len
== SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
2186 len
= strnlen(cfg
->stream_name
, SNDRV_CTL_ELEM_ID_NAME_MAXLEN
);
2187 if (len
== SNDRV_CTL_ELEM_ID_NAME_MAXLEN
)
2190 stream_name
= cfg
->stream_name
;
2194 link
= snd_soc_find_dai_link(tplg
->comp
->card
, le32_to_cpu(cfg
->id
),
2197 dev_err(tplg
->dev
, "ASoC: physical link %s (id %d) not exist\n",
2203 if (cfg
->num_hw_configs
)
2204 set_link_hw_format(link
, cfg
);
2208 set_link_flags(link
,
2209 le32_to_cpu(cfg
->flag_mask
),
2210 le32_to_cpu(cfg
->flags
));
2212 /* pass control to component driver for optional further init */
2213 ret
= soc_tplg_dai_link_load(tplg
, link
, cfg
);
2215 dev_err(tplg
->dev
, "ASoC: physical link loading failed\n");
2219 /* for unloading it in snd_soc_tplg_component_remove */
2220 link
->dobj
.index
= tplg
->index
;
2221 link
->dobj
.ops
= tplg
->ops
;
2222 link
->dobj
.type
= SND_SOC_DOBJ_BACKEND_LINK
;
2223 list_add(&link
->dobj
.list
, &tplg
->comp
->dobj_list
);
2229 /* Load physical link config elements from the topology context */
2230 static int soc_tplg_link_elems_load(struct soc_tplg
*tplg
,
2231 struct snd_soc_tplg_hdr
*hdr
)
2233 struct snd_soc_tplg_link_config
*link
, *_link
;
2239 count
= le32_to_cpu(hdr
->count
);
2241 /* check the element size and count */
2242 link
= (struct snd_soc_tplg_link_config
*)tplg
->pos
;
2243 size
= le32_to_cpu(link
->size
);
2244 if (size
> sizeof(struct snd_soc_tplg_link_config
)
2245 || size
< sizeof(struct snd_soc_tplg_link_config_v4
)) {
2246 dev_err(tplg
->dev
, "ASoC: invalid size %d for physical link elems\n",
2251 if (soc_tplg_check_elem_count(tplg
,
2253 le32_to_cpu(hdr
->payload_size
),
2254 "physical link config")) {
2255 dev_err(tplg
->dev
, "ASoC: invalid count %d for physical link elems\n",
2260 /* config physical DAI links */
2261 for (i
= 0; i
< count
; i
++) {
2262 link
= (struct snd_soc_tplg_link_config
*)tplg
->pos
;
2263 size
= le32_to_cpu(link
->size
);
2264 if (size
== sizeof(*link
)) {
2269 ret
= link_new_ver(tplg
, link
, &_link
);
2274 ret
= soc_tplg_link_config(tplg
, _link
);
2281 /* offset by version-specific struct size and
2282 * real priv data size
2284 tplg
->pos
+= size
+ le32_to_cpu(_link
->priv
.size
);
2287 kfree(_link
); /* free the duplicated one */
2294 * soc_tplg_dai_config - Find and configure an existing physical DAI.
2295 * @tplg: topology context
2296 * @d: physical DAI configs.
2298 * The physical dai should already be registered by the platform driver.
2299 * The platform driver should specify the DAI name and ID for matching.
2301 static int soc_tplg_dai_config(struct soc_tplg
*tplg
,
2302 struct snd_soc_tplg_dai
*d
)
2304 struct snd_soc_dai_link_component dai_component
;
2305 struct snd_soc_dai
*dai
;
2306 struct snd_soc_dai_driver
*dai_drv
;
2307 struct snd_soc_pcm_stream
*stream
;
2308 struct snd_soc_tplg_stream_caps
*caps
;
2311 memset(&dai_component
, 0, sizeof(dai_component
));
2313 dai_component
.dai_name
= d
->dai_name
;
2314 dai
= snd_soc_find_dai(&dai_component
);
2316 dev_err(tplg
->dev
, "ASoC: physical DAI %s not registered\n",
2321 if (le32_to_cpu(d
->dai_id
) != dai
->id
) {
2322 dev_err(tplg
->dev
, "ASoC: physical DAI %s id mismatch\n",
2327 dai_drv
= dai
->driver
;
2332 stream
= &dai_drv
->playback
;
2333 caps
= &d
->caps
[SND_SOC_TPLG_STREAM_PLAYBACK
];
2334 ret
= set_stream_info(tplg
, stream
, caps
);
2340 stream
= &dai_drv
->capture
;
2341 caps
= &d
->caps
[SND_SOC_TPLG_STREAM_CAPTURE
];
2342 ret
= set_stream_info(tplg
, stream
, caps
);
2348 set_dai_flags(dai_drv
,
2349 le32_to_cpu(d
->flag_mask
),
2350 le32_to_cpu(d
->flags
));
2352 /* pass control to component driver for optional further init */
2353 ret
= soc_tplg_dai_load(tplg
, dai_drv
, NULL
, dai
);
2355 dev_err(tplg
->dev
, "ASoC: DAI loading failed\n");
2365 /* load physical DAI elements */
2366 static int soc_tplg_dai_elems_load(struct soc_tplg
*tplg
,
2367 struct snd_soc_tplg_hdr
*hdr
)
2369 struct snd_soc_tplg_dai
*dai
;
2373 count
= le32_to_cpu(hdr
->count
);
2375 /* config the existing BE DAIs */
2376 for (i
= 0; i
< count
; i
++) {
2377 dai
= (struct snd_soc_tplg_dai
*)tplg
->pos
;
2378 if (le32_to_cpu(dai
->size
) != sizeof(*dai
)) {
2379 dev_err(tplg
->dev
, "ASoC: invalid physical DAI size\n");
2383 ret
= soc_tplg_dai_config(tplg
, dai
);
2385 dev_err(tplg
->dev
, "ASoC: failed to configure DAI\n");
2389 tplg
->pos
+= (sizeof(*dai
) + le32_to_cpu(dai
->priv
.size
));
2392 dev_dbg(tplg
->dev
, "ASoC: Configure %d BE DAIs\n", count
);
2397 * manifest_new_ver - Create a new version of manifest from the old version
2399 * @tplg: topology context
2400 * @src: old version of manifest as a source
2401 * @manifest: latest version of manifest created from the source
2403 * Support from vesion 4. Users need free the returned manifest manually.
2405 static int manifest_new_ver(struct soc_tplg
*tplg
,
2406 struct snd_soc_tplg_manifest
*src
,
2407 struct snd_soc_tplg_manifest
**manifest
)
2409 struct snd_soc_tplg_manifest
*dest
;
2410 struct snd_soc_tplg_manifest_v4
*src_v4
;
2415 size
= le32_to_cpu(src
->size
);
2416 if (size
!= sizeof(*src_v4
)) {
2417 dev_warn(tplg
->dev
, "ASoC: invalid manifest size %d\n",
2421 src
->size
= cpu_to_le32(sizeof(*src_v4
));
2424 dev_warn(tplg
->dev
, "ASoC: old version of manifest\n");
2426 src_v4
= (struct snd_soc_tplg_manifest_v4
*)src
;
2427 dest
= kzalloc(sizeof(*dest
) + le32_to_cpu(src_v4
->priv
.size
),
2432 dest
->size
= cpu_to_le32(sizeof(*dest
)); /* size of latest abi version */
2433 dest
->control_elems
= src_v4
->control_elems
;
2434 dest
->widget_elems
= src_v4
->widget_elems
;
2435 dest
->graph_elems
= src_v4
->graph_elems
;
2436 dest
->pcm_elems
= src_v4
->pcm_elems
;
2437 dest
->dai_link_elems
= src_v4
->dai_link_elems
;
2438 dest
->priv
.size
= src_v4
->priv
.size
;
2439 if (dest
->priv
.size
)
2440 memcpy(dest
->priv
.data
, src_v4
->priv
.data
,
2441 le32_to_cpu(src_v4
->priv
.size
));
2447 static int soc_tplg_manifest_load(struct soc_tplg
*tplg
,
2448 struct snd_soc_tplg_hdr
*hdr
)
2450 struct snd_soc_tplg_manifest
*manifest
, *_manifest
;
2454 manifest
= (struct snd_soc_tplg_manifest
*)tplg
->pos
;
2456 /* check ABI version by size, create a new manifest if abi not match */
2457 if (le32_to_cpu(manifest
->size
) == sizeof(*manifest
)) {
2459 _manifest
= manifest
;
2462 ret
= manifest_new_ver(tplg
, manifest
, &_manifest
);
2467 /* pass control to component driver for optional further init */
2468 if (tplg
->ops
&& tplg
->ops
->manifest
)
2469 ret
= tplg
->ops
->manifest(tplg
->comp
, tplg
->index
, _manifest
);
2471 if (!abi_match
) /* free the duplicated one */
2477 /* validate header magic, size and type */
2478 static int soc_valid_header(struct soc_tplg
*tplg
,
2479 struct snd_soc_tplg_hdr
*hdr
)
2481 if (soc_tplg_get_hdr_offset(tplg
) >= tplg
->fw
->size
)
2484 if (le32_to_cpu(hdr
->size
) != sizeof(*hdr
)) {
2486 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n",
2487 le32_to_cpu(hdr
->type
), soc_tplg_get_hdr_offset(tplg
),
2492 /* big endian firmware objects not supported atm */
2493 if (le32_to_cpu(hdr
->magic
) == SOC_TPLG_MAGIC_BIG_ENDIAN
) {
2495 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n",
2496 tplg
->pass
, hdr
->magic
,
2497 soc_tplg_get_hdr_offset(tplg
), tplg
->fw
->size
);
2501 if (le32_to_cpu(hdr
->magic
) != SND_SOC_TPLG_MAGIC
) {
2503 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n",
2504 tplg
->pass
, hdr
->magic
,
2505 soc_tplg_get_hdr_offset(tplg
), tplg
->fw
->size
);
2509 /* Support ABI from version 4 */
2510 if (le32_to_cpu(hdr
->abi
) > SND_SOC_TPLG_ABI_VERSION
||
2511 le32_to_cpu(hdr
->abi
) < SND_SOC_TPLG_ABI_VERSION_MIN
) {
2513 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n",
2514 tplg
->pass
, hdr
->abi
,
2515 SND_SOC_TPLG_ABI_VERSION
, soc_tplg_get_hdr_offset(tplg
),
2520 if (hdr
->payload_size
== 0) {
2521 dev_err(tplg
->dev
, "ASoC: header has 0 size at offset 0x%lx.\n",
2522 soc_tplg_get_hdr_offset(tplg
));
2529 /* check header type and call appropriate handler */
2530 static int soc_tplg_load_header(struct soc_tplg
*tplg
,
2531 struct snd_soc_tplg_hdr
*hdr
)
2533 int (*elem_load
)(struct soc_tplg
*tplg
,
2534 struct snd_soc_tplg_hdr
*hdr
);
2535 unsigned int hdr_pass
;
2537 tplg
->pos
= tplg
->hdr_pos
+ sizeof(struct snd_soc_tplg_hdr
);
2539 tplg
->index
= le32_to_cpu(hdr
->index
);
2541 switch (le32_to_cpu(hdr
->type
)) {
2542 case SND_SOC_TPLG_TYPE_MIXER
:
2543 case SND_SOC_TPLG_TYPE_ENUM
:
2544 case SND_SOC_TPLG_TYPE_BYTES
:
2545 hdr_pass
= SOC_TPLG_PASS_MIXER
;
2546 elem_load
= soc_tplg_kcontrol_elems_load
;
2548 case SND_SOC_TPLG_TYPE_DAPM_GRAPH
:
2549 hdr_pass
= SOC_TPLG_PASS_GRAPH
;
2550 elem_load
= soc_tplg_dapm_graph_elems_load
;
2552 case SND_SOC_TPLG_TYPE_DAPM_WIDGET
:
2553 hdr_pass
= SOC_TPLG_PASS_WIDGET
;
2554 elem_load
= soc_tplg_dapm_widget_elems_load
;
2556 case SND_SOC_TPLG_TYPE_PCM
:
2557 hdr_pass
= SOC_TPLG_PASS_PCM_DAI
;
2558 elem_load
= soc_tplg_pcm_elems_load
;
2560 case SND_SOC_TPLG_TYPE_DAI
:
2561 hdr_pass
= SOC_TPLG_PASS_BE_DAI
;
2562 elem_load
= soc_tplg_dai_elems_load
;
2564 case SND_SOC_TPLG_TYPE_DAI_LINK
:
2565 case SND_SOC_TPLG_TYPE_BACKEND_LINK
:
2566 /* physical link configurations */
2567 hdr_pass
= SOC_TPLG_PASS_LINK
;
2568 elem_load
= soc_tplg_link_elems_load
;
2570 case SND_SOC_TPLG_TYPE_MANIFEST
:
2571 hdr_pass
= SOC_TPLG_PASS_MANIFEST
;
2572 elem_load
= soc_tplg_manifest_load
;
2575 /* bespoke vendor data object */
2576 hdr_pass
= SOC_TPLG_PASS_VENDOR
;
2577 elem_load
= soc_tplg_vendor_load
;
2581 if (tplg
->pass
== hdr_pass
) {
2583 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n",
2584 hdr
->payload_size
, hdr
->type
, hdr
->version
,
2585 hdr
->vendor_type
, tplg
->pass
);
2586 return elem_load(tplg
, hdr
);
2592 /* process the topology file headers */
2593 static int soc_tplg_process_headers(struct soc_tplg
*tplg
)
2595 struct snd_soc_tplg_hdr
*hdr
;
2598 tplg
->pass
= SOC_TPLG_PASS_START
;
2600 /* process the header types from start to end */
2601 while (tplg
->pass
<= SOC_TPLG_PASS_END
) {
2603 tplg
->hdr_pos
= tplg
->fw
->data
;
2604 hdr
= (struct snd_soc_tplg_hdr
*)tplg
->hdr_pos
;
2606 while (!soc_tplg_is_eof(tplg
)) {
2608 /* make sure header is valid before loading */
2609 ret
= soc_valid_header(tplg
, hdr
);
2612 "ASoC: topology: invalid header: %d\n", ret
);
2614 } else if (ret
== 0) {
2618 /* load the header object */
2619 ret
= soc_tplg_load_header(tplg
, hdr
);
2622 "ASoC: topology: could not load header: %d\n", ret
);
2626 /* goto next header */
2627 tplg
->hdr_pos
+= le32_to_cpu(hdr
->payload_size
) +
2628 sizeof(struct snd_soc_tplg_hdr
);
2629 hdr
= (struct snd_soc_tplg_hdr
*)tplg
->hdr_pos
;
2632 /* next data type pass */
2636 /* signal DAPM we are complete */
2637 ret
= soc_tplg_dapm_complete(tplg
);
2640 "ASoC: failed to initialise DAPM from Firmware\n");
2645 static int soc_tplg_load(struct soc_tplg
*tplg
)
2649 ret
= soc_tplg_process_headers(tplg
);
2651 soc_tplg_complete(tplg
);
2656 /* load audio component topology from "firmware" file */
2657 int snd_soc_tplg_component_load(struct snd_soc_component
*comp
,
2658 struct snd_soc_tplg_ops
*ops
, const struct firmware
*fw
)
2660 struct soc_tplg tplg
;
2664 * check if we have sane parameters:
2665 * comp - needs to exist to keep and reference data while parsing
2666 * comp->dev - used for resource management and prints
2667 * comp->card - used for setting card related parameters
2668 * fw - we need it, as it is the very thing we parse
2670 if (!comp
|| !comp
->dev
|| !comp
->card
|| !fw
)
2673 /* setup parsing context */
2674 memset(&tplg
, 0, sizeof(tplg
));
2676 tplg
.dev
= comp
->dev
;
2680 tplg
.io_ops
= ops
->io_ops
;
2681 tplg
.io_ops_count
= ops
->io_ops_count
;
2682 tplg
.bytes_ext_ops
= ops
->bytes_ext_ops
;
2683 tplg
.bytes_ext_ops_count
= ops
->bytes_ext_ops_count
;
2686 ret
= soc_tplg_load(&tplg
);
2687 /* free the created components if fail to load topology */
2689 snd_soc_tplg_component_remove(comp
);
2693 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load
);
2695 /* remove dynamic controls from the component driver */
2696 int snd_soc_tplg_component_remove(struct snd_soc_component
*comp
)
2698 struct snd_soc_dobj
*dobj
, *next_dobj
;
2699 int pass
= SOC_TPLG_PASS_END
;
2701 /* process the header types from end to start */
2702 while (pass
>= SOC_TPLG_PASS_START
) {
2704 /* remove mixer controls */
2705 list_for_each_entry_safe(dobj
, next_dobj
, &comp
->dobj_list
,
2708 switch (dobj
->type
) {
2709 case SND_SOC_DOBJ_MIXER
:
2710 remove_mixer(comp
, dobj
, pass
);
2712 case SND_SOC_DOBJ_ENUM
:
2713 remove_enum(comp
, dobj
, pass
);
2715 case SND_SOC_DOBJ_BYTES
:
2716 remove_bytes(comp
, dobj
, pass
);
2718 case SND_SOC_DOBJ_GRAPH
:
2719 remove_route(comp
, dobj
, pass
);
2721 case SND_SOC_DOBJ_WIDGET
:
2722 remove_widget(comp
, dobj
, pass
);
2724 case SND_SOC_DOBJ_PCM
:
2725 remove_dai(comp
, dobj
, pass
);
2727 case SND_SOC_DOBJ_DAI_LINK
:
2728 remove_link(comp
, dobj
, pass
);
2730 case SND_SOC_DOBJ_BACKEND_LINK
:
2732 * call link_unload ops if extra
2733 * deinitialization is needed.
2735 remove_backend_link(comp
, dobj
, pass
);
2738 dev_err(comp
->dev
, "ASoC: invalid component type %d for removal\n",
2746 /* let caller know if FW can be freed when no objects are left */
2747 return !list_empty(&comp
->dobj_list
);
2749 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove
);