soc.h 54.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * 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

16
#include <linux/of.h>
17 18
#include <linux/platform_device.h>
#include <linux/types.h>
19
#include <linux/notifier.h>
20
#include <linux/workqueue.h>
21 22
#include <linux/interrupt.h>
#include <linux/kernel.h>
23
#include <linux/regmap.h>
24
#include <linux/log2.h>
25 26
#include <sound/core.h>
#include <sound/pcm.h>
27
#include <sound/compress_driver.h>
28 29
#include <sound/control.h>
#include <sound/ac97_codec.h>
30
#include <sound/soc-topology.h>
31 32 33 34

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

262 263 264 265 266 267
#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 }) }
268

269 270 271 272 273 274 275 276
#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 }) }

V
Vinod Koul 已提交
277 278 279 280 281 282
#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} }
283 284 285 286 287
#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), \
288
	.info = snd_soc_bytes_info_ext, \
289 290
	.private_value = (unsigned long)&(struct soc_bytes_ext) \
		{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
291 292 293 294 295 296 297 298 299
#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} }

300 301 302 303
#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
		snd_soc_get_strobe, snd_soc_put_strobe)

304 305 306 307 308
/*
 * 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) \
309
	const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
310 311 312 313
						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) \
314
	const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
315
#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
316
	const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
317 318 319
							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)
320 321 322 323 324

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

325 326
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
327

328 329 330 331 332 333 334 335 336 337
/*
 * 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

338 339 340 341 342 343 344 345 346 347 348 349
/*
 * 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 {
350 351 352 353
	SND_SOC_BIAS_OFF = 0,
	SND_SOC_BIAS_STANDBY = 1,
	SND_SOC_BIAS_PREPARE = 2,
	SND_SOC_BIAS_ON = 3,
354 355
};

356
struct device_node;
M
Mark Brown 已提交
357 358
struct snd_jack;
struct snd_soc_card;
359 360 361
struct snd_soc_pcm_stream;
struct snd_soc_ops;
struct snd_soc_pcm_runtime;
362
struct snd_soc_dai;
363
struct snd_soc_dai_driver;
M
Mark Brown 已提交
364
struct snd_soc_platform;
365
struct snd_soc_dai_link;
366
struct snd_soc_platform_driver;
367
struct snd_soc_codec;
368
struct snd_soc_codec_driver;
369 370
struct snd_soc_component;
struct snd_soc_component_driver;
371
struct soc_enum;
M
Mark Brown 已提交
372
struct snd_soc_jack;
373
struct snd_soc_jack_zone;
M
Mark Brown 已提交
374
struct snd_soc_jack_pin;
L
Liam Girdwood 已提交
375
#include <sound/soc-dapm.h>
376
#include <sound/soc-dpcm.h>
377

378
struct snd_soc_jack_gpio;
379 380 381

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

L
Liam Girdwood 已提交
382 383 384 385 386
enum snd_soc_pcm_subclass {
	SND_SOC_PCM_CLASS_PCM	= 0,
	SND_SOC_PCM_CLASS_BE	= 1,
};

387
enum snd_soc_card_subclass {
388 389
	SND_SOC_CARD_CLASS_INIT		= 0,
	SND_SOC_CARD_CLASS_RUNTIME	= 1,
390 391
};

392
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
393
			     int source, unsigned int freq, int dir);
394 395 396
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
			  unsigned int freq_in, unsigned int freq_out);

397 398
int snd_soc_register_card(struct snd_soc_card *card);
int snd_soc_unregister_card(struct snd_soc_card *card);
399
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
400
#ifdef CONFIG_PM_SLEEP
401 402
int snd_soc_suspend(struct device *dev);
int snd_soc_resume(struct device *dev);
403 404 405 406 407 408 409 410 411 412 413
#else
static inline int snd_soc_suspend(struct device *dev)
{
	return 0;
}

static inline int snd_soc_resume(struct device *dev)
{
	return 0;
}
#endif
414
int snd_soc_poweroff(struct device *dev);
415
int snd_soc_register_platform(struct device *dev,
416
		const struct snd_soc_platform_driver *platform_drv);
417 418
int devm_snd_soc_register_platform(struct device *dev,
		const struct snd_soc_platform_driver *platform_drv);
419
void snd_soc_unregister_platform(struct device *dev);
420 421 422 423
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);
424
int snd_soc_register_codec(struct device *dev,
425
		const struct snd_soc_codec_driver *codec_drv,
426 427
		struct snd_soc_dai_driver *dai_drv, int num_dai);
void snd_soc_unregister_codec(struct device *dev);
428 429 430
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);
431 432 433
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);
434
void snd_soc_unregister_component(struct device *dev);
435 436
int snd_soc_cache_init(struct snd_soc_codec *codec);
int snd_soc_cache_exit(struct snd_soc_codec *codec);
437

438 439 440 441
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);
M
Mark Brown 已提交
442
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
443
int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
M
Mark Brown 已提交
444

445 446 447 448 449
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);

450
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
451 452
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);
453

454 455 456
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

457 458 459
/* 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);
460
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
461 462
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

463 464 465 466
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

467 468 469
int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
		int cmd, struct snd_soc_platform *platform);

470 471 472 473
int soc_dai_hw_params(struct snd_pcm_substream *substream,
		      struct snd_pcm_hw_params *params,
		      struct snd_soc_dai *dai);

M
Mark Brown 已提交
474
/* Jack reporting */
475 476 477 478
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 已提交
479 480 481
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);
482 483 484 485
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);
486 487 488
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);
489 490 491
#ifdef CONFIG_GPIOLIB
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
492 493 494
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
			    struct snd_soc_jack *jack,
			    int count, struct snd_soc_jack_gpio *gpios);
