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