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 #define SOC_TPLG_PASS_LINK 8 53 54 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST 55 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_LINK 56 57 /* 58 * Old version of ABI structs, supported for backward compatibility. 59 */ 60 61 /* Manifest v4 */ 62 struct snd_soc_tplg_manifest_v4 { 63 __le32 size; /* in bytes of this structure */ 64 __le32 control_elems; /* number of control elements */ 65 __le32 widget_elems; /* number of widget elements */ 66 __le32 graph_elems; /* number of graph elements */ 67 __le32 pcm_elems; /* number of PCM elements */ 68 __le32 dai_link_elems; /* number of DAI link elements */ 69 struct snd_soc_tplg_private priv; 70 } __packed; 71 72 /* Stream Capabilities v4 */ 73 struct snd_soc_tplg_stream_caps_v4 { 74 __le32 size; /* in bytes of this structure */ 75 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 76 __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ 77 __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ 78 __le32 rate_min; /* min rate */ 79 __le32 rate_max; /* max rate */ 80 __le32 channels_min; /* min channels */ 81 __le32 channels_max; /* max channels */ 82 __le32 periods_min; /* min number of periods */ 83 __le32 periods_max; /* max number of periods */ 84 __le32 period_size_min; /* min period size bytes */ 85 __le32 period_size_max; /* max period size bytes */ 86 __le32 buffer_size_min; /* min buffer size bytes */ 87 __le32 buffer_size_max; /* max buffer size bytes */ 88 } __packed; 89 90 /* PCM v4 */ 91 struct snd_soc_tplg_pcm_v4 { 92 __le32 size; /* in bytes of this structure */ 93 char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 94 char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 95 __le32 pcm_id; /* unique ID - used to match with DAI link */ 96 __le32 dai_id; /* unique ID - used to match */ 97 __le32 playback; /* supports playback mode */ 98 __le32 capture; /* supports capture mode */ 99 __le32 compress; /* 1 = compressed; 0 = PCM */ 100 struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ 101 __le32 num_streams; /* number of streams */ 102 struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */ 103 } __packed; 104 105 /* Physical link config v4 */ 106 struct snd_soc_tplg_link_config_v4 { 107 __le32 size; /* in bytes of this structure */ 108 __le32 id; /* unique ID - used to match */ 109 struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ 110 __le32 num_streams; /* number of streams */ 111 } __packed; 112 113 /* topology context */ 114 struct soc_tplg { 115 const struct firmware *fw; 116 117 /* runtime FW parsing */ 118 const u8 *pos; /* read postion */ 119 const u8 *hdr_pos; /* header position */ 120 unsigned int pass; /* pass number */ 121 122 /* component caller */ 123 struct device *dev; 124 struct snd_soc_component *comp; 125 u32 index; /* current block index */ 126 u32 req_index; /* required index, only loaded/free matching blocks */ 127 128 /* vendor specific kcontrol operations */ 129 const struct snd_soc_tplg_kcontrol_ops *io_ops; 130 int io_ops_count; 131 132 /* vendor specific bytes ext handlers, for TLV bytes controls */ 133 const struct snd_soc_tplg_bytes_ext_ops *bytes_ext_ops; 134 int bytes_ext_ops_count; 135 136 /* optional fw loading callbacks to component drivers */ 137 struct snd_soc_tplg_ops *ops; 138 }; 139 140 static int soc_tplg_process_headers(struct soc_tplg *tplg); 141 static void soc_tplg_complete(struct soc_tplg *tplg); 142 struct snd_soc_dapm_widget * 143 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm, 144 const struct snd_soc_dapm_widget *widget); 145 struct snd_soc_dapm_widget * 146 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, 147 const struct snd_soc_dapm_widget *widget); 148 149 /* check we dont overflow the data for this control chunk */ 150 static int soc_tplg_check_elem_count(struct soc_tplg *tplg, size_t elem_size, 151 unsigned int count, size_t bytes, const char *elem_type) 152 { 153 const u8 *end = tplg->pos + elem_size * count; 154 155 if (end > tplg->fw->data + tplg->fw->size) { 156 dev_err(tplg->dev, "ASoC: %s overflow end of data\n", 157 elem_type); 158 return -EINVAL; 159 } 160 161 /* check there is enough room in chunk for control. 162 extra bytes at the end of control are for vendor data here */ 163 if (elem_size * count > bytes) { 164 dev_err(tplg->dev, 165 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n", 166 elem_type, count, elem_size, bytes); 167 return -EINVAL; 168 } 169 170 return 0; 171 } 172 173 static inline int soc_tplg_is_eof(struct soc_tplg *tplg) 174 { 175 const u8 *end = tplg->hdr_pos; 176 177 if (end >= tplg->fw->data + tplg->fw->size) 178 return 1; 179 return 0; 180 } 181 182 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg) 183 { 184 return (unsigned long)(tplg->hdr_pos - tplg->fw->data); 185 } 186 187 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg) 188 { 189 return (unsigned long)(tplg->pos - tplg->fw->data); 190 } 191 192 /* mapping of Kcontrol types and associated operations. */ 193 static const struct snd_soc_tplg_kcontrol_ops io_ops[] = { 194 {SND_SOC_TPLG_CTL_VOLSW, snd_soc_get_volsw, 195 snd_soc_put_volsw, snd_soc_info_volsw}, 196 {SND_SOC_TPLG_CTL_VOLSW_SX, snd_soc_get_volsw_sx, 197 snd_soc_put_volsw_sx, NULL}, 198 {SND_SOC_TPLG_CTL_ENUM, snd_soc_get_enum_double, 199 snd_soc_put_enum_double, snd_soc_info_enum_double}, 200 {SND_SOC_TPLG_CTL_ENUM_VALUE, snd_soc_get_enum_double, 201 snd_soc_put_enum_double, NULL}, 202 {SND_SOC_TPLG_CTL_BYTES, snd_soc_bytes_get, 203 snd_soc_bytes_put, snd_soc_bytes_info}, 204 {SND_SOC_TPLG_CTL_RANGE, snd_soc_get_volsw_range, 205 snd_soc_put_volsw_range, snd_soc_info_volsw_range}, 206 {SND_SOC_TPLG_CTL_VOLSW_XR_SX, snd_soc_get_xr_sx, 207 snd_soc_put_xr_sx, snd_soc_info_xr_sx}, 208 {SND_SOC_TPLG_CTL_STROBE, snd_soc_get_strobe, 209 snd_soc_put_strobe, NULL}, 210 {SND_SOC_TPLG_DAPM_CTL_VOLSW, snd_soc_dapm_get_volsw, 211 snd_soc_dapm_put_volsw, snd_soc_info_volsw}, 212 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE, snd_soc_dapm_get_enum_double, 213 snd_soc_dapm_put_enum_double, snd_soc_info_enum_double}, 214 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT, snd_soc_dapm_get_enum_double, 215 snd_soc_dapm_put_enum_double, NULL}, 216 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE, snd_soc_dapm_get_enum_double, 217 snd_soc_dapm_put_enum_double, NULL}, 218 {SND_SOC_TPLG_DAPM_CTL_PIN, snd_soc_dapm_get_pin_switch, 219 snd_soc_dapm_put_pin_switch, snd_soc_dapm_info_pin_switch}, 220 }; 221 222 struct soc_tplg_map { 223 int uid; 224 int kid; 225 }; 226 227 /* mapping of widget types from UAPI IDs to kernel IDs */ 228 static const struct soc_tplg_map dapm_map[] = { 229 {SND_SOC_TPLG_DAPM_INPUT, snd_soc_dapm_input}, 230 {SND_SOC_TPLG_DAPM_OUTPUT, snd_soc_dapm_output}, 231 {SND_SOC_TPLG_DAPM_MUX, snd_soc_dapm_mux}, 232 {SND_SOC_TPLG_DAPM_MIXER, snd_soc_dapm_mixer}, 233 {SND_SOC_TPLG_DAPM_PGA, snd_soc_dapm_pga}, 234 {SND_SOC_TPLG_DAPM_OUT_DRV, snd_soc_dapm_out_drv}, 235 {SND_SOC_TPLG_DAPM_ADC, snd_soc_dapm_adc}, 236 {SND_SOC_TPLG_DAPM_DAC, snd_soc_dapm_dac}, 237 {SND_SOC_TPLG_DAPM_SWITCH, snd_soc_dapm_switch}, 238 {SND_SOC_TPLG_DAPM_PRE, snd_soc_dapm_pre}, 239 {SND_SOC_TPLG_DAPM_POST, snd_soc_dapm_post}, 240 {SND_SOC_TPLG_DAPM_AIF_IN, snd_soc_dapm_aif_in}, 241 {SND_SOC_TPLG_DAPM_AIF_OUT, snd_soc_dapm_aif_out}, 242 {SND_SOC_TPLG_DAPM_DAI_IN, snd_soc_dapm_dai_in}, 243 {SND_SOC_TPLG_DAPM_DAI_OUT, snd_soc_dapm_dai_out}, 244 {SND_SOC_TPLG_DAPM_DAI_LINK, snd_soc_dapm_dai_link}, 245 {SND_SOC_TPLG_DAPM_BUFFER, snd_soc_dapm_buffer}, 246 {SND_SOC_TPLG_DAPM_SCHEDULER, snd_soc_dapm_scheduler}, 247 {SND_SOC_TPLG_DAPM_EFFECT, snd_soc_dapm_effect}, 248 {SND_SOC_TPLG_DAPM_SIGGEN, snd_soc_dapm_siggen}, 249 {SND_SOC_TPLG_DAPM_SRC, snd_soc_dapm_src}, 250 {SND_SOC_TPLG_DAPM_ASRC, snd_soc_dapm_asrc}, 251 {SND_SOC_TPLG_DAPM_ENCODER, snd_soc_dapm_encoder}, 252 {SND_SOC_TPLG_DAPM_DECODER, snd_soc_dapm_decoder}, 253 }; 254 255 static int tplc_chan_get_reg(struct soc_tplg *tplg, 256 struct snd_soc_tplg_channel *chan, int map) 257 { 258 int i; 259 260 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) { 261 if (chan[i].id == map) 262 return chan[i].reg; 263 } 264 265 return -EINVAL; 266 } 267 268 static int tplc_chan_get_shift(struct soc_tplg *tplg, 269 struct snd_soc_tplg_channel *chan, int map) 270 { 271 int i; 272 273 for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) { 274 if (chan[i].id == map) 275 return chan[i].shift; 276 } 277 278 return -EINVAL; 279 } 280 281 static int get_widget_id(int tplg_type) 282 { 283 int i; 284 285 for (i = 0; i < ARRAY_SIZE(dapm_map); i++) { 286 if (tplg_type == dapm_map[i].uid) 287 return dapm_map[i].kid; 288 } 289 290 return -EINVAL; 291 } 292 293 static inline void soc_bind_err(struct soc_tplg *tplg, 294 struct snd_soc_tplg_ctl_hdr *hdr, int index) 295 { 296 dev_err(tplg->dev, 297 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n", 298 hdr->ops.get, hdr->ops.put, hdr->ops.info, index, 299 soc_tplg_get_offset(tplg)); 300 } 301 302 static inline void soc_control_err(struct soc_tplg *tplg, 303 struct snd_soc_tplg_ctl_hdr *hdr, const char *name) 304 { 305 dev_err(tplg->dev, 306 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n", 307 name, hdr->ops.get, hdr->ops.put, hdr->ops.info, 308 soc_tplg_get_offset(tplg)); 309 } 310 311 /* pass vendor data to component driver for processing */ 312 static int soc_tplg_vendor_load_(struct soc_tplg *tplg, 313 struct snd_soc_tplg_hdr *hdr) 314 { 315 int ret = 0; 316 317 if (tplg->comp && tplg->ops && tplg->ops->vendor_load) 318 ret = tplg->ops->vendor_load(tplg->comp, hdr); 319 else { 320 dev_err(tplg->dev, "ASoC: no vendor load callback for ID %d\n", 321 hdr->vendor_type); 322 return -EINVAL; 323 } 324 325 if (ret < 0) 326 dev_err(tplg->dev, 327 "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n", 328 soc_tplg_get_hdr_offset(tplg), 329 soc_tplg_get_hdr_offset(tplg), 330 hdr->type, hdr->vendor_type); 331 return ret; 332 } 333 334 /* pass vendor data to component driver for processing */ 335 static int soc_tplg_vendor_load(struct soc_tplg *tplg, 336 struct snd_soc_tplg_hdr *hdr) 337 { 338 if (tplg->pass != SOC_TPLG_PASS_VENDOR) 339 return 0; 340 341 return soc_tplg_vendor_load_(tplg, hdr); 342 } 343 344 /* optionally pass new dynamic widget to component driver. This is mainly for 345 * external widgets where we can assign private data/ops */ 346 static int soc_tplg_widget_load(struct soc_tplg *tplg, 347 struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w) 348 { 349 if (tplg->comp && tplg->ops && tplg->ops->widget_load) 350 return tplg->ops->widget_load(tplg->comp, w, tplg_w); 351 352 return 0; 353 } 354 355 /* optionally pass new dynamic widget to component driver. This is mainly for 356 * external widgets where we can assign private data/ops */ 357 static int soc_tplg_widget_ready(struct soc_tplg *tplg, 358 struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w) 359 { 360 if (tplg->comp && tplg->ops && tplg->ops->widget_ready) 361 return tplg->ops->widget_ready(tplg->comp, w, tplg_w); 362 363 return 0; 364 } 365 366 /* pass DAI configurations to component driver for extra initialization */ 367 static int soc_tplg_dai_load(struct soc_tplg *tplg, 368 struct snd_soc_dai_driver *dai_drv) 369 { 370 if (tplg->comp && tplg->ops && tplg->ops->dai_load) 371 return tplg->ops->dai_load(tplg->comp, dai_drv); 372 373 return 0; 374 } 375 376 /* pass link configurations to component driver for extra initialization */ 377 static int soc_tplg_dai_link_load(struct soc_tplg *tplg, 378 struct snd_soc_dai_link *link) 379 { 380 if (tplg->comp && tplg->ops && tplg->ops->link_load) 381 return tplg->ops->link_load(tplg->comp, link); 382 383 return 0; 384 } 385 386 /* tell the component driver that all firmware has been loaded in this request */ 387 static void soc_tplg_complete(struct soc_tplg *tplg) 388 { 389 if (tplg->comp && tplg->ops && tplg->ops->complete) 390 tplg->ops->complete(tplg->comp); 391 } 392 393 /* add a dynamic kcontrol */ 394 static int soc_tplg_add_dcontrol(struct snd_card *card, struct device *dev, 395 const struct snd_kcontrol_new *control_new, const char *prefix, 396 void *data, struct snd_kcontrol **kcontrol) 397 { 398 int err; 399 400 *kcontrol = snd_soc_cnew(control_new, data, control_new->name, prefix); 401 if (*kcontrol == NULL) { 402 dev_err(dev, "ASoC: Failed to create new kcontrol %s\n", 403 control_new->name); 404 return -ENOMEM; 405 } 406 407 err = snd_ctl_add(card, *kcontrol); 408 if (err < 0) { 409 dev_err(dev, "ASoC: Failed to add %s: %d\n", 410 control_new->name, err); 411 return err; 412 } 413 414 return 0; 415 } 416 417 /* add a dynamic kcontrol for component driver */ 418 static int soc_tplg_add_kcontrol(struct soc_tplg *tplg, 419 struct snd_kcontrol_new *k, struct snd_kcontrol **kcontrol) 420 { 421 struct snd_soc_component *comp = tplg->comp; 422 423 return soc_tplg_add_dcontrol(comp->card->snd_card, 424 comp->dev, k, NULL, comp, kcontrol); 425 } 426 427 /* remove a mixer kcontrol */ 428 static void remove_mixer(struct snd_soc_component *comp, 429 struct snd_soc_dobj *dobj, int pass) 430 { 431 struct snd_card *card = comp->card->snd_card; 432 struct soc_mixer_control *sm = 433 container_of(dobj, struct soc_mixer_control, dobj); 434 const unsigned int *p = NULL; 435 436 if (pass != SOC_TPLG_PASS_MIXER) 437 return; 438 439 if (dobj->ops && dobj->ops->control_unload) 440 dobj->ops->control_unload(comp, dobj); 441 442 if (sm->dobj.control.kcontrol->tlv.p) 443 p = sm->dobj.control.kcontrol->tlv.p; 444 snd_ctl_remove(card, sm->dobj.control.kcontrol); 445 list_del(&sm->dobj.list); 446 kfree(sm); 447 kfree(p); 448 } 449 450 /* remove an enum kcontrol */ 451 static void remove_enum(struct snd_soc_component *comp, 452 struct snd_soc_dobj *dobj, int pass) 453 { 454 struct snd_card *card = comp->card->snd_card; 455 struct soc_enum *se = container_of(dobj, struct soc_enum, dobj); 456 int i; 457 458 if (pass != SOC_TPLG_PASS_MIXER) 459 return; 460 461 if (dobj->ops && dobj->ops->control_unload) 462 dobj->ops->control_unload(comp, dobj); 463 464 snd_ctl_remove(card, se->dobj.control.kcontrol); 465 list_del(&se->dobj.list); 466 467 kfree(se->dobj.control.dvalues); 468 for (i = 0; i < se->items; i++) 469 kfree(se->dobj.control.dtexts[i]); 470 kfree(se); 471 } 472 473 /* remove a byte kcontrol */ 474 static void remove_bytes(struct snd_soc_component *comp, 475 struct snd_soc_dobj *dobj, int pass) 476 { 477 struct snd_card *card = comp->card->snd_card; 478 struct soc_bytes_ext *sb = 479 container_of(dobj, struct soc_bytes_ext, dobj); 480 481 if (pass != SOC_TPLG_PASS_MIXER) 482 return; 483 484 if (dobj->ops && dobj->ops->control_unload) 485 dobj->ops->control_unload(comp, dobj); 486 487 snd_ctl_remove(card, sb->dobj.control.kcontrol); 488 list_del(&sb->dobj.list); 489 kfree(sb); 490 } 491 492 /* remove a widget and it's kcontrols - routes must be removed first */ 493 static void remove_widget(struct snd_soc_component *comp, 494 struct snd_soc_dobj *dobj, int pass) 495 { 496 struct snd_card *card = comp->card->snd_card; 497 struct snd_soc_dapm_widget *w = 498 container_of(dobj, struct snd_soc_dapm_widget, dobj); 499 int i; 500 501 if (pass != SOC_TPLG_PASS_WIDGET) 502 return; 503 504 if (dobj->ops && dobj->ops->widget_unload) 505 dobj->ops->widget_unload(comp, dobj); 506 507 if (!w->kcontrols) 508 goto free_news; 509 510 /* 511 * Dynamic Widgets either have 1..N enum kcontrols or mixers. 512 * The enum may either have an array of values or strings. 513 */ 514 if (dobj->widget.kcontrol_type == SND_SOC_TPLG_TYPE_ENUM) { 515 /* enumerated widget mixer */ 516 for (i = 0; w->kcontrols != NULL && i < w->num_kcontrols; i++) { 517 struct snd_kcontrol *kcontrol = w->kcontrols[i]; 518 struct soc_enum *se = 519 (struct soc_enum *)kcontrol->private_value; 520 int j; 521 522 snd_ctl_remove(card, kcontrol); 523 524 kfree(se->dobj.control.dvalues); 525 for (j = 0; j < se->items; j++) 526 kfree(se->dobj.control.dtexts[j]); 527 528 kfree(se); 529 kfree(w->kcontrol_news[i].name); 530 } 531 } else { 532 /* volume mixer or bytes controls */ 533 for (i = 0; w->kcontrols != NULL && i < w->num_kcontrols; i++) { 534 struct snd_kcontrol *kcontrol = w->kcontrols[i]; 535 536 if (dobj->widget.kcontrol_type 537 == SND_SOC_TPLG_TYPE_MIXER) 538 kfree(kcontrol->tlv.p); 539 540 /* Private value is used as struct soc_mixer_control 541 * for volume mixers or soc_bytes_ext for bytes 542 * controls. 543 */ 544 kfree((void *)kcontrol->private_value); 545 snd_ctl_remove(card, kcontrol); 546 kfree(w->kcontrol_news[i].name); 547 } 548 } 549 550 free_news: 551 kfree(w->kcontrol_news); 552 553 /* widget w is freed by soc-dapm.c */ 554 } 555 556 /* remove DAI configurations */ 557 static void remove_dai(struct snd_soc_component *comp, 558 struct snd_soc_dobj *dobj, int pass) 559 { 560 struct snd_soc_dai_driver *dai_drv = 561 container_of(dobj, struct snd_soc_dai_driver, dobj); 562 563 if (pass != SOC_TPLG_PASS_PCM_DAI) 564 return; 565 566 if (dobj->ops && dobj->ops->dai_unload) 567 dobj->ops->dai_unload(comp, dobj); 568 569 kfree(dai_drv->name); 570 list_del(&dobj->list); 571 kfree(dai_drv); 572 } 573 574 /* remove link configurations */ 575 static void remove_link(struct snd_soc_component *comp, 576 struct snd_soc_dobj *dobj, int pass) 577 { 578 struct snd_soc_dai_link *link = 579 container_of(dobj, struct snd_soc_dai_link, dobj); 580 581 if (pass != SOC_TPLG_PASS_PCM_DAI) 582 return; 583 584 if (dobj->ops && dobj->ops->link_unload) 585 dobj->ops->link_unload(comp, dobj); 586 587 kfree(link->name); 588 kfree(link->stream_name); 589 kfree(link->cpu_dai_name); 590 591 list_del(&dobj->list); 592 snd_soc_remove_dai_link(comp->card, link); 593 kfree(link); 594 } 595 596 /* bind a kcontrol to it's IO handlers */ 597 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr *hdr, 598 struct snd_kcontrol_new *k, 599 const struct soc_tplg *tplg) 600 { 601 const struct snd_soc_tplg_kcontrol_ops *ops; 602 const struct snd_soc_tplg_bytes_ext_ops *ext_ops; 603 int num_ops, i; 604 605 if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES 606 && k->iface & SNDRV_CTL_ELEM_IFACE_MIXER 607 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE 608 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) { 609 struct soc_bytes_ext *sbe; 610 struct snd_soc_tplg_bytes_control *be; 611 612 sbe = (struct soc_bytes_ext *)k->private_value; 613 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr); 614 615 /* TLV bytes controls need standard kcontrol info handler, 616 * TLV callback and extended put/get handlers. 617 */ 618 k->info = snd_soc_bytes_info_ext; 619 k->tlv.c = snd_soc_bytes_tlv_callback; 620 621 ext_ops = tplg->bytes_ext_ops; 622 num_ops = tplg->bytes_ext_ops_count; 623 for (i = 0; i < num_ops; i++) { 624 if (!sbe->put && ext_ops[i].id == be->ext_ops.put) 625 sbe->put = ext_ops[i].put; 626 if (!sbe->get && ext_ops[i].id == be->ext_ops.get) 627 sbe->get = ext_ops[i].get; 628 } 629 630 if (sbe->put && sbe->get) 631 return 0; 632 else 633 return -EINVAL; 634 } 635 636 /* try and map vendor specific kcontrol handlers first */ 637 ops = tplg->io_ops; 638 num_ops = tplg->io_ops_count; 639 for (i = 0; i < num_ops; i++) { 640 641 if (k->put == NULL && ops[i].id == hdr->ops.put) 642 k->put = ops[i].put; 643 if (k->get == NULL && ops[i].id == hdr->ops.get) 644 k->get = ops[i].get; 645 if (k->info == NULL && ops[i].id == hdr->ops.info) 646 k->info = ops[i].info; 647 } 648 649 /* vendor specific handlers found ? */ 650 if (k->put && k->get && k->info) 651 return 0; 652 653 /* none found so try standard kcontrol handlers */ 654 ops = io_ops; 655 num_ops = ARRAY_SIZE(io_ops); 656 for (i = 0; i < num_ops; i++) { 657 658 if (k->put == NULL && ops[i].id == hdr->ops.put) 659 k->put = ops[i].put; 660 if (k->get == NULL && ops[i].id == hdr->ops.get) 661 k->get = ops[i].get; 662 if (k->info == NULL && ops[i].id == hdr->ops.info) 663 k->info = ops[i].info; 664 } 665 666 /* standard handlers found ? */ 667 if (k->put && k->get && k->info) 668 return 0; 669 670 /* nothing to bind */ 671 return -EINVAL; 672 } 673 674 /* bind a widgets to it's evnt handlers */ 675 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w, 676 const struct snd_soc_tplg_widget_events *events, 677 int num_events, u16 event_type) 678 { 679 int i; 680 681 w->event = NULL; 682 683 for (i = 0; i < num_events; i++) { 684 if (event_type == events[i].type) { 685 686 /* found - so assign event */ 687 w->event = events[i].event_handler; 688 return 0; 689 } 690 } 691 692 /* not found */ 693 return -EINVAL; 694 } 695 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event); 696 697 /* optionally pass new dynamic kcontrol to component driver. */ 698 static int soc_tplg_init_kcontrol(struct soc_tplg *tplg, 699 struct snd_kcontrol_new *k, struct snd_soc_tplg_ctl_hdr *hdr) 700 { 701 if (tplg->comp && tplg->ops && tplg->ops->control_load) 702 return tplg->ops->control_load(tplg->comp, k, hdr); 703 704 return 0; 705 } 706 707 708 static int soc_tplg_create_tlv_db_scale(struct soc_tplg *tplg, 709 struct snd_kcontrol_new *kc, struct snd_soc_tplg_tlv_dbscale *scale) 710 { 711 unsigned int item_len = 2 * sizeof(unsigned int); 712 unsigned int *p; 713 714 p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL); 715 if (!p) 716 return -ENOMEM; 717 718 p[0] = SNDRV_CTL_TLVT_DB_SCALE; 719 p[1] = item_len; 720 p[2] = scale->min; 721 p[3] = (scale->step & TLV_DB_SCALE_MASK) 722 | (scale->mute ? TLV_DB_SCALE_MUTE : 0); 723 724 kc->tlv.p = (void *)p; 725 return 0; 726 } 727 728 static int soc_tplg_create_tlv(struct soc_tplg *tplg, 729 struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc) 730 { 731 struct snd_soc_tplg_ctl_tlv *tplg_tlv; 732 733 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE)) 734 return 0; 735 736 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) { 737 tplg_tlv = &tc->tlv; 738 switch (tplg_tlv->type) { 739 case SNDRV_CTL_TLVT_DB_SCALE: 740 return soc_tplg_create_tlv_db_scale(tplg, kc, 741 &tplg_tlv->scale); 742 743 /* TODO: add support for other TLV types */ 744 default: 745 dev_dbg(tplg->dev, "Unsupported TLV type %d\n", 746 tplg_tlv->type); 747 return -EINVAL; 748 } 749 } 750 751 return 0; 752 } 753 754 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg, 755 struct snd_kcontrol_new *kc) 756 { 757 kfree(kc->tlv.p); 758 } 759 760 static int soc_tplg_dbytes_create(struct soc_tplg *tplg, unsigned int count, 761 size_t size) 762 { 763 struct snd_soc_tplg_bytes_control *be; 764 struct soc_bytes_ext *sbe; 765 struct snd_kcontrol_new kc; 766 int i, err; 767 768 if (soc_tplg_check_elem_count(tplg, 769 sizeof(struct snd_soc_tplg_bytes_control), count, 770 size, "mixer bytes")) { 771 dev_err(tplg->dev, "ASoC: Invalid count %d for byte control\n", 772 count); 773 return -EINVAL; 774 } 775 776 for (i = 0; i < count; i++) { 777 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 778 779 /* validate kcontrol */ 780 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 781 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 782 return -EINVAL; 783 784 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL); 785 if (sbe == NULL) 786 return -ENOMEM; 787 788 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 789 be->priv.size); 790 791 dev_dbg(tplg->dev, 792 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 793 be->hdr.name, be->hdr.access); 794 795 memset(&kc, 0, sizeof(kc)); 796 kc.name = be->hdr.name; 797 kc.private_value = (long)sbe; 798 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 799 kc.access = be->hdr.access; 800 801 sbe->max = be->max; 802 sbe->dobj.type = SND_SOC_DOBJ_BYTES; 803 sbe->dobj.ops = tplg->ops; 804 INIT_LIST_HEAD(&sbe->dobj.list); 805 806 /* map io handlers */ 807 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg); 808 if (err) { 809 soc_control_err(tplg, &be->hdr, be->hdr.name); 810 kfree(sbe); 811 continue; 812 } 813 814 /* pass control to driver for optional further init */ 815 err = soc_tplg_init_kcontrol(tplg, &kc, 816 (struct snd_soc_tplg_ctl_hdr *)be); 817 if (err < 0) { 818 dev_err(tplg->dev, "ASoC: failed to init %s\n", 819 be->hdr.name); 820 kfree(sbe); 821 continue; 822 } 823 824 /* register control here */ 825 err = soc_tplg_add_kcontrol(tplg, &kc, 826 &sbe->dobj.control.kcontrol); 827 if (err < 0) { 828 dev_err(tplg->dev, "ASoC: failed to add %s\n", 829 be->hdr.name); 830 kfree(sbe); 831 continue; 832 } 833 834 list_add(&sbe->dobj.list, &tplg->comp->dobj_list); 835 } 836 return 0; 837 838 } 839 840 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count, 841 size_t size) 842 { 843 struct snd_soc_tplg_mixer_control *mc; 844 struct soc_mixer_control *sm; 845 struct snd_kcontrol_new kc; 846 int i, err; 847 848 if (soc_tplg_check_elem_count(tplg, 849 sizeof(struct snd_soc_tplg_mixer_control), 850 count, size, "mixers")) { 851 852 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n", 853 count); 854 return -EINVAL; 855 } 856 857 for (i = 0; i < count; i++) { 858 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 859 860 /* validate kcontrol */ 861 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 862 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 863 return -EINVAL; 864 865 sm = kzalloc(sizeof(*sm), GFP_KERNEL); 866 if (sm == NULL) 867 return -ENOMEM; 868 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) + 869 mc->priv.size); 870 871 dev_dbg(tplg->dev, 872 "ASoC: adding mixer kcontrol %s with access 0x%x\n", 873 mc->hdr.name, mc->hdr.access); 874 875 memset(&kc, 0, sizeof(kc)); 876 kc.name = mc->hdr.name; 877 kc.private_value = (long)sm; 878 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 879 kc.access = mc->hdr.access; 880 881 /* we only support FL/FR channel mapping atm */ 882 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 883 SNDRV_CHMAP_FL); 884 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 885 SNDRV_CHMAP_FR); 886 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 887 SNDRV_CHMAP_FL); 888 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 889 SNDRV_CHMAP_FR); 890 891 sm->max = mc->max; 892 sm->min = mc->min; 893 sm->invert = mc->invert; 894 sm->platform_max = mc->platform_max; 895 sm->dobj.index = tplg->index; 896 sm->dobj.ops = tplg->ops; 897 sm->dobj.type = SND_SOC_DOBJ_MIXER; 898 INIT_LIST_HEAD(&sm->dobj.list); 899 900 /* map io handlers */ 901 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg); 902 if (err) { 903 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 904 kfree(sm); 905 continue; 906 } 907 908 /* pass control to driver for optional further init */ 909 err = soc_tplg_init_kcontrol(tplg, &kc, 910 (struct snd_soc_tplg_ctl_hdr *) mc); 911 if (err < 0) { 912 dev_err(tplg->dev, "ASoC: failed to init %s\n", 913 mc->hdr.name); 914 kfree(sm); 915 continue; 916 } 917 918 /* create any TLV data */ 919 soc_tplg_create_tlv(tplg, &kc, &mc->hdr); 920 921 /* register control here */ 922 err = soc_tplg_add_kcontrol(tplg, &kc, 923 &sm->dobj.control.kcontrol); 924 if (err < 0) { 925 dev_err(tplg->dev, "ASoC: failed to add %s\n", 926 mc->hdr.name); 927 soc_tplg_free_tlv(tplg, &kc); 928 kfree(sm); 929 continue; 930 } 931 932 list_add(&sm->dobj.list, &tplg->comp->dobj_list); 933 } 934 935 return 0; 936 } 937 938 static int soc_tplg_denum_create_texts(struct soc_enum *se, 939 struct snd_soc_tplg_enum_control *ec) 940 { 941 int i, ret; 942 943 se->dobj.control.dtexts = 944 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL); 945 if (se->dobj.control.dtexts == NULL) 946 return -ENOMEM; 947 948 for (i = 0; i < ec->items; i++) { 949 950 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 951 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 952 ret = -EINVAL; 953 goto err; 954 } 955 956 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL); 957 if (!se->dobj.control.dtexts[i]) { 958 ret = -ENOMEM; 959 goto err; 960 } 961 } 962 963 se->texts = (const char * const *)se->dobj.control.dtexts; 964 return 0; 965 966 err: 967 for (--i; i >= 0; i--) 968 kfree(se->dobj.control.dtexts[i]); 969 kfree(se->dobj.control.dtexts); 970 return ret; 971 } 972 973 static int soc_tplg_denum_create_values(struct soc_enum *se, 974 struct snd_soc_tplg_enum_control *ec) 975 { 976 if (ec->items > sizeof(*ec->values)) 977 return -EINVAL; 978 979 se->dobj.control.dvalues = kmemdup(ec->values, 980 ec->items * sizeof(u32), 981 GFP_KERNEL); 982 if (!se->dobj.control.dvalues) 983 return -ENOMEM; 984 985 return 0; 986 } 987 988 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count, 989 size_t size) 990 { 991 struct snd_soc_tplg_enum_control *ec; 992 struct soc_enum *se; 993 struct snd_kcontrol_new kc; 994 int i, ret, err; 995 996 if (soc_tplg_check_elem_count(tplg, 997 sizeof(struct snd_soc_tplg_enum_control), 998 count, size, "enums")) { 999 1000 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n", 1001 count); 1002 return -EINVAL; 1003 } 1004 1005 for (i = 0; i < count; i++) { 1006 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 1007 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 1008 ec->priv.size); 1009 1010 /* validate kcontrol */ 1011 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1012 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1013 return -EINVAL; 1014 1015 se = kzalloc((sizeof(*se)), GFP_KERNEL); 1016 if (se == NULL) 1017 return -ENOMEM; 1018 1019 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n", 1020 ec->hdr.name, ec->items); 1021 1022 memset(&kc, 0, sizeof(kc)); 1023 kc.name = ec->hdr.name; 1024 kc.private_value = (long)se; 1025 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1026 kc.access = ec->hdr.access; 1027 1028 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL); 1029 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, 1030 SNDRV_CHMAP_FL); 1031 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, 1032 SNDRV_CHMAP_FL); 1033 1034 se->items = ec->items; 1035 se->mask = ec->mask; 1036 se->dobj.index = tplg->index; 1037 se->dobj.type = SND_SOC_DOBJ_ENUM; 1038 se->dobj.ops = tplg->ops; 1039 INIT_LIST_HEAD(&se->dobj.list); 1040 1041 switch (ec->hdr.ops.info) { 1042 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1043 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1044 err = soc_tplg_denum_create_values(se, ec); 1045 if (err < 0) { 1046 dev_err(tplg->dev, 1047 "ASoC: could not create values for %s\n", 1048 ec->hdr.name); 1049 kfree(se); 1050 continue; 1051 } 1052 /* fall through and create texts */ 1053 case SND_SOC_TPLG_CTL_ENUM: 1054 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1055 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1056 err = soc_tplg_denum_create_texts(se, ec); 1057 if (err < 0) { 1058 dev_err(tplg->dev, 1059 "ASoC: could not create texts for %s\n", 1060 ec->hdr.name); 1061 kfree(se); 1062 continue; 1063 } 1064 break; 1065 default: 1066 dev_err(tplg->dev, 1067 "ASoC: invalid enum control type %d for %s\n", 1068 ec->hdr.ops.info, ec->hdr.name); 1069 kfree(se); 1070 continue; 1071 } 1072 1073 /* map io handlers */ 1074 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg); 1075 if (err) { 1076 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 1077 kfree(se); 1078 continue; 1079 } 1080 1081 /* pass control to driver for optional further init */ 1082 err = soc_tplg_init_kcontrol(tplg, &kc, 1083 (struct snd_soc_tplg_ctl_hdr *) ec); 1084 if (err < 0) { 1085 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1086 ec->hdr.name); 1087 kfree(se); 1088 continue; 1089 } 1090 1091 /* register control here */ 1092 ret = soc_tplg_add_kcontrol(tplg, 1093 &kc, &se->dobj.control.kcontrol); 1094 if (ret < 0) { 1095 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n", 1096 ec->hdr.name); 1097 kfree(se); 1098 continue; 1099 } 1100 1101 list_add(&se->dobj.list, &tplg->comp->dobj_list); 1102 } 1103 1104 return 0; 1105 } 1106 1107 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg, 1108 struct snd_soc_tplg_hdr *hdr) 1109 { 1110 struct snd_soc_tplg_ctl_hdr *control_hdr; 1111 int i; 1112 1113 if (tplg->pass != SOC_TPLG_PASS_MIXER) { 1114 tplg->pos += hdr->size + hdr->payload_size; 1115 return 0; 1116 } 1117 1118 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count, 1119 soc_tplg_get_offset(tplg)); 1120 1121 for (i = 0; i < hdr->count; i++) { 1122 1123 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1124 1125 if (control_hdr->size != sizeof(*control_hdr)) { 1126 dev_err(tplg->dev, "ASoC: invalid control size\n"); 1127 return -EINVAL; 1128 } 1129 1130 switch (control_hdr->ops.info) { 1131 case SND_SOC_TPLG_CTL_VOLSW: 1132 case SND_SOC_TPLG_CTL_STROBE: 1133 case SND_SOC_TPLG_CTL_VOLSW_SX: 1134 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1135 case SND_SOC_TPLG_CTL_RANGE: 1136 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1137 case SND_SOC_TPLG_DAPM_CTL_PIN: 1138 soc_tplg_dmixer_create(tplg, 1, hdr->payload_size); 1139 break; 1140 case SND_SOC_TPLG_CTL_ENUM: 1141 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1142 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1143 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1144 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1145 soc_tplg_denum_create(tplg, 1, hdr->payload_size); 1146 break; 1147 case SND_SOC_TPLG_CTL_BYTES: 1148 soc_tplg_dbytes_create(tplg, 1, hdr->payload_size); 1149 break; 1150 default: 1151 soc_bind_err(tplg, control_hdr, i); 1152 return -EINVAL; 1153 } 1154 } 1155 1156 return 0; 1157 } 1158 1159 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg, 1160 struct snd_soc_tplg_hdr *hdr) 1161 { 1162 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm; 1163 struct snd_soc_dapm_route route; 1164 struct snd_soc_tplg_dapm_graph_elem *elem; 1165 int count = hdr->count, i; 1166 1167 if (tplg->pass != SOC_TPLG_PASS_GRAPH) { 1168 tplg->pos += hdr->size + hdr->payload_size; 1169 return 0; 1170 } 1171 1172 if (soc_tplg_check_elem_count(tplg, 1173 sizeof(struct snd_soc_tplg_dapm_graph_elem), 1174 count, hdr->payload_size, "graph")) { 1175 1176 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n", 1177 count); 1178 return -EINVAL; 1179 } 1180 1181 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes for index %d\n", count, 1182 hdr->index); 1183 1184 for (i = 0; i < count; i++) { 1185 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos; 1186 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem); 1187 1188 /* validate routes */ 1189 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1190 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1191 return -EINVAL; 1192 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1193 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1194 return -EINVAL; 1195 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1196 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1197 return -EINVAL; 1198 1199 route.source = elem->source; 1200 route.sink = elem->sink; 1201 route.connected = NULL; /* set to NULL atm for tplg users */ 1202 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0) 1203 route.control = NULL; 1204 else 1205 route.control = elem->control; 1206 1207 /* add route, but keep going if some fail */ 1208 snd_soc_dapm_add_routes(dapm, &route, 1); 1209 } 1210 1211 return 0; 1212 } 1213 1214 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create( 1215 struct soc_tplg *tplg, int num_kcontrols) 1216 { 1217 struct snd_kcontrol_new *kc; 1218 struct soc_mixer_control *sm; 1219 struct snd_soc_tplg_mixer_control *mc; 1220 int i, err; 1221 1222 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL); 1223 if (kc == NULL) 1224 return NULL; 1225 1226 for (i = 0; i < num_kcontrols; i++) { 1227 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 1228 sm = kzalloc(sizeof(*sm), GFP_KERNEL); 1229 if (sm == NULL) 1230 goto err; 1231 1232 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) + 1233 mc->priv.size); 1234 1235 /* validate kcontrol */ 1236 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1237 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1238 goto err_str; 1239 1240 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n", 1241 mc->hdr.name, i); 1242 1243 kc[i].name = kstrdup(mc->hdr.name, GFP_KERNEL); 1244 if (kc[i].name == NULL) 1245 goto err_str; 1246 kc[i].private_value = (long)sm; 1247 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1248 kc[i].access = mc->hdr.access; 1249 1250 /* we only support FL/FR channel mapping atm */ 1251 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 1252 SNDRV_CHMAP_FL); 1253 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 1254 SNDRV_CHMAP_FR); 1255 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 1256 SNDRV_CHMAP_FL); 1257 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 1258 SNDRV_CHMAP_FR); 1259 1260 sm->max = mc->max; 1261 sm->min = mc->min; 1262 sm->invert = mc->invert; 1263 sm->platform_max = mc->platform_max; 1264 sm->dobj.index = tplg->index; 1265 INIT_LIST_HEAD(&sm->dobj.list); 1266 1267 /* map io handlers */ 1268 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg); 1269 if (err) { 1270 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 1271 kfree(sm); 1272 continue; 1273 } 1274 1275 /* pass control to driver for optional further init */ 1276 err = soc_tplg_init_kcontrol(tplg, &kc[i], 1277 (struct snd_soc_tplg_ctl_hdr *)mc); 1278 if (err < 0) { 1279 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1280 mc->hdr.name); 1281 kfree(sm); 1282 continue; 1283 } 1284 1285 /* create any TLV data */ 1286 soc_tplg_create_tlv(tplg, &kc[i], &mc->hdr); 1287 } 1288 return kc; 1289 1290 err_str: 1291 kfree(sm); 1292 err: 1293 for (--i; i >= 0; i--) { 1294 kfree((void *)kc[i].private_value); 1295 kfree(kc[i].name); 1296 } 1297 kfree(kc); 1298 return NULL; 1299 } 1300 1301 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create( 1302 struct soc_tplg *tplg, int num_kcontrols) 1303 { 1304 struct snd_kcontrol_new *kc; 1305 struct snd_soc_tplg_enum_control *ec; 1306 struct soc_enum *se; 1307 int i, j, err; 1308 1309 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL); 1310 if (kc == NULL) 1311 return NULL; 1312 1313 for (i = 0; i < num_kcontrols; i++) { 1314 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 1315 /* validate kcontrol */ 1316 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1317 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1318 goto err; 1319 1320 se = kzalloc(sizeof(*se), GFP_KERNEL); 1321 if (se == NULL) 1322 goto err; 1323 1324 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n", 1325 ec->hdr.name); 1326 1327 kc[i].name = kstrdup(ec->hdr.name, GFP_KERNEL); 1328 if (kc[i].name == NULL) { 1329 kfree(se); 1330 goto err_se; 1331 } 1332 kc[i].private_value = (long)se; 1333 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1334 kc[i].access = ec->hdr.access; 1335 1336 /* we only support FL/FR channel mapping atm */ 1337 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL); 1338 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, 1339 SNDRV_CHMAP_FL); 1340 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, 1341 SNDRV_CHMAP_FR); 1342 1343 se->items = ec->items; 1344 se->mask = ec->mask; 1345 se->dobj.index = tplg->index; 1346 1347 switch (ec->hdr.ops.info) { 1348 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1349 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1350 err = soc_tplg_denum_create_values(se, ec); 1351 if (err < 0) { 1352 dev_err(tplg->dev, "ASoC: could not create values for %s\n", 1353 ec->hdr.name); 1354 goto err_se; 1355 } 1356 /* fall through to create texts */ 1357 case SND_SOC_TPLG_CTL_ENUM: 1358 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1359 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1360 err = soc_tplg_denum_create_texts(se, ec); 1361 if (err < 0) { 1362 dev_err(tplg->dev, "ASoC: could not create texts for %s\n", 1363 ec->hdr.name); 1364 goto err_se; 1365 } 1366 break; 1367 default: 1368 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n", 1369 ec->hdr.ops.info, ec->hdr.name); 1370 goto err_se; 1371 } 1372 1373 /* map io handlers */ 1374 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc[i], tplg); 1375 if (err) { 1376 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 1377 goto err_se; 1378 } 1379 1380 /* pass control to driver for optional further init */ 1381 err = soc_tplg_init_kcontrol(tplg, &kc[i], 1382 (struct snd_soc_tplg_ctl_hdr *)ec); 1383 if (err < 0) { 1384 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1385 ec->hdr.name); 1386 goto err_se; 1387 } 1388 1389 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 1390 ec->priv.size); 1391 } 1392 1393 return kc; 1394 1395 err_se: 1396 for (; i >= 0; i--) { 1397 /* free values and texts */ 1398 se = (struct soc_enum *)kc[i].private_value; 1399 if (!se) 1400 continue; 1401 1402 kfree(se->dobj.control.dvalues); 1403 for (j = 0; j < ec->items; j++) 1404 kfree(se->dobj.control.dtexts[j]); 1405 1406 kfree(se); 1407 kfree(kc[i].name); 1408 } 1409 err: 1410 kfree(kc); 1411 1412 return NULL; 1413 } 1414 1415 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create( 1416 struct soc_tplg *tplg, int count) 1417 { 1418 struct snd_soc_tplg_bytes_control *be; 1419 struct soc_bytes_ext *sbe; 1420 struct snd_kcontrol_new *kc; 1421 int i, err; 1422 1423 kc = kcalloc(count, sizeof(*kc), GFP_KERNEL); 1424 if (!kc) 1425 return NULL; 1426 1427 for (i = 0; i < count; i++) { 1428 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 1429 1430 /* validate kcontrol */ 1431 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1432 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1433 goto err; 1434 1435 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL); 1436 if (sbe == NULL) 1437 goto err; 1438 1439 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 1440 be->priv.size); 1441 1442 dev_dbg(tplg->dev, 1443 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 1444 be->hdr.name, be->hdr.access); 1445 1446 kc[i].name = kstrdup(be->hdr.name, GFP_KERNEL); 1447 if (kc[i].name == NULL) { 1448 kfree(sbe); 1449 goto err; 1450 } 1451 kc[i].private_value = (long)sbe; 1452 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1453 kc[i].access = be->hdr.access; 1454 1455 sbe->max = be->max; 1456 INIT_LIST_HEAD(&sbe->dobj.list); 1457 1458 /* map standard io handlers and check for external handlers */ 1459 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg); 1460 if (err) { 1461 soc_control_err(tplg, &be->hdr, be->hdr.name); 1462 kfree(sbe); 1463 continue; 1464 } 1465 1466 /* pass control to driver for optional further init */ 1467 err = soc_tplg_init_kcontrol(tplg, &kc[i], 1468 (struct snd_soc_tplg_ctl_hdr *)be); 1469 if (err < 0) { 1470 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1471 be->hdr.name); 1472 kfree(sbe); 1473 continue; 1474 } 1475 } 1476 1477 return kc; 1478 1479 err: 1480 for (--i; i >= 0; i--) { 1481 kfree((void *)kc[i].private_value); 1482 kfree(kc[i].name); 1483 } 1484 1485 kfree(kc); 1486 return NULL; 1487 } 1488 1489 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg, 1490 struct snd_soc_tplg_dapm_widget *w) 1491 { 1492 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm; 1493 struct snd_soc_dapm_widget template, *widget; 1494 struct snd_soc_tplg_ctl_hdr *control_hdr; 1495 struct snd_soc_card *card = tplg->comp->card; 1496 unsigned int kcontrol_type; 1497 int ret = 0; 1498 1499 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1500 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1501 return -EINVAL; 1502 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1503 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1504 return -EINVAL; 1505 1506 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n", 1507 w->name, w->id); 1508 1509 memset(&template, 0, sizeof(template)); 1510 1511 /* map user to kernel widget ID */ 1512 template.id = get_widget_id(w->id); 1513 if (template.id < 0) 1514 return template.id; 1515 1516 /* strings are allocated here, but used and freed by the widget */ 1517 template.name = kstrdup(w->name, GFP_KERNEL); 1518 if (!template.name) 1519 return -ENOMEM; 1520 template.sname = kstrdup(w->sname, GFP_KERNEL); 1521 if (!template.sname) { 1522 ret = -ENOMEM; 1523 goto err; 1524 } 1525 template.reg = w->reg; 1526 template.shift = w->shift; 1527 template.mask = w->mask; 1528 template.subseq = w->subseq; 1529 template.on_val = w->invert ? 0 : 1; 1530 template.off_val = w->invert ? 1 : 0; 1531 template.ignore_suspend = w->ignore_suspend; 1532 template.event_flags = w->event_flags; 1533 template.dobj.index = tplg->index; 1534 1535 tplg->pos += 1536 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size); 1537 if (w->num_kcontrols == 0) { 1538 kcontrol_type = 0; 1539 template.num_kcontrols = 0; 1540 goto widget; 1541 } 1542 1543 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1544 dev_dbg(tplg->dev, "ASoC: template %s has %d controls of type %x\n", 1545 w->name, w->num_kcontrols, control_hdr->type); 1546 1547 switch (control_hdr->ops.info) { 1548 case SND_SOC_TPLG_CTL_VOLSW: 1549 case SND_SOC_TPLG_CTL_STROBE: 1550 case SND_SOC_TPLG_CTL_VOLSW_SX: 1551 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1552 case SND_SOC_TPLG_CTL_RANGE: 1553 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1554 kcontrol_type = SND_SOC_TPLG_TYPE_MIXER; /* volume mixer */ 1555 template.num_kcontrols = w->num_kcontrols; 1556 template.kcontrol_news = 1557 soc_tplg_dapm_widget_dmixer_create(tplg, 1558 template.num_kcontrols); 1559 if (!template.kcontrol_news) { 1560 ret = -ENOMEM; 1561 goto hdr_err; 1562 } 1563 break; 1564 case SND_SOC_TPLG_CTL_ENUM: 1565 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1566 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1567 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1568 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1569 kcontrol_type = SND_SOC_TPLG_TYPE_ENUM; /* enumerated mixer */ 1570 template.num_kcontrols = w->num_kcontrols; 1571 template.kcontrol_news = 1572 soc_tplg_dapm_widget_denum_create(tplg, 1573 template.num_kcontrols); 1574 if (!template.kcontrol_news) { 1575 ret = -ENOMEM; 1576 goto hdr_err; 1577 } 1578 break; 1579 case SND_SOC_TPLG_CTL_BYTES: 1580 kcontrol_type = SND_SOC_TPLG_TYPE_BYTES; /* bytes control */ 1581 template.num_kcontrols = w->num_kcontrols; 1582 template.kcontrol_news = 1583 soc_tplg_dapm_widget_dbytes_create(tplg, 1584 template.num_kcontrols); 1585 if (!template.kcontrol_news) { 1586 ret = -ENOMEM; 1587 goto hdr_err; 1588 } 1589 break; 1590 default: 1591 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n", 1592 control_hdr->ops.get, control_hdr->ops.put, 1593 control_hdr->ops.info); 1594 ret = -EINVAL; 1595 goto hdr_err; 1596 } 1597 1598 widget: 1599 ret = soc_tplg_widget_load(tplg, &template, w); 1600 if (ret < 0) 1601 goto hdr_err; 1602 1603 /* card dapm mutex is held by the core if we are loading topology 1604 * data during sound card init. */ 1605 if (card->instantiated) 1606 widget = snd_soc_dapm_new_control(dapm, &template); 1607 else 1608 widget = snd_soc_dapm_new_control_unlocked(dapm, &template); 1609 if (IS_ERR(widget)) { 1610 ret = PTR_ERR(widget); 1611 /* Do not nag about probe deferrals */ 1612 if (ret != -EPROBE_DEFER) 1613 dev_err(tplg->dev, 1614 "ASoC: failed to create widget %s controls (%d)\n", 1615 w->name, ret); 1616 goto hdr_err; 1617 } 1618 if (widget == NULL) { 1619 dev_err(tplg->dev, "ASoC: failed to create widget %s controls\n", 1620 w->name); 1621 ret = -ENOMEM; 1622 goto hdr_err; 1623 } 1624 1625 widget->dobj.type = SND_SOC_DOBJ_WIDGET; 1626 widget->dobj.widget.kcontrol_type = kcontrol_type; 1627 widget->dobj.ops = tplg->ops; 1628 widget->dobj.index = tplg->index; 1629 list_add(&widget->dobj.list, &tplg->comp->dobj_list); 1630 1631 ret = soc_tplg_widget_ready(tplg, widget, w); 1632 if (ret < 0) 1633 goto ready_err; 1634 1635 return 0; 1636 1637 ready_err: 1638 snd_soc_tplg_widget_remove(widget); 1639 snd_soc_dapm_free_widget(widget); 1640 hdr_err: 1641 kfree(template.sname); 1642 err: 1643 kfree(template.name); 1644 return ret; 1645 } 1646 1647 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg, 1648 struct snd_soc_tplg_hdr *hdr) 1649 { 1650 struct snd_soc_tplg_dapm_widget *widget; 1651 int ret, count = hdr->count, i; 1652 1653 if (tplg->pass != SOC_TPLG_PASS_WIDGET) 1654 return 0; 1655 1656 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count); 1657 1658 for (i = 0; i < count; i++) { 1659 widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos; 1660 if (widget->size != sizeof(*widget)) { 1661 dev_err(tplg->dev, "ASoC: invalid widget size\n"); 1662 return -EINVAL; 1663 } 1664 1665 ret = soc_tplg_dapm_widget_create(tplg, widget); 1666 if (ret < 0) { 1667 dev_err(tplg->dev, "ASoC: failed to load widget %s\n", 1668 widget->name); 1669 return ret; 1670 } 1671 } 1672 1673 return 0; 1674 } 1675 1676 static int soc_tplg_dapm_complete(struct soc_tplg *tplg) 1677 { 1678 struct snd_soc_card *card = tplg->comp->card; 1679 int ret; 1680 1681 /* Card might not have been registered at this point. 1682 * If so, just return success. 1683 */ 1684 if (!card || !card->instantiated) { 1685 dev_warn(tplg->dev, "ASoC: Parent card not yet available," 1686 " widget card binding deferred\n"); 1687 return 0; 1688 } 1689 1690 ret = snd_soc_dapm_new_widgets(card); 1691 if (ret < 0) 1692 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n", 1693 ret); 1694 1695 return 0; 1696 } 1697 1698 static void set_stream_info(struct snd_soc_pcm_stream *stream, 1699 struct snd_soc_tplg_stream_caps *caps) 1700 { 1701 stream->stream_name = kstrdup(caps->name, GFP_KERNEL); 1702 stream->channels_min = caps->channels_min; 1703 stream->channels_max = caps->channels_max; 1704 stream->rates = caps->rates; 1705 stream->rate_min = caps->rate_min; 1706 stream->rate_max = caps->rate_max; 1707 stream->formats = caps->formats; 1708 stream->sig_bits = caps->sig_bits; 1709 } 1710 1711 static void set_dai_flags(struct snd_soc_dai_driver *dai_drv, 1712 unsigned int flag_mask, unsigned int flags) 1713 { 1714 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) 1715 dai_drv->symmetric_rates = 1716 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES ? 1 : 0; 1717 1718 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) 1719 dai_drv->symmetric_channels = 1720 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS ? 1721 1 : 0; 1722 1723 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) 1724 dai_drv->symmetric_samplebits = 1725 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS ? 1726 1 : 0; 1727 } 1728 1729 static int soc_tplg_dai_create(struct soc_tplg *tplg, 1730 struct snd_soc_tplg_pcm *pcm) 1731 { 1732 struct snd_soc_dai_driver *dai_drv; 1733 struct snd_soc_pcm_stream *stream; 1734 struct snd_soc_tplg_stream_caps *caps; 1735 int ret; 1736 1737 dai_drv = kzalloc(sizeof(struct snd_soc_dai_driver), GFP_KERNEL); 1738 if (dai_drv == NULL) 1739 return -ENOMEM; 1740 1741 if (strlen(pcm->dai_name)) 1742 dai_drv->name = kstrdup(pcm->dai_name, GFP_KERNEL); 1743 dai_drv->id = pcm->dai_id; 1744 1745 if (pcm->playback) { 1746 stream = &dai_drv->playback; 1747 caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 1748 set_stream_info(stream, caps); 1749 } 1750 1751 if (pcm->capture) { 1752 stream = &dai_drv->capture; 1753 caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 1754 set_stream_info(stream, caps); 1755 } 1756 1757 /* pass control to component driver for optional further init */ 1758 ret = soc_tplg_dai_load(tplg, dai_drv); 1759 if (ret < 0) { 1760 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); 1761 kfree(dai_drv); 1762 return ret; 1763 } 1764 1765 dai_drv->dobj.index = tplg->index; 1766 dai_drv->dobj.ops = tplg->ops; 1767 dai_drv->dobj.type = SND_SOC_DOBJ_PCM; 1768 list_add(&dai_drv->dobj.list, &tplg->comp->dobj_list); 1769 1770 /* register the DAI to the component */ 1771 return snd_soc_register_dai(tplg->comp, dai_drv); 1772 } 1773 1774 static void set_link_flags(struct snd_soc_dai_link *link, 1775 unsigned int flag_mask, unsigned int flags) 1776 { 1777 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES) 1778 link->symmetric_rates = 1779 flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES ? 1 : 0; 1780 1781 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS) 1782 link->symmetric_channels = 1783 flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS ? 1784 1 : 0; 1785 1786 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS) 1787 link->symmetric_samplebits = 1788 flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS ? 1789 1 : 0; 1790 1791 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP) 1792 link->ignore_suspend = 1793 flags & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP ? 1794 1 : 0; 1795 } 1796 1797 /* create the FE DAI link */ 1798 static int soc_tplg_fe_link_create(struct soc_tplg *tplg, 1799 struct snd_soc_tplg_pcm *pcm) 1800 { 1801 struct snd_soc_dai_link *link; 1802 int ret; 1803 1804 link = kzalloc(sizeof(struct snd_soc_dai_link), GFP_KERNEL); 1805 if (link == NULL) 1806 return -ENOMEM; 1807 1808 if (strlen(pcm->pcm_name)) { 1809 link->name = kstrdup(pcm->pcm_name, GFP_KERNEL); 1810 link->stream_name = kstrdup(pcm->pcm_name, GFP_KERNEL); 1811 } 1812 link->id = pcm->pcm_id; 1813 1814 if (strlen(pcm->dai_name)) 1815 link->cpu_dai_name = kstrdup(pcm->dai_name, GFP_KERNEL); 1816 1817 link->codec_name = "snd-soc-dummy"; 1818 link->codec_dai_name = "snd-soc-dummy-dai"; 1819 1820 /* enable DPCM */ 1821 link->dynamic = 1; 1822 link->dpcm_playback = pcm->playback; 1823 link->dpcm_capture = pcm->capture; 1824 if (pcm->flag_mask) 1825 set_link_flags(link, pcm->flag_mask, pcm->flags); 1826 1827 /* pass control to component driver for optional further init */ 1828 ret = soc_tplg_dai_link_load(tplg, link); 1829 if (ret < 0) { 1830 dev_err(tplg->comp->dev, "ASoC: FE link loading failed\n"); 1831 kfree(link); 1832 return ret; 1833 } 1834 1835 link->dobj.index = tplg->index; 1836 link->dobj.ops = tplg->ops; 1837 link->dobj.type = SND_SOC_DOBJ_DAI_LINK; 1838 list_add(&link->dobj.list, &tplg->comp->dobj_list); 1839 1840 snd_soc_add_dai_link(tplg->comp->card, link); 1841 return 0; 1842 } 1843 1844 /* create a FE DAI and DAI link from the PCM object */ 1845 static int soc_tplg_pcm_create(struct soc_tplg *tplg, 1846 struct snd_soc_tplg_pcm *pcm) 1847 { 1848 int ret; 1849 1850 ret = soc_tplg_dai_create(tplg, pcm); 1851 if (ret < 0) 1852 return ret; 1853 1854 return soc_tplg_fe_link_create(tplg, pcm); 1855 } 1856 1857 /* copy stream caps from the old version 4 of source */ 1858 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps *dest, 1859 struct snd_soc_tplg_stream_caps_v4 *src) 1860 { 1861 dest->size = sizeof(*dest); 1862 memcpy(dest->name, src->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1863 dest->formats = src->formats; 1864 dest->rates = src->rates; 1865 dest->rate_min = src->rate_min; 1866 dest->rate_max = src->rate_max; 1867 dest->channels_min = src->channels_min; 1868 dest->channels_max = src->channels_max; 1869 dest->periods_min = src->periods_min; 1870 dest->periods_max = src->periods_max; 1871 dest->period_size_min = src->period_size_min; 1872 dest->period_size_max = src->period_size_max; 1873 dest->buffer_size_min = src->buffer_size_min; 1874 dest->buffer_size_max = src->buffer_size_max; 1875 } 1876 1877 /** 1878 * pcm_new_ver - Create the new version of PCM from the old version. 1879 * @tplg: topology context 1880 * @src: older version of pcm as a source 1881 * @pcm: latest version of pcm created from the source 1882 * 1883 * Support from vesion 4. User should free the returned pcm manually. 1884 */ 1885 static int pcm_new_ver(struct soc_tplg *tplg, 1886 struct snd_soc_tplg_pcm *src, 1887 struct snd_soc_tplg_pcm **pcm) 1888 { 1889 struct snd_soc_tplg_pcm *dest; 1890 struct snd_soc_tplg_pcm_v4 *src_v4; 1891 int i; 1892 1893 *pcm = NULL; 1894 1895 if (src->size != sizeof(*src_v4)) { 1896 dev_err(tplg->dev, "ASoC: invalid PCM size\n"); 1897 return -EINVAL; 1898 } 1899 1900 dev_warn(tplg->dev, "ASoC: old version of PCM\n"); 1901 src_v4 = (struct snd_soc_tplg_pcm_v4 *)src; 1902 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 1903 if (!dest) 1904 return -ENOMEM; 1905 1906 dest->size = sizeof(*dest); /* size of latest abi version */ 1907 memcpy(dest->pcm_name, src_v4->pcm_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1908 memcpy(dest->dai_name, src_v4->dai_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1909 dest->pcm_id = src_v4->pcm_id; 1910 dest->dai_id = src_v4->dai_id; 1911 dest->playback = src_v4->playback; 1912 dest->capture = src_v4->capture; 1913 dest->compress = src_v4->compress; 1914 dest->num_streams = src_v4->num_streams; 1915 for (i = 0; i < dest->num_streams; i++) 1916 memcpy(&dest->stream[i], &src_v4->stream[i], 1917 sizeof(struct snd_soc_tplg_stream)); 1918 1919 for (i = 0; i < 2; i++) 1920 stream_caps_new_ver(&dest->caps[i], &src_v4->caps[i]); 1921 1922 *pcm = dest; 1923 return 0; 1924 } 1925 1926 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, 1927 struct snd_soc_tplg_hdr *hdr) 1928 { 1929 struct snd_soc_tplg_pcm *pcm, *_pcm; 1930 int count = hdr->count; 1931 int i; 1932 bool abi_match; 1933 1934 if (tplg->pass != SOC_TPLG_PASS_PCM_DAI) 1935 return 0; 1936 1937 /* check the element size and count */ 1938 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1939 if (pcm->size > sizeof(struct snd_soc_tplg_pcm) 1940 || pcm->size < sizeof(struct snd_soc_tplg_pcm_v4)) { 1941 dev_err(tplg->dev, "ASoC: invalid size %d for PCM elems\n", 1942 pcm->size); 1943 return -EINVAL; 1944 } 1945 1946 if (soc_tplg_check_elem_count(tplg, 1947 pcm->size, count, 1948 hdr->payload_size, "PCM DAI")) { 1949 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n", 1950 count); 1951 return -EINVAL; 1952 } 1953 1954 for (i = 0; i < count; i++) { 1955 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1956 1957 /* check ABI version by size, create a new version of pcm 1958 * if abi not match. 1959 */ 1960 if (pcm->size == sizeof(*pcm)) { 1961 abi_match = true; 1962 _pcm = pcm; 1963 } else { 1964 abi_match = false; 1965 pcm_new_ver(tplg, pcm, &_pcm); 1966 } 1967 1968 /* create the FE DAIs and DAI links */ 1969 soc_tplg_pcm_create(tplg, _pcm); 1970 1971 /* offset by version-specific struct size and 1972 * real priv data size 1973 */ 1974 tplg->pos += pcm->size + _pcm->priv.size; 1975 1976 if (!abi_match) 1977 kfree(_pcm); /* free the duplicated one */ 1978 } 1979 1980 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count); 1981 1982 return 0; 1983 } 1984 1985 /** 1986 * set_link_hw_format - Set the HW audio format of the physical DAI link. 1987 * @link: &snd_soc_dai_link which should be updated 1988 * @cfg: physical link configs. 1989 * 1990 * Topology context contains a list of supported HW formats (configs) and 1991 * a default format ID for the physical link. This function will use this 1992 * default ID to choose the HW format to set the link's DAI format for init. 1993 */ 1994 static void set_link_hw_format(struct snd_soc_dai_link *link, 1995 struct snd_soc_tplg_link_config *cfg) 1996 { 1997 struct snd_soc_tplg_hw_config *hw_config; 1998 unsigned char bclk_master, fsync_master; 1999 unsigned char invert_bclk, invert_fsync; 2000 int i; 2001 2002 for (i = 0; i < cfg->num_hw_configs; i++) { 2003 hw_config = &cfg->hw_config[i]; 2004 if (hw_config->id != cfg->default_hw_config_id) 2005 continue; 2006 2007 link->dai_fmt = hw_config->fmt & SND_SOC_DAIFMT_FORMAT_MASK; 2008 2009 /* clock signal polarity */ 2010 invert_bclk = hw_config->invert_bclk; 2011 invert_fsync = hw_config->invert_fsync; 2012 if (!invert_bclk && !invert_fsync) 2013 link->dai_fmt |= SND_SOC_DAIFMT_NB_NF; 2014 else if (!invert_bclk && invert_fsync) 2015 link->dai_fmt |= SND_SOC_DAIFMT_NB_IF; 2016 else if (invert_bclk && !invert_fsync) 2017 link->dai_fmt |= SND_SOC_DAIFMT_IB_NF; 2018 else 2019 link->dai_fmt |= SND_SOC_DAIFMT_IB_IF; 2020 2021 /* clock masters */ 2022 bclk_master = hw_config->bclk_master; 2023 fsync_master = hw_config->fsync_master; 2024 if (!bclk_master && !fsync_master) 2025 link->dai_fmt |= SND_SOC_DAIFMT_CBM_CFM; 2026 else if (bclk_master && !fsync_master) 2027 link->dai_fmt |= SND_SOC_DAIFMT_CBS_CFM; 2028 else if (!bclk_master && fsync_master) 2029 link->dai_fmt |= SND_SOC_DAIFMT_CBM_CFS; 2030 else 2031 link->dai_fmt |= SND_SOC_DAIFMT_CBS_CFS; 2032 } 2033 } 2034 2035 /** 2036 * link_new_ver - Create a new physical link config from the old 2037 * version of source. 2038 * @tplg: topology context 2039 * @src: old version of phyical link config as a source 2040 * @link: latest version of physical link config created from the source 2041 * 2042 * Support from vesion 4. User need free the returned link config manually. 2043 */ 2044 static int link_new_ver(struct soc_tplg *tplg, 2045 struct snd_soc_tplg_link_config *src, 2046 struct snd_soc_tplg_link_config **link) 2047 { 2048 struct snd_soc_tplg_link_config *dest; 2049 struct snd_soc_tplg_link_config_v4 *src_v4; 2050 int i; 2051 2052 *link = NULL; 2053 2054 if (src->size != sizeof(struct snd_soc_tplg_link_config_v4)) { 2055 dev_err(tplg->dev, "ASoC: invalid physical link config size\n"); 2056 return -EINVAL; 2057 } 2058 2059 dev_warn(tplg->dev, "ASoC: old version of physical link config\n"); 2060 2061 src_v4 = (struct snd_soc_tplg_link_config_v4 *)src; 2062 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 2063 if (!dest) 2064 return -ENOMEM; 2065 2066 dest->size = sizeof(*dest); 2067 dest->id = src_v4->id; 2068 dest->num_streams = src_v4->num_streams; 2069 for (i = 0; i < dest->num_streams; i++) 2070 memcpy(&dest->stream[i], &src_v4->stream[i], 2071 sizeof(struct snd_soc_tplg_stream)); 2072 2073 *link = dest; 2074 return 0; 2075 } 2076 2077 /* Find and configure an existing physical DAI link */ 2078 static int soc_tplg_link_config(struct soc_tplg *tplg, 2079 struct snd_soc_tplg_link_config *cfg) 2080 { 2081 struct snd_soc_dai_link *link; 2082 const char *name, *stream_name; 2083 size_t len; 2084 int ret; 2085 2086 len = strnlen(cfg->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2087 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2088 return -EINVAL; 2089 else if (len) 2090 name = cfg->name; 2091 else 2092 name = NULL; 2093 2094 len = strnlen(cfg->stream_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2095 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2096 return -EINVAL; 2097 else if (len) 2098 stream_name = cfg->stream_name; 2099 else 2100 stream_name = NULL; 2101 2102 link = snd_soc_find_dai_link(tplg->comp->card, cfg->id, 2103 name, stream_name); 2104 if (!link) { 2105 dev_err(tplg->dev, "ASoC: physical link %s (id %d) not exist\n", 2106 name, cfg->id); 2107 return -EINVAL; 2108 } 2109 2110 /* hw format */ 2111 if (cfg->num_hw_configs) 2112 set_link_hw_format(link, cfg); 2113 2114 /* flags */ 2115 if (cfg->flag_mask) 2116 set_link_flags(link, cfg->flag_mask, cfg->flags); 2117 2118 /* pass control to component driver for optional further init */ 2119 ret = soc_tplg_dai_link_load(tplg, link); 2120 if (ret < 0) { 2121 dev_err(tplg->dev, "ASoC: physical link loading failed\n"); 2122 return ret; 2123 } 2124 2125 return 0; 2126 } 2127 2128 2129 /* Load physical link config elements from the topology context */ 2130 static int soc_tplg_link_elems_load(struct soc_tplg *tplg, 2131 struct snd_soc_tplg_hdr *hdr) 2132 { 2133 struct snd_soc_tplg_link_config *link, *_link; 2134 int count = hdr->count; 2135 int i, ret; 2136 bool abi_match; 2137 2138 if (tplg->pass != SOC_TPLG_PASS_LINK) { 2139 tplg->pos += hdr->size + hdr->payload_size; 2140 return 0; 2141 }; 2142 2143 /* check the element size and count */ 2144 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2145 if (link->size > sizeof(struct snd_soc_tplg_link_config) 2146 || link->size < sizeof(struct snd_soc_tplg_link_config_v4)) { 2147 dev_err(tplg->dev, "ASoC: invalid size %d for physical link elems\n", 2148 link->size); 2149 return -EINVAL; 2150 } 2151 2152 if (soc_tplg_check_elem_count(tplg, 2153 link->size, count, 2154 hdr->payload_size, "physical link config")) { 2155 dev_err(tplg->dev, "ASoC: invalid count %d for physical link elems\n", 2156 count); 2157 return -EINVAL; 2158 } 2159 2160 /* config physical DAI links */ 2161 for (i = 0; i < count; i++) { 2162 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2163 if (link->size == sizeof(*link)) { 2164 abi_match = true; 2165 _link = link; 2166 } else { 2167 abi_match = false; 2168 ret = link_new_ver(tplg, link, &_link); 2169 if (ret < 0) 2170 return ret; 2171 } 2172 2173 ret = soc_tplg_link_config(tplg, _link); 2174 if (ret < 0) 2175 return ret; 2176 2177 /* offset by version-specific struct size and 2178 * real priv data size 2179 */ 2180 tplg->pos += link->size + _link->priv.size; 2181 2182 if (!abi_match) 2183 kfree(_link); /* free the duplicated one */ 2184 } 2185 2186 return 0; 2187 } 2188 2189 /** 2190 * soc_tplg_dai_config - Find and configure an existing physical DAI. 2191 * @tplg: topology context 2192 * @d: physical DAI configs. 2193 * 2194 * The physical dai should already be registered by the platform driver. 2195 * The platform driver should specify the DAI name and ID for matching. 2196 */ 2197 static int soc_tplg_dai_config(struct soc_tplg *tplg, 2198 struct snd_soc_tplg_dai *d) 2199 { 2200 struct snd_soc_dai_link_component dai_component = {0}; 2201 struct snd_soc_dai *dai; 2202 struct snd_soc_dai_driver *dai_drv; 2203 struct snd_soc_pcm_stream *stream; 2204 struct snd_soc_tplg_stream_caps *caps; 2205 int ret; 2206 2207 dai_component.dai_name = d->dai_name; 2208 dai = snd_soc_find_dai(&dai_component); 2209 if (!dai) { 2210 dev_err(tplg->dev, "ASoC: physical DAI %s not registered\n", 2211 d->dai_name); 2212 return -EINVAL; 2213 } 2214 2215 if (d->dai_id != dai->id) { 2216 dev_err(tplg->dev, "ASoC: physical DAI %s id mismatch\n", 2217 d->dai_name); 2218 return -EINVAL; 2219 } 2220 2221 dai_drv = dai->driver; 2222 if (!dai_drv) 2223 return -EINVAL; 2224 2225 if (d->playback) { 2226 stream = &dai_drv->playback; 2227 caps = &d->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 2228 set_stream_info(stream, caps); 2229 } 2230 2231 if (d->capture) { 2232 stream = &dai_drv->capture; 2233 caps = &d->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 2234 set_stream_info(stream, caps); 2235 } 2236 2237 if (d->flag_mask) 2238 set_dai_flags(dai_drv, d->flag_mask, d->flags); 2239 2240 /* pass control to component driver for optional further init */ 2241 ret = soc_tplg_dai_load(tplg, dai_drv); 2242 if (ret < 0) { 2243 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); 2244 return ret; 2245 } 2246 2247 return 0; 2248 } 2249 2250 /* load physical DAI elements */ 2251 static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, 2252 struct snd_soc_tplg_hdr *hdr) 2253 { 2254 struct snd_soc_tplg_dai *dai; 2255 int count = hdr->count; 2256 int i; 2257 2258 if (tplg->pass != SOC_TPLG_PASS_BE_DAI) 2259 return 0; 2260 2261 /* config the existing BE DAIs */ 2262 for (i = 0; i < count; i++) { 2263 dai = (struct snd_soc_tplg_dai *)tplg->pos; 2264 if (dai->size != sizeof(*dai)) { 2265 dev_err(tplg->dev, "ASoC: invalid physical DAI size\n"); 2266 return -EINVAL; 2267 } 2268 2269 soc_tplg_dai_config(tplg, dai); 2270 tplg->pos += (sizeof(*dai) + dai->priv.size); 2271 } 2272 2273 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count); 2274 return 0; 2275 } 2276 2277 /** 2278 * manifest_new_ver - Create a new version of manifest from the old version 2279 * of source. 2280 * @tplg: topology context 2281 * @src: old version of manifest as a source 2282 * @manifest: latest version of manifest created from the source 2283 * 2284 * Support from vesion 4. Users need free the returned manifest manually. 2285 */ 2286 static int manifest_new_ver(struct soc_tplg *tplg, 2287 struct snd_soc_tplg_manifest *src, 2288 struct snd_soc_tplg_manifest **manifest) 2289 { 2290 struct snd_soc_tplg_manifest *dest; 2291 struct snd_soc_tplg_manifest_v4 *src_v4; 2292 2293 *manifest = NULL; 2294 2295 if (src->size != sizeof(*src_v4)) { 2296 dev_err(tplg->dev, "ASoC: invalid manifest size\n"); 2297 return -EINVAL; 2298 } 2299 2300 dev_warn(tplg->dev, "ASoC: old version of manifest\n"); 2301 2302 src_v4 = (struct snd_soc_tplg_manifest_v4 *)src; 2303 dest = kzalloc(sizeof(*dest) + src_v4->priv.size, GFP_KERNEL); 2304 if (!dest) 2305 return -ENOMEM; 2306 2307 dest->size = sizeof(*dest); /* size of latest abi version */ 2308 dest->control_elems = src_v4->control_elems; 2309 dest->widget_elems = src_v4->widget_elems; 2310 dest->graph_elems = src_v4->graph_elems; 2311 dest->pcm_elems = src_v4->pcm_elems; 2312 dest->dai_link_elems = src_v4->dai_link_elems; 2313 dest->priv.size = src_v4->priv.size; 2314 if (dest->priv.size) 2315 memcpy(dest->priv.data, src_v4->priv.data, 2316 src_v4->priv.size); 2317 2318 *manifest = dest; 2319 return 0; 2320 } 2321 2322 static int soc_tplg_manifest_load(struct soc_tplg *tplg, 2323 struct snd_soc_tplg_hdr *hdr) 2324 { 2325 struct snd_soc_tplg_manifest *manifest, *_manifest; 2326 bool abi_match; 2327 int err; 2328 2329 if (tplg->pass != SOC_TPLG_PASS_MANIFEST) 2330 return 0; 2331 2332 manifest = (struct snd_soc_tplg_manifest *)tplg->pos; 2333 2334 /* check ABI version by size, create a new manifest if abi not match */ 2335 if (manifest->size == sizeof(*manifest)) { 2336 abi_match = true; 2337 _manifest = manifest; 2338 } else { 2339 abi_match = false; 2340 err = manifest_new_ver(tplg, manifest, &_manifest); 2341 if (err < 0) 2342 return err; 2343 } 2344 2345 /* pass control to component driver for optional further init */ 2346 if (tplg->comp && tplg->ops && tplg->ops->manifest) 2347 return tplg->ops->manifest(tplg->comp, _manifest); 2348 2349 if (!abi_match) /* free the duplicated one */ 2350 kfree(_manifest); 2351 2352 return 0; 2353 } 2354 2355 /* validate header magic, size and type */ 2356 static int soc_valid_header(struct soc_tplg *tplg, 2357 struct snd_soc_tplg_hdr *hdr) 2358 { 2359 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size) 2360 return 0; 2361 2362 if (hdr->size != sizeof(*hdr)) { 2363 dev_err(tplg->dev, 2364 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n", 2365 hdr->type, soc_tplg_get_hdr_offset(tplg), 2366 tplg->fw->size); 2367 return -EINVAL; 2368 } 2369 2370 /* big endian firmware objects not supported atm */ 2371 if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) { 2372 dev_err(tplg->dev, 2373 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", 2374 tplg->pass, hdr->magic, 2375 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2376 return -EINVAL; 2377 } 2378 2379 if (hdr->magic != SND_SOC_TPLG_MAGIC) { 2380 dev_err(tplg->dev, 2381 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n", 2382 tplg->pass, hdr->magic, 2383 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2384 return -EINVAL; 2385 } 2386 2387 /* Support ABI from version 4 */ 2388 if (hdr->abi > SND_SOC_TPLG_ABI_VERSION 2389 || hdr->abi < SND_SOC_TPLG_ABI_VERSION_MIN) { 2390 dev_err(tplg->dev, 2391 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n", 2392 tplg->pass, hdr->abi, 2393 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg), 2394 tplg->fw->size); 2395 return -EINVAL; 2396 } 2397 2398 if (hdr->payload_size == 0) { 2399 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n", 2400 soc_tplg_get_hdr_offset(tplg)); 2401 return -EINVAL; 2402 } 2403 2404 if (tplg->pass == hdr->type) 2405 dev_dbg(tplg->dev, 2406 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n", 2407 hdr->payload_size, hdr->type, hdr->version, 2408 hdr->vendor_type, tplg->pass); 2409 2410 return 1; 2411 } 2412 2413 /* check header type and call appropriate handler */ 2414 static int soc_tplg_load_header(struct soc_tplg *tplg, 2415 struct snd_soc_tplg_hdr *hdr) 2416 { 2417 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr); 2418 2419 /* check for matching ID */ 2420 if (hdr->index != tplg->req_index && 2421 tplg->req_index != SND_SOC_TPLG_INDEX_ALL) 2422 return 0; 2423 2424 tplg->index = hdr->index; 2425 2426 switch (hdr->type) { 2427 case SND_SOC_TPLG_TYPE_MIXER: 2428 case SND_SOC_TPLG_TYPE_ENUM: 2429 case SND_SOC_TPLG_TYPE_BYTES: 2430 return soc_tplg_kcontrol_elems_load(tplg, hdr); 2431 case SND_SOC_TPLG_TYPE_DAPM_GRAPH: 2432 return soc_tplg_dapm_graph_elems_load(tplg, hdr); 2433 case SND_SOC_TPLG_TYPE_DAPM_WIDGET: 2434 return soc_tplg_dapm_widget_elems_load(tplg, hdr); 2435 case SND_SOC_TPLG_TYPE_PCM: 2436 return soc_tplg_pcm_elems_load(tplg, hdr); 2437 case SND_SOC_TPLG_TYPE_DAI: 2438 return soc_tplg_dai_elems_load(tplg, hdr); 2439 case SND_SOC_TPLG_TYPE_DAI_LINK: 2440 case SND_SOC_TPLG_TYPE_BACKEND_LINK: 2441 /* physical link configurations */ 2442 return soc_tplg_link_elems_load(tplg, hdr); 2443 case SND_SOC_TPLG_TYPE_MANIFEST: 2444 return soc_tplg_manifest_load(tplg, hdr); 2445 default: 2446 /* bespoke vendor data object */ 2447 return soc_tplg_vendor_load(tplg, hdr); 2448 } 2449 2450 return 0; 2451 } 2452 2453 /* process the topology file headers */ 2454 static int soc_tplg_process_headers(struct soc_tplg *tplg) 2455 { 2456 struct snd_soc_tplg_hdr *hdr; 2457 int ret; 2458 2459 tplg->pass = SOC_TPLG_PASS_START; 2460 2461 /* process the header types from start to end */ 2462 while (tplg->pass <= SOC_TPLG_PASS_END) { 2463 2464 tplg->hdr_pos = tplg->fw->data; 2465 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2466 2467 while (!soc_tplg_is_eof(tplg)) { 2468 2469 /* make sure header is valid before loading */ 2470 ret = soc_valid_header(tplg, hdr); 2471 if (ret < 0) 2472 return ret; 2473 else if (ret == 0) 2474 break; 2475 2476 /* load the header object */ 2477 ret = soc_tplg_load_header(tplg, hdr); 2478 if (ret < 0) 2479 return ret; 2480 2481 /* goto next header */ 2482 tplg->hdr_pos += hdr->payload_size + 2483 sizeof(struct snd_soc_tplg_hdr); 2484 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2485 } 2486 2487 /* next data type pass */ 2488 tplg->pass++; 2489 } 2490 2491 /* signal DAPM we are complete */ 2492 ret = soc_tplg_dapm_complete(tplg); 2493 if (ret < 0) 2494 dev_err(tplg->dev, 2495 "ASoC: failed to initialise DAPM from Firmware\n"); 2496 2497 return ret; 2498 } 2499 2500 static int soc_tplg_load(struct soc_tplg *tplg) 2501 { 2502 int ret; 2503 2504 ret = soc_tplg_process_headers(tplg); 2505 if (ret == 0) 2506 soc_tplg_complete(tplg); 2507 2508 return ret; 2509 } 2510 2511 /* load audio component topology from "firmware" file */ 2512 int snd_soc_tplg_component_load(struct snd_soc_component *comp, 2513 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id) 2514 { 2515 struct soc_tplg tplg; 2516 2517 /* setup parsing context */ 2518 memset(&tplg, 0, sizeof(tplg)); 2519 tplg.fw = fw; 2520 tplg.dev = comp->dev; 2521 tplg.comp = comp; 2522 tplg.ops = ops; 2523 tplg.req_index = id; 2524 tplg.io_ops = ops->io_ops; 2525 tplg.io_ops_count = ops->io_ops_count; 2526 tplg.bytes_ext_ops = ops->bytes_ext_ops; 2527 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; 2528 2529 return soc_tplg_load(&tplg); 2530 } 2531 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load); 2532 2533 /* remove this dynamic widget */ 2534 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w) 2535 { 2536 /* make sure we are a widget */ 2537 if (w->dobj.type != SND_SOC_DOBJ_WIDGET) 2538 return; 2539 2540 remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET); 2541 } 2542 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove); 2543 2544 /* remove all dynamic widgets from this DAPM context */ 2545 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm, 2546 u32 index) 2547 { 2548 struct snd_soc_dapm_widget *w, *next_w; 2549 2550 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) { 2551 2552 /* make sure we are a widget with correct context */ 2553 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm) 2554 continue; 2555 2556 /* match ID */ 2557 if (w->dobj.index != index && 2558 w->dobj.index != SND_SOC_TPLG_INDEX_ALL) 2559 continue; 2560 /* check and free and dynamic widget kcontrols */ 2561 snd_soc_tplg_widget_remove(w); 2562 snd_soc_dapm_free_widget(w); 2563 } 2564 snd_soc_dapm_reset_cache(dapm); 2565 } 2566 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all); 2567 2568 /* remove dynamic controls from the component driver */ 2569 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index) 2570 { 2571 struct snd_soc_dobj *dobj, *next_dobj; 2572 int pass = SOC_TPLG_PASS_END; 2573 2574 /* process the header types from end to start */ 2575 while (pass >= SOC_TPLG_PASS_START) { 2576 2577 /* remove mixer controls */ 2578 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list, 2579 list) { 2580 2581 /* match index */ 2582 if (dobj->index != index && 2583 index != SND_SOC_TPLG_INDEX_ALL) 2584 continue; 2585 2586 switch (dobj->type) { 2587 case SND_SOC_DOBJ_MIXER: 2588 remove_mixer(comp, dobj, pass); 2589 break; 2590 case SND_SOC_DOBJ_ENUM: 2591 remove_enum(comp, dobj, pass); 2592 break; 2593 case SND_SOC_DOBJ_BYTES: 2594 remove_bytes(comp, dobj, pass); 2595 break; 2596 case SND_SOC_DOBJ_WIDGET: 2597 remove_widget(comp, dobj, pass); 2598 break; 2599 case SND_SOC_DOBJ_PCM: 2600 remove_dai(comp, dobj, pass); 2601 break; 2602 case SND_SOC_DOBJ_DAI_LINK: 2603 remove_link(comp, dobj, pass); 2604 break; 2605 default: 2606 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n", 2607 dobj->type); 2608 break; 2609 } 2610 } 2611 pass--; 2612 } 2613 2614 /* let caller know if FW can be freed when no objects are left */ 2615 return !list_empty(&comp->dobj_list); 2616 } 2617 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove); 2618