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_MIXER 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 int 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 1; 113 return 0; 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 mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n", 241 name, hdr->ops.get, hdr->ops.put, hdr->ops.info, 242 soc_tplg_get_offset(tplg)); 243 } 244 245 /* pass vendor data to component driver for processing */ 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_MIXER) 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_MIXER) 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_MIXER) 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 (IS_ENABLED(CONFIG_SND_CTL_VALIDATION) && 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_init_kcontrol(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, unsigned int count, 680 size_t size) 681 { 682 struct snd_soc_tplg_bytes_control *be; 683 struct soc_bytes_ext *sbe; 684 struct snd_kcontrol_new kc; 685 int i; 686 int err = 0; 687 688 if (soc_tplg_check_elem_count(tplg, 689 sizeof(struct snd_soc_tplg_bytes_control), 690 count, size, "mixer bytes")) 691 return -EINVAL; 692 693 for (i = 0; i < count; i++) { 694 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 695 696 /* validate kcontrol */ 697 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 698 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 699 return -EINVAL; 700 701 sbe = devm_kzalloc(tplg->dev, sizeof(*sbe), GFP_KERNEL); 702 if (sbe == NULL) 703 return -ENOMEM; 704 705 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 706 le32_to_cpu(be->priv.size)); 707 708 dev_dbg(tplg->dev, 709 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 710 be->hdr.name, be->hdr.access); 711 712 memset(&kc, 0, sizeof(kc)); 713 kc.name = be->hdr.name; 714 kc.private_value = (long)sbe; 715 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 716 kc.access = le32_to_cpu(be->hdr.access); 717 718 sbe->max = le32_to_cpu(be->max); 719 sbe->dobj.type = SND_SOC_DOBJ_BYTES; 720 sbe->dobj.ops = tplg->ops; 721 INIT_LIST_HEAD(&sbe->dobj.list); 722 723 /* map io handlers */ 724 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg); 725 if (err) { 726 soc_control_err(tplg, &be->hdr, be->hdr.name); 727 break; 728 } 729 730 /* pass control to driver for optional further init */ 731 err = soc_tplg_init_kcontrol(tplg, &kc, 732 (struct snd_soc_tplg_ctl_hdr *)be); 733 if (err < 0) { 734 dev_err(tplg->dev, "ASoC: failed to init %s\n", 735 be->hdr.name); 736 break; 737 } 738 739 /* register control here */ 740 err = soc_tplg_add_kcontrol(tplg, &kc, 741 &sbe->dobj.control.kcontrol); 742 if (err < 0) { 743 dev_err(tplg->dev, "ASoC: failed to add %s\n", 744 be->hdr.name); 745 break; 746 } 747 748 list_add(&sbe->dobj.list, &tplg->comp->dobj_list); 749 } 750 return err; 751 752 } 753 754 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count, 755 size_t size) 756 { 757 struct snd_soc_tplg_mixer_control *mc; 758 struct soc_mixer_control *sm; 759 struct snd_kcontrol_new kc; 760 int i; 761 int err = 0; 762 763 if (soc_tplg_check_elem_count(tplg, 764 sizeof(struct snd_soc_tplg_mixer_control), 765 count, size, "mixers")) 766 return -EINVAL; 767 768 for (i = 0; i < count; i++) { 769 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 770 771 /* validate kcontrol */ 772 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 773 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 774 return -EINVAL; 775 776 sm = devm_kzalloc(tplg->dev, sizeof(*sm), GFP_KERNEL); 777 if (sm == NULL) 778 return -ENOMEM; 779 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) + 780 le32_to_cpu(mc->priv.size)); 781 782 dev_dbg(tplg->dev, 783 "ASoC: adding mixer kcontrol %s with access 0x%x\n", 784 mc->hdr.name, mc->hdr.access); 785 786 memset(&kc, 0, sizeof(kc)); 787 kc.name = mc->hdr.name; 788 kc.private_value = (long)sm; 789 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 790 kc.access = le32_to_cpu(mc->hdr.access); 791 792 /* we only support FL/FR channel mapping atm */ 793 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 794 SNDRV_CHMAP_FL); 795 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 796 SNDRV_CHMAP_FR); 797 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 798 SNDRV_CHMAP_FL); 799 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 800 SNDRV_CHMAP_FR); 801 802 sm->max = le32_to_cpu(mc->max); 803 sm->min = le32_to_cpu(mc->min); 804 sm->invert = le32_to_cpu(mc->invert); 805 sm->platform_max = le32_to_cpu(mc->platform_max); 806 sm->dobj.index = tplg->index; 807 sm->dobj.ops = tplg->ops; 808 sm->dobj.type = SND_SOC_DOBJ_MIXER; 809 INIT_LIST_HEAD(&sm->dobj.list); 810 811 /* map io handlers */ 812 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg); 813 if (err) { 814 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 815 break; 816 } 817 818 /* create any TLV data */ 819 err = soc_tplg_create_tlv(tplg, &kc, &mc->hdr); 820 if (err < 0) { 821 dev_err(tplg->dev, "ASoC: failed to create TLV %s\n", 822 mc->hdr.name); 823 break; 824 } 825 826 /* pass control to driver for optional further init */ 827 err = soc_tplg_init_kcontrol(tplg, &kc, 828 (struct snd_soc_tplg_ctl_hdr *) mc); 829 if (err < 0) { 830 dev_err(tplg->dev, "ASoC: failed to init %s\n", 831 mc->hdr.name); 832 break; 833 } 834 835 /* register control here */ 836 err = soc_tplg_add_kcontrol(tplg, &kc, 837 &sm->dobj.control.kcontrol); 838 if (err < 0) { 839 dev_err(tplg->dev, "ASoC: failed to add %s\n", 840 mc->hdr.name); 841 break; 842 } 843 844 list_add(&sm->dobj.list, &tplg->comp->dobj_list); 845 } 846 847 return err; 848 } 849 850 static int soc_tplg_denum_create_texts(struct soc_tplg *tplg, struct soc_enum *se, 851 struct snd_soc_tplg_enum_control *ec) 852 { 853 int i, ret; 854 855 if (le32_to_cpu(ec->items) > ARRAY_SIZE(ec->texts)) 856 return -EINVAL; 857 858 se->dobj.control.dtexts = 859 devm_kcalloc(tplg->dev, le32_to_cpu(ec->items), sizeof(char *), GFP_KERNEL); 860 if (se->dobj.control.dtexts == NULL) 861 return -ENOMEM; 862 863 for (i = 0; i < le32_to_cpu(ec->items); i++) { 864 865 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 866 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 867 ret = -EINVAL; 868 goto err; 869 } 870 871 se->dobj.control.dtexts[i] = devm_kstrdup(tplg->dev, ec->texts[i], GFP_KERNEL); 872 if (!se->dobj.control.dtexts[i]) { 873 ret = -ENOMEM; 874 goto err; 875 } 876 } 877 878 se->items = le32_to_cpu(ec->items); 879 se->texts = (const char * const *)se->dobj.control.dtexts; 880 return 0; 881 882 err: 883 return ret; 884 } 885 886 static int soc_tplg_denum_create_values(struct soc_tplg *tplg, struct soc_enum *se, 887 struct snd_soc_tplg_enum_control *ec) 888 { 889 int i; 890 891 /* 892 * Following "if" checks if we have at most SND_SOC_TPLG_NUM_TEXTS 893 * values instead of using ARRAY_SIZE(ec->values) due to the fact that 894 * it is oversized for its purpose. Additionally it is done so because 895 * it is defined in UAPI header where it can't be easily changed. 896 */ 897 if (le32_to_cpu(ec->items) > SND_SOC_TPLG_NUM_TEXTS) 898 return -EINVAL; 899 900 se->dobj.control.dvalues = devm_kcalloc(tplg->dev, le32_to_cpu(ec->items), 901 sizeof(*se->dobj.control.dvalues), 902 GFP_KERNEL); 903 if (!se->dobj.control.dvalues) 904 return -ENOMEM; 905 906 /* convert from little-endian */ 907 for (i = 0; i < le32_to_cpu(ec->items); i++) { 908 se->dobj.control.dvalues[i] = le32_to_cpu(ec->values[i]); 909 } 910 911 return 0; 912 } 913 914 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count, 915 size_t size) 916 { 917 struct snd_soc_tplg_enum_control *ec; 918 struct soc_enum *se; 919 struct snd_kcontrol_new kc; 920 int i; 921 int err = 0; 922 923 if (soc_tplg_check_elem_count(tplg, 924 sizeof(struct snd_soc_tplg_enum_control), 925 count, size, "enums")) 926 return -EINVAL; 927 928 for (i = 0; i < count; i++) { 929 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 930 931 /* validate kcontrol */ 932 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 933 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 934 return -EINVAL; 935 936 se = devm_kzalloc(tplg->dev, (sizeof(*se)), GFP_KERNEL); 937 if (se == NULL) 938 return -ENOMEM; 939 940 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 941 le32_to_cpu(ec->priv.size)); 942 943 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n", 944 ec->hdr.name, ec->items); 945 946 memset(&kc, 0, sizeof(kc)); 947 kc.name = ec->hdr.name; 948 kc.private_value = (long)se; 949 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 950 kc.access = le32_to_cpu(ec->hdr.access); 951 952 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL); 953 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, 954 SNDRV_CHMAP_FL); 955 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, 956 SNDRV_CHMAP_FL); 957 958 se->mask = le32_to_cpu(ec->mask); 959 se->dobj.index = tplg->index; 960 se->dobj.type = SND_SOC_DOBJ_ENUM; 961 se->dobj.ops = tplg->ops; 962 INIT_LIST_HEAD(&se->dobj.list); 963 964 switch (le32_to_cpu(ec->hdr.ops.info)) { 965 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 966 case SND_SOC_TPLG_CTL_ENUM_VALUE: 967 err = soc_tplg_denum_create_values(tplg, se, ec); 968 if (err < 0) { 969 dev_err(tplg->dev, 970 "ASoC: could not create values for %s\n", 971 ec->hdr.name); 972 goto err_denum; 973 } 974 fallthrough; 975 case SND_SOC_TPLG_CTL_ENUM: 976 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 977 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 978 err = soc_tplg_denum_create_texts(tplg, se, ec); 979 if (err < 0) { 980 dev_err(tplg->dev, 981 "ASoC: could not create texts for %s\n", 982 ec->hdr.name); 983 goto err_denum; 984 } 985 break; 986 default: 987 err = -EINVAL; 988 dev_err(tplg->dev, 989 "ASoC: invalid enum control type %d for %s\n", 990 ec->hdr.ops.info, ec->hdr.name); 991 goto err_denum; 992 } 993 994 /* map io handlers */ 995 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg); 996 if (err) { 997 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 998 goto err_denum; 999 } 1000 1001 /* pass control to driver for optional further init */ 1002 err = soc_tplg_init_kcontrol(tplg, &kc, 1003 (struct snd_soc_tplg_ctl_hdr *) ec); 1004 if (err < 0) { 1005 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1006 ec->hdr.name); 1007 goto err_denum; 1008 } 1009 1010 /* register control here */ 1011 err = soc_tplg_add_kcontrol(tplg, 1012 &kc, &se->dobj.control.kcontrol); 1013 if (err < 0) { 1014 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n", 1015 ec->hdr.name); 1016 goto err_denum; 1017 } 1018 1019 list_add(&se->dobj.list, &tplg->comp->dobj_list); 1020 } 1021 return 0; 1022 1023 err_denum: 1024 return err; 1025 } 1026 1027 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg, 1028 struct snd_soc_tplg_hdr *hdr) 1029 { 1030 int ret; 1031 int i; 1032 1033 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count, 1034 soc_tplg_get_offset(tplg)); 1035 1036 for (i = 0; i < le32_to_cpu(hdr->count); i++) { 1037 struct snd_soc_tplg_ctl_hdr *control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1038 1039 if (le32_to_cpu(control_hdr->size) != sizeof(*control_hdr)) { 1040 dev_err(tplg->dev, "ASoC: invalid control size\n"); 1041 return -EINVAL; 1042 } 1043 1044 switch (le32_to_cpu(control_hdr->ops.info)) { 1045 case SND_SOC_TPLG_CTL_VOLSW: 1046 case SND_SOC_TPLG_CTL_STROBE: 1047 case SND_SOC_TPLG_CTL_VOLSW_SX: 1048 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1049 case SND_SOC_TPLG_CTL_RANGE: 1050 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1051 case SND_SOC_TPLG_DAPM_CTL_PIN: 1052 ret = soc_tplg_dmixer_create(tplg, 1, 1053 le32_to_cpu(hdr->payload_size)); 1054 break; 1055 case SND_SOC_TPLG_CTL_ENUM: 1056 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1057 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1058 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1059 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1060 ret = soc_tplg_denum_create(tplg, 1, 1061 le32_to_cpu(hdr->payload_size)); 1062 break; 1063 case SND_SOC_TPLG_CTL_BYTES: 1064 ret = soc_tplg_dbytes_create(tplg, 1, 1065 le32_to_cpu(hdr->payload_size)); 1066 break; 1067 default: 1068 soc_bind_err(tplg, control_hdr, i); 1069 return -EINVAL; 1070 } 1071 if (ret < 0) { 1072 dev_err(tplg->dev, "ASoC: invalid control\n"); 1073 return ret; 1074 } 1075 1076 } 1077 1078 return 0; 1079 } 1080 1081 /* optionally pass new dynamic kcontrol to component driver. */ 1082 static int soc_tplg_add_route(struct soc_tplg *tplg, 1083 struct snd_soc_dapm_route *route) 1084 { 1085 if (tplg->ops && tplg->ops->dapm_route_load) 1086 return tplg->ops->dapm_route_load(tplg->comp, tplg->index, 1087 route); 1088 1089 return 0; 1090 } 1091 1092 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg, 1093 struct snd_soc_tplg_hdr *hdr) 1094 { 1095 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm; 1096 struct snd_soc_tplg_dapm_graph_elem *elem; 1097 struct snd_soc_dapm_route *route; 1098 int count, i; 1099 int ret = 0; 1100 1101 count = le32_to_cpu(hdr->count); 1102 1103 if (soc_tplg_check_elem_count(tplg, 1104 sizeof(struct snd_soc_tplg_dapm_graph_elem), 1105 count, le32_to_cpu(hdr->payload_size), "graph")) 1106 return -EINVAL; 1107 1108 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes for index %d\n", count, 1109 hdr->index); 1110 1111 for (i = 0; i < count; i++) { 1112 route = devm_kzalloc(tplg->dev, sizeof(*route), GFP_KERNEL); 1113 if (!route) 1114 return -ENOMEM; 1115 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos; 1116 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem); 1117 1118 /* validate routes */ 1119 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1120 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 1121 ret = -EINVAL; 1122 break; 1123 } 1124 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1125 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 1126 ret = -EINVAL; 1127 break; 1128 } 1129 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1130 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 1131 ret = -EINVAL; 1132 break; 1133 } 1134 1135 route->source = elem->source; 1136 route->sink = elem->sink; 1137 1138 /* set to NULL atm for tplg users */ 1139 route->connected = NULL; 1140 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0) 1141 route->control = NULL; 1142 else 1143 route->control = elem->control; 1144 1145 /* add route dobj to dobj_list */ 1146 route->dobj.type = SND_SOC_DOBJ_GRAPH; 1147 route->dobj.ops = tplg->ops; 1148 route->dobj.index = tplg->index; 1149 list_add(&route->dobj.list, &tplg->comp->dobj_list); 1150 1151 ret = soc_tplg_add_route(tplg, route); 1152 if (ret < 0) { 1153 dev_err(tplg->dev, "ASoC: topology: add_route failed: %d\n", ret); 1154 break; 1155 } 1156 1157 /* add route, but keep going if some fail */ 1158 snd_soc_dapm_add_routes(dapm, route, 1); 1159 } 1160 1161 return ret; 1162 } 1163 1164 static int soc_tplg_dapm_widget_dmixer_create(struct soc_tplg *tplg, struct snd_kcontrol_new *kc) 1165 { 1166 struct soc_mixer_control *sm; 1167 struct snd_soc_tplg_mixer_control *mc; 1168 int err; 1169 1170 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 1171 1172 /* validate kcontrol */ 1173 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1174 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1175 return -EINVAL; 1176 1177 sm = devm_kzalloc(tplg->dev, sizeof(*sm), GFP_KERNEL); 1178 if (!sm) 1179 return -ENOMEM; 1180 1181 tplg->pos += sizeof(struct snd_soc_tplg_mixer_control) + 1182 le32_to_cpu(mc->priv.size); 1183 1184 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s\n", 1185 mc->hdr.name); 1186 1187 kc->private_value = (long)sm; 1188 kc->name = devm_kstrdup(tplg->dev, mc->hdr.name, GFP_KERNEL); 1189 if (!kc->name) 1190 return -ENOMEM; 1191 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1192 kc->access = le32_to_cpu(mc->hdr.access); 1193 1194 /* we only support FL/FR channel mapping atm */ 1195 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 1196 SNDRV_CHMAP_FL); 1197 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 1198 SNDRV_CHMAP_FR); 1199 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 1200 SNDRV_CHMAP_FL); 1201 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 1202 SNDRV_CHMAP_FR); 1203 1204 sm->max = le32_to_cpu(mc->max); 1205 sm->min = le32_to_cpu(mc->min); 1206 sm->invert = le32_to_cpu(mc->invert); 1207 sm->platform_max = le32_to_cpu(mc->platform_max); 1208 sm->dobj.index = tplg->index; 1209 INIT_LIST_HEAD(&sm->dobj.list); 1210 1211 /* map io handlers */ 1212 err = soc_tplg_kcontrol_bind_io(&mc->hdr, kc, tplg); 1213 if (err) { 1214 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 1215 return err; 1216 } 1217 1218 /* create any TLV data */ 1219 err = soc_tplg_create_tlv(tplg, kc, &mc->hdr); 1220 if (err < 0) { 1221 dev_err(tplg->dev, "ASoC: failed to create TLV %s\n", 1222 mc->hdr.name); 1223 return err; 1224 } 1225 1226 /* pass control to driver for optional further init */ 1227 err = soc_tplg_init_kcontrol(tplg, kc, 1228 (struct snd_soc_tplg_ctl_hdr *)mc); 1229 if (err < 0) { 1230 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1231 mc->hdr.name); 1232 return err; 1233 } 1234 1235 return 0; 1236 } 1237 1238 static int soc_tplg_dapm_widget_denum_create(struct soc_tplg *tplg, struct snd_kcontrol_new *kc) 1239 { 1240 struct snd_soc_tplg_enum_control *ec; 1241 struct soc_enum *se; 1242 int err; 1243 1244 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 1245 /* validate kcontrol */ 1246 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1247 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1248 return -EINVAL; 1249 1250 se = devm_kzalloc(tplg->dev, sizeof(*se), GFP_KERNEL); 1251 if (!se) 1252 return -ENOMEM; 1253 1254 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 1255 le32_to_cpu(ec->priv.size)); 1256 1257 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n", 1258 ec->hdr.name); 1259 1260 kc->private_value = (long)se; 1261 kc->name = devm_kstrdup(tplg->dev, ec->hdr.name, GFP_KERNEL); 1262 if (!kc->name) 1263 return -ENOMEM; 1264 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1265 kc->access = le32_to_cpu(ec->hdr.access); 1266 1267 /* we only support FL/FR channel mapping atm */ 1268 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL); 1269 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, 1270 SNDRV_CHMAP_FL); 1271 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, 1272 SNDRV_CHMAP_FR); 1273 1274 se->items = le32_to_cpu(ec->items); 1275 se->mask = le32_to_cpu(ec->mask); 1276 se->dobj.index = tplg->index; 1277 1278 switch (le32_to_cpu(ec->hdr.ops.info)) { 1279 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1280 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1281 err = soc_tplg_denum_create_values(tplg, se, ec); 1282 if (err < 0) { 1283 dev_err(tplg->dev, "ASoC: could not create values for %s\n", 1284 ec->hdr.name); 1285 return err; 1286 } 1287 fallthrough; 1288 case SND_SOC_TPLG_CTL_ENUM: 1289 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1290 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1291 err = soc_tplg_denum_create_texts(tplg, se, ec); 1292 if (err < 0) { 1293 dev_err(tplg->dev, "ASoC: could not create texts for %s\n", 1294 ec->hdr.name); 1295 return err; 1296 } 1297 break; 1298 default: 1299 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n", 1300 ec->hdr.ops.info, ec->hdr.name); 1301 return -EINVAL; 1302 } 1303 1304 /* map io handlers */ 1305 err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg); 1306 if (err) { 1307 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 1308 return err; 1309 } 1310 1311 /* pass control to driver for optional further init */ 1312 err = soc_tplg_init_kcontrol(tplg, kc, 1313 (struct snd_soc_tplg_ctl_hdr *)ec); 1314 if (err < 0) { 1315 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1316 ec->hdr.name); 1317 return err; 1318 } 1319 1320 return 0; 1321 } 1322 1323 static int soc_tplg_dapm_widget_dbytes_create(struct soc_tplg *tplg, struct snd_kcontrol_new *kc) 1324 { 1325 struct snd_soc_tplg_bytes_control *be; 1326 struct soc_bytes_ext *sbe; 1327 int err; 1328 1329 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 1330 1331 /* validate kcontrol */ 1332 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1333 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1334 return -EINVAL; 1335 1336 sbe = devm_kzalloc(tplg->dev, sizeof(*sbe), GFP_KERNEL); 1337 if (!sbe) 1338 return -ENOMEM; 1339 1340 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 1341 le32_to_cpu(be->priv.size)); 1342 1343 dev_dbg(tplg->dev, 1344 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 1345 be->hdr.name, be->hdr.access); 1346 1347 kc->private_value = (long)sbe; 1348 kc->name = devm_kstrdup(tplg->dev, be->hdr.name, GFP_KERNEL); 1349 if (!kc->name) 1350 return -ENOMEM; 1351 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1352 kc->access = le32_to_cpu(be->hdr.access); 1353 1354 sbe->max = le32_to_cpu(be->max); 1355 INIT_LIST_HEAD(&sbe->dobj.list); 1356 1357 /* map standard io handlers and check for external handlers */ 1358 err = soc_tplg_kcontrol_bind_io(&be->hdr, kc, tplg); 1359 if (err) { 1360 soc_control_err(tplg, &be->hdr, be->hdr.name); 1361 return err; 1362 } 1363 1364 /* pass control to driver for optional further init */ 1365 err = soc_tplg_init_kcontrol(tplg, kc, 1366 (struct snd_soc_tplg_ctl_hdr *)be); 1367 if (err < 0) { 1368 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1369 be->hdr.name); 1370 return err; 1371 } 1372 1373 return 0; 1374 } 1375 1376 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg, 1377 struct snd_soc_tplg_dapm_widget *w) 1378 { 1379 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm; 1380 struct snd_soc_dapm_widget template, *widget; 1381 struct snd_soc_tplg_ctl_hdr *control_hdr; 1382 struct snd_soc_card *card = tplg->comp->card; 1383 unsigned int *kcontrol_type = NULL; 1384 struct snd_kcontrol_new *kc; 1385 int mixer_count = 0; 1386 int bytes_count = 0; 1387 int enum_count = 0; 1388 int ret = 0; 1389 int i; 1390 1391 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1392 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1393 return -EINVAL; 1394 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1395 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1396 return -EINVAL; 1397 1398 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n", 1399 w->name, w->id); 1400 1401 memset(&template, 0, sizeof(template)); 1402 1403 /* map user to kernel widget ID */ 1404 template.id = get_widget_id(le32_to_cpu(w->id)); 1405 if ((int)template.id < 0) 1406 return template.id; 1407 1408 /* strings are allocated here, but used and freed by the widget */ 1409 template.name = kstrdup(w->name, GFP_KERNEL); 1410 if (!template.name) 1411 return -ENOMEM; 1412 template.sname = kstrdup(w->sname, GFP_KERNEL); 1413 if (!template.sname) { 1414 ret = -ENOMEM; 1415 goto err; 1416 } 1417 template.reg = le32_to_cpu(w->reg); 1418 template.shift = le32_to_cpu(w->shift); 1419 template.mask = le32_to_cpu(w->mask); 1420 template.subseq = le32_to_cpu(w->subseq); 1421 template.on_val = w->invert ? 0 : 1; 1422 template.off_val = w->invert ? 1 : 0; 1423 template.ignore_suspend = le32_to_cpu(w->ignore_suspend); 1424 template.event_flags = le16_to_cpu(w->event_flags); 1425 template.dobj.index = tplg->index; 1426 1427 tplg->pos += 1428 (sizeof(struct snd_soc_tplg_dapm_widget) + 1429 le32_to_cpu(w->priv.size)); 1430 1431 if (w->num_kcontrols == 0) { 1432 template.num_kcontrols = 0; 1433 goto widget; 1434 } 1435 1436 template.num_kcontrols = le32_to_cpu(w->num_kcontrols); 1437 kc = devm_kcalloc(tplg->dev, le32_to_cpu(w->num_kcontrols), sizeof(*kc), GFP_KERNEL); 1438 if (!kc) 1439 goto err; 1440 1441 kcontrol_type = devm_kcalloc(tplg->dev, le32_to_cpu(w->num_kcontrols), sizeof(unsigned int), 1442 GFP_KERNEL); 1443 if (!kcontrol_type) 1444 goto err; 1445 1446 for (i = 0; i < le32_to_cpu(w->num_kcontrols); i++) { 1447 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1448 switch (le32_to_cpu(control_hdr->ops.info)) { 1449 case SND_SOC_TPLG_CTL_VOLSW: 1450 case SND_SOC_TPLG_CTL_STROBE: 1451 case SND_SOC_TPLG_CTL_VOLSW_SX: 1452 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1453 case SND_SOC_TPLG_CTL_RANGE: 1454 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1455 /* volume mixer */ 1456 kc[i].index = mixer_count; 1457 kcontrol_type[i] = SND_SOC_TPLG_TYPE_MIXER; 1458 mixer_count++; 1459 ret = soc_tplg_dapm_widget_dmixer_create(tplg, &kc[i]); 1460 if (ret < 0) 1461 goto hdr_err; 1462 break; 1463 case SND_SOC_TPLG_CTL_ENUM: 1464 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1465 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1466 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1467 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1468 /* enumerated mixer */ 1469 kc[i].index = enum_count; 1470 kcontrol_type[i] = SND_SOC_TPLG_TYPE_ENUM; 1471 enum_count++; 1472 ret = soc_tplg_dapm_widget_denum_create(tplg, &kc[i]); 1473 if (ret < 0) 1474 goto hdr_err; 1475 break; 1476 case SND_SOC_TPLG_CTL_BYTES: 1477 /* bytes control */ 1478 kc[i].index = bytes_count; 1479 kcontrol_type[i] = SND_SOC_TPLG_TYPE_BYTES; 1480 bytes_count++; 1481 ret = soc_tplg_dapm_widget_dbytes_create(tplg, &kc[i]); 1482 if (ret < 0) 1483 goto hdr_err; 1484 break; 1485 default: 1486 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n", 1487 control_hdr->ops.get, control_hdr->ops.put, 1488 le32_to_cpu(control_hdr->ops.info)); 1489 ret = -EINVAL; 1490 goto hdr_err; 1491 } 1492 } 1493 1494 template.kcontrol_news = kc; 1495 dev_dbg(tplg->dev, "ASoC: template %s with %d/%d/%d (mixer/enum/bytes) control\n", 1496 w->name, mixer_count, enum_count, bytes_count); 1497 1498 widget: 1499 ret = soc_tplg_widget_load(tplg, &template, w); 1500 if (ret < 0) 1501 goto hdr_err; 1502 1503 /* card dapm mutex is held by the core if we are loading topology 1504 * data during sound card init. */ 1505 if (card->instantiated) 1506 widget = snd_soc_dapm_new_control(dapm, &template); 1507 else 1508 widget = snd_soc_dapm_new_control_unlocked(dapm, &template); 1509 if (IS_ERR(widget)) { 1510 ret = PTR_ERR(widget); 1511 goto hdr_err; 1512 } 1513 1514 widget->dobj.type = SND_SOC_DOBJ_WIDGET; 1515 widget->dobj.widget.kcontrol_type = kcontrol_type; 1516 widget->dobj.ops = tplg->ops; 1517 widget->dobj.index = tplg->index; 1518 list_add(&widget->dobj.list, &tplg->comp->dobj_list); 1519 1520 ret = soc_tplg_widget_ready(tplg, widget, w); 1521 if (ret < 0) 1522 goto ready_err; 1523 1524 kfree(template.sname); 1525 kfree(template.name); 1526 1527 return 0; 1528 1529 ready_err: 1530 remove_widget(widget->dapm->component, &widget->dobj, SOC_TPLG_PASS_WIDGET); 1531 snd_soc_dapm_free_widget(widget); 1532 hdr_err: 1533 kfree(template.sname); 1534 err: 1535 kfree(template.name); 1536 return ret; 1537 } 1538 1539 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg, 1540 struct snd_soc_tplg_hdr *hdr) 1541 { 1542 int count, i; 1543 1544 count = le32_to_cpu(hdr->count); 1545 1546 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count); 1547 1548 for (i = 0; i < count; i++) { 1549 struct snd_soc_tplg_dapm_widget *widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos; 1550 int ret; 1551 1552 /* 1553 * check if widget itself fits within topology file 1554 * use sizeof instead of widget->size, as we can't be sure 1555 * it is set properly yet (file may end before it is present) 1556 */ 1557 if (soc_tplg_get_offset(tplg) + sizeof(*widget) >= tplg->fw->size) { 1558 dev_err(tplg->dev, "ASoC: invalid widget data size\n"); 1559 return -EINVAL; 1560 } 1561 1562 /* check if widget has proper size */ 1563 if (le32_to_cpu(widget->size) != sizeof(*widget)) { 1564 dev_err(tplg->dev, "ASoC: invalid widget size\n"); 1565 return -EINVAL; 1566 } 1567 1568 /* check if widget private data fits within topology file */ 1569 if (soc_tplg_get_offset(tplg) + le32_to_cpu(widget->priv.size) >= tplg->fw->size) { 1570 dev_err(tplg->dev, "ASoC: invalid widget private data size\n"); 1571 return -EINVAL; 1572 } 1573 1574 ret = soc_tplg_dapm_widget_create(tplg, widget); 1575 if (ret < 0) { 1576 dev_err(tplg->dev, "ASoC: failed to load widget %s\n", 1577 widget->name); 1578 return ret; 1579 } 1580 } 1581 1582 return 0; 1583 } 1584 1585 static int soc_tplg_dapm_complete(struct soc_tplg *tplg) 1586 { 1587 struct snd_soc_card *card = tplg->comp->card; 1588 int ret; 1589 1590 /* Card might not have been registered at this point. 1591 * If so, just return success. 1592 */ 1593 if (!card || !card->instantiated) { 1594 dev_warn(tplg->dev, "ASoC: Parent card not yet available," 1595 " widget card binding deferred\n"); 1596 return 0; 1597 } 1598 1599 ret = snd_soc_dapm_new_widgets(card); 1600 if (ret < 0) 1601 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n", 1602 ret); 1603 1604 return 0; 1605 } 1606 1607 static int set_stream_info(struct soc_tplg *tplg, struct snd_soc_pcm_stream *stream, 1608 struct snd_soc_tplg_stream_caps *caps) 1609 { 1610 stream->stream_name = devm_kstrdup(tplg->dev, caps->name, GFP_KERNEL); 1611 if (!stream->stream_name) 1612 return -ENOMEM; 1613 1614 stream->channels_min = le32_to_cpu(caps->channels_min); 1615 stream->channels_max = le32_to_cpu(caps->channels_max); 1616 stream->rates = le32_to_cpu(caps->rates); 1617 stream->rate_min = le32_to_cpu(caps->rate_min); 1618 stream->rate_max = le32_to_cpu(caps->rate_max); 1619 stream->formats = le64_to_cpu(caps->formats); 1620 stream->sig_bits = le32_to_cpu(caps->sig_bits); 1621 1622 return 0; 1623 } 1624 1625 static void set_dai_flags(struct snd_soc_dai_driver *dai_drv, 1626 unsigned int flag_mask, unsigned int flags) 1627 { 1628 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) 1629 dai_drv->symmetric_rate = 1630 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) ? 1 : 0; 1631 1632 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) 1633 dai_drv->symmetric_channels = 1634 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) ? 1635 1 : 0; 1636 1637 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) 1638 dai_drv->symmetric_sample_bits = 1639 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) ? 1640 1 : 0; 1641 } 1642 1643 static int soc_tplg_dai_create(struct soc_tplg *tplg, 1644 struct snd_soc_tplg_pcm *pcm) 1645 { 1646 struct snd_soc_dai_driver *dai_drv; 1647 struct snd_soc_pcm_stream *stream; 1648 struct snd_soc_tplg_stream_caps *caps; 1649 struct snd_soc_dai *dai; 1650 struct snd_soc_dapm_context *dapm = 1651 snd_soc_component_get_dapm(tplg->comp); 1652 int ret; 1653 1654 dai_drv = devm_kzalloc(tplg->dev, sizeof(struct snd_soc_dai_driver), GFP_KERNEL); 1655 if (dai_drv == NULL) 1656 return -ENOMEM; 1657 1658 if (strlen(pcm->dai_name)) { 1659 dai_drv->name = devm_kstrdup(tplg->dev, pcm->dai_name, GFP_KERNEL); 1660 if (!dai_drv->name) { 1661 ret = -ENOMEM; 1662 goto err; 1663 } 1664 } 1665 dai_drv->id = le32_to_cpu(pcm->dai_id); 1666 1667 if (pcm->playback) { 1668 stream = &dai_drv->playback; 1669 caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 1670 ret = set_stream_info(tplg, stream, caps); 1671 if (ret < 0) 1672 goto err; 1673 } 1674 1675 if (pcm->capture) { 1676 stream = &dai_drv->capture; 1677 caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 1678 ret = set_stream_info(tplg, stream, caps); 1679 if (ret < 0) 1680 goto err; 1681 } 1682 1683 if (pcm->compress) 1684 dai_drv->compress_new = snd_soc_new_compress; 1685 1686 /* pass control to component driver for optional further init */ 1687 ret = soc_tplg_dai_load(tplg, dai_drv, pcm, NULL); 1688 if (ret < 0) { 1689 dev_err(tplg->dev, "ASoC: DAI loading failed\n"); 1690 goto err; 1691 } 1692 1693 dai_drv->dobj.index = tplg->index; 1694 dai_drv->dobj.ops = tplg->ops; 1695 dai_drv->dobj.type = SND_SOC_DOBJ_PCM; 1696 list_add(&dai_drv->dobj.list, &tplg->comp->dobj_list); 1697 1698 /* register the DAI to the component */ 1699 dai = snd_soc_register_dai(tplg->comp, dai_drv, false); 1700 if (!dai) 1701 return -ENOMEM; 1702 1703 /* Create the DAI widgets here */ 1704 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 1705 if (ret != 0) { 1706 dev_err(dai->dev, "Failed to create DAI widgets %d\n", ret); 1707 snd_soc_unregister_dai(dai); 1708 return ret; 1709 } 1710 1711 return 0; 1712 1713 err: 1714 return ret; 1715 } 1716 1717 static void set_link_flags(struct snd_soc_dai_link *link, 1718 unsigned int flag_mask, unsigned int flags) 1719 { 1720 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES) 1721 link->symmetric_rate = 1722 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES) ? 1 : 0; 1723 1724 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS) 1725 link->symmetric_channels = 1726 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS) ? 1727 1 : 0; 1728 1729 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS) 1730 link->symmetric_sample_bits = 1731 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS) ? 1732 1 : 0; 1733 1734 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP) 1735 link->ignore_suspend = 1736 (flags & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP) ? 1737 1 : 0; 1738 } 1739 1740 /* create the FE DAI link */ 1741 static int soc_tplg_fe_link_create(struct soc_tplg *tplg, 1742 struct snd_soc_tplg_pcm *pcm) 1743 { 1744 struct snd_soc_dai_link *link; 1745 struct snd_soc_dai_link_component *dlc; 1746 int ret; 1747 1748 /* link + cpu + codec + platform */ 1749 link = devm_kzalloc(tplg->dev, sizeof(*link) + (3 * sizeof(*dlc)), GFP_KERNEL); 1750 if (link == NULL) 1751 return -ENOMEM; 1752 1753 dlc = (struct snd_soc_dai_link_component *)(link + 1); 1754 1755 link->cpus = &dlc[0]; 1756 link->codecs = &dlc[1]; 1757 link->platforms = &dlc[2]; 1758 1759 link->num_cpus = 1; 1760 link->num_codecs = 1; 1761 link->num_platforms = 1; 1762 1763 link->dobj.index = tplg->index; 1764 link->dobj.ops = tplg->ops; 1765 link->dobj.type = SND_SOC_DOBJ_DAI_LINK; 1766 1767 if (strlen(pcm->pcm_name)) { 1768 link->name = devm_kstrdup(tplg->dev, pcm->pcm_name, GFP_KERNEL); 1769 link->stream_name = devm_kstrdup(tplg->dev, pcm->pcm_name, GFP_KERNEL); 1770 if (!link->name || !link->stream_name) { 1771 ret = -ENOMEM; 1772 goto err; 1773 } 1774 } 1775 link->id = le32_to_cpu(pcm->pcm_id); 1776 1777 if (strlen(pcm->dai_name)) { 1778 link->cpus->dai_name = devm_kstrdup(tplg->dev, pcm->dai_name, GFP_KERNEL); 1779 if (!link->cpus->dai_name) { 1780 ret = -ENOMEM; 1781 goto err; 1782 } 1783 } 1784 1785 link->codecs->name = "snd-soc-dummy"; 1786 link->codecs->dai_name = "snd-soc-dummy-dai"; 1787 1788 link->platforms->name = "snd-soc-dummy"; 1789 1790 /* enable DPCM */ 1791 link->dynamic = 1; 1792 link->dpcm_playback = le32_to_cpu(pcm->playback); 1793 link->dpcm_capture = le32_to_cpu(pcm->capture); 1794 if (pcm->flag_mask) 1795 set_link_flags(link, 1796 le32_to_cpu(pcm->flag_mask), 1797 le32_to_cpu(pcm->flags)); 1798 1799 /* pass control to component driver for optional further init */ 1800 ret = soc_tplg_dai_link_load(tplg, link, NULL); 1801 if (ret < 0) { 1802 dev_err(tplg->dev, "ASoC: FE link loading failed\n"); 1803 goto err; 1804 } 1805 1806 ret = snd_soc_add_pcm_runtime(tplg->comp->card, link); 1807 if (ret < 0) { 1808 dev_err(tplg->dev, "ASoC: adding FE link failed\n"); 1809 goto err; 1810 } 1811 1812 list_add(&link->dobj.list, &tplg->comp->dobj_list); 1813 1814 return 0; 1815 err: 1816 return ret; 1817 } 1818 1819 /* create a FE DAI and DAI link from the PCM object */ 1820 static int soc_tplg_pcm_create(struct soc_tplg *tplg, 1821 struct snd_soc_tplg_pcm *pcm) 1822 { 1823 int ret; 1824 1825 ret = soc_tplg_dai_create(tplg, pcm); 1826 if (ret < 0) 1827 return ret; 1828 1829 return soc_tplg_fe_link_create(tplg, pcm); 1830 } 1831 1832 /* copy stream caps from the old version 4 of source */ 1833 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps *dest, 1834 struct snd_soc_tplg_stream_caps_v4 *src) 1835 { 1836 dest->size = cpu_to_le32(sizeof(*dest)); 1837 memcpy(dest->name, src->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1838 dest->formats = src->formats; 1839 dest->rates = src->rates; 1840 dest->rate_min = src->rate_min; 1841 dest->rate_max = src->rate_max; 1842 dest->channels_min = src->channels_min; 1843 dest->channels_max = src->channels_max; 1844 dest->periods_min = src->periods_min; 1845 dest->periods_max = src->periods_max; 1846 dest->period_size_min = src->period_size_min; 1847 dest->period_size_max = src->period_size_max; 1848 dest->buffer_size_min = src->buffer_size_min; 1849 dest->buffer_size_max = src->buffer_size_max; 1850 } 1851 1852 /** 1853 * pcm_new_ver - Create the new version of PCM from the old version. 1854 * @tplg: topology context 1855 * @src: older version of pcm as a source 1856 * @pcm: latest version of pcm created from the source 1857 * 1858 * Support from version 4. User should free the returned pcm manually. 1859 */ 1860 static int pcm_new_ver(struct soc_tplg *tplg, 1861 struct snd_soc_tplg_pcm *src, 1862 struct snd_soc_tplg_pcm **pcm) 1863 { 1864 struct snd_soc_tplg_pcm *dest; 1865 struct snd_soc_tplg_pcm_v4 *src_v4; 1866 int i; 1867 1868 *pcm = NULL; 1869 1870 if (le32_to_cpu(src->size) != sizeof(*src_v4)) { 1871 dev_err(tplg->dev, "ASoC: invalid PCM size\n"); 1872 return -EINVAL; 1873 } 1874 1875 dev_warn(tplg->dev, "ASoC: old version of PCM\n"); 1876 src_v4 = (struct snd_soc_tplg_pcm_v4 *)src; 1877 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 1878 if (!dest) 1879 return -ENOMEM; 1880 1881 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 1882 memcpy(dest->pcm_name, src_v4->pcm_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1883 memcpy(dest->dai_name, src_v4->dai_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1884 dest->pcm_id = src_v4->pcm_id; 1885 dest->dai_id = src_v4->dai_id; 1886 dest->playback = src_v4->playback; 1887 dest->capture = src_v4->capture; 1888 dest->compress = src_v4->compress; 1889 dest->num_streams = src_v4->num_streams; 1890 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 1891 memcpy(&dest->stream[i], &src_v4->stream[i], 1892 sizeof(struct snd_soc_tplg_stream)); 1893 1894 for (i = 0; i < 2; i++) 1895 stream_caps_new_ver(&dest->caps[i], &src_v4->caps[i]); 1896 1897 *pcm = dest; 1898 return 0; 1899 } 1900 1901 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, 1902 struct snd_soc_tplg_hdr *hdr) 1903 { 1904 struct snd_soc_tplg_pcm *pcm, *_pcm; 1905 int count; 1906 int size; 1907 int i; 1908 bool abi_match; 1909 int ret; 1910 1911 count = le32_to_cpu(hdr->count); 1912 1913 /* check the element size and count */ 1914 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1915 size = le32_to_cpu(pcm->size); 1916 if (size > sizeof(struct snd_soc_tplg_pcm) 1917 || size < sizeof(struct snd_soc_tplg_pcm_v4)) { 1918 dev_err(tplg->dev, "ASoC: invalid size %d for PCM elems\n", 1919 size); 1920 return -EINVAL; 1921 } 1922 1923 if (soc_tplg_check_elem_count(tplg, 1924 size, count, 1925 le32_to_cpu(hdr->payload_size), 1926 "PCM DAI")) 1927 return -EINVAL; 1928 1929 for (i = 0; i < count; i++) { 1930 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1931 size = le32_to_cpu(pcm->size); 1932 1933 /* check ABI version by size, create a new version of pcm 1934 * if abi not match. 1935 */ 1936 if (size == sizeof(*pcm)) { 1937 abi_match = true; 1938 _pcm = pcm; 1939 } else { 1940 abi_match = false; 1941 ret = pcm_new_ver(tplg, pcm, &_pcm); 1942 if (ret < 0) 1943 return ret; 1944 } 1945 1946 /* create the FE DAIs and DAI links */ 1947 ret = soc_tplg_pcm_create(tplg, _pcm); 1948 if (ret < 0) { 1949 if (!abi_match) 1950 kfree(_pcm); 1951 return ret; 1952 } 1953 1954 /* offset by version-specific struct size and 1955 * real priv data size 1956 */ 1957 tplg->pos += size + le32_to_cpu(_pcm->priv.size); 1958 1959 if (!abi_match) 1960 kfree(_pcm); /* free the duplicated one */ 1961 } 1962 1963 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count); 1964 1965 return 0; 1966 } 1967 1968 /** 1969 * set_link_hw_format - Set the HW audio format of the physical DAI link. 1970 * @link: &snd_soc_dai_link which should be updated 1971 * @cfg: physical link configs. 1972 * 1973 * Topology context contains a list of supported HW formats (configs) and 1974 * a default format ID for the physical link. This function will use this 1975 * default ID to choose the HW format to set the link's DAI format for init. 1976 */ 1977 static void set_link_hw_format(struct snd_soc_dai_link *link, 1978 struct snd_soc_tplg_link_config *cfg) 1979 { 1980 struct snd_soc_tplg_hw_config *hw_config; 1981 unsigned char bclk_provider, fsync_provider; 1982 unsigned char invert_bclk, invert_fsync; 1983 int i; 1984 1985 for (i = 0; i < le32_to_cpu(cfg->num_hw_configs); i++) { 1986 hw_config = &cfg->hw_config[i]; 1987 if (hw_config->id != cfg->default_hw_config_id) 1988 continue; 1989 1990 link->dai_fmt = le32_to_cpu(hw_config->fmt) & 1991 SND_SOC_DAIFMT_FORMAT_MASK; 1992 1993 /* clock gating */ 1994 switch (hw_config->clock_gated) { 1995 case SND_SOC_TPLG_DAI_CLK_GATE_GATED: 1996 link->dai_fmt |= SND_SOC_DAIFMT_GATED; 1997 break; 1998 1999 case SND_SOC_TPLG_DAI_CLK_GATE_CONT: 2000 link->dai_fmt |= SND_SOC_DAIFMT_CONT; 2001 break; 2002 2003 default: 2004 /* ignore the value */ 2005 break; 2006 } 2007 2008 /* clock signal polarity */ 2009 invert_bclk = hw_config->invert_bclk; 2010 invert_fsync = hw_config->invert_fsync; 2011 if (!invert_bclk && !invert_fsync) 2012 link->dai_fmt |= SND_SOC_DAIFMT_NB_NF; 2013 else if (!invert_bclk && invert_fsync) 2014 link->dai_fmt |= SND_SOC_DAIFMT_NB_IF; 2015 else if (invert_bclk && !invert_fsync) 2016 link->dai_fmt |= SND_SOC_DAIFMT_IB_NF; 2017 else 2018 link->dai_fmt |= SND_SOC_DAIFMT_IB_IF; 2019 2020 /* clock masters */ 2021 bclk_provider = (hw_config->bclk_provider == 2022 SND_SOC_TPLG_BCLK_CP); 2023 fsync_provider = (hw_config->fsync_provider == 2024 SND_SOC_TPLG_FSYNC_CP); 2025 if (bclk_provider && fsync_provider) 2026 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFP; 2027 else if (!bclk_provider && fsync_provider) 2028 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFP; 2029 else if (bclk_provider && !fsync_provider) 2030 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFC; 2031 else 2032 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFC; 2033 } 2034 } 2035 2036 /** 2037 * link_new_ver - Create a new physical link config from the old 2038 * version of source. 2039 * @tplg: topology context 2040 * @src: old version of phyical link config as a source 2041 * @link: latest version of physical link config created from the source 2042 * 2043 * Support from version 4. User need free the returned link config manually. 2044 */ 2045 static int link_new_ver(struct soc_tplg *tplg, 2046 struct snd_soc_tplg_link_config *src, 2047 struct snd_soc_tplg_link_config **link) 2048 { 2049 struct snd_soc_tplg_link_config *dest; 2050 struct snd_soc_tplg_link_config_v4 *src_v4; 2051 int i; 2052 2053 *link = NULL; 2054 2055 if (le32_to_cpu(src->size) != 2056 sizeof(struct snd_soc_tplg_link_config_v4)) { 2057 dev_err(tplg->dev, "ASoC: invalid physical link config size\n"); 2058 return -EINVAL; 2059 } 2060 2061 dev_warn(tplg->dev, "ASoC: old version of physical link config\n"); 2062 2063 src_v4 = (struct snd_soc_tplg_link_config_v4 *)src; 2064 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 2065 if (!dest) 2066 return -ENOMEM; 2067 2068 dest->size = cpu_to_le32(sizeof(*dest)); 2069 dest->id = src_v4->id; 2070 dest->num_streams = src_v4->num_streams; 2071 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 2072 memcpy(&dest->stream[i], &src_v4->stream[i], 2073 sizeof(struct snd_soc_tplg_stream)); 2074 2075 *link = dest; 2076 return 0; 2077 } 2078 2079 /** 2080 * snd_soc_find_dai_link - Find a DAI link 2081 * 2082 * @card: soc card 2083 * @id: DAI link ID to match 2084 * @name: DAI link name to match, optional 2085 * @stream_name: DAI link stream name to match, optional 2086 * 2087 * This function will search all existing DAI links of the soc card to 2088 * find the link of the same ID. Since DAI links may not have their 2089 * unique ID, so name and stream name should also match if being 2090 * specified. 2091 * 2092 * Return: pointer of DAI link, or NULL if not found. 2093 */ 2094 static struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card, 2095 int id, const char *name, 2096 const char *stream_name) 2097 { 2098 struct snd_soc_pcm_runtime *rtd; 2099 2100 for_each_card_rtds(card, rtd) { 2101 struct snd_soc_dai_link *link = rtd->dai_link; 2102 2103 if (link->id != id) 2104 continue; 2105 2106 if (name && (!link->name || strcmp(name, link->name))) 2107 continue; 2108 2109 if (stream_name && (!link->stream_name 2110 || strcmp(stream_name, link->stream_name))) 2111 continue; 2112 2113 return link; 2114 } 2115 2116 return NULL; 2117 } 2118 2119 /* Find and configure an existing physical DAI link */ 2120 static int soc_tplg_link_config(struct soc_tplg *tplg, 2121 struct snd_soc_tplg_link_config *cfg) 2122 { 2123 struct snd_soc_dai_link *link; 2124 const char *name, *stream_name; 2125 size_t len; 2126 int ret; 2127 2128 len = strnlen(cfg->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2129 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2130 return -EINVAL; 2131 else if (len) 2132 name = cfg->name; 2133 else 2134 name = NULL; 2135 2136 len = strnlen(cfg->stream_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2137 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2138 return -EINVAL; 2139 else if (len) 2140 stream_name = cfg->stream_name; 2141 else 2142 stream_name = NULL; 2143 2144 link = snd_soc_find_dai_link(tplg->comp->card, le32_to_cpu(cfg->id), 2145 name, stream_name); 2146 if (!link) { 2147 dev_err(tplg->dev, "ASoC: physical link %s (id %d) not exist\n", 2148 name, cfg->id); 2149 return -EINVAL; 2150 } 2151 2152 /* hw format */ 2153 if (cfg->num_hw_configs) 2154 set_link_hw_format(link, cfg); 2155 2156 /* flags */ 2157 if (cfg->flag_mask) 2158 set_link_flags(link, 2159 le32_to_cpu(cfg->flag_mask), 2160 le32_to_cpu(cfg->flags)); 2161 2162 /* pass control to component driver for optional further init */ 2163 ret = soc_tplg_dai_link_load(tplg, link, cfg); 2164 if (ret < 0) { 2165 dev_err(tplg->dev, "ASoC: physical link loading failed\n"); 2166 return ret; 2167 } 2168 2169 /* for unloading it in snd_soc_tplg_component_remove */ 2170 link->dobj.index = tplg->index; 2171 link->dobj.ops = tplg->ops; 2172 link->dobj.type = SND_SOC_DOBJ_BACKEND_LINK; 2173 list_add(&link->dobj.list, &tplg->comp->dobj_list); 2174 2175 return 0; 2176 } 2177 2178 2179 /* Load physical link config elements from the topology context */ 2180 static int soc_tplg_link_elems_load(struct soc_tplg *tplg, 2181 struct snd_soc_tplg_hdr *hdr) 2182 { 2183 struct snd_soc_tplg_link_config *link, *_link; 2184 int count; 2185 int size; 2186 int i, ret; 2187 bool abi_match; 2188 2189 count = le32_to_cpu(hdr->count); 2190 2191 /* check the element size and count */ 2192 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2193 size = le32_to_cpu(link->size); 2194 if (size > sizeof(struct snd_soc_tplg_link_config) 2195 || size < sizeof(struct snd_soc_tplg_link_config_v4)) { 2196 dev_err(tplg->dev, "ASoC: invalid size %d for physical link elems\n", 2197 size); 2198 return -EINVAL; 2199 } 2200 2201 if (soc_tplg_check_elem_count(tplg, size, count, 2202 le32_to_cpu(hdr->payload_size), 2203 "physical link config")) 2204 return -EINVAL; 2205 2206 /* config physical DAI links */ 2207 for (i = 0; i < count; i++) { 2208 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2209 size = le32_to_cpu(link->size); 2210 if (size == sizeof(*link)) { 2211 abi_match = true; 2212 _link = link; 2213 } else { 2214 abi_match = false; 2215 ret = link_new_ver(tplg, link, &_link); 2216 if (ret < 0) 2217 return ret; 2218 } 2219 2220 ret = soc_tplg_link_config(tplg, _link); 2221 if (ret < 0) { 2222 if (!abi_match) 2223 kfree(_link); 2224 return ret; 2225 } 2226 2227 /* offset by version-specific struct size and 2228 * real priv data size 2229 */ 2230 tplg->pos += size + le32_to_cpu(_link->priv.size); 2231 2232 if (!abi_match) 2233 kfree(_link); /* free the duplicated one */ 2234 } 2235 2236 return 0; 2237 } 2238 2239 /** 2240 * soc_tplg_dai_config - Find and configure an existing physical DAI. 2241 * @tplg: topology context 2242 * @d: physical DAI configs. 2243 * 2244 * The physical dai should already be registered by the platform driver. 2245 * The platform driver should specify the DAI name and ID for matching. 2246 */ 2247 static int soc_tplg_dai_config(struct soc_tplg *tplg, 2248 struct snd_soc_tplg_dai *d) 2249 { 2250 struct snd_soc_dai_link_component dai_component; 2251 struct snd_soc_dai *dai; 2252 struct snd_soc_dai_driver *dai_drv; 2253 struct snd_soc_pcm_stream *stream; 2254 struct snd_soc_tplg_stream_caps *caps; 2255 int ret; 2256 2257 memset(&dai_component, 0, sizeof(dai_component)); 2258 2259 dai_component.dai_name = d->dai_name; 2260 dai = snd_soc_find_dai(&dai_component); 2261 if (!dai) { 2262 dev_err(tplg->dev, "ASoC: physical DAI %s not registered\n", 2263 d->dai_name); 2264 return -EINVAL; 2265 } 2266 2267 if (le32_to_cpu(d->dai_id) != dai->id) { 2268 dev_err(tplg->dev, "ASoC: physical DAI %s id mismatch\n", 2269 d->dai_name); 2270 return -EINVAL; 2271 } 2272 2273 dai_drv = dai->driver; 2274 if (!dai_drv) 2275 return -EINVAL; 2276 2277 if (d->playback) { 2278 stream = &dai_drv->playback; 2279 caps = &d->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 2280 ret = set_stream_info(tplg, stream, caps); 2281 if (ret < 0) 2282 goto err; 2283 } 2284 2285 if (d->capture) { 2286 stream = &dai_drv->capture; 2287 caps = &d->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 2288 ret = set_stream_info(tplg, stream, caps); 2289 if (ret < 0) 2290 goto err; 2291 } 2292 2293 if (d->flag_mask) 2294 set_dai_flags(dai_drv, 2295 le32_to_cpu(d->flag_mask), 2296 le32_to_cpu(d->flags)); 2297 2298 /* pass control to component driver for optional further init */ 2299 ret = soc_tplg_dai_load(tplg, dai_drv, NULL, dai); 2300 if (ret < 0) { 2301 dev_err(tplg->dev, "ASoC: DAI loading failed\n"); 2302 goto err; 2303 } 2304 2305 return 0; 2306 2307 err: 2308 return ret; 2309 } 2310 2311 /* load physical DAI elements */ 2312 static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, 2313 struct snd_soc_tplg_hdr *hdr) 2314 { 2315 int count; 2316 int i; 2317 2318 count = le32_to_cpu(hdr->count); 2319 2320 /* config the existing BE DAIs */ 2321 for (i = 0; i < count; i++) { 2322 struct snd_soc_tplg_dai *dai = (struct snd_soc_tplg_dai *)tplg->pos; 2323 int ret; 2324 2325 if (le32_to_cpu(dai->size) != sizeof(*dai)) { 2326 dev_err(tplg->dev, "ASoC: invalid physical DAI size\n"); 2327 return -EINVAL; 2328 } 2329 2330 ret = soc_tplg_dai_config(tplg, dai); 2331 if (ret < 0) { 2332 dev_err(tplg->dev, "ASoC: failed to configure DAI\n"); 2333 return ret; 2334 } 2335 2336 tplg->pos += (sizeof(*dai) + le32_to_cpu(dai->priv.size)); 2337 } 2338 2339 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count); 2340 return 0; 2341 } 2342 2343 /** 2344 * manifest_new_ver - Create a new version of manifest from the old version 2345 * of source. 2346 * @tplg: topology context 2347 * @src: old version of manifest as a source 2348 * @manifest: latest version of manifest created from the source 2349 * 2350 * Support from version 4. Users need free the returned manifest manually. 2351 */ 2352 static int manifest_new_ver(struct soc_tplg *tplg, 2353 struct snd_soc_tplg_manifest *src, 2354 struct snd_soc_tplg_manifest **manifest) 2355 { 2356 struct snd_soc_tplg_manifest *dest; 2357 struct snd_soc_tplg_manifest_v4 *src_v4; 2358 int size; 2359 2360 *manifest = NULL; 2361 2362 size = le32_to_cpu(src->size); 2363 if (size != sizeof(*src_v4)) { 2364 dev_warn(tplg->dev, "ASoC: invalid manifest size %d\n", 2365 size); 2366 if (size) 2367 return -EINVAL; 2368 src->size = cpu_to_le32(sizeof(*src_v4)); 2369 } 2370 2371 dev_warn(tplg->dev, "ASoC: old version of manifest\n"); 2372 2373 src_v4 = (struct snd_soc_tplg_manifest_v4 *)src; 2374 dest = kzalloc(sizeof(*dest) + le32_to_cpu(src_v4->priv.size), 2375 GFP_KERNEL); 2376 if (!dest) 2377 return -ENOMEM; 2378 2379 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 2380 dest->control_elems = src_v4->control_elems; 2381 dest->widget_elems = src_v4->widget_elems; 2382 dest->graph_elems = src_v4->graph_elems; 2383 dest->pcm_elems = src_v4->pcm_elems; 2384 dest->dai_link_elems = src_v4->dai_link_elems; 2385 dest->priv.size = src_v4->priv.size; 2386 if (dest->priv.size) 2387 memcpy(dest->priv.data, src_v4->priv.data, 2388 le32_to_cpu(src_v4->priv.size)); 2389 2390 *manifest = dest; 2391 return 0; 2392 } 2393 2394 static int soc_tplg_manifest_load(struct soc_tplg *tplg, 2395 struct snd_soc_tplg_hdr *hdr) 2396 { 2397 struct snd_soc_tplg_manifest *manifest, *_manifest; 2398 bool abi_match; 2399 int ret = 0; 2400 2401 manifest = (struct snd_soc_tplg_manifest *)tplg->pos; 2402 2403 /* check ABI version by size, create a new manifest if abi not match */ 2404 if (le32_to_cpu(manifest->size) == sizeof(*manifest)) { 2405 abi_match = true; 2406 _manifest = manifest; 2407 } else { 2408 abi_match = false; 2409 2410 ret = manifest_new_ver(tplg, manifest, &_manifest); 2411 if (ret < 0) 2412 return ret; 2413 } 2414 2415 /* pass control to component driver for optional further init */ 2416 if (tplg->ops && tplg->ops->manifest) 2417 ret = tplg->ops->manifest(tplg->comp, tplg->index, _manifest); 2418 2419 if (!abi_match) /* free the duplicated one */ 2420 kfree(_manifest); 2421 2422 return ret; 2423 } 2424 2425 /* validate header magic, size and type */ 2426 static int soc_valid_header(struct soc_tplg *tplg, 2427 struct snd_soc_tplg_hdr *hdr) 2428 { 2429 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size) 2430 return 0; 2431 2432 if (le32_to_cpu(hdr->size) != sizeof(*hdr)) { 2433 dev_err(tplg->dev, 2434 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n", 2435 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2436 tplg->fw->size); 2437 return -EINVAL; 2438 } 2439 2440 if (soc_tplg_get_hdr_offset(tplg) + hdr->payload_size >= tplg->fw->size) { 2441 dev_err(tplg->dev, 2442 "ASoC: invalid header of type %d at offset %ld payload_size %d\n", 2443 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2444 hdr->payload_size); 2445 return -EINVAL; 2446 } 2447 2448 /* big endian firmware objects not supported atm */ 2449 if (le32_to_cpu(hdr->magic) == SOC_TPLG_MAGIC_BIG_ENDIAN) { 2450 dev_err(tplg->dev, 2451 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", 2452 tplg->pass, hdr->magic, 2453 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2454 return -EINVAL; 2455 } 2456 2457 if (le32_to_cpu(hdr->magic) != SND_SOC_TPLG_MAGIC) { 2458 dev_err(tplg->dev, 2459 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n", 2460 tplg->pass, hdr->magic, 2461 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2462 return -EINVAL; 2463 } 2464 2465 /* Support ABI from version 4 */ 2466 if (le32_to_cpu(hdr->abi) > SND_SOC_TPLG_ABI_VERSION || 2467 le32_to_cpu(hdr->abi) < SND_SOC_TPLG_ABI_VERSION_MIN) { 2468 dev_err(tplg->dev, 2469 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n", 2470 tplg->pass, hdr->abi, 2471 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg), 2472 tplg->fw->size); 2473 return -EINVAL; 2474 } 2475 2476 if (hdr->payload_size == 0) { 2477 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n", 2478 soc_tplg_get_hdr_offset(tplg)); 2479 return -EINVAL; 2480 } 2481 2482 return 1; 2483 } 2484 2485 /* check header type and call appropriate handler */ 2486 static int soc_tplg_load_header(struct soc_tplg *tplg, 2487 struct snd_soc_tplg_hdr *hdr) 2488 { 2489 int (*elem_load)(struct soc_tplg *tplg, 2490 struct snd_soc_tplg_hdr *hdr); 2491 unsigned int hdr_pass; 2492 2493 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr); 2494 2495 tplg->index = le32_to_cpu(hdr->index); 2496 2497 switch (le32_to_cpu(hdr->type)) { 2498 case SND_SOC_TPLG_TYPE_MIXER: 2499 case SND_SOC_TPLG_TYPE_ENUM: 2500 case SND_SOC_TPLG_TYPE_BYTES: 2501 hdr_pass = SOC_TPLG_PASS_MIXER; 2502 elem_load = soc_tplg_kcontrol_elems_load; 2503 break; 2504 case SND_SOC_TPLG_TYPE_DAPM_GRAPH: 2505 hdr_pass = SOC_TPLG_PASS_GRAPH; 2506 elem_load = soc_tplg_dapm_graph_elems_load; 2507 break; 2508 case SND_SOC_TPLG_TYPE_DAPM_WIDGET: 2509 hdr_pass = SOC_TPLG_PASS_WIDGET; 2510 elem_load = soc_tplg_dapm_widget_elems_load; 2511 break; 2512 case SND_SOC_TPLG_TYPE_PCM: 2513 hdr_pass = SOC_TPLG_PASS_PCM_DAI; 2514 elem_load = soc_tplg_pcm_elems_load; 2515 break; 2516 case SND_SOC_TPLG_TYPE_DAI: 2517 hdr_pass = SOC_TPLG_PASS_BE_DAI; 2518 elem_load = soc_tplg_dai_elems_load; 2519 break; 2520 case SND_SOC_TPLG_TYPE_DAI_LINK: 2521 case SND_SOC_TPLG_TYPE_BACKEND_LINK: 2522 /* physical link configurations */ 2523 hdr_pass = SOC_TPLG_PASS_LINK; 2524 elem_load = soc_tplg_link_elems_load; 2525 break; 2526 case SND_SOC_TPLG_TYPE_MANIFEST: 2527 hdr_pass = SOC_TPLG_PASS_MANIFEST; 2528 elem_load = soc_tplg_manifest_load; 2529 break; 2530 default: 2531 /* bespoke vendor data object */ 2532 hdr_pass = SOC_TPLG_PASS_VENDOR; 2533 elem_load = soc_tplg_vendor_load; 2534 break; 2535 } 2536 2537 if (tplg->pass == hdr_pass) { 2538 dev_dbg(tplg->dev, 2539 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n", 2540 hdr->payload_size, hdr->type, hdr->version, 2541 hdr->vendor_type, tplg->pass); 2542 return elem_load(tplg, hdr); 2543 } 2544 2545 return 0; 2546 } 2547 2548 /* process the topology file headers */ 2549 static int soc_tplg_process_headers(struct soc_tplg *tplg) 2550 { 2551 int ret; 2552 2553 tplg->pass = SOC_TPLG_PASS_START; 2554 2555 /* process the header types from start to end */ 2556 while (tplg->pass <= SOC_TPLG_PASS_END) { 2557 struct snd_soc_tplg_hdr *hdr; 2558 2559 tplg->hdr_pos = tplg->fw->data; 2560 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2561 2562 while (!soc_tplg_is_eof(tplg)) { 2563 2564 /* make sure header is valid before loading */ 2565 ret = soc_valid_header(tplg, hdr); 2566 if (ret < 0) { 2567 dev_err(tplg->dev, 2568 "ASoC: topology: invalid header: %d\n", ret); 2569 return ret; 2570 } else if (ret == 0) { 2571 break; 2572 } 2573 2574 /* load the header object */ 2575 ret = soc_tplg_load_header(tplg, hdr); 2576 if (ret < 0) { 2577 dev_err(tplg->dev, 2578 "ASoC: topology: could not load header: %d\n", ret); 2579 return ret; 2580 } 2581 2582 /* goto next header */ 2583 tplg->hdr_pos += le32_to_cpu(hdr->payload_size) + 2584 sizeof(struct snd_soc_tplg_hdr); 2585 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2586 } 2587 2588 /* next data type pass */ 2589 tplg->pass++; 2590 } 2591 2592 /* signal DAPM we are complete */ 2593 ret = soc_tplg_dapm_complete(tplg); 2594 if (ret < 0) 2595 dev_err(tplg->dev, 2596 "ASoC: failed to initialise DAPM from Firmware\n"); 2597 2598 return ret; 2599 } 2600 2601 static int soc_tplg_load(struct soc_tplg *tplg) 2602 { 2603 int ret; 2604 2605 ret = soc_tplg_process_headers(tplg); 2606 if (ret == 0) 2607 return soc_tplg_complete(tplg); 2608 2609 return ret; 2610 } 2611 2612 /* load audio component topology from "firmware" file */ 2613 int snd_soc_tplg_component_load(struct snd_soc_component *comp, 2614 struct snd_soc_tplg_ops *ops, const struct firmware *fw) 2615 { 2616 struct soc_tplg tplg; 2617 int ret; 2618 2619 /* 2620 * check if we have sane parameters: 2621 * comp - needs to exist to keep and reference data while parsing 2622 * comp->card - used for setting card related parameters 2623 * comp->card->dev - used for resource management and prints 2624 * fw - we need it, as it is the very thing we parse 2625 */ 2626 if (!comp || !comp->card || !comp->card->dev || !fw) 2627 return -EINVAL; 2628 2629 /* setup parsing context */ 2630 memset(&tplg, 0, sizeof(tplg)); 2631 tplg.fw = fw; 2632 tplg.dev = comp->card->dev; 2633 tplg.comp = comp; 2634 if (ops) { 2635 tplg.ops = ops; 2636 tplg.io_ops = ops->io_ops; 2637 tplg.io_ops_count = ops->io_ops_count; 2638 tplg.bytes_ext_ops = ops->bytes_ext_ops; 2639 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; 2640 } 2641 2642 ret = soc_tplg_load(&tplg); 2643 /* free the created components if fail to load topology */ 2644 if (ret) 2645 snd_soc_tplg_component_remove(comp); 2646 2647 return ret; 2648 } 2649 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load); 2650 2651 /* remove dynamic controls from the component driver */ 2652 int snd_soc_tplg_component_remove(struct snd_soc_component *comp) 2653 { 2654 struct snd_card *card = comp->card->snd_card; 2655 struct snd_soc_dobj *dobj, *next_dobj; 2656 int pass = SOC_TPLG_PASS_END; 2657 2658 /* process the header types from end to start */ 2659 while (pass >= SOC_TPLG_PASS_START) { 2660 2661 /* remove mixer controls */ 2662 down_write(&card->controls_rwsem); 2663 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list, 2664 list) { 2665 2666 switch (dobj->type) { 2667 case SND_SOC_DOBJ_MIXER: 2668 remove_mixer(comp, dobj, pass); 2669 break; 2670 case SND_SOC_DOBJ_ENUM: 2671 remove_enum(comp, dobj, pass); 2672 break; 2673 case SND_SOC_DOBJ_BYTES: 2674 remove_bytes(comp, dobj, pass); 2675 break; 2676 case SND_SOC_DOBJ_GRAPH: 2677 remove_route(comp, dobj, pass); 2678 break; 2679 case SND_SOC_DOBJ_WIDGET: 2680 remove_widget(comp, dobj, pass); 2681 break; 2682 case SND_SOC_DOBJ_PCM: 2683 remove_dai(comp, dobj, pass); 2684 break; 2685 case SND_SOC_DOBJ_DAI_LINK: 2686 remove_link(comp, dobj, pass); 2687 break; 2688 case SND_SOC_DOBJ_BACKEND_LINK: 2689 /* 2690 * call link_unload ops if extra 2691 * deinitialization is needed. 2692 */ 2693 remove_backend_link(comp, dobj, pass); 2694 break; 2695 default: 2696 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n", 2697 dobj->type); 2698 break; 2699 } 2700 } 2701 up_write(&card->controls_rwsem); 2702 pass--; 2703 } 2704 2705 /* let caller know if FW can be freed when no objects are left */ 2706 return !list_empty(&comp->dobj_list); 2707 } 2708 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove); 2709