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