soc.h 50.9 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 30 31 32 33
#include <sound/control.h>
#include <sound/ac97_codec.h>

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

257 258 259 260 261 262
#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 }) }
263

264 265 266 267 268 269 270 271
#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 已提交
272 273 274 275 276 277
#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} }
278 279 280 281 282
#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), \
283
	.info = snd_soc_bytes_info_ext, \
284 285
	.private_value = (unsigned long)&(struct soc_bytes_ext) \
		{.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
286 287 288 289 290 291 292 293 294
#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} }

295 296 297 298
#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
		snd_soc_get_strobe, snd_soc_put_strobe)

299 300 301 302 303
/*
 * 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) \
304
	const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
305 306 307 308
						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) \
309
	const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
310
#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
311
	const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
312 313 314
							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)
315 316
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
317

318 319 320 321 322 323 324 325 326 327
/*
 * 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

328 329 330 331 332 333 334 335 336 337 338 339
/*
 * 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 {
340 341 342 343
	SND_SOC_BIAS_OFF = 0,
	SND_SOC_BIAS_STANDBY = 1,
	SND_SOC_BIAS_PREPARE = 2,
	SND_SOC_BIAS_ON = 3,
344 345
};

346
struct device_node;
M
Mark Brown 已提交
347 348
struct snd_jack;
struct snd_soc_card;
349 350 351
struct snd_soc_pcm_stream;
struct snd_soc_ops;
struct snd_soc_pcm_runtime;
352
struct snd_soc_dai;
353
struct snd_soc_dai_driver;
M
Mark Brown 已提交
354
struct snd_soc_platform;
355
struct snd_soc_dai_link;
356
struct snd_soc_platform_driver;
357
struct snd_soc_codec;
358
struct snd_soc_codec_driver;
359 360
struct snd_soc_component;
struct snd_soc_component_driver;
361
struct soc_enum;
M
Mark Brown 已提交
362
struct snd_soc_jack;
363
struct snd_soc_jack_zone;
M
Mark Brown 已提交
364
struct snd_soc_jack_pin;
L
Liam Girdwood 已提交
365
#include <sound/soc-dapm.h>
366
#include <sound/soc-dpcm.h>
367

368
struct snd_soc_jack_gpio;
369 370 371

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

L
Liam Girdwood 已提交
372 373 374 375 376
enum snd_soc_pcm_subclass {
	SND_SOC_PCM_CLASS_PCM	= 0,
	SND_SOC_PCM_CLASS_BE	= 1,
};

377
enum snd_soc_card_subclass {
378 379
	SND_SOC_CARD_CLASS_INIT		= 0,
	SND_SOC_CARD_CLASS_RUNTIME	= 1,
380 381
};

382
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
383
			     int source, unsigned int freq, int dir);
384 385 386
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
			  unsigned int freq_in, unsigned int freq_out);

387 388
int snd_soc_register_card(struct snd_soc_card *card);
int snd_soc_unregister_card(struct snd_soc_card *card);
389
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
390 391 392
int snd_soc_suspend(struct device *dev);
int snd_soc_resume(struct device *dev);
int snd_soc_poweroff(struct device *dev);
393
int snd_soc_register_platform(struct device *dev,
394
		const struct snd_soc_platform_driver *platform_drv);
395 396
int devm_snd_soc_register_platform(struct device *dev,
		const struct snd_soc_platform_driver *platform_drv);
397
void snd_soc_unregister_platform(struct device *dev);
398 399 400 401
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);
402
int snd_soc_register_codec(struct device *dev,
403
		const struct snd_soc_codec_driver *codec_drv,
404 405
		struct snd_soc_dai_driver *dai_drv, int num_dai);
void snd_soc_unregister_codec(struct device *dev);
406 407 408
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);
409 410 411
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);
412
void snd_soc_unregister_component(struct device *dev);
413 414
int snd_soc_cache_init(struct snd_soc_codec *codec);
int snd_soc_cache_exit(struct snd_soc_codec *codec);
415

416 417 418 419
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 已提交
420
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
421
int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
M
Mark Brown 已提交
422

423 424 425 426 427
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);

428
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
429 430
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);
431

432 433 434
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

435 436 437
/* 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);
438
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
439 440
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

441 442 443 444
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

445 446 447
int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
		int cmd, struct snd_soc_platform *platform);

448 449 450 451
int soc_dai_hw_params(struct snd_pcm_substream *substream,
		      struct snd_pcm_hw_params *params,
		      struct snd_soc_dai *dai);

M
Mark Brown 已提交
452
/* Jack reporting */
453
int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
M
Mark Brown 已提交
454 455 456 457
		     struct snd_soc_jack *jack);
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);
458 459 460 461
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);
462 463 464
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);
465 466 467
#ifdef CONFIG_GPIOLIB
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
468 469 470
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
			    struct snd_soc_jack *jack,
			    int count, struct snd_soc_jack_gpio *gpios);
