ASoC: dapm: Use DAPM mutex for DAPM ops instead of codec mutex
[linux-2.6.git] / sound / soc / soc-dapm.c
index 8454cc2..ffb6af5 100644 (file)
@@ -124,6 +124,81 @@ static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
        return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
 }
 
+/* get snd_card from DAPM context */
+static inline struct snd_card *dapm_get_snd_card(
+       struct snd_soc_dapm_context *dapm)
+{
+       if (dapm->codec)
+               return dapm->codec->card->snd_card;
+       else if (dapm->platform)
+               return dapm->platform->card->snd_card;
+       else
+               BUG();
+
+       /* unreachable */
+       return NULL;
+}
+
+/* get soc_card from DAPM context */
+static inline struct snd_soc_card *dapm_get_soc_card(
+               struct snd_soc_dapm_context *dapm)
+{
+       if (dapm->codec)
+               return dapm->codec->card;
+       else if (dapm->platform)
+               return dapm->platform->card;
+       else
+               BUG();
+
+       /* unreachable */
+       return NULL;
+}
+
+static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg)
+{
+       if (w->codec)
+               return snd_soc_read(w->codec, reg);
+       else if (w->platform)
+               return snd_soc_platform_read(w->platform, reg);
+
+       dev_err(w->dapm->dev, "no valid widget read method\n");
+       return -1;
+}
+
+static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, int val)
+{
+       if (w->codec)
+               return snd_soc_write(w->codec, reg, val);
+       else if (w->platform)
+               return snd_soc_platform_write(w->platform, reg, val);
+
+       dev_err(w->dapm->dev, "no valid widget write method\n");
+       return -1;
+}
+
+static int soc_widget_update_bits(struct snd_soc_dapm_widget *w,
+       unsigned short reg, unsigned int mask, unsigned int value)
+{
+       int change;
+       unsigned int old, new;
+       int ret;
+
+       ret = soc_widget_read(w, reg);
+       if (ret < 0)
+               return ret;
+
+       old = ret;
+       new = (old & ~mask) | (value & mask);
+       change = old != new;
+       if (change) {
+               ret = soc_widget_write(w, reg, new);
+               if (ret < 0)
+                       return ret;
+       }
+
+       return change;
+}
+
 /**
  * snd_soc_dapm_set_bias_level - set the bias level for the system
  * @dapm: DAPM context
@@ -139,39 +214,26 @@ static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
        struct snd_soc_card *card = dapm->card;
        int ret = 0;
 
-       switch (level) {
-       case SND_SOC_BIAS_ON:
-               dev_dbg(dapm->dev, "Setting full bias\n");
-               break;
-       case SND_SOC_BIAS_PREPARE:
-               dev_dbg(dapm->dev, "Setting bias prepare\n");
-               break;
-       case SND_SOC_BIAS_STANDBY:
-               dev_dbg(dapm->dev, "Setting standby bias\n");
-               break;
-       case SND_SOC_BIAS_OFF:
-               dev_dbg(dapm->dev, "Setting bias off\n");
-               break;
-       default:
-               dev_err(dapm->dev, "Setting invalid bias %d\n", level);
-               return -EINVAL;
-       }
-
        trace_snd_soc_bias_level_start(card, level);
 
        if (card && card->set_bias_level)
-               ret = card->set_bias_level(card, level);
-       if (ret == 0) {
-               if (dapm->codec && dapm->codec->driver->set_bias_level)
-                       ret = dapm->codec->driver->set_bias_level(dapm->codec, level);
+               ret = card->set_bias_level(card, dapm, level);
+       if (ret != 0)
+               goto out;
+
+       if (dapm->codec) {
+               if (dapm->codec->driver->set_bias_level)
+                       ret = dapm->codec->driver->set_bias_level(dapm->codec,
+                                                                 level);
                else
                        dapm->bias_level = level;
        }
-       if (ret == 0) {
-               if (card && card->set_bias_level_post)
-                       ret = card->set_bias_level_post(card, level);
-       }
+       if (ret != 0)
+               goto out;
 
+       if (card && card->set_bias_level_post)
+               ret = card->set_bias_level_post(card, dapm, level);
+out:
        trace_snd_soc_bias_level_done(card, level);
 
        return ret;
@@ -187,14 +249,14 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
        case snd_soc_dapm_mixer_named_ctl: {
                int val;
                struct soc_mixer_control *mc = (struct soc_mixer_control *)
-                       w->kcontrols[i].private_value;
+                       w->kcontrol_news[i].private_value;
                unsigned int reg = mc->reg;
                unsigned int shift = mc->shift;
                int max = mc->max;
                unsigned int mask = (1 << fls(max)) - 1;
                unsigned int invert = mc->invert;
 
-               val = snd_soc_read(w->codec, reg);
+               val = soc_widget_read(w, reg);
                val = (val >> shift) & mask;
 
                if ((invert && !val) || (!invert && val))
@@ -204,12 +266,13 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
        }
        break;
        case snd_soc_dapm_mux: {
-               struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
+               struct soc_enum *e = (struct soc_enum *)
+                       w->kcontrol_news[i].private_value;
                int val, item, bitmask;
 
                for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
-               ;
-               val = snd_soc_read(w->codec, e->reg);
+                       ;
+               val = soc_widget_read(w, e->reg);
                item = (val >> e->shift_l) & (bitmask - 1);
 
                p->connect = 0;
@@ -220,7 +283,8 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
        }
        break;
        case snd_soc_dapm_virt_mux: {
-               struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
+               struct soc_enum *e = (struct soc_enum *)
+                       w->kcontrol_news[i].private_value;
 
                p->connect = 0;
                /* since a virtual mux has no backing registers to
@@ -235,10 +299,10 @@ static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
        break;
        case snd_soc_dapm_value_mux: {
                struct soc_enum *e = (struct soc_enum *)
-                       w->kcontrols[i].private_value;
+                       w->kcontrol_news[i].private_value;
                int val, item;
 
-               val = snd_soc_read(w->codec, e->reg);
+               val = soc_widget_read(w, e->reg);
                val = (val >> e->shift_l) & e->mask;
                for (item = 0; item < e->max; item++) {
                        if (val == e->values[item])
@@ -310,11 +374,11 @@ static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
 
        /* search for mixer kcontrol */
        for (i = 0; i < dest->num_kcontrols; i++) {
-               if (!strcmp(control_name, dest->kcontrols[i].name)) {
+               if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
                        list_add(&path->list, &dapm->card->paths);
                        list_add(&path->list_sink, &dest->sources);
                        list_add(&path->list_source, &src->sinks);
-                       path->name = dest->kcontrols[i].name;
+                       path->name = dest->kcontrol_news[i].name;
                        dapm_set_path_status(dest, path, i);
                        return 0;
                }
@@ -322,15 +386,42 @@ static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
        return -ENODEV;
 }
 
