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 830 831

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

	/* bits */
	unsigned int idle_bias_on:1;
	unsigned int suspend_bias_off:1;
836 837 838 839 840
};

struct snd_soc_component {
	const char *name;
	int id;
841
	const char *name_prefix;
842
	struct device *dev;
843
	struct snd_soc_card *card;
844 845 846

	unsigned int active;

847
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
848
	unsigned int registered_as_component:1;
849
	unsigned int suspended:1; /* is in suspend PM state */
850

851
	struct list_head list;
852
	struct list_head card_aux_list; /* for auxiliary bound components */
853
	struct list_head card_list;
854

855 856 857
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

858
	const struct snd_soc_component_driver *driver;
859 860

	struct list_head dai_list;
861 862 863 864 865 866 867 868

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

870 871 872
	/* attached dynamic objects */
	struct list_head dobj_list;

873 874 875 876 877 878 879 880 881 882
#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.
	*/

883 884
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
885

886 887 888 889
	struct snd_soc_codec *codec;

	int (*probe)(struct snd_soc_component *);
	void (*remove)(struct snd_soc_component *);
890 891
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
892 893
	int (*pcm_new)(struct snd_soc_component *, struct snd_soc_pcm_runtime *);
	void (*pcm_free)(struct snd_soc_component *, struct snd_pcm *);
894

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

904 905 906
	/* machine specific init */
	int (*init)(struct snd_soc_component *component);

907 908 909 910
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
911 912
};

913 914 915 916 917 918 919 920 921 922 923 924
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)

925
/* SoC Audio Codec device */
926
struct snd_soc_codec {
M
Mark Brown 已提交
927
	struct device *dev;
928
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
929 930

	struct list_head list;
931 932

	/* runtime */
933
	unsigned int cache_init:1; /* codec cache has been initialized */
934 935 936 937 938

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

940 941
	/* component */
	struct snd_soc_component component;
942 943
};

944 945 946 947 948 949
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
950
	int (*suspend)(struct snd_soc_codec *);
951
	int (*resume)(struct snd_soc_codec *);
952
	struct snd_soc_component_driver component_driver;
953

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

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

	void (*seq_notifier)(struct snd_soc_dapm_context *,
978
			     enum snd_soc_dapm_type, int);
979

980
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
981 982 983
};

/* SoC platform interface */
984
struct snd_soc_platform_driver {
985

986 987
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
988
	struct snd_soc_component_driver component_driver;
989 990

	/* pcm creation and destruction */
991
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
992 993
	void (*pcm_free)(struct snd_pcm *);

994
	/* platform stream pcm ops */
995
	const struct snd_pcm_ops *ops;
996

997
	/* platform stream compress ops */
998
	const struct snd_compr_ops *compr_ops;
999 1000
};

1001 1002
struct snd_soc_dai_link_component {
	const char *name;
1003
	struct device_node *of_node;
1004 1005 1006
	const char *dai_name;
};

1007 1008
struct snd_soc_platform {
	struct device *dev;
1009
	const struct snd_soc_platform_driver *driver;
1010

1011
	struct list_head list;
1012

1013
	struct snd_soc_component component;
1014
};
1015

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

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

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

1056
	const struct snd_soc_pcm_stream *params;
1057
	unsigned int num_params;
1058

1059 1060
	unsigned int dai_fmt;           /* format to set on init */

1061 1062
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
	/* 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;

1077 1078 1079 1080
	/* For unidirectional dai links */
	unsigned int playback_only:1;
	unsigned int capture_only:1;

1081 1082 1083
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

1084 1085
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
1086 1087
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
1088

1089 1090 1091 1092 1093 1094
	/* 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;

1095 1096 1097 1098
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

1099 1100 1101
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;

1102 1103
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
1104 1105 1106

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

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

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1121 1122 1123
	const char *name_prefix;
};

1124 1125
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1126 1127 1128 1129 1130 1131

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

	/* codec/machine specific init - e.g. add machine controls */
1135
	int (*init)(struct snd_soc_component *component);
1136 1137
};

1138 1139
/* SoC card */
struct snd_soc_card {
1140
	const char *name;
1141 1142
	const char *long_name;
	const char *driver_name;
1143 1144
	char dmi_longname[80];

M
Mark Brown 已提交
1145
	struct device *dev;
1146 1147
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1148

1149
	struct mutex mutex;
1150
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1151

1152
	bool instantiated;
1153

1154
	int (*probe)(struct snd_soc_card *card);
1155
	int (*late_probe)(struct snd_soc_card *card);
1156
	int (*remove)(struct snd_soc_card *card);
1157 1158 1159

