soc.h 59.0 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 437
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
			  unsigned int freq_in, unsigned int freq_out);

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

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

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

488 489 490 491 492
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);

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

497 498 499
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt);

500 501 502
/* 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);
503
int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
504 505
int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);

506 507 508 509
/* set runtime hw params */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw);

510 511 512
int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
		int cmd, struct snd_soc_platform *platform);

513 514 515 516
int soc_dai_hw_params(struct snd_pcm_substream *substream,
		      struct snd_pcm_hw_params *params,
		      struct snd_soc_dai *dai);

M
Mark Brown 已提交
517
/* Jack reporting */
518 519 520 521
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 已提交
522 523 524
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);
525 526 527 528
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);
529 530 531
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);
532 533 534
#ifdef CONFIG_GPIOLIB
int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
535 536 537
int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
			    struct snd_soc_jack *jack,
			    int count, struct snd_soc_jack_gpio *gpios);
538 539
void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
			struct snd_soc_jack_gpio *gpios);
540 541 542 543 544 545 546
#else
static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
					 struct snd_soc_jack_gpio *gpios)
{
	return 0;
}

547 548 549 550
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)
551 552 553 554
{
	return 0;
}

555 556 557 558
static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
					   struct snd_soc_jack_gpio *gpios)
{
}
559
#endif
M
Mark Brown 已提交
560

561
/* codec register bit access */
562
int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
563
				unsigned int mask, unsigned int value);
564
int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
565
			       unsigned int reg, unsigned int mask,
566
			       unsigned int value);
567
int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
568
				unsigned int mask, unsigned int value);
569

570
#ifdef CONFIG_SND_SOC_AC97_BUS
571
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec);
572 573
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
	unsigned int id, unsigned int id_mask);
574
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97);
575

576
int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
577 578
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev);
579

580 581 582 583 584 585 586 587 588 589 590 591 592 593
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

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

M
Mark Brown 已提交
662 663 664 665 666 667
/**
 * 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
668
 * @list:   internal list entry
M
Mark Brown 已提交
669 670 671 672 673 674 675 676
 */
struct snd_soc_jack_pin {
	struct list_head list;
	const char *pin;
	int mask;
	bool invert;
};

677 678 679 680 681 682 683 684
/**
 * 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
685
 * @list:   internal list entry
686 687 688 689 690 691 692 693 694
 */
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;
};

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

722
	/* private: */
723
	struct snd_soc_jack *jack;
724
	struct delayed_work work;
725
	struct notifier_block pm_notifier;
726
	struct gpio_desc *desc;
727

728
	void *data;
729
	/* public: */
730
	int (*jack_status_check)(void *data);
731 732
};

M
Mark Brown 已提交
733
struct snd_soc_jack {
734
	struct mutex mutex;
M
Mark Brown 已提交
735
	struct snd_jack *jack;
736
	struct snd_soc_card *card;
M
Mark Brown 已提交
737 738
	struct list_head pins;
	int status;
739
	struct blocking_notifier_head notifier;
740
	struct list_head jack_zones;
M
Mark Brown 已提交
741 742
};

743 744
/* SoC PCM stream information */
struct snd_soc_pcm_stream {
745
	const char *stream_name;
G
Graeme Gregory 已提交
746 747
	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
	unsigned int rates;		/* SNDRV_PCM_RATE_* */
748 749 750 751
	unsigned int rate_min;		/* min rate */
	unsigned int rate_max;		/* max rate */
	unsigned int channels_min;	/* min channels */
	unsigned int channels_max;	/* max channels */
752
	unsigned int sig_bits;		/* number of bits of content */
753 754 755 756 757 758 759 760 761 762 763 764
};

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

765 766 767 768 769 770 771
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 *);
};

