Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
1da177e4 LT |
2 | #ifndef __SOUND_PCM_PARAMS_H |
3 | #define __SOUND_PCM_PARAMS_H | |
4 | ||
5 | /* | |
6 | * PCM params helpers | |
7 | * Copyright (c) by Abramo Bagnara <abramo@alsa-project.org> | |
1da177e4 LT |
8 | */ |
9 | ||
f3761c39 MB |
10 | #include <sound/pcm.h> |
11 | ||
e88e8ae6 TI |
12 | int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, |
13 | struct snd_pcm_hw_params *params, | |
14 | snd_pcm_hw_param_t var, int *dir); | |
15 | int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, | |
16 | struct snd_pcm_hw_params *params, | |
17 | snd_pcm_hw_param_t var, int *dir); | |
18 | int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, | |
19 | snd_pcm_hw_param_t var, int *dir); | |
1da177e4 | 20 | |
1da177e4 LT |
21 | #define SNDRV_MASK_BITS 64 /* we use so far 64bits only */ |
22 | #define SNDRV_MASK_SIZE (SNDRV_MASK_BITS / 32) | |
23 | #define MASK_OFS(i) ((i) >> 5) | |
24 | #define MASK_BIT(i) (1U << ((i) & 31)) | |
25 | ||
9bb22e21 | 26 | static inline size_t snd_mask_sizeof(void) |
1da177e4 | 27 | { |
877211f5 | 28 | return sizeof(struct snd_mask); |
1da177e4 LT |
29 | } |
30 | ||
9bb22e21 | 31 | static inline void snd_mask_none(struct snd_mask *mask) |
1da177e4 LT |
32 | { |
33 | memset(mask, 0, sizeof(*mask)); | |
34 | } | |
35 | ||
9bb22e21 | 36 | static inline void snd_mask_any(struct snd_mask *mask) |
1da177e4 LT |
37 | { |
38 | memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t)); | |
39 | } | |
40 | ||
9bb22e21 | 41 | static inline int snd_mask_empty(const struct snd_mask *mask) |
1da177e4 LT |
42 | { |
43 | int i; | |
44 | for (i = 0; i < SNDRV_MASK_SIZE; i++) | |
45 | if (mask->bits[i]) | |
46 | return 0; | |
47 | return 1; | |
48 | } | |
49 | ||
9bb22e21 | 50 | static inline unsigned int snd_mask_min(const struct snd_mask *mask) |
1da177e4 LT |
51 | { |
52 | int i; | |
1da177e4 LT |
53 | for (i = 0; i < SNDRV_MASK_SIZE; i++) { |
54 | if (mask->bits[i]) | |
599ee329 | 55 | return __ffs(mask->bits[i]) + (i << 5); |
1da177e4 LT |
56 | } |
57 | return 0; | |
58 | } | |
59 | ||
9bb22e21 | 60 | static inline unsigned int snd_mask_max(const struct snd_mask *mask) |
1da177e4 LT |
61 | { |
62 | int i; | |
1da177e4 LT |
63 | for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) { |
64 | if (mask->bits[i]) | |
757b0376 | 65 | return __fls(mask->bits[i]) + (i << 5); |
1da177e4 LT |
66 | } |
67 | return 0; | |
68 | } | |
69 | ||
9bb22e21 | 70 | static inline void snd_mask_set(struct snd_mask *mask, unsigned int val) |
1da177e4 | 71 | { |
1da177e4 LT |
72 | mask->bits[MASK_OFS(val)] |= MASK_BIT(val); |
73 | } | |
74 | ||
0b62834e TI |
75 | /* Most of drivers need only this one */ |
76 | static inline void snd_mask_set_format(struct snd_mask *mask, | |
77 | snd_pcm_format_t format) | |
78 | { | |
79 | snd_mask_set(mask, (__force unsigned int)format); | |
80 | } | |
81 | ||
9bb22e21 | 82 | static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val) |
1da177e4 | 83 | { |
1da177e4 LT |
84 | mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val); |
85 | } | |
86 | ||
9bb22e21 TI |
87 | static inline void snd_mask_set_range(struct snd_mask *mask, |
88 | unsigned int from, unsigned int to) | |
1da177e4 LT |
89 | { |
90 | unsigned int i; | |
1da177e4 LT |
91 | for (i = from; i <= to; i++) |
92 | mask->bits[MASK_OFS(i)] |= MASK_BIT(i); | |
93 | } | |
94 | ||
9bb22e21 TI |
95 | static inline void snd_mask_reset_range(struct snd_mask *mask, |
96 | unsigned int from, unsigned int to) | |
1da177e4 LT |
97 | { |
98 | unsigned int i; | |
1da177e4 LT |
99 | for (i = from; i <= to; i++) |
100 | mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i); | |
101 | } | |
102 | ||
9bb22e21 | 103 | static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val) |
1da177e4 LT |
104 | { |
105 | unsigned int v; | |
1da177e4 LT |
106 | v = mask->bits[MASK_OFS(val)] & MASK_BIT(val); |
107 | snd_mask_none(mask); | |
108 | mask->bits[MASK_OFS(val)] = v; | |
109 | } | |
110 | ||
9bb22e21 TI |
111 | static inline void snd_mask_intersect(struct snd_mask *mask, |
112 | const struct snd_mask *v) | |
1da177e4 LT |
113 | { |
114 | int i; | |
115 | for (i = 0; i < SNDRV_MASK_SIZE; i++) | |
116 | mask->bits[i] &= v->bits[i]; | |
117 | } | |
118 | ||
9bb22e21 TI |
119 | static inline int snd_mask_eq(const struct snd_mask *mask, |
120 | const struct snd_mask *v) | |
1da177e4 LT |
121 | { |
122 | return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t)); | |
123 | } | |
124 | ||
9bb22e21 TI |
125 | static inline void snd_mask_copy(struct snd_mask *mask, |
126 | const struct snd_mask *v) | |
1da177e4 LT |
127 | { |
128 | *mask = *v; | |
129 | } | |
130 | ||
9bb22e21 | 131 | static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val) |
1da177e4 | 132 | { |
1da177e4 LT |
133 | return mask->bits[MASK_OFS(val)] & MASK_BIT(val); |
134 | } | |
135 | ||
9bb22e21 | 136 | static inline int snd_mask_single(const struct snd_mask *mask) |
1da177e4 LT |
137 | { |
138 | int i, c = 0; | |
1da177e4 LT |
139 | for (i = 0; i < SNDRV_MASK_SIZE; i++) { |
140 | if (! mask->bits[i]) | |
141 | continue; | |
142 | if (mask->bits[i] & (mask->bits[i] - 1)) | |
143 | return 0; | |
144 | if (c) | |
145 | return 0; | |
146 | c++; | |
147 | } | |
148 | return 1; | |
149 | } | |
150 | ||
9bb22e21 TI |
151 | static inline int snd_mask_refine(struct snd_mask *mask, |
152 | const struct snd_mask *v) | |
1da177e4 | 153 | { |
877211f5 | 154 | struct snd_mask old; |
1da177e4 LT |
155 | snd_mask_copy(&old, mask); |
156 | snd_mask_intersect(mask, v); | |
157 | if (snd_mask_empty(mask)) | |
158 | return -EINVAL; | |
159 | return !snd_mask_eq(mask, &old); | |
160 | } | |
161 | ||
9bb22e21 | 162 | static inline int snd_mask_refine_first(struct snd_mask *mask) |
1da177e4 | 163 | { |
1da177e4 LT |
164 | if (snd_mask_single(mask)) |
165 | return 0; | |
166 | snd_mask_leave(mask, snd_mask_min(mask)); | |
167 | return 1; | |
168 | } | |
169 | ||
9bb22e21 | 170 | static inline int snd_mask_refine_last(struct snd_mask *mask) |
1da177e4 | 171 | { |
1da177e4 LT |
172 | if (snd_mask_single(mask)) |
173 | return 0; | |
174 | snd_mask_leave(mask, snd_mask_max(mask)); | |
175 | return 1; | |
176 | } | |
177 | ||
9bb22e21 | 178 | static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val) |
1da177e4 | 179 | { |
1da177e4 LT |
180 | if (snd_mask_min(mask) >= val) |
181 | return 0; | |
182 | snd_mask_reset_range(mask, 0, val - 1); | |
183 | if (snd_mask_empty(mask)) | |
184 | return -EINVAL; | |
185 | return 1; | |
186 | } | |
187 | ||
9bb22e21 | 188 | static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val) |
1da177e4 | 189 | { |
1da177e4 LT |
190 | if (snd_mask_max(mask) <= val) |
191 | return 0; | |
192 | snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS); | |
193 | if (snd_mask_empty(mask)) | |
194 | return -EINVAL; | |
195 | return 1; | |
196 | } | |
197 | ||
9bb22e21 | 198 | static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val) |
1da177e4 LT |
199 | { |
200 | int changed; | |
1da177e4 LT |
201 | changed = !snd_mask_single(mask); |
202 | snd_mask_leave(mask, val); | |
203 | if (snd_mask_empty(mask)) | |
204 | return -EINVAL; | |
205 | return changed; | |
206 | } | |
207 | ||
9bb22e21 | 208 | static inline int snd_mask_value(const struct snd_mask *mask) |
1da177e4 | 209 | { |
1da177e4 LT |
210 | return snd_mask_min(mask); |
211 | } | |
212 | ||
9bb22e21 | 213 | static inline void snd_interval_any(struct snd_interval *i) |
1da177e4 LT |
214 | { |
215 | i->min = 0; | |
216 | i->openmin = 0; | |
217 | i->max = UINT_MAX; | |
218 | i->openmax = 0; | |
219 | i->integer = 0; | |
220 | i->empty = 0; | |
221 | } | |
222 | ||
9bb22e21 | 223 | static inline void snd_interval_none(struct snd_interval *i) |
1da177e4 LT |
224 | { |
225 | i->empty = 1; | |
226 | } | |
227 | ||
9bb22e21 | 228 | static inline int snd_interval_checkempty(const struct snd_interval *i) |
1da177e4 LT |
229 | { |
230 | return (i->min > i->max || | |
231 | (i->min == i->max && (i->openmin || i->openmax))); | |
232 | } | |
233 | ||
9bb22e21 | 234 | static inline int snd_interval_empty(const struct snd_interval *i) |
1da177e4 LT |
235 | { |
236 | return i->empty; | |
237 | } | |
238 | ||
9bb22e21 | 239 | static inline int snd_interval_single(const struct snd_interval *i) |
1da177e4 | 240 | { |
1da177e4 | 241 | return (i->min == i->max || |
5363857b | 242 | (i->min + 1 == i->max && (i->openmin || i->openmax))); |
1da177e4 LT |
243 | } |
244 | ||
9bb22e21 | 245 | static inline int snd_interval_value(const struct snd_interval *i) |
1da177e4 | 246 | { |
5363857b TI |
247 | if (i->openmin && !i->openmax) |
248 | return i->max; | |
1da177e4 LT |
249 | return i->min; |
250 | } | |
251 | ||
9bb22e21 | 252 | static inline int snd_interval_min(const struct snd_interval *i) |
1da177e4 | 253 | { |
1da177e4 LT |
254 | return i->min; |
255 | } | |
256 | ||
9bb22e21 | 257 | static inline int snd_interval_max(const struct snd_interval *i) |
1da177e4 LT |
258 | { |
259 | unsigned int v; | |
1da177e4 LT |
260 | v = i->max; |
261 | if (i->openmax) | |
262 | v--; | |
263 | return v; | |
264 | } | |
265 | ||
9bb22e21 | 266 | static inline int snd_interval_test(const struct snd_interval *i, unsigned int val) |
1da177e4 LT |
267 | { |
268 | return !((i->min > val || (i->min == val && i->openmin) || | |
269 | i->max < val || (i->max == val && i->openmax))); | |
270 | } | |
271 | ||
9bb22e21 | 272 | static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s) |
1da177e4 LT |
273 | { |
274 | *d = *s; | |
275 | } | |
276 | ||
9bb22e21 | 277 | static inline int snd_interval_setinteger(struct snd_interval *i) |
1da177e4 LT |
278 | { |
279 | if (i->integer) | |
280 | return 0; | |
281 | if (i->openmin && i->openmax && i->min == i->max) | |
282 | return -EINVAL; | |
283 | i->integer = 1; | |
284 | return 1; | |
285 | } | |
286 | ||
9bb22e21 | 287 | static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2) |
1da177e4 LT |
288 | { |
289 | if (i1->empty) | |
290 | return i2->empty; | |
291 | if (i2->empty) | |
292 | return i1->empty; | |
293 | return i1->min == i2->min && i1->openmin == i2->openmin && | |
294 | i1->max == i2->max && i1->openmax == i2->openmax; | |
295 | } | |
296 | ||
89827ca9 LPC |
297 | /** |
298 | * params_access - get the access type from the hw params | |
299 | * @p: hw params | |
300 | */ | |
744c2ad2 LPC |
301 | static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p) |
302 | { | |
303 | return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p, | |
304 | SNDRV_PCM_HW_PARAM_ACCESS)); | |
305 | } | |
306 | ||
89827ca9 LPC |
307 | /** |
308 | * params_format - get the sample format from the hw params | |
309 | * @p: hw params | |
310 | */ | |
744c2ad2 LPC |
311 | static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p) |
312 | { | |
313 | return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p, | |
314 | SNDRV_PCM_HW_PARAM_FORMAT)); | |
315 | } | |
316 | ||
89827ca9 LPC |
317 | /** |
318 | * params_subformat - get the sample subformat from the hw params | |
319 | * @p: hw params | |
320 | */ | |
744c2ad2 LPC |
321 | static inline snd_pcm_subformat_t |
322 | params_subformat(const struct snd_pcm_hw_params *p) | |
323 | { | |
324 | return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p, | |
325 | SNDRV_PCM_HW_PARAM_SUBFORMAT)); | |
326 | } | |
1da177e4 | 327 | |
89827ca9 LPC |
328 | /** |
329 | * params_period_bytes - get the period size (in bytes) from the hw params | |
330 | * @p: hw params | |
331 | */ | |
b51beb75 TI |
332 | static inline unsigned int |
333 | params_period_bytes(const struct snd_pcm_hw_params *p) | |
334 | { | |
cd9978f1 | 335 | return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min; |
b51beb75 TI |
336 | } |
337 | ||
89827ca9 LPC |
338 | /** |
339 | * params_width - get the number of bits of the sample format from the hw params | |
340 | * @p: hw params | |
341 | * | |
342 | * This function returns the number of bits per sample that the selected sample | |
343 | * format of the hw params has. | |
344 | */ | |
345 | static inline int params_width(const struct snd_pcm_hw_params *p) | |
8c5178fc MB |
346 | { |
347 | return snd_pcm_format_width(params_format(p)); | |
348 | } | |
349 | ||
89827ca9 LPC |
350 | /* |
351 | * params_physical_width - get the storage size of the sample format from the hw params | |
352 | * @p: hw params | |
353 | * | |
354 | * This functions returns the number of bits per sample that the selected sample | |
355 | * format of the hw params takes up in memory. This will be equal or larger than | |
356 | * params_width(). | |
357 | */ | |
358 | static inline int params_physical_width(const struct snd_pcm_hw_params *p) | |
8c5178fc MB |
359 | { |
360 | return snd_pcm_format_physical_width(params_format(p)); | |
361 | } | |
362 | ||
052a9f69 FY |
363 | static inline void |
364 | params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt) | |
365 | { | |
0b62834e | 366 | snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt); |
052a9f69 FY |
367 | } |
368 | ||
b51beb75 | 369 | #endif /* __SOUND_PCM_PARAMS_H */ |