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