soc.h 58.8 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
#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),\
88
	.info = snd_soc_info_volsw_sx, \
89 90 91 92 93 94
	.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) }
D
Damien.Horsley 已提交
112 113 114 115 116 117 118 119
#define SOC_DOUBLE_STS(xname, reg, shift_left, shift_right, max, invert) \
{									\
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),		\
	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,		\
	.access = SNDRV_CTL_ELEM_ACCESS_READ |				\
		SNDRV_CTL_ELEM_ACCESS_VOLATILE,				\
	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right,	\
					  max, invert, 0) }
120
#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
121
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
122
	.info = snd_soc_info_volsw, \
123
	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
124 125
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
126 127 128 129 130 131 132
#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) }
133
#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
P
Philipp Zabel 已提交
134 135 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), \
	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
	.put = snd_soc_put_volsw, \
140
	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
141
					  max, invert, 0) }
142
#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
P
Philipp Zabel 已提交
143 144 145 146
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
	.tlv.p = (tlv_array), \
147
	.info = snd_soc_info_volsw, \
148
	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
149 150
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
151 152 153 154 155 156 157 158 159 160
#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) }
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), \
166
	.info = snd_soc_info_volsw_sx, \
167 168 169 170 171 172
	.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} }
173 174 175 176 177 178 179 180 181
#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) }
182 183 184 185 186 187 188 189 190 191 192
#define SOC_SINGLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
{	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
	.tlv.p  = (tlv_array), \
	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
	.put = snd_soc_put_volsw, \
	.private_value = (unsigned long)&(struct soc_mixer_control) \
	{.reg = xreg, .rreg = xreg,  \
	 .min = xmin, .max = xmax, .platform_max = xmax, \
	.sign_bit = 7,} }
193
#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
194 195 196 197
{	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
	.tlv.p  = (tlv_array), \
198 199 200
	.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) }
201
#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
202
{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
203 204 205 206 207 208 209
	.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 已提交
210
{	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
211
	.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
212 213
#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
214 215 216 217
#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}
218 219
#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
	SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
220 221 222 223 224
#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 }
225
#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
226 227
	 xhandler_get, xhandler_put) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
G
Graeme Gregory 已提交
228
	.info = snd_soc_info_volsw, \
229
	.get = xhandler_get, .put = xhandler_put, \
230
	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
231
#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
D
Daniel Mack 已提交
232 233 234 235
	 xhandler_get, xhandler_put) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.info = snd_soc_info_volsw, \
	.get = xhandler_get, .put = xhandler_put, \
236
	.private_value = \
237
		SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
A
Adam Thomson 已提交
238 239 240 241 242 243 244
#define SOC_DOUBLE_R_EXT(xname, reg_left, reg_right, xshift, xmax, xinvert,\
	 xhandler_get, xhandler_put) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
	.info = snd_soc_info_volsw, \
	.get = xhandler_get, .put = xhandler_put, \
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
245
#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
246 247 248 249 250 251 252
	 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, \
253
	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
254 255 256 257 258 259 260 261 262 263 264 265
#define SOC_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
				 xhandler_get, xhandler_put, tlv_array) \
{	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
	.tlv.p = (tlv_array), \
	.info = snd_soc_info_volsw_range, \
	.get = xhandler_get, .put = xhandler_put, \
	.private_value = (unsigned long)&(struct soc_mixer_control) \
		{.reg = xreg, .rreg = xreg, .shift = xshift, \
		 .rshift = xshift, .min = xmin, .max = xmax, \
		 .platform_max = xmax, .invert = xinvert} }
266 267 268 269 270 271 272 273
#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, \
274
	.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
275
					  xmax, xinvert, 0) }
276 277 278 279 280 281
#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), \
282
	.info = snd_soc_info_volsw, \
283
	.get = xhandler_get, .put = xhandler_put, \
284 285
	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
					    xmax, xinvert) }
286 287 288 289 290 291 292
#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, \
293
	.info = snd_soc_info_enum_double, \
294 295
	.get = xhandler_get, .put = xhandler_put, \
	.private_value = (unsigned long)&xenum }
