soc.h 60.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 474 475
int snd_soc_add_component(struct device *dev,
		struct snd_soc_component *component,
		const struct snd_soc_component_driver *component_driver,
		struct snd_soc_dai_driver *dai_drv,
		int num_dai);
476
int snd_soc_register_component(struct device *dev,
477
			 const struct snd_soc_component_driver *component_driver,
478
			 struct snd_soc_dai_driver *dai_drv, int num_dai);
479
int devm_snd_soc_register_component(struct device *dev,
480
			 const struct snd_soc_component_driver *component_driver,
481
			 struct snd_soc_dai_driver *dai_drv, int num_dai);
482
void snd_soc_unregister_component(struct device *dev);
483 484
struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
						   const char *driver_name);
485 486
int snd_soc_cache_init(struct snd_soc_codec *codec);
int snd_soc_cache_exit(struct snd_soc_codec *codec);
487

488 489 490 491
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 已提交
492
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
493 494 495
#ifdef CONFIG_SND_SOC_COMPRESS
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
#endif
M
Mark Brown 已提交
496

497 498 499 500 501
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);

502
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
503 504
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);
505

506 507 508
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

509
#ifdef CONFIG_DMI
510
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
511 512 513 514 515 516 517
#else
static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
				       const char *flavour)
{
	return 0;
}
#endif
518

519 520 521
/* 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);
522
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
523 524
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

525 526 527 528
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

529 530 531 532
int soc_dai_hw_params(struct snd_pcm_substream *substream,
		      struct snd_pcm_hw_params *params,
		      struct snd_soc_dai *dai);

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

563 564 565 566
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)
567 568 569 570
{
	return 0;
}

571 572 573 574
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
575
#endif
M
Mark Brown 已提交
576

577
/* codec register bit access */
578
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
579
				unsigned int mask, unsigned int value);
580
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
581
			       unsigned int reg, unsigned int mask,
582
			       unsigned int value);
583
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
584
				unsigned int mask, unsigned int value);
585

586
#ifdef CONFIG_SND_SOC_AC97_BUS
587
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
588 589
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
	unsigned int id, unsigned int id_mask);
590
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
591

592
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
593 594
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
595

596 597 598 599 600 601 602 603 604 605 606 607 608 609
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

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

M
Mark Brown 已提交
678 679 680 681 682 683
/**
 * 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
684
 * @list:   internal list entry
M
Mark Brown 已提交
685 686 687 688 689 690 691 692
 */
struct snd_soc_jack_pin {
	struct list_head list;
	const char *pin;
	int mask;
	bool invert;
};

693 694 695 696 697 698 699 700
/**
 * 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
701
 * @list:   internal list entry
702 703 704 705 706 707 708 709 710
 */
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;
};

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

738
	/* private: */
739
	struct snd_soc_jack *jack;
740
	struct delayed_work work;
741
	struct notifier_block pm_notifier;
742
	struct gpio_desc *desc;
743

744
	void *data;
745
	/* public: */
746
	int (*jack_status_check)(void *data);
747 748
};

M
Mark Brown 已提交
749
struct snd_soc_jack {
750
	struct mutex mutex;
M
Mark Brown 已提交
751
	struct snd_jack *jack;
752
	struct snd_soc_card *card;
M
Mark Brown 已提交
753 754
	struct list_head pins;
	int status;
755
	struct blocking_notifier_head notifier;
756
	struct list_head jack_zones;
M
Mark Brown 已提交
757 758
};

759 760
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
761
	const char *stream_name;
G
Graeme Gregory 已提交
762 763
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
764 765 766 767
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
768
	unsigned int sig_bits;		/* number of bits of content */
769 770 771 772 773 774 775 776 777 778 779 780
};

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

781 782 783 784 785 786 787
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 *);
};

788 789 790
/* component interface */
struct snd_soc_component_driver {
	const char *name;
791

792 793 794 795 796 797 798 799 800 801
	/* 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 *);
802 803
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
804

805 806 807 808
	/* pcm creation and destruction */
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_pcm *);

