Merge branch 'topic/dapm' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into asoc-pxa

14 files changed, 438 insertions, 196 deletions

diff --git a/sound/soc/codecs/adav80x.c b/sound/soc/codecs/adav80x.c
index f78b27a7c461..ab790d5fe53d 100644
--- a/sound/soc/codecs/adav80x.c
+++ b/sound/soc/codecs/adav80x.c
@@ -541,6 +541,7 @@ static int adav80x_set_sysclk(struct snd_soc_codec *codec,
                               unsigned int freq, int dir)
 {
         struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         if (dir == SND_SOC_CLOCK_IN) {
                 switch (clk_id) {
@@ -573,7 +574,7 @@ static int adav80x_set_sysclk(struct snd_soc_codec *codec,
                         regmap_write(adav80x->regmap, ADAV80X_ICLK_CTRL2,
                                 iclk_ctrl2);
 
-                        snd_soc_dapm_sync(&codec->dapm);
+                        snd_soc_dapm_sync(dapm);
                 }
         } else {
                 unsigned int mask;
@@ -600,17 +601,21 @@ static int adav80x_set_sysclk(struct snd_soc_codec *codec,
                         adav80x->sysclk_pd[clk_id] = false;
                 }
 
+                snd_soc_dapm_mutex_lock(dapm);
+
                 if (adav80x->sysclk_pd[0])
-                        snd_soc_dapm_disable_pin(&codec->dapm, "PLL1");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "PLL1");
                 else
-                        snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL1");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm, "PLL1");
 
                 if (adav80x->sysclk_pd[1] || adav80x->sysclk_pd[2])
-                        snd_soc_dapm_disable_pin(&codec->dapm, "PLL2");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "PLL2");
                 else
-                        snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL2");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm, "PLL2");
 
-                snd_soc_dapm_sync(&codec->dapm);
+                snd_soc_dapm_sync_unlocked(dapm);
+
+                snd_soc_dapm_mutex_unlock(dapm);
         }
 
         return 0;
diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c
index 4e3e31aaf509..492fe846ae68 100644
--- a/sound/soc/codecs/wm5100.c
+++ b/sound/soc/codecs/wm5100.c
@@ -2100,6 +2100,7 @@ static void wm5100_micd_irq(struct wm5100_priv *wm5100)
 int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
 {
         struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         if (jack) {
                 wm5100->jack = jack;
@@ -2117,9 +2118,14 @@ int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
                                     WM5100_ACCDET_RATE_MASK);
 
                 /* We need the charge pump to power MICBIAS */
-                snd_soc_dapm_force_enable_pin(&codec->dapm, "CP2");
-                snd_soc_dapm_force_enable_pin(&codec->dapm, "SYSCLK");
-                snd_soc_dapm_sync(&codec->dapm);
+                snd_soc_dapm_mutex_lock(dapm);
+
+                snd_soc_dapm_force_enable_pin_unlocked(dapm, "CP2");
+                snd_soc_dapm_force_enable_pin_unlocked(dapm, "SYSCLK");
+
+                snd_soc_dapm_sync_unlocked(dapm);
+
+                snd_soc_dapm_mutex_unlock(dapm);
 
                 /* We start off just enabling microphone detection - even a
                  * plain headphone will trigger detection.
diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index 97db3b45b411..9e6233633c44 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -3089,6 +3089,7 @@ static irqreturn_t wm8962_irq(int irq, void *data)
 int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
 {
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int irq_mask, enable;
 
         wm8962->jack = jack;
@@ -3109,14 +3110,18 @@ int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
         snd_soc_jack_report(wm8962->jack, 0,
                             SND_JACK_MICROPHONE | SND_JACK_BTN_0);
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (jack) {
-                snd_soc_dapm_force_enable_pin(&codec->dapm, "SYSCLK");
-                snd_soc_dapm_force_enable_pin(&codec->dapm, "MICBIAS");
+                snd_soc_dapm_force_enable_pin_unlocked(dapm, "SYSCLK");
+                snd_soc_dapm_force_enable_pin_unlocked(dapm, "MICBIAS");
         } else {
-                snd_soc_dapm_disable_pin(&codec->dapm, "SYSCLK");
-                snd_soc_dapm_disable_pin(&codec->dapm, "MICBIAS");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "SYSCLK");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "MICBIAS");
         }
 
+        snd_soc_dapm_mutex_unlock(dapm);
+
         return 0;
 }
 EXPORT_SYMBOL_GPL(wm8962_mic_detect);
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index b9be9cbc4603..e8daf55d37e3 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -2549,43 +2549,52 @@ static int wm8994_set_bias_level(struct snd_soc_codec *codec,
 int wm8994_vmid_mode(struct snd_soc_codec *codec, enum wm8994_vmid_mode mode)
 {
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         switch (mode) {
         case WM8994_VMID_NORMAL:
+                snd_soc_dapm_mutex_lock(dapm);
+
                 if (wm8994->hubs.lineout1_se) {
-                        snd_soc_dapm_disable_pin(&codec->dapm,
-                                                 "LINEOUT1N Driver");
-                        snd_soc_dapm_disable_pin(&codec->dapm,
-                                                 "LINEOUT1P Driver");
+                        snd_soc_dapm_disable_pin_unlocked(dapm,
+                                                          "LINEOUT1N Driver");
+                        snd_soc_dapm_disable_pin_unlocked(dapm,
+                                                          "LINEOUT1P Driver");
                 }
                 if (wm8994->hubs.lineout2_se) {
-                        snd_soc_dapm_disable_pin(&codec->dapm,
-                                                 "LINEOUT2N Driver");
-                        snd_soc_dapm_disable_pin(&codec->dapm,
-                                                 "LINEOUT2P Driver");
+                        snd_soc_dapm_disable_pin_unlocked(dapm,
+                                                          "LINEOUT2N Driver");
+                        snd_soc_dapm_disable_pin_unlocked(dapm,
+                                                          "LINEOUT2P Driver");
                 }
 
                 /* Do the sync with the old mode to allow it to clean up */
-                snd_soc_dapm_sync(&codec->dapm);
+                snd_soc_dapm_sync_unlocked(dapm);
                 wm8994->vmid_mode = mode;
+
+                snd_soc_dapm_mutex_unlock(dapm);
                 break;
 
         case WM8994_VMID_FORCE:
+                snd_soc_dapm_mutex_lock(dapm);
+
                 if (wm8994->hubs.lineout1_se) {
-                        snd_soc_dapm_force_enable_pin(&codec->dapm,
-                                                      "LINEOUT1N Driver");
-                        snd_soc_dapm_force_enable_pin(&codec->dapm,
-                                                      "LINEOUT1P Driver");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm,
+                                                               "LINEOUT1N Driver");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm,
+                                                               "LINEOUT1P Driver");
                 }
                 if (wm8994->hubs.lineout2_se) {
-                        snd_soc_dapm_force_enable_pin(&codec->dapm,
-                                                      "LINEOUT2N Driver");
-                        snd_soc_dapm_force_enable_pin(&codec->dapm,
-                                                      "LINEOUT2P Driver");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm,
+                                                               "LINEOUT2N Driver");
+                        snd_soc_dapm_force_enable_pin_unlocked(dapm,
+                                                               "LINEOUT2P Driver");
                 }
 
                 wm8994->vmid_mode = mode;
