ASoC: soc-dapm: convert to snd_soc_dapm_xxx()

This patch converts below functions.

dapm->dev -> snd_soc_dapm_to_dev()
dapm->card -> snd_soc_dapm_to_card()
dapm->component -> snd_soc_dapm_to_component()

dapm_kcontrol_get_value() -> snd_soc_dapm_kcontrol_get_value()

snd_soc_component_enable_pin() -> snd_soc_dapm_enable_pin()
snd_soc_component_enable_pin_unlocked() -> snd_soc_dapm_enable_pin_unlocked()
snd_soc_component_disable_pin() -> snd_soc_dapm_disable_pin()
snd_soc_component_disable_pin_unlocked() -> snd_soc_dapm_disable_pin_unlocked()
snd_soc_component_nc_pin() -> snd_soc_dapm_nc_pin()
snd_soc_component_nc_pin_unlocked() -> snd_soc_dapm_nc_pin_unlocked()
snd_soc_component_get_pin_status() -> snd_soc_dapm_get_pin_status()
snd_soc_component_force_enable_pin() -> snd_soc_dapm_force_enable_pin()
snd_soc_component_force_enable_pin_unlocked() -> snd_soc_dapm_force_enable_pin_unlocked()
snd_soc_component_force_bias_level() -> snd_soc_dapm_force_bias_level()
snd_soc_component_get_bias_level() -> snd_soc_dapm_get_bias_level()
snd_soc_component_init_bias_level() -> snd_soc_dapm_init_bias_level()
snd_soc_component_get_dapm() -> snd_soc_component_to_dapm()

snd_soc_dapm_kcontrol_component() -> snd_soc_dapm_kcontrol_to_component()
snd_soc_dapm_kcontrol_widget() -> snd_soc_dapm_kcontrol_to_widget()
snd_soc_dapm_kcontrol_dapm() -> snd_soc_dapm_kcontrol_to_dapm()
snd_soc_dapm_np_pin() -> snd_soc_dapm_disable_pin()

Signed-off-by: Kuninori Morimoto <[e-mail]>
Reviewed-by: Charles Keepax <[e-mail]>
Link: https://patch.msgid.link/[e-mail]
Signed-off-by: Mark Brown <[e-mail]>

sound/soc/soc-dapm.c

···
 
 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
 {
+	struct device *dev = snd_soc_dapm_to_dev(w->dapm);
+
 	dapm_assert_locked(w->dapm);
 
 	if (!dapm_dirty_widget(w)) {
-		dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
+		dev_vdbg(dev, "Marking %s dirty due to %s\n",
 			 w->name, reason);
 		list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
 	}
···
 	struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
 	const char *control)
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	bool dynamic_source = false;
 	bool dynamic_sink = false;
 
···
 	}
 
 	if (dynamic_source && dynamic_sink) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
 			source->name, control, sink->name);
 		return -EINVAL;
 	} else if (!dynamic_source && !dynamic_sink) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"Control not supported for path %s -> [%s] -> %s\n",
 			source->name, control, sink->name);
 		return -EINVAL;
···
 	int (*connected)(struct snd_soc_dapm_widget *source,
 			 struct snd_soc_dapm_widget *sink))
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	enum snd_soc_dapm_direction dir;
 	struct snd_soc_dapm_path *path;
 	int ret;
 
 	if (wsink->is_supply && !wsource->is_supply) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
 			wsource->name, wsink->name);
 		return -EINVAL;
 	}
 
 	if (connected && !wsource->is_supply) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"connected() callback only supported for supply widgets (%s -> %s)\n",
 			wsource->name, wsink->name);
 		return -EINVAL;
 	}
 
 	if (wsource->is_supply && control) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
 			wsource->name, control, wsink->name);
 		return -EINVAL;