296 297
#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
	SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
298

299 300 301 302 303 304
#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 }) }
305

306 307 308 309 310 311 312 313
#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 }) }

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

340 341 342 343
#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
		snd_soc_get_strobe, snd_soc_put_strobe)

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

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

365 366
#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
367

368 369 370 371 372 373 374 375 376 377
/*
 * 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

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

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

419
struct snd_soc_jack_gpio;
420 421 422

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

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

428
enum snd_soc_card_subclass {
429 430
	SND_SOC_CARD_CLASS_INIT		= 0,
	SND_SOC_CARD_CLASS_RUNTIME	= 1,
431 432
};

433
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
434
			     int source, unsigned int freq, int dir);
435 436
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
			  unsigned int freq_in, unsigned int freq_out);
437 438
int snd_soc_codec_set_jack(struct snd_soc_codec *codec,
			   struct snd_soc_jack *jack, void *data);
439

440 441
int snd_soc_register_card(struct snd_soc_card *card);
int snd_soc_unregister_card(struct snd_soc_card *card);
442
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
443
#ifdef CONFIG_PM_SLEEP
444 445
int snd_soc_suspend(struct device *dev);
int snd_soc_resume(struct device *dev);
446 447 448 449 450 451 452 453 454 455 456
#else
static inline int snd_soc_suspend(struct device *dev)
{
	return 0;
}

static inline int snd_soc_resume(struct device *dev)
{
	return 0;
}
#endif
457
int snd_soc_poweroff(struct device *dev);
458
int snd_soc_register_platform(struct device *dev,
459
		const struct snd_soc_platform_driver *platform_drv);
460 461
int devm_snd_soc_register_platform(struct device *dev,
		const struct snd_soc_platform_driver *platform_drv);
462
void snd_soc_unregister_platform(struct device *dev);
463 464 465 466
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);
467
int snd_soc_register_codec(struct device *dev,
468
		const struct snd_soc_codec_driver *codec_drv,
469 470
		struct snd_soc_dai_driver *dai_drv, int num_dai);
void snd_soc_unregister_codec(struct device *dev);
471 472 473
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);
474 475 476
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);
477
void snd_soc_unregister_component(struct device *dev);
478 479
int snd_soc_cache_init(struct snd_soc_codec *codec);
int snd_soc_cache_exit(struct snd_soc_codec *codec);
480

481 482 483 484
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 已提交
485
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
486 487 488
#ifdef CONFIG_SND_SOC_COMPRESS
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
#endif
M
Mark Brown 已提交
489

490 491 492 493 494
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);

495
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
496 497
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);
498

499 500 501
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

502
#ifdef CONFIG_DMI
503
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
504 505 506 507 508 509 510
#else
static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
				       const char *flavour)
{
	return 0;
}
#endif
511

512 513 514
/* 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);
515
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
516 517
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

518 519 520 521
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

522 523 524 525
int soc_dai_hw_params(struct snd_pcm_substream *substream,
		      struct snd_pcm_hw_params *params,
		      struct snd_soc_dai *dai);

M
Mark Brown 已提交
526
/* Jack reporting */
527 528 529 530
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 已提交
531 532 533
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);
534 535 536 537
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);
538 539 540
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);
541 542 543
#ifdef CONFIG_GPIOLIB
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
544 545 546
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
			    struct snd_soc_jack *jack,
			    int count, struct snd_soc_jack_gpio *gpios);
547 548
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
549 550 551 552 553 554 555
#else
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
					 struct snd_soc_jack_gpio *gpios)
{
	return 0;
}

556 557 558 559
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)
560 561 562 563
{
	return 0;
}

564 565 566 567
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
568
#endif
M
Mark Brown 已提交
569

570
/* codec register bit access */
571
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
572
				unsigned int mask, unsigned int value);
573
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
574
			       unsigned int reg, unsigned int mask,
575
			       unsigned int value);
576
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
577
				unsigned int mask, unsigned int value);
578

579
#ifdef CONFIG_SND_SOC_AC97_BUS
580
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
581 582
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
	unsigned int id, unsigned int id_mask);
