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