sound/soc/soc-dapm.c

   1 /*
   2  * soc-dapm.c  --  ALSA SoC Dynamic Audio Power Management
   3  *
   4  * Copyright 2005 Wolfson Microelectronics PLC.
   5  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
   6  *
   7  *  This program is free software; you can redistribute  it and/or modify it
   8  *  under  the terms of  the GNU General  Public License as published by the
   9  *  Free Software Foundation;  either version 2 of the  License, or (at your
  10  *  option) any later version.
  11  *
  12  *  Features:
  13  *    o Changes power status of internal codec blocks depending on the
  14  *      dynamic configuration of codec internal audio paths and active
  15  *      DACs/ADCs.
  16  *    o Platform power domain - can support external components i.e. amps and
  17  *      mic/headphone insertion events.
  18  *    o Automatic Mic Bias support
  19  *    o Jack insertion power event initiation - e.g. hp insertion will enable
  20  *      sinks, dacs, etc
  21  *    o Delayed power down of audio subsystem to reduce pops between a quick
  22  *      device reopen.
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/init.h>
  29 #include <linux/async.h>
  30 #include <linux/delay.h>
  31 #include <linux/pm.h>
  32 #include <linux/bitops.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/jiffies.h>
  35 #include <linux/debugfs.h>
  36 #include <linux/pm_runtime.h>
  37 #include <linux/regulator/consumer.h>
  38 #include <linux/clk.h>
  39 #include <linux/slab.h>
  40 #include <sound/core.h>
  41 #include <sound/pcm.h>
  42 #include <sound/pcm_params.h>
  43 #include <sound/soc.h>
  44 #include <sound/initval.h>
  45
  46 #include <trace/events/asoc.h>
  47
  48 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
  49
  50 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
  51         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
  52         const char *control,
  53         int (*connected)(struct snd_soc_dapm_widget *source,
  54                          struct snd_soc_dapm_widget *sink));
  55 static struct snd_soc_dapm_widget *
  56 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
  57                          const struct snd_soc_dapm_widget *widget);
  58
  59 /* dapm power sequences - make this per codec in the future */
  60 static int dapm_up_seq[] = {
  61         [snd_soc_dapm_pre] = 0,
  62         [snd_soc_dapm_regulator_supply] = 1,
  63         [snd_soc_dapm_clock_supply] = 1,
  64         [snd_soc_dapm_supply] = 2,
  65         [snd_soc_dapm_micbias] = 3,
  66         [snd_soc_dapm_dai_link] = 2,
  67         [snd_soc_dapm_dai_in] = 4,
  68         [snd_soc_dapm_dai_out] = 4,
  69         [snd_soc_dapm_aif_in] = 4,
  70         [snd_soc_dapm_aif_out] = 4,
  71         [snd_soc_dapm_mic] = 5,
  72         [snd_soc_dapm_mux] = 6,
  73         [snd_soc_dapm_dac] = 7,
  74         [snd_soc_dapm_switch] = 8,
  75         [snd_soc_dapm_mixer] = 8,
  76         [snd_soc_dapm_mixer_named_ctl] = 8,
  77         [snd_soc_dapm_pga] = 9,
  78         [snd_soc_dapm_adc] = 10,
  79         [snd_soc_dapm_out_drv] = 11,
  80         [snd_soc_dapm_hp] = 11,
  81         [snd_soc_dapm_spk] = 11,
  82         [snd_soc_dapm_line] = 11,
  83         [snd_soc_dapm_kcontrol] = 12,
  84         [snd_soc_dapm_post] = 13,
  85 };
  86
  87 static int dapm_down_seq[] = {
  88         [snd_soc_dapm_pre] = 0,
  89         [snd_soc_dapm_kcontrol] = 1,
  90         [snd_soc_dapm_adc] = 2,
  91         [snd_soc_dapm_hp] = 3,
  92         [snd_soc_dapm_spk] = 3,
  93         [snd_soc_dapm_line] = 3,
  94         [snd_soc_dapm_out_drv] = 3,
  95         [snd_soc_dapm_pga] = 4,
  96         [snd_soc_dapm_switch] = 5,
  97         [snd_soc_dapm_mixer_named_ctl] = 5,
  98         [snd_soc_dapm_mixer] = 5,
  99         [snd_soc_dapm_dac] = 6,
 100         [snd_soc_dapm_mic] = 7,
 101         [snd_soc_dapm_micbias] = 8,
 102         [snd_soc_dapm_mux] = 9,
 103         [snd_soc_dapm_aif_in] = 10,
 104         [snd_soc_dapm_aif_out] = 10,
 105         [snd_soc_dapm_dai_in] = 10,
 106         [snd_soc_dapm_dai_out] = 10,
 107         [snd_soc_dapm_dai_link] = 11,
 108         [snd_soc_dapm_supply] = 12,
 109         [snd_soc_dapm_clock_supply] = 13,
 110         [snd_soc_dapm_regulator_supply] = 13,
 111         [snd_soc_dapm_post] = 14,
 112 };
 113
 114 static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
 115 {
 116         if (dapm->card && dapm->card->instantiated)
 117                 lockdep_assert_held(&dapm->card->dapm_mutex);
 118 }
 119
 120 static void pop_wait(u32 pop_time)
 121 {
 122         if (pop_time)
 123                 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
 124 }
 125
 126 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
 127 {
 128         va_list args;
 129         char *buf;
 130
 131         if (!pop_time)
 132                 return;
 133
 134         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 135         if (buf == NULL)
 136                 return;
 137
 138         va_start(args, fmt);
 139         vsnprintf(buf, PAGE_SIZE, fmt, args);
 140         dev_info(dev, "%s", buf);
 141         va_end(args);
 142
 143         kfree(buf);
 144 }
 145
 146 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
 147 {
 148         return !list_empty(&w->dirty);
 149 }
 150
 151 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
 152 {
 153         dapm_assert_locked(w->dapm);
 154
 155         if (!dapm_dirty_widget(w)) {
 156                 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
 157                          w->name, reason);
 158                 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
 159         }
 160 }
 161
 162 void dapm_mark_io_dirty(struct snd_soc_dapm_context *dapm)
 163 {
 164         struct snd_soc_card *card = dapm->card;
 165         struct snd_soc_dapm_widget *w;
 166
 167         mutex_lock(&card->dapm_mutex);
 168
 169         list_for_each_entry(w, &card->widgets, list) {
 170                 switch (w->id) {
 171                 case snd_soc_dapm_input:
 172                 case snd_soc_dapm_output:
 173                         dapm_mark_dirty(w, "Rechecking inputs and outputs");
 174                         break;
 175                 default:
 176                         break;
 177                 }
 178         }
 179
 180         mutex_unlock(&card->dapm_mutex);
 181 }
 182 EXPORT_SYMBOL_GPL(dapm_mark_io_dirty);
 183
 184 /* create a new dapm widget */
 185 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
 186         const struct snd_soc_dapm_widget *_widget)
 187 {
 188         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
 189 }
 190
 191 struct dapm_kcontrol_data {
 192         unsigned int value;
 193         struct snd_soc_dapm_widget *widget;
 194         struct list_head paths;
 195         struct snd_soc_dapm_widget_list *wlist;
 196 };
 197
 198 static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
 199         struct snd_kcontrol *kcontrol)
 200 {
 201         struct dapm_kcontrol_data *data;
 202         struct soc_mixer_control *mc;
 203
 204         data = kzalloc(sizeof(*data), GFP_KERNEL);
 205         if (!data) {
 206                 dev_err(widget->dapm->dev,
 207                                 "ASoC: can't allocate kcontrol data for %s\n",
 208                                 widget->name);
 209                 return -ENOMEM;
 210         }
 211
 212         INIT_LIST_HEAD(&data->paths);
 213
 214         switch (widget->id) {
 215         case snd_soc_dapm_switch:
 216         case snd_soc_dapm_mixer:
 217         case snd_soc_dapm_mixer_named_ctl:
 218                 mc = (struct soc_mixer_control *)kcontrol->private_value;
 219
 220                 if (mc->autodisable) {
 221                         struct snd_soc_dapm_widget template;
 222
 223                         memset(&template, 0, sizeof(template));
 224                         template.reg = mc->reg;
 225                         template.mask = (1 << fls(mc->max)) - 1;
 226                         template.shift = mc->shift;
 227                         if (mc->invert)
 228                                 template.off_val = mc->max;
 229                         else
 230                                 template.off_val = 0;
 231                         template.on_val = template.off_val;
 232                         template.id = snd_soc_dapm_kcontrol;
 233                         template.name = kcontrol->id.name;
 234
 235                         data->value = template.on_val;
 236
 237                         data->widget = snd_soc_dapm_new_control(widget->dapm,
 238                                 &template);
 239                         if (!data->widget) {
 240                                 kfree(data);
 241                                 return -ENOMEM;
 242                         }
 243                 }
 244                 break;
 245         default:
 246                 break;
 247         }
 248
 249         kcontrol->private_data = data;
 250
 251         return 0;
 252 }
 253
 254 static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
 255 {
 256         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
 257         kfree(data->wlist);
 258         kfree(data);
 259 }
 260
 261 static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
 262         const struct snd_kcontrol *kcontrol)
 263 {
 264         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 265
 266         return data->wlist;
 267 }
 268
 269 static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
 270         struct snd_soc_dapm_widget *widget)
 271 {
 272         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 273         struct snd_soc_dapm_widget_list *new_wlist;
 274         unsigned int n;
 275
 276         if (data->wlist)
 277                 n = data->wlist->num_widgets + 1;
 278         else
 279                 n = 1;
 280
 281         new_wlist = krealloc(data->wlist,
 282                         sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL);
 283         if (!new_wlist)
 284                 return -ENOMEM;
 285
 286         new_wlist->widgets[n - 1] = widget;
 287         new_wlist->num_widgets = n;
 288
 289         data->wlist = new_wlist;
 290
 291         return 0;
 292 }
 293
 294 static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
 295         struct snd_soc_dapm_path *path)
 296 {
 297         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 298
 299         list_add_tail(&path->list_kcontrol, &data->paths);
 300
 301         if (data->widget) {
 302                 snd_soc_dapm_add_path(data->widget->dapm, data->widget,
 303                     path->source, NULL, NULL);
 304         }
 305 }
 306
 307 static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
 308 {
 309         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 310
 311         if (!data->widget)
 312                 return true;
 313
 314         return data->widget->power;
 315 }
 316
 317 static struct list_head *dapm_kcontrol_get_path_list(
 318         const struct snd_kcontrol *kcontrol)
 319 {
 320         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 321
 322         return &data->paths;
 323 }
 324
 325 #define dapm_kcontrol_for_each_path(path, kcontrol) \
 326         list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
 327                 list_kcontrol)
 328
 329 static unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
 330 {
 331         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 332
 333         return data->value;
 334 }
 335
 336 static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
 337         unsigned int value)
 338 {
 339         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
 340
 341         if (data->value == value)
 342                 return false;
 343
 344         if (data->widget)
 345                 data->widget->on_val = value;
 346
 347         data->value = value;
 348
 349         return true;
 350 }
 351
 352 /**
 353  * snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
 354  *  kcontrol
 355  * @kcontrol: The kcontrol
 356  *
 357  * Note: This function must only be used on kcontrols that are known to have
 358  * been registered for a CODEC. Otherwise the behaviour is undefined.
 359  */
 360 struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
 361         struct snd_kcontrol *kcontrol)
 362 {
 363         return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
 364 }
 365 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
 366
 367 /**
 368  * snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol
 369  * @kcontrol: The kcontrol
 370  */
 371 struct snd_soc_codec *snd_soc_dapm_kcontrol_codec(struct snd_kcontrol *kcontrol)
 372 {
 373         return snd_soc_dapm_to_codec(snd_soc_dapm_kcontrol_dapm(kcontrol));
 374 }
 375 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_codec);
 376
 377 static void dapm_reset(struct snd_soc_card *card)
 378 {
 379         struct snd_soc_dapm_widget *w;
 380
 381         lockdep_assert_held(&card->dapm_mutex);
 382
 383         memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
 384
 385         list_for_each_entry(w, &card->widgets, list) {
 386                 w->new_power = w->power;
 387                 w->power_checked = false;
 388                 w->inputs = -1;
 389                 w->outputs = -1;
 390         }
 391 }
 392
 393 static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
 394 {
 395         if (!dapm->component)
 396                 return NULL;
 397         return dapm->component->name_prefix;
 398 }
 399
 400 static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
 401         unsigned int *value)
 402 {
 403         if (!dapm->component)
 404                 return -EIO;
 405         return snd_soc_component_read(dapm->component, reg, value);
 406 }
 407
 408 static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
 409         int reg, unsigned int mask, unsigned int value)
 410 {
 411         if (!dapm->component)
 412                 return -EIO;
 413         return snd_soc_component_update_bits_async(dapm->component, reg,
 414                 mask, value);
 415 }
 416
 417 static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
 418         int reg, unsigned int mask, unsigned int value)
 419 {
 420         if (!dapm->component)
 421                 return -EIO;
 422         return snd_soc_component_test_bits(dapm->component, reg, mask, value);
 423 }
 424
 425 static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
 426 {
 427         if (dapm->component)
 428                 snd_soc_component_async_complete(dapm->component);
 429 }
 430
 431 /**
 432  * snd_soc_dapm_set_bias_level - set the bias level for the system
 433  * @dapm: DAPM context
 434  * @level: level to configure
 435  *
 436  * Configure the bias (power) levels for the SoC audio device.
 437  *
 438  * Returns 0 for success else error.
 439  */
 440 static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
 441                                        enum snd_soc_bias_level level)
 442 {
 443         struct snd_soc_card *card = dapm->card;
 444         int ret = 0;
 445
 446         trace_snd_soc_bias_level_start(card, level);
 447
 448         if (card && card->set_bias_level)
 449                 ret = card->set_bias_level(card, dapm, level);
 450         if (ret != 0)
 451                 goto out;
 452
 453         if (dapm->set_bias_level)
 454                 ret = dapm->set_bias_level(dapm, level);
 455         else if (!card || dapm != &card->dapm)
 456                 dapm->bias_level = level;
 457
 458         if (ret != 0)
 459                 goto out;
 460
 461         if (card && card->set_bias_level_post)
 462                 ret = card->set_bias_level_post(card, dapm, level);
 463 out:
 464         trace_snd_soc_bias_level_done(card, level);
 465
 466         return ret;
 467 }
 468
 469 /* connect mux widget to its interconnecting audio paths */
 470 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
 471         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 472         struct snd_soc_dapm_path *path, const char *control_name,
 473         const struct snd_kcontrol_new *kcontrol)
 474 {
 475         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 476         unsigned int val, item;
 477         int i;
 478
 479         if (e->reg != SND_SOC_NOPM) {
 480                 soc_dapm_read(dapm, e->reg, &val);
 481                 val = (val >> e->shift_l) & e->mask;
 482                 item = snd_soc_enum_val_to_item(e, val);
 483         } else {
 484                 /* since a virtual mux has no backing registers to
 485                  * decide which path to connect, it will try to match
 486                  * with the first enumeration.  This is to ensure
 487                  * that the default mux choice (the first) will be
 488                  * correctly powered up during initialization.
 489                  */
 490                 item = 0;
 491         }
 492
 493         for (i = 0; i < e->items; i++) {
 494                 if (!(strcmp(control_name, e->texts[i]))) {
 495                         list_add(&path->list, &dapm->card->paths);
 496                         list_add(&path->list_sink, &dest->sources);
 497                         list_add(&path->list_source, &src->sinks);
 498                         path->name = (char*)e->texts[i];
 499                         if (i == item)
 500                                 path->connect = 1;
 501                         else
 502                                 path->connect = 0;
 503                         return 0;
 504                 }
 505         }
 506
 507         return -ENODEV;
 508 }
 509
 510 /* set up initial codec paths */
 511 static void dapm_set_mixer_path_status(struct snd_soc_dapm_widget *w,
 512         struct snd_soc_dapm_path *p, int i)
 513 {
 514         struct soc_mixer_control *mc = (struct soc_mixer_control *)
 515                 w->kcontrol_news[i].private_value;
 516         unsigned int reg = mc->reg;
 517         unsigned int shift = mc->shift;
 518         unsigned int max = mc->max;
 519         unsigned int mask = (1 << fls(max)) - 1;
 520         unsigned int invert = mc->invert;
 521         unsigned int val;
 522
 523         if (reg != SND_SOC_NOPM) {
 524                 soc_dapm_read(w->dapm, reg, &val);
 525                 val = (val >> shift) & mask;
 526                 if (invert)
 527                         val = max - val;
 528                 p->connect = !!val;
 529         } else {
 530                 p->connect = 0;
 531         }
 532 }
 533
 534 /* connect mixer widget to its interconnecting audio paths */
 535 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
 536         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 537         struct snd_soc_dapm_path *path, const char *control_name)
 538 {
 539         int i;
 540
 541         /* search for mixer kcontrol */
 542         for (i = 0; i < dest->num_kcontrols; i++) {
 543                 if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
 544                         list_add(&path->list, &dapm->card->paths);
 545                         list_add(&path->list_sink, &dest->sources);
 546                         list_add(&path->list_source, &src->sinks);
 547                         path->name = dest->kcontrol_news[i].name;
 548                         dapm_set_mixer_path_status(dest, path, i);
 549                         return 0;
 550                 }
 551         }
 552         return -ENODEV;
 553 }
 554
 555 static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
 556         struct snd_soc_dapm_widget *kcontrolw,
 557         const struct snd_kcontrol_new *kcontrol_new,
 558         struct snd_kcontrol **kcontrol)
 559 {
 560         struct snd_soc_dapm_widget *w;
 561         int i;
 562
 563         *kcontrol = NULL;
 564
 565         list_for_each_entry(w, &dapm->card->widgets, list) {
 566                 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
 567                         continue;
 568                 for (i = 0; i < w->num_kcontrols; i++) {
 569                         if (&w->kcontrol_news[i] == kcontrol_new) {
 570                                 if (w->kcontrols)
 571                                         *kcontrol = w->kcontrols[i];
 572                                 return 1;
 573                         }
 574                 }
 575         }
 576
 577         return 0;
 578 }
 579
 580 /*
 581  * Determine if a kcontrol is shared. If it is, look it up. If it isn't,
 582  * create it. Either way, add the widget into the control's widget list
 583  */
 584 static int dapm_create_or_share_mixmux_kcontrol(struct snd_soc_dapm_widget *w,
 585         int kci)
 586 {
 587         struct snd_soc_dapm_context *dapm = w->dapm;
 588         struct snd_card *card = dapm->card->snd_card;
 589         const char *prefix;
 590         size_t prefix_len;
 591         int shared;
 592         struct snd_kcontrol *kcontrol;
 593         bool wname_in_long_name, kcname_in_long_name;
 594         char *long_name;
 595         const char *name;
 596         int ret;
 597
 598         prefix = soc_dapm_prefix(dapm);
 599         if (prefix)
 600                 prefix_len = strlen(prefix) + 1;
 601         else
 602                 prefix_len = 0;
 603
 604         shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
 605                                          &kcontrol);
 606
 607         if (!kcontrol) {
 608                 if (shared) {
 609                         wname_in_long_name = false;
 610                         kcname_in_long_name = true;
 611                 } else {
 612                         switch (w->id) {
 613                         case snd_soc_dapm_switch:
 614                         case snd_soc_dapm_mixer:
 615                                 wname_in_long_name = true;
 616                                 kcname_in_long_name = true;
 617                                 break;
 618                         case snd_soc_dapm_mixer_named_ctl:
 619                                 wname_in_long_name = false;
 620                                 kcname_in_long_name = true;
 621                                 break;
 622                         case snd_soc_dapm_mux:
 623                                 wname_in_long_name = true;
 624                                 kcname_in_long_name = false;
 625                                 break;
 626                         default:
 627                                 return -EINVAL;
 628                         }
 629                 }
 630
 631                 if (wname_in_long_name && kcname_in_long_name) {
 632                         /*
 633                          * The control will get a prefix from the control
 634                          * creation process but we're also using the same
 635                          * prefix for widgets so cut the prefix off the
 636                          * front of the widget name.
 637                          */
 638                         long_name = kasprintf(GFP_KERNEL, "%s %s",
 639                                  w->name + prefix_len,
 640                                  w->kcontrol_news[kci].name);
 641                         if (long_name == NULL)
 642                                 return -ENOMEM;
 643
 644                         name = long_name;
 645                 } else if (wname_in_long_name) {
 646                         long_name = NULL;
 647                         name = w->name + prefix_len;
 648                 } else {
 649                         long_name = NULL;
 650                         name = w->kcontrol_news[kci].name;
 651                 }
 652
 653                 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
 654                                         prefix);
 655                 kfree(long_name);
 656                 if (!kcontrol)
 657                         return -ENOMEM;
 658                 kcontrol->private_free = dapm_kcontrol_free;
 659
 660                 ret = dapm_kcontrol_data_alloc(w, kcontrol);
 661                 if (ret) {
 662                         snd_ctl_free_one(kcontrol);
 663                         return ret;
 664                 }
 665
 666                 ret = snd_ctl_add(card, kcontrol);
 667                 if (ret < 0) {
 668                         dev_err(dapm->dev,
 669                                 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
 670                                 w->name, name, ret);
 671                         return ret;
 672                 }
 673         }
 674
 675         ret = dapm_kcontrol_add_widget(kcontrol, w);
 676         if (ret)
 677                 return ret;
 678
 679         w->kcontrols[kci] = kcontrol;
 680
 681         return 0;
 682 }
 683
 684 /* create new dapm mixer control */
 685 static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
 686 {
 687         int i, ret;
 688         struct snd_soc_dapm_path *path;
 689
 690         /* add kcontrol */
 691         for (i = 0; i < w->num_kcontrols; i++) {
 692                 /* match name */
 693                 list_for_each_entry(path, &w->sources, list_sink) {
 694                         /* mixer/mux paths name must match control name */
 695                         if (path->name != (char *)w->kcontrol_news[i].name)
 696                                 continue;
 697
 698                         if (w->kcontrols[i]) {
 699                                 dapm_kcontrol_add_path(w->kcontrols[i], path);
 700                                 continue;
 701                         }
 702
 703                         ret = dapm_create_or_share_mixmux_kcontrol(w, i);
 704                         if (ret < 0)
 705                                 return ret;
 706
 707                         dapm_kcontrol_add_path(w->kcontrols[i], path);
 708                 }
 709         }
 710
 711         return 0;
 712 }
 713
 714 /* create new dapm mux control */
 715 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
 716 {
 717         struct snd_soc_dapm_context *dapm = w->dapm;
 718         struct snd_soc_dapm_path *path;
 719         int ret;
 720
 721         if (w->num_kcontrols != 1) {
 722                 dev_err(dapm->dev,
 723                         "ASoC: mux %s has incorrect number of controls\n",
 724                         w->name);
 725                 return -EINVAL;
 726         }
 727
 728         if (list_empty(&w->sources)) {
 729                 dev_err(dapm->dev, "ASoC: mux %s has no paths\n", w->name);
 730                 return -EINVAL;
 731         }
 732
 733         ret = dapm_create_or_share_mixmux_kcontrol(w, 0);
 734         if (ret < 0)
 735                 return ret;
 736
 737         list_for_each_entry(path, &w->sources, list_sink)
 738                 dapm_kcontrol_add_path(w->kcontrols[0], path);
 739
 740         return 0;
 741 }
 742
 743 /* create new dapm volume control */
 744 static int dapm_new_pga(struct snd_soc_dapm_widget *w)
 745 {
 746         if (w->num_kcontrols)
 747                 dev_err(w->dapm->dev,
 748                         "ASoC: PGA controls not supported: '%s'\n", w->name);
 749
 750         return 0;
 751 }
 752
 753 /* reset 'walked' bit for each dapm path */
 754 static void dapm_clear_walk_output(struct snd_soc_dapm_context *dapm,
 755                                    struct list_head *sink)
 756 {
 757         struct snd_soc_dapm_path *p;
 758
 759         list_for_each_entry(p, sink, list_source) {
 760                 if (p->walked) {
 761                         p->walked = 0;
 762                         dapm_clear_walk_output(dapm, &p->sink->sinks);
 763                 }
 764         }
 765 }
 766
 767 static void dapm_clear_walk_input(struct snd_soc_dapm_context *dapm,
 768                                   struct list_head *source)
 769 {
 770         struct snd_soc_dapm_path *p;
 771
 772         list_for_each_entry(p, source, list_sink) {
 773                 if (p->walked) {
 774                         p->walked = 0;
 775                         dapm_clear_walk_input(dapm, &p->source->sources);
 776                 }
 777         }
 778 }
 779
 780
 781 /* We implement power down on suspend by checking the power state of
 782  * the ALSA card - when we are suspending the ALSA state for the card
 783  * is set to D3.
 784  */
 785 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
 786 {
 787         int level = snd_power_get_state(widget->dapm->card->snd_card);
 788
 789         switch (level) {
 790         case SNDRV_CTL_POWER_D3hot:
 791         case SNDRV_CTL_POWER_D3cold:
 792                 if (widget->ignore_suspend)
 793                         dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
 794                                 widget->name);
 795                 return widget->ignore_suspend;
 796         default:
 797                 return 1;
 798         }
 799 }
 800
 801 /* add widget to list if it's not already in the list */
 802 static int dapm_list_add_widget(struct snd_soc_dapm_widget_list **list,
 803         struct snd_soc_dapm_widget *w)
 804 {
 805         struct snd_soc_dapm_widget_list *wlist;
 806         int wlistsize, wlistentries, i;
 807
 808         if (*list == NULL)
 809                 return -EINVAL;
 810
 811         wlist = *list;
 812
 813         /* is this widget already in the list */
 814         for (i = 0; i < wlist->num_widgets; i++) {
 815                 if (wlist->widgets[i] == w)
 816                         return 0;
 817         }
 818
 819         /* allocate some new space */
 820         wlistentries = wlist->num_widgets + 1;
 821         wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
 822                         wlistentries * sizeof(struct snd_soc_dapm_widget *);
 823         *list = krealloc(wlist, wlistsize, GFP_KERNEL);
 824         if (*list == NULL) {
 825                 dev_err(w->dapm->dev, "ASoC: can't allocate widget list for %s\n",
 826                         w->name);
 827                 return -ENOMEM;
 828         }
 829         wlist = *list;
 830
 831         /* insert the widget */
 832         dev_dbg(w->dapm->dev, "ASoC: added %s in widget list pos %d\n",
 833                         w->name, wlist->num_widgets);
 834
 835         wlist->widgets[wlist->num_widgets] = w;
 836         wlist->num_widgets++;
 837         return 1;
 838 }
 839
 840 /*
 841  * Recursively check for a completed path to an active or physically connected
 842  * output widget. Returns number of complete paths.
 843  */
 844 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
 845         struct snd_soc_dapm_widget_list **list)
 846 {
 847         struct snd_soc_dapm_path *path;
 848         int con = 0;
 849
 850         if (widget->outputs >= 0)
 851                 return widget->outputs;
 852
 853         DAPM_UPDATE_STAT(widget, path_checks);
 854
 855         switch (widget->id) {
 856         case snd_soc_dapm_supply:
 857         case snd_soc_dapm_regulator_supply:
 858         case snd_soc_dapm_clock_supply:
 859         case snd_soc_dapm_kcontrol:
 860                 return 0;
 861         default:
 862                 break;
 863         }
 864
 865         switch (widget->id) {
 866         case snd_soc_dapm_adc:
 867         case snd_soc_dapm_aif_out:
 868         case snd_soc_dapm_dai_out:
 869                 if (widget->active) {
 870                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 871                         return widget->outputs;
 872                 }
 873         default:
 874                 break;
 875         }
 876
 877         if (widget->connected) {
 878                 /* connected pin ? */
 879                 if (widget->id == snd_soc_dapm_output && !widget->ext) {
 880                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 881                         return widget->outputs;
 882                 }
 883
 884                 /* connected jack or spk ? */
 885                 if (widget->id == snd_soc_dapm_hp ||
 886                     widget->id == snd_soc_dapm_spk ||
 887                     (widget->id == snd_soc_dapm_line &&
 888                      !list_empty(&widget->sources))) {
 889                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 890                         return widget->outputs;
 891                 }
 892         }
 893
 894         list_for_each_entry(path, &widget->sinks, list_source) {
 895                 DAPM_UPDATE_STAT(widget, neighbour_checks);
 896
 897                 if (path->weak)
 898                         continue;
 899
 900                 if (path->walking)
 901                         return 1;
 902
 903                 if (path->walked)
 904                         continue;
 905
 906                 trace_snd_soc_dapm_output_path(widget, path);
 907
 908                 if (path->sink && path->connect) {
 909                         path->walked = 1;
 910                         path->walking = 1;
 911
 912                         /* do we need to add this widget to the list ? */
 913                         if (list) {
 914                                 int err;
 915                                 err = dapm_list_add_widget(list, path->sink);
 916                                 if (err < 0) {
 917                                         dev_err(widget->dapm->dev,
 918                                                 "ASoC: could not add widget %s\n",
 919                                                 widget->name);
 920                                         path->walking = 0;
 921                                         return con;
 922                                 }
 923                         }
 924
 925                         con += is_connected_output_ep(path->sink, list);
 926
 927                         path->walking = 0;
 928                 }
 929         }
 930
 931         widget->outputs = con;
 932
 933         return con;
 934 }
 935
 936 /*
 937  * Recursively check for a completed path to an active or physically connected
 938  * input widget. Returns number of complete paths.
 939  */
 940 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
 941         struct snd_soc_dapm_widget_list **list)
 942 {
 943         struct snd_soc_dapm_path *path;
 944         int con = 0;
 945
 946         if (widget->inputs >= 0)
 947                 return widget->inputs;
 948
 949         DAPM_UPDATE_STAT(widget, path_checks);
 950
 951         switch (widget->id) {
 952         case snd_soc_dapm_supply:
 953         case snd_soc_dapm_regulator_supply:
 954         case snd_soc_dapm_clock_supply:
 955         case snd_soc_dapm_kcontrol:
 956                 return 0;
 957         default:
 958                 break;
 959         }
 960
 961         /* active stream ? */
 962         switch (widget->id) {
 963         case snd_soc_dapm_dac:
 964         case snd_soc_dapm_aif_in:
 965         case snd_soc_dapm_dai_in:
 966                 if (widget->active) {
 967                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 968                         return widget->inputs;
 969                 }
 970         default:
 971                 break;
 972         }
 973
 974         if (widget->connected) {
 975                 /* connected pin ? */
 976                 if (widget->id == snd_soc_dapm_input && !widget->ext) {
 977                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 978                         return widget->inputs;
 979                 }
 980
 981                 /* connected VMID/Bias for lower pops */
 982                 if (widget->id == snd_soc_dapm_vmid) {
 983                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 984                         return widget->inputs;
 985                 }
 986
 987                 /* connected jack ? */
 988                 if (widget->id == snd_soc_dapm_mic ||
 989                     (widget->id == snd_soc_dapm_line &&
 990                      !list_empty(&widget->sinks))) {
 991                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 992                         return widget->inputs;
 993                 }
 994
 995                 /* signal generator */
 996                 if (widget->id == snd_soc_dapm_siggen) {
 997                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 998                         return widget->inputs;
 999                 }
1000         }
1001
1002         list_for_each_entry(path, &widget->sources, list_sink) {
1003                 DAPM_UPDATE_STAT(widget, neighbour_checks);
1004
1005                 if (path->weak)
1006                         continue;
1007
1008                 if (path->walking)
1009                         return 1;
1010
1011                 if (path->walked)
1012                         continue;
1013
1014                 trace_snd_soc_dapm_input_path(widget, path);
1015
1016                 if (path->source && path->connect) {
1017                         path->walked = 1;
1018                         path->walking = 1;
1019
1020                         /* do we need to add this widget to the list ? */
1021                         if (list) {
1022                                 int err;
1023                                 err = dapm_list_add_widget(list, path->source);
1024                                 if (err < 0) {
1025                                         dev_err(widget->dapm->dev,
1026                                                 "ASoC: could not add widget %s\n",
1027                                                 widget->name);
1028                                         path->walking = 0;
1029                                         return con;
1030                                 }
1031                         }
1032
1033                         con += is_connected_input_ep(path->source, list);
1034
1035                         path->walking = 0;
1036                 }
1037         }
1038
1039         widget->inputs = con;
1040
1041         return con;
1042 }
1043
1044 /**
1045  * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1046  * @dai: the soc DAI.
1047  * @stream: stream direction.
1048  * @list: list of active widgets for this stream.
1049  *
1050  * Queries DAPM graph as to whether an valid audio stream path exists for
1051  * the initial stream specified by name. This takes into account
1052  * current mixer and mux kcontrol settings. Creates list of valid widgets.
1053  *
1054  * Returns the number of valid paths or negative error.
1055  */
1056 int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1057         struct snd_soc_dapm_widget_list **list)
1058 {
1059         struct snd_soc_card *card = dai->card;
1060         int paths;
1061
1062         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1063         dapm_reset(card);
1064
1065         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1066                 paths = is_connected_output_ep(dai->playback_widget, list);
1067                 dapm_clear_walk_output(&card->dapm,
1068                                        &dai->playback_widget->sinks);
1069         } else {
1070                 paths = is_connected_input_ep(dai->capture_widget, list);
1071                 dapm_clear_walk_input(&card->dapm,
1072                                       &dai->capture_widget->sources);
1073         }
1074
1075         trace_snd_soc_dapm_connected(paths, stream);
1076         mutex_unlock(&card->dapm_mutex);
1077
1078         return paths;
1079 }
1080
1081 /*
1082  * Handler for regulator supply widget.
1083  */
1084 int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1085                    struct snd_kcontrol *kcontrol, int event)
1086 {
1087         int ret;
1088
1089         soc_dapm_async_complete(w->dapm);
1090
1091         if (SND_SOC_DAPM_EVENT_ON(event)) {
1092                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1093                         ret = regulator_allow_bypass(w->regulator, false);
1094                         if (ret != 0)
1095                                 dev_warn(w->dapm->dev,
1096                                          "ASoC: Failed to unbypass %s: %d\n",
1097                                          w->name, ret);
1098                 }
1099
1100                 return regulator_enable(w->regulator);
1101         } else {
1102                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1103                         ret = regulator_allow_bypass(w->regulator, true);
1104                         if (ret != 0)
1105                                 dev_warn(w->dapm->dev,
1106                                          "ASoC: Failed to bypass %s: %d\n",
1107                                          w->name, ret);
1108                 }
1109
1110                 return regulator_disable_deferred(w->regulator, w->shift);
1111         }
1112 }
1113 EXPORT_SYMBOL_GPL(dapm_regulator_event);
1114
1115 /*
1116  * Handler for clock supply widget.
1117  */
1118 int dapm_clock_event(struct snd_soc_dapm_widget *w,
1119                    struct snd_kcontrol *kcontrol, int event)
1120 {
1121         if (!w->clk)
1122                 return -EIO;
1123
1124         soc_dapm_async_complete(w->dapm);
1125
1126 #ifdef CONFIG_HAVE_CLK
1127         if (SND_SOC_DAPM_EVENT_ON(event)) {
1128                 return clk_prepare_enable(w->clk);
1129         } else {
1130                 clk_disable_unprepare(w->clk);
1131                 return 0;
1132         }
1133 #endif
1134         return 0;
1135 }
1136 EXPORT_SYMBOL_GPL(dapm_clock_event);
1137
1138 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1139 {
1140         if (w->power_checked)
1141                 return w->new_power;
1142
1143         if (w->force)
1144                 w->new_power = 1;
1145         else
1146                 w->new_power = w->power_check(w);
1147
1148         w->power_checked = true;
1149
1150         return w->new_power;
1151 }
1152
1153 /* Generic check to see if a widget should be powered.
1154  */
1155 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1156 {
1157         int in, out;
1158
1159         DAPM_UPDATE_STAT(w, power_checks);
1160
1161         in = is_connected_input_ep(w, NULL);
1162         dapm_clear_walk_input(w->dapm, &w->sources);
1163         out = is_connected_output_ep(w, NULL);
1164         dapm_clear_walk_output(w->dapm, &w->sinks);
1165         return out != 0 && in != 0;
1166 }
1167
1168 /* Check to see if an ADC has power */
1169 static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
1170 {
1171         int in;
1172
1173         DAPM_UPDATE_STAT(w, power_checks);
1174
1175         if (w->active) {
1176                 in = is_connected_input_ep(w, NULL);
1177                 dapm_clear_walk_input(w->dapm, &w->sources);
1178                 return in != 0;
1179         } else {
1180                 return dapm_generic_check_power(w);
1181         }
1182 }
1183
1184 /* Check to see if a DAC has power */
1185 static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
1186 {
1187         int out;
1188
1189         DAPM_UPDATE_STAT(w, power_checks);
1190
1191         if (w->active) {
1192                 out = is_connected_output_ep(w, NULL);
1193                 dapm_clear_walk_output(w->dapm, &w->sinks);
1194                 return out != 0;
1195         } else {
1196                 return dapm_generic_check_power(w);
1197         }
1198 }
1199
1200 /* Check to see if a power supply is needed */
1201 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1202 {
1203         struct snd_soc_dapm_path *path;
1204
1205         DAPM_UPDATE_STAT(w, power_checks);
1206
1207         /* Check if one of our outputs is connected */
1208         list_for_each_entry(path, &w->sinks, list_source) {
1209                 DAPM_UPDATE_STAT(w, neighbour_checks);
1210
1211                 if (path->weak)
1212                         continue;
1213
1214                 if (path->connected &&
1215                     !path->connected(path->source, path->sink))
1216                         continue;
1217
1218                 if (!path->sink)
1219                         continue;
1220
1221                 if (dapm_widget_power_check(path->sink))
1222                         return 1;
1223         }
1224
1225         return 0;
1226 }
1227
1228 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1229 {
1230         return 1;
1231 }
1232
1233 static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1234                             struct snd_soc_dapm_widget *b,
1235                             bool power_up)
1236 {
1237         int *sort;
1238
1239         if (power_up)
1240                 sort = dapm_up_seq;
1241         else
1242                 sort = dapm_down_seq;
1243
1244         if (sort[a->id] != sort[b->id])
1245                 return sort[a->id] - sort[b->id];
1246         if (a->subseq != b->subseq) {
1247                 if (power_up)
1248                         return a->subseq - b->subseq;
1249                 else
1250                         return b->subseq - a->subseq;
1251         }
1252         if (a->reg != b->reg)
1253                 return a->reg - b->reg;
1254         if (a->dapm != b->dapm)
1255                 return (unsigned long)a->dapm - (unsigned long)b->dapm;
1256
1257         return 0;
1258 }
1259
1260 /* Insert a widget in order into a DAPM power sequence. */
1261 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1262                             struct list_head *list,
1263                             bool power_up)
1264 {
1265         struct snd_soc_dapm_widget *w;
1266
1267         list_for_each_entry(w, list, power_list)
1268                 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
1269                         list_add_tail(&new_widget->power_list, &w->power_list);
1270                         return;
1271                 }
1272
1273         list_add_tail(&new_widget->power_list, list);
1274 }
1275
1276 static void dapm_seq_check_event(struct snd_soc_card *card,
1277                                  struct snd_soc_dapm_widget *w, int event)
1278 {
1279         const char *ev_name;
1280         int power, ret;
1281
1282         switch (event) {
1283         case SND_SOC_DAPM_PRE_PMU:
1284                 ev_name = "PRE_PMU";
1285                 power = 1;
1286                 break;
1287         case SND_SOC_DAPM_POST_PMU:
1288                 ev_name = "POST_PMU";
1289                 power = 1;
1290                 break;
1291         case SND_SOC_DAPM_PRE_PMD:
1292                 ev_name = "PRE_PMD";
1293                 power = 0;
1294                 break;
1295         case SND_SOC_DAPM_POST_PMD:
1296                 ev_name = "POST_PMD";
1297                 power = 0;
1298                 break;
1299         case SND_SOC_DAPM_WILL_PMU:
1300                 ev_name = "WILL_PMU";
1301                 power = 1;
1302                 break;
1303         case SND_SOC_DAPM_WILL_PMD:
1304                 ev_name = "WILL_PMD";
1305                 power = 0;
1306                 break;
1307         default:
1308                 WARN(1, "Unknown event %d\n", event);
1309                 return;
1310         }
1311
1312         if (w->new_power != power)
1313                 return;
1314
1315         if (w->event && (w->event_flags & event)) {
1316                 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1317                         w->name, ev_name);
1318                 soc_dapm_async_complete(w->dapm);
1319                 trace_snd_soc_dapm_widget_event_start(w, event);
1320                 ret = w->event(w, NULL, event);
1321                 trace_snd_soc_dapm_widget_event_done(w, event);
1322                 if (ret < 0)
1323                         dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1324                                ev_name, w->name, ret);
1325         }
1326 }
1327
1328 /* Apply the coalesced changes from a DAPM sequence */
1329 static void dapm_seq_run_coalesced(struct snd_soc_card *card,
1330                                    struct list_head *pending)
1331 {
1332         struct snd_soc_dapm_context *dapm;
1333         struct snd_soc_dapm_widget *w;
1334         int reg;
1335         unsigned int value = 0;
1336         unsigned int mask = 0;
1337
1338         w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1339         reg = w->reg;
1340         dapm = w->dapm;
1341
1342         list_for_each_entry(w, pending, power_list) {
1343                 WARN_ON(reg != w->reg || dapm != w->dapm);
1344                 w->power = w->new_power;
1345
1346                 mask |= w->mask << w->shift;
1347                 if (w->power)
1348                         value |= w->on_val << w->shift;
1349                 else
1350                         value |= w->off_val << w->shift;
1351
1352                 pop_dbg(dapm->dev, card->pop_time,
1353                         "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1354                         w->name, reg, value, mask);
1355
1356                 /* Check for events */
1357                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1358                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
1359         }
1360
1361         if (reg >= 0) {
1362                 /* Any widget will do, they should all be updating the
1363                  * same register.
1364                  */
1365
1366                 pop_dbg(dapm->dev, card->pop_time,
1367                         "pop test : Applying 0x%x/0x%x to %x in %dms\n",
1368                         value, mask, reg, card->pop_time);
1369                 pop_wait(card->pop_time);
1370                 soc_dapm_update_bits(dapm, reg, mask, value);
1371         }
1372
1373         list_for_each_entry(w, pending, power_list) {
1374                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1375                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
1376         }
1377 }
1378
1379 /* Apply a DAPM power sequence.
1380  *
1381  * We walk over a pre-sorted list of widgets to apply power to.  In
1382  * order to minimise the number of writes to the device required
1383  * multiple widgets will be updated in a single write where possible.
1384  * Currently anything that requires more than a single write is not
1385  * handled.
1386  */
1387 static void dapm_seq_run(struct snd_soc_card *card,
1388         struct list_head *list, int event, bool power_up)
1389 {
1390         struct snd_soc_dapm_widget *w, *n;
1391         struct snd_soc_dapm_context *d;
1392         LIST_HEAD(pending);
1393         int cur_sort = -1;
1394         int cur_subseq = -1;
1395         int cur_reg = SND_SOC_NOPM;
1396         struct snd_soc_dapm_context *cur_dapm = NULL;
1397         int ret, i;
1398         int *sort;
1399
1400         if (power_up)
1401                 sort = dapm_up_seq;
1402         else
1403                 sort = dapm_down_seq;
1404
1405         list_for_each_entry_safe(w, n, list, power_list) {
1406                 ret = 0;
1407
1408                 /* Do we need to apply any queued changes? */
1409                 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1410                     w->dapm != cur_dapm || w->subseq != cur_subseq) {
1411                         if (!list_empty(&pending))
1412                                 dapm_seq_run_coalesced(card, &pending);
1413
1414                         if (cur_dapm && cur_dapm->seq_notifier) {
1415                                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1416                                         if (sort[i] == cur_sort)
1417                                                 cur_dapm->seq_notifier(cur_dapm,
1418                                                                        i,
1419                                                                        cur_subseq);
1420                         }
1421
1422                         if (cur_dapm && w->dapm != cur_dapm)
1423                                 soc_dapm_async_complete(cur_dapm);
1424
1425                         INIT_LIST_HEAD(&pending);
1426                         cur_sort = -1;
1427                         cur_subseq = INT_MIN;
1428                         cur_reg = SND_SOC_NOPM;
1429                         cur_dapm = NULL;
1430                 }
1431
1432                 switch (w->id) {
1433                 case snd_soc_dapm_pre:
1434                         if (!w->event)
1435                                 list_for_each_entry_safe_continue(w, n, list,
1436                                                                   power_list);
1437
1438                         if (event == SND_SOC_DAPM_STREAM_START)
1439                                 ret = w->event(w,
1440                                                NULL, SND_SOC_DAPM_PRE_PMU);
1441                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1442                                 ret = w->event(w,
1443                                                NULL, SND_SOC_DAPM_PRE_PMD);
1444                         break;
1445
1446                 case snd_soc_dapm_post:
1447                         if (!w->event)
1448                                 list_for_each_entry_safe_continue(w, n, list,
1449                                                                   power_list);
1450
1451                         if (event == SND_SOC_DAPM_STREAM_START)
1452                                 ret = w->event(w,
1453                                                NULL, SND_SOC_DAPM_POST_PMU);
1454                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1455                                 ret = w->event(w,
1456                                                NULL, SND_SOC_DAPM_POST_PMD);
1457                         break;
1458
1459                 default:
1460                         /* Queue it up for application */
1461                         cur_sort = sort[w->id];
1462                         cur_subseq = w->subseq;
1463                         cur_reg = w->reg;
1464                         cur_dapm = w->dapm;
1465                         list_move(&w->power_list, &pending);
1466                         break;
1467                 }
1468
1469                 if (ret < 0)
1470                         dev_err(w->dapm->dev,
1471                                 "ASoC: Failed to apply widget power: %d\n", ret);
1472         }
1473
1474         if (!list_empty(&pending))
1475                 dapm_seq_run_coalesced(card, &pending);
1476
1477         if (cur_dapm && cur_dapm->seq_notifier) {
1478                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1479                         if (sort[i] == cur_sort)
1480                                 cur_dapm->seq_notifier(cur_dapm,
1481                                                        i, cur_subseq);
1482         }
1483
1484         list_for_each_entry(d, &card->dapm_list, list) {
1485                 soc_dapm_async_complete(d);
1486         }
1487 }
1488
1489 static void dapm_widget_update(struct snd_soc_card *card)
1490 {
1491         struct snd_soc_dapm_update *update = card->update;
1492         struct snd_soc_dapm_widget_list *wlist;
1493         struct snd_soc_dapm_widget *w = NULL;
1494         unsigned int wi;
1495         int ret;
1496
1497         if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
1498                 return;
1499
1500         wlist = dapm_kcontrol_get_wlist(update->kcontrol);
1501
1502         for (wi = 0; wi < wlist->num_widgets; wi++) {
1503                 w = wlist->widgets[wi];
1504
1505                 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1506                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1507                         if (ret != 0)
1508                                 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
1509                                            w->name, ret);
1510                 }
1511         }
1512
1513         if (!w)
1514                 return;
1515
1516         ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1517                 update->val);
1518         if (ret < 0)
1519                 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
1520                         w->name, ret);
1521
1522         for (wi = 0; wi < wlist->num_widgets; wi++) {
1523                 w = wlist->widgets[wi];
1524
1525                 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1526                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1527                         if (ret != 0)
1528                                 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
1529                                            w->name, ret);
1530                 }
1531         }
1532 }
1533
1534 /* Async callback run prior to DAPM sequences - brings to _PREPARE if
1535  * they're changing state.
1536  */
1537 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1538 {
1539         struct snd_soc_dapm_context *d = data;
1540         int ret;
1541
1542         /* If we're off and we're not supposed to be go into STANDBY */
1543         if (d->bias_level == SND_SOC_BIAS_OFF &&
1544             d->target_bias_level != SND_SOC_BIAS_OFF) {
1545                 if (d->dev)
1546                         pm_runtime_get_sync(d->dev);
1547
1548                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1549                 if (ret != 0)
1550                         dev_err(d->dev,
1551                                 "ASoC: Failed to turn on bias: %d\n", ret);
1552         }
1553
1554         /* Prepare for a transition to ON or away from ON */
1555         if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1556              d->bias_level != SND_SOC_BIAS_ON) ||
1557             (d->target_bias_level != SND_SOC_BIAS_ON &&
1558              d->bias_level == SND_SOC_BIAS_ON)) {
1559                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1560                 if (ret != 0)
1561                         dev_err(d->dev,
1562                                 "ASoC: Failed to prepare bias: %d\n", ret);
1563         }
1564 }
1565
1566 /* Async callback run prior to DAPM sequences - brings to their final
1567  * state.
1568  */
1569 static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1570 {
1571         struct snd_soc_dapm_context *d = data;
1572         int ret;
1573
1574         /* If we just powered the last thing off drop to standby bias */
1575         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1576             (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1577              d->target_bias_level == SND_SOC_BIAS_OFF)) {
1578                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1579                 if (ret != 0)
1580                         dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
1581                                 ret);
1582         }
1583
1584         /* If we're in standby and can support bias off then do that */
1585         if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1586             d->target_bias_level == SND_SOC_BIAS_OFF) {
1587                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1588                 if (ret != 0)
1589                         dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1590                                 ret);
1591
1592                 if (d->dev)
1593                         pm_runtime_put(d->dev);
1594         }
1595
1596         /* If we just powered up then move to active bias */
1597         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1598             d->target_bias_level == SND_SOC_BIAS_ON) {
1599                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1600                 if (ret != 0)
1601                         dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
1602                                 ret);
1603         }
1604 }
1605
1606 static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1607                                        bool power, bool connect)
1608 {
1609         /* If a connection is being made or broken then that update
1610          * will have marked the peer dirty, otherwise the widgets are
1611          * not connected and this update has no impact. */
1612         if (!connect)
1613                 return;
1614
1615         /* If the peer is already in the state we're moving to then we
1616          * won't have an impact on it. */
1617         if (power != peer->power)
1618                 dapm_mark_dirty(peer, "peer state change");
1619 }
1620
1621 static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1622                                   struct list_head *up_list,
1623                                   struct list_head *down_list)
1624 {
1625         struct snd_soc_dapm_path *path;
1626
1627         if (w->power == power)
1628                 return;
1629
1630         trace_snd_soc_dapm_widget_power(w, power);
1631
1632         /* If we changed our power state perhaps our neigbours changed
1633          * also.
1634          */
1635         list_for_each_entry(path, &w->sources, list_sink) {
1636                 if (path->source) {
1637                         dapm_widget_set_peer_power(path->source, power,
1638                                                    path->connect);
1639                 }
1640         }
1641         switch (w->id) {
1642         case snd_soc_dapm_supply:
1643         case snd_soc_dapm_regulator_supply:
1644         case snd_soc_dapm_clock_supply:
1645         case snd_soc_dapm_kcontrol:
1646                 /* Supplies can't affect their outputs, only their inputs */
1647                 break;
1648         default:
1649                 list_for_each_entry(path, &w->sinks, list_source) {
1650                         if (path->sink) {
1651                                 dapm_widget_set_peer_power(path->sink, power,
1652                                                            path->connect);
1653                         }
1654                 }
1655                 break;
1656         }
1657
1658         if (power)
1659                 dapm_seq_insert(w, up_list, true);
1660         else
1661                 dapm_seq_insert(w, down_list, false);
1662 }
1663
1664 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1665                                   struct list_head *up_list,
1666                                   struct list_head *down_list)
1667 {
1668         int power;
1669
1670         switch (w->id) {
1671         case snd_soc_dapm_pre:
1672                 dapm_seq_insert(w, down_list, false);
1673                 break;
1674         case snd_soc_dapm_post:
1675                 dapm_seq_insert(w, up_list, true);
1676                 break;
1677
1678         default:
1679                 power = dapm_widget_power_check(w);
1680
1681                 dapm_widget_set_power(w, power, up_list, down_list);
1682                 break;
1683         }
1684 }
1685
1686 /*
1687  * Scan each dapm widget for complete audio path.
1688  * A complete path is a route that has valid endpoints i.e.:-
1689  *
1690  *  o DAC to output pin.
1691  *  o Input Pin to ADC.
1692  *  o Input pin to Output pin (bypass, sidetone)
1693  *  o DAC to ADC (loopback).
1694  */
1695 static int dapm_power_widgets(struct snd_soc_card *card, int event)
1696 {
1697         struct snd_soc_dapm_widget *w;
1698         struct snd_soc_dapm_context *d;
1699         LIST_HEAD(up_list);
1700         LIST_HEAD(down_list);
1701         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
1702         enum snd_soc_bias_level bias;
1703
1704         lockdep_assert_held(&card->dapm_mutex);
1705
1706         trace_snd_soc_dapm_start(card);
1707
1708         list_for_each_entry(d, &card->dapm_list, list) {
1709                 if (d->idle_bias_off)
1710                         d->target_bias_level = SND_SOC_BIAS_OFF;
1711                 else
1712                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1713         }
1714
1715         dapm_reset(card);
1716
1717         /* Check which widgets we need to power and store them in
1718          * lists indicating if they should be powered up or down.  We
1719          * only check widgets that have been flagged as dirty but note
1720          * that new widgets may be added to the dirty list while we
1721          * iterate.
1722          */
1723         list_for_each_entry(w, &card->dapm_dirty, dirty) {
1724                 dapm_power_one_widget(w, &up_list, &down_list);
1725         }
1726
1727         list_for_each_entry(w, &card->widgets, list) {
1728                 switch (w->id) {
1729                 case snd_soc_dapm_pre:
1730                 case snd_soc_dapm_post:
1731                         /* These widgets always need to be powered */
1732                         break;
1733                 default:
1734                         list_del_init(&w->dirty);
1735                         break;
1736                 }
1737
1738                 if (w->new_power) {
1739                         d = w->dapm;
1740
1741                         /* Supplies and micbiases only bring the
1742                          * context up to STANDBY as unless something
1743                          * else is active and passing audio they
1744                          * generally don't require full power.  Signal
1745                          * generators are virtual pins and have no
1746                          * power impact themselves.
1747                          */
1748                         switch (w->id) {
1749                         case snd_soc_dapm_siggen:
1750                         case snd_soc_dapm_vmid:
1751                                 break;
1752                         case snd_soc_dapm_supply:
1753                         case snd_soc_dapm_regulator_supply:
1754                         case snd_soc_dapm_clock_supply:
1755                         case snd_soc_dapm_micbias:
1756                                 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1757                                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1758                                 break;
1759                         default:
1760                                 d->target_bias_level = SND_SOC_BIAS_ON;
1761                                 break;
1762                         }
1763                 }
1764
1765         }
1766
1767         /* Force all contexts in the card to the same bias state if
1768          * they're not ground referenced.
1769          */
1770         bias = SND_SOC_BIAS_OFF;
1771         list_for_each_entry(d, &card->dapm_list, list)
1772                 if (d->target_bias_level > bias)
1773                         bias = d->target_bias_level;
1774         list_for_each_entry(d, &card->dapm_list, list)
1775                 if (!d->idle_bias_off)
1776                         d->target_bias_level = bias;
1777
1778         trace_snd_soc_dapm_walk_done(card);
1779
1780         /* Run card bias changes at first */
1781         dapm_pre_sequence_async(&card->dapm, 0);
1782         /* Run other bias changes in parallel */
1783         list_for_each_entry(d, &card->dapm_list, list) {
1784                 if (d != &card->dapm)
1785                         async_schedule_domain(dapm_pre_sequence_async, d,
1786                                                 &async_domain);
1787         }
1788         async_synchronize_full_domain(&async_domain);
1789
1790         list_for_each_entry(w, &down_list, power_list) {
1791                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
1792         }
1793
1794         list_for_each_entry(w, &up_list, power_list) {
1795                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
1796         }
1797
1798         /* Power down widgets first; try to avoid amplifying pops. */
1799         dapm_seq_run(card, &down_list, event, false);
1800
1801         dapm_widget_update(card);
1802
1803         /* Now power up. */
1804         dapm_seq_run(card, &up_list, event, true);
1805
1806         /* Run all the bias changes in parallel */
1807         list_for_each_entry(d, &card->dapm_list, list) {
1808                 if (d != &card->dapm)
1809                         async_schedule_domain(dapm_post_sequence_async, d,
1810                                                 &async_domain);
1811         }
1812         async_synchronize_full_domain(&async_domain);
1813         /* Run card bias changes at last */
1814         dapm_post_sequence_async(&card->dapm, 0);
1815
1816         /* do we need to notify any clients that DAPM event is complete */
1817         list_for_each_entry(d, &card->dapm_list, list) {
1818                 if (d->stream_event)
1819                         d->stream_event(d, event);
1820         }
1821
1822         pop_dbg(card->dev, card->pop_time,
1823                 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
1824         pop_wait(card->pop_time);
1825
1826         trace_snd_soc_dapm_done(card);
1827
1828         return 0;
1829 }
1830
1831 #ifdef CONFIG_DEBUG_FS
1832 static ssize_t dapm_widget_power_read_file(struct file *file,
1833                                            char __user *user_buf,
1834                                            size_t count, loff_t *ppos)
1835 {
1836         struct snd_soc_dapm_widget *w = file->private_data;
1837         char *buf;
1838         int in, out;
1839         ssize_t ret;
1840         struct snd_soc_dapm_path *p = NULL;
1841
1842         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1843         if (!buf)
1844                 return -ENOMEM;
1845
1846         in = is_connected_input_ep(w, NULL);
1847         dapm_clear_walk_input(w->dapm, &w->sources);
1848         out = is_connected_output_ep(w, NULL);
1849         dapm_clear_walk_output(w->dapm, &w->sinks);
1850
1851         ret = snprintf(buf, PAGE_SIZE, "%s: %s%s  in %d out %d",
1852                        w->name, w->power ? "On" : "Off",
1853                        w->force ? " (forced)" : "", in, out);
1854
1855         if (w->reg >= 0)
1856                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1857                                 " - R%d(0x%x) mask 0x%x",
1858                                 w->reg, w->reg, w->mask << w->shift);
1859
1860         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1861
1862         if (w->sname)
1863                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1864                                 w->sname,
1865                                 w->active ? "active" : "inactive");
1866
1867         list_for_each_entry(p, &w->sources, list_sink) {
1868                 if (p->connected && !p->connected(w, p->source))
1869                         continue;
1870
1871                 if (p->connect)
1872                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1873                                         " in  \"%s\" \"%s\"\n",
1874                                         p->name ? p->name : "static",
1875                                         p->source->name);
1876         }
1877         list_for_each_entry(p, &w->sinks, list_source) {
1878                 if (p->connected && !p->connected(w, p->sink))
1879                         continue;
1880
1881                 if (p->connect)
1882                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1883                                         " out \"%s\" \"%s\"\n",
1884                                         p->name ? p->name : "static",
1885                                         p->sink->name);
1886         }
1887
1888         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1889
1890         kfree(buf);
1891         return ret;
1892 }
1893
1894 static const struct file_operations dapm_widget_power_fops = {
1895         .open = simple_open,
1896         .read = dapm_widget_power_read_file,
1897         .llseek = default_llseek,
1898 };
1899
1900 static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1901                                    size_t count, loff_t *ppos)
1902 {
1903         struct snd_soc_dapm_context *dapm = file->private_data;
1904         char *level;
1905
1906         switch (dapm->bias_level) {
1907         case SND_SOC_BIAS_ON:
1908                 level = "On\n";
1909                 break;
1910         case SND_SOC_BIAS_PREPARE:
1911                 level = "Prepare\n";
1912                 break;
1913         case SND_SOC_BIAS_STANDBY:
1914                 level = "Standby\n";
1915                 break;
1916         case SND_SOC_BIAS_OFF:
1917                 level = "Off\n";
1918                 break;
1919         default:
1920                 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
1921                 level = "Unknown\n";
1922                 break;
1923         }
1924
1925         return simple_read_from_buffer(user_buf, count, ppos, level,
1926                                        strlen(level));
1927 }
1928
1929 static const struct file_operations dapm_bias_fops = {
1930         .open = simple_open,
1931         .read = dapm_bias_read_file,
1932         .llseek = default_llseek,
1933 };
1934
1935 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1936         struct dentry *parent)
1937 {
1938         struct dentry *d;
1939
1940         dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
1941
1942         if (!dapm->debugfs_dapm) {
1943                 dev_warn(dapm->dev,
1944                        "ASoC: Failed to create DAPM debugfs directory\n");
1945                 return;
1946         }
1947
1948         d = debugfs_create_file("bias_level", 0444,
1949                                 dapm->debugfs_dapm, dapm,
1950                                 &dapm_bias_fops);
1951         if (!d)
1952                 dev_warn(dapm->dev,
1953                          "ASoC: Failed to create bias level debugfs file\n");
1954 }
1955
1956 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1957 {
1958         struct snd_soc_dapm_context *dapm = w->dapm;
1959         struct dentry *d;
1960
1961         if (!dapm->debugfs_dapm || !w->name)
1962                 return;
1963
1964         d = debugfs_create_file(w->name, 0444,
1965                                 dapm->debugfs_dapm, w,
1966                                 &dapm_widget_power_fops);
1967         if (!d)
1968                 dev_warn(w->dapm->dev,
1969                         "ASoC: Failed to create %s debugfs file\n",
1970                         w->name);
1971 }
1972
1973 static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1974 {
1975         debugfs_remove_recursive(dapm->debugfs_dapm);
1976 }
1977
1978 #else
1979 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1980         struct dentry *parent)
1981 {
1982 }
1983
1984 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1985 {
1986 }
1987
1988 static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1989 {
1990 }
1991
1992 #endif
1993
1994 /* test and update the power status of a mux widget */
1995 static int soc_dapm_mux_update_power(struct snd_soc_card *card,
1996                                  struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
1997 {
1998         struct snd_soc_dapm_path *path;
1999         int found = 0;
2000
2001         lockdep_assert_held(&card->dapm_mutex);
2002
2003         /* find dapm widget path assoc with kcontrol */
2004         dapm_kcontrol_for_each_path(path, kcontrol) {
2005                 if (!path->name || !e->texts[mux])
2006                         continue;
2007
2008                 found = 1;
2009                 /* we now need to match the string in the enum to the path */
2010                 if (!(strcmp(path->name, e->texts[mux]))) {
2011                         path->connect = 1; /* new connection */
2012                         dapm_mark_dirty(path->source, "mux connection");
2013                 } else {
2014                         if (path->connect)
2015                                 dapm_mark_dirty(path->source,
2016                                                 "mux disconnection");
2017                         path->connect = 0; /* old connection must be powered down */
2018                 }
2019                 dapm_mark_dirty(path->sink, "mux change");
2020         }
2021
2022         if (found)
2023                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2024
2025         return found;
2026 }
2027
2028 int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
2029         struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2030         struct snd_soc_dapm_update *update)
2031 {
2032         struct snd_soc_card *card = dapm->card;
2033         int ret;
2034
2035         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2036         card->update = update;
2037         ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
2038         card->update = NULL;
2039         mutex_unlock(&card->dapm_mutex);
2040         if (ret > 0)
2041                 soc_dpcm_runtime_update(card);
2042         return ret;
2043 }
2044 EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2045
2046 /* test and update the power status of a mixer or switch widget */
2047 static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
2048                                    struct snd_kcontrol *kcontrol, int connect)
2049 {
2050         struct snd_soc_dapm_path *path;
2051         int found = 0;
2052
2053         lockdep_assert_held(&card->dapm_mutex);
2054
2055         /* find dapm widget path assoc with kcontrol */
2056         dapm_kcontrol_for_each_path(path, kcontrol) {
2057                 found = 1;
2058                 path->connect = connect;
2059                 dapm_mark_dirty(path->source, "mixer connection");
2060                 dapm_mark_dirty(path->sink, "mixer update");
2061         }
2062
2063         if (found)
2064                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2065
2066         return found;
2067 }
2068
2069 int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
2070         struct snd_kcontrol *kcontrol, int connect,
2071         struct snd_soc_dapm_update *update)
2072 {
2073         struct snd_soc_card *card = dapm->card;
2074         int ret;
2075
2076         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2077         card->update = update;
2078         ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
2079         card->update = NULL;
2080         mutex_unlock(&card->dapm_mutex);
2081         if (ret > 0)
2082                 soc_dpcm_runtime_update(card);
2083         return ret;
2084 }
2085 EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2086
2087 static ssize_t dapm_widget_show_codec(struct snd_soc_codec *codec, char *buf)
2088 {
2089         struct snd_soc_dapm_widget *w;
2090         int count = 0;
2091         char *state = "not set";
2092
2093         list_for_each_entry(w, &codec->component.card->widgets, list) {
2094                 if (w->dapm != &codec->dapm)
2095                         continue;
2096
2097                 /* only display widgets that burnm power */
2098                 switch (w->id) {
2099                 case snd_soc_dapm_hp:
2100                 case snd_soc_dapm_mic:
2101                 case snd_soc_dapm_spk:
2102                 case snd_soc_dapm_line:
2103                 case snd_soc_dapm_micbias:
2104                 case snd_soc_dapm_dac:
2105                 case snd_soc_dapm_adc:
2106                 case snd_soc_dapm_pga:
2107                 case snd_soc_dapm_out_drv:
2108                 case snd_soc_dapm_mixer:
2109                 case snd_soc_dapm_mixer_named_ctl:
2110                 case snd_soc_dapm_supply:
2111                 case snd_soc_dapm_regulator_supply:
2112                 case snd_soc_dapm_clock_supply:
2113                         if (w->name)
2114                                 count += sprintf(buf + count, "%s: %s\n",
2115                                         w->name, w->power ? "On":"Off");
2116                 break;
2117                 default:
2118                 break;
2119                 }
2120         }
2121
2122         switch (codec->dapm.bias_level) {
2123         case SND_SOC_BIAS_ON:
2124                 state = "On";
2125                 break;
2126         case SND_SOC_BIAS_PREPARE:
2127                 state = "Prepare";
2128                 break;
2129         case SND_SOC_BIAS_STANDBY:
2130                 state = "Standby";
2131                 break;
2132         case SND_SOC_BIAS_OFF:
2133                 state = "Off";
2134                 break;
2135         }
2136         count += sprintf(buf + count, "PM State: %s\n", state);
2137
2138         return count;
2139 }
2140
2141 /* show dapm widget status in sys fs */
2142 static ssize_t dapm_widget_show(struct device *dev,
2143         struct device_attribute *attr, char *buf)
2144 {
2145         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2146         int i, count = 0;
2147
2148         for (i = 0; i < rtd->num_codecs; i++) {
2149                 struct snd_soc_codec *codec = rtd->codec_dais[i]->codec;
2150                 count += dapm_widget_show_codec(codec, buf + count);
2151         }
2152
2153         return count;
2154 }
2155
2156 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2157
2158 int snd_soc_dapm_sys_add(struct device *dev)
2159 {
2160         return device_create_file(dev, &dev_attr_dapm_widget);
2161 }
2162
2163 static void snd_soc_dapm_sys_remove(struct device *dev)
2164 {
2165         device_remove_file(dev, &dev_attr_dapm_widget);
2166 }
2167
2168 static void dapm_free_path(struct snd_soc_dapm_path *path)
2169 {
2170         list_del(&path->list_sink);
2171         list_del(&path->list_source);
2172         list_del(&path->list_kcontrol);
2173         list_del(&path->list);
2174         kfree(path);
2175 }
2176
2177 /* free all dapm widgets and resources */
2178 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2179 {
2180         struct snd_soc_dapm_widget *w, *next_w;
2181         struct snd_soc_dapm_path *p, *next_p;
2182
2183         list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2184                 if (w->dapm != dapm)
2185                         continue;
2186                 list_del(&w->list);
2187                 /*
2188                  * remove source and sink paths associated to this widget.
2189                  * While removing the path, remove reference to it from both
2190                  * source and sink widgets so that path is removed only once.
2191                  */
2192                 list_for_each_entry_safe(p, next_p, &w->sources, list_sink)
2193                         dapm_free_path(p);
2194
2195                 list_for_each_entry_safe(p, next_p, &w->sinks, list_source)
2196                         dapm_free_path(p);
2197
2198                 kfree(w->kcontrols);
2199                 kfree(w->name);
2200                 kfree(w);
2201         }
2202 }
2203
2204 static struct snd_soc_dapm_widget *dapm_find_widget(
2205                         struct snd_soc_dapm_context *dapm, const char *pin,
2206                         bool search_other_contexts)
2207 {
2208         struct snd_soc_dapm_widget *w;
2209         struct snd_soc_dapm_widget *fallback = NULL;
2210
2211         list_for_each_entry(w, &dapm->card->widgets, list) {
2212                 if (!strcmp(w->name, pin)) {
2213                         if (w->dapm == dapm)
2214                                 return w;
2215                         else
2216                                 fallback = w;
2217                 }
2218         }
2219
2220         if (search_other_contexts)
2221                 return fallback;
2222
2223         return NULL;
2224 }
2225
2226 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
2227                                 const char *pin, int status)
2228 {
2229         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2230
2231         dapm_assert_locked(dapm);
2232
2233         if (!w) {
2234                 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
2235                 return -EINVAL;
2236         }
2237
2238         if (w->connected != status)
2239                 dapm_mark_dirty(w, "pin configuration");
2240
2241         w->connected = status;
2242         if (status == 0)
2243                 w->force = 0;
2244
2245         return 0;
2246 }
2247
2248 /**
2249  * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2250  * @dapm: DAPM context
2251  *
2252  * Walks all dapm audio paths and powers widgets according to their
2253  * stream or path usage.
2254  *
2255  * Requires external locking.
2256  *
2257  * Returns 0 for success.
2258  */
2259 int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2260 {
2261         /*
2262          * Suppress early reports (eg, jacks syncing their state) to avoid
2263          * silly DAPM runs during card startup.
2264          */
2265         if (!dapm->card || !dapm->card->instantiated)
2266                 return 0;
2267
2268         return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2269 }
2270 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2271
2272 /**
2273  * snd_soc_dapm_sync - scan and power dapm paths
2274  * @dapm: DAPM context
2275  *
2276  * Walks all dapm audio paths and powers widgets according to their
2277  * stream or path usage.
2278  *
2279  * Returns 0 for success.
2280  */
2281 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2282 {
2283         int ret;
2284
2285         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2286         ret = snd_soc_dapm_sync_unlocked(dapm);
2287         mutex_unlock(&dapm->card->dapm_mutex);
2288         return ret;
2289 }
2290 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2291
2292 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2293         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2294         const char *control,
2295         int (*connected)(struct snd_soc_dapm_widget *source,
2296                          struct snd_soc_dapm_widget *sink))
2297 {
2298         struct snd_soc_dapm_path *path;
2299         int ret;
2300
2301         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2302         if (!path)
2303                 return -ENOMEM;
2304
2305         path->source = wsource;
2306         path->sink = wsink;
2307         path->connected = connected;
2308         INIT_LIST_HEAD(&path->list);
2309         INIT_LIST_HEAD(&path->list_kcontrol);
2310         INIT_LIST_HEAD(&path->list_source);
2311         INIT_LIST_HEAD(&path->list_sink);
2312
2313         /* check for external widgets */
2314         if (wsink->id == snd_soc_dapm_input) {
2315                 if (wsource->id == snd_soc_dapm_micbias ||
2316                         wsource->id == snd_soc_dapm_mic ||
2317                         wsource->id == snd_soc_dapm_line ||
2318                         wsource->id == snd_soc_dapm_output)
2319                         wsink->ext = 1;
2320         }
2321         if (wsource->id == snd_soc_dapm_output) {
2322                 if (wsink->id == snd_soc_dapm_spk ||
2323                         wsink->id == snd_soc_dapm_hp ||
2324                         wsink->id == snd_soc_dapm_line ||
2325                         wsink->id == snd_soc_dapm_input)
2326                         wsource->ext = 1;
2327         }
2328
2329         dapm_mark_dirty(wsource, "Route added");
2330         dapm_mark_dirty(wsink, "Route added");
2331
2332         /* connect static paths */
2333         if (control == NULL) {
2334                 list_add(&path->list, &dapm->card->paths);
2335                 list_add(&path->list_sink, &wsink->sources);
2336                 list_add(&path->list_source, &wsource->sinks);
2337                 path->connect = 1;
2338                 return 0;
2339         }
2340
2341         /* connect dynamic paths */
2342         switch (wsink->id) {
2343         case snd_soc_dapm_adc:
2344         case snd_soc_dapm_dac:
2345         case snd_soc_dapm_pga:
2346         case snd_soc_dapm_out_drv:
2347         case snd_soc_dapm_input:
2348         case snd_soc_dapm_output:
2349         case snd_soc_dapm_siggen:
2350         case snd_soc_dapm_micbias:
2351         case snd_soc_dapm_vmid:
2352         case snd_soc_dapm_pre:
2353         case snd_soc_dapm_post:
2354         case snd_soc_dapm_supply:
2355         case snd_soc_dapm_regulator_supply:
2356         case snd_soc_dapm_clock_supply:
2357         case snd_soc_dapm_aif_in:
2358         case snd_soc_dapm_aif_out:
2359         case snd_soc_dapm_dai_in:
2360         case snd_soc_dapm_dai_out:
2361         case snd_soc_dapm_dai_link:
2362         case snd_soc_dapm_kcontrol:
2363                 list_add(&path->list, &dapm->card->paths);
2364                 list_add(&path->list_sink, &wsink->sources);
2365                 list_add(&path->list_source, &wsource->sinks);
2366                 path->connect = 1;
2367                 return 0;
2368         case snd_soc_dapm_mux:
2369                 ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
2370                         &wsink->kcontrol_news[0]);
2371                 if (ret != 0)
2372                         goto err;
2373                 break;
2374         case snd_soc_dapm_switch:
2375         case snd_soc_dapm_mixer:
2376         case snd_soc_dapm_mixer_named_ctl:
2377                 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
2378                 if (ret != 0)
2379                         goto err;
2380                 break;
2381         case snd_soc_dapm_hp:
2382         case snd_soc_dapm_mic:
2383         case snd_soc_dapm_line:
2384         case snd_soc_dapm_spk:
2385                 list_add(&path->list, &dapm->card->paths);
2386                 list_add(&path->list_sink, &wsink->sources);
2387                 list_add(&path->list_source, &wsource->sinks);
2388                 path->connect = 0;
2389                 return 0;
2390         }
2391
2392         return 0;
2393 err:
2394         kfree(path);
2395         return ret;
2396 }
2397
2398 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
2399                                   const struct snd_soc_dapm_route *route)
2400 {
2401         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2402         struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2403         const char *sink;
2404         const char *source;
2405         char prefixed_sink[80];
2406         char prefixed_source[80];
2407         const char *prefix;
2408         int ret;
2409
2410         prefix = soc_dapm_prefix(dapm);
2411         if (prefix) {
2412                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2413                          prefix, route->sink);
2414                 sink = prefixed_sink;
2415                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2416                          prefix, route->source);
2417                 source = prefixed_source;
2418         } else {
2419                 sink = route->sink;
2420                 source = route->source;
2421         }
2422
2423         /*
2424          * find src and dest widgets over all widgets but favor a widget from
2425          * current DAPM context
2426          */
2427         list_for_each_entry(w, &dapm->card->widgets, list) {
2428                 if (!wsink && !(strcmp(w->name, sink))) {
2429                         wtsink = w;
2430                         if (w->dapm == dapm)
2431                                 wsink = w;
2432                         continue;
2433                 }
2434                 if (!wsource && !(strcmp(w->name, source))) {
2435                         wtsource = w;
2436                         if (w->dapm == dapm)
2437                                 wsource = w;
2438                 }
2439         }
2440         /* use widget from another DAPM context if not found from this */
2441         if (!wsink)
2442                 wsink = wtsink;
2443         if (!wsource)
2444                 wsource = wtsource;
2445
2446         if (wsource == NULL) {
2447                 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2448                         route->source);
2449                 return -ENODEV;
2450         }
2451         if (wsink == NULL) {
2452                 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2453                         route->sink);
2454                 return -ENODEV;
2455         }
2456
2457         ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2458                 route->connected);
2459         if (ret)
2460                 goto err;
2461
2462         return 0;
2463 err:
2464         dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2465                  source, route->control, sink);
2466         return ret;
2467 }
2468
2469 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2470                                   const struct snd_soc_dapm_route *route)
2471 {
2472         struct snd_soc_dapm_path *path, *p;
2473         const char *sink;
2474         const char *source;
2475         char prefixed_sink[80];
2476         char prefixed_source[80];
2477         const char *prefix;
2478
2479         if (route->control) {
2480                 dev_err(dapm->dev,
2481                         "ASoC: Removal of routes with controls not supported\n");
2482                 return -EINVAL;
2483         }
2484
2485         prefix = soc_dapm_prefix(dapm);
2486         if (prefix) {
2487                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2488                          prefix, route->sink);
2489                 sink = prefixed_sink;
2490                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2491                          prefix, route->source);
2492                 source = prefixed_source;
2493         } else {
2494                 sink = route->sink;
2495                 source = route->source;
2496         }
2497
2498         path = NULL;
2499         list_for_each_entry(p, &dapm->card->paths, list) {
2500                 if (strcmp(p->source->name, source) != 0)
2501                         continue;
2502                 if (strcmp(p->sink->name, sink) != 0)
2503                         continue;
2504                 path = p;
2505                 break;
2506         }
2507
2508         if (path) {
2509                 dapm_mark_dirty(path->source, "Route removed");
2510                 dapm_mark_dirty(path->sink, "Route removed");
2511
2512                 dapm_free_path(path);
2513         } else {
2514                 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
2515                          source, sink);
2516         }
2517
2518         return 0;
2519 }
2520
2521 /**
2522  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
2523  * @dapm: DAPM context
2524  * @route: audio routes
2525  * @num: number of routes
2526  *
2527  * Connects 2 dapm widgets together via a named audio path. The sink is
2528  * the widget receiving the audio signal, whilst the source is the sender
2529  * of the audio signal.
2530  *
2531  * Returns 0 for success else error. On error all resources can be freed
2532  * with a call to snd_soc_card_free().
2533  */
2534 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
2535                             const struct snd_soc_dapm_route *route, int num)
2536 {
2537         int i, r, ret = 0;
2538
2539         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2540         for (i = 0; i < num; i++) {
2541                 r = snd_soc_dapm_add_route(dapm, route);
2542                 if (r < 0) {
2543                         dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2544                                 route->source,
2545                                 route->control ? route->control : "direct",
2546                                 route->sink);
2547                         ret = r;
2548                 }
2549                 route++;
2550         }
2551         mutex_unlock(&dapm->card->dapm_mutex);
2552
2553         return ret;
2554 }
2555 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2556
2557 /**
2558  * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2559  * @dapm: DAPM context
2560  * @route: audio routes
2561  * @num: number of routes
2562  *
2563  * Removes routes from the DAPM context.
2564  */
2565 int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2566                             const struct snd_soc_dapm_route *route, int num)
2567 {
2568         int i, ret = 0;
2569
2570         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2571         for (i = 0; i < num; i++) {
2572                 snd_soc_dapm_del_route(dapm, route);
2573                 route++;
2574         }
2575         mutex_unlock(&dapm->card->dapm_mutex);
2576
2577         return ret;
2578 }
2579 EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2580
2581 static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2582                                    const struct snd_soc_dapm_route *route)
2583 {
2584         struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2585                                                               route->source,
2586                                                               true);
2587         struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2588                                                             route->sink,
2589                                                             true);
2590         struct snd_soc_dapm_path *path;
2591         int count = 0;
2592
2593         if (!source) {
2594                 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
2595                         route->source);
2596                 return -ENODEV;
2597         }
2598
2599         if (!sink) {
2600                 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
2601                         route->sink);
2602                 return -ENODEV;
2603         }
2604
2605         if (route->control || route->connected)
2606                 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
2607                          route->source, route->sink);
2608
2609         list_for_each_entry(path, &source->sinks, list_source) {
2610                 if (path->sink == sink) {
2611                         path->weak = 1;
2612                         count++;
2613                 }
2614         }
2615
2616         if (count == 0)
2617                 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
2618                         route->source, route->sink);
2619         if (count > 1)
2620                 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
2621                          count, route->source, route->sink);
2622
2623         return 0;
2624 }
2625
2626 /**
2627  * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2628  * @dapm: DAPM context
2629  * @route: audio routes
2630  * @num: number of routes
2631  *
2632  * Mark existing routes matching those specified in the passed array
2633  * as being weak, meaning that they are ignored for the purpose of
2634  * power decisions.  The main intended use case is for sidetone paths
2635  * which couple audio between other independent paths if they are both
2636  * active in order to make the combination work better at the user
2637  * level but which aren't intended to be "used".
2638  *
2639  * Note that CODEC drivers should not use this as sidetone type paths
2640  * can frequently also be used as bypass paths.
2641  */
2642 int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2643                              const struct snd_soc_dapm_route *route, int num)
2644 {
2645         int i, err;
2646         int ret = 0;
2647
2648         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2649         for (i = 0; i < num; i++) {
2650                 err = snd_soc_dapm_weak_route(dapm, route);
2651                 if (err)
2652                         ret = err;
2653                 route++;
2654         }
2655         mutex_unlock(&dapm->card->dapm_mutex);
2656
2657         return ret;
2658 }
2659 EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2660
2661 /**
2662  * snd_soc_dapm_new_widgets - add new dapm widgets
2663  * @dapm: DAPM context
2664  *
2665  * Checks the codec for any new dapm widgets and creates them if found.
2666  *
2667  * Returns 0 for success.
2668  */
2669 int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
2670 {
2671         struct snd_soc_dapm_widget *w;
2672         unsigned int val;
2673
2674         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2675
2676         list_for_each_entry(w, &card->widgets, list)
2677         {
2678                 if (w->new)
2679                         continue;
2680
2681                 if (w->num_kcontrols) {
2682                         w->kcontrols = kzalloc(w->num_kcontrols *
2683                                                 sizeof(struct snd_kcontrol *),
2684                                                 GFP_KERNEL);
2685                         if (!w->kcontrols) {
2686                                 mutex_unlock(&card->dapm_mutex);
2687                                 return -ENOMEM;
2688                         }
2689                 }
2690
2691                 switch(w->id) {
2692                 case snd_soc_dapm_switch:
2693                 case snd_soc_dapm_mixer:
2694                 case snd_soc_dapm_mixer_named_ctl:
2695                         dapm_new_mixer(w);
2696                         break;
2697                 case snd_soc_dapm_mux:
2698                         dapm_new_mux(w);
2699                         break;
2700                 case snd_soc_dapm_pga:
2701                 case snd_soc_dapm_out_drv:
2702                         dapm_new_pga(w);
2703                         break;
2704                 default:
2705                         break;
2706                 }
2707
2708                 /* Read the initial power state from the device */
2709                 if (w->reg >= 0) {
2710                         soc_dapm_read(w->dapm, w->reg, &val);
2711                         val = val >> w->shift;
2712                         val &= w->mask;
2713                         if (val == w->on_val)
2714                                 w->power = 1;
2715                 }
2716
2717                 w->new = 1;
2718
2719                 dapm_mark_dirty(w, "new widget");
2720                 dapm_debugfs_add_widget(w);
2721         }
2722
2723         dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2724         mutex_unlock(&card->dapm_mutex);
2725         return 0;
2726 }
2727 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2728
2729 /**
2730  * snd_soc_dapm_get_volsw - dapm mixer get callback
2731  * @kcontrol: mixer control
2732  * @ucontrol: control element information
2733  *
2734  * Callback to get the value of a dapm mixer control.
2735  *
2736  * Returns 0 for success.
2737  */
2738 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2739         struct snd_ctl_elem_value *ucontrol)
2740 {
2741         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2742         struct snd_soc_card *card = dapm->card;
2743         struct soc_mixer_control *mc =
2744                 (struct soc_mixer_control *)kcontrol->private_value;
2745         int reg = mc->reg;
2746         unsigned int shift = mc->shift;
2747         int max = mc->max;
2748         unsigned int mask = (1 << fls(max)) - 1;
2749         unsigned int invert = mc->invert;
2750         unsigned int val;
2751         int ret = 0;
2752
2753         if (snd_soc_volsw_is_stereo(mc))
2754                 dev_warn(dapm->dev,
2755                          "ASoC: Control '%s' is stereo, which is not supported\n",
2756                          kcontrol->id.name);
2757
2758         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2759         if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
2760                 ret = soc_dapm_read(dapm, reg, &val);
2761                 val = (val >> shift) & mask;
2762         } else {
2763                 val = dapm_kcontrol_get_value(kcontrol);
2764         }
2765         mutex_unlock(&card->dapm_mutex);
2766
2767         if (invert)
2768                 ucontrol->value.integer.value[0] = max - val;
2769         else
2770                 ucontrol->value.integer.value[0] = val;
2771
2772         return ret;
2773 }
2774 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
2775
2776 /**
2777  * snd_soc_dapm_put_volsw - dapm mixer set callback
2778  * @kcontrol: mixer control
2779  * @ucontrol: control element information
2780  *
2781  * Callback to set the value of a dapm mixer control.
2782  *
2783  * Returns 0 for success.
2784  */
2785 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
2786         struct snd_ctl_elem_value *ucontrol)
2787 {
2788         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2789         struct snd_soc_card *card = dapm->card;
2790         struct soc_mixer_control *mc =
2791                 (struct soc_mixer_control *)kcontrol->private_value;
2792         int reg = mc->reg;
2793         unsigned int shift = mc->shift;
2794         int max = mc->max;
2795         unsigned int mask = (1 << fls(max)) - 1;
2796         unsigned int invert = mc->invert;
2797         unsigned int val;
2798         int connect, change, reg_change = 0;
2799         struct snd_soc_dapm_update update;
2800         int ret = 0;
2801
2802         if (snd_soc_volsw_is_stereo(mc))
2803                 dev_warn(dapm->dev,
2804                          "ASoC: Control '%s' is stereo, which is not supported\n",
2805                          kcontrol->id.name);
2806
2807         val = (ucontrol->value.integer.value[0] & mask);
2808         connect = !!val;
2809
2810         if (invert)
2811                 val = max - val;
2812
2813         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2814
2815         change = dapm_kcontrol_set_value(kcontrol, val);
2816
2817         if (reg != SND_SOC_NOPM) {
2818                 mask = mask << shift;
2819                 val = val << shift;
2820
2821                 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
2822         }
2823
2824         if (change || reg_change) {
2825                 if (reg_change) {
2826                         update.kcontrol = kcontrol;
2827                         update.reg = reg;
2828                         update.mask = mask;
2829                         update.val = val;
2830                         card->update = &update;
2831                 }
2832                 change |= reg_change;
2833
2834                 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
2835
2836                 card->update = NULL;
2837         }
2838
2839         mutex_unlock(&card->dapm_mutex);
2840
2841         if (ret > 0)
2842                 soc_dpcm_runtime_update(card);
2843
2844         return change;
2845 }
2846 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
2847
2848 /**
2849  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
2850  * @kcontrol: mixer control
2851  * @ucontrol: control element information
2852  *
2853  * Callback to get the value of a dapm enumerated double mixer control.
2854  *
2855  * Returns 0 for success.
2856  */
2857 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
2858         struct snd_ctl_elem_value *ucontrol)
2859 {
2860         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2861         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2862         unsigned int reg_val, val;
2863
2864         if (e->reg != SND_SOC_NOPM) {
2865                 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
2866                 if (ret)
2867                         return ret;
2868         } else {
2869                 reg_val = dapm_kcontrol_get_value(kcontrol);
2870         }
2871
2872         val = (reg_val >> e->shift_l) & e->mask;
2873         ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
2874         if (e->shift_l != e->shift_r) {
2875                 val = (reg_val >> e->shift_r) & e->mask;
2876                 val = snd_soc_enum_val_to_item(e, val);
2877                 ucontrol->value.enumerated.item[1] = val;
2878         }
2879
2880         return 0;
2881 }
2882 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2883
2884 /**
2885  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2886  * @kcontrol: mixer control
2887  * @ucontrol: control element information
2888  *
2889  * Callback to set the value of a dapm enumerated double mixer control.
2890  *
2891  * Returns 0 for success.
2892  */
2893 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2894         struct snd_ctl_elem_value *ucontrol)
2895 {
2896         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2897         struct snd_soc_card *card = dapm->card;
2898         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2899         unsigned int *item = ucontrol->value.enumerated.item;
2900         unsigned int val, change;
2901         unsigned int mask;
2902         struct snd_soc_dapm_update update;
2903         int ret = 0;
2904
2905         if (item[0] >= e->items)
2906                 return -EINVAL;
2907
2908         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
2909         mask = e->mask << e->shift_l;
2910         if (e->shift_l != e->shift_r) {
2911                 if (item[1] > e->items)
2912                         return -EINVAL;
2913                 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
2914                 mask |= e->mask << e->shift_r;
2915         }
2916
2917         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2918
2919         if (e->reg != SND_SOC_NOPM)
2920                 change = soc_dapm_test_bits(dapm, e->reg, mask, val);
2921         else
2922                 change = dapm_kcontrol_set_value(kcontrol, val);
2923
2924         if (change) {
2925                 if (e->reg != SND_SOC_NOPM) {
2926                         update.kcontrol = kcontrol;
2927                         update.reg = e->reg;
2928                         update.mask = mask;
2929                         update.val = val;
2930                         card->update = &update;
2931                 }
2932
2933                 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
2934
2935                 card->update = NULL;
2936         }
2937
2938         mutex_unlock(&card->dapm_mutex);
2939
2940         if (ret > 0)
2941                 soc_dpcm_runtime_update(card);
2942
2943         return change;
2944 }
2945 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2946
2947 /**
2948  * snd_soc_dapm_info_pin_switch - Info for a pin switch
2949  *
2950  * @kcontrol: mixer control
2951  * @uinfo: control element information
2952  *
2953  * Callback to provide information about a pin switch control.
2954  */
2955 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
2956                                  struct snd_ctl_elem_info *uinfo)
2957 {
2958         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2959         uinfo->count = 1;
2960         uinfo->value.integer.min = 0;
2961         uinfo->value.integer.max = 1;
2962
2963         return 0;
2964 }
2965 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
2966
2967 /**
2968  * snd_soc_dapm_get_pin_switch - Get information for a pin switch
2969  *
2970  * @kcontrol: mixer control
2971  * @ucontrol: Value
2972  */
2973 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
2974                                 struct snd_ctl_elem_value *ucontrol)
2975 {
2976         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
2977         const char *pin = (const char *)kcontrol->private_value;
2978
2979         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2980
2981         ucontrol->value.integer.value[0] =
2982                 snd_soc_dapm_get_pin_status(&card->dapm, pin);
2983
2984         mutex_unlock(&card->dapm_mutex);
2985
2986         return 0;
2987 }
2988 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
2989
2990 /**
2991  * snd_soc_dapm_put_pin_switch - Set information for a pin switch
2992  *
2993  * @kcontrol: mixer control
2994  * @ucontrol: Value
2995  */
2996 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
2997                                 struct snd_ctl_elem_value *ucontrol)
2998 {
2999         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3000         const char *pin = (const char *)kcontrol->private_value;
3001
3002         if (ucontrol->value.integer.value[0])
3003                 snd_soc_dapm_enable_pin(&card->dapm, pin);
3004         else
3005                 snd_soc_dapm_disable_pin(&card->dapm, pin);
3006
3007         snd_soc_dapm_sync(&card->dapm);
3008         return 0;
3009 }
3010 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3011
3012 static struct snd_soc_dapm_widget *
3013 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
3014                          const struct snd_soc_dapm_widget *widget)
3015 {
3016         struct snd_soc_dapm_widget *w;
3017         const char *prefix;
3018         int ret;
3019
3020         if ((w = dapm_cnew_widget(widget)) == NULL)
3021                 return NULL;
3022
3023         switch (w->id) {
3024         case snd_soc_dapm_regulator_supply:
3025                 w->regulator = devm_regulator_get(dapm->dev, w->name);
3026                 if (IS_ERR(w->regulator)) {
3027                         ret = PTR_ERR(w->regulator);
3028                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3029                                 w->name, ret);
3030                         return NULL;
3031                 }
3032
3033                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3034                         ret = regulator_allow_bypass(w->regulator, true);
3035                         if (ret != 0)
3036                                 dev_warn(w->dapm->dev,
3037                                          "ASoC: Failed to bypass %s: %d\n",
3038                                          w->name, ret);
3039                 }
3040                 break;
3041         case snd_soc_dapm_clock_supply:
3042 #ifdef CONFIG_CLKDEV_LOOKUP
3043                 w->clk = devm_clk_get(dapm->dev, w->name);
3044                 if (IS_ERR(w->clk)) {
3045                         ret = PTR_ERR(w->clk);
3046                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3047                                 w->name, ret);
3048                         return NULL;
3049                 }
3050 #else
3051                 return NULL;
3052 #endif
3053                 break;
3054         default:
3055                 break;
3056         }
3057
3058         prefix = soc_dapm_prefix(dapm);
3059         if (prefix)
3060                 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
3061         else
3062                 w->name = kasprintf(GFP_KERNEL, "%s", widget->name);
3063
3064         if (w->name == NULL) {
3065                 kfree(w);
3066                 return NULL;
3067         }
3068
3069         switch (w->id) {
3070         case snd_soc_dapm_switch:
3071         case snd_soc_dapm_mixer:
3072         case snd_soc_dapm_mixer_named_ctl:
3073                 w->power_check = dapm_generic_check_power;
3074                 break;
3075         case snd_soc_dapm_mux:
3076                 w->power_check = dapm_generic_check_power;
3077                 break;
3078         case snd_soc_dapm_dai_out:
3079                 w->power_check = dapm_adc_check_power;
3080                 break;
3081         case snd_soc_dapm_dai_in:
3082                 w->power_check = dapm_dac_check_power;
3083                 break;
3084         case snd_soc_dapm_adc:
3085         case snd_soc_dapm_aif_out:
3086         case snd_soc_dapm_dac:
3087         case snd_soc_dapm_aif_in:
3088         case snd_soc_dapm_pga:
3089         case snd_soc_dapm_out_drv:
3090         case snd_soc_dapm_input:
3091         case snd_soc_dapm_output:
3092         case snd_soc_dapm_micbias:
3093         case snd_soc_dapm_spk:
3094         case snd_soc_dapm_hp:
3095         case snd_soc_dapm_mic:
3096         case snd_soc_dapm_line:
3097         case snd_soc_dapm_dai_link:
3098                 w->power_check = dapm_generic_check_power;
3099                 break;
3100         case snd_soc_dapm_supply:
3101         case snd_soc_dapm_regulator_supply:
3102         case snd_soc_dapm_clock_supply:
3103         case snd_soc_dapm_kcontrol:
3104                 w->power_check = dapm_supply_check_power;
3105                 break;
3106         default:
3107                 w->power_check = dapm_always_on_check_power;
3108                 break;
3109         }
3110
3111         w->dapm = dapm;
3112         w->codec = dapm->codec;
3113         INIT_LIST_HEAD(&w->sources);
3114         INIT_LIST_HEAD(&w->sinks);
3115         INIT_LIST_HEAD(&w->list);
3116         INIT_LIST_HEAD(&w->dirty);
3117         list_add(&w->list, &dapm->card->widgets);
3118
3119         /* machine layer set ups unconnected pins and insertions */
3120         w->connected = 1;
3121         return w;
3122 }
3123
3124 /**
3125  * snd_soc_dapm_new_controls - create new dapm controls
3126  * @dapm: DAPM context
3127  * @widget: widget array
3128  * @num: number of widgets
3129  *
3130  * Creates new DAPM controls based upon the templates.
3131  *
3132  * Returns 0 for success else error.
3133  */
3134 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
3135         const struct snd_soc_dapm_widget *widget,
3136         int num)
3137 {
3138         struct snd_soc_dapm_widget *w;
3139         int i;
3140         int ret = 0;
3141
3142         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3143         for (i = 0; i < num; i++) {
3144                 w = snd_soc_dapm_new_control(dapm, widget);
3145                 if (!w) {
3146                         dev_err(dapm->dev,
3147                                 "ASoC: Failed to create DAPM control %s\n",
3148                                 widget->name);
3149                         ret = -ENOMEM;
3150                         break;
3151                 }
3152                 widget++;
3153         }
3154         mutex_unlock(&dapm->card->dapm_mutex);
3155         return ret;
3156 }
3157 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3158
3159 static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3160                                   struct snd_kcontrol *kcontrol, int event)
3161 {
3162         struct snd_soc_dapm_path *source_p, *sink_p;
3163         struct snd_soc_dai *source, *sink;
3164         const struct snd_soc_pcm_stream *config = w->params;
3165         struct snd_pcm_substream substream;
3166         struct snd_pcm_hw_params *params = NULL;
3167         u64 fmt;
3168         int ret;
3169
3170         if (WARN_ON(!config) ||
3171             WARN_ON(list_empty(&w->sources) || list_empty(&w->sinks)))
3172                 return -EINVAL;
3173
3174         /* We only support a single source and sink, pick the first */
3175         source_p = list_first_entry(&w->sources, struct snd_soc_dapm_path,
3176                                     list_sink);
3177         sink_p = list_first_entry(&w->sinks, struct snd_soc_dapm_path,
3178                                   list_source);
3179
3180         if (WARN_ON(!source_p || !sink_p) ||
3181             WARN_ON(!sink_p->source || !source_p->sink) ||
3182             WARN_ON(!source_p->source || !sink_p->sink))
3183                 return -EINVAL;
3184
3185         source = source_p->source->priv;
3186         sink = sink_p->sink->priv;
3187
3188         /* Be a little careful as we don't want to overflow the mask array */
3189         if (config->formats) {
3190                 fmt = ffs(config->formats) - 1;
3191         } else {
3192                 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
3193                          config->formats);
3194                 fmt = 0;
3195         }
3196
3197         /* Currently very limited parameter selection */
3198         params = kzalloc(sizeof(*params), GFP_KERNEL);
3199         if (!params) {
3200                 ret = -ENOMEM;
3201                 goto out;
3202         }
3203         snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
3204
3205         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
3206                 config->rate_min;
3207         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
3208                 config->rate_max;
3209
3210         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
3211                 = config->channels_min;
3212         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
3213                 = config->channels_max;
3214
3215         memset(&substream, 0, sizeof(substream));
3216
3217         switch (event) {
3218         case SND_SOC_DAPM_PRE_PMU:
3219                 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3220                 ret = soc_dai_hw_params(&substream, params, source);
3221                 if (ret < 0)
3222                         goto out;
3223
3224                 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3225                 ret = soc_dai_hw_params(&substream, params, sink);
3226                 if (ret < 0)
3227                         goto out;
3228                 break;
3229
3230         case SND_SOC_DAPM_POST_PMU:
3231                 ret = snd_soc_dai_digital_mute(sink, 0,
3232                                                SNDRV_PCM_STREAM_PLAYBACK);
3233                 if (ret != 0 && ret != -ENOTSUPP)
3234                         dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
3235                 ret = 0;
3236                 break;
3237
3238         case SND_SOC_DAPM_PRE_PMD:
3239                 ret = snd_soc_dai_digital_mute(sink, 1,
3240                                                SNDRV_PCM_STREAM_PLAYBACK);
3241                 if (ret != 0 && ret != -ENOTSUPP)
3242                         dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
3243                 ret = 0;
3244                 break;
3245
3246         default:
3247                 WARN(1, "Unknown event %d\n", event);
3248                 return -EINVAL;
3249         }
3250
3251 out:
3252         kfree(params);
3253         return ret;
3254 }
3255
3256 int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3257                          const struct snd_soc_pcm_stream *params,
3258                          struct snd_soc_dapm_widget *source,
3259                          struct snd_soc_dapm_widget *sink)
3260 {
3261         struct snd_soc_dapm_widget template;
3262         struct snd_soc_dapm_widget *w;
3263         size_t len;
3264         char *link_name;
3265         int ret;
3266
3267         len = strlen(source->name) + strlen(sink->name) + 2;
3268         link_name = devm_kzalloc(card->dev, len, GFP_KERNEL);
3269         if (!link_name)
3270                 return -ENOMEM;
3271         snprintf(link_name, len, "%s-%s", source->name, sink->name);
3272
3273         memset(&template, 0, sizeof(template));
3274         template.reg = SND_SOC_NOPM;
3275         template.id = snd_soc_dapm_dai_link;
3276         template.name = link_name;
3277         template.event = snd_soc_dai_link_event;
3278         template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3279                 SND_SOC_DAPM_PRE_PMD;
3280
3281         dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
3282
3283         w = snd_soc_dapm_new_control(&card->dapm, &template);
3284         if (!w) {
3285                 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
3286                         link_name);
3287                 return -ENOMEM;
3288         }
3289
3290         w->params = params;
3291
3292         ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3293         if (ret)
3294                 return ret;
3295         return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
3296 }
3297
3298 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3299                                  struct snd_soc_dai *dai)
3300 {
3301         struct snd_soc_dapm_widget template;
3302         struct snd_soc_dapm_widget *w;
3303
3304         WARN_ON(dapm->dev != dai->dev);
3305
3306         memset(&template, 0, sizeof(template));
3307         template.reg = SND_SOC_NOPM;
3308
3309         if (dai->driver->playback.stream_name) {
3310                 template.id = snd_soc_dapm_dai_in;
3311                 template.name = dai->driver->playback.stream_name;
3312                 template.sname = dai->driver->playback.stream_name;
3313
3314                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3315                         template.name);
3316
3317                 w = snd_soc_dapm_new_control(dapm, &template);
3318                 if (!w) {
3319                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3320                                 dai->driver->playback.stream_name);
3321                         return -ENOMEM;
3322                 }
3323
3324                 w->priv = dai;
3325                 dai->playback_widget = w;
3326         }
3327
3328         if (dai->driver->capture.stream_name) {
3329                 template.id = snd_soc_dapm_dai_out;
3330                 template.name = dai->driver->capture.stream_name;
3331                 template.sname = dai->driver->capture.stream_name;
3332
3333                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3334                         template.name);
3335
3336                 w = snd_soc_dapm_new_control(dapm, &template);
3337                 if (!w) {
3338                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3339                                 dai->driver->capture.stream_name);
3340                         return -ENOMEM;
3341                 }
3342
3343                 w->priv = dai;
3344                 dai->capture_widget = w;
3345         }
3346
3347         return 0;
3348 }
3349
3350 int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3351 {
3352         struct snd_soc_dapm_widget *dai_w, *w;
3353         struct snd_soc_dapm_widget *src, *sink;
3354         struct snd_soc_dai *dai;
3355
3356         /* For each DAI widget... */
3357         list_for_each_entry(dai_w, &card->widgets, list) {
3358                 switch (dai_w->id) {
3359                 case snd_soc_dapm_dai_in:
3360                 case snd_soc_dapm_dai_out:
3361                         break;
3362                 default:
3363                         continue;
3364                 }
3365
3366                 dai = dai_w->priv;
3367
3368                 /* ...find all widgets with the same stream and link them */
3369                 list_for_each_entry(w, &card->widgets, list) {
3370                         if (w->dapm != dai_w->dapm)
3371                                 continue;
3372
3373                         switch (w->id) {
3374                         case snd_soc_dapm_dai_in:
3375                         case snd_soc_dapm_dai_out:
3376                                 continue;
3377                         default:
3378                                 break;
3379                         }
3380
3381                         if (!w->sname || !strstr(w->sname, dai_w->name))
3382                                 continue;
3383
3384                         if (dai_w->id == snd_soc_dapm_dai_in) {
3385                                 src = dai_w;
3386                                 sink = w;
3387                         } else {
3388                                 src = w;
3389                                 sink = dai_w;
3390                         }
3391                         dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3392                         snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
3393                 }
3394         }
3395
3396         return 0;
3397 }
3398
3399 static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3400                                           struct snd_soc_pcm_runtime *rtd)
3401 {
3402         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3403         struct snd_soc_dapm_widget *sink, *source;
3404         int i;
3405
3406         for (i = 0; i < rtd->num_codecs; i++) {
3407                 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
3408
3409                 /* there is no point in connecting BE DAI links with dummies */
3410                 if (snd_soc_dai_is_dummy(codec_dai) ||
3411                         snd_soc_dai_is_dummy(cpu_dai))
3412                         continue;
3413
3414                 /* connect BE DAI playback if widgets are valid */
3415                 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
3416                         source = cpu_dai->playback_widget;
3417                         sink = codec_dai->playback_widget;
3418                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3419                                 cpu_dai->component->name, source->name,
3420                                 codec_dai->component->name, sink->name);
3421
3422                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3423                                 NULL, NULL);
3424                 }
3425
3426                 /* connect BE DAI capture if widgets are valid */
3427                 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
3428                         source = codec_dai->capture_widget;
3429                         sink = cpu_dai->capture_widget;
3430                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3431                                 codec_dai->component->name, source->name,
3432                                 cpu_dai->component->name, sink->name);
3433
3434                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3435                                 NULL, NULL);
3436                 }
3437         }
3438 }
3439
3440 static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3441         int event)
3442 {
3443         struct snd_soc_dapm_widget *w;
3444
3445         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3446                 w = dai->playback_widget;
3447         else
3448                 w = dai->capture_widget;
3449
3450         if (w) {
3451                 dapm_mark_dirty(w, "stream event");
3452
3453                 switch (event) {
3454                 case SND_SOC_DAPM_STREAM_START:
3455                         w->active = 1;
3456                         break;
3457                 case SND_SOC_DAPM_STREAM_STOP:
3458                         w->active = 0;
3459                         break;
3460                 case SND_SOC_DAPM_STREAM_SUSPEND:
3461                 case SND_SOC_DAPM_STREAM_RESUME:
3462                 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3463                 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3464                         break;
3465                 }
3466         }
3467 }
3468
3469 void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3470 {
3471         struct snd_soc_pcm_runtime *rtd = card->rtd;
3472         int i;
3473
3474         /* for each BE DAI link... */
3475         for (i = 0; i < card->num_rtd; i++) {
3476                 rtd = &card->rtd[i];
3477
3478                 /*
3479                  * dynamic FE links have no fixed DAI mapping.
3480                  * CODEC<->CODEC links have no direct connection.
3481                  */
3482                 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3483                         continue;
3484
3485                 dapm_connect_dai_link_widgets(card, rtd);
3486         }
3487 }
3488
3489 static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3490         int event)
3491 {
3492         int i;
3493
3494         soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
3495         for (i = 0; i < rtd->num_codecs; i++)
3496                 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
3497
3498         dapm_power_widgets(rtd->card, event);
3499 }
3500
3501 /**
3502  * snd_soc_dapm_stream_event - send a stream event to the dapm core
3503  * @rtd: PCM runtime data
3504  * @stream: stream name
3505  * @event: stream event
3506  *
3507  * Sends a stream event to the dapm core. The core then makes any
3508  * necessary widget power changes.
3509  *
3510  * Returns 0 for success else error.
3511  */
3512 void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3513                               int event)
3514 {
3515         struct snd_soc_card *card = rtd->card;
3516
3517         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3518         soc_dapm_stream_event(rtd, stream, event);
3519         mutex_unlock(&card->dapm_mutex);
3520 }
3521
3522 /**
3523  * snd_soc_dapm_enable_pin_unlocked - enable pin.
3524  * @dapm: DAPM context
3525  * @pin: pin name
3526  *
3527  * Enables input/output pin and its parents or children widgets iff there is
3528  * a valid audio route and active audio stream.
3529  *
3530  * Requires external locking.
3531  *
3532  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3533  * do any widget power switching.
3534  */
3535 int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3536                                    const char *pin)
3537 {
3538         return snd_soc_dapm_set_pin(dapm, pin, 1);
3539 }
3540 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
3541
3542 /**
3543  * snd_soc_dapm_enable_pin - enable pin.
3544  * @dapm: DAPM context
3545  * @pin: pin name
3546  *
3547  * Enables input/output pin and its parents or children widgets iff there is
3548  * a valid audio route and active audio stream.
3549  *
3550  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3551  * do any widget power switching.
3552  */
3553 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
3554 {
3555         int ret;
3556
3557         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3558
3559         ret = snd_soc_dapm_set_pin(dapm, pin, 1);
3560
3561         mutex_unlock(&dapm->card->dapm_mutex);
3562
3563         return ret;
3564 }
3565 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
3566
3567 /**
3568  * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
3569  * @dapm: DAPM context
3570  * @pin: pin name
3571  *
3572  * Enables input/output pin regardless of any other state.  This is
3573  * intended for use with microphone bias supplies used in microphone
3574  * jack detection.
3575  *
3576  * Requires external locking.
3577  *
3578  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3579  * do any widget power switching.
3580  */
3581 int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3582                                          const char *pin)
3583 {
3584         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
3585
3586         if (!w) {
3587                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
3588                 return -EINVAL;
3589         }
3590
3591         dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
3592         w->connected = 1;
3593         w->force = 1;
3594         dapm_mark_dirty(w, "force enable");
3595
3596         return 0;
3597 }
3598 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
3599
3600 /**
3601  * snd_soc_dapm_force_enable_pin - force a pin to be enabled
3602  * @dapm: DAPM context
3603  * @pin: pin name
3604  *
3605  * Enables input/output pin regardless of any other state.  This is
3606  * intended for use with microphone bias supplies used in microphone
3607  * jack detection.
3608  *
3609  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3610  * do any widget power switching.
3611  */
3612 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
3613                                   const char *pin)
3614 {
3615         int ret;
3616
3617         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3618
3619         ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
3620
3621         mutex_unlock(&dapm->card->dapm_mutex);
3622
3623         return ret;
3624 }
3625 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
3626
3627 /**
3628  * snd_soc_dapm_disable_pin_unlocked - disable pin.
3629  * @dapm: DAPM context
3630  * @pin: pin name
3631  *
3632  * Disables input/output pin and its parents or children widgets.
3633  *
3634  * Requires external locking.
3635  *
3636  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3637  * do any widget power switching.
3638  */
3639 int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3640                                     const char *pin)
3641 {
3642         return snd_soc_dapm_set_pin(dapm, pin, 0);
3643 }
3644 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
3645
3646 /**
3647  * snd_soc_dapm_disable_pin - disable pin.
3648  * @dapm: DAPM context
3649  * @pin: pin name
3650  *
3651  * Disables input/output pin and its parents or children widgets.
3652  *
3653  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3654  * do any widget power switching.
3655  */
3656 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
3657                              const char *pin)
3658 {
3659         int ret;
3660
3661         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3662
3663         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
3664
3665         mutex_unlock(&dapm->card->dapm_mutex);
3666
3667         return ret;
3668 }
3669 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
3670
3671 /**
3672  * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
3673  * @dapm: DAPM context
3674  * @pin: pin name
3675  *
3676  * Marks the specified pin as being not connected, disabling it along
3677  * any parent or child widgets.  At present this is identical to
3678  * snd_soc_dapm_disable_pin() but in future it will be extended to do
3679  * additional things such as disabling controls which only affect
3680  * paths through the pin.
3681  *
3682  * Requires external locking.
3683  *
3684  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3685  * do any widget power switching.
3686  */
3687 int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
3688                                const char *pin)
3689 {
3690         return snd_soc_dapm_set_pin(dapm, pin, 0);
3691 }
3692 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
3693
3694 /**
3695  * snd_soc_dapm_nc_pin - permanently disable pin.
3696  * @dapm: DAPM context
3697  * @pin: pin name
3698  *
3699  * Marks the specified pin as being not connected, disabling it along
3700  * any parent or child widgets.  At present this is identical to
3701  * snd_soc_dapm_disable_pin() but in future it will be extended to do
3702  * additional things such as disabling controls which only affect
3703  * paths through the pin.
3704  *
3705  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3706  * do any widget power switching.
3707  */
3708 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
3709 {
3710         int ret;
3711
3712         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3713
3714         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
3715
3716         mutex_unlock(&dapm->card->dapm_mutex);
3717
3718         return ret;
3719 }
3720 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
3721
3722 /**
3723  * snd_soc_dapm_get_pin_status - get audio pin status
3724  * @dapm: DAPM context
3725  * @pin: audio signal pin endpoint (or start point)
3726  *
3727  * Get audio pin status - connected or disconnected.
3728  *
3729  * Returns 1 for connected otherwise 0.
3730  */
3731 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
3732                                 const char *pin)
3733 {
3734         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
3735
3736         if (w)
3737                 return w->connected;
3738
3739         return 0;
3740 }
3741 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
3742
3743 /**
3744  * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
3745  * @dapm: DAPM context
3746  * @pin: audio signal pin endpoint (or start point)
3747  *
3748  * Mark the given endpoint or pin as ignoring suspend.  When the
3749  * system is disabled a path between two endpoints flagged as ignoring
3750  * suspend will not be disabled.  The path must already be enabled via
3751  * normal means at suspend time, it will not be turned on if it was not
3752  * already enabled.
3753  */
3754 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
3755                                 const char *pin)
3756 {
3757         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
3758
3759         if (!w) {
3760                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
3761                 return -EINVAL;
3762         }
3763
3764         w->ignore_suspend = 1;
3765
3766         return 0;
3767 }
3768 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
3769
3770 static bool snd_soc_dapm_widget_in_card_paths(struct snd_soc_card *card,
3771                                               struct snd_soc_dapm_widget *w)
3772 {
3773         struct snd_soc_dapm_path *p;
3774
3775         list_for_each_entry(p, &card->paths, list) {
3776                 if ((p->source == w) || (p->sink == w)) {
3777                         dev_dbg(card->dev,
3778                             "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n",
3779                             p->source->name, p->source->id, p->source->dapm,
3780                             p->sink->name, p->sink->id, p->sink->dapm);
3781
3782                         /* Connected to something other than the codec */
3783                         if (p->source->dapm != p->sink->dapm)
3784                                 return true;
3785                         /*
3786                          * Loopback connection from codec external pin to
3787                          * codec external pin
3788                          */
3789                         if (p->sink->id == snd_soc_dapm_input) {
3790                                 switch (p->source->id) {
3791                                 case snd_soc_dapm_output:
3792                                 case snd_soc_dapm_micbias:
3793                                         return true;
3794                                 default:
3795                                         break;
3796                                 }
3797                         }
3798                 }
3799         }
3800
3801         return false;
3802 }
3803
3804 /**
3805  * snd_soc_dapm_auto_nc_pins - call snd_soc_dapm_nc_pin for unused pins
3806  * @card: The card whose pins should be processed
3807  *
3808  * Automatically call snd_soc_dapm_nc_pin() for any external pins in the card
3809  * which are unused. Pins are used if they are connected externally to a
3810  * component, whether that be to some other device, or a loop-back connection to
3811  * the component itself.
3812  */
3813 void snd_soc_dapm_auto_nc_pins(struct snd_soc_card *card)
3814 {
3815         struct snd_soc_dapm_widget *w;
3816
3817         dev_dbg(card->dev, "ASoC: Auto NC: DAPMs: card:%p\n", &card->dapm);
3818
3819         list_for_each_entry(w, &card->widgets, list) {
3820                 switch (w->id) {
3821                 case snd_soc_dapm_input:
3822                 case snd_soc_dapm_output:
3823                 case snd_soc_dapm_micbias:
3824                         dev_dbg(card->dev, "ASoC: Auto NC: Checking widget %s\n",
3825                                 w->name);
3826                         if (!snd_soc_dapm_widget_in_card_paths(card, w)) {
3827                                 dev_dbg(card->dev,
3828                                         "... Not in map; disabling\n");
3829                                 snd_soc_dapm_nc_pin(w->dapm, w->name);
3830                         }
3831                         break;
3832                 default:
3833                         break;
3834                 }
3835         }
3836 }
3837
3838 /**
3839  * snd_soc_dapm_free - free dapm resources
3840  * @dapm: DAPM context
3841  *
3842  * Free all dapm widgets and resources.
3843  */
3844 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
3845 {
3846         snd_soc_dapm_sys_remove(dapm->dev);
3847         dapm_debugfs_cleanup(dapm);
3848         dapm_free_widgets(dapm);
3849         list_del(&dapm->list);
3850 }
3851 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
3852
3853 static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
3854 {
3855         struct snd_soc_card *card = dapm->card;
3856         struct snd_soc_dapm_widget *w;
3857         LIST_HEAD(down_list);
3858         int powerdown = 0;
3859
3860         mutex_lock(&card->dapm_mutex);
3861
3862         list_for_each_entry(w, &dapm->card->widgets, list) {
3863                 if (w->dapm != dapm)
3864                         continue;
3865                 if (w->power) {
3866                         dapm_seq_insert(w, &down_list, false);
3867                         w->power = 0;
3868                         powerdown = 1;
3869                 }
3870         }
3871
3872         /* If there were no widgets to power down we're already in
3873          * standby.
3874          */
3875         if (powerdown) {
3876                 if (dapm->bias_level == SND_SOC_BIAS_ON)
3877                         snd_soc_dapm_set_bias_level(dapm,
3878                                                     SND_SOC_BIAS_PREPARE);
3879                 dapm_seq_run(card, &down_list, 0, false);
3880                 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
3881                         snd_soc_dapm_set_bias_level(dapm,
3882                                                     SND_SOC_BIAS_STANDBY);
3883         }
3884
3885         mutex_unlock(&card->dapm_mutex);
3886 }
3887
3888 /*
3889  * snd_soc_dapm_shutdown - callback for system shutdown
3890  */
3891 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
3892 {
3893         struct snd_soc_dapm_context *dapm;
3894
3895         list_for_each_entry(dapm, &card->dapm_list, list) {
3896                 if (dapm != &card->dapm) {
3897                         soc_dapm_shutdown_dapm(dapm);
3898                         if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
3899                                 snd_soc_dapm_set_bias_level(dapm,
3900                                                             SND_SOC_BIAS_OFF);
3901                 }
3902         }
3903
3904         soc_dapm_shutdown_dapm(&card->dapm);
3905         if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
3906                 snd_soc_dapm_set_bias_level(&card->dapm,
3907                                             SND_SOC_BIAS_OFF);
3908 }
3909
3910 /* Module information */
3911 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
3912 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
3913 MODULE_LICENSE("GPL");