-                snd_soc_dapm_sync(&codec->dapm);
+                snd_soc_dapm_sync_unlocked(dapm);
+
+                snd_soc_dapm_mutex_unlock(dapm);
                 break;
 
         default:
diff --git a/sound/soc/codecs/wm8996.c b/sound/soc/codecs/wm8996.c
index 1a7655b0aa22..d565d0ac7a11 100644
--- a/sound/soc/codecs/wm8996.c
+++ b/sound/soc/codecs/wm8996.c
@@ -2251,6 +2251,7 @@ int wm8996_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
                   wm8996_polarity_fn polarity_cb)
 {
         struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(codec);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         wm8996->jack = jack;
         wm8996->detecting = true;
@@ -2267,8 +2268,12 @@ int wm8996_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
                             WM8996_MICB2_DISCH, 0);
 
         /* LDO2 powers the microphones, SYSCLK clocks detection */
-        snd_soc_dapm_force_enable_pin(&codec->dapm, "LDO2");
-        snd_soc_dapm_force_enable_pin(&codec->dapm, "SYSCLK");
+        snd_soc_dapm_mutex_lock(dapm);
+
+        snd_soc_dapm_force_enable_pin_unlocked(dapm, "LDO2");
+        snd_soc_dapm_force_enable_pin_unlocked(dapm, "SYSCLK");
+
+        snd_soc_dapm_mutex_unlock(dapm);
 
         /* We start off just enabling microphone detection - even a
          * plain headphone will trigger detection.
diff --git a/sound/soc/intel/mfld_machine.c b/sound/soc/intel/mfld_machine.c
index d3d4c32434f7..0cef32e9d402 100644
--- a/sound/soc/intel/mfld_machine.c
+++ b/sound/soc/intel/mfld_machine.c
@@ -101,20 +101,27 @@ static int headset_set_switch(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         if (ucontrol->value.integer.value[0] == hs_switch)
                 return 0;
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (ucontrol->value.integer.value[0]) {
                 pr_debug("hs_set HS path\n");
-                snd_soc_dapm_enable_pin(&codec->dapm, "Headphones");
-                snd_soc_dapm_disable_pin(&codec->dapm, "EPOUT");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphones");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT");
         } else {
                 pr_debug("hs_set EP path\n");
-                snd_soc_dapm_disable_pin(&codec->dapm, "Headphones");
-                snd_soc_dapm_enable_pin(&codec->dapm, "EPOUT");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "EPOUT");
         }
-        snd_soc_dapm_sync(&codec->dapm);
+
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
+
         hs_switch = ucontrol->value.integer.value[0];
 
         return 0;
@@ -122,18 +129,20 @@ static int headset_set_switch(struct snd_kcontrol *kcontrol,
 
 static void lo_enable_out_pins(struct snd_soc_codec *codec)
 {
-        snd_soc_dapm_enable_pin(&codec->dapm, "IHFOUTL");
-        snd_soc_dapm_enable_pin(&codec->dapm, "IHFOUTR");
-        snd_soc_dapm_enable_pin(&codec->dapm, "LINEOUTL");
-        snd_soc_dapm_enable_pin(&codec->dapm, "LINEOUTR");
-        snd_soc_dapm_enable_pin(&codec->dapm, "VIB1OUT");
-        snd_soc_dapm_enable_pin(&codec->dapm, "VIB2OUT");
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+
+        snd_soc_dapm_enable_pin_unlocked(dapm, "IHFOUTL");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "IHFOUTR");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "LINEOUTL");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "LINEOUTR");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "VIB1OUT");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "VIB2OUT");
         if (hs_switch) {
-                snd_soc_dapm_enable_pin(&codec->dapm, "Headphones");
-                snd_soc_dapm_disable_pin(&codec->dapm, "EPOUT");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphones");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT");
         } else {
-                snd_soc_dapm_disable_pin(&codec->dapm, "Headphones");
-                snd_soc_dapm_enable_pin(&codec->dapm, "EPOUT");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "EPOUT");
         }
 }
 
@@ -148,44 +157,52 @@ static int lo_set_switch(struct snd_kcontrol *kcontrol,
         struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
 
         if (ucontrol->value.integer.value[0] == lo_dac)
                 return 0;
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         /* we dont want to work with last state of lineout so just enable all
          * pins and then disable pins not required
          */
         lo_enable_out_pins(codec);