471 472
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
473 474 475 476 477 478 479
#else
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
					 struct snd_soc_jack_gpio *gpios)
{
	return 0;
}

480 481 482 483
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)
484 485 486 487
{
	return 0;
}

488 489 490 491
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
492
#endif
M
Mark Brown 已提交
493

494
/* codec register bit access */
495
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
496
				unsigned int mask, unsigned int value);
497
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
498
			       unsigned int reg, unsigned int mask,
499
			       unsigned int value);
500
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
501
				unsigned int mask, unsigned int value);
502

503
#ifdef CONFIG_SND_SOC_AC97_BUS
504
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
505 506
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec);
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
507

508
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
509 510
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
511

512 513 514 515 516 517 518 519 520 521 522 523 524 525
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

526 527 528 529
/*
 *Controls
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
530
				  void *data, const char *long_name,
531
				  const char *prefix);
532 533
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
					       const char *name);
534 535
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
536
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
537
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
538
int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
539
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
540 541 542 543
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);
544 545 546 547 548 549 550 551
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);
552
#define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
553 554 555 556
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);
557 558
#define snd_soc_get_volsw_2r snd_soc_get_volsw
#define snd_soc_put_volsw_2r snd_soc_put_volsw
559 560 561 562
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);
563 564 565 566 567 568
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);
569 570
int snd_soc_limit_volume(struct snd_soc_codec *codec,
	const char *name, int max);
571 572 573 574 575 576
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 已提交
577 578
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *ucontrol);
579 580
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
	unsigned int size, unsigned int __user *tlv);
581 582 583 584 585 586
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);
587 588 589 590
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);
591

M
Mark Brown 已提交
592 593 594 595 596 597 598 599 600 601 602 603 604 605
/**
 * 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;
};

606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
/**
 * 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;
};

624 625 626
/**
 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 *
627
 * @gpio:         legacy gpio number
628 629
 * @idx:          gpio descriptor index within the function of the GPIO
 *                consumer device
630
 * @gpiod_dev     GPIO consumer device
631 632
 * @name:         gpio name. Also as connection ID for the GPIO consumer
 *                device function name lookup
633 634 635
 * @report:       value to report when jack detected
 * @invert:       report presence in low state
 * @debouce_time: debouce time in ms
636
 * @wake:	  enable as wake source
637 638 639
 * @jack_status_check: callback function which overrides the detection
 *		       to provide more complex checks (eg, reading an
 *		       ADC).
640 641 642
 */
struct snd_soc_jack_gpio {
	unsigned int gpio;
643 644
	unsigned int idx;
	struct device *gpiod_dev;
645 646 647 648
	const char *name;
	int report;
	int invert;
	int debounce_time;
649 650
	bool wake;

651
	struct snd_soc_jack *jack;
652
	struct delayed_work work;
653
	struct gpio_desc *desc;
654

655 656
	void *data;
	int (*jack_status_check)(void *data);
657 658
};

M
Mark Brown 已提交
659
struct snd_soc_jack {
660
	struct mutex mutex;
M
Mark Brown 已提交
661
	struct snd_jack *jack;
662
	struct snd_soc_codec *codec;
M
Mark Brown 已提交
663 664
	struct list_head pins;
	int status;
665
	struct blocking_notifier_head notifier;
666
	struct list_head jack_zones;
M
Mark Brown 已提交
667 668
};

669 670
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
671
	const char *stream_name;
G
Graeme Gregory 已提交
672 673
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
674 675 676 677
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
678
	unsigned int sig_bits;		/* number of bits of content */
679 680 681 682 683 684 685 686 687 688 689 690
};

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

691 692 693 694 695 696 697
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 *);
};

