diff options
author | Vinod Koul <vinod.koul@linux.intel.com> | 2011-12-23 00:06:38 -0500 |
---|---|---|
committer | Takashi Iwai <tiwai@suse.de> | 2011-12-23 04:08:11 -0500 |
commit | e60061a379e1f679ff862acfe1be5819fb6d234c (patch) | |
tree | 45758abf89365d2d8b91a68e92d7cf8f40b08aec | |
parent | 50c34cfe7bbb5cef9d32de63286ff97d8d6877a9 (diff) |
ALSA: core: add API header and driver header files
This patch adds the header files for ioctl definitions and header file for
driver APIs for lower level device drivers to use
Signed-off-by: Vinod Koul <vinod.koul@linux.intel.com>
Signed-off-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
-rw-r--r-- | include/sound/compress_driver.h | 167 | ||||
-rw-r--r-- | include/sound/compress_offload.h | 161 |
2 files changed, 328 insertions, 0 deletions
diff --git a/include/sound/compress_driver.h b/include/sound/compress_driver.h new file mode 100644 index 000000000000..48f2a1ff2bbc --- /dev/null +++ b/include/sound/compress_driver.h | |||
@@ -0,0 +1,167 @@ | |||
1 | /* | ||
2 | * compress_driver.h - compress offload driver definations | ||
3 | * | ||
4 | * Copyright (C) 2011 Intel Corporation | ||
5 | * Authors: Vinod Koul <vinod.koul@linux.intel.com> | ||
6 | * Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> | ||
7 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; version 2 of the License. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License along | ||
19 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
20 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. | ||
21 | * | ||
22 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||
23 | * | ||
24 | */ | ||
25 | #ifndef __COMPRESS_DRIVER_H | ||
26 | #define __COMPRESS_DRIVER_H | ||
27 | |||
28 | #include <linux/types.h> | ||
29 | #include <linux/sched.h> | ||
30 | #include <sound/compress_offload.h> | ||
31 | #include <sound/asound.h> | ||
32 | #include <sound/pcm.h> | ||
33 | |||
34 | struct snd_compr_ops; | ||
35 | |||
36 | /** | ||
37 | * struct snd_compr_runtime: runtime stream description | ||
38 | * @state: stream state | ||
39 | * @ops: pointer to DSP callbacks | ||
40 | * @buffer: pointer to kernel buffer, valid only when not in mmap mode or | ||
41 | * DSP doesn't implement copy | ||
42 | * @buffer_size: size of the above buffer | ||
43 | * @fragment_size: size of buffer fragment in bytes | ||
44 | * @fragments: number of such fragments | ||
45 | * @hw_pointer: offset of last location in buffer where DSP copied data | ||
46 | * @app_pointer: offset of last location in buffer where app wrote data | ||
47 | * @total_bytes_available: cumulative number of bytes made available in | ||
48 | * the ring buffer | ||
49 | * @total_bytes_transferred: cumulative bytes transferred by offload DSP | ||
50 | * @sleep: poll sleep | ||
51 | */ | ||
52 | struct snd_compr_runtime { | ||
53 | snd_pcm_state_t state; | ||
54 | struct snd_compr_ops *ops; | ||
55 | void *buffer; | ||
56 | u64 buffer_size; | ||
57 | u32 fragment_size; | ||
58 | u32 fragments; | ||
59 | u64 hw_pointer; | ||
60 | u64 app_pointer; | ||
61 | u64 total_bytes_available; | ||
62 | u64 total_bytes_transferred; | ||
63 | wait_queue_head_t sleep; | ||
64 | }; | ||
65 | |||
66 | /** | ||
67 | * struct snd_compr_stream: compressed stream | ||
68 | * @name: device name | ||
69 | * @ops: pointer to DSP callbacks | ||
70 | * @runtime: pointer to runtime structure | ||
71 | * @device: device pointer | ||
72 | * @direction: stream direction, playback/recording | ||
73 | * @private_data: pointer to DSP private data | ||
74 | */ | ||
75 | struct snd_compr_stream { | ||
76 | const char *name; | ||
77 | struct snd_compr_ops *ops; | ||
78 | struct snd_compr_runtime *runtime; | ||
79 | struct snd_compr *device; | ||
80 | enum snd_compr_direction direction; | ||
81 | void *private_data; | ||
82 | }; | ||
83 | |||
84 | /** | ||
85 | * struct snd_compr_ops: compressed path DSP operations | ||
86 | * @open: Open the compressed stream | ||
87 | * This callback is mandatory and shall keep dsp ready to receive the stream | ||
88 | * parameter | ||
89 | * @free: Close the compressed stream, mandatory | ||
90 | * @set_params: Sets the compressed stream parameters, mandatory | ||
91 | * This can be called in during stream creation only to set codec params | ||
92 | * and the stream properties | ||
93 | * @get_params: retrieve the codec parameters, mandatory | ||
94 | * @trigger: Trigger operations like start, pause, resume, drain, stop. | ||
95 | * This callback is mandatory | ||
96 | * @pointer: Retrieve current h/w pointer information. Mandatory | ||
97 | * @copy: Copy the compressed data to/from userspace, Optional | ||
98 | * Can't be implemented if DSP supports mmap | ||
99 | * @mmap: DSP mmap method to mmap DSP memory | ||
100 | * @ack: Ack for DSP when data is written to audio buffer, Optional | ||
101 | * Not valid if copy is implemented | ||
102 | * @get_caps: Retrieve DSP capabilities, mandatory | ||
103 | * @get_codec_caps: Retrieve capabilities for a specific codec, mandatory | ||
104 | */ | ||
105 | struct snd_compr_ops { | ||
106 | int (*open)(struct snd_compr_stream *stream); | ||
107 | int (*free)(struct snd_compr_stream *stream); | ||
108 | int (*set_params)(struct snd_compr_stream *stream, | ||
109 | struct snd_compr_params *params); | ||
110 | int (*get_params)(struct snd_compr_stream *stream, | ||
111 | struct snd_codec *params); | ||
112 | int (*trigger)(struct snd_compr_stream *stream, int cmd); | ||
113 | int (*pointer)(struct snd_compr_stream *stream, | ||
114 | struct snd_compr_tstamp *tstamp); | ||
115 | int (*copy)(struct snd_compr_stream *stream, const char __user *buf, | ||
116 | size_t count); | ||
117 | int (*mmap)(struct snd_compr_stream *stream, | ||
118 | struct vm_area_struct *vma); | ||
119 | int (*ack)(struct snd_compr_stream *stream, size_t bytes); | ||
120 | int (*get_caps) (struct snd_compr_stream *stream, | ||
121 | struct snd_compr_caps *caps); | ||
122 | int (*get_codec_caps) (struct snd_compr_stream *stream, | ||
123 | struct snd_compr_codec_caps *codec); | ||
124 | }; | ||
125 | |||
126 | /** | ||
127 | * struct snd_compr: Compressed device | ||
128 | * @name: DSP device name | ||
129 | * @dev: Device pointer | ||
130 | * @ops: pointer to DSP callbacks | ||
131 | * @private_data: pointer to DSP pvt data | ||
132 | * @card: sound card pointer | ||
133 | * @direction: Playback or capture direction | ||
134 | * @lock: device lock | ||
135 | * @device: device id | ||
136 | */ | ||
137 | struct snd_compr { | ||
138 | const char *name; | ||
139 | struct device *dev; | ||
140 | struct snd_compr_ops *ops; | ||
141 | void *private_data; | ||
142 | struct snd_card *card; | ||
143 | unsigned int direction; | ||
144 | struct mutex lock; | ||
145 | int device; | ||
146 | }; | ||
147 | |||
148 | /* compress device register APIs */ | ||
149 | int snd_compress_register(struct snd_compr *device); | ||
150 | int snd_compress_deregister(struct snd_compr *device); | ||
151 | int snd_compress_new(struct snd_card *card, int device, | ||
152 | int type, struct snd_compr *compr); | ||
153 | |||
154 | /* dsp driver callback apis | ||
155 | * For playback: driver should call snd_compress_fragment_elapsed() to let the | ||
156 | * framework know that a fragment has been consumed from the ring buffer | ||
157 | * | ||
158 | * For recording: we want to know when a frame is available or when | ||
159 | * at least one frame is available so snd_compress_frame_elapsed() | ||
160 | * callback should be called when a encodeded frame is available | ||
161 | */ | ||
162 | static inline void snd_compr_fragment_elapsed(struct snd_compr_stream *stream) | ||
163 | { | ||
164 | wake_up(&stream->runtime->sleep); | ||
165 | } | ||
166 | |||
167 | #endif | ||
diff --git a/include/sound/compress_offload.h b/include/sound/compress_offload.h new file mode 100644 index 000000000000..05341a43fedf --- /dev/null +++ b/include/sound/compress_offload.h | |||
@@ -0,0 +1,161 @@ | |||
1 | /* | ||
2 | * compress_offload.h - compress offload header definations | ||
3 | * | ||
4 | * Copyright (C) 2011 Intel Corporation | ||
5 | * Authors: Vinod Koul <vinod.koul@linux.intel.com> | ||
6 | * Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> | ||
7 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; version 2 of the License. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, but | ||
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License along | ||
19 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
20 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. | ||
21 | * | ||
22 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||
23 | * | ||
24 | */ | ||
25 | #ifndef __COMPRESS_OFFLOAD_H | ||
26 | #define __COMPRESS_OFFLOAD_H | ||
27 | |||
28 | #include <linux/types.h> | ||
29 | #include <sound/asound.h> | ||
30 | #include <sound/compress_params.h> | ||
31 | |||
32 | |||
33 | #define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 1, 0) | ||
34 | /** | ||
35 | * struct snd_compressed_buffer: compressed buffer | ||
36 | * @fragment_size: size of buffer fragment in bytes | ||
37 | * @fragments: number of such fragments | ||
38 | */ | ||
39 | struct snd_compressed_buffer { | ||
40 | __u32 fragment_size; | ||
41 | __u32 fragments; | ||
42 | }; | ||
43 | |||
44 | /** | ||
45 | * struct snd_compr_params: compressed stream params | ||
46 | * @buffer: buffer description | ||
47 | * @codec: codec parameters | ||
48 | * @no_wake_mode: dont wake on fragment elapsed | ||
49 | */ | ||
50 | struct snd_compr_params { | ||
51 | struct snd_compressed_buffer buffer; | ||
52 | struct snd_codec codec; | ||
53 | __u8 no_wake_mode; | ||
54 | }; | ||
55 | |||
56 | /** | ||
57 | * struct snd_compr_tstamp: timestamp descriptor | ||
58 | * @byte_offset: Byte offset in ring buffer to DSP | ||
59 | * @copied_total: Total number of bytes copied from/to ring buffer to/by DSP | ||
60 | * @pcm_frames: Frames decoded or encoded by DSP. This field will evolve by | ||
61 | * large steps and should only be used to monitor encoding/decoding | ||
62 | * progress. It shall not be used for timing estimates. | ||
63 | * @pcm_io_frames: Frames rendered or received by DSP into a mixer or an audio | ||
64 | * output/input. This field should be used for A/V sync or time estimates. | ||
65 | * @sampling_rate: sampling rate of audio | ||
66 | */ | ||
67 | struct snd_compr_tstamp { | ||
68 | __u32 byte_offset; | ||
69 | __u32 copied_total; | ||
70 | snd_pcm_uframes_t pcm_frames; | ||
71 | snd_pcm_uframes_t pcm_io_frames; | ||
72 | __u32 sampling_rate; | ||
73 | }; | ||
74 | |||
75 | /** | ||
76 | * struct snd_compr_avail: avail descriptor | ||
77 | * @avail: Number of bytes available in ring buffer for writing/reading | ||
78 | * @tstamp: timestamp infomation | ||
79 | */ | ||
80 | struct snd_compr_avail { | ||
81 | __u64 avail; | ||
82 | struct snd_compr_tstamp tstamp; | ||
83 | }; | ||
84 | |||
85 | enum snd_compr_direction { | ||
86 | SND_COMPRESS_PLAYBACK = 0, | ||
87 | SND_COMPRESS_CAPTURE | ||
88 | }; | ||
89 | |||
90 | /** | ||
91 | * struct snd_compr_caps: caps descriptor | ||
92 | * @codecs: pointer to array of codecs | ||
93 | * @direction: direction supported. Of type snd_compr_direction | ||
94 | * @min_fragment_size: minimum fragment supported by DSP | ||
95 | * @max_fragment_size: maximum fragment supported by DSP | ||
96 | * @min_fragments: min fragments supported by DSP | ||
97 | * @max_fragments: max fragments supported by DSP | ||
98 | * @num_codecs: number of codecs supported | ||
99 | * @reserved: reserved field | ||
100 | */ | ||
101 | struct snd_compr_caps { | ||
102 | __u32 num_codecs; | ||
103 | __u32 direction; | ||
104 | __u32 min_fragment_size; | ||
105 | __u32 max_fragment_size; | ||
106 | __u32 min_fragments; | ||
107 | __u32 max_fragments; | ||
108 | __u32 codecs[MAX_NUM_CODECS]; | ||
109 | __u32 reserved[11]; | ||
110 | }; | ||
111 | |||
112 | /** | ||
113 | * struct snd_compr_codec_caps: query capability of codec | ||
114 | * @codec: codec for which capability is queried | ||
115 | * @num_descriptors: number of codec descriptors | ||
116 | * @descriptor: array of codec capability descriptor | ||
117 | */ | ||
118 | struct snd_compr_codec_caps { | ||
119 | __u32 codec; | ||
120 | __u32 num_descriptors; | ||
121 | struct snd_codec_desc descriptor[MAX_NUM_CODEC_DESCRIPTORS]; | ||
122 | }; | ||
123 | |||
124 | /** | ||
125 | * compress path ioctl definitions | ||
126 | * SNDRV_COMPRESS_GET_CAPS: Query capability of DSP | ||
127 | * SNDRV_COMPRESS_GET_CODEC_CAPS: Query capability of a codec | ||
128 | * SNDRV_COMPRESS_SET_PARAMS: Set codec and stream parameters | ||
129 | * Note: only codec params can be changed runtime and stream params cant be | ||
130 | * SNDRV_COMPRESS_GET_PARAMS: Query codec params | ||
131 | * SNDRV_COMPRESS_TSTAMP: get the current timestamp value | ||
132 | * SNDRV_COMPRESS_AVAIL: get the current buffer avail value. | ||
133 | * This also queries the tstamp properties | ||
134 | * SNDRV_COMPRESS_PAUSE: Pause the running stream | ||
135 | * SNDRV_COMPRESS_RESUME: resume a paused stream | ||
136 | * SNDRV_COMPRESS_START: Start a stream | ||
137 | * SNDRV_COMPRESS_STOP: stop a running stream, discarding ring buffer content | ||
138 | * and the buffers currently with DSP | ||
139 | * SNDRV_COMPRESS_DRAIN: Play till end of buffers and stop after that | ||
140 | * SNDRV_COMPRESS_IOCTL_VERSION: Query the API version | ||
141 | */ | ||
142 | #define SNDRV_COMPRESS_IOCTL_VERSION _IOR('C', 0x00, int) | ||
143 | #define SNDRV_COMPRESS_GET_CAPS _IOWR('C', 0x10, struct snd_compr_caps) | ||
144 | #define SNDRV_COMPRESS_GET_CODEC_CAPS _IOWR('C', 0x11,\ | ||
145 | struct snd_compr_codec_caps) | ||
146 | #define SNDRV_COMPRESS_SET_PARAMS _IOW('C', 0x12, struct snd_compr_params) | ||
147 | #define SNDRV_COMPRESS_GET_PARAMS _IOR('C', 0x13, struct snd_codec) | ||
148 | #define SNDRV_COMPRESS_TSTAMP _IOR('C', 0x20, struct snd_compr_tstamp) | ||
149 | #define SNDRV_COMPRESS_AVAIL _IOR('C', 0x21, struct snd_compr_avail) | ||
150 | #define SNDRV_COMPRESS_PAUSE _IO('C', 0x30) | ||
151 | #define SNDRV_COMPRESS_RESUME _IO('C', 0x31) | ||
152 | #define SNDRV_COMPRESS_START _IO('C', 0x32) | ||
153 | #define SNDRV_COMPRESS_STOP _IO('C', 0x33) | ||
154 | #define SNDRV_COMPRESS_DRAIN _IO('C', 0x34) | ||
155 | /* | ||
156 | * TODO | ||
157 | * 1. add mmap support | ||
158 | * | ||
159 | */ | ||
160 | #define SND_COMPR_TRIGGER_DRAIN 7 /*FIXME move this to pcm.h */ | ||
161 | #endif | ||