583
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
584

585
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
586 587
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
588

589 590 591 592 593 594 595 596 597 598 599 600 601 602
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

603 604 605 606
/*
 *Controls
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
607
				  void *data, const char *long_name,
608
				  const char *prefix);
609 610
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
					       const char *name);
611 612
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
613
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
614
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
615
int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
616
	const struct snd_kcontrol_new *controls, unsigned int num_controls);
617 618 619 620
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);
621 622 623 624 625 626 627 628
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);
629 630
int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
			  struct snd_ctl_elem_info *uinfo);
631
#define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
632 633 634 635
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);
636 637
#define snd_soc_get_volsw_2r snd_soc_get_volsw
#define snd_soc_put_volsw_2r snd_soc_put_volsw
638 639 640 641
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);
642 643 644 645 646 647
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);
648
int snd_soc_limit_volume(struct snd_soc_card *card,
649
	const char *name, int max);
650 651 652 653 654 655
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 已提交
656 657
int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *ucontrol);
658 659
int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
	unsigned int size, unsigned int __user *tlv);
660 661 662 663 664 665
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);
666 667 668 669
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);
670

M
Mark Brown 已提交
671 672 673 674 675 676
/**
 * 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
677
 * @list:   internal list entry
M
Mark Brown 已提交
678 679 680 681 682 683 684 685
 */
struct snd_soc_jack_pin {
	struct list_head list;
	const char *pin;
	int mask;
	bool invert;
};

686 687 688 689 690 691 692 693
/**
 * 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
694
 * @list:   internal list entry
695 696 697 698 699 700 701 702 703
 */
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;
};

704 705 706
/**
 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
 *
707
 * @gpio:         legacy gpio number
708 709
 * @idx:          gpio descriptor index within the function of the GPIO
 *                consumer device
710
 * @gpiod_dev:    GPIO consumer device
711 712
 * @name:         gpio name. Also as connection ID for the GPIO consumer
 *                device function name lookup
713 714
 * @report:       value to report when jack detected
 * @invert:       report presence in low state
715
 * @debounce_time: debounce time in ms
716
 * @wake:	  enable as wake source
717 718 719
 * @jack_status_check: callback function which overrides the detection
 *		       to provide more complex checks (eg, reading an
 *		       ADC).
720 721 722
 */
struct snd_soc_jack_gpio {
	unsigned int gpio;
723 724
	unsigned int idx;
	struct device *gpiod_dev;
725 726 727 728
	const char *name;
	int report;
	int invert;
	int debounce_time;
729 730
	bool wake;

731
	/* private: */
732
	struct snd_soc_jack *jack;
733
	struct delayed_work work;
734
	struct notifier_block pm_notifier;
735
	struct gpio_desc *desc;
736

737
	void *data;
738
	/* public: */
739
	int (*jack_status_check)(void *data);
740 741
};

M
Mark Brown 已提交
742
struct snd_soc_jack {
743
	struct mutex mutex;
M
Mark Brown 已提交
744
	struct snd_jack *jack;
745
	struct snd_soc_card *card;
M
Mark Brown 已提交
746 747
	struct list_head pins;
	int status;
748
	struct blocking_notifier_head notifier;
749
	struct list_head jack_zones;
M
Mark Brown 已提交
750 751
};

752 753
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
754
	const char *stream_name;
G
Graeme Gregory 已提交
755 756
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
757 758 759 760
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
761
	unsigned int sig_bits;		/* number of bits of content */
762 763 764 765 766 767 768 769 770 771 772 773
};

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

774 775 776 777 778 779 780
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 *);
};

781 782 783
/* component interface */
struct snd_soc_component_driver {
	const char *name;
784

785 786 787 788 789 790 791 792 793 794
	/* 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 *);
795 796
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
797

798 799 800 801
	/* pcm creation and destruction */
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_pcm *);

802 803 804 805
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
806 807
	int (*of_xlate_dai_id)(struct snd_soc_component *comment,
			       struct device_node *endpoint);
808 809 810
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
811 812 813 814

	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