+static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
+       struct snd_soc_dapm_widget *kcontrolw,
+       const struct snd_kcontrol_new *kcontrol_new,
+       struct snd_kcontrol **kcontrol)
+{
+       struct snd_soc_dapm_widget *w;
+       int i;
+
+       *kcontrol = NULL;
+
+       list_for_each_entry(w, &dapm->card->widgets, list) {
+               if (w == kcontrolw || w->dapm != kcontrolw->dapm)
+                       continue;
+               for (i = 0; i < w->num_kcontrols; i++) {
+                       if (&w->kcontrol_news[i] == kcontrol_new) {
+                               if (w->kcontrols)
+                                       *kcontrol = w->kcontrols[i];
+                               return 1;
+                       }
+               }
+       }
+
+       return 0;
+}
+
 /* create new dapm mixer control */
-static int dapm_new_mixer(struct snd_soc_dapm_context *dapm,
-       struct snd_soc_dapm_widget *w)
+static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
 {
+       struct snd_soc_dapm_context *dapm = w->dapm;
        int i, ret = 0;
        size_t name_len, prefix_len;
        struct snd_soc_dapm_path *path;
        struct snd_card *card = dapm->card->snd_card;
        const char *prefix;
+       struct snd_soc_dapm_widget_list *wlist;
+       size_t wlistsize;
 
        if (dapm->codec)
                prefix = dapm->codec->name_prefix;
@@ -349,23 +440,37 @@ static int dapm_new_mixer(struct snd_soc_dapm_context *dapm,
                list_for_each_entry(path, &w->sources, list_sink) {
 
                        /* mixer/mux paths name must match control name */
-                       if (path->name != (char*)w->kcontrols[i].name)
+                       if (path->name != (char *)w->kcontrol_news[i].name)
                                continue;
 
+                       wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
+                                   sizeof(struct snd_soc_dapm_widget *),
+                       wlist = kzalloc(wlistsize, GFP_KERNEL);
+                       if (wlist == NULL) {
+                               dev_err(dapm->dev,
+                                       "asoc: can't allocate widget list for %s\n",
+                                       w->name);
+                               return -ENOMEM;
+                       }
+                       wlist->num_widgets = 1;
+                       wlist->widgets[0] = w;
+
                        /* add dapm control with long name.
                         * for dapm_mixer this is the concatenation of the
                         * mixer and kcontrol name.
                         * for dapm_mixer_named_ctl this is simply the
                         * kcontrol name.
                         */
-                       name_len = strlen(w->kcontrols[i].name) + 1;
+                       name_len = strlen(w->kcontrol_news[i].name) + 1;
                        if (w->id != snd_soc_dapm_mixer_named_ctl)
                                name_len += 1 + strlen(w->name);
 
                        path->long_name = kmalloc(name_len, GFP_KERNEL);
 
-                       if (path->long_name == NULL)
+                       if (path->long_name == NULL) {
+                               kfree(wlist);
                                return -ENOMEM;
+                       }
 
                        switch (w->id) {
                        default:
@@ -377,82 +482,122 @@ static int dapm_new_mixer(struct snd_soc_dapm_context *dapm,
                                 */
                                snprintf(path->long_name, name_len, "%s %s",
                                         w->name + prefix_len,
-                                        w->kcontrols[i].name);
+                                        w->kcontrol_news[i].name);
                                break;
                        case snd_soc_dapm_mixer_named_ctl:
                                snprintf(path->long_name, name_len, "%s",
-                                        w->kcontrols[i].name);
+                                        w->kcontrol_news[i].name);
                                break;
                        }
 
                        path->long_name[name_len - 1] = '\0';
 
-                       path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
-                                                     path->long_name, prefix);
+                       path->kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
+                                                     wlist, path->long_name,
+                                                     prefix);
                        ret = snd_ctl_add(card, path->kcontrol);
                        if (ret < 0) {
                                dev_err(dapm->dev,
                                        "asoc: failed to add dapm kcontrol %s: %d\n",
                                        path->long_name, ret);
+                               kfree(wlist);
                                kfree(path->long_name);
                                path->long_name = NULL;
                                return ret;
                        }
