1 /* 2 * soc-topology.c -- ALSA SoC Topology 3 * 4 * Copyright (C) 2012 Texas Instruments Inc. 5 * Copyright (C) 2015 Intel Corporation. 6 * 7 * Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com> 8 * K, Mythri P <mythri.p.k@intel.com> 9 * Prusty, Subhransu S <subhransu.s.prusty@intel.com> 10 * B, Jayachandran <jayachandran.b@intel.com> 11 * Abdullah, Omair M <omair.m.abdullah@intel.com> 12 * Jin, Yao <yao.jin@intel.com> 13 * Lin, Mengdong <mengdong.lin@intel.com> 14 * 15 * This program is free software; you can redistribute it and/or modify it 16 * under the terms of the GNU General Public License as published by the 17 * Free Software Foundation; either version 2 of the License, or (at your 18 * option) any later version. 19 * 20 * Add support to read audio firmware topology alongside firmware text. The 21 * topology data can contain kcontrols, DAPM graphs, widgets, DAIs, DAI links, 22 * equalizers, firmware, coefficients etc. 23 * 24 * This file only manages the core ALSA and ASoC components, all other bespoke 25 * firmware topology data is passed to component drivers for bespoke handling. 26 */ 27 28 #include <linux/kernel.h> 29 #include <linux/export.h> 30 #include <linux/list.h> 31 #include <linux/firmware.h> 32 #include <linux/slab.h> 33 #include <sound/soc.h> 34 #include <sound/soc-dapm.h> 35 #include <sound/soc-topology.h> 36 #include <sound/tlv.h> 37 38 /* 39 * We make several passes over the data (since it wont necessarily be ordered) 40 * and process objects in the following order. This guarantees the component 41 * drivers will be ready with any vendor data before the mixers and DAPM objects 42 * are loaded (that may make use of the vendor data). 43 */ 44 #define SOC_TPLG_PASS_MANIFEST 0 45 #define SOC_TPLG_PASS_VENDOR 1 46 #define SOC_TPLG_PASS_MIXER 2 47 #define SOC_TPLG_PASS_WIDGET 3 48 #define SOC_TPLG_PASS_PCM_DAI 4 49 #define SOC_TPLG_PASS_GRAPH 5 50 #define SOC_TPLG_PASS_PINS 6 51 #define SOC_TPLG_PASS_BE_DAI 7 52 53 #define SOC_TPLG_PASS_START SOC_TPLG_PASS_MANIFEST 54 #define SOC_TPLG_PASS_END SOC_TPLG_PASS_BE_DAI 55 56 struct soc_tplg { 57 const struct firmware *fw; 58 59 /* runtime FW parsing */ 60 const u8 *pos; /* read postion */ 61 const u8 *hdr_pos; /* header position */ 62 unsigned int pass; /* pass number */ 63 64 /* component caller */ 65 struct device *dev; 66 struct snd_soc_component *comp; 67 u32 index; /* current block index */ 68 u32 req_index; /* required index, only loaded/free matching blocks */ 69 70 /* vendor specific kcontrol operations */ 71 const struct snd_soc_tplg_kcontrol_ops *io_ops; 72 int io_ops_count; 73 74 /* vendor specific bytes ext handlers, for TLV bytes controls */ 75 const struct snd_soc_tplg_bytes_ext_ops *bytes_ext_ops; 76 int bytes_ext_ops_count; 77 78 /* optional fw loading callbacks to component drivers */ 79 struct snd_soc_tplg_ops *ops; 80 }; 81 82 static int soc_tplg_process_headers(struct soc_tplg *tplg); 83 static void soc_tplg_complete(struct soc_tplg *tplg); 84 struct snd_soc_dapm_widget * 85 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm, 86 const struct snd_soc_dapm_widget *widget); 87 struct snd_soc_dapm_widget * 88 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, 89 const struct snd_soc_dapm_widget *widget); 90 91 /* check we dont overflow the data for this control chunk */ 92 static int soc_tplg_check_elem_count(struct soc_tplg *tplg, size_t elem_size, 93 unsigned int count, size_t bytes, const char *elem_type) 94 { 95 const u8 *end = tplg->pos + elem_size * count; 96 97 if (end > tplg->fw->data + tplg->fw->size) { 98 dev_err(tplg->dev, "ASoC: %s overflow end of data\n", 99 elem_type); 100 return -EINVAL; 101 } 102 103 /* check there is enough room in chunk for control. 104 extra bytes at the end of control are for vendor data here */ 105 if (elem_size * count > bytes) { 106 dev_err(tplg->dev, 107 "ASoC: %s count %d of size %zu is bigger than chunk %zu\n", 108 elem_type, count, elem_size, bytes); 109 return -EINVAL; 110 } 111 112 return 0; 113 } 114 115 static inline int soc_tplg_is_eof(struct soc_tplg *tplg) 116 { 117 const u8 *end = tplg->hdr_pos; 118 119 if (end >= tplg->fw->data + tplg->fw->size) 120 return 1; 121 return 0; 122 } 123 124 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg) 125 { 126 return (unsigned long)(tplg->hdr_pos - tplg->fw->data); 127 } 128 129 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg) 130 { 131 return (unsigned long)(tplg->pos - tplg->fw->data); 132 } 133 134 /* mapping of Kcontrol types and associated operations. */ 135 static const struct snd_soc_tplg_kcontrol_ops io_ops[] = { 136 {SND_SOC_TPLG_CTL_VOLSW, snd_soc_get_volsw, 137 snd_soc_put_volsw, snd_soc_info_volsw}, 138 {SND_SOC_TPLG_CTL_VOLSW_SX, snd_soc_get_volsw_sx, 139 snd_soc_put_volsw_sx, NULL}, 140 {SND_SOC_TPLG_CTL_ENUM, snd_soc_get_enum_double, 141 snd_soc_put_enum_double, snd_soc_info_enum_double}, 142 {SND_SOC_TPLG_CTL_ENUM_VALUE, snd_soc_get_enum_double, 143 snd_soc_put_enum_double, NULL}, 144 {SND_SOC_TPLG_CTL_BYTES, snd_soc_bytes_get, 145 snd_soc_bytes_put, snd_soc_bytes_info}, 146 {SND_SOC_TPLG_CTL_RANGE, snd_soc_get_volsw_range, 147 snd_soc_put_volsw_range, snd_soc_info_volsw_range}, 148 {SND_SOC_TPLG_CTL_VOLSW_XR_SX, snd_soc_get_xr_sx, 149 snd_soc_put_xr_sx, snd_soc_info_xr_sx}, 150 {SND_SOC_TPLG_CTL_STROBE, snd_soc_get_strobe, 151 snd_soc_put_strobe, NULL}, 152 {SND_SOC_TPLG_DAPM_CTL_VOLSW, snd_soc_dapm_get_volsw, 153 snd_soc_dapm_put_volsw, snd_soc_info_volsw}, 154 {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE, snd_soc_dapm_get_enum_double, 155 snd_soc_dapm_put_enum_double, snd_soc_info_enum_double}, 156 {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT, snd_soc_dapm_get_enum_double, 157 snd_soc_dapm_put_enum_double, NULL}, 158 {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE, snd_soc_dapm_get_enum_double, 159 snd_soc_dapm_put_enum_double, NULL}, 160 {SND_SOC_TPLG_DAPM_CTL_PIN, snd_soc_dapm_get_pin_switch, 161 snd_soc_dapm_put_pin_switch, snd_soc_dapm_info_pin_switch}, 162 }; 163 164 struct soc_tplg_map { 165 int uid; 166 int kid; 167 }; 168 169 /* mapping of widget types from UAPI IDs to kernel IDs */ 170 static const struct soc_tplg_map dapm_map[] = { 171 {SND_SOC_TPLG_DAPM_INPUT, snd_soc_dapm_input}, 172 {SND_SOC_TPLG_DAPM_OUTPUT, snd_soc_dapm_output}, 173 {SND_SOC_TPLG_DAPM_MUX, snd_soc_dapm_mux}, 174 {SND_SOC_TPLG_DAPM_MIXER, snd_soc_dapm_mixer}, 175 {SND_SOC_TPLG_DAPM_PGA, snd_soc_dapm_pga}, 176 {SND_SOC_TPLG_DAPM_OUT_DRV, snd_soc_dapm_out_drv}, 177 {SND_SOC_TPLG_DAPM_ADC, snd_soc_dapm_adc}, 178 {SND_SOC_TPLG_DAPM_DAC, snd_soc_dapm_dac}, 179 {SND_SOC_TPLG_DAPM_SWITCH, snd_soc_dapm_switch}, 180 {SND_SOC_TPLG_DAPM_PRE, snd_soc_dapm_pre}, 181 {SND_SOC_TPLG_DAPM_POST, snd_soc_dapm_post}, 182 {SND_SOC_TPLG_DAPM_AIF_IN, snd_soc_dapm_aif_in}, 183 {SND_SOC_TPLG_DAPM_AIF_OUT, snd_soc_dapm_aif_out}, 184 {SND_SOC_TPLG_DAPM_DAI_IN, snd_soc_dapm_dai_in}, 185 {SND_SOC_TPLG_DAPM_DAI_OUT, snd_soc_dapm_dai_out}, 186 {SND_SOC_TPLG_DAPM_DAI_LINK, snd_soc_dapm_dai_link}, 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 (chan[i].id == map) 196 return 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 (chan[i].id == map) 209 return 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->comp && tplg->ops && tplg->ops->vendor_load) 252 ret = tplg->ops->vendor_load(tplg->comp, 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 /* pass vendor data to component driver for processing */ 269 static int soc_tplg_vendor_load(struct soc_tplg *tplg, 270 struct snd_soc_tplg_hdr *hdr) 271 { 272 if (tplg->pass != SOC_TPLG_PASS_VENDOR) 273 return 0; 274 275 return soc_tplg_vendor_load_(tplg, hdr); 276 } 277 278 /* optionally pass new dynamic widget to component driver. This is mainly for 279 * external widgets where we can assign private data/ops */ 280 static int soc_tplg_widget_load(struct soc_tplg *tplg, 281 struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w) 282 { 283 if (tplg->comp && tplg->ops && tplg->ops->widget_load) 284 return tplg->ops->widget_load(tplg->comp, w, tplg_w); 285 286 return 0; 287 } 288 289 /* pass DAI configurations to component driver for extra intialization */ 290 static int soc_tplg_dai_load(struct soc_tplg *tplg, 291 struct snd_soc_dai_driver *dai_drv) 292 { 293 if (tplg->comp && tplg->ops && tplg->ops->dai_load) 294 return tplg->ops->dai_load(tplg->comp, dai_drv); 295 296 return 0; 297 } 298 299 /* pass link configurations to component driver for extra intialization */ 300 static int soc_tplg_dai_link_load(struct soc_tplg *tplg, 301 struct snd_soc_dai_link *link) 302 { 303 if (tplg->comp && tplg->ops && tplg->ops->link_load) 304 return tplg->ops->link_load(tplg->comp, link); 305 306 return 0; 307 } 308 309 /* tell the component driver that all firmware has been loaded in this request */ 310 static void soc_tplg_complete(struct soc_tplg *tplg) 311 { 312 if (tplg->comp && tplg->ops && tplg->ops->complete) 313 tplg->ops->complete(tplg->comp); 314 } 315 316 /* add a dynamic kcontrol */ 317 static int soc_tplg_add_dcontrol(struct snd_card *card, struct device *dev, 318 const struct snd_kcontrol_new *control_new, const char *prefix, 319 void *data, struct snd_kcontrol **kcontrol) 320 { 321 int err; 322 323 *kcontrol = snd_soc_cnew(control_new, data, control_new->name, prefix); 324 if (*kcontrol == NULL) { 325 dev_err(dev, "ASoC: Failed to create new kcontrol %s\n", 326 control_new->name); 327 return -ENOMEM; 328 } 329 330 err = snd_ctl_add(card, *kcontrol); 331 if (err < 0) { 332 dev_err(dev, "ASoC: Failed to add %s: %d\n", 333 control_new->name, err); 334 return err; 335 } 336 337 return 0; 338 } 339 340 /* add a dynamic kcontrol for component driver */ 341 static int soc_tplg_add_kcontrol(struct soc_tplg *tplg, 342 struct snd_kcontrol_new *k, struct snd_kcontrol **kcontrol) 343 { 344 struct snd_soc_component *comp = tplg->comp; 345 346 return soc_tplg_add_dcontrol(comp->card->snd_card, 347 comp->dev, k, NULL, comp, kcontrol); 348 } 349 350 /* remove a mixer kcontrol */ 351 static void remove_mixer(struct snd_soc_component *comp, 352 struct snd_soc_dobj *dobj, int pass) 353 { 354 struct snd_card *card = comp->card->snd_card; 355 struct soc_mixer_control *sm = 356 container_of(dobj, struct soc_mixer_control, dobj); 357 const unsigned int *p = NULL; 358 359 if (pass != SOC_TPLG_PASS_MIXER) 360 return; 361 362 if (dobj->ops && dobj->ops->control_unload) 363 dobj->ops->control_unload(comp, dobj); 364 365 if (sm->dobj.control.kcontrol->tlv.p) 366 p = sm->dobj.control.kcontrol->tlv.p; 367 snd_ctl_remove(card, sm->dobj.control.kcontrol); 368 list_del(&sm->dobj.list); 369 kfree(sm); 370 kfree(p); 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 struct soc_enum *se = container_of(dobj, struct soc_enum, dobj); 379 int i; 380 381 if (pass != SOC_TPLG_PASS_MIXER) 382 return; 383 384 if (dobj->ops && dobj->ops->control_unload) 385 dobj->ops->control_unload(comp, dobj); 386 387 snd_ctl_remove(card, se->dobj.control.kcontrol); 388 list_del(&se->dobj.list); 389 390 kfree(se->dobj.control.dvalues); 391 for (i = 0; i < se->items; i++) 392 kfree(se->dobj.control.dtexts[i]); 393 kfree(se); 394 } 395 396 /* remove a byte kcontrol */ 397 static void remove_bytes(struct snd_soc_component *comp, 398 struct snd_soc_dobj *dobj, int pass) 399 { 400 struct snd_card *card = comp->card->snd_card; 401 struct soc_bytes_ext *sb = 402 container_of(dobj, struct soc_bytes_ext, dobj); 403 404 if (pass != SOC_TPLG_PASS_MIXER) 405 return; 406 407 if (dobj->ops && dobj->ops->control_unload) 408 dobj->ops->control_unload(comp, dobj); 409 410 snd_ctl_remove(card, sb->dobj.control.kcontrol); 411 list_del(&sb->dobj.list); 412 kfree(sb); 413 } 414 415 /* remove a widget and it's kcontrols - routes must be removed first */ 416 static void remove_widget(struct snd_soc_component *comp, 417 struct snd_soc_dobj *dobj, int pass) 418 { 419 struct snd_card *card = comp->card->snd_card; 420 struct snd_soc_dapm_widget *w = 421 container_of(dobj, struct snd_soc_dapm_widget, dobj); 422 int i; 423 424 if (pass != SOC_TPLG_PASS_WIDGET) 425 return; 426 427 if (dobj->ops && dobj->ops->widget_unload) 428 dobj->ops->widget_unload(comp, dobj); 429 430 /* 431 * Dynamic Widgets either have 1 enum kcontrol or 1..N mixers. 432 * The enum may either have an array of values or strings. 433 */ 434 if (dobj->widget.kcontrol_enum) { 435 /* enumerated widget mixer */ 436 struct soc_enum *se = 437 (struct soc_enum *)w->kcontrols[0]->private_value; 438 439 snd_ctl_remove(card, w->kcontrols[0]); 440 441 kfree(se->dobj.control.dvalues); 442 for (i = 0; i < se->items; i++) 443 kfree(se->dobj.control.dtexts[i]); 444 445 kfree(se); 446 kfree(w->kcontrol_news); 447 } else { 448 /* non enumerated widget mixer */ 449 for (i = 0; i < w->num_kcontrols; i++) { 450 struct snd_kcontrol *kcontrol = w->kcontrols[i]; 451 struct soc_mixer_control *sm = 452 (struct soc_mixer_control *) kcontrol->private_value; 453 454 kfree(w->kcontrols[i]->tlv.p); 455 456 snd_ctl_remove(card, w->kcontrols[i]); 457 kfree(sm); 458 } 459 kfree(w->kcontrol_news); 460 } 461 /* widget w is freed by soc-dapm.c */ 462 } 463 464 /* remove DAI configurations */ 465 static void remove_dai(struct snd_soc_component *comp, 466 struct snd_soc_dobj *dobj, int pass) 467 { 468 struct snd_soc_dai_driver *dai_drv = 469 container_of(dobj, struct snd_soc_dai_driver, dobj); 470 471 if (pass != SOC_TPLG_PASS_PCM_DAI) 472 return; 473 474 if (dobj->ops && dobj->ops->dai_unload) 475 dobj->ops->dai_unload(comp, dobj); 476 477 list_del(&dobj->list); 478 kfree(dai_drv); 479 } 480 481 /* remove link configurations */ 482 static void remove_link(struct snd_soc_component *comp, 483 struct snd_soc_dobj *dobj, int pass) 484 { 485 struct snd_soc_dai_link *link = 486 container_of(dobj, struct snd_soc_dai_link, dobj); 487 488 if (pass != SOC_TPLG_PASS_PCM_DAI) 489 return; 490 491 if (dobj->ops && dobj->ops->link_unload) 492 dobj->ops->link_unload(comp, dobj); 493 494 list_del(&dobj->list); 495 snd_soc_remove_dai_link(comp->card, link); 496 kfree(link); 497 } 498 499 /* bind a kcontrol to it's IO handlers */ 500 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr *hdr, 501 struct snd_kcontrol_new *k, 502 const struct soc_tplg *tplg) 503 { 504 const struct snd_soc_tplg_kcontrol_ops *ops; 505 const struct snd_soc_tplg_bytes_ext_ops *ext_ops; 506 int num_ops, i; 507 508 if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES 509 && k->iface & SNDRV_CTL_ELEM_IFACE_MIXER 510 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE 511 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) { 512 struct soc_bytes_ext *sbe; 513 struct snd_soc_tplg_bytes_control *be; 514 515 sbe = (struct soc_bytes_ext *)k->private_value; 516 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr); 517 518 /* TLV bytes controls need standard kcontrol info handler, 519 * TLV callback and extended put/get handlers. 520 */ 521 k->info = snd_soc_bytes_info_ext; 522 k->tlv.c = snd_soc_bytes_tlv_callback; 523 524 ext_ops = tplg->bytes_ext_ops; 525 num_ops = tplg->bytes_ext_ops_count; 526 for (i = 0; i < num_ops; i++) { 527 if (!sbe->put && ext_ops[i].id == be->ext_ops.put) 528 sbe->put = ext_ops[i].put; 529 if (!sbe->get && ext_ops[i].id == be->ext_ops.get) 530 sbe->get = ext_ops[i].get; 531 } 532 533 if (sbe->put && sbe->get) 534 return 0; 535 else 536 return -EINVAL; 537 } 538 539 /* try and map vendor specific kcontrol handlers first */ 540 ops = tplg->io_ops; 541 num_ops = tplg->io_ops_count; 542 for (i = 0; i < num_ops; i++) { 543 544 if (k->put == NULL && ops[i].id == hdr->ops.put) 545 k->put = ops[i].put; 546 if (k->get == NULL && ops[i].id == hdr->ops.get) 547 k->get = ops[i].get; 548 if (k->info == NULL && ops[i].id == hdr->ops.info) 549 k->info = ops[i].info; 550 } 551 552 /* vendor specific handlers found ? */ 553 if (k->put && k->get && k->info) 554 return 0; 555 556 /* none found so try standard kcontrol handlers */ 557 ops = io_ops; 558 num_ops = ARRAY_SIZE(io_ops); 559 for (i = 0; i < num_ops; i++) { 560 561 if (k->put == NULL && ops[i].id == hdr->ops.put) 562 k->put = ops[i].put; 563 if (k->get == NULL && ops[i].id == hdr->ops.get) 564 k->get = ops[i].get; 565 if (k->info == NULL && ops[i].id == hdr->ops.info) 566 k->info = ops[i].info; 567 } 568 569 /* standard handlers found ? */ 570 if (k->put && k->get && k->info) 571 return 0; 572 573 /* nothing to bind */ 574 return -EINVAL; 575 } 576 577 /* bind a widgets to it's evnt handlers */ 578 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w, 579 const struct snd_soc_tplg_widget_events *events, 580 int num_events, u16 event_type) 581 { 582 int i; 583 584 w->event = NULL; 585 586 for (i = 0; i < num_events; i++) { 587 if (event_type == events[i].type) { 588 589 /* found - so assign event */ 590 w->event = events[i].event_handler; 591 return 0; 592 } 593 } 594 595 /* not found */ 596 return -EINVAL; 597 } 598 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event); 599 600 /* optionally pass new dynamic kcontrol to component driver. */ 601 static int soc_tplg_init_kcontrol(struct soc_tplg *tplg, 602 struct snd_kcontrol_new *k, struct snd_soc_tplg_ctl_hdr *hdr) 603 { 604 if (tplg->comp && tplg->ops && tplg->ops->control_load) 605 return tplg->ops->control_load(tplg->comp, k, hdr); 606 607 return 0; 608 } 609 610 611 static int soc_tplg_create_tlv_db_scale(struct soc_tplg *tplg, 612 struct snd_kcontrol_new *kc, struct snd_soc_tplg_tlv_dbscale *scale) 613 { 614 unsigned int item_len = 2 * sizeof(unsigned int); 615 unsigned int *p; 616 617 p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL); 618 if (!p) 619 return -ENOMEM; 620 621 p[0] = SNDRV_CTL_TLVT_DB_SCALE; 622 p[1] = item_len; 623 p[2] = scale->min; 624 p[3] = (scale->step & TLV_DB_SCALE_MASK) 625 | (scale->mute ? TLV_DB_SCALE_MUTE : 0); 626 627 kc->tlv.p = (void *)p; 628 return 0; 629 } 630 631 static int soc_tplg_create_tlv(struct soc_tplg *tplg, 632 struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc) 633 { 634 struct snd_soc_tplg_ctl_tlv *tplg_tlv; 635 636 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE)) 637 return 0; 638 639 if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) { 640 tplg_tlv = &tc->tlv; 641 switch (tplg_tlv->type) { 642 case SNDRV_CTL_TLVT_DB_SCALE: 643 return soc_tplg_create_tlv_db_scale(tplg, kc, 644 &tplg_tlv->scale); 645 646 /* TODO: add support for other TLV types */ 647 default: 648 dev_dbg(tplg->dev, "Unsupported TLV type %d\n", 649 tplg_tlv->type); 650 return -EINVAL; 651 } 652 } 653 654 return 0; 655 } 656 657 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg, 658 struct snd_kcontrol_new *kc) 659 { 660 kfree(kc->tlv.p); 661 } 662 663 static int soc_tplg_dbytes_create(struct soc_tplg *tplg, unsigned int count, 664 size_t size) 665 { 666 struct snd_soc_tplg_bytes_control *be; 667 struct soc_bytes_ext *sbe; 668 struct snd_kcontrol_new kc; 669 int i, err; 670 671 if (soc_tplg_check_elem_count(tplg, 672 sizeof(struct snd_soc_tplg_bytes_control), count, 673 size, "mixer bytes")) { 674 dev_err(tplg->dev, "ASoC: Invalid count %d for byte control\n", 675 count); 676 return -EINVAL; 677 } 678 679 for (i = 0; i < count; i++) { 680 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 681 682 /* validate kcontrol */ 683 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 684 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 685 return -EINVAL; 686 687 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL); 688 if (sbe == NULL) 689 return -ENOMEM; 690 691 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 692 be->priv.size); 693 694 dev_dbg(tplg->dev, 695 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 696 be->hdr.name, be->hdr.access); 697 698 memset(&kc, 0, sizeof(kc)); 699 kc.name = be->hdr.name; 700 kc.private_value = (long)sbe; 701 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 702 kc.access = be->hdr.access; 703 704 sbe->max = be->max; 705 sbe->dobj.type = SND_SOC_DOBJ_BYTES; 706 sbe->dobj.ops = tplg->ops; 707 INIT_LIST_HEAD(&sbe->dobj.list); 708 709 /* map io handlers */ 710 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg); 711 if (err) { 712 soc_control_err(tplg, &be->hdr, be->hdr.name); 713 kfree(sbe); 714 continue; 715 } 716 717 /* pass control to driver for optional further init */ 718 err = soc_tplg_init_kcontrol(tplg, &kc, 719 (struct snd_soc_tplg_ctl_hdr *)be); 720 if (err < 0) { 721 dev_err(tplg->dev, "ASoC: failed to init %s\n", 722 be->hdr.name); 723 kfree(sbe); 724 continue; 725 } 726 727 /* register control here */ 728 err = soc_tplg_add_kcontrol(tplg, &kc, 729 &sbe->dobj.control.kcontrol); 730 if (err < 0) { 731 dev_err(tplg->dev, "ASoC: failed to add %s\n", 732 be->hdr.name); 733 kfree(sbe); 734 continue; 735 } 736 737 list_add(&sbe->dobj.list, &tplg->comp->dobj_list); 738 } 739 return 0; 740 741 } 742 743 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count, 744 size_t size) 745 { 746 struct snd_soc_tplg_mixer_control *mc; 747 struct soc_mixer_control *sm; 748 struct snd_kcontrol_new kc; 749 int i, err; 750 751 if (soc_tplg_check_elem_count(tplg, 752 sizeof(struct snd_soc_tplg_mixer_control), 753 count, size, "mixers")) { 754 755 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n", 756 count); 757 return -EINVAL; 758 } 759 760 for (i = 0; i < count; i++) { 761 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 762 763 /* validate kcontrol */ 764 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 765 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 766 return -EINVAL; 767 768 sm = kzalloc(sizeof(*sm), GFP_KERNEL); 769 if (sm == NULL) 770 return -ENOMEM; 771 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) + 772 mc->priv.size); 773 774 dev_dbg(tplg->dev, 775 "ASoC: adding mixer kcontrol %s with access 0x%x\n", 776 mc->hdr.name, mc->hdr.access); 777 778 memset(&kc, 0, sizeof(kc)); 779 kc.name = mc->hdr.name; 780 kc.private_value = (long)sm; 781 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 782 kc.access = mc->hdr.access; 783 784 /* we only support FL/FR channel mapping atm */ 785 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 786 SNDRV_CHMAP_FL); 787 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 788 SNDRV_CHMAP_FR); 789 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 790 SNDRV_CHMAP_FL); 791 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 792 SNDRV_CHMAP_FR); 793 794 sm->max = mc->max; 795 sm->min = mc->min; 796 sm->invert = mc->invert; 797 sm->platform_max = mc->platform_max; 798 sm->dobj.index = tplg->index; 799 sm->dobj.ops = tplg->ops; 800 sm->dobj.type = SND_SOC_DOBJ_MIXER; 801 INIT_LIST_HEAD(&sm->dobj.list); 802 803 /* map io handlers */ 804 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg); 805 if (err) { 806 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 807 kfree(sm); 808 continue; 809 } 810 811 /* pass control to driver for optional further init */ 812 err = soc_tplg_init_kcontrol(tplg, &kc, 813 (struct snd_soc_tplg_ctl_hdr *) mc); 814 if (err < 0) { 815 dev_err(tplg->dev, "ASoC: failed to init %s\n", 816 mc->hdr.name); 817 kfree(sm); 818 continue; 819 } 820 821 /* create any TLV data */ 822 soc_tplg_create_tlv(tplg, &kc, &mc->hdr); 823 824 /* register control here */ 825 err = soc_tplg_add_kcontrol(tplg, &kc, 826 &sm->dobj.control.kcontrol); 827 if (err < 0) { 828 dev_err(tplg->dev, "ASoC: failed to add %s\n", 829 mc->hdr.name); 830 soc_tplg_free_tlv(tplg, &kc); 831 kfree(sm); 832 continue; 833 } 834 835 list_add(&sm->dobj.list, &tplg->comp->dobj_list); 836 } 837 838 return 0; 839 } 840 841 static int soc_tplg_denum_create_texts(struct soc_enum *se, 842 struct snd_soc_tplg_enum_control *ec) 843 { 844 int i, ret; 845 846 se->dobj.control.dtexts = 847 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL); 848 if (se->dobj.control.dtexts == NULL) 849 return -ENOMEM; 850 851 for (i = 0; i < ec->items; i++) { 852 853 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 854 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) { 855 ret = -EINVAL; 856 goto err; 857 } 858 859 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL); 860 if (!se->dobj.control.dtexts[i]) { 861 ret = -ENOMEM; 862 goto err; 863 } 864 } 865 866 return 0; 867 868 err: 869 for (--i; i >= 0; i--) 870 kfree(se->dobj.control.dtexts[i]); 871 kfree(se->dobj.control.dtexts); 872 return ret; 873 } 874 875 static int soc_tplg_denum_create_values(struct soc_enum *se, 876 struct snd_soc_tplg_enum_control *ec) 877 { 878 if (ec->items > sizeof(*ec->values)) 879 return -EINVAL; 880 881 se->dobj.control.dvalues = kmemdup(ec->values, 882 ec->items * sizeof(u32), 883 GFP_KERNEL); 884 if (!se->dobj.control.dvalues) 885 return -ENOMEM; 886 887 return 0; 888 } 889 890 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count, 891 size_t size) 892 { 893 struct snd_soc_tplg_enum_control *ec; 894 struct soc_enum *se; 895 struct snd_kcontrol_new kc; 896 int i, ret, err; 897 898 if (soc_tplg_check_elem_count(tplg, 899 sizeof(struct snd_soc_tplg_enum_control), 900 count, size, "enums")) { 901 902 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n", 903 count); 904 return -EINVAL; 905 } 906 907 for (i = 0; i < count; i++) { 908 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 909 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 910 ec->priv.size); 911 912 /* validate kcontrol */ 913 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 914 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 915 return -EINVAL; 916 917 se = kzalloc((sizeof(*se)), GFP_KERNEL); 918 if (se == NULL) 919 return -ENOMEM; 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 = 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->items = ec->items; 937 se->mask = ec->mask; 938 se->dobj.index = tplg->index; 939 se->dobj.type = SND_SOC_DOBJ_ENUM; 940 se->dobj.ops = tplg->ops; 941 INIT_LIST_HEAD(&se->dobj.list); 942 943 switch (ec->hdr.ops.info) { 944 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 945 case SND_SOC_TPLG_CTL_ENUM_VALUE: 946 err = soc_tplg_denum_create_values(se, ec); 947 if (err < 0) { 948 dev_err(tplg->dev, 949 "ASoC: could not create values for %s\n", 950 ec->hdr.name); 951 kfree(se); 952 continue; 953 } 954 /* fall through and create texts */ 955 case SND_SOC_TPLG_CTL_ENUM: 956 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 957 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 958 err = soc_tplg_denum_create_texts(se, ec); 959 if (err < 0) { 960 dev_err(tplg->dev, 961 "ASoC: could not create texts for %s\n", 962 ec->hdr.name); 963 kfree(se); 964 continue; 965 } 966 break; 967 default: 968 dev_err(tplg->dev, 969 "ASoC: invalid enum control type %d for %s\n", 970 ec->hdr.ops.info, ec->hdr.name); 971 kfree(se); 972 continue; 973 } 974 975 /* map io handlers */ 976 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg); 977 if (err) { 978 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 979 kfree(se); 980 continue; 981 } 982 983 /* pass control to driver for optional further init */ 984 err = soc_tplg_init_kcontrol(tplg, &kc, 985 (struct snd_soc_tplg_ctl_hdr *) ec); 986 if (err < 0) { 987 dev_err(tplg->dev, "ASoC: failed to init %s\n", 988 ec->hdr.name); 989 kfree(se); 990 continue; 991 } 992 993 /* register control here */ 994 ret = soc_tplg_add_kcontrol(tplg, 995 &kc, &se->dobj.control.kcontrol); 996 if (ret < 0) { 997 dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n", 998 ec->hdr.name); 999 kfree(se); 1000 continue; 1001 } 1002 1003 list_add(&se->dobj.list, &tplg->comp->dobj_list); 1004 } 1005 1006 return 0; 1007 } 1008 1009 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg, 1010 struct snd_soc_tplg_hdr *hdr) 1011 { 1012 struct snd_soc_tplg_ctl_hdr *control_hdr; 1013 int i; 1014 1015 if (tplg->pass != SOC_TPLG_PASS_MIXER) { 1016 tplg->pos += hdr->size + hdr->payload_size; 1017 return 0; 1018 } 1019 1020 dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count, 1021 soc_tplg_get_offset(tplg)); 1022 1023 for (i = 0; i < hdr->count; i++) { 1024 1025 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1026 1027 if (control_hdr->size != sizeof(*control_hdr)) { 1028 dev_err(tplg->dev, "ASoC: invalid control size\n"); 1029 return -EINVAL; 1030 } 1031 1032 switch (control_hdr->ops.info) { 1033 case SND_SOC_TPLG_CTL_VOLSW: 1034 case SND_SOC_TPLG_CTL_STROBE: 1035 case SND_SOC_TPLG_CTL_VOLSW_SX: 1036 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1037 case SND_SOC_TPLG_CTL_RANGE: 1038 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1039 case SND_SOC_TPLG_DAPM_CTL_PIN: 1040 soc_tplg_dmixer_create(tplg, 1, hdr->payload_size); 1041 break; 1042 case SND_SOC_TPLG_CTL_ENUM: 1043 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1044 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1045 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1046 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1047 soc_tplg_denum_create(tplg, 1, hdr->payload_size); 1048 break; 1049 case SND_SOC_TPLG_CTL_BYTES: 1050 soc_tplg_dbytes_create(tplg, 1, hdr->payload_size); 1051 break; 1052 default: 1053 soc_bind_err(tplg, control_hdr, i); 1054 return -EINVAL; 1055 } 1056 } 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_dapm_route route; 1066 struct snd_soc_tplg_dapm_graph_elem *elem; 1067 int count = hdr->count, i; 1068 1069 if (tplg->pass != SOC_TPLG_PASS_GRAPH) { 1070 tplg->pos += hdr->size + hdr->payload_size; 1071 return 0; 1072 } 1073 1074 if (soc_tplg_check_elem_count(tplg, 1075 sizeof(struct snd_soc_tplg_dapm_graph_elem), 1076 count, hdr->payload_size, "graph")) { 1077 1078 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n", 1079 count); 1080 return -EINVAL; 1081 } 1082 1083 dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes\n", count); 1084 1085 for (i = 0; i < count; i++) { 1086 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos; 1087 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem); 1088 1089 /* validate routes */ 1090 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1091 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1092 return -EINVAL; 1093 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1094 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1095 return -EINVAL; 1096 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1097 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1098 return -EINVAL; 1099 1100 route.source = elem->source; 1101 route.sink = elem->sink; 1102 route.connected = NULL; /* set to NULL atm for tplg users */ 1103 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0) 1104 route.control = NULL; 1105 else 1106 route.control = elem->control; 1107 1108 /* add route, but keep going if some fail */ 1109 snd_soc_dapm_add_routes(dapm, &route, 1); 1110 } 1111 1112 return 0; 1113 } 1114 1115 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create( 1116 struct soc_tplg *tplg, int num_kcontrols) 1117 { 1118 struct snd_kcontrol_new *kc; 1119 struct soc_mixer_control *sm; 1120 struct snd_soc_tplg_mixer_control *mc; 1121 int i, err; 1122 1123 kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL); 1124 if (kc == NULL) 1125 return NULL; 1126 1127 for (i = 0; i < num_kcontrols; i++) { 1128 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos; 1129 sm = kzalloc(sizeof(*sm), GFP_KERNEL); 1130 if (sm == NULL) 1131 goto err; 1132 1133 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) + 1134 mc->priv.size); 1135 1136 /* validate kcontrol */ 1137 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1138 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1139 goto err_str; 1140 1141 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n", 1142 mc->hdr.name, i); 1143 1144 kc[i].name = mc->hdr.name; 1145 kc[i].private_value = (long)sm; 1146 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1147 kc[i].access = mc->hdr.access; 1148 1149 /* we only support FL/FR channel mapping atm */ 1150 sm->reg = tplc_chan_get_reg(tplg, mc->channel, 1151 SNDRV_CHMAP_FL); 1152 sm->rreg = tplc_chan_get_reg(tplg, mc->channel, 1153 SNDRV_CHMAP_FR); 1154 sm->shift = tplc_chan_get_shift(tplg, mc->channel, 1155 SNDRV_CHMAP_FL); 1156 sm->rshift = tplc_chan_get_shift(tplg, mc->channel, 1157 SNDRV_CHMAP_FR); 1158 1159 sm->max = mc->max; 1160 sm->min = mc->min; 1161 sm->invert = mc->invert; 1162 sm->platform_max = mc->platform_max; 1163 sm->dobj.index = tplg->index; 1164 INIT_LIST_HEAD(&sm->dobj.list); 1165 1166 /* map io handlers */ 1167 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg); 1168 if (err) { 1169 soc_control_err(tplg, &mc->hdr, mc->hdr.name); 1170 kfree(sm); 1171 continue; 1172 } 1173 1174 /* pass control to driver for optional further init */ 1175 err = soc_tplg_init_kcontrol(tplg, &kc[i], 1176 (struct snd_soc_tplg_ctl_hdr *)mc); 1177 if (err < 0) { 1178 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1179 mc->hdr.name); 1180 kfree(sm); 1181 continue; 1182 } 1183 } 1184 return kc; 1185 1186 err_str: 1187 kfree(sm); 1188 err: 1189 for (--i; i >= 0; i--) 1190 kfree((void *)kc[i].private_value); 1191 kfree(kc); 1192 return NULL; 1193 } 1194 1195 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create( 1196 struct soc_tplg *tplg) 1197 { 1198 struct snd_kcontrol_new *kc; 1199 struct snd_soc_tplg_enum_control *ec; 1200 struct soc_enum *se; 1201 int i, err; 1202 1203 ec = (struct snd_soc_tplg_enum_control *)tplg->pos; 1204 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) + 1205 ec->priv.size); 1206 1207 /* validate kcontrol */ 1208 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1209 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1210 return NULL; 1211 1212 kc = kzalloc(sizeof(*kc), GFP_KERNEL); 1213 if (kc == NULL) 1214 return NULL; 1215 1216 se = kzalloc(sizeof(*se), GFP_KERNEL); 1217 if (se == NULL) 1218 goto err; 1219 1220 dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n", 1221 ec->hdr.name); 1222 1223 kc->name = ec->hdr.name; 1224 kc->private_value = (long)se; 1225 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1226 kc->access = ec->hdr.access; 1227 1228 /* we only support FL/FR channel mapping atm */ 1229 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL); 1230 se->shift_l = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FL); 1231 se->shift_r = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FR); 1232 1233 se->items = ec->items; 1234 se->mask = ec->mask; 1235 se->dobj.index = tplg->index; 1236 1237 switch (ec->hdr.ops.info) { 1238 case SND_SOC_TPLG_CTL_ENUM_VALUE: 1239 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE: 1240 err = soc_tplg_denum_create_values(se, ec); 1241 if (err < 0) { 1242 dev_err(tplg->dev, "ASoC: could not create values for %s\n", 1243 ec->hdr.name); 1244 goto err_se; 1245 } 1246 /* fall through to create texts */ 1247 case SND_SOC_TPLG_CTL_ENUM: 1248 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE: 1249 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT: 1250 err = soc_tplg_denum_create_texts(se, ec); 1251 if (err < 0) { 1252 dev_err(tplg->dev, "ASoC: could not create texts for %s\n", 1253 ec->hdr.name); 1254 goto err_se; 1255 } 1256 break; 1257 default: 1258 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n", 1259 ec->hdr.ops.info, ec->hdr.name); 1260 goto err_se; 1261 } 1262 1263 /* map io handlers */ 1264 err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg); 1265 if (err) { 1266 soc_control_err(tplg, &ec->hdr, ec->hdr.name); 1267 goto err_se; 1268 } 1269 1270 /* pass control to driver for optional further init */ 1271 err = soc_tplg_init_kcontrol(tplg, kc, 1272 (struct snd_soc_tplg_ctl_hdr *)ec); 1273 if (err < 0) { 1274 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1275 ec->hdr.name); 1276 goto err_se; 1277 } 1278 1279 return kc; 1280 1281 err_se: 1282 /* free values and texts */ 1283 kfree(se->dobj.control.dvalues); 1284 for (i = 0; i < ec->items; i++) 1285 kfree(se->dobj.control.dtexts[i]); 1286 1287 kfree(se); 1288 err: 1289 kfree(kc); 1290 1291 return NULL; 1292 } 1293 1294 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create( 1295 struct soc_tplg *tplg, int count) 1296 { 1297 struct snd_soc_tplg_bytes_control *be; 1298 struct soc_bytes_ext *sbe; 1299 struct snd_kcontrol_new *kc; 1300 int i, err; 1301 1302 kc = kcalloc(count, sizeof(*kc), GFP_KERNEL); 1303 if (!kc) 1304 return NULL; 1305 1306 for (i = 0; i < count; i++) { 1307 be = (struct snd_soc_tplg_bytes_control *)tplg->pos; 1308 1309 /* validate kcontrol */ 1310 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1311 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1312 goto err; 1313 1314 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL); 1315 if (sbe == NULL) 1316 goto err; 1317 1318 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) + 1319 be->priv.size); 1320 1321 dev_dbg(tplg->dev, 1322 "ASoC: adding bytes kcontrol %s with access 0x%x\n", 1323 be->hdr.name, be->hdr.access); 1324 1325 kc[i].name = be->hdr.name; 1326 kc[i].private_value = (long)sbe; 1327 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1328 kc[i].access = be->hdr.access; 1329 1330 sbe->max = be->max; 1331 INIT_LIST_HEAD(&sbe->dobj.list); 1332 1333 /* map standard io handlers and check for external handlers */ 1334 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg); 1335 if (err) { 1336 soc_control_err(tplg, &be->hdr, be->hdr.name); 1337 kfree(sbe); 1338 continue; 1339 } 1340 1341 /* pass control to driver for optional further init */ 1342 err = soc_tplg_init_kcontrol(tplg, &kc[i], 1343 (struct snd_soc_tplg_ctl_hdr *)be); 1344 if (err < 0) { 1345 dev_err(tplg->dev, "ASoC: failed to init %s\n", 1346 be->hdr.name); 1347 kfree(sbe); 1348 continue; 1349 } 1350 } 1351 1352 return kc; 1353 1354 err: 1355 for (--i; i >= 0; i--) 1356 kfree((void *)kc[i].private_value); 1357 1358 kfree(kc); 1359 return NULL; 1360 } 1361 1362 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg, 1363 struct snd_soc_tplg_dapm_widget *w) 1364 { 1365 struct snd_soc_dapm_context *dapm = &tplg->comp->dapm; 1366 struct snd_soc_dapm_widget template, *widget; 1367 struct snd_soc_tplg_ctl_hdr *control_hdr; 1368 struct snd_soc_card *card = tplg->comp->card; 1369 int ret = 0; 1370 1371 if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1372 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1373 return -EINVAL; 1374 if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 1375 SNDRV_CTL_ELEM_ID_NAME_MAXLEN) 1376 return -EINVAL; 1377 1378 dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n", 1379 w->name, w->id); 1380 1381 memset(&template, 0, sizeof(template)); 1382 1383 /* map user to kernel widget ID */ 1384 template.id = get_widget_id(w->id); 1385 if (template.id < 0) 1386 return template.id; 1387 1388 template.name = kstrdup(w->name, GFP_KERNEL); 1389 if (!template.name) 1390 return -ENOMEM; 1391 template.sname = kstrdup(w->sname, GFP_KERNEL); 1392 if (!template.sname) { 1393 ret = -ENOMEM; 1394 goto err; 1395 } 1396 template.reg = w->reg; 1397 template.shift = w->shift; 1398 template.mask = w->mask; 1399 template.subseq = w->subseq; 1400 template.on_val = w->invert ? 0 : 1; 1401 template.off_val = w->invert ? 1 : 0; 1402 template.ignore_suspend = w->ignore_suspend; 1403 template.event_flags = w->event_flags; 1404 template.dobj.index = tplg->index; 1405 1406 tplg->pos += 1407 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size); 1408 if (w->num_kcontrols == 0) { 1409 template.num_kcontrols = 0; 1410 goto widget; 1411 } 1412 1413 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos; 1414 dev_dbg(tplg->dev, "ASoC: template %s has %d controls of type %x\n", 1415 w->name, w->num_kcontrols, control_hdr->type); 1416 1417 switch (control_hdr->ops.info) { 1418 case SND_SOC_TPLG_CTL_VOLSW: 1419 case SND_SOC_TPLG_CTL_STROBE: 1420 case SND_SOC_TPLG_CTL_VOLSW_SX: 1421 case SND_SOC_TPLG_CTL_VOLSW_XR_SX: 1422 case SND_SOC_TPLG_CTL_RANGE: 1423 case SND_SOC_TPLG_DAPM_CTL_VOLSW: 1424 template.num_kcontrols = w->num_kcontrols; 1425 template.kcontrol_news = 1426 soc_tplg_dapm_widget_dmixer_create(tplg, 1427 template.num_kcontrols); 1428 if (!template.kcontrol_news) { 1429 ret = -ENOMEM; 1430 goto hdr_err; 1431 } 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 template.dobj.widget.kcontrol_enum = 1; 1439 template.num_kcontrols = 1; 1440 template.kcontrol_news = 1441 soc_tplg_dapm_widget_denum_create(tplg); 1442 if (!template.kcontrol_news) { 1443 ret = -ENOMEM; 1444 goto hdr_err; 1445 } 1446 break; 1447 case SND_SOC_TPLG_CTL_BYTES: 1448 template.num_kcontrols = w->num_kcontrols; 1449 template.kcontrol_news = 1450 soc_tplg_dapm_widget_dbytes_create(tplg, 1451 template.num_kcontrols); 1452 if (!template.kcontrol_news) { 1453 ret = -ENOMEM; 1454 goto hdr_err; 1455 } 1456 break; 1457 default: 1458 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n", 1459 control_hdr->ops.get, control_hdr->ops.put, 1460 control_hdr->ops.info); 1461 ret = -EINVAL; 1462 goto hdr_err; 1463 } 1464 1465 widget: 1466 ret = soc_tplg_widget_load(tplg, &template, w); 1467 if (ret < 0) 1468 goto hdr_err; 1469 1470 /* card dapm mutex is held by the core if we are loading topology 1471 * data during sound card init. */ 1472 if (card->instantiated) 1473 widget = snd_soc_dapm_new_control(dapm, &template); 1474 else 1475 widget = snd_soc_dapm_new_control_unlocked(dapm, &template); 1476 if (widget == NULL) { 1477 dev_err(tplg->dev, "ASoC: failed to create widget %s controls\n", 1478 w->name); 1479 ret = -ENOMEM; 1480 goto hdr_err; 1481 } 1482 1483 widget->dobj.type = SND_SOC_DOBJ_WIDGET; 1484 widget->dobj.ops = tplg->ops; 1485 widget->dobj.index = tplg->index; 1486 kfree(template.sname); 1487 kfree(template.name); 1488 list_add(&widget->dobj.list, &tplg->comp->dobj_list); 1489 return 0; 1490 1491 hdr_err: 1492 kfree(template.sname); 1493 err: 1494 kfree(template.name); 1495 return ret; 1496 } 1497 1498 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg, 1499 struct snd_soc_tplg_hdr *hdr) 1500 { 1501 struct snd_soc_tplg_dapm_widget *widget; 1502 int ret, count = hdr->count, i; 1503 1504 if (tplg->pass != SOC_TPLG_PASS_WIDGET) 1505 return 0; 1506 1507 dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count); 1508 1509 for (i = 0; i < count; i++) { 1510 widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos; 1511 if (widget->size != sizeof(*widget)) { 1512 dev_err(tplg->dev, "ASoC: invalid widget size\n"); 1513 return -EINVAL; 1514 } 1515 1516 ret = soc_tplg_dapm_widget_create(tplg, widget); 1517 if (ret < 0) { 1518 dev_err(tplg->dev, "ASoC: failed to load widget %s\n", 1519 widget->name); 1520 return ret; 1521 } 1522 } 1523 1524 return 0; 1525 } 1526 1527 static int soc_tplg_dapm_complete(struct soc_tplg *tplg) 1528 { 1529 struct snd_soc_card *card = tplg->comp->card; 1530 int ret; 1531 1532 /* Card might not have been registered at this point. 1533 * If so, just return success. 1534 */ 1535 if (!card || !card->instantiated) { 1536 dev_warn(tplg->dev, "ASoC: Parent card not yet available," 1537 "Do not add new widgets now\n"); 1538 return 0; 1539 } 1540 1541 ret = snd_soc_dapm_new_widgets(card); 1542 if (ret < 0) 1543 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n", 1544 ret); 1545 1546 return 0; 1547 } 1548 1549 static void set_stream_info(struct snd_soc_pcm_stream *stream, 1550 struct snd_soc_tplg_stream_caps *caps) 1551 { 1552 stream->stream_name = kstrdup(caps->name, GFP_KERNEL); 1553 stream->channels_min = caps->channels_min; 1554 stream->channels_max = caps->channels_max; 1555 stream->rates = caps->rates; 1556 stream->rate_min = caps->rate_min; 1557 stream->rate_max = caps->rate_max; 1558 stream->formats = caps->formats; 1559 stream->sig_bits = caps->sig_bits; 1560 } 1561 1562 static void set_dai_flags(struct snd_soc_dai_driver *dai_drv, 1563 unsigned int flag_mask, unsigned int flags) 1564 { 1565 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES) 1566 dai_drv->symmetric_rates = 1567 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES ? 1 : 0; 1568 1569 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS) 1570 dai_drv->symmetric_channels = 1571 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS ? 1572 1 : 0; 1573 1574 if (flag_mask & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS) 1575 dai_drv->symmetric_samplebits = 1576 flags & SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS ? 1577 1 : 0; 1578 } 1579 1580 static int soc_tplg_dai_create(struct soc_tplg *tplg, 1581 struct snd_soc_tplg_pcm *pcm) 1582 { 1583 struct snd_soc_dai_driver *dai_drv; 1584 struct snd_soc_pcm_stream *stream; 1585 struct snd_soc_tplg_stream_caps *caps; 1586 int ret; 1587 1588 dai_drv = kzalloc(sizeof(struct snd_soc_dai_driver), GFP_KERNEL); 1589 if (dai_drv == NULL) 1590 return -ENOMEM; 1591 1592 dai_drv->name = pcm->dai_name; 1593 dai_drv->id = pcm->dai_id; 1594 1595 if (pcm->playback) { 1596 stream = &dai_drv->playback; 1597 caps = &pcm->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 1598 set_stream_info(stream, caps); 1599 } 1600 1601 if (pcm->capture) { 1602 stream = &dai_drv->capture; 1603 caps = &pcm->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 1604 set_stream_info(stream, caps); 1605 } 1606 1607 /* pass control to component driver for optional further init */ 1608 ret = soc_tplg_dai_load(tplg, dai_drv); 1609 if (ret < 0) { 1610 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); 1611 kfree(dai_drv); 1612 return ret; 1613 } 1614 1615 dai_drv->dobj.index = tplg->index; 1616 dai_drv->dobj.ops = tplg->ops; 1617 dai_drv->dobj.type = SND_SOC_DOBJ_PCM; 1618 list_add(&dai_drv->dobj.list, &tplg->comp->dobj_list); 1619 1620 /* register the DAI to the component */ 1621 return snd_soc_register_dai(tplg->comp, dai_drv); 1622 } 1623 1624 /* create the FE DAI link */ 1625 static int soc_tplg_link_create(struct soc_tplg *tplg, 1626 struct snd_soc_tplg_pcm *pcm) 1627 { 1628 struct snd_soc_dai_link *link; 1629 int ret; 1630 1631 link = kzalloc(sizeof(struct snd_soc_dai_link), GFP_KERNEL); 1632 if (link == NULL) 1633 return -ENOMEM; 1634 1635 link->name = pcm->pcm_name; 1636 link->stream_name = pcm->pcm_name; 1637 link->id = pcm->pcm_id; 1638 1639 link->cpu_dai_name = pcm->dai_name; 1640 link->codec_name = "snd-soc-dummy"; 1641 link->codec_dai_name = "snd-soc-dummy-dai"; 1642 1643 /* enable DPCM */ 1644 link->dynamic = 1; 1645 link->dpcm_playback = pcm->playback; 1646 link->dpcm_capture = pcm->capture; 1647 1648 /* pass control to component driver for optional further init */ 1649 ret = soc_tplg_dai_link_load(tplg, link); 1650 if (ret < 0) { 1651 dev_err(tplg->comp->dev, "ASoC: FE link loading failed\n"); 1652 kfree(link); 1653 return ret; 1654 } 1655 1656 link->dobj.index = tplg->index; 1657 link->dobj.ops = tplg->ops; 1658 link->dobj.type = SND_SOC_DOBJ_DAI_LINK; 1659 list_add(&link->dobj.list, &tplg->comp->dobj_list); 1660 1661 snd_soc_add_dai_link(tplg->comp->card, link); 1662 return 0; 1663 } 1664 1665 /* create a FE DAI and DAI link from the PCM object */ 1666 static int soc_tplg_pcm_create(struct soc_tplg *tplg, 1667 struct snd_soc_tplg_pcm *pcm) 1668 { 1669 int ret; 1670 1671 ret = soc_tplg_dai_create(tplg, pcm); 1672 if (ret < 0) 1673 return ret; 1674 1675 return soc_tplg_link_create(tplg, pcm); 1676 } 1677 1678 static int soc_tplg_pcm_elems_load(struct soc_tplg *tplg, 1679 struct snd_soc_tplg_hdr *hdr) 1680 { 1681 struct snd_soc_tplg_pcm *pcm; 1682 int count = hdr->count; 1683 int i; 1684 1685 if (tplg->pass != SOC_TPLG_PASS_PCM_DAI) 1686 return 0; 1687 1688 if (soc_tplg_check_elem_count(tplg, 1689 sizeof(struct snd_soc_tplg_pcm), count, 1690 hdr->payload_size, "PCM DAI")) { 1691 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n", 1692 count); 1693 return -EINVAL; 1694 } 1695 1696 /* create the FE DAIs and DAI links */ 1697 pcm = (struct snd_soc_tplg_pcm *)tplg->pos; 1698 for (i = 0; i < count; i++) { 1699 if (pcm->size != sizeof(*pcm)) { 1700 dev_err(tplg->dev, "ASoC: invalid pcm size\n"); 1701 return -EINVAL; 1702 } 1703 1704 soc_tplg_pcm_create(tplg, pcm); 1705 pcm++; 1706 } 1707 1708 dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count); 1709 tplg->pos += sizeof(struct snd_soc_tplg_pcm) * count; 1710 1711 return 0; 1712 } 1713 1714 /* * 1715 * soc_tplg_be_dai_config - Find and configure an existing BE DAI. 1716 * @tplg: topology context 1717 * @be: topology BE DAI configs. 1718 * 1719 * The BE dai should already be registered by the platform driver. The 1720 * platform driver should specify the BE DAI name and ID for matching. 1721 */ 1722 static int soc_tplg_be_dai_config(struct soc_tplg *tplg, 1723 struct snd_soc_tplg_be_dai *be) 1724 { 1725 struct snd_soc_dai_link_component dai_component = {0}; 1726 struct snd_soc_dai *dai; 1727 struct snd_soc_dai_driver *dai_drv; 1728 struct snd_soc_pcm_stream *stream; 1729 struct snd_soc_tplg_stream_caps *caps; 1730 int ret; 1731 1732 dai_component.dai_name = be->dai_name; 1733 dai = snd_soc_find_dai(&dai_component); 1734 if (!dai) { 1735 dev_err(tplg->dev, "ASoC: BE DAI %s not registered\n", 1736 be->dai_name); 1737 return -EINVAL; 1738 } 1739 1740 if (be->dai_id != dai->id) { 1741 dev_err(tplg->dev, "ASoC: BE DAI %s id mismatch\n", 1742 be->dai_name); 1743 return -EINVAL; 1744 } 1745 1746 dai_drv = dai->driver; 1747 if (!dai_drv) 1748 return -EINVAL; 1749 1750 if (be->playback) { 1751 stream = &dai_drv->playback; 1752 caps = &be->caps[SND_SOC_TPLG_STREAM_PLAYBACK]; 1753 set_stream_info(stream, caps); 1754 } 1755 1756 if (be->capture) { 1757 stream = &dai_drv->capture; 1758 caps = &be->caps[SND_SOC_TPLG_STREAM_CAPTURE]; 1759 set_stream_info(stream, caps); 1760 } 1761 1762 if (be->flag_mask) 1763 set_dai_flags(dai_drv, be->flag_mask, be->flags); 1764 1765 /* pass control to component driver for optional further init */ 1766 ret = soc_tplg_dai_load(tplg, dai_drv); 1767 if (ret < 0) { 1768 dev_err(tplg->comp->dev, "ASoC: DAI loading failed\n"); 1769 return ret; 1770 } 1771 1772 return 0; 1773 } 1774 1775 static int soc_tplg_be_dai_elems_load(struct soc_tplg *tplg, 1776 struct snd_soc_tplg_hdr *hdr) 1777 { 1778 struct snd_soc_tplg_be_dai *be; 1779 int count = hdr->count; 1780 int i; 1781 1782 if (tplg->pass != SOC_TPLG_PASS_BE_DAI) 1783 return 0; 1784 1785 /* config the existing BE DAIs */ 1786 for (i = 0; i < count; i++) { 1787 be = (struct snd_soc_tplg_be_dai *)tplg->pos; 1788 if (be->size != sizeof(*be)) { 1789 dev_err(tplg->dev, "ASoC: invalid BE DAI size\n"); 1790 return -EINVAL; 1791 } 1792 1793 soc_tplg_be_dai_config(tplg, be); 1794 tplg->pos += (sizeof(*be) + be->priv.size); 1795 } 1796 1797 dev_dbg(tplg->dev, "ASoC: Configure %d BE DAIs\n", count); 1798 return 0; 1799 } 1800 1801 1802 static int soc_tplg_manifest_load(struct soc_tplg *tplg, 1803 struct snd_soc_tplg_hdr *hdr) 1804 { 1805 struct snd_soc_tplg_manifest *manifest; 1806 1807 if (tplg->pass != SOC_TPLG_PASS_MANIFEST) 1808 return 0; 1809 1810 manifest = (struct snd_soc_tplg_manifest *)tplg->pos; 1811 if (manifest->size != sizeof(*manifest)) { 1812 dev_err(tplg->dev, "ASoC: invalid manifest size\n"); 1813 return -EINVAL; 1814 } 1815 1816 tplg->pos += sizeof(struct snd_soc_tplg_manifest); 1817 1818 if (tplg->comp && tplg->ops && tplg->ops->manifest) 1819 return tplg->ops->manifest(tplg->comp, manifest); 1820 1821 dev_err(tplg->dev, "ASoC: Firmware manifest not supported\n"); 1822 return 0; 1823 } 1824 1825 /* validate header magic, size and type */ 1826 static int soc_valid_header(struct soc_tplg *tplg, 1827 struct snd_soc_tplg_hdr *hdr) 1828 { 1829 if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size) 1830 return 0; 1831 1832 if (hdr->size != sizeof(*hdr)) { 1833 dev_err(tplg->dev, 1834 "ASoC: invalid header size for type %d at offset 0x%lx size 0x%zx.\n", 1835 hdr->type, soc_tplg_get_hdr_offset(tplg), 1836 tplg->fw->size); 1837 return -EINVAL; 1838 } 1839 1840 /* big endian firmware objects not supported atm */ 1841 if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) { 1842 dev_err(tplg->dev, 1843 "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n", 1844 tplg->pass, hdr->magic, 1845 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 1846 return -EINVAL; 1847 } 1848 1849 if (hdr->magic != SND_SOC_TPLG_MAGIC) { 1850 dev_err(tplg->dev, 1851 "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n", 1852 tplg->pass, hdr->magic, 1853 soc_tplg_get_hdr_offset(tplg), tplg->fw->size); 1854 return -EINVAL; 1855 } 1856 1857 if (hdr->abi != SND_SOC_TPLG_ABI_VERSION) { 1858 dev_err(tplg->dev, 1859 "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n", 1860 tplg->pass, hdr->abi, 1861 SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg), 1862 tplg->fw->size); 1863 return -EINVAL; 1864 } 1865 1866 if (hdr->payload_size == 0) { 1867 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n", 1868 soc_tplg_get_hdr_offset(tplg)); 1869 return -EINVAL; 1870 } 1871 1872 if (tplg->pass == hdr->type) 1873 dev_dbg(tplg->dev, 1874 "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n", 1875 hdr->payload_size, hdr->type, hdr->version, 1876 hdr->vendor_type, tplg->pass); 1877 1878 return 1; 1879 } 1880 1881 /* check header type and call appropriate handler */ 1882 static int soc_tplg_load_header(struct soc_tplg *tplg, 1883 struct snd_soc_tplg_hdr *hdr) 1884 { 1885 tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr); 1886 1887 /* check for matching ID */ 1888 if (hdr->index != tplg->req_index && 1889 hdr->index != SND_SOC_TPLG_INDEX_ALL) 1890 return 0; 1891 1892 tplg->index = hdr->index; 1893 1894 switch (hdr->type) { 1895 case SND_SOC_TPLG_TYPE_MIXER: 1896 case SND_SOC_TPLG_TYPE_ENUM: 1897 case SND_SOC_TPLG_TYPE_BYTES: 1898 return soc_tplg_kcontrol_elems_load(tplg, hdr); 1899 case SND_SOC_TPLG_TYPE_DAPM_GRAPH: 1900 return soc_tplg_dapm_graph_elems_load(tplg, hdr); 1901 case SND_SOC_TPLG_TYPE_DAPM_WIDGET: 1902 return soc_tplg_dapm_widget_elems_load(tplg, hdr); 1903 case SND_SOC_TPLG_TYPE_PCM: 1904 return soc_tplg_pcm_elems_load(tplg, hdr); 1905 case SND_SOC_TPLG_TYPE_BE_DAI: 1906 return soc_tplg_be_dai_elems_load(tplg, hdr); 1907 case SND_SOC_TPLG_TYPE_MANIFEST: 1908 return soc_tplg_manifest_load(tplg, hdr); 1909 default: 1910 /* bespoke vendor data object */ 1911 return soc_tplg_vendor_load(tplg, hdr); 1912 } 1913 1914 return 0; 1915 } 1916 1917 /* process the topology file headers */ 1918 static int soc_tplg_process_headers(struct soc_tplg *tplg) 1919 { 1920 struct snd_soc_tplg_hdr *hdr; 1921 int ret; 1922 1923 tplg->pass = SOC_TPLG_PASS_START; 1924 1925 /* process the header types from start to end */ 1926 while (tplg->pass <= SOC_TPLG_PASS_END) { 1927 1928 tplg->hdr_pos = tplg->fw->data; 1929 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 1930 1931 while (!soc_tplg_is_eof(tplg)) { 1932 1933 /* make sure header is valid before loading */ 1934 ret = soc_valid_header(tplg, hdr); 1935 if (ret < 0) 1936 return ret; 1937 else if (ret == 0) 1938 break; 1939 1940 /* load the header object */ 1941 ret = soc_tplg_load_header(tplg, hdr); 1942 if (ret < 0) 1943 return ret; 1944 1945 /* goto next header */ 1946 tplg->hdr_pos += hdr->payload_size + 1947 sizeof(struct snd_soc_tplg_hdr); 1948 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos; 1949 } 1950 1951 /* next data type pass */ 1952 tplg->pass++; 1953 } 1954 1955 /* signal DAPM we are complete */ 1956 ret = soc_tplg_dapm_complete(tplg); 1957 if (ret < 0) 1958 dev_err(tplg->dev, 1959 "ASoC: failed to initialise DAPM from Firmware\n"); 1960 1961 return ret; 1962 } 1963 1964 static int soc_tplg_load(struct soc_tplg *tplg) 1965 { 1966 int ret; 1967 1968 ret = soc_tplg_process_headers(tplg); 1969 if (ret == 0) 1970 soc_tplg_complete(tplg); 1971 1972 return ret; 1973 } 1974 1975 /* load audio component topology from "firmware" file */ 1976 int snd_soc_tplg_component_load(struct snd_soc_component *comp, 1977 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id) 1978 { 1979 struct soc_tplg tplg; 1980 1981 /* setup parsing context */ 1982 memset(&tplg, 0, sizeof(tplg)); 1983 tplg.fw = fw; 1984 tplg.dev = comp->dev; 1985 tplg.comp = comp; 1986 tplg.ops = ops; 1987 tplg.req_index = id; 1988 tplg.io_ops = ops->io_ops; 1989 tplg.io_ops_count = ops->io_ops_count; 1990 tplg.bytes_ext_ops = ops->bytes_ext_ops; 1991 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count; 1992 1993 return soc_tplg_load(&tplg); 1994 } 1995 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load); 1996 1997 /* remove this dynamic widget */ 1998 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w) 1999 { 2000 /* make sure we are a widget */ 2001 if (w->dobj.type != SND_SOC_DOBJ_WIDGET) 2002 return; 2003 2004 remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET); 2005 } 2006 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove); 2007 2008 /* remove all dynamic widgets from this DAPM context */ 2009 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm, 2010 u32 index) 2011 { 2012 struct snd_soc_dapm_widget *w, *next_w; 2013 2014 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) { 2015 2016 /* make sure we are a widget with correct context */ 2017 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm) 2018 continue; 2019 2020 /* match ID */ 2021 if (w->dobj.index != index && 2022 w->dobj.index != SND_SOC_TPLG_INDEX_ALL) 2023 continue; 2024 /* check and free and dynamic widget kcontrols */ 2025 snd_soc_tplg_widget_remove(w); 2026 snd_soc_dapm_free_widget(w); 2027 } 2028 snd_soc_dapm_reset_cache(dapm); 2029 } 2030 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all); 2031 2032 /* remove dynamic controls from the component driver */ 2033 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index) 2034 { 2035 struct snd_soc_dobj *dobj, *next_dobj; 2036 int pass = SOC_TPLG_PASS_END; 2037 2038 /* process the header types from end to start */ 2039 while (pass >= SOC_TPLG_PASS_START) { 2040 2041 /* remove mixer controls */ 2042 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list, 2043 list) { 2044 2045 /* match index */ 2046 if (dobj->index != index && 2047 dobj->index != SND_SOC_TPLG_INDEX_ALL) 2048 continue; 2049 2050 switch (dobj->type) { 2051 case SND_SOC_DOBJ_MIXER: 2052 remove_mixer(comp, dobj, pass); 2053 break; 2054 case SND_SOC_DOBJ_ENUM: 2055 remove_enum(comp, dobj, pass); 2056 break; 2057 case SND_SOC_DOBJ_BYTES: 2058 remove_bytes(comp, dobj, pass); 2059 break; 2060 case SND_SOC_DOBJ_WIDGET: 2061 remove_widget(comp, dobj, pass); 2062 break; 2063 case SND_SOC_DOBJ_PCM: 2064 remove_dai(comp, dobj, pass); 2065 break; 2066 case SND_SOC_DOBJ_DAI_LINK: 2067 remove_link(comp, dobj, pass); 2068 break; 2069 default: 2070 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n", 2071 dobj->type); 2072 break; 2073 } 2074 } 2075 pass--; 2076 } 2077 2078 /* let caller know if FW can be freed when no objects are left */ 2079 return !list_empty(&comp->dobj_list); 2080 } 2081 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove); 2082