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