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 <[email protected]>
   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/meadphone 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 powerdown of audio susbsystem to reduce pops between a quick
  22  *      device reopen.
  23  *
  24  *  Todo:
  25  *    o DAPM power change sequencing - allow for configurable per
  26  *      codec sequences.
  27  *    o Support for analogue bias optimisation.
  28  *    o Support for reduced codec oversampling rates.
  29  *    o Support for reduced codec bias currents.
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/moduleparam.h>
  34 #include <linux/init.h>
  35 #include <linux/async.h>
  36 #include <linux/delay.h>
  37 #include <linux/pm.h>
  38 #include <linux/bitops.h>
  39 #include <linux/platform_device.h>
  40 #include <linux/jiffies.h>
  41 #include <linux/debugfs.h>
  42 #include <linux/slab.h>
  43 #include <sound/core.h>
  44 #include <sound/pcm.h>
  45 #include <sound/pcm_params.h>
  46 #include <sound/soc.h>
  47 #include <sound/initval.h>
  48
  49 #include <trace/events/asoc.h>
  50
  51 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
  52
  53 /* dapm power sequences - make this per codec in the future */
  54 static int dapm_up_seq[] = {
  55         [snd_soc_dapm_pre] = 0,
  56         [snd_soc_dapm_supply] = 1,
  57         [snd_soc_dapm_micbias] = 2,
  58         [snd_soc_dapm_aif_in] = 3,
  59         [snd_soc_dapm_aif_out] = 3,
  60         [snd_soc_dapm_mic] = 4,
  61         [snd_soc_dapm_mux] = 5,
  62         [snd_soc_dapm_virt_mux] = 5,
  63         [snd_soc_dapm_value_mux] = 5,
  64         [snd_soc_dapm_dac] = 6,
  65         [snd_soc_dapm_mixer] = 7,
  66         [snd_soc_dapm_mixer_named_ctl] = 7,
  67         [snd_soc_dapm_pga] = 8,
  68         [snd_soc_dapm_adc] = 9,
  69         [snd_soc_dapm_out_drv] = 10,
  70         [snd_soc_dapm_hp] = 10,
  71         [snd_soc_dapm_spk] = 10,
  72         [snd_soc_dapm_post] = 11,
  73 };
  74
  75 static int dapm_down_seq[] = {
  76         [snd_soc_dapm_pre] = 0,
  77         [snd_soc_dapm_adc] = 1,
  78         [snd_soc_dapm_hp] = 2,
  79         [snd_soc_dapm_spk] = 2,
  80         [snd_soc_dapm_out_drv] = 2,
  81         [snd_soc_dapm_pga] = 4,
  82         [snd_soc_dapm_mixer_named_ctl] = 5,
  83         [snd_soc_dapm_mixer] = 5,
  84         [snd_soc_dapm_dac] = 6,
  85         [snd_soc_dapm_mic] = 7,
  86         [snd_soc_dapm_micbias] = 8,
  87         [snd_soc_dapm_mux] = 9,
  88         [snd_soc_dapm_virt_mux] = 9,
  89         [snd_soc_dapm_value_mux] = 9,
  90         [snd_soc_dapm_aif_in] = 10,
  91         [snd_soc_dapm_aif_out] = 10,
  92         [snd_soc_dapm_supply] = 11,
  93         [snd_soc_dapm_post] = 12,
  94 };
  95
  96 static void pop_wait(u32 pop_time)
  97 {
  98         if (pop_time)
  99                 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
 100 }
 101
 102 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
 103 {
 104         va_list args;
 105         char *buf;
 106
 107         if (!pop_time)
 108                 return;
 109
 110         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 111         if (buf == NULL)
 112                 return;
 113
 114         va_start(args, fmt);
 115         vsnprintf(buf, PAGE_SIZE, fmt, args);
 116         dev_info(dev, "%s", buf);
 117         va_end(args);
 118
 119         kfree(buf);
 120 }
 121
 122 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
 123 {
 124         return !list_empty(&w->dirty);
 125 }
 126
 127 void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
 128 {
 129         if (!dapm_dirty_widget(w)) {
 130                 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
 131                          w->name, reason);
 132                 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
 133         }
 134 }
 135 EXPORT_SYMBOL_GPL(dapm_mark_dirty);
 136
 137 /* create a new dapm widget */
 138 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
 139         const struct snd_soc_dapm_widget *_widget)
 140 {
 141         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
 142 }
 143
 144 /* get snd_card from DAPM context */
 145 static inline struct snd_card *dapm_get_snd_card(
 146         struct snd_soc_dapm_context *dapm)
 147 {
 148         if (dapm->codec)
 149                 return dapm->codec->card->snd_card;
 150         else if (dapm->platform)
 151                 return dapm->platform->card->snd_card;
 152         else
 153                 BUG();
 154
 155         /* unreachable */
 156         return NULL;
 157 }
 158
 159 /* get soc_card from DAPM context */
 160 static inline struct snd_soc_card *dapm_get_soc_card(
 161                 struct snd_soc_dapm_context *dapm)
 162 {
 163         if (dapm->codec)
 164                 return dapm->codec->card;
 165         else if (dapm->platform)
 166                 return dapm->platform->card;
 167         else
 168                 BUG();
 169
 170         /* unreachable */
 171         return NULL;
 172 }
 173
 174 static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg)
 175 {
 176         if (w->codec)
 177                 return snd_soc_read(w->codec, reg);
 178         else if (w->platform)
 179                 return snd_soc_platform_read(w->platform, reg);
 180
 181         dev_err(w->dapm->dev, "no valid widget read method\n");
 182         return -1;
 183 }
 184
 185 static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, int val)
 186 {
 187         if (w->codec)
 188                 return snd_soc_write(w->codec, reg, val);
 189         else if (w->platform)
 190                 return snd_soc_platform_write(w->platform, reg, val);
 191
 192         dev_err(w->dapm->dev, "no valid widget write method\n");
 193         return -1;
 194 }
 195
 196 static int soc_widget_update_bits(struct snd_soc_dapm_widget *w,
 197         unsigned short reg, unsigned int mask, unsigned int value)
 198 {
 199         int change;
 200         unsigned int old, new;
 201         int ret;
 202
 203         ret = soc_widget_read(w, reg);
 204         if (ret < 0)
 205                 return ret;
 206
 207         old = ret;
 208         new = (old & ~mask) | (value & mask);
 209         change = old != new;
 210         if (change) {
 211                 ret = soc_widget_write(w, reg, new);
 212                 if (ret < 0)
 213                         return ret;
 214         }
 215
 216         return change;
 217 }
 218
 219 /**
 220  * snd_soc_dapm_set_bias_level - set the bias level for the system
 221  * @dapm: DAPM context
 222  * @level: level to configure
 223  *
 224  * Configure the bias (power) levels for the SoC audio device.
 225  *
 226  * Returns 0 for success else error.
 227  */
 228 static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
 229                                        enum snd_soc_bias_level level)
 230 {
 231         struct snd_soc_card *card = dapm->card;
 232         int ret = 0;
 233
 234         trace_snd_soc_bias_level_start(card, level);
 235
 236         if (card && card->set_bias_level)
 237                 ret = card->set_bias_level(card, dapm, level);
 238         if (ret != 0)
 239                 goto out;
 240
 241         if (dapm->codec) {
 242                 if (dapm->codec->driver->set_bias_level)
 243                         ret = dapm->codec->driver->set_bias_level(dapm->codec,
 244                                                                   level);
 245                 else
 246                         dapm->bias_level = level;
 247         }
 248         if (ret != 0)
 249                 goto out;
 250
 251         if (card && card->set_bias_level_post)
 252                 ret = card->set_bias_level_post(card, dapm, level);
 253 out:
 254         trace_snd_soc_bias_level_done(card, level);
 255
 256         return ret;
 257 }
 258
 259 /* set up initial codec paths */
 260 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
 261         struct snd_soc_dapm_path *p, int i)
 262 {
 263         switch (w->id) {
 264         case snd_soc_dapm_switch:
 265         case snd_soc_dapm_mixer:
 266         case snd_soc_dapm_mixer_named_ctl: {
 267                 int val;
 268                 struct soc_mixer_control *mc = (struct soc_mixer_control *)
 269                         w->kcontrol_news[i].private_value;
 270                 unsigned int reg = mc->reg;
 271                 unsigned int shift = mc->shift;
 272                 int max = mc->max;
 273                 unsigned int mask = (1 << fls(max)) - 1;
 274                 unsigned int invert = mc->invert;
 275
 276                 val = soc_widget_read(w, reg);
 277                 val = (val >> shift) & mask;
 278
 279                 if ((invert && !val) || (!invert && val))
 280                         p->connect = 1;
 281                 else
 282                         p->connect = 0;
 283         }
 284         break;
 285         case snd_soc_dapm_mux: {
 286                 struct soc_enum *e = (struct soc_enum *)
 287                         w->kcontrol_news[i].private_value;
 288                 int val, item, bitmask;
 289
 290                 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
 291                         ;
 292                 val = soc_widget_read(w, e->reg);
 293                 item = (val >> e->shift_l) & (bitmask - 1);
 294
 295                 p->connect = 0;
 296                 for (i = 0; i < e->max; i++) {
 297                         if (!(strcmp(p->name, e->texts[i])) && item == i)
 298                                 p->connect = 1;
 299                 }
 300         }
 301         break;
 302         case snd_soc_dapm_virt_mux: {
 303                 struct soc_enum *e = (struct soc_enum *)
 304                         w->kcontrol_news[i].private_value;
 305
 306                 p->connect = 0;
 307                 /* since a virtual mux has no backing registers to
 308                  * decide which path to connect, it will try to match
 309                  * with the first enumeration.  This is to ensure
 310                  * that the default mux choice (the first) will be
 311                  * correctly powered up during initialization.
 312                  */
 313                 if (!strcmp(p->name, e->texts[0]))
 314                         p->connect = 1;
 315         }
 316         break;
 317         case snd_soc_dapm_value_mux: {
 318                 struct soc_enum *e = (struct soc_enum *)
 319                         w->kcontrol_news[i].private_value;
 320                 int val, item;
 321
 322                 val = soc_widget_read(w, e->reg);
 323                 val = (val >> e->shift_l) & e->mask;
 324                 for (item = 0; item < e->max; item++) {
 325                         if (val == e->values[item])
 326                                 break;
 327                 }
 328
 329                 p->connect = 0;
 330                 for (i = 0; i < e->max; i++) {
 331                         if (!(strcmp(p->name, e->texts[i])) && item == i)
 332                                 p->connect = 1;
 333                 }
 334         }
 335         break;
 336         /* does not affect routing - always connected */
 337         case snd_soc_dapm_pga:
 338         case snd_soc_dapm_out_drv:
 339         case snd_soc_dapm_output:
 340         case snd_soc_dapm_adc:
 341         case snd_soc_dapm_input:
 342         case snd_soc_dapm_dac:
 343         case snd_soc_dapm_micbias:
 344         case snd_soc_dapm_vmid:
 345         case snd_soc_dapm_supply:
 346         case snd_soc_dapm_aif_in:
 347         case snd_soc_dapm_aif_out:
 348         case snd_soc_dapm_hp:
 349         case snd_soc_dapm_mic:
 350         case snd_soc_dapm_spk:
 351         case snd_soc_dapm_line:
 352                 p->connect = 1;
 353         break;
 354         /* does affect routing - dynamically connected */
 355         case snd_soc_dapm_pre:
 356         case snd_soc_dapm_post:
 357                 p->connect = 0;
 358         break;
 359         }
 360 }
 361
 362 /* connect mux widget to its interconnecting audio paths */
 363 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
 364         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 365         struct snd_soc_dapm_path *path, const char *control_name,
 366         const struct snd_kcontrol_new *kcontrol)
 367 {
 368         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 369         int i;
 370
 371         for (i = 0; i < e->max; i++) {
 372                 if (!(strcmp(control_name, e->texts[i]))) {
 373                         list_add(&path->list, &dapm->card->paths);
 374                         list_add(&path->list_sink, &dest->sources);
 375                         list_add(&path->list_source, &src->sinks);
 376                         path->name = (char*)e->texts[i];
 377                         dapm_set_path_status(dest, path, 0);
 378                         return 0;
 379                 }
 380         }
 381
 382         return -ENODEV;
 383 }
 384
 385 /* connect mixer widget to its interconnecting audio paths */
 386 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
 387         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 388         struct snd_soc_dapm_path *path, const char *control_name)
 389 {
 390         int i;
 391
 392         /* search for mixer kcontrol */
 393         for (i = 0; i < dest->num_kcontrols; i++) {
 394                 if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
 395                         list_add(&path->list, &dapm->card->paths);
 396                         list_add(&path->list_sink, &dest->sources);
 397                         list_add(&path->list_source, &src->sinks);
 398                         path->name = dest->kcontrol_news[i].name;
 399                         dapm_set_path_status(dest, path, i);
 400                         return 0;
 401                 }
 402         }
 403         return -ENODEV;
 404 }
 405
 406 static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
 407         struct snd_soc_dapm_widget *kcontrolw,
 408         const struct snd_kcontrol_new *kcontrol_new,
 409         struct snd_kcontrol **kcontrol)
 410 {
 411         struct snd_soc_dapm_widget *w;
 412         int i;
 413
 414         *kcontrol = NULL;
 415
 416         list_for_each_entry(w, &dapm->card->widgets, list) {
 417                 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
 418                         continue;
 419                 for (i = 0; i < w->num_kcontrols; i++) {
 420                         if (&w->kcontrol_news[i] == kcontrol_new) {
 421                                 if (w->kcontrols)
 422                                         *kcontrol = w->kcontrols[i];
 423                                 return 1;
 424                         }
 425                 }
 426         }
 427
 428         return 0;
 429 }
 430
 431 /* create new dapm mixer control */
 432 static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
 433 {
 434         struct snd_soc_dapm_context *dapm = w->dapm;
 435         int i, ret = 0;
 436         size_t name_len, prefix_len;
 437         struct snd_soc_dapm_path *path;
 438         struct snd_card *card = dapm->card->snd_card;
 439         const char *prefix;
 440         struct snd_soc_dapm_widget_list *wlist;
 441         size_t wlistsize;
 442
 443         if (dapm->codec)
 444                 prefix = dapm->codec->name_prefix;
 445         else
 446                 prefix = NULL;
 447
 448         if (prefix)
 449                 prefix_len = strlen(prefix) + 1;
 450         else
 451                 prefix_len = 0;
 452
 453         /* add kcontrol */
 454         for (i = 0; i < w->num_kcontrols; i++) {
 455
 456                 /* match name */
 457                 list_for_each_entry(path, &w->sources, list_sink) {
 458
 459                         /* mixer/mux paths name must match control name */
 460                         if (path->name != (char *)w->kcontrol_news[i].name)
 461                                 continue;
 462
 463                         if (w->kcontrols[i]) {
 464                                 path->kcontrol = w->kcontrols[i];
 465                                 continue;
 466                         }
 467
 468                         wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
 469                                     sizeof(struct snd_soc_dapm_widget *),
 470                         wlist = kzalloc(wlistsize, GFP_KERNEL);
 471                         if (wlist == NULL) {
 472                                 dev_err(dapm->dev,
 473                                         "asoc: can't allocate widget list for %s\n",
 474                                         w->name);
 475                                 return -ENOMEM;
 476                         }
 477                         wlist->num_widgets = 1;
 478                         wlist->widgets[0] = w;
 479
 480                         /* add dapm control with long name.
 481                          * for dapm_mixer this is the concatenation of the
 482                          * mixer and kcontrol name.
 483                          * for dapm_mixer_named_ctl this is simply the
 484                          * kcontrol name.
 485                          */
 486                         name_len = strlen(w->kcontrol_news[i].name) + 1;
 487                         if (w->id != snd_soc_dapm_mixer_named_ctl)
 488                                 name_len += 1 + strlen(w->name);
 489
 490                         path->long_name = kmalloc(name_len, GFP_KERNEL);
 491
 492                         if (path->long_name == NULL) {
 493                                 kfree(wlist);
 494                                 return -ENOMEM;
 495                         }
 496
 497                         switch (w->id) {
 498                         default:
 499                                 /* The control will get a prefix from
 500                                  * the control creation process but
 501                                  * we're also using the same prefix
 502                                  * for widgets so cut the prefix off
 503                                  * the front of the widget name.
 504                                  */
 505                                 snprintf(path->long_name, name_len, "%s %s",
 506                                          w->name + prefix_len,
 507                                          w->kcontrol_news[i].name);
 508                                 break;
 509                         case snd_soc_dapm_mixer_named_ctl:
 510                                 snprintf(path->long_name, name_len, "%s",
 511                                          w->kcontrol_news[i].name);
 512                                 break;
 513                         }
 514
 515                         path->long_name[name_len - 1] = '\0';
 516
 517                         path->kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
 518                                                       wlist, path->long_name,
 519                                                       prefix);
 520                         ret = snd_ctl_add(card, path->kcontrol);
 521                         if (ret < 0) {
 522                                 dev_err(dapm->dev,
 523                                         "asoc: failed to add dapm kcontrol %s: %d\n",
 524                                         path->long_name, ret);
 525                                 kfree(wlist);
 526                                 kfree(path->long_name);
 527                                 path->long_name = NULL;
 528                                 return ret;
 529                         }
 530                         w->kcontrols[i] = path->kcontrol;
 531                 }
 532         }
 533         return ret;
 534 }
 535
 536 /* create new dapm mux control */
 537 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
 538 {
 539         struct snd_soc_dapm_context *dapm = w->dapm;
 540         struct snd_soc_dapm_path *path = NULL;
 541         struct snd_kcontrol *kcontrol;
 542         struct snd_card *card = dapm->card->snd_card;
 543         const char *prefix;
 544         size_t prefix_len;
 545         int ret;
 546         struct snd_soc_dapm_widget_list *wlist;
 547         int shared, wlistentries;
 548         size_t wlistsize;
 549         char *name;
 550
 551         if (w->num_kcontrols != 1) {
 552                 dev_err(dapm->dev,
 553                         "asoc: mux %s has incorrect number of controls\n",
 554                         w->name);
 555                 return -EINVAL;
 556         }
 557
 558         shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[0],
 559                                          &kcontrol);
 560         if (kcontrol) {
 561                 wlist = kcontrol->private_data;
 562                 wlistentries = wlist->num_widgets + 1;
 563         } else {
 564                 wlist = NULL;
 565                 wlistentries = 1;
 566         }
 567         wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
 568                 wlistentries * sizeof(struct snd_soc_dapm_widget *),
 569         wlist = krealloc(wlist, wlistsize, GFP_KERNEL);
 570         if (wlist == NULL) {
 571                 dev_err(dapm->dev,
 572                         "asoc: can't allocate widget list for %s\n", w->name);
 573                 return -ENOMEM;
 574         }
 575         wlist->num_widgets = wlistentries;
 576         wlist->widgets[wlistentries - 1] = w;
 577
 578         if (!kcontrol) {
 579                 if (dapm->codec)
 580                         prefix = dapm->codec->name_prefix;
 581                 else
 582                         prefix = NULL;
 583
 584                 if (shared) {
 585                         name = w->kcontrol_news[0].name;
 586                         prefix_len = 0;
 587                 } else {
 588                         name = w->name;
 589                         if (prefix)
 590                                 prefix_len = strlen(prefix) + 1;
 591                         else
 592                                 prefix_len = 0;
 593                 }
 594
 595                 /*
 596                  * The control will get a prefix from the control creation
 597                  * process but we're also using the same prefix for widgets so
 598                  * cut the prefix off the front of the widget name.
 599                  */
 600                 kcontrol = snd_soc_cnew(&w->kcontrol_news[0], wlist,
 601                                         name + prefix_len, prefix);
 602                 ret = snd_ctl_add(card, kcontrol);
 603                 if (ret < 0) {
 604                         dev_err(dapm->dev, "failed to add kcontrol %s: %d\n",
 605                                 w->name, ret);
 606                         kfree(wlist);
 607                         return ret;
 608                 }
 609         }
 610
 611         kcontrol->private_data = wlist;
 612
 613         w->kcontrols[0] = kcontrol;
 614
 615         list_for_each_entry(path, &w->sources, list_sink)
 616                 path->kcontrol = kcontrol;
 617
 618         return 0;
 619 }
 620
 621 /* create new dapm volume control */
 622 static int dapm_new_pga(struct snd_soc_dapm_widget *w)
 623 {
 624         if (w->num_kcontrols)
 625                 dev_err(w->dapm->dev,
 626                         "asoc: PGA controls not supported: '%s'\n", w->name);
 627
 628         return 0;
 629 }
 630
 631 /* reset 'walked' bit for each dapm path */
 632 static inline void dapm_clear_walk(struct snd_soc_dapm_context *dapm)
 633 {
 634         struct snd_soc_dapm_path *p;
 635
 636         list_for_each_entry(p, &dapm->card->paths, list)
 637                 p->walked = 0;
 638 }
 639
 640 /* We implement power down on suspend by checking the power state of
 641  * the ALSA card - when we are suspending the ALSA state for the card
 642  * is set to D3.
 643  */
 644 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
 645 {
 646         int level = snd_power_get_state(widget->dapm->card->snd_card);
 647
 648         switch (level) {
 649         case SNDRV_CTL_POWER_D3hot:
 650         case SNDRV_CTL_POWER_D3cold:
 651                 if (widget->ignore_suspend)
 652                         dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
 653                                 widget->name);
 654                 return widget->ignore_suspend;
 655         default:
 656                 return 1;
 657         }
 658 }
 659
 660 /*
 661  * Recursively check for a completed path to an active or physically connected
 662  * output widget. Returns number of complete paths.
 663  */
 664 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
 665 {
 666         struct snd_soc_dapm_path *path;
 667         int con = 0;
 668
 669         if (widget->outputs >= 0)
 670                 return widget->outputs;
 671
 672         DAPM_UPDATE_STAT(widget, path_checks);
 673
 674         if (widget->id == snd_soc_dapm_supply)
 675                 return 0;
 676
 677         switch (widget->id) {
 678         case snd_soc_dapm_adc:
 679         case snd_soc_dapm_aif_out:
 680                 if (widget->active) {
 681                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 682                         return widget->outputs;
 683                 }
 684         default:
 685                 break;
 686         }
 687
 688         if (widget->connected) {
 689                 /* connected pin ? */
 690                 if (widget->id == snd_soc_dapm_output && !widget->ext) {
 691                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 692                         return widget->outputs;
 693                 }
 694
 695                 /* connected jack or spk ? */
 696                 if (widget->id == snd_soc_dapm_hp ||
 697                     widget->id == snd_soc_dapm_spk ||
 698                     (widget->id == snd_soc_dapm_line &&
 699                      !list_empty(&widget->sources))) {
 700                         widget->outputs = snd_soc_dapm_suspend_check(widget);
 701                         return widget->outputs;
 702                 }
 703         }
 704
 705         list_for_each_entry(path, &widget->sinks, list_source) {
 706                 DAPM_UPDATE_STAT(widget, neighbour_checks);
 707
 708                 if (path->weak)
 709                         continue;
 710
 711                 if (path->walked)
 712                         continue;
 713
 714                 if (path->sink && path->connect) {
 715                         path->walked = 1;
 716                         con += is_connected_output_ep(path->sink);
 717                 }
 718         }
 719
 720         widget->outputs = con;
 721
 722         return con;
 723 }
 724
 725 /*
 726  * Recursively check for a completed path to an active or physically connected
 727  * input widget. Returns number of complete paths.
 728  */
 729 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
 730 {
 731         struct snd_soc_dapm_path *path;
 732         int con = 0;
 733
 734         if (widget->inputs >= 0)
 735                 return widget->inputs;
 736
 737         DAPM_UPDATE_STAT(widget, path_checks);
 738
 739         if (widget->id == snd_soc_dapm_supply)
 740                 return 0;
 741
 742         /* active stream ? */
 743         switch (widget->id) {
 744         case snd_soc_dapm_dac:
 745         case snd_soc_dapm_aif_in:
 746                 if (widget->active) {
 747                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 748                         return widget->inputs;
 749                 }
 750         default:
 751                 break;
 752         }
 753
 754         if (widget->connected) {
 755                 /* connected pin ? */
 756                 if (widget->id == snd_soc_dapm_input && !widget->ext) {
 757                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 758                         return widget->inputs;
 759                 }
 760
 761                 /* connected VMID/Bias for lower pops */
 762                 if (widget->id == snd_soc_dapm_vmid) {
 763                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 764                         return widget->inputs;
 765                 }
 766
 767                 /* connected jack ? */
 768                 if (widget->id == snd_soc_dapm_mic ||
 769                     (widget->id == snd_soc_dapm_line &&
 770                      !list_empty(&widget->sinks))) {
 771                         widget->inputs = snd_soc_dapm_suspend_check(widget);
 772                         return widget->inputs;
 773                 }
 774
 775         }
 776
 777         list_for_each_entry(path, &widget->sources, list_sink) {
 778                 DAPM_UPDATE_STAT(widget, neighbour_checks);
 779
 780                 if (path->weak)
 781                         continue;
 782
 783                 if (path->walked)
 784                         continue;
 785
 786                 if (path->source && path->connect) {
 787                         path->walked = 1;
 788                         con += is_connected_input_ep(path->source);
 789                 }
 790         }
 791
 792         widget->inputs = con;
 793
 794         return con;
 795 }
 796
 797 /*
 798  * Handler for generic register modifier widget.
 799  */
 800 int dapm_reg_event(struct snd_soc_dapm_widget *w,
 801                    struct snd_kcontrol *kcontrol, int event)
 802 {
 803         unsigned int val;
 804
 805         if (SND_SOC_DAPM_EVENT_ON(event))
 806                 val = w->on_val;
 807         else
 808                 val = w->off_val;
 809
 810         soc_widget_update_bits(w, -(w->reg + 1),
 811                             w->mask << w->shift, val << w->shift);
 812
 813         return 0;
 814 }
 815 EXPORT_SYMBOL_GPL(dapm_reg_event);
 816
 817 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
 818 {
 819         if (w->power_checked)
 820                 return w->new_power;
 821
 822         if (w->force)
 823                 w->new_power = 1;
 824         else
 825                 w->new_power = w->power_check(w);
 826
 827         w->power_checked = true;
 828
 829         return w->new_power;
 830 }
 831
 832 /* Generic check to see if a widget should be powered.
 833  */
 834 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
 835 {
 836         int in, out;
 837
 838         DAPM_UPDATE_STAT(w, power_checks);
 839
 840         in = is_connected_input_ep(w);
 841         dapm_clear_walk(w->dapm);
 842         out = is_connected_output_ep(w);
 843         dapm_clear_walk(w->dapm);
 844         return out != 0 && in != 0;
 845 }
 846
 847 /* Check to see if an ADC has power */
 848 static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
 849 {
 850         int in;
 851
 852         DAPM_UPDATE_STAT(w, power_checks);
 853
 854         if (w->active) {
 855                 in = is_connected_input_ep(w);
 856                 dapm_clear_walk(w->dapm);
 857                 return in != 0;
 858         } else {
 859                 return dapm_generic_check_power(w);
 860         }
 861 }
 862
 863 /* Check to see if a DAC has power */
 864 static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
 865 {
 866         int out;
 867
 868         DAPM_UPDATE_STAT(w, power_checks);
 869
 870         if (w->active) {
 871                 out = is_connected_output_ep(w);
 872                 dapm_clear_walk(w->dapm);
 873                 return out != 0;
 874         } else {
 875                 return dapm_generic_check_power(w);
 876         }
 877 }
 878
 879 /* Check to see if a power supply is needed */
 880 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
 881 {
 882         struct snd_soc_dapm_path *path;
 883
 884         DAPM_UPDATE_STAT(w, power_checks);
 885
 886         /* Check if one of our outputs is connected */
 887         list_for_each_entry(path, &w->sinks, list_source) {
 888                 DAPM_UPDATE_STAT(w, neighbour_checks);
 889
 890                 if (path->weak)
 891                         continue;
 892
 893                 if (path->connected &&
 894                     !path->connected(path->source, path->sink))
 895                         continue;
 896
 897                 if (!path->sink)
 898                         continue;
 899
 900                 if (dapm_widget_power_check(path->sink))
 901                         return 1;
 902         }
 903
 904         dapm_clear_walk(w->dapm);
 905
 906         return 0;
 907 }
 908
 909 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
 910 {
 911         return 1;
 912 }
 913
 914 static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
 915                             struct snd_soc_dapm_widget *b,
 916                             bool power_up)
 917 {
 918         int *sort;
 919
 920         if (power_up)
 921                 sort = dapm_up_seq;
 922         else
 923                 sort = dapm_down_seq;
 924
 925         if (sort[a->id] != sort[b->id])
 926                 return sort[a->id] - sort[b->id];
 927         if (a->subseq != b->subseq) {
 928                 if (power_up)
 929                         return a->subseq - b->subseq;
 930                 else
 931                         return b->subseq - a->subseq;
 932         }
 933         if (a->reg != b->reg)
 934                 return a->reg - b->reg;
 935         if (a->dapm != b->dapm)
 936                 return (unsigned long)a->dapm - (unsigned long)b->dapm;
 937
 938         return 0;
 939 }
 940
 941 /* Insert a widget in order into a DAPM power sequence. */
 942 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
 943                             struct list_head *list,
 944                             bool power_up)
 945 {
 946         struct snd_soc_dapm_widget *w;
 947
 948         list_for_each_entry(w, list, power_list)
 949                 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
 950                         list_add_tail(&new_widget->power_list, &w->power_list);
 951                         return;
 952                 }
 953
 954         list_add_tail(&new_widget->power_list, list);
 955 }
 956
 957 static void dapm_seq_check_event(struct snd_soc_dapm_context *dapm,
 958                                  struct snd_soc_dapm_widget *w, int event)
 959 {
 960         struct snd_soc_card *card = dapm->card;
 961         const char *ev_name;
 962         int power, ret;
 963
 964         switch (event) {
 965         case SND_SOC_DAPM_PRE_PMU:
 966                 ev_name = "PRE_PMU";
 967                 power = 1;
 968                 break;
 969         case SND_SOC_DAPM_POST_PMU:
 970                 ev_name = "POST_PMU";
 971                 power = 1;
 972                 break;
 973         case SND_SOC_DAPM_PRE_PMD:
 974                 ev_name = "PRE_PMD";
 975                 power = 0;
 976                 break;
 977         case SND_SOC_DAPM_POST_PMD:
 978                 ev_name = "POST_PMD";
 979                 power = 0;
 980                 break;
 981         default:
 982                 BUG();
 983                 return;
 984         }
 985
 986         if (w->power != power)
 987                 return;
 988
 989         if (w->event && (w->event_flags & event)) {
 990                 pop_dbg(dapm->dev, card->pop_time, "pop test : %s %s\n",
 991                         w->name, ev_name);
 992                 trace_snd_soc_dapm_widget_event_start(w, event);
 993                 ret = w->event(w, NULL, event);
 994                 trace_snd_soc_dapm_widget_event_done(w, event);
 995                 if (ret < 0)
 996                         pr_err("%s: %s event failed: %d\n",
 997                                ev_name, w->name, ret);
 998         }
 999 }