809 810 811
	/* component wide operations */
	int (*set_sysclk)(struct snd_soc_component *component,
			  int clk_id, int source, unsigned int freq, int dir);
812 813
	int (*set_pll)(struct snd_soc_component *component, int pll_id,
		       int source, unsigned int freq_in, unsigned int freq_out);
814 815
	int (*set_jack)(struct snd_soc_component *component,
			struct snd_soc_jack *jack,  void *data);
816

817 818 819 820
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
821 822
	int (*of_xlate_dai_id)(struct snd_soc_component *comment,
			       struct device_node *endpoint);
823 824 825
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
826 827
	int (*set_bias_level)(struct snd_soc_component *component,
			      enum snd_soc_bias_level level);
828

829
	const struct snd_pcm_ops *ops;
830
	const struct snd_compr_ops *compr_ops;
831

832 833 834
	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
835 836 837 838

	/* bits */
	unsigned int idle_bias_on:1;
	unsigned int suspend_bias_off:1;
839 840 841 842 843
};

struct snd_soc_component {
	const char *name;
	int id;
844
	const char *name_prefix;
845
	struct device *dev;
846
	struct snd_soc_card *card;
847 848 849

	unsigned int active;

850
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
851
	unsigned int registered_as_component:1;
852
	unsigned int suspended:1; /* is in suspend PM state */
853

854
	struct list_head list;
855
	struct list_head card_aux_list; /* for auxiliary bound components */
856
	struct list_head card_list;
857

858 859 860
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

861
	const struct snd_soc_component_driver *driver;
862 863

	struct list_head dai_list;
864 865 866 867 868 869 870 871

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

873 874 875
	/* attached dynamic objects */
	struct list_head dobj_list;

876 877 878 879 880 881 882 883 884 885
#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.
	*/

886 887
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
888

889 890 891 892
	struct snd_soc_codec *codec;

	int (*probe)(struct snd_soc_component *);
	void (*remove)(struct snd_soc_component *);
893 894
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
895 896
	int (*pcm_new)(struct snd_soc_component *, struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_soc_component *, struct snd_pcm *);
897

898 899
	int (*set_sysclk)(struct snd_soc_component *component,
			  int clk_id, int source, unsigned int freq, int dir);
900 901
	int (*set_pll)(struct snd_soc_component *component, int pll_id,
		       int source, unsigned int freq_in, unsigned int freq_out);
902 903
	int (*set_jack)(struct snd_soc_component *component,
			struct snd_soc_jack *jack,  void *data);
904 905
	int (*set_bias_level)(struct snd_soc_component *component,
			      enum snd_soc_bias_level level);
906

907 908 909
	/* machine specific init */
	int (*init)(struct snd_soc_component *component);

910 911 912 913
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
914 915
};

916 917 918 919 920 921 922 923 924 925 926 927
struct snd_soc_rtdcom_list {
	struct snd_soc_component *component;
	struct list_head list; /* rtd::component_list */
};
struct snd_soc_component*
snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
		       const char *driver_name);
#define for_each_rtdcom(rtd, rtdcom) \
	list_for_each_entry(rtdcom, &(rtd)->component_list, list)
#define for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2) \
	list_for_each_entry_safe(rtdcom1, rtdcom2, &(rtd)->component_list, list)

928
/* SoC Audio Codec device */
929
struct snd_soc_codec {
M
Mark Brown 已提交
930
	struct device *dev;
931
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
932 933

	struct list_head list;
934 935

	/* runtime */
936
	unsigned int cache_init:1; /* codec cache has been initialized */
937 938 939 940 941

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

943 944
	/* component */
	struct snd_soc_component component;
945 946
};

947 948 949 950 951 952
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
953
	int (*suspend)(struct snd_soc_codec *);
954
	int (*resume)(struct snd_soc_codec *);
955
	struct snd_soc_component_driver component_driver;
956

957 958
	/* codec wide operations */
	int (*set_sysclk)(struct snd_soc_codec *codec,
959
			  int clk_id, int source, unsigned int freq, int dir);
960 961
	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
		unsigned int freq_in, unsigned int freq_out);
