soc.h 57.1 KB
Newer Older
1 2
/* SPDX-License-Identifier: GPL-2.0
 *
3 4
 * linux/sound/soc.h -- ALSA SoC Layer
 *
5 6
 * Author:	Liam Girdwood
 * Created:	Aug 11th 2005
7 8 9 10 11 12
 * Copyright:	Wolfson Microelectronics. PLC.
 */

#ifndef __LINUX_SND_SOC_H
#define __LINUX_SND_SOC_H

13
#include <linux/of.h>
14 15
#include <linux/platform_device.h>
#include <linux/types.h>
16
#include <linux/notifier.h>
17
#include <linux/workqueue.h>
18 19
#include <linux/interrupt.h>
#include <linux/kernel.h>
20
#include <linux/regmap.h>
21
#include <linux/log2.h>
22 23
#include <sound/core.h>
#include <sound/pcm.h>
24
#include <sound/compress_driver.h>
25 26 27 28 29 30
#include <sound/control.h>
#include <sound/ac97_codec.h>

/*
 * Convenience kcontrol builders
 */
31
#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
32
	((unsigned long)&(struct soc_mixer_control) \
33 34
	{.reg = xreg, .rreg = xreg, .shift = shift_left, \
	.rshift = shift_right, .max = xmax, .platform_max = xmax, \
35
	.invert = xinvert, .autodisable = xautodisable})
36 37 38 39 40
#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})
41 42
#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
	SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
43 44
#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
	((unsigned long)&(struct soc_mixer_control) \
45
	{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
46 47 48 49
#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})
50 51 52 53 54
#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})
55 56 57 58
#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})
P
Philipp Zabel 已提交
59
#define SOC_SINGLE(xname, reg, shift, max, invert) \
60 61 62
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
	.put = snd_soc_put_volsw, \
63
	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
64 65 66 67 68
#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) \
69 70 71
		{.reg = xreg, .rreg = xreg, .shift = xshift, \
		 .rshift = xshift,  .min = xmin, .max = xmax, \
		 .platform_max = xmax, .invert = xinvert} }
P
Philipp Zabel 已提交
72 73 74 75 76 77 78
#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, \
79
	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
80 81 82 83 84
#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),\
85
	.info = snd_soc_info_volsw_sx, \
86 87 88 89 90 91
	.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} }
92 93 94 95 96 97 98 99
#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) \
100 101 102
		{.reg = xreg, .rreg = xreg, .shift = xshift, \
		 .rshift = xshift, .min = xmin, .max = xmax, \
		 .platform_max = xmax, .invert = xinvert} }
103
#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
104 105 106
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
	.put = snd_soc_put_volsw, \
107
	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
108
					  max, invert, 0) }
D
Damien.Horsley 已提交
109 110 111 112 113 114 115 116
#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) }
117
#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
118
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
119
	.info = snd_soc_info_volsw, \
120
	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
121 122
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
123 124 125 126 127 128 129
#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) }
130
#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
P
Philipp Zabel 已提交
131 132 133 134 135 136
{	.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, \
137
	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
138
					  max, invert, 0) }
139
#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
P
Philipp Zabel 已提交
140 141 142 143
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
	.tlv.p = (tlv_array), \
144
	.info = snd_soc_info_volsw, \
145
	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
146 147
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
148 149 150 151 152 153 154 155 156 157
#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) }
158 159 160 161 162
#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), \
163
	.info = snd_soc_info_volsw_sx, \
164 165 166 167 168 169
	.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} }
170 171 172 173 174 175 176 177 178
#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) }
179 180 181 182 183 184 185 186 187 188 189
#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,} }
190
#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
191 192 193 194
{	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
	.tlv.p  = (tlv_array), \
195 196 197
	.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) }
198
#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
199
{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
200 201 202 203 204 205 206
	.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) \
P
Peter Ujfalusi 已提交
207
{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
208
	.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
209 210
#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
211 212 213 214
#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}
215 216
#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
	SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
217 218 219 220 221
#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 }
222
#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
223 224
	 xhandler_get, xhandler_put) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
G
Graeme Gregory 已提交
225
	.info = snd_soc_info_volsw, \
226
	.get = xhandler_get, .put = xhandler_put, \
227
	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
228
#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
D
Daniel Mack 已提交
229 230 231 232
	 xhandler_get, xhandler_put) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.info = snd_soc_info_volsw, \
	.get = xhandler_get, .put = xhandler_put, \
233
	.private_value = \
234
		SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
A
Adam Thomson 已提交
235 236 237 238 239 240 241
#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) }
242
#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
243 244 245 246 247 248 249
	 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, \
250
	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
251 252 253 254 255 256 257 258 259 260 261 262
#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} }
263 264 265 266 267 268 269 270
#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, \
271
	.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
272
					  xmax, xinvert, 0) }
273 274 275 276 277 278
#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), \
279
	.info = snd_soc_info_volsw, \
280
	.get = xhandler_get, .put = xhandler_put, \