698 699 700
/* component interface */
struct snd_soc_component_driver {
	const char *name;
701

702 703 704 705 706 707 708 709 710 711 712
	/* 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 *);

713 714 715 716
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
717 718 719
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
720 721 722 723

	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
724 725 726 727 728
};

struct snd_soc_component {
	const char *name;
	int id;
729
	const char *name_prefix;
730
	struct device *dev;
731
	struct snd_soc_card *card;
732 733 734

	unsigned int active;

735
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
736
	unsigned int registered_as_component:1;
737
	unsigned int probed:1;
738

739 740
	struct list_head list;

741 742 743
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

744
	const struct snd_soc_component_driver *driver;
745 746

	struct list_head dai_list;
747 748 749 750 751 752 753 754

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

756 757 758 759 760 761 762 763 764 765
#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.
	*/

766 767 768
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
	struct snd_soc_dapm_context *dapm_ptr;
769

770 771 772 773 774 775 776 777 778 779 780
	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 *);

781 782 783 784
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
785 786
};

787
/* SoC Audio Codec device */
788
struct snd_soc_codec {
M
Mark Brown 已提交
789
	struct device *dev;
790
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
791 792

	struct list_head list;
793
	struct list_head card_list;
794 795

	/* runtime */
796
	unsigned int cache_bypass:1; /* Suppress access to the cache */
797
	unsigned int suspended:1; /* Codec is in suspend PM state */
798
	unsigned int cache_init:1; /* codec cache has been initialized */
799 800 801 802 803

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

805 806 807
	/* component */
	struct snd_soc_component component;

808
	/* dapm */
L
Liam Girdwood 已提交
809
	struct snd_soc_dapm_context dapm;
810

811 812 813
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_reg;
#endif
814 815
};

816 817 818 819 820 821
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
822
	int (*suspend)(struct snd_soc_codec *);
823
	int (*resume)(struct snd_soc_codec *);
824
	struct snd_soc_component_driver component_driver;
825

826 827 828
	/* Default control and setup, added after probe() is run */
	const struct snd_kcontrol_new *controls;
	int num_controls;
829 830 831 832 833
	const struct snd_soc_dapm_widget *dapm_widgets;
	int num_dapm_widgets;
	const struct snd_soc_dapm_route *dapm_routes;
	int num_dapm_routes;

834 835
	/* codec wide operations */
	int (*set_sysclk)(struct snd_soc_codec *codec,
836
			  int clk_id, int source, unsigned int freq, int dir);
837 838 839
	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
		unsigned int freq_in, unsigned int freq_out);

840
	/* codec IO */
841
	struct regmap *(*get_regmap)(struct device *);
842 843
	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
844
	unsigned int reg_cache_size;
845 846 847 848 849 850 851
	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);
852
	bool idle_bias_off;
853
	bool suspend_bias_off;
854 855

	void (*seq_notifier)(struct snd_soc_dapm_context *,
856
			     enum snd_soc_dapm_type, int);
857

858
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
859 860 861
};

/* SoC platform interface */
862
struct snd_soc_platform_driver {
863

864 865
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
866
	struct snd_soc_component_driver component_driver;
867 868

	/* pcm creation and destruction */
869
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
870 871
	void (*pcm_free)(struct snd_pcm *);

872 873 874 875 876 877 878
	/*
	 * For platform caused delay reporting.
	 * Optional.
	 */
	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
		struct snd_soc_dai *);

879
	/* platform stream pcm ops */
880
	const struct snd_pcm_ops *ops;
881

882
	/* platform stream compress ops */
883
	const struct snd_compr_ops *compr_ops;
884

885
	int (*bespoke_trigger)(struct snd_pcm_substream *, int);
886 887
};

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
struct snd_soc_platform {
	struct device *dev;
896
	const struct snd_soc_platform_driver *driver;
897

898
	struct list_head list;
899

900
	struct snd_soc_component component;
901
};
902

903 904 905 906
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
907 908 909 910 911 912 913 914
	/*
	 * 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;
915
	struct device_node *cpu_of_node;
916 917 918 919 920
	/*
	 * 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.
	 */
921
	const char *cpu_dai_name;
922 923 924 925 926
	/*
	 * You MUST specify the link's codec, either by device name, or by
	 * DT/OF node, but not both.
	 */
	const char *codec_name;
927
	struct device_node *codec_of_node;