772 773 774
/* component interface */
struct snd_soc_component_driver {
	const char *name;
775

776 777 778 779 780 781 782 783 784 785
	/* 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 *);
786 787
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
788

789 790 791 792
	/* DT */
	int (*of_xlate_dai_name)(struct snd_soc_component *component,
				 struct of_phandle_args *args,
				 const char **dai_name);
793 794 795
	void (*seq_notifier)(struct snd_soc_component *, enum snd_soc_dapm_type,
		int subseq);
	int (*stream_event)(struct snd_soc_component *, int event);
796 797 798 799

	/* probe ordering - for components with runtime dependencies */
	int probe_order;
	int remove_order;
800 801 802 803 804
};

struct snd_soc_component {
	const char *name;
	int id;
805
	const char *name_prefix;
806
	struct device *dev;
807
	struct snd_soc_card *card;
808 809 810

	unsigned int active;

811
	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
812
	unsigned int registered_as_component:1;
813
	unsigned int auxiliary:1; /* for auxiliary component of the card */
814
	unsigned int suspended:1; /* is in suspend PM state */
815

816
	struct list_head list;
817
	struct list_head card_list;
818

819 820 821
	struct snd_soc_dai_driver *dai_drv;
	int num_dai;

822
	const struct snd_soc_component_driver *driver;
823 824

	struct list_head dai_list;
825 826 827 828 829 830 831 832

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

834 835 836
	/* attached dynamic objects */
	struct list_head dobj_list;

837 838 839 840 841 842 843 844 845 846
#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.
	*/

847 848
	/* Don't use these, use snd_soc_component_get_dapm() */
	struct snd_soc_dapm_context dapm;
849

850 851 852 853 854 855 856 857 858 859
	const struct snd_kcontrol_new *controls;
	unsigned int num_controls;
	const struct snd_soc_dapm_widget *dapm_widgets;
	unsigned int num_dapm_widgets;
	const struct snd_soc_dapm_route *dapm_routes;
	unsigned int num_dapm_routes;
	struct snd_soc_codec *codec;

	int (*probe)(struct snd_soc_component *);
	void (*remove)(struct snd_soc_component *);
860 861
	int (*suspend)(struct snd_soc_component *);
	int (*resume)(struct snd_soc_component *);
862

863 864 865
	/* machine specific init */
	int (*init)(struct snd_soc_component *component);

866 867 868 869
#ifdef CONFIG_DEBUG_FS
	void (*init_debugfs)(struct snd_soc_component *component);
	const char *debugfs_prefix;
#endif
870 871
};

872
/* SoC Audio Codec device */
873
struct snd_soc_codec {
M
Mark Brown 已提交
874
	struct device *dev;
875
	const struct snd_soc_codec_driver *driver;
M
Mark Brown 已提交
876 877

	struct list_head list;
878 879

	/* runtime */
880
	unsigned int cache_bypass:1; /* Suppress access to the cache */
881
	unsigned int cache_init:1; /* codec cache has been initialized */
882 883 884 885 886

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

888 889 890
	/* component */
	struct snd_soc_component component;

891 892 893
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_reg;
#endif
894 895
};

896 897 898 899 900 901
/* codec driver */
struct snd_soc_codec_driver {

	/* driver ops */
	int (*probe)(struct snd_soc_codec *);
	int (*remove)(struct snd_soc_codec *);
902
	int (*suspend)(struct snd_soc_codec *);
903
	int (*resume)(struct snd_soc_codec *);
904
	struct snd_soc_component_driver component_driver;
905

906 907
	/* codec wide operations */
	int (*set_sysclk)(struct snd_soc_codec *codec,
908
			  int clk_id, int source, unsigned int freq, int dir);
909 910 911
	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
		unsigned int freq_in, unsigned int freq_out);

912
	/* codec IO */
913
	struct regmap *(*get_regmap)(struct device *);
914 915
	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
916
	unsigned int reg_cache_size;
917 918 919 920 921 922 923
	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);
924
	bool idle_bias_off;
925
	bool suspend_bias_off;