281 282
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
283 284 285 286 287 288 289
#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, \
290
	.info = snd_soc_info_enum_double, \
291 292
	.get = xhandler_get, .put = xhandler_put, \
	.private_value = (unsigned long)&xenum }
293 294
#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
	SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
295

296 297 298 299 300 301
#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 }) }
302

303 304 305 306 307 308 309 310
#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 }) }

311 312 313
/*
 * SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
 */
V
Vinod Koul 已提交
314 315 316 317 318 319
#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} }
320 321 322 323 324
#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), \
325
	.info = snd_soc_bytes_info_ext, \
326 327
	.private_value = (unsigned long)&(struct soc_bytes_ext) \
		{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
328 329 330 331 332 333 334 335 336
#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} }

337 338 339 340
#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
		snd_soc_get_strobe, snd_soc_put_strobe)

341 342 343 344 345
/*
 * 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) \
346
	const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
347 348 349 350
						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) \
351
	const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
352
#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
353
	const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
354 355 356
							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)
357 358 359 360 361

#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)

362 363
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
364

365 366 367 368 369 370 371 372 373 374
/*
 * 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

375 376 377 378 379
#define for_each_comp_order(order)		\
	for (order  = SND_SOC_COMP_ORDER_FIRST;	\
	     order <= SND_SOC_COMP_ORDER_LAST;	\
	     order++)

380 381 382 383 384 385 386 387 388 389 390 391
/*
 * 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 {
392 393 394 395
	SND_SOC_BIAS_OFF = 0,
	SND_SOC_BIAS_STANDBY = 1,
	SND_SOC_BIAS_PREPARE = 2,
	SND_SOC_BIAS_ON = 3,
396 397
};

398
struct device_node;
M
Mark Brown 已提交
399 400
struct snd_jack;
struct snd_soc_card;
401 402 403
struct snd_soc_pcm_stream;
struct snd_soc_ops;
struct snd_soc_pcm_runtime;
404
struct snd_soc_dai;
405
struct snd_soc_dai_driver;
406
struct snd_soc_dai_link;
407 408
struct snd_soc_component;
struct snd_soc_component_driver;
409
struct soc_enum;
M
Mark Brown 已提交
410
struct snd_soc_jack;
411
struct snd_soc_jack_zone;
M
Mark Brown 已提交
412
struct snd_soc_jack_pin;
L
Liam Girdwood 已提交
413
#include <sound/soc-dapm.h>
414
#include <sound/soc-dpcm.h>
415
#include <sound/soc-topology.h>
416

417
struct snd_soc_jack_gpio;
418 419 420

typedef int (*hw_write_t)(void *,const char* ,int);

L
Liam Girdwood 已提交
421 422 423 424 425
enum snd_soc_pcm_subclass {
	SND_SOC_PCM_CLASS_PCM	= 0,
	SND_SOC_PCM_CLASS_BE	= 1,
};

426
enum snd_soc_card_subclass {
427 428
	SND_SOC_CARD_CLASS_INIT		= 0,
	SND_SOC_CARD_CLASS_RUNTIME	= 1,
429 430
};

431 432
int snd_soc_register_card(struct snd_soc_card *card);
int snd_soc_unregister_card(struct snd_soc_card *card);
433
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
434
#ifdef CONFIG_PM_SLEEP
435 436
int snd_soc_suspend(struct device *dev);
int snd_soc_resume(struct device *dev);
437 438 439 440 441 442 443 444 445 446 447
#else
static inline int snd_soc_suspend(struct device *dev)
{
	return 0;
}

static inline int snd_soc_resume(struct device *dev)
{
	return 0;
}
#endif
448
int snd_soc_poweroff(struct device *dev);
449 450 451 452 453
int snd_soc_add_component(struct device *dev,
		struct snd_soc_component *component,
		const struct snd_soc_component_driver *component_driver,
		struct snd_soc_dai_driver *dai_drv,
		int num_dai);
454
int snd_soc_register_component(struct device *dev,
455
			 const struct snd_soc_component_driver *component_driver,
456
			 struct snd_soc_dai_driver *dai_drv, int num_dai);
457
int devm_snd_soc_register_component(struct device *dev,
458
			 const struct snd_soc_component_driver *component_driver,
459
			 struct snd_soc_dai_driver *dai_drv, int num_dai);
460
void snd_soc_unregister_component(struct device *dev);
461 462
struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
						   const char *driver_name);
463

M
Mark Brown 已提交
464
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
465 466
#ifdef CONFIG_SND_SOC_COMPRESS
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
467 468 469 470 471
#else
static inline int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
{
	return 0;
}
472
#endif
M
Mark Brown 已提交
473

474 475
void snd_soc_disconnect_sync(struct device *dev);

476 477 478 479 480
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);

481
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
482 483
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);
484

485 486 487
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

488
#ifdef CONFIG_DMI
489
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
490 491 492 493 494 495 496
#else
static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
				       const char *flavour)
{
	return 0;
}
#endif
497

498 499 500
/* 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);
501
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
502 503
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

504 505 506 507
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

M
Mark Brown 已提交
508
/* Jack reporting */
509 510 511 512
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);

