2006-10-06 18:20:14 +02:00
|
|
|
/*
|
|
|
|
* linux/sound/soc.h -- ALSA SoC Layer
|
|
|
|
*
|
|
|
|
* Author: Liam Girdwood
|
|
|
|
* Created: Aug 11th 2005
|
|
|
|
* Copyright: Wolfson Microelectronics. PLC.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_SND_SOC_H
|
|
|
|
#define __LINUX_SND_SOC_H
|
|
|
|
|
2013-09-11 02:39:56 +02:00
|
|
|
#include <linux/of.h>
|
2006-10-06 18:20:14 +02:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/types.h>
|
2010-03-22 13:06:30 +01:00
|
|
|
#include <linux/notifier.h>
|
2006-12-15 09:30:07 +01:00
|
|
|
#include <linux/workqueue.h>
|
2009-03-03 22:25:04 +01:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel.h>
|
2011-06-13 20:35:29 +02:00
|
|
|
#include <linux/regmap.h>
|
2012-09-14 13:57:27 +02:00
|
|
|
#include <linux/log2.h>
|
2006-10-06 18:20:14 +02:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/pcm.h>
|
2012-08-16 13:40:40 +02:00
|
|
|
#include <sound/compress_driver.h>
|
2006-10-06 18:20:14 +02:00
|
|
|
#include <sound/control.h>
|
|
|
|
#include <sound/ac97_codec.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convenience kcontrol builders
|
|
|
|
*/
|
2013-08-05 11:27:31 +02:00
|
|
|
#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
|
2008-07-29 12:42:26 +02:00
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
2011-10-05 09:29:22 +02:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = shift_left, \
|
|
|
|
.rshift = shift_right, .max = xmax, .platform_max = xmax, \
|
2013-08-05 11:27:31 +02:00
|
|
|
.invert = xinvert, .autodisable = xautodisable})
|
2014-10-25 20:25:56 +02: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 11:27:31 +02:00
|
|
|
#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
|
|
|
|
SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
|
2008-07-29 12:42:26 +02:00
|
|
|
#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
|
|
|
|
((unsigned long)&(struct soc_mixer_control) \
|
2010-05-10 13:39:24 +02:00
|
|
|
{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
|
2011-10-04 13:39:39 +02: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 16:02:11 +01: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 12:40:55 +02: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 14:37:42 +01:00
|
|
|
#define SOC_SINGLE(xname, reg, shift, max, invert) \
|
2006-10-06 18:20:14 +02: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 11:27:31 +02:00
|
|
|
.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
|
2012-05-31 16:18:01 +02: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-19 17:05:00 +01:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = xshift, \
|
|
|
|
.rshift = xshift, .min = xmin, .max = xmax, \
|
|
|
|
.platform_max = xmax, .invert = xinvert} }
|
2008-01-10 14:37:42 +01: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 11:27:31 +02:00
|
|
|
.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
|
2012-03-30 17:43:55 +02: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 14:31:24 +02:00
|
|
|
.info = snd_soc_info_volsw_sx, \
|
2012-03-30 17:43:55 +02: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 16:18:01 +02: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-19 17:05:00 +01:00
|
|
|
{.reg = xreg, .rreg = xreg, .shift = xshift, \
|
|
|
|
.rshift = xshift, .min = xmin, .max = xmax, \
|
|
|
|
.platform_max = xmax, .invert = xinvert} }
|
2011-10-04 13:39:38 +02:00
|
|
|
#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
|
2006-10-06 18:20:14 +02: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 13:39:38 +02:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
|
2013-08-05 11:27:31 +02:00
|
|
|
max, invert, 0) }
|
2015-12-08 16:58:58 +01: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 12:42:26 +02:00
|
|
|
#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
|
2006-10-06 18:20:14 +02:00
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
|
2011-10-05 09:29:23 +02:00
|
|
|
.info = snd_soc_info_volsw, \
|
2011-10-05 09:29:25 +02:00
|
|
|
.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
|
2011-10-04 13:39:39 +02:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
xmax, xinvert) }
|
2012-06-22 12:40:55 +02: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 13:39:38 +02:00
|
|
|
#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
|
2008-01-10 14:37:42 +01: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 13:39:38 +02:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
|
2013-08-05 11:27:31 +02:00
|
|
|
max, invert, 0) }
|
2008-07-29 12:42:26 +02:00
|
|
|
#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
|
2008-01-10 14:37:42 +01: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 09:29:23 +02:00
|
|
|
.info = snd_soc_info_volsw, \
|
2011-10-05 09:29:25 +02:00
|
|
|
.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
|
2011-10-04 13:39:39 +02:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
xmax, xinvert) }
|
2012-06-22 12:40:55 +02: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 17:43:55 +02: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 14:31:24 +02:00
|
|
|
.info = snd_soc_info_volsw_sx, \
|
2012-03-30 17:43:55 +02: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 16:02:11 +01: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 15:45:45 +02: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 12:42:26 +02:00
|
|
|
#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
|
2008-05-28 18:58:05 +02: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-25 20:25:56 +02: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 08:11:42 +01:00
|
|
|
#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
|
2006-10-06 18:20:14 +02:00
|
|
|
{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
|
2014-02-18 08:11:42 +01: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 08:54:57 +01:00
|
|
|
{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
|
2014-02-18 08:11:42 +01:00
|
|
|
.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
|
2015-05-01 13:37:23 +02: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 13:37:26 +02: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 08:31:05 +01:00
|
|
|
#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
|
|
|
|
SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
|
2006-10-06 18:20:14 +02: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 12:42:27 +02:00
|
|
|
#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
|
2006-10-06 18:20:14 +02:00
|
|
|
xhandler_get, xhandler_put) \
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
|
2007-02-02 17:13:05 +01:00
|
|
|
.info = snd_soc_info_volsw, \
|
2006-10-06 18:20:14 +02:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2013-08-05 11:27:31 +02:00
|
|
|
.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
|
2011-10-04 13:39:38 +02:00
|
|
|
#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
|
2009-04-24 16:37:44 +02: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 13:39:38 +02:00
|
|
|
.private_value = \
|
2013-08-05 11:27:31 +02:00
|
|
|
SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
|
2015-09-29 17:43:56 +02: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 12:42:27 +02:00
|
|
|
#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
|
2008-06-11 14:47:13 +02: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 11:27:31 +02:00
|
|
|
.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
|
2015-09-16 14:59:42 +02: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 13:33:47 +02: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 13:39:38 +02:00
|
|
|
.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
|
2013-08-05 11:27:31 +02:00
|
|
|
xmax, xinvert, 0) }
|
2009-07-15 13:33:50 +02: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 09:29:23 +02:00
|
|
|
.info = snd_soc_info_volsw, \
|
2009-07-15 13:33:50 +02:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
2011-10-04 13:39:39 +02:00
|
|
|
.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
|
|
|
|
xmax, xinvert) }
|
2006-10-06 18:20:14 +02: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-10 21:33:10 +02:00
|
|
|
.info = snd_soc_info_enum_double, \
|
2006-10-06 18:20:14 +02:00
|
|
|
.get = xhandler_get, .put = xhandler_put, \
|
|
|
|
.private_value = (unsigned long)&xenum }
|
2014-07-07 14:16:54 +02:00
|
|
|
#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
|
|
|
|
SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2011-10-10 19:31:26 +02: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 }) }
|
2010-05-15 17:30:01 +02:00
|
|
|
|
2012-02-18 01:20:33 +01: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 16:52:29 +01:00
|
|
|
/*
|
|
|
|
* SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
|
|
|
|
*/
|
2014-05-02 07:28:11 +02: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-15 18:04:48 +02: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 11:23:03 +02:00
|
|
|
.info = snd_soc_bytes_info_ext, \
|
2014-07-15 18:04:48 +02:00
|
|
|
.private_value = (unsigned long)&(struct soc_bytes_ext) \
|
|
|
|
{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
|
2012-04-20 11:32:13 +02: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 11:32:44 +02: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-21 22:04:03 +01: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 09:08:51 +01:00
|
|
|
const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
|
2010-01-21 22:04:03 +01: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 09:08:51 +01:00
|
|
|
const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
|
2010-01-21 22:04:03 +01:00
|
|
|
#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
|
2014-02-18 09:08:51 +01:00
|
|
|
const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
|
2010-01-21 22:04:03 +01: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 13:37:26 +02: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 08:31:05 +01:00
|
|
|
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
|
|
|
|
const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
|
2010-01-21 22:04:03 +01:00
|
|
|
|
2011-06-07 17:08:05 +02:00
|
|
|
/*
|
|
|
|
* Component probe and remove ordering levels for components with runtime
|
|
|
|
* dependencies.
|
|
|
|
*/
|
|
|
|
#define SND_SOC_COMP_ORDER_FIRST -2
|
|
|
|
#define SND_SOC_COMP_ORDER_EARLY -1
|
|
|
|
#define SND_SOC_COMP_ORDER_NORMAL 0
|
|
|
|
#define SND_SOC_COMP_ORDER_LATE 1
|
|
|
|
#define SND_SOC_COMP_ORDER_LAST 2
|
|
|
|
|
2008-05-19 12:31:28 +02:00
|
|
|
/*
|
|
|
|
* Bias levels
|
|
|
|
*
|
|
|
|
* @ON: Bias is fully on for audio playback and capture operations.
|
|
|
|
* @PREPARE: Prepare for audio operations. Called before DAPM switching for
|
|
|
|
* stream start and stop operations.
|
|
|
|
* @STANDBY: Low power standby state when no playback/capture operations are
|
|
|
|
* in progress. NOTE: The transition time between STANDBY and ON
|
|
|
|
* should be as fast as possible and no longer than 10ms.
|
|
|
|
* @OFF: Power Off. No restrictions on transition times.
|
|
|
|
*/
|
|
|
|
enum snd_soc_bias_level {
|
2011-06-04 12:25:10 +02:00
|
|
|
SND_SOC_BIAS_OFF = 0,
|
|
|
|
SND_SOC_BIAS_STANDBY = 1,
|
|
|
|
SND_SOC_BIAS_PREPARE = 2,
|
|
|
|
SND_SOC_BIAS_ON = 3,
|
2008-05-19 12:31:28 +02:00
|
|
|
};
|
|
|
|
|
2011-12-21 18:40:59 +01:00
|
|
|
struct device_node;
|
2009-01-07 18:31:10 +01:00
|
|
|
struct snd_jack;
|
|
|
|
struct snd_soc_card;
|
2006-10-06 18:20:14 +02:00
|
|
|
struct snd_soc_pcm_stream;
|
|
|
|
struct snd_soc_ops;
|
|
|
|
struct snd_soc_pcm_runtime;
|
2008-07-07 17:07:17 +02:00
|
|
|
struct snd_soc_dai;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_dai_driver;
|
2008-12-03 20:40:30 +01:00
|
|
|
struct snd_soc_platform;
|
2010-02-22 07:58:04 +01:00
|
|
|
struct snd_soc_dai_link;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_platform_driver;
|
2006-10-06 18:20:14 +02:00
|
|
|
struct snd_soc_codec;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_codec_driver;
|
2013-03-12 02:27:21 +01:00
|
|
|
struct snd_soc_component;
|
|
|
|
struct snd_soc_component_driver;
|
2006-10-06 18:20:14 +02:00
|
|
|
struct soc_enum;
|
2009-01-07 18:31:10 +01:00
|
|
|
struct snd_soc_jack;
|
2011-02-09 10:14:17 +01:00
|
|
|
struct snd_soc_jack_zone;
|
2009-01-07 18:31:10 +01:00
|
|
|
struct snd_soc_jack_pin;
|
2010-11-05 14:53:46 +01: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 13:12:49 +02:00
|
|
|
#include <sound/soc-dpcm.h>
|
2016-01-15 09:13:28 +01:00
|
|
|
#include <sound/soc-topology.h>
|
2010-03-17 21:15:21 +01:00
|
|
|
|
2009-03-03 22:25:04 +01:00
|
|
|
struct snd_soc_jack_gpio;
|
2006-10-06 18:20:14 +02:00
|
|
|
|
|
|
|
typedef int (*hw_write_t)(void *,const char* ,int);
|
|
|
|
|
2011-06-09 18:04:39 +02:00
|
|
|
enum snd_soc_pcm_subclass {
|
|
|
|
SND_SOC_PCM_CLASS_PCM = 0,
|
|
|
|
SND_SOC_PCM_CLASS_BE = 1,
|
|
|
|
};
|
|
|
|
|
2012-03-07 11:38:25 +01:00
|
|
|
enum snd_soc_card_subclass {
|
2012-03-09 13:02:07 +01:00
|
|
|
SND_SOC_CARD_CLASS_INIT = 0,
|
|
|
|
SND_SOC_CARD_CLASS_RUNTIME = 1,
|
2012-03-07 11:38:25 +01:00
|
|
|
};
|
|
|
|
|
2011-03-07 21:58:11 +01:00
|
|
|
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
|
2011-08-24 21:09:01 +02:00
|
|
|
int source, unsigned int freq, int dir);
|
2011-03-07 21:58:11 +01:00
|
|
|
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
|
|
|
|
unsigned int freq_in, unsigned int freq_out);
|
|
|
|
|
2011-01-14 14:52:48 +01:00
|
|
|
int snd_soc_register_card(struct snd_soc_card *card);
|
|
|
|
int snd_soc_unregister_card(struct snd_soc_card *card);
|
2013-09-16 19:02:05 +02:00
|
|
|
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
|
2015-04-19 03:45:48 +02:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2011-01-26 15:59:27 +01:00
|
|
|
int snd_soc_suspend(struct device *dev);
|
|
|
|
int snd_soc_resume(struct device *dev);
|
2015-04-19 03:45:48 +02: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 15:59:27 +01:00
|
|
|
int snd_soc_poweroff(struct device *dev);
|
2010-03-17 21:15:21 +01:00
|
|
|
int snd_soc_register_platform(struct device *dev,
|
2013-03-27 12:02:22 +01:00
|
|
|
const struct snd_soc_platform_driver *platform_drv);
|
2014-04-16 14:46:11 +02:00
|
|
|
int devm_snd_soc_register_platform(struct device *dev,
|
|
|
|
const struct snd_soc_platform_driver *platform_drv);
|
2010-03-17 21:15:21 +01:00
|
|
|
void snd_soc_unregister_platform(struct device *dev);
|
2013-04-15 19:19:49 +02:00
|
|
|
int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
|
|
|
|
const struct snd_soc_platform_driver *platform_drv);
|
|
|
|
void snd_soc_remove_platform(struct snd_soc_platform *platform);
|
|
|
|
struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev);
|
2010-03-17 21:15:21 +01:00
|
|
|
int snd_soc_register_codec(struct device *dev,
|
2010-12-02 17:21:08 +01:00
|
|
|
const struct snd_soc_codec_driver *codec_drv,
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_dai_driver *dai_drv, int num_dai);
|
|
|
|
void snd_soc_unregister_codec(struct device *dev);
|
2013-03-12 02:27:21 +01:00
|
|
|
int snd_soc_register_component(struct device *dev,
|
|
|
|
const struct snd_soc_component_driver *cmpnt_drv,
|
|
|
|
struct snd_soc_dai_driver *dai_drv, int num_dai);
|
2013-09-04 21:37:34 +02:00
|
|
|
int devm_snd_soc_register_component(struct device *dev,
|
|
|
|
const struct snd_soc_component_driver *cmpnt_drv,
|
|
|
|
struct snd_soc_dai_driver *dai_drv, int num_dai);
|
2013-03-12 02:27:21 +01:00
|
|
|
void snd_soc_unregister_component(struct device *dev);
|
2010-11-11 11:04:57 +01:00
|
|
|
int snd_soc_cache_init(struct snd_soc_codec *codec);
|
|
|
|
int snd_soc_cache_exit(struct snd_soc_codec *codec);
|
2014-11-08 16:38:07 +01:00
|
|
|
|
2011-07-04 12:10:15 +02:00
|
|
|
int snd_soc_platform_read(struct snd_soc_platform *platform,
|
|
|
|
unsigned int reg);
|
|
|
|
int snd_soc_platform_write(struct snd_soc_platform *platform,
|
|
|
|
unsigned int reg, unsigned int val);
|
2011-12-22 13:16:39 +01:00
|
|
|
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
|
2015-10-13 17:41:00 +02:00
|
|
|
#ifdef CONFIG_SND_SOC_COMPRESS
|
|
|
|
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
|
|
|
|
#endif
|
2008-12-03 20:40:30 +01:00
|
|
|
|
2012-04-25 13:12:53 +02:00
|
|
|
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
|
|
|
|
const char *dai_link, int stream);
|
|
|
|
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
|
|
|
|
const char *dai_link);
|
|
|
|
|
2014-03-05 13:17:42 +01:00
|
|
|
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
|
2014-03-05 13:17:43 +01:00
|
|
|
void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd, int stream);
|
|
|
|
void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd, int stream);
|
2014-03-05 13:17:42 +01:00
|
|
|
|
2015-01-06 15:17:20 +01:00
|
|
|
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
|
|
|
|
unsigned int dai_fmt);
|
|
|
|
|
2009-11-10 17:08:04 +01: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 12:36:10 +01:00
|
|
|
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
|
2009-11-10 17:08:04 +01:00
|
|
|
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
|
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
/* set runtime hw params */
|
|
|
|
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
|
|
|
|
const struct snd_pcm_hardware *hw);
|
|
|
|
|
2012-04-25 13:12:52 +02:00
|
|
|
int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
|
|
|
|
int cmd, struct snd_soc_platform *platform);
|
|
|
|
|
2014-07-08 23:19:38 +02:00
|
|
|
int soc_dai_hw_params(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *params,
|
|
|
|
struct snd_soc_dai *dai);
|
|
|
|
|
2009-01-07 18:31:10 +01:00
|
|
|
/* Jack reporting */
|
2015-03-04 10:33:17 +01:00
|
|
|
int snd_soc_card_jack_new(struct snd_soc_card *card, const char *id, int type,
|
|
|
|
struct snd_soc_jack *jack, struct snd_soc_jack_pin *pins,
|
|
|
|
unsigned int num_pins);
|
|
|
|
|
2009-01-07 18:31:10 +01:00
|
|
|
void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
|
|
|
|
int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_pin *pins);
|
2010-03-22 13:06:30 +01:00
|
|
|
void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
|
|
|
|
struct notifier_block *nb);
|
|
|
|
void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
|
|
|
|
struct notifier_block *nb);
|
2011-02-09 10:14:17 +01:00
|
|
|
int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_zone *zones);
|
|
|
|
int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
|
2009-03-03 22:25:04 +01:00
|
|
|
#ifdef CONFIG_GPIOLIB
|
|
|
|
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_gpio *gpios);
|
2014-05-26 13:34:37 +02:00
|
|
|
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
|
|
|
|
struct snd_soc_jack *jack,
|
|
|
|
int count, struct snd_soc_jack_gpio *gpios);
|
2009-03-03 22:25:04 +01:00
|
|
|
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_gpio *gpios);
|
2013-11-21 15:55:06 +01:00
|
|
|
#else
|
|
|
|
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_gpio *gpios)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-27 09:39:57 +02:00
|
|
|
static inline int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
|
|
|
|
struct snd_soc_jack *jack,
|
|
|
|
int count,
|
|
|
|
struct snd_soc_jack_gpio *gpios)
|
2014-05-26 13:34:37 +02:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-21 15:55:06 +01:00
|
|
|
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
|
|
|
|
struct snd_soc_jack_gpio *gpios)
|
|
|
|
{
|
|
|
|
}
|
2009-03-03 22:25:04 +01:00
|
|
|
#endif
|
2009-01-07 18:31:10 +01:00
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
/* codec register bit access */
|
2014-04-08 05:18:10 +02:00
|
|
|
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
|
2009-06-07 07:49:11 +02:00
|
|
|
unsigned int mask, unsigned int value);
|
2009-12-04 15:22:03 +01:00
|
|
|
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
|
2014-04-08 05:18:10 +02:00
|
|
|
unsigned int reg, unsigned int mask,
|
2009-12-04 15:22:03 +01:00
|
|
|
unsigned int value);
|
2014-04-08 05:18:10 +02:00
|
|
|
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
|
2009-06-07 07:49:11 +02:00
|
|
|
unsigned int mask, unsigned int value);
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2014-11-10 22:41:46 +01:00
|
|
|
#ifdef CONFIG_SND_SOC_AC97_BUS
|
2015-01-23 16:21:36 +01:00
|
|
|
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
|
2015-07-21 21:53:01 +02:00
|
|
|
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
|
|
|
|
unsigned int id, unsigned int id_mask);
|
2014-11-10 22:41:53 +01:00
|
|
|
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2013-06-26 13:45:59 +02:00
|
|
|
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
|
2013-08-19 17:05:55 +02:00
|
|
|
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
|
|
|
|
struct platform_device *pdev);
|
2013-06-26 13:45:59 +02:00
|
|
|
|
2014-11-10 22:41:46 +01: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-06 18:20:14 +02:00
|
|
|
/*
|
|
|
|
*Controls
|
|
|
|
*/
|
|
|
|
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
|
2012-02-17 02:07:42 +01:00
|
|
|
void *data, const char *long_name,
|
2011-03-08 18:23:24 +01:00
|
|
|
const char *prefix);
|
2013-07-29 14:51:58 +02:00
|
|
|
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
|
|
|
|
const char *name);
|
2014-07-17 22:01:08 +02:00
|
|
|
int snd_soc_add_component_controls(struct snd_soc_component *component,
|
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls);
|
2012-02-03 18:43:09 +01:00
|
|
|
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
|
2014-07-17 22:01:08 +02:00
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls);
|
2011-07-04 23:10:51 +02:00
|
|
|
int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
|
2014-07-17 22:01:08 +02:00
|
|
|
const struct snd_kcontrol_new *controls, unsigned int num_controls);
|
2012-02-03 18:43:09 +01: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-06 18:20:14 +02: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 14:31:24 +02:00
|
|
|
int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo);
|
2008-05-13 14:03:40 +02:00
|
|
|
#define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
|
2006-10-06 18:20:14 +02: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 06:43:21 +02:00
|
|
|
#define snd_soc_get_volsw_2r snd_soc_get_volsw
|
|
|
|
#define snd_soc_put_volsw_2r snd_soc_put_volsw
|
2012-03-30 17:43:55 +02: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 16:18:01 +02: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 17:04:33 +02:00
|
|
|
int snd_soc_limit_volume(struct snd_soc_card *card,
|
2010-05-07 13:05:49 +02:00
|
|
|
const char *name, int max);
|
2011-10-10 19:31:26 +02: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 07:28:11 +02:00
|
|
|
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *ucontrol);
|
2014-07-15 18:04:48 +02:00
|
|
|
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
unsigned int size, unsigned int __user *tlv);
|
2012-04-20 11:32:13 +02: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 11:32:44 +02: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-06 18:20:14 +02:00
|
|
|
|
2009-01-07 18:31:10 +01:00
|
|
|
/**
|
|
|
|
* struct snd_soc_jack_pin - Describes a pin to update based on jack detection
|
|
|
|
*
|
|
|
|
* @pin: name of the pin to update
|
|
|
|
* @mask: bits to check for in reported jack status
|
|
|
|
* @invert: if non-zero then pin is enabled when status is not reported
|
2015-08-25 09:14:48 +02:00
|
|
|
* @list: internal list entry
|
2009-01-07 18:31:10 +01:00
|
|
|
*/
|
|
|
|
struct snd_soc_jack_pin {
|
|
|
|
struct list_head list;
|
|
|
|
const char *pin;
|
|
|
|
int mask;
|
|
|
|
bool invert;
|
|
|
|
};
|
|
|
|
|
2011-02-09 10:14:17 +01:00
|
|
|
/**
|
|
|
|
* struct snd_soc_jack_zone - Describes voltage zones of jack detection
|
|
|
|
*
|
|
|
|
* @min_mv: start voltage in mv
|
|
|
|
* @max_mv: end voltage in mv
|
|
|
|
* @jack_type: type of jack that is expected for this voltage
|
|
|
|
* @debounce_time: debounce_time for jack, codec driver should wait for this
|
|
|
|
* duration before reading the adc for voltages
|
2015-08-25 09:14:48 +02:00
|
|
|
* @list: internal list entry
|
2011-02-09 10:14:17 +01:00
|
|
|
*/
|
|
|
|
struct snd_soc_jack_zone {
|
|
|
|
unsigned int min_mv;
|
|
|
|
unsigned int max_mv;
|
|
|
|
unsigned int jack_type;
|
|
|
|
unsigned int debounce_time;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2009-03-03 22:25:04 +01:00
|
|
|
/**
|
|
|
|
* struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
|
|
|
|
*
|
2014-05-26 13:34:37 +02:00
|
|
|
* @gpio: legacy gpio number
|
2014-05-27 12:54:18 +02:00
|
|
|
* @idx: gpio descriptor index within the function of the GPIO
|
|
|
|
* consumer device
|
2015-08-25 09:14:48 +02:00
|
|
|
* @gpiod_dev: GPIO consumer device
|
2014-05-27 12:54:18 +02:00
|
|
|
* @name: gpio name. Also as connection ID for the GPIO consumer
|
|
|
|
* device function name lookup
|
2009-03-03 22:25:04 +01:00
|
|
|
* @report: value to report when jack detected
|
|
|
|
* @invert: report presence in low state
|
2015-08-25 09:14:48 +02:00
|
|
|
* @debounce_time: debounce time in ms
|
2011-02-18 01:35:55 +01:00
|
|
|
* @wake: enable as wake source
|
2011-02-18 01:41:42 +01:00
|
|
|
* @jack_status_check: callback function which overrides the detection
|
|
|
|
* to provide more complex checks (eg, reading an
|
|
|
|
* ADC).
|
2009-03-03 22:25:04 +01:00
|
|
|
*/
|
|
|
|
struct snd_soc_jack_gpio {
|
|
|
|
unsigned int gpio;
|
2014-05-26 13:34:37 +02:00
|
|
|
unsigned int idx;
|
|
|
|
struct device *gpiod_dev;
|
2009-03-03 22:25:04 +01:00
|
|
|
const char *name;
|
|
|
|
int report;
|
|
|
|
int invert;
|
|
|
|
int debounce_time;
|
2011-02-18 01:35:55 +01:00
|
|
|
bool wake;
|
|
|
|
|
2015-08-25 09:14:48 +02:00
|
|
|
/* private: */
|
2009-03-03 22:25:04 +01:00
|
|
|
struct snd_soc_jack *jack;
|
2010-10-07 00:54:28 +02:00
|
|
|
struct delayed_work work;
|
2014-05-26 13:34:36 +02:00
|
|
|
struct gpio_desc *desc;
|
2009-11-12 09:14:04 +01:00
|
|
|
|
2014-02-23 07:40:44 +01:00
|
|
|
void *data;
|
2015-08-25 09:14:48 +02:00
|
|
|
/* public: */
|
2014-02-23 07:40:44 +01:00
|
|
|
int (*jack_status_check)(void *data);
|
2009-03-03 22:25:04 +01:00
|
|
|
};
|
|
|
|
|
2009-01-07 18:31:10 +01:00
|
|
|
struct snd_soc_jack {
|
2012-03-12 15:07:49 +01:00
|
|
|
struct mutex mutex;
|
2009-01-07 18:31:10 +01:00
|
|
|
struct snd_jack *jack;
|
2015-03-04 10:33:17 +01:00
|
|
|
struct snd_soc_card *card;
|
2009-01-07 18:31:10 +01:00
|
|
|
struct list_head pins;
|
|
|
|
int status;
|
2010-03-22 13:06:30 +01:00
|
|
|
struct blocking_notifier_head notifier;
|
2011-02-09 10:14:17 +01:00
|
|
|
struct list_head jack_zones;
|
2009-01-07 18:31:10 +01:00
|
|
|
};
|
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
/* SoC PCM stream information */
|
|
|
|
struct snd_soc_pcm_stream {
|
2010-03-17 21:15:21 +01:00
|
|
|
const char *stream_name;
|
2007-02-02 17:13:05 +01:00
|
|
|
u64 formats; /* SNDRV_PCM_FMTBIT_* */
|
|
|
|
unsigned int rates; /* SNDRV_PCM_RATE_* */
|
2006-10-06 18:20:14 +02: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-16 19:38:51 +01:00
|
|
|
unsigned int sig_bits; /* number of bits of content */
|
2006-10-06 18:20:14 +02: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 13:40:40 +02: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 *);
|
|
|
|
};
|
|
|
|
|
2013-09-05 04:39:03 +02:00
|
|
|
/* component interface */
|
|
|
|
struct snd_soc_component_driver {
|
|
|
|
const char *name;
|
2013-09-11 02:39:56 +02:00
|
|
|
|
2014-08-19 15:51:21 +02:00
|
|
|
/* Default control and setup, added after probe() is run */
|
|
|
|
const struct snd_kcontrol_new *controls;
|
|
|
|
unsigned int num_controls;
|
|
|
|
const struct snd_soc_dapm_widget *dapm_widgets;
|
|
|
|
unsigned int num_dapm_widgets;
|
|
|
|
const struct snd_soc_dapm_route *dapm_routes;
|
|
|
|
unsigned int num_dapm_routes;
|
|
|
|
|
|
|
|
int (*probe)(struct snd_soc_component *);
|
|
|
|
void (*remove)(struct snd_soc_component *);
|
|
|
|
|
2013-09-11 02:39:56 +02:00
|
|
|
/* DT */
|
|
|
|
int (*of_xlate_dai_name)(struct snd_soc_component *component,
|
|
|
|
struct of_phandle_args *args,
|
|
|
|
const char **dai_name);
|
2014-06-16 18:13:08 +02:00
|
|
|
void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
|
|
|
|
int subseq);
|
|
|
|
int (*stream_event)(struct snd_soc_component *, int event);
|
2014-08-19 15:51:19 +02:00
|
|
|
|
|
|
|
/* probe ordering - for components with runtime dependencies */
|
|
|
|
int probe_order;
|
|
|
|
int remove_order;
|
2013-09-05 04:39:03 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct snd_soc_component {
|
|
|
|
const char *name;
|
|
|
|
int id;
|
2014-06-16 18:13:01 +02:00
|
|
|
const char *name_prefix;
|
2013-09-05 04:39:03 +02:00
|
|
|
struct device *dev;
|
2014-07-17 22:01:07 +02:00
|
|
|
struct snd_soc_card *card;
|
2014-03-05 13:17:47 +01:00
|
|
|
|
|
|
|
unsigned int active;
|
|
|
|
|
2014-03-05 13:17:48 +01:00
|
|
|
unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
|
2014-03-18 09:02:11 +01:00
|
|
|
unsigned int registered_as_component:1;
|
2014-03-05 13:17:48 +01:00
|
|
|
|
2013-09-05 04:39:03 +02:00
|
|
|
struct list_head list;
|
2016-01-06 06:29:31 +01:00
|
|
|
struct list_head list_aux; /* for auxiliary component of the card */
|
2013-09-05 04:39:03 +02:00
|
|
|
|
2013-10-17 07:05:26 +02:00
|
|
|
struct snd_soc_dai_driver *dai_drv;
|
|
|
|
int num_dai;
|
|
|
|
|
2013-09-05 04:39:03 +02:00
|
|
|
const struct snd_soc_component_driver *driver;
|
2014-03-09 17:41:47 +01:00
|
|
|
|
|
|
|
struct list_head dai_list;
|
2014-04-22 13:23:13 +02:00
|
|
|
|
|
|
|
int (*read)(struct snd_soc_component *, unsigned int, unsigned int *);
|
|
|
|
int (*write)(struct snd_soc_component *, unsigned int, unsigned int);
|
|
|
|
|
|
|
|
struct regmap *regmap;
|
|
|
|
int val_bytes;
|
|
|
|
|
|
|
|
struct mutex io_mutex;
|
2014-06-16 18:13:06 +02:00
|
|
|
|
2015-05-29 20:06:14 +02:00
|
|
|
/* attached dynamic objects */
|
|
|
|
struct list_head dobj_list;
|
|
|
|
|
2014-08-19 15:51:18 +02:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_root;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DO NOT use any of the fields below in drivers, they are temporary and
|
|
|
|
* are going to be removed again soon. If you use them in driver code the
|
|
|
|
* driver will be marked as BROKEN when these fields are removed.
|
|
|
|
*/
|
|
|
|
|
2014-06-16 18:13:06 +02:00
|
|
|
/* Don't use these, use snd_soc_component_get_dapm() */
|
|
|
|
struct snd_soc_dapm_context dapm;
|
2014-08-19 15:51:18 +02:00
|
|
|
|
2014-08-19 15:51:19 +02:00
|
|
|
const struct snd_kcontrol_new *controls;
|
|
|
|
unsigned int num_controls;
|
|
|
|
const struct snd_soc_dapm_widget *dapm_widgets;
|
|
|
|
unsigned int num_dapm_widgets;
|
|
|
|
const struct snd_soc_dapm_route *dapm_routes;
|
|
|
|
unsigned int num_dapm_routes;
|
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
|
|
|
|
int (*probe)(struct snd_soc_component *);
|
|
|
|
void (*remove)(struct snd_soc_component *);
|
|
|
|
|
2016-01-06 06:29:31 +01:00
|
|
|
/* machine specific init */
|
|
|
|
int (*init)(struct snd_soc_component *component);
|
|
|
|
|
2014-08-19 15:51:18 +02:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
void (*init_debugfs)(struct snd_soc_component *component);
|
|
|
|
const char *debugfs_prefix;
|
|
|
|
#endif
|
2013-09-05 04:39:03 +02:00
|
|
|
};
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
/* SoC Audio Codec device */
|
2006-10-06 18:20:14 +02:00
|
|
|
struct snd_soc_codec {
|
2008-12-10 15:32:45 +01:00
|
|
|
struct device *dev;
|
2010-12-02 17:21:08 +01:00
|
|
|
const struct snd_soc_codec_driver *driver;
|
2008-12-10 15:32:45 +01:00
|
|
|
|
|
|
|
struct list_head list;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct list_head card_list;
|
2006-10-06 18:20:14 +02:00
|
|
|
|
|
|
|
/* runtime */
|
2011-01-19 15:53:36 +01:00
|
|
|
unsigned int cache_bypass:1; /* Suppress access to the cache */
|
2010-03-17 21:15:21 +01:00
|
|
|
unsigned int suspended:1; /* Codec is in suspend PM state */
|
2010-12-02 17:11:06 +01:00
|
|
|
unsigned int cache_init:1; /* codec cache has been initialized */
|
2006-10-06 18:20:14 +02:00
|
|
|
|
|
|
|
/* codec IO */
|
|
|
|
void *control_data; /* codec control (i2c/3wire) data */
|
|
|
|
hw_write_t hw_write;
|
|
|
|
void *reg_cache;
|
2010-01-19 23:49:43 +01:00
|
|
|
|
2013-09-05 04:39:03 +02:00
|
|
|
/* component */
|
|
|
|
struct snd_soc_component component;
|
|
|
|
|
2008-12-03 18:34:03 +01:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_reg;
|
|
|
|
#endif
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
/* codec driver */
|
|
|
|
struct snd_soc_codec_driver {
|
|
|
|
|
|
|
|
/* driver ops */
|
|
|
|
int (*probe)(struct snd_soc_codec *);
|
|
|
|
int (*remove)(struct snd_soc_codec *);
|
2011-12-02 10:18:28 +01:00
|
|
|
int (*suspend)(struct snd_soc_codec *);
|
2010-03-17 21:15:21 +01:00
|
|
|
int (*resume)(struct snd_soc_codec *);
|
2013-09-05 04:39:03 +02:00
|
|
|
struct snd_soc_component_driver component_driver;
|
2010-03-17 21:15:21 +01:00
|
|
|
|
2011-03-07 21:58:11 +01:00
|
|
|
/* codec wide operations */
|
|
|
|
int (*set_sysclk)(struct snd_soc_codec *codec,
|
2011-08-24 21:09:01 +02:00
|
|
|
int clk_id, int source, unsigned int freq, int dir);
|
2011-03-07 21:58:11 +01:00
|
|
|
int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
|
|
|
|
unsigned int freq_in, unsigned int freq_out);
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
/* codec IO */
|
2014-03-26 06:40:23 +01:00
|
|
|
struct regmap *(*get_regmap)(struct device *);
|
2010-03-17 21:15:21 +01:00
|
|
|
unsigned int (*read)(struct snd_soc_codec *, unsigned int);
|
|
|
|
int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
|
2011-08-24 20:12:49 +02:00
|
|
|
unsigned int reg_cache_size;
|
2010-03-17 21:15:21 +01:00
|
|
|
short reg_cache_step;
|
|
|
|
short reg_word_size;
|
|
|
|
const void *reg_cache_default;
|
|
|
|
|
|
|
|
/* codec bias level */
|
|
|
|
int (*set_bias_level)(struct snd_soc_codec *,
|
|
|
|
enum snd_soc_bias_level level);
|
2011-08-22 19:40:30 +02:00
|
|
|
bool idle_bias_off;
|
2014-09-04 19:44:06 +02:00
|
|
|
bool suspend_bias_off;
|
2011-01-18 17:14:44 +01:00
|
|
|
|
|
|
|
void (*seq_notifier)(struct snd_soc_dapm_context *,
|
2011-01-26 22:41:28 +01:00
|
|
|
enum snd_soc_dapm_type, int);
|
2011-06-07 17:08:05 +02:00
|
|
|
|
2012-02-08 14:20:50 +01:00
|
|
|
bool ignore_pmdown_time; /* Doesn't benefit from pmdown delay */
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* SoC platform interface */
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_platform_driver {
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
int (*probe)(struct snd_soc_platform *);
|
|
|
|
int (*remove)(struct snd_soc_platform *);
|
2014-03-18 09:02:12 +01:00
|
|
|
struct snd_soc_component_driver component_driver;
|
2006-10-06 18:20:14 +02:00
|
|
|
|
|
|
|
/* pcm creation and destruction */
|
2011-06-07 17:08:33 +02:00
|
|
|
int (*pcm_new)(struct snd_soc_pcm_runtime *);
|
2006-10-06 18:20:14 +02:00
|
|
|
void (*pcm_free)(struct snd_pcm *);
|
|
|
|
|
2010-03-03 14:08:07 +01:00
|
|
|
/*
|
|
|
|
* For platform caused delay reporting.
|
|
|
|
* Optional.
|
|
|
|
*/
|
|
|
|
snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
|
|
|
|
struct snd_soc_dai *);
|
|
|
|
|
2012-08-16 13:40:40 +02:00
|
|
|
/* platform stream pcm ops */
|
2013-03-27 12:02:23 +01:00
|
|
|
const struct snd_pcm_ops *ops;
|
2011-06-07 17:08:05 +02:00
|
|
|
|
2012-08-16 13:40:40 +02:00
|
|
|
/* platform stream compress ops */
|
2013-03-27 12:02:24 +01:00
|
|
|
const struct snd_compr_ops *compr_ops;
|
2012-08-16 13:40:40 +02:00
|
|
|
|
2012-04-25 13:12:52 +02:00
|
|
|
int (*bespoke_trigger)(struct snd_pcm_substream *, int);
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
2014-07-08 23:19:34 +02:00
|
|
|
struct snd_soc_dai_link_component {
|
|
|
|
const char *name;
|
2014-11-25 12:14:48 +01:00
|
|
|
struct device_node *of_node;
|
2014-07-08 23:19:34 +02:00
|
|
|
const char *dai_name;
|
|
|
|
};
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_platform {
|
|
|
|
struct device *dev;
|
2013-03-27 12:02:22 +01:00
|
|
|
const struct snd_soc_platform_driver *driver;
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
struct list_head list;
|
2011-07-04 23:10:52 +02:00
|
|
|
|
2014-03-18 09:02:12 +01:00
|
|
|
struct snd_soc_component component;
|
2010-03-17 21:15:21 +01:00
|
|
|
};
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2010-03-17 21:15:21 +01: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: 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 02:22:11 +02: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.
|
|
|
|
*/
|
|
|
|
const char *cpu_name;
|
2014-06-16 16:33:46 +02:00
|
|
|
struct device_node *cpu_of_node;
|
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 02:22:11 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2010-03-17 21:15:21 +01:00
|
|
|
const char *cpu_dai_name;
|
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 02:22:11 +02:00
|
|
|
/*
|
|
|
|
* You MUST specify the link's codec, either by device name, or by
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
*/
|
|
|
|
const char *codec_name;
|
2014-06-16 16:33:46 +02:00
|
|
|
struct device_node *codec_of_node;
|
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 02:22:11 +02:00
|
|
|
/* You MUST specify the DAI name within the codec */
|
2010-03-17 21:15:21 +01:00
|
|
|
const char *codec_dai_name;
|
2014-07-08 23:19:34 +02: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 02:22:11 +02: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
|
|
|
|
* do not need a platform.
|
|
|
|
*/
|
|
|
|
const char *platform_name;
|
2014-06-16 16:33:46 +02:00
|
|
|
struct device_node *platform_of_node;
|
2016-04-19 07:12:35 +02:00
|
|
|
int id; /* optional ID for machine driver link identification */
|
2008-01-10 14:39:01 +01:00
|
|
|
|
2012-04-04 23:12:09 +02:00
|
|
|
const struct snd_soc_pcm_stream *params;
|
2015-02-02 18:06:44 +01:00
|
|
|
unsigned int num_params;
|
2012-04-04 23:12:09 +02:00
|
|
|
|
2011-09-27 17:41:01 +02: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 13:12:49 +02:00
|
|
|
enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
|
|
|
|
|
2015-04-21 09:02:34 +02:00
|
|
|
/* codec/machine specific init - e.g. add machine controls */
|
|
|
|
int (*init)(struct snd_soc_pcm_runtime *rtd);
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
/* For unidirectional dai links */
|
|
|
|
bool playback_only;
|
|
|
|
bool capture_only;
|
|
|
|
|
|
|
|
/* Mark this pcm with non atomic ops */
|
|
|
|
bool nonatomic;
|
|
|
|
|
2010-05-09 14:25:43 +02:00
|
|
|
/* Keep DAI active over suspend */
|
|
|
|
unsigned int ignore_suspend:1;
|
|
|
|
|
2009-04-07 19:10:13 +02:00
|
|
|
/* Symmetry requirements */
|
|
|
|
unsigned int symmetric_rates:1;
|
2013-11-13 11:56:24 +01:00
|
|
|
unsigned int symmetric_channels:1;
|
|
|
|
unsigned int symmetric_samplebits:1;
|
2009-04-07 19:10:13 +02: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 13:12:49 +02: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-07 18:51:42 +01:00
|
|
|
/* DPCM capture and Playback support */
|
|
|
|
unsigned int dpcm_capture:1;
|
|
|
|
unsigned int dpcm_playback:1;
|
|
|
|
|
2015-05-12 04:03:33 +02:00
|
|
|
/* DPCM used FE & BE merged format */
|
|
|
|
unsigned int dpcm_merged_format:1;
|
|
|
|
|
2011-10-27 08:42:33 +02:00
|
|
|
/* pmdown_time is ignored at stop */
|
|
|
|
unsigned int ignore_pmdown_time:1;
|
2015-12-02 07:11:22 +01:00
|
|
|
|
|
|
|
struct list_head list; /* DAI link list of the soc card */
|
|
|
|
struct snd_soc_dobj dobj; /* For topology */
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
2010-12-02 15:53:03 +01:00
|
|
|
struct snd_soc_codec_conf {
|
2014-04-28 16:07:22 +02:00
|
|
|
/*
|
|
|
|
* specify device either by device name, or by
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
*/
|
ASoC: Add optional name_prefix for codec kcontrol, widget and route names
There is a need to prefix codec kcontrol, widget and internal route names in
an ASoC machine that has multiple codecs with conflicting names. The name
collision would occur when codec drivers try to registering kcontrols with
the same name or when building audio paths.
This patch introduces optional prefix_map into struct snd_soc_card. With it
machine drivers can specify a unique name prefix to each codec that have
conflicting names with anothers. Prefix to codec is matched with codec
name.
Following example illustrates a machine that has two same codec instances.
Name collision from kcontrol registration is avoided by specifying a name
prefix "foo" for the second codec. As the codec widget names are prefixed
then second audio map for that codec shows a prefixed widget name.
static const struct snd_soc_dapm_route map0[] = {
{"Spk", NULL, "MONO"},
};
static const struct snd_soc_dapm_route map1[] = {
{"Vibra", NULL, "foo MONO"},
};
static struct snd_soc_prefix_map codec_prefix[] = {
{
.dev_name = "codec.2",
.name_prefix = "foo",
},
};
static struct snd_soc_card card = {
...
.prefix_map = codec_prefix,
.num_prefixes = ARRAY_SIZE(codec_prefix),
};
Signed-off-by: Jarkko Nikula <jhnikula@gmail.com>
Acked-by: Liam Girdwood <lrg@slimlogic.co.uk>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2010-11-13 19:40:44 +01:00
|
|
|
const char *dev_name;
|
2014-11-25 12:14:48 +01:00
|
|
|
struct device_node *of_node;
|
2010-12-02 15:53:03 +01: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-13 19:40:44 +01:00
|
|
|
const char *name_prefix;
|
|
|
|
};
|
|
|
|
|
2010-11-25 16:47:38 +01:00
|
|
|
struct snd_soc_aux_dev {
|
|
|
|
const char *name; /* Codec name */
|
2014-04-28 16:07:22 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* specify multi-codec either by device name, or by
|
|
|
|
* DT/OF node, but not both.
|
|
|
|
*/
|
|
|
|
const char *codec_name;
|
2014-11-25 12:14:48 +01:00
|
|
|
struct device_node *codec_of_node;
|
2010-11-25 16:47:38 +01:00
|
|
|
|
|
|
|
/* codec/machine specific init - e.g. add machine controls */
|
2014-08-19 15:51:23 +02:00
|
|
|
int (*init)(struct snd_soc_component *component);
|
2010-11-25 16:47:38 +01:00
|
|
|
};
|
|
|
|
|
2008-11-18 21:50:34 +01:00
|
|
|
/* SoC card */
|
|
|
|
struct snd_soc_card {
|
2010-03-17 21:15:21 +01:00
|
|
|
const char *name;
|
2011-05-12 17:14:04 +02:00
|
|
|
const char *long_name;
|
|
|
|
const char *driver_name;
|
2008-11-28 14:29:45 +01:00
|
|
|
struct device *dev;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_card *snd_card;
|
|
|
|
struct module *owner;
|
2008-11-28 14:29:45 +01:00
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
struct mutex mutex;
|
2012-03-07 11:38:26 +01:00
|
|
|
struct mutex dapm_mutex;
|
2008-11-28 14:29:45 +01:00
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
bool instantiated;
|
2006-10-06 18:20:14 +02:00
|
|
|
|
2011-01-26 15:17:20 +01:00
|
|
|
int (*probe)(struct snd_soc_card *card);
|
2011-03-02 19:36:34 +01:00
|
|
|
int (*late_probe)(struct snd_soc_card *card);
|
2011-01-26 15:17:20 +01:00
|
|
|
int (*remove)(struct snd_soc_card *card);
|
2006-10-06 18:20:14 +02: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 15:05:25 +01: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-06 18:20:14 +02:00
|
|
|
|
2008-01-10 14:36:20 +01:00
|
|
|
/* callbacks */
|
2008-11-18 21:50:34 +01:00
|
|
|
int (*set_bias_level)(struct snd_soc_card *,
|
2011-06-06 20:13:23 +02:00
|
|
|
struct snd_soc_dapm_context *dapm,
|
2008-05-19 12:31:28 +02:00
|
|
|
enum snd_soc_bias_level level);
|
2010-12-04 13:41:04 +01:00
|
|
|
int (*set_bias_level_post)(struct snd_soc_card *,
|
2011-06-06 20:13:23 +02:00
|
|
|
struct snd_soc_dapm_context *dapm,
|
2010-12-04 13:41:04 +01:00
|
|
|
enum snd_soc_bias_level level);
|
2008-01-10 14:36:20 +01:00
|
|
|
|
2015-12-02 07:11:32 +01: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 15:30:44 +01:00
|
|
|
long pmdown_time;
|
2010-02-12 12:05:44 +01:00
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
/* CPU <--> Codec DAI links */
|
2015-12-02 07:11:22 +01:00
|
|
|
struct snd_soc_dai_link *dai_link; /* predefined links only */
|
|
|
|
int num_links; /* predefined links only */
|
|
|
|
struct list_head dai_link_list; /* all links */
|
|
|
|
int num_dai_links;
|
|
|
|
|
2015-11-18 08:34:11 +01:00
|
|
|
struct list_head rtd_list;
|
2010-03-17 21:15:21 +01:00
|
|
|
int num_rtd;
|
2008-12-02 16:08:03 +01:00
|
|
|
|
2010-12-02 15:53:03 +01: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-13 19:40:44 +01:00
|
|
|
|
2010-11-25 16:47:38 +01: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-01-06 06:29:31 +01:00
|
|
|
struct list_head aux_comp_list;
|
2010-11-25 16:47:38 +01:00
|
|
|
|
2011-04-07 12:18:44 +02:00
|
|
|
const struct snd_kcontrol_new *controls;
|
|
|
|
int num_controls;
|
|
|
|
|
2011-03-02 19:35:51 +01:00
|
|
|
/*
|
|
|
|
* Card-specific routes and widgets.
|
2015-02-15 02:22:49 +01:00
|
|
|
* Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
|
2011-03-02 19:35:51 +01:00
|
|
|
*/
|
2011-04-12 19:31:01 +02:00
|
|
|
const struct snd_soc_dapm_widget *dapm_widgets;
|
2011-03-02 19:35:51 +01:00
|
|
|
int num_dapm_widgets;
|
2011-04-12 19:31:01 +02:00
|
|
|
const struct snd_soc_dapm_route *dapm_routes;
|
2011-03-02 19:35:51 +01:00
|
|
|
int num_dapm_routes;
|
2015-02-15 02:22:49 +01: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-11-23 20:42:04 +01:00
|
|
|
bool fully_routed;
|
2011-03-02 19:35:51 +01:00
|
|
|
|
2008-12-02 16:08:03 +01:00
|
|
|
struct work_struct deferred_resume_work;
|
2010-03-17 21:15:21 +01:00
|
|
|
|
|
|
|
/* lists of probed devices belonging to this card */
|
|
|
|
struct list_head codec_dev_list;
|
2010-11-05 19:35:19 +01:00
|
|
|
|
2010-12-14 11:18:31 +01:00
|
|
|
struct list_head widgets;
|
2010-12-14 11:18:30 +01:00
|
|
|
struct list_head paths;
|
2010-12-14 11:18:32 +01:00
|
|
|
struct list_head dapm_list;
|
2011-10-03 22:06:40 +02:00
|
|
|
struct list_head dapm_dirty;
|
2010-12-14 11:18:30 +01:00
|
|
|
|
2015-05-29 20:06:14 +02:00
|
|
|
/* attached dynamic objects */
|
|
|
|
struct list_head dobj_list;
|
|
|
|
|
2011-03-02 19:21:57 +01:00
|
|
|
/* Generic DAPM context for the card */
|
|
|
|
struct snd_soc_dapm_context dapm;
|
2011-09-20 22:43:24 +02:00
|
|
|
struct snd_soc_dapm_stats dapm_stats;
|
2013-07-29 17:13:55 +02:00
|
|
|
struct snd_soc_dapm_update *update;
|
2011-03-02 19:21:57 +01:00
|
|
|
|
2010-11-05 19:35:19 +01:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_card_root;
|
2010-11-05 19:35:21 +01:00
|
|
|
struct dentry *debugfs_pop_time;
|
2010-11-05 19:35:19 +01:00
|
|
|
#endif
|
2010-11-05 19:35:21 +01:00
|
|
|
u32 pop_time;
|
2011-01-28 14:11:47 +01:00
|
|
|
|
|
|
|
void *drvdata;
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
|
2011-11-10 12:46:13 +01:00
|
|
|
struct snd_soc_pcm_runtime {
|
2012-01-07 02:12:45 +01:00
|
|
|
struct device *dev;
|
2008-11-18 21:50:34 +01:00
|
|
|
struct snd_soc_card *card;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_dai_link *dai_link;
|
2011-06-09 18:04:39 +02:00
|
|
|
struct mutex pcm_mutex;
|
|
|
|
enum snd_soc_pcm_subclass pcm_subclass;
|
|
|
|
struct snd_pcm_ops ops;
|
2010-03-17 21:15:21 +01:00
|
|
|
|
|
|
|
unsigned int dev_registered:1;
|
2006-10-06 18:20:14 +02: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 13:12:49 +02:00
|
|
|
/* Dynamic PCM BE runtime data */
|
|
|
|
struct snd_soc_dpcm_runtime dpcm[2];
|
2014-01-17 18:03:56 +01:00
|
|
|
int fe_compr;
|
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 13:12:49 +02:00
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
long pmdown_time;
|
ASoC: Prevent pop_wait overwrite
pop_wait is used to determine if a deferred playback close
needs to be cancelled when the a PCM is open or if after
the power-down delay expires it needs to run. pop_wait is
associated with the CODEC DAI, so the CODEC DAI must be
unique. This holds true for most CODECs, except for the
dummy CODEC and its DAI.
In DAI links with non-unique dummy CODECs (e.g. front-ends),
pop_wait can be overwritten by another DAI link using also a
dummy CODEC. Failure to cancel a deferred close can cause
mute due to the DAPM STOP event sent in the deferred work.
One scenario where pop_wait is overwritten and causing mute
is below (where hw:0,0 and hw:0,1 are two front-ends with
default pmdown_time = 5 secs):
aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE -d 1
sleep 1
aplay /dev/urandom -D hw:0,1 -c 2 -r 48000 -f S16_LE -d 3 &
aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE
Since CODECs may not be unique, pop_wait is moved to the PCM
runtime structure. Creating separate dummy CODECs for each
DAI link can also solve the problem, but at this point it's
only pop_wait variable in the CODEC DAI that has negative
effects by not being unique.
Signed-off-by: Misael Lopez Cruz <misael.lopez@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-12-13 19:23:05 +01:00
|
|
|
unsigned char pop_wait:1;
|
2010-03-17 21:15:21 +01:00
|
|
|
|
|
|
|
/* runtime devices */
|
|
|
|
struct snd_pcm *pcm;
|
2012-08-16 13:40:40 +02:00
|
|
|
struct snd_compr *compr;
|
2010-03-17 21:15:21 +01:00
|
|
|
struct snd_soc_codec *codec;
|
|
|
|
struct snd_soc_platform *platform;
|
|
|
|
struct snd_soc_dai *codec_dai;
|
|
|
|
struct snd_soc_dai *cpu_dai;
|
2014-08-19 15:51:22 +02:00
|
|
|
struct snd_soc_component *component; /* Only valid for AUX dev rtds */
|
2010-03-17 21:15:21 +01:00
|
|
|
|
2014-07-08 23:19:34 +02:00
|
|
|
struct snd_soc_dai **codec_dais;
|
|
|
|
unsigned int num_codecs;
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
struct delayed_work delayed_work;
|
2012-04-25 13:12:50 +02:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_dpcm_root;
|
|
|
|
struct dentry *debugfs_dpcm_state;
|
|
|
|
#endif
|
2015-11-18 08:34:11 +01:00
|
|
|
|
|
|
|
unsigned int num; /* 0-based and monotonic increasing */
|
|
|
|
struct list_head list; /* rtd list of the soc card */
|
2006-10-06 18:20:14 +02:00
|
|
|
};
|
|
|
|
|
2008-07-29 12:42:26 +02:00
|
|
|
/* mixer control */
|
|
|
|
struct soc_mixer_control {
|
2010-05-10 13:39:24 +02:00
|
|
|
int min, max, platform_max;
|
2013-10-06 13:43:49 +02:00
|
|
|
int reg, rreg;
|
|
|
|
unsigned int shift, rshift;
|
2014-01-16 16:02:10 +01:00
|
|
|
unsigned int sign_bit;
|
2013-08-05 11:27:31 +02:00
|
|
|
unsigned int invert:1;
|
|
|
|
unsigned int autodisable:1;
|
2015-05-29 20:06:14 +02:00
|
|
|
struct snd_soc_dobj dobj;
|
2008-07-29 12:42:26 +02:00
|
|
|
};
|
|
|
|
|
2011-10-10 19:31:26 +02:00
|
|
|
struct soc_bytes {
|
|
|
|
int base;
|
|
|
|
int num_regs;
|
2012-02-18 01:20:33 +01:00
|
|
|
u32 mask;
|
2011-10-10 19:31:26 +02:00
|
|
|
};
|
|
|
|
|
2014-05-02 07:28:11 +02:00
|
|
|
struct soc_bytes_ext {
|
|
|
|
int max;
|
2015-05-29 20:06:14 +02:00
|
|
|
struct snd_soc_dobj dobj;
|
|
|
|
|
2014-07-15 18:04:48 +02:00
|
|
|
/* used for TLV byte control */
|
2015-11-09 18:50:00 +01: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 07:28:11 +02:00
|
|
|
};
|
|
|
|
|
2012-04-20 11:32:13 +02:00
|
|
|
/* multi register control */
|
|
|
|
struct soc_mreg_control {
|
|
|
|
long min, max;
|
|
|
|
unsigned int regbase, regcount, nbits, invert;
|
|
|
|
};
|
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
/* enumerated kcontrol */
|
|
|
|
struct soc_enum {
|
2014-02-28 08:31:05 +01:00
|
|
|
int reg;
|
2009-01-05 08:54:57 +01:00
|
|
|
unsigned char shift_l;
|
|
|
|
unsigned char shift_r;
|
2014-02-18 08:11:42 +01:00
|
|
|
unsigned int items;
|
2009-01-05 08:54:57 +01:00
|
|
|
unsigned int mask;
|
2011-05-03 12:50:29 +02:00
|
|
|
const char * const *texts;
|
2009-01-05 08:54:57 +01:00
|
|
|
const unsigned int *values;
|
2015-05-01 13:37:26 +02:00
|
|
|
unsigned int autodisable:1;
|
2015-05-29 20:06:14 +02:00
|
|
|
struct snd_soc_dobj dobj;
|
2009-01-05 08:54:57 +01:00
|
|
|
};
|
|
|
|
|
2014-03-18 09:02:10 +01:00
|
|
|
/**
|
|
|
|
* snd_soc_component_to_codec() - Casts a component to the CODEC it is embedded in
|
|
|
|
* @component: The component to cast to a CODEC
|
|
|
|
*
|
|
|
|
* This function must only be used on components that are known to be CODECs.
|
|
|
|
* Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_codec *snd_soc_component_to_codec(
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
return container_of(component, struct snd_soc_codec, component);
|
|
|
|
}
|
|
|
|
|
2014-03-18 09:02:12 +01:00
|
|
|
/**
|
|
|
|
* snd_soc_component_to_platform() - Casts a component to the platform it is embedded in
|
|
|
|
* @component: The component to cast to a platform
|
|
|
|
*
|
|
|
|
* This function must only be used on components that are known to be platforms.
|
|
|
|
* Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_platform *snd_soc_component_to_platform(
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
return container_of(component, struct snd_soc_platform, component);
|
|
|
|
}
|
|
|
|
|
2014-06-16 18:13:06 +02:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_to_component() - Casts a DAPM context to the component it is
|
|
|
|
* embedded in
|
|
|
|
* @dapm: The DAPM context to cast to the component
|
|
|
|
*
|
|
|
|
* This function must only be used on DAPM contexts that are known to be part of
|
|
|
|
* a component (e.g. in a component driver). Otherwise the behavior is
|
|
|
|
* undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_component *snd_soc_dapm_to_component(
|
|
|
|
struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
return container_of(dapm, struct snd_soc_component, dapm);
|
|
|
|
}
|
|
|
|
|
2014-05-18 14:24:12 +02:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_to_codec() - Casts a DAPM context to the CODEC it is embedded in
|
|
|
|
* @dapm: The DAPM context to cast to the CODEC
|
|
|
|
*
|
|
|
|
* This function must only be used on DAPM contexts that are known to be part of
|
|
|
|
* a CODEC (e.g. in a CODEC driver). Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_codec *snd_soc_dapm_to_codec(
|
|
|
|
struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
2015-07-06 15:38:11 +02:00
|
|
|
return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));
|
2014-05-18 14:24:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_to_platform() - Casts a DAPM context to the platform it is
|
|
|
|
* embedded in
|
|
|
|
* @dapm: The DAPM context to cast to the platform.
|
|
|
|
*
|
|
|
|
* This function must only be used on DAPM contexts that are known to be part of
|
|
|
|
* a platform (e.g. in a platform driver). Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_platform *snd_soc_dapm_to_platform(
|
|
|
|
struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
2014-06-16 18:13:07 +02:00
|
|
|
return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
|
2014-05-18 14:24:12 +02:00
|
|
|
}
|
|
|
|
|
2014-06-16 18:13:06 +02:00
|
|
|
/**
|
|
|
|
* snd_soc_component_get_dapm() - Returns the DAPM context associated with a
|
|
|
|
* component
|
|
|
|
* @component: The component for which to get the DAPM context
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_dapm_context *snd_soc_component_get_dapm(
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
2015-07-06 15:38:11 +02:00
|
|
|
return &component->dapm;
|
2014-06-16 18:13:06 +02:00
|
|
|
}
|
|
|
|
|
2015-04-27 22:13:22 +02:00
|
|
|
/**
|
|
|
|
* snd_soc_codec_get_dapm() - Returns the DAPM context for the CODEC
|
|
|
|
* @codec: The CODEC for which to get the DAPM context
|
|
|
|
*
|
|
|
|
* Note: Use this function instead of directly accessing the CODEC's dapm field
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_dapm_context *snd_soc_codec_get_dapm(
|
|
|
|
struct snd_soc_codec *codec)
|
|
|
|
{
|
2015-07-06 15:38:11 +02:00
|
|
|
return snd_soc_component_get_dapm(&codec->component);
|
2015-04-27 22:13:22 +02:00
|
|
|
}
|
|
|
|
|
2015-04-27 22:13:23 +02:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
|
2015-08-25 09:14:48 +02:00
|
|
|
* @codec: The CODEC for which to initialize the DAPM bias level
|
2015-04-27 22:13:23 +02:00
|
|
|
* @level: The DAPM level to initialize to
|
|
|
|
*
|
|
|
|
* Initializes the CODEC DAPM bias level. See snd_soc_dapm_init_bias_level().
|
|
|
|
*/
|
|
|
|
static inline void snd_soc_codec_init_bias_level(struct snd_soc_codec *codec,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
snd_soc_dapm_init_bias_level(snd_soc_codec_get_dapm(codec), level);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_dapm_get_bias_level() - Get current CODEC DAPM bias level
|
|
|
|
* @codec: The CODEC for which to get the DAPM bias level
|
|
|
|
*
|
|
|
|
* Returns: The current DAPM bias level of the CODEC.
|
|
|
|
*/
|
|
|
|
static inline enum snd_soc_bias_level snd_soc_codec_get_bias_level(
|
|
|
|
struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_get_bias_level(snd_soc_codec_get_dapm(codec));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_codec_force_bias_level() - Set the CODEC DAPM bias level
|
|
|
|
* @codec: The CODEC for which to set the level
|
|
|
|
* @level: The level to set to
|
|
|
|
*
|
|
|
|
* Forces the CODEC bias level to a specific state. See
|
|
|
|
* snd_soc_dapm_force_bias_level().
|
|
|
|
*/
|
|
|
|
static inline int snd_soc_codec_force_bias_level(struct snd_soc_codec *codec,
|
|
|
|
enum snd_soc_bias_level level)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_force_bias_level(snd_soc_codec_get_dapm(codec),
|
|
|
|
level);
|
|
|
|
}
|
|
|
|
|
2015-03-15 10:27:20 +01:00
|
|
|
/**
|
|
|
|
* snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol
|
|
|
|
* @kcontrol: The kcontrol
|
|
|
|
*
|
|
|
|
* This function must only be used on DAPM contexts that are known to be part of
|
|
|
|
* a CODEC (e.g. in a CODEC driver). Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_codec *snd_soc_dapm_kcontrol_codec(
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
return snd_soc_dapm_to_codec(snd_soc_dapm_kcontrol_dapm(kcontrol));
|
|
|
|
}
|
|
|
|
|
2009-05-22 10:41:30 +02:00
|
|
|
/* codec IO */
|
2010-11-01 20:41:57 +01:00
|
|
|
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
|
2014-04-19 10:43:57 +02:00
|
|
|
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
|
|
|
|
unsigned int val);
|
2009-05-22 10:41:30 +02:00
|
|
|
|
2014-11-08 16:38:07 +01:00
|
|
|
/**
|
|
|
|
* snd_soc_cache_sync() - Sync the register cache with the hardware
|
|
|
|
* @codec: CODEC to sync
|
|
|
|
*
|
|
|
|
* Note: This function will call regcache_sync()
|
|
|
|
*/
|
|
|
|
static inline int snd_soc_cache_sync(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
return regcache_sync(codec->component.regmap);
|
|
|
|
}
|
|
|
|
|
2014-04-22 13:23:13 +02:00
|
|
|
/* component IO */
|
|
|
|
int snd_soc_component_read(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int *val);
|
|
|
|
int snd_soc_component_write(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int val);
|
|
|
|
int snd_soc_component_update_bits(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int mask, unsigned int val);
|
|
|
|
int snd_soc_component_update_bits_async(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int mask, unsigned int val);
|
|
|
|
void snd_soc_component_async_complete(struct snd_soc_component *component);
|
|
|
|
int snd_soc_component_test_bits(struct snd_soc_component *component,
|
|
|
|
unsigned int reg, unsigned int mask, unsigned int value);
|
|
|
|
|
2014-11-25 21:41:03 +01:00
|
|
|
#ifdef CONFIG_REGMAP
|
|
|
|
|
2014-11-18 19:45:52 +01:00
|
|
|
void snd_soc_component_init_regmap(struct snd_soc_component *component,
|
|
|
|
struct regmap *regmap);
|
|
|
|
void snd_soc_component_exit_regmap(struct snd_soc_component *component);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_codec_init_regmap() - Initialize regmap instance for the CODEC
|
|
|
|
* @codec: The CODEC for which to initialize the regmap instance
|
|
|
|
* @regmap: The regmap instance that should be used by the CODEC
|
|
|
|
*
|
|
|
|
* This function allows deferred assignment of the regmap instance that is
|
|
|
|
* associated with the CODEC. Only use this if the regmap instance is not yet
|
|
|
|
* ready when the CODEC is registered. The function must also be called before
|
|
|
|
* the first IO attempt of the CODEC.
|
|
|
|
*/
|
|
|
|
static inline void snd_soc_codec_init_regmap(struct snd_soc_codec *codec,
|
|
|
|
struct regmap *regmap)
|
|
|
|
{
|
|
|
|
snd_soc_component_init_regmap(&codec->component, regmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_soc_codec_exit_regmap() - De-initialize regmap instance for the CODEC
|
|
|
|
* @codec: The CODEC for which to de-initialize the regmap instance
|
|
|
|
*
|
|
|
|
* Calls regmap_exit() on the regmap instance associated to the CODEC and
|
|
|
|
* removes the regmap instance from the CODEC.
|
|
|
|
*
|
|
|
|
* This function should only be used if snd_soc_codec_init_regmap() was used to
|
|
|
|
* initialize the regmap instance.
|
|
|
|
*/
|
|
|
|
static inline void snd_soc_codec_exit_regmap(struct snd_soc_codec *codec)
|
|
|
|
{
|
|
|
|
snd_soc_component_exit_regmap(&codec->component);
|
|
|
|
}
|
|
|
|
|
2014-11-25 21:41:03 +01:00
|
|
|
#endif
|
|
|
|
|
2010-03-17 21:15:21 +01:00
|
|
|
/* device driver data */
|
|
|
|
|
2011-01-28 14:11:47 +01:00
|
|
|
static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
card->drvdata = data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
return card->drvdata;
|
|
|
|
}
|
|
|
|
|
2014-08-20 13:08:46 +02:00
|
|
|
static inline void snd_soc_component_set_drvdata(struct snd_soc_component *c,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
dev_set_drvdata(c->dev, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *snd_soc_component_get_drvdata(struct snd_soc_component *c)
|
|
|
|
{
|
|
|
|
return dev_get_drvdata(c->dev);
|
|
|
|
}
|
|
|
|
|
2010-04-14 08:35:19 +02:00
|
|
|
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
|
2010-03-17 21:15:21 +01:00
|
|
|
void *data)
|
2010-04-14 08:35:19 +02:00
|
|
|
{
|
2014-08-20 13:08:46 +02:00
|
|
|
snd_soc_component_set_drvdata(&codec->component, data);
|
2010-04-14 08:35:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
|
|
|
|
{
|
2014-08-20 13:08:46 +02:00
|
|
|
return snd_soc_component_get_drvdata(&codec->component);
|
2010-03-17 21:15:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
|
|
|
|
void *data)
|
|
|
|
{
|
2014-08-20 13:08:46 +02:00
|
|
|
snd_soc_component_set_drvdata(&platform->component, data);
|
2010-03-17 21:15:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
|
|
|
|
{
|
2014-08-20 13:08:46 +02:00
|
|
|
return snd_soc_component_get_drvdata(&platform->component);
|
2010-03-17 21:15:21 +01:00
|
|
|
}
|
|
|
|
|
2011-01-13 18:18:52 +01:00
|
|
|
static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
|
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&card->codec_dev_list);
|
|
|
|
INIT_LIST_HEAD(&card->widgets);
|
|
|
|
INIT_LIST_HEAD(&card->paths);
|
|
|
|
INIT_LIST_HEAD(&card->dapm_list);
|
2016-01-06 06:29:31 +01:00
|
|
|
INIT_LIST_HEAD(&card->aux_comp_list);
|
2011-01-13 18:18:52 +01:00
|
|
|
}
|
|
|
|
|
2011-10-05 09:29:22 +02:00
|
|
|
static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
|
|
|
|
{
|
|
|
|
if (mc->reg == mc->rreg && mc->shift == mc->rshift)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-02-28 08:31:03 +01: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-03-05 13:17:47 +01:00
|
|
|
static inline bool snd_soc_component_is_active(
|
|
|
|
struct snd_soc_component *component)
|
|
|
|
{
|
|
|
|
return component->active != 0;
|
|
|
|
}
|
|
|
|
|
2014-03-05 13:17:45 +01:00
|
|
|
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
|
|
|
|
{
|
2014-03-05 13:17:47 +01:00
|
|
|
return snd_soc_component_is_active(&codec->component);
|
2014-03-05 13:17:45 +01:00
|
|
|
}
|
|
|
|
|
2014-04-22 13:23:14 +02: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
|
|
|
|
* for a component. Either with snd_soc_add_codec_controls() or
|
|
|
|
* snd_soc_add_platform_controls() or via table based setup for either a
|
|
|
|
* CODEC, a platform or component driver. Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_component *snd_soc_kcontrol_component(
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
|
|
|
return snd_kcontrol_chip(kcontrol);
|
|
|
|
}
|
|
|
|
|
2014-03-18 09:02:04 +01:00
|
|
|
/**
|
|
|
|
* snd_soc_kcontrol_codec() - Returns the CODEC that registered the control
|
|
|
|
* @kcontrol: The control for which to get the CODEC
|
|
|
|
*
|
|
|
|
* Note: This function will only work correctly if the control has been
|
|
|
|
* registered with snd_soc_add_codec_controls() or via table based setup of
|
|
|
|
* snd_soc_codec_driver. Otherwise the behavior is undefined.
|
|
|
|
*/
|
|
|
|
static inline struct snd_soc_codec *snd_soc_kcontrol_codec(
|
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
2014-04-22 13:23:14 +02:00
|
|
|
return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
|
2014-03-18 09:02:04 +01:00
|
|
|
}
|
|
|
|
|
2014-03-18 09:02:05 +01:00
|
|
|
/**
|
2015-03-04 02:56:13 +01:00
|
|
|
* snd_soc_kcontrol_platform() - Returns the platform that registered the control
|
2014-03-18 09:02:05 +01:00
|
|
|
* @kcontrol: The control for which to get the platform
|
|
|
|
*
|
|
|
|
* Note: This function will only work correctly if the control has been
|
|
|
|
* registered with snd_soc_add_platform_controls() or via table based setup of
|
|
|
|
* a snd_soc_platform_driver. Otherwise the behavior is undefined.
|
|
|
|
*/
|
2014-04-15 22:24:21 +02:00
|
|
|
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
|
2014-03-18 09:02:05 +01:00
|
|
|
struct snd_kcontrol *kcontrol)
|
|
|
|
{
|
2014-04-22 13:23:14 +02:00
|
|
|
return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
|
2014-03-18 09:02:05 +01:00
|
|
|
}
|
|
|
|
|
2011-04-28 11:57:54 +02:00
|
|
|
int snd_soc_util_init(void);
|
|
|
|
void snd_soc_util_exit(void);
|
|
|
|
|
2011-12-12 23:55:34 +01:00
|
|
|
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
|
|
|
|
const char *propname);
|
ASoC: add snd_soc_of_parse_audio_simple_widgets for DT
This patch adds snd_soc_of_parse_audio_simple_widgets() and supports
below style of widgets name on DT:
"template-wname", "user supplied wname"
For instance:
simple-audio-widgets =
"Microphone", "Microphone Jack",
"Line", "Line In Jack",
"Line", "Line Out Jack",
"Headphone", "Headphone Jack",
"Speaker", "Speaker External";
The "template-wname" currently includes: "Microphone", "Line", "Headphone"
and "Speaker".
Signed-off-by: Xiubo Li <Li.Xiubo@freescale.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-08 08:59:52 +01:00
|
|
|
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
|
|
|
|
const char *propname);
|
2014-02-14 02:34:35 +01:00
|
|
|
int snd_soc_of_parse_tdm_slot(struct device_node *np,
|
2015-09-09 20:27:43 +02:00
|
|
|
unsigned int *tx_mask,
|
|
|
|
unsigned int *rx_mask,
|
2014-02-14 02:34:35 +01:00
|
|
|
unsigned int *slots,
|
|
|
|
unsigned int *slot_width);
|
2015-07-15 09:07:42 +02:00
|
|
|
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);
|
2011-12-12 23:55:35 +01:00
|
|
|
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
|
|
|
|
const char *propname);
|
2013-01-15 03:36:04 +01:00
|
|
|
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
|
2014-03-24 11:15:24 +01:00
|
|
|
const char *prefix,
|
|
|
|
struct device_node **bitclkmaster,
|
|
|
|
struct device_node **framemaster);
|
2013-09-11 02:39:56 +02:00
|
|
|
int snd_soc_of_get_dai_name(struct device_node *of_node,
|
|
|
|
const char **dai_name);
|
2014-11-25 13:16:12 +01:00
|
|
|
int snd_soc_of_get_dai_link_codecs(struct device *dev,
|
|
|
|
struct device_node *of_node,
|
|
|
|
struct snd_soc_dai_link *dai_link);
|
2011-12-12 23:55:34 +01:00
|
|
|
|
2015-12-02 07:11:22 +01:00
|
|
|
int snd_soc_add_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link);
|
|
|
|
void snd_soc_remove_dai_link(struct snd_soc_card *card,
|
|
|
|
struct snd_soc_dai_link *dai_link);
|
|
|
|
|
2015-12-31 09:40:43 +01:00
|
|
|
int snd_soc_register_dai(struct snd_soc_component *component,
|
|
|
|
struct snd_soc_dai_driver *dai_drv);
|
|
|
|
|
2016-04-19 07:12:25 +02:00
|
|
|
struct snd_soc_dai *snd_soc_find_dai(
|
|
|
|
const struct snd_soc_dai_link_component *dlc);
|
|
|
|
|
2008-07-23 15:03:07 +02:00
|
|
|
#include <sound/soc-dai.h>
|
|
|
|
|
2011-01-08 06:36:11 +01:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2011-01-10 23:25:21 +01:00
|
|
|
extern struct dentry *snd_soc_debugfs_root;
|
2011-01-08 06:36:11 +01:00
|
|
|
#endif
|
|
|
|
|
2011-01-26 15:59:27 +01:00
|
|
|
extern const struct dev_pm_ops snd_soc_pm_ops;
|
|
|
|
|
2014-02-18 16:22:13 +01:00
|
|
|
/* Helper functions */
|
|
|
|
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
2015-12-29 17:25:13 +01:00
|
|
|
mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
|
2014-02-18 16:22:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
|
|
|
|
{
|
|
|
|
mutex_unlock(&dapm->card->dapm_mutex);
|
|
|
|
}
|
|
|
|
|
2006-10-06 18:20:14 +02:00
|
|
|
#endif
|