815 816 817 818 819
};

struct snd_soc_component {
	const char *name;
	int id;
820
	const char *name_prefix;
821
	struct device *dev;
822
	struct snd_soc_card *card;
823 824 825

	unsigned int active;

826
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
827
	unsigned int registered_as_component:1;
828
	unsigned int suspended:1; /* is in suspend PM state */
829

830
	struct list_head list;
831
	struct list_head card_aux_list; /* for auxiliary bound components */
832
	struct list_head card_list;
833

834 835 836
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

837
	const struct snd_soc_component_driver *driver;
838 839

	struct list_head dai_list;
840 841 842 843 844 845 846 847

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

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

852 853 854 855 856 857 858 859 860 861
#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.
	*/

862 863
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
864

865 866 867 868 869 870 871 872 873 874
	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 *);
875 876
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
877 878
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_pcm *);
879

880 881 882
	/* machine specific init */
	int (*init)(struct snd_soc_component *component);

883 884 885 886
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
887 888
};

889
/* SoC Audio Codec device */
890
struct snd_soc_codec {
M
Mark Brown 已提交
891
	struct device *dev;
892
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
893 894

	struct list_head list;
895 896

	/* runtime */
897
	unsigned int cache_bypass:1; /* Suppress access to the cache */
898
	unsigned int cache_init:1; /* codec cache has been initialized */
899 900 901 902 903

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

905 906 907
	/* component */
	struct snd_soc_component component;

908 909 910
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_reg;
#endif
911 912
};

913 914 915 916 917 918
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
919
	int (*suspend)(struct snd_soc_codec *);
920
	int (*resume)(struct snd_soc_codec *);
921
	struct snd_soc_component_driver component_driver;
922

923 924
	/* codec wide operations */
	int (*set_sysclk)(struct snd_soc_codec *codec,
925
			  int clk_id, int source, unsigned int freq, int dir);
926 927
	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
		unsigned int freq_in, unsigned int freq_out);
928 929
	int (*set_jack)(struct snd_soc_codec *codec,
			struct snd_soc_jack *jack,  void *data);
930

931
	/* codec IO */
932
	struct regmap *(*get_regmap)(struct device *);
933 934
	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
935
	unsigned int reg_cache_size;
936 937 938 939 940 941 942
	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);
943
	bool idle_bias_off;
944
	bool suspend_bias_off;
945 946

	void (*seq_notifier)(struct snd_soc_dapm_context *,
947
			     enum snd_soc_dapm_type, int);
948

949
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
950 951 952
};

/* SoC platform interface */
953
struct snd_soc_platform_driver {
954

955 956
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
957
	struct snd_soc_component_driver component_driver;
958 959

	/* pcm creation and destruction */
960
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
961 962
	void (*pcm_free)(struct snd_pcm *);

963
	/* platform stream pcm ops */
964
	const struct snd_pcm_ops *ops;
965

966
	/* platform stream compress ops */
967
	const struct snd_compr_ops *compr_ops;
968 969
};

970 971
struct snd_soc_dai_link_component {
	const char *name;
972
	struct device_node *of_node;
973 974 975
	const char *dai_name;
};

976 977
struct snd_soc_platform {
	struct device *dev;
978
	const struct snd_soc_platform_driver *driver;
979

980
	struct list_head list;
981

982
	struct snd_soc_component component;
983
};
984

985 986 987 988
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
989 990 991 992 993 994 995 996
	/*
	 * 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;
997
	struct device_node *cpu_of_node;
998 999 1000 1001 1002
	/*
	 * 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.
	 */
1003
	const char *cpu_dai_name;
1004 1005 1006 1007 1008
	/*
	 * You MUST specify the link's 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
	/* You MUST specify the DAI name within the codec */
1011
	const char *codec_dai_name;
1012 1013 1014 1015

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

1016 1017 1018 1019 1020 1021
	/*
	 * 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;
1022
	struct device_node *platform_of_node;
1023
	int id;	/* optional ID for machine driver link identification */
1024

1025
	const struct snd_soc_pcm_stream *params;
