Root/include/sound/soc.h

1/*
2 * linux/sound/soc.h -- ALSA SoC Layer
3 *
4 * Author: Liam Girdwood
5 * Created: Aug 11th 2005
6 * Copyright: Wolfson Microelectronics. PLC.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#ifndef __LINUX_SND_SOC_H
14#define __LINUX_SND_SOC_H
15
16#include <linux/of.h>
17#include <linux/platform_device.h>
18#include <linux/types.h>
19#include <linux/notifier.h>
20#include <linux/workqueue.h>
21#include <linux/interrupt.h>
22#include <linux/kernel.h>
23#include <linux/regmap.h>
24#include <linux/log2.h>
25#include <sound/core.h>
26#include <sound/pcm.h>
27#include <sound/compress_driver.h>
28#include <sound/control.h>
29#include <sound/ac97_codec.h>
30
31/*
32 * Convenience kcontrol builders
33 */
34#define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert, xautodisable) \
35    ((unsigned long)&(struct soc_mixer_control) \
36    {.reg = xreg, .rreg = xreg, .shift = shift_left, \
37    .rshift = shift_right, .max = xmax, .platform_max = xmax, \
38    .invert = xinvert, .autodisable = xautodisable})
39#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
40    SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert, xautodisable)
41#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
42    ((unsigned long)&(struct soc_mixer_control) \
43    {.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
44#define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
45    ((unsigned long)&(struct soc_mixer_control) \
46    {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
47    .max = xmax, .platform_max = xmax, .invert = xinvert})
48#define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
49    ((unsigned long)&(struct soc_mixer_control) \
50    {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
51    .min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
52#define SOC_SINGLE(xname, reg, shift, max, invert) \
53{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
54    .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
55    .put = snd_soc_put_volsw, \
56    .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
57#define SOC_SINGLE_RANGE(xname, xreg, xshift, xmin, xmax, xinvert) \
58{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
59    .info = snd_soc_info_volsw_range, .get = snd_soc_get_volsw_range, \
60    .put = snd_soc_put_volsw_range, \
61    .private_value = (unsigned long)&(struct soc_mixer_control) \
62        {.reg = xreg, .rreg = xreg, .shift = xshift, \
63         .rshift = xshift, .min = xmin, .max = xmax, \
64         .platform_max = xmax, .invert = xinvert} }
65#define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
66{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
67    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
68         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
69    .tlv.p = (tlv_array), \
70    .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
71    .put = snd_soc_put_volsw, \
72    .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
73#define SOC_SINGLE_SX_TLV(xname, xreg, xshift, xmin, xmax, tlv_array) \
74{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
75    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
76    SNDRV_CTL_ELEM_ACCESS_READWRITE, \
77    .tlv.p = (tlv_array),\
78    .info = snd_soc_info_volsw, \
79    .get = snd_soc_get_volsw_sx,\
80    .put = snd_soc_put_volsw_sx, \
81    .private_value = (unsigned long)&(struct soc_mixer_control) \
82        {.reg = xreg, .rreg = xreg, \
83        .shift = xshift, .rshift = xshift, \
84        .max = xmax, .min = xmin} }
85#define SOC_SINGLE_RANGE_TLV(xname, xreg, xshift, xmin, xmax, xinvert, tlv_array) \
86{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
87    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
88         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
89    .tlv.p = (tlv_array), \
90    .info = snd_soc_info_volsw_range, \
91    .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
92    .private_value = (unsigned long)&(struct soc_mixer_control) \
93        {.reg = xreg, .rreg = xreg, .shift = xshift, \
94         .rshift = xshift, .min = xmin, .max = xmax, \
95         .platform_max = xmax, .invert = xinvert} }
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                      max, invert, 0) }
102#define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
103{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
104    .info = snd_soc_info_volsw, \
105    .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
106    .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
107                        xmax, xinvert) }
108#define SOC_DOUBLE_R_RANGE(xname, reg_left, reg_right, xshift, xmin, \
109               xmax, xinvert) \
110{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
111    .info = snd_soc_info_volsw_range, \
112    .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
113    .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
114                        xshift, xmin, xmax, xinvert) }
115#define SOC_DOUBLE_TLV(xname, reg, shift_left, shift_right, max, invert, tlv_array) \
116{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
117    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
118         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
119    .tlv.p = (tlv_array), \
120    .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
121    .put = snd_soc_put_volsw, \
122    .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
123                      max, invert, 0) }
124#define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
125{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
126    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
127         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
128    .tlv.p = (tlv_array), \
129    .info = snd_soc_info_volsw, \
130    .get = snd_soc_get_volsw, .put = snd_soc_put_volsw, \
131    .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
132                        xmax, xinvert) }
133#define SOC_DOUBLE_R_RANGE_TLV(xname, reg_left, reg_right, xshift, xmin, \
134                   xmax, xinvert, tlv_array) \
135{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
136    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
137         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
138    .tlv.p = (tlv_array), \
139    .info = snd_soc_info_volsw_range, \
140    .get = snd_soc_get_volsw_range, .put = snd_soc_put_volsw_range, \
141    .private_value = SOC_DOUBLE_R_RANGE_VALUE(reg_left, reg_right, \
142                        xshift, xmin, xmax, xinvert) }
143#define SOC_DOUBLE_R_SX_TLV(xname, xreg, xrreg, xshift, xmin, xmax, 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_sx, \
150    .put = snd_soc_put_volsw_sx, \
151    .private_value = (unsigned long)&(struct soc_mixer_control) \
152        {.reg = xreg, .rreg = xrreg, \
153        .shift = xshift, .rshift = xshift, \
154        .max = xmax, .min = xmin} }
155#define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
156{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
157    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
158          SNDRV_CTL_ELEM_ACCESS_READWRITE, \
159    .tlv.p = (tlv_array), \
160    .info = snd_soc_info_volsw_s8, .get = snd_soc_get_volsw_s8, \
161    .put = snd_soc_put_volsw_s8, \
162    .private_value = (unsigned long)&(struct soc_mixer_control) \
163        {.reg = xreg, .min = xmin, .max = xmax, \
164         .platform_max = xmax} }
165#define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \
166{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
167    .max = xmax, .texts = xtexts, \
168    .mask = xmax ? roundup_pow_of_two(xmax) - 1 : 0}
169#define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \
170    SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)
171#define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
172{ .max = xmax, .texts = xtexts }
173#define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
174{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
175    .mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
176#define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
177    SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
178#define SOC_ENUM(xname, xenum) \
179{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
180    .info = snd_soc_info_enum_double, \
181    .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
182    .private_value = (unsigned long)&xenum }
183#define SOC_VALUE_ENUM(xname, xenum) \
184{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
185    .info = snd_soc_info_enum_double, \
186    .get = snd_soc_get_value_enum_double, \
187    .put = snd_soc_put_value_enum_double, \
188    .private_value = (unsigned long)&xenum }
189#define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
190     xhandler_get, xhandler_put) \
191{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
192    .info = snd_soc_info_volsw, \
193    .get = xhandler_get, .put = xhandler_put, \
194    .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
195#define SOC_DOUBLE_EXT(xname, reg, shift_left, shift_right, max, invert,\
196     xhandler_get, xhandler_put) \
197{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
198    .info = snd_soc_info_volsw, \
199    .get = xhandler_get, .put = xhandler_put, \
200    .private_value = \
201        SOC_DOUBLE_VALUE(reg, shift_left, shift_right, max, invert, 0) }
202#define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
203     xhandler_get, xhandler_put, tlv_array) \
204{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
205    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
206         SNDRV_CTL_ELEM_ACCESS_READWRITE,\
207    .tlv.p = (tlv_array), \
208    .info = snd_soc_info_volsw, \
209    .get = xhandler_get, .put = xhandler_put, \
210    .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, 0) }
211#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
212     xhandler_get, xhandler_put, tlv_array) \
213{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
214    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
215         SNDRV_CTL_ELEM_ACCESS_READWRITE, \
216    .tlv.p = (tlv_array), \
217    .info = snd_soc_info_volsw, \
218    .get = xhandler_get, .put = xhandler_put, \
219    .private_value = SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, \
220                      xmax, xinvert, 0) }
221#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
222     xhandler_get, xhandler_put, tlv_array) \
223{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
224    .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
225         SNDRV_CTL_ELEM_ACCESS_READWRITE, \
226    .tlv.p = (tlv_array), \
227    .info = snd_soc_info_volsw, \
228    .get = xhandler_get, .put = xhandler_put, \
229    .private_value = SOC_DOUBLE_R_VALUE(reg_left, reg_right, xshift, \
230                        xmax, xinvert) }
231#define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
232{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
233    .info = snd_soc_info_bool_ext, \
234    .get = xhandler_get, .put = xhandler_put, \
235    .private_value = xdata }
236#define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
237{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
238    .info = snd_soc_info_enum_double, \
239    .get = xhandler_get, .put = xhandler_put, \
240    .private_value = (unsigned long)&xenum }
241
242#define SND_SOC_BYTES(xname, xbase, xregs) \
243{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
244    .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
245    .put = snd_soc_bytes_put, .private_value = \
246        ((unsigned long)&(struct soc_bytes) \
247        {.base = xbase, .num_regs = xregs }) }
248
249#define SND_SOC_BYTES_MASK(xname, xbase, xregs, xmask) \
250{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
251    .info = snd_soc_bytes_info, .get = snd_soc_bytes_get, \
252    .put = snd_soc_bytes_put, .private_value = \
253        ((unsigned long)&(struct soc_bytes) \
254        {.base = xbase, .num_regs = xregs, \
255         .mask = xmask }) }
256
257#define SOC_SINGLE_XR_SX(xname, xregbase, xregcount, xnbits, \
258        xmin, xmax, xinvert) \
259{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
260    .info = snd_soc_info_xr_sx, .get = snd_soc_get_xr_sx, \
261    .put = snd_soc_put_xr_sx, \
262    .private_value = (unsigned long)&(struct soc_mreg_control) \
263        {.regbase = xregbase, .regcount = xregcount, .nbits = xnbits, \
264        .invert = xinvert, .min = xmin, .max = xmax} }
265
266#define SOC_SINGLE_STROBE(xname, xreg, xshift, xinvert) \
267    SOC_SINGLE_EXT(xname, xreg, xshift, 1, xinvert, \
268        snd_soc_get_strobe, snd_soc_put_strobe)
269
270/*
271 * Simplified versions of above macros, declaring a struct and calculating
272 * ARRAY_SIZE internally
273 */
274#define SOC_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xtexts) \
275    struct soc_enum name = SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, \
276                        ARRAY_SIZE(xtexts), xtexts)
277#define SOC_ENUM_SINGLE_DECL(name, xreg, xshift, xtexts) \
278    SOC_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xtexts)
279#define SOC_ENUM_SINGLE_EXT_DECL(name, xtexts) \
280    struct soc_enum name = SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(xtexts), xtexts)
281#define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
282    struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
283                            ARRAY_SIZE(xtexts), xtexts, xvalues)
284#define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
285    SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
286
287/*
288 * Component probe and remove ordering levels for components with runtime
289 * dependencies.
290 */
291#define SND_SOC_COMP_ORDER_FIRST -2
292#define SND_SOC_COMP_ORDER_EARLY -1
293#define SND_SOC_COMP_ORDER_NORMAL 0
294#define SND_SOC_COMP_ORDER_LATE 1
295#define SND_SOC_COMP_ORDER_LAST 2
296
297/*
298 * Bias levels
299 *
300 * @ON: Bias is fully on for audio playback and capture operations.
301 * @PREPARE: Prepare for audio operations. Called before DAPM switching for
302 * stream start and stop operations.
303 * @STANDBY: Low power standby state when no playback/capture operations are
304 * in progress. NOTE: The transition time between STANDBY and ON
305 * should be as fast as possible and no longer than 10ms.
306 * @OFF: Power Off. No restrictions on transition times.
307 */
308enum snd_soc_bias_level {
309    SND_SOC_BIAS_OFF = 0,
310    SND_SOC_BIAS_STANDBY = 1,
311    SND_SOC_BIAS_PREPARE = 2,
312    SND_SOC_BIAS_ON = 3,
313};
314
315struct device_node;
316struct snd_jack;
317struct snd_soc_card;
318struct snd_soc_pcm_stream;
319struct snd_soc_ops;
320struct snd_soc_pcm_runtime;
321struct snd_soc_dai;
322struct snd_soc_dai_driver;
323struct snd_soc_platform;
324struct snd_soc_dai_link;
325struct snd_soc_platform_driver;
326struct snd_soc_codec;
327struct snd_soc_codec_driver;
328struct snd_soc_component;
329struct snd_soc_component_driver;
330struct soc_enum;
331struct snd_soc_jack;
332struct snd_soc_jack_zone;
333struct snd_soc_jack_pin;
334#include <sound/soc-dapm.h>
335#include <sound/soc-dpcm.h>
336
337#ifdef CONFIG_GPIOLIB
338struct snd_soc_jack_gpio;
339#endif
340
341typedef int (*hw_write_t)(void *,const char* ,int);
342
343extern struct snd_ac97_bus_ops *soc_ac97_ops;
344
345enum snd_soc_control_type {
346    SND_SOC_I2C = 1,
347    SND_SOC_SPI,
348    SND_SOC_REGMAP,
349};
350
351enum snd_soc_pcm_subclass {
352    SND_SOC_PCM_CLASS_PCM = 0,
353    SND_SOC_PCM_CLASS_BE = 1,
354};
355
356enum snd_soc_card_subclass {
357    SND_SOC_CARD_CLASS_INIT = 0,
358    SND_SOC_CARD_CLASS_RUNTIME = 1,
359};
360
361int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
362                 int source, unsigned int freq, int dir);
363int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
364              unsigned int freq_in, unsigned int freq_out);
365
366int snd_soc_register_card(struct snd_soc_card *card);
367int snd_soc_unregister_card(struct snd_soc_card *card);
368int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
369int snd_soc_suspend(struct device *dev);
370int snd_soc_resume(struct device *dev);
371int snd_soc_poweroff(struct device *dev);
372int snd_soc_register_platform(struct device *dev,
373        const struct snd_soc_platform_driver *platform_drv);
374void snd_soc_unregister_platform(struct device *dev);
375int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
376        const struct snd_soc_platform_driver *platform_drv);
377void snd_soc_remove_platform(struct snd_soc_platform *platform);
378struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev);
379int snd_soc_register_codec(struct device *dev,
380        const struct snd_soc_codec_driver *codec_drv,
381        struct snd_soc_dai_driver *dai_drv, int num_dai);
382void snd_soc_unregister_codec(struct device *dev);
383int snd_soc_register_component(struct device *dev,
384             const struct snd_soc_component_driver *cmpnt_drv,
385             struct snd_soc_dai_driver *dai_drv, int num_dai);
386int devm_snd_soc_register_component(struct device *dev,
387             const struct snd_soc_component_driver *cmpnt_drv,
388             struct snd_soc_dai_driver *dai_drv, int num_dai);
389void snd_soc_unregister_component(struct device *dev);
390int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
391                    unsigned int reg);
392int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
393                    unsigned int reg);
394int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
395                    unsigned int reg);
396int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
397                   int addr_bits, int data_bits,
398                   enum snd_soc_control_type control);
399int snd_soc_cache_sync(struct snd_soc_codec *codec);
400int snd_soc_cache_init(struct snd_soc_codec *codec);
401int snd_soc_cache_exit(struct snd_soc_codec *codec);
402int snd_soc_cache_write(struct snd_soc_codec *codec,
403            unsigned int reg, unsigned int value);
404int snd_soc_cache_read(struct snd_soc_codec *codec,
405               unsigned int reg, unsigned int *value);
406int snd_soc_platform_read(struct snd_soc_platform *platform,
407                    unsigned int reg);
408int snd_soc_platform_write(struct snd_soc_platform *platform,
409                    unsigned int reg, unsigned int val);
410int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
411int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num);
412
413struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
414        const char *dai_link, int stream);
415struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
416        const char *dai_link);
417
418/* Utility functions to get clock rates from various things */
419int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
420int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
421int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
422int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
423
424/* set runtime hw params */
425int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
426    const struct snd_pcm_hardware *hw);
427
428int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
429        int cmd, struct snd_soc_platform *platform);
430
431/* Jack reporting */
432int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
433             struct snd_soc_jack *jack);
434void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
435int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
436              struct snd_soc_jack_pin *pins);
437void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
438                    struct notifier_block *nb);
439void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
440                      struct notifier_block *nb);
441int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
442              struct snd_soc_jack_zone *zones);
443int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage);
444#ifdef CONFIG_GPIOLIB
445int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
446            struct snd_soc_jack_gpio *gpios);
447void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
448            struct snd_soc_jack_gpio *gpios);
449#endif
450
451/* codec register bit access */
452int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
453                unsigned int mask, unsigned int value);
454int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
455                   unsigned short reg, unsigned int mask,
456                   unsigned int value);
457int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
458                unsigned int mask, unsigned int value);
459
460int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
461    struct snd_ac97_bus_ops *ops, int num);
462void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
463
464int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops);
465int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
466        struct platform_device *pdev);
467
468/*
469 *Controls
470 */
471struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
472                  void *data, const char *long_name,
473                  const char *prefix);
474struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
475                           const char *name);
476int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
477    const struct snd_kcontrol_new *controls, int num_controls);
478int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
479    const struct snd_kcontrol_new *controls, int num_controls);
480int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
481    const struct snd_kcontrol_new *controls, int num_controls);
482int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
483    const struct snd_kcontrol_new *controls, int num_controls);
484int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
485    struct snd_ctl_elem_info *uinfo);
486int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
487    struct snd_ctl_elem_value *ucontrol);
488int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
489    struct snd_ctl_elem_value *ucontrol);
490int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
491    struct snd_ctl_elem_value *ucontrol);
492int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
493    struct snd_ctl_elem_value *ucontrol);
494int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
495    struct snd_ctl_elem_info *uinfo);
496#define snd_soc_info_bool_ext snd_ctl_boolean_mono_info
497int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
498    struct snd_ctl_elem_value *ucontrol);
499int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
500    struct snd_ctl_elem_value *ucontrol);
501#define snd_soc_get_volsw_2r snd_soc_get_volsw
502#define snd_soc_put_volsw_2r snd_soc_put_volsw
503int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
504    struct snd_ctl_elem_value *ucontrol);
505int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
506    struct snd_ctl_elem_value *ucontrol);
507int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
508    struct snd_ctl_elem_info *uinfo);
509int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
510    struct snd_ctl_elem_value *ucontrol);
511int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
512    struct snd_ctl_elem_value *ucontrol);
513int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
514    struct snd_ctl_elem_info *uinfo);
515int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
516    struct snd_ctl_elem_value *ucontrol);
517int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
518    struct snd_ctl_elem_value *ucontrol);
519int snd_soc_limit_volume(struct snd_soc_codec *codec,
520    const char *name, int max);
521int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
522               struct snd_ctl_elem_info *uinfo);
523int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
524              struct snd_ctl_elem_value *ucontrol);
525int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
526              struct snd_ctl_elem_value *ucontrol);
527int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
528    struct snd_ctl_elem_info *uinfo);
529int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
530    struct snd_ctl_elem_value *ucontrol);
531int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
532    struct snd_ctl_elem_value *ucontrol);
533int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
534    struct snd_ctl_elem_value *ucontrol);
535int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
536    struct snd_ctl_elem_value *ucontrol);
537
538/**
539 * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
540 *
541 * @pin: name of the pin to update
542 * @mask: bits to check for in reported jack status
543 * @invert: if non-zero then pin is enabled when status is not reported
544 */
545struct snd_soc_jack_pin {
546    struct list_head list;
547    const char *pin;
548    int mask;
549    bool invert;
550};
551
552/**
553 * struct snd_soc_jack_zone - Describes voltage zones of jack detection
554 *
555 * @min_mv: start voltage in mv
556 * @max_mv: end voltage in mv
557 * @jack_type: type of jack that is expected for this voltage
558 * @debounce_time: debounce_time for jack, codec driver should wait for this
559 * duration before reading the adc for voltages
560 * @:list: list container
561 */
562struct snd_soc_jack_zone {
563    unsigned int min_mv;
564    unsigned int max_mv;
565    unsigned int jack_type;
566    unsigned int debounce_time;
567    struct list_head list;
568};
569
570/**
571 * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
572 *
573 * @gpio: gpio number
574 * @name: gpio name
575 * @report: value to report when jack detected
576 * @invert: report presence in low state
577 * @debouce_time: debouce time in ms
578 * @wake: enable as wake source
579 * @jack_status_check: callback function which overrides the detection
580 * to provide more complex checks (eg, reading an
581 * ADC).
582 */
583#ifdef CONFIG_GPIOLIB
584struct snd_soc_jack_gpio {
585    unsigned int gpio;
586    const char *name;
587    int report;
588    int invert;
589    int debounce_time;
590    bool wake;
591
592    struct snd_soc_jack *jack;
593    struct delayed_work work;
594
595    int (*jack_status_check)(void);
596};
597#endif
598
599struct snd_soc_jack {
600    struct mutex mutex;
601    struct snd_jack *jack;
602    struct snd_soc_codec *codec;
603    struct list_head pins;
604    int status;
605    struct blocking_notifier_head notifier;
606    struct list_head jack_zones;
607};
608
609/* SoC PCM stream information */
610struct snd_soc_pcm_stream {
611    const char *stream_name;
612    u64 formats; /* SNDRV_PCM_FMTBIT_* */
613    unsigned int rates; /* SNDRV_PCM_RATE_* */
614    unsigned int rate_min; /* min rate */
615    unsigned int rate_max; /* max rate */
616    unsigned int channels_min; /* min channels */
617    unsigned int channels_max; /* max channels */
618    unsigned int sig_bits; /* number of bits of content */
619};
620
621/* SoC audio ops */
622struct snd_soc_ops {
623    int (*startup)(struct snd_pcm_substream *);
624    void (*shutdown)(struct snd_pcm_substream *);
625    int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
626    int (*hw_free)(struct snd_pcm_substream *);
627    int (*prepare)(struct snd_pcm_substream *);
628    int (*trigger)(struct snd_pcm_substream *, int);
629};
630
631struct snd_soc_compr_ops {
632    int (*startup)(struct snd_compr_stream *);
633    void (*shutdown)(struct snd_compr_stream *);
634    int (*set_params)(struct snd_compr_stream *);
635    int (*trigger)(struct snd_compr_stream *);
636};
637
638/* component interface */
639struct snd_soc_component_driver {
640    const char *name;
641
642    /* DT */
643    int (*of_xlate_dai_name)(struct snd_soc_component *component,
644                 struct of_phandle_args *args,
645                 const char **dai_name);
646};
647
648struct snd_soc_component {
649    const char *name;
650    int id;
651    struct device *dev;
652    struct list_head list;
653
654    struct snd_soc_dai_driver *dai_drv;
655    int num_dai;
656
657    const struct snd_soc_component_driver *driver;
658};
659
660/* SoC Audio Codec device */
661struct snd_soc_codec {
662    const char *name;
663    const char *name_prefix;
664    int id;
665    struct device *dev;
666    const struct snd_soc_codec_driver *driver;
667
668    struct mutex mutex;
669    struct snd_soc_card *card;
670    struct list_head list;
671    struct list_head card_list;
672    int num_dai;
673    int (*volatile_register)(struct snd_soc_codec *, unsigned int);
674    int (*readable_register)(struct snd_soc_codec *, unsigned int);
675    int (*writable_register)(struct snd_soc_codec *, unsigned int);
676
677    /* runtime */
678    struct snd_ac97 *ac97; /* for ad-hoc ac97 devices */
679    unsigned int active;
680    unsigned int cache_bypass:1; /* Suppress access to the cache */
681    unsigned int suspended:1; /* Codec is in suspend PM state */
682    unsigned int probed:1; /* Codec has been probed */
683    unsigned int ac97_registered:1; /* Codec has been AC97 registered */
684    unsigned int ac97_created:1; /* Codec has been created by SoC */
685    unsigned int cache_init:1; /* codec cache has been initialized */
686    unsigned int using_regmap:1; /* using regmap access */
687    u32 cache_only; /* Suppress writes to hardware */
688    u32 cache_sync; /* Cache needs to be synced to hardware */
689
690    /* codec IO */
691    void *control_data; /* codec control (i2c/3wire) data */
692    hw_write_t hw_write;
693    unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
694    unsigned int (*read)(struct snd_soc_codec *, unsigned int);
695    int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
696    void *reg_cache;
697    struct mutex cache_rw_mutex;
698    int val_bytes;
699
700    /* component */
701    struct snd_soc_component component;
702
703    /* dapm */
704    struct snd_soc_dapm_context dapm;
705    unsigned int ignore_pmdown_time:1; /* pmdown_time is ignored at stop */
706
707#ifdef CONFIG_DEBUG_FS
708    struct dentry *debugfs_codec_root;
709    struct dentry *debugfs_reg;
710#endif
711};
712
713/* codec driver */
714struct snd_soc_codec_driver {
715
716    /* driver ops */
717    int (*probe)(struct snd_soc_codec *);
718    int (*remove)(struct snd_soc_codec *);
719    int (*suspend)(struct snd_soc_codec *);
720    int (*resume)(struct snd_soc_codec *);
721    struct snd_soc_component_driver component_driver;
722
723    /* Default control and setup, added after probe() is run */
724    const struct snd_kcontrol_new *controls;
725    int num_controls;
726    const struct snd_soc_dapm_widget *dapm_widgets;
727    int num_dapm_widgets;
728    const struct snd_soc_dapm_route *dapm_routes;
729    int num_dapm_routes;
730
731    /* codec wide operations */
732    int (*set_sysclk)(struct snd_soc_codec *codec,
733              int clk_id, int source, unsigned int freq, int dir);
734    int (*set_pll)(struct snd_soc_codec *codec, int pll_id, int source,
735        unsigned int freq_in, unsigned int freq_out);
736
737    /* codec IO */
738    unsigned int (*read)(struct snd_soc_codec *, unsigned int);
739    int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
740    int (*display_register)(struct snd_soc_codec *, char *,
741                size_t, unsigned int);
742    int (*volatile_register)(struct snd_soc_codec *, unsigned int);
743    int (*readable_register)(struct snd_soc_codec *, unsigned int);
744    int (*writable_register)(struct snd_soc_codec *, unsigned int);
745    unsigned int reg_cache_size;
746    short reg_cache_step;
747    short reg_word_size;
748    const void *reg_cache_default;
749
750    /* codec bias level */
751    int (*set_bias_level)(struct snd_soc_codec *,
752                  enum snd_soc_bias_level level);
753    bool idle_bias_off;
754
755    void (*seq_notifier)(struct snd_soc_dapm_context *,
756                 enum snd_soc_dapm_type, int);
757
758    /* codec stream completion event */
759    int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
760
761    bool ignore_pmdown_time; /* Doesn't benefit from pmdown delay */
762
763    /* probe ordering - for components with runtime dependencies */
764    int probe_order;
765    int remove_order;
766};
767
768/* SoC platform interface */
769struct snd_soc_platform_driver {
770
771    int (*probe)(struct snd_soc_platform *);
772    int (*remove)(struct snd_soc_platform *);
773    int (*suspend)(struct snd_soc_dai *dai);
774    int (*resume)(struct snd_soc_dai *dai);
775
776    /* pcm creation and destruction */
777    int (*pcm_new)(struct snd_soc_pcm_runtime *);
778    void (*pcm_free)(struct snd_pcm *);
779
780    /* Default control and setup, added after probe() is run */
781    const struct snd_kcontrol_new *controls;
782    int num_controls;
783    const struct snd_soc_dapm_widget *dapm_widgets;
784    int num_dapm_widgets;
785    const struct snd_soc_dapm_route *dapm_routes;
786    int num_dapm_routes;
787
788    /*
789     * For platform caused delay reporting.
790     * Optional.
791     */
792    snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
793        struct snd_soc_dai *);
794
795    /* platform stream pcm ops */
796    const struct snd_pcm_ops *ops;
797
798    /* platform stream compress ops */
799    const struct snd_compr_ops *compr_ops;
800
801    /* platform stream completion event */
802    int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);
803
804    /* probe ordering - for components with runtime dependencies */
805    int probe_order;
806    int remove_order;
807
808    /* platform IO - used for platform DAPM */
809    unsigned int (*read)(struct snd_soc_platform *, unsigned int);
810    int (*write)(struct snd_soc_platform *, unsigned int, unsigned int);
811    int (*bespoke_trigger)(struct snd_pcm_substream *, int);
812};
813
814struct snd_soc_platform {
815    const char *name;
816    int id;
817    struct device *dev;
818    const struct snd_soc_platform_driver *driver;
819    struct mutex mutex;
820
821    unsigned int suspended:1; /* platform is suspended */
822    unsigned int probed:1;
823
824    struct snd_soc_card *card;
825    struct list_head list;
826    struct list_head card_list;
827
828    struct snd_soc_dapm_context dapm;
829
830#ifdef CONFIG_DEBUG_FS
831    struct dentry *debugfs_platform_root;
832#endif
833};
834
835struct snd_soc_dai_link {
836    /* config - must be set by machine driver */
837    const char *name; /* Codec name */
838    const char *stream_name; /* Stream name */
839    /*
840     * You MAY specify the link's CPU-side device, either by device name,
841     * or by DT/OF node, but not both. If this information is omitted,
842     * the CPU-side DAI is matched using .cpu_dai_name only, which hence
843     * must be globally unique. These fields are currently typically used
844     * only for codec to codec links, or systems using device tree.
845     */
846    const char *cpu_name;
847    const struct device_node *cpu_of_node;
848    /*
849     * You MAY specify the DAI name of the CPU DAI. If this information is
850     * omitted, the CPU-side DAI is matched using .cpu_name/.cpu_of_node
851     * only, which only works well when that device exposes a single DAI.
852     */
853    const char *cpu_dai_name;
854    /*
855     * You MUST specify the link's codec, either by device name, or by
856     * DT/OF node, but not both.
857     */
858    const char *codec_name;
859    const struct device_node *codec_of_node;
860    /* You MUST specify the DAI name within the codec */
861    const char *codec_dai_name;
862    /*
863     * You MAY specify the link's platform/PCM/DMA driver, either by
864     * device name, or by DT/OF node, but not both. Some forms of link
865     * do not need a platform.
866     */
867    const char *platform_name;
868    const struct device_node *platform_of_node;
869    int be_id; /* optional ID for machine driver BE identification */
870
871    const struct snd_soc_pcm_stream *params;
872
873    unsigned int dai_fmt; /* format to set on init */
874
875    enum snd_soc_dpcm_trigger trigger[2]; /* trigger type for DPCM */
876
877    /* Keep DAI active over suspend */
878    unsigned int ignore_suspend:1;
879
880    /* Symmetry requirements */
881    unsigned int symmetric_rates:1;
882
883    /* Do not create a PCM for this DAI link (Backend link) */
884    unsigned int no_pcm:1;
885
886    /* This DAI link can route to other DAI links at runtime (Frontend)*/
887    unsigned int dynamic:1;
888
889    /* pmdown_time is ignored at stop */
890    unsigned int ignore_pmdown_time:1;
891
892    /* codec/machine specific init - e.g. add machine controls */
893    int (*init)(struct snd_soc_pcm_runtime *rtd);
894
895    /* optional hw_params re-writing for BE and FE sync */
896    int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
897            struct snd_pcm_hw_params *params);
898
899    /* machine stream operations */
900    const struct snd_soc_ops *ops;
901    const struct snd_soc_compr_ops *compr_ops;
902
903    /* For unidirectional dai links */
904    bool playback_only;
905    bool capture_only;
906};
907
908struct snd_soc_codec_conf {
909    const char *dev_name;
910
911    /*
912     * optional map of kcontrol, widget and path name prefixes that are
913     * associated per device
914     */
915    const char *name_prefix;
916};
917
918struct snd_soc_aux_dev {
919    const char *name; /* Codec name */
920    const char *codec_name; /* for multi-codec */
921
922    /* codec/machine specific init - e.g. add machine controls */
923    int (*init)(struct snd_soc_dapm_context *dapm);
924};
925
926/* SoC card */
927struct snd_soc_card {
928    const char *name;
929    const char *long_name;
930    const char *driver_name;
931    struct device *dev;
932    struct snd_card *snd_card;
933    struct module *owner;
934
935    struct list_head list;
936    struct mutex mutex;
937    struct mutex dapm_mutex;
938
939    bool instantiated;
940
941    int (*probe)(struct snd_soc_card *card);
942    int (*late_probe)(struct snd_soc_card *card);
943    int (*remove)(struct snd_soc_card *card);
944
945    /* the pre and post PM functions are used to do any PM work before and
946     * after the codec and DAI's do any PM work. */
947    int (*suspend_pre)(struct snd_soc_card *card);
948    int (*suspend_post)(struct snd_soc_card *card);
949    int (*resume_pre)(struct snd_soc_card *card);
950    int (*resume_post)(struct snd_soc_card *card);
951
952    /* callbacks */
953    int (*set_bias_level)(struct snd_soc_card *,
954                  struct snd_soc_dapm_context *dapm,
955                  enum snd_soc_bias_level level);
956    int (*set_bias_level_post)(struct snd_soc_card *,
957                   struct snd_soc_dapm_context *dapm,
958                   enum snd_soc_bias_level level);
959
960    long pmdown_time;
961
962    /* CPU <--> Codec DAI links */
963    struct snd_soc_dai_link *dai_link;
964    int num_links;
965    struct snd_soc_pcm_runtime *rtd;
966    int num_rtd;
967
968    /* optional codec specific configuration */
969    struct snd_soc_codec_conf *codec_conf;
970    int num_configs;
971
972    /*
973     * optional auxiliary devices such as amplifiers or codecs with DAI
974     * link unused
975     */
976    struct snd_soc_aux_dev *aux_dev;
977    int num_aux_devs;
978    struct snd_soc_pcm_runtime *rtd_aux;
979    int num_aux_rtd;
980
981    const struct snd_kcontrol_new *controls;
982    int num_controls;
983
984    /*
985     * Card-specific routes and widgets.
986     */
987    const struct snd_soc_dapm_widget *dapm_widgets;
988    int num_dapm_widgets;
989    const struct snd_soc_dapm_route *dapm_routes;
990    int num_dapm_routes;
991    bool fully_routed;
992
993    struct work_struct deferred_resume_work;
994
995    /* lists of probed devices belonging to this card */
996    struct list_head codec_dev_list;
997    struct list_head platform_dev_list;
998    struct list_head dai_dev_list;
999
1000    struct list_head widgets;
1001    struct list_head paths;
1002    struct list_head dapm_list;
1003    struct list_head dapm_dirty;
1004
1005    /* Generic DAPM context for the card */
1006    struct snd_soc_dapm_context dapm;
1007    struct snd_soc_dapm_stats dapm_stats;
1008    struct snd_soc_dapm_update *update;
1009
1010#ifdef CONFIG_DEBUG_FS
1011    struct dentry *debugfs_card_root;
1012    struct dentry *debugfs_pop_time;
1013#endif
1014    u32 pop_time;
1015
1016    void *drvdata;
1017};
1018
1019/* SoC machine DAI configuration, glues a codec and cpu DAI together */
1020struct snd_soc_pcm_runtime {
1021    struct device *dev;
1022    struct snd_soc_card *card;
1023    struct snd_soc_dai_link *dai_link;
1024    struct mutex pcm_mutex;
1025    enum snd_soc_pcm_subclass pcm_subclass;
1026    struct snd_pcm_ops ops;
1027
1028    unsigned int dev_registered:1;
1029
1030    /* Dynamic PCM BE runtime data */
1031    struct snd_soc_dpcm_runtime dpcm[2];
1032
1033    long pmdown_time;
1034    unsigned char pop_wait:1;
1035
1036    /* runtime devices */
1037    struct snd_pcm *pcm;
1038    struct snd_compr *compr;
1039    struct snd_soc_codec *codec;
1040    struct snd_soc_platform *platform;
1041    struct snd_soc_dai *codec_dai;
1042    struct snd_soc_dai *cpu_dai;
1043
1044    struct delayed_work delayed_work;
1045#ifdef CONFIG_DEBUG_FS
1046    struct dentry *debugfs_dpcm_root;
1047    struct dentry *debugfs_dpcm_state;
1048#endif
1049};
1050
1051/* mixer control */
1052struct soc_mixer_control {
1053    int min, max, platform_max;
1054    int reg, rreg;
1055    unsigned int shift, rshift;
1056    unsigned int invert:1;
1057    unsigned int autodisable:1;
1058};
1059
1060struct soc_bytes {
1061    int base;
1062    int num_regs;
1063    u32 mask;
1064};
1065
1066/* multi register control */
1067struct soc_mreg_control {
1068    long min, max;
1069    unsigned int regbase, regcount, nbits, invert;
1070};
1071
1072/* enumerated kcontrol */
1073struct soc_enum {
1074    unsigned short reg;
1075    unsigned short reg2;
1076    unsigned char shift_l;
1077    unsigned char shift_r;
1078    unsigned int max;
1079    unsigned int mask;
1080    const char * const *texts;
1081    const unsigned int *values;
1082};
1083
1084/* codec IO */
1085unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
1086unsigned int snd_soc_write(struct snd_soc_codec *codec,
1087               unsigned int reg, unsigned int val);
1088
1089/* device driver data */
1090
1091static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
1092        void *data)
1093{
1094    card->drvdata = data;
1095}
1096
1097static inline void *snd_soc_card_get_drvdata(struct snd_soc_card *card)
1098{
1099    return card->drvdata;
1100}
1101
1102static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
1103        void *data)
1104{
1105    dev_set_drvdata(codec->dev, data);
1106}
1107
1108static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
1109{
1110    return dev_get_drvdata(codec->dev);
1111}
1112
1113static inline void snd_soc_platform_set_drvdata(struct snd_soc_platform *platform,
1114        void *data)
1115{
1116    dev_set_drvdata(platform->dev, data);
1117}
1118
1119static inline void *snd_soc_platform_get_drvdata(struct snd_soc_platform *platform)
1120{
1121    return dev_get_drvdata(platform->dev);
1122}
1123
1124static inline void snd_soc_pcm_set_drvdata(struct snd_soc_pcm_runtime *rtd,
1125        void *data)
1126{
1127    dev_set_drvdata(rtd->dev, data);
1128}
1129
1130static inline void *snd_soc_pcm_get_drvdata(struct snd_soc_pcm_runtime *rtd)
1131{
1132    return dev_get_drvdata(rtd->dev);
1133}
1134
1135static inline void snd_soc_initialize_card_lists(struct snd_soc_card *card)
1136{
1137    INIT_LIST_HEAD(&card->dai_dev_list);
1138    INIT_LIST_HEAD(&card->codec_dev_list);
1139    INIT_LIST_HEAD(&card->platform_dev_list);
1140    INIT_LIST_HEAD(&card->widgets);
1141    INIT_LIST_HEAD(&card->paths);
1142    INIT_LIST_HEAD(&card->dapm_list);
1143}
1144
1145static inline bool snd_soc_volsw_is_stereo(struct soc_mixer_control *mc)
1146{
1147    if (mc->reg == mc->rreg && mc->shift == mc->rshift)
1148        return 0;
1149    /*
1150     * mc->reg == mc->rreg && mc->shift != mc->rshift, or
1151     * mc->reg != mc->rreg means that the control is
1152     * stereo (bits in one register or in two registers)
1153     */
1154    return 1;
1155}
1156
1157int snd_soc_util_init(void);
1158void snd_soc_util_exit(void);
1159
1160int snd_soc_of_parse_card_name(struct snd_soc_card *card,
1161                   const char *propname);
1162int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
1163                   const char *propname);
1164unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
1165                     const char *prefix);
1166int snd_soc_of_get_dai_name(struct device_node *of_node,
1167                const char **dai_name);
1168
1169#include <sound/soc-dai.h>
1170
1171#ifdef CONFIG_DEBUG_FS
1172extern struct dentry *snd_soc_debugfs_root;
1173#endif
1174
1175extern const struct dev_pm_ops snd_soc_pm_ops;
1176
1177#endif
1178

Archive Download this file



interactive