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 ret = -ENOMEM; 1406 goto hdr_err; 1407 } 1408 1409 kcontrol_type = devm_kcalloc(tplg->dev, le32_to_cpu(w->num_kcontrols), sizeof(unsigned int), 1410 GFP_KERNEL); 1411 if (!kcontrol_type) { 1412 ret = -ENOMEM; 1413 goto hdr_err; 1414 } 1415 1416 for (i = 0; i < le32_to_cpu(w->num_kcontrols); i++) { 1417 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1418 switch (le32_to_cpu(control_hdr->ops.info)) { 1419 case SND_SOC_TPLG_CTL_VOLSW: 1420 case SND_SOC_TPLG_CTL_STROBE: 1421 case SND_SOC_TPLG_CTL_VOLSW_SX: 1422 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1423 case SND_SOC_TPLG_CTL_RANGE: 1424 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1425 /* volume mixer */ 1426 kc[i].index = mixer_count; 1427 kcontrol_type[i] = SND_SOC_TPLG_TYPE_MIXER; 1428 mixer_count++; 1429 ret = soc_tplg_dapm_widget_dmixer_create(tplg, &kc[i]); 1430 if (ret < 0) 1431 goto hdr_err; 1432 break; 1433 case SND_SOC_TPLG_CTL_ENUM: 1434 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1435 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1436 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1437 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1438 /* enumerated mixer */ 1439 kc[i].index = enum_count; 1440 kcontrol_type[i] = SND_SOC_TPLG_TYPE_ENUM; 1441 enum_count++; 1442 ret = soc_tplg_dapm_widget_denum_create(tplg, &kc[i]); 1443 if (ret < 0) 1444 goto hdr_err; 1445 break; 1446 case SND_SOC_TPLG_CTL_BYTES: 1447 /* bytes control */ 1448 kc[i].index = bytes_count; 1449 kcontrol_type[i] = SND_SOC_TPLG_TYPE_BYTES; 1450 bytes_count++; 1451 ret = soc_tplg_dapm_widget_dbytes_create(tplg, &kc[i]); 1452 if (ret < 0) 1453 goto hdr_err; 1454 break; 1455 default: 1456 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n", 1457 control_hdr->ops.get, control_hdr->ops.put, 1458 le32_to_cpu(control_hdr->ops.info)); 1459 ret = -EINVAL; 1460 goto hdr_err; 1461 } 1462 } 1463 1464 template.kcontrol_news = kc; 1465 dev_dbg(tplg->dev, "ASoC: template %s with %d/%d/%d (mixer/enum/bytes) control\n", 1466 w->name, mixer_count, enum_count, bytes_count); 1467 1468 widget: 1469 ret = soc_tplg_widget_load(tplg, &template, w); 1470 if (ret < 0) 1471 goto hdr_err; 1472 1473 /* card dapm mutex is held by the core if we are loading topology 1474 * data during sound card init. */ 1475 if (card->instantiated) 1476 widget = snd_soc_dapm_new_control(dapm, &template); 1477 else 1478 widget = snd_soc_dapm_new_control_unlocked(dapm, &template); 1479 if (IS_ERR(widget)) { 1480 ret = PTR_ERR(widget); 1481 goto hdr_err; 1482 } 1483 1484 widget->dobj.type = SND_SOC_DOBJ_WIDGET; 1485 widget->dobj.widget.kcontrol_type = kcontrol_type; 1486 widget->dobj.ops = tplg->ops; 1487 widget->dobj.index = tplg->index; 1488 list_add(&widget->dobj.list, &tplg->comp->dobj_list); 1489 1490 ret = soc_tplg_widget_ready(tplg, widget, w); 1491 if (ret < 0) 1492 goto ready_err; 1493 1494 kfree(template.sname); 1495 kfree(template.name); 1496 1497 return 0; 1498 1499 ready_err: 1500 remove_widget(widget->dapm->component, &widget->dobj, SOC_TPLG_PASS_WIDGET); 1501 snd_soc_dapm_free_widget(widget); 1502 hdr_err: 1503 kfree(template.sname); 1504 err: 1505 kfree(template.name); 1506 return ret; 1507 } 1508 1509 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg, 1510 struct snd_soc_tplg_hdr *hdr) 1511 { 1512 int count, i; 1513 1514 count = le32_to_cpu(hdr->count); 1515 1516 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count); 1517 1518 for (i = 0; i < count; i++) { 1519 struct snd_soc_tplg_dapm_widget *widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos; 1520 int ret; 1521 1522 /* 1523 * check if widget itself fits within topology file 1524 * use sizeof instead of widget->size, as we can't be sure 1525 * it is set properly yet (file may end before it is present) 1526 */ 1527 if (soc_tplg_get_offset(tplg) + sizeof(*widget) >= tplg->fw->size) { 1528 dev_err(tplg->dev, "ASoC: invalid widget data size\n"); 1529 return -EINVAL; 1530 } 1531 1532 /* check if widget has proper size */ 1533 if (le32_to_cpu(widget->size) != sizeof(*widget)) { 1534 dev_err(tplg->dev, "ASoC: invalid widget size\n"); 1535 return -EINVAL; 1536 } 1537 1538 /* check if widget private data fits within topology file */ 1539 if (soc_tplg_get_offset(tplg) + le32_to_cpu(widget->priv.size) >= tplg->fw->size) { 1540 dev_err(tplg->dev, "ASoC: invalid widget private data size\n"); 1541 return -EINVAL; 1542 } 1543 1544 ret = soc_tplg_dapm_widget_create(tplg, widget); 1545 if (ret < 0) { 1546 dev_err(tplg->dev, "ASoC: failed to load widget %s\n", 1547 widget->name); 1548 return ret; 1549 } 1550 } 1551 1552 return 0; 1553 } 1554 1555 static int soc_tplg_dapm_complete(struct soc_tplg *tplg) 1556 { 1557 struct snd_soc_card *card = tplg->comp->card; 1558 int ret; 1559 1560 /* Card might not have been registered at this point. 1561 * If so, just return success. 1562 */ 1563 if (!card || !card->instantiated) { 1564 dev_warn(tplg->dev, "ASoC: Parent card not yet available," 1565 " widget card binding deferred\n"); 1566 return 0; 1567 } 1568 1569 ret = snd_soc_dapm_new_widgets(card); 1570 if (ret < 0) 1571 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n", 1572 ret); 1573 1574 return 0; 1575 } 1576 1577 static int set_stream_info(struct soc_tplg *tplg, struct snd_soc_pcm_stream *stream, 1578 struct snd_soc_tplg_stream_caps *caps) 1579 { 1580 stream->stream_name = devm_kstrdup(tplg->dev, caps->name, GFP_KERNEL); 1581 if (!stream->stream_name) 1582 return -ENOMEM; 1583 1584 stream->channels_min = le32_to_cpu(caps->channels_min); 1585 stream->channels_max = le32_to_cpu(caps->channels_max); 1586 stream->rates = le32_to_cpu(caps->rates); 1587 stream->rate_min = le32_to_cpu(caps->rate_min); 1588 stream->rate_max = le32_to_cpu(caps->rate_max); 1589 stream->formats = le64_to_cpu(caps->formats); 1590 stream->sig_bits = le32_to_cpu(caps->sig_bits); 1591 1592 return 0; 1593 } 1594 1595 static void set_dai_flags(struct snd_soc_dai_driver *dai_drv, 1596 unsigned int flag_mask, unsigned int flags) 1597 { 1598 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) 1599 dai_drv->symmetric_rate = 1600 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) ? 1 : 0; 1601 1602 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) 1603 dai_drv->symmetric_channels = 1604 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) ? 1605 1 : 0; 1606 1607 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) 1608 dai_drv->symmetric_sample_bits = 1609 (flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) ? 1610 1 : 0; 1611 } 1612 1613 static int soc_tplg_dai_create(struct soc_tplg *tplg, 1614 struct snd_soc_tplg_pcm *pcm) 1615 { 1616 struct snd_soc_dai_driver *dai_drv; 1617 struct snd_soc_pcm_stream *stream; 1618 struct snd_soc_tplg_stream_caps *caps; 1619 struct snd_soc_dai *dai; 1620 struct snd_soc_dapm_context *dapm = 1621 snd_soc_component_get_dapm(tplg->comp); 1622 int ret; 1623 1624 dai_drv = devm_kzalloc(tplg->dev, sizeof(struct snd_soc_dai_driver), GFP_KERNEL); 1625 if (dai_drv == NULL) 1626 return -ENOMEM; 1627 1628 if (strlen(pcm->dai_name)) { 1629 dai_drv->name = devm_kstrdup(tplg->dev, pcm->dai_name, GFP_KERNEL); 1630 if (!dai_drv->name) { 1631 ret = -ENOMEM; 1632 goto err; 1633 } 1634 } 1635 dai_drv->id = le32_to_cpu(pcm->dai_id); 1636 1637 if (pcm->playback) { 1638 stream = &dai_drv->playback; 1639 caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 1640 ret = set_stream_info(tplg, stream, caps); 1641 if (ret < 0) 1642 goto err; 1643 } 1644 1645 if (pcm->capture) { 1646 stream = &dai_drv->capture; 1647 caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 1648 ret = set_stream_info(tplg, stream, caps); 1649 if (ret < 0) 1650 goto err; 1651 } 1652 1653 if (pcm->compress) 1654 dai_drv->compress_new = snd_soc_new_compress; 1655 1656 /* pass control to component driver for optional further init */ 1657 ret = soc_tplg_dai_load(tplg, dai_drv, pcm, NULL); 1658 if (ret < 0) { 1659 dev_err(tplg->dev, "ASoC: DAI loading failed\n"); 1660 goto err; 1661 } 1662 1663 dai_drv->dobj.index = tplg->index; 1664 dai_drv->dobj.ops = tplg->ops; 1665 dai_drv->dobj.type = SND_SOC_DOBJ_PCM; 1666 list_add(&dai_drv->dobj.list, &tplg->comp->dobj_list); 1667 1668 /* register the DAI to the component */ 1669 dai = snd_soc_register_dai(tplg->comp, dai_drv, false); 1670 if (!dai) 1671 return -ENOMEM; 1672 1673 /* Create the DAI widgets here */ 1674 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 1675 if (ret != 0) { 1676 dev_err(dai->dev, "Failed to create DAI widgets %d\n", ret); 1677 snd_soc_unregister_dai(dai); 1678 return ret; 1679 } 1680 1681 return 0; 1682 1683 err: 1684 return ret; 1685 } 1686 1687 static void set_link_flags(struct snd_soc_dai_link *link, 1688 unsigned int flag_mask, unsigned int flags) 1689 { 1690 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES) 1691 link->symmetric_rate = 1692 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES) ? 1 : 0; 1693 1694 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS) 1695 link->symmetric_channels = 1696 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS) ? 1697 1 : 0; 1698 1699 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS) 1700 link->symmetric_sample_bits = 1701 (flags & SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS) ? 1702 1 : 0; 1703 1704 if (flag_mask & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP) 1705 link->ignore_suspend = 1706 (flags & SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP) ? 1707 1 : 0; 1708 } 1709 1710 /* create the FE DAI link */ 1711 static int soc_tplg_fe_link_create(struct soc_tplg *tplg, 1712 struct snd_soc_tplg_pcm *pcm) 1713 { 1714 struct snd_soc_dai_link *link; 1715 struct snd_soc_dai_link_component *dlc; 1716 int ret; 1717 1718 /* link + cpu + codec + platform */ 1719 link = devm_kzalloc(tplg->dev, sizeof(*link) + (3 * sizeof(*dlc)), GFP_KERNEL); 1720 if (link == NULL) 1721 return -ENOMEM; 1722 1723 dlc = (struct snd_soc_dai_link_component *)(link + 1); 1724 1725 link->cpus = &dlc[0]; 1726 link->codecs = &dlc[1]; 1727 link->platforms = &dlc[2]; 1728 1729 link->num_cpus = 1; 1730 link->num_codecs = 1; 1731 link->num_platforms = 1; 1732 1733 link->dobj.index = tplg->index; 1734 link->dobj.ops = tplg->ops; 1735 link->dobj.type = SND_SOC_DOBJ_DAI_LINK; 1736 1737 if (strlen(pcm->pcm_name)) { 1738 link->name = devm_kstrdup(tplg->dev, pcm->pcm_name, GFP_KERNEL); 1739 link->stream_name = devm_kstrdup(tplg->dev, pcm->pcm_name, GFP_KERNEL); 1740 if (!link->name || !link->stream_name) { 1741 ret = -ENOMEM; 1742 goto err; 1743 } 1744 } 1745 link->id = le32_to_cpu(pcm->pcm_id); 1746 1747 if (strlen(pcm->dai_name)) { 1748 link->cpus->dai_name = devm_kstrdup(tplg->dev, pcm->dai_name, GFP_KERNEL); 1749 if (!link->cpus->dai_name) { 1750 ret = -ENOMEM; 1751 goto err; 1752 } 1753 } 1754 1755 link->codecs->name = "snd-soc-dummy"; 1756 link->codecs->dai_name = "snd-soc-dummy-dai"; 1757 1758 link->platforms->name = "snd-soc-dummy"; 1759 1760 /* enable DPCM */ 1761 link->dynamic = 1; 1762 link->ignore_pmdown_time = 1; 1763 link->dpcm_playback = le32_to_cpu(pcm->playback); 1764 link->dpcm_capture = le32_to_cpu(pcm->capture); 1765 if (pcm->flag_mask) 1766 set_link_flags(link, 1767 le32_to_cpu(pcm->flag_mask), 1768 le32_to_cpu(pcm->flags)); 1769 1770 /* pass control to component driver for optional further init */ 1771 ret = soc_tplg_dai_link_load(tplg, link, NULL); 1772 if (ret < 0) { 1773 dev_err(tplg->dev, "ASoC: FE link loading failed\n"); 1774 goto err; 1775 } 1776 1777 ret = snd_soc_add_pcm_runtime(tplg->comp->card, link); 1778 if (ret < 0) { 1779 dev_err(tplg->dev, "ASoC: adding FE link failed\n"); 1780 goto err; 1781 } 1782 1783 list_add(&link->dobj.list, &tplg->comp->dobj_list); 1784 1785 return 0; 1786 err: 1787 return ret; 1788 } 1789 1790 /* create a FE DAI and DAI link from the PCM object */ 1791 static int soc_tplg_pcm_create(struct soc_tplg *tplg, 1792 struct snd_soc_tplg_pcm *pcm) 1793 { 1794 int ret; 1795 1796 ret = soc_tplg_dai_create(tplg, pcm); 1797 if (ret < 0) 1798 return ret; 1799 1800 return soc_tplg_fe_link_create(tplg, pcm); 1801 } 1802 1803 /* copy stream caps from the old version 4 of source */ 1804 static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps *dest, 1805 struct snd_soc_tplg_stream_caps_v4 *src) 1806 { 1807 dest->size = cpu_to_le32(sizeof(*dest)); 1808 memcpy(dest->name, src->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1809 dest->formats = src->formats; 1810 dest->rates = src->rates; 1811 dest->rate_min = src->rate_min; 1812 dest->rate_max = src->rate_max; 1813 dest->channels_min = src->channels_min; 1814 dest->channels_max = src->channels_max; 1815 dest->periods_min = src->periods_min; 1816 dest->periods_max = src->periods_max; 1817 dest->period_size_min = src->period_size_min; 1818 dest->period_size_max = src->period_size_max; 1819 dest->buffer_size_min = src->buffer_size_min; 1820 dest->buffer_size_max = src->buffer_size_max; 1821 } 1822 1823 /** 1824 * pcm_new_ver - Create the new version of PCM from the old version. 1825 * @tplg: topology context 1826 * @src: older version of pcm as a source 1827 * @pcm: latest version of pcm created from the source 1828 * 1829 * Support from version 4. User should free the returned pcm manually. 1830 */ 1831 static int pcm_new_ver(struct soc_tplg *tplg, 1832 struct snd_soc_tplg_pcm *src, 1833 struct snd_soc_tplg_pcm **pcm) 1834 { 1835 struct snd_soc_tplg_pcm *dest; 1836 struct snd_soc_tplg_pcm_v4 *src_v4; 1837 int i; 1838 1839 *pcm = NULL; 1840 1841 if (le32_to_cpu(src->size) != sizeof(*src_v4)) { 1842 dev_err(tplg->dev, "ASoC: invalid PCM size\n"); 1843 return -EINVAL; 1844 } 1845 1846 dev_warn(tplg->dev, "ASoC: old version of PCM\n"); 1847 src_v4 = (struct snd_soc_tplg_pcm_v4 *)src; 1848 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 1849 if (!dest) 1850 return -ENOMEM; 1851 1852 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 1853 memcpy(dest->pcm_name, src_v4->pcm_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1854 memcpy(dest->dai_name, src_v4->dai_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 1855 dest->pcm_id = src_v4->pcm_id; 1856 dest->dai_id = src_v4->dai_id; 1857 dest->playback = src_v4->playback; 1858 dest->capture = src_v4->capture; 1859 dest->compress = src_v4->compress; 1860 dest->num_streams = src_v4->num_streams; 1861 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 1862 memcpy(&dest->stream[i], &src_v4->stream[i], 1863 sizeof(struct snd_soc_tplg_stream)); 1864 1865 for (i = 0; i < 2; i++) 1866 stream_caps_new_ver(&dest->caps[i], &src_v4->caps[i]); 1867 1868 *pcm = dest; 1869 return 0; 1870 } 1871 1872 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, 1873 struct snd_soc_tplg_hdr *hdr) 1874 { 1875 struct snd_soc_tplg_pcm *pcm, *_pcm; 1876 int count; 1877 int size; 1878 int i; 1879 bool abi_match; 1880 int ret; 1881 1882 count = le32_to_cpu(hdr->count); 1883 1884 /* check the element size and count */ 1885 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1886 size = le32_to_cpu(pcm->size); 1887 if (size > sizeof(struct snd_soc_tplg_pcm) 1888 || size < sizeof(struct snd_soc_tplg_pcm_v4)) { 1889 dev_err(tplg->dev, "ASoC: invalid size %d for PCM elems\n", 1890 size); 1891 return -EINVAL; 1892 } 1893 1894 if (soc_tplg_check_elem_count(tplg, 1895 size, count, 1896 le32_to_cpu(hdr->payload_size), 1897 "PCM DAI")) 1898 return -EINVAL; 1899 1900 for (i = 0; i < count; i++) { 1901 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1902 size = le32_to_cpu(pcm->size); 1903 1904 /* check ABI version by size, create a new version of pcm 1905 * if abi not match. 1906 */ 1907 if (size == sizeof(*pcm)) { 1908 abi_match = true; 1909 _pcm = pcm; 1910 } else { 1911 abi_match = false; 1912 ret = pcm_new_ver(tplg, pcm, &_pcm); 1913 if (ret < 0) 1914 return ret; 1915 } 1916 1917 /* create the FE DAIs and DAI links */ 1918 ret = soc_tplg_pcm_create(tplg, _pcm); 1919 if (ret < 0) { 1920 if (!abi_match) 1921 kfree(_pcm); 1922 return ret; 1923 } 1924 1925 /* offset by version-specific struct size and 1926 * real priv data size 1927 */ 1928 tplg->pos += size + le32_to_cpu(_pcm->priv.size); 1929 1930 if (!abi_match) 1931 kfree(_pcm); /* free the duplicated one */ 1932 } 1933 1934 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count); 1935 1936 return 0; 1937 } 1938 1939 /** 1940 * set_link_hw_format - Set the HW audio format of the physical DAI link. 1941 * @link: &snd_soc_dai_link which should be updated 1942 * @cfg: physical link configs. 1943 * 1944 * Topology context contains a list of supported HW formats (configs) and 1945 * a default format ID for the physical link. This function will use this 1946 * default ID to choose the HW format to set the link's DAI format for init. 1947 */ 1948 static void set_link_hw_format(struct snd_soc_dai_link *link, 1949 struct snd_soc_tplg_link_config *cfg) 1950 { 1951 struct snd_soc_tplg_hw_config *hw_config; 1952 unsigned char bclk_provider, fsync_provider; 1953 unsigned char invert_bclk, invert_fsync; 1954 int i; 1955 1956 for (i = 0; i < le32_to_cpu(cfg->num_hw_configs); i++) { 1957 hw_config = &cfg->hw_config[i]; 1958 if (hw_config->id != cfg->default_hw_config_id) 1959 continue; 1960 1961 link->dai_fmt = le32_to_cpu(hw_config->fmt) & 1962 SND_SOC_DAIFMT_FORMAT_MASK; 1963 1964 /* clock gating */ 1965 switch (hw_config->clock_gated) { 1966 case SND_SOC_TPLG_DAI_CLK_GATE_GATED: 1967 link->dai_fmt |= SND_SOC_DAIFMT_GATED; 1968 break; 1969 1970 case SND_SOC_TPLG_DAI_CLK_GATE_CONT: 1971 link->dai_fmt |= SND_SOC_DAIFMT_CONT; 1972 break; 1973 1974 default: 1975 /* ignore the value */ 1976 break; 1977 } 1978 1979 /* clock signal polarity */ 1980 invert_bclk = hw_config->invert_bclk; 1981 invert_fsync = hw_config->invert_fsync; 1982 if (!invert_bclk && !invert_fsync) 1983 link->dai_fmt |= SND_SOC_DAIFMT_NB_NF; 1984 else if (!invert_bclk && invert_fsync) 1985 link->dai_fmt |= SND_SOC_DAIFMT_NB_IF; 1986 else if (invert_bclk && !invert_fsync) 1987 link->dai_fmt |= SND_SOC_DAIFMT_IB_NF; 1988 else 1989 link->dai_fmt |= SND_SOC_DAIFMT_IB_IF; 1990 1991 /* clock masters */ 1992 bclk_provider = (hw_config->bclk_provider == 1993 SND_SOC_TPLG_BCLK_CP); 1994 fsync_provider = (hw_config->fsync_provider == 1995 SND_SOC_TPLG_FSYNC_CP); 1996 if (bclk_provider && fsync_provider) 1997 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFP; 1998 else if (!bclk_provider && fsync_provider) 1999 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFP; 2000 else if (bclk_provider && !fsync_provider) 2001 link->dai_fmt |= SND_SOC_DAIFMT_CBP_CFC; 2002 else 2003 link->dai_fmt |= SND_SOC_DAIFMT_CBC_CFC; 2004 } 2005 } 2006 2007 /** 2008 * link_new_ver - Create a new physical link config from the old 2009 * version of source. 2010 * @tplg: topology context 2011 * @src: old version of phyical link config as a source 2012 * @link: latest version of physical link config created from the source 2013 * 2014 * Support from version 4. User need free the returned link config manually. 2015 */ 2016 static int link_new_ver(struct soc_tplg *tplg, 2017 struct snd_soc_tplg_link_config *src, 2018 struct snd_soc_tplg_link_config **link) 2019 { 2020 struct snd_soc_tplg_link_config *dest; 2021 struct snd_soc_tplg_link_config_v4 *src_v4; 2022 int i; 2023 2024 *link = NULL; 2025 2026 if (le32_to_cpu(src->size) != 2027 sizeof(struct snd_soc_tplg_link_config_v4)) { 2028 dev_err(tplg->dev, "ASoC: invalid physical link config size\n"); 2029 return -EINVAL; 2030 } 2031 2032 dev_warn(tplg->dev, "ASoC: old version of physical link config\n"); 2033 2034 src_v4 = (struct snd_soc_tplg_link_config_v4 *)src; 2035 dest = kzalloc(sizeof(*dest), GFP_KERNEL); 2036 if (!dest) 2037 return -ENOMEM; 2038 2039 dest->size = cpu_to_le32(sizeof(*dest)); 2040 dest->id = src_v4->id; 2041 dest->num_streams = src_v4->num_streams; 2042 for (i = 0; i < le32_to_cpu(dest->num_streams); i++) 2043 memcpy(&dest->stream[i], &src_v4->stream[i], 2044 sizeof(struct snd_soc_tplg_stream)); 2045 2046 *link = dest; 2047 return 0; 2048 } 2049 2050 /** 2051 * snd_soc_find_dai_link - Find a DAI link 2052 * 2053 * @card: soc card 2054 * @id: DAI link ID to match 2055 * @name: DAI link name to match, optional 2056 * @stream_name: DAI link stream name to match, optional 2057 * 2058 * This function will search all existing DAI links of the soc card to 2059 * find the link of the same ID. Since DAI links may not have their 2060 * unique ID, so name and stream name should also match if being 2061 * specified. 2062 * 2063 * Return: pointer of DAI link, or NULL if not found. 2064 */ 2065 static struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card, 2066 int id, const char *name, 2067 const char *stream_name) 2068 { 2069 struct snd_soc_pcm_runtime *rtd; 2070 2071 for_each_card_rtds(card, rtd) { 2072 struct snd_soc_dai_link *link = rtd->dai_link; 2073 2074 if (link->id != id) 2075 continue; 2076 2077 if (name && (!link->name || strcmp(name, link->name))) 2078 continue; 2079 2080 if (stream_name && (!link->stream_name 2081 || strcmp(stream_name, link->stream_name))) 2082 continue; 2083 2084 return link; 2085 } 2086 2087 return NULL; 2088 } 2089 2090 /* Find and configure an existing physical DAI link */ 2091 static int soc_tplg_link_config(struct soc_tplg *tplg, 2092 struct snd_soc_tplg_link_config *cfg) 2093 { 2094 struct snd_soc_dai_link *link; 2095 const char *name, *stream_name; 2096 size_t len; 2097 int ret; 2098 2099 len = strnlen(cfg->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2100 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2101 return -EINVAL; 2102 else if (len) 2103 name = cfg->name; 2104 else 2105 name = NULL; 2106 2107 len = strnlen(cfg->stream_name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); 2108 if (len == SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 2109 return -EINVAL; 2110 else if (len) 2111 stream_name = cfg->stream_name; 2112 else 2113 stream_name = NULL; 2114 2115 link = snd_soc_find_dai_link(tplg->comp->card, le32_to_cpu(cfg->id), 2116 name, stream_name); 2117 if (!link) { 2118 dev_err(tplg->dev, "ASoC: physical link %s (id %d) not exist\n", 2119 name, cfg->id); 2120 return -EINVAL; 2121 } 2122 2123 /* hw format */ 2124 if (cfg->num_hw_configs) 2125 set_link_hw_format(link, cfg); 2126 2127 /* flags */ 2128 if (cfg->flag_mask) 2129 set_link_flags(link, 2130 le32_to_cpu(cfg->flag_mask), 2131 le32_to_cpu(cfg->flags)); 2132 2133 /* pass control to component driver for optional further init */ 2134 ret = soc_tplg_dai_link_load(tplg, link, cfg); 2135 if (ret < 0) { 2136 dev_err(tplg->dev, "ASoC: physical link loading failed\n"); 2137 return ret; 2138 } 2139 2140 /* for unloading it in snd_soc_tplg_component_remove */ 2141 link->dobj.index = tplg->index; 2142 link->dobj.ops = tplg->ops; 2143 link->dobj.type = SND_SOC_DOBJ_BACKEND_LINK; 2144 list_add(&link->dobj.list, &tplg->comp->dobj_list); 2145 2146 return 0; 2147 } 2148 2149 2150 /* Load physical link config elements from the topology context */ 2151 static int soc_tplg_link_elems_load(struct soc_tplg *tplg, 2152 struct snd_soc_tplg_hdr *hdr) 2153 { 2154 struct snd_soc_tplg_link_config *link, *_link; 2155 int count; 2156 int size; 2157 int i, ret; 2158 bool abi_match; 2159 2160 count = le32_to_cpu(hdr->count); 2161 2162 /* check the element size and count */ 2163 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2164 size = le32_to_cpu(link->size); 2165 if (size > sizeof(struct snd_soc_tplg_link_config) 2166 || size < sizeof(struct snd_soc_tplg_link_config_v4)) { 2167 dev_err(tplg->dev, "ASoC: invalid size %d for physical link elems\n", 2168 size); 2169 return -EINVAL; 2170 } 2171 2172 if (soc_tplg_check_elem_count(tplg, size, count, 2173 le32_to_cpu(hdr->payload_size), 2174 "physical link config")) 2175 return -EINVAL; 2176 2177 /* config physical DAI links */ 2178 for (i = 0; i < count; i++) { 2179 link = (struct snd_soc_tplg_link_config *)tplg->pos; 2180 size = le32_to_cpu(link->size); 2181 if (size == sizeof(*link)) { 2182 abi_match = true; 2183 _link = link; 2184 } else { 2185 abi_match = false; 2186 ret = link_new_ver(tplg, link, &_link); 2187 if (ret < 0) 2188 return ret; 2189 } 2190 2191 ret = soc_tplg_link_config(tplg, _link); 2192 if (ret < 0) { 2193 if (!abi_match) 2194 kfree(_link); 2195 return ret; 2196 } 2197 2198 /* offset by version-specific struct size and 2199 * real priv data size 2200 */ 2201 tplg->pos += size + le32_to_cpu(_link->priv.size); 2202 2203 if (!abi_match) 2204 kfree(_link); /* free the duplicated one */ 2205 } 2206 2207 return 0; 2208 } 2209 2210 /** 2211 * soc_tplg_dai_config - Find and configure an existing physical DAI. 2212 * @tplg: topology context 2213 * @d: physical DAI configs. 2214 * 2215 * The physical dai should already be registered by the platform driver. 2216 * The platform driver should specify the DAI name and ID for matching. 2217 */ 2218 static int soc_tplg_dai_config(struct soc_tplg *tplg, 2219 struct snd_soc_tplg_dai *d) 2220 { 2221 struct snd_soc_dai_link_component dai_component; 2222 struct snd_soc_dai *dai; 2223 struct snd_soc_dai_driver *dai_drv; 2224 struct snd_soc_pcm_stream *stream; 2225 struct snd_soc_tplg_stream_caps *caps; 2226 int ret; 2227 2228 memset(&dai_component, 0, sizeof(dai_component)); 2229 2230 dai_component.dai_name = d->dai_name; 2231 dai = snd_soc_find_dai(&dai_component); 2232 if (!dai) { 2233 dev_err(tplg->dev, "ASoC: physical DAI %s not registered\n", 2234 d->dai_name); 2235 return -EINVAL; 2236 } 2237 2238 if (le32_to_cpu(d->dai_id) != dai->id) { 2239 dev_err(tplg->dev, "ASoC: physical DAI %s id mismatch\n", 2240 d->dai_name); 2241 return -EINVAL; 2242 } 2243 2244 dai_drv = dai->driver; 2245 if (!dai_drv) 2246 return -EINVAL; 2247 2248 if (d->playback) { 2249 stream = &dai_drv->playback; 2250 caps = &d->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 2251 ret = set_stream_info(tplg, stream, caps); 2252 if (ret < 0) 2253 goto err; 2254 } 2255 2256 if (d->capture) { 2257 stream = &dai_drv->capture; 2258 caps = &d->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 2259 ret = set_stream_info(tplg, stream, caps); 2260 if (ret < 0) 2261 goto err; 2262 } 2263 2264 if (d->flag_mask) 2265 set_dai_flags(dai_drv, 2266 le32_to_cpu(d->flag_mask), 2267 le32_to_cpu(d->flags)); 2268 2269 /* pass control to component driver for optional further init */ 2270 ret = soc_tplg_dai_load(tplg, dai_drv, NULL, dai); 2271 if (ret < 0) { 2272 dev_err(tplg->dev, "ASoC: DAI loading failed\n"); 2273 goto err; 2274 } 2275 2276 return 0; 2277 2278 err: 2279 return ret; 2280 } 2281 2282 /* load physical DAI elements */ 2283 static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, 2284 struct snd_soc_tplg_hdr *hdr) 2285 { 2286 int count; 2287 int i; 2288 2289 count = le32_to_cpu(hdr->count); 2290 2291 /* config the existing BE DAIs */ 2292 for (i = 0; i < count; i++) { 2293 struct snd_soc_tplg_dai *dai = (struct snd_soc_tplg_dai *)tplg->pos; 2294 int ret; 2295 2296 if (le32_to_cpu(dai->size) != sizeof(*dai)) { 2297 dev_err(tplg->dev, "ASoC: invalid physical DAI size\n"); 2298 return -EINVAL; 2299 } 2300 2301 ret = soc_tplg_dai_config(tplg, dai); 2302 if (ret < 0) { 2303 dev_err(tplg->dev, "ASoC: failed to configure DAI\n"); 2304 return ret; 2305 } 2306 2307 tplg->pos += (sizeof(*dai) + le32_to_cpu(dai->priv.size)); 2308 } 2309 2310 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count); 2311 return 0; 2312 } 2313 2314 /** 2315 * manifest_new_ver - Create a new version of manifest from the old version 2316 * of source. 2317 * @tplg: topology context 2318 * @src: old version of manifest as a source 2319 * @manifest: latest version of manifest created from the source 2320 * 2321 * Support from version 4. Users need free the returned manifest manually. 2322 */ 2323 static int manifest_new_ver(struct soc_tplg *tplg, 2324 struct snd_soc_tplg_manifest *src, 2325 struct snd_soc_tplg_manifest **manifest) 2326 { 2327 struct snd_soc_tplg_manifest *dest; 2328 struct snd_soc_tplg_manifest_v4 *src_v4; 2329 int size; 2330 2331 *manifest = NULL; 2332 2333 size = le32_to_cpu(src->size); 2334 if (size != sizeof(*src_v4)) { 2335 dev_warn(tplg->dev, "ASoC: invalid manifest size %d\n", 2336 size); 2337 if (size) 2338 return -EINVAL; 2339 src->size = cpu_to_le32(sizeof(*src_v4)); 2340 } 2341 2342 dev_warn(tplg->dev, "ASoC: old version of manifest\n"); 2343 2344 src_v4 = (struct snd_soc_tplg_manifest_v4 *)src; 2345 dest = kzalloc(sizeof(*dest) + le32_to_cpu(src_v4->priv.size), 2346 GFP_KERNEL); 2347 if (!dest) 2348 return -ENOMEM; 2349 2350 dest->size = cpu_to_le32(sizeof(*dest)); /* size of latest abi version */ 2351 dest->control_elems = src_v4->control_elems; 2352 dest->widget_elems = src_v4->widget_elems; 2353 dest->graph_elems = src_v4->graph_elems; 2354 dest->pcm_elems = src_v4->pcm_elems; 2355 dest->dai_link_elems = src_v4->dai_link_elems; 2356 dest->priv.size = src_v4->priv.size; 2357 if (dest->priv.size) 2358 memcpy(dest->priv.data, src_v4->priv.data, 2359 le32_to_cpu(src_v4->priv.size)); 2360 2361 *manifest = dest; 2362 return 0; 2363 } 2364 2365 static int soc_tplg_manifest_load(struct soc_tplg *tplg, 2366 struct snd_soc_tplg_hdr *hdr) 2367 { 2368 struct snd_soc_tplg_manifest *manifest, *_manifest; 2369 bool abi_match; 2370 int ret = 0; 2371 2372 manifest = (struct snd_soc_tplg_manifest *)tplg->pos; 2373 2374 /* check ABI version by size, create a new manifest if abi not match */ 2375 if (le32_to_cpu(manifest->size) == sizeof(*manifest)) { 2376 abi_match = true; 2377 _manifest = manifest; 2378 } else { 2379 abi_match = false; 2380 2381 ret = manifest_new_ver(tplg, manifest, &_manifest); 2382 if (ret < 0) 2383 return ret; 2384 } 2385 2386 /* pass control to component driver for optional further init */ 2387 if (tplg->ops && tplg->ops->manifest) 2388 ret = tplg->ops->manifest(tplg->comp, tplg->index, _manifest); 2389 2390 if (!abi_match) /* free the duplicated one */ 2391 kfree(_manifest); 2392 2393 return ret; 2394 } 2395 2396 /* validate header magic, size and type */ 2397 static int soc_valid_header(struct soc_tplg *tplg, 2398 struct snd_soc_tplg_hdr *hdr) 2399 { 2400 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size) 2401 return 0; 2402 2403 if (le32_to_cpu(hdr->size) != sizeof(*hdr)) { 2404 dev_err(tplg->dev, 2405 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n", 2406 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2407 tplg->fw->size); 2408 return -EINVAL; 2409 } 2410 2411 if (soc_tplg_get_hdr_offset(tplg) + hdr->payload_size >= tplg->fw->size) { 2412 dev_err(tplg->dev, 2413 "ASoC: invalid header of type %d at offset %ld payload_size %d\n", 2414 le32_to_cpu(hdr->type), soc_tplg_get_hdr_offset(tplg), 2415 hdr->payload_size); 2416 return -EINVAL; 2417 } 2418 2419 /* big endian firmware objects not supported atm */ 2420 if (le32_to_cpu(hdr->magic) == SOC_TPLG_MAGIC_BIG_ENDIAN) { 2421 dev_err(tplg->dev, 2422 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", 2423 tplg->pass, hdr->magic, 2424 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2425 return -EINVAL; 2426 } 2427 2428 if (le32_to_cpu(hdr->magic) != SND_SOC_TPLG_MAGIC) { 2429 dev_err(tplg->dev, 2430 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n", 2431 tplg->pass, hdr->magic, 2432 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 2433 return -EINVAL; 2434 } 2435 2436 /* Support ABI from version 4 */ 2437 if (le32_to_cpu(hdr->abi) > SND_SOC_TPLG_ABI_VERSION || 2438 le32_to_cpu(hdr->abi) < SND_SOC_TPLG_ABI_VERSION_MIN) { 2439 dev_err(tplg->dev, 2440 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n", 2441 tplg->pass, hdr->abi, 2442 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg), 2443 tplg->fw->size); 2444 return -EINVAL; 2445 } 2446 2447 if (hdr->payload_size == 0) { 2448 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n", 2449 soc_tplg_get_hdr_offset(tplg)); 2450 return -EINVAL; 2451 } 2452 2453 return 1; 2454 } 2455 2456 /* check header type and call appropriate handler */ 2457 static int soc_tplg_load_header(struct soc_tplg *tplg, 2458 struct snd_soc_tplg_hdr *hdr) 2459 { 2460 int (*elem_load)(struct soc_tplg *tplg, 2461 struct snd_soc_tplg_hdr *hdr); 2462 unsigned int hdr_pass; 2463 2464 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr); 2465 2466 tplg->index = le32_to_cpu(hdr->index); 2467 2468 switch (le32_to_cpu(hdr->type)) { 2469 case SND_SOC_TPLG_TYPE_MIXER: 2470 case SND_SOC_TPLG_TYPE_ENUM: 2471 case SND_SOC_TPLG_TYPE_BYTES: 2472 hdr_pass = SOC_TPLG_PASS_CONTROL; 2473 elem_load = soc_tplg_kcontrol_elems_load; 2474 break; 2475 case SND_SOC_TPLG_TYPE_DAPM_GRAPH: 2476 hdr_pass = SOC_TPLG_PASS_GRAPH; 2477 elem_load = soc_tplg_dapm_graph_elems_load; 2478 break; 2479 case SND_SOC_TPLG_TYPE_DAPM_WIDGET: 2480 hdr_pass = SOC_TPLG_PASS_WIDGET; 2481 elem_load = soc_tplg_dapm_widget_elems_load; 2482 break; 2483 case SND_SOC_TPLG_TYPE_PCM: 2484 hdr_pass = SOC_TPLG_PASS_PCM_DAI; 2485 elem_load = soc_tplg_pcm_elems_load; 2486 break; 2487 case SND_SOC_TPLG_TYPE_DAI: 2488 hdr_pass = SOC_TPLG_PASS_BE_DAI; 2489 elem_load = soc_tplg_dai_elems_load; 2490 break; 2491 case SND_SOC_TPLG_TYPE_DAI_LINK: 2492 case SND_SOC_TPLG_TYPE_BACKEND_LINK: 2493 /* physical link configurations */ 2494 hdr_pass = SOC_TPLG_PASS_LINK; 2495 elem_load = soc_tplg_link_elems_load; 2496 break; 2497 case SND_SOC_TPLG_TYPE_MANIFEST: 2498 hdr_pass = SOC_TPLG_PASS_MANIFEST; 2499 elem_load = soc_tplg_manifest_load; 2500 break; 2501 default: 2502 /* bespoke vendor data object */ 2503 hdr_pass = SOC_TPLG_PASS_VENDOR; 2504 elem_load = soc_tplg_vendor_load; 2505 break; 2506 } 2507 2508 if (tplg->pass == hdr_pass) { 2509 dev_dbg(tplg->dev, 2510 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n", 2511 hdr->payload_size, hdr->type, hdr->version, 2512 hdr->vendor_type, tplg->pass); 2513 return elem_load(tplg, hdr); 2514 } 2515 2516 return 0; 2517 } 2518 2519 /* process the topology file headers */ 2520 static int soc_tplg_process_headers(struct soc_tplg *tplg) 2521 { 2522 int ret; 2523 2524 /* process the header types from start to end */ 2525 for (tplg->pass = SOC_TPLG_PASS_START; tplg->pass <= SOC_TPLG_PASS_END; tplg->pass++) { 2526 struct snd_soc_tplg_hdr *hdr; 2527 2528 tplg->hdr_pos = tplg->fw->data; 2529 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2530 2531 while (!soc_tplg_is_eof(tplg)) { 2532 2533 /* make sure header is valid before loading */ 2534 ret = soc_valid_header(tplg, hdr); 2535 if (ret < 0) { 2536 dev_err(tplg->dev, 2537 "ASoC: topology: invalid header: %d\n", ret); 2538 return ret; 2539 } else if (ret == 0) { 2540 break; 2541 } 2542 2543 /* load the header object */ 2544 ret = soc_tplg_load_header(tplg, hdr); 2545 if (ret < 0) { 2546 dev_err(tplg->dev, 2547 "ASoC: topology: could not load header: %d\n", ret); 2548 return ret; 2549 } 2550 2551 /* goto next header */ 2552 tplg->hdr_pos += le32_to_cpu(hdr->payload_size) + 2553 sizeof(struct snd_soc_tplg_hdr); 2554 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 2555 } 2556 2557 } 2558 2559 /* signal DAPM we are complete */ 2560 ret = soc_tplg_dapm_complete(tplg); 2561 if (ret < 0) 2562 dev_err(tplg->dev, 2563 "ASoC: failed to initialise DAPM from Firmware\n"); 2564 2565 return ret; 2566 } 2567 2568 static int soc_tplg_load(struct soc_tplg *tplg) 2569 { 2570 int ret; 2571 2572 ret = soc_tplg_process_headers(tplg); 2573 if (ret == 0) 2574 return soc_tplg_complete(tplg); 2575 2576 return ret; 2577 } 2578 2579 /* load audio component topology from "firmware" file */ 2580 int snd_soc_tplg_component_load(struct snd_soc_component *comp, 2581 struct snd_soc_tplg_ops *ops, const struct firmware *fw) 2582 { 2583 struct soc_tplg tplg; 2584 int ret; 2585 2586 /* 2587 * check if we have sane parameters: 2588 * comp - needs to exist to keep and reference data while parsing 2589 * comp->card - used for setting card related parameters 2590 * comp->card->dev - used for resource management and prints 2591 * fw - we need it, as it is the very thing we parse 2592 */ 2593 if (!comp || !comp->card || !comp->card->dev || !fw) 2594 return -EINVAL; 2595 2596 /* setup parsing context */ 2597 memset(&tplg, 0, sizeof(tplg)); 2598 tplg.fw = fw; 2599 tplg.dev = comp->card->dev; 2600 tplg.comp = comp; 2601 if (ops) { 2602 tplg.ops = ops; 2603 tplg.io_ops = ops->io_ops; 2604 tplg.io_ops_count = ops->io_ops_count; 2605 tplg.bytes_ext_ops = ops->bytes_ext_ops; 2606 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; 2607 } 2608 2609 ret = soc_tplg_load(&tplg); 2610 /* free the created components if fail to load topology */ 2611 if (ret) 2612 snd_soc_tplg_component_remove(comp); 2613 2614 return ret; 2615 } 2616 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load); 2617 2618 /* remove dynamic controls from the component driver */ 2619 int snd_soc_tplg_component_remove(struct snd_soc_component *comp) 2620 { 2621 struct snd_card *card = comp->card->snd_card; 2622 struct snd_soc_dobj *dobj, *next_dobj; 2623 int pass; 2624 2625 /* process the header types from end to start */ 2626 for (pass = SOC_TPLG_PASS_END; pass >= SOC_TPLG_PASS_START; pass--) { 2627 2628 /* remove mixer controls */ 2629 down_write(&card->controls_rwsem); 2630 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list, 2631 list) { 2632 2633 switch (dobj->type) { 2634 case SND_SOC_DOBJ_MIXER: 2635 remove_mixer(comp, dobj, pass); 2636 break; 2637 case SND_SOC_DOBJ_ENUM: 2638 remove_enum(comp, dobj, pass); 2639 break; 2640 case SND_SOC_DOBJ_BYTES: 2641 remove_bytes(comp, dobj, pass); 2642 break; 2643 case SND_SOC_DOBJ_GRAPH: 2644 remove_route(comp, dobj, pass); 2645 break; 2646 case SND_SOC_DOBJ_WIDGET: 2647 remove_widget(comp, dobj, pass); 2648 break; 2649 case SND_SOC_DOBJ_PCM: 2650 remove_dai(comp, dobj, pass); 2651 break; 2652 case SND_SOC_DOBJ_DAI_LINK: 2653 remove_link(comp, dobj, pass); 2654 break; 2655 case SND_SOC_DOBJ_BACKEND_LINK: 2656 /* 2657 * call link_unload ops if extra 2658 * deinitialization is needed. 2659 */ 2660 remove_backend_link(comp, dobj, pass); 2661 break; 2662 default: 2663 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n", 2664 dobj->type); 2665 break; 2666 } 2667 } 2668 up_write(&card->controls_rwsem); 2669 } 2670 2671 /* let caller know if FW can be freed when no objects are left */ 2672 return !list_empty(&comp->dobj_list); 2673 } 2674 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove); 2675