M
Mark Brown 已提交
513 514 515
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);
516 517 518 519
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);
520 521 522
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);
523 524 525
#ifdef CONFIG_GPIOLIB
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
526 527 528
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
			    struct snd_soc_jack *jack,
			    int count, struct snd_soc_jack_gpio *gpios);
529 530
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
531 532 533 534 535 536 537
#else
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
					 struct snd_soc_jack_gpio *gpios)
{
	return 0;
}

538 539 540 541
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)
542 543 544 545
{
	return 0;
}

546 547 548 549
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
550
#endif
M
Mark Brown 已提交
551

552 553
struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
554
	unsigned int id, unsigned int id_mask);
555
void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
556

557
#ifdef CONFIG_SND_SOC_AC97_BUS
558
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
559 560
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
561

562 563 564 565 566 567 568 569 570 571 572 573 574 575
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

576 577 578 579
/*
 *Controls
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
580
				  void *data, const char *long_name,
581
				  const char *prefix);
582 583
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
					       const char *name);
584 585
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
586 587 588 589
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);
590 591 592 593 594 595 596 597
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);
598 599
int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
			  struct snd_ctl_elem_info *uinfo);
600
#define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
601 602 603 604
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);
605 606
#define snd_soc_get_volsw_2r snd_soc_get_volsw
#define snd_soc_put_volsw_2r snd_soc_put_volsw
607 608 609 610
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);
611 612 613 614 615 616
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);
617
int snd_soc_limit_volume(struct snd_soc_card *card,
618
	const char *name, int max);
619 620 621 622 623 624
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);
V
Vinod Koul 已提交
625 626
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *ucontrol);
627 628
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
	unsigned int size, unsigned int __user *tlv);
629 630 631 632 633 634
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);
635 636 637 638
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);
639

M
Mark Brown 已提交
640 641 642 643 644 645
/**
 * 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
646
 * @list:   internal list entry
M
Mark Brown 已提交
647 648 649 650 651 652 653 654
 */
struct snd_soc_jack_pin {
	struct list_head list;
	const char *pin;
	int mask;
	bool invert;
};

655 656 657 658 659 660 661 662
/**
 * 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
663
 * @list:   internal list entry
664 665 666 667 668 669 670 671 672
 */
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;
};

673 674 675
/**
 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 *
676
 * @gpio:         legacy gpio number
677 678
 * @idx:          gpio descriptor index within the function of the GPIO
 *                consumer device
679
 * @gpiod_dev:    GPIO consumer device
680 681
 * @name:         gpio name. Also as connection ID for the GPIO consumer
 *                device function name lookup
682 683
 * @report:       value to report when jack detected
 * @invert:       report presence in low state
684
 * @debounce_time: debounce time in ms
685
 * @wake:	  enable as wake source
686 687 688
 * @jack_status_check: callback function which overrides the detection
 *		       to provide more complex checks (eg, reading an
 *		       ADC).
689 690 691
 */
struct snd_soc_jack_gpio {
	unsigned int gpio;
692 693
	unsigned int idx;
	struct device *gpiod_dev;
694 695 696 697
	const char *name;
	int report;
	int invert;
	int debounce_time;
698 699
	bool wake;

700
	/* private: */
701
	struct snd_soc_jack *jack;
702
	struct delayed_work work;
703
	struct notifier_block pm_notifier;
704
	struct gpio_desc *desc;
705

706
	void *data;
707
	/* public: */
708
	int (*jack_status_check)(void *data);
709 710
};

M
Mark Brown 已提交
711
struct snd_soc_jack {
712
	struct mutex mutex;
M
Mark Brown 已提交
713
	struct snd_jack *jack;
714
	struct snd_soc_card *card;
M
Mark Brown 已提交
715 716
	struct list_head pins;
	int status;
717
	struct blocking_notifier_head notifier;
718
	struct list_head jack_zones;
M
Mark Brown 已提交
719 720
};

721 722
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
723
	const char *stream_name;
G
Graeme Gregory 已提交
724 725
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
726 727 728 729
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
730
	unsigned int sig_bits;		/* number of bits of content */
731 732 733 734 735 736 737 738 739 740 741 742
};

/* 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);
};

743 744 745 746 747 748 749
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 *);
};

750 751 752
/* component interface */
struct snd_soc_component_driver {
	const char *name;
753

754 755 756 757 758 759 760 761 762 763
	/* 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 *);
764 765
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
766

767 768 769
	unsigned int (*read)(struct snd_soc_component *, unsigned int);
	int (*write)(struct snd_soc_component *, unsigned int, unsigned int);

770 771 772 773
	/* pcm creation and destruction */
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_pcm *);

774 775 776
	/* component wide operations */
	int (*set_sysclk)(struct snd_soc_component *component,
			  int clk_id, int source, unsigned int freq, int dir);
777 778
	int (*set_pll)(struct snd_soc_component *component, int pll_id,
		       int source, unsigned int freq_in, unsigned int freq_out);
