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