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