779 780
	int (*set_jack)(struct snd_soc_component *component,
			struct snd_soc_jack *jack,  void *data);
781

782 783 784 785
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
786 787
	int (*of_xlate_dai_id)(struct snd_soc_component *comment,
			       struct device_node *endpoint);
788 789 790
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
791 792
	int (*set_bias_level)(struct snd_soc_component *component,
			      enum snd_soc_bias_level level);
793

794
	const struct snd_pcm_ops *ops;
795
	const struct snd_compr_ops *compr_ops;
796

797 798 799
	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
800

801 802 803 804 805 806 807
	/*
	 * signal if the module handling the component should not be removed
	 * if a pcm is open. Setting this would prevent the module
	 * refcount being incremented in probe() but allow it be incremented
	 * when a pcm is opened and decremented when it is closed.
	 */
	unsigned int module_get_upon_open:1;
808

809 810 811
	/* bits */
	unsigned int idle_bias_on:1;
	unsigned int suspend_bias_off:1;
812
	unsigned int use_pmdown_time:1; /* care pmdown_time at stop */
813
	unsigned int endianness:1;
814
	unsigned int non_legacy_dai_naming:1;
815 816 817 818 819 820 821 822

	/* this component uses topology and ignore machine driver FEs */
	const char *ignore_machine;
	const char *topology_name_prefix;
	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
				  struct snd_pcm_hw_params *params);
	bool use_dai_pcm_id;	/* use the DAI link PCM ID as PCM device number */
	int be_pcm_base;	/* base device ID for all BE PCMs */
823 824 825 826 827
};

struct snd_soc_component {
	const char *name;
	int id;
828
	const char *name_prefix;
829
	struct device *dev;
830
	struct snd_soc_card *card;
831 832 833

	unsigned int active;

834
	unsigned int suspended:1; /* is in suspend PM state */
835

836
	struct list_head list;
837
	struct list_head card_aux_list; /* for auxiliary bound components */
838
	struct list_head card_list;
839 840

	const struct snd_soc_component_driver *driver;
841 842

	struct list_head dai_list;
843
	int num_dai;
844 845 846 847 848

	struct regmap *regmap;
	int val_bytes;

	struct mutex io_mutex;
849

850 851 852
	/* attached dynamic objects */
	struct list_head dobj_list;

853 854 855 856 857 858
	/*
	* 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.
	*/

859 860
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
861

862 863 864
	/* machine specific init */
	int (*init)(struct snd_soc_component *component);

865
#ifdef CONFIG_DEBUG_FS
866
	struct dentry *debugfs_root;
867 868
	const char *debugfs_prefix;
#endif
869 870
};

871 872 873 874 875
#define for_each_component_dais(component, dai)\
	list_for_each_entry(dai, &(component)->dai_list, list)
#define for_each_component_dais_safe(component, dai, _dai)\
	list_for_each_entry_safe(dai, _dai, &(component)->dai_list, list)

876 877 878 879 880 881 882 883 884 885 886 887
struct snd_soc_rtdcom_list {
	struct snd_soc_component *component;
	struct list_head list; /* rtd::component_list */
};
struct snd_soc_component*
snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
		       const char *driver_name);
#define for_each_rtdcom(rtd, rtdcom) \
	list_for_each_entry(rtdcom, &(rtd)->component_list, list)
#define for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2) \
	list_for_each_entry_safe(rtdcom1, rtdcom2, &(rtd)->component_list, list)

888 889
struct snd_soc_dai_link_component {
	const char *name;
890
	struct device_node *of_node;
891 892 893
	const char *dai_name;
};

894 895 896 897
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
898

899 900 901 902 903 904 905 906 907 908 909 910
	/*
	 * You MAY specify the link's CPU-side device, either by device name,
	 * or by DT/OF node, but not both. If this information is omitted,
	 * the CPU-side DAI is matched using .cpu_dai_name only, which hence
	 * must be globally unique. These fields are currently typically used
	 * only for codec to codec links, or systems using device tree.
	 */
	/*
	 * You MAY specify the DAI name of the CPU DAI. If this information is
	 * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
	 * only, which only works well when that device exposes a single DAI.
	 */
911 912 913
	struct snd_soc_dai_link_component *cpus;
	unsigned int num_cpus;

914 915 916 917 918
	/*
	 * You MUST specify the link's codec, either by device name, or by
	 * DT/OF node, but not both.
	 */
	/* You MUST specify the DAI name within the codec */
919 920 921
	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

922 923 924
	/*
	 * 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
925
	 * do not need a platform. In such case, platforms are not mandatory.
926
	 */
927 928
	struct snd_soc_dai_link_component *platforms;
	unsigned int num_platforms;
929

930
	int id;	/* optional ID for machine driver link identification */
931

932
	const struct snd_soc_pcm_stream *params;
933
	unsigned int num_params;
934

935 936
	unsigned int dai_fmt;           /* format to set on init */

937 938
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