926 927

	void (*seq_notifier)(struct snd_soc_dapm_context *,
928
			     enum snd_soc_dapm_type, int);
929

930
	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
931 932 933
};

/* SoC platform interface */
934
struct snd_soc_platform_driver {
935

936 937
	int (*probe)(struct snd_soc_platform *);
	int (*remove)(struct snd_soc_platform *);
938
	struct snd_soc_component_driver component_driver;
939 940

	/* pcm creation and destruction */
941
	int (*pcm_new)(struct snd_soc_pcm_runtime *);
942 943
	void (*pcm_free)(struct snd_pcm *);

944 945 946 947 948 949 950
	/*
	 * For platform caused delay reporting.
	 * Optional.
	 */
	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
		struct snd_soc_dai *);

951
	/* platform stream pcm ops */
952
	const struct snd_pcm_ops *ops;
953

954
	/* platform stream compress ops */
955
	const struct snd_compr_ops *compr_ops;
956

957
	int (*bespoke_trigger)(struct snd_pcm_substream *, int);
958 959
};

960 961
struct snd_soc_dai_link_component {
	const char *name;
962
	struct device_node *of_node;
963 964 965
	const char *dai_name;
};

966 967
struct snd_soc_platform {
	struct device *dev;
968
	const struct snd_soc_platform_driver *driver;
969

970
	struct list_head list;
971

972
	struct snd_soc_component component;
973
};
974

975 976 977 978
struct snd_soc_dai_link {
	/* config - must be set by machine driver */
	const char *name;			/* Codec name */
	const char *stream_name;		/* Stream name */
979 980 981 982 983 984 985 986
	/*
	 * 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;
987
	struct device_node *cpu_of_node;
988 989 990 991 992
	/*
	 * 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.
	 */
993
	const char *cpu_dai_name;
994 995 996 997 998
	/*
	 * You MUST specify the link's codec, either by device name, or by
	 * DT/OF node, but not both.
	 */
	const char *codec_name;
999
	struct device_node *codec_of_node;
1000
	/* You MUST specify the DAI name within the codec */
1001
	const char *codec_dai_name;
1002 1003 1004 1005

	struct snd_soc_dai_link_component *codecs;
	unsigned int num_codecs;

1006 1007 1008 1009 1010 1011
	/*
	 * 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;
1012
	struct device_node *platform_of_node;
1013
	int id;	/* optional ID for machine driver link identification */
1014

1015
	const struct snd_soc_pcm_stream *params;
1016
	unsigned int num_params;
1017

1018 1019
	unsigned int dai_fmt;           /* format to set on init */

1020 1021
	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
	/* 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;

1036 1037 1038 1039
	/* For unidirectional dai links */
	unsigned int playback_only:1;
	unsigned int capture_only:1;

1040 1041 1042
	/* Keep DAI active over suspend */
	unsigned int ignore_suspend:1;

1043 1044
	/* Symmetry requirements */
	unsigned int symmetric_rates:1;
1045 1046
	unsigned int symmetric_channels:1;
	unsigned int symmetric_samplebits:1;
1047

1048 1049 1050 1051 1052 1053
	/* 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;

1054 1055 1056 1057
	/* DPCM capture and Playback support */
	unsigned int dpcm_capture:1;
	unsigned int dpcm_playback:1;

1058 1059 1060
	/* DPCM used FE & BE merged format */
	unsigned int dpcm_merged_format:1;

1061 1062
	/* pmdown_time is ignored at stop */
	unsigned int ignore_pmdown_time:1;
1063 1064 1065

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

1068
struct snd_soc_codec_conf {
1069 1070 1071 1072
	/*
	 * specify device either by device name, or by
	 * DT/OF node, but not both.
	 */
1073
	const char *dev_name;
1074
	struct device_node *of_node;
1075 1076 1077 1078 1079