495 496
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
497 498 499 500 501 502 503
#else
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
					 struct snd_soc_jack_gpio *gpios)
{
	return 0;
}

504 505 506 507
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)
508 509 510 511
{
	return 0;
}

512 513 514 515
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
516
#endif
M
Mark Brown 已提交
517

518
/* codec register bit access */
519
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
520
				unsigned int mask, unsigned int value);
521
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
522
			       unsigned int reg, unsigned int mask,
523
			       unsigned int value);
524
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
525
				unsigned int mask, unsigned int value);
526

527
#ifdef CONFIG_SND_SOC_AC97_BUS
528
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
529 530
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec);
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
531

532
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
533 534
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
535

536 537 538 539 540 541 542 543 544 545 546 547 548 549
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

550 551 552 553
/*
 *Controls
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
554
				  void *data, const char *long_name,
555
				  const char *prefix);
556 557
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
					       const char *name);
558 559
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
560
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
561
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
562
int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
563
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
564 565 566 567
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);
568 569 570 571 572 573 574 575
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);
576
#define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
577 578 579 580
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);
581 582
#define snd_soc_get_volsw_2r snd_soc_get_volsw
#define snd_soc_put_volsw_2r snd_soc_put_volsw
583 584 585 586
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);
587 588 589 590 591 592
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);
593 594
int snd_soc_limit_volume(struct snd_soc_codec *codec,
	const char *name, int max);
595 596 597 598 599 600
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 已提交
601 602
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *ucontrol);
603 604
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
	unsigned int size, unsigned int __user *tlv);
605 606 607 608 609 610
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);
611 612 613 614
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);
615

M
Mark Brown 已提交
616 617 618 619 620 621 622 623 624 625 626 627 628 629
/**
 * 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
 */
struct snd_soc_jack_pin {
	struct list_head list;
	const char *pin;
	int mask;
	bool invert;
};

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
/**
 * 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
 * @:list: list container
 */
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;
};

