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