962 963
	int (*set_jack)(struct snd_soc_codec *codec,
			struct snd_soc_jack *jack,  void *data);
964

965
	/* codec IO */
966
	struct regmap *(*get_regmap)(struct device *);
967 968
	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
969
	unsigned int reg_cache_size;
970 971 972 973 974 975 976
	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);
977
	bool idle_bias_off;
978
	bool suspend_bias_off;
979 980

	void (*seq_notifier)(struct snd_soc_dapm_context *,
981
			     enum snd_soc_dapm_type, int);
982

983
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
984 985 986
};

/* SoC platform interface */
987
struct snd_soc_platform_driver {
988

989 990
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
991
	struct snd_soc_component_driver component_driver;
992 993

	/* pcm creation and destruction */
994
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
995 996
	void (*pcm_free)(struct snd_pcm *);

997
	/* platform stream pcm ops */
998
	const struct snd_pcm_ops *ops;
999

1000
	/* platform stream compress ops */
1001
	const struct snd_compr_ops *compr_ops;
1002 1003
};

1004 1005
struct snd_soc_dai_link_component {
	const char *name;
1006
	struct device_node *of_node;
1007 1008 1009
	const char *dai_name;
};

1010 1011
struct snd_soc_platform {
	struct device *dev;
1012
	const struct snd_soc_platform_driver *driver;
1013

1014
	struct list_head list;
1015

1016
	struct snd_soc_component component;
1017
};
1018

1019 1020 1021 1022
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
1023 1024 1025 1026 1027 1028 1029 1030
	/*
	 * 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;
1031
	struct device_node *cpu_of_node;
1032 1033 1034 1035 1036
	/*
	 * 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.
	 */
1037
	const char *cpu_dai_name;
1038 1039 1040 1041 1042
	/*
	 * You MUST specify the link's codec, either by device name, or by
	 * DT/OF node, but not both.
	 */
	const char *codec_name;
1043
	struct device_node *codec_of_node;
1044
	/* You MUST specify the DAI name within the codec */
1045
	const char *codec_dai_name;
1046 1047 1048 1049

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

1050 1051 1052 1053 1054 1055
	/*
	 * 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;
1056
	struct device_node *platform_of_node;
1057
	int id;	/* optional ID for machine driver link identification */
1058

1059
	const struct snd_soc_pcm_stream *params;
1060
	unsigned int num_params;
1061

1062 1063
	unsigned int dai_fmt;           /* format to set on init */

1064 1065
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
	/* 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;

1080 1081 1082 1083
	/* For unidirectional dai links */
	unsigned int playback_only:1;
	unsigned int capture_only:1;

1084 1085 1086
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

1087 1088
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
1089 1090
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
1091

1092 1093 1094 1095 1096 1097
	/* 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;

1098 1099 1100 1101
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

1102 1103 1104
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;

1105 1106
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
1107 1108 1109

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

1112
struct snd_soc_codec_conf {
1113 1114 1115 1116
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
1117
	const char *dev_name;
1118
	struct device_node *of_node;
1119 1120 1121 1122 1123

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1124 1125 1126
	const char *name_prefix;
};

1127 1128
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1129 1130 1131 1132 1133 1134

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

	/* codec/machine specific init - e.g. add machine controls */
1138
	int (*init)(struct snd_soc_component *component);
1139 1140
};

1141 1142
/* SoC card */
struct snd_soc_card {
1143
	const char *name;
1144 1145
	const char *long_name;
	const char *driver_name;
1146 1147
	char dmi_longname[80];

M
Mark Brown 已提交
1148
	struct device *dev;
1149 1150
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1151

1152
	struct mutex mutex;
1153
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1154

1155
	bool instantiated;
1156

1157
	int (*probe)(struct snd_soc_card *card);
1158
	int (*late_probe)(struct snd_soc_card *card);
1159
	int (*remove)(struct snd_soc_card *card);
1160 1161 1162

	/* 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. */
1163 1164 1165 1166
	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);
1167

1168
	/* callbacks */