648 649 650
/**
 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 *
651
 * @gpio:         legacy gpio number
652 653
 * @idx:          gpio descriptor index within the function of the GPIO
 *                consumer device
654
 * @gpiod_dev     GPIO consumer device
655 656
 * @name:         gpio name. Also as connection ID for the GPIO consumer
 *                device function name lookup
657 658 659
 * @report:       value to report when jack detected
 * @invert:       report presence in low state
 * @debouce_time: debouce time in ms
660
 * @wake:	  enable as wake source
661 662 663
 * @jack_status_check: callback function which overrides the detection
 *		       to provide more complex checks (eg, reading an
 *		       ADC).
664 665 666
 */
struct snd_soc_jack_gpio {
	unsigned int gpio;
667 668
	unsigned int idx;
	struct device *gpiod_dev;
669 670 671 672
	const char *name;
	int report;
	int invert;
	int debounce_time;
673 674
	bool wake;

675
	struct snd_soc_jack *jack;
676
	struct delayed_work work;
677
	struct gpio_desc *desc;
678

679 680
	void *data;
	int (*jack_status_check)(void *data);
681 682
};

M
Mark Brown 已提交
683
struct snd_soc_jack {
684
	struct mutex mutex;
M
Mark Brown 已提交
685
	struct snd_jack *jack;
686
	struct snd_soc_card *card;
M
Mark Brown 已提交
687 688
	struct list_head pins;
	int status;
689
	struct blocking_notifier_head notifier;
690
	struct list_head jack_zones;
M
Mark Brown 已提交
691 692
};

693 694
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
695
	const char *stream_name;
G
Graeme Gregory 已提交
696 697
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
698 699 700 701
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
702
	unsigned int sig_bits;		/* number of bits of content */
703 704 705 706 707 708 709 710 711 712 713 714
};

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

715 716 717 718 719 720 721
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 *);
};

722 723 724
/* component interface */
struct snd_soc_component_driver {
	const char *name;
725

726 727 728 729 730 731 732 733 734 735 736
	/* 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 *);

737 738 739 740
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
741 742 743
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
744 745 746 747

	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
748 749 750 751 752
};

struct snd_soc_component {
	const char *name;
	int id;
753
	const char *name_prefix;
754
	struct device *dev;
755
	struct snd_soc_card *card;
756 757 758

	unsigned int active;

759
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
760
	unsigned int registered_as_component:1;
761
	unsigned int probed:1;
762

763 764
	struct list_head list;

765 766 767
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

768
	const struct snd_soc_component_driver *driver;
769 770

	struct list_head dai_list;
771 772 773 774 775 776 777 778

	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;
779

780 781 782
	/* attached dynamic objects */
	struct list_head dobj_list;

783 784 785 786 787 788 789 790 791 792
#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.
	*/

793 794 795
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
	struct snd_soc_dapm_context *dapm_ptr;
796

797 798 799 800 801 802 803 804 805 806 807
	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 *);

808 809 810 811
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
812 813
};

814
/* SoC Audio Codec device */
815
struct snd_soc_codec {
M
Mark Brown 已提交
816
	struct device *dev;
817
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
818 819

	struct list_head list;
820
	struct list_head card_list;
821 822

	/* runtime */
823
	unsigned int cache_bypass:1; /* Suppress access to the cache */
824
	unsigned int suspended:1; /* Codec is in suspend PM state */
825
	unsigned int cache_init:1; /* codec cache has been initialized */
826 827 828 829 830

	/* codec IO */
	void *control_data; /* codec control (i2c/3wire) data */
	hw_write_t hw_write;
	void *reg_cache;
831

832 833 834
	/* component */
	struct snd_soc_component component;

835
	/* Don't access this directly, use snd_soc_codec_get_dapm() */
L
Liam Girdwood 已提交
836
	struct snd_soc_dapm_context dapm;
837

838 839 840
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_reg;
#endif
841 842
};

843 844 845 846 847 848
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
849
	int (*suspend)(struct snd_soc_codec *);
850
	int (*resume)(struct snd_soc_codec *);
851
	struct snd_soc_component_driver component_driver;
852

853 854 855
	/* Default control and setup, added after probe() is run */
	const struct snd_kcontrol_new *controls;
	int num_controls;
