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_rate:1;
689 unsigned int symmetric_channels:1;
690 unsigned int symmetric_sample_bits: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
716
717
718
719 unsigned int stop_dma_first:1;
720
721#ifdef CONFIG_SND_SOC_TOPOLOGY
722 struct snd_soc_dobj dobj;
723#endif
724};
725
726static inline struct snd_soc_dai_link_component*
727asoc_link_to_cpu(struct snd_soc_dai_link *link, int n) {
728 return &(link)->cpus[n];
729}
730
731static inline struct snd_soc_dai_link_component*
732asoc_link_to_codec(struct snd_soc_dai_link *link, int n) {
733 return &(link)->codecs[n];
734}
735
736static inline struct snd_soc_dai_link_component*
737asoc_link_to_platform(struct snd_soc_dai_link *link, int n) {
738 return &(link)->platforms[n];
739}
740
741#define for_each_link_codecs(link, i, codec) \
742 for ((i) = 0; \
743 ((i) < link->num_codecs) && \
744 ((codec) = asoc_link_to_codec(link, i)); \
745 (i)++)
746
747#define for_each_link_platforms(link, i, platform) \
748 for ((i) = 0; \
749 ((i) < link->num_platforms) && \
750 ((platform) = asoc_link_to_platform(link, i)); \
751 (i)++)
752
753#define for_each_link_cpus(link, i, cpu) \
754 for ((i) = 0; \
755 ((i) < link->num_cpus) && \
756 ((cpu) = asoc_link_to_cpu(link, i)); \
757 (i)++)
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
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812#define SND_SOC_DAILINK_REG1(name) SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
813#define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
814#define SND_SOC_DAILINK_REG3(cpu, codec, platform) \
815 .cpus = cpu, \
816 .num_cpus = ARRAY_SIZE(cpu), \
817 .codecs = codec, \
818 .num_codecs = ARRAY_SIZE(codec), \
819 .platforms = platform, \
820 .num_platforms = ARRAY_SIZE(platform)
821
822#define SND_SOC_DAILINK_REGx(_1, _2, _3, func, ...) func
823#define SND_SOC_DAILINK_REG(...) \
824 SND_SOC_DAILINK_REGx(__VA_ARGS__, \
825 SND_SOC_DAILINK_REG3, \
826 SND_SOC_DAILINK_REG2, \
827 SND_SOC_DAILINK_REG1)(__VA_ARGS__)
828
829#define SND_SOC_DAILINK_DEF(name, def...) \
830 static struct snd_soc_dai_link_component name[] = { def }
831
832#define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...) \
833 SND_SOC_DAILINK_DEF(name##_cpus, cpu); \
834 SND_SOC_DAILINK_DEF(name##_codecs, codec); \
835 SND_SOC_DAILINK_DEF(name##_platforms, platform)
836
837#define DAILINK_COMP_ARRAY(param...) param
838#define COMP_EMPTY() { }
839#define COMP_CPU(_dai) { .dai_name = _dai, }
840#define COMP_CODEC(_name, _dai) { .name = _name, .dai_name = _dai, }
841#define COMP_PLATFORM(_name) { .name = _name }
842#define COMP_AUX(_name) { .name = _name }
843#define COMP_CODEC_CONF(_name) { .name = _name }
844#define COMP_DUMMY() { .name = "snd-soc-dummy", .dai_name = "snd-soc-dummy-dai", }
845
846extern struct snd_soc_dai_link_component null_dailink_component[0];
847
848
849struct snd_soc_codec_conf {
850
851
852
853
854 struct snd_soc_dai_link_component dlc;
855
856
857
858
859
860 const char *name_prefix;
861};
862
863struct snd_soc_aux_dev {
864
865
866
867
868 struct snd_soc_dai_link_component dlc;
869
870
871 int (*init)(struct snd_soc_component *component);
872};
873
874
875struct snd_soc_card {
876 const char *name;
877 const char *long_name;
878 const char *driver_name;
879 const char *components;
880#ifdef CONFIG_DMI
881 char dmi_longname[80];
882#endif
883 char topology_shortname[32];
884
885 struct device *dev;
886 struct snd_card *snd_card;
887 struct module *owner;
888
889 struct mutex mutex;
890 struct mutex dapm_mutex;
891
892
893 struct mutex pcm_mutex;
894 enum snd_soc_pcm_subclass pcm_subclass;
895
896 int (*probe)(struct snd_soc_card *card);
897 int (*late_probe)(struct snd_soc_card *card);
898 int (*remove)(struct snd_soc_card *card);
899
900
901
902 int (*suspend_pre)(struct snd_soc_card *card);
903 int (*suspend_post)(struct snd_soc_card *card);
904 int (*resume_pre)(struct snd_soc_card *card);
905 int (*resume_post)(struct snd_soc_card *card);
906
907
908 int (*set_bias_level)(struct snd_soc_card *,
909 struct snd_soc_dapm_context *dapm,
910 enum snd_soc_bias_level level);
911 int (*set_bias_level_post)(struct snd_soc_card *,
912 struct snd_soc_dapm_context *dapm,
913 enum snd_soc_bias_level level);
914
915 int (*add_dai_link)(struct snd_soc_card *,
916 struct snd_soc_dai_link *link);
917 void (*remove_dai_link)(struct snd_soc_card *,
918 struct snd_soc_dai_link *link);
919
920 long pmdown_time;
921
922
923 struct snd_soc_dai_link *dai_link;
924 int num_links;
925
926 struct list_head rtd_list;
927 int num_rtd;
928
929
930 struct snd_soc_codec_conf *codec_conf;
931 int num_configs;
932
933
934
935
936
937 struct snd_soc_aux_dev *aux_dev;
938 int num_aux_devs;
939 struct list_head aux_comp_list;
940
941 const struct snd_kcontrol_new *controls;
942 int num_controls;
943
944
945
946
947
948 const struct snd_soc_dapm_widget *dapm_widgets;
949 int num_dapm_widgets;
950 const struct snd_soc_dapm_route *dapm_routes;
951 int num_dapm_routes;
952 const struct snd_soc_dapm_widget *of_dapm_widgets;
953 int num_of_dapm_widgets;
954 const struct snd_soc_dapm_route *of_dapm_routes;
955 int num_of_dapm_routes;
956
957
958 struct list_head component_dev_list;
959 struct list_head list;
960
961 struct list_head widgets;
962 struct list_head paths;
963 struct list_head dapm_list;
964 struct list_head dapm_dirty;
965
966
967 struct list_head dobj_list;
968
969
970 struct snd_soc_dapm_context dapm;
971 struct snd_soc_dapm_stats dapm_stats;
972 struct snd_soc_dapm_update *update;
973
974#ifdef CONFIG_DEBUG_FS
975 struct dentry *debugfs_card_root;
976#endif
977#ifdef CONFIG_PM_SLEEP
978 struct work_struct deferred_resume_work;
979#endif
980 u32 pop_time;
981
982
983 unsigned int instantiated:1;
984 unsigned int topology_shortname_created:1;
985 unsigned int fully_routed:1;
986 unsigned int disable_route_checks:1;
987 unsigned int probed:1;
988 unsigned int component_chaining:1;
989
990 void *drvdata;
991};
992#define for_each_card_prelinks(card, i, link) \
993 for ((i) = 0; \
994 ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
995 (i)++)
996#define for_each_card_pre_auxs(card, i, aux) \
997 for ((i) = 0; \
998 ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
999 (i)++)
1000
1001#define for_each_card_rtds(card, rtd) \
1002 list_for_each_entry(rtd, &(card)->rtd_list, list)
1003#define for_each_card_rtds_safe(card, rtd, _rtd) \
1004 list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
1005
1006#define for_each_card_auxs(card, component) \
1007 list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
1008#define for_each_card_auxs_safe(card, component, _comp) \
1009 list_for_each_entry_safe(component, _comp, \
1010 &card->aux_comp_list, card_aux_list)
1011
1012#define for_each_card_components(card, component) \
1013 list_for_each_entry(component, &(card)->component_dev_list, card_list)
1014
1015#define for_each_card_dapms(card, dapm) \
1016 list_for_each_entry(dapm, &card->dapm_list, list)
1017
1018#define for_each_card_widgets(card, w)\
1019 list_for_each_entry(w, &card->widgets, list)
1020#define for_each_card_widgets_safe(card, w, _w) \
1021 list_for_each_entry_safe(w, _w, &card->widgets, list)
1022
1023
1024struct snd_soc_pcm_runtime {
1025 struct device *dev;
1026 struct snd_soc_card *card;
1027 struct snd_soc_dai_link *dai_link;
1028 struct snd_pcm_ops ops;
1029
1030 unsigned int params_select;
1031
1032
1033 struct snd_soc_dpcm_runtime dpcm[2];
1034
1035 long pmdown_time;
1036
1037
1038 struct snd_pcm *pcm;
1039 struct snd_compr *compr;
1040
1041
1042
1043
1044
1045
1046
1047
1048 struct snd_soc_dai **dais;
1049 unsigned int num_codecs;
1050 unsigned int num_cpus;
1051
1052 struct snd_soc_dapm_widget *playback_widget;
1053 struct snd_soc_dapm_widget *capture_widget;
1054
1055 struct delayed_work delayed_work;
1056 void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
1057#ifdef CONFIG_DEBUG_FS
1058 struct dentry *debugfs_dpcm_root;
1059#endif
1060
1061 unsigned int num;
1062 struct list_head list;
1063
1064
1065 struct snd_pcm_substream *mark_startup;
1066 struct snd_pcm_substream *mark_hw_params;
1067 struct snd_pcm_substream *mark_trigger;
1068 struct snd_compr_stream *mark_compr_startup;
1069
1070
1071 unsigned int pop_wait:1;
1072 unsigned int fe_compr:1;
1073
1074 int num_components;
1075 struct snd_soc_component *components[];
1076};
1077
1078#define asoc_rtd_to_cpu(rtd, n) (rtd)->dais[n]
1079#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
1080#define asoc_substream_to_rtd(substream) \
1081 (struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
1082
1083#define for_each_rtd_components(rtd, i, component) \
1084 for ((i) = 0, component = NULL; \
1085 ((i) < rtd->num_components) && ((component) = rtd->components[i]);\
1086 (i)++)
1087#define for_each_rtd_cpu_dais(rtd, i, dai) \
1088 for ((i) = 0; \
1089 ((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
1090 (i)++)
1091#define for_each_rtd_codec_dais(rtd, i, dai) \
1092 for ((i) = 0; \
1093 ((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
1094 (i)++)
1095#define for_each_rtd_dais(rtd, i, dai) \
1096 for ((i) = 0; \
1097 ((i) < (rtd)->num_cpus + (rtd)->num_codecs) && \
1098 ((dai) = (rtd)->dais[i]); \
1099 (i)++)
1100
1101void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
1102
1103
1104struct soc_mixer_control {
1105 int min, max, platform_max;
1106 int reg, rreg;
1107 unsigned int shift, rshift;
1108 unsigned int sign_bit;
1109 unsigned int invert:1;
1110 unsigned int autodisable:1;
1111#ifdef CONFIG_SND_SOC_TOPOLOGY
1112 struct snd_soc_dobj dobj;
1113#endif
1114};
1115
1116struct soc_bytes {
1117 int base;
1118 int num_regs;
1119 u32 mask;
1120};
1121
1122struct soc_bytes_ext {
1123 int max;
1124#ifdef CONFIG_SND_SOC_TOPOLOGY
1125 struct snd_soc_dobj dobj;
1126#endif
1127
1128 int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
1129 unsigned int size);
1130 int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
1131 unsigned int size);
1132};
1133
1134
1135struct soc_mreg_control {
1136 long min, max;
1137 unsigned int regbase, regcount, nbits, invert;
1138};
1139
1140
1141struct soc_enum {
1142 int reg;
1143 unsigned char shift_l;
1144 unsigned char shift_r;
1145 unsigned int items;
1146 unsigned int mask;
1147 const char * const *texts;
1148 const unsigned int *values;
1149 unsigned int autodisable:1;
1150#ifdef CONFIG_SND_SOC_TOPOLOGY
1151 struct snd_soc_dobj dobj;
1152#endif
1153};
1154
1155static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1156{
1157 if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1158 return false;
1159
1160
1161
1162
1163
1164 return true;
1165}
1166
1167static inline unsigned int snd_soc_enum_val_to_item(struct soc_enum *e,
1168 unsigned int val)
1169{
1170 unsigned int i;
1171
1172 if (!e->values)
1173 return val;
1174
1175 for (i = 0; i < e->items; i++)
1176 if (val == e->values[i])
1177 return i;
1178
1179 return 0;
1180}
1181
1182static inline unsigned int snd_soc_enum_item_to_val(struct soc_enum *e,
1183 unsigned int item)
1184{
1185 if (!e->values)
1186 return item;
1187
1188 return e->values[item];
1189}
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201static inline struct snd_soc_component *snd_soc_kcontrol_component(
1202 struct snd_kcontrol *kcontrol)
1203{
1204 return snd_kcontrol_chip(kcontrol);
1205}
1206
1207int snd_soc_util_init(void);
1208void snd_soc_util_exit(void);
1209
1210int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1211 const char *propname);
1212int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1213 const char *propname);
1214int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop);
1215int snd_soc_of_get_slot_mask(struct device_node *np,
1216 const char *prop_name,
1217 unsigned int *mask);
1218int snd_soc_of_parse_tdm_slot(struct device_node *np,
1219 unsigned int *tx_mask,
1220 unsigned int *rx_mask,
1221 unsigned int *slots,
1222 unsigned int *slot_width);
1223void snd_soc_of_parse_node_prefix(struct device_node *np,
1224 struct snd_soc_codec_conf *codec_conf,
1225 struct device_node *of_node,
1226 const char *propname);
1227static inline
1228void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1229 struct snd_soc_codec_conf *codec_conf,
1230 struct device_node *of_node,
1231 const char *propname)
1232{
1233 snd_soc_of_parse_node_prefix(card->dev->of_node,
1234 codec_conf, of_node, propname);
1235}
1236
1237int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1238 const char *propname);
1239int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
1240
1241unsigned int snd_soc_daifmt_clock_provider_fliped(unsigned int dai_fmt);
1242unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame);
1243
1244unsigned int snd_soc_daifmt_parse_format(struct device_node *np, const char *prefix);
1245unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np,
1246 const char *prefix,
1247 struct device_node **bitclkmaster,
1248 struct device_node **framemaster);
1249#define snd_soc_daifmt_parse_clock_provider_as_bitmap(np, prefix) \
1250 snd_soc_daifmt_parse_clock_provider_raw(np, prefix, NULL, NULL)
1251#define snd_soc_daifmt_parse_clock_provider_as_phandle \
1252 snd_soc_daifmt_parse_clock_provider_raw
1253#define snd_soc_daifmt_parse_clock_provider_as_flag(np, prefix) \
1254 snd_soc_daifmt_clock_provider_from_bitmap( \
1255 snd_soc_daifmt_parse_clock_provider_as_bitmap(np, prefix))
1256
1257int snd_soc_get_dai_id(struct device_node *ep);
1258int snd_soc_get_dai_name(const struct of_phandle_args *args,
1259 const char **dai_name);
1260int snd_soc_of_get_dai_name(struct device_node *of_node,
1261 const char **dai_name);
1262int snd_soc_of_get_dai_link_codecs(struct device *dev,
1263 struct device_node *of_node,
1264 struct snd_soc_dai_link *dai_link);
1265void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1266
1267int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
1268 struct snd_soc_dai_link *dai_link);
1269void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
1270 struct snd_soc_pcm_runtime *rtd);
1271
1272struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
1273 struct snd_soc_dai_driver *dai_drv,
1274 bool legacy_dai_naming);
1275struct snd_soc_dai *devm_snd_soc_register_dai(struct device *dev,
1276 struct snd_soc_component *component,
1277 struct snd_soc_dai_driver *dai_drv,
1278 bool legacy_dai_naming);
1279void snd_soc_unregister_dai(struct snd_soc_dai *dai);
1280
1281struct snd_soc_dai *snd_soc_find_dai(
1282 const struct snd_soc_dai_link_component *dlc);
1283struct snd_soc_dai *snd_soc_find_dai_with_mutex(
1284 const struct snd_soc_dai_link_component *dlc);
1285
1286#include <sound/soc-dai.h>
1287
1288static inline
1289int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
1290 const char *platform_name)
1291{
1292 struct snd_soc_dai_link *dai_link;
1293 const char *name;
1294 int i;
1295
1296 if (!platform_name)
1297 return 0;
1298
1299
1300 for_each_card_prelinks(card, i, dai_link) {
1301
1302 if (dai_link->num_platforms != 1)
1303 return -EINVAL;
1304
1305 if (!dai_link->platforms)
1306 return -EINVAL;
1307
1308 name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
1309 if (!name)
1310 return -ENOMEM;
1311
1312
1313 dai_link->platforms->name = name;
1314 }
1315
1316 return 0;
1317}
1318
1319#ifdef CONFIG_DEBUG_FS
1320extern struct dentry *snd_soc_debugfs_root;
1321#endif
1322
1323extern const struct dev_pm_ops snd_soc_pm_ops;
1324
1325
1326static inline void snd_soc_dapm_mutex_lock(struct snd_soc_dapm_context *dapm)
1327{
1328 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1329}
1330
1331static inline void snd_soc_dapm_mutex_unlock(struct snd_soc_dapm_context *dapm)
1332{
1333 mutex_unlock(&dapm->card->dapm_mutex);
1334}
1335
1336#include <sound/soc-component.h>
1337#include <sound/soc-card.h>
1338#include <sound/soc-jack.h>
1339
1340#endif
1341