	/*
	 * optional map of kcontrol, widget and path name prefixes that are
	 * associated per device
	 */
1080 1081 1082
	const char *name_prefix;
};

1083 1084
struct snd_soc_aux_dev {
	const char *name;		/* Codec name */
1085 1086 1087 1088 1089 1090

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

	/* codec/machine specific init - e.g. add machine controls */
1094
	int (*init)(struct snd_soc_component *component);
1095 1096
};

1097 1098
/* SoC card */
struct snd_soc_card {
1099
	const char *name;
1100 1101
	const char *long_name;
	const char *driver_name;
M
Mark Brown 已提交
1102
	struct device *dev;
1103 1104
	struct snd_card *snd_card;
	struct module *owner;
M
Mark Brown 已提交
1105

1106
	struct mutex mutex;
1107
	struct mutex dapm_mutex;
M
Mark Brown 已提交
1108

1109
	bool instantiated;
1110

1111
	int (*probe)(struct snd_soc_card *card);
1112
	int (*late_probe)(struct snd_soc_card *card);
1113
	int (*remove)(struct snd_soc_card *card);
1114 1115 1116

	/* 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. */
1117 1118 1119 1120
	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);
1121

1122
	/* callbacks */
1123
	int (*set_bias_level)(struct snd_soc_card *,
1124
			      struct snd_soc_dapm_context *dapm,
1125
			      enum snd_soc_bias_level level);
1126
	int (*set_bias_level_post)(struct snd_soc_card *,
1127
				   struct snd_soc_dapm_context *dapm,
1128
				   enum snd_soc_bias_level level);
1129

1130 1131 1132 1133 1134
	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 已提交
1135
	long pmdown_time;
1136

1137
	/* CPU <--> Codec DAI links  */
1138 1139 1140 1141 1142
	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;

1143
	struct list_head rtd_list;
1144
	int num_rtd;
1145

1146 1147 1148
	/* optional codec specific configuration */
	struct snd_soc_codec_conf *codec_conf;
	int num_configs;
1149

1150 1151 1152 1153 1154 1155 1156
	/*
	 * optional auxiliary devices such as amplifiers or codecs with DAI
	 * link unused
	 */
	struct snd_soc_aux_dev *aux_dev;
	int num_aux_devs;

1157 1158 1159
	const struct snd_kcontrol_new *controls;
	int num_controls;

1160 1161
	/*
	 * Card-specific routes and widgets.
1162
	 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1163
	 */
1164
	const struct snd_soc_dapm_widget *dapm_widgets;
1165
	int num_dapm_widgets;
1166
	const struct snd_soc_dapm_route *dapm_routes;
1167
	int num_dapm_routes;
1168 1169 1170 1171
	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;
1172
	bool fully_routed;
1173

1174
	struct work_struct deferred_resume_work;
1175 1176

	/* lists of probed devices belonging to this card */
1177
	struct list_head component_dev_list;
1178

1179
	struct list_head widgets;
1180
	struct list_head paths;
1181
	struct list_head dapm_list;
1182
	struct list_head dapm_dirty;
1183

1184 1185 1186
	/* attached dynamic objects */
	struct list_head dobj_list;

M
Mark Brown 已提交
1187 1188
	/* Generic DAPM context for the card */
	struct snd_soc_dapm_context dapm;
1189
	struct snd_soc_dapm_stats dapm_stats;
1190
	struct snd_soc_dapm_update *update;
M
Mark Brown 已提交
1191

1192 1193
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_card_root;
1194
	struct dentry *debugfs_pop_time;
1195
#endif
1196
	u32 pop_time;
M
Mark Brown 已提交
1197 1198

	void *drvdata;
1199 1200
};