+
         switch (ucontrol->value.integer.value[0]) {
         case 0:
                 pr_debug("set vibra path\n");
-                snd_soc_dapm_disable_pin(&codec->dapm, "VIB1OUT");
-                snd_soc_dapm_disable_pin(&codec->dapm, "VIB2OUT");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "VIB1OUT");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "VIB2OUT");
                 snd_soc_update_bits(codec, SN95031_LOCTL, 0x66, 0);
                 break;
 
         case 1:
                 pr_debug("set hs  path\n");
-                snd_soc_dapm_disable_pin(&codec->dapm, "Headphones");
-                snd_soc_dapm_disable_pin(&codec->dapm, "EPOUT");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT");
                 snd_soc_update_bits(codec, SN95031_LOCTL, 0x66, 0x22);
                 break;
 
         case 2:
                 pr_debug("set spkr path\n");
-                snd_soc_dapm_disable_pin(&codec->dapm, "IHFOUTL");
-                snd_soc_dapm_disable_pin(&codec->dapm, "IHFOUTR");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "IHFOUTL");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "IHFOUTR");
                 snd_soc_update_bits(codec, SN95031_LOCTL, 0x66, 0x44);
                 break;
 
         case 3:
                 pr_debug("set null path\n");
-                snd_soc_dapm_disable_pin(&codec->dapm, "LINEOUTL");
-                snd_soc_dapm_disable_pin(&codec->dapm, "LINEOUTR");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "LINEOUTL");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "LINEOUTR");
                 snd_soc_update_bits(codec, SN95031_LOCTL, 0x66, 0x66);
                 break;
         }
-        snd_soc_dapm_sync(&codec->dapm);
+
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
+
         lo_dac = ucontrol->value.integer.value[0];
         return 0;
 }
diff --git a/sound/soc/omap/ams-delta.c b/sound/soc/omap/ams-delta.c
index 629446482a91..14718cd6c29f 100644
--- a/sound/soc/omap/ams-delta.c
+++ b/sound/soc/omap/ams-delta.c
@@ -106,57 +106,59 @@ static int ams_delta_set_audio_mode(struct snd_kcontrol *kcontrol,
         if (ucontrol->value.enumerated.item[0] >= control->max)
                 return -EINVAL;
 
-        mutex_lock(&codec->mutex);
+        snd_soc_dapm_mutex_lock(dapm);
 
         /* Translate selection to bitmap */
         pins = ams_delta_audio_mode_pins[ucontrol->value.enumerated.item[0]];
 
         /* Setup pins after corresponding bits if changed */
         pin = !!(pins & (1 << AMS_DELTA_MOUTHPIECE));
+
         if (pin != snd_soc_dapm_get_pin_status(dapm, "Mouthpiece")) {
                 changed = 1;
                 if (pin)
-                        snd_soc_dapm_enable_pin(dapm, "Mouthpiece");
+                        snd_soc_dapm_enable_pin_unlocked(dapm, "Mouthpiece");
                 else
-                        snd_soc_dapm_disable_pin(dapm, "Mouthpiece");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "Mouthpiece");
         }
         pin = !!(pins & (1 << AMS_DELTA_EARPIECE));
         if (pin != snd_soc_dapm_get_pin_status(dapm, "Earpiece")) {
                 changed = 1;
                 if (pin)
-                        snd_soc_dapm_enable_pin(dapm, "Earpiece");
+                        snd_soc_dapm_enable_pin_unlocked(dapm, "Earpiece");
                 else
-                        snd_soc_dapm_disable_pin(dapm, "Earpiece");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "Earpiece");
         }
         pin = !!(pins & (1 << AMS_DELTA_MICROPHONE));
         if (pin != snd_soc_dapm_get_pin_status(dapm, "Microphone")) {
                 changed = 1;
                 if (pin)
-                        snd_soc_dapm_enable_pin(dapm, "Microphone");
+                        snd_soc_dapm_enable_pin_unlocked(dapm, "Microphone");
                 else
-                        snd_soc_dapm_disable_pin(dapm, "Microphone");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "Microphone");
         }
         pin = !!(pins & (1 << AMS_DELTA_SPEAKER));
         if (pin != snd_soc_dapm_get_pin_status(dapm, "Speaker")) {
                 changed = 1;
                 if (pin)
-                        snd_soc_dapm_enable_pin(dapm, "Speaker");
+                        snd_soc_dapm_enable_pin_unlocked(dapm, "Speaker");
                 else
-                        snd_soc_dapm_disable_pin(dapm, "Speaker");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "Speaker");
         }
         pin = !!(pins & (1 << AMS_DELTA_AGC));
         if (pin != ams_delta_audio_agc) {
                 ams_delta_audio_agc = pin;
                 changed = 1;
                 if (pin)
-                        snd_soc_dapm_enable_pin(dapm, "AGCIN");
+                        snd_soc_dapm_enable_pin_unlocked(dapm, "AGCIN");
                 else
-                        snd_soc_dapm_disable_pin(dapm, "AGCIN");
+                        snd_soc_dapm_disable_pin_unlocked(dapm, "AGCIN");
         }
