1 /* SPDX-License-Identifier: GPL-2.0
2 *
3 * linux/sound/soc.h -- ALSA SoC Layer
4 *
5 * Author: Liam Girdwood
6 * Created: Aug 11th 2005
7 * Copyright: Wolfson Microelectronics. PLC.
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
32 struct module;
33 struct platform_device;
34
35 /* For the current users of sound/soc.h to avoid build issues */
36 #include <linux/platform_device.h>
37 #include <linux/regmap.h>
38
39 /*
40 * Convenience kcontrol builders
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 * SND_SOC_BYTES_EXT is deprecated, please USE SND_SOC_BYTES_TLV instead
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 * Simplified versions of above macros, declaring a struct and calculating
375 * ARRAY_SIZE internally
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
397 struct snd_jack;
398 struct snd_soc_card;
399 struct snd_soc_pcm_stream;
400 struct snd_soc_ops;
401 struct snd_soc_pcm_runtime;
402 struct snd_soc_dai;
403 struct snd_soc_dai_driver;
404 struct snd_soc_dai_link;
405 struct snd_soc_component;
406 struct snd_soc_component_driver;
407 struct soc_enum;
408 struct snd_soc_jack;
409 struct snd_soc_jack_zone;
410 struct snd_soc_jack_pin;
411
412 #include <sound/soc-dapm.h>
413 #include <sound/soc-dpcm.h>
414 #include <sound/soc-topology.h>
415
416 struct snd_soc_jack_gpio;
417
418 enum snd_soc_pcm_subclass {
419 SND_SOC_PCM_CLASS_PCM = 0,
420 SND_SOC_PCM_CLASS_BE = 1,
421 };
422
423 int snd_soc_register_card(struct snd_soc_card *card);
424 void snd_soc_unregister_card(struct snd_soc_card *card);
425 int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
426 #ifdef CONFIG_PM_SLEEP
427 int snd_soc_suspend(struct device *dev);
428 int snd_soc_resume(struct device *dev);
429 #else
snd_soc_suspend(struct device * dev)430 static inline int snd_soc_suspend(struct device *dev)
431 {
432 return 0;
433 }
434
snd_soc_resume(struct device * dev)435 static inline int snd_soc_resume(struct device *dev)
436 {
437 return 0;
438 }
439 #endif
440 int snd_soc_poweroff(struct device *dev);
441 int snd_soc_component_initialize(struct snd_soc_component *component,
442 const struct snd_soc_component_driver *driver,
443 struct device *dev);
444 int snd_soc_add_component(struct snd_soc_component *component,
445 struct snd_soc_dai_driver *dai_drv,
446 int num_dai);
447 int snd_soc_register_component(struct device *dev,
448 const struct snd_soc_component_driver *component_driver,
449 struct snd_soc_dai_driver *dai_drv, int num_dai);
450 int devm_snd_soc_register_component(struct device *dev,
451 const struct snd_soc_component_driver *component_driver,
452 struct snd_soc_dai_driver *dai_drv, int num_dai);
453 void snd_soc_unregister_component(struct device *dev);
454 void snd_soc_unregister_component_by_driver(struct device *dev,
455 const struct snd_soc_component_driver *component_driver);
456 struct snd_soc_component *snd_soc_lookup_component_nolocked(struct device *dev,
457 const char *driver_name);
458 struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
459 const char *driver_name);
460
461 int soc_new_pcm(struct snd_soc_pcm_runtime *rtd);
462 #ifdef CONFIG_SND_SOC_COMPRESS
463 int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd);
464 #else
snd_soc_new_compress(struct snd_soc_pcm_runtime * rtd)465 static inline int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd)
466 {
467 return 0;
468 }
469 #endif
470
471 void snd_soc_disconnect_sync(struct device *dev);
472
473 struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
474 struct snd_soc_dai_link *dai_link);
475
476 bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd);
477
478 void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
479 int stream, int action);
snd_soc_runtime_activate(struct snd_soc_pcm_runtime * rtd,int stream)480 static inline void snd_soc_runtime_activate(struct snd_soc_pcm_runtime *rtd,
481 int stream)
482 {
483 snd_soc_runtime_action(rtd, stream, 1);
484 }
snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime * rtd,int stream)485 static inline void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime *rtd,
486 int stream)
487 {
488 snd_soc_runtime_action(rtd, stream, -1);
489 }
490
491 int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
492 struct snd_pcm_hardware *hw, int stream);
493
494 int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
495 unsigned int dai_fmt);
496
497 /* Utility functions to get clock rates from various things */
498 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
499 int snd_soc_params_to_frame_size(const struct snd_pcm_hw_params *params);
500 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
501 int snd_soc_params_to_bclk(const struct snd_pcm_hw_params *parms);
502 int snd_soc_tdm_params_to_bclk(const struct snd_pcm_hw_params *params,
503 int tdm_width, int tdm_slots, int slot_multiple);
504 int snd_soc_ret(const struct device *dev, int ret, const char *fmt, ...);
505
506 /* set runtime hw params */
snd_soc_set_runtime_hwparams(struct snd_pcm_substream * substream,const struct snd_pcm_hardware * hw)507 static inline int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
508 const struct snd_pcm_hardware *hw)
509 {
510 substream->runtime->hw = *hw;
511
512 return 0;
513 }
514
515 struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component);
516 struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
517 unsigned int id, unsigned int id_mask);
518 void snd_soc_free_ac97_component(struct snd_ac97 *ac97);
519
520 #ifdef CONFIG_SND_SOC_AC97_BUS
521 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
522 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
523 struct platform_device *pdev);
524
525 extern struct snd_ac97_bus_ops *soc_ac97_ops;
526 #else
snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops * ops,struct platform_device * pdev)527 static inline int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
528 struct platform_device *pdev)
529 {
530 return 0;
531 }
532
snd_soc_set_ac97_ops(struct snd_ac97_bus_ops * ops)533 static inline int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
534 {
535 return 0;
536 }
537 #endif
538
539 /*
540 *Controls
541 */
542 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
543 void *data, const char *long_name,
544 const char *prefix);
545 int snd_soc_add_component_controls(struct snd_soc_component *component,
546 const struct snd_kcontrol_new *controls, unsigned int num_controls);
547 int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
548 const struct snd_kcontrol_new *controls, int num_controls);
549 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
550 const struct snd_kcontrol_new *controls, int num_controls);
551 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
552 struct snd_ctl_elem_info *uinfo);
553 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
554 struct snd_ctl_elem_value *ucontrol);
555 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
556 struct snd_ctl_elem_value *ucontrol);
557 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
558 struct snd_ctl_elem_info *uinfo);
559 int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
560 struct snd_ctl_elem_info *uinfo);
561 #define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
562 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_value *ucontrol);
564 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
565 struct snd_ctl_elem_value *ucontrol);
566 #define snd_soc_get_volsw_2r snd_soc_get_volsw
567 #define snd_soc_put_volsw_2r snd_soc_put_volsw
568 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_value *ucontrol);
570 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
571 struct snd_ctl_elem_value *ucontrol);
572 int snd_soc_limit_volume(struct snd_soc_card *card,
573 const char *name, int max);
574 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_info *uinfo);
576 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
577 struct snd_ctl_elem_value *ucontrol);
578 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
579 struct snd_ctl_elem_value *ucontrol);
580 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
581 struct snd_ctl_elem_info *ucontrol);
582 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
583 unsigned int size, unsigned int __user *tlv);
584 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
585 struct snd_ctl_elem_info *uinfo);
586 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
587 struct snd_ctl_elem_value *ucontrol);
588 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
589 struct snd_ctl_elem_value *ucontrol);
590 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
591 struct snd_ctl_elem_value *ucontrol);
592 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
593 struct snd_ctl_elem_value *ucontrol);
594
595 enum snd_soc_trigger_order {
596 /* start stop */
597 SND_SOC_TRIGGER_ORDER_DEFAULT = 0, /* Link->Component->DAI DAI->Component->Link */
598 SND_SOC_TRIGGER_ORDER_LDC, /* Link->DAI->Component Component->DAI->Link */
599
600 SND_SOC_TRIGGER_ORDER_MAX,
601 };
602
603 /* SoC PCM stream information */
604 struct snd_soc_pcm_stream {
605 const char *stream_name;
606 u64 formats; /* SNDRV_PCM_FMTBIT_* */
607 u32 subformats; /* for S32_LE format, SNDRV_PCM_SUBFMTBIT_* */
608 unsigned int rates; /* SNDRV_PCM_RATE_* */
609 unsigned int rate_min; /* min rate */
610 unsigned int rate_max; /* max rate */
611 unsigned int channels_min; /* min channels */
612 unsigned int channels_max; /* max channels */
613 unsigned int sig_bits; /* number of bits of content */
614 };
615
616 /* SoC audio ops */
617 struct snd_soc_ops {
618 int (*startup)(struct snd_pcm_substream *);
619 void (*shutdown)(struct snd_pcm_substream *);
620 int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
621 int (*hw_free)(struct snd_pcm_substream *);
622 int (*prepare)(struct snd_pcm_substream *);
623 int (*trigger)(struct snd_pcm_substream *, int);
624 };
625
626 struct snd_soc_compr_ops {
627 int (*startup)(struct snd_compr_stream *);
628 void (*shutdown)(struct snd_compr_stream *);
629 int (*set_params)(struct snd_compr_stream *);
630 };
631
632 struct snd_soc_component*
633 snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
634 const char *driver_name);
635
636 struct snd_soc_dai_link_component {
637 const char *name;
638 struct device_node *of_node;
639 const char *dai_name;
640 const struct of_phandle_args *dai_args;
641
642 /*
643 * Extra format = SND_SOC_DAIFMT_Bx_Fx
644 *
645 * [Note] it is Bx_Fx base, not CBx_CFx
646 *
647 * It will be used with dai_link->dai_fmt
648 * see
649 * snd_soc_runtime_set_dai_fmt()
650 */
651 unsigned int ext_fmt;
652 };
653
654 /*
655 * [dai_link->ch_maps Image sample]
656 *
657 *-------------------------
658 * CPU0 <---> Codec0
659 *
660 * ch-map[0].cpu = 0 ch-map[0].codec = 0
661 *
662 *-------------------------
663 * CPU0 <---> Codec0
664 * CPU1 <---> Codec1
665 * CPU2 <---> Codec2
666 *
667 * ch-map[0].cpu = 0 ch-map[0].codec = 0
668 * ch-map[1].cpu = 1 ch-map[1].codec = 1
669 * ch-map[2].cpu = 2 ch-map[2].codec = 2
670 *
671 *-------------------------
672 * CPU0 <---> Codec0
673 * CPU1 <-+-> Codec1
674 * CPU2 <-/
675 *
676 * ch-map[0].cpu = 0 ch-map[0].codec = 0
677 * ch-map[1].cpu = 1 ch-map[1].codec = 1
678 * ch-map[2].cpu = 2 ch-map[2].codec = 1
679 *
680 *-------------------------
681 * CPU0 <---> Codec0
682 * CPU1 <-+-> Codec1
683 * \-> Codec2
684 *
685 * ch-map[0].cpu = 0 ch-map[0].codec = 0
686 * ch-map[1].cpu = 1 ch-map[1].codec = 1
687 * ch-map[2].cpu = 1 ch-map[2].codec = 2
688 *
689 */
690 struct snd_soc_dai_link_ch_map {
691 unsigned int cpu;
692 unsigned int codec;
693 unsigned int ch_mask;
694 };
695
696 struct snd_soc_dai_link {
697 /* config - must be set by machine driver */
698 const char *name; /* Codec name */
699 const char *stream_name; /* Stream name */
700
701 /*
702 * You MAY specify the link's CPU-side device, either by device name,
703 * or by DT/OF node, but not both. If this information is omitted,
704 * the CPU-side DAI is matched using .cpu_dai_name only, which hence
705 * must be globally unique. These fields are currently typically used
706 * only for codec to codec links, or systems using device tree.
707 */
708 /*
709 * You MAY specify the DAI name of the CPU DAI. If this information is
710 * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
711 * only, which only works well when that device exposes a single DAI.
712 */
713 struct snd_soc_dai_link_component *cpus;
714 unsigned int num_cpus;
715
716 /*
717 * You MUST specify the link's codec, either by device name, or by
718 * DT/OF node, but not both.
719 */
720 /* You MUST specify the DAI name within the codec */
721 struct snd_soc_dai_link_component *codecs;
722 unsigned int num_codecs;
723
724 /* num_ch_maps = max(num_cpu, num_codecs) */
725 struct snd_soc_dai_link_ch_map *ch_maps;
726
727 /*
728 * You MAY specify the link's platform/PCM/DMA driver, either by
729 * device name, or by DT/OF node, but not both. Some forms of link
730 * do not need a platform. In such case, platforms are not mandatory.
731 */
732 struct snd_soc_dai_link_component *platforms;
733 unsigned int num_platforms;
734
735 int id; /* optional ID for machine driver link identification */
736
737 /*
738 * for Codec2Codec
739 */
740 const struct snd_soc_pcm_stream *c2c_params;
741 unsigned int num_c2c_params;
742
743 unsigned int dai_fmt; /* format to set on init */
744
745 enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
746
747 /* codec/machine specific init - e.g. add machine controls */
748 int (*init)(struct snd_soc_pcm_runtime *rtd);
749
750 /* codec/machine specific exit - dual of init() */
751 void (*exit)(struct snd_soc_pcm_runtime *rtd);
752
753 /* optional hw_params re-writing for BE and FE sync */
754 int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
755 struct snd_pcm_hw_params *params);
756
757 /* machine stream operations */
758 const struct snd_soc_ops *ops;
759 const struct snd_soc_compr_ops *compr_ops;
760
761 /*
762 * soc_pcm_trigger() start/stop sequence.
763 * see also
764 * snd_soc_component_driver
765 * soc_pcm_trigger()
766 */
767 enum snd_soc_trigger_order trigger_start;
768 enum snd_soc_trigger_order trigger_stop;
769
770 /* Mark this pcm with non atomic ops */
771 unsigned int nonatomic:1;
772
773 /* For unidirectional dai links */
774 unsigned int playback_only:1;
775 unsigned int capture_only:1;
776
777 /* Keep DAI active over suspend */
778 unsigned int ignore_suspend:1;
779
780 /* Symmetry requirements */
781 unsigned int symmetric_rate:1;
782 unsigned int symmetric_channels:1;
783 unsigned int symmetric_sample_bits:1;
784
785 /* Do not create a PCM for this DAI link (Backend link) */
786 unsigned int no_pcm:1;
787
788 /* This DAI link can route to other DAI links at runtime (Frontend)*/
789 unsigned int dynamic:1;
790
791 /* DPCM used FE & BE merged format */
792 unsigned int dpcm_merged_format:1;
793 /* DPCM used FE & BE merged channel */
794 unsigned int dpcm_merged_chan:1;
795 /* DPCM used FE & BE merged rate */
796 unsigned int dpcm_merged_rate:1;
797
798 /* pmdown_time is ignored at stop */
799 unsigned int ignore_pmdown_time:1;
800
801 /* Do not create a PCM for this DAI link (Backend link) */
802 unsigned int ignore:1;
803
804 #ifdef CONFIG_SND_SOC_TOPOLOGY
805 struct snd_soc_dobj dobj; /* For topology */
806 #endif
807 };
808
snd_soc_link_num_ch_map(const struct snd_soc_dai_link * link)809 static inline int snd_soc_link_num_ch_map(const struct snd_soc_dai_link *link)
810 {
811 return max(link->num_cpus, link->num_codecs);
812 }
813
814 static inline struct snd_soc_dai_link_component*
snd_soc_link_to_cpu(struct snd_soc_dai_link * link,int n)815 snd_soc_link_to_cpu(struct snd_soc_dai_link *link, int n) {
816 return &(link)->cpus[n];
817 }
818
819 static inline struct snd_soc_dai_link_component*
snd_soc_link_to_codec(struct snd_soc_dai_link * link,int n)820 snd_soc_link_to_codec(struct snd_soc_dai_link *link, int n) {
821 return &(link)->codecs[n];
822 }
823
824 static inline struct snd_soc_dai_link_component*
snd_soc_link_to_platform(struct snd_soc_dai_link * link,int n)825 snd_soc_link_to_platform(struct snd_soc_dai_link *link, int n) {
826 return &(link)->platforms[n];
827 }
828
829 #define for_each_link_codecs(link, i, codec) \
830 for ((i) = 0; \
831 ((i) < link->num_codecs) && \
832 ((codec) = snd_soc_link_to_codec(link, i)); \
833 (i)++)
834
835 #define for_each_link_platforms(link, i, platform) \
836 for ((i) = 0; \
837 ((i) < link->num_platforms) && \
838 ((platform) = snd_soc_link_to_platform(link, i)); \
839 (i)++)
840
841 #define for_each_link_cpus(link, i, cpu) \
842 for ((i) = 0; \
843 ((i) < link->num_cpus) && \
844 ((cpu) = snd_soc_link_to_cpu(link, i)); \
845 (i)++)
846
847 #define for_each_link_ch_maps(link, i, ch_map) \
848 for ((i) = 0; \
849 ((i) < snd_soc_link_num_ch_map(link) && \
850 ((ch_map) = link->ch_maps + i)); \
851 (i)++)
852
853 /*
854 * Sample 1 : Single CPU/Codec/Platform
855 *
856 * SND_SOC_DAILINK_DEFS(test,
857 * DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai")),
858 * DAILINK_COMP_ARRAY(COMP_CODEC("codec", "codec_dai")),
859 * DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
860 *
861 * struct snd_soc_dai_link link = {
862 * ...
863 * SND_SOC_DAILINK_REG(test),
864 * };
865 *
866 * Sample 2 : Multi CPU/Codec, no Platform
867 *
868 * SND_SOC_DAILINK_DEFS(test,
869 * DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
870 * COMP_CPU("cpu_dai2")),
871 * DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
872 * COMP_CODEC("codec2", "codec_dai2")));
873 *
874 * struct snd_soc_dai_link link = {
875 * ...
876 * SND_SOC_DAILINK_REG(test),
877 * };
878 *
879 * Sample 3 : Define each CPU/Codec/Platform manually
880 *
881 * SND_SOC_DAILINK_DEF(test_cpu,
882 * DAILINK_COMP_ARRAY(COMP_CPU("cpu_dai1"),
883 * COMP_CPU("cpu_dai2")));
884 * SND_SOC_DAILINK_DEF(test_codec,
885 * DAILINK_COMP_ARRAY(COMP_CODEC("codec1", "codec_dai1"),
886 * COMP_CODEC("codec2", "codec_dai2")));
887 * SND_SOC_DAILINK_DEF(test_platform,
888 * DAILINK_COMP_ARRAY(COMP_PLATFORM("platform")));
889 *
890 * struct snd_soc_dai_link link = {
891 * ...
892 * SND_SOC_DAILINK_REG(test_cpu,
893 * test_codec,
894 * test_platform),
895 * };
896 *
897 * Sample 4 : Sample3 without platform
898 *
899 * struct snd_soc_dai_link link = {
900 * ...
901 * SND_SOC_DAILINK_REG(test_cpu,
902 * test_codec);
903 * };
904 */
905
906 #define SND_SOC_DAILINK_REG1(name) SND_SOC_DAILINK_REG3(name##_cpus, name##_codecs, name##_platforms)
907 #define SND_SOC_DAILINK_REG2(cpu, codec) SND_SOC_DAILINK_REG3(cpu, codec, null_dailink_component)
908 #define SND_SOC_DAILINK_REG3(cpu, codec, platform) \
909 .cpus = cpu, \
910 .num_cpus = ARRAY_SIZE(cpu), \
911 .codecs = codec, \
912 .num_codecs = ARRAY_SIZE(codec), \
913 .platforms = platform, \
914 .num_platforms = ARRAY_SIZE(platform)
915
916 #define SND_SOC_DAILINK_REG(...) \
917 CONCATENATE(SND_SOC_DAILINK_REG, COUNT_ARGS(__VA_ARGS__))(__VA_ARGS__)
918
919 #define SND_SOC_DAILINK_DEF(name, def...) \
920 static struct snd_soc_dai_link_component name[] = { def }
921
922 #define SND_SOC_DAILINK_DEFS(name, cpu, codec, platform...) \
923 SND_SOC_DAILINK_DEF(name##_cpus, cpu); \
924 SND_SOC_DAILINK_DEF(name##_codecs, codec); \
925 SND_SOC_DAILINK_DEF(name##_platforms, platform)
926
927 #define DAILINK_COMP_ARRAY(param...) param
928 #define COMP_EMPTY() { }
929 #define COMP_CPU(_dai) { .dai_name = _dai, }
930 #define COMP_CODEC(_name, _dai) { .name = _name, .dai_name = _dai, }
931 #define COMP_PLATFORM(_name) { .name = _name }
932 #define COMP_AUX(_name) { .name = _name }
933 #define COMP_CODEC_CONF(_name) { .name = _name }
934 #define COMP_DUMMY() /* see snd_soc_fill_dummy_dai() */
935
936 extern struct snd_soc_dai_link_component null_dailink_component[0];
937 extern struct snd_soc_dai_link_component snd_soc_dummy_dlc;
938
939
940 struct snd_soc_codec_conf {
941 /*
942 * specify device either by device name, or by
943 * DT/OF node, but not both.
944 */
945 struct snd_soc_dai_link_component dlc;
946
947 /*
948 * optional map of kcontrol, widget and path name prefixes that are
949 * associated per device
950 */
951 const char *name_prefix;
952 };
953
954 struct snd_soc_aux_dev {
955 /*
956 * specify multi-codec either by device name, or by
957 * DT/OF node, but not both.
958 */
959 struct snd_soc_dai_link_component dlc;
960
961 /* codec/machine specific init - e.g. add machine controls */
962 int (*init)(struct snd_soc_component *component);
963 };
964
965 /* SoC card */
966 struct snd_soc_card {
967 const char *name;
968 const char *long_name;
969 const char *driver_name;
970 const char *components;
971 #ifdef CONFIG_DMI
972 char dmi_longname[80];
973 #endif /* CONFIG_DMI */
974
975 #ifdef CONFIG_PCI
976 /*
977 * PCI does not define 0 as invalid, so pci_subsystem_set indicates
978 * whether a value has been written to these fields.
979 */
980 unsigned short pci_subsystem_vendor;
981 unsigned short pci_subsystem_device;
982 bool pci_subsystem_set;
983 #endif /* CONFIG_PCI */
984
985 char topology_shortname[32];
986
987 struct device *dev;
988 struct snd_card *snd_card;
989 struct module *owner;
990
991 struct mutex mutex;
992 struct mutex dapm_mutex;
993
994 /* Mutex for PCM operations */
995 struct mutex pcm_mutex;
996 enum snd_soc_pcm_subclass pcm_subclass;
997
998 int (*probe)(struct snd_soc_card *card);
999 int (*late_probe)(struct snd_soc_card *card);
1000 void (*fixup_controls)(struct snd_soc_card *card);
1001 int (*remove)(struct snd_soc_card *card);
1002
1003 /* the pre and post PM functions are used to do any PM work before and
1004 * after the codec and DAI's do any PM work. */
1005 int (*suspend_pre)(struct snd_soc_card *card);
1006 int (*suspend_post)(struct snd_soc_card *card);
1007 int (*resume_pre)(struct snd_soc_card *card);
1008 int (*resume_post)(struct snd_soc_card *card);
1009
1010 /* callbacks */
1011 int (*set_bias_level)(struct snd_soc_card *,
1012 struct snd_soc_dapm_context *dapm,
1013 enum snd_soc_bias_level level);
1014 int (*set_bias_level_post)(struct snd_soc_card *,
1015 struct snd_soc_dapm_context *dapm,
1016 enum snd_soc_bias_level level);
1017
1018 int (*add_dai_link)(struct snd_soc_card *,
1019 struct snd_soc_dai_link *link);
1020 void (*remove_dai_link)(struct snd_soc_card *,
1021 struct snd_soc_dai_link *link);
1022
1023 long pmdown_time;
1024
1025 /* CPU <--> Codec DAI links */
1026 struct snd_soc_dai_link *dai_link; /* predefined links only */
1027 int num_links; /* predefined links only */
1028
1029 struct list_head rtd_list;
1030 int num_rtd;
1031
1032 /* optional codec specific configuration */
1033 struct snd_soc_codec_conf *codec_conf;
1034 int num_configs;
1035
1036 /*
1037 * optional auxiliary devices such as amplifiers or codecs with DAI
1038 * link unused
1039 */
1040 struct snd_soc_aux_dev *aux_dev;
1041 int num_aux_devs;
1042 struct list_head aux_comp_list;
1043
1044 const struct snd_kcontrol_new *controls;
1045 int num_controls;
1046
1047 /*
1048 * Card-specific routes and widgets.
1049 * Note: of_dapm_xxx for Device Tree; Otherwise for driver build-in.
1050 */
1051 const struct snd_soc_dapm_widget *dapm_widgets;
1052 int num_dapm_widgets;
1053 const struct snd_soc_dapm_route *dapm_routes;
1054 int num_dapm_routes;
1055 const struct snd_soc_dapm_widget *of_dapm_widgets;
1056 int num_of_dapm_widgets;
1057 const struct snd_soc_dapm_route *of_dapm_routes;
1058 int num_of_dapm_routes;
1059
1060 /* lists of probed devices belonging to this card */
1061 struct list_head component_dev_list;
1062 struct list_head list;
1063
1064 struct list_head widgets;
1065 struct list_head paths;
1066 struct list_head dapm_list;
1067 struct list_head dapm_dirty;
1068
1069 /* attached dynamic objects */
1070 struct list_head dobj_list;
1071
1072 /* Generic DAPM context for the card */
1073 struct snd_soc_dapm_context dapm;
1074 struct snd_soc_dapm_stats dapm_stats;
1075
1076 #ifdef CONFIG_DEBUG_FS
1077 struct dentry *debugfs_card_root;
1078 #endif
1079 #ifdef CONFIG_PM_SLEEP
1080 struct work_struct deferred_resume_work;
1081 #endif
1082 u32 pop_time;
1083
1084 /* bit field */
1085 unsigned int instantiated:1;
1086 unsigned int topology_shortname_created:1;
1087 unsigned int fully_routed:1;
1088 unsigned int probed:1;
1089 unsigned int component_chaining:1;
1090
1091 void *drvdata;
1092 };
1093 #define for_each_card_prelinks(card, i, link) \
1094 for ((i) = 0; \
1095 ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
1096 (i)++)
1097 #define for_each_card_pre_auxs(card, i, aux) \
1098 for ((i) = 0; \
1099 ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
1100 (i)++)
1101
1102 #define for_each_card_rtds(card, rtd) \
1103 list_for_each_entry(rtd, &(card)->rtd_list, list)
1104 #define for_each_card_rtds_safe(card, rtd, _rtd) \
1105 list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
1106
1107 #define for_each_card_auxs(card, component) \
1108 list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
1109 #define for_each_card_auxs_safe(card, component, _comp) \
1110 list_for_each_entry_safe(component, _comp, \
1111 &card->aux_comp_list, card_aux_list)
1112
1113 #define for_each_card_components(card, component) \
1114 list_for_each_entry(component, &(card)->component_dev_list, card_list)
1115
1116 #define for_each_card_dapms(card, dapm) \
1117 list_for_each_entry(dapm, &card->dapm_list, list)
1118
1119 #define for_each_card_widgets(card, w)\
1120 list_for_each_entry(w, &card->widgets, list)
1121 #define for_each_card_widgets_safe(card, w, _w) \
1122 list_for_each_entry_safe(w, _w, &card->widgets, list)
1123
1124
snd_soc_card_is_instantiated(struct snd_soc_card * card)1125 static inline int snd_soc_card_is_instantiated(struct snd_soc_card *card)
1126 {
1127 return card && card->instantiated;
1128 }
1129
1130 /* SoC machine DAI configuration, glues a codec and cpu DAI together */
1131 struct snd_soc_pcm_runtime {
1132 struct device *dev;
1133 struct snd_soc_card *card;
1134 struct snd_soc_dai_link *dai_link;
1135 struct snd_pcm_ops ops;
1136
1137 unsigned int c2c_params_select; /* currently selected c2c_param for dai link */
1138
1139 /* Dynamic PCM BE runtime data */
1140 struct snd_soc_dpcm_runtime dpcm[SNDRV_PCM_STREAM_LAST + 1];
1141 struct snd_soc_dapm_widget *c2c_widget[SNDRV_PCM_STREAM_LAST + 1];
1142
1143 long pmdown_time;
1144
1145 /* runtime devices */
1146 struct snd_pcm *pcm;
1147 struct snd_compr *compr;
1148
1149 /*
1150 * dais = cpu_dai + codec_dai
1151 * see
1152 * soc_new_pcm_runtime()
1153 * snd_soc_rtd_to_cpu()
1154 * snd_soc_rtd_to_codec()
1155 */
1156 struct snd_soc_dai **dais;
1157
1158 struct delayed_work delayed_work;
1159 void (*close_delayed_work_func)(struct snd_soc_pcm_runtime *rtd);
1160 #ifdef CONFIG_DEBUG_FS
1161 struct dentry *debugfs_dpcm_root;
1162 #endif
1163
1164 unsigned int id; /* 0-based and monotonic increasing */
1165 struct list_head list; /* rtd list of the soc card */
1166
1167 /* function mark */
1168 struct snd_pcm_substream *mark_startup;
1169 struct snd_pcm_substream *mark_hw_params;
1170 struct snd_pcm_substream *mark_trigger;
1171 struct snd_compr_stream *mark_compr_startup;
1172
1173 /* bit field */
1174 unsigned int pop_wait:1;
1175 unsigned int fe_compr:1; /* for Dynamic PCM */
1176 unsigned int initialized:1;
1177
1178 /* CPU/Codec/Platform */
1179 int num_components;
1180 struct snd_soc_component *components[] __counted_by(num_components);
1181 };
1182
1183 /* see soc_new_pcm_runtime() */
1184 #define snd_soc_rtd_to_cpu(rtd, n) (rtd)->dais[n]
1185 #define snd_soc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->dai_link->num_cpus]
1186
1187 static inline struct snd_soc_pcm_runtime *
snd_soc_substream_to_rtd(const struct snd_pcm_substream * substream)1188 snd_soc_substream_to_rtd(const struct snd_pcm_substream *substream)
1189 {
1190 return snd_pcm_substream_chip(substream);
1191 }
1192
1193 #define for_each_rtd_components(rtd, i, component) \
1194 for ((i) = 0, component = NULL; \
1195 ((i) < rtd->num_components) && ((component) = rtd->components[i]);\
1196 (i)++)
1197 #define for_each_rtd_cpu_dais(rtd, i, dai) \
1198 for ((i) = 0; \
1199 ((i) < rtd->dai_link->num_cpus) && ((dai) = snd_soc_rtd_to_cpu(rtd, i)); \
1200 (i)++)
1201 #define for_each_rtd_codec_dais(rtd, i, dai) \
1202 for ((i) = 0; \
1203 ((i) < rtd->dai_link->num_codecs) && ((dai) = snd_soc_rtd_to_codec(rtd, i)); \
1204 (i)++)
1205 #define for_each_rtd_dais(rtd, i, dai) \
1206 for ((i) = 0; \
1207 ((i) < (rtd)->dai_link->num_cpus + (rtd)->dai_link->num_codecs) && \
1208 ((dai) = (rtd)->dais[i]); \
1209 (i)++)
1210 #define for_each_rtd_dais_reverse(rtd, i, dai) \
1211 for ((i) = (rtd)->dai_link->num_cpus + (rtd)->dai_link->num_codecs - 1; \
1212 (i) >= 0 && ((dai) = (rtd)->dais[i]); \
1213 (i)--)
1214 #define for_each_rtd_ch_maps(rtd, i, ch_maps) for_each_link_ch_maps(rtd->dai_link, i, ch_maps)
1215
1216 void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);
1217
1218 /* mixer control */
1219 struct soc_mixer_control {
1220 /* Minimum and maximum specified as written to the hardware */
1221 int min, max;
1222 /* Limited maximum value specified as presented through the control */
1223 int platform_max;
1224 int reg, rreg;
1225 unsigned int shift, rshift;
1226 u32 num_channels;
1227 unsigned int sign_bit;
1228 unsigned int invert:1;
1229 unsigned int autodisable:1;
1230 #ifdef CONFIG_SND_SOC_TOPOLOGY
1231 struct snd_soc_dobj dobj;
1232 #endif
1233 };
1234
1235 struct soc_bytes {
1236 int base;
1237 int num_regs;
1238 u32 mask;
1239 };
1240
1241 struct soc_bytes_ext {
1242 int max;
1243 #ifdef CONFIG_SND_SOC_TOPOLOGY
1244 struct snd_soc_dobj dobj;
1245 #endif
1246 /* used for TLV byte control */
1247 int (*get)(struct snd_kcontrol *kcontrol, unsigned int __user *bytes,
1248 unsigned int size);
1249 int (*put)(struct snd_kcontrol *kcontrol, const unsigned int __user *bytes,
1250 unsigned int size);
1251 };
1252
1253 /* multi register control */
1254 struct soc_mreg_control {
1255 long min, max;
1256 unsigned int regbase, regcount, nbits, invert;
1257 };
1258
1259 /* enumerated kcontrol */
1260 struct soc_enum {
1261 int reg;
1262 unsigned char shift_l;
1263 unsigned char shift_r;
1264 unsigned int items;
1265 unsigned int mask;
1266 const char * const *texts;
1267 const unsigned int *values;
1268 unsigned int autodisable:1;
1269 #ifdef CONFIG_SND_SOC_TOPOLOGY
1270 struct snd_soc_dobj dobj;
1271 #endif
1272 };
1273
snd_soc_volsw_is_stereo(const struct soc_mixer_control * mc)1274 static inline bool snd_soc_volsw_is_stereo(const struct soc_mixer_control *mc)
1275 {
1276 if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1277 return false;
1278 /*
1279 * mc->reg == mc->rreg && mc->shift != mc->rshift, or
1280 * mc->reg != mc->rreg means that the control is
1281 * stereo (bits in one register or in two registers)
1282 */
1283 return true;
1284 }
1285
snd_soc_enum_val_to_item(const struct soc_enum * e,unsigned int val)1286 static inline unsigned int snd_soc_enum_val_to_item(const struct soc_enum *e,
1287 unsigned int val)
1288 {
1289 unsigned int i;
1290
1291 if (!e->values)
1292 return val;
1293
1294 for (i = 0; i < e->items; i++)
1295 if (val == e->values[i])
1296 return i;
1297
1298 return 0;
1299 }
1300
snd_soc_enum_item_to_val(const struct soc_enum * e,unsigned int item)1301 static inline unsigned int snd_soc_enum_item_to_val(const struct soc_enum *e,
1302 unsigned int item)
1303 {
1304 if (!e->values)
1305 return item;
1306
1307 return e->values[item];
1308 }
1309
1310 /**
1311 * snd_soc_kcontrol_component() - Returns the component that registered the
1312 * control
1313 * @kcontrol: The control for which to get the component
1314 *
1315 * Note: This function will work correctly if the control has been registered
1316 * for a component. With snd_soc_add_codec_controls() or via table based
1317 * setup for either a CODEC or component driver. Otherwise the behavior is
1318 * undefined.
1319 */
snd_soc_kcontrol_component(struct snd_kcontrol * kcontrol)1320 static inline struct snd_soc_component *snd_soc_kcontrol_component(
1321 struct snd_kcontrol *kcontrol)
1322 {
1323 return snd_kcontrol_chip(kcontrol);
1324 }
1325
1326 int snd_soc_util_init(void);
1327 void snd_soc_util_exit(void);
1328
1329 int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1330 const char *propname);
1331 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
1332 const char *propname);
1333 int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop);
1334 int snd_soc_of_get_slot_mask(struct device_node *np,
1335 const char *prop_name,
1336 unsigned int *mask);
1337 int snd_soc_of_parse_tdm_slot(struct device_node *np,
1338 unsigned int *tx_mask,
1339 unsigned int *rx_mask,
1340 unsigned int *slots,
1341 unsigned int *slot_width);
1342 void snd_soc_of_parse_node_prefix(struct device_node *np,
1343 struct snd_soc_codec_conf *codec_conf,
1344 struct device_node *of_node,
1345 const char *propname);
1346 static inline
snd_soc_of_parse_audio_prefix(struct snd_soc_card * card,struct snd_soc_codec_conf * codec_conf,struct device_node * of_node,const char * propname)1347 void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
1348 struct snd_soc_codec_conf *codec_conf,
1349 struct device_node *of_node,
1350 const char *propname)
1351 {
1352 snd_soc_of_parse_node_prefix(card->dev->of_node,
1353 codec_conf, of_node, propname);
1354 }
1355
1356 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1357 const char *propname);
1358 int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname);
1359
1360 unsigned int snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt);
1361 unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame);
1362
1363 unsigned int snd_soc_daifmt_parse_format(struct device_node *np, const char *prefix);
1364 unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np,
1365 const char *prefix,
1366 struct device_node **bitclkmaster,
1367 struct device_node **framemaster);
1368 #define snd_soc_daifmt_parse_clock_provider_as_bitmap(np, prefix) \
1369 snd_soc_daifmt_parse_clock_provider_raw(np, prefix, NULL, NULL)
1370 #define snd_soc_daifmt_parse_clock_provider_as_phandle \
1371 snd_soc_daifmt_parse_clock_provider_raw
1372 #define snd_soc_daifmt_parse_clock_provider_as_flag(np, prefix) \
1373 snd_soc_daifmt_clock_provider_from_bitmap( \
1374 snd_soc_daifmt_parse_clock_provider_as_bitmap(np, prefix))
1375
1376 int snd_soc_get_stream_cpu(const struct snd_soc_dai_link *dai_link, int stream);
1377 int snd_soc_get_dlc(const struct of_phandle_args *args,
1378 struct snd_soc_dai_link_component *dlc);
1379 int snd_soc_of_get_dlc(struct device_node *of_node,
1380 struct of_phandle_args *args,
1381 struct snd_soc_dai_link_component *dlc,
1382 int index);
1383 int snd_soc_get_dai_id(struct device_node *ep);
1384 int snd_soc_get_dai_name(const struct of_phandle_args *args,
1385 const char **dai_name);
1386 int snd_soc_of_get_dai_name(struct device_node *of_node,
1387 const char **dai_name, int index);
1388 int snd_soc_of_get_dai_link_codecs(struct device *dev,
1389 struct device_node *of_node,
1390 struct snd_soc_dai_link *dai_link);
1391 void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link);
1392 int snd_soc_of_get_dai_link_cpus(struct device *dev,
1393 struct device_node *of_node,
1394 struct snd_soc_dai_link *dai_link);
1395 void snd_soc_of_put_dai_link_cpus(struct snd_soc_dai_link *dai_link);
1396
1397 int snd_soc_add_pcm_runtimes(struct snd_soc_card *card,
1398 struct snd_soc_dai_link *dai_link,
1399 int num_dai_link);
1400 void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
1401 struct snd_soc_pcm_runtime *rtd);
1402
1403 void snd_soc_dlc_use_cpu_as_platform(struct snd_soc_dai_link_component *platforms,
1404 struct snd_soc_dai_link_component *cpus);
1405 struct of_phandle_args *snd_soc_copy_dai_args(struct device *dev,
1406 const struct of_phandle_args *args);
1407 struct snd_soc_dai *snd_soc_get_dai_via_args(const struct of_phandle_args *dai_args);
1408 struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
1409 struct snd_soc_dai_driver *dai_drv,
1410 bool legacy_dai_naming);
1411 void snd_soc_unregister_dai(struct snd_soc_dai *dai);
1412
1413 struct snd_soc_dai *snd_soc_find_dai(
1414 const struct snd_soc_dai_link_component *dlc);
1415 struct snd_soc_dai *snd_soc_find_dai_with_mutex(
1416 const struct snd_soc_dai_link_component *dlc);
1417
1418 #include <sound/soc-dai.h>
1419
1420 static inline
snd_soc_fixup_dai_links_platform_name(struct snd_soc_card * card,const char * platform_name)1421 int snd_soc_fixup_dai_links_platform_name(struct snd_soc_card *card,
1422 const char *platform_name)
1423 {
1424 struct snd_soc_dai_link *dai_link;
1425 const char *name;
1426 int i;
1427
1428 if (!platform_name) /* nothing to do */
1429 return 0;
1430
1431 /* set platform name for each dailink */
1432 for_each_card_prelinks(card, i, dai_link) {
1433 /* only single platform is supported for now */
1434 if (dai_link->num_platforms != 1)
1435 return -EINVAL;
1436
1437 if (!dai_link->platforms)
1438 return -EINVAL;
1439
1440 name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
1441 if (!name)
1442 return -ENOMEM;
1443
1444 /* only single platform is supported for now */
1445 dai_link->platforms->name = name;
1446 }
1447
1448 return 0;
1449 }
1450
1451 #ifdef CONFIG_DEBUG_FS
1452 extern struct dentry *snd_soc_debugfs_root;
1453 #endif
1454
1455 extern const struct dev_pm_ops snd_soc_pm_ops;
1456
1457 /*
1458 * DAPM helper functions
1459 */
1460 enum snd_soc_dapm_subclass {
1461 SND_SOC_DAPM_CLASS_ROOT = 0,
1462 SND_SOC_DAPM_CLASS_RUNTIME = 1,
1463 };
1464
_snd_soc_dapm_mutex_lock_root_c(struct snd_soc_card * card)1465 static inline void _snd_soc_dapm_mutex_lock_root_c(struct snd_soc_card *card)
1466 {
1467 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_ROOT);
1468 }
1469
_snd_soc_dapm_mutex_lock_c(struct snd_soc_card * card)1470 static inline void _snd_soc_dapm_mutex_lock_c(struct snd_soc_card *card)
1471 {
1472 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1473 }
1474
_snd_soc_dapm_mutex_unlock_c(struct snd_soc_card * card)1475 static inline void _snd_soc_dapm_mutex_unlock_c(struct snd_soc_card *card)
1476 {
1477 mutex_unlock(&card->dapm_mutex);
1478 }
1479
_snd_soc_dapm_mutex_assert_held_c(struct snd_soc_card * card)1480 static inline void _snd_soc_dapm_mutex_assert_held_c(struct snd_soc_card *card)
1481 {
1482 lockdep_assert_held(&card->dapm_mutex);
1483 }
1484
_snd_soc_dapm_mutex_lock_root_d(struct snd_soc_dapm_context * dapm)1485 static inline void _snd_soc_dapm_mutex_lock_root_d(struct snd_soc_dapm_context *dapm)
1486 {
1487 _snd_soc_dapm_mutex_lock_root_c(dapm->card);
1488 }
1489
_snd_soc_dapm_mutex_lock_d(struct snd_soc_dapm_context * dapm)1490 static inline void _snd_soc_dapm_mutex_lock_d(struct snd_soc_dapm_context *dapm)
1491 {
1492 _snd_soc_dapm_mutex_lock_c(dapm->card);
1493 }
1494
_snd_soc_dapm_mutex_unlock_d(struct snd_soc_dapm_context * dapm)1495 static inline void _snd_soc_dapm_mutex_unlock_d(struct snd_soc_dapm_context *dapm)
1496 {
1497 _snd_soc_dapm_mutex_unlock_c(dapm->card);
1498 }
1499
_snd_soc_dapm_mutex_assert_held_d(struct snd_soc_dapm_context * dapm)1500 static inline void _snd_soc_dapm_mutex_assert_held_d(struct snd_soc_dapm_context *dapm)
1501 {
1502 _snd_soc_dapm_mutex_assert_held_c(dapm->card);
1503 }
1504
1505 #define snd_soc_dapm_mutex_lock_root(x) _Generic((x), \
1506 struct snd_soc_card * : _snd_soc_dapm_mutex_lock_root_c, \
1507 struct snd_soc_dapm_context * : _snd_soc_dapm_mutex_lock_root_d)(x)
1508 #define snd_soc_dapm_mutex_lock(x) _Generic((x), \
1509 struct snd_soc_card * : _snd_soc_dapm_mutex_lock_c, \
1510 struct snd_soc_dapm_context * : _snd_soc_dapm_mutex_lock_d)(x)
1511 #define snd_soc_dapm_mutex_unlock(x) _Generic((x), \
1512 struct snd_soc_card * : _snd_soc_dapm_mutex_unlock_c, \
1513 struct snd_soc_dapm_context * : _snd_soc_dapm_mutex_unlock_d)(x)
1514 #define snd_soc_dapm_mutex_assert_held(x) _Generic((x), \
1515 struct snd_soc_card * : _snd_soc_dapm_mutex_assert_held_c, \
1516 struct snd_soc_dapm_context * : _snd_soc_dapm_mutex_assert_held_d)(x)
1517
1518 /*
1519 * PCM helper functions
1520 */
_snd_soc_dpcm_mutex_lock_c(struct snd_soc_card * card)1521 static inline void _snd_soc_dpcm_mutex_lock_c(struct snd_soc_card *card)
1522 {
1523 mutex_lock_nested(&card->pcm_mutex, card->pcm_subclass);
1524 }
1525
_snd_soc_dpcm_mutex_unlock_c(struct snd_soc_card * card)1526 static inline void _snd_soc_dpcm_mutex_unlock_c(struct snd_soc_card *card)
1527 {
1528 mutex_unlock(&card->pcm_mutex);
1529 }
1530
_snd_soc_dpcm_mutex_assert_held_c(struct snd_soc_card * card)1531 static inline void _snd_soc_dpcm_mutex_assert_held_c(struct snd_soc_card *card)
1532 {
1533 lockdep_assert_held(&card->pcm_mutex);
1534 }
1535
_snd_soc_dpcm_mutex_lock_r(struct snd_soc_pcm_runtime * rtd)1536 static inline void _snd_soc_dpcm_mutex_lock_r(struct snd_soc_pcm_runtime *rtd)
1537 {
1538 _snd_soc_dpcm_mutex_lock_c(rtd->card);
1539 }
1540
_snd_soc_dpcm_mutex_unlock_r(struct snd_soc_pcm_runtime * rtd)1541 static inline void _snd_soc_dpcm_mutex_unlock_r(struct snd_soc_pcm_runtime *rtd)
1542 {
1543 _snd_soc_dpcm_mutex_unlock_c(rtd->card);
1544 }
1545
_snd_soc_dpcm_mutex_assert_held_r(struct snd_soc_pcm_runtime * rtd)1546 static inline void _snd_soc_dpcm_mutex_assert_held_r(struct snd_soc_pcm_runtime *rtd)
1547 {
1548 _snd_soc_dpcm_mutex_assert_held_c(rtd->card);
1549 }
1550
1551 #define snd_soc_dpcm_mutex_lock(x) _Generic((x), \
1552 struct snd_soc_card * : _snd_soc_dpcm_mutex_lock_c, \
1553 struct snd_soc_pcm_runtime * : _snd_soc_dpcm_mutex_lock_r)(x)
1554
1555 #define snd_soc_dpcm_mutex_unlock(x) _Generic((x), \
1556 struct snd_soc_card * : _snd_soc_dpcm_mutex_unlock_c, \
1557 struct snd_soc_pcm_runtime * : _snd_soc_dpcm_mutex_unlock_r)(x)
1558
1559 #define snd_soc_dpcm_mutex_assert_held(x) _Generic((x), \
1560 struct snd_soc_card * : _snd_soc_dpcm_mutex_assert_held_c, \
1561 struct snd_soc_pcm_runtime * : _snd_soc_dpcm_mutex_assert_held_r)(x)
1562
1563 #include <sound/soc-component.h>
1564 #include <sound/soc-card.h>
1565 #include <sound/soc-jack.h>
1566
1567 #endif
1568