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/meadphone 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 powerdown of audio susbsystem to reduce pops between a quick
  22  *      device reopen.
  23  *
  24  *  Todo:
  25  *    o DAPM power change sequencing - allow for configurable per
  26  *      codec sequences.
  27  *    o Support for analogue bias optimisation.
  28  *    o Support for reduced codec oversampling rates.
  29  *    o Support for reduced codec bias currents.
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/moduleparam.h>
  34 #include <linux/init.h>
  35 #include <linux/delay.h>
  36 #include <linux/pm.h>
  37 #include <linux/bitops.h>
  38 #include <linux/platform_device.h>
  39 #include <linux/jiffies.h>
  40 #include <linux/debugfs.h>
  41 #include <linux/slab.h>
  42 #include <sound/core.h>
  43 #include <sound/pcm.h>
  44 #include <sound/pcm_params.h>
  45 #include <sound/soc.h>
  46 #include <sound/soc-dapm.h>
  47 #include <sound/initval.h>
  48
  49 #include <trace/events/asoc.h>
  50
  51 /* dapm power sequences - make this per codec in the future */
  52 static int dapm_up_seq[] = {
  53         [snd_soc_dapm_pre] = 0,
  54         [snd_soc_dapm_supply] = 1,
  55         [snd_soc_dapm_micbias] = 2,
  56         [snd_soc_dapm_aif_in] = 3,
  57         [snd_soc_dapm_aif_out] = 3,
  58         [snd_soc_dapm_mic] = 4,
  59         [snd_soc_dapm_mux] = 5,
  60         [snd_soc_dapm_value_mux] = 5,
  61         [snd_soc_dapm_dac] = 6,
  62         [snd_soc_dapm_mixer] = 7,
  63         [snd_soc_dapm_mixer_named_ctl] = 7,
  64         [snd_soc_dapm_pga] = 8,
  65         [snd_soc_dapm_adc] = 9,
  66         [snd_soc_dapm_hp] = 10,
  67         [snd_soc_dapm_spk] = 10,
  68         [snd_soc_dapm_post] = 11,
  69 };
  70
  71 static int dapm_down_seq[] = {
  72         [snd_soc_dapm_pre] = 0,
  73         [snd_soc_dapm_adc] = 1,
  74         [snd_soc_dapm_hp] = 2,
  75         [snd_soc_dapm_spk] = 2,
  76         [snd_soc_dapm_pga] = 4,
  77         [snd_soc_dapm_mixer_named_ctl] = 5,
  78         [snd_soc_dapm_mixer] = 5,
  79         [snd_soc_dapm_dac] = 6,
  80         [snd_soc_dapm_mic] = 7,
  81         [snd_soc_dapm_micbias] = 8,
  82         [snd_soc_dapm_mux] = 9,
  83         [snd_soc_dapm_value_mux] = 9,
  84         [snd_soc_dapm_aif_in] = 10,
  85         [snd_soc_dapm_aif_out] = 10,
  86         [snd_soc_dapm_supply] = 11,
  87         [snd_soc_dapm_post] = 12,
  88 };
  89
  90 static void pop_wait(u32 pop_time)
  91 {
  92         if (pop_time)
  93                 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
  94 }
  95
  96 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
  97 {
  98         va_list args;
  99         char *buf;
 100
 101         if (!pop_time)
 102                 return;
 103
 104         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 105         if (buf == NULL)
 106                 return;
 107
 108         va_start(args, fmt);
 109         vsnprintf(buf, PAGE_SIZE, fmt, args);
 110         dev_info(dev, buf);
 111         va_end(args);
 112
 113         kfree(buf);
 114 }
 115
 116 /* create a new dapm widget */
 117 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
 118         const struct snd_soc_dapm_widget *_widget)
 119 {
 120         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
 121 }
 122
 123 /**
 124  * snd_soc_dapm_set_bias_level - set the bias level for the system
 125  * @card: audio device
 126  * @level: level to configure
 127  *
 128  * Configure the bias (power) levels for the SoC audio device.
 129  *
 130  * Returns 0 for success else error.
 131  */
 132 static int snd_soc_dapm_set_bias_level(struct snd_soc_card *card,
 133                                        struct snd_soc_dapm_context *dapm,
 134                                        enum snd_soc_bias_level level)
 135 {
 136         int ret = 0;
 137
 138         switch (level) {
 139         case SND_SOC_BIAS_ON:
 140                 dev_dbg(dapm->dev, "Setting full bias\n");
 141                 break;
 142         case SND_SOC_BIAS_PREPARE:
 143                 dev_dbg(dapm->dev, "Setting bias prepare\n");
 144                 break;
 145         case SND_SOC_BIAS_STANDBY:
 146                 dev_dbg(dapm->dev, "Setting standby bias\n");
 147                 break;
 148         case SND_SOC_BIAS_OFF:
 149                 dev_dbg(dapm->dev, "Setting bias off\n");
 150                 break;
 151         default:
 152                 dev_err(dapm->dev, "Setting invalid bias %d\n", level);
 153                 return -EINVAL;
 154         }
 155
 156         trace_snd_soc_bias_level_start(card, level);
 157
 158         if (card && card->set_bias_level)
 159                 ret = card->set_bias_level(card, level);
 160         if (ret == 0) {
 161                 if (dapm->codec && dapm->codec->driver->set_bias_level)
 162                         ret = dapm->codec->driver->set_bias_level(dapm->codec, level);
 163                 else
 164                         dapm->bias_level = level;
 165         }
 166
 167         trace_snd_soc_bias_level_done(card, level);
 168
 169         return ret;
 170 }
 171
 172 /* set up initial codec paths */
 173 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
 174         struct snd_soc_dapm_path *p, int i)
 175 {
 176         switch (w->id) {
 177         case snd_soc_dapm_switch:
 178         case snd_soc_dapm_mixer:
 179         case snd_soc_dapm_mixer_named_ctl: {
 180                 int val;
 181                 struct soc_mixer_control *mc = (struct soc_mixer_control *)
 182                         w->kcontrols[i].private_value;
 183                 unsigned int reg = mc->reg;
 184                 unsigned int shift = mc->shift;
 185                 int max = mc->max;
 186                 unsigned int mask = (1 << fls(max)) - 1;
 187                 unsigned int invert = mc->invert;
 188
 189                 val = snd_soc_read(w->codec, reg);
 190                 val = (val >> shift) & mask;
 191
 192                 if ((invert && !val) || (!invert && val))
 193                         p->connect = 1;
 194                 else
 195                         p->connect = 0;
 196         }
 197         break;
 198         case snd_soc_dapm_mux: {
 199                 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
 200                 int val, item, bitmask;
 201
 202                 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
 203                 ;
 204                 val = snd_soc_read(w->codec, e->reg);
 205                 item = (val >> e->shift_l) & (bitmask - 1);
 206
 207                 p->connect = 0;
 208                 for (i = 0; i < e->max; i++) {
 209                         if (!(strcmp(p->name, e->texts[i])) && item == i)
 210                                 p->connect = 1;
 211                 }
 212         }
 213         break;
 214         case snd_soc_dapm_value_mux: {
 215                 struct soc_enum *e = (struct soc_enum *)
 216                         w->kcontrols[i].private_value;
 217                 int val, item;
 218
 219                 val = snd_soc_read(w->codec, e->reg);
 220                 val = (val >> e->shift_l) & e->mask;
 221                 for (item = 0; item < e->max; item++) {
 222                         if (val == e->values[item])
 223                                 break;
 224                 }
 225
 226                 p->connect = 0;
 227                 for (i = 0; i < e->max; i++) {
 228                         if (!(strcmp(p->name, e->texts[i])) && item == i)
 229                                 p->connect = 1;
 230                 }
 231         }
 232         break;
 233         /* does not effect routing - always connected */
 234         case snd_soc_dapm_pga:
 235         case snd_soc_dapm_output:
 236         case snd_soc_dapm_adc:
 237         case snd_soc_dapm_input:
 238         case snd_soc_dapm_dac:
 239         case snd_soc_dapm_micbias:
 240         case snd_soc_dapm_vmid:
 241         case snd_soc_dapm_supply:
 242         case snd_soc_dapm_aif_in:
 243         case snd_soc_dapm_aif_out:
 244                 p->connect = 1;
 245         break;
 246         /* does effect routing - dynamically connected */
 247         case snd_soc_dapm_hp:
 248         case snd_soc_dapm_mic:
 249         case snd_soc_dapm_spk:
 250         case snd_soc_dapm_line:
 251         case snd_soc_dapm_pre:
 252         case snd_soc_dapm_post:
 253                 p->connect = 0;
 254         break;
 255         }
 256 }
 257
 258 /* connect mux widget to its interconnecting audio paths */
 259 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
 260         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 261         struct snd_soc_dapm_path *path, const char *control_name,
 262         const struct snd_kcontrol_new *kcontrol)
 263 {
 264         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 265         int i;
 266
 267         for (i = 0; i < e->max; i++) {
 268                 if (!(strcmp(control_name, e->texts[i]))) {
 269                         list_add(&path->list, &dapm->paths);
 270                         list_add(&path->list_sink, &dest->sources);
 271                         list_add(&path->list_source, &src->sinks);
 272                         path->name = (char*)e->texts[i];
 273                         dapm_set_path_status(dest, path, 0);
 274                         return 0;
 275                 }
 276         }
 277
 278         return -ENODEV;
 279 }
 280
 281 /* connect mixer widget to its interconnecting audio paths */
 282 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
 283         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
 284         struct snd_soc_dapm_path *path, const char *control_name)
 285 {
 286         int i;
 287
 288         /* search for mixer kcontrol */
 289         for (i = 0; i < dest->num_kcontrols; i++) {
 290                 if (!strcmp(control_name, dest->kcontrols[i].name)) {
 291                         list_add(&path->list, &dapm->paths);
 292                         list_add(&path->list_sink, &dest->sources);
 293                         list_add(&path->list_source, &src->sinks);
 294                         path->name = dest->kcontrols[i].name;
 295                         dapm_set_path_status(dest, path, i);
 296                         return 0;
 297                 }
 298         }
 299         return -ENODEV;
 300 }
 301
 302 /* update dapm codec register bits */
 303 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
 304 {
 305         int change, power;
 306         unsigned int old, new;
 307         struct snd_soc_codec *codec = widget->codec;
 308         struct snd_soc_dapm_context *dapm = widget->dapm;
 309         struct snd_soc_card *card = dapm->card;
 310
 311         /* check for valid widgets */
 312         if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
 313                 widget->id == snd_soc_dapm_output ||
 314                 widget->id == snd_soc_dapm_hp ||
 315                 widget->id == snd_soc_dapm_mic ||
 316                 widget->id == snd_soc_dapm_line ||
 317                 widget->id == snd_soc_dapm_spk)
 318                 return 0;
 319
 320         power = widget->power;
 321         if (widget->invert)
 322                 power = (power ? 0:1);
 323
 324         old = snd_soc_read(codec, widget->reg);
 325         new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
 326
 327         change = old != new;
 328         if (change) {
 329                 pop_dbg(dapm->dev, card->pop_time,
 330                         "pop test %s : %s in %d ms\n",
 331                         widget->name, widget->power ? "on" : "off",
 332                         card->pop_time);
 333                 pop_wait(card->pop_time);
 334                 snd_soc_write(codec, widget->reg, new);
 335         }
 336         dev_dbg(dapm->dev, "reg %x old %x new %x change %d\n", widget->reg,
 337                 old, new, change);
 338         return change;
 339 }
 340
 341 /* create new dapm mixer control */
 342 static int dapm_new_mixer(struct snd_soc_dapm_context *dapm,
 343         struct snd_soc_dapm_widget *w)
 344 {
 345         int i, ret = 0;
 346         size_t name_len;
 347         struct snd_soc_dapm_path *path;
 348         struct snd_card *card = dapm->codec->card->snd_card;
 349
 350         /* add kcontrol */
 351         for (i = 0; i < w->num_kcontrols; i++) {
 352
 353                 /* match name */
 354                 list_for_each_entry(path, &w->sources, list_sink) {
 355
 356                         /* mixer/mux paths name must match control name */
 357                         if (path->name != (char*)w->kcontrols[i].name)
 358                                 continue;
 359
 360                         /* add dapm control with long name.
 361                          * for dapm_mixer this is the concatenation of the
 362                          * mixer and kcontrol name.
 363                          * for dapm_mixer_named_ctl this is simply the
 364                          * kcontrol name.
 365                          */
 366                         name_len = strlen(w->kcontrols[i].name) + 1;
 367                         if (w->id != snd_soc_dapm_mixer_named_ctl)
 368                                 name_len += 1 + strlen(w->name);
 369
 370                         path->long_name = kmalloc(name_len, GFP_KERNEL);
 371
 372                         if (path->long_name == NULL)
 373                                 return -ENOMEM;
 374
 375                         switch (w->id) {
 376                         default:
 377                                 snprintf(path->long_name, name_len, "%s %s",
 378                                          w->name, w->kcontrols[i].name);
 379                                 break;
 380                         case snd_soc_dapm_mixer_named_ctl:
 381                                 snprintf(path->long_name, name_len, "%s",
 382                                          w->kcontrols[i].name);
 383                                 break;
 384                         }
 385
 386                         path->long_name[name_len - 1] = '\0';
 387
 388                         path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
 389                                 path->long_name);
 390                         ret = snd_ctl_add(card, path->kcontrol);
 391                         if (ret < 0) {
 392                                 dev_err(dapm->dev,
 393                                         "asoc: failed to add dapm kcontrol %s: %d\n",
 394                                         path->long_name, ret);
 395                                 kfree(path->long_name);
 396                                 path->long_name = NULL;
 397                                 return ret;
 398                         }
 399                 }
 400         }
 401         return ret;
 402 }
 403
 404 /* create new dapm mux control */
 405 static int dapm_new_mux(struct snd_soc_dapm_context *dapm,
 406         struct snd_soc_dapm_widget *w)
 407 {
 408         struct snd_soc_dapm_path *path = NULL;
 409         struct snd_kcontrol *kcontrol;
 410         struct snd_card *card = dapm->codec->card->snd_card;
 411         int ret = 0;
 412
 413         if (!w->num_kcontrols) {
 414                 dev_err(dapm->dev, "asoc: mux %s has no controls\n", w->name);
 415                 return -EINVAL;
 416         }
 417
 418         kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
 419         ret = snd_ctl_add(card, kcontrol);
 420
 421         if (ret < 0)
 422                 goto err;
 423
 424         list_for_each_entry(path, &w->sources, list_sink)
 425                 path->kcontrol = kcontrol;
 426
 427         return ret;
 428
 429 err:
 430         dev_err(dapm->dev, "asoc: failed to add kcontrol %s\n", w->name);
 431         return ret;
 432 }
 433
 434 /* create new dapm volume control */
 435 static int dapm_new_pga(struct snd_soc_dapm_context *dapm,
 436         struct snd_soc_dapm_widget *w)
 437 {
 438         if (w->num_kcontrols)
 439                 dev_err(w->dapm->dev,
 440                         "asoc: PGA controls not supported: '%s'\n", w->name);
 441
 442         return 0;
 443 }
 444
 445 /* reset 'walked' bit for each dapm path */
 446 static inline void dapm_clear_walk(struct snd_soc_dapm_context *dapm)
 447 {
 448         struct snd_soc_dapm_path *p;
 449
 450         list_for_each_entry(p, &dapm->paths, list)
 451                 p->walked = 0;
 452 }
 453
 454 /* We implement power down on suspend by checking the power state of
 455  * the ALSA card - when we are suspending the ALSA state for the card
 456  * is set to D3.
 457  */
 458 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
 459 {
 460         int level = snd_power_get_state(widget->dapm->codec->card->snd_card);
 461
 462         switch (level) {
 463         case SNDRV_CTL_POWER_D3hot:
 464         case SNDRV_CTL_POWER_D3cold:
 465                 if (widget->ignore_suspend)
 466                         dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
 467                                 widget->name);
 468                 return widget->ignore_suspend;
 469         default:
 470                 return 1;
 471         }
 472 }
 473
 474 /*
 475  * Recursively check for a completed path to an active or physically connected
 476  * output widget. Returns number of complete paths.
 477  */
 478 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
 479 {
 480         struct snd_soc_dapm_path *path;
 481         int con = 0;
 482
 483         if (widget->id == snd_soc_dapm_supply)
 484                 return 0;
 485
 486         switch (widget->id) {
 487         case snd_soc_dapm_adc:
 488         case snd_soc_dapm_aif_out:
 489                 if (widget->active)
 490                         return snd_soc_dapm_suspend_check(widget);
 491         default:
 492                 break;
 493         }
 494
 495         if (widget->connected) {
 496                 /* connected pin ? */
 497                 if (widget->id == snd_soc_dapm_output && !widget->ext)
 498                         return snd_soc_dapm_suspend_check(widget);
 499
 500                 /* connected jack or spk ? */
 501                 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
 502                     (widget->id == snd_soc_dapm_line && !list_empty(&widget->sources)))
 503                         return snd_soc_dapm_suspend_check(widget);
 504         }
 505
 506         list_for_each_entry(path, &widget->sinks, list_source) {
 507                 if (path->walked)
 508                         continue;
 509
 510                 if (path->sink && path->connect) {
 511                         path->walked = 1;
 512                         con += is_connected_output_ep(path->sink);
 513                 }
 514         }
 515
 516         return con;
 517 }
 518
 519 /*
 520  * Recursively check for a completed path to an active or physically connected
 521  * input widget. Returns number of complete paths.
 522  */
 523 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
 524 {
 525         struct snd_soc_dapm_path *path;
 526         int con = 0;
 527
 528         if (widget->id == snd_soc_dapm_supply)
 529                 return 0;
 530
 531         /* active stream ? */
 532         switch (widget->id) {
 533         case snd_soc_dapm_dac:
 534         case snd_soc_dapm_aif_in:
 535                 if (widget->active)
 536                         return snd_soc_dapm_suspend_check(widget);
 537         default:
 538                 break;
 539         }
 540
 541         if (widget->connected) {
 542                 /* connected pin ? */
 543                 if (widget->id == snd_soc_dapm_input && !widget->ext)
 544                         return snd_soc_dapm_suspend_check(widget);
 545
 546                 /* connected VMID/Bias for lower pops */
 547                 if (widget->id == snd_soc_dapm_vmid)
 548                         return snd_soc_dapm_suspend_check(widget);
 549
 550                 /* connected jack ? */
 551                 if (widget->id == snd_soc_dapm_mic ||
 552                     (widget->id == snd_soc_dapm_line && !list_empty(&widget->sinks)))
 553                         return snd_soc_dapm_suspend_check(widget);
 554         }
 555
 556         list_for_each_entry(path, &widget->sources, list_sink) {
 557                 if (path->walked)
 558                         continue;
 559
 560                 if (path->source && path->connect) {
 561                         path->walked = 1;
 562                         con += is_connected_input_ep(path->source);
 563                 }
 564         }
 565
 566         return con;
 567 }
 568
 569 /*
 570  * Handler for generic register modifier widget.
 571  */
 572 int dapm_reg_event(struct snd_soc_dapm_widget *w,
 573                    struct snd_kcontrol *kcontrol, int event)
 574 {
 575         unsigned int val;
 576
 577         if (SND_SOC_DAPM_EVENT_ON(event))
 578                 val = w->on_val;
 579         else
 580                 val = w->off_val;
 581
 582         snd_soc_update_bits(w->codec, -(w->reg + 1),
 583                             w->mask << w->shift, val << w->shift);
 584
 585         return 0;
 586 }
 587 EXPORT_SYMBOL_GPL(dapm_reg_event);
 588
 589 /* Standard power change method, used to apply power changes to most
 590  * widgets.
 591  */
 592 static int dapm_generic_apply_power(struct snd_soc_dapm_widget *w)
 593 {
 594         int ret;
 595
 596         /* call any power change event handlers */
 597         if (w->event)
 598                 dev_dbg(w->dapm->dev, "power %s event for %s flags %x\n",
 599                          w->power ? "on" : "off",
 600                          w->name, w->event_flags);
 601
 602         /* power up pre event */
 603         if (w->power && w->event &&
 604             (w->event_flags & SND_SOC_DAPM_PRE_PMU)) {
 605                 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMU);
 606                 if (ret < 0)
 607                         return ret;
 608         }
 609
 610         /* power down pre event */
 611         if (!w->power && w->event &&
 612             (w->event_flags & SND_SOC_DAPM_PRE_PMD)) {
 613                 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMD);
 614                 if (ret < 0)
 615                         return ret;
 616         }
 617
 618         dapm_update_bits(w);
 619
 620         /* power up post event */
 621         if (w->power && w->event &&
 622             (w->event_flags & SND_SOC_DAPM_POST_PMU)) {
 623                 ret = w->event(w,
 624                                NULL, SND_SOC_DAPM_POST_PMU);
 625                 if (ret < 0)
 626                         return ret;
 627         }
 628
 629         /* power down post event */
 630         if (!w->power && w->event &&
 631             (w->event_flags & SND_SOC_DAPM_POST_PMD)) {
 632                 ret = w->event(w, NULL, SND_SOC_DAPM_POST_PMD);
 633                 if (ret < 0)
 634                         return ret;
 635         }
 636
 637         return 0;
 638 }
 639
 640 /* Generic check to see if a widget should be powered.
 641  */
 642 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
 643 {
 644         int in, out;
 645
 646         in = is_connected_input_ep(w);
 647         dapm_clear_walk(w->dapm);
 648         out = is_connected_output_ep(w);
 649         dapm_clear_walk(w->dapm);
 650         return out != 0 && in != 0;
 651 }
 652
 653 /* Check to see if an ADC has power */
 654 static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
 655 {
 656         int in;
 657
 658         if (w->active) {
 659                 in = is_connected_input_ep(w);
 660                 dapm_clear_walk(w->dapm);
 661                 return in != 0;
 662         } else {
 663                 return dapm_generic_check_power(w);
 664         }
 665 }
 666
 667 /* Check to see if a DAC has power */
 668 static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
 669 {
 670         int out;
 671
 672         if (w->active) {
 673                 out = is_connected_output_ep(w);
 674                 dapm_clear_walk(w->dapm);
 675                 return out != 0;
 676         } else {
 677                 return dapm_generic_check_power(w);
 678         }
 679 }
 680
 681 /* Check to see if a power supply is needed */
 682 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
 683 {
 684         struct snd_soc_dapm_path *path;
 685         int power = 0;
 686
 687         /* Check if one of our outputs is connected */
 688         list_for_each_entry(path, &w->sinks, list_source) {
 689                 if (path->connected &&
 690                     !path->connected(path->source, path->sink))
 691                         continue;
 692
 693                 if (path->sink && path->sink->power_check &&
 694                     path->sink->power_check(path->sink)) {
 695                         power = 1;
 696                         break;
 697                 }
 698         }
 699
 700         dapm_clear_walk(w->dapm);
 701
 702         return power;
 703 }
 704
 705 static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
 706                             struct snd_soc_dapm_widget *b,
 707                             int sort[])
 708 {
 709         if (sort[a->id] != sort[b->id])
 710                 return sort[a->id] - sort[b->id];
 711         if (a->reg != b->reg)
 712                 return a->reg - b->reg;
 713         if (a->codec != b->codec)
 714                 return (unsigned long)a->codec - (unsigned long)b->codec;
 715
 716         return 0;
 717 }
 718
 719 /* Insert a widget in order into a DAPM power sequence. */
 720 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
 721                             struct list_head *list,
 722                             int sort[])
 723 {
 724         struct snd_soc_dapm_widget *w;
 725
 726         list_for_each_entry(w, list, power_list)
 727                 if (dapm_seq_compare(new_widget, w, sort) < 0) {
 728                         list_add_tail(&new_widget->power_list, &w->power_list);
 729                         return;
 730                 }
 731
 732         list_add_tail(&new_widget->power_list, list);
 733 }
 734
 735 static void dapm_seq_check_event(struct snd_soc_dapm_context *dapm,
 736                                  struct snd_soc_dapm_widget *w, int event)
 737 {
 738         struct snd_soc_card *card = dapm->card;
 739         const char *ev_name;
 740         int power, ret;
 741
 742         switch (event) {
 743         case SND_SOC_DAPM_PRE_PMU:
 744                 ev_name = "PRE_PMU";
 745                 power = 1;
 746                 break;
 747         case SND_SOC_DAPM_POST_PMU:
 748                 ev_name = "POST_PMU";
 749                 power = 1;
 750                 break;
 751         case SND_SOC_DAPM_PRE_PMD:
 752                 ev_name = "PRE_PMD";
 753                 power = 0;
 754                 break;
 755         case SND_SOC_DAPM_POST_PMD:
 756                 ev_name = "POST_PMD";
 757                 power = 0;
 758                 break;
 759         default:
 760                 BUG();
 761                 return;
 762         }
 763
 764         if (w->power != power)
 765                 return;
 766
 767         if (w->event && (w->event_flags & event)) {
 768                 pop_dbg(dapm->dev, card->pop_time, "pop test : %s %s\n",
 769                         w->name, ev_name);
 770                 trace_snd_soc_dapm_widget_event_start(w, event);
 771                 ret = w->event(w, NULL, event);
 772                 trace_snd_soc_dapm_widget_event_done(w, event);
 773                 if (ret < 0)
 774                         pr_err("%s: %s event failed: %d\n",
 775                                ev_name, w->name, ret);
 776         }
 777 }
 778
 779 /* Apply the coalesced changes from a DAPM sequence */
 780 static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
 781                                    struct list_head *pending)
 782 {
 783         struct snd_soc_card *card = dapm->card;
 784         struct snd_soc_dapm_widget *w;
 785         int reg, power;
 786         unsigned int value = 0;
 787         unsigned int mask = 0;
 788         unsigned int cur_mask;
 789
 790         reg = list_first_entry(pending, struct snd_soc_dapm_widget,
 791                                power_list)->reg;
 792
 793         list_for_each_entry(w, pending, power_list) {
 794                 cur_mask = 1 << w->shift;
 795                 BUG_ON(reg != w->reg);
 796
 797                 if (w->invert)
 798                         power = !w->power;
 799                 else
 800                         power = w->power;
 801
 802                 mask |= cur_mask;
 803                 if (power)
 804                         value |= cur_mask;
 805
 806                 pop_dbg(dapm->dev, card->pop_time,
 807                         "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
 808                         w->name, reg, value, mask);
 809
 810                 /* Check for events */
 811                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMU);
 812                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMD);
 813         }
 814
 815         if (reg >= 0) {
 816                 pop_dbg(dapm->dev, card->pop_time,
 817                         "pop test : Applying 0x%x/0x%x to %x in %dms\n",
 818                         value, mask, reg, card->pop_time);
 819                 pop_wait(card->pop_time);
 820                 snd_soc_update_bits(dapm->codec, reg, mask, value);
 821         }
 822
 823         list_for_each_entry(w, pending, power_list) {
 824                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMU);
 825                 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMD);
 826         }
 827 }
 828
 829 /* Apply a DAPM power sequence.
 830  *
 831  * We walk over a pre-sorted list of widgets to apply power to.  In
 832  * order to minimise the number of writes to the device required
 833  * multiple widgets will be updated in a single write where possible.
 834  * Currently anything that requires more than a single write is not
 835  * handled.
 836  */
 837 static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
 838                          struct list_head *list, int event, int sort[])
 839 {
 840         struct snd_soc_dapm_widget *w, *n;
 841         LIST_HEAD(pending);
 842         int cur_sort = -1;
 843         int cur_reg = SND_SOC_NOPM;
 844         int ret;
 845
 846         list_for_each_entry_safe(w, n, list, power_list) {
 847                 ret = 0;
 848
 849                 /* Do we need to apply any queued changes? */
 850                 if (sort[w->id] != cur_sort || w->reg != cur_reg) {
 851                         if (!list_empty(&pending))
 852                                 dapm_seq_run_coalesced(dapm, &pending);
 853
 854                         INIT_LIST_HEAD(&pending);
 855                         cur_sort = -1;
 856                         cur_reg = SND_SOC_NOPM;
 857                 }
 858
 859                 switch (w->id) {
 860                 case snd_soc_dapm_pre:
 861                         if (!w->event)
 862                                 list_for_each_entry_safe_continue(w, n, list,
 863                                                                   power_list);
 864
 865                         if (event == SND_SOC_DAPM_STREAM_START)
 866                                 ret = w->event(w,
 867                                                NULL, SND_SOC_DAPM_PRE_PMU);
 868                         else if (event == SND_SOC_DAPM_STREAM_STOP)
 869                                 ret = w->event(w,
 870                                                NULL, SND_SOC_DAPM_PRE_PMD);
 871                         break;
 872
 873                 case snd_soc_dapm_post:
 874                         if (!w->event)
 875                                 list_for_each_entry_safe_continue(w, n, list,
 876                                                                   power_list);
 877
 878                         if (event == SND_SOC_DAPM_STREAM_START)
 879                                 ret = w->event(w,
 880                                                NULL, SND_SOC_DAPM_POST_PMU);
 881                         else if (event == SND_SOC_DAPM_STREAM_STOP)
 882                                 ret = w->event(w,
 883                                                NULL, SND_SOC_DAPM_POST_PMD);
 884                         break;
 885
 886                 case snd_soc_dapm_input:
 887                 case snd_soc_dapm_output:
 888                 case snd_soc_dapm_hp:
 889                 case snd_soc_dapm_mic:
 890                 case snd_soc_dapm_line:
 891                 case snd_soc_dapm_spk:
 892                         /* No register support currently */
 893                         ret = dapm_generic_apply_power(w);
 894                         break;
 895
 896                 default:
 897                         /* Queue it up for application */
 898                         cur_sort = sort[w->id];
 899                         cur_reg = w->reg;
 900                         list_move(&w->power_list, &pending);
 901                         break;
 902                 }
 903
 904                 if (ret < 0)
 905                         dev_err(w->dapm->dev,
 906                                 "Failed to apply widget power: %d\n", ret);
 907         }
 908
 909         if (!list_empty(&pending))
 910                 dapm_seq_run_coalesced(dapm, &pending);
 911 }
 912
 913 /*
 914  * Scan each dapm widget for complete audio path.
 915  * A complete path is a route that has valid endpoints i.e.:-
 916  *
 917  *  o DAC to output pin.
 918  *  o Input Pin to ADC.
 919  *  o Input pin to Output pin (bypass, sidetone)
 920  *  o DAC to ADC (loopback).
 921  */
 922 static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
 923 {
 924         struct snd_soc_card *card = dapm->codec->card;
 925         struct snd_soc_dapm_widget *w;
 926         LIST_HEAD(up_list);
 927         LIST_HEAD(down_list);
 928         int ret = 0;
 929         int power;
 930         int sys_power = 0;
 931
 932         trace_snd_soc_dapm_start(card);
 933
 934         /* Check which widgets we need to power and store them in
 935          * lists indicating if they should be powered up or down.
 936          */
 937         list_for_each_entry(w, &dapm->widgets, list) {
 938                 switch (w->id) {
 939                 case snd_soc_dapm_pre:
 940                         dapm_seq_insert(w, &down_list, dapm_down_seq);
 941                         break;
 942                 case snd_soc_dapm_post:
 943                         dapm_seq_insert(w, &up_list, dapm_up_seq);
 944                         break;
 945
 946                 default:
 947                         if (!w->power_check)
 948                                 continue;
 949
 950                         if (!w->force)
 951                                 power = w->power_check(w);
 952                         else
 953                                 power = 1;
 954                         if (power)
 955                                 sys_power = 1;
 956
 957                         if (w->power == power)
 958                                 continue;
 959
 960                         trace_snd_soc_dapm_widget_power(w, power);
 961
 962                         if (power)
 963                                 dapm_seq_insert(w, &up_list, dapm_up_seq);
 964                         else
 965                                 dapm_seq_insert(w, &down_list, dapm_down_seq);
 966
 967                         w->power = power;
 968                         break;
 969                 }
 970         }
 971
 972         /* If there are no DAPM widgets then try to figure out power from the
 973          * event type.
 974          */
 975         if (list_empty(&dapm->widgets)) {
 976                 switch (event) {
 977                 case SND_SOC_DAPM_STREAM_START:
 978                 case SND_SOC_DAPM_STREAM_RESUME:
 979                         sys_power = 1;
 980                         break;
 981                 case SND_SOC_DAPM_STREAM_SUSPEND:
 982                         sys_power = 0;
 983                         break;
 984                 case SND_SOC_DAPM_STREAM_NOP:
 985                         switch (dapm->bias_level) {
 986                                 case SND_SOC_BIAS_STANDBY:
 987                                 case SND_SOC_BIAS_OFF:
 988                                         sys_power = 0;
 989                                         break;
 990                                 default:
 991                                         sys_power = 1;
 992                                         break;
 993                         }
 994                         break;
 995                 default:
 996                         break;
 997                 }
 998         }
 999
1000         if (sys_power && dapm->bias_level == SND_SOC_BIAS_OFF) {
1001                 ret = snd_soc_dapm_set_bias_level(card, dapm,
1002                                                   SND_SOC_BIAS_STANDBY);
1003                 if (ret != 0)
1004                         dev_err(dapm->dev,
1005                                 "Failed to turn on bias: %d\n", ret);
1006         }
1007
1008         /* If we're changing to all on or all off then prepare */
1009         if ((sys_power && dapm->bias_level == SND_SOC_BIAS_STANDBY) ||
1010             (!sys_power && dapm->bias_level == SND_SOC_BIAS_ON)) {
1011                 ret = snd_soc_dapm_set_bias_level(card, dapm, SND_SOC_BIAS_PREPARE);
1012                 if (ret != 0)
1013                         dev_err(dapm->dev,
1014                                 "Failed to prepare bias: %d\n", ret);
1015         }
1016
1017         /* Power down widgets first; try to avoid amplifying pops. */
1018         dapm_seq_run(dapm, &down_list, event, dapm_down_seq);
1019
1020         /* Now power up. */
1021         dapm_seq_run(dapm, &up_list, event, dapm_up_seq);
1022
1023         /* If we just powered the last thing off drop to standby bias */
1024         if (dapm->bias_level == SND_SOC_BIAS_PREPARE && !sys_power) {
1025                 ret = snd_soc_dapm_set_bias_level(card, dapm, SND_SOC_BIAS_STANDBY);
1026                 if (ret != 0)
1027                         dev_err(dapm->dev,
1028                                 "Failed to apply standby bias: %d\n", ret);
1029         }
1030
1031         /* If we're in standby and can support bias off then do that */
1032         if (dapm->bias_level == SND_SOC_BIAS_STANDBY &&
1033             dapm->idle_bias_off) {
1034                 ret = snd_soc_dapm_set_bias_level(card, dapm, SND_SOC_BIAS_OFF);
1035                 if (ret != 0)
1036                         dev_err(dapm->dev,
1037                                 "Failed to turn off bias: %d\n", ret);
1038         }
1039
1040         /* If we just powered up then move to active bias */
1041         if (dapm->bias_level == SND_SOC_BIAS_PREPARE && sys_power) {
1042                 ret = snd_soc_dapm_set_bias_level(card, dapm, SND_SOC_BIAS_ON);
1043                 if (ret != 0)
1044                         dev_err(dapm->dev,
1045                                 "Failed to apply active bias: %d\n", ret);
1046         }
1047
1048         pop_dbg(dapm->dev, card->pop_time,
1049                 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
1050         pop_wait(card->pop_time);
1051
1052         trace_snd_soc_dapm_done(card);
1053
1054         return 0;
1055 }
1056
1057 #ifdef CONFIG_DEBUG_FS
1058 static int dapm_widget_power_open_file(struct inode *inode, struct file *file)
1059 {
1060         file->private_data = inode->i_private;
1061         return 0;
1062 }
1063
1064 static ssize_t dapm_widget_power_read_file(struct file *file,
1065                                            char __user *user_buf,
1066                                            size_t count, loff_t *ppos)
1067 {
1068         struct snd_soc_dapm_widget *w = file->private_data;
1069         char *buf;
1070         int in, out;
1071         ssize_t ret;
1072         struct snd_soc_dapm_path *p = NULL;
1073
1074         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1075         if (!buf)
1076                 return -ENOMEM;
1077
1078         in = is_connected_input_ep(w);
1079         dapm_clear_walk(w->dapm);
1080         out = is_connected_output_ep(w);
1081         dapm_clear_walk(w->dapm);
1082
1083         ret = snprintf(buf, PAGE_SIZE, "%s: %s  in %d out %d",
1084                        w->name, w->power ? "On" : "Off", in, out);
1085
1086         if (w->reg >= 0)
1087                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1088                                 " - R%d(0x%x) bit %d",
1089                                 w->reg, w->reg, w->shift);
1090
1091         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1092
1093         if (w->sname)
1094                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1095                                 w->sname,
1096                                 w->active ? "active" : "inactive");
1097
1098         list_for_each_entry(p, &w->sources, list_sink) {
1099                 if (p->connected && !p->connected(w, p->sink))
1100                         continue;
1101
1102                 if (p->connect)
1103                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1104                                         " in  %s %s\n",
1105                                         p->name ? p->name : "static",
1106                                         p->source->name);
1107         }
1108         list_for_each_entry(p, &w->sinks, list_source) {
1109                 if (p->connected && !p->connected(w, p->sink))
1110                         continue;
1111
1112                 if (p->connect)
1113                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1114                                         " out %s %s\n",
1115                                         p->name ? p->name : "static",
1116                                         p->sink->name);
1117         }
1118
1119         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1120
1121         kfree(buf);
1122         return ret;
1123 }
1124
1125 static const struct file_operations dapm_widget_power_fops = {
1126         .open = dapm_widget_power_open_file,
1127         .read = dapm_widget_power_read_file,
1128         .llseek = default_llseek,
1129 };
1130
1131 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm)
1132 {
1133         struct snd_soc_dapm_widget *w;
1134         struct dentry *d;
1135
1136         if (!dapm->debugfs_dapm)
1137                 return;
1138
1139         list_for_each_entry(w, &dapm->widgets, list) {
1140                 if (!w->name)
1141                         continue;
1142
1143                 d = debugfs_create_file(w->name, 0444,
1144                                         dapm->debugfs_dapm, w,
1145                                         &dapm_widget_power_fops);
1146                 if (!d)
1147                         dev_warn(w->dapm->dev,
1148                                 "ASoC: Failed to create %s debugfs file\n",
1149                                 w->name);
1150         }
1151 }
1152 #else
1153 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm)
1154 {
1155 }
1156 #endif
1157
1158 /* test and update the power status of a mux widget */
1159 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
1160                                  struct snd_kcontrol *kcontrol, int change,
1161                                  int mux, struct soc_enum *e)
1162 {
1163         struct snd_soc_dapm_path *path;
1164         int found = 0;
1165
1166         if (widget->id != snd_soc_dapm_mux &&
1167             widget->id != snd_soc_dapm_value_mux)
1168                 return -ENODEV;
1169
1170         if (!change)
1171                 return 0;
1172
1173         /* find dapm widget path assoc with kcontrol */
1174         list_for_each_entry(path, &widget->dapm->paths, list) {
1175                 if (path->kcontrol != kcontrol)
1176                         continue;
1177
1178                 if (!path->name || !e->texts[mux])
1179                         continue;
1180
1181                 found = 1;
1182                 /* we now need to match the string in the enum to the path */
1183                 if (!(strcmp(path->name, e->texts[mux])))
1184                         path->connect = 1; /* new connection */
1185                 else
1186                         path->connect = 0; /* old connection must be powered down */
1187         }
1188
1189         if (found)
1190                 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1191
1192         return 0;
1193 }
1194
1195 /* test and update the power status of a mixer or switch widget */
1196 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
1197                                    struct snd_kcontrol *kcontrol, int connect)
1198 {
1199         struct snd_soc_dapm_path *path;
1200         int found = 0;
1201
1202         if (widget->id != snd_soc_dapm_mixer &&
1203             widget->id != snd_soc_dapm_mixer_named_ctl &&
1204             widget->id != snd_soc_dapm_switch)
1205                 return -ENODEV;
1206
1207         /* find dapm widget path assoc with kcontrol */
1208         list_for_each_entry(path, &widget->dapm->paths, list) {
1209                 if (path->kcontrol != kcontrol)
1210                         continue;
1211
1212                 /* found, now check type */
1213                 found = 1;
1214                 path->connect = connect;
1215                 break;
1216         }
1217
1218         if (found)
1219                 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1220
1221         return 0;
1222 }
1223
1224 /* show dapm widget status in sys fs */
1225 static ssize_t dapm_widget_show(struct device *dev,
1226         struct device_attribute *attr, char *buf)
1227 {
1228         struct snd_soc_pcm_runtime *rtd =
1229                         container_of(dev, struct snd_soc_pcm_runtime, dev);
1230         struct snd_soc_codec *codec =rtd->codec;
1231         struct snd_soc_dapm_widget *w;
1232         int count = 0;
1233         char *state = "not set";
1234
1235         list_for_each_entry(w, &codec->dapm.widgets, list) {
1236
1237                 /* only display widgets that burnm power */
1238                 switch (w->id) {
1239                 case snd_soc_dapm_hp:
1240                 case snd_soc_dapm_mic:
1241                 case snd_soc_dapm_spk:
1242                 case snd_soc_dapm_line:
1243                 case snd_soc_dapm_micbias:
1244                 case snd_soc_dapm_dac:
1245                 case snd_soc_dapm_adc:
1246                 case snd_soc_dapm_pga:
1247                 case snd_soc_dapm_mixer:
1248                 case snd_soc_dapm_mixer_named_ctl:
1249                 case snd_soc_dapm_supply:
1250                         if (w->name)
1251                                 count += sprintf(buf + count, "%s: %s\n",
1252                                         w->name, w->power ? "On":"Off");
1253                 break;
1254                 default:
1255                 break;
1256                 }
1257         }
1258
1259         switch (codec->dapm.bias_level) {
1260         case SND_SOC_BIAS_ON:
1261                 state = "On";
1262                 break;
1263         case SND_SOC_BIAS_PREPARE:
1264                 state = "Prepare";
1265                 break;
1266         case SND_SOC_BIAS_STANDBY:
1267                 state = "Standby";
1268                 break;
1269         case SND_SOC_BIAS_OFF:
1270                 state = "Off";
1271                 break;
1272         }
1273         count += sprintf(buf + count, "PM State: %s\n", state);
1274
1275         return count;
1276 }
1277
1278 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
1279
1280 int snd_soc_dapm_sys_add(struct device *dev)
1281 {
1282         return device_create_file(dev, &dev_attr_dapm_widget);
1283 }
1284
1285 static void snd_soc_dapm_sys_remove(struct device *dev)
1286 {
1287         device_remove_file(dev, &dev_attr_dapm_widget);
1288 }
1289
1290 /* free all dapm widgets and resources */
1291 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
1292 {
1293         struct snd_soc_dapm_widget *w, *next_w;
1294         struct snd_soc_dapm_path *p, *next_p;
1295
1296         list_for_each_entry_safe(w, next_w, &dapm->widgets, list) {
1297                 list_del(&w->list);
1298                 kfree(w);
1299         }
1300
1301         list_for_each_entry_safe(p, next_p, &dapm->paths, list) {
1302                 list_del(&p->list);
1303                 kfree(p->long_name);
1304                 kfree(p);
1305         }
1306 }
1307
1308 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
1309                                 const char *pin, int status)
1310 {
1311         struct snd_soc_dapm_widget *w;
1312
1313         list_for_each_entry(w, &dapm->widgets, list) {
1314                 if (!strcmp(w->name, pin)) {
1315                         dev_dbg(w->dapm->dev, "dapm: pin %s = %d\n",
1316                                 pin, status);
1317                         w->connected = status;
1318                         /* Allow disabling of forced pins */
1319                         if (status == 0)
1320                                 w->force = 0;
1321                         return 0;
1322                 }
1323         }
1324
1325         dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
1326         return -EINVAL;
1327 }
1328
1329 /**
1330  * snd_soc_dapm_sync - scan and power dapm paths
1331  * @dapm: DAPM context
1332  *
1333  * Walks all dapm audio paths and powers widgets according to their
1334  * stream or path usage.
1335  *
1336  * Returns 0 for success.
1337  */
1338 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
1339 {
1340         return dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
1341 }
1342 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
1343
1344 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
1345                                   const struct snd_soc_dapm_route *route)
1346 {
1347         struct snd_soc_dapm_path *path;
1348         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
1349         const char *sink = route->sink;
1350         const char *control = route->control;
1351         const char *source = route->source;
1352         int ret = 0;
1353
1354         /* find src and dest widgets */
1355         list_for_each_entry(w, &dapm->widgets, list) {
1356
1357                 if (!wsink && !(strcmp(w->name, sink))) {
1358                         wsink = w;
1359                         continue;
1360                 }
1361                 if (!wsource && !(strcmp(w->name, source))) {
1362                         wsource = w;
1363                 }
1364         }
1365
1366         if (wsource == NULL || wsink == NULL)
1367                 return -ENODEV;
1368
1369         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
1370         if (!path)
1371                 return -ENOMEM;
1372
1373         path->source = wsource;
1374         path->sink = wsink;
1375         path->connected = route->connected;
1376         INIT_LIST_HEAD(&path->list);
1377         INIT_LIST_HEAD(&path->list_source);
1378         INIT_LIST_HEAD(&path->list_sink);
1379
1380         /* check for external widgets */
1381         if (wsink->id == snd_soc_dapm_input) {
1382                 if (wsource->id == snd_soc_dapm_micbias ||
1383                         wsource->id == snd_soc_dapm_mic ||
1384                         wsource->id == snd_soc_dapm_line ||
1385                         wsource->id == snd_soc_dapm_output)
1386                         wsink->ext = 1;
1387         }
1388         if (wsource->id == snd_soc_dapm_output) {
1389                 if (wsink->id == snd_soc_dapm_spk ||
1390                         wsink->id == snd_soc_dapm_hp ||
1391                         wsink->id == snd_soc_dapm_line ||
1392                         wsink->id == snd_soc_dapm_input)
1393                         wsource->ext = 1;
1394         }
1395
1396         /* connect static paths */
1397         if (control == NULL) {
1398                 list_add(&path->list, &dapm->paths);
1399                 list_add(&path->list_sink, &wsink->sources);
1400                 list_add(&path->list_source, &wsource->sinks);
1401                 path->connect = 1;
1402                 return 0;
1403         }
1404
1405         /* connect dynamic paths */
1406         switch(wsink->id) {
1407         case snd_soc_dapm_adc:
1408         case snd_soc_dapm_dac:
1409         case snd_soc_dapm_pga:
1410         case snd_soc_dapm_input:
1411         case snd_soc_dapm_output:
1412         case snd_soc_dapm_micbias:
1413         case snd_soc_dapm_vmid:
1414         case snd_soc_dapm_pre:
1415         case snd_soc_dapm_post:
1416         case snd_soc_dapm_supply:
1417         case snd_soc_dapm_aif_in:
1418         case snd_soc_dapm_aif_out:
1419                 list_add(&path->list, &dapm->paths);
1420                 list_add(&path->list_sink, &wsink->sources);
1421                 list_add(&path->list_source, &wsource->sinks);
1422                 path->connect = 1;
1423                 return 0;
1424         case snd_soc_dapm_mux:
1425         case snd_soc_dapm_value_mux:
1426                 ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
1427                         &wsink->kcontrols[0]);
1428                 if (ret != 0)
1429                         goto err;
1430                 break;
1431         case snd_soc_dapm_switch:
1432         case snd_soc_dapm_mixer:
1433         case snd_soc_dapm_mixer_named_ctl:
1434                 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
1435                 if (ret != 0)
1436                         goto err;
1437                 break;
1438         case snd_soc_dapm_hp:
1439         case snd_soc_dapm_mic:
1440         case snd_soc_dapm_line:
1441         case snd_soc_dapm_spk:
1442                 list_add(&path->list, &dapm->paths);
1443                 list_add(&path->list_sink, &wsink->sources);
1444                 list_add(&path->list_source, &wsource->sinks);
1445                 path->connect = 0;
1446                 return 0;
1447         }
1448         return 0;
1449
1450 err:
1451         dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
1452                  source, control, sink);
1453         kfree(path);
1454         return ret;
1455 }
1456
1457 /**
1458  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
1459  * @dapm: DAPM context
1460  * @route: audio routes
1461  * @num: number of routes
1462  *
1463  * Connects 2 dapm widgets together via a named audio path. The sink is
1464  * the widget receiving the audio signal, whilst the source is the sender
1465  * of the audio signal.
1466  *
1467  * Returns 0 for success else error. On error all resources can be freed
1468  * with a call to snd_soc_card_free().
1469  */
1470 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
1471                             const struct snd_soc_dapm_route *route, int num)
1472 {
1473         int i, ret;
1474
1475         for (i = 0; i < num; i++) {
1476                 ret = snd_soc_dapm_add_route(dapm, route);
1477                 if (ret < 0) {
1478                         dev_err(dapm->dev, "Failed to add route %s->%s\n",
1479                                 route->source, route->sink);
1480                         return ret;
1481                 }
1482                 route++;
1483         }
1484
1485         return 0;
1486 }
1487 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
1488
1489 /**
1490  * snd_soc_dapm_new_widgets - add new dapm widgets
1491  * @dapm: DAPM context
1492  *
1493  * Checks the codec for any new dapm widgets and creates them if found.
1494  *
1495  * Returns 0 for success.
1496  */
1497 int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
1498 {
1499         struct snd_soc_dapm_widget *w;
1500
1501         list_for_each_entry(w, &dapm->widgets, list)
1502         {
1503                 if (w->new)
1504                         continue;
1505
1506                 switch(w->id) {
1507                 case snd_soc_dapm_switch:
1508                 case snd_soc_dapm_mixer:
1509                 case snd_soc_dapm_mixer_named_ctl:
1510                         w->power_check = dapm_generic_check_power;
1511                         dapm_new_mixer(dapm, w);
1512                         break;
1513                 case snd_soc_dapm_mux:
1514                 case snd_soc_dapm_value_mux:
1515                         w->power_check = dapm_generic_check_power;
1516                         dapm_new_mux(dapm, w);
1517                         break;
1518                 case snd_soc_dapm_adc:
1519                 case snd_soc_dapm_aif_out:
1520                         w->power_check = dapm_adc_check_power;
1521                         break;
1522                 case snd_soc_dapm_dac:
1523                 case snd_soc_dapm_aif_in:
1524                         w->power_check = dapm_dac_check_power;
1525                         break;
1526                 case snd_soc_dapm_pga:
1527                         w->power_check = dapm_generic_check_power;
1528                         dapm_new_pga(dapm, w);
1529                         break;
1530                 case snd_soc_dapm_input:
1531                 case snd_soc_dapm_output:
1532                 case snd_soc_dapm_micbias:
1533                 case snd_soc_dapm_spk:
1534                 case snd_soc_dapm_hp:
1535                 case snd_soc_dapm_mic:
1536                 case snd_soc_dapm_line:
1537                         w->power_check = dapm_generic_check_power;
1538                         break;
1539                 case snd_soc_dapm_supply:
1540                         w->power_check = dapm_supply_check_power;
1541                 case snd_soc_dapm_vmid:
1542                 case snd_soc_dapm_pre:
1543                 case snd_soc_dapm_post:
1544                         break;
1545                 }
1546                 w->new = 1;
1547         }
1548
1549         dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
1550         return 0;
1551 }
1552 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1553
1554 /**
1555  * snd_soc_dapm_get_volsw - dapm mixer get callback
1556  * @kcontrol: mixer control
1557  * @ucontrol: control element information
1558  *
1559  * Callback to get the value of a dapm mixer control.
1560  *
1561  * Returns 0 for success.
1562  */
1563 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1564         struct snd_ctl_elem_value *ucontrol)
1565 {
1566         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1567         struct soc_mixer_control *mc =
1568                 (struct soc_mixer_control *)kcontrol->private_value;
1569         unsigned int reg = mc->reg;
1570         unsigned int shift = mc->shift;
1571         unsigned int rshift = mc->rshift;
1572         int max = mc->max;
1573         unsigned int invert = mc->invert;
1574         unsigned int mask = (1 << fls(max)) - 1;
1575
1576         ucontrol->value.integer.value[0] =
1577                 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1578         if (shift != rshift)
1579                 ucontrol->value.integer.value[1] =
1580                         (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1581         if (invert) {
1582                 ucontrol->value.integer.value[0] =
1583                         max - ucontrol->value.integer.value[0];
1584                 if (shift != rshift)
1585                         ucontrol->value.integer.value[1] =
1586                                 max - ucontrol->value.integer.value[1];
1587         }
1588
1589         return 0;
1590 }
1591 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1592
1593 /**
1594  * snd_soc_dapm_put_volsw - dapm mixer set callback
1595  * @kcontrol: mixer control
1596  * @ucontrol: control element information
1597  *
1598  * Callback to set the value of a dapm mixer control.
1599  *
1600  * Returns 0 for success.
1601  */
1602 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1603         struct snd_ctl_elem_value *ucontrol)
1604 {
1605         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1606         struct soc_mixer_control *mc =
1607                 (struct soc_mixer_control *)kcontrol->private_value;
1608         unsigned int reg = mc->reg;
1609         unsigned int shift = mc->shift;
1610         unsigned int rshift = mc->rshift;
1611         int max = mc->max;
1612         unsigned int mask = (1 << fls(max)) - 1;
1613         unsigned int invert = mc->invert;
1614         unsigned int val, val2, val_mask;
1615         int connect;
1616         int ret;
1617
1618         val = (ucontrol->value.integer.value[0] & mask);
1619
1620         if (invert)
1621                 val = max - val;
1622         val_mask = mask << shift;
1623         val = val << shift;
1624         if (shift != rshift) {
1625                 val2 = (ucontrol->value.integer.value[1] & mask);
1626                 if (invert)
1627                         val2 = max - val2;
1628                 val_mask |= mask << rshift;
1629                 val |= val2 << rshift;
1630         }
1631
1632         mutex_lock(&widget->codec->mutex);
1633         widget->value = val;
1634
1635         if (snd_soc_test_bits(widget->codec, reg, val_mask, val)) {
1636                 if (val)
1637                         /* new connection */
1638                         connect = invert ? 0:1;
1639                 else
1640                         /* old connection must be powered down */
1641                         connect = invert ? 1:0;
1642
1643                 dapm_mixer_update_power(widget, kcontrol, connect);
1644         }
1645
1646         if (widget->event) {
1647                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1648                         ret = widget->event(widget, kcontrol,
1649                                                 SND_SOC_DAPM_PRE_REG);
1650                         if (ret < 0) {
1651                                 ret = 1;
1652                                 goto out;
1653                         }
1654                 }
1655                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1656                 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1657                         ret = widget->event(widget, kcontrol,
1658                                                 SND_SOC_DAPM_POST_REG);
1659         } else
1660                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1661
1662 out:
1663         mutex_unlock(&widget->codec->mutex);
1664         return ret;
1665 }
1666 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1667
1668 /**
1669  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1670  * @kcontrol: mixer control
1671  * @ucontrol: control element information
1672  *
1673  * Callback to get the value of a dapm enumerated double mixer control.
1674  *
1675  * Returns 0 for success.
1676  */
1677 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1678         struct snd_ctl_elem_value *ucontrol)
1679 {
1680         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1681         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1682         unsigned int val, bitmask;
1683
1684         for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1685                 ;
1686         val = snd_soc_read(widget->codec, e->reg);
1687         ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1688         if (e->shift_l != e->shift_r)
1689                 ucontrol->value.enumerated.item[1] =
1690                         (val >> e->shift_r) & (bitmask - 1);
1691
1692         return 0;
1693 }
1694 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1695
1696 /**
1697  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1698  * @kcontrol: mixer control
1699  * @ucontrol: control element information
1700  *
1701  * Callback to set the value of a dapm enumerated double mixer control.
1702  *
1703  * Returns 0 for success.
1704  */
1705 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1706         struct snd_ctl_elem_value *ucontrol)
1707 {
1708         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1709         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1710         unsigned int val, mux, change;
1711         unsigned int mask, bitmask;
1712         int ret = 0;
1713
1714         for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1715                 ;
1716         if (ucontrol->value.enumerated.item[0] > e->max - 1)
1717                 return -EINVAL;
1718         mux = ucontrol->value.enumerated.item[0];
1719         val = mux << e->shift_l;
1720         mask = (bitmask - 1) << e->shift_l;
1721         if (e->shift_l != e->shift_r) {
1722                 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1723                         return -EINVAL;
1724                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1725                 mask |= (bitmask - 1) << e->shift_r;
1726         }
1727
1728         mutex_lock(&widget->codec->mutex);
1729         widget->value = val;
1730         change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
1731         dapm_mux_update_power(widget, kcontrol, change, mux, e);
1732
1733         if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1734                 ret = widget->event(widget,
1735                                     kcontrol, SND_SOC_DAPM_PRE_REG);
1736                 if (ret < 0)
1737                         goto out;
1738         }
1739
1740         ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1741
1742         if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1743                 ret = widget->event(widget,
1744                                     kcontrol, SND_SOC_DAPM_POST_REG);
1745
1746 out:
1747         mutex_unlock(&widget->codec->mutex);
1748         return ret;
1749 }
1750 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1751
1752 /**
1753  * snd_soc_dapm_get_enum_virt - Get virtual DAPM mux
1754  * @kcontrol: mixer control
1755  * @ucontrol: control element information
1756  *
1757  * Returns 0 for success.
1758  */
1759 int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
1760                                struct snd_ctl_elem_value *ucontrol)
1761 {
1762         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1763
1764         ucontrol->value.enumerated.item[0] = widget->value;
1765
1766         return 0;
1767 }
1768 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
1769
1770 /**
1771  * snd_soc_dapm_put_enum_virt - Set virtual DAPM mux
1772  * @kcontrol: mixer control
1773  * @ucontrol: control element information
1774  *
1775  * Returns 0 for success.
1776  */
1777 int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
1778                                struct snd_ctl_elem_value *ucontrol)
1779 {
1780         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1781         struct soc_enum *e =
1782                 (struct soc_enum *)kcontrol->private_value;
1783         int change;
1784         int ret = 0;
1785
1786         if (ucontrol->value.enumerated.item[0] >= e->max)
1787                 return -EINVAL;
1788
1789         mutex_lock(&widget->codec->mutex);
1790
1791         change = widget->value != ucontrol->value.enumerated.item[0];
1792         widget->value = ucontrol->value.enumerated.item[0];
1793         dapm_mux_update_power(widget, kcontrol, change, widget->value, e);
1794
1795         mutex_unlock(&widget->codec->mutex);
1796         return ret;
1797 }
1798 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
1799
1800 /**
1801  * snd_soc_dapm_get_value_enum_double - dapm semi enumerated double mixer get
1802  *                                      callback
1803  * @kcontrol: mixer control
1804  * @ucontrol: control element information
1805  *
1806  * Callback to get the value of a dapm semi enumerated double mixer control.
1807  *
1808  * Semi enumerated mixer: the enumerated items are referred as values. Can be
1809  * used for handling bitfield coded enumeration for example.
1810  *
1811  * Returns 0 for success.
1812  */
1813 int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
1814         struct snd_ctl_elem_value *ucontrol)
1815 {
1816         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1817         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1818         unsigned int reg_val, val, mux;
1819
1820         reg_val = snd_soc_read(widget->codec, e->reg);
1821         val = (reg_val >> e->shift_l) & e->mask;
1822         for (mux = 0; mux < e->max; mux++) {
1823                 if (val == e->values[mux])
1824                         break;
1825         }
1826         ucontrol->value.enumerated.item[0] = mux;
1827         if (e->shift_l != e->shift_r) {
1828                 val = (reg_val >> e->shift_r) & e->mask;
1829                 for (mux = 0; mux < e->max; mux++) {
1830                         if (val == e->values[mux])
1831                                 break;
1832                 }
1833                 ucontrol->value.enumerated.item[1] = mux;
1834         }
1835
1836         return 0;
1837 }
1838 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_value_enum_double);
1839
1840 /**
1841  * snd_soc_dapm_put_value_enum_double - dapm semi enumerated double mixer set
1842  *                                      callback
1843  * @kcontrol: mixer control
1844  * @ucontrol: control element information
1845  *
1846  * Callback to set the value of a dapm semi enumerated double mixer control.
1847  *
1848  * Semi enumerated mixer: the enumerated items are referred as values. Can be
1849  * used for handling bitfield coded enumeration for example.
1850  *
1851  * Returns 0 for success.
1852  */
1853 int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
1854         struct snd_ctl_elem_value *ucontrol)
1855 {
1856         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1857         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1858         unsigned int val, mux, change;
1859         unsigned int mask;
1860         int ret = 0;
1861
1862         if (ucontrol->value.enumerated.item[0] > e->max - 1)
1863                 return -EINVAL;
1864         mux = ucontrol->value.enumerated.item[0];
1865         val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
1866         mask = e->mask << e->shift_l;
1867         if (e->shift_l != e->shift_r) {
1868                 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1869                         return -EINVAL;
1870                 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
1871                 mask |= e->mask << e->shift_r;
1872         }
1873
1874         mutex_lock(&widget->codec->mutex);
1875         widget->value = val;
1876         change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
1877         dapm_mux_update_power(widget, kcontrol, change, mux, e);
1878
1879         if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1880                 ret = widget->event(widget,
1881                                     kcontrol, SND_SOC_DAPM_PRE_REG);
1882                 if (ret < 0)
1883                         goto out;
1884         }
1885
1886         ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1887
1888         if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1889                 ret = widget->event(widget,
1890                                     kcontrol, SND_SOC_DAPM_POST_REG);
1891
1892 out:
1893         mutex_unlock(&widget->codec->mutex);
1894         return ret;
1895 }
1896 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
1897
1898 /**
1899  * snd_soc_dapm_info_pin_switch - Info for a pin switch
1900  *
1901  * @kcontrol: mixer control
1902  * @uinfo: control element information
1903  *
1904  * Callback to provide information about a pin switch control.
1905  */
1906 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
1907                                  struct snd_ctl_elem_info *uinfo)
1908 {
1909         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1910         uinfo->count = 1;
1911         uinfo->value.integer.min = 0;
1912         uinfo->value.integer.max = 1;
1913
1914         return 0;
1915 }
1916 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
1917
1918 /**
1919  * snd_soc_dapm_get_pin_switch - Get information for a pin switch
1920  *
1921  * @kcontrol: mixer control
1922  * @ucontrol: Value
1923  */
1924 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
1925                                 struct snd_ctl_elem_value *ucontrol)
1926 {
1927         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1928         const char *pin = (const char *)kcontrol->private_value;
1929
1930         mutex_lock(&codec->mutex);
1931
1932         ucontrol->value.integer.value[0] =
1933                 snd_soc_dapm_get_pin_status(&codec->dapm, pin);
1934
1935         mutex_unlock(&codec->mutex);
1936
1937         return 0;
1938 }
1939 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
1940
1941 /**
1942  * snd_soc_dapm_put_pin_switch - Set information for a pin switch
1943  *
1944  * @kcontrol: mixer control
1945  * @ucontrol: Value
1946  */
1947 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
1948                                 struct snd_ctl_elem_value *ucontrol)
1949 {
1950         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1951         const char *pin = (const char *)kcontrol->private_value;
1952
1953         mutex_lock(&codec->mutex);
1954
1955         if (ucontrol->value.integer.value[0])
1956                 snd_soc_dapm_enable_pin(&codec->dapm, pin);
1957         else
1958                 snd_soc_dapm_disable_pin(&codec->dapm, pin);
1959
1960         snd_soc_dapm_sync(&codec->dapm);
1961
1962         mutex_unlock(&codec->mutex);
1963
1964         return 0;
1965 }
1966 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
1967
1968 /**
1969  * snd_soc_dapm_new_control - create new dapm control
1970  * @dapm: DAPM context
1971  * @widget: widget template
1972  *
1973  * Creates a new dapm control based upon the template.
1974  *
1975  * Returns 0 for success else error.
1976  */
1977 int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
1978         const struct snd_soc_dapm_widget *widget)
1979 {
1980         struct snd_soc_dapm_widget *w;
1981
1982         if ((w = dapm_cnew_widget(widget)) == NULL)
1983                 return -ENOMEM;
1984
1985         w->dapm = dapm;
1986         w->codec = dapm->codec;
1987         INIT_LIST_HEAD(&w->sources);
1988         INIT_LIST_HEAD(&w->sinks);
1989         INIT_LIST_HEAD(&w->list);
1990         list_add(&w->list, &dapm->widgets);
1991
1992         /* machine layer set ups unconnected pins and insertions */
1993         w->connected = 1;
1994         return 0;
1995 }
1996 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1997
1998 /**
1999  * snd_soc_dapm_new_controls - create new dapm controls
2000  * @dapm: DAPM context
2001  * @widget: widget array
2002  * @num: number of widgets
2003  *
2004  * Creates new DAPM controls based upon the templates.
2005  *
2006  * Returns 0 for success else error.
2007  */
2008 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
2009         const struct snd_soc_dapm_widget *widget,
2010         int num)
2011 {
2012         int i, ret;
2013
2014         for (i = 0; i < num; i++) {
2015                 ret = snd_soc_dapm_new_control(dapm, widget);
2016                 if (ret < 0) {
2017                         dev_err(dapm->dev,
2018                                 "ASoC: Failed to create DAPM control %s: %d\n",
2019                                 widget->name, ret);
2020                         return ret;
2021                 }
2022                 widget++;
2023         }
2024         return 0;
2025 }
2026 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
2027
2028 static void soc_dapm_stream_event(struct snd_soc_dapm_context *dapm,
2029         const char *stream, int event)
2030 {
2031         struct snd_soc_dapm_widget *w;
2032
2033         list_for_each_entry(w, &dapm->widgets, list)
2034         {
2035                 if (!w->sname)
2036                         continue;
2037                 dev_dbg(w->dapm->dev, "widget %s\n %s stream %s event %d\n",
2038                         w->name, w->sname, stream, event);
2039                 if (strstr(w->sname, stream)) {
2040                         switch(event) {
2041                         case SND_SOC_DAPM_STREAM_START:
2042                                 w->active = 1;
2043                                 break;
2044                         case SND_SOC_DAPM_STREAM_STOP:
2045                                 w->active = 0;
2046                                 break;
2047                         case SND_SOC_DAPM_STREAM_SUSPEND:
2048                         case SND_SOC_DAPM_STREAM_RESUME:
2049                         case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
2050                         case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
2051                                 break;
2052                         }
2053                 }
2054         }
2055
2056         dapm_power_widgets(dapm, event);
2057 }
2058
2059 /**
2060  * snd_soc_dapm_stream_event - send a stream event to the dapm core
2061  * @rtd: PCM runtime data
2062  * @stream: stream name
2063  * @event: stream event
2064  *
2065  * Sends a stream event to the dapm core. The core then makes any
2066  * necessary widget power changes.
2067  *
2068  * Returns 0 for success else error.
2069  */
2070 int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
2071         const char *stream, int event)
2072 {
2073         struct snd_soc_codec *codec = rtd->codec;
2074
2075         if (stream == NULL)
2076                 return 0;
2077
2078         mutex_lock(&codec->mutex);
2079         soc_dapm_stream_event(&codec->dapm, stream, event);
2080         mutex_unlock(&codec->mutex);
2081         return 0;
2082 }
2083 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
2084
2085 /**
2086  * snd_soc_dapm_enable_pin - enable pin.
2087  * @dapm: DAPM context
2088  * @pin: pin name
2089  *
2090  * Enables input/output pin and its parents or children widgets iff there is
2091  * a valid audio route and active audio stream.
2092  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2093  * do any widget power switching.
2094  */
2095 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2096 {
2097         return snd_soc_dapm_set_pin(dapm, pin, 1);
2098 }
2099 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
2100
2101 /**
2102  * snd_soc_dapm_force_enable_pin - force a pin to be enabled
2103  * @dapm: DAPM context
2104  * @pin: pin name
2105  *
2106  * Enables input/output pin regardless of any other state.  This is
2107  * intended for use with microphone bias supplies used in microphone
2108  * jack detection.
2109  *
2110  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2111  * do any widget power switching.
2112  */
2113 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
2114                                   const char *pin)
2115 {
2116         struct snd_soc_dapm_widget *w;
2117
2118         list_for_each_entry(w, &dapm->widgets, list) {
2119                 if (!strcmp(w->name, pin)) {
2120                         dev_dbg(w->dapm->dev,
2121                                 "dapm: force enable pin %s\n", pin);
2122                         w->connected = 1;
2123                         w->force = 1;
2124                         return 0;
2125                 }
2126         }
2127
2128         dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2129         return -EINVAL;
2130 }
2131 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
2132
2133 /**
2134  * snd_soc_dapm_disable_pin - disable pin.
2135  * @dapm: DAPM context
2136  * @pin: pin name
2137  *
2138  * Disables input/output pin and its parents or children widgets.
2139  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2140  * do any widget power switching.
2141  */
2142 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
2143                              const char *pin)
2144 {
2145         return snd_soc_dapm_set_pin(dapm, pin, 0);
2146 }
2147 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2148
2149 /**
2150  * snd_soc_dapm_nc_pin - permanently disable pin.
2151  * @dapm: DAPM context
2152  * @pin: pin name
2153  *
2154  * Marks the specified pin as being not connected, disabling it along
2155  * any parent or child widgets.  At present this is identical to
2156  * snd_soc_dapm_disable_pin() but in future it will be extended to do
2157  * additional things such as disabling controls which only affect
2158  * paths through the pin.
2159  *
2160  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2161  * do any widget power switching.
2162  */
2163 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2164 {
2165         return snd_soc_dapm_set_pin(dapm, pin, 0);
2166 }
2167 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
2168
2169 /**
2170  * snd_soc_dapm_get_pin_status - get audio pin status
2171  * @dapm: DAPM context
2172  * @pin: audio signal pin endpoint (or start point)
2173  *
2174  * Get audio pin status - connected or disconnected.
2175  *
2176  * Returns 1 for connected otherwise 0.
2177  */
2178 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
2179                                 const char *pin)
2180 {
2181         struct snd_soc_dapm_widget *w;
2182
2183         list_for_each_entry(w, &dapm->widgets, list) {
2184                 if (!strcmp(w->name, pin))
2185                         return w->connected;
2186         }
2187
2188         return 0;
2189 }
2190 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
2191
2192 /**
2193  * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
2194  * @dapm: DAPM context
2195  * @pin: audio signal pin endpoint (or start point)
2196  *
2197  * Mark the given endpoint or pin as ignoring suspend.  When the
2198  * system is disabled a path between two endpoints flagged as ignoring
2199  * suspend will not be disabled.  The path must already be enabled via
2200  * normal means at suspend time, it will not be turned on if it was not
2201  * already enabled.
2202  */
2203 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
2204                                 const char *pin)
2205 {
2206         struct snd_soc_dapm_widget *w;
2207
2208         list_for_each_entry(w, &dapm->widgets, list) {
2209                 if (!strcmp(w->name, pin)) {
2210                         w->ignore_suspend = 1;
2211                         return 0;
2212                 }
2213         }
2214
2215         dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2216         return -EINVAL;
2217 }
2218 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
2219
2220 /**
2221  * snd_soc_dapm_free - free dapm resources
2222  * @card: SoC device
2223  *
2224  * Free all dapm widgets and resources.
2225  */
2226 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
2227 {
2228         snd_soc_dapm_sys_remove(dapm->dev);
2229         dapm_free_widgets(dapm);
2230 }
2231 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
2232
2233 static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
2234 {
2235         struct snd_soc_dapm_widget *w;
2236         LIST_HEAD(down_list);
2237         int powerdown = 0;
2238
2239         list_for_each_entry(w, &dapm->widgets, list) {
2240                 if (w->power) {
2241                         dapm_seq_insert(w, &down_list, dapm_down_seq);
2242                         w->power = 0;
2243                         powerdown = 1;
2244                 }
2245         }
2246
2247         /* If there were no widgets to power down we're already in
2248          * standby.
2249          */
2250         if (powerdown) {
2251                 snd_soc_dapm_set_bias_level(NULL, dapm, SND_SOC_BIAS_PREPARE);
2252                 dapm_seq_run(dapm, &down_list, 0, dapm_down_seq);
2253                 snd_soc_dapm_set_bias_level(NULL, dapm, SND_SOC_BIAS_STANDBY);
2254         }
2255 }
2256
2257 /*
2258  * snd_soc_dapm_shutdown - callback for system shutdown
2259  */
2260 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
2261 {
2262         struct snd_soc_codec *codec;
2263
2264         list_for_each_entry(codec, &card->codec_dev_list, list) {
2265                 soc_dapm_shutdown_codec(&codec->dapm);
2266                 snd_soc_dapm_set_bias_level(card, &codec->dapm, SND_SOC_BIAS_OFF);
2267         }
2268 }
2269
2270 /* Module information */
2271 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
2272 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
2273 MODULE_LICENSE("GPL");