xref: /openbmc/linux/include/sound/soc.h (revision b34e08d5)
1 /*
2  * linux/sound/soc.h -- ALSA SoC Layer
3  *
4  * Author:		Liam Girdwood
5  * Created:		Aug 11th 2005
6  * Copyright:	Wolfson Microelectronics. PLC.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12 
13 #ifndef __LINUX_SND_SOC_H
14 #define __LINUX_SND_SOC_H
15 
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/types.h>
19 #include <linux/notifier.h>
20 #include <linux/workqueue.h>
21 #include <linux/interrupt.h>
22 #include <linux/kernel.h>
23 #include <linux/regmap.h>
24 #include <linux/log2.h>
25 #include <sound/core.h>
26 #include <sound/pcm.h>
27 #include <sound/compress_driver.h>
28 #include <sound/control.h>
29 #include <sound/ac97_codec.h>
30 
31 /*
32  * Convenience kcontrol builders
33  */
34 #define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
35 	((unsigned long)&(struct soc_mixer_control) \
36 	{.reg = xreg, .rreg = xreg, .shift = shift_left, \
37 	.rshift = shift_right, .max = xmax, .platform_max = xmax, \
38 	.invert = xinvert, .autodisable = xautodisable})
39 #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
40 	SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
41 #define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
42 	((unsigned long)&(struct soc_mixer_control) \
43 	{.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
44 #define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
45 	((unsigned long)&(struct soc_mixer_control) \
46 	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
47 	.max = xmax, .platform_max = xmax, .invert = xinvert})
48 #define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
49 	((unsigned long)&(struct soc_mixer_control) \
50 	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
51 	.max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
52 	.invert = xinvert})
53 #define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
54 	((unsigned long)&(struct soc_mixer_control) \
55 	{.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
56 	.min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
57 #define SOC_SINGLE(xname, reg, shift, max, invert) \
58 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
59 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
60 	.put = snd_soc_put_volsw, \
61 	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
62 #define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
63 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
64 	.info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
65 	.put = snd_soc_put_volsw_range, \
66 	.private_value = (unsigned long)&(struct soc_mixer_control) \
67 		{.reg = xreg, .rreg = xreg, .shift = xshift, \
68 		 .rshift = xshift,  .min = xmin, .max = xmax, \
69 		 .platform_max = xmax, .invert = xinvert} }
70 #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
71 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
72 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
73 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
74 	.tlv.p = (tlv_array), \
75 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
76 	.put = snd_soc_put_volsw, \
77 	.private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
78 #define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
79 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
80 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
81 	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
82 	.tlv.p  = (tlv_array),\
83 	.info = snd_soc_info_volsw, \
84 	.get = snd_soc_get_volsw_sx,\
85 	.put = snd_soc_put_volsw_sx, \
86 	.private_value = (unsigned long)&(struct soc_mixer_control) \
87 		{.reg = xreg, .rreg = xreg, \
88 		.shift = xshift, .rshift = xshift, \
89 		.max = xmax, .min = xmin} }
90 #define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
91 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
92 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
93 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
94 	.tlv.p = (tlv_array), \
95 	.info = snd_soc_info_volsw_range, \
96 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
97 	.private_value = (unsigned long)&(struct soc_mixer_control) \
98 		{.reg = xreg, .rreg = xreg, .shift = xshift, \
99 		 .rshift = xshift, .min = xmin, .max = xmax, \
100 		 .platform_max = xmax, .invert = xinvert} }
101 #define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
102 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
103 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
104 	.put = snd_soc_put_volsw, \
105 	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
106 					  max, invert, 0) }
107 #define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
108 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
109 	.info = snd_soc_info_volsw, \
110 	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
111 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
112 					    xmax, xinvert) }
113 #define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
114 			   xmax, xinvert)		\
115 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
116 	.info = snd_soc_info_volsw_range, \
117 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
118 	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
119 					    xshift, xmin, xmax, xinvert) }
120 #define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
121 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
122 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
123 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
124 	.tlv.p = (tlv_array), \
125 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
126 	.put = snd_soc_put_volsw, \
127 	.private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
128 					  max, invert, 0) }
129 #define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
130 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
131 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
132 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
133 	.tlv.p = (tlv_array), \
134 	.info = snd_soc_info_volsw, \
135 	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
136 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
137 					    xmax, xinvert) }
138 #define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
139 			       xmax, xinvert, tlv_array)		\
140 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
141 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
142 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
143 	.tlv.p = (tlv_array), \
144 	.info = snd_soc_info_volsw_range, \
145 	.get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
146 	.private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
147 					    xshift, xmin, xmax, xinvert) }
148 #define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, tlv_array) \
149 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
150 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
151 	SNDRV_CTL_ELEM_ACCESS_READWRITE, \
152 	.tlv.p  = (tlv_array), \
153 	.info = snd_soc_info_volsw, \
154 	.get = snd_soc_get_volsw_sx, \
155 	.put = snd_soc_put_volsw_sx, \
156 	.private_value = (unsigned long)&(struct soc_mixer_control) \
157 		{.reg = xreg, .rreg = xrreg, \
158 		.shift = xshift, .rshift = xshift, \
159 		.max = xmax, .min = xmin} }
160 #define SOC_DOUBLE_R_S_TLV(xname, reg_left, reg_right, xshift, xmin, xmax, xsign_bit, xinvert, tlv_array) \
161 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
162 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
163 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
164 	.tlv.p = (tlv_array), \
165 	.info = snd_soc_info_volsw, \
166 	.get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
167 	.private_value = SOC_DOUBLE_R_S_VALUE(reg_left, reg_right, xshift, \
168 					    xmin, xmax, xsign_bit, xinvert) }
169 #define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
170 {	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
171 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
172 		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
173 	.tlv.p  = (tlv_array), \
174 	.info   = snd_soc_info_volsw_s8, .get = snd_soc_get_volsw_s8, \
175 	.put    = snd_soc_put_volsw_s8, \
176 	.private_value = (unsigned long)&(struct soc_mixer_control) \
177 		{.reg = xreg, .min = xmin, .max = xmax, \
178 		 .platform_max = xmax} }
179 #define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
180 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
181 	.items = xitems, .texts = xtexts, \
182 	.mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
183 #define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
184 	SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
185 #define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
186 {	.items = xitems, .texts = xtexts }
187 #define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
188 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
189 	.mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
190 #define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xnitmes, xtexts, xvalues) \
191 	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xnitmes, xtexts, xvalues)
192 #define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
193 	SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
194 #define SOC_ENUM(xname, xenum) \
195 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
196 	.info = snd_soc_info_enum_double, \
197 	.get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
198 	.private_value = (unsigned long)&xenum }
199 #define SOC_VALUE_ENUM(xname, xenum) \
200 	SOC_ENUM(xname, xenum)
201 #define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
202 	 xhandler_get, xhandler_put) \
203 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
204 	.info = snd_soc_info_volsw, \
205 	.get = xhandler_get, .put = xhandler_put, \
206 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
207 #define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
208 	 xhandler_get, xhandler_put) \
209 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
210 	.info = snd_soc_info_volsw, \
211 	.get = xhandler_get, .put = xhandler_put, \
212 	.private_value = \
213 		SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
214 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
215 	 xhandler_get, xhandler_put, tlv_array) \
216 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
217 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
218 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
219 	.tlv.p = (tlv_array), \
220 	.info = snd_soc_info_volsw, \
221 	.get = xhandler_get, .put = xhandler_put, \
222 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
223 #define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
224 	 xhandler_get, xhandler_put, tlv_array) \
225 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
226 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
227 		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
228 	.tlv.p = (tlv_array), \
229 	.info = snd_soc_info_volsw, \
230 	.get = xhandler_get, .put = xhandler_put, \
231 	.private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
232 					  xmax, xinvert, 0) }
233 #define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
234 	 xhandler_get, xhandler_put, tlv_array) \
235 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
236 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
237 		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
238 	.tlv.p = (tlv_array), \
239 	.info = snd_soc_info_volsw, \
240 	.get = xhandler_get, .put = xhandler_put, \
241 	.private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
242 					    xmax, xinvert) }
243 #define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
244 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
245 	.info = snd_soc_info_bool_ext, \
246 	.get = xhandler_get, .put = xhandler_put, \
247 	.private_value = xdata }
248 #define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
249 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
250 	.info = snd_soc_info_enum_double, \
251 	.get = xhandler_get, .put = xhandler_put, \
252 	.private_value = (unsigned long)&xenum }
253 
254 #define SND_SOC_BYTES(xname, xbase, xregs)		      \
255 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
256 	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
257 	.put = snd_soc_bytes_put, .private_value =	      \
258 		((unsigned long)&(struct soc_bytes)           \
259 		{.base = xbase, .num_regs = xregs }) }
260 
261 #define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask)	      \
262 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,   \
263 	.info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
264 	.put = snd_soc_bytes_put, .private_value =	      \
265 		((unsigned long)&(struct soc_bytes)           \
266 		{.base = xbase, .num_regs = xregs,	      \
267 		 .mask = xmask }) }
268 
269 #define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
270 		xmin, xmax, xinvert) \
271 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
272 	.info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
273 	.put = snd_soc_put_xr_sx, \
274 	.private_value = (unsigned long)&(struct soc_mreg_control) \
275 		{.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
276 		.invert = xinvert, .min = xmin, .max = xmax} }
277 
278 #define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
279 	SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
280 		snd_soc_get_strobe, snd_soc_put_strobe)
281 
282 /*
283  * Simplified versions of above macros, declaring a struct and calculating
284  * ARRAY_SIZE internally
285  */
286 #define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
287 	const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
288 						ARRAY_SIZE(xtexts), xtexts)
289 #define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
290 	SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
291 #define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
292 	const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
293 #define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
294 	const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
295 							ARRAY_SIZE(xtexts), xtexts, xvalues)
296 #define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
297 	SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
298 #define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
299 	const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
300 
301 /*
302  * Component probe and remove ordering levels for components with runtime
303  * dependencies.
304  */
305 #define SND_SOC_COMP_ORDER_FIRST		-2
306 #define SND_SOC_COMP_ORDER_EARLY		-1
307 #define SND_SOC_COMP_ORDER_NORMAL		0
308 #define SND_SOC_COMP_ORDER_LATE		1
309 #define SND_SOC_COMP_ORDER_LAST		2
310 
311 /*
312  * Bias levels
313  *
314  * @ON:      Bias is fully on for audio playback and capture operations.
315  * @PREPARE: Prepare for audio operations. Called before DAPM switching for
316  *           stream start and stop operations.
317  * @STANDBY: Low power standby state when no playback/capture operations are
318  *           in progress. NOTE: The transition time between STANDBY and ON
319  *           should be as fast as possible and no longer than 10ms.
320  * @OFF:     Power Off. No restrictions on transition times.
321  */
322 enum snd_soc_bias_level {
323 	SND_SOC_BIAS_OFF = 0,
324 	SND_SOC_BIAS_STANDBY = 1,
325 	SND_SOC_BIAS_PREPARE = 2,
326 	SND_SOC_BIAS_ON = 3,
327 };
328 
329 struct device_node;
330 struct snd_jack;
331 struct snd_soc_card;
332 struct snd_soc_pcm_stream;
333 struct snd_soc_ops;
334 struct snd_soc_pcm_runtime;
335 struct snd_soc_dai;
336 struct snd_soc_dai_driver;
337 struct snd_soc_platform;
338 struct snd_soc_dai_link;
339 struct snd_soc_platform_driver;
340 struct snd_soc_codec;
341 struct snd_soc_codec_driver;
342 struct snd_soc_component;
343 struct snd_soc_component_driver;
344 struct soc_enum;
345 struct snd_soc_jack;
346 struct snd_soc_jack_zone;
347 struct snd_soc_jack_pin;
348 #include <sound/soc-dapm.h>
349 #include <sound/soc-dpcm.h>
350 
351 struct snd_soc_jack_gpio;
352 
353 typedef int (*hw_write_t)(void *,const char* ,int);
354 
355 extern struct snd_ac97_bus_ops *soc_ac97_ops;
356 
357 enum snd_soc_pcm_subclass {
358 	SND_SOC_PCM_CLASS_PCM	= 0,
359 	SND_SOC_PCM_CLASS_BE	= 1,
360 };
361 
362 enum snd_soc_card_subclass {
363 	SND_SOC_CARD_CLASS_INIT		= 0,
364 	SND_SOC_CARD_CLASS_RUNTIME	= 1,
365 };
366 
367 int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
368 			     int source, unsigned int freq, int dir);
369 int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
370 			  unsigned int freq_in, unsigned int freq_out);
371 
372 int snd_soc_register_card(struct snd_soc_card *card);
373 int snd_soc_unregister_card(struct snd_soc_card *card);
374 int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
375 int snd_soc_suspend(struct device *dev);
376 int snd_soc_resume(struct device *dev);
377 int snd_soc_poweroff(struct device *dev);
378 int snd_soc_register_platform(struct device *dev,
379 		const struct snd_soc_platform_driver *platform_drv);
380 void snd_soc_unregister_platform(struct device *dev);
381 int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
382 		const struct snd_soc_platform_driver *platform_drv);
383 void snd_soc_remove_platform(struct snd_soc_platform *platform);
384 struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev);
385 int snd_soc_register_codec(struct device *dev,
386 		const struct snd_soc_codec_driver *codec_drv,
387 		struct snd_soc_dai_driver *dai_drv, int num_dai);
388 void snd_soc_unregister_codec(struct device *dev);
389 int snd_soc_register_component(struct device *dev,
390 			 const struct snd_soc_component_driver *cmpnt_drv,
391 			 struct snd_soc_dai_driver *dai_drv, int num_dai);
392 int devm_snd_soc_register_component(struct device *dev,
393 			 const struct snd_soc_component_driver *cmpnt_drv,
394 			 struct snd_soc_dai_driver *dai_drv, int num_dai);
395 void snd_soc_unregister_component(struct device *dev);
396 int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
397 				    unsigned int reg);
398 int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
399 				    unsigned int reg);
400 int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
401 				    unsigned int reg);
402 int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
403 			       struct regmap *regmap);
404 int snd_soc_cache_sync(struct snd_soc_codec *codec);
405 int snd_soc_cache_init(struct snd_soc_codec *codec);
406 int snd_soc_cache_exit(struct snd_soc_codec *codec);
407 int snd_soc_cache_write(struct snd_soc_codec *codec,
408 			unsigned int reg, unsigned int value);
409 int snd_soc_cache_read(struct snd_soc_codec *codec,
410 		       unsigned int reg, unsigned int *value);
411 int snd_soc_platform_read(struct snd_soc_platform *platform,
412 					unsigned int reg);
413 int snd_soc_platform_write(struct snd_soc_platform *platform,
414 					unsigned int reg, unsigned int val);
415 int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
416 int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
417 
418 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
419 		const char *dai_link, int stream);
420 struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
421 		const char *dai_link);
422 
423 bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
424 void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd, int stream);
425 void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd, int stream);
426 
427 /* Utility functions to get clock rates from various things */
428 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
429 int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
430 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
431 int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
432 
433 /* set runtime hw params */
434 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
435 	const struct snd_pcm_hardware *hw);
436 
437 int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
438 		int cmd, struct snd_soc_platform *platform);
439 
440 /* Jack reporting */
441 int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
442 		     struct snd_soc_jack *jack);
443 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
444 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
445 			  struct snd_soc_jack_pin *pins);
446 void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
447 				    struct notifier_block *nb);
448 void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
449 				      struct notifier_block *nb);
450 int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
451 			  struct snd_soc_jack_zone *zones);
452 int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
453 #ifdef CONFIG_GPIOLIB
454 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
455 			struct snd_soc_jack_gpio *gpios);
456 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
457 			struct snd_soc_jack_gpio *gpios);
458 #else
459 static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
460 					 struct snd_soc_jack_gpio *gpios)
461 {
462 	return 0;
463 }
464 
465 static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
466 					   struct snd_soc_jack_gpio *gpios)
467 {
468 }
469 #endif
470 
471 /* codec register bit access */
472 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
473 				unsigned int mask, unsigned int value);
474 int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
475 			       unsigned short reg, unsigned int mask,
476 			       unsigned int value);
477 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
478 				unsigned int mask, unsigned int value);
479 
480 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
481 	struct snd_ac97_bus_ops *ops, int num);
482 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
483 
484 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
485 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
486 		struct platform_device *pdev);
487 
488 /*
489  *Controls
490  */
491 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
492 				  void *data, const char *long_name,
493 				  const char *prefix);
494 struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
495 					       const char *name);
496 int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
497 	const struct snd_kcontrol_new *controls, int num_controls);
498 int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
499 	const struct snd_kcontrol_new *controls, int num_controls);
500 int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
501 	const struct snd_kcontrol_new *controls, int num_controls);
502 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
503 	const struct snd_kcontrol_new *controls, int num_controls);
504 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
505 	struct snd_ctl_elem_info *uinfo);
506 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
507 	struct snd_ctl_elem_value *ucontrol);
508 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
509 	struct snd_ctl_elem_value *ucontrol);
510 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
511 	struct snd_ctl_elem_info *uinfo);
512 #define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
513 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
514 	struct snd_ctl_elem_value *ucontrol);
515 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
516 	struct snd_ctl_elem_value *ucontrol);
517 #define snd_soc_get_volsw_2r snd_soc_get_volsw
518 #define snd_soc_put_volsw_2r snd_soc_put_volsw
519 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
520 	struct snd_ctl_elem_value *ucontrol);
521 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
522 	struct snd_ctl_elem_value *ucontrol);
523 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
524 	struct snd_ctl_elem_info *uinfo);
525 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
526 	struct snd_ctl_elem_value *ucontrol);
527 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
528 	struct snd_ctl_elem_value *ucontrol);
529 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
530 	struct snd_ctl_elem_info *uinfo);
531 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
532 	struct snd_ctl_elem_value *ucontrol);
533 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
534 	struct snd_ctl_elem_value *ucontrol);
535 int snd_soc_limit_volume(struct snd_soc_codec *codec,
536 	const char *name, int max);
537 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
538 		       struct snd_ctl_elem_info *uinfo);
539 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
540 		      struct snd_ctl_elem_value *ucontrol);
541 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
542 		      struct snd_ctl_elem_value *ucontrol);
543 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
544 	struct snd_ctl_elem_info *uinfo);
545 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
546 	struct snd_ctl_elem_value *ucontrol);
547 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
548 	struct snd_ctl_elem_value *ucontrol);
549 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
550 	struct snd_ctl_elem_value *ucontrol);
551 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
552 	struct snd_ctl_elem_value *ucontrol);
553 
554 /**
555  * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
556  *
557  * @pin:    name of the pin to update
558  * @mask:   bits to check for in reported jack status
559  * @invert: if non-zero then pin is enabled when status is not reported
560  */
561 struct snd_soc_jack_pin {
562 	struct list_head list;
563 	const char *pin;
564 	int mask;
565 	bool invert;
566 };
567 
568 /**
569  * struct snd_soc_jack_zone - Describes voltage zones of jack detection
570  *
571  * @min_mv: start voltage in mv
572  * @max_mv: end voltage in mv
573  * @jack_type: type of jack that is expected for this voltage
574  * @debounce_time: debounce_time for jack, codec driver should wait for this
575  *		duration before reading the adc for voltages
576  * @:list: list container
577  */
578 struct snd_soc_jack_zone {
579 	unsigned int min_mv;
580 	unsigned int max_mv;
581 	unsigned int jack_type;
582 	unsigned int debounce_time;
583 	struct list_head list;
584 };
585 
586 /**
587  * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
588  *
589  * @gpio:         gpio number
590  * @name:         gpio name
591  * @report:       value to report when jack detected
592  * @invert:       report presence in low state
593  * @debouce_time: debouce time in ms
594  * @wake:	  enable as wake source
595  * @jack_status_check: callback function which overrides the detection
596  *		       to provide more complex checks (eg, reading an
597  *		       ADC).
598  */
599 struct snd_soc_jack_gpio {
600 	unsigned int gpio;
601 	const char *name;
602 	int report;
603 	int invert;
604 	int debounce_time;
605 	bool wake;
606 
607 	struct snd_soc_jack *jack;
608 	struct delayed_work work;
609 
610 	void *data;
611 	int (*jack_status_check)(void *data);
612 };
613 
614 struct snd_soc_jack {
615 	struct mutex mutex;
616 	struct snd_jack *jack;
617 	struct snd_soc_codec *codec;
618 	struct list_head pins;
619 	int status;
620 	struct blocking_notifier_head notifier;
621 	struct list_head jack_zones;
622 };
623 
624 /* SoC PCM stream information */
625 struct snd_soc_pcm_stream {
626 	const char *stream_name;
627 	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
628 	unsigned int rates;		/* SNDRV_PCM_RATE_* */
629 	unsigned int rate_min;		/* min rate */
630 	unsigned int rate_max;		/* max rate */
631 	unsigned int channels_min;	/* min channels */
632 	unsigned int channels_max;	/* max channels */
633 	unsigned int sig_bits;		/* number of bits of content */
634 };
635 
636 /* SoC audio ops */
637 struct snd_soc_ops {
638 	int (*startup)(struct snd_pcm_substream *);
639 	void (*shutdown)(struct snd_pcm_substream *);
640 	int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
641 	int (*hw_free)(struct snd_pcm_substream *);
642 	int (*prepare)(struct snd_pcm_substream *);
643 	int (*trigger)(struct snd_pcm_substream *, int);
644 };
645 
646 struct snd_soc_compr_ops {
647 	int (*startup)(struct snd_compr_stream *);
648 	void (*shutdown)(struct snd_compr_stream *);
649 	int (*set_params)(struct snd_compr_stream *);
650 	int (*trigger)(struct snd_compr_stream *);
651 };
652 
653 /* component interface */
654 struct snd_soc_component_driver {
655 	const char *name;
656 
657 	/* DT */
658 	int (*of_xlate_dai_name)(struct snd_soc_component *component,
659 				 struct of_phandle_args *args,
660 				 const char **dai_name);
661 };
662 
663 struct snd_soc_component {
664 	const char *name;
665 	int id;
666 	struct device *dev;
667 
668 	unsigned int active;
669 
670 	unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
671 
672 	struct list_head list;
673 
674 	struct snd_soc_dai_driver *dai_drv;
675 	int num_dai;
676 
677 	const struct snd_soc_component_driver *driver;
678 
679 	struct list_head dai_list;
680 };
681 
682 /* SoC Audio Codec device */
683 struct snd_soc_codec {
684 	const char *name;
685 	const char *name_prefix;
686 	int id;
687 	struct device *dev;
688 	const struct snd_soc_codec_driver *driver;
689 
690 	struct mutex mutex;
691 	struct snd_soc_card *card;
692 	struct list_head list;
693 	struct list_head card_list;
694 	int num_dai;
695 	int (*volatile_register)(struct snd_soc_codec *, unsigned int);
696 	int (*readable_register)(struct snd_soc_codec *, unsigned int);
697 	int (*writable_register)(struct snd_soc_codec *, unsigned int);
698 
699 	/* runtime */
700 	struct snd_ac97 *ac97;  /* for ad-hoc ac97 devices */
701 	unsigned int cache_bypass:1; /* Suppress access to the cache */
702 	unsigned int suspended:1; /* Codec is in suspend PM state */
703 	unsigned int probed:1; /* Codec has been probed */
704 	unsigned int ac97_registered:1; /* Codec has been AC97 registered */
705 	unsigned int ac97_created:1; /* Codec has been created by SoC */
706 	unsigned int cache_init:1; /* codec cache has been initialized */
707 	unsigned int using_regmap:1; /* using regmap access */
708 	u32 cache_only;  /* Suppress writes to hardware */
709 	u32 cache_sync; /* Cache needs to be synced to hardware */
710 
711 	/* codec IO */
712 	void *control_data; /* codec control (i2c/3wire) data */
713 	hw_write_t hw_write;
714 	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
715 	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
716 	void *reg_cache;
717 	struct mutex cache_rw_mutex;
718 	int val_bytes;
719 
720 	/* component */
721 	struct snd_soc_component component;
722 
723 	/* dapm */
724 	struct snd_soc_dapm_context dapm;
725 
726 #ifdef CONFIG_DEBUG_FS
727 	struct dentry *debugfs_codec_root;
728 	struct dentry *debugfs_reg;
729 #endif
730 };
731 
732 /* codec driver */
733 struct snd_soc_codec_driver {
734 
735 	/* driver ops */
736 	int (*probe)(struct snd_soc_codec *);
737 	int (*remove)(struct snd_soc_codec *);
738 	int (*suspend)(struct snd_soc_codec *);
739 	int (*resume)(struct snd_soc_codec *);
740 	struct snd_soc_component_driver component_driver;
741 
742 	/* Default control and setup, added after probe() is run */
743 	const struct snd_kcontrol_new *controls;
744 	int num_controls;
745 	const struct snd_soc_dapm_widget *dapm_widgets;
746 	int num_dapm_widgets;
747 	const struct snd_soc_dapm_route *dapm_routes;
748 	int num_dapm_routes;
749 
750 	/* codec wide operations */
751 	int (*set_sysclk)(struct snd_soc_codec *codec,
752 			  int clk_id, int source, unsigned int freq, int dir);
753 	int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
754 		unsigned int freq_in, unsigned int freq_out);
755 
756 	/* codec IO */
757 	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
758 	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
759 	int (*display_register)(struct snd_soc_codec *, char *,
760 				size_t, unsigned int);
761 	int (*volatile_register)(struct snd_soc_codec *, unsigned int);
762 	int (*readable_register)(struct snd_soc_codec *, unsigned int);
763 	int (*writable_register)(struct snd_soc_codec *, unsigned int);
764 	unsigned int reg_cache_size;
765 	short reg_cache_step;
766 	short reg_word_size;
767 	const void *reg_cache_default;
768 
769 	/* codec bias level */
770 	int (*set_bias_level)(struct snd_soc_codec *,
771 			      enum snd_soc_bias_level level);
772 	bool idle_bias_off;
773 
774 	void (*seq_notifier)(struct snd_soc_dapm_context *,
775 			     enum snd_soc_dapm_type, int);
776 
777 	/* codec stream completion event */
778 	int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
779 
780 	bool ignore_pmdown_time;  /* Doesn't benefit from pmdown delay */
781 
782 	/* probe ordering - for components with runtime dependencies */
783 	int probe_order;
784 	int remove_order;
785 };
786 
787 /* SoC platform interface */
788 struct snd_soc_platform_driver {
789 
790 	int (*probe)(struct snd_soc_platform *);
791 	int (*remove)(struct snd_soc_platform *);
792 	int (*suspend)(struct snd_soc_dai *dai);
793 	int (*resume)(struct snd_soc_dai *dai);
794 
795 	/* pcm creation and destruction */
796 	int (*pcm_new)(struct snd_soc_pcm_runtime *);
797 	void (*pcm_free)(struct snd_pcm *);
798 
799 	/* Default control and setup, added after probe() is run */
800 	const struct snd_kcontrol_new *controls;
801 	int num_controls;
802 	const struct snd_soc_dapm_widget *dapm_widgets;
803 	int num_dapm_widgets;
804 	const struct snd_soc_dapm_route *dapm_routes;
805 	int num_dapm_routes;
806 
807 	/*
808 	 * For platform caused delay reporting.
809 	 * Optional.
810 	 */
811 	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
812 		struct snd_soc_dai *);
813 
814 	/* platform stream pcm ops */
815 	const struct snd_pcm_ops *ops;
816 
817 	/* platform stream compress ops */
818 	const struct snd_compr_ops *compr_ops;
819 
820 	/* platform stream completion event */
821 	int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
822 
823 	/* probe ordering - for components with runtime dependencies */
824 	int probe_order;
825 	int remove_order;
826 
827 	/* platform IO - used for platform DAPM */
828 	unsigned int (*read)(struct snd_soc_platform *, unsigned int);
829 	int (*write)(struct snd_soc_platform *, unsigned int, unsigned int);
830 	int (*bespoke_trigger)(struct snd_pcm_substream *, int);
831 };
832 
833 struct snd_soc_platform {
834 	const char *name;
835 	int id;
836 	struct device *dev;
837 	const struct snd_soc_platform_driver *driver;
838 	struct mutex mutex;
839 
840 	unsigned int suspended:1; /* platform is suspended */
841 	unsigned int probed:1;
842 
843 	struct snd_soc_card *card;
844 	struct list_head list;
845 	struct list_head card_list;
846 
847 	struct snd_soc_dapm_context dapm;
848 
849 #ifdef CONFIG_DEBUG_FS
850 	struct dentry *debugfs_platform_root;
851 #endif
852 };
853 
854 struct snd_soc_dai_link {
855 	/* config - must be set by machine driver */
856 	const char *name;			/* Codec name */
857 	const char *stream_name;		/* Stream name */
858 	/*
859 	 * You MAY specify the link's CPU-side device, either by device name,
860 	 * or by DT/OF node, but not both. If this information is omitted,
861 	 * the CPU-side DAI is matched using .cpu_dai_name only, which hence
862 	 * must be globally unique. These fields are currently typically used
863 	 * only for codec to codec links, or systems using device tree.
864 	 */
865 	const char *cpu_name;
866 	const struct device_node *cpu_of_node;
867 	/*
868 	 * You MAY specify the DAI name of the CPU DAI. If this information is
869 	 * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
870 	 * only, which only works well when that device exposes a single DAI.
871 	 */
872 	const char *cpu_dai_name;
873 	/*
874 	 * You MUST specify the link's codec, either by device name, or by
875 	 * DT/OF node, but not both.
876 	 */
877 	const char *codec_name;
878 	const struct device_node *codec_of_node;
879 	/* You MUST specify the DAI name within the codec */
880 	const char *codec_dai_name;
881 	/*
882 	 * You MAY specify the link's platform/PCM/DMA driver, either by
883 	 * device name, or by DT/OF node, but not both. Some forms of link
884 	 * do not need a platform.
885 	 */
886 	const char *platform_name;
887 	const struct device_node *platform_of_node;
888 	int be_id;	/* optional ID for machine driver BE identification */
889 
890 	const struct snd_soc_pcm_stream *params;
891 
892 	unsigned int dai_fmt;           /* format to set on init */
893 
894 	enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
895 
896 	/* Keep DAI active over suspend */
897 	unsigned int ignore_suspend:1;
898 
899 	/* Symmetry requirements */
900 	unsigned int symmetric_rates:1;
901 	unsigned int symmetric_channels:1;
902 	unsigned int symmetric_samplebits:1;
903 
904 	/* Do not create a PCM for this DAI link (Backend link) */
905 	unsigned int no_pcm:1;
906 
907 	/* This DAI link can route to other DAI links at runtime (Frontend)*/
908 	unsigned int dynamic:1;
909 
910 	/* DPCM capture and Playback support */
911 	unsigned int dpcm_capture:1;
912 	unsigned int dpcm_playback:1;
913 
914 	/* pmdown_time is ignored at stop */
915 	unsigned int ignore_pmdown_time:1;
916 
917 	/* codec/machine specific init - e.g. add machine controls */
918 	int (*init)(struct snd_soc_pcm_runtime *rtd);
919 
920 	/* optional hw_params re-writing for BE and FE sync */
921 	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
922 			struct snd_pcm_hw_params *params);
923 
924 	/* machine stream operations */
925 	const struct snd_soc_ops *ops;
926 	const struct snd_soc_compr_ops *compr_ops;
927 
928 	/* For unidirectional dai links */
929 	bool playback_only;
930 	bool capture_only;
931 };
932 
933 struct snd_soc_codec_conf {
934 	const char *dev_name;
935 
936 	/*
937 	 * optional map of kcontrol, widget and path name prefixes that are
938 	 * associated per device
939 	 */
940 	const char *name_prefix;
941 };
942 
943 struct snd_soc_aux_dev {
944 	const char *name;		/* Codec name */
945 	const char *codec_name;		/* for multi-codec */
946 
947 	/* codec/machine specific init - e.g. add machine controls */
948 	int (*init)(struct snd_soc_dapm_context *dapm);
949 };
950 
951 /* SoC card */
952 struct snd_soc_card {
953 	const char *name;
954 	const char *long_name;
955 	const char *driver_name;
956 	struct device *dev;
957 	struct snd_card *snd_card;
958 	struct module *owner;
959 
960 	struct list_head list;
961 	struct mutex mutex;
962 	struct mutex dapm_mutex;
963 
964 	bool instantiated;
965 
966 	int (*probe)(struct snd_soc_card *card);
967 	int (*late_probe)(struct snd_soc_card *card);
968 	int (*remove)(struct snd_soc_card *card);
969 
970 	/* the pre and post PM functions are used to do any PM work before and
971 	 * after the codec and DAI's do any PM work. */
972 	int (*suspend_pre)(struct snd_soc_card *card);
973 	int (*suspend_post)(struct snd_soc_card *card);
974 	int (*resume_pre)(struct snd_soc_card *card);
975 	int (*resume_post)(struct snd_soc_card *card);
976 
977 	/* callbacks */
978 	int (*set_bias_level)(struct snd_soc_card *,
979 			      struct snd_soc_dapm_context *dapm,
980 			      enum snd_soc_bias_level level);
981 	int (*set_bias_level_post)(struct snd_soc_card *,
982 				   struct snd_soc_dapm_context *dapm,
983 				   enum snd_soc_bias_level level);
984 
985 	long pmdown_time;
986 
987 	/* CPU <--> Codec DAI links  */
988 	struct snd_soc_dai_link *dai_link;
989 	int num_links;
990 	struct snd_soc_pcm_runtime *rtd;
991 	int num_rtd;
992 
993 	/* optional codec specific configuration */
994 	struct snd_soc_codec_conf *codec_conf;
995 	int num_configs;
996 
997 	/*
998 	 * optional auxiliary devices such as amplifiers or codecs with DAI
999 	 * link unused
1000 	 */
1001 	struct snd_soc_aux_dev *aux_dev;
1002 	int num_aux_devs;
1003 	struct snd_soc_pcm_runtime *rtd_aux;
1004 	int num_aux_rtd;
1005 
1006 	const struct snd_kcontrol_new *controls;
1007 	int num_controls;
1008 
1009 	/*
1010 	 * Card-specific routes and widgets.
1011 	 */
1012 	const struct snd_soc_dapm_widget *dapm_widgets;
1013 	int num_dapm_widgets;
1014 	const struct snd_soc_dapm_route *dapm_routes;
1015 	int num_dapm_routes;
1016 	bool fully_routed;
1017 
1018 	struct work_struct deferred_resume_work;
1019 
1020 	/* lists of probed devices belonging to this card */
1021 	struct list_head codec_dev_list;
1022 	struct list_head platform_dev_list;
1023 	struct list_head dai_dev_list;
1024 
1025 	struct list_head widgets;
1026 	struct list_head paths;
1027 	struct list_head dapm_list;
1028 	struct list_head dapm_dirty;
1029 
1030 	/* Generic DAPM context for the card */
1031 	struct snd_soc_dapm_context dapm;
1032 	struct snd_soc_dapm_stats dapm_stats;
1033 	struct snd_soc_dapm_update *update;
1034 
1035 #ifdef CONFIG_DEBUG_FS
1036 	struct dentry *debugfs_card_root;
1037 	struct dentry *debugfs_pop_time;
1038 #endif
1039 	u32 pop_time;
1040 
1041 	void *drvdata;
1042 };
1043 
1044 /* SoC machine DAI configuration, glues a codec and cpu DAI together */
1045 struct snd_soc_pcm_runtime {
1046 	struct device *dev;
1047 	struct snd_soc_card *card;
1048 	struct snd_soc_dai_link *dai_link;
1049 	struct mutex pcm_mutex;
1050 	enum snd_soc_pcm_subclass pcm_subclass;
1051 	struct snd_pcm_ops ops;
1052 
1053 	unsigned int dev_registered:1;
1054 
1055 	/* Dynamic PCM BE runtime data */
1056 	struct snd_soc_dpcm_runtime dpcm[2];
1057 	int fe_compr;
1058 
1059 	long pmdown_time;
1060 	unsigned char pop_wait:1;
1061 
1062 	/* runtime devices */
1063 	struct snd_pcm *pcm;
1064 	struct snd_compr *compr;
1065 	struct snd_soc_codec *codec;
1066 	struct snd_soc_platform *platform;
1067 	struct snd_soc_dai *codec_dai;
1068 	struct snd_soc_dai *cpu_dai;
1069 
1070 	struct delayed_work delayed_work;
1071 #ifdef CONFIG_DEBUG_FS
1072 	struct dentry *debugfs_dpcm_root;
1073 	struct dentry *debugfs_dpcm_state;
1074 #endif
1075 };
1076 
1077 /* mixer control */
1078 struct soc_mixer_control {
1079 	int min, max, platform_max;
1080 	int reg, rreg;
1081 	unsigned int shift, rshift;
1082 	unsigned int sign_bit;
1083 	unsigned int invert:1;
1084 	unsigned int autodisable:1;
1085 };
1086 
1087 struct soc_bytes {
1088 	int base;
1089 	int num_regs;
1090 	u32 mask;
1091 };
1092 
1093 /* multi register control */
1094 struct soc_mreg_control {
1095 	long min, max;
1096 	unsigned int regbase, regcount, nbits, invert;
1097 };
1098 
1099 /* enumerated kcontrol */
1100 struct soc_enum {
1101 	int reg;
1102 	unsigned char shift_l;
1103 	unsigned char shift_r;
1104 	unsigned int items;
1105 	unsigned int mask;
1106 	const char * const *texts;
1107 	const unsigned int *values;
1108 };
1109 
1110 /**
1111  * snd_soc_component_to_codec() - Casts a component to the CODEC it is embedded in
1112  * @component: The component to cast to a CODEC
1113  *
1114  * This function must only be used on components that are known to be CODECs.
1115  * Otherwise the behavior is undefined.
1116  */
1117 static inline struct snd_soc_codec *snd_soc_component_to_codec(
1118 	struct snd_soc_component *component)
1119 {
1120 	return container_of(component, struct snd_soc_codec, component);
1121 }
1122 
1123 /* codec IO */
1124 unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1125 unsigned int snd_soc_write(struct snd_soc_codec *codec,
1126 			   unsigned int reg, unsigned int val);
1127 
1128 /* device driver data */
1129 
1130 static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
1131 		void *data)
1132 {
1133 	card->drvdata = data;
1134 }
1135 
1136 static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
1137 {
1138 	return card->drvdata;
1139 }
1140 
1141 static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1142 		void *data)
1143 {
1144 	dev_set_drvdata(codec->dev, data);
1145 }
1146 
1147 static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
1148 {
1149 	return dev_get_drvdata(codec->dev);
1150 }
1151 
1152 static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
1153 		void *data)
1154 {
1155 	dev_set_drvdata(platform->dev, data);
1156 }
1157 
1158 static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
1159 {
1160 	return dev_get_drvdata(platform->dev);
1161 }
1162 
1163 static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
1164 		void *data)
1165 {
1166 	dev_set_drvdata(rtd->dev, data);
1167 }
1168 
1169 static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
1170 {
1171 	return dev_get_drvdata(rtd->dev);
1172 }
1173 
1174 static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
1175 {
1176 	INIT_LIST_HEAD(&card->dai_dev_list);
1177 	INIT_LIST_HEAD(&card->codec_dev_list);
1178 	INIT_LIST_HEAD(&card->platform_dev_list);
1179 	INIT_LIST_HEAD(&card->widgets);
1180 	INIT_LIST_HEAD(&card->paths);
1181 	INIT_LIST_HEAD(&card->dapm_list);
1182 }
1183 
1184 static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1185 {
1186 	if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1187 		return 0;
1188 	/*
1189 	 * mc->reg == mc->rreg && mc->shift != mc->rshift, or
1190 	 * mc->reg != mc->rreg means that the control is
1191 	 * stereo (bits in one register or in two registers)
1192 	 */
1193 	return 1;
1194 }
1195 
1196 static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
1197 	unsigned int val)
1198 {
1199 	unsigned int i;
1200 
1201 	if (!e->values)
1202 		return val;
1203 
1204 	for (i = 0; i < e->items; i++)
1205 		if (val == e->values[i])
1206 			return i;
1207 
1208 	return 0;
1209 }
1210 
1211 static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
1212 	unsigned int item)
1213 {
1214 	if (!e->values)
1215 		return item;
1216 
1217 	return e->values[item];
1218 }
1219 
1220 static inline bool snd_soc_component_is_active(
1221 	struct snd_soc_component *component)
1222 {
1223 	return component->active != 0;
1224 }
1225 
1226 static inline bool snd_soc_codec_is_active(struct snd_soc_codec *codec)
1227 {
1228 	return snd_soc_component_is_active(&codec->component);
1229 }
1230 
1231 int snd_soc_util_init(void);
1232 void snd_soc_util_exit(void);
1233 
1234 int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1235 			       const char *propname);
1236 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1237 					  const char *propname);
1238 int snd_soc_of_parse_tdm_slot(struct device_node *np,
1239 			      unsigned int *slots,
1240 			      unsigned int *slot_width);
1241 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1242 				   const char *propname);
1243 unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1244 				     const char *prefix);
1245 int snd_soc_of_get_dai_name(struct device_node *of_node,
1246 			    const char **dai_name);
1247 
1248 #include <sound/soc-dai.h>
1249 
1250 #ifdef CONFIG_DEBUG_FS
1251 extern struct dentry *snd_soc_debugfs_root;
1252 #endif
1253 
1254 extern const struct dev_pm_ops snd_soc_pm_ops;
1255 
1256 /* Helper functions */
1257 static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
1258 {
1259 	mutex_lock(&dapm->card->dapm_mutex);
1260 }
1261 
1262 static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
1263 {
1264 	mutex_unlock(&dapm->card->dapm_mutex);
1265 }
1266 
1267 #endif
1268