2 * soc-topology.c -- ALSA SoC Topology
4 * Copyright (C) 2012 Texas Instruments Inc.
5 * Copyright (C) 2015 Intel Corporation.
7 * Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com>
8 * K, Mythri P <mythri.p.k@intel.com>
9 * Prusty, Subhransu S <subhransu.s.prusty@intel.com>
10 * B, Jayachandran <jayachandran.b@intel.com>
11 * Abdullah, Omair M <omair.m.abdullah@intel.com>
12 * Jin, Yao <yao.jin@intel.com>
13 * Lin, Mengdong <mengdong.lin@intel.com>
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 2 of the License, or (at your
18 * option) any later version.
20 * Add support to read audio firmware topology alongside firmware text. The
21 * topology data can contain kcontrols, DAPM graphs, widgets, DAIs, DAI links,
22 * equalizers, firmware, coefficients etc.
24 * This file only manages the core ALSA and ASoC components, all other bespoke
25 * firmware topology data is passed to component drivers for bespoke handling.
28 #include <linux/kernel.h>
29 #include <linux/export.h>
30 #include <linux/list.h>
31 #include <linux/firmware.h>
32 #include <linux/slab.h>
33 #include <sound/soc.h>
34 #include <sound/soc-dapm.h>
35 #include <sound/soc-topology.h>
36 #include <sound/tlv.h>
39 * We make several passes over the data (since it wont necessarily be ordered)
40 * and process objects in the following order. This guarantees the component
41 * drivers will be ready with any vendor data before the mixers and DAPM objects
42 * are loaded (that may make use of the vendor data).
44 #define SOC_TPLG_PASS_MANIFEST 0
45 #define SOC_TPLG_PASS_VENDOR 1
46 #define SOC_TPLG_PASS_MIXER 2
47 #define SOC_TPLG_PASS_WIDGET 3
48 #define SOC_TPLG_PASS_PCM_DAI 4
49 #define SOC_TPLG_PASS_GRAPH 5
50 #define SOC_TPLG_PASS_PINS 6
52 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST
53 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_PINS
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 struct snd_soc_dapm_widget *
84 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
85 const struct snd_soc_dapm_widget *widget);
86 struct snd_soc_dapm_widget *
87 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
88 const struct snd_soc_dapm_widget *widget);
90 /* check we dont overflow the data for this control chunk */
91 static int soc_tplg_check_elem_count(struct soc_tplg *tplg, size_t elem_size,
92 unsigned int count, size_t bytes, const char *elem_type)
94 const u8 *end = tplg->pos + elem_size * count;
96 if (end > tplg->fw->data + tplg->fw->size) {
97 dev_err(tplg->dev, "ASoC: %s overflow end of data\n",
102 /* check there is enough room in chunk for control.
103 extra bytes at the end of control are for vendor data here */
104 if (elem_size * count > bytes) {
106 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
107 elem_type, count, elem_size, bytes);
114 static inline int soc_tplg_is_eof(struct soc_tplg *tplg)
116 const u8 *end = tplg->hdr_pos;
118 if (end >= tplg->fw->data + tplg->fw->size)
123 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg)
125 return (unsigned long)(tplg->hdr_pos - tplg->fw->data);
128 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg)
130 return (unsigned long)(tplg->pos - tplg->fw->data);
133 /* mapping of Kcontrol types and associated operations. */
134 static const struct snd_soc_tplg_kcontrol_ops io_ops[] = {
135 {SND_SOC_TPLG_CTL_VOLSW, snd_soc_get_volsw,
136 snd_soc_put_volsw, snd_soc_info_volsw},
137 {SND_SOC_TPLG_CTL_VOLSW_SX, snd_soc_get_volsw_sx,
138 snd_soc_put_volsw_sx, NULL},
139 {SND_SOC_TPLG_CTL_ENUM, snd_soc_get_enum_double,
140 snd_soc_put_enum_double, snd_soc_info_enum_double},
141 {SND_SOC_TPLG_CTL_ENUM_VALUE, snd_soc_get_enum_double,
142 snd_soc_put_enum_double, NULL},
143 {SND_SOC_TPLG_CTL_BYTES, snd_soc_bytes_get,
144 snd_soc_bytes_put, snd_soc_bytes_info},
145 {SND_SOC_TPLG_CTL_RANGE, snd_soc_get_volsw_range,
146 snd_soc_put_volsw_range, snd_soc_info_volsw_range},
147 {SND_SOC_TPLG_CTL_VOLSW_XR_SX, snd_soc_get_xr_sx,
148 snd_soc_put_xr_sx, snd_soc_info_xr_sx},
149 {SND_SOC_TPLG_CTL_STROBE, snd_soc_get_strobe,
150 snd_soc_put_strobe, NULL},
151 {SND_SOC_TPLG_DAPM_CTL_VOLSW, snd_soc_dapm_get_volsw,
152 snd_soc_dapm_put_volsw, snd_soc_info_volsw},
153 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE, snd_soc_dapm_get_enum_double,
154 snd_soc_dapm_put_enum_double, snd_soc_info_enum_double},
155 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT, snd_soc_dapm_get_enum_double,
156 snd_soc_dapm_put_enum_double, NULL},
157 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE, snd_soc_dapm_get_enum_double,
158 snd_soc_dapm_put_enum_double, NULL},
159 {SND_SOC_TPLG_DAPM_CTL_PIN, snd_soc_dapm_get_pin_switch,
160 snd_soc_dapm_put_pin_switch, snd_soc_dapm_info_pin_switch},
163 struct soc_tplg_map {
168 /* mapping of widget types from UAPI IDs to kernel IDs */
169 static const struct soc_tplg_map dapm_map[] = {
170 {SND_SOC_TPLG_DAPM_INPUT, snd_soc_dapm_input},
171 {SND_SOC_TPLG_DAPM_OUTPUT, snd_soc_dapm_output},
172 {SND_SOC_TPLG_DAPM_MUX, snd_soc_dapm_mux},
173 {SND_SOC_TPLG_DAPM_MIXER, snd_soc_dapm_mixer},
174 {SND_SOC_TPLG_DAPM_PGA, snd_soc_dapm_pga},
175 {SND_SOC_TPLG_DAPM_OUT_DRV, snd_soc_dapm_out_drv},
176 {SND_SOC_TPLG_DAPM_ADC, snd_soc_dapm_adc},
177 {SND_SOC_TPLG_DAPM_DAC, snd_soc_dapm_dac},
178 {SND_SOC_TPLG_DAPM_SWITCH, snd_soc_dapm_switch},
179 {SND_SOC_TPLG_DAPM_PRE, snd_soc_dapm_pre},
180 {SND_SOC_TPLG_DAPM_POST, snd_soc_dapm_post},
181 {SND_SOC_TPLG_DAPM_AIF_IN, snd_soc_dapm_aif_in},
182 {SND_SOC_TPLG_DAPM_AIF_OUT, snd_soc_dapm_aif_out},
183 {SND_SOC_TPLG_DAPM_DAI_IN, snd_soc_dapm_dai_in},
184 {SND_SOC_TPLG_DAPM_DAI_OUT, snd_soc_dapm_dai_out},
185 {SND_SOC_TPLG_DAPM_DAI_LINK, snd_soc_dapm_dai_link},
188 static int tplc_chan_get_reg(struct soc_tplg *tplg,
189 struct snd_soc_tplg_channel *chan, int map)
193 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
194 if (chan[i].id == map)
201 static int tplc_chan_get_shift(struct soc_tplg *tplg,
202 struct snd_soc_tplg_channel *chan, int map)
206 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
207 if (chan[i].id == map)
208 return chan[i].shift;
214 static int get_widget_id(int tplg_type)
218 for (i = 0; i < ARRAY_SIZE(dapm_map); i++) {
219 if (tplg_type == dapm_map[i].uid)
220 return dapm_map[i].kid;
226 static enum snd_soc_dobj_type get_dobj_mixer_type(
227 struct snd_soc_tplg_ctl_hdr *control_hdr)
229 if (control_hdr == NULL)
230 return SND_SOC_DOBJ_NONE;
232 switch (control_hdr->ops.info) {
233 case SND_SOC_TPLG_CTL_VOLSW:
234 case SND_SOC_TPLG_CTL_VOLSW_SX:
235 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
236 case SND_SOC_TPLG_CTL_RANGE:
237 case SND_SOC_TPLG_CTL_STROBE:
238 return SND_SOC_DOBJ_MIXER;
239 case SND_SOC_TPLG_CTL_ENUM:
240 case SND_SOC_TPLG_CTL_ENUM_VALUE:
241 return SND_SOC_DOBJ_ENUM;
242 case SND_SOC_TPLG_CTL_BYTES:
243 return SND_SOC_DOBJ_BYTES;
245 return SND_SOC_DOBJ_NONE;
249 static enum snd_soc_dobj_type get_dobj_type(struct snd_soc_tplg_hdr *hdr,
250 struct snd_soc_tplg_ctl_hdr *control_hdr)
253 case SND_SOC_TPLG_TYPE_MIXER:
254 return get_dobj_mixer_type(control_hdr);
255 case SND_SOC_TPLG_TYPE_DAPM_GRAPH:
256 case SND_SOC_TPLG_TYPE_MANIFEST:
257 return SND_SOC_DOBJ_NONE;
258 case SND_SOC_TPLG_TYPE_DAPM_WIDGET:
259 return SND_SOC_DOBJ_WIDGET;
260 case SND_SOC_TPLG_TYPE_DAI_LINK:
261 return SND_SOC_DOBJ_DAI_LINK;
262 case SND_SOC_TPLG_TYPE_PCM:
263 return SND_SOC_DOBJ_PCM;
264 case SND_SOC_TPLG_TYPE_CODEC_LINK:
265 return SND_SOC_DOBJ_CODEC_LINK;
267 return SND_SOC_DOBJ_NONE;
271 static inline void soc_bind_err(struct soc_tplg *tplg,
272 struct snd_soc_tplg_ctl_hdr *hdr, int index)
275 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n",
276 hdr->ops.get, hdr->ops.put, hdr->ops.info, index,
277 soc_tplg_get_offset(tplg));
280 static inline void soc_control_err(struct soc_tplg *tplg,
281 struct snd_soc_tplg_ctl_hdr *hdr, const char *name)
284 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n",
285 name, hdr->ops.get, hdr->ops.put, hdr->ops.info,
286 soc_tplg_get_offset(tplg));
289 /* pass vendor data to component driver for processing */
290 static int soc_tplg_vendor_load_(struct soc_tplg *tplg,
291 struct snd_soc_tplg_hdr *hdr)
295 if (tplg->comp && tplg->ops && tplg->ops->vendor_load)
296 ret = tplg->ops->vendor_load(tplg->comp, hdr);
298 dev_err(tplg->dev, "ASoC: no vendor load callback for ID %d\n",
305 "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n",
306 soc_tplg_get_hdr_offset(tplg),
307 soc_tplg_get_hdr_offset(tplg),
308 hdr->type, hdr->vendor_type);
312 /* pass vendor data to component driver for processing */
313 static int soc_tplg_vendor_load(struct soc_tplg *tplg,
314 struct snd_soc_tplg_hdr *hdr)
316 if (tplg->pass != SOC_TPLG_PASS_VENDOR)
319 return soc_tplg_vendor_load_(tplg, hdr);
322 /* optionally pass new dynamic widget to component driver. This is mainly for
323 * external widgets where we can assign private data/ops */
324 static int soc_tplg_widget_load(struct soc_tplg *tplg,
325 struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w)
327 if (tplg->comp && tplg->ops && tplg->ops->widget_load)
328 return tplg->ops->widget_load(tplg->comp, w, tplg_w);
333 /* pass dynamic FEs configurations to component driver */
334 static int soc_tplg_pcm_dai_load(struct soc_tplg *tplg,
335 struct snd_soc_tplg_pcm_dai *pcm_dai, int num_pcm_dai)
337 if (tplg->comp && tplg->ops && tplg->ops->pcm_dai_load)
338 return tplg->ops->pcm_dai_load(tplg->comp, pcm_dai, num_pcm_dai);
343 /* tell the component driver that all firmware has been loaded in this request */
344 static void soc_tplg_complete(struct soc_tplg *tplg)
346 if (tplg->comp && tplg->ops && tplg->ops->complete)
347 tplg->ops->complete(tplg->comp);
350 /* add a dynamic kcontrol */
351 static int soc_tplg_add_dcontrol(struct snd_card *card, struct device *dev,
352 const struct snd_kcontrol_new *control_new, const char *prefix,
353 void *data, struct snd_kcontrol **kcontrol)
357 *kcontrol = snd_soc_cnew(control_new, data, control_new->name, prefix);
358 if (*kcontrol == NULL) {
359 dev_err(dev, "ASoC: Failed to create new kcontrol %s\n",
364 err = snd_ctl_add(card, *kcontrol);
366 dev_err(dev, "ASoC: Failed to add %s: %d\n",
367 control_new->name, err);
374 /* add a dynamic kcontrol for component driver */
375 static int soc_tplg_add_kcontrol(struct soc_tplg *tplg,
376 struct snd_kcontrol_new *k, struct snd_kcontrol **kcontrol)
378 struct snd_soc_component *comp = tplg->comp;
380 return soc_tplg_add_dcontrol(comp->card->snd_card,
381 comp->dev, k, NULL, comp, kcontrol);
384 /* remove a mixer kcontrol */
385 static void remove_mixer(struct snd_soc_component *comp,
386 struct snd_soc_dobj *dobj, int pass)
388 struct snd_card *card = comp->card->snd_card;
389 struct soc_mixer_control *sm =
390 container_of(dobj, struct soc_mixer_control, dobj);
391 const unsigned int *p = NULL;
393 if (pass != SOC_TPLG_PASS_MIXER)
396 if (dobj->ops && dobj->ops->control_unload)
397 dobj->ops->control_unload(comp, dobj);
399 if (sm->dobj.control.kcontrol->tlv.p)
400 p = sm->dobj.control.kcontrol->tlv.p;
401 snd_ctl_remove(card, sm->dobj.control.kcontrol);
402 list_del(&sm->dobj.list);
407 /* remove an enum kcontrol */
408 static void remove_enum(struct snd_soc_component *comp,
409 struct snd_soc_dobj *dobj, int pass)
411 struct snd_card *card = comp->card->snd_card;
412 struct soc_enum *se = container_of(dobj, struct soc_enum, dobj);
415 if (pass != SOC_TPLG_PASS_MIXER)
418 if (dobj->ops && dobj->ops->control_unload)
419 dobj->ops->control_unload(comp, dobj);
421 snd_ctl_remove(card, se->dobj.control.kcontrol);
422 list_del(&se->dobj.list);
424 kfree(se->dobj.control.dvalues);
425 for (i = 0; i < se->items; i++)
426 kfree(se->dobj.control.dtexts[i]);
430 /* remove a byte kcontrol */
431 static void remove_bytes(struct snd_soc_component *comp,
432 struct snd_soc_dobj *dobj, int pass)
434 struct snd_card *card = comp->card->snd_card;
435 struct soc_bytes_ext *sb =
436 container_of(dobj, struct soc_bytes_ext, dobj);
438 if (pass != SOC_TPLG_PASS_MIXER)
441 if (dobj->ops && dobj->ops->control_unload)
442 dobj->ops->control_unload(comp, dobj);
444 snd_ctl_remove(card, sb->dobj.control.kcontrol);
445 list_del(&sb->dobj.list);
449 /* remove a widget and it's kcontrols - routes must be removed first */
450 static void remove_widget(struct snd_soc_component *comp,
451 struct snd_soc_dobj *dobj, int pass)
453 struct snd_card *card = comp->card->snd_card;
454 struct snd_soc_dapm_widget *w =
455 container_of(dobj, struct snd_soc_dapm_widget, dobj);
458 if (pass != SOC_TPLG_PASS_WIDGET)
461 if (dobj->ops && dobj->ops->widget_unload)
462 dobj->ops->widget_unload(comp, dobj);
465 * Dynamic Widgets either have 1 enum kcontrol or 1..N mixers.
466 * The enum may either have an array of values or strings.
468 if (dobj->widget.kcontrol_enum) {
469 /* enumerated widget mixer */
470 struct soc_enum *se =
471 (struct soc_enum *)w->kcontrols[0]->private_value;
473 snd_ctl_remove(card, w->kcontrols[0]);
475 kfree(se->dobj.control.dvalues);
476 for (i = 0; i < se->items; i++)
477 kfree(se->dobj.control.dtexts[i]);
480 kfree(w->kcontrol_news);
482 /* non enumerated widget mixer */
483 for (i = 0; i < w->num_kcontrols; i++) {
484 struct snd_kcontrol *kcontrol = w->kcontrols[i];
485 struct soc_mixer_control *sm =
486 (struct soc_mixer_control *) kcontrol->private_value;
488 kfree(w->kcontrols[i]->tlv.p);
490 snd_ctl_remove(card, w->kcontrols[i]);
493 kfree(w->kcontrol_news);
495 /* widget w is freed by soc-dapm.c */
498 /* remove PCM DAI configurations */
499 static void remove_pcm_dai(struct snd_soc_component *comp,
500 struct snd_soc_dobj *dobj, int pass)
502 if (pass != SOC_TPLG_PASS_PCM_DAI)
505 if (dobj->ops && dobj->ops->pcm_dai_unload)
506 dobj->ops->pcm_dai_unload(comp, dobj);
508 list_del(&dobj->list);
512 /* bind a kcontrol to it's IO handlers */
513 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr *hdr,
514 struct snd_kcontrol_new *k,
515 const struct soc_tplg *tplg)
517 const struct snd_soc_tplg_kcontrol_ops *ops;
518 const struct snd_soc_tplg_bytes_ext_ops *ext_ops;
521 if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES
522 && k->iface & SNDRV_CTL_ELEM_IFACE_MIXER
523 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
524 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
525 struct soc_bytes_ext *sbe;
526 struct snd_soc_tplg_bytes_control *be;
528 sbe = (struct soc_bytes_ext *)k->private_value;
529 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
531 /* TLV bytes controls need standard kcontrol info handler,
532 * TLV callback and extended put/get handlers.
534 k->info = snd_soc_bytes_info;
535 k->tlv.c = snd_soc_bytes_tlv_callback;
537 ext_ops = tplg->bytes_ext_ops;
538 num_ops = tplg->bytes_ext_ops_count;
539 for (i = 0; i < num_ops; i++) {
540 if (!sbe->put && ext_ops[i].id == be->ext_ops.put)
541 sbe->put = ext_ops[i].put;
542 if (!sbe->get && ext_ops[i].id == be->ext_ops.get)
543 sbe->get = ext_ops[i].get;
546 if (sbe->put && sbe->get)
552 /* try and map vendor specific kcontrol handlers first */
554 num_ops = tplg->io_ops_count;
555 for (i = 0; i < num_ops; i++) {
557 if (k->put == NULL && ops[i].id == hdr->ops.put)
559 if (k->get == NULL && ops[i].id == hdr->ops.get)
561 if (k->info == NULL && ops[i].id == hdr->ops.info)
562 k->info = ops[i].info;
565 /* vendor specific handlers found ? */
566 if (k->put && k->get && k->info)
569 /* none found so try standard kcontrol handlers */
571 num_ops = ARRAY_SIZE(io_ops);
572 for (i = 0; i < num_ops; i++) {
574 if (k->put == NULL && ops[i].id == hdr->ops.put)
576 if (k->get == NULL && ops[i].id == hdr->ops.get)
578 if (k->info == NULL && ops[i].id == hdr->ops.info)
579 k->info = ops[i].info;
582 /* standard handlers found ? */
583 if (k->put && k->get && k->info)
586 /* nothing to bind */
590 /* bind a widgets to it's evnt handlers */
591 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w,
592 const struct snd_soc_tplg_widget_events *events,
593 int num_events, u16 event_type)
599 for (i = 0; i < num_events; i++) {
600 if (event_type == events[i].type) {
602 /* found - so assign event */
603 w->event = events[i].event_handler;
611 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event);
613 /* optionally pass new dynamic kcontrol to component driver. */
614 static int soc_tplg_init_kcontrol(struct soc_tplg *tplg,
615 struct snd_kcontrol_new *k, struct snd_soc_tplg_ctl_hdr *hdr)
617 if (tplg->comp && tplg->ops && tplg->ops->control_load)
618 return tplg->ops->control_load(tplg->comp, k, hdr);
624 static int soc_tplg_create_tlv_db_scale(struct soc_tplg *tplg,
625 struct snd_kcontrol_new *kc, struct snd_soc_tplg_tlv_dbscale *scale)
627 unsigned int item_len = 2 * sizeof(unsigned int);
630 p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL);
634 p[0] = SNDRV_CTL_TLVT_DB_SCALE;
637 p[3] = (scale->step & TLV_DB_SCALE_MASK)
638 | (scale->mute ? TLV_DB_SCALE_MUTE : 0);
640 kc->tlv.p = (void *)p;
644 static int soc_tplg_create_tlv(struct soc_tplg *tplg,
645 struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc)
647 struct snd_soc_tplg_ctl_tlv *tplg_tlv;
649 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE))
652 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) {
654 switch (tplg_tlv->type) {
655 case SNDRV_CTL_TLVT_DB_SCALE:
656 return soc_tplg_create_tlv_db_scale(tplg, kc,
659 /* TODO: add support for other TLV types */
661 dev_dbg(tplg->dev, "Unsupported TLV type %d\n",
670 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg,
671 struct snd_kcontrol_new *kc)
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;
684 if (soc_tplg_check_elem_count(tplg,
685 sizeof(struct snd_soc_tplg_bytes_control), count,
686 size, "mixer bytes")) {
687 dev_err(tplg->dev, "ASoC: Invalid count %d for byte control\n",
692 for (i = 0; i < count; i++) {
693 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
695 /* validate kcontrol */
696 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
697 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
700 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
704 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
708 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
709 be->hdr.name, be->hdr.access);
711 memset(&kc, 0, sizeof(kc));
712 kc.name = be->hdr.name;
713 kc.private_value = (long)sbe;
714 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
715 kc.access = be->hdr.access;
718 sbe->dobj.type = SND_SOC_DOBJ_BYTES;
719 sbe->dobj.ops = tplg->ops;
720 INIT_LIST_HEAD(&sbe->dobj.list);
722 /* map io handlers */
723 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg);
725 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",
740 /* register control here */
741 err = soc_tplg_add_kcontrol(tplg, &kc,
742 &sbe->dobj.control.kcontrol);
744 dev_err(tplg->dev, "ASoC: failed to add %s\n",
750 list_add(&sbe->dobj.list, &tplg->comp->dobj_list);
756 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count,
759 struct snd_soc_tplg_mixer_control *mc;
760 struct soc_mixer_control *sm;
761 struct snd_kcontrol_new kc;
764 if (soc_tplg_check_elem_count(tplg,
765 sizeof(struct snd_soc_tplg_mixer_control),
766 count, size, "mixers")) {
768 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n",
773 for (i = 0; i < count; i++) {
774 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
776 /* validate kcontrol */
777 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
778 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
781 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
784 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
788 "ASoC: adding mixer kcontrol %s with access 0x%x\n",
789 mc->hdr.name, mc->hdr.access);
791 memset(&kc, 0, sizeof(kc));
792 kc.name = mc->hdr.name;
793 kc.private_value = (long)sm;
794 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
795 kc.access = mc->hdr.access;
797 /* we only support FL/FR channel mapping atm */
798 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
800 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
802 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
804 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
809 sm->invert = mc->invert;
810 sm->platform_max = mc->platform_max;
811 sm->dobj.index = tplg->index;
812 sm->dobj.ops = tplg->ops;
813 sm->dobj.type = SND_SOC_DOBJ_MIXER;
814 INIT_LIST_HEAD(&sm->dobj.list);
816 /* map io handlers */
817 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg);
819 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
824 /* pass control to driver for optional further init */
825 err = soc_tplg_init_kcontrol(tplg, &kc,
826 (struct snd_soc_tplg_ctl_hdr *) mc);
828 dev_err(tplg->dev, "ASoC: failed to init %s\n",
834 /* create any TLV data */
835 soc_tplg_create_tlv(tplg, &kc, &mc->hdr);
837 /* register control here */
838 err = soc_tplg_add_kcontrol(tplg, &kc,
839 &sm->dobj.control.kcontrol);
841 dev_err(tplg->dev, "ASoC: failed to add %s\n",
843 soc_tplg_free_tlv(tplg, &kc);
848 list_add(&sm->dobj.list, &tplg->comp->dobj_list);
854 static int soc_tplg_denum_create_texts(struct soc_enum *se,
855 struct snd_soc_tplg_enum_control *ec)
859 se->dobj.control.dtexts =
860 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL);
861 if (se->dobj.control.dtexts == NULL)
864 for (i = 0; i < ec->items; i++) {
866 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
867 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) {
872 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL);
873 if (!se->dobj.control.dtexts[i]) {
882 for (--i; i >= 0; i--)
883 kfree(se->dobj.control.dtexts[i]);
884 kfree(se->dobj.control.dtexts);
888 static int soc_tplg_denum_create_values(struct soc_enum *se,
889 struct snd_soc_tplg_enum_control *ec)
891 if (ec->items > sizeof(*ec->values))
894 se->dobj.control.dvalues = kmemdup(ec->values,
895 ec->items * sizeof(u32),
897 if (!se->dobj.control.dvalues)
903 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count,
906 struct snd_soc_tplg_enum_control *ec;
908 struct snd_kcontrol_new kc;
911 if (soc_tplg_check_elem_count(tplg,
912 sizeof(struct snd_soc_tplg_enum_control),
913 count, size, "enums")) {
915 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n",
920 for (i = 0; i < count; i++) {
921 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
922 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
925 /* validate kcontrol */
926 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
927 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
930 se = kzalloc((sizeof(*se)), GFP_KERNEL);
934 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n",
935 ec->hdr.name, ec->items);
937 memset(&kc, 0, sizeof(kc));
938 kc.name = ec->hdr.name;
939 kc.private_value = (long)se;
940 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
941 kc.access = ec->hdr.access;
943 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
944 se->shift_l = tplc_chan_get_shift(tplg, ec->channel,
946 se->shift_r = tplc_chan_get_shift(tplg, ec->channel,
949 se->items = ec->items;
951 se->dobj.index = tplg->index;
952 se->dobj.type = SND_SOC_DOBJ_ENUM;
953 se->dobj.ops = tplg->ops;
954 INIT_LIST_HEAD(&se->dobj.list);
956 switch (ec->hdr.ops.info) {
957 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
958 case SND_SOC_TPLG_CTL_ENUM_VALUE:
959 err = soc_tplg_denum_create_values(se, ec);
962 "ASoC: could not create values for %s\n",
967 /* fall through and create texts */
968 case SND_SOC_TPLG_CTL_ENUM:
969 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
970 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
971 err = soc_tplg_denum_create_texts(se, ec);
974 "ASoC: could not create texts for %s\n",
982 "ASoC: invalid enum control type %d for %s\n",
983 ec->hdr.ops.info, ec->hdr.name);
988 /* map io handlers */
989 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg);
991 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
996 /* pass control to driver for optional further init */
997 err = soc_tplg_init_kcontrol(tplg, &kc,
998 (struct snd_soc_tplg_ctl_hdr *) ec);
1000 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1006 /* register control here */
1007 ret = soc_tplg_add_kcontrol(tplg,
1008 &kc, &se->dobj.control.kcontrol);
1010 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n",
1016 list_add(&se->dobj.list, &tplg->comp->dobj_list);
1022 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg,
1023 struct snd_soc_tplg_hdr *hdr)
1025 struct snd_soc_tplg_ctl_hdr *control_hdr;
1028 if (tplg->pass != SOC_TPLG_PASS_MIXER) {
1029 tplg->pos += hdr->size + hdr->payload_size;
1033 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count,
1034 soc_tplg_get_offset(tplg));
1036 for (i = 0; i < hdr->count; i++) {
1038 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1040 switch (control_hdr->ops.info) {
1041 case SND_SOC_TPLG_CTL_VOLSW:
1042 case SND_SOC_TPLG_CTL_STROBE:
1043 case SND_SOC_TPLG_CTL_VOLSW_SX:
1044 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1045 case SND_SOC_TPLG_CTL_RANGE:
1046 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1047 case SND_SOC_TPLG_DAPM_CTL_PIN:
1048 soc_tplg_dmixer_create(tplg, 1, hdr->payload_size);
1050 case SND_SOC_TPLG_CTL_ENUM:
1051 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1052 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1053 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1054 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1055 soc_tplg_denum_create(tplg, 1, hdr->payload_size);
1057 case SND_SOC_TPLG_CTL_BYTES:
1058 soc_tplg_dbytes_create(tplg, 1, hdr->payload_size);
1061 soc_bind_err(tplg, control_hdr, i);
1069 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg,
1070 struct snd_soc_tplg_hdr *hdr)
1072 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1073 struct snd_soc_dapm_route route;
1074 struct snd_soc_tplg_dapm_graph_elem *elem;
1075 int count = hdr->count, i;
1077 if (tplg->pass != SOC_TPLG_PASS_GRAPH) {
1078 tplg->pos += hdr->size + hdr->payload_size;
1082 if (soc_tplg_check_elem_count(tplg,
1083 sizeof(struct snd_soc_tplg_dapm_graph_elem),
1084 count, hdr->payload_size, "graph")) {
1086 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n",
1091 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes\n", count);
1093 for (i = 0; i < count; i++) {
1094 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos;
1095 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem);
1097 /* validate routes */
1098 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1099 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1101 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1102 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1104 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1105 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1108 route.source = elem->source;
1109 route.sink = elem->sink;
1110 route.connected = NULL; /* set to NULL atm for tplg users */
1111 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0)
1112 route.control = NULL;
1114 route.control = elem->control;
1116 /* add route, but keep going if some fail */
1117 snd_soc_dapm_add_routes(dapm, &route, 1);
1123 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create(
1124 struct soc_tplg *tplg, int num_kcontrols)
1126 struct snd_kcontrol_new *kc;
1127 struct soc_mixer_control *sm;
1128 struct snd_soc_tplg_mixer_control *mc;
1131 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL);
1135 for (i = 0; i < num_kcontrols; i++) {
1136 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
1137 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
1141 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
1144 /* validate kcontrol */
1145 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1146 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1149 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n",
1152 kc[i].name = mc->hdr.name;
1153 kc[i].private_value = (long)sm;
1154 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1155 kc[i].access = mc->hdr.access;
1157 /* we only support FL/FR channel mapping atm */
1158 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
1160 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
1162 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
1164 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
1169 sm->invert = mc->invert;
1170 sm->platform_max = mc->platform_max;
1171 sm->dobj.index = tplg->index;
1172 INIT_LIST_HEAD(&sm->dobj.list);
1174 /* map io handlers */
1175 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg);
1177 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
1182 /* pass control to driver for optional further init */
1183 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1184 (struct snd_soc_tplg_ctl_hdr *)mc);
1186 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1197 for (--i; i >= 0; i--)
1198 kfree((void *)kc[i].private_value);
1203 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create(
1204 struct soc_tplg *tplg)
1206 struct snd_kcontrol_new *kc;
1207 struct snd_soc_tplg_enum_control *ec;
1208 struct soc_enum *se;
1211 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
1212 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
1215 /* validate kcontrol */
1216 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1217 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1220 kc = kzalloc(sizeof(*kc), GFP_KERNEL);
1224 se = kzalloc(sizeof(*se), GFP_KERNEL);
1228 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n",
1231 kc->name = ec->hdr.name;
1232 kc->private_value = (long)se;
1233 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1234 kc->access = ec->hdr.access;
1236 /* we only support FL/FR channel mapping atm */
1237 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
1238 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FL);
1239 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FR);
1241 se->items = ec->items;
1242 se->mask = ec->mask;
1243 se->dobj.index = tplg->index;
1245 switch (ec->hdr.ops.info) {
1246 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1247 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1248 err = soc_tplg_denum_create_values(se, ec);
1250 dev_err(tplg->dev, "ASoC: could not create values for %s\n",
1254 /* fall through to create texts */
1255 case SND_SOC_TPLG_CTL_ENUM:
1256 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1257 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1258 err = soc_tplg_denum_create_texts(se, ec);
1260 dev_err(tplg->dev, "ASoC: could not create texts for %s\n",
1266 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n",
1267 ec->hdr.ops.info, ec->hdr.name);
1271 /* map io handlers */
1272 err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg);
1274 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
1278 /* pass control to driver for optional further init */
1279 err = soc_tplg_init_kcontrol(tplg, kc,
1280 (struct snd_soc_tplg_ctl_hdr *)ec);
1282 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1290 /* free values and texts */
1291 kfree(se->dobj.control.dvalues);
1292 for (i = 0; i < ec->items; i++)
1293 kfree(se->dobj.control.dtexts[i]);
1302 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create(
1303 struct soc_tplg *tplg, int count)
1305 struct snd_soc_tplg_bytes_control *be;
1306 struct soc_bytes_ext *sbe;
1307 struct snd_kcontrol_new *kc;
1310 kc = kcalloc(count, sizeof(*kc), GFP_KERNEL);
1314 for (i = 0; i < count; i++) {
1315 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
1317 /* validate kcontrol */
1318 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1319 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1322 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
1326 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
1330 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1331 be->hdr.name, be->hdr.access);
1333 kc[i].name = be->hdr.name;
1334 kc[i].private_value = (long)sbe;
1335 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1336 kc[i].access = be->hdr.access;
1339 INIT_LIST_HEAD(&sbe->dobj.list);
1341 /* map standard io handlers and check for external handlers */
1342 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg);
1344 soc_control_err(tplg, &be->hdr, be->hdr.name);
1349 /* pass control to driver for optional further init */
1350 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1351 (struct snd_soc_tplg_ctl_hdr *)be);
1353 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1363 for (--i; i >= 0; i--)
1364 kfree((void *)kc[i].private_value);
1370 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg,
1371 struct snd_soc_tplg_dapm_widget *w)
1373 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1374 struct snd_soc_dapm_widget template, *widget;
1375 struct snd_soc_tplg_ctl_hdr *control_hdr;
1376 struct snd_soc_card *card = tplg->comp->card;
1379 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1380 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1382 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1383 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1386 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n",
1389 memset(&template, 0, sizeof(template));
1391 /* map user to kernel widget ID */
1392 template.id = get_widget_id(w->id);
1393 if (template.id < 0)
1396 template.name = kstrdup(w->name, GFP_KERNEL);
1399 template.sname = kstrdup(w->sname, GFP_KERNEL);
1400 if (!template.sname) {
1404 template.reg = w->reg;
1405 template.shift = w->shift;
1406 template.mask = w->mask;
1407 template.subseq = w->subseq;
1408 template.on_val = w->invert ? 0 : 1;
1409 template.off_val = w->invert ? 1 : 0;
1410 template.ignore_suspend = w->ignore_suspend;
1411 template.event_flags = w->event_flags;
1412 template.dobj.index = tplg->index;
1415 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size);
1416 if (w->num_kcontrols == 0) {
1417 template.num_kcontrols = 0;
1421 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1422 dev_dbg(tplg->dev, "ASoC: template %s has %d controls of type %x\n",
1423 w->name, w->num_kcontrols, control_hdr->type);
1425 switch (control_hdr->ops.info) {
1426 case SND_SOC_TPLG_CTL_VOLSW:
1427 case SND_SOC_TPLG_CTL_STROBE:
1428 case SND_SOC_TPLG_CTL_VOLSW_SX:
1429 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1430 case SND_SOC_TPLG_CTL_RANGE:
1431 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1432 template.num_kcontrols = w->num_kcontrols;
1433 template.kcontrol_news =
1434 soc_tplg_dapm_widget_dmixer_create(tplg,
1435 template.num_kcontrols);
1436 if (!template.kcontrol_news) {
1441 case SND_SOC_TPLG_CTL_ENUM:
1442 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1443 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1444 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1445 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1446 template.dobj.widget.kcontrol_enum = 1;
1447 template.num_kcontrols = 1;
1448 template.kcontrol_news =
1449 soc_tplg_dapm_widget_denum_create(tplg);
1450 if (!template.kcontrol_news) {
1455 case SND_SOC_TPLG_CTL_BYTES:
1456 template.num_kcontrols = w->num_kcontrols;
1457 template.kcontrol_news =
1458 soc_tplg_dapm_widget_dbytes_create(tplg,
1459 template.num_kcontrols);
1460 if (!template.kcontrol_news) {
1466 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n",
1467 control_hdr->ops.get, control_hdr->ops.put,
1468 control_hdr->ops.info);
1474 ret = soc_tplg_widget_load(tplg, &template, w);
1478 /* card dapm mutex is held by the core if we are loading topology
1479 * data during sound card init. */
1480 if (card->instantiated)
1481 widget = snd_soc_dapm_new_control(dapm, &template);
1483 widget = snd_soc_dapm_new_control_unlocked(dapm, &template);
1484 if (widget == NULL) {
1485 dev_err(tplg->dev, "ASoC: failed to create widget %s controls\n",
1490 widget->dobj.type = SND_SOC_DOBJ_WIDGET;
1491 widget->dobj.ops = tplg->ops;
1492 widget->dobj.index = tplg->index;
1493 list_add(&widget->dobj.list, &tplg->comp->dobj_list);
1497 kfree(template.sname);
1499 kfree(template.name);
1503 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg,
1504 struct snd_soc_tplg_hdr *hdr)
1506 struct snd_soc_tplg_dapm_widget *widget;
1507 int ret, count = hdr->count, i;
1509 if (tplg->pass != SOC_TPLG_PASS_WIDGET)
1512 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count);
1514 for (i = 0; i < count; i++) {
1515 widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos;
1516 ret = soc_tplg_dapm_widget_create(tplg, widget);
1518 dev_err(tplg->dev, "ASoC: failed to load widget %s\n",
1525 static int soc_tplg_dapm_complete(struct soc_tplg *tplg)
1527 struct snd_soc_card *card = tplg->comp->card;
1530 /* Card might not have been registered at this point.
1531 * If so, just return success.
1533 if (!card || !card->instantiated) {
1534 dev_warn(tplg->dev, "ASoC: Parent card not yet available,"
1535 "Do not add new widgets now\n");
1539 ret = snd_soc_dapm_new_widgets(card);
1541 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n",
1547 static int soc_tplg_pcm_dai_elems_load(struct soc_tplg *tplg,
1548 struct snd_soc_tplg_hdr *hdr)
1550 struct snd_soc_tplg_pcm_dai *pcm_dai;
1551 struct snd_soc_dobj *dobj;
1552 int count = hdr->count;
1555 if (tplg->pass != SOC_TPLG_PASS_PCM_DAI)
1558 pcm_dai = (struct snd_soc_tplg_pcm_dai *)tplg->pos;
1560 if (soc_tplg_check_elem_count(tplg,
1561 sizeof(struct snd_soc_tplg_pcm_dai), count,
1562 hdr->payload_size, "PCM DAI")) {
1563 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n",
1568 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count);
1569 tplg->pos += sizeof(struct snd_soc_tplg_pcm_dai) * count;
1571 dobj = kzalloc(sizeof(struct snd_soc_dobj), GFP_KERNEL);
1575 /* Call the platform driver call back to register the dais */
1576 ret = soc_tplg_pcm_dai_load(tplg, pcm_dai, count);
1578 dev_err(tplg->comp->dev, "ASoC: PCM DAI loading failed\n");
1582 dobj->type = get_dobj_type(hdr, NULL);
1583 dobj->pcm_dai.count = count;
1584 dobj->pcm_dai.pd = pcm_dai;
1585 dobj->ops = tplg->ops;
1586 dobj->index = tplg->index;
1587 list_add(&dobj->list, &tplg->comp->dobj_list);
1595 static int soc_tplg_manifest_load(struct soc_tplg *tplg,
1596 struct snd_soc_tplg_hdr *hdr)
1598 struct snd_soc_tplg_manifest *manifest;
1600 if (tplg->pass != SOC_TPLG_PASS_MANIFEST)
1603 manifest = (struct snd_soc_tplg_manifest *)tplg->pos;
1604 tplg->pos += sizeof(struct snd_soc_tplg_manifest);
1606 if (tplg->comp && tplg->ops && tplg->ops->manifest)
1607 return tplg->ops->manifest(tplg->comp, manifest);
1609 dev_err(tplg->dev, "ASoC: Firmware manifest not supported\n");
1613 /* validate header magic, size and type */
1614 static int soc_valid_header(struct soc_tplg *tplg,
1615 struct snd_soc_tplg_hdr *hdr)
1617 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size)
1620 /* big endian firmware objects not supported atm */
1621 if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) {
1623 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n",
1624 tplg->pass, hdr->magic,
1625 soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1629 if (hdr->magic != SND_SOC_TPLG_MAGIC) {
1631 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n",
1632 tplg->pass, hdr->magic,
1633 soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1637 if (hdr->abi != SND_SOC_TPLG_ABI_VERSION) {
1639 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n",
1640 tplg->pass, hdr->abi,
1641 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg),
1646 if (hdr->payload_size == 0) {
1647 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n",
1648 soc_tplg_get_hdr_offset(tplg));
1652 if (tplg->pass == hdr->type)
1654 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n",
1655 hdr->payload_size, hdr->type, hdr->version,
1656 hdr->vendor_type, tplg->pass);
1661 /* check header type and call appropriate handler */
1662 static int soc_tplg_load_header(struct soc_tplg *tplg,
1663 struct snd_soc_tplg_hdr *hdr)
1665 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr);
1667 /* check for matching ID */
1668 if (hdr->index != tplg->req_index &&
1669 hdr->index != SND_SOC_TPLG_INDEX_ALL)
1672 tplg->index = hdr->index;
1674 switch (hdr->type) {
1675 case SND_SOC_TPLG_TYPE_MIXER:
1676 case SND_SOC_TPLG_TYPE_ENUM:
1677 case SND_SOC_TPLG_TYPE_BYTES:
1678 return soc_tplg_kcontrol_elems_load(tplg, hdr);
1679 case SND_SOC_TPLG_TYPE_DAPM_GRAPH:
1680 return soc_tplg_dapm_graph_elems_load(tplg, hdr);
1681 case SND_SOC_TPLG_TYPE_DAPM_WIDGET:
1682 return soc_tplg_dapm_widget_elems_load(tplg, hdr);
1683 case SND_SOC_TPLG_TYPE_PCM:
1684 case SND_SOC_TPLG_TYPE_DAI_LINK:
1685 case SND_SOC_TPLG_TYPE_CODEC_LINK:
1686 return soc_tplg_pcm_dai_elems_load(tplg, hdr);
1687 case SND_SOC_TPLG_TYPE_MANIFEST:
1688 return soc_tplg_manifest_load(tplg, hdr);
1690 /* bespoke vendor data object */
1691 return soc_tplg_vendor_load(tplg, hdr);
1697 /* process the topology file headers */
1698 static int soc_tplg_process_headers(struct soc_tplg *tplg)
1700 struct snd_soc_tplg_hdr *hdr;
1703 tplg->pass = SOC_TPLG_PASS_START;
1705 /* process the header types from start to end */
1706 while (tplg->pass <= SOC_TPLG_PASS_END) {
1708 tplg->hdr_pos = tplg->fw->data;
1709 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1711 while (!soc_tplg_is_eof(tplg)) {
1713 /* make sure header is valid before loading */
1714 ret = soc_valid_header(tplg, hdr);
1720 /* load the header object */
1721 ret = soc_tplg_load_header(tplg, hdr);
1725 /* goto next header */
1726 tplg->hdr_pos += hdr->payload_size +
1727 sizeof(struct snd_soc_tplg_hdr);
1728 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1731 /* next data type pass */
1735 /* signal DAPM we are complete */
1736 ret = soc_tplg_dapm_complete(tplg);
1739 "ASoC: failed to initialise DAPM from Firmware\n");
1744 static int soc_tplg_load(struct soc_tplg *tplg)
1748 ret = soc_tplg_process_headers(tplg);
1750 soc_tplg_complete(tplg);
1755 /* load audio component topology from "firmware" file */
1756 int snd_soc_tplg_component_load(struct snd_soc_component *comp,
1757 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id)
1759 struct soc_tplg tplg;
1761 /* setup parsing context */
1762 memset(&tplg, 0, sizeof(tplg));
1764 tplg.dev = comp->dev;
1767 tplg.req_index = id;
1768 tplg.io_ops = ops->io_ops;
1769 tplg.io_ops_count = ops->io_ops_count;
1770 tplg.bytes_ext_ops = ops->bytes_ext_ops;
1771 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count;
1773 return soc_tplg_load(&tplg);
1775 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
1777 /* remove this dynamic widget */
1778 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w)
1780 /* make sure we are a widget */
1781 if (w->dobj.type != SND_SOC_DOBJ_WIDGET)
1784 remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET);
1786 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove);
1788 /* remove all dynamic widgets from this DAPM context */
1789 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
1792 struct snd_soc_dapm_widget *w, *next_w;
1794 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
1796 /* make sure we are a widget with correct context */
1797 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm)
1801 if (w->dobj.index != index &&
1802 w->dobj.index != SND_SOC_TPLG_INDEX_ALL)
1804 /* check and free and dynamic widget kcontrols */
1805 snd_soc_tplg_widget_remove(w);
1806 snd_soc_dapm_free_widget(w);
1809 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all);
1811 /* remove dynamic controls from the component driver */
1812 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index)
1814 struct snd_soc_dobj *dobj, *next_dobj;
1815 int pass = SOC_TPLG_PASS_END;
1817 /* process the header types from end to start */
1818 while (pass >= SOC_TPLG_PASS_START) {
1820 /* remove mixer controls */
1821 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list,
1825 if (dobj->index != index &&
1826 dobj->index != SND_SOC_TPLG_INDEX_ALL)
1829 switch (dobj->type) {
1830 case SND_SOC_DOBJ_MIXER:
1831 remove_mixer(comp, dobj, pass);
1833 case SND_SOC_DOBJ_ENUM:
1834 remove_enum(comp, dobj, pass);
1836 case SND_SOC_DOBJ_BYTES:
1837 remove_bytes(comp, dobj, pass);
1839 case SND_SOC_DOBJ_WIDGET:
1840 remove_widget(comp, dobj, pass);
1842 case SND_SOC_DOBJ_PCM:
1843 case SND_SOC_DOBJ_DAI_LINK:
1844 case SND_SOC_DOBJ_CODEC_LINK:
1845 remove_pcm_dai(comp, dobj, pass);
1848 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n",
1856 /* let caller know if FW can be freed when no objects are left */
1857 return !list_empty(&comp->dobj_list);
1859 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove);