1 /*
2 * Digital Audio (PCM) abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Abramo Bagnara <abramo@alsa-project.org>
5 *
6 *
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.
11 *
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.
16 *
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
20 *
21 */
22
23 #include <linux/slab.h>
24 #include <linux/time.h>
25 #include <linux/math64.h>
26 #include <linux/export.h>
27 #include <sound/core.h>
28 #include <sound/control.h>
29 #include <sound/tlv.h>
30 #include <sound/info.h>
31 #include <sound/pcm.h>
32 #include <sound/pcm_params.h>
33 #include <sound/timer.h>
34
35 /*
36 * fill ring buffer with silence
37 * runtime->silence_start: starting pointer to silence area
38 * runtime->silence_filled: size filled with silence
39 * runtime->silence_threshold: threshold from application
40 * runtime->silence_size: maximal size from application
41 *
42 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
43 */
snd_pcm_playback_silence(struct snd_pcm_substream * substream,snd_pcm_uframes_t new_hw_ptr)44 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
45 {
46 struct snd_pcm_runtime *runtime = substream->runtime;
47 snd_pcm_uframes_t frames, ofs, transfer;
48
49 if (runtime->silence_size < runtime->boundary) {
50 snd_pcm_sframes_t noise_dist, n;
51 if (runtime->silence_start != runtime->control->appl_ptr) {
52 n = runtime->control->appl_ptr - runtime->silence_start;
53 if (n < 0)
54 n += runtime->boundary;
55 if ((snd_pcm_uframes_t)n < runtime->silence_filled)
56 runtime->silence_filled -= n;
57 else
58 runtime->silence_filled = 0;
59 runtime->silence_start = runtime->control->appl_ptr;
60 }
61 if (runtime->silence_filled >= runtime->buffer_size)
62 return;
63 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
64 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
65 return;
66 frames = runtime->silence_threshold - noise_dist;
67 if (frames > runtime->silence_size)
68 frames = runtime->silence_size;
69 } else {
70 if (new_hw_ptr == ULONG_MAX) { /* initialization */
71 snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
72 if (avail > runtime->buffer_size)
73 avail = runtime->buffer_size;
74 runtime->silence_filled = avail > 0 ? avail : 0;
75 runtime->silence_start = (runtime->status->hw_ptr +
76 runtime->silence_filled) %
77 runtime->boundary;
78 } else {
79 ofs = runtime->status->hw_ptr;
80 frames = new_hw_ptr - ofs;
81 if ((snd_pcm_sframes_t)frames < 0)
82 frames += runtime->boundary;
83 runtime->silence_filled -= frames;
84 if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
85 runtime->silence_filled = 0;
86 runtime->silence_start = new_hw_ptr;
87 } else {
88 runtime->silence_start = ofs;
89 }
90 }
91 frames = runtime->buffer_size - runtime->silence_filled;
92 }
93 if (snd_BUG_ON(frames > runtime->buffer_size))
94 return;
95 if (frames == 0)
96 return;
97 ofs = runtime->silence_start % runtime->buffer_size;
98 while (frames > 0) {
99 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
100 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
101 runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
102 if (substream->ops->silence) {
103 int err;
104 err = substream->ops->silence(substream, -1, ofs, transfer);
105 snd_BUG_ON(err < 0);
106 } else {
107 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
108 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
109 }
110 } else {
111 unsigned int c;
112 unsigned int channels = runtime->channels;
113 if (substream->ops->silence) {
114 for (c = 0; c < channels; ++c) {
115 int err;
116 err = substream->ops->silence(substream, c, ofs, transfer);
117 snd_BUG_ON(err < 0);
118 }
119 } else {
120 size_t dma_csize = runtime->dma_bytes / channels;
121 for (c = 0; c < channels; ++c) {
122 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
123 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
124 }
125 }
126 }
127 runtime->silence_filled += transfer;
128 frames -= transfer;
129 ofs = 0;
130 }
131 }
132
133 #ifdef CONFIG_SND_DEBUG
snd_pcm_debug_name(struct snd_pcm_substream * substream,char * name,size_t len)134 void snd_pcm_debug_name(struct snd_pcm_substream *substream,
135 char *name, size_t len)
136 {
137 snprintf(name, len, "pcmC%dD%d%c:%d",
138 substream->pcm->card->number,
139 substream->pcm->device,
140 substream->stream ? 'c' : 'p',
141 substream->number);
142 }
143 EXPORT_SYMBOL(snd_pcm_debug_name);
144 #endif
145
146 #define XRUN_DEBUG_BASIC (1<<0)
147 #define XRUN_DEBUG_STACK (1<<1) /* dump also stack */
148 #define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */
149 #define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */
150 #define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */
151 #define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */
152 #define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */
153
154 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
155
156 #define xrun_debug(substream, mask) \
157 ((substream)->pstr->xrun_debug & (mask))
158 #else
159 #define xrun_debug(substream, mask) 0
160 #endif
161
162 #define dump_stack_on_xrun(substream) do { \
163 if (xrun_debug(substream, XRUN_DEBUG_STACK)) \
164 dump_stack(); \
165 } while (0)
166
xrun(struct snd_pcm_substream * substream)167 static void xrun(struct snd_pcm_substream *substream)
168 {
169 struct snd_pcm_runtime *runtime = substream->runtime;
170
171 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
172 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
173 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
174 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
175 char name[16];
176 snd_pcm_debug_name(substream, name, sizeof(name));
177 snd_printd(KERN_DEBUG "XRUN: %s\n", name);
178 dump_stack_on_xrun(substream);
179 }
180 }
181
182 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
183 #define hw_ptr_error(substream, fmt, args...) \
184 do { \
185 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \
186 xrun_log_show(substream); \
187 if (printk_ratelimit()) { \
188 snd_printd("PCM: " fmt, ##args); \
189 } \
190 dump_stack_on_xrun(substream); \
191 } \
192 } while (0)
193
194 #define XRUN_LOG_CNT 10
195
196 struct hwptr_log_entry {
197 unsigned int in_interrupt;
198 unsigned long jiffies;
199 snd_pcm_uframes_t pos;
200 snd_pcm_uframes_t period_size;
201 snd_pcm_uframes_t buffer_size;
202 snd_pcm_uframes_t old_hw_ptr;
203 snd_pcm_uframes_t hw_ptr_base;
204 };
205
206 struct snd_pcm_hwptr_log {
207 unsigned int idx;
208 unsigned int hit: 1;
209 struct hwptr_log_entry entries[XRUN_LOG_CNT];
210 };
211
xrun_log(struct snd_pcm_substream * substream,snd_pcm_uframes_t pos,int in_interrupt)212 static void xrun_log(struct snd_pcm_substream *substream,
213 snd_pcm_uframes_t pos, int in_interrupt)
214 {
215 struct snd_pcm_runtime *runtime = substream->runtime;
216 struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
217 struct hwptr_log_entry *entry;
218
219 if (log == NULL) {
220 log = kzalloc(sizeof(*log), GFP_ATOMIC);
221 if (log == NULL)
222 return;
223 runtime->hwptr_log = log;
224 } else {
225 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
226 return;
227 }
228 entry = &log->entries[log->idx];
229 entry->in_interrupt = in_interrupt;
230 entry->jiffies = jiffies;
231 entry->pos = pos;
232 entry->period_size = runtime->period_size;
233 entry->buffer_size = runtime->buffer_size;
234 entry->old_hw_ptr = runtime->status->hw_ptr;
235 entry->hw_ptr_base = runtime->hw_ptr_base;
236 log->idx = (log->idx + 1) % XRUN_LOG_CNT;
237 }
238
xrun_log_show(struct snd_pcm_substream * substream)239 static void xrun_log_show(struct snd_pcm_substream *substream)
240 {
241 struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
242 struct hwptr_log_entry *entry;
243 char name[16];
244 unsigned int idx;
245 int cnt;
246
247 if (log == NULL)
248 return;
249 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
250 return;
251 snd_pcm_debug_name(substream, name, sizeof(name));
252 for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
253 entry = &log->entries[idx];
254 if (entry->period_size == 0)
255 break;
256 snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
257 "hwptr=%ld/%ld\n",
258 name, entry->in_interrupt ? "[Q] " : "",
259 entry->jiffies,
260 (unsigned long)entry->pos,
261 (unsigned long)entry->period_size,
262 (unsigned long)entry->buffer_size,
263 (unsigned long)entry->old_hw_ptr,
264 (unsigned long)entry->hw_ptr_base);
265 idx++;
266 idx %= XRUN_LOG_CNT;
267 }
268 log->hit = 1;
269 }
270
271 #else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
272
273 #define hw_ptr_error(substream, fmt, args...) do { } while (0)
274 #define xrun_log(substream, pos, in_interrupt) do { } while (0)
275 #define xrun_log_show(substream) do { } while (0)
276
277 #endif
278
snd_pcm_update_state(struct snd_pcm_substream * substream,struct snd_pcm_runtime * runtime)279 int snd_pcm_update_state(struct snd_pcm_substream *substream,
280 struct snd_pcm_runtime *runtime)
281 {
282 snd_pcm_uframes_t avail;
283
284 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
285 avail = snd_pcm_playback_avail(runtime);
286 else
287 avail = snd_pcm_capture_avail(runtime);
288 if (avail > runtime->avail_max)
289 runtime->avail_max = avail;
290 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
291 if (avail >= runtime->buffer_size) {
292 snd_pcm_drain_done(substream);
293 return -EPIPE;
294 }
295 } else {
296 if (avail >= runtime->stop_threshold) {
297 xrun(substream);
298 return -EPIPE;
299 }
300 }
301 if (runtime->twake) {
302 if (avail >= runtime->twake)
303 wake_up(&runtime->tsleep);
304 } else if (avail >= runtime->control->avail_min)
305 wake_up(&runtime->sleep);
306 return 0;
307 }
308
snd_pcm_update_hw_ptr0(struct snd_pcm_substream * substream,unsigned int in_interrupt)309 static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
310 unsigned int in_interrupt)
311 {
312 struct snd_pcm_runtime *runtime = substream->runtime;
313 snd_pcm_uframes_t pos;
314 snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
315 snd_pcm_sframes_t hdelta, delta;
316 unsigned long jdelta;
317 unsigned long curr_jiffies;
318 struct timespec curr_tstamp;
319 struct timespec audio_tstamp;
320 int crossed_boundary = 0;
321
322 old_hw_ptr = runtime->status->hw_ptr;
323
324 /*
325 * group pointer, time and jiffies reads to allow for more
326 * accurate correlations/corrections.
327 * The values are stored at the end of this routine after
328 * corrections for hw_ptr position
329 */
330 pos = substream->ops->pointer(substream);
331 curr_jiffies = jiffies;
332 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
333 snd_pcm_gettime(runtime, (struct timespec *)&curr_tstamp);
334
335 if ((runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK) &&
336 (substream->ops->wall_clock))
337 substream->ops->wall_clock(substream, &audio_tstamp);
338 }
339
340 if (pos == SNDRV_PCM_POS_XRUN) {
341 xrun(substream);
342 return -EPIPE;
343 }
344 if (pos >= runtime->buffer_size) {
345 if (printk_ratelimit()) {
346 char name[16];
347 snd_pcm_debug_name(substream, name, sizeof(name));
348 xrun_log_show(substream);
349 snd_printd(KERN_ERR "BUG: %s, pos = %ld, "
350 "buffer size = %ld, period size = %ld\n",
351 name, pos, runtime->buffer_size,
352 runtime->period_size);
353 }
354 pos = 0;
355 }
356 pos -= pos % runtime->min_align;
357 if (xrun_debug(substream, XRUN_DEBUG_LOG))
358 xrun_log(substream, pos, in_interrupt);
359 hw_base = runtime->hw_ptr_base;
360 new_hw_ptr = hw_base + pos;
361 if (in_interrupt) {
362 /* we know that one period was processed */
363 /* delta = "expected next hw_ptr" for in_interrupt != 0 */
364 delta = runtime->hw_ptr_interrupt + runtime->period_size;
365 if (delta > new_hw_ptr) {
366 /* check for double acknowledged interrupts */
367 hdelta = curr_jiffies - runtime->hw_ptr_jiffies;
368 if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
369 hw_base += runtime->buffer_size;
370 if (hw_base >= runtime->boundary) {
371 hw_base = 0;
372 crossed_boundary++;
373 }
374 new_hw_ptr = hw_base + pos;
375 goto __delta;
376 }
377 }
378 }
379 /* new_hw_ptr might be lower than old_hw_ptr in case when */
380 /* pointer crosses the end of the ring buffer */
381 if (new_hw_ptr < old_hw_ptr) {
382 hw_base += runtime->buffer_size;
383 if (hw_base >= runtime->boundary) {
384 hw_base = 0;
385 crossed_boundary++;
386 }
387 new_hw_ptr = hw_base + pos;
388 }
389 __delta:
390 delta = new_hw_ptr - old_hw_ptr;
391 if (delta < 0)
392 delta += runtime->boundary;
393 if (xrun_debug(substream, in_interrupt ?
394 XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
395 char name[16];
396 snd_pcm_debug_name(substream, name, sizeof(name));
397 snd_printd("%s_update: %s: pos=%u/%u/%u, "
398 "hwptr=%ld/%ld/%ld/%ld\n",
399 in_interrupt ? "period" : "hwptr",
400 name,
401 (unsigned int)pos,
402 (unsigned int)runtime->period_size,
403 (unsigned int)runtime->buffer_size,
404 (unsigned long)delta,
405 (unsigned long)old_hw_ptr,
406 (unsigned long)new_hw_ptr,
407 (unsigned long)runtime->hw_ptr_base);
408 }
409
410 if (runtime->no_period_wakeup) {
411 snd_pcm_sframes_t xrun_threshold;
412 /*
413 * Without regular period interrupts, we have to check
414 * the elapsed time to detect xruns.
415 */
416 jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
417 if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
418 goto no_delta_check;
419 hdelta = jdelta - delta * HZ / runtime->rate;
420 xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
421 while (hdelta > xrun_threshold) {
422 delta += runtime->buffer_size;
423 hw_base += runtime->buffer_size;
424 if (hw_base >= runtime->boundary) {
425 hw_base = 0;
426 crossed_boundary++;
427 }
428 new_hw_ptr = hw_base + pos;
429 hdelta -= runtime->hw_ptr_buffer_jiffies;
430 }
431 goto no_delta_check;
432 }
433
434 /* something must be really wrong */
435 if (delta >= runtime->buffer_size + runtime->period_size) {
436 hw_ptr_error(substream,
437 "Unexpected hw_pointer value %s"
438 "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
439 "old_hw_ptr=%ld)\n",
440 in_interrupt ? "[Q] " : "[P]",
441 substream->stream, (long)pos,
442 (long)new_hw_ptr, (long)old_hw_ptr);
443 return 0;
444 }
445
446 /* Do jiffies check only in xrun_debug mode */
447 if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
448 goto no_jiffies_check;
449
450 /* Skip the jiffies check for hardwares with BATCH flag.
451 * Such hardware usually just increases the position at each IRQ,
452 * thus it can't give any strange position.
453 */
454 if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
455 goto no_jiffies_check;
456 hdelta = delta;
457 if (hdelta < runtime->delay)
458 goto no_jiffies_check;
459 hdelta -= runtime->delay;
460 jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
461 if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
462 delta = jdelta /
463 (((runtime->period_size * HZ) / runtime->rate)
464 + HZ/100);
465 /* move new_hw_ptr according jiffies not pos variable */
466 new_hw_ptr = old_hw_ptr;
467 hw_base = delta;
468 /* use loop to avoid checks for delta overflows */
469 /* the delta value is small or zero in most cases */
470 while (delta > 0) {
471 new_hw_ptr += runtime->period_size;
472 if (new_hw_ptr >= runtime->boundary) {
473 new_hw_ptr -= runtime->boundary;
474 crossed_boundary--;
475 }
476 delta--;
477 }
478 /* align hw_base to buffer_size */
479 hw_ptr_error(substream,
480 "hw_ptr skipping! %s"
481 "(pos=%ld, delta=%ld, period=%ld, "
482 "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
483 in_interrupt ? "[Q] " : "",
484 (long)pos, (long)hdelta,
485 (long)runtime->period_size, jdelta,
486 ((hdelta * HZ) / runtime->rate), hw_base,
487 (unsigned long)old_hw_ptr,
488 (unsigned long)new_hw_ptr);
489 /* reset values to proper state */
490 delta = 0;
491 hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
492 }
493 no_jiffies_check:
494 if (delta > runtime->period_size + runtime->period_size / 2) {
495 hw_ptr_error(substream,
496 "Lost interrupts? %s"
497 "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
498 "old_hw_ptr=%ld)\n",
499 in_interrupt ? "[Q] " : "",
500 substream->stream, (long)delta,
501 (long)new_hw_ptr,
502 (long)old_hw_ptr);
503 }
504
505 no_delta_check:
506 if (runtime->status->hw_ptr == new_hw_ptr)
507 return 0;
508
509 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
510 runtime->silence_size > 0)
511 snd_pcm_playback_silence(substream, new_hw_ptr);
512
513 if (in_interrupt) {
514 delta = new_hw_ptr - runtime->hw_ptr_interrupt;
515 if (delta < 0)
516 delta += runtime->boundary;
517 delta -= (snd_pcm_uframes_t)delta % runtime->period_size;
518 runtime->hw_ptr_interrupt += delta;
519 if (runtime->hw_ptr_interrupt >= runtime->boundary)
520 runtime->hw_ptr_interrupt -= runtime->boundary;
521 }
522 runtime->hw_ptr_base = hw_base;
523 runtime->status->hw_ptr = new_hw_ptr;
524 runtime->hw_ptr_jiffies = curr_jiffies;
525 if (crossed_boundary) {
526 snd_BUG_ON(crossed_boundary != 1);
527 runtime->hw_ptr_wrap += runtime->boundary;
528 }
529 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
530 runtime->status->tstamp = curr_tstamp;
531
532 if (!(runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK)) {
533 /*
534 * no wall clock available, provide audio timestamp
535 * derived from pointer position+delay
536 */
537 u64 audio_frames, audio_nsecs;
538
539 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
540 audio_frames = runtime->hw_ptr_wrap
541 + runtime->status->hw_ptr
542 - runtime->delay;
543 else
544 audio_frames = runtime->hw_ptr_wrap
545 + runtime->status->hw_ptr
546 + runtime->delay;
547 audio_nsecs = div_u64(audio_frames * 1000000000LL,
548 runtime->rate);
549 audio_tstamp = ns_to_timespec(audio_nsecs);
550 }
551 runtime->status->audio_tstamp = audio_tstamp;
552 }
553
554 return snd_pcm_update_state(substream, runtime);
555 }
556
557 /* CAUTION: call it with irq disabled */
snd_pcm_update_hw_ptr(struct snd_pcm_substream * substream)558 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
559 {
560 return snd_pcm_update_hw_ptr0(substream, 0);
561 }
562
563 /**
564 * snd_pcm_set_ops - set the PCM operators
565 * @pcm: the pcm instance
566 * @direction: stream direction, SNDRV_PCM_STREAM_XXX
567 * @ops: the operator table
568 *
569 * Sets the given PCM operators to the pcm instance.
570 */
snd_pcm_set_ops(struct snd_pcm * pcm,int direction,struct snd_pcm_ops * ops)571 void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
572 {
573 struct snd_pcm_str *stream = &pcm->streams[direction];
574 struct snd_pcm_substream *substream;
575
576 for (substream = stream->substream; substream != NULL; substream = substream->next)
577 substream->ops = ops;
578 }
579
580 EXPORT_SYMBOL(snd_pcm_set_ops);
581
582 /**
583 * snd_pcm_sync - set the PCM sync id
584 * @substream: the pcm substream
585 *
586 * Sets the PCM sync identifier for the card.
587 */
snd_pcm_set_sync(struct snd_pcm_substream * substream)588 void snd_pcm_set_sync(struct snd_pcm_substream *substream)
589 {
590 struct snd_pcm_runtime *runtime = substream->runtime;
591
592 runtime->sync.id32[0] = substream->pcm->card->number;
593 runtime->sync.id32[1] = -1;
594 runtime->sync.id32[2] = -1;
595 runtime->sync.id32[3] = -1;
596 }
597
598 EXPORT_SYMBOL(snd_pcm_set_sync);
599
600 /*
601 * Standard ioctl routine
602 */
603
div32(unsigned int a,unsigned int b,unsigned int * r)604 static inline unsigned int div32(unsigned int a, unsigned int b,
605 unsigned int *r)
606 {
607 if (b == 0) {
608 *r = 0;
609 return UINT_MAX;
610 }
611 *r = a % b;
612 return a / b;
613 }
614
div_down(unsigned int a,unsigned int b)615 static inline unsigned int div_down(unsigned int a, unsigned int b)
616 {
617 if (b == 0)
618 return UINT_MAX;
619 return a / b;
620 }
621
div_up(unsigned int a,unsigned int b)622 static inline unsigned int div_up(unsigned int a, unsigned int b)
623 {
624 unsigned int r;
625 unsigned int q;
626 if (b == 0)
627 return UINT_MAX;
628 q = div32(a, b, &r);
629 if (r)
630 ++q;
631 return q;
632 }
633
mul(unsigned int a,unsigned int b)634 static inline unsigned int mul(unsigned int a, unsigned int b)
635 {
636 if (a == 0)
637 return 0;
638 if (div_down(UINT_MAX, a) < b)
639 return UINT_MAX;
640 return a * b;
641 }
642
muldiv32(unsigned int a,unsigned int b,unsigned int c,unsigned int * r)643 static inline unsigned int muldiv32(unsigned int a, unsigned int b,
644 unsigned int c, unsigned int *r)
645 {
646 u_int64_t n = (u_int64_t) a * b;
647 if (c == 0) {
648 snd_BUG_ON(!n);
649 *r = 0;
650 return UINT_MAX;
651 }
652 n = div_u64_rem(n, c, r);
653 if (n >= UINT_MAX) {
654 *r = 0;
655 return UINT_MAX;
656 }
657 return n;
658 }
659
660 /**
661 * snd_interval_refine - refine the interval value of configurator
662 * @i: the interval value to refine
663 * @v: the interval value to refer to
664 *
665 * Refines the interval value with the reference value.
666 * The interval is changed to the range satisfying both intervals.
667 * The interval status (min, max, integer, etc.) are evaluated.
668 *
669 * Return: Positive if the value is changed, zero if it's not changed, or a
670 * negative error code.
671 */
snd_interval_refine(struct snd_interval * i,const struct snd_interval * v)672 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
673 {
674 int changed = 0;
675 if (snd_BUG_ON(snd_interval_empty(i)))
676 return -EINVAL;
677 if (i->min < v->min) {
678 i->min = v->min;
679 i->openmin = v->openmin;
680 changed = 1;
681 } else if (i->min == v->min && !i->openmin && v->openmin) {
682 i->openmin = 1;
683 changed = 1;
684 }
685 if (i->max > v->max) {
686 i->max = v->max;
687 i->openmax = v->openmax;
688 changed = 1;
689 } else if (i->max == v->max && !i->openmax && v->openmax) {
690 i->openmax = 1;
691 changed = 1;
692 }
693 if (!i->integer && v->integer) {
694 i->integer = 1;
695 changed = 1;
696 }
697 if (i->integer) {
698 if (i->openmin) {
699 i->min++;
700 i->openmin = 0;
701 }
702 if (i->openmax) {
703 i->max--;
704 i->openmax = 0;
705 }
706 } else if (!i->openmin && !i->openmax && i->min == i->max)
707 i->integer = 1;
708 if (snd_interval_checkempty(i)) {
709 snd_interval_none(i);
710 return -EINVAL;
711 }
712 return changed;
713 }
714
715 EXPORT_SYMBOL(snd_interval_refine);
716
snd_interval_refine_first(struct snd_interval * i)717 static int snd_interval_refine_first(struct snd_interval *i)
718 {
719 if (snd_BUG_ON(snd_interval_empty(i)))
720 return -EINVAL;
721 if (snd_interval_single(i))
722 return 0;
723 i->max = i->min;
724 i->openmax = i->openmin;
725 if (i->openmax)
726 i->max++;
727 return 1;
728 }
729
snd_interval_refine_last(struct snd_interval * i)730 static int snd_interval_refine_last(struct snd_interval *i)
731 {
732 if (snd_BUG_ON(snd_interval_empty(i)))
733 return -EINVAL;
734 if (snd_interval_single(i))
735 return 0;
736 i->min = i->max;
737 i->openmin = i->openmax;
738 if (i->openmin)
739 i->min--;
740 return 1;
741 }
742
snd_interval_mul(const struct snd_interval * a,const struct snd_interval * b,struct snd_interval * c)743 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
744 {
745 if (a->empty || b->empty) {
746 snd_interval_none(c);
747 return;
748 }
749 c->empty = 0;
750 c->min = mul(a->min, b->min);
751 c->openmin = (a->openmin || b->openmin);
752 c->max = mul(a->max, b->max);
753 c->openmax = (a->openmax || b->openmax);
754 c->integer = (a->integer && b->integer);
755 }
756
757 /**
758 * snd_interval_div - refine the interval value with division
759 * @a: dividend
760 * @b: divisor
761 * @c: quotient
762 *
763 * c = a / b
764 *
765 * Returns non-zero if the value is changed, zero if not changed.
766 */
snd_interval_div(const struct snd_interval * a,const struct snd_interval * b,struct snd_interval * c)767 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
768 {
769 unsigned int r;
770 if (a->empty || b->empty) {
771 snd_interval_none(c);
772 return;
773 }
774 c->empty = 0;
775 c->min = div32(a->min, b->max, &r);
776 c->openmin = (r || a->openmin || b->openmax);
777 if (b->min > 0) {
778 c->max = div32(a->max, b->min, &r);
779 if (r) {
780 c->max++;
781 c->openmax = 1;
782 } else
783 c->openmax = (a->openmax || b->openmin);
784 } else {
785 c->max = UINT_MAX;
786 c->openmax = 0;
787 }
788 c->integer = 0;
789 }
790
791 /**
792 * snd_interval_muldivk - refine the interval value
793 * @a: dividend 1
794 * @b: dividend 2
795 * @k: divisor (as integer)
796 * @c: result
797 *
798 * c = a * b / k
799 *
800 * Returns non-zero if the value is changed, zero if not changed.
801 */
snd_interval_muldivk(const struct snd_interval * a,const struct snd_interval * b,unsigned int k,struct snd_interval * c)802 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
803 unsigned int k, struct snd_interval *c)
804 {
805 unsigned int r;
806 if (a->empty || b->empty) {
807 snd_interval_none(c);
808 return;
809 }
810 c->empty = 0;
811 c->min = muldiv32(a->min, b->min, k, &r);
812 c->openmin = (r || a->openmin || b->openmin);
813 c->max = muldiv32(a->max, b->max, k, &r);
814 if (r) {
815 c->max++;
816 c->openmax = 1;
817 } else
818 c->openmax = (a->openmax || b->openmax);
819 c->integer = 0;
820 }
821
822 /**
823 * snd_interval_mulkdiv - refine the interval value
824 * @a: dividend 1
825 * @k: dividend 2 (as integer)
826 * @b: divisor
827 * @c: result
828 *
829 * c = a * k / b
830 *
831 * Returns non-zero if the value is changed, zero if not changed.
832 */
snd_interval_mulkdiv(const struct snd_interval * a,unsigned int k,const struct snd_interval * b,struct snd_interval * c)833 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
834 const struct snd_interval *b, struct snd_interval *c)
835 {
836 unsigned int r;
837 if (a->empty || b->empty) {
838 snd_interval_none(c);
839 return;
840 }
841 c->empty = 0;
842 c->min = muldiv32(a->min, k, b->max, &r);
843 c->openmin = (r || a->openmin || b->openmax);
844 if (b->min > 0) {
845 c->max = muldiv32(a->max, k, b->min, &r);
846 if (r) {
847 c->max++;
848 c->openmax = 1;
849 } else
850 c->openmax = (a->openmax || b->openmin);
851 } else {
852 c->max = UINT_MAX;
853 c->openmax = 0;
854 }
855 c->integer = 0;
856 }
857
858 /* ---- */
859
860
861 /**
862 * snd_interval_ratnum - refine the interval value
863 * @i: interval to refine
864 * @rats_count: number of ratnum_t
865 * @rats: ratnum_t array
866 * @nump: pointer to store the resultant numerator
867 * @denp: pointer to store the resultant denominator
868 *
869 * Return: Positive if the value is changed, zero if it's not changed, or a
870 * negative error code.
871 */
snd_interval_ratnum(struct snd_interval * i,unsigned int rats_count,struct snd_ratnum * rats,unsigned int * nump,unsigned int * denp)872 int snd_interval_ratnum(struct snd_interval *i,
873 unsigned int rats_count, struct snd_ratnum *rats,
874 unsigned int *nump, unsigned int *denp)
875 {
876 unsigned int best_num, best_den;
877 int best_diff;
878 unsigned int k;
879 struct snd_interval t;
880 int err;
881 unsigned int result_num, result_den;
882 int result_diff;
883
884 best_num = best_den = best_diff = 0;
885 for (k = 0; k < rats_count; ++k) {
886 unsigned int num = rats[k].num;
887 unsigned int den;
888 unsigned int q = i->min;
889 int diff;
890 if (q == 0)
891 q = 1;
892 den = div_up(num, q);
893 if (den < rats[k].den_min)
894 continue;
895 if (den > rats[k].den_max)
896 den = rats[k].den_max;
897 else {
898 unsigned int r;
899 r = (den - rats[k].den_min) % rats[k].den_step;
900 if (r != 0)
901 den -= r;
902 }
903 diff = num - q * den;
904 if (diff < 0)
905 diff = -diff;
906 if (best_num == 0 ||
907 diff * best_den < best_diff * den) {
908 best_diff = diff;
909 best_den = den;
910 best_num = num;
911 }
912 }
913 if (best_den == 0) {
914 i->empty = 1;
915 return -EINVAL;
916 }
917 t.min = div_down(best_num, best_den);
918 t.openmin = !!(best_num % best_den);
919
920 result_num = best_num;
921 result_diff = best_diff;
922 result_den = best_den;
923 best_num = best_den = best_diff = 0;
924 for (k = 0; k < rats_count; ++k) {
925 unsigned int num = rats[k].num;
926 unsigned int den;
927 unsigned int q = i->max;
928 int diff;
929 if (q == 0) {
930 i->empty = 1;
931 return -EINVAL;
932 }
933 den = div_down(num, q);
934 if (den > rats[k].den_max)
935 continue;
936 if (den < rats[k].den_min)
937 den = rats[k].den_min;
938 else {
939 unsigned int r;
940 r = (den - rats[k].den_min) % rats[k].den_step;
941 if (r != 0)
942 den += rats[k].den_step - r;
943 }
944 diff = q * den - num;
945 if (diff < 0)
946 diff = -diff;
947 if (best_num == 0 ||
948 diff * best_den < best_diff * den) {
949 best_diff = diff;
950 best_den = den;
951 best_num = num;
952 }
953 }
954 if (best_den == 0) {
955 i->empty = 1;
956 return -EINVAL;
957 }
958 t.max = div_up(best_num, best_den);
959 t.openmax = !!(best_num % best_den);
960 t.integer = 0;
961 err = snd_interval_refine(i, &t);
962 if (err < 0)
963 return err;
964
965 if (snd_interval_single(i)) {
966 if (best_diff * result_den < result_diff * best_den) {
967 result_num = best_num;
968 result_den = best_den;
969 }
970 if (nump)
971 *nump = result_num;
972 if (denp)
973 *denp = result_den;
974 }
975 return err;
976 }
977
978 EXPORT_SYMBOL(snd_interval_ratnum);
979
980 /**
981 * snd_interval_ratden - refine the interval value
982 * @i: interval to refine
983 * @rats_count: number of struct ratden
984 * @rats: struct ratden array
985 * @nump: pointer to store the resultant numerator
986 * @denp: pointer to store the resultant denominator
987 *
988 * Return: Positive if the value is changed, zero if it's not changed, or a
989 * negative error code.
990 */
snd_interval_ratden(struct snd_interval * i,unsigned int rats_count,struct snd_ratden * rats,unsigned int * nump,unsigned int * denp)991 static int snd_interval_ratden(struct snd_interval *i,
992 unsigned int rats_count, struct snd_ratden *rats,
993 unsigned int *nump, unsigned int *denp)
994 {
995 unsigned int best_num, best_diff, best_den;
996 unsigned int k;
997 struct snd_interval t;
998 int err;
999
1000 best_num = best_den = best_diff = 0;
1001 for (k = 0; k < rats_count; ++k) {
1002 unsigned int num;
1003 unsigned int den = rats[k].den;
1004 unsigned int q = i->min;
1005 int diff;
1006 num = mul(q, den);
1007 if (num > rats[k].num_max)
1008 continue;
1009 if (num < rats[k].num_min)
1010 num = rats[k].num_max;
1011 else {
1012 unsigned int r;
1013 r = (num - rats[k].num_min) % rats[k].num_step;
1014 if (r != 0)
1015 num += rats[k].num_step - r;
1016 }
1017 diff = num - q * den;
1018 if (best_num == 0 ||
1019 diff * best_den < best_diff * den) {
1020 best_diff = diff;
1021 best_den = den;
1022 best_num = num;
1023 }
1024 }
1025 if (best_den == 0) {
1026 i->empty = 1;
1027 return -EINVAL;
1028 }
1029 t.min = div_down(best_num, best_den);
1030 t.openmin = !!(best_num % best_den);
1031
1032 best_num = best_den = best_diff = 0;
1033 for (k = 0; k < rats_count; ++k) {
1034 unsigned int num;
1035 unsigned int den = rats[k].den;
1036 unsigned int q = i->max;
1037 int diff;
1038 num = mul(q, den);
1039 if (num < rats[k].num_min)
1040 continue;
1041 if (num > rats[k].num_max)
1042 num = rats[k].num_max;
1043 else {
1044 unsigned int r;
1045 r = (num - rats[k].num_min) % rats[k].num_step;
1046 if (r != 0)
1047 num -= r;
1048 }
1049 diff = q * den - num;
1050 if (best_num == 0 ||
1051 diff * best_den < best_diff * den) {
1052 best_diff = diff;
1053 best_den = den;
1054 best_num = num;
1055 }
1056 }
1057 if (best_den == 0) {
1058 i->empty = 1;
1059 return -EINVAL;
1060 }
1061 t.max = div_up(best_num, best_den);
1062 t.openmax = !!(best_num % best_den);
1063 t.integer = 0;
1064 err = snd_interval_refine(i, &t);
1065 if (err < 0)
1066 return err;
1067
1068 if (snd_interval_single(i)) {
1069 if (nump)
1070 *nump = best_num;
1071 if (denp)
1072 *denp = best_den;
1073 }
1074 return err;
1075 }
1076
1077 /**
1078 * snd_interval_list - refine the interval value from the list
1079 * @i: the interval value to refine
1080 * @count: the number of elements in the list
1081 * @list: the value list
1082 * @mask: the bit-mask to evaluate
1083 *
1084 * Refines the interval value from the list.
1085 * When mask is non-zero, only the elements corresponding to bit 1 are
1086 * evaluated.
1087 *
1088 * Return: Positive if the value is changed, zero if it's not changed, or a
1089 * negative error code.
1090 */
snd_interval_list(struct snd_interval * i,unsigned int count,const unsigned int * list,unsigned int mask)1091 int snd_interval_list(struct snd_interval *i, unsigned int count,
1092 const unsigned int *list, unsigned int mask)
1093 {
1094 unsigned int k;
1095 struct snd_interval list_range;
1096
1097 if (!count) {
1098 i->empty = 1;
1099 return -EINVAL;
1100 }
1101 snd_interval_any(&list_range);
1102 list_range.min = UINT_MAX;
1103 list_range.max = 0;
1104 for (k = 0; k < count; k++) {
1105 if (mask && !(mask & (1 << k)))
1106 continue;
1107 if (!snd_interval_test(i, list[k]))
1108 continue;
1109 list_range.min = min(list_range.min, list[k]);
1110 list_range.max = max(list_range.max, list[k]);
1111 }
1112 return snd_interval_refine(i, &list_range);
1113 }
1114
1115 EXPORT_SYMBOL(snd_interval_list);
1116
snd_interval_step(struct snd_interval * i,unsigned int min,unsigned int step)1117 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
1118 {
1119 unsigned int n;
1120 int changed = 0;
1121 n = (i->min - min) % step;
1122 if (n != 0 || i->openmin) {
1123 i->min += step - n;
1124 changed = 1;
1125 }
1126 n = (i->max - min) % step;
1127 if (n != 0 || i->openmax) {
1128 i->max -= n;
1129 changed = 1;
1130 }
1131 if (snd_interval_checkempty(i)) {
1132 i->empty = 1;
1133 return -EINVAL;
1134 }
1135 return changed;
1136 }
1137
1138 /* Info constraints helpers */
1139
1140 /**
1141 * snd_pcm_hw_rule_add - add the hw-constraint rule
1142 * @runtime: the pcm runtime instance
1143 * @cond: condition bits
1144 * @var: the variable to evaluate
1145 * @func: the evaluation function
1146 * @private: the private data pointer passed to function
1147 * @dep: the dependent variables
1148 *
1149 * Return: Zero if successful, or a negative error code on failure.
1150 */
snd_pcm_hw_rule_add(struct snd_pcm_runtime * runtime,unsigned int cond,int var,snd_pcm_hw_rule_func_t func,void * private,int dep,...)1151 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
1152 int var,
1153 snd_pcm_hw_rule_func_t func, void *private,
1154 int dep, ...)
1155 {
1156 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1157 struct snd_pcm_hw_rule *c;
1158 unsigned int k;
1159 va_list args;
1160 va_start(args, dep);
1161 if (constrs->rules_num >= constrs->rules_all) {
1162 struct snd_pcm_hw_rule *new;
1163 unsigned int new_rules = constrs->rules_all + 16;
1164 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
1165 if (!new) {
1166 va_end(args);
1167 return -ENOMEM;
1168 }
1169 if (constrs->rules) {
1170 memcpy(new, constrs->rules,
1171 constrs->rules_num * sizeof(*c));
1172 kfree(constrs->rules);
1173 }
1174 constrs->rules = new;
1175 constrs->rules_all = new_rules;
1176 }
1177 c = &constrs->rules[constrs->rules_num];
1178 c->cond = cond;
1179 c->func = func;
1180 c->var = var;
1181 c->private = private;
1182 k = 0;
1183 while (1) {
1184 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
1185 va_end(args);
1186 return -EINVAL;
1187 }
1188 c->deps[k++] = dep;
1189 if (dep < 0)
1190 break;
1191 dep = va_arg(args, int);
1192 }
1193 constrs->rules_num++;
1194 va_end(args);
1195 return 0;
1196 }
1197
1198 EXPORT_SYMBOL(snd_pcm_hw_rule_add);
1199
1200 /**
1201 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
1202 * @runtime: PCM runtime instance
1203 * @var: hw_params variable to apply the mask
1204 * @mask: the bitmap mask
1205 *
1206 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
1207 *
1208 * Return: Zero if successful, or a negative error code on failure.
1209 */
snd_pcm_hw_constraint_mask(struct snd_pcm_runtime * runtime,snd_pcm_hw_param_t var,u_int32_t mask)1210 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1211 u_int32_t mask)
1212 {
1213 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1214 struct snd_mask *maskp = constrs_mask(constrs, var);
1215 *maskp->bits &= mask;
1216 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
1217 if (*maskp->bits == 0)
1218 return -EINVAL;
1219 return 0;
1220 }
1221
1222 /**
1223 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
1224 * @runtime: PCM runtime instance
1225 * @var: hw_params variable to apply the mask
1226 * @mask: the 64bit bitmap mask
1227 *
1228 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
1229 *
1230 * Return: Zero if successful, or a negative error code on failure.
1231 */
snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime * runtime,snd_pcm_hw_param_t var,u_int64_t mask)1232 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1233 u_int64_t mask)
1234 {
1235 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1236 struct snd_mask *maskp = constrs_mask(constrs, var);
1237 maskp->bits[0] &= (u_int32_t)mask;
1238 maskp->bits[1] &= (u_int32_t)(mask >> 32);
1239 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
1240 if (! maskp->bits[0] && ! maskp->bits[1])
1241 return -EINVAL;
1242 return 0;
1243 }
1244
1245 /**
1246 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
1247 * @runtime: PCM runtime instance
1248 * @var: hw_params variable to apply the integer constraint
1249 *
1250 * Apply the constraint of integer to an interval parameter.
1251 *
1252 * Return: Positive if the value is changed, zero if it's not changed, or a
1253 * negative error code.
1254 */
snd_pcm_hw_constraint_integer(struct snd_pcm_runtime * runtime,snd_pcm_hw_param_t var)1255 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
1256 {
1257 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1258 return snd_interval_setinteger(constrs_interval(constrs, var));
1259 }
1260
1261 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
1262
1263 /**
1264 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
1265 * @runtime: PCM runtime instance
1266 * @var: hw_params variable to apply the range
1267 * @min: the minimal value
1268 * @max: the maximal value
1269 *
1270 * Apply the min/max range constraint to an interval parameter.
1271 *
1272 * Return: Positive if the value is changed, zero if it's not changed, or a
1273 * negative error code.
1274 */
snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime * runtime,snd_pcm_hw_param_t var,unsigned int min,unsigned int max)1275 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1276 unsigned int min, unsigned int max)
1277 {
1278 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1279 struct snd_interval t;
1280 t.min = min;
1281 t.max = max;
1282 t.openmin = t.openmax = 0;
1283 t.integer = 0;
1284 return snd_interval_refine(constrs_interval(constrs, var), &t);
1285 }
1286
1287 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
1288
snd_pcm_hw_rule_list(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1289 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
1290 struct snd_pcm_hw_rule *rule)
1291 {
1292 struct snd_pcm_hw_constraint_list *list = rule->private;
1293 return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
1294 }
1295
1296
1297 /**
1298 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
1299 * @runtime: PCM runtime instance
1300 * @cond: condition bits
1301 * @var: hw_params variable to apply the list constraint
1302 * @l: list
1303 *
1304 * Apply the list of constraints to an interval parameter.
1305 *
1306 * Return: Zero if successful, or a negative error code on failure.
1307 */
snd_pcm_hw_constraint_list(struct snd_pcm_runtime * runtime,unsigned int cond,snd_pcm_hw_param_t var,const struct snd_pcm_hw_constraint_list * l)1308 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
1309 unsigned int cond,
1310 snd_pcm_hw_param_t var,
1311 const struct snd_pcm_hw_constraint_list *l)
1312 {
1313 return snd_pcm_hw_rule_add(runtime, cond, var,
1314 snd_pcm_hw_rule_list, (void *)l,
1315 var, -1);
1316 }
1317
1318 EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
1319
snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1320 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
1321 struct snd_pcm_hw_rule *rule)
1322 {
1323 struct snd_pcm_hw_constraint_ratnums *r = rule->private;
1324 unsigned int num = 0, den = 0;
1325 int err;
1326 err = snd_interval_ratnum(hw_param_interval(params, rule->var),
1327 r->nrats, r->rats, &num, &den);
1328 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1329 params->rate_num = num;
1330 params->rate_den = den;
1331 }
1332 return err;
1333 }
1334
1335 /**
1336 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
1337 * @runtime: PCM runtime instance
1338 * @cond: condition bits
1339 * @var: hw_params variable to apply the ratnums constraint
1340 * @r: struct snd_ratnums constriants
1341 *
1342 * Return: Zero if successful, or a negative error code on failure.
1343 */
snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime * runtime,unsigned int cond,snd_pcm_hw_param_t var,struct snd_pcm_hw_constraint_ratnums * r)1344 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
1345 unsigned int cond,
1346 snd_pcm_hw_param_t var,
1347 struct snd_pcm_hw_constraint_ratnums *r)
1348 {
1349 return snd_pcm_hw_rule_add(runtime, cond, var,
1350 snd_pcm_hw_rule_ratnums, r,
1351 var, -1);
1352 }
1353
1354 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
1355
snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1356 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
1357 struct snd_pcm_hw_rule *rule)
1358 {
1359 struct snd_pcm_hw_constraint_ratdens *r = rule->private;
1360 unsigned int num = 0, den = 0;
1361 int err = snd_interval_ratden(hw_param_interval(params, rule->var),
1362 r->nrats, r->rats, &num, &den);
1363 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1364 params->rate_num = num;
1365 params->rate_den = den;
1366 }
1367 return err;
1368 }
1369
1370 /**
1371 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
1372 * @runtime: PCM runtime instance
1373 * @cond: condition bits
1374 * @var: hw_params variable to apply the ratdens constraint
1375 * @r: struct snd_ratdens constriants
1376 *
1377 * Return: Zero if successful, or a negative error code on failure.
1378 */
snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime * runtime,unsigned int cond,snd_pcm_hw_param_t var,struct snd_pcm_hw_constraint_ratdens * r)1379 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
1380 unsigned int cond,
1381 snd_pcm_hw_param_t var,
1382 struct snd_pcm_hw_constraint_ratdens *r)
1383 {
1384 return snd_pcm_hw_rule_add(runtime, cond, var,
1385 snd_pcm_hw_rule_ratdens, r,
1386 var, -1);
1387 }
1388
1389 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
1390
snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1391 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
1392 struct snd_pcm_hw_rule *rule)
1393 {
1394 unsigned int l = (unsigned long) rule->private;
1395 int width = l & 0xffff;
1396 unsigned int msbits = l >> 16;
1397 struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
1398 if (snd_interval_single(i) && snd_interval_value(i) == width)
1399 params->msbits = msbits;
1400 return 0;
1401 }
1402
1403 /**
1404 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
1405 * @runtime: PCM runtime instance
1406 * @cond: condition bits
1407 * @width: sample bits width
1408 * @msbits: msbits width
1409 *
1410 * Return: Zero if successful, or a negative error code on failure.
1411 */
snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime * runtime,unsigned int cond,unsigned int width,unsigned int msbits)1412 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
1413 unsigned int cond,
1414 unsigned int width,
1415 unsigned int msbits)
1416 {
1417 unsigned long l = (msbits << 16) | width;
1418 return snd_pcm_hw_rule_add(runtime, cond, -1,
1419 snd_pcm_hw_rule_msbits,
1420 (void*) l,
1421 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1422 }
1423
1424 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
1425
snd_pcm_hw_rule_step(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1426 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
1427 struct snd_pcm_hw_rule *rule)
1428 {
1429 unsigned long step = (unsigned long) rule->private;
1430 return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
1431 }
1432
1433 /**
1434 * snd_pcm_hw_constraint_step - add a hw constraint step rule
1435 * @runtime: PCM runtime instance
1436 * @cond: condition bits
1437 * @var: hw_params variable to apply the step constraint
1438 * @step: step size
1439 *
1440 * Return: Zero if successful, or a negative error code on failure.
1441 */
snd_pcm_hw_constraint_step(struct snd_pcm_runtime * runtime,unsigned int cond,snd_pcm_hw_param_t var,unsigned long step)1442 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
1443 unsigned int cond,
1444 snd_pcm_hw_param_t var,
1445 unsigned long step)
1446 {
1447 return snd_pcm_hw_rule_add(runtime, cond, var,
1448 snd_pcm_hw_rule_step, (void *) step,
1449 var, -1);
1450 }
1451
1452 EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
1453
snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1454 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
1455 {
1456 static unsigned int pow2_sizes[] = {
1457 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1458 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1459 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1460 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1461 };
1462 return snd_interval_list(hw_param_interval(params, rule->var),
1463 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
1464 }
1465
1466 /**
1467 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
1468 * @runtime: PCM runtime instance
1469 * @cond: condition bits
1470 * @var: hw_params variable to apply the power-of-2 constraint
1471 *
1472 * Return: Zero if successful, or a negative error code on failure.
1473 */
snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime * runtime,unsigned int cond,snd_pcm_hw_param_t var)1474 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
1475 unsigned int cond,
1476 snd_pcm_hw_param_t var)
1477 {
1478 return snd_pcm_hw_rule_add(runtime, cond, var,
1479 snd_pcm_hw_rule_pow2, NULL,
1480 var, -1);
1481 }
1482
1483 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
1484
snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1485 static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,
1486 struct snd_pcm_hw_rule *rule)
1487 {
1488 unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;
1489 struct snd_interval *rate;
1490
1491 rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1492 return snd_interval_list(rate, 1, &base_rate, 0);
1493 }
1494
1495 /**
1496 * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
1497 * @runtime: PCM runtime instance
1498 * @base_rate: the rate at which the hardware does not resample
1499 *
1500 * Return: Zero if successful, or a negative error code on failure.
1501 */
snd_pcm_hw_rule_noresample(struct snd_pcm_runtime * runtime,unsigned int base_rate)1502 int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
1503 unsigned int base_rate)
1504 {
1505 return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,
1506 SNDRV_PCM_HW_PARAM_RATE,
1507 snd_pcm_hw_rule_noresample_func,
1508 (void *)(uintptr_t)base_rate,
1509 SNDRV_PCM_HW_PARAM_RATE, -1);
1510 }
1511 EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);
1512
_snd_pcm_hw_param_any(struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var)1513 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
1514 snd_pcm_hw_param_t var)
1515 {
1516 if (hw_is_mask(var)) {
1517 snd_mask_any(hw_param_mask(params, var));
1518 params->cmask |= 1 << var;
1519 params->rmask |= 1 << var;
1520 return;
1521 }
1522 if (hw_is_interval(var)) {
1523 snd_interval_any(hw_param_interval(params, var));
1524 params->cmask |= 1 << var;
1525 params->rmask |= 1 << var;
1526 return;
1527 }
1528 snd_BUG();
1529 }
1530
_snd_pcm_hw_params_any(struct snd_pcm_hw_params * params)1531 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
1532 {
1533 unsigned int k;
1534 memset(params, 0, sizeof(*params));
1535 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
1536 _snd_pcm_hw_param_any(params, k);
1537 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
1538 _snd_pcm_hw_param_any(params, k);
1539 params->info = ~0U;
1540 }
1541
1542 EXPORT_SYMBOL(_snd_pcm_hw_params_any);
1543
1544 /**
1545 * snd_pcm_hw_param_value - return @params field @var value
1546 * @params: the hw_params instance
1547 * @var: parameter to retrieve
1548 * @dir: pointer to the direction (-1,0,1) or %NULL
1549 *
1550 * Return: The value for field @var if it's fixed in configuration space
1551 * defined by @params. -%EINVAL otherwise.
1552 */
snd_pcm_hw_param_value(const struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var,int * dir)1553 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
1554 snd_pcm_hw_param_t var, int *dir)
1555 {
1556 if (hw_is_mask(var)) {
1557 const struct snd_mask *mask = hw_param_mask_c(params, var);
1558 if (!snd_mask_single(mask))
1559 return -EINVAL;
1560 if (dir)
1561 *dir = 0;
1562 return snd_mask_value(mask);
1563 }
1564 if (hw_is_interval(var)) {
1565 const struct snd_interval *i = hw_param_interval_c(params, var);
1566 if (!snd_interval_single(i))
1567 return -EINVAL;
1568 if (dir)
1569 *dir = i->openmin;
1570 return snd_interval_value(i);
1571 }
1572 return -EINVAL;
1573 }
1574
1575 EXPORT_SYMBOL(snd_pcm_hw_param_value);
1576
_snd_pcm_hw_param_setempty(struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var)1577 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
1578 snd_pcm_hw_param_t var)
1579 {
1580 if (hw_is_mask(var)) {
1581 snd_mask_none(hw_param_mask(params, var));
1582 params->cmask |= 1 << var;
1583 params->rmask |= 1 << var;
1584 } else if (hw_is_interval(var)) {
1585 snd_interval_none(hw_param_interval(params, var));
1586 params->cmask |= 1 << var;
1587 params->rmask |= 1 << var;
1588 } else {
1589 snd_BUG();
1590 }
1591 }
1592
1593 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
1594
_snd_pcm_hw_param_first(struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var)1595 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
1596 snd_pcm_hw_param_t var)
1597 {
1598 int changed;
1599 if (hw_is_mask(var))
1600 changed = snd_mask_refine_first(hw_param_mask(params, var));
1601 else if (hw_is_interval(var))
1602 changed = snd_interval_refine_first(hw_param_interval(params, var));
1603 else
1604 return -EINVAL;
1605 if (changed) {
1606 params->cmask |= 1 << var;
1607 params->rmask |= 1 << var;
1608 }
1609 return changed;
1610 }
1611
1612
1613 /**
1614 * snd_pcm_hw_param_first - refine config space and return minimum value
1615 * @pcm: PCM instance
1616 * @params: the hw_params instance
1617 * @var: parameter to retrieve
1618 * @dir: pointer to the direction (-1,0,1) or %NULL
1619 *
1620 * Inside configuration space defined by @params remove from @var all
1621 * values > minimum. Reduce configuration space accordingly.
1622 *
1623 * Return: The minimum, or a negative error code on failure.
1624 */
snd_pcm_hw_param_first(struct snd_pcm_substream * pcm,struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var,int * dir)1625 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
1626 struct snd_pcm_hw_params *params,
1627 snd_pcm_hw_param_t var, int *dir)
1628 {
1629 int changed = _snd_pcm_hw_param_first(params, var);
1630 if (changed < 0)
1631 return changed;
1632 if (params->rmask) {
1633 int err = snd_pcm_hw_refine(pcm, params);
1634 if (snd_BUG_ON(err < 0))
1635 return err;
1636 }
1637 return snd_pcm_hw_param_value(params, var, dir);
1638 }
1639
1640 EXPORT_SYMBOL(snd_pcm_hw_param_first);
1641
_snd_pcm_hw_param_last(struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var)1642 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
1643 snd_pcm_hw_param_t var)
1644 {
1645 int changed;
1646 if (hw_is_mask(var))
1647 changed = snd_mask_refine_last(hw_param_mask(params, var));
1648 else if (hw_is_interval(var))
1649 changed = snd_interval_refine_last(hw_param_interval(params, var));
1650 else
1651 return -EINVAL;
1652 if (changed) {
1653 params->cmask |= 1 << var;
1654 params->rmask |= 1 << var;
1655 }
1656 return changed;
1657 }
1658
1659
1660 /**
1661 * snd_pcm_hw_param_last - refine config space and return maximum value
1662 * @pcm: PCM instance
1663 * @params: the hw_params instance
1664 * @var: parameter to retrieve
1665 * @dir: pointer to the direction (-1,0,1) or %NULL
1666 *
1667 * Inside configuration space defined by @params remove from @var all
1668 * values < maximum. Reduce configuration space accordingly.
1669 *
1670 * Return: The maximum, or a negative error code on failure.
1671 */
snd_pcm_hw_param_last(struct snd_pcm_substream * pcm,struct snd_pcm_hw_params * params,snd_pcm_hw_param_t var,int * dir)1672 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
1673 struct snd_pcm_hw_params *params,
1674 snd_pcm_hw_param_t var, int *dir)
1675 {
1676 int changed = _snd_pcm_hw_param_last(params, var);
1677 if (changed < 0)
1678 return changed;
1679 if (params->rmask) {
1680 int err = snd_pcm_hw_refine(pcm, params);
1681 if (snd_BUG_ON(err < 0))
1682 return err;
1683 }
1684 return snd_pcm_hw_param_value(params, var, dir);
1685 }
1686
1687 EXPORT_SYMBOL(snd_pcm_hw_param_last);
1688
1689 /**
1690 * snd_pcm_hw_param_choose - choose a configuration defined by @params
1691 * @pcm: PCM instance
1692 * @params: the hw_params instance
1693 *
1694 * Choose one configuration from configuration space defined by @params.
1695 * The configuration chosen is that obtained fixing in this order:
1696 * first access, first format, first subformat, min channels,
1697 * min rate, min period time, max buffer size, min tick time
1698 *
1699 * Return: Zero if successful, or a negative error code on failure.
1700 */
snd_pcm_hw_params_choose(struct snd_pcm_substream * pcm,struct snd_pcm_hw_params * params)1701 int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1702 struct snd_pcm_hw_params *params)
1703 {
1704 static int vars[] = {
1705 SNDRV_PCM_HW_PARAM_ACCESS,
1706 SNDRV_PCM_HW_PARAM_FORMAT,
1707 SNDRV_PCM_HW_PARAM_SUBFORMAT,
1708 SNDRV_PCM_HW_PARAM_CHANNELS,
1709 SNDRV_PCM_HW_PARAM_RATE,
1710 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1711 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1712 SNDRV_PCM_HW_PARAM_TICK_TIME,
1713 -1
1714 };
1715 int err, *v;
1716
1717 for (v = vars; *v != -1; v++) {
1718 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
1719 err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1720 else
1721 err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
1722 if (snd_BUG_ON(err < 0))
1723 return err;
1724 }
1725 return 0;
1726 }
1727
snd_pcm_lib_ioctl_reset(struct snd_pcm_substream * substream,void * arg)1728 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
1729 void *arg)
1730 {
1731 struct snd_pcm_runtime *runtime = substream->runtime;
1732 unsigned long flags;
1733 snd_pcm_stream_lock_irqsave(substream, flags);
1734 if (snd_pcm_running(substream) &&
1735 snd_pcm_update_hw_ptr(substream) >= 0)
1736 runtime->status->hw_ptr %= runtime->buffer_size;
1737 else {
1738 runtime->status->hw_ptr = 0;
1739 runtime->hw_ptr_wrap = 0;
1740 }
1741 snd_pcm_stream_unlock_irqrestore(substream, flags);
1742 return 0;
1743 }
1744
snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream * substream,void * arg)1745 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
1746 void *arg)
1747 {
1748 struct snd_pcm_channel_info *info = arg;
1749 struct snd_pcm_runtime *runtime = substream->runtime;
1750 int width;
1751 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
1752 info->offset = -1;
1753 return 0;
1754 }
1755 width = snd_pcm_format_physical_width(runtime->format);
1756 if (width < 0)
1757 return width;
1758 info->offset = 0;
1759 switch (runtime->access) {
1760 case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
1761 case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
1762 info->first = info->channel * width;
1763 info->step = runtime->channels * width;
1764 break;
1765 case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
1766 case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
1767 {
1768 size_t size = runtime->dma_bytes / runtime->channels;
1769 info->first = info->channel * size * 8;
1770 info->step = width;
1771 break;
1772 }
1773 default:
1774 snd_BUG();
1775 break;
1776 }
1777 return 0;
1778 }
1779
snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream * substream,void * arg)1780 static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
1781 void *arg)
1782 {
1783 struct snd_pcm_hw_params *params = arg;
1784 snd_pcm_format_t format;
1785 int channels, width;
1786
1787 params->fifo_size = substream->runtime->hw.fifo_size;
1788 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
1789 format = params_format(params);
1790 channels = params_channels(params);
1791 width = snd_pcm_format_physical_width(format);
1792 params->fifo_size /= width * channels;
1793 }
1794 return 0;
1795 }
1796
1797 /**
1798 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1799 * @substream: the pcm substream instance
1800 * @cmd: ioctl command
1801 * @arg: ioctl argument
1802 *
1803 * Processes the generic ioctl commands for PCM.
1804 * Can be passed as the ioctl callback for PCM ops.
1805 *
1806 * Return: Zero if successful, or a negative error code on failure.
1807 */
snd_pcm_lib_ioctl(struct snd_pcm_substream * substream,unsigned int cmd,void * arg)1808 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
1809 unsigned int cmd, void *arg)
1810 {
1811 switch (cmd) {
1812 case SNDRV_PCM_IOCTL1_INFO:
1813 return 0;
1814 case SNDRV_PCM_IOCTL1_RESET:
1815 return snd_pcm_lib_ioctl_reset(substream, arg);
1816 case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
1817 return snd_pcm_lib_ioctl_channel_info(substream, arg);
1818 case SNDRV_PCM_IOCTL1_FIFO_SIZE:
1819 return snd_pcm_lib_ioctl_fifo_size(substream, arg);
1820 }
1821 return -ENXIO;
1822 }
1823
1824 EXPORT_SYMBOL(snd_pcm_lib_ioctl);
1825
1826 /**
1827 * snd_pcm_period_elapsed - update the pcm status for the next period
1828 * @substream: the pcm substream instance
1829 *
1830 * This function is called from the interrupt handler when the
1831 * PCM has processed the period size. It will update the current
1832 * pointer, wake up sleepers, etc.
1833 *
1834 * Even if more than one periods have elapsed since the last call, you
1835 * have to call this only once.
1836 */
snd_pcm_period_elapsed(struct snd_pcm_substream * substream)1837 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
1838 {
1839 struct snd_pcm_runtime *runtime;
1840 unsigned long flags;
1841
1842 if (PCM_RUNTIME_CHECK(substream))
1843 return;
1844 runtime = substream->runtime;
1845
1846 if (runtime->transfer_ack_begin)
1847 runtime->transfer_ack_begin(substream);
1848
1849 snd_pcm_stream_lock_irqsave(substream, flags);
1850 if (!snd_pcm_running(substream) ||
1851 snd_pcm_update_hw_ptr0(substream, 1) < 0)
1852 goto _end;
1853
1854 if (substream->timer_running)
1855 snd_timer_interrupt(substream->timer, 1);
1856 _end:
1857 kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
1858 snd_pcm_stream_unlock_irqrestore(substream, flags);
1859 if (runtime->transfer_ack_end)
1860 runtime->transfer_ack_end(substream);
1861 }
1862
1863 EXPORT_SYMBOL(snd_pcm_period_elapsed);
1864
1865 /*
1866 * Wait until avail_min data becomes available
1867 * Returns a negative error code if any error occurs during operation.
1868 * The available space is stored on availp. When err = 0 and avail = 0
1869 * on the capture stream, it indicates the stream is in DRAINING state.
1870 */
wait_for_avail(struct snd_pcm_substream * substream,snd_pcm_uframes_t * availp)1871 static int wait_for_avail(struct snd_pcm_substream *substream,
1872 snd_pcm_uframes_t *availp)
1873 {
1874 struct snd_pcm_runtime *runtime = substream->runtime;
1875 int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
1876 wait_queue_t wait;
1877 int err = 0;
1878 snd_pcm_uframes_t avail = 0;
1879 long wait_time, tout;
1880
1881 init_waitqueue_entry(&wait, current);
1882 set_current_state(TASK_INTERRUPTIBLE);
1883 add_wait_queue(&runtime->tsleep, &wait);
1884
1885 if (runtime->no_period_wakeup)
1886 wait_time = MAX_SCHEDULE_TIMEOUT;
1887 else {
1888 wait_time = 10;
1889 if (runtime->rate) {
1890 long t = runtime->period_size * 2 / runtime->rate;
1891 wait_time = max(t, wait_time);
1892 }
1893 wait_time = msecs_to_jiffies(wait_time * 1000);
1894 }
1895
1896 for (;;) {
1897 if (signal_pending(current)) {
1898 err = -ERESTARTSYS;
1899 break;
1900 }
1901
1902 /*
1903 * We need to check if space became available already
1904 * (and thus the wakeup happened already) first to close
1905 * the race of space already having become available.
1906 * This check must happen after been added to the waitqueue
1907 * and having current state be INTERRUPTIBLE.
1908 */
1909 if (is_playback)
1910 avail = snd_pcm_playback_avail(runtime);
1911 else
1912 avail = snd_pcm_capture_avail(runtime);
1913 if (avail >= runtime->twake)
1914 break;
1915 snd_pcm_stream_unlock_irq(substream);
1916
1917 tout = schedule_timeout(wait_time);
1918
1919 snd_pcm_stream_lock_irq(substream);
1920 set_current_state(TASK_INTERRUPTIBLE);
1921 switch (runtime->status->state) {
1922 case SNDRV_PCM_STATE_SUSPENDED:
1923 err = -ESTRPIPE;
1924 goto _endloop;
1925 case SNDRV_PCM_STATE_XRUN:
1926 err = -EPIPE;
1927 goto _endloop;
1928 case SNDRV_PCM_STATE_DRAINING:
1929 if (is_playback)
1930 err = -EPIPE;
1931 else
1932 avail = 0; /* indicate draining */
1933 goto _endloop;
1934 case SNDRV_PCM_STATE_OPEN:
1935 case SNDRV_PCM_STATE_SETUP:
1936 case SNDRV_PCM_STATE_DISCONNECTED:
1937 err = -EBADFD;
1938 goto _endloop;
1939 }
1940 if (!tout) {
1941 snd_printd("%s write error (DMA or IRQ trouble?)\n",
1942 is_playback ? "playback" : "capture");
1943 err = -EIO;
1944 break;
1945 }
1946 }
1947 _endloop:
1948 set_current_state(TASK_RUNNING);
1949 remove_wait_queue(&runtime->tsleep, &wait);
1950 *availp = avail;
1951 return err;
1952 }
1953
snd_pcm_lib_write_transfer(struct snd_pcm_substream * substream,unsigned int hwoff,unsigned long data,unsigned int off,snd_pcm_uframes_t frames)1954 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
1955 unsigned int hwoff,
1956 unsigned long data, unsigned int off,
1957 snd_pcm_uframes_t frames)
1958 {
1959 struct snd_pcm_runtime *runtime = substream->runtime;
1960 int err;
1961 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1962 if (substream->ops->copy) {
1963 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1964 return err;
1965 } else {
1966 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1967 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1968 return -EFAULT;
1969 }
1970 return 0;
1971 }
1972
1973 typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
1974 unsigned long data, unsigned int off,
1975 snd_pcm_uframes_t size);
1976
snd_pcm_lib_write1(struct snd_pcm_substream * substream,unsigned long data,snd_pcm_uframes_t size,int nonblock,transfer_f transfer)1977 static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
1978 unsigned long data,
1979 snd_pcm_uframes_t size,
1980 int nonblock,
1981 transfer_f transfer)
1982 {
1983 struct snd_pcm_runtime *runtime = substream->runtime;
1984 snd_pcm_uframes_t xfer = 0;
1985 snd_pcm_uframes_t offset = 0;
1986 snd_pcm_uframes_t avail;
1987 int err = 0;
1988
1989 if (size == 0)
1990 return 0;
1991
1992 snd_pcm_stream_lock_irq(substream);
1993 switch (runtime->status->state) {
1994 case SNDRV_PCM_STATE_PREPARED:
1995 case SNDRV_PCM_STATE_RUNNING:
1996 case SNDRV_PCM_STATE_PAUSED:
1997 break;
1998 case SNDRV_PCM_STATE_XRUN:
1999 err = -EPIPE;
2000 goto _end_unlock;
2001 case SNDRV_PCM_STATE_SUSPENDED:
2002 err = -ESTRPIPE;
2003 goto _end_unlock;
2004 default:
2005 err = -EBADFD;
2006 goto _end_unlock;
2007 }
2008
2009 runtime->twake = runtime->control->avail_min ? : 1;
2010 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
2011 snd_pcm_update_hw_ptr(substream);
2012 avail = snd_pcm_playback_avail(runtime);
2013 while (size > 0) {
2014 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
2015 snd_pcm_uframes_t cont;
2016 if (!avail) {
2017 if (nonblock) {
2018 err = -EAGAIN;
2019 goto _end_unlock;
2020 }
2021 runtime->twake = min_t(snd_pcm_uframes_t, size,
2022 runtime->control->avail_min ? : 1);
2023 err = wait_for_avail(substream, &avail);
2024 if (err < 0)
2025 goto _end_unlock;
2026 }
2027 frames = size > avail ? avail : size;
2028 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2029 if (frames > cont)
2030 frames = cont;
2031 if (snd_BUG_ON(!frames)) {
2032 runtime->twake = 0;
2033 snd_pcm_stream_unlock_irq(substream);
2034 return -EINVAL;
2035 }
2036 appl_ptr = runtime->control->appl_ptr;
2037 appl_ofs = appl_ptr % runtime->buffer_size;
2038 snd_pcm_stream_unlock_irq(substream);
2039 err = transfer(substream, appl_ofs, data, offset, frames);
2040 snd_pcm_stream_lock_irq(substream);
2041 if (err < 0)
2042 goto _end_unlock;
2043 switch (runtime->status->state) {
2044 case SNDRV_PCM_STATE_XRUN:
2045 err = -EPIPE;
2046 goto _end_unlock;
2047 case SNDRV_PCM_STATE_SUSPENDED:
2048 err = -ESTRPIPE;
2049 goto _end_unlock;
2050 default:
2051 break;
2052 }
2053 appl_ptr += frames;
2054 if (appl_ptr >= runtime->boundary)
2055 appl_ptr -= runtime->boundary;
2056 runtime->control->appl_ptr = appl_ptr;
2057 if (substream->ops->ack)
2058 substream->ops->ack(substream);
2059
2060 offset += frames;
2061 size -= frames;
2062 xfer += frames;
2063 avail -= frames;
2064 if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
2065 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
2066 err = snd_pcm_start(substream);
2067 if (err < 0)
2068 goto _end_unlock;
2069 }
2070 }
2071 _end_unlock:
2072 runtime->twake = 0;
2073 if (xfer > 0 && err >= 0)
2074 snd_pcm_update_state(substream, runtime);
2075 snd_pcm_stream_unlock_irq(substream);
2076 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2077 }
2078
2079 /* sanity-check for read/write methods */
pcm_sanity_check(struct snd_pcm_substream * substream)2080 static int pcm_sanity_check(struct snd_pcm_substream *substream)
2081 {
2082 struct snd_pcm_runtime *runtime;
2083 if (PCM_RUNTIME_CHECK(substream))
2084 return -ENXIO;
2085 runtime = substream->runtime;
2086 if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
2087 return -EINVAL;
2088 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2089 return -EBADFD;
2090 return 0;
2091 }
2092
snd_pcm_lib_write(struct snd_pcm_substream * substream,const void __user * buf,snd_pcm_uframes_t size)2093 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
2094 {
2095 struct snd_pcm_runtime *runtime;
2096 int nonblock;
2097 int err;
2098
2099 err = pcm_sanity_check(substream);
2100 if (err < 0)
2101 return err;
2102 runtime = substream->runtime;
2103 nonblock = !!(substream->f_flags & O_NONBLOCK);
2104
2105 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
2106 runtime->channels > 1)
2107 return -EINVAL;
2108 return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
2109 snd_pcm_lib_write_transfer);
2110 }
2111
2112 EXPORT_SYMBOL(snd_pcm_lib_write);
2113
snd_pcm_lib_writev_transfer(struct snd_pcm_substream * substream,unsigned int hwoff,unsigned long data,unsigned int off,snd_pcm_uframes_t frames)2114 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
2115 unsigned int hwoff,
2116 unsigned long data, unsigned int off,
2117 snd_pcm_uframes_t frames)
2118 {
2119 struct snd_pcm_runtime *runtime = substream->runtime;
2120 int err;
2121 void __user **bufs = (void __user **)data;
2122 int channels = runtime->channels;
2123 int c;
2124 if (substream->ops->copy) {
2125 if (snd_BUG_ON(!substream->ops->silence))
2126 return -EINVAL;
2127 for (c = 0; c < channels; ++c, ++bufs) {
2128 if (*bufs == NULL) {
2129 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
2130 return err;
2131 } else {
2132 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2133 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2134 return err;
2135 }
2136 }
2137 } else {
2138 /* default transfer behaviour */
2139 size_t dma_csize = runtime->dma_bytes / channels;
2140 for (c = 0; c < channels; ++c, ++bufs) {
2141 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2142 if (*bufs == NULL) {
2143 snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
2144 } else {
2145 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2146 if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
2147 return -EFAULT;
2148 }
2149 }
2150 }
2151 return 0;
2152 }
2153
snd_pcm_lib_writev(struct snd_pcm_substream * substream,void __user ** bufs,snd_pcm_uframes_t frames)2154 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
2155 void __user **bufs,
2156 snd_pcm_uframes_t frames)
2157 {
2158 struct snd_pcm_runtime *runtime;
2159 int nonblock;
2160 int err;
2161
2162 err = pcm_sanity_check(substream);
2163 if (err < 0)
2164 return err;
2165 runtime = substream->runtime;
2166 nonblock = !!(substream->f_flags & O_NONBLOCK);
2167
2168 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2169 return -EINVAL;
2170 return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
2171 nonblock, snd_pcm_lib_writev_transfer);
2172 }
2173
2174 EXPORT_SYMBOL(snd_pcm_lib_writev);
2175
snd_pcm_lib_read_transfer(struct snd_pcm_substream * substream,unsigned int hwoff,unsigned long data,unsigned int off,snd_pcm_uframes_t frames)2176 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
2177 unsigned int hwoff,
2178 unsigned long data, unsigned int off,
2179 snd_pcm_uframes_t frames)
2180 {
2181 struct snd_pcm_runtime *runtime = substream->runtime;
2182 int err;
2183 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
2184 if (substream->ops->copy) {
2185 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
2186 return err;
2187 } else {
2188 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
2189 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
2190 return -EFAULT;
2191 }
2192 return 0;
2193 }
2194
snd_pcm_lib_read1(struct snd_pcm_substream * substream,unsigned long data,snd_pcm_uframes_t size,int nonblock,transfer_f transfer)2195 static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
2196 unsigned long data,
2197 snd_pcm_uframes_t size,
2198 int nonblock,
2199 transfer_f transfer)
2200 {
2201 struct snd_pcm_runtime *runtime = substream->runtime;
2202 snd_pcm_uframes_t xfer = 0;
2203 snd_pcm_uframes_t offset = 0;
2204 snd_pcm_uframes_t avail;
2205 int err = 0;
2206
2207 if (size == 0)
2208 return 0;
2209
2210 snd_pcm_stream_lock_irq(substream);
2211 switch (runtime->status->state) {
2212 case SNDRV_PCM_STATE_PREPARED:
2213 if (size >= runtime->start_threshold) {
2214 err = snd_pcm_start(substream);
2215 if (err < 0)
2216 goto _end_unlock;
2217 }
2218 break;
2219 case SNDRV_PCM_STATE_DRAINING:
2220 case SNDRV_PCM_STATE_RUNNING:
2221 case SNDRV_PCM_STATE_PAUSED:
2222 break;
2223 case SNDRV_PCM_STATE_XRUN:
2224 err = -EPIPE;
2225 goto _end_unlock;
2226 case SNDRV_PCM_STATE_SUSPENDED:
2227 err = -ESTRPIPE;
2228 goto _end_unlock;
2229 default:
2230 err = -EBADFD;
2231 goto _end_unlock;
2232 }
2233
2234 runtime->twake = runtime->control->avail_min ? : 1;
2235 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
2236 snd_pcm_update_hw_ptr(substream);
2237 avail = snd_pcm_capture_avail(runtime);
2238 while (size > 0) {
2239 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
2240 snd_pcm_uframes_t cont;
2241 if (!avail) {
2242 if (runtime->status->state ==
2243 SNDRV_PCM_STATE_DRAINING) {
2244 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
2245 goto _end_unlock;
2246 }
2247 if (nonblock) {
2248 err = -EAGAIN;
2249 goto _end_unlock;
2250 }
2251 runtime->twake = min_t(snd_pcm_uframes_t, size,
2252 runtime->control->avail_min ? : 1);
2253 err = wait_for_avail(substream, &avail);
2254 if (err < 0)
2255 goto _end_unlock;
2256 if (!avail)
2257 continue; /* draining */
2258 }
2259 frames = size > avail ? avail : size;
2260 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2261 if (frames > cont)
2262 frames = cont;
2263 if (snd_BUG_ON(!frames)) {
2264 runtime->twake = 0;
2265 snd_pcm_stream_unlock_irq(substream);
2266 return -EINVAL;
2267 }
2268 appl_ptr = runtime->control->appl_ptr;
2269 appl_ofs = appl_ptr % runtime->buffer_size;
2270 snd_pcm_stream_unlock_irq(substream);
2271 err = transfer(substream, appl_ofs, data, offset, frames);
2272 snd_pcm_stream_lock_irq(substream);
2273 if (err < 0)
2274 goto _end_unlock;
2275 switch (runtime->status->state) {
2276 case SNDRV_PCM_STATE_XRUN:
2277 err = -EPIPE;
2278 goto _end_unlock;
2279 case SNDRV_PCM_STATE_SUSPENDED:
2280 err = -ESTRPIPE;
2281 goto _end_unlock;
2282 default:
2283 break;
2284 }
2285 appl_ptr += frames;
2286 if (appl_ptr >= runtime->boundary)
2287 appl_ptr -= runtime->boundary;
2288 runtime->control->appl_ptr = appl_ptr;
2289 if (substream->ops->ack)
2290 substream->ops->ack(substream);
2291
2292 offset += frames;
2293 size -= frames;
2294 xfer += frames;
2295 avail -= frames;
2296 }
2297 _end_unlock:
2298 runtime->twake = 0;
2299 if (xfer > 0 && err >= 0)
2300 snd_pcm_update_state(substream, runtime);
2301 snd_pcm_stream_unlock_irq(substream);
2302 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2303 }
2304
snd_pcm_lib_read(struct snd_pcm_substream * substream,void __user * buf,snd_pcm_uframes_t size)2305 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
2306 {
2307 struct snd_pcm_runtime *runtime;
2308 int nonblock;
2309 int err;
2310
2311 err = pcm_sanity_check(substream);
2312 if (err < 0)
2313 return err;
2314 runtime = substream->runtime;
2315 nonblock = !!(substream->f_flags & O_NONBLOCK);
2316 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
2317 return -EINVAL;
2318 return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
2319 }
2320
2321 EXPORT_SYMBOL(snd_pcm_lib_read);
2322
snd_pcm_lib_readv_transfer(struct snd_pcm_substream * substream,unsigned int hwoff,unsigned long data,unsigned int off,snd_pcm_uframes_t frames)2323 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
2324 unsigned int hwoff,
2325 unsigned long data, unsigned int off,
2326 snd_pcm_uframes_t frames)
2327 {
2328 struct snd_pcm_runtime *runtime = substream->runtime;
2329 int err;
2330 void __user **bufs = (void __user **)data;
2331 int channels = runtime->channels;
2332 int c;
2333 if (substream->ops->copy) {
2334 for (c = 0; c < channels; ++c, ++bufs) {
2335 char __user *buf;
2336 if (*bufs == NULL)
2337 continue;
2338 buf = *bufs + samples_to_bytes(runtime, off);
2339 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2340 return err;
2341 }
2342 } else {
2343 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
2344 for (c = 0; c < channels; ++c, ++bufs) {
2345 char *hwbuf;
2346 char __user *buf;
2347 if (*bufs == NULL)
2348 continue;
2349
2350 hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2351 buf = *bufs + samples_to_bytes(runtime, off);
2352 if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
2353 return -EFAULT;
2354 }
2355 }
2356 return 0;
2357 }
2358
snd_pcm_lib_readv(struct snd_pcm_substream * substream,void __user ** bufs,snd_pcm_uframes_t frames)2359 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
2360 void __user **bufs,
2361 snd_pcm_uframes_t frames)
2362 {
2363 struct snd_pcm_runtime *runtime;
2364 int nonblock;
2365 int err;
2366
2367 err = pcm_sanity_check(substream);
2368 if (err < 0)
2369 return err;
2370 runtime = substream->runtime;
2371 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2372 return -EBADFD;
2373
2374 nonblock = !!(substream->f_flags & O_NONBLOCK);
2375 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2376 return -EINVAL;
2377 return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
2378 }
2379
2380 EXPORT_SYMBOL(snd_pcm_lib_readv);
2381
2382 /*
2383 * standard channel mapping helpers
2384 */
2385
2386 /* default channel maps for multi-channel playbacks, up to 8 channels */
2387 const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[] = {
2388 { .channels = 1,
2389 .map = { SNDRV_CHMAP_MONO } },
2390 { .channels = 2,
2391 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2392 { .channels = 4,
2393 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2394 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2395 { .channels = 6,
2396 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2397 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2398 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
2399 { .channels = 8,
2400 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2401 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2402 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2403 SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2404 { }
2405 };
2406 EXPORT_SYMBOL_GPL(snd_pcm_std_chmaps);
2407
2408 /* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2409 const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[] = {
2410 { .channels = 1,
2411 .map = { SNDRV_CHMAP_MONO } },
2412 { .channels = 2,
2413 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2414 { .channels = 4,
2415 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2416 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2417 { .channels = 6,
2418 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2419 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2420 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2421 { .channels = 8,
2422 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2423 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2424 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2425 SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2426 { }
2427 };
2428 EXPORT_SYMBOL_GPL(snd_pcm_alt_chmaps);
2429
valid_chmap_channels(const struct snd_pcm_chmap * info,int ch)2430 static bool valid_chmap_channels(const struct snd_pcm_chmap *info, int ch)
2431 {
2432 if (ch > info->max_channels)
2433 return false;
2434 return !info->channel_mask || (info->channel_mask & (1U << ch));
2435 }
2436
pcm_chmap_ctl_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2437 static int pcm_chmap_ctl_info(struct snd_kcontrol *kcontrol,
2438 struct snd_ctl_elem_info *uinfo)
2439 {
2440 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2441
2442 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2443 uinfo->count = 0;
2444 uinfo->count = info->max_channels;
2445 uinfo->value.integer.min = 0;
2446 uinfo->value.integer.max = SNDRV_CHMAP_LAST;
2447 return 0;
2448 }
2449
2450 /* get callback for channel map ctl element
2451 * stores the channel position firstly matching with the current channels
2452 */
pcm_chmap_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2453 static int pcm_chmap_ctl_get(struct snd_kcontrol *kcontrol,
2454 struct snd_ctl_elem_value *ucontrol)
2455 {
2456 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2457 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2458 struct snd_pcm_substream *substream;
2459 const struct snd_pcm_chmap_elem *map;
2460
2461 if (snd_BUG_ON(!info->chmap))
2462 return -EINVAL;
2463 substream = snd_pcm_chmap_substream(info, idx);
2464 if (!substream)
2465 return -ENODEV;
2466 memset(ucontrol->value.integer.value, 0,
2467 sizeof(ucontrol->value.integer.value));
2468 if (!substream->runtime)
2469 return 0; /* no channels set */
2470 for (map = info->chmap; map->channels; map++) {
2471 int i;
2472 if (map->channels == substream->runtime->channels &&
2473 valid_chmap_channels(info, map->channels)) {
2474 for (i = 0; i < map->channels; i++)
2475 ucontrol->value.integer.value[i] = map->map[i];
2476 return 0;
2477 }
2478 }
2479 return -EINVAL;
2480 }
2481
2482 /* tlv callback for channel map ctl element
2483 * expands the pre-defined channel maps in a form of TLV
2484 */
pcm_chmap_ctl_tlv(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * tlv)2485 static int pcm_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2486 unsigned int size, unsigned int __user *tlv)
2487 {
2488 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2489 const struct snd_pcm_chmap_elem *map;
2490 unsigned int __user *dst;
2491 int c, count = 0;
2492
2493 if (snd_BUG_ON(!info->chmap))
2494 return -EINVAL;
2495 if (size < 8)
2496 return -ENOMEM;
2497 if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
2498 return -EFAULT;
2499 size -= 8;
2500 dst = tlv + 2;
2501 for (map = info->chmap; map->channels; map++) {
2502 int chs_bytes = map->channels * 4;
2503 if (!valid_chmap_channels(info, map->channels))
2504 continue;
2505 if (size < 8)
2506 return -ENOMEM;
2507 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||
2508 put_user(chs_bytes, dst + 1))
2509 return -EFAULT;
2510 dst += 2;
2511 size -= 8;
2512 count += 8;
2513 if (size < chs_bytes)
2514 return -ENOMEM;
2515 size -= chs_bytes;
2516 count += chs_bytes;
2517 for (c = 0; c < map->channels; c++) {
2518 if (put_user(map->map[c], dst))
2519 return -EFAULT;
2520 dst++;
2521 }
2522 }
2523 if (put_user(count, tlv + 1))
2524 return -EFAULT;
2525 return 0;
2526 }
2527
pcm_chmap_ctl_private_free(struct snd_kcontrol * kcontrol)2528 static void pcm_chmap_ctl_private_free(struct snd_kcontrol *kcontrol)
2529 {
2530 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2531 info->pcm->streams[info->stream].chmap_kctl = NULL;
2532 kfree(info);
2533 }
2534
2535 /**
2536 * snd_pcm_add_chmap_ctls - create channel-mapping control elements
2537 * @pcm: the assigned PCM instance
2538 * @stream: stream direction
2539 * @chmap: channel map elements (for query)
2540 * @max_channels: the max number of channels for the stream
2541 * @private_value: the value passed to each kcontrol's private_value field
2542 * @info_ret: store struct snd_pcm_chmap instance if non-NULL
2543 *
2544 * Create channel-mapping control elements assigned to the given PCM stream(s).
2545 * Return: Zero if successful, or a negative error value.
2546 */
snd_pcm_add_chmap_ctls(struct snd_pcm * pcm,int stream,const struct snd_pcm_chmap_elem * chmap,int max_channels,unsigned long private_value,struct snd_pcm_chmap ** info_ret)2547 int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
2548 const struct snd_pcm_chmap_elem *chmap,
2549 int max_channels,
2550 unsigned long private_value,
2551 struct snd_pcm_chmap **info_ret)
2552 {
2553 struct snd_pcm_chmap *info;
2554 struct snd_kcontrol_new knew = {
2555 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2556 .access = SNDRV_CTL_ELEM_ACCESS_READ |
2557 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2558 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
2559 .info = pcm_chmap_ctl_info,
2560 .get = pcm_chmap_ctl_get,
2561 .tlv.c = pcm_chmap_ctl_tlv,
2562 };
2563 int err;
2564
2565 info = kzalloc(sizeof(*info), GFP_KERNEL);
2566 if (!info)
2567 return -ENOMEM;
2568 info->pcm = pcm;
2569 info->stream = stream;
2570 info->chmap = chmap;
2571 info->max_channels = max_channels;
2572 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2573 knew.name = "Playback Channel Map";
2574 else
2575 knew.name = "Capture Channel Map";
2576 knew.device = pcm->device;
2577 knew.count = pcm->streams[stream].substream_count;
2578 knew.private_value = private_value;
2579 info->kctl = snd_ctl_new1(&knew, info);
2580 if (!info->kctl) {
2581 kfree(info);
2582 return -ENOMEM;
2583 }
2584 info->kctl->private_free = pcm_chmap_ctl_private_free;
2585 err = snd_ctl_add(pcm->card, info->kctl);
2586 if (err < 0)
2587 return err;
2588 pcm->streams[stream].chmap_kctl = info->kctl;
2589 if (info_ret)
2590 *info_ret = info;
2591 return 0;
2592 }
2593 EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls);
2594