856 857 858 859 860
	const struct snd_soc_dapm_widget *dapm_widgets;
	int num_dapm_widgets;
	const struct snd_soc_dapm_route *dapm_routes;
	int num_dapm_routes;

861 862
	/* codec wide operations */
	int (*set_sysclk)(struct snd_soc_codec *codec,
863
			  int clk_id, int source, unsigned int freq, int dir);
864 865 866
	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
		unsigned int freq_in, unsigned int freq_out);

867
	/* codec IO */
868
	struct regmap *(*get_regmap)(struct device *);
869 870
	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
871
	unsigned int reg_cache_size;
872 873 874 875 876 877 878
	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);
879
	bool idle_bias_off;
880
	bool suspend_bias_off;
881 882

	void (*seq_notifier)(struct snd_soc_dapm_context *,
883
			     enum snd_soc_dapm_type, int);
884

885
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
886 887 888
};

/* SoC platform interface */
889
struct snd_soc_platform_driver {
890

891 892
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
893
	struct snd_soc_component_driver component_driver;
894 895

	/* pcm creation and destruction */
896
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
897 898
	void (*pcm_free)(struct snd_pcm *);

899 900 901 902 903 904 905
	/*
	 * For platform caused delay reporting.
	 * Optional.
	 */
	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
		struct snd_soc_dai *);

906
	/* platform stream pcm ops */
907
	const struct snd_pcm_ops *ops;
908

909
	/* platform stream compress ops */
910
	const struct snd_compr_ops *compr_ops;
911

912
	int (*bespoke_trigger)(struct snd_pcm_substream *, int);
913 914
};

915 916
struct snd_soc_dai_link_component {
	const char *name;
917
	struct device_node *of_node;
918 919 920
	const char *dai_name;
};

921 922
struct snd_soc_platform {
	struct device *dev;
923
	const struct snd_soc_platform_driver *driver;
924

925
	struct list_head list;
926

927
	struct snd_soc_component component;
928
};
929

930 931 932 933
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
934 935 936 937 938 939 940 941
	/*
	 * 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;
942
	struct device_node *cpu_of_node;
943 944 945 946 947
	/*
	 * 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.
	 */
948
	const char *cpu_dai_name;
949 950 951 952 953
	/*
	 * You MUST specify the link's codec, either by device name, or by
	 * DT/OF node, but not both.
	 */
	const char *codec_name;
954
	struct device_node *codec_of_node;
955
	/* You MUST specify the DAI name within the codec */
956
	const char *codec_dai_name;
957 958 959 960

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

961 962 963 964 965 966
	/*
	 * 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;
967
	struct device_node *platform_of_node;
968
	int be_id;	/* optional ID for machine driver BE identification */
969

970
	const struct snd_soc_pcm_stream *params;
971
	unsigned int num_params;
972

973 974
	unsigned int dai_fmt;           /* format to set on init */

975 976
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
	/* 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;

995 996 997
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

998 999
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
1000 1001
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
1002

1003 1004 1005 1006 1007 1008
	/* 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;

1009 1010 1011 1012
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

1013 1014 1015
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;

1016 1017
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
1018 1019
};

1020
struct snd_soc_codec_conf {
1021 1022 1023 1024
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
1025
	const char *dev_name;
1026
	struct device_node *of_node;
1027 1028 1029 1030 1031

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1032 1033 1034
	const char *name_prefix;
};

1035 1036
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1037 1038 1039 1040 1041 1042

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

	/* codec/machine specific init - e.g. add machine controls */
1046
	int (*init)(struct snd_soc_component *component);
1047 1048
};

1049 1050
/* SoC card */
struct snd_soc_card {
1051
	const char *name;
1052 1053
	const char *long_name;
	const char *driver_name;
M
Mark Brown 已提交
1054
	struct device *dev;
1055 1056
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1057

1058
	struct mutex mutex;
1059
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1060

1061
	bool instantiated;
1062

1063
	int (*probe)(struct snd_soc_card *card);
1064
	int (*late_probe)(struct snd_soc_card *card);
1065
	int (*remove)(struct snd_soc_card *card);
1066 1067 1068

