]> git.ipfire.org Git - people/ms/linux.git/blob - sound/soc/soc-topology.c
projects / people / ms / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[people/ms/linux.git] / sound / soc / soc-topology.c
1 /*
2 * soc-topology.c -- ALSA SoC Topology
3 *
4 * Copyright (C) 2012 Texas Instruments Inc.
5 * Copyright (C) 2015 Intel Corporation.
6 *
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>
14 *
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.
19 *
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.
23 *
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.
26 */
27
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>
37
38 /*
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).
43 */
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
51
52 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST
53 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_PINS
54
55 struct soc_tplg {
56 const struct firmware *fw;
57
58 /* runtime FW parsing */
59 const u8 *pos; /* read postion */
60 const u8 *hdr_pos; /* header position */
61 unsigned int pass; /* pass number */
62
63 /* component caller */
64 struct device *dev;
65 struct snd_soc_component *comp;
66 u32 index; /* current block index */
67 u32 req_index; /* required index, only loaded/free matching blocks */
68
69 /* vendor specific kcontrol operations */
70 const struct snd_soc_tplg_kcontrol_ops *io_ops;
71 int io_ops_count;
72
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;
76
77 /* optional fw loading callbacks to component drivers */
78 struct snd_soc_tplg_ops *ops;
79 };
80
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);
89
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)
93 {
94 const u8 *end = tplg->pos + elem_size * count;
95
96 if (end > tplg->fw->data + tplg->fw->size) {
97 dev_err(tplg->dev, "ASoC: %s overflow end of data\n",
98 elem_type);
99 return -EINVAL;
100 }
101
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) {
105 dev_err(tplg->dev,
106 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
107 elem_type, count, elem_size, bytes);
108 return -EINVAL;
109 }
110
111 return 0;
112 }
113
114 static inline int soc_tplg_is_eof(struct soc_tplg *tplg)
115 {
116 const u8 *end = tplg->hdr_pos;
117
118 if (end >= tplg->fw->data + tplg->fw->size)
119 return 1;
120 return 0;
121 }
122
123 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg)
124 {
125 return (unsigned long)(tplg->hdr_pos - tplg->fw->data);
126 }
127
128 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg)
129 {
130 return (unsigned long)(tplg->pos - tplg->fw->data);
131 }
132
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},
161 };
162
163 struct soc_tplg_map {
164 int uid;
165 int kid;
166 };
167
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},
186 };
187
188 static int tplc_chan_get_reg(struct soc_tplg *tplg,
189 struct snd_soc_tplg_channel *chan, int map)
190 {
191 int i;
192
193 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
194 if (chan[i].id == map)
195 return chan[i].reg;
196 }
197
198 return -EINVAL;
199 }
200
201 static int tplc_chan_get_shift(struct soc_tplg *tplg,
202 struct snd_soc_tplg_channel *chan, int map)
203 {
204 int i;
205
206 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
207 if (chan[i].id == map)
208 return chan[i].shift;
209 }
210
211 return -EINVAL;
212 }
213
214 static int get_widget_id(int tplg_type)
215 {
216 int i;
217
218 for (i = 0; i < ARRAY_SIZE(dapm_map); i++) {
219 if (tplg_type == dapm_map[i].uid)
220 return dapm_map[i].kid;
221 }
222
223 return -EINVAL;
224 }
225
226 static enum snd_soc_dobj_type get_dobj_mixer_type(
227 struct snd_soc_tplg_ctl_hdr *control_hdr)
228 {
229 if (control_hdr == NULL)
230 return SND_SOC_DOBJ_NONE;
231
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;
244 default:
245 return SND_SOC_DOBJ_NONE;
246 }
247 }
248
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)
251 {
252 switch (hdr->type) {
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;
266 default:
267 return SND_SOC_DOBJ_NONE;
268 }
269 }
270
271 static inline void soc_bind_err(struct soc_tplg *tplg,
272 struct snd_soc_tplg_ctl_hdr *hdr, int index)
273 {
274 dev_err(tplg->dev,
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));
278 }
279
280 static inline void soc_control_err(struct soc_tplg *tplg,
281 struct snd_soc_tplg_ctl_hdr *hdr, const char *name)
282 {
283 dev_err(tplg->dev,
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));
287 }
288
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)
292 {
293 int ret = 0;
294
295 if (tplg->comp && tplg->ops && tplg->ops->vendor_load)
296 ret = tplg->ops->vendor_load(tplg->comp, hdr);
297 else {
298 dev_err(tplg->dev, "ASoC: no vendor load callback for ID %d\n",
299 hdr->vendor_type);
300 return -EINVAL;
301 }
302
303 if (ret < 0)
304 dev_err(tplg->dev,
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);
309 return ret;
310 }
311
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)
315 {
316 if (tplg->pass != SOC_TPLG_PASS_VENDOR)
317 return 0;
318
319 return soc_tplg_vendor_load_(tplg, hdr);
320 }
321
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)
326 {
327 if (tplg->comp && tplg->ops && tplg->ops->widget_load)
328 return tplg->ops->widget_load(tplg->comp, w, tplg_w);
329
330 return 0;
331 }
332
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)
336 {
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);
339
340 return 0;
341 }
342
343 /* tell the component driver that all firmware has been loaded in this request */
344 static void soc_tplg_complete(struct soc_tplg *tplg)
345 {
346 if (tplg->comp && tplg->ops && tplg->ops->complete)
347 tplg->ops->complete(tplg->comp);
348 }
349
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)
354 {
355 int err;
356
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",
360 control_new->name);
361 return -ENOMEM;
362 }
363
364 err = snd_ctl_add(card, *kcontrol);
365 if (err < 0) {
366 dev_err(dev, "ASoC: Failed to add %s: %d\n",
367 control_new->name, err);
368 return err;
369 }
370
371 return 0;
372 }
373
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)
377 {
378 struct snd_soc_component *comp = tplg->comp;
379
380 return soc_tplg_add_dcontrol(comp->card->snd_card,
381 comp->dev, k, NULL, comp, kcontrol);
382 }
383
384 /* remove a mixer kcontrol */
385 static void remove_mixer(struct snd_soc_component *comp,
386 struct snd_soc_dobj *dobj, int pass)
387 {
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;
392
393 if (pass != SOC_TPLG_PASS_MIXER)
394 return;
395
396 if (dobj->ops && dobj->ops->control_unload)
397 dobj->ops->control_unload(comp, dobj);
398
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);
403 kfree(sm);
404 kfree(p);
405 }
406
407 /* remove an enum kcontrol */
408 static void remove_enum(struct snd_soc_component *comp,
409 struct snd_soc_dobj *dobj, int pass)
410 {
411 struct snd_card *card = comp->card->snd_card;
412 struct soc_enum *se = container_of(dobj, struct soc_enum, dobj);
413 int i;
414
415 if (pass != SOC_TPLG_PASS_MIXER)
416 return;
417
418 if (dobj->ops && dobj->ops->control_unload)
419 dobj->ops->control_unload(comp, dobj);
420
421 snd_ctl_remove(card, se->dobj.control.kcontrol);
422 list_del(&se->dobj.list);
423
424 kfree(se->dobj.control.dvalues);
425 for (i = 0; i < se->items; i++)
426 kfree(se->dobj.control.dtexts[i]);
427 kfree(se);
428 }
429
430 /* remove a byte kcontrol */
431 static void remove_bytes(struct snd_soc_component *comp,
432 struct snd_soc_dobj *dobj, int pass)
433 {
434 struct snd_card *card = comp->card->snd_card;
435 struct soc_bytes_ext *sb =
436 container_of(dobj, struct soc_bytes_ext, dobj);
437
438 if (pass != SOC_TPLG_PASS_MIXER)
439 return;
440
441 if (dobj->ops && dobj->ops->control_unload)
442 dobj->ops->control_unload(comp, dobj);
443
444 snd_ctl_remove(card, sb->dobj.control.kcontrol);
445 list_del(&sb->dobj.list);
446 kfree(sb);
447 }
448
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)
452 {
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);
456 int i;
457
458 if (pass != SOC_TPLG_PASS_WIDGET)
459 return;
460
461 if (dobj->ops && dobj->ops->widget_unload)
462 dobj->ops->widget_unload(comp, dobj);
463
464 /*
465 * Dynamic Widgets either have 1 enum kcontrol or 1..N mixers.
466 * The enum may either have an array of values or strings.
467 */
468 if (dobj->widget.kcontrol_enum) {
469 /* enumerated widget mixer */
470 struct soc_enum *se =
471 (struct soc_enum *)w->kcontrols[0]->private_value;
472
473 snd_ctl_remove(card, w->kcontrols[0]);
474
475 kfree(se->dobj.control.dvalues);
476 for (i = 0; i < se->items; i++)
477 kfree(se->dobj.control.dtexts[i]);
478
479 kfree(se);
480 kfree(w->kcontrol_news);
481 } else {
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;
487
488 kfree(w->kcontrols[i]->tlv.p);
489
490 snd_ctl_remove(card, w->kcontrols[i]);
491 kfree(sm);
492 }
493 kfree(w->kcontrol_news);
494 }
495 /* widget w is freed by soc-dapm.c */
496 }
497
498 /* remove PCM DAI configurations */
499 static void remove_pcm_dai(struct snd_soc_component *comp,
500 struct snd_soc_dobj *dobj, int pass)
501 {
502 if (pass != SOC_TPLG_PASS_PCM_DAI)
503 return;
504
505 if (dobj->ops && dobj->ops->pcm_dai_unload)
506 dobj->ops->pcm_dai_unload(comp, dobj);
507
508 list_del(&dobj->list);
509 kfree(dobj);
510 }
511
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)
516 {
517 const struct snd_soc_tplg_kcontrol_ops *ops;
518 const struct snd_soc_tplg_bytes_ext_ops *ext_ops;
519 int num_ops, i;
520
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;
527
528 sbe = (struct soc_bytes_ext *)k->private_value;
529 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
530
531 /* TLV bytes controls need standard kcontrol info handler,
532 * TLV callback and extended put/get handlers.
533 */
534 k->info = snd_soc_bytes_info;
535 k->tlv.c = snd_soc_bytes_tlv_callback;
536
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;
544 }
545
546 if (sbe->put && sbe->get)
547 return 0;
548 else
549 return -EINVAL;
550 }
551
552 /* try and map vendor specific kcontrol handlers first */
553 ops = tplg->io_ops;
554 num_ops = tplg->io_ops_count;
555 for (i = 0; i < num_ops; i++) {
556
557 if (k->put == NULL && ops[i].id == hdr->ops.put)
558 k->put = ops[i].put;
559 if (k->get == NULL && ops[i].id == hdr->ops.get)
560 k->get = ops[i].get;
561 if (k->info == NULL && ops[i].id == hdr->ops.info)
562 k->info = ops[i].info;
563 }
564
565 /* vendor specific handlers found ? */
566 if (k->put && k->get && k->info)
567 return 0;
568
569 /* none found so try standard kcontrol handlers */
570 ops = io_ops;
571 num_ops = ARRAY_SIZE(io_ops);
572 for (i = 0; i < num_ops; i++) {
573
574 if (k->put == NULL && ops[i].id == hdr->ops.put)
575 k->put = ops[i].put;
576 if (k->get == NULL && ops[i].id == hdr->ops.get)
577 k->get = ops[i].get;
578 if (k->info == NULL && ops[i].id == hdr->ops.info)
579 k->info = ops[i].info;
580 }
581
582 /* standard handlers found ? */
583 if (k->put && k->get && k->info)
584 return 0;
585
586 /* nothing to bind */
587 return -EINVAL;
588 }
589
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)
594 {
595 int i;
596
597 w->event = NULL;
598
599 for (i = 0; i < num_events; i++) {
600 if (event_type == events[i].type) {
601
602 /* found - so assign event */
603 w->event = events[i].event_handler;
604 return 0;
605 }
606 }
607
608 /* not found */
609 return -EINVAL;
610 }
611 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event);
612
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)
616 {
617 if (tplg->comp && tplg->ops && tplg->ops->control_load)
618 return tplg->ops->control_load(tplg->comp, k, hdr);
619
620 return 0;
621 }
622
623
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)
626 {
627 unsigned int item_len = 2 * sizeof(unsigned int);
628 unsigned int *p;
629
630 p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL);
631 if (!p)
632 return -ENOMEM;
633
634 p[0] = SNDRV_CTL_TLVT_DB_SCALE;
635 p[1] = item_len;
636 p[2] = scale->min;
637 p[3] = (scale->step & TLV_DB_SCALE_MASK)
638 | (scale->mute ? TLV_DB_SCALE_MUTE : 0);
639
640 kc->tlv.p = (void *)p;
641 return 0;
642 }
643
644 static int soc_tplg_create_tlv(struct soc_tplg *tplg,
645 struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc)
646 {
647 struct snd_soc_tplg_ctl_tlv *tplg_tlv;
648
649 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE))
650 return 0;
651
652 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) {
653 tplg_tlv = &tc->tlv;
654 switch (tplg_tlv->type) {
655 case SNDRV_CTL_TLVT_DB_SCALE:
656 return soc_tplg_create_tlv_db_scale(tplg, kc,
657 &tplg_tlv->scale);
658
659 /* TODO: add support for other TLV types */
660 default:
661 dev_dbg(tplg->dev, "Unsupported TLV type %d\n",
662 tplg_tlv->type);
663 return -EINVAL;
664 }
665 }
666
667 return 0;
668 }
669
670 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg,
671 struct snd_kcontrol_new *kc)
672 {
673 kfree(kc->tlv.p);
674 }
675
676 static int soc_tplg_dbytes_create(struct soc_tplg *tplg, unsigned int count,
677 size_t size)
678 {
679 struct snd_soc_tplg_bytes_control *be;
680 struct soc_bytes_ext *sbe;
681 struct snd_kcontrol_new kc;
682 int i, err;
683
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",
688 count);
689 return -EINVAL;
690 }
691
692 for (i = 0; i < count; i++) {
693 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
694
695 /* validate kcontrol */
696 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
697 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
698 return -EINVAL;
699
700 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
701 if (sbe == NULL)
702 return -ENOMEM;
703
704 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
705 be->priv.size);
706
707 dev_dbg(tplg->dev,
708 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
709 be->hdr.name, be->hdr.access);
710
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;
716
717 sbe->max = be->max;
718 sbe->dobj.type = SND_SOC_DOBJ_BYTES;
719 sbe->dobj.ops = tplg->ops;
720 INIT_LIST_HEAD(&sbe->dobj.list);
721
722 /* map io handlers */
723 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg);
724 if (err) {
725 soc_control_err(tplg, &be->hdr, be->hdr.name);
726 kfree(sbe);
727 continue;
728 }
729
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);
733 if (err < 0) {
734 dev_err(tplg->dev, "ASoC: failed to init %s\n",
735 be->hdr.name);
736 kfree(sbe);
737 continue;
738 }
739
740 /* register control here */
741 err = soc_tplg_add_kcontrol(tplg, &kc,
742 &sbe->dobj.control.kcontrol);
743 if (err < 0) {
744 dev_err(tplg->dev, "ASoC: failed to add %s\n",
745 be->hdr.name);
746 kfree(sbe);
747 continue;
748 }
749
750 list_add(&sbe->dobj.list, &tplg->comp->dobj_list);
751 }
752 return 0;
753
754 }
755
756 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count,
757 size_t size)
758 {
759 struct snd_soc_tplg_mixer_control *mc;
760 struct soc_mixer_control *sm;
761 struct snd_kcontrol_new kc;
762 int i, err;
763
764 if (soc_tplg_check_elem_count(tplg,
765 sizeof(struct snd_soc_tplg_mixer_control),
766 count, size, "mixers")) {
767
768 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n",
769 count);
770 return -EINVAL;
771 }
772
773 for (i = 0; i < count; i++) {
774 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
775
776 /* validate kcontrol */
777 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
778 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
779 return -EINVAL;
780
781 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
782 if (sm == NULL)
783 return -ENOMEM;
784 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
785 mc->priv.size);
786
787 dev_dbg(tplg->dev,
788 "ASoC: adding mixer kcontrol %s with access 0x%x\n",
789 mc->hdr.name, mc->hdr.access);
790
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;
796
797 /* we only support FL/FR channel mapping atm */
798 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
799 SNDRV_CHMAP_FL);
800 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
801 SNDRV_CHMAP_FR);
802 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
803 SNDRV_CHMAP_FL);
804 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
805 SNDRV_CHMAP_FR);
806
807 sm->max = mc->max;
808 sm->min = mc->min;
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);
815
816 /* map io handlers */
817 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg);
818 if (err) {
819 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
820 kfree(sm);
821 continue;
822 }
823
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);
827 if (err < 0) {
828 dev_err(tplg->dev, "ASoC: failed to init %s\n",
829 mc->hdr.name);
830 kfree(sm);
831 continue;
832 }
833
834 /* create any TLV data */
835 soc_tplg_create_tlv(tplg, &kc, &mc->hdr);
836
837 /* register control here */
838 err = soc_tplg_add_kcontrol(tplg, &kc,
839 &sm->dobj.control.kcontrol);
840 if (err < 0) {
841 dev_err(tplg->dev, "ASoC: failed to add %s\n",
842 mc->hdr.name);
843 soc_tplg_free_tlv(tplg, &kc);
844 kfree(sm);
845 continue;
846 }
847
848 list_add(&sm->dobj.list, &tplg->comp->dobj_list);
849 }
850
851 return 0;
852 }
853
854 static int soc_tplg_denum_create_texts(struct soc_enum *se,
855 struct snd_soc_tplg_enum_control *ec)
856 {
857 int i, ret;
858
859 se->dobj.control.dtexts =
860 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL);
861 if (se->dobj.control.dtexts == NULL)
862 return -ENOMEM;
863
864 for (i = 0; i < ec->items; i++) {
865
866 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
867 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) {
868 ret = -EINVAL;
869 goto err;
870 }
871
872 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL);
873 if (!se->dobj.control.dtexts[i]) {
874 ret = -ENOMEM;
875 goto err;
876 }
877 }
878
879 return 0;
880
881 err:
882 for (--i; i >= 0; i--)
883 kfree(se->dobj.control.dtexts[i]);
884 kfree(se->dobj.control.dtexts);
885 return ret;
886 }
887
888 static int soc_tplg_denum_create_values(struct soc_enum *se,
889 struct snd_soc_tplg_enum_control *ec)
890 {
891 if (ec->items > sizeof(*ec->values))
892 return -EINVAL;
893
894 se->dobj.control.dvalues = kmemdup(ec->values,
895 ec->items * sizeof(u32),
896 GFP_KERNEL);
897 if (!se->dobj.control.dvalues)
898 return -ENOMEM;
899
900 return 0;
901 }
902
903 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count,
904 size_t size)
905 {
906 struct snd_soc_tplg_enum_control *ec;
907 struct soc_enum *se;
908 struct snd_kcontrol_new kc;
909 int i, ret, err;
910
911 if (soc_tplg_check_elem_count(tplg,
912 sizeof(struct snd_soc_tplg_enum_control),
913 count, size, "enums")) {
914
915 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n",
916 count);
917 return -EINVAL;
918 }
919
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) +
923 ec->priv.size);
924
925 /* validate kcontrol */
926 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
927 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
928 return -EINVAL;
929
930 se = kzalloc((sizeof(*se)), GFP_KERNEL);
931 if (se == NULL)
932 return -ENOMEM;
933
934 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n",
935 ec->hdr.name, ec->items);
936
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;
942
943 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
944 se->shift_l = tplc_chan_get_shift(tplg, ec->channel,
945 SNDRV_CHMAP_FL);
946 se->shift_r = tplc_chan_get_shift(tplg, ec->channel,
947 SNDRV_CHMAP_FL);
948
949 se->items = ec->items;
950 se->mask = ec->mask;
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);
955
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);
960 if (err < 0) {
961 dev_err(tplg->dev,
962 "ASoC: could not create values for %s\n",
963 ec->hdr.name);
964 kfree(se);
965 continue;
966 }
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);
972 if (err < 0) {
973 dev_err(tplg->dev,
974 "ASoC: could not create texts for %s\n",
975 ec->hdr.name);
976 kfree(se);
977 continue;
978 }
979 break;
980 default:
981 dev_err(tplg->dev,
982 "ASoC: invalid enum control type %d for %s\n",
983 ec->hdr.ops.info, ec->hdr.name);
984 kfree(se);
985 continue;
986 }
987
988 /* map io handlers */
989 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg);
990 if (err) {
991 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
992 kfree(se);
993 continue;
994 }
995
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);
999 if (err < 0) {
1000 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1001 ec->hdr.name);
1002 kfree(se);
1003 continue;
1004 }
1005
1006 /* register control here */
1007 ret = soc_tplg_add_kcontrol(tplg,
1008 &kc, &se->dobj.control.kcontrol);
1009 if (ret < 0) {
1010 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n",
1011 ec->hdr.name);
1012 kfree(se);
1013 continue;
1014 }
1015
1016 list_add(&se->dobj.list, &tplg->comp->dobj_list);
1017 }
1018
1019 return 0;
1020 }
1021
1022 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg,
1023 struct snd_soc_tplg_hdr *hdr)
1024 {
1025 struct snd_soc_tplg_ctl_hdr *control_hdr;
1026 int i;
1027
1028 if (tplg->pass != SOC_TPLG_PASS_MIXER) {
1029 tplg->pos += hdr->size + hdr->payload_size;
1030 return 0;
1031 }
1032
1033 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count,
1034 soc_tplg_get_offset(tplg));
1035
1036 for (i = 0; i < hdr->count; i++) {
1037
1038 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1039
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);
1049 break;
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);
1056 break;
1057 case SND_SOC_TPLG_CTL_BYTES:
1058 soc_tplg_dbytes_create(tplg, 1, hdr->payload_size);
1059 break;
1060 default:
1061 soc_bind_err(tplg, control_hdr, i);
1062 return -EINVAL;
1063 }
1064 }
1065
1066 return 0;
1067 }
1068
1069 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg,
1070 struct snd_soc_tplg_hdr *hdr)
1071 {
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;
1076
1077 if (tplg->pass != SOC_TPLG_PASS_GRAPH) {
1078 tplg->pos += hdr->size + hdr->payload_size;
1079 return 0;
1080 }
1081
1082 if (soc_tplg_check_elem_count(tplg,
1083 sizeof(struct snd_soc_tplg_dapm_graph_elem),
1084 count, hdr->payload_size, "graph")) {
1085
1086 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n",
1087 count);
1088 return -EINVAL;
1089 }
1090
1091 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes\n", count);
1092
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);
1096
1097 /* validate routes */
1098 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1099 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1100 return -EINVAL;
1101 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1102 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1103 return -EINVAL;
1104 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1105 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1106 return -EINVAL;
1107
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;
1113 else
1114 route.control = elem->control;
1115
1116 /* add route, but keep going if some fail */
1117 snd_soc_dapm_add_routes(dapm, &route, 1);
1118 }
1119
1120 return 0;
1121 }
1122
1123 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create(
1124 struct soc_tplg *tplg, int num_kcontrols)
1125 {
1126 struct snd_kcontrol_new *kc;
1127 struct soc_mixer_control *sm;
1128 struct snd_soc_tplg_mixer_control *mc;
1129 int i, err;
1130
1131 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL);
1132 if (kc == NULL)
1133 return NULL;
1134
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);
1138 if (sm == NULL)
1139 goto err;
1140
1141 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
1142 mc->priv.size);
1143
1144 /* validate kcontrol */
1145 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1146 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1147 goto err_str;
1148
1149 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n",
1150 mc->hdr.name, i);
1151
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;
1156
1157 /* we only support FL/FR channel mapping atm */
1158 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
1159 SNDRV_CHMAP_FL);
1160 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
1161 SNDRV_CHMAP_FR);
1162 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
1163 SNDRV_CHMAP_FL);
1164 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
1165 SNDRV_CHMAP_FR);
1166
1167 sm->max = mc->max;
1168 sm->min = mc->min;
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);
1173
1174 /* map io handlers */
1175 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg);
1176 if (err) {
1177 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
1178 kfree(sm);
1179 continue;
1180 }
1181
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);
1185 if (err < 0) {
1186 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1187 mc->hdr.name);
1188 kfree(sm);
1189 continue;
1190 }
1191 }
1192 return kc;
1193
1194 err_str:
1195 kfree(sm);
1196 err:
1197 for (--i; i >= 0; i--)
1198 kfree((void *)kc[i].private_value);
1199 kfree(kc);
1200 return NULL;
1201 }
1202
1203 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create(
1204 struct soc_tplg *tplg)
1205 {
1206 struct snd_kcontrol_new *kc;
1207 struct snd_soc_tplg_enum_control *ec;
1208 struct soc_enum *se;
1209 int i, err;
1210
1211 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
1212 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
1213 ec->priv.size);
1214
1215 /* validate kcontrol */
1216 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1217 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1218 return NULL;
1219
1220 kc = kzalloc(sizeof(*kc), GFP_KERNEL);
1221 if (kc == NULL)
1222 return NULL;
1223
1224 se = kzalloc(sizeof(*se), GFP_KERNEL);
1225 if (se == NULL)
1226 goto err;
1227
1228 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n",
1229 ec->hdr.name);
1230
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;
1235
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);
1240
1241 se->items = ec->items;
1242 se->mask = ec->mask;
1243 se->dobj.index = tplg->index;
1244
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);
1249 if (err < 0) {
1250 dev_err(tplg->dev, "ASoC: could not create values for %s\n",
1251 ec->hdr.name);
1252 goto err_se;
1253 }
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);
1259 if (err < 0) {
1260 dev_err(tplg->dev, "ASoC: could not create texts for %s\n",
1261 ec->hdr.name);
1262 goto err_se;
1263 }
1264 break;
1265 default:
1266 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n",
1267 ec->hdr.ops.info, ec->hdr.name);
1268 goto err_se;
1269 }
1270
1271 /* map io handlers */
1272 err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg);
1273 if (err) {
1274 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
1275 goto err_se;
1276 }
1277
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);
1281 if (err < 0) {
1282 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1283 ec->hdr.name);
1284 goto err_se;
1285 }
1286
1287 return kc;
1288
1289 err_se:
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]);
1294
1295 kfree(se);
1296 err:
1297 kfree(kc);
1298
1299 return NULL;
1300 }
1301
1302 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create(
1303 struct soc_tplg *tplg, int count)
1304 {
1305 struct snd_soc_tplg_bytes_control *be;
1306 struct soc_bytes_ext *sbe;
1307 struct snd_kcontrol_new *kc;
1308 int i, err;
1309
1310 kc = kcalloc(count, sizeof(*kc), GFP_KERNEL);
1311 if (!kc)
1312 return NULL;
1313
1314 for (i = 0; i < count; i++) {
1315 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
1316
1317 /* validate kcontrol */
1318 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1319 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1320 goto err;
1321
1322 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
1323 if (sbe == NULL)
1324 goto err;
1325
1326 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
1327 be->priv.size);
1328
1329 dev_dbg(tplg->dev,
1330 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1331 be->hdr.name, be->hdr.access);
1332
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;
1337
1338 sbe->max = be->max;
1339 INIT_LIST_HEAD(&sbe->dobj.list);
1340
1341 /* map standard io handlers and check for external handlers */
1342 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg);
1343 if (err) {
1344 soc_control_err(tplg, &be->hdr, be->hdr.name);
1345 kfree(sbe);
1346 continue;
1347 }
1348
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);
1352 if (err < 0) {
1353 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1354 be->hdr.name);
1355 kfree(sbe);
1356 continue;
1357 }
1358 }
1359
1360 return kc;
1361
1362 err:
1363 for (--i; i >= 0; i--)
1364 kfree((void *)kc[i].private_value);
1365
1366 kfree(kc);
1367 return NULL;
1368 }
1369
1370 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg,
1371 struct snd_soc_tplg_dapm_widget *w)
1372 {
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;
1377 int ret = 0;
1378
1379 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1380 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1381 return -EINVAL;
1382 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1383 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1384 return -EINVAL;
1385
1386 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n",
1387 w->name, w->id);
1388
1389 memset(&template, 0, sizeof(template));
1390
1391 /* map user to kernel widget ID */
1392 template.id = get_widget_id(w->id);
1393 if (template.id < 0)
1394 return template.id;
1395
1396 template.name = kstrdup(w->name, GFP_KERNEL);
1397 if (!template.name)
1398 return -ENOMEM;
1399 template.sname = kstrdup(w->sname, GFP_KERNEL);
1400 if (!template.sname) {
1401 ret = -ENOMEM;
1402 goto err;
1403 }
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;
1413
1414 tplg->pos +=
1415 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size);
1416 if (w->num_kcontrols == 0) {
1417 template.num_kcontrols = 0;
1418 goto widget;
1419 }
1420
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);
1424
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) {
1437 ret = -ENOMEM;
1438 goto hdr_err;
1439 }
1440 break;
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) {
1451 ret = -ENOMEM;
1452 goto hdr_err;
1453 }
1454 break;
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) {
1461 ret = -ENOMEM;
1462 goto hdr_err;
1463 }
1464 break;
1465 default:
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);
1469 ret = -EINVAL;
1470 goto hdr_err;
1471 }
1472
1473 widget:
1474 ret = soc_tplg_widget_load(tplg, &template, w);
1475 if (ret < 0)
1476 goto hdr_err;
1477
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);
1482 else
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",
1486 w->name);
1487 goto hdr_err;
1488 }
1489
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);
1494 return 0;
1495
1496 hdr_err:
1497 kfree(template.sname);
1498 err:
1499 kfree(template.name);
1500 return ret;
1501 }
1502
1503 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg,
1504 struct snd_soc_tplg_hdr *hdr)
1505 {
1506 struct snd_soc_tplg_dapm_widget *widget;
1507 int ret, count = hdr->count, i;
1508
1509 if (tplg->pass != SOC_TPLG_PASS_WIDGET)
1510 return 0;
1511
1512 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count);
1513
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);
1517 if (ret < 0)
1518 dev_err(tplg->dev, "ASoC: failed to load widget %s\n",
1519 widget->name);
1520 }
1521
1522 return 0;
1523 }
1524
1525 static int soc_tplg_dapm_complete(struct soc_tplg *tplg)
1526 {
1527 struct snd_soc_card *card = tplg->comp->card;
1528 int ret;
1529
1530 /* Card might not have been registered at this point.
1531 * If so, just return success.
1532 */
1533 if (!card || !card->instantiated) {
1534 dev_warn(tplg->dev, "ASoC: Parent card not yet available,"
1535 "Do not add new widgets now\n");
1536 return 0;
1537 }
1538
1539 ret = snd_soc_dapm_new_widgets(card);
1540 if (ret < 0)
1541 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n",
1542 ret);
1543
1544 return 0;
1545 }
1546
1547 static int soc_tplg_pcm_dai_elems_load(struct soc_tplg *tplg,
1548 struct snd_soc_tplg_hdr *hdr)
1549 {
1550 struct snd_soc_tplg_pcm_dai *pcm_dai;
1551 struct snd_soc_dobj *dobj;
1552 int count = hdr->count;
1553 int ret;
1554
1555 if (tplg->pass != SOC_TPLG_PASS_PCM_DAI)
1556 return 0;
1557
1558 pcm_dai = (struct snd_soc_tplg_pcm_dai *)tplg->pos;
1559
1560 if (soc_tplg_check_elem_count(tplg,
1561 sizeof(struct snd_soc_tplg_pcm), count,
1562 hdr->payload_size, "PCM DAI")) {
1563 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n",
1564 count);
1565 return -EINVAL;
1566 }
1567
1568 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count);
1569 tplg->pos += sizeof(struct snd_soc_tplg_pcm) * count;
1570
1571 dobj = kzalloc(sizeof(struct snd_soc_dobj), GFP_KERNEL);
1572 if (dobj == NULL)
1573 return -ENOMEM;
1574
1575 /* Call the platform driver call back to register the dais */
1576 ret = soc_tplg_pcm_dai_load(tplg, pcm_dai, count);
1577 if (ret < 0) {
1578 dev_err(tplg->comp->dev, "ASoC: PCM DAI loading failed\n");
1579 goto err;
1580 }
1581
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);
1588 return 0;
1589
1590 err:
1591 kfree(dobj);
1592 return ret;
1593 }
1594
1595 static int soc_tplg_manifest_load(struct soc_tplg *tplg,
1596 struct snd_soc_tplg_hdr *hdr)
1597 {
1598 struct snd_soc_tplg_manifest *manifest;
1599
1600 if (tplg->pass != SOC_TPLG_PASS_MANIFEST)
1601 return 0;
1602
1603 manifest = (struct snd_soc_tplg_manifest *)tplg->pos;
1604 tplg->pos += sizeof(struct snd_soc_tplg_manifest);
1605
1606 if (tplg->comp && tplg->ops && tplg->ops->manifest)
1607 return tplg->ops->manifest(tplg->comp, manifest);
1608
1609 dev_err(tplg->dev, "ASoC: Firmware manifest not supported\n");
1610 return 0;
1611 }
1612
1613 /* validate header magic, size and type */
1614 static int soc_valid_header(struct soc_tplg *tplg,
1615 struct snd_soc_tplg_hdr *hdr)
1616 {
1617 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size)
1618 return 0;
1619
1620 /* big endian firmware objects not supported atm */
1621 if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) {
1622 dev_err(tplg->dev,
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);
1626 return -EINVAL;
1627 }
1628
1629 if (hdr->magic != SND_SOC_TPLG_MAGIC) {
1630 dev_err(tplg->dev,
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);
1634 return -EINVAL;
1635 }
1636
1637 if (hdr->abi != SND_SOC_TPLG_ABI_VERSION) {
1638 dev_err(tplg->dev,
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),
1642 tplg->fw->size);
1643 return -EINVAL;
1644 }
1645
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));
1649 return -EINVAL;
1650 }
1651
1652 if (tplg->pass == hdr->type)
1653 dev_dbg(tplg->dev,
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);
1657
1658 return 1;
1659 }
1660
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)
1664 {
1665 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr);
1666
1667 /* check for matching ID */
1668 if (hdr->index != tplg->req_index &&
1669 hdr->index != SND_SOC_TPLG_INDEX_ALL)
1670 return 0;
1671
1672 tplg->index = hdr->index;
1673
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);
1689 default:
1690 /* bespoke vendor data object */
1691 return soc_tplg_vendor_load(tplg, hdr);
1692 }
1693
1694 return 0;
1695 }
1696
1697 /* process the topology file headers */
1698 static int soc_tplg_process_headers(struct soc_tplg *tplg)
1699 {
1700 struct snd_soc_tplg_hdr *hdr;
1701 int ret;
1702
1703 tplg->pass = SOC_TPLG_PASS_START;
1704
1705 /* process the header types from start to end */
1706 while (tplg->pass <= SOC_TPLG_PASS_END) {
1707
1708 tplg->hdr_pos = tplg->fw->data;
1709 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1710
1711 while (!soc_tplg_is_eof(tplg)) {
1712
1713 /* make sure header is valid before loading */
1714 ret = soc_valid_header(tplg, hdr);
1715 if (ret < 0)
1716 return ret;
1717 else if (ret == 0)
1718 break;
1719
1720 /* load the header object */
1721 ret = soc_tplg_load_header(tplg, hdr);
1722 if (ret < 0)
1723 return ret;
1724
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;
1729 }
1730
1731 /* next data type pass */
1732 tplg->pass++;
1733 }
1734
1735 /* signal DAPM we are complete */
1736 ret = soc_tplg_dapm_complete(tplg);
1737 if (ret < 0)
1738 dev_err(tplg->dev,
1739 "ASoC: failed to initialise DAPM from Firmware\n");
1740
1741 return ret;
1742 }
1743
1744 static int soc_tplg_load(struct soc_tplg *tplg)
1745 {
1746 int ret;
1747
1748 ret = soc_tplg_process_headers(tplg);
1749 if (ret == 0)
1750 soc_tplg_complete(tplg);
1751
1752 return ret;
1753 }
1754
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)
1758 {
1759 struct soc_tplg tplg;
1760
1761 /* setup parsing context */
1762 memset(&tplg, 0, sizeof(tplg));
1763 tplg.fw = fw;
1764 tplg.dev = comp->dev;
1765 tplg.comp = comp;
1766 tplg.ops = ops;
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;
1772
1773 return soc_tplg_load(&tplg);
1774 }
1775 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
1776
1777 /* remove this dynamic widget */
1778 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w)
1779 {
1780 /* make sure we are a widget */
1781 if (w->dobj.type != SND_SOC_DOBJ_WIDGET)
1782 return;
1783
1784 remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET);
1785 }
1786 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove);
1787
1788 /* remove all dynamic widgets from this DAPM context */
1789 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
1790 u32 index)
1791 {
1792 struct snd_soc_dapm_widget *w, *next_w;
1793
1794 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
1795
1796 /* make sure we are a widget with correct context */
1797 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm)
1798 continue;
1799
1800 /* match ID */
1801 if (w->dobj.index != index &&
1802 w->dobj.index != SND_SOC_TPLG_INDEX_ALL)
1803 continue;
1804 /* check and free and dynamic widget kcontrols */
1805 snd_soc_tplg_widget_remove(w);
1806 snd_soc_dapm_free_widget(w);
1807 }
1808 }
1809 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all);
1810
1811 /* remove dynamic controls from the component driver */
1812 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index)
1813 {
1814 struct snd_soc_dobj *dobj, *next_dobj;
1815 int pass = SOC_TPLG_PASS_END;
1816
1817 /* process the header types from end to start */
1818 while (pass >= SOC_TPLG_PASS_START) {
1819
1820 /* remove mixer controls */
1821 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list,
1822 list) {
1823
1824 /* match index */
1825 if (dobj->index != index &&
1826 dobj->index != SND_SOC_TPLG_INDEX_ALL)
1827 continue;
1828
1829 switch (dobj->type) {
1830 case SND_SOC_DOBJ_MIXER:
1831 remove_mixer(comp, dobj, pass);
1832 break;
1833 case SND_SOC_DOBJ_ENUM:
1834 remove_enum(comp, dobj, pass);
1835 break;
1836 case SND_SOC_DOBJ_BYTES:
1837 remove_bytes(comp, dobj, pass);
1838 break;
1839 case SND_SOC_DOBJ_WIDGET:
1840 remove_widget(comp, dobj, pass);
1841 break;
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);
1846 break;
1847 default:
1848 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n",
1849 dobj->type);
1850 break;
1851 }
1852 }
1853 pass--;
1854 }
1855
1856 /* let caller know if FW can be freed when no objects are left */
1857 return !list_empty(&comp->dobj_list);
1858 }
1859 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove);
Michael's Linux tree.