1000
1001 /* Apply the coalesced changes from a DAPM sequence */
1002 static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
1003                                    struct list_head *pending)
1004 {
1005         struct snd_soc_card *card = dapm->card;
1006         struct snd_soc_dapm_widget *w;
1007         int reg, power;
1008         unsigned int value = 0;
1009         unsigned int mask = 0;
1010         unsigned int cur_mask;
1011
1012         reg = list_first_entry(pending, struct snd_soc_dapm_widget,
1013                                power_list)->reg;
1014
1015         list_for_each_entry(w, pending, power_list) {
1016                 cur_mask = 1 << w->shift;
1017                 BUG_ON(reg != w->reg);
1018
1019                 if (w->invert)
1020                         power = !w->power;
1021                 else
1022                         power = w->power;
1023
1024                 mask |= cur_mask;
1025                 if (power)
1026                         value |= cur_mask;
1027
1028                 pop_dbg(dapm->dev, card->pop_time,
1029                         "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1030                         w->name, reg, value, mask);
1031
1032                 /* Check for events */
1033                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMU);
1034                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMD);
1035         }
1036
1037         if (reg >= 0) {
1038                 /* Any widget will do, they should all be updating the
1039                  * same register.
1040                  */
1041                 w = list_first_entry(pending, struct snd_soc_dapm_widget,
1042                                      power_list);
1043
1044                 pop_dbg(dapm->dev, card->pop_time,
1045                         "pop test : Applying 0x%x/0x%x to %x in %dms\n",
1046                         value, mask, reg, card->pop_time);
1047                 pop_wait(card->pop_time);
1048                 soc_widget_update_bits(w, reg, mask, value);
1049         }
1050
1051         list_for_each_entry(w, pending, power_list) {
1052                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMU);
1053                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMD);
1054         }
1055 }
1056
1057 /* Apply a DAPM power sequence.
1058  *
1059  * We walk over a pre-sorted list of widgets to apply power to.  In
1060  * order to minimise the number of writes to the device required
1061  * multiple widgets will be updated in a single write where possible.
1062  * Currently anything that requires more than a single write is not
1063  * handled.
1064  */
1065 static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
1066                          struct list_head *list, int event, bool power_up)
1067 {
1068         struct snd_soc_dapm_widget *w, *n;
1069         LIST_HEAD(pending);
1070         int cur_sort = -1;
1071         int cur_subseq = -1;
1072         int cur_reg = SND_SOC_NOPM;
1073         struct snd_soc_dapm_context *cur_dapm = NULL;
1074         int ret, i;
1075         int *sort;
1076
1077         if (power_up)
1078                 sort = dapm_up_seq;
1079         else
1080                 sort = dapm_down_seq;
1081
1082         list_for_each_entry_safe(w, n, list, power_list) {
1083                 ret = 0;
1084
1085                 /* Do we need to apply any queued changes? */
1086                 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1087                     w->dapm != cur_dapm || w->subseq != cur_subseq) {
1088                         if (!list_empty(&pending))
1089                                 dapm_seq_run_coalesced(cur_dapm, &pending);
1090
1091                         if (cur_dapm && cur_dapm->seq_notifier) {
1092                                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1093                                         if (sort[i] == cur_sort)
1094                                                 cur_dapm->seq_notifier(cur_dapm,
1095                                                                        i,
1096                                                                        cur_subseq);
1097                         }
1098
1099                         INIT_LIST_HEAD(&pending);
1100                         cur_sort = -1;
1101                         cur_subseq = INT_MIN;
1102                         cur_reg = SND_SOC_NOPM;
1103                         cur_dapm = NULL;
1104                 }
1105
1106                 switch (w->id) {
1107                 case snd_soc_dapm_pre:
1108                         if (!w->event)
1109                                 list_for_each_entry_safe_continue(w, n, list,
1110                                                                   power_list);
1111
1112                         if (event == SND_SOC_DAPM_STREAM_START)
1113                                 ret = w->event(w,
1114                                                NULL, SND_SOC_DAPM_PRE_PMU);
1115                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1116                                 ret = w->event(w,
1117                                                NULL, SND_SOC_DAPM_PRE_PMD);
1118                         break;
1119
1120                 case snd_soc_dapm_post:
1121                         if (!w->event)
1122                                 list_for_each_entry_safe_continue(w, n, list,
1123                                                                   power_list);
1124
1125                         if (event == SND_SOC_DAPM_STREAM_START)
1126                                 ret = w->event(w,
1127                                                NULL, SND_SOC_DAPM_POST_PMU);
1128                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1129                                 ret = w->event(w,
1130                                                NULL, SND_SOC_DAPM_POST_PMD);
1131                         break;
1132
1133                 default:
1134                         /* Queue it up for application */
1135                         cur_sort = sort[w->id];
1136                         cur_subseq = w->subseq;
1137                         cur_reg = w->reg;
1138                         cur_dapm = w->dapm;
1139                         list_move(&w->power_list, &pending);
1140                         break;
1141                 }
1142
1143                 if (ret < 0)
1144                         dev_err(w->dapm->dev,
1145                                 "Failed to apply widget power: %d\n", ret);
1146         }
1147
1148         if (!list_empty(&pending))
1149                 dapm_seq_run_coalesced(cur_dapm, &pending);
1150
1151         if (cur_dapm && cur_dapm->seq_notifier) {
1152                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1153                         if (sort[i] == cur_sort)
1154                                 cur_dapm->seq_notifier(cur_dapm,
1155                                                        i, cur_subseq);
1156         }
1157 }
1158
1159 static void dapm_widget_update(struct snd_soc_dapm_context *dapm)
1160 {
1161         struct snd_soc_dapm_update *update = dapm->update;
1162         struct snd_soc_dapm_widget *w;
1163         int ret;
1164
1165         if (!update)
1166                 return;
1167
1168         w = update->widget;
1169
1170         if (w->event &&
1171             (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1172                 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1173                 if (ret != 0)
1174                         pr_err("%s DAPM pre-event failed: %d\n",
1175                                w->name, ret);
1176         }
1177
1178         ret = snd_soc_update_bits(w->codec, update->reg, update->mask,
1179                                   update->val);
1180         if (ret < 0)
1181                 pr_err("%s DAPM update failed: %d\n", w->name, ret);
1182
1183         if (w->event &&
1184             (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1185                 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1186                 if (ret != 0)
1187                         pr_err("%s DAPM post-event failed: %d\n",
1188                                w->name, ret);
1189         }
1190 }
1191
1192 /* Async callback run prior to DAPM sequences - brings to _PREPARE if
1193  * they're changing state.
1194  */
1195 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1196 {
1197         struct snd_soc_dapm_context *d = data;
1198         int ret;
1199
1200         /* If we're off and we're not supposed to be go into STANDBY */
1201         if (d->bias_level == SND_SOC_BIAS_OFF &&
1202             d->target_bias_level != SND_SOC_BIAS_OFF) {
1203                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1204                 if (ret != 0)
1205                         dev_err(d->dev,
1206                                 "Failed to turn on bias: %d\n", ret);
1207         }
1208
1209         /* Prepare for a STADDBY->ON or ON->STANDBY transition */
1210         if (d->bias_level != d->target_bias_level) {
1211                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1212                 if (ret != 0)
1213                         dev_err(d->dev,
1214                                 "Failed to prepare bias: %d\n", ret);
1215         }
1216 }
1217
1218 /* Async callback run prior to DAPM sequences - brings to their final
1219  * state.
1220  */
1221 static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1222 {
1223         struct snd_soc_dapm_context *d = data;
1224         int ret;
1225
1226         /* If we just powered the last thing off drop to standby bias */
1227         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1228             (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1229              d->target_bias_level == SND_SOC_BIAS_OFF)) {
1230                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1231                 if (ret != 0)
1232                         dev_err(d->dev, "Failed to apply standby bias: %d\n",
1233                                 ret);
1234         }
1235
1236         /* If we're in standby and can support bias off then do that */
1237         if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1238             d->target_bias_level == SND_SOC_BIAS_OFF) {
1239                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1240                 if (ret != 0)
1241                         dev_err(d->dev, "Failed to turn off bias: %d\n", ret);
1242         }
1243
1244         /* If we just powered up then move to active bias */
1245         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1246             d->target_bias_level == SND_SOC_BIAS_ON) {
1247                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1248                 if (ret != 0)
1249                         dev_err(d->dev, "Failed to apply active bias: %d\n",
1250                                 ret);
1251         }
1252 }
1253
1254 static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1255                                        bool power, bool connect)
1256 {
1257         /* If a connection is being made or broken then that update
1258          * will have marked the peer dirty, otherwise the widgets are
1259          * not connected and this update has no impact. */
1260         if (!connect)
1261                 return;
1262
1263         /* If the peer is already in the state we're moving to then we
1264          * won't have an impact on it. */
1265         if (power != peer->power)
1266                 dapm_mark_dirty(peer, "peer state change");
1267 }
1268
1269 static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1270                                   struct list_head *up_list,
1271                                   struct list_head *down_list)
1272 {
1273         struct snd_soc_dapm_path *path;
1274
1275         if (w->power == power)
1276                 return;
1277
1278         trace_snd_soc_dapm_widget_power(w, power);
1279
1280         /* If we changed our power state perhaps our neigbours changed
1281          * also.
1282          */
1283         list_for_each_entry(path, &w->sources, list_sink) {
1284                 if (path->source) {
1285                         dapm_widget_set_peer_power(path->source, power,
1286                                                    path->connect);
1287                 }
1288         }
1289         switch (w->id) {
1290         case snd_soc_dapm_supply:
1291                 /* Supplies can't affect their outputs, only their inputs */
1292                 break;
1293         default:
1294                 list_for_each_entry(path, &w->sinks, list_source) {
1295                         if (path->sink) {
1296                                 dapm_widget_set_peer_power(path->sink, power,
1297                                                            path->connect);
1298                         }
1299                 }
1300                 break;
1301         }
1302
1303         if (power)
1304                 dapm_seq_insert(w, up_list, true);
1305         else
1306                 dapm_seq_insert(w, down_list, false);
1307
1308         w->power = power;
1309 }
1310
1311 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1312                                   struct list_head *up_list,
1313                                   struct list_head *down_list)
1314 {
1315         int power;
1316
1317         switch (w->id) {
1318         case snd_soc_dapm_pre:
1319                 dapm_seq_insert(w, down_list, false);
1320                 break;
1321         case snd_soc_dapm_post:
1322                 dapm_seq_insert(w, up_list, true);
1323                 break;
1324
1325         default:
1326                 power = dapm_widget_power_check(w);
1327
1328                 dapm_widget_set_power(w, power, up_list, down_list);
1329                 break;
1330         }
1331 }
1332
1333 /*
1334  * Scan each dapm widget for complete audio path.
1335  * A complete path is a route that has valid endpoints i.e.:-
1336  *
1337  *  o DAC to output pin.
1338  *  o Input Pin to ADC.
1339  *  o Input pin to Output pin (bypass, sidetone)
1340  *  o DAC to ADC (loopback).
1341  */
1342 static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
1343 {
1344         struct snd_soc_card *card = dapm->card;
1345         struct snd_soc_dapm_widget *w;
1346         struct snd_soc_dapm_context *d;
1347         LIST_HEAD(up_list);
1348         LIST_HEAD(down_list);
1349         LIST_HEAD(async_domain);
1350         enum snd_soc_bias_level bias;
1351
1352         trace_snd_soc_dapm_start(card);
1353
1354         list_for_each_entry(d, &card->dapm_list, list) {
1355                 if (d->n_widgets || d->codec == NULL) {
1356                         if (d->idle_bias_off)
1357                                 d->target_bias_level = SND_SOC_BIAS_OFF;
1358                         else
1359                                 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1360                 }
1361         }
1362
1363         memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
1364
1365         list_for_each_entry(w, &card->widgets, list) {
1366                 w->power_checked = false;
1367                 w->inputs = -1;
1368                 w->outputs = -1;
1369         }
1370
1371         /* Check which widgets we need to power and store them in
1372          * lists indicating if they should be powered up or down.  We
1373          * only check widgets that have been flagged as dirty but note
1374          * that new widgets may be added to the dirty list while we
1375          * iterate.
1376          */
1377         list_for_each_entry(w, &card->dapm_dirty, dirty) {
1378                 dapm_power_one_widget(w, &up_list, &down_list);
1379         }
1380
1381         list_for_each_entry(w, &card->widgets, list) {
1382                 list_del_init(&w->dirty);
1383
1384                 if (w->power) {
1385                         d = w->dapm;
1386
1387                         /* Supplies and micbiases only bring the
1388                          * context up to STANDBY as unless something
1389                          * else is active and passing audio they
1390                          * generally don't require full power.
1391                          */
1392                         switch (w->id) {
1393                         case snd_soc_dapm_supply:
1394                         case snd_soc_dapm_micbias:
1395                                 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1396                                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1397                                 break;
1398                         default:
1399                                 d->target_bias_level = SND_SOC_BIAS_ON;
1400                                 break;
1401                         }
1402                 }
1403
1404         }
1405
1406         /* If there are no DAPM widgets then try to figure out power from the
1407          * event type.
1408          */
1409         if (!dapm->n_widgets) {
1410                 switch (event) {
1411                 case SND_SOC_DAPM_STREAM_START:
1412                 case SND_SOC_DAPM_STREAM_RESUME:
1413                         dapm->target_bias_level = SND_SOC_BIAS_ON;
1414                         break;
1415                 case SND_SOC_DAPM_STREAM_STOP:
1416                         if (dapm->codec->active)
1417                                 dapm->target_bias_level = SND_SOC_BIAS_ON;
1418                         else
1419                                 dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
1420                         break;
1421                 case SND_SOC_DAPM_STREAM_SUSPEND:
1422                         dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
1423                         break;
1424                 case SND_SOC_DAPM_STREAM_NOP:
1425                         dapm->target_bias_level = dapm->bias_level;
1426                         break;
1427                 default:
1428                         break;
1429                 }
1430         }
1431
1432         /* Force all contexts in the card to the same bias state if
1433          * they're not ground referenced.
1434          */
1435         bias = SND_SOC_BIAS_OFF;
1436         list_for_each_entry(d, &card->dapm_list, list)
1437                 if (d->target_bias_level > bias)
1438                         bias = d->target_bias_level;
1439         list_for_each_entry(d, &card->dapm_list, list)
1440                 if (!d->idle_bias_off)
1441                         d->target_bias_level = bias;
1442
1443         trace_snd_soc_dapm_walk_done(card);
1444
1445         /* Run all the bias changes in parallel */
1446         list_for_each_entry(d, &dapm->card->dapm_list, list)
1447                 async_schedule_domain(dapm_pre_sequence_async, d,
1448                                         &async_domain);
1449         async_synchronize_full_domain(&async_domain);
1450
1451         /* Power down widgets first; try to avoid amplifying pops. */
1452         dapm_seq_run(dapm, &down_list, event, false);
1453
1454         dapm_widget_update(dapm);
1455
1456         /* Now power up. */
1457         dapm_seq_run(dapm, &up_list, event, true);
1458
1459         /* Run all the bias changes in parallel */
1460         list_for_each_entry(d, &dapm->card->dapm_list, list)
1461                 async_schedule_domain(dapm_post_sequence_async, d,
1462                                         &async_domain);
1463         async_synchronize_full_domain(&async_domain);
1464
1465         pop_dbg(dapm->dev, card->pop_time,
1466                 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
1467         pop_wait(card->pop_time);
1468
1469         trace_snd_soc_dapm_done(card);
1470
1471         return 0;
1472 }
1473
1474 #ifdef CONFIG_DEBUG_FS
1475 static int dapm_widget_power_open_file(struct inode *inode, struct file *file)
1476 {
1477         file->private_data = inode->i_private;
1478         return 0;
1479 }
1480
1481 static ssize_t dapm_widget_power_read_file(struct file *file,
1482                                            char __user *user_buf,
1483                                            size_t count, loff_t *ppos)
1484 {
1485         struct snd_soc_dapm_widget *w = file->private_data;
1486         char *buf;
1487         int in, out;
1488         ssize_t ret;
1489         struct snd_soc_dapm_path *p = NULL;
1490
1491         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1492         if (!buf)
1493                 return -ENOMEM;
1494
1495         in = is_connected_input_ep(w);
1496         dapm_clear_walk(w->dapm);
1497         out = is_connected_output_ep(w);
1498         dapm_clear_walk(w->dapm);
1499
1500         ret = snprintf(buf, PAGE_SIZE, "%s: %s  in %d out %d",
1501                        w->name, w->power ? "On" : "Off", in, out);
1502
1503         if (w->reg >= 0)
1504                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1505                                 " - R%d(0x%x) bit %d",
1506                                 w->reg, w->reg, w->shift);
1507
1508         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1509
1510         if (w->sname)
1511                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1512                                 w->sname,
1513                                 w->active ? "active" : "inactive");
1514
1515         list_for_each_entry(p, &w->sources, list_sink) {
1516                 if (p->connected && !p->connected(w, p->sink))
1517                         continue;
1518
1519                 if (p->connect)
1520                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1521                                         " in  \"%s\" \"%s\"\n",
1522                                         p->name ? p->name : "static",
1523                                         p->source->name);
1524         }
1525         list_for_each_entry(p, &w->sinks, list_source) {
1526                 if (p->connected && !p->connected(w, p->sink))
1527                         continue;
1528
1529                 if (p->connect)
1530                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1531                                         " out \"%s\" \"%s\"\n",
1532                                         p->name ? p->name : "static",
1533                                         p->sink->name);
1534         }
1535
1536         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1537
1538         kfree(buf);
1539         return ret;
1540 }
1541
1542 static const struct file_operations dapm_widget_power_fops = {
1543         .open = dapm_widget_power_open_file,
1544         .read = dapm_widget_power_read_file,
1545         .llseek = default_llseek,
1546 };
1547
1548 static int dapm_bias_open_file(struct inode *inode, struct file *file)
1549 {
1550         file->private_data = inode->i_private;
1551         return 0;
1552 }
1553
1554 static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1555                                    size_t count, loff_t *ppos)
1556 {
1557         struct snd_soc_dapm_context *dapm = file->private_data;
1558         char *level;
1559
1560         switch (dapm->bias_level) {
1561         case SND_SOC_BIAS_ON:
1562                 level = "On\n";
1563                 break;
1564         case SND_SOC_BIAS_PREPARE:
1565                 level = "Prepare\n";
1566                 break;
1567         case SND_SOC_BIAS_STANDBY:
1568                 level = "Standby\n";
1569                 break;
1570         case SND_SOC_BIAS_OFF:
1571                 level = "Off\n";
1572                 break;
1573         default:
1574                 BUG();
1575                 level = "Unknown\n";
1576                 break;
1577         }
1578
1579         return simple_read_from_buffer(user_buf, count, ppos, level,
1580                                        strlen(level));
1581 }
1582
1583 static const struct file_operations dapm_bias_fops = {
1584         .open = dapm_bias_open_file,
1585         .read = dapm_bias_read_file,
1586         .llseek = default_llseek,
1587 };
1588
1589 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1590         struct dentry *parent)
1591 {
1592         struct dentry *d;
1593
1594         dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
1595
1596         if (!dapm->debugfs_dapm) {
1597                 printk(KERN_WARNING
1598                        "Failed to create DAPM debugfs directory\n");
1599                 return;
1600         }
1601
1602         d = debugfs_create_file("bias_level", 0444,
1603                                 dapm->debugfs_dapm, dapm,
1604                                 &dapm_bias_fops);
1605         if (!d)
1606                 dev_warn(dapm->dev,
1607                          "ASoC: Failed to create bias level debugfs file\n");
1608 }
1609
1610 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1611 {
1612         struct snd_soc_dapm_context *dapm = w->dapm;
1613         struct dentry *d;
1614
1615         if (!dapm->debugfs_dapm || !w->name)
1616                 return;
1617
1618         d = debugfs_create_file(w->name, 0444,
1619                                 dapm->debugfs_dapm, w,
1620                                 &dapm_widget_power_fops);
1621         if (!d)
1622                 dev_warn(w->dapm->dev,
1623                         "ASoC: Failed to create %s debugfs file\n",
1624                         w->name);
1625 }
1626
1627 static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1628 {
1629         debugfs_remove_recursive(dapm->debugfs_dapm);
1630 }
1631
1632 #else
1633 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1634         struct dentry *parent)
1635 {
1636 }
1637
1638 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1639 {
1640 }
1641
1642 static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1643 {
1644 }
1645
1646 #endif
1647
1648 /* test and update the power status of a mux widget */
1649 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
1650                                  struct snd_kcontrol *kcontrol, int change,
1651                                  int mux, struct soc_enum *e)
1652 {
1653         struct snd_soc_dapm_path *path;
1654         int found = 0;
1655
1656         if (widget->id != snd_soc_dapm_mux &&
1657             widget->id != snd_soc_dapm_virt_mux &&
1658             widget->id != snd_soc_dapm_value_mux)
1659                 return -ENODEV;
1660
1661         if (!change)
1662                 return 0;
1663
1664         /* find dapm widget path assoc with kcontrol */
1665         list_for_each_entry(path, &widget->dapm->card->paths, list) {
1666                 if (path->kcontrol != kcontrol)
1667                         continue;
1668
1669                 if (!path->name || !e->texts[mux])
1670                         continue;
1671
1672                 found = 1;
1673                 /* we now need to match the string in the enum to the path */
1674                 if (!(strcmp(path->name, e->texts[mux]))) {
1675                         path->connect = 1; /* new connection */
1676                         dapm_mark_dirty(path->source, "mux connection");
1677                 } else {
1678                         if (path->connect)
1679                                 dapm_mark_dirty(path->source,
1680                                                 "mux disconnection");
1681                         path->connect = 0; /* old connection must be powered down */
1682                 }
1683         }
1684
1685         if (found) {
1686                 dapm_mark_dirty(widget, "mux change");
1687                 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1688         }
1689
1690         return 0;
1691 }
1692
1693 /* test and update the power status of a mixer or switch widget */
1694 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
1695                                    struct snd_kcontrol *kcontrol, int connect)
1696 {
1697         struct snd_soc_dapm_path *path;
1698         int found = 0;
1699
1700         if (widget->id != snd_soc_dapm_mixer &&
1701             widget->id != snd_soc_dapm_mixer_named_ctl &&
1702             widget->id != snd_soc_dapm_switch)
1703                 return -ENODEV;
1704
1705         /* find dapm widget path assoc with kcontrol */
1706         list_for_each_entry(path, &widget->dapm->card->paths, list) {
1707                 if (path->kcontrol != kcontrol)
1708                         continue;
1709
1710                 /* found, now check type */
1711                 found = 1;
1712                 path->connect = connect;
1713                 dapm_mark_dirty(path->source, "mixer connection");
1714         }
1715
1716         if (found) {
1717                 dapm_mark_dirty(widget, "mixer update");
1718                 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1719         }
1720
1721         return 0;
1722 }
1723
1724 /* show dapm widget status in sys fs */
1725 static ssize_t dapm_widget_show(struct device *dev,
1726         struct device_attribute *attr, char *buf)
1727 {
1728         struct snd_soc_pcm_runtime *rtd =
1729                         container_of(dev, struct snd_soc_pcm_runtime, dev);
1730         struct snd_soc_codec *codec =rtd->codec;
1731         struct snd_soc_dapm_widget *w;
1732         int count = 0;
1733         char *state = "not set";
1734
1735         list_for_each_entry(w, &codec->card->widgets, list) {
1736                 if (w->dapm != &codec->dapm)
1737                         continue;
1738
1739                 /* only display widgets that burnm power */
1740                 switch (w->id) {
1741                 case snd_soc_dapm_hp:
1742                 case snd_soc_dapm_mic:
1743                 case snd_soc_dapm_spk:
1744                 case snd_soc_dapm_line:
1745                 case snd_soc_dapm_micbias:
1746                 case snd_soc_dapm_dac:
1747                 case snd_soc_dapm_adc:
1748                 case snd_soc_dapm_pga:
1749                 case snd_soc_dapm_out_drv:
1750                 case snd_soc_dapm_mixer:
1751                 case snd_soc_dapm_mixer_named_ctl:
1752                 case snd_soc_dapm_supply:
1753                         if (w->name)
1754                                 count += sprintf(buf + count, "%s: %s\n",
1755                                         w->name, w->power ? "On":"Off");
1756                 break;
1757                 default:
1758                 break;
1759                 }
1760         }
1761
1762         switch (codec->dapm.bias_level) {
1763         case SND_SOC_BIAS_ON:
1764                 state = "On";
1765                 break;
1766         case SND_SOC_BIAS_PREPARE:
1767                 state = "Prepare";
1768                 break;
1769         case SND_SOC_BIAS_STANDBY:
1770                 state = "Standby";
1771                 break;
1772         case SND_SOC_BIAS_OFF:
1773                 state = "Off";
1774                 break;
1775         }
1776         count += sprintf(buf + count, "PM State: %s\n", state);
1777
1778         return count;
1779 }
1780
1781 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
1782
1783 int snd_soc_dapm_sys_add(struct device *dev)
1784 {
1785         return device_create_file(dev, &dev_attr_dapm_widget);
1786 }
1787
1788 static void snd_soc_dapm_sys_remove(struct device *dev)
1789 {
1790         device_remove_file(dev, &dev_attr_dapm_widget);
1791 }
1792
1793 /* free all dapm widgets and resources */
1794 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
1795 {
1796         struct snd_soc_dapm_widget *w, *next_w;
1797         struct snd_soc_dapm_path *p, *next_p;
1798
1799         list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
1800                 if (w->dapm != dapm)
1801                         continue;
1802                 list_del(&w->list);
1803                 /*
1804                  * remove source and sink paths associated to this widget.
1805                  * While removing the path, remove reference to it from both
1806                  * source and sink widgets so that path is removed only once.
1807                  */
1808                 list_for_each_entry_safe(p, next_p, &w->sources, list_sink) {
1809                         list_del(&p->list_sink);
1810                         list_del(&p->list_source);
1811                         list_del(&p->list);
1812                         kfree(p->long_name);
1813                         kfree(p);
1814                 }
1815                 list_for_each_entry_safe(p, next_p, &w->sinks, list_source) {
1816                         list_del(&p->list_sink);
1817                         list_del(&p->list_source);
1818                         list_del(&p->list);
1819                         kfree(p->long_name);
1820                         kfree(p);
1821                 }
1822                 kfree(w->kcontrols);
1823                 kfree(w->name);
1824                 kfree(w);
1825         }
1826 }
1827
1828 static struct snd_soc_dapm_widget *dapm_find_widget(
1829                         struct snd_soc_dapm_context *dapm, const char *pin,
1830                         bool search_other_contexts)
1831 {
1832         struct snd_soc_dapm_widget *w;
1833         struct snd_soc_dapm_widget *fallback = NULL;
1834
1835         list_for_each_entry(w, &dapm->card->widgets, list) {
1836                 if (!strcmp(w->name, pin)) {
1837                         if (w->dapm == dapm)
1838                                 return w;
1839                         else
1840                                 fallback = w;
1841                 }
1842         }
1843
1844         if (search_other_contexts)
1845                 return fallback;
1846
1847         return NULL;
1848 }
1849
1850 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
1851                                 const char *pin, int status)
1852 {
1853         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
1854
1855         if (!w) {
1856                 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
1857                 return -EINVAL;
1858         }
1859
1860         w->connected = status;
1861         if (status == 0)
1862                 w->force = 0;
1863         dapm_mark_dirty(w, "pin configuration");
1864
1865         return 0;
1866 }
1867
1868 /**
1869  * snd_soc_dapm_sync - scan and power dapm paths
1870  * @dapm: DAPM context
1871  *
1872  * Walks all dapm audio paths and powers widgets according to their
1873  * stream or path usage.
1874  *
1875  * Returns 0 for success.
1876  */
1877 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
1878 {
1879         /*
1880          * Suppress early reports (eg, jacks syncing their state) to avoid
1881          * silly DAPM runs during card startup.
1882          */
1883         if (!dapm->card || !dapm->card->instantiated)
1884                 return 0;
1885
1886         return dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
1887 }
1888 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
1889
1890 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
1891                                   const struct snd_soc_dapm_route *route)
1892 {
1893         struct snd_soc_dapm_path *path;
1894         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
1895         struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
1896         const char *sink;
1897         const char *control = route->control;
1898         const char *source;
1899         char prefixed_sink[80];
1900         char prefixed_source[80];
1901         int ret = 0;
1902
1903         if (dapm->codec && dapm->codec->name_prefix) {
1904                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
1905                          dapm->codec->name_prefix, route->sink);
1906                 sink = prefixed_sink;
1907                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
1908                          dapm->codec->name_prefix, route->source);
1909                 source = prefixed_source;
1910         } else {
1911                 sink = route->sink;
1912                 source = route->source;
1913         }
1914
1915         /*
1916          * find src and dest widgets over all widgets but favor a widget from
1917          * current DAPM context
1918          */
1919         list_for_each_entry(w, &dapm->card->widgets, list) {
1920                 if (!wsink && !(strcmp(w->name, sink))) {
1921                         wtsink = w;
1922                         if (w->dapm == dapm)
1923                                 wsink = w;
1924                         continue;
1925                 }
1926                 if (!wsource && !(strcmp(w->name, source))) {
1927                         wtsource = w;
1928                         if (w->dapm == dapm)
1929                                 wsource = w;
1930                 }
1931         }
1932         /* use widget from another DAPM context if not found from this */
1933         if (!wsink)
1934                 wsink = wtsink;
1935         if (!wsource)
1936                 wsource = wtsource;
1937
1938         if (wsource == NULL || wsink == NULL)
1939                 return -ENODEV;
1940
1941         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
1942         if (!path)
1943                 return -ENOMEM;
1944
1945         path->source = wsource;
1946         path->sink = wsink;
1947         path->connected = route->connected;
1948         INIT_LIST_HEAD(&path->list);
1949         INIT_LIST_HEAD(&path->list_source);
1950         INIT_LIST_HEAD(&path->list_sink);
1951
1952         /* check for external widgets */
1953         if (wsink->id == snd_soc_dapm_input) {
1954                 if (wsource->id == snd_soc_dapm_micbias ||
1955                         wsource->id == snd_soc_dapm_mic ||
1956                         wsource->id == snd_soc_dapm_line ||
1957                         wsource->id == snd_soc_dapm_output)
1958                         wsink->ext = 1;
1959         }
1960         if (wsource->id == snd_soc_dapm_output) {
1961                 if (wsink->id == snd_soc_dapm_spk ||
1962                         wsink->id == snd_soc_dapm_hp ||
1963                         wsink->id == snd_soc_dapm_line ||
1964                         wsink->id == snd_soc_dapm_input)
1965                         wsource->ext = 1;
1966         }
1967
1968         /* connect static paths */
1969         if (control == NULL) {
1970                 list_add(&path->list, &dapm->card->paths);
1971                 list_add(&path->list_sink, &wsink->sources);
1972                 list_add(&path->list_source, &wsource->sinks);
1973                 path->connect = 1;
1974                 return 0;
1975         }
1976
1977         /* connect dynamic paths */
1978         switch (wsink->id) {
1979         case snd_soc_dapm_adc:
1980         case snd_soc_dapm_dac:
1981         case snd_soc_dapm_pga:
1982         case snd_soc_dapm_out_drv:
1983         case snd_soc_dapm_input:
1984         case snd_soc_dapm_output:
1985         case snd_soc_dapm_micbias:
1986         case snd_soc_dapm_vmid:
1987         case snd_soc_dapm_pre:
1988         case snd_soc_dapm_post:
1989         case snd_soc_dapm_supply:
1990         case snd_soc_dapm_aif_in:
1991         case snd_soc_dapm_aif_out:
1992                 list_add(&path->list, &dapm->card->paths);
1993                 list_add(&path->list_sink, &wsink->sources);
1994                 list_add(&path->list_source, &wsource->sinks);
1995                 path->connect = 1;
1996                 return 0;
1997         case snd_soc_dapm_mux:
1998         case snd_soc_dapm_virt_mux:
1999         case snd_soc_dapm_value_mux:
2000                 ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
2001                         &wsink->kcontrol_news[0]);
2002                 if (ret != 0)
2003                         goto err;
2004                 break;
2005         case snd_soc_dapm_switch:
2006         case snd_soc_dapm_mixer:
2007         case snd_soc_dapm_mixer_named_ctl:
2008                 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
2009                 if (ret != 0)
2010                         goto err;
2011                 break;
2012         case snd_soc_dapm_hp:
2013         case snd_soc_dapm_mic:
2014         case snd_soc_dapm_line:
2015         case snd_soc_dapm_spk:
2016                 list_add(&path->list, &dapm->card->paths);
2017                 list_add(&path->list_sink, &wsink->sources);
2018                 list_add(&path->list_source, &wsource->sinks);
2019                 path->connect = 0;
2020                 return 0;
2021         }
2022         return 0;
2023
2024 err:
2025         dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
2026                  source, control, sink);
2027         kfree(path);
2028         return ret;
2029 }
2030
2031 /**
2032  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
2033  * @dapm: DAPM context
2034  * @route: audio routes
2035  * @num: number of routes
2036  *
2037  * Connects 2 dapm widgets together via a named audio path. The sink is
2038  * the widget receiving the audio signal, whilst the source is the sender
2039  * of the audio signal.
2040  *
2041  * Returns 0 for success else error. On error all resources can be freed
2042  * with a call to snd_soc_card_free().
2043  */
2044 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
2045                             const struct snd_soc_dapm_route *route, int num)
2046 {
2047         int i, ret;
2048
2049         for (i = 0; i < num; i++) {
2050                 ret = snd_soc_dapm_add_route(dapm, route);
2051                 if (ret < 0) {
2052                         dev_err(dapm->dev, "Failed to add route %s->%s\n",
2053                                 route->source, route->sink);
2054                         return ret;
2055                 }
2056                 route++;
2057         }
2058
2059         return 0;
2060 }
2061 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2062
2063 static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2064                                    const struct snd_soc_dapm_route *route)
2065 {
2066         struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2067                                                               route->source,
2068                                                               true);
2069         struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2070                                                             route->sink,
2071                                                             true);
2072         struct snd_soc_dapm_path *path;
2073         int count = 0;
2074
2075         if (!source) {
2076                 dev_err(dapm->dev, "Unable to find source %s for weak route\n",
2077                         route->source);
2078                 return -ENODEV;
2079         }
2080
2081         if (!sink) {
2082                 dev_err(dapm->dev, "Unable to find sink %s for weak route\n",
2083                         route->sink);
2084                 return -ENODEV;
2085         }
2086
2087         if (route->control || route->connected)
2088                 dev_warn(dapm->dev, "Ignoring control for weak route %s->%s\n",
2089                          route->source, route->sink);
2090
2091         list_for_each_entry(path, &source->sinks, list_source) {
2092                 if (path->sink == sink) {
2093                         path->weak = 1;
2094                         count++;
2095                 }
2096         }
2097
2098         if (count == 0)
2099                 dev_err(dapm->dev, "No path found for weak route %s->%s\n",
2100                         route->source, route->sink);
2101         if (count > 1)
2102                 dev_warn(dapm->dev, "%d paths found for weak route %s->%s\n",
2103                          count, route->source, route->sink);
2104
2105         return 0;
2106 }
2107
2108 /**
2109  * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2110  * @dapm: DAPM context
2111  * @route: audio routes
2112  * @num: number of routes
2113  *
2114  * Mark existing routes matching those specified in the passed array
2115  * as being weak, meaning that they are ignored for the purpose of
2116  * power decisions.  The main intended use case is for sidetone paths
2117  * which couple audio between other independent paths if they are both
2118  * active in order to make the combination work better at the user
2119  * level but which aren't intended to be "used".
2120  *
2121  * Note that CODEC drivers should not use this as sidetone type paths
2122  * can frequently also be used as bypass paths.
2123  */
2124 int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2125                              const struct snd_soc_dapm_route *route, int num)
2126 {
2127         int i, err;
2128         int ret = 0;
2129
2130         for (i = 0; i < num; i++) {
2131                 err = snd_soc_dapm_weak_route(dapm, route);
2132                 if (err)
2133                         ret = err;
2134                 route++;
2135         }
2136
2137         return ret;
2138 }
2139 EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2140
2141 /**
2142  * snd_soc_dapm_new_widgets - add new dapm widgets
2143  * @dapm: DAPM context
2144  *
2145  * Checks the codec for any new dapm widgets and creates them if found.
2146  *
2147  * Returns 0 for success.
2148  */
2149 int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
2150 {
2151         struct snd_soc_dapm_widget *w;
2152         unsigned int val;
2153
2154         list_for_each_entry(w, &dapm->card->widgets, list)
2155         {
2156                 if (w->new)
2157                         continue;
2158
2159                 if (w->num_kcontrols) {
2160                         w->kcontrols = kzalloc(w->num_kcontrols *
2161                                                 sizeof(struct snd_kcontrol *),
2162                                                 GFP_KERNEL);
2163                         if (!w->kcontrols)
2164                                 return -ENOMEM;
2165                 }
2166
2167                 switch(w->id) {
2168                 case snd_soc_dapm_switch:
2169                 case snd_soc_dapm_mixer:
2170                 case snd_soc_dapm_mixer_named_ctl:
2171                         dapm_new_mixer(w);
2172                         break;
2173                 case snd_soc_dapm_mux:
2174                 case snd_soc_dapm_virt_mux:
2175                 case snd_soc_dapm_value_mux:
2176                         dapm_new_mux(w);
2177                         break;
2178                 case snd_soc_dapm_pga:
2179                 case snd_soc_dapm_out_drv:
2180                         dapm_new_pga(w);
2181                         break;
2182                 default:
2183                         break;
2184                 }
2185
2186                 /* Read the initial power state from the device */
2187                 if (w->reg >= 0) {
2188                         val = soc_widget_read(w, w->reg);
2189                         val &= 1 << w->shift;
2190                         if (w->invert)
2191                                 val = !val;
2192
2193                         if (val)
2194                                 w->power = 1;
2195                 }
2196
2197                 w->new = 1;
2198
2199                 dapm_mark_dirty(w, "new widget");
2200                 dapm_debugfs_add_widget(w);
2201         }
2202
2203         dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
2204         return 0;
2205 }
2206 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2207
2208 /**
2209  * snd_soc_dapm_get_volsw - dapm mixer get callback
2210  * @kcontrol: mixer control
2211  * @ucontrol: control element information
2212  *
2213  * Callback to get the value of a dapm mixer control.
2214  *
2215  * Returns 0 for success.
2216  */
2217 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2218         struct snd_ctl_elem_value *ucontrol)
2219 {
2220         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2221         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2222         struct soc_mixer_control *mc =
2223                 (struct soc_mixer_control *)kcontrol->private_value;
2224         unsigned int reg = mc->reg;
2225         unsigned int shift = mc->shift;
2226         unsigned int rshift = mc->rshift;
2227         int max = mc->max;
2228         unsigned int invert = mc->invert;
2229         unsigned int mask = (1 << fls(max)) - 1;
2230
2231         ucontrol->value.integer.value[0] =
2232                 (snd_soc_read(widget->codec, reg) >> shift) & mask;
2233         if (shift != rshift)
2234                 ucontrol->value.integer.value[1] =
2235                         (snd_soc_read(widget->codec, reg) >> rshift) & mask;
2236         if (invert) {
2237                 ucontrol->value.integer.value[0] =
2238                         max - ucontrol->value.integer.value[0];
2239                 if (shift != rshift)
2240                         ucontrol->value.integer.value[1] =
2241                                 max - ucontrol->value.integer.value[1];
2242         }
2243
2244         return 0;
2245 }
2246 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
2247
2248 /**
2249  * snd_soc_dapm_put_volsw - dapm mixer set callback
2250  * @kcontrol: mixer control
2251  * @ucontrol: control element information
2252  *
2253  * Callback to set the value of a dapm mixer control.
2254  *
2255  * Returns 0 for success.
2256  */
2257 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
2258         struct snd_ctl_elem_value *ucontrol)
2259 {
2260         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2261         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2262         struct snd_soc_codec *codec = widget->codec;
2263         struct soc_mixer_control *mc =
2264                 (struct soc_mixer_control *)kcontrol->private_value;
2265         unsigned int reg = mc->reg;
2266         unsigned int shift = mc->shift;
2267         int max = mc->max;
2268         unsigned int mask = (1 << fls(max)) - 1;
2269         unsigned int invert = mc->invert;
2270         unsigned int val;
2271         int connect, change;
2272         struct snd_soc_dapm_update update;
2273         int wi;
2274
2275         val = (ucontrol->value.integer.value[0] & mask);
2276
2277         if (invert)
2278                 val = max - val;
2279         mask = mask << shift;
2280         val = val << shift;
2281
2282         if (val)
2283                 /* new connection */
2284                 connect = invert ? 0 : 1;
2285         else
2286                 /* old connection must be powered down */
2287                 connect = invert ? 1 : 0;
2288
2289         mutex_lock(&codec->mutex);
2290
2291         change = snd_soc_test_bits(widget->codec, reg, mask, val);
2292         if (change) {
2293                 for (wi = 0; wi < wlist->num_widgets; wi++) {
2294                         widget = wlist->widgets[wi];
2295
2296                         widget->value = val;
2297
2298                         update.kcontrol = kcontrol;
2299                         update.widget = widget;
2300                         update.reg = reg;
2301                         update.mask = mask;
2302                         update.val = val;
2303                         widget->dapm->update = &update;
2304
2305                         dapm_mixer_update_power(widget, kcontrol, connect);
2306
2307                         widget->dapm->update = NULL;
2308                 }
2309         }
2310
2311         mutex_unlock(&codec->mutex);
2312         return 0;
2313 }
2314 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
2315
2316 /**
2317  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
2318  * @kcontrol: mixer control
2319  * @ucontrol: control element information
2320  *
2321  * Callback to get the value of a dapm enumerated double mixer control.
2322  *
2323  * Returns 0 for success.
2324  */
2325 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
2326         struct snd_ctl_elem_value *ucontrol)
2327 {
2328         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2329         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2330         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2331         unsigned int val, bitmask;
2332
2333         for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2334                 ;
2335         val = snd_soc_read(widget->codec, e->reg);
2336         ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
2337         if (e->shift_l != e->shift_r)
2338                 ucontrol->value.enumerated.item[1] =
2339                         (val >> e->shift_r) & (bitmask - 1);
2340
2341         return 0;
2342 }
2343 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2344
2345 /**
2346  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2347  * @kcontrol: mixer control
2348  * @ucontrol: control element information
2349  *
2350  * Callback to set the value of a dapm enumerated double mixer control.
2351  *
2352  * Returns 0 for success.
2353  */
2354 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2355         struct snd_ctl_elem_value *ucontrol)
2356 {
2357         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2358         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2359         struct snd_soc_codec *codec = widget->codec;
2360         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2361         unsigned int val, mux, change;
2362         unsigned int mask, bitmask;
2363         struct snd_soc_dapm_update update;
2364         int wi;
2365
2366         for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2367                 ;
2368         if (ucontrol->value.enumerated.item[0] > e->max - 1)
2369                 return -EINVAL;
2370         mux = ucontrol->value.enumerated.item[0];
2371         val = mux << e->shift_l;
2372         mask = (bitmask - 1) << e->shift_l;
2373         if (e->shift_l != e->shift_r) {
2374                 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2375                         return -EINVAL;
2376                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2377                 mask |= (bitmask - 1) << e->shift_r;
2378         }
2379
2380         mutex_lock(&codec->mutex);
2381
2382         change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
2383         if (change) {
2384                 for (wi = 0; wi < wlist->num_widgets; wi++) {
2385                         widget = wlist->widgets[wi];
2386
2387                         widget->value = val;
2388
2389                         update.kcontrol = kcontrol;
2390                         update.widget = widget;
2391                         update.reg = e->reg;
2392                         update.mask = mask;
2393                         update.val = val;
2394                         widget->dapm->update = &update;
2395
2396                         dapm_mux_update_power(widget, kcontrol, change, mux, e);
2397
2398                         widget->dapm->update = NULL;
2399                 }
2400         }
2401
2402         mutex_unlock(&codec->mutex);
2403         return change;
2404 }
2405 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2406
2407 /**
2408  * snd_soc_dapm_get_enum_virt - Get virtual DAPM mux
2409  * @kcontrol: mixer control
2410  * @ucontrol: control element information
2411  *
2412  * Returns 0 for success.
2413  */
2414 int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
2415                                struct snd_ctl_elem_value *ucontrol)
2416 {
2417         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2418         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2419
2420         ucontrol->value.enumerated.item[0] = widget->value;
2421
2422         return 0;
2423 }
2424 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
2425
2426 /**
2427  * snd_soc_dapm_put_enum_virt - Set virtual DAPM mux
2428  * @kcontrol: mixer control
2429  * @ucontrol: control element information
2430  *
2431  * Returns 0 for success.
2432  */
2433 int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
2434                                struct snd_ctl_elem_value *ucontrol)
2435 {
2436         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2437         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2438         struct snd_soc_codec *codec = widget->codec;
2439         struct soc_enum *e =
2440                 (struct soc_enum *)kcontrol->private_value;
2441         int change;
2442         int ret = 0;
2443         int wi;
2444
2445         if (ucontrol->value.enumerated.item[0] >= e->max)
2446                 return -EINVAL;
2447
2448         mutex_lock(&codec->mutex);
2449
2450         change = widget->value != ucontrol->value.enumerated.item[0];
2451         if (change) {
2452                 for (wi = 0; wi < wlist->num_widgets; wi++) {
2453                         widget = wlist->widgets[wi];
2454
2455                         widget->value = ucontrol->value.enumerated.item[0];
2456
2457                         dapm_mux_update_power(widget, kcontrol, change,
2458                                               widget->value, e);
2459                 }
2460         }
2461
2462         mutex_unlock(&codec->mutex);
2463         return ret;
2464 }
2465 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
2466
2467 /**
2468  * snd_soc_dapm_get_value_enum_double - dapm semi enumerated double mixer get
2469  *                                      callback
2470  * @kcontrol: mixer control
2471  * @ucontrol: control element information
2472  *
2473  * Callback to get the value of a dapm semi enumerated double mixer control.
2474  *
2475  * Semi enumerated mixer: the enumerated items are referred as values. Can be
2476  * used for handling bitfield coded enumeration for example.
2477  *
2478  * Returns 0 for success.
2479  */
2480 int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
2481         struct snd_ctl_elem_value *ucontrol)
2482 {
2483         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2484         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2485         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2486         unsigned int reg_val, val, mux;
2487
2488         reg_val = snd_soc_read(widget->codec, e->reg);
2489         val = (reg_val >> e->shift_l) & e->mask;
2490         for (mux = 0; mux < e->max; mux++) {
2491                 if (val == e->values[mux])
2492                         break;
2493         }
2494         ucontrol->value.enumerated.item[0] = mux;
2495         if (e->shift_l != e->shift_r) {
2496                 val = (reg_val >> e->shift_r) & e->mask;
2497                 for (mux = 0; mux < e->max; mux++) {
2498                         if (val == e->values[mux])
2499                                 break;
2500                 }
2501                 ucontrol->value.enumerated.item[1] = mux;
2502         }
2503
2504         return 0;
2505 }
2506 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_value_enum_double);
2507
2508 /**
2509  * snd_soc_dapm_put_value_enum_double - dapm semi enumerated double mixer set
2510  *                                      callback
2511  * @kcontrol: mixer control
2512  * @ucontrol: control element information
2513  *
2514  * Callback to set the value of a dapm semi enumerated double mixer control.
2515  *
2516  * Semi enumerated mixer: the enumerated items are referred as values. Can be
2517  * used for handling bitfield coded enumeration for example.
2518  *
2519  * Returns 0 for success.
2520  */
2521 int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
2522         struct snd_ctl_elem_value *ucontrol)
2523 {
2524         struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2525         struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2526         struct snd_soc_codec *codec = widget->codec;
2527         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2528         unsigned int val, mux, change;
2529         unsigned int mask;
2530         struct snd_soc_dapm_update update;
2531         int wi;
2532
2533         if (ucontrol->value.enumerated.item[0] > e->max - 1)
2534                 return -EINVAL;
2535         mux = ucontrol->value.enumerated.item[0];
2536         val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2537         mask = e->mask << e->shift_l;
2538         if (e->shift_l != e->shift_r) {
2539                 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2540                         return -EINVAL;
2541                 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2542                 mask |= e->mask << e->shift_r;
2543         }
2544
2545         mutex_lock(&codec->mutex);
2546
2547         change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
2548         if (change) {
2549                 for (wi = 0; wi < wlist->num_widgets; wi++) {
2550                         widget = wlist->widgets[wi];
2551
2552                         widget->value = val;
2553
2554                         update.kcontrol = kcontrol;
2555                         update.widget = widget;
2556                         update.reg = e->reg;
2557                         update.mask = mask;
2558                         update.val = val;
2559                         widget->dapm->update = &update;
2560
2561                         dapm_mux_update_power(widget, kcontrol, change, mux, e);
2562
2563                         widget->dapm->update = NULL;
2564                 }
2565         }
2566
2567         mutex_unlock(&codec->mutex);
2568         return change;
2569 }
2570 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
2571
2572 /**
2573  * snd_soc_dapm_info_pin_switch - Info for a pin switch
2574  *
2575  * @kcontrol: mixer control
2576  * @uinfo: control element information
2577  *
2578  * Callback to provide information about a pin switch control.
2579  */
2580 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
2581                                  struct snd_ctl_elem_info *uinfo)
2582 {
2583         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2584         uinfo->count = 1;
2585         uinfo->value.integer.min = 0;
2586         uinfo->value.integer.max = 1;
2587
2588         return 0;
2589 }
2590 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
2591
2592 /**
2593  * snd_soc_dapm_get_pin_switch - Get information for a pin switch
2594  *
2595  * @kcontrol: mixer control
2596  * @ucontrol: Value
2597  */
2598 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
2599                                 struct snd_ctl_elem_value *ucontrol)
2600 {
2601         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2602         const char *pin = (const char *)kcontrol->private_value;
2603
2604         mutex_lock(&codec->mutex);
2605
2606         ucontrol->value.integer.value[0] =
2607                 snd_soc_dapm_get_pin_status(&codec->dapm, pin);
2608
2609         mutex_unlock(&codec->mutex);
2610
2611         return 0;
2612 }
2613 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
2614
2615 /**
2616  * snd_soc_dapm_put_pin_switch - Set information for a pin switch
2617  *
2618  * @kcontrol: mixer control
2619  * @ucontrol: Value
2620  */
2621 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
2622                                 struct snd_ctl_elem_value *ucontrol)
2623 {
2624         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2625         const char *pin = (const char *)kcontrol->private_value;
2626
2627         mutex_lock(&codec->mutex);
2628
2629         if (ucontrol->value.integer.value[0])
2630                 snd_soc_dapm_enable_pin(&codec->dapm, pin);
2631         else
2632                 snd_soc_dapm_disable_pin(&codec->dapm, pin);
2633
2634         snd_soc_dapm_sync(&codec->dapm);
2635
2636         mutex_unlock(&codec->mutex);
2637
2638         return 0;
2639 }
2640 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
2641
2642 /**
2643  * snd_soc_dapm_new_control - create new dapm control
2644  * @dapm: DAPM context
2645  * @widget: widget template
2646  *
2647  * Creates a new dapm control based upon the template.
2648  *
2649  * Returns 0 for success else error.
2650  */
2651 int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
2652         const struct snd_soc_dapm_widget *widget)
2653 {
2654         struct snd_soc_dapm_widget *w;
2655         size_t name_len;
2656
2657         if ((w = dapm_cnew_widget(widget)) == NULL)
2658                 return -ENOMEM;
2659
2660         name_len = strlen(widget->name) + 1;
2661         if (dapm->codec && dapm->codec->name_prefix)
2662                 name_len += 1 + strlen(dapm->codec->name_prefix);
2663         w->name = kmalloc(name_len, GFP_KERNEL);
2664         if (w->name == NULL) {
2665                 kfree(w);
2666                 return -ENOMEM;
2667         }
2668         if (dapm->codec && dapm->codec->name_prefix)
2669                 snprintf(w->name, name_len, "%s %s",
2670                         dapm->codec->name_prefix, widget->name);
2671         else
2672                 snprintf(w->name, name_len, "%s", widget->name);
2673
2674         switch (w->id) {
2675         case snd_soc_dapm_switch:
2676         case snd_soc_dapm_mixer:
2677         case snd_soc_dapm_mixer_named_ctl:
2678                 w->power_check = dapm_generic_check_power;
2679                 break;
2680         case snd_soc_dapm_mux:
2681         case snd_soc_dapm_virt_mux:
2682         case snd_soc_dapm_value_mux:
2683                 w->power_check = dapm_generic_check_power;
2684                 break;
2685         case snd_soc_dapm_adc:
2686         case snd_soc_dapm_aif_out:
2687                 w->power_check = dapm_adc_check_power;
2688                 break;
2689         case snd_soc_dapm_dac:
2690         case snd_soc_dapm_aif_in:
2691                 w->power_check = dapm_dac_check_power;
2692                 break;
2693         case snd_soc_dapm_pga:
2694         case snd_soc_dapm_out_drv:
2695         case snd_soc_dapm_input:
2696         case snd_soc_dapm_output:
2697         case snd_soc_dapm_micbias:
2698         case snd_soc_dapm_spk:
2699         case snd_soc_dapm_hp:
2700         case snd_soc_dapm_mic:
2701         case snd_soc_dapm_line:
2702                 w->power_check = dapm_generic_check_power;
2703                 break;
2704         case snd_soc_dapm_supply:
2705                 w->power_check = dapm_supply_check_power;
2706                 break;
2707         default:
2708                 w->power_check = dapm_always_on_check_power;
2709                 break;
2710         }
2711
2712         dapm->n_widgets++;
2713         w->dapm = dapm;
2714         w->codec = dapm->codec;
2715         w->platform = dapm->platform;
2716         INIT_LIST_HEAD(&w->sources);
2717         INIT_LIST_HEAD(&w->sinks);
2718         INIT_LIST_HEAD(&w->list);
2719         INIT_LIST_HEAD(&w->dirty);
2720         list_add(&w->list, &dapm->card->widgets);
2721
2722         /* machine layer set ups unconnected pins and insertions */
2723         w->connected = 1;
2724         return 0;
2725 }
2726 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
2727
2728 /**
2729  * snd_soc_dapm_new_controls - create new dapm controls
2730  * @dapm: DAPM context
2731  * @widget: widget array
2732  * @num: number of widgets
2733  *
2734  * Creates new DAPM controls based upon the templates.
2735  *
2736  * Returns 0 for success else error.
2737  */
2738 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
2739         const struct snd_soc_dapm_widget *widget,
2740         int num)
2741 {
2742         int i, ret;
2743
2744         for (i = 0; i < num; i++) {
2745                 ret = snd_soc_dapm_new_control(dapm, widget);
2746                 if (ret < 0) {
2747                         dev_err(dapm->dev,
2748                                 "ASoC: Failed to create DAPM control %s: %d\n",
2749                                 widget->name, ret);
2750                         return ret;
2751                 }
2752                 widget++;
2753         }
2754         return 0;
2755 }
2756 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
2757
2758 static void soc_dapm_stream_event(struct snd_soc_dapm_context *dapm,
2759         const char *stream, int event)
2760 {
2761         struct snd_soc_dapm_widget *w;
2762
2763         list_for_each_entry(w, &dapm->card->widgets, list)
2764         {
2765                 if (!w->sname || w->dapm != dapm)
2766                         continue;
2767                 dev_vdbg(w->dapm->dev, "widget %s\n %s stream %s event %d\n",
2768                         w->name, w->sname, stream, event);
2769                 if (strstr(w->sname, stream)) {
2770                         dapm_mark_dirty(w, "stream event");
2771                         switch(event) {
2772                         case SND_SOC_DAPM_STREAM_START:
2773                                 w->active = 1;
2774                                 break;
2775                         case SND_SOC_DAPM_STREAM_STOP:
2776                                 w->active = 0;
2777                                 break;
2778                         case SND_SOC_DAPM_STREAM_SUSPEND:
2779                         case SND_SOC_DAPM_STREAM_RESUME:
2780                         case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
2781                         case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
2782                                 break;
2783                         }
2784                 }
2785         }
2786
2787         dapm_power_widgets(dapm, event);
2788
2789         /* do we need to notify any clients that DAPM stream is complete */
2790         if (dapm->stream_event)
2791                 dapm->stream_event(dapm, event);
2792 }
2793
2794 /**
2795  * snd_soc_dapm_stream_event - send a stream event to the dapm core
2796  * @rtd: PCM runtime data
2797  * @stream: stream name
2798  * @event: stream event
2799  *
2800  * Sends a stream event to the dapm core. The core then makes any
2801  * necessary widget power changes.
2802  *
2803  * Returns 0 for success else error.
2804  */
2805 int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
2806         const char *stream, int event)
2807 {
2808         struct snd_soc_codec *codec = rtd->codec;
2809
2810         if (stream == NULL)
2811                 return 0;
2812
2813         mutex_lock(&codec->mutex);
2814         soc_dapm_stream_event(&codec->dapm, stream, event);
2815         mutex_unlock(&codec->mutex);
2816         return 0;
2817 }
2818
2819 /**
2820  * snd_soc_dapm_enable_pin - enable pin.
2821  * @dapm: DAPM context
2822  * @pin: pin name
2823  *
2824  * Enables input/output pin and its parents or children widgets iff there is
2825  * a valid audio route and active audio stream.
2826  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2827  * do any widget power switching.
2828  */
2829 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2830 {
2831         return snd_soc_dapm_set_pin(dapm, pin, 1);
2832 }
2833 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
2834
2835 /**
2836  * snd_soc_dapm_force_enable_pin - force a pin to be enabled
2837  * @dapm: DAPM context
2838  * @pin: pin name
2839  *
2840  * Enables input/output pin regardless of any other state.  This is
2841  * intended for use with microphone bias supplies used in microphone
2842  * jack detection.
2843  *
2844  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2845  * do any widget power switching.
2846  */
2847 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
2848                                   const char *pin)
2849 {
2850         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2851
2852         if (!w) {
2853                 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2854                 return -EINVAL;
2855         }
2856
2857         dev_dbg(w->dapm->dev, "dapm: force enable pin %s\n", pin);
2858         w->connected = 1;
2859         w->force = 1;
2860         dapm_mark_dirty(w, "force enable");
2861
2862         return 0;
2863 }
2864 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
2865
2866 /**
2867  * snd_soc_dapm_disable_pin - disable pin.
2868  * @dapm: DAPM context
2869  * @pin: pin name
2870  *
2871  * Disables input/output pin and its parents or children widgets.
2872  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2873  * do any widget power switching.
2874  */
2875 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
2876                              const char *pin)
2877 {
2878         return snd_soc_dapm_set_pin(dapm, pin, 0);
2879 }
2880 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2881
2882 /**
2883  * snd_soc_dapm_nc_pin - permanently disable pin.
2884  * @dapm: DAPM context
2885  * @pin: pin name
2886  *
2887  * Marks the specified pin as being not connected, disabling it along
2888  * any parent or child widgets.  At present this is identical to
2889  * snd_soc_dapm_disable_pin() but in future it will be extended to do
2890  * additional things such as disabling controls which only affect
2891  * paths through the pin.
2892  *
2893  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2894  * do any widget power switching.
2895  */
2896 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2897 {
2898         return snd_soc_dapm_set_pin(dapm, pin, 0);
2899 }
2900 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
2901
2902 /**
2903  * snd_soc_dapm_get_pin_status - get audio pin status
2904  * @dapm: DAPM context
2905  * @pin: audio signal pin endpoint (or start point)
2906  *
2907  * Get audio pin status - connected or disconnected.
2908  *
2909  * Returns 1 for connected otherwise 0.
2910  */
2911 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
2912                                 const char *pin)
2913 {
2914         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2915
2916         if (w)
2917                 return w->connected;
2918
2919         return 0;
2920 }
2921 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
2922
2923 /**
2924  * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
2925  * @dapm: DAPM context
2926  * @pin: audio signal pin endpoint (or start point)
2927  *
2928  * Mark the given endpoint or pin as ignoring suspend.  When the
2929  * system is disabled a path between two endpoints flagged as ignoring
2930  * suspend will not be disabled.  The path must already be enabled via
2931  * normal means at suspend time, it will not be turned on if it was not
2932  * already enabled.
2933  */
2934 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
2935                                 const char *pin)
2936 {
2937         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
2938
2939         if (!w) {
2940                 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2941                 return -EINVAL;
2942         }
2943
2944         w->ignore_suspend = 1;
2945
2946         return 0;
2947 }
2948 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
2949
2950 /**
2951  * snd_soc_dapm_free - free dapm resources
2952  * @dapm: DAPM context
2953  *
2954  * Free all dapm widgets and resources.
2955  */
2956 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
2957 {
2958         snd_soc_dapm_sys_remove(dapm->dev);
2959         dapm_debugfs_cleanup(dapm);
2960         dapm_free_widgets(dapm);
2961         list_del(&dapm->list);
2962 }
2963 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
2964
2965 static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
2966 {
2967         struct snd_soc_dapm_widget *w;
2968         LIST_HEAD(down_list);
2969         int powerdown = 0;
2970
2971         list_for_each_entry(w, &dapm->card->widgets, list) {
2972                 if (w->dapm != dapm)
2973                         continue;
2974                 if (w->power) {
2975                         dapm_seq_insert(w, &down_list, false);
2976                         w->power = 0;
2977                         powerdown = 1;
2978                 }
2979         }
2980
2981         /* If there were no widgets to power down we're already in
2982          * standby.
2983          */
2984         if (powerdown) {
2985                 snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_PREPARE);
2986                 dapm_seq_run(dapm, &down_list, 0, false);
2987                 snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_STANDBY);
2988         }
2989 }
2990
2991 /*
2992  * snd_soc_dapm_shutdown - callback for system shutdown
2993  */
2994 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
2995 {
2996         struct snd_soc_codec *codec;
2997
2998         list_for_each_entry(codec, &card->codec_dev_list, list) {
2999                 soc_dapm_shutdown_codec(&codec->dapm);
3000                 snd_soc_dapm_set_bias_level(&codec->dapm, SND_SOC_BIAS_OFF);
3001         }
3002 }
3003
3004 /* Module information */
3005 MODULE_AUTHOR("Liam Girdwood, [email protected]");
3006 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
3007 MODULE_LICENSE("GPL");