1026
	unsigned int num_params;
1027

1028 1029
	unsigned int dai_fmt;           /* format to set on init */

1030 1031
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
	/* codec/machine specific init - e.g. add machine controls */
	int (*init)(struct snd_soc_pcm_runtime *rtd);

	/* optional hw_params re-writing for BE and FE sync */
	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
			struct snd_pcm_hw_params *params);

	/* machine stream operations */
	const struct snd_soc_ops *ops;
	const struct snd_soc_compr_ops *compr_ops;

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

1046 1047 1048 1049
	/* For unidirectional dai links */
	unsigned int playback_only:1;
	unsigned int capture_only:1;

1050 1051 1052
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

1053 1054
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
1055 1056
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
1057

1058 1059 1060 1061 1062 1063
	/* 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;

1064 1065 1066 1067
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

1068 1069 1070
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;

1071 1072
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
1073 1074 1075

	struct list_head list; /* DAI link list of the soc card */
	struct snd_soc_dobj dobj; /* For topology */
1076 1077
};

1078
struct snd_soc_codec_conf {
1079 1080 1081 1082
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
1083
	const char *dev_name;
1084
	struct device_node *of_node;
1085 1086 1087 1088 1089

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1090 1091 1092
	const char *name_prefix;
};

1093 1094
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1095 1096 1097 1098 1099 1100

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

	/* codec/machine specific init - e.g. add machine controls */
1104
	int (*init)(struct snd_soc_component *component);
1105 1106
};

1107 1108
/* SoC card */
struct snd_soc_card {
1109
	const char *name;
1110 1111
	const char *long_name;
	const char *driver_name;
1112 1113
	char dmi_longname[80];

M
Mark Brown 已提交
1114
	struct device *dev;
1115 1116
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1117

1118
	struct mutex mutex;
1119
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1120

1121
	bool instantiated;
1122

1123
	int (*probe)(struct snd_soc_card *card);
1124
	int (*late_probe)(struct snd_soc_card *card);
1125
	int (*remove)(struct snd_soc_card *card);
1126 1127 1128

	/* 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. */
1129 1130 1131 1132
	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);
1133

1134
	/* callbacks */
1135
	int (*set_bias_level)(struct snd_soc_card *,
1136
			      struct snd_soc_dapm_context *dapm,
1137
			      enum snd_soc_bias_level level);
1138
	int (*set_bias_level_post)(struct snd_soc_card *,
1139
				   struct snd_soc_dapm_context *dapm,
1140
				   enum snd_soc_bias_level level);
1141

1142 1143 1144 1145 1146
	int (*add_dai_link)(struct snd_soc_card *,
			    struct snd_soc_dai_link *link);
	void (*remove_dai_link)(struct snd_soc_card *,
			    struct snd_soc_dai_link *link);

M
Mark Brown 已提交
1147
	long pmdown_time;
1148

1149
	/* CPU <--> Codec DAI links  */
1150 1151 1152 1153 1154
	struct snd_soc_dai_link *dai_link;  /* predefined links only */
	int num_links;  /* predefined links only */
	struct list_head dai_link_list; /* all links */
	int num_dai_links;

1155
	struct list_head rtd_list;
1156
	int num_rtd;
1157

1158 1159 1160
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1161

1162 1163 1164 1165 1166 1167
	/*
	 * optional auxiliary devices such as amplifiers or codecs with DAI
	 * link unused
	 */
	struct snd_soc_aux_dev *aux_dev;
	int num_aux_devs;
1168
	struct list_head aux_comp_list;
1169

1170 1171 1172
	const struct snd_kcontrol_new *controls;
	int num_controls;

1173 1174
	/*
	 * Card-specific routes and widgets.
1175
	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1176
	 */
1177
	const struct snd_soc_dapm_widget *dapm_widgets;
1178
	int num_dapm_widgets;
1179
	const struct snd_soc_dapm_route *dapm_routes;
1180
	int num_dapm_routes;
1181 1182 1183 1184
	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;
1185
	bool fully_routed;
1186

1187
	struct work_struct deferred_resume_work;