939 940 941 942 943 944 945 946 947 948 949 950 951 952
	/* 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;

	/* Mark this pcm with non atomic ops */
	bool nonatomic;

953 954 955 956
	/* For unidirectional dai links */
	unsigned int playback_only:1;
	unsigned int capture_only:1;

957 958 959
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

960 961
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
962 963
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
964

965 966 967 968 969 970
	/* 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;

971 972 973 974
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

975 976
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;
977 978
	/* DPCM used FE & BE merged channel */
	unsigned int dpcm_merged_chan:1;
979 980
	/* DPCM used FE & BE merged rate */
	unsigned int dpcm_merged_rate:1;
981

982 983
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
984

985 986 987
	/* Do not create a PCM for this DAI link (Backend link) */
	unsigned int ignore:1;

988 989
	struct list_head list; /* DAI link list of the soc card */
	struct snd_soc_dobj dobj; /* For topology */
990
};
991 992 993 994
#define for_each_link_codecs(link, i, codec)				\
	for ((i) = 0;							\
	     ((i) < link->num_codecs) && ((codec) = &link->codecs[i]);	\
	     (i)++)
995

996 997 998 999 1000 1001
#define for_each_link_platforms(link, i, platform)			\
	for ((i) = 0;							\
	     ((i) < link->num_platforms) &&				\
	     ((platform) = &link->platforms[i]);			\
	     (i)++)

1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
/*
 * Sample 1 : Single CPU/Codec/Platform
 *
 * SND_SOC_DAILINK_DEFS(test,
 *	DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai")),
 *	DAILINK_COMP_ARRAY(COMP_CODEC("codec", "codec_dai")),
 *	DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
 *
 * struct snd_soc_dai_link link = {
 *	...
 *	SND_SOC_DAILINK_REG(test),
 * };
 *
 * Sample 2 : Multi CPU/Codec, no Platform
 *
 * SND_SOC_DAILINK_DEFS(test,
 *	DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
 *			   COMP_CPU("cpu_dai2")),
 *	DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
 *			   COMP_CODEC("codec2", "codec_dai2")));
 *
 * struct snd_soc_dai_link link = {
 *	...
 *	SND_SOC_DAILINK_REG(test),
 * };
 *
 * Sample 3 : Define each CPU/Codec/Platform manually
 *
 * SND_SOC_DAILINK_DEF(test_cpu,
 *		DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
 *				   COMP_CPU("cpu_dai2")));
 * SND_SOC_DAILINK_DEF(test_codec,
 *		DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
 *				   COMP_CODEC("codec2", "codec_dai2")));
 * SND_SOC_DAILINK_DEF(test_platform,
 *		DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
 *
 * struct snd_soc_dai_link link = {
 *	...
 *	SND_SOC_DAILINK_REG(test_cpu,
 *			    test_codec,
 *			    test_platform),
 * };
 *
 * Sample 4 : Sample3 without platform
 *
 * struct snd_soc_dai_link link = {
 *	...
 *	SND_SOC_DAILINK_REG(test_cpu,
 *			    test_codec);
 * };
 */

#define SND_SOC_DAILINK_REG1(name)	 SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
#define SND_SOC_DAILINK_REG3(cpu, codec, platform)	\
	.cpus		= cpu,				\
	.num_cpus	= ARRAY_SIZE(cpu),		\
	.codecs		= codec,			\
	.num_codecs	= ARRAY_SIZE(codec),		\
	.platforms	= platform,			\
	.num_platforms	= ARRAY_SIZE(platform)

#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
#define SND_SOC_DAILINK_REG(...) \
	SND_SOC_DAILINK_REGx(__VA_ARGS__,		\
			SND_SOC_DAILINK_REG3,	\
			SND_SOC_DAILINK_REG2,	\
			SND_SOC_DAILINK_REG1)(__VA_ARGS__)

#define SND_SOC_DAILINK_DEF(name, def...)		\
	static struct snd_soc_dai_link_component name[]	= { def }