1169
	int (*set_bias_level)(struct snd_soc_card *,
1170
			      struct snd_soc_dapm_context *dapm,
1171
			      enum snd_soc_bias_level level);
1172
	int (*set_bias_level_post)(struct snd_soc_card *,
1173
				   struct snd_soc_dapm_context *dapm,
1174
				   enum snd_soc_bias_level level);
1175

1176 1177 1178 1179 1180
	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 已提交
1181
	long pmdown_time;
1182

1183
	/* CPU <--> Codec DAI links  */
1184 1185 1186 1187 1188
	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;

1189
	struct list_head rtd_list;
1190
	int num_rtd;
1191

1192 1193 1194
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1195

1196 1197 1198 1199 1200 1201
	/*
	 * optional auxiliary devices such as amplifiers or codecs with DAI
	 * link unused
	 */
	struct snd_soc_aux_dev *aux_dev;
	int num_aux_devs;
1202
	struct list_head aux_comp_list;
1203

1204 1205 1206
	const struct snd_kcontrol_new *controls;
	int num_controls;

1207 1208
	/*
	 * Card-specific routes and widgets.
1209
	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1210
	 */
1211
	const struct snd_soc_dapm_widget *dapm_widgets;
1212
	int num_dapm_widgets;
1213
	const struct snd_soc_dapm_route *dapm_routes;
1214
	int num_dapm_routes;
1215 1216 1217 1218
	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;
1219
	bool fully_routed;
1220

1221
	struct work_struct deferred_resume_work;
1222 1223

	/* lists of probed devices belonging to this card */
1224
	struct list_head component_dev_list;
1225

1226
	struct list_head widgets;
1227
	struct list_head paths;
1228
	struct list_head dapm_list;
1229
	struct list_head dapm_dirty;
1230

1231 1232 1233
	/* attached dynamic objects */
	struct list_head dobj_list;

M
Mark Brown 已提交
1234 1235
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1236
	struct snd_soc_dapm_stats dapm_stats;
1237
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1238

1239 1240
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1241
	struct dentry *debugfs_pop_time;
1242
#endif
1243
	u32 pop_time;
M
Mark Brown 已提交
1244 1245

	void *drvdata;
1246 1247
};

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

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

1261 1262 1263 1264
	long pmdown_time;

	/* runtime devices */
	struct snd_pcm *pcm;
1265
	struct snd_compr *compr;
1266
	struct snd_soc_codec *codec;
1267
	struct snd_soc_platform *platform; /* will be removed */
1268 1269 1270
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;

1271 1272 1273
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1274
	struct delayed_work delayed_work;
1275 1276 1277
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
#endif
1278 1279 1280

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

	/* bit field */
	unsigned int dev_registered:1;
	unsigned int pop_wait:1;
1286 1287
};

1288 1289
/* mixer control */
struct soc_mixer_control {
1290
	int min, max, platform_max;
1291 1292
	int reg, rreg;
	unsigned int shift, rshift;
1293
	unsigned int sign_bit;
1294 1295
	unsigned int invert:1;
	unsigned int autodisable:1;
1296
	struct snd_soc_dobj dobj;
1297 1298
};

1299 1300 1301
struct soc_bytes {
	int base;
	int num_regs;
1302
	u32 mask;
1303 1304
};

V
Vinod Koul 已提交
1305 1306
struct soc_bytes_ext {
	int max;
1307 1308
	struct snd_soc_dobj dobj;

1309
	/* used for TLV byte control */
1310 1311 1312 1313
	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 已提交
1314 1315
};

