sound/soc/soc-dapm.c

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