	/* 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. */
1069 1070 1071 1072
	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);
1073

1074
	/* callbacks */
1075
	int (*set_bias_level)(struct snd_soc_card *,
1076
			      struct snd_soc_dapm_context *dapm,
1077
			      enum snd_soc_bias_level level);
1078
	int (*set_bias_level_post)(struct snd_soc_card *,
1079
				   struct snd_soc_dapm_context *dapm,
1080
				   enum snd_soc_bias_level level);
1081

M
Mark Brown 已提交
1082
	long pmdown_time;
1083

1084 1085 1086
	/* CPU <--> Codec DAI links  */
	struct snd_soc_dai_link *dai_link;
	int num_links;
1087 1088
	struct snd_soc_pcm_runtime *rtd;
	int num_rtd;
1089

1090 1091 1092
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1093

1094 1095 1096 1097 1098 1099 1100 1101 1102
	/*
	 * optional auxiliary devices such as amplifiers or codecs with DAI
	 * link unused
	 */
	struct snd_soc_aux_dev *aux_dev;
	int num_aux_devs;
	struct snd_soc_pcm_runtime *rtd_aux;
	int num_aux_rtd;

1103 1104 1105
	const struct snd_kcontrol_new *controls;
	int num_controls;

1106 1107
	/*
	 * Card-specific routes and widgets.
1108
	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1109
	 */
1110
	const struct snd_soc_dapm_widget *dapm_widgets;
1111
	int num_dapm_widgets;
1112
	const struct snd_soc_dapm_route *dapm_routes;
1113
	int num_dapm_routes;
1114 1115 1116 1117
	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;
1118
	bool fully_routed;
1119

1120
	struct work_struct deferred_resume_work;
1121 1122 1123

	/* lists of probed devices belonging to this card */
	struct list_head codec_dev_list;
1124

1125
	struct list_head widgets;
1126
	struct list_head paths;
1127
	struct list_head dapm_list;
1128
	struct list_head dapm_dirty;
1129

1130 1131 1132
	/* attached dynamic objects */
	struct list_head dobj_list;

M
Mark Brown 已提交
1133 1134
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1135
	struct snd_soc_dapm_stats dapm_stats;
1136
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1137

1138 1139
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1140
	struct dentry *debugfs_pop_time;
1141
#endif
1142
	u32 pop_time;
M
Mark Brown 已提交
1143 1144

	void *drvdata;
1145 1146
};

1147
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1148
struct snd_soc_pcm_runtime {
1149
	struct device *dev;
1150
	struct snd_soc_card *card;
1151
	struct snd_soc_dai_link *dai_link;
L
Liam Girdwood 已提交
1152 1153 1154
	struct mutex pcm_mutex;
	enum snd_soc_pcm_subclass pcm_subclass;
	struct snd_pcm_ops ops;
1155 1156

	unsigned int dev_registered:1;
1157

1158 1159
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];
1160
	int fe_compr;
1161

1162
	long pmdown_time;
1163
	unsigned char pop_wait:1;
1164 1165 1166

	/* runtime devices */
	struct snd_pcm *pcm;
1167
	struct snd_compr *compr;
1168 1169 1170 1171
	struct snd_soc_codec *codec;
	struct snd_soc_platform *platform;
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;
1172
	struct snd_soc_component *component; /* Only valid for AUX dev rtds */
1173

1174 1175 1176
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1177
	struct delayed_work delayed_work;
1178 1179 1180 1181
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
	struct dentry *debugfs_dpcm_state;
#endif
1182 1183
};

1184 1185
/* mixer control */
struct soc_mixer_control {
1186
	int min, max, platform_max;
1187 1188
	int reg, rreg;
	unsigned int shift, rshift;
1189
	unsigned int sign_bit;
1190 1191
	unsigned int invert:1;
	unsigned int autodisable:1;
1192
	struct snd_soc_dobj dobj;
1193 1194
};

