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