···
 static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
 	struct snd_kcontrol *kcontrol, const char *ctrl_name)
 {
+	struct device *dev = snd_soc_dapm_to_dev(widget->dapm);
 	struct dapm_kcontrol_data *data;
 	struct soc_mixer_control *mc;
 	struct soc_enum *e;
···
 			struct snd_soc_dapm_widget template;
 
 			if (snd_soc_volsw_is_stereo(mc))
-				dev_warn(widget->dapm->dev,
+				dev_warn(dev,
 					 "ASoC: Unsupported stereo autodisable control '%s'\n",
 					 ctrl_name);
 
···
 	int kci)
 {
 	struct snd_soc_dapm_context *dapm = w->dapm;
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	struct snd_card *card = dapm->card->snd_card;
 	const char *prefix;
 	size_t prefix_len;
···
 
 		ret = snd_ctl_add(card, kcontrol);
 		if (ret < 0) {
-			dev_err(dapm->dev,
+			dev_err(dev,
 				"ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
 				w->name, name, ret);
 			goto exit_free;
···
 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
 {
 	struct snd_soc_dapm_context *dapm = w->dapm;
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	enum snd_soc_dapm_direction dir;
 	struct snd_soc_dapm_path *path;
 	const char *type;
···
 	}
 
 	if (w->num_kcontrols != 1) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"ASoC: %s %s has incorrect number of controls\n", type,
 			w->name);
 		return -EINVAL;
 	}
 
 	if (list_empty(&w->edges[dir])) {
-		dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
+		dev_err(dev, "ASoC: %s %s has no paths\n", type, w->name);
 		return -EINVAL;
 	}
 
···
 	/* add kcontrol */
 	for (i = 0; i < w->num_kcontrols; i++) {
 		struct snd_soc_dapm_context *dapm = w->dapm;
+		struct device *dev = snd_soc_dapm_to_dev(dapm);
 		struct snd_card *card = dapm->card->snd_card;
 		struct snd_kcontrol *kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
 							     w, w->name, NULL);
 		int ret = snd_ctl_add(card, kcontrol);
 
 		if (ret < 0) {
-			dev_err(dapm->dev,
+			dev_err(dev,
 				"ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
 				w->name, w->kcontrol_news[i].name, ret);
 			return ret;
···
  */
 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
 {
+	struct device *dev = snd_soc_dapm_to_dev(widget->dapm);
 	int level = snd_power_get_state(widget->dapm->card->snd_card);
 
 	switch (level) {
 	case SNDRV_CTL_POWER_D3hot:
 	case SNDRV_CTL_POWER_D3cold:
 		if (widget->ignore_suspend)
-			dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
+			dev_dbg(dev, "ASoC: %s ignoring suspend\n",
 				widget->name);
 		return widget->ignore_suspend;
 	default:
···
 int snd_soc_dapm_regulator_event(struct snd_soc_dapm_widget *w,
 				 struct snd_kcontrol *kcontrol, int event)
 {
+	struct device *dev = snd_soc_dapm_to_dev(w->dapm);
 	int ret;
 
 	soc_dapm_async_complete(w->dapm);
···
 		if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
 			ret = regulator_allow_bypass(w->regulator, false);
 			if (ret != 0)
-				dev_warn(w->dapm->dev,
+				dev_warn(dev,
 					 "ASoC: Failed to unbypass %s: %d\n",
 					 w->name, ret);
 		}
···
 		if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
 			ret = regulator_allow_bypass(w->regulator, true);
 			if (ret != 0)
-				dev_warn(w->dapm->dev,
+				dev_warn(dev,
 					 "ASoC: Failed to bypass %s: %d\n",
 					 w->name, ret);
 		}
···
 static void dapm_seq_check_event(struct snd_soc_card *card,
 				 struct snd_soc_dapm_widget *w, int event)
 {
+	struct device *dev = card->dev;
 	const char *ev_name;
 	int power;
 
···
 	if (w->event && (w->event_flags & event)) {
 		int ret;
 
-		pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
+		pop_dbg(dev, card->pop_time, "pop test : %s %s\n",
 			w->name, ev_name);
 		soc_dapm_async_complete(w->dapm);
 		trace_snd_soc_dapm_widget_event_start(w, event);
 		ret = w->event(w, NULL, event);
 		trace_snd_soc_dapm_widget_event_done(w, event);
 		if (ret < 0)
-			dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
+			dev_err(dev, "ASoC: %s: %s event failed: %d\n",
 			       ev_name, w->name, ret);
 	}
 }
···
 static void dapm_seq_run_coalesced(struct snd_soc_card *card,
 				   struct list_head *pending)
 {
+	struct device *dev = card->dev;
 	struct snd_soc_dapm_context *dapm;
 	struct snd_soc_dapm_widget *w;
 	int reg;
···
 		else
 			value |= w->off_val << w->shift;
 
-		pop_dbg(dapm->dev, card->pop_time,
+		pop_dbg(dev, card->pop_time,
 			"pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
 			w->name, reg, value, mask);
 
···
 		 * same register.
 		 */
 
-		pop_dbg(dapm->dev, card->pop_time,
+		pop_dbg(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);
···
 static void dapm_seq_run(struct snd_soc_card *card,
 	struct list_head *list, int event, bool power_up)
 {
+	struct device *dev = card->dev;
 	struct snd_soc_dapm_widget *w, *n;
 	struct snd_soc_dapm_context *d;
 	LIST_HEAD(pending);
···
 		}
 
 		if (ret < 0)
-			dev_err(w->dapm->dev,
+			dev_err(dev,
 				"ASoC: Failed to apply widget power: %d\n", ret);
 	}
 
···
 
 static void dapm_widget_update(struct snd_soc_card *card, struct snd_soc_dapm_update *update)
 {
+	struct device *dev = card->dev;
 	struct snd_soc_dapm_widget_list *wlist;
 	struct snd_soc_dapm_widget *w = NULL;
 	unsigned int wi;
···
 		if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
 			ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
 			if (ret != 0)
-				dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
+				dev_err(dev, "ASoC: %s DAPM pre-event failed: %d\n",
 					   w->name, ret);
 		}
 	}
···
 	ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
 		update->val);
 	if (ret < 0)
-		dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
+		dev_err(dev, "ASoC: %s DAPM update failed: %d\n",
 			w->name, ret);
 
 	if (update->has_second_set) {
 		ret = soc_dapm_update_bits(w->dapm, update->reg2,
 					   update->mask2, update->val2);
 		if (ret < 0)
-			dev_err(w->dapm->dev,
+			dev_err(dev,
 				"ASoC: %s DAPM update failed: %d\n",
 				w->name, ret);
 	}
···
 		if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
 			ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
 			if (ret != 0)
-				dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
+				dev_err(dev, "ASoC: %s DAPM post-event failed: %d\n",
 					   w->name, ret);
 		}
 	}
···
 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
 {
 	struct snd_soc_dapm_context *dapm = data;
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	int ret;
 
 	/* If we're off and we're not supposed to go into STANDBY */
 	if (dapm->bias_level == SND_SOC_BIAS_OFF &&
 	    dapm->target_bias_level != SND_SOC_BIAS_OFF) {
-		if (dapm->dev && cookie)
-			pm_runtime_get_sync(dapm->dev);
+		if (dev && cookie)
+			pm_runtime_get_sync(dev);
 
 		ret = snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_STANDBY);
 		if (ret != 0)
-			dev_err(dapm->dev,
+			dev_err(dev,
 				"ASoC: Failed to turn on bias: %d\n", ret);
 	}
 
···
 	     dapm->bias_level == SND_SOC_BIAS_ON)) {
 		ret = snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_PREPARE);
 		if (ret != 0)
-			dev_err(dapm->dev,
+			dev_err(dev,
 				"ASoC: Failed to prepare bias: %d\n", ret);
 	}
 }
···
 static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
 {
 	struct snd_soc_dapm_context *dapm = data;
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	int ret;
 
 	/* If we just powered the last thing off drop to standby bias */
···
 	     dapm->target_bias_level == SND_SOC_BIAS_OFF)) {
 		ret = snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_STANDBY);
 		if (ret != 0)
-			dev_err(dapm->dev, "ASoC: Failed to apply standby bias: %d\n",
-				ret);
+			dev_err(dev, "ASoC: Failed to apply standby bias: %d\n", ret);
 	}
 
 	/* If we're in standby and can support bias off then do that */
···
 	    dapm->target_bias_level == SND_SOC_BIAS_OFF) {
 		ret = snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_OFF);
 		if (ret != 0)
-			dev_err(dapm->dev, "ASoC: Failed to turn off bias: %d\n",
-				ret);
+			dev_err(dev, "ASoC: Failed to turn off bias: %d\n", ret);
 
-		if (dapm->dev && cookie)
-			pm_runtime_put(dapm->dev);
+		if (dev && cookie)
+			pm_runtime_put(dev);
 	}
 
 	/* If we just powered up then move to active bias */
···
 	    dapm->target_bias_level == SND_SOC_BIAS_ON) {
 		ret = snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_ON);
 		if (ret != 0)
