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