Lines Matching +full:ignore +full:- +full:suspend +full:- +full:widgets
1 // SPDX-License-Identifier: GPL-2.0+
3 // soc-dapm.c -- ALSA SoC Dynamic Audio Power Management
12 // o Platform power domain - can support external components i.e. amps and
15 // o Jack insertion power event initiation - e.g. hp insertion will enable
43 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
52 /* dapm power sequences - make this per codec in the future */
137 if (snd_soc_card_is_instantiated(dapm->card))
170 if (dapm->component)
171 return dapm->component->dev;
173 return dapm->card->dev;
179 return dapm->card;
185 return dapm->component;
191 return !list_empty(&w->dirty);
196 dapm_assert_locked(w->dapm);
199 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
200 w->name, reason);
201 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
220 dapm_assert_locked(w->dapm);
222 if (w->endpoints[dir] == -1)
225 list_add_tail(&w->work_list, &list);
226 w->endpoints[dir] = -1;
230 if (p->is_supply || !p->connect)
232 node = p->node[rdir];
233 if (node->endpoints[dir] != -1) {
234 node->endpoints[dir] = -1;
235 list_add_tail(&node->work_list, &list);
242 * dapm_widget_invalidate_input_paths() - Invalidate the cached number of
246 * Resets the cached number of inputs for the specified widget and all widgets
259 * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
263 * Resets the cached number of outputs for the specified widget and all widgets
276 * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
277 * for the widgets connected to a path
292 if (p->is_supply)
299 * so there is no need to re-check the path.
301 if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
302 dapm_widget_invalidate_input_paths(p->sink);
303 if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
304 dapm_widget_invalidate_output_paths(p->source);
314 if (w->is_ep) {
316 if (w->is_ep & SND_SOC_DAPM_EP_SINK)
318 if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
338 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, _widget->name);
340 w->name = kstrdup_const(_widget->name, GFP_KERNEL);
341 if (!w->name)
344 if (_widget->sname) {
345 w->sname = kstrdup_const(_widget->sname, GFP_KERNEL);
346 if (!w->sname) {
347 kfree_const(w->name);
364 if (!dapm->component)
365 return -EIO;
366 return snd_soc_component_read(dapm->component, reg);
374 p->sink->kcontrol_news[i].private_value;
375 unsigned int reg = mc->reg;
376 unsigned int invert = mc->invert;
379 unsigned int shift = mc->shift;
380 unsigned int max = mc->max;
381 unsigned int mask = (1 << fls(max)) - 1;
382 unsigned int val = soc_dapm_read(p->sink->dapm, reg);
397 if (reg != mc->rreg)
398 val = soc_dapm_read(p->sink->dapm, mc->rreg);
399 val = (val >> mc->rshift) & mask;
404 val = max - val;
405 p->connect = !!val;
413 p->connect = invert;
422 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
423 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
427 if (e->reg != SND_SOC_NOPM) {
430 val = soc_dapm_read(dapm, e->reg);
431 val = (val >> e->shift_l) & e->mask;
443 i = match_string(e->texts, e->items, control_name);
445 return -ENODEV;
447 path->name = e->texts[i];
448 path->connect = (i == item);
460 for (i = 0; i < path->sink->num_kcontrols; i++) {
461 if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
462 path->name = path->sink->kcontrol_news[i].name;
467 return -ENODEV;
471 * dapm_update_widget_flags() - Re-compute widget sink and source flags
474 * Some widgets have a dynamic category which depends on which neighbors they
475 * are connected to. This function update the category for these widgets.
485 switch (w->id) {
488 if (w->dapm->card->fully_routed)
492 if (p->source->id == snd_soc_dapm_micbias ||
493 p->source->id == snd_soc_dapm_mic ||
494 p->source->id == snd_soc_dapm_line ||
495 p->source->id == snd_soc_dapm_output) {
503 if (w->dapm->card->fully_routed)
507 if (p->sink->id == snd_soc_dapm_spk ||
508 p->sink->id == snd_soc_dapm_hp ||
509 p->sink->id == snd_soc_dapm_line ||
510 p->sink->id == snd_soc_dapm_input) {
519 if (!list_empty(&w->edges[dir]))
527 w->is_ep = ep;
541 switch (source->id) {
549 switch (sink->id) {
561 dev_err(dapm->dev,
562 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
563 source->name, control, sink->name);
564 return -EINVAL;
566 dev_err(dapm->dev,
567 "Control not supported for path %s -> [%s] -> %s\n",
568 source->name, control, sink->name);
569 return -EINVAL;
586 if (wsink->is_supply && !wsource->is_supply) {
587 dev_err(dapm->dev,
588 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
589 wsource->name, wsink->name);
590 return -EINVAL;
593 if (connected && !wsource->is_supply) {
594 dev_err(dapm->dev,
595 "connected() callback only supported for supply widgets (%s -> %s)\n",
596 wsource->name, wsink->name);
597 return -EINVAL;
600 if (wsource->is_supply && control) {
601 dev_err(dapm->dev,
602 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
603 wsource->name, control, wsink->name);
604 return -EINVAL;
613 return -ENOMEM;
615 path->node[SND_SOC_DAPM_DIR_IN] = wsource;
616 path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
618 path->connected = connected;
619 INIT_LIST_HEAD(&path->list);
620 INIT_LIST_HEAD(&path->list_kcontrol);
622 if (wsource->is_supply || wsink->is_supply)
623 path->is_supply = 1;
627 path->connect = 1;
629 switch (wsource->id) {
639 switch (wsink->id) {
657 list_add(&path->list, &dapm->card->paths);
660 list_add(&path->list_node[dir], &path->node[dir]->edges[dir]);
663 dapm_update_widget_flags(path->node[dir]);
664 dapm_mark_dirty(path->node[dir], "Route added");
667 if (snd_soc_card_is_instantiated(dapm->card) && path->connect)
687 return -ENOMEM;
689 INIT_LIST_HEAD(&data->paths);
691 switch (widget->id) {
695 mc = (struct soc_mixer_control *)kcontrol->private_value;
697 if (mc->autodisable) {
701 dev_warn(widget->dapm->dev,
708 ret = -ENOMEM;
713 template.reg = mc->reg;
714 template.mask = (1 << fls(mc->max)) - 1;
715 template.shift = mc->shift;
716 if (mc->invert)
717 template.off_val = mc->max;
724 data->value = template.on_val;
726 data->widget =
727 snd_soc_dapm_new_control_unlocked(widget->dapm,
730 if (IS_ERR(data->widget)) {
731 ret = PTR_ERR(data->widget);
738 e = (struct soc_enum *)kcontrol->private_value;
740 if (e->autodisable) {
746 ret = -ENOMEM;
751 template.reg = e->reg;
752 template.mask = e->mask;
753 template.shift = e->shift_l;
759 data->value = template.on_val;
761 data->widget = snd_soc_dapm_new_control_unlocked(
762 widget->dapm, &template);
764 if (IS_ERR(data->widget)) {
765 ret = PTR_ERR(data->widget);
769 snd_soc_dapm_add_path(widget->dapm, data->widget,
771 } else if (e->reg != SND_SOC_NOPM) {
772 data->value = soc_dapm_read(widget->dapm, e->reg) &
773 (e->mask << e->shift_l);
780 kcontrol->private_data = data;
793 list_del(&data->paths);
794 kfree(data->wlist);
803 return data->wlist;
813 if (data->wlist)
814 n = data->wlist->num_widgets + 1;
818 new_wlist = krealloc(data->wlist,
819 struct_size(new_wlist, widgets, n),
822 return -ENOMEM;
824 new_wlist->num_widgets = n;
825 new_wlist->widgets[n - 1] = widget;
827 data->wlist = new_wlist;
837 list_add_tail(&path->list_kcontrol, &data->paths);
844 if (!data->widget)
847 return data->widget->power;
855 return &data->paths;
866 return data->value;
875 if (data->value == value)
878 if (data->widget) {
879 switch (dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->id) {
883 data->widget->on_val = value & data->widget->mask;
887 data->widget->on_val = value >> data->widget->shift;
890 data->widget->on_val = value;
895 data->value = value;
901 * snd_soc_dapm_kcontrol_to_widget() - Returns the widget associated to a
907 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0];
912 * snd_soc_dapm_kcontrol_to_dapm() - Returns the dapm context associated to a kcontrol
920 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
925 * snd_soc_dapm_kcontrol_to_component() - Returns the component associated to a
944 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
947 w->new_power = w->power;
948 w->power_checked = false;
954 if (!dapm->component)
956 return dapm->component->name_prefix;
962 if (!dapm->component)
963 return -EIO;
964 return snd_soc_component_update_bits(dapm->component, reg,
971 if (!dapm->component)
972 return -EIO;
973 return snd_soc_component_test_bits(dapm->component, reg, mask, value);
978 if (dapm->component)
979 snd_soc_component_async_complete(dapm->component);
986 struct list_head *wlist = &w->dapm->card->widgets;
991 if (!strcmp(name, w->name))
1003 * snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
1016 * used during probe or resume from suspend to power up the device so
1024 if (dapm->component)
1025 ret = snd_soc_component_set_bias_level(dapm->component, level);
1028 dapm->bias_level = level;
1035 * snd_soc_dapm_init_bias_level() - Initialize DAPM bias level
1043 * the power-on reset state of the device.
1049 dapm->bias_level = level;
1054 * snd_soc_dapm_set_bias_level - set the bias level for the system
1065 struct snd_soc_card *card = dapm->card;
1074 if (dapm != &card->dapm)
1092 * snd_soc_dapm_get_bias_level() - Get current DAPM bias level
1099 return dapm->bias_level;
1113 for_each_card_widgets(dapm->card, w) {
1114 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
1116 for (i = 0; i < w->num_kcontrols; i++) {
1117 if (&w->kcontrol_news[i] == kcontrol_new) {
1118 if (w->kcontrols)
1119 *kcontrol = w->kcontrols[i];
1135 struct snd_soc_dapm_context *dapm = w->dapm;
1136 struct snd_card *card = dapm->card->snd_card;
1152 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
1160 switch (w->id) {
1179 return -EINVAL;
1182 if (w->no_wname_in_kcontrol_name)
1189 * prefix for widgets so cut the prefix off the
1193 w->name + prefix_len,
1194 w->kcontrol_news[kci].name);
1196 return -ENOMEM;
1201 name = w->name + prefix_len;
1204 name = w->kcontrol_news[kci].name;
1207 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
1210 ret = -ENOMEM;
1214 kcontrol->private_free = dapm_kcontrol_free;
1224 dev_err(dapm->dev,
1226 w->name, name, ret);
1233 w->kcontrols[kci] = kcontrol;
1249 for (i = 0; i < w->num_kcontrols; i++) {
1253 if (path->name != (char *)w->kcontrol_news[i].name)
1256 if (!w->kcontrols[i]) {
1262 dapm_kcontrol_add_path(w->kcontrols[i], path);
1264 data = snd_kcontrol_chip(w->kcontrols[i]);
1265 if (data->widget)
1266 snd_soc_dapm_add_path(data->widget->dapm,
1267 data->widget,
1268 path->source,
1279 struct snd_soc_dapm_context *dapm = w->dapm;
1285 switch (w->id) {
1295 return -EINVAL;
1298 if (w->num_kcontrols != 1) {
1299 dev_err(dapm->dev,
1301 w->name);
1302 return -EINVAL;
1305 if (list_empty(&w->edges[dir])) {
1306 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
1307 return -EINVAL;
1315 if (path->name)
1316 dapm_kcontrol_add_path(w->kcontrols[0], path);
1327 for (i = 0; i < w->num_kcontrols; i++) {
1340 struct snd_soc_pcm_runtime *rtd = w->priv;
1343 if (rtd->dai_link->num_c2c_params <= 1)
1347 for (i = 0; i < w->num_kcontrols; i++) {
1348 struct snd_soc_dapm_context *dapm = w->dapm;
1349 struct snd_card *card = dapm->card->snd_card;
1350 struct snd_kcontrol *kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
1351 w, w->name, NULL);
1355 dev_err(dapm->dev,
1357 w->name, w->kcontrol_news[i].name, ret);
1360 kcontrol->private_data = w;
1361 w->kcontrols[i] = kcontrol;
1367 /* We implement power down on suspend by checking the power state of
1368 * the ALSA card - when we are suspending the ALSA state for the card
1373 int level = snd_power_get_state(widget->dapm->card->snd_card);
1378 if (widget->ignore_suspend)
1379 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
1380 widget->name);
1381 return widget->ignore_suspend;
1393 struct list_head *widgets)
1400 list_for_each(it, widgets)
1403 *list = kzalloc(struct_size(*list, widgets, size), GFP_KERNEL);
1405 return -ENOMEM;
1407 (*list)->num_widgets = size;
1409 list_for_each_entry(w, widgets, work_list)
1410 (*list)->widgets[i++] = w;
1412 (*list)->num_widgets = i;
1419 * widget and all widgets that can be reached via incoming or outcoming paths
1428 widget->endpoints[dir] = -1;
1431 if (path->is_supply)
1434 if (path->walking)
1437 if (path->connect) {
1438 path->walking = 1;
1439 invalidate_paths_ep(path->node[dir], dir);
1440 path->walking = 0;
1464 if (widget->endpoints[dir] >= 0)
1465 return widget->endpoints[dir];
1471 list_add_tail(&widget->work_list, list);
1478 if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1479 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1480 return widget->endpoints[dir];
1486 if (path->is_supply)
1489 if (path->walking)
1494 if (path->connect) {
1495 path->walking = 1;
1496 con += fn(path->node[dir], list, custom_stop_condition);
1497 path->walking = 0;
1501 widget->endpoints[dir] = con;
1512 * direction as an arguments, it should return true if widgets from that point
1543 * snd_soc_dapm_dai_get_connected_widgets - query audio path and it's widgets.
1546 * @list: list of active widgets for this stream.
1552 * current mixer and mux kcontrol settings. Creates list of valid widgets.
1566 struct snd_soc_card *card = dai->component->card;
1568 LIST_HEAD(widgets);
1576 paths = is_connected_output_ep(w, &widgets,
1580 paths = is_connected_input_ep(w, &widgets,
1585 list_del(widgets.next);
1587 ret = dapm_widget_list_create(list, &widgets);
1612 soc_dapm_async_complete(w->dapm);
1615 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1616 ret = regulator_allow_bypass(w->regulator, false);
1618 dev_warn(w->dapm->dev,
1620 w->name, ret);
1623 return regulator_enable(w->regulator);
1625 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1626 ret = regulator_allow_bypass(w->regulator, true);
1628 dev_warn(w->dapm->dev,
1630 w->name, ret);
1633 return regulator_disable_deferred(w->regulator, w->shift);
1644 struct snd_soc_dapm_pinctrl_priv *priv = w->priv;
1645 struct pinctrl *p = w->pinctrl;
1649 return -EIO;
1652 s = pinctrl_lookup_state(p, priv->active_state);
1654 s = pinctrl_lookup_state(p, priv->sleep_state);
1669 if (!w->clk)
1670 return -EIO;
1672 soc_dapm_async_complete(w->dapm);
1675 return clk_prepare_enable(w->clk);
1677 clk_disable_unprepare(w->clk);
1687 if (w->power_checked)
1688 return w->new_power;
1690 if (w->force)
1691 w->new_power = 1;
1693 w->new_power = w->power_check(w);
1695 w->power_checked = true;
1697 return w->new_power;
1723 if (path->connected &&
1724 !path->connected(path->source, path->sink))
1727 if (dapm_widget_power_check(path->sink))
1736 return w->connected;
1753 WARN_ONCE(sort[a->id] == 0, "offset a->id %d not initialized\n", a->id);
1754 WARN_ONCE(sort[b->id] == 0, "offset b->id %d not initialized\n", b->id);
1756 if (sort[a->id] != sort[b->id])
1757 return sort[a->id] - sort[b->id];
1758 if (a->subseq != b->subseq) {
1760 return a->subseq - b->subseq;
1762 return b->subseq - a->subseq;
1764 if (a->reg != b->reg)
1765 return a->reg - b->reg;
1766 if (a->dapm != b->dapm)
1767 return (unsigned long)a->dapm - (unsigned long)b->dapm;
1781 list_add_tail(&new_widget->power_list, &w->power_list);
1785 list_add_tail(&new_widget->power_list, list);
1824 if (w->new_power != power)
1827 if (w->event && (w->event_flags & event)) {
1830 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1831 w->name, ev_name);
1832 soc_dapm_async_complete(w->dapm);
1834 ret = w->event(w, NULL, event);
1837 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1838 ev_name, w->name, ret);
1853 reg = w->reg;
1854 dapm = w->dapm;
1857 WARN_ON(reg != w->reg || dapm != w->dapm);
1858 w->power = w->new_power;
1860 mask |= w->mask << w->shift;
1861 if (w->power)
1862 value |= w->on_val << w->shift;
1864 value |= w->off_val << w->shift;
1866 pop_dbg(dapm->dev, card->pop_time,
1868 w->name, reg, value, mask);
1880 pop_dbg(dapm->dev, card->pop_time,
1882 value, mask, reg, card->pop_time);
1883 pop_wait(card->pop_time);
1895 * We walk over a pre-sorted list of widgets to apply power to. In
1897 * multiple widgets will be updated in a single write where possible.
1907 int cur_sort = -1;
1908 int cur_subseq = -1;
1923 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1924 w->dapm != cur_dapm || w->subseq != cur_subseq) {
1928 if (cur_dapm && cur_dapm->component) {
1932 cur_dapm->component,
1936 if (cur_dapm && w->dapm != cur_dapm)
1940 cur_sort = -1;
1946 switch (w->id) {
1948 if (!w->event)
1952 ret = w->event(w,
1955 ret = w->event(w,
1960 if (!w->event)
1964 ret = w->event(w,
1967 ret = w->event(w,
1973 cur_sort = sort[w->id];
1974 cur_subseq = w->subseq;
1975 cur_reg = w->reg;
1976 cur_dapm = w->dapm;
1977 list_move(&w->power_list, &pending);
1982 dev_err(w->dapm->dev,
1989 if (cur_dapm && cur_dapm->component) {
1993 cur_dapm->component,
2008 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
2011 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
2014 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
2015 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
2017 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
2018 w->name, ret);
2025 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
2026 update->val);
2028 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
2029 w->name, ret);
2031 if (update->has_second_set) {
2032 ret = soc_dapm_update_bits(w->dapm, update->reg2,
2033 update->mask2, update->val2);
2035 dev_err(w->dapm->dev,
2037 w->name, ret);
2041 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
2042 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
2044 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
2045 w->name, ret);
2050 /* Async callback run prior to DAPM sequences - brings to _PREPARE if
2059 if (dapm->bias_level == SND_SOC_BIAS_OFF &&
2060 dapm->target_bias_level != SND_SOC_BIAS_OFF) {
2061 if (dapm->dev && cookie)
2062 pm_runtime_get_sync(dapm->dev);
2066 dev_err(dapm->dev,
2071 if ((dapm->target_bias_level == SND_SOC_BIAS_ON &&
2072 dapm->bias_level != SND_SOC_BIAS_ON) ||
2073 (dapm->target_bias_level != SND_SOC_BIAS_ON &&
2074 dapm->bias_level == SND_SOC_BIAS_ON)) {
2077 dev_err(dapm->dev,
2082 /* Async callback run prior to DAPM sequences - brings to their final
2091 if (dapm->bias_level == SND_SOC_BIAS_PREPARE &&
2092 (dapm->target_bias_level == SND_SOC_BIAS_STANDBY ||
2093 dapm->target_bias_level == SND_SOC_BIAS_OFF)) {
2096 dev_err(dapm->dev, "ASoC: Failed to apply standby bias: %d\n",
2101 if (dapm->bias_level == SND_SOC_BIAS_STANDBY &&
2102 dapm->target_bias_level == SND_SOC_BIAS_OFF) {
2105 dev_err(dapm->dev, "ASoC: Failed to turn off bias: %d\n",
2108 if (dapm->dev && cookie)
2109 pm_runtime_put(dapm->dev);
2113 if (dapm->bias_level == SND_SOC_BIAS_PREPARE &&
2114 dapm->target_bias_level == SND_SOC_BIAS_ON) {
2117 dev_err(dapm->dev, "ASoC: Failed to apply active bias: %d\n",
2126 * will have marked the peer dirty, otherwise the widgets are
2133 if (power != peer->power)
2144 switch (w->id) {
2157 if (w->power == power)
2167 dapm_widget_set_peer_power(path->source, power, path->connect);
2172 if (!w->is_supply)
2174 dapm_widget_set_peer_power(path->sink, power, path->connect);
2185 if (dapm->idle_bias) {
2187 unsigned int state = snd_power_get_state(dapm->card->snd_card);
2191 return !component->driver->suspend_bias_off;
2194 return dapm->idle_bias;
2200 dapm->idle_bias = on;
2206 * A complete path is a route that has valid endpoints i.e.:-
2230 d->target_bias_level = SND_SOC_BIAS_STANDBY;
2232 d->target_bias_level = SND_SOC_BIAS_OFF;
2237 /* Check which widgets we need to power and store them in
2239 * only check widgets that have been flagged as dirty but note
2240 * that new widgets may be added to the dirty list while we
2243 list_for_each_entry(w, &card->dapm_dirty, dirty) {
2248 switch (w->id) {
2251 /* These widgets always need to be powered */
2254 list_del_init(&w->dirty);
2258 if (w->new_power) {
2259 d = w->dapm;
2268 switch (w->id) {
2277 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
2278 d->target_bias_level = SND_SOC_BIAS_STANDBY;
2281 d->target_bias_level = SND_SOC_BIAS_ON;
2293 if (d->target_bias_level > bias)
2294 bias = d->target_bias_level;
2297 d->target_bias_level = bias;
2302 dapm_pre_sequence_async(&card->dapm, 0);
2305 if (d != &card->dapm && d->bias_level != d->target_bias_level)
2319 /* Power down widgets first; try to avoid amplifying pops. */
2329 if (d != &card->dapm && d->bias_level != d->target_bias_level)
2335 dapm_post_sequence_async(&card->dapm, 0);
2339 if (!d->component)
2342 ret = snd_soc_component_stream_event(d->component, event);
2347 pop_dbg(card->dev, card->pop_time,
2348 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
2349 pop_wait(card->pop_time);
2403 struct snd_soc_dapm_widget *w = file->private_data;
2415 return -ENOMEM;
2417 snd_soc_dapm_mutex_lock_root(w->dapm);
2419 /* Supply widgets are not handled by is_connected_{input,output}_ep() */
2420 if (w->is_supply) {
2429 w->name, w->power ? "On" : "Off",
2430 w->force ? " (forced)" : "", in, out);
2432 if (w->reg >= 0)
2433 ret += scnprintf(buf + ret, PAGE_SIZE - ret,
2434 " - R%d(0x%x) mask 0x%x",
2435 w->reg, w->reg, w->mask << w->shift);
2437 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
2439 if (w->sname)
2440 ret += scnprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
2441 w->sname,
2442 w->active ? "active" : "inactive");
2444 ret += scnprintf(buf + ret, PAGE_SIZE - ret, " widget-type %s\n",
2445 snd_soc_dapm_type_name[w->id]);
2450 if (p->connected && !p->connected(p->source, p->sink))
2453 if (!p->connect)
2456 c_name = p->node[rdir]->dapm->component ?
2457 p->node[rdir]->dapm->component->name : NULL;
2458 ret += scnprintf(buf + ret, PAGE_SIZE - ret,
2461 p->name ? p->name : "static",
2462 p->node[rdir]->name, c_name);
2466 snd_soc_dapm_mutex_unlock(w->dapm);
2483 struct snd_soc_dapm_context *dapm = file->private_data;
2486 switch (dapm->bias_level) {
2500 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
2521 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2523 debugfs_create_file("bias_level", 0444, dapm->debugfs_dapm, dapm,
2529 struct snd_soc_dapm_context *dapm = w->dapm;
2531 if (!dapm->debugfs_dapm || !w->name)
2534 debugfs_create_file(w->name, 0444, dapm->debugfs_dapm, w,
2540 struct snd_soc_dapm_context *dapm = w->dapm;
2542 if (!dapm->debugfs_dapm || !w->name)
2545 debugfs_lookup_and_remove(w->name, dapm->debugfs_dapm);
2550 debugfs_remove_recursive(dapm->debugfs_dapm);
2551 dapm->debugfs_dapm = NULL;
2575 * soc_dapm_connect_path() - Connects or disconnects a path
2584 if (path->connect == connect)
2587 path->connect = connect;
2588 dapm_mark_dirty(path->source, reason);
2589 dapm_mark_dirty(path->sink, reason);
2609 if (e && !(strcmp(path->name, e->texts[mux])))
2627 struct snd_soc_card *card = dapm->card;
2691 struct snd_soc_card *card = dapm->card;
2695 ret = soc_dapm_mixer_update_power(card, kcontrol, update, connect, -1);
2714 if (!component->card)
2717 for_each_card_widgets(component->card, w) {
2718 if (w->dapm != dapm)
2721 /* only display widgets that burn power */
2722 switch (w->id) {
2739 if (w->name)
2741 w->name, w->power ? "On":"Off");
2775 snd_soc_dapm_mutex_lock_root(rtd->card);
2778 struct snd_soc_component *component = codec_dai->component;
2783 snd_soc_dapm_mutex_unlock(rtd->card);
2797 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2798 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
2799 list_del(&path->list_kcontrol);
2800 list_del(&path->list);
2805 * snd_soc_dapm_free_widget - Free specified widget
2818 list_del(&w->list);
2819 list_del(&w->dirty);
2823 * source and sink widgets so that path is removed only once.
2832 kfree(w->kcontrols);
2833 kfree_const(w->name);
2834 kfree_const(w->sname);
2839 /* free all dapm widgets and resources */
2844 for_each_card_widgets_safe(dapm->card, w, next_w) {
2845 if (w->dapm != dapm)
2850 dapm->wcache_sink = NULL;
2851 dapm->wcache_source = NULL;
2872 for_each_card_widgets(dapm->card, w) {
2873 if (!strcmp(w->name, pin_name)) {
2874 if (w->dapm == dapm)
2901 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
2902 return -EINVAL;
2905 if (w->connected != status) {
2912 w->connected = status;
2914 w->force = 0;
2932 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2935 * Walks all dapm audio paths and powers widgets according to their
2948 if (!snd_soc_card_is_instantiated(dapm->card))
2951 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP, NULL);
2956 * snd_soc_dapm_sync - scan and power dapm paths
2959 * Walks all dapm audio paths and powers widgets according to their
2979 switch (w->id) {
2987 dev_dbg(w->dapm->dev, "%s DAI route %s -> %s\n",
2988 w->channel < channels ? "Connecting" : "Disconnecting",
2989 p->source->name, p->sink->name);
2991 if (w->channel < channels)
3003 int dir = substream->stream;
3014 dev_dbg(dai->dev, "Update DAI routes for %s %s\n", dai->name, snd_pcm_direction_name(dir));
3017 ret = dapm_update_dai_chan(p, p->sink, channels);
3023 ret = dapm_update_dai_chan(p, p->source, channels);
3038 snd_soc_dapm_mutex_lock(rtd->card);
3040 snd_soc_dapm_mutex_unlock(rtd->card);
3047 struct snd_soc_component *component = widget->dapm->component;
3048 const char *wname = widget->name;
3050 if (component && component->name_prefix)
3051 wname += strlen(component->name_prefix) + 1; /* plus space */
3074 prefix, route->sink);
3077 prefix, route->source);
3080 sink = route->sink;
3081 source = route->source;
3084 wsource = dapm_wcache_lookup(dapm->wcache_source, source);
3085 wsink = dapm_wcache_lookup(dapm->wcache_sink, sink);
3091 * find src and dest widgets over all widgets but favor a widget from
3094 for_each_card_widgets(dapm->card, w) {
3095 if (!wsink && !(strcmp(w->name, sink))) {
3097 if (w->dapm == dapm) {
3104 dev_warn(dapm->dev,
3106 w->name);
3109 if (!wsource && !(strcmp(w->name, source))) {
3111 if (w->dapm == dapm) {
3118 dev_warn(dapm->dev,
3120 w->name);
3129 ret = -ENODEV;
3137 dapm->wcache_sink = wsink;
3138 dapm->wcache_source = wsource;
3140 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
3141 route->connected);
3144 dev_err(dapm->dev, "ASoC: Failed to add route %s%s -%s%s%s> %s%s\n",
3146 !route->control ? "" : "> [",
3147 !route->control ? "" : route->control,
3148 !route->control ? "" : "] -",
3163 if (route->control) {
3164 dev_err(dapm->dev,
3166 return -EINVAL;
3172 prefix, route->sink);
3175 prefix, route->source);
3178 sink = route->sink;
3179 source = route->source;
3183 list_for_each_entry(p, &dapm->card->paths, list) {
3184 if (strcmp(p->source->name, source) != 0)
3186 if (strcmp(p->sink->name, sink) != 0)
3193 struct snd_soc_dapm_widget *wsource = path->source;
3194 struct snd_soc_dapm_widget *wsink = path->sink;
3198 if (path->connect)
3207 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
3215 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
3220 * Connects 2 dapm widgets together via a named audio path. The sink is
3246 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
3270 * snd_soc_dapm_new_widgets - add new dapm widgets
3271 * @card: card to be checked for new dapm widgets
3273 * Checks the codec for any new dapm widgets and creates them if found.
3286 if (w->new)
3289 if (w->num_kcontrols) {
3290 w->kcontrols = kcalloc(w->num_kcontrols,
3293 if (!w->kcontrols) {
3295 return -ENOMEM;
3299 switch(w->id) {
3322 if (w->reg >= 0) {
3323 val = soc_dapm_read(w->dapm, w->reg);
3324 val = val >> w->shift;
3325 val &= w->mask;
3326 if (val == w->on_val)
3327 w->power = 1;
3330 w->new = 1;
3343 * snd_soc_dapm_get_volsw - dapm mixer get callback
3356 (struct soc_mixer_control *)kcontrol->private_value;
3357 int reg = mc->reg;
3358 unsigned int shift = mc->shift;
3359 int max = mc->max;
3361 unsigned int mask = (1 << fls(max)) - 1;
3362 unsigned int invert = mc->invert;
3370 if (reg != mc->rreg)
3371 reg_val = soc_dapm_read(dapm, mc->rreg);
3374 rval = (reg_val >> mc->rshift) & mask;
3385 ucontrol->value.integer.value[0] = max - val;
3387 ucontrol->value.integer.value[0] = val;
3391 ucontrol->value.integer.value[1] = max - rval;
3393 ucontrol->value.integer.value[1] = rval;
3401 * snd_soc_dapm_put_volsw - dapm mixer set callback
3413 struct snd_soc_card *card = dapm->card;
3415 (struct soc_mixer_control *)kcontrol->private_value;
3416 int reg = mc->reg;
3417 unsigned int shift = mc->shift;
3418 int max = mc->max;
3420 unsigned int mask = (1 << width) - 1;
3421 unsigned int invert = mc->invert;
3423 int connect, rconnect = -1, change, reg_change = 0;
3428 val = (ucontrol->value.integer.value[0] & mask);
3432 val = max - val;
3435 rval = (ucontrol->value.integer.value[1] & mask);
3438 rval = max - rval;
3445 dev_warn(dapm->dev,
3447 kcontrol->id.name);
3452 rval = rval << mc->rshift;
3457 reg_change |= soc_dapm_test_bits(dapm, mc->rreg,
3458 mask << mc->rshift,
3466 update.reg2 = mc->rreg;
3467 update.mask2 = mask << mc->rshift;
3489 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3501 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3505 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
3506 reg_val = soc_dapm_read(dapm, e->reg);
3512 val = (reg_val >> e->shift_l) & e->mask;
3513 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3514 if (e->shift_l != e->shift_r) {
3515 val = (reg_val >> e->shift_r) & e->mask;
3517 ucontrol->value.enumerated.item[1] = val;
3525 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3537 struct snd_soc_card *card = dapm->card;
3538 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3539 unsigned int *item = ucontrol->value.enumerated.item;
3546 if (item[0] >= e->items)
3547 return -EINVAL;
3549 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
3550 mask = e->mask << e->shift_l;
3551 if (e->shift_l != e->shift_r) {
3552 if (item[1] > e->items)
3553 return -EINVAL;
3554 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
3555 mask |= e->mask << e->shift_r;
3562 if (e->reg != SND_SOC_NOPM)
3563 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3568 update.reg = e->reg;
3586 * snd_soc_dapm_info_pin_switch - Info for a pin switch
3596 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3597 uinfo->count = 1;
3598 uinfo->value.integer.min = 0;
3599 uinfo->value.integer.max = 1;
3610 ucontrol->value.integer.value[0] = snd_soc_dapm_get_pin_status(dapm, pin);
3617 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3629 const char *pin = (const char *)kcontrol->private_value;
3631 return __snd_soc_dapm_get_pin_switch(&card->dapm, pin, ucontrol);
3636 * snd_soc_dapm_get_component_pin_switch - Get information for a pin switch
3648 const char *pin = (const char *)kcontrol->private_value;
3650 return __snd_soc_dapm_get_pin_switch(&component->dapm, pin, ucontrol);
3661 ret = __snd_soc_dapm_set_pin(dapm, pin, !!ucontrol->value.integer.value[0]);
3670 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3682 const char *pin = (const char *)kcontrol->private_value;
3684 return __snd_soc_dapm_put_pin_switch(&card->dapm, pin, ucontrol);
3689 * snd_soc_dapm_put_component_pin_switch - Set information for a pin switch
3701 const char *pin = (const char *)kcontrol->private_value;
3703 return __snd_soc_dapm_put_pin_switch(&component->dapm, pin, ucontrol);
3713 int ret = -ENOMEM;
3719 switch (w->id) {
3721 w->regulator = devm_regulator_get(dapm->dev, widget->name);
3722 if (IS_ERR(w->regulator)) {
3723 ret = PTR_ERR(w->regulator);
3727 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3728 ret = regulator_allow_bypass(w->regulator, true);
3730 dev_warn(dapm->dev,
3732 w->name, ret);
3736 w->pinctrl = devm_pinctrl_get(dapm->dev);
3737 if (IS_ERR(w->pinctrl)) {
3738 ret = PTR_ERR(w->pinctrl);
3746 w->clk = devm_clk_get(dapm->dev, widget->name);
3747 if (IS_ERR(w->clk)) {
3748 ret = PTR_ERR(w->clk);
3756 switch (w->id) {
3758 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3759 w->power_check = dapm_generic_check_power;
3762 if (!dapm->card->fully_routed)
3763 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3764 w->power_check = dapm_generic_check_power;
3768 w->is_ep = SND_SOC_DAPM_EP_SINK;
3769 w->power_check = dapm_generic_check_power;
3772 if (!dapm->card->fully_routed)
3773 w->is_ep = SND_SOC_DAPM_EP_SINK;
3774 w->power_check = dapm_generic_check_power;
3778 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3779 w->power_check = dapm_always_on_check_power;
3782 w->is_ep = SND_SOC_DAPM_EP_SINK;
3783 w->power_check = dapm_always_on_check_power;
3809 w->power_check = dapm_generic_check_power;
3816 w->is_supply = 1;
3817 w->power_check = dapm_supply_check_power;
3820 w->power_check = dapm_always_on_check_power;
3824 w->dapm = dapm;
3825 INIT_LIST_HEAD(&w->list);
3826 INIT_LIST_HEAD(&w->dirty);
3828 list_add_tail(&w->list, &dapm->card->widgets);
3831 INIT_LIST_HEAD(&w->edges[dir]);
3832 w->endpoints[dir] = -1;
3836 w->connected = 1;
3840 dev_err_probe(dapm->dev, ret, "ASoC: Failed to request %s\n",
3841 w->name);
3842 kfree_const(w->name);
3843 kfree_const(w->sname);
3850 * snd_soc_dapm_new_control - create new dapm control
3873 * snd_soc_dapm_new_controls - create new dapm controls
3876 * @num: number of widgets
3927 return -ENOMEM;
3931 return -ENOMEM;
3933 substream->runtime = runtime;
3935 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3937 source = path->source->priv;
3943 snd_soc_dai_activate(source, substream->stream);
3946 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
3948 sink = path->sink->priv;
3954 snd_soc_dai_activate(sink, substream->stream);
3957 substream->hw_opened = 1;
3964 config = rtd->dai_link->c2c_params + rtd->c2c_params_select;
3966 dev_err(w->dapm->dev, "ASoC: link config missing\n");
3967 return -EINVAL;
3971 if (!config->formats) {
3972 dev_warn(w->dapm->dev, "ASoC: Invalid format was specified\n");
3974 return -EINVAL;
3977 fmt = ffs(config->formats) - 1;
3980 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
3981 config->rate_min;
3982 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
3983 config->rate_max;
3984 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
3985 = config->channels_min;
3986 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
3987 = config->channels_max;
3989 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3991 source = path->source->priv;
4000 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
4002 sink = path->sink->priv;
4011 runtime->format = params_format(params);
4012 runtime->subformat = params_subformat(params);
4013 runtime->channels = params_channels(params);
4014 runtime->rate = params_rate(params);
4024 struct snd_pcm_substream *substream = w->priv;
4025 int ret = 0, saved_stream = substream->stream;
4027 if (WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
4028 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
4029 return -EINVAL;
4041 source = path->source->priv;
4047 sink = path->sink->priv;
4053 sink = path->sink->priv;
4062 sink = path->sink->priv;
4068 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
4070 source = path->source->priv;
4074 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
4076 sink = path->sink->priv;
4080 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
4082 source = path->source->priv;
4083 snd_soc_dai_deactivate(source, substream->stream);
4087 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
4089 sink = path->sink->priv;
4090 snd_soc_dai_deactivate(sink, substream->stream);
4096 kfree(substream->runtime);
4097 substream->runtime = NULL;
4102 ret = -EINVAL;
4107 substream->stream = saved_stream;
4115 struct snd_soc_pcm_runtime *rtd = w->priv;
4117 ucontrol->value.enumerated.item[0] = rtd->c2c_params_select;
4126 struct snd_soc_pcm_runtime *rtd = w->priv;
4129 if (w->power)
4130 return -EBUSY;
4132 if (ucontrol->value.enumerated.item[0] == rtd->c2c_params_select)
4135 if (ucontrol->value.enumerated.item[0] >= rtd->dai_link->num_c2c_params)
4136 return -EINVAL;
4138 rtd->c2c_params_select = ucontrol->value.enumerated.item[0];
4151 devm_kfree(card->dev, (void *)*private_value);
4157 devm_kfree(card->dev, (void *)w_param_text[count]);
4158 devm_kfree(card->dev, w_param_text);
4181 if (!config->stream_name) {
4182 dev_warn(card->dapm.dev,
4186 devm_kasprintf(card->dev, GFP_KERNEL,
4190 w_param_text[count] = devm_kmemdup(card->dev,
4191 config->stream_name,
4192 strlen(config->stream_name) + 1,
4204 (unsigned long) devm_kmemdup(card->dev,
4208 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
4214 kcontrol_news = devm_kmemdup(card->dev, &kcontrol_dai_link[0],
4218 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
4242 int ret = -ENOMEM;
4244 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
4245 rtd->dai_link->name, id);
4253 if (rtd->dai_link->num_c2c_params > 1) {
4254 w_param_text = devm_kcalloc(card->dev,
4255 rtd->dai_link->num_c2c_params,
4262 rtd->dai_link->c2c_params,
4263 rtd->dai_link->num_c2c_params,
4279 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
4281 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
4287 w->priv = substream;
4292 devm_kfree(card->dev, (void *)template.kcontrol_news);
4294 rtd->dai_link->num_c2c_params, w_param_text);
4296 devm_kfree(card->dev, link_name);
4298 dev_err(rtd->dev, "ASoC: Failed to create %s-%s widget: %d\n",
4299 rtd->dai_link->name, id, ret);
4304 * snd_soc_dapm_new_dai_widgets - Create new DAPM widgets
4316 WARN_ON(dapm->dev != dai->dev);
4321 if (dai->driver->playback.stream_name) {
4323 template.name = dai->driver->playback.stream_name;
4324 template.sname = dai->driver->playback.stream_name;
4326 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
4333 w->priv = dai;
4337 if (dai->driver->capture.stream_name) {
4339 template.name = dai->driver->capture.stream_name;
4340 template.sname = dai->driver->capture.stream_name;
4342 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
4349 w->priv = dai;
4365 switch (dai_w->id) {
4374 if (!dai_w->priv) {
4375 dev_dbg(card->dev, "dai widget %s has no DAI\n",
4376 dai_w->name);
4380 dai = dai_w->priv;
4382 /* ...find all widgets with the same stream and link them */
4384 if (w->dapm != dai_w->dapm)
4387 switch (w->id) {
4395 if (!w->sname || !strstr(w->sname, dai_w->sname))
4398 if (dai_w->id == snd_soc_dapm_dai_in) {
4405 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
4406 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
4420 dev_dbg(dapm->dev, "connected DAI link %s:%s -> %s:%s\n",
4421 src_dai->component->name, src->name,
4422 sink_dai->component->name, sink->name);
4437 struct snd_soc_dai_link *dai_link = rtd->dai_link;
4452 /* connect BE DAI playback if widgets are valid */
4460 if (dai_link->c2c_params && !rtd->c2c_widget[stream]) {
4461 struct snd_pcm_substream *substream = rtd->pcm->streams[stream].substream;
4468 rtd->c2c_widget[stream] = dai;
4471 dapm_connect_dai_routes(&card->dapm, src_dai[stream], *src[stream],
4472 rtd->c2c_widget[stream],
4489 if (w->id == snd_soc_dapm_dai_in) {
4499 w->active = 1;
4500 w->is_ep = ep;
4503 w->active = 0;
4504 w->is_ep = 0;
4528 * CODEC<->CODEC links have no direct connection.
4530 if (rtd->dai_link->dynamic)
4535 * soc.h :: [dai_link->ch_maps Image sample]
4538 cpu_dai = snd_soc_rtd_to_cpu(rtd, ch_maps->cpu);
4539 codec_dai = snd_soc_rtd_to_codec(rtd, ch_maps->codec);
4555 dapm_power_widgets(rtd->card, event, NULL);
4559 * snd_soc_dapm_stream_event - send a stream event to the dapm core
4572 struct snd_soc_card *card = rtd->card;
4589 rtd->pop_wait = 1;
4591 &rtd->delayed_work,
4592 msecs_to_jiffies(rtd->pmdown_time));
4603 * snd_soc_dapm_enable_pin_unlocked - enable pin.
4607 * Enables input/output pin and its parents or children widgets iff there is
4623 * snd_soc_dapm_enable_pin - enable pin.
4627 * Enables input/output pin and its parents or children widgets iff there is
4648 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
4667 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4668 return -EINVAL;
4671 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
4672 if (!w->connected) {
4674 * w->force does not affect the number of input or output paths,
4675 * so we only have to recheck if w->connected is changed
4679 w->connected = 1;
4681 w->force = 1;
4689 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
4716 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4720 * Disables input/output pin and its parents or children widgets.
4735 * snd_soc_dapm_disable_pin - disable pin.
4739 * Disables input/output pin and its parents or children widgets.
4760 * snd_soc_dapm_get_pin_status - get audio pin status
4764 * Get audio pin status - connected or disconnected.
4774 return w->connected;
4781 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
4785 * Mark the given endpoint or pin as ignoring suspend. When the
4787 * suspend will not be disabled. The path must already be enabled via
4788 * normal means at suspend time, it will not be turned on if it was not
4797 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4798 return -EINVAL;
4801 w->ignore_suspend = 1;
4808 * snd_soc_dapm_free - free dapm resources
4811 * Free all dapm widgets and resources.
4817 list_del(&dapm->list);
4824 dapm->card = card;
4825 dapm->component = component;
4826 dapm->bias_level = SND_SOC_BIAS_OFF;
4829 dapm->dev = component->dev;
4830 dapm->idle_bias = component->driver->idle_bias_on;
4832 dapm->dev = card->dev;
4835 INIT_LIST_HEAD(&dapm->list);
4837 list_add(&dapm->list, &card->dapm_list);
4842 struct snd_soc_card *card = dapm->card;
4849 for_each_card_widgets(dapm->card, w) {
4850 if (w->dapm != dapm)
4852 if (w->power) {
4854 w->new_power = 0;
4859 /* If there were no widgets to power down we're already in
4863 if (dapm->bias_level == SND_SOC_BIAS_ON)
4867 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4876 * snd_soc_dapm_shutdown - callback for system shutdown
4883 if (dapm != &card->dapm) {
4885 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4891 soc_dapm_shutdown_dapm(&card->dapm);
4892 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4893 snd_soc_dapm_set_bias_level(&card->dapm,