Lines Matching refs:w
184 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
186 return !list_empty(&w->dirty);
189 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
191 dapm_assert_locked(w->dapm);
193 if (!dapm_dirty_widget(w)) {
194 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
195 w->name, reason);
196 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
208 struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
215 dapm_assert_locked(w->dapm);
217 if (w->endpoints[dir] == -1)
220 list_add_tail(&w->work_list, &list);
221 w->endpoints[dir] = -1;
223 list_for_each_entry(w, &list, work_list) {
224 snd_soc_dapm_widget_for_each_path(w, dir, p) {
239 * @w: The widget for which to invalidate the cached number of input paths
248 static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
250 dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_IN);
256 * @w: The widget for which to invalidate the cached number of output paths
265 static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
267 dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
304 struct snd_soc_dapm_widget *w;
308 for_each_card_widgets(card, w) {
309 if (w->is_ep) {
310 dapm_mark_dirty(w, "Rechecking endpoints");
311 if (w->is_ep & SND_SOC_DAPM_EP_SINK)
312 dapm_widget_invalidate_output_paths(w);
313 if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
314 dapm_widget_invalidate_input_paths(w);
327 struct snd_soc_dapm_widget *w __free(kfree) = kmemdup(_widget,
330 if (!w)
334 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, _widget->name);
336 w->name = kstrdup_const(_widget->name, GFP_KERNEL);
337 if (!w->name)
341 w->sname = kstrdup_const(_widget->sname, GFP_KERNEL);
342 if (!w->sname) {
343 kfree_const(w->name);
348 return_ptr(w);
611 struct snd_soc_dapm_widget *w;
617 for_each_card_widgets(card, w) {
618 w->new_power = w->power;
619 w->power_checked = false;
661 dapm_wcache_lookup(struct snd_soc_dapm_widget *w, const char *name)
663 if (w) {
664 struct list_head *wlist = &w->dapm->card->widgets;
668 list_for_each_entry_from(w, wlist, list) {
669 if (!strcmp(name, w->name))
670 return w;
749 struct snd_soc_dapm_widget *w)
751 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
851 struct snd_soc_dapm_widget *w;
856 for_each_card_widgets(dapm->card, w) {
857 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
859 for (i = 0; i < w->num_kcontrols; i++) {
860 if (&w->kcontrol_news[i] == kcontrol_new) {
861 if (w->kcontrols)
862 *kcontrol = w->kcontrols[i];
875 static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
878 struct snd_soc_dapm_context *dapm = w->dapm;
895 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
903 switch (w->id) {
925 if (w->no_wname_in_kcontrol_name)
936 w->name + prefix_len,
937 w->kcontrol_news[kci].name);
944 name = w->name + prefix_len;
947 name = w->kcontrol_news[kci].name;
950 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
959 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
969 w->name, name, ret);
974 ret = dapm_kcontrol_add_widget(kcontrol, w);
976 w->kcontrols[kci] = kcontrol;
985 static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
992 for (i = 0; i < w->num_kcontrols; i++) {
994 snd_soc_dapm_widget_for_each_source_path(w, path) {
996 if (path->name != (char *)w->kcontrol_news[i].name)
999 if (!w->kcontrols[i]) {
1000 ret = dapm_create_or_share_kcontrol(w, i);
1005 dapm_kcontrol_add_path(w->kcontrols[i], path);
1007 data = snd_kcontrol_chip(w->kcontrols[i]);
1020 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
1022 struct snd_soc_dapm_context *dapm = w->dapm;
1028 switch (w->id) {
1041 if (w->num_kcontrols != 1) {
1044 w->name);
1048 if (list_empty(&w->edges[dir])) {
1049 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
1053 ret = dapm_create_or_share_kcontrol(w, 0);
1057 snd_soc_dapm_widget_for_each_path(w, dir, path) {
1059 dapm_kcontrol_add_path(w->kcontrols[0], path);
1066 static int dapm_new_pga(struct snd_soc_dapm_widget *w)
1070 for (i = 0; i < w->num_kcontrols; i++) {
1071 int ret = dapm_create_or_share_kcontrol(w, i);
1080 static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
1083 struct snd_soc_pcm_runtime *rtd = w->priv;
1090 for (i = 0; i < w->num_kcontrols; i++) {
1091 struct snd_soc_dapm_context *dapm = w->dapm;
1093 struct snd_kcontrol *kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
1094 w, w->name, NULL);
1100 w->name, w->kcontrol_news[i].name, ret);
1103 kcontrol->private_data = w;
1104 w->kcontrols[i] = kcontrol;
1138 struct snd_soc_dapm_widget *w;
1152 list_for_each_entry(w, widgets, work_list)
1153 (*list)->widgets[i++] = w;
1310 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(dai, stream);
1318 invalidate_paths_ep(w, SND_SOC_DAPM_DIR_OUT);
1319 paths = is_connected_output_ep(w, &widgets,
1322 invalidate_paths_ep(w, SND_SOC_DAPM_DIR_IN);
1323 paths = is_connected_input_ep(w, &widgets,
1350 int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1355 soc_dapm_async_complete(w->dapm);
1358 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1359 ret = regulator_allow_bypass(w->regulator, false);
1361 dev_warn(w->dapm->dev,
1363 w->name, ret);
1366 return regulator_enable(w->regulator);
1368 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1369 ret = regulator_allow_bypass(w->regulator, true);
1371 dev_warn(w->dapm->dev,
1373 w->name, ret);
1376 return regulator_disable_deferred(w->regulator, w->shift);
1384 int dapm_pinctrl_event(struct snd_soc_dapm_widget *w,
1387 struct snd_soc_dapm_pinctrl_priv *priv = w->priv;
1388 struct pinctrl *p = w->pinctrl;
1409 int dapm_clock_event(struct snd_soc_dapm_widget *w,
1412 if (!w->clk)
1415 soc_dapm_async_complete(w->dapm);
1418 return clk_prepare_enable(w->clk);
1420 clk_disable_unprepare(w->clk);
1428 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1430 if (w->power_checked)
1431 return w->new_power;
1433 if (w->force)
1434 w->new_power = 1;
1436 w->new_power = w->power_check(w);
1438 w->power_checked = true;
1440 return w->new_power;
1444 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1448 DAPM_UPDATE_STAT(w, power_checks);
1450 in = is_connected_input_ep(w, NULL, NULL);
1451 out = is_connected_output_ep(w, NULL, NULL);
1456 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1460 DAPM_UPDATE_STAT(w, power_checks);
1463 snd_soc_dapm_widget_for_each_sink_path(w, path) {
1464 DAPM_UPDATE_STAT(w, neighbour_checks);
1480 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1482 return w->connected;
1523 struct snd_soc_dapm_widget *w;
1525 list_for_each_entry(w, list, power_list)
1526 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
1527 list_add_tail(&new_widget->power_list, &w->power_list);
1535 struct snd_soc_dapm_widget *w, int event)
1570 if (w->new_power != power)
1573 if (w->event && (w->event_flags & event)) {
1576 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1577 w->name, ev_name);
1578 soc_dapm_async_complete(w->dapm);
1579 trace_snd_soc_dapm_widget_event_start(w, event);
1580 ret = w->event(w, NULL, event);
1581 trace_snd_soc_dapm_widget_event_done(w, event);
1583 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1584 ev_name, w->name, ret);
1593 struct snd_soc_dapm_widget *w;
1598 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1599 reg = w->reg;
1600 dapm = w->dapm;
1602 list_for_each_entry(w, pending, power_list) {
1603 WARN_ON(reg != w->reg || dapm != w->dapm);
1604 w->power = w->new_power;
1606 mask |= w->mask << w->shift;
1607 if (w->power)
1608 value |= w->on_val << w->shift;
1610 value |= w->off_val << w->shift;
1614 w->name, reg, value, mask);
1617 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1618 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
1633 list_for_each_entry(w, pending, power_list) {
1634 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1635 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
1650 struct snd_soc_dapm_widget *w, *n;
1665 list_for_each_entry_safe(w, n, list, power_list) {
1669 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1670 w->dapm != cur_dapm || w->subseq != cur_subseq) {
1682 if (cur_dapm && w->dapm != cur_dapm)
1692 switch (w->id) {
1694 if (!w->event)
1698 ret = w->event(w,
1701 ret = w->event(w,
1706 if (!w->event)
1710 ret = w->event(w,
1713 ret = w->event(w,
1719 cur_sort = sort[w->id];
1720 cur_subseq = w->subseq;
1721 cur_reg = w->reg;
1722 cur_dapm = w->dapm;
1723 list_move(&w->power_list, &pending);
1728 dev_err(w->dapm->dev,
1751 struct snd_soc_dapm_widget *w = NULL;
1760 for_each_dapm_widgets(wlist, wi, w) {
1761 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1762 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1764 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
1765 w->name, ret);
1769 if (!w)
1772 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1775 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
1776 w->name, ret);
1779 ret = soc_dapm_update_bits(w->dapm, update->reg2,
1782 dev_err(w->dapm->dev,
1784 w->name, ret);
1787 for_each_dapm_widgets(wlist, wi, w) {
1788 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1789 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1791 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
1792 w->name, ret);
1884 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1891 switch (w->id) {
1902 power = dapm_widget_power_check(w);
1904 if (w->power == power)
1907 trace_snd_soc_dapm_widget_power(w, power);
1913 snd_soc_dapm_widget_for_each_source_path(w, path)
1919 if (!w->is_supply)
1920 snd_soc_dapm_widget_for_each_sink_path(w, path)
1925 dapm_seq_insert(w, up_list, true);
1927 dapm_seq_insert(w, down_list, false);
1957 struct snd_soc_dapm_widget *w;
1984 list_for_each_entry(w, &card->dapm_dirty, dirty) {
1985 dapm_power_one_widget(w, &up_list, &down_list);
1988 for_each_card_widgets(card, w) {
1989 switch (w->id) {
1995 list_del_init(&w->dirty);
1999 if (w->new_power) {
2000 d = w->dapm;
2009 switch (w->id) {
2052 list_for_each_entry(w, &down_list, power_list) {
2053 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
2056 list_for_each_entry(w, &up_list, power_list) {
2057 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
2144 struct snd_soc_dapm_widget *w = file->private_data;
2158 snd_soc_dapm_mutex_lock_root(w->dapm);
2161 if (w->is_supply) {
2165 in = is_connected_input_ep(w, NULL, NULL);
2166 out = is_connected_output_ep(w, NULL, NULL);
2170 w->name, w->power ? "On" : "Off",
2171 w->force ? " (forced)" : "", in, out);
2173 if (w->reg >= 0)
2176 w->reg, w->reg, w->mask << w->shift);
2180 if (w->sname)
2182 w->sname,
2183 w->active ? "active" : "inactive");
2186 snd_soc_dapm_type_name[w->id]);
2190 snd_soc_dapm_widget_for_each_path(w, dir, p) {
2207 snd_soc_dapm_mutex_unlock(w->dapm);
2268 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2270 struct snd_soc_dapm_context *dapm = w->dapm;
2272 if (!dapm->debugfs_dapm || !w->name)
2275 debugfs_create_file(w->name, 0444, dapm->debugfs_dapm, w,
2279 static void dapm_debugfs_free_widget(struct snd_soc_dapm_widget *w)
2281 struct snd_soc_dapm_context *dapm = w->dapm;
2283 if (!dapm->debugfs_dapm || !w->name)
2286 debugfs_lookup_and_remove(w->name, dapm->debugfs_dapm);
2301 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2305 static inline void dapm_debugfs_free_widget(struct snd_soc_dapm_widget *w)
2449 struct snd_soc_dapm_widget *w;
2459 for_each_card_widgets(cmpnt->card, w) {
2460 if (w->dapm != dapm)
2464 switch (w->id) {
2481 if (w->name)
2483 w->name, w->power ? "On":"Off");
2548 * @w: widget to free
2552 void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2557 if (!w)
2560 list_del(&w->list);
2561 list_del(&w->dirty);
2568 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2572 dapm_debugfs_free_widget(w);
2574 kfree(w->kcontrols);
2575 kfree_const(w->name);
2576 kfree_const(w->sname);
2577 kfree(w);
2584 struct snd_soc_dapm_widget *w, *next_w;
2586 for_each_card_widgets_safe(dapm->card, w, next_w) {
2587 if (w->dapm != dapm)
2589 snd_soc_dapm_free_widget(w);
2600 struct snd_soc_dapm_widget *w;
2614 for_each_card_widgets(dapm->card, w) {
2615 if (!strcmp(w->name, pin_name)) {
2616 if (w->dapm == dapm)
2617 return w;
2619 fallback = w;
2637 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2642 if (!w) {
2647 if (w->connected != status) {
2648 dapm_mark_dirty(w, "pin configuration");
2649 dapm_widget_invalidate_input_paths(w);
2650 dapm_widget_invalidate_output_paths(w);
2654 w->connected = status;
2656 w->force = 0;
2718 struct snd_soc_dapm_widget *w,
2721 switch (w->id) {
2729 dev_dbg(w->dapm->dev, "%s DAI route %s -> %s\n",
2730 w->channel < channels ? "Connecting" : "Disconnecting",
2733 if (w->channel < channels)
2748 struct snd_soc_dapm_widget *w;
2751 w = snd_soc_dai_get_widget(dai, dir);
2753 if (!w)
2758 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2764 snd_soc_dapm_widget_for_each_source_path(w, p) {
2802 * @w: The widget for which to update the flags
2809 static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2815 switch (w->id) {
2818 if (w->dapm->card->fully_routed)
2821 snd_soc_dapm_widget_for_each_source_path(w, p) {
2833 if (w->dapm->card->fully_routed)
2836 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2849 if (!list_empty(&w->edges[dir]))
2857 w->is_ep = ep;
3007 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
3041 for_each_card_widgets(dapm->card, w) {
3042 if (!wsink && !(strcmp(w->name, sink))) {
3043 wtsink = w;
3044 if (w->dapm == dapm) {
3045 wsink = w;
3053 w->name);
3056 if (!wsource && !(strcmp(w->name, source))) {
3057 wtsource = w;
3058 if (w->dapm == dapm) {
3059 wsource = w;
3067 w->name);
3306 struct snd_soc_dapm_widget *w;
3311 for_each_card_widgets(card, w)
3313 if (w->new)
3316 if (w->num_kcontrols) {
3317 w->kcontrols = kcalloc(w->num_kcontrols,
3320 if (!w->kcontrols) {
3326 switch(w->id) {
3330 dapm_new_mixer(w);
3334 dapm_new_mux(w);
3339 dapm_new_pga(w);
3342 dapm_new_dai_link(w);
3349 if (w->reg >= 0) {
3350 val = soc_dapm_read(w->dapm, w->reg);
3351 val = val >> w->shift;
3352 val &= w->mask;
3353 if (val == w->on_val)
3354 w->power = 1;
3357 w->new = 1;
3359 dapm_mark_dirty(w, "new widget");
3360 dapm_debugfs_add_widget(w);
3688 struct snd_soc_dapm_widget *w;
3691 w = dapm_cnew_widget(widget, soc_dapm_prefix(dapm));
3692 if (!w)
3695 switch (w->id) {
3697 w->regulator = devm_regulator_get(dapm->dev, widget->name);
3698 if (IS_ERR(w->regulator)) {
3699 ret = PTR_ERR(w->regulator);
3703 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3704 ret = regulator_allow_bypass(w->regulator, true);
3708 w->name, ret);
3712 w->pinctrl = devm_pinctrl_get(dapm->dev);
3713 if (IS_ERR(w->pinctrl)) {
3714 ret = PTR_ERR(w->pinctrl);
3719 dapm_pinctrl_event(w, NULL, SND_SOC_DAPM_POST_PMD);
3722 w->clk = devm_clk_get(dapm->dev, widget->name);
3723 if (IS_ERR(w->clk)) {
3724 ret = PTR_ERR(w->clk);
3732 switch (w->id) {
3734 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3735 w->power_check = dapm_generic_check_power;
3739 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3740 w->power_check = dapm_generic_check_power;
3744 w->is_ep = SND_SOC_DAPM_EP_SINK;
3745 w->power_check = dapm_generic_check_power;
3749 w->is_ep = SND_SOC_DAPM_EP_SINK;
3750 w->power_check = dapm_generic_check_power;
3754 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3755 w->power_check = dapm_always_on_check_power;
3758 w->is_ep = SND_SOC_DAPM_EP_SINK;
3759 w->power_check = dapm_always_on_check_power;
3785 w->power_check = dapm_generic_check_power;
3792 w->is_supply = 1;
3793 w->power_check = dapm_supply_check_power;
3796 w->power_check = dapm_always_on_check_power;
3800 w->dapm = dapm;
3801 INIT_LIST_HEAD(&w->list);
3802 INIT_LIST_HEAD(&w->dirty);
3804 list_add_tail(&w->list, &dapm->card->widgets);
3807 INIT_LIST_HEAD(&w->edges[dir]);
3808 w->endpoints[dir] = -1;
3812 w->connected = 1;
3813 return w;
3817 w->name);
3818 kfree_const(w->name);
3819 kfree_const(w->sname);
3820 kfree(w);
3838 struct snd_soc_dapm_widget *w;
3841 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3844 return w;
3867 struct snd_soc_dapm_widget *w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3868 if (IS_ERR(w)) {
3869 ret = PTR_ERR(w);
3880 snd_soc_dai_link_event_pre_pmu(struct snd_soc_dapm_widget *w,
3912 snd_soc_dapm_widget_for_each_source_path(w, path) {
3923 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3942 dev_err(w->dapm->dev, "ASoC: link config missing\n");
3948 dev_warn(w->dapm->dev, "ASoC: Invalid format was specified\n");
3966 snd_soc_dapm_widget_for_each_source_path(w, path) {
3977 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3995 static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
4000 struct snd_pcm_substream *substream = w->priv;
4003 if (WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
4004 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
4009 ret = snd_soc_dai_link_event_pre_pmu(w, substream);
4016 snd_soc_dapm_widget_for_each_source_path(w, path) {
4022 snd_soc_dapm_widget_for_each_sink_path(w, path) {
4028 snd_soc_dapm_widget_for_each_sink_path(w, path) {
4037 snd_soc_dapm_widget_for_each_sink_path(w, path) {
4045 snd_soc_dapm_widget_for_each_source_path(w, path) {
4051 snd_soc_dapm_widget_for_each_sink_path(w, path) {
4057 snd_soc_dapm_widget_for_each_source_path(w, path) {
4064 snd_soc_dapm_widget_for_each_sink_path(w, path) {
4090 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
4091 struct snd_soc_pcm_runtime *rtd = w->priv;
4101 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
4102 struct snd_soc_pcm_runtime *rtd = w->priv;
4105 if (w->power)
4212 struct snd_soc_dapm_widget *w;
4257 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
4258 if (IS_ERR(w)) {
4259 ret = PTR_ERR(w);
4263 w->priv = substream;
4265 return w;
4290 struct snd_soc_dapm_widget *w;
4305 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
4306 if (IS_ERR(w))
4307 return PTR_ERR(w);
4309 w->priv = dai;
4310 snd_soc_dai_set_widget_playback(dai, w);
4321 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
4322 if (IS_ERR(w))
4323 return PTR_ERR(w);
4325 w->priv = dai;
4326 snd_soc_dai_set_widget_capture(dai, w);
4335 struct snd_soc_dapm_widget *dai_w, *w;
4359 for_each_card_widgets(card, w) {
4360 if (w->dapm != dai_w->dapm)
4363 switch (w->id) {
4371 if (!w->sname || !strstr(w->sname, dai_w->sname))
4376 sink = w;
4378 src = w;
4382 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
4456 struct snd_soc_dapm_widget *w;
4458 w = snd_soc_dai_get_widget(dai, stream);
4460 if (w) {
4463 dapm_mark_dirty(w, "stream event");
4465 if (w->id == snd_soc_dapm_dai_in) {
4467 dapm_widget_invalidate_input_paths(w);
4470 dapm_widget_invalidate_output_paths(w);
4475 w->active = 1;
4476 w->is_ep = ep;
4479 w->active = 0;
4480 w->is_ep = 0;
4640 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4642 if (!w) {
4647 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
4648 if (!w->connected) {
4650 * w->force does not affect the number of input or output paths,
4651 * so we only have to recheck if w->connected is changed
4653 dapm_widget_invalidate_input_paths(w);
4654 dapm_widget_invalidate_output_paths(w);
4655 w->connected = 1;
4657 w->force = 1;
4658 dapm_mark_dirty(w, "force enable");
4798 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4800 if (w)
4801 return w->connected;
4821 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
4823 if (!w) {
4828 w->ignore_suspend = 1;
4873 struct snd_soc_dapm_widget *w;
4879 for_each_card_widgets(dapm->card, w) {
4880 if (w->dapm != dapm)
4882 if (w->power) {
4883 dapm_seq_insert(w, &down_list, false);
4884 w->new_power = 0;