Pileus Git - ~andy/linux/blob - sound/soc/soc-dapm.c

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