2006-10-06 16:31:09 +00:00
|
|
|
/*
|
|
|
|
* soc-core.c -- ALSA SoC Audio Layer
|
|
|
|
*
|
|
|
|
* Copyright 2005 Wolfson Microelectronics PLC.
|
2006-12-18 13:39:02 +00:00
|
|
|
* Copyright 2005 Openedhand Ltd.
|
2010-03-17 20:15:21 +00:00
|
|
|
* Copyright (C) 2010 Slimlogic Ltd.
|
|
|
|
* Copyright (C) 2010 Texas Instruments Inc.
|
2006-12-18 13:39:02 +00:00
|
|
|
*
|
2008-10-12 12:17:36 +00:00
|
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
2006-12-18 13:39:02 +00:00
|
|
|
* with code, comments and ideas from :-
|
|
|
|
* Richard Purdie <richard@openedhand.com>
|
2006-10-06 16:31:09 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
* option) any later version.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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 00:42:14 +00:00
|
|
|
#include <linux/debugfs.h>
|
2006-10-06 16:31:09 +00:00
|
|
|
#include <linux/platform_device.h>
|
2013-08-19 15:05:55 +00:00
|
|
|
#include <linux/pinctrl/consumer.h>
|
2011-09-20 10:41:54 +00: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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-12-12 22:55:34 +00:00
|
|
|
#include <linux/of.h>
|
2017-05-18 01:39:25 +00:00
|
|
|
#include <linux/of_graph.h>
|
2017-01-14 08:13:02 +00:00
|
|
|
#include <linux/dmi.h>
|
2006-10-06 16:31:09 +00:00
|
|
|
#include <sound/core.h>
|
2010-12-05 12:22:46 +00:00
|
|
|
#include <sound/jack.h>
|
2006-10-06 16:31:09 +00: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 11:12:49 +00:00
|
|
|
#include <sound/soc-dpcm.h>
|
2015-05-29 18:06:14 +00:00
|
|
|
#include <sound/soc-topology.h>
|
2006-10-06 16:31:09 +00:00
|
|
|
#include <sound/initval.h>
|
|
|
|
|
2010-11-03 22:05:58 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/asoc.h>
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
#define NAME_SIZE 32
|
|
|
|
|
2008-12-03 17:34:03 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-10 22:25:21 +00:00
|
|
|
struct dentry *snd_soc_debugfs_root;
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
|
2008-12-03 17:34:03 +00:00
|
|
|
#endif
|
|
|
|
|
2008-11-28 13:29:45 +00:00
|
|
|
static DEFINE_MUTEX(client_mutex);
|
2008-12-03 19:40:30 +00:00
|
|
|
static LIST_HEAD(platform_list);
|
2008-12-10 14:32:45 +00:00
|
|
|
static LIST_HEAD(codec_list);
|
2013-03-12 01:27:21 +00:00
|
|
|
static LIST_HEAD(component_list);
|
2008-11-28 13:29:45 +00:00
|
|
|
|
2006-10-06 16:31:09 +00: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 07:01:39 +00: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 */
|
|
|
|
};
|
|
|
|
|
2011-02-01 12:24:08 +00:00
|
|
|
/* returns the minimum number of bytes needed to represent
|
|
|
|
* a particular given value */
|
|
|
|
static int min_bytes_needed(unsigned long val)
|
|
|
|
{
|
|
|
|
int c = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
|
|
|
|
if (val & (1UL << i))
|
|
|
|
break;
|
|
|
|
c = (sizeof val * 8) - c;
|
|
|
|
if (!c || (c % 8))
|
|
|
|
c = (c + 8) / 8;
|
|
|
|
else
|
|
|
|
c /= 8;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2011-02-02 13:58:58 +00:00
|
|
|
/* fill buf which is 'len' bytes with a formatted
|
|
|
|
* string of the form 'reg: value\n' */
|
|
|
|
static int format_register_str(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg, char *buf, size_t len)
|
|
|
|
{
|
2011-04-01 20:50:44 +00:00
|
|
|
int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
|
|
|
|
int regsize = codec->driver->reg_word_size * 2;
|
2011-02-02 13:58:58 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* +2 for ': ' and + 1 for '\n' */
|
|
|
|
if (wordsize + regsize + 2 + 1 != len)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-05-26 12:40:14 +00:00
|
|
|
sprintf(buf, "%.*x: ", wordsize, reg);
|
|
|
|
buf += wordsize + 2;
|
2011-02-02 13:58:58 +00:00
|
|
|
|
2015-05-26 12:40:14 +00:00
|
|
|
ret = snd_soc_read(codec, reg);
|
|
|
|
if (ret < 0)
|
|
|
|
memset(buf, 'X', regsize);
|
|
|
|
else
|
|
|
|
sprintf(buf, "%.*x", regsize, ret);
|
|
|
|
buf[regsize] = '\n';
|
|
|
|
/* no NUL-termination needed */
|
2011-02-02 13:58:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
/* codec register dump */
|
2011-02-02 13:58:58 +00:00
|
|
|
static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
|
|
|
|
size_t count, loff_t pos)
|
2009-11-03 21:56:13 +00:00
|
|
|
{
|
2011-02-02 13:58:58 +00:00
|
|
|
int i, step = 1;
|
2011-02-01 12:24:08 +00:00
|
|
|
int wordsize, regsize;
|
2011-02-02 13:58:58 +00:00
|
|
|
int len;
|
|
|
|
size_t total = 0;
|
|
|
|
loff_t p = 0;
|
2011-02-01 12:24:08 +00:00
|
|
|
|
2011-04-01 20:50:44 +00:00
|
|
|
wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
|
|
|
|
regsize = codec->driver->reg_word_size * 2;
|
2009-11-03 21:56:13 +00:00
|
|
|
|
2011-02-02 13:58:58 +00:00
|
|
|
len = wordsize + regsize + 2 + 1;
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
if (!codec->driver->reg_cache_size)
|
2009-11-03 21:56:13 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
if (codec->driver->reg_cache_step)
|
|
|
|
step = codec->driver->reg_cache_step;
|
2009-11-03 21:56:13 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
for (i = 0; i < codec->driver->reg_cache_size; i += step) {
|
2014-03-18 08:02:09 +00:00
|
|
|
/* only support larger than PAGE_SIZE bytes debugfs
|
|
|
|
* entries for the default case */
|
|
|
|
if (p >= pos) {
|
|
|
|
if (total + len >= count - 1)
|
|
|
|
break;
|
|
|
|
format_register_str(codec, i, buf + total, len);
|
|
|
|
total += len;
|
2010-07-14 15:14:33 +00:00
|
|
|
}
|
2014-03-18 08:02:09 +00:00
|
|
|
p += len;
|
2009-11-03 21:56:13 +00:00
|
|
|
}
|
|
|
|
|
2011-02-02 13:58:58 +00:00
|
|
|
total = min(total, count - 1);
|
2009-11-03 21:56:13 +00:00
|
|
|
|
2011-02-02 13:58:58 +00:00
|
|
|
return total;
|
2009-11-03 21:56:13 +00:00
|
|
|
}
|
2011-02-02 13:58:58 +00:00
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
static ssize_t codec_reg_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-01-07 01:12:45 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2011-02-02 13:58:58 +00:00
|
|
|
return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
|
2009-11-03 21:56:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
|
|
|
|
|
2010-02-12 11:37:24 +00:00
|
|
|
static ssize_t pmdown_time_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-01-07 01:12:45 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-02-12 11:37:24 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
return sprintf(buf, "%ld\n", rtd->pmdown_time);
|
2010-02-12 11:37:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t pmdown_time_set(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2012-01-07 01:12:45 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-10-28 03:11:17 +00:00
|
|
|
int ret;
|
2010-02-12 11:37:24 +00:00
|
|
|
|
2013-07-19 07:24:59 +00:00
|
|
|
ret = kstrtol(buf, 10, &rtd->pmdown_time);
|
2010-10-28 03:11:17 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-02-12 11:37:24 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
|
|
|
|
|
2015-01-30 19:16:37 +00:00
|
|
|
static struct attribute *soc_dev_attrs[] = {
|
|
|
|
&dev_attr_codec_reg.attr,
|
|
|
|
&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 */
|
|
|
|
return rtd->codec ? attr->mode : 0; /* enabled only with codec */
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct attribute_group soc_dapm_dev_group = {
|
|
|
|
.attrs = soc_dapm_dev_attrs,
|
|
|
|
.is_visible = soc_dev_attr_is_visible,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group soc_dev_roup = {
|
|
|
|
.attrs = soc_dev_attrs,
|
|
|
|
.is_visible = soc_dev_attr_is_visible,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *soc_dev_attr_groups[] = {
|
|
|
|
&soc_dapm_dev_group,
|
|
|
|
&soc_dev_roup,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
|
2011-02-02 13:58:58 +00:00
|
|
|
size_t count, loff_t *ppos)
|
2009-11-03 21:56:13 +00:00
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
struct snd_soc_codec *codec = file->private_data;
|
2011-02-02 13:58:58 +00:00
|
|
|
char *buf;
|
|
|
|
|
|
|
|
if (*ppos < 0 || !count)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
buf = kmalloc(count, GFP_KERNEL);
|
2009-11-03 21:56:13 +00:00
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
2011-02-02 13:58:58 +00:00
|
|
|
|
|
|
|
ret = soc_codec_reg_show(codec, buf, count, *ppos);
|
|
|
|
if (ret >= 0) {
|
|
|
|
if (copy_to_user(user_buf, buf, ret)) {
|
|
|
|
kfree(buf);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
*ppos += ret;
|
|
|
|
}
|
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
kfree(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t codec_reg_write_file(struct file *file,
|
|
|
|
const char __user *user_buf, size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[32];
|
2011-05-12 23:50:10 +00:00
|
|
|
size_t buf_size;
|
2009-11-03 21:56:13 +00:00
|
|
|
char *start = buf;
|
|
|
|
unsigned long reg, value;
|
|
|
|
struct snd_soc_codec *codec = file->private_data;
|
2013-07-19 07:24:59 +00:00
|
|
|
int ret;
|
2009-11-03 21:56:13 +00:00
|
|
|
|
|
|
|
buf_size = min(count, (sizeof(buf)-1));
|
|
|
|
if (copy_from_user(buf, user_buf, buf_size))
|
|
|
|
return -EFAULT;
|
|
|
|
buf[buf_size] = 0;
|
|
|
|
|
|
|
|
while (*start == ' ')
|
|
|
|
start++;
|
|
|
|
reg = simple_strtoul(start, &start, 16);
|
|
|
|
while (*start == ' ')
|
|
|
|
start++;
|
2013-07-19 07:24:59 +00:00
|
|
|
ret = kstrtoul(start, 16, &value);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-01-06 16:04:57 +00:00
|
|
|
|
|
|
|
/* Userspace has been fiddling around behind the kernel's back */
|
2013-01-21 06:47:39 +00:00
|
|
|
add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
|
2011-01-06 16:04:57 +00:00
|
|
|
|
2010-12-07 16:30:38 +00:00
|
|
|
snd_soc_write(codec, reg, value);
|
2009-11-03 21:56:13 +00:00
|
|
|
return buf_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations codec_reg_fops = {
|
2012-04-05 21:25:11 +00:00
|
|
|
.open = simple_open,
|
2009-11-03 21:56:13 +00:00
|
|
|
.read = codec_reg_read_file,
|
|
|
|
.write = codec_reg_write_file,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = default_llseek,
|
2009-11-03 21:56:13 +00:00
|
|
|
};
|
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
static void soc_init_component_debugfs(struct snd_soc_component *component)
|
2014-06-26 14:22:50 +00:00
|
|
|
{
|
2015-04-09 08:52:38 +00:00
|
|
|
if (!component->card->debugfs_card_root)
|
|
|
|
return;
|
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
if (component->debugfs_prefix) {
|
|
|
|
char *name;
|
2014-06-26 14:22:50 +00:00
|
|
|
|
2014-08-19 13:51:18 +00: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 14:22:50 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
if (!component->debugfs_root) {
|
|
|
|
dev_warn(component->dev,
|
|
|
|
"ASoC: Failed to create component debugfs directory\n");
|
|
|
|
return;
|
|
|
|
}
|
2014-06-26 14:22:50 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
|
|
|
|
component->debugfs_root);
|
2014-06-26 14:22:50 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
if (component->init_debugfs)
|
|
|
|
component->init_debugfs(component);
|
2014-06-26 14:22:50 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
|
2009-11-03 21:56:13 +00:00
|
|
|
{
|
2014-08-19 13:51:18 +00:00
|
|
|
debugfs_remove_recursive(component->debugfs_root);
|
|
|
|
}
|
2010-11-05 18:35:20 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
static void soc_init_codec_debugfs(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
2009-11-03 21:56:13 +00:00
|
|
|
|
|
|
|
codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
|
2014-08-19 13:51:18 +00:00
|
|
|
codec->component.debugfs_root,
|
2009-11-03 21:56:13 +00:00
|
|
|
codec, &codec_reg_fops);
|
|
|
|
if (!codec->debugfs_reg)
|
2013-05-04 20:21:38 +00:00
|
|
|
dev_warn(codec->dev,
|
|
|
|
"ASoC: Failed to create codec register debugfs file\n");
|
2012-02-15 15:25:31 +00:00
|
|
|
}
|
|
|
|
|
2010-09-15 17:15:14 +00:00
|
|
|
static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
2010-10-13 09:52:16 +00:00
|
|
|
ssize_t len, ret = 0;
|
2010-09-15 17:15:14 +00:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
2010-10-13 09:52:16 +00:00
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
|
2014-06-16 16:13:02 +00:00
|
|
|
codec->component.name);
|
2010-10-13 09:52:16 +00:00
|
|
|
if (len >= 0)
|
|
|
|
ret += len;
|
|
|
|
if (ret > PAGE_SIZE) {
|
|
|
|
ret = PAGE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-09-15 17:15:14 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2010-09-15 17:15:14 +00:00
|
|
|
if (ret >= 0)
|
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations codec_list_fops = {
|
|
|
|
.read = codec_list_read_file,
|
|
|
|
.llseek = default_llseek,/* read accesses f_pos */
|
|
|
|
};
|
|
|
|
|
2010-09-15 17:19:07 +00:00
|
|
|
static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
2010-10-13 09:52:16 +00:00
|
|
|
ssize_t len, ret = 0;
|
2014-03-09 16:41:47 +00:00
|
|
|
struct snd_soc_component *component;
|
2010-09-15 17:19:07 +00:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
2014-03-09 16:41:47 +00:00
|
|
|
list_for_each_entry(component, &component_list, list) {
|
|
|
|
list_for_each_entry(dai, &component->dai_list, list) {
|
|
|
|
len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
|
|
|
|
dai->name);
|
|
|
|
if (len >= 0)
|
|
|
|
ret += len;
|
|
|
|
if (ret > PAGE_SIZE) {
|
|
|
|
ret = PAGE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
2010-10-13 09:52:16 +00:00
|
|
|
}
|
|
|
|
}
|
2010-09-15 17:19:07 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2010-10-13 09:52:16 +00:00
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
2010-09-15 17:19:07 +00:00
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations dai_list_fops = {
|
|
|
|
.read = dai_list_read_file,
|
|
|
|
.llseek = default_llseek,/* read accesses f_pos */
|
|
|
|
};
|
|
|
|
|
2010-09-15 17:22:40 +00:00
|
|
|
static ssize_t platform_list_read_file(struct file *file,
|
|
|
|
char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
2010-10-13 09:52:16 +00:00
|
|
|
ssize_t len, ret = 0;
|
2010-09-15 17:22:40 +00:00
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
|
2010-10-13 09:52:16 +00:00
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
|
|
|
len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
|
2014-06-16 16:13:02 +00:00
|
|
|
platform->component.name);
|
2010-10-13 09:52:16 +00:00
|
|
|
if (len >= 0)
|
|
|
|
ret += len;
|
|
|
|
if (ret > PAGE_SIZE) {
|
|
|
|
ret = PAGE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-09-15 17:22:40 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2010-10-13 09:52:16 +00:00
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
2010-09-15 17:22:40 +00:00
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations platform_list_fops = {
|
|
|
|
.read = platform_list_read_file,
|
|
|
|
.llseek = default_llseek,/* read accesses f_pos */
|
|
|
|
};
|
|
|
|
|
2010-11-05 18:35:19 +00:00
|
|
|
static void soc_init_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
2015-04-09 08:52:38 +00:00
|
|
|
if (!snd_soc_debugfs_root)
|
|
|
|
return;
|
|
|
|
|
2010-11-05 18:35:19 +00:00
|
|
|
card->debugfs_card_root = debugfs_create_dir(card->name,
|
2011-01-10 22:25:21 +00:00
|
|
|
snd_soc_debugfs_root);
|
2010-11-05 18:35:21 +00:00
|
|
|
if (!card->debugfs_card_root) {
|
2010-11-05 18:35:19 +00:00
|
|
|
dev_warn(card->dev,
|
2011-12-09 13:16:29 +00:00
|
|
|
"ASoC: Failed to create card debugfs directory\n");
|
2010-11-05 18:35:21 +00: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 14:47:09 +00:00
|
|
|
"ASoC: Failed to create pop time debugfs file\n");
|
2010-11-05 18:35:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(card->debugfs_card_root);
|
|
|
|
}
|
|
|
|
|
2015-04-09 08:52:38 +00:00
|
|
|
|
|
|
|
static void snd_soc_debugfs_init(void)
|
|
|
|
{
|
|
|
|
snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
|
|
|
|
if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
|
|
|
|
pr_warn("ASoC: Failed to create debugfs directory\n");
|
|
|
|
snd_soc_debugfs_root = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
|
|
|
|
&codec_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
|
|
|
if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
|
|
|
|
&platform_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create platform list debugfs file\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_soc_debugfs_exit(void)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(snd_soc_debugfs_root);
|
|
|
|
}
|
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
#else
|
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
#define soc_init_codec_debugfs NULL
|
2010-11-09 09:06:44 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
static inline void soc_init_component_debugfs(
|
|
|
|
struct snd_soc_component *component)
|
2012-02-15 15:25:31 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
static inline void soc_cleanup_component_debugfs(
|
|
|
|
struct snd_soc_component *component)
|
2012-02-15 15:25:31 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-11-09 09:06:44 +00: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 08:52:38 +00:00
|
|
|
|
|
|
|
static inline void snd_soc_debugfs_init(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void snd_soc_debugfs_exit(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-11-03 21:56:13 +00:00
|
|
|
#endif
|
|
|
|
|
2012-04-25 11:12:53 +00:00
|
|
|
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
|
|
|
|
const char *dai_link, int stream)
|
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2012-04-25 11:12:53 +00:00
|
|
|
|
2015-11-18 07:34:11 +00: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 11:12:53 +00:00
|
|
|
}
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
|
2012-04-25 11:12:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
|
|
|
|
|
2015-11-18 07:34:11 +00: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;
|
|
|
|
|
|
|
|
rtd->card = card;
|
|
|
|
rtd->dai_link = dai_link;
|
|
|
|
rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
|
|
|
|
dai_link->num_codecs,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!rtd->codec_dais) {
|
|
|
|
kfree(rtd);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rtd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
if (rtd && rtd->codec_dais)
|
|
|
|
kfree(rtd->codec_dais);
|
|
|
|
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 11:12:53 +00:00
|
|
|
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
const char *dai_link)
|
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2012-04-25 11:12:53 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (!strcmp(rtd->dai_link->name, dai_link))
|
|
|
|
return rtd;
|
2012-04-25 11:12:53 +00:00
|
|
|
}
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
|
2012-04-25 11:12:53 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
|
|
|
|
|
2013-08-05 12:17:28 +00: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 14:59:27 +00:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2006-10-06 16:31:09 +00:00
|
|
|
/* powers down audio subsystem for suspend */
|
2011-01-26 14:59:27 +00:00
|
|
|
int snd_soc_suspend(struct device *dev)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
2011-01-26 14:59:27 +00:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2016-11-30 06:22:36 +00:00
|
|
|
struct snd_soc_component *component;
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
|
|
|
int i;
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2014-08-19 13:51:30 +00:00
|
|
|
/* If the card is not initialized yet there is nothing to do */
|
|
|
|
if (!card->instantiated)
|
2009-06-03 15:44:49 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-06-13 15:24:05 +00:00
|
|
|
/* Due to the resume being scheduled into a workqueue we could
|
|
|
|
* suspend before that's finished - wait for it to complete.
|
|
|
|
*/
|
2010-03-17 20:15:21 +00:00
|
|
|
snd_power_lock(card->snd_card);
|
|
|
|
snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
|
|
|
|
snd_power_unlock(card->snd_card);
|
2008-06-13 15:24:05 +00:00
|
|
|
|
|
|
|
/* we're going to block userspace touching us until resume completes */
|
2010-03-17 20:15:21 +00:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
|
2008-06-13 15:24:05 +00:00
|
|
|
|
2010-12-02 16:24:24 +00:00
|
|
|
/* mute any active DACs */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *dai = rtd->codec_dais[i];
|
2014-07-08 21:19:34 +00: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 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2008-01-10 13:39:01 +00:00
|
|
|
/* suspend all pcms */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
snd_pcm_suspend_all(rtd->pcm);
|
2010-05-09 12:25:43 +00:00
|
|
|
}
|
2008-01-10 13:39:01 +00:00
|
|
|
|
2008-11-18 20:50:34 +00:00
|
|
|
if (card->suspend_pre)
|
2011-01-26 14:05:25 +00:00
|
|
|
card->suspend_pre(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2014-11-10 21:41:52 +00:00
|
|
|
if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
|
2010-03-17 20:15:21 +00:00
|
|
|
cpu_dai->driver->suspend(cpu_dai);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2015-03-30 19:04:50 +00:00
|
|
|
/* close any waiting streams */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-02-16 23:03:27 +00:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-02-16 23:03:27 +00:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2014-10-25 15:42:01 +00:00
|
|
|
/* Recheck all endpoints too, their state is affected by suspend */
|
|
|
|
dapm_mark_endpoints_dirty(card);
|
2012-09-01 00:38:32 +00:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
|
|
|
|
2016-11-30 06:23:13 +00:00
|
|
|
/* suspend all COMPONENTs */
|
2016-11-30 06:22:36 +00: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 06:23:13 +00:00
|
|
|
/* If there are paths active then the COMPONENT will be held with
|
2010-03-17 20:15:21 +00:00
|
|
|
* bias _ON and should not be suspended. */
|
2016-11-30 06:23:13 +00:00
|
|
|
if (!component->suspended) {
|
2015-07-06 13:38:11 +00:00
|
|
|
switch (snd_soc_dapm_get_bias_level(dapm)) {
|
2010-03-17 20:15:21 +00:00
|
|
|
case SND_SOC_BIAS_STANDBY:
|
2012-01-31 15:49:10 +00:00
|
|
|
/*
|
2016-11-30 06:23:13 +00:00
|
|
|
* If the COMPONENT is capable of idle
|
2012-01-31 15:49:10 +00:00
|
|
|
* bias off then being in STANDBY
|
|
|
|
* means it's doing something,
|
|
|
|
* otherwise fall through.
|
|
|
|
*/
|
2015-07-06 13:38:11 +00:00
|
|
|
if (dapm->idle_bias_off) {
|
2016-11-30 06:23:13 +00:00
|
|
|
dev_dbg(component->dev,
|
2013-05-04 20:21:38 +00:00
|
|
|
"ASoC: idle_bias_off CODEC on over suspend\n");
|
2012-01-31 15:49:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-09-04 17:44:07 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
case SND_SOC_BIAS_OFF:
|
2016-11-30 06:23:13 +00:00
|
|
|
if (component->suspend)
|
|
|
|
component->suspend(component);
|
|
|
|
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 06:57:31 +00:00
|
|
|
/* deactivate pins to sleep state */
|
2016-11-30 06:23:13 +00:00
|
|
|
pinctrl_pm_select_sleep_state(component->dev);
|
2010-03-17 20:15:21 +00:00
|
|
|
break;
|
|
|
|
default:
|
2016-11-30 06:23:13 +00:00
|
|
|
dev_dbg(component->dev,
|
|
|
|
"ASoC: COMPONENT is on over suspend\n");
|
2010-03-17 20:15:21 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-05-07 20:11:40 +00:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2014-11-10 21:41:52 +00:00
|
|
|
if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
|
2010-03-17 20:15:21 +00: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 06:57:31 +00:00
|
|
|
|
|
|
|
/* deactivate pins to sleep state */
|
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2008-11-18 20:50:34 +00:00
|
|
|
if (card->suspend_post)
|
2011-01-26 14:05:25 +00:00
|
|
|
card->suspend_post(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 14:59:27 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_suspend);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2008-06-13 15:24:05 +00: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 16:31:09 +00:00
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_card *card =
|
|
|
|
container_of(work, struct snd_soc_card, deferred_resume_work);
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2016-11-30 06:22:36 +00:00
|
|
|
struct snd_soc_component *component;
|
2015-11-18 07:34:11 +00:00
|
|
|
int i;
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2008-06-13 15:24:05 +00:00
|
|
|
/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
|
|
|
|
* so userspace apps are blocked from touching us
|
|
|
|
*/
|
|
|
|
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: starting resume work\n");
|
2008-06-13 15:24:05 +00:00
|
|
|
|
2010-05-07 19:24:05 +00:00
|
|
|
/* Bring us up into D2 so that DAPM starts enabling things */
|
2010-03-17 20:15:21 +00:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
|
2010-05-07 19:24:05 +00:00
|
|
|
|
2008-11-18 20:50:34 +00:00
|
|
|
if (card->resume_pre)
|
2011-01-26 14:05:25 +00:00
|
|
|
card->resume_pre(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2014-11-10 21:41:52 +00:00
|
|
|
/* resume control bus DAIs */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2014-11-10 21:41:52 +00:00
|
|
|
if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
|
2010-03-17 20:15:21 +00:00
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
|
|
|
}
|
|
|
|
|
2016-11-30 06:22:36 +00:00
|
|
|
list_for_each_entry(component, &card->component_dev_list, card_list) {
|
2016-11-30 06:23:13 +00:00
|
|
|
if (component->suspended) {
|
|
|
|
if (component->resume)
|
|
|
|
component->resume(component);
|
|
|
|
component->suspended = 0;
|
2010-05-07 20:11:40 +00:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-03-07 16:32:59 +00:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
2012-02-16 23:03:27 +00:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2012-03-07 16:32:59 +00:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
2012-02-16 23:03:27 +00:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2008-05-19 10:32:25 +00:00
|
|
|
/* unmute any active DACs */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *dai = rtd->codec_dais[i];
|
2014-07-08 21:19:34 +00: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 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2010-05-09 12:25:43 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
if (rtd->dai_link->ignore_suspend)
|
2010-05-09 12:25:43 +00:00
|
|
|
continue;
|
|
|
|
|
2014-11-10 21:41:52 +00:00
|
|
|
if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
|
2010-03-17 20:15:21 +00:00
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2008-11-18 20:50:34 +00:00
|
|
|
if (card->resume_post)
|
2011-01-26 14:05:25 +00:00
|
|
|
card->resume_post(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: resume work completed\n");
|
2008-06-13 15:24:05 +00:00
|
|
|
|
2014-10-25 15:42:01 +00:00
|
|
|
/* Recheck all endpoints too, their state is affected by suspend */
|
|
|
|
dapm_mark_endpoints_dirty(card);
|
2012-09-01 00:38:32 +00:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2015-11-23 15:52:31 +00: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 15:24:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* powers up audio subsystem after a suspend */
|
2011-01-26 14:59:27 +00:00
|
|
|
int snd_soc_resume(struct device *dev)
|
2008-06-13 15:24:05 +00:00
|
|
|
{
|
2011-01-26 14:59:27 +00:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2014-11-10 21:41:52 +00:00
|
|
|
bool bus_control = false;
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2010-02-22 11:27:13 +00:00
|
|
|
|
2014-08-19 13:51:30 +00:00
|
|
|
/* If the card is not initialized yet there is nothing to do */
|
|
|
|
if (!card->instantiated)
|
2011-11-23 14:37:00 +00: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 06:57:31 +00:00
|
|
|
/* activate pins from sleep state */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-08 21:19:34 +00: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 06:57:31 +00:00
|
|
|
if (cpu_dai->active)
|
|
|
|
pinctrl_pm_select_default_state(cpu_dai->dev);
|
2014-07-08 21:19:34 +00: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 06:57:31 +00:00
|
|
|
}
|
|
|
|
|
2014-11-10 21:41:52 +00: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 10:27:03 +00:00
|
|
|
* due to I/O costs and anti-pop so handle them out of line.
|
|
|
|
*/
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2014-11-10 21:41:52 +00:00
|
|
|
bus_control |= cpu_dai->driver->bus_control;
|
2011-05-25 20:06:41 +00:00
|
|
|
}
|
2014-11-10 21:41:52 +00:00
|
|
|
if (bus_control) {
|
|
|
|
dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
|
2011-05-25 20:06:41 +00:00
|
|
|
soc_resume_deferred(&card->deferred_resume_work);
|
|
|
|
} else {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(dev, "ASoC: Scheduling resume work\n");
|
2011-05-25 20:06:41 +00:00
|
|
|
if (!schedule_work(&card->deferred_resume_work))
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(dev, "ASoC: resume work item may be lost\n");
|
2009-03-31 10:27:03 +00:00
|
|
|
}
|
2008-06-13 15:24:05 +00:00
|
|
|
|
2006-10-06 16:31:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 14:59:27 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_resume);
|
2006-10-06 16:31:09 +00:00
|
|
|
#else
|
2011-01-26 14:59:27 +00:00
|
|
|
#define snd_soc_suspend NULL
|
|
|
|
#define snd_soc_resume NULL
|
2006-10-06 16:31:09 +00:00
|
|
|
#endif
|
|
|
|
|
2011-11-23 10:40:40 +00:00
|
|
|
static const struct snd_soc_dai_ops null_dai_ops = {
|
2009-10-16 10:13:38 +00:00
|
|
|
};
|
|
|
|
|
2014-08-19 13:51:22 +00:00
|
|
|
static struct snd_soc_component *soc_find_component(
|
|
|
|
const struct device_node *of_node, const char *name)
|
2014-03-21 15:27:25 +00:00
|
|
|
{
|
2014-08-19 13:51:22 +00:00
|
|
|
struct snd_soc_component *component;
|
2014-03-21 15:27:25 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
|
2014-08-19 13:51:22 +00: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 15:27:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-04-22 04:25:33 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_find_dai - Find a registered DAI
|
|
|
|
*
|
|
|
|
* @dlc: name of the DAI and optional component info to match
|
|
|
|
*
|
2017-05-08 22:57:50 +00:00
|
|
|
* This function will search all registered components and their DAIs to
|
2016-04-22 04:25:33 +00: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 05:12:25 +00:00
|
|
|
struct snd_soc_dai *snd_soc_find_dai(
|
2014-08-19 13:51:27 +00:00
|
|
|
const struct snd_soc_dai_link_component *dlc)
|
2014-03-21 15:27:25 +00:00
|
|
|
{
|
2014-08-19 13:51:27 +00:00
|
|
|
struct snd_soc_component *component;
|
|
|
|
struct snd_soc_dai *dai;
|
2015-05-26 18:59:05 +00:00
|
|
|
struct device_node *component_of_node;
|
2014-03-21 15:27:25 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
|
2014-08-19 13:51:27 +00:00
|
|
|
/* Find CPU DAI from registered DAIs*/
|
|
|
|
list_for_each_entry(component, &component_list, list) {
|
2015-05-26 18:59:05 +00: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 13:51:27 +00:00
|
|
|
continue;
|
2014-10-29 20:46:30 +00:00
|
|
|
if (dlc->name && strcmp(component->name, dlc->name))
|
2014-08-19 13:51:27 +00:00
|
|
|
continue;
|
|
|
|
list_for_each_entry(dai, &component->dai_list, list) {
|
|
|
|
if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
|
2014-03-21 15:27:25 +00:00
|
|
|
continue;
|
|
|
|
|
2014-08-19 13:51:27 +00:00
|
|
|
return dai;
|
2014-03-21 15:27:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-19 05:12:25 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_find_dai);
|
2014-03-21 15:27:25 +00:00
|
|
|
|
2016-11-02 17:04:12 +00: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 11:38:15 +00:00
|
|
|
* @stream_name: DAI link stream name to match, optional
|
2016-11-02 17:04:12 +00: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 06:11:40 +00: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 16:03:52 +00:00
|
|
|
static int soc_bind_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2014-07-08 21:19:34 +00:00
|
|
|
struct snd_soc_dai_link_component *codecs = dai_link->codecs;
|
2014-08-19 13:51:27 +00:00
|
|
|
struct snd_soc_dai_link_component cpu_dai_component;
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_dai **codec_dais;
|
2008-12-04 15:32:53 +00:00
|
|
|
struct snd_soc_platform *platform;
|
2016-11-07 13:03:17 +00:00
|
|
|
struct device_node *platform_of_node;
|
2011-04-27 17:16:32 +00:00
|
|
|
const char *platform_name;
|
2014-07-08 21:19:34 +00:00
|
|
|
int i;
|
2008-12-04 15:32:53 +00:00
|
|
|
|
2015-11-23 16:03:52 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
|
2008-12-04 15:32:53 +00:00
|
|
|
|
2015-12-02 06:11:40 +00: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 15:32:53 +00:00
|
|
|
|
2016-02-22 08:44:31 +00:00
|
|
|
rtd = soc_new_pcm_runtime(card, dai_link);
|
|
|
|
if (!rtd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-08-19 13:51:27 +00: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-14 21:18:39 +00:00
|
|
|
if (!rtd->cpu_dai) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
|
2012-03-14 21:18:39 +00:00
|
|
|
dai_link->cpu_dai_name);
|
2015-11-18 07:34:11 +00:00
|
|
|
goto _err_defer;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
rtd->num_codecs = dai_link->num_codecs;
|
2011-04-27 17:16:32 +00:00
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
/* Find CODEC from registered CODECs */
|
2015-11-18 07:34:11 +00:00
|
|
|
codec_dais = rtd->codec_dais;
|
2014-07-08 21:19:34 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-08-19 13:51:27 +00:00
|
|
|
codec_dais[i] = snd_soc_find_dai(&codecs[i]);
|
2014-07-08 21:19:34 +00:00
|
|
|
if (!codec_dais[i]) {
|
|
|
|
dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
|
|
|
|
codecs[i].dai_name);
|
2015-11-18 07:34:11 +00:00
|
|
|
goto _err_defer;
|
2014-07-08 21:19:34 +00:00
|
|
|
}
|
2014-03-21 15:27:25 +00:00
|
|
|
}
|
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
/* Single codec links expect codec and codec_dai in runtime data */
|
|
|
|
rtd->codec_dai = codec_dais[0];
|
|
|
|
rtd->codec = rtd->codec_dai->codec;
|
|
|
|
|
2011-04-27 17:16:32 +00:00
|
|
|
/* if there's no platform we match on the empty platform */
|
|
|
|
platform_name = dai_link->platform_name;
|
2011-12-21 17:40:59 +00:00
|
|
|
if (!platform_name && !dai_link->platform_of_node)
|
2011-04-27 17:16:32 +00:00
|
|
|
platform_name = "snd-soc-dummy";
|
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
/* find one from the set of registered platforms */
|
2010-03-17 20:15:21 +00:00
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
2016-11-07 13:03:17 +00:00
|
|
|
platform_of_node = platform->dev->of_node;
|
|
|
|
if (!platform_of_node && platform->dev->parent->of_node)
|
|
|
|
platform_of_node = platform->dev->parent->of_node;
|
|
|
|
|
2011-12-21 17:40:59 +00:00
|
|
|
if (dai_link->platform_of_node) {
|
2016-11-07 13:03:17 +00:00
|
|
|
if (platform_of_node != dai_link->platform_of_node)
|
2011-12-21 17:40:59 +00:00
|
|
|
continue;
|
|
|
|
} else {
|
2014-06-16 16:13:02 +00:00
|
|
|
if (strcmp(platform->component.name, platform_name))
|
2011-12-21 17:40:59 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-12-07 20:58:27 +00:00
|
|
|
|
|
|
|
rtd->platform = platform;
|
2009-10-16 10:13:38 +00:00
|
|
|
}
|
2012-03-14 21:18:39 +00:00
|
|
|
if (!rtd->platform) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: platform %s not registered\n",
|
2010-03-17 20:15:21 +00:00
|
|
|
dai_link->platform_name);
|
2016-08-11 13:39:00 +00:00
|
|
|
goto _err_defer;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
2012-03-14 21:18:39 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
soc_add_pcm_runtime(card, rtd);
|
2012-03-14 21:18:39 +00:00
|
|
|
return 0;
|
2015-11-18 07:34:11 +00:00
|
|
|
|
|
|
|
_err_defer:
|
|
|
|
soc_free_pcm_runtime(rtd);
|
|
|
|
return -EPROBE_DEFER;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
static void soc_remove_component(struct snd_soc_component *component)
|
2012-06-08 18:34:22 +00:00
|
|
|
{
|
2015-07-08 18:47:44 +00:00
|
|
|
if (!component->card)
|
2014-08-19 13:51:24 +00:00
|
|
|
return;
|
2012-06-08 18:34:22 +00:00
|
|
|
|
2016-11-30 06:22:36 +00:00
|
|
|
list_del(&component->card_list);
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (component->remove)
|
|
|
|
component->remove(component);
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
snd_soc_dapm_free(snd_soc_component_get_dapm(component));
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
soc_cleanup_component_debugfs(component);
|
2015-07-08 18:47:44 +00:00
|
|
|
component->card = NULL;
|
2014-08-19 13:51:19 +00:00
|
|
|
module_put(component->dev->driver->owner);
|
2010-12-06 14:27:07 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:26 +00:00
|
|
|
static void soc_remove_dai(struct snd_soc_dai *dai, int order)
|
2010-03-17 20:15:21 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2014-08-19 13:51:26 +00:00
|
|
|
if (dai && dai->probed &&
|
|
|
|
dai->driver->remove_order == order) {
|
|
|
|
if (dai->driver->remove) {
|
|
|
|
err = dai->driver->remove(dai);
|
2010-03-17 20:15:21 +00:00
|
|
|
if (err < 0)
|
2014-08-19 13:51:26 +00:00
|
|
|
dev_err(dai->dev,
|
2012-11-19 14:47:09 +00:00
|
|
|
"ASoC: failed to remove %s: %d\n",
|
2014-08-19 13:51:26 +00:00
|
|
|
dai->name, err);
|
2008-12-08 19:26:48 +00:00
|
|
|
}
|
2014-08-19 13:51:26 +00:00
|
|
|
dai->probed = 0;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
2014-03-21 15:27:26 +00:00
|
|
|
}
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
static void soc_remove_link_dais(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2014-03-21 15:27:26 +00:00
|
|
|
{
|
2014-08-19 13:51:26 +00:00
|
|
|
int i;
|
2014-03-21 15:27:26 +00:00
|
|
|
|
|
|
|
/* unregister the rtd device */
|
|
|
|
if (rtd->dev_registered) {
|
|
|
|
device_unregister(rtd->dev);
|
|
|
|
rtd->dev_registered = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove the CODEC DAI */
|
2014-07-08 21:19:34 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++)
|
2014-08-19 13:51:26 +00:00
|
|
|
soc_remove_dai(rtd->codec_dais[i], order);
|
2008-12-08 19:26:48 +00:00
|
|
|
|
2014-08-19 13:51:26 +00:00
|
|
|
soc_remove_dai(rtd->cpu_dai, order);
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
static void soc_remove_link_components(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2012-06-08 18:34:23 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
2014-08-19 13:51:21 +00:00
|
|
|
struct snd_soc_component *component;
|
2014-07-08 21:19:34 +00:00
|
|
|
int i;
|
2012-06-08 18:34:23 +00:00
|
|
|
|
|
|
|
/* remove the platform */
|
2014-08-19 13:51:24 +00:00
|
|
|
if (platform && platform->component.driver->remove_order == order)
|
2014-08-19 13:51:19 +00:00
|
|
|
soc_remove_component(&platform->component);
|
2012-06-08 18:34:23 +00:00
|
|
|
|
|
|
|
/* remove the CODEC-side CODEC */
|
2014-07-08 21:19:34 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-08-19 13:51:21 +00:00
|
|
|
component = rtd->codec_dais[i]->component;
|
2014-08-19 13:51:24 +00:00
|
|
|
if (component->driver->remove_order == order)
|
2014-08-19 13:51:21 +00:00
|
|
|
soc_remove_component(component);
|
2012-06-08 18:34:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* remove any CPU-side CODEC */
|
|
|
|
if (cpu_dai) {
|
2014-08-19 13:51:24 +00:00
|
|
|
if (cpu_dai->component->driver->remove_order == order)
|
2014-08-19 13:51:21 +00:00
|
|
|
soc_remove_component(cpu_dai->component);
|
2012-06-08 18:34:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-08 05:50:44 +00:00
|
|
|
static void soc_remove_dai_links(struct snd_soc_card *card)
|
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
int order;
|
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2015-12-02 06:11:22 +00:00
|
|
|
struct snd_soc_dai_link *link, *_link;
|
2011-04-08 05:50:44 +00:00
|
|
|
|
2011-06-07 15:08:05 +00:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
soc_remove_link_dais(card, rtd, order);
|
2012-06-08 18:34:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
|
|
|
soc_remove_link_components(card, rtd, order);
|
2011-06-07 15:08:05 +00:00
|
|
|
}
|
2012-06-08 18:34:23 +00:00
|
|
|
|
2015-12-02 06:11:22 +00: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 05:50:44 +00:00
|
|
|
}
|
|
|
|
|
2015-11-23 16:01:49 +00: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 05:50:44 +00:00
|
|
|
}
|
|
|
|
|
2015-12-02 06:11:22 +00: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 06:11:32 +00: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 06:11:22 +00: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 06:11:32 +00: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 06:11:22 +00: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);
|
|
|
|
|
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-13 18:40:44 +00:00
|
|
|
static void soc_set_name_prefix(struct snd_soc_card *card,
|
2014-06-16 16:13:01 +00: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-13 18:40:44 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-12-02 14:53:03 +00:00
|
|
|
if (card->codec_conf == NULL)
|
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-13 18:40:44 +00:00
|
|
|
return;
|
|
|
|
|
2010-12-02 14:53:03 +00:00
|
|
|
for (i = 0; i < card->num_configs; i++) {
|
|
|
|
struct snd_soc_codec_conf *map = &card->codec_conf[i];
|
2014-06-16 16:13:01 +00:00
|
|
|
if (map->of_node && component->dev->of_node != map->of_node)
|
2014-04-28 14:07:22 +00:00
|
|
|
continue;
|
2014-06-16 16:13:01 +00:00
|
|
|
if (map->dev_name && strcmp(component->name, map->dev_name))
|
2014-04-28 14:07:22 +00:00
|
|
|
continue;
|
2014-06-16 16:13:01 +00:00
|
|
|
component->name_prefix = map->name_prefix;
|
2014-04-28 14:07:22 +00:00
|
|
|
break;
|
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-13 18:40:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
static int soc_probe_component(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_component *component)
|
2010-12-06 14:27:07 +00:00
|
|
|
{
|
2014-08-19 13:51:19 +00:00
|
|
|
struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
|
2012-02-17 03:37:51 +00:00
|
|
|
struct snd_soc_dai *dai;
|
2014-08-19 13:51:19 +00:00
|
|
|
int ret;
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2015-07-08 18:47:43 +00:00
|
|
|
if (!strcmp(component->name, "snd-soc-dummy"))
|
2014-08-19 13:51:24 +00:00
|
|
|
return 0;
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2015-07-08 18:47:44 +00:00
|
|
|
if (component->card) {
|
2015-07-08 18:47:43 +00: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 14:27:07 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (!try_module_get(component->dev->driver->owner))
|
2011-01-27 14:24:22 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
component->card = card;
|
|
|
|
dapm->card = card;
|
|
|
|
soc_set_name_prefix(card, component);
|
2010-12-06 14:27:07 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
soc_init_component_debugfs(component);
|
2011-04-30 17:45:49 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (component->dapm_widgets) {
|
|
|
|
ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
|
|
|
|
component->num_dapm_widgets);
|
2014-04-01 12:59:33 +00:00
|
|
|
|
|
|
|
if (ret != 0) {
|
2014-08-19 13:51:19 +00:00
|
|
|
dev_err(component->dev,
|
2014-04-01 12:59:33 +00:00
|
|
|
"Failed to create new controls %d\n", ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
2011-05-05 14:59:09 +00:00
|
|
|
|
2014-08-20 11:08:49 +00:00
|
|
|
list_for_each_entry(dai, &component->dai_list, list) {
|
|
|
|
ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
|
2014-03-31 14:47:12 +00:00
|
|
|
if (ret != 0) {
|
2014-08-20 11:08:49 +00:00
|
|
|
dev_err(component->dev,
|
2014-03-31 14:47:12 +00:00
|
|
|
"Failed to create DAI widgets %d\n", ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
2012-02-17 03:37:51 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (component->probe) {
|
|
|
|
ret = component->probe(component);
|
2010-12-06 14:27:07 +00:00
|
|
|
if (ret < 0) {
|
2014-08-19 13:51:19 +00:00
|
|
|
dev_err(component->dev,
|
|
|
|
"ASoC: failed to probe component %d\n", ret);
|
2011-01-27 14:24:22 +00:00
|
|
|
goto err_probe;
|
2010-12-06 14:27:07 +00:00
|
|
|
}
|
2011-07-04 21:10:53 +00:00
|
|
|
|
2014-08-19 13:51:19 +00: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 11:47:41 +00:00
|
|
|
}
|
|
|
|
|
2016-01-06 05:29:31 +00: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (component->controls)
|
|
|
|
snd_soc_add_component_controls(component, component->controls,
|
|
|
|
component->num_controls);
|
|
|
|
if (component->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(dapm, component->dapm_routes,
|
|
|
|
component->num_dapm_routes);
|
2012-04-05 18:28:01 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
list_add(&dapm->list, &card->dapm_list);
|
2016-11-30 06:22:36 +00:00
|
|
|
list_add(&component->card_list, &card->component_dev_list);
|
2011-07-01 15:54:08 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_probe:
|
2014-08-19 13:51:19 +00:00
|
|
|
soc_cleanup_component_debugfs(component);
|
2015-07-08 18:47:44 +00:00
|
|
|
component->card = NULL;
|
2014-08-19 13:51:19 +00:00
|
|
|
module_put(component->dev->driver->owner);
|
2011-07-01 15:54:08 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-07 01:12:45 +00:00
|
|
|
static void rtd_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(dev);
|
|
|
|
}
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2014-07-01 20:13:48 +00:00
|
|
|
static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
const char *name)
|
2014-04-24 12:01:44 +00:00
|
|
|
{
|
2010-12-06 14:27:07 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* register the rtd device */
|
2012-01-07 01:12:45 +00:00
|
|
|
rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
|
|
|
|
if (!rtd->dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
device_initialize(rtd->dev);
|
2014-07-01 20:13:48 +00:00
|
|
|
rtd->dev->parent = rtd->card->dev;
|
2012-01-07 01:12:45 +00:00
|
|
|
rtd->dev->release = rtd_release;
|
2015-01-30 19:16:37 +00:00
|
|
|
rtd->dev->groups = soc_dev_attr_groups;
|
2014-08-17 09:28:35 +00:00
|
|
|
dev_set_name(rtd->dev, "%s", name);
|
2012-01-07 01:12:45 +00:00
|
|
|
dev_set_drvdata(rtd->dev, rtd);
|
2011-06-09 16:04:39 +00: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 11:12:49 +00: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 01:12:45 +00:00
|
|
|
ret = device_add(rtd->dev);
|
2010-12-06 14:27:07 +00:00
|
|
|
if (ret < 0) {
|
2012-12-25 16:56:05 +00:00
|
|
|
/* calling put_device() here to free the rtd->dev */
|
|
|
|
put_device(rtd->dev);
|
2014-07-01 20:13:48 +00:00
|
|
|
dev_err(rtd->card->dev,
|
2012-11-19 14:47:09 +00:00
|
|
|
"ASoC: failed to register runtime device: %d\n", ret);
|
2010-12-06 14:27:07 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
rtd->dev_registered = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
static int soc_probe_link_components(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd,
|
2012-06-08 18:34:23 +00:00
|
|
|
int order)
|
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
2014-08-19 13:51:19 +00:00
|
|
|
struct snd_soc_component *component;
|
2014-07-08 21:19:34 +00:00
|
|
|
int i, ret;
|
2012-06-08 18:34:23 +00:00
|
|
|
|
|
|
|
/* probe the CPU-side component, if it is a CODEC */
|
2014-08-19 13:51:21 +00:00
|
|
|
component = rtd->cpu_dai->component;
|
2014-08-19 13:51:24 +00:00
|
|
|
if (component->driver->probe_order == order) {
|
2014-08-19 13:51:21 +00:00
|
|
|
ret = soc_probe_component(card, component);
|
2012-06-08 18:34:23 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
/* probe the CODEC-side components */
|
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-08-19 13:51:21 +00:00
|
|
|
component = rtd->codec_dais[i]->component;
|
2014-08-19 13:51:24 +00:00
|
|
|
if (component->driver->probe_order == order) {
|
2014-08-19 13:51:19 +00:00
|
|
|
ret = soc_probe_component(card, component);
|
2014-07-08 21:19:34 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2012-06-08 18:34:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* probe the platform */
|
2014-08-19 13:51:24 +00:00
|
|
|
if (platform->component.driver->probe_order == order) {
|
2014-08-19 13:51:19 +00:00
|
|
|
ret = soc_probe_component(card, &platform->component);
|
2012-06-08 18:34:23 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-04 10:30:59 +00:00
|
|
|
static int soc_probe_dai(struct snd_soc_dai *dai, int order)
|
2014-03-21 15:27:26 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-11-04 10:30:59 +00:00
|
|
|
if (!dai->probed && dai->driver->probe_order == order) {
|
|
|
|
if (dai->driver->probe) {
|
|
|
|
ret = dai->driver->probe(dai);
|
2014-03-21 15:27:26 +00:00
|
|
|
if (ret < 0) {
|
2014-11-04 10:30:59 +00:00
|
|
|
dev_err(dai->dev,
|
|
|
|
"ASoC: failed to probe DAI %s: %d\n",
|
|
|
|
dai->name, ret);
|
2014-03-21 15:27:26 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-04 10:30:59 +00:00
|
|
|
dai->probed = 1;
|
2014-03-21 15:27:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-03 15:52:51 +00: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 15:27:27 +00:00
|
|
|
static int soc_link_dai_widgets(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link,
|
2014-07-01 07:47:54 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd)
|
2014-03-21 15:27:27 +00:00
|
|
|
{
|
2014-07-01 07:47:54 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
2015-11-09 17:49:58 +00:00
|
|
|
struct snd_soc_dapm_widget *sink, *source;
|
2014-03-21 15:27:27 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
if (rtd->num_codecs > 1)
|
|
|
|
dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
|
|
|
|
|
2014-03-21 15:27:27 +00:00
|
|
|
/* link the DAI widgets */
|
2015-11-09 17:49:58 +00:00
|
|
|
sink = codec_dai->playback_widget;
|
|
|
|
source = cpu_dai->capture_widget;
|
|
|
|
if (sink && source) {
|
2014-03-21 15:27:27 +00:00
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
2015-11-09 17:49:58 +00:00
|
|
|
dai_link->num_params,
|
|
|
|
source, sink);
|
2014-03-21 15:27:27 +00:00
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
|
2015-11-09 17:49:58 +00:00
|
|
|
sink->name, source->name, ret);
|
2014-03-21 15:27:27 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-09 17:49:58 +00:00
|
|
|
sink = cpu_dai->playback_widget;
|
|
|
|
source = codec_dai->capture_widget;
|
|
|
|
if (sink && source) {
|
2014-03-21 15:27:27 +00:00
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
2015-11-09 17:49:58 +00:00
|
|
|
dai_link->num_params,
|
|
|
|
source, sink);
|
2014-03-21 15:27:27 +00:00
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
|
2015-11-09 17:49:58 +00:00
|
|
|
sink->name, source->name, ret);
|
2014-03-21 15:27:27 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
static int soc_probe_link_dais(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_pcm_runtime *rtd, int order)
|
2010-03-17 20:15:21 +00:00
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_dai_link *dai_link = rtd->dai_link;
|
2012-04-04 21:12:09 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2014-07-08 21:19:34 +00:00
|
|
|
int i, ret;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
|
2015-11-18 07:34:11 +00:00
|
|
|
card->name, rtd->num, order);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
|
|
|
/* set default power off timeout */
|
|
|
|
rtd->pmdown_time = pmdown_time;
|
|
|
|
|
2014-11-04 10:30:59 +00:00
|
|
|
ret = soc_probe_dai(cpu_dai, order);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
/* probe the CODEC DAI */
|
2014-07-08 21:19:34 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
2014-11-04 10:30:59 +00:00
|
|
|
ret = soc_probe_dai(rtd->codec_dais[i], order);
|
2014-07-08 21:19:34 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-11-03 22:13:13 +00:00
|
|
|
|
2011-06-07 15:08:05 +00:00
|
|
|
/* complete DAI probe during last probe */
|
|
|
|
if (order != SND_SOC_COMP_ORDER_LAST)
|
|
|
|
return 0;
|
|
|
|
|
2014-07-01 20:13:48 +00: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 09:47:00 +00:00
|
|
|
if (dai_link->dai_fmt)
|
|
|
|
snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
|
|
|
|
|
2014-07-01 20:13:48 +00:00
|
|
|
ret = soc_post_component_init(rtd, dai_link->name);
|
2010-12-06 14:27:07 +00:00
|
|
|
if (ret)
|
2010-03-17 20:15:21 +00:00
|
|
|
return ret;
|
2009-11-03 22:13:13 +00:00
|
|
|
|
2014-07-01 20:13:48 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
/* add DPCM sysfs entries */
|
2015-04-09 08:52:37 +00:00
|
|
|
if (dai_link->dynamic)
|
|
|
|
soc_dpcm_debugfs_add(rtd);
|
2014-07-01 20:13:48 +00:00
|
|
|
#endif
|
|
|
|
|
2015-10-13 15:41:00 +00:00
|
|
|
if (cpu_dai->driver->compress_new) {
|
2012-08-16 11:40:41 +00:00
|
|
|
/*create compress_device"*/
|
2015-11-18 07:34:11 +00:00
|
|
|
ret = cpu_dai->driver->compress_new(rtd, rtd->num);
|
2012-04-04 21:12:09 +00:00
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: can't create compress %s\n",
|
2012-08-16 11:40:41 +00:00
|
|
|
dai_link->stream_name);
|
2012-04-04 21:12:09 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
2012-08-16 11:40:41 +00:00
|
|
|
|
|
|
|
if (!dai_link->params) {
|
|
|
|
/* create the pcm */
|
2015-11-18 07:34:11 +00:00
|
|
|
ret = soc_new_pcm(rtd, rtd->num);
|
2012-08-16 11:40:41 +00:00
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
|
2012-08-16 11:40:41 +00:00
|
|
|
dai_link->stream_name, ret);
|
2012-04-04 21:12:09 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2017-01-03 15:52:51 +00: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 11:40:41 +00:00
|
|
|
} else {
|
2013-08-05 12:17:28 +00:00
|
|
|
INIT_DELAYED_WORK(&rtd->delayed_work,
|
|
|
|
codec2codec_close_delayed_work);
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
/* link the DAI widgets */
|
2014-07-01 07:47:54 +00:00
|
|
|
ret = soc_link_dai_widgets(card, dai_link, rtd);
|
2014-03-21 15:27:27 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-04-04 21:12:09 +00:00
|
|
|
}
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-01 20:13:47 +00:00
|
|
|
static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
|
2014-04-28 14:07:22 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
|
2016-01-06 05:29:31 +00: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 14:07:22 +00:00
|
|
|
}
|
2012-08-09 17:44:37 +00:00
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
component->init = aux_dev->init;
|
2016-12-29 13:11:21 +00:00
|
|
|
list_add(&component->card_aux_list, &card->aux_comp_list);
|
2016-11-30 06:22:55 +00:00
|
|
|
|
2014-07-01 20:13:47 +00:00
|
|
|
return 0;
|
2016-01-06 05:29:31 +00:00
|
|
|
|
|
|
|
err_defer:
|
|
|
|
dev_err(card->dev, "ASoC: %s not registered\n", name);
|
|
|
|
return -EPROBE_DEFER;
|
2012-03-14 21:18:39 +00:00
|
|
|
}
|
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
static int soc_probe_aux_devices(struct snd_soc_card *card)
|
2010-11-25 15:47:38 +00:00
|
|
|
{
|
2017-03-24 00:13:00 +00:00
|
|
|
struct snd_soc_component *comp;
|
2016-01-06 05:29:31 +00:00
|
|
|
int order;
|
2014-07-01 20:13:47 +00:00
|
|
|
int ret;
|
2014-04-28 14:07:22 +00:00
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2017-03-24 00:13:00 +00:00
|
|
|
list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
|
2016-01-06 05:29:31 +00: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-01 20:13:48 +00:00
|
|
|
}
|
|
|
|
}
|
2010-11-25 15:47:38 +00:00
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
return 0;
|
2010-11-25 15:47:38 +00:00
|
|
|
}
|
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
static void soc_remove_aux_devices(struct snd_soc_card *card)
|
2010-11-25 15:47:38 +00:00
|
|
|
{
|
2016-01-06 05:29:31 +00:00
|
|
|
struct snd_soc_component *comp, *_comp;
|
|
|
|
int order;
|
2010-11-25 15:47:38 +00:00
|
|
|
|
2016-01-06 05:29:31 +00: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 00:13:00 +00:00
|
|
|
&card->aux_comp_list, card_aux_list) {
|
2016-11-30 06:22:55 +00:00
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
if (comp->driver->remove_order == order) {
|
|
|
|
soc_remove_component(comp);
|
2017-03-24 00:13:00 +00:00
|
|
|
/* remove it from the card's aux_comp_list */
|
|
|
|
list_del(&comp->card_aux_list);
|
2016-01-06 05:29:31 +00:00
|
|
|
}
|
|
|
|
}
|
2010-11-25 15:47:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-31 18:31:15 +00:00
|
|
|
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
|
2010-12-02 16:11:06 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (codec->cache_init)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = snd_soc_cache_init(codec);
|
|
|
|
if (ret < 0) {
|
2013-05-04 20:21:38 +00:00
|
|
|
dev_err(codec->dev,
|
|
|
|
"ASoC: Failed to set cache compression type: %d\n",
|
|
|
|
ret);
|
2010-12-02 16:11:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
codec->cache_init = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-06 14:17:20 +00: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 */
|
|
|
|
if (cpu_dai->codec) {
|
|
|
|
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 11:23:05 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
|
2015-01-06 14:17:20 +00:00
|
|
|
|
2017-01-14 08:13:02 +00:00
|
|
|
|
2017-04-24 06:54:41 +00:00
|
|
|
#ifdef CONFIG_DMI
|
2017-01-14 08:13:02 +00: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 07:01:39 +00: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 16:27:13 +00:00
|
|
|
}
|
2017-06-28 07:01:39 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-01-14 08:13:02 +00: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 07:01:39 +00:00
|
|
|
if (!vendor || !is_dmi_valid(vendor)) {
|
2017-01-14 08:13:02 +00:00
|
|
|
dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-28 07:01:39 +00:00
|
|
|
|
2017-01-14 08:13:02 +00: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 07:01:39 +00:00
|
|
|
if (product && is_dmi_valid(product)) {
|
2017-01-14 08:13:02 +00: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 07:01:39 +00:00
|
|
|
if (product_version && is_dmi_valid(product_version)) {
|
2017-01-14 08:13:02 +00: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 07:01:39 +00:00
|
|
|
if (board && is_dmi_valid(board)) {
|
2017-01-14 08:13:02 +00: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 06:54:41 +00:00
|
|
|
#endif /* CONFIG_DMI */
|
2017-01-14 08:13:02 +00:00
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
static int snd_soc_instantiate_card(struct snd_soc_card *card)
|
2010-03-17 20:15:21 +00:00
|
|
|
{
|
2010-12-02 16:11:06 +00:00
|
|
|
struct snd_soc_codec *codec;
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2015-12-02 06:11:48 +00:00
|
|
|
struct snd_soc_dai_link *dai_link;
|
2015-01-06 14:17:20 +00:00
|
|
|
int ret, i, order;
|
2009-11-03 22:13:13 +00:00
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2012-03-07 10:38:25 +00:00
|
|
|
mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
|
2010-02-12 11:37:24 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
/* bind DAIs */
|
2012-03-14 21:18:39 +00:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
2015-11-23 16:03:52 +00:00
|
|
|
ret = soc_bind_dai_link(card, &card->dai_link[i]);
|
2012-03-14 21:18:39 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
|
|
|
}
|
2009-11-03 22:13:13 +00:00
|
|
|
|
2014-07-01 20:13:47 +00:00
|
|
|
/* bind aux_devs too */
|
2012-03-14 21:18:39 +00:00
|
|
|
for (i = 0; i < card->num_aux_devs; i++) {
|
2014-07-01 20:13:47 +00:00
|
|
|
ret = soc_bind_aux_dev(card, i);
|
2012-03-14 21:18:39 +00:00
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
2008-12-04 15:32:53 +00:00
|
|
|
|
2015-12-02 06:11:22 +00: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-12-02 16:11:06 +00:00
|
|
|
/* initialize the register cache for each available codec */
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (codec->cache_init)
|
|
|
|
continue;
|
2013-08-31 18:31:15 +00:00
|
|
|
ret = snd_soc_init_codec_cache(codec);
|
2012-03-14 21:18:39 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto base_error;
|
2010-12-02 16:11:06 +00:00
|
|
|
}
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
/* card bind complete so register a sound card */
|
2014-01-29 13:42:55 +00:00
|
|
|
ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
|
2010-03-17 20:15:21 +00:00
|
|
|
card->owner, 0, &card->snd_card);
|
|
|
|
if (ret < 0) {
|
2013-05-04 20:21:38 +00:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: can't create sound card for card %s: %d\n",
|
|
|
|
card->name, ret);
|
2012-03-14 21:18:39 +00:00
|
|
|
goto base_error;
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
|
2015-04-09 08:52:36 +00:00
|
|
|
soc_init_card_debugfs(card);
|
|
|
|
|
2011-03-02 18:21:57 +00: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-04-30 17:45:49 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
|
|
|
|
#endif
|
|
|
|
|
2011-02-02 10:43:26 +00:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2010-03-17 20:15:21 +00:00
|
|
|
/* deferred resume work */
|
|
|
|
INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
|
|
|
|
#endif
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2011-04-13 00:51:37 +00:00
|
|
|
if (card->dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
|
|
|
|
card->num_dapm_widgets);
|
|
|
|
|
2015-02-15 01:22:49 +00:00
|
|
|
if (card->of_dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
|
|
|
|
card->num_of_dapm_widgets);
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
/* initialise the sound card only once */
|
|
|
|
if (card->probe) {
|
2011-01-26 14:17:20 +00:00
|
|
|
ret = card->probe(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto card_probe_error;
|
|
|
|
}
|
2009-11-03 22:13:13 +00:00
|
|
|
|
2012-06-08 18:34:23 +00:00
|
|
|
/* probe all components used by DAI links on this card */
|
2011-06-07 15:08:05 +00:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
ret = soc_probe_link_components(card, rtd, order);
|
2011-06-07 15:08:05 +00:00
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: failed to instantiate card %d\n",
|
|
|
|
ret);
|
2012-06-08 18:34:23 +00:00
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
/* probe auxiliary components */
|
|
|
|
ret = soc_probe_aux_devices(card);
|
|
|
|
if (ret < 0)
|
|
|
|
goto probe_dai_err;
|
|
|
|
|
2015-12-02 06:11:48 +00: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-08 18:34:23 +00: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 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
|
|
|
ret = soc_probe_link_dais(card, rtd, order);
|
2012-06-08 18:34:23 +00:00
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: failed to instantiate card %d\n",
|
|
|
|
ret);
|
2011-06-07 15:08:05 +00:00
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
2010-03-17 20:15:21 +00:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2012-02-17 03:37:51 +00:00
|
|
|
snd_soc_dapm_link_dai_widgets(card);
|
2014-01-08 10:40:19 +00:00
|
|
|
snd_soc_dapm_connect_dai_link_widgets(card);
|
2012-02-17 03:37:51 +00:00
|
|
|
|
2011-04-07 10:18:44 +00:00
|
|
|
if (card->controls)
|
2012-02-03 17:43:09 +00:00
|
|
|
snd_soc_add_card_controls(card, card->controls, card->num_controls);
|
2011-04-07 10:18:44 +00:00
|
|
|
|
2011-03-02 18:35:51 +00:00
|
|
|
if (card->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
|
|
|
|
card->num_dapm_routes);
|
|
|
|
|
2015-02-15 01:22:49 +00: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 15:41:01 +00:00
|
|
|
|
2017-04-24 06:54:42 +00:00
|
|
|
/* try to set some sane longname if DMI is available */
|
|
|
|
snd_soc_set_dmi_name(card, NULL);
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
|
|
|
|
"%s", card->name);
|
2011-05-12 15:14:04 +00:00
|
|
|
snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
|
|
|
|
"%s", card->long_name ? card->long_name : card->name);
|
2011-09-20 10:41:54 +00: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-17 20:15:21 +00:00
|
|
|
|
2011-03-02 18:36:34 +00:00
|
|
|
if (card->late_probe) {
|
|
|
|
ret = card->late_probe(card);
|
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
|
2011-03-02 18:36:34 +00:00
|
|
|
card->name, ret);
|
|
|
|
goto probe_aux_dev_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-27 13:51:01 +00:00
|
|
|
snd_soc_dapm_new_widgets(card);
|
2013-08-27 13:51:00 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
ret = snd_card_register(card->snd_card);
|
|
|
|
if (ret < 0) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
|
|
|
|
ret);
|
2010-12-07 08:12:29 +00:00
|
|
|
goto probe_aux_dev_err;
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
card->instantiated = 1;
|
2011-10-07 13:29:19 +00:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2010-03-17 20:15:21 +00:00
|
|
|
mutex_unlock(&card->mutex);
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2012-03-14 21:18:39 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2010-11-25 15:47:38 +00:00
|
|
|
probe_aux_dev_err:
|
2016-01-06 05:29:31 +00:00
|
|
|
soc_remove_aux_devices(card);
|
2010-11-25 15:47:38 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
probe_dai_err:
|
2011-04-08 05:50:44 +00:00
|
|
|
soc_remove_dai_links(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
|
|
|
card_probe_error:
|
2008-11-18 20:50:34 +00:00
|
|
|
if (card->remove)
|
2011-01-26 14:17:20 +00:00
|
|
|
card->remove(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2015-07-08 20:14:48 +00:00
|
|
|
snd_soc_dapm_free(&card->dapm);
|
2015-04-09 08:52:36 +00:00
|
|
|
soc_cleanup_card_debugfs(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
base_error:
|
2015-11-18 07:34:11 +00:00
|
|
|
soc_remove_pcm_runtimes(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
mutex_unlock(&card->mutex);
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
return ret;
|
2008-12-04 15:32:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* probes a new socdev */
|
|
|
|
static int soc_probe(struct platform_device *pdev)
|
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2008-12-04 15:32:53 +00:00
|
|
|
|
2011-01-14 13:52:48 +00: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 13:07:41 +00:00
|
|
|
dev_warn(&pdev->dev,
|
2012-11-19 14:47:09 +00:00
|
|
|
"ASoC: machine %s should use snd_soc_register_card()\n",
|
2012-03-02 13:07:41 +00:00
|
|
|
card->name);
|
|
|
|
|
2008-12-04 15:32:53 +00:00
|
|
|
/* Bodge while we unpick instantiation */
|
|
|
|
card->dev = &pdev->dev;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2012-08-09 17:45:23 +00:00
|
|
|
return snd_soc_register_card(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
|
2011-01-13 17:18:02 +00:00
|
|
|
static int soc_cleanup_card_resources(struct snd_soc_card *card)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2011-01-13 17:18:02 +00:00
|
|
|
/* make sure any delayed work runs */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
2012-08-20 21:51:24 +00:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2009-05-11 10:04:55 +00:00
|
|
|
|
2017-05-24 08:19:45 +00:00
|
|
|
/* free the ALSA card at first; this syncs with pending operations */
|
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
|
2011-01-13 17:18:02 +00:00
|
|
|
/* remove and free each DAI */
|
2011-04-08 05:50:44 +00:00
|
|
|
soc_remove_dai_links(card);
|
2015-11-18 07:34:11 +00:00
|
|
|
soc_remove_pcm_runtimes(card);
|
2010-11-25 15:47:38 +00:00
|
|
|
|
2016-01-06 05:29:31 +00:00
|
|
|
/* remove auxiliary devices */
|
|
|
|
soc_remove_aux_devices(card);
|
|
|
|
|
2016-08-18 18:32:59 +00:00
|
|
|
snd_soc_dapm_free(&card->dapm);
|
2011-01-13 17:18:02 +00:00
|
|
|
soc_cleanup_card_debugfs(card);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2011-01-13 17:18:02 +00:00
|
|
|
/* remove the card */
|
|
|
|
if (card->remove)
|
2011-01-26 14:17:20 +00:00
|
|
|
card->remove(card);
|
2010-11-05 18:35:19 +00:00
|
|
|
|
2011-01-13 17:18:02 +00: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 16:31:09 +00:00
|
|
|
|
2008-11-28 13:29:45 +00:00
|
|
|
snd_soc_unregister_card(card);
|
2006-10-06 16:31:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-26 14:59:27 +00:00
|
|
|
int snd_soc_poweroff(struct device *dev)
|
2009-06-22 12:16:51 +00:00
|
|
|
{
|
2011-01-26 14:59:27 +00:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2009-06-22 12:16:51 +00:00
|
|
|
|
|
|
|
if (!card->instantiated)
|
2009-06-30 18:05:15 +00:00
|
|
|
return 0;
|
2009-06-22 12:16:51 +00: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 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list)
|
2012-08-20 21:51:24 +00:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2009-06-22 12:16:51 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
snd_soc_dapm_shutdown(card);
|
2009-06-30 18:05:15 +00: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 06:57:31 +00:00
|
|
|
/* deactivate pins to sleep state */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-08 21:19:34 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2015-11-18 07:34:11 +00:00
|
|
|
int i;
|
2014-07-08 21:19:34 +00: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 06:57:31 +00:00
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
2015-11-18 07:34:11 +00:00
|
|
|
for (i = 0; i < rtd->num_codecs; i++) {
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
|
2014-07-08 21:19:34 +00: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 06:57:31 +00:00
|
|
|
}
|
|
|
|
|
2009-06-30 18:05:15 +00:00
|
|
|
return 0;
|
2009-06-22 12:16:51 +00:00
|
|
|
}
|
2011-01-26 14:59:27 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
|
2009-06-22 12:16:51 +00:00
|
|
|
|
2011-01-26 14:59:27 +00:00
|
|
|
const struct dev_pm_ops snd_soc_pm_ops = {
|
2012-02-24 10:55:49 +00:00
|
|
|
.suspend = snd_soc_suspend,
|
|
|
|
.resume = snd_soc_resume,
|
|
|
|
.freeze = snd_soc_suspend,
|
|
|
|
.thaw = snd_soc_resume,
|
2011-01-26 14:59:27 +00:00
|
|
|
.poweroff = snd_soc_poweroff,
|
2012-02-24 10:55:49 +00:00
|
|
|
.restore = snd_soc_resume,
|
2009-06-30 18:05:15 +00:00
|
|
|
};
|
2011-04-06 01:35:30 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
|
2009-06-30 18:05:15 +00:00
|
|
|
|
2006-10-06 16:31:09 +00:00
|
|
|
/* ASoC platform driver */
|
|
|
|
static struct platform_driver soc_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "soc-audio",
|
2011-01-26 14:59:27 +00:00
|
|
|
.pm = &snd_soc_pm_ops,
|
2006-10-06 16:31:09 +00:00
|
|
|
},
|
|
|
|
.probe = soc_probe,
|
|
|
|
.remove = soc_remove,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_cnew - create new control
|
|
|
|
* @_template: control template
|
|
|
|
* @data: control private data
|
2009-01-01 12:18:17 +00:00
|
|
|
* @long_name: control long name
|
2011-03-08 17:23:24 +00:00
|
|
|
* @prefix: control name prefix
|
2006-10-06 16:31:09 +00: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 01:07:42 +00:00
|
|
|
void *data, const char *long_name,
|
2011-03-08 17:23:24 +00:00
|
|
|
const char *prefix)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
|
|
|
struct snd_kcontrol_new template;
|
2011-03-08 17:23:24 +00:00
|
|
|
struct snd_kcontrol *kcontrol;
|
|
|
|
char *name = NULL;
|
2006-10-06 16:31:09 +00:00
|
|
|
|
|
|
|
memcpy(&template, _template, sizeof(template));
|
|
|
|
template.index = 0;
|
|
|
|
|
2011-03-08 17:23:24 +00:00
|
|
|
if (!long_name)
|
|
|
|
long_name = template.name;
|
|
|
|
|
|
|
|
if (prefix) {
|
2013-05-14 09:05:32 +00:00
|
|
|
name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
|
2011-03-08 17:23:24 +00: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 16:31:09 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_cnew);
|
|
|
|
|
2012-02-03 17:43:09 +00: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 14:47:09 +00:00
|
|
|
dev_err(dev, "ASoC: Failed to add %s: %d\n",
|
|
|
|
control->name, err);
|
2012-02-03 17:43:09 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-29 12:51:58 +00: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-17 20:01:08 +00: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);
|
|
|
|
|
2009-01-09 00:23:21 +00:00
|
|
|
/**
|
2012-02-03 17:43:09 +00:00
|
|
|
* snd_soc_add_codec_controls - add an array of controls to a codec.
|
|
|
|
* Convenience function to add a list of controls. Many codecs were
|
2009-01-09 00:23:21 +00:00
|
|
|
* duplicating this code.
|
|
|
|
*
|
|
|
|
* @codec: codec to add controls to
|
|
|
|
* @controls: array of controls to add
|
|
|
|
* @num_controls: number of elements in the array
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
2012-02-03 17:43:09 +00:00
|
|
|
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
|
2014-07-17 20:01:08 +00:00
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls)
|
2009-01-09 00:23:21 +00:00
|
|
|
{
|
2014-07-17 20:01:08 +00:00
|
|
|
return snd_soc_add_component_controls(&codec->component, controls,
|
|
|
|
num_controls);
|
2009-01-09 00:23:21 +00:00
|
|
|
}
|
2012-02-03 17:43:09 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
|
2009-01-09 00:23:21 +00:00
|
|
|
|
2011-07-04 21:10:51 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_add_platform_controls - add an array of controls to a platform.
|
2012-02-03 17:43:09 +00:00
|
|
|
* Convenience function to add a list of controls.
|
2011-07-04 21:10:51 +00:00
|
|
|
*
|
|
|
|
* @platform: platform 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_platform_controls(struct snd_soc_platform *platform,
|
2014-07-17 20:01:08 +00:00
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls)
|
2011-07-04 21:10:51 +00:00
|
|
|
{
|
2014-07-17 20:01:08 +00:00
|
|
|
return snd_soc_add_component_controls(&platform->component, controls,
|
|
|
|
num_controls);
|
2011-07-04 21:10:51 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
|
|
|
|
|
2012-02-03 17:43:09 +00: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 10:30:58 +00:00
|
|
|
struct snd_card *card = dai->component->card->snd_card;
|
2012-02-03 17:43:09 +00: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 12:19:13 +00: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)
|
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_sysclk)
|
|
|
|
return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
|
2011-03-07 20:58:11 +00:00
|
|
|
else if (dai->codec && dai->codec->driver->set_sysclk)
|
2011-08-24 19:09:01 +00:00
|
|
|
return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
|
2011-03-07 20:58:11 +00:00
|
|
|
freq, dir);
|
2008-07-08 12:19:13 +00:00
|
|
|
else
|
2014-01-15 19:04:19 +00:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 12:19:13 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
|
|
|
|
|
2011-03-07 20:58:11 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_codec_set_sysclk - configure CODEC system or master clock.
|
|
|
|
* @codec: CODEC
|
|
|
|
* @clk_id: DAI specific clock ID
|
2011-08-24 19:09:01 +00:00
|
|
|
* @source: Source for the clock
|
2011-03-07 20:58:11 +00:00
|
|
|
* @freq: new clock frequency in Hz
|
|
|
|
* @dir: new clock direction - input/output.
|
|
|
|
*
|
|
|
|
* Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
|
2011-08-24 19:09:01 +00:00
|
|
|
int source, unsigned int freq, int dir)
|
2011-03-07 20:58:11 +00:00
|
|
|
{
|
|
|
|
if (codec->driver->set_sysclk)
|
2011-08-24 19:09:01 +00:00
|
|
|
return codec->driver->set_sysclk(codec, clk_id, source,
|
|
|
|
freq, dir);
|
2011-03-07 20:58:11 +00:00
|
|
|
else
|
2014-01-15 19:04:19 +00:00
|
|
|
return -ENOTSUPP;
|
2011-03-07 20:58:11 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
|
|
|
|
|
2008-07-08 12:19:13 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_clkdiv - configure DAI clock dividers.
|
|
|
|
* @dai: DAI
|
2009-01-01 12:18:17 +00:00
|
|
|
* @div_id: DAI specific clock divider ID
|
2008-07-08 12:19:13 +00: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)
|
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_clkdiv)
|
|
|
|
return dai->driver->ops->set_clkdiv(dai, div_id, div);
|
2008-07-08 12:19:13 +00: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-05 17:52:16 +00:00
|
|
|
* @source: DAI specific source for the PLL
|
2008-07-08 12:19:13 +00: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-05 17:52:16 +00: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 12:19:13 +00:00
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_pll)
|
|
|
|
return dai->driver->ops->set_pll(dai, pll_id, source,
|
2009-09-05 17:52:16 +00:00
|
|
|
freq_in, freq_out);
|
2011-03-07 20:58:11 +00:00
|
|
|
else if (dai->codec && dai->codec->driver->set_pll)
|
|
|
|
return dai->codec->driver->set_pll(dai->codec, pll_id, source,
|
|
|
|
freq_in, freq_out);
|
2008-07-08 12:19:13 +00:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
|
|
|
|
|
2011-03-07 20:58:11 +00:00
|
|
|
/*
|
|
|
|
* snd_soc_codec_set_pll - configure codec PLL.
|
|
|
|
* @codec: CODEC
|
|
|
|
* @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_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
|
|
|
|
unsigned int freq_in, unsigned int freq_out)
|
|
|
|
{
|
|
|
|
if (codec->driver->set_pll)
|
|
|
|
return codec->driver->set_pll(codec, pll_id, source,
|
|
|
|
freq_in, freq_out);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
|
|
|
|
|
2013-09-16 12:01:46 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
|
|
|
|
* @dai: DAI
|
2015-07-15 14:02:38 +00:00
|
|
|
* @ratio: Ratio of BCLK to Sample rate.
|
2013-09-16 12:01:46 +00: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)
|
|
|
|
{
|
|
|
|
if (dai->driver && dai->driver->ops->set_bclk_ratio)
|
|
|
|
return dai->driver->ops->set_bclk_ratio(dai, ratio);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
|
|
|
|
|
2008-07-08 12:19:13 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_fmt - configure DAI hardware audio format.
|
|
|
|
* @dai: DAI
|
|
|
|
* @fmt: SND_SOC_DAIFMT_ format value.
|
|
|
|
*
|
|
|
|
* Configures the DAI hardware format and clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
|
|
|
|
{
|
2012-03-08 16:59:40 +00:00
|
|
|
if (dai->driver == NULL)
|
2008-07-08 12:19:13 +00:00
|
|
|
return -EINVAL;
|
2012-03-08 16:59:40 +00:00
|
|
|
if (dai->driver->ops->set_fmt == NULL)
|
|
|
|
return -ENOTSUPP;
|
|
|
|
return dai->driver->ops->set_fmt(dai, fmt);
|
2008-07-08 12:19:13 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
|
|
|
|
|
2014-02-14 01:34:35 +00:00
|
|
|
/**
|
2014-03-21 06:17:12 +00:00
|
|
|
* snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
|
2014-02-14 01:34:35 +00: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 06:17:12 +00:00
|
|
|
static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
|
2014-02-14 01:34:35 +00: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 12:19:13 +00:00
|
|
|
/**
|
2015-01-12 09:27:20 +00:00
|
|
|
* snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
|
|
|
|
* @dai: The DAI to configure
|
2009-06-16 00:44:31 +00:00
|
|
|
* @tx_mask: bitmask representing active TX slots.
|
|
|
|
* @rx_mask: bitmask representing active RX slots.
|
2008-07-08 12:19:13 +00:00
|
|
|
* @slots: Number of slots in use.
|
2009-06-16 00:44:31 +00:00
|
|
|
* @slot_width: Width in bits for each slot.
|
2008-07-08 12:19:13 +00:00
|
|
|
*
|
2015-01-12 09:27:20 +00: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 12:19:13 +00:00
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
|
2009-06-16 00:44:31 +00:00
|
|
|
unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
|
2008-07-08 12:19:13 +00:00
|
|
|
{
|
2014-03-21 06:17:12 +00:00
|
|
|
if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
|
|
|
|
dai->driver->ops->xlate_tdm_slot_mask(slots,
|
2014-02-14 01:34:35 +00:00
|
|
|
&tx_mask, &rx_mask);
|
|
|
|
else
|
2014-03-21 06:17:12 +00:00
|
|
|
snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
|
2014-02-14 01:34:35 +00:00
|
|
|
|
2014-07-08 21:19:34 +00:00
|
|
|
dai->tx_mask = tx_mask;
|
|
|
|
dai->rx_mask = rx_mask;
|
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_tdm_slot)
|
|
|
|
return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
|
2009-06-16 00:44:31 +00:00
|
|
|
slots, slot_width);
|
2008-07-08 12:19:13 +00:00
|
|
|
else
|
2014-01-23 05:02:47 +00:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 12:19:13 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
|
|
|
|
|
2009-09-11 17:16:29 +00: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)
|
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_channel_map)
|
|
|
|
return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
|
2009-09-11 17:16:29 +00:00
|
|
|
rx_num, rx_slot);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
|
|
|
|
|
2008-07-08 12:19:13 +00: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)
|
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
if (dai->driver && dai->driver->ops->set_tristate)
|
|
|
|
return dai->driver->ops->set_tristate(dai, tristate);
|
2008-07-08 12:19:13 +00: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 15:44:07 +00:00
|
|
|
* @direction: stream to mute
|
2008-07-08 12:19:13 +00:00
|
|
|
*
|
|
|
|
* Mutes the DAI DAC.
|
|
|
|
*/
|
2013-02-06 15:44:07 +00:00
|
|
|
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
|
|
|
|
int direction)
|
2008-07-08 12:19:13 +00:00
|
|
|
{
|
2013-02-06 15:44:07 +00: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-17 20:15:21 +00:00
|
|
|
return dai->driver->ops->digital_mute(dai, mute);
|
2008-07-08 12:19:13 +00:00
|
|
|
else
|
2012-04-13 18:16:03 +00:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 12:19:13 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
|
|
|
|
|
2008-11-28 13:29:45 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_register_card - Register a card with the ASoC core
|
|
|
|
*
|
2009-01-01 12:18:17 +00:00
|
|
|
* @card: Card to register
|
2008-11-28 13:29:45 +00:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 13:52:48 +00:00
|
|
|
int snd_soc_register_card(struct snd_soc_card *card)
|
2008-11-28 13:29:45 +00:00
|
|
|
{
|
2015-11-23 16:01:49 +00:00
|
|
|
int i, ret;
|
2015-11-18 07:34:11 +00:00
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2008-11-28 13:29:45 +00:00
|
|
|
if (!card->name || !card->dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-12-21 17:40:59 +00:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
struct snd_soc_dai_link *link = &card->dai_link[i];
|
|
|
|
|
2015-11-23 16:01:49 +00:00
|
|
|
ret = soc_init_dai_link(card, link);
|
2014-07-08 21:19:34 +00:00
|
|
|
if (ret) {
|
2015-11-23 16:01:49 +00:00
|
|
|
dev_err(card->dev, "ASoC: failed to init link %s\n",
|
2013-05-04 20:21:38 +00:00
|
|
|
link->name);
|
2015-11-23 16:01:49 +00:00
|
|
|
return ret;
|
2011-12-21 17:40:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-03 17:25:34 +00:00
|
|
|
dev_set_drvdata(card->dev, card);
|
|
|
|
|
2011-01-28 21:26:35 +00:00
|
|
|
snd_soc_initialize_card_lists(card);
|
|
|
|
|
2015-12-02 06:11:22 +00:00
|
|
|
INIT_LIST_HEAD(&card->dai_link_list);
|
|
|
|
card->num_dai_links = 0;
|
|
|
|
|
2015-11-18 07:34:11 +00:00
|
|
|
INIT_LIST_HEAD(&card->rtd_list);
|
|
|
|
card->num_rtd = 0;
|
|
|
|
|
2011-10-03 20:06:40 +00:00
|
|
|
INIT_LIST_HEAD(&card->dapm_dirty);
|
2015-05-29 18:06:14 +00:00
|
|
|
INIT_LIST_HEAD(&card->dobj_list);
|
2008-11-28 13:29:45 +00:00
|
|
|
card->instantiated = 0;
|
2010-03-17 20:15:21 +00:00
|
|
|
mutex_init(&card->mutex);
|
2012-03-07 10:38:26 +00:00
|
|
|
mutex_init(&card->dapm_mutex);
|
2008-11-28 13:29:45 +00:00
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
ret = snd_soc_instantiate_card(card);
|
|
|
|
if (ret != 0)
|
2015-03-24 09:01:00 +00:00
|
|
|
return ret;
|
2008-11-28 13:29:45 +00: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 06:57:31 +00:00
|
|
|
/* deactivate pins to sleep state */
|
2015-11-18 07:34:11 +00:00
|
|
|
list_for_each_entry(rtd, &card->rtd_list, list) {
|
2014-07-08 21:19:34 +00: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 06:57:31 +00:00
|
|
|
if (!cpu_dai->active)
|
|
|
|
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
|
|
|
}
|
|
|
|
|
2012-03-14 21:18:39 +00:00
|
|
|
return ret;
|
2008-11-28 13:29:45 +00:00
|
|
|
}
|
2011-01-14 13:52:48 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_card);
|
2008-11-28 13:29:45 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_card - Unregister a card with the ASoC core
|
|
|
|
*
|
2009-01-01 12:18:17 +00:00
|
|
|
* @card: Card to unregister
|
2008-11-28 13:29:45 +00:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 13:52:48 +00:00
|
|
|
int snd_soc_unregister_card(struct snd_soc_card *card)
|
2008-11-28 13:29:45 +00:00
|
|
|
{
|
2014-09-04 17:44:04 +00:00
|
|
|
if (card->instantiated) {
|
|
|
|
card->instantiated = false;
|
2014-09-04 17:44:05 +00:00
|
|
|
snd_soc_dapm_shutdown(card);
|
2011-01-13 17:18:02 +00:00
|
|
|
soc_cleanup_card_resources(card);
|
2015-02-05 05:34:10 +00:00
|
|
|
dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
|
2014-09-04 17:44:04 +00:00
|
|
|
}
|
2008-11-28 13:29:45 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-14 13:52:48 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
|
2008-11-28 13:29:45 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
/*
|
|
|
|
* Simplify DAI link configuration by removing ".-1" from device names
|
|
|
|
* and sanitizing names.
|
|
|
|
*/
|
2010-12-06 15:49:20 +00:00
|
|
|
static char *fmt_single_name(struct device *dev, int *id)
|
2010-03-17 20:15:21 +00:00
|
|
|
{
|
|
|
|
char *found, name[NAME_SIZE];
|
|
|
|
int id1, id2;
|
|
|
|
|
|
|
|
if (dev_name(dev) == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2010-12-06 15:42:17 +00:00
|
|
|
strlcpy(name, dev_name(dev), NAME_SIZE);
|
2010-03-17 20:15:21 +00: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 08:10:45 +00:00
|
|
|
*id = ((id1 & 0xffff) << 16) + id2;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
|
|
|
/* sanitize component name for DAI link creation */
|
|
|
|
snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
|
2010-12-06 15:42:17 +00:00
|
|
|
strlcpy(name, tmp, NAME_SIZE);
|
2010-03-17 20:15:21 +00: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-04 20:21:38 +00:00
|
|
|
dev_err(dev,
|
|
|
|
"ASoC: error - multiple DAI %s registered with no name\n",
|
|
|
|
dev_name(dev));
|
2010-03-17 20:15:21 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kstrdup(dai_drv->name, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
/**
|
2014-03-09 16:41:45 +00:00
|
|
|
* snd_soc_unregister_dai - Unregister DAIs from the ASoC core
|
2008-11-30 23:31:24 +00:00
|
|
|
*
|
2014-03-09 16:41:45 +00:00
|
|
|
* @component: The component for which the DAIs should be unregistered
|
2008-11-30 23:31:24 +00:00
|
|
|
*/
|
2014-03-09 16:41:45 +00:00
|
|
|
static void snd_soc_unregister_dais(struct snd_soc_component *component)
|
2008-11-30 23:31:24 +00:00
|
|
|
{
|
2014-03-12 07:34:39 +00:00
|
|
|
struct snd_soc_dai *dai, *_dai;
|
2008-11-30 23:31:24 +00:00
|
|
|
|
2014-03-12 07:34:39 +00:00
|
|
|
list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
|
2014-03-09 16:41:45 +00:00
|
|
|
dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
|
|
|
|
dai->name);
|
2014-03-12 07:34:39 +00:00
|
|
|
list_del(&dai->list);
|
2014-03-09 16:41:45 +00:00
|
|
|
kfree(dai->name);
|
2010-03-17 20:15:21 +00:00
|
|
|
kfree(dai);
|
|
|
|
}
|
2008-11-30 23:31:24 +00:00
|
|
|
}
|
|
|
|
|
2015-12-31 08:40:20 +00: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;
|
|
|
|
|
|
|
|
list_add(&dai->list, &component->dai_list);
|
|
|
|
component->num_dai++;
|
|
|
|
|
|
|
|
dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
|
|
|
|
return dai;
|
|
|
|
}
|
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
/**
|
2014-03-09 16:41:45 +00:00
|
|
|
* snd_soc_register_dais - Register a DAI with the ASoC core
|
2008-11-30 23:31:24 +00:00
|
|
|
*
|
2014-03-05 12:17:46 +00:00
|
|
|
* @component: The component the DAIs are registered for
|
|
|
|
* @dai_drv: DAI driver to use for the DAIs
|
2009-01-01 12:18:17 +00:00
|
|
|
* @count: Number of DAIs
|
2014-03-09 16:41:45 +00:00
|
|
|
* @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
|
|
|
|
* parent's name.
|
2008-11-30 23:31:24 +00:00
|
|
|
*/
|
2014-03-05 12:17:46 +00:00
|
|
|
static int snd_soc_register_dais(struct snd_soc_component *component,
|
2014-06-16 16:13:03 +00:00
|
|
|
struct snd_soc_dai_driver *dai_drv, size_t count,
|
|
|
|
bool legacy_dai_naming)
|
2008-11-30 23:31:24 +00:00
|
|
|
{
|
2014-03-05 12:17:46 +00:00
|
|
|
struct device *dev = component->dev;
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_dai *dai;
|
2014-03-09 16:41:45 +00:00
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2017-02-27 22:30:02 +00:00
|
|
|
dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
|
2008-11-30 23:31:24 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
component->dai_drv = dai_drv;
|
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2015-12-31 08:40:20 +00:00
|
|
|
dai = soc_add_dai(component, dai_drv + i,
|
|
|
|
count == 1 && legacy_dai_naming);
|
2010-11-03 07:04:45 +00:00
|
|
|
if (dai == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
2008-11-30 23:31:24 +00:00
|
|
|
}
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
return 0;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
err:
|
2014-03-09 16:41:45 +00:00
|
|
|
snd_soc_unregister_dais(component);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2008-11-30 23:31:24 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-12-31 08:40:43 +00: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 16:29:19 +00:00
|
|
|
|
2015-12-31 08:40:43 +00: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-11-30 23:31:24 +00:00
|
|
|
}
|
|
|
|
|
2015-12-31 08:40:43 +00:00
|
|
|
lockdep_assert_held(&client_mutex);
|
|
|
|
dai = soc_add_dai(component, dai_drv, false);
|
|
|
|
if (!dai)
|
|
|
|
return -ENOMEM;
|
2008-11-30 23:31:24 +00:00
|
|
|
|
2015-12-31 08:40:43 +00: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-11-30 23:31:24 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2015-12-31 08:40:43 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_dai);
|
2008-11-30 23:31:24 +00:00
|
|
|
|
2014-06-16 16:13:08 +00: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 02:39:03 +00:00
|
|
|
{
|
2014-06-16 16:13:08 +00:00
|
|
|
struct snd_soc_component *component = dapm->component;
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:08 +00:00
|
|
|
component->driver->seq_notifier(component, type, subseq);
|
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:08 +00: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 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:08 +00:00
|
|
|
return component->driver->stream_event(component, event);
|
|
|
|
}
|
2014-04-22 11:23:13 +00:00
|
|
|
|
2014-06-16 16:13:03 +00: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 02:39:03 +00:00
|
|
|
{
|
2014-06-16 16:13:06 +00:00
|
|
|
struct snd_soc_dapm_context *dapm;
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
component->name = fmt_single_name(dev, &component->id);
|
|
|
|
if (!component->name) {
|
|
|
|
dev_err(dev, "ASoC: Failed to allocate name\n");
|
2013-09-05 02:39:03 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
component->dev = dev;
|
|
|
|
component->driver = driver;
|
2014-08-19 13:51:21 +00:00
|
|
|
component->probe = component->driver->probe;
|
|
|
|
component->remove = component->driver->remove;
|
2016-11-30 06:23:13 +00:00
|
|
|
component->suspend = component->driver->suspend;
|
|
|
|
component->resume = component->driver->resume;
|
2016-12-15 08:41:38 +00:00
|
|
|
component->pcm_new = component->driver->pcm_new;
|
2017-02-25 11:23:00 +00:00
|
|
|
component->pcm_free = component->driver->pcm_free;
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2015-07-06 13:38:11 +00:00
|
|
|
dapm = &component->dapm;
|
2014-06-16 16:13:06 +00:00
|
|
|
dapm->dev = dev;
|
|
|
|
dapm->component = component;
|
|
|
|
dapm->bias_level = SND_SOC_BIAS_OFF;
|
2014-08-24 13:36:55 +00:00
|
|
|
dapm->idle_bias_off = true;
|
2014-06-16 16:13:08 +00: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;
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-08-19 13:51:21 +00:00
|
|
|
component->controls = driver->controls;
|
|
|
|
component->num_controls = driver->num_controls;
|
|
|
|
component->dapm_widgets = driver->dapm_widgets;
|
|
|
|
component->num_dapm_widgets = driver->num_dapm_widgets;
|
|
|
|
component->dapm_routes = driver->dapm_routes;
|
|
|
|
component->num_dapm_routes = driver->num_dapm_routes;
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
INIT_LIST_HEAD(&component->dai_list);
|
|
|
|
mutex_init(&component->io_mutex);
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-11-18 18:45:52 +00:00
|
|
|
static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
|
2014-08-19 13:51:28 +00:00
|
|
|
{
|
2014-11-18 18:45:52 +00: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-25 20:41:03 +00:00
|
|
|
#ifdef CONFIG_REGMAP
|
|
|
|
|
2014-11-18 18:45:52 +00: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 13:51:28 +00:00
|
|
|
}
|
2014-11-18 18:45:52 +00: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 13:51:28 +00:00
|
|
|
|
2014-11-25 20:41:03 +00:00
|
|
|
#endif
|
2014-08-19 13:51:28 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
|
|
|
|
{
|
2014-11-18 18:45:52 +00:00
|
|
|
if (!component->write && !component->read) {
|
|
|
|
if (!component->regmap)
|
|
|
|
component->regmap = dev_get_regmap(component->dev, NULL);
|
|
|
|
if (component->regmap)
|
|
|
|
snd_soc_component_setup_regmap(component);
|
|
|
|
}
|
2014-08-19 13:51:28 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
list_add(&component->list, &component_list);
|
2015-05-29 18:06:14 +00:00
|
|
|
INIT_LIST_HEAD(&component->dobj_list);
|
2014-06-16 16:13:03 +00:00
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
static void snd_soc_component_add(struct snd_soc_component *component)
|
|
|
|
{
|
2013-09-05 02:39:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_add_unlocked(component);
|
2013-09-05 02:39:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2014-06-16 16:13:03 +00:00
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
static void snd_soc_component_cleanup(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
snd_soc_unregister_dais(component);
|
|
|
|
kfree(component->name);
|
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00: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 06:31:22 +00:00
|
|
|
struct snd_soc_card *card = component->card;
|
|
|
|
|
|
|
|
if (card)
|
|
|
|
snd_soc_unregister_card(card);
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
list_del(&component->list);
|
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
|
|
|
int snd_soc_register_component(struct device *dev,
|
|
|
|
const struct snd_soc_component_driver *cmpnt_drv,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
int num_dai)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *cmpnt;
|
2014-06-16 16:13:03 +00:00
|
|
|
int ret;
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
|
2013-09-05 02:39:03 +00:00
|
|
|
if (!cmpnt) {
|
|
|
|
dev_err(dev, "ASoC: Failed to allocate memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_free;
|
|
|
|
|
2014-03-05 12:17:48 +00:00
|
|
|
cmpnt->ignore_pmdown_time = true;
|
2014-03-18 08:02:11 +00:00
|
|
|
cmpnt->registered_as_component = true;
|
2014-03-05 12:17:48 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
|
|
|
|
if (ret < 0) {
|
2015-02-24 14:11:26 +00:00
|
|
|
dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
|
2014-06-16 16:13:03 +00:00
|
|
|
goto err_cleanup;
|
|
|
|
}
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_add(cmpnt);
|
2014-04-28 12:30:51 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
return 0;
|
2014-04-28 12:30:51 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
err_cleanup:
|
|
|
|
snd_soc_component_cleanup(cmpnt);
|
|
|
|
err_free:
|
|
|
|
kfree(cmpnt);
|
|
|
|
return ret;
|
2014-04-28 12:30:51 +00:00
|
|
|
}
|
2014-06-16 16:13:03 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_component);
|
2014-04-28 12:30:51 +00:00
|
|
|
|
2013-09-05 02:39:03 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_unregister_component - Unregister a component from the ASoC core
|
|
|
|
*
|
2015-08-25 07:14:48 +00:00
|
|
|
* @dev: The device to unregister
|
2013-09-05 02:39:03 +00:00
|
|
|
*/
|
|
|
|
void snd_soc_unregister_component(struct device *dev)
|
|
|
|
{
|
|
|
|
struct snd_soc_component *cmpnt;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2013-09-05 02:39:03 +00:00
|
|
|
list_for_each_entry(cmpnt, &component_list, list) {
|
2014-03-18 08:02:11 +00:00
|
|
|
if (dev == cmpnt->dev && cmpnt->registered_as_component)
|
2013-09-05 02:39:03 +00:00
|
|
|
goto found;
|
|
|
|
}
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2013-09-05 02:39:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
found:
|
2015-05-29 18:06:14 +00:00
|
|
|
snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
|
2015-03-07 18:34:03 +00:00
|
|
|
snd_soc_component_del_unlocked(cmpnt);
|
|
|
|
mutex_unlock(&client_mutex);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_cleanup(cmpnt);
|
|
|
|
kfree(cmpnt);
|
2013-09-05 02:39:03 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
|
2014-04-22 11:23:13 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
|
2013-09-05 02:39:03 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
return platform->driver->probe(platform);
|
2014-04-22 11:23:13 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
|
2014-04-22 11:23:13 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
platform->driver->remove(platform);
|
2013-09-05 02:39:03 +00:00
|
|
|
}
|
|
|
|
|
2016-12-15 08:41:38 +00:00
|
|
|
static int snd_soc_platform_drv_pcm_new(struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
|
|
|
|
2017-03-08 23:18:54 +00:00
|
|
|
if (platform->driver->pcm_new)
|
|
|
|
return platform->driver->pcm_new(rtd);
|
|
|
|
else
|
|
|
|
return 0;
|
2016-12-15 08:41:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_soc_platform_drv_pcm_free(struct snd_pcm *pcm)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = pcm->private_data;
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
|
|
|
|
2017-03-08 23:18:54 +00:00
|
|
|
if (platform->driver->pcm_free)
|
|
|
|
platform->driver->pcm_free(pcm);
|
2016-12-15 08:41:38 +00:00
|
|
|
}
|
|
|
|
|
2008-12-03 19:40:30 +00:00
|
|
|
/**
|
2013-04-15 17:19:49 +00:00
|
|
|
* snd_soc_add_platform - Add a platform to the ASoC core
|
|
|
|
* @dev: The parent device for the platform
|
|
|
|
* @platform: The platform to add
|
2015-07-15 14:02:39 +00:00
|
|
|
* @platform_drv: The driver for the platform
|
2008-12-03 19:40:30 +00:00
|
|
|
*/
|
2013-04-15 17:19:49 +00:00
|
|
|
int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
|
2013-03-27 11:02:22 +00:00
|
|
|
const struct snd_soc_platform_driver *platform_drv)
|
2008-12-03 19:40:30 +00:00
|
|
|
{
|
2014-03-18 08:02:12 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
ret = snd_soc_component_initialize(&platform->component,
|
|
|
|
&platform_drv->component_driver, dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-12-03 19:40:30 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
platform->dev = dev;
|
|
|
|
platform->driver = platform_drv;
|
2014-08-19 13:51:19 +00:00
|
|
|
|
|
|
|
if (platform_drv->probe)
|
|
|
|
platform->component.probe = snd_soc_platform_drv_probe;
|
|
|
|
if (platform_drv->remove)
|
|
|
|
platform->component.remove = snd_soc_platform_drv_remove;
|
2016-12-15 08:41:38 +00:00
|
|
|
if (platform_drv->pcm_new)
|
|
|
|
platform->component.pcm_new = snd_soc_platform_drv_pcm_new;
|
|
|
|
if (platform_drv->pcm_free)
|
|
|
|
platform->component.pcm_free = snd_soc_platform_drv_pcm_free;
|
2008-12-03 19:40:30 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
platform->component.debugfs_prefix = "platform";
|
|
|
|
#endif
|
2008-12-03 19:40:30 +00:00
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_add_unlocked(&platform->component);
|
2008-12-03 19:40:30 +00:00
|
|
|
list_add(&platform->list, &platform_list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2014-06-16 16:13:02 +00:00
|
|
|
dev_dbg(dev, "ASoC: Registered platform '%s'\n",
|
|
|
|
platform->component.name);
|
2008-12-03 19:40:30 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2013-04-15 17:19:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_platform);
|
2008-12-03 19:40:30 +00:00
|
|
|
|
|
|
|
/**
|
2013-04-15 17:19:49 +00:00
|
|
|
* snd_soc_register_platform - Register a platform with the ASoC core
|
2008-12-03 19:40:30 +00:00
|
|
|
*
|
2015-08-25 07:14:48 +00:00
|
|
|
* @dev: The device for the platform
|
|
|
|
* @platform_drv: The driver for the platform
|
2008-12-03 19:40:30 +00:00
|
|
|
*/
|
2013-04-15 17:19:49 +00:00
|
|
|
int snd_soc_register_platform(struct device *dev,
|
|
|
|
const struct snd_soc_platform_driver *platform_drv)
|
2008-12-03 19:40:30 +00:00
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_platform *platform;
|
2013-04-15 17:19:49 +00:00
|
|
|
int ret;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2013-04-15 17:19:49 +00:00
|
|
|
dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2013-04-15 17:19:49 +00:00
|
|
|
platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
|
|
|
|
if (platform == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = snd_soc_add_platform(dev, platform, platform_drv);
|
|
|
|
if (ret)
|
|
|
|
kfree(platform);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_platform);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_remove_platform - Remove a platform from the ASoC core
|
|
|
|
* @platform: the platform to remove
|
|
|
|
*/
|
|
|
|
void snd_soc_remove_platform(struct snd_soc_platform *platform)
|
|
|
|
{
|
2014-03-18 08:02:12 +00:00
|
|
|
|
2008-12-03 19:40:30 +00:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_del(&platform->list);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_del_unlocked(&platform->component);
|
2008-12-03 19:40:30 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2013-04-15 17:19:49 +00:00
|
|
|
dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
|
2014-06-16 16:13:02 +00:00
|
|
|
platform->component.name);
|
2014-10-07 11:41:23 +00:00
|
|
|
|
|
|
|
snd_soc_component_cleanup(&platform->component);
|
2013-04-15 17:19:49 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
|
|
|
|
|
|
|
|
struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
|
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2013-04-15 17:19:49 +00:00
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
2015-03-07 18:34:03 +00:00
|
|
|
if (dev == platform->dev) {
|
|
|
|
mutex_unlock(&client_mutex);
|
2013-04-15 17:19:49 +00:00
|
|
|
return platform;
|
2015-03-07 18:34:03 +00:00
|
|
|
}
|
2013-04-15 17:19:49 +00:00
|
|
|
}
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2013-04-15 17:19:49 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_platform - Unregister a platform from the ASoC core
|
|
|
|
*
|
2015-08-25 07:14:48 +00:00
|
|
|
* @dev: platform to unregister
|
2013-04-15 17:19:49 +00:00
|
|
|
*/
|
|
|
|
void snd_soc_unregister_platform(struct device *dev)
|
|
|
|
{
|
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
|
|
|
platform = snd_soc_lookup_platform(dev);
|
|
|
|
if (!platform)
|
|
|
|
return;
|
|
|
|
|
|
|
|
snd_soc_remove_platform(platform);
|
2010-03-17 20:15:21 +00:00
|
|
|
kfree(platform);
|
2008-12-03 19:40:30 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
|
|
|
|
|
2009-05-09 15:22:58 +00:00
|
|
|
static u64 codec_format_map[] = {
|
|
|
|
SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
|
|
|
|
SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
|
|
|
|
SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
|
|
|
|
| SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 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 fixup_codec_formats(struct snd_soc_pcm_stream *stream)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
|
|
|
|
if (stream->formats & codec_format_map[i])
|
|
|
|
stream->formats |= codec_format_map[i];
|
|
|
|
}
|
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
return codec->driver->probe(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
codec->driver->remove(codec);
|
|
|
|
}
|
|
|
|
|
2016-11-30 06:23:13 +00:00
|
|
|
static int snd_soc_codec_drv_suspend(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
return codec->driver->suspend(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_soc_codec_drv_resume(struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
return codec->driver->resume(codec);
|
|
|
|
}
|
|
|
|
|
2014-04-22 11:23:13 +00:00
|
|
|
static int snd_soc_codec_drv_write(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int val)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
return codec->driver->write(codec, reg, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_soc_codec_drv_read(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int *val)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
|
|
|
|
|
|
|
|
*val = codec->driver->read(codec, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:05 +00:00
|
|
|
static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
|
|
|
|
|
|
|
|
return codec->driver->set_bias_level(codec, level);
|
|
|
|
}
|
|
|
|
|
2008-12-10 14:32:45 +00:00
|
|
|
/**
|
|
|
|
* snd_soc_register_codec - Register a codec with the ASoC core
|
|
|
|
*
|
2015-08-25 07:14:48 +00:00
|
|
|
* @dev: The parent device for this codec
|
|
|
|
* @codec_drv: Codec driver
|
|
|
|
* @dai_drv: The associated DAI driver
|
|
|
|
* @num_dai: Number of DAIs
|
2008-12-10 14:32:45 +00:00
|
|
|
*/
|
2010-03-17 20:15:21 +00:00
|
|
|
int snd_soc_register_codec(struct device *dev,
|
2010-12-02 16:21:08 +00:00
|
|
|
const struct snd_soc_codec_driver *codec_drv,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
int num_dai)
|
2008-12-10 14:32:45 +00:00
|
|
|
{
|
2015-07-06 13:38:11 +00:00
|
|
|
struct snd_soc_dapm_context *dapm;
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_codec *codec;
|
2014-06-16 16:13:03 +00:00
|
|
|
struct snd_soc_dai *dai;
|
2010-03-17 20:15:21 +00:00
|
|
|
int ret, i;
|
2009-05-09 15:22:58 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
dev_dbg(dev, "codec register %s\n", dev_name(dev));
|
|
|
|
|
|
|
|
codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
|
|
|
|
if (codec == NULL)
|
|
|
|
return -ENOMEM;
|
2008-12-10 14:32:45 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
codec->component.codec = codec;
|
2014-06-16 16:13:06 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
ret = snd_soc_component_initialize(&codec->component,
|
|
|
|
&codec_drv->component_driver, dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_free;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2014-08-19 13:51:19 +00:00
|
|
|
if (codec_drv->probe)
|
|
|
|
codec->component.probe = snd_soc_codec_drv_probe;
|
|
|
|
if (codec_drv->remove)
|
|
|
|
codec->component.remove = snd_soc_codec_drv_remove;
|
2016-11-30 06:23:13 +00:00
|
|
|
if (codec_drv->suspend)
|
|
|
|
codec->component.suspend = snd_soc_codec_drv_suspend;
|
|
|
|
if (codec_drv->resume)
|
|
|
|
codec->component.resume = snd_soc_codec_drv_resume;
|
2014-04-22 11:23:13 +00:00
|
|
|
if (codec_drv->write)
|
|
|
|
codec->component.write = snd_soc_codec_drv_write;
|
|
|
|
if (codec_drv->read)
|
|
|
|
codec->component.read = snd_soc_codec_drv_read;
|
2014-03-05 12:17:48 +00:00
|
|
|
codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
|
2015-07-06 13:38:11 +00:00
|
|
|
|
|
|
|
dapm = snd_soc_codec_get_dapm(codec);
|
|
|
|
dapm->idle_bias_off = codec_drv->idle_bias_off;
|
|
|
|
dapm->suspend_bias_off = codec_drv->suspend_bias_off;
|
2014-06-16 16:13:08 +00:00
|
|
|
if (codec_drv->seq_notifier)
|
2015-07-06 13:38:11 +00:00
|
|
|
dapm->seq_notifier = codec_drv->seq_notifier;
|
2014-06-16 16:13:05 +00:00
|
|
|
if (codec_drv->set_bias_level)
|
2015-07-06 13:38:11 +00:00
|
|
|
dapm->set_bias_level = snd_soc_codec_set_bias_level;
|
2010-11-11 10:04:57 +00:00
|
|
|
codec->dev = dev;
|
|
|
|
codec->driver = codec_drv;
|
2014-04-22 11:23:13 +00:00
|
|
|
codec->component.val_bytes = codec_drv->reg_word_size;
|
2010-11-05 13:53:46 +00:00
|
|
|
|
2014-08-19 13:51:18 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
codec->component.init_debugfs = soc_init_codec_debugfs;
|
|
|
|
codec->component.debugfs_prefix = "codec";
|
|
|
|
#endif
|
|
|
|
|
2014-08-19 13:51:28 +00:00
|
|
|
if (codec_drv->get_regmap)
|
|
|
|
codec->component.regmap = codec_drv->get_regmap(dev);
|
2014-03-26 05:40:23 +00:00
|
|
|
|
2010-03-17 20:15:21 +00:00
|
|
|
for (i = 0; i < num_dai; i++) {
|
|
|
|
fixup_codec_formats(&dai_drv[i].playback);
|
|
|
|
fixup_codec_formats(&dai_drv[i].capture);
|
|
|
|
}
|
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
|
2013-02-25 08:40:40 +00:00
|
|
|
if (ret < 0) {
|
2015-02-24 14:11:26 +00:00
|
|
|
dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
|
2014-06-16 16:13:03 +00:00
|
|
|
goto err_cleanup;
|
2010-08-18 19:20:55 +00:00
|
|
|
}
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
list_for_each_entry(dai, &codec->component.dai_list, list)
|
|
|
|
dai->codec = codec;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2013-03-08 01:42:33 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_add_unlocked(&codec->component);
|
2012-04-09 16:29:19 +00:00
|
|
|
list_add(&codec->list, &codec_list);
|
2013-03-08 01:42:33 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2014-06-16 16:13:02 +00:00
|
|
|
dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
|
|
|
|
codec->component.name);
|
2008-12-10 14:32:45 +00:00
|
|
|
return 0;
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
err_cleanup:
|
|
|
|
snd_soc_component_cleanup(&codec->component);
|
|
|
|
err_free:
|
2010-03-17 20:15:21 +00:00
|
|
|
kfree(codec);
|
|
|
|
return ret;
|
2008-12-10 14:32:45 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_codec);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_codec - Unregister a codec from the ASoC core
|
|
|
|
*
|
2015-08-25 07:14:48 +00:00
|
|
|
* @dev: codec to unregister
|
2008-12-10 14:32:45 +00:00
|
|
|
*/
|
2010-03-17 20:15:21 +00:00
|
|
|
void snd_soc_unregister_codec(struct device *dev)
|
2008-12-10 14:32:45 +00:00
|
|
|
{
|
2010-03-17 20:15:21 +00:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_lock(&client_mutex);
|
2010-03-17 20:15:21 +00:00
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (dev == codec->dev)
|
|
|
|
goto found;
|
|
|
|
}
|
2015-03-07 18:34:03 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
2010-03-17 20:15:21 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
found:
|
2008-12-10 14:32:45 +00:00
|
|
|
list_del(&codec->list);
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_del_unlocked(&codec->component);
|
2008-12-10 14:32:45 +00:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2014-06-16 16:13:02 +00:00
|
|
|
dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
|
|
|
|
codec->component.name);
|
2010-03-17 20:15:21 +00:00
|
|
|
|
2014-06-16 16:13:03 +00:00
|
|
|
snd_soc_component_cleanup(&codec->component);
|
2010-11-11 10:04:57 +00:00
|
|
|
snd_soc_cache_exit(codec);
|
2010-03-17 20:15:21 +00:00
|
|
|
kfree(codec);
|
2008-12-10 14:32:45 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
|
|
|
|
|
2011-12-12 22:55:34 +00:00
|
|
|
/* Retrieve a card's name from device tree */
|
2017-01-27 06:37:51 +00:00
|
|
|
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
|
|
|
|
const char *propname)
|
2011-12-12 22:55:34 +00:00
|
|
|
{
|
2017-01-27 06:37:51 +00:00
|
|
|
struct device_node *np;
|
2011-12-12 22:55:34 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-07-04 08:53:00 +00:00
|
|
|
if (!card->dev) {
|
|
|
|
pr_err("card->dev is not set before calling %s\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-01-27 06:37:51 +00:00
|
|
|
np = card->dev->of_node;
|
2014-07-04 08:53:00 +00:00
|
|
|
|
2011-12-12 22:55:34 +00: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 14:47:09 +00:00
|
|
|
"ASoC: Property '%s' could not be read: %d\n",
|
2011-12-12 22:55:34 +00:00
|
|
|
propname, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 06:37:51 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
|
2011-12-12 22:55:34 +00: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 07:59:52 +00: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 06:37:34 +00: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 07:59:52 +00:00
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 06:37:34 +00: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 07:59:52 +00: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 01:22:49 +00: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 07:59:52 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 06:37:34 +00: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 07:59:52 +00:00
|
|
|
|
2015-09-09 18:27:43 +00:00
|
|
|
static int snd_soc_of_get_slot_mask(struct device_node *np,
|
|
|
|
const char *prop_name,
|
|
|
|
unsigned int *mask)
|
|
|
|
{
|
|
|
|
u32 val;
|
2015-09-17 10:13:38 +00:00
|
|
|
const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
|
2015-09-09 18:27:43 +00: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;
|
|
|
|
}
|
|
|
|
|
2014-02-14 01:34:35 +00:00
|
|
|
int snd_soc_of_parse_tdm_slot(struct device_node *np,
|
2015-09-09 18:27:43 +00:00
|
|
|
unsigned int *tx_mask,
|
|
|
|
unsigned int *rx_mask,
|
2014-02-14 01:34:35 +00:00
|
|
|
unsigned int *slots,
|
|
|
|
unsigned int *slot_width)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
int ret;
|
|
|
|
|
2015-09-09 18:27:43 +00: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 01:34:35 +00: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 06:37:16 +00:00
|
|
|
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
|
2015-07-15 07:07:42 +00:00
|
|
|
struct snd_soc_codec_conf *codec_conf,
|
|
|
|
struct device_node *of_node,
|
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 06:37:16 +00:00
|
|
|
struct device_node *np = card->dev->of_node;
|
2015-07-15 07:07:42 +00: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 06:37:16 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
|
2015-07-15 07:07:42 +00:00
|
|
|
|
2017-01-27 06:36:50 +00:00
|
|
|
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
|
2011-12-12 22:55:35 +00:00
|
|
|
const char *propname)
|
|
|
|
{
|
2017-01-27 06:36:50 +00:00
|
|
|
struct device_node *np = card->dev->of_node;
|
2014-12-18 11:46:38 +00:00
|
|
|
int num_routes;
|
2011-12-12 22:55:35 +00:00
|
|
|
struct snd_soc_dapm_route *routes;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
num_routes = of_property_count_strings(np, propname);
|
2012-04-24 07:24:43 +00:00
|
|
|
if (num_routes < 0 || num_routes & 1) {
|
2013-05-04 20:21:38 +00:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' does not exist or its length is not even\n",
|
|
|
|
propname);
|
2011-12-12 22:55:35 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
num_routes /= 2;
|
|
|
|
if (!num_routes) {
|
2012-11-19 14:47:09 +00:00
|
|
|
dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
|
2011-12-12 22:55:35 +00:00
|
|
|
propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-12-18 11:46:38 +00:00
|
|
|
routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
|
2011-12-12 22:55:35 +00:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!routes) {
|
|
|
|
dev_err(card->dev,
|
2012-11-19 14:47:09 +00:00
|
|
|
"ASoC: Could not allocate DAPM route table\n");
|
2011-12-12 22:55:35 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_routes; i++) {
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
2014-12-18 11:46:38 +00:00
|
|
|
2 * i, &routes[i].sink);
|
2011-12-12 22:55:35 +00:00
|
|
|
if (ret) {
|
2012-12-10 07:19:52 +00:00
|
|
|
dev_err(card->dev,
|
|
|
|
"ASoC: Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, 2 * i, ret);
|
2011-12-12 22:55:35 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
2014-12-18 11:46:38 +00:00
|
|
|
(2 * i) + 1, &routes[i].source);
|
2011-12-12 22:55:35 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
2012-12-10 07:19:52 +00:00
|
|
|
"ASoC: Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, (2 * i) + 1, ret);
|
2011-12-12 22:55:35 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-15 01:22:49 +00:00
|
|
|
card->num_of_dapm_routes = num_routes;
|
|
|
|
card->of_dapm_routes = routes;
|
2011-12-12 22:55:35 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 06:36:50 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
|
2011-12-12 22:55:35 +00:00
|
|
|
|
2013-01-15 02:36:04 +00:00
|
|
|
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
|
2014-03-24 10:15:24 +00:00
|
|
|
const char *prefix,
|
|
|
|
struct device_node **bitclkmaster,
|
|
|
|
struct device_node **framemaster)
|
2013-01-15 02:36:04 +00: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 01:33:24 +00:00
|
|
|
* check "dai-format = xxx"
|
|
|
|
* or "[prefix]format = xxx"
|
2013-01-15 02:36:04 +00:00
|
|
|
* SND_SOC_DAIFMT_FORMAT_MASK area
|
|
|
|
*/
|
2017-04-20 01:33:24 +00: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 02:36:04 +00: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 05:03:36 +00:00
|
|
|
* check "[prefix]continuous-clock"
|
2013-01-15 02:36:04 +00:00
|
|
|
* SND_SOC_DAIFMT_CLOCK_MASK area
|
|
|
|
*/
|
2013-01-30 05:03:36 +00:00
|
|
|
snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
|
2016-08-05 08:56:51 +00:00
|
|
|
if (of_property_read_bool(np, prop))
|
2013-01-30 05:03:36 +00:00
|
|
|
format |= SND_SOC_DAIFMT_CONT;
|
|
|
|
else
|
|
|
|
format |= SND_SOC_DAIFMT_GATED;
|
2013-01-15 02:36:04 +00: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 10:15:24 +00:00
|
|
|
if (bit && bitclkmaster)
|
|
|
|
*bitclkmaster = of_parse_phandle(np, prop, 0);
|
2013-01-15 02:36:04 +00:00
|
|
|
|
|
|
|
snprintf(prop, sizeof(prop), "%sframe-master", prefix);
|
|
|
|
frame = !!of_get_property(np, prop, NULL);
|
2014-03-24 10:15:24 +00:00
|
|
|
if (frame && framemaster)
|
|
|
|
*framemaster = of_parse_phandle(np, prop, 0);
|
2013-01-15 02:36:04 +00: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 01:39:25 +00: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);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);
|
|
|
|
|
2016-11-11 01:19:28 +00:00
|
|
|
int snd_soc_get_dai_name(struct of_phandle_args *args,
|
2014-11-25 12:16:12 +00:00
|
|
|
const char **dai_name)
|
2013-09-11 00:39:56 +00:00
|
|
|
{
|
|
|
|
struct snd_soc_component *pos;
|
2015-05-26 18:59:05 +00:00
|
|
|
struct device_node *component_of_node;
|
2014-11-25 12:16:12 +00:00
|
|
|
int ret = -EPROBE_DEFER;
|
2013-09-11 00:39:56 +00:00
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_for_each_entry(pos, &component_list, list) {
|
2015-05-26 18:59:05 +00: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 00:39:56 +00:00
|
|
|
continue;
|
|
|
|
|
2013-10-17 05:05:26 +00:00
|
|
|
if (pos->driver->of_xlate_dai_name) {
|
2014-11-25 12:16:12 +00:00
|
|
|
ret = pos->driver->of_xlate_dai_name(pos,
|
|
|
|
args,
|
|
|
|
dai_name);
|
2013-10-17 05:05:26 +00:00
|
|
|
} else {
|
|
|
|
int id = -1;
|
|
|
|
|
2014-11-25 12:16:12 +00:00
|
|
|
switch (args->args_count) {
|
2013-10-17 05:05:26 +00:00
|
|
|
case 0:
|
|
|
|
id = 0; /* same as dai_drv[0] */
|
|
|
|
break;
|
|
|
|
case 1:
|
2014-11-25 12:16:12 +00:00
|
|
|
id = args->args[0];
|
2013-10-17 05:05:26 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* not supported */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id < 0 || id >= pos->num_dai) {
|
|
|
|
ret = -EINVAL;
|
2014-04-21 11:14:46 +00:00
|
|
|
continue;
|
2013-10-17 05:05:26 +00:00
|
|
|
}
|
2013-12-20 06:39:51 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
*dai_name = pos->dai_drv[id].name;
|
|
|
|
if (!*dai_name)
|
|
|
|
*dai_name = pos->name;
|
2013-09-11 00:39:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&client_mutex);
|
2014-11-25 12:16:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2016-11-11 01:19:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
|
2014-11-25 12:16:12 +00: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 00:39:56 +00:00
|
|
|
|
|
|
|
of_node_put(args.np);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
|
|
|
|
|
2014-11-25 12:16:12 +00: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.
|
|
|
|
* The device nodes in the array (of_node) must be dereferenced by the caller.
|
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
component = devm_kzalloc(dev,
|
|
|
|
sizeof *component * num_codecs,
|
|
|
|
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:
|
|
|
|
for (index = 0, component = dai_link->codecs;
|
|
|
|
index < dai_link->num_codecs;
|
|
|
|
index++, component++) {
|
|
|
|
if (!component->of_node)
|
|
|
|
break;
|
|
|
|
of_node_put(component->of_node);
|
|
|
|
component->of_node = NULL;
|
|
|
|
}
|
|
|
|
dai_link->codecs = NULL;
|
|
|
|
dai_link->num_codecs = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
|
|
|
|
|
2008-12-10 06:47:22 +00:00
|
|
|
static int __init snd_soc_init(void)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
2015-04-09 08:52:38 +00:00
|
|
|
snd_soc_debugfs_init();
|
2011-04-28 09:57:54 +00:00
|
|
|
snd_soc_util_init();
|
|
|
|
|
2006-10-06 16:31:09 +00:00
|
|
|
return platform_driver_register(&soc_driver);
|
|
|
|
}
|
2010-10-12 16:41:03 +00:00
|
|
|
module_init(snd_soc_init);
|
2006-10-06 16:31:09 +00:00
|
|
|
|
2008-11-30 22:11:24 +00:00
|
|
|
static void __exit snd_soc_exit(void)
|
2006-10-06 16:31:09 +00:00
|
|
|
{
|
2011-04-28 09:57:54 +00:00
|
|
|
snd_soc_util_exit();
|
2015-04-09 08:52:38 +00:00
|
|
|
snd_soc_debugfs_exit();
|
2011-04-28 09:57:54 +00:00
|
|
|
|
2008-05-19 10:32:25 +00:00
|
|
|
platform_driver_unregister(&soc_driver);
|
2006-10-06 16:31:09 +00:00
|
|
|
}
|
|
|
|
module_exit(snd_soc_exit);
|
|
|
|
|
|
|
|
/* Module information */
|
2008-10-12 12:17:36 +00:00
|
|
|
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
|
2006-10-06 16:31:09 +00:00
|
|
|
MODULE_DESCRIPTION("ALSA SoC Core");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-04-14 11:33:36 +00:00
|
|
|
MODULE_ALIAS("platform:soc-audio");
|