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