#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...)	\
	SND_SOC_DAILINK_DEF(name##_cpus, cpu);			\
	SND_SOC_DAILINK_DEF(name##_codecs, codec);		\
	SND_SOC_DAILINK_DEF(name##_platforms, platform)

#define DAILINK_COMP_ARRAY(param...)	param
#define COMP_EMPTY()			{ }
#define COMP_CPU(_dai)			{ .dai_name = _dai, }
#define COMP_CODEC(_name, _dai)		{ .name = _name, .dai_name = _dai, }
#define COMP_PLATFORM(_name)		{ .name = _name }
#define COMP_DUMMY()			{ .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }

extern struct snd_soc_dai_link_component null_dailink_component[0];


1090
struct snd_soc_codec_conf {
1091 1092 1093 1094
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
1095
	const char *dev_name;
1096
	struct device_node *of_node;
1097 1098 1099 1100 1101

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1102 1103 1104
	const char *name_prefix;
};

1105 1106
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1107 1108 1109 1110 1111 1112

	/*
	 * specify multi-codec either by device name, or by
	 * DT/OF node, but not both.
	 */
	const char *codec_name;
1113
	struct device_node *codec_of_node;
1114 1115

	/* codec/machine specific init - e.g. add machine controls */
1116
	int (*init)(struct snd_soc_component *component);
1117 1118
};

1119 1120
/* SoC card */
struct snd_soc_card {
1121
	const char *name;
1122 1123
	const char *long_name;
	const char *driver_name;
1124
	char dmi_longname[80];
1125
	char topology_shortname[32];
1126

M
Mark Brown 已提交
1127
	struct device *dev;
1128 1129
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1130

1131
	struct mutex mutex;
1132
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1133

1134 1135
	spinlock_t dpcm_lock;

1136
	bool instantiated;
1137
	bool topology_shortname_created;
1138

1139
	int (*probe)(struct snd_soc_card *card);
1140
	int (*late_probe)(struct snd_soc_card *card);
1141
	int (*remove)(struct snd_soc_card *card);
1142 1143 1144

	/* 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. */
1145 1146 1147 1148
	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);
1149

1150
	/* callbacks */
1151
	int (*set_bias_level)(struct snd_soc_card *,
1152
			      struct snd_soc_dapm_context *dapm,
1153
			      enum snd_soc_bias_level level);
1154
	int (*set_bias_level_post)(struct snd_soc_card *,
1155
				   struct snd_soc_dapm_context *dapm,
1156
				   enum snd_soc_bias_level level);
1157

1158 1159 1160 1161 1162
	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);

M
Mark Brown 已提交
1163
	long pmdown_time;
1164

1165
	/* CPU <--> Codec DAI links  */
1166 1167 1168 1169
	struct snd_soc_dai_link *dai_link;  /* predefined links only */
	int num_links;  /* predefined links only */
	struct list_head dai_link_list; /* all links */

1170
	struct list_head rtd_list;
1171
	int num_rtd;
1172

1173 1174 1175
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1176

1177 1178 1179 1180 1181 1182
	/*
	 * optional auxiliary devices such as amplifiers or codecs with DAI
	 * link unused
	 */
	struct snd_soc_aux_dev *aux_dev;
	int num_aux_devs;
1183
	struct list_head aux_comp_list;
1184

1185 1186 1187
	const struct snd_kcontrol_new *controls;
	int num_controls;

1188 1189
	/*
	 * Card-specific routes and widgets.
1190
	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1191
	 */
1192
	const struct snd_soc_dapm_widget *dapm_widgets;
1193
	int num_dapm_widgets;
1194
	const struct snd_soc_dapm_route *dapm_routes;
1195
	int num_dapm_routes;
1196 1197 1198 1199
	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;
1200
	bool fully_routed;
1201

1202
	struct work_struct deferred_resume_work;
1203 1204

	/* lists of probed devices belonging to this card */
1205
	struct list_head component_dev_list;
1206
	struct list_head list;
1207

1208
	struct list_head widgets;
1209
	struct list_head paths;
1210
	struct list_head dapm_list;
1211
	struct list_head dapm_dirty;
1212

1213 1214 1215
	/* attached dynamic objects */
	struct list_head dobj_list;

M
Mark Brown 已提交
1216 1217
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1218
	struct snd_soc_dapm_stats dapm_stats;
1219
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1220

1221 1222
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1223
	struct dentry *debugfs_pop_time;
1224
#endif
1225
	u32 pop_time;
M
Mark Brown 已提交
1226 1227

	void *drvdata;
1228
};
1229 1230 1231 1232
#define for_each_card_prelinks(card, i, link)				\
	for ((i) = 0;							\
	     ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
	     (i)++)
1233

1234
#define for_each_card_links(card, link)				\
1235
	list_for_each_entry(link, &(card)->dai_link_list, list)
1236 1237 1238
#define for_each_card_links_safe(card, link, _link)			\
	list_for_each_entry_safe(link, _link, &(card)->dai_link_list, list)

1239 1240 1241 1242
#define for_each_card_rtds(card, rtd)			\
	list_for_each_entry(rtd, &(card)->rtd_list, list)
#define for_each_card_rtds_safe(card, rtd, _rtd)	\
	list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
1243

1244 1245 1246
#define for_each_card_components(card, component)			\
	list_for_each_entry(component, &(card)->component_dev_list, card_list)

1247
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1248
struct snd_soc_pcm_runtime {
1249
	struct device *dev;
1250
	struct snd_soc_card *card;
1251
	struct snd_soc_dai_link *dai_link;
L
Liam Girdwood 已提交
1252 1253 1254
	struct mutex pcm_mutex;
	enum snd_soc_pcm_subclass pcm_subclass;
	struct snd_pcm_ops ops;
1255

1256 1257
	unsigned int params_select; /* currently selected param for dai link */

1258 1259 1260
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];

1261 1262 1263 1264
	long pmdown_time;

	/* runtime devices */
	struct snd_pcm *pcm;
1265
	struct snd_compr *compr;
1266 1267 1268
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;

1269 1270 1271
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1272
	struct delayed_work delayed_work;
