1
2
3
4
5
6
7
8
9
10#ifndef __LINUX_SND_SOC_H
11#define __LINUX_SND_SOC_H
12
13#include <linux/of.h>
14#include <linux/platform_device.h>
15#include <linux/types.h>
16#include <linux/notifier.h>
17#include <linux/workqueue.h>
18#include <linux/interrupt.h>
19#include <linux/kernel.h>
20#include <linux/regmap.h>
21#include <linux/log2.h>
22#include <sound/core.h>
23#include <sound/pcm.h>
24#include <sound/compress_driver.h>
25#include <sound/control.h>
26#include <sound/ac97_codec.h>
27
28
29
30
31#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
32 ((unsigned long)&(struct soc_mixer_control) \
33 {.reg = xreg, .rreg = xreg, .shift = shift_left, \
34 .rshift = shift_right, .max = xmax, .platform_max = xmax, \
35 .invert = xinvert, .autodisable = xautodisable})
36#define SOC_DOUBLE_S_VALUE(xreg, shift_left, shift_right, xmin, xmax, xsign_bit, xinvert, xautodisable) \
37 ((unsigned long)&(struct soc_mixer_control) \
38 {.reg = xreg, .rreg = xreg, .shift = shift_left, \
39 .rshift = shift_right, .min = xmin, .max = xmax, .platform_max = xmax, \
40 .sign_bit = xsign_bit, .invert = xinvert, .autodisable = xautodisable})
41#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
42 SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
43#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
44 ((unsigned long)&(struct soc_mixer_control) \
45 {.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
46#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
47 ((unsigned long)&(struct soc_mixer_control) \
48 {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
49 .max = xmax, .platform_max = xmax, .invert = xinvert})
50#define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
51 ((unsigned long)&(struct soc_mixer_control) \
52 {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
53 .max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
54 .invert = xinvert})
55#define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
56 ((unsigned long)&(struct soc_mixer_control) \
57 {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
58 .min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
59#define SOC_SINGLE(xname, reg, shift, max, invert) \
60{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
61 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
62 .put = snd_soc_put_volsw, \
63 .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
64#define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
65{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
66 .info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
67 .put = snd_soc_put_volsw_range, \
68 .private_value = (unsigned long)&(struct soc_mixer_control) \
69 {.reg = xreg, .rreg = xreg, .shift = xshift, \
70 .rshift = xshift, .min = xmin, .max = xmax, \
71 .platform_max = xmax, .invert = xinvert} }
72#define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
73{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
74 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
75 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
76 .tlv.p = (tlv_array), \
77 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
78 .put = snd_soc_put_volsw, \
79 .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
80#define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
81{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
82 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
83 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
84 .tlv.p = (tlv_array),\
85 .info = snd_soc_info_volsw_sx, \
86 .get = snd_soc_get_volsw_sx,\
87 .put = snd_soc_put_volsw_sx, \
88 .private_value = (unsigned long)&(struct soc_mixer_control) \
89 {.reg = xreg, .rreg = xreg, \
90 .shift = xshift, .rshift = xshift, \
91 .max = xmax, .min = xmin} }
92#define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
93{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
94 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
95 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
96 .tlv.p = (tlv_array), \
97 .info = snd_soc_info_volsw_range, \
98 .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
99 .private_value = (unsigned long)&(struct soc_mixer_control) \
100 {.reg = xreg, .rreg = xreg, .shift = xshift, \
101 .rshift = xshift, .min = xmin, .max = xmax, \
102 .platform_max = xmax, .invert = xinvert} }
103#define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
104{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
105 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
106 .put = snd_soc_put_volsw, \
107 .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
108 max, invert, 0) }
109#define SOC_DOUBLE_STS(xname, reg, shift_left, shift_right, max, invert) \
110{ \
111 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
112 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
113 .access = SNDRV_CTL_ELEM_ACCESS_READ | \
114 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
115 .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
116 max, invert, 0) }
117#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
118{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
119 .info = snd_soc_info_volsw, \
120 .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
121 .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
122 xmax, xinvert) }
123#define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
124 xmax, xinvert) \
125{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
126 .info = snd_soc_info_volsw_range, \
127 .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
128 .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
129 xshift, xmin, xmax, xinvert) }
130#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
131{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
132 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
133 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
134 .tlv.p = (tlv_array), \
135 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
136 .put = snd_soc_put_volsw, \
137 .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
138 max, invert, 0) }
139#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, 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, \
145 .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
146 .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
147 xmax, xinvert) }
148#define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
149 xmax, xinvert, tlv_array) \
150{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
151 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
152 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
153 .tlv.p = (tlv_array), \
154 .info = snd_soc_info_volsw_range, \
155 .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
156 .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
157 xshift, xmin, xmax, xinvert) }
158#define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, tlv_array) \
159{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
160 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
161 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
162 .tlv.p = (tlv_array), \
163 .info = snd_soc_info_volsw_sx, \
164 .get = snd_soc_get_volsw_sx, \
165 .put = snd_soc_put_volsw_sx, \
166 .private_value = (unsigned long)&(struct soc_mixer_control) \
167 {.reg = xreg, .rreg = xrreg, \
168 .shift = xshift, .rshift = xshift, \
169 .max = xmax, .min = xmin} }
170#define SOC_DOUBLE_R_S_TLV(xname, reg_left, reg_right, xshift, xmin, xmax, xsign_bit, xinvert, tlv_array) \
171{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
172 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
173 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
174 .tlv.p = (tlv_array), \
175 .info = snd_soc_info_volsw, \
176 .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
177 .private_value = SOC_DOUBLE_R_S_VALUE(reg_left, reg_right, xshift, \
178 xmin, xmax, xsign_bit, xinvert) }
179#define SOC_SINGLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
180{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
181 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
182 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
183 .tlv.p = (tlv_array), \
184 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
185 .put = snd_soc_put_volsw, \
186 .private_value = (unsigned long)&(struct soc_mixer_control) \
187 {.reg = xreg, .rreg = xreg, \
188 .min = xmin, .max = xmax, .platform_max = xmax, \
189 .sign_bit = 7,} }
190#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
191{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
192 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
193 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
194 .tlv.p = (tlv_array), \
195 .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
196 .put = snd_soc_put_volsw, \
197 .private_value = SOC_DOUBLE_S_VALUE(xreg, 0, 8, xmin, xmax, 7, 0, 0) }
198#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
199{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
200 .items = xitems, .texts = xtexts, \
201 .mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
202#define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
203 SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
204#define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
205{ .items = xitems, .texts = xtexts }
206#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
207{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
208 .mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
209#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
210 SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xitems, xtexts, xvalues)
211#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, xshift, xmask, xitems, xtexts, xvalues) \
212{ .reg = xreg, .shift_l = xshift, .shift_r = xshift, \
213 .mask = xmask, .items = xitems, .texts = xtexts, \
214 .values = xvalues, .autodisable = 1}
215#define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
216 SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
217#define SOC_ENUM(xname, xenum) \
218{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
219 .info = snd_soc_info_enum_double, \
220 .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
221 .private_value = (unsigned long)&xenum }
222#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
223 xhandler_get, xhandler_put) \
224{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
225 .info = snd_soc_info_volsw, \
226 .get = xhandler_get, .put = xhandler_put, \
227 .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
228#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
229 xhandler_get, xhandler_put) \
230{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
231 .info = snd_soc_info_volsw, \
232 .get = xhandler_get, .put = xhandler_put, \
233 .private_value = \
234 SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
235#define SOC_DOUBLE_R_EXT(xname, reg_left, reg_right, xshift, xmax, xinvert,\
236 xhandler_get, xhandler_put) \
237{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
238 .info = snd_soc_info_volsw, \
239 .get = xhandler_get, .put = xhandler_put, \
240 .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
241 xmax, xinvert) }
242#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
243 xhandler_get, xhandler_put, tlv_array) \
244{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
245 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
246 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
247 .tlv.p = (tlv_array), \
248 .info = snd_soc_info_volsw, \
249 .get = xhandler_get, .put = xhandler_put, \
250 .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
251#define SOC_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
252 xhandler_get, xhandler_put, tlv_array) \
253{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
254 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
255 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
256 .tlv.p = (tlv_array), \
257 .info = snd_soc_info_volsw_range, \
258 .get = xhandler_get, .put = xhandler_put, \
259 .private_value = (unsigned long)&(struct soc_mixer_control) \
260 {.reg = xreg, .rreg = xreg, .shift = xshift, \
261 .rshift = xshift, .min = xmin, .max = xmax, \
262 .platform_max = xmax, .invert = xinvert} }
263#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
264 xhandler_get, xhandler_put, tlv_array) \
265{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
266 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
267 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
268 .tlv.p = (tlv_array), \
269 .info = snd_soc_info_volsw, \
270 .get = xhandler_get, .put = xhandler_put, \
271 .private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
272 xmax, xinvert, 0) }
273#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
274 xhandler_get, xhandler_put, tlv_array) \
275{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
276 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
277 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
278 .tlv.p = (tlv_array), \
279 .info = snd_soc_info_volsw, \
280 .get = xhandler_get, .put = xhandler_put, \
281 .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
282 xmax, xinvert) }
283#define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
284{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
285 .info = snd_soc_info_bool_ext, \
286 .get = xhandler_get, .put = xhandler_put, \
287 .private_value = xdata }
288#define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
289{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
290 .info = snd_soc_info_enum_double, \
291 .get = xhandler_get, .put = xhandler_put, \
292 .private_value = (unsigned long)&xenum }
293#define SOC_VALUE_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
294 SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put)
295
296#define SND_SOC_BYTES(xname, xbase, xregs) \
297{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
298 .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
299 .put = snd_soc_bytes_put, .private_value = \
300 ((unsigned long)&(struct soc_bytes) \
301 {.base = xbase, .num_regs = xregs }) }
302#define SND_SOC_BYTES_E(xname, xbase, xregs, xhandler_get, xhandler_put) \
303{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
304 .info = snd_soc_bytes_info, .get = xhandler_get, \
305 .put = xhandler_put, .private_value = \
306 ((unsigned long)&(struct soc_bytes) \
307 {.base = xbase, .num_regs = xregs }) }
308
309#define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask) \
310{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
311 .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
312 .put = snd_soc_bytes_put, .private_value = \
313 ((unsigned long)&(struct soc_bytes) \
314 {.base = xbase, .num_regs = xregs, \
315 .mask = xmask }) }
316
317
318
319
320#define SND_SOC_BYTES_EXT(xname, xcount, xhandler_get, xhandler_put) \
321{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
322 .info = snd_soc_bytes_info_ext, \
323 .get = xhandler_get, .put = xhandler_put, \
324 .private_value = (unsigned long)&(struct soc_bytes_ext) \
325 {.max = xcount} }
326#define SND_SOC_BYTES_TLV(xname, xcount, xhandler_get, xhandler_put) \
327{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
328 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE | \
329 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
330 .tlv.c = (snd_soc_bytes_tlv_callback), \
331 .info = snd_soc_bytes_info_ext, \
332 .private_value = (unsigned long)&(struct soc_bytes_ext) \
333 {.max = xcount, .get = xhandler_get, .put = xhandler_put, } }
334#define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
335 xmin, xmax, xinvert) \
336{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
337 .info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
338 .put = snd_soc_put_xr_sx, \
339 .private_value = (unsigned long)&(struct soc_mreg_control) \
340 {.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
341 .invert = xinvert, .min = xmin, .max = xmax} }
342
343#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
344 SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
345 snd_soc_get_strobe, snd_soc_put_strobe)
346
347
348
349
350
351#define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
352 const struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
353 ARRAY_SIZE(xtexts), xtexts)
354#define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
355 SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
356#define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
357 const struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
358#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
359 const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
360 ARRAY_SIZE(xtexts), xtexts, xvalues)
361#define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
362 SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
363
364#define SOC_VALUE_ENUM_SINGLE_AUTODISABLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
365 const struct soc_enum name = SOC_VALUE_ENUM_SINGLE_AUTODISABLE(xreg, \
366 xshift, xmask, ARRAY_SIZE(xtexts), xtexts, xvalues)
367
368#define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
369 const struct soc_enum name = SOC_ENUM_SINGLE_VIRT(ARRAY_SIZE(xtexts), xtexts)
370
371struct device_node;
372struct snd_jack;
373struct snd_soc_card;
374struct snd_soc_pcm_stream;
375struct snd_soc_ops;
376struct snd_soc_pcm_runtime;
377struct snd_soc_dai;
378struct snd_soc_dai_driver;
379struct snd_soc_dai_link;
380struct snd_soc_component;
381struct snd_soc_component_driver;
382struct soc_enum;
383struct snd_soc_jack;
384struct snd_soc_jack_zone;
385struct snd_soc_jack_pin;
386#include <sound/soc-dapm.h>
387#include <sound/soc-dpcm.h>
388#include <sound/soc-topology.h>
389
390struct snd_soc_jack_gpio;
391
392typedef int (*hw_write_t)(void *,const char* ,int);
393
394enum snd_soc_pcm_subclass {
395 SND_SOC_PCM_CLASS_PCM = 0,
396 SND_SOC_PCM_CLASS_BE = 1,
397};
398
399int snd_soc_register_card(struct snd_soc_card *card);
400int snd_soc_unregister_card(struct snd_soc_card *card);
401int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
402#ifdef CONFIG_PM_SLEEP
403int snd_soc_suspend(struct device *dev);
404int snd_soc_resume(struct device *dev);
405#else
406static inline int snd_soc_suspend(struct device *dev)
407{
408 return 0;
409}
410
411static inline int snd_soc_resume(struct device *dev)
412{
413 return 0;
414}
415#endif
416int snd_soc_poweroff(struct device *dev);
417int snd_soc_component_initialize(struct snd_soc_component *component,
418 const struct snd_soc_component_driver *driver,
419 struct device *dev);
420int snd_soc_add_component(struct snd_soc_component *component,
421 struct snd_soc_dai_driver *dai_drv,
422 int num_dai);
423int snd_soc_register_component(struct device *dev,
424 const struct snd_soc_component_driver *component_driver,
425 struct snd_soc_dai_driver *dai_drv, int num_dai);
426int devm_snd_soc_register_component(struct device *dev,
427 const struct snd_soc_component_driver *component_driver,
428 struct snd_soc_dai_driver *dai_drv, int num_dai);
429void snd_soc_unregister_component(struct device *dev);
430void snd_soc_unregister_component_by_driver(struct device *dev,
431 const struct snd_soc_component_driver *component_driver);
432struct snd_soc_component *snd_soc_lookup_component_nolocked(struct device *dev,
433 const char *driver_name);
434struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
435 const char *driver_name);
436
437int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
438#ifdef CONFIG_SND_SOC_COMPRESS
439int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
440#else
441static inline int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
442{
443 return 0;
444}
445#endif
446
447void snd_soc_disconnect_sync(struct device *dev);
448
449struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
450 struct snd_soc_dai_link *dai_link);
451
452bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
453
454void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
455 int stream, int action);
456static inline void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd,
457 int stream)
458{
459 snd_soc_runtime_action(rtd, stream, 1);
460}
461static inline void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd,
462 int stream)
463{
464 snd_soc_runtime_action(rtd, stream, -1);
465}
466
467int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
468 struct snd_pcm_hardware *hw, int stream);
469
470int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
471 unsigned int dai_fmt);
472
473#ifdef CONFIG_DMI
474int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour);
475#else
476static inline int snd_soc_set_dmi_name(struct snd_soc_card *card,
477 const char *flavour)
478{
479 return 0;
480}
481#endif
482
483
484int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
485int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
486int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
487int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
488
489
490int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
491 const struct snd_pcm_hardware *hw);
492
493
494void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
495int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
496 struct snd_soc_jack_pin *pins);
497void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
498 struct notifier_block *nb);
499void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
500 struct notifier_block *nb);
501int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
502 struct snd_soc_jack_zone *zones);
503int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
504#ifdef CONFIG_GPIOLIB
505int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
506 struct snd_soc_jack_gpio *gpios);
507int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
508 struct snd_soc_jack *jack,
509 int count, struct snd_soc_jack_gpio *gpios);
510void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
511 struct snd_soc_jack_gpio *gpios);
512#else
513static inline int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
514 struct snd_soc_jack_gpio *gpios)
515{
516 return 0;
517}
518
519static inline int snd_soc_jack_add_gpiods(struct device *gpiod_dev,
520 struct snd_soc_jack *jack,
521 int count,
522 struct snd_soc_jack_gpio *gpios)
523{
524 return 0;
525}
526
527static inline void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
528 struct snd_soc_jack_gpio *gpios)
529{
530}
531#endif
532
533struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
534struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
535 unsigned int id, unsigned int id_mask);
536void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
537
538#ifdef CONFIG_SND_SOC_AC97_BUS
539int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
540int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
541 struct platform_device *pdev);
542
543extern struct snd_ac97_bus_ops *soc_ac97_ops;
544#else
545static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
546 struct platform_device *pdev)
547{
548 return 0;
549}
550
551static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
552{
553 return 0;
554}
555#endif
556
557
558
559
560struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
561 void *data, const char *long_name,
562 const char *prefix);
563int snd_soc_add_component_controls(struct snd_soc_component *component,
564 const struct snd_kcontrol_new *controls, unsigned int num_controls);
565int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
566 const struct snd_kcontrol_new *controls, int num_controls);
567int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
568 const struct snd_kcontrol_new *controls, int num_controls);
569int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
570 struct snd_ctl_elem_info *uinfo);
571int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
572 struct snd_ctl_elem_value *ucontrol);
573int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
574 struct snd_ctl_elem_value *ucontrol);
575int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
576 struct snd_ctl_elem_info *uinfo);
577int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
578 struct snd_ctl_elem_info *uinfo);
579#define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
580int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
581 struct snd_ctl_elem_value *ucontrol);
582int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
583 struct snd_ctl_elem_value *ucontrol);
584#define snd_soc_get_volsw_2r snd_soc_get_volsw
585#define snd_soc_put_volsw_2r snd_soc_put_volsw
586int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
587 struct snd_ctl_elem_value *ucontrol);
588int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
589 struct snd_ctl_elem_value *ucontrol);
590int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
591 struct snd_ctl_elem_info *uinfo);
592int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
593 struct snd_ctl_elem_value *ucontrol);
594int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
595 struct snd_ctl_elem_value *ucontrol);
596int snd_soc_limit_volume(struct snd_soc_card *card,
597 const char *name, int max);
598int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
599 struct snd_ctl_elem_info *uinfo);
600int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
601 struct snd_ctl_elem_value *ucontrol);
602int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
603 struct snd_ctl_elem_value *ucontrol);
604int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
605 struct snd_ctl_elem_info *ucontrol);
606int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
607 unsigned int size, unsigned int __user *tlv);
608int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
609 struct snd_ctl_elem_info *uinfo);
610int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
611 struct snd_ctl_elem_value *ucontrol);
612int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
613 struct snd_ctl_elem_value *ucontrol);
614int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
615 struct snd_ctl_elem_value *ucontrol);
616int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
617 struct snd_ctl_elem_value *ucontrol);
618
619
620
621
622
623
624
625
626
627struct snd_soc_jack_pin {
628 struct list_head list;
629 const char *pin;
630 int mask;
631 bool invert;
632};
633
634
635
636
637
638
639
640
641
642
643
644struct snd_soc_jack_zone {
645 unsigned int min_mv;
646 unsigned int max_mv;
647 unsigned int jack_type;
648 unsigned int debounce_time;
649 struct list_head list;
650};
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669struct snd_soc_jack_gpio {
670 unsigned int gpio;
671 unsigned int idx;
672 struct device *gpiod_dev;
673 const char *name;
674 int report;
675 int invert;
676 int debounce_time;
677 bool wake;
678
679
680 struct snd_soc_jack *jack;
681 struct delayed_work work;
682 struct notifier_block pm_notifier;
683 struct gpio_desc *desc;
684
685 void *data;
686
687 int (*jack_status_check)(void *data);
688};
689
690struct snd_soc_jack {
691 struct mutex mutex;
692 struct snd_jack *jack;
693 struct snd_soc_card *card;
694 struct list_head pins;
695 int status;
696 struct blocking_notifier_head notifier;
697 struct list_head jack_zones;
698};
699
700
701struct snd_soc_pcm_stream {
702 const char *stream_name;
703 u64 formats;
704 unsigned int rates;
705 unsigned int rate_min;
706 unsigned int rate_max;
707 unsigned int channels_min;
708 unsigned int channels_max;
709 unsigned int sig_bits;
710};
711
712
713struct snd_soc_ops {
714 int (*startup)(struct snd_pcm_substream *);
715 void (*shutdown)(struct snd_pcm_substream *);
716 int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
717 int (*hw_free)(struct snd_pcm_substream *);
718 int (*prepare)(struct snd_pcm_substream *);
719 int (*trigger)(struct snd_pcm_substream *, int);
720};
721
722struct snd_soc_compr_ops {
723 int (*startup)(struct snd_compr_stream *);
724 void (*shutdown)(struct snd_compr_stream *);
725 int (*set_params)(struct snd_compr_stream *);
726 int (*trigger)(struct snd_compr_stream *);
727};
728
729struct snd_soc_component*
730snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
731 const char *driver_name);
732
733struct snd_soc_dai_link_component {
734 const char *name;
735 struct device_node *of_node;
736 const char *dai_name;
737};
738
739struct snd_soc_dai_link {
740
741 const char *name;
742 const char *stream_name;
743
744
745
746
747
748
749
750
751
752
753
754
755
756 struct snd_soc_dai_link_component *cpus;
757 unsigned int num_cpus;
758
759
760
761
762
763
764 struct snd_soc_dai_link_component *codecs;
765 unsigned int num_codecs;
766
767
768
769
770
771
772 struct snd_soc_dai_link_component *platforms;
773 unsigned int num_platforms;
774
775 int id;
776
777 const struct snd_soc_pcm_stream *params;
778 unsigned int num_params;
779
780 unsigned int dai_fmt;
781
782 enum snd_soc_dpcm_trigger trigger[2];
783
784
785 int (*init)(struct snd_soc_pcm_runtime *rtd);
786
787
788 void (*exit)(struct snd_soc_pcm_runtime *rtd);
789
790
791 int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
792 struct snd_pcm_hw_params *params);
793
794
795 const struct snd_soc_ops *ops;
796 const struct snd_soc_compr_ops *compr_ops;
797
798
799 unsigned int nonatomic:1;
800
801
802 unsigned int playback_only:1;
803 unsigned int capture_only:1;
804
805
806 unsigned int ignore_suspend:1;
807
808
809 unsigned int symmetric_rates:1;
810 unsigned int symmetric_channels:1;
811 unsigned int symmetric_samplebits:1;
812
813
814 unsigned int no_pcm:1;
815
816
817 unsigned int dynamic:1;
818
819
820 unsigned int dpcm_capture:1;
821 unsigned int dpcm_playback:1;
822
823
824 unsigned int dpcm_merged_format:1;
825
826 unsigned int dpcm_merged_chan:1;
827
828 unsigned int dpcm_merged_rate:1;
829
830
831 unsigned int ignore_pmdown_time:1;
832
833
834 unsigned int ignore:1;
835
836#ifdef CONFIG_SND_SOC_TOPOLOGY
837 struct snd_soc_dobj dobj;
838#endif
839};
840#define for_each_link_codecs(link, i, codec) \
841 for ((i) = 0; \
842 ((i) < link->num_codecs) && ((codec) = &link->codecs[i]); \
843 (i)++)
844
845#define for_each_link_platforms(link, i, platform) \
846 for ((i) = 0; \
847 ((i) < link->num_platforms) && \
848 ((platform) = &link->platforms[i]); \
849 (i)++)
850
851#define for_each_link_cpus(link, i, cpu) \
852 for ((i) = 0; \
853 ((i) < link->num_cpus) && ((cpu) = &link->cpus[i]); \
854 (i)++)
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909#define SND_SOC_DAILINK_REG1(name) SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
910#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
911#define SND_SOC_DAILINK_REG3(cpu, codec, platform) \
912 .cpus = cpu, \
913 .num_cpus = ARRAY_SIZE(cpu), \
914 .codecs = codec, \
915 .num_codecs = ARRAY_SIZE(codec), \
916 .platforms = platform, \
917 .num_platforms = ARRAY_SIZE(platform)
918
919#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
920#define SND_SOC_DAILINK_REG(...) \
921 SND_SOC_DAILINK_REGx(__VA_ARGS__, \
922 SND_SOC_DAILINK_REG3, \
923 SND_SOC_DAILINK_REG2, \
924 SND_SOC_DAILINK_REG1)(__VA_ARGS__)
925
926#define SND_SOC_DAILINK_DEF(name, def...) \
927 static struct snd_soc_dai_link_component name[] = { def }
928
929#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...) \
930 SND_SOC_DAILINK_DEF(name##_cpus, cpu); \
931 SND_SOC_DAILINK_DEF(name##_codecs, codec); \
932 SND_SOC_DAILINK_DEF(name##_platforms, platform)
933
934#define DAILINK_COMP_ARRAY(param...) param
935#define COMP_EMPTY() { }
936#define COMP_CPU(_dai) { .dai_name = _dai, }
937#define COMP_CODEC(_name, _dai) { .name = _name, .dai_name = _dai, }
938#define COMP_PLATFORM(_name) { .name = _name }
939#define COMP_AUX(_name) { .name = _name }
940#define COMP_CODEC_CONF(_name) { .name = _name }
941#define COMP_DUMMY() { .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }
942
943extern struct snd_soc_dai_link_component null_dailink_component[0];
944
945
946struct snd_soc_codec_conf {
947
948
949
950
951 struct snd_soc_dai_link_component dlc;
952
953
954
955
956
957 const char *name_prefix;
958};
959
960struct snd_soc_aux_dev {
961
962
963
964
965 struct snd_soc_dai_link_component dlc;
966
967
968 int (*init)(struct snd_soc_component *component);
969};
970
971
972struct snd_soc_card {
973 const char *name;
974 const char *long_name;
975 const char *driver_name;
976 const char *components;
977#ifdef CONFIG_DMI
978 char dmi_longname[80];
979#endif
980 char topology_shortname[32];
981
982 struct device *dev;
983 struct snd_card *snd_card;
984 struct module *owner;
985
986 struct mutex mutex;
987 struct mutex dapm_mutex;
988
989
990 struct mutex pcm_mutex;
991 enum snd_soc_pcm_subclass pcm_subclass;
992
993 spinlock_t dpcm_lock;
994
995 int (*probe)(struct snd_soc_card *card);
996 int (*late_probe)(struct snd_soc_card *card);
997 int (*remove)(struct snd_soc_card *card);
998
999
1000
1001 int (*suspend_pre)(struct snd_soc_card *card);
1002 int (*suspend_post)(struct snd_soc_card *card);
1003 int (*resume_pre)(struct snd_soc_card *card);
1004 int (*resume_post)(struct snd_soc_card *card);
1005
1006
1007 int (*set_bias_level)(struct snd_soc_card *,
1008 struct snd_soc_dapm_context *dapm,
1009 enum snd_soc_bias_level level);
1010 int (*set_bias_level_post)(struct snd_soc_card *,
1011 struct snd_soc_dapm_context *dapm,
1012 enum snd_soc_bias_level level);
1013
1014 int (*add_dai_link)(struct snd_soc_card *,
1015 struct snd_soc_dai_link *link);
1016 void (*remove_dai_link)(struct snd_soc_card *,
1017 struct snd_soc_dai_link *link);
1018
1019 long pmdown_time;
1020
1021
1022 struct snd_soc_dai_link *dai_link;
1023 int num_links;
1024
1025 struct list_head rtd_list;
1026 int num_rtd;
1027
1028
1029 struct snd_soc_codec_conf *codec_conf;
1030 int num_configs;
1031
1032
1033
1034
1035
1036 struct snd_soc_aux_dev *aux_dev;
1037 int num_aux_devs;
1038 struct list_head aux_comp_list;
1039
1040 const struct snd_kcontrol_new *controls;
1041 int num_controls;
1042
1043
1044
1045
1046
1047 const struct snd_soc_dapm_widget *dapm_widgets;
1048 int num_dapm_widgets;
1049 const struct snd_soc_dapm_route *dapm_routes;
1050 int num_dapm_routes;
1051 const struct snd_soc_dapm_widget *of_dapm_widgets;
1052 int num_of_dapm_widgets;
1053 const struct snd_soc_dapm_route *of_dapm_routes;
1054 int num_of_dapm_routes;
1055
1056
1057 struct list_head component_dev_list;
1058 struct list_head list;
1059
1060 struct list_head widgets;
1061 struct list_head paths;
1062 struct list_head dapm_list;
1063 struct list_head dapm_dirty;
1064
1065
1066 struct list_head dobj_list;
1067
1068
1069 struct snd_soc_dapm_context dapm;
1070 struct snd_soc_dapm_stats dapm_stats;
1071 struct snd_soc_dapm_update *update;
1072
1073#ifdef CONFIG_DEBUG_FS
1074 struct dentry *debugfs_card_root;
1075#endif
1076#ifdef CONFIG_PM_SLEEP
1077 struct work_struct deferred_resume_work;
1078#endif
1079 u32 pop_time;
1080
1081
1082 unsigned int instantiated:1;
1083 unsigned int topology_shortname_created:1;
1084 unsigned int fully_routed:1;
1085 unsigned int disable_route_checks:1;
1086 unsigned int probed:1;
1087
1088 void *drvdata;
1089};
1090#define for_each_card_prelinks(card, i, link) \
1091 for ((i) = 0; \
1092 ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
1093 (i)++)
1094#define for_each_card_pre_auxs(card, i, aux) \
1095 for ((i) = 0; \
1096 ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
1097 (i)++)
1098
1099#define for_each_card_rtds(card, rtd) \
1100 list_for_each_entry(rtd, &(card)->rtd_list, list)
1101#define for_each_card_rtds_safe(card, rtd, _rtd) \
1102 list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
1103
1104#define for_each_card_auxs(card, component) \
1105 list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
1106#define for_each_card_auxs_safe(card, component, _comp) \
1107 list_for_each_entry_safe(component, _comp, \
1108 &card->aux_comp_list, card_aux_list)
1109
1110#define for_each_card_components(card, component) \
1111 list_for_each_entry(component, &(card)->component_dev_list, card_list)
1112
1113#define for_each_card_dapms(card, dapm) \
1114 list_for_each_entry(dapm, &card->dapm_list, list)
1115
1116#define for_each_card_widgets(card, w)\
1117 list_for_each_entry(w, &card->widgets, list)
1118#define for_each_card_widgets_safe(card, w, _w) \
1119 list_for_each_entry_safe(w, _w, &card->widgets, list)
1120
1121
1122struct snd_soc_pcm_runtime {
1123 struct device *dev;
1124 struct snd_soc_card *card;
1125 struct snd_soc_dai_link *dai_link;
1126 struct snd_pcm_ops ops;
1127
1128 unsigned int params_select;
1129
1130
1131 struct snd_soc_dpcm_runtime dpcm[2];
1132
1133 long pmdown_time;
1134
1135
1136 struct snd_pcm *pcm;
1137 struct snd_compr *compr;
1138
1139
1140
1141
1142
1143
1144
1145
1146 struct snd_soc_dai **dais;
1147 unsigned int num_codecs;
1148 unsigned int num_cpus;
1149
1150 struct snd_soc_dapm_widget *playback_widget;
1151 struct snd_soc_dapm_widget *capture_widget;
1152
1153 struct delayed_work delayed_work;
1154 void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
1155#ifdef CONFIG_DEBUG_FS
1156 struct dentry *debugfs_dpcm_root;
1157#endif
1158
1159 unsigned int num;
1160 struct list_head list;
1161
1162
1163 struct snd_pcm_substream *mark_startup;
1164
1165
1166 unsigned int pop_wait:1;
1167 unsigned int fe_compr:1;
1168
1169 int num_components;
1170 struct snd_soc_component *components[];
1171};
1172
1173#define asoc_rtd_to_cpu(rtd, n) (rtd)->dais[n]
1174#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
1175#define asoc_substream_to_rtd(substream) \
1176 (struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
1177
1178#define for_each_rtd_components(rtd, i, component) \
1179 for ((i) = 0, component = NULL; \
1180 ((i) < rtd->num_components) && ((component) = rtd->components[i]);\
1181 (i)++)
1182#define for_each_rtd_cpu_dais(rtd, i, dai) \
1183 for ((i) = 0; \
1184 ((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
1185 (i)++)
1186#define for_each_rtd_cpu_dais_rollback(rtd, i, dai) \
1187 for (; (--(i) >= 0) && ((dai) = asoc_rtd_to_cpu(rtd, i));)
1188#define for_each_rtd_codec_dais(rtd, i, dai) \
1189 for ((i) = 0; \
1190 ((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
1191 (i)++)
1192#define for_each_rtd_codec_dais_rollback(rtd, i, dai) \
1193 for (; (--(i) >= 0) && ((dai) = asoc_rtd_to_codec(rtd, i));)
1194#define for_each_rtd_dais(rtd, i, dai) \
1195 for ((i) = 0; \
1196 ((i) < (rtd)->num_cpus + (rtd)->num_codecs) && \
1197 ((dai) = (rtd)->dais[i]); \
1198 (i)++)
1199#define for_each_rtd_dais_rollback(rtd, i, dai) \
1200 for (; (--(i) >= 0) && ((dai) = (rtd)->dais[i]);)
1201
1202void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
1203
1204
1205struct soc_mixer_control {
1206 int min, max, platform_max;
1207 int reg, rreg;
1208 unsigned int shift, rshift;
1209 unsigned int sign_bit;
1210 unsigned int invert:1;
1211 unsigned int autodisable:1;
1212#ifdef CONFIG_SND_SOC_TOPOLOGY
1213 struct snd_soc_dobj dobj;
1214#endif
1215};
1216
1217struct soc_bytes {
1218 int base;
1219 int num_regs;
1220 u32 mask;
1221};
1222
1223struct soc_bytes_ext {
1224 int max;
1225#ifdef CONFIG_SND_SOC_TOPOLOGY
1226 struct snd_soc_dobj dobj;
1227#endif
1228
1229 int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
1230 unsigned int size);
1231 int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
1232 unsigned int size);
1233};
1234
1235
1236struct soc_mreg_control {
1237 long min, max;
1238 unsigned int regbase, regcount, nbits, invert;
1239};
1240
1241
1242struct soc_enum {
1243 int reg;
1244 unsigned char shift_l;
1245 unsigned char shift_r;
1246 unsigned int items;
1247 unsigned int mask;
1248 const char * const *texts;
1249 const unsigned int *values;
1250 unsigned int autodisable:1;
1251#ifdef CONFIG_SND_SOC_TOPOLOGY
1252 struct snd_soc_dobj dobj;
1253#endif
1254};
1255
1256static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1257{
1258 if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1259 return false;
1260
1261
1262
1263
1264
1265 return true;
1266}
1267
1268static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
1269 unsigned int val)
1270{
1271 unsigned int i;
1272
1273 if (!e->values)
1274 return val;
1275
1276 for (i = 0; i < e->items; i++)
1277 if (val == e->values[i])
1278 return i;
1279
1280 return 0;
1281}
1282
1283static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
1284 unsigned int item)
1285{
1286 if (!e->values)
1287 return item;
1288
1289 return e->values[item];
1290}
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302static inline struct snd_soc_component *snd_soc_kcontrol_component(
1303 struct snd_kcontrol *kcontrol)
1304{
1305 return snd_kcontrol_chip(kcontrol);
1306}
1307
1308int snd_soc_util_init(void);
1309void snd_soc_util_exit(void);
1310
1311int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1312 const char *propname);
1313int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1314 const char *propname);
1315int snd_soc_of_get_slot_mask(struct device_node *np,
1316 const char *prop_name,
1317 unsigned int *mask);
1318int snd_soc_of_parse_tdm_slot(struct device_node *np,
1319 unsigned int *tx_mask,
1320 unsigned int *rx_mask,
1321 unsigned int *slots,
1322 unsigned int *slot_width);
1323void snd_soc_of_parse_node_prefix(struct device_node *np,
1324 struct snd_soc_codec_conf *codec_conf,
1325 struct device_node *of_node,
1326 const char *propname);
1327static inline
1328void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1329 struct snd_soc_codec_conf *codec_conf,
1330 struct device_node *of_node,
1331 const char *propname)
1332{
1333 snd_soc_of_parse_node_prefix(card->dev->of_node,
1334 codec_conf, of_node, propname);
1335}
1336
1337int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1338 const char *propname);
1339int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
1340unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1341 const char *prefix,
1342 struct device_node **bitclkmaster,
1343 struct device_node **framemaster);
1344int snd_soc_get_dai_id(struct device_node *ep);
1345int snd_soc_get_dai_name(struct of_phandle_args *args,
1346 const char **dai_name);
1347int snd_soc_of_get_dai_name(struct device_node *of_node,
1348 const char **dai_name);
1349int snd_soc_of_get_dai_link_codecs(struct device *dev,
1350 struct device_node *of_node,
1351 struct snd_soc_dai_link *dai_link);
1352void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1353
1354int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
1355 struct snd_soc_dai_link *dai_link);
1356void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
1357 struct snd_soc_pcm_runtime *rtd);
1358
1359struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
1360 struct snd_soc_dai_driver *dai_drv,
1361 bool legacy_dai_naming);
1362struct snd_soc_dai *devm_snd_soc_register_dai(struct device *dev,
1363 struct snd_soc_component *component,
1364 struct snd_soc_dai_driver *dai_drv,
1365 bool legacy_dai_naming);
1366void snd_soc_unregister_dai(struct snd_soc_dai *dai);
1367
1368struct snd_soc_dai *snd_soc_find_dai(
1369 const struct snd_soc_dai_link_component *dlc);
1370struct snd_soc_dai *snd_soc_find_dai_with_mutex(
1371 const struct snd_soc_dai_link_component *dlc);
1372
1373#include <sound/soc-dai.h>
1374
1375static inline
1376int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
1377 const char *platform_name)
1378{
1379 struct snd_soc_dai_link *dai_link;
1380 const char *name;
1381 int i;
1382
1383 if (!platform_name)
1384 return 0;
1385
1386
1387 for_each_card_prelinks(card, i, dai_link) {
1388 name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
1389 if (!name)
1390 return -ENOMEM;
1391
1392 if (!dai_link->platforms)
1393 return -EINVAL;
1394
1395
1396 dai_link->platforms->name = name;
1397 }
1398
1399 return 0;
1400}
1401
1402#ifdef CONFIG_DEBUG_FS
1403extern struct dentry *snd_soc_debugfs_root;
1404#endif
1405
1406extern const struct dev_pm_ops snd_soc_pm_ops;
1407
1408
1409static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
1410{
1411 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1412}
1413
1414static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
1415{
1416 mutex_unlock(&dapm->card->dapm_mutex);
1417}
1418
1419#include <sound/soc-component.h>
1420#include <sound/soc-card.h>
1421
1422#endif
1423