-			dev_err(dapm->dev, "ASoC: Failed to apply active bias: %d\n",
-				ret);
+			dev_err(dev, "ASoC: Failed to apply active bias: %d\n", ret);
 	}
 }
 
···
 static int dapm_power_widgets(struct snd_soc_card *card, int event,
 			      struct snd_soc_dapm_update *update)
 {
+	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
 	struct snd_soc_dapm_widget *w;
 	struct snd_soc_dapm_context *d;
 	LIST_HEAD(up_list);
···
 	trace_snd_soc_dapm_walk_done(card);
 
 	/* Run card bias changes at first */
-	dapm_pre_sequence_async(&card->dapm, 0);
+	dapm_pre_sequence_async(dapm, 0);
 	/* Run other bias changes in parallel */
 	for_each_card_dapms(card, d) {
-		if (d != &card->dapm && d->bias_level != d->target_bias_level)
+		if (d != dapm && d->bias_level != d->target_bias_level)
 			async_schedule_domain(dapm_pre_sequence_async, d,
 						&async_domain);
 	}
···
 
 	/* Run all the bias changes in parallel */
 	for_each_card_dapms(card, d) {
-		if (d != &card->dapm && d->bias_level != d->target_bias_level)
+		if (d != dapm && d->bias_level != d->target_bias_level)
 			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);
+	dapm_post_sequence_async(dapm, 0);
 
 	/* do we need to notify any clients that DAPM event is complete */
 	for_each_card_dapms(card, d) {
···
 static ssize_t dapm_widget_show_component(struct snd_soc_component *component,
 					  char *buf, int count)
 {
-	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
+	struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
 	struct snd_soc_dapm_widget *w;
 	char *state = "not set";
 
···
 				  const char *pin, int status)
 {
 	struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	int ret = 0;
 
 	dapm_assert_locked(dapm);
 
 	if (!w) {
-		dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
+		dev_err(dev, "ASoC: DAPM unknown pin %s\n", pin);
 		return -EINVAL;
 	}
 
···
 				struct snd_soc_dapm_widget *w,
 				int channels)
 {
+	struct device *dev = snd_soc_dapm_to_dev(w->dapm);
+
 	switch (w->id) {
 	case snd_soc_dapm_aif_out:
 	case snd_soc_dapm_aif_in:
···
 		return 0;
 	}
 
-	dev_dbg(w->dapm->dev, "%s DAI route %s -> %s\n",
+	dev_dbg(dev, "%s DAI route %s -> %s\n",
 		w->channel < channels ? "Connecting" : "Disconnecting",
 		p->source->name, p->sink->name);
 
···
 {
 	struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
 	struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	const char *sink;
 	const char *source;
 	char prefixed_sink[80];
···
 			}
 			sink_ref++;
 			if (sink_ref > 1)
-				dev_warn(dapm->dev,
+				dev_warn(dev,
 					"ASoC: sink widget %s overwritten\n",
 					w->name);
 			continue;
···
 			}
 			source_ref++;
 			if (source_ref > 1)
-				dev_warn(dapm->dev,
+				dev_warn(dev,
 					"ASoC: source widget %s overwritten\n",
 					w->name);
 		}
···
 		route->connected);
 err:
 	if (ret)
-		dev_err(dapm->dev, "ASoC: Failed to add route %s%s -%s%s%s> %s%s\n",
+		dev_err(dev, "ASoC: Failed to add route %s%s -%s%s%s> %s%s\n",
 			source, !wsource ? "(*)" : "",
 			!route->control ? "" : "> [",
 			!route->control ? "" : route->control,
···
 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
 				  const struct snd_soc_dapm_route *route)
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	struct snd_soc_dapm_path *path, *p;
 	const char *sink;
 	const char *source;
···
 	const char *prefix;
 
 	if (route->control) {
-		dev_err(dapm->dev,
+		dev_err(dev,
 			"ASoC: Removal of routes with controls not supported\n");
 		return -EINVAL;
 	}
···
 		dapm_update_widget_flags(wsource);
 		dapm_update_widget_flags(wsink);
 	} else {
-		dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
+		dev_warn(dev, "ASoC: Route %s->%s does not exist\n",
 			 source, sink);
 	}
 
···
 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
 	struct soc_mixer_control *mc =
 		(struct soc_mixer_control *)kcontrol->private_value;
 	int reg = mc->reg;
···
 		if (snd_soc_volsw_is_stereo(mc))
 			rval = (reg_val >> mc->rshift) & mask;
 	} else {
-		reg_val = dapm_kcontrol_get_value(kcontrol);
+		reg_val = snd_soc_dapm_kcontrol_get_value(kcontrol);
 		val = reg_val & mask;
 
 		if (snd_soc_volsw_is_stereo(mc))
···
 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	struct snd_soc_card *card = dapm->card;
 	struct soc_mixer_control *mc =
 		(struct soc_mixer_control *)kcontrol->private_value;
···
 
 	/* This assumes field width < (bits in unsigned int / 2) */
 	if (width > sizeof(unsigned int) * 8 / 2)
-		dev_warn(dapm->dev,
+		dev_warn(dev,
 			 "ASoC: control %s field width limit exceeded\n",
 			 kcontrol->id.name);
 	change = dapm_kcontrol_set_value(kcontrol, val | (rval << width));
···
 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 	unsigned int reg_val, val;
 
···
 	if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
 		reg_val = soc_dapm_read(dapm, e->reg);
 	} else {
-		reg_val = dapm_kcontrol_get_value(kcontrol);
+		reg_val = snd_soc_dapm_kcontrol_get_value(kcontrol);
 	}
 	snd_soc_dapm_mutex_unlock(dapm);
 
···
 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
 	struct snd_ctl_elem_value *ucontrol)
 {
-	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
 	struct snd_soc_card *card = dapm->card;
 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 	unsigned int *item = ucontrol->value.enumerated.item;
···
 				struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
 	const char *pin = (const char *)kcontrol->private_value;
 
-	return __snd_soc_dapm_get_pin_switch(&card->dapm, pin, ucontrol);
+	return __snd_soc_dapm_get_pin_switch(dapm, pin, ucontrol);
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
 
···
 					  struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
 	const char *pin = (const char *)kcontrol->private_value;
 
-	return __snd_soc_dapm_get_pin_switch(&component->dapm, pin, ucontrol);
+	return __snd_soc_dapm_get_pin_switch(dapm, pin, ucontrol);
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_component_pin_switch);
 
···
 				struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
 	const char *pin = (const char *)kcontrol->private_value;
 
-	return __snd_soc_dapm_put_pin_switch(&card->dapm, pin, ucontrol);
+	return __snd_soc_dapm_put_pin_switch(dapm, pin, ucontrol);
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
 
···
 					  struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+	struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
 	const char *pin = (const char *)kcontrol->private_value;
 
-	return __snd_soc_dapm_put_pin_switch(&component->dapm, pin, ucontrol);
+	return __snd_soc_dapm_put_pin_switch(dapm, pin, ucontrol);
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_component_pin_switch);
 
···
 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
 			 const struct snd_soc_dapm_widget *widget)
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	enum snd_soc_dapm_direction dir;
 	struct snd_soc_dapm_widget *w;
 	int ret = -ENOMEM;
···
 
 	switch (w->id) {
 	case snd_soc_dapm_regulator_supply:
-		w->regulator = devm_regulator_get(dapm->dev, widget->name);
+		w->regulator = devm_regulator_get(dev, widget->name);
 		if (IS_ERR(w->regulator)) {
 			ret = PTR_ERR(w->regulator);
 			goto request_failed;
···
 		if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
 			ret = regulator_allow_bypass(w->regulator, true);
 			if (ret != 0)
-				dev_warn(dapm->dev,
+				dev_warn(dev,
 					 "ASoC: Failed to bypass %s: %d\n",
 					 w->name, ret);
 		}
 		break;
 	case snd_soc_dapm_pinctrl:
-		w->pinctrl = devm_pinctrl_get(dapm->dev);
+		w->pinctrl = devm_pinctrl_get(dev);
 		if (IS_ERR(w->pinctrl)) {
 			ret = PTR_ERR(w->pinctrl);
 			goto request_failed;
···
 		snd_soc_dapm_pinctrl_event(w, NULL, SND_SOC_DAPM_POST_PMD);
 		break;
 	case snd_soc_dapm_clock_supply:
-		w->clk = devm_clk_get(dapm->dev, widget->name);
+		w->clk = devm_clk_get(dev, widget->name);
 		if (IS_ERR(w->clk)) {
 			ret = PTR_ERR(w->clk);
 			goto request_failed;
···
 	return w;
 
 request_failed:
-	dev_err_probe(dapm->dev, ret, "ASoC: Failed to request %s\n",
+	dev_err_probe(dev, ret, "ASoC: Failed to request %s\n",
 		      w->name);
 	kfree_const(w->name);
 	kfree_const(w->sname);
···
 snd_soc_dai_link_event_pre_pmu(struct snd_soc_dapm_widget *w,
 			       struct snd_pcm_substream *substream)
 {
+	struct device *dev = snd_soc_dapm_to_dev(w->dapm);
 	struct snd_soc_dapm_path *path;
 	struct snd_soc_dai *source, *sink;
 	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
···
 	 */
 	config = rtd->dai_link->c2c_params + rtd->c2c_params_select;
 	if (!config) {
-		dev_err(w->dapm->dev, "ASoC: link config missing\n");
+		dev_err(dev, "ASoC: link config missing\n");
 		return -EINVAL;
 	}
 
 	/* Be a little careful as we don't want to overflow the mask array */
 	if (!config->formats) {
-		dev_warn(w->dapm->dev, "ASoC: Invalid format was specified\n");
+		dev_warn(dev, "ASoC: Invalid format was specified\n");
 
 		return -EINVAL;
 	}
···
 
 	for (count = 0 ; count < num_c2c_params; count++) {
 		if (!config->stream_name) {
-			dev_warn(card->dapm.dev,
+			dev_warn(card->dev,
 				"ASoC: anonymous config %d for dai link %s\n",
 				count, link_name);
 			w_param_text[count] =
···
 		     struct snd_pcm_substream *substream,
 		     char *id)
 {
+	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
 	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 	struct snd_soc_dapm_widget template;
 	struct snd_soc_dapm_widget *w;
···
 
 	dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
 
-	w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
+	w = snd_soc_dapm_new_control_unlocked(dapm, &template);
 	if (IS_ERR(w)) {
 		ret = PTR_ERR(w);
 		goto outfree_kcontrol_news;
···
 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
 				 struct snd_soc_dai *dai)
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	struct snd_soc_dapm_widget template;
 	struct snd_soc_dapm_widget *w;
 
-	WARN_ON(dapm->dev != dai->dev);
+	WARN_ON(dev != dai->dev);
 
 	memset(&template, 0, sizeof(template));
 	template.reg = SND_SOC_NOPM;
···
 				    struct snd_soc_dai *sink_dai,
 				    struct snd_soc_dapm_widget *sink)
 {
-	dev_dbg(dapm->dev, "connected DAI link %s:%s -> %s:%s\n",
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
+
+	dev_dbg(dev, "connected DAI link %s:%s -> %s:%s\n",
 		src_dai->component->name, src->name,
 		sink_dai->component->name, sink->name);
 
···
 				  struct snd_soc_dai *codec_dai,
 				  struct snd_soc_dai *cpu_dai)
 {
+	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
 	struct snd_soc_dai_link *dai_link = rtd->dai_link;
 	struct snd_soc_dapm_widget *codec, *cpu;
 	struct snd_soc_dai *src_dai[]		= { cpu_dai,	codec_dai };
···
 			rtd->c2c_widget[stream] = dai;
 		}
 
-		dapm_connect_dai_routes(&card->dapm, src_dai[stream], *src[stream],
+		dapm_connect_dai_routes(dapm, src_dai[stream], *src[stream],
 					rtd->c2c_widget[stream],
 					sink_dai[stream], *sink[stream]);
 	}
···
 int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
 					 const char *pin)
 {
+	struct device *dev;
 	struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
 
 	if (!w) {
-		dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
+		dev = snd_soc_dapm_to_dev(dapm);
+
+		dev_err(dev, "ASoC: unknown pin %s\n", pin);
 		return -EINVAL;
 	}
 
-	dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
+	dev = snd_soc_dapm_to_dev(w->dapm);
+
+	dev_dbg(dev, "ASoC: force enable pin %s\n", pin);
 	if (!w->connected) {
 		/*
 		 * w->force does not affect the number of input or output paths,
···
 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
 				const char *pin)
 {
+	struct device *dev = snd_soc_dapm_to_dev(dapm);
 	struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
 
 	if (!w) {
-		dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
+		dev_err(dev, "ASoC: unknown pin %s\n", pin);
 		return -EINVAL;
 	}
 
···
  */
 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
 {
+	struct snd_soc_dapm_context *card_dapm = snd_soc_card_to_dapm(card);
 	struct snd_soc_dapm_context *dapm;
 
 	for_each_card_dapms(card, dapm) {
-		if (dapm != &card->dapm) {
+		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);
+				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);
+	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 */