1201
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1202
struct snd_soc_pcm_runtime {
1203
	struct device *dev;
1204
	struct snd_soc_card *card;
1205
	struct snd_soc_dai_link *dai_link;
L
Liam Girdwood 已提交
1206 1207 1208
	struct mutex pcm_mutex;
	enum snd_soc_pcm_subclass pcm_subclass;
	struct snd_pcm_ops ops;
1209

1210 1211
	/* Dynamic PCM BE runtime data */
	struct snd_soc_dpcm_runtime dpcm[2];
1212
	int fe_compr;
1213

1214 1215 1216 1217
	long pmdown_time;

	/* runtime devices */
	struct snd_pcm *pcm;
1218
	struct snd_compr *compr;
1219 1220 1221 1222 1223
	struct snd_soc_codec *codec;
	struct snd_soc_platform *platform;
	struct snd_soc_dai *codec_dai;
	struct snd_soc_dai *cpu_dai;

1224 1225 1226
	struct snd_soc_dai **codec_dais;
	unsigned int num_codecs;

1227
	struct delayed_work delayed_work;
1228 1229 1230 1231
#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs_dpcm_root;
	struct dentry *debugfs_dpcm_state;
#endif
1232 1233 1234

	unsigned int num; /* 0-based and monotonic increasing */
	struct list_head list; /* rtd list of the soc card */
1235 1236 1237 1238

	/* bit field */
	unsigned int dev_registered:1;
	unsigned int pop_wait:1;
1239 1240
};

1241 1242
/* mixer control */
struct soc_mixer_control {
1243
	int min, max, platform_max;
1244 1245
	int reg, rreg;
	unsigned int shift, rshift;
1246
	unsigned int sign_bit;
1247 1248
	unsigned int invert:1;
	unsigned int autodisable:1;
1249
	struct snd_soc_dobj dobj;
1250 1251
};

1252 1253 1254
struct soc_bytes {
	int base;
	int num_regs;
1255
	u32 mask;
1256 1257
};

V
Vinod Koul 已提交
1258 1259
struct soc_bytes_ext {
	int max;
1260 1261
	struct snd_soc_dobj dobj;

1262
	/* used for TLV byte control */
1263 1264 1265 1266
	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 已提交
1267 1268
};

1269 1270 1271 1272 1273 1274
/* multi register control */
struct soc_mreg_control {
	long min, max;
	unsigned int regbase, regcount, nbits, invert;
};

1275 1276
/* enumerated kcontrol */
struct soc_enum {
1277
	int reg;
P
Peter Ujfalusi 已提交
1278 1279
	unsigned char shift_l;
	unsigned char shift_r;
1280
	unsigned int items;
P
Peter Ujfalusi 已提交
1281
	unsigned int mask;
1282
	const char * const *texts;
P
Peter Ujfalusi 已提交
1283
	const unsigned int *values;
1284
	unsigned int autodisable:1;
1285
	struct snd_soc_dobj dobj;
P
Peter Ujfalusi 已提交
1286 1287
};

1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
/**
 * 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);
}

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

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

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
/**
 * 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)
{
1339
	return snd_soc_component_to_codec(snd_soc_dapm_to_component(dapm));
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
}

/**
 * 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)
{
1353
	return snd_soc_component_to_platform(snd_soc_dapm_to_component(dapm));
1354 1355
}

1356 1357 1358 1359 1360 1361 1362 1363
/**
 * 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)
{
1364
	return &component->dapm;
1365 1366
}

1367 1368 1369 1370 1371 1372 1373 1374 1375
/**
 * 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)
{
1376
	return snd_soc_component_get_dapm(&codec->component);
1377 1378
}

1379 1380
/**
 * snd_soc_dapm_init_bias_level() - Initialize CODEC DAPM bias level
1381
 * @codec: The CODEC for which to initialize the DAPM bias level
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
 * @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);
}

1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
/**
 * 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));
}

1432
/* codec IO */
1433
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1434 1435
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
	unsigned int val);
1436

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
/**
 * 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);
}

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

1461 1462
#ifdef CONFIG_REGMAP

1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
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);
}

1498 1499
#endif

1500 1501
/* device driver data */

