2006-10-06 23:31:09 +07:00
|
|
|
/*
|
|
|
|
* soc-core.c -- ALSA SoC Audio Layer
|
|
|
|
*
|
|
|
|
* Copyright 2005 Wolfson Microelectronics PLC.
|
2006-12-18 20:39:02 +07:00
|
|
|
* Copyright 2005 Openedhand Ltd.
|
2010-03-18 03:15:21 +07:00
|
|
|
* Copyright (C) 2010 Slimlogic Ltd.
|
|
|
|
* Copyright (C) 2010 Texas Instruments Inc.
|
2006-12-18 20:39:02 +07:00
|
|
|
*
|
2008-10-12 19:17:36 +07:00
|
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
2006-12-18 20:39:02 +07:00
|
|
|
* with code, comments and ideas from :-
|
|
|
|
* Richard Purdie <richard@openedhand.com>
|
2006-10-06 23:31:09 +07: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 07:42:14 +07:00
|
|
|
#include <linux/debugfs.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <linux/platform_device.h>
|
2011-09-20 17:41:54 +07:00
|
|
|
#include <linux/ctype.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2011-12-13 05:55:34 +07:00
|
|
|
#include <linux/of.h>
|
2009-07-22 18:01:03 +07:00
|
|
|
#include <sound/ac97_codec.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/core.h>
|
2010-12-05 19:22:46 +07:00
|
|
|
#include <sound/jack.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/soc.h>
|
ASoC: dpcm: Add Dynamic PCM core operations.
The Dynamic PCM core allows digital audio data to be dynamically
routed between different ALSA PCMs and DAI links on SoC CPUs with
on chip DSP devices. e.g. audio data could be played on pcm:0,0 and
routed to any (or all) SoC DAI links.
Dynamic PCM introduces the concept of Front End (FE) PCMs and Back
End (BE) PCMs. The FE PCMs are normal ALSA PCM devices except that
they can dynamically route digital audio data to any supported BE
PCM. A BE PCM has no ALSA device, but represents a DAI link and it's
substream and audio HW parameters.
e.g. pcm:0,0 routing digital data to 2 external codecs.
FE pcm:0,0 ----> BE (McBSP.0) ----> CODEC 0
+--> BE (McPDM.0) ----> CODEC 1
e.g. pcm:0,0 and pcm:0,1 routing digital data to 1 external codec.
FE pcm:0,0 ---
+--> BE (McBSP.0) ----> CODEC
FE pcm:0,1 ---
The digital audio routing is controlled by the usual ALSA method
of mixer kcontrols. Dynamic PCM uses a DAPM graph to work out the
routing based upon the mixer settings and configures the BE PCMs
based on routing and the FE HW params.
DPCM is designed so that most ASoC component drivers will need no
modification at all. It's intended that existing CODEC, DAI and
platform drivers can be used in DPCM based audio devices without
any changes. However, there will be some cases where minor changes
are required (e.g. for very tightly coupled HW) and there are
helpers to support this too.
Somethimes the HW params of a FE and BE do not match or are
incompatible, so in these cases the machine driver can reconfigure
any hw_params and make any DSP perform sample rate / format conversion.
This patch adds the core DPCM code and contains :-
o The FE and BE PCM operations.
o FE and BE DAI link support.
o FE and BE PCM creation.
o BE support API.
o BE and FE link management.
Signed-off-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-04-25 18:12:49 +07:00
|
|
|
#include <sound/soc-dpcm.h>
|
2006-10-06 23:31:09 +07:00
|
|
|
#include <sound/initval.h>
|
|
|
|
|
2010-11-04 05:05:58 +07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/asoc.h>
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
#define NAME_SIZE 32
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
|
|
|
|
|
2008-12-04 00:34:03 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-11 05:25:21 +07:00
|
|
|
struct dentry *snd_soc_debugfs_root;
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
|
2008-12-04 00:34:03 +07:00
|
|
|
#endif
|
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
static DEFINE_MUTEX(client_mutex);
|
2008-12-01 06:31:24 +07:00
|
|
|
static LIST_HEAD(dai_list);
|
2008-12-04 02:40:30 +07:00
|
|
|
static LIST_HEAD(platform_list);
|
2008-12-10 21:32:45 +07:00
|
|
|
static LIST_HEAD(codec_list);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/*
|
|
|
|
* This is a timeout to do a DAPM powerdown after a stream is closed().
|
|
|
|
* It can be used to eliminate pops between different playback streams, e.g.
|
|
|
|
* between two audio tracks.
|
|
|
|
*/
|
|
|
|
static int pmdown_time = 5000;
|
|
|
|
module_param(pmdown_time, int, 0);
|
|
|
|
MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
|
|
|
|
|
2011-02-01 19:24:08 +07: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 20:58:58 +07: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-02 03:50:44 +07:00
|
|
|
int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
|
|
|
|
int regsize = codec->driver->reg_word_size * 2;
|
2011-02-02 20:58:58 +07:00
|
|
|
int ret;
|
|
|
|
char tmpbuf[len + 1];
|
|
|
|
char regbuf[regsize + 1];
|
|
|
|
|
|
|
|
/* since tmpbuf is allocated on the stack, warn the callers if they
|
|
|
|
* try to abuse this function */
|
|
|
|
WARN_ON(len > 63);
|
|
|
|
|
|
|
|
/* +2 for ': ' and + 1 for '\n' */
|
|
|
|
if (wordsize + regsize + 2 + 1 != len)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-08-01 11:52:48 +07:00
|
|
|
ret = snd_soc_read(codec, reg);
|
2011-02-02 20:58:58 +07:00
|
|
|
if (ret < 0) {
|
|
|
|
memset(regbuf, 'X', regsize);
|
|
|
|
regbuf[regsize] = '\0';
|
|
|
|
} else {
|
|
|
|
snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* prepare the buffer */
|
|
|
|
snprintf(tmpbuf, len + 1, "%.*x: %s\n", wordsize, reg, regbuf);
|
|
|
|
/* copy it back to the caller without the '\0' */
|
|
|
|
memcpy(buf, tmpbuf, len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
/* codec register dump */
|
2011-02-02 20:58:58 +07:00
|
|
|
static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
|
|
|
|
size_t count, loff_t pos)
|
2009-11-04 04:56:13 +07:00
|
|
|
{
|
2011-02-02 20:58:58 +07:00
|
|
|
int i, step = 1;
|
2011-02-01 19:24:08 +07:00
|
|
|
int wordsize, regsize;
|
2011-02-02 20:58:58 +07:00
|
|
|
int len;
|
|
|
|
size_t total = 0;
|
|
|
|
loff_t p = 0;
|
2011-02-01 19:24:08 +07:00
|
|
|
|
2011-04-02 03:50:44 +07:00
|
|
|
wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
|
|
|
|
regsize = codec->driver->reg_word_size * 2;
|
2009-11-04 04:56:13 +07:00
|
|
|
|
2011-02-02 20:58:58 +07:00
|
|
|
len = wordsize + regsize + 2 + 1;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (!codec->driver->reg_cache_size)
|
2009-11-04 04:56:13 +07:00
|
|
|
return 0;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (codec->driver->reg_cache_step)
|
|
|
|
step = codec->driver->reg_cache_step;
|
2009-11-04 04:56:13 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < codec->driver->reg_cache_size; i += step) {
|
2011-08-27 23:24:14 +07:00
|
|
|
if (!snd_soc_codec_readable_register(codec, i))
|
2009-11-04 04:56:13 +07:00
|
|
|
continue;
|
2010-03-18 03:15:21 +07:00
|
|
|
if (codec->driver->display_register) {
|
|
|
|
count += codec->driver->display_register(codec, buf + count,
|
2009-11-04 04:56:13 +07:00
|
|
|
PAGE_SIZE - count, i);
|
2010-07-14 22:14:33 +07:00
|
|
|
} else {
|
2011-02-02 20:58:58 +07: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;
|
|
|
|
}
|
|
|
|
p += len;
|
2010-07-14 22:14:33 +07:00
|
|
|
}
|
2009-11-04 04:56:13 +07:00
|
|
|
}
|
|
|
|
|
2011-02-02 20:58:58 +07:00
|
|
|
total = min(total, count - 1);
|
2009-11-04 04:56:13 +07:00
|
|
|
|
2011-02-02 20:58:58 +07:00
|
|
|
return total;
|
2009-11-04 04:56:13 +07:00
|
|
|
}
|
2011-02-02 20:58:58 +07:00
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
static ssize_t codec_reg_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-01-07 08:12:45 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-02-02 20:58:58 +07:00
|
|
|
return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
|
2009-11-04 04:56:13 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
|
|
|
|
|
2010-02-12 18:37:24 +07:00
|
|
|
static ssize_t pmdown_time_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-01-07 08:12:45 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
return sprintf(buf, "%ld\n", rtd->pmdown_time);
|
2010-02-12 18:37:24 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t pmdown_time_set(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2012-01-07 08:12:45 +07:00
|
|
|
struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
|
2010-10-28 10:11:17 +07:00
|
|
|
int ret;
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2010-10-28 10:11:17 +07:00
|
|
|
ret = strict_strtol(buf, 10, &rtd->pmdown_time);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-02-12 18:37:24 +07:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
|
2011-02-02 20:58:58 +07:00
|
|
|
size_t count, loff_t *ppos)
|
2009-11-04 04:56:13 +07:00
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
struct snd_soc_codec *codec = file->private_data;
|
2011-02-02 20:58:58 +07:00
|
|
|
char *buf;
|
|
|
|
|
|
|
|
if (*ppos < 0 || !count)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
buf = kmalloc(count, GFP_KERNEL);
|
2009-11-04 04:56:13 +07:00
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
2011-02-02 20:58:58 +07: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-04 04:56:13 +07: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-13 06:50:10 +07:00
|
|
|
size_t buf_size;
|
2009-11-04 04:56:13 +07:00
|
|
|
char *start = buf;
|
|
|
|
unsigned long reg, value;
|
|
|
|
struct snd_soc_codec *codec = file->private_data;
|
|
|
|
|
|
|
|
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++;
|
|
|
|
if (strict_strtoul(start, 16, &value))
|
|
|
|
return -EINVAL;
|
2011-01-06 23:04:57 +07:00
|
|
|
|
|
|
|
/* Userspace has been fiddling around behind the kernel's back */
|
|
|
|
add_taint(TAINT_USER);
|
|
|
|
|
2010-12-07 23:30:38 +07:00
|
|
|
snd_soc_write(codec, reg, value);
|
2009-11-04 04:56:13 +07:00
|
|
|
return buf_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations codec_reg_fops = {
|
2012-04-06 04:25:11 +07:00
|
|
|
.open = simple_open,
|
2009-11-04 04:56:13 +07: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 23:52:59 +07:00
|
|
|
.llseek = default_llseek,
|
2009-11-04 04:56:13 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
|
|
|
|
{
|
2010-11-06 01:35:20 +07:00
|
|
|
struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
|
|
|
|
|
|
|
|
codec->debugfs_codec_root = debugfs_create_dir(codec->name,
|
|
|
|
debugfs_card_root);
|
2009-11-04 04:56:13 +07:00
|
|
|
if (!codec->debugfs_codec_root) {
|
2012-02-15 22:15:37 +07:00
|
|
|
dev_warn(codec->dev, "Failed to create codec debugfs directory\n");
|
2009-11-04 04:56:13 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-01-27 03:53:50 +07:00
|
|
|
debugfs_create_bool("cache_sync", 0444, codec->debugfs_codec_root,
|
|
|
|
&codec->cache_sync);
|
|
|
|
debugfs_create_bool("cache_only", 0444, codec->debugfs_codec_root,
|
|
|
|
&codec->cache_only);
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
|
|
|
|
codec->debugfs_codec_root,
|
|
|
|
codec, &codec_reg_fops);
|
|
|
|
if (!codec->debugfs_reg)
|
2012-02-15 22:15:37 +07:00
|
|
|
dev_warn(codec->dev, "Failed to create codec register debugfs file\n");
|
2009-11-04 04:56:13 +07:00
|
|
|
|
2011-05-01 00:45:48 +07:00
|
|
|
snd_soc_dapm_debugfs_init(&codec->dapm, codec->debugfs_codec_root);
|
2009-11-04 04:56:13 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(codec->debugfs_codec_root);
|
|
|
|
}
|
|
|
|
|
2012-02-15 22:25:31 +07:00
|
|
|
static void soc_init_platform_debugfs(struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
struct dentry *debugfs_card_root = platform->card->debugfs_card_root;
|
|
|
|
|
|
|
|
platform->debugfs_platform_root = debugfs_create_dir(platform->name,
|
|
|
|
debugfs_card_root);
|
|
|
|
if (!platform->debugfs_platform_root) {
|
|
|
|
dev_warn(platform->dev,
|
|
|
|
"Failed to create platform debugfs directory\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
snd_soc_dapm_debugfs_init(&platform->dapm,
|
|
|
|
platform->debugfs_platform_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_cleanup_platform_debugfs(struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(platform->debugfs_platform_root);
|
|
|
|
}
|
|
|
|
|
2010-09-16 00:15:14 +07: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 16:52:16 +07:00
|
|
|
ssize_t len, ret = 0;
|
2010-09-16 00:15:14 +07:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-10-13 16:52:16 +07:00
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
|
|
|
|
codec->name);
|
|
|
|
if (len >= 0)
|
|
|
|
ret += len;
|
|
|
|
if (ret > PAGE_SIZE) {
|
|
|
|
ret = PAGE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-09-16 00:15:14 +07: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-16 00:19:07 +07: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 16:52:16 +07:00
|
|
|
ssize_t len, ret = 0;
|
2010-09-16 00:19:07 +07:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-10-13 16:52:16 +07:00
|
|
|
list_for_each_entry(dai, &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-09-16 00:19:07 +07:00
|
|
|
|
2010-10-13 16:52:16 +07:00
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
2010-09-16 00:19:07 +07: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-16 00:22:40 +07: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 16:52:16 +07:00
|
|
|
ssize_t len, ret = 0;
|
2010-09-16 00:22:40 +07:00
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-10-13 16:52:16 +07:00
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
|
|
|
len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
|
|
|
|
platform->name);
|
|
|
|
if (len >= 0)
|
|
|
|
ret += len;
|
|
|
|
if (ret > PAGE_SIZE) {
|
|
|
|
ret = PAGE_SIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-09-16 00:22:40 +07:00
|
|
|
|
2010-10-13 16:52:16 +07:00
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
2010-09-16 00:22:40 +07: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-06 01:35:19 +07:00
|
|
|
static void soc_init_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
card->debugfs_card_root = debugfs_create_dir(card->name,
|
2011-01-11 05:25:21 +07:00
|
|
|
snd_soc_debugfs_root);
|
2010-11-06 01:35:21 +07:00
|
|
|
if (!card->debugfs_card_root) {
|
2010-11-06 01:35:19 +07:00
|
|
|
dev_warn(card->dev,
|
2011-12-09 20:16:29 +07:00
|
|
|
"ASoC: Failed to create card debugfs directory\n");
|
2010-11-06 01:35:21 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
|
|
|
|
card->debugfs_card_root,
|
|
|
|
&card->pop_time);
|
|
|
|
if (!card->debugfs_pop_time)
|
|
|
|
dev_warn(card->dev,
|
|
|
|
"Failed to create pop time debugfs file\n");
|
2010-11-06 01:35:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
debugfs_remove_recursive(card->debugfs_card_root);
|
|
|
|
}
|
|
|
|
|
2009-11-04 04:56:13 +07:00
|
|
|
#else
|
|
|
|
|
|
|
|
static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
}
|
2010-11-09 16:06:44 +07:00
|
|
|
|
2012-02-15 22:25:31 +07:00
|
|
|
static inline void soc_init_platform_debugfs(struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void soc_cleanup_platform_debugfs(struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-11-09 16:06:44 +07:00
|
|
|
static inline void soc_init_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
}
|
2009-11-04 04:56:13 +07:00
|
|
|
#endif
|
|
|
|
|
2012-04-25 18:12:53 +07:00
|
|
|
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
|
|
|
|
const char *dai_link, int stream)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
if (card->rtd[i].dai_link->no_pcm &&
|
|
|
|
!strcmp(card->rtd[i].dai_link->name, dai_link))
|
|
|
|
return card->rtd[i].pcm->streams[stream].substream;
|
|
|
|
}
|
|
|
|
dev_dbg(card->dev, "failed to find dai link %s\n", dai_link);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
|
|
|
|
|
|
|
|
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
const char *dai_link)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
if (!strcmp(card->rtd[i].dai_link->name, dai_link))
|
|
|
|
return &card->rtd[i];
|
|
|
|
}
|
|
|
|
dev_dbg(card->dev, "failed to find rtd %s\n", dai_link);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
|
|
|
/* unregister ac97 codec */
|
|
|
|
static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
if (codec->ac97->dev.bus)
|
|
|
|
device_unregister(&codec->ac97->dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* stop no dev release warning */
|
|
|
|
static void soc_ac97_device_release(struct device *dev){}
|
|
|
|
|
|
|
|
/* register ac97 codec to bus */
|
|
|
|
static int soc_ac97_dev_register(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
codec->ac97->dev.bus = &ac97_bus_type;
|
2009-04-02 01:35:01 +07:00
|
|
|
codec->ac97->dev.parent = codec->card->dev;
|
2006-10-06 23:31:09 +07:00
|
|
|
codec->ac97->dev.release = soc_ac97_device_release;
|
|
|
|
|
2008-11-02 09:50:35 +07:00
|
|
|
dev_set_name(&codec->ac97->dev, "%d-%d:%s",
|
2010-03-18 03:15:21 +07:00
|
|
|
codec->card->snd_card->number, 0, codec->name);
|
2006-10-06 23:31:09 +07:00
|
|
|
err = device_register(&codec->ac97->dev);
|
|
|
|
if (err < 0) {
|
|
|
|
snd_printk(KERN_ERR "Can't register ac97 bus\n");
|
|
|
|
codec->ac97->dev.bus = NULL;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2006-10-06 23:31:09 +07:00
|
|
|
/* powers down audio subsystem for suspend */
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_suspend(struct device *dev)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2010-11-25 22:47:38 +07:00
|
|
|
struct snd_soc_codec *codec;
|
2006-10-06 23:31:09 +07:00
|
|
|
int i;
|
|
|
|
|
2009-06-03 22:44:49 +07:00
|
|
|
/* If the initialization of this soc device failed, there is no codec
|
|
|
|
* associated with it. Just bail out in this case.
|
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
if (list_empty(&card->codec_dev_list))
|
2009-06-03 22:44:49 +07:00
|
|
|
return 0;
|
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* Due to the resume being scheduled into a workqueue we could
|
|
|
|
* suspend before that's finished - wait for it to complete.
|
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_lock(card->snd_card);
|
|
|
|
snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
|
|
|
|
snd_power_unlock(card->snd_card);
|
2008-06-13 22:24:05 +07:00
|
|
|
|
|
|
|
/* we're going to block userspace touching us until resume completes */
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2010-12-02 23:24:24 +07:00
|
|
|
/* mute any active DACs */
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *dai = card->rtd[i].codec_dai;
|
|
|
|
struct snd_soc_dai_driver *drv = dai->driver;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (drv->ops->digital_mute && dai->playback_active)
|
|
|
|
drv->ops->digital_mute(dai, 1);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-01-10 20:39:01 +07:00
|
|
|
/* suspend all pcms */
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_pcm_suspend_all(card->rtd[i].pcm);
|
2010-05-09 19:25:43 +07:00
|
|
|
}
|
2008-01-10 20:39:01 +07:00
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->suspend_pre)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->suspend_pre(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
|
|
|
struct snd_soc_platform *platform = card->rtd[i].platform;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
|
|
|
|
cpu_dai->driver->suspend(cpu_dai);
|
|
|
|
if (platform->driver->suspend && !platform->suspended) {
|
|
|
|
platform->driver->suspend(cpu_dai);
|
|
|
|
platform->suspended = 1;
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* close any waiting streams and save state */
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_delayed_work(&card->rtd[i].delayed_work);
|
2010-11-05 20:53:46 +07:00
|
|
|
card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2012-02-17 06:03:27 +07:00
|
|
|
snd_soc_dapm_stream_event(&card->rtd[i],
|
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-02-17 06:03:27 +07:00
|
|
|
snd_soc_dapm_stream_event(&card->rtd[i],
|
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
|
|
|
SND_SOC_DAPM_STREAM_SUSPEND);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2012-09-01 07:38:32 +07:00
|
|
|
/* Recheck all analogue paths too */
|
|
|
|
dapm_mark_io_dirty(&card->dapm);
|
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* suspend all CODECs */
|
2010-11-25 22:47:38 +07:00
|
|
|
list_for_each_entry(codec, &card->codec_dev_list, card_list) {
|
2010-03-18 03:15:21 +07:00
|
|
|
/* If there are paths active then the CODEC will be held with
|
|
|
|
* bias _ON and should not be suspended. */
|
|
|
|
if (!codec->suspended && codec->driver->suspend) {
|
2010-11-05 20:53:46 +07:00
|
|
|
switch (codec->dapm.bias_level) {
|
2010-03-18 03:15:21 +07:00
|
|
|
case SND_SOC_BIAS_STANDBY:
|
2012-01-31 22:49:10 +07:00
|
|
|
/*
|
|
|
|
* If the CODEC is capable of idle
|
|
|
|
* bias off then being in STANDBY
|
|
|
|
* means it's doing something,
|
|
|
|
* otherwise fall through.
|
|
|
|
*/
|
|
|
|
if (codec->dapm.idle_bias_off) {
|
|
|
|
dev_dbg(codec->dev,
|
|
|
|
"idle_bias_off CODEC on over suspend\n");
|
|
|
|
break;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
case SND_SOC_BIAS_OFF:
|
2011-12-02 16:18:28 +07:00
|
|
|
codec->driver->suspend(codec);
|
2010-03-18 03:15:21 +07:00
|
|
|
codec->suspended = 1;
|
2011-07-18 11:17:13 +07:00
|
|
|
codec->cache_sync = 1;
|
2012-09-12 11:21:52 +07:00
|
|
|
if (codec->using_regmap)
|
|
|
|
regcache_mark_dirty(codec->control_data);
|
2010-03-18 03:15:21 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_dbg(codec->dev, "CODEC is on over suspend\n");
|
|
|
|
break;
|
|
|
|
}
|
2010-05-08 03:11:40 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
|
|
|
|
cpu_dai->driver->suspend(cpu_dai);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->suspend_post)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->suspend_post(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_suspend);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* deferred resume work, so resume can complete before we finished
|
|
|
|
* setting our codec back up, which can be very slow on I2C
|
|
|
|
*/
|
|
|
|
static void soc_resume_deferred(struct work_struct *work)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_card *card =
|
|
|
|
container_of(work, struct snd_soc_card, deferred_resume_work);
|
2010-11-25 22:47:38 +07:00
|
|
|
struct snd_soc_codec *codec;
|
2006-10-06 23:31:09 +07:00
|
|
|
int i;
|
|
|
|
|
2008-06-13 22:24:05 +07:00
|
|
|
/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
|
|
|
|
* so userspace apps are blocked from touching us
|
|
|
|
*/
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
dev_dbg(card->dev, "starting resume work\n");
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2010-05-08 02:24:05 +07:00
|
|
|
/* Bring us up into D2 so that DAPM starts enabling things */
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
|
2010-05-08 02:24:05 +07:00
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->resume_pre)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->resume_pre(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* resume AC97 DAIs */
|
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
|
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
|
|
|
}
|
|
|
|
|
2010-11-25 22:47:38 +07:00
|
|
|
list_for_each_entry(codec, &card->codec_dev_list, card_list) {
|
2010-03-18 03:15:21 +07:00
|
|
|
/* If the CODEC was idle over suspend then it will have been
|
|
|
|
* left with bias OFF or STANDBY and suspended so we must now
|
|
|
|
* resume. Otherwise the suspend was suppressed.
|
|
|
|
*/
|
|
|
|
if (codec->driver->resume && codec->suspended) {
|
2010-11-05 20:53:46 +07:00
|
|
|
switch (codec->dapm.bias_level) {
|
2010-03-18 03:15:21 +07:00
|
|
|
case SND_SOC_BIAS_STANDBY:
|
|
|
|
case SND_SOC_BIAS_OFF:
|
|
|
|
codec->driver->resume(codec);
|
|
|
|
codec->suspended = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_dbg(codec->dev, "CODEC was on over suspend\n");
|
|
|
|
break;
|
|
|
|
}
|
2010-05-08 03:11:40 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2012-02-17 06:03:27 +07:00
|
|
|
snd_soc_dapm_stream_event(&card->rtd[i],
|
2012-03-07 23:32:59 +07:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
2012-02-17 06:03:27 +07:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-02-17 06:03:27 +07:00
|
|
|
snd_soc_dapm_stream_event(&card->rtd[i],
|
2012-03-07 23:32:59 +07:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
2012-02-17 06:03:27 +07:00
|
|
|
SND_SOC_DAPM_STREAM_RESUME);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-05-19 17:32:25 +07:00
|
|
|
/* unmute any active DACs */
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *dai = card->rtd[i].codec_dai;
|
|
|
|
struct snd_soc_dai_driver *drv = dai->driver;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (drv->ops->digital_mute && dai->playback_active)
|
|
|
|
drv->ops->digital_mute(dai, 0);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
|
|
|
struct snd_soc_platform *platform = card->rtd[i].platform;
|
2010-05-09 19:25:43 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd[i].dai_link->ignore_suspend)
|
2010-05-09 19:25:43 +07:00
|
|
|
continue;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
|
|
|
|
cpu_dai->driver->resume(cpu_dai);
|
|
|
|
if (platform->driver->resume && platform->suspended) {
|
|
|
|
platform->driver->resume(cpu_dai);
|
|
|
|
platform->suspended = 0;
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->resume_post)
|
2011-01-26 21:05:25 +07:00
|
|
|
card->resume_post(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
dev_dbg(card->dev, "resume work completed\n");
|
2008-06-13 22:24:05 +07:00
|
|
|
|
|
|
|
/* userspace can access us now we are back as we were before */
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
|
2012-09-01 07:38:32 +07:00
|
|
|
|
|
|
|
/* Recheck all analogue paths too */
|
|
|
|
dapm_mark_io_dirty(&card->dapm);
|
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2008-06-13 22:24:05 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* powers up audio subsystem after a suspend */
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_resume(struct device *dev)
|
2008-06-13 22:24:05 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2011-05-26 03:06:41 +07:00
|
|
|
int i, ac97_control = 0;
|
2010-02-22 18:27:13 +07:00
|
|
|
|
2011-11-23 21:37:00 +07:00
|
|
|
/* If the initialization of this soc device failed, there is no codec
|
|
|
|
* associated with it. Just bail out in this case.
|
|
|
|
*/
|
|
|
|
if (list_empty(&card->codec_dev_list))
|
|
|
|
return 0;
|
|
|
|
|
2009-03-31 17:27:03 +07:00
|
|
|
/* AC97 devices 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
|
|
|
|
* due to I/O costs and anti-pop so handle them out of line.
|
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
2011-05-26 03:06:41 +07:00
|
|
|
ac97_control |= cpu_dai->driver->ac97_control;
|
|
|
|
}
|
|
|
|
if (ac97_control) {
|
|
|
|
dev_dbg(dev, "Resuming AC97 immediately\n");
|
|
|
|
soc_resume_deferred(&card->deferred_resume_work);
|
|
|
|
} else {
|
|
|
|
dev_dbg(dev, "Scheduling resume work\n");
|
|
|
|
if (!schedule_work(&card->deferred_resume_work))
|
|
|
|
dev_err(dev, "resume work item may be lost\n");
|
2009-03-31 17:27:03 +07:00
|
|
|
}
|
2008-06-13 22:24:05 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_resume);
|
2006-10-06 23:31:09 +07:00
|
|
|
#else
|
2011-01-26 21:59:27 +07:00
|
|
|
#define snd_soc_suspend NULL
|
|
|
|
#define snd_soc_resume NULL
|
2006-10-06 23:31:09 +07:00
|
|
|
#endif
|
|
|
|
|
2011-11-23 17:40:40 +07:00
|
|
|
static const struct snd_soc_dai_ops null_dai_ops = {
|
2009-10-16 17:13:38 +07:00
|
|
|
};
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
static int soc_bind_dai_link(struct snd_soc_card *card, int num)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai_link *dai_link = &card->dai_link[num];
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
|
2009-11-04 05:13:13 +07:00
|
|
|
struct snd_soc_codec *codec;
|
2008-12-04 22:32:53 +07:00
|
|
|
struct snd_soc_platform *platform;
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai *codec_dai, *cpu_dai;
|
2011-04-28 00:16:32 +07:00
|
|
|
const char *platform_name;
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
/* Find CPU DAI from registered DAIs*/
|
2010-03-18 03:15:21 +07:00
|
|
|
list_for_each_entry(cpu_dai, &dai_list, list) {
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 07:22:11 +07:00
|
|
|
if (dai_link->cpu_of_node &&
|
|
|
|
(cpu_dai->dev->of_node != dai_link->cpu_of_node))
|
|
|
|
continue;
|
|
|
|
if (dai_link->cpu_name &&
|
|
|
|
strcmp(dev_name(cpu_dai->dev), dai_link->cpu_name))
|
|
|
|
continue;
|
|
|
|
if (dai_link->cpu_dai_name &&
|
|
|
|
strcmp(cpu_dai->name, dai_link->cpu_dai_name))
|
|
|
|
continue;
|
2011-12-08 03:58:27 +07:00
|
|
|
|
|
|
|
rtd->cpu_dai = cpu_dai;
|
2008-12-04 22:32:53 +07:00
|
|
|
}
|
2008-12-02 22:08:03 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
if (!rtd->cpu_dai) {
|
2012-08-10 00:44:37 +07:00
|
|
|
dev_err(card->dev, "CPU DAI %s not registered\n",
|
2012-03-15 04:18:39 +07:00
|
|
|
dai_link->cpu_dai_name);
|
|
|
|
return -EPROBE_DEFER;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
/* Find CODEC from registered CODECs */
|
2010-03-18 03:15:21 +07:00
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
2011-12-22 00:40:59 +07:00
|
|
|
if (dai_link->codec_of_node) {
|
|
|
|
if (codec->dev->of_node != dai_link->codec_of_node)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if (strcmp(codec->name, dai_link->codec_name))
|
|
|
|
continue;
|
|
|
|
}
|
2011-12-08 03:58:27 +07:00
|
|
|
|
|
|
|
rtd->codec = codec;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CODEC found, so find CODEC DAI from registered DAIs from
|
|
|
|
* this CODEC
|
|
|
|
*/
|
|
|
|
list_for_each_entry(codec_dai, &dai_list, list) {
|
|
|
|
if (codec->dev == codec_dai->dev &&
|
|
|
|
!strcmp(codec_dai->name,
|
|
|
|
dai_link->codec_dai_name)) {
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-12-08 03:58:27 +07:00
|
|
|
rtd->codec_dai = codec_dai;
|
|
|
|
}
|
2008-12-04 22:32:53 +07:00
|
|
|
}
|
2011-12-08 03:58:27 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
if (!rtd->codec_dai) {
|
2012-08-10 00:44:37 +07:00
|
|
|
dev_err(card->dev, "CODEC DAI %s not registered\n",
|
2012-03-15 04:18:39 +07:00
|
|
|
dai_link->codec_dai_name);
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2008-12-09 02:26:48 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
if (!rtd->codec) {
|
2012-08-10 00:44:37 +07:00
|
|
|
dev_err(card->dev, "CODEC %s not registered\n",
|
2012-03-15 04:18:39 +07:00
|
|
|
dai_link->codec_name);
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
2011-04-28 00:16:32 +07:00
|
|
|
|
|
|
|
/* if there's no platform we match on the empty platform */
|
|
|
|
platform_name = dai_link->platform_name;
|
2011-12-22 00:40:59 +07:00
|
|
|
if (!platform_name && !dai_link->platform_of_node)
|
2011-04-28 00:16:32 +07:00
|
|
|
platform_name = "snd-soc-dummy";
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
/* find one from the set of registered platforms */
|
2010-03-18 03:15:21 +07:00
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
2011-12-22 00:40:59 +07:00
|
|
|
if (dai_link->platform_of_node) {
|
|
|
|
if (platform->dev->of_node !=
|
|
|
|
dai_link->platform_of_node)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if (strcmp(platform->name, platform_name))
|
|
|
|
continue;
|
|
|
|
}
|
2011-12-08 03:58:27 +07:00
|
|
|
|
|
|
|
rtd->platform = platform;
|
2009-10-16 17:13:38 +07:00
|
|
|
}
|
2012-03-15 04:18:39 +07:00
|
|
|
if (!rtd->platform) {
|
2012-08-10 00:44:37 +07:00
|
|
|
dev_err(card->dev, "platform %s not registered\n",
|
2010-03-18 03:15:21 +07:00
|
|
|
dai_link->platform_name);
|
2012-03-15 04:18:39 +07:00
|
|
|
return -EPROBE_DEFER;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2012-03-15 04:18:39 +07:00
|
|
|
|
|
|
|
card->num_rtd++;
|
|
|
|
|
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
2012-06-09 01:34:22 +07:00
|
|
|
static int soc_remove_platform(struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (platform->driver->remove) {
|
|
|
|
ret = platform->driver->remove(platform);
|
|
|
|
if (ret < 0)
|
|
|
|
pr_err("asoc: failed to remove %s: %d\n",
|
|
|
|
platform->name, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure all DAPM widgets are freed */
|
|
|
|
snd_soc_dapm_free(&platform->dapm);
|
|
|
|
|
|
|
|
soc_cleanup_platform_debugfs(platform);
|
|
|
|
platform->probed = 0;
|
|
|
|
list_del(&platform->card_list);
|
|
|
|
module_put(platform->dev->driver->owner);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
static void soc_remove_codec(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (codec->driver->remove) {
|
|
|
|
err = codec->driver->remove(codec);
|
|
|
|
if (err < 0)
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"asoc: failed to remove %s: %d\n",
|
|
|
|
codec->name, err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure all DAPM widgets are freed */
|
|
|
|
snd_soc_dapm_free(&codec->dapm);
|
|
|
|
|
|
|
|
soc_cleanup_codec_debugfs(codec);
|
|
|
|
codec->probed = 0;
|
|
|
|
list_del(&codec->card_list);
|
|
|
|
module_put(codec->dev->driver->owner);
|
|
|
|
}
|
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
static void soc_remove_link_dais(struct snd_soc_card *card, int num, int order)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* unregister the rtd device */
|
|
|
|
if (rtd->dev_registered) {
|
2012-01-07 08:12:45 +07:00
|
|
|
device_remove_file(rtd->dev, &dev_attr_pmdown_time);
|
|
|
|
device_remove_file(rtd->dev, &dev_attr_codec_reg);
|
|
|
|
device_unregister(rtd->dev);
|
2010-03-18 03:15:21 +07:00
|
|
|
rtd->dev_registered = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove the CODEC DAI */
|
2011-06-07 22:08:05 +07:00
|
|
|
if (codec_dai && codec_dai->probed &&
|
|
|
|
codec_dai->driver->remove_order == order) {
|
2010-03-18 03:15:21 +07:00
|
|
|
if (codec_dai->driver->remove) {
|
|
|
|
err = codec_dai->driver->remove(codec_dai);
|
|
|
|
if (err < 0)
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to remove %s: %d\n",
|
|
|
|
codec_dai->name, err);
|
2008-12-09 02:26:48 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
codec_dai->probed = 0;
|
|
|
|
list_del(&codec_dai->card_list);
|
|
|
|
}
|
2008-12-09 02:26:48 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* remove the cpu_dai */
|
2011-06-07 22:08:05 +07:00
|
|
|
if (cpu_dai && cpu_dai->probed &&
|
|
|
|
cpu_dai->driver->remove_order == order) {
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->remove) {
|
|
|
|
err = cpu_dai->driver->remove(cpu_dai);
|
|
|
|
if (err < 0)
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to remove %s: %d\n",
|
|
|
|
cpu_dai->name, err);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
cpu_dai->probed = 0;
|
|
|
|
list_del(&cpu_dai->card_list);
|
2012-06-09 01:34:20 +07:00
|
|
|
|
2012-06-09 01:34:21 +07:00
|
|
|
if (!cpu_dai->codec) {
|
|
|
|
snd_soc_dapm_free(&cpu_dai->dapm);
|
2012-06-09 01:34:20 +07:00
|
|
|
module_put(cpu_dai->dev->driver->owner);
|
2012-06-09 01:34:21 +07:00
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
static void soc_remove_link_components(struct snd_soc_card *card, int num,
|
|
|
|
int order)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
|
|
|
/* remove the platform */
|
|
|
|
if (platform && platform->probed &&
|
|
|
|
platform->driver->remove_order == order) {
|
|
|
|
soc_remove_platform(platform);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove the CODEC-side CODEC */
|
|
|
|
if (codec_dai) {
|
|
|
|
codec = codec_dai->codec;
|
|
|
|
if (codec && codec->probed &&
|
|
|
|
codec->driver->remove_order == order)
|
|
|
|
soc_remove_codec(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove any CPU-side CODEC */
|
|
|
|
if (cpu_dai) {
|
|
|
|
codec = cpu_dai->codec;
|
|
|
|
if (codec && codec->probed &&
|
|
|
|
codec->driver->remove_order == order)
|
|
|
|
soc_remove_codec(codec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-08 12:50:44 +07:00
|
|
|
static void soc_remove_dai_links(struct snd_soc_card *card)
|
|
|
|
{
|
2011-06-07 22:08:05 +07:00
|
|
|
int dai, order;
|
2011-04-08 12:50:44 +07:00
|
|
|
|
2011-06-07 22:08:05 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
|
|
|
for (dai = 0; dai < card->num_rtd; dai++)
|
2012-06-09 01:34:23 +07:00
|
|
|
soc_remove_link_dais(card, dai, order);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
|
|
|
for (dai = 0; dai < card->num_rtd; dai++)
|
|
|
|
soc_remove_link_components(card, dai, order);
|
2011-06-07 22:08:05 +07:00
|
|
|
}
|
2012-06-09 01:34:23 +07:00
|
|
|
|
2011-04-08 12:50:44 +07:00
|
|
|
card->num_rtd = 0;
|
|
|
|
}
|
|
|
|
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
static void soc_set_name_prefix(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2010-12-02 21:53:03 +07: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-14 01:40:44 +07:00
|
|
|
return;
|
|
|
|
|
2010-12-02 21:53:03 +07:00
|
|
|
for (i = 0; i < card->num_configs; i++) {
|
|
|
|
struct snd_soc_codec_conf *map = &card->codec_conf[i];
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-14 01:40:44 +07:00
|
|
|
if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
|
|
|
|
codec->name_prefix = map->name_prefix;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
static int soc_probe_codec(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2011-03-07 23:38:44 +07:00
|
|
|
const struct snd_soc_codec_driver *driver = codec->driver;
|
2012-02-17 10:37:51 +07:00
|
|
|
struct snd_soc_dai *dai;
|
2010-12-06 21:27:07 +07:00
|
|
|
|
|
|
|
codec->card = card;
|
|
|
|
codec->dapm.card = card;
|
|
|
|
soc_set_name_prefix(card, codec);
|
|
|
|
|
2011-01-27 21:24:22 +07:00
|
|
|
if (!try_module_get(codec->dev->driver->owner))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2011-05-01 00:45:49 +07:00
|
|
|
soc_init_codec_debugfs(codec);
|
|
|
|
|
2011-05-05 21:59:09 +07:00
|
|
|
if (driver->dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&codec->dapm, driver->dapm_widgets,
|
|
|
|
driver->num_dapm_widgets);
|
|
|
|
|
2012-02-17 10:37:51 +07:00
|
|
|
/* Create DAPM widgets for each DAI stream */
|
|
|
|
list_for_each_entry(dai, &dai_list, list) {
|
|
|
|
if (dai->dev != codec->dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
snd_soc_dapm_new_dai_widgets(&codec->dapm, dai);
|
|
|
|
}
|
|
|
|
|
2011-08-23 00:40:30 +07:00
|
|
|
codec->dapm.idle_bias_off = driver->idle_bias_off;
|
|
|
|
|
2011-03-07 23:38:44 +07:00
|
|
|
if (driver->probe) {
|
|
|
|
ret = driver->probe(codec);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"asoc: failed to probe CODEC %s: %d\n",
|
|
|
|
codec->name, ret);
|
2011-01-27 21:24:22 +07:00
|
|
|
goto err_probe;
|
2010-12-06 21:27:07 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-22 19:04:02 +07:00
|
|
|
/* If the driver didn't set I/O up try regmap */
|
2012-08-02 02:05:47 +07:00
|
|
|
if (!codec->write && dev_get_regmap(codec->dev, NULL))
|
2012-06-22 19:04:02 +07:00
|
|
|
snd_soc_codec_set_cache_io(codec, 0, 0, SND_SOC_REGMAP);
|
|
|
|
|
2011-04-07 17:18:44 +07:00
|
|
|
if (driver->controls)
|
2012-02-04 00:43:09 +07:00
|
|
|
snd_soc_add_codec_controls(codec, driver->controls,
|
2011-04-07 17:18:44 +07:00
|
|
|
driver->num_controls);
|
2011-03-07 23:38:44 +07:00
|
|
|
if (driver->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&codec->dapm, driver->dapm_routes,
|
|
|
|
driver->num_dapm_routes);
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
/* mark codec as probed and add to card codec list */
|
|
|
|
codec->probed = 1;
|
|
|
|
list_add(&codec->card_list, &card->codec_dev_list);
|
2010-12-14 17:18:32 +07:00
|
|
|
list_add(&codec->dapm.list, &card->dapm_list);
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2011-01-27 21:24:22 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_probe:
|
2011-05-01 00:45:49 +07:00
|
|
|
soc_cleanup_codec_debugfs(codec);
|
2011-01-27 21:24:22 +07:00
|
|
|
module_put(codec->dev->driver->owner);
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-07-01 22:54:08 +07:00
|
|
|
static int soc_probe_platform(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_platform *platform)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
const struct snd_soc_platform_driver *driver = platform->driver;
|
2012-03-07 18:47:41 +07:00
|
|
|
struct snd_soc_dai *dai;
|
2011-07-01 22:54:08 +07:00
|
|
|
|
|
|
|
platform->card = card;
|
2011-07-05 04:10:52 +07:00
|
|
|
platform->dapm.card = card;
|
2011-07-01 22:54:08 +07:00
|
|
|
|
|
|
|
if (!try_module_get(platform->dev->driver->owner))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2012-02-15 22:25:31 +07:00
|
|
|
soc_init_platform_debugfs(platform);
|
|
|
|
|
2011-07-05 04:10:53 +07:00
|
|
|
if (driver->dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&platform->dapm,
|
|
|
|
driver->dapm_widgets, driver->num_dapm_widgets);
|
|
|
|
|
2012-03-07 18:47:41 +07:00
|
|
|
/* Create DAPM widgets for each DAI stream */
|
|
|
|
list_for_each_entry(dai, &dai_list, list) {
|
|
|
|
if (dai->dev != platform->dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
snd_soc_dapm_new_dai_widgets(&platform->dapm, dai);
|
|
|
|
}
|
|
|
|
|
2012-04-06 01:28:01 +07:00
|
|
|
platform->dapm.idle_bias_off = 1;
|
|
|
|
|
2011-07-01 22:54:08 +07:00
|
|
|
if (driver->probe) {
|
|
|
|
ret = driver->probe(platform);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(platform->dev,
|
|
|
|
"asoc: failed to probe platform %s: %d\n",
|
|
|
|
platform->name, ret);
|
|
|
|
goto err_probe;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-05 04:10:53 +07:00
|
|
|
if (driver->controls)
|
|
|
|
snd_soc_add_platform_controls(platform, driver->controls,
|
|
|
|
driver->num_controls);
|
|
|
|
if (driver->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&platform->dapm, driver->dapm_routes,
|
|
|
|
driver->num_dapm_routes);
|
|
|
|
|
2011-07-01 22:54:08 +07:00
|
|
|
/* mark platform as probed and add to card platform list */
|
|
|
|
platform->probed = 1;
|
|
|
|
list_add(&platform->card_list, &card->platform_dev_list);
|
2011-07-05 04:10:52 +07:00
|
|
|
list_add(&platform->dapm.list, &card->dapm_list);
|
2011-07-01 22:54:08 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_probe:
|
2012-03-02 23:13:44 +07:00
|
|
|
soc_cleanup_platform_debugfs(platform);
|
2011-07-01 22:54:08 +07:00
|
|
|
module_put(platform->dev->driver->owner);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-07 08:12:45 +07:00
|
|
|
static void rtd_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(dev);
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
static int soc_post_component_init(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_codec *codec,
|
|
|
|
int num, int dailess)
|
|
|
|
{
|
|
|
|
struct snd_soc_dai_link *dai_link = NULL;
|
|
|
|
struct snd_soc_aux_dev *aux_dev = NULL;
|
|
|
|
struct snd_soc_pcm_runtime *rtd;
|
|
|
|
const char *temp, *name;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!dailess) {
|
|
|
|
dai_link = &card->dai_link[num];
|
|
|
|
rtd = &card->rtd[num];
|
|
|
|
name = dai_link->name;
|
|
|
|
} else {
|
|
|
|
aux_dev = &card->aux_dev[num];
|
|
|
|
rtd = &card->rtd_aux[num];
|
|
|
|
name = aux_dev->name;
|
|
|
|
}
|
2011-02-03 03:11:41 +07:00
|
|
|
rtd->card = card;
|
2010-12-06 21:27:07 +07:00
|
|
|
|
2011-10-18 06:11:49 +07:00
|
|
|
/* Make sure all DAPM widgets are instantiated */
|
|
|
|
snd_soc_dapm_new_widgets(&codec->dapm);
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
/* machine controls, routes and widgets are not prefixed */
|
|
|
|
temp = codec->name_prefix;
|
|
|
|
codec->name_prefix = NULL;
|
|
|
|
|
|
|
|
/* do machine specific initialization */
|
|
|
|
if (!dailess && dai_link->init)
|
|
|
|
ret = dai_link->init(rtd);
|
|
|
|
else if (dailess && aux_dev->init)
|
|
|
|
ret = aux_dev->init(&codec->dapm);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
codec->name_prefix = temp;
|
|
|
|
|
|
|
|
/* register the rtd device */
|
|
|
|
rtd->codec = codec;
|
2012-01-07 08:12:45 +07:00
|
|
|
|
|
|
|
rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
|
|
|
|
if (!rtd->dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
device_initialize(rtd->dev);
|
|
|
|
rtd->dev->parent = card->dev;
|
|
|
|
rtd->dev->release = rtd_release;
|
|
|
|
rtd->dev->init_name = name;
|
|
|
|
dev_set_drvdata(rtd->dev, rtd);
|
2011-06-09 23:04:39 +07:00
|
|
|
mutex_init(&rtd->pcm_mutex);
|
ASoC: dpcm: Add Dynamic PCM core operations.
The Dynamic PCM core allows digital audio data to be dynamically
routed between different ALSA PCMs and DAI links on SoC CPUs with
on chip DSP devices. e.g. audio data could be played on pcm:0,0 and
routed to any (or all) SoC DAI links.
Dynamic PCM introduces the concept of Front End (FE) PCMs and Back
End (BE) PCMs. The FE PCMs are normal ALSA PCM devices except that
they can dynamically route digital audio data to any supported BE
PCM. A BE PCM has no ALSA device, but represents a DAI link and it's
substream and audio HW parameters.
e.g. pcm:0,0 routing digital data to 2 external codecs.
FE pcm:0,0 ----> BE (McBSP.0) ----> CODEC 0
+--> BE (McPDM.0) ----> CODEC 1
e.g. pcm:0,0 and pcm:0,1 routing digital data to 1 external codec.
FE pcm:0,0 ---
+--> BE (McBSP.0) ----> CODEC
FE pcm:0,1 ---
The digital audio routing is controlled by the usual ALSA method
of mixer kcontrols. Dynamic PCM uses a DAPM graph to work out the
routing based upon the mixer settings and configures the BE PCMs
based on routing and the FE HW params.
DPCM is designed so that most ASoC component drivers will need no
modification at all. It's intended that existing CODEC, DAI and
platform drivers can be used in DPCM based audio devices without
any changes. However, there will be some cases where minor changes
are required (e.g. for very tightly coupled HW) and there are
helpers to support this too.
Somethimes the HW params of a FE and BE do not match or are
incompatible, so in these cases the machine driver can reconfigure
any hw_params and make any DSP perform sample rate / format conversion.
This patch adds the core DPCM code and contains :-
o The FE and BE PCM operations.
o FE and BE DAI link support.
o FE and BE PCM creation.
o BE support API.
o BE and FE link management.
Signed-off-by: Liam Girdwood <lrg@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-04-25 18:12:49 +07:00
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
|
|
|
|
INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
|
2012-01-07 08:12:45 +07:00
|
|
|
ret = device_add(rtd->dev);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"asoc: failed to register runtime device: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
rtd->dev_registered = 1;
|
|
|
|
|
|
|
|
/* add DAPM sysfs entries for this codec */
|
2012-01-07 08:12:45 +07:00
|
|
|
ret = snd_soc_dapm_sys_add(rtd->dev);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0)
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"asoc: failed to add codec dapm sysfs entries: %d\n",
|
|
|
|
ret);
|
|
|
|
|
|
|
|
/* add codec sysfs entries */
|
2012-01-07 08:12:45 +07:00
|
|
|
ret = device_create_file(rtd->dev, &dev_attr_codec_reg);
|
2010-12-06 21:27:07 +07:00
|
|
|
if (ret < 0)
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"asoc: failed to add codec sysfs files: %d\n", ret);
|
|
|
|
|
2012-04-25 18:12:50 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
/* add DPCM sysfs entries */
|
2012-04-30 17:05:30 +07:00
|
|
|
if (!dailess && !dai_link->dynamic)
|
2012-04-25 18:12:50 +07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = soc_dpcm_debugfs_add(rtd);
|
|
|
|
if (ret < 0)
|
|
|
|
dev_err(rtd->dev, "asoc: failed to add dpcm sysfs entries: %d\n", ret);
|
|
|
|
|
|
|
|
out:
|
|
|
|
#endif
|
2010-12-06 21:27:07 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
static int soc_probe_link_components(struct snd_soc_card *card, int num,
|
|
|
|
int order)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* probe the CPU-side component, if it is a CODEC */
|
|
|
|
if (cpu_dai->codec &&
|
|
|
|
!cpu_dai->codec->probed &&
|
|
|
|
cpu_dai->codec->driver->probe_order == order) {
|
|
|
|
ret = soc_probe_codec(card, cpu_dai->codec);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* probe the CODEC-side component */
|
|
|
|
if (!codec_dai->codec->probed &&
|
|
|
|
codec_dai->codec->driver->probe_order == order) {
|
|
|
|
ret = soc_probe_codec(card, codec_dai->codec);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* probe the platform */
|
|
|
|
if (!platform->probed &&
|
|
|
|
platform->driver->probe_order == order) {
|
|
|
|
ret = soc_probe_platform(card, platform);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
|
|
|
struct snd_soc_dai_link *dai_link = &card->dai_link[num];
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
|
|
|
|
struct snd_soc_codec *codec = rtd->codec;
|
|
|
|
struct snd_soc_platform *platform = rtd->platform;
|
2012-04-05 04:12:09 +07:00
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
struct snd_soc_dapm_widget *play_w, *capture_w;
|
2010-03-18 03:15:21 +07:00
|
|
|
int ret;
|
|
|
|
|
2011-06-07 22:08:05 +07:00
|
|
|
dev_dbg(card->dev, "probe %s dai link %d late %d\n",
|
|
|
|
card->name, num, order);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* config components */
|
|
|
|
cpu_dai->platform = platform;
|
|
|
|
codec_dai->card = card;
|
|
|
|
cpu_dai->card = card;
|
|
|
|
|
|
|
|
/* set default power off timeout */
|
|
|
|
rtd->pmdown_time = pmdown_time;
|
|
|
|
|
|
|
|
/* probe the cpu_dai */
|
2011-06-07 22:08:05 +07:00
|
|
|
if (!cpu_dai->probed &&
|
|
|
|
cpu_dai->driver->probe_order == order) {
|
2012-06-09 01:34:20 +07:00
|
|
|
if (!cpu_dai->codec) {
|
|
|
|
cpu_dai->dapm.card = card;
|
|
|
|
if (!try_module_get(cpu_dai->dev->driver->owner))
|
|
|
|
return -ENODEV;
|
2011-05-24 19:57:43 +07:00
|
|
|
|
2012-06-09 01:34:21 +07:00
|
|
|
list_add(&cpu_dai->dapm.list, &card->dapm_list);
|
2012-06-09 01:34:20 +07:00
|
|
|
snd_soc_dapm_new_dai_widgets(&cpu_dai->dapm, cpu_dai);
|
|
|
|
}
|
2012-03-07 18:47:41 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
if (cpu_dai->driver->probe) {
|
|
|
|
ret = cpu_dai->driver->probe(cpu_dai);
|
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to probe CPU DAI %s: %d\n",
|
|
|
|
cpu_dai->name, ret);
|
2011-05-24 19:57:43 +07:00
|
|
|
module_put(cpu_dai->dev->driver->owner);
|
2010-03-18 03:15:21 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cpu_dai->probed = 1;
|
2011-07-17 23:00:26 +07:00
|
|
|
/* mark cpu_dai as probed and add to card dai list */
|
2010-03-18 03:15:21 +07:00
|
|
|
list_add(&cpu_dai->card_list, &card->dai_dev_list);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* probe the CODEC DAI */
|
2011-06-07 22:08:05 +07:00
|
|
|
if (!codec_dai->probed && codec_dai->driver->probe_order == order) {
|
2010-03-18 03:15:21 +07:00
|
|
|
if (codec_dai->driver->probe) {
|
|
|
|
ret = codec_dai->driver->probe(codec_dai);
|
2009-11-04 05:13:13 +07:00
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to probe CODEC DAI %s: %d\n",
|
|
|
|
codec_dai->name, ret);
|
2010-03-18 03:15:21 +07:00
|
|
|
return ret;
|
2009-11-04 05:13:13 +07:00
|
|
|
}
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-07-17 23:00:26 +07:00
|
|
|
/* mark codec_dai as probed and add to card dai list */
|
2010-03-18 03:15:21 +07:00
|
|
|
codec_dai->probed = 1;
|
|
|
|
list_add(&codec_dai->card_list, &card->dai_dev_list);
|
2009-11-04 05:13:13 +07:00
|
|
|
}
|
|
|
|
|
2011-06-07 22:08:05 +07:00
|
|
|
/* complete DAI probe during last probe */
|
|
|
|
if (order != SND_SOC_COMP_ORDER_LAST)
|
|
|
|
return 0;
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
ret = soc_post_component_init(card, codec, num, 0);
|
|
|
|
if (ret)
|
2010-03-18 03:15:21 +07:00
|
|
|
return ret;
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2012-01-07 08:12:45 +07:00
|
|
|
ret = device_create_file(rtd->dev, &dev_attr_pmdown_time);
|
2010-03-18 03:15:21 +07:00
|
|
|
if (ret < 0)
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_warn("asoc: failed to add pmdown_time sysfs:%d\n", ret);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-08-16 18:40:41 +07:00
|
|
|
if (cpu_dai->driver->compress_dai) {
|
|
|
|
/*create compress_device"*/
|
|
|
|
ret = soc_new_compress(rtd, num);
|
2012-04-05 04:12:09 +07:00
|
|
|
if (ret < 0) {
|
2012-08-16 18:40:41 +07:00
|
|
|
pr_err("asoc: can't create compress %s\n",
|
|
|
|
dai_link->stream_name);
|
2012-04-05 04:12:09 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
} else {
|
2012-08-16 18:40:41 +07:00
|
|
|
|
|
|
|
if (!dai_link->params) {
|
|
|
|
/* create the pcm */
|
|
|
|
ret = soc_new_pcm(rtd, num);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("asoc: can't create pcm %s :%d\n",
|
|
|
|
dai_link->stream_name, ret);
|
2012-04-05 04:12:09 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2012-08-16 18:40:41 +07:00
|
|
|
} else {
|
|
|
|
/* link the DAI widgets */
|
|
|
|
play_w = codec_dai->playback_widget;
|
|
|
|
capture_w = cpu_dai->capture_widget;
|
|
|
|
if (play_w && capture_w) {
|
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
|
|
|
capture_w, play_w);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "Can't link %s to %s: %d\n",
|
|
|
|
play_w->name, capture_w->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2012-04-05 04:12:09 +07:00
|
|
|
|
2012-08-16 18:40:41 +07:00
|
|
|
play_w = cpu_dai->playback_widget;
|
|
|
|
capture_w = codec_dai->capture_widget;
|
|
|
|
if (play_w && capture_w) {
|
|
|
|
ret = snd_soc_dapm_new_pcm(card, dai_link->params,
|
2012-04-05 04:12:09 +07:00
|
|
|
capture_w, play_w);
|
2012-08-16 18:40:41 +07:00
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(card->dev, "Can't link %s to %s: %d\n",
|
|
|
|
play_w->name, capture_w->name, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-04-05 04:12:09 +07:00
|
|
|
}
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* add platform data for AC97 devices */
|
|
|
|
if (rtd->codec_dai->driver->ac97_control)
|
|
|
|
snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-04 05:13:13 +07:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
2010-03-18 03:15:21 +07:00
|
|
|
static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2009-11-04 05:13:13 +07:00
|
|
|
/* Only instantiate AC97 if not already done by the adaptor
|
|
|
|
* for the generic AC97 subsystem.
|
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
|
2010-10-13 15:30:32 +07:00
|
|
|
/*
|
|
|
|
* It is possible that the AC97 device is already registered to
|
|
|
|
* the device subsystem. This happens when the device is created
|
|
|
|
* via snd_ac97_mixer(). Currently only SoC codec that does so
|
|
|
|
* is the generic AC97 glue but others migh emerge.
|
|
|
|
*
|
|
|
|
* In those cases we don't try to register the device again.
|
|
|
|
*/
|
|
|
|
if (!rtd->codec->ac97_created)
|
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
ret = soc_ac97_dev_register(rtd->codec);
|
2009-11-04 05:13:13 +07:00
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: AC97 device register failed:%d\n", ret);
|
2010-03-18 03:15:21 +07:00
|
|
|
return ret;
|
2009-11-04 05:13:13 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
rtd->codec->ac97_registered = 1;
|
2009-11-04 05:13:13 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
if (codec->ac97_registered) {
|
|
|
|
soc_ac97_dev_unregister(codec);
|
|
|
|
codec->ac97_registered = 0;
|
|
|
|
}
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
#endif
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
static int soc_check_aux_dev(struct snd_soc_card *card, int num)
|
|
|
|
{
|
|
|
|
struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
|
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
|
|
|
/* find CODEC from registered CODECs*/
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (!strcmp(codec->name, aux_dev->codec_name))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-10 00:44:37 +07:00
|
|
|
dev_err(card->dev, "%s not registered\n", aux_dev->codec_name);
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
|
|
|
|
2010-11-25 22:47:38 +07:00
|
|
|
static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
|
|
|
|
{
|
|
|
|
struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
|
|
|
|
struct snd_soc_codec *codec;
|
2010-12-03 14:18:22 +07:00
|
|
|
int ret = -ENODEV;
|
2010-11-25 22:47:38 +07:00
|
|
|
|
|
|
|
/* find CODEC from registered CODECs*/
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (!strcmp(codec->name, aux_dev->codec_name)) {
|
|
|
|
if (codec->probed) {
|
|
|
|
dev_err(codec->dev,
|
|
|
|
"asoc: codec already probed");
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-12-03 14:18:22 +07:00
|
|
|
goto found;
|
2010-11-25 22:47:38 +07:00
|
|
|
}
|
|
|
|
}
|
2010-12-03 14:18:22 +07:00
|
|
|
/* codec not found */
|
|
|
|
dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
|
2012-03-15 04:18:39 +07:00
|
|
|
return -EPROBE_DEFER;
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2010-12-03 14:18:22 +07:00
|
|
|
found:
|
2010-12-06 21:27:07 +07:00
|
|
|
ret = soc_probe_codec(card, codec);
|
2010-11-25 22:47:38 +07:00
|
|
|
if (ret < 0)
|
2010-12-06 21:27:07 +07:00
|
|
|
return ret;
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
ret = soc_post_component_init(card, codec, num, 1);
|
2010-11-25 22:47:38 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
|
|
|
|
{
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
|
|
|
|
struct snd_soc_codec *codec = rtd->codec;
|
|
|
|
|
|
|
|
/* unregister the rtd device */
|
|
|
|
if (rtd->dev_registered) {
|
2012-01-07 08:12:45 +07:00
|
|
|
device_remove_file(rtd->dev, &dev_attr_codec_reg);
|
|
|
|
device_del(rtd->dev);
|
2010-11-25 22:47:38 +07:00
|
|
|
rtd->dev_registered = 0;
|
|
|
|
}
|
|
|
|
|
2010-12-06 21:27:07 +07:00
|
|
|
if (codec && codec->probed)
|
|
|
|
soc_remove_codec(codec);
|
2010-11-25 22:47:38 +07:00
|
|
|
}
|
|
|
|
|
2010-12-02 23:11:06 +07:00
|
|
|
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
|
|
|
|
enum snd_soc_compress_type compress_type)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (codec->cache_init)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* override the compress_type if necessary */
|
|
|
|
if (compress_type && codec->compress_type != compress_type)
|
|
|
|
codec->compress_type = compress_type;
|
|
|
|
ret = snd_soc_cache_init(codec);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(codec->dev, "Failed to set cache compression type: %d\n",
|
|
|
|
ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
codec->cache_init = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
static int snd_soc_instantiate_card(struct snd_soc_card *card)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
2010-12-02 23:11:06 +07:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
struct snd_soc_codec_conf *codec_conf;
|
|
|
|
enum snd_soc_compress_type compress_type;
|
2011-09-27 22:41:01 +07:00
|
|
|
struct snd_soc_dai_link *dai_link;
|
2012-04-09 22:29:21 +07:00
|
|
|
int ret, i, order, dai_fmt;
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2012-03-07 17:38:25 +07:00
|
|
|
mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
|
2010-02-12 18:37:24 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* bind DAIs */
|
2012-03-15 04:18:39 +07:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
ret = soc_bind_dai_link(card, i);
|
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
/* check aux_devs too */
|
|
|
|
for (i = 0; i < card->num_aux_devs; i++) {
|
|
|
|
ret = soc_check_aux_dev(card, i);
|
|
|
|
if (ret != 0)
|
|
|
|
goto base_error;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2010-12-02 23:11:06 +07:00
|
|
|
/* initialize the register cache for each available codec */
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (codec->cache_init)
|
|
|
|
continue;
|
2011-01-11 18:43:51 +07:00
|
|
|
/* by default we don't override the compress_type */
|
|
|
|
compress_type = 0;
|
2010-12-02 23:11:06 +07:00
|
|
|
/* check to see if we need to override the compress_type */
|
|
|
|
for (i = 0; i < card->num_configs; ++i) {
|
|
|
|
codec_conf = &card->codec_conf[i];
|
|
|
|
if (!strcmp(codec->name, codec_conf->dev_name)) {
|
|
|
|
compress_type = codec_conf->compress_type;
|
|
|
|
if (compress_type && compress_type
|
|
|
|
!= codec->compress_type)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = snd_soc_init_codec_cache(codec, compress_type);
|
2012-03-15 04:18:39 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto base_error;
|
2010-12-02 23:11:06 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* card bind complete so register a sound card */
|
|
|
|
ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
|
|
|
|
card->owner, 0, &card->snd_card);
|
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: can't create sound card for card %s: %d\n",
|
|
|
|
card->name, ret);
|
2012-03-15 04:18:39 +07:00
|
|
|
goto base_error;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
card->snd_card->dev = card->dev;
|
|
|
|
|
2011-03-03 01:21:57 +07:00
|
|
|
card->dapm.bias_level = SND_SOC_BIAS_OFF;
|
|
|
|
card->dapm.dev = card->dev;
|
|
|
|
card->dapm.card = card;
|
|
|
|
list_add(&card->dapm.list, &card->dapm_list);
|
|
|
|
|
2011-05-01 00:45:49 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
|
|
|
|
#endif
|
|
|
|
|
2011-02-02 17:43:26 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2010-03-18 03:15:21 +07:00
|
|
|
/* deferred resume work */
|
|
|
|
INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
|
|
|
|
#endif
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2011-04-13 07:51:37 +07:00
|
|
|
if (card->dapm_widgets)
|
|
|
|
snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
|
|
|
|
card->num_dapm_widgets);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* initialise the sound card only once */
|
|
|
|
if (card->probe) {
|
2011-01-26 21:17:20 +07:00
|
|
|
ret = card->probe(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto card_probe_error;
|
|
|
|
}
|
2009-11-04 05:13:13 +07:00
|
|
|
|
2012-06-09 01:34:23 +07:00
|
|
|
/* probe all components used by DAI links on this card */
|
2011-06-07 22:08:05 +07:00
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
|
|
|
for (i = 0; i < card->num_links; i++) {
|
2012-06-09 01:34:23 +07:00
|
|
|
ret = soc_probe_link_components(card, i, order);
|
2011-06-07 22:08:05 +07:00
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("asoc: failed to instantiate card %s: %d\n",
|
2012-06-09 01:34:23 +07:00
|
|
|
card->name, ret);
|
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* probe all DAI links on this card */
|
|
|
|
for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
|
|
|
|
order++) {
|
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
ret = soc_probe_link_dais(card, i, order);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("asoc: failed to instantiate card %s: %d\n",
|
|
|
|
card->name, ret);
|
2011-06-07 22:08:05 +07:00
|
|
|
goto probe_dai_err;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-11-25 22:47:38 +07:00
|
|
|
for (i = 0; i < card->num_aux_devs; i++) {
|
|
|
|
ret = soc_probe_aux_dev(card, i);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("asoc: failed to add auxiliary devices %s: %d\n",
|
|
|
|
card->name, ret);
|
|
|
|
goto probe_aux_dev_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-17 10:37:51 +07:00
|
|
|
snd_soc_dapm_link_dai_widgets(card);
|
|
|
|
|
2011-04-07 17:18:44 +07:00
|
|
|
if (card->controls)
|
2012-02-04 00:43:09 +07:00
|
|
|
snd_soc_add_card_controls(card, card->controls, card->num_controls);
|
2011-04-07 17:18:44 +07:00
|
|
|
|
2011-03-03 01:35:51 +07:00
|
|
|
if (card->dapm_routes)
|
|
|
|
snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
|
|
|
|
card->num_dapm_routes);
|
|
|
|
|
2011-10-10 19:38:06 +07:00
|
|
|
snd_soc_dapm_new_widgets(&card->dapm);
|
|
|
|
|
2011-09-27 22:41:01 +07:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
dai_link = &card->dai_link[i];
|
2012-04-09 22:29:21 +07:00
|
|
|
dai_fmt = dai_link->dai_fmt;
|
2011-09-27 22:41:01 +07:00
|
|
|
|
2012-04-09 22:29:21 +07:00
|
|
|
if (dai_fmt) {
|
2011-09-27 22:41:01 +07:00
|
|
|
ret = snd_soc_dai_set_fmt(card->rtd[i].codec_dai,
|
2012-04-09 22:29:21 +07:00
|
|
|
dai_fmt);
|
2012-03-08 23:59:40 +07:00
|
|
|
if (ret != 0 && ret != -ENOTSUPP)
|
2011-09-27 22:41:01 +07:00
|
|
|
dev_warn(card->rtd[i].codec_dai->dev,
|
|
|
|
"Failed to set DAI format: %d\n",
|
|
|
|
ret);
|
2012-04-09 22:29:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If this is a regular CPU link there will be a platform */
|
2012-05-15 03:47:22 +07:00
|
|
|
if (dai_fmt &&
|
|
|
|
(dai_link->platform_name || dai_link->platform_of_node)) {
|
2012-04-09 22:29:21 +07:00
|
|
|
ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
|
|
|
|
dai_fmt);
|
|
|
|
if (ret != 0 && ret != -ENOTSUPP)
|
|
|
|
dev_warn(card->rtd[i].cpu_dai->dev,
|
|
|
|
"Failed to set DAI format: %d\n",
|
|
|
|
ret);
|
|
|
|
} else if (dai_fmt) {
|
|
|
|
/* Flip the polarity for the "CPU" end */
|
|
|
|
dai_fmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
|
|
|
|
switch (dai_link->dai_fmt &
|
|
|
|
SND_SOC_DAIFMT_MASTER_MASK) {
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFM:
|
|
|
|
dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBM_CFS:
|
|
|
|
dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFM:
|
|
|
|
dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
|
|
|
|
break;
|
|
|
|
case SND_SOC_DAIFMT_CBS_CFS:
|
|
|
|
dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
|
|
|
|
break;
|
|
|
|
}
|
2011-09-27 22:41:01 +07:00
|
|
|
|
|
|
|
ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
|
2012-04-09 22:29:21 +07:00
|
|
|
dai_fmt);
|
2012-03-08 23:59:40 +07:00
|
|
|
if (ret != 0 && ret != -ENOTSUPP)
|
2011-09-27 22:41:01 +07:00
|
|
|
dev_warn(card->rtd[i].cpu_dai->dev,
|
|
|
|
"Failed to set DAI format: %d\n",
|
|
|
|
ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
|
|
|
|
"%s", card->name);
|
2011-05-12 22:14:04 +07:00
|
|
|
snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
|
|
|
|
"%s", card->long_name ? card->long_name : card->name);
|
2011-09-20 17:41:54 +07:00
|
|
|
snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
|
|
|
|
"%s", card->driver_name ? card->driver_name : card->name);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
|
|
|
|
switch (card->snd_card->driver[i]) {
|
|
|
|
case '_':
|
|
|
|
case '-':
|
|
|
|
case '\0':
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!isalnum(card->snd_card->driver[i]))
|
|
|
|
card->snd_card->driver[i] = '_';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-03-03 01:36:34 +07:00
|
|
|
if (card->late_probe) {
|
|
|
|
ret = card->late_probe(card);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(card->dev, "%s late_probe() failed: %d\n",
|
|
|
|
card->name, ret);
|
|
|
|
goto probe_aux_dev_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-08 19:59:44 +07:00
|
|
|
snd_soc_dapm_new_widgets(&card->dapm);
|
|
|
|
|
2011-11-24 02:42:04 +07:00
|
|
|
if (card->fully_routed)
|
2011-11-28 02:38:34 +07:00
|
|
|
list_for_each_entry(codec, &card->codec_dev_list, card_list)
|
2011-11-24 02:42:04 +07:00
|
|
|
snd_soc_dapm_auto_nc_codec_pins(codec);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
ret = snd_card_register(card->snd_card);
|
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to register soundcard for %s: %d\n",
|
|
|
|
card->name, ret);
|
2010-12-07 15:12:29 +07:00
|
|
|
goto probe_aux_dev_err;
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
|
|
|
/* register any AC97 codecs */
|
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
2010-12-07 15:12:29 +07:00
|
|
|
ret = soc_register_ac97_dai_link(&card->rtd[i]);
|
|
|
|
if (ret < 0) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: failed to register AC97 %s: %d\n",
|
|
|
|
card->name, ret);
|
2010-12-07 15:12:29 +07:00
|
|
|
while (--i >= 0)
|
2010-12-14 00:03:27 +07:00
|
|
|
soc_unregister_ac97_dai_link(card->rtd[i].codec);
|
2010-12-07 15:12:29 +07:00
|
|
|
goto probe_aux_dev_err;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2010-12-07 15:12:29 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
card->instantiated = 1;
|
2011-10-07 20:29:19 +07:00
|
|
|
snd_soc_dapm_sync(&card->dapm);
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_unlock(&card->mutex);
|
2012-03-15 04:18:39 +07:00
|
|
|
|
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2010-11-25 22:47:38 +07:00
|
|
|
probe_aux_dev_err:
|
|
|
|
for (i = 0; i < card->num_aux_devs; i++)
|
|
|
|
soc_remove_aux_dev(card, i);
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
probe_dai_err:
|
2011-04-08 12:50:44 +07:00
|
|
|
soc_remove_dai_links(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
card_probe_error:
|
2008-11-19 03:50:34 +07:00
|
|
|
if (card->remove)
|
2011-01-26 21:17:20 +07:00
|
|
|
card->remove(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
base_error:
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_unlock(&card->mutex);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
return ret;
|
2008-12-04 22:32:53 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* probes a new socdev */
|
|
|
|
static int soc_probe(struct platform_device *pdev)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2008-12-04 22:32:53 +07:00
|
|
|
|
2011-01-14 20:52:48 +07:00
|
|
|
/*
|
|
|
|
* no card, so machine driver should be registering card
|
|
|
|
* we should not be here in that case so ret error
|
|
|
|
*/
|
|
|
|
if (!card)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-03-02 20:07:41 +07:00
|
|
|
dev_warn(&pdev->dev,
|
|
|
|
"ASoC machine %s should use snd_soc_register_card()\n",
|
|
|
|
card->name);
|
|
|
|
|
2008-12-04 22:32:53 +07:00
|
|
|
/* Bodge while we unpick instantiation */
|
|
|
|
card->dev = &pdev->dev;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2012-08-10 00:45:23 +07:00
|
|
|
return snd_soc_register_card(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
static int soc_cleanup_card_resources(struct snd_soc_card *card)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* make sure any delayed work runs */
|
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2011-01-14 00:18:02 +07:00
|
|
|
}
|
2009-05-11 17:04:55 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* remove auxiliary devices */
|
|
|
|
for (i = 0; i < card->num_aux_devs; i++)
|
|
|
|
soc_remove_aux_dev(card, i);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* remove and free each DAI */
|
2011-04-08 12:50:44 +07:00
|
|
|
soc_remove_dai_links(card);
|
2010-11-25 22:47:38 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
soc_cleanup_card_debugfs(card);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
/* remove the card */
|
|
|
|
if (card->remove)
|
2011-01-26 21:17:20 +07:00
|
|
|
card->remove(card);
|
2010-11-06 01:35:19 +07:00
|
|
|
|
2011-05-01 00:45:47 +07:00
|
|
|
snd_soc_dapm_free(&card->dapm);
|
|
|
|
|
2011-01-14 00:18:02 +07:00
|
|
|
snd_card_free(card->snd_card);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* removes a socdev */
|
|
|
|
static int soc_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
snd_soc_unregister_card(card);
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
int snd_soc_poweroff(struct device *dev)
|
2009-06-22 19:16:51 +07:00
|
|
|
{
|
2011-01-26 21:59:27 +07:00
|
|
|
struct snd_soc_card *card = dev_get_drvdata(dev);
|
2010-03-18 03:15:21 +07:00
|
|
|
int i;
|
2009-06-22 19:16:51 +07:00
|
|
|
|
|
|
|
if (!card->instantiated)
|
2009-07-01 01:05:15 +07:00
|
|
|
return 0;
|
2009-06-22 19:16:51 +07:00
|
|
|
|
|
|
|
/* Flush out pmdown_time work - we actually do want to run it
|
|
|
|
* now, we're shutting down so no imminent restart. */
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < card->num_rtd; i++) {
|
|
|
|
struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_delayed_work(&rtd->delayed_work);
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2009-06-22 19:16:51 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_soc_dapm_shutdown(card);
|
2009-07-01 01:05:15 +07:00
|
|
|
|
|
|
|
return 0;
|
2009-06-22 19:16:51 +07:00
|
|
|
}
|
2011-01-26 21:59:27 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
|
2009-06-22 19:16:51 +07:00
|
|
|
|
2011-01-26 21:59:27 +07:00
|
|
|
const struct dev_pm_ops snd_soc_pm_ops = {
|
2012-02-24 17:55:49 +07:00
|
|
|
.suspend = snd_soc_suspend,
|
|
|
|
.resume = snd_soc_resume,
|
|
|
|
.freeze = snd_soc_suspend,
|
|
|
|
.thaw = snd_soc_resume,
|
2011-01-26 21:59:27 +07:00
|
|
|
.poweroff = snd_soc_poweroff,
|
2012-02-24 17:55:49 +07:00
|
|
|
.restore = snd_soc_resume,
|
2009-07-01 01:05:15 +07:00
|
|
|
};
|
2011-04-06 08:35:30 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
|
2009-07-01 01:05:15 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/* ASoC platform driver */
|
|
|
|
static struct platform_driver soc_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "soc-audio",
|
2008-04-14 18:33:36 +07:00
|
|
|
.owner = THIS_MODULE,
|
2011-01-26 21:59:27 +07:00
|
|
|
.pm = &snd_soc_pm_ops,
|
2006-10-06 23:31:09 +07:00
|
|
|
},
|
|
|
|
.probe = soc_probe,
|
|
|
|
.remove = soc_remove,
|
|
|
|
};
|
|
|
|
|
2009-07-05 21:12:22 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_codec_volatile_register: Report if a register is volatile.
|
|
|
|
*
|
|
|
|
* @codec: CODEC to query.
|
|
|
|
* @reg: Register to query.
|
|
|
|
*
|
|
|
|
* Boolean function indiciating if a CODEC register is volatile.
|
|
|
|
*/
|
2011-01-24 21:05:25 +07:00
|
|
|
int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg)
|
2009-07-05 21:12:22 +07:00
|
|
|
{
|
2011-01-13 19:20:38 +07:00
|
|
|
if (codec->volatile_register)
|
|
|
|
return codec->volatile_register(codec, reg);
|
2009-07-05 21:12:22 +07:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
|
|
|
|
|
2011-03-24 20:45:18 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_codec_readable_register: Report if a register is readable.
|
|
|
|
*
|
|
|
|
* @codec: CODEC to query.
|
|
|
|
* @reg: Register to query.
|
|
|
|
*
|
|
|
|
* Boolean function indicating if a CODEC register is readable.
|
|
|
|
*/
|
|
|
|
int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg)
|
|
|
|
{
|
|
|
|
if (codec->readable_register)
|
|
|
|
return codec->readable_register(codec, reg);
|
|
|
|
else
|
2011-08-27 23:24:12 +07:00
|
|
|
return 1;
|
2011-03-24 20:45:18 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_codec_writable_register: Report if a register is writable.
|
|
|
|
*
|
|
|
|
* @codec: CODEC to query.
|
|
|
|
* @reg: Register to query.
|
|
|
|
*
|
|
|
|
* Boolean function indicating if a CODEC register is writable.
|
|
|
|
*/
|
|
|
|
int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg)
|
|
|
|
{
|
|
|
|
if (codec->writable_register)
|
|
|
|
return codec->writable_register(codec, reg);
|
|
|
|
else
|
2011-08-27 23:24:12 +07:00
|
|
|
return 1;
|
2011-03-24 20:45:18 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register);
|
|
|
|
|
2011-07-04 17:10:15 +07:00
|
|
|
int snd_soc_platform_read(struct snd_soc_platform *platform,
|
|
|
|
unsigned int reg)
|
|
|
|
{
|
|
|
|
unsigned int ret;
|
|
|
|
|
|
|
|
if (!platform->driver->read) {
|
|
|
|
dev_err(platform->dev, "platform has no read back\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = platform->driver->read(platform, reg);
|
|
|
|
dev_dbg(platform->dev, "read %x => %x\n", reg, ret);
|
2011-07-05 04:10:50 +07:00
|
|
|
trace_snd_soc_preg_read(platform, reg, ret);
|
2011-07-04 17:10:15 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_platform_read);
|
|
|
|
|
|
|
|
int snd_soc_platform_write(struct snd_soc_platform *platform,
|
|
|
|
unsigned int reg, unsigned int val)
|
|
|
|
{
|
|
|
|
if (!platform->driver->write) {
|
|
|
|
dev_err(platform->dev, "platform has no write back\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(platform->dev, "write %x = %x\n", reg, val);
|
2011-07-05 04:10:50 +07:00
|
|
|
trace_snd_soc_preg_write(platform, reg, val);
|
2011-07-04 17:10:15 +07:00
|
|
|
return platform->driver->write(platform, reg, val);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_platform_write);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_new_ac97_codec - initailise AC97 device
|
|
|
|
* @codec: audio codec
|
|
|
|
* @ops: AC97 bus operations
|
|
|
|
* @num: AC97 codec number
|
|
|
|
*
|
|
|
|
* Initialises AC97 codec resources for use by ad-hoc devices only.
|
|
|
|
*/
|
|
|
|
int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
|
|
|
|
struct snd_ac97_bus_ops *ops, int num)
|
|
|
|
{
|
|
|
|
mutex_lock(&codec->mutex);
|
|
|
|
|
|
|
|
codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
|
|
|
|
if (codec->ac97 == NULL) {
|
|
|
|
mutex_unlock(&codec->mutex);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
|
|
|
|
if (codec->ac97->bus == NULL) {
|
|
|
|
kfree(codec->ac97);
|
|
|
|
codec->ac97 = NULL;
|
|
|
|
mutex_unlock(&codec->mutex);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->ac97->bus->ops = ops;
|
|
|
|
codec->ac97->num = num;
|
2010-10-13 15:30:32 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark the AC97 device to be created by us. This way we ensure that the
|
|
|
|
* device will be registered with the device subsystem later on.
|
|
|
|
*/
|
|
|
|
codec->ac97_created = 1;
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
mutex_unlock(&codec->mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_free_ac97_codec - free AC97 codec device
|
|
|
|
* @codec: audio codec
|
|
|
|
*
|
|
|
|
* Frees AC97 codec device resources.
|
|
|
|
*/
|
|
|
|
void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
mutex_lock(&codec->mutex);
|
2010-03-18 03:15:21 +07:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
|
|
|
soc_unregister_ac97_dai_link(codec);
|
|
|
|
#endif
|
2006-10-06 23:31:09 +07:00
|
|
|
kfree(codec->ac97->bus);
|
|
|
|
kfree(codec->ac97);
|
|
|
|
codec->ac97 = NULL;
|
2010-10-13 15:30:32 +07:00
|
|
|
codec->ac97_created = 0;
|
2006-10-06 23:31:09 +07:00
|
|
|
mutex_unlock(&codec->mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
|
|
|
|
|
2010-11-02 02:41:57 +07:00
|
|
|
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
|
|
|
|
{
|
|
|
|
unsigned int ret;
|
|
|
|
|
2010-12-02 23:15:29 +07:00
|
|
|
ret = codec->read(codec, reg);
|
2010-11-02 02:41:57 +07:00
|
|
|
dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
|
2010-11-04 05:05:58 +07:00
|
|
|
trace_snd_soc_reg_read(codec, reg, ret);
|
2010-11-02 02:41:57 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_read);
|
|
|
|
|
|
|
|
unsigned int snd_soc_write(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg, unsigned int val)
|
|
|
|
{
|
|
|
|
dev_dbg(codec->dev, "write %x = %x\n", reg, val);
|
2010-11-04 05:05:58 +07:00
|
|
|
trace_snd_soc_reg_write(codec, reg, val);
|
2010-12-02 23:15:29 +07:00
|
|
|
return codec->write(codec, reg, val);
|
2010-11-02 02:41:57 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_write);
|
|
|
|
|
2011-03-22 17:37:03 +07:00
|
|
|
unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
|
|
|
|
unsigned int reg, const void *data, size_t len)
|
|
|
|
{
|
|
|
|
return codec->bulk_write_raw(codec, reg, data, len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_update_bits - update codec register bits
|
|
|
|
* @codec: audio codec
|
|
|
|
* @reg: codec register
|
|
|
|
* @mask: register mask
|
|
|
|
* @value: new value
|
|
|
|
*
|
|
|
|
* Writes new register value.
|
|
|
|
*
|
2011-01-11 04:58:13 +07:00
|
|
|
* Returns 1 for change, 0 for no change, or negative error code.
|
2006-10-06 23:31:09 +07:00
|
|
|
*/
|
|
|
|
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int mask, unsigned int value)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2011-12-03 19:33:55 +07:00
|
|
|
bool change;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int old, new;
|
2011-01-11 04:58:13 +07:00
|
|
|
int ret;
|
|
|
|
|
2011-12-03 19:33:55 +07:00
|
|
|
if (codec->using_regmap) {
|
|
|
|
ret = regmap_update_bits_check(codec->control_data, reg,
|
|
|
|
mask, value, &change);
|
|
|
|
} else {
|
|
|
|
ret = snd_soc_read(codec, reg);
|
2011-01-11 04:58:13 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-12-03 19:33:55 +07:00
|
|
|
|
|
|
|
old = ret;
|
|
|
|
new = (old & ~mask) | (value & mask);
|
|
|
|
change = old != new;
|
|
|
|
if (change)
|
|
|
|
ret = snd_soc_write(codec, reg, new);
|
2011-01-11 04:58:13 +07:00
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2011-12-03 19:33:55 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return change;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_update_bits);
|
|
|
|
|
2009-10-30 18:34:03 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_update_bits_locked - update codec register bits
|
|
|
|
* @codec: audio codec
|
|
|
|
* @reg: codec register
|
|
|
|
* @mask: register mask
|
|
|
|
* @value: new value
|
|
|
|
*
|
|
|
|
* Writes new register value, and takes the codec mutex.
|
|
|
|
*
|
|
|
|
* Returns 1 for change else 0.
|
|
|
|
*/
|
2009-12-04 21:22:03 +07:00
|
|
|
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
|
|
|
|
unsigned short reg, unsigned int mask,
|
|
|
|
unsigned int value)
|
2009-10-30 18:34:03 +07:00
|
|
|
{
|
|
|
|
int change;
|
|
|
|
|
|
|
|
mutex_lock(&codec->mutex);
|
|
|
|
change = snd_soc_update_bits(codec, reg, mask, value);
|
|
|
|
mutex_unlock(&codec->mutex);
|
|
|
|
|
|
|
|
return change;
|
|
|
|
}
|
2009-12-04 21:22:03 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
|
2009-10-30 18:34:03 +07:00
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_test_bits - test register for change
|
|
|
|
* @codec: audio codec
|
|
|
|
* @reg: codec register
|
|
|
|
* @mask: register mask
|
|
|
|
* @value: new value
|
|
|
|
*
|
|
|
|
* Tests a register with a new value and checks if the new value is
|
|
|
|
* different from the old value.
|
|
|
|
*
|
|
|
|
* Returns 1 for change else 0.
|
|
|
|
*/
|
|
|
|
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int mask, unsigned int value)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
|
|
|
int change;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int old, new;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
old = snd_soc_read(codec, reg);
|
|
|
|
new = (old & ~mask) | value;
|
|
|
|
change = old != new;
|
|
|
|
|
|
|
|
return change;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_test_bits);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_set_runtime_hwparams - set the runtime hardware parameters
|
|
|
|
* @substream: the pcm substream
|
|
|
|
* @hw: the hardware parameters
|
|
|
|
*
|
|
|
|
* Sets the substream runtime hardware parameters.
|
|
|
|
*/
|
|
|
|
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
|
|
|
|
const struct snd_pcm_hardware *hw)
|
|
|
|
{
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->hw.info = hw->info;
|
|
|
|
runtime->hw.formats = hw->formats;
|
|
|
|
runtime->hw.period_bytes_min = hw->period_bytes_min;
|
|
|
|
runtime->hw.period_bytes_max = hw->period_bytes_max;
|
|
|
|
runtime->hw.periods_min = hw->periods_min;
|
|
|
|
runtime->hw.periods_max = hw->periods_max;
|
|
|
|
runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
|
|
|
|
runtime->hw.fifo_size = hw->fifo_size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_cnew - create new control
|
|
|
|
* @_template: control template
|
|
|
|
* @data: control private data
|
2009-01-01 19:18:17 +07:00
|
|
|
* @long_name: control long name
|
2011-03-09 00:23:24 +07:00
|
|
|
* @prefix: control name prefix
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Create a new mixer control from a template control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success, else error.
|
|
|
|
*/
|
|
|
|
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
|
2012-02-17 08:07:42 +07:00
|
|
|
void *data, const char *long_name,
|
2011-03-09 00:23:24 +07:00
|
|
|
const char *prefix)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
|
|
|
struct snd_kcontrol_new template;
|
2011-03-09 00:23:24 +07:00
|
|
|
struct snd_kcontrol *kcontrol;
|
|
|
|
char *name = NULL;
|
|
|
|
int name_len;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
memcpy(&template, _template, sizeof(template));
|
|
|
|
template.index = 0;
|
|
|
|
|
2011-03-09 00:23:24 +07:00
|
|
|
if (!long_name)
|
|
|
|
long_name = template.name;
|
|
|
|
|
|
|
|
if (prefix) {
|
|
|
|
name_len = strlen(long_name) + strlen(prefix) + 2;
|
2011-08-20 10:03:44 +07:00
|
|
|
name = kmalloc(name_len, GFP_KERNEL);
|
2011-03-09 00:23:24 +07:00
|
|
|
if (!name)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
snprintf(name, name_len, "%s %s", prefix, long_name);
|
|
|
|
|
|
|
|
template.name = name;
|
|
|
|
} else {
|
|
|
|
template.name = long_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
kcontrol = snd_ctl_new1(&template, data);
|
|
|
|
|
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
return kcontrol;
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_cnew);
|
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls,
|
|
|
|
const char *prefix, void *data)
|
|
|
|
{
|
|
|
|
int err, i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_controls; i++) {
|
|
|
|
const struct snd_kcontrol_new *control = &controls[i];
|
|
|
|
err = snd_ctl_add(card, snd_soc_cnew(control, data,
|
|
|
|
control->name, prefix));
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(dev, "Failed to add %s: %d\n", control->name, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-09 07:23:21 +07:00
|
|
|
/**
|
2012-02-04 00:43:09 +07: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 07:23:21 +07: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-04 00:43:09 +07:00
|
|
|
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
|
2009-01-09 07:23:21 +07:00
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_card *card = codec->card->snd_card;
|
2009-01-09 07:23:21 +07:00
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
return snd_soc_add_controls(card, codec->dev, controls, num_controls,
|
|
|
|
codec->name_prefix, codec);
|
2009-01-09 07:23:21 +07:00
|
|
|
}
|
2012-02-04 00:43:09 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
|
2009-01-09 07:23:21 +07:00
|
|
|
|
2011-07-05 04:10:51 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_add_platform_controls - add an array of controls to a platform.
|
2012-02-04 00:43:09 +07:00
|
|
|
* Convenience function to add a list of controls.
|
2011-07-05 04:10:51 +07: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,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
|
|
|
struct snd_card *card = platform->card->snd_card;
|
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
return snd_soc_add_controls(card, platform->dev, controls, num_controls,
|
|
|
|
NULL, platform);
|
2011-07-05 04:10:51 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
|
|
|
|
|
2012-02-04 00:43:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_add_card_controls - add an array of controls to a SoC card.
|
|
|
|
* Convenience function to add a list of controls.
|
|
|
|
*
|
|
|
|
* @soc_card: SoC card to add controls to
|
|
|
|
* @controls: array of controls to add
|
|
|
|
* @num_controls: number of elements in the array
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
|
|
|
struct snd_card *card = soc_card->snd_card;
|
|
|
|
|
|
|
|
return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
|
|
|
|
NULL, soc_card);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_add_dai_controls - add an array of controls to a DAI.
|
|
|
|
* Convienience function to add a list of controls.
|
|
|
|
*
|
|
|
|
* @dai: DAI to add controls to
|
|
|
|
* @controls: array of controls to add
|
|
|
|
* @num_controls: number of elements in the array
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls)
|
|
|
|
{
|
|
|
|
struct snd_card *card = dai->card->snd_card;
|
|
|
|
|
|
|
|
return snd_soc_add_controls(card, dai->dev, controls, num_controls,
|
|
|
|
NULL, dai);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_info_enum_double - enumerated double mixer info callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information about a double enumerated
|
|
|
|
* mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
|
|
uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
|
2008-07-29 17:42:27 +07:00
|
|
|
uinfo->value.enumerated.items = e->max;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-07-29 17:42:27 +07:00
|
|
|
if (uinfo->value.enumerated.item > e->max - 1)
|
|
|
|
uinfo->value.enumerated.item = e->max - 1;
|
2006-10-06 23:31:09 +07:00
|
|
|
strcpy(uinfo->value.enumerated.name,
|
|
|
|
e->texts[uinfo->value.enumerated.item]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_get_enum_double - enumerated double mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Callback to get the value of a double enumerated mixer.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2012-09-14 18:57:27 +07:00
|
|
|
unsigned int val;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
val = snd_soc_read(codec, e->reg);
|
2008-05-19 17:32:25 +07:00
|
|
|
ucontrol->value.enumerated.item[0]
|
2012-09-14 18:57:27 +07:00
|
|
|
= (val >> e->shift_l) & e->mask;
|
2006-10-06 23:31:09 +07:00
|
|
|
if (e->shift_l != e->shift_r)
|
|
|
|
ucontrol->value.enumerated.item[1] =
|
2012-09-14 18:57:27 +07:00
|
|
|
(val >> e->shift_r) & e->mask;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_enum_double - enumerated double mixer put callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Callback to set the value of a double enumerated mixer.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int val;
|
2012-09-14 18:57:27 +07:00
|
|
|
unsigned int mask;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-07-29 17:42:27 +07:00
|
|
|
if (ucontrol->value.enumerated.item[0] > e->max - 1)
|
2006-10-06 23:31:09 +07:00
|
|
|
return -EINVAL;
|
|
|
|
val = ucontrol->value.enumerated.item[0] << e->shift_l;
|
2012-09-14 18:57:27 +07:00
|
|
|
mask = e->mask << e->shift_l;
|
2006-10-06 23:31:09 +07:00
|
|
|
if (e->shift_l != e->shift_r) {
|
2008-07-29 17:42:27 +07:00
|
|
|
if (ucontrol->value.enumerated.item[1] > e->max - 1)
|
2006-10-06 23:31:09 +07:00
|
|
|
return -EINVAL;
|
|
|
|
val |= ucontrol->value.enumerated.item[1] << e->shift_r;
|
2012-09-14 18:57:27 +07:00
|
|
|
mask |= e->mask << e->shift_r;
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
2009-10-30 18:34:03 +07:00
|
|
|
return snd_soc_update_bits_locked(codec, e->reg, mask, val);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
|
|
|
|
|
2009-01-05 14:54:57 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_get_value_enum_double - semi enumerated double mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to get the value of a double semi enumerated mixer.
|
|
|
|
*
|
|
|
|
* Semi enumerated mixer: the enumerated items are referred as values. Can be
|
|
|
|
* used for handling bitfield coded enumeration for example.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2009-01-08 18:34:29 +07:00
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int reg_val, val, mux;
|
2009-01-05 14:54:57 +07:00
|
|
|
|
|
|
|
reg_val = snd_soc_read(codec, e->reg);
|
|
|
|
val = (reg_val >> e->shift_l) & e->mask;
|
|
|
|
for (mux = 0; mux < e->max; mux++) {
|
|
|
|
if (val == e->values[mux])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ucontrol->value.enumerated.item[0] = mux;
|
|
|
|
if (e->shift_l != e->shift_r) {
|
|
|
|
val = (reg_val >> e->shift_r) & e->mask;
|
|
|
|
for (mux = 0; mux < e->max; mux++) {
|
|
|
|
if (val == e->values[mux])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ucontrol->value.enumerated.item[1] = mux;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_value_enum_double - semi enumerated double mixer put callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to set the value of a double semi enumerated mixer.
|
|
|
|
*
|
|
|
|
* Semi enumerated mixer: the enumerated items are referred as values. Can be
|
|
|
|
* used for handling bitfield coded enumeration for example.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2009-01-08 18:34:29 +07:00
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int val;
|
|
|
|
unsigned int mask;
|
2009-01-05 14:54:57 +07:00
|
|
|
|
|
|
|
if (ucontrol->value.enumerated.item[0] > e->max - 1)
|
|
|
|
return -EINVAL;
|
|
|
|
val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
|
|
|
|
mask = e->mask << e->shift_l;
|
|
|
|
if (e->shift_l != e->shift_r) {
|
|
|
|
if (ucontrol->value.enumerated.item[1] > e->max - 1)
|
|
|
|
return -EINVAL;
|
|
|
|
val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
|
|
|
|
mask |= e->mask << e->shift_r;
|
|
|
|
}
|
|
|
|
|
2009-10-30 18:34:03 +07:00
|
|
|
return snd_soc_update_bits_locked(codec, e->reg, mask, val);
|
2009-01-05 14:54:57 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_info_enum_ext - external enumerated single mixer info callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information about an external enumerated
|
|
|
|
* single mixer.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
|
|
uinfo->count = 1;
|
2008-07-29 17:42:27 +07:00
|
|
|
uinfo->value.enumerated.items = e->max;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-07-29 17:42:27 +07:00
|
|
|
if (uinfo->value.enumerated.item > e->max - 1)
|
|
|
|
uinfo->value.enumerated.item = e->max - 1;
|
2006-10-06 23:31:09 +07:00
|
|
|
strcpy(uinfo->value.enumerated.name,
|
|
|
|
e->texts[uinfo->value.enumerated.item]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_info_volsw_ext - external single mixer info callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information about a single external mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
2008-01-10 20:37:42 +07:00
|
|
|
int max = kcontrol->private_value;
|
|
|
|
|
2009-04-16 03:37:46 +07:00
|
|
|
if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
|
2008-01-10 20:37:42 +07:00
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
|
|
|
else
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.integer.min = 0;
|
2008-01-10 20:37:42 +07:00
|
|
|
uinfo->value.integer.max = max;
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_info_volsw - single mixer info callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
2011-10-05 14:29:23 +07:00
|
|
|
* Callback to provide information about a single mixer control, or a double
|
|
|
|
* mixer control that spans 2 registers.
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2010-05-10 18:39:24 +07:00
|
|
|
int platform_max;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2010-05-10 18:39:24 +07:00
|
|
|
if (!mc->platform_max)
|
|
|
|
mc->platform_max = mc->max;
|
|
|
|
platform_max = mc->platform_max;
|
|
|
|
|
|
|
|
if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
|
2008-01-10 20:37:42 +07:00
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
|
|
|
else
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
|
2011-10-05 14:29:23 +07:00
|
|
|
uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
|
2006-10-06 23:31:09 +07:00
|
|
|
uinfo->value.integer.min = 0;
|
2010-05-10 18:39:24 +07:00
|
|
|
uinfo->value.integer.max = platform_max;
|
2006-10-06 23:31:09 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_get_volsw - single mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
2011-10-05 14:29:24 +07:00
|
|
|
* Callback to get the value of a single mixer control, or a double mixer
|
|
|
|
* control that spans 2 registers.
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2006-10-06 23:31:09 +07:00
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int reg = mc->reg;
|
2011-10-05 14:29:24 +07:00
|
|
|
unsigned int reg2 = mc->rreg;
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int rshift = mc->rshift;
|
2008-07-29 17:42:26 +07:00
|
|
|
int max = mc->max;
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
|
|
|
unsigned int invert = mc->invert;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
(snd_soc_read(codec, reg) >> shift) & mask;
|
2011-10-05 14:29:24 +07:00
|
|
|
if (invert)
|
2006-10-06 23:31:09 +07:00
|
|
|
ucontrol->value.integer.value[0] =
|
2008-01-10 20:37:42 +07:00
|
|
|
max - ucontrol->value.integer.value[0];
|
2011-10-05 14:29:24 +07:00
|
|
|
|
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
|
|
|
if (reg == reg2)
|
|
|
|
ucontrol->value.integer.value[1] =
|
|
|
|
(snd_soc_read(codec, reg) >> rshift) & mask;
|
|
|
|
else
|
|
|
|
ucontrol->value.integer.value[1] =
|
|
|
|
(snd_soc_read(codec, reg2) >> shift) & mask;
|
|
|
|
if (invert)
|
2006-10-06 23:31:09 +07:00
|
|
|
ucontrol->value.integer.value[1] =
|
2008-01-10 20:37:42 +07:00
|
|
|
max - ucontrol->value.integer.value[1];
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_volsw - single mixer put callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
2011-10-05 14:29:25 +07:00
|
|
|
* Callback to set the value of a single mixer control, or a double mixer
|
|
|
|
* control that spans 2 registers.
|
2006-10-06 23:31:09 +07:00
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2006-10-06 23:31:09 +07:00
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int reg = mc->reg;
|
2011-10-05 14:29:25 +07:00
|
|
|
unsigned int reg2 = mc->rreg;
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int rshift = mc->rshift;
|
2008-07-29 17:42:26 +07:00
|
|
|
int max = mc->max;
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
|
|
|
unsigned int invert = mc->invert;
|
2011-10-05 14:29:25 +07:00
|
|
|
int err;
|
|
|
|
bool type_2r = 0;
|
|
|
|
unsigned int val2 = 0;
|
|
|
|
unsigned int val, val_mask;
|
2006-10-06 23:31:09 +07:00
|
|
|
|
|
|
|
val = (ucontrol->value.integer.value[0] & mask);
|
|
|
|
if (invert)
|
2008-01-10 20:37:42 +07:00
|
|
|
val = max - val;
|
2006-10-06 23:31:09 +07:00
|
|
|
val_mask = mask << shift;
|
|
|
|
val = val << shift;
|
2011-10-05 14:29:25 +07:00
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
2006-10-06 23:31:09 +07:00
|
|
|
val2 = (ucontrol->value.integer.value[1] & mask);
|
|
|
|
if (invert)
|
2008-01-10 20:37:42 +07:00
|
|
|
val2 = max - val2;
|
2011-10-05 14:29:25 +07:00
|
|
|
if (reg == reg2) {
|
|
|
|
val_mask |= mask << rshift;
|
|
|
|
val |= val2 << rshift;
|
|
|
|
} else {
|
|
|
|
val2 = val2 << shift;
|
|
|
|
type_2r = 1;
|
|
|
|
}
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
2009-10-30 18:34:03 +07:00
|
|
|
err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
|
2008-05-19 17:32:25 +07:00
|
|
|
if (err < 0)
|
2006-10-06 23:31:09 +07:00
|
|
|
return err;
|
|
|
|
|
2011-10-05 14:29:25 +07:00
|
|
|
if (type_2r)
|
|
|
|
err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return err;
|
|
|
|
}
|
2011-10-05 14:29:25 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2012-03-30 22:43:55 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_get_volsw_sx - single mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to get the value of a single mixer control, or a double mixer
|
|
|
|
* control that spans 2 registers.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int reg2 = mc->rreg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int rshift = mc->rshift;
|
|
|
|
int max = mc->max;
|
|
|
|
int min = mc->min;
|
|
|
|
int mask = (1 << (fls(min + max) - 1)) - 1;
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
((snd_soc_read(codec, reg) >> shift) - min) & mask;
|
|
|
|
|
|
|
|
if (snd_soc_volsw_is_stereo(mc))
|
|
|
|
ucontrol->value.integer.value[1] =
|
|
|
|
((snd_soc_read(codec, reg2) >> rshift) - min) & mask;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_volsw_sx - double mixer set callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to set the value of a double mixer control that spans 2 registers.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int reg2 = mc->rreg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int rshift = mc->rshift;
|
|
|
|
int max = mc->max;
|
|
|
|
int min = mc->min;
|
|
|
|
int mask = (1 << (fls(min + max) - 1)) - 1;
|
2012-04-03 23:33:50 +07:00
|
|
|
int err = 0;
|
2012-03-30 22:43:55 +07:00
|
|
|
unsigned short val, val_mask, val2 = 0;
|
|
|
|
|
|
|
|
val_mask = mask << shift;
|
|
|
|
val = (ucontrol->value.integer.value[0] + min) & mask;
|
|
|
|
val = val << shift;
|
|
|
|
|
|
|
|
if (snd_soc_update_bits_locked(codec, reg, val_mask, val))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (snd_soc_volsw_is_stereo(mc)) {
|
|
|
|
val_mask = mask << rshift;
|
|
|
|
val2 = (ucontrol->value.integer.value[1] + min) & mask;
|
|
|
|
val2 = val2 << rshift;
|
|
|
|
|
|
|
|
if (snd_soc_update_bits_locked(codec, reg2, val_mask, val2))
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
|
|
|
|
|
2008-05-28 23:58:05 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_info_volsw_s8 - signed mixer info callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information about a signed mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2010-05-10 18:39:24 +07:00
|
|
|
int platform_max;
|
2008-07-29 17:42:26 +07:00
|
|
|
int min = mc->min;
|
2008-05-28 23:58:05 +07:00
|
|
|
|
2010-05-10 18:39:24 +07:00
|
|
|
if (!mc->platform_max)
|
|
|
|
mc->platform_max = mc->max;
|
|
|
|
platform_max = mc->platform_max;
|
|
|
|
|
2008-05-28 23:58:05 +07:00
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = 2;
|
|
|
|
uinfo->value.integer.min = 0;
|
2010-05-10 18:39:24 +07:00
|
|
|
uinfo->value.integer.max = platform_max - min;
|
2008-05-28 23:58:05 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_get_volsw_s8 - signed mixer get callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2008-05-28 23:58:05 +07:00
|
|
|
*
|
|
|
|
* Callback to get the value of a signed mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2008-05-28 23:58:05 +07:00
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int reg = mc->reg;
|
2008-07-29 17:42:26 +07:00
|
|
|
int min = mc->min;
|
2008-05-28 23:58:05 +07:00
|
|
|
int val = snd_soc_read(codec, reg);
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
((signed char)(val & 0xff))-min;
|
|
|
|
ucontrol->value.integer.value[1] =
|
|
|
|
((signed char)((val >> 8) & 0xff))-min;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_volsw_sgn - signed mixer put callback
|
|
|
|
* @kcontrol: mixer control
|
2009-01-01 19:18:17 +07:00
|
|
|
* @ucontrol: control element information
|
2008-05-28 23:58:05 +07:00
|
|
|
*
|
|
|
|
* Callback to set the value of a signed mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
2008-07-29 17:42:26 +07:00
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
2008-05-28 23:58:05 +07:00
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2008-07-29 21:22:24 +07:00
|
|
|
unsigned int reg = mc->reg;
|
2008-07-29 17:42:26 +07:00
|
|
|
int min = mc->min;
|
2009-06-07 12:49:11 +07:00
|
|
|
unsigned int val;
|
2008-05-28 23:58:05 +07:00
|
|
|
|
|
|
|
val = (ucontrol->value.integer.value[0]+min) & 0xff;
|
|
|
|
val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
|
|
|
|
|
2009-10-30 18:34:03 +07:00
|
|
|
return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
|
2008-05-28 23:58:05 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
|
|
|
|
|
2012-05-31 21:18:01 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_info_volsw_range - single mixer info callback with range.
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information, within a range, about a single
|
|
|
|
* mixer control.
|
|
|
|
*
|
|
|
|
* returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
int platform_max;
|
|
|
|
int min = mc->min;
|
|
|
|
|
|
|
|
if (!mc->platform_max)
|
|
|
|
mc->platform_max = mc->max;
|
|
|
|
platform_max = mc->platform_max;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = platform_max - min;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_volsw_range - single mixer put value callback with range.
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to set the value, within a range, for a single mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
int min = mc->min;
|
|
|
|
int max = mc->max;
|
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
|
|
|
unsigned int invert = mc->invert;
|
|
|
|
unsigned int val, val_mask;
|
|
|
|
|
|
|
|
val = ((ucontrol->value.integer.value[0] + min) & mask);
|
|
|
|
if (invert)
|
|
|
|
val = max - val;
|
|
|
|
val_mask = mask << shift;
|
|
|
|
val = val << shift;
|
|
|
|
|
|
|
|
return snd_soc_update_bits_locked(codec, reg, val_mask, val);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_get_volsw_range - single mixer get callback with range
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to get the value, within a range, of a single mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
int min = mc->min;
|
|
|
|
int max = mc->max;
|
|
|
|
unsigned int mask = (1 << fls(max)) - 1;
|
|
|
|
unsigned int invert = mc->invert;
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
(snd_soc_read(codec, reg) >> shift) & mask;
|
|
|
|
if (invert)
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
max - ucontrol->value.integer.value[0];
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
|
|
ucontrol->value.integer.value[0] - min;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
|
|
|
|
|
2010-05-07 18:05:49 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_limit_volume - Set new limit to an existing volume control.
|
|
|
|
*
|
|
|
|
* @codec: where to look for the control
|
|
|
|
* @name: Name of the control
|
|
|
|
* @max: new maximum limit
|
|
|
|
*
|
|
|
|
* Return 0 for success, else error.
|
|
|
|
*/
|
|
|
|
int snd_soc_limit_volume(struct snd_soc_codec *codec,
|
|
|
|
const char *name, int max)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_card *card = codec->card->snd_card;
|
2010-05-07 18:05:49 +07:00
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
struct soc_mixer_control *mc;
|
|
|
|
int found = 0;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/* Sanity check for name and max */
|
|
|
|
if (unlikely(!name || max <= 0))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
list_for_each_entry(kctl, &card->controls, list) {
|
|
|
|
if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found) {
|
|
|
|
mc = (struct soc_mixer_control *)kctl->private_value;
|
|
|
|
if (max <= mc->max) {
|
2010-05-10 18:39:24 +07:00
|
|
|
mc->platform_max = max;
|
2010-05-07 18:05:49 +07:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
|
|
|
|
|
2011-10-11 00:31:26 +07:00
|
|
|
int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct soc_bytes *params = (void *)kcontrol->private_value;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
|
|
|
|
uinfo->count = params->num_regs * codec->val_bytes;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
|
|
|
|
|
|
|
|
int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_bytes *params = (void *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (codec->using_regmap)
|
|
|
|
ret = regmap_raw_read(codec->control_data, params->base,
|
|
|
|
ucontrol->value.bytes.data,
|
|
|
|
params->num_regs * codec->val_bytes);
|
|
|
|
else
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
2012-02-18 07:20:33 +07:00
|
|
|
/* Hide any masked bytes to ensure consistent data reporting */
|
|
|
|
if (ret == 0 && params->mask) {
|
|
|
|
switch (codec->val_bytes) {
|
|
|
|
case 1:
|
|
|
|
ucontrol->value.bytes.data[0] &= ~params->mask;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
((u16 *)(&ucontrol->value.bytes.data))[0]
|
|
|
|
&= ~params->mask;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
((u32 *)(&ucontrol->value.bytes.data))[0]
|
|
|
|
&= ~params->mask;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-11 00:31:26 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
|
|
|
|
|
|
|
|
int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_bytes *params = (void *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
2012-02-18 07:20:33 +07:00
|
|
|
int ret, len;
|
|
|
|
unsigned int val;
|
|
|
|
void *data;
|
2011-10-11 00:31:26 +07:00
|
|
|
|
2012-02-18 07:20:33 +07:00
|
|
|
if (!codec->using_regmap)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
data = ucontrol->value.bytes.data;
|
|
|
|
len = params->num_regs * codec->val_bytes;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we've got a mask then we need to preserve the register
|
|
|
|
* bits. We shouldn't modify the incoming data so take a
|
|
|
|
* copy.
|
|
|
|
*/
|
|
|
|
if (params->mask) {
|
|
|
|
ret = regmap_read(codec->control_data, params->base, &val);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
val &= params->mask;
|
|
|
|
|
|
|
|
data = kmemdup(data, len, GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
switch (codec->val_bytes) {
|
|
|
|
case 1:
|
|
|
|
((u8 *)data)[0] &= ~params->mask;
|
|
|
|
((u8 *)data)[0] |= val;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
((u16 *)data)[0] &= cpu_to_be16(~params->mask);
|
|
|
|
((u16 *)data)[0] |= cpu_to_be16(val);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
((u32 *)data)[0] &= cpu_to_be32(~params->mask);
|
|
|
|
((u32 *)data)[0] |= cpu_to_be32(val);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = regmap_raw_write(codec->control_data, params->base,
|
|
|
|
data, len);
|
|
|
|
|
|
|
|
if (params->mask)
|
|
|
|
kfree(data);
|
2011-10-11 00:31:26 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
|
|
|
|
|
2012-04-20 16:32:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_info_xr_sx - signed multi register info callback
|
|
|
|
* @kcontrol: mreg control
|
|
|
|
* @uinfo: control element information
|
|
|
|
*
|
|
|
|
* Callback to provide information of a control that can
|
|
|
|
* span multiple codec registers which together
|
|
|
|
* forms a single signed value in a MSB/LSB manner.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct soc_mreg_control *mc =
|
|
|
|
(struct soc_mreg_control *)kcontrol->private_value;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.integer.min = mc->min;
|
|
|
|
uinfo->value.integer.max = mc->max;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_get_xr_sx - signed multi register get callback
|
|
|
|
* @kcontrol: mreg control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to get the value of a control that can span
|
|
|
|
* multiple codec registers which together forms a single
|
|
|
|
* signed value in a MSB/LSB manner. The control supports
|
|
|
|
* specifying total no of bits used to allow for bitfields
|
|
|
|
* across the multiple codec registers.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mreg_control *mc =
|
|
|
|
(struct soc_mreg_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int regbase = mc->regbase;
|
|
|
|
unsigned int regcount = mc->regcount;
|
|
|
|
unsigned int regwshift = codec->driver->reg_word_size * BITS_PER_BYTE;
|
|
|
|
unsigned int regwmask = (1<<regwshift)-1;
|
|
|
|
unsigned int invert = mc->invert;
|
|
|
|
unsigned long mask = (1UL<<mc->nbits)-1;
|
|
|
|
long min = mc->min;
|
|
|
|
long max = mc->max;
|
|
|
|
long val = 0;
|
|
|
|
unsigned long regval;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < regcount; i++) {
|
|
|
|
regval = snd_soc_read(codec, regbase+i) & regwmask;
|
|
|
|
val |= regval << (regwshift*(regcount-i-1));
|
|
|
|
}
|
|
|
|
val &= mask;
|
|
|
|
if (min < 0 && val > max)
|
|
|
|
val |= ~mask;
|
|
|
|
if (invert)
|
|
|
|
val = max - val;
|
|
|
|
ucontrol->value.integer.value[0] = val;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_xr_sx - signed multi register get callback
|
|
|
|
* @kcontrol: mreg control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback to set the value of a control that can span
|
|
|
|
* multiple codec registers which together forms a single
|
|
|
|
* signed value in a MSB/LSB manner. The control supports
|
|
|
|
* specifying total no of bits used to allow for bitfields
|
|
|
|
* across the multiple codec registers.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mreg_control *mc =
|
|
|
|
(struct soc_mreg_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int regbase = mc->regbase;
|
|
|
|
unsigned int regcount = mc->regcount;
|
|
|
|
unsigned int regwshift = codec->driver->reg_word_size * BITS_PER_BYTE;
|
|
|
|
unsigned int regwmask = (1<<regwshift)-1;
|
|
|
|
unsigned int invert = mc->invert;
|
|
|
|
unsigned long mask = (1UL<<mc->nbits)-1;
|
|
|
|
long max = mc->max;
|
|
|
|
long val = ucontrol->value.integer.value[0];
|
|
|
|
unsigned int i, regval, regmask;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (invert)
|
|
|
|
val = max - val;
|
|
|
|
val &= mask;
|
|
|
|
for (i = 0; i < regcount; i++) {
|
|
|
|
regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
|
|
|
|
regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
|
|
|
|
err = snd_soc_update_bits_locked(codec, regbase+i,
|
|
|
|
regmask, regval);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
|
|
|
|
|
2012-04-20 16:32:44 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_get_strobe - strobe get callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback get the value of a strobe mixer control.
|
|
|
|
*
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int mask = 1 << shift;
|
|
|
|
unsigned int invert = mc->invert != 0;
|
|
|
|
unsigned int val = snd_soc_read(codec, reg) & mask;
|
|
|
|
|
|
|
|
if (shift != 0 && val != 0)
|
|
|
|
val = val >> shift;
|
|
|
|
ucontrol->value.enumerated.item[0] = val ^ invert;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_put_strobe - strobe put callback
|
|
|
|
* @kcontrol: mixer control
|
|
|
|
* @ucontrol: control element information
|
|
|
|
*
|
|
|
|
* Callback strobe a register bit to high then low (or the inverse)
|
|
|
|
* in one pass of a single mixer enum control.
|
|
|
|
*
|
|
|
|
* Returns 1 for success.
|
|
|
|
*/
|
|
|
|
int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct soc_mixer_control *mc =
|
|
|
|
(struct soc_mixer_control *)kcontrol->private_value;
|
|
|
|
struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int reg = mc->reg;
|
|
|
|
unsigned int shift = mc->shift;
|
|
|
|
unsigned int mask = 1 << shift;
|
|
|
|
unsigned int invert = mc->invert != 0;
|
|
|
|
unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
|
|
|
|
unsigned int val1 = (strobe ^ invert) ? mask : 0;
|
|
|
|
unsigned int val2 = (strobe ^ invert) ? 0 : mask;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = snd_soc_update_bits_locked(codec, reg, mask, val1);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = snd_soc_update_bits_locked(codec, reg, mask, val2);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_sysclk - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @clk_id: DAI specific clock ID
|
|
|
|
* @freq: new clock frequency in Hz
|
|
|
|
* @dir: new clock direction - input/output.
|
|
|
|
*
|
|
|
|
* Configures the DAI master (MCLK) or system (SYSCLK) clocking.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
|
|
|
|
unsigned int freq, int dir)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->set_sysclk)
|
|
|
|
return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
|
2011-03-08 03:58:11 +07:00
|
|
|
else if (dai->codec && dai->codec->driver->set_sysclk)
|
2011-08-25 02:09:01 +07:00
|
|
|
return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
|
2011-03-08 03:58:11 +07:00
|
|
|
freq, dir);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
|
|
|
|
|
2011-03-08 03:58:11 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_codec_set_sysclk - configure CODEC system or master clock.
|
|
|
|
* @codec: CODEC
|
|
|
|
* @clk_id: DAI specific clock ID
|
2011-08-25 02:09:01 +07:00
|
|
|
* @source: Source for the clock
|
2011-03-08 03:58:11 +07: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-25 02:09:01 +07:00
|
|
|
int source, unsigned int freq, int dir)
|
2011-03-08 03:58:11 +07:00
|
|
|
{
|
|
|
|
if (codec->driver->set_sysclk)
|
2011-08-25 02:09:01 +07:00
|
|
|
return codec->driver->set_sysclk(codec, clk_id, source,
|
|
|
|
freq, dir);
|
2011-03-08 03:58:11 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_clkdiv - configure DAI clock dividers.
|
|
|
|
* @dai: DAI
|
2009-01-01 19:18:17 +07:00
|
|
|
* @div_id: DAI specific clock divider ID
|
2008-07-08 19:19:13 +07:00
|
|
|
* @div: new clock divisor.
|
|
|
|
*
|
|
|
|
* Configures the clock dividers. This is used to derive the best DAI bit and
|
|
|
|
* frame clocks from the system or master clock. It's best to set the DAI bit
|
|
|
|
* and frame clocks as low as possible to save system power.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
|
|
|
|
int div_id, int div)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->set_clkdiv)
|
|
|
|
return dai->driver->ops->set_clkdiv(dai, div_id, div);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_pll - configure DAI PLL.
|
|
|
|
* @dai: DAI
|
|
|
|
* @pll_id: DAI specific PLL ID
|
2009-09-06 00:52:16 +07:00
|
|
|
* @source: DAI specific source for the PLL
|
2008-07-08 19:19:13 +07:00
|
|
|
* @freq_in: PLL input clock frequency in Hz
|
|
|
|
* @freq_out: requested PLL output clock frequency in Hz
|
|
|
|
*
|
|
|
|
* Configures and enables PLL to generate output clock based on input clock.
|
|
|
|
*/
|
2009-09-06 00:52:16 +07:00
|
|
|
int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
|
|
|
|
unsigned int freq_in, unsigned int freq_out)
|
2008-07-08 19:19:13 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->set_pll)
|
|
|
|
return dai->driver->ops->set_pll(dai, pll_id, source,
|
2009-09-06 00:52:16 +07:00
|
|
|
freq_in, freq_out);
|
2011-03-08 03:58:11 +07: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 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
|
|
|
|
|
2011-03-08 03:58:11 +07: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);
|
|
|
|
|
2008-07-08 19:19:13 +07: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 23:59:40 +07:00
|
|
|
if (dai->driver == NULL)
|
2008-07-08 19:19:13 +07:00
|
|
|
return -EINVAL;
|
2012-03-08 23:59:40 +07:00
|
|
|
if (dai->driver->ops->set_fmt == NULL)
|
|
|
|
return -ENOTSUPP;
|
|
|
|
return dai->driver->ops->set_fmt(dai, fmt);
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_tdm_slot - configure DAI TDM.
|
|
|
|
* @dai: DAI
|
2009-06-16 07:44:31 +07:00
|
|
|
* @tx_mask: bitmask representing active TX slots.
|
|
|
|
* @rx_mask: bitmask representing active RX slots.
|
2008-07-08 19:19:13 +07:00
|
|
|
* @slots: Number of slots in use.
|
2009-06-16 07:44:31 +07:00
|
|
|
* @slot_width: Width in bits for each slot.
|
2008-07-08 19:19:13 +07:00
|
|
|
*
|
|
|
|
* Configures a DAI for TDM operation. Both mask and slots are codec and DAI
|
|
|
|
* specific.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
|
2009-06-16 07:44:31 +07:00
|
|
|
unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
|
2008-07-08 19:19:13 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07: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 07:44:31 +07:00
|
|
|
slots, slot_width);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
|
|
|
|
|
2009-09-12 00:16:29 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_channel_map - configure DAI audio channel map
|
|
|
|
* @dai: DAI
|
|
|
|
* @tx_num: how many TX channels
|
|
|
|
* @tx_slot: pointer to an array which imply the TX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
* @rx_num: how many RX channels
|
|
|
|
* @rx_slot: pointer to an array which imply the RX slot number channel
|
|
|
|
* 0~num-1 uses
|
|
|
|
*
|
|
|
|
* configure the relationship between channel number and TDM slot number.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
|
|
|
|
unsigned int tx_num, unsigned int *tx_slot,
|
|
|
|
unsigned int rx_num, unsigned int *rx_slot)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->set_channel_map)
|
|
|
|
return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
|
2009-09-12 00:16:29 +07:00
|
|
|
rx_num, rx_slot);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
|
|
|
|
|
2008-07-08 19:19:13 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_dai_set_tristate - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @tristate: tristate enable
|
|
|
|
*
|
|
|
|
* Tristates the DAI so that others can use it.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->set_tristate)
|
|
|
|
return dai->driver->ops->set_tristate(dai, tristate);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dai_digital_mute - configure DAI system or master clock.
|
|
|
|
* @dai: DAI
|
|
|
|
* @mute: mute enable
|
|
|
|
*
|
|
|
|
* Mutes the DAI DAC.
|
|
|
|
*/
|
|
|
|
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
|
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
if (dai->driver && dai->driver->ops->digital_mute)
|
|
|
|
return dai->driver->ops->digital_mute(dai, mute);
|
2008-07-08 19:19:13 +07:00
|
|
|
else
|
2012-04-14 01:16:03 +07:00
|
|
|
return -ENOTSUPP;
|
2008-07-08 19:19:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
|
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_card - Register a card with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @card: Card to register
|
2008-11-28 20:29:45 +07:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 20:52:48 +07:00
|
|
|
int snd_soc_register_card(struct snd_soc_card *card)
|
2008-11-28 20:29:45 +07:00
|
|
|
{
|
2012-03-15 04:18:39 +07:00
|
|
|
int i, ret;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
if (!card->name || !card->dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-12-22 00:40:59 +07:00
|
|
|
for (i = 0; i < card->num_links; i++) {
|
|
|
|
struct snd_soc_dai_link *link = &card->dai_link[i];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Codec must be specified by 1 of name or OF node,
|
|
|
|
* not both or neither.
|
|
|
|
*/
|
|
|
|
if (!!link->codec_name == !!link->codec_of_node) {
|
|
|
|
dev_err(card->dev,
|
2012-01-09 19:09:29 +07:00
|
|
|
"Neither/both codec name/of_node are set for %s\n",
|
|
|
|
link->name);
|
2011-12-22 00:40:59 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 07:22:11 +07:00
|
|
|
/* Codec DAI name must be specified */
|
|
|
|
if (!link->codec_dai_name) {
|
|
|
|
dev_err(card->dev, "codec_dai_name not set for %s\n",
|
|
|
|
link->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2011-12-22 00:40:59 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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,
|
2012-01-09 19:09:29 +07:00
|
|
|
"Both platform name/of_node are set for %s\n", link->name);
|
2011-12-22 00:40:59 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 07:22:11 +07:00
|
|
|
* 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,
|
|
|
|
"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
|
2011-12-22 00:40:59 +07:00
|
|
|
*/
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 07:22:11 +07:00
|
|
|
if (!link->cpu_dai_name &&
|
|
|
|
!(link->cpu_name || link->cpu_of_node)) {
|
2011-12-22 00:40:59 +07:00
|
|
|
dev_err(card->dev,
|
ASoC: make snd_soc_dai_link more symmetrical
Prior to this patch, the CPU side of a DAI link was specified using a
single name. Often, this was the result of calling dev_name() on the
device providing the DAI, but in the case of a CPU DAI driver that
provided multiple DAIs, it needed to mix together both the device name
and some device-relative name, in order to form a single globally unique
name.
However, the CODEC side of the DAI link was specified using separate
fields for device (name or OF node) and device-relative DAI name.
This patch allows the CPU side of a DAI link to be specified in the same
way as the CODEC side, separating concepts of device and device-relative
DAI name.
I believe this will be important in multi-codec and/or dynamic PCM
scenarios, where a single CPU driver provides multiple DAIs, while also
booting using device tree, with accompanying desire not to hard-code the
CPU side device's name into the original .cpu_dai_name field.
Ideally, both the CPU DAI and CODEC DAI loops in soc_bind_dai_link()
would now be identical. However, two things prevent that at present:
1) The need to save rtd->codec for the CODEC side, which means we have
to search for the CODEC explicitly, and not just the CODEC side DAI.
2) Since we know the CODEC side DAI is part of a codec, and not just
a standalone DAI, it's slightly more efficient to convert .codec_name/
.codec_of_node into a codec first, and then compare each DAI's .codec
field, since this avoids strcmp() on each DAI's CODEC's name within
the loop.
However, the two loops are essentially semantically equivalent.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-05-26 07:22:11 +07:00
|
|
|
"Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
|
2012-01-09 19:09:29 +07:00
|
|
|
link->name);
|
2011-12-22 00:40:59 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-04 00:25:34 +07:00
|
|
|
dev_set_drvdata(card->dev, card);
|
|
|
|
|
2011-01-29 04:26:35 +07:00
|
|
|
snd_soc_initialize_card_lists(card);
|
|
|
|
|
2011-01-14 00:18:32 +07:00
|
|
|
soc_init_card_debugfs(card);
|
|
|
|
|
2012-03-15 03:18:49 +07:00
|
|
|
card->rtd = devm_kzalloc(card->dev,
|
|
|
|
sizeof(struct snd_soc_pcm_runtime) *
|
|
|
|
(card->num_links + card->num_aux_devs),
|
|
|
|
GFP_KERNEL);
|
2010-03-18 03:15:21 +07:00
|
|
|
if (card->rtd == NULL)
|
|
|
|
return -ENOMEM;
|
2012-04-18 00:00:11 +07:00
|
|
|
card->num_rtd = 0;
|
2010-11-25 22:47:38 +07:00
|
|
|
card->rtd_aux = &card->rtd[card->num_links];
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
for (i = 0; i < card->num_links; i++)
|
|
|
|
card->rtd[i].dai_link = &card->dai_link[i];
|
|
|
|
|
2008-11-28 20:29:45 +07:00
|
|
|
INIT_LIST_HEAD(&card->list);
|
2011-10-04 03:06:40 +07:00
|
|
|
INIT_LIST_HEAD(&card->dapm_dirty);
|
2008-11-28 20:29:45 +07:00
|
|
|
card->instantiated = 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_init(&card->mutex);
|
2012-03-07 17:38:26 +07:00
|
|
|
mutex_init(&card->dapm_mutex);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
ret = snd_soc_instantiate_card(card);
|
|
|
|
if (ret != 0)
|
|
|
|
soc_cleanup_card_debugfs(card);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2012-03-15 04:18:39 +07:00
|
|
|
return ret;
|
2008-11-28 20:29:45 +07:00
|
|
|
}
|
2011-01-14 20:52:48 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_card);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_card - Unregister a card with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @card: Card to unregister
|
2008-11-28 20:29:45 +07:00
|
|
|
*
|
|
|
|
*/
|
2011-01-14 20:52:48 +07:00
|
|
|
int snd_soc_unregister_card(struct snd_soc_card *card)
|
2008-11-28 20:29:45 +07:00
|
|
|
{
|
2011-01-14 00:18:02 +07:00
|
|
|
if (card->instantiated)
|
|
|
|
soc_cleanup_card_resources(card);
|
2008-11-28 20:29:45 +07:00
|
|
|
dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-14 20:52:48 +07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
|
2008-11-28 20:29:45 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/*
|
|
|
|
* Simplify DAI link configuration by removing ".-1" from device names
|
|
|
|
* and sanitizing names.
|
|
|
|
*/
|
2010-12-06 22:49:20 +07:00
|
|
|
static char *fmt_single_name(struct device *dev, int *id)
|
2010-03-18 03:15:21 +07:00
|
|
|
{
|
|
|
|
char *found, name[NAME_SIZE];
|
|
|
|
int id1, id2;
|
|
|
|
|
|
|
|
if (dev_name(dev) == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2010-12-06 22:42:17 +07:00
|
|
|
strlcpy(name, dev_name(dev), NAME_SIZE);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* are we a "%s.%d" name (platform and SPI components) */
|
|
|
|
found = strstr(name, dev->driver->name);
|
|
|
|
if (found) {
|
|
|
|
/* get ID */
|
|
|
|
if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
|
|
|
|
|
|
|
|
/* discard ID from name if ID == -1 */
|
|
|
|
if (*id == -1)
|
|
|
|
found[strlen(dev->driver->name)] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* I2C component devices are named "bus-addr" */
|
|
|
|
if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
|
|
|
|
char tmp[NAME_SIZE];
|
|
|
|
|
|
|
|
/* create unique ID number from I2C addr and bus */
|
2010-10-19 15:10:45 +07:00
|
|
|
*id = ((id1 & 0xffff) << 16) + id2;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* sanitize component name for DAI link creation */
|
|
|
|
snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
|
2010-12-06 22:42:17 +07:00
|
|
|
strlcpy(name, tmp, NAME_SIZE);
|
2010-03-18 03:15:21 +07:00
|
|
|
} else
|
|
|
|
*id = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kstrdup(name, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Simplify DAI link naming for single devices with multiple DAIs by removing
|
|
|
|
* any ".-1" and using the DAI name (instead of device name).
|
|
|
|
*/
|
|
|
|
static inline char *fmt_multiple_name(struct device *dev,
|
|
|
|
struct snd_soc_dai_driver *dai_drv)
|
|
|
|
{
|
|
|
|
if (dai_drv->name == NULL) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_err("asoc: error - multiple DAI %s registered with no name\n",
|
2010-03-18 03:15:21 +07:00
|
|
|
dev_name(dev));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kstrdup(dai_drv->name, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_dai - Register a DAI with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @dai: DAI to register
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
int snd_soc_register_dai(struct device *dev,
|
|
|
|
struct snd_soc_dai_driver *dai_drv)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
2012-04-09 23:29:19 +07:00
|
|
|
struct snd_soc_codec *codec;
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
dev_dbg(dev, "dai register %s\n", dev_name(dev));
|
2008-12-01 06:31:24 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
|
|
|
|
if (dai == NULL)
|
2011-04-20 15:00:51 +07:00
|
|
|
return -ENOMEM;
|
2008-12-01 06:31:24 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* create DAI component name */
|
|
|
|
dai->name = fmt_single_name(dev, &dai->id);
|
|
|
|
if (dai->name == NULL) {
|
|
|
|
kfree(dai);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-03-03 08:41:00 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
dai->dev = dev;
|
|
|
|
dai->driver = dai_drv;
|
2012-03-07 18:47:41 +07:00
|
|
|
dai->dapm.dev = dev;
|
2010-03-18 03:15:21 +07:00
|
|
|
if (!dai->driver->ops)
|
|
|
|
dai->driver->ops = &null_dai_ops;
|
2008-12-01 06:31:24 +07:00
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
2012-04-09 23:29:19 +07:00
|
|
|
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (codec->dev == dev) {
|
|
|
|
dev_dbg(dev, "Mapped DAI %s to CODEC %s\n",
|
|
|
|
dai->name, codec->name);
|
|
|
|
dai->codec = codec;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-07 14:24:13 +07:00
|
|
|
if (!dai->codec)
|
|
|
|
dai->dapm.idle_bias_off = 1;
|
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
list_add(&dai->list, &dai_list);
|
2012-04-09 23:29:19 +07:00
|
|
|
|
2008-12-01 06:31:24 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Registered DAI '%s'\n", dai->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_dai);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_dai - Unregister a DAI from the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @dai: DAI to unregister
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
void snd_soc_unregister_dai(struct device *dev)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
|
|
|
|
list_for_each_entry(dai, &dai_list, list) {
|
|
|
|
if (dev == dai->dev)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
found:
|
2008-12-01 06:31:24 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_del(&dai->list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Unregistered DAI '%s'\n", dai->name);
|
2010-03-18 03:15:21 +07:00
|
|
|
kfree(dai->name);
|
|
|
|
kfree(dai);
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_register_dais - Register multiple DAIs with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @dai: Array of DAIs to register
|
|
|
|
* @count: Number of DAIs
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
int snd_soc_register_dais(struct device *dev,
|
|
|
|
struct snd_soc_dai_driver *dai_drv, size_t count)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
2012-04-09 23:29:19 +07:00
|
|
|
struct snd_soc_codec *codec;
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_dai *dai;
|
|
|
|
int i, ret = 0;
|
|
|
|
|
2010-08-18 06:30:30 +07:00
|
|
|
dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
|
2008-12-01 06:31:24 +07:00
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
|
2010-11-03 14:04:45 +07:00
|
|
|
if (dai == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* create DAI component name */
|
|
|
|
dai->name = fmt_multiple_name(dev, &dai_drv[i]);
|
|
|
|
if (dai->name == NULL) {
|
|
|
|
kfree(dai);
|
|
|
|
ret = -EINVAL;
|
2008-12-01 06:31:24 +07:00
|
|
|
goto err;
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
dai->dev = dev;
|
|
|
|
dai->driver = &dai_drv[i];
|
2010-10-12 21:43:21 +07:00
|
|
|
if (dai->driver->id)
|
|
|
|
dai->id = dai->driver->id;
|
|
|
|
else
|
|
|
|
dai->id = i;
|
2012-03-07 18:47:41 +07:00
|
|
|
dai->dapm.dev = dev;
|
2010-03-18 03:15:21 +07:00
|
|
|
if (!dai->driver->ops)
|
|
|
|
dai->driver->ops = &null_dai_ops;
|
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
2012-04-09 23:29:19 +07:00
|
|
|
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (codec->dev == dev) {
|
|
|
|
dev_dbg(dev, "Mapped DAI %s to CODEC %s\n",
|
|
|
|
dai->name, codec->name);
|
|
|
|
dai->codec = codec;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-07 14:24:13 +07:00
|
|
|
if (!dai->codec)
|
|
|
|
dai->dapm.idle_bias_off = 1;
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
list_add(&dai->list, &dai_list);
|
2012-04-09 23:29:19 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Registered DAI '%s'\n", dai->name);
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (i--; i >= 0; i--)
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_soc_unregister_dai(dev);
|
2008-12-01 06:31:24 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_dais);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @dai: Array of DAIs to unregister
|
|
|
|
* @count: Number of DAIs
|
2008-12-01 06:31:24 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
void snd_soc_unregister_dais(struct device *dev, size_t count)
|
2008-12-01 06:31:24 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
2010-03-18 03:15:21 +07:00
|
|
|
snd_soc_unregister_dai(dev);
|
2008-12-01 06:31:24 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
|
|
|
|
|
2008-12-04 02:40:30 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_platform - Register a platform with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @platform: platform to register
|
2008-12-04 02:40:30 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
int snd_soc_register_platform(struct device *dev,
|
|
|
|
struct snd_soc_platform_driver *platform_drv)
|
2008-12-04 02:40:30 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
|
|
|
dev_dbg(dev, "platform register %s\n", dev_name(dev));
|
|
|
|
|
|
|
|
platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
|
|
|
|
if (platform == NULL)
|
2011-04-20 15:00:51 +07:00
|
|
|
return -ENOMEM;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
|
|
|
/* create platform component name */
|
|
|
|
platform->name = fmt_single_name(dev, &platform->id);
|
|
|
|
if (platform->name == NULL) {
|
|
|
|
kfree(platform);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-12-04 02:40:30 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
platform->dev = dev;
|
|
|
|
platform->driver = platform_drv;
|
2011-07-05 04:10:52 +07:00
|
|
|
platform->dapm.dev = dev;
|
|
|
|
platform->dapm.platform = platform;
|
2011-07-25 17:15:15 +07:00
|
|
|
platform->dapm.stream_event = platform_drv->stream_event;
|
2012-03-07 01:16:18 +07:00
|
|
|
mutex_init(&platform->mutex);
|
2008-12-04 02:40:30 +07:00
|
|
|
|
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_add(&platform->list, &platform_list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Registered platform '%s'\n", platform->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_platform);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_platform - Unregister a platform from the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @platform: platform to unregister
|
2008-12-04 02:40:30 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
void snd_soc_unregister_platform(struct device *dev)
|
2008-12-04 02:40:30 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
|
|
|
|
list_for_each_entry(platform, &platform_list, list) {
|
|
|
|
if (dev == platform->dev)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
found:
|
2008-12-04 02:40:30 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_del(&platform->list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Unregistered platform '%s'\n", platform->name);
|
2010-03-18 03:15:21 +07:00
|
|
|
kfree(platform->name);
|
|
|
|
kfree(platform);
|
2008-12-04 02:40:30 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
|
|
|
|
|
2009-05-09 22:22:58 +07: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];
|
|
|
|
}
|
|
|
|
|
2008-12-10 21:32:45 +07:00
|
|
|
/**
|
|
|
|
* snd_soc_register_codec - Register a codec with the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @codec: codec to register
|
2008-12-10 21:32:45 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
int snd_soc_register_codec(struct device *dev,
|
2010-12-02 23:21:08 +07:00
|
|
|
const struct snd_soc_codec_driver *codec_drv,
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
int num_dai)
|
2008-12-10 21:32:45 +07:00
|
|
|
{
|
2010-12-02 23:11:05 +07:00
|
|
|
size_t reg_size;
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
int ret, i;
|
2009-05-09 22:22:58 +07:00
|
|
|
|
2010-03-18 03:15:21 +07: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 21:32:45 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* create CODEC component name */
|
|
|
|
codec->name = fmt_single_name(dev, &codec->id);
|
|
|
|
if (codec->name == NULL) {
|
|
|
|
kfree(codec);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2010-12-02 21:53:01 +07:00
|
|
|
if (codec_drv->compress_type)
|
|
|
|
codec->compress_type = codec_drv->compress_type;
|
|
|
|
else
|
|
|
|
codec->compress_type = SND_SOC_FLAT_COMPRESSION;
|
|
|
|
|
2010-12-02 23:15:29 +07:00
|
|
|
codec->write = codec_drv->write;
|
|
|
|
codec->read = codec_drv->read;
|
2011-01-13 19:20:38 +07:00
|
|
|
codec->volatile_register = codec_drv->volatile_register;
|
|
|
|
codec->readable_register = codec_drv->readable_register;
|
2011-03-24 20:45:17 +07:00
|
|
|
codec->writable_register = codec_drv->writable_register;
|
2012-02-08 20:20:50 +07:00
|
|
|
codec->ignore_pmdown_time = codec_drv->ignore_pmdown_time;
|
2010-11-05 20:53:46 +07:00
|
|
|
codec->dapm.bias_level = SND_SOC_BIAS_OFF;
|
|
|
|
codec->dapm.dev = dev;
|
|
|
|
codec->dapm.codec = codec;
|
2011-01-18 23:14:44 +07:00
|
|
|
codec->dapm.seq_notifier = codec_drv->seq_notifier;
|
2011-07-25 17:15:15 +07:00
|
|
|
codec->dapm.stream_event = codec_drv->stream_event;
|
2010-11-11 17:04:57 +07:00
|
|
|
codec->dev = dev;
|
|
|
|
codec->driver = codec_drv;
|
|
|
|
codec->num_dai = num_dai;
|
|
|
|
mutex_init(&codec->mutex);
|
2010-11-05 20:53:46 +07:00
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
/* allocate CODEC register cache */
|
|
|
|
if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
|
2010-12-02 23:11:05 +07:00
|
|
|
reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
|
2011-01-12 17:38:58 +07:00
|
|
|
codec->reg_size = reg_size;
|
2010-12-02 23:11:05 +07:00
|
|
|
/* it is necessary to make a copy of the default register cache
|
|
|
|
* because in the case of using a compression type that requires
|
|
|
|
* the default register cache to be marked as __devinitconst the
|
|
|
|
* kernel might have freed the array by the time we initialize
|
|
|
|
* the cache.
|
|
|
|
*/
|
2011-01-10 17:10:56 +07:00
|
|
|
if (codec_drv->reg_cache_default) {
|
|
|
|
codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
|
|
|
|
reg_size, GFP_KERNEL);
|
|
|
|
if (!codec->reg_def_copy) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
}
|
2009-05-09 22:22:58 +07:00
|
|
|
}
|
|
|
|
|
2011-01-13 19:20:38 +07:00
|
|
|
if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
|
|
|
|
if (!codec->volatile_register)
|
|
|
|
codec->volatile_register = snd_soc_default_volatile_register;
|
|
|
|
if (!codec->readable_register)
|
|
|
|
codec->readable_register = snd_soc_default_readable_register;
|
2011-03-24 20:45:17 +07:00
|
|
|
if (!codec->writable_register)
|
|
|
|
codec->writable_register = snd_soc_default_writable_register;
|
2011-01-13 19:20:38 +07:00
|
|
|
}
|
|
|
|
|
2010-03-18 03:15:21 +07:00
|
|
|
for (i = 0; i < num_dai; i++) {
|
|
|
|
fixup_codec_formats(&dai_drv[i].playback);
|
|
|
|
fixup_codec_formats(&dai_drv[i].capture);
|
|
|
|
}
|
|
|
|
|
2012-04-09 23:29:19 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_add(&codec->list, &codec_list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
2010-08-19 02:20:55 +07:00
|
|
|
/* register any DAIs */
|
|
|
|
if (num_dai) {
|
|
|
|
ret = snd_soc_register_dais(dev, dai_drv, num_dai);
|
|
|
|
if (ret < 0)
|
2012-04-09 23:29:19 +07:00
|
|
|
dev_err(codec->dev, "Failed to regster DAIs: %d\n",
|
|
|
|
ret);
|
2010-08-19 02:20:55 +07:00
|
|
|
}
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-12-10 21:32:45 +07:00
|
|
|
pr_debug("Registered codec '%s'\n", codec->name);
|
|
|
|
return 0;
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2010-12-02 23:11:06 +07:00
|
|
|
fail:
|
2010-03-18 03:15:21 +07:00
|
|
|
kfree(codec->name);
|
|
|
|
kfree(codec);
|
|
|
|
return ret;
|
2008-12-10 21:32:45 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_register_codec);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_unregister_codec - Unregister a codec from the ASoC core
|
|
|
|
*
|
2009-01-01 19:18:17 +07:00
|
|
|
* @codec: codec to unregister
|
2008-12-10 21:32:45 +07:00
|
|
|
*/
|
2010-03-18 03:15:21 +07:00
|
|
|
void snd_soc_unregister_codec(struct device *dev)
|
2008-12-10 21:32:45 +07:00
|
|
|
{
|
2010-03-18 03:15:21 +07:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
list_for_each_entry(codec, &codec_list, list) {
|
|
|
|
if (dev == codec->dev)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
found:
|
2010-08-19 02:20:55 +07:00
|
|
|
if (codec->num_dai)
|
|
|
|
for (i = 0; i < codec->num_dai; i++)
|
|
|
|
snd_soc_unregister_dai(dev);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2008-12-10 21:32:45 +07:00
|
|
|
mutex_lock(&client_mutex);
|
|
|
|
list_del(&codec->list);
|
|
|
|
mutex_unlock(&client_mutex);
|
|
|
|
|
|
|
|
pr_debug("Unregistered codec '%s'\n", codec->name);
|
2010-03-18 03:15:21 +07:00
|
|
|
|
2010-11-11 17:04:57 +07:00
|
|
|
snd_soc_cache_exit(codec);
|
2010-12-02 23:11:05 +07:00
|
|
|
kfree(codec->reg_def_copy);
|
2010-10-21 19:19:45 +07:00
|
|
|
kfree(codec->name);
|
2010-03-18 03:15:21 +07:00
|
|
|
kfree(codec);
|
2008-12-10 21:32:45 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
|
|
|
|
|
2011-12-13 05:55:34 +07:00
|
|
|
/* Retrieve a card's name from device tree */
|
|
|
|
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
|
|
|
|
const char *propname)
|
|
|
|
{
|
|
|
|
struct device_node *np = card->dev->of_node;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
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,
|
|
|
|
"Property '%s' could not be read: %d\n",
|
|
|
|
propname, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
|
|
|
|
|
2011-12-13 05:55:35 +07:00
|
|
|
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
|
|
|
|
const char *propname)
|
|
|
|
{
|
|
|
|
struct device_node *np = card->dev->of_node;
|
|
|
|
int num_routes;
|
|
|
|
struct snd_soc_dapm_route *routes;
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
num_routes = of_property_count_strings(np, propname);
|
2012-04-24 14:24:43 +07:00
|
|
|
if (num_routes < 0 || num_routes & 1) {
|
2011-12-13 05:55:35 +07:00
|
|
|
dev_err(card->dev,
|
2012-04-24 14:24:43 +07:00
|
|
|
"Property '%s' does not exist or its length is not even\n",
|
|
|
|
propname);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
num_routes /= 2;
|
|
|
|
if (!num_routes) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"Property '%s's length is zero\n",
|
|
|
|
propname);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!routes) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"Could not allocate DAPM route table\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_routes; i++) {
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
|
|
|
2 * i, &routes[i].sink);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, 2 * i, ret);
|
2012-07-11 22:36:34 +07:00
|
|
|
kfree(routes);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
ret = of_property_read_string_index(np, propname,
|
|
|
|
(2 * i) + 1, &routes[i].source);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(card->dev,
|
|
|
|
"Property '%s' index %d could not be read: %d\n",
|
|
|
|
propname, (2 * i) + 1, ret);
|
2012-07-11 22:36:34 +07:00
|
|
|
kfree(routes);
|
2011-12-13 05:55:35 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
card->num_dapm_routes = num_routes;
|
|
|
|
card->dapm_routes = routes;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
|
|
|
|
|
2008-12-10 13:47:22 +07:00
|
|
|
static int __init snd_soc_init(void)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2008-12-04 00:34:03 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-11 05:25:21 +07:00
|
|
|
snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
|
|
|
|
if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
|
2012-02-18 04:40:38 +07:00
|
|
|
pr_warn("ASoC: Failed to create debugfs directory\n");
|
2011-01-11 05:25:21 +07:00
|
|
|
snd_soc_debugfs_root = NULL;
|
2008-12-04 00:34:03 +07:00
|
|
|
}
|
2010-09-16 00:15:14 +07:00
|
|
|
|
2011-01-11 05:25:21 +07:00
|
|
|
if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
|
2010-09-16 00:15:14 +07:00
|
|
|
&codec_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
|
|
|
|
|
2011-01-11 05:25:21 +07:00
|
|
|
if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
|
2010-09-16 00:19:07 +07:00
|
|
|
&dai_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create DAI list debugfs file\n");
|
2010-09-16 00:22:40 +07:00
|
|
|
|
2011-01-11 05:25:21 +07:00
|
|
|
if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
|
2010-09-16 00:22:40 +07:00
|
|
|
&platform_list_fops))
|
|
|
|
pr_warn("ASoC: Failed to create platform list debugfs file\n");
|
2008-12-04 00:34:03 +07:00
|
|
|
#endif
|
|
|
|
|
2011-04-28 16:57:54 +07:00
|
|
|
snd_soc_util_init();
|
|
|
|
|
2006-10-06 23:31:09 +07:00
|
|
|
return platform_driver_register(&soc_driver);
|
|
|
|
}
|
2010-10-12 23:41:03 +07:00
|
|
|
module_init(snd_soc_init);
|
2006-10-06 23:31:09 +07:00
|
|
|
|
2008-12-01 05:11:24 +07:00
|
|
|
static void __exit snd_soc_exit(void)
|
2006-10-06 23:31:09 +07:00
|
|
|
{
|
2011-04-28 16:57:54 +07:00
|
|
|
snd_soc_util_exit();
|
|
|
|
|
2008-12-04 00:34:03 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-11 05:25:21 +07:00
|
|
|
debugfs_remove_recursive(snd_soc_debugfs_root);
|
2008-12-04 00:34:03 +07:00
|
|
|
#endif
|
2008-05-19 17:32:25 +07:00
|
|
|
platform_driver_unregister(&soc_driver);
|
2006-10-06 23:31:09 +07:00
|
|
|
}
|
|
|
|
module_exit(snd_soc_exit);
|
|
|
|
|
|
|
|
/* Module information */
|
2008-10-12 19:17:36 +07:00
|
|
|
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
|
2006-10-06 23:31:09 +07:00
|
|
|
MODULE_DESCRIPTION("ALSA SoC Core");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-04-14 18:33:36 +07:00
|
|
|
MODULE_ALIAS("platform:soc-audio");
|