1188 1189

	/* lists of probed devices belonging to this card */
1190
	struct list_head component_dev_list;
1191

1192
	struct list_head widgets;
1193
	struct list_head paths;
1194
	struct list_head dapm_list;
1195
	struct list_head dapm_dirty;
1196

1197 1198 1199
	/* attached dynamic objects */
	struct list_head dobj_list;

M
Mark Brown 已提交
1200 1201
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1202
	struct snd_soc_dapm_stats dapm_stats;
1203
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1204

1205 1206
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1207
	struct dentry *debugfs_pop_time;
1208
#endif
1209
	u32 pop_time;
M
Mark Brown 已提交
1210 1211

	void *drvdata;
1212 1213
};

1214
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1215
struct snd_soc_pcm_runtime {
1216
	struct device *dev;
1217
	struct snd_soc_card *card;
1218
	struct snd_soc_dai_link *dai_link;
L
Liam Girdwood 已提交
1219 1220 1221
	struct mutex pcm_mutex;
	enum snd_soc_pcm_subclass pcm_subclass;
	struct snd_pcm_ops ops;
1222

1223 1224
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];
1225
	int fe_compr;
1226

1227 1228 1229 1230
	long pmdown_time;

	/* runtime devices */
	struct snd_pcm *pcm;
1231
	struct snd_compr *compr;
1232 1233 1234 1235 1236
	struct snd_soc_codec *codec;
	struct snd_soc_platform *platform;
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;

1237 1238 1239
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1240
	struct delayed_work delayed_work;
1241 1242 1243 1244
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
	struct dentry *debugfs_dpcm_state;
#endif
1245 1246 1247

	unsigned int num; /* 0-based and monotonic increasing */
	struct list_head list; /* rtd list of the soc card */
1248 1249 1250 1251

	/* bit field */
	unsigned int dev_registered:1;
	unsigned int pop_wait:1;
1252 1253
};

1254 1255
/* mixer control */
struct soc_mixer_control {
1256
	int min, max, platform_max;
1257 1258
	int reg, rreg;
	unsigned int shift, rshift;
1259
	unsigned int sign_bit;
1260 1261
	unsigned int invert:1;
	unsigned int autodisable:1;
1262
	struct snd_soc_dobj dobj;
1263 1264
};

1265 1266 1267
struct soc_bytes {
	int base;
	int num_regs;
1268
	u32 mask;
1269 1270
};

V
Vinod Koul 已提交
1271 1272
struct soc_bytes_ext {
	int max;
1273 1274
	struct snd_soc_dobj dobj;

1275
	/* used for TLV byte control */
1276 1277 1278 1279
	int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
			unsigned int size);
	int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
			unsigned int size);
V
Vinod Koul 已提交
1280 1281
};

1282 1283 1284 1285 1286 1287
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1288 1289
/* enumerated kcontrol */
struct soc_enum {
1290
	int reg;
P
Peter Ujfalusi 已提交
1291 1292
	unsigned char shift_l;
	unsigned char shift_r;
1293
	unsigned int items;
P
Peter Ujfalusi 已提交
1294
	unsigned int mask;
1295
	const char * const *texts;
P
Peter Ujfalusi 已提交
1296
	const unsigned int *values;
1297
	unsigned int autodisable:1;
1298
	struct snd_soc_dobj dobj;
P
Peter Ujfalusi 已提交
1299 1300
};

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
/**
 * 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);
}

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
/**
 * 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);
}

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
/**
 * 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);
}

1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
/**
 * 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)
{
1352
	return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
}

/**
 * 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)
{
1366
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1367 1368
}

1369 1370 1371 1372 1373 1374 1375 1376
/**
 * 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)
{
1377
	return &component->dapm;
1378 1379
}

1380 1381 1382 1383 1384 1385 1386 1387 1388
/**
 * 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)
{
1389
	return snd_soc_component_get_dapm(&codec->component);
1390 1391
}

1392 1393
/**
 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
1394
 * @codec: The CODEC for which to initialize the DAPM bias level
1395 1396 1397 1398 1399 1400 1401 1402 1403 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
 * @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);
}

1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
/**
 * 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));
}

1445
/* codec IO */
1446
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1447 1448
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1449

