sound/soc/soc-dapm.c

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