2018-07-02 13:24:18 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
//
|
|
|
|
// soc-core.c -- ALSA SoC Audio Layer
|
|
|
|
//
|
|
|
|
// Copyright 2005 Wolfson Microelectronics PLC.
|
|
|
|
// Copyright 2005 Openedhand Ltd.
|
|
|
|
// Copyright (C) 2010 Slimlogic Ltd.
|
|
|
|
// Copyright (C) 2010 Texas Instruments Inc.
|
|
|
|
//
|
|
|
|
// Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
|
|
|
// with code, comments and ideas from :-
|
|
|
|
// Richard Purdie <richard@openedhand.com>
|
|
|
|
//
|
|
|
|
// TODO:
|
|
|
|
// o Add hw rules to enforce rates, etc.
|
|
|
|
// o More testing with other codecs/machines.
|
|
|
|
// o Add more codecs and platforms to ensure good API coverage.
|
|
|
|
// o Support TDM on PCM and I2S
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/bitops.h>
|
2008-10-14 07:42:14 +07:00
|
|
|
#include <linux/debugfs.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <linux/platform_device.h>
|
2013-08-19 22:05:55 +07:00
|
|
|
#include <linux/pinctrl/consumer.h>
|
2011-09-20 17:41:54 +07:00
|
|
|
#include <linux/ctype.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 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2011-12-13 05:55:34 +07:00
|
|
|
#include <linux/of.h>
|
2017-05-18 08:39:25 +07:00
|
|
|
#include <linux/of_graph.h>
|
2017-01-14 15:13:02 +07:00
|
|
|
#include <linux/dmi.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/core.h>
|
2010-12-05 19:22:46 +07:00
|
|
|
#include <sound/jack.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
ASoC: dpcm: Add Dynamic PCM core operations.
The Dynamic PCM core allows digital audio data to be dynamically
routed between different ALSA PCMs and DAI links on SoC CPUs with
on chip DSP devices. e.g. audio data could be played on pcm:0,0 and
routed to any (or all) SoC DAI links.
Dynamic PCM introduces the concept of Front End (FE) PCMs and Back
End (BE) PCMs. The FE PCMs are normal ALSA PCM devices except that
they can dynamically route digital audio data to any supported BE
PCM. A BE PCM has no ALSA device, but represents a DAI link and it's
substream and audio HW parameters.
e.g. pcm:0,0 routing digital data to 2 external codecs.
FE pcm:0,0 ----> BE (McBSP.0) ----> CODEC 0
+--> BE (McPDM.0) ----> CODEC 1
e.g. pcm:0,0 and pcm:0,1 routing digital data to 1 external codec.
FE pcm:0,0 ---
+--> BE (McBSP.0) ----> CODEC
FE pcm:0,1 ---
The digital audio routing is controlled by the usual ALSA method
of mixer kcontrols. Dynamic PCM uses a DAPM graph to work out the
routing based upon the mixer settings and configures the BE PCMs
based on routing and the FE HW params.
DPCM is designed so that most ASoC component drivers will need no
modification at all. It's intended that existing CODEC, DAI and
platform drivers can be used in DPCM based audio devices without
any changes. However, there will be some cases where minor changes
are required (e.g. for very tightly coupled HW) and there are
helpers to support this too.
Somethimes the HW params of a FE and BE do not match or are
incompatible, so in these cases the machine driver can reconfigure
any hw_params and make any DSP perform sample rate / format conversion.
This patch adds the core DPCM code and contains :-
o The FE and BE PCM operations.
o FE and BE DAI link support.
o FE and BE PCM creation.
o BE support API.
o BE and FE link management.
Signed-off-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-04-25 18:12:49 +07:00
|
|
|
#include <sound/soc-dpcm.h>
|
2015-05-30 01:06:14 +07:00
|
|
|
#include <sound/soc-topology.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/initval.h>
|
|
|
|
|
2010-11-04 05:05:58 +07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/asoc.h>
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
#define NAME_SIZE 32
|
|
|
|
|
2008-12-04 00:34:03 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-11 05:25:21 +07:00
|
|
|
struct dentry *snd_soc_debugfs_root;
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
|
2008-12-04 00:34:03 +07:00
|
|
|
#endif
|
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
static DEFINE_MUTEX(client_mutex);
|
2013-03-12 08:27:21 +07:00
|
|
|
static LIST_HEAD(component_list);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/*
|
|
|
|
* This is a timeout to do a DAPM powerdown after a stream is closed().
|
|
|
|
* It can be used to eliminate pops between different playback streams, e.g.
|
|
|
|
* between two audio tracks.
|
|
|
|
*/
|
|
|
|
static int pmdown_time = 5000;
|
|
|
|
module_param(pmdown_time, int, 0);
|
|
|
|
MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
|
|
|
|
|
2017-06-28 14:01:39 +07:00
|
|
|
/* If a DMI filed contain strings in this blacklist (e.g.
|
|
|
|
* "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken
|
|
|
|
* as invalid and dropped when setting the card long name from DMI info.
|
|
|
|
*/
|
|
|
|
static const char * const dmi_blacklist[] = {
|
|
|
|
"To be filled by OEM",
|
|
|
|
"TBD by OEM",
|
|
|
|
"Default String",
|
|
|
|
"Board Manufacturer",
|
|
|
|
"Board Vendor Name",
|
|
|
|
"Board Product Name",
|
|
|
|
NULL, /* terminator */
|
|
|
|
};
|
|
|
|
|
2010-02-12 18:37:24 +07:00
|
|
|
static ssize_t pmdown_time_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-01-07 08:12:45 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
return sprintf(buf, "%ld\n", rtd->pmdown_time);
|
2010-02-12 18:37:24 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t pmdown_time_set(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2012-01-07 08:12:45 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-10-28 10:11:17 +07:00
|
|
|
int ret;
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2013-07-19 14:24:59 +07:00
|
|
|
ret = kstrtol(buf, 10, &rtd->pmdown_time);
|
2010-10-28 10:11:17 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-02-12 18:37:24 +07:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
|
|
|
|
|
2015-01-31 02:16:37 +07:00
|
|
|
static struct attribute *soc_dev_attrs[] = {
|
|
|
|
&dev_attr_pmdown_time.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
|
|
|
|
struct attribute *attr, int idx)
|
|
|
|
{
|
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (attr == &dev_attr_pmdown_time.attr)
|
|
|
|
return attr->mode; /* always visible */
|
2017-12-05 11:20:42 +07:00
|
|
|
return rtd->num_codecs ? attr->mode : 0; /* enabled only with codec */
|
2015-01-31 02:16:37 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct attribute_group soc_dapm_dev_group = {
|
|
|
|
.attrs = soc_dapm_dev_attrs,
|
|
|
|
.is_visible = soc_dev_attr_is_visible,
|
|
|
|
};
|
|
|
|
|
2018-03-09 19:46:27 +07:00
|
|
|
static const struct attribute_group soc_dev_group = {
|
2015-01-31 02:16:37 +07:00
|
|
|
.attrs = soc_dev_attrs,
|
|
|
|
.is_visible = soc_dev_attr_is_visible,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *soc_dev_attr_groups[] = {
|
|
|
|
&soc_dapm_dev_group,
|
2018-03-09 19:46:27 +07:00
|
|
|
&soc_dev_group,
|
2015-01-31 02:16:37 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2014-08-19 20:51:18 +07:00
|
|
|
static void soc_init_component_debugfs(struct snd_soc_component *component)
|
2014-06-26 21:22:50 +07:00
|
|
|
{
|
2015-04-09 15:52:38 +07:00
|
|
|
if (!component->card->debugfs_card_root)
|
|
|
|
return;
|
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
if (component->debugfs_prefix) {
|
|
|
|
char *name;
|
2014-06-26 21:22:50 +07:00
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
name = kasprintf(GFP_KERNEL, "%s:%s",
|
|
|
|
component->debugfs_prefix, component->name);
|
|
|
|
if (name) {
|
|
|
|
component->debugfs_root = debugfs_create_dir(name,
|
|
|
|
component->card->debugfs_card_root);
|
|
|
|
kfree(name);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
component->debugfs_root = debugfs_create_dir(component->name,
|
|
|
|
component->card->debugfs_card_root);
|
|
|
|
}
|
2014-06-26 21:22:50 +07:00
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
if (!component->debugfs_root) {
|
|
|
|
dev_warn(component->dev,
|
|
|
|
"ASoC: Failed to create component debugfs directory\n");
|
|
|
|
return;
|
|
|
|
}
|
2014-06-26 21:22:50 +07:00
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
|
|
|
|
component->debugfs_root);
|
2014-06-26 21:22:50 +07:00
|
|
|
}
|
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
|
2009-11-04 04:56:13 +07:00
|
|
|
{
|
2014-08-19 20:51:18 +07:00
|
|
|
debugfs_remove_recursive(component->debugfs_root);
|
|
|
|
}
|
2010-11-06 01:35:20 +07:00
|
|
|
|
2018-02-14 21:48:07 +07:00
|
|
|
static int dai_list_show(struct seq_file *m, void *v)
|
2010-09-16 00:19:07 +07:00
|
|
|
{
|
2014-03-09 23:41:47 +07:00
|
|
|
struct snd_soc_component *component;
|
2010-09-16 00:19:07 +07:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
2018-01-18 12:31:26 +07:00
|
|
|
list_for_each_entry(component, &component_list, list)
|
|
|
|
list_for_each_entry(dai, &component->dai_list, list)
|
|
|
|
seq_printf(m, "%s\n", dai->name);
|
2010-09-16 00:19:07 +07:00
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2018-01-18 12:31:26 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2018-02-14 21:48:07 +07:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(dai_list);
|
2010-09-16 00:19:07 +07:00
|
|
|
|
2018-05-08 10:21:00 +07:00
|
|
|
static int component_list_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
|
|
|
list_for_each_entry(component, &component_list, list)
|
|
|
|
seq_printf(m, "%s\n", component->name);
|
|
|
|
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
DEFINE_SHOW_ATTRIBUTE(component_list);
|
|
|
|
|
2010-11-06 01:35:19 +07:00
|
|
|
static void soc_init_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
2015-04-09 15:52:38 +07:00
|
|
|
if (!snd_soc_debugfs_root)
|
|
|
|
return;
|
|
|
|
|
2010-11-06 01:35:19 +07:00
|
|
|
card->debugfs_card_root = debugfs_create_dir(card->name,
|
2011-01-11 05:25:21 +07:00
|
|
|
snd_soc_debugfs_root);
|
2010-11-06 01:35:21 +07:00
|
|
|
if (!card->debugfs_card_root) {
|
2010-11-06 01:35:19 +07:00
|
|
|
dev_warn(card->dev,
|
2011-12-09 20:16:29 +07:00
|
|
|
"ASoC: Failed to create card debugfs directory\n");
|
2010-11-06 01:35:21 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
|
|
|
|
card->debugfs_card_root,
|
|
|
|
&card->pop_time);
|
|
|
|
if (!card->debugfs_pop_time)
|
|
|
|
dev_warn(card->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: Failed to create pop time debugfs file\n");
|
2010-11-06 01:35:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(card->debugfs_card_root);
|
|
|
|
}
|
|
|
|
|
2015-04-09 15:52:38 +07:00
|
|
|
static void snd_soc_debugfs_init(void)
|
|
|
|
{
|
|
|
|
snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
|
2017-08-07 19:08:53 +07:00
|
|
|
if (IS_ERR_OR_NULL(snd_soc_debugfs_root)) {
|
2015-04-09 15:52:38 +07:00
|
|
|
pr_warn("ASoC: Failed to create debugfs directory\n");
|
|
|
|
snd_soc_debugfs_root = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
|
|
|
|
&dai_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create DAI list debugfs file\n");
|
2018-05-08 10:21:00 +07:00
|
|
|
|
|
|
|
if (!debugfs_create_file("components", 0444, snd_soc_debugfs_root, NULL,
|
|
|
|
&component_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create component list debugfs file\n");
|
2015-04-09 15:52:38 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_soc_debugfs_exit(void)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(snd_soc_debugfs_root);
|
|
|
|
}
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
#else
|
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
static inline void soc_init_component_debugfs(
|
|
|
|
struct snd_soc_component *component)
|
2012-02-15 22:25:31 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-08-19 20:51:18 +07:00
|
|
|
static inline void soc_cleanup_component_debugfs(
|
|
|
|
struct snd_soc_component *component)
|
2012-02-15 22:25:31 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-11-09 16:06:44 +07:00
|
|
|
static inline void soc_init_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
}
|
2015-04-09 15:52:38 +07:00
|
|
|
|
|
|
|
static inline void snd_soc_debugfs_init(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void snd_soc_debugfs_exit(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
#endif
|
|
|
|
|
2017-08-08 13:17:47 +07:00
|
|
|
static int snd_soc_rtdcom_add(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_rtdcom_list *rtdcom;
|
|
|
|
struct snd_soc_rtdcom_list *new_rtdcom;
|
|
|
|
|
|
|
|
for_each_rtdcom(rtd, rtdcom) {
|
|
|
|
/* already connected */
|
|
|
|
if (rtdcom->component == component)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_rtdcom = kmalloc(sizeof(*new_rtdcom), GFP_KERNEL);
|
|
|
|
if (!new_rtdcom)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
new_rtdcom->component = component;
|
|
|
|
INIT_LIST_HEAD(&new_rtdcom->list);
|
|
|
|
|
|
|
|
list_add_tail(&new_rtdcom->list, &rtd->component_list);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_soc_rtdcom_del_all(struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
struct snd_soc_rtdcom_list *rtdcom1, *rtdcom2;
|
|
|
|
|
|
|
|
for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2)
|
|
|
|
kfree(rtdcom1);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&rtd->component_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
const char *driver_name)
|
|
|
|
{
|
|
|
|
struct snd_soc_rtdcom_list *rtdcom;
|
|
|
|
|
2018-01-23 07:41:24 +07:00
|
|
|
if (!driver_name)
|
|
|
|
return NULL;
|
|
|
|
|
2017-08-08 13:17:47 +07:00
|
|
|
for_each_rtdcom(rtd, rtdcom) {
|
2018-01-23 07:41:24 +07:00
|
|
|
const char *component_name = rtdcom->component->driver->name;
|
|
|
|
|
|
|
|
if (!component_name)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((component_name == driver_name) ||
|
|
|
|
strcmp(component_name, driver_name) == 0)
|
2017-08-08 13:17:47 +07:00
|
|
|
return rtdcom->component;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2018-01-18 08:13:54 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup);
|
2017-08-08 13:17:47 +07:00
|
|
|
|
2012-04-25 18:12:53 +07:00
|
|
|
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
|
|
|
|
const char *dai_link, int stream)
|
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2012-04-25 18:12:53 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (rtd->dai_link->no_pcm &&
|
|
|
|
!strcmp(rtd->dai_link->name, dai_link))
|
|
|
|
return rtd->pcm->streams[stream].substream;
|
2012-04-25 18:12:53 +07:00
|
|
|
}
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
|
2012-04-25 18:12:53 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
|
|
|
|
|
2017-09-26 07:40:42 +07:00
|
|
|
static const struct snd_soc_ops null_snd_soc_ops;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
|
|
|
|
struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
|
|
|
|
|
|
|
rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
|
|
|
|
if (!rtd)
|
|
|
|
return NULL;
|
|
|
|
|
2017-08-08 13:17:47 +07:00
|
|
|
INIT_LIST_HEAD(&rtd->component_list);
|
2015-11-18 14:34:11 +07:00
|
|
|
rtd->card = card;
|
|
|
|
rtd->dai_link = dai_link;
|
2017-09-26 07:40:42 +07:00
|
|
|
if (!rtd->dai_link->ops)
|
|
|
|
rtd->dai_link->ops = &null_snd_soc_ops;
|
|
|
|
|
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-13 04:03:40 +07:00
|
|
|
rtd->codec_dais = kcalloc(dai_link->num_codecs,
|
|
|
|
sizeof(struct snd_soc_dai *),
|
2015-11-18 14:34:11 +07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!rtd->codec_dais) {
|
|
|
|
kfree(rtd);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rtd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
2017-09-25 08:38:13 +07:00
|
|
|
kfree(rtd->codec_dais);
|
2017-08-08 13:17:47 +07:00
|
|
|
snd_soc_rtdcom_del_all(rtd);
|
2015-11-18 14:34:11 +07:00
|
|
|
kfree(rtd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_add_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
list_add_tail(&rtd->list, &card->rtd_list);
|
|
|
|
rtd->num = card->num_rtd;
|
|
|
|
card->num_rtd++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd, *_rtd;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
|
|
|
|
list_del(&rtd->list);
|
|
|
|
soc_free_pcm_runtime(rtd);
|
|
|
|
}
|
|
|
|
|
|
|
|
card->num_rtd = 0;
|
|
|
|
}
|
|
|
|
|
2012-04-25 18:12:53 +07:00
|
|
|
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
const char *dai_link)
|
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2012-04-25 18:12:53 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (!strcmp(rtd->dai_link->name, dai_link))
|
|
|
|
return rtd;
|
2012-04-25 18:12:53 +07:00
|
|
|
}
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
|
2012-04-25 18:12:53 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
|
|
|
|
|
2013-08-05 19:17:28 +07:00
|
|
|
static void codec2codec_close_delayed_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
/* Currently nothing to do for c2c links
|
|
|
|
* Since c2c links are internal nodes in the DAPM graph and
|
|
|
|
* don't interface with the outside world or application layer
|
|
|
|
* we don't have to do any special handling on close.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2006-10-06 23:31:09 +07:00
|
|
|
/* powers down audio subsystem for suspend */
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_suspend(struct device *dev)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2016-11-30 13:22:36 +07:00
|
|
|
struct snd_soc_component *component;
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
|
|
|
int i;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2014-08-19 20:51:30 +07:00
|
|
|
/* If the card is not initialized yet there is nothing to do */
|
|
|
|
if (!card->instantiated)
|
2009-06-03 22:44:49 +07:00
|
|
|
return 0;
|
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* Due to the resume being scheduled into a workqueue we could
|
|
|
|
* suspend before that's finished - wait for it to complete.
|
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
|
2008-06-13 22:24:05 +07:00
|
|
|
|
|
|
|
/* we're going to block userspace touching us until resume completes */
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2010-12-02 23:24:24 +07:00
|
|
|
/* mute any active DACs */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *dai = rtd->codec_dais[i];
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai_driver *drv = dai->driver;
|
|
|
|
|
|
|
|
if (drv->ops->digital_mute && dai->playback_active)
|
|
|
|
drv->ops->digital_mute(dai, 1);
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-01-10 20:39:01 +07:00
|
|
|
/* suspend all pcms */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
snd_pcm_suspend_all(rtd->pcm);
|
2010-05-09 19:25:43 +07:00
|
|
|
}
|
2008-01-10 20:39:01 +07:00
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->suspend_pre)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->suspend_pre(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
|
2010-03-18 03:15:21 +07:00
|
|
|
cpu_dai->driver->suspend(cpu_dai);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2015-03-31 02:04:50 +07:00
|
|
|
/* close any waiting streams */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-02-17 06:03:27 +07:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-02-17 06:03:27 +07:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2014-10-25 22:42:01 +07:00
|
|
|
/* Recheck all endpoints too, their state is affected by suspend */
|
|
|
|
dapm_mark_endpoints_dirty(card);
|
2012-09-01 07:38:32 +07:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
|
|
|
|
2016-11-30 13:23:13 +07:00
|
|
|
/* suspend all COMPONENTs */
|
2016-11-30 13:22:36 +07:00
|
|
|
list_for_each_entry(component, &card->component_dev_list, card_list) {
|
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
|
|
|
|
|
2016-11-30 13:23:13 +07:00
|
|
|
/* If there are paths active then the COMPONENT will be held with
|
2010-03-18 03:15:21 +07:00
|
|
|
* bias _ON and should not be suspended. */
|
2016-11-30 13:23:13 +07:00
|
|
|
if (!component->suspended) {
|
2015-07-06 20:38:11 +07:00
|
|
|
switch (snd_soc_dapm_get_bias_level(dapm)) {
|
2010-03-18 03:15:21 +07:00
|
|
|
case SND_SOC_BIAS_STANDBY:
|
2012-01-31 22:49:10 +07:00
|
|
|
/*
|
2016-11-30 13:23:13 +07:00
|
|
|
* If the COMPONENT is capable of idle
|
2012-01-31 22:49:10 +07:00
|
|
|
* bias off then being in STANDBY
|
|
|
|
* means it's doing something,
|
|
|
|
* otherwise fall through.
|
|
|
|
*/
|
2015-07-06 20:38:11 +07:00
|
|
|
if (dapm->idle_bias_off) {
|
2016-11-30 13:23:13 +07:00
|
|
|
dev_dbg(component->dev,
|
2013-05-05 03:21:38 +07:00
|
|
|
"ASoC: idle_bias_off CODEC on over suspend\n");
|
2012-01-31 22:49:10 +07:00
|
|
|
break;
|
|
|
|
}
|
2018-08-03 23:34:30 +07:00
|
|
|
/* fall through */
|
2014-09-05 00:44:07 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
case SND_SOC_BIAS_OFF:
|
2018-05-08 10:20:24 +07:00
|
|
|
if (component->driver->suspend)
|
|
|
|
component->driver->suspend(component);
|
2016-11-30 13:23:13 +07:00
|
|
|
component->suspended = 1;
|
|
|
|
if (component->regmap)
|
|
|
|
regcache_mark_dirty(component->regmap);
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
/* deactivate pins to sleep state */
|
2016-11-30 13:23:13 +07:00
|
|
|
pinctrl_pm_select_sleep_state(component->dev);
|
2010-03-18 03:15:21 +07:00
|
|
|
break;
|
|
|
|
default:
|
2016-11-30 13:23:13 +07:00
|
|
|
dev_dbg(component->dev,
|
|
|
|
"ASoC: COMPONENT is on over suspend\n");
|
2010-03-18 03:15:21 +07:00
|
|
|
break;
|
|
|
|
}
|
2010-05-08 03:11:40 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
|
2010-03-18 03:15:21 +07:00
|
|
|
cpu_dai->driver->suspend(cpu_dai);
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
|
|
|
|
/* deactivate pins to sleep state */
|
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->suspend_post)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->suspend_post(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_suspend);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* deferred resume work, so resume can complete before we finished
|
|
|
|
* setting our codec back up, which can be very slow on I2C
|
|
|
|
*/
|
|
|
|
static void soc_resume_deferred(struct work_struct *work)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_card *card =
|
|
|
|
container_of(work, struct snd_soc_card, deferred_resume_work);
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2016-11-30 13:22:36 +07:00
|
|
|
struct snd_soc_component *component;
|
2015-11-18 14:34:11 +07:00
|
|
|
int i;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
|
|
|
|
* so userspace apps are blocked from touching us
|
|
|
|
*/
|
|
|
|
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: starting resume work\n");
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2010-05-08 02:24:05 +07:00
|
|
|
/* Bring us up into D2 so that DAPM starts enabling things */
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
|
2010-05-08 02:24:05 +07:00
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->resume_pre)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->resume_pre(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
/* resume control bus DAIs */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
|
2010-03-18 03:15:21 +07:00
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
|
|
|
}
|
|
|
|
|
2016-11-30 13:22:36 +07:00
|
|
|
list_for_each_entry(component, &card->component_dev_list, card_list) {
|
2016-11-30 13:23:13 +07:00
|
|
|
if (component->suspended) {
|
2018-05-08 10:20:24 +07:00
|
|
|
if (component->driver->resume)
|
|
|
|
component->driver->resume(component);
|
2016-11-30 13:23:13 +07:00
|
|
|
component->suspended = 0;
|
2010-05-08 03:11:40 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-03-07 23:32:59 +07:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
2012-02-17 06:03:27 +07:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-03-07 23:32:59 +07:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
2012-02-17 06:03:27 +07:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-05-19 17:32:25 +07:00
|
|
|
/* unmute any active DACs */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *dai = rtd->codec_dais[i];
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai_driver *drv = dai->driver;
|
|
|
|
|
|
|
|
if (drv->ops->digital_mute && dai->playback_active)
|
|
|
|
drv->ops->digital_mute(dai, 0);
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
|
2010-03-18 03:15:21 +07:00
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->resume_post)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->resume_post(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: resume work completed\n");
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2014-10-25 22:42:01 +07:00
|
|
|
/* Recheck all endpoints too, their state is affected by suspend */
|
|
|
|
dapm_mark_endpoints_dirty(card);
|
2012-09-01 07:38:32 +07:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2015-11-23 22:52:31 +07:00
|
|
|
|
|
|
|
/* userspace can access us now we are back as we were before */
|
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
|
2008-06-13 22:24:05 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* powers up audio subsystem after a suspend */
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_resume(struct device *dev)
|
2008-06-13 22:24:05 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2014-11-11 04:41:52 +07:00
|
|
|
bool bus_control = false;
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2010-02-22 18:27:13 +07:00
|
|
|
|
2014-08-19 20:51:30 +07:00
|
|
|
/* If the card is not initialized yet there is nothing to do */
|
|
|
|
if (!card->instantiated)
|
2011-11-23 21:37:00 +07:00
|
|
|
return 0;
|
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
/* activate pins from sleep state */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai **codec_dais = rtd->codec_dais;
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
int j;
|
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
if (cpu_dai->active)
|
|
|
|
pinctrl_pm_select_default_state(cpu_dai->dev);
|
2014-07-09 04:19:34 +07:00
|
|
|
|
|
|
|
for (j = 0; j < rtd->num_codecs; j++) {
|
|
|
|
struct snd_soc_dai *codec_dai = codec_dais[j];
|
|
|
|
if (codec_dai->active)
|
|
|
|
pinctrl_pm_select_default_state(codec_dai->dev);
|
|
|
|
}
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
}
|
|
|
|
|
2014-11-11 04:41:52 +07:00
|
|
|
/*
|
|
|
|
* DAIs that also act as the control bus master might have other drivers
|
|
|
|
* hanging off them so need to resume immediately. Other drivers don't
|
|
|
|
* have that problem and may take a substantial amount of time to resume
|
2009-03-31 17:27:03 +07:00
|
|
|
* due to I/O costs and anti-pop so handle them out of line.
|
|
|
|
*/
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2014-11-11 04:41:52 +07:00
|
|
|
bus_control |= cpu_dai->driver->bus_control;
|
2011-05-26 03:06:41 +07:00
|
|
|
}
|
2014-11-11 04:41:52 +07:00
|
|
|
if (bus_control) {
|
|
|
|
dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
|
2011-05-26 03:06:41 +07:00
|
|
|
soc_resume_deferred(&card->deferred_resume_work);
|
|
|
|
} else {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(dev, "ASoC: Scheduling resume work\n");
|
2011-05-26 03:06:41 +07:00
|
|
|
if (!schedule_work(&card->deferred_resume_work))
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(dev, "ASoC: resume work item may be lost\n");
|
2009-03-31 17:27:03 +07:00
|
|
|
}
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_resume);
|
2006-10-06 23:31:09 +07:00
|
|
|
#else
|
2011-01-26 21:59:27 +07:00
|
|
|
#define snd_soc_suspend NULL
|
|
|
|
#define snd_soc_resume NULL
|
2006-10-06 23:31:09 +07:00
|
|
|
#endif
|
|
|
|
|
2011-11-23 17:40:40 +07:00
|
|
|
static const struct snd_soc_dai_ops null_dai_ops = {
|
2009-10-16 17:13:38 +07:00
|
|
|
};
|
|
|
|
|
2014-08-19 20:51:22 +07:00
|
|
|
static struct snd_soc_component *soc_find_component(
|
|
|
|
const struct device_node *of_node, const char *name)
|
2014-03-21 22:27:25 +07:00
|
|
|
{
|
2014-08-19 20:51:22 +07:00
|
|
|
struct snd_soc_component *component;
|
2014-03-21 22:27:25 +07:00
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
|
2014-08-19 20:51:22 +07:00
|
|
|
list_for_each_entry(component, &component_list, list) {
|
|
|
|
if (of_node) {
|
|
|
|
if (component->dev->of_node == of_node)
|
|
|
|
return component;
|
|
|
|
} else if (strcmp(component->name, name) == 0) {
|
|
|
|
return component;
|
2014-03-21 22:27:25 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-04-22 11:25:33 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_find_dai - Find a registered DAI
|
|
|
|
*
|
2017-08-22 14:57:21 +07:00
|
|
|
* @dlc: name of the DAI or the DAI driver and optional component info to match
|
2016-04-22 11:25:33 +07:00
|
|
|
*
|
2017-05-09 05:57:50 +07:00
|
|
|
* This function will search all registered components and their DAIs to
|
2016-04-22 11:25:33 +07:00
|
|
|
* find the DAI of the same name. The component's of_node and name
|
|
|
|
* should also match if being specified.
|
|
|
|
*
|
|
|
|
* Return: pointer of DAI, or NULL if not found.
|
|
|
|
*/
|
2016-04-19 12:12:25 +07:00
|
|
|
struct snd_soc_dai *snd_soc_find_dai(
|
2014-08-19 20:51:27 +07:00
|
|
|
const struct snd_soc_dai_link_component *dlc)
|
2014-03-21 22:27:25 +07:00
|
|
|
{
|
2014-08-19 20:51:27 +07:00
|
|
|
struct snd_soc_component *component;
|
|
|
|
struct snd_soc_dai *dai;
|
2015-05-27 01:59:05 +07:00
|
|
|
struct device_node *component_of_node;
|
2014-03-21 22:27:25 +07:00
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
|
2014-08-19 20:51:27 +07:00
|
|
|
/* Find CPU DAI from registered DAIs*/
|
|
|
|
list_for_each_entry(component, &component_list, list) {
|
2015-05-27 01:59:05 +07:00
|
|
|
component_of_node = component->dev->of_node;
|
|
|
|
if (!component_of_node && component->dev->parent)
|
|
|
|
component_of_node = component->dev->parent->of_node;
|
|
|
|
|
|
|
|
if (dlc->of_node && component_of_node != dlc->of_node)
|
2014-08-19 20:51:27 +07:00
|
|
|
continue;
|
2014-10-30 03:46:30 +07:00
|
|
|
if (dlc->name && strcmp(component->name, dlc->name))
|
2014-08-19 20:51:27 +07:00
|
|
|
continue;
|
|
|
|
list_for_each_entry(dai, &component->dai_list, list) {
|
2017-08-22 14:57:21 +07:00
|
|
|
if (dlc->dai_name && strcmp(dai->name, dlc->dai_name)
|
2017-08-24 11:40:17 +07:00
|
|
|
&& (!dai->driver->name
|
|
|
|
|| strcmp(dai->driver->name, dlc->dai_name)))
|
2014-03-21 22:27:25 +07:00
|
|
|
continue;
|
|
|
|
|
2014-08-19 20:51:27 +07:00
|
|
|
return dai;
|
2014-03-21 22:27:25 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-19 12:12:25 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_find_dai);
|
2014-03-21 22:27:25 +07:00
|
|
|
|
2016-11-03 00:04:12 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_find_dai_link - Find a DAI link
|
|
|
|
*
|
|
|
|
* @card: soc card
|
|
|
|
* @id: DAI link ID to match
|
|
|
|
* @name: DAI link name to match, optional
|
2017-01-12 18:38:15 +07:00
|
|
|
* @stream_name: DAI link stream name to match, optional
|
2016-11-03 00:04:12 +07:00
|
|
|
*
|
|
|
|
* This function will search all existing DAI links of the soc card to
|
|
|
|
* find the link of the same ID. Since DAI links may not have their
|
|
|
|
* unique ID, so name and stream name should also match if being
|
|
|
|
* specified.
|
|
|
|
*
|
|
|
|
* Return: pointer of DAI link, or NULL if not found.
|
|
|
|
*/
|
|
|
|
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
|
|
|
|
int id, const char *name,
|
|
|
|
const char *stream_name)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai_link *link, *_link;
|
|
|
|
|
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
|
|
|
|
if (link->id != id)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (name && (!link->name || strcmp(name, link->name)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (stream_name && (!link->stream_name
|
|
|
|
|| strcmp(stream_name, link->stream_name)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return link;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);
|
|
|
|
|
2015-12-02 13:11:40 +07:00
|
|
|
static bool soc_is_dai_link_bound(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
|
|
|
|
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (rtd->dai_link == dai_link)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-11-23 23:03:52 +07:00
|
|
|
static int soc_bind_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai_link_component *codecs = dai_link->codecs;
|
2014-08-19 20:51:27 +07:00
|
|
|
struct snd_soc_dai_link_component cpu_dai_component;
|
2017-08-08 13:18:10 +07:00
|
|
|
struct snd_soc_component *component;
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_dai **codec_dais;
|
2016-11-07 20:03:17 +07:00
|
|
|
struct device_node *platform_of_node;
|
2011-04-28 00:16:32 +07:00
|
|
|
const char *platform_name;
|
2014-07-09 04:19:34 +07:00
|
|
|
int i;
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2018-07-02 22:59:54 +07:00
|
|
|
if (dai_link->ignore)
|
|
|
|
return 0;
|
|
|
|
|
2015-11-23 23:03:52 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2015-12-02 13:11:40 +07:00
|
|
|
if (soc_is_dai_link_bound(card, dai_link)) {
|
|
|
|
dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
|
|
|
|
dai_link->name);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2016-02-22 15:44:31 +07:00
|
|
|
rtd = soc_new_pcm_runtime(card, dai_link);
|
|
|
|
if (!rtd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-08-19 20:51:27 +07:00
|
|
|
cpu_dai_component.name = dai_link->cpu_name;
|
|
|
|
cpu_dai_component.of_node = dai_link->cpu_of_node;
|
|
|
|
cpu_dai_component.dai_name = dai_link->cpu_dai_name;
|
|
|
|
rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
|
2012-03-15 04:18:39 +07:00
|
|
|
if (!rtd->cpu_dai) {
|
2018-02-01 17:09:41 +07:00
|
|
|
dev_info(card->dev, "ASoC: CPU DAI %s not registered\n",
|
|
|
|
dai_link->cpu_dai_name);
|
2015-11-18 14:34:11 +07:00
|
|
|
goto _err_defer;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2017-08-08 13:18:10 +07:00
|
|
|
snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2014-07-09 04:19:34 +07:00
|
|
|
rtd->num_codecs = dai_link->num_codecs;
|
2011-04-28 00:16:32 +07:00
|
|
|
|
2014-07-09 04:19:34 +07:00
|
|
|
/* Find CODEC from registered CODECs */
|
2015-11-18 14:34:11 +07:00
|
|
|
codec_dais = rtd->codec_dais;
|
2014-07-09 04:19:34 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-08-19 20:51:27 +07:00
|
|
|
codec_dais[i] = snd_soc_find_dai(&codecs[i]);
|
2014-07-09 04:19:34 +07:00
|
|
|
if (!codec_dais[i]) {
|
|
|
|
dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
|
|
|
|
codecs[i].dai_name);
|
2015-11-18 14:34:11 +07:00
|
|
|
goto _err_defer;
|
2014-07-09 04:19:34 +07:00
|
|
|
}
|
2017-08-08 13:18:10 +07:00
|
|
|
snd_soc_rtdcom_add(rtd, codec_dais[i]->component);
|
2014-03-21 22:27:25 +07:00
|
|
|
}
|
|
|
|
|
2014-07-09 04:19:34 +07:00
|
|
|
/* Single codec links expect codec and codec_dai in runtime data */
|
|
|
|
rtd->codec_dai = codec_dais[0];
|
|
|
|
|
2011-04-28 00:16:32 +07:00
|
|
|
/* if there's no platform we match on the empty platform */
|
|
|
|
platform_name = dai_link->platform_name;
|
2011-12-22 00:40:59 +07:00
|
|
|
if (!platform_name && !dai_link->platform_of_node)
|
2011-04-28 00:16:32 +07:00
|
|
|
platform_name = "snd-soc-dummy";
|
|
|
|
|
2017-08-08 13:18:10 +07:00
|
|
|
/* find one from the set of registered platforms */
|
|
|
|
list_for_each_entry(component, &component_list, list) {
|
|
|
|
platform_of_node = component->dev->of_node;
|
|
|
|
if (!platform_of_node && component->dev->parent->of_node)
|
|
|
|
platform_of_node = component->dev->parent->of_node;
|
|
|
|
|
|
|
|
if (dai_link->platform_of_node) {
|
|
|
|
if (platform_of_node != dai_link->platform_of_node)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if (strcmp(component->name, platform_name))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_rtdcom_add(rtd, component);
|
|
|
|
}
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
soc_add_pcm_runtime(card, rtd);
|
2012-03-15 04:18:39 +07:00
|
|
|
return 0;
|
2015-11-18 14:34:11 +07:00
|
|
|
|
|
|
|
_err_defer:
|
|
|
|
soc_free_pcm_runtime(rtd);
|
|
|
|
return -EPROBE_DEFER;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
static void soc_remove_component(struct snd_soc_component *component)
|
2012-06-09 01:34:22 +07:00
|
|
|
{
|
2015-07-09 01:47:44 +07:00
|
|
|
if (!component->card)
|
2014-08-19 20:51:24 +07:00
|
|
|
return;
|
2012-06-09 01:34:22 +07:00
|
|
|
|
2016-11-30 13:22:36 +07:00
|
|
|
list_del(&component->card_list);
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2018-05-08 10:20:24 +07:00
|
|
|
if (component->driver->remove)
|
|
|
|
component->driver->remove(component);
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
snd_soc_dapm_free(snd_soc_component_get_dapm(component));
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
soc_cleanup_component_debugfs(component);
|
2015-07-09 01:47:44 +07:00
|
|
|
component->card = NULL;
|
2014-08-19 20:51:19 +07:00
|
|
|
module_put(component->dev->driver->owner);
|
2010-12-06 21:27:07 +07:00
|
|
|
}
|
|
|
|
|
2014-08-19 20:51:26 +07:00
|
|
|
static void soc_remove_dai(struct snd_soc_dai *dai, int order)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2014-08-19 20:51:26 +07:00
|
|
|
if (dai && dai->probed &&
|
|
|
|
dai->driver->remove_order == order) {
|
|
|
|
if (dai->driver->remove) {
|
|
|
|
err = dai->driver->remove(dai);
|
2010-03-18 03:15:21 +07:00
|
|
|
if (err < 0)
|
2014-08-19 20:51:26 +07:00
|
|
|
dev_err(dai->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: failed to remove %s: %d\n",
|
2014-08-19 20:51:26 +07:00
|
|
|
dai->name, err);
|
2008-12-09 02:26:48 +07:00
|
|
|
}
|
2014-08-19 20:51:26 +07:00
|
|
|
dai->probed = 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2014-03-21 22:27:26 +07:00
|
|
|
}
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
static void soc_remove_link_dais(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2014-03-21 22:27:26 +07:00
|
|
|
{
|
2014-08-19 20:51:26 +07:00
|
|
|
int i;
|
2014-03-21 22:27:26 +07:00
|
|
|
|
|
|
|
/* unregister the rtd device */
|
|
|
|
if (rtd->dev_registered) {
|
|
|
|
device_unregister(rtd->dev);
|
|
|
|
rtd->dev_registered = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove the CODEC DAI */
|
2014-07-09 04:19:34 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++)
|
2014-08-19 20:51:26 +07:00
|
|
|
soc_remove_dai(rtd->codec_dais[i], order);
|
2008-12-09 02:26:48 +07:00
|
|
|
|
2014-08-19 20:51:26 +07:00
|
|
|
soc_remove_dai(rtd->cpu_dai, order);
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
static void soc_remove_link_components(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2012-06-09 01:34:23 +07:00
|
|
|
{
|
2014-08-19 20:51:21 +07:00
|
|
|
struct snd_soc_component *component;
|
2017-08-08 13:18:10 +07:00
|
|
|
struct snd_soc_rtdcom_list *rtdcom;
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2017-08-08 13:18:10 +07:00
|
|
|
for_each_rtdcom(rtd, rtdcom) {
|
|
|
|
component = rtdcom->component;
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2014-08-19 20:51:24 +07:00
|
|
|
if (component->driver->remove_order == order)
|
2014-08-19 20:51:21 +07:00
|
|
|
soc_remove_component(component);
|
2012-06-09 01:34:23 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-08 12:50:44 +07:00
|
|
|
static void soc_remove_dai_links(struct snd_soc_card *card)
|
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
int order;
|
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2015-12-02 13:11:22 +07:00
|
|
|
struct snd_soc_dai_link *link, *_link;
|
2011-04-08 12:50:44 +07:00
|
|
|
|
2011-06-07 22:08:05 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
soc_remove_link_dais(card, rtd, order);
|
2012-06-09 01:34:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
soc_remove_link_components(card, rtd, order);
|
2011-06-07 22:08:05 +07:00
|
|
|
}
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
|
|
|
|
if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
|
|
|
|
dev_warn(card->dev, "Topology forgot to remove link %s?\n",
|
|
|
|
link->name);
|
|
|
|
|
|
|
|
list_del(&link->list);
|
|
|
|
card->num_dai_links--;
|
|
|
|
}
|
2011-04-08 12:50:44 +07:00
|
|
|
}
|
|
|
|
|
2015-11-23 23:01:49 +07:00
|
|
|
static int snd_soc_init_multicodec(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
/* Legacy codec/codec_dai link is a single entry in multicodec */
|
|
|
|
if (dai_link->codec_name || dai_link->codec_of_node ||
|
|
|
|
dai_link->codec_dai_name) {
|
|
|
|
dai_link->num_codecs = 1;
|
|
|
|
|
|
|
|
dai_link->codecs = devm_kzalloc(card->dev,
|
|
|
|
sizeof(struct snd_soc_dai_link_component),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!dai_link->codecs)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dai_link->codecs[0].name = dai_link->codec_name;
|
|
|
|
dai_link->codecs[0].of_node = dai_link->codec_of_node;
|
|
|
|
dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dai_link->codecs) {
|
|
|
|
dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int soc_init_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *link)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
ret = snd_soc_init_multicodec(card, link);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev, "ASoC: failed to init multicodec\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < link->num_codecs; i++) {
|
|
|
|
/*
|
|
|
|
* Codec must be specified by 1 of name or OF node,
|
|
|
|
* not both or neither.
|
|
|
|
*/
|
|
|
|
if (!!link->codecs[i].name ==
|
|
|
|
!!link->codecs[i].of_node) {
|
|
|
|
dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/* Codec DAI name must be specified */
|
|
|
|
if (!link->codecs[i].dai_name) {
|
|
|
|
dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Platform may be specified by either name or OF node, but
|
|
|
|
* can be left unspecified, and a dummy platform will be used.
|
|
|
|
*/
|
|
|
|
if (link->platform_name && link->platform_of_node) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Both platform name/of_node are set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CPU device may be specified by either name or OF node, but
|
|
|
|
* can be left unspecified, and will be matched based on DAI
|
|
|
|
* name alone..
|
|
|
|
*/
|
|
|
|
if (link->cpu_name && link->cpu_of_node) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Neither/both cpu name/of_node are set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* At least one of CPU DAI name or CPU device name/node must be
|
|
|
|
* specified
|
|
|
|
*/
|
|
|
|
if (!link->cpu_dai_name &&
|
|
|
|
!(link->cpu_name || link->cpu_of_node)) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2011-04-08 12:50:44 +07:00
|
|
|
}
|
|
|
|
|
2017-11-28 13:27:09 +07:00
|
|
|
void snd_soc_disconnect_sync(struct device *dev)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component = snd_soc_lookup_component(dev, NULL);
|
|
|
|
|
|
|
|
if (!component || !component->card)
|
|
|
|
return;
|
|
|
|
|
|
|
|
snd_card_disconnect_sync(component->card->snd_card);
|
|
|
|
}
|
2017-11-29 09:38:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_disconnect_sync);
|
2017-11-28 13:27:09 +07:00
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_add_dai_link - Add a DAI link dynamically
|
|
|
|
* @card: The ASoC card to which the DAI link is added
|
|
|
|
* @dai_link: The new DAI link to add
|
|
|
|
*
|
|
|
|
* This function adds a DAI link to the ASoC card's link list.
|
|
|
|
*
|
|
|
|
* Note: Topology can use this API to add DAI links when probing the
|
|
|
|
* topology component. And machine drivers can still define static
|
|
|
|
* DAI links in dai_link array.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
if (dai_link->dobj.type
|
|
|
|
&& dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
|
|
|
|
dev_err(card->dev, "Invalid dai link type %d\n",
|
|
|
|
dai_link->dobj.type);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
lockdep_assert_held(&client_mutex);
|
2015-12-02 13:11:32 +07:00
|
|
|
/* Notify the machine driver for extra initialization
|
|
|
|
* on the link created by topology.
|
|
|
|
*/
|
|
|
|
if (dai_link->dobj.type && card->add_dai_link)
|
|
|
|
card->add_dai_link(card, dai_link);
|
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
list_add_tail(&dai_link->list, &card->dai_link_list);
|
|
|
|
card->num_dai_links++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_remove_dai_link - Remove a DAI link from the list
|
|
|
|
* @card: The ASoC card that owns the link
|
|
|
|
* @dai_link: The DAI link to remove
|
|
|
|
*
|
|
|
|
* This function removes a DAI link from the ASoC card's link list.
|
|
|
|
*
|
|
|
|
* For DAI links previously added by topology, topology should
|
|
|
|
* remove them by using the dobj embedded in the link.
|
|
|
|
*/
|
|
|
|
void snd_soc_remove_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai_link *link, *_link;
|
|
|
|
|
|
|
|
if (dai_link->dobj.type
|
|
|
|
&& dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
|
|
|
|
dev_err(card->dev, "Invalid dai link type %d\n",
|
|
|
|
dai_link->dobj.type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
lockdep_assert_held(&client_mutex);
|
2015-12-02 13:11:32 +07:00
|
|
|
/* Notify the machine driver for extra destruction
|
|
|
|
* on the link created by topology.
|
|
|
|
*/
|
|
|
|
if (dai_link->dobj.type && card->remove_dai_link)
|
|
|
|
card->remove_dai_link(card, dai_link);
|
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
|
|
|
|
if (link == dai_link) {
|
|
|
|
list_del(&link->list);
|
|
|
|
card->num_dai_links--;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);
|
|
|
|
|
2018-07-13 19:50:43 +07:00
|
|
|
static void soc_set_of_name_prefix(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct device_node *component_of_node = component->dev->of_node;
|
|
|
|
const char *str;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!component_of_node && component->dev->parent)
|
|
|
|
component_of_node = component->dev->parent->of_node;
|
|
|
|
|
|
|
|
ret = of_property_read_string(component_of_node, "sound-name-prefix",
|
|
|
|
&str);
|
|
|
|
if (!ret)
|
|
|
|
component->name_prefix = str;
|
|
|
|
}
|
|
|
|
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
static void soc_set_name_prefix(struct snd_soc_card *card,
|
2014-06-16 23:13:01 +07:00
|
|
|
struct snd_soc_component *component)
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2018-07-13 19:50:43 +07:00
|
|
|
for (i = 0; i < card->num_configs && card->codec_conf; i++) {
|
2010-12-02 21:53:03 +07:00
|
|
|
struct snd_soc_codec_conf *map = &card->codec_conf[i];
|
2018-04-27 19:54:36 +07:00
|
|
|
struct device_node *component_of_node = component->dev->of_node;
|
|
|
|
|
|
|
|
if (!component_of_node && component->dev->parent)
|
|
|
|
component_of_node = component->dev->parent->of_node;
|
|
|
|
|
|
|
|
if (map->of_node && component_of_node != map->of_node)
|
2014-04-28 21:07:22 +07:00
|
|
|
continue;
|
2014-06-16 23:13:01 +07:00
|
|
|
if (map->dev_name && strcmp(component->name, map->dev_name))
|
2014-04-28 21:07:22 +07:00
|
|
|
continue;
|
2014-06-16 23:13:01 +07:00
|
|
|
component->name_prefix = map->name_prefix;
|
2018-07-13 19:50:43 +07:00
|
|
|
return;
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
}
|
2018-07-13 19:50:43 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is no configuration table or no match in the table,
|
|
|
|
* check if a prefix is provided in the node
|
|
|
|
*/
|
|
|
|
soc_set_of_name_prefix(component);
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
}
|
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
static int soc_probe_component(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_component *component)
|
2010-12-06 21:27:07 +07:00
|
|
|
{
|
2014-08-19 20:51:19 +07:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
|
2012-02-17 10:37:51 +07:00
|
|
|
struct snd_soc_dai *dai;
|
2014-08-19 20:51:19 +07:00
|
|
|
int ret;
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2015-07-09 01:47:43 +07:00
|
|
|
if (!strcmp(component->name, "snd-soc-dummy"))
|
2014-08-19 20:51:24 +07:00
|
|
|
return 0;
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2015-07-09 01:47:44 +07:00
|
|
|
if (component->card) {
|
2015-07-09 01:47:43 +07:00
|
|
|
if (component->card != card) {
|
|
|
|
dev_err(component->dev,
|
|
|
|
"Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
|
|
|
|
card->name, component->card->name);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
if (!try_module_get(component->dev->driver->owner))
|
2011-01-27 21:24:22 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
component->card = card;
|
|
|
|
dapm->card = card;
|
|
|
|
soc_set_name_prefix(card, component);
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
soc_init_component_debugfs(component);
|
2011-05-01 00:45:49 +07:00
|
|
|
|
2017-08-25 07:29:20 +07:00
|
|
|
if (component->driver->dapm_widgets) {
|
|
|
|
ret = snd_soc_dapm_new_controls(dapm,
|
|
|
|
component->driver->dapm_widgets,
|
|
|
|
component->driver->num_dapm_widgets);
|
2014-04-01 19:59:33 +07:00
|
|
|
|
|
|
|
if (ret != 0) {
|
2014-08-19 20:51:19 +07:00
|
|
|
dev_err(component->dev,
|
2014-04-01 19:59:33 +07:00
|
|
|
"Failed to create new controls %d\n", ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
2011-05-05 21:59:09 +07:00
|
|
|
|
2014-08-20 18:08:49 +07:00
|
|
|
list_for_each_entry(dai, &component->dai_list, list) {
|
|
|
|
ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
|
2014-03-31 21:47:12 +07:00
|
|
|
if (ret != 0) {
|
2014-08-20 18:08:49 +07:00
|
|
|
dev_err(component->dev,
|
2014-03-31 21:47:12 +07:00
|
|
|
"Failed to create DAI widgets %d\n", ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
2012-02-17 10:37:51 +07:00
|
|
|
|
2018-05-08 10:20:24 +07:00
|
|
|
if (component->driver->probe) {
|
|
|
|
ret = component->driver->probe(component);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0) {
|
2014-08-19 20:51:19 +07:00
|
|
|
dev_err(component->dev,
|
|
|
|
"ASoC: failed to probe component %d\n", ret);
|
2011-01-27 21:24:22 +07:00
|
|
|
goto err_probe;
|
2010-12-06 21:27:07 +07:00
|
|
|
}
|
2011-07-05 04:10:53 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
WARN(dapm->idle_bias_off &&
|
|
|
|
dapm->bias_level != SND_SOC_BIAS_OFF,
|
|
|
|
"codec %s can not start from non-off bias with idle_bias_off==1\n",
|
|
|
|
component->name);
|
2012-03-07 18:47:41 +07:00
|
|
|
}
|
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
/* machine specific init */
|
|
|
|
if (component->init) {
|
|
|
|
ret = component->init(component);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(component->dev,
|
|
|
|
"Failed to do machine specific init %d\n", ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-25 07:29:01 +07:00
|
|
|
if (component->driver->controls)
|
|
|
|
snd_soc_add_component_controls(component,
|
|
|
|
component->driver->controls,
|
|
|
|
component->driver->num_controls);
|
2017-08-25 07:29:41 +07:00
|
|
|
if (component->driver->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(dapm,
|
|
|
|
component->driver->dapm_routes,
|
|
|
|
component->driver->num_dapm_routes);
|
2012-04-06 01:28:01 +07:00
|
|
|
|
2014-08-19 20:51:19 +07:00
|
|
|
list_add(&dapm->list, &card->dapm_list);
|
2016-11-30 13:22:36 +07:00
|
|
|
list_add(&component->card_list, &card->component_dev_list);
|
2011-07-01 22:54:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_probe:
|
2014-08-19 20:51:19 +07:00
|
|
|
soc_cleanup_component_debugfs(component);
|
2015-07-09 01:47:44 +07:00
|
|
|
component->card = NULL;
|
2014-08-19 20:51:19 +07:00
|
|
|
module_put(component->dev->driver->owner);
|
2011-07-01 22:54:08 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-07 08:12:45 +07:00
|
|
|
static void rtd_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(dev);
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2014-07-02 03:13:48 +07:00
|
|
|
static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
const char *name)
|
2014-04-24 19:01:44 +07:00
|
|
|
{
|
2010-12-06 21:27:07 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* register the rtd device */
|
2012-01-07 08:12:45 +07:00
|
|
|
rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
|
|
|
|
if (!rtd->dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
device_initialize(rtd->dev);
|
2014-07-02 03:13:48 +07:00
|
|
|
rtd->dev->parent = rtd->card->dev;
|
2012-01-07 08:12:45 +07:00
|
|
|
rtd->dev->release = rtd_release;
|
2015-01-31 02:16:37 +07:00
|
|
|
rtd->dev->groups = soc_dev_attr_groups;
|
2014-08-17 16:28:35 +07:00
|
|
|
dev_set_name(rtd->dev, "%s", name);
|
2012-01-07 08:12:45 +07:00
|
|
|
dev_set_drvdata(rtd->dev, rtd);
|
2011-06-09 23:04:39 +07:00
|
|
|
mutex_init(&rtd->pcm_mutex);
|
ASoC: dpcm: Add Dynamic PCM core operations.
The Dynamic PCM core allows digital audio data to be dynamically
routed between different ALSA PCMs and DAI links on SoC CPUs with
on chip DSP devices. e.g. audio data could be played on pcm:0,0 and
routed to any (or all) SoC DAI links.
Dynamic PCM introduces the concept of Front End (FE) PCMs and Back
End (BE) PCMs. The FE PCMs are normal ALSA PCM devices except that
they can dynamically route digital audio data to any supported BE
PCM. A BE PCM has no ALSA device, but represents a DAI link and it's
substream and audio HW parameters.
e.g. pcm:0,0 routing digital data to 2 external codecs.
FE pcm:0,0 ----> BE (McBSP.0) ----> CODEC 0
+--> BE (McPDM.0) ----> CODEC 1
e.g. pcm:0,0 and pcm:0,1 routing digital data to 1 external codec.
FE pcm:0,0 ---
+--> BE (McBSP.0) ----> CODEC
FE pcm:0,1 ---
The digital audio routing is controlled by the usual ALSA method
of mixer kcontrols. Dynamic PCM uses a DAPM graph to work out the
routing based upon the mixer settings and configures the BE PCMs
based on routing and the FE HW params.
DPCM is designed so that most ASoC component drivers will need no
modification at all. It's intended that existing CODEC, DAI and
platform drivers can be used in DPCM based audio devices without
any changes. However, there will be some cases where minor changes
are required (e.g. for very tightly coupled HW) and there are
helpers to support this too.
Somethimes the HW params of a FE and BE do not match or are
incompatible, so in these cases the machine driver can reconfigure
any hw_params and make any DSP perform sample rate / format conversion.
This patch adds the core DPCM code and contains :-
o The FE and BE PCM operations.
o FE and BE DAI link support.
o FE and BE PCM creation.
o BE support API.
o BE and FE link management.
Signed-off-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-04-25 18:12:49 +07:00
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
|
2012-01-07 08:12:45 +07:00
|
|
|
ret = device_add(rtd->dev);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0) {
|
2012-12-25 23:56:05 +07:00
|
|
|
/* calling put_device() here to free the rtd->dev */
|
|
|
|
put_device(rtd->dev);
|
2014-07-02 03:13:48 +07:00
|
|
|
dev_err(rtd->card->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: failed to register runtime device: %d\n", ret);
|
2010-12-06 21:27:07 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
rtd->dev_registered = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
static int soc_probe_link_components(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd,
|
2012-06-09 01:34:23 +07:00
|
|
|
int order)
|
|
|
|
{
|
2014-08-19 20:51:19 +07:00
|
|
|
struct snd_soc_component *component;
|
2017-08-08 13:18:10 +07:00
|
|
|
struct snd_soc_rtdcom_list *rtdcom;
|
|
|
|
int ret;
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2017-08-08 13:18:10 +07:00
|
|
|
for_each_rtdcom(rtd, rtdcom) {
|
|
|
|
component = rtdcom->component;
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2014-08-19 20:51:24 +07:00
|
|
|
if (component->driver->probe_order == order) {
|
2014-08-19 20:51:19 +07:00
|
|
|
ret = soc_probe_component(card, component);
|
2014-07-09 04:19:34 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-06-09 01:34:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-04 17:30:59 +07:00
|
|
|
static int soc_probe_dai(struct snd_soc_dai *dai, int order)
|
2014-03-21 22:27:26 +07:00
|
|
|
{
|
2018-02-14 09:58:03 +07:00
|
|
|
if (dai->probed ||
|
|
|
|
dai->driver->probe_order != order)
|
|
|
|
return 0;
|
2014-03-21 22:27:26 +07:00
|
|
|
|
2018-02-14 09:58:03 +07:00
|
|
|
if (dai->driver->probe) {
|
|
|
|
int ret = dai->driver->probe(dai);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dai->dev, "ASoC: failed to probe DAI %s: %d\n",
|
|
|
|
dai->name, ret);
|
|
|
|
return ret;
|
2014-03-21 22:27:26 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-14 09:58:03 +07:00
|
|
|
dai->probed = 1;
|
|
|
|
|
2014-03-21 22:27:26 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-03 22:52:51 +07:00
|
|
|
static int soc_link_dai_pcm_new(struct snd_soc_dai **dais, int num_dais,
|
|
|
|
struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < num_dais; ++i) {
|
|
|
|
struct snd_soc_dai_driver *drv = dais[i]->driver;
|
|
|
|
|
|
|
|
if (!rtd->dai_link->no_pcm && drv->pcm_new)
|
|
|
|
ret = drv->pcm_new(rtd, dais[i]);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dais[i]->dev,
|
|
|
|
"ASoC: Failed to bind %s with pcm device\n",
|
|
|
|
dais[i]->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-21 22:27:27 +07:00
|
|
|
static int soc_link_dai_widgets(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link,
|
2014-07-01 14:47:54 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd)
|
2014-03-21 22:27:27 +07:00
|
|
|
{
|
2014-07-01 14:47:54 +07:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
2015-11-10 00:49:58 +07:00
|
|
|
struct snd_soc_dapm_widget *sink, *source;
|
2014-03-21 22:27:27 +07:00
|
|
|
int ret;
|
|
|
|
|
2014-07-09 04:19:34 +07:00
|
|
|
if (rtd->num_codecs > 1)
|
|
|
|
dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
|
|
|
|
|
2014-03-21 22:27:27 +07:00
|
|
|
/* link the DAI widgets */
|
2015-11-10 00:49:58 +07:00
|
|
|
sink = codec_dai->playback_widget;
|
|
|
|
source = cpu_dai->capture_widget;
|
|
|
|
if (sink && source) {
|
2014-03-21 22:27:27 +07:00
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
2015-11-10 00:49:58 +07:00
|
|
|
dai_link->num_params,
|
|
|
|
source, sink);
|
2014-03-21 22:27:27 +07:00
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
|
2015-11-10 00:49:58 +07:00
|
|
|
sink->name, source->name, ret);
|
2014-03-21 22:27:27 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-10 00:49:58 +07:00
|
|
|
sink = cpu_dai->playback_widget;
|
|
|
|
source = codec_dai->capture_widget;
|
|
|
|
if (sink && source) {
|
2014-03-21 22:27:27 +07:00
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
2015-11-10 00:49:58 +07:00
|
|
|
dai_link->num_params,
|
|
|
|
source, sink);
|
2014-03-21 22:27:27 +07:00
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
|
2015-11-10 00:49:58 +07:00
|
|
|
sink->name, source->name, ret);
|
2014-03-21 22:27:27 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
static int soc_probe_link_dais(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_dai_link *dai_link = rtd->dai_link;
|
2012-04-05 04:12:09 +07:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2018-07-02 22:59:54 +07:00
|
|
|
struct snd_soc_rtdcom_list *rtdcom;
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
int i, ret, num;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
|
2015-11-18 14:34:11 +07:00
|
|
|
card->name, rtd->num, order);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* set default power off timeout */
|
|
|
|
rtd->pmdown_time = pmdown_time;
|
|
|
|
|
2014-11-04 17:30:59 +07:00
|
|
|
ret = soc_probe_dai(cpu_dai, order);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* probe the CODEC DAI */
|
2014-07-09 04:19:34 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-11-04 17:30:59 +07:00
|
|
|
ret = soc_probe_dai(rtd->codec_dais[i], order);
|
2014-07-09 04:19:34 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2011-06-07 22:08:05 +07:00
|
|
|
/* complete DAI probe during last probe */
|
|
|
|
if (order != SND_SOC_COMP_ORDER_LAST)
|
|
|
|
return 0;
|
|
|
|
|
2014-07-02 03:13:48 +07:00
|
|
|
/* do machine specific initialization */
|
|
|
|
if (dai_link->init) {
|
|
|
|
ret = dai_link->init(rtd);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(card->dev, "ASoC: failed to init %s: %d\n",
|
|
|
|
dai_link->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-10 16:47:00 +07:00
|
|
|
if (dai_link->dai_fmt)
|
|
|
|
snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
|
|
|
|
|
2014-07-02 03:13:48 +07:00
|
|
|
ret = soc_post_component_init(rtd, dai_link->name);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret)
|
2010-03-18 03:15:21 +07:00
|
|
|
return ret;
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2014-07-02 03:13:48 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
/* add DPCM sysfs entries */
|
2015-04-09 15:52:37 +07:00
|
|
|
if (dai_link->dynamic)
|
|
|
|
soc_dpcm_debugfs_add(rtd);
|
2014-07-02 03:13:48 +07:00
|
|
|
#endif
|
|
|
|
|
2018-07-02 22:59:54 +07:00
|
|
|
num = rtd->num;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* most drivers will register their PCMs using DAI link ordering but
|
|
|
|
* topology based drivers can use the DAI link id field to set PCM
|
|
|
|
* device number and then use rtd + a base offset of the BEs.
|
|
|
|
*/
|
|
|
|
for_each_rtdcom(rtd, rtdcom) {
|
|
|
|
component = rtdcom->component;
|
|
|
|
|
|
|
|
if (!component->driver->use_dai_pcm_id)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (rtd->dai_link->no_pcm)
|
|
|
|
num += component->driver->be_pcm_base;
|
|
|
|
else
|
|
|
|
num = rtd->dai_link->id;
|
|
|
|
}
|
|
|
|
|
2015-10-13 22:41:00 +07:00
|
|
|
if (cpu_dai->driver->compress_new) {
|
2012-08-16 18:40:41 +07:00
|
|
|
/*create compress_device"*/
|
2018-07-02 22:59:54 +07:00
|
|
|
ret = cpu_dai->driver->compress_new(rtd, num);
|
2012-04-05 04:12:09 +07:00
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev, "ASoC: can't create compress %s\n",
|
2012-08-16 18:40:41 +07:00
|
|
|
dai_link->stream_name);
|
2012-04-05 04:12:09 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
2012-08-16 18:40:41 +07:00
|
|
|
|
|
|
|
if (!dai_link->params) {
|
|
|
|
/* create the pcm */
|
2018-07-02 22:59:54 +07:00
|
|
|
ret = soc_new_pcm(rtd, num);
|
2012-08-16 18:40:41 +07:00
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
|
2012-08-16 18:40:41 +07:00
|
|
|
dai_link->stream_name, ret);
|
2012-04-05 04:12:09 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2017-01-03 22:52:51 +07:00
|
|
|
ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
ret = soc_link_dai_pcm_new(rtd->codec_dais,
|
|
|
|
rtd->num_codecs, rtd);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-08-16 18:40:41 +07:00
|
|
|
} else {
|
2013-08-05 19:17:28 +07:00
|
|
|
INIT_DELAYED_WORK(&rtd->delayed_work,
|
|
|
|
codec2codec_close_delayed_work);
|
|
|
|
|
2012-08-16 18:40:41 +07:00
|
|
|
/* link the DAI widgets */
|
2014-07-01 14:47:54 +07:00
|
|
|
ret = soc_link_dai_widgets(card, dai_link, rtd);
|
2014-03-21 22:27:27 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-04-05 04:12:09 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-02 03:13:47 +07:00
|
|
|
static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
|
2014-04-28 21:07:22 +07:00
|
|
|
{
|
|
|
|
struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
|
2016-01-06 12:29:31 +07:00
|
|
|
struct snd_soc_component *component;
|
|
|
|
const char *name;
|
|
|
|
struct device_node *codec_of_node;
|
|
|
|
|
|
|
|
if (aux_dev->codec_of_node || aux_dev->codec_name) {
|
|
|
|
/* codecs, usually analog devices */
|
|
|
|
name = aux_dev->codec_name;
|
|
|
|
codec_of_node = aux_dev->codec_of_node;
|
|
|
|
component = soc_find_component(codec_of_node, name);
|
|
|
|
if (!component) {
|
|
|
|
if (codec_of_node)
|
|
|
|
name = of_node_full_name(codec_of_node);
|
|
|
|
goto err_defer;
|
|
|
|
}
|
|
|
|
} else if (aux_dev->name) {
|
|
|
|
/* generic components */
|
|
|
|
name = aux_dev->name;
|
|
|
|
component = soc_find_component(NULL, name);
|
|
|
|
if (!component)
|
|
|
|
goto err_defer;
|
|
|
|
} else {
|
|
|
|
dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
|
|
|
|
return -EINVAL;
|
2014-04-28 21:07:22 +07:00
|
|
|
}
|
2012-08-10 00:44:37 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
component->init = aux_dev->init;
|
2016-12-29 20:11:21 +07:00
|
|
|
list_add(&component->card_aux_list, &card->aux_comp_list);
|
2016-11-30 13:22:55 +07:00
|
|
|
|
2014-07-02 03:13:47 +07:00
|
|
|
return 0;
|
2016-01-06 12:29:31 +07:00
|
|
|
|
|
|
|
err_defer:
|
|
|
|
dev_err(card->dev, "ASoC: %s not registered\n", name);
|
|
|
|
return -EPROBE_DEFER;
|
2012-03-15 04:18:39 +07:00
|
|
|
}
|
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
static int soc_probe_aux_devices(struct snd_soc_card *card)
|
2010-11-25 22:47:38 +07:00
|
|
|
{
|
2017-03-24 07:13:00 +07:00
|
|
|
struct snd_soc_component *comp;
|
2016-01-06 12:29:31 +07:00
|
|
|
int order;
|
2014-07-02 03:13:47 +07:00
|
|
|
int ret;
|
2014-04-28 21:07:22 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2017-03-24 07:13:00 +07:00
|
|
|
list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
|
2016-01-06 12:29:31 +07:00
|
|
|
if (comp->driver->probe_order == order) {
|
|
|
|
ret = soc_probe_component(card, comp);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: failed to probe aux component %s %d\n",
|
|
|
|
comp->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2014-07-02 03:13:48 +07:00
|
|
|
}
|
|
|
|
}
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
return 0;
|
2010-11-25 22:47:38 +07:00
|
|
|
}
|
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
static void soc_remove_aux_devices(struct snd_soc_card *card)
|
2010-11-25 22:47:38 +07:00
|
|
|
{
|
2016-01-06 12:29:31 +07:00
|
|
|
struct snd_soc_component *comp, *_comp;
|
|
|
|
int order;
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
|
|
|
list_for_each_entry_safe(comp, _comp,
|
2017-03-24 07:13:00 +07:00
|
|
|
&card->aux_comp_list, card_aux_list) {
|
2016-11-30 13:22:55 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
if (comp->driver->remove_order == order) {
|
|
|
|
soc_remove_component(comp);
|
2017-03-24 07:13:00 +07:00
|
|
|
/* remove it from the card's aux_comp_list */
|
|
|
|
list_del(&comp->card_aux_list);
|
2016-01-06 12:29:31 +07:00
|
|
|
}
|
|
|
|
}
|
2010-11-25 22:47:38 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-06 21:17:20 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
|
|
|
|
* @rtd: The runtime for which the DAI link format should be changed
|
|
|
|
* @dai_fmt: The new DAI link format
|
|
|
|
*
|
|
|
|
* This function updates the DAI link format for all DAIs connected to the DAI
|
|
|
|
* link for the specified runtime.
|
|
|
|
*
|
|
|
|
* Note: For setups with a static format set the dai_fmt field in the
|
|
|
|
* corresponding snd_dai_link struct instead of using this function.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, otherwise a negative error code.
|
|
|
|
*/
|
|
|
|
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
unsigned int dai_fmt)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai **codec_dais = rtd->codec_dais;
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *codec_dai = codec_dais[i];
|
|
|
|
|
|
|
|
ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
|
|
|
|
if (ret != 0 && ret != -ENOTSUPP) {
|
|
|
|
dev_warn(codec_dai->dev,
|
|
|
|
"ASoC: Failed to set DAI format: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
|
2017-12-15 12:10:47 +07:00
|
|
|
/* the component which has non_legacy_dai_naming is Codec */
|
2018-05-08 10:20:24 +07:00
|
|
|
if (cpu_dai->component->driver->non_legacy_dai_naming) {
|
2015-01-06 21:17:20 +07:00
|
|
|
unsigned int inv_dai_fmt;
|
|
|
|
|
|
|
|
inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
|
|
|
|
switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFM:
|
|
|
|
inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFS:
|
|
|
|
inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFM:
|
|
|
|
inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFS:
|
|
|
|
inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dai_fmt = inv_dai_fmt;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
|
|
|
|
if (ret != 0 && ret != -ENOTSUPP) {
|
|
|
|
dev_warn(cpu_dai->dev,
|
|
|
|
"ASoC: Failed to set DAI format: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-01-08 18:23:05 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
|
2015-01-06 21:17:20 +07:00
|
|
|
|
2017-01-14 15:13:02 +07:00
|
|
|
|
2017-04-24 13:54:41 +07:00
|
|
|
#ifdef CONFIG_DMI
|
2017-01-14 15:13:02 +07:00
|
|
|
/* Trim special characters, and replace '-' with '_' since '-' is used to
|
|
|
|
* separate different DMI fields in the card long name. Only number and
|
|
|
|
* alphabet characters and a few separator characters are kept.
|
|
|
|
*/
|
|
|
|
static void cleanup_dmi_name(char *name)
|
|
|
|
{
|
|
|
|
int i, j = 0;
|
|
|
|
|
|
|
|
for (i = 0; name[i]; i++) {
|
|
|
|
if (isalnum(name[i]) || (name[i] == '.')
|
|
|
|
|| (name[i] == '_'))
|
|
|
|
name[j++] = name[i];
|
|
|
|
else if (name[i] == '-')
|
|
|
|
name[j++] = '_';
|
|
|
|
}
|
|
|
|
|
|
|
|
name[j] = '\0';
|
|
|
|
}
|
|
|
|
|
2017-06-28 14:01:39 +07:00
|
|
|
/* Check if a DMI field is valid, i.e. not containing any string
|
|
|
|
* in the black list.
|
|
|
|
*/
|
|
|
|
static int is_dmi_valid(const char *field)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (dmi_blacklist[i]) {
|
|
|
|
if (strstr(field, dmi_blacklist[i]))
|
|
|
|
return 0;
|
|
|
|
i++;
|
2017-06-29 23:27:13 +07:00
|
|
|
}
|
2017-06-28 14:01:39 +07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-01-14 15:13:02 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_set_dmi_name() - Register DMI names to card
|
|
|
|
* @card: The card to register DMI names
|
|
|
|
* @flavour: The flavour "differentiator" for the card amongst its peers.
|
|
|
|
*
|
|
|
|
* An Intel machine driver may be used by many different devices but are
|
|
|
|
* difficult for userspace to differentiate, since machine drivers ususally
|
|
|
|
* use their own name as the card short name and leave the card long name
|
|
|
|
* blank. To differentiate such devices and fix bugs due to lack of
|
|
|
|
* device-specific configurations, this function allows DMI info to be used
|
|
|
|
* as the sound card long name, in the format of
|
|
|
|
* "vendor-product-version-board"
|
|
|
|
* (Character '-' is used to separate different DMI fields here).
|
|
|
|
* This will help the user space to load the device-specific Use Case Manager
|
|
|
|
* (UCM) configurations for the card.
|
|
|
|
*
|
|
|
|
* Possible card long names may be:
|
|
|
|
* DellInc.-XPS139343-01-0310JH
|
|
|
|
* ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
|
|
|
|
* Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
|
|
|
|
*
|
|
|
|
* This function also supports flavoring the card longname to provide
|
|
|
|
* the extra differentiation, like "vendor-product-version-board-flavor".
|
|
|
|
*
|
|
|
|
* We only keep number and alphabet characters and a few separator characters
|
|
|
|
* in the card long name since UCM in the user space uses the card long names
|
|
|
|
* as card configuration directory names and AudoConf cannot support special
|
|
|
|
* charactors like SPACE.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, otherwise a negative error code.
|
|
|
|
*/
|
|
|
|
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
|
|
|
|
{
|
|
|
|
const char *vendor, *product, *product_version, *board;
|
|
|
|
size_t longname_buf_size = sizeof(card->snd_card->longname);
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
if (card->long_name)
|
|
|
|
return 0; /* long name already set by driver or from DMI */
|
|
|
|
|
|
|
|
/* make up dmi long name as: vendor.product.version.board */
|
|
|
|
vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
|
2017-06-28 14:01:39 +07:00
|
|
|
if (!vendor || !is_dmi_valid(vendor)) {
|
2017-01-14 15:13:02 +07:00
|
|
|
dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-28 14:01:39 +07:00
|
|
|
|
2017-01-14 15:13:02 +07:00
|
|
|
snprintf(card->dmi_longname, sizeof(card->snd_card->longname),
|
|
|
|
"%s", vendor);
|
|
|
|
cleanup_dmi_name(card->dmi_longname);
|
|
|
|
|
|
|
|
product = dmi_get_system_info(DMI_PRODUCT_NAME);
|
2017-06-28 14:01:39 +07:00
|
|
|
if (product && is_dmi_valid(product)) {
|
2017-01-14 15:13:02 +07:00
|
|
|
len = strlen(card->dmi_longname);
|
|
|
|
snprintf(card->dmi_longname + len,
|
|
|
|
longname_buf_size - len,
|
|
|
|
"-%s", product);
|
|
|
|
|
|
|
|
len++; /* skip the separator "-" */
|
|
|
|
if (len < longname_buf_size)
|
|
|
|
cleanup_dmi_name(card->dmi_longname + len);
|
|
|
|
|
|
|
|
/* some vendors like Lenovo may only put a self-explanatory
|
|
|
|
* name in the product version field
|
|
|
|
*/
|
|
|
|
product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);
|
2017-06-28 14:01:39 +07:00
|
|
|
if (product_version && is_dmi_valid(product_version)) {
|
2017-01-14 15:13:02 +07:00
|
|
|
len = strlen(card->dmi_longname);
|
|
|
|
snprintf(card->dmi_longname + len,
|
|
|
|
longname_buf_size - len,
|
|
|
|
"-%s", product_version);
|
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len < longname_buf_size)
|
|
|
|
cleanup_dmi_name(card->dmi_longname + len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
board = dmi_get_system_info(DMI_BOARD_NAME);
|
2017-06-28 14:01:39 +07:00
|
|
|
if (board && is_dmi_valid(board)) {
|
2017-01-14 15:13:02 +07:00
|
|
|
len = strlen(card->dmi_longname);
|
|
|
|
snprintf(card->dmi_longname + len,
|
|
|
|
longname_buf_size - len,
|
|
|
|
"-%s", board);
|
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len < longname_buf_size)
|
|
|
|
cleanup_dmi_name(card->dmi_longname + len);
|
|
|
|
} else if (!product) {
|
|
|
|
/* fall back to using legacy name */
|
|
|
|
dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add flavour to dmi long name */
|
|
|
|
if (flavour) {
|
|
|
|
len = strlen(card->dmi_longname);
|
|
|
|
snprintf(card->dmi_longname + len,
|
|
|
|
longname_buf_size - len,
|
|
|
|
"-%s", flavour);
|
|
|
|
|
|
|
|
len++;
|
|
|
|
if (len < longname_buf_size)
|
|
|
|
cleanup_dmi_name(card->dmi_longname + len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the card long name */
|
|
|
|
card->long_name = card->dmi_longname;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
|
2017-04-24 13:54:41 +07:00
|
|
|
#endif /* CONFIG_DMI */
|
2017-01-14 15:13:02 +07:00
|
|
|
|
2018-07-02 22:59:54 +07:00
|
|
|
static void soc_check_tplg_fes(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
const struct snd_soc_component_driver *comp_drv;
|
|
|
|
struct snd_soc_dai_link *dai_link;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
list_for_each_entry(component, &component_list, list) {
|
|
|
|
|
|
|
|
/* does this component override FEs ? */
|
|
|
|
if (!component->driver->ignore_machine)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* for this machine ? */
|
|
|
|
if (strcmp(component->driver->ignore_machine,
|
|
|
|
card->dev->driver->name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* machine matches, so override the rtd data */
|
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
|
|
|
|
dai_link = &card->dai_link[i];
|
|
|
|
|
|
|
|
/* ignore this FE */
|
|
|
|
if (dai_link->dynamic) {
|
|
|
|
dai_link->ignore = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_info(card->dev, "info: override FE DAI link %s\n",
|
|
|
|
card->dai_link[i].name);
|
|
|
|
|
|
|
|
/* override platform component */
|
|
|
|
dai_link->platform_name = component->name;
|
|
|
|
|
|
|
|
/* convert non BE into BE */
|
|
|
|
dai_link->no_pcm = 1;
|
|
|
|
|
|
|
|
/* override any BE fixups */
|
|
|
|
dai_link->be_hw_params_fixup =
|
|
|
|
component->driver->be_hw_params_fixup;
|
|
|
|
|
|
|
|
/* most BE links don't set stream name, so set it to
|
|
|
|
* dai link name if it's NULL to help bind widgets.
|
|
|
|
*/
|
|
|
|
if (!dai_link->stream_name)
|
|
|
|
dai_link->stream_name = dai_link->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Inform userspace we are using alternate topology */
|
|
|
|
if (component->driver->topology_name_prefix) {
|
|
|
|
|
|
|
|
/* topology shortname created ? */
|
|
|
|
if (!card->topology_shortname_created) {
|
|
|
|
comp_drv = component->driver;
|
|
|
|
|
|
|
|
snprintf(card->topology_shortname, 32, "%s-%s",
|
|
|
|
comp_drv->topology_name_prefix,
|
|
|
|
card->name);
|
|
|
|
card->topology_shortname_created = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* use topology shortname */
|
|
|
|
card->name = card->topology_shortname;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
static int snd_soc_instantiate_card(struct snd_soc_card *card)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2015-12-02 13:11:48 +07:00
|
|
|
struct snd_soc_dai_link *dai_link;
|
2015-01-06 21:17:20 +07:00
|
|
|
int ret, i, order;
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_lock(&client_mutex);
|
2012-03-07 17:38:25 +07:00
|
|
|
mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2018-07-02 22:59:54 +07:00
|
|
|
/* check whether any platform is ignore machine FE and using topology */
|
|
|
|
soc_check_tplg_fes(card);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* bind DAIs */
|
2012-03-15 04:18:39 +07:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
2015-11-23 23:03:52 +07:00
|
|
|
ret = soc_bind_dai_link(card, &card->dai_link[i]);
|
2012-03-15 04:18:39 +07:00
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2014-07-02 03:13:47 +07:00
|
|
|
/* bind aux_devs too */
|
2012-03-15 04:18:39 +07:00
|
|
|
for (i = 0; i < card->num_aux_devs; i++) {
|
2014-07-02 03:13:47 +07:00
|
|
|
ret = soc_bind_aux_dev(card, i);
|
2012-03-15 04:18:39 +07:00
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
/* add predefined DAI links to the list */
|
|
|
|
for (i = 0; i < card->num_links; i++)
|
|
|
|
snd_soc_add_dai_link(card, card->dai_link+i);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* card bind complete so register a sound card */
|
2014-01-29 20:42:55 +07:00
|
|
|
ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
|
2010-03-18 03:15:21 +07:00
|
|
|
card->owner, 0, &card->snd_card);
|
|
|
|
if (ret < 0) {
|
2013-05-05 03:21:38 +07:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: can't create sound card for card %s: %d\n",
|
|
|
|
card->name, ret);
|
2012-03-15 04:18:39 +07:00
|
|
|
goto base_error;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
2015-04-09 15:52:36 +07:00
|
|
|
soc_init_card_debugfs(card);
|
|
|
|
|
2011-03-03 01:21:57 +07:00
|
|
|
card->dapm.bias_level = SND_SOC_BIAS_OFF;
|
|
|
|
card->dapm.dev = card->dev;
|
|
|
|
card->dapm.card = card;
|
|
|
|
list_add(&card->dapm.list, &card->dapm_list);
|
|
|
|
|
2011-05-01 00:45:49 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
|
|
|
|
#endif
|
|
|
|
|
2011-02-02 17:43:26 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2010-03-18 03:15:21 +07:00
|
|
|
/* deferred resume work */
|
|
|
|
INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
|
|
|
|
#endif
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2011-04-13 07:51:37 +07:00
|
|
|
if (card->dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
|
|
|
|
card->num_dapm_widgets);
|
|
|
|
|
2015-02-15 08:22:49 +07:00
|
|
|
if (card->of_dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
|
|
|
|
card->num_of_dapm_widgets);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* initialise the sound card only once */
|
|
|
|
if (card->probe) {
|
2011-01-26 21:17:20 +07:00
|
|
|
ret = card->probe(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto card_probe_error;
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
/* probe all components used by DAI links on this card */
|
2011-06-07 22:08:05 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
ret = soc_probe_link_components(card, rtd, order);
|
2011-06-07 22:08:05 +07:00
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: failed to instantiate card %d\n",
|
|
|
|
ret);
|
2012-06-09 01:34:23 +07:00
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
/* probe auxiliary components */
|
|
|
|
ret = soc_probe_aux_devices(card);
|
|
|
|
if (ret < 0)
|
|
|
|
goto probe_dai_err;
|
|
|
|
|
2015-12-02 13:11:48 +07:00
|
|
|
/* Find new DAI links added during probing components and bind them.
|
|
|
|
* Components with topology may bring new DAIs and DAI links.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(dai_link, &card->dai_link_list, list) {
|
|
|
|
if (soc_is_dai_link_bound(card, dai_link))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = soc_init_dai_link(card, dai_link);
|
|
|
|
if (ret)
|
|
|
|
goto probe_dai_err;
|
|
|
|
ret = soc_bind_dai_link(card, dai_link);
|
|
|
|
if (ret)
|
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
/* probe all DAI links on this card */
|
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
ret = soc_probe_link_dais(card, rtd, order);
|
2012-06-09 01:34:23 +07:00
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: failed to instantiate card %d\n",
|
|
|
|
ret);
|
2011-06-07 22:08:05 +07:00
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-02-17 10:37:51 +07:00
|
|
|
snd_soc_dapm_link_dai_widgets(card);
|
2014-01-08 17:40:19 +07:00
|
|
|
snd_soc_dapm_connect_dai_link_widgets(card);
|
2012-02-17 10:37:51 +07:00
|
|
|
|
2011-04-07 17:18:44 +07:00
|
|
|
if (card->controls)
|
2012-02-04 00:43:09 +07:00
|
|
|
snd_soc_add_card_controls(card, card->controls, card->num_controls);
|
2011-04-07 17:18:44 +07:00
|
|
|
|
2011-03-03 01:35:51 +07:00
|
|
|
if (card->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
|
|
|
|
card->num_dapm_routes);
|
|
|
|
|
2015-02-15 08:22:49 +07:00
|
|
|
if (card->of_dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
|
|
|
|
card->num_of_dapm_routes);
|
2011-09-27 22:41:01 +07:00
|
|
|
|
2017-04-24 13:54:42 +07:00
|
|
|
/* try to set some sane longname if DMI is available */
|
|
|
|
snd_soc_set_dmi_name(card, NULL);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
|
|
|
|
"%s", card->name);
|
2011-05-12 22:14:04 +07:00
|
|
|
snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
|
|
|
|
"%s", card->long_name ? card->long_name : card->name);
|
2011-09-20 17:41:54 +07:00
|
|
|
snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
|
|
|
|
"%s", card->driver_name ? card->driver_name : card->name);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
|
|
|
|
switch (card->snd_card->driver[i]) {
|
|
|
|
case '_':
|
|
|
|
case '-':
|
|
|
|
case '\0':
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!isalnum(card->snd_card->driver[i]))
|
|
|
|
card->snd_card->driver[i] = '_';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-03-03 01:36:34 +07:00
|
|
|
if (card->late_probe) {
|
|
|
|
ret = card->late_probe(card);
|
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
|
2011-03-03 01:36:34 +07:00
|
|
|
card->name, ret);
|
|
|
|
goto probe_aux_dev_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-27 20:51:01 +07:00
|
|
|
snd_soc_dapm_new_widgets(card);
|
2013-08-27 20:51:00 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
ret = snd_card_register(card->snd_card);
|
|
|
|
if (ret < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
|
|
|
|
ret);
|
2010-12-07 15:12:29 +07:00
|
|
|
goto probe_aux_dev_err;
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
card->instantiated = 1;
|
2011-10-07 20:29:19 +07:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_unlock(&card->mutex);
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
2012-03-15 04:18:39 +07:00
|
|
|
|
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2010-11-25 22:47:38 +07:00
|
|
|
probe_aux_dev_err:
|
2016-01-06 12:29:31 +07:00
|
|
|
soc_remove_aux_devices(card);
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
probe_dai_err:
|
2011-04-08 12:50:44 +07:00
|
|
|
soc_remove_dai_links(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
card_probe_error:
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->remove)
|
2011-01-26 21:17:20 +07:00
|
|
|
card->remove(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2015-07-09 03:14:48 +07:00
|
|
|
snd_soc_dapm_free(&card->dapm);
|
2015-04-09 15:52:36 +07:00
|
|
|
soc_cleanup_card_debugfs(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
base_error:
|
2015-11-18 14:34:11 +07:00
|
|
|
soc_remove_pcm_runtimes(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_unlock(&card->mutex);
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
return ret;
|
2008-12-04 22:32:53 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* probes a new socdev */
|
|
|
|
static int soc_probe(struct platform_device *pdev)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2011-01-14 20:52:48 +07:00
|
|
|
/*
|
|
|
|
* no card, so machine driver should be registering card
|
|
|
|
* we should not be here in that case so ret error
|
|
|
|
*/
|
|
|
|
if (!card)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-03-02 20:07:41 +07:00
|
|
|
dev_warn(&pdev->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: machine %s should use snd_soc_register_card()\n",
|
2012-03-02 20:07:41 +07:00
|
|
|
card->name);
|
|
|
|
|
2008-12-04 22:32:53 +07:00
|
|
|
/* Bodge while we unpick instantiation */
|
|
|
|
card->dev = &pdev->dev;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-08-10 00:45:23 +07:00
|
|
|
return snd_soc_register_card(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
static int soc_cleanup_card_resources(struct snd_soc_card *card)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* make sure any delayed work runs */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2009-05-11 17:04:55 +07:00
|
|
|
|
2017-05-24 15:19:45 +07:00
|
|
|
/* free the ALSA card at first; this syncs with pending operations */
|
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* remove and free each DAI */
|
2011-04-08 12:50:44 +07:00
|
|
|
soc_remove_dai_links(card);
|
2015-11-18 14:34:11 +07:00
|
|
|
soc_remove_pcm_runtimes(card);
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2016-01-06 12:29:31 +07:00
|
|
|
/* remove auxiliary devices */
|
|
|
|
soc_remove_aux_devices(card);
|
|
|
|
|
2016-08-19 01:32:59 +07:00
|
|
|
snd_soc_dapm_free(&card->dapm);
|
2011-01-14 00:18:02 +07:00
|
|
|
soc_cleanup_card_debugfs(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* remove the card */
|
|
|
|
if (card->remove)
|
2011-01-26 21:17:20 +07:00
|
|
|
card->remove(card);
|
2010-11-06 01:35:19 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* removes a socdev */
|
|
|
|
static int soc_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
snd_soc_unregister_card(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_poweroff(struct device *dev)
|
2009-06-22 19:16:51 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2009-06-22 19:16:51 +07:00
|
|
|
|
|
|
|
if (!card->instantiated)
|
2009-07-01 01:05:15 +07:00
|
|
|
return 0;
|
2009-06-22 19:16:51 +07:00
|
|
|
|
|
|
|
/* Flush out pmdown_time work - we actually do want to run it
|
|
|
|
* now, we're shutting down so no imminent restart. */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2009-06-22 19:16:51 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_soc_dapm_shutdown(card);
|
2009-07-01 01:05:15 +07:00
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
/* deactivate pins to sleep state */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2015-11-18 14:34:11 +07:00
|
|
|
int i;
|
2014-07-09 04:19:34 +07:00
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
2015-11-18 14:34:11 +07:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
|
2014-07-09 04:19:34 +07:00
|
|
|
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
|
|
|
}
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
}
|
|
|
|
|
2009-07-01 01:05:15 +07:00
|
|
|
return 0;
|
2009-06-22 19:16:51 +07:00
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
|
2009-06-22 19:16:51 +07:00
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
const struct dev_pm_ops snd_soc_pm_ops = {
|
2012-02-24 17:55:49 +07:00
|
|
|
.suspend = snd_soc_suspend,
|
|
|
|
.resume = snd_soc_resume,
|
|
|
|
.freeze = snd_soc_suspend,
|
|
|
|
.thaw = snd_soc_resume,
|
2011-01-26 21:59:27 +07:00
|
|
|
.poweroff = snd_soc_poweroff,
|
2012-02-24 17:55:49 +07:00
|
|
|
.restore = snd_soc_resume,
|
2009-07-01 01:05:15 +07:00
|
|
|
};
|
2011-04-06 08:35:30 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
|
2009-07-01 01:05:15 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/* ASoC platform driver */
|
|
|
|
static struct platform_driver soc_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "soc-audio",
|
2011-01-26 21:59:27 +07:00
|
|
|
.pm = &snd_soc_pm_ops,
|
2006-10-06 23:31:09 +07:00
|
|
|
},
|
|
|
|
.probe = soc_probe,
|
|
|
|
.remove = soc_remove,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_cnew - create new control
|
|
|
|
* @_template: control template
|
|
|
|
* @data: control private data
|
2009-01-01 19:18:17 +07:00
|
|
|
* @long_name: control long name
|
2011-03-09 00:23:24 +07:00
|
|
|
* @prefix: control name prefix
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Create a new mixer control from a template control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success, else error.
|
|
|
|
*/
|
|
|
|
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
|
2012-02-17 08:07:42 +07:00
|
|
|
void *data, const char *long_name,
|
2011-03-09 00:23:24 +07:00
|
|
|
const char *prefix)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
|
|
|
struct snd_kcontrol_new template;
|
2011-03-09 00:23:24 +07:00
|
|
|
struct snd_kcontrol *kcontrol;
|
|
|
|
char *name = NULL;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
memcpy(&template, _template, sizeof(template));
|
|
|
|
template.index = 0;
|
|
|
|
|
2011-03-09 00:23:24 +07:00
|
|
|
if (!long_name)
|
|
|
|
long_name = template.name;
|
|
|
|
|
|
|
|
if (prefix) {
|
2013-05-14 16:05:32 +07:00
|
|
|
name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
|
2011-03-09 00:23:24 +07:00
|
|
|
if (!name)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
template.name = name;
|
|
|
|
} else {
|
|
|
|
template.name = long_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
kcontrol = snd_ctl_new1(&template, data);
|
|
|
|
|
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
return kcontrol;
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_cnew);
|
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls,
|
|
|
|
const char *prefix, void *data)
|
|
|
|
{
|
|
|
|
int err, i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_controls; i++) {
|
|
|
|
const struct snd_kcontrol_new *control = &controls[i];
|
|
|
|
err = snd_ctl_add(card, snd_soc_cnew(control, data,
|
|
|
|
control->name, prefix));
|
|
|
|
if (err < 0) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(dev, "ASoC: Failed to add %s: %d\n",
|
|
|
|
control->name, err);
|
2012-02-04 00:43:09 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:51:58 +07:00
|
|
|
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct snd_card *card = soc_card->snd_card;
|
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
|
|
|
|
if (unlikely(!name))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
list_for_each_entry(kctl, &card->controls, list)
|
|
|
|
if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
|
|
|
|
return kctl;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
|
|
|
|
|
2014-07-18 03:01:08 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_add_component_controls - Add an array of controls to a component.
|
|
|
|
*
|
|
|
|
* @component: Component to add controls to
|
|
|
|
* @controls: Array of controls to add
|
|
|
|
* @num_controls: Number of elements in the array
|
|
|
|
*
|
|
|
|
* Return: 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_component_controls(struct snd_soc_component *component,
|
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls)
|
|
|
|
{
|
|
|
|
struct snd_card *card = component->card->snd_card;
|
|
|
|
|
|
|
|
return snd_soc_add_controls(card, component->dev, controls,
|
|
|
|
num_controls, component->name_prefix, component);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
|
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_add_card_controls - add an array of controls to a SoC card.
|
|
|
|
* Convenience function to add a list of controls.
|
|
|
|
*
|
|
|
|
* @soc_card: SoC card to add controls to
|
|
|
|
* @controls: array of controls to add
|
|
|
|
* @num_controls: number of elements in the array
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
|
|
|
struct snd_card *card = soc_card->snd_card;
|
|
|
|
|
|
|
|
return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
|
|
|
|
NULL, soc_card);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_add_dai_controls - add an array of controls to a DAI.
|
|
|
|
* Convienience function to add a list of controls.
|
|
|
|
*
|
|
|
|
* @dai: DAI to add controls to
|
|
|
|
* @controls: array of controls to add
|
|
|
|
* @num_controls: number of elements in the array
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
2014-11-04 17:30:58 +07:00
|
|
|
struct snd_card *card = dai->component->card->snd_card;
|
2012-02-04 00:43:09 +07:00
|
|
|
|
|
|
|
return snd_soc_add_controls(card, dai->dev, controls, num_controls,
|
|
|
|
NULL, dai);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_sysclk - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @clk_id: DAI specific clock ID
|
|
|
|
* @freq: new clock frequency in Hz
|
|
|
|
* @dir: new clock direction - input/output.
|
|
|
|
*
|
|
|
|
* Configures the DAI master (MCLK) or system (SYSCLK) clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
|
|
|
|
unsigned int freq, int dir)
|
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_sysclk)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
|
2017-08-24 07:57:35 +07:00
|
|
|
|
|
|
|
return snd_soc_component_set_sysclk(dai->component, clk_id, 0,
|
|
|
|
freq, dir);
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
|
|
|
|
|
2017-08-24 07:57:35 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_component_set_sysclk - configure COMPONENT system or master clock.
|
|
|
|
* @component: COMPONENT
|
|
|
|
* @clk_id: DAI specific clock ID
|
|
|
|
* @source: Source for the clock
|
|
|
|
* @freq: new clock frequency in Hz
|
|
|
|
* @dir: new clock direction - input/output.
|
|
|
|
*
|
|
|
|
* Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_component_set_sysclk(struct snd_soc_component *component, int clk_id,
|
|
|
|
int source, unsigned int freq, int dir)
|
|
|
|
{
|
|
|
|
if (component->driver->set_sysclk)
|
|
|
|
return component->driver->set_sysclk(component, clk_id, source,
|
|
|
|
freq, dir);
|
|
|
|
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_clkdiv - configure DAI clock dividers.
|
|
|
|
* @dai: DAI
|
2009-01-01 19:18:17 +07:00
|
|
|
* @div_id: DAI specific clock divider ID
|
2008-07-08 19:19:13 +07:00
|
|
|
* @div: new clock divisor.
|
|
|
|
*
|
|
|
|
* Configures the clock dividers. This is used to derive the best DAI bit and
|
|
|
|
* frame clocks from the system or master clock. It's best to set the DAI bit
|
|
|
|
* and frame clocks as low as possible to save system power.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
|
|
|
|
int div_id, int div)
|
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_clkdiv)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_clkdiv(dai, div_id, div);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_pll - configure DAI PLL.
|
|
|
|
* @dai: DAI
|
|
|
|
* @pll_id: DAI specific PLL ID
|
2009-09-06 00:52:16 +07:00
|
|
|
* @source: DAI specific source for the PLL
|
2008-07-08 19:19:13 +07:00
|
|
|
* @freq_in: PLL input clock frequency in Hz
|
|
|
|
* @freq_out: requested PLL output clock frequency in Hz
|
|
|
|
*
|
|
|
|
* Configures and enables PLL to generate output clock based on input clock.
|
|
|
|
*/
|
2009-09-06 00:52:16 +07:00
|
|
|
int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
|
|
|
|
unsigned int freq_in, unsigned int freq_out)
|
2008-07-08 19:19:13 +07:00
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_pll)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_pll(dai, pll_id, source,
|
2009-09-06 00:52:16 +07:00
|
|
|
freq_in, freq_out);
|
2017-08-24 07:57:51 +07:00
|
|
|
|
|
|
|
return snd_soc_component_set_pll(dai->component, pll_id, source,
|
|
|
|
freq_in, freq_out);
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
|
|
|
|
|
2017-08-24 07:57:51 +07:00
|
|
|
/*
|
|
|
|
* snd_soc_component_set_pll - configure component PLL.
|
|
|
|
* @component: COMPONENT
|
|
|
|
* @pll_id: DAI specific PLL ID
|
|
|
|
* @source: DAI specific source for the PLL
|
|
|
|
* @freq_in: PLL input clock frequency in Hz
|
|
|
|
* @freq_out: requested PLL output clock frequency in Hz
|
|
|
|
*
|
|
|
|
* Configures and enables PLL to generate output clock based on input clock.
|
|
|
|
*/
|
|
|
|
int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
|
|
|
|
int source, unsigned int freq_in,
|
|
|
|
unsigned int freq_out)
|
|
|
|
{
|
|
|
|
if (component->driver->set_pll)
|
|
|
|
return component->driver->set_pll(component, pll_id, source,
|
|
|
|
freq_in, freq_out);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);
|
|
|
|
|
2013-09-16 19:01:46 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
|
|
|
|
* @dai: DAI
|
2015-07-15 21:02:38 +07:00
|
|
|
* @ratio: Ratio of BCLK to Sample rate.
|
2013-09-16 19:01:46 +07:00
|
|
|
*
|
|
|
|
* Configures the DAI for a preset BCLK to sample rate ratio.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
|
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_bclk_ratio)
|
2013-09-16 19:01:46 +07:00
|
|
|
return dai->driver->ops->set_bclk_ratio(dai, ratio);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_fmt - configure DAI hardware audio format.
|
|
|
|
* @dai: DAI
|
2017-10-30 07:10:34 +07:00
|
|
|
* @fmt: SND_SOC_DAIFMT_* format value.
|
2008-07-08 19:19:13 +07:00
|
|
|
*
|
|
|
|
* Configures the DAI hardware format and clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
|
|
|
|
{
|
2012-03-08 23:59:40 +07:00
|
|
|
if (dai->driver == NULL)
|
2008-07-08 19:19:13 +07:00
|
|
|
return -EINVAL;
|
2012-03-08 23:59:40 +07:00
|
|
|
if (dai->driver->ops->set_fmt == NULL)
|
|
|
|
return -ENOTSUPP;
|
|
|
|
return dai->driver->ops->set_fmt(dai, fmt);
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
|
|
|
|
|
2014-02-14 08:34:35 +07:00
|
|
|
/**
|
2014-03-21 13:17:12 +07:00
|
|
|
* snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
|
2014-02-14 08:34:35 +07:00
|
|
|
* @slots: Number of slots in use.
|
|
|
|
* @tx_mask: bitmask representing active TX slots.
|
|
|
|
* @rx_mask: bitmask representing active RX slots.
|
|
|
|
*
|
|
|
|
* Generates the TDM tx and rx slot default masks for DAI.
|
|
|
|
*/
|
2014-03-21 13:17:12 +07:00
|
|
|
static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
|
2014-02-14 08:34:35 +07:00
|
|
|
unsigned int *tx_mask,
|
|
|
|
unsigned int *rx_mask)
|
|
|
|
{
|
|
|
|
if (*tx_mask || *rx_mask)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!slots)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
*tx_mask = (1 << slots) - 1;
|
|
|
|
*rx_mask = (1 << slots) - 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
2015-01-12 16:27:20 +07:00
|
|
|
* snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
|
|
|
|
* @dai: The DAI to configure
|
2009-06-16 07:44:31 +07:00
|
|
|
* @tx_mask: bitmask representing active TX slots.
|
|
|
|
* @rx_mask: bitmask representing active RX slots.
|
2008-07-08 19:19:13 +07:00
|
|
|
* @slots: Number of slots in use.
|
2009-06-16 07:44:31 +07:00
|
|
|
* @slot_width: Width in bits for each slot.
|
2008-07-08 19:19:13 +07:00
|
|
|
*
|
2015-01-12 16:27:20 +07:00
|
|
|
* This function configures the specified DAI for TDM operation. @slot contains
|
|
|
|
* the total number of slots of the TDM stream and @slot_with the width of each
|
|
|
|
* slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
|
|
|
|
* active slots of the TDM stream for the specified DAI, i.e. which slots the
|
|
|
|
* DAI should write to or read from. If a bit is set the corresponding slot is
|
|
|
|
* active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
|
|
|
|
* the first slot, bit 1 to the second slot and so on. The first active slot
|
|
|
|
* maps to the first channel of the DAI, the second active slot to the second
|
|
|
|
* channel and so on.
|
|
|
|
*
|
|
|
|
* TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
|
|
|
|
* @rx_mask and @slot_width will be ignored.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, a negative error code otherwise.
|
2008-07-08 19:19:13 +07:00
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
|
2009-06-16 07:44:31 +07:00
|
|
|
unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
|
2008-07-08 19:19:13 +07:00
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->xlate_tdm_slot_mask)
|
2014-03-21 13:17:12 +07:00
|
|
|
dai->driver->ops->xlate_tdm_slot_mask(slots,
|
2014-02-14 08:34:35 +07:00
|
|
|
&tx_mask, &rx_mask);
|
|
|
|
else
|
2014-03-21 13:17:12 +07:00
|
|
|
snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
|
2014-02-14 08:34:35 +07:00
|
|
|
|
2014-07-09 04:19:34 +07:00
|
|
|
dai->tx_mask = tx_mask;
|
|
|
|
dai->rx_mask = rx_mask;
|
|
|
|
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_tdm_slot)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
|
2009-06-16 07:44:31 +07:00
|
|
|
slots, slot_width);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
2014-01-23 12:02:47 +07:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
|
|
|
|
|
2009-09-12 00:16:29 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_channel_map - configure DAI audio channel map
|
|
|
|
* @dai: DAI
|
|
|
|
* @tx_num: how many TX channels
|
|
|
|
* @tx_slot: pointer to an array which imply the TX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
* @rx_num: how many RX channels
|
|
|
|
* @rx_slot: pointer to an array which imply the RX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
*
|
|
|
|
* configure the relationship between channel number and TDM slot number.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
|
|
|
|
unsigned int tx_num, unsigned int *tx_slot,
|
|
|
|
unsigned int rx_num, unsigned int *rx_slot)
|
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_channel_map)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
|
2009-09-12 00:16:29 +07:00
|
|
|
rx_num, rx_slot);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
|
|
|
|
|
2018-07-23 22:54:03 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_get_channel_map - Get DAI audio channel map
|
|
|
|
* @dai: DAI
|
|
|
|
* @tx_num: how many TX channels
|
|
|
|
* @tx_slot: pointer to an array which imply the TX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
* @rx_num: how many RX channels
|
|
|
|
* @rx_slot: pointer to an array which imply the RX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_get_channel_map(struct snd_soc_dai *dai,
|
|
|
|
unsigned int *tx_num, unsigned int *tx_slot,
|
|
|
|
unsigned int *rx_num, unsigned int *rx_slot)
|
|
|
|
{
|
|
|
|
if (dai->driver->ops->get_channel_map)
|
|
|
|
return dai->driver->ops->get_channel_map(dai, tx_num, tx_slot,
|
|
|
|
rx_num, rx_slot);
|
|
|
|
else
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_tristate - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @tristate: tristate enable
|
|
|
|
*
|
|
|
|
* Tristates the DAI so that others can use it.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
|
|
|
|
{
|
2017-09-25 08:38:34 +07:00
|
|
|
if (dai->driver->ops->set_tristate)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->set_tristate(dai, tristate);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dai_digital_mute - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @mute: mute enable
|
2013-02-06 22:44:07 +07:00
|
|
|
* @direction: stream to mute
|
2008-07-08 19:19:13 +07:00
|
|
|
*
|
|
|
|
* Mutes the DAI DAC.
|
|
|
|
*/
|
2013-02-06 22:44:07 +07:00
|
|
|
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
|
|
|
|
int direction)
|
2008-07-08 19:19:13 +07:00
|
|
|
{
|
2013-02-06 22:44:07 +07:00
|
|
|
if (!dai->driver)
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
|
|
|
if (dai->driver->ops->mute_stream)
|
|
|
|
return dai->driver->ops->mute_stream(dai, mute, direction);
|
|
|
|
else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
|
|
|
|
dai->driver->ops->digital_mute)
|
2010-03-18 03:15:21 +07:00
|
|
|
return dai->driver->ops->digital_mute(dai, mute);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
2012-04-14 01:16:03 +07:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
|
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_card - Register a card with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @card: Card to register
|
2008-11-28 20:29:45 +07:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 20:52:48 +07:00
|
|
|
int snd_soc_register_card(struct snd_soc_card *card)
|
2008-11-28 20:29:45 +07:00
|
|
|
{
|
2015-11-23 23:01:49 +07:00
|
|
|
int i, ret;
|
2015-11-18 14:34:11 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
if (!card->name || !card->dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-12-22 00:40:59 +07:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
struct snd_soc_dai_link *link = &card->dai_link[i];
|
|
|
|
|
2015-11-23 23:01:49 +07:00
|
|
|
ret = soc_init_dai_link(card, link);
|
2014-07-09 04:19:34 +07:00
|
|
|
if (ret) {
|
2015-11-23 23:01:49 +07:00
|
|
|
dev_err(card->dev, "ASoC: failed to init link %s\n",
|
2013-05-05 03:21:38 +07:00
|
|
|
link->name);
|
2015-11-23 23:01:49 +07:00
|
|
|
return ret;
|
2011-12-22 00:40:59 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-04 00:25:34 +07:00
|
|
|
dev_set_drvdata(card->dev, card);
|
|
|
|
|
2011-01-29 04:26:35 +07:00
|
|
|
snd_soc_initialize_card_lists(card);
|
|
|
|
|
2015-12-02 13:11:22 +07:00
|
|
|
INIT_LIST_HEAD(&card->dai_link_list);
|
|
|
|
card->num_dai_links = 0;
|
|
|
|
|
2015-11-18 14:34:11 +07:00
|
|
|
INIT_LIST_HEAD(&card->rtd_list);
|
|
|
|
card->num_rtd = 0;
|
|
|
|
|
2011-10-04 03:06:40 +07:00
|
|
|
INIT_LIST_HEAD(&card->dapm_dirty);
|
2015-05-30 01:06:14 +07:00
|
|
|
INIT_LIST_HEAD(&card->dobj_list);
|
2008-11-28 20:29:45 +07:00
|
|
|
card->instantiated = 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_init(&card->mutex);
|
2012-03-07 17:38:26 +07:00
|
|
|
mutex_init(&card->dapm_mutex);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
ret = snd_soc_instantiate_card(card);
|
|
|
|
if (ret != 0)
|
2015-03-24 16:01:00 +07:00
|
|
|
return ret;
|
2008-11-28 20:29:45 +07:00
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
/* deactivate pins to sleep state */
|
2015-11-18 14:34:11 +07:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-09 04:19:34 +07:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
for (j = 0; j < rtd->num_codecs; j++) {
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
|
|
|
|
if (!codec_dai->active)
|
|
|
|
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
|
|
|
}
|
|
|
|
|
ASoC: Add pinctrl PM to components of active DAIs
It's quite popular that more drivers are using pinctrl PM, for example:
(Documentation/devicetree/bindings/arm/primecell.txt). Just like what
runtime PM does, it would deactivate and activate pin group depending
on whether it's being used or not.
And this pinctrl PM might be also beneficial to cpu dai drivers because
they might have actual pinctrl so as to sleep their pins and wake them
up as needed.
To achieve this goal, this patch sets pins to the default state during
resume or startup; While during suspend and shutdown, it would set pins
to the sleep state.
As pinctrl PM would return zero if there is no such pinctrl sleep state
settings, this patch would not break current ASoC subsystem directly.
[ However, there is still an exception that the patch can not handle,
that is, when cpu dai driver does not have pinctrl property but another
device has it. (The AUDMUX <-> SSI on Freescale i.MX6 series for example.
SSI as a cpu dai doesn't contain pinctrl property while AUDMUX, an Audio
Multiplexer, has it). In this case, this kind of cpu dai driver needs to
find a way to obtain the pinctrl property as its own, by moving property
from AUDMUX to SSI, or creating a pins link/dependency between these two
devices, or using a more decent way after we figure it out. ]
Signed-off-by: Nicolin Chen <b42378@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2013-11-04 13:57:31 +07:00
|
|
|
if (!cpu_dai->active)
|
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
|
|
|
}
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
return ret;
|
2008-11-28 20:29:45 +07:00
|
|
|
}
|
2011-01-14 20:52:48 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_card);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_card - Unregister a card with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @card: Card to unregister
|
2008-11-28 20:29:45 +07:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 20:52:48 +07:00
|
|
|
int snd_soc_unregister_card(struct snd_soc_card *card)
|
2008-11-28 20:29:45 +07:00
|
|
|
{
|
2014-09-05 00:44:04 +07:00
|
|
|
if (card->instantiated) {
|
|
|
|
card->instantiated = false;
|
2014-09-05 00:44:05 +07:00
|
|
|
snd_soc_dapm_shutdown(card);
|
2011-01-14 00:18:02 +07:00
|
|
|
soc_cleanup_card_resources(card);
|
2015-02-05 12:34:10 +07:00
|
|
|
dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
|
2014-09-05 00:44:04 +07:00
|
|
|
}
|
2008-11-28 20:29:45 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-14 20:52:48 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/*
|
|
|
|
* Simplify DAI link configuration by removing ".-1" from device names
|
|
|
|
* and sanitizing names.
|
|
|
|
*/
|
2010-12-06 22:49:20 +07:00
|
|
|
static char *fmt_single_name(struct device *dev, int *id)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
|
|
|
char *found, name[NAME_SIZE];
|
|
|
|
int id1, id2;
|
|
|
|
|
|
|
|
if (dev_name(dev) == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2010-12-06 22:42:17 +07:00
|
|
|
strlcpy(name, dev_name(dev), NAME_SIZE);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* are we a "%s.%d" name (platform and SPI components) */
|
|
|
|
found = strstr(name, dev->driver->name);
|
|
|
|
if (found) {
|
|
|
|
/* get ID */
|
|
|
|
if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
|
|
|
|
|
|
|
|
/* discard ID from name if ID == -1 */
|
|
|
|
if (*id == -1)
|
|
|
|
found[strlen(dev->driver->name)] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* I2C component devices are named "bus-addr" */
|
|
|
|
if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
|
|
|
|
char tmp[NAME_SIZE];
|
|
|
|
|
|
|
|
/* create unique ID number from I2C addr and bus */
|
2010-10-19 15:10:45 +07:00
|
|
|
*id = ((id1 & 0xffff) << 16) + id2;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* sanitize component name for DAI link creation */
|
|
|
|
snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
|
2010-12-06 22:42:17 +07:00
|
|
|
strlcpy(name, tmp, NAME_SIZE);
|
2010-03-18 03:15:21 +07:00
|
|
|
} else
|
|
|
|
*id = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kstrdup(name, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Simplify DAI link naming for single devices with multiple DAIs by removing
|
|
|
|
* any ".-1" and using the DAI name (instead of device name).
|
|
|
|
*/
|
|
|
|
static inline char *fmt_multiple_name(struct device *dev,
|
|
|
|
struct snd_soc_dai_driver *dai_drv)
|
|
|
|
{
|
|
|
|
if (dai_drv->name == NULL) {
|
2013-05-05 03:21:38 +07:00
|
|
|
dev_err(dev,
|
|
|
|
"ASoC: error - multiple DAI %s registered with no name\n",
|
|
|
|
dev_name(dev));
|
2010-03-18 03:15:21 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kstrdup(dai_drv->name, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
/**
|
2014-03-09 23:41:45 +07:00
|
|
|
* snd_soc_unregister_dai - Unregister DAIs from the ASoC core
|
2008-12-01 06:31:24 +07:00
|
|
|
*
|
2014-03-09 23:41:45 +07:00
|
|
|
* @component: The component for which the DAIs should be unregistered
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2014-03-09 23:41:45 +07:00
|
|
|
static void snd_soc_unregister_dais(struct snd_soc_component *component)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
2014-03-12 14:34:39 +07:00
|
|
|
struct snd_soc_dai *dai, *_dai;
|
2008-12-01 06:31:24 +07:00
|
|
|
|
2014-03-12 14:34:39 +07:00
|
|
|
list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
|
2014-03-09 23:41:45 +07:00
|
|
|
dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
|
|
|
|
dai->name);
|
2014-03-12 14:34:39 +07:00
|
|
|
list_del(&dai->list);
|
2014-03-09 23:41:45 +07:00
|
|
|
kfree(dai->name);
|
2010-03-18 03:15:21 +07:00
|
|
|
kfree(dai);
|
|
|
|
}
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
|
|
|
|
2015-12-31 15:40:20 +07:00
|
|
|
/* Create a DAI and add it to the component's DAI list */
|
|
|
|
static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
bool legacy_dai_naming)
|
|
|
|
{
|
|
|
|
struct device *dev = component->dev;
|
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
|
|
|
|
|
|
|
|
dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
|
|
|
|
if (dai == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Back in the old days when we still had component-less DAIs,
|
|
|
|
* instead of having a static name, component-less DAIs would
|
|
|
|
* inherit the name of the parent device so it is possible to
|
|
|
|
* register multiple instances of the DAI. We still need to keep
|
|
|
|
* the same naming style even though those DAIs are not
|
|
|
|
* component-less anymore.
|
|
|
|
*/
|
|
|
|
if (legacy_dai_naming &&
|
|
|
|
(dai_drv->id == 0 || dai_drv->name == NULL)) {
|
|
|
|
dai->name = fmt_single_name(dev, &dai->id);
|
|
|
|
} else {
|
|
|
|
dai->name = fmt_multiple_name(dev, dai_drv);
|
|
|
|
if (dai_drv->id)
|
|
|
|
dai->id = dai_drv->id;
|
|
|
|
else
|
|
|
|
dai->id = component->num_dai;
|
|
|
|
}
|
|
|
|
if (dai->name == NULL) {
|
|
|
|
kfree(dai);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dai->component = component;
|
|
|
|
dai->dev = dev;
|
|
|
|
dai->driver = dai_drv;
|
|
|
|
if (!dai->driver->ops)
|
|
|
|
dai->driver->ops = &null_dai_ops;
|
|
|
|
|
2017-12-20 08:48:29 +07:00
|
|
|
list_add_tail(&dai->list, &component->dai_list);
|
2015-12-31 15:40:20 +07:00
|
|
|
component->num_dai++;
|
|
|
|
|
|
|
|
dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
|
|
|
|
return dai;
|
|
|
|
}
|
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
/**
|
2014-03-09 23:41:45 +07:00
|
|
|
* snd_soc_register_dais - Register a DAI with the ASoC core
|
2008-12-01 06:31:24 +07:00
|
|
|
*
|
2014-03-05 19:17:46 +07:00
|
|
|
* @component: The component the DAIs are registered for
|
|
|
|
* @dai_drv: DAI driver to use for the DAIs
|
2009-01-01 19:18:17 +07:00
|
|
|
* @count: Number of DAIs
|
2014-03-09 23:41:45 +07:00
|
|
|
* @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
|
|
|
|
* parent's name.
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2014-03-05 19:17:46 +07:00
|
|
|
static int snd_soc_register_dais(struct snd_soc_component *component,
|
2018-05-08 10:23:01 +07:00
|
|
|
struct snd_soc_dai_driver *dai_drv, size_t count)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
2014-03-05 19:17:46 +07:00
|
|
|
struct device *dev = component->dev;
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai *dai;
|
2014-03-09 23:41:45 +07:00
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2017-02-28 05:30:02 +07:00
|
|
|
dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
|
2008-12-01 06:31:24 +07:00
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2015-12-31 15:40:20 +07:00
|
|
|
dai = soc_add_dai(component, dai_drv + i,
|
2018-05-08 10:23:01 +07:00
|
|
|
count == 1 && !component->driver->non_legacy_dai_naming);
|
2010-11-03 14:04:45 +07:00
|
|
|
if (dai == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
err:
|
2014-03-09 23:41:45 +07:00
|
|
|
snd_soc_unregister_dais(component);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-12-31 15:40:43 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_dai - Register a DAI dynamically & create its widgets
|
|
|
|
*
|
|
|
|
* @component: The component the DAIs are registered for
|
|
|
|
* @dai_drv: DAI driver to use for the DAI
|
|
|
|
*
|
|
|
|
* Topology can use this API to register DAIs when probing a component.
|
|
|
|
* These DAIs's widgets will be freed in the card cleanup and the DAIs
|
|
|
|
* will be freed in the component cleanup.
|
|
|
|
*/
|
|
|
|
int snd_soc_register_dai(struct snd_soc_component *component,
|
|
|
|
struct snd_soc_dai_driver *dai_drv)
|
|
|
|
{
|
|
|
|
struct snd_soc_dapm_context *dapm =
|
|
|
|
snd_soc_component_get_dapm(component);
|
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
int ret;
|
2012-04-09 23:29:19 +07:00
|
|
|
|
2015-12-31 15:40:43 +07:00
|
|
|
if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
|
|
|
|
dev_err(component->dev, "Invalid dai type %d\n",
|
|
|
|
dai_drv->dobj.type);
|
|
|
|
return -EINVAL;
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
|
|
|
|
2015-12-31 15:40:43 +07:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
dai = soc_add_dai(component, dai_drv, false);
|
|
|
|
if (!dai)
|
|
|
|
return -ENOMEM;
|
2008-12-01 06:31:24 +07:00
|
|
|
|
2015-12-31 15:40:43 +07:00
|
|
|
/* Create the DAI widgets here. After adding DAIs, topology may
|
|
|
|
* also add routes that need these widgets as source or sink.
|
|
|
|
*/
|
|
|
|
ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(component->dev,
|
|
|
|
"Failed to create DAI widgets %d\n", ret);
|
|
|
|
}
|
2008-12-01 06:31:24 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2015-12-31 15:40:43 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_dai);
|
2008-12-01 06:31:24 +07:00
|
|
|
|
2014-06-16 23:13:08 +07:00
|
|
|
static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
|
|
|
|
enum snd_soc_dapm_type type, int subseq)
|
2013-09-05 09:39:03 +07:00
|
|
|
{
|
2014-06-16 23:13:08 +07:00
|
|
|
struct snd_soc_component *component = dapm->component;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:08 +07:00
|
|
|
component->driver->seq_notifier(component, type, subseq);
|
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:08 +07:00
|
|
|
static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
|
|
|
|
int event)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component = dapm->component;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:08 +07:00
|
|
|
return component->driver->stream_event(component, event);
|
|
|
|
}
|
2014-04-22 18:23:13 +07:00
|
|
|
|
2017-09-26 08:01:10 +07:00
|
|
|
static int snd_soc_component_set_bias_level(struct snd_soc_dapm_context *dapm,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component = dapm->component;
|
|
|
|
|
|
|
|
return component->driver->set_bias_level(component, level);
|
|
|
|
}
|
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
static int snd_soc_component_initialize(struct snd_soc_component *component,
|
|
|
|
const struct snd_soc_component_driver *driver, struct device *dev)
|
2013-09-05 09:39:03 +07:00
|
|
|
{
|
2014-06-16 23:13:06 +07:00
|
|
|
struct snd_soc_dapm_context *dapm;
|
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
component->name = fmt_single_name(dev, &component->id);
|
|
|
|
if (!component->name) {
|
|
|
|
dev_err(dev, "ASoC: Failed to allocate name\n");
|
2013-09-05 09:39:03 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
component->dev = dev;
|
|
|
|
component->driver = driver;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2017-08-25 08:06:04 +07:00
|
|
|
dapm = snd_soc_component_get_dapm(component);
|
2014-06-16 23:13:06 +07:00
|
|
|
dapm->dev = dev;
|
|
|
|
dapm->component = component;
|
|
|
|
dapm->bias_level = SND_SOC_BIAS_OFF;
|
2017-09-26 08:01:10 +07:00
|
|
|
dapm->idle_bias_off = !driver->idle_bias_on;
|
|
|
|
dapm->suspend_bias_off = driver->suspend_bias_off;
|
2014-06-16 23:13:08 +07:00
|
|
|
if (driver->seq_notifier)
|
|
|
|
dapm->seq_notifier = snd_soc_component_seq_notifier;
|
|
|
|
if (driver->stream_event)
|
|
|
|
dapm->stream_event = snd_soc_component_stream_event;
|
2017-09-26 08:01:10 +07:00
|
|
|
if (driver->set_bias_level)
|
|
|
|
dapm->set_bias_level = snd_soc_component_set_bias_level;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
INIT_LIST_HEAD(&component->dai_list);
|
|
|
|
mutex_init(&component->io_mutex);
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-11-19 01:45:52 +07:00
|
|
|
static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
|
2014-08-19 20:51:28 +07:00
|
|
|
{
|
2014-11-19 01:45:52 +07:00
|
|
|
int val_bytes = regmap_get_val_bytes(component->regmap);
|
|
|
|
|
|
|
|
/* Errors are legitimate for non-integer byte multiples */
|
|
|
|
if (val_bytes > 0)
|
|
|
|
component->val_bytes = val_bytes;
|
|
|
|
}
|
|
|
|
|
2014-11-26 03:41:03 +07:00
|
|
|
#ifdef CONFIG_REGMAP
|
|
|
|
|
2014-11-19 01:45:52 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_component_init_regmap() - Initialize regmap instance for the component
|
|
|
|
* @component: The component for which to initialize the regmap instance
|
|
|
|
* @regmap: The regmap instance that should be used by the component
|
|
|
|
*
|
|
|
|
* This function allows deferred assignment of the regmap instance that is
|
|
|
|
* associated with the component. Only use this if the regmap instance is not
|
|
|
|
* yet ready when the component is registered. The function must also be called
|
|
|
|
* before the first IO attempt of the component.
|
|
|
|
*/
|
|
|
|
void snd_soc_component_init_regmap(struct snd_soc_component *component,
|
|
|
|
struct regmap *regmap)
|
|
|
|
{
|
|
|
|
component->regmap = regmap;
|
|
|
|
snd_soc_component_setup_regmap(component);
|
2014-08-19 20:51:28 +07:00
|
|
|
}
|
2014-11-19 01:45:52 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
|
|
|
|
* @component: The component for which to de-initialize the regmap instance
|
|
|
|
*
|
|
|
|
* Calls regmap_exit() on the regmap instance associated to the component and
|
|
|
|
* removes the regmap instance from the component.
|
|
|
|
*
|
|
|
|
* This function should only be used if snd_soc_component_init_regmap() was used
|
|
|
|
* to initialize the regmap instance.
|
|
|
|
*/
|
|
|
|
void snd_soc_component_exit_regmap(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
regmap_exit(component->regmap);
|
|
|
|
component->regmap = NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
|
2014-08-19 20:51:28 +07:00
|
|
|
|
2014-11-26 03:41:03 +07:00
|
|
|
#endif
|
2014-08-19 20:51:28 +07:00
|
|
|
|
2018-05-08 10:22:11 +07:00
|
|
|
static void snd_soc_component_add(struct snd_soc_component *component)
|
2014-06-16 23:13:03 +07:00
|
|
|
{
|
2018-05-08 10:22:11 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
2018-05-08 10:20:24 +07:00
|
|
|
if (!component->driver->write && !component->driver->read) {
|
2014-11-19 01:45:52 +07:00
|
|
|
if (!component->regmap)
|
|
|
|
component->regmap = dev_get_regmap(component->dev, NULL);
|
|
|
|
if (component->regmap)
|
|
|
|
snd_soc_component_setup_regmap(component);
|
|
|
|
}
|
2014-08-19 20:51:28 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
list_add(&component->list, &component_list);
|
2015-05-30 01:06:14 +07:00
|
|
|
INIT_LIST_HEAD(&component->dobj_list);
|
2013-09-05 09:39:03 +07:00
|
|
|
|
|
|
|
mutex_unlock(&client_mutex);
|
2014-06-16 23:13:03 +07:00
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
static void snd_soc_component_cleanup(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
snd_soc_unregister_dais(component);
|
|
|
|
kfree(component->name);
|
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
|
|
|
|
{
|
ASoC: soc-core: verify Sound Card normality
Current ALSA SoC Sound Card basically consists of CPU/Codec/Platform
components. If system uses Kernel modules, we can disable these drivers
by using rmmod command. In such case, we can't disable
CPU/Codec/Platform driver without disabling Sound Card driver.
But on the other hand, we can disable these drivers by using unbind
command. In such case, we can disable these drivers randomly.
In this case, we can create dirty Sound Card which is missing necessary
components.
(1) If user disabled Sound Card first, but did nothing to other drivers,
user can't use Sound because Sound Card is no longer exists.
(2) If user disabled CPU/Codec/Platform driver randomly, but did nothing
to Sound Card, user still be able to use Sound Card, because dirty Sound
Card still exists. In this case, Sound system will be crashed if user
started sound playback/capture. But we can't block such random unbind
now.
To avoid Sound Card crash in (2) case, we need to unregister Sound Card
whenever CPU/Codec/Platform component were unregistered.
This patch solves this issue.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2017-04-03 13:31:22 +07:00
|
|
|
struct snd_soc_card *card = component->card;
|
|
|
|
|
|
|
|
if (card)
|
|
|
|
snd_soc_unregister_card(card);
|
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
list_del(&component->list);
|
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2017-10-11 08:38:29 +07:00
|
|
|
#define ENDIANNESS_MAP(name) \
|
|
|
|
(SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
|
|
|
|
static u64 endianness_format_map[] = {
|
|
|
|
ENDIANNESS_MAP(S16_),
|
|
|
|
ENDIANNESS_MAP(U16_),
|
|
|
|
ENDIANNESS_MAP(S24_),
|
|
|
|
ENDIANNESS_MAP(U24_),
|
|
|
|
ENDIANNESS_MAP(S32_),
|
|
|
|
ENDIANNESS_MAP(U32_),
|
|
|
|
ENDIANNESS_MAP(S24_3),
|
|
|
|
ENDIANNESS_MAP(U24_3),
|
|
|
|
ENDIANNESS_MAP(S20_3),
|
|
|
|
ENDIANNESS_MAP(U20_3),
|
|
|
|
ENDIANNESS_MAP(S18_3),
|
|
|
|
ENDIANNESS_MAP(U18_3),
|
|
|
|
ENDIANNESS_MAP(FLOAT_),
|
|
|
|
ENDIANNESS_MAP(FLOAT64_),
|
|
|
|
ENDIANNESS_MAP(IEC958_SUBFRAME_),
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix up the DAI formats for endianness: codecs don't actually see
|
|
|
|
* the endianness of the data but we're using the CPU format
|
|
|
|
* definitions which do need to include endianness so we ensure that
|
|
|
|
* codec DAIs always have both big and little endian variants set.
|
|
|
|
*/
|
|
|
|
static void convert_endianness_formats(struct snd_soc_pcm_stream *stream)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++)
|
|
|
|
if (stream->formats & endianness_format_map[i])
|
|
|
|
stream->formats |= endianness_format_map[i];
|
|
|
|
}
|
|
|
|
|
2017-10-02 12:10:17 +07:00
|
|
|
int snd_soc_add_component(struct device *dev,
|
|
|
|
struct snd_soc_component *component,
|
|
|
|
const struct snd_soc_component_driver *component_driver,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
int num_dai)
|
2013-09-05 09:39:03 +07:00
|
|
|
{
|
2014-06-16 23:13:03 +07:00
|
|
|
int ret;
|
2017-10-11 08:38:29 +07:00
|
|
|
int i;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2017-08-07 09:06:23 +07:00
|
|
|
ret = snd_soc_component_initialize(component, component_driver, dev);
|
2014-06-16 23:13:03 +07:00
|
|
|
if (ret)
|
|
|
|
goto err_free;
|
|
|
|
|
2017-10-11 08:38:29 +07:00
|
|
|
if (component_driver->endianness) {
|
|
|
|
for (i = 0; i < num_dai; i++) {
|
|
|
|
convert_endianness_formats(&dai_drv[i].playback);
|
|
|
|
convert_endianness_formats(&dai_drv[i].capture);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-08 10:23:01 +07:00
|
|
|
ret = snd_soc_register_dais(component, dai_drv, num_dai);
|
2014-06-16 23:13:03 +07:00
|
|
|
if (ret < 0) {
|
2015-02-24 21:11:26 +07:00
|
|
|
dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
|
2014-06-16 23:13:03 +07:00
|
|
|
goto err_cleanup;
|
|
|
|
}
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2017-08-07 09:06:23 +07:00
|
|
|
snd_soc_component_add(component);
|
2014-04-28 19:30:51 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
return 0;
|
2014-04-28 19:30:51 +07:00
|
|
|
|
2014-06-16 23:13:03 +07:00
|
|
|
err_cleanup:
|
2017-08-07 09:06:23 +07:00
|
|
|
snd_soc_component_cleanup(component);
|
2014-06-16 23:13:03 +07:00
|
|
|
err_free:
|
|
|
|
return ret;
|
2014-04-28 19:30:51 +07:00
|
|
|
}
|
2017-10-02 12:10:17 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_component);
|
|
|
|
|
|
|
|
int snd_soc_register_component(struct device *dev,
|
|
|
|
const struct snd_soc_component_driver *component_driver,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
int num_dai)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
|
2018-03-19 14:27:17 +07:00
|
|
|
component = devm_kzalloc(dev, sizeof(*component), GFP_KERNEL);
|
2017-10-02 12:10:33 +07:00
|
|
|
if (!component)
|
2017-10-02 12:10:17 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return snd_soc_add_component(dev, component, component_driver,
|
|
|
|
dai_drv, num_dai);
|
|
|
|
}
|
2014-06-16 23:13:03 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_component);
|
2014-04-28 19:30:51 +07:00
|
|
|
|
2013-09-05 09:39:03 +07:00
|
|
|
/**
|
2017-08-07 09:06:55 +07:00
|
|
|
* snd_soc_unregister_component - Unregister all related component
|
|
|
|
* from the ASoC core
|
2013-09-05 09:39:03 +07:00
|
|
|
*
|
2015-08-25 14:14:48 +07:00
|
|
|
* @dev: The device to unregister
|
2013-09-05 09:39:03 +07:00
|
|
|
*/
|
2017-08-07 09:06:55 +07:00
|
|
|
static int __snd_soc_unregister_component(struct device *dev)
|
2013-09-05 09:39:03 +07:00
|
|
|
{
|
2017-08-07 09:06:23 +07:00
|
|
|
struct snd_soc_component *component;
|
2017-08-07 09:06:40 +07:00
|
|
|
int found = 0;
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_lock(&client_mutex);
|
2017-08-07 09:06:23 +07:00
|
|
|
list_for_each_entry(component, &component_list, list) {
|
2018-05-08 10:20:24 +07:00
|
|
|
if (dev != component->dev)
|
2017-08-07 09:06:40 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
|
|
|
|
snd_soc_component_del_unlocked(component);
|
|
|
|
found = 1;
|
|
|
|
break;
|
2013-09-05 09:39:03 +07:00
|
|
|
}
|
2015-03-08 01:34:03 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
2013-09-05 09:39:03 +07:00
|
|
|
|
2017-08-07 09:06:40 +07:00
|
|
|
if (found) {
|
|
|
|
snd_soc_component_cleanup(component);
|
|
|
|
}
|
2017-08-07 09:06:55 +07:00
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
void snd_soc_unregister_component(struct device *dev)
|
|
|
|
{
|
|
|
|
while (__snd_soc_unregister_component(dev));
|
2013-09-05 09:39:03 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
|
|
|
|
|
2017-10-02 12:09:52 +07:00
|
|
|
struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
|
|
|
|
const char *driver_name)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
struct snd_soc_component *ret;
|
|
|
|
|
|
|
|
ret = NULL;
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_for_each_entry(component, &component_list, list) {
|
|
|
|
if (dev != component->dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (driver_name &&
|
|
|
|
(driver_name != component->driver->name) &&
|
|
|
|
(strcmp(component->driver->name, driver_name) != 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = component;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_lookup_component);
|
|
|
|
|
2011-12-13 05:55:34 +07:00
|
|
|
/* Retrieve a card's name from device tree */
|
2017-01-27 13:37:51 +07:00
|
|
|
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
|
|
|
|
const char *propname)
|
2011-12-13 05:55:34 +07:00
|
|
|
{
|
2017-01-27 13:37:51 +07:00
|
|
|
struct device_node *np;
|
2011-12-13 05:55:34 +07:00
|
|
|
int ret;
|
|
|
|
|
2014-07-04 15:53:00 +07:00
|
|
|
if (!card->dev) {
|
|
|
|
pr_err("card->dev is not set before calling %s\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-01-27 13:37:51 +07:00
|
|
|
np = card->dev->of_node;
|
2014-07-04 15:53:00 +07:00
|
|
|
|
2011-12-13 05:55:34 +07:00
|
|
|
ret = of_property_read_string_index(np, propname, 0, &card->name);
|
|
|
|
/*
|
|
|
|
* EINVAL means the property does not exist. This is fine providing
|
|
|
|
* card->name was previously set, which is checked later in
|
|
|
|
* snd_soc_register_card.
|
|
|
|
*/
|
|
|
|
if (ret < 0 && ret != -EINVAL) {
|
|
|
|
dev_err(card->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: Property '%s' could not be read: %d\n",
|
2011-12-13 05:55:34 +07:00
|
|
|
propname, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 13:37:51 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
|
2011-12-13 05:55:34 +07:00
|
|
|
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 14:59:52 +07:00
|
|
|
static const struct snd_soc_dapm_widget simple_widgets[] = {
|
|
|
|
SND_SOC_DAPM_MIC("Microphone", NULL),
|
|
|
|
SND_SOC_DAPM_LINE("Line", NULL),
|
|
|
|
SND_SOC_DAPM_HP("Headphone", NULL),
|
|
|
|
SND_SOC_DAPM_SPK("Speaker", NULL),
|
|
|
|
};
|
|
|
|
|
2017-01-27 13:37:34 +07:00
|
|
|
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 14:59:52 +07:00
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 13:37:34 +07:00
|
|
|
struct device_node *np = card->dev->of_node;
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 14:59:52 +07:00
|
|
|
struct snd_soc_dapm_widget *widgets;
|
|
|
|
const char *template, *wname;
|
|
|
|
int i, j, num_widgets, ret;
|
|
|
|
|
|
|
|
num_widgets = of_property_count_strings(np, propname);
|
|
|
|
if (num_widgets < 0) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' does not exist\n", propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (num_widgets & 1) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' length is not even\n", propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_widgets /= 2;
|
|
|
|
if (!num_widgets) {
|
|
|
|
dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
|
|
|
|
propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!widgets) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Could not allocate memory for widgets\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_widgets; i++) {
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
|
|
|
2 * i, &template);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' index %d read error:%d\n",
|
|
|
|
propname, 2 * i, ret);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
|
|
|
|
if (!strncmp(template, simple_widgets[j].name,
|
|
|
|
strlen(simple_widgets[j].name))) {
|
|
|
|
widgets[i] = simple_widgets[j];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (j >= ARRAY_SIZE(simple_widgets)) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: DAPM widget '%s' is not supported\n",
|
|
|
|
template);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
|
|
|
(2 * i) + 1,
|
|
|
|
&wname);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' index %d read error:%d\n",
|
|
|
|
propname, (2 * i) + 1, ret);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
widgets[i].name = wname;
|
|
|
|
}
|
|
|
|
|
2015-02-15 08:22:49 +07:00
|
|
|
card->of_dapm_widgets = widgets;
|
|
|
|
card->num_of_dapm_widgets = num_widgets;
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 14:59:52 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 13:37:34 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 14:59:52 +07:00
|
|
|
|
2018-07-17 22:43:02 +07:00
|
|
|
int snd_soc_of_get_slot_mask(struct device_node *np,
|
|
|
|
const char *prop_name,
|
|
|
|
unsigned int *mask)
|
2015-09-10 01:27:43 +07:00
|
|
|
{
|
|
|
|
u32 val;
|
2015-09-17 17:13:38 +07:00
|
|
|
const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
|
2015-09-10 01:27:43 +07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!of_slot_mask)
|
|
|
|
return 0;
|
|
|
|
val /= sizeof(u32);
|
|
|
|
for (i = 0; i < val; i++)
|
|
|
|
if (be32_to_cpup(&of_slot_mask[i]))
|
|
|
|
*mask |= (1 << i);
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
2018-07-17 22:43:02 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask);
|
2015-09-10 01:27:43 +07:00
|
|
|
|
2014-02-14 08:34:35 +07:00
|
|
|
int snd_soc_of_parse_tdm_slot(struct device_node *np,
|
2015-09-10 01:27:43 +07:00
|
|
|
unsigned int *tx_mask,
|
|
|
|
unsigned int *rx_mask,
|
2014-02-14 08:34:35 +07:00
|
|
|
unsigned int *slots,
|
|
|
|
unsigned int *slot_width)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int ret;
|
|
|
|
|
2015-09-10 01:27:43 +07:00
|
|
|
if (tx_mask)
|
|
|
|
snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
|
|
|
|
if (rx_mask)
|
|
|
|
snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
|
|
|
|
|
2014-02-14 08:34:35 +07:00
|
|
|
if (of_property_read_bool(np, "dai-tdm-slot-num")) {
|
|
|
|
ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (slots)
|
|
|
|
*slots = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (of_property_read_bool(np, "dai-tdm-slot-width")) {
|
|
|
|
ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (slot_width)
|
|
|
|
*slot_width = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
|
|
|
|
|
2017-01-27 13:37:16 +07:00
|
|
|
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
|
2015-07-15 14:07:42 +07:00
|
|
|
struct snd_soc_codec_conf *codec_conf,
|
|
|
|
struct device_node *of_node,
|
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 13:37:16 +07:00
|
|
|
struct device_node *np = card->dev->of_node;
|
2015-07-15 14:07:42 +07:00
|
|
|
const char *str;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_property_read_string(np, propname, &str);
|
|
|
|
if (ret < 0) {
|
|
|
|
/* no prefix is not error */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec_conf->of_node = of_node;
|
|
|
|
codec_conf->name_prefix = str;
|
|
|
|
}
|
2017-01-27 13:37:16 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
|
2015-07-15 14:07:42 +07:00
|
|
|
|
2017-01-27 13:36:50 +07:00
|
|
|
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
|
2011-12-13 05:55:35 +07:00
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 13:36:50 +07:00
|
|
|
struct device_node *np = card->dev->of_node;
|
2014-12-18 18:46:38 +07:00
|
|
|
int num_routes;
|
2011-12-13 05:55:35 +07:00
|
|
|
struct snd_soc_dapm_route *routes;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
num_routes = of_property_count_strings(np, propname);
|
2012-04-24 14:24:43 +07:00
|
|
|
if (num_routes < 0 || num_routes & 1) {
|
2013-05-05 03:21:38 +07:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' does not exist or its length is not even\n",
|
|
|
|
propname);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
num_routes /= 2;
|
|
|
|
if (!num_routes) {
|
2012-11-19 21:47:09 +07:00
|
|
|
dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
|
2011-12-13 05:55:35 +07:00
|
|
|
propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
treewide: devm_kzalloc() -> devm_kcalloc()
The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
This patch replaces cases of:
devm_kzalloc(handle, a * b, gfp)
with:
devm_kcalloc(handle, a * b, gfp)
as well as handling cases of:
devm_kzalloc(handle, a * b * c, gfp)
with:
devm_kzalloc(handle, array3_size(a, b, c), gfp)
as it's slightly less ugly than:
devm_kcalloc(handle, array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
devm_kzalloc(handle, 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.
Some manual whitespace fixes were needed in this patch, as Coccinelle
really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
expression HANDLE;
type TYPE;
expression THING, E;
@@
(
devm_kzalloc(HANDLE,
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
devm_kzalloc(HANDLE,
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression HANDLE;
expression COUNT;
typedef u8;
typedef __u8;
@@
(
devm_kzalloc(HANDLE,
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
expression HANDLE;
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
expression HANDLE;
identifier SIZE, COUNT;
@@
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression HANDLE;
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression HANDLE;
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
expression HANDLE;
identifier STRIDE, SIZE, COUNT;
@@
(
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- 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 HANDLE;
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE,
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- 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 HANDLE;
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
|
devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
|
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE, C1 * C2, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * E2
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * (E2)
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 04:07:58 +07:00
|
|
|
routes = devm_kcalloc(card->dev, num_routes, sizeof(*routes),
|
2011-12-13 05:55:35 +07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!routes) {
|
|
|
|
dev_err(card->dev,
|
2012-11-19 21:47:09 +07:00
|
|
|
"ASoC: Could not allocate DAPM route table\n");
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_routes; i++) {
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
2014-12-18 18:46:38 +07:00
|
|
|
2 * i, &routes[i].sink);
|
2011-12-13 05:55:35 +07:00
|
|
|
if (ret) {
|
2012-12-10 14:19:52 +07:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, 2 * i, ret);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
2014-12-18 18:46:38 +07:00
|
|
|
(2 * i) + 1, &routes[i].source);
|
2011-12-13 05:55:35 +07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
2012-12-10 14:19:52 +07:00
|
|
|
"ASoC: Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, (2 * i) + 1, ret);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-15 08:22:49 +07:00
|
|
|
card->num_of_dapm_routes = num_routes;
|
|
|
|
card->of_dapm_routes = routes;
|
2011-12-13 05:55:35 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 13:36:50 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
|
2011-12-13 05:55:35 +07:00
|
|
|
|
2013-01-15 09:36:04 +07:00
|
|
|
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
|
2014-03-24 17:15:24 +07:00
|
|
|
const char *prefix,
|
|
|
|
struct device_node **bitclkmaster,
|
|
|
|
struct device_node **framemaster)
|
2013-01-15 09:36:04 +07:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
char prop[128];
|
|
|
|
unsigned int format = 0;
|
|
|
|
int bit, frame;
|
|
|
|
const char *str;
|
|
|
|
struct {
|
|
|
|
char *name;
|
|
|
|
unsigned int val;
|
|
|
|
} of_fmt_table[] = {
|
|
|
|
{ "i2s", SND_SOC_DAIFMT_I2S },
|
|
|
|
{ "right_j", SND_SOC_DAIFMT_RIGHT_J },
|
|
|
|
{ "left_j", SND_SOC_DAIFMT_LEFT_J },
|
|
|
|
{ "dsp_a", SND_SOC_DAIFMT_DSP_A },
|
|
|
|
{ "dsp_b", SND_SOC_DAIFMT_DSP_B },
|
|
|
|
{ "ac97", SND_SOC_DAIFMT_AC97 },
|
|
|
|
{ "pdm", SND_SOC_DAIFMT_PDM},
|
|
|
|
{ "msb", SND_SOC_DAIFMT_MSB },
|
|
|
|
{ "lsb", SND_SOC_DAIFMT_LSB },
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!prefix)
|
|
|
|
prefix = "";
|
|
|
|
|
|
|
|
/*
|
2017-04-20 08:33:24 +07:00
|
|
|
* check "dai-format = xxx"
|
|
|
|
* or "[prefix]format = xxx"
|
2013-01-15 09:36:04 +07:00
|
|
|
* SND_SOC_DAIFMT_FORMAT_MASK area
|
|
|
|
*/
|
2017-04-20 08:33:24 +07:00
|
|
|
ret = of_property_read_string(np, "dai-format", &str);
|
|
|
|
if (ret < 0) {
|
|
|
|
snprintf(prop, sizeof(prop), "%sformat", prefix);
|
|
|
|
ret = of_property_read_string(np, prop, &str);
|
|
|
|
}
|
2013-01-15 09:36:04 +07:00
|
|
|
if (ret == 0) {
|
|
|
|
for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
|
|
|
|
if (strcmp(str, of_fmt_table[i].name) == 0) {
|
|
|
|
format |= of_fmt_table[i].val;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2013-01-30 12:03:36 +07:00
|
|
|
* check "[prefix]continuous-clock"
|
2013-01-15 09:36:04 +07:00
|
|
|
* SND_SOC_DAIFMT_CLOCK_MASK area
|
|
|
|
*/
|
2013-01-30 12:03:36 +07:00
|
|
|
snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
|
2016-08-05 15:56:51 +07:00
|
|
|
if (of_property_read_bool(np, prop))
|
2013-01-30 12:03:36 +07:00
|
|
|
format |= SND_SOC_DAIFMT_CONT;
|
|
|
|
else
|
|
|
|
format |= SND_SOC_DAIFMT_GATED;
|
2013-01-15 09:36:04 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* check "[prefix]bitclock-inversion"
|
|
|
|
* check "[prefix]frame-inversion"
|
|
|
|
* SND_SOC_DAIFMT_INV_MASK area
|
|
|
|
*/
|
|
|
|
snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
|
|
|
|
bit = !!of_get_property(np, prop, NULL);
|
|
|
|
|
|
|
|
snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
|
|
|
|
frame = !!of_get_property(np, prop, NULL);
|
|
|
|
|
|
|
|
switch ((bit << 4) + frame) {
|
|
|
|
case 0x11:
|
|
|
|
format |= SND_SOC_DAIFMT_IB_IF;
|
|
|
|
break;
|
|
|
|
case 0x10:
|
|
|
|
format |= SND_SOC_DAIFMT_IB_NF;
|
|
|
|
break;
|
|
|
|
case 0x01:
|
|
|
|
format |= SND_SOC_DAIFMT_NB_IF;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* SND_SOC_DAIFMT_NB_NF is default */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check "[prefix]bitclock-master"
|
|
|
|
* check "[prefix]frame-master"
|
|
|
|
* SND_SOC_DAIFMT_MASTER_MASK area
|
|
|
|
*/
|
|
|
|
snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
|
|
|
|
bit = !!of_get_property(np, prop, NULL);
|
2014-03-24 17:15:24 +07:00
|
|
|
if (bit && bitclkmaster)
|
|
|
|
*bitclkmaster = of_parse_phandle(np, prop, 0);
|
2013-01-15 09:36:04 +07:00
|
|
|
|
|
|
|
snprintf(prop, sizeof(prop), "%sframe-master", prefix);
|
|
|
|
frame = !!of_get_property(np, prop, NULL);
|
2014-03-24 17:15:24 +07:00
|
|
|
if (frame && framemaster)
|
|
|
|
*framemaster = of_parse_phandle(np, prop, 0);
|
2013-01-15 09:36:04 +07:00
|
|
|
|
|
|
|
switch ((bit << 4) + frame) {
|
|
|
|
case 0x11:
|
|
|
|
format |= SND_SOC_DAIFMT_CBM_CFM;
|
|
|
|
break;
|
|
|
|
case 0x10:
|
|
|
|
format |= SND_SOC_DAIFMT_CBM_CFS;
|
|
|
|
break;
|
|
|
|
case 0x01:
|
|
|
|
format |= SND_SOC_DAIFMT_CBS_CFM;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
format |= SND_SOC_DAIFMT_CBS_CFS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return format;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
|
|
|
|
|
2017-05-18 08:39:25 +07:00
|
|
|
int snd_soc_get_dai_id(struct device_node *ep)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *pos;
|
|
|
|
struct device_node *node;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
node = of_graph_get_port_parent(ep);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For example HDMI case, HDMI has video/sound port,
|
|
|
|
* but ALSA SoC needs sound port number only.
|
|
|
|
* Thus counting HDMI DT port/endpoint doesn't work.
|
|
|
|
* Then, it should have .of_xlate_dai_id
|
|
|
|
*/
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_for_each_entry(pos, &component_list, list) {
|
|
|
|
struct device_node *component_of_node = pos->dev->of_node;
|
|
|
|
|
|
|
|
if (!component_of_node && pos->dev->parent)
|
|
|
|
component_of_node = pos->dev->parent->of_node;
|
|
|
|
|
|
|
|
if (component_of_node != node)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (pos->driver->of_xlate_dai_id)
|
|
|
|
ret = pos->driver->of_xlate_dai_id(pos, ep);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2017-07-28 15:23:15 +07:00
|
|
|
of_node_put(node);
|
|
|
|
|
2017-05-18 08:39:25 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);
|
|
|
|
|
2016-11-11 08:19:28 +07:00
|
|
|
int snd_soc_get_dai_name(struct of_phandle_args *args,
|
2014-11-25 19:16:12 +07:00
|
|
|
const char **dai_name)
|
2013-09-11 07:39:56 +07:00
|
|
|
{
|
|
|
|
struct snd_soc_component *pos;
|
2015-05-27 01:59:05 +07:00
|
|
|
struct device_node *component_of_node;
|
2014-11-25 19:16:12 +07:00
|
|
|
int ret = -EPROBE_DEFER;
|
2013-09-11 07:39:56 +07:00
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_for_each_entry(pos, &component_list, list) {
|
2015-05-27 01:59:05 +07:00
|
|
|
component_of_node = pos->dev->of_node;
|
|
|
|
if (!component_of_node && pos->dev->parent)
|
|
|
|
component_of_node = pos->dev->parent->of_node;
|
|
|
|
|
|
|
|
if (component_of_node != args->np)
|
2013-09-11 07:39:56 +07:00
|
|
|
continue;
|
|
|
|
|
2013-10-17 12:05:26 +07:00
|
|
|
if (pos->driver->of_xlate_dai_name) {
|
2014-11-25 19:16:12 +07:00
|
|
|
ret = pos->driver->of_xlate_dai_name(pos,
|
|
|
|
args,
|
|
|
|
dai_name);
|
2013-10-17 12:05:26 +07:00
|
|
|
} else {
|
2017-12-20 08:48:29 +07:00
|
|
|
struct snd_soc_dai *dai;
|
2013-10-17 12:05:26 +07:00
|
|
|
int id = -1;
|
|
|
|
|
2014-11-25 19:16:12 +07:00
|
|
|
switch (args->args_count) {
|
2013-10-17 12:05:26 +07:00
|
|
|
case 0:
|
|
|
|
id = 0; /* same as dai_drv[0] */
|
|
|
|
break;
|
|
|
|
case 1:
|
2014-11-25 19:16:12 +07:00
|
|
|
id = args->args[0];
|
2013-10-17 12:05:26 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* not supported */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id < 0 || id >= pos->num_dai) {
|
|
|
|
ret = -EINVAL;
|
2014-04-21 18:14:46 +07:00
|
|
|
continue;
|
2013-10-17 12:05:26 +07:00
|
|
|
}
|
2013-12-20 13:39:51 +07:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2017-12-20 08:48:29 +07:00
|
|
|
/* find target DAI */
|
|
|
|
list_for_each_entry(dai, &pos->dai_list, list) {
|
|
|
|
if (id == 0)
|
|
|
|
break;
|
|
|
|
id--;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dai_name = dai->driver->name;
|
2013-12-20 13:39:51 +07:00
|
|
|
if (!*dai_name)
|
|
|
|
*dai_name = pos->name;
|
2013-09-11 07:39:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&client_mutex);
|
2014-11-25 19:16:12 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2016-11-11 08:19:28 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
|
2014-11-25 19:16:12 +07:00
|
|
|
|
|
|
|
int snd_soc_of_get_dai_name(struct device_node *of_node,
|
|
|
|
const char **dai_name)
|
|
|
|
{
|
|
|
|
struct of_phandle_args args;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = of_parse_phandle_with_args(of_node, "sound-dai",
|
|
|
|
"#sound-dai-cells", 0, &args);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = snd_soc_get_dai_name(&args, dai_name);
|
2013-09-11 07:39:56 +07:00
|
|
|
|
|
|
|
of_node_put(args.np);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
|
|
|
|
|
2018-03-10 00:48:54 +07:00
|
|
|
/*
|
|
|
|
* snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array
|
|
|
|
* @dai_link: DAI link
|
|
|
|
*
|
|
|
|
* Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs().
|
|
|
|
*/
|
|
|
|
void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai_link_component *component = dai_link->codecs;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
for (index = 0; index < dai_link->num_codecs; index++, component++) {
|
|
|
|
if (!component->of_node)
|
|
|
|
break;
|
|
|
|
of_node_put(component->of_node);
|
|
|
|
component->of_node = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs);
|
|
|
|
|
2014-11-25 19:16:12 +07:00
|
|
|
/*
|
|
|
|
* snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
|
|
|
|
* @dev: Card device
|
|
|
|
* @of_node: Device node
|
|
|
|
* @dai_link: DAI link
|
|
|
|
*
|
|
|
|
* Builds an array of CODEC DAI components from the DAI link property
|
|
|
|
* 'sound-dai'.
|
|
|
|
* The array is set in the DAI link and the number of DAIs is set accordingly.
|
2018-03-10 00:48:54 +07:00
|
|
|
* The device nodes in the array (of_node) must be dereferenced by calling
|
|
|
|
* snd_soc_of_put_dai_link_codecs() on @dai_link.
|
2014-11-25 19:16:12 +07:00
|
|
|
*
|
|
|
|
* Returns 0 for success
|
|
|
|
*/
|
|
|
|
int snd_soc_of_get_dai_link_codecs(struct device *dev,
|
|
|
|
struct device_node *of_node,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
|
|
|
{
|
|
|
|
struct of_phandle_args args;
|
|
|
|
struct snd_soc_dai_link_component *component;
|
|
|
|
char *name;
|
|
|
|
int index, num_codecs, ret;
|
|
|
|
|
|
|
|
/* Count the number of CODECs */
|
|
|
|
name = "sound-dai";
|
|
|
|
num_codecs = of_count_phandle_with_args(of_node, name,
|
|
|
|
"#sound-dai-cells");
|
|
|
|
if (num_codecs <= 0) {
|
|
|
|
if (num_codecs == -ENOENT)
|
|
|
|
dev_err(dev, "No 'sound-dai' property\n");
|
|
|
|
else
|
|
|
|
dev_err(dev, "Bad phandle in 'sound-dai'\n");
|
|
|
|
return num_codecs;
|
|
|
|
}
|
treewide: devm_kzalloc() -> devm_kcalloc()
The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
This patch replaces cases of:
devm_kzalloc(handle, a * b, gfp)
with:
devm_kcalloc(handle, a * b, gfp)
as well as handling cases of:
devm_kzalloc(handle, a * b * c, gfp)
with:
devm_kzalloc(handle, array3_size(a, b, c), gfp)
as it's slightly less ugly than:
devm_kcalloc(handle, array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
devm_kzalloc(handle, 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.
Some manual whitespace fixes were needed in this patch, as Coccinelle
really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
expression HANDLE;
type TYPE;
expression THING, E;
@@
(
devm_kzalloc(HANDLE,
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
devm_kzalloc(HANDLE,
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression HANDLE;
expression COUNT;
typedef u8;
typedef __u8;
@@
(
devm_kzalloc(HANDLE,
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
expression HANDLE;
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
expression HANDLE;
identifier SIZE, COUNT;
@@
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression HANDLE;
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression HANDLE;
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
expression HANDLE;
identifier STRIDE, SIZE, COUNT;
@@
(
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- 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 HANDLE;
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE,
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- 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 HANDLE;
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
|
devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
|
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE, C1 * C2, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * E2
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * (E2)
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 04:07:58 +07:00
|
|
|
component = devm_kcalloc(dev,
|
|
|
|
num_codecs, sizeof(*component),
|
2014-11-25 19:16:12 +07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!component)
|
|
|
|
return -ENOMEM;
|
|
|
|
dai_link->codecs = component;
|
|
|
|
dai_link->num_codecs = num_codecs;
|
|
|
|
|
|
|
|
/* Parse the list */
|
|
|
|
for (index = 0, component = dai_link->codecs;
|
|
|
|
index < dai_link->num_codecs;
|
|
|
|
index++, component++) {
|
|
|
|
ret = of_parse_phandle_with_args(of_node, name,
|
|
|
|
"#sound-dai-cells",
|
|
|
|
index, &args);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
component->of_node = args.np;
|
|
|
|
ret = snd_soc_get_dai_name(&args, &component->dai_name);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
err:
|
2018-03-10 00:48:54 +07:00
|
|
|
snd_soc_of_put_dai_link_codecs(dai_link);
|
2014-11-25 19:16:12 +07:00
|
|
|
dai_link->codecs = NULL;
|
|
|
|
dai_link->num_codecs = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
|
|
|
|
|
2008-12-10 13:47:22 +07:00
|
|
|
static int __init snd_soc_init(void)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2015-04-09 15:52:38 +07:00
|
|
|
snd_soc_debugfs_init();
|
2011-04-28 16:57:54 +07:00
|
|
|
snd_soc_util_init();
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return platform_driver_register(&soc_driver);
|
|
|
|
}
|
2010-10-12 23:41:03 +07:00
|
|
|
module_init(snd_soc_init);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-12-01 05:11:24 +07:00
|
|
|
static void __exit snd_soc_exit(void)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2011-04-28 16:57:54 +07:00
|
|
|
snd_soc_util_exit();
|
2015-04-09 15:52:38 +07:00
|
|
|
snd_soc_debugfs_exit();
|
2011-04-28 16:57:54 +07:00
|
|
|
|
2008-05-19 17:32:25 +07:00
|
|
|
platform_driver_unregister(&soc_driver);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
module_exit(snd_soc_exit);
|
|
|
|
|
|
|
|
/* Module information */
|
2008-10-12 19:17:36 +07:00
|
|
|
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
|
2006-10-06 23:31:09 +07:00
|
|
|
MODULE_DESCRIPTION("ALSA SoC Core");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-04-14 18:33:36 +07:00
|
|
|
MODULE_ALIAS("platform:soc-audio");
|