1273 1274 1275
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
#endif
1276 1277 1278

	unsigned int num; /* 0-based and monotonic increasing */
	struct list_head list; /* rtd list of the soc card */
1279
	struct list_head component_list; /* list of connected components */
1280 1281 1282 1283

	/* bit field */
	unsigned int dev_registered:1;
	unsigned int pop_wait:1;
1284
	unsigned int fe_compr:1; /* for Dynamic PCM */
1285
};
1286 1287 1288 1289
#define for_each_rtd_codec_dai(rtd, i, dai)\
	for ((i) = 0;						       \
	     ((i) < rtd->num_codecs) && ((dai) = rtd->codec_dais[i]); \
	     (i)++)
1290
#define for_each_rtd_codec_dai_rollback(rtd, i, dai)		\
1291
	for (; ((--i) >= 0) && ((dai) = rtd->codec_dais[i]);)
1292

1293

1294 1295
/* mixer control */
struct soc_mixer_control {
1296
	int min, max, platform_max;
1297 1298
	int reg, rreg;
	unsigned int shift, rshift;
1299
	unsigned int sign_bit;
1300 1301
	unsigned int invert:1;
	unsigned int autodisable:1;
1302
	struct snd_soc_dobj dobj;
1303 1304
};

1305 1306 1307
struct soc_bytes {
	int base;
	int num_regs;
1308
	u32 mask;
1309 1310
};

V
Vinod Koul 已提交
1311 1312
struct soc_bytes_ext {
	int max;
1313 1314
	struct snd_soc_dobj dobj;

1315
	/* used for TLV byte control */
1316 1317 1318 1319
	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);
V
Vinod Koul 已提交
1320 1321
};

1322 1323 1324 1325 1326 1327
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1328 1329
/* enumerated kcontrol */
struct soc_enum {
1330
	int reg;
P
Peter Ujfalusi 已提交
1331 1332
	unsigned char shift_l;
	unsigned char shift_r;
1333
	unsigned int items;
P
Peter Ujfalusi 已提交
1334
	unsigned int mask;
1335
	const char * const *texts;
P
Peter Ujfalusi 已提交
1336
	const unsigned int *values;
1337
	unsigned int autodisable:1;
1338
	struct snd_soc_dobj dobj;
P
Peter Ujfalusi 已提交
1339 1340
};

1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
/**
 * 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);
}

/**
 * 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)
{
1364
	return &component->dapm;
1365 1366
}

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
/**
 * snd_soc_component_init_bias_level() - Initialize COMPONENT DAPM bias level
 * @component: The COMPONENT for which to initialize the DAPM bias level
 * @level: The DAPM level to initialize to
 *
 * Initializes the COMPONENT DAPM bias level. See snd_soc_dapm_init_bias_level().
 */
static inline void
snd_soc_component_init_bias_level(struct snd_soc_component *component,
				  enum snd_soc_bias_level level)
{
	snd_soc_dapm_init_bias_level(
		snd_soc_component_get_dapm(component), level);
}

/**
 * snd_soc_component_get_bias_level() - Get current COMPONENT DAPM bias level
 * @component: The COMPONENT for which to get the DAPM bias level
 *
 * Returns: The current DAPM bias level of the COMPONENT.
 */
static inline enum snd_soc_bias_level
snd_soc_component_get_bias_level(struct snd_soc_component *component)
{
	return snd_soc_dapm_get_bias_level(
		snd_soc_component_get_dapm(component));
}

/**
 * snd_soc_component_force_bias_level() - Set the COMPONENT DAPM bias level
 * @component: The COMPONENT for which to set the level
 * @level: The level to set to
 *
 * Forces the COMPONENT bias level to a specific state. See
 * snd_soc_dapm_force_bias_level().
 */
static inline int
snd_soc_component_force_bias_level(struct snd_soc_component *component,
				   enum snd_soc_bias_level level)
{
	return snd_soc_dapm_force_bias_level(
		snd_soc_component_get_dapm(component),
		level);
}

1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
/**
 * snd_soc_dapm_kcontrol_component() - Returns the component associated to a kcontrol
 * @kcontrol: The kcontrol
 *
 * 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_kcontrol_component(
	struct snd_kcontrol *kcontrol)
{
	return snd_soc_dapm_to_component(snd_soc_dapm_kcontrol_dapm(kcontrol));
}

1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
/**
 * snd_soc_component_cache_sync() - Sync the register cache with the hardware
 * @component: COMPONENT to sync
 *
 * Note: This function will call regcache_sync()
 */
static inline int snd_soc_component_cache_sync(
	struct snd_soc_component *component)
{
	return regcache_sync(component->regmap);
}

1437 1438 1439
/* component IO */
int snd_soc_component_read(struct snd_soc_component *component,
	unsigned int reg, unsigned int *val);
1440 1441
unsigned int snd_soc_component_read32(struct snd_soc_component *component,
				      unsigned int reg);
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
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);

