2018-07-02 06:24:31 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
//
|
|
|
|
// soc-dapm.c -- ALSA SoC Dynamic Audio Power Management
|
|
|
|
//
|
|
|
|
// Copyright 2005 Wolfson Microelectronics PLC.
|
|
|
|
// Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
|
|
|
//
|
|
|
|
// Features:
|
|
|
|
// o Changes power status of internal codec blocks depending on the
|
|
|
|
// dynamic configuration of codec internal audio paths and active
|
|
|
|
// DACs/ADCs.
|
|
|
|
// o Platform power domain - can support external components i.e. amps and
|
|
|
|
// mic/headphone insertion events.
|
|
|
|
// o Automatic Mic Bias support
|
|
|
|
// o Jack insertion power event initiation - e.g. hp insertion will enable
|
|
|
|
// sinks, dacs, etc
|
|
|
|
// o Delayed power down of audio subsystem to reduce pops between a quick
|
|
|
|
// device reopen.
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
2011-02-18 19:49:43 +00:00
|
|
|
#include <linux/async.h>
|
2006-10-06 16:32:18 +00:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/jiffies.h>
|
2009-08-24 07:40:34 +00:00
|
|
|
#include <linux/debugfs.h>
|
2011-12-05 15:17:06 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-01-21 21:14:48 +00:00
|
|
|
#include <linux/regulator/consumer.h>
|
2018-03-10 02:37:27 +00:00
|
|
|
#include <linux/pinctrl/consumer.h>
|
2012-05-24 13:26:25 +00:00
|
|
|
#include <linux/clk.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2006-10-06 16:32:18 +00:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
2010-11-05 13:53:46 +00:00
|
|
|
#include <sound/soc.h>
|
2006-10-06 16:32:18 +00:00
|
|
|
#include <sound/initval.h>
|
|
|
|
|
2010-11-04 04:07:02 +00:00
|
|
|
#include <trace/events/asoc.h>
|
|
|
|
|
2011-09-20 20:43:24 +00:00
|
|
|
#define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
#define SND_SOC_DAPM_DIR_REVERSE(x) ((x == SND_SOC_DAPM_DIR_IN) ? \
|
|
|
|
SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN)
|
|
|
|
|
|
|
|
#define snd_soc_dapm_for_each_direction(dir) \
|
|
|
|
for ((dir) = SND_SOC_DAPM_DIR_IN; (dir) <= SND_SOC_DAPM_DIR_OUT; \
|
|
|
|
(dir)++)
|
|
|
|
|
2013-08-05 09:27:31 +00:00
|
|
|
static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
|
|
|
|
const char *control,
|
|
|
|
int (*connected)(struct snd_soc_dapm_widget *source,
|
|
|
|
struct snd_soc_dapm_widget *sink));
|
2015-06-01 21:57:53 +00:00
|
|
|
|
2015-06-04 14:13:09 +00:00
|
|
|
struct snd_soc_dapm_widget *
|
2013-08-05 09:27:31 +00:00
|
|
|
snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
|
|
|
|
const struct snd_soc_dapm_widget *widget);
|
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
struct snd_soc_dapm_widget *
|
|
|
|
snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
|
2013-08-05 09:27:31 +00:00
|
|
|
const struct snd_soc_dapm_widget *widget);
|
|
|
|
|
2022-06-23 10:51:15 +00:00
|
|
|
static unsigned int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg);
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* dapm power sequences - make this per codec in the future */
|
|
|
|
static int dapm_up_seq[] = {
|
2019-02-05 16:22:28 +00:00
|
|
|
[snd_soc_dapm_pre] = 1,
|
|
|
|
[snd_soc_dapm_regulator_supply] = 2,
|
|
|
|
[snd_soc_dapm_pinctrl] = 2,
|
|
|
|
[snd_soc_dapm_clock_supply] = 2,
|
|
|
|
[snd_soc_dapm_supply] = 3,
|
2022-10-19 00:37:07 +00:00
|
|
|
[snd_soc_dapm_dai_link] = 3,
|
2019-02-05 16:22:28 +00:00
|
|
|
[snd_soc_dapm_micbias] = 4,
|
|
|
|
[snd_soc_dapm_vmid] = 4,
|
|
|
|
[snd_soc_dapm_dai_in] = 5,
|
|
|
|
[snd_soc_dapm_dai_out] = 5,
|
|
|
|
[snd_soc_dapm_aif_in] = 5,
|
|
|
|
[snd_soc_dapm_aif_out] = 5,
|
|
|
|
[snd_soc_dapm_mic] = 6,
|
|
|
|
[snd_soc_dapm_siggen] = 6,
|
|
|
|
[snd_soc_dapm_input] = 6,
|
|
|
|
[snd_soc_dapm_output] = 6,
|
|
|
|
[snd_soc_dapm_mux] = 7,
|
|
|
|
[snd_soc_dapm_demux] = 7,
|
|
|
|
[snd_soc_dapm_dac] = 8,
|
|
|
|
[snd_soc_dapm_switch] = 9,
|
|
|
|
[snd_soc_dapm_mixer] = 9,
|
|
|
|
[snd_soc_dapm_mixer_named_ctl] = 9,
|
|
|
|
[snd_soc_dapm_pga] = 10,
|
|
|
|
[snd_soc_dapm_buffer] = 10,
|
|
|
|
[snd_soc_dapm_scheduler] = 10,
|
|
|
|
[snd_soc_dapm_effect] = 10,
|
|
|
|
[snd_soc_dapm_src] = 10,
|
|
|
|
[snd_soc_dapm_asrc] = 10,
|
|
|
|
[snd_soc_dapm_encoder] = 10,
|
|
|
|
[snd_soc_dapm_decoder] = 10,
|
|
|
|
[snd_soc_dapm_adc] = 11,
|
|
|
|
[snd_soc_dapm_out_drv] = 12,
|
|
|
|
[snd_soc_dapm_hp] = 12,
|
|
|
|
[snd_soc_dapm_line] = 12,
|
|
|
|
[snd_soc_dapm_sink] = 12,
|
2023-03-24 16:33:28 +00:00
|
|
|
[snd_soc_dapm_spk] = 13,
|
|
|
|
[snd_soc_dapm_kcontrol] = 14,
|
|
|
|
[snd_soc_dapm_post] = 15,
|
2006-10-06 16:32:18 +00:00
|
|
|
};
|
2009-01-06 20:11:51 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
static int dapm_down_seq[] = {
|
2019-02-05 16:22:28 +00:00
|
|
|
[snd_soc_dapm_pre] = 1,
|
|
|
|
[snd_soc_dapm_kcontrol] = 2,
|
|
|
|
[snd_soc_dapm_adc] = 3,
|
|
|
|
[snd_soc_dapm_spk] = 4,
|
2023-03-24 16:33:28 +00:00
|
|
|
[snd_soc_dapm_hp] = 5,
|
|
|
|
[snd_soc_dapm_line] = 5,
|
|
|
|
[snd_soc_dapm_out_drv] = 5,
|
|
|
|
[snd_soc_dapm_sink] = 6,
|
|
|
|
[snd_soc_dapm_pga] = 6,
|
|
|
|
[snd_soc_dapm_buffer] = 6,
|
|
|
|
[snd_soc_dapm_scheduler] = 6,
|
|
|
|
[snd_soc_dapm_effect] = 6,
|
|
|
|
[snd_soc_dapm_src] = 6,
|
|
|
|
[snd_soc_dapm_asrc] = 6,
|
|
|
|
[snd_soc_dapm_encoder] = 6,
|
|
|
|
[snd_soc_dapm_decoder] = 6,
|
|
|
|
[snd_soc_dapm_switch] = 7,
|
|
|
|
[snd_soc_dapm_mixer_named_ctl] = 7,
|
|
|
|
[snd_soc_dapm_mixer] = 7,
|
|
|
|
[snd_soc_dapm_dac] = 8,
|
|
|
|
[snd_soc_dapm_mic] = 9,
|
|
|
|
[snd_soc_dapm_siggen] = 9,
|
|
|
|
[snd_soc_dapm_input] = 9,
|
|
|
|
[snd_soc_dapm_output] = 9,
|
|
|
|
[snd_soc_dapm_micbias] = 10,
|
|
|
|
[snd_soc_dapm_vmid] = 10,
|
|
|
|
[snd_soc_dapm_mux] = 11,
|
|
|
|
[snd_soc_dapm_demux] = 11,
|
|
|
|
[snd_soc_dapm_aif_in] = 12,
|
|
|
|
[snd_soc_dapm_aif_out] = 12,
|
|
|
|
[snd_soc_dapm_dai_in] = 12,
|
|
|
|
[snd_soc_dapm_dai_out] = 12,
|
|
|
|
[snd_soc_dapm_dai_link] = 13,
|
|
|
|
[snd_soc_dapm_supply] = 14,
|
|
|
|
[snd_soc_dapm_clock_supply] = 15,
|
|
|
|
[snd_soc_dapm_pinctrl] = 15,
|
|
|
|
[snd_soc_dapm_regulator_supply] = 15,
|
|
|
|
[snd_soc_dapm_post] = 16,
|
2006-10-06 16:32:18 +00:00
|
|
|
};
|
|
|
|
|
2014-03-06 08:49:11 +00:00
|
|
|
static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
2023-01-31 02:01:34 +00:00
|
|
|
if (snd_soc_card_is_instantiated(dapm->card))
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_assert_held(dapm);
|
2014-03-06 08:49:11 +00:00
|
|
|
}
|
|
|
|
|
2008-10-14 00:42:14 +00:00
|
|
|
static void pop_wait(u32 pop_time)
|
2008-07-02 10:51:20 +00:00
|
|
|
{
|
|
|
|
if (pop_time)
|
|
|
|
schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
|
|
|
|
}
|
|
|
|
|
2019-01-23 19:41:30 +00:00
|
|
|
__printf(3, 4)
|
2010-11-09 12:40:28 +00:00
|
|
|
static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
|
2008-07-02 10:51:20 +00:00
|
|
|
{
|
|
|
|
va_list args;
|
2010-11-09 12:40:28 +00:00
|
|
|
char *buf;
|
2008-07-02 10:51:20 +00:00
|
|
|
|
2010-11-09 12:40:28 +00:00
|
|
|
if (!pop_time)
|
|
|
|
return;
|
2008-07-02 10:51:20 +00:00
|
|
|
|
2010-11-09 12:40:28 +00:00
|
|
|
buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
|
|
|
if (buf == NULL)
|
|
|
|
return;
|
2008-07-02 10:51:20 +00:00
|
|
|
|
2010-11-09 12:40:28 +00:00
|
|
|
va_start(args, fmt);
|
|
|
|
vsnprintf(buf, PAGE_SIZE, fmt, args);
|
2010-12-22 13:08:40 +00:00
|
|
|
dev_info(dev, "%s", buf);
|
2008-07-02 10:51:20 +00:00
|
|
|
va_end(args);
|
2010-11-09 12:40:28 +00:00
|
|
|
|
|
|
|
kfree(buf);
|
2008-07-02 10:51:20 +00:00
|
|
|
}
|
|
|
|
|
2011-10-03 20:06:40 +00:00
|
|
|
static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
return !list_empty(&w->dirty);
|
|
|
|
}
|
|
|
|
|
2014-03-06 08:15:48 +00:00
|
|
|
static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
|
2011-10-03 20:06:40 +00:00
|
|
|
{
|
2014-03-06 08:49:11 +00:00
|
|
|
dapm_assert_locked(w->dapm);
|
|
|
|
|
2011-10-04 21:28:08 +00:00
|
|
|
if (!dapm_dirty_widget(w)) {
|
|
|
|
dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
|
|
|
|
w->name, reason);
|
2011-10-03 20:06:40 +00:00
|
|
|
list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
|
2011-10-04 21:28:08 +00:00
|
|
|
}
|
2011-10-03 20:06:40 +00:00
|
|
|
}
|
|
|
|
|
2014-10-25 15:42:03 +00:00
|
|
|
/*
|
2015-08-11 19:38:00 +00:00
|
|
|
* Common implementation for dapm_widget_invalidate_input_paths() and
|
|
|
|
* dapm_widget_invalidate_output_paths(). The function is inlined since the
|
|
|
|
* combined size of the two specialized functions is only marginally larger then
|
|
|
|
* the size of the generic function and at the same time the fast path of the
|
|
|
|
* specialized functions is significantly smaller than the generic function.
|
2014-10-25 15:42:03 +00:00
|
|
|
*/
|
2015-08-11 19:38:00 +00:00
|
|
|
static __always_inline void dapm_widget_invalidate_paths(
|
|
|
|
struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
|
2014-10-25 15:42:03 +00:00
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
|
|
|
|
struct snd_soc_dapm_widget *node;
|
2014-10-25 15:42:03 +00:00
|
|
|
struct snd_soc_dapm_path *p;
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
dapm_assert_locked(w->dapm);
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if (w->endpoints[dir] == -1)
|
2014-10-25 15:42:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
list_add_tail(&w->work_list, &list);
|
2015-08-11 19:38:00 +00:00
|
|
|
w->endpoints[dir] = -1;
|
2014-10-25 15:42:03 +00:00
|
|
|
|
|
|
|
list_for_each_entry(w, &list, work_list) {
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_path(w, dir, p) {
|
2014-10-25 15:42:03 +00:00
|
|
|
if (p->is_supply || p->weak || !p->connect)
|
|
|
|
continue;
|
2015-08-11 19:38:00 +00:00
|
|
|
node = p->node[rdir];
|
|
|
|
if (node->endpoints[dir] != -1) {
|
|
|
|
node->endpoints[dir] = -1;
|
|
|
|
list_add_tail(&node->work_list, &list);
|
2014-10-25 15:42:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
/*
|
|
|
|
* dapm_widget_invalidate_input_paths() - Invalidate the cached number of
|
|
|
|
* input paths
|
|
|
|
* @w: The widget for which to invalidate the cached number of input paths
|
|
|
|
*
|
|
|
|
* Resets the cached number of inputs for the specified widget and all widgets
|
|
|
|
* that can be reached via outcoming paths from the widget.
|
|
|
|
*
|
|
|
|
* This function must be called if the number of output paths for a widget might
|
|
|
|
* have changed. E.g. if the source state of a widget changes or a path is added
|
|
|
|
* or activated with the widget as the sink.
|
|
|
|
*/
|
|
|
|
static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_IN);
|
|
|
|
}
|
|
|
|
|
2014-10-25 15:42:03 +00:00
|
|
|
/*
|
|
|
|
* dapm_widget_invalidate_output_paths() - Invalidate the cached number of
|
|
|
|
* output paths
|
|
|
|
* @w: The widget for which to invalidate the cached number of output paths
|
|
|
|
*
|
|
|
|
* Resets the cached number of outputs for the specified widget and all widgets
|
|
|
|
* that can be reached via incoming paths from the widget.
|
|
|
|
*
|
|
|
|
* This function must be called if the number of output paths for a widget might
|
|
|
|
* have changed. E.g. if the sink state of a widget changes or a path is added
|
|
|
|
* or activated with the widget as the source.
|
|
|
|
*/
|
|
|
|
static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
|
2014-10-25 15:42:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
|
|
|
|
* for the widgets connected to a path
|
|
|
|
* @p: The path to invalidate
|
|
|
|
*
|
|
|
|
* Resets the cached number of inputs for the sink of the path and the cached
|
|
|
|
* number of outputs for the source of the path.
|
|
|
|
*
|
|
|
|
* This function must be called when a path is added, removed or the connected
|
|
|
|
* state changes.
|
|
|
|
*/
|
|
|
|
static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Weak paths or supply paths do not influence the number of input or
|
|
|
|
* output paths of their neighbors.
|
|
|
|
*/
|
|
|
|
if (p->weak || p->is_supply)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of connected endpoints is the sum of the number of
|
|
|
|
* connected endpoints of all neighbors. If a node with 0 connected
|
|
|
|
* endpoints is either connected or disconnected that sum won't change,
|
|
|
|
* so there is no need to re-check the path.
|
|
|
|
*/
|
2015-08-11 19:38:00 +00:00
|
|
|
if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_widget_invalidate_input_paths(p->sink);
|
2015-08-11 19:38:00 +00:00
|
|
|
if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_widget_invalidate_output_paths(p->source);
|
|
|
|
}
|
|
|
|
|
2014-10-25 15:42:01 +00:00
|
|
|
void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
|
2012-09-01 00:38:32 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(card);
|
2012-09-01 00:38:32 +00:00
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, w) {
|
2015-08-11 19:38:00 +00:00
|
|
|
if (w->is_ep) {
|
2014-10-25 15:42:01 +00:00
|
|
|
dapm_mark_dirty(w, "Rechecking endpoints");
|
2015-08-11 19:38:00 +00:00
|
|
|
if (w->is_ep & SND_SOC_DAPM_EP_SINK)
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_widget_invalidate_output_paths(w);
|
2015-08-11 19:38:00 +00:00
|
|
|
if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_widget_invalidate_input_paths(w);
|
|
|
|
}
|
2012-09-01 00:38:32 +00:00
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2012-09-01 00:38:32 +00:00
|
|
|
}
|
2014-10-25 15:42:01 +00:00
|
|
|
EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
|
2012-09-01 00:38:32 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* create a new dapm widget */
|
2007-02-05 13:56:20 +00:00
|
|
|
static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
|
2006-10-06 16:32:18 +00:00
|
|
|
const struct snd_soc_dapm_widget *_widget)
|
|
|
|
{
|
2019-02-01 17:05:12 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
|
|
|
w = kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
|
|
|
|
if (!w)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* w->name is duplicated in caller, but w->sname isn't.
|
|
|
|
* Duplicate it here if defined
|
|
|
|
*/
|
|
|
|
if (_widget->sname) {
|
|
|
|
w->sname = kstrdup_const(_widget->sname, GFP_KERNEL);
|
2019-02-19 12:04:27 +00:00
|
|
|
if (!w->sname) {
|
|
|
|
kfree(w);
|
2019-02-01 17:05:12 +00:00
|
|
|
return NULL;
|
2019-02-19 12:04:27 +00:00
|
|
|
}
|
2019-02-01 17:05:12 +00:00
|
|
|
}
|
|
|
|
return w;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:58 +00:00
|
|
|
struct dapm_kcontrol_data {
|
2013-07-29 15:13:59 +00:00
|
|
|
unsigned int value;
|
2013-08-05 09:27:31 +00:00
|
|
|
struct snd_soc_dapm_widget *widget;
|
2013-07-29 15:14:00 +00:00
|
|
|
struct list_head paths;
|
2013-08-01 12:08:07 +00:00
|
|
|
struct snd_soc_dapm_widget_list *wlist;
|
2013-07-29 15:13:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
|
2016-02-03 20:59:50 +00:00
|
|
|
struct snd_kcontrol *kcontrol, const char *ctrl_name)
|
2013-07-29 15:13:58 +00:00
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data;
|
2013-08-05 09:27:31 +00:00
|
|
|
struct soc_mixer_control *mc;
|
2015-05-01 11:37:26 +00:00
|
|
|
struct soc_enum *e;
|
2015-05-01 11:37:25 +00:00
|
|
|
const char *name;
|
|
|
|
int ret;
|
2013-07-29 15:13:58 +00:00
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
data = kzalloc(sizeof(*data), GFP_KERNEL);
|
2015-05-01 11:37:24 +00:00
|
|
|
if (!data)
|
2013-07-29 15:13:58 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-07-29 15:14:00 +00:00
|
|
|
INIT_LIST_HEAD(&data->paths);
|
2013-07-29 15:13:58 +00:00
|
|
|
|
2013-08-05 09:27:31 +00:00
|
|
|
switch (widget->id) {
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
|
|
|
mc = (struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
|
|
|
|
if (mc->autodisable) {
|
|
|
|
struct snd_soc_dapm_widget template;
|
|
|
|
|
2022-06-23 10:51:20 +00:00
|
|
|
if (snd_soc_volsw_is_stereo(mc))
|
|
|
|
dev_warn(widget->dapm->dev,
|
|
|
|
"ASoC: Unsupported stereo autodisable control '%s'\n",
|
|
|
|
ctrl_name);
|
|
|
|
|
2016-02-03 20:59:50 +00:00
|
|
|
name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
|
2015-05-01 11:37:25 +00:00
|
|
|
"Autodisable");
|
|
|
|
if (!name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_data;
|
|
|
|
}
|
|
|
|
|
2013-08-05 09:27:31 +00:00
|
|
|
memset(&template, 0, sizeof(template));
|
|
|
|
template.reg = mc->reg;
|
|
|
|
template.mask = (1 << fls(mc->max)) - 1;
|
|
|
|
template.shift = mc->shift;
|
|
|
|
if (mc->invert)
|
|
|
|
template.off_val = mc->max;
|
|
|
|
else
|
|
|
|
template.off_val = 0;
|
|
|
|
template.on_val = template.off_val;
|
|
|
|
template.id = snd_soc_dapm_kcontrol;
|
2015-05-01 11:37:25 +00:00
|
|
|
template.name = name;
|
2013-08-05 09:27:31 +00:00
|
|
|
|
2013-08-30 15:39:33 +00:00
|
|
|
data->value = template.on_val;
|
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
data->widget =
|
|
|
|
snd_soc_dapm_new_control_unlocked(widget->dapm,
|
2013-08-05 09:27:31 +00:00
|
|
|
&template);
|
2015-07-08 19:59:59 +00:00
|
|
|
kfree(name);
|
ASoC: dapm: handle probe deferrals
This starts to handle probe deferrals on regulators and clocks
on the ASoC DAPM.
I came to this patch after audio stopped working on Ux500 ages
ago and I finally looked into it to see what is wrong. I had
messages like this in the console since a while back:
ab8500-codec.0: ASoC: Failed to request audioclk: -517
ab8500-codec.0: ASoC: Failed to create DAPM control audioclk
ab8500-codec.0: Failed to create new controls -12
snd-soc-mop500.0: ASoC: failed to instantiate card -12
snd-soc-mop500.0: Error: snd_soc_register_card failed (-12)!
snd-soc-mop500: probe of snd-soc-mop500.0 failed with error -12
Apparently because the widget table for the codec looks like
this (sound/soc/codecs/ab8500-codec.c):
static const struct snd_soc_dapm_widget ab8500_dapm_widgets[] = {
/* Clocks */
SND_SOC_DAPM_CLOCK_SUPPLY("audioclk"),
/* Regulators */
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AUD", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC1", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC2", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-DMIC", 0, 0),
So when we call snd_soc_register_codec() and any of these widgets
get a deferred probe we do not get an -EPROBE_DEFER (-517) back as
we should and instead we just fail. Apparently the code assumes
that clocks and regulators must be available at this point and
not defer.
After this patch it rather looks like this:
ab8500-codec.0: Failed to create new controls -517
snd-soc-mop500.0: ASoC: failed to instantiate card -517
snd-soc-mop500.0: Error: snd_soc_register_card failed (-517)!
(...)
abx500-clk.0: registered clocks for ab850x
snd-soc-mop500.0: ab8500-codec-dai.0 <-> ux500-msp-i2s.1 mapping ok
snd-soc-mop500.0: ab8500-codec-dai.1 <-> ux500-msp-i2s.3 mapping ok
I'm pretty happy about the patch as it it, but I'm a bit
uncertain on how to proceed: there are a lot of users of the
external functions snd_soc_dapm_new_control() (111 sites)
and that will now return an occassional error pointer, which
is not handled in the calling sites.
I want an indication from the maintainers whether I should just
go in and augment all these call sites, or if deferred probe
is frowned upon when it leads to this much overhead.
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
2017-01-13 09:23:52 +00:00
|
|
|
if (IS_ERR(data->widget)) {
|
|
|
|
ret = PTR_ERR(data->widget);
|
|
|
|
goto err_data;
|
|
|
|
}
|
2013-08-05 09:27:31 +00:00
|
|
|
}
|
|
|
|
break;
|
2015-05-01 16:02:43 +00:00
|
|
|
case snd_soc_dapm_demux:
|
2015-05-01 11:37:26 +00:00
|
|
|
case snd_soc_dapm_mux:
|
|
|
|
e = (struct soc_enum *)kcontrol->private_value;
|
|
|
|
|
|
|
|
if (e->autodisable) {
|
|
|
|
struct snd_soc_dapm_widget template;
|
|
|
|
|
2016-02-03 20:59:50 +00:00
|
|
|
name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
|
2015-05-01 11:37:26 +00:00
|
|
|
"Autodisable");
|
|
|
|
if (!name) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&template, 0, sizeof(template));
|
|
|
|
template.reg = e->reg;
|
2020-04-18 04:13:20 +00:00
|
|
|
template.mask = e->mask;
|
2015-05-01 11:37:26 +00:00
|
|
|
template.shift = e->shift_l;
|
|
|
|
template.off_val = snd_soc_enum_item_to_val(e, 0);
|
|
|
|
template.on_val = template.off_val;
|
|
|
|
template.id = snd_soc_dapm_kcontrol;
|
|
|
|
template.name = name;
|
|
|
|
|
|
|
|
data->value = template.on_val;
|
|
|
|
|
2015-06-26 09:39:43 +00:00
|
|
|
data->widget = snd_soc_dapm_new_control_unlocked(
|
|
|
|
widget->dapm, &template);
|
2015-07-08 19:59:59 +00:00
|
|
|
kfree(name);
|
ASoC: dapm: handle probe deferrals
This starts to handle probe deferrals on regulators and clocks
on the ASoC DAPM.
I came to this patch after audio stopped working on Ux500 ages
ago and I finally looked into it to see what is wrong. I had
messages like this in the console since a while back:
ab8500-codec.0: ASoC: Failed to request audioclk: -517
ab8500-codec.0: ASoC: Failed to create DAPM control audioclk
ab8500-codec.0: Failed to create new controls -12
snd-soc-mop500.0: ASoC: failed to instantiate card -12
snd-soc-mop500.0: Error: snd_soc_register_card failed (-12)!
snd-soc-mop500: probe of snd-soc-mop500.0 failed with error -12
Apparently because the widget table for the codec looks like
this (sound/soc/codecs/ab8500-codec.c):
static const struct snd_soc_dapm_widget ab8500_dapm_widgets[] = {
/* Clocks */
SND_SOC_DAPM_CLOCK_SUPPLY("audioclk"),
/* Regulators */
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AUD", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC1", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC2", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-DMIC", 0, 0),
So when we call snd_soc_register_codec() and any of these widgets
get a deferred probe we do not get an -EPROBE_DEFER (-517) back as
we should and instead we just fail. Apparently the code assumes
that clocks and regulators must be available at this point and
not defer.
After this patch it rather looks like this:
ab8500-codec.0: Failed to create new controls -517
snd-soc-mop500.0: ASoC: failed to instantiate card -517
snd-soc-mop500.0: Error: snd_soc_register_card failed (-517)!
(...)
abx500-clk.0: registered clocks for ab850x
snd-soc-mop500.0: ab8500-codec-dai.0 <-> ux500-msp-i2s.1 mapping ok
snd-soc-mop500.0: ab8500-codec-dai.1 <-> ux500-msp-i2s.3 mapping ok
I'm pretty happy about the patch as it it, but I'm a bit
uncertain on how to proceed: there are a lot of users of the
external functions snd_soc_dapm_new_control() (111 sites)
and that will now return an occassional error pointer, which
is not handled in the calling sites.
I want an indication from the maintainers whether I should just
go in and augment all these call sites, or if deferred probe
is frowned upon when it leads to this much overhead.
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
2017-01-13 09:23:52 +00:00
|
|
|
if (IS_ERR(data->widget)) {
|
|
|
|
ret = PTR_ERR(data->widget);
|
|
|
|
goto err_data;
|
|
|
|
}
|
2015-05-01 11:37:26 +00:00
|
|
|
|
|
|
|
snd_soc_dapm_add_path(widget->dapm, data->widget,
|
|
|
|
widget, NULL, NULL);
|
2022-06-23 10:51:15 +00:00
|
|
|
} else if (e->reg != SND_SOC_NOPM) {
|
|
|
|
data->value = soc_dapm_read(widget->dapm, e->reg) &
|
|
|
|
(e->mask << e->shift_l);
|
2015-05-01 11:37:26 +00:00
|
|
|
}
|
|
|
|
break;
|
2013-08-05 09:27:31 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:58 +00:00
|
|
|
kcontrol->private_data = data;
|
|
|
|
|
|
|
|
return 0;
|
2015-05-01 11:37:25 +00:00
|
|
|
|
|
|
|
err_data:
|
|
|
|
kfree(data);
|
|
|
|
return ret;
|
2013-07-29 15:13:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
|
2018-06-04 11:13:26 +00:00
|
|
|
|
|
|
|
list_del(&data->paths);
|
2013-08-01 12:08:07 +00:00
|
|
|
kfree(data->wlist);
|
2013-07-29 15:13:58 +00:00
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
|
|
|
|
const struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
return data->wlist;
|
2013-07-29 15:13:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_soc_dapm_widget *widget)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
2013-08-01 12:08:07 +00:00
|
|
|
struct snd_soc_dapm_widget_list *new_wlist;
|
|
|
|
unsigned int n;
|
2013-07-29 15:13:58 +00:00
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
if (data->wlist)
|
|
|
|
n = data->wlist->num_widgets + 1;
|
|
|
|
else
|
|
|
|
n = 1;
|
|
|
|
|
|
|
|
new_wlist = krealloc(data->wlist,
|
2019-05-23 20:36:37 +00:00
|
|
|
struct_size(new_wlist, widgets, n),
|
|
|
|
GFP_KERNEL);
|
2013-08-01 12:08:07 +00:00
|
|
|
if (!new_wlist)
|
2013-07-29 15:13:58 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
new_wlist->widgets[n - 1] = widget;
|
|
|
|
new_wlist->num_widgets = n;
|
2013-07-29 15:13:58 +00:00
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
data->wlist = new_wlist;
|
2013-07-29 15:13:58 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:14:00 +00:00
|
|
|
static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_soc_dapm_path *path)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
list_add_tail(&path->list_kcontrol, &data->paths);
|
2013-08-05 09:27:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
if (!data->widget)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return data->widget->power;
|
2013-07-29 15:14:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct list_head *dapm_kcontrol_get_path_list(
|
|
|
|
const struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
return &data->paths;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define dapm_kcontrol_for_each_path(path, kcontrol) \
|
|
|
|
list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
|
|
|
|
list_kcontrol)
|
|
|
|
|
2014-09-19 11:16:05 +00:00
|
|
|
unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
|
2013-07-29 15:13:59 +00:00
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
return data->value;
|
|
|
|
}
|
2014-09-19 11:16:05 +00:00
|
|
|
EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
|
2013-07-29 15:13:59 +00:00
|
|
|
|
|
|
|
static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
|
|
|
|
unsigned int value)
|
|
|
|
{
|
|
|
|
struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
if (data->value == value)
|
|
|
|
return false;
|
|
|
|
|
2020-04-18 04:13:20 +00:00
|
|
|
if (data->widget) {
|
|
|
|
switch (dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->id) {
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
|
|
|
data->widget->on_val = value & data->widget->mask;
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_demux:
|
|
|
|
case snd_soc_dapm_mux:
|
|
|
|
data->widget->on_val = value >> data->widget->shift;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
data->widget->on_val = value;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-08-05 09:27:31 +00:00
|
|
|
|
2013-07-29 15:13:59 +00:00
|
|
|
data->value = value;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-20 17:00:08 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_kcontrol_widget() - Returns the widget associated to a
|
|
|
|
* kcontrol
|
|
|
|
* @kcontrol: The kcontrol
|
|
|
|
*/
|
|
|
|
struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
return dapm_kcontrol_get_wlist(kcontrol)->widgets[0];
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_widget);
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
|
|
|
|
* kcontrol
|
|
|
|
* @kcontrol: The kcontrol
|
|
|
|
*
|
|
|
|
* Note: This function must only be used on kcontrols that are known to have
|
|
|
|
* been registered for a CODEC. Otherwise the behaviour is undefined.
|
|
|
|
*/
|
|
|
|
struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
|
|
|
|
|
2012-02-15 15:15:34 +00:00
|
|
|
static void dapm_reset(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_assert_held(card);
|
2014-03-06 08:49:11 +00:00
|
|
|
|
2012-02-15 15:15:34 +00:00
|
|
|
memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
|
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, w) {
|
2013-07-29 15:14:03 +00:00
|
|
|
w->new_power = w->power;
|
2012-02-15 15:15:34 +00:00
|
|
|
w->power_checked = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:01 +00:00
|
|
|
static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
if (!dapm->component)
|
|
|
|
return NULL;
|
|
|
|
return dapm->component->name_prefix;
|
|
|
|
}
|
|
|
|
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
static unsigned int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg)
|
2011-06-13 18:37:36 +00:00
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
if (!dapm->component)
|
2014-04-22 11:23:13 +00:00
|
|
|
return -EIO;
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
return snd_soc_component_read(dapm->component, reg);
|
2012-03-06 18:16:19 +00:00
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
|
2014-04-22 11:23:13 +00:00
|
|
|
int reg, unsigned int mask, unsigned int value)
|
2012-03-06 18:16:19 +00:00
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
if (!dapm->component)
|
2014-04-22 11:23:13 +00:00
|
|
|
return -EIO;
|
2014-12-15 13:08:48 +00:00
|
|
|
return snd_soc_component_update_bits(dapm->component, reg,
|
|
|
|
mask, value);
|
2012-03-06 18:16:19 +00:00
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
|
|
|
|
int reg, unsigned int mask, unsigned int value)
|
|
|
|
{
|
|
|
|
if (!dapm->component)
|
|
|
|
return -EIO;
|
|
|
|
return snd_soc_component_test_bits(dapm->component, reg, mask, value);
|
|
|
|
}
|
|
|
|
|
2013-10-09 12:52:52 +00:00
|
|
|
static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
2014-04-22 11:23:13 +00:00
|
|
|
if (dapm->component)
|
|
|
|
snd_soc_component_async_complete(dapm->component);
|
2011-06-13 18:37:36 +00:00
|
|
|
}
|
|
|
|
|
2015-05-11 12:50:30 +00:00
|
|
|
static struct snd_soc_dapm_widget *
|
2022-10-17 23:36:27 +00:00
|
|
|
dapm_wcache_lookup(struct snd_soc_dapm_widget *w, const char *name)
|
2015-05-11 12:50:30 +00:00
|
|
|
{
|
|
|
|
if (w) {
|
2021-08-05 01:10:55 +00:00
|
|
|
struct list_head *wlist = &w->dapm->card->widgets;
|
|
|
|
const int depth = 2;
|
|
|
|
int i = 0;
|
2015-05-11 12:50:30 +00:00
|
|
|
|
|
|
|
list_for_each_entry_from(w, wlist, list) {
|
|
|
|
if (!strcmp(name, w->name))
|
|
|
|
return w;
|
|
|
|
|
|
|
|
if (++i == depth)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-04-27 20:13:23 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
|
|
|
|
* @dapm: The DAPM context for which to set the level
|
|
|
|
* @level: The level to set
|
|
|
|
*
|
|
|
|
* Forces the DAPM bias level to a specific state. It will call the bias level
|
|
|
|
* callback of DAPM context with the specified level. This will even happen if
|
|
|
|
* the context is already at the same level. Furthermore it will not go through
|
|
|
|
* the normal bias level sequencing, meaning any intermediate states between the
|
|
|
|
* current and the target state will not be entered.
|
|
|
|
*
|
|
|
|
* Note that the change in bias level is only temporary and the next time
|
|
|
|
* snd_soc_dapm_sync() is called the state will be set to the level as
|
|
|
|
* determined by the DAPM core. The function is mainly intended to be used to
|
|
|
|
* used during probe or resume from suspend to power up the device so
|
|
|
|
* initialization can be done, before the DAPM core takes over.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2019-07-26 04:51:43 +00:00
|
|
|
if (dapm->component)
|
|
|
|
ret = snd_soc_component_set_bias_level(dapm->component, level);
|
2015-04-27 20:13:23 +00:00
|
|
|
|
2015-04-27 20:13:25 +00:00
|
|
|
if (ret == 0)
|
|
|
|
dapm->bias_level = level;
|
|
|
|
|
2015-04-27 20:13:23 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
|
|
|
|
|
2009-05-17 20:41:23 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_set_bias_level - set the bias level for the system
|
2011-02-18 19:12:42 +00:00
|
|
|
* @dapm: DAPM context
|
2009-05-17 20:41:23 +00:00
|
|
|
* @level: level to configure
|
|
|
|
*
|
|
|
|
* Configure the bias (power) levels for the SoC audio device.
|
|
|
|
*
|
|
|
|
* Returns 0 for success else error.
|
|
|
|
*/
|
2011-02-18 19:12:42 +00:00
|
|
|
static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
|
2010-11-05 13:53:46 +00:00
|
|
|
enum snd_soc_bias_level level)
|
2009-05-17 20:41:23 +00:00
|
|
|
{
|
2011-02-18 19:12:42 +00:00
|
|
|
struct snd_soc_card *card = dapm->card;
|
2009-05-17 20:41:23 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_bias_level_start(card, level);
|
|
|
|
|
2020-05-28 01:49:35 +00:00
|
|
|
ret = snd_soc_card_set_bias_level(card, dapm, level);
|
2011-06-06 17:15:19 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto out;
|
|
|
|
|
2015-04-27 20:13:23 +00:00
|
|
|
if (!card || dapm != &card->dapm)
|
|
|
|
ret = snd_soc_dapm_force_bias_level(dapm, level);
|
2012-07-06 15:56:16 +00:00
|
|
|
|
2011-06-06 17:15:19 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto out;
|
|
|
|
|
2020-05-28 01:50:35 +00:00
|
|
|
ret = snd_soc_card_set_bias_level_post(card, dapm, level);
|
2011-06-06 17:15:19 +00:00
|
|
|
out:
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_bias_level_done(card, level);
|
|
|
|
|
2009-05-17 20:41:23 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-06-06 10:26:15 +00:00
|
|
|
/* connect mux widget to its interconnecting audio paths */
|
2010-11-05 13:53:46 +00:00
|
|
|
static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
|
2015-05-01 16:02:43 +00:00
|
|
|
struct snd_soc_dapm_path *path, const char *control_name,
|
|
|
|
struct snd_soc_dapm_widget *w)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-05-01 16:02:43 +00:00
|
|
|
const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
|
2006-10-06 16:32:18 +00:00
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2021-08-05 01:11:00 +00:00
|
|
|
unsigned int item;
|
2006-10-06 16:32:18 +00:00
|
|
|
int i;
|
2010-12-16 15:53:39 +00:00
|
|
|
|
2014-02-28 07:31:12 +00:00
|
|
|
if (e->reg != SND_SOC_NOPM) {
|
2021-08-05 01:11:00 +00:00
|
|
|
unsigned int val;
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
val = soc_dapm_read(dapm, e->reg);
|
2014-02-28 07:31:12 +00:00
|
|
|
val = (val >> e->shift_l) & e->mask;
|
|
|
|
item = snd_soc_enum_val_to_item(e, val);
|
|
|
|
} else {
|
2010-12-16 15:53:39 +00:00
|
|
|
/* since a virtual mux has no backing registers to
|
|
|
|
* decide which path to connect, it will try to match
|
|
|
|
* with the first enumeration. This is to ensure
|
|
|
|
* that the default mux choice (the first) will be
|
|
|
|
* correctly powered up during initialization.
|
|
|
|
*/
|
2014-02-28 07:31:12 +00:00
|
|
|
item = 0;
|
2010-12-16 15:53:39 +00:00
|
|
|
}
|
2009-01-05 07:54:57 +00:00
|
|
|
|
2018-05-31 11:11:23 +00:00
|
|
|
i = match_string(e->texts, e->items, control_name);
|
|
|
|
if (i < 0)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
path->name = e->texts[i];
|
|
|
|
path->connect = (i == item);
|
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-02-28 07:31:12 +00:00
|
|
|
/* set up initial codec paths */
|
2016-11-02 07:35:59 +00:00
|
|
|
static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i,
|
|
|
|
int nth_path)
|
2014-02-28 07:31:12 +00:00
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc = (struct soc_mixer_control *)
|
2014-10-25 15:41:58 +00:00
|
|
|
p->sink->kcontrol_news[i].private_value;
|
2014-02-28 07:31:12 +00:00
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int invert = mc->invert;
|
|
|
|
|
|
|
|
if (reg != SND_SOC_NOPM) {
|
2021-08-05 01:11:05 +00:00
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int max = mc->max;
|
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
|
|
|
unsigned int val = soc_dapm_read(p->sink->dapm, reg);
|
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
/*
|
|
|
|
* The nth_path argument allows this function to know
|
|
|
|
* which path of a kcontrol it is setting the initial
|
|
|
|
* status for. Ideally this would support any number
|
|
|
|
* of paths and channels. But since kcontrols only come
|
|
|
|
* in mono and stereo variants, we are limited to 2
|
|
|
|
* channels.
|
|
|
|
*
|
|
|
|
* The following code assumes for stereo controls the
|
|
|
|
* first path is the left channel, and all remaining
|
|
|
|
* paths are the right channel.
|
|
|
|
*/
|
|
|
|
if (snd_soc_volsw_is_stereo(mc) && nth_path > 0) {
|
|
|
|
if (reg != mc->rreg)
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
val = soc_dapm_read(p->sink->dapm, mc->rreg);
|
2016-11-02 07:35:59 +00:00
|
|
|
val = (val >> mc->rshift) & mask;
|
|
|
|
} else {
|
|
|
|
val = (val >> shift) & mask;
|
|
|
|
}
|
2014-02-28 07:31:12 +00:00
|
|
|
if (invert)
|
|
|
|
val = max - val;
|
|
|
|
p->connect = !!val;
|
|
|
|
} else {
|
2020-03-31 07:55:16 +00:00
|
|
|
/* since a virtual mixer has no backing registers to
|
|
|
|
* decide which path to connect, it will try to match
|
|
|
|
* with initial state. This is to ensure
|
|
|
|
* that the default mixer choice will be
|
|
|
|
* correctly powered up during initialization.
|
|
|
|
*/
|
|
|
|
p->connect = invert;
|
2014-02-28 07:31:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-06 10:26:15 +00:00
|
|
|
/* connect mixer widget to its interconnecting audio paths */
|
2010-11-05 13:53:46 +00:00
|
|
|
static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_path *path, const char *control_name)
|
|
|
|
{
|
2016-11-02 07:35:59 +00:00
|
|
|
int i, nth_path = 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
/* search for mixer kcontrol */
|
2014-10-25 15:41:58 +00:00
|
|
|
for (i = 0; i < path->sink->num_kcontrols; i++) {
|
|
|
|
if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
|
|
|
|
path->name = path->sink->kcontrol_news[i].name;
|
2016-11-02 07:35:59 +00:00
|
|
|
dapm_set_mixer_path_status(path, i, nth_path++);
|
2006-10-06 16:32:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
|
ASoC: Fix dapm_is_shared_kcontrol so everything isn't shared
Commit af46800 ("ASoC: Implement mux control sharing") introduced
function dapm_is_shared_kcontrol.
When this function returns true, the naming of DAPM controls is derived
from the kcontrol_new. Otherwise, the name comes from the widget (and
possibly a widget's naming prefix).
A bug in the implementation of dapm_is_shared_kcontrol made it return 1
in all cases. Hence, that commit caused a change in control naming for
all controls instead of just shared controls.
Specifically, a control is always considered shared because it is always
compared against itself. Solve this by never comparing against the widget
containing the control being created.
Equally, controls should never be shared between DAPM contexts; when the
same codec is instantiated multiple times, the same kcontrol_new will be
used. However, the control should no be shared between the multiple
instances.
I tested that with the Tegra WM8903 driver:
* Shared is now mostly 0 as expected, and sometimes 1.
* The expected controls are still generated after this change.
However, I don't have any systems that have a widget/control naming
prefix, so I can't test that aspect.
Thanks for Jarkko Nikula for pointing out how to fix this.
Reported-by: Liam Girdwood <lrg@ti.com>
Tested-by: Jarkko Nikula <jhnikula@gmail.com>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-05-26 15:57:33 +00:00
|
|
|
struct snd_soc_dapm_widget *kcontrolw,
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
const struct snd_kcontrol_new *kcontrol_new,
|
|
|
|
struct snd_kcontrol **kcontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*kcontrol = NULL;
|
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(dapm->card, w) {
|
ASoC: Fix dapm_is_shared_kcontrol so everything isn't shared
Commit af46800 ("ASoC: Implement mux control sharing") introduced
function dapm_is_shared_kcontrol.
When this function returns true, the naming of DAPM controls is derived
from the kcontrol_new. Otherwise, the name comes from the widget (and
possibly a widget's naming prefix).
A bug in the implementation of dapm_is_shared_kcontrol made it return 1
in all cases. Hence, that commit caused a change in control naming for
all controls instead of just shared controls.
Specifically, a control is always considered shared because it is always
compared against itself. Solve this by never comparing against the widget
containing the control being created.
Equally, controls should never be shared between DAPM contexts; when the
same codec is instantiated multiple times, the same kcontrol_new will be
used. However, the control should no be shared between the multiple
instances.
I tested that with the Tegra WM8903 driver:
* Shared is now mostly 0 as expected, and sometimes 1.
* The expected controls are still generated after this change.
However, I don't have any systems that have a widget/control naming
prefix, so I can't test that aspect.
Thanks for Jarkko Nikula for pointing out how to fix this.
Reported-by: Liam Girdwood <lrg@ti.com>
Tested-by: Jarkko Nikula <jhnikula@gmail.com>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-05-26 15:57:33 +00:00
|
|
|
if (w == kcontrolw || w->dapm != kcontrolw->dapm)
|
|
|
|
continue;
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
/*
|
|
|
|
* Determine if a kcontrol is shared. If it is, look it up. If it isn't,
|
|
|
|
* create it. Either way, add the widget into the control's widget list
|
|
|
|
*/
|
2015-10-20 17:00:06 +00:00
|
|
|
static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
|
2013-08-12 22:28:42 +00:00
|
|
|
int kci)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2011-06-09 11:22:36 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
2011-03-02 18:17:32 +00:00
|
|
|
struct snd_card *card = dapm->card->snd_card;
|
2011-03-08 17:23:24 +00:00
|
|
|
const char *prefix;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
size_t prefix_len;
|
|
|
|
int shared;
|
|
|
|
struct snd_kcontrol *kcontrol;
|
|
|
|
bool wname_in_long_name, kcname_in_long_name;
|
2014-10-07 11:41:24 +00:00
|
|
|
char *long_name = NULL;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
const char *name;
|
2014-10-07 11:41:24 +00:00
|
|
|
int ret = 0;
|
2011-03-08 17:23:24 +00:00
|
|
|
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix = soc_dapm_prefix(dapm);
|
2011-03-09 11:33:09 +00:00
|
|
|
if (prefix)
|
|
|
|
prefix_len = strlen(prefix) + 1;
|
|
|
|
else
|
|
|
|
prefix_len = 0;
|
|
|
|
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
|
|
|
|
&kcontrol);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
if (!kcontrol) {
|
|
|
|
if (shared) {
|
|
|
|
wname_in_long_name = false;
|
|
|
|
kcname_in_long_name = true;
|
|
|
|
} else {
|
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
2015-10-20 17:00:06 +00:00
|
|
|
case snd_soc_dapm_pga:
|
2019-04-30 23:11:34 +00:00
|
|
|
case snd_soc_dapm_effect:
|
2016-08-27 11:28:00 +00:00
|
|
|
case snd_soc_dapm_out_drv:
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
wname_in_long_name = true;
|
|
|
|
kcname_in_long_name = true;
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
|
|
|
wname_in_long_name = false;
|
|
|
|
kcname_in_long_name = true;
|
|
|
|
break;
|
2015-05-01 16:02:43 +00:00
|
|
|
case snd_soc_dapm_demux:
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
case snd_soc_dapm_mux:
|
|
|
|
wname_in_long_name = true;
|
|
|
|
kcname_in_long_name = false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2011-08-15 18:15:21 +00:00
|
|
|
}
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (wname_in_long_name && kcname_in_long_name) {
|
|
|
|
/*
|
|
|
|
* 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.
|
2009-01-06 20:11:51 +00:00
|
|
|
*/
|
2013-05-14 09:05:32 +00:00
|
|
|
long_name = kasprintf(GFP_KERNEL, "%s %s",
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
w->name + prefix_len,
|
|
|
|
w->kcontrol_news[kci].name);
|
2013-07-29 15:13:58 +00:00
|
|
|
if (long_name == NULL)
|
2013-05-14 09:05:32 +00:00
|
|
|
return -ENOMEM;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
|
|
|
|
name = long_name;
|
|
|
|
} else if (wname_in_long_name) {
|
|
|
|
long_name = NULL;
|
|
|
|
name = w->name + prefix_len;
|
|
|
|
} else {
|
|
|
|
long_name = NULL;
|
|
|
|
name = w->kcontrol_news[kci].name;
|
|
|
|
}
|
2009-01-06 20:11:51 +00:00
|
|
|
|
2013-07-29 15:13:58 +00:00
|
|
|
kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
prefix);
|
2014-10-07 11:41:24 +00:00
|
|
|
if (!kcontrol) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto exit_free;
|
|
|
|
}
|
|
|
|
|
2013-08-01 12:08:06 +00:00
|
|
|
kcontrol->private_free = dapm_kcontrol_free;
|
2013-07-29 15:13:58 +00:00
|
|
|
|
2016-02-03 20:59:50 +00:00
|
|
|
ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
|
2013-07-29 15:13:58 +00:00
|
|
|
if (ret) {
|
|
|
|
snd_ctl_free_one(kcontrol);
|
2014-10-07 11:41:24 +00:00
|
|
|
goto exit_free;
|
2013-07-29 15:13:58 +00:00
|
|
|
}
|
|
|
|
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
ret = snd_ctl_add(card, kcontrol);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dapm->dev,
|
|
|
|
"ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
|
|
|
|
w->name, name, ret);
|
2014-10-07 11:41:24 +00:00
|
|
|
goto exit_free;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2013-08-01 12:08:07 +00:00
|
|
|
ret = dapm_kcontrol_add_widget(kcontrol, w);
|
2014-10-07 11:41:24 +00:00
|
|
|
if (ret == 0)
|
|
|
|
w->kcontrols[kci] = kcontrol;
|
2013-08-01 12:08:07 +00:00
|
|
|
|
2014-10-07 11:41:24 +00:00
|
|
|
exit_free:
|
|
|
|
kfree(long_name);
|
2009-01-06 20:11:51 +00:00
|
|
|
|
2014-10-07 11:41:24 +00:00
|
|
|
return ret;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
}
|
2008-10-28 13:02:31 +00:00
|
|
|
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
/* create new dapm mixer control */
|
|
|
|
static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
struct snd_soc_dapm_path *path;
|
2015-05-01 11:37:26 +00:00
|
|
|
struct dapm_kcontrol_data *data;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
|
|
|
|
/* add kcontrol */
|
|
|
|
for (i = 0; i < w->num_kcontrols; i++) {
|
|
|
|
/* match name */
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path) {
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
/* mixer/mux paths name must match control name */
|
|
|
|
if (path->name != (char *)w->kcontrol_news[i].name)
|
|
|
|
continue;
|
|
|
|
|
2015-05-01 11:37:26 +00:00
|
|
|
if (!w->kcontrols[i]) {
|
2015-10-20 17:00:06 +00:00
|
|
|
ret = dapm_create_or_share_kcontrol(w, i);
|
2015-05-01 11:37:26 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
|
2013-08-12 22:28:42 +00:00
|
|
|
dapm_kcontrol_add_path(w->kcontrols[i], path);
|
2015-05-01 11:37:26 +00:00
|
|
|
|
|
|
|
data = snd_kcontrol_chip(w->kcontrols[i]);
|
|
|
|
if (data->widget)
|
|
|
|
snd_soc_dapm_add_path(data->widget->dapm,
|
|
|
|
data->widget,
|
|
|
|
path->source,
|
|
|
|
NULL, NULL);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
}
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* create new dapm mux control */
|
2011-06-09 11:22:36 +00:00
|
|
|
static int dapm_new_mux(struct snd_soc_dapm_widget *w)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2011-06-09 11:22:36 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir;
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
struct snd_soc_dapm_path *path;
|
2015-05-01 16:02:43 +00:00
|
|
|
const char *type;
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
int ret;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2015-05-01 16:02:43 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_mux:
|
2015-08-11 19:38:00 +00:00
|
|
|
dir = SND_SOC_DAPM_DIR_OUT;
|
2015-05-01 16:02:43 +00:00
|
|
|
type = "mux";
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_demux:
|
2015-08-11 19:38:00 +00:00
|
|
|
dir = SND_SOC_DAPM_DIR_IN;
|
2015-05-01 16:02:43 +00:00
|
|
|
type = "demux";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
if (w->num_kcontrols != 1) {
|
|
|
|
dev_err(dapm->dev,
|
2015-05-01 16:02:43 +00:00
|
|
|
"ASoC: %s %s has incorrect number of controls\n", type,
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
w->name);
|
2006-10-06 16:32:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if (list_empty(&w->edges[dir])) {
|
2015-05-01 16:02:43 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
return -EINVAL;
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
}
|
2010-11-05 13:53:46 +00:00
|
|
|
|
2015-10-20 17:00:06 +00:00
|
|
|
ret = dapm_create_or_share_kcontrol(w, 0);
|
ASoC: dapm: Implement mixer control sharing
This is the equivalent of commit af46800 "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.
This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.
Without this, you either:
1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).
2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.
Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2013-03-29 21:40:10 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-04-28 23:37:59 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_path(w, dir, path) {
|
|
|
|
if (path->name)
|
|
|
|
dapm_kcontrol_add_path(w->kcontrols[0], path);
|
2014-10-25 15:41:57 +00:00
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
|
ASoC: Implement mux control sharing
Control sharing is enabled when two widgets include pointers to the
same kcontrol_new in their definition. Specifically:
static const struct snd_kcontrol_new adcinput_mux =
SOC_DAPM_ENUM("ADC Input", adcinput_enum);
static const struct snd_soc_dapm_widget wm8903_dapm_widgets[] = {
SND_SOC_DAPM_MUX("Left ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
SND_SOC_DAPM_MUX("Right ADC Input", SND_SOC_NOPM, 0, 0, &adcinput_mux),
};
This is useful when a single register bit or field affects multiple
muxes at once. The common case is to have separate control bits or
fields for each mux (channel). An alternative way of looking at this
is that the mux is a stereo (or even n-channel) mux, rather than
independant mono muxes.
Without this change, a separate kcontrol will be created for each
DAPM_MUX. This has the following disadvantages:
* Confuses the user/programmer with redundant controls that don't
map to separate hardware.
* When one of the controls is changed, ASoC fails to update the DAPM
logic for paths solely affected by the other controls impacted by
the same register bits. This causes some paths not to be correctly
powered up or down. Prior to this change, to work around this, the
user or programmer had to manually toggle all duplicate controls away
from the intended setting, and then back to it.
Control sharing implies that the control is named based on the
kcontrol_new itself, not any of the widgets that are affected by it.
Control sharing is implemented by: When creating kcontrols, if a
kcontrol does not yet exist for a particular kcontrol_new, then a new
kcontrol is created with a list of widgets containing just a single
entry. This is the normal case. However, if a kcontrol does already
exists for the given kcontrol_new, the current widget is simply added
to that kcontrol's list of affected widgets.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2011-04-28 23:38:01 +00:00
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* create new dapm volume control */
|
2011-06-09 11:22:36 +00:00
|
|
|
static int dapm_new_pga(struct snd_soc_dapm_widget *w)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2021-08-05 01:11:10 +00:00
|
|
|
int i;
|
2015-10-20 17:00:06 +00:00
|
|
|
|
|
|
|
for (i = 0; i < w->num_kcontrols; i++) {
|
2021-08-05 01:11:10 +00:00
|
|
|
int ret = dapm_create_or_share_kcontrol(w, i);
|
2015-10-20 17:00:06 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2010-03-03 17:45:21 +00:00
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2015-02-02 17:06:44 +00:00
|
|
|
/* create new dapm dai link control */
|
|
|
|
static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
2021-08-05 01:11:15 +00:00
|
|
|
int i;
|
2018-09-05 14:21:02 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = w->priv;
|
2015-02-02 17:06:44 +00:00
|
|
|
|
|
|
|
/* create control for links with > 1 config */
|
2023-04-02 22:59:35 +00:00
|
|
|
if (rtd->dai_link->num_c2c_params <= 1)
|
2015-02-02 17:06:44 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* add kcontrol */
|
|
|
|
for (i = 0; i < w->num_kcontrols; i++) {
|
2021-08-05 01:11:15 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = w->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);
|
|
|
|
|
2015-02-02 17:06:44 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dapm->dev,
|
|
|
|
"ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
|
|
|
|
w->name, w->kcontrol_news[i].name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
kcontrol->private_data = w;
|
|
|
|
w->kcontrols[i] = kcontrol;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-07 19:24:05 +00:00
|
|
|
/* We implement power down on suspend by checking the power state of
|
|
|
|
* the ALSA card - when we are suspending the ALSA state for the card
|
|
|
|
* is set to D3.
|
|
|
|
*/
|
|
|
|
static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
|
|
|
|
{
|
2011-03-02 18:17:32 +00:00
|
|
|
int level = snd_power_get_state(widget->dapm->card->snd_card);
|
2010-05-07 19:24:05 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
switch (level) {
|
2010-05-07 19:24:05 +00:00
|
|
|
case SNDRV_CTL_POWER_D3hot:
|
|
|
|
case SNDRV_CTL_POWER_D3cold:
|
2010-05-07 20:11:40 +00:00
|
|
|
if (widget->ignore_suspend)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
|
2010-11-09 12:40:27 +00:00
|
|
|
widget->name);
|
2010-05-07 20:11:40 +00:00
|
|
|
return widget->ignore_suspend;
|
2010-05-07 19:24:05 +00:00
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
ASoC: soc-pcm: move dpcm_path_put() to soc-pcm.c
dpcm_path_put() (A) is calling kfree(*list).
The freed list is created by dapm_widget_list_create() (B) which is called
from snd_soc_dapm_dai_get_connected_widgets() (C) which is called from
dpcm_path_get() (D).
(B) dapm_widget_list_create(**list, ...)
{
...
=> *list = kzalloc();
...
}
(C) snd_soc_dapm_dai_get_connected_widgets(..., **list, ...)
{
...
dapm_widget_list_create(list, ...);
...
}
(D) dpcm_path_get(..., **list)
{
...
snd_soc_dapm_dai_get_connected_widgets(..., list, ...);
...
}
(A) dpcm_path_put(**list)
{
=> kfree(*list);
}
This kind of unbalance code is very difficult to read/understand.
To avoid this issue, this patch adds each missing paired function
dapm_widget_list_free() for dapm_widget_list_create() (B), and
snd_soc_dapm_dai_free_widgets() for snd_soc_dapm_dai_get_connected_widgets() (C).
This patch uses these, and moves dpcm_path_put() next to dpcm_path_get().
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87a75fjc9q.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-02-19 06:56:52 +00:00
|
|
|
static void dapm_widget_list_free(struct snd_soc_dapm_widget_list **list)
|
|
|
|
{
|
|
|
|
kfree(*list);
|
|
|
|
}
|
|
|
|
|
2015-07-26 17:04:59 +00:00
|
|
|
static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
|
|
|
|
struct list_head *widgets)
|
2012-04-18 10:41:11 +00:00
|
|
|
{
|
2015-07-26 17:04:59 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
struct list_head *it;
|
|
|
|
unsigned int size = 0;
|
|
|
|
unsigned int i = 0;
|
2012-04-18 10:41:11 +00:00
|
|
|
|
2015-07-26 17:04:59 +00:00
|
|
|
list_for_each(it, widgets)
|
|
|
|
size++;
|
2012-04-18 10:41:11 +00:00
|
|
|
|
treewide: Use struct_size() for kmalloc()-family
One of the more common cases of allocation size calculations is finding
the size of a structure that has a zero-sized array at the end, along
with memory for some number of elements for that array. For example:
struct foo {
int stuff;
void *entry[];
};
instance = kmalloc(sizeof(struct foo) + sizeof(void *) * count, GFP_KERNEL);
Instead of leaving these open-coded and prone to type mistakes, we can
now use the new struct_size() helper:
instance = kmalloc(struct_size(instance, entry, count), GFP_KERNEL);
This patch makes the changes for kmalloc()-family (and kvmalloc()-family)
uses. It was done via automatic conversion with manual review for the
"CHECKME" non-standard cases noted below, using the following Coccinelle
script:
// pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
// sizeof *pkey_cache->table, GFP_KERNEL);
@@
identifier alloc =~ "kmalloc|kzalloc|kvmalloc|kvzalloc";
expression GFP;
identifier VAR, ELEMENT;
expression COUNT;
@@
- alloc(sizeof(*VAR) + COUNT * sizeof(*VAR->ELEMENT), GFP)
+ alloc(struct_size(VAR, ELEMENT, COUNT), GFP)
// mr = kzalloc(sizeof(*mr) + m * sizeof(mr->map[0]), GFP_KERNEL);
@@
identifier alloc =~ "kmalloc|kzalloc|kvmalloc|kvzalloc";
expression GFP;
identifier VAR, ELEMENT;
expression COUNT;
@@
- alloc(sizeof(*VAR) + COUNT * sizeof(VAR->ELEMENT[0]), GFP)
+ alloc(struct_size(VAR, ELEMENT, COUNT), GFP)
// Same pattern, but can't trivially locate the trailing element name,
// or variable name.
@@
identifier alloc =~ "kmalloc|kzalloc|kvmalloc|kvzalloc";
expression GFP;
expression SOMETHING, COUNT, ELEMENT;
@@
- alloc(sizeof(SOMETHING) + COUNT * sizeof(ELEMENT), GFP)
+ alloc(CHECKME_struct_size(&SOMETHING, ELEMENT, COUNT), GFP)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-05-08 20:45:50 +00:00
|
|
|
*list = kzalloc(struct_size(*list, widgets, size), GFP_KERNEL);
|
2015-07-26 17:04:59 +00:00
|
|
|
if (*list == NULL)
|
2012-04-18 10:41:11 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-07-26 17:04:59 +00:00
|
|
|
list_for_each_entry(w, widgets, work_list)
|
|
|
|
(*list)->widgets[i++] = w;
|
2012-04-18 10:41:11 +00:00
|
|
|
|
2015-07-26 17:04:59 +00:00
|
|
|
(*list)->num_widgets = i;
|
|
|
|
|
|
|
|
return 0;
|
2012-04-18 10:41:11 +00:00
|
|
|
}
|
|
|
|
|
2019-08-09 08:40:34 +00:00
|
|
|
/*
|
|
|
|
* Recursively reset the cached number of inputs or outputs for the specified
|
|
|
|
* widget and all widgets that can be reached via incoming or outcoming paths
|
|
|
|
* from the widget.
|
|
|
|
*/
|
|
|
|
static void invalidate_paths_ep(struct snd_soc_dapm_widget *widget,
|
|
|
|
enum snd_soc_dapm_direction dir)
|
|
|
|
{
|
|
|
|
enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
|
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
|
|
|
|
widget->endpoints[dir] = -1;
|
|
|
|
|
|
|
|
snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
|
|
|
|
if (path->weak || path->is_supply)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (path->walking)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (path->connect) {
|
|
|
|
path->walking = 1;
|
|
|
|
invalidate_paths_ep(path->node[dir], dir);
|
|
|
|
path->walking = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/*
|
2015-08-11 19:38:00 +00:00
|
|
|
* Common implementation for is_connected_output_ep() and
|
|
|
|
* is_connected_input_ep(). The function is inlined since the combined size of
|
|
|
|
* the two specialized functions is only marginally larger then the size of the
|
|
|
|
* generic function and at the same time the fast path of the specialized
|
|
|
|
* functions is significantly smaller than the generic function.
|
2006-10-06 16:32:18 +00:00
|
|
|
*/
|
2015-08-11 19:38:00 +00:00
|
|
|
static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
|
|
|
|
struct list_head *list, enum snd_soc_dapm_direction dir,
|
2016-05-13 16:03:55 +00:00
|
|
|
int (*fn)(struct snd_soc_dapm_widget *, struct list_head *,
|
|
|
|
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
|
|
|
|
enum snd_soc_dapm_direction)),
|
|
|
|
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
|
|
|
|
enum snd_soc_dapm_direction))
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
int con = 0;
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if (widget->endpoints[dir] >= 0)
|
|
|
|
return widget->endpoints[dir];
|
2011-10-09 10:52:05 +00:00
|
|
|
|
2011-09-20 20:43:24 +00:00
|
|
|
DAPM_UPDATE_STAT(widget, path_checks);
|
|
|
|
|
2015-07-26 17:04:59 +00:00
|
|
|
/* do we need to add this widget to the list ? */
|
|
|
|
if (list)
|
|
|
|
list_add_tail(&widget->work_list, list);
|
|
|
|
|
2016-06-15 05:46:55 +00:00
|
|
|
if (custom_stop_condition && custom_stop_condition(widget, dir)) {
|
2019-07-18 08:43:33 +00:00
|
|
|
list = NULL;
|
|
|
|
custom_stop_condition = NULL;
|
2016-06-15 05:46:55 +00:00
|
|
|
}
|
2016-05-13 16:03:55 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
|
|
|
|
widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
|
|
|
|
return widget->endpoints[dir];
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
|
2011-09-21 17:19:14 +00:00
|
|
|
DAPM_UPDATE_STAT(widget, neighbour_checks);
|
|
|
|
|
2014-10-25 15:42:00 +00:00
|
|
|
if (path->weak || path->is_supply)
|
2011-06-13 15:42:29 +00:00
|
|
|
continue;
|
|
|
|
|
2013-02-22 17:48:15 +00:00
|
|
|
if (path->walking)
|
|
|
|
return 1;
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
trace_snd_soc_dapm_path(widget, dir, path);
|
2012-04-18 10:41:11 +00:00
|
|
|
|
2014-10-20 17:36:34 +00:00
|
|
|
if (path->connect) {
|
2013-02-22 17:48:15 +00:00
|
|
|
path->walking = 1;
|
2016-05-13 16:03:55 +00:00
|
|
|
con += fn(path->node[dir], list, custom_stop_condition);
|
2013-02-22 17:48:15 +00:00
|
|
|
path->walking = 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
widget->endpoints[dir] = con;
|
2011-10-09 10:52:05 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
return con;
|
|
|
|
}
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
/*
|
|
|
|
* Recursively check for a completed path to an active or physically connected
|
|
|
|
* output widget. Returns number of complete paths.
|
2016-05-13 16:03:55 +00:00
|
|
|
*
|
|
|
|
* Optionally, can be supplied with a function acting as a stopping condition.
|
|
|
|
* This function takes the dapm widget currently being examined and the walk
|
2019-07-18 08:43:33 +00:00
|
|
|
* direction as an arguments, it should return true if widgets from that point
|
|
|
|
* in the graph onwards should not be added to the widget list.
|
2015-08-11 19:38:00 +00:00
|
|
|
*/
|
|
|
|
static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
|
2016-05-13 16:03:55 +00:00
|
|
|
struct list_head *list,
|
|
|
|
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
|
|
|
|
enum snd_soc_dapm_direction))
|
2015-08-11 19:38:00 +00:00
|
|
|
{
|
|
|
|
return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
|
2016-05-13 16:03:55 +00:00
|
|
|
is_connected_output_ep, custom_stop_condition);
|
2015-08-11 19:38:00 +00:00
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/*
|
|
|
|
* Recursively check for a completed path to an active or physically connected
|
|
|
|
* input widget. Returns number of complete paths.
|
2016-05-13 16:03:55 +00:00
|
|
|
*
|
|
|
|
* Optionally, can be supplied with a function acting as a stopping condition.
|
|
|
|
* This function takes the dapm widget currently being examined and the walk
|
|
|
|
* direction as an arguments, it should return true if the walk should be
|
|
|
|
* stopped and false otherwise.
|
2006-10-06 16:32:18 +00:00
|
|
|
*/
|
2012-04-18 10:41:11 +00:00
|
|
|
static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
|
2016-05-13 16:03:55 +00:00
|
|
|
struct list_head *list,
|
|
|
|
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
|
|
|
|
enum snd_soc_dapm_direction))
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
|
2016-05-13 16:03:55 +00:00
|
|
|
is_connected_input_ep, custom_stop_condition);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2012-04-18 10:41:11 +00:00
|
|
|
/**
|
2020-10-23 16:33:35 +00:00
|
|
|
* snd_soc_dapm_dai_get_connected_widgets - query audio path and it's widgets.
|
2012-04-18 10:41:11 +00:00
|
|
|
* @dai: the soc DAI.
|
|
|
|
* @stream: stream direction.
|
|
|
|
* @list: list of active widgets for this stream.
|
2016-05-13 16:03:55 +00:00
|
|
|
* @custom_stop_condition: (optional) a function meant to stop the widget graph
|
|
|
|
* walk based on custom logic.
|
2012-04-18 10:41:11 +00:00
|
|
|
*
|
2016-08-16 14:56:17 +00:00
|
|
|
* Queries DAPM graph as to whether a valid audio stream path exists for
|
2012-04-18 10:41:11 +00:00
|
|
|
* the initial stream specified by name. This takes into account
|
|
|
|
* current mixer and mux kcontrol settings. Creates list of valid widgets.
|
|
|
|
*
|
2016-05-13 16:03:55 +00:00
|
|
|
* Optionally, can be supplied with a function acting as a stopping condition.
|
|
|
|
* This function takes the dapm widget currently being examined and the walk
|
|
|
|
* direction as an arguments, it should return true if the walk should be
|
|
|
|
* stopped and false otherwise.
|
|
|
|
*
|
2012-04-18 10:41:11 +00:00
|
|
|
* Returns the number of valid paths or negative error.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
|
2016-05-13 16:03:55 +00:00
|
|
|
struct snd_soc_dapm_widget_list **list,
|
|
|
|
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
|
|
|
|
enum snd_soc_dapm_direction))
|
2012-04-18 10:41:11 +00:00
|
|
|
{
|
2014-11-04 10:30:58 +00:00
|
|
|
struct snd_soc_card *card = dai->component->card;
|
2023-01-31 02:01:34 +00:00
|
|
|
struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(dai, stream);
|
2015-07-26 17:04:59 +00:00
|
|
|
LIST_HEAD(widgets);
|
2012-04-18 10:41:11 +00:00
|
|
|
int paths;
|
2015-07-26 17:04:59 +00:00
|
|
|
int ret;
|
2012-04-18 10:41:11 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2014-10-25 15:42:03 +00:00
|
|
|
|
2019-08-09 08:40:34 +00:00
|
|
|
if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
|
|
|
|
invalidate_paths_ep(w, SND_SOC_DAPM_DIR_OUT);
|
|
|
|
paths = is_connected_output_ep(w, &widgets,
|
2016-05-13 16:03:55 +00:00
|
|
|
custom_stop_condition);
|
2019-08-09 08:40:34 +00:00
|
|
|
} else {
|
|
|
|
invalidate_paths_ep(w, SND_SOC_DAPM_DIR_IN);
|
|
|
|
paths = is_connected_input_ep(w, &widgets,
|
2016-05-13 16:03:55 +00:00
|
|
|
custom_stop_condition);
|
2019-08-09 08:40:34 +00:00
|
|
|
}
|
2015-07-26 17:04:59 +00:00
|
|
|
|
|
|
|
/* Drop starting point */
|
|
|
|
list_del(widgets.next);
|
|
|
|
|
|
|
|
ret = dapm_widget_list_create(list, &widgets);
|
|
|
|
if (ret)
|
2015-08-11 19:37:59 +00:00
|
|
|
paths = ret;
|
2012-04-18 10:41:11 +00:00
|
|
|
|
|
|
|
trace_snd_soc_dapm_connected(paths, stream);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2012-04-18 10:41:11 +00:00
|
|
|
|
|
|
|
return paths;
|
|
|
|
}
|
2021-09-27 12:05:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_dai_get_connected_widgets);
|
2012-04-18 10:41:11 +00:00
|
|
|
|
ASoC: soc-pcm: move dpcm_path_put() to soc-pcm.c
dpcm_path_put() (A) is calling kfree(*list).
The freed list is created by dapm_widget_list_create() (B) which is called
from snd_soc_dapm_dai_get_connected_widgets() (C) which is called from
dpcm_path_get() (D).
(B) dapm_widget_list_create(**list, ...)
{
...
=> *list = kzalloc();
...
}
(C) snd_soc_dapm_dai_get_connected_widgets(..., **list, ...)
{
...
dapm_widget_list_create(list, ...);
...
}
(D) dpcm_path_get(..., **list)
{
...
snd_soc_dapm_dai_get_connected_widgets(..., list, ...);
...
}
(A) dpcm_path_put(**list)
{
=> kfree(*list);
}
This kind of unbalance code is very difficult to read/understand.
To avoid this issue, this patch adds each missing paired function
dapm_widget_list_free() for dapm_widget_list_create() (B), and
snd_soc_dapm_dai_free_widgets() for snd_soc_dapm_dai_get_connected_widgets() (C).
This patch uses these, and moves dpcm_path_put() next to dpcm_path_get().
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87a75fjc9q.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-02-19 06:56:52 +00:00
|
|
|
void snd_soc_dapm_dai_free_widgets(struct snd_soc_dapm_widget_list **list)
|
|
|
|
{
|
|
|
|
dapm_widget_list_free(list);
|
|
|
|
}
|
2021-09-27 12:05:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_dai_free_widgets);
|
ASoC: soc-pcm: move dpcm_path_put() to soc-pcm.c
dpcm_path_put() (A) is calling kfree(*list).
The freed list is created by dapm_widget_list_create() (B) which is called
from snd_soc_dapm_dai_get_connected_widgets() (C) which is called from
dpcm_path_get() (D).
(B) dapm_widget_list_create(**list, ...)
{
...
=> *list = kzalloc();
...
}
(C) snd_soc_dapm_dai_get_connected_widgets(..., **list, ...)
{
...
dapm_widget_list_create(list, ...);
...
}
(D) dpcm_path_get(..., **list)
{
...
snd_soc_dapm_dai_get_connected_widgets(..., list, ...);
...
}
(A) dpcm_path_put(**list)
{
=> kfree(*list);
}
This kind of unbalance code is very difficult to read/understand.
To avoid this issue, this patch adds each missing paired function
dapm_widget_list_free() for dapm_widget_list_create() (B), and
snd_soc_dapm_dai_free_widgets() for snd_soc_dapm_dai_get_connected_widgets() (C).
This patch uses these, and moves dpcm_path_put() next to dpcm_path_get().
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87a75fjc9q.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-02-19 06:56:52 +00:00
|
|
|
|
2012-01-21 21:14:48 +00:00
|
|
|
/*
|
|
|
|
* Handler for regulator supply widget.
|
|
|
|
*/
|
|
|
|
int dapm_regulator_event(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
2012-09-07 04:57:11 +00:00
|
|
|
int ret;
|
|
|
|
|
2013-10-09 12:52:52 +00:00
|
|
|
soc_dapm_async_complete(w->dapm);
|
|
|
|
|
2012-09-07 04:57:11 +00:00
|
|
|
if (SND_SOC_DAPM_EVENT_ON(event)) {
|
2013-07-29 15:14:01 +00:00
|
|
|
if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
|
2013-01-10 19:33:47 +00:00
|
|
|
ret = regulator_allow_bypass(w->regulator, false);
|
2012-09-07 04:57:11 +00:00
|
|
|
if (ret != 0)
|
|
|
|
dev_warn(w->dapm->dev,
|
2014-02-18 16:05:27 +00:00
|
|
|
"ASoC: Failed to unbypass %s: %d\n",
|
2012-09-07 04:57:11 +00:00
|
|
|
w->name, ret);
|
|
|
|
}
|
|
|
|
|
2012-03-09 17:20:16 +00:00
|
|
|
return regulator_enable(w->regulator);
|
2012-09-07 04:57:11 +00:00
|
|
|
} else {
|
2013-07-29 15:14:01 +00:00
|
|
|
if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
|
2013-01-10 19:33:47 +00:00
|
|
|
ret = regulator_allow_bypass(w->regulator, true);
|
2012-09-07 04:57:11 +00:00
|
|
|
if (ret != 0)
|
|
|
|
dev_warn(w->dapm->dev,
|
2014-02-18 16:05:27 +00:00
|
|
|
"ASoC: Failed to bypass %s: %d\n",
|
2012-09-07 04:57:11 +00:00
|
|
|
w->name, ret);
|
|
|
|
}
|
|
|
|
|
2012-03-09 17:20:16 +00:00
|
|
|
return regulator_disable_deferred(w->regulator, w->shift);
|
2012-09-07 04:57:11 +00:00
|
|
|
}
|
2012-01-21 21:14:48 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dapm_regulator_event);
|
|
|
|
|
2018-03-10 02:37:27 +00:00
|
|
|
/*
|
|
|
|
* Handler for pinctrl widget.
|
|
|
|
*/
|
|
|
|
int dapm_pinctrl_event(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_pinctrl_priv *priv = w->priv;
|
|
|
|
struct pinctrl *p = w->pinctrl;
|
|
|
|
struct pinctrl_state *s;
|
|
|
|
|
|
|
|
if (!p || !priv)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (SND_SOC_DAPM_EVENT_ON(event))
|
|
|
|
s = pinctrl_lookup_state(p, priv->active_state);
|
|
|
|
else
|
|
|
|
s = pinctrl_lookup_state(p, priv->sleep_state);
|
|
|
|
|
|
|
|
if (IS_ERR(s))
|
|
|
|
return PTR_ERR(s);
|
|
|
|
|
|
|
|
return pinctrl_select_state(p, s);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dapm_pinctrl_event);
|
|
|
|
|
2012-05-24 13:26:25 +00:00
|
|
|
/*
|
|
|
|
* Handler for clock supply widget.
|
|
|
|
*/
|
|
|
|
int dapm_clock_event(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
|
|
|
if (!w->clk)
|
|
|
|
return -EIO;
|
|
|
|
|
2013-10-09 12:52:52 +00:00
|
|
|
soc_dapm_async_complete(w->dapm);
|
|
|
|
|
2012-05-24 13:26:25 +00:00
|
|
|
if (SND_SOC_DAPM_EVENT_ON(event)) {
|
2013-04-30 14:09:52 +00:00
|
|
|
return clk_prepare_enable(w->clk);
|
2012-05-24 13:26:25 +00:00
|
|
|
} else {
|
2013-04-30 14:09:52 +00:00
|
|
|
clk_disable_unprepare(w->clk);
|
2012-05-24 13:26:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-08-28 13:35:02 +00:00
|
|
|
|
2012-07-12 21:00:16 +00:00
|
|
|
return 0;
|
2012-05-24 13:26:25 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dapm_clock_event);
|
|
|
|
|
2011-09-28 17:28:23 +00:00
|
|
|
static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
2011-10-04 21:15:59 +00:00
|
|
|
if (w->power_checked)
|
|
|
|
return w->new_power;
|
|
|
|
|
2011-09-28 17:28:23 +00:00
|
|
|
if (w->force)
|
2011-10-04 21:15:59 +00:00
|
|
|
w->new_power = 1;
|
2011-09-28 17:28:23 +00:00
|
|
|
else
|
2011-10-04 21:15:59 +00:00
|
|
|
w->new_power = w->power_check(w);
|
|
|
|
|
|
|
|
w->power_checked = true;
|
|
|
|
|
|
|
|
return w->new_power;
|
2011-09-28 17:28:23 +00:00
|
|
|
}
|
|
|
|
|
2016-08-16 14:56:17 +00:00
|
|
|
/* Generic check to see if a widget should be powered. */
|
2009-04-20 15:56:59 +00:00
|
|
|
static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
int in, out;
|
|
|
|
|
2011-09-20 20:43:24 +00:00
|
|
|
DAPM_UPDATE_STAT(w, power_checks);
|
|
|
|
|
2016-05-13 16:03:55 +00:00
|
|
|
in = is_connected_input_ep(w, NULL, NULL);
|
|
|
|
out = is_connected_output_ep(w, NULL, NULL);
|
2009-04-20 15:56:59 +00:00
|
|
|
return out != 0 && in != 0;
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:24:55 +00:00
|
|
|
/* Check to see if a power supply is needed */
|
|
|
|
static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
|
2011-09-20 20:43:24 +00:00
|
|
|
DAPM_UPDATE_STAT(w, power_checks);
|
|
|
|
|
2009-04-22 17:24:55 +00:00
|
|
|
/* Check if one of our outputs is connected */
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
2011-09-28 17:20:26 +00:00
|
|
|
DAPM_UPDATE_STAT(w, neighbour_checks);
|
|
|
|
|
2011-06-13 15:42:29 +00:00
|
|
|
if (path->weak)
|
|
|
|
continue;
|
|
|
|
|
2009-09-08 17:59:05 +00:00
|
|
|
if (path->connected &&
|
|
|
|
!path->connected(path->source, path->sink))
|
|
|
|
continue;
|
|
|
|
|
2011-10-04 21:57:50 +00:00
|
|
|
if (dapm_widget_power_check(path->sink))
|
|
|
|
return 1;
|
2009-04-22 17:24:55 +00:00
|
|
|
}
|
|
|
|
|
2011-10-04 21:57:50 +00:00
|
|
|
return 0;
|
2009-04-22 17:24:55 +00:00
|
|
|
}
|
|
|
|
|
2011-09-28 17:23:53 +00:00
|
|
|
static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
2015-12-02 10:22:16 +00:00
|
|
|
return w->connected;
|
2011-09-28 17:23:53 +00:00
|
|
|
}
|
|
|
|
|
2009-06-06 18:03:23 +00:00
|
|
|
static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
|
|
|
|
struct snd_soc_dapm_widget *b,
|
2011-01-15 13:14:30 +00:00
|
|
|
bool power_up)
|
2009-03-01 19:21:10 +00:00
|
|
|
{
|
2011-01-15 13:14:30 +00:00
|
|
|
int *sort;
|
|
|
|
|
2019-02-05 16:22:28 +00:00
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(dapm_up_seq) != SND_SOC_DAPM_TYPE_COUNT);
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(dapm_down_seq) != SND_SOC_DAPM_TYPE_COUNT);
|
|
|
|
|
2011-01-15 13:14:30 +00:00
|
|
|
if (power_up)
|
|
|
|
sort = dapm_up_seq;
|
|
|
|
else
|
|
|
|
sort = dapm_down_seq;
|
|
|
|
|
2019-02-05 16:22:28 +00:00
|
|
|
WARN_ONCE(sort[a->id] == 0, "offset a->id %d not initialized\n", a->id);
|
|
|
|
WARN_ONCE(sort[b->id] == 0, "offset b->id %d not initialized\n", b->id);
|
|
|
|
|
2009-06-06 18:03:23 +00:00
|
|
|
if (sort[a->id] != sort[b->id])
|
|
|
|
return sort[a->id] - sort[b->id];
|
2011-01-15 13:40:50 +00:00
|
|
|
if (a->subseq != b->subseq) {
|
|
|
|
if (power_up)
|
|
|
|
return a->subseq - b->subseq;
|
|
|
|
else
|
|
|
|
return b->subseq - a->subseq;
|
|
|
|
}
|
2009-06-07 11:51:26 +00:00
|
|
|
if (a->reg != b->reg)
|
|
|
|
return a->reg - b->reg;
|
2010-11-12 15:28:42 +00:00
|
|
|
if (a->dapm != b->dapm)
|
|
|
|
return (unsigned long)a->dapm - (unsigned long)b->dapm;
|
2009-03-01 19:21:10 +00:00
|
|
|
|
2009-06-06 18:03:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-03-01 19:21:10 +00:00
|
|
|
|
2009-06-06 18:03:23 +00:00
|
|
|
/* Insert a widget in order into a DAPM power sequence. */
|
|
|
|
static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
|
|
|
|
struct list_head *list,
|
2011-01-15 13:14:30 +00:00
|
|
|
bool power_up)
|
2009-06-06 18:03:23 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
|
|
|
list_for_each_entry(w, list, power_list)
|
2011-01-15 13:14:30 +00:00
|
|
|
if (dapm_seq_compare(new_widget, w, power_up) < 0) {
|
2009-06-06 18:03:23 +00:00
|
|
|
list_add_tail(&new_widget->power_list, &w->power_list);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&new_widget->power_list, list);
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
static void dapm_seq_check_event(struct snd_soc_card *card,
|
2010-11-04 03:51:49 +00:00
|
|
|
struct snd_soc_dapm_widget *w, int event)
|
|
|
|
{
|
|
|
|
const char *ev_name;
|
2021-08-05 01:11:20 +00:00
|
|
|
int power;
|
2010-11-04 03:51:49 +00:00
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case SND_SOC_DAPM_PRE_PMU:
|
|
|
|
ev_name = "PRE_PMU";
|
|
|
|
power = 1;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_POST_PMU:
|
|
|
|
ev_name = "POST_PMU";
|
|
|
|
power = 1;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_PRE_PMD:
|
|
|
|
ev_name = "PRE_PMD";
|
|
|
|
power = 0;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_POST_PMD:
|
|
|
|
ev_name = "POST_PMD";
|
|
|
|
power = 0;
|
|
|
|
break;
|
2013-02-25 15:14:19 +00:00
|
|
|
case SND_SOC_DAPM_WILL_PMU:
|
|
|
|
ev_name = "WILL_PMU";
|
|
|
|
power = 1;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_WILL_PMD:
|
|
|
|
ev_name = "WILL_PMD";
|
|
|
|
power = 0;
|
|
|
|
break;
|
2010-11-04 03:51:49 +00:00
|
|
|
default:
|
2013-11-06 10:07:19 +00:00
|
|
|
WARN(1, "Unknown event %d\n", event);
|
2010-11-04 03:51:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:14:03 +00:00
|
|
|
if (w->new_power != power)
|
2010-11-04 03:51:49 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (w->event && (w->event_flags & event)) {
|
2021-08-05 01:11:20 +00:00
|
|
|
int ret;
|
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
|
2010-11-04 03:51:49 +00:00
|
|
|
w->name, ev_name);
|
2013-10-09 12:52:52 +00:00
|
|
|
soc_dapm_async_complete(w->dapm);
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_dapm_widget_event_start(w, event);
|
2010-11-04 03:51:49 +00:00
|
|
|
ret = w->event(w, NULL, event);
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_dapm_widget_event_done(w, event);
|
2010-11-04 03:51:49 +00:00
|
|
|
if (ret < 0)
|
2013-07-29 15:13:56 +00:00
|
|
|
dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
|
2010-11-04 03:51:49 +00:00
|
|
|
ev_name, w->name, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
/* Apply the coalesced changes from a DAPM sequence */
|
2013-07-29 15:13:56 +00:00
|
|
|
static void dapm_seq_run_coalesced(struct snd_soc_card *card,
|
2009-06-07 11:51:26 +00:00
|
|
|
struct list_head *pending)
|
2009-06-07 09:12:52 +00:00
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm;
|
2010-11-04 03:51:49 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
2013-07-29 15:14:01 +00:00
|
|
|
int reg;
|
2009-06-07 11:51:26 +00:00
|
|
|
unsigned int value = 0;
|
|
|
|
unsigned int mask = 0;
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
|
|
|
|
reg = w->reg;
|
|
|
|
dapm = w->dapm;
|
2009-06-07 11:51:26 +00:00
|
|
|
|
|
|
|
list_for_each_entry(w, pending, power_list) {
|
2014-06-16 16:13:06 +00:00
|
|
|
WARN_ON(reg != w->reg || dapm != w->dapm);
|
2013-07-29 15:14:03 +00:00
|
|
|
w->power = w->new_power;
|
2009-06-07 11:51:26 +00:00
|
|
|
|
2013-07-29 15:14:01 +00:00
|
|
|
mask |= w->mask << w->shift;
|
|
|
|
if (w->power)
|
|
|
|
value |= w->on_val << w->shift;
|
2009-06-07 11:51:26 +00:00
|
|
|
else
|
2013-07-29 15:14:01 +00:00
|
|
|
value |= w->off_val << w->shift;
|
2009-06-07 11:51:26 +00:00
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
pop_dbg(dapm->dev, card->pop_time,
|
2009-06-07 11:51:26 +00:00
|
|
|
"pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
|
|
|
|
w->name, reg, value, mask);
|
2009-06-07 12:21:24 +00:00
|
|
|
|
2010-11-04 03:51:49 +00:00
|
|
|
/* Check for events */
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
|
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
|
2009-06-07 12:21:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (reg >= 0) {
|
2011-06-19 12:49:28 +00:00
|
|
|
/* Any widget will do, they should all be updating the
|
|
|
|
* same register.
|
|
|
|
*/
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
pop_dbg(dapm->dev, card->pop_time,
|
2009-06-07 12:21:24 +00:00
|
|
|
"pop test : Applying 0x%x/0x%x to %x in %dms\n",
|
2010-11-05 18:35:21 +00:00
|
|
|
value, mask, reg, card->pop_time);
|
|
|
|
pop_wait(card->pop_time);
|
2014-06-16 16:13:06 +00:00
|
|
|
soc_dapm_update_bits(dapm, reg, mask, value);
|
2009-06-07 11:51:26 +00:00
|
|
|
}
|
|
|
|
|
2009-06-07 12:21:24 +00:00
|
|
|
list_for_each_entry(w, pending, power_list) {
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
|
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
|
2009-06-07 12:21:24 +00:00
|
|
|
}
|
2009-06-07 11:51:26 +00:00
|
|
|
}
|
2009-03-01 19:21:10 +00:00
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
/* Apply a DAPM power sequence.
|
|
|
|
*
|
|
|
|
* We walk over a pre-sorted list of widgets to apply power to. In
|
|
|
|
* order to minimise the number of writes to the device required
|
|
|
|
* multiple widgets will be updated in a single write where possible.
|
|
|
|
* Currently anything that requires more than a single write is not
|
|
|
|
* handled.
|
|
|
|
*/
|
2013-07-29 15:13:56 +00:00
|
|
|
static void dapm_seq_run(struct snd_soc_card *card,
|
|
|
|
struct list_head *list, int event, bool power_up)
|
2009-06-07 11:51:26 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w, *n;
|
2013-10-09 12:52:52 +00:00
|
|
|
struct snd_soc_dapm_context *d;
|
2009-06-07 11:51:26 +00:00
|
|
|
LIST_HEAD(pending);
|
|
|
|
int cur_sort = -1;
|
2011-01-15 13:40:50 +00:00
|
|
|
int cur_subseq = -1;
|
2009-06-07 11:51:26 +00:00
|
|
|
int cur_reg = SND_SOC_NOPM;
|
2010-12-14 10:18:32 +00:00
|
|
|
struct snd_soc_dapm_context *cur_dapm = NULL;
|
2021-08-05 01:11:24 +00:00
|
|
|
int i;
|
2011-01-15 13:14:30 +00:00
|
|
|
int *sort;
|
|
|
|
|
|
|
|
if (power_up)
|
|
|
|
sort = dapm_up_seq;
|
|
|
|
else
|
|
|
|
sort = dapm_down_seq;
|
2009-06-07 09:12:52 +00:00
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
list_for_each_entry_safe(w, n, list, power_list) {
|
2021-08-05 01:11:24 +00:00
|
|
|
int ret = 0;
|
2009-06-07 11:51:26 +00:00
|
|
|
|
|
|
|
/* Do we need to apply any queued changes? */
|
2010-12-14 10:18:32 +00:00
|
|
|
if (sort[w->id] != cur_sort || w->reg != cur_reg ||
|
2011-01-15 13:40:50 +00:00
|
|
|
w->dapm != cur_dapm || w->subseq != cur_subseq) {
|
2009-06-07 11:51:26 +00:00
|
|
|
if (!list_empty(&pending))
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_run_coalesced(card, &pending);
|
2009-06-07 11:51:26 +00:00
|
|
|
|
2019-07-26 04:51:35 +00:00
|
|
|
if (cur_dapm && cur_dapm->component) {
|
2011-01-18 16:14:44 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
|
|
|
|
if (sort[i] == cur_sort)
|
2019-07-26 04:51:35 +00:00
|
|
|
snd_soc_component_seq_notifier(
|
|
|
|
cur_dapm->component,
|
|
|
|
i, cur_subseq);
|
2011-01-18 16:14:44 +00:00
|
|
|
}
|
|
|
|
|
2013-10-09 12:52:52 +00:00
|
|
|
if (cur_dapm && w->dapm != cur_dapm)
|
|
|
|
soc_dapm_async_complete(cur_dapm);
|
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
INIT_LIST_HEAD(&pending);
|
|
|
|
cur_sort = -1;
|
2011-07-16 01:55:08 +00:00
|
|
|
cur_subseq = INT_MIN;
|
2009-06-07 11:51:26 +00:00
|
|
|
cur_reg = SND_SOC_NOPM;
|
2010-12-14 10:18:32 +00:00
|
|
|
cur_dapm = NULL;
|
2009-06-07 11:51:26 +00:00
|
|
|
}
|
|
|
|
|
2009-06-07 09:12:52 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_pre:
|
|
|
|
if (!w->event)
|
2022-03-29 01:21:34 +00:00
|
|
|
continue;
|
2009-06-07 09:12:52 +00:00
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
if (event == SND_SOC_DAPM_STREAM_START)
|
2009-06-07 09:12:52 +00:00
|
|
|
ret = w->event(w,
|
|
|
|
NULL, SND_SOC_DAPM_PRE_PMU);
|
2009-06-07 11:51:26 +00:00
|
|
|
else if (event == SND_SOC_DAPM_STREAM_STOP)
|
2009-06-07 09:12:52 +00:00
|
|
|
ret = w->event(w,
|
|
|
|
NULL, SND_SOC_DAPM_PRE_PMD);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case snd_soc_dapm_post:
|
|
|
|
if (!w->event)
|
2022-03-29 01:21:34 +00:00
|
|
|
continue;
|
2009-06-07 09:12:52 +00:00
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
if (event == SND_SOC_DAPM_STREAM_START)
|
2009-06-07 09:12:52 +00:00
|
|
|
ret = w->event(w,
|
|
|
|
NULL, SND_SOC_DAPM_POST_PMU);
|
2009-06-07 11:51:26 +00:00
|
|
|
else if (event == SND_SOC_DAPM_STREAM_STOP)
|
2009-06-07 09:12:52 +00:00
|
|
|
ret = w->event(w,
|
|
|
|
NULL, SND_SOC_DAPM_POST_PMD);
|
|
|
|
break;
|
|
|
|
|
2009-06-07 11:51:26 +00:00
|
|
|
default:
|
2009-06-07 12:21:24 +00:00
|
|
|
/* Queue it up for application */
|
|
|
|
cur_sort = sort[w->id];
|
2011-01-15 13:40:50 +00:00
|
|
|
cur_subseq = w->subseq;
|
2009-06-07 12:21:24 +00:00
|
|
|
cur_reg = w->reg;
|
2010-12-14 10:18:32 +00:00
|
|
|
cur_dapm = w->dapm;
|
2009-06-07 12:21:24 +00:00
|
|
|
list_move(&w->power_list, &pending);
|
|
|
|
break;
|
2009-06-07 09:12:52 +00:00
|
|
|
}
|
2009-06-07 11:51:26 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2010-11-09 12:40:27 +00:00
|
|
|
dev_err(w->dapm->dev,
|
2012-11-19 14:39:12 +00:00
|
|
|
"ASoC: Failed to apply widget power: %d\n", ret);
|
2009-04-20 16:15:41 +00:00
|
|
|
}
|
2009-06-07 11:51:26 +00:00
|
|
|
|
|
|
|
if (!list_empty(&pending))
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_run_coalesced(card, &pending);
|
2011-01-18 16:14:44 +00:00
|
|
|
|
2019-07-26 04:51:35 +00:00
|
|
|
if (cur_dapm && cur_dapm->component) {
|
2011-01-18 16:14:44 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
|
|
|
|
if (sort[i] == cur_sort)
|
2019-07-26 04:51:35 +00:00
|
|
|
snd_soc_component_seq_notifier(
|
|
|
|
cur_dapm->component,
|
|
|
|
i, cur_subseq);
|
2011-01-18 16:14:44 +00:00
|
|
|
}
|
2013-10-09 12:52:52 +00:00
|
|
|
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d)
|
2013-10-09 12:52:52 +00:00
|
|
|
soc_dapm_async_complete(d);
|
2009-03-01 19:21:10 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
static void dapm_widget_update(struct snd_soc_card *card)
|
2010-12-14 16:13:57 +00:00
|
|
|
{
|
2013-07-29 15:13:56 +00:00
|
|
|
struct snd_soc_dapm_update *update = card->update;
|
2013-07-24 13:27:37 +00:00
|
|
|
struct snd_soc_dapm_widget_list *wlist;
|
|
|
|
struct snd_soc_dapm_widget *w = NULL;
|
|
|
|
unsigned int wi;
|
2010-12-14 16:13:57 +00:00
|
|
|
int ret;
|
|
|
|
|
2013-08-05 09:27:31 +00:00
|
|
|
if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
|
2010-12-14 16:13:57 +00:00
|
|
|
return;
|
|
|
|
|
2013-07-29 15:13:58 +00:00
|
|
|
wlist = dapm_kcontrol_get_wlist(update->kcontrol);
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2020-02-10 03:14:22 +00:00
|
|
|
for_each_dapm_widgets(wlist, wi, w) {
|
2013-07-24 13:27:37 +00:00
|
|
|
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)
|
2013-07-29 15:13:56 +00:00
|
|
|
dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
|
2013-07-24 13:27:37 +00:00
|
|
|
w->name, ret);
|
|
|
|
}
|
2010-12-14 16:13:57 +00:00
|
|
|
}
|
|
|
|
|
2013-07-24 13:27:37 +00:00
|
|
|
if (!w)
|
|
|
|
return;
|
|
|
|
|
2014-06-16 16:13:06 +00:00
|
|
|
ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
|
|
|
|
update->val);
|
2010-12-14 16:13:57 +00:00
|
|
|
if (ret < 0)
|
2013-07-29 15:13:56 +00:00
|
|
|
dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
|
2012-11-19 14:39:12 +00:00
|
|
|
w->name, ret);
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2016-11-02 07:35:58 +00:00
|
|
|
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,
|
|
|
|
"ASoC: %s DAPM update failed: %d\n",
|
|
|
|
w->name, ret);
|
|
|
|
}
|
|
|
|
|
2020-02-10 03:14:22 +00:00
|
|
|
for_each_dapm_widgets(wlist, wi, w) {
|
2013-07-24 13:27:37 +00:00
|
|
|
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)
|
2013-07-29 15:13:56 +00:00
|
|
|
dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
|
2013-07-24 13:27:37 +00:00
|
|
|
w->name, ret);
|
|
|
|
}
|
2010-12-14 16:13:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-18 19:49:43 +00:00
|
|
|
/* Async callback run prior to DAPM sequences - brings to _PREPARE if
|
|
|
|
* they're changing state.
|
|
|
|
*/
|
|
|
|
static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_context *d = data;
|
|
|
|
int ret;
|
|
|
|
|
2016-08-16 14:56:17 +00:00
|
|
|
/* If we're off and we're not supposed to go into STANDBY */
|
2011-06-04 10:25:10 +00:00
|
|
|
if (d->bias_level == SND_SOC_BIAS_OFF &&
|
|
|
|
d->target_bias_level != SND_SOC_BIAS_OFF) {
|
2020-07-24 07:07:31 +00:00
|
|
|
if (d->dev && cookie)
|
2011-12-05 15:17:06 +00:00
|
|
|
pm_runtime_get_sync(d->dev);
|
|
|
|
|
2011-02-18 19:49:43 +00:00
|
|
|
ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
|
|
|
|
if (ret != 0)
|
|
|
|
dev_err(d->dev,
|
2012-11-19 14:39:12 +00:00
|
|
|
"ASoC: Failed to turn on bias: %d\n", ret);
|
2011-02-18 19:49:43 +00:00
|
|
|
}
|
|
|
|
|
2014-05-06 08:32:15 +00:00
|
|
|
/* Prepare for a transition to ON or away from ON */
|
|
|
|
if ((d->target_bias_level == SND_SOC_BIAS_ON &&
|
|
|
|
d->bias_level != SND_SOC_BIAS_ON) ||
|
|
|
|
(d->target_bias_level != SND_SOC_BIAS_ON &&
|
|
|
|
d->bias_level == SND_SOC_BIAS_ON)) {
|
2011-02-18 19:49:43 +00:00
|
|
|
ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
|
|
|
|
if (ret != 0)
|
|
|
|
dev_err(d->dev,
|
2012-11-19 14:39:12 +00:00
|
|
|
"ASoC: Failed to prepare bias: %d\n", ret);
|
2011-02-18 19:49:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Async callback run prior to DAPM sequences - brings to their final
|
|
|
|
* state.
|
|
|
|
*/
|
|
|
|
static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_context *d = data;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* If we just powered the last thing off drop to standby bias */
|
2011-06-04 10:25:10 +00:00
|
|
|
if (d->bias_level == SND_SOC_BIAS_PREPARE &&
|
|
|
|
(d->target_bias_level == SND_SOC_BIAS_STANDBY ||
|
|
|
|
d->target_bias_level == SND_SOC_BIAS_OFF)) {
|
2011-02-18 19:49:43 +00:00
|
|
|
ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
|
|
|
|
if (ret != 0)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
|
2011-02-18 19:49:43 +00:00
|
|
|
ret);
|
|
|
|
}
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2011-02-18 19:49:43 +00:00
|
|
|
/* If we're in standby and can support bias off then do that */
|
2011-06-04 10:25:10 +00:00
|
|
|
if (d->bias_level == SND_SOC_BIAS_STANDBY &&
|
|
|
|
d->target_bias_level == SND_SOC_BIAS_OFF) {
|
2011-02-18 19:49:43 +00:00
|
|
|
ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
|
|
|
|
if (ret != 0)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
|
|
|
|
ret);
|
2011-12-05 15:17:06 +00:00
|
|
|
|
2020-07-24 07:07:31 +00:00
|
|
|
if (d->dev && cookie)
|
2012-01-25 19:53:58 +00:00
|
|
|
pm_runtime_put(d->dev);
|
2011-02-18 19:49:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we just powered up then move to active bias */
|
2011-06-04 10:25:10 +00:00
|
|
|
if (d->bias_level == SND_SOC_BIAS_PREPARE &&
|
|
|
|
d->target_bias_level == SND_SOC_BIAS_ON) {
|
2011-02-18 19:49:43 +00:00
|
|
|
ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
|
|
|
|
if (ret != 0)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
|
2011-02-18 19:49:43 +00:00
|
|
|
ret);
|
|
|
|
}
|
|
|
|
}
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2011-10-03 21:36:57 +00:00
|
|
|
static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
|
|
|
|
bool power, bool connect)
|
|
|
|
{
|
|
|
|
/* If a connection is being made or broken then that update
|
|
|
|
* will have marked the peer dirty, otherwise the widgets are
|
|
|
|
* not connected and this update has no impact. */
|
|
|
|
if (!connect)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* If the peer is already in the state we're moving to then we
|
|
|
|
* won't have an impact on it. */
|
|
|
|
if (power != peer->power)
|
2011-10-04 21:28:08 +00:00
|
|
|
dapm_mark_dirty(peer, "peer state change");
|
2011-10-03 21:36:57 +00:00
|
|
|
}
|
|
|
|
|
ASoC: soc-dapm.c: merge dapm_power_one_widget() and dapm_widget_set_power()
dapm_widget_set_power() (= X) is called only from
dapm_power_one_widget() (= Y), and total purpose of these functions are
calling dapm_seq_insert() (= a) accordingly for each widget.
(X) static void dapm_widget_set_power(...)
{
...
if (power)
(a) dapm_seq_insert(w, up_list, true);
else
(a) dapm_seq_insert(w, down_list, false);
}
(Y) static void dapm_power_one_widget(...)
{
..
switch (w->id) {
case snd_soc_dapm_pre:
(a) dapm_seq_insert(w, down_list, false);
break;
case snd_soc_dapm_post:
(a) dapm_seq_insert(w, up_list, true);
break;
default:
power = dapm_widget_power_check(w);
(X) dapm_widget_set_power(w, power, up_list, down_list);
break;
}
}
It should be more simple, but the code is unnecessarily complicated,
and difficult to read/understand. This patch merge these into one.
Link: https://lore.kernel.org/all/87tu42owdd.wl-kuninori.morimoto.gx@renesas.com/
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Amadeusz Sławiński <amadeuszx.slawinski@linux.intel.com>
Link: https://lore.kernel.org/r/8735bktzrx.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-19 00:36:51 +00:00
|
|
|
static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
|
2011-09-28 16:02:31 +00:00
|
|
|
struct list_head *up_list,
|
|
|
|
struct list_head *down_list)
|
|
|
|
{
|
2011-10-03 20:06:40 +00:00
|
|
|
struct snd_soc_dapm_path *path;
|
ASoC: soc-dapm.c: merge dapm_power_one_widget() and dapm_widget_set_power()
dapm_widget_set_power() (= X) is called only from
dapm_power_one_widget() (= Y), and total purpose of these functions are
calling dapm_seq_insert() (= a) accordingly for each widget.
(X) static void dapm_widget_set_power(...)
{
...
if (power)
(a) dapm_seq_insert(w, up_list, true);
else
(a) dapm_seq_insert(w, down_list, false);
}
(Y) static void dapm_power_one_widget(...)
{
..
switch (w->id) {
case snd_soc_dapm_pre:
(a) dapm_seq_insert(w, down_list, false);
break;
case snd_soc_dapm_post:
(a) dapm_seq_insert(w, up_list, true);
break;
default:
power = dapm_widget_power_check(w);
(X) dapm_widget_set_power(w, power, up_list, down_list);
break;
}
}
It should be more simple, but the code is unnecessarily complicated,
and difficult to read/understand. This patch merge these into one.
Link: https://lore.kernel.org/all/87tu42owdd.wl-kuninori.morimoto.gx@renesas.com/
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Amadeusz Sławiński <amadeuszx.slawinski@linux.intel.com>
Link: https://lore.kernel.org/r/8735bktzrx.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-19 00:36:51 +00:00
|
|
|
int power;
|
|
|
|
|
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_pre:
|
|
|
|
power = 0;
|
|
|
|
goto end;
|
|
|
|
case snd_soc_dapm_post:
|
|
|
|
power = 1;
|
|
|
|
goto end;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
power = dapm_widget_power_check(w);
|
2011-10-03 20:06:40 +00:00
|
|
|
|
2011-09-28 16:02:31 +00:00
|
|
|
if (w->power == power)
|
|
|
|
return;
|
|
|
|
|
|
|
|
trace_snd_soc_dapm_widget_power(w, power);
|
|
|
|
|
2022-10-17 23:36:56 +00:00
|
|
|
/*
|
|
|
|
* If we changed our power state perhaps our neigbours
|
|
|
|
* changed also.
|
2011-10-03 20:06:40 +00:00
|
|
|
*/
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path)
|
2014-10-20 17:36:34 +00:00
|
|
|
dapm_widget_set_peer_power(path->source, power, path->connect);
|
|
|
|
|
2022-10-17 23:36:56 +00:00
|
|
|
/*
|
|
|
|
* Supplies can't affect their outputs, only their inputs
|
|
|
|
*/
|
|
|
|
if (!w->is_supply)
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path)
|
2022-10-17 23:36:56 +00:00
|
|
|
dapm_widget_set_peer_power(path->sink, power, path->connect);
|
2011-10-03 20:06:40 +00:00
|
|
|
|
ASoC: soc-dapm.c: merge dapm_power_one_widget() and dapm_widget_set_power()
dapm_widget_set_power() (= X) is called only from
dapm_power_one_widget() (= Y), and total purpose of these functions are
calling dapm_seq_insert() (= a) accordingly for each widget.
(X) static void dapm_widget_set_power(...)
{
...
if (power)
(a) dapm_seq_insert(w, up_list, true);
else
(a) dapm_seq_insert(w, down_list, false);
}
(Y) static void dapm_power_one_widget(...)
{
..
switch (w->id) {
case snd_soc_dapm_pre:
(a) dapm_seq_insert(w, down_list, false);
break;
case snd_soc_dapm_post:
(a) dapm_seq_insert(w, up_list, true);
break;
default:
power = dapm_widget_power_check(w);
(X) dapm_widget_set_power(w, power, up_list, down_list);
break;
}
}
It should be more simple, but the code is unnecessarily complicated,
and difficult to read/understand. This patch merge these into one.
Link: https://lore.kernel.org/all/87tu42owdd.wl-kuninori.morimoto.gx@renesas.com/
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Amadeusz Sławiński <amadeuszx.slawinski@linux.intel.com>
Link: https://lore.kernel.org/r/8735bktzrx.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-19 00:36:51 +00:00
|
|
|
end:
|
2011-09-28 16:02:31 +00:00
|
|
|
if (power)
|
|
|
|
dapm_seq_insert(w, up_list, true);
|
|
|
|
else
|
|
|
|
dapm_seq_insert(w, down_list, false);
|
|
|
|
}
|
|
|
|
|
2014-09-04 17:44:06 +00:00
|
|
|
static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
if (dapm->idle_bias_off)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
switch (snd_power_get_state(dapm->card->snd_card)) {
|
|
|
|
case SNDRV_CTL_POWER_D3hot:
|
|
|
|
case SNDRV_CTL_POWER_D3cold:
|
|
|
|
return dapm->suspend_bias_off;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/*
|
|
|
|
* Scan each dapm widget for complete audio path.
|
|
|
|
* A complete path is a route that has valid endpoints i.e.:-
|
|
|
|
*
|
|
|
|
* o DAC to output pin.
|
2016-08-16 14:56:17 +00:00
|
|
|
* o Input pin to ADC.
|
2006-10-06 16:32:18 +00:00
|
|
|
* o Input pin to Output pin (bypass, sidetone)
|
|
|
|
* o DAC to ADC (loopback).
|
|
|
|
*/
|
2013-07-29 15:13:56 +00:00
|
|
|
static int dapm_power_widgets(struct snd_soc_card *card, int event)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
2010-12-14 10:18:32 +00:00
|
|
|
struct snd_soc_dapm_context *d;
|
2009-06-07 12:57:17 +00:00
|
|
|
LIST_HEAD(up_list);
|
|
|
|
LIST_HEAD(down_list);
|
2012-07-10 02:33:25 +00:00
|
|
|
ASYNC_DOMAIN_EXCLUSIVE(async_domain);
|
2011-06-04 10:25:10 +00:00
|
|
|
enum snd_soc_bias_level bias;
|
2019-07-26 04:51:39 +00:00
|
|
|
int ret;
|
2009-05-16 16:47:29 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_assert_held(card);
|
2014-03-06 08:49:11 +00:00
|
|
|
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_dapm_start(card);
|
|
|
|
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d) {
|
2014-09-04 17:44:06 +00:00
|
|
|
if (dapm_idle_bias_off(d))
|
2012-03-08 15:06:09 +00:00
|
|
|
d->target_bias_level = SND_SOC_BIAS_OFF;
|
|
|
|
else
|
|
|
|
d->target_bias_level = SND_SOC_BIAS_STANDBY;
|
2011-06-04 10:25:10 +00:00
|
|
|
}
|
2010-12-14 10:18:32 +00:00
|
|
|
|
2012-02-15 15:15:34 +00:00
|
|
|
dapm_reset(card);
|
2011-10-04 21:15:59 +00:00
|
|
|
|
2009-05-16 16:47:29 +00:00
|
|
|
/* Check which widgets we need to power and store them in
|
2011-10-03 20:06:40 +00:00
|
|
|
* lists indicating if they should be powered up or down. We
|
|
|
|
* only check widgets that have been flagged as dirty but note
|
|
|
|
* that new widgets may be added to the dirty list while we
|
|
|
|
* iterate.
|
2009-05-16 16:47:29 +00:00
|
|
|
*/
|
2011-10-03 20:06:40 +00:00
|
|
|
list_for_each_entry(w, &card->dapm_dirty, dirty) {
|
2011-09-20 21:22:32 +00:00
|
|
|
dapm_power_one_widget(w, &up_list, &down_list);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, w) {
|
2012-07-20 16:29:34 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_pre:
|
|
|
|
case snd_soc_dapm_post:
|
|
|
|
/* These widgets always need to be powered */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
list_del_init(&w->dirty);
|
|
|
|
break;
|
|
|
|
}
|
2011-10-03 20:06:40 +00:00
|
|
|
|
2013-07-29 15:14:03 +00:00
|
|
|
if (w->new_power) {
|
2011-09-28 16:19:47 +00:00
|
|
|
d = w->dapm;
|
|
|
|
|
|
|
|
/* Supplies and micbiases only bring the
|
|
|
|
* context up to STANDBY as unless something
|
|
|
|
* else is active and passing audio they
|
2012-01-25 19:55:22 +00:00
|
|
|
* generally don't require full power. Signal
|
|
|
|
* generators are virtual pins and have no
|
|
|
|
* power impact themselves.
|
2011-09-28 16:19:47 +00:00
|
|
|
*/
|
|
|
|
switch (w->id) {
|
2012-01-25 19:55:22 +00:00
|
|
|
case snd_soc_dapm_siggen:
|
2013-10-05 17:26:17 +00:00
|
|
|
case snd_soc_dapm_vmid:
|
2012-01-25 19:55:22 +00:00
|
|
|
break;
|
2011-09-28 16:19:47 +00:00
|
|
|
case snd_soc_dapm_supply:
|
2012-01-21 21:14:48 +00:00
|
|
|
case snd_soc_dapm_regulator_supply:
|
2018-03-10 02:37:27 +00:00
|
|
|
case snd_soc_dapm_pinctrl:
|
2012-05-24 13:26:25 +00:00
|
|
|
case snd_soc_dapm_clock_supply:
|
2011-09-28 16:19:47 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-09-21 20:29:47 +00:00
|
|
|
/* Force all contexts in the card to the same bias state if
|
|
|
|
* they're not ground referenced.
|
|
|
|
*/
|
2011-06-04 10:25:10 +00:00
|
|
|
bias = SND_SOC_BIAS_OFF;
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d)
|
2011-06-04 10:25:10 +00:00
|
|
|
if (d->target_bias_level > bias)
|
|
|
|
bias = d->target_bias_level;
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d)
|
2014-09-04 17:44:06 +00:00
|
|
|
if (!dapm_idle_bias_off(d))
|
2011-09-21 20:29:47 +00:00
|
|
|
d->target_bias_level = bias;
|
2011-04-04 12:05:11 +00:00
|
|
|
|
2011-09-20 20:43:24 +00:00
|
|
|
trace_snd_soc_dapm_walk_done(card);
|
2011-04-04 12:05:11 +00:00
|
|
|
|
2014-03-01 16:04:03 +00:00
|
|
|
/* Run card bias changes at first */
|
|
|
|
dapm_pre_sequence_async(&card->dapm, 0);
|
|
|
|
/* Run other bias changes in parallel */
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d) {
|
ASoC: core: Don't schedule DAPM work if already in target state
When dapm_power_widgets() is called, the dapm_pre_sequence_async() and
dapm_post_sequence_async() functions are scheduled for all DAPM contexts
(apart from the card DAPM context) regardless of whether the DAPM
context is already in the desired state. The overhead of this is not
insignificant and the more DAPM contexts there are the more overhead
there is.
For example, on the Tegra124 Jetson TK1, when profiling the time taken
to execute the dapm_power_widgets() the following times were observed.
Times for function dapm_power_widgets() are (us):
Min 23, Ave 190, Max 434, Count 39
Here 'Count' is the number of times that dapm_power_widgets() has been
called. Please note that the above time were measured using ktime_get()
to log the time on entry and exit from dapm_power_widgets(). So it
should be noted that these times may not be purely the time take to
execute this function if it is preempted. However, after applying this
patch and measuring the time taken to execute dapm_power_widgets() again
a significant improvement is seen as shown below.
Times for function dapm_power_widgets() are (us):
Min 4, Ave 16, Max 82, Count 39
Therefore, optimise the dapm_power_widgets() function by only scheduling
the dapm_pre/post_sequence_async() work if the DAPM context is not in
the desired state.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-08-17 15:35:43 +00:00
|
|
|
if (d != &card->dapm && d->bias_level != d->target_bias_level)
|
2014-03-01 16:04:03 +00:00
|
|
|
async_schedule_domain(dapm_pre_sequence_async, d,
|
|
|
|
&async_domain);
|
|
|
|
}
|
2011-02-18 19:49:43 +00:00
|
|
|
async_synchronize_full_domain(&async_domain);
|
2009-05-17 20:41:23 +00:00
|
|
|
|
2013-05-22 22:12:53 +00:00
|
|
|
list_for_each_entry(w, &down_list, power_list) {
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
|
2013-02-25 15:14:19 +00:00
|
|
|
}
|
|
|
|
|
2013-05-22 22:12:53 +00:00
|
|
|
list_for_each_entry(w, &up_list, power_list) {
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
|
2013-02-25 15:14:19 +00:00
|
|
|
}
|
|
|
|
|
2009-05-16 16:47:29 +00:00
|
|
|
/* Power down widgets first; try to avoid amplifying pops. */
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_run(card, &down_list, event, false);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_widget_update(card);
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2009-05-16 16:47:29 +00:00
|
|
|
/* Now power up. */
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_run(card, &up_list, event, true);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2011-02-18 19:49:43 +00:00
|
|
|
/* Run all the bias changes in parallel */
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d) {
|
ASoC: core: Don't schedule DAPM work if already in target state
When dapm_power_widgets() is called, the dapm_pre_sequence_async() and
dapm_post_sequence_async() functions are scheduled for all DAPM contexts
(apart from the card DAPM context) regardless of whether the DAPM
context is already in the desired state. The overhead of this is not
insignificant and the more DAPM contexts there are the more overhead
there is.
For example, on the Tegra124 Jetson TK1, when profiling the time taken
to execute the dapm_power_widgets() the following times were observed.
Times for function dapm_power_widgets() are (us):
Min 23, Ave 190, Max 434, Count 39
Here 'Count' is the number of times that dapm_power_widgets() has been
called. Please note that the above time were measured using ktime_get()
to log the time on entry and exit from dapm_power_widgets(). So it
should be noted that these times may not be purely the time take to
execute this function if it is preempted. However, after applying this
patch and measuring the time taken to execute dapm_power_widgets() again
a significant improvement is seen as shown below.
Times for function dapm_power_widgets() are (us):
Min 4, Ave 16, Max 82, Count 39
Therefore, optimise the dapm_power_widgets() function by only scheduling
the dapm_pre/post_sequence_async() work if the DAPM context is not in
the desired state.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-08-17 15:35:43 +00:00
|
|
|
if (d != &card->dapm && d->bias_level != d->target_bias_level)
|
2014-03-01 16:04:03 +00:00
|
|
|
async_schedule_domain(dapm_post_sequence_async, d,
|
|
|
|
&async_domain);
|
|
|
|
}
|
2011-02-18 19:49:43 +00:00
|
|
|
async_synchronize_full_domain(&async_domain);
|
2014-03-01 16:04:03 +00:00
|
|
|
/* Run card bias changes at last */
|
|
|
|
dapm_post_sequence_async(&card->dapm, 0);
|
2009-05-17 20:41:23 +00:00
|
|
|
|
2012-02-15 15:15:35 +00:00
|
|
|
/* do we need to notify any clients that DAPM event is complete */
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, d) {
|
2019-07-26 04:51:39 +00:00
|
|
|
if (!d->component)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = snd_soc_component_stream_event(d->component, event);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-02-15 15:15:35 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
pop_dbg(card->dev, card->pop_time,
|
2010-11-09 12:40:28 +00:00
|
|
|
"DAPM sequencing finished, waiting %dms\n", card->pop_time);
|
2010-11-05 18:35:21 +00:00
|
|
|
pop_wait(card->pop_time);
|
2009-07-08 17:54:57 +00:00
|
|
|
|
2010-11-04 04:07:02 +00:00
|
|
|
trace_snd_soc_dapm_done(card);
|
|
|
|
|
2009-03-01 19:21:10 +00:00
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2009-08-21 15:38:13 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
static ssize_t dapm_widget_power_read_file(struct file *file,
|
|
|
|
char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w = file->private_data;
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir, rdir;
|
2009-08-21 15:38:13 +00:00
|
|
|
char *buf;
|
|
|
|
int in, out;
|
|
|
|
ssize_t ret;
|
|
|
|
struct snd_soc_dapm_path *p = NULL;
|
|
|
|
|
|
|
|
buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(w->dapm);
|
2015-07-06 15:01:24 +00:00
|
|
|
|
2014-10-25 15:42:00 +00:00
|
|
|
/* Supply widgets are not handled by is_connected_{input,output}_ep() */
|
|
|
|
if (w->is_supply) {
|
|
|
|
in = 0;
|
|
|
|
out = 0;
|
|
|
|
} else {
|
2016-05-13 16:03:55 +00:00
|
|
|
in = is_connected_input_ep(w, NULL, NULL);
|
|
|
|
out = is_connected_output_ep(w, NULL, NULL);
|
2014-10-25 15:42:00 +00:00
|
|
|
}
|
2009-08-21 15:38:13 +00:00
|
|
|
|
ASoC: dapm: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-12 15:28:43 +00:00
|
|
|
ret = scnprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
|
2012-03-03 18:01:01 +00:00
|
|
|
w->name, w->power ? "On" : "Off",
|
|
|
|
w->force ? " (forced)" : "", in, out);
|
2009-08-21 15:38:13 +00:00
|
|
|
|
2009-12-04 15:25:56 +00:00
|
|
|
if (w->reg >= 0)
|
ASoC: dapm: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-12 15:28:43 +00:00
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret,
|
2013-07-29 15:14:01 +00:00
|
|
|
" - R%d(0x%x) mask 0x%x",
|
|
|
|
w->reg, w->reg, w->mask << w->shift);
|
2009-12-04 15:25:56 +00:00
|
|
|
|
ASoC: dapm: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-12 15:28:43 +00:00
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
|
2009-12-04 15:25:56 +00:00
|
|
|
|
2009-09-14 15:49:00 +00:00
|
|
|
if (w->sname)
|
ASoC: dapm: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-12 15:28:43 +00:00
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
|
2009-09-14 15:49:00 +00:00
|
|
|
w->sname,
|
|
|
|
w->active ? "active" : "inactive");
|
2009-08-21 15:38:13 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_for_each_direction(dir) {
|
|
|
|
rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
|
|
|
|
snd_soc_dapm_widget_for_each_path(w, dir, p) {
|
2018-02-05 05:00:00 +00:00
|
|
|
if (p->connected && !p->connected(p->source, p->sink))
|
2015-08-11 19:38:00 +00:00
|
|
|
continue;
|
2009-09-08 17:59:05 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if (!p->connect)
|
|
|
|
continue;
|
2009-09-08 17:59:05 +00:00
|
|
|
|
ASoC: dapm: change snprintf to scnprintf for possible overflow
Change snprintf to scnprintf. There are generally two cases where using
snprintf causes problems.
1) Uses of size += snprintf(buf, SIZE - size, fmt, ...)
In this case, if snprintf would have written more characters than what the
buffer size (SIZE) is, then size will end up larger than SIZE. In later
uses of snprintf, SIZE - size will result in a negative number, leading
to problems. Note that size might already be too large by using
size = snprintf before the code reaches a case of size += snprintf.
2) If size is ultimately used as a length parameter for a copy back to user
space, then it will potentially allow for a buffer overflow and information
disclosure when size is greater than SIZE. When the size is used to index
the buffer directly, we can have memory corruption. This also means when
size = snprintf... is used, it may also cause problems since size may become
large. Copying to userspace is mitigated by the HARDENED_USERCOPY kernel
configuration.
The solution to these issues is to use scnprintf which returns the number of
characters actually written to the buffer, so the size variable will never
exceed SIZE.
Signed-off-by: Silvio Cesare <silvio.cesare@gmail.com>
Cc: Liam Girdwood <lgirdwood@gmail.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-12 15:28:43 +00:00
|
|
|
ret += scnprintf(buf + ret, PAGE_SIZE - ret,
|
2015-08-11 19:38:00 +00:00
|
|
|
" %s \"%s\" \"%s\"\n",
|
|
|
|
(rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
|
2009-08-21 15:38:13 +00:00
|
|
|
p->name ? p->name : "static",
|
2015-08-11 19:38:00 +00:00
|
|
|
p->node[rdir]->name);
|
|
|
|
}
|
2009-08-21 15:38:13 +00:00
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(w->dapm);
|
2015-07-06 15:01:24 +00:00
|
|
|
|
2009-08-21 15:38:13 +00:00
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations dapm_widget_power_fops = {
|
2012-04-05 21:25:11 +00:00
|
|
|
.open = simple_open,
|
2009-08-21 15:38:13 +00:00
|
|
|
.read = dapm_widget_power_read_file,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = default_llseek,
|
2009-08-21 15:38:13 +00:00
|
|
|
};
|
|
|
|
|
2011-04-04 11:48:13 +00:00
|
|
|
static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_context *dapm = file->private_data;
|
|
|
|
char *level;
|
|
|
|
|
|
|
|
switch (dapm->bias_level) {
|
|
|
|
case SND_SOC_BIAS_ON:
|
|
|
|
level = "On\n";
|
|
|
|
break;
|
|
|
|
case SND_SOC_BIAS_PREPARE:
|
|
|
|
level = "Prepare\n";
|
|
|
|
break;
|
|
|
|
case SND_SOC_BIAS_STANDBY:
|
|
|
|
level = "Standby\n";
|
|
|
|
break;
|
|
|
|
case SND_SOC_BIAS_OFF:
|
|
|
|
level = "Off\n";
|
|
|
|
break;
|
|
|
|
default:
|
2013-11-06 10:07:19 +00:00
|
|
|
WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
|
2011-04-04 11:48:13 +00:00
|
|
|
level = "Unknown\n";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return simple_read_from_buffer(user_buf, count, ppos, level,
|
|
|
|
strlen(level));
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations dapm_bias_fops = {
|
2012-04-05 21:25:11 +00:00
|
|
|
.open = simple_open,
|
2011-04-04 11:48:13 +00:00
|
|
|
.read = dapm_bias_read_file,
|
|
|
|
.llseek = default_llseek,
|
|
|
|
};
|
|
|
|
|
2011-04-30 17:45:48 +00:00
|
|
|
void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct dentry *parent)
|
2009-08-21 15:38:13 +00:00
|
|
|
{
|
2019-06-21 11:33:57 +00:00
|
|
|
if (!parent || IS_ERR(parent))
|
2015-04-09 08:52:38 +00:00
|
|
|
return;
|
|
|
|
|
2011-04-30 17:45:48 +00:00
|
|
|
dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
|
|
|
|
|
2019-07-31 13:17:15 +00:00
|
|
|
debugfs_create_file("bias_level", 0444, dapm->debugfs_dapm, dapm,
|
|
|
|
&dapm_bias_fops);
|
2011-04-30 17:45:49 +00:00
|
|
|
}
|
2011-04-04 11:48:13 +00:00
|
|
|
|
2011-04-30 17:45:49 +00:00
|
|
|
static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
2009-08-21 15:38:13 +00:00
|
|
|
|
2011-04-30 17:45:49 +00:00
|
|
|
if (!dapm->debugfs_dapm || !w->name)
|
|
|
|
return;
|
|
|
|
|
2019-07-31 13:17:15 +00:00
|
|
|
debugfs_create_file(w->name, 0444, dapm->debugfs_dapm, w,
|
|
|
|
&dapm_widget_power_fops);
|
2009-08-21 15:38:13 +00:00
|
|
|
}
|
2011-04-30 17:45:49 +00:00
|
|
|
|
2011-04-30 17:45:50 +00:00
|
|
|
static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(dapm->debugfs_dapm);
|
2019-05-27 07:51:34 +00:00
|
|
|
dapm->debugfs_dapm = NULL;
|
2011-04-30 17:45:50 +00:00
|
|
|
}
|
|
|
|
|
2009-08-21 15:38:13 +00:00
|
|
|
#else
|
2011-04-30 17:45:48 +00:00
|
|
|
void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct dentry *parent)
|
2009-08-21 15:38:13 +00:00
|
|
|
{
|
|
|
|
}
|
2011-04-30 17:45:49 +00:00
|
|
|
|
|
|
|
static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-04-30 17:45:50 +00:00
|
|
|
static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-08-21 15:38:13 +00:00
|
|
|
#endif
|
|
|
|
|
2014-10-25 15:41:56 +00:00
|
|
|
/*
|
|
|
|
* soc_dapm_connect_path() - Connects or disconnects a path
|
|
|
|
* @path: The path to update
|
|
|
|
* @connect: The new connect state of the path. True if the path is connected,
|
2016-08-16 14:56:17 +00:00
|
|
|
* false if it is disconnected.
|
2014-10-25 15:41:56 +00:00
|
|
|
* @reason: The reason why the path changed (for debugging only)
|
|
|
|
*/
|
|
|
|
static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
|
|
|
|
bool connect, const char *reason)
|
|
|
|
{
|
|
|
|
if (path->connect == connect)
|
|
|
|
return;
|
|
|
|
|
|
|
|
path->connect = connect;
|
|
|
|
dapm_mark_dirty(path->source, reason);
|
|
|
|
dapm_mark_dirty(path->sink, reason);
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_path_invalidate(path);
|
2014-10-25 15:41:56 +00:00
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* test and update the power status of a mux widget */
|
2013-07-29 15:13:56 +00:00
|
|
|
static int soc_dapm_mux_update_power(struct snd_soc_card *card,
|
2012-02-06 16:05:14 +00:00
|
|
|
struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
int found = 0;
|
2014-10-25 15:41:56 +00:00
|
|
|
bool connect;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_assert_held(card);
|
2014-03-06 08:49:11 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* find dapm widget path assoc with kcontrol */
|
2013-07-29 15:14:00 +00:00
|
|
|
dapm_kcontrol_for_each_path(path, kcontrol) {
|
2006-10-06 16:32:18 +00:00
|
|
|
found = 1;
|
|
|
|
/* we now need to match the string in the enum to the path */
|
2019-05-15 13:18:55 +00:00
|
|
|
if (e && !(strcmp(path->name, e->texts[mux])))
|
2014-10-25 15:41:56 +00:00
|
|
|
connect = true;
|
|
|
|
else
|
|
|
|
connect = false;
|
|
|
|
|
|
|
|
soc_dapm_connect_path(path, connect, "mux update");
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2013-07-24 13:27:37 +00:00
|
|
|
if (found)
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2012-04-25 11:12:51 +00:00
|
|
|
return found;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2012-03-07 10:38:27 +00:00
|
|
|
|
2013-07-24 13:27:37 +00:00
|
|
|
int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
|
2013-07-24 13:27:38 +00:00
|
|
|
struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
|
|
|
|
struct snd_soc_dapm_update *update)
|
2012-03-07 10:38:27 +00:00
|
|
|
{
|
2013-07-24 13:27:37 +00:00
|
|
|
struct snd_soc_card *card = dapm->card;
|
2012-03-07 10:38:27 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = update;
|
2013-07-29 15:13:56 +00:00
|
|
|
ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = NULL;
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2012-04-25 11:12:51 +00:00
|
|
|
if (ret > 0)
|
2020-03-12 09:52:14 +00:00
|
|
|
snd_soc_dpcm_runtime_update(card);
|
2012-03-07 10:38:27 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2012-02-06 16:05:14 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2008-01-10 13:39:46 +00:00
|
|
|
/* test and update the power status of a mixer or switch widget */
|
2013-07-29 15:13:56 +00:00
|
|
|
static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
|
2016-11-02 07:35:59 +00:00
|
|
|
struct snd_kcontrol *kcontrol,
|
|
|
|
int connect, int rconnect)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
int found = 0;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_assert_held(card);
|
2014-03-06 08:49:11 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* find dapm widget path assoc with kcontrol */
|
2013-07-29 15:14:00 +00:00
|
|
|
dapm_kcontrol_for_each_path(path, kcontrol) {
|
2016-11-02 07:35:59 +00:00
|
|
|
/*
|
|
|
|
* Ideally this function should support any number of
|
|
|
|
* paths and channels. But since kcontrols only come
|
|
|
|
* in mono and stereo variants, we are limited to 2
|
|
|
|
* channels.
|
|
|
|
*
|
|
|
|
* The following code assumes for stereo controls the
|
|
|
|
* first path (when 'found == 0') is the left channel,
|
|
|
|
* and all remaining paths (when 'found == 1') are the
|
|
|
|
* right channel.
|
|
|
|
*
|
|
|
|
* A stereo control is signified by a valid 'rconnect'
|
|
|
|
* value, either 0 for unconnected, or >= 0 for connected.
|
|
|
|
* This is chosen instead of using snd_soc_volsw_is_stereo,
|
|
|
|
* so that the behavior of snd_soc_dapm_mixer_update_power
|
|
|
|
* doesn't change even when the kcontrol passed in is
|
|
|
|
* stereo.
|
|
|
|
*
|
|
|
|
* It passes 'connect' as the path connect status for
|
|
|
|
* the left channel, and 'rconnect' for the right
|
|
|
|
* channel.
|
|
|
|
*/
|
|
|
|
if (found && rconnect >= 0)
|
|
|
|
soc_dapm_connect_path(path, rconnect, "mixer update");
|
|
|
|
else
|
|
|
|
soc_dapm_connect_path(path, connect, "mixer update");
|
2006-10-06 16:32:18 +00:00
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
|
2013-07-24 13:27:37 +00:00
|
|
|
if (found)
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2012-04-25 11:12:51 +00:00
|
|
|
return found;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2012-03-07 10:38:27 +00:00
|
|
|
|
2013-07-24 13:27:37 +00:00
|
|
|
int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
|
2013-07-24 13:27:38 +00:00
|
|
|
struct snd_kcontrol *kcontrol, int connect,
|
|
|
|
struct snd_soc_dapm_update *update)
|
2012-03-07 10:38:27 +00:00
|
|
|
{
|
2013-07-24 13:27:37 +00:00
|
|
|
struct snd_soc_card *card = dapm->card;
|
2012-03-07 10:38:27 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = update;
|
2016-11-02 07:35:59 +00:00
|
|
|
ret = soc_dapm_mixer_update_power(card, kcontrol, connect, -1);
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = NULL;
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2012-04-25 11:12:51 +00:00
|
|
|
if (ret > 0)
|
2020-03-12 09:52:14 +00:00
|
|
|
snd_soc_dpcm_runtime_update(card);
|
2012-03-07 10:38:27 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2012-02-06 16:05:14 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2015-07-06 13:38:10 +00:00
|
|
|
static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
|
2022-08-01 17:01:07 +00:00
|
|
|
char *buf, int count)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-07-06 13:38:10 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
char *state = "not set";
|
|
|
|
|
2016-03-18 12:04:23 +00:00
|
|
|
/* card won't be set for the dummy component, as a spot fix
|
|
|
|
* we're checking for that case specifically here but in future
|
|
|
|
* we will ensure that the dummy component looks like others.
|
|
|
|
*/
|
|
|
|
if (!cmpnt->card)
|
|
|
|
return 0;
|
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(cmpnt->card, w) {
|
2015-07-06 13:38:10 +00:00
|
|
|
if (w->dapm != dapm)
|
2010-12-14 10:18:31 +00:00
|
|
|
continue;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2016-08-16 14:56:17 +00:00
|
|
|
/* only display widgets that burn power */
|
2006-10-06 16:32:18 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_hp:
|
|
|
|
case snd_soc_dapm_mic:
|
|
|
|
case snd_soc_dapm_spk:
|
|
|
|
case snd_soc_dapm_line:
|
|
|
|
case snd_soc_dapm_micbias:
|
|
|
|
case snd_soc_dapm_dac:
|
|
|
|
case snd_soc_dapm_adc:
|
|
|
|
case snd_soc_dapm_pga:
|
2019-04-30 23:11:34 +00:00
|
|
|
case snd_soc_dapm_effect:
|
2010-12-11 03:11:44 +00:00
|
|
|
case snd_soc_dapm_out_drv:
|
2006-10-06 16:32:18 +00:00
|
|
|
case snd_soc_dapm_mixer:
|
2009-01-06 20:11:51 +00:00
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
2009-04-22 17:24:55 +00:00
|
|
|
case snd_soc_dapm_supply:
|
2012-01-21 21:14:48 +00:00
|
|
|
case snd_soc_dapm_regulator_supply:
|
2018-03-10 02:37:27 +00:00
|
|
|
case snd_soc_dapm_pinctrl:
|
2012-05-24 13:26:25 +00:00
|
|
|
case snd_soc_dapm_clock_supply:
|
2006-10-06 16:32:18 +00:00
|
|
|
if (w->name)
|
2022-08-01 17:01:07 +00:00
|
|
|
count += sysfs_emit_at(buf, count, "%s: %s\n",
|
2006-10-06 16:32:18 +00:00
|
|
|
w->name, w->power ? "On":"Off");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-06 13:38:10 +00:00
|
|
|
switch (snd_soc_dapm_get_bias_level(dapm)) {
|
2008-05-19 10:31:28 +00:00
|
|
|
case SND_SOC_BIAS_ON:
|
|
|
|
state = "On";
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
2008-05-19 10:31:28 +00:00
|
|
|
case SND_SOC_BIAS_PREPARE:
|
|
|
|
state = "Prepare";
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
2008-05-19 10:31:28 +00:00
|
|
|
case SND_SOC_BIAS_STANDBY:
|
|
|
|
state = "Standby";
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
2008-05-19 10:31:28 +00:00
|
|
|
case SND_SOC_BIAS_OFF:
|
|
|
|
state = "Off";
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
|
|
|
}
|
2022-08-01 17:01:07 +00:00
|
|
|
count += sysfs_emit_at(buf, count, "PM State: %s\n", state);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2014-07-08 21:19:36 +00:00
|
|
|
/* show dapm widget status in sys fs */
|
|
|
|
static ssize_t dapm_widget_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2018-09-03 02:12:56 +00:00
|
|
|
struct snd_soc_dai *codec_dai;
|
2014-07-08 21:19:36 +00:00
|
|
|
int i, count = 0;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(rtd->card);
|
2015-07-06 15:01:24 +00:00
|
|
|
|
2020-03-09 04:08:04 +00:00
|
|
|
for_each_rtd_codec_dais(rtd, i, codec_dai) {
|
2018-09-03 02:12:56 +00:00
|
|
|
struct snd_soc_component *cmpnt = codec_dai->component;
|
2015-07-06 13:38:10 +00:00
|
|
|
|
2022-08-01 17:01:07 +00:00
|
|
|
count = dapm_widget_show_component(cmpnt, buf, count);
|
2014-07-08 21:19:36 +00:00
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(rtd->card);
|
2015-07-06 15:01:24 +00:00
|
|
|
|
2014-07-08 21:19:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2017-12-19 18:15:08 +00:00
|
|
|
static DEVICE_ATTR_RO(dapm_widget);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2015-01-30 19:16:37 +00:00
|
|
|
struct attribute *soc_dapm_dev_attrs[] = {
|
|
|
|
&dev_attr_dapm_widget.attr,
|
|
|
|
NULL
|
|
|
|
};
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2013-06-14 11:16:53 +00:00
|
|
|
static void dapm_free_path(struct snd_soc_dapm_path *path)
|
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
|
|
|
|
list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
|
2013-07-29 15:14:00 +00:00
|
|
|
list_del(&path->list_kcontrol);
|
2013-06-14 11:16:53 +00:00
|
|
|
list_del(&path->list);
|
|
|
|
kfree(path);
|
|
|
|
}
|
|
|
|
|
2022-03-11 15:35:29 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_free_widget - Free specified widget
|
|
|
|
* @w: widget to free
|
|
|
|
*
|
|
|
|
* Removes widget from all paths and frees memory occupied by it.
|
|
|
|
*/
|
2015-07-21 16:11:07 +00:00
|
|
|
void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *p, *next_p;
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir;
|
2015-07-21 16:11:07 +00:00
|
|
|
|
2022-10-17 23:36:49 +00:00
|
|
|
if (!w)
|
|
|
|
return;
|
|
|
|
|
2015-07-21 16:11:07 +00:00
|
|
|
list_del(&w->list);
|
2020-12-13 01:20:12 +00:00
|
|
|
list_del(&w->dirty);
|
2015-07-21 16:11:07 +00:00
|
|
|
/*
|
|
|
|
* remove source and sink paths associated to this widget.
|
|
|
|
* While removing the path, remove reference to it from both
|
|
|
|
* source and sink widgets so that path is removed only once.
|
|
|
|
*/
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_for_each_direction(dir) {
|
|
|
|
snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
|
|
|
|
dapm_free_path(p);
|
|
|
|
}
|
2015-07-21 16:11:07 +00:00
|
|
|
|
|
|
|
kfree(w->kcontrols);
|
2015-07-21 16:11:08 +00:00
|
|
|
kfree_const(w->name);
|
2019-02-01 17:05:12 +00:00
|
|
|
kfree_const(w->sname);
|
2015-07-21 16:11:07 +00:00
|
|
|
kfree(w);
|
|
|
|
}
|
2022-03-11 15:35:29 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_free_widget);
|
2015-07-21 16:11:07 +00:00
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* free all dapm widgets and resources */
|
2010-11-05 13:53:46 +00:00
|
|
|
static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w, *next_w;
|
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets_safe(dapm->card, w, next_w) {
|
2010-12-14 10:18:31 +00:00
|
|
|
if (w->dapm != dapm)
|
|
|
|
continue;
|
2015-07-21 16:11:07 +00:00
|
|
|
snd_soc_dapm_free_widget(w);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2022-10-17 23:36:27 +00:00
|
|
|
|
|
|
|
dapm->wcache_sink = NULL;
|
|
|
|
dapm->wcache_source = NULL;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
static struct snd_soc_dapm_widget *dapm_find_widget(
|
|
|
|
struct snd_soc_dapm_context *dapm, const char *pin,
|
|
|
|
bool search_other_contexts)
|
2008-07-07 12:35:17 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
2011-04-27 16:34:31 +00:00
|
|
|
struct snd_soc_dapm_widget *fallback = NULL;
|
2021-02-08 23:40:42 +00:00
|
|
|
char prefixed_pin[80];
|
|
|
|
const char *pin_name;
|
|
|
|
const char *prefix = soc_dapm_prefix(dapm);
|
|
|
|
|
|
|
|
if (prefix) {
|
|
|
|
snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s",
|
|
|
|
prefix, pin);
|
|
|
|
pin_name = prefixed_pin;
|
|
|
|
} else {
|
|
|
|
pin_name = pin;
|
|
|
|
}
|
2008-07-07 12:35:17 +00:00
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(dapm->card, w) {
|
2021-02-08 23:40:42 +00:00
|
|
|
if (!strcmp(w->name, pin_name)) {
|
2011-04-27 16:34:31 +00:00
|
|
|
if (w->dapm == dapm)
|
|
|
|
return w;
|
|
|
|
else
|
|
|
|
fallback = w;
|
2008-07-07 12:35:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
if (search_other_contexts)
|
|
|
|
return fallback;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-11-05 09:09:25 +00:00
|
|
|
/*
|
|
|
|
* set the DAPM pin status:
|
|
|
|
* returns 1 when the value has been updated, 0 when unchanged, or a negative
|
|
|
|
* error code; called from kcontrol put callback
|
|
|
|
*/
|
|
|
|
static int __snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin, int status)
|
2011-04-27 16:34:31 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
|
2021-10-06 14:17:12 +00:00
|
|
|
int ret = 0;
|
2011-04-27 16:34:31 +00:00
|
|
|
|
2014-03-06 08:49:11 +00:00
|
|
|
dapm_assert_locked(dapm);
|
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
if (!w) {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
|
2011-04-27 16:34:31 +00:00
|
|
|
return -EINVAL;
|
2011-04-06 02:38:14 +00:00
|
|
|
}
|
|
|
|
|
2014-10-25 15:42:03 +00:00
|
|
|
if (w->connected != status) {
|
2012-02-16 19:50:07 +00:00
|
|
|
dapm_mark_dirty(w, "pin configuration");
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_widget_invalidate_input_paths(w);
|
|
|
|
dapm_widget_invalidate_output_paths(w);
|
2021-10-06 14:17:12 +00:00
|
|
|
ret = 1;
|
2014-10-25 15:42:03 +00:00
|
|
|
}
|
2012-02-16 19:50:07 +00:00
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
w->connected = status;
|
|
|
|
if (status == 0)
|
|
|
|
w->force = 0;
|
|
|
|
|
2021-10-06 14:17:12 +00:00
|
|
|
return ret;
|
2008-07-07 12:35:17 +00:00
|
|
|
}
|
|
|
|
|
2021-11-05 09:09:25 +00:00
|
|
|
/*
|
|
|
|
* similar as __snd_soc_dapm_set_pin(), but returns 0 when successful;
|
|
|
|
* called from several API functions below
|
|
|
|
*/
|
|
|
|
static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin, int status)
|
|
|
|
{
|
|
|
|
int ret = __snd_soc_dapm_set_pin(dapm, pin, status);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/**
|
2014-02-18 15:22:15 +00:00
|
|
|
* snd_soc_dapm_sync_unlocked - scan and power dapm paths
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Walks all dapm audio paths and powers widgets according to their
|
|
|
|
* stream or path usage.
|
|
|
|
*
|
2014-02-18 15:22:15 +00:00
|
|
|
* Requires external locking.
|
|
|
|
*
|
2006-10-06 16:32:18 +00:00
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
2014-02-18 15:22:15 +00:00
|
|
|
int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2011-10-07 13:29:19 +00:00
|
|
|
/*
|
|
|
|
* Suppress early reports (eg, jacks syncing their state) to avoid
|
|
|
|
* silly DAPM runs during card startup.
|
|
|
|
*/
|
2023-01-31 02:01:34 +00:00
|
|
|
if (!snd_soc_card_is_instantiated(dapm->card))
|
2011-10-07 13:29:19 +00:00
|
|
|
return 0;
|
|
|
|
|
2014-02-18 15:22:15 +00:00
|
|
|
return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_sync - scan and power dapm paths
|
|
|
|
* @dapm: DAPM context
|
|
|
|
*
|
|
|
|
* Walks all dapm audio paths and powers widgets according to their
|
|
|
|
* stream or path usage.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-02-18 15:22:15 +00:00
|
|
|
ret = snd_soc_dapm_sync_unlocked(dapm);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2012-03-07 10:38:26 +00:00
|
|
|
return ret;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2008-07-07 12:35:17 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2019-01-31 13:30:18 +00:00
|
|
|
static int dapm_update_dai_chan(struct snd_soc_dapm_path *p,
|
|
|
|
struct snd_soc_dapm_widget *w,
|
|
|
|
int channels)
|
|
|
|
{
|
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_aif_out:
|
|
|
|
case snd_soc_dapm_aif_in:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(w->dapm->dev, "%s DAI route %s -> %s\n",
|
|
|
|
w->channel < channels ? "Connecting" : "Disconnecting",
|
|
|
|
p->source->name, p->sink->name);
|
|
|
|
|
|
|
|
if (w->channel < channels)
|
|
|
|
soc_dapm_connect_path(p, true, "dai update");
|
|
|
|
else
|
|
|
|
soc_dapm_connect_path(p, false, "dai update");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dapm_update_dai_unlocked(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *params,
|
|
|
|
struct snd_soc_dai *dai)
|
|
|
|
{
|
|
|
|
int dir = substream->stream;
|
|
|
|
int channels = params_channels(params);
|
|
|
|
struct snd_soc_dapm_path *p;
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
int ret;
|
|
|
|
|
2020-02-19 06:56:41 +00:00
|
|
|
w = snd_soc_dai_get_widget(dai, dir);
|
2019-01-31 13:30:18 +00:00
|
|
|
|
2019-02-06 11:13:59 +00:00
|
|
|
if (!w)
|
|
|
|
return 0;
|
|
|
|
|
2019-01-31 13:30:18 +00:00
|
|
|
dev_dbg(dai->dev, "Update DAI routes for %s %s\n", dai->name,
|
|
|
|
dir == SNDRV_PCM_STREAM_PLAYBACK ? "playback" : "capture");
|
|
|
|
|
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, p) {
|
|
|
|
ret = dapm_update_dai_chan(p, p->sink, channels);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, p) {
|
|
|
|
ret = dapm_update_dai_chan(p, p->source, channels);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int snd_soc_dapm_update_dai(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *params,
|
|
|
|
struct snd_soc_dai *dai)
|
|
|
|
{
|
2020-07-20 01:17:39 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
|
2019-01-31 13:30:18 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(rtd->card);
|
2019-01-31 13:30:18 +00:00
|
|
|
ret = dapm_update_dai_unlocked(substream, params, dai);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(rtd->card);
|
2019-01-31 13:30:18 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_update_dai);
|
|
|
|
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
/*
|
|
|
|
* dapm_update_widget_flags() - Re-compute widget sink and source flags
|
|
|
|
* @w: The widget for which to update the flags
|
|
|
|
*
|
|
|
|
* Some widgets have a dynamic category which depends on which neighbors they
|
|
|
|
* are connected to. This function update the category for these widgets.
|
|
|
|
*
|
|
|
|
* This function must be called whenever a path is added or removed to a widget.
|
|
|
|
*/
|
|
|
|
static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
|
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
struct snd_soc_dapm_path *p;
|
2015-08-11 19:38:00 +00:00
|
|
|
unsigned int ep;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
|
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_input:
|
2016-08-16 14:56:17 +00:00
|
|
|
/* On a fully routed card an input is never a source */
|
2014-12-21 10:05:44 +00:00
|
|
|
if (w->dapm->card->fully_routed)
|
2015-08-11 19:38:00 +00:00
|
|
|
return;
|
|
|
|
ep = SND_SOC_DAPM_EP_SOURCE;
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, p) {
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
if (p->source->id == snd_soc_dapm_micbias ||
|
|
|
|
p->source->id == snd_soc_dapm_mic ||
|
|
|
|
p->source->id == snd_soc_dapm_line ||
|
|
|
|
p->source->id == snd_soc_dapm_output) {
|
2015-08-11 19:38:00 +00:00
|
|
|
ep = 0;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_output:
|
2014-12-21 10:05:44 +00:00
|
|
|
/* On a fully routed card a output is never a sink */
|
|
|
|
if (w->dapm->card->fully_routed)
|
2015-08-11 19:38:00 +00:00
|
|
|
return;
|
|
|
|
ep = SND_SOC_DAPM_EP_SINK;
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, p) {
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
if (p->sink->id == snd_soc_dapm_spk ||
|
|
|
|
p->sink->id == snd_soc_dapm_hp ||
|
|
|
|
p->sink->id == snd_soc_dapm_line ||
|
|
|
|
p->sink->id == snd_soc_dapm_input) {
|
2015-08-11 19:38:00 +00:00
|
|
|
ep = 0;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_line:
|
2015-08-11 19:38:00 +00:00
|
|
|
ep = 0;
|
|
|
|
snd_soc_dapm_for_each_direction(dir) {
|
|
|
|
if (!list_empty(&w->edges[dir]))
|
|
|
|
ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
|
|
|
|
}
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
2015-08-11 19:38:00 +00:00
|
|
|
return;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
}
|
2015-08-11 19:38:00 +00:00
|
|
|
|
|
|
|
w->is_ep = ep;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
}
|
|
|
|
|
2015-05-01 16:02:43 +00:00
|
|
|
static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
|
|
|
|
const char *control)
|
|
|
|
{
|
|
|
|
bool dynamic_source = false;
|
|
|
|
bool dynamic_sink = false;
|
|
|
|
|
|
|
|
if (!control)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (source->id) {
|
|
|
|
case snd_soc_dapm_demux:
|
|
|
|
dynamic_source = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (sink->id) {
|
|
|
|
case snd_soc_dapm_mux:
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
|
|
|
dynamic_sink = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dynamic_source && dynamic_sink) {
|
|
|
|
dev_err(dapm->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,
|
|
|
|
"Control not supported for path %s -> [%s] -> %s\n",
|
|
|
|
source->name, control, sink->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:14:02 +00:00
|
|
|
static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
|
|
|
|
const char *control,
|
|
|
|
int (*connected)(struct snd_soc_dapm_widget *source,
|
|
|
|
struct snd_soc_dapm_widget *sink))
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir;
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_path *path;
|
2013-07-29 15:14:02 +00:00
|
|
|
int ret;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2014-10-25 15:42:02 +00:00
|
|
|
if (wsink->is_supply && !wsource->is_supply) {
|
|
|
|
dev_err(dapm->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,
|
|
|
|
"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,
|
|
|
|
"Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
|
|
|
|
wsource->name, control, wsink->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-05-01 16:02:43 +00:00
|
|
|
ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
path->node[SND_SOC_DAPM_DIR_IN] = wsource;
|
|
|
|
path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
|
|
|
|
|
2013-07-29 15:14:02 +00:00
|
|
|
path->connected = connected;
|
2006-10-06 16:32:18 +00:00
|
|
|
INIT_LIST_HEAD(&path->list);
|
2013-08-12 23:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&path->list_kcontrol);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2014-10-25 15:42:00 +00:00
|
|
|
if (wsource->is_supply || wsink->is_supply)
|
|
|
|
path->is_supply = 1;
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* connect static paths */
|
|
|
|
if (control == NULL) {
|
|
|
|
path->connect = 1;
|
2014-10-25 15:41:58 +00:00
|
|
|
} else {
|
2015-05-01 16:02:43 +00:00
|
|
|
switch (wsource->id) {
|
|
|
|
case snd_soc_dapm_demux:
|
|
|
|
ret = dapm_connect_mux(dapm, path, control, wsource);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-10-25 15:41:58 +00:00
|
|
|
switch (wsink->id) {
|
|
|
|
case snd_soc_dapm_mux:
|
2015-05-01 16:02:43 +00:00
|
|
|
ret = dapm_connect_mux(dapm, path, control, wsink);
|
2014-10-25 15:41:58 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
|
|
|
ret = dapm_connect_mixer(dapm, path, control);
|
|
|
|
if (ret != 0)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
default:
|
2015-05-01 16:02:43 +00:00
|
|
|
break;
|
2014-10-25 15:41:58 +00:00
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2012-07-05 16:20:06 +00:00
|
|
|
|
2014-10-25 15:41:58 +00:00
|
|
|
list_add(&path->list, &dapm->card->paths);
|
2022-10-17 23:36:42 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_for_each_direction(dir)
|
2022-10-17 23:36:42 +00:00
|
|
|
list_add(&path->list_node[dir], &path->node[dir]->edges[dir]);
|
2014-10-25 15:41:58 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_for_each_direction(dir) {
|
2022-10-17 23:36:42 +00:00
|
|
|
dapm_update_widget_flags(path->node[dir]);
|
|
|
|
dapm_mark_dirty(path->node[dir], "Route added");
|
2015-08-11 19:38:00 +00:00
|
|
|
}
|
2014-10-25 15:41:58 +00:00
|
|
|
|
2023-01-31 02:01:34 +00:00
|
|
|
if (snd_soc_card_is_instantiated(dapm->card) && path->connect)
|
2014-10-25 15:42:03 +00:00
|
|
|
dapm_path_invalidate(path);
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
return 0;
|
2013-07-29 15:14:02 +00:00
|
|
|
err:
|
|
|
|
kfree(path);
|
|
|
|
return ret;
|
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2013-07-29 15:14:02 +00:00
|
|
|
static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
|
2014-05-07 14:20:25 +00:00
|
|
|
const struct snd_soc_dapm_route *route)
|
2013-07-29 15:14:02 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
|
|
|
|
struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
|
|
|
|
const char *sink;
|
|
|
|
const char *source;
|
|
|
|
char prefixed_sink[80];
|
|
|
|
char prefixed_source[80];
|
2014-06-16 16:13:01 +00:00
|
|
|
const char *prefix;
|
2019-01-31 11:30:05 +00:00
|
|
|
unsigned int sink_ref = 0;
|
|
|
|
unsigned int source_ref = 0;
|
2013-07-29 15:14:02 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix = soc_dapm_prefix(dapm);
|
|
|
|
if (prefix) {
|
2013-07-29 15:14:02 +00:00
|
|
|
snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix, route->sink);
|
2013-07-29 15:14:02 +00:00
|
|
|
sink = prefixed_sink;
|
|
|
|
snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix, route->source);
|
2013-07-29 15:14:02 +00:00
|
|
|
source = prefixed_source;
|
|
|
|
} else {
|
|
|
|
sink = route->sink;
|
|
|
|
source = route->source;
|
|
|
|
}
|
|
|
|
|
2022-10-17 23:36:27 +00:00
|
|
|
wsource = dapm_wcache_lookup(dapm->wcache_source, source);
|
|
|
|
wsink = dapm_wcache_lookup(dapm->wcache_sink, sink);
|
2015-05-11 12:50:30 +00:00
|
|
|
|
|
|
|
if (wsink && wsource)
|
|
|
|
goto skip_search;
|
|
|
|
|
2013-07-29 15:14:02 +00:00
|
|
|
/*
|
|
|
|
* find src and dest widgets over all widgets but favor a widget from
|
|
|
|
* current DAPM context
|
|
|
|
*/
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(dapm->card, w) {
|
2013-07-29 15:14:02 +00:00
|
|
|
if (!wsink && !(strcmp(w->name, sink))) {
|
|
|
|
wtsink = w;
|
2015-05-07 10:33:58 +00:00
|
|
|
if (w->dapm == dapm) {
|
2013-07-29 15:14:02 +00:00
|
|
|
wsink = w;
|
2015-05-07 10:33:58 +00:00
|
|
|
if (wsource)
|
|
|
|
break;
|
|
|
|
}
|
2019-01-31 11:30:05 +00:00
|
|
|
sink_ref++;
|
|
|
|
if (sink_ref > 1)
|
|
|
|
dev_warn(dapm->dev,
|
|
|
|
"ASoC: sink widget %s overwritten\n",
|
|
|
|
w->name);
|
2013-07-29 15:14:02 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!wsource && !(strcmp(w->name, source))) {
|
|
|
|
wtsource = w;
|
2015-05-07 10:33:58 +00:00
|
|
|
if (w->dapm == dapm) {
|
2013-07-29 15:14:02 +00:00
|
|
|
wsource = w;
|
2015-05-07 10:33:58 +00:00
|
|
|
if (wsink)
|
|
|
|
break;
|
|
|
|
}
|
2019-01-31 11:30:05 +00:00
|
|
|
source_ref++;
|
|
|
|
if (source_ref > 1)
|
|
|
|
dev_warn(dapm->dev,
|
|
|
|
"ASoC: source widget %s overwritten\n",
|
|
|
|
w->name);
|
2013-07-29 15:14:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* use widget from another DAPM context if not found from this */
|
|
|
|
if (!wsink)
|
|
|
|
wsink = wtsink;
|
|
|
|
if (!wsource)
|
|
|
|
wsource = wtsource;
|
|
|
|
|
ASoC: soc-dapm.c: tidyup error handling on snd_soc_dapm_add_route()
Current error handling on snd_soc_dapm_add_route() has some wastes.
It indicates *own* error message *only* for sink or source,
and return error directly at (A). OTOH, it has similar error message at
(B) which indicates *both* sink/source.
And more, (A) is using dev_err(), (B) is using dev_warn().
(B) is caring prefix, but (A) is not.
(X) int snd_soc_dapm_add_route(...)
{
...
if (wsource == NULL) {
(A) dev_err(...);
return -ENODEV;
}
if (wsink == NULL) {
(A) dev_err(...);
return -ENODEV;
}
...
ret = snd_soc_dapm_add_path(...);
if (ret)
(B) goto err;
return 0;
err:
(B) dev_warn(...);
return ret;
}
Above snd_soc_dapm_add_route() (= X) is called from
snd_soc_dapm_add_routes() (= Y).
(X) will indicate error message by itself, but (Y) will indicate
own error message at (C). (C) is duplicated.
(Y) int snd_soc_dapm_add_routes(...)
{
...
for (...) {
(X) int r = snd_soc_dapm_add_route(...);
if (r < 0) {
(C) dev_err(...);
ret = r;
}
...
}
...
}
This patch (1) merges these error message (= A,B) into one,
(2) use dev_err(), (3) remove duplicate error message (= C) from
snd_soc_dapm_add_routes().
By this patch, it will indicate error message like this.
- error message with prefix
- not found widget will have "(*)" mark
- it indicates [control] if exists.
ex)
[if no sink with control]
ASoC: Failed to add route SOURCE -> [CTRL] -> SINK(*)
[if no source without control]
ASoC: Failed to add route SOURCE(*) -> SINK
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87zgduowe5.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-17 23:36:35 +00:00
|
|
|
ret = -ENODEV;
|
|
|
|
if (!wsource)
|
|
|
|
goto err;
|
|
|
|
if (!wsink)
|
|
|
|
goto err;
|
2013-07-29 15:14:02 +00:00
|
|
|
|
2015-05-11 12:50:30 +00:00
|
|
|
skip_search:
|
2022-10-17 23:36:27 +00:00
|
|
|
/* update cache */
|
|
|
|
dapm->wcache_sink = wsink;
|
|
|
|
dapm->wcache_source = wsource;
|
2015-05-11 12:50:30 +00:00
|
|
|
|
2013-07-29 15:14:02 +00:00
|
|
|
ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
|
|
|
|
route->connected);
|
2006-10-06 16:32:18 +00:00
|
|
|
err:
|
ASoC: soc-dapm.c: tidyup error handling on snd_soc_dapm_add_route()
Current error handling on snd_soc_dapm_add_route() has some wastes.
It indicates *own* error message *only* for sink or source,
and return error directly at (A). OTOH, it has similar error message at
(B) which indicates *both* sink/source.
And more, (A) is using dev_err(), (B) is using dev_warn().
(B) is caring prefix, but (A) is not.
(X) int snd_soc_dapm_add_route(...)
{
...
if (wsource == NULL) {
(A) dev_err(...);
return -ENODEV;
}
if (wsink == NULL) {
(A) dev_err(...);
return -ENODEV;
}
...
ret = snd_soc_dapm_add_path(...);
if (ret)
(B) goto err;
return 0;
err:
(B) dev_warn(...);
return ret;
}
Above snd_soc_dapm_add_route() (= X) is called from
snd_soc_dapm_add_routes() (= Y).
(X) will indicate error message by itself, but (Y) will indicate
own error message at (C). (C) is duplicated.
(Y) int snd_soc_dapm_add_routes(...)
{
...
for (...) {
(X) int r = snd_soc_dapm_add_route(...);
if (r < 0) {
(C) dev_err(...);
ret = r;
}
...
}
...
}
This patch (1) merges these error message (= A,B) into one,
(2) use dev_err(), (3) remove duplicate error message (= C) from
snd_soc_dapm_add_routes().
By this patch, it will indicate error message like this.
- error message with prefix
- not found widget will have "(*)" mark
- it indicates [control] if exists.
ex)
[if no sink with control]
ASoC: Failed to add route SOURCE -> [CTRL] -> SINK(*)
[if no source without control]
ASoC: Failed to add route SOURCE(*) -> SINK
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87zgduowe5.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-17 23:36:35 +00:00
|
|
|
if (ret)
|
|
|
|
dev_err(dapm->dev, "ASoC: Failed to add route %s%s -%s%s%s> %s%s\n",
|
|
|
|
source, !wsource ? "(*)" : "",
|
|
|
|
!route->control ? "" : "> [",
|
|
|
|
!route->control ? "" : route->control,
|
|
|
|
!route->control ? "" : "] -",
|
|
|
|
sink, !wsink ? "(*)" : "");
|
2006-10-06 16:32:18 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2008-05-13 12:52:19 +00:00
|
|
|
|
2012-07-05 16:24:19 +00:00
|
|
|
static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
|
|
|
|
const struct snd_soc_dapm_route *route)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *path, *p;
|
|
|
|
const char *sink;
|
|
|
|
const char *source;
|
|
|
|
char prefixed_sink[80];
|
|
|
|
char prefixed_source[80];
|
2014-06-16 16:13:01 +00:00
|
|
|
const char *prefix;
|
2012-07-05 16:24:19 +00:00
|
|
|
|
|
|
|
if (route->control) {
|
|
|
|
dev_err(dapm->dev,
|
2012-11-19 14:39:12 +00:00
|
|
|
"ASoC: Removal of routes with controls not supported\n");
|
2012-07-05 16:24:19 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix = soc_dapm_prefix(dapm);
|
|
|
|
if (prefix) {
|
2012-07-05 16:24:19 +00:00
|
|
|
snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix, route->sink);
|
2012-07-05 16:24:19 +00:00
|
|
|
sink = prefixed_sink;
|
|
|
|
snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
|
2014-06-16 16:13:01 +00:00
|
|
|
prefix, route->source);
|
2012-07-05 16:24:19 +00:00
|
|
|
source = prefixed_source;
|
|
|
|
} else {
|
|
|
|
sink = route->sink;
|
|
|
|
source = route->source;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = NULL;
|
|
|
|
list_for_each_entry(p, &dapm->card->paths, list) {
|
|
|
|
if (strcmp(p->source->name, source) != 0)
|
|
|
|
continue;
|
|
|
|
if (strcmp(p->sink->name, sink) != 0)
|
|
|
|
continue;
|
|
|
|
path = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (path) {
|
2021-08-05 01:11:28 +00:00
|
|
|
struct snd_soc_dapm_widget *wsource = path->source;
|
|
|
|
struct snd_soc_dapm_widget *wsink = path->sink;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
|
|
|
|
dapm_mark_dirty(wsource, "Route removed");
|
|
|
|
dapm_mark_dirty(wsink, "Route removed");
|
2014-10-25 15:42:03 +00:00
|
|
|
if (path->connect)
|
|
|
|
dapm_path_invalidate(path);
|
2012-07-05 16:24:19 +00:00
|
|
|
|
2013-06-14 11:16:53 +00:00
|
|
|
dapm_free_path(path);
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
|
|
|
|
/* Update any path related flags */
|
|
|
|
dapm_update_widget_flags(wsource);
|
|
|
|
dapm_update_widget_flags(wsink);
|
2012-07-05 16:24:19 +00:00
|
|
|
} else {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
|
2012-07-05 16:24:19 +00:00
|
|
|
source, sink);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-13 12:52:19 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_add_routes - Add routes between DAPM widgets
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-05-13 12:52:19 +00:00
|
|
|
* @route: audio routes
|
|
|
|
* @num: number of routes
|
|
|
|
*
|
|
|
|
* Connects 2 dapm widgets together via a named audio path. The sink is
|
|
|
|
* the widget receiving the audio signal, whilst the source is the sender
|
|
|
|
* of the audio signal.
|
|
|
|
*
|
|
|
|
* Returns 0 for success else error. On error all resources can be freed
|
|
|
|
* with a call to snd_soc_card_free().
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
|
2008-05-13 12:52:19 +00:00
|
|
|
const struct snd_soc_dapm_route *route, int num)
|
|
|
|
{
|
2021-08-05 01:11:33 +00:00
|
|
|
int i, ret = 0;
|
2008-05-13 12:52:19 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2008-05-13 12:52:19 +00:00
|
|
|
for (i = 0; i < num; i++) {
|
2021-08-05 01:11:33 +00:00
|
|
|
int r = snd_soc_dapm_add_route(dapm, route);
|
ASoC: soc-dapm.c: tidyup error handling on snd_soc_dapm_add_route()
Current error handling on snd_soc_dapm_add_route() has some wastes.
It indicates *own* error message *only* for sink or source,
and return error directly at (A). OTOH, it has similar error message at
(B) which indicates *both* sink/source.
And more, (A) is using dev_err(), (B) is using dev_warn().
(B) is caring prefix, but (A) is not.
(X) int snd_soc_dapm_add_route(...)
{
...
if (wsource == NULL) {
(A) dev_err(...);
return -ENODEV;
}
if (wsink == NULL) {
(A) dev_err(...);
return -ENODEV;
}
...
ret = snd_soc_dapm_add_path(...);
if (ret)
(B) goto err;
return 0;
err:
(B) dev_warn(...);
return ret;
}
Above snd_soc_dapm_add_route() (= X) is called from
snd_soc_dapm_add_routes() (= Y).
(X) will indicate error message by itself, but (Y) will indicate
own error message at (C). (C) is duplicated.
(Y) int snd_soc_dapm_add_routes(...)
{
...
for (...) {
(X) int r = snd_soc_dapm_add_route(...);
if (r < 0) {
(C) dev_err(...);
ret = r;
}
...
}
...
}
This patch (1) merges these error message (= A,B) into one,
(2) use dev_err(), (3) remove duplicate error message (= C) from
snd_soc_dapm_add_routes().
By this patch, it will indicate error message like this.
- error message with prefix
- not found widget will have "(*)" mark
- it indicates [control] if exists.
ex)
[if no sink with control]
ASoC: Failed to add route SOURCE -> [CTRL] -> SINK(*)
[if no source without control]
ASoC: Failed to add route SOURCE(*) -> SINK
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87zgduowe5.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2022-10-17 23:36:35 +00:00
|
|
|
if (r < 0)
|
2012-06-22 11:21:49 +00:00
|
|
|
ret = r;
|
2008-05-13 12:52:19 +00:00
|
|
|
route++;
|
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2008-05-13 12:52:19 +00:00
|
|
|
|
2012-04-13 19:25:43 +00:00
|
|
|
return ret;
|
2008-05-13 12:52:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
|
|
|
|
|
2012-07-05 16:24:19 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_del_routes - Remove routes between DAPM widgets
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @route: audio routes
|
|
|
|
* @num: number of routes
|
|
|
|
*
|
|
|
|
* Removes routes from the DAPM context.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
|
|
|
|
const struct snd_soc_dapm_route *route, int num)
|
|
|
|
{
|
2016-02-11 05:53:35 +00:00
|
|
|
int i;
|
2012-07-05 16:24:19 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2012-07-05 16:24:19 +00:00
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
snd_soc_dapm_del_route(dapm, route);
|
|
|
|
route++;
|
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2012-07-05 16:24:19 +00:00
|
|
|
|
2016-02-11 05:53:35 +00:00
|
|
|
return 0;
|
2012-07-05 16:24:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
|
|
|
|
|
2011-06-13 15:42:29 +00:00
|
|
|
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) {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
|
2011-06-13 15:42:29 +00:00
|
|
|
route->source);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sink) {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
|
2011-06-13 15:42:29 +00:00
|
|
|
route->sink);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (route->control || route->connected)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
|
2011-06-13 15:42:29 +00:00
|
|
|
route->source, route->sink);
|
|
|
|
|
2015-07-26 17:05:00 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(source, path) {
|
2011-06-13 15:42:29 +00:00
|
|
|
if (path->sink == sink) {
|
|
|
|
path->weak = 1;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count == 0)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
|
2011-06-13 15:42:29 +00:00
|
|
|
route->source, route->sink);
|
|
|
|
if (count > 1)
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
|
2011-06-13 15:42:29 +00:00
|
|
|
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)
|
|
|
|
{
|
2021-08-05 01:11:37 +00:00
|
|
|
int i;
|
2011-06-13 15:42:29 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(dapm);
|
2011-06-13 15:42:29 +00:00
|
|
|
for (i = 0; i < num; i++) {
|
2021-08-05 01:11:37 +00:00
|
|
|
int err = snd_soc_dapm_weak_route(dapm, route);
|
2011-06-13 15:42:29 +00:00
|
|
|
if (err)
|
|
|
|
ret = err;
|
|
|
|
route++;
|
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2011-06-13 15:42:29 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_new_widgets - add new dapm widgets
|
2015-08-25 07:14:48 +00:00
|
|
|
* @card: card to be checked for new dapm widgets
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Checks the codec for any new dapm widgets and creates them if found.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
2013-08-27 13:51:01 +00:00
|
|
|
int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
2011-02-09 18:04:11 +00:00
|
|
|
unsigned int val;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(card);
|
2012-03-07 10:38:26 +00:00
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, w)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
|
|
|
if (w->new)
|
|
|
|
continue;
|
|
|
|
|
2011-04-28 23:37:59 +00:00
|
|
|
if (w->num_kcontrols) {
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
w->kcontrols = kcalloc(w->num_kcontrols,
|
2011-04-28 23:37:59 +00:00
|
|
|
sizeof(struct snd_kcontrol *),
|
|
|
|
GFP_KERNEL);
|
2012-03-07 10:38:26 +00:00
|
|
|
if (!w->kcontrols) {
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2011-04-28 23:37:59 +00:00
|
|
|
return -ENOMEM;
|
2012-03-07 10:38:26 +00:00
|
|
|
}
|
2011-04-28 23:37:59 +00:00
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
switch(w->id) {
|
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
2009-01-06 20:11:51 +00:00
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
2011-06-09 11:22:36 +00:00
|
|
|
dapm_new_mixer(w);
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
|
|
|
case snd_soc_dapm_mux:
|
2015-05-01 16:02:43 +00:00
|
|
|
case snd_soc_dapm_demux:
|
2011-06-09 11:22:36 +00:00
|
|
|
dapm_new_mux(w);
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
|
|
|
case snd_soc_dapm_pga:
|
2019-04-30 23:11:34 +00:00
|
|
|
case snd_soc_dapm_effect:
|
2010-12-11 03:11:44 +00:00
|
|
|
case snd_soc_dapm_out_drv:
|
2011-06-09 11:22:36 +00:00
|
|
|
dapm_new_pga(w);
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
2015-02-02 17:06:44 +00:00
|
|
|
case snd_soc_dapm_dai_link:
|
|
|
|
dapm_new_dai_link(w);
|
|
|
|
break;
|
2011-10-08 13:04:50 +00:00
|
|
|
default:
|
2006-10-06 16:32:18 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-02-09 18:04:11 +00:00
|
|
|
|
|
|
|
/* Read the initial power state from the device */
|
|
|
|
if (w->reg >= 0) {
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
val = soc_dapm_read(w->dapm, w->reg);
|
2014-01-14 23:31:54 +00:00
|
|
|
val = val >> w->shift;
|
2013-07-29 15:14:01 +00:00
|
|
|
val &= w->mask;
|
|
|
|
if (val == w->on_val)
|
2011-02-09 18:04:11 +00:00
|
|
|
w->power = 1;
|
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
w->new = 1;
|
2011-04-30 17:45:49 +00:00
|
|
|
|
2011-10-05 11:09:12 +00:00
|
|
|
dapm_mark_dirty(w, "new widget");
|
2011-04-30 17:45:49 +00:00
|
|
|
dapm_debugfs_add_widget(w);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2006-10-06 16:32:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_get_volsw - dapm mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 12:18:17 +00:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Callback to get the value of a dapm mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
|
2008-07-29 10:42:26 +00:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2013-10-06 11:43:49 +00:00
|
|
|
int reg = mc->reg;
|
2008-07-29 14:22:24 +00:00
|
|
|
unsigned int shift = mc->shift;
|
2008-07-29 10:42:26 +00:00
|
|
|
int max = mc->max;
|
2016-11-02 07:35:59 +00:00
|
|
|
unsigned int width = fls(max);
|
2008-07-29 14:22:24 +00:00
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
2012-07-03 18:18:17 +00:00
|
|
|
unsigned int invert = mc->invert;
|
2016-11-02 07:35:59 +00:00
|
|
|
unsigned int reg_val, val, rval = 0;
|
2012-07-03 18:18:17 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-06-16 16:13:06 +00:00
|
|
|
if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
reg_val = soc_dapm_read(dapm, reg);
|
2016-11-02 07:35:59 +00:00
|
|
|
val = (reg_val >> shift) & mask;
|
|
|
|
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
if (reg != mc->rreg)
|
|
|
|
reg_val = soc_dapm_read(dapm, mc->rreg);
|
2016-11-02 07:35:59 +00:00
|
|
|
|
|
|
|
if (snd_soc_volsw_is_stereo(mc))
|
|
|
|
rval = (reg_val >> mc->rshift) & mask;
|
2014-06-16 16:13:06 +00:00
|
|
|
} else {
|
2016-11-02 07:35:59 +00:00
|
|
|
reg_val = dapm_kcontrol_get_value(kcontrol);
|
|
|
|
val = reg_val & mask;
|
|
|
|
|
|
|
|
if (snd_soc_volsw_is_stereo(mc))
|
|
|
|
rval = (reg_val >> width) & mask;
|
2014-06-16 16:13:06 +00:00
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2013-08-05 09:27:31 +00:00
|
|
|
|
2012-07-03 18:18:17 +00:00
|
|
|
if (invert)
|
2013-08-05 09:27:31 +00:00
|
|
|
ucontrol->value.integer.value[0] = max - val;
|
|
|
|
else
|
|
|
|
ucontrol->value.integer.value[0] = val;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
|
|
|
if (invert)
|
|
|
|
ucontrol->value.integer.value[1] = max - rval;
|
|
|
|
else
|
|
|
|
ucontrol->value.integer.value[1] = rval;
|
|
|
|
}
|
|
|
|
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
return 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_put_volsw - dapm mixer set callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 12:18:17 +00:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Callback to set the value of a dapm mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2008-07-29 10:42:26 +00:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2013-10-06 11:43:49 +00:00
|
|
|
int reg = mc->reg;
|
2008-07-29 14:22:24 +00:00
|
|
|
unsigned int shift = mc->shift;
|
2008-07-29 10:42:26 +00:00
|
|
|
int max = mc->max;
|
2016-11-02 07:35:59 +00:00
|
|
|
unsigned int width = fls(max);
|
|
|
|
unsigned int mask = (1 << width) - 1;
|
2008-07-29 14:22:24 +00:00
|
|
|
unsigned int invert = mc->invert;
|
2016-11-02 07:35:59 +00:00
|
|
|
unsigned int val, rval = 0;
|
|
|
|
int connect, rconnect = -1, change, reg_change = 0;
|
2018-02-14 15:39:05 +00:00
|
|
|
struct snd_soc_dapm_update update = {};
|
2013-12-13 12:13:49 +00:00
|
|
|
int ret = 0;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
val = (ucontrol->value.integer.value[0] & mask);
|
2012-06-18 20:41:28 +00:00
|
|
|
connect = !!val;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
if (invert)
|
2008-01-10 13:37:42 +00:00
|
|
|
val = max - val;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
|
|
|
rval = (ucontrol->value.integer.value[1] & mask);
|
|
|
|
rconnect = !!rval;
|
|
|
|
if (invert)
|
|
|
|
rval = max - rval;
|
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
/* This assumes field width < (bits in unsigned int / 2) */
|
|
|
|
if (width > sizeof(unsigned int) * 8 / 2)
|
|
|
|
dev_warn(dapm->dev,
|
|
|
|
"ASoC: control %s field width limit exceeded\n",
|
|
|
|
kcontrol->id.name);
|
|
|
|
change = dapm_kcontrol_set_value(kcontrol, val | (rval << width));
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2014-06-09 11:20:29 +00:00
|
|
|
if (reg != SND_SOC_NOPM) {
|
|
|
|
val = val << shift;
|
2016-11-02 07:35:59 +00:00
|
|
|
rval = rval << mc->rshift;
|
|
|
|
|
|
|
|
reg_change = soc_dapm_test_bits(dapm, reg, mask << shift, val);
|
2014-06-09 11:20:29 +00:00
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
if (snd_soc_volsw_is_stereo(mc))
|
|
|
|
reg_change |= soc_dapm_test_bits(dapm, mc->rreg,
|
|
|
|
mask << mc->rshift,
|
|
|
|
rval);
|
2014-06-09 11:20:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (change || reg_change) {
|
|
|
|
if (reg_change) {
|
2016-11-02 07:35:59 +00:00
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
|
|
|
update.has_second_set = true;
|
|
|
|
update.reg2 = mc->rreg;
|
|
|
|
update.mask2 = mask << mc->rshift;
|
|
|
|
update.val2 = rval;
|
|
|
|
}
|
2014-06-09 11:20:29 +00:00
|
|
|
update.kcontrol = kcontrol;
|
|
|
|
update.reg = reg;
|
2016-11-02 07:35:59 +00:00
|
|
|
update.mask = mask << shift;
|
2014-06-09 11:20:29 +00:00
|
|
|
update.val = val;
|
|
|
|
card->update = &update;
|
2013-10-06 11:43:49 +00:00
|
|
|
}
|
2010-12-14 16:13:57 +00:00
|
|
|
|
2016-11-02 07:35:59 +00:00
|
|
|
ret = soc_dapm_mixer_update_power(card, kcontrol, connect,
|
|
|
|
rconnect);
|
2011-04-28 23:38:00 +00:00
|
|
|
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = NULL;
|
2009-12-07 18:09:03 +00:00
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2013-12-13 12:13:49 +00:00
|
|
|
|
|
|
|
if (ret > 0)
|
2020-03-12 09:52:14 +00:00
|
|
|
snd_soc_dpcm_runtime_update(card);
|
2013-12-13 12:13:49 +00:00
|
|
|
|
2013-07-24 13:27:35 +00:00
|
|
|
return change;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 12:18:17 +00:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Callback to get the value of a dapm enumerated double mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
|
2006-10-06 16:32:18 +00:00
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2014-02-28 07:31:04 +00:00
|
|
|
unsigned int reg_val, val;
|
2013-12-13 12:13:49 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2015-05-01 11:37:26 +00:00
|
|
|
if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
|
ASoC: soc-component: merge snd_soc_component_read() and snd_soc_component_read32()
We had read/write function for Codec, Platform, etc,
but these has been merged into snd_soc_component_read/write().
Internally, it is using regmap or driver function.
In read case, each styles are like below
regmap
ret = regmap_read(..., reg, &val);
driver function
val = xxx->read(..., reg);
Because of this kind of different style, to keep same read style,
when we merged each read function into snd_soc_component_read(),
we created snd_soc_component_read32(), like below.
commit 738b49efe6c6 ("ASoC: add snd_soc_component_read32")
(1) val = snd_soc_component_read32(component, reg);
(2) ret = snd_soc_component_read(component, reg, &val);
Many drivers are using snd_soc_component_read32(), and
some drivers are using snd_soc_component_read() today.
In generally, we don't check read function successes,
because, we will have many other issues at initial timing
if read function didn't work.
Now we can use soc_component_err() when error case.
This means, it is easy to notice if error occurred.
This patch aggressively merge snd_soc_component_read() and _read32(),
and makes snd_soc_component_read/write() as generally style.
This patch do
1) merge snd_soc_component_read() and snd_soc_component_read32()
2) it uses soc_component_err() when error case (easy to notice)
3) keeps read32 for now by #define
4) update snd_soc_component_read() for all drivers
Because _read() user drivers are not too many, this patch changes
all user drivers.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Link: https://lore.kernel.org/r/87sgev4mfl.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-06-16 05:19:41 +00:00
|
|
|
reg_val = soc_dapm_read(dapm, e->reg);
|
2014-08-08 15:29:35 +00:00
|
|
|
} else {
|
2014-02-28 07:31:11 +00:00
|
|
|
reg_val = dapm_kcontrol_get_value(kcontrol);
|
2014-08-08 15:29:35 +00:00
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2009-01-05 07:54:57 +00:00
|
|
|
|
|
|
|
val = (reg_val >> e->shift_l) & e->mask;
|
2014-02-28 07:31:04 +00:00
|
|
|
ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
|
2009-01-05 07:54:57 +00:00
|
|
|
if (e->shift_l != e->shift_r) {
|
|
|
|
val = (reg_val >> e->shift_r) & e->mask;
|
2014-02-28 07:31:04 +00:00
|
|
|
val = snd_soc_enum_val_to_item(e, val);
|
|
|
|
ucontrol->value.enumerated.item[1] = val;
|
2009-01-05 07:54:57 +00:00
|
|
|
}
|
|
|
|
|
2014-08-08 15:29:35 +00:00
|
|
|
return 0;
|
2009-01-05 07:54:57 +00:00
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
|
2009-01-05 07:54:57 +00:00
|
|
|
|
2020-02-14 10:57:43 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to set the value of a dapm enumerated double mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2009-01-05 07:54:57 +00:00
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
|
|
|
|
struct snd_soc_card *card = dapm->card;
|
2009-01-08 11:34:29 +00:00
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2014-02-28 07:31:04 +00:00
|
|
|
unsigned int *item = ucontrol->value.enumerated.item;
|
2015-05-01 11:37:26 +00:00
|
|
|
unsigned int val, change, reg_change = 0;
|
2009-06-07 05:49:11 +00:00
|
|
|
unsigned int mask;
|
2018-02-14 15:39:05 +00:00
|
|
|
struct snd_soc_dapm_update update = {};
|
2013-12-13 12:13:49 +00:00
|
|
|
int ret = 0;
|
2009-01-05 07:54:57 +00:00
|
|
|
|
2014-02-28 07:31:04 +00:00
|
|
|
if (item[0] >= e->items)
|
2009-01-05 07:54:57 +00:00
|
|
|
return -EINVAL;
|
2014-02-28 07:31:04 +00:00
|
|
|
|
|
|
|
val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
|
2009-01-05 07:54:57 +00:00
|
|
|
mask = e->mask << e->shift_l;
|
|
|
|
if (e->shift_l != e->shift_r) {
|
2014-02-28 07:31:04 +00:00
|
|
|
if (item[1] > e->items)
|
2009-01-05 07:54:57 +00:00
|
|
|
return -EINVAL;
|
2016-08-27 11:27:59 +00:00
|
|
|
val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
|
2009-01-05 07:54:57 +00:00
|
|
|
mask |= e->mask << e->shift_r;
|
|
|
|
}
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2011-04-28 23:38:00 +00:00
|
|
|
|
2015-05-01 11:37:26 +00:00
|
|
|
change = dapm_kcontrol_set_value(kcontrol, val);
|
|
|
|
|
2014-02-28 07:31:11 +00:00
|
|
|
if (e->reg != SND_SOC_NOPM)
|
2015-05-01 11:37:26 +00:00
|
|
|
reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
|
2014-02-28 07:31:11 +00:00
|
|
|
|
2015-05-01 11:37:26 +00:00
|
|
|
if (change || reg_change) {
|
|
|
|
if (reg_change) {
|
2014-02-28 07:31:11 +00:00
|
|
|
update.kcontrol = kcontrol;
|
|
|
|
update.reg = e->reg;
|
|
|
|
update.mask = mask;
|
|
|
|
update.val = val;
|
|
|
|
card->update = &update;
|
|
|
|
}
|
2009-10-05 15:24:26 +00:00
|
|
|
|
2014-02-28 07:31:04 +00:00
|
|
|
ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
|
2011-04-28 23:38:00 +00:00
|
|
|
|
2013-07-29 15:13:55 +00:00
|
|
|
card->update = NULL;
|
2011-04-28 23:38:00 +00:00
|
|
|
}
|
2009-01-05 07:54:57 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2013-12-13 12:13:49 +00:00
|
|
|
|
|
|
|
if (ret > 0)
|
2020-03-12 09:52:14 +00:00
|
|
|
snd_soc_dpcm_runtime_update(card);
|
2013-12-13 12:13:49 +00:00
|
|
|
|
2010-12-14 16:13:57 +00:00
|
|
|
return change;
|
2009-01-05 07:54:57 +00:00
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
|
2009-01-05 07:54:57 +00:00
|
|
|
|
2009-02-28 21:14:20 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_info_pin_switch - Info for a pin switch
|
|
|
|
*
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information about a pin switch control.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_get_pin_switch - Get information for a pin switch
|
|
|
|
*
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: Value
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2012-02-15 01:11:15 +00:00
|
|
|
struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
|
2009-02-28 21:14:20 +00:00
|
|
|
const char *pin = (const char *)kcontrol->private_value;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2009-02-28 21:14:20 +00:00
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] =
|
2012-02-15 01:11:15 +00:00
|
|
|
snd_soc_dapm_get_pin_status(&card->dapm, pin);
|
2009-02-28 21:14:20 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2009-02-28 21:14:20 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_put_pin_switch - Set information for a pin switch
|
|
|
|
*
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: Value
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2012-02-15 01:11:15 +00:00
|
|
|
struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
|
2009-02-28 21:14:20 +00:00
|
|
|
const char *pin = (const char *)kcontrol->private_value;
|
2021-10-06 14:17:12 +00:00
|
|
|
int ret;
|
2009-02-28 21:14:20 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2021-11-05 09:09:25 +00:00
|
|
|
ret = __snd_soc_dapm_set_pin(&card->dapm, pin,
|
|
|
|
!!ucontrol->value.integer.value[0]);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2009-02-28 21:14:20 +00:00
|
|
|
|
2012-03-07 10:38:26 +00:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2021-10-06 14:17:12 +00:00
|
|
|
return ret;
|
2009-02-28 21:14:20 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
|
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
struct snd_soc_dapm_widget *
|
|
|
|
snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
|
2012-02-16 19:07:13 +00:00
|
|
|
const struct snd_soc_dapm_widget *widget)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2015-08-11 19:38:00 +00:00
|
|
|
enum snd_soc_dapm_direction dir;
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
2014-06-16 16:13:01 +00:00
|
|
|
const char *prefix;
|
2022-09-05 23:17:57 +00:00
|
|
|
int ret = -ENOMEM;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
|
|
|
if ((w = dapm_cnew_widget(widget)) == NULL)
|
2022-09-05 23:17:57 +00:00
|
|
|
goto cnew_failed;
|
|
|
|
|
|
|
|
prefix = soc_dapm_prefix(dapm);
|
|
|
|
if (prefix)
|
|
|
|
w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
|
|
|
|
else
|
|
|
|
w->name = kstrdup_const(widget->name, GFP_KERNEL);
|
|
|
|
if (!w->name)
|
|
|
|
goto name_failed;
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2012-01-21 21:14:48 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_regulator_supply:
|
2022-10-25 15:01:49 +00:00
|
|
|
w->regulator = devm_regulator_get(dapm->dev, widget->name);
|
2012-03-09 17:20:16 +00:00
|
|
|
if (IS_ERR(w->regulator)) {
|
|
|
|
ret = PTR_ERR(w->regulator);
|
2018-09-05 14:20:58 +00:00
|
|
|
goto request_failed;
|
2012-01-21 21:14:48 +00:00
|
|
|
}
|
2013-01-10 19:33:47 +00:00
|
|
|
|
2013-07-29 15:14:01 +00:00
|
|
|
if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
|
2013-01-10 19:33:47 +00:00
|
|
|
ret = regulator_allow_bypass(w->regulator, true);
|
|
|
|
if (ret != 0)
|
2018-09-05 14:20:58 +00:00
|
|
|
dev_warn(dapm->dev,
|
2014-02-18 16:05:27 +00:00
|
|
|
"ASoC: Failed to bypass %s: %d\n",
|
2013-01-10 19:33:47 +00:00
|
|
|
w->name, ret);
|
|
|
|
}
|
2012-01-21 21:14:48 +00:00
|
|
|
break;
|
2018-03-10 02:37:27 +00:00
|
|
|
case snd_soc_dapm_pinctrl:
|
|
|
|
w->pinctrl = devm_pinctrl_get(dapm->dev);
|
2018-08-28 13:35:03 +00:00
|
|
|
if (IS_ERR(w->pinctrl)) {
|
2018-03-10 02:37:27 +00:00
|
|
|
ret = PTR_ERR(w->pinctrl);
|
2018-09-05 14:20:58 +00:00
|
|
|
goto request_failed;
|
2018-03-10 02:37:27 +00:00
|
|
|
}
|
2020-02-19 09:38:38 +00:00
|
|
|
|
|
|
|
/* set to sleep_state when initializing */
|
|
|
|
dapm_pinctrl_event(w, NULL, SND_SOC_DAPM_POST_PMD);
|
2018-03-10 02:37:27 +00:00
|
|
|
break;
|
2012-05-24 13:26:25 +00:00
|
|
|
case snd_soc_dapm_clock_supply:
|
2012-06-04 07:14:13 +00:00
|
|
|
w->clk = devm_clk_get(dapm->dev, w->name);
|
2012-05-24 13:26:25 +00:00
|
|
|
if (IS_ERR(w->clk)) {
|
|
|
|
ret = PTR_ERR(w->clk);
|
2018-09-05 14:20:58 +00:00
|
|
|
goto request_failed;
|
2012-05-24 13:26:25 +00:00
|
|
|
}
|
|
|
|
break;
|
2012-01-21 21:14:48 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2011-10-08 13:04:50 +00:00
|
|
|
switch (w->id) {
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
case snd_soc_dapm_mic:
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SOURCE;
|
2011-10-08 13:04:50 +00:00
|
|
|
w->power_check = dapm_generic_check_power;
|
|
|
|
break;
|
2014-12-21 10:05:44 +00:00
|
|
|
case snd_soc_dapm_input:
|
|
|
|
if (!dapm->card->fully_routed)
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SOURCE;
|
2014-12-21 10:05:44 +00:00
|
|
|
w->power_check = dapm_generic_check_power;
|
|
|
|
break;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
case snd_soc_dapm_spk:
|
|
|
|
case snd_soc_dapm_hp:
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SINK;
|
2011-10-08 13:04:50 +00:00
|
|
|
w->power_check = dapm_generic_check_power;
|
|
|
|
break;
|
2014-12-21 10:05:44 +00:00
|
|
|
case snd_soc_dapm_output:
|
|
|
|
if (!dapm->card->fully_routed)
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SINK;
|
2014-12-21 10:05:44 +00:00
|
|
|
w->power_check = dapm_generic_check_power;
|
|
|
|
break;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
case snd_soc_dapm_vmid:
|
|
|
|
case snd_soc_dapm_siggen:
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SOURCE;
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
w->power_check = dapm_always_on_check_power;
|
|
|
|
break;
|
2015-11-23 15:52:30 +00:00
|
|
|
case snd_soc_dapm_sink:
|
|
|
|
w->is_ep = SND_SOC_DAPM_EP_SINK;
|
|
|
|
w->power_check = dapm_always_on_check_power;
|
|
|
|
break;
|
|
|
|
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
case snd_soc_dapm_mux:
|
2015-05-01 16:02:43 +00:00
|
|
|
case snd_soc_dapm_demux:
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
case snd_soc_dapm_switch:
|
|
|
|
case snd_soc_dapm_mixer:
|
|
|
|
case snd_soc_dapm_mixer_named_ctl:
|
2013-07-18 21:03:01 +00:00
|
|
|
case snd_soc_dapm_adc:
|
|
|
|
case snd_soc_dapm_aif_out:
|
|
|
|
case snd_soc_dapm_dac:
|
|
|
|
case snd_soc_dapm_aif_in:
|
2011-10-08 13:04:50 +00:00
|
|
|
case snd_soc_dapm_pga:
|
2019-03-02 01:08:53 +00:00
|
|
|
case snd_soc_dapm_buffer:
|
|
|
|
case snd_soc_dapm_scheduler:
|
|
|
|
case snd_soc_dapm_effect:
|
|
|
|
case snd_soc_dapm_src:
|
|
|
|
case snd_soc_dapm_asrc:
|
|
|
|
case snd_soc_dapm_encoder:
|
|
|
|
case snd_soc_dapm_decoder:
|
2011-10-08 13:04:50 +00:00
|
|
|
case snd_soc_dapm_out_drv:
|
|
|
|
case snd_soc_dapm_micbias:
|
|
|
|
case snd_soc_dapm_line:
|
2012-04-04 21:12:09 +00:00
|
|
|
case snd_soc_dapm_dai_link:
|
2014-10-20 17:36:38 +00:00
|
|
|
case snd_soc_dapm_dai_out:
|
|
|
|
case snd_soc_dapm_dai_in:
|
2011-10-08 13:04:50 +00:00
|
|
|
w->power_check = dapm_generic_check_power;
|
|
|
|
break;
|
|
|
|
case snd_soc_dapm_supply:
|
2012-01-21 21:14:48 +00:00
|
|
|
case snd_soc_dapm_regulator_supply:
|
2018-03-10 02:37:27 +00:00
|
|
|
case snd_soc_dapm_pinctrl:
|
2012-05-24 13:26:25 +00:00
|
|
|
case snd_soc_dapm_clock_supply:
|
2013-08-05 09:27:31 +00:00
|
|
|
case snd_soc_dapm_kcontrol:
|
ASoC: dapm: Introduce toplevel widget categories
DAPM widgets can be classified into four categories:
* supply: Supply widgets do not affect the power state of their
non-supply widget neighbors and unlike other widgets a
supply widget is not powered up when it is on an active
path, but when at least on of its neighbors is powered up.
* source: A source is a widget that receives data from outside the
DAPM graph or generates data. This can for example be a
microphone, the playback DMA or a signal generator. A source
widget will be considered powered up if there is an active
path to a sink widget.
* sink: A sink is a widget that transmits data to somewhere outside
of the DAPM graph. This can e.g. be a speaker or the capture
DMA. A sink widget will be considered powered up if there is
an active path from a source widget.
* normal: Normal widgets are widgets not covered by the categories
above. A normal widget will be considered powered up if it
is on an active path between a source widget and a sink
widget.
The way the number of input and output paths for a widget is calculated
depends on its category. There are a bunch of factors which decide which
category a widget is. Currently there is no formal classification of these
categories and we calculate the category of the widget based on these
factors whenever we want to know it. This is at least once for every widget
during each power update sequence. The factors which determine the category
of the widgets are mostly static though and if at all change rather seldom.
This patch introduces three new per widget flags, one for each of non-normal
widgets categories. Instead of re-computing the category each time we want
to know them the flags will be checked. For the majority of widgets the
category is solely determined by the widget id, which means it never changes
and only has to be set once when the widget is created. The only widgets
with dynamic categories are:
snd_soc_dapm_dai_out: Is considered a sink iff the capture stream is
active, otherwise normal.
snd_soc_dapm_dai_in: Is considered a source iff the playback stream
is active, otherwise normal.
snd_soc_dapm_input: Is considered a sink iff it has no outgoing
paths, otherwise normal.
snd_soc_dapm_output: Is considered a source iff it has no incoming
paths, otherwise normal.
snd_soc_dapm_line: Is considered a sink iff it has no outgoing paths
and is considered a source iff it has no incoming paths,
otherwise normal.
For snd_soc_dapm_dai_out/snd_soc_dapm_dai_in widgets the category will be
updated when a stream is started or stopped. For the other dynamic widgets
the category will be updated when a path connecting to it is added or
removed.
Introducing those new widget categories allows to make
is_connected_{output,input}_ep, which are among the hottest paths of the
DAPM algorithm, more generic and significantly shorter.
The before and after sizes for is_connected_{output,input}_ep are:
On ARM (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 480 340 -140
is_connected_input_ep 456 352 -104
On amd64 (defconfig + CONFIG_SND_SOC):
function old new delta
is_connected_output_ep 579 427 -152
is_connected_input_ep 563 427 -136
Which is about a 25%-30% decrease, other architectures are expected to have
similar numbers. At the same time the size of the snd_soc_dapm_widget struct
does not change since the new flags are stored in the same word as the
existing flags.
Note: that since the per widget 'ext' flag was only used to decide whether a
snd_soc_dapm_input or snd_soc_dapm_output widget was a source or a sink it
is now unused and can be removed.
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@kernel.org>
2014-10-25 15:41:59 +00:00
|
|
|
w->is_supply = 1;
|
2011-10-08 13:04:50 +00:00
|
|
|
w->power_check = dapm_supply_check_power;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
w->power_check = dapm_always_on_check_power;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-11-05 13:53:46 +00:00
|
|
|
w->dapm = dapm;
|
2006-10-06 16:32:18 +00:00
|
|
|
INIT_LIST_HEAD(&w->list);
|
2011-10-03 20:06:40 +00:00
|
|
|
INIT_LIST_HEAD(&w->dirty);
|
2020-03-09 04:08:21 +00:00
|
|
|
/* see for_each_card_widgets */
|
2015-05-01 16:02:42 +00:00
|
|
|
list_add_tail(&w->list, &dapm->card->widgets);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
snd_soc_dapm_for_each_direction(dir) {
|
|
|
|
INIT_LIST_HEAD(&w->edges[dir]);
|
|
|
|
w->endpoints[dir] = -1;
|
|
|
|
}
|
2014-10-25 15:42:03 +00:00
|
|
|
|
2016-08-16 14:56:17 +00:00
|
|
|
/* machine layer sets up unconnected pins and insertions */
|
2006-10-06 16:32:18 +00:00
|
|
|
w->connected = 1;
|
2012-02-16 19:07:13 +00:00
|
|
|
return w;
|
2018-09-05 14:20:58 +00:00
|
|
|
|
|
|
|
request_failed:
|
2022-09-14 13:33:55 +00:00
|
|
|
dev_err_probe(dapm->dev, ret, "ASoC: Failed to request %s\n",
|
|
|
|
w->name);
|
2022-09-05 23:17:57 +00:00
|
|
|
kfree_const(w->name);
|
|
|
|
name_failed:
|
2019-07-22 13:57:44 +00:00
|
|
|
kfree_const(w->sname);
|
|
|
|
kfree(w);
|
2022-09-05 23:17:57 +00:00
|
|
|
cnew_failed:
|
2018-09-05 14:20:58 +00:00
|
|
|
return ERR_PTR(ret);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 14:20:59 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_new_control - create new dapm control
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @widget: widget template
|
|
|
|
*
|
|
|
|
* Creates new DAPM control based upon a template.
|
|
|
|
*
|
|
|
|
* Returns a widget pointer on success or an error pointer on failure
|
|
|
|
*/
|
|
|
|
struct snd_soc_dapm_widget *
|
|
|
|
snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
|
|
|
|
const struct snd_soc_dapm_widget *widget)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2018-09-05 14:20:59 +00:00
|
|
|
w = snd_soc_dapm_new_control_unlocked(dapm, widget);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2018-09-05 14:20:59 +00:00
|
|
|
|
|
|
|
return w;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
|
|
|
|
|
2008-05-13 12:51:19 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_new_controls - create new dapm controls
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-05-13 12:51:19 +00:00
|
|
|
* @widget: widget array
|
|
|
|
* @num: number of widgets
|
|
|
|
*
|
|
|
|
* Creates new DAPM controls based upon the templates.
|
|
|
|
*
|
|
|
|
* Returns 0 for success else error.
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
|
2008-05-13 12:51:19 +00:00
|
|
|
const struct snd_soc_dapm_widget *widget,
|
|
|
|
int num)
|
|
|
|
{
|
2012-02-16 19:07:13 +00:00
|
|
|
int i;
|
2012-04-13 19:25:43 +00:00
|
|
|
int ret = 0;
|
2008-05-13 12:51:19 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(dapm);
|
2008-05-13 12:51:19 +00:00
|
|
|
for (i = 0; i < num; i++) {
|
2021-08-05 01:11:41 +00:00
|
|
|
struct snd_soc_dapm_widget *w = snd_soc_dapm_new_control_unlocked(dapm, widget);
|
ASoC: dapm: handle probe deferrals
This starts to handle probe deferrals on regulators and clocks
on the ASoC DAPM.
I came to this patch after audio stopped working on Ux500 ages
ago and I finally looked into it to see what is wrong. I had
messages like this in the console since a while back:
ab8500-codec.0: ASoC: Failed to request audioclk: -517
ab8500-codec.0: ASoC: Failed to create DAPM control audioclk
ab8500-codec.0: Failed to create new controls -12
snd-soc-mop500.0: ASoC: failed to instantiate card -12
snd-soc-mop500.0: Error: snd_soc_register_card failed (-12)!
snd-soc-mop500: probe of snd-soc-mop500.0 failed with error -12
Apparently because the widget table for the codec looks like
this (sound/soc/codecs/ab8500-codec.c):
static const struct snd_soc_dapm_widget ab8500_dapm_widgets[] = {
/* Clocks */
SND_SOC_DAPM_CLOCK_SUPPLY("audioclk"),
/* Regulators */
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AUD", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC1", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC2", 0, 0),
SND_SOC_DAPM_REGULATOR_SUPPLY("V-DMIC", 0, 0),
So when we call snd_soc_register_codec() and any of these widgets
get a deferred probe we do not get an -EPROBE_DEFER (-517) back as
we should and instead we just fail. Apparently the code assumes
that clocks and regulators must be available at this point and
not defer.
After this patch it rather looks like this:
ab8500-codec.0: Failed to create new controls -517
snd-soc-mop500.0: ASoC: failed to instantiate card -517
snd-soc-mop500.0: Error: snd_soc_register_card failed (-517)!
(...)
abx500-clk.0: registered clocks for ab850x
snd-soc-mop500.0: ab8500-codec-dai.0 <-> ux500-msp-i2s.1 mapping ok
snd-soc-mop500.0: ab8500-codec-dai.1 <-> ux500-msp-i2s.3 mapping ok
I'm pretty happy about the patch as it it, but I'm a bit
uncertain on how to proceed: there are a lot of users of the
external functions snd_soc_dapm_new_control() (111 sites)
and that will now return an occassional error pointer, which
is not handled in the calling sites.
I want an indication from the maintainers whether I should just
go in and augment all these call sites, or if deferred probe
is frowned upon when it leads to this much overhead.
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
2017-01-13 09:23:52 +00:00
|
|
|
if (IS_ERR(w)) {
|
|
|
|
ret = PTR_ERR(w);
|
2012-04-13 19:25:43 +00:00
|
|
|
break;
|
2008-12-18 11:19:30 +00:00
|
|
|
}
|
2008-05-13 12:51:19 +00:00
|
|
|
widget++;
|
|
|
|
}
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2012-04-13 19:25:43 +00:00
|
|
|
return ret;
|
2008-05-13 12:51:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
static int
|
|
|
|
snd_soc_dai_link_event_pre_pmu(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_pcm_substream *substream)
|
2012-04-04 21:12:09 +00:00
|
|
|
{
|
2018-09-05 14:21:01 +00:00
|
|
|
struct snd_soc_dapm_path *path;
|
2012-04-04 21:12:09 +00:00
|
|
|
struct snd_soc_dai *source, *sink;
|
2020-07-20 01:17:39 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
|
2012-04-26 18:12:21 +00:00
|
|
|
struct snd_pcm_hw_params *params = NULL;
|
2019-07-25 16:59:46 +00:00
|
|
|
const struct snd_soc_pcm_stream *config = NULL;
|
2019-07-25 16:59:48 +00:00
|
|
|
struct snd_pcm_runtime *runtime = NULL;
|
2018-07-25 20:43:26 +00:00
|
|
|
unsigned int fmt;
|
2019-07-26 12:33:27 +00:00
|
|
|
int ret = 0;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2022-09-08 02:45:12 +00:00
|
|
|
/*
|
|
|
|
* NOTE
|
|
|
|
*
|
|
|
|
* snd_pcm_hw_params is quite large (608 bytes on arm64) and is
|
|
|
|
* starting to get a bit excessive for allocation on the stack,
|
|
|
|
* especially when you're building with some of the KASAN type
|
|
|
|
* stuff that increases stack usage.
|
|
|
|
* So, we use kzalloc()/kfree() for params in this function.
|
|
|
|
*/
|
2019-07-25 16:59:46 +00:00
|
|
|
params = kzalloc(sizeof(*params), GFP_KERNEL);
|
|
|
|
if (!params)
|
|
|
|
return -ENOMEM;
|
2018-09-05 14:21:02 +00:00
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
|
|
|
|
if (!runtime) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
substream->runtime = runtime;
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path) {
|
|
|
|
source = path->source->priv;
|
|
|
|
|
|
|
|
ret = snd_soc_dai_startup(source, substream);
|
2021-03-15 00:58:37 +00:00
|
|
|
if (ret < 0)
|
2019-07-25 16:59:46 +00:00
|
|
|
goto out;
|
2021-03-15 00:58:37 +00:00
|
|
|
|
2020-05-15 00:46:33 +00:00
|
|
|
snd_soc_dai_activate(source, substream->stream);
|
2019-07-25 16:59:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
|
|
|
|
|
|
|
ret = snd_soc_dai_startup(sink, substream);
|
2021-03-15 00:58:37 +00:00
|
|
|
if (ret < 0)
|
2019-07-25 16:59:46 +00:00
|
|
|
goto out;
|
2021-03-15 00:58:37 +00:00
|
|
|
|
2020-05-15 00:46:33 +00:00
|
|
|
snd_soc_dai_activate(sink, substream->stream);
|
2019-07-25 16:59:46 +00:00
|
|
|
}
|
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
substream->hw_opened = 1;
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
/*
|
|
|
|
* Note: getting the config after .startup() gives a chance to
|
|
|
|
* either party on the link to alter the configuration if
|
|
|
|
* necessary
|
|
|
|
*/
|
2023-04-02 22:59:35 +00:00
|
|
|
config = rtd->dai_link->c2c_params + rtd->c2c_params_select;
|
2022-09-05 23:17:43 +00:00
|
|
|
if (!config) {
|
2019-07-25 16:59:46 +00:00
|
|
|
dev_err(w->dapm->dev, "ASoC: link config missing\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-04-04 21:12:09 +00:00
|
|
|
|
|
|
|
/* Be a little careful as we don't want to overflow the mask array */
|
2022-09-08 02:45:27 +00:00
|
|
|
if (!config->formats) {
|
|
|
|
dev_warn(w->dapm->dev, "ASoC: Invalid format was specified\n");
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
ret = -EINVAL;
|
2012-04-26 18:12:21 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2022-09-08 02:45:27 +00:00
|
|
|
fmt = ffs(config->formats) - 1;
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
|
2012-04-26 18:12:21 +00:00
|
|
|
hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
|
2012-04-04 21:12:09 +00:00
|
|
|
config->rate_min;
|
2012-04-26 18:12:21 +00:00
|
|
|
hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
|
2012-04-04 21:12:09 +00:00
|
|
|
config->rate_max;
|
2012-04-26 18:12:21 +00:00
|
|
|
hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
|
2012-04-04 21:12:09 +00:00
|
|
|
= config->channels_min;
|
2012-04-26 18:12:21 +00:00
|
|
|
hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
|
2012-04-04 21:12:09 +00:00
|
|
|
= config->channels_max;
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path) {
|
|
|
|
source = path->source->priv;
|
|
|
|
|
|
|
|
ret = snd_soc_dai_hw_params(source, substream, params);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dapm_update_dai_unlocked(substream, params, source);
|
|
|
|
}
|
|
|
|
|
|
|
|
substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
|
|
|
|
|
|
|
ret = snd_soc_dai_hw_params(sink, substream, params);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dapm_update_dai_unlocked(substream, params, sink);
|
|
|
|
}
|
|
|
|
|
2019-07-25 16:59:49 +00:00
|
|
|
runtime->format = params_format(params);
|
|
|
|
runtime->subformat = params_subformat(params);
|
|
|
|
runtime->channels = params_channels(params);
|
|
|
|
runtime->rate = params_rate(params);
|
|
|
|
|
2019-07-25 16:59:46 +00:00
|
|
|
out:
|
2022-09-08 02:45:12 +00:00
|
|
|
/* see above NOTE */
|
2019-07-25 16:59:46 +00:00
|
|
|
kfree(params);
|
2022-09-08 02:45:12 +00:00
|
|
|
|
2019-07-26 12:33:27 +00:00
|
|
|
return ret;
|
2019-07-25 16:59:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
|
|
|
|
struct snd_kcontrol *kcontrol, int event)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_path *path;
|
|
|
|
struct snd_soc_dai *source, *sink;
|
2019-07-25 16:59:48 +00:00
|
|
|
struct snd_pcm_substream *substream = w->priv;
|
|
|
|
int ret = 0, saved_stream = substream->stream;
|
2019-07-25 16:59:46 +00:00
|
|
|
|
|
|
|
if (WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
|
|
|
|
list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-04-04 21:12:09 +00:00
|
|
|
switch (event) {
|
|
|
|
case SND_SOC_DAPM_PRE_PMU:
|
2019-07-25 16:59:48 +00:00
|
|
|
ret = snd_soc_dai_link_event_pre_pmu(w, substream);
|
2019-07-25 16:59:46 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2019-01-31 13:30:18 +00:00
|
|
|
|
2012-04-04 21:12:09 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_DAPM_POST_PMU:
|
2018-09-05 14:21:01 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
|
|
|
|
2021-03-15 00:58:37 +00:00
|
|
|
snd_soc_dai_digital_mute(sink, 0, SNDRV_PCM_STREAM_PLAYBACK);
|
2018-09-05 14:21:01 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
2012-04-04 21:12:09 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SND_SOC_DAPM_PRE_PMD:
|
2018-09-05 14:21:01 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
|
|
|
|
2021-03-15 00:58:37 +00:00
|
|
|
snd_soc_dai_digital_mute(sink, 1, SNDRV_PCM_STREAM_PLAYBACK);
|
2018-09-05 14:21:01 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_CAPTURE;
|
2018-09-05 14:21:01 +00:00
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path) {
|
|
|
|
source = path->source->priv;
|
ASoC: soc-dai: add mark for snd_soc_dai_hw_params/free()
soc_pcm_hw_params() does rollback when failed (A),
but, it is almost same as soc_pcm_hw_free().
static int soc_pcm_hw_params(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return ret;
^ component_err:
| ...
| interface_err:
(A) ...
| codec_err:
| ...
v return ret;
}
The difference is
soc_pcm_hw_free() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_hw_free() and rollback.
Now, soc_pcm_hw_params/free() are handling
1) snd_soc_link_hw_params/free()
2) snd_soc_pcm_component_hw_params/free()
=> 3) snd_soc_dai_hw_params/free()
This patch is for 3) snd_soc_dai_hw_params/free().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when hw_params() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *previous* hw_params() only now,
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87imbxgqai.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-29 04:31:53 +00:00
|
|
|
snd_soc_dai_hw_free(source, substream, 0);
|
2019-07-25 16:59:44 +00:00
|
|
|
}
|
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
|
2019-07-25 16:59:44 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
ASoC: soc-dai: add mark for snd_soc_dai_hw_params/free()
soc_pcm_hw_params() does rollback when failed (A),
but, it is almost same as soc_pcm_hw_free().
static int soc_pcm_hw_params(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return ret;
^ component_err:
| ...
| interface_err:
(A) ...
| codec_err:
| ...
v return ret;
}
The difference is
soc_pcm_hw_free() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_hw_free() and rollback.
Now, soc_pcm_hw_params/free() are handling
1) snd_soc_link_hw_params/free()
2) snd_soc_pcm_component_hw_params/free()
=> 3) snd_soc_dai_hw_params/free()
This patch is for 3) snd_soc_dai_hw_params/free().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when hw_params() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *previous* hw_params() only now,
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87imbxgqai.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-29 04:31:53 +00:00
|
|
|
snd_soc_dai_hw_free(sink, substream, 0);
|
2019-07-25 16:59:44 +00:00
|
|
|
}
|
2018-10-11 16:28:28 +00:00
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_CAPTURE;
|
2019-07-25 16:59:44 +00:00
|
|
|
snd_soc_dapm_widget_for_each_source_path(w, path) {
|
|
|
|
source = path->source->priv;
|
2020-05-15 00:46:33 +00:00
|
|
|
snd_soc_dai_deactivate(source, substream->stream);
|
ASoC: soc-dai: add mark for snd_soc_dai_startup/shutdown()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
=> 1) snd_soc_dai_startup/shutdown()
2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
5) pm_runtime_put/get()
This patch is for 1) snd_soc_dai_startup/shutdown().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when startup() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* startup() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87lfgubwoc.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 00:00:40 +00:00
|
|
|
snd_soc_dai_shutdown(source, substream, 0);
|
2015-10-20 17:00:07 +00:00
|
|
|
}
|
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
|
2018-09-05 14:21:01 +00:00
|
|
|
snd_soc_dapm_widget_for_each_sink_path(w, path) {
|
|
|
|
sink = path->sink->priv;
|
2020-05-15 00:46:33 +00:00
|
|
|
snd_soc_dai_deactivate(sink, substream->stream);
|
ASoC: soc-dai: add mark for snd_soc_dai_startup/shutdown()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
=> 1) snd_soc_dai_startup/shutdown()
2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
5) pm_runtime_put/get()
This patch is for 1) snd_soc_dai_startup/shutdown().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when startup() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* startup() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87lfgubwoc.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 00:00:40 +00:00
|
|
|
snd_soc_dai_shutdown(sink, substream, 0);
|
2015-10-20 17:00:07 +00:00
|
|
|
}
|
2012-04-04 21:12:09 +00:00
|
|
|
break;
|
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
case SND_SOC_DAPM_POST_PMD:
|
|
|
|
kfree(substream->runtime);
|
|
|
|
break;
|
|
|
|
|
2012-04-04 21:12:09 +00:00
|
|
|
default:
|
2013-11-06 10:07:19 +00:00
|
|
|
WARN(1, "Unknown event %d\n", event);
|
2015-09-10 12:31:44 +00:00
|
|
|
ret = -EINVAL;
|
2012-04-04 21:12:09 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 18:12:21 +00:00
|
|
|
out:
|
2019-07-25 16:59:48 +00:00
|
|
|
/* Restore the substream direction */
|
|
|
|
substream->stream = saved_stream;
|
2012-04-26 18:12:21 +00:00
|
|
|
return ret;
|
2012-04-04 21:12:09 +00:00
|
|
|
}
|
|
|
|
|
2015-02-02 17:06:44 +00:00
|
|
|
static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
|
2018-09-05 14:21:02 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = w->priv;
|
2015-02-02 17:06:44 +00:00
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
ucontrol->value.enumerated.item[0] = rtd->c2c_params_select;
|
2015-02-02 17:06:44 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
|
2018-09-05 14:21:02 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = w->priv;
|
2015-02-02 17:06:44 +00:00
|
|
|
|
|
|
|
/* Can't change the config when widget is already powered */
|
|
|
|
if (w->power)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
if (ucontrol->value.enumerated.item[0] == rtd->c2c_params_select)
|
2015-02-02 17:06:44 +00:00
|
|
|
return 0;
|
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
if (ucontrol->value.enumerated.item[0] >= rtd->dai_link->num_c2c_params)
|
2015-02-02 17:06:44 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
rtd->c2c_params_select = ucontrol->value.enumerated.item[0];
|
2015-02-02 17:06:44 +00:00
|
|
|
|
2021-10-06 14:17:12 +00:00
|
|
|
return 1;
|
2015-02-02 17:06:44 +00:00
|
|
|
}
|
|
|
|
|
2017-10-10 09:20:11 +00:00
|
|
|
static void
|
2017-09-29 04:52:39 +00:00
|
|
|
snd_soc_dapm_free_kcontrol(struct snd_soc_card *card,
|
|
|
|
unsigned long *private_value,
|
2023-04-02 22:59:35 +00:00
|
|
|
int num_c2c_params,
|
2017-09-29 04:52:39 +00:00
|
|
|
const char **w_param_text)
|
|
|
|
{
|
|
|
|
int count;
|
|
|
|
|
|
|
|
devm_kfree(card->dev, (void *)*private_value);
|
2019-03-22 12:30:09 +00:00
|
|
|
|
|
|
|
if (!w_param_text)
|
|
|
|
return;
|
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
for (count = 0 ; count < num_c2c_params; count++)
|
2017-09-29 04:52:39 +00:00
|
|
|
devm_kfree(card->dev, (void *)w_param_text[count]);
|
|
|
|
devm_kfree(card->dev, w_param_text);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new *
|
|
|
|
snd_soc_dapm_alloc_kcontrol(struct snd_soc_card *card,
|
|
|
|
char *link_name,
|
2023-04-02 22:59:35 +00:00
|
|
|
const struct snd_soc_pcm_stream *c2c_params,
|
|
|
|
int num_c2c_params, const char **w_param_text,
|
2017-09-29 04:52:39 +00:00
|
|
|
unsigned long *private_value)
|
2012-04-04 21:12:09 +00:00
|
|
|
{
|
2015-02-02 17:06:44 +00:00
|
|
|
struct soc_enum w_param_enum[] = {
|
|
|
|
SOC_ENUM_SINGLE(0, 0, 0, NULL),
|
|
|
|
};
|
|
|
|
struct snd_kcontrol_new kcontrol_dai_link[] = {
|
|
|
|
SOC_ENUM_EXT(NULL, w_param_enum[0],
|
|
|
|
snd_soc_dapm_dai_link_get,
|
|
|
|
snd_soc_dapm_dai_link_put),
|
|
|
|
};
|
2017-09-29 04:52:39 +00:00
|
|
|
struct snd_kcontrol_new *kcontrol_news;
|
2023-04-02 22:59:35 +00:00
|
|
|
const struct snd_soc_pcm_stream *config = c2c_params;
|
2017-09-29 04:52:39 +00:00
|
|
|
int count;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
for (count = 0 ; count < num_c2c_params; count++) {
|
2015-02-02 17:06:44 +00:00
|
|
|
if (!config->stream_name) {
|
|
|
|
dev_warn(card->dapm.dev,
|
|
|
|
"ASoC: anonymous config %d for dai link %s\n",
|
|
|
|
count, link_name);
|
|
|
|
w_param_text[count] =
|
2015-03-25 11:22:35 +00:00
|
|
|
devm_kasprintf(card->dev, GFP_KERNEL,
|
|
|
|
"Anonymous Configuration %d",
|
|
|
|
count);
|
2015-02-02 17:06:44 +00:00
|
|
|
} else {
|
|
|
|
w_param_text[count] = devm_kmemdup(card->dev,
|
|
|
|
config->stream_name,
|
|
|
|
strlen(config->stream_name) + 1,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
2017-09-29 04:52:39 +00:00
|
|
|
if (!w_param_text[count])
|
|
|
|
goto outfree_w_param;
|
2015-02-02 17:06:44 +00:00
|
|
|
config++;
|
|
|
|
}
|
2017-09-29 04:52:39 +00:00
|
|
|
|
2023-04-02 22:59:35 +00:00
|
|
|
w_param_enum[0].items = num_c2c_params;
|
2015-02-02 17:06:44 +00:00
|
|
|
w_param_enum[0].texts = w_param_text;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2017-09-29 04:52:39 +00:00
|
|
|
*private_value =
|
2015-02-02 17:06:44 +00:00
|
|
|
(unsigned long) devm_kmemdup(card->dev,
|
|
|
|
(void *)(kcontrol_dai_link[0].private_value),
|
|
|
|
sizeof(struct soc_enum), GFP_KERNEL);
|
2017-09-29 04:52:39 +00:00
|
|
|
if (!*private_value) {
|
2015-02-02 17:06:44 +00:00
|
|
|
dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
|
|
|
|
link_name);
|
2017-09-29 04:52:39 +00:00
|
|
|
goto outfree_w_param;
|
2015-02-02 17:06:44 +00:00
|
|
|
}
|
2017-09-29 04:52:39 +00:00
|
|
|
kcontrol_dai_link[0].private_value = *private_value;
|
2015-02-02 17:06:44 +00:00
|
|
|
/* duplicate kcontrol_dai_link on heap so that memory persists */
|
2017-09-29 04:52:39 +00:00
|
|
|
kcontrol_news = devm_kmemdup(card->dev, &kcontrol_dai_link[0],
|
2015-02-02 17:06:44 +00:00
|
|
|
sizeof(struct snd_kcontrol_new),
|
|
|
|
GFP_KERNEL);
|
2017-09-29 04:52:39 +00:00
|
|
|
if (!kcontrol_news) {
|
2015-02-02 17:06:44 +00:00
|
|
|
dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
|
|
|
|
link_name);
|
2017-09-29 04:52:39 +00:00
|
|
|
goto outfree_w_param;
|
2015-02-02 17:06:44 +00:00
|
|
|
}
|
2017-09-29 04:52:39 +00:00
|
|
|
return kcontrol_news;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2017-09-29 04:52:39 +00:00
|
|
|
outfree_w_param:
|
2023-04-02 22:59:35 +00:00
|
|
|
snd_soc_dapm_free_kcontrol(card, private_value, num_c2c_params, w_param_text);
|
2017-09-29 04:52:39 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-09-05 14:21:00 +00:00
|
|
|
static struct snd_soc_dapm_widget *
|
2019-07-25 16:59:48 +00:00
|
|
|
snd_soc_dapm_new_dai(struct snd_soc_card *card,
|
|
|
|
struct snd_pcm_substream *substream,
|
2019-07-25 16:59:45 +00:00
|
|
|
char *id)
|
2017-09-29 04:52:39 +00:00
|
|
|
{
|
2020-07-20 01:17:39 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
|
2017-09-29 04:52:39 +00:00
|
|
|
struct snd_soc_dapm_widget template;
|
|
|
|
struct snd_soc_dapm_widget *w;
|
2022-10-19 00:37:00 +00:00
|
|
|
const struct snd_kcontrol_new *kcontrol_news;
|
|
|
|
int num_kcontrols;
|
2017-09-29 04:52:39 +00:00
|
|
|
const char **w_param_text;
|
2019-03-22 16:23:39 +00:00
|
|
|
unsigned long private_value = 0;
|
2017-09-29 04:52:39 +00:00
|
|
|
char *link_name;
|
2022-10-19 00:37:00 +00:00
|
|
|
int ret = -ENOMEM;
|
2017-09-29 04:52:39 +00:00
|
|
|
|
|
|
|
link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
|
2019-07-25 16:59:45 +00:00
|
|
|
rtd->dai_link->name, id);
|
2017-09-29 04:52:39 +00:00
|
|
|
if (!link_name)
|
2022-10-19 00:37:00 +00:00
|
|
|
goto name_fail;
|
2017-09-29 04:52:39 +00:00
|
|
|
|
|
|
|
/* allocate memory for control, only in case of multiple configs */
|
2022-10-19 00:37:00 +00:00
|
|
|
w_param_text = NULL;
|
|
|
|
kcontrol_news = NULL;
|
|
|
|
num_kcontrols = 0;
|
2023-04-02 22:59:35 +00:00
|
|
|
if (rtd->dai_link->num_c2c_params > 1) {
|
2018-09-05 14:21:00 +00:00
|
|
|
w_param_text = devm_kcalloc(card->dev,
|
2023-04-02 22:59:35 +00:00
|
|
|
rtd->dai_link->num_c2c_params,
|
2018-09-05 14:21:00 +00:00
|
|
|
sizeof(char *), GFP_KERNEL);
|
2022-10-19 00:37:00 +00:00
|
|
|
if (!w_param_text)
|
2017-09-29 04:52:39 +00:00
|
|
|
goto param_fail;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2022-10-19 00:37:00 +00:00
|
|
|
num_kcontrols = 1;
|
|
|
|
kcontrol_news = snd_soc_dapm_alloc_kcontrol(card, link_name,
|
2023-04-02 22:59:35 +00:00
|
|
|
rtd->dai_link->c2c_params,
|
|
|
|
rtd->dai_link->num_c2c_params,
|
2022-10-19 00:37:00 +00:00
|
|
|
w_param_text, &private_value);
|
|
|
|
if (!kcontrol_news)
|
2017-09-29 04:52:39 +00:00
|
|
|
goto param_fail;
|
|
|
|
}
|
2022-10-19 00:37:00 +00:00
|
|
|
|
|
|
|
memset(&template, 0, sizeof(template));
|
|
|
|
template.reg = SND_SOC_NOPM;
|
|
|
|
template.id = snd_soc_dapm_dai_link;
|
|
|
|
template.name = link_name;
|
|
|
|
template.event = snd_soc_dai_link_event;
|
|
|
|
template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
|
|
|
|
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD;
|
|
|
|
template.kcontrol_news = kcontrol_news;
|
|
|
|
template.num_kcontrols = num_kcontrols;
|
|
|
|
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
|
2018-09-07 19:40:33 +00:00
|
|
|
if (IS_ERR(w)) {
|
|
|
|
ret = PTR_ERR(w);
|
2015-02-02 17:06:44 +00:00
|
|
|
goto outfree_kcontrol_news;
|
2018-09-07 19:40:33 +00:00
|
|
|
}
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2019-07-25 16:59:48 +00:00
|
|
|
w->priv = substream;
|
2012-04-04 21:12:09 +00:00
|
|
|
|
2018-09-05 14:21:00 +00:00
|
|
|
return w;
|
2015-02-02 17:06:44 +00:00
|
|
|
|
|
|
|
outfree_kcontrol_news:
|
|
|
|
devm_kfree(card->dev, (void *)template.kcontrol_news);
|
2018-09-05 14:21:00 +00:00
|
|
|
snd_soc_dapm_free_kcontrol(card, &private_value,
|
2023-04-02 22:59:35 +00:00
|
|
|
rtd->dai_link->num_c2c_params, w_param_text);
|
2017-09-29 04:52:39 +00:00
|
|
|
param_fail:
|
2015-02-02 17:06:44 +00:00
|
|
|
devm_kfree(card->dev, link_name);
|
2022-10-19 00:37:00 +00:00
|
|
|
name_fail:
|
|
|
|
dev_err(rtd->dev, "ASoC: Failed to create %s-%s widget: %d\n",
|
|
|
|
rtd->dai_link->name, id, ret);
|
2018-09-05 14:21:00 +00:00
|
|
|
return ERR_PTR(ret);
|
2012-04-04 21:12:09 +00:00
|
|
|
}
|
|
|
|
|
2022-03-11 15:35:29 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_new_dai_widgets - Create new DAPM widgets
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @dai: parent DAI
|
|
|
|
*
|
|
|
|
* Returns 0 on success, error code otherwise.
|
|
|
|
*/
|
2012-02-17 03:37:51 +00:00
|
|
|
int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_dai *dai)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2012-02-17 03:37:51 +00:00
|
|
|
struct snd_soc_dapm_widget template;
|
2006-10-06 16:32:18 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
|
2012-02-17 03:37:51 +00:00
|
|
|
WARN_ON(dapm->dev != dai->dev);
|
|
|
|
|
|
|
|
memset(&template, 0, sizeof(template));
|
|
|
|
template.reg = SND_SOC_NOPM;
|
|
|
|
|
|
|
|
if (dai->driver->playback.stream_name) {
|
2013-06-05 18:36:11 +00:00
|
|
|
template.id = snd_soc_dapm_dai_in;
|
2012-02-17 03:37:51 +00:00
|
|
|
template.name = dai->driver->playback.stream_name;
|
|
|
|
template.sname = dai->driver->playback.stream_name;
|
|
|
|
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_dbg(dai->dev, "ASoC: adding %s widget\n",
|
2012-02-17 03:37:51 +00:00
|
|
|
template.name);
|
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
w = snd_soc_dapm_new_control_unlocked(dapm, &template);
|
2018-09-05 14:20:58 +00:00
|
|
|
if (IS_ERR(w))
|
|
|
|
return PTR_ERR(w);
|
2012-02-17 03:37:51 +00:00
|
|
|
|
|
|
|
w->priv = dai;
|
2023-01-31 02:01:34 +00:00
|
|
|
snd_soc_dai_set_widget_playback(dai, w);
|
2012-02-17 03:37:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dai->driver->capture.stream_name) {
|
2013-06-05 18:36:11 +00:00
|
|
|
template.id = snd_soc_dapm_dai_out;
|
2012-02-17 03:37:51 +00:00
|
|
|
template.name = dai->driver->capture.stream_name;
|
|
|
|
template.sname = dai->driver->capture.stream_name;
|
|
|
|
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_dbg(dai->dev, "ASoC: adding %s widget\n",
|
2012-02-17 03:37:51 +00:00
|
|
|
template.name);
|
|
|
|
|
2015-05-25 17:21:17 +00:00
|
|
|
w = snd_soc_dapm_new_control_unlocked(dapm, &template);
|
2018-09-05 14:20:58 +00:00
|
|
|
if (IS_ERR(w))
|
|
|
|
return PTR_ERR(w);
|
2012-02-17 03:37:51 +00:00
|
|
|
|
|
|
|
w->priv = dai;
|
2023-01-31 02:01:34 +00:00
|
|
|
snd_soc_dai_set_widget_capture(dai, w);
|
2012-02-17 03:37:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2022-03-11 15:35:29 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_dai_widgets);
|
2012-02-17 03:37:51 +00:00
|
|
|
|
|
|
|
int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_widget *dai_w, *w;
|
2014-05-07 14:20:28 +00:00
|
|
|
struct snd_soc_dapm_widget *src, *sink;
|
2012-02-17 03:37:51 +00:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
/* For each DAI widget... */
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, dai_w) {
|
2013-06-05 18:36:11 +00:00
|
|
|
switch (dai_w->id) {
|
|
|
|
case snd_soc_dapm_dai_in:
|
|
|
|
case snd_soc_dapm_dai_out:
|
|
|
|
break;
|
|
|
|
default:
|
2006-10-06 16:32:18 +00:00
|
|
|
continue;
|
2013-06-05 18:36:11 +00:00
|
|
|
}
|
2012-02-17 03:37:51 +00:00
|
|
|
|
2018-06-14 19:26:42 +00:00
|
|
|
/* let users know there is no DAI to link */
|
|
|
|
if (!dai_w->priv) {
|
|
|
|
dev_dbg(card->dev, "dai widget %s has no DAI\n",
|
|
|
|
dai_w->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-02-17 03:37:51 +00:00
|
|
|
dai = dai_w->priv;
|
|
|
|
|
|
|
|
/* ...find all widgets with the same stream and link them */
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(card, w) {
|
2012-02-17 03:37:51 +00:00
|
|
|
if (w->dapm != dai_w->dapm)
|
|
|
|
continue;
|
|
|
|
|
2013-06-05 18:36:11 +00:00
|
|
|
switch (w->id) {
|
|
|
|
case snd_soc_dapm_dai_in:
|
|
|
|
case snd_soc_dapm_dai_out:
|
2012-02-17 03:37:51 +00:00
|
|
|
continue;
|
2013-06-05 18:36:11 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-02-17 03:37:51 +00:00
|
|
|
|
2015-07-21 09:51:35 +00:00
|
|
|
if (!w->sname || !strstr(w->sname, dai_w->sname))
|
2012-02-17 03:37:51 +00:00
|
|
|
continue;
|
|
|
|
|
2014-05-07 14:20:28 +00:00
|
|
|
if (dai_w->id == snd_soc_dapm_dai_in) {
|
|
|
|
src = dai_w;
|
|
|
|
sink = w;
|
|
|
|
} else {
|
|
|
|
src = w;
|
|
|
|
sink = dai_w;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2014-05-07 14:20:28 +00:00
|
|
|
dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
|
|
|
|
snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-17 03:37:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-07-25 10:15:15 +00:00
|
|
|
|
2020-04-09 18:12:07 +00:00
|
|
|
static void dapm_connect_dai_routes(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_dai *src_dai,
|
|
|
|
struct snd_soc_dapm_widget *src,
|
|
|
|
struct snd_soc_dapm_widget *dai,
|
|
|
|
struct snd_soc_dai *sink_dai,
|
|
|
|
struct snd_soc_dapm_widget *sink)
|
2014-01-08 10:40:19 +00:00
|
|
|
{
|
2020-04-09 18:12:07 +00:00
|
|
|
dev_dbg(dapm->dev, "connected DAI link %s:%s -> %s:%s\n",
|
|
|
|
src_dai->component->name, src->name,
|
|
|
|
sink_dai->component->name, sink->name);
|
|
|
|
|
|
|
|
if (dai) {
|
|
|
|
snd_soc_dapm_add_path(dapm, src, dai, NULL, NULL);
|
|
|
|
src = dai;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_dapm_add_path(dapm, src, sink, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
static int get_stream_cpu(struct snd_soc_dai_link *dai_link, int stream)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* [Normal]
|
|
|
|
*
|
|
|
|
* Playback
|
|
|
|
* CPU : SNDRV_PCM_STREAM_PLAYBACK
|
|
|
|
* Codec: SNDRV_PCM_STREAM_PLAYBACK
|
|
|
|
*
|
|
|
|
* Playback
|
|
|
|
* CPU : SNDRV_PCM_STREAM_CAPTURE
|
|
|
|
* Codec: SNDRV_PCM_STREAM_CAPTURE
|
|
|
|
*/
|
|
|
|
if (!dai_link->c2c_params)
|
|
|
|
return stream;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* [Codec2Codec]
|
|
|
|
*
|
|
|
|
* Playback
|
|
|
|
* CPU : SNDRV_PCM_STREAM_CAPTURE
|
|
|
|
* Codec: SNDRV_PCM_STREAM_PLAYBACK
|
|
|
|
*
|
|
|
|
* Capture
|
|
|
|
* CPU : SNDRV_PCM_STREAM_PLAYBACK
|
|
|
|
* Codec: SNDRV_PCM_STREAM_CAPTURE
|
|
|
|
*/
|
|
|
|
if (stream == SNDRV_PCM_STREAM_CAPTURE)
|
|
|
|
return SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
|
|
|
|
return SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
}
|
|
|
|
|
2020-04-09 18:12:07 +00:00
|
|
|
static void dapm_connect_dai_pair(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd,
|
|
|
|
struct snd_soc_dai *codec_dai,
|
|
|
|
struct snd_soc_dai *cpu_dai)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai_link *dai_link = rtd->dai_link;
|
2023-04-05 22:57:55 +00:00
|
|
|
struct snd_soc_dapm_widget *codec, *cpu;
|
|
|
|
struct snd_soc_dai *src_dai[] = { cpu_dai, codec_dai };
|
|
|
|
struct snd_soc_dai *sink_dai[] = { codec_dai, cpu_dai };
|
|
|
|
struct snd_soc_dapm_widget **src[] = { &cpu, &codec };
|
|
|
|
struct snd_soc_dapm_widget **sink[] = { &codec, &cpu };
|
|
|
|
char *widget_name[] = { "playback", "capture" };
|
2022-09-20 06:32:36 +00:00
|
|
|
int stream;
|
2014-01-08 10:40:19 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
for_each_pcm_streams(stream) {
|
|
|
|
int stream_cpu, stream_codec;
|
2018-09-05 14:21:00 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
stream_cpu = get_stream_cpu(dai_link, stream);
|
|
|
|
stream_codec = stream;
|
2020-02-25 13:39:14 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
/* connect BE DAI playback if widgets are valid */
|
|
|
|
cpu = snd_soc_dai_get_widget(cpu_dai, stream_cpu);
|
|
|
|
codec = snd_soc_dai_get_widget(codec_dai, stream_codec);
|
2014-01-08 10:40:19 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
if (!cpu || !codec)
|
|
|
|
continue;
|
2020-02-25 13:39:14 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
/* special handling for [Codec2Codec] */
|
2023-04-02 22:59:35 +00:00
|
|
|
if (dai_link->c2c_params && !rtd->c2c_widget[stream]) {
|
2023-04-05 22:57:55 +00:00
|
|
|
struct snd_pcm_substream *substream = rtd->pcm->streams[stream].substream;
|
|
|
|
struct snd_soc_dapm_widget *dai = snd_soc_dapm_new_dai(card, substream,
|
|
|
|
widget_name[stream]);
|
|
|
|
|
2020-04-09 18:12:08 +00:00
|
|
|
if (IS_ERR(dai))
|
2023-04-05 22:57:55 +00:00
|
|
|
continue;
|
|
|
|
|
2022-09-20 06:32:36 +00:00
|
|
|
rtd->c2c_widget[stream] = dai;
|
2014-01-08 10:40:19 +00:00
|
|
|
}
|
2020-02-25 13:39:14 +00:00
|
|
|
|
2023-04-05 22:57:55 +00:00
|
|
|
dapm_connect_dai_routes(&card->dapm, src_dai[stream], *src[stream],
|
2022-09-20 06:32:36 +00:00
|
|
|
rtd->c2c_widget[stream],
|
2023-04-05 22:57:55 +00:00
|
|
|
sink_dai[stream], *sink[stream]);
|
2014-01-08 10:40:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-29 12:51:22 +00:00
|
|
|
static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
|
2012-03-07 16:32:59 +00:00
|
|
|
int event)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2014-04-29 12:51:22 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
2012-02-16 23:03:27 +00:00
|
|
|
|
2020-02-19 06:56:41 +00:00
|
|
|
w = snd_soc_dai_get_widget(dai, stream);
|
2012-02-17 03:43:20 +00:00
|
|
|
|
2014-04-29 12:51:22 +00:00
|
|
|
if (w) {
|
2021-08-05 01:11:44 +00:00
|
|
|
unsigned int ep;
|
|
|
|
|
2014-04-29 12:51:22 +00:00
|
|
|
dapm_mark_dirty(w, "stream event");
|
2012-03-07 16:32:59 +00:00
|
|
|
|
2015-08-11 19:38:00 +00:00
|
|
|
if (w->id == snd_soc_dapm_dai_in) {
|
|
|
|
ep = SND_SOC_DAPM_EP_SOURCE;
|
|
|
|
dapm_widget_invalidate_input_paths(w);
|
|
|
|
} else {
|
|
|
|
ep = SND_SOC_DAPM_EP_SINK;
|
|
|
|
dapm_widget_invalidate_output_paths(w);
|
|
|
|
}
|
|
|
|
|
2012-03-07 16:32:59 +00:00
|
|
|
switch (event) {
|
|
|
|
case SND_SOC_DAPM_STREAM_START:
|
2014-04-29 12:51:22 +00:00
|
|
|
w->active = 1;
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = ep;
|
2012-03-07 16:32:59 +00:00
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_STREAM_STOP:
|
2014-04-29 12:51:22 +00:00
|
|
|
w->active = 0;
|
2015-08-11 19:38:00 +00:00
|
|
|
w->is_ep = 0;
|
2012-03-07 16:32:59 +00:00
|
|
|
break;
|
|
|
|
case SND_SOC_DAPM_STREAM_SUSPEND:
|
|
|
|
case SND_SOC_DAPM_STREAM_RESUME:
|
|
|
|
case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
|
|
|
|
case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-04-29 12:51:22 +00:00
|
|
|
}
|
2012-03-07 16:32:59 +00:00
|
|
|
|
2014-07-08 21:19:36 +00:00
|
|
|
void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
|
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2020-04-09 18:12:09 +00:00
|
|
|
struct snd_soc_dai *codec_dai;
|
|
|
|
int i;
|
2014-07-08 21:19:36 +00:00
|
|
|
|
|
|
|
/* for each BE DAI link... */
|
2018-09-18 01:29:35 +00:00
|
|
|
for_each_card_rtds(card, rtd) {
|
2014-07-08 21:19:36 +00:00
|
|
|
/*
|
|
|
|
* dynamic FE links have no fixed DAI mapping.
|
|
|
|
* CODEC<->CODEC links have no direct connection.
|
|
|
|
*/
|
2018-09-05 14:21:00 +00:00
|
|
|
if (rtd->dai_link->dynamic)
|
2014-07-08 21:19:36 +00:00
|
|
|
continue;
|
|
|
|
|
2022-09-20 06:32:16 +00:00
|
|
|
if (rtd->dai_link->num_cpus == 1) {
|
2020-04-09 18:12:09 +00:00
|
|
|
for_each_rtd_codec_dais(rtd, i, codec_dai)
|
|
|
|
dapm_connect_dai_pair(card, rtd, codec_dai,
|
2020-04-14 17:04:08 +00:00
|
|
|
asoc_rtd_to_cpu(rtd, 0));
|
2022-09-20 06:32:16 +00:00
|
|
|
} else if (rtd->dai_link->num_codecs == rtd->dai_link->num_cpus) {
|
2020-04-09 18:12:09 +00:00
|
|
|
for_each_rtd_codec_dais(rtd, i, codec_dai)
|
|
|
|
dapm_connect_dai_pair(card, rtd, codec_dai,
|
2020-04-14 17:04:08 +00:00
|
|
|
asoc_rtd_to_cpu(rtd, i));
|
2020-04-09 18:12:09 +00:00
|
|
|
} else {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"N cpus to M codecs link is not supported yet\n");
|
|
|
|
}
|
2014-07-08 21:19:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-29 12:51:22 +00:00
|
|
|
static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
|
|
|
|
int event)
|
|
|
|
{
|
2020-03-16 06:37:09 +00:00
|
|
|
struct snd_soc_dai *dai;
|
2014-07-08 21:19:36 +00:00
|
|
|
int i;
|
|
|
|
|
2020-03-16 06:37:09 +00:00
|
|
|
for_each_rtd_dais(rtd, i, dai)
|
|
|
|
soc_dapm_dai_stream_event(dai, stream, event);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_power_widgets(rtd->card, event);
|
2010-11-05 13:53:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_stream_event - send a stream event to the dapm core
|
|
|
|
* @rtd: PCM runtime data
|
|
|
|
* @stream: stream name
|
|
|
|
* @event: stream event
|
|
|
|
*
|
|
|
|
* Sends a stream event to the dapm core. The core then makes any
|
|
|
|
* necessary widget power changes.
|
|
|
|
*
|
|
|
|
* Returns 0 for success else error.
|
|
|
|
*/
|
2012-03-07 16:32:59 +00:00
|
|
|
void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
|
|
|
|
int event)
|
2010-11-05 13:53:46 +00:00
|
|
|
{
|
2012-03-07 10:38:26 +00:00
|
|
|
struct snd_soc_card *card = rtd->card;
|
2010-11-05 13:53:46 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(card);
|
2012-03-07 16:32:59 +00:00
|
|
|
soc_dapm_stream_event(rtd, stream, event);
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
|
2020-01-10 02:36:23 +00:00
|
|
|
void snd_soc_dapm_stream_stop(struct snd_soc_pcm_runtime *rtd, int stream)
|
|
|
|
{
|
|
|
|
if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
|
|
|
|
if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
|
|
|
|
/* powered down playback stream now */
|
|
|
|
snd_soc_dapm_stream_event(rtd,
|
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
SND_SOC_DAPM_STREAM_STOP);
|
|
|
|
} else {
|
|
|
|
/* start delayed pop wq here for playback streams */
|
|
|
|
rtd->pop_wait = 1;
|
|
|
|
queue_delayed_work(system_power_efficient_wq,
|
|
|
|
&rtd->delayed_work,
|
|
|
|
msecs_to_jiffies(rtd->pmdown_time));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* capture streams can be powered down now */
|
|
|
|
snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
|
|
|
|
SND_SOC_DAPM_STREAM_STOP);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_stop);
|
|
|
|
|
2014-02-18 15:22:14 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_enable_pin_unlocked - enable pin.
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Enables input/output pin and its parents or children widgets iff there is
|
|
|
|
* a valid audio route and active audio stream.
|
|
|
|
*
|
|
|
|
* Requires external locking.
|
|
|
|
*
|
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_set_pin(dapm, pin, 1);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/**
|
2008-07-07 12:35:17 +00:00
|
|
|
* snd_soc_dapm_enable_pin - enable pin.
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-07-07 12:35:17 +00:00
|
|
|
* @pin: pin name
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
2009-06-06 10:26:15 +00:00
|
|
|
* Enables input/output pin and its parents or children widgets iff there is
|
2008-07-07 12:35:17 +00:00
|
|
|
* a valid audio route and active audio stream.
|
2014-02-18 15:22:14 +00:00
|
|
|
*
|
2008-07-07 12:35:17 +00:00
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
2006-10-06 16:32:18 +00:00
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2014-02-18 15:22:14 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
ret = snd_soc_dapm_set_pin(dapm, pin, 1);
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
return ret;
|
2008-07-07 12:35:17 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2010-03-15 19:23:37 +00:00
|
|
|
/**
|
2014-02-18 15:22:14 +00:00
|
|
|
* snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2010-03-15 19:23:37 +00:00
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Enables input/output pin regardless of any other state. This is
|
|
|
|
* intended for use with microphone bias supplies used in microphone
|
|
|
|
* jack detection.
|
|
|
|
*
|
2014-02-18 15:22:14 +00:00
|
|
|
* Requires external locking.
|
|
|
|
*
|
2010-03-15 19:23:37 +00:00
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
2014-02-18 15:22:14 +00:00
|
|
|
int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
2010-03-15 19:23:37 +00:00
|
|
|
{
|
2011-04-27 16:34:31 +00:00
|
|
|
struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
|
2010-03-15 19:23:37 +00:00
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
if (!w) {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
|
2011-04-27 16:34:31 +00:00
|
|
|
return -EINVAL;
|
2011-04-06 02:38:14 +00:00
|
|
|
}
|
|
|
|
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
|
2014-10-25 15:42:03 +00:00
|
|
|
if (!w->connected) {
|
|
|
|
/*
|
|
|
|
* w->force does not affect the number of input or output paths,
|
|
|
|
* so we only have to recheck if w->connected is changed
|
|
|
|
*/
|
|
|
|
dapm_widget_invalidate_input_paths(w);
|
|
|
|
dapm_widget_invalidate_output_paths(w);
|
|
|
|
w->connected = 1;
|
|
|
|
}
|
2011-04-27 16:34:31 +00:00
|
|
|
w->force = 1;
|
2011-10-04 21:28:08 +00:00
|
|
|
dapm_mark_dirty(w, "force enable");
|
2010-03-15 19:23:37 +00:00
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
return 0;
|
2010-03-15 19:23:37 +00:00
|
|
|
}
|
2014-02-18 15:22:14 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_force_enable_pin - force a pin to be enabled
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Enables input/output pin regardless of any other state. This is
|
|
|
|
* intended for use with microphone bias supplies used in microphone
|
|
|
|
* jack detection.
|
|
|
|
*
|
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2010-03-15 19:23:37 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
|
|
|
|
|
2014-02-18 15:22:14 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_disable_pin_unlocked - disable pin.
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Disables input/output pin and its parents or children widgets.
|
|
|
|
*
|
|
|
|
* Requires external locking.
|
|
|
|
*
|
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_set_pin(dapm, pin, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
|
|
|
|
|
2008-07-07 12:35:17 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_disable_pin - disable pin.
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-07-07 12:35:17 +00:00
|
|
|
* @pin: pin name
|
|
|
|
*
|
2009-06-06 10:26:15 +00:00
|
|
|
* Disables input/output pin and its parents or children widgets.
|
2014-02-18 15:22:14 +00:00
|
|
|
*
|
2008-07-07 12:35:17 +00:00
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
2008-07-07 12:35:17 +00:00
|
|
|
{
|
2014-02-18 15:22:14 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
ret = snd_soc_dapm_set_pin(dapm, pin, 0);
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
return ret;
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
2008-07-07 12:35:17 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
|
2006-10-06 16:32:18 +00:00
|
|
|
|
2014-02-18 15:22:14 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
|
|
|
|
* @dapm: DAPM context
|
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Marks the specified pin as being not connected, disabling it along
|
|
|
|
* any parent or child widgets. At present this is identical to
|
|
|
|
* snd_soc_dapm_disable_pin() but in future it will be extended to do
|
|
|
|
* additional things such as disabling controls which only affect
|
|
|
|
* paths through the pin.
|
|
|
|
*
|
|
|
|
* Requires external locking.
|
|
|
|
*
|
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
|
|
|
int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_set_pin(dapm, pin, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
|
|
|
|
|
2008-09-24 10:23:11 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_nc_pin - permanently disable pin.
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-09-24 10:23:11 +00:00
|
|
|
* @pin: pin name
|
|
|
|
*
|
|
|
|
* Marks the specified pin as being not connected, disabling it along
|
|
|
|
* any parent or child widgets. At present this is identical to
|
|
|
|
* snd_soc_dapm_disable_pin() but in future it will be extended to do
|
|
|
|
* additional things such as disabling controls which only affect
|
|
|
|
* paths through the pin.
|
|
|
|
*
|
|
|
|
* NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
|
|
|
|
* do any widget power switching.
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
|
2008-09-24 10:23:11 +00:00
|
|
|
{
|
2014-02-18 15:22:14 +00:00
|
|
|
int ret;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
ret = snd_soc_dapm_set_pin(dapm, pin, 0);
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(dapm);
|
2014-02-18 15:22:14 +00:00
|
|
|
|
|
|
|
return ret;
|
2008-09-24 10:23:11 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
|
|
|
|
|
2008-04-30 17:27:40 +00:00
|
|
|
/**
|
2008-07-07 12:35:17 +00:00
|
|
|
* snd_soc_dapm_get_pin_status - get audio pin status
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2008-07-07 12:35:17 +00:00
|
|
|
* @pin: audio signal pin endpoint (or start point)
|
2008-04-30 17:27:40 +00:00
|
|
|
*
|
2008-07-07 12:35:17 +00:00
|
|
|
* Get audio pin status - connected or disconnected.
|
2008-04-30 17:27:40 +00:00
|
|
|
*
|
2008-07-07 12:35:17 +00:00
|
|
|
* Returns 1 for connected otherwise 0.
|
2008-04-30 17:27:40 +00:00
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
2008-04-30 17:27:40 +00:00
|
|
|
{
|
2011-04-27 16:34:31 +00:00
|
|
|
struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
|
2008-04-30 17:27:40 +00:00
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
if (w)
|
|
|
|
return w->connected;
|
2011-04-19 21:25:11 +00:00
|
|
|
|
2008-04-30 17:27:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-07-07 12:35:17 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
|
2008-04-30 17:27:40 +00:00
|
|
|
|
2010-05-07 20:11:40 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
|
2010-11-05 13:53:46 +00:00
|
|
|
* @dapm: DAPM context
|
2010-05-07 20:11:40 +00:00
|
|
|
* @pin: audio signal pin endpoint (or start point)
|
|
|
|
*
|
|
|
|
* Mark the given endpoint or pin as ignoring suspend. When the
|
|
|
|
* system is disabled a path between two endpoints flagged as ignoring
|
|
|
|
* suspend will not be disabled. The path must already be enabled via
|
|
|
|
* normal means at suspend time, it will not be turned on if it was not
|
|
|
|
* already enabled.
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
|
|
|
|
const char *pin)
|
2010-05-07 20:11:40 +00:00
|
|
|
{
|
2011-04-27 16:34:31 +00:00
|
|
|
struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
|
2010-05-07 20:11:40 +00:00
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
if (!w) {
|
2012-11-19 14:39:12 +00:00
|
|
|
dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
|
2011-04-27 16:34:31 +00:00
|
|
|
return -EINVAL;
|
2010-05-07 20:11:40 +00:00
|
|
|
}
|
|
|
|
|
2011-04-27 16:34:31 +00:00
|
|
|
w->ignore_suspend = 1;
|
|
|
|
|
|
|
|
return 0;
|
2010-05-07 20:11:40 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_free - free dapm resources
|
2011-08-26 13:33:52 +00:00
|
|
|
* @dapm: DAPM context
|
2006-10-06 16:32:18 +00:00
|
|
|
*
|
|
|
|
* Free all dapm widgets and resources.
|
|
|
|
*/
|
2010-11-05 13:53:46 +00:00
|
|
|
void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
|
2006-10-06 16:32:18 +00:00
|
|
|
{
|
2011-04-30 17:45:50 +00:00
|
|
|
dapm_debugfs_cleanup(dapm);
|
2010-11-05 13:53:46 +00:00
|
|
|
dapm_free_widgets(dapm);
|
2010-12-14 10:18:32 +00:00
|
|
|
list_del(&dapm->list);
|
2006-10-06 16:32:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
|
|
|
|
|
ASoC: soc-core: add snd_soc_dapm_init()
It is easy to read code if it is cleanly using paired function/naming,
like start <-> stop, register <-> unregister, etc, etc.
But, current ALSA SoC code is very random, unbalance, not paired, etc.
It is easy to create bug at the such code, and it will be difficult to
debug.
soc-dapm has snd_soc_dapm_free() which cleanups debugfs, widgets, list.
But, there is no paired initialize function.
This patch adds snd_soc_dapm_init() and initilaizing dapm
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87pnkw7lbj.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-08-23 00:58:52 +00:00
|
|
|
void snd_soc_dapm_init(struct snd_soc_dapm_context *dapm,
|
|
|
|
struct snd_soc_card *card,
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
dapm->card = card;
|
|
|
|
dapm->component = component;
|
|
|
|
dapm->bias_level = SND_SOC_BIAS_OFF;
|
|
|
|
|
|
|
|
if (component) {
|
|
|
|
dapm->dev = component->dev;
|
2020-10-11 09:19:39 +00:00
|
|
|
dapm->idle_bias_off = !component->driver->idle_bias_on;
|
ASoC: soc-core: add snd_soc_dapm_init()
It is easy to read code if it is cleanly using paired function/naming,
like start <-> stop, register <-> unregister, etc, etc.
But, current ALSA SoC code is very random, unbalance, not paired, etc.
It is easy to create bug at the such code, and it will be difficult to
debug.
soc-dapm has snd_soc_dapm_free() which cleanups debugfs, widgets, list.
But, there is no paired initialize function.
This patch adds snd_soc_dapm_init() and initilaizing dapm
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87pnkw7lbj.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-08-23 00:58:52 +00:00
|
|
|
dapm->suspend_bias_off = component->driver->suspend_bias_off;
|
|
|
|
} else {
|
|
|
|
dapm->dev = card->dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dapm->list);
|
2020-03-09 04:08:16 +00:00
|
|
|
/* see for_each_card_dapms */
|
ASoC: soc-core: add snd_soc_dapm_init()
It is easy to read code if it is cleanly using paired function/naming,
like start <-> stop, register <-> unregister, etc, etc.
But, current ALSA SoC code is very random, unbalance, not paired, etc.
It is easy to create bug at the such code, and it will be difficult to
debug.
soc-dapm has snd_soc_dapm_free() which cleanups debugfs, widgets, list.
But, there is no paired initialize function.
This patch adds snd_soc_dapm_init() and initilaizing dapm
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87pnkw7lbj.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-08-23 00:58:52 +00:00
|
|
|
list_add(&dapm->list, &card->dapm_list);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dapm_init);
|
|
|
|
|
2014-03-01 16:04:02 +00:00
|
|
|
static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
|
2009-06-22 12:16:51 +00:00
|
|
|
{
|
2012-07-06 15:57:05 +00:00
|
|
|
struct snd_soc_card *card = dapm->card;
|
2009-06-22 12:16:51 +00:00
|
|
|
struct snd_soc_dapm_widget *w;
|
|
|
|
LIST_HEAD(down_list);
|
|
|
|
int powerdown = 0;
|
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_lock_root(card);
|
2012-07-06 15:57:05 +00:00
|
|
|
|
2020-03-09 04:08:21 +00:00
|
|
|
for_each_card_widgets(dapm->card, w) {
|
2010-12-14 10:18:31 +00:00
|
|
|
if (w->dapm != dapm)
|
|
|
|
continue;
|
2009-06-22 12:16:51 +00:00
|
|
|
if (w->power) {
|
2011-01-15 13:14:30 +00:00
|
|
|
dapm_seq_insert(w, &down_list, false);
|
2020-02-28 15:31:45 +00:00
|
|
|
w->new_power = 0;
|
2009-06-22 12:16:51 +00:00
|
|
|
powerdown = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there were no widgets to power down we're already in
|
|
|
|
* standby.
|
|
|
|
*/
|
|
|
|
if (powerdown) {
|
2012-02-22 15:52:56 +00:00
|
|
|
if (dapm->bias_level == SND_SOC_BIAS_ON)
|
|
|
|
snd_soc_dapm_set_bias_level(dapm,
|
|
|
|
SND_SOC_BIAS_PREPARE);
|
2013-07-29 15:13:56 +00:00
|
|
|
dapm_seq_run(card, &down_list, 0, false);
|
2012-02-22 15:52:56 +00:00
|
|
|
if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
|
|
|
|
snd_soc_dapm_set_bias_level(dapm,
|
|
|
|
SND_SOC_BIAS_STANDBY);
|
2009-06-22 12:16:51 +00:00
|
|
|
}
|
2012-07-06 15:57:05 +00:00
|
|
|
|
ASoC: expand snd_soc_dapm_mutex_lock/unlock()
soc.h has snd_soc_dapm_mutex_lock/unlock() definition and
many drivers are using it, but soc-dapm.c is not.
1st reason is snd_soc_dapm_mutex_lock/unlock() requests
snd_soc_dapm_context pointer as parameter (A), but sometimes soc-dapm.c
needs to use snd_soc_card (B).
(A) static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
} ^^^^^^^^^^
(B) mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
^^^^
2nd reason is it want to use SND_SOC_DAPM_CLASS_INIT for mutex_lock_nested(),
but helper is using _RUNTIME (A).
The conclusion is we want to use "dapm vs card" and "_RUNTIME vs _INIT"
for dapm lock/unlock. To enable this selfish request, this patch uses
_Generic macro. We can use snd_soc_dapm_mutex_lock/unlock() for both
dapm and card case.
snd_soc_dapm_mutex_lock(dapm); snd_soc_dapm_mutex_unlock(dapm);
snd_soc_dapm_mutex_lock(card); snd_soc_dapm_mutex_unlock(card);
Current soc-dapm.c is using both mutex_lock() and mutex_lock_nested().
This patch handles mutex_lock() as mutex_lock_nested(..., 0),
in other words, handles below as same.
mutex_lock(&card->dapm_mutex);
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Because people might misunderstand that _init() is mutex initialization,
this patch renames _INIT to _ROOT and adds new
snd_soc_dapm_mutex_lock_root() for it.
This patch also moves snd_soc_dapm_subclass definition from soc-dapm.h
to soc.h to keep related code together.
Because very complex soc.h vs soc-dapm.h relationship,
it is difficult/impossible to define these helper into soc-dapm.h.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87cz4hx3v0.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2023-04-06 00:15:48 +00:00
|
|
|
snd_soc_dapm_mutex_unlock(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* snd_soc_dapm_shutdown - callback for system shutdown
|
|
|
|
*/
|
|
|
|
void snd_soc_dapm_shutdown(struct snd_soc_card *card)
|
|
|
|
{
|
2014-03-01 16:04:02 +00:00
|
|
|
struct snd_soc_dapm_context *dapm;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2020-03-09 04:08:16 +00:00
|
|
|
for_each_card_dapms(card, dapm) {
|
2014-03-01 16:04:03 +00:00
|
|
|
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);
|
|
|
|
}
|
2010-11-05 13:53:46 +00:00
|
|
|
}
|
2014-03-01 16:04:03 +00:00
|
|
|
|
|
|
|
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);
|
2009-06-22 12:16:51 +00:00
|
|
|
}
|
|
|
|
|
2006-10-06 16:32:18 +00:00
|
|
|
/* Module information */
|
2008-10-12 12:17:36 +00:00
|
|
|
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
|
2006-10-06 16:32:18 +00:00
|
|
|
MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
|
|
|
|
MODULE_LICENSE("GPL");
|