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