+
         if (changed)
-                snd_soc_dapm_sync(dapm);
+                snd_soc_dapm_sync_unlocked(dapm);
 
-        mutex_unlock(&codec->mutex);
+        snd_soc_dapm_mutex_unlock(dapm);
 
         return changed;
 }
@@ -315,12 +317,17 @@ static void cx81801_close(struct tty_struct *tty)
         v253_ops.close(tty);
 
         /* Revert back to default audio input/output constellation */
-        snd_soc_dapm_disable_pin(dapm, "Mouthpiece");
-        snd_soc_dapm_enable_pin(dapm, "Earpiece");
-        snd_soc_dapm_enable_pin(dapm, "Microphone");
-        snd_soc_dapm_disable_pin(dapm, "Speaker");
-        snd_soc_dapm_disable_pin(dapm, "AGCIN");
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_mutex_lock(dapm);
+
+        snd_soc_dapm_disable_pin_unlocked(dapm, "Mouthpiece");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "Earpiece");
+        snd_soc_dapm_enable_pin_unlocked(dapm, "Microphone");
+        snd_soc_dapm_disable_pin_unlocked(dapm, "Speaker");
+        snd_soc_dapm_disable_pin_unlocked(dapm, "AGCIN");
+
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 /* Line discipline .hangup() */
diff --git a/sound/soc/omap/n810.c b/sound/soc/omap/n810.c
index 3fde9e402710..480a39ce02bc 100644
--- a/sound/soc/omap/n810.c
+++ b/sound/soc/omap/n810.c
@@ -68,26 +68,30 @@ static void n810_ext_control(struct snd_soc_dapm_context *dapm)
                 break;
         }
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (n810_spk_func)
-                snd_soc_dapm_enable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk");
         else
-                snd_soc_dapm_disable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk");
 
         if (hp)
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
         else
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
         if (line1l)
-                snd_soc_dapm_enable_pin(dapm, "LINE1L");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "LINE1L");
         else
-                snd_soc_dapm_disable_pin(dapm, "LINE1L");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "LINE1L");
 
         if (n810_dmic_func)
-                snd_soc_dapm_enable_pin(dapm, "DMic");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "DMic");
         else
-                snd_soc_dapm_disable_pin(dapm, "DMic");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "DMic");
+
+        snd_soc_dapm_sync_unlocked(dapm);
 
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int n810_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/omap/rx51.c b/sound/soc/omap/rx51.c
index 611179c3bca4..7fb3d4b10370 100644
--- a/sound/soc/omap/rx51.c
+++ b/sound/soc/omap/rx51.c
@@ -74,26 +74,30 @@ static void rx51_ext_control(struct snd_soc_dapm_context *dapm)
                 break;
         }
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (rx51_spk_func)
-                snd_soc_dapm_enable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk");
         else
-                snd_soc_dapm_disable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk");
         if (rx51_dmic_func)
-                snd_soc_dapm_enable_pin(dapm, "DMic");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "DMic");
         else
-                snd_soc_dapm_disable_pin(dapm, "DMic");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "DMic");
         if (hp)
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
         else
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
         if (hs)
-                snd_soc_dapm_enable_pin(dapm, "HS Mic");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "HS Mic");
         else
