sound/soc/soc-topology.c

   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
  52 #define SOC_TPLG_PASS_START     SOC_TPLG_PASS_MANIFEST
  53 #define SOC_TPLG_PASS_END       SOC_TPLG_PASS_PINS
  54
  55 struct soc_tplg {
  56         const struct firmware *fw;
  57
  58         /* runtime FW parsing */
  59         const u8 *pos;          /* read postion */
  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         u32 req_index;  /* required index, only loaded/free matching blocks */
  68
  69         /* vendor specific kcontrol operations */
  70         const struct snd_soc_tplg_kcontrol_ops *io_ops;
  71         int io_ops_count;
  72
  73         /* vendor specific bytes ext handlers, for TLV bytes controls */
  74         const struct snd_soc_tplg_bytes_ext_ops *bytes_ext_ops;
  75         int bytes_ext_ops_count;
  76
  77         /* optional fw loading callbacks to component drivers */
  78         struct snd_soc_tplg_ops *ops;
  79 };
  80
  81 static int soc_tplg_process_headers(struct soc_tplg *tplg);
  82 static void soc_tplg_complete(struct soc_tplg *tplg);
  83 struct snd_soc_dapm_widget *
  84 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
  85                          const struct snd_soc_dapm_widget *widget);
  86 struct snd_soc_dapm_widget *
  87 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
  88                          const struct snd_soc_dapm_widget *widget);
  89
  90 /* check we dont overflow the data for this control chunk */
  91 static int soc_tplg_check_elem_count(struct soc_tplg *tplg, size_t elem_size,
  92         unsigned int count, size_t bytes, const char *elem_type)
  93 {
  94         const u8 *end = tplg->pos + elem_size * count;
  95
  96         if (end > tplg->fw->data + tplg->fw->size) {
  97                 dev_err(tplg->dev, "ASoC: %s overflow end of data\n",
  98                         elem_type);
  99                 return -EINVAL;
 100         }
 101
 102         /* check there is enough room in chunk for control.
 103            extra bytes at the end of control are for vendor data here  */
 104         if (elem_size * count > bytes) {
 105                 dev_err(tplg->dev,
 106                         "ASoC: %s count %d of size %zu is bigger than chunk %zu\n",
 107                         elem_type, count, elem_size, bytes);
 108                 return -EINVAL;
 109         }
 110
 111         return 0;
 112 }
 113
 114 static inline int soc_tplg_is_eof(struct soc_tplg *tplg)
 115 {
 116         const u8 *end = tplg->hdr_pos;
 117
 118         if (end >= tplg->fw->data + tplg->fw->size)
 119                 return 1;
 120         return 0;
 121 }
 122
 123 static inline unsigned long soc_tplg_get_hdr_offset(struct soc_tplg *tplg)
 124 {
 125         return (unsigned long)(tplg->hdr_pos - tplg->fw->data);
 126 }
 127
 128 static inline unsigned long soc_tplg_get_offset(struct soc_tplg *tplg)
 129 {
 130         return (unsigned long)(tplg->pos - tplg->fw->data);
 131 }
 132
 133 /* mapping of Kcontrol types and associated operations. */
 134 static const struct snd_soc_tplg_kcontrol_ops io_ops[] = {
 135         {SND_SOC_TPLG_CTL_VOLSW, snd_soc_get_volsw,
 136                 snd_soc_put_volsw, snd_soc_info_volsw},
 137         {SND_SOC_TPLG_CTL_VOLSW_SX, snd_soc_get_volsw_sx,
 138                 snd_soc_put_volsw_sx, NULL},
 139         {SND_SOC_TPLG_CTL_ENUM, snd_soc_get_enum_double,
 140                 snd_soc_put_enum_double, snd_soc_info_enum_double},
 141         {SND_SOC_TPLG_CTL_ENUM_VALUE, snd_soc_get_enum_double,
 142                 snd_soc_put_enum_double, NULL},
 143         {SND_SOC_TPLG_CTL_BYTES, snd_soc_bytes_get,
 144                 snd_soc_bytes_put, snd_soc_bytes_info},
 145         {SND_SOC_TPLG_CTL_RANGE, snd_soc_get_volsw_range,
 146                 snd_soc_put_volsw_range, snd_soc_info_volsw_range},
 147         {SND_SOC_TPLG_CTL_VOLSW_XR_SX, snd_soc_get_xr_sx,
 148                 snd_soc_put_xr_sx, snd_soc_info_xr_sx},
 149         {SND_SOC_TPLG_CTL_STROBE, snd_soc_get_strobe,
 150                 snd_soc_put_strobe, NULL},
 151         {SND_SOC_TPLG_DAPM_CTL_VOLSW, snd_soc_dapm_get_volsw,
 152                 snd_soc_dapm_put_volsw, snd_soc_info_volsw},
 153         {SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE, snd_soc_dapm_get_enum_double,
 154                 snd_soc_dapm_put_enum_double, snd_soc_info_enum_double},
 155         {SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT, snd_soc_dapm_get_enum_double,
 156                 snd_soc_dapm_put_enum_double, NULL},
 157         {SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE, snd_soc_dapm_get_enum_double,
 158                 snd_soc_dapm_put_enum_double, NULL},
 159         {SND_SOC_TPLG_DAPM_CTL_PIN, snd_soc_dapm_get_pin_switch,
 160                 snd_soc_dapm_put_pin_switch, snd_soc_dapm_info_pin_switch},
 161 };
 162
 163 struct soc_tplg_map {
 164         int uid;
 165         int kid;
 166 };
 167
 168 /* mapping of widget types from UAPI IDs to kernel IDs */
 169 static const struct soc_tplg_map dapm_map[] = {
 170         {SND_SOC_TPLG_DAPM_INPUT, snd_soc_dapm_input},
 171         {SND_SOC_TPLG_DAPM_OUTPUT, snd_soc_dapm_output},
 172         {SND_SOC_TPLG_DAPM_MUX, snd_soc_dapm_mux},
 173         {SND_SOC_TPLG_DAPM_MIXER, snd_soc_dapm_mixer},
 174         {SND_SOC_TPLG_DAPM_PGA, snd_soc_dapm_pga},
 175         {SND_SOC_TPLG_DAPM_OUT_DRV, snd_soc_dapm_out_drv},
 176         {SND_SOC_TPLG_DAPM_ADC, snd_soc_dapm_adc},
 177         {SND_SOC_TPLG_DAPM_DAC, snd_soc_dapm_dac},
 178         {SND_SOC_TPLG_DAPM_SWITCH, snd_soc_dapm_switch},
 179         {SND_SOC_TPLG_DAPM_PRE, snd_soc_dapm_pre},
 180         {SND_SOC_TPLG_DAPM_POST, snd_soc_dapm_post},
 181         {SND_SOC_TPLG_DAPM_AIF_IN, snd_soc_dapm_aif_in},
 182         {SND_SOC_TPLG_DAPM_AIF_OUT, snd_soc_dapm_aif_out},
 183         {SND_SOC_TPLG_DAPM_DAI_IN, snd_soc_dapm_dai_in},
 184         {SND_SOC_TPLG_DAPM_DAI_OUT, snd_soc_dapm_dai_out},
 185         {SND_SOC_TPLG_DAPM_DAI_LINK, snd_soc_dapm_dai_link},
 186 };
 187
 188 static int tplc_chan_get_reg(struct soc_tplg *tplg,
 189         struct snd_soc_tplg_channel *chan, int map)
 190 {
 191         int i;
 192
 193         for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
 194                 if (chan[i].id == map)
 195                         return chan[i].reg;
 196         }
 197
 198         return -EINVAL;
 199 }
 200
 201 static int tplc_chan_get_shift(struct soc_tplg *tplg,
 202         struct snd_soc_tplg_channel *chan, int map)
 203 {
 204         int i;
 205
 206         for (i = 0; i < SND_SOC_TPLG_MAX_CHAN; i++) {
 207                 if (chan[i].id == map)
 208                         return chan[i].shift;
 209         }
 210
 211         return -EINVAL;
 212 }
 213
 214 static int get_widget_id(int tplg_type)
 215 {
 216         int i;
 217
 218         for (i = 0; i < ARRAY_SIZE(dapm_map); i++) {
 219                 if (tplg_type == dapm_map[i].uid)
 220                         return dapm_map[i].kid;
 221         }
 222
 223         return -EINVAL;
 224 }
 225
 226 static enum snd_soc_dobj_type get_dobj_mixer_type(
 227         struct snd_soc_tplg_ctl_hdr *control_hdr)
 228 {
 229         if (control_hdr == NULL)
 230                 return SND_SOC_DOBJ_NONE;
 231
 232         switch (control_hdr->ops.info) {
 233         case SND_SOC_TPLG_CTL_VOLSW:
 234         case SND_SOC_TPLG_CTL_VOLSW_SX:
 235         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
 236         case SND_SOC_TPLG_CTL_RANGE:
 237         case SND_SOC_TPLG_CTL_STROBE:
 238                 return SND_SOC_DOBJ_MIXER;
 239         case SND_SOC_TPLG_CTL_ENUM:
 240         case SND_SOC_TPLG_CTL_ENUM_VALUE:
 241                 return SND_SOC_DOBJ_ENUM;
 242         case SND_SOC_TPLG_CTL_BYTES:
 243                 return SND_SOC_DOBJ_BYTES;
 244         default:
 245                 return SND_SOC_DOBJ_NONE;
 246         }
 247 }
 248
 249 static enum snd_soc_dobj_type get_dobj_type(struct snd_soc_tplg_hdr *hdr,
 250         struct snd_soc_tplg_ctl_hdr *control_hdr)
 251 {
 252         switch (hdr->type) {
 253         case SND_SOC_TPLG_TYPE_MIXER:
 254                 return get_dobj_mixer_type(control_hdr);
 255         case SND_SOC_TPLG_TYPE_DAPM_GRAPH:
 256         case SND_SOC_TPLG_TYPE_MANIFEST:
 257                 return SND_SOC_DOBJ_NONE;
 258         case SND_SOC_TPLG_TYPE_DAPM_WIDGET:
 259                 return SND_SOC_DOBJ_WIDGET;
 260         case SND_SOC_TPLG_TYPE_DAI_LINK:
 261                 return SND_SOC_DOBJ_DAI_LINK;
 262         case SND_SOC_TPLG_TYPE_PCM:
 263                 return SND_SOC_DOBJ_PCM;
 264         case SND_SOC_TPLG_TYPE_CODEC_LINK:
 265                 return SND_SOC_DOBJ_CODEC_LINK;
 266         default:
 267                 return SND_SOC_DOBJ_NONE;
 268         }
 269 }
 270
 271 static inline void soc_bind_err(struct soc_tplg *tplg,
 272         struct snd_soc_tplg_ctl_hdr *hdr, int index)
 273 {
 274         dev_err(tplg->dev,
 275                 "ASoC: invalid control type (g,p,i) %d:%d:%d index %d at 0x%lx\n",
 276                 hdr->ops.get, hdr->ops.put, hdr->ops.info, index,
 277                 soc_tplg_get_offset(tplg));
 278 }
 279
 280 static inline void soc_control_err(struct soc_tplg *tplg,
 281         struct snd_soc_tplg_ctl_hdr *hdr, const char *name)
 282 {
 283         dev_err(tplg->dev,
 284                 "ASoC: no complete mixer IO handler for %s type (g,p,i) %d:%d:%d at 0x%lx\n",
 285                 name, hdr->ops.get, hdr->ops.put, hdr->ops.info,
 286                 soc_tplg_get_offset(tplg));
 287 }
 288
 289 /* pass vendor data to component driver for processing */
 290 static int soc_tplg_vendor_load_(struct soc_tplg *tplg,
 291         struct snd_soc_tplg_hdr *hdr)
 292 {
 293         int ret = 0;
 294
 295         if (tplg->comp && tplg->ops && tplg->ops->vendor_load)
 296                 ret = tplg->ops->vendor_load(tplg->comp, hdr);
 297         else {
 298                 dev_err(tplg->dev, "ASoC: no vendor load callback for ID %d\n",
 299                         hdr->vendor_type);
 300                 return -EINVAL;
 301         }
 302
 303         if (ret < 0)
 304                 dev_err(tplg->dev,
 305                         "ASoC: vendor load failed at hdr offset %ld/0x%lx for type %d:%d\n",
 306                         soc_tplg_get_hdr_offset(tplg),
 307                         soc_tplg_get_hdr_offset(tplg),
 308                         hdr->type, hdr->vendor_type);
 309         return ret;
 310 }
 311
 312 /* pass vendor data to component driver for processing */
 313 static int soc_tplg_vendor_load(struct soc_tplg *tplg,
 314         struct snd_soc_tplg_hdr *hdr)
 315 {
 316         if (tplg->pass != SOC_TPLG_PASS_VENDOR)
 317                 return 0;
 318
 319         return soc_tplg_vendor_load_(tplg, hdr);
 320 }
 321
 322 /* optionally pass new dynamic widget to component driver. This is mainly for
 323  * external widgets where we can assign private data/ops */
 324 static int soc_tplg_widget_load(struct soc_tplg *tplg,
 325         struct snd_soc_dapm_widget *w, struct snd_soc_tplg_dapm_widget *tplg_w)
 326 {
 327         if (tplg->comp && tplg->ops && tplg->ops->widget_load)
 328                 return tplg->ops->widget_load(tplg->comp, w, tplg_w);
 329
 330         return 0;
 331 }
 332
 333 /* pass dynamic FEs configurations to component driver */
 334 static int soc_tplg_pcm_dai_load(struct soc_tplg *tplg,
 335         struct snd_soc_tplg_pcm_dai *pcm_dai, int num_pcm_dai)
 336 {
 337         if (tplg->comp && tplg->ops && tplg->ops->pcm_dai_load)
 338                 return tplg->ops->pcm_dai_load(tplg->comp, pcm_dai, num_pcm_dai);
 339
 340         return 0;
 341 }
 342
 343 /* tell the component driver that all firmware has been loaded in this request */
 344 static void soc_tplg_complete(struct soc_tplg *tplg)
 345 {
 346         if (tplg->comp && tplg->ops && tplg->ops->complete)
 347                 tplg->ops->complete(tplg->comp);
 348 }
 349
 350 /* add a dynamic kcontrol */
 351 static int soc_tplg_add_dcontrol(struct snd_card *card, struct device *dev,
 352         const struct snd_kcontrol_new *control_new, const char *prefix,
 353         void *data, struct snd_kcontrol **kcontrol)
 354 {
 355         int err;
 356
 357         *kcontrol = snd_soc_cnew(control_new, data, control_new->name, prefix);
 358         if (*kcontrol == NULL) {
 359                 dev_err(dev, "ASoC: Failed to create new kcontrol %s\n",
 360                 control_new->name);
 361                 return -ENOMEM;
 362         }
 363
 364         err = snd_ctl_add(card, *kcontrol);
 365         if (err < 0) {
 366                 dev_err(dev, "ASoC: Failed to add %s: %d\n",
 367                         control_new->name, err);
 368                 return err;
 369         }
 370
 371         return 0;
 372 }
 373
 374 /* add a dynamic kcontrol for component driver */
 375 static int soc_tplg_add_kcontrol(struct soc_tplg *tplg,
 376         struct snd_kcontrol_new *k, struct snd_kcontrol **kcontrol)
 377 {
 378         struct snd_soc_component *comp = tplg->comp;
 379
 380         return soc_tplg_add_dcontrol(comp->card->snd_card,
 381                                 comp->dev, k, NULL, comp, kcontrol);
 382 }
 383
 384 /* remove a mixer kcontrol */
 385 static void remove_mixer(struct snd_soc_component *comp,
 386         struct snd_soc_dobj *dobj, int pass)
 387 {
 388         struct snd_card *card = comp->card->snd_card;
 389         struct soc_mixer_control *sm =
 390                 container_of(dobj, struct soc_mixer_control, dobj);
 391         const unsigned int *p = NULL;
 392
 393         if (pass != SOC_TPLG_PASS_MIXER)
 394                 return;
 395
 396         if (dobj->ops && dobj->ops->control_unload)
 397                 dobj->ops->control_unload(comp, dobj);
 398
 399         if (sm->dobj.control.kcontrol->tlv.p)
 400                 p = sm->dobj.control.kcontrol->tlv.p;
 401         snd_ctl_remove(card, sm->dobj.control.kcontrol);
 402         list_del(&sm->dobj.list);
 403         kfree(sm);
 404         kfree(p);
 405 }
 406
 407 /* remove an enum kcontrol */
 408 static void remove_enum(struct snd_soc_component *comp,
 409         struct snd_soc_dobj *dobj, int pass)
 410 {
 411         struct snd_card *card = comp->card->snd_card;
 412         struct soc_enum *se = container_of(dobj, struct soc_enum, dobj);
 413         int i;
 414
 415         if (pass != SOC_TPLG_PASS_MIXER)
 416                 return;
 417
 418         if (dobj->ops && dobj->ops->control_unload)
 419                 dobj->ops->control_unload(comp, dobj);
 420
 421         snd_ctl_remove(card, se->dobj.control.kcontrol);
 422         list_del(&se->dobj.list);
 423
 424         kfree(se->dobj.control.dvalues);
 425         for (i = 0; i < se->items; i++)
 426                 kfree(se->dobj.control.dtexts[i]);
 427         kfree(se);
 428 }
 429
 430 /* remove a byte kcontrol */
 431 static void remove_bytes(struct snd_soc_component *comp,
 432         struct snd_soc_dobj *dobj, int pass)
 433 {
 434         struct snd_card *card = comp->card->snd_card;
 435         struct soc_bytes_ext *sb =
 436                 container_of(dobj, struct soc_bytes_ext, dobj);
 437
 438         if (pass != SOC_TPLG_PASS_MIXER)
 439                 return;
 440
 441         if (dobj->ops && dobj->ops->control_unload)
 442                 dobj->ops->control_unload(comp, dobj);
 443
 444         snd_ctl_remove(card, sb->dobj.control.kcontrol);
 445         list_del(&sb->dobj.list);
 446         kfree(sb);
 447 }
 448
 449 /* remove a widget and it's kcontrols - routes must be removed first */
 450 static void remove_widget(struct snd_soc_component *comp,
 451         struct snd_soc_dobj *dobj, int pass)
 452 {
 453         struct snd_card *card = comp->card->snd_card;
 454         struct snd_soc_dapm_widget *w =
 455                 container_of(dobj, struct snd_soc_dapm_widget, dobj);
 456         int i;
 457
 458         if (pass != SOC_TPLG_PASS_WIDGET)
 459                 return;
 460
 461         if (dobj->ops && dobj->ops->widget_unload)
 462                 dobj->ops->widget_unload(comp, dobj);
 463
 464         /*
 465          * Dynamic Widgets either have 1 enum kcontrol or 1..N mixers.
 466          * The enum may either have an array of values or strings.
 467          */
 468         if (dobj->widget.kcontrol_enum) {
 469                 /* enumerated widget mixer */
 470                 struct soc_enum *se =
 471                         (struct soc_enum *)w->kcontrols[0]->private_value;
 472
 473                 snd_ctl_remove(card, w->kcontrols[0]);
 474
 475                 kfree(se->dobj.control.dvalues);
 476                 for (i = 0; i < se->items; i++)
 477                         kfree(se->dobj.control.dtexts[i]);
 478
 479                 kfree(se);
 480                 kfree(w->kcontrol_news);
 481         } else {
 482                 /* non enumerated widget mixer */
 483                 for (i = 0; i < w->num_kcontrols; i++) {
 484                         struct snd_kcontrol *kcontrol = w->kcontrols[i];
 485                         struct soc_mixer_control *sm =
 486                         (struct soc_mixer_control *) kcontrol->private_value;
 487
 488                         kfree(w->kcontrols[i]->tlv.p);
 489
 490                         snd_ctl_remove(card, w->kcontrols[i]);
 491                         kfree(sm);
 492                 }
 493                 kfree(w->kcontrol_news);
 494         }
 495         /* widget w is freed by soc-dapm.c */
 496 }
 497
 498 /* remove PCM DAI configurations */
 499 static void remove_pcm_dai(struct snd_soc_component *comp,
 500         struct snd_soc_dobj *dobj, int pass)
 501 {
 502         if (pass != SOC_TPLG_PASS_PCM_DAI)
 503                 return;
 504
 505         if (dobj->ops && dobj->ops->pcm_dai_unload)
 506                 dobj->ops->pcm_dai_unload(comp, dobj);
 507
 508         list_del(&dobj->list);
 509         kfree(dobj);
 510 }
 511
 512 /* bind a kcontrol to it's IO handlers */
 513 static int soc_tplg_kcontrol_bind_io(struct snd_soc_tplg_ctl_hdr *hdr,
 514         struct snd_kcontrol_new *k,
 515         const struct soc_tplg *tplg)
 516 {
 517         const struct snd_soc_tplg_kcontrol_ops *ops;
 518         const struct snd_soc_tplg_bytes_ext_ops *ext_ops;
 519         int num_ops, i;
 520
 521         if (hdr->ops.info == SND_SOC_TPLG_CTL_BYTES
 522                 && k->iface & SNDRV_CTL_ELEM_IFACE_MIXER
 523                 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE
 524                 && k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
 525                 struct soc_bytes_ext *sbe;
 526                 struct snd_soc_tplg_bytes_control *be;
 527
 528                 sbe = (struct soc_bytes_ext *)k->private_value;
 529                 be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
 530
 531                 /* TLV bytes controls need standard kcontrol info handler,
 532                  * TLV callback and extended put/get handlers.
 533                  */
 534                 k->info = snd_soc_bytes_info_ext;
 535                 k->tlv.c = snd_soc_bytes_tlv_callback;
 536
 537                 ext_ops = tplg->bytes_ext_ops;
 538                 num_ops = tplg->bytes_ext_ops_count;
 539                 for (i = 0; i < num_ops; i++) {
 540                         if (!sbe->put && ext_ops[i].id == be->ext_ops.put)
 541                                 sbe->put = ext_ops[i].put;
 542                         if (!sbe->get && ext_ops[i].id == be->ext_ops.get)
 543                                 sbe->get = ext_ops[i].get;
 544                 }
 545
 546                 if (sbe->put && sbe->get)
 547                         return 0;
 548                 else
 549                         return -EINVAL;
 550         }
 551
 552         /* try and map vendor specific kcontrol handlers first */
 553         ops = tplg->io_ops;
 554         num_ops = tplg->io_ops_count;
 555         for (i = 0; i < num_ops; i++) {
 556
 557                 if (k->put == NULL && ops[i].id == hdr->ops.put)
 558                         k->put = ops[i].put;
 559                 if (k->get == NULL && ops[i].id == hdr->ops.get)
 560                         k->get = ops[i].get;
 561                 if (k->info == NULL && ops[i].id == hdr->ops.info)
 562                         k->info = ops[i].info;
 563         }
 564
 565         /* vendor specific handlers found ? */
 566         if (k->put && k->get && k->info)
 567                 return 0;
 568
 569         /* none found so try standard kcontrol handlers */
 570         ops = io_ops;
 571         num_ops = ARRAY_SIZE(io_ops);
 572         for (i = 0; i < num_ops; i++) {
 573
 574                 if (k->put == NULL && ops[i].id == hdr->ops.put)
 575                         k->put = ops[i].put;
 576                 if (k->get == NULL && ops[i].id == hdr->ops.get)
 577                         k->get = ops[i].get;
 578                 if (k->info == NULL && ops[i].id == hdr->ops.info)
 579                         k->info = ops[i].info;
 580         }
 581
 582         /* standard handlers found ? */
 583         if (k->put && k->get && k->info)
 584                 return 0;
 585
 586         /* nothing to bind */
 587         return -EINVAL;
 588 }
 589
 590 /* bind a widgets to it's evnt handlers */
 591 int snd_soc_tplg_widget_bind_event(struct snd_soc_dapm_widget *w,
 592                 const struct snd_soc_tplg_widget_events *events,
 593                 int num_events, u16 event_type)
 594 {
 595         int i;
 596
 597         w->event = NULL;
 598
 599         for (i = 0; i < num_events; i++) {
 600                 if (event_type == events[i].type) {
 601
 602                         /* found - so assign event */
 603                         w->event = events[i].event_handler;
 604                         return 0;
 605                 }
 606         }
 607
 608         /* not found */
 609         return -EINVAL;
 610 }
 611 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_bind_event);
 612
 613 /* optionally pass new dynamic kcontrol to component driver. */
 614 static int soc_tplg_init_kcontrol(struct soc_tplg *tplg,
 615         struct snd_kcontrol_new *k, struct snd_soc_tplg_ctl_hdr *hdr)
 616 {
 617         if (tplg->comp && tplg->ops && tplg->ops->control_load)
 618                 return tplg->ops->control_load(tplg->comp, k, hdr);
 619
 620         return 0;
 621 }
 622
 623
 624 static int soc_tplg_create_tlv_db_scale(struct soc_tplg *tplg,
 625         struct snd_kcontrol_new *kc, struct snd_soc_tplg_tlv_dbscale *scale)
 626 {
 627         unsigned int item_len = 2 * sizeof(unsigned int);
 628         unsigned int *p;
 629
 630         p = kzalloc(item_len + 2 * sizeof(unsigned int), GFP_KERNEL);
 631         if (!p)
 632                 return -ENOMEM;
 633
 634         p[0] = SNDRV_CTL_TLVT_DB_SCALE;
 635         p[1] = item_len;
 636         p[2] = scale->min;
 637         p[3] = (scale->step & TLV_DB_SCALE_MASK)
 638                         | (scale->mute ? TLV_DB_SCALE_MUTE : 0);
 639
 640         kc->tlv.p = (void *)p;
 641         return 0;
 642 }
 643
 644 static int soc_tplg_create_tlv(struct soc_tplg *tplg,
 645         struct snd_kcontrol_new *kc, struct snd_soc_tplg_ctl_hdr *tc)
 646 {
 647         struct snd_soc_tplg_ctl_tlv *tplg_tlv;
 648
 649         if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE))
 650                 return 0;
 651
 652         if (!(tc->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK)) {
 653                 tplg_tlv = &tc->tlv;
 654                 switch (tplg_tlv->type) {
 655                 case SNDRV_CTL_TLVT_DB_SCALE:
 656                         return soc_tplg_create_tlv_db_scale(tplg, kc,
 657                                         &tplg_tlv->scale);
 658
 659                 /* TODO: add support for other TLV types */
 660                 default:
 661                         dev_dbg(tplg->dev, "Unsupported TLV type %d\n",
 662                                         tplg_tlv->type);
 663                         return -EINVAL;
 664                 }
 665         }
 666
 667         return 0;
 668 }
 669
 670 static inline void soc_tplg_free_tlv(struct soc_tplg *tplg,
 671         struct snd_kcontrol_new *kc)
 672 {
 673         kfree(kc->tlv.p);
 674 }
 675
 676 static int soc_tplg_dbytes_create(struct soc_tplg *tplg, unsigned int count,
 677         size_t size)
 678 {
 679         struct snd_soc_tplg_bytes_control *be;
 680         struct soc_bytes_ext *sbe;
 681         struct snd_kcontrol_new kc;
 682         int i, err;
 683
 684         if (soc_tplg_check_elem_count(tplg,
 685                 sizeof(struct snd_soc_tplg_bytes_control), count,
 686                         size, "mixer bytes")) {
 687                 dev_err(tplg->dev, "ASoC: Invalid count %d for byte control\n",
 688                         count);
 689                 return -EINVAL;
 690         }
 691
 692         for (i = 0; i < count; i++) {
 693                 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
 694
 695                 /* validate kcontrol */
 696                 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
 697                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
 698                         return -EINVAL;
 699
 700                 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
 701                 if (sbe == NULL)
 702                         return -ENOMEM;
 703
 704                 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
 705                         be->priv.size);
 706
 707                 dev_dbg(tplg->dev,
 708                         "ASoC: adding bytes kcontrol %s with access 0x%x\n",
 709                         be->hdr.name, be->hdr.access);
 710
 711                 memset(&kc, 0, sizeof(kc));
 712                 kc.name = be->hdr.name;
 713                 kc.private_value = (long)sbe;
 714                 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 715                 kc.access = be->hdr.access;
 716
 717                 sbe->max = be->max;
 718                 sbe->dobj.type = SND_SOC_DOBJ_BYTES;
 719                 sbe->dobj.ops = tplg->ops;
 720                 INIT_LIST_HEAD(&sbe->dobj.list);
 721
 722                 /* map io handlers */
 723                 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg);
 724                 if (err) {
 725                         soc_control_err(tplg, &be->hdr, be->hdr.name);
 726                         kfree(sbe);
 727                         continue;
 728                 }
 729
 730                 /* pass control to driver for optional further init */
 731                 err = soc_tplg_init_kcontrol(tplg, &kc,
 732                         (struct snd_soc_tplg_ctl_hdr *)be);
 733                 if (err < 0) {
 734                         dev_err(tplg->dev, "ASoC: failed to init %s\n",
 735                                 be->hdr.name);
 736                         kfree(sbe);
 737                         continue;
 738                 }
 739
 740                 /* register control here */
 741                 err = soc_tplg_add_kcontrol(tplg, &kc,
 742                         &sbe->dobj.control.kcontrol);
 743                 if (err < 0) {
 744                         dev_err(tplg->dev, "ASoC: failed to add %s\n",
 745                                 be->hdr.name);
 746                         kfree(sbe);
 747                         continue;
 748                 }
 749
 750                 list_add(&sbe->dobj.list, &tplg->comp->dobj_list);
 751         }
 752         return 0;
 753
 754 }
 755
 756 static int soc_tplg_dmixer_create(struct soc_tplg *tplg, unsigned int count,
 757         size_t size)
 758 {
 759         struct snd_soc_tplg_mixer_control *mc;
 760         struct soc_mixer_control *sm;
 761         struct snd_kcontrol_new kc;
 762         int i, err;
 763
 764         if (soc_tplg_check_elem_count(tplg,
 765                 sizeof(struct snd_soc_tplg_mixer_control),
 766                 count, size, "mixers")) {
 767
 768                 dev_err(tplg->dev, "ASoC: invalid count %d for controls\n",
 769                         count);
 770                 return -EINVAL;
 771         }
 772
 773         for (i = 0; i < count; i++) {
 774                 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
 775
 776                 /* validate kcontrol */
 777                 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
 778                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
 779                         return -EINVAL;
 780
 781                 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
 782                 if (sm == NULL)
 783                         return -ENOMEM;
 784                 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
 785                         mc->priv.size);
 786
 787                 dev_dbg(tplg->dev,
 788                         "ASoC: adding mixer kcontrol %s with access 0x%x\n",
 789                         mc->hdr.name, mc->hdr.access);
 790
 791                 memset(&kc, 0, sizeof(kc));
 792                 kc.name = mc->hdr.name;
 793                 kc.private_value = (long)sm;
 794                 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 795                 kc.access = mc->hdr.access;
 796
 797                 /* we only support FL/FR channel mapping atm */
 798                 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
 799                         SNDRV_CHMAP_FL);
 800                 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
 801                         SNDRV_CHMAP_FR);
 802                 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
 803                         SNDRV_CHMAP_FL);
 804                 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
 805                         SNDRV_CHMAP_FR);
 806
 807                 sm->max = mc->max;
 808                 sm->min = mc->min;
 809                 sm->invert = mc->invert;
 810                 sm->platform_max = mc->platform_max;
 811                 sm->dobj.index = tplg->index;
 812                 sm->dobj.ops = tplg->ops;
 813                 sm->dobj.type = SND_SOC_DOBJ_MIXER;
 814                 INIT_LIST_HEAD(&sm->dobj.list);
 815
 816                 /* map io handlers */
 817                 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc, tplg);
 818                 if (err) {
 819                         soc_control_err(tplg, &mc->hdr, mc->hdr.name);
 820                         kfree(sm);
 821                         continue;
 822                 }
 823
 824                 /* pass control to driver for optional further init */
 825                 err = soc_tplg_init_kcontrol(tplg, &kc,
 826                         (struct snd_soc_tplg_ctl_hdr *) mc);
 827                 if (err < 0) {
 828                         dev_err(tplg->dev, "ASoC: failed to init %s\n",
 829                                 mc->hdr.name);
 830                         kfree(sm);
 831                         continue;
 832                 }
 833
 834                 /* create any TLV data */
 835                 soc_tplg_create_tlv(tplg, &kc, &mc->hdr);
 836
 837                 /* register control here */
 838                 err = soc_tplg_add_kcontrol(tplg, &kc,
 839                         &sm->dobj.control.kcontrol);
 840                 if (err < 0) {
 841                         dev_err(tplg->dev, "ASoC: failed to add %s\n",
 842                                 mc->hdr.name);
 843                         soc_tplg_free_tlv(tplg, &kc);
 844                         kfree(sm);
 845                         continue;
 846                 }
 847
 848                 list_add(&sm->dobj.list, &tplg->comp->dobj_list);
 849         }
 850
 851         return 0;
 852 }
 853
 854 static int soc_tplg_denum_create_texts(struct soc_enum *se,
 855         struct snd_soc_tplg_enum_control *ec)
 856 {
 857         int i, ret;
 858
 859         se->dobj.control.dtexts =
 860                 kzalloc(sizeof(char *) * ec->items, GFP_KERNEL);
 861         if (se->dobj.control.dtexts == NULL)
 862                 return -ENOMEM;
 863
 864         for (i = 0; i < ec->items; i++) {
 865
 866                 if (strnlen(ec->texts[i], SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
 867                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN) {
 868                         ret = -EINVAL;
 869                         goto err;
 870                 }
 871
 872                 se->dobj.control.dtexts[i] = kstrdup(ec->texts[i], GFP_KERNEL);
 873                 if (!se->dobj.control.dtexts[i]) {
 874                         ret = -ENOMEM;
 875                         goto err;
 876                 }
 877         }
 878
 879         return 0;
 880
 881 err:
 882         for (--i; i >= 0; i--)
 883                 kfree(se->dobj.control.dtexts[i]);
 884         kfree(se->dobj.control.dtexts);
 885         return ret;
 886 }
 887
 888 static int soc_tplg_denum_create_values(struct soc_enum *se,
 889         struct snd_soc_tplg_enum_control *ec)
 890 {
 891         if (ec->items > sizeof(*ec->values))
 892                 return -EINVAL;
 893
 894         se->dobj.control.dvalues = kmemdup(ec->values,
 895                                            ec->items * sizeof(u32),
 896                                            GFP_KERNEL);
 897         if (!se->dobj.control.dvalues)
 898                 return -ENOMEM;
 899
 900         return 0;
 901 }
 902
 903 static int soc_tplg_denum_create(struct soc_tplg *tplg, unsigned int count,
 904         size_t size)
 905 {
 906         struct snd_soc_tplg_enum_control *ec;
 907         struct soc_enum *se;
 908         struct snd_kcontrol_new kc;
 909         int i, ret, err;
 910
 911         if (soc_tplg_check_elem_count(tplg,
 912                 sizeof(struct snd_soc_tplg_enum_control),
 913                 count, size, "enums")) {
 914
 915                 dev_err(tplg->dev, "ASoC: invalid count %d for enum controls\n",
 916                         count);
 917                 return -EINVAL;
 918         }
 919
 920         for (i = 0; i < count; i++) {
 921                 ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
 922                 tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
 923                         ec->priv.size);
 924
 925                 /* validate kcontrol */
 926                 if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
 927                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
 928                         return -EINVAL;
 929
 930                 se = kzalloc((sizeof(*se)), GFP_KERNEL);
 931                 if (se == NULL)
 932                         return -ENOMEM;
 933
 934                 dev_dbg(tplg->dev, "ASoC: adding enum kcontrol %s size %d\n",
 935                         ec->hdr.name, ec->items);
 936
 937                 memset(&kc, 0, sizeof(kc));
 938                 kc.name = ec->hdr.name;
 939                 kc.private_value = (long)se;
 940                 kc.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 941                 kc.access = ec->hdr.access;
 942
 943                 se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
 944                 se->shift_l = tplc_chan_get_shift(tplg, ec->channel,
 945                         SNDRV_CHMAP_FL);
 946                 se->shift_r = tplc_chan_get_shift(tplg, ec->channel,
 947                         SNDRV_CHMAP_FL);
 948
 949                 se->items = ec->items;
 950                 se->mask = ec->mask;
 951                 se->dobj.index = tplg->index;
 952                 se->dobj.type = SND_SOC_DOBJ_ENUM;
 953                 se->dobj.ops = tplg->ops;
 954                 INIT_LIST_HEAD(&se->dobj.list);
 955
 956                 switch (ec->hdr.ops.info) {
 957                 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
 958                 case SND_SOC_TPLG_CTL_ENUM_VALUE:
 959                         err = soc_tplg_denum_create_values(se, ec);
 960                         if (err < 0) {
 961                                 dev_err(tplg->dev,
 962                                         "ASoC: could not create values for %s\n",
 963                                         ec->hdr.name);
 964                                 kfree(se);
 965                                 continue;
 966                         }
 967                         /* fall through and create texts */
 968                 case SND_SOC_TPLG_CTL_ENUM:
 969                 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
 970                 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
 971                         err = soc_tplg_denum_create_texts(se, ec);
 972                         if (err < 0) {
 973                                 dev_err(tplg->dev,
 974                                         "ASoC: could not create texts for %s\n",
 975                                         ec->hdr.name);
 976                                 kfree(se);
 977                                 continue;
 978                         }
 979                         break;
 980                 default:
 981                         dev_err(tplg->dev,
 982                                 "ASoC: invalid enum control type %d for %s\n",
 983                                 ec->hdr.ops.info, ec->hdr.name);
 984                         kfree(se);
 985                         continue;
 986                 }
 987
 988                 /* map io handlers */
 989                 err = soc_tplg_kcontrol_bind_io(&ec->hdr, &kc, tplg);
 990                 if (err) {
 991                         soc_control_err(tplg, &ec->hdr, ec->hdr.name);
 992                         kfree(se);
 993                         continue;
 994                 }
 995
 996                 /* pass control to driver for optional further init */
 997                 err = soc_tplg_init_kcontrol(tplg, &kc,
 998                         (struct snd_soc_tplg_ctl_hdr *) ec);
 999                 if (err < 0) {
1000                         dev_err(tplg->dev, "ASoC: failed to init %s\n",
1001                                 ec->hdr.name);
1002                         kfree(se);
1003                         continue;
1004                 }
1005
1006                 /* register control here */
1007                 ret = soc_tplg_add_kcontrol(tplg,
1008                         &kc, &se->dobj.control.kcontrol);
1009                 if (ret < 0) {
1010                         dev_err(tplg->dev, "ASoC: could not add kcontrol %s\n",
1011                                 ec->hdr.name);
1012                         kfree(se);
1013                         continue;
1014                 }
1015
1016                 list_add(&se->dobj.list, &tplg->comp->dobj_list);
1017         }
1018
1019         return 0;
1020 }
1021
1022 static int soc_tplg_kcontrol_elems_load(struct soc_tplg *tplg,
1023         struct snd_soc_tplg_hdr *hdr)
1024 {
1025         struct snd_soc_tplg_ctl_hdr *control_hdr;
1026         int i;
1027
1028         if (tplg->pass != SOC_TPLG_PASS_MIXER) {
1029                 tplg->pos += hdr->size + hdr->payload_size;
1030                 return 0;
1031         }
1032
1033         dev_dbg(tplg->dev, "ASoC: adding %d kcontrols at 0x%lx\n", hdr->count,
1034                 soc_tplg_get_offset(tplg));
1035
1036         for (i = 0; i < hdr->count; i++) {
1037
1038                 control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1039
1040                 switch (control_hdr->ops.info) {
1041                 case SND_SOC_TPLG_CTL_VOLSW:
1042                 case SND_SOC_TPLG_CTL_STROBE:
1043                 case SND_SOC_TPLG_CTL_VOLSW_SX:
1044                 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1045                 case SND_SOC_TPLG_CTL_RANGE:
1046                 case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1047                 case SND_SOC_TPLG_DAPM_CTL_PIN:
1048                         soc_tplg_dmixer_create(tplg, 1, hdr->payload_size);
1049                         break;
1050                 case SND_SOC_TPLG_CTL_ENUM:
1051                 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1052                 case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1053                 case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1054                 case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1055                         soc_tplg_denum_create(tplg, 1, hdr->payload_size);
1056                         break;
1057                 case SND_SOC_TPLG_CTL_BYTES:
1058                         soc_tplg_dbytes_create(tplg, 1, hdr->payload_size);
1059                         break;
1060                 default:
1061                         soc_bind_err(tplg, control_hdr, i);
1062                         return -EINVAL;
1063                 }
1064         }
1065
1066         return 0;
1067 }
1068
1069 static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg,
1070         struct snd_soc_tplg_hdr *hdr)
1071 {
1072         struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1073         struct snd_soc_dapm_route route;
1074         struct snd_soc_tplg_dapm_graph_elem *elem;
1075         int count = hdr->count, i;
1076
1077         if (tplg->pass != SOC_TPLG_PASS_GRAPH) {
1078                 tplg->pos += hdr->size + hdr->payload_size;
1079                 return 0;
1080         }
1081
1082         if (soc_tplg_check_elem_count(tplg,
1083                 sizeof(struct snd_soc_tplg_dapm_graph_elem),
1084                 count, hdr->payload_size, "graph")) {
1085
1086                 dev_err(tplg->dev, "ASoC: invalid count %d for DAPM routes\n",
1087                         count);
1088                 return -EINVAL;
1089         }
1090
1091         dev_dbg(tplg->dev, "ASoC: adding %d DAPM routes\n", count);
1092
1093         for (i = 0; i < count; i++) {
1094                 elem = (struct snd_soc_tplg_dapm_graph_elem *)tplg->pos;
1095                 tplg->pos += sizeof(struct snd_soc_tplg_dapm_graph_elem);
1096
1097                 /* validate routes */
1098                 if (strnlen(elem->source, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1099                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1100                         return -EINVAL;
1101                 if (strnlen(elem->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1102                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1103                         return -EINVAL;
1104                 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1105                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1106                         return -EINVAL;
1107
1108                 route.source = elem->source;
1109                 route.sink = elem->sink;
1110                 route.connected = NULL; /* set to NULL atm for tplg users */
1111                 if (strnlen(elem->control, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) == 0)
1112                         route.control = NULL;
1113                 else
1114                         route.control = elem->control;
1115
1116                 /* add route, but keep going if some fail */
1117                 snd_soc_dapm_add_routes(dapm, &route, 1);
1118         }
1119
1120         return 0;
1121 }
1122
1123 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create(
1124         struct soc_tplg *tplg, int num_kcontrols)
1125 {
1126         struct snd_kcontrol_new *kc;
1127         struct soc_mixer_control *sm;
1128         struct snd_soc_tplg_mixer_control *mc;
1129         int i, err;
1130
1131         kc = kcalloc(num_kcontrols, sizeof(*kc), GFP_KERNEL);
1132         if (kc == NULL)
1133                 return NULL;
1134
1135         for (i = 0; i < num_kcontrols; i++) {
1136                 mc = (struct snd_soc_tplg_mixer_control *)tplg->pos;
1137                 sm = kzalloc(sizeof(*sm), GFP_KERNEL);
1138                 if (sm == NULL)
1139                         goto err;
1140
1141                 tplg->pos += (sizeof(struct snd_soc_tplg_mixer_control) +
1142                         mc->priv.size);
1143
1144                 /* validate kcontrol */
1145                 if (strnlen(mc->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1146                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1147                         goto err_str;
1148
1149                 dev_dbg(tplg->dev, " adding DAPM widget mixer control %s at %d\n",
1150                         mc->hdr.name, i);
1151
1152                 kc[i].name = mc->hdr.name;
1153                 kc[i].private_value = (long)sm;
1154                 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1155                 kc[i].access = mc->hdr.access;
1156
1157                 /* we only support FL/FR channel mapping atm */
1158                 sm->reg = tplc_chan_get_reg(tplg, mc->channel,
1159                         SNDRV_CHMAP_FL);
1160                 sm->rreg = tplc_chan_get_reg(tplg, mc->channel,
1161                         SNDRV_CHMAP_FR);
1162                 sm->shift = tplc_chan_get_shift(tplg, mc->channel,
1163                         SNDRV_CHMAP_FL);
1164                 sm->rshift = tplc_chan_get_shift(tplg, mc->channel,
1165                         SNDRV_CHMAP_FR);
1166
1167                 sm->max = mc->max;
1168                 sm->min = mc->min;
1169                 sm->invert = mc->invert;
1170                 sm->platform_max = mc->platform_max;
1171                 sm->dobj.index = tplg->index;
1172                 INIT_LIST_HEAD(&sm->dobj.list);
1173
1174                 /* map io handlers */
1175                 err = soc_tplg_kcontrol_bind_io(&mc->hdr, &kc[i], tplg);
1176                 if (err) {
1177                         soc_control_err(tplg, &mc->hdr, mc->hdr.name);
1178                         kfree(sm);
1179                         continue;
1180                 }
1181
1182                 /* pass control to driver for optional further init */
1183                 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1184                         (struct snd_soc_tplg_ctl_hdr *)mc);
1185                 if (err < 0) {
1186                         dev_err(tplg->dev, "ASoC: failed to init %s\n",
1187                                 mc->hdr.name);
1188                         kfree(sm);
1189                         continue;
1190                 }
1191
1192                 /* create any TLV data */
1193                 soc_tplg_create_tlv(tplg, &kc[i], &mc->hdr);
1194         }
1195         return kc;
1196
1197 err_str:
1198         kfree(sm);
1199 err:
1200         for (--i; i >= 0; i--)
1201                 kfree((void *)kc[i].private_value);
1202         kfree(kc);
1203         return NULL;
1204 }
1205
1206 static struct snd_kcontrol_new *soc_tplg_dapm_widget_denum_create(
1207         struct soc_tplg *tplg)
1208 {
1209         struct snd_kcontrol_new *kc;
1210         struct snd_soc_tplg_enum_control *ec;
1211         struct soc_enum *se;
1212         int i, err;
1213
1214         ec = (struct snd_soc_tplg_enum_control *)tplg->pos;
1215         tplg->pos += (sizeof(struct snd_soc_tplg_enum_control) +
1216                 ec->priv.size);
1217
1218         /* validate kcontrol */
1219         if (strnlen(ec->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1220                 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1221                 return NULL;
1222
1223         kc = kzalloc(sizeof(*kc), GFP_KERNEL);
1224         if (kc == NULL)
1225                 return NULL;
1226
1227         se = kzalloc(sizeof(*se), GFP_KERNEL);
1228         if (se == NULL)
1229                 goto err;
1230
1231         dev_dbg(tplg->dev, " adding DAPM widget enum control %s\n",
1232                 ec->hdr.name);
1233
1234         kc->name = ec->hdr.name;
1235         kc->private_value = (long)se;
1236         kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1237         kc->access = ec->hdr.access;
1238
1239         /* we only support FL/FR channel mapping atm */
1240         se->reg = tplc_chan_get_reg(tplg, ec->channel, SNDRV_CHMAP_FL);
1241         se->shift_l = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FL);
1242         se->shift_r = tplc_chan_get_shift(tplg, ec->channel, SNDRV_CHMAP_FR);
1243
1244         se->items = ec->items;
1245         se->mask = ec->mask;
1246         se->dobj.index = tplg->index;
1247
1248         switch (ec->hdr.ops.info) {
1249         case SND_SOC_TPLG_CTL_ENUM_VALUE:
1250         case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1251                 err = soc_tplg_denum_create_values(se, ec);
1252                 if (err < 0) {
1253                         dev_err(tplg->dev, "ASoC: could not create values for %s\n",
1254                                 ec->hdr.name);
1255                         goto err_se;
1256                 }
1257                 /* fall through to create texts */
1258         case SND_SOC_TPLG_CTL_ENUM:
1259         case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1260         case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1261                 err = soc_tplg_denum_create_texts(se, ec);
1262                 if (err < 0) {
1263                         dev_err(tplg->dev, "ASoC: could not create texts for %s\n",
1264                                 ec->hdr.name);
1265                         goto err_se;
1266                 }
1267                 break;
1268         default:
1269                 dev_err(tplg->dev, "ASoC: invalid enum control type %d for %s\n",
1270                         ec->hdr.ops.info, ec->hdr.name);
1271                 goto err_se;
1272         }
1273
1274         /* map io handlers */
1275         err = soc_tplg_kcontrol_bind_io(&ec->hdr, kc, tplg);
1276         if (err) {
1277                 soc_control_err(tplg, &ec->hdr, ec->hdr.name);
1278                 goto err_se;
1279         }
1280
1281         /* pass control to driver for optional further init */
1282         err = soc_tplg_init_kcontrol(tplg, kc,
1283                 (struct snd_soc_tplg_ctl_hdr *)ec);
1284         if (err < 0) {
1285                 dev_err(tplg->dev, "ASoC: failed to init %s\n",
1286                         ec->hdr.name);
1287                 goto err_se;
1288         }
1289
1290         return kc;
1291
1292 err_se:
1293         /* free values and texts */
1294         kfree(se->dobj.control.dvalues);
1295         for (i = 0; i < ec->items; i++)
1296                 kfree(se->dobj.control.dtexts[i]);
1297
1298         kfree(se);
1299 err:
1300         kfree(kc);
1301
1302         return NULL;
1303 }
1304
1305 static struct snd_kcontrol_new *soc_tplg_dapm_widget_dbytes_create(
1306         struct soc_tplg *tplg, int count)
1307 {
1308         struct snd_soc_tplg_bytes_control *be;
1309         struct soc_bytes_ext  *sbe;
1310         struct snd_kcontrol_new *kc;
1311         int i, err;
1312
1313         kc = kcalloc(count, sizeof(*kc), GFP_KERNEL);
1314         if (!kc)
1315                 return NULL;
1316
1317         for (i = 0; i < count; i++) {
1318                 be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
1319
1320                 /* validate kcontrol */
1321                 if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1322                         SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1323                         goto err;
1324
1325                 sbe = kzalloc(sizeof(*sbe), GFP_KERNEL);
1326                 if (sbe == NULL)
1327                         goto err;
1328
1329                 tplg->pos += (sizeof(struct snd_soc_tplg_bytes_control) +
1330                         be->priv.size);
1331
1332                 dev_dbg(tplg->dev,
1333                         "ASoC: adding bytes kcontrol %s with access 0x%x\n",
1334                         be->hdr.name, be->hdr.access);
1335
1336                 kc[i].name = be->hdr.name;
1337                 kc[i].private_value = (long)sbe;
1338                 kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1339                 kc[i].access = be->hdr.access;
1340
1341                 sbe->max = be->max;
1342                 INIT_LIST_HEAD(&sbe->dobj.list);
1343
1344                 /* map standard io handlers and check for external handlers */
1345                 err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg);
1346                 if (err) {
1347                         soc_control_err(tplg, &be->hdr, be->hdr.name);
1348                         kfree(sbe);
1349                         continue;
1350                 }
1351
1352                 /* pass control to driver for optional further init */
1353                 err = soc_tplg_init_kcontrol(tplg, &kc[i],
1354                         (struct snd_soc_tplg_ctl_hdr *)be);
1355                 if (err < 0) {
1356                         dev_err(tplg->dev, "ASoC: failed to init %s\n",
1357                                 be->hdr.name);
1358                         kfree(sbe);
1359                         continue;
1360                 }
1361         }
1362
1363         return kc;
1364
1365 err:
1366         for (--i; i >= 0; i--)
1367                 kfree((void *)kc[i].private_value);
1368
1369         kfree(kc);
1370         return NULL;
1371 }
1372
1373 static int soc_tplg_dapm_widget_create(struct soc_tplg *tplg,
1374         struct snd_soc_tplg_dapm_widget *w)
1375 {
1376         struct snd_soc_dapm_context *dapm = &tplg->comp->dapm;
1377         struct snd_soc_dapm_widget template, *widget;
1378         struct snd_soc_tplg_ctl_hdr *control_hdr;
1379         struct snd_soc_card *card = tplg->comp->card;
1380         int ret = 0;
1381
1382         if (strnlen(w->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1383                 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1384                 return -EINVAL;
1385         if (strnlen(w->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
1386                 SNDRV_CTL_ELEM_ID_NAME_MAXLEN)
1387                 return -EINVAL;
1388
1389         dev_dbg(tplg->dev, "ASoC: creating DAPM widget %s id %d\n",
1390                 w->name, w->id);
1391
1392         memset(&template, 0, sizeof(template));
1393
1394         /* map user to kernel widget ID */
1395         template.id = get_widget_id(w->id);
1396         if (template.id < 0)
1397                 return template.id;
1398
1399         template.name = kstrdup(w->name, GFP_KERNEL);
1400         if (!template.name)
1401                 return -ENOMEM;
1402         template.sname = kstrdup(w->sname, GFP_KERNEL);
1403         if (!template.sname) {
1404                 ret = -ENOMEM;
1405                 goto err;
1406         }
1407         template.reg = w->reg;
1408         template.shift = w->shift;
1409         template.mask = w->mask;
1410         template.subseq = w->subseq;
1411         template.on_val = w->invert ? 0 : 1;
1412         template.off_val = w->invert ? 1 : 0;
1413         template.ignore_suspend = w->ignore_suspend;
1414         template.event_flags = w->event_flags;
1415         template.dobj.index = tplg->index;
1416
1417         tplg->pos +=
1418                 (sizeof(struct snd_soc_tplg_dapm_widget) + w->priv.size);
1419         if (w->num_kcontrols == 0) {
1420                 template.num_kcontrols = 0;
1421                 goto widget;
1422         }
1423
1424         control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
1425         dev_dbg(tplg->dev, "ASoC: template %s has %d controls of type %x\n",
1426                 w->name, w->num_kcontrols, control_hdr->type);
1427
1428         switch (control_hdr->ops.info) {
1429         case SND_SOC_TPLG_CTL_VOLSW:
1430         case SND_SOC_TPLG_CTL_STROBE:
1431         case SND_SOC_TPLG_CTL_VOLSW_SX:
1432         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1433         case SND_SOC_TPLG_CTL_RANGE:
1434         case SND_SOC_TPLG_DAPM_CTL_VOLSW:
1435                 template.num_kcontrols = w->num_kcontrols;
1436                 template.kcontrol_news =
1437                         soc_tplg_dapm_widget_dmixer_create(tplg,
1438                         template.num_kcontrols);
1439                 if (!template.kcontrol_news) {
1440                         ret = -ENOMEM;
1441                         goto hdr_err;
1442                 }
1443                 break;
1444         case SND_SOC_TPLG_CTL_ENUM:
1445         case SND_SOC_TPLG_CTL_ENUM_VALUE:
1446         case SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE:
1447         case SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT:
1448         case SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE:
1449                 template.dobj.widget.kcontrol_enum = 1;
1450                 template.num_kcontrols = 1;
1451                 template.kcontrol_news =
1452                         soc_tplg_dapm_widget_denum_create(tplg);
1453                 if (!template.kcontrol_news) {
1454                         ret = -ENOMEM;
1455                         goto hdr_err;
1456                 }
1457                 break;
1458         case SND_SOC_TPLG_CTL_BYTES:
1459                 template.num_kcontrols = w->num_kcontrols;
1460                 template.kcontrol_news =
1461                         soc_tplg_dapm_widget_dbytes_create(tplg,
1462                                 template.num_kcontrols);
1463                 if (!template.kcontrol_news) {
1464                         ret = -ENOMEM;
1465                         goto hdr_err;
1466                 }
1467                 break;
1468         default:
1469                 dev_err(tplg->dev, "ASoC: invalid widget control type %d:%d:%d\n",
1470                         control_hdr->ops.get, control_hdr->ops.put,
1471                         control_hdr->ops.info);
1472                 ret = -EINVAL;
1473                 goto hdr_err;
1474         }
1475
1476 widget:
1477         ret = soc_tplg_widget_load(tplg, &template, w);
1478         if (ret < 0)
1479                 goto hdr_err;
1480
1481         /* card dapm mutex is held by the core if we are loading topology
1482          * data during sound card init. */
1483         if (card->instantiated)
1484                 widget = snd_soc_dapm_new_control(dapm, &template);
1485         else
1486                 widget = snd_soc_dapm_new_control_unlocked(dapm, &template);
1487         if (IS_ERR(widget)) {
1488                 ret = PTR_ERR(widget);
1489                 /* Do not nag about probe deferrals */
1490                 if (ret != -EPROBE_DEFER)
1491                         dev_err(tplg->dev,
1492                                 "ASoC: failed to create widget %s controls (%d)\n",
1493                                 w->name, ret);
1494                 goto hdr_err;
1495         }
1496         if (widget == NULL) {
1497                 dev_err(tplg->dev, "ASoC: failed to create widget %s controls\n",
1498                         w->name);
1499                 ret = -ENOMEM;
1500                 goto hdr_err;
1501         }
1502
1503         widget->dobj.type = SND_SOC_DOBJ_WIDGET;
1504         widget->dobj.ops = tplg->ops;
1505         widget->dobj.index = tplg->index;
1506         list_add(&widget->dobj.list, &tplg->comp->dobj_list);
1507         return 0;
1508
1509 hdr_err:
1510         kfree(template.sname);
1511 err:
1512         kfree(template.name);
1513         return ret;
1514 }
1515
1516 static int soc_tplg_dapm_widget_elems_load(struct soc_tplg *tplg,
1517         struct snd_soc_tplg_hdr *hdr)
1518 {
1519         struct snd_soc_tplg_dapm_widget *widget;
1520         int ret, count = hdr->count, i;
1521
1522         if (tplg->pass != SOC_TPLG_PASS_WIDGET)
1523                 return 0;
1524
1525         dev_dbg(tplg->dev, "ASoC: adding %d DAPM widgets\n", count);
1526
1527         for (i = 0; i < count; i++) {
1528                 widget = (struct snd_soc_tplg_dapm_widget *) tplg->pos;
1529                 ret = soc_tplg_dapm_widget_create(tplg, widget);
1530                 if (ret < 0)
1531                         dev_err(tplg->dev, "ASoC: failed to load widget %s\n",
1532                                 widget->name);
1533         }
1534
1535         return 0;
1536 }
1537
1538 static int soc_tplg_dapm_complete(struct soc_tplg *tplg)
1539 {
1540         struct snd_soc_card *card = tplg->comp->card;
1541         int ret;
1542
1543         /* Card might not have been registered at this point.
1544          * If so, just return success.
1545         */
1546         if (!card || !card->instantiated) {
1547                 dev_warn(tplg->dev, "ASoC: Parent card not yet available,"
1548                                 "Do not add new widgets now\n");
1549                 return 0;
1550         }
1551
1552         ret = snd_soc_dapm_new_widgets(card);
1553         if (ret < 0)
1554                 dev_err(tplg->dev, "ASoC: failed to create new widgets %d\n",
1555                         ret);
1556
1557         return 0;
1558 }
1559
1560 static int soc_tplg_pcm_dai_elems_load(struct soc_tplg *tplg,
1561         struct snd_soc_tplg_hdr *hdr)
1562 {
1563         struct snd_soc_tplg_pcm_dai *pcm_dai;
1564         struct snd_soc_dobj *dobj;
1565         int count = hdr->count;
1566         int ret;
1567
1568         if (tplg->pass != SOC_TPLG_PASS_PCM_DAI)
1569                 return 0;
1570
1571         pcm_dai = (struct snd_soc_tplg_pcm_dai *)tplg->pos;
1572
1573         if (soc_tplg_check_elem_count(tplg,
1574                 sizeof(struct snd_soc_tplg_pcm), count,
1575                 hdr->payload_size, "PCM DAI")) {
1576                 dev_err(tplg->dev, "ASoC: invalid count %d for PCM DAI elems\n",
1577                         count);
1578                 return -EINVAL;
1579         }
1580
1581         dev_dbg(tplg->dev, "ASoC: adding %d PCM DAIs\n", count);
1582         tplg->pos += sizeof(struct snd_soc_tplg_pcm) * count;
1583
1584         dobj = kzalloc(sizeof(struct snd_soc_dobj), GFP_KERNEL);
1585         if (dobj == NULL)
1586                 return -ENOMEM;
1587
1588         /* Call the platform driver call back to register the dais */
1589         ret = soc_tplg_pcm_dai_load(tplg, pcm_dai, count);
1590         if (ret < 0) {
1591                 dev_err(tplg->comp->dev, "ASoC: PCM DAI loading failed\n");
1592                 goto err;
1593         }
1594
1595         dobj->type = get_dobj_type(hdr, NULL);
1596         dobj->pcm_dai.count = count;
1597         dobj->pcm_dai.pd = pcm_dai;
1598         dobj->ops = tplg->ops;
1599         dobj->index = tplg->index;
1600         list_add(&dobj->list, &tplg->comp->dobj_list);
1601         return 0;
1602
1603 err:
1604         kfree(dobj);
1605         return ret;
1606 }
1607
1608 static int soc_tplg_manifest_load(struct soc_tplg *tplg,
1609         struct snd_soc_tplg_hdr *hdr)
1610 {
1611         struct snd_soc_tplg_manifest *manifest;
1612
1613         if (tplg->pass != SOC_TPLG_PASS_MANIFEST)
1614                 return 0;
1615
1616         manifest = (struct snd_soc_tplg_manifest *)tplg->pos;
1617         tplg->pos += sizeof(struct snd_soc_tplg_manifest);
1618
1619         if (tplg->comp && tplg->ops && tplg->ops->manifest)
1620                 return tplg->ops->manifest(tplg->comp, manifest);
1621
1622         dev_err(tplg->dev, "ASoC: Firmware manifest not supported\n");
1623         return 0;
1624 }
1625
1626 /* validate header magic, size and type */
1627 static int soc_valid_header(struct soc_tplg *tplg,
1628         struct snd_soc_tplg_hdr *hdr)
1629 {
1630         if (soc_tplg_get_hdr_offset(tplg) >= tplg->fw->size)
1631                 return 0;
1632
1633         /* big endian firmware objects not supported atm */
1634         if (hdr->magic == cpu_to_be32(SND_SOC_TPLG_MAGIC)) {
1635                 dev_err(tplg->dev,
1636                         "ASoC: pass %d big endian not supported header got %x at offset 0x%lx size 0x%zx.\n",
1637                         tplg->pass, hdr->magic,
1638                         soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1639                 return -EINVAL;
1640         }
1641
1642         if (hdr->magic != SND_SOC_TPLG_MAGIC) {
1643                 dev_err(tplg->dev,
1644                         "ASoC: pass %d does not have a valid header got %x at offset 0x%lx size 0x%zx.\n",
1645                         tplg->pass, hdr->magic,
1646                         soc_tplg_get_hdr_offset(tplg), tplg->fw->size);
1647                 return -EINVAL;
1648         }
1649
1650         if (hdr->abi != SND_SOC_TPLG_ABI_VERSION) {
1651                 dev_err(tplg->dev,
1652                         "ASoC: pass %d invalid ABI version got 0x%x need 0x%x at offset 0x%lx size 0x%zx.\n",
1653                         tplg->pass, hdr->abi,
1654                         SND_SOC_TPLG_ABI_VERSION, soc_tplg_get_hdr_offset(tplg),
1655                         tplg->fw->size);
1656                 return -EINVAL;
1657         }
1658
1659         if (hdr->payload_size == 0) {
1660                 dev_err(tplg->dev, "ASoC: header has 0 size at offset 0x%lx.\n",
1661                         soc_tplg_get_hdr_offset(tplg));
1662                 return -EINVAL;
1663         }
1664
1665         if (tplg->pass == hdr->type)
1666                 dev_dbg(tplg->dev,
1667                         "ASoC: Got 0x%x bytes of type %d version %d vendor %d at pass %d\n",
1668                         hdr->payload_size, hdr->type, hdr->version,
1669                         hdr->vendor_type, tplg->pass);
1670
1671         return 1;
1672 }
1673
1674 /* check header type and call appropriate handler */
1675 static int soc_tplg_load_header(struct soc_tplg *tplg,
1676         struct snd_soc_tplg_hdr *hdr)
1677 {
1678         tplg->pos = tplg->hdr_pos + sizeof(struct snd_soc_tplg_hdr);
1679
1680         /* check for matching ID */
1681         if (hdr->index != tplg->req_index &&
1682                 hdr->index != SND_SOC_TPLG_INDEX_ALL)
1683                 return 0;
1684
1685         tplg->index = hdr->index;
1686
1687         switch (hdr->type) {
1688         case SND_SOC_TPLG_TYPE_MIXER:
1689         case SND_SOC_TPLG_TYPE_ENUM:
1690         case SND_SOC_TPLG_TYPE_BYTES:
1691                 return soc_tplg_kcontrol_elems_load(tplg, hdr);
1692         case SND_SOC_TPLG_TYPE_DAPM_GRAPH:
1693                 return soc_tplg_dapm_graph_elems_load(tplg, hdr);
1694         case SND_SOC_TPLG_TYPE_DAPM_WIDGET:
1695                 return soc_tplg_dapm_widget_elems_load(tplg, hdr);
1696         case SND_SOC_TPLG_TYPE_PCM:
1697         case SND_SOC_TPLG_TYPE_DAI_LINK:
1698         case SND_SOC_TPLG_TYPE_CODEC_LINK:
1699                 return soc_tplg_pcm_dai_elems_load(tplg, hdr);
1700         case SND_SOC_TPLG_TYPE_MANIFEST:
1701                 return soc_tplg_manifest_load(tplg, hdr);
1702         default:
1703                 /* bespoke vendor data object */
1704                 return soc_tplg_vendor_load(tplg, hdr);
1705         }
1706
1707         return 0;
1708 }
1709
1710 /* process the topology file headers */
1711 static int soc_tplg_process_headers(struct soc_tplg *tplg)
1712 {
1713         struct snd_soc_tplg_hdr *hdr;
1714         int ret;
1715
1716         tplg->pass = SOC_TPLG_PASS_START;
1717
1718         /* process the header types from start to end */
1719         while (tplg->pass <= SOC_TPLG_PASS_END) {
1720
1721                 tplg->hdr_pos = tplg->fw->data;
1722                 hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1723
1724                 while (!soc_tplg_is_eof(tplg)) {
1725
1726                         /* make sure header is valid before loading */
1727                         ret = soc_valid_header(tplg, hdr);
1728                         if (ret < 0)
1729                                 return ret;
1730                         else if (ret == 0)
1731                                 break;
1732
1733                         /* load the header object */
1734                         ret = soc_tplg_load_header(tplg, hdr);
1735                         if (ret < 0)
1736                                 return ret;
1737
1738                         /* goto next header */
1739                         tplg->hdr_pos += hdr->payload_size +
1740                                 sizeof(struct snd_soc_tplg_hdr);
1741                         hdr = (struct snd_soc_tplg_hdr *)tplg->hdr_pos;
1742                 }
1743
1744                 /* next data type pass */
1745                 tplg->pass++;
1746         }
1747
1748         /* signal DAPM we are complete */
1749         ret = soc_tplg_dapm_complete(tplg);
1750         if (ret < 0)
1751                 dev_err(tplg->dev,
1752                         "ASoC: failed to initialise DAPM from Firmware\n");
1753
1754         return ret;
1755 }
1756
1757 static int soc_tplg_load(struct soc_tplg *tplg)
1758 {
1759         int ret;
1760
1761         ret = soc_tplg_process_headers(tplg);
1762         if (ret == 0)
1763                 soc_tplg_complete(tplg);
1764
1765         return ret;
1766 }
1767
1768 /* load audio component topology from "firmware" file */
1769 int snd_soc_tplg_component_load(struct snd_soc_component *comp,
1770         struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id)
1771 {
1772         struct soc_tplg tplg;
1773         int ret;
1774
1775         /* setup parsing context */
1776         memset(&tplg, 0, sizeof(tplg));
1777         tplg.fw = fw;
1778         tplg.dev = comp->dev;
1779         tplg.comp = comp;
1780         tplg.ops = ops;
1781         tplg.req_index = id;
1782         tplg.io_ops = ops->io_ops;
1783         tplg.io_ops_count = ops->io_ops_count;
1784         tplg.bytes_ext_ops = ops->bytes_ext_ops;
1785         tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count;
1786
1787         ret = soc_tplg_load(&tplg);
1788         /* free the created components if fail to load topology */
1789         if (ret)
1790                 snd_soc_tplg_component_remove(comp, SND_SOC_TPLG_INDEX_ALL);
1791
1792         return ret;
1793 }
1794 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
1795
1796 /* remove this dynamic widget */
1797 void snd_soc_tplg_widget_remove(struct snd_soc_dapm_widget *w)
1798 {
1799         /* make sure we are a widget */
1800         if (w->dobj.type != SND_SOC_DOBJ_WIDGET)
1801                 return;
1802
1803         remove_widget(w->dapm->component, &w->dobj, SOC_TPLG_PASS_WIDGET);
1804 }
1805 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove);
1806
1807 /* remove all dynamic widgets from this DAPM context */
1808 void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
1809         u32 index)
1810 {
1811         struct snd_soc_dapm_widget *w, *next_w;
1812
1813         list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
1814
1815                 /* make sure we are a widget with correct context */
1816                 if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm)
1817                         continue;
1818
1819                 /* match ID */
1820                 if (w->dobj.index != index &&
1821                         w->dobj.index != SND_SOC_TPLG_INDEX_ALL)
1822                         continue;
1823                 /* check and free and dynamic widget kcontrols */
1824                 snd_soc_tplg_widget_remove(w);
1825                 snd_soc_dapm_free_widget(w);
1826         }
1827         snd_soc_dapm_reset_cache(dapm);
1828 }
1829 EXPORT_SYMBOL_GPL(snd_soc_tplg_widget_remove_all);
1830
1831 /* remove dynamic controls from the component driver */
1832 int snd_soc_tplg_component_remove(struct snd_soc_component *comp, u32 index)
1833 {
1834         struct snd_soc_dobj *dobj, *next_dobj;
1835         int pass = SOC_TPLG_PASS_END;
1836
1837         /* process the header types from end to start */
1838         while (pass >= SOC_TPLG_PASS_START) {
1839
1840                 /* remove mixer controls */
1841                 list_for_each_entry_safe(dobj, next_dobj, &comp->dobj_list,
1842                         list) {
1843
1844                         /* match index */
1845                         if (dobj->index != index &&
1846                                 dobj->index != SND_SOC_TPLG_INDEX_ALL)
1847                                 continue;
1848
1849                         switch (dobj->type) {
1850                         case SND_SOC_DOBJ_MIXER:
1851                                 remove_mixer(comp, dobj, pass);
1852                                 break;
1853                         case SND_SOC_DOBJ_ENUM:
1854                                 remove_enum(comp, dobj, pass);
1855                                 break;
1856                         case SND_SOC_DOBJ_BYTES:
1857                                 remove_bytes(comp, dobj, pass);
1858                                 break;
1859                         case SND_SOC_DOBJ_WIDGET:
1860                                 remove_widget(comp, dobj, pass);
1861                                 break;
1862                         case SND_SOC_DOBJ_PCM:
1863                         case SND_SOC_DOBJ_DAI_LINK:
1864                         case SND_SOC_DOBJ_CODEC_LINK:
1865                                 remove_pcm_dai(comp, dobj, pass);
1866                                 break;
1867                         default:
1868                                 dev_err(comp->dev, "ASoC: invalid component type %d for removal\n",
1869                                         dobj->type);
1870                                 break;
1871                         }
1872                 }
1873                 pass--;
1874         }
1875
1876         /* let caller know if FW can be freed when no objects are left */
1877         return !list_empty(&comp->dobj_list);
1878 }
1879 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_remove);