1195 1196 1197
struct soc_bytes {
	int base;
	int num_regs;
1198
	u32 mask;
1199 1200
};

V
Vinod Koul 已提交
1201 1202
struct soc_bytes_ext {
	int max;
1203 1204
	struct snd_soc_dobj dobj;

1205 1206 1207
	/* used for TLV byte control */
	int (*get)(unsigned int __user *bytes, unsigned int size);
	int (*put)(const unsigned int __user *bytes, unsigned int size);
V
Vinod Koul 已提交
1208 1209
};

1210 1211 1212 1213 1214 1215
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1216 1217
/* enumerated kcontrol */
struct soc_enum {
1218
	int reg;
P
Peter Ujfalusi 已提交
1219 1220
	unsigned char shift_l;
	unsigned char shift_r;
1221
	unsigned int items;
P
Peter Ujfalusi 已提交
1222
	unsigned int mask;
1223
	const char * const *texts;
P
Peter Ujfalusi 已提交
1224
	const unsigned int *values;
1225
	unsigned int autodisable:1;
1226
	struct snd_soc_dobj dobj;
P
Peter Ujfalusi 已提交
1227 1228
};

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
/**
 * 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);
}

1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
/**
 * 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);
}

1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
/**
 * 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);
}

1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
/**
 * 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)
{
	return container_of(dapm, struct snd_soc_codec, dapm);
}

/**
 * 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)
{
1294
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1295 1296
}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
/**
 * 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)
{
	return component->dapm_ptr;
}

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
/**
 * 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)
{
	return &codec->dapm;
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
/**
 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
 * @dapm: The CODEC for which to initialize the DAPM bias level
 * @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);
}

1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
/**
 * 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));
}

1373
/* codec IO */
1374
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1375 1376
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1377

1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
/**
 * 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);
}

1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
/* 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);

1402 1403
#ifdef CONFIG_REGMAP

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
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);
}

1439 1440
#endif

1441 1442
/* device driver data */

M
Mark Brown 已提交
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
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;
}

1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
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);
}

1465
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1466
		void *data)
1467
{
1468
	snd_soc_component_set_drvdata(&codec->component, data);
1469 1470 1471 1472
}

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1473
	return snd_soc_component_get_drvdata(&codec->component);
1474 1475 1476 1477 1478
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1479
	snd_soc_component_set_drvdata(&platform->component, data);
1480 1481 1482 1483
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1484
	return snd_soc_component_get_drvdata(&platform->component);
1485 1486 1487 1488 1489
}

static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
		void *data)
{
1490
	dev_set_drvdata(rtd->dev, data);
1491 1492 1493 1494
}

static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
{
1495
	return dev_get_drvdata(rtd->dev);
1496 1497
}

1498 1499 1500 1501 1502 1503 1504 1505
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);
}

1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
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;
}

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

1542 1543 1544 1545 1546 1547
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1548 1549
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1550
	return snd_soc_component_is_active(&codec->component);
1551 1552
}

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
/**
 * 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);
}

1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
/**
 * 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)
{
1580
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1581 1582
}

1583
/**
1584
 * snd_soc_kcontrol_platform() - Returns the platform that registered the control
1585 1586 1587 1588 1589 1590
 * @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.
 */
1591
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1592 1593
	struct snd_kcontrol *kcontrol)
{
1594
	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1595 1596
}

1597 1598 1599
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1600 1601
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname);
1602 1603
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname);
1604 1605 1606
int snd_soc_of_parse_tdm_slot(struct device_node *np,
			      unsigned int *slots,
			      unsigned int *slot_width);
1607 1608
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
				   const char *propname);
1609
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1610 1611 1612
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1613 1614
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1615 1616 1617
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1618

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

1621
#ifdef CONFIG_DEBUG_FS
1622
extern struct dentry *snd_soc_debugfs_root;
1623 1624
#endif

1625 1626
extern const struct dev_pm_ops snd_soc_pm_ops;

1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
/* Helper functions */
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
	mutex_lock(&dapm->card->dapm_mutex);
}

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

1638
#endif