M
Mark Brown 已提交
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
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;
}

1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
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);
}

1524
static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1525
		void *data)
1526
{
1527
	snd_soc_component_set_drvdata(&codec->component, data);
1528 1529 1530 1531
}

static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
{
1532
	return snd_soc_component_get_drvdata(&codec->component);
1533 1534 1535 1536 1537
}

static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
		void *data)
{
1538
	snd_soc_component_set_drvdata(&platform->component, data);
1539 1540 1541 1542
}

static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
{
1543
	return snd_soc_component_get_drvdata(&platform->component);
1544 1545
}

1546 1547 1548 1549 1550
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);
1551
	INIT_LIST_HEAD(&card->component_dev_list);
1552 1553
}

1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
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;
}

1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
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];
}

1590 1591 1592 1593 1594 1595
static inline bool snd_soc_component_is_active(
	struct snd_soc_component *component)
{
	return component->active != 0;
}

1596 1597
static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
{
1598
	return snd_soc_component_is_active(&codec->component);
1599 1600
}

1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
/**
 * 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);
}

1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
/**
 * 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)
{
1628
	return snd_soc_component_to_codec(snd_soc_kcontrol_component(kcontrol));
1629 1630
}

1631
/**
1632
 * snd_soc_kcontrol_platform() - Returns the platform that registered the control
1633 1634 1635 1636 1637 1638
 * @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.
 */
1639
static inline struct snd_soc_platform *snd_soc_kcontrol_platform(
1640 1641
	struct snd_kcontrol *kcontrol)
{
1642
	return snd_soc_component_to_platform(snd_soc_kcontrol_component(kcontrol));
1643 1644
}

1645 1646 1647
int snd_soc_util_init(void);
void snd_soc_util_exit(void);

1648 1649 1650 1651 1652
#define snd_soc_of_parse_card_name(card, propname) \
	snd_soc_of_parse_card_name_from_node(card, NULL, propname)
int snd_soc_of_parse_card_name_from_node(struct snd_soc_card *card,
					 struct device_node *np,
					 const char *propname);
1653 1654 1655 1656 1657 1658
#define snd_soc_of_parse_audio_simple_widgets(card, propname)\
	snd_soc_of_parse_audio_simple_widgets_from_node(card, NULL, propname)
int snd_soc_of_parse_audio_simple_widgets_from_node(struct snd_soc_card *card,
						    struct device_node *np,
						    const char *propname);

1659
int snd_soc_of_parse_tdm_slot(struct device_node *np,
1660 1661
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
1662 1663
			      unsigned int *slots,
			      unsigned int *slot_width);
1664 1665 1666 1667 1668
#define snd_soc_of_parse_audio_prefix(card, codec_conf, of_node, propname) \
	snd_soc_of_parse_audio_prefix_from_node(card, NULL, codec_conf, \
						of_node, propname)
void snd_soc_of_parse_audio_prefix_from_node(struct snd_soc_card *card,
				   struct device_node *np,
1669 1670 1671
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname);
1672 1673 1674 1675 1676 1677 1678

#define snd_soc_of_parse_audio_routing(card, propname) \
	snd_soc_of_parse_audio_routing_from_node(card, NULL, propname)
int snd_soc_of_parse_audio_routing_from_node(struct snd_soc_card *card,
					     struct device_node *np,
					     const char *propname);

1679
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1680 1681 1682
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster);
1683 1684
int snd_soc_get_dai_name(struct of_phandle_args *args,
			 const char **dai_name);
1685 1686
int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name);
1687 1688 1689
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link);
1690

1691 1692 1693 1694
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 已提交
1695 1696 1697
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
					       int id, const char *name,
					       const char *stream_name);
1698

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

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

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

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

1711 1712
extern const struct dev_pm_ops snd_soc_pm_ops;

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

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

1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
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);

1744
#endif