+                       w->kcontrols[i] = path->kcontrol;
                }
        }
        return ret;
 }
 
 /* create new dapm mux control */
-static int dapm_new_mux(struct snd_soc_dapm_context *dapm,
-       struct snd_soc_dapm_widget *w)
+static int dapm_new_mux(struct snd_soc_dapm_widget *w)
 {
+       struct snd_soc_dapm_context *dapm = w->dapm;
        struct snd_soc_dapm_path *path = NULL;
        struct snd_kcontrol *kcontrol;
        struct snd_card *card = dapm->card->snd_card;
        const char *prefix;
        size_t prefix_len;
-       int ret = 0;
-
-       if (!w->num_kcontrols) {
-               dev_err(dapm->dev, "asoc: mux %s has no controls\n", w->name);
+       int ret;
+       struct snd_soc_dapm_widget_list *wlist;
+       int shared, wlistentries;
+       size_t wlistsize;
+       char *name;
+
+       if (w->num_kcontrols != 1) {
+               dev_err(dapm->dev,
+                       "asoc: mux %s has incorrect number of controls\n",
+                       w->name);
                return -EINVAL;
        }
 
-       if (dapm->codec)
-               prefix = dapm->codec->name_prefix;
-       else
-               prefix = NULL;
+       shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[0],
+                                        &kcontrol);
+       if (kcontrol) {
+               wlist = kcontrol->private_data;
+               wlistentries = wlist->num_widgets + 1;
+       } else {
+               wlist = NULL;
+               wlistentries = 1;
+       }
+       wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
+               wlistentries * sizeof(struct snd_soc_dapm_widget *),
+       wlist = krealloc(wlist, wlistsize, GFP_KERNEL);
+       if (wlist == NULL) {
+               dev_err(dapm->dev,
+                       "asoc: can't allocate widget list for %s\n", w->name);
+               return -ENOMEM;
+       }
+       wlist->num_widgets = wlistentries;
+       wlist->widgets[wlistentries - 1] = w;
 
-       if (prefix)
-               prefix_len = strlen(prefix) + 1;
-       else
-               prefix_len = 0;
+       if (!kcontrol) {
+               if (dapm->codec)
+                       prefix = dapm->codec->name_prefix;
+               else
+                       prefix = NULL;
+
+               if (shared) {
+                       name = w->kcontrol_news[0].name;
+                       prefix_len = 0;
+               } else {
+                       name = w->name;
+                       if (prefix)
+                               prefix_len = strlen(prefix) + 1;
+                       else
+                               prefix_len = 0;
+               }
 
-       /* The control will get a prefix from the control creation
-        * process but we're also using the same prefix for widgets so
-        * cut the prefix off the front of the widget name.
-        */
-       kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name + prefix_len,
-                               prefix);
-       ret = snd_ctl_add(card, kcontrol);
+               /*
+                * The control will get a prefix from the control creation
+                * process but we're also using the same prefix for widgets so
+                * cut the prefix off the front of the widget name.
+                */
+               kcontrol = snd_soc_cnew(&w->kcontrol_news[0], wlist,
+                                       name + prefix_len, prefix);
+               ret = snd_ctl_add(card, kcontrol);
+               if (ret < 0) {
+                       dev_err(dapm->dev,
+                               "asoc: failed to add kcontrol %s\n", w->name);
+                       kfree(wlist);
+                       return ret;
+               }
+       }
 
-       if (ret < 0)
-               goto err;
+       kcontrol->private_data = wlist;
+
+       w->kcontrols[0] = kcontrol;
 
        list_for_each_entry(path, &w->sources, list_sink)
                path->kcontrol = kcontrol;
 
