sound/soc/soc-dapm.c

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