928
	/* You MUST specify the DAI name within the codec */
929
	const char *codec_dai_name;
930 931 932 933

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

934 935 936 937 938 939
	/*
	 * 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;
940
	struct device_node *platform_of_node;
941
	int be_id;	/* optional ID for machine driver BE identification */
942

943 944
	const struct snd_soc_pcm_stream *params;

945 946
	unsigned int dai_fmt;           /* format to set on init */

947 948
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

949 950 951
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

952 953
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
954 955
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
956

957 958 959 960 961 962
	/* 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;

963 964 965 966
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

967 968 969
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;

970 971
	/* codec/machine specific init - e.g. add machine controls */
	int (*init)(struct snd_soc_pcm_runtime *rtd);
972

973 974 975 976
	/* 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);

977
	/* machine stream operations */
978 979
	const struct snd_soc_ops *ops;
	const struct snd_soc_compr_ops *compr_ops;
980 981 982 983

	/* For unidirectional dai links */
	bool playback_only;
	bool capture_only;
984 985
};

986
struct snd_soc_codec_conf {
987 988 989 990
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
991
	const char *dev_name;
992
	struct device_node *of_node;
993 994 995 996 997

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
998 999 1000
	const char *name_prefix;
};

1001 1002
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1003 1004 1005 1006 1007 1008

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

	/* codec/machine specific init - e.g. add machine controls */
1012
	int (*init)(struct snd_soc_component *component);
1013 1014
};

1015 1016
/* SoC card */
struct snd_soc_card {
1017
	const char *name;
1018 1019
	const char *long_name;
	const char *driver_name;
M
Mark Brown 已提交
1020
	struct device *dev;
1021 1022
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1023

1024
	struct mutex mutex;
1025
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1026

1027
	bool instantiated;
1028

1029
	int (*probe)(struct snd_soc_card *card);
1030
	int (*late_probe)(struct snd_soc_card *card);
1031
	int (*remove)(struct snd_soc_card *card);
1032 1033 1034

	/* 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. */
1035 1036 1037 1038
	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);
1039

1040
	/* callbacks */
1041
	int (*set_bias_level)(struct snd_soc_card *,
1042
			      struct snd_soc_dapm_context *dapm,
1043
			      enum snd_soc_bias_level level);
1044
	int (*set_bias_level_post)(struct snd_soc_card *,
1045
				   struct snd_soc_dapm_context *dapm,
1046
				   enum snd_soc_bias_level level);
1047

M
Mark Brown 已提交
1048
	long pmdown_time;
1049

1050 1051 1052
	/* CPU <--> Codec DAI links  */
	struct snd_soc_dai_link *dai_link;
	int num_links;
1053 1054
	struct snd_soc_pcm_runtime *rtd;
	int num_rtd;
1055

1056 1057 1058
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1059

1060 1061 1062 1063 1064 1065 1066 1067 1068
	/*
	 * 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;

1069 1070 1071
	const struct snd_kcontrol_new *controls;
	int num_controls;

1072 1073 1074
	/*
	 * Card-specific routes and widgets.
	 */
1075
	const struct snd_soc_dapm_widget *dapm_widgets;
1076
	int num_dapm_widgets;
1077
	const struct snd_soc_dapm_route *dapm_routes;
1078
	int num_dapm_routes;
1079
	bool fully_routed;
1080

1081
	struct work_struct deferred_resume_work;
1082 1083 1084

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

1086
	struct list_head widgets;
1087
	struct list_head paths;
1088
	struct list_head dapm_list;
1089
	struct list_head dapm_dirty;
1090

M
Mark Brown 已提交
1091 1092
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1093
	struct snd_soc_dapm_stats dapm_stats;
1094
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1095

1096 1097
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1098
	struct dentry *debugfs_pop_time;
1099
#endif
1100
	u32 pop_time;
M
Mark Brown 已提交
1101 1102

	void *drvdata;
1103 1104
};

1105
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1106
struct snd_soc_pcm_runtime {
1107
	struct device *dev;
1108
	struct snd_soc_card *card;
1109
	struct snd_soc_dai_link *dai_link;
L
Liam Girdwood 已提交
1110 1111 1112
	struct mutex pcm_mutex;
	enum snd_soc_pcm_subclass pcm_subclass;
	struct snd_pcm_ops ops;
1113 1114

