2018-07-02 14:24:18 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0
|
|
|
|
|
*
|
2006-10-07 00:20:14 +08:00
|
|
|
* linux/sound/soc.h -- ALSA SoC Layer
|
|
|
|
|
*
|
2018-07-02 14:24:18 +08:00
|
|
|
* Author: Liam Girdwood
|
|
|
|
|
* Created: Aug 11th 2005
|
2006-10-07 00:20:14 +08:00
|
|
|
* Copyright: Wolfson Microelectronics. PLC.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __LINUX_SND_SOC_H
|
|
|
|
|
#define __LINUX_SND_SOC_H
|
|
|
|
|
|
2013-09-11 08:39:56 +08:00
|
|
|
#include <linux/of.h>
|
2006-10-07 00:20:14 +08:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
|
#include <linux/types.h>
|
2010-03-22 20:06:30 +08:00
|
|
|
#include <linux/notifier.h>
|
2006-12-15 16:30:07 +08:00
|
|
|
#include <linux/workqueue.h>
|
2009-03-04 05:25:04 +08:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/kernel.h>
|
2011-06-14 02:35:29 +08:00
|
|
|
#include <linux/regmap.h>
|
2012-09-14 19:57:27 +08:00
|
|
|
#include <linux/log2.h>
|
2006-10-07 00:20:14 +08:00
|
|
|
#include <sound/core.h>
|
|
|
|
|
#include <sound/pcm.h>
|
2012-08-16 19:40:40 +08:00
|
|
|
#include <sound/compress_driver.h>
|
2006-10-07 00:20:14 +08:00
|
|
|
#include <sound/control.h>
|
|
|
|
|
#include <sound/ac97_codec.h>
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Convenience kcontrol builders
|
|
|
|
|
*/
|
2013-08-05 17:27:31 +08:00
|
|
|
#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
|
2008-07-29 18:42:26 +08:00
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
2011-10-05 15:29:22 +08:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = shift_left, \
|
|
|
|
|
.rshift = shift_right, .max = xmax, .platform_max = xmax, \
|
2013-08-05 17:27:31 +08:00
|
|
|
.invert = xinvert, .autodisable = xautodisable})
|
2014-10-26 02:25:56 +08:00
|
|
|
#define SOC_DOUBLE_S_VALUE(xreg, shift_left, shift_right, xmin, xmax, xsign_bit, xinvert, xautodisable) \
|
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xreg, .rreg = xreg, .shift = shift_left, \
|
|
|
|
|
.rshift = shift_right, .min = xmin, .max = xmax, .platform_max = xmax, \
|
|
|
|
|
.sign_bit = xsign_bit, .invert = xinvert, .autodisable = xautodisable})
|
2013-08-05 17:27:31 +08:00
|
|
|
#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
|
|
|
|
|
SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
|
2008-07-29 18:42:26 +08:00
|
|
|
#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
|
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
2010-05-10 19:39:24 +08:00
|
|
|
{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
|
2011-10-04 19:39:39 +08:00
|
|
|
#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
|
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
|
|
|
|
|
.max = xmax, .platform_max = xmax, .invert = xinvert})
|
2014-01-16 23:02:11 +08:00
|
|
|
#define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
|
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
|
|
|
|
|
.max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
|
|
|
|
|
.invert = xinvert})
|
2012-06-22 18:40:55 +08:00
|
|
|
#define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
|
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
|
|
|
|
|
.min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
|
2008-01-10 21:37:42 +08:00
|
|
|
#define SOC_SINGLE(xname, reg, shift, max, invert) \
|
2006-10-07 00:20:14 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
2013-08-05 17:27:31 +08:00
|
|
|
.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
|
2012-05-31 22:18:01 +08:00
|
|
|
#define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
|
|
|
|
|
.put = snd_soc_put_volsw_range, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
2012-12-20 00:05:00 +08:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = xshift, \
|
|
|
|
|
.rshift = xshift, .min = xmin, .max = xmax, \
|
|
|
|
|
.platform_max = xmax, .invert = xinvert} }
|
2008-01-10 21:37:42 +08:00
|
|
|
#define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
2013-08-05 17:27:31 +08:00
|
|
|
.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
|
2012-03-30 23:43:55 +08:00
|
|
|
#define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array),\
|
2015-10-14 20:31:24 +08:00
|
|
|
.info = snd_soc_info_volsw_sx, \
|
2012-03-30 23:43:55 +08:00
|
|
|
.get = snd_soc_get_volsw_sx,\
|
|
|
|
|
.put = snd_soc_put_volsw_sx, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xreg, .rreg = xreg, \
|
|
|
|
|
.shift = xshift, .rshift = xshift, \
|
|
|
|
|
.max = xmax, .min = xmin} }
|
2012-05-31 22:18:01 +08:00
|
|
|
#define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw_range, \
|
|
|
|
|
.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
2012-12-20 00:05:00 +08:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = xshift, \
|
|
|
|
|
.rshift = xshift, .min = xmin, .max = xmax, \
|
|
|
|
|
.platform_max = xmax, .invert = xinvert} }
|
2011-10-04 19:39:38 +08:00
|
|
|
#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
|
2006-10-07 00:20:14 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
2011-10-04 19:39:38 +08:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
|
2013-08-05 17:27:31 +08:00
|
|
|
max, invert, 0) }
|
2015-12-08 23:58:58 +08:00
|
|
|
#define SOC_DOUBLE_STS(xname, reg, shift_left, shift_right, max, invert) \
|
|
|
|
|
{ \
|
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
|
|
|
|
|
.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
|
|
|
|
|
max, invert, 0) }
|
2008-07-29 18:42:26 +08:00
|
|
|
#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
|
2006-10-07 00:20:14 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
2011-10-05 15:29:23 +08:00
|
|
|
.info = snd_soc_info_volsw, \
|
2011-10-05 15:29:25 +08:00
|
|
|
.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
|
2011-10-04 19:39:39 +08:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
|
xmax, xinvert) }
|
2012-06-22 18:40:55 +08:00
|
|
|
#define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
|
|
|
|
|
xmax, xinvert) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.info = snd_soc_info_volsw_range, \
|
|
|
|
|
.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
|
|
|
|
|
.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
|
|
|
|
|
xshift, xmin, xmax, xinvert) }
|
2011-10-04 19:39:38 +08:00
|
|
|
#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
|
2008-01-10 21:37:42 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
2011-10-04 19:39:38 +08:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
|
2013-08-05 17:27:31 +08:00
|
|
|
max, invert, 0) }
|
2008-07-29 18:42:26 +08:00
|
|
|
#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
|
2008-01-10 21:37:42 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
2011-10-05 15:29:23 +08:00
|
|
|
.info = snd_soc_info_volsw, \
|
2011-10-05 15:29:25 +08:00
|
|
|
.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
|
2011-10-04 19:39:39 +08:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
|
xmax, xinvert) }
|
2012-06-22 18:40:55 +08:00
|
|
|
#define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
|
|
|
|
|
xmax, xinvert, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw_range, \
|
|
|
|
|
.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
|
|
|
|
|
.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
|
|
|
|
|
xshift, xmin, xmax, xinvert) }
|
2012-03-30 23:43:55 +08:00
|
|
|
#define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array), \
|
2015-10-14 20:31:24 +08:00
|
|
|
.info = snd_soc_info_volsw_sx, \
|
2012-03-30 23:43:55 +08:00
|
|
|
.get = snd_soc_get_volsw_sx, \
|
|
|
|
|
.put = snd_soc_put_volsw_sx, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xreg, .rreg = xrreg, \
|
|
|
|
|
.shift = xshift, .rshift = xshift, \
|
|
|
|
|
.max = xmax, .min = xmin} }
|
2014-01-16 23:02:11 +08:00
|
|
|
#define SOC_DOUBLE_R_S_TLV(xname, reg_left, reg_right, xshift, xmin, xmax, xsign_bit, xinvert, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, \
|
|
|
|
|
.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
|
|
|
|
|
.private_value = SOC_DOUBLE_R_S_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
|
xmin, xmax, xsign_bit, xinvert) }
|
2016-05-27 21:45:45 +08:00
|
|
|
#define SOC_SINGLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xreg, .rreg = xreg, \
|
|
|
|
|
.min = xmin, .max = xmax, .platform_max = xmax, \
|
|
|
|
|
.sign_bit = 7,} }
|
2008-07-29 18:42:26 +08:00
|
|
|
#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
|
2008-05-29 00:58:05 +08:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array), \
|
2014-10-26 02:25:56 +08:00
|
|
|
.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
|
|
|
|
|
.put = snd_soc_put_volsw, \
|
|
|
|
|
.private_value = SOC_DOUBLE_S_VALUE(xreg, 0, 8, xmin, xmax, 7, 0, 0) }
|
2014-02-18 15:11:42 +08:00
|
|
|
#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
|
2006-10-07 00:20:14 +08:00
|
|
|
{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
|
2014-02-18 15:11:42 +08:00
|
|
|
.items = xitems, .texts = xtexts, \
|
|
|
|
|
.mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
|
|
|
|
|
#define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
|
|
|
|
|
SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
|
|
|
|
|
#define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
|
|
|
|
|
{ .items = xitems, .texts = xtexts }
|
|
|
|
|
#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
|
2009-01-05 15:54:57 +08:00
|
|
|
{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
|
2014-02-18 15:11:42 +08:00
|
|
|
.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
|
2015-05-01 19:37:23 +08:00
|
|
|
#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
|
|
|
|
|
SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
|
2015-05-01 19:37:26 +08:00
|
|
|
#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
|
|
|
|
|
{ .reg = xreg, .shift_l = xshift, .shift_r = xshift, \
|
|
|
|
|
.mask = xmask, .items = xitems, .texts = xtexts, \
|
|
|
|
|
.values = xvalues, .autodisable = 1}
|
2014-02-28 15:31:05 +08:00
|
|
|
#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
|
|
|
|
|
SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
|
2006-10-07 00:20:14 +08:00
|
|
|
#define SOC_ENUM(xname, xenum) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
|
|
|
|
|
.info = snd_soc_info_enum_double, \
|
|
|
|
|
.get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
|
|
|
|
|
.private_value = (unsigned long)&xenum }
|
2008-07-29 18:42:27 +08:00
|
|
|
#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
|
2006-10-07 00:20:14 +08:00
|
|
|
xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
2007-02-03 00:13:05 +08:00
|
|
|
.info = snd_soc_info_volsw, \
|
2006-10-07 00:20:14 +08:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2013-08-05 17:27:31 +08:00
|
|
|
.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
|
2011-10-04 19:39:38 +08:00
|
|
|
#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
|
2009-04-24 22:37:44 +08:00
|
|
|
xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.info = snd_soc_info_volsw, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2011-10-04 19:39:38 +08:00
|
|
|
.private_value = \
|
2013-08-05 17:27:31 +08:00
|
|
|
SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
|
2015-09-29 23:43:56 +08:00
|
|
|
#define SOC_DOUBLE_R_EXT(xname, reg_left, reg_right, xshift, xmax, xinvert,\
|
|
|
|
|
xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.info = snd_soc_info_volsw, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
|
xmax, xinvert) }
|
2008-07-29 18:42:27 +08:00
|
|
|
#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
|
2008-06-11 20:47:13 +08:00
|
|
|
xhandler_get, xhandler_put, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2013-08-05 17:27:31 +08:00
|
|
|
.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
|
2015-09-16 20:59:42 +08:00
|
|
|
#define SOC_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
|
|
|
|
|
xhandler_get, xhandler_put, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE,\
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw_range, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mixer_control) \
|
|
|
|
|
{.reg = xreg, .rreg = xreg, .shift = xshift, \
|
|
|
|
|
.rshift = xshift, .min = xmin, .max = xmax, \
|
|
|
|
|
.platform_max = xmax, .invert = xinvert} }
|
2009-07-15 19:33:47 +08:00
|
|
|
#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
|
|
|
|
|
xhandler_get, xhandler_put, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array), \
|
|
|
|
|
.info = snd_soc_info_volsw, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2011-10-04 19:39:38 +08:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
|
2013-08-05 17:27:31 +08:00
|
|
|
xmax, xinvert, 0) }
|
2009-07-15 19:33:50 +08:00
|
|
|
#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
|
|
|
|
|
xhandler_get, xhandler_put, tlv_array) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_READWRITE, \
|
|
|
|
|
.tlv.p = (tlv_array), \
|
2011-10-05 15:29:23 +08:00
|
|
|
.info = snd_soc_info_volsw, \
|
2009-07-15 19:33:50 +08:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2011-10-04 19:39:39 +08:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
|
xmax, xinvert) }
|
2006-10-07 00:20:14 +08:00
|
|
|
#define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_info_bool_ext, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
|
.private_value = xdata }
|
|
|
|
|
#define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
2013-08-11 03:33:10 +08:00
|
|
|
.info = snd_soc_info_enum_double, \
|
2006-10-07 00:20:14 +08:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
|
.private_value = (unsigned long)&xenum }
|
2014-07-07 20:16:54 +08:00
|
|
|
#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
|
|
|
|
|
SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2011-10-11 01:31:26 +08:00
|
|
|
#define SND_SOC_BYTES(xname, xbase, xregs) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
|
|
|
|
|
.put = snd_soc_bytes_put, .private_value = \
|
|
|
|
|
((unsigned long)&(struct soc_bytes) \
|
|
|
|
|
{.base = xbase, .num_regs = xregs }) }
|
2019-11-20 14:08:43 +08:00
|
|
|
#define SND_SOC_BYTES_E(xname, xbase, xregs, xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_bytes_info, .get = xhandler_get, \
|
|
|
|
|
.put = xhandler_put, .private_value = \
|
|
|
|
|
((unsigned long)&(struct soc_bytes) \
|
|
|
|
|
{.base = xbase, .num_regs = xregs }) }
|
2010-05-15 23:30:01 +08:00
|
|
|
|
2012-02-18 08:20:33 +08:00
|
|
|
#define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
|
|
|
|
|
.put = snd_soc_bytes_put, .private_value = \
|
|
|
|
|
((unsigned long)&(struct soc_bytes) \
|
|
|
|
|
{.base = xbase, .num_regs = xregs, \
|
|
|
|
|
.mask = xmask }) }
|
|
|
|
|
|
2015-11-23 23:52:29 +08:00
|
|
|
/*
|
|
|
|
|
* SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
|
|
|
|
|
*/
|
2014-05-02 13:28:11 +08:00
|
|
|
#define SND_SOC_BYTES_EXT(xname, xcount, xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.info = snd_soc_bytes_info_ext, \
|
|
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_bytes_ext) \
|
|
|
|
|
{.max = xcount} }
|
2014-07-16 00:04:48 +08:00
|
|
|
#define SND_SOC_BYTES_TLV(xname, xcount, xhandler_get, xhandler_put) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE | \
|
|
|
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
|
|
|
|
|
.tlv.c = (snd_soc_bytes_tlv_callback), \
|
2014-08-18 17:23:03 +08:00
|
|
|
.info = snd_soc_bytes_info_ext, \
|
2014-07-16 00:04:48 +08:00
|
|
|
.private_value = (unsigned long)&(struct soc_bytes_ext) \
|
|
|
|
|
{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
|
2012-04-20 17:32:13 +08:00
|
|
|
#define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
|
|
|
|
|
xmin, xmax, xinvert) \
|
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
|
|
|
|
.info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
|
|
|
|
|
.put = snd_soc_put_xr_sx, \
|
|
|
|
|
.private_value = (unsigned long)&(struct soc_mreg_control) \
|
|
|
|
|
{.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
|
|
|
|
|
.invert = xinvert, .min = xmin, .max = xmax} }
|
|
|
|
|
|
2012-04-20 17:32:44 +08:00
|
|
|
#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
|
|
|
|
|
SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
|
|
|
|
|
snd_soc_get_strobe, snd_soc_put_strobe)
|
|
|
|
|
|
2010-01-22 05:04:03 +08:00
|
|
|
/*
|
|
|
|
|
* Simplified versions of above macros, declaring a struct and calculating
|
|
|
|
|
* ARRAY_SIZE internally
|
|
|
|
|
*/
|
|
|
|
|
#define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
|
2014-02-18 16:08:51 +08:00
|
|
|
const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
|
2010-01-22 05:04:03 +08:00
|
|
|
ARRAY_SIZE(xtexts), xtexts)
|
|
|
|
|
#define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
|
|
|
|
|
SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
|
|
|
|
|
#define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
|
2014-02-18 16:08:51 +08:00
|
|
|
const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
|
2010-01-22 05:04:03 +08:00
|
|
|
#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
|
2014-02-18 16:08:51 +08:00
|
|
|
const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
|
2010-01-22 05:04:03 +08:00
|
|
|
ARRAY_SIZE(xtexts), xtexts, xvalues)
|
|
|
|
|
#define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
|
|
|
|
|
SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
|
2015-05-01 19:37:26 +08:00
|
|
|
|
|
|
|
|
#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
|
|
|
|
|
const struct soc_enum name = SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, \
|
|
|
|
|
xshift, xmask, ARRAY_SIZE(xtexts), xtexts, xvalues)
|
|
|
|
|
|
2014-02-28 15:31:05 +08:00
|
|
|
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
|
|
|
|
|
const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
|
2010-01-22 05:04:03 +08:00
|
|
|
|
2011-12-22 01:40:59 +08:00
|
|
|
struct device_node;
|
2009-01-08 01:31:10 +08:00
|
|
|
struct snd_jack;
|
|
|
|
|
struct snd_soc_card;
|
2006-10-07 00:20:14 +08:00
|
|
|
struct snd_soc_pcm_stream;
|
|
|
|
|
struct snd_soc_ops;
|
|
|
|
|
struct snd_soc_pcm_runtime;
|
2008-07-07 23:07:17 +08:00
|
|
|
struct snd_soc_dai;
|
2010-03-18 04:15:21 +08:00
|
|
|
struct snd_soc_dai_driver;
|
2010-02-22 14:58:04 +08:00
|
|
|
struct snd_soc_dai_link;
|
2013-03-12 09:27:21 +08:00
|
|
|
struct snd_soc_component;
|
|
|
|
|
struct snd_soc_component_driver;
|
2006-10-07 00:20:14 +08:00
|
|
|
struct soc_enum;
|
2009-01-08 01:31:10 +08:00
|
|
|
struct snd_soc_jack;
|
2011-02-09 17:14:17 +08:00
|
|
|
struct snd_soc_jack_zone;
|
2009-01-08 01:31:10 +08:00
|
|
|
struct snd_soc_jack_pin;
|
2010-11-05 21:53:46 +08:00
|
|
|
#include <sound/soc-dapm.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 19:12:49 +08:00
|
|
|
#include <sound/soc-dpcm.h>
|
2016-01-15 16:13:28 +08:00
|
|
|
#include <sound/soc-topology.h>
|
2010-03-18 04:15:21 +08:00
|
|
|
|
2009-03-04 05:25:04 +08:00
|
|
|
struct snd_soc_jack_gpio;
|
2006-10-07 00:20:14 +08:00
|
|
|
|
|
|
|
|
typedef int (*hw_write_t)(void *,const char* ,int);
|
|
|
|
|
|
2011-06-10 00:04:39 +08:00
|
|
|
enum snd_soc_pcm_subclass {
|
|
|
|
|
SND_SOC_PCM_CLASS_PCM = 0,
|
|
|
|
|
SND_SOC_PCM_CLASS_BE = 1,
|
|
|
|
|
};
|
|
|
|
|
|
2011-01-14 21:52:48 +08:00
|
|
|
int snd_soc_register_card(struct snd_soc_card *card);
|
|
|
|
|
int snd_soc_unregister_card(struct snd_soc_card *card);
|
2013-09-17 01:02:05 +08:00
|
|
|
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
|
2015-04-19 09:45:48 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2011-01-26 22:59:27 +08:00
|
|
|
int snd_soc_suspend(struct device *dev);
|
|
|
|
|
int snd_soc_resume(struct device *dev);
|
2015-04-19 09:45:48 +08:00
|
|
|
#else
|
|
|
|
|
static inline int snd_soc_suspend(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int snd_soc_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2011-01-26 22:59:27 +08:00
|
|
|
int snd_soc_poweroff(struct device *dev);
|
2020-07-31 22:41:44 +08:00
|
|
|
int snd_soc_component_initialize(struct snd_soc_component *component,
|
|
|
|
|
const struct snd_soc_component_driver *driver,
|
2020-07-31 22:41:45 +08:00
|
|
|
struct device *dev);
|
2020-07-31 22:41:46 +08:00
|
|
|
int snd_soc_add_component(struct snd_soc_component *component,
|
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
|
int num_dai);
|
2013-03-12 09:27:21 +08:00
|
|
|
int snd_soc_register_component(struct device *dev,
|
2017-08-07 10:06:23 +08:00
|
|
|
const struct snd_soc_component_driver *component_driver,
|
2013-03-12 09:27:21 +08:00
|
|
|
struct snd_soc_dai_driver *dai_drv, int num_dai);
|
2013-09-05 03:37:34 +08:00
|
|
|
int devm_snd_soc_register_component(struct device *dev,
|
2017-08-07 10:06:23 +08:00
|
|
|
const struct snd_soc_component_driver *component_driver,
|
2013-09-05 03:37:34 +08:00
|
|
|
struct snd_soc_dai_driver *dai_drv, int num_dai);
|
2013-03-12 09:27:21 +08:00
|
|
|
void snd_soc_unregister_component(struct device *dev);
|
2020-07-07 15:42:37 +08:00
|
|
|
void snd_soc_unregister_component_by_driver(struct device *dev,
|
|
|
|
|
const struct snd_soc_component_driver *component_driver);
|
2020-06-12 15:37:48 +08:00
|
|
|
struct snd_soc_component *snd_soc_lookup_component_nolocked(struct device *dev,
|
|
|
|
|
const char *driver_name);
|
2017-10-02 13:09:52 +08:00
|
|
|
struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
|
|
|
|
|
const char *driver_name);
|
2014-11-08 23:38:07 +08:00
|
|
|
|
2011-12-22 20:16:39 +08:00
|
|
|
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
|
2015-10-13 23:41:00 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_COMPRESS
|
|
|
|
|
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
|
2018-05-30 07:30:02 +08:00
|
|
|
#else
|
|
|
|
|
static inline int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-10-13 23:41:00 +08:00
|
|
|
#endif
|
2008-12-04 03:40:30 +08:00
|
|
|
|
2017-11-28 14:27:09 +08:00
|
|
|
void snd_soc_disconnect_sync(struct device *dev);
|
|
|
|
|
|
2012-04-25 19:12:53 +08:00
|
|
|
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
|
2019-12-10 08:34:08 +08:00
|
|
|
struct snd_soc_dai_link *dai_link);
|
2012-04-25 19:12:53 +08:00
|
|
|
|
2014-03-05 20:17:42 +08:00
|
|
|
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
|
2020-05-15 08:46:21 +08:00
|
|
|
|
|
|
|
|
void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
int stream, int action);
|
|
|
|
|
static inline void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
int stream)
|
|
|
|
|
{
|
|
|
|
|
snd_soc_runtime_action(rtd, stream, 1);
|
|
|
|
|
}
|
|
|
|
|
static inline void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
int stream)
|
|
|
|
|
{
|
|
|
|
|
snd_soc_runtime_action(rtd, stream, -1);
|
|
|
|
|
}
|
2014-03-05 20:17:42 +08:00
|
|
|
|
2020-03-05 13:11:42 +08:00
|
|
|
int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
struct snd_pcm_hardware *hw, int stream);
|
|
|
|
|
|
2015-01-06 22:17:20 +08:00
|
|
|
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
unsigned int dai_fmt);
|
|
|
|
|
|
2017-04-24 14:54:41 +08:00
|
|
|
#ifdef CONFIG_DMI
|
2017-01-14 16:13:02 +08:00
|
|
|
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
|
2017-04-24 14:54:41 +08:00
|
|
|
#else
|
|
|
|
|
static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
|
|
|
|
|
const char *flavour)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2017-01-14 16:13:02 +08:00
|
|
|
|
2009-11-11 00:08:04 +08:00
|
|
|
/* Utility functions to get clock rates from various things */
|
|
|
|
|
int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
|
|
|
|
|
int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
|
2009-11-19 19:36:10 +08:00
|
|
|
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
|
2009-11-11 00:08:04 +08:00
|
|
|
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
|
|
|
|
|
|
2006-10-07 00:20:14 +08:00
|
|
|
/* set runtime hw params */
|
|
|
|
|
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
|
|
|
|
|
const struct snd_pcm_hardware *hw);
|
|
|
|
|
|
2018-01-29 10:58:25 +08:00
|
|
|
struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
|
|
|
|
|
struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
|
2015-07-22 03:53:01 +08:00
|
|
|
unsigned int id, unsigned int id_mask);
|
2018-01-29 10:58:25 +08:00
|
|
|
void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2018-11-02 23:18:21 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
2013-06-26 19:45:59 +08:00
|
|
|
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
|
2013-08-19 23:05:55 +08:00
|
|
|
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
|
|
|
|
|
struct platform_device *pdev);
|
2013-06-26 19:45:59 +08:00
|
|
|
|
2014-11-11 05:41:46 +08:00
|
|
|
extern struct snd_ac97_bus_ops *soc_ac97_ops;
|
|
|
|
|
#else
|
|
|
|
|
static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
|
|
|
|
|
struct platform_device *pdev)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-10-07 00:20:14 +08:00
|
|
|
/*
|
|
|
|
|
*Controls
|
|
|
|
|
*/
|
|
|
|
|
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
|
2012-02-17 09:07:42 +08:00
|
|
|
void *data, const char *long_name,
|
2011-03-09 01:23:24 +08:00
|
|
|
const char *prefix);
|
2014-07-18 04:01:08 +08:00
|
|
|
int snd_soc_add_component_controls(struct snd_soc_component *component,
|
|
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls);
|
2012-02-04 01:43:09 +08:00
|
|
|
int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
|
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls);
|
|
|
|
|
int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
|
|
|
|
|
const struct snd_kcontrol_new *controls, int num_controls);
|
2006-10-07 00:20:14 +08:00
|
|
|
int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
|
|
|
|
int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
2015-10-14 20:31:24 +08:00
|
|
|
int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
2008-05-13 20:03:40 +08:00
|
|
|
#define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
|
2006-10-07 00:20:14 +08:00
|
|
|
int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2011-10-06 12:43:21 +08:00
|
|
|
#define snd_soc_get_volsw_2r snd_soc_get_volsw
|
|
|
|
|
#define snd_soc_put_volsw_2r snd_soc_put_volsw
|
2012-03-30 23:43:55 +08:00
|
|
|
int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2012-05-31 22:18:01 +08:00
|
|
|
int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
|
|
|
|
int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2015-10-18 23:04:33 +08:00
|
|
|
int snd_soc_limit_volume(struct snd_soc_card *card,
|
2010-05-07 19:05:49 +08:00
|
|
|
const char *name, int max);
|
2011-10-11 01:31:26 +08:00
|
|
|
int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
|
|
|
|
int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2014-05-02 13:28:11 +08:00
|
|
|
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *ucontrol);
|
2014-07-16 00:04:48 +08:00
|
|
|
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
|
unsigned int size, unsigned int __user *tlv);
|
2012-04-20 17:32:13 +08:00
|
|
|
int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
|
|
|
|
int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2012-04-20 17:32:44 +08:00
|
|
|
int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
|
|
|
|
int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
|
|
|
|
|
struct snd_ctl_elem_value *ucontrol);
|
2006-10-07 00:20:14 +08:00
|
|
|
|
|
|
|
|
/* SoC PCM stream information */
|
|
|
|
|
struct snd_soc_pcm_stream {
|
2010-03-18 04:15:21 +08:00
|
|
|
const char *stream_name;
|
2007-02-03 00:13:05 +08:00
|
|
|
u64 formats; /* SNDRV_PCM_FMTBIT_* */
|
|
|
|
|
unsigned int rates; /* SNDRV_PCM_RATE_* */
|
2006-10-07 00:20:14 +08:00
|
|
|
unsigned int rate_min; /* min rate */
|
|
|
|
|
unsigned int rate_max; /* max rate */
|
|
|
|
|
unsigned int channels_min; /* min channels */
|
|
|
|
|
unsigned int channels_max; /* max channels */
|
2012-01-17 02:38:51 +08:00
|
|
|
unsigned int sig_bits; /* number of bits of content */
|
2006-10-07 00:20:14 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* SoC audio ops */
|
|
|
|
|
struct snd_soc_ops {
|
|
|
|
|
int (*startup)(struct snd_pcm_substream *);
|
|
|
|
|
void (*shutdown)(struct snd_pcm_substream *);
|
|
|
|
|
int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
|
|
|
|
|
int (*hw_free)(struct snd_pcm_substream *);
|
|
|
|
|
int (*prepare)(struct snd_pcm_substream *);
|
|
|
|
|
int (*trigger)(struct snd_pcm_substream *, int);
|
|
|
|
|
};
|
|
|
|
|
|
2012-08-16 19:40:40 +08:00
|
|
|
struct snd_soc_compr_ops {
|
|
|
|
|
int (*startup)(struct snd_compr_stream *);
|
|
|
|
|
void (*shutdown)(struct snd_compr_stream *);
|
|
|
|
|
int (*set_params)(struct snd_compr_stream *);
|
|
|
|
|
int (*trigger)(struct snd_compr_stream *);
|
|
|
|
|
};
|
|
|
|
|
|
2017-08-08 14:17:47 +08:00
|
|
|
struct snd_soc_component*
|
|
|
|
|
snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
const char *driver_name);
|
|
|
|
|
|
2014-07-09 05:19:34 +08:00
|
|
|
struct snd_soc_dai_link_component {
|
|
|
|
|
const char *name;
|
2014-11-25 19:14:48 +08:00
|
|
|
struct device_node *of_node;
|
2014-07-09 05:19:34 +08:00
|
|
|
const char *dai_name;
|
|
|
|
|
};
|
|
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
struct snd_soc_dai_link {
|
|
|
|
|
/* config - must be set by machine driver */
|
|
|
|
|
const char *name; /* Codec name */
|
|
|
|
|
const char *stream_name; /* Stream name */
|
ASoC: soc.h: add explanation of legacy/modern style of dai_link
Current ALSA SoC is assuming 1 CPU 1 Platform (= DMA) style system.
Because of this background, it is directly using
xxx_name / xxx_of_node / xxx_dai_name on dai_link.
Let's call it as legacy style here.
More complex style system like multi CPU multi Platform (= DMA) will
coming. To supporting it, we can use snd_soc_dai_link_component on
dai_link. Let's call it as modern style here.
But current ALSA SoC can't support it so far. Thus, we need to have
multi CPU / multi Codec / multi Platform style in the future on ALSA SoC.
Currently we already have multi Codec support. Platform is starting to
use modern style on dai_link, but still style only. Multi Platform is
not yet implemented. And we still don't have multi CPU support on ALSA
SoC, and not have modern style either.
Currently, if driver is using legacy style Codec/Platform, it will be
converted to modern style on soc-core. This means, we are using glue code
for legacy vs modern style so far on ALSA SoC.
We can fully switch to modern style on all drivers if ALSA SoC supported
modern style for CPU, and then, legacy style code will be removed from
ALSA SoC.
Untile then, we need to keep both legacy/modern style and its glue code.
This patch adds such future plan and background on soc.h
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-01-18 10:20:41 +08: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 08:22:11 +08:00
|
|
|
/*
|
|
|
|
|
* You MAY specify the link's CPU-side device, either by device name,
|
|
|
|
|
* or by DT/OF node, but not both. If this information is omitted,
|
|
|
|
|
* the CPU-side DAI is matched using .cpu_dai_name only, which hence
|
|
|
|
|
* must be globally unique. These fields are currently typically used
|
|
|
|
|
* only for codec to codec links, or systems using device tree.
|
|
|
|
|
*/
|
|
|
|
|
/*
|
|
|
|
|
* You MAY specify the DAI name of the CPU DAI. If this information is
|
|
|
|
|
* omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
|
|
|
|
|
* only, which only works well when that device exposes a single DAI.
|
|
|
|
|
*/
|
2019-06-06 12:07:22 +08:00
|
|
|
struct snd_soc_dai_link_component *cpus;
|
|
|
|
|
unsigned int num_cpus;
|
|
|
|
|
|
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 08:22:11 +08:00
|
|
|
/*
|
|
|
|
|
* You MUST specify the link's codec, either by device name, or by
|
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
|
*/
|
|
|
|
|
/* You MUST specify the DAI name within the codec */
|
2014-07-09 05:19:34 +08:00
|
|
|
struct snd_soc_dai_link_component *codecs;
|
|
|
|
|
unsigned int num_codecs;
|
|
|
|
|
|
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 08:22:11 +08:00
|
|
|
/*
|
|
|
|
|
* You MAY specify the link's platform/PCM/DMA driver, either by
|
|
|
|
|
* device name, or by DT/OF node, but not both. Some forms of link
|
ASoC: soc-core: allow no Platform on dai_link
dai_link is used to selecting Component (= CPU/Codec/Platform) and
DAI (= CPU/Codec). And selected CPU/Codec/Platform components are
*listed* on Card.
Many drivers don't need special Platform component, but was
mandatory at legacy style ALSA SoC.
Thus, there is this kind of settings on many drivers.
dai_link->platform_of_node = dai_link->cpu_of_node;
In this case, soc_bind_dai_link() will pick-up "CPU component" as
"Platform component", and try to add it to snd_soc_pcm_runtime.
But it will be ignored, because it is already added when CPU bindings.
Historically, this kind of "CPU component" is used/selected as
"Platform" on many ALSA SoC drivers.
OTOH, Dummy Platform will be selected automatically by ALSA SoC if
driver doesn't have Platform settings.
These indicates that there are 2 type of Platforms exist at current
ALSA SoC if driver doesn't need special Platform.
1) use Dummy Platform as Platform component
2) use CPU component as Platform component
ALSA SoC will call Dummy Platform callback function if it is using
Dummy Platform, but it is completely pointless. Because it is the
sound card which doesn't need special Platform.
Thus, the behavior we request to ALSA SoC is selecting 2) automatically
instead of 1) if sound card doesn't need special Platform.
And, 2) means "do nothing" as above explain.
These were needed at legacy style dai_link, but is no longer needed
at modern style dai_link anymore.
This patch allows "no Platform" settings on dai_link, and will do
nothing for it if there was no platform settings. This is same as 2).
By this patch, all drivers which is selecting "CPU component" as
"Platform" can remove such settings.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2019-06-19 09:14:07 +08:00
|
|
|
* do not need a platform. In such case, platforms are not mandatory.
|
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 08:22:11 +08:00
|
|
|
*/
|
2019-01-21 08:32:32 +08:00
|
|
|
struct snd_soc_dai_link_component *platforms;
|
|
|
|
|
unsigned int num_platforms;
|
2018-08-31 11:10:08 +08:00
|
|
|
|
2016-04-19 13:12:35 +08:00
|
|
|
int id; /* optional ID for machine driver link identification */
|
2008-01-10 21:39:01 +08:00
|
|
|
|
2012-04-05 05:12:09 +08:00
|
|
|
const struct snd_soc_pcm_stream *params;
|
2015-02-03 01:06:44 +08:00
|
|
|
unsigned int num_params;
|
2012-04-05 05:12:09 +08:00
|
|
|
|
2011-09-27 23:41:01 +08:00
|
|
|
unsigned int dai_fmt; /* format to set on init */
|
|
|
|
|
|
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 19:12:49 +08:00
|
|
|
enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
|
|
|
|
|
|
2015-04-21 15:02:34 +08:00
|
|
|
/* codec/machine specific init - e.g. add machine controls */
|
|
|
|
|
int (*init)(struct snd_soc_pcm_runtime *rtd);
|
|
|
|
|
|
2020-06-22 23:42:37 +08:00
|
|
|
/* codec/machine specific exit - dual of init() */
|
|
|
|
|
void (*exit)(struct snd_soc_pcm_runtime *rtd);
|
|
|
|
|
|
2015-04-21 15:02:34 +08:00
|
|
|
/* optional hw_params re-writing for BE and FE sync */
|
|
|
|
|
int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
|
struct snd_pcm_hw_params *params);
|
|
|
|
|
|
|
|
|
|
/* machine stream operations */
|
|
|
|
|
const struct snd_soc_ops *ops;
|
|
|
|
|
const struct snd_soc_compr_ops *compr_ops;
|
|
|
|
|
|
|
|
|
|
/* Mark this pcm with non atomic ops */
|
2020-05-28 09:47:37 +08:00
|
|
|
unsigned int nonatomic:1;
|
2015-04-21 15:02:34 +08:00
|
|
|
|
2016-10-24 08:44:10 +08:00
|
|
|
/* For unidirectional dai links */
|
|
|
|
|
unsigned int playback_only:1;
|
|
|
|
|
unsigned int capture_only:1;
|
|
|
|
|
|
2010-05-09 20:25:43 +08:00
|
|
|
/* Keep DAI active over suspend */
|
|
|
|
|
unsigned int ignore_suspend:1;
|
|
|
|
|
|
2009-04-08 01:10:13 +08:00
|
|
|
/* Symmetry requirements */
|
2021-01-15 12:52:54 +08:00
|
|
|
unsigned int symmetric_rate:1;
|
2013-11-13 18:56:24 +08:00
|
|
|
unsigned int symmetric_channels:1;
|
2021-01-15 12:52:54 +08:00
|
|
|
unsigned int symmetric_sample_bits:1;
|
2009-04-08 01:10:13 +08:00
|
|
|
|
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 19:12:49 +08:00
|
|
|
/* Do not create a PCM for this DAI link (Backend link) */
|
|
|
|
|
unsigned int no_pcm:1;
|
|
|
|
|
|
|
|
|
|
/* This DAI link can route to other DAI links at runtime (Frontend)*/
|
|
|
|
|
unsigned int dynamic:1;
|
|
|
|
|
|
2014-01-08 01:51:42 +08:00
|
|
|
/* DPCM capture and Playback support */
|
|
|
|
|
unsigned int dpcm_capture:1;
|
|
|
|
|
unsigned int dpcm_playback:1;
|
|
|
|
|
|
2015-05-12 10:03:33 +08:00
|
|
|
/* DPCM used FE & BE merged format */
|
|
|
|
|
unsigned int dpcm_merged_format:1;
|
2018-06-20 17:25:20 +08:00
|
|
|
/* DPCM used FE & BE merged channel */
|
|
|
|
|
unsigned int dpcm_merged_chan:1;
|
2018-07-05 18:13:49 +08:00
|
|
|
/* DPCM used FE & BE merged rate */
|
|
|
|
|
unsigned int dpcm_merged_rate:1;
|
2015-05-12 10:03:33 +08:00
|
|
|
|
2011-10-27 14:42:33 +08:00
|
|
|
/* pmdown_time is ignored at stop */
|
|
|
|
|
unsigned int ignore_pmdown_time:1;
|
2015-12-02 14:11:22 +08:00
|
|
|
|
2018-07-02 23:59:54 +08:00
|
|
|
/* Do not create a PCM for this DAI link (Backend link) */
|
|
|
|
|
unsigned int ignore:1;
|
|
|
|
|
|
2019-11-05 14:47:26 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_TOPOLOGY
|
2015-12-02 14:11:22 +08:00
|
|
|
struct snd_soc_dobj dobj; /* For topology */
|
2019-11-05 14:47:26 +08:00
|
|
|
#endif
|
2006-10-07 00:20:14 +08:00
|
|
|
};
|
2018-09-03 10:12:40 +08:00
|
|
|
#define for_each_link_codecs(link, i, codec) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < link->num_codecs) && ((codec) = &link->codecs[i]); \
|
|
|
|
|
(i)++)
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2019-06-27 20:13:50 +08:00
|
|
|
#define for_each_link_platforms(link, i, platform) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < link->num_platforms) && \
|
|
|
|
|
((platform) = &link->platforms[i]); \
|
|
|
|
|
(i)++)
|
|
|
|
|
|
2020-02-25 21:39:12 +08:00
|
|
|
#define for_each_link_cpus(link, i, cpu) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < link->num_cpus) && ((cpu) = &link->cpus[i]); \
|
|
|
|
|
(i)++)
|
|
|
|
|
|
2019-06-06 12:07:42 +08:00
|
|
|
/*
|
|
|
|
|
* Sample 1 : Single CPU/Codec/Platform
|
|
|
|
|
*
|
|
|
|
|
* SND_SOC_DAILINK_DEFS(test,
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai")),
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CODEC("codec", "codec_dai")),
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
|
|
|
|
|
*
|
|
|
|
|
* struct snd_soc_dai_link link = {
|
|
|
|
|
* ...
|
|
|
|
|
* SND_SOC_DAILINK_REG(test),
|
|
|
|
|
* };
|
|
|
|
|
*
|
|
|
|
|
* Sample 2 : Multi CPU/Codec, no Platform
|
|
|
|
|
*
|
|
|
|
|
* SND_SOC_DAILINK_DEFS(test,
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
|
|
|
|
|
* COMP_CPU("cpu_dai2")),
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
|
|
|
|
|
* COMP_CODEC("codec2", "codec_dai2")));
|
|
|
|
|
*
|
|
|
|
|
* struct snd_soc_dai_link link = {
|
|
|
|
|
* ...
|
|
|
|
|
* SND_SOC_DAILINK_REG(test),
|
|
|
|
|
* };
|
|
|
|
|
*
|
|
|
|
|
* Sample 3 : Define each CPU/Codec/Platform manually
|
|
|
|
|
*
|
|
|
|
|
* SND_SOC_DAILINK_DEF(test_cpu,
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
|
|
|
|
|
* COMP_CPU("cpu_dai2")));
|
|
|
|
|
* SND_SOC_DAILINK_DEF(test_codec,
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
|
|
|
|
|
* COMP_CODEC("codec2", "codec_dai2")));
|
|
|
|
|
* SND_SOC_DAILINK_DEF(test_platform,
|
|
|
|
|
* DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
|
|
|
|
|
*
|
|
|
|
|
* struct snd_soc_dai_link link = {
|
|
|
|
|
* ...
|
|
|
|
|
* SND_SOC_DAILINK_REG(test_cpu,
|
|
|
|
|
* test_codec,
|
|
|
|
|
* test_platform),
|
|
|
|
|
* };
|
|
|
|
|
*
|
|
|
|
|
* Sample 4 : Sample3 without platform
|
|
|
|
|
*
|
|
|
|
|
* struct snd_soc_dai_link link = {
|
|
|
|
|
* ...
|
|
|
|
|
* SND_SOC_DAILINK_REG(test_cpu,
|
|
|
|
|
* test_codec);
|
|
|
|
|
* };
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define SND_SOC_DAILINK_REG1(name) SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
|
|
|
|
|
#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
|
|
|
|
|
#define SND_SOC_DAILINK_REG3(cpu, codec, platform) \
|
|
|
|
|
.cpus = cpu, \
|
|
|
|
|
.num_cpus = ARRAY_SIZE(cpu), \
|
|
|
|
|
.codecs = codec, \
|
|
|
|
|
.num_codecs = ARRAY_SIZE(codec), \
|
|
|
|
|
.platforms = platform, \
|
|
|
|
|
.num_platforms = ARRAY_SIZE(platform)
|
|
|
|
|
|
|
|
|
|
#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
|
|
|
|
|
#define SND_SOC_DAILINK_REG(...) \
|
|
|
|
|
SND_SOC_DAILINK_REGx(__VA_ARGS__, \
|
|
|
|
|
SND_SOC_DAILINK_REG3, \
|
|
|
|
|
SND_SOC_DAILINK_REG2, \
|
|
|
|
|
SND_SOC_DAILINK_REG1)(__VA_ARGS__)
|
|
|
|
|
|
|
|
|
|
#define SND_SOC_DAILINK_DEF(name, def...) \
|
|
|
|
|
static struct snd_soc_dai_link_component name[] = { def }
|
|
|
|
|
|
|
|
|
|
#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...) \
|
|
|
|
|
SND_SOC_DAILINK_DEF(name##_cpus, cpu); \
|
|
|
|
|
SND_SOC_DAILINK_DEF(name##_codecs, codec); \
|
|
|
|
|
SND_SOC_DAILINK_DEF(name##_platforms, platform)
|
|
|
|
|
|
|
|
|
|
#define DAILINK_COMP_ARRAY(param...) param
|
|
|
|
|
#define COMP_EMPTY() { }
|
|
|
|
|
#define COMP_CPU(_dai) { .dai_name = _dai, }
|
|
|
|
|
#define COMP_CODEC(_name, _dai) { .name = _name, .dai_name = _dai, }
|
|
|
|
|
#define COMP_PLATFORM(_name) { .name = _name }
|
2019-08-08 13:52:33 +08:00
|
|
|
#define COMP_AUX(_name) { .name = _name }
|
2019-12-13 08:54:36 +08:00
|
|
|
#define COMP_CODEC_CONF(_name) { .name = _name }
|
2019-06-06 12:07:42 +08:00
|
|
|
#define COMP_DUMMY() { .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }
|
|
|
|
|
|
|
|
|
|
extern struct snd_soc_dai_link_component null_dailink_component[0];
|
|
|
|
|
|
|
|
|
|
|
2010-12-02 22:53:03 +08:00
|
|
|
struct snd_soc_codec_conf {
|
2014-04-28 22:07:22 +08:00
|
|
|
/*
|
|
|
|
|
* specify device either by device name, or by
|
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
|
*/
|
2019-12-13 08:54:36 +08:00
|
|
|
struct snd_soc_dai_link_component dlc;
|
|
|
|
|
|
2010-12-02 22:53:03 +08:00
|
|
|
/*
|
|
|
|
|
* optional map of kcontrol, widget and path name prefixes that are
|
|
|
|
|
* associated per device
|
|
|
|
|
*/
|
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 02:40:44 +08:00
|
|
|
const char *name_prefix;
|
|
|
|
|
};
|
|
|
|
|
|
2010-11-25 23:47:38 +08:00
|
|
|
struct snd_soc_aux_dev {
|
2014-04-28 22:07:22 +08:00
|
|
|
/*
|
|
|
|
|
* specify multi-codec either by device name, or by
|
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
|
*/
|
2019-08-08 13:52:33 +08:00
|
|
|
struct snd_soc_dai_link_component dlc;
|
|
|
|
|
|
2010-11-25 23:47:38 +08:00
|
|
|
/* codec/machine specific init - e.g. add machine controls */
|
2014-08-19 21:51:23 +08:00
|
|
|
int (*init)(struct snd_soc_component *component);
|
2010-11-25 23:47:38 +08:00
|
|
|
};
|
|
|
|
|
|
2008-11-19 04:50:34 +08:00
|
|
|
/* SoC card */
|
|
|
|
|
struct snd_soc_card {
|
2010-03-18 04:15:21 +08:00
|
|
|
const char *name;
|
2011-05-12 23:14:04 +08:00
|
|
|
const char *long_name;
|
|
|
|
|
const char *driver_name;
|
2019-11-20 01:49:32 +08:00
|
|
|
const char *components;
|
2019-12-11 12:32:05 +08:00
|
|
|
#ifdef CONFIG_DMI
|
2017-01-14 16:13:02 +08:00
|
|
|
char dmi_longname[80];
|
2019-12-11 12:32:05 +08:00
|
|
|
#endif /* CONFIG_DMI */
|
2018-07-02 23:59:54 +08:00
|
|
|
char topology_shortname[32];
|
2017-01-14 16:13:02 +08:00
|
|
|
|
2008-11-28 21:29:45 +08:00
|
|
|
struct device *dev;
|
2010-03-18 04:15:21 +08:00
|
|
|
struct snd_card *snd_card;
|
|
|
|
|
struct module *owner;
|
2008-11-28 21:29:45 +08:00
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
struct mutex mutex;
|
2012-03-07 18:38:26 +08:00
|
|
|
struct mutex dapm_mutex;
|
2008-11-28 21:29:45 +08:00
|
|
|
|
2019-08-13 18:45:32 +08:00
|
|
|
/* Mutex for PCM operations */
|
|
|
|
|
struct mutex pcm_mutex;
|
|
|
|
|
enum snd_soc_pcm_subclass pcm_subclass;
|
|
|
|
|
|
2019-03-08 13:05:53 +08:00
|
|
|
spinlock_t dpcm_lock;
|
|
|
|
|
|
2011-01-26 22:17:20 +08:00
|
|
|
int (*probe)(struct snd_soc_card *card);
|
2011-03-03 02:36:34 +08:00
|
|
|
int (*late_probe)(struct snd_soc_card *card);
|
2011-01-26 22:17:20 +08:00
|
|
|
int (*remove)(struct snd_soc_card *card);
|
2006-10-07 00:20:14 +08:00
|
|
|
|
|
|
|
|
/* the pre and post PM functions are used to do any PM work before and
|
|
|
|
|
* after the codec and DAI's do any PM work. */
|
2011-01-26 22:05:25 +08:00
|
|
|
int (*suspend_pre)(struct snd_soc_card *card);
|
|
|
|
|
int (*suspend_post)(struct snd_soc_card *card);
|
|
|
|
|
int (*resume_pre)(struct snd_soc_card *card);
|
|
|
|
|
int (*resume_post)(struct snd_soc_card *card);
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2008-01-10 21:36:20 +08:00
|
|
|
/* callbacks */
|
2008-11-19 04:50:34 +08:00
|
|
|
int (*set_bias_level)(struct snd_soc_card *,
|
2011-06-07 02:13:23 +08:00
|
|
|
struct snd_soc_dapm_context *dapm,
|
2008-05-19 18:31:28 +08:00
|
|
|
enum snd_soc_bias_level level);
|
2010-12-04 20:41:04 +08:00
|
|
|
int (*set_bias_level_post)(struct snd_soc_card *,
|
2011-06-07 02:13:23 +08:00
|
|
|
struct snd_soc_dapm_context *dapm,
|
2010-12-04 20:41:04 +08:00
|
|
|
enum snd_soc_bias_level level);
|
2008-01-10 21:36:20 +08:00
|
|
|
|
2015-12-02 14:11:32 +08:00
|
|
|
int (*add_dai_link)(struct snd_soc_card *,
|
|
|
|
|
struct snd_soc_dai_link *link);
|
|
|
|
|
void (*remove_dai_link)(struct snd_soc_card *,
|
|
|
|
|
struct snd_soc_dai_link *link);
|
|
|
|
|
|
2010-02-17 22:30:44 +08:00
|
|
|
long pmdown_time;
|
2010-02-12 19:05:44 +08:00
|
|
|
|
2006-10-07 00:20:14 +08:00
|
|
|
/* CPU <--> Codec DAI links */
|
2015-12-02 14:11:22 +08:00
|
|
|
struct snd_soc_dai_link *dai_link; /* predefined links only */
|
|
|
|
|
int num_links; /* predefined links only */
|
|
|
|
|
|
2015-11-18 15:34:11 +08:00
|
|
|
struct list_head rtd_list;
|
2010-03-18 04:15:21 +08:00
|
|
|
int num_rtd;
|
2008-12-02 23:08:03 +08:00
|
|
|
|
2010-12-02 22:53:03 +08:00
|
|
|
/* optional codec specific configuration */
|
|
|
|
|
struct snd_soc_codec_conf *codec_conf;
|
|
|
|
|
int num_configs;
|
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 02:40:44 +08:00
|
|
|
|
2010-11-25 23:47:38 +08:00
|
|
|
/*
|
|
|
|
|
* optional auxiliary devices such as amplifiers or codecs with DAI
|
|
|
|
|
* link unused
|
|
|
|
|
*/
|
|
|
|
|
struct snd_soc_aux_dev *aux_dev;
|
|
|
|
|
int num_aux_devs;
|
2016-12-29 21:11:21 +08:00
|
|
|
struct list_head aux_comp_list;
|
2010-11-25 23:47:38 +08:00
|
|
|
|
2011-04-07 18:18:44 +08:00
|
|
|
const struct snd_kcontrol_new *controls;
|
|
|
|
|
int num_controls;
|
|
|
|
|
|
2011-03-03 02:35:51 +08:00
|
|
|
/*
|
|
|
|
|
* Card-specific routes and widgets.
|
2015-02-15 09:22:49 +08:00
|
|
|
* Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
|
2011-03-03 02:35:51 +08:00
|
|
|
*/
|
2011-04-13 01:31:01 +08:00
|
|
|
const struct snd_soc_dapm_widget *dapm_widgets;
|
2011-03-03 02:35:51 +08:00
|
|
|
int num_dapm_widgets;
|
2011-04-13 01:31:01 +08:00
|
|
|
const struct snd_soc_dapm_route *dapm_routes;
|
2011-03-03 02:35:51 +08:00
|
|
|
int num_dapm_routes;
|
2015-02-15 09:22:49 +08:00
|
|
|
const struct snd_soc_dapm_widget *of_dapm_widgets;
|
|
|
|
|
int num_of_dapm_widgets;
|
|
|
|
|
const struct snd_soc_dapm_route *of_dapm_routes;
|
|
|
|
|
int num_of_dapm_routes;
|
2011-03-03 02:35:51 +08:00
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
/* lists of probed devices belonging to this card */
|
2016-11-30 14:22:36 +08:00
|
|
|
struct list_head component_dev_list;
|
2018-09-12 17:15:00 +08:00
|
|
|
struct list_head list;
|
2010-11-06 02:35:19 +08:00
|
|
|
|
2010-12-14 18:18:31 +08:00
|
|
|
struct list_head widgets;
|
2010-12-14 18:18:30 +08:00
|
|
|
struct list_head paths;
|
2010-12-14 18:18:32 +08:00
|
|
|
struct list_head dapm_list;
|
2011-10-04 04:06:40 +08:00
|
|
|
struct list_head dapm_dirty;
|
2010-12-14 18:18:30 +08:00
|
|
|
|
2015-05-30 02:06:14 +08:00
|
|
|
/* attached dynamic objects */
|
|
|
|
|
struct list_head dobj_list;
|
|
|
|
|
|
2011-03-03 02:21:57 +08:00
|
|
|
/* Generic DAPM context for the card */
|
|
|
|
|
struct snd_soc_dapm_context dapm;
|
2011-09-21 04:43:24 +08:00
|
|
|
struct snd_soc_dapm_stats dapm_stats;
|
2013-07-29 23:13:55 +08:00
|
|
|
struct snd_soc_dapm_update *update;
|
2011-03-03 02:21:57 +08:00
|
|
|
|
2010-11-06 02:35:19 +08:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
|
struct dentry *debugfs_card_root;
|
2019-08-07 09:31:24 +08:00
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
struct work_struct deferred_resume_work;
|
2010-11-06 02:35:19 +08:00
|
|
|
#endif
|
2010-11-06 02:35:21 +08:00
|
|
|
u32 pop_time;
|
2011-01-28 21:11:47 +08:00
|
|
|
|
2020-05-28 09:47:37 +08:00
|
|
|
/* bit field */
|
|
|
|
|
unsigned int instantiated:1;
|
|
|
|
|
unsigned int topology_shortname_created:1;
|
|
|
|
|
unsigned int fully_routed:1;
|
|
|
|
|
unsigned int disable_route_checks:1;
|
2020-05-28 09:50:21 +08:00
|
|
|
unsigned int probed:1;
|
2020-11-02 23:10:09 +08:00
|
|
|
unsigned int component_chaining:1;
|
2020-05-28 09:47:37 +08:00
|
|
|
|
2011-01-28 21:11:47 +08:00
|
|
|
void *drvdata;
|
2006-10-07 00:20:14 +08:00
|
|
|
};
|
2018-09-18 09:28:49 +08:00
|
|
|
#define for_each_card_prelinks(card, i, link) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
|
|
|
|
|
(i)++)
|
2019-08-08 13:54:44 +08:00
|
|
|
#define for_each_card_pre_auxs(card, i, aux) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
|
|
|
|
|
(i)++)
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2018-09-18 09:29:35 +08:00
|
|
|
#define for_each_card_rtds(card, rtd) \
|
|
|
|
|
list_for_each_entry(rtd, &(card)->rtd_list, list)
|
|
|
|
|
#define for_each_card_rtds_safe(card, rtd, _rtd) \
|
|
|
|
|
list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
|
2018-09-18 09:29:16 +08:00
|
|
|
|
2019-08-08 13:54:44 +08:00
|
|
|
#define for_each_card_auxs(card, component) \
|
|
|
|
|
list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
|
|
|
|
|
#define for_each_card_auxs_safe(card, component, _comp) \
|
|
|
|
|
list_for_each_entry_safe(component, _comp, \
|
|
|
|
|
&card->aux_comp_list, card_aux_list)
|
|
|
|
|
|
2018-09-18 09:29:55 +08:00
|
|
|
#define for_each_card_components(card, component) \
|
|
|
|
|
list_for_each_entry(component, &(card)->component_dev_list, card_list)
|
|
|
|
|
|
2020-03-09 12:08:16 +08:00
|
|
|
#define for_each_card_dapms(card, dapm) \
|
|
|
|
|
list_for_each_entry(dapm, &card->dapm_list, list)
|
|
|
|
|
|
2020-03-09 12:08:21 +08:00
|
|
|
#define for_each_card_widgets(card, w)\
|
|
|
|
|
list_for_each_entry(w, &card->widgets, list)
|
|
|
|
|
#define for_each_card_widgets_safe(card, w, _w) \
|
|
|
|
|
list_for_each_entry_safe(w, _w, &card->widgets, list)
|
|
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
|
2011-11-10 19:46:13 +08:00
|
|
|
struct snd_soc_pcm_runtime {
|
2012-01-07 09:12:45 +08:00
|
|
|
struct device *dev;
|
2008-11-19 04:50:34 +08:00
|
|
|
struct snd_soc_card *card;
|
2010-03-18 04:15:21 +08:00
|
|
|
struct snd_soc_dai_link *dai_link;
|
2011-06-10 00:04:39 +08:00
|
|
|
struct snd_pcm_ops ops;
|
2010-03-18 04:15:21 +08:00
|
|
|
|
2018-09-05 22:21:02 +08:00
|
|
|
unsigned int params_select; /* currently selected param for dai link */
|
|
|
|
|
|
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 19:12:49 +08:00
|
|
|
/* Dynamic PCM BE runtime data */
|
|
|
|
|
struct snd_soc_dpcm_runtime dpcm[2];
|
|
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
long pmdown_time;
|
|
|
|
|
|
|
|
|
|
/* runtime devices */
|
|
|
|
|
struct snd_pcm *pcm;
|
2012-08-16 19:40:40 +08:00
|
|
|
struct snd_compr *compr;
|
2010-03-18 04:15:21 +08:00
|
|
|
|
2020-03-30 09:48:27 +08:00
|
|
|
/*
|
|
|
|
|
* dais = cpu_dai + codec_dai
|
|
|
|
|
* see
|
|
|
|
|
* soc_new_pcm_runtime()
|
|
|
|
|
* asoc_rtd_to_cpu()
|
|
|
|
|
* asoc_rtd_to_codec()
|
|
|
|
|
*/
|
|
|
|
|
struct snd_soc_dai **dais;
|
2014-07-09 05:19:34 +08:00
|
|
|
unsigned int num_codecs;
|
2020-02-25 21:39:12 +08:00
|
|
|
unsigned int num_cpus;
|
|
|
|
|
|
2020-05-27 00:19:30 +08:00
|
|
|
struct snd_soc_dapm_widget *playback_widget;
|
|
|
|
|
struct snd_soc_dapm_widget *capture_widget;
|
|
|
|
|
|
2010-03-18 04:15:21 +08:00
|
|
|
struct delayed_work delayed_work;
|
2019-12-04 01:30:07 +08:00
|
|
|
void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
|
2012-04-25 19:12:50 +08:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
|
struct dentry *debugfs_dpcm_root;
|
|
|
|
|
#endif
|
2015-11-18 15:34:11 +08:00
|
|
|
|
|
|
|
|
unsigned int num; /* 0-based and monotonic increasing */
|
|
|
|
|
struct list_head list; /* rtd list of the soc card */
|
2016-10-24 13:24:36 +08:00
|
|
|
|
ASoC: soc-link: add mark for snd_soc_link_startup/shutdown()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
1) snd_soc_dai_startup/shutdown()
=> 2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
5) pm_runtime_put/get()
This patch is for 2) snd_soc_link_startup/shutdown().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when startup() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* startup() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87k0webwnv.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 08:00:57 +08:00
|
|
|
/* function mark */
|
|
|
|
|
struct snd_pcm_substream *mark_startup;
|
ASoC: soc-link: add mark for snd_soc_link_hw_params/free()
soc_pcm_hw_params() does rollback when failed (A),
but, it is almost same as soc_pcm_hw_free().
static int soc_pcm_hw_params(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return ret;
^ component_err:
| ...
| interface_err:
(A) ...
| codec_err:
| ...
v return ret;
}
The difference is
soc_pcm_hw_free() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_hw_free() and rollback.
Now, soc_pcm_hw_params/free() are handling
=> 1) snd_soc_link_hw_params/free()
2) snd_soc_pcm_component_hw_params/free()
3) snd_soc_dai_hw_params/free()
This patch is for 1) snd_soc_link_hw_params/free().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when hw_params() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here ist that it cares *previous* hw_params() only now,
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87lfgtgqba.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-29 12:31:25 +08:00
|
|
|
struct snd_pcm_substream *mark_hw_params;
|
ASoC: soc-pcm: care trigger rollback
soc_pcm_trigger() calls DAI/Component/Link trigger,
but some of them might be failed.
static int soc_pcm_trigger(...)
{
...
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
ret = snd_soc_link_trigger(substream, cmd);
if (ret < 0)
break;
(*) ret = snd_soc_pcm_component_trigger(substream, cmd);
if (ret < 0)
break;
ret = snd_soc_pcm_dai_trigger(substream, cmd);
break;
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
ret = snd_soc_pcm_dai_trigger(substream, cmd);
if (ret < 0)
break;
ret = snd_soc_pcm_component_trigger(substream, cmd);
if (ret < 0)
break;
ret = snd_soc_link_trigger(substream, cmd);
break;
}
...
}
For example, if soc_pcm_trigger() failed at (*) point,
we need to rollback previous succeeded trigger.
This patch adds trigger mark for DAI/Component/Link,
and do STOP if START/RESUME/PAUSE_RELEASE were failed.
Because it need to use new rollback parameter,
we need to modify DAI/Component/Link trigger functions in the same time.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87a6uycssd.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-12-01 07:51:33 +08:00
|
|
|
struct snd_pcm_substream *mark_trigger;
|
2020-11-19 07:50:14 +08:00
|
|
|
struct snd_compr_stream *mark_compr_startup;
|
ASoC: soc-link: add mark for snd_soc_link_startup/shutdown()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
1) snd_soc_dai_startup/shutdown()
=> 2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
5) pm_runtime_put/get()
This patch is for 2) snd_soc_link_startup/shutdown().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when startup() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* startup() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87k0webwnv.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 08:00:57 +08:00
|
|
|
|
2016-10-24 13:24:36 +08:00
|
|
|
/* bit field */
|
|
|
|
|
unsigned int pop_wait:1;
|
2019-05-13 15:07:27 +08:00
|
|
|
unsigned int fe_compr:1; /* for Dynamic PCM */
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 10:35:21 +08:00
|
|
|
|
|
|
|
|
int num_components;
|
2020-05-08 03:22:28 +08:00
|
|
|
struct snd_soc_component *components[]; /* CPU/Codec/Platform */
|
2006-10-07 00:20:14 +08:00
|
|
|
};
|
2020-03-23 13:16:57 +08:00
|
|
|
/* see soc_new_pcm_runtime() */
|
|
|
|
|
#define asoc_rtd_to_cpu(rtd, n) (rtd)->dais[n]
|
|
|
|
|
#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
|
2020-07-20 09:17:39 +08:00
|
|
|
#define asoc_substream_to_rtd(substream) \
|
|
|
|
|
(struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
|
2020-03-23 13:16:57 +08:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 10:35:21 +08:00
|
|
|
#define for_each_rtd_components(rtd, i, component) \
|
2020-04-29 05:47:31 +08:00
|
|
|
for ((i) = 0, component = NULL; \
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 10:35:21 +08:00
|
|
|
((i) < rtd->num_components) && ((component) = rtd->components[i]);\
|
|
|
|
|
(i)++)
|
2020-03-09 12:07:29 +08:00
|
|
|
#define for_each_rtd_cpu_dais(rtd, i, dai) \
|
|
|
|
|
for ((i) = 0; \
|
2020-03-30 09:47:37 +08:00
|
|
|
((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
|
2020-03-09 12:07:29 +08:00
|
|
|
(i)++)
|
|
|
|
|
#define for_each_rtd_codec_dais(rtd, i, dai) \
|
|
|
|
|
for ((i) = 0; \
|
2020-03-30 09:47:37 +08:00
|
|
|
((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
|
2020-03-09 12:07:29 +08:00
|
|
|
(i)++)
|
2020-03-16 14:36:58 +08:00
|
|
|
#define for_each_rtd_dais(rtd, i, dai) \
|
|
|
|
|
for ((i) = 0; \
|
|
|
|
|
((i) < (rtd)->num_cpus + (rtd)->num_codecs) && \
|
|
|
|
|
((dai) = (rtd)->dais[i]); \
|
|
|
|
|
(i)++)
|
2020-03-09 12:07:29 +08:00
|
|
|
|
2020-01-10 10:36:17 +08:00
|
|
|
void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
|
2006-10-07 00:20:14 +08:00
|
|
|
|
2008-07-29 18:42:26 +08:00
|
|
|
/* mixer control */
|
|
|
|
|
struct soc_mixer_control {
|
2010-05-10 19:39:24 +08:00
|
|
|
int min, max, platform_max;
|
2013-10-06 19:43:49 +08:00
|
|
|
int reg, rreg;
|
|
|
|
|
unsigned int shift, rshift;
|
2014-01-16 23:02:10 +08:00
|
|
|
unsigned int sign_bit;
|
2013-08-05 17:27:31 +08:00
|
|
|
unsigned int invert:1;
|
|
|
|
|
unsigned int autodisable:1;
|
2019-11-05 14:47:26 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_TOPOLOGY
|
2015-05-30 02:06:14 +08:00
|
|
|
struct snd_soc_dobj dobj;
|
2019-11-05 14:47:26 +08:00
|
|
|
#endif
|
2008-07-29 18:42:26 +08:00
|
|
|
};
|
|
|
|
|
|
2011-10-11 01:31:26 +08:00
|
|
|
struct soc_bytes {
|
|
|
|
|
int base;
|
|
|
|
|
int num_regs;
|
2012-02-18 08:20:33 +08:00
|
|
|
u32 mask;
|
2011-10-11 01:31:26 +08:00
|
|
|
};
|
|
|
|
|
|
2014-05-02 13:28:11 +08:00
|
|
|
struct soc_bytes_ext {
|
|
|
|
|
int max;
|
2019-11-05 14:47:26 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_TOPOLOGY
|
2015-05-30 02:06:14 +08:00
|
|
|
struct snd_soc_dobj dobj;
|
2019-11-05 14:47:26 +08:00
|
|
|
#endif
|
2014-07-16 00:04:48 +08:00
|
|
|
/* used for TLV byte control */
|
2015-11-10 01:50:00 +08:00
|
|
|
int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
|
|
|
|
|
unsigned int size);
|
|
|
|
|
int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
|
|
|
|
|
unsigned int size);
|
2014-05-02 13:28:11 +08:00
|
|
|
};
|
|
|
|
|
|
2012-04-20 17:32:13 +08:00
|
|
|
/* multi register control */
|
|
|
|
|
struct soc_mreg_control {
|
|
|
|
|
long min, max;
|
|
|
|
|
unsigned int regbase, regcount, nbits, invert;
|
|
|
|
|
};
|
|
|
|
|
|
2006-10-07 00:20:14 +08:00
|
|
|
/* enumerated kcontrol */
|
|
|
|
|
struct soc_enum {
|
2014-02-28 15:31:05 +08:00
|
|
|
int reg;
|
2009-01-05 15:54:57 +08:00
|
|
|
unsigned char shift_l;
|
|
|
|
|
unsigned char shift_r;
|
2014-02-18 15:11:42 +08:00
|
|
|
unsigned int items;
|
2009-01-05 15:54:57 +08:00
|
|
|
unsigned int mask;
|
2011-05-03 18:50:29 +08:00
|
|
|
const char * const *texts;
|
2009-01-05 15:54:57 +08:00
|
|
|
const unsigned int *values;
|
2015-05-01 19:37:26 +08:00
|
|
|
unsigned int autodisable:1;
|
2019-11-05 14:47:26 +08:00
|
|
|
#ifdef CONFIG_SND_SOC_TOPOLOGY
|
2015-05-30 02:06:14 +08:00
|
|
|
struct snd_soc_dobj dobj;
|
2019-11-05 14:47:26 +08:00
|
|
|
#endif
|
2009-01-05 15:54:57 +08:00
|
|
|
};
|
|
|
|
|
|
2011-10-05 15:29:22 +08:00
|
|
|
static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
|
|
|
|
|
{
|
|
|
|
|
if (mc->reg == mc->rreg && mc->shift == mc->rshift)
|
2020-04-22 15:18:05 +08:00
|
|
|
return false;
|
2011-10-05 15:29:22 +08:00
|
|
|
/*
|
|
|
|
|
* mc->reg == mc->rreg && mc->shift != mc->rshift, or
|
|
|
|
|
* mc->reg != mc->rreg means that the control is
|
|
|
|
|
* stereo (bits in one register or in two registers)
|
|
|
|
|
*/
|
2020-04-22 15:18:05 +08:00
|
|
|
return true;
|
2011-10-05 15:29:22 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-28 15:31:03 +08:00
|
|
|
static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
|
|
|
|
|
unsigned int val)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
if (!e->values)
|
|
|
|
|
return val;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < e->items; i++)
|
|
|
|
|
if (val == e->values[i])
|
|
|
|
|
return i;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
|
|
|
|
|
unsigned int item)
|
|
|
|
|
{
|
|
|
|
|
if (!e->values)
|
|
|
|
|
return item;
|
|
|
|
|
|
|
|
|
|
return e->values[item];
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-22 19:23:14 +08:00
|
|
|
/**
|
|
|
|
|
* snd_soc_kcontrol_component() - Returns the component that registered the
|
|
|
|
|
* control
|
|
|
|
|
* @kcontrol: The control for which to get the component
|
|
|
|
|
*
|
|
|
|
|
* Note: This function will work correctly if the control has been registered
|
2018-04-24 23:39:02 +08:00
|
|
|
* for a component. With snd_soc_add_codec_controls() or via table based
|
|
|
|
|
* setup for either a CODEC or component driver. Otherwise the behavior is
|
|
|
|
|
* undefined.
|
2014-04-22 19:23:14 +08:00
|
|
|
*/
|
|
|
|
|
static inline struct snd_soc_component *snd_soc_kcontrol_component(
|
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
|
{
|
|
|
|
|
return snd_kcontrol_chip(kcontrol);
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-28 17:57:54 +08:00
|
|
|
int snd_soc_util_init(void);
|
|
|
|
|
void snd_soc_util_exit(void);
|
|
|
|
|
|
2017-01-27 14:37:51 +08:00
|
|
|
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
|
|
|
|
|
const char *propname);
|
2017-01-27 14:37:34 +08:00
|
|
|
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
|
|
|
|
|
const char *propname);
|
2018-07-17 23:43:02 +08:00
|
|
|
int snd_soc_of_get_slot_mask(struct device_node *np,
|
|
|
|
|
const char *prop_name,
|
|
|
|
|
unsigned int *mask);
|
2014-02-14 09:34:35 +08:00
|
|
|
int snd_soc_of_parse_tdm_slot(struct device_node *np,
|
2015-09-10 02:27:43 +08:00
|
|
|
unsigned int *tx_mask,
|
|
|
|
|
unsigned int *rx_mask,
|
2014-02-14 09:34:35 +08:00
|
|
|
unsigned int *slots,
|
|
|
|
|
unsigned int *slot_width);
|
2018-11-22 08:55:09 +08:00
|
|
|
void snd_soc_of_parse_node_prefix(struct device_node *np,
|
2015-07-15 15:07:42 +08:00
|
|
|
struct snd_soc_codec_conf *codec_conf,
|
|
|
|
|
struct device_node *of_node,
|
|
|
|
|
const char *propname);
|
2018-11-26 09:21:22 +08:00
|
|
|
static inline
|
|
|
|
|
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
|
|
|
|
|
struct snd_soc_codec_conf *codec_conf,
|
|
|
|
|
struct device_node *of_node,
|
|
|
|
|
const char *propname)
|
|
|
|
|
{
|
|
|
|
|
snd_soc_of_parse_node_prefix(card->dev->of_node,
|
|
|
|
|
codec_conf, of_node, propname);
|
|
|
|
|
}
|
2018-11-22 08:55:09 +08:00
|
|
|
|
2017-01-27 14:36:50 +08:00
|
|
|
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
|
|
|
|
|
const char *propname);
|
2020-08-01 18:02:55 +08:00
|
|
|
int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
|
2013-01-15 10:36:04 +08:00
|
|
|
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
|
2014-03-24 18:15:24 +08:00
|
|
|
const char *prefix,
|
|
|
|
|
struct device_node **bitclkmaster,
|
|
|
|
|
struct device_node **framemaster);
|
2017-05-18 09:39:25 +08:00
|
|
|
int snd_soc_get_dai_id(struct device_node *ep);
|
2016-11-11 09:19:28 +08:00
|
|
|
int snd_soc_get_dai_name(struct of_phandle_args *args,
|
|
|
|
|
const char **dai_name);
|
2013-09-11 08:39:56 +08:00
|
|
|
int snd_soc_of_get_dai_name(struct device_node *of_node,
|
|
|
|
|
const char **dai_name);
|
2014-11-25 20:16:12 +08:00
|
|
|
int snd_soc_of_get_dai_link_codecs(struct device *dev,
|
|
|
|
|
struct device_node *of_node,
|
|
|
|
|
struct snd_soc_dai_link *dai_link);
|
2018-03-10 01:48:54 +08:00
|
|
|
void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
|
2011-12-13 06:55:34 +08:00
|
|
|
|
2019-12-10 08:34:19 +08:00
|
|
|
int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
|
struct snd_soc_dai_link *dai_link);
|
2019-12-10 08:34:23 +08:00
|
|
|
void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd);
|
2015-12-02 14:11:22 +08:00
|
|
|
|
2019-11-05 14:47:14 +08:00
|
|
|
struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
|
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
|
bool legacy_dai_naming);
|
2020-06-13 04:59:37 +08:00
|
|
|
struct snd_soc_dai *devm_snd_soc_register_dai(struct device *dev,
|
|
|
|
|
struct snd_soc_component *component,
|
|
|
|
|
struct snd_soc_dai_driver *dai_drv,
|
|
|
|
|
bool legacy_dai_naming);
|
2019-11-05 14:47:04 +08:00
|
|
|
void snd_soc_unregister_dai(struct snd_soc_dai *dai);
|
2015-12-31 16:40:43 +08:00
|
|
|
|
2016-04-19 13:12:25 +08:00
|
|
|
struct snd_soc_dai *snd_soc_find_dai(
|
|
|
|
|
const struct snd_soc_dai_link_component *dlc);
|
2020-08-27 07:55:39 +08:00
|
|
|
struct snd_soc_dai *snd_soc_find_dai_with_mutex(
|
|
|
|
|
const struct snd_soc_dai_link_component *dlc);
|
2016-04-19 13:12:25 +08:00
|
|
|
|
2008-07-23 21:03:07 +08:00
|
|
|
#include <sound/soc-dai.h>
|
|
|
|
|
|
2019-01-26 04:34:55 +08:00
|
|
|
static inline
|
|
|
|
|
int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
|
|
|
|
|
const char *platform_name)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_dai_link *dai_link;
|
|
|
|
|
const char *name;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!platform_name) /* nothing to do */
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* set platform name for each dailink */
|
|
|
|
|
for_each_card_prelinks(card, i, dai_link) {
|
|
|
|
|
name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
|
|
|
|
|
if (!name)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2019-06-06 12:22:19 +08:00
|
|
|
if (!dai_link->platforms)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* only single platform is supported for now */
|
|
|
|
|
dai_link->platforms->name = name;
|
2019-01-26 04:34:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-08 13:36:11 +08:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-11 06:25:21 +08:00
|
|
|
extern struct dentry *snd_soc_debugfs_root;
|
2011-01-08 13:36:11 +08:00
|
|
|
#endif
|
|
|
|
|
|
2011-01-26 22:59:27 +08:00
|
|
|
extern const struct dev_pm_ops snd_soc_pm_ops;
|
|
|
|
|
|
2014-02-18 23:22:13 +08:00
|
|
|
/* Helper functions */
|
|
|
|
|
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
|
|
|
|
|
{
|
2015-12-30 00:25:13 +08:00
|
|
|
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
|
2014-02-18 23:22:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
|
|
|
|
|
{
|
|
|
|
|
mutex_unlock(&dapm->card->dapm_mutex);
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-26 12:49:48 +08:00
|
|
|
#include <sound/soc-component.h>
|
2020-05-28 09:47:46 +08:00
|
|
|
#include <sound/soc-card.h>
|
2020-11-30 07:45:26 +08:00
|
|
|
#include <sound/soc-jack.h>
|
2016-11-29 23:44:38 +08:00
|
|
|
|
2006-10-07 00:20:14 +08:00
|
|
|
#endif
|