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->ignore_pmdown_time = 1; 1759 link->dpcm_playback = le32_to_cpu(pcm->playback); 1760 link->dpcm_capture = le32_to_cpu(pcm->capture); 1761 if (pcm->flag_mask) 1762 set_link_flags(link, 1763 le32_to_cpu(pcm->flag_mask), 1764 le32_to_cpu(pcm->flags)); 1765 1766 /* pass control to component driver for optional further init */ 1767 ret = soc_tplg_dai_link_load(tplg, link, NULL); 1768 if (ret < 0) { 1769 dev_err(tplg->dev, "ASoC: FE link loading failed\n"); 1770 goto err; 1771 } 1772 1773 ret = snd_soc_add_pcm_runtime(tplg->comp->card, link); 1774 if (ret < 0) { 1775 dev_err(tplg->dev, "ASoC: adding FE link failed\n"); 1776 goto err; 1777 } 1778 1779 list_add(&link->dobj.list, &tplg->comp->dobj_list); 1780 1781 return 0; 1782 err: 1783 return ret; 1784 } 1785 1786 /* create a FE DAI and DAI link from the PCM object */ 1787 static int soc_tplg_pcm_create(struct soc_tplg *tplg, 1788 struct snd_soc_tplg_pcm *pcm) 1789 { 1790 int ret; 1791 1792 ret = soc_tplg_dai_create(tplg, pcm); 1793 if (ret < 0) 1794 return ret; 1795 1796 return soc_tplg_fe_link_create(tplg, pcm); 1797 } 1798 1799 /* copy stream caps from the old version 4 of source */ 1800 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps *dest, 1801 struct snd_soc_tplg_stream_caps_v4 *src) 1802 { 1803 dest->size = cpu_to_le32(sizeof(*dest)); 1804 memcpy(dest->name, src->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1805 dest->formats = src->formats; 1806 dest->rates = src->rates; 1807 dest->rate_min = src->rate_min; 1808 dest->rate_max = src->rate_max; 1809 dest->channels_min = src->channels_min; 1810 dest->channels_max = src->channels_max; 1811 dest->periods_min = src->periods_min; 1812 dest->periods_max = src->periods_max; 1813 dest->period_size_min = src->period_size_min; 1814 dest->period_size_max = src->period_size_max; 1815 dest->buffer_size_min = src->buffer_size_min; 1816 dest->buffer_size_max = src->buffer_size_max; 1817 } 1818 1819 /** 1820 * pcm_new_ver - Create the new version of PCM from the old version. 1821 * @tplg: topology context 1822 * @src: older version of pcm as a source 1823 * @pcm: latest version of pcm created from the source 1824 * 1825 * Support from version 4. User should free the returned pcm manually. 1826 */ 1827 static int pcm_new_ver(struct soc_tplg *tplg, 1828 struct snd_soc_tplg_pcm *src, 1829 struct snd_soc_tplg_pcm **pcm) 1830 { 1831 struct snd_soc_tplg_pcm *dest; 1832 struct snd_soc_tplg_pcm_v4 *src_v4; 1833 int i; 1834 1835 *pcm = NULL; 1836 1837 if (le32_to_cpu(src->size) != sizeof(*src_v4)) { 1838 dev_err(tplg->dev, "ASoC: invalid PCM size\n"); 1839 return -EINVAL; 1840 } 1841 1842 dev_warn(tplg->dev, "ASoC: old version of PCM\n"); 1843 src_v4 = (struct snd_soc_tplg_pcm_v4 *)src; 1844 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 1845 if (!dest) 1846 return -ENOMEM; 1847 1848 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 1849 memcpy(dest->pcm_name, src_v4->pcm_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1850 memcpy(dest->dai_name, src_v4->dai_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1851 dest->pcm_id = src_v4->pcm_id; 1852 dest->dai_id = src_v4->dai_id; 1853 dest->playback = src_v4->playback; 1854 dest->capture = src_v4->capture; 1855 dest->compress = src_v4->compress; 1856 dest->num_streams = src_v4->num_streams; 1857 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 1858 memcpy(&dest->stream[i], &src_v4->stream[i], 1859 sizeof(struct snd_soc_tplg_stream)); 1860 1861 for (i = 0; i < 2; i++) 1862 stream_caps_new_ver(&dest->caps[i], &src_v4->caps[i]); 1863 1864 *pcm = dest; 1865 return 0; 1866 } 1867 1868 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, 1869 struct snd_soc_tplg_hdr *hdr) 1870 { 1871 struct snd_soc_tplg_pcm *pcm, *_pcm; 1872 int count; 1873 int size; 1874 int i; 1875 bool abi_match; 1876 int ret; 1877 1878 count = le32_to_cpu(hdr->count); 1879 1880 /* check the element size and count */ 1881 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1882 size = le32_to_cpu(pcm->size); 1883 if (size > sizeof(struct snd_soc_tplg_pcm) 1884 || size < sizeof(struct snd_soc_tplg_pcm_v4)) { 1885 dev_err(tplg->dev, "ASoC: invalid size %d for PCM elems\n", 1886 size); 1887 return -EINVAL; 1888 } 1889 1890 if (soc_tplg_check_elem_count(tplg, 1891 size, count, 1892 le32_to_cpu(hdr->payload_size), 1893 "PCM DAI")) 1894 return -EINVAL; 1895 1896 for (i = 0; i < count; i++) { 1897 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1898 size = le32_to_cpu(pcm->size); 1899 1900 /* check ABI version by size, create a new version of pcm 1901 * if abi not match. 1902 */ 1903 if (size == sizeof(*pcm)) { 1904 abi_match = true; 1905 _pcm = pcm; 1906 } else { 1907 abi_match = false; 1908 ret = pcm_new_ver(tplg, pcm, &_pcm); 1909 if (ret < 0) 1910 return ret; 1911 } 1912 1913 /* create the FE DAIs and DAI links */ 1914 ret = soc_tplg_pcm_create(tplg, _pcm); 1915 if (ret < 0) { 1916 if (!abi_match) 1917 kfree(_pcm); 1918 return ret; 1919 } 1920 1921 /* offset by version-specific struct size and 1922 * real priv data size 1923 */ 1924 tplg->pos += size + le32_to_cpu(_pcm->priv.size); 1925 1926 if (!abi_match) 1927 kfree(_pcm); /* free the duplicated one */ 1928 } 1929 1930 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count); 1931 1932 return 0; 1933 } 1934 1935 /** 1936 * set_link_hw_format - Set the HW audio format of the physical DAI link. 1937 * @link: &snd_soc_dai_link which should be updated 1938 * @cfg: physical link configs. 1939 * 1940 * Topology context contains a list of supported HW formats (configs) and 1941 * a default format ID for the physical link. This function will use this 1942 * default ID to choose the HW format to set the link's DAI format for init. 1943 */ 1944 static void set_link_hw_format(struct snd_soc_dai_link *link, 1945 struct snd_soc_tplg_link_config *cfg) 1946 { 1947 struct snd_soc_tplg_hw_config *hw_config; 1948 unsigned char bclk_provider, fsync_provider; 1949 unsigned char invert_bclk, invert_fsync; 1950 int i; 1951 1952 for (i = 0; i < le32_to_cpu(cfg->num_hw_configs); i++) { 1953 hw_config = &cfg->hw_config[i]; 1954 if (hw_config->id != cfg->default_hw_config_id) 1955 continue; 1956 1957 link->dai_fmt = le32_to_cpu(hw_config->fmt) & 1958 SND_SOC_DAIFMT_FORMAT_MASK; 1959 1960 /* clock gating */ 1961 switch (hw_config->clock_gated) { 1962 case SND_SOC_TPLG_DAI_CLK_GATE_GATED: 1963 link->dai_fmt |= SND_SOC_DAIFMT_GATED; 1964 break; 1965 1966 case SND_SOC_TPLG_DAI_CLK_GATE_CONT: 1967 link->dai_fmt |= SND_SOC_DAIFMT_CONT; 1968 break; 1969 1970 default: 1971 /* ignore the value */ 1972 break; 1973 } 1974 1975 /* clock signal polarity */ 1976 invert_bclk = hw_config->invert_bclk; 1977 invert_fsync = hw_config->invert_fsync; 1978 if (!invert_bclk && !invert_fsync) 1979 link->dai_fmt |= SND_SOC_DAIFMT_NB_NF; 1980 else if (!invert_bclk && invert_fsync) 1981 link->dai_fmt |= SND_SOC_DAIFMT_NB_IF; 1982 else if (invert_bclk && !invert_fsync) 1983 link->dai_fmt |= SND_SOC_DAIFMT_IB_NF; 1984 else 1985 link->dai_fmt |= SND_SOC_DAIFMT_IB_IF; 1986 1987 /* clock masters */ 1988 bclk_provider = (hw_config->bclk_provider == 1989 SND_SOC_TPLG_BCLK_CP); 1990 fsync_provider = (hw_config->fsync_provider == 1991 SND_SOC_TPLG_FSYNC_CP); 1992 if (bclk_provider && fsync_provider) 1993 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFP; 1994 else if (!bclk_provider && fsync_provider) 1995 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFP; 1996 else if (bclk_provider && !fsync_provider) 1997 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFC; 1998 else 1999 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFC; 2000 } 2001 } 2002 2003 /** 2004 * link_new_ver - Create a new physical link config from the old 2005 * version of source. 2006 * @tplg: topology context 2007 * @src: old version of phyical link config as a source 2008 * @link: latest version of physical link config created from the source 2009 * 2010 * Support from version 4. User need free the returned link config manually. 2011 */ 2012 static int link_new_ver(struct soc_tplg *tplg, 2013 struct snd_soc_tplg_link_config *src, 2014 struct snd_soc_tplg_link_config **link) 2015 { 2016 struct snd_soc_tplg_link_config *dest; 2017 struct snd_soc_tplg_link_config_v4 *src_v4; 2018 int i; 2019 2020 *link = NULL; 2021 2022 if (le32_to_cpu(src->size) != 2023 sizeof(struct snd_soc_tplg_link_config_v4)) { 2024 dev_err(tplg->dev, "ASoC: invalid physical link config size\n"); 2025 return -EINVAL; 2026 } 2027 2028 dev_warn(tplg->dev, "ASoC: old version of physical link config\n"); 2029 2030 src_v4 = (struct snd_soc_tplg_link_config_v4 *)src; 2031 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 2032 if (!dest) 2033 return -ENOMEM; 2034 2035 dest->size = cpu_to_le32(sizeof(*dest)); 2036 dest->id = src_v4->id; 2037 dest->num_streams = src_v4->num_streams; 2038 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 2039 memcpy(&dest->stream[i], &src_v4->stream[i], 2040 sizeof(struct snd_soc_tplg_stream)); 2041 2042 *link = dest; 2043 return 0; 2044 } 2045 2046 /** 2047 * snd_soc_find_dai_link - Find a DAI link 2048 * 2049 * @card: soc card 2050 * @id: DAI link ID to match 2051 * @name: DAI link name to match, optional 2052 * @stream_name: DAI link stream name to match, optional 2053 * 2054 * This function will search all existing DAI links of the soc card to 2055 * find the link of the same ID. Since DAI links may not have their 2056 * unique ID, so name and stream name should also match if being 2057 * specified. 2058 * 2059 * Return: pointer of DAI link, or NULL if not found. 2060 */ 2061 static struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card, 2062 int id, const char *name, 2063 const char *stream_name) 2064 { 2065 struct snd_soc_pcm_runtime *rtd; 2066 2067 for_each_card_rtds(card, rtd) { 2068 struct snd_soc_dai_link *link = rtd->dai_link; 2069 2070 if (link->id != id) 2071 continue; 2072 2073 if (name && (!link->name || strcmp(name, link->name))) 2074 continue; 2075 2076 if (stream_name && (!link->stream_name 2077 || strcmp(stream_name, link->stream_name))) 2078 continue; 2079 2080 return link; 2081 } 2082 2083 return NULL; 2084 } 2085 2086 /* Find and configure an existing physical DAI link */ 2087 static int soc_tplg_link_config(struct soc_tplg *tplg, 2088 struct snd_soc_tplg_link_config *cfg) 2089 { 2090 struct snd_soc_dai_link *link; 2091 const char *name, *stream_name; 2092 size_t len; 2093 int ret; 2094 2095 len = strnlen(cfg->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2096 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2097 return -EINVAL; 2098 else if (len) 2099 name = cfg->name; 2100 else 2101 name = NULL; 2102 2103 len = strnlen(cfg->stream_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2104 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2105 return -EINVAL; 2106 else if (len) 2107 stream_name = cfg->stream_name; 2108 else 2109 stream_name = NULL; 2110 2111 link = snd_soc_find_dai_link(tplg->comp->card, le32_to_cpu(cfg->id), 2112 name, stream_name); 2113 if (!link) { 2114 dev_err(tplg->dev, "ASoC: physical link %s (id %d) not exist\n", 2115 name, cfg->id); 2116 return -EINVAL; 2117 } 2118 2119 /* hw format */ 2120 if (cfg->num_hw_configs) 2121 set_link_hw_format(link, cfg); 2122 2123 /* flags */ 2124 if (cfg->flag_mask) 2125 set_link_flags(link, 2126 le32_to_cpu(cfg->flag_mask), 2127 le32_to_cpu(cfg->flags)); 2128 2129 /* pass control to component driver for optional further init */ 2130 ret = soc_tplg_dai_link_load(tplg, link, cfg); 2131 if (ret < 0) { 2132 dev_err(tplg->dev, "ASoC: physical link loading failed\n"); 2133 return ret; 2134 } 2135 2136 /* for unloading it in snd_soc_tplg_component_remove */ 2137 link->dobj.index = tplg->index; 2138 link->dobj.ops = tplg->ops; 2139 link->dobj.type = SND_SOC_DOBJ_BACKEND_LINK; 2140 list_add(&link->dobj.list, &tplg->comp->dobj_list); 2141 2142 return 0; 2143 } 2144 2145 2146 /* Load physical link config elements from the topology context */ 2147 static int soc_tplg_link_elems_load(struct soc_tplg *tplg, 2148 struct snd_soc_tplg_hdr *hdr) 2149 { 2150 struct snd_soc_tplg_link_config *link, *_link; 2151 int count; 2152 int size; 2153 int i, ret; 2154 bool abi_match; 2155 2156 count = le32_to_cpu(hdr->count); 2157 2158 /* check the element size and count */ 2159 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2160 size = le32_to_cpu(link->size); 2161 if (size > sizeof(struct snd_soc_tplg_link_config) 2162 || size < sizeof(struct snd_soc_tplg_link_config_v4)) { 2163 dev_err(tplg->dev, "ASoC: invalid size %d for physical link elems\n", 2164 size); 2165 return -EINVAL; 2166 } 2167 2168 if (soc_tplg_check_elem_count(tplg, size, count, 2169 le32_to_cpu(hdr->payload_size), 2170 "physical link config")) 2171 return -EINVAL; 2172 2173 /* config physical DAI links */ 2174 for (i = 0; i < count; i++) { 2175 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2176 size = le32_to_cpu(link->size); 2177 if (size == sizeof(*link)) { 2178 abi_match = true; 2179 _link = link; 2180 } else { 2181 abi_match = false; 2182 ret = link_new_ver(tplg, link, &_link); 2183 if (ret < 0) 2184 return ret; 2185 } 2186 2187 ret = soc_tplg_link_config(tplg, _link); 2188 if (ret < 0) { 2189 if (!abi_match) 2190 kfree(_link); 2191 return ret; 2192 } 2193 2194 /* offset by version-specific struct size and 2195 * real priv data size 2196 */ 2197 tplg->pos += size + le32_to_cpu(_link->priv.size); 2198 2199 if (!abi_match) 2200 kfree(_link); /* free the duplicated one */ 2201 } 2202 2203 return 0; 2204 } 2205 2206 /** 2207 * soc_tplg_dai_config - Find and configure an existing physical DAI. 2208 * @tplg: topology context 2209 * @d: physical DAI configs. 2210 * 2211 * The physical dai should already be registered by the platform driver. 2212 * The platform driver should specify the DAI name and ID for matching. 2213 */ 2214 static int soc_tplg_dai_config(struct soc_tplg *tplg, 2215 struct snd_soc_tplg_dai *d) 2216 { 2217 struct snd_soc_dai_link_component dai_component; 2218 struct snd_soc_dai *dai; 2219 struct snd_soc_dai_driver *dai_drv; 2220 struct snd_soc_pcm_stream *stream; 2221 struct snd_soc_tplg_stream_caps *caps; 2222 int ret; 2223 2224 memset(&dai_component, 0, sizeof(dai_component)); 2225 2226 dai_component.dai_name = d->dai_name; 2227 dai = snd_soc_find_dai(&dai_component); 2228 if (!dai) { 2229 dev_err(tplg->dev, "ASoC: physical DAI %s not registered\n", 2230 d->dai_name); 2231 return -EINVAL; 2232 } 2233 2234 if (le32_to_cpu(d->dai_id) != dai->id) { 2235 dev_err(tplg->dev, "ASoC: physical DAI %s id mismatch\n", 2236 d->dai_name); 2237 return -EINVAL; 2238 } 2239 2240 dai_drv = dai->driver; 2241 if (!dai_drv) 2242 return -EINVAL; 2243 2244 if (d->playback) { 2245 stream = &dai_drv->playback; 2246 caps = &d->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 2247 ret = set_stream_info(tplg, stream, caps); 2248 if (ret < 0) 2249 goto err; 2250 } 2251 2252 if (d->capture) { 2253 stream = &dai_drv->capture; 2254 caps = &d->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 2255 ret = set_stream_info(tplg, stream, caps); 2256 if (ret < 0) 2257 goto err; 2258 } 2259 2260 if (d->flag_mask) 2261 set_dai_flags(dai_drv, 2262 le32_to_cpu(d->flag_mask), 2263 le32_to_cpu(d->flags)); 2264 2265 /* pass control to component driver for optional further init */ 2266 ret = soc_tplg_dai_load(tplg, dai_drv, NULL, dai); 2267 if (ret < 0) { 2268 dev_err(tplg->dev, "ASoC: DAI loading failed\n"); 2269 goto err; 2270 } 2271 2272 return 0; 2273 2274 err: 2275 return ret; 2276 } 2277 2278 /* load physical DAI elements */ 2279 static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, 2280 struct snd_soc_tplg_hdr *hdr) 2281 { 2282 int count; 2283 int i; 2284 2285 count = le32_to_cpu(hdr->count); 2286 2287 /* config the existing BE DAIs */ 2288 for (i = 0; i < count; i++) { 2289 struct snd_soc_tplg_dai *dai = (struct snd_soc_tplg_dai *)tplg->pos; 2290 int ret; 2291 2292 if (le32_to_cpu(dai->size) != sizeof(*dai)) { 2293 dev_err(tplg->dev, "ASoC: invalid physical DAI size\n"); 2294 return -EINVAL; 2295 } 2296 2297 ret = soc_tplg_dai_config(tplg, dai); 2298 if (ret < 0) { 2299 dev_err(tplg->dev, "ASoC: failed to configure DAI\n"); 2300 return ret; 2301 } 2302 2303 tplg->pos += (sizeof(*dai) + le32_to_cpu(dai->priv.size)); 2304 } 2305 2306 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count); 2307 return 0; 2308 } 2309 2310 /** 2311 * manifest_new_ver - Create a new version of manifest from the old version 2312 * of source. 2313 * @tplg: topology context 2314 * @src: old version of manifest as a source 2315 * @manifest: latest version of manifest created from the source 2316 * 2317 * Support from version 4. Users need free the returned manifest manually. 2318 */ 2319 static int manifest_new_ver(struct soc_tplg *tplg, 2320 struct snd_soc_tplg_manifest *src, 2321 struct snd_soc_tplg_manifest **manifest) 2322 { 2323 struct snd_soc_tplg_manifest *dest; 2324 struct snd_soc_tplg_manifest_v4 *src_v4; 2325 int size; 2326 2327 *manifest = NULL; 2328 2329 size = le32_to_cpu(src->size); 2330 if (size != sizeof(*src_v4)) { 2331 dev_warn(tplg->dev, "ASoC: invalid manifest size %d\n", 2332 size); 2333 if (size) 2334 return -EINVAL; 2335 src->size = cpu_to_le32(sizeof(*src_v4)); 2336 } 2337 2338 dev_warn(tplg->dev, "ASoC: old version of manifest\n"); 2339 2340 src_v4 = (struct snd_soc_tplg_manifest_v4 *)src; 2341 dest = kzalloc(sizeof(*dest) + le32_to_cpu(src_v4->priv.size), 2342 GFP_KERNEL); 2343 if (!dest) 2344 return -ENOMEM; 2345 2346 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 2347 dest->control_elems = src_v4->control_elems; 2348 dest->widget_elems = src_v4->widget_elems; 2349 dest->graph_elems = src_v4->graph_elems; 2350 dest->pcm_elems = src_v4->pcm_elems; 2351 dest->dai_link_elems = src_v4->dai_link_elems; 2352 dest->priv.size = src_v4->priv.size; 2353 if (dest->priv.size) 2354 memcpy(dest->priv.data, src_v4->priv.data, 2355 le32_to_cpu(src_v4->priv.size)); 2356 2357 *manifest = dest; 2358 return 0; 2359 } 2360 2361 static int soc_tplg_manifest_load(struct soc_tplg *tplg, 2362 struct snd_soc_tplg_hdr *hdr) 2363 { 2364 struct snd_soc_tplg_manifest *manifest, *_manifest; 2365 bool abi_match; 2366 int ret = 0; 2367 2368 manifest = (struct snd_soc_tplg_manifest *)tplg->pos; 2369 2370 /* check ABI version by size, create a new manifest if abi not match */ 2371 if (le32_to_cpu(manifest->size) == sizeof(*manifest)) { 2372 abi_match = true; 2373 _manifest = manifest; 2374 } else { 2375 abi_match = false; 2376 2377 ret = manifest_new_ver(tplg, manifest, &_manifest); 2378 if (ret < 0) 2379 return ret; 2380 } 2381 2382 /* pass control to component driver for optional further init */ 2383 if (tplg->ops && tplg->ops->manifest) 2384 ret = tplg->ops->manifest(tplg->comp, tplg->index, _manifest); 2385 2386 if (!abi_match) /* free the duplicated one */ 2387 kfree(_manifest); 2388 2389 return ret; 2390 } 2391 2392 /* validate header magic, size and type */ 2393 static int soc_valid_header(struct soc_tplg *tplg, 2394 struct snd_soc_tplg_hdr *hdr) 2395 { 2396 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size) 2397 return 0; 2398 2399 if (le32_to_cpu(hdr->size) != sizeof(*hdr)) { 2400 dev_err(tplg->dev, 2401 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n", 2402 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2403 tplg->fw->size); 2404 return -EINVAL; 2405 } 2406 2407 if (soc_tplg_get_hdr_offset(tplg) + hdr->payload_size >= tplg->fw->size) { 2408 dev_err(tplg->dev, 2409 "ASoC: invalid header of type %d at offset %ld payload_size %d\n", 2410 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2411 hdr->payload_size); 2412 return -EINVAL; 2413 } 2414 2415 /* big endian firmware objects not supported atm */ 2416 if (le32_to_cpu(hdr->magic) == SOC_TPLG_MAGIC_BIG_ENDIAN) { 2417 dev_err(tplg->dev, 2418 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", 2419 tplg->pass, hdr->magic, 2420 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2421 return -EINVAL; 2422 } 2423 2424 if (le32_to_cpu(hdr->magic) != SND_SOC_TPLG_MAGIC) { 2425 dev_err(tplg->dev, 2426 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n", 2427 tplg->pass, hdr->magic, 2428 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2429 return -EINVAL; 2430 } 2431 2432 /* Support ABI from version 4 */ 2433 if (le32_to_cpu(hdr->abi) > SND_SOC_TPLG_ABI_VERSION || 2434 le32_to_cpu(hdr->abi) < SND_SOC_TPLG_ABI_VERSION_MIN) { 2435 dev_err(tplg->dev, 2436 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n", 2437 tplg->pass, hdr->abi, 2438 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg), 2439 tplg->fw->size); 2440 return -EINVAL; 2441 } 2442 2443 if (hdr->payload_size == 0) { 2444 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n", 2445 soc_tplg_get_hdr_offset(tplg)); 2446 return -EINVAL; 2447 } 2448 2449 return 1; 2450 } 2451 2452 /* check header type and call appropriate handler */ 2453 static int soc_tplg_load_header(struct soc_tplg *tplg, 2454 struct snd_soc_tplg_hdr *hdr) 2455 { 2456 int (*elem_load)(struct soc_tplg *tplg, 2457 struct snd_soc_tplg_hdr *hdr); 2458 unsigned int hdr_pass; 2459 2460 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr); 2461 2462 tplg->index = le32_to_cpu(hdr->index); 2463 2464 switch (le32_to_cpu(hdr->type)) { 2465 case SND_SOC_TPLG_TYPE_MIXER: 2466 case SND_SOC_TPLG_TYPE_ENUM: 2467 case SND_SOC_TPLG_TYPE_BYTES: 2468 hdr_pass = SOC_TPLG_PASS_CONTROL; 2469 elem_load = soc_tplg_kcontrol_elems_load; 2470 break; 2471 case SND_SOC_TPLG_TYPE_DAPM_GRAPH: 2472 hdr_pass = SOC_TPLG_PASS_GRAPH; 2473 elem_load = soc_tplg_dapm_graph_elems_load; 2474 break; 2475 case SND_SOC_TPLG_TYPE_DAPM_WIDGET: 2476 hdr_pass = SOC_TPLG_PASS_WIDGET; 2477 elem_load = soc_tplg_dapm_widget_elems_load; 2478 break; 2479 case SND_SOC_TPLG_TYPE_PCM: 2480 hdr_pass = SOC_TPLG_PASS_PCM_DAI; 2481 elem_load = soc_tplg_pcm_elems_load; 2482 break; 2483 case SND_SOC_TPLG_TYPE_DAI: 2484 hdr_pass = SOC_TPLG_PASS_BE_DAI; 2485 elem_load = soc_tplg_dai_elems_load; 2486 break; 2487 case SND_SOC_TPLG_TYPE_DAI_LINK: 2488 case SND_SOC_TPLG_TYPE_BACKEND_LINK: 2489 /* physical link configurations */ 2490 hdr_pass = SOC_TPLG_PASS_LINK; 2491 elem_load = soc_tplg_link_elems_load; 2492 break; 2493 case SND_SOC_TPLG_TYPE_MANIFEST: 2494 hdr_pass = SOC_TPLG_PASS_MANIFEST; 2495 elem_load = soc_tplg_manifest_load; 2496 break; 2497 default: 2498 /* bespoke vendor data object */ 2499 hdr_pass = SOC_TPLG_PASS_VENDOR; 2500 elem_load = soc_tplg_vendor_load; 2501 break; 2502 } 2503 2504 if (tplg->pass == hdr_pass) { 2505 dev_dbg(tplg->dev, 2506 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n", 2507 hdr->payload_size, hdr->type, hdr->version, 2508 hdr->vendor_type, tplg->pass); 2509 return elem_load(tplg, hdr); 2510 } 2511 2512 return 0; 2513 } 2514 2515 /* process the topology file headers */ 2516 static int soc_tplg_process_headers(struct soc_tplg *tplg) 2517 { 2518 int ret; 2519 2520 /* process the header types from start to end */ 2521 for (tplg->pass = SOC_TPLG_PASS_START; tplg->pass <= SOC_TPLG_PASS_END; tplg->pass++) { 2522 struct snd_soc_tplg_hdr *hdr; 2523 2524 tplg->hdr_pos = tplg->fw->data; 2525 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2526 2527 while (!soc_tplg_is_eof(tplg)) { 2528 2529 /* make sure header is valid before loading */ 2530 ret = soc_valid_header(tplg, hdr); 2531 if (ret < 0) { 2532 dev_err(tplg->dev, 2533 "ASoC: topology: invalid header: %d\n", ret); 2534 return ret; 2535 } else if (ret == 0) { 2536 break; 2537 } 2538 2539 /* load the header object */ 2540 ret = soc_tplg_load_header(tplg, hdr); 2541 if (ret < 0) { 2542 dev_err(tplg->dev, 2543 "ASoC: topology: could not load header: %d\n", ret); 2544 return ret; 2545 } 2546 2547 /* goto next header */ 2548 tplg->hdr_pos += le32_to_cpu(hdr->payload_size) + 2549 sizeof(struct snd_soc_tplg_hdr); 2550 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2551 } 2552 2553 } 2554 2555 /* signal DAPM we are complete */ 2556 ret = soc_tplg_dapm_complete(tplg); 2557 if (ret < 0) 2558 dev_err(tplg->dev, 2559 "ASoC: failed to initialise DAPM from Firmware\n"); 2560 2561 return ret; 2562 } 2563 2564 static int soc_tplg_load(struct soc_tplg *tplg) 2565 { 2566 int ret; 2567 2568 ret = soc_tplg_process_headers(tplg); 2569 if (ret == 0) 2570 return soc_tplg_complete(tplg); 2571 2572 return ret; 2573 } 2574 2575 /* load audio component topology from "firmware" file */ 2576 int snd_soc_tplg_component_load(struct snd_soc_component *comp, 2577 struct snd_soc_tplg_ops *ops, const struct firmware *fw) 2578 { 2579 struct soc_tplg tplg; 2580 int ret; 2581 2582 /* 2583 * check if we have sane parameters: 2584 * comp - needs to exist to keep and reference data while parsing 2585 * comp->card - used for setting card related parameters 2586 * comp->card->dev - used for resource management and prints 2587 * fw - we need it, as it is the very thing we parse 2588 */ 2589 if (!comp || !comp->card || !comp->card->dev || !fw) 2590 return -EINVAL; 2591 2592 /* setup parsing context */ 2593 memset(&tplg, 0, sizeof(tplg)); 2594 tplg.fw = fw; 2595 tplg.dev = comp->card->dev; 2596 tplg.comp = comp; 2597 if (ops) { 2598 tplg.ops = ops; 2599 tplg.io_ops = ops->io_ops; 2600 tplg.io_ops_count = ops->io_ops_count; 2601 tplg.bytes_ext_ops = ops->bytes_ext_ops; 2602 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; 2603 } 2604 2605 ret = soc_tplg_load(&tplg); 2606 /* free the created components if fail to load topology */ 2607 if (ret) 2608 snd_soc_tplg_component_remove(comp); 2609 2610 return ret; 2611 } 2612 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load); 2613 2614 /* remove dynamic controls from the component driver */ 2615 int snd_soc_tplg_component_remove(struct snd_soc_component *comp) 2616 { 2617 struct snd_card *card = comp->card->snd_card; 2618 struct snd_soc_dobj *dobj, *next_dobj; 2619 int pass; 2620 2621 /* process the header types from end to start */ 2622 for (pass = SOC_TPLG_PASS_END; pass >= SOC_TPLG_PASS_START; pass--) { 2623 2624 /* remove mixer controls */ 2625 down_write(&card->controls_rwsem); 2626 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list, 2627 list) { 2628 2629 switch (dobj->type) { 2630 case SND_SOC_DOBJ_MIXER: 2631 remove_mixer(comp, dobj, pass); 2632 break; 2633 case SND_SOC_DOBJ_ENUM: 2634 remove_enum(comp, dobj, pass); 2635 break; 2636 case SND_SOC_DOBJ_BYTES: 2637 remove_bytes(comp, dobj, pass); 2638 break; 2639 case SND_SOC_DOBJ_GRAPH: 2640 remove_route(comp, dobj, pass); 2641 break; 2642 case SND_SOC_DOBJ_WIDGET: 2643 remove_widget(comp, dobj, pass); 2644 break; 2645 case SND_SOC_DOBJ_PCM: 2646 remove_dai(comp, dobj, pass); 2647 break; 2648 case SND_SOC_DOBJ_DAI_LINK: 2649 remove_link(comp, dobj, pass); 2650 break; 2651 case SND_SOC_DOBJ_BACKEND_LINK: 2652 /* 2653 * call link_unload ops if extra 2654 * deinitialization is needed. 2655 */ 2656 remove_backend_link(comp, dobj, pass); 2657 break; 2658 default: 2659 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n", 2660 dobj->type); 2661 break; 2662 } 2663 } 2664 up_write(&card->controls_rwsem); 2665 } 2666 2667 /* let caller know if FW can be freed when no objects are left */ 2668 return !list_empty(&comp->dobj_list); 2669 } 2670 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove); 2671