1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
/**
 * 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);
}

1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
/* 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);

1474 1475
#ifdef CONFIG_REGMAP

1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
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);
}

1511 1512
#endif

1513 1514
/* device driver data */

M
Mark Brown 已提交
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
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;
}

1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
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);
}

1537
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1538
		void *data)
1539
{
1540
	snd_soc_component_set_drvdata(&codec->component, data);
1541 1542 1543 1544
}

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1545
	return snd_soc_component_get_drvdata(&codec->component);
1546 1547 1548 1549 1550
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1551
	snd_soc_component_set_drvdata(&platform->component, data);
1552 1553 1554 1555
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1556
	return snd_soc_component_get_drvdata(&platform->component);
1557 1558
}

1559 1560 1561 1562 1563
static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
{
	INIT_LIST_HEAD(&card->widgets);
	INIT_LIST_HEAD(&card->paths);
	INIT_LIST_HEAD(&card->dapm_list);
1564
	INIT_LIST_HEAD(&card->aux_comp_list);
1565
	INIT_LIST_HEAD(&card->component_dev_list);
1566 1567
}

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
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;
}

1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
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];
}

1604 1605 1606 1607 1608 1609
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1610 1611
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1612
	return snd_soc_component_is_active(&codec->component);
1613 1614
}

1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
/**
 * 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);
}

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
/**
 * 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)
{
1642
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1643 1644
}

1645
/**
1646
 * snd_soc_kcontrol_platform() - Returns the platform that registered the control
1647 1648 1649 1650 1651 1652
 * @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.
 */
1653
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1654 1655
	struct snd_kcontrol *kcontrol)
{
1656
	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1657 1658
}

1659 1660 1661
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1662 1663
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname);
1664 1665
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname);
1666
int snd_soc_of_parse_tdm_slot(struct device_node *np,
1667 1668
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
1669 1670
			      unsigned int *slots,
			      unsigned int *slot_width);
1671
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1672 1673 1674
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname);
1675 1676
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
				   const char *propname);
1677
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1678 1679 1680
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1681
int snd_soc_get_dai_id(struct device_node *ep);
1682 1683
int snd_soc_get_dai_name(struct of_phandle_args *args,
			 const char **dai_name);
1684 1685
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1686 1687 1688
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1689

1690 1691 1692 1693
int snd_soc_add_dai_link(struct snd_soc_card *card,
				struct snd_soc_dai_link *dai_link);
void snd_soc_remove_dai_link(struct snd_soc_card *card,
			     struct snd_soc_dai_link *dai_link);
M
Mengdong Lin 已提交
1694 1695 1696
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
					       int id, const char *name,
					       const char *stream_name);
1697

1698 1699 1700
int snd_soc_register_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv);

M
Mengdong Lin 已提交
1701 1702 1703
struct snd_soc_dai *snd_soc_find_dai(
	const struct snd_soc_dai_link_component *dlc);

1704 1705
#include <sound/soc-dai.h>

1706
#ifdef CONFIG_DEBUG_FS
1707
extern struct dentry *snd_soc_debugfs_root;
1708 1709
#endif

1710 1711
extern const struct dev_pm_ops snd_soc_pm_ops;

1712 1713 1714
/* Helper functions */
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
1715
	mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1716 1717 1718 1719 1720 1721 1722
}

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

1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
int snd_soc_component_enable_pin(struct snd_soc_component *component,
				 const char *pin);
int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
					  const char *pin);
int snd_soc_component_disable_pin(struct snd_soc_component *component,
				  const char *pin);
int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
					   const char *pin);
int snd_soc_component_nc_pin(struct snd_soc_component *component,
			     const char *pin);
int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
				      const char *pin);
int snd_soc_component_get_pin_status(struct snd_soc_component *component,
				     const char *pin);
int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
				       const char *pin);
int snd_soc_component_force_enable_pin_unlocked(
					struct snd_soc_component *component,
					const char *pin);

1743
#endif