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
493struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
494struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
495 unsigned int id, unsigned int id_mask);
496void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
497
498#ifdef CONFIG_SND_SOC_AC97_BUS
499int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
500int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
501 struct platform_device *pdev);
502
503extern struct snd_ac97_bus_ops *soc_ac97_ops;
504#else
505static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
506 struct platform_device *pdev)
507{
508 return 0;
509}
510
511static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
512{
513 return 0;
514}
515#endif
516
517
518
519
520struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
521 void *data, const char *long_name,
522 const char *prefix);
523int snd_soc_add_component_controls(struct snd_soc_component *component,
524 const struct snd_kcontrol_new *controls, unsigned int num_controls);
525int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
526 const struct snd_kcontrol_new *controls, int num_controls);
527int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
528 const struct snd_kcontrol_new *controls, int num_controls);
529int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
530 struct snd_ctl_elem_info *uinfo);
531int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_value *ucontrol);
533int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
534 struct snd_ctl_elem_value *ucontrol);
535int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
536 struct snd_ctl_elem_info *uinfo);
537int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
538 struct snd_ctl_elem_info *uinfo);
539#define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
540int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
541 struct snd_ctl_elem_value *ucontrol);
542int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
543 struct snd_ctl_elem_value *ucontrol);
544#define snd_soc_get_volsw_2r snd_soc_get_volsw
545#define snd_soc_put_volsw_2r snd_soc_put_volsw
546int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
547 struct snd_ctl_elem_value *ucontrol);
548int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
549 struct snd_ctl_elem_value *ucontrol);
550int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
551 struct snd_ctl_elem_info *uinfo);
552int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
553 struct snd_ctl_elem_value *ucontrol);
554int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
555 struct snd_ctl_elem_value *ucontrol);
556int snd_soc_limit_volume(struct snd_soc_card *card,
557 const char *name, int max);
558int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
559 struct snd_ctl_elem_info *uinfo);
560int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
561 struct snd_ctl_elem_value *ucontrol);
562int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_value *ucontrol);
564int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
565 struct snd_ctl_elem_info *ucontrol);
566int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
567 unsigned int size, unsigned int __user *tlv);
568int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_info *uinfo);
570int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
571 struct snd_ctl_elem_value *ucontrol);
572int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
573 struct snd_ctl_elem_value *ucontrol);
574int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_value *ucontrol);
576int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
577 struct snd_ctl_elem_value *ucontrol);
578
579
580struct snd_soc_pcm_stream {
581 const char *stream_name;
582 u64 formats;
583 unsigned int rates;
584 unsigned int rate_min;
585 unsigned int rate_max;
586 unsigned int channels_min;
587 unsigned int channels_max;
588 unsigned int sig_bits;
589};
590
591
592struct snd_soc_ops {
593 int (*startup)(struct snd_pcm_substream *);
594 void (*shutdown)(struct snd_pcm_substream *);
595 int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
596 int (*hw_free)(struct snd_pcm_substream *);
597 int (*prepare)(struct snd_pcm_substream *);
598 int (*trigger)(struct snd_pcm_substream *, int);
599};
600
601struct snd_soc_compr_ops {
602 int (*startup)(struct snd_compr_stream *);
603 void (*shutdown)(struct snd_compr_stream *);
604 int (*set_params)(struct snd_compr_stream *);
605 int (*trigger)(struct snd_compr_stream *);
606};
607
608struct snd_soc_component*
609snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
610 const char *driver_name);
611
612struct snd_soc_dai_link_component {
613 const char *name;
614 struct device_node *of_node;
615 const char *dai_name;
616};
617
618struct snd_soc_dai_link {
619
620 const char *name;
621 const char *stream_name;
622
623
624
625
626
627
628
629
630
631
632
633
634
635 struct snd_soc_dai_link_component *cpus;
636 unsigned int num_cpus;
637
638
639
640
641
642
643 struct snd_soc_dai_link_component *codecs;
644 unsigned int num_codecs;
645
646
647
648
649
650
651 struct snd_soc_dai_link_component *platforms;
652 unsigned int num_platforms;
653
654 int id;
655
656 const struct snd_soc_pcm_stream *params;
657 unsigned int num_params;
658
659 unsigned int dai_fmt;
660
661 enum snd_soc_dpcm_trigger trigger[2];
662
663
664 int (*init)(struct snd_soc_pcm_runtime *rtd);
665
666
667 void (*exit)(struct snd_soc_pcm_runtime *rtd);
668
669
670 int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
671 struct snd_pcm_hw_params *params);
672
673
674 const struct snd_soc_ops *ops;
675 const struct snd_soc_compr_ops *compr_ops;
676
677
678 unsigned int nonatomic:1;
679
680
681 unsigned int playback_only:1;
682 unsigned int capture_only:1;
683
684
685 unsigned int ignore_suspend:1;
686
687
688 unsigned int symmetric_rates:1;
689 unsigned int symmetric_channels:1;
690 unsigned int symmetric_samplebits:1;
691
692
693 unsigned int no_pcm:1;
694
695
696 unsigned int dynamic:1;
697
698
699 unsigned int dpcm_capture:1;
700 unsigned int dpcm_playback:1;
701
702
703 unsigned int dpcm_merged_format:1;
704
705 unsigned int dpcm_merged_chan:1;
706
707 unsigned int dpcm_merged_rate:1;
708
709
710 unsigned int ignore_pmdown_time:1;
711
712
713 unsigned int ignore:1;
714
715#ifdef CONFIG_SND_SOC_TOPOLOGY
716 struct snd_soc_dobj dobj;
717#endif
718};
719#define for_each_link_codecs(link, i, codec) \
720 for ((i) = 0; \
721 ((i) < link->num_codecs) && ((codec) = &link->codecs[i]); \
722 (i)++)
723
724#define for_each_link_platforms(link, i, platform) \
725 for ((i) = 0; \
726 ((i) < link->num_platforms) && \
727 ((platform) = &link->platforms[i]); \
728 (i)++)
729
730#define for_each_link_cpus(link, i, cpu) \
731 for ((i) = 0; \
732 ((i) < link->num_cpus) && ((cpu) = &link->cpus[i]); \
733 (i)++)
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788#define SND_SOC_DAILINK_REG1(name) SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
789#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
790#define SND_SOC_DAILINK_REG3(cpu, codec, platform) \
791 .cpus = cpu, \
792 .num_cpus = ARRAY_SIZE(cpu), \
793 .codecs = codec, \
794 .num_codecs = ARRAY_SIZE(codec), \
795 .platforms = platform, \
796 .num_platforms = ARRAY_SIZE(platform)
797
798#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
799#define SND_SOC_DAILINK_REG(...) \
800 SND_SOC_DAILINK_REGx(__VA_ARGS__, \
801 SND_SOC_DAILINK_REG3, \
802 SND_SOC_DAILINK_REG2, \
803 SND_SOC_DAILINK_REG1)(__VA_ARGS__)
804
805#define SND_SOC_DAILINK_DEF(name, def...) \
806 static struct snd_soc_dai_link_component name[] = { def }
807
808#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...) \
809 SND_SOC_DAILINK_DEF(name##_cpus, cpu); \
810 SND_SOC_DAILINK_DEF(name##_codecs, codec); \
811 SND_SOC_DAILINK_DEF(name##_platforms, platform)
812
813#define DAILINK_COMP_ARRAY(param...) param
814#define COMP_EMPTY() { }
815#define COMP_CPU(_dai) { .dai_name = _dai, }
816#define COMP_CODEC(_name, _dai) { .name = _name, .dai_name = _dai, }
817#define COMP_PLATFORM(_name) { .name = _name }
818#define COMP_AUX(_name) { .name = _name }
819#define COMP_CODEC_CONF(_name) { .name = _name }
820#define COMP_DUMMY() { .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }
821
822extern struct snd_soc_dai_link_component null_dailink_component[0];
823
824
825struct snd_soc_codec_conf {
826
827
828
829
830 struct snd_soc_dai_link_component dlc;
831
832
833
834
835
836 const char *name_prefix;
837};
838
839struct snd_soc_aux_dev {
840
841
842
843
844 struct snd_soc_dai_link_component dlc;
845
846
847 int (*init)(struct snd_soc_component *component);
848};
849
850
851struct snd_soc_card {
852 const char *name;
853 const char *long_name;
854 const char *driver_name;
855 const char *components;
856#ifdef CONFIG_DMI
857 char dmi_longname[80];
858#endif
859 char topology_shortname[32];
860
861 struct device *dev;
862 struct snd_card *snd_card;
863 struct module *owner;
864
865 struct mutex mutex;
866 struct mutex dapm_mutex;
867
868
869 struct mutex pcm_mutex;
870 enum snd_soc_pcm_subclass pcm_subclass;
871
872 spinlock_t dpcm_lock;
873
874 int (*probe)(struct snd_soc_card *card);
875 int (*late_probe)(struct snd_soc_card *card);
876 int (*remove)(struct snd_soc_card *card);
877
878
879
880 int (*suspend_pre)(struct snd_soc_card *card);
881 int (*suspend_post)(struct snd_soc_card *card);
882 int (*resume_pre)(struct snd_soc_card *card);
883 int (*resume_post)(struct snd_soc_card *card);
884
885
886 int (*set_bias_level)(struct snd_soc_card *,
887 struct snd_soc_dapm_context *dapm,
888 enum snd_soc_bias_level level);
889 int (*set_bias_level_post)(struct snd_soc_card *,
890 struct snd_soc_dapm_context *dapm,
891 enum snd_soc_bias_level level);
892
893 int (*add_dai_link)(struct snd_soc_card *,
894 struct snd_soc_dai_link *link);
895 void (*remove_dai_link)(struct snd_soc_card *,
896 struct snd_soc_dai_link *link);
897
898 long pmdown_time;
899
900
901 struct snd_soc_dai_link *dai_link;
902 int num_links;
903
904 struct list_head rtd_list;
905 int num_rtd;
906
907
908 struct snd_soc_codec_conf *codec_conf;
909 int num_configs;
910
911
912
913
914
915 struct snd_soc_aux_dev *aux_dev;
916 int num_aux_devs;
917 struct list_head aux_comp_list;
918
919 const struct snd_kcontrol_new *controls;
920 int num_controls;
921
922
923
924
925
926 const struct snd_soc_dapm_widget *dapm_widgets;
927 int num_dapm_widgets;
928 const struct snd_soc_dapm_route *dapm_routes;
929 int num_dapm_routes;
930 const struct snd_soc_dapm_widget *of_dapm_widgets;
931 int num_of_dapm_widgets;
932 const struct snd_soc_dapm_route *of_dapm_routes;
933 int num_of_dapm_routes;
934
935
936 struct list_head component_dev_list;
937 struct list_head list;
938
939 struct list_head widgets;
940 struct list_head paths;
941 struct list_head dapm_list;
942 struct list_head dapm_dirty;
943
944
945 struct list_head dobj_list;
946
947
948 struct snd_soc_dapm_context dapm;
949 struct snd_soc_dapm_stats dapm_stats;
950 struct snd_soc_dapm_update *update;
951
952#ifdef CONFIG_DEBUG_FS
953 struct dentry *debugfs_card_root;
954#endif
955#ifdef CONFIG_PM_SLEEP
956 struct work_struct deferred_resume_work;
957#endif
958 u32 pop_time;
959
960
961 unsigned int instantiated:1;
962 unsigned int topology_shortname_created:1;
963 unsigned int fully_routed:1;
964 unsigned int disable_route_checks:1;
965 unsigned int probed:1;
966 unsigned int component_chaining:1;
967
968 void *drvdata;
969};
970#define for_each_card_prelinks(card, i, link) \
971 for ((i) = 0; \
972 ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
973 (i)++)
974#define for_each_card_pre_auxs(card, i, aux) \
975 for ((i) = 0; \
976 ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
977 (i)++)
978
979#define for_each_card_rtds(card, rtd) \
980 list_for_each_entry(rtd, &(card)->rtd_list, list)
981#define for_each_card_rtds_safe(card, rtd, _rtd) \
982 list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
983
984#define for_each_card_auxs(card, component) \
985 list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
986#define for_each_card_auxs_safe(card, component, _comp) \
987 list_for_each_entry_safe(component, _comp, \
988 &card->aux_comp_list, card_aux_list)
989
990#define for_each_card_components(card, component) \
991 list_for_each_entry(component, &(card)->component_dev_list, card_list)
992
993#define for_each_card_dapms(card, dapm) \
994 list_for_each_entry(dapm, &card->dapm_list, list)
995
996#define for_each_card_widgets(card, w)\
997 list_for_each_entry(w, &card->widgets, list)
998#define for_each_card_widgets_safe(card, w, _w) \
999 list_for_each_entry_safe(w, _w, &card->widgets, list)
1000
1001
1002struct snd_soc_pcm_runtime {
1003 struct device *dev;
1004 struct snd_soc_card *card;
1005 struct snd_soc_dai_link *dai_link;
1006 struct snd_pcm_ops ops;
1007
1008 unsigned int params_select;
1009
1010
1011 struct snd_soc_dpcm_runtime dpcm[2];
1012
1013 long pmdown_time;
1014
1015
1016 struct snd_pcm *pcm;
1017 struct snd_compr *compr;
1018
1019
1020
1021
1022
1023
1024
1025
1026 struct snd_soc_dai **dais;
1027 unsigned int num_codecs;
1028 unsigned int num_cpus;
1029
1030 struct snd_soc_dapm_widget *playback_widget;
1031 struct snd_soc_dapm_widget *capture_widget;
1032
1033 struct delayed_work delayed_work;
1034 void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
1035#ifdef CONFIG_DEBUG_FS
1036 struct dentry *debugfs_dpcm_root;
1037#endif
1038
1039 unsigned int num;
1040 struct list_head list;
1041
1042
1043 struct snd_pcm_substream *mark_startup;
1044 struct snd_pcm_substream *mark_hw_params;
1045 struct snd_pcm_substream *mark_trigger;
1046 struct snd_compr_stream *mark_compr_startup;
1047
1048
1049 unsigned int pop_wait:1;
1050 unsigned int fe_compr:1;
1051
1052 int num_components;
1053 struct snd_soc_component *components[];
1054};
1055
1056#define asoc_rtd_to_cpu(rtd, n) (rtd)->dais[n]
1057#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
1058#define asoc_substream_to_rtd(substream) \
1059 (struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
1060
1061#define for_each_rtd_components(rtd, i, component) \
1062 for ((i) = 0, component = NULL; \
1063 ((i) < rtd->num_components) && ((component) = rtd->components[i]);\
1064 (i)++)
1065#define for_each_rtd_cpu_dais(rtd, i, dai) \
1066 for ((i) = 0; \
1067 ((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
1068 (i)++)
1069#define for_each_rtd_codec_dais(rtd, i, dai) \
1070 for ((i) = 0; \
1071 ((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
1072 (i)++)
1073#define for_each_rtd_dais(rtd, i, dai) \
1074 for ((i) = 0; \
1075 ((i) < (rtd)->num_cpus + (rtd)->num_codecs) && \
1076 ((dai) = (rtd)->dais[i]); \
1077 (i)++)
1078
1079void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
1080
1081
1082struct soc_mixer_control {
1083 int min, max, platform_max;
1084 int reg, rreg;
1085 unsigned int shift, rshift;
1086 unsigned int sign_bit;
1087 unsigned int invert:1;
1088 unsigned int autodisable:1;
1089#ifdef CONFIG_SND_SOC_TOPOLOGY
1090 struct snd_soc_dobj dobj;
1091#endif
1092};
1093
1094struct soc_bytes {
1095 int base;
1096 int num_regs;
1097 u32 mask;
1098};
1099
1100struct soc_bytes_ext {
1101 int max;
1102#ifdef CONFIG_SND_SOC_TOPOLOGY
1103 struct snd_soc_dobj dobj;
1104#endif
1105
1106 int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
1107 unsigned int size);
1108 int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
1109 unsigned int size);
1110};
1111
1112
1113struct soc_mreg_control {
1114 long min, max;
1115 unsigned int regbase, regcount, nbits, invert;
1116};
1117
1118
1119struct soc_enum {
1120 int reg;
1121 unsigned char shift_l;
1122 unsigned char shift_r;
1123 unsigned int items;
1124 unsigned int mask;
1125 const char * const *texts;
1126 const unsigned int *values;
1127 unsigned int autodisable:1;
1128#ifdef CONFIG_SND_SOC_TOPOLOGY
1129 struct snd_soc_dobj dobj;
1130#endif
1131};
1132
1133static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1134{
1135 if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1136 return false;
1137
1138
1139
1140
1141
1142 return true;
1143}
1144
1145static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
1146 unsigned int val)
1147{
1148 unsigned int i;
1149
1150 if (!e->values)
1151 return val;
1152
1153 for (i = 0; i < e->items; i++)
1154 if (val == e->values[i])
1155 return i;
1156
1157 return 0;
1158}
1159
1160static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
1161 unsigned int item)
1162{
1163 if (!e->values)
1164 return item;
1165
1166 return e->values[item];
1167}
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179static inline struct snd_soc_component *snd_soc_kcontrol_component(
1180 struct snd_kcontrol *kcontrol)
1181{
1182 return snd_kcontrol_chip(kcontrol);
1183}
1184
1185int snd_soc_util_init(void);
1186void snd_soc_util_exit(void);
1187
1188int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1189 const char *propname);
1190int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1191 const char *propname);
1192int snd_soc_of_get_slot_mask(struct device_node *np,
1193 const char *prop_name,
1194 unsigned int *mask);
1195int snd_soc_of_parse_tdm_slot(struct device_node *np,
1196 unsigned int *tx_mask,
1197 unsigned int *rx_mask,
1198 unsigned int *slots,
1199 unsigned int *slot_width);
1200void snd_soc_of_parse_node_prefix(struct device_node *np,
1201 struct snd_soc_codec_conf *codec_conf,
1202 struct device_node *of_node,
1203 const char *propname);
1204static inline
1205void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1206 struct snd_soc_codec_conf *codec_conf,
1207 struct device_node *of_node,
1208 const char *propname)
1209{
1210 snd_soc_of_parse_node_prefix(card->dev->of_node,
1211 codec_conf, of_node, propname);
1212}
1213
1214int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1215 const char *propname);
1216int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
1217unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1218 const char *prefix,
1219 struct device_node **bitclkmaster,
1220 struct device_node **framemaster);
1221int snd_soc_get_dai_id(struct device_node *ep);
1222int snd_soc_get_dai_name(struct of_phandle_args *args,
1223 const char **dai_name);
1224int snd_soc_of_get_dai_name(struct device_node *of_node,
1225 const char **dai_name);
1226int snd_soc_of_get_dai_link_codecs(struct device *dev,
1227 struct device_node *of_node,
1228 struct snd_soc_dai_link *dai_link);
1229void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1230
1231int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
1232 struct snd_soc_dai_link *dai_link);
1233void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
1234 struct snd_soc_pcm_runtime *rtd);
1235
1236struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
1237 struct snd_soc_dai_driver *dai_drv,
1238 bool legacy_dai_naming);
1239struct snd_soc_dai *devm_snd_soc_register_dai(struct device *dev,
1240 struct snd_soc_component *component,
1241 struct snd_soc_dai_driver *dai_drv,
1242 bool legacy_dai_naming);
1243void snd_soc_unregister_dai(struct snd_soc_dai *dai);
1244
1245struct snd_soc_dai *snd_soc_find_dai(
1246 const struct snd_soc_dai_link_component *dlc);
1247struct snd_soc_dai *snd_soc_find_dai_with_mutex(
1248 const struct snd_soc_dai_link_component *dlc);
1249
1250#include <sound/soc-dai.h>
1251
1252static inline
1253int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
1254 const char *platform_name)
1255{
1256 struct snd_soc_dai_link *dai_link;
1257 const char *name;
1258 int i;
1259
1260 if (!platform_name)
1261 return 0;
1262
1263
1264 for_each_card_prelinks(card, i, dai_link) {
1265 name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
1266 if (!name)
1267 return -ENOMEM;
1268
1269 if (!dai_link->platforms)
1270 return -EINVAL;
1271
1272
1273 dai_link->platforms->name = name;
1274 }
1275
1276 return 0;
1277}
1278
1279#ifdef CONFIG_DEBUG_FS
1280extern struct dentry *snd_soc_debugfs_root;
1281#endif
1282
1283extern const struct dev_pm_ops snd_soc_pm_ops;
1284
1285
1286static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
1287{
1288 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1289}
1290
1291static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
1292{
1293 mutex_unlock(&dapm->card->dapm_mutex);
1294}
1295
1296#include <sound/soc-component.h>
1297#include <sound/soc-card.h>
1298#include <sound/soc-jack.h>
1299
1300#endif
1301
