Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-or-later */
2 : : #ifndef __SOUND_PCM_H
3 : : #define __SOUND_PCM_H
4 : :
5 : : /*
6 : : * Digital Audio (PCM) abstract layer
7 : : * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
8 : : * Abramo Bagnara <abramo@alsa-project.org>
9 : : */
10 : :
11 : : #include <sound/asound.h>
12 : : #include <sound/memalloc.h>
13 : : #include <sound/minors.h>
14 : : #include <linux/poll.h>
15 : : #include <linux/mm.h>
16 : : #include <linux/bitops.h>
17 : : #include <linux/pm_qos.h>
18 : : #include <linux/refcount.h>
19 : :
20 : : #define snd_pcm_substream_chip(substream) ((substream)->private_data)
21 : : #define snd_pcm_chip(pcm) ((pcm)->private_data)
22 : :
23 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
24 : : #include <sound/pcm_oss.h>
25 : : #endif
26 : :
27 : : /*
28 : : * Hardware (lowlevel) section
29 : : */
30 : :
31 : : struct snd_pcm_hardware {
32 : : unsigned int info; /* SNDRV_PCM_INFO_* */
33 : : u64 formats; /* SNDRV_PCM_FMTBIT_* */
34 : : unsigned int rates; /* SNDRV_PCM_RATE_* */
35 : : unsigned int rate_min; /* min rate */
36 : : unsigned int rate_max; /* max rate */
37 : : unsigned int channels_min; /* min channels */
38 : : unsigned int channels_max; /* max channels */
39 : : size_t buffer_bytes_max; /* max buffer size */
40 : : size_t period_bytes_min; /* min period size */
41 : : size_t period_bytes_max; /* max period size */
42 : : unsigned int periods_min; /* min # of periods */
43 : : unsigned int periods_max; /* max # of periods */
44 : : size_t fifo_size; /* fifo size in bytes */
45 : : };
46 : :
47 : : struct snd_pcm_status64;
48 : : struct snd_pcm_substream;
49 : :
50 : : struct snd_pcm_audio_tstamp_config; /* definitions further down */
51 : : struct snd_pcm_audio_tstamp_report;
52 : :
53 : : struct snd_pcm_ops {
54 : : int (*open)(struct snd_pcm_substream *substream);
55 : : int (*close)(struct snd_pcm_substream *substream);
56 : : int (*ioctl)(struct snd_pcm_substream * substream,
57 : : unsigned int cmd, void *arg);
58 : : int (*hw_params)(struct snd_pcm_substream *substream,
59 : : struct snd_pcm_hw_params *params);
60 : : int (*hw_free)(struct snd_pcm_substream *substream);
61 : : int (*prepare)(struct snd_pcm_substream *substream);
62 : : int (*trigger)(struct snd_pcm_substream *substream, int cmd);
63 : : int (*sync_stop)(struct snd_pcm_substream *substream);
64 : : snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
65 : : int (*get_time_info)(struct snd_pcm_substream *substream,
66 : : struct timespec64 *system_ts, struct timespec64 *audio_ts,
67 : : struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
68 : : struct snd_pcm_audio_tstamp_report *audio_tstamp_report);
69 : : int (*fill_silence)(struct snd_pcm_substream *substream, int channel,
70 : : unsigned long pos, unsigned long bytes);
71 : : int (*copy_user)(struct snd_pcm_substream *substream, int channel,
72 : : unsigned long pos, void __user *buf,
73 : : unsigned long bytes);
74 : : int (*copy_kernel)(struct snd_pcm_substream *substream, int channel,
75 : : unsigned long pos, void *buf, unsigned long bytes);
76 : : struct page *(*page)(struct snd_pcm_substream *substream,
77 : : unsigned long offset);
78 : : int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
79 : : int (*ack)(struct snd_pcm_substream *substream);
80 : : };
81 : :
82 : : /*
83 : : *
84 : : */
85 : :
86 : : #if defined(CONFIG_SND_DYNAMIC_MINORS)
87 : : #define SNDRV_PCM_DEVICES (SNDRV_OS_MINORS-2)
88 : : #else
89 : : #define SNDRV_PCM_DEVICES 8
90 : : #endif
91 : :
92 : : #define SNDRV_PCM_IOCTL1_RESET 0
93 : : /* 1 is absent slot. */
94 : : #define SNDRV_PCM_IOCTL1_CHANNEL_INFO 2
95 : : /* 3 is absent slot. */
96 : : #define SNDRV_PCM_IOCTL1_FIFO_SIZE 4
97 : :
98 : : #define SNDRV_PCM_TRIGGER_STOP 0
99 : : #define SNDRV_PCM_TRIGGER_START 1
100 : : #define SNDRV_PCM_TRIGGER_PAUSE_PUSH 3
101 : : #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE 4
102 : : #define SNDRV_PCM_TRIGGER_SUSPEND 5
103 : : #define SNDRV_PCM_TRIGGER_RESUME 6
104 : : #define SNDRV_PCM_TRIGGER_DRAIN 7
105 : :
106 : : #define SNDRV_PCM_POS_XRUN ((snd_pcm_uframes_t)-1)
107 : :
108 : : /* If you change this don't forget to change rates[] table in pcm_native.c */
109 : : #define SNDRV_PCM_RATE_5512 (1<<0) /* 5512Hz */
110 : : #define SNDRV_PCM_RATE_8000 (1<<1) /* 8000Hz */
111 : : #define SNDRV_PCM_RATE_11025 (1<<2) /* 11025Hz */
112 : : #define SNDRV_PCM_RATE_16000 (1<<3) /* 16000Hz */
113 : : #define SNDRV_PCM_RATE_22050 (1<<4) /* 22050Hz */
114 : : #define SNDRV_PCM_RATE_32000 (1<<5) /* 32000Hz */
115 : : #define SNDRV_PCM_RATE_44100 (1<<6) /* 44100Hz */
116 : : #define SNDRV_PCM_RATE_48000 (1<<7) /* 48000Hz */
117 : : #define SNDRV_PCM_RATE_64000 (1<<8) /* 64000Hz */
118 : : #define SNDRV_PCM_RATE_88200 (1<<9) /* 88200Hz */
119 : : #define SNDRV_PCM_RATE_96000 (1<<10) /* 96000Hz */
120 : : #define SNDRV_PCM_RATE_176400 (1<<11) /* 176400Hz */
121 : : #define SNDRV_PCM_RATE_192000 (1<<12) /* 192000Hz */
122 : : #define SNDRV_PCM_RATE_352800 (1<<13) /* 352800Hz */
123 : : #define SNDRV_PCM_RATE_384000 (1<<14) /* 384000Hz */
124 : :
125 : : #define SNDRV_PCM_RATE_CONTINUOUS (1<<30) /* continuous range */
126 : : #define SNDRV_PCM_RATE_KNOT (1<<31) /* supports more non-continuos rates */
127 : :
128 : : #define SNDRV_PCM_RATE_8000_44100 (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
129 : : SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
130 : : SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
131 : : #define SNDRV_PCM_RATE_8000_48000 (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
132 : : #define SNDRV_PCM_RATE_8000_96000 (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
133 : : SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
134 : : #define SNDRV_PCM_RATE_8000_192000 (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
135 : : SNDRV_PCM_RATE_192000)
136 : : #define SNDRV_PCM_RATE_8000_384000 (SNDRV_PCM_RATE_8000_192000|\
137 : : SNDRV_PCM_RATE_352800|\
138 : : SNDRV_PCM_RATE_384000)
139 : : #define _SNDRV_PCM_FMTBIT(fmt) (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
140 : : #define SNDRV_PCM_FMTBIT_S8 _SNDRV_PCM_FMTBIT(S8)
141 : : #define SNDRV_PCM_FMTBIT_U8 _SNDRV_PCM_FMTBIT(U8)
142 : : #define SNDRV_PCM_FMTBIT_S16_LE _SNDRV_PCM_FMTBIT(S16_LE)
143 : : #define SNDRV_PCM_FMTBIT_S16_BE _SNDRV_PCM_FMTBIT(S16_BE)
144 : : #define SNDRV_PCM_FMTBIT_U16_LE _SNDRV_PCM_FMTBIT(U16_LE)
145 : : #define SNDRV_PCM_FMTBIT_U16_BE _SNDRV_PCM_FMTBIT(U16_BE)
146 : : #define SNDRV_PCM_FMTBIT_S24_LE _SNDRV_PCM_FMTBIT(S24_LE)
147 : : #define SNDRV_PCM_FMTBIT_S24_BE _SNDRV_PCM_FMTBIT(S24_BE)
148 : : #define SNDRV_PCM_FMTBIT_U24_LE _SNDRV_PCM_FMTBIT(U24_LE)
149 : : #define SNDRV_PCM_FMTBIT_U24_BE _SNDRV_PCM_FMTBIT(U24_BE)
150 : : #define SNDRV_PCM_FMTBIT_S32_LE _SNDRV_PCM_FMTBIT(S32_LE)
151 : : #define SNDRV_PCM_FMTBIT_S32_BE _SNDRV_PCM_FMTBIT(S32_BE)
152 : : #define SNDRV_PCM_FMTBIT_U32_LE _SNDRV_PCM_FMTBIT(U32_LE)
153 : : #define SNDRV_PCM_FMTBIT_U32_BE _SNDRV_PCM_FMTBIT(U32_BE)
154 : : #define SNDRV_PCM_FMTBIT_FLOAT_LE _SNDRV_PCM_FMTBIT(FLOAT_LE)
155 : : #define SNDRV_PCM_FMTBIT_FLOAT_BE _SNDRV_PCM_FMTBIT(FLOAT_BE)
156 : : #define SNDRV_PCM_FMTBIT_FLOAT64_LE _SNDRV_PCM_FMTBIT(FLOAT64_LE)
157 : : #define SNDRV_PCM_FMTBIT_FLOAT64_BE _SNDRV_PCM_FMTBIT(FLOAT64_BE)
158 : : #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
159 : : #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
160 : : #define SNDRV_PCM_FMTBIT_MU_LAW _SNDRV_PCM_FMTBIT(MU_LAW)
161 : : #define SNDRV_PCM_FMTBIT_A_LAW _SNDRV_PCM_FMTBIT(A_LAW)
162 : : #define SNDRV_PCM_FMTBIT_IMA_ADPCM _SNDRV_PCM_FMTBIT(IMA_ADPCM)
163 : : #define SNDRV_PCM_FMTBIT_MPEG _SNDRV_PCM_FMTBIT(MPEG)
164 : : #define SNDRV_PCM_FMTBIT_GSM _SNDRV_PCM_FMTBIT(GSM)
165 : : #define SNDRV_PCM_FMTBIT_S20_LE _SNDRV_PCM_FMTBIT(S20_LE)
166 : : #define SNDRV_PCM_FMTBIT_U20_LE _SNDRV_PCM_FMTBIT(U20_LE)
167 : : #define SNDRV_PCM_FMTBIT_S20_BE _SNDRV_PCM_FMTBIT(S20_BE)
168 : : #define SNDRV_PCM_FMTBIT_U20_BE _SNDRV_PCM_FMTBIT(U20_BE)
169 : : #define SNDRV_PCM_FMTBIT_SPECIAL _SNDRV_PCM_FMTBIT(SPECIAL)
170 : : #define SNDRV_PCM_FMTBIT_S24_3LE _SNDRV_PCM_FMTBIT(S24_3LE)
171 : : #define SNDRV_PCM_FMTBIT_U24_3LE _SNDRV_PCM_FMTBIT(U24_3LE)
172 : : #define SNDRV_PCM_FMTBIT_S24_3BE _SNDRV_PCM_FMTBIT(S24_3BE)
173 : : #define SNDRV_PCM_FMTBIT_U24_3BE _SNDRV_PCM_FMTBIT(U24_3BE)
174 : : #define SNDRV_PCM_FMTBIT_S20_3LE _SNDRV_PCM_FMTBIT(S20_3LE)
175 : : #define SNDRV_PCM_FMTBIT_U20_3LE _SNDRV_PCM_FMTBIT(U20_3LE)
176 : : #define SNDRV_PCM_FMTBIT_S20_3BE _SNDRV_PCM_FMTBIT(S20_3BE)
177 : : #define SNDRV_PCM_FMTBIT_U20_3BE _SNDRV_PCM_FMTBIT(U20_3BE)
178 : : #define SNDRV_PCM_FMTBIT_S18_3LE _SNDRV_PCM_FMTBIT(S18_3LE)
179 : : #define SNDRV_PCM_FMTBIT_U18_3LE _SNDRV_PCM_FMTBIT(U18_3LE)
180 : : #define SNDRV_PCM_FMTBIT_S18_3BE _SNDRV_PCM_FMTBIT(S18_3BE)
181 : : #define SNDRV_PCM_FMTBIT_U18_3BE _SNDRV_PCM_FMTBIT(U18_3BE)
182 : : #define SNDRV_PCM_FMTBIT_G723_24 _SNDRV_PCM_FMTBIT(G723_24)
183 : : #define SNDRV_PCM_FMTBIT_G723_24_1B _SNDRV_PCM_FMTBIT(G723_24_1B)
184 : : #define SNDRV_PCM_FMTBIT_G723_40 _SNDRV_PCM_FMTBIT(G723_40)
185 : : #define SNDRV_PCM_FMTBIT_G723_40_1B _SNDRV_PCM_FMTBIT(G723_40_1B)
186 : : #define SNDRV_PCM_FMTBIT_DSD_U8 _SNDRV_PCM_FMTBIT(DSD_U8)
187 : : #define SNDRV_PCM_FMTBIT_DSD_U16_LE _SNDRV_PCM_FMTBIT(DSD_U16_LE)
188 : : #define SNDRV_PCM_FMTBIT_DSD_U32_LE _SNDRV_PCM_FMTBIT(DSD_U32_LE)
189 : : #define SNDRV_PCM_FMTBIT_DSD_U16_BE _SNDRV_PCM_FMTBIT(DSD_U16_BE)
190 : : #define SNDRV_PCM_FMTBIT_DSD_U32_BE _SNDRV_PCM_FMTBIT(DSD_U32_BE)
191 : :
192 : : #ifdef SNDRV_LITTLE_ENDIAN
193 : : #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_LE
194 : : #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_LE
195 : : #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_LE
196 : : #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_LE
197 : : #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_LE
198 : : #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_LE
199 : : #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_LE
200 : : #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_LE
201 : : #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
202 : : #define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_LE
203 : : #define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_LE
204 : : #endif
205 : : #ifdef SNDRV_BIG_ENDIAN
206 : : #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_BE
207 : : #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_BE
208 : : #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_BE
209 : : #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_BE
210 : : #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_BE
211 : : #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_BE
212 : : #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_BE
213 : : #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_BE
214 : : #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
215 : : #define SNDRV_PCM_FMTBIT_S20 SNDRV_PCM_FMTBIT_S20_BE
216 : : #define SNDRV_PCM_FMTBIT_U20 SNDRV_PCM_FMTBIT_U20_BE
217 : : #endif
218 : :
219 : : struct snd_pcm_file {
220 : : struct snd_pcm_substream *substream;
221 : : int no_compat_mmap;
222 : : unsigned int user_pversion; /* supported protocol version */
223 : : };
224 : :
225 : : struct snd_pcm_hw_rule;
226 : : typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
227 : : struct snd_pcm_hw_rule *rule);
228 : :
229 : : struct snd_pcm_hw_rule {
230 : : unsigned int cond;
231 : : int var;
232 : : int deps[4];
233 : :
234 : : snd_pcm_hw_rule_func_t func;
235 : : void *private;
236 : : };
237 : :
238 : : struct snd_pcm_hw_constraints {
239 : : struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
240 : : SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
241 : : struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
242 : : SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
243 : : unsigned int rules_num;
244 : : unsigned int rules_all;
245 : : struct snd_pcm_hw_rule *rules;
246 : : };
247 : :
248 : 0 : static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
249 : : snd_pcm_hw_param_t var)
250 : : {
251 [ # # # # ]: 0 : return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
252 : : }
253 : :
254 : 0 : static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
255 : : snd_pcm_hw_param_t var)
256 : : {
257 [ # # ]: 0 : return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
258 : : }
259 : :
260 : : struct snd_ratnum {
261 : : unsigned int num;
262 : : unsigned int den_min, den_max, den_step;
263 : : };
264 : :
265 : : struct snd_ratden {
266 : : unsigned int num_min, num_max, num_step;
267 : : unsigned int den;
268 : : };
269 : :
270 : : struct snd_pcm_hw_constraint_ratnums {
271 : : int nrats;
272 : : const struct snd_ratnum *rats;
273 : : };
274 : :
275 : : struct snd_pcm_hw_constraint_ratdens {
276 : : int nrats;
277 : : const struct snd_ratden *rats;
278 : : };
279 : :
280 : : struct snd_pcm_hw_constraint_list {
281 : : const unsigned int *list;
282 : : unsigned int count;
283 : : unsigned int mask;
284 : : };
285 : :
286 : : struct snd_pcm_hw_constraint_ranges {
287 : : unsigned int count;
288 : : const struct snd_interval *ranges;
289 : : unsigned int mask;
290 : : };
291 : :
292 : : /*
293 : : * userspace-provided audio timestamp config to kernel,
294 : : * structure is for internal use only and filled with dedicated unpack routine
295 : : */
296 : : struct snd_pcm_audio_tstamp_config {
297 : : /* 5 of max 16 bits used */
298 : : u32 type_requested:4;
299 : : u32 report_delay:1; /* add total delay to A/D or D/A */
300 : : };
301 : :
302 : 0 : static inline void snd_pcm_unpack_audio_tstamp_config(__u32 data,
303 : : struct snd_pcm_audio_tstamp_config *config)
304 : : {
305 : 0 : config->type_requested = data & 0xF;
306 [ # # ]: 0 : config->report_delay = (data >> 4) & 1;
307 : : }
308 : :
309 : : /*
310 : : * kernel-provided audio timestamp report to user-space
311 : : * structure is for internal use only and read by dedicated pack routine
312 : : */
313 : : struct snd_pcm_audio_tstamp_report {
314 : : /* 6 of max 16 bits used for bit-fields */
315 : :
316 : : /* for backwards compatibility */
317 : : u32 valid:1;
318 : :
319 : : /* actual type if hardware could not support requested timestamp */
320 : : u32 actual_type:4;
321 : :
322 : : /* accuracy represented in ns units */
323 : : u32 accuracy_report:1; /* 0 if accuracy unknown, 1 if accuracy field is valid */
324 : : u32 accuracy; /* up to 4.29s, will be packed in separate field */
325 : : };
326 : :
327 : 0 : static inline void snd_pcm_pack_audio_tstamp_report(__u32 *data, __u32 *accuracy,
328 : : const struct snd_pcm_audio_tstamp_report *report)
329 : : {
330 : 0 : u32 tmp;
331 : :
332 : 0 : tmp = report->accuracy_report;
333 : 0 : tmp <<= 4;
334 : 0 : tmp |= report->actual_type;
335 : 0 : tmp <<= 1;
336 : 0 : tmp |= report->valid;
337 : :
338 : 0 : *data &= 0xffff; /* zero-clear MSBs */
339 : 0 : *data |= (tmp << 16);
340 : 0 : *accuracy = report->accuracy;
341 : 0 : }
342 : :
343 : :
344 : : struct snd_pcm_runtime {
345 : : /* -- Status -- */
346 : : struct snd_pcm_substream *trigger_master;
347 : : struct timespec64 trigger_tstamp; /* trigger timestamp */
348 : : bool trigger_tstamp_latched; /* trigger timestamp latched in low-level driver/hardware */
349 : : int overrange;
350 : : snd_pcm_uframes_t avail_max;
351 : : snd_pcm_uframes_t hw_ptr_base; /* Position at buffer restart */
352 : : snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
353 : : unsigned long hw_ptr_jiffies; /* Time when hw_ptr is updated */
354 : : unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */
355 : : snd_pcm_sframes_t delay; /* extra delay; typically FIFO size */
356 : : u64 hw_ptr_wrap; /* offset for hw_ptr due to boundary wrap-around */
357 : :
358 : : /* -- HW params -- */
359 : : snd_pcm_access_t access; /* access mode */
360 : : snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */
361 : : snd_pcm_subformat_t subformat; /* subformat */
362 : : unsigned int rate; /* rate in Hz */
363 : : unsigned int channels; /* channels */
364 : : snd_pcm_uframes_t period_size; /* period size */
365 : : unsigned int periods; /* periods */
366 : : snd_pcm_uframes_t buffer_size; /* buffer size */
367 : : snd_pcm_uframes_t min_align; /* Min alignment for the format */
368 : : size_t byte_align;
369 : : unsigned int frame_bits;
370 : : unsigned int sample_bits;
371 : : unsigned int info;
372 : : unsigned int rate_num;
373 : : unsigned int rate_den;
374 : : unsigned int no_period_wakeup: 1;
375 : :
376 : : /* -- SW params -- */
377 : : int tstamp_mode; /* mmap timestamp is updated */
378 : : unsigned int period_step;
379 : : snd_pcm_uframes_t start_threshold;
380 : : snd_pcm_uframes_t stop_threshold;
381 : : snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
382 : : noise is nearest than this */
383 : : snd_pcm_uframes_t silence_size; /* Silence filling size */
384 : : snd_pcm_uframes_t boundary; /* pointers wrap point */
385 : :
386 : : snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
387 : : snd_pcm_uframes_t silence_filled; /* size filled with silence */
388 : :
389 : : union snd_pcm_sync_id sync; /* hardware synchronization ID */
390 : :
391 : : /* -- mmap -- */
392 : : struct snd_pcm_mmap_status *status;
393 : : struct snd_pcm_mmap_control *control;
394 : :
395 : : /* -- locking / scheduling -- */
396 : : snd_pcm_uframes_t twake; /* do transfer (!poll) wakeup if non-zero */
397 : : wait_queue_head_t sleep; /* poll sleep */
398 : : wait_queue_head_t tsleep; /* transfer sleep */
399 : : struct fasync_struct *fasync;
400 : : bool stop_operating; /* sync_stop will be called */
401 : :
402 : : /* -- private section -- */
403 : : void *private_data;
404 : : void (*private_free)(struct snd_pcm_runtime *runtime);
405 : :
406 : : /* -- hardware description -- */
407 : : struct snd_pcm_hardware hw;
408 : : struct snd_pcm_hw_constraints hw_constraints;
409 : :
410 : : /* -- timer -- */
411 : : unsigned int timer_resolution; /* timer resolution */
412 : : int tstamp_type; /* timestamp type */
413 : :
414 : : /* -- DMA -- */
415 : : unsigned char *dma_area; /* DMA area */
416 : : dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */
417 : : size_t dma_bytes; /* size of DMA area */
418 : :
419 : : struct snd_dma_buffer *dma_buffer_p; /* allocated buffer */
420 : : unsigned int buffer_changed:1; /* buffer allocation changed; set only in managed mode */
421 : :
422 : : /* -- audio timestamp config -- */
423 : : struct snd_pcm_audio_tstamp_config audio_tstamp_config;
424 : : struct snd_pcm_audio_tstamp_report audio_tstamp_report;
425 : : struct timespec64 driver_tstamp;
426 : :
427 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
428 : : /* -- OSS things -- */
429 : : struct snd_pcm_oss_runtime oss;
430 : : #endif
431 : : };
432 : :
433 : : struct snd_pcm_group { /* keep linked substreams */
434 : : spinlock_t lock;
435 : : struct mutex mutex;
436 : : struct list_head substreams;
437 : : refcount_t refs;
438 : : };
439 : :
440 : : struct pid;
441 : :
442 : : struct snd_pcm_substream {
443 : : struct snd_pcm *pcm;
444 : : struct snd_pcm_str *pstr;
445 : : void *private_data; /* copied from pcm->private_data */
446 : : int number;
447 : : char name[32]; /* substream name */
448 : : int stream; /* stream (direction) */
449 : : struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
450 : : size_t buffer_bytes_max; /* limit ring buffer size */
451 : : struct snd_dma_buffer dma_buffer;
452 : : size_t dma_max;
453 : : /* -- hardware operations -- */
454 : : const struct snd_pcm_ops *ops;
455 : : /* -- runtime information -- */
456 : : struct snd_pcm_runtime *runtime;
457 : : /* -- timer section -- */
458 : : struct snd_timer *timer; /* timer */
459 : : unsigned timer_running: 1; /* time is running */
460 : : long wait_time; /* time in ms for R/W to wait for avail */
461 : : /* -- next substream -- */
462 : : struct snd_pcm_substream *next;
463 : : /* -- linked substreams -- */
464 : : struct list_head link_list; /* linked list member */
465 : : struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */
466 : : struct snd_pcm_group *group; /* pointer to current group */
467 : : /* -- assigned files -- */
468 : : int ref_count;
469 : : atomic_t mmap_count;
470 : : unsigned int f_flags;
471 : : void (*pcm_release)(struct snd_pcm_substream *);
472 : : struct pid *pid;
473 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
474 : : /* -- OSS things -- */
475 : : struct snd_pcm_oss_substream oss;
476 : : #endif
477 : : #ifdef CONFIG_SND_VERBOSE_PROCFS
478 : : struct snd_info_entry *proc_root;
479 : : #endif /* CONFIG_SND_VERBOSE_PROCFS */
480 : : /* misc flags */
481 : : unsigned int hw_opened: 1;
482 : : unsigned int managed_buffer_alloc:1;
483 : : };
484 : :
485 : : #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
486 : :
487 : :
488 : : struct snd_pcm_str {
489 : : int stream; /* stream (direction) */
490 : : struct snd_pcm *pcm;
491 : : /* -- substreams -- */
492 : : unsigned int substream_count;
493 : : unsigned int substream_opened;
494 : : struct snd_pcm_substream *substream;
495 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
496 : : /* -- OSS things -- */
497 : : struct snd_pcm_oss_stream oss;
498 : : #endif
499 : : #ifdef CONFIG_SND_VERBOSE_PROCFS
500 : : struct snd_info_entry *proc_root;
501 : : #ifdef CONFIG_SND_PCM_XRUN_DEBUG
502 : : unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */
503 : : #endif
504 : : #endif
505 : : struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
506 : : struct device dev;
507 : : };
508 : :
509 : : struct snd_pcm {
510 : : struct snd_card *card;
511 : : struct list_head list;
512 : : int device; /* device number */
513 : : unsigned int info_flags;
514 : : unsigned short dev_class;
515 : : unsigned short dev_subclass;
516 : : char id[64];
517 : : char name[80];
518 : : struct snd_pcm_str streams[2];
519 : : struct mutex open_mutex;
520 : : wait_queue_head_t open_wait;
521 : : void *private_data;
522 : : void (*private_free) (struct snd_pcm *pcm);
523 : : bool internal; /* pcm is for internal use only */
524 : : bool nonatomic; /* whole PCM operations are in non-atomic context */
525 : : bool no_device_suspend; /* don't invoke device PM suspend */
526 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
527 : : struct snd_pcm_oss oss;
528 : : #endif
529 : : };
530 : :
531 : : /*
532 : : * Registering
533 : : */
534 : :
535 : : extern const struct file_operations snd_pcm_f_ops[2];
536 : :
537 : : int snd_pcm_new(struct snd_card *card, const char *id, int device,
538 : : int playback_count, int capture_count,
539 : : struct snd_pcm **rpcm);
540 : : int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
541 : : int playback_count, int capture_count,
542 : : struct snd_pcm **rpcm);
543 : : int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
544 : :
545 : : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
546 : : struct snd_pcm_notify {
547 : : int (*n_register) (struct snd_pcm * pcm);
548 : : int (*n_disconnect) (struct snd_pcm * pcm);
549 : : int (*n_unregister) (struct snd_pcm * pcm);
550 : : struct list_head list;
551 : : };
552 : : int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
553 : : #endif
554 : :
555 : : /*
556 : : * Native I/O
557 : : */
558 : :
559 : : int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
560 : : int snd_pcm_info_user(struct snd_pcm_substream *substream,
561 : : struct snd_pcm_info __user *info);
562 : : int snd_pcm_status64(struct snd_pcm_substream *substream,
563 : : struct snd_pcm_status64 *status);
564 : : int snd_pcm_start(struct snd_pcm_substream *substream);
565 : : int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
566 : : int snd_pcm_drain_done(struct snd_pcm_substream *substream);
567 : : int snd_pcm_stop_xrun(struct snd_pcm_substream *substream);
568 : : #ifdef CONFIG_PM
569 : : int snd_pcm_suspend_all(struct snd_pcm *pcm);
570 : : #else
571 : : static inline int snd_pcm_suspend_all(struct snd_pcm *pcm)
572 : : {
573 : : return 0;
574 : : }
575 : : #endif
576 : : int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
577 : : int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
578 : : struct snd_pcm_substream **rsubstream);
579 : : void snd_pcm_release_substream(struct snd_pcm_substream *substream);
580 : : int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
581 : : struct snd_pcm_substream **rsubstream);
582 : : void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
583 : : int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
584 : :
585 : :
586 : : #ifdef CONFIG_SND_DEBUG
587 : : void snd_pcm_debug_name(struct snd_pcm_substream *substream,
588 : : char *name, size_t len);
589 : : #else
590 : : static inline void
591 : 0 : snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
592 : : {
593 : 0 : *buf = 0;
594 : : }
595 : : #endif
596 : :
597 : : /*
598 : : * PCM library
599 : : */
600 : :
601 : : /**
602 : : * snd_pcm_stream_linked - Check whether the substream is linked with others
603 : : * @substream: substream to check
604 : : *
605 : : * Returns true if the given substream is being linked with others.
606 : : */
607 : 0 : static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
608 : : {
609 [ # # # # : 0 : return substream->group != &substream->self_group;
# # # # #
# # # ]
610 : : }
611 : :
612 : : void snd_pcm_stream_lock(struct snd_pcm_substream *substream);
613 : : void snd_pcm_stream_unlock(struct snd_pcm_substream *substream);
614 : : void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream);
615 : : void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream);
616 : : unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream);
617 : :
618 : : /**
619 : : * snd_pcm_stream_lock_irqsave - Lock the PCM stream
620 : : * @substream: PCM substream
621 : : * @flags: irq flags
622 : : *
623 : : * This locks the PCM stream like snd_pcm_stream_lock() but with the local
624 : : * IRQ (only when nonatomic is false). In nonatomic case, this is identical
625 : : * as snd_pcm_stream_lock().
626 : : */
627 : : #define snd_pcm_stream_lock_irqsave(substream, flags) \
628 : : do { \
629 : : typecheck(unsigned long, flags); \
630 : : flags = _snd_pcm_stream_lock_irqsave(substream); \
631 : : } while (0)
632 : : void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream,
633 : : unsigned long flags);
634 : :
635 : : /**
636 : : * snd_pcm_group_for_each_entry - iterate over the linked substreams
637 : : * @s: the iterator
638 : : * @substream: the substream
639 : : *
640 : : * Iterate over the all linked substreams to the given @substream.
641 : : * When @substream isn't linked with any others, this gives returns @substream
642 : : * itself once.
643 : : */
644 : : #define snd_pcm_group_for_each_entry(s, substream) \
645 : : list_for_each_entry(s, &substream->group->substreams, link_list)
646 : :
647 : : /**
648 : : * snd_pcm_running - Check whether the substream is in a running state
649 : : * @substream: substream to check
650 : : *
651 : : * Returns true if the given substream is in the state RUNNING, or in the
652 : : * state DRAINING for playback.
653 : : */
654 : 0 : static inline int snd_pcm_running(struct snd_pcm_substream *substream)
655 : : {
656 [ # # # # : 0 : return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
657 [ # # # # : 0 : (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
# # # # #
# # # # #
# # ]
658 : : substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
659 : : }
660 : :
661 : : /**
662 : : * bytes_to_samples - Unit conversion of the size from bytes to samples
663 : : * @runtime: PCM runtime instance
664 : : * @size: size in bytes
665 : : */
666 : 0 : static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
667 : : {
668 : 0 : return size * 8 / runtime->sample_bits;
669 : : }
670 : :
671 : : /**
672 : : * bytes_to_frames - Unit conversion of the size from bytes to frames
673 : : * @runtime: PCM runtime instance
674 : : * @size: size in bytes
675 : : */
676 : 0 : static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
677 : : {
678 : 0 : return size * 8 / runtime->frame_bits;
679 : : }
680 : :
681 : : /**
682 : : * samples_to_bytes - Unit conversion of the size from samples to bytes
683 : : * @runtime: PCM runtime instance
684 : : * @size: size in samples
685 : : */
686 : 0 : static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
687 : : {
688 : 0 : return size * runtime->sample_bits / 8;
689 : : }
690 : :
691 : : /**
692 : : * frames_to_bytes - Unit conversion of the size from frames to bytes
693 : : * @runtime: PCM runtime instance
694 : : * @size: size in frames
695 : : */
696 : 0 : static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
697 : : {
698 [ # # ]: 0 : return size * runtime->frame_bits / 8;
699 : : }
700 : :
701 : : /**
702 : : * frame_aligned - Check whether the byte size is aligned to frames
703 : : * @runtime: PCM runtime instance
704 : : * @bytes: size in bytes
705 : : */
706 : 0 : static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
707 : : {
708 [ # # # # : 0 : return bytes % runtime->byte_align == 0;
# # # # ]
709 : : }
710 : :
711 : : /**
712 : : * snd_pcm_lib_buffer_bytes - Get the buffer size of the current PCM in bytes
713 : : * @substream: PCM substream
714 : : */
715 : 0 : static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
716 : : {
717 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
718 [ # # ]: 0 : return frames_to_bytes(runtime, runtime->buffer_size);
719 : : }
720 : :
721 : : /**
722 : : * snd_pcm_lib_period_bytes - Get the period size of the current PCM in bytes
723 : : * @substream: PCM substream
724 : : */
725 : 0 : static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
726 : : {
727 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
728 [ # # ]: 0 : return frames_to_bytes(runtime, runtime->period_size);
729 : : }
730 : :
731 : : /**
732 : : * snd_pcm_playback_avail - Get the available (writable) space for playback
733 : : * @runtime: PCM runtime instance
734 : : *
735 : : * Result is between 0 ... (boundary - 1)
736 : : */
737 : 0 : static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
738 : : {
739 : 0 : snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
740 : 0 : if (avail < 0)
741 : 0 : avail += runtime->boundary;
742 [ # # # # : 0 : else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
# # ]
743 : 0 : avail -= runtime->boundary;
744 [ # # ]: 0 : return avail;
745 : : }
746 : :
747 : : /**
748 : : * snd_pcm_capture_avail - Get the available (readable) space for capture
749 : : * @runtime: PCM runtime instance
750 : : *
751 : : * Result is between 0 ... (boundary - 1)
752 : : */
753 : 0 : static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
754 : : {
755 : 0 : snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
756 [ # # ]: 0 : if (avail < 0)
757 : 0 : avail += runtime->boundary;
758 [ # # ]: 0 : return avail;
759 : : }
760 : :
761 : : /**
762 : : * snd_pcm_playback_hw_avail - Get the queued space for playback
763 : : * @runtime: PCM runtime instance
764 : : */
765 : 0 : static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
766 : : {
767 [ # # # # : 0 : return runtime->buffer_size - snd_pcm_playback_avail(runtime);
# # # # #
# ]
768 : : }
769 : :
770 : : /**
771 : : * snd_pcm_capture_hw_avail - Get the free space for capture
772 : : * @runtime: PCM runtime instance
773 : : */
774 : : static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
775 : : {
776 : : return runtime->buffer_size - snd_pcm_capture_avail(runtime);
777 : : }
778 : :
779 : : /**
780 : : * snd_pcm_playback_ready - check whether the playback buffer is available
781 : : * @substream: the pcm substream instance
782 : : *
783 : : * Checks whether enough free space is available on the playback buffer.
784 : : *
785 : : * Return: Non-zero if available, or zero if not.
786 : : */
787 : : static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
788 : : {
789 : : struct snd_pcm_runtime *runtime = substream->runtime;
790 : : return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
791 : : }
792 : :
793 : : /**
794 : : * snd_pcm_capture_ready - check whether the capture buffer is available
795 : : * @substream: the pcm substream instance
796 : : *
797 : : * Checks whether enough capture data is available on the capture buffer.
798 : : *
799 : : * Return: Non-zero if available, or zero if not.
800 : : */
801 : : static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
802 : : {
803 : : struct snd_pcm_runtime *runtime = substream->runtime;
804 : : return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
805 : : }
806 : :
807 : : /**
808 : : * snd_pcm_playback_data - check whether any data exists on the playback buffer
809 : : * @substream: the pcm substream instance
810 : : *
811 : : * Checks whether any data exists on the playback buffer.
812 : : *
813 : : * Return: Non-zero if any data exists, or zero if not. If stop_threshold
814 : : * is bigger or equal to boundary, then this function returns always non-zero.
815 : : */
816 : 0 : static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
817 : : {
818 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
819 : :
820 [ # # ]: 0 : if (runtime->stop_threshold >= runtime->boundary)
821 : : return 1;
822 [ # # # # ]: 0 : return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
823 : : }
824 : :
825 : : /**
826 : : * snd_pcm_playback_empty - check whether the playback buffer is empty
827 : : * @substream: the pcm substream instance
828 : : *
829 : : * Checks whether the playback buffer is empty.
830 : : *
831 : : * Return: Non-zero if empty, or zero if not.
832 : : */
833 : 0 : static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
834 : : {
835 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
836 [ # # ]: 0 : return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
837 : : }
838 : :
839 : : /**
840 : : * snd_pcm_capture_empty - check whether the capture buffer is empty
841 : : * @substream: the pcm substream instance
842 : : *
843 : : * Checks whether the capture buffer is empty.
844 : : *
845 : : * Return: Non-zero if empty, or zero if not.
846 : : */
847 : : static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
848 : : {
849 : : struct snd_pcm_runtime *runtime = substream->runtime;
850 : : return snd_pcm_capture_avail(runtime) == 0;
851 : : }
852 : :
853 : : /**
854 : : * snd_pcm_trigger_done - Mark the master substream
855 : : * @substream: the pcm substream instance
856 : : * @master: the linked master substream
857 : : *
858 : : * When multiple substreams of the same card are linked and the hardware
859 : : * supports the single-shot operation, the driver calls this in the loop
860 : : * in snd_pcm_group_for_each_entry() for marking the substream as "done".
861 : : * Then most of trigger operations are performed only to the given master
862 : : * substream.
863 : : *
864 : : * The trigger_master mark is cleared at timestamp updates at the end
865 : : * of trigger operations.
866 : : */
867 : 0 : static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
868 : : struct snd_pcm_substream *master)
869 : : {
870 : 0 : substream->runtime->trigger_master = master;
871 : 0 : }
872 : :
873 : 0 : static inline int hw_is_mask(int var)
874 : : {
875 [ # # # # : 0 : return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
# # # # #
# ]
876 : : var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
877 : : }
878 : :
879 : 0 : static inline int hw_is_interval(int var)
880 : : {
881 [ # # # # : 0 : return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
# # # # #
# ]
882 : : var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
883 : : }
884 : :
885 : 0 : static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
886 : : snd_pcm_hw_param_t var)
887 : : {
888 [ # # ]: 0 : return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
889 : : }
890 : :
891 : 0 : static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
892 : : snd_pcm_hw_param_t var)
893 : : {
894 : 0 : return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
895 : : }
896 : :
897 : 0 : static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
898 : : snd_pcm_hw_param_t var)
899 : : {
900 : 0 : return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
901 : : }
902 : :
903 : 0 : static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
904 : : snd_pcm_hw_param_t var)
905 : : {
906 [ # # # # ]: 0 : return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
907 : : }
908 : :
909 : : /**
910 : : * params_channels - Get the number of channels from the hw params
911 : : * @p: hw params
912 : : */
913 : 0 : static inline unsigned int params_channels(const struct snd_pcm_hw_params *p)
914 : : {
915 [ # # ]: 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
916 : : }
917 : :
918 : : /**
919 : : * params_rate - Get the sample rate from the hw params
920 : : * @p: hw params
921 : : */
922 : 0 : static inline unsigned int params_rate(const struct snd_pcm_hw_params *p)
923 : : {
924 [ # # ]: 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_RATE)->min;
925 : : }
926 : :
927 : : /**
928 : : * params_period_size - Get the period size (in frames) from the hw params
929 : : * @p: hw params
930 : : */
931 : 0 : static inline unsigned int params_period_size(const struct snd_pcm_hw_params *p)
932 : : {
933 [ # # ]: 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
934 : : }
935 : :
936 : : /**
937 : : * params_periods - Get the number of periods from the hw params
938 : : * @p: hw params
939 : : */
940 : 0 : static inline unsigned int params_periods(const struct snd_pcm_hw_params *p)
941 : : {
942 [ # # ]: 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIODS)->min;
943 : : }
944 : :
945 : : /**
946 : : * params_buffer_size - Get the buffer size (in frames) from the hw params
947 : : * @p: hw params
948 : : */
949 : 0 : static inline unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)
950 : : {
951 [ # # ]: 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min;
952 : : }
953 : :
954 : : /**
955 : : * params_buffer_bytes - Get the buffer size (in bytes) from the hw params
956 : : * @p: hw params
957 : : */
958 : 0 : static inline unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p)
959 : : {
960 : 0 : return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min;
961 : : }
962 : :
963 : : int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
964 : : int snd_interval_list(struct snd_interval *i, unsigned int count,
965 : : const unsigned int *list, unsigned int mask);
966 : : int snd_interval_ranges(struct snd_interval *i, unsigned int count,
967 : : const struct snd_interval *list, unsigned int mask);
968 : : int snd_interval_ratnum(struct snd_interval *i,
969 : : unsigned int rats_count, const struct snd_ratnum *rats,
970 : : unsigned int *nump, unsigned int *denp);
971 : :
972 : : void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
973 : : void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
974 : :
975 : : int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
976 : :
977 : : int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
978 : : u_int64_t mask);
979 : : int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
980 : : unsigned int min, unsigned int max);
981 : : int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
982 : : int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
983 : : unsigned int cond,
984 : : snd_pcm_hw_param_t var,
985 : : const struct snd_pcm_hw_constraint_list *l);
986 : : int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime,
987 : : unsigned int cond,
988 : : snd_pcm_hw_param_t var,
989 : : const struct snd_pcm_hw_constraint_ranges *r);
990 : : int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
991 : : unsigned int cond,
992 : : snd_pcm_hw_param_t var,
993 : : const struct snd_pcm_hw_constraint_ratnums *r);
994 : : int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
995 : : unsigned int cond,
996 : : snd_pcm_hw_param_t var,
997 : : const struct snd_pcm_hw_constraint_ratdens *r);
998 : : int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
999 : : unsigned int cond,
1000 : : unsigned int width,
1001 : : unsigned int msbits);
1002 : : int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
1003 : : unsigned int cond,
1004 : : snd_pcm_hw_param_t var,
1005 : : unsigned long step);
1006 : : int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
1007 : : unsigned int cond,
1008 : : snd_pcm_hw_param_t var);
1009 : : int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
1010 : : unsigned int base_rate);
1011 : : int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
1012 : : unsigned int cond,
1013 : : int var,
1014 : : snd_pcm_hw_rule_func_t func, void *private,
1015 : : int dep, ...);
1016 : :
1017 : : /**
1018 : : * snd_pcm_hw_constraint_single() - Constrain parameter to a single value
1019 : : * @runtime: PCM runtime instance
1020 : : * @var: The hw_params variable to constrain
1021 : : * @val: The value to constrain to
1022 : : *
1023 : : * Return: Positive if the value is changed, zero if it's not changed, or a
1024 : : * negative error code.
1025 : : */
1026 : : static inline int snd_pcm_hw_constraint_single(
1027 : : struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1028 : : unsigned int val)
1029 : : {
1030 : : return snd_pcm_hw_constraint_minmax(runtime, var, val, val);
1031 : : }
1032 : :
1033 : : int snd_pcm_format_signed(snd_pcm_format_t format);
1034 : : int snd_pcm_format_unsigned(snd_pcm_format_t format);
1035 : : int snd_pcm_format_linear(snd_pcm_format_t format);
1036 : : int snd_pcm_format_little_endian(snd_pcm_format_t format);
1037 : : int snd_pcm_format_big_endian(snd_pcm_format_t format);
1038 : : #if 0 /* just for kernel-doc */
1039 : : /**
1040 : : * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
1041 : : * @format: the format to check
1042 : : *
1043 : : * Return: 1 if the given PCM format is CPU-endian, 0 if
1044 : : * opposite, or a negative error code if endian not specified.
1045 : : */
1046 : : int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
1047 : : #endif /* DocBook */
1048 : : #ifdef SNDRV_LITTLE_ENDIAN
1049 : : #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
1050 : : #else
1051 : : #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
1052 : : #endif
1053 : : int snd_pcm_format_width(snd_pcm_format_t format); /* in bits */
1054 : : int snd_pcm_format_physical_width(snd_pcm_format_t format); /* in bits */
1055 : : ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
1056 : : const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
1057 : : int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
1058 : :
1059 : : void snd_pcm_set_ops(struct snd_pcm * pcm, int direction,
1060 : : const struct snd_pcm_ops *ops);
1061 : : void snd_pcm_set_sync(struct snd_pcm_substream *substream);
1062 : : int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
1063 : : unsigned int cmd, void *arg);
1064 : : void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
1065 : : snd_pcm_sframes_t __snd_pcm_lib_xfer(struct snd_pcm_substream *substream,
1066 : : void *buf, bool interleaved,
1067 : : snd_pcm_uframes_t frames, bool in_kernel);
1068 : :
1069 : : static inline snd_pcm_sframes_t
1070 : 0 : snd_pcm_lib_write(struct snd_pcm_substream *substream,
1071 : : const void __user *buf, snd_pcm_uframes_t frames)
1072 : : {
1073 : 0 : return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
1074 : : }
1075 : :
1076 : : static inline snd_pcm_sframes_t
1077 : 0 : snd_pcm_lib_read(struct snd_pcm_substream *substream,
1078 : : void __user *buf, snd_pcm_uframes_t frames)
1079 : : {
1080 : 0 : return __snd_pcm_lib_xfer(substream, (void __force *)buf, true, frames, false);
1081 : : }
1082 : :
1083 : : static inline snd_pcm_sframes_t
1084 : 0 : snd_pcm_lib_writev(struct snd_pcm_substream *substream,
1085 : : void __user **bufs, snd_pcm_uframes_t frames)
1086 : : {
1087 : 0 : return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
1088 : : }
1089 : :
1090 : : static inline snd_pcm_sframes_t
1091 : 0 : snd_pcm_lib_readv(struct snd_pcm_substream *substream,
1092 : : void __user **bufs, snd_pcm_uframes_t frames)
1093 : : {
1094 : 0 : return __snd_pcm_lib_xfer(substream, (void *)bufs, false, frames, false);
1095 : : }
1096 : :
1097 : : static inline snd_pcm_sframes_t
1098 : : snd_pcm_kernel_write(struct snd_pcm_substream *substream,
1099 : : const void *buf, snd_pcm_uframes_t frames)
1100 : : {
1101 : : return __snd_pcm_lib_xfer(substream, (void *)buf, true, frames, true);
1102 : : }
1103 : :
1104 : : static inline snd_pcm_sframes_t
1105 : : snd_pcm_kernel_read(struct snd_pcm_substream *substream,
1106 : : void *buf, snd_pcm_uframes_t frames)
1107 : : {
1108 : : return __snd_pcm_lib_xfer(substream, buf, true, frames, true);
1109 : : }
1110 : :
1111 : : static inline snd_pcm_sframes_t
1112 : : snd_pcm_kernel_writev(struct snd_pcm_substream *substream,
1113 : : void **bufs, snd_pcm_uframes_t frames)
1114 : : {
1115 : : return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
1116 : : }
1117 : :
1118 : : static inline snd_pcm_sframes_t
1119 : : snd_pcm_kernel_readv(struct snd_pcm_substream *substream,
1120 : : void **bufs, snd_pcm_uframes_t frames)
1121 : : {
1122 : : return __snd_pcm_lib_xfer(substream, bufs, false, frames, true);
1123 : : }
1124 : :
1125 : : int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
1126 : : unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate);
1127 : : unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit);
1128 : : unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
1129 : : unsigned int rates_b);
1130 : : unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
1131 : : unsigned int rate_max);
1132 : :
1133 : : /**
1134 : : * snd_pcm_set_runtime_buffer - Set the PCM runtime buffer
1135 : : * @substream: PCM substream to set
1136 : : * @bufp: the buffer information, NULL to clear
1137 : : *
1138 : : * Copy the buffer information to runtime->dma_buffer when @bufp is non-NULL.
1139 : : * Otherwise it clears the current buffer information.
1140 : : */
1141 : 0 : static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
1142 : : struct snd_dma_buffer *bufp)
1143 : : {
1144 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
1145 [ # # ]: 0 : if (bufp) {
1146 : 0 : runtime->dma_buffer_p = bufp;
1147 : 0 : runtime->dma_area = bufp->area;
1148 : 0 : runtime->dma_addr = bufp->addr;
1149 : 0 : runtime->dma_bytes = bufp->bytes;
1150 : : } else {
1151 : 0 : runtime->dma_buffer_p = NULL;
1152 : 0 : runtime->dma_area = NULL;
1153 : 0 : runtime->dma_addr = 0;
1154 : 0 : runtime->dma_bytes = 0;
1155 : : }
1156 : : }
1157 : :
1158 : : /**
1159 : : * snd_pcm_gettime - Fill the timespec64 depending on the timestamp mode
1160 : : * @runtime: PCM runtime instance
1161 : : * @tv: timespec64 to fill
1162 : : */
1163 : : static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime,
1164 : : struct timespec64 *tv)
1165 : : {
1166 : : switch (runtime->tstamp_type) {
1167 : : case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC:
1168 : : ktime_get_ts64(tv);
1169 : : break;
1170 : : case SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW:
1171 : : ktime_get_raw_ts64(tv);
1172 : : break;
1173 : : default:
1174 : : ktime_get_real_ts64(tv);
1175 : : break;
1176 : : }
1177 : : }
1178 : :
1179 : : /*
1180 : : * Memory
1181 : : */
1182 : :
1183 : : void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
1184 : : void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
1185 : : void snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
1186 : : int type, struct device *data,
1187 : : size_t size, size_t max);
1188 : : void snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
1189 : : int type, void *data,
1190 : : size_t size, size_t max);
1191 : : int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
1192 : : int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
1193 : :
1194 : : void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
1195 : : struct device *data, size_t size, size_t max);
1196 : : void snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,
1197 : : struct device *data,
1198 : : size_t size, size_t max);
1199 : :
1200 : : int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
1201 : : size_t size, gfp_t gfp_flags);
1202 : : int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream);
1203 : : struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
1204 : : unsigned long offset);
1205 : : /**
1206 : : * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer
1207 : : * @substream: the substream to allocate the buffer to
1208 : : * @size: the requested buffer size, in bytes
1209 : : *
1210 : : * Allocates the PCM substream buffer using vmalloc(), i.e., the memory is
1211 : : * contiguous in kernel virtual space, but not in physical memory. Use this
1212 : : * if the buffer is accessed by kernel code but not by device DMA.
1213 : : *
1214 : : * Return: 1 if the buffer was changed, 0 if not changed, or a negative error
1215 : : * code.
1216 : : */
1217 : : static inline int snd_pcm_lib_alloc_vmalloc_buffer
1218 : : (struct snd_pcm_substream *substream, size_t size)
1219 : : {
1220 : : return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
1221 : : GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
1222 : : }
1223 : :
1224 : : /**
1225 : : * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer
1226 : : * @substream: the substream to allocate the buffer to
1227 : : * @size: the requested buffer size, in bytes
1228 : : *
1229 : : * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses
1230 : : * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory.
1231 : : *
1232 : : * Return: 1 if the buffer was changed, 0 if not changed, or a negative error
1233 : : * code.
1234 : : */
1235 : : static inline int snd_pcm_lib_alloc_vmalloc_32_buffer
1236 : : (struct snd_pcm_substream *substream, size_t size)
1237 : : {
1238 : : return _snd_pcm_lib_alloc_vmalloc_buffer(substream, size,
1239 : : GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1240 : : }
1241 : :
1242 : : #define snd_pcm_get_dma_buf(substream) ((substream)->runtime->dma_buffer_p)
1243 : :
1244 : : #ifdef CONFIG_SND_DMA_SGBUF
1245 : : /*
1246 : : * SG-buffer handling
1247 : : */
1248 : : #define snd_pcm_substream_sgbuf(substream) \
1249 : : snd_pcm_get_dma_buf(substream)->private_data
1250 : : #endif /* SND_DMA_SGBUF */
1251 : :
1252 : : /**
1253 : : * snd_pcm_sgbuf_get_addr - Get the DMA address at the corresponding offset
1254 : : * @substream: PCM substream
1255 : : * @ofs: byte offset
1256 : : */
1257 : : static inline dma_addr_t
1258 : : snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
1259 : : {
1260 : : return snd_sgbuf_get_addr(snd_pcm_get_dma_buf(substream), ofs);
1261 : : }
1262 : :
1263 : : /**
1264 : : * snd_pcm_sgbuf_get_ptr - Get the virtual address at the corresponding offset
1265 : : * @substream: PCM substream
1266 : : * @ofs: byte offset
1267 : : */
1268 : : static inline void *
1269 : : snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
1270 : : {
1271 : : return snd_sgbuf_get_ptr(snd_pcm_get_dma_buf(substream), ofs);
1272 : : }
1273 : :
1274 : : /**
1275 : : * snd_pcm_sgbuf_chunk_size - Compute the max size that fits within the contig.
1276 : : * page from the given size
1277 : : * @substream: PCM substream
1278 : : * @ofs: byte offset
1279 : : * @size: byte size to examine
1280 : : */
1281 : : static inline unsigned int
1282 : : snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
1283 : : unsigned int ofs, unsigned int size)
1284 : : {
1285 : : return snd_sgbuf_get_chunk_size(snd_pcm_get_dma_buf(substream), ofs, size);
1286 : : }
1287 : :
1288 : : /**
1289 : : * snd_pcm_mmap_data_open - increase the mmap counter
1290 : : * @area: VMA
1291 : : *
1292 : : * PCM mmap callback should handle this counter properly
1293 : : */
1294 : 0 : static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
1295 : : {
1296 : 0 : struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1297 : 0 : atomic_inc(&substream->mmap_count);
1298 : 0 : }
1299 : :
1300 : : /**
1301 : : * snd_pcm_mmap_data_close - decrease the mmap counter
1302 : : * @area: VMA
1303 : : *
1304 : : * PCM mmap callback should handle this counter properly
1305 : : */
1306 : 0 : static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
1307 : : {
1308 : 0 : struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1309 : 0 : atomic_dec(&substream->mmap_count);
1310 : 0 : }
1311 : :
1312 : : int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
1313 : : struct vm_area_struct *area);
1314 : : /* mmap for io-memory area */
1315 : : #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
1316 : : #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP
1317 : : int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
1318 : : #else
1319 : : #define SNDRV_PCM_INFO_MMAP_IOMEM 0
1320 : : #define snd_pcm_lib_mmap_iomem NULL
1321 : : #endif
1322 : :
1323 : : /**
1324 : : * snd_pcm_limit_isa_dma_size - Get the max size fitting with ISA DMA transfer
1325 : : * @dma: DMA number
1326 : : * @max: pointer to store the max size
1327 : : */
1328 : : static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
1329 : : {
1330 : : *max = dma < 4 ? 64 * 1024 : 128 * 1024;
1331 : : }
1332 : :
1333 : : /*
1334 : : * Misc
1335 : : */
1336 : :
1337 : : #define SNDRV_PCM_DEFAULT_CON_SPDIF (IEC958_AES0_CON_EMPHASIS_NONE|\
1338 : : (IEC958_AES1_CON_ORIGINAL<<8)|\
1339 : : (IEC958_AES1_CON_PCM_CODER<<8)|\
1340 : : (IEC958_AES3_CON_FS_48000<<24))
1341 : :
1342 : : const char *snd_pcm_format_name(snd_pcm_format_t format);
1343 : :
1344 : : /**
1345 : : * snd_pcm_stream_str - Get a string naming the direction of a stream
1346 : : * @substream: the pcm substream instance
1347 : : *
1348 : : * Return: A string naming the direction of the stream.
1349 : : */
1350 : : static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
1351 : : {
1352 : : if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1353 : : return "Playback";
1354 : : else
1355 : : return "Capture";
1356 : : }
1357 : :
1358 : : /*
1359 : : * PCM channel-mapping control API
1360 : : */
1361 : : /* array element of channel maps */
1362 : : struct snd_pcm_chmap_elem {
1363 : : unsigned char channels;
1364 : : unsigned char map[15];
1365 : : };
1366 : :
1367 : : /* channel map information; retrieved via snd_kcontrol_chip() */
1368 : : struct snd_pcm_chmap {
1369 : : struct snd_pcm *pcm; /* assigned PCM instance */
1370 : : int stream; /* PLAYBACK or CAPTURE */
1371 : : struct snd_kcontrol *kctl;
1372 : : const struct snd_pcm_chmap_elem *chmap;
1373 : : unsigned int max_channels;
1374 : : unsigned int channel_mask; /* optional: active channels bitmask */
1375 : : void *private_data; /* optional: private data pointer */
1376 : : };
1377 : :
1378 : : /**
1379 : : * snd_pcm_chmap_substream - get the PCM substream assigned to the given chmap info
1380 : : * @info: chmap information
1381 : : * @idx: the substream number index
1382 : : */
1383 : : static inline struct snd_pcm_substream *
1384 : 0 : snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx)
1385 : : {
1386 : 0 : struct snd_pcm_substream *s;
1387 [ # # ]: 0 : for (s = info->pcm->streams[info->stream].substream; s; s = s->next)
1388 [ # # ]: 0 : if (s->number == idx)
1389 : : return s;
1390 : : return NULL;
1391 : : }
1392 : :
1393 : : /* ALSA-standard channel maps (RL/RR prior to C/LFE) */
1394 : : extern const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[];
1395 : : /* Other world's standard channel maps (C/LFE prior to RL/RR) */
1396 : : extern const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[];
1397 : :
1398 : : /* bit masks to be passed to snd_pcm_chmap.channel_mask field */
1399 : : #define SND_PCM_CHMAP_MASK_24 ((1U << 2) | (1U << 4))
1400 : : #define SND_PCM_CHMAP_MASK_246 (SND_PCM_CHMAP_MASK_24 | (1U << 6))
1401 : : #define SND_PCM_CHMAP_MASK_2468 (SND_PCM_CHMAP_MASK_246 | (1U << 8))
1402 : :
1403 : : int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
1404 : : const struct snd_pcm_chmap_elem *chmap,
1405 : : int max_channels,
1406 : : unsigned long private_value,
1407 : : struct snd_pcm_chmap **info_ret);
1408 : :
1409 : : /**
1410 : : * pcm_format_to_bits - Strong-typed conversion of pcm_format to bitwise
1411 : : * @pcm_format: PCM format
1412 : : */
1413 : : static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)
1414 : : {
1415 : : return 1ULL << (__force int) pcm_format;
1416 : : }
1417 : :
1418 : : /* printk helpers */
1419 : : #define pcm_err(pcm, fmt, args...) \
1420 : : dev_err((pcm)->card->dev, fmt, ##args)
1421 : : #define pcm_warn(pcm, fmt, args...) \
1422 : : dev_warn((pcm)->card->dev, fmt, ##args)
1423 : : #define pcm_dbg(pcm, fmt, args...) \
1424 : : dev_dbg((pcm)->card->dev, fmt, ##args)
1425 : :
1426 : : struct snd_pcm_status64 {
1427 : : snd_pcm_state_t state; /* stream state */
1428 : : u8 rsvd[4];
1429 : : s64 trigger_tstamp_sec; /* time when stream was started/stopped/paused */
1430 : : s64 trigger_tstamp_nsec;
1431 : : s64 tstamp_sec; /* reference timestamp */
1432 : : s64 tstamp_nsec;
1433 : : snd_pcm_uframes_t appl_ptr; /* appl ptr */
1434 : : snd_pcm_uframes_t hw_ptr; /* hw ptr */
1435 : : snd_pcm_sframes_t delay; /* current delay in frames */
1436 : : snd_pcm_uframes_t avail; /* number of frames available */
1437 : : snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */
1438 : : snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */
1439 : : snd_pcm_state_t suspended_state; /* suspended stream state */
1440 : : __u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */
1441 : : s64 audio_tstamp_sec; /* sample counter, wall clock, PHC or on-demand sync'ed */
1442 : : s64 audio_tstamp_nsec;
1443 : : s64 driver_tstamp_sec; /* useful in case reference system tstamp is reported with delay */
1444 : : s64 driver_tstamp_nsec;
1445 : : __u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */
1446 : : unsigned char reserved[52-4*sizeof(s64)]; /* must be filled with zero */
1447 : : };
1448 : :
1449 : : #define SNDRV_PCM_IOCTL_STATUS64 _IOR('A', 0x20, struct snd_pcm_status64)
1450 : : #define SNDRV_PCM_IOCTL_STATUS_EXT64 _IOWR('A', 0x24, struct snd_pcm_status64)
1451 : :
1452 : : struct snd_pcm_status32 {
1453 : : snd_pcm_state_t state; /* stream state */
1454 : : s32 trigger_tstamp_sec; /* time when stream was started/stopped/paused */
1455 : : s32 trigger_tstamp_nsec;
1456 : : s32 tstamp_sec; /* reference timestamp */
1457 : : s32 tstamp_nsec;
1458 : : u32 appl_ptr; /* appl ptr */
1459 : : u32 hw_ptr; /* hw ptr */
1460 : : s32 delay; /* current delay in frames */
1461 : : u32 avail; /* number of frames available */
1462 : : u32 avail_max; /* max frames available on hw since last status */
1463 : : u32 overrange; /* count of ADC (capture) overrange detections from last status */
1464 : : snd_pcm_state_t suspended_state; /* suspended stream state */
1465 : : u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */
1466 : : s32 audio_tstamp_sec; /* sample counter, wall clock, PHC or on-demand sync'ed */
1467 : : s32 audio_tstamp_nsec;
1468 : : s32 driver_tstamp_sec; /* useful in case reference system tstamp is reported with delay */
1469 : : s32 driver_tstamp_nsec;
1470 : : u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */
1471 : : unsigned char reserved[52-4*sizeof(s32)]; /* must be filled with zero */
1472 : : };
1473 : :
1474 : : #define SNDRV_PCM_IOCTL_STATUS32 _IOR('A', 0x20, struct snd_pcm_status32)
1475 : : #define SNDRV_PCM_IOCTL_STATUS_EXT32 _IOWR('A', 0x24, struct snd_pcm_status32)
1476 : :
1477 : : #endif /* __SOUND_PCM_H */
|