	unsigned int dev_registered:1;
1115

1116 1117
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];
1118
	int fe_compr;
1119

1120
	long pmdown_time;
1121
	unsigned char pop_wait:1;
1122 1123 1124

	/* runtime devices */
	struct snd_pcm *pcm;
1125
	struct snd_compr *compr;
1126 1127 1128 1129
	struct snd_soc_codec *codec;
	struct snd_soc_platform *platform;
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;
1130
	struct snd_soc_component *component; /* Only valid for AUX dev rtds */
1131

1132 1133 1134
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1135
	struct delayed_work delayed_work;
1136 1137 1138 1139
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
	struct dentry *debugfs_dpcm_state;
#endif
1140 1141
};

1142 1143
/* mixer control */
struct soc_mixer_control {
1144
	int min, max, platform_max;
1145 1146
	int reg, rreg;
	unsigned int shift, rshift;
1147
	unsigned int sign_bit;
1148 1149
	unsigned int invert:1;
	unsigned int autodisable:1;
1150 1151
};

1152 1153 1154
struct soc_bytes {
	int base;
	int num_regs;
1155
	u32 mask;
1156 1157
};

V
Vinod Koul 已提交
1158 1159
struct soc_bytes_ext {
	int max;
1160 1161 1162
	/* 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 已提交
1163 1164
};

1165 1166 1167 1168 1169 1170
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1171 1172
/* enumerated kcontrol */
struct soc_enum {
1173
	int reg;
P
Peter Ujfalusi 已提交
1174 1175
	unsigned char shift_l;
	unsigned char shift_r;
1176
	unsigned int items;
P
Peter Ujfalusi 已提交
1177
	unsigned int mask;
1178
	const char * const *texts;
P
Peter Ujfalusi 已提交
1179 1180 1181
	const unsigned int *values;
};

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
/**
 * 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);
}

1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
/**
 * 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);
}

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
/**
 * 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);
}

1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
/**
 * 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)
{
1247
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1248 1249
}

1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
/**
 * 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;
}

1261
/* codec IO */
1262
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1263 1264
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1265

1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
/**
 * 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);
}

1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
/* 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);

1290 1291
#ifdef CONFIG_REGMAP

1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
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);
}

1327 1328
#endif

1329 1330
/* device driver data */

M
Mark Brown 已提交
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
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;
}

1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
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);
}

1353
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1354
		void *data)
1355
{
1356
	snd_soc_component_set_drvdata(&codec->component, data);
1357 1358 1359 1360
}

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1361
	return snd_soc_component_get_drvdata(&codec->component);
1362 1363 1364 1365 1366
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1367
	snd_soc_component_set_drvdata(&platform->component, data);
1368 1369 1370 1371
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1372
	return snd_soc_component_get_drvdata(&platform->component);
1373 1374 1375 1376 1377
}

static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
		void *data)
{
1378
	dev_set_drvdata(rtd->dev, data);
1379 1380 1381 1382
}

static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
{
1383
	return dev_get_drvdata(rtd->dev);
1384 1385
}

1386 1387 1388 1389 1390 1391 1392 1393
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);
}

1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
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;
}

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
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];
}

1430 1431 1432 1433 1434 1435
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1436 1437
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1438
	return snd_soc_component_is_active(&codec->component);
1439 1440
}

1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
/**
 * 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);
}

1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
/**
 * 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)
{
1468
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1469 1470
}

1471 1472 1473 1474 1475 1476 1477 1478
/**
 * snd_soc_kcontrol_platform() - Returns the platform that registerd the control
 * @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.
 */
1479
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1480 1481
	struct snd_kcontrol *kcontrol)
{
1482
	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1483 1484
}

1485 1486 1487
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1488 1489
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname);
1490 1491
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname);
1492 1493 1494
int snd_soc_of_parse_tdm_slot(struct device_node *np,
			      unsigned int *slots,
			      unsigned int *slot_width);
1495 1496
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
				   const char *propname);
1497
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1498 1499 1500
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1501 1502
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1503 1504 1505
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1506

1507 1508
#include <sound/soc-dai.h>

1509
#ifdef CONFIG_DEBUG_FS
1510
extern struct dentry *snd_soc_debugfs_root;
1511 1512
#endif

1513 1514
extern const struct dev_pm_ops snd_soc_pm_ops;

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
/* 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);
}

1526
#endif