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