xref: /openbmc/linux/include/sound/soc.h (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
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/platform_device.h>
17 #include <linux/types.h>
18 #include <linux/workqueue.h>
19 #include <linux/interrupt.h>
20 #include <linux/kernel.h>
21 #include <sound/core.h>
22 #include <sound/pcm.h>
23 #include <sound/control.h>
24 #include <sound/ac97_codec.h>
25 
26 /*
27  * Convenience kcontrol builders
28  */
29 #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \
30 	((unsigned long)&(struct soc_mixer_control) \
31 	{.reg = xreg, .shift = xshift, .rshift = xshift, .max = xmax, \
32 	.invert = xinvert})
33 #define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
34 	((unsigned long)&(struct soc_mixer_control) \
35 	{.reg = xreg, .max = xmax, .invert = xinvert})
36 #define SOC_SINGLE(xname, reg, shift, max, invert) \
37 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
38 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
39 	.put = snd_soc_put_volsw, \
40 	.private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
41 #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
42 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
43 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
44 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
45 	.tlv.p = (tlv_array), \
46 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
47 	.put = snd_soc_put_volsw, \
48 	.private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
49 #define SOC_DOUBLE(xname, xreg, shift_left, shift_right, xmax, xinvert) \
50 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
51 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
52 	.put = snd_soc_put_volsw, \
53 	.private_value = (unsigned long)&(struct soc_mixer_control) \
54 		{.reg = xreg, .shift = shift_left, .rshift = shift_right, \
55 		 .max = xmax, .invert = xinvert} }
56 #define SOC_DOUBLE_R(xname, reg_left, reg_right, xshift, xmax, xinvert) \
57 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
58 	.info = snd_soc_info_volsw_2r, \
59 	.get = snd_soc_get_volsw_2r, .put = snd_soc_put_volsw_2r, \
60 	.private_value = (unsigned long)&(struct soc_mixer_control) \
61 		{.reg = reg_left, .rreg = reg_right, .shift = xshift, \
62 		.max = xmax, .invert = xinvert} }
63 #define SOC_DOUBLE_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert, tlv_array) \
64 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
65 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
66 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
67 	.tlv.p = (tlv_array), \
68 	.info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \
69 	.put = snd_soc_put_volsw, \
70 	.private_value = (unsigned long)&(struct soc_mixer_control) \
71 		{.reg = xreg, .shift = shift_left, .rshift = shift_right,\
72 		 .max = xmax, .invert = xinvert} }
73 #define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, 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_2r, \
79 	.get = snd_soc_get_volsw_2r, .put = snd_soc_put_volsw_2r, \
80 	.private_value = (unsigned long)&(struct soc_mixer_control) \
81 		{.reg = reg_left, .rreg = reg_right, .shift = xshift, \
82 		.max = xmax, .invert = xinvert} }
83 #define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
84 {	.iface  = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
85 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
86 		  SNDRV_CTL_ELEM_ACCESS_READWRITE, \
87 	.tlv.p  = (tlv_array), \
88 	.info   = snd_soc_info_volsw_s8, .get = snd_soc_get_volsw_s8, \
89 	.put    = snd_soc_put_volsw_s8, \
90 	.private_value = (unsigned long)&(struct soc_mixer_control) \
91 		{.reg = xreg, .min = xmin, .max = xmax} }
92 #define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \
93 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
94 	.max = xmax, .texts = xtexts }
95 #define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \
96 	SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)
97 #define SOC_ENUM_SINGLE_EXT(xmax, xtexts) \
98 {	.max = xmax, .texts = xtexts }
99 #define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xmax, xtexts, xvalues) \
100 {	.reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
101 	.mask = xmask, .max = xmax, .texts = xtexts, .values = xvalues}
102 #define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xmax, xtexts, xvalues) \
103 	SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xmax, xtexts, xvalues)
104 #define SOC_ENUM(xname, xenum) \
105 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
106 	.info = snd_soc_info_enum_double, \
107 	.get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \
108 	.private_value = (unsigned long)&xenum }
109 #define SOC_VALUE_ENUM(xname, xenum) \
110 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
111 	.info = snd_soc_info_enum_double, \
112 	.get = snd_soc_get_value_enum_double, \
113 	.put = snd_soc_put_value_enum_double, \
114 	.private_value = (unsigned long)&xenum }
115 #define SOC_SINGLE_EXT(xname, xreg, xshift, xmax, xinvert,\
116 	 xhandler_get, xhandler_put) \
117 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
118 	.info = snd_soc_info_volsw, \
119 	.get = xhandler_get, .put = xhandler_put, \
120 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
121 #define SOC_DOUBLE_EXT(xname, xreg, shift_left, shift_right, xmax, xinvert,\
122 	 xhandler_get, xhandler_put) \
123 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
124 	.info = snd_soc_info_volsw, \
125 	.get = xhandler_get, .put = xhandler_put, \
126 	.private_value = (unsigned long)&(struct soc_mixer_control) \
127 		{.reg = xreg, .shift = shift_left, .rshift = shift_right, \
128 		 .max = xmax, .invert = xinvert} }
129 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
130 	 xhandler_get, xhandler_put, tlv_array) \
131 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
132 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
133 		 SNDRV_CTL_ELEM_ACCESS_READWRITE,\
134 	.tlv.p = (tlv_array), \
135 	.info = snd_soc_info_volsw, \
136 	.get = xhandler_get, .put = xhandler_put, \
137 	.private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
138 #define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
139 	 xhandler_get, xhandler_put, tlv_array) \
140 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
141 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
142 		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
143 	.tlv.p = (tlv_array), \
144 	.info = snd_soc_info_volsw, \
145 	.get = xhandler_get, .put = xhandler_put, \
146 	.private_value = (unsigned long)&(struct soc_mixer_control) \
147 		{.reg = xreg, .shift = shift_left, .rshift = shift_right, \
148 		.max = xmax, .invert = xinvert} }
149 #define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
150 	 xhandler_get, xhandler_put, tlv_array) \
151 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
152 	.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
153 		 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
154 	.tlv.p = (tlv_array), \
155 	.info = snd_soc_info_volsw_2r, \
156 	.get = xhandler_get, .put = xhandler_put, \
157 	.private_value = (unsigned long)&(struct soc_mixer_control) \
158 		{.reg = reg_left, .rreg = reg_right, .shift = xshift, \
159 		.max = xmax, .invert = xinvert} }
160 #define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
161 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
162 	.info = snd_soc_info_bool_ext, \
163 	.get = xhandler_get, .put = xhandler_put, \
164 	.private_value = xdata }
165 #define SOC_ENUM_EXT(xname, xenum, xhandler_get, xhandler_put) \
166 {	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
167 	.info = snd_soc_info_enum_ext, \
168 	.get = xhandler_get, .put = xhandler_put, \
169 	.private_value = (unsigned long)&xenum }
170 
171 /*
172  * Bias levels
173  *
174  * @ON:      Bias is fully on for audio playback and capture operations.
175  * @PREPARE: Prepare for audio operations. Called before DAPM switching for
176  *           stream start and stop operations.
177  * @STANDBY: Low power standby state when no playback/capture operations are
178  *           in progress. NOTE: The transition time between STANDBY and ON
179  *           should be as fast as possible and no longer than 10ms.
180  * @OFF:     Power Off. No restrictions on transition times.
181  */
182 enum snd_soc_bias_level {
183 	SND_SOC_BIAS_ON,
184 	SND_SOC_BIAS_PREPARE,
185 	SND_SOC_BIAS_STANDBY,
186 	SND_SOC_BIAS_OFF,
187 };
188 
189 struct snd_jack;
190 struct snd_soc_card;
191 struct snd_soc_device;
192 struct snd_soc_pcm_stream;
193 struct snd_soc_ops;
194 struct snd_soc_dai_mode;
195 struct snd_soc_pcm_runtime;
196 struct snd_soc_dai;
197 struct snd_soc_platform;
198 struct snd_soc_codec;
199 struct soc_enum;
200 struct snd_soc_ac97_ops;
201 struct snd_soc_jack;
202 struct snd_soc_jack_pin;
203 #ifdef CONFIG_GPIOLIB
204 struct snd_soc_jack_gpio;
205 #endif
206 
207 typedef int (*hw_write_t)(void *,const char* ,int);
208 
209 extern struct snd_ac97_bus_ops soc_ac97_ops;
210 
211 enum snd_soc_control_type {
212 	SND_SOC_CUSTOM,
213 	SND_SOC_I2C,
214 	SND_SOC_SPI,
215 };
216 
217 int snd_soc_register_platform(struct snd_soc_platform *platform);
218 void snd_soc_unregister_platform(struct snd_soc_platform *platform);
219 int snd_soc_register_codec(struct snd_soc_codec *codec);
220 void snd_soc_unregister_codec(struct snd_soc_codec *codec);
221 int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg);
222 int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
223 			       int addr_bits, int data_bits,
224 			       enum snd_soc_control_type control);
225 
226 /* pcm <-> DAI connect */
227 void snd_soc_free_pcms(struct snd_soc_device *socdev);
228 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid);
229 
230 /* Utility functions to get clock rates from various things */
231 int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots);
232 int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params);
233 int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots);
234 int snd_soc_params_to_bclk(struct snd_pcm_hw_params *parms);
235 
236 /* set runtime hw params */
237 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
238 	const struct snd_pcm_hardware *hw);
239 
240 /* Jack reporting */
241 int snd_soc_jack_new(struct snd_soc_card *card, const char *id, int type,
242 		     struct snd_soc_jack *jack);
243 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask);
244 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
245 			  struct snd_soc_jack_pin *pins);
246 #ifdef CONFIG_GPIOLIB
247 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
248 			struct snd_soc_jack_gpio *gpios);
249 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
250 			struct snd_soc_jack_gpio *gpios);
251 #endif
252 
253 /* codec register bit access */
254 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
255 				unsigned int mask, unsigned int value);
256 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
257 				unsigned int mask, unsigned int value);
258 
259 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
260 	struct snd_ac97_bus_ops *ops, int num);
261 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec);
262 
263 /*
264  *Controls
265  */
266 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
267 	void *data, char *long_name);
268 int snd_soc_add_controls(struct snd_soc_codec *codec,
269 	const struct snd_kcontrol_new *controls, int num_controls);
270 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
271 	struct snd_ctl_elem_info *uinfo);
272 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
273 	struct snd_ctl_elem_info *uinfo);
274 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
275 	struct snd_ctl_elem_value *ucontrol);
276 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
277 	struct snd_ctl_elem_value *ucontrol);
278 int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
279 	struct snd_ctl_elem_value *ucontrol);
280 int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
281 	struct snd_ctl_elem_value *ucontrol);
282 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
283 	struct snd_ctl_elem_info *uinfo);
284 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
285 	struct snd_ctl_elem_info *uinfo);
286 #define snd_soc_info_bool_ext		snd_ctl_boolean_mono_info
287 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
288 	struct snd_ctl_elem_value *ucontrol);
289 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
290 	struct snd_ctl_elem_value *ucontrol);
291 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
292 	struct snd_ctl_elem_info *uinfo);
293 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
294 	struct snd_ctl_elem_value *ucontrol);
295 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
296 	struct snd_ctl_elem_value *ucontrol);
297 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
298 	struct snd_ctl_elem_info *uinfo);
299 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
300 	struct snd_ctl_elem_value *ucontrol);
301 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
302 	struct snd_ctl_elem_value *ucontrol);
303 
304 /**
305  * struct snd_soc_jack_pin - Describes a pin to update based on jack detection
306  *
307  * @pin:    name of the pin to update
308  * @mask:   bits to check for in reported jack status
309  * @invert: if non-zero then pin is enabled when status is not reported
310  */
311 struct snd_soc_jack_pin {
312 	struct list_head list;
313 	const char *pin;
314 	int mask;
315 	bool invert;
316 };
317 
318 /**
319  * struct snd_soc_jack_gpio - Describes a gpio pin for jack detection
320  *
321  * @gpio:         gpio number
322  * @name:         gpio name
323  * @report:       value to report when jack detected
324  * @invert:       report presence in low state
325  * @debouce_time: debouce time in ms
326  */
327 #ifdef CONFIG_GPIOLIB
328 struct snd_soc_jack_gpio {
329 	unsigned int gpio;
330 	const char *name;
331 	int report;
332 	int invert;
333 	int debounce_time;
334 	struct snd_soc_jack *jack;
335 	struct work_struct work;
336 
337 	int (*jack_status_check)(void);
338 };
339 #endif
340 
341 struct snd_soc_jack {
342 	struct snd_jack *jack;
343 	struct snd_soc_card *card;
344 	struct list_head pins;
345 	int status;
346 };
347 
348 /* SoC PCM stream information */
349 struct snd_soc_pcm_stream {
350 	char *stream_name;
351 	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
352 	unsigned int rates;		/* SNDRV_PCM_RATE_* */
353 	unsigned int rate_min;		/* min rate */
354 	unsigned int rate_max;		/* max rate */
355 	unsigned int channels_min;	/* min channels */
356 	unsigned int channels_max;	/* max channels */
357 	unsigned int active:1;		/* stream is in use */
358 };
359 
360 /* SoC audio ops */
361 struct snd_soc_ops {
362 	int (*startup)(struct snd_pcm_substream *);
363 	void (*shutdown)(struct snd_pcm_substream *);
364 	int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
365 	int (*hw_free)(struct snd_pcm_substream *);
366 	int (*prepare)(struct snd_pcm_substream *);
367 	int (*trigger)(struct snd_pcm_substream *, int);
368 };
369 
370 /* SoC Audio Codec */
371 struct snd_soc_codec {
372 	char *name;
373 	struct module *owner;
374 	struct mutex mutex;
375 	struct device *dev;
376 	struct snd_soc_device *socdev;
377 
378 	struct list_head list;
379 
380 	/* callbacks */
381 	int (*set_bias_level)(struct snd_soc_codec *,
382 			      enum snd_soc_bias_level level);
383 
384 	/* runtime */
385 	struct snd_card *card;
386 	struct snd_ac97 *ac97;  /* for ad-hoc ac97 devices */
387 	unsigned int active;
388 	unsigned int pcm_devs;
389 	void *private_data;
390 
391 	/* codec IO */
392 	void *control_data; /* codec control (i2c/3wire) data */
393 	unsigned int (*read)(struct snd_soc_codec *, unsigned int);
394 	int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
395 	int (*display_register)(struct snd_soc_codec *, char *,
396 				size_t, unsigned int);
397 	int (*volatile_register)(unsigned int);
398 	int (*readable_register)(unsigned int);
399 	hw_write_t hw_write;
400 	unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
401 	void *reg_cache;
402 	short reg_cache_size;
403 	short reg_cache_step;
404 
405 	/* dapm */
406 	u32 pop_time;
407 	struct list_head dapm_widgets;
408 	struct list_head dapm_paths;
409 	enum snd_soc_bias_level bias_level;
410 	enum snd_soc_bias_level suspend_bias_level;
411 	struct delayed_work delayed_work;
412 
413 	/* codec DAI's */
414 	struct snd_soc_dai *dai;
415 	unsigned int num_dai;
416 
417 #ifdef CONFIG_DEBUG_FS
418 	struct dentry *debugfs_codec_root;
419 	struct dentry *debugfs_reg;
420 	struct dentry *debugfs_pop_time;
421 	struct dentry *debugfs_dapm;
422 #endif
423 };
424 
425 /* codec device */
426 struct snd_soc_codec_device {
427 	int (*probe)(struct platform_device *pdev);
428 	int (*remove)(struct platform_device *pdev);
429 	int (*suspend)(struct platform_device *pdev, pm_message_t state);
430 	int (*resume)(struct platform_device *pdev);
431 };
432 
433 /* SoC platform interface */
434 struct snd_soc_platform {
435 	char *name;
436 	struct list_head list;
437 
438 	int (*probe)(struct platform_device *pdev);
439 	int (*remove)(struct platform_device *pdev);
440 	int (*suspend)(struct snd_soc_dai *dai);
441 	int (*resume)(struct snd_soc_dai *dai);
442 
443 	/* pcm creation and destruction */
444 	int (*pcm_new)(struct snd_card *, struct snd_soc_dai *,
445 		struct snd_pcm *);
446 	void (*pcm_free)(struct snd_pcm *);
447 
448 	/* platform stream ops */
449 	struct snd_pcm_ops *pcm_ops;
450 };
451 
452 /* SoC machine DAI configuration, glues a codec and cpu DAI together */
453 struct snd_soc_dai_link  {
454 	char *name;			/* Codec name */
455 	char *stream_name;		/* Stream name */
456 
457 	/* DAI */
458 	struct snd_soc_dai *codec_dai;
459 	struct snd_soc_dai *cpu_dai;
460 
461 	/* machine stream operations */
462 	struct snd_soc_ops *ops;
463 
464 	/* codec/machine specific init - e.g. add machine controls */
465 	int (*init)(struct snd_soc_codec *codec);
466 
467 	/* Symmetry requirements */
468 	unsigned int symmetric_rates:1;
469 
470 	/* Symmetry data - only valid if symmetry is being enforced */
471 	unsigned int rate;
472 
473 	/* DAI pcm */
474 	struct snd_pcm *pcm;
475 };
476 
477 /* SoC card */
478 struct snd_soc_card {
479 	char *name;
480 	struct device *dev;
481 
482 	struct list_head list;
483 
484 	int instantiated;
485 
486 	int (*probe)(struct platform_device *pdev);
487 	int (*remove)(struct platform_device *pdev);
488 
489 	/* the pre and post PM functions are used to do any PM work before and
490 	 * after the codec and DAI's do any PM work. */
491 	int (*suspend_pre)(struct platform_device *pdev, pm_message_t state);
492 	int (*suspend_post)(struct platform_device *pdev, pm_message_t state);
493 	int (*resume_pre)(struct platform_device *pdev);
494 	int (*resume_post)(struct platform_device *pdev);
495 
496 	/* callbacks */
497 	int (*set_bias_level)(struct snd_soc_card *,
498 			      enum snd_soc_bias_level level);
499 
500 	/* CPU <--> Codec DAI links  */
501 	struct snd_soc_dai_link *dai_link;
502 	int num_links;
503 
504 	struct snd_soc_device *socdev;
505 
506 	struct snd_soc_codec *codec;
507 
508 	struct snd_soc_platform *platform;
509 	struct delayed_work delayed_work;
510 	struct work_struct deferred_resume_work;
511 };
512 
513 /* SoC Device - the audio subsystem */
514 struct snd_soc_device {
515 	struct device *dev;
516 	struct snd_soc_card *card;
517 	struct snd_soc_codec_device *codec_dev;
518 	void *codec_data;
519 };
520 
521 /* runtime channel data */
522 struct snd_soc_pcm_runtime {
523 	struct snd_soc_dai_link *dai;
524 	struct snd_soc_device *socdev;
525 };
526 
527 /* mixer control */
528 struct soc_mixer_control {
529 	int min, max;
530 	unsigned int reg, rreg, shift, rshift, invert;
531 };
532 
533 /* enumerated kcontrol */
534 struct soc_enum {
535 	unsigned short reg;
536 	unsigned short reg2;
537 	unsigned char shift_l;
538 	unsigned char shift_r;
539 	unsigned int max;
540 	unsigned int mask;
541 	const char **texts;
542 	const unsigned int *values;
543 	void *dapm;
544 };
545 
546 /* codec IO */
547 static inline unsigned int snd_soc_read(struct snd_soc_codec *codec,
548 					unsigned int reg)
549 {
550 	return codec->read(codec, reg);
551 }
552 
553 static inline unsigned int snd_soc_write(struct snd_soc_codec *codec,
554 					 unsigned int reg, unsigned int val)
555 {
556 	return codec->write(codec, reg, val);
557 }
558 
559 #include <sound/soc-dai.h>
560 
561 #endif
562