2 * Digital Audio (PCM) abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Abramo Bagnara <abramo@alsa-project.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/slab.h>
24 #include <linux/sched/signal.h>
25 #include <linux/time.h>
26 #include <linux/math64.h>
27 #include <linux/export.h>
28 #include <sound/core.h>
29 #include <sound/control.h>
30 #include <sound/tlv.h>
31 #include <sound/info.h>
32 #include <sound/pcm.h>
33 #include <sound/pcm_params.h>
34 #include <sound/timer.h>
36 #include "pcm_local.h"
38 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
39 #define CREATE_TRACE_POINTS
40 #include "pcm_trace.h"
42 #define trace_hwptr(substream, pos, in_interrupt)
43 #define trace_xrun(substream)
44 #define trace_hw_ptr_error(substream, reason)
45 #define trace_applptr(substream, prev, curr)
48 static int fill_silence_frames(struct snd_pcm_substream
*substream
,
49 snd_pcm_uframes_t off
, snd_pcm_uframes_t frames
);
52 * fill ring buffer with silence
53 * runtime->silence_start: starting pointer to silence area
54 * runtime->silence_filled: size filled with silence
55 * runtime->silence_threshold: threshold from application
56 * runtime->silence_size: maximal size from application
58 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
60 void snd_pcm_playback_silence(struct snd_pcm_substream
*substream
, snd_pcm_uframes_t new_hw_ptr
)
62 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
63 snd_pcm_uframes_t frames
, ofs
, transfer
;
66 if (runtime
->silence_size
< runtime
->boundary
) {
67 snd_pcm_sframes_t noise_dist
, n
;
68 snd_pcm_uframes_t appl_ptr
= READ_ONCE(runtime
->control
->appl_ptr
);
69 if (runtime
->silence_start
!= appl_ptr
) {
70 n
= appl_ptr
- runtime
->silence_start
;
72 n
+= runtime
->boundary
;
73 if ((snd_pcm_uframes_t
)n
< runtime
->silence_filled
)
74 runtime
->silence_filled
-= n
;
76 runtime
->silence_filled
= 0;
77 runtime
->silence_start
= appl_ptr
;
79 if (runtime
->silence_filled
>= runtime
->buffer_size
)
81 noise_dist
= snd_pcm_playback_hw_avail(runtime
) + runtime
->silence_filled
;
82 if (noise_dist
>= (snd_pcm_sframes_t
) runtime
->silence_threshold
)
84 frames
= runtime
->silence_threshold
- noise_dist
;
85 if (frames
> runtime
->silence_size
)
86 frames
= runtime
->silence_size
;
88 if (new_hw_ptr
== ULONG_MAX
) { /* initialization */
89 snd_pcm_sframes_t avail
= snd_pcm_playback_hw_avail(runtime
);
90 if (avail
> runtime
->buffer_size
)
91 avail
= runtime
->buffer_size
;
92 runtime
->silence_filled
= avail
> 0 ? avail
: 0;
93 runtime
->silence_start
= (runtime
->status
->hw_ptr
+
94 runtime
->silence_filled
) %
97 ofs
= runtime
->status
->hw_ptr
;
98 frames
= new_hw_ptr
- ofs
;
99 if ((snd_pcm_sframes_t
)frames
< 0)
100 frames
+= runtime
->boundary
;
101 runtime
->silence_filled
-= frames
;
102 if ((snd_pcm_sframes_t
)runtime
->silence_filled
< 0) {
103 runtime
->silence_filled
= 0;
104 runtime
->silence_start
= new_hw_ptr
;
106 runtime
->silence_start
= ofs
;
109 frames
= runtime
->buffer_size
- runtime
->silence_filled
;
111 if (snd_BUG_ON(frames
> runtime
->buffer_size
))
115 ofs
= runtime
->silence_start
% runtime
->buffer_size
;
117 transfer
= ofs
+ frames
> runtime
->buffer_size
? runtime
->buffer_size
- ofs
: frames
;
118 err
= fill_silence_frames(substream
, ofs
, transfer
);
120 runtime
->silence_filled
+= transfer
;
126 #ifdef CONFIG_SND_DEBUG
127 void snd_pcm_debug_name(struct snd_pcm_substream
*substream
,
128 char *name
, size_t len
)
130 snprintf(name
, len
, "pcmC%dD%d%c:%d",
131 substream
->pcm
->card
->number
,
132 substream
->pcm
->device
,
133 substream
->stream
? 'c' : 'p',
136 EXPORT_SYMBOL(snd_pcm_debug_name
);
139 #define XRUN_DEBUG_BASIC (1<<0)
140 #define XRUN_DEBUG_STACK (1<<1) /* dump also stack */
141 #define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */
143 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
145 #define xrun_debug(substream, mask) \
146 ((substream)->pstr->xrun_debug & (mask))
148 #define xrun_debug(substream, mask) 0
151 #define dump_stack_on_xrun(substream) do { \
152 if (xrun_debug(substream, XRUN_DEBUG_STACK)) \
156 static void xrun(struct snd_pcm_substream
*substream
)
158 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
160 trace_xrun(substream
);
161 if (runtime
->tstamp_mode
== SNDRV_PCM_TSTAMP_ENABLE
)
162 snd_pcm_gettime(runtime
, (struct timespec
*)&runtime
->status
->tstamp
);
163 snd_pcm_stop(substream
, SNDRV_PCM_STATE_XRUN
);
164 if (xrun_debug(substream
, XRUN_DEBUG_BASIC
)) {
166 snd_pcm_debug_name(substream
, name
, sizeof(name
));
167 pcm_warn(substream
->pcm
, "XRUN: %s\n", name
);
168 dump_stack_on_xrun(substream
);
172 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
173 #define hw_ptr_error(substream, in_interrupt, reason, fmt, args...) \
175 trace_hw_ptr_error(substream, reason); \
176 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \
177 pr_err_ratelimited("ALSA: PCM: [%c] " reason ": " fmt, \
178 (in_interrupt) ? 'Q' : 'P', ##args); \
179 dump_stack_on_xrun(substream); \
183 #else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
185 #define hw_ptr_error(substream, fmt, args...) do { } while (0)
189 int snd_pcm_update_state(struct snd_pcm_substream
*substream
,
190 struct snd_pcm_runtime
*runtime
)
192 snd_pcm_uframes_t avail
;
194 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
195 avail
= snd_pcm_playback_avail(runtime
);
197 avail
= snd_pcm_capture_avail(runtime
);
198 if (avail
> runtime
->avail_max
)
199 runtime
->avail_max
= avail
;
200 if (runtime
->status
->state
== SNDRV_PCM_STATE_DRAINING
) {
201 if (avail
>= runtime
->buffer_size
) {
202 snd_pcm_drain_done(substream
);
206 if (avail
>= runtime
->stop_threshold
) {
211 if (runtime
->twake
) {
212 if (avail
>= runtime
->twake
)
213 wake_up(&runtime
->tsleep
);
214 } else if (avail
>= runtime
->control
->avail_min
)
215 wake_up(&runtime
->sleep
);
219 static void update_audio_tstamp(struct snd_pcm_substream
*substream
,
220 struct timespec
*curr_tstamp
,
221 struct timespec
*audio_tstamp
)
223 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
224 u64 audio_frames
, audio_nsecs
;
225 struct timespec driver_tstamp
;
227 if (runtime
->tstamp_mode
!= SNDRV_PCM_TSTAMP_ENABLE
)
230 if (!(substream
->ops
->get_time_info
) ||
231 (runtime
->audio_tstamp_report
.actual_type
==
232 SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT
)) {
235 * provide audio timestamp derived from pointer position
236 * add delay only if requested
239 audio_frames
= runtime
->hw_ptr_wrap
+ runtime
->status
->hw_ptr
;
241 if (runtime
->audio_tstamp_config
.report_delay
) {
242 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
243 audio_frames
-= runtime
->delay
;
245 audio_frames
+= runtime
->delay
;
247 audio_nsecs
= div_u64(audio_frames
* 1000000000LL,
249 *audio_tstamp
= ns_to_timespec(audio_nsecs
);
251 if (!timespec_equal(&runtime
->status
->audio_tstamp
, audio_tstamp
)) {
252 runtime
->status
->audio_tstamp
= *audio_tstamp
;
253 runtime
->status
->tstamp
= *curr_tstamp
;
257 * re-take a driver timestamp to let apps detect if the reference tstamp
258 * read by low-level hardware was provided with a delay
260 snd_pcm_gettime(substream
->runtime
, (struct timespec
*)&driver_tstamp
);
261 runtime
->driver_tstamp
= driver_tstamp
;
264 static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream
*substream
,
265 unsigned int in_interrupt
)
267 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
268 snd_pcm_uframes_t pos
;
269 snd_pcm_uframes_t old_hw_ptr
, new_hw_ptr
, hw_base
;
270 snd_pcm_sframes_t hdelta
, delta
;
271 unsigned long jdelta
;
272 unsigned long curr_jiffies
;
273 struct timespec curr_tstamp
;
274 struct timespec audio_tstamp
;
275 int crossed_boundary
= 0;
277 old_hw_ptr
= runtime
->status
->hw_ptr
;
280 * group pointer, time and jiffies reads to allow for more
281 * accurate correlations/corrections.
282 * The values are stored at the end of this routine after
283 * corrections for hw_ptr position
285 pos
= substream
->ops
->pointer(substream
);
286 curr_jiffies
= jiffies
;
287 if (runtime
->tstamp_mode
== SNDRV_PCM_TSTAMP_ENABLE
) {
288 if ((substream
->ops
->get_time_info
) &&
289 (runtime
->audio_tstamp_config
.type_requested
!= SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT
)) {
290 substream
->ops
->get_time_info(substream
, &curr_tstamp
,
292 &runtime
->audio_tstamp_config
,
293 &runtime
->audio_tstamp_report
);
295 /* re-test in case tstamp type is not supported in hardware and was demoted to DEFAULT */
296 if (runtime
->audio_tstamp_report
.actual_type
== SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT
)
297 snd_pcm_gettime(runtime
, (struct timespec
*)&curr_tstamp
);
299 snd_pcm_gettime(runtime
, (struct timespec
*)&curr_tstamp
);
302 if (pos
== SNDRV_PCM_POS_XRUN
) {
306 if (pos
>= runtime
->buffer_size
) {
307 if (printk_ratelimit()) {
309 snd_pcm_debug_name(substream
, name
, sizeof(name
));
310 pcm_err(substream
->pcm
,
311 "invalid position: %s, pos = %ld, buffer size = %ld, period size = %ld\n",
312 name
, pos
, runtime
->buffer_size
,
313 runtime
->period_size
);
317 pos
-= pos
% runtime
->min_align
;
318 trace_hwptr(substream
, pos
, in_interrupt
);
319 hw_base
= runtime
->hw_ptr_base
;
320 new_hw_ptr
= hw_base
+ pos
;
322 /* we know that one period was processed */
323 /* delta = "expected next hw_ptr" for in_interrupt != 0 */
324 delta
= runtime
->hw_ptr_interrupt
+ runtime
->period_size
;
325 if (delta
> new_hw_ptr
) {
326 /* check for double acknowledged interrupts */
327 hdelta
= curr_jiffies
- runtime
->hw_ptr_jiffies
;
328 if (hdelta
> runtime
->hw_ptr_buffer_jiffies
/2 + 1) {
329 hw_base
+= runtime
->buffer_size
;
330 if (hw_base
>= runtime
->boundary
) {
334 new_hw_ptr
= hw_base
+ pos
;
339 /* new_hw_ptr might be lower than old_hw_ptr in case when */
340 /* pointer crosses the end of the ring buffer */
341 if (new_hw_ptr
< old_hw_ptr
) {
342 hw_base
+= runtime
->buffer_size
;
343 if (hw_base
>= runtime
->boundary
) {
347 new_hw_ptr
= hw_base
+ pos
;
350 delta
= new_hw_ptr
- old_hw_ptr
;
352 delta
+= runtime
->boundary
;
354 if (runtime
->no_period_wakeup
) {
355 snd_pcm_sframes_t xrun_threshold
;
357 * Without regular period interrupts, we have to check
358 * the elapsed time to detect xruns.
360 jdelta
= curr_jiffies
- runtime
->hw_ptr_jiffies
;
361 if (jdelta
< runtime
->hw_ptr_buffer_jiffies
/ 2)
363 hdelta
= jdelta
- delta
* HZ
/ runtime
->rate
;
364 xrun_threshold
= runtime
->hw_ptr_buffer_jiffies
/ 2 + 1;
365 while (hdelta
> xrun_threshold
) {
366 delta
+= runtime
->buffer_size
;
367 hw_base
+= runtime
->buffer_size
;
368 if (hw_base
>= runtime
->boundary
) {
372 new_hw_ptr
= hw_base
+ pos
;
373 hdelta
-= runtime
->hw_ptr_buffer_jiffies
;
378 /* something must be really wrong */
379 if (delta
>= runtime
->buffer_size
+ runtime
->period_size
) {
380 hw_ptr_error(substream
, in_interrupt
, "Unexpected hw_ptr",
381 "(stream=%i, pos=%ld, new_hw_ptr=%ld, old_hw_ptr=%ld)\n",
382 substream
->stream
, (long)pos
,
383 (long)new_hw_ptr
, (long)old_hw_ptr
);
387 /* Do jiffies check only in xrun_debug mode */
388 if (!xrun_debug(substream
, XRUN_DEBUG_JIFFIESCHECK
))
389 goto no_jiffies_check
;
391 /* Skip the jiffies check for hardwares with BATCH flag.
392 * Such hardware usually just increases the position at each IRQ,
393 * thus it can't give any strange position.
395 if (runtime
->hw
.info
& SNDRV_PCM_INFO_BATCH
)
396 goto no_jiffies_check
;
398 if (hdelta
< runtime
->delay
)
399 goto no_jiffies_check
;
400 hdelta
-= runtime
->delay
;
401 jdelta
= curr_jiffies
- runtime
->hw_ptr_jiffies
;
402 if (((hdelta
* HZ
) / runtime
->rate
) > jdelta
+ HZ
/100) {
404 (((runtime
->period_size
* HZ
) / runtime
->rate
)
406 /* move new_hw_ptr according jiffies not pos variable */
407 new_hw_ptr
= old_hw_ptr
;
409 /* use loop to avoid checks for delta overflows */
410 /* the delta value is small or zero in most cases */
412 new_hw_ptr
+= runtime
->period_size
;
413 if (new_hw_ptr
>= runtime
->boundary
) {
414 new_hw_ptr
-= runtime
->boundary
;
419 /* align hw_base to buffer_size */
420 hw_ptr_error(substream
, in_interrupt
, "hw_ptr skipping",
421 "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
422 (long)pos
, (long)hdelta
,
423 (long)runtime
->period_size
, jdelta
,
424 ((hdelta
* HZ
) / runtime
->rate
), hw_base
,
425 (unsigned long)old_hw_ptr
,
426 (unsigned long)new_hw_ptr
);
427 /* reset values to proper state */
429 hw_base
= new_hw_ptr
- (new_hw_ptr
% runtime
->buffer_size
);
432 if (delta
> runtime
->period_size
+ runtime
->period_size
/ 2) {
433 hw_ptr_error(substream
, in_interrupt
,
435 "(stream=%i, delta=%ld, new_hw_ptr=%ld, old_hw_ptr=%ld)\n",
436 substream
->stream
, (long)delta
,
442 if (runtime
->status
->hw_ptr
== new_hw_ptr
) {
443 update_audio_tstamp(substream
, &curr_tstamp
, &audio_tstamp
);
447 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
&&
448 runtime
->silence_size
> 0)
449 snd_pcm_playback_silence(substream
, new_hw_ptr
);
452 delta
= new_hw_ptr
- runtime
->hw_ptr_interrupt
;
454 delta
+= runtime
->boundary
;
455 delta
-= (snd_pcm_uframes_t
)delta
% runtime
->period_size
;
456 runtime
->hw_ptr_interrupt
+= delta
;
457 if (runtime
->hw_ptr_interrupt
>= runtime
->boundary
)
458 runtime
->hw_ptr_interrupt
-= runtime
->boundary
;
460 runtime
->hw_ptr_base
= hw_base
;
461 runtime
->status
->hw_ptr
= new_hw_ptr
;
462 runtime
->hw_ptr_jiffies
= curr_jiffies
;
463 if (crossed_boundary
) {
464 snd_BUG_ON(crossed_boundary
!= 1);
465 runtime
->hw_ptr_wrap
+= runtime
->boundary
;
468 update_audio_tstamp(substream
, &curr_tstamp
, &audio_tstamp
);
470 return snd_pcm_update_state(substream
, runtime
);
473 /* CAUTION: call it with irq disabled */
474 int snd_pcm_update_hw_ptr(struct snd_pcm_substream
*substream
)
476 return snd_pcm_update_hw_ptr0(substream
, 0);
480 * snd_pcm_set_ops - set the PCM operators
481 * @pcm: the pcm instance
482 * @direction: stream direction, SNDRV_PCM_STREAM_XXX
483 * @ops: the operator table
485 * Sets the given PCM operators to the pcm instance.
487 void snd_pcm_set_ops(struct snd_pcm
*pcm
, int direction
,
488 const struct snd_pcm_ops
*ops
)
490 struct snd_pcm_str
*stream
= &pcm
->streams
[direction
];
491 struct snd_pcm_substream
*substream
;
493 for (substream
= stream
->substream
; substream
!= NULL
; substream
= substream
->next
)
494 substream
->ops
= ops
;
496 EXPORT_SYMBOL(snd_pcm_set_ops
);
499 * snd_pcm_sync - set the PCM sync id
500 * @substream: the pcm substream
502 * Sets the PCM sync identifier for the card.
504 void snd_pcm_set_sync(struct snd_pcm_substream
*substream
)
506 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
508 runtime
->sync
.id32
[0] = substream
->pcm
->card
->number
;
509 runtime
->sync
.id32
[1] = -1;
510 runtime
->sync
.id32
[2] = -1;
511 runtime
->sync
.id32
[3] = -1;
513 EXPORT_SYMBOL(snd_pcm_set_sync
);
516 * Standard ioctl routine
519 static inline unsigned int div32(unsigned int a
, unsigned int b
,
530 static inline unsigned int div_down(unsigned int a
, unsigned int b
)
537 static inline unsigned int div_up(unsigned int a
, unsigned int b
)
549 static inline unsigned int mul(unsigned int a
, unsigned int b
)
553 if (div_down(UINT_MAX
, a
) < b
)
558 static inline unsigned int muldiv32(unsigned int a
, unsigned int b
,
559 unsigned int c
, unsigned int *r
)
561 u_int64_t n
= (u_int64_t
) a
* b
;
566 n
= div_u64_rem(n
, c
, r
);
575 * snd_interval_refine - refine the interval value of configurator
576 * @i: the interval value to refine
577 * @v: the interval value to refer to
579 * Refines the interval value with the reference value.
580 * The interval is changed to the range satisfying both intervals.
581 * The interval status (min, max, integer, etc.) are evaluated.
583 * Return: Positive if the value is changed, zero if it's not changed, or a
584 * negative error code.
586 int snd_interval_refine(struct snd_interval
*i
, const struct snd_interval
*v
)
589 if (snd_BUG_ON(snd_interval_empty(i
)))
591 if (i
->min
< v
->min
) {
593 i
->openmin
= v
->openmin
;
595 } else if (i
->min
== v
->min
&& !i
->openmin
&& v
->openmin
) {
599 if (i
->max
> v
->max
) {
601 i
->openmax
= v
->openmax
;
603 } else if (i
->max
== v
->max
&& !i
->openmax
&& v
->openmax
) {
607 if (!i
->integer
&& v
->integer
) {
620 } else if (!i
->openmin
&& !i
->openmax
&& i
->min
== i
->max
)
622 if (snd_interval_checkempty(i
)) {
623 snd_interval_none(i
);
628 EXPORT_SYMBOL(snd_interval_refine
);
630 static int snd_interval_refine_first(struct snd_interval
*i
)
632 const unsigned int last_max
= i
->max
;
634 if (snd_BUG_ON(snd_interval_empty(i
)))
636 if (snd_interval_single(i
))
641 /* only exclude max value if also excluded before refine */
642 i
->openmax
= (i
->openmax
&& i
->max
>= last_max
);
646 static int snd_interval_refine_last(struct snd_interval
*i
)
648 const unsigned int last_min
= i
->min
;
650 if (snd_BUG_ON(snd_interval_empty(i
)))
652 if (snd_interval_single(i
))
657 /* only exclude min value if also excluded before refine */
658 i
->openmin
= (i
->openmin
&& i
->min
<= last_min
);
662 void snd_interval_mul(const struct snd_interval
*a
, const struct snd_interval
*b
, struct snd_interval
*c
)
664 if (a
->empty
|| b
->empty
) {
665 snd_interval_none(c
);
669 c
->min
= mul(a
->min
, b
->min
);
670 c
->openmin
= (a
->openmin
|| b
->openmin
);
671 c
->max
= mul(a
->max
, b
->max
);
672 c
->openmax
= (a
->openmax
|| b
->openmax
);
673 c
->integer
= (a
->integer
&& b
->integer
);
677 * snd_interval_div - refine the interval value with division
684 * Returns non-zero if the value is changed, zero if not changed.
686 void snd_interval_div(const struct snd_interval
*a
, const struct snd_interval
*b
, struct snd_interval
*c
)
689 if (a
->empty
|| b
->empty
) {
690 snd_interval_none(c
);
694 c
->min
= div32(a
->min
, b
->max
, &r
);
695 c
->openmin
= (r
|| a
->openmin
|| b
->openmax
);
697 c
->max
= div32(a
->max
, b
->min
, &r
);
702 c
->openmax
= (a
->openmax
|| b
->openmin
);
711 * snd_interval_muldivk - refine the interval value
714 * @k: divisor (as integer)
719 * Returns non-zero if the value is changed, zero if not changed.
721 void snd_interval_muldivk(const struct snd_interval
*a
, const struct snd_interval
*b
,
722 unsigned int k
, struct snd_interval
*c
)
725 if (a
->empty
|| b
->empty
) {
726 snd_interval_none(c
);
730 c
->min
= muldiv32(a
->min
, b
->min
, k
, &r
);
731 c
->openmin
= (r
|| a
->openmin
|| b
->openmin
);
732 c
->max
= muldiv32(a
->max
, b
->max
, k
, &r
);
737 c
->openmax
= (a
->openmax
|| b
->openmax
);
742 * snd_interval_mulkdiv - refine the interval value
744 * @k: dividend 2 (as integer)
750 * Returns non-zero if the value is changed, zero if not changed.
752 void snd_interval_mulkdiv(const struct snd_interval
*a
, unsigned int k
,
753 const struct snd_interval
*b
, struct snd_interval
*c
)
756 if (a
->empty
|| b
->empty
) {
757 snd_interval_none(c
);
761 c
->min
= muldiv32(a
->min
, k
, b
->max
, &r
);
762 c
->openmin
= (r
|| a
->openmin
|| b
->openmax
);
764 c
->max
= muldiv32(a
->max
, k
, b
->min
, &r
);
769 c
->openmax
= (a
->openmax
|| b
->openmin
);
781 * snd_interval_ratnum - refine the interval value
782 * @i: interval to refine
783 * @rats_count: number of ratnum_t
784 * @rats: ratnum_t array
785 * @nump: pointer to store the resultant numerator
786 * @denp: pointer to store the resultant denominator
788 * Return: Positive if the value is changed, zero if it's not changed, or a
789 * negative error code.
791 int snd_interval_ratnum(struct snd_interval
*i
,
792 unsigned int rats_count
, const struct snd_ratnum
*rats
,
793 unsigned int *nump
, unsigned int *denp
)
795 unsigned int best_num
, best_den
;
798 struct snd_interval t
;
800 unsigned int result_num
, result_den
;
803 best_num
= best_den
= best_diff
= 0;
804 for (k
= 0; k
< rats_count
; ++k
) {
805 unsigned int num
= rats
[k
].num
;
807 unsigned int q
= i
->min
;
811 den
= div_up(num
, q
);
812 if (den
< rats
[k
].den_min
)
814 if (den
> rats
[k
].den_max
)
815 den
= rats
[k
].den_max
;
818 r
= (den
- rats
[k
].den_min
) % rats
[k
].den_step
;
822 diff
= num
- q
* den
;
826 diff
* best_den
< best_diff
* den
) {
836 t
.min
= div_down(best_num
, best_den
);
837 t
.openmin
= !!(best_num
% best_den
);
839 result_num
= best_num
;
840 result_diff
= best_diff
;
841 result_den
= best_den
;
842 best_num
= best_den
= best_diff
= 0;
843 for (k
= 0; k
< rats_count
; ++k
) {
844 unsigned int num
= rats
[k
].num
;
846 unsigned int q
= i
->max
;
852 den
= div_down(num
, q
);
853 if (den
> rats
[k
].den_max
)
855 if (den
< rats
[k
].den_min
)
856 den
= rats
[k
].den_min
;
859 r
= (den
- rats
[k
].den_min
) % rats
[k
].den_step
;
861 den
+= rats
[k
].den_step
- r
;
863 diff
= q
* den
- num
;
867 diff
* best_den
< best_diff
* den
) {
877 t
.max
= div_up(best_num
, best_den
);
878 t
.openmax
= !!(best_num
% best_den
);
880 err
= snd_interval_refine(i
, &t
);
884 if (snd_interval_single(i
)) {
885 if (best_diff
* result_den
< result_diff
* best_den
) {
886 result_num
= best_num
;
887 result_den
= best_den
;
896 EXPORT_SYMBOL(snd_interval_ratnum
);
899 * snd_interval_ratden - refine the interval value
900 * @i: interval to refine
901 * @rats_count: number of struct ratden
902 * @rats: struct ratden array
903 * @nump: pointer to store the resultant numerator
904 * @denp: pointer to store the resultant denominator
906 * Return: Positive if the value is changed, zero if it's not changed, or a
907 * negative error code.
909 static int snd_interval_ratden(struct snd_interval
*i
,
910 unsigned int rats_count
,
911 const struct snd_ratden
*rats
,
912 unsigned int *nump
, unsigned int *denp
)
914 unsigned int best_num
, best_diff
, best_den
;
916 struct snd_interval t
;
919 best_num
= best_den
= best_diff
= 0;
920 for (k
= 0; k
< rats_count
; ++k
) {
922 unsigned int den
= rats
[k
].den
;
923 unsigned int q
= i
->min
;
926 if (num
> rats
[k
].num_max
)
928 if (num
< rats
[k
].num_min
)
929 num
= rats
[k
].num_max
;
932 r
= (num
- rats
[k
].num_min
) % rats
[k
].num_step
;
934 num
+= rats
[k
].num_step
- r
;
936 diff
= num
- q
* den
;
938 diff
* best_den
< best_diff
* den
) {
948 t
.min
= div_down(best_num
, best_den
);
949 t
.openmin
= !!(best_num
% best_den
);
951 best_num
= best_den
= best_diff
= 0;
952 for (k
= 0; k
< rats_count
; ++k
) {
954 unsigned int den
= rats
[k
].den
;
955 unsigned int q
= i
->max
;
958 if (num
< rats
[k
].num_min
)
960 if (num
> rats
[k
].num_max
)
961 num
= rats
[k
].num_max
;
964 r
= (num
- rats
[k
].num_min
) % rats
[k
].num_step
;
968 diff
= q
* den
- num
;
970 diff
* best_den
< best_diff
* den
) {
980 t
.max
= div_up(best_num
, best_den
);
981 t
.openmax
= !!(best_num
% best_den
);
983 err
= snd_interval_refine(i
, &t
);
987 if (snd_interval_single(i
)) {
997 * snd_interval_list - refine the interval value from the list
998 * @i: the interval value to refine
999 * @count: the number of elements in the list
1000 * @list: the value list
1001 * @mask: the bit-mask to evaluate
1003 * Refines the interval value from the list.
1004 * When mask is non-zero, only the elements corresponding to bit 1 are
1007 * Return: Positive if the value is changed, zero if it's not changed, or a
1008 * negative error code.
1010 int snd_interval_list(struct snd_interval
*i
, unsigned int count
,
1011 const unsigned int *list
, unsigned int mask
)
1014 struct snd_interval list_range
;
1020 snd_interval_any(&list_range
);
1021 list_range
.min
= UINT_MAX
;
1023 for (k
= 0; k
< count
; k
++) {
1024 if (mask
&& !(mask
& (1 << k
)))
1026 if (!snd_interval_test(i
, list
[k
]))
1028 list_range
.min
= min(list_range
.min
, list
[k
]);
1029 list_range
.max
= max(list_range
.max
, list
[k
]);
1031 return snd_interval_refine(i
, &list_range
);
1033 EXPORT_SYMBOL(snd_interval_list
);
1036 * snd_interval_ranges - refine the interval value from the list of ranges
1037 * @i: the interval value to refine
1038 * @count: the number of elements in the list of ranges
1039 * @ranges: the ranges list
1040 * @mask: the bit-mask to evaluate
1042 * Refines the interval value from the list of ranges.
1043 * When mask is non-zero, only the elements corresponding to bit 1 are
1046 * Return: Positive if the value is changed, zero if it's not changed, or a
1047 * negative error code.
1049 int snd_interval_ranges(struct snd_interval
*i
, unsigned int count
,
1050 const struct snd_interval
*ranges
, unsigned int mask
)
1053 struct snd_interval range_union
;
1054 struct snd_interval range
;
1057 snd_interval_none(i
);
1060 snd_interval_any(&range_union
);
1061 range_union
.min
= UINT_MAX
;
1062 range_union
.max
= 0;
1063 for (k
= 0; k
< count
; k
++) {
1064 if (mask
&& !(mask
& (1 << k
)))
1066 snd_interval_copy(&range
, &ranges
[k
]);
1067 if (snd_interval_refine(&range
, i
) < 0)
1069 if (snd_interval_empty(&range
))
1072 if (range
.min
< range_union
.min
) {
1073 range_union
.min
= range
.min
;
1074 range_union
.openmin
= 1;
1076 if (range
.min
== range_union
.min
&& !range
.openmin
)
1077 range_union
.openmin
= 0;
1078 if (range
.max
> range_union
.max
) {
1079 range_union
.max
= range
.max
;
1080 range_union
.openmax
= 1;
1082 if (range
.max
== range_union
.max
&& !range
.openmax
)
1083 range_union
.openmax
= 0;
1085 return snd_interval_refine(i
, &range_union
);
1087 EXPORT_SYMBOL(snd_interval_ranges
);
1089 static int snd_interval_step(struct snd_interval
*i
, unsigned int step
)
1094 if (n
!= 0 || i
->openmin
) {
1100 if (n
!= 0 || i
->openmax
) {
1105 if (snd_interval_checkempty(i
)) {
1112 /* Info constraints helpers */
1115 * snd_pcm_hw_rule_add - add the hw-constraint rule
1116 * @runtime: the pcm runtime instance
1117 * @cond: condition bits
1118 * @var: the variable to evaluate
1119 * @func: the evaluation function
1120 * @private: the private data pointer passed to function
1121 * @dep: the dependent variables
1123 * Return: Zero if successful, or a negative error code on failure.
1125 int snd_pcm_hw_rule_add(struct snd_pcm_runtime
*runtime
, unsigned int cond
,
1127 snd_pcm_hw_rule_func_t func
, void *private,
1130 struct snd_pcm_hw_constraints
*constrs
= &runtime
->hw_constraints
;
1131 struct snd_pcm_hw_rule
*c
;
1134 va_start(args
, dep
);
1135 if (constrs
->rules_num
>= constrs
->rules_all
) {
1136 struct snd_pcm_hw_rule
*new;
1137 unsigned int new_rules
= constrs
->rules_all
+ 16;
1138 new = kcalloc(new_rules
, sizeof(*c
), GFP_KERNEL
);
1143 if (constrs
->rules
) {
1144 memcpy(new, constrs
->rules
,
1145 constrs
->rules_num
* sizeof(*c
));
1146 kfree(constrs
->rules
);
1148 constrs
->rules
= new;
1149 constrs
->rules_all
= new_rules
;
1151 c
= &constrs
->rules
[constrs
->rules_num
];
1155 c
->private = private;
1158 if (snd_BUG_ON(k
>= ARRAY_SIZE(c
->deps
))) {
1165 dep
= va_arg(args
, int);
1167 constrs
->rules_num
++;
1171 EXPORT_SYMBOL(snd_pcm_hw_rule_add
);
1174 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
1175 * @runtime: PCM runtime instance
1176 * @var: hw_params variable to apply the mask
1177 * @mask: the bitmap mask
1179 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
1181 * Return: Zero if successful, or a negative error code on failure.
1183 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime
*runtime
, snd_pcm_hw_param_t var
,
1186 struct snd_pcm_hw_constraints
*constrs
= &runtime
->hw_constraints
;
1187 struct snd_mask
*maskp
= constrs_mask(constrs
, var
);
1188 *maskp
->bits
&= mask
;
1189 memset(maskp
->bits
+ 1, 0, (SNDRV_MASK_MAX
-32) / 8); /* clear rest */
1190 if (*maskp
->bits
== 0)
1196 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
1197 * @runtime: PCM runtime instance
1198 * @var: hw_params variable to apply the mask
1199 * @mask: the 64bit bitmap mask
1201 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
1203 * Return: Zero if successful, or a negative error code on failure.
1205 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime
*runtime
, snd_pcm_hw_param_t var
,
1208 struct snd_pcm_hw_constraints
*constrs
= &runtime
->hw_constraints
;
1209 struct snd_mask
*maskp
= constrs_mask(constrs
, var
);
1210 maskp
->bits
[0] &= (u_int32_t
)mask
;
1211 maskp
->bits
[1] &= (u_int32_t
)(mask
>> 32);
1212 memset(maskp
->bits
+ 2, 0, (SNDRV_MASK_MAX
-64) / 8); /* clear rest */
1213 if (! maskp
->bits
[0] && ! maskp
->bits
[1])
1217 EXPORT_SYMBOL(snd_pcm_hw_constraint_mask64
);
1220 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
1221 * @runtime: PCM runtime instance
1222 * @var: hw_params variable to apply the integer constraint
1224 * Apply the constraint of integer to an interval parameter.
1226 * Return: Positive if the value is changed, zero if it's not changed, or a
1227 * negative error code.
1229 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime
*runtime
, snd_pcm_hw_param_t var
)
1231 struct snd_pcm_hw_constraints
*constrs
= &runtime
->hw_constraints
;
1232 return snd_interval_setinteger(constrs_interval(constrs
, var
));
1234 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer
);
1237 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
1238 * @runtime: PCM runtime instance
1239 * @var: hw_params variable to apply the range
1240 * @min: the minimal value
1241 * @max: the maximal value
1243 * Apply the min/max range constraint to an interval parameter.
1245 * Return: Positive if the value is changed, zero if it's not changed, or a
1246 * negative error code.
1248 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime
*runtime
, snd_pcm_hw_param_t var
,
1249 unsigned int min
, unsigned int max
)
1251 struct snd_pcm_hw_constraints
*constrs
= &runtime
->hw_constraints
;
1252 struct snd_interval t
;
1255 t
.openmin
= t
.openmax
= 0;
1257 return snd_interval_refine(constrs_interval(constrs
, var
), &t
);
1259 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax
);
1261 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params
*params
,
1262 struct snd_pcm_hw_rule
*rule
)
1264 struct snd_pcm_hw_constraint_list
*list
= rule
->private;
1265 return snd_interval_list(hw_param_interval(params
, rule
->var
), list
->count
, list
->list
, list
->mask
);
1270 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
1271 * @runtime: PCM runtime instance
1272 * @cond: condition bits
1273 * @var: hw_params variable to apply the list constraint
1276 * Apply the list of constraints to an interval parameter.
1278 * Return: Zero if successful, or a negative error code on failure.
1280 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime
*runtime
,
1282 snd_pcm_hw_param_t var
,
1283 const struct snd_pcm_hw_constraint_list
*l
)
1285 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1286 snd_pcm_hw_rule_list
, (void *)l
,
1289 EXPORT_SYMBOL(snd_pcm_hw_constraint_list
);
1291 static int snd_pcm_hw_rule_ranges(struct snd_pcm_hw_params
*params
,
1292 struct snd_pcm_hw_rule
*rule
)
1294 struct snd_pcm_hw_constraint_ranges
*r
= rule
->private;
1295 return snd_interval_ranges(hw_param_interval(params
, rule
->var
),
1296 r
->count
, r
->ranges
, r
->mask
);
1301 * snd_pcm_hw_constraint_ranges - apply list of range constraints to a parameter
1302 * @runtime: PCM runtime instance
1303 * @cond: condition bits
1304 * @var: hw_params variable to apply the list of range constraints
1307 * Apply the list of range constraints to an interval parameter.
1309 * Return: Zero if successful, or a negative error code on failure.
1311 int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime
*runtime
,
1313 snd_pcm_hw_param_t var
,
1314 const struct snd_pcm_hw_constraint_ranges
*r
)
1316 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1317 snd_pcm_hw_rule_ranges
, (void *)r
,
1320 EXPORT_SYMBOL(snd_pcm_hw_constraint_ranges
);
1322 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params
*params
,
1323 struct snd_pcm_hw_rule
*rule
)
1325 const struct snd_pcm_hw_constraint_ratnums
*r
= rule
->private;
1326 unsigned int num
= 0, den
= 0;
1328 err
= snd_interval_ratnum(hw_param_interval(params
, rule
->var
),
1329 r
->nrats
, r
->rats
, &num
, &den
);
1330 if (err
>= 0 && den
&& rule
->var
== SNDRV_PCM_HW_PARAM_RATE
) {
1331 params
->rate_num
= num
;
1332 params
->rate_den
= den
;
1338 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
1339 * @runtime: PCM runtime instance
1340 * @cond: condition bits
1341 * @var: hw_params variable to apply the ratnums constraint
1342 * @r: struct snd_ratnums constriants
1344 * Return: Zero if successful, or a negative error code on failure.
1346 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime
*runtime
,
1348 snd_pcm_hw_param_t var
,
1349 const struct snd_pcm_hw_constraint_ratnums
*r
)
1351 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1352 snd_pcm_hw_rule_ratnums
, (void *)r
,
1355 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums
);
1357 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params
*params
,
1358 struct snd_pcm_hw_rule
*rule
)
1360 const struct snd_pcm_hw_constraint_ratdens
*r
= rule
->private;
1361 unsigned int num
= 0, den
= 0;
1362 int err
= snd_interval_ratden(hw_param_interval(params
, rule
->var
),
1363 r
->nrats
, r
->rats
, &num
, &den
);
1364 if (err
>= 0 && den
&& rule
->var
== SNDRV_PCM_HW_PARAM_RATE
) {
1365 params
->rate_num
= num
;
1366 params
->rate_den
= den
;
1372 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
1373 * @runtime: PCM runtime instance
1374 * @cond: condition bits
1375 * @var: hw_params variable to apply the ratdens constraint
1376 * @r: struct snd_ratdens constriants
1378 * Return: Zero if successful, or a negative error code on failure.
1380 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime
*runtime
,
1382 snd_pcm_hw_param_t var
,
1383 const struct snd_pcm_hw_constraint_ratdens
*r
)
1385 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1386 snd_pcm_hw_rule_ratdens
, (void *)r
,
1389 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens
);
1391 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params
*params
,
1392 struct snd_pcm_hw_rule
*rule
)
1394 unsigned int l
= (unsigned long) rule
->private;
1395 int width
= l
& 0xffff;
1396 unsigned int msbits
= l
>> 16;
1397 const struct snd_interval
*i
=
1398 hw_param_interval_c(params
, SNDRV_PCM_HW_PARAM_SAMPLE_BITS
);
1400 if (!snd_interval_single(i
))
1403 if ((snd_interval_value(i
) == width
) ||
1404 (width
== 0 && snd_interval_value(i
) > msbits
))
1405 params
->msbits
= min_not_zero(params
->msbits
, msbits
);
1411 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
1412 * @runtime: PCM runtime instance
1413 * @cond: condition bits
1414 * @width: sample bits width
1415 * @msbits: msbits width
1417 * This constraint will set the number of most significant bits (msbits) if a
1418 * sample format with the specified width has been select. If width is set to 0
1419 * the msbits will be set for any sample format with a width larger than the
1422 * Return: Zero if successful, or a negative error code on failure.
1424 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime
*runtime
,
1427 unsigned int msbits
)
1429 unsigned long l
= (msbits
<< 16) | width
;
1430 return snd_pcm_hw_rule_add(runtime
, cond
, -1,
1431 snd_pcm_hw_rule_msbits
,
1433 SNDRV_PCM_HW_PARAM_SAMPLE_BITS
, -1);
1435 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits
);
1437 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params
*params
,
1438 struct snd_pcm_hw_rule
*rule
)
1440 unsigned long step
= (unsigned long) rule
->private;
1441 return snd_interval_step(hw_param_interval(params
, rule
->var
), step
);
1445 * snd_pcm_hw_constraint_step - add a hw constraint step rule
1446 * @runtime: PCM runtime instance
1447 * @cond: condition bits
1448 * @var: hw_params variable to apply the step constraint
1451 * Return: Zero if successful, or a negative error code on failure.
1453 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime
*runtime
,
1455 snd_pcm_hw_param_t var
,
1458 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1459 snd_pcm_hw_rule_step
, (void *) step
,
1462 EXPORT_SYMBOL(snd_pcm_hw_constraint_step
);
1464 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params
*params
, struct snd_pcm_hw_rule
*rule
)
1466 static unsigned int pow2_sizes
[] = {
1467 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1468 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1469 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1470 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1472 return snd_interval_list(hw_param_interval(params
, rule
->var
),
1473 ARRAY_SIZE(pow2_sizes
), pow2_sizes
, 0);
1477 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
1478 * @runtime: PCM runtime instance
1479 * @cond: condition bits
1480 * @var: hw_params variable to apply the power-of-2 constraint
1482 * Return: Zero if successful, or a negative error code on failure.
1484 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime
*runtime
,
1486 snd_pcm_hw_param_t var
)
1488 return snd_pcm_hw_rule_add(runtime
, cond
, var
,
1489 snd_pcm_hw_rule_pow2
, NULL
,
1492 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2
);
1494 static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params
*params
,
1495 struct snd_pcm_hw_rule
*rule
)
1497 unsigned int base_rate
= (unsigned int)(uintptr_t)rule
->private;
1498 struct snd_interval
*rate
;
1500 rate
= hw_param_interval(params
, SNDRV_PCM_HW_PARAM_RATE
);
1501 return snd_interval_list(rate
, 1, &base_rate
, 0);
1505 * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
1506 * @runtime: PCM runtime instance
1507 * @base_rate: the rate at which the hardware does not resample
1509 * Return: Zero if successful, or a negative error code on failure.
1511 int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime
*runtime
,
1512 unsigned int base_rate
)
1514 return snd_pcm_hw_rule_add(runtime
, SNDRV_PCM_HW_PARAMS_NORESAMPLE
,
1515 SNDRV_PCM_HW_PARAM_RATE
,
1516 snd_pcm_hw_rule_noresample_func
,
1517 (void *)(uintptr_t)base_rate
,
1518 SNDRV_PCM_HW_PARAM_RATE
, -1);
1520 EXPORT_SYMBOL(snd_pcm_hw_rule_noresample
);
1522 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params
*params
,
1523 snd_pcm_hw_param_t var
)
1525 if (hw_is_mask(var
)) {
1526 snd_mask_any(hw_param_mask(params
, var
));
1527 params
->cmask
|= 1 << var
;
1528 params
->rmask
|= 1 << var
;
1531 if (hw_is_interval(var
)) {
1532 snd_interval_any(hw_param_interval(params
, var
));
1533 params
->cmask
|= 1 << var
;
1534 params
->rmask
|= 1 << var
;
1540 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params
*params
)
1543 memset(params
, 0, sizeof(*params
));
1544 for (k
= SNDRV_PCM_HW_PARAM_FIRST_MASK
; k
<= SNDRV_PCM_HW_PARAM_LAST_MASK
; k
++)
1545 _snd_pcm_hw_param_any(params
, k
);
1546 for (k
= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
; k
<= SNDRV_PCM_HW_PARAM_LAST_INTERVAL
; k
++)
1547 _snd_pcm_hw_param_any(params
, k
);
1550 EXPORT_SYMBOL(_snd_pcm_hw_params_any
);
1553 * snd_pcm_hw_param_value - return @params field @var value
1554 * @params: the hw_params instance
1555 * @var: parameter to retrieve
1556 * @dir: pointer to the direction (-1,0,1) or %NULL
1558 * Return: The value for field @var if it's fixed in configuration space
1559 * defined by @params. -%EINVAL otherwise.
1561 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params
*params
,
1562 snd_pcm_hw_param_t var
, int *dir
)
1564 if (hw_is_mask(var
)) {
1565 const struct snd_mask
*mask
= hw_param_mask_c(params
, var
);
1566 if (!snd_mask_single(mask
))
1570 return snd_mask_value(mask
);
1572 if (hw_is_interval(var
)) {
1573 const struct snd_interval
*i
= hw_param_interval_c(params
, var
);
1574 if (!snd_interval_single(i
))
1578 return snd_interval_value(i
);
1582 EXPORT_SYMBOL(snd_pcm_hw_param_value
);
1584 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params
*params
,
1585 snd_pcm_hw_param_t var
)
1587 if (hw_is_mask(var
)) {
1588 snd_mask_none(hw_param_mask(params
, var
));
1589 params
->cmask
|= 1 << var
;
1590 params
->rmask
|= 1 << var
;
1591 } else if (hw_is_interval(var
)) {
1592 snd_interval_none(hw_param_interval(params
, var
));
1593 params
->cmask
|= 1 << var
;
1594 params
->rmask
|= 1 << var
;
1599 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty
);
1601 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params
*params
,
1602 snd_pcm_hw_param_t var
)
1605 if (hw_is_mask(var
))
1606 changed
= snd_mask_refine_first(hw_param_mask(params
, var
));
1607 else if (hw_is_interval(var
))
1608 changed
= snd_interval_refine_first(hw_param_interval(params
, var
));
1612 params
->cmask
|= 1 << var
;
1613 params
->rmask
|= 1 << var
;
1620 * snd_pcm_hw_param_first - refine config space and return minimum value
1621 * @pcm: PCM instance
1622 * @params: the hw_params instance
1623 * @var: parameter to retrieve
1624 * @dir: pointer to the direction (-1,0,1) or %NULL
1626 * Inside configuration space defined by @params remove from @var all
1627 * values > minimum. Reduce configuration space accordingly.
1629 * Return: The minimum, or a negative error code on failure.
1631 int snd_pcm_hw_param_first(struct snd_pcm_substream
*pcm
,
1632 struct snd_pcm_hw_params
*params
,
1633 snd_pcm_hw_param_t var
, int *dir
)
1635 int changed
= _snd_pcm_hw_param_first(params
, var
);
1638 if (params
->rmask
) {
1639 int err
= snd_pcm_hw_refine(pcm
, params
);
1643 return snd_pcm_hw_param_value(params
, var
, dir
);
1645 EXPORT_SYMBOL(snd_pcm_hw_param_first
);
1647 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params
*params
,
1648 snd_pcm_hw_param_t var
)
1651 if (hw_is_mask(var
))
1652 changed
= snd_mask_refine_last(hw_param_mask(params
, var
));
1653 else if (hw_is_interval(var
))
1654 changed
= snd_interval_refine_last(hw_param_interval(params
, var
));
1658 params
->cmask
|= 1 << var
;
1659 params
->rmask
|= 1 << var
;
1666 * snd_pcm_hw_param_last - refine config space and return maximum value
1667 * @pcm: PCM instance
1668 * @params: the hw_params instance
1669 * @var: parameter to retrieve
1670 * @dir: pointer to the direction (-1,0,1) or %NULL
1672 * Inside configuration space defined by @params remove from @var all
1673 * values < maximum. Reduce configuration space accordingly.
1675 * Return: The maximum, or a negative error code on failure.
1677 int snd_pcm_hw_param_last(struct snd_pcm_substream
*pcm
,
1678 struct snd_pcm_hw_params
*params
,
1679 snd_pcm_hw_param_t var
, int *dir
)
1681 int changed
= _snd_pcm_hw_param_last(params
, var
);
1684 if (params
->rmask
) {
1685 int err
= snd_pcm_hw_refine(pcm
, params
);
1689 return snd_pcm_hw_param_value(params
, var
, dir
);
1691 EXPORT_SYMBOL(snd_pcm_hw_param_last
);
1693 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream
*substream
,
1696 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1697 unsigned long flags
;
1698 snd_pcm_stream_lock_irqsave(substream
, flags
);
1699 if (snd_pcm_running(substream
) &&
1700 snd_pcm_update_hw_ptr(substream
) >= 0)
1701 runtime
->status
->hw_ptr
%= runtime
->buffer_size
;
1703 runtime
->status
->hw_ptr
= 0;
1704 runtime
->hw_ptr_wrap
= 0;
1706 snd_pcm_stream_unlock_irqrestore(substream
, flags
);
1710 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream
*substream
,
1713 struct snd_pcm_channel_info
*info
= arg
;
1714 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1716 if (!(runtime
->info
& SNDRV_PCM_INFO_MMAP
)) {
1720 width
= snd_pcm_format_physical_width(runtime
->format
);
1724 switch (runtime
->access
) {
1725 case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
:
1726 case SNDRV_PCM_ACCESS_RW_INTERLEAVED
:
1727 info
->first
= info
->channel
* width
;
1728 info
->step
= runtime
->channels
* width
;
1730 case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED
:
1731 case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
:
1733 size_t size
= runtime
->dma_bytes
/ runtime
->channels
;
1734 info
->first
= info
->channel
* size
* 8;
1745 static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream
*substream
,
1748 struct snd_pcm_hw_params
*params
= arg
;
1749 snd_pcm_format_t format
;
1753 params
->fifo_size
= substream
->runtime
->hw
.fifo_size
;
1754 if (!(substream
->runtime
->hw
.info
& SNDRV_PCM_INFO_FIFO_IN_FRAMES
)) {
1755 format
= params_format(params
);
1756 channels
= params_channels(params
);
1757 frame_size
= snd_pcm_format_size(format
, channels
);
1759 params
->fifo_size
/= (unsigned)frame_size
;
1765 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1766 * @substream: the pcm substream instance
1767 * @cmd: ioctl command
1768 * @arg: ioctl argument
1770 * Processes the generic ioctl commands for PCM.
1771 * Can be passed as the ioctl callback for PCM ops.
1773 * Return: Zero if successful, or a negative error code on failure.
1775 int snd_pcm_lib_ioctl(struct snd_pcm_substream
*substream
,
1776 unsigned int cmd
, void *arg
)
1779 case SNDRV_PCM_IOCTL1_RESET
:
1780 return snd_pcm_lib_ioctl_reset(substream
, arg
);
1781 case SNDRV_PCM_IOCTL1_CHANNEL_INFO
:
1782 return snd_pcm_lib_ioctl_channel_info(substream
, arg
);
1783 case SNDRV_PCM_IOCTL1_FIFO_SIZE
:
1784 return snd_pcm_lib_ioctl_fifo_size(substream
, arg
);
1788 EXPORT_SYMBOL(snd_pcm_lib_ioctl
);
1791 * snd_pcm_period_elapsed - update the pcm status for the next period
1792 * @substream: the pcm substream instance
1794 * This function is called from the interrupt handler when the
1795 * PCM has processed the period size. It will update the current
1796 * pointer, wake up sleepers, etc.
1798 * Even if more than one periods have elapsed since the last call, you
1799 * have to call this only once.
1801 void snd_pcm_period_elapsed(struct snd_pcm_substream
*substream
)
1803 struct snd_pcm_runtime
*runtime
;
1804 unsigned long flags
;
1806 if (PCM_RUNTIME_CHECK(substream
))
1808 runtime
= substream
->runtime
;
1810 snd_pcm_stream_lock_irqsave(substream
, flags
);
1811 if (!snd_pcm_running(substream
) ||
1812 snd_pcm_update_hw_ptr0(substream
, 1) < 0)
1815 #ifdef CONFIG_SND_PCM_TIMER
1816 if (substream
->timer_running
)
1817 snd_timer_interrupt(substream
->timer
, 1);
1820 kill_fasync(&runtime
->fasync
, SIGIO
, POLL_IN
);
1821 snd_pcm_stream_unlock_irqrestore(substream
, flags
);
1823 EXPORT_SYMBOL(snd_pcm_period_elapsed
);
1826 * Wait until avail_min data becomes available
1827 * Returns a negative error code if any error occurs during operation.
1828 * The available space is stored on availp. When err = 0 and avail = 0
1829 * on the capture stream, it indicates the stream is in DRAINING state.
1831 static int wait_for_avail(struct snd_pcm_substream
*substream
,
1832 snd_pcm_uframes_t
*availp
)
1834 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1835 int is_playback
= substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
;
1836 wait_queue_entry_t wait
;
1838 snd_pcm_uframes_t avail
= 0;
1839 long wait_time
, tout
;
1841 init_waitqueue_entry(&wait
, current
);
1842 set_current_state(TASK_INTERRUPTIBLE
);
1843 add_wait_queue(&runtime
->tsleep
, &wait
);
1845 if (runtime
->no_period_wakeup
)
1846 wait_time
= MAX_SCHEDULE_TIMEOUT
;
1849 if (runtime
->rate
) {
1850 long t
= runtime
->period_size
* 2 / runtime
->rate
;
1851 wait_time
= max(t
, wait_time
);
1853 wait_time
= msecs_to_jiffies(wait_time
* 1000);
1857 if (signal_pending(current
)) {
1863 * We need to check if space became available already
1864 * (and thus the wakeup happened already) first to close
1865 * the race of space already having become available.
1866 * This check must happen after been added to the waitqueue
1867 * and having current state be INTERRUPTIBLE.
1870 avail
= snd_pcm_playback_avail(runtime
);
1872 avail
= snd_pcm_capture_avail(runtime
);
1873 if (avail
>= runtime
->twake
)
1875 snd_pcm_stream_unlock_irq(substream
);
1877 tout
= schedule_timeout(wait_time
);
1879 snd_pcm_stream_lock_irq(substream
);
1880 set_current_state(TASK_INTERRUPTIBLE
);
1881 switch (runtime
->status
->state
) {
1882 case SNDRV_PCM_STATE_SUSPENDED
:
1885 case SNDRV_PCM_STATE_XRUN
:
1888 case SNDRV_PCM_STATE_DRAINING
:
1892 avail
= 0; /* indicate draining */
1894 case SNDRV_PCM_STATE_OPEN
:
1895 case SNDRV_PCM_STATE_SETUP
:
1896 case SNDRV_PCM_STATE_DISCONNECTED
:
1899 case SNDRV_PCM_STATE_PAUSED
:
1903 pcm_dbg(substream
->pcm
,
1904 "%s write error (DMA or IRQ trouble?)\n",
1905 is_playback
? "playback" : "capture");
1911 set_current_state(TASK_RUNNING
);
1912 remove_wait_queue(&runtime
->tsleep
, &wait
);
1917 typedef int (*pcm_transfer_f
)(struct snd_pcm_substream
*substream
,
1918 int channel
, unsigned long hwoff
,
1919 void *buf
, unsigned long bytes
);
1921 typedef int (*pcm_copy_f
)(struct snd_pcm_substream
*, snd_pcm_uframes_t
, void *,
1922 snd_pcm_uframes_t
, snd_pcm_uframes_t
, pcm_transfer_f
);
1924 /* calculate the target DMA-buffer position to be written/read */
1925 static void *get_dma_ptr(struct snd_pcm_runtime
*runtime
,
1926 int channel
, unsigned long hwoff
)
1928 return runtime
->dma_area
+ hwoff
+
1929 channel
* (runtime
->dma_bytes
/ runtime
->channels
);
1932 /* default copy_user ops for write; used for both interleaved and non- modes */
1933 static int default_write_copy(struct snd_pcm_substream
*substream
,
1934 int channel
, unsigned long hwoff
,
1935 void *buf
, unsigned long bytes
)
1937 if (copy_from_user(get_dma_ptr(substream
->runtime
, channel
, hwoff
),
1938 (void __user
*)buf
, bytes
))
1943 /* default copy_kernel ops for write */
1944 static int default_write_copy_kernel(struct snd_pcm_substream
*substream
,
1945 int channel
, unsigned long hwoff
,
1946 void *buf
, unsigned long bytes
)
1948 memcpy(get_dma_ptr(substream
->runtime
, channel
, hwoff
), buf
, bytes
);
1952 /* fill silence instead of copy data; called as a transfer helper
1953 * from __snd_pcm_lib_write() or directly from noninterleaved_copy() when
1954 * a NULL buffer is passed
1956 static int fill_silence(struct snd_pcm_substream
*substream
, int channel
,
1957 unsigned long hwoff
, void *buf
, unsigned long bytes
)
1959 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1961 if (substream
->stream
!= SNDRV_PCM_STREAM_PLAYBACK
)
1963 if (substream
->ops
->fill_silence
)
1964 return substream
->ops
->fill_silence(substream
, channel
,
1967 snd_pcm_format_set_silence(runtime
->format
,
1968 get_dma_ptr(runtime
, channel
, hwoff
),
1969 bytes_to_samples(runtime
, bytes
));
1973 /* default copy_user ops for read; used for both interleaved and non- modes */
1974 static int default_read_copy(struct snd_pcm_substream
*substream
,
1975 int channel
, unsigned long hwoff
,
1976 void *buf
, unsigned long bytes
)
1978 if (copy_to_user((void __user
*)buf
,
1979 get_dma_ptr(substream
->runtime
, channel
, hwoff
),
1985 /* default copy_kernel ops for read */
1986 static int default_read_copy_kernel(struct snd_pcm_substream
*substream
,
1987 int channel
, unsigned long hwoff
,
1988 void *buf
, unsigned long bytes
)
1990 memcpy(buf
, get_dma_ptr(substream
->runtime
, channel
, hwoff
), bytes
);
1994 /* call transfer function with the converted pointers and sizes;
1995 * for interleaved mode, it's one shot for all samples
1997 static int interleaved_copy(struct snd_pcm_substream
*substream
,
1998 snd_pcm_uframes_t hwoff
, void *data
,
1999 snd_pcm_uframes_t off
,
2000 snd_pcm_uframes_t frames
,
2001 pcm_transfer_f transfer
)
2003 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2005 /* convert to bytes */
2006 hwoff
= frames_to_bytes(runtime
, hwoff
);
2007 off
= frames_to_bytes(runtime
, off
);
2008 frames
= frames_to_bytes(runtime
, frames
);
2009 return transfer(substream
, 0, hwoff
, data
+ off
, frames
);
2012 /* call transfer function with the converted pointers and sizes for each
2013 * non-interleaved channel; when buffer is NULL, silencing instead of copying
2015 static int noninterleaved_copy(struct snd_pcm_substream
*substream
,
2016 snd_pcm_uframes_t hwoff
, void *data
,
2017 snd_pcm_uframes_t off
,
2018 snd_pcm_uframes_t frames
,
2019 pcm_transfer_f transfer
)
2021 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2022 int channels
= runtime
->channels
;
2026 /* convert to bytes; note that it's not frames_to_bytes() here.
2027 * in non-interleaved mode, we copy for each channel, thus
2028 * each copy is n_samples bytes x channels = whole frames.
2030 off
= samples_to_bytes(runtime
, off
);
2031 frames
= samples_to_bytes(runtime
, frames
);
2032 hwoff
= samples_to_bytes(runtime
, hwoff
);
2033 for (c
= 0; c
< channels
; ++c
, ++bufs
) {
2034 if (!data
|| !*bufs
)
2035 err
= fill_silence(substream
, c
, hwoff
, NULL
, frames
);
2037 err
= transfer(substream
, c
, hwoff
, *bufs
+ off
,
2045 /* fill silence on the given buffer position;
2046 * called from snd_pcm_playback_silence()
2048 static int fill_silence_frames(struct snd_pcm_substream
*substream
,
2049 snd_pcm_uframes_t off
, snd_pcm_uframes_t frames
)
2051 if (substream
->runtime
->access
== SNDRV_PCM_ACCESS_RW_INTERLEAVED
||
2052 substream
->runtime
->access
== SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
)
2053 return interleaved_copy(substream
, off
, NULL
, 0, frames
,
2056 return noninterleaved_copy(substream
, off
, NULL
, 0, frames
,
2060 /* sanity-check for read/write methods */
2061 static int pcm_sanity_check(struct snd_pcm_substream
*substream
)
2063 struct snd_pcm_runtime
*runtime
;
2064 if (PCM_RUNTIME_CHECK(substream
))
2066 runtime
= substream
->runtime
;
2067 if (snd_BUG_ON(!substream
->ops
->copy_user
&& !runtime
->dma_area
))
2069 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
)
2074 static int pcm_accessible_state(struct snd_pcm_runtime
*runtime
)
2076 switch (runtime
->status
->state
) {
2077 case SNDRV_PCM_STATE_PREPARED
:
2078 case SNDRV_PCM_STATE_RUNNING
:
2079 case SNDRV_PCM_STATE_PAUSED
:
2081 case SNDRV_PCM_STATE_XRUN
:
2083 case SNDRV_PCM_STATE_SUSPENDED
:
2090 /* update to the given appl_ptr and call ack callback if needed;
2091 * when an error is returned, take back to the original value
2093 int pcm_lib_apply_appl_ptr(struct snd_pcm_substream
*substream
,
2094 snd_pcm_uframes_t appl_ptr
)
2096 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2097 snd_pcm_uframes_t old_appl_ptr
= runtime
->control
->appl_ptr
;
2100 if (old_appl_ptr
== appl_ptr
)
2103 runtime
->control
->appl_ptr
= appl_ptr
;
2104 if (substream
->ops
->ack
) {
2105 ret
= substream
->ops
->ack(substream
);
2107 runtime
->control
->appl_ptr
= old_appl_ptr
;
2112 trace_applptr(substream
, old_appl_ptr
, appl_ptr
);
2117 /* the common loop for read/write data */
2118 snd_pcm_sframes_t
__snd_pcm_lib_xfer(struct snd_pcm_substream
*substream
,
2119 void *data
, bool interleaved
,
2120 snd_pcm_uframes_t size
, bool in_kernel
)
2122 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2123 snd_pcm_uframes_t xfer
= 0;
2124 snd_pcm_uframes_t offset
= 0;
2125 snd_pcm_uframes_t avail
;
2127 pcm_transfer_f transfer
;
2132 err
= pcm_sanity_check(substream
);
2136 is_playback
= substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
;
2138 if (runtime
->access
!= SNDRV_PCM_ACCESS_RW_INTERLEAVED
&&
2139 runtime
->channels
> 1)
2141 writer
= interleaved_copy
;
2143 if (runtime
->access
!= SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
)
2145 writer
= noninterleaved_copy
;
2150 transfer
= fill_silence
;
2153 } else if (in_kernel
) {
2154 if (substream
->ops
->copy_kernel
)
2155 transfer
= substream
->ops
->copy_kernel
;
2157 transfer
= is_playback
?
2158 default_write_copy_kernel
: default_read_copy_kernel
;
2160 if (substream
->ops
->copy_user
)
2161 transfer
= (pcm_transfer_f
)substream
->ops
->copy_user
;
2163 transfer
= is_playback
?
2164 default_write_copy
: default_read_copy
;
2170 nonblock
= !!(substream
->f_flags
& O_NONBLOCK
);
2172 snd_pcm_stream_lock_irq(substream
);
2173 err
= pcm_accessible_state(runtime
);
2178 runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
&&
2179 size
>= runtime
->start_threshold
) {
2180 err
= snd_pcm_start(substream
);
2185 runtime
->twake
= runtime
->control
->avail_min
? : 1;
2186 if (runtime
->status
->state
== SNDRV_PCM_STATE_RUNNING
)
2187 snd_pcm_update_hw_ptr(substream
);
2189 avail
= snd_pcm_playback_avail(runtime
);
2191 avail
= snd_pcm_capture_avail(runtime
);
2193 snd_pcm_uframes_t frames
, appl_ptr
, appl_ofs
;
2194 snd_pcm_uframes_t cont
;
2197 runtime
->status
->state
== SNDRV_PCM_STATE_DRAINING
) {
2198 snd_pcm_stop(substream
, SNDRV_PCM_STATE_SETUP
);
2205 runtime
->twake
= min_t(snd_pcm_uframes_t
, size
,
2206 runtime
->control
->avail_min
? : 1);
2207 err
= wait_for_avail(substream
, &avail
);
2211 continue; /* draining */
2213 frames
= size
> avail
? avail
: size
;
2214 appl_ptr
= READ_ONCE(runtime
->control
->appl_ptr
);
2215 appl_ofs
= appl_ptr
% runtime
->buffer_size
;
2216 cont
= runtime
->buffer_size
- appl_ofs
;
2219 if (snd_BUG_ON(!frames
)) {
2221 snd_pcm_stream_unlock_irq(substream
);
2224 snd_pcm_stream_unlock_irq(substream
);
2225 err
= writer(substream
, appl_ofs
, data
, offset
, frames
,
2227 snd_pcm_stream_lock_irq(substream
);
2230 err
= pcm_accessible_state(runtime
);
2234 if (appl_ptr
>= runtime
->boundary
)
2235 appl_ptr
-= runtime
->boundary
;
2236 err
= pcm_lib_apply_appl_ptr(substream
, appl_ptr
);
2245 runtime
->status
->state
== SNDRV_PCM_STATE_PREPARED
&&
2246 snd_pcm_playback_hw_avail(runtime
) >= (snd_pcm_sframes_t
)runtime
->start_threshold
) {
2247 err
= snd_pcm_start(substream
);
2254 if (xfer
> 0 && err
>= 0)
2255 snd_pcm_update_state(substream
, runtime
);
2256 snd_pcm_stream_unlock_irq(substream
);
2257 return xfer
> 0 ? (snd_pcm_sframes_t
)xfer
: err
;
2259 EXPORT_SYMBOL(__snd_pcm_lib_xfer
);
2262 * standard channel mapping helpers
2265 /* default channel maps for multi-channel playbacks, up to 8 channels */
2266 const struct snd_pcm_chmap_elem snd_pcm_std_chmaps
[] = {
2268 .map
= { SNDRV_CHMAP_MONO
} },
2270 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
} },
2272 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2273 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
} },
2275 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2276 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
,
2277 SNDRV_CHMAP_FC
, SNDRV_CHMAP_LFE
} },
2279 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2280 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
,
2281 SNDRV_CHMAP_FC
, SNDRV_CHMAP_LFE
,
2282 SNDRV_CHMAP_SL
, SNDRV_CHMAP_SR
} },
2285 EXPORT_SYMBOL_GPL(snd_pcm_std_chmaps
);
2287 /* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2288 const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps
[] = {
2290 .map
= { SNDRV_CHMAP_MONO
} },
2292 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
} },
2294 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2295 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
} },
2297 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2298 SNDRV_CHMAP_FC
, SNDRV_CHMAP_LFE
,
2299 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
} },
2301 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
2302 SNDRV_CHMAP_FC
, SNDRV_CHMAP_LFE
,
2303 SNDRV_CHMAP_RL
, SNDRV_CHMAP_RR
,
2304 SNDRV_CHMAP_SL
, SNDRV_CHMAP_SR
} },
2307 EXPORT_SYMBOL_GPL(snd_pcm_alt_chmaps
);
2309 static bool valid_chmap_channels(const struct snd_pcm_chmap
*info
, int ch
)
2311 if (ch
> info
->max_channels
)
2313 return !info
->channel_mask
|| (info
->channel_mask
& (1U << ch
));
2316 static int pcm_chmap_ctl_info(struct snd_kcontrol
*kcontrol
,
2317 struct snd_ctl_elem_info
*uinfo
)
2319 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
2321 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2323 uinfo
->count
= info
->max_channels
;
2324 uinfo
->value
.integer
.min
= 0;
2325 uinfo
->value
.integer
.max
= SNDRV_CHMAP_LAST
;
2329 /* get callback for channel map ctl element
2330 * stores the channel position firstly matching with the current channels
2332 static int pcm_chmap_ctl_get(struct snd_kcontrol
*kcontrol
,
2333 struct snd_ctl_elem_value
*ucontrol
)
2335 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
2336 unsigned int idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
2337 struct snd_pcm_substream
*substream
;
2338 const struct snd_pcm_chmap_elem
*map
;
2342 substream
= snd_pcm_chmap_substream(info
, idx
);
2345 memset(ucontrol
->value
.integer
.value
, 0,
2346 sizeof(ucontrol
->value
.integer
.value
));
2347 if (!substream
->runtime
)
2348 return 0; /* no channels set */
2349 for (map
= info
->chmap
; map
->channels
; map
++) {
2351 if (map
->channels
== substream
->runtime
->channels
&&
2352 valid_chmap_channels(info
, map
->channels
)) {
2353 for (i
= 0; i
< map
->channels
; i
++)
2354 ucontrol
->value
.integer
.value
[i
] = map
->map
[i
];
2361 /* tlv callback for channel map ctl element
2362 * expands the pre-defined channel maps in a form of TLV
2364 static int pcm_chmap_ctl_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2365 unsigned int size
, unsigned int __user
*tlv
)
2367 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
2368 const struct snd_pcm_chmap_elem
*map
;
2369 unsigned int __user
*dst
;
2376 if (put_user(SNDRV_CTL_TLVT_CONTAINER
, tlv
))
2380 for (map
= info
->chmap
; map
->channels
; map
++) {
2381 int chs_bytes
= map
->channels
* 4;
2382 if (!valid_chmap_channels(info
, map
->channels
))
2386 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED
, dst
) ||
2387 put_user(chs_bytes
, dst
+ 1))
2392 if (size
< chs_bytes
)
2396 for (c
= 0; c
< map
->channels
; c
++) {
2397 if (put_user(map
->map
[c
], dst
))
2402 if (put_user(count
, tlv
+ 1))
2407 static void pcm_chmap_ctl_private_free(struct snd_kcontrol
*kcontrol
)
2409 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
2410 info
->pcm
->streams
[info
->stream
].chmap_kctl
= NULL
;
2415 * snd_pcm_add_chmap_ctls - create channel-mapping control elements
2416 * @pcm: the assigned PCM instance
2417 * @stream: stream direction
2418 * @chmap: channel map elements (for query)
2419 * @max_channels: the max number of channels for the stream
2420 * @private_value: the value passed to each kcontrol's private_value field
2421 * @info_ret: store struct snd_pcm_chmap instance if non-NULL
2423 * Create channel-mapping control elements assigned to the given PCM stream(s).
2424 * Return: Zero if successful, or a negative error value.
2426 int snd_pcm_add_chmap_ctls(struct snd_pcm
*pcm
, int stream
,
2427 const struct snd_pcm_chmap_elem
*chmap
,
2429 unsigned long private_value
,
2430 struct snd_pcm_chmap
**info_ret
)
2432 struct snd_pcm_chmap
*info
;
2433 struct snd_kcontrol_new knew
= {
2434 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
2435 .access
= SNDRV_CTL_ELEM_ACCESS_READ
|
2436 SNDRV_CTL_ELEM_ACCESS_TLV_READ
|
2437 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
,
2438 .info
= pcm_chmap_ctl_info
,
2439 .get
= pcm_chmap_ctl_get
,
2440 .tlv
.c
= pcm_chmap_ctl_tlv
,
2444 if (WARN_ON(pcm
->streams
[stream
].chmap_kctl
))
2446 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
2450 info
->stream
= stream
;
2451 info
->chmap
= chmap
;
2452 info
->max_channels
= max_channels
;
2453 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
2454 knew
.name
= "Playback Channel Map";
2456 knew
.name
= "Capture Channel Map";
2457 knew
.device
= pcm
->device
;
2458 knew
.count
= pcm
->streams
[stream
].substream_count
;
2459 knew
.private_value
= private_value
;
2460 info
->kctl
= snd_ctl_new1(&knew
, info
);
2465 info
->kctl
->private_free
= pcm_chmap_ctl_private_free
;
2466 err
= snd_ctl_add(pcm
->card
, info
->kctl
);
2469 pcm
->streams
[stream
].chmap_kctl
= info
->kctl
;
2474 EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls
);