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