-                snd_soc_dapm_disable_pin(dapm, "HS Mic");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "HS Mic");
 
         gpio_set_value(RX51_TVOUT_SEL_GPIO, tvout);
 
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int rx51_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/pxa/corgi.c b/sound/soc/pxa/corgi.c
index 916ff63d85d0..5a88136aa800 100644
--- a/sound/soc/pxa/corgi.c
+++ b/sound/soc/pxa/corgi.c
@@ -47,51 +47,55 @@ static int corgi_spk_func;
 
 static void corgi_ext_control(struct snd_soc_dapm_context *dapm)
 {
+        snd_soc_dapm_mutex_lock(dapm);
+
         /* set up jack connection */
         switch (corgi_jack_func) {
         case CORGI_HP:
                 /* set = unmute headphone */
                 gpio_set_value(CORGI_GPIO_MUTE_L, 1);
                 gpio_set_value(CORGI_GPIO_MUTE_R, 1);
-                snd_soc_dapm_disable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
                 break;
         case CORGI_MIC:
                 /* reset = mute headphone */
                 gpio_set_value(CORGI_GPIO_MUTE_L, 0);
                 gpio_set_value(CORGI_GPIO_MUTE_R, 0);
-                snd_soc_dapm_enable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
                 break;
         case CORGI_LINE:
                 gpio_set_value(CORGI_GPIO_MUTE_L, 0);
                 gpio_set_value(CORGI_GPIO_MUTE_R, 0);
-                snd_soc_dapm_disable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_enable_pin(dapm, "Line Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
                 break;
         case CORGI_HEADSET:
                 gpio_set_value(CORGI_GPIO_MUTE_L, 0);
                 gpio_set_value(CORGI_GPIO_MUTE_R, 1);
-                snd_soc_dapm_enable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_enable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headset Jack");
                 break;
         }
 
         if (corgi_spk_func == CORGI_SPK_ON)
-                snd_soc_dapm_enable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk");
         else
-                snd_soc_dapm_disable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk");
 
         /* signal a DAPM event */
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int corgi_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/pxa/magician.c b/sound/soc/pxa/magician.c
index aeb08f5f3e1c..41ab6678b65d 100644
--- a/sound/soc/pxa/magician.c
+++ b/sound/soc/pxa/magician.c
@@ -45,27 +45,31 @@ static void magician_ext_control(struct snd_soc_codec *codec)
 {
         struct snd_soc_dapm_context *dapm = &codec->dapm;
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (magician_spk_switch)
-                snd_soc_dapm_enable_pin(dapm, "Speaker");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Speaker");
         else
-                snd_soc_dapm_disable_pin(dapm, "Speaker");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Speaker");
         if (magician_hp_switch)
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
         else
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
 
         switch (magician_in_sel) {
         case MAGICIAN_MIC:
-                snd_soc_dapm_disable_pin(dapm, "Headset Mic");
-                snd_soc_dapm_enable_pin(dapm, "Call Mic");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Mic");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Call Mic");
                 break;
         case MAGICIAN_MIC_EXT:
-                snd_soc_dapm_disable_pin(dapm, "Call Mic");
-                snd_soc_dapm_enable_pin(dapm, "Headset Mic");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Call Mic");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headset Mic");
                 break;
         }
 
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int magician_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/pxa/spitz.c b/sound/soc/pxa/spitz.c
index d1b6bf9c8583..1373b017a951 100644
--- a/sound/soc/pxa/spitz.c
+++ b/sound/soc/pxa/spitz.c
@@ -46,61 +46,66 @@ static int spitz_mic_gpio;
 
 static void spitz_ext_control(struct snd_soc_dapm_context *dapm)
 {
+        snd_soc_dapm_mutex_lock(dapm);
+
         if (spitz_spk_func == SPITZ_SPK_ON)
-                snd_soc_dapm_enable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk");
         else
-                snd_soc_dapm_disable_pin(dapm, "Ext Spk");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk");
 
         /* set up jack connection */
         switch (spitz_jack_func) {
         case SPITZ_HP:
                 /* enable and unmute hp jack, disable mic bias */
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
-                snd_soc_dapm_disable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
                 gpio_set_value(SPITZ_GPIO_MUTE_L, 1);
                 gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
                 break;
         case SPITZ_MIC:
                 /* enable mic jack and bias, mute hp */
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_enable_pin(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Mic Jack");
                 gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
                 gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
                 break;
         case SPITZ_LINE:
                 /* enable line jack, disable mic bias and mute hp */
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
-                snd_soc_dapm_disable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_enable_pin(dapm, "Line Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Line Jack");
                 gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
                 gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
                 break;
         case SPITZ_HEADSET:
                 /* enable and unmute headset jack enable mic bias, mute L hp */
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_enable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
-                snd_soc_dapm_enable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headset Jack");
                 gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
                 gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
                 break;
         case SPITZ_HP_OFF:
 
                 /* jack removed, everything off */
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
-                snd_soc_dapm_disable_pin(dapm, "Mic Jack");
-                snd_soc_dapm_disable_pin(dapm, "Line Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Line Jack");
                 gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
                 gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
                 break;
         }
-        snd_soc_dapm_sync(dapm);
+
+        snd_soc_dapm_sync_unlocked(dapm);
+
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int spitz_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/pxa/tosa.c b/sound/soc/pxa/tosa.c
index d6f38d7ecc1c..cead1658d10a 100644
--- a/sound/soc/pxa/tosa.c
+++ b/sound/soc/pxa/tosa.c
@@ -48,31 +48,35 @@ static void tosa_ext_control(struct snd_soc_codec *codec)
 {
         struct snd_soc_dapm_context *dapm = &codec->dapm;
 
+        snd_soc_dapm_mutex_lock(dapm);
+
         /* set up jack connection */
         switch (tosa_jack_func) {
         case TOSA_HP:
-                snd_soc_dapm_disable_pin(dapm, "Mic (Internal)");
-                snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic (Internal)");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
                 break;
         case TOSA_MIC_INT:
-                snd_soc_dapm_enable_pin(dapm, "Mic (Internal)");
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_disable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Mic (Internal)");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
                 break;
         case TOSA_HEADSET:
-                snd_soc_dapm_disable_pin(dapm, "Mic (Internal)");
-                snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
-                snd_soc_dapm_enable_pin(dapm, "Headset Jack");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Mic (Internal)");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Headset Jack");
                 break;
         }
 
         if (tosa_spk_func == TOSA_SPK_ON)
-                snd_soc_dapm_enable_pin(dapm, "Speaker");
+                snd_soc_dapm_enable_pin_unlocked(dapm, "Speaker");
         else
-                snd_soc_dapm_disable_pin(dapm, "Speaker");
+                snd_soc_dapm_disable_pin_unlocked(dapm, "Speaker");
+
+        snd_soc_dapm_sync_unlocked(dapm);
 
-        snd_soc_dapm_sync(dapm);
+        snd_soc_dapm_mutex_unlock(dapm);
 }
 
 static int tosa_startup(struct snd_pcm_substream *substream)
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index dc8ff13187f7..5c01ac1cfc0a 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -115,6 +115,12 @@ static int dapm_down_seq[] = {
         [snd_soc_dapm_post] = 14,
 };
 
+static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
+{
+        if (dapm->card && dapm->card->instantiated)
+                lockdep_assert_held(&dapm->card->dapm_mutex);
+}
+
 static void pop_wait(u32 pop_time)
 {
         if (pop_time)
@@ -146,15 +152,16 @@ static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
         return !list_empty(&w->dirty);
 }
 
-void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
+static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
 {
+        dapm_assert_locked(w->dapm);
+
         if (!dapm_dirty_widget(w)) {
                 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
                          w->name, reason);
                 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
         }
 }
-EXPORT_SYMBOL_GPL(dapm_mark_dirty);
 
 void dapm_mark_io_dirty(struct snd_soc_dapm_context *dapm)
 {
@@ -361,6 +368,8 @@ static void dapm_reset(struct snd_soc_card *card)
 {
         struct snd_soc_dapm_widget *w;
 
+        lockdep_assert_held(&card->dapm_mutex);
+
         memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
 
         list_for_each_entry(w, &card->widgets, list) {
@@ -386,7 +395,8 @@ static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg,
         return -1;
 }
 
-static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, int val)
+static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg,
+        unsigned int val)
 {
         if (w->codec)
                 return snd_soc_write(w->codec, reg, val);
@@ -506,7 +516,7 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
         case snd_soc_dapm_switch:
         case snd_soc_dapm_mixer:
         case snd_soc_dapm_mixer_named_ctl: {
-                int val;
+                unsigned int val;
                 struct soc_mixer_control *mc = (struct soc_mixer_control *)
                         w->kcontrol_news[i].private_value;
                 int reg = mc->reg;
@@ -530,7 +540,7 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
         case snd_soc_dapm_mux: {
                 struct soc_enum *e = (struct soc_enum *)
                         w->kcontrol_news[i].private_value;
-                int val, item;
+                unsigned int val, item;
 
                 soc_widget_read(w, e->reg, &val);
                 item = (val >> e->shift_l) & e->mask;
@@ -559,7 +569,7 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
         case snd_soc_dapm_value_mux: {
                 struct soc_enum *e = (struct soc_enum *)
                         w->kcontrol_news[i].private_value;
-                int val, item;
+                unsigned int val, item;
 
                 soc_widget_read(w, e->reg, &val);
                 val = (val >> e->shift_l) & e->mask;
@@ -1218,7 +1228,7 @@ int dapm_regulator_event(struct snd_soc_dapm_widget *w,
                         ret = regulator_allow_bypass(w->regulator, false);
                         if (ret != 0)
                                 dev_warn(w->dapm->dev,
-                                         "ASoC: Failed to bypass %s: %d\n",
+                                         "ASoC: Failed to unbypass %s: %d\n",
                                          w->name, ret);
                 }
 
@@ -1228,7 +1238,7 @@ int dapm_regulator_event(struct snd_soc_dapm_widget *w,
                         ret = regulator_allow_bypass(w->regulator, true);
                         if (ret != 0)
                                 dev_warn(w->dapm->dev,
-                                         "ASoC: Failed to unbypass %s: %d\n",
+                                         "ASoC: Failed to bypass %s: %d\n",
                                          w->name, ret);
                 }
 
@@ -1823,6 +1833,8 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
         enum snd_soc_bias_level bias;
 
+        lockdep_assert_held(&card->dapm_mutex);
+
         trace_snd_soc_dapm_start(card);
 
         list_for_each_entry(d, &card->dapm_list, list) {
@@ -1897,10 +1909,14 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
 
         trace_snd_soc_dapm_walk_done(card);
 
-        /* Run all the bias changes in parallel */
-        list_for_each_entry(d, &card->dapm_list, list)
-                async_schedule_domain(dapm_pre_sequence_async, d,
-                                        &async_domain);
+        /* Run card bias changes at first */
+        dapm_pre_sequence_async(&card->dapm, 0);
+        /* Run other bias changes in parallel */
+        list_for_each_entry(d, &card->dapm_list, list) {
+                if (d != &card->dapm)
+                        async_schedule_domain(dapm_pre_sequence_async, d,
+                                                &async_domain);
+        }
         async_synchronize_full_domain(&async_domain);
 
         list_for_each_entry(w, &down_list, power_list) {
@@ -1920,10 +1936,14 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
         dapm_seq_run(card, &up_list, event, true);
 
         /* Run all the bias changes in parallel */
-        list_for_each_entry(d, &card->dapm_list, list)
-                async_schedule_domain(dapm_post_sequence_async, d,
-                                        &async_domain);
+        list_for_each_entry(d, &card->dapm_list, list) {
+                if (d != &card->dapm)
+                        async_schedule_domain(dapm_post_sequence_async, d,
+                                                &async_domain);
+        }
         async_synchronize_full_domain(&async_domain);
+        /* Run card bias changes at last */
+        dapm_post_sequence_async(&card->dapm, 0);
 
         /* do we need to notify any clients that DAPM event is complete */
         list_for_each_entry(d, &card->dapm_list, list) {
@@ -2110,6 +2130,8 @@ static int soc_dapm_mux_update_power(struct snd_soc_card *card,
         struct snd_soc_dapm_path *path;
         int found = 0;
 
+        lockdep_assert_held(&card->dapm_mutex);
+
         /* find dapm widget path assoc with kcontrol */
         dapm_kcontrol_for_each_path(path, kcontrol) {
                 if (!path->name || !e->texts[mux])
@@ -2160,6 +2182,8 @@ static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
         struct snd_soc_dapm_path *path;
         int found = 0;
 
+        lockdep_assert_held(&card->dapm_mutex);
+
         /* find dapm widget path assoc with kcontrol */
         dapm_kcontrol_for_each_path(path, kcontrol) {
                 found = 1;
@@ -2325,6 +2349,8 @@ static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
 {
         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
 
+        dapm_assert_locked(dapm);
+
         if (!w) {
                 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
                 return -EINVAL;
@@ -2341,18 +2367,18 @@ static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
 }
 
 /**
- * snd_soc_dapm_sync - scan and power dapm paths
+ * snd_soc_dapm_sync_unlocked - scan and power dapm paths
  * @dapm: DAPM context
  *
  * Walks all dapm audio paths and powers widgets according to their
  * stream or path usage.
  *
+ * Requires external locking.
+ *
  * Returns 0 for success.
  */
-int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
+int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
 {
-        int ret;
-
         /*
          * Suppress early reports (eg, jacks syncing their state) to avoid
          * silly DAPM runs during card startup.
@@ -2360,8 +2386,25 @@ int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
         if (!dapm->card || !dapm->card->instantiated)
                 return 0;
 
+        return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
+
+/**
+ * snd_soc_dapm_sync - scan and power dapm paths
+ * @dapm: DAPM context
+ *
+ * Walks all dapm audio paths and powers widgets according to their
+ * stream or path usage.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
+{
+        int ret;
+
         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
-        ret = dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
+        ret = snd_soc_dapm_sync_unlocked(dapm);
         mutex_unlock(&dapm->card->dapm_mutex);
         return ret;
 }
@@ -3210,15 +3253,11 @@ int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
         const char *pin = (const char *)kcontrol->private_value;
 
-        mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
-
         if (ucontrol->value.integer.value[0])
                 snd_soc_dapm_enable_pin(&card->dapm, pin);
         else
                 snd_soc_dapm_disable_pin(&card->dapm, pin);
 
-        mutex_unlock(&card->dapm_mutex);
-
         snd_soc_dapm_sync(&card->dapm);
         return 0;
 }
@@ -3248,7 +3287,7 @@ snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
                         ret = regulator_allow_bypass(w->regulator, true);
                         if (ret != 0)
                                 dev_warn(w->dapm->dev,
-                                         "ASoC: Failed to unbypass %s: %d\n",
+                                         "ASoC: Failed to bypass %s: %d\n",
                                          w->name, ret);
                 }
                 break;
@@ -3767,23 +3806,52 @@ void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
 }
 
 /**
+ * snd_soc_dapm_enable_pin_unlocked - enable pin.
+ * @dapm: DAPM context
+ * @pin: pin name
+ *
+ * Enables input/output pin and its parents or children widgets iff there is
+ * a valid audio route and active audio stream.
+ *
+ * Requires external locking.
+ *
+ * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
+ * do any widget power switching.
+ */
+int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                   const char *pin)
+{
+        return snd_soc_dapm_set_pin(dapm, pin, 1);
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
+
+/**
  * snd_soc_dapm_enable_pin - enable pin.
  * @dapm: DAPM context
  * @pin: pin name
  *
  * Enables input/output pin and its parents or children widgets iff there is
  * a valid audio route and active audio stream.
+ *
  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
  * do any widget power switching.
  */
 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
 {
-        return snd_soc_dapm_set_pin(dapm, pin, 1);
+        int ret;
+
+        mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+        ret = snd_soc_dapm_set_pin(dapm, pin, 1);
+
+        mutex_unlock(&dapm->card->dapm_mutex);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
 
 /**
- * snd_soc_dapm_force_enable_pin - force a pin to be enabled
+ * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
  * @dapm: DAPM context
  * @pin: pin name
  *
@@ -3791,11 +3859,13 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
  * intended for use with microphone bias supplies used in microphone
  * jack detection.
  *
+ * Requires external locking.
+ *
  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
  * do any widget power switching.
  */
-int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
-                                  const char *pin)
+int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                         const char *pin)
 {
         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
 
@@ -3811,25 +3881,103 @@ int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
+
+/**
+ * snd_soc_dapm_force_enable_pin - force a pin to be enabled
+ * @dapm: DAPM context
+ * @pin: pin name
+ *
+ * Enables input/output pin regardless of any other state.  This is
+ * intended for use with microphone bias supplies used in microphone
+ * jack detection.
+ *
+ * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
+ * do any widget power switching.
+ */
+int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
+                                  const char *pin)
+{
+        int ret;
+
+        mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+        ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
+
+        mutex_unlock(&dapm->card->dapm_mutex);
+
+        return ret;
+}
 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
 
 /**
+ * snd_soc_dapm_disable_pin_unlocked - disable pin.
+ * @dapm: DAPM context
+ * @pin: pin name
+ *
+ * Disables input/output pin and its parents or children widgets.
+ *
+ * Requires external locking.
+ *
+ * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
+ * do any widget power switching.
+ */
+int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                                    const char *pin)
+{
+        return snd_soc_dapm_set_pin(dapm, pin, 0);
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
+
+/**
  * snd_soc_dapm_disable_pin - disable pin.
  * @dapm: DAPM context
  * @pin: pin name
  *
  * Disables input/output pin and its parents or children widgets.
+ *
  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
  * do any widget power switching.
  */
 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
                              const char *pin)
 {
-        return snd_soc_dapm_set_pin(dapm, pin, 0);
+        int ret;
+
+        mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+        ret = snd_soc_dapm_set_pin(dapm, pin, 0);
+
+        mutex_unlock(&dapm->card->dapm_mutex);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
 
 /**
+ * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
+ * @dapm: DAPM context
+ * @pin: pin name
+ *
+ * Marks the specified pin as being not connected, disabling it along
+ * any parent or child widgets.  At present this is identical to
+ * snd_soc_dapm_disable_pin() but in future it will be extended to do
+ * additional things such as disabling controls which only affect
+ * paths through the pin.
+ *
+ * Requires external locking.
+ *
+ * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
+ * do any widget power switching.
+ */
+int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
+                               const char *pin)
+{
+        return snd_soc_dapm_set_pin(dapm, pin, 0);
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
+
+/**
  * snd_soc_dapm_nc_pin - permanently disable pin.
  * @dapm: DAPM context
  * @pin: pin name
@@ -3845,7 +3993,15 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
  */
 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
 {
-        return snd_soc_dapm_set_pin(dapm, pin, 0);
+        int ret;
+
+        mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+        ret = snd_soc_dapm_set_pin(dapm, pin, 0);
+
+        mutex_unlock(&dapm->card->dapm_mutex);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
 
@@ -3985,7 +4141,7 @@ void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
 
-static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
+static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
 {
         struct snd_soc_card *card = dapm->card;
         struct snd_soc_dapm_widget *w;
@@ -4025,14 +4181,21 @@ static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
  */
 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
 {
-        struct snd_soc_codec *codec;
-
-        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
-                soc_dapm_shutdown_codec(&codec->dapm);
-                if (codec->dapm.bias_level == SND_SOC_BIAS_STANDBY)
-                        snd_soc_dapm_set_bias_level(&codec->dapm,
-                                                    SND_SOC_BIAS_OFF);
+        struct snd_soc_dapm_context *dapm;
+
+        list_for_each_entry(dapm, &card->dapm_list, list) {
+                if (dapm != &card->dapm) {
+                        soc_dapm_shutdown_dapm(dapm);
+                        if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
+                                snd_soc_dapm_set_bias_level(dapm,
+                                                            SND_SOC_BIAS_OFF);
+                }
         }
+
+        soc_dapm_shutdown_dapm(&card->dapm);
+        if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
+                snd_soc_dapm_set_bias_level(&card->dapm,
+                                            SND_SOC_BIAS_OFF);
 }
 
 /* Module information */