-       return ret;
-
-err:
-       dev_err(dapm->dev, "asoc: failed to add kcontrol %s\n", w->name);
-       return ret;
+       return 0;
 }
 
 /* create new dapm volume control */
-static int dapm_new_pga(struct snd_soc_dapm_context *dapm,
-       struct snd_soc_dapm_widget *w)
+static int dapm_new_pga(struct snd_soc_dapm_widget *w)
 {
        if (w->num_kcontrols)
                dev_err(w->dapm->dev,
@@ -523,6 +668,9 @@ static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
        }
 
        list_for_each_entry(path, &widget->sinks, list_source) {
+               if (path->weak)
+                       continue;
+
                if (path->walked)
                        continue;
 
@@ -573,6 +721,9 @@ static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
        }
 
        list_for_each_entry(path, &widget->sources, list_sink) {
+               if (path->weak)
+                       continue;
+
                if (path->walked)
                        continue;
 
@@ -598,7 +749,7 @@ int dapm_reg_event(struct snd_soc_dapm_widget *w,
        else
                val = w->off_val;
 
-       snd_soc_update_bits(w->codec, -(w->reg + 1),
+       soc_widget_update_bits(w, -(w->reg + 1),
                            w->mask << w->shift, val << w->shift);
 
        return 0;
@@ -654,6 +805,9 @@ static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
 
        /* Check if one of our outputs is connected */
        list_for_each_entry(path, &w->sinks, list_source) {
+               if (path->weak)
+                       continue;
+
                if (path->connected &&
                    !path->connected(path->source, path->sink))
                        continue;
@@ -802,11 +956,17 @@ static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
        }
 
        if (reg >= 0) {
+               /* Any widget will do, they should all be updating the
+                * same register.
+                */
+               w = list_first_entry(pending, struct snd_soc_dapm_widget,
+                                    power_list);
+
                pop_dbg(dapm->dev, card->pop_time,
                        "pop test : Applying 0x%x/0x%x to %x in %dms\n",
                        value, mask, reg, card->pop_time);
                pop_wait(card->pop_time);
-               snd_soc_update_bits(dapm->codec, reg, mask, value);
+               soc_widget_update_bits(w, reg, mask, value);
        }
 
        list_for_each_entry(w, pending, power_list) {
@@ -859,7 +1019,7 @@ static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
 
                        INIT_LIST_HEAD(&pending);
                        cur_sort = -1;
-                       cur_subseq = -1;
+                       cur_subseq = INT_MIN;
                        cur_reg = SND_SOC_NOPM;
                        cur_dapm = NULL;
                }
@@ -958,16 +1118,17 @@ static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
        struct snd_soc_dapm_context *d = data;
        int ret;
 
-       if (d->dev_power && d->bias_level == SND_SOC_BIAS_OFF) {
+       /* If we're off and we're not supposed to be go into STANDBY */
+       if (d->bias_level == SND_SOC_BIAS_OFF &&
+           d->target_bias_level != SND_SOC_BIAS_OFF) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
                if (ret != 0)
                        dev_err(d->dev,
                                "Failed to turn on bias: %d\n", ret);
        }
 
-       /* If we're changing to all on or all off then prepare */
-       if ((d->dev_power && d->bias_level == SND_SOC_BIAS_STANDBY) ||
-           (!d->dev_power && d->bias_level == SND_SOC_BIAS_ON)) {
+       /* Prepare for a STADDBY->ON or ON->STANDBY transition */
+       if (d->bias_level != d->target_bias_level) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
                if (ret != 0)
                        dev_err(d->dev,
@@ -984,7 +1145,9 @@ static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
        int ret;
 
        /* If we just powered the last thing off drop to standby bias */
-       if (d->bias_level == SND_SOC_BIAS_PREPARE && !d->dev_power) {
+       if (d->bias_level == SND_SOC_BIAS_PREPARE &&
+           (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
+            d->target_bias_level == SND_SOC_BIAS_OFF)) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
                if (ret != 0)
                        dev_err(d->dev, "Failed to apply standby bias: %d\n",
@@ -992,14 +1155,16 @@ static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
        }
 
        /* If we're in standby and can support bias off then do that */
-       if (d->bias_level == SND_SOC_BIAS_STANDBY && d->idle_bias_off) {
+       if (d->bias_level == SND_SOC_BIAS_STANDBY &&
+           d->target_bias_level == SND_SOC_BIAS_OFF) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
                if (ret != 0)
                        dev_err(d->dev, "Failed to turn off bias: %d\n", ret);
        }
 
        /* If we just powered up then move to active bias */
-       if (d->bias_level == SND_SOC_BIAS_PREPARE && d->dev_power) {
+       if (d->bias_level == SND_SOC_BIAS_PREPARE &&
+           d->target_bias_level == SND_SOC_BIAS_ON) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
                if (ret != 0)
                        dev_err(d->dev, "Failed to apply active bias: %d\n",
@@ -1024,13 +1189,19 @@ static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
        LIST_HEAD(up_list);
        LIST_HEAD(down_list);
        LIST_HEAD(async_domain);
+       enum snd_soc_bias_level bias;
        int power;
 
        trace_snd_soc_dapm_start(card);
 
-       list_for_each_entry(d, &card->dapm_list, list)
-               if (d->n_widgets)
-                       d->dev_power = 0;
+       list_for_each_entry(d, &card->dapm_list, list) {
+               if (d->n_widgets || d->codec == NULL) {
+                       if (d->idle_bias_off)
+                               d->target_bias_level = SND_SOC_BIAS_OFF;
+                       else
+                               d->target_bias_level = SND_SOC_BIAS_STANDBY;
+               }
+       }
 
        /* Check which widgets we need to power and store them in
         * lists indicating if they should be powered up or down.
@@ -1052,8 +1223,27 @@ static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
                                power = w->power_check(w);
                        else
                                power = 1;
-                       if (power)
-                               w->dapm->dev_power = 1;
+
+                       if (power) {
+                               d = w->dapm;
+
+                               /* Supplies and micbiases only bring
+                                * the context up to STANDBY as unless
+                                * something else is active and
+                                * passing audio they generally don't
+                                * require full power.
+                                */
+                               switch (w->id) {
+                               case snd_soc_dapm_supply:
+                               case snd_soc_dapm_micbias:
+                                       if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
+                                               d->target_bias_level = SND_SOC_BIAS_STANDBY;
+                                       break;
+                               default:
+                                       d->target_bias_level = SND_SOC_BIAS_ON;
+                                       break;
+                               }
+                       }
 
                        if (w->power == power)
                                continue;
@@ -1077,24 +1267,19 @@ static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
                switch (event) {
                case SND_SOC_DAPM_STREAM_START:
                case SND_SOC_DAPM_STREAM_RESUME:
-                       dapm->dev_power = 1;
+                       dapm->target_bias_level = SND_SOC_BIAS_ON;
                        break;
                case SND_SOC_DAPM_STREAM_STOP:
-                       dapm->dev_power = !!dapm->codec->active;
+                       if (dapm->codec->active)
+                               dapm->target_bias_level = SND_SOC_BIAS_ON;
+                       else
+                               dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
                        break;
                case SND_SOC_DAPM_STREAM_SUSPEND:
-                       dapm->dev_power = 0;
+                       dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
                        break;
                case SND_SOC_DAPM_STREAM_NOP:
-                       switch (dapm->bias_level) {
-                               case SND_SOC_BIAS_STANDBY:
-                               case SND_SOC_BIAS_OFF:
-                                       dapm->dev_power = 0;
-                                       break;
-                               default:
-                                       dapm->dev_power = 1;
-                                       break;
-                       }
+                       dapm->target_bias_level = dapm->bias_level;
                        break;
                default:
                        break;
@@ -1102,12 +1287,12 @@ static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
        }
 
        /* Force all contexts in the card to the same bias state */
-       power = 0;
+       bias = SND_SOC_BIAS_OFF;
        list_for_each_entry(d, &card->dapm_list, list)
-               if (d->dev_power)
-                       power = 1;
+               if (d->target_bias_level > bias)
+                       bias = d->target_bias_level;
        list_for_each_entry(d, &card->dapm_list, list)
-               d->dev_power = power;
+               d->target_bias_level = bias;
 
 
        /* Run all the bias changes in parallel */
@@ -1292,6 +1477,11 @@ static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
                        w->name);
 }
 
+static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
+{
+       debugfs_remove_recursive(dapm->debugfs_dapm);
+}
+
 #else
 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
        struct dentry *parent)
@@ -1302,6 +1492,10 @@ static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
 {
 }
 
+static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
+{
+}
+
 #endif
 
 /* test and update the power status of a mux widget */
@@ -1469,6 +1663,7 @@ static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
                        kfree(p->long_name);
                        kfree(p);
                }
+               kfree(w->kcontrols);
                kfree(w->name);
                kfree(w);
        }
@@ -1524,7 +1719,12 @@ static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
  */
 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
 {
-       return dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
+       int ret;
+
+       mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
+       ret = dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
+       mutex_unlock(&dapm->card->dapm_mutex);
+       return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
 
@@ -1639,7 +1839,7 @@ static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
        case snd_soc_dapm_virt_mux:
        case snd_soc_dapm_value_mux:
                ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
-                       &wsink->kcontrols[0]);
+                       &wsink->kcontrol_news[0]);
                if (ret != 0)
                        goto err;
                break;
@@ -1687,20 +1887,103 @@ int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
 {
        int i, ret;
 
+       mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
        for (i = 0; i < num; i++) {
                ret = snd_soc_dapm_add_route(dapm, route);
                if (ret < 0) {
                        dev_err(dapm->dev, "Failed to add route %s->%s\n",
                                route->source, route->sink);
+                       mutex_unlock(&dapm->card->dapm_mutex);
                        return ret;
                }
                route++;
        }
+       mutex_unlock(&dapm->card->dapm_mutex);
 
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
 
+static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
+                                  const struct snd_soc_dapm_route *route)
+{
+       struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
+                                                             route->source,
+                                                             true);
+       struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
+                                                           route->sink,
+                                                           true);
+       struct snd_soc_dapm_path *path;
+       int count = 0;
+
+       if (!source) {
+               dev_err(dapm->dev, "Unable to find source %s for weak route\n",
+                       route->source);
+               return -ENODEV;
+       }
+
+       if (!sink) {
+               dev_err(dapm->dev, "Unable to find sink %s for weak route\n",
+                       route->sink);
+               return -ENODEV;
+       }
+
+       if (route->control || route->connected)
+               dev_warn(dapm->dev, "Ignoring control for weak route %s->%s\n",
+                        route->source, route->sink);
+
+       list_for_each_entry(path, &source->sinks, list_source) {
+               if (path->sink == sink) {
+                       path->weak = 1;
+                       count++;
+               }
+       }
+
+       if (count == 0)
+               dev_err(dapm->dev, "No path found for weak route %s->%s\n",
+                       route->source, route->sink);
+       if (count > 1)
+               dev_warn(dapm->dev, "%d paths found for weak route %s->%s\n",
+                        count, route->source, route->sink);
+
+       return 0;
+}
+
+/**
+ * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
+ * @dapm: DAPM context
+ * @route: audio routes
+ * @num: number of routes
+ *
+ * Mark existing routes matching those specified in the passed array
+ * as being weak, meaning that they are ignored for the purpose of
+ * power decisions.  The main intended use case is for sidetone paths
+ * which couple audio between other independent paths if they are both
+ * active in order to make the combination work better at the user
+ * level but which aren't intended to be "used".
+ *
+ * Note that CODEC drivers should not use this as sidetone type paths
+ * can frequently also be used as bypass paths.
+ */
+int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
+                            const struct snd_soc_dapm_route *route, int num)
+{
+       int i, err;
+       int ret = 0;
+
+       mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
+       for (i = 0; i < num; i++) {
+               err = snd_soc_dapm_weak_route(dapm, route);
+               if (err)
+                       ret = err;
+               route++;
+       }
+       mutex_unlock(&dapm->card->dapm_mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
+
 /**
  * snd_soc_dapm_new_widgets - add new dapm widgets
  * @dapm: DAPM context
@@ -1714,23 +1997,35 @@ int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
        struct snd_soc_dapm_widget *w;
        unsigned int val;
 
+       mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
+
        list_for_each_entry(w, &dapm->card->widgets, list)
        {
                if (w->new)
                        continue;
 
+               if (w->num_kcontrols) {
+                       w->kcontrols = kzalloc(w->num_kcontrols *
+                                               sizeof(struct snd_kcontrol *),
+                                               GFP_KERNEL);
+                       if (!w->kcontrols) {
+                               mutex_unlock(&dapm->card->dapm_mutex);
+                               return -ENOMEM;
+                       }
+               }
+
                switch(w->id) {
                case snd_soc_dapm_switch:
                case snd_soc_dapm_mixer:
                case snd_soc_dapm_mixer_named_ctl:
                        w->power_check = dapm_generic_check_power;
-                       dapm_new_mixer(dapm, w);
+                       dapm_new_mixer(w);
                        break;
                case snd_soc_dapm_mux:
                case snd_soc_dapm_virt_mux:
                case snd_soc_dapm_value_mux:
                        w->power_check = dapm_generic_check_power;
-                       dapm_new_mux(dapm, w);
+                       dapm_new_mux(w);
                        break;
                case snd_soc_dapm_adc:
                case snd_soc_dapm_aif_out:
@@ -1743,7 +2038,7 @@ int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
                case snd_soc_dapm_pga:
                case snd_soc_dapm_out_drv:
                        w->power_check = dapm_generic_check_power;
-                       dapm_new_pga(dapm, w);
+                       dapm_new_pga(w);
                        break;
                case snd_soc_dapm_input:
                case snd_soc_dapm_output:
@@ -1764,7 +2059,7 @@ int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
 
                /* Read the initial power state from the device */
                if (w->reg >= 0) {
-                       val = snd_soc_read(w->codec, w->reg);
+                       val = soc_widget_read(w, w->reg);
                        val &= 1 << w->shift;
                        if (w->invert)
                                val = !val;
@@ -1779,6 +2074,7 @@ int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
        }
 
        dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
+       mutex_unlock(&dapm->card->dapm_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
@@ -1795,7 +2091,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
        struct soc_mixer_control *mc =
                (struct soc_mixer_control *)kcontrol->private_value;
        unsigned int reg = mc->reg;
@@ -1834,7 +2131,10 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
+       struct snd_soc_codec *codec = widget->codec;
+       struct snd_soc_card *card = codec->card;
        struct soc_mixer_control *mc =
                (struct soc_mixer_control *)kcontrol->private_value;
        unsigned int reg = mc->reg;
@@ -1845,6 +2145,7 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
        unsigned int val;
        int connect, change;
        struct snd_soc_dapm_update update;
+       int wi;
 
        val = (ucontrol->value.integer.value[0] & mask);
 
@@ -1853,31 +2154,36 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
        mask = mask << shift;
        val = val << shift;
 
-       mutex_lock(&widget->codec->mutex);
-       widget->value = val;
+       if (val)
+               /* new connection */
+               connect = invert ? 0 : 1;
+       else
+               /* old connection must be powered down */
+               connect = invert ? 1 : 0;
+
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
 
        change = snd_soc_test_bits(widget->codec, reg, mask, val);
        if (change) {
-               if (val)
-                       /* new connection */
-                       connect = invert ? 0:1;
-               else
-                       /* old connection must be powered down */
-                       connect = invert ? 1:0;
+               for (wi = 0; wi < wlist->num_widgets; wi++) {
+                       widget = wlist->widgets[wi];
+
+                       widget->value = val;
 
-               update.kcontrol = kcontrol;
-               update.widget = widget;
-               update.reg = reg;
-               update.mask = mask;
-               update.val = val;
-               widget->dapm->update = &update;
+                       update.kcontrol = kcontrol;
+                       update.widget = widget;
+                       update.reg = reg;
+                       update.mask = mask;
+                       update.val = val;
+                       widget->dapm->update = &update;
 
-               dapm_mixer_update_power(widget, kcontrol, connect);
+                       dapm_mixer_update_power(widget, kcontrol, connect);
 
-               widget->dapm->update = NULL;
+                       widget->dapm->update = NULL;
+               }
        }
 
-       mutex_unlock(&widget->codec->mutex);
+       mutex_unlock(&card->dapm_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
@@ -1894,7 +2200,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int val, bitmask;
 
@@ -1922,11 +2229,15 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
+       struct snd_soc_codec *codec = widget->codec;
+       struct snd_soc_card *card = codec->card;
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int val, mux, change;
        unsigned int mask, bitmask;
        struct snd_soc_dapm_update update;
+       int wi;
 
        for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
                ;
@@ -1942,22 +2253,29 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
                mask |= (bitmask - 1) << e->shift_r;
        }
 
-       mutex_lock(&widget->codec->mutex);
-       widget->value = val;
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
+
        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
+       if (change) {
+               for (wi = 0; wi < wlist->num_widgets; wi++) {
+                       widget = wlist->widgets[wi];
+
+                       widget->value = val;
 
-       update.kcontrol = kcontrol;
-       update.widget = widget;
-       update.reg = e->reg;
-       update.mask = mask;
-       update.val = val;
-       widget->dapm->update = &update;
+                       update.kcontrol = kcontrol;
+                       update.widget = widget;
+                       update.reg = e->reg;
+                       update.mask = mask;
+                       update.val = val;
+                       widget->dapm->update = &update;
 
-       dapm_mux_update_power(widget, kcontrol, change, mux, e);
+                       dapm_mux_update_power(widget, kcontrol, change, mux, e);
 
-       widget->dapm->update = NULL;
+                       widget->dapm->update = NULL;
+               }
+       }
 
-       mutex_unlock(&widget->codec->mutex);
+       mutex_unlock(&card->dapm_mutex);
        return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
@@ -1972,7 +2290,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
 int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
                               struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
 
        ucontrol->value.enumerated.item[0] = widget->value;
 
@@ -1990,22 +2309,34 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
 int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
                               struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
+       struct snd_soc_codec *codec = widget->codec;
+       struct snd_soc_card *card = codec->card;
        struct soc_enum *e =
                (struct soc_enum *)kcontrol->private_value;
        int change;
        int ret = 0;
+       int wi;
 
        if (ucontrol->value.enumerated.item[0] >= e->max)
                return -EINVAL;
 
-       mutex_lock(&widget->codec->mutex);
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
 
        change = widget->value != ucontrol->value.enumerated.item[0];
-       widget->value = ucontrol->value.enumerated.item[0];
-       dapm_mux_update_power(widget, kcontrol, change, widget->value, e);
+       if (change) {
+               for (wi = 0; wi < wlist->num_widgets; wi++) {
+                       widget = wlist->widgets[wi];
 
-       mutex_unlock(&widget->codec->mutex);
+                       widget->value = ucontrol->value.enumerated.item[0];
+
+                       dapm_mux_update_power(widget, kcontrol, change,
+                                             widget->value, e);
+               }
+       }
+
+       mutex_unlock(&card->dapm_mutex);
        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
@@ -2026,7 +2357,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
 int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int reg_val, val, mux;
 
@@ -2066,11 +2398,15 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_get_value_enum_double);
 int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
 {
-       struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_dapm_widget *widget = wlist->widgets[0];
+       struct snd_soc_codec *codec = widget->codec;
+       struct snd_soc_card *card = codec->card;
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
        unsigned int val, mux, change;
        unsigned int mask;
        struct snd_soc_dapm_update update;
+       int wi;
 
        if (ucontrol->value.enumerated.item[0] > e->max - 1)
                return -EINVAL;
@@ -2084,22 +2420,29 @@ int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
                mask |= e->mask << e->shift_r;
        }
 
-       mutex_lock(&widget->codec->mutex);
-       widget->value = val;
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
+
        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
+       if (change) {
+               for (wi = 0; wi < wlist->num_widgets; wi++) {
+                       widget = wlist->widgets[wi];
 
-       update.kcontrol = kcontrol;
-       update.widget = widget;
-       update.reg = e->reg;
-       update.mask = mask;
-       update.val = val;
-       widget->dapm->update = &update;
+                       widget->value = val;
 
-       dapm_mux_update_power(widget, kcontrol, change, mux, e);
+                       update.kcontrol = kcontrol;
+                       update.widget = widget;
+                       update.reg = e->reg;
+                       update.mask = mask;
+                       update.val = val;
+                       widget->dapm->update = &update;
 
-       widget->dapm->update = NULL;
+                       dapm_mux_update_power(widget, kcontrol, change, mux, e);
 
-       mutex_unlock(&widget->codec->mutex);
+                       widget->dapm->update = NULL;
+               }
+       }
+
+       mutex_unlock(&card->dapm_mutex);
        return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
@@ -2134,14 +2477,15 @@ int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
                                struct snd_ctl_elem_value *ucontrol)
 {
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_card *card = codec->card;
        const char *pin = (const char *)kcontrol->private_value;
 
-       mutex_lock(&codec->mutex);
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
 
        ucontrol->value.integer.value[0] =
                snd_soc_dapm_get_pin_status(&codec->dapm, pin);
 
-       mutex_unlock(&codec->mutex);
+       mutex_unlock(&card->dapm_mutex);
 
        return 0;
 }
@@ -2157,19 +2501,19 @@ int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
                                struct snd_ctl_elem_value *ucontrol)
 {
        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+       struct snd_soc_card *card = codec->card;
        const char *pin = (const char *)kcontrol->private_value;
 
-       mutex_lock(&codec->mutex);
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
 
        if (ucontrol->value.integer.value[0])
                snd_soc_dapm_enable_pin(&codec->dapm, pin);
        else
                snd_soc_dapm_disable_pin(&codec->dapm, pin);
 
-       snd_soc_dapm_sync(&codec->dapm);
-
-       mutex_unlock(&codec->mutex);
+       mutex_unlock(&card->dapm_mutex);
 
+       snd_soc_dapm_sync(&codec->dapm);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
@@ -2209,6 +2553,7 @@ int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
        dapm->n_widgets++;
        w->dapm = dapm;
        w->codec = dapm->codec;
+       w->platform = dapm->platform;
        INIT_LIST_HEAD(&w->sources);
        INIT_LIST_HEAD(&w->sinks);
        INIT_LIST_HEAD(&w->list);
@@ -2236,16 +2581,19 @@ int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
 {
        int i, ret;
 
+       mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
        for (i = 0; i < num; i++) {
                ret = snd_soc_dapm_new_control(dapm, widget);
                if (ret < 0) {
                        dev_err(dapm->dev,
                                "ASoC: Failed to create DAPM control %s: %d\n",
                                widget->name, ret);
+                       mutex_unlock(&dapm->card->dapm_mutex);
                        return ret;
                }
                widget++;
        }
+       mutex_unlock(&dapm->card->dapm_mutex);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
@@ -2296,13 +2644,14 @@ int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
        const char *stream, int event)
 {
        struct snd_soc_codec *codec = rtd->codec;
+       struct snd_soc_card *card = rtd->card;
 
        if (stream == NULL)
                return 0;
 
-       mutex_lock(&codec->mutex);
+       mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_PCM);
        soc_dapm_stream_event(&codec->dapm, stream, event);
-       mutex_unlock(&codec->mutex);
+       mutex_unlock(&card->dapm_mutex);
        return 0;
 }
 
@@ -2438,13 +2787,14 @@ EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
 
 /**
  * snd_soc_dapm_free - free dapm resources
- * @card: SoC device
+ * @dapm: DAPM context
  *
  * Free all dapm widgets and resources.
  */
 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
 {
        snd_soc_dapm_sys_remove(dapm->dev);
+       dapm_debugfs_cleanup(dapm);
        dapm_free_widgets(dapm);
        list_del(&dapm->list);
 }