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