1452 1453 1454
/* component wide operations */
int snd_soc_component_set_sysclk(struct snd_soc_component *component,
			int clk_id, int source, unsigned int freq, int dir);
1455 1456 1457
int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
			      int source, unsigned int freq_in,
			      unsigned int freq_out);
1458 1459
int snd_soc_component_set_jack(struct snd_soc_component *component,
			       struct snd_soc_jack *jack, void *data);
1460

1461 1462
#ifdef CONFIG_REGMAP

1463 1464 1465 1466
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);

1467 1468
#endif

1469 1470
/* device driver data */

M
Mark Brown 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
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;
}

1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
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);
}

1493 1494 1495 1496 1497
static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
{
	INIT_LIST_HEAD(&card->widgets);
	INIT_LIST_HEAD(&card->paths);
	INIT_LIST_HEAD(&card->dapm_list);
1498
	INIT_LIST_HEAD(&card->aux_comp_list);
1499
	INIT_LIST_HEAD(&card->component_dev_list);
1500
	INIT_LIST_HEAD(&card->list);
1501 1502
}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
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;
}

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
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];
}

1539 1540 1541 1542 1543 1544
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1545 1546 1547 1548 1549 1550
/**
 * 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
1551 1552 1553
 * for a component. With snd_soc_add_codec_controls() or via table based
 * setup for either a CODEC or component driver. Otherwise the behavior is
 * undefined.
1554 1555 1556 1557 1558 1559 1560
 */
static inline struct snd_soc_component *snd_soc_kcontrol_component(
	struct snd_kcontrol *kcontrol)
{
	return snd_kcontrol_chip(kcontrol);
}

1561 1562 1563
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1564 1565
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname);
1566 1567
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname);
1568 1569 1570
int snd_soc_of_get_slot_mask(struct device_node *np,
			     const char *prop_name,
			     unsigned int *mask);
1571
int snd_soc_of_parse_tdm_slot(struct device_node *np,
1572 1573
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
1574 1575
			      unsigned int *slots,
			      unsigned int *slot_width);
1576
void snd_soc_of_parse_node_prefix(struct device_node *np,
1577 1578 1579
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname);
1580 1581 1582 1583 1584 1585 1586 1587 1588
static inline
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname)
{
	snd_soc_of_parse_node_prefix(card->dev->of_node,
				     codec_conf, of_node, propname);
}
1589

1590 1591
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
				   const char *propname);
1592
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1593 1594 1595
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1596
int snd_soc_get_dai_id(struct device_node *ep);
1597 1598
int snd_soc_get_dai_name(struct of_phandle_args *args,
			 const char **dai_name);
1599 1600
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1601 1602 1603
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1604
void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1605

1606 1607 1608 1609
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);
M
Mengdong Lin 已提交
1610 1611 1612
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
					       int id, const char *name,
					       const char *stream_name);
1613

1614 1615 1616
int snd_soc_register_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv);

M
Mengdong Lin 已提交
1617 1618 1619
struct snd_soc_dai *snd_soc_find_dai(
	const struct snd_soc_dai_link_component *dlc);

1620 1621
#include <sound/soc-dai.h>

1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
static inline
struct snd_soc_dai *snd_soc_card_get_codec_dai(struct snd_soc_card *card,
					       const char *dai_name)
{
	struct snd_soc_pcm_runtime *rtd;

	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (!strcmp(rtd->codec_dai->name, dai_name))
			return rtd->codec_dai;
	}

	return NULL;
}

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
static inline
int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
					  const char *platform_name)
{
	struct snd_soc_dai_link *dai_link;
	const char *name;
	int i;

	if (!platform_name) /* nothing to do */
		return 0;

	/* set platform name for each dailink */
	for_each_card_prelinks(card, i, dai_link) {
		name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
		if (!name)
			return -ENOMEM;

1653 1654 1655 1656 1657
		if (!dai_link->platforms)
			return -EINVAL;

		/* only single platform is supported for now */
		dai_link->platforms->name = name;
1658 1659 1660 1661 1662
	}

	return 0;
}

1663
#ifdef CONFIG_DEBUG_FS
1664
extern struct dentry *snd_soc_debugfs_root;
1665 1666
#endif

1667 1668
extern const struct dev_pm_ops snd_soc_pm_ops;

1669 1670 1671
/* Helper functions */
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
1672
	mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1673 1674 1675 1676 1677 1678 1679
}

static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
{
	mutex_unlock(&dapm->card->dapm_mutex);
}

1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
int snd_soc_component_enable_pin(struct snd_soc_component *component,
				 const char *pin);
int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
					  const char *pin);
int snd_soc_component_disable_pin(struct snd_soc_component *component,
				  const char *pin);
int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
					   const char *pin);
int snd_soc_component_nc_pin(struct snd_soc_component *component,
			     const char *pin);
int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
				      const char *pin);
int snd_soc_component_get_pin_status(struct snd_soc_component *component,
				     const char *pin);
int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
				       const char *pin);
int snd_soc_component_force_enable_pin_unlocked(
					struct snd_soc_component *component,
					const char *pin);

1700
#endif