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