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 #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);