	/* 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. */
1160 1161 1162 1163
	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);
1164

1165
	/* callbacks */
1166
	int (*set_bias_level)(struct snd_soc_card *,
1167
			      struct snd_soc_dapm_context *dapm,
1168
			      enum snd_soc_bias_level level);
1169
	int (*set_bias_level_post)(struct snd_soc_card *,
1170
				   struct snd_soc_dapm_context *dapm,
1171
				   enum snd_soc_bias_level level);
1172

1173 1174 1175 1176 1177
	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 已提交
1178
	long pmdown_time;
1179

1180
	/* CPU <--> Codec DAI links  */
1181 1182 1183 1184 1185
	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;

1186
	struct list_head rtd_list;
1187
	int num_rtd;
1188

1189 1190 1191
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1192

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

1201 1202 1203
	const struct snd_kcontrol_new *controls;
	int num_controls;

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

1218
	struct work_struct deferred_resume_work;
1219 1220

	/* lists of probed devices belonging to this card */
1221
	struct list_head component_dev_list;
1222

1223
	struct list_head widgets;
1224
	struct list_head paths;
1225
	struct list_head dapm_list;
1226
	struct list_head dapm_dirty;
1227

1228 1229 1230
	/* attached dynamic objects */
	struct list_head dobj_list;

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

1236 1237
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1238
	struct dentry *debugfs_pop_time;
1239
#endif
1240
	u32 pop_time;
M
Mark Brown 已提交
1241 1242

	void *drvdata;
1243 1244
};

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

1254 1255
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];
1256
	int fe_compr;
1257

1258 1259 1260 1261
	long pmdown_time;

	/* runtime devices */
	struct snd_pcm *pcm;
1262
	struct snd_compr *compr;
1263
	struct snd_soc_codec *codec;
1264
	struct snd_soc_platform *platform; /* will be removed */
1265 1266 1267
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;

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

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

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

	/* bit field */
	unsigned int dev_registered:1;
	unsigned int pop_wait:1;
1283 1284
};

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

1296 1297 1298
struct soc_bytes {
	int base;
	int num_regs;
1299
	u32 mask;
1300 1301
};

V
Vinod Koul 已提交
1302 1303
struct soc_bytes_ext {
	int max;
1304 1305
	struct snd_soc_dobj dobj;

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

1313 1314 1315 1316 1317 1318
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

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

1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
/**
 * 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);
}

1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
/**
 * 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);
}

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

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

/**
 * 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)
{
1397
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1398 1399
}

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

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

1423 1424
/**
 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
1425
 * @codec: The CODEC for which to initialize the DAPM bias level
1426 1427 1428 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
 * @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);
}

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

1476
/* codec IO */
1477
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1478 1479
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1480

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

1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
/* 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);

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

1514 1515
#ifdef CONFIG_REGMAP

1516 1517 1518 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
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);
}

1551 1552
#endif

1553 1554
/* device driver data */

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

1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
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);
}

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

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1585
	return snd_soc_component_get_drvdata(&codec->component);
1586 1587 1588 1589 1590
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1591
	snd_soc_component_set_drvdata(&platform->component, data);
1592 1593 1594 1595
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1596
	return snd_soc_component_get_drvdata(&platform->component);
1597 1598
}

1599 1600 1601 1602 1603
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);
1604
	INIT_LIST_HEAD(&card->aux_comp_list);
1605
	INIT_LIST_HEAD(&card->component_dev_list);
1606 1607
}

1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
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;
}

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

1644 1645 1646 1647 1648 1649
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1650 1651
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1652
	return snd_soc_component_is_active(&codec->component);
1653 1654
}

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

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

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

1699 1700 1701
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

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

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

1738 1739 1740
int snd_soc_register_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv);

M
Mengdong Lin 已提交
1741 1742 1743
struct snd_soc_dai *snd_soc_find_dai(
	const struct snd_soc_dai_link_component *dlc);

1744 1745
#include <sound/soc-dai.h>

1746
#ifdef CONFIG_DEBUG_FS
1747
extern struct dentry *snd_soc_debugfs_root;
1748 1749
#endif

1750 1751
extern const struct dev_pm_ops snd_soc_pm_ops;

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

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

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

1783
#endif