1316 1317 1318 1319 1320 1321
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1322 1323
/* enumerated kcontrol */
struct soc_enum {
1324
	int reg;
P
Peter Ujfalusi 已提交
1325 1326
	unsigned char shift_l;
	unsigned char shift_r;
1327
	unsigned int items;
P
Peter Ujfalusi 已提交
1328
	unsigned int mask;
1329
	const char * const *texts;
P
Peter Ujfalusi 已提交
1330
	const unsigned int *values;
1331
	unsigned int autodisable:1;
1332
	struct snd_soc_dobj dobj;
P
Peter Ujfalusi 已提交
1333 1334
};

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
/**
 * 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);
}

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
/**
 * 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);
}

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

1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
/**
 * 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)
{
1386
	return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
}

/**
 * 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)
{
1400
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1401 1402
}

1403 1404 1405 1406 1407 1408 1409 1410
/**
 * 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)
{
1411
	return &component->dapm;
1412 1413
}

1414 1415 1416 1417 1418 1419 1420 1421 1422
/**
 * 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)
{
1423
	return snd_soc_component_get_dapm(&codec->component);
1424 1425
}

1426 1427
/**
 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
1428
 * @codec: The CODEC for which to initialize the DAPM bias level
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
 * @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);
}

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
/**
 * 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));
}

1479
/* codec IO */
1480
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1481 1482
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1483

1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
/**
 * 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);
}

1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
/* 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);

1508 1509 1510
/* component wide operations */
int snd_soc_component_set_sysclk(struct snd_soc_component *component,
			int clk_id, int source, unsigned int freq, int dir);
1511 1512 1513
int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
			      int source, unsigned int freq_in,
			      unsigned int freq_out);
1514 1515
int snd_soc_component_set_jack(struct snd_soc_component *component,
			       struct snd_soc_jack *jack, void *data);
1516

1517 1518
#ifdef CONFIG_REGMAP

1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
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);
}

1554 1555
#endif

1556 1557
/* device driver data */

M
Mark Brown 已提交
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
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;
}

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

1580
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1581
		void *data)
1582
{
1583
	snd_soc_component_set_drvdata(&codec->component, data);
1584 1585 1586 1587
}

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1588
	return snd_soc_component_get_drvdata(&codec->component);
1589 1590 1591 1592 1593
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1594
	snd_soc_component_set_drvdata(&platform->component, data);
1595 1596 1597 1598
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1599
	return snd_soc_component_get_drvdata(&platform->component);
1600 1601
}

1602 1603 1604 1605 1606
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);
1607
	INIT_LIST_HEAD(&card->aux_comp_list);
1608
	INIT_LIST_HEAD(&card->component_dev_list);
1609 1610
}

1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
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;
}

1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
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];
}

1647 1648 1649 1650 1651 1652
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1653 1654
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1655
	return snd_soc_component_is_active(&codec->component);
1656 1657
}

1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
/**
 * 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);
}

1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
/**
 * 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)
{
1685
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1686 1687
}

1688
/**
1689
 * snd_soc_kcontrol_platform() - Returns the platform that registered the control
1690 1691 1692 1693 1694 1695
 * @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.
 */
1696
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1697 1698
	struct snd_kcontrol *kcontrol)
{
1699
	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1700 1701
}

1702 1703 1704
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1705 1706
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname);
1707 1708
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname);
1709
int snd_soc_of_parse_tdm_slot(struct device_node *np,
1710 1711
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
1712 1713
			      unsigned int *slots,
			      unsigned int *slot_width);
1714
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1715 1716 1717
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname);
1718 1719
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
				   const char *propname);
1720
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1721 1722 1723
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1724
int snd_soc_get_dai_id(struct device_node *ep);
1725 1726
int snd_soc_get_dai_name(struct of_phandle_args *args,
			 const char **dai_name);
1727 1728
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1729 1730 1731
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1732

1733 1734 1735 1736
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 已提交
1737 1738 1739
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
					       int id, const char *name,
					       const char *stream_name);
1740

1741 1742 1743
int snd_soc_register_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv);

M
Mengdong Lin 已提交
1744 1745 1746
struct snd_soc_dai *snd_soc_find_dai(
	const struct snd_soc_dai_link_component *dlc);

1747 1748
#include <sound/soc-dai.h>

1749
#ifdef CONFIG_DEBUG_FS
1750
extern struct dentry *snd_soc_debugfs_root;
1751 1752
#endif

1753 1754
extern const struct dev_pm_ops snd_soc_pm_ops;

1755 1756 1757
/* Helper functions */
static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
{
1758
	mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1759 1760 1761 1762 1763 1764 1765
}

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

1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
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);

1786
#endif