?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: usb-audio: Avoid access before bLength check in build_audio_procunit()
[linux/fpc-iii.git] / sound / soc / soc-topology.c
blobd6b48c796bfcefd5471d088d6cba2000c3a54568
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 #define SOC_TPLG_PASS_BE_DAI 7
52
53 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST
54 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_BE_DAI
55
56 struct soc_tplg {
57 const struct firmware *fw;
58
59 /* runtime FW parsing */
60 const u8 *pos; /* read postion */
61 const u8 *hdr_pos; /* header position */
62 unsigned int pass; /* pass number */
63
64 /* component caller */
65 struct device *dev;
66 struct snd_soc_component *comp;
67 u32 index; /* current block index */
68 u32 req_index; /* required index, only loaded/free matching blocks */
69
70 /* vendor specific kcontrol operations */
71 const struct snd_soc_tplg_kcontrol_ops *io_ops;
72 int io_ops_count;
73
74 /* vendor specific bytes ext handlers, for TLV bytes controls */
75 const struct snd_soc_tplg_bytes_ext_ops *bytes_ext_ops;
76 int bytes_ext_ops_count;
77
78 /* optional fw loading callbacks to component drivers */
79 struct snd_soc_tplg_ops *ops;
80 };
81
82 static int soc_tplg_process_headers(struct soc_tplg *tplg);
83 static void soc_tplg_complete(struct soc_tplg *tplg);
84 struct snd_soc_dapm_widget *
85 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
86 const struct snd_soc_dapm_widget *widget);
87 struct snd_soc_dapm_widget *
88 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
89 const struct snd_soc_dapm_widget *widget);
90
91 /* check we dont overflow the data for this control chunk */
92 static int soc_tplg_check_elem_count(struct soc_tplg *tplg, size_t elem_size,
93 unsigned int count, size_t bytes, const char *elem_type)
94 {
95 const u8 *end = tplg->pos + elem_size * count;
96
97 if (end > tplg->fw->data + tplg->fw->size) {
98 dev_err(tplg->dev, "ASoC: %s overflow end of data\n",
99 elem_type);
100 return -EINVAL;
101 }
102
103 /* check there is enough room in chunk for control.
104 extra bytes at the end of control are for vendor data here */
105 if (elem_size * count > bytes) {
106 dev_err(tplg->dev,
107 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
108 elem_type, count, elem_size, bytes);
109 return -EINVAL;
110 }
111
112 return 0;
113 }
114
115 static inline int soc_tplg_is_eof(struct soc_tplg *tplg)
116 {
117 const u8 *end = tplg->hdr_pos;
118
119 if (end >= tplg->fw->data + tplg->fw->size)
120 return 1;
121 return 0;
122 }
123
124 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg)
125 {
126 return (unsigned long)(tplg->hdr_pos - tplg->fw->data);
127 }
128
129 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg)
130 {
131 return (unsigned long)(tplg->pos - tplg->fw->data);
132 }
133
134 /* mapping of Kcontrol types and associated operations. */
135 static const struct snd_soc_tplg_kcontrol_ops io_ops[] = {
136 {SND_SOC_TPLG_CTL_VOLSW, snd_soc_get_volsw,
137 snd_soc_put_volsw, snd_soc_info_volsw},
138 {SND_SOC_TPLG_CTL_VOLSW_SX, snd_soc_get_volsw_sx,
139 snd_soc_put_volsw_sx, NULL},
140 {SND_SOC_TPLG_CTL_ENUM, snd_soc_get_enum_double,
141 snd_soc_put_enum_double, snd_soc_info_enum_double},
142 {SND_SOC_TPLG_CTL_ENUM_VALUE, snd_soc_get_enum_double,
143 snd_soc_put_enum_double, NULL},
144 {SND_SOC_TPLG_CTL_BYTES, snd_soc_bytes_get,
145 snd_soc_bytes_put, snd_soc_bytes_info},
146 {SND_SOC_TPLG_CTL_RANGE, snd_soc_get_volsw_range,
147 snd_soc_put_volsw_range, snd_soc_info_volsw_range},
148 {SND_SOC_TPLG_CTL_VOLSW_XR_SX, snd_soc_get_xr_sx,
149 snd_soc_put_xr_sx, snd_soc_info_xr_sx},
150 {SND_SOC_TPLG_CTL_STROBE, snd_soc_get_strobe,
151 snd_soc_put_strobe, NULL},
152 {SND_SOC_TPLG_DAPM_CTL_VOLSW, snd_soc_dapm_get_volsw,
153 snd_soc_dapm_put_volsw, snd_soc_info_volsw},
154 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE, snd_soc_dapm_get_enum_double,
155 snd_soc_dapm_put_enum_double, snd_soc_info_enum_double},
156 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT, snd_soc_dapm_get_enum_double,
157 snd_soc_dapm_put_enum_double, NULL},
158 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE, snd_soc_dapm_get_enum_double,
159 snd_soc_dapm_put_enum_double, NULL},
160 {SND_SOC_TPLG_DAPM_CTL_PIN, snd_soc_dapm_get_pin_switch,
161 snd_soc_dapm_put_pin_switch, snd_soc_dapm_info_pin_switch},
162 };
163
164 struct soc_tplg_map {
165 int uid;
166 int kid;
167 };
168
169 /* mapping of widget types from UAPI IDs to kernel IDs */
170 static const struct soc_tplg_map dapm_map[] = {
171 {SND_SOC_TPLG_DAPM_INPUT, snd_soc_dapm_input},
172 {SND_SOC_TPLG_DAPM_OUTPUT, snd_soc_dapm_output},
173 {SND_SOC_TPLG_DAPM_MUX, snd_soc_dapm_mux},
174 {SND_SOC_TPLG_DAPM_MIXER, snd_soc_dapm_mixer},
175 {SND_SOC_TPLG_DAPM_PGA, snd_soc_dapm_pga},
176 {SND_SOC_TPLG_DAPM_OUT_DRV, snd_soc_dapm_out_drv},
177 {SND_SOC_TPLG_DAPM_ADC, snd_soc_dapm_adc},
178 {SND_SOC_TPLG_DAPM_DAC, snd_soc_dapm_dac},
179 {SND_SOC_TPLG_DAPM_SWITCH, snd_soc_dapm_switch},
180 {SND_SOC_TPLG_DAPM_PRE, snd_soc_dapm_pre},
181 {SND_SOC_TPLG_DAPM_POST, snd_soc_dapm_post},
182 {SND_SOC_TPLG_DAPM_AIF_IN, snd_soc_dapm_aif_in},
183 {SND_SOC_TPLG_DAPM_AIF_OUT, snd_soc_dapm_aif_out},
184 {SND_SOC_TPLG_DAPM_DAI_IN, snd_soc_dapm_dai_in},
185 {SND_SOC_TPLG_DAPM_DAI_OUT, snd_soc_dapm_dai_out},
186 {SND_SOC_TPLG_DAPM_DAI_LINK, snd_soc_dapm_dai_link},
187 };
188
189 static int tplc_chan_get_reg(struct soc_tplg *tplg,
190 struct snd_soc_tplg_channel *chan, int map)
191 {
192 int i;
193
194 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
195 if (chan[i].id == map)
196 return chan[i].reg;
197 }
198
199 return -EINVAL;
200 }
201
202 static int tplc_chan_get_shift(struct soc_tplg *tplg,
203 struct snd_soc_tplg_channel *chan, int map)
204 {
205 int i;
206
207 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
208 if (chan[i].id == map)
209 return chan[i].shift;
210 }
211
212 return -EINVAL;
213 }
214
215 static int get_widget_id(int tplg_type)
216 {
217 int i;
218
219 for (i = 0; i < ARRAY_SIZE(dapm_map); i++) {
220 if (tplg_type == dapm_map[i].uid)
221 return dapm_map[i].kid;
222 }
223
224 return -EINVAL;
225 }
226
227 static inline void soc_bind_err(struct soc_tplg *tplg,
228 struct snd_soc_tplg_ctl_hdr *hdr, int index)
229 {
230 dev_err(tplg->dev,
231 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n",
232 hdr->ops.get, hdr->ops.put, hdr->ops.info, index,
233 soc_tplg_get_offset(tplg));
234 }
235
236 static inline void soc_control_err(struct soc_tplg *tplg,
237 struct snd_soc_tplg_ctl_hdr *hdr, const char *name)
238 {
239 dev_err(tplg->dev,
240 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n",
241 name, hdr->ops.get, hdr->ops.put, hdr->ops.info,
242 soc_tplg_get_offset(tplg));
243 }
244
245 /* pass vendor data to component driver for processing */
246 static int soc_tplg_vendor_load_(struct soc_tplg *tplg,
247 struct snd_soc_tplg_hdr *hdr)
248 {
249 int ret = 0;
250
251 if (tplg->comp && tplg->ops && tplg->ops->vendor_load)
252 ret = tplg->ops->vendor_load(tplg->comp, hdr);
253 else {
254 dev_err(tplg->dev, "ASoC: no vendor load callback for ID %d\n",
255 hdr->vendor_type);
256 return -EINVAL;
257 }
258
259 if (ret < 0)
260 dev_err(tplg->dev,
261 "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n",
262 soc_tplg_get_hdr_offset(tplg),
263 soc_tplg_get_hdr_offset(tplg),
264 hdr->type, hdr->vendor_type);
265 return ret;
266 }
267
268 /* pass vendor data to component driver for processing */
269 static int soc_tplg_vendor_load(struct soc_tplg *tplg,
270 struct snd_soc_tplg_hdr *hdr)
271 {
272 if (tplg->pass != SOC_TPLG_PASS_VENDOR)
273 return 0;
274
275 return soc_tplg_vendor_load_(tplg, hdr);
276 }
277
278 /* optionally pass new dynamic widget to component driver. This is mainly for
279 * external widgets where we can assign private data/ops */
280 static int soc_tplg_widget_load(struct soc_tplg *tplg,
281 struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w)
282 {
283 if (tplg->comp && tplg->ops && tplg->ops->widget_load)
284 return tplg->ops->widget_load(tplg->comp, w, tplg_w);
285
286 return 0;
287 }
288
289 /* pass DAI configurations to component driver for extra intialization */
290 static int soc_tplg_dai_load(struct soc_tplg *tplg,
291 struct snd_soc_dai_driver *dai_drv)
292 {
293 if (tplg->comp && tplg->ops && tplg->ops->dai_load)
294 return tplg->ops->dai_load(tplg->comp, dai_drv);
295
296 return 0;
297 }
298
299 /* pass link configurations to component driver for extra intialization */
300 static int soc_tplg_dai_link_load(struct soc_tplg *tplg,
301 struct snd_soc_dai_link *link)
302 {
303 if (tplg->comp && tplg->ops && tplg->ops->link_load)
304 return tplg->ops->link_load(tplg->comp, link);
305
306 return 0;
307 }
308
309 /* tell the component driver that all firmware has been loaded in this request */
310 static void soc_tplg_complete(struct soc_tplg *tplg)
311 {
312 if (tplg->comp && tplg->ops && tplg->ops->complete)
313 tplg->ops->complete(tplg->comp);
314 }
315
316 /* add a dynamic kcontrol */
317 static int soc_tplg_add_dcontrol(struct snd_card *card, struct device *dev,
318 const struct snd_kcontrol_new *control_new, const char *prefix,
319 void *data, struct snd_kcontrol **kcontrol)
320 {
321 int err;
322
323 *kcontrol = snd_soc_cnew(control_new, data, control_new->name, prefix);
324 if (*kcontrol == NULL) {
325 dev_err(dev, "ASoC: Failed to create new kcontrol %s\n",
326 control_new->name);
327 return -ENOMEM;
328 }
329
330 err = snd_ctl_add(card, *kcontrol);
331 if (err < 0) {
332 dev_err(dev, "ASoC: Failed to add %s: %d\n",
333 control_new->name, err);
334 return err;
335 }
336
337 return 0;
338 }
339
340 /* add a dynamic kcontrol for component driver */
341 static int soc_tplg_add_kcontrol(struct soc_tplg *tplg,
342 struct snd_kcontrol_new *k, struct snd_kcontrol **kcontrol)
343 {
344 struct snd_soc_component *comp = tplg->comp;
345
346 return soc_tplg_add_dcontrol(comp->card->snd_card,
347 comp->dev, k, NULL, comp, kcontrol);
348 }
349
350 /* remove a mixer kcontrol */
351 static void remove_mixer(struct snd_soc_component *comp,
352 struct snd_soc_dobj *dobj, int pass)
353 {
354 struct snd_card *card = comp->card->snd_card;
355 struct soc_mixer_control *sm =
356 container_of(dobj, struct soc_mixer_control, dobj);
357 const unsigned int *p = NULL;
358
359 if (pass != SOC_TPLG_PASS_MIXER)
360 return;
361
362 if (dobj->ops && dobj->ops->control_unload)
363 dobj->ops->control_unload(comp, dobj);
364
365 if (sm->dobj.control.kcontrol->tlv.p)
366 p = sm->dobj.control.kcontrol->tlv.p;
367 snd_ctl_remove(card, sm->dobj.control.kcontrol);
368 list_del(&sm->dobj.list);
369 kfree(sm);
370 kfree(p);
371 }
372
373 /* remove an enum kcontrol */
374 static void remove_enum(struct snd_soc_component *comp,
375 struct snd_soc_dobj *dobj, int pass)
376 {
377 struct snd_card *card = comp->card->snd_card;
378 struct soc_enum *se = container_of(dobj, struct soc_enum, dobj);
379 int i;
380
381 if (pass != SOC_TPLG_PASS_MIXER)
382 return;
383
384 if (dobj->ops && dobj->ops->control_unload)
385 dobj->ops->control_unload(comp, dobj);
386
387 snd_ctl_remove(card, se->dobj.control.kcontrol);
388 list_del(&se->dobj.list);
389
390 kfree(se->dobj.control.dvalues);
391 for (i = 0; i < se->items; i++)
392 kfree(se->dobj.control.dtexts[i]);
393 kfree(se);
394 }
395
396 /* remove a byte kcontrol */
397 static void remove_bytes(struct snd_soc_component *comp,
398 struct snd_soc_dobj *dobj, int pass)
399 {
400 struct snd_card *card = comp->card->snd_card;
401 struct soc_bytes_ext *sb =
402 container_of(dobj, struct soc_bytes_ext, dobj);
403
404 if (pass != SOC_TPLG_PASS_MIXER)
405 return;
406
407 if (dobj->ops && dobj->ops->control_unload)
408 dobj->ops->control_unload(comp, dobj);
409
410 snd_ctl_remove(card, sb->dobj.control.kcontrol);
411 list_del(&sb->dobj.list);
412 kfree(sb);
413 }
414
415 /* remove a widget and it's kcontrols - routes must be removed first */
416 static void remove_widget(struct snd_soc_component *comp,
417 struct snd_soc_dobj *dobj, int pass)
418 {
419 struct snd_card *card = comp->card->snd_card;
420 struct snd_soc_dapm_widget *w =
421 container_of(dobj, struct snd_soc_dapm_widget, dobj);
422 int i;
423
424 if (pass != SOC_TPLG_PASS_WIDGET)
425 return;
426
427 if (dobj->ops && dobj->ops->widget_unload)
428 dobj->ops->widget_unload(comp, dobj);
429
430 /*
431 * Dynamic Widgets either have 1 enum kcontrol or 1..N mixers.
432 * The enum may either have an array of values or strings.
433 */
434 if (dobj->widget.kcontrol_enum) {
435 /* enumerated widget mixer */
436 struct soc_enum *se =
437 (struct soc_enum *)w->kcontrols[0]->private_value;
438
439 snd_ctl_remove(card, w->kcontrols[0]);
440
441 kfree(se->dobj.control.dvalues);
442 for (i = 0; i < se->items; i++)
443 kfree(se->dobj.control.dtexts[i]);
444
445 kfree(se);
446 kfree(w->kcontrol_news);
447 } else {
448 /* non enumerated widget mixer */
449 for (i = 0; i < w->num_kcontrols; i++) {
450 struct snd_kcontrol *kcontrol = w->kcontrols[i];
451 struct soc_mixer_control *sm =
452 (struct soc_mixer_control *) kcontrol->private_value;
453
454 kfree(w->kcontrols[i]->tlv.p);
455
456 snd_ctl_remove(card, w->kcontrols[i]);
457 kfree(sm);
458 }
459 kfree(w->kcontrol_news);
460 }
461 /* widget w is freed by soc-dapm.c */
462 }
463
464 /* remove DAI configurations */
465 static void remove_dai(struct snd_soc_component *comp,
466 struct snd_soc_dobj *dobj, int pass)
467 {
468 struct snd_soc_dai_driver *dai_drv =
469 container_of(dobj, struct snd_soc_dai_driver, dobj);
470
471 if (pass != SOC_TPLG_PASS_PCM_DAI)
472 return;
473
474 if (dobj->ops && dobj->ops->dai_unload)
475 dobj->ops->dai_unload(comp, dobj);
476
477 list_del(&dobj->list);
478 kfree(dai_drv);
479 }
480
481 /* remove link configurations */
482 static void remove_link(struct snd_soc_component *comp,
483 struct snd_soc_dobj *dobj, int pass)
484 {
485 struct snd_soc_dai_link *link =
486 container_of(dobj, struct snd_soc_dai_link, dobj);
487
488 if (pass != SOC_TPLG_PASS_PCM_DAI)
489 return;
490
491 if (dobj->ops && dobj->ops->link_unload)
492 dobj->ops->link_unload(comp, dobj);
493
494 list_del(&dobj->list);
495 snd_soc_remove_dai_link(comp->card, link);
496 kfree(link);
497 }
498
499 /* bind a kcontrol to it's IO handlers */
500 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr *hdr,
501 struct snd_kcontrol_new *k,
502 const struct soc_tplg *tplg)
503 {
504 const struct snd_soc_tplg_kcontrol_ops *ops;
505 const struct snd_soc_tplg_bytes_ext_ops *ext_ops;
506 int num_ops, i;
507
508 if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES
509 && k->iface & SNDRV_CTL_ELEM_IFACE_MIXER
510 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
511 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
512 struct soc_bytes_ext *sbe;
513 struct snd_soc_tplg_bytes_control *be;
514
515 sbe = (struct soc_bytes_ext *)k->private_value;
516 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
517
518 /* TLV bytes controls need standard kcontrol info handler,
519 * TLV callback and extended put/get handlers.
520 */
521 k->info = snd_soc_bytes_info_ext;
522 k->tlv.c = snd_soc_bytes_tlv_callback;
523
524 ext_ops = tplg->bytes_ext_ops;
525 num_ops = tplg->bytes_ext_ops_count;
526 for (i = 0; i < num_ops; i++) {
527 if (!sbe->put && ext_ops[i].id == be->ext_ops.put)
528 sbe->put = ext_ops[i].put;
529 if (!sbe->get && ext_ops[i].id == be->ext_ops.get)
530 sbe->get = ext_ops[i].get;
531 }
532
533 if (sbe->put && sbe->get)
534 return 0;
535 else
536 return -EINVAL;
537 }
538
539 /* try and map vendor specific kcontrol handlers first */
540 ops = tplg->io_ops;
541 num_ops = tplg->io_ops_count;
542 for (i = 0; i < num_ops; i++) {
543
544 if (k->put == NULL && ops[i].id == hdr->ops.put)
545 k->put = ops[i].put;
546 if (k->get == NULL && ops[i].id == hdr->ops.get)
547 k->get = ops[i].get;
548 if (k->info == NULL && ops[i].id == hdr->ops.info)
549 k->info = ops[i].info;
550 }
551
552 /* vendor specific handlers found ? */
553 if (k->put && k->get && k->info)
554 return 0;
555
556 /* none found so try standard kcontrol handlers */
557 ops = io_ops;
558 num_ops = ARRAY_SIZE(io_ops);
559 for (i = 0; i < num_ops; i++) {
560
561 if (k->put == NULL && ops[i].id == hdr->ops.put)
562 k->put = ops[i].put;
563 if (k->get == NULL && ops[i].id == hdr->ops.get)
564 k->get = ops[i].get;
565 if (k->info == NULL && ops[i].id == hdr->ops.info)
566 k->info = ops[i].info;
567 }
568
569 /* standard handlers found ? */
570 if (k->put && k->get && k->info)
571 return 0;
572
573 /* nothing to bind */
574 return -EINVAL;
575 }
576
577 /* bind a widgets to it's evnt handlers */
578 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w,
579 const struct snd_soc_tplg_widget_events *events,
580 int num_events, u16 event_type)
581 {
582 int i;
583
584 w->event = NULL;
585
586 for (i = 0; i < num_events; i++) {
587 if (event_type == events[i].type) {
588
589 /* found - so assign event */
590 w->event = events[i].event_handler;
591 return 0;
592 }
593 }
594
595 /* not found */
596 return -EINVAL;
597 }
598 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event);
599
600 /* optionally pass new dynamic kcontrol to component driver. */
601 static int soc_tplg_init_kcontrol(struct soc_tplg *tplg,
602 struct snd_kcontrol_new *k, struct snd_soc_tplg_ctl_hdr *hdr)
603 {
604 if (tplg->comp && tplg->ops && tplg->ops->control_load)
605 return tplg->ops->control_load(tplg->comp, k, hdr);
606
607 return 0;
608 }
609
610
611 static int soc_tplg_create_tlv_db_scale(struct soc_tplg *tplg,
612 struct snd_kcontrol_new *kc, struct snd_soc_tplg_tlv_dbscale *scale)
613 {
614 unsigned int item_len = 2 * sizeof(unsigned int);
615 unsigned int *p;
616
617 p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL);
618 if (!p)
619 return -ENOMEM;
620
621 p[0] = SNDRV_CTL_TLVT_DB_SCALE;
622 p[1] = item_len;
623 p[2] = scale->min;
624 p[3] = (scale->step & TLV_DB_SCALE_MASK)
625 | (scale->mute ? TLV_DB_SCALE_MUTE : 0);
626
627 kc->tlv.p = (void *)p;
628 return 0;
629 }
630
631 static int soc_tplg_create_tlv(struct soc_tplg *tplg,
632 struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc)
633 {
634 struct snd_soc_tplg_ctl_tlv *tplg_tlv;
635
636 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE))
637 return 0;
638
639 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) {
640 tplg_tlv = &tc->tlv;
641 switch (tplg_tlv->type) {
642 case SNDRV_CTL_TLVT_DB_SCALE:
643 return soc_tplg_create_tlv_db_scale(tplg, kc,
644 &tplg_tlv->scale);
645
646 /* TODO: add support for other TLV types */
647 default:
648 dev_dbg(tplg->dev, "Unsupported TLV type %d\n",
649 tplg_tlv->type);
650 return -EINVAL;
651 }
652 }
653
654 return 0;
655 }
656
657 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg,
658 struct snd_kcontrol_new *kc)
659 {
660 kfree(kc->tlv.p);
661 }
662
663 static int soc_tplg_dbytes_create(struct soc_tplg *tplg, unsigned int count,
664 size_t size)
665 {
666 struct snd_soc_tplg_bytes_control *be;
667 struct soc_bytes_ext *sbe;
668 struct snd_kcontrol_new kc;
669 int i, err;
670
671 if (soc_tplg_check_elem_count(tplg,
672 sizeof(struct snd_soc_tplg_bytes_control), count,
673 size, "mixer bytes")) {
674 dev_err(tplg->dev, "ASoC: Invalid count %d for byte control\n",
675 count);
676 return -EINVAL;
677 }
678
679 for (i = 0; i < count; i++) {
680 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
681
682 /* validate kcontrol */
683 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
684 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
685 return -EINVAL;
686
687 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
688 if (sbe == NULL)
689 return -ENOMEM;
690
691 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
692 be->priv.size);
693
694 dev_dbg(tplg->dev,
695 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
696 be->hdr.name, be->hdr.access);
697
698 memset(&kc, 0, sizeof(kc));
699 kc.name = be->hdr.name;
700 kc.private_value = (long)sbe;
701 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
702 kc.access = be->hdr.access;
703
704 sbe->max = be->max;
705 sbe->dobj.type = SND_SOC_DOBJ_BYTES;
706 sbe->dobj.ops = tplg->ops;
707 INIT_LIST_HEAD(&sbe->dobj.list);
708
709 /* map io handlers */
710 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg);
711 if (err) {
712 soc_control_err(tplg, &be->hdr, be->hdr.name);
713 kfree(sbe);
714 continue;
715 }
716
717 /* pass control to driver for optional further init */
718 err = soc_tplg_init_kcontrol(tplg, &kc,
719 (struct snd_soc_tplg_ctl_hdr *)be);
720 if (err < 0) {
721 dev_err(tplg->dev, "ASoC: failed to init %s\n",
722 be->hdr.name);
723 kfree(sbe);
724 continue;
725 }
726
727 /* register control here */
728 err = soc_tplg_add_kcontrol(tplg, &kc,
729 &sbe->dobj.control.kcontrol);
730 if (err < 0) {
731 dev_err(tplg->dev, "ASoC: failed to add %s\n",
732 be->hdr.name);
733 kfree(sbe);
734 continue;
735 }
736
737 list_add(&sbe->dobj.list, &tplg->comp->dobj_list);
738 }
739 return 0;
740
741 }
742
743 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count,
744 size_t size)
745 {
746 struct snd_soc_tplg_mixer_control *mc;
747 struct soc_mixer_control *sm;
748 struct snd_kcontrol_new kc;
749 int i, err;
750
751 if (soc_tplg_check_elem_count(tplg,
752 sizeof(struct snd_soc_tplg_mixer_control),
753 count, size, "mixers")) {
754
755 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n",
756 count);
757 return -EINVAL;
758 }
759
760 for (i = 0; i < count; i++) {
761 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
762
763 /* validate kcontrol */
764 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
765 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
766 return -EINVAL;
767
768 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
769 if (sm == NULL)
770 return -ENOMEM;
771 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
772 mc->priv.size);
773
774 dev_dbg(tplg->dev,
775 "ASoC: adding mixer kcontrol %s with access 0x%x\n",
776 mc->hdr.name, mc->hdr.access);
777
778 memset(&kc, 0, sizeof(kc));
779 kc.name = mc->hdr.name;
780 kc.private_value = (long)sm;
781 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
782 kc.access = mc->hdr.access;
783
784 /* we only support FL/FR channel mapping atm */
785 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
786 SNDRV_CHMAP_FL);
787 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
788 SNDRV_CHMAP_FR);
789 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
790 SNDRV_CHMAP_FL);
791 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
792 SNDRV_CHMAP_FR);
793
794 sm->max = mc->max;
795 sm->min = mc->min;
796 sm->invert = mc->invert;
797 sm->platform_max = mc->platform_max;
798 sm->dobj.index = tplg->index;
799 sm->dobj.ops = tplg->ops;
800 sm->dobj.type = SND_SOC_DOBJ_MIXER;
801 INIT_LIST_HEAD(&sm->dobj.list);
802
803 /* map io handlers */
804 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg);
805 if (err) {
806 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
807 kfree(sm);
808 continue;
809 }
810
811 /* pass control to driver for optional further init */
812 err = soc_tplg_init_kcontrol(tplg, &kc,
813 (struct snd_soc_tplg_ctl_hdr *) mc);
814 if (err < 0) {
815 dev_err(tplg->dev, "ASoC: failed to init %s\n",
816 mc->hdr.name);
817 kfree(sm);
818 continue;
819 }
820
821 /* create any TLV data */
822 soc_tplg_create_tlv(tplg, &kc, &mc->hdr);
823
824 /* register control here */
825 err = soc_tplg_add_kcontrol(tplg, &kc,
826 &sm->dobj.control.kcontrol);
827 if (err < 0) {
828 dev_err(tplg->dev, "ASoC: failed to add %s\n",
829 mc->hdr.name);
830 soc_tplg_free_tlv(tplg, &kc);
831 kfree(sm);
832 continue;
833 }
834
835 list_add(&sm->dobj.list, &tplg->comp->dobj_list);
836 }
837
838 return 0;
839 }
840
841 static int soc_tplg_denum_create_texts(struct soc_enum *se,
842 struct snd_soc_tplg_enum_control *ec)
843 {
844 int i, ret;
845
846 se->dobj.control.dtexts =
847 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL);
848 if (se->dobj.control.dtexts == NULL)
849 return -ENOMEM;
850
851 for (i = 0; i < ec->items; i++) {
852
853 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
854 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) {
855 ret = -EINVAL;
856 goto err;
857 }
858
859 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL);
860 if (!se->dobj.control.dtexts[i]) {
861 ret = -ENOMEM;
862 goto err;
863 }
864 }
865
866 return 0;
867
868 err:
869 for (--i; i >= 0; i--)
870 kfree(se->dobj.control.dtexts[i]);
871 kfree(se->dobj.control.dtexts);
872 return ret;
873 }
874
875 static int soc_tplg_denum_create_values(struct soc_enum *se,
876 struct snd_soc_tplg_enum_control *ec)
877 {
878 if (ec->items > sizeof(*ec->values))
879 return -EINVAL;
880
881 se->dobj.control.dvalues = kmemdup(ec->values,
882 ec->items * sizeof(u32),
883 GFP_KERNEL);
884 if (!se->dobj.control.dvalues)
885 return -ENOMEM;
886
887 return 0;
888 }
889
890 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count,
891 size_t size)
892 {
893 struct snd_soc_tplg_enum_control *ec;
894 struct soc_enum *se;
895 struct snd_kcontrol_new kc;
896 int i, ret, err;
897
898 if (soc_tplg_check_elem_count(tplg,
899 sizeof(struct snd_soc_tplg_enum_control),
900 count, size, "enums")) {
901
902 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n",
903 count);
904 return -EINVAL;
905 }
906
907 for (i = 0; i < count; i++) {
908 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
909 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
910 ec->priv.size);
911
912 /* validate kcontrol */
913 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
914 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
915 return -EINVAL;
916
917 se = kzalloc((sizeof(*se)), GFP_KERNEL);
918 if (se == NULL)
919 return -ENOMEM;
920
921 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n",
922 ec->hdr.name, ec->items);
923
924 memset(&kc, 0, sizeof(kc));
925 kc.name = ec->hdr.name;
926 kc.private_value = (long)se;
927 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
928 kc.access = ec->hdr.access;
929
930 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
931 se->shift_l = tplc_chan_get_shift(tplg, ec->channel,
932 SNDRV_CHMAP_FL);
933 se->shift_r = tplc_chan_get_shift(tplg, ec->channel,
934 SNDRV_CHMAP_FL);
935
936 se->items = ec->items;
937 se->mask = ec->mask;
938 se->dobj.index = tplg->index;
939 se->dobj.type = SND_SOC_DOBJ_ENUM;
940 se->dobj.ops = tplg->ops;
941 INIT_LIST_HEAD(&se->dobj.list);
942
943 switch (ec->hdr.ops.info) {
944 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
945 case SND_SOC_TPLG_CTL_ENUM_VALUE:
946 err = soc_tplg_denum_create_values(se, ec);
947 if (err < 0) {
948 dev_err(tplg->dev,
949 "ASoC: could not create values for %s\n",
950 ec->hdr.name);
951 kfree(se);
952 continue;
953 }
954 /* fall through and create texts */
955 case SND_SOC_TPLG_CTL_ENUM:
956 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
957 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
958 err = soc_tplg_denum_create_texts(se, ec);
959 if (err < 0) {
960 dev_err(tplg->dev,
961 "ASoC: could not create texts for %s\n",
962 ec->hdr.name);
963 kfree(se);
964 continue;
965 }
966 break;
967 default:
968 dev_err(tplg->dev,
969 "ASoC: invalid enum control type %d for %s\n",
970 ec->hdr.ops.info, ec->hdr.name);
971 kfree(se);
972 continue;
973 }
974
975 /* map io handlers */
976 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg);
977 if (err) {
978 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
979 kfree(se);
980 continue;
981 }
982
983 /* pass control to driver for optional further init */
984 err = soc_tplg_init_kcontrol(tplg, &kc,
985 (struct snd_soc_tplg_ctl_hdr *) ec);
986 if (err < 0) {
987 dev_err(tplg->dev, "ASoC: failed to init %s\n",
988 ec->hdr.name);
989 kfree(se);
990 continue;
991 }
992
993 /* register control here */
994 ret = soc_tplg_add_kcontrol(tplg,
995 &kc, &se->dobj.control.kcontrol);
996 if (ret < 0) {
997 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n",
998 ec->hdr.name);
999 kfree(se);
1000 continue;
1001 }
1002
1003 list_add(&se->dobj.list, &tplg->comp->dobj_list);
1004 }
1005
1006 return 0;
1007 }
1008
1009 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg,
1010 struct snd_soc_tplg_hdr *hdr)
1011 {
1012 struct snd_soc_tplg_ctl_hdr *control_hdr;
1013 int i;
1014
1015 if (tplg->pass != SOC_TPLG_PASS_MIXER) {
1016 tplg->pos += hdr->size + hdr->payload_size;
1017 return 0;
1018 }
1019
1020 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count,
1021 soc_tplg_get_offset(tplg));
1022
1023 for (i = 0; i < hdr->count; i++) {
1024
1025 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1026
1027 if (control_hdr->size != sizeof(*control_hdr)) {
1028 dev_err(tplg->dev, "ASoC: invalid control size\n");
1029 return -EINVAL;
1030 }
1031
1032 switch (control_hdr->ops.info) {
1033 case SND_SOC_TPLG_CTL_VOLSW:
1034 case SND_SOC_TPLG_CTL_STROBE:
1035 case SND_SOC_TPLG_CTL_VOLSW_SX:
1036 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1037 case SND_SOC_TPLG_CTL_RANGE:
1038 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1039 case SND_SOC_TPLG_DAPM_CTL_PIN:
1040 soc_tplg_dmixer_create(tplg, 1, hdr->payload_size);
1041 break;
1042 case SND_SOC_TPLG_CTL_ENUM:
1043 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1044 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1045 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1046 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1047 soc_tplg_denum_create(tplg, 1, hdr->payload_size);
1048 break;
1049 case SND_SOC_TPLG_CTL_BYTES:
1050 soc_tplg_dbytes_create(tplg, 1, hdr->payload_size);
1051 break;
1052 default:
1053 soc_bind_err(tplg, control_hdr, i);
1054 return -EINVAL;
1055 }
1056 }
1057
1058 return 0;
1059 }
1060
1061 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg,
1062 struct snd_soc_tplg_hdr *hdr)
1063 {
1064 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1065 struct snd_soc_dapm_route route;
1066 struct snd_soc_tplg_dapm_graph_elem *elem;
1067 int count = hdr->count, i;
1068
1069 if (tplg->pass != SOC_TPLG_PASS_GRAPH) {
1070 tplg->pos += hdr->size + hdr->payload_size;
1071 return 0;
1072 }
1073
1074 if (soc_tplg_check_elem_count(tplg,
1075 sizeof(struct snd_soc_tplg_dapm_graph_elem),
1076 count, hdr->payload_size, "graph")) {
1077
1078 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n",
1079 count);
1080 return -EINVAL;
1081 }
1082
1083 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes\n", count);
1084
1085 for (i = 0; i < count; i++) {
1086 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos;
1087 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem);
1088
1089 /* validate routes */
1090 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1091 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1092 return -EINVAL;
1093 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1094 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1095 return -EINVAL;
1096 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1097 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1098 return -EINVAL;
1099
1100 route.source = elem->source;
1101 route.sink = elem->sink;
1102 route.connected = NULL; /* set to NULL atm for tplg users */
1103 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0)
1104 route.control = NULL;
1105 else
1106 route.control = elem->control;
1107
1108 /* add route, but keep going if some fail */
1109 snd_soc_dapm_add_routes(dapm, &route, 1);
1110 }
1111
1112 return 0;
1113 }
1114
1115 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create(
1116 struct soc_tplg *tplg, int num_kcontrols)
1117 {
1118 struct snd_kcontrol_new *kc;
1119 struct soc_mixer_control *sm;
1120 struct snd_soc_tplg_mixer_control *mc;
1121 int i, err;
1122
1123 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL);
1124 if (kc == NULL)
1125 return NULL;
1126
1127 for (i = 0; i < num_kcontrols; i++) {
1128 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
1129 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
1130 if (sm == NULL)
1131 goto err;
1132
1133 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
1134 mc->priv.size);
1135
1136 /* validate kcontrol */
1137 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1138 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1139 goto err_str;
1140
1141 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n",
1142 mc->hdr.name, i);
1143
1144 kc[i].name = mc->hdr.name;
1145 kc[i].private_value = (long)sm;
1146 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1147 kc[i].access = mc->hdr.access;
1148
1149 /* we only support FL/FR channel mapping atm */
1150 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
1151 SNDRV_CHMAP_FL);
1152 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
1153 SNDRV_CHMAP_FR);
1154 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
1155 SNDRV_CHMAP_FL);
1156 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
1157 SNDRV_CHMAP_FR);
1158
1159 sm->max = mc->max;
1160 sm->min = mc->min;
1161 sm->invert = mc->invert;
1162 sm->platform_max = mc->platform_max;
1163 sm->dobj.index = tplg->index;
1164 INIT_LIST_HEAD(&sm->dobj.list);
1165
1166 /* map io handlers */
1167 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg);
1168 if (err) {
1169 soc_control_err(tplg, &mc->hdr, mc->hdr.name);
1170 kfree(sm);
1171 continue;
1172 }
1173
1174 /* pass control to driver for optional further init */
1175 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1176 (struct snd_soc_tplg_ctl_hdr *)mc);
1177 if (err < 0) {
1178 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1179 mc->hdr.name);
1180 kfree(sm);
1181 continue;
1182 }
1183
1184 /* create any TLV data */
1185 soc_tplg_create_tlv(tplg, &kc[i], &mc->hdr);
1186 }
1187 return kc;
1188
1189 err_str:
1190 kfree(sm);
1191 err:
1192 for (--i; i >= 0; i--)
1193 kfree((void *)kc[i].private_value);
1194 kfree(kc);
1195 return NULL;
1196 }
1197
1198 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create(
1199 struct soc_tplg *tplg)
1200 {
1201 struct snd_kcontrol_new *kc;
1202 struct snd_soc_tplg_enum_control *ec;
1203 struct soc_enum *se;
1204 int i, err;
1205
1206 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
1207 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
1208 ec->priv.size);
1209
1210 /* validate kcontrol */
1211 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1212 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1213 return NULL;
1214
1215 kc = kzalloc(sizeof(*kc), GFP_KERNEL);
1216 if (kc == NULL)
1217 return NULL;
1218
1219 se = kzalloc(sizeof(*se), GFP_KERNEL);
1220 if (se == NULL)
1221 goto err;
1222
1223 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n",
1224 ec->hdr.name);
1225
1226 kc->name = ec->hdr.name;
1227 kc->private_value = (long)se;
1228 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1229 kc->access = ec->hdr.access;
1230
1231 /* we only support FL/FR channel mapping atm */
1232 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
1233 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FL);
1234 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FR);
1235
1236 se->items = ec->items;
1237 se->mask = ec->mask;
1238 se->dobj.index = tplg->index;
1239
1240 switch (ec->hdr.ops.info) {
1241 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1242 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1243 err = soc_tplg_denum_create_values(se, ec);
1244 if (err < 0) {
1245 dev_err(tplg->dev, "ASoC: could not create values for %s\n",
1246 ec->hdr.name);
1247 goto err_se;
1248 }
1249 /* fall through to create texts */
1250 case SND_SOC_TPLG_CTL_ENUM:
1251 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1252 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1253 err = soc_tplg_denum_create_texts(se, ec);
1254 if (err < 0) {
1255 dev_err(tplg->dev, "ASoC: could not create texts for %s\n",
1256 ec->hdr.name);
1257 goto err_se;
1258 }
1259 break;
1260 default:
1261 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n",
1262 ec->hdr.ops.info, ec->hdr.name);
1263 goto err_se;
1264 }
1265
1266 /* map io handlers */
1267 err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg);
1268 if (err) {
1269 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
1270 goto err_se;
1271 }
1272
1273 /* pass control to driver for optional further init */
1274 err = soc_tplg_init_kcontrol(tplg, kc,
1275 (struct snd_soc_tplg_ctl_hdr *)ec);
1276 if (err < 0) {
1277 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1278 ec->hdr.name);
1279 goto err_se;
1280 }
1281
1282 return kc;
1283
1284 err_se:
1285 /* free values and texts */
1286 kfree(se->dobj.control.dvalues);
1287 for (i = 0; i < ec->items; i++)
1288 kfree(se->dobj.control.dtexts[i]);
1289
1290 kfree(se);
1291 err:
1292 kfree(kc);
1293
1294 return NULL;
1295 }
1296
1297 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create(
1298 struct soc_tplg *tplg, int count)
1299 {
1300 struct snd_soc_tplg_bytes_control *be;
1301 struct soc_bytes_ext *sbe;
1302 struct snd_kcontrol_new *kc;
1303 int i, err;
1304
1305 kc = kcalloc(count, sizeof(*kc), GFP_KERNEL);
1306 if (!kc)
1307 return NULL;
1308
1309 for (i = 0; i < count; i++) {
1310 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
1311
1312 /* validate kcontrol */
1313 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1314 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1315 goto err;
1316
1317 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
1318 if (sbe == NULL)
1319 goto err;
1320
1321 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
1322 be->priv.size);
1323
1324 dev_dbg(tplg->dev,
1325 "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1326 be->hdr.name, be->hdr.access);
1327
1328 kc[i].name = be->hdr.name;
1329 kc[i].private_value = (long)sbe;
1330 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1331 kc[i].access = be->hdr.access;
1332
1333 sbe->max = be->max;
1334 INIT_LIST_HEAD(&sbe->dobj.list);
1335
1336 /* map standard io handlers and check for external handlers */
1337 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg);
1338 if (err) {
1339 soc_control_err(tplg, &be->hdr, be->hdr.name);
1340 kfree(sbe);
1341 continue;
1342 }
1343
1344 /* pass control to driver for optional further init */
1345 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1346 (struct snd_soc_tplg_ctl_hdr *)be);
1347 if (err < 0) {
1348 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1349 be->hdr.name);
1350 kfree(sbe);
1351 continue;
1352 }
1353 }
1354
1355 return kc;
1356
1357 err:
1358 for (--i; i >= 0; i--)
1359 kfree((void *)kc[i].private_value);
1360
1361 kfree(kc);
1362 return NULL;
1363 }
1364
1365 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg,
1366 struct snd_soc_tplg_dapm_widget *w)
1367 {
1368 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1369 struct snd_soc_dapm_widget template, *widget;
1370 struct snd_soc_tplg_ctl_hdr *control_hdr;
1371 struct snd_soc_card *card = tplg->comp->card;
1372 int ret = 0;
1373
1374 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1375 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1376 return -EINVAL;
1377 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1378 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1379 return -EINVAL;
1380
1381 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n",
1382 w->name, w->id);
1383
1384 memset(&template, 0, sizeof(template));
1385
1386 /* map user to kernel widget ID */
1387 template.id = get_widget_id(w->id);
1388 if (template.id < 0)
1389 return template.id;
1390
1391 template.name = kstrdup(w->name, GFP_KERNEL);
1392 if (!template.name)
1393 return -ENOMEM;
1394 template.sname = kstrdup(w->sname, GFP_KERNEL);
1395 if (!template.sname) {
1396 ret = -ENOMEM;
1397 goto err;
1398 }
1399 template.reg = w->reg;
1400 template.shift = w->shift;
1401 template.mask = w->mask;
1402 template.subseq = w->subseq;
1403 template.on_val = w->invert ? 0 : 1;
1404 template.off_val = w->invert ? 1 : 0;
1405 template.ignore_suspend = w->ignore_suspend;
1406 template.event_flags = w->event_flags;
1407 template.dobj.index = tplg->index;
1408
1409 tplg->pos +=
1410 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size);
1411 if (w->num_kcontrols == 0) {
1412 template.num_kcontrols = 0;
1413 goto widget;
1414 }
1415
1416 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1417 dev_dbg(tplg->dev, "ASoC: template %s has %d controls of type %x\n",
1418 w->name, w->num_kcontrols, control_hdr->type);
1419
1420 switch (control_hdr->ops.info) {
1421 case SND_SOC_TPLG_CTL_VOLSW:
1422 case SND_SOC_TPLG_CTL_STROBE:
1423 case SND_SOC_TPLG_CTL_VOLSW_SX:
1424 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1425 case SND_SOC_TPLG_CTL_RANGE:
1426 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1427 template.num_kcontrols = w->num_kcontrols;
1428 template.kcontrol_news =
1429 soc_tplg_dapm_widget_dmixer_create(tplg,
1430 template.num_kcontrols);
1431 if (!template.kcontrol_news) {
1432 ret = -ENOMEM;
1433 goto hdr_err;
1434 }
1435 break;
1436 case SND_SOC_TPLG_CTL_ENUM:
1437 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1438 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1439 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1440 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1441 template.dobj.widget.kcontrol_enum = 1;
1442 template.num_kcontrols = 1;
1443 template.kcontrol_news =
1444 soc_tplg_dapm_widget_denum_create(tplg);
1445 if (!template.kcontrol_news) {
1446 ret = -ENOMEM;
1447 goto hdr_err;
1448 }
1449 break;
1450 case SND_SOC_TPLG_CTL_BYTES:
1451 template.num_kcontrols = w->num_kcontrols;
1452 template.kcontrol_news =
1453 soc_tplg_dapm_widget_dbytes_create(tplg,
1454 template.num_kcontrols);
1455 if (!template.kcontrol_news) {
1456 ret = -ENOMEM;
1457 goto hdr_err;
1458 }
1459 break;
1460 default:
1461 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n",
1462 control_hdr->ops.get, control_hdr->ops.put,
1463 control_hdr->ops.info);
1464 ret = -EINVAL;
1465 goto hdr_err;
1466 }
1467
1468 widget:
1469 ret = soc_tplg_widget_load(tplg, &template, w);
1470 if (ret < 0)
1471 goto hdr_err;
1472
1473 /* card dapm mutex is held by the core if we are loading topology
1474 * data during sound card init. */
1475 if (card->instantiated)
1476 widget = snd_soc_dapm_new_control(dapm, &template);
1477 else
1478 widget = snd_soc_dapm_new_control_unlocked(dapm, &template);
1479 if (IS_ERR(widget)) {
1480 ret = PTR_ERR(widget);
1481 /* Do not nag about probe deferrals */
1482 if (ret != -EPROBE_DEFER)
1483 dev_err(tplg->dev,
1484 "ASoC: failed to create widget %s controls (%d)\n",
1485 w->name, ret);
1486 goto hdr_err;
1487 }
1488 if (widget == NULL) {
1489 dev_err(tplg->dev, "ASoC: failed to create widget %s controls\n",
1490 w->name);
1491 ret = -ENOMEM;
1492 goto hdr_err;
1493 }
1494
1495 widget->dobj.type = SND_SOC_DOBJ_WIDGET;
1496 widget->dobj.ops = tplg->ops;
1497 widget->dobj.index = tplg->index;
1498 kfree(template.sname);
1499 kfree(template.name);
1500 list_add(&widget->dobj.list, &tplg->comp->dobj_list);
1501 return 0;
1502
1503 hdr_err:
1504 kfree(template.sname);
1505 err:
1506 kfree(template.name);
1507 return ret;
1508 }
1509
1510 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg,
1511 struct snd_soc_tplg_hdr *hdr)
1512 {
1513 struct snd_soc_tplg_dapm_widget *widget;
1514 int ret, count = hdr->count, i;
1515
1516 if (tplg->pass != SOC_TPLG_PASS_WIDGET)
1517 return 0;
1518
1519 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count);
1520
1521 for (i = 0; i < count; i++) {
1522 widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos;
1523 if (widget->size != sizeof(*widget)) {
1524 dev_err(tplg->dev, "ASoC: invalid widget size\n");
1525 return -EINVAL;
1526 }
1527
1528 ret = soc_tplg_dapm_widget_create(tplg, widget);
1529 if (ret < 0) {
1530 dev_err(tplg->dev, "ASoC: failed to load widget %s\n",
1531 widget->name);
1532 return ret;
1533 }
1534 }
1535
1536 return 0;
1537 }
1538
1539 static int soc_tplg_dapm_complete(struct soc_tplg *tplg)
1540 {
1541 struct snd_soc_card *card = tplg->comp->card;
1542 int ret;
1543
1544 /* Card might not have been registered at this point.
1545 * If so, just return success.
1546 */
1547 if (!card || !card->instantiated) {
1548 dev_warn(tplg->dev, "ASoC: Parent card not yet available,"
1549 "Do not add new widgets now\n");
1550 return 0;
1551 }
1552
1553 ret = snd_soc_dapm_new_widgets(card);
1554 if (ret < 0)
1555 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n",
1556 ret);
1557
1558 return 0;
1559 }
1560
1561 static void set_stream_info(struct snd_soc_pcm_stream *stream,
1562 struct snd_soc_tplg_stream_caps *caps)
1563 {
1564 stream->stream_name = kstrdup(caps->name, GFP_KERNEL);
1565 stream->channels_min = caps->channels_min;
1566 stream->channels_max = caps->channels_max;
1567 stream->rates = caps->rates;
1568 stream->rate_min = caps->rate_min;
1569 stream->rate_max = caps->rate_max;
1570 stream->formats = caps->formats;
1571 stream->sig_bits = caps->sig_bits;
1572 }
1573
1574 static void set_dai_flags(struct snd_soc_dai_driver *dai_drv,
1575 unsigned int flag_mask, unsigned int flags)
1576 {
1577 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES)
1578 dai_drv->symmetric_rates =
1579 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES ? 1 : 0;
1580
1581 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS)
1582 dai_drv->symmetric_channels =
1583 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS ?
1584 1 : 0;
1585
1586 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS)
1587 dai_drv->symmetric_samplebits =
1588 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS ?
1589 1 : 0;
1590 }
1591
1592 static int soc_tplg_dai_create(struct soc_tplg *tplg,
1593 struct snd_soc_tplg_pcm *pcm)
1594 {
1595 struct snd_soc_dai_driver *dai_drv;
1596 struct snd_soc_pcm_stream *stream;
1597 struct snd_soc_tplg_stream_caps *caps;
1598 int ret;
1599
1600 dai_drv = kzalloc(sizeof(struct snd_soc_dai_driver), GFP_KERNEL);
1601 if (dai_drv == NULL)
1602 return -ENOMEM;
1603
1604 dai_drv->name = pcm->dai_name;
1605 dai_drv->id = pcm->dai_id;
1606
1607 if (pcm->playback) {
1608 stream = &dai_drv->playback;
1609 caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK];
1610 set_stream_info(stream, caps);
1611 }
1612
1613 if (pcm->capture) {
1614 stream = &dai_drv->capture;
1615 caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE];
1616 set_stream_info(stream, caps);
1617 }
1618
1619 /* pass control to component driver for optional further init */
1620 ret = soc_tplg_dai_load(tplg, dai_drv);
1621 if (ret < 0) {
1622 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n");
1623 kfree(dai_drv);
1624 return ret;
1625 }
1626
1627 dai_drv->dobj.index = tplg->index;
1628 dai_drv->dobj.ops = tplg->ops;
1629 dai_drv->dobj.type = SND_SOC_DOBJ_PCM;
1630 list_add(&dai_drv->dobj.list, &tplg->comp->dobj_list);
1631
1632 /* register the DAI to the component */
1633 return snd_soc_register_dai(tplg->comp, dai_drv);
1634 }
1635
1636 /* create the FE DAI link */
1637 static int soc_tplg_link_create(struct soc_tplg *tplg,
1638 struct snd_soc_tplg_pcm *pcm)
1639 {
1640 struct snd_soc_dai_link *link;
1641 int ret;
1642
1643 link = kzalloc(sizeof(struct snd_soc_dai_link), GFP_KERNEL);
1644 if (link == NULL)
1645 return -ENOMEM;
1646
1647 link->name = pcm->pcm_name;
1648 link->stream_name = pcm->pcm_name;
1649 link->id = pcm->pcm_id;
1650
1651 link->cpu_dai_name = pcm->dai_name;
1652 link->codec_name = "snd-soc-dummy";
1653 link->codec_dai_name = "snd-soc-dummy-dai";
1654
1655 /* enable DPCM */
1656 link->dynamic = 1;
1657 link->dpcm_playback = pcm->playback;
1658 link->dpcm_capture = pcm->capture;
1659
1660 /* pass control to component driver for optional further init */
1661 ret = soc_tplg_dai_link_load(tplg, link);
1662 if (ret < 0) {
1663 dev_err(tplg->comp->dev, "ASoC: FE link loading failed\n");
1664 kfree(link);
1665 return ret;
1666 }
1667
1668 link->dobj.index = tplg->index;
1669 link->dobj.ops = tplg->ops;
1670 link->dobj.type = SND_SOC_DOBJ_DAI_LINK;
1671 list_add(&link->dobj.list, &tplg->comp->dobj_list);
1672
1673 snd_soc_add_dai_link(tplg->comp->card, link);
1674 return 0;
1675 }
1676
1677 /* create a FE DAI and DAI link from the PCM object */
1678 static int soc_tplg_pcm_create(struct soc_tplg *tplg,
1679 struct snd_soc_tplg_pcm *pcm)
1680 {
1681 int ret;
1682
1683 ret = soc_tplg_dai_create(tplg, pcm);
1684 if (ret < 0)
1685 return ret;
1686
1687 return soc_tplg_link_create(tplg, pcm);
1688 }
1689
1690 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg,
1691 struct snd_soc_tplg_hdr *hdr)
1692 {
1693 struct snd_soc_tplg_pcm *pcm;
1694 int count = hdr->count;
1695 int i;
1696
1697 if (tplg->pass != SOC_TPLG_PASS_PCM_DAI)
1698 return 0;
1699
1700 if (soc_tplg_check_elem_count(tplg,
1701 sizeof(struct snd_soc_tplg_pcm), count,
1702 hdr->payload_size, "PCM DAI")) {
1703 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n",
1704 count);
1705 return -EINVAL;
1706 }
1707
1708 /* create the FE DAIs and DAI links */
1709 pcm = (struct snd_soc_tplg_pcm *)tplg->pos;
1710 for (i = 0; i < count; i++) {
1711 if (pcm->size != sizeof(*pcm)) {
1712 dev_err(tplg->dev, "ASoC: invalid pcm size\n");
1713 return -EINVAL;
1714 }
1715
1716 soc_tplg_pcm_create(tplg, pcm);
1717 pcm++;
1718 }
1719
1720 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count);
1721 tplg->pos += sizeof(struct snd_soc_tplg_pcm) * count;
1722
1723 return 0;
1724 }
1725
1726 /* *
1727 * soc_tplg_be_dai_config - Find and configure an existing BE DAI.
1728 * @tplg: topology context
1729 * @be: topology BE DAI configs.
1730 *
1731 * The BE dai should already be registered by the platform driver. The
1732 * platform driver should specify the BE DAI name and ID for matching.
1733 */
1734 static int soc_tplg_be_dai_config(struct soc_tplg *tplg,
1735 struct snd_soc_tplg_be_dai *be)
1736 {
1737 struct snd_soc_dai_link_component dai_component = {0};
1738 struct snd_soc_dai *dai;
1739 struct snd_soc_dai_driver *dai_drv;
1740 struct snd_soc_pcm_stream *stream;
1741 struct snd_soc_tplg_stream_caps *caps;
1742 int ret;
1743
1744 dai_component.dai_name = be->dai_name;
1745 dai = snd_soc_find_dai(&dai_component);
1746 if (!dai) {
1747 dev_err(tplg->dev, "ASoC: BE DAI %s not registered\n",
1748 be->dai_name);
1749 return -EINVAL;
1750 }
1751
1752 if (be->dai_id != dai->id) {
1753 dev_err(tplg->dev, "ASoC: BE DAI %s id mismatch\n",
1754 be->dai_name);
1755 return -EINVAL;
1756 }
1757
1758 dai_drv = dai->driver;
1759 if (!dai_drv)
1760 return -EINVAL;
1761
1762 if (be->playback) {
1763 stream = &dai_drv->playback;
1764 caps = &be->caps[SND_SOC_TPLG_STREAM_PLAYBACK];
1765 set_stream_info(stream, caps);
1766 }
1767
1768 if (be->capture) {
1769 stream = &dai_drv->capture;
1770 caps = &be->caps[SND_SOC_TPLG_STREAM_CAPTURE];
1771 set_stream_info(stream, caps);
1772 }
1773
1774 if (be->flag_mask)
1775 set_dai_flags(dai_drv, be->flag_mask, be->flags);
1776
1777 /* pass control to component driver for optional further init */
1778 ret = soc_tplg_dai_load(tplg, dai_drv);
1779 if (ret < 0) {
1780 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n");
1781 return ret;
1782 }
1783
1784 return 0;
1785 }
1786
1787 static int soc_tplg_be_dai_elems_load(struct soc_tplg *tplg,
1788 struct snd_soc_tplg_hdr *hdr)
1789 {
1790 struct snd_soc_tplg_be_dai *be;
1791 int count = hdr->count;
1792 int i;
1793
1794 if (tplg->pass != SOC_TPLG_PASS_BE_DAI)
1795 return 0;
1796
1797 /* config the existing BE DAIs */
1798 for (i = 0; i < count; i++) {
1799 be = (struct snd_soc_tplg_be_dai *)tplg->pos;
1800 if (be->size != sizeof(*be)) {
1801 dev_err(tplg->dev, "ASoC: invalid BE DAI size\n");
1802 return -EINVAL;
1803 }
1804
1805 soc_tplg_be_dai_config(tplg, be);
1806 tplg->pos += (sizeof(*be) + be->priv.size);
1807 }
1808
1809 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count);
1810 return 0;
1811 }
1812
1813
1814 static int soc_tplg_manifest_load(struct soc_tplg *tplg,
1815 struct snd_soc_tplg_hdr *hdr)
1816 {
1817 struct snd_soc_tplg_manifest *manifest;
1818
1819 if (tplg->pass != SOC_TPLG_PASS_MANIFEST)
1820 return 0;
1821
1822 manifest = (struct snd_soc_tplg_manifest *)tplg->pos;
1823 if (manifest->size != sizeof(*manifest)) {
1824 dev_err(tplg->dev, "ASoC: invalid manifest size\n");
1825 return -EINVAL;
1826 }
1827
1828 tplg->pos += sizeof(struct snd_soc_tplg_manifest);
1829
1830 if (tplg->comp && tplg->ops && tplg->ops->manifest)
1831 return tplg->ops->manifest(tplg->comp, manifest);
1832
1833 dev_err(tplg->dev, "ASoC: Firmware manifest not supported\n");
1834 return 0;
1835 }
1836
1837 /* validate header magic, size and type */
1838 static int soc_valid_header(struct soc_tplg *tplg,
1839 struct snd_soc_tplg_hdr *hdr)
1840 {
1841 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size)
1842 return 0;
1843
1844 if (hdr->size != sizeof(*hdr)) {
1845 dev_err(tplg->dev,
1846 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n",
1847 hdr->type, soc_tplg_get_hdr_offset(tplg),
1848 tplg->fw->size);
1849 return -EINVAL;
1850 }
1851
1852 /* big endian firmware objects not supported atm */
1853 if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) {
1854 dev_err(tplg->dev,
1855 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n",
1856 tplg->pass, hdr->magic,
1857 soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1858 return -EINVAL;
1859 }
1860
1861 if (hdr->magic != SND_SOC_TPLG_MAGIC) {
1862 dev_err(tplg->dev,
1863 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n",
1864 tplg->pass, hdr->magic,
1865 soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1866 return -EINVAL;
1867 }
1868
1869 if (hdr->abi != SND_SOC_TPLG_ABI_VERSION) {
1870 dev_err(tplg->dev,
1871 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n",
1872 tplg->pass, hdr->abi,
1873 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg),
1874 tplg->fw->size);
1875 return -EINVAL;
1876 }
1877
1878 if (hdr->payload_size == 0) {
1879 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n",
1880 soc_tplg_get_hdr_offset(tplg));
1881 return -EINVAL;
1882 }
1883
1884 if (tplg->pass == hdr->type)
1885 dev_dbg(tplg->dev,
1886 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n",
1887 hdr->payload_size, hdr->type, hdr->version,
1888 hdr->vendor_type, tplg->pass);
1889
1890 return 1;
1891 }
1892
1893 /* check header type and call appropriate handler */
1894 static int soc_tplg_load_header(struct soc_tplg *tplg,
1895 struct snd_soc_tplg_hdr *hdr)
1896 {
1897 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr);
1898
1899 /* check for matching ID */
1900 if (hdr->index != tplg->req_index &&
1901 hdr->index != SND_SOC_TPLG_INDEX_ALL)
1902 return 0;
1903
1904 tplg->index = hdr->index;
1905
1906 switch (hdr->type) {
1907 case SND_SOC_TPLG_TYPE_MIXER:
1908 case SND_SOC_TPLG_TYPE_ENUM:
1909 case SND_SOC_TPLG_TYPE_BYTES:
1910 return soc_tplg_kcontrol_elems_load(tplg, hdr);
1911 case SND_SOC_TPLG_TYPE_DAPM_GRAPH:
1912 return soc_tplg_dapm_graph_elems_load(tplg, hdr);
1913 case SND_SOC_TPLG_TYPE_DAPM_WIDGET:
1914 return soc_tplg_dapm_widget_elems_load(tplg, hdr);
1915 case SND_SOC_TPLG_TYPE_PCM:
1916 return soc_tplg_pcm_elems_load(tplg, hdr);
1917 case SND_SOC_TPLG_TYPE_BE_DAI:
1918 return soc_tplg_be_dai_elems_load(tplg, hdr);
1919 case SND_SOC_TPLG_TYPE_MANIFEST:
1920 return soc_tplg_manifest_load(tplg, hdr);
1921 default:
1922 /* bespoke vendor data object */
1923 return soc_tplg_vendor_load(tplg, hdr);
1924 }
1925
1926 return 0;
1927 }
1928
1929 /* process the topology file headers */
1930 static int soc_tplg_process_headers(struct soc_tplg *tplg)
1931 {
1932 struct snd_soc_tplg_hdr *hdr;
1933 int ret;
1934
1935 tplg->pass = SOC_TPLG_PASS_START;
1936
1937 /* process the header types from start to end */
1938 while (tplg->pass <= SOC_TPLG_PASS_END) {
1939
1940 tplg->hdr_pos = tplg->fw->data;
1941 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1942
1943 while (!soc_tplg_is_eof(tplg)) {
1944
1945 /* make sure header is valid before loading */
1946 ret = soc_valid_header(tplg, hdr);
1947 if (ret < 0)
1948 return ret;
1949 else if (ret == 0)
1950 break;
1951
1952 /* load the header object */
1953 ret = soc_tplg_load_header(tplg, hdr);
1954 if (ret < 0)
1955 return ret;
1956
1957 /* goto next header */
1958 tplg->hdr_pos += hdr->payload_size +
1959 sizeof(struct snd_soc_tplg_hdr);
1960 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1961 }
1962
1963 /* next data type pass */
1964 tplg->pass++;
1965 }
1966
1967 /* signal DAPM we are complete */
1968 ret = soc_tplg_dapm_complete(tplg);
1969 if (ret < 0)
1970 dev_err(tplg->dev,
1971 "ASoC: failed to initialise DAPM from Firmware\n");
1972
1973 return ret;
1974 }
1975
1976 static int soc_tplg_load(struct soc_tplg *tplg)
1977 {
1978 int ret;
1979
1980 ret = soc_tplg_process_headers(tplg);
1981 if (ret == 0)
1982 soc_tplg_complete(tplg);
1983
1984 return ret;
1985 }
1986
1987 /* load audio component topology from "firmware" file */
1988 int snd_soc_tplg_component_load(struct snd_soc_component *comp,
1989 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id)
1990 {
1991 struct soc_tplg tplg;
1992
1993 /* setup parsing context */
1994 memset(&tplg, 0, sizeof(tplg));
1995 tplg.fw = fw;
1996 tplg.dev = comp->dev;
1997 tplg.comp = comp;
1998 tplg.ops = ops;
1999 tplg.req_index = id;
2000 tplg.io_ops = ops->io_ops;
2001 tplg.io_ops_count = ops->io_ops_count;
2002 tplg.bytes_ext_ops = ops->bytes_ext_ops;
2003 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count;
2004
2005 return soc_tplg_load(&tplg);
2006 }
2007 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
2008
2009 /* remove this dynamic widget */
2010 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w)
2011 {
2012 /* make sure we are a widget */
2013 if (w->dobj.type != SND_SOC_DOBJ_WIDGET)
2014 return;
2015
2016 remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET);
2017 }
2018 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove);
2019
2020 /* remove all dynamic widgets from this DAPM context */
2021 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
2022 u32 index)
2023 {
2024 struct snd_soc_dapm_widget *w, *next_w;
2025
2026 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2027
2028 /* make sure we are a widget with correct context */
2029 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm)
2030 continue;
2031
2032 /* match ID */
2033 if (w->dobj.index != index &&
2034 w->dobj.index != SND_SOC_TPLG_INDEX_ALL)
2035 continue;
2036 /* check and free and dynamic widget kcontrols */
2037 snd_soc_tplg_widget_remove(w);
2038 snd_soc_dapm_free_widget(w);
2039 }
2040 snd_soc_dapm_reset_cache(dapm);
2041 }
2042 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all);
2043
2044 /* remove dynamic controls from the component driver */
2045 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index)
2046 {
2047 struct snd_soc_dobj *dobj, *next_dobj;
2048 int pass = SOC_TPLG_PASS_END;
2049
2050 /* process the header types from end to start */
2051 while (pass >= SOC_TPLG_PASS_START) {
2052
2053 /* remove mixer controls */
2054 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list,
2055 list) {
2056
2057 /* match index */
2058 if (dobj->index != index &&
2059 dobj->index != SND_SOC_TPLG_INDEX_ALL)
2060 continue;
2061
2062 switch (dobj->type) {
2063 case SND_SOC_DOBJ_MIXER:
2064 remove_mixer(comp, dobj, pass);
2065 break;
2066 case SND_SOC_DOBJ_ENUM:
2067 remove_enum(comp, dobj, pass);
2068 break;
2069 case SND_SOC_DOBJ_BYTES:
2070 remove_bytes(comp, dobj, pass);
2071 break;
2072 case SND_SOC_DOBJ_WIDGET:
2073 remove_widget(comp, dobj, pass);
2074 break;
2075 case SND_SOC_DOBJ_PCM:
2076 remove_dai(comp, dobj, pass);
2077 break;
2078 case SND_SOC_DOBJ_DAI_LINK:
2079 remove_link(comp, dobj, pass);
2080 break;
2081 default:
2082 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n",
2083 dobj->type);
2084 break;
2085 }
2086 }
2087 pass--;
2088 }
2089
2090 /* let caller know if FW can be freed when no objects are left */
2091 return !list_empty(&comp->dobj_list);
2092 }
2093 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove);
Linux with added FPC-III support