blob: 62e90b862a0ddd2a1b7a0c49d34e76686a13b869 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Digital Audio (PCM) abstract layer
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02003 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/slab.h>
24#include <linux/time.h>
Takashi Iwai3f7440a2009-06-05 17:40:04 +020025#include <linux/math64.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <sound/core.h>
27#include <sound/control.h>
28#include <sound/info.h>
29#include <sound/pcm.h>
30#include <sound/pcm_params.h>
31#include <sound/timer.h>
32
33/*
34 * fill ring buffer with silence
35 * runtime->silence_start: starting pointer to silence area
36 * runtime->silence_filled: size filled with silence
37 * runtime->silence_threshold: threshold from application
38 * runtime->silence_size: maximal size from application
39 *
40 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
41 */
Takashi Iwai877211f2005-11-17 13:59:38 +010042void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
Takashi Iwai877211f2005-11-17 13:59:38 +010044 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 snd_pcm_uframes_t frames, ofs, transfer;
46
47 if (runtime->silence_size < runtime->boundary) {
48 snd_pcm_sframes_t noise_dist, n;
49 if (runtime->silence_start != runtime->control->appl_ptr) {
50 n = runtime->control->appl_ptr - runtime->silence_start;
51 if (n < 0)
52 n += runtime->boundary;
53 if ((snd_pcm_uframes_t)n < runtime->silence_filled)
54 runtime->silence_filled -= n;
55 else
56 runtime->silence_filled = 0;
57 runtime->silence_start = runtime->control->appl_ptr;
58 }
Takashi Iwai235475c2005-12-07 15:28:07 +010059 if (runtime->silence_filled >= runtime->buffer_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
62 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
63 return;
64 frames = runtime->silence_threshold - noise_dist;
65 if (frames > runtime->silence_size)
66 frames = runtime->silence_size;
67 } else {
68 if (new_hw_ptr == ULONG_MAX) { /* initialization */
69 snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
Jaroslav Kysela9e216e82010-07-19 16:37:39 +020070 if (avail > runtime->buffer_size)
71 avail = runtime->buffer_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 runtime->silence_filled = avail > 0 ? avail : 0;
73 runtime->silence_start = (runtime->status->hw_ptr +
74 runtime->silence_filled) %
75 runtime->boundary;
76 } else {
77 ofs = runtime->status->hw_ptr;
78 frames = new_hw_ptr - ofs;
79 if ((snd_pcm_sframes_t)frames < 0)
80 frames += runtime->boundary;
81 runtime->silence_filled -= frames;
82 if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
83 runtime->silence_filled = 0;
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020084 runtime->silence_start = new_hw_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 } else {
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020086 runtime->silence_start = ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 }
89 frames = runtime->buffer_size - runtime->silence_filled;
90 }
Takashi Iwai7eaa9432008-08-08 17:09:09 +020091 if (snd_BUG_ON(frames > runtime->buffer_size))
92 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 if (frames == 0)
94 return;
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020095 ofs = runtime->silence_start % runtime->buffer_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 while (frames > 0) {
97 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
98 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
99 runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
100 if (substream->ops->silence) {
101 int err;
102 err = substream->ops->silence(substream, -1, ofs, transfer);
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200103 snd_BUG_ON(err < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 } else {
105 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
106 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
107 }
108 } else {
109 unsigned int c;
110 unsigned int channels = runtime->channels;
111 if (substream->ops->silence) {
112 for (c = 0; c < channels; ++c) {
113 int err;
114 err = substream->ops->silence(substream, c, ofs, transfer);
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200115 snd_BUG_ON(err < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 }
117 } else {
118 size_t dma_csize = runtime->dma_bytes / channels;
119 for (c = 0; c < channels; ++c) {
120 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
121 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
122 }
123 }
124 }
125 runtime->silence_filled += transfer;
126 frames -= transfer;
127 ofs = 0;
128 }
129}
130
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200131#ifdef CONFIG_SND_DEBUG
132void snd_pcm_debug_name(struct snd_pcm_substream *substream,
Takashi Iwaic0070112009-06-08 15:58:48 +0200133 char *name, size_t len)
134{
135 snprintf(name, len, "pcmC%dD%d%c:%d",
136 substream->pcm->card->number,
137 substream->pcm->device,
138 substream->stream ? 'c' : 'p',
139 substream->number);
140}
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200141EXPORT_SYMBOL(snd_pcm_debug_name);
142#endif
Takashi Iwaic0070112009-06-08 15:58:48 +0200143
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100144#define XRUN_DEBUG_BASIC (1<<0)
145#define XRUN_DEBUG_STACK (1<<1) /* dump also stack */
146#define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */
147#define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */
148#define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */
149#define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */
150#define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */
151
152#ifdef CONFIG_SND_PCM_XRUN_DEBUG
153
154#define xrun_debug(substream, mask) \
155 ((substream)->pstr->xrun_debug & (mask))
Jarkko Nikula0f170142010-03-26 16:07:25 +0200156#else
157#define xrun_debug(substream, mask) 0
158#endif
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100159
160#define dump_stack_on_xrun(substream) do { \
161 if (xrun_debug(substream, XRUN_DEBUG_STACK)) \
162 dump_stack(); \
163 } while (0)
164
Takashi Iwai877211f2005-11-17 13:59:38 +0100165static void xrun(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166{
Jaroslav Kysela13f040f2009-05-28 11:31:20 +0200167 struct snd_pcm_runtime *runtime = substream->runtime;
168
169 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
170 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
Jaroslav Kysela741b20c2009-12-17 17:34:39 +0100172 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
Takashi Iwaic0070112009-06-08 15:58:48 +0200173 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200174 snd_pcm_debug_name(substream, name, sizeof(name));
Takashi Iwaic0070112009-06-08 15:58:48 +0200175 snd_printd(KERN_DEBUG "XRUN: %s\n", name);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100176 dump_stack_on_xrun(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
Jarkko Nikula0f170142010-03-26 16:07:25 +0200180#ifdef CONFIG_SND_PCM_XRUN_DEBUG
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100181#define hw_ptr_error(substream, fmt, args...) \
182 do { \
183 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100184 xrun_log_show(substream); \
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100185 if (printk_ratelimit()) { \
186 snd_printd("PCM: " fmt, ##args); \
187 } \
188 dump_stack_on_xrun(substream); \
189 } \
190 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100192#define XRUN_LOG_CNT 10
193
194struct hwptr_log_entry {
Ben Gardinerec08b142011-05-18 10:03:34 -0400195 unsigned int in_interrupt;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100196 unsigned long jiffies;
197 snd_pcm_uframes_t pos;
198 snd_pcm_uframes_t period_size;
199 snd_pcm_uframes_t buffer_size;
200 snd_pcm_uframes_t old_hw_ptr;
201 snd_pcm_uframes_t hw_ptr_base;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100202};
203
204struct snd_pcm_hwptr_log {
205 unsigned int idx;
206 unsigned int hit: 1;
207 struct hwptr_log_entry entries[XRUN_LOG_CNT];
208};
209
210static void xrun_log(struct snd_pcm_substream *substream,
Ben Gardinerec08b142011-05-18 10:03:34 -0400211 snd_pcm_uframes_t pos, int in_interrupt)
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100212{
213 struct snd_pcm_runtime *runtime = substream->runtime;
214 struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
215 struct hwptr_log_entry *entry;
216
217 if (log == NULL) {
218 log = kzalloc(sizeof(*log), GFP_ATOMIC);
219 if (log == NULL)
220 return;
221 runtime->hwptr_log = log;
222 } else {
223 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
224 return;
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200225 }
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100226 entry = &log->entries[log->idx];
Ben Gardinerec08b142011-05-18 10:03:34 -0400227 entry->in_interrupt = in_interrupt;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100228 entry->jiffies = jiffies;
229 entry->pos = pos;
230 entry->period_size = runtime->period_size;
Joe Perchesc80c1d52010-11-14 19:05:02 -0800231 entry->buffer_size = runtime->buffer_size;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100232 entry->old_hw_ptr = runtime->status->hw_ptr;
233 entry->hw_ptr_base = runtime->hw_ptr_base;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100234 log->idx = (log->idx + 1) % XRUN_LOG_CNT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100237static void xrun_log_show(struct snd_pcm_substream *substream)
238{
239 struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
240 struct hwptr_log_entry *entry;
241 char name[16];
242 unsigned int idx;
243 int cnt;
244
245 if (log == NULL)
246 return;
247 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
248 return;
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200249 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100250 for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
251 entry = &log->entries[idx];
252 if (entry->period_size == 0)
253 break;
Ben Gardinerec08b142011-05-18 10:03:34 -0400254 snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100255 "hwptr=%ld/%ld\n",
Ben Gardinerec08b142011-05-18 10:03:34 -0400256 name, entry->in_interrupt ? "[Q] " : "",
257 entry->jiffies,
258 (unsigned long)entry->pos,
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100259 (unsigned long)entry->period_size,
260 (unsigned long)entry->buffer_size,
261 (unsigned long)entry->old_hw_ptr,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100262 (unsigned long)entry->hw_ptr_base);
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100263 idx++;
264 idx %= XRUN_LOG_CNT;
265 }
266 log->hit = 1;
267}
268
269#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
270
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100271#define hw_ptr_error(substream, fmt, args...) do { } while (0)
Ben Gardiner217658f2011-05-18 23:52:38 -0400272#define xrun_log(substream, pos, in_interrupt) do { } while (0)
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100273#define xrun_log_show(substream) do { } while (0)
274
275#endif
276
Jaroslav Kysela12509322010-01-07 15:36:31 +0100277int snd_pcm_update_state(struct snd_pcm_substream *substream,
278 struct snd_pcm_runtime *runtime)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
280 snd_pcm_uframes_t avail;
281
282 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
283 avail = snd_pcm_playback_avail(runtime);
284 else
285 avail = snd_pcm_capture_avail(runtime);
286 if (avail > runtime->avail_max)
287 runtime->avail_max = avail;
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200288 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
289 if (avail >= runtime->buffer_size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 snd_pcm_drain_done(substream);
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200291 return -EPIPE;
292 }
293 } else {
294 if (avail >= runtime->stop_threshold) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 xrun(substream);
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200296 return -EPIPE;
297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 }
David Dillow5daeba32010-06-27 00:13:20 +0200299 if (runtime->twake) {
300 if (avail >= runtime->twake)
301 wake_up(&runtime->tsleep);
302 } else if (avail >= runtime->control->avail_min)
303 wake_up(&runtime->sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 return 0;
305}
306
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100307static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
308 unsigned int in_interrupt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Takashi Iwai877211f2005-11-17 13:59:38 +0100310 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 snd_pcm_uframes_t pos;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100312 snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200313 snd_pcm_sframes_t hdelta, delta;
314 unsigned long jdelta;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200316 old_hw_ptr = runtime->status->hw_ptr;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100317 pos = substream->ops->pointer(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 if (pos == SNDRV_PCM_POS_XRUN) {
319 xrun(substream);
320 return -EPIPE;
321 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100322 if (pos >= runtime->buffer_size) {
323 if (printk_ratelimit()) {
324 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200325 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100326 xrun_log_show(substream);
327 snd_printd(KERN_ERR "BUG: %s, pos = %ld, "
328 "buffer size = %ld, period size = %ld\n",
329 name, pos, runtime->buffer_size,
330 runtime->period_size);
331 }
332 pos = 0;
Takashi Iwaicedb8112009-07-23 11:04:13 +0200333 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100334 pos -= pos % runtime->min_align;
335 if (xrun_debug(substream, XRUN_DEBUG_LOG))
Ben Gardinerec08b142011-05-18 10:03:34 -0400336 xrun_log(substream, pos, in_interrupt);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100337 hw_base = runtime->hw_ptr_base;
338 new_hw_ptr = hw_base + pos;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100339 if (in_interrupt) {
340 /* we know that one period was processed */
341 /* delta = "expected next hw_ptr" for in_interrupt != 0 */
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100342 delta = runtime->hw_ptr_interrupt + runtime->period_size;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100343 if (delta > new_hw_ptr) {
Jaroslav Kyselabd76af02010-08-18 14:16:54 +0200344 /* check for double acknowledged interrupts */
345 hdelta = jiffies - runtime->hw_ptr_jiffies;
346 if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
347 hw_base += runtime->buffer_size;
348 if (hw_base >= runtime->boundary)
349 hw_base = 0;
350 new_hw_ptr = hw_base + pos;
351 goto __delta;
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100355 /* new_hw_ptr might be lower than old_hw_ptr in case when */
356 /* pointer crosses the end of the ring buffer */
357 if (new_hw_ptr < old_hw_ptr) {
358 hw_base += runtime->buffer_size;
359 if (hw_base >= runtime->boundary)
360 hw_base = 0;
361 new_hw_ptr = hw_base + pos;
362 }
363 __delta:
Clemens Ladischb406e612010-05-25 09:01:46 +0200364 delta = new_hw_ptr - old_hw_ptr;
365 if (delta < 0)
366 delta += runtime->boundary;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100367 if (xrun_debug(substream, in_interrupt ?
368 XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
369 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200370 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100371 snd_printd("%s_update: %s: pos=%u/%u/%u, "
372 "hwptr=%ld/%ld/%ld/%ld\n",
373 in_interrupt ? "period" : "hwptr",
374 name,
375 (unsigned int)pos,
376 (unsigned int)runtime->period_size,
377 (unsigned int)runtime->buffer_size,
378 (unsigned long)delta,
379 (unsigned long)old_hw_ptr,
380 (unsigned long)new_hw_ptr,
381 (unsigned long)runtime->hw_ptr_base);
382 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100383
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100384 if (runtime->no_period_wakeup) {
Kelly Anderson12ff4142011-04-01 11:58:25 +0200385 snd_pcm_sframes_t xrun_threshold;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100386 /*
387 * Without regular period interrupts, we have to check
388 * the elapsed time to detect xruns.
389 */
390 jdelta = jiffies - runtime->hw_ptr_jiffies;
Clemens Ladisch47228e42010-11-18 09:53:07 +0100391 if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
392 goto no_delta_check;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100393 hdelta = jdelta - delta * HZ / runtime->rate;
Kelly Anderson12ff4142011-04-01 11:58:25 +0200394 xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
395 while (hdelta > xrun_threshold) {
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100396 delta += runtime->buffer_size;
397 hw_base += runtime->buffer_size;
398 if (hw_base >= runtime->boundary)
399 hw_base = 0;
400 new_hw_ptr = hw_base + pos;
401 hdelta -= runtime->hw_ptr_buffer_jiffies;
402 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100403 goto no_delta_check;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100404 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100405
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100406 /* something must be really wrong */
Jaroslav Kysela7b3a1772010-01-08 08:43:01 +0100407 if (delta >= runtime->buffer_size + runtime->period_size) {
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100408 hw_ptr_error(substream,
409 "Unexpected hw_pointer value %s"
410 "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
411 "old_hw_ptr=%ld)\n",
412 in_interrupt ? "[Q] " : "[P]",
413 substream->stream, (long)pos,
414 (long)new_hw_ptr, (long)old_hw_ptr);
415 return 0;
416 }
Takashi Iwaic87d9732009-05-27 10:53:33 +0200417
418 /* Do jiffies check only in xrun_debug mode */
Jaroslav Kysela741b20c2009-12-17 17:34:39 +0100419 if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
Takashi Iwaic87d9732009-05-27 10:53:33 +0200420 goto no_jiffies_check;
421
Takashi Iwai3e5b5012009-04-28 12:07:08 +0200422 /* Skip the jiffies check for hardwares with BATCH flag.
423 * Such hardware usually just increases the position at each IRQ,
424 * thus it can't give any strange position.
425 */
426 if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
427 goto no_jiffies_check;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100428 hdelta = delta;
Jaroslav Kyselaa4444da2009-05-28 12:31:56 +0200429 if (hdelta < runtime->delay)
430 goto no_jiffies_check;
431 hdelta -= runtime->delay;
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200432 jdelta = jiffies - runtime->hw_ptr_jiffies;
433 if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
434 delta = jdelta /
435 (((runtime->period_size * HZ) / runtime->rate)
436 + HZ/100);
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100437 /* move new_hw_ptr according jiffies not pos variable */
438 new_hw_ptr = old_hw_ptr;
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100439 hw_base = delta;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100440 /* use loop to avoid checks for delta overflows */
441 /* the delta value is small or zero in most cases */
442 while (delta > 0) {
443 new_hw_ptr += runtime->period_size;
444 if (new_hw_ptr >= runtime->boundary)
445 new_hw_ptr -= runtime->boundary;
446 delta--;
447 }
448 /* align hw_base to buffer_size */
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200449 hw_ptr_error(substream,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100450 "hw_ptr skipping! %s"
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200451 "(pos=%ld, delta=%ld, period=%ld, "
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100452 "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
453 in_interrupt ? "[Q] " : "",
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200454 (long)pos, (long)hdelta,
455 (long)runtime->period_size, jdelta,
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100456 ((hdelta * HZ) / runtime->rate), hw_base,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100457 (unsigned long)old_hw_ptr,
458 (unsigned long)new_hw_ptr);
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100459 /* reset values to proper state */
460 delta = 0;
461 hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200462 }
Takashi Iwai3e5b5012009-04-28 12:07:08 +0200463 no_jiffies_check:
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200464 if (delta > runtime->period_size + runtime->period_size / 2) {
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100465 hw_ptr_error(substream,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100466 "Lost interrupts? %s"
467 "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
468 "old_hw_ptr=%ld)\n",
469 in_interrupt ? "[Q] " : "",
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100470 substream->stream, (long)delta,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100471 (long)new_hw_ptr,
472 (long)old_hw_ptr);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100473 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100474
Clemens Ladischab69a492010-11-15 10:46:23 +0100475 no_delta_check:
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100476 if (runtime->status->hw_ptr == new_hw_ptr)
477 return 0;
Takashi Iwaiab1863f2009-06-07 12:09:17 +0200478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
480 runtime->silence_size > 0)
481 snd_pcm_playback_silence(substream, new_hw_ptr);
482
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100483 if (in_interrupt) {
Clemens Ladischead40462010-05-21 09:15:59 +0200484 delta = new_hw_ptr - runtime->hw_ptr_interrupt;
485 if (delta < 0)
486 delta += runtime->boundary;
487 delta -= (snd_pcm_uframes_t)delta % runtime->period_size;
488 runtime->hw_ptr_interrupt += delta;
489 if (runtime->hw_ptr_interrupt >= runtime->boundary)
490 runtime->hw_ptr_interrupt -= runtime->boundary;
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100491 }
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100492 runtime->hw_ptr_base = hw_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 runtime->status->hw_ptr = new_hw_ptr;
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200494 runtime->hw_ptr_jiffies = jiffies;
Jaroslav Kysela13f040f2009-05-28 11:31:20 +0200495 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
496 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Jaroslav Kysela12509322010-01-07 15:36:31 +0100498 return snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
501/* CAUTION: call it with irq disabled */
Takashi Iwai877211f2005-11-17 13:59:38 +0100502int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503{
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100504 return snd_pcm_update_hw_ptr0(substream, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505}
506
507/**
508 * snd_pcm_set_ops - set the PCM operators
509 * @pcm: the pcm instance
510 * @direction: stream direction, SNDRV_PCM_STREAM_XXX
511 * @ops: the operator table
512 *
513 * Sets the given PCM operators to the pcm instance.
514 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100515void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
Takashi Iwai877211f2005-11-17 13:59:38 +0100517 struct snd_pcm_str *stream = &pcm->streams[direction];
518 struct snd_pcm_substream *substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 for (substream = stream->substream; substream != NULL; substream = substream->next)
521 substream->ops = ops;
522}
523
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200524EXPORT_SYMBOL(snd_pcm_set_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526/**
527 * snd_pcm_sync - set the PCM sync id
528 * @substream: the pcm substream
529 *
530 * Sets the PCM sync identifier for the card.
531 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100532void snd_pcm_set_sync(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
Takashi Iwai877211f2005-11-17 13:59:38 +0100534 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
536 runtime->sync.id32[0] = substream->pcm->card->number;
537 runtime->sync.id32[1] = -1;
538 runtime->sync.id32[2] = -1;
539 runtime->sync.id32[3] = -1;
540}
541
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200542EXPORT_SYMBOL(snd_pcm_set_sync);
543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544/*
545 * Standard ioctl routine
546 */
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548static inline unsigned int div32(unsigned int a, unsigned int b,
549 unsigned int *r)
550{
551 if (b == 0) {
552 *r = 0;
553 return UINT_MAX;
554 }
555 *r = a % b;
556 return a / b;
557}
558
559static inline unsigned int div_down(unsigned int a, unsigned int b)
560{
561 if (b == 0)
562 return UINT_MAX;
563 return a / b;
564}
565
566static inline unsigned int div_up(unsigned int a, unsigned int b)
567{
568 unsigned int r;
569 unsigned int q;
570 if (b == 0)
571 return UINT_MAX;
572 q = div32(a, b, &r);
573 if (r)
574 ++q;
575 return q;
576}
577
578static inline unsigned int mul(unsigned int a, unsigned int b)
579{
580 if (a == 0)
581 return 0;
582 if (div_down(UINT_MAX, a) < b)
583 return UINT_MAX;
584 return a * b;
585}
586
587static inline unsigned int muldiv32(unsigned int a, unsigned int b,
588 unsigned int c, unsigned int *r)
589{
590 u_int64_t n = (u_int64_t) a * b;
591 if (c == 0) {
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200592 snd_BUG_ON(!n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 *r = 0;
594 return UINT_MAX;
595 }
Takashi Iwai3f7440a2009-06-05 17:40:04 +0200596 n = div_u64_rem(n, c, r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (n >= UINT_MAX) {
598 *r = 0;
599 return UINT_MAX;
600 }
601 return n;
602}
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604/**
605 * snd_interval_refine - refine the interval value of configurator
606 * @i: the interval value to refine
607 * @v: the interval value to refer to
608 *
609 * Refines the interval value with the reference value.
610 * The interval is changed to the range satisfying both intervals.
611 * The interval status (min, max, integer, etc.) are evaluated.
612 *
613 * Returns non-zero if the value is changed, zero if not changed.
614 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100615int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616{
617 int changed = 0;
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200618 if (snd_BUG_ON(snd_interval_empty(i)))
619 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 if (i->min < v->min) {
621 i->min = v->min;
622 i->openmin = v->openmin;
623 changed = 1;
624 } else if (i->min == v->min && !i->openmin && v->openmin) {
625 i->openmin = 1;
626 changed = 1;
627 }
628 if (i->max > v->max) {
629 i->max = v->max;
630 i->openmax = v->openmax;
631 changed = 1;
632 } else if (i->max == v->max && !i->openmax && v->openmax) {
633 i->openmax = 1;
634 changed = 1;
635 }
636 if (!i->integer && v->integer) {
637 i->integer = 1;
638 changed = 1;
639 }
640 if (i->integer) {
641 if (i->openmin) {
642 i->min++;
643 i->openmin = 0;
644 }
645 if (i->openmax) {
646 i->max--;
647 i->openmax = 0;
648 }
649 } else if (!i->openmin && !i->openmax && i->min == i->max)
650 i->integer = 1;
651 if (snd_interval_checkempty(i)) {
652 snd_interval_none(i);
653 return -EINVAL;
654 }
655 return changed;
656}
657
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200658EXPORT_SYMBOL(snd_interval_refine);
659
Takashi Iwai877211f2005-11-17 13:59:38 +0100660static int snd_interval_refine_first(struct snd_interval *i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200662 if (snd_BUG_ON(snd_interval_empty(i)))
663 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (snd_interval_single(i))
665 return 0;
666 i->max = i->min;
667 i->openmax = i->openmin;
668 if (i->openmax)
669 i->max++;
670 return 1;
671}
672
Takashi Iwai877211f2005-11-17 13:59:38 +0100673static int snd_interval_refine_last(struct snd_interval *i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200675 if (snd_BUG_ON(snd_interval_empty(i)))
676 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (snd_interval_single(i))
678 return 0;
679 i->min = i->max;
680 i->openmin = i->openmax;
681 if (i->openmin)
682 i->min--;
683 return 1;
684}
685
Takashi Iwai877211f2005-11-17 13:59:38 +0100686void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
688 if (a->empty || b->empty) {
689 snd_interval_none(c);
690 return;
691 }
692 c->empty = 0;
693 c->min = mul(a->min, b->min);
694 c->openmin = (a->openmin || b->openmin);
695 c->max = mul(a->max, b->max);
696 c->openmax = (a->openmax || b->openmax);
697 c->integer = (a->integer && b->integer);
698}
699
700/**
701 * snd_interval_div - refine the interval value with division
Takashi Iwaidf8db932005-09-07 13:38:19 +0200702 * @a: dividend
703 * @b: divisor
704 * @c: quotient
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 *
706 * c = a / b
707 *
708 * Returns non-zero if the value is changed, zero if not changed.
709 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100710void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
712 unsigned int r;
713 if (a->empty || b->empty) {
714 snd_interval_none(c);
715 return;
716 }
717 c->empty = 0;
718 c->min = div32(a->min, b->max, &r);
719 c->openmin = (r || a->openmin || b->openmax);
720 if (b->min > 0) {
721 c->max = div32(a->max, b->min, &r);
722 if (r) {
723 c->max++;
724 c->openmax = 1;
725 } else
726 c->openmax = (a->openmax || b->openmin);
727 } else {
728 c->max = UINT_MAX;
729 c->openmax = 0;
730 }
731 c->integer = 0;
732}
733
734/**
735 * snd_interval_muldivk - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200736 * @a: dividend 1
737 * @b: dividend 2
738 * @k: divisor (as integer)
739 * @c: result
740 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 * c = a * b / k
742 *
743 * Returns non-zero if the value is changed, zero if not changed.
744 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100745void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
746 unsigned int k, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
748 unsigned int r;
749 if (a->empty || b->empty) {
750 snd_interval_none(c);
751 return;
752 }
753 c->empty = 0;
754 c->min = muldiv32(a->min, b->min, k, &r);
755 c->openmin = (r || a->openmin || b->openmin);
756 c->max = muldiv32(a->max, b->max, k, &r);
757 if (r) {
758 c->max++;
759 c->openmax = 1;
760 } else
761 c->openmax = (a->openmax || b->openmax);
762 c->integer = 0;
763}
764
765/**
766 * snd_interval_mulkdiv - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200767 * @a: dividend 1
768 * @k: dividend 2 (as integer)
769 * @b: divisor
770 * @c: result
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 *
772 * c = a * k / b
773 *
774 * Returns non-zero if the value is changed, zero if not changed.
775 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100776void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
777 const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
779 unsigned int r;
780 if (a->empty || b->empty) {
781 snd_interval_none(c);
782 return;
783 }
784 c->empty = 0;
785 c->min = muldiv32(a->min, k, b->max, &r);
786 c->openmin = (r || a->openmin || b->openmax);
787 if (b->min > 0) {
788 c->max = muldiv32(a->max, k, b->min, &r);
789 if (r) {
790 c->max++;
791 c->openmax = 1;
792 } else
793 c->openmax = (a->openmax || b->openmin);
794 } else {
795 c->max = UINT_MAX;
796 c->openmax = 0;
797 }
798 c->integer = 0;
799}
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801/* ---- */
802
803
804/**
805 * snd_interval_ratnum - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200806 * @i: interval to refine
807 * @rats_count: number of ratnum_t
808 * @rats: ratnum_t array
809 * @nump: pointer to store the resultant numerator
810 * @denp: pointer to store the resultant denominator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 *
812 * Returns non-zero if the value is changed, zero if not changed.
813 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100814int snd_interval_ratnum(struct snd_interval *i,
815 unsigned int rats_count, struct snd_ratnum *rats,
816 unsigned int *nump, unsigned int *denp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817{
Krzysztof Helt8374e242009-12-21 17:07:08 +0100818 unsigned int best_num, best_den;
819 int best_diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 unsigned int k;
Takashi Iwai877211f2005-11-17 13:59:38 +0100821 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 int err;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100823 unsigned int result_num, result_den;
824 int result_diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 best_num = best_den = best_diff = 0;
827 for (k = 0; k < rats_count; ++k) {
828 unsigned int num = rats[k].num;
829 unsigned int den;
830 unsigned int q = i->min;
831 int diff;
832 if (q == 0)
833 q = 1;
Krzysztof Helt40962d72009-12-19 18:31:04 +0100834 den = div_up(num, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 if (den < rats[k].den_min)
836 continue;
837 if (den > rats[k].den_max)
838 den = rats[k].den_max;
839 else {
840 unsigned int r;
841 r = (den - rats[k].den_min) % rats[k].den_step;
842 if (r != 0)
843 den -= r;
844 }
845 diff = num - q * den;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100846 if (diff < 0)
847 diff = -diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 if (best_num == 0 ||
849 diff * best_den < best_diff * den) {
850 best_diff = diff;
851 best_den = den;
852 best_num = num;
853 }
854 }
855 if (best_den == 0) {
856 i->empty = 1;
857 return -EINVAL;
858 }
859 t.min = div_down(best_num, best_den);
860 t.openmin = !!(best_num % best_den);
861
Krzysztof Helt8374e242009-12-21 17:07:08 +0100862 result_num = best_num;
863 result_diff = best_diff;
864 result_den = best_den;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 best_num = best_den = best_diff = 0;
866 for (k = 0; k < rats_count; ++k) {
867 unsigned int num = rats[k].num;
868 unsigned int den;
869 unsigned int q = i->max;
870 int diff;
871 if (q == 0) {
872 i->empty = 1;
873 return -EINVAL;
874 }
Krzysztof Helt40962d72009-12-19 18:31:04 +0100875 den = div_down(num, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (den > rats[k].den_max)
877 continue;
878 if (den < rats[k].den_min)
879 den = rats[k].den_min;
880 else {
881 unsigned int r;
882 r = (den - rats[k].den_min) % rats[k].den_step;
883 if (r != 0)
884 den += rats[k].den_step - r;
885 }
886 diff = q * den - num;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100887 if (diff < 0)
888 diff = -diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if (best_num == 0 ||
890 diff * best_den < best_diff * den) {
891 best_diff = diff;
892 best_den = den;
893 best_num = num;
894 }
895 }
896 if (best_den == 0) {
897 i->empty = 1;
898 return -EINVAL;
899 }
900 t.max = div_up(best_num, best_den);
901 t.openmax = !!(best_num % best_den);
902 t.integer = 0;
903 err = snd_interval_refine(i, &t);
904 if (err < 0)
905 return err;
906
907 if (snd_interval_single(i)) {
Krzysztof Helt8374e242009-12-21 17:07:08 +0100908 if (best_diff * result_den < result_diff * best_den) {
909 result_num = best_num;
910 result_den = best_den;
911 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 if (nump)
Krzysztof Helt8374e242009-12-21 17:07:08 +0100913 *nump = result_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 if (denp)
Krzysztof Helt8374e242009-12-21 17:07:08 +0100915 *denp = result_den;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 }
917 return err;
918}
919
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200920EXPORT_SYMBOL(snd_interval_ratnum);
921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922/**
923 * snd_interval_ratden - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200924 * @i: interval to refine
Takashi Iwai877211f2005-11-17 13:59:38 +0100925 * @rats_count: number of struct ratden
926 * @rats: struct ratden array
Takashi Iwaidf8db932005-09-07 13:38:19 +0200927 * @nump: pointer to store the resultant numerator
928 * @denp: pointer to store the resultant denominator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 *
930 * Returns non-zero if the value is changed, zero if not changed.
931 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100932static int snd_interval_ratden(struct snd_interval *i,
933 unsigned int rats_count, struct snd_ratden *rats,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 unsigned int *nump, unsigned int *denp)
935{
936 unsigned int best_num, best_diff, best_den;
937 unsigned int k;
Takashi Iwai877211f2005-11-17 13:59:38 +0100938 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 int err;
940
941 best_num = best_den = best_diff = 0;
942 for (k = 0; k < rats_count; ++k) {
943 unsigned int num;
944 unsigned int den = rats[k].den;
945 unsigned int q = i->min;
946 int diff;
947 num = mul(q, den);
948 if (num > rats[k].num_max)
949 continue;
950 if (num < rats[k].num_min)
951 num = rats[k].num_max;
952 else {
953 unsigned int r;
954 r = (num - rats[k].num_min) % rats[k].num_step;
955 if (r != 0)
956 num += rats[k].num_step - r;
957 }
958 diff = num - q * den;
959 if (best_num == 0 ||
960 diff * best_den < best_diff * den) {
961 best_diff = diff;
962 best_den = den;
963 best_num = num;
964 }
965 }
966 if (best_den == 0) {
967 i->empty = 1;
968 return -EINVAL;
969 }
970 t.min = div_down(best_num, best_den);
971 t.openmin = !!(best_num % best_den);
972
973 best_num = best_den = best_diff = 0;
974 for (k = 0; k < rats_count; ++k) {
975 unsigned int num;
976 unsigned int den = rats[k].den;
977 unsigned int q = i->max;
978 int diff;
979 num = mul(q, den);
980 if (num < rats[k].num_min)
981 continue;
982 if (num > rats[k].num_max)
983 num = rats[k].num_max;
984 else {
985 unsigned int r;
986 r = (num - rats[k].num_min) % rats[k].num_step;
987 if (r != 0)
988 num -= r;
989 }
990 diff = q * den - num;
991 if (best_num == 0 ||
992 diff * best_den < best_diff * den) {
993 best_diff = diff;
994 best_den = den;
995 best_num = num;
996 }
997 }
998 if (best_den == 0) {
999 i->empty = 1;
1000 return -EINVAL;
1001 }
1002 t.max = div_up(best_num, best_den);
1003 t.openmax = !!(best_num % best_den);
1004 t.integer = 0;
1005 err = snd_interval_refine(i, &t);
1006 if (err < 0)
1007 return err;
1008
1009 if (snd_interval_single(i)) {
1010 if (nump)
1011 *nump = best_num;
1012 if (denp)
1013 *denp = best_den;
1014 }
1015 return err;
1016}
1017
1018/**
1019 * snd_interval_list - refine the interval value from the list
1020 * @i: the interval value to refine
1021 * @count: the number of elements in the list
1022 * @list: the value list
1023 * @mask: the bit-mask to evaluate
1024 *
1025 * Refines the interval value from the list.
1026 * When mask is non-zero, only the elements corresponding to bit 1 are
1027 * evaluated.
1028 *
1029 * Returns non-zero if the value is changed, zero if not changed.
1030 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001031int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032{
1033 unsigned int k;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001034 struct snd_interval list_range;
Takashi Iwai0981a262007-02-01 14:53:49 +01001035
1036 if (!count) {
1037 i->empty = 1;
1038 return -EINVAL;
1039 }
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001040 snd_interval_any(&list_range);
1041 list_range.min = UINT_MAX;
1042 list_range.max = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 for (k = 0; k < count; k++) {
1044 if (mask && !(mask & (1 << k)))
1045 continue;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001046 if (!snd_interval_test(i, list[k]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 continue;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001048 list_range.min = min(list_range.min, list[k]);
1049 list_range.max = max(list_range.max, list[k]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001051 return snd_interval_refine(i, &list_range);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052}
1053
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001054EXPORT_SYMBOL(snd_interval_list);
1055
Takashi Iwai877211f2005-11-17 13:59:38 +01001056static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057{
1058 unsigned int n;
1059 int changed = 0;
1060 n = (i->min - min) % step;
1061 if (n != 0 || i->openmin) {
1062 i->min += step - n;
1063 changed = 1;
1064 }
1065 n = (i->max - min) % step;
1066 if (n != 0 || i->openmax) {
1067 i->max -= n;
1068 changed = 1;
1069 }
1070 if (snd_interval_checkempty(i)) {
1071 i->empty = 1;
1072 return -EINVAL;
1073 }
1074 return changed;
1075}
1076
1077/* Info constraints helpers */
1078
1079/**
1080 * snd_pcm_hw_rule_add - add the hw-constraint rule
1081 * @runtime: the pcm runtime instance
1082 * @cond: condition bits
1083 * @var: the variable to evaluate
1084 * @func: the evaluation function
1085 * @private: the private data pointer passed to function
1086 * @dep: the dependent variables
1087 *
1088 * Returns zero if successful, or a negative error code on failure.
1089 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001090int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 int var,
1092 snd_pcm_hw_rule_func_t func, void *private,
1093 int dep, ...)
1094{
Takashi Iwai877211f2005-11-17 13:59:38 +01001095 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1096 struct snd_pcm_hw_rule *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 unsigned int k;
1098 va_list args;
1099 va_start(args, dep);
1100 if (constrs->rules_num >= constrs->rules_all) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001101 struct snd_pcm_hw_rule *new;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 unsigned int new_rules = constrs->rules_all + 16;
1103 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001104 if (!new) {
1105 va_end(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 return -ENOMEM;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001107 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 if (constrs->rules) {
1109 memcpy(new, constrs->rules,
1110 constrs->rules_num * sizeof(*c));
1111 kfree(constrs->rules);
1112 }
1113 constrs->rules = new;
1114 constrs->rules_all = new_rules;
1115 }
1116 c = &constrs->rules[constrs->rules_num];
1117 c->cond = cond;
1118 c->func = func;
1119 c->var = var;
1120 c->private = private;
1121 k = 0;
1122 while (1) {
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001123 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
1124 va_end(args);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001125 return -EINVAL;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001126 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 c->deps[k++] = dep;
1128 if (dep < 0)
1129 break;
1130 dep = va_arg(args, int);
1131 }
1132 constrs->rules_num++;
1133 va_end(args);
1134 return 0;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001135}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001137EXPORT_SYMBOL(snd_pcm_hw_rule_add);
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001140 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
Takashi Iwaidf8db932005-09-07 13:38:19 +02001141 * @runtime: PCM runtime instance
1142 * @var: hw_params variable to apply the mask
1143 * @mask: the bitmap mask
1144 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001145 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001147int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 u_int32_t mask)
1149{
Takashi Iwai877211f2005-11-17 13:59:38 +01001150 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1151 struct snd_mask *maskp = constrs_mask(constrs, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 *maskp->bits &= mask;
1153 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
1154 if (*maskp->bits == 0)
1155 return -EINVAL;
1156 return 0;
1157}
1158
1159/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001160 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
Takashi Iwaidf8db932005-09-07 13:38:19 +02001161 * @runtime: PCM runtime instance
1162 * @var: hw_params variable to apply the mask
1163 * @mask: the 64bit bitmap mask
1164 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001165 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001167int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 u_int64_t mask)
1169{
Takashi Iwai877211f2005-11-17 13:59:38 +01001170 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1171 struct snd_mask *maskp = constrs_mask(constrs, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 maskp->bits[0] &= (u_int32_t)mask;
1173 maskp->bits[1] &= (u_int32_t)(mask >> 32);
1174 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
1175 if (! maskp->bits[0] && ! maskp->bits[1])
1176 return -EINVAL;
1177 return 0;
1178}
1179
1180/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001181 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
Takashi Iwaidf8db932005-09-07 13:38:19 +02001182 * @runtime: PCM runtime instance
1183 * @var: hw_params variable to apply the integer constraint
1184 *
1185 * Apply the constraint of integer to an interval parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001187int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188{
Takashi Iwai877211f2005-11-17 13:59:38 +01001189 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return snd_interval_setinteger(constrs_interval(constrs, var));
1191}
1192
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001193EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001196 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
Takashi Iwaidf8db932005-09-07 13:38:19 +02001197 * @runtime: PCM runtime instance
1198 * @var: hw_params variable to apply the range
1199 * @min: the minimal value
1200 * @max: the maximal value
1201 *
1202 * Apply the min/max range constraint to an interval parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001204int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 unsigned int min, unsigned int max)
1206{
Takashi Iwai877211f2005-11-17 13:59:38 +01001207 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1208 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 t.min = min;
1210 t.max = max;
1211 t.openmin = t.openmax = 0;
1212 t.integer = 0;
1213 return snd_interval_refine(constrs_interval(constrs, var), &t);
1214}
1215
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001216EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
1217
Takashi Iwai877211f2005-11-17 13:59:38 +01001218static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
1219 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220{
Takashi Iwai877211f2005-11-17 13:59:38 +01001221 struct snd_pcm_hw_constraint_list *list = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
1223}
1224
1225
1226/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001227 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001228 * @runtime: PCM runtime instance
1229 * @cond: condition bits
1230 * @var: hw_params variable to apply the list constraint
1231 * @l: list
1232 *
1233 * Apply the list of constraints to an interval parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001235int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 unsigned int cond,
1237 snd_pcm_hw_param_t var,
Takashi Iwai877211f2005-11-17 13:59:38 +01001238 struct snd_pcm_hw_constraint_list *l)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
1240 return snd_pcm_hw_rule_add(runtime, cond, var,
1241 snd_pcm_hw_rule_list, l,
1242 var, -1);
1243}
1244
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001245EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
1246
Takashi Iwai877211f2005-11-17 13:59:38 +01001247static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
1248 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249{
Takashi Iwai877211f2005-11-17 13:59:38 +01001250 struct snd_pcm_hw_constraint_ratnums *r = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 unsigned int num = 0, den = 0;
1252 int err;
1253 err = snd_interval_ratnum(hw_param_interval(params, rule->var),
1254 r->nrats, r->rats, &num, &den);
1255 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1256 params->rate_num = num;
1257 params->rate_den = den;
1258 }
1259 return err;
1260}
1261
1262/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001263 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001264 * @runtime: PCM runtime instance
1265 * @cond: condition bits
1266 * @var: hw_params variable to apply the ratnums constraint
Takashi Iwai877211f2005-11-17 13:59:38 +01001267 * @r: struct snd_ratnums constriants
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001269int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 unsigned int cond,
1271 snd_pcm_hw_param_t var,
Takashi Iwai877211f2005-11-17 13:59:38 +01001272 struct snd_pcm_hw_constraint_ratnums *r)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273{
1274 return snd_pcm_hw_rule_add(runtime, cond, var,
1275 snd_pcm_hw_rule_ratnums, r,
1276 var, -1);
1277}
1278
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001279EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
1280
Takashi Iwai877211f2005-11-17 13:59:38 +01001281static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
1282 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283{
Takashi Iwai877211f2005-11-17 13:59:38 +01001284 struct snd_pcm_hw_constraint_ratdens *r = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 unsigned int num = 0, den = 0;
1286 int err = snd_interval_ratden(hw_param_interval(params, rule->var),
1287 r->nrats, r->rats, &num, &den);
1288 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1289 params->rate_num = num;
1290 params->rate_den = den;
1291 }
1292 return err;
1293}
1294
1295/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001296 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001297 * @runtime: PCM runtime instance
1298 * @cond: condition bits
1299 * @var: hw_params variable to apply the ratdens constraint
Takashi Iwai877211f2005-11-17 13:59:38 +01001300 * @r: struct snd_ratdens constriants
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001302int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 unsigned int cond,
1304 snd_pcm_hw_param_t var,
Takashi Iwai877211f2005-11-17 13:59:38 +01001305 struct snd_pcm_hw_constraint_ratdens *r)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
1307 return snd_pcm_hw_rule_add(runtime, cond, var,
1308 snd_pcm_hw_rule_ratdens, r,
1309 var, -1);
1310}
1311
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001312EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
1313
Takashi Iwai877211f2005-11-17 13:59:38 +01001314static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
1315 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316{
1317 unsigned int l = (unsigned long) rule->private;
1318 int width = l & 0xffff;
1319 unsigned int msbits = l >> 16;
Takashi Iwai877211f2005-11-17 13:59:38 +01001320 struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (snd_interval_single(i) && snd_interval_value(i) == width)
1322 params->msbits = msbits;
1323 return 0;
1324}
1325
1326/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001327 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001328 * @runtime: PCM runtime instance
1329 * @cond: condition bits
1330 * @width: sample bits width
1331 * @msbits: msbits width
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001333int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 unsigned int cond,
1335 unsigned int width,
1336 unsigned int msbits)
1337{
1338 unsigned long l = (msbits << 16) | width;
1339 return snd_pcm_hw_rule_add(runtime, cond, -1,
1340 snd_pcm_hw_rule_msbits,
1341 (void*) l,
1342 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1343}
1344
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001345EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
1346
Takashi Iwai877211f2005-11-17 13:59:38 +01001347static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
1348 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
1350 unsigned long step = (unsigned long) rule->private;
1351 return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
1352}
1353
1354/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001355 * snd_pcm_hw_constraint_step - add a hw constraint step rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001356 * @runtime: PCM runtime instance
1357 * @cond: condition bits
1358 * @var: hw_params variable to apply the step constraint
1359 * @step: step size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001361int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 unsigned int cond,
1363 snd_pcm_hw_param_t var,
1364 unsigned long step)
1365{
1366 return snd_pcm_hw_rule_add(runtime, cond, var,
1367 snd_pcm_hw_rule_step, (void *) step,
1368 var, -1);
1369}
1370
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001371EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
1372
Takashi Iwai877211f2005-11-17 13:59:38 +01001373static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374{
Marcin Åšlusarz67c39312007-12-14 12:53:21 +01001375 static unsigned int pow2_sizes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1377 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1378 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1379 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1380 };
1381 return snd_interval_list(hw_param_interval(params, rule->var),
1382 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
1383}
1384
1385/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001386 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001387 * @runtime: PCM runtime instance
1388 * @cond: condition bits
1389 * @var: hw_params variable to apply the power-of-2 constraint
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001391int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 unsigned int cond,
1393 snd_pcm_hw_param_t var)
1394{
1395 return snd_pcm_hw_rule_add(runtime, cond, var,
1396 snd_pcm_hw_rule_pow2, NULL,
1397 var, -1);
1398}
1399
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001400EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
1401
Takashi Iwai877211f2005-11-17 13:59:38 +01001402static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001403 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404{
1405 if (hw_is_mask(var)) {
1406 snd_mask_any(hw_param_mask(params, var));
1407 params->cmask |= 1 << var;
1408 params->rmask |= 1 << var;
1409 return;
1410 }
1411 if (hw_is_interval(var)) {
1412 snd_interval_any(hw_param_interval(params, var));
1413 params->cmask |= 1 << var;
1414 params->rmask |= 1 << var;
1415 return;
1416 }
1417 snd_BUG();
1418}
1419
Takashi Iwai877211f2005-11-17 13:59:38 +01001420void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421{
1422 unsigned int k;
1423 memset(params, 0, sizeof(*params));
1424 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
1425 _snd_pcm_hw_param_any(params, k);
1426 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
1427 _snd_pcm_hw_param_any(params, k);
1428 params->info = ~0U;
1429}
1430
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001431EXPORT_SYMBOL(_snd_pcm_hw_params_any);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
1433/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001434 * snd_pcm_hw_param_value - return @params field @var value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001435 * @params: the hw_params instance
1436 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001437 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001439 * Return the value for field @var if it's fixed in configuration space
1440 * defined by @params. Return -%EINVAL otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001442int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
1443 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444{
1445 if (hw_is_mask(var)) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001446 const struct snd_mask *mask = hw_param_mask_c(params, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 if (!snd_mask_single(mask))
1448 return -EINVAL;
1449 if (dir)
1450 *dir = 0;
1451 return snd_mask_value(mask);
1452 }
1453 if (hw_is_interval(var)) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001454 const struct snd_interval *i = hw_param_interval_c(params, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 if (!snd_interval_single(i))
1456 return -EINVAL;
1457 if (dir)
1458 *dir = i->openmin;
1459 return snd_interval_value(i);
1460 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 return -EINVAL;
1462}
1463
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001464EXPORT_SYMBOL(snd_pcm_hw_param_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
Takashi Iwai877211f2005-11-17 13:59:38 +01001466void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 snd_pcm_hw_param_t var)
1468{
1469 if (hw_is_mask(var)) {
1470 snd_mask_none(hw_param_mask(params, var));
1471 params->cmask |= 1 << var;
1472 params->rmask |= 1 << var;
1473 } else if (hw_is_interval(var)) {
1474 snd_interval_none(hw_param_interval(params, var));
1475 params->cmask |= 1 << var;
1476 params->rmask |= 1 << var;
1477 } else {
1478 snd_BUG();
1479 }
1480}
1481
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001482EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Takashi Iwai877211f2005-11-17 13:59:38 +01001484static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001485 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486{
1487 int changed;
1488 if (hw_is_mask(var))
1489 changed = snd_mask_refine_first(hw_param_mask(params, var));
1490 else if (hw_is_interval(var))
1491 changed = snd_interval_refine_first(hw_param_interval(params, var));
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001492 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 if (changed) {
1495 params->cmask |= 1 << var;
1496 params->rmask |= 1 << var;
1497 }
1498 return changed;
1499}
1500
1501
1502/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001503 * snd_pcm_hw_param_first - refine config space and return minimum value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001504 * @pcm: PCM instance
1505 * @params: the hw_params instance
1506 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001507 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001509 * Inside configuration space defined by @params remove from @var all
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 * values > minimum. Reduce configuration space accordingly.
1511 * Return the minimum.
1512 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001513int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
1514 struct snd_pcm_hw_params *params,
1515 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516{
1517 int changed = _snd_pcm_hw_param_first(params, var);
1518 if (changed < 0)
1519 return changed;
1520 if (params->rmask) {
1521 int err = snd_pcm_hw_refine(pcm, params);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001522 if (snd_BUG_ON(err < 0))
1523 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 }
1525 return snd_pcm_hw_param_value(params, var, dir);
1526}
1527
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001528EXPORT_SYMBOL(snd_pcm_hw_param_first);
1529
Takashi Iwai877211f2005-11-17 13:59:38 +01001530static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001531 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532{
1533 int changed;
1534 if (hw_is_mask(var))
1535 changed = snd_mask_refine_last(hw_param_mask(params, var));
1536 else if (hw_is_interval(var))
1537 changed = snd_interval_refine_last(hw_param_interval(params, var));
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001538 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 if (changed) {
1541 params->cmask |= 1 << var;
1542 params->rmask |= 1 << var;
1543 }
1544 return changed;
1545}
1546
1547
1548/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001549 * snd_pcm_hw_param_last - refine config space and return maximum value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001550 * @pcm: PCM instance
1551 * @params: the hw_params instance
1552 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001553 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001555 * Inside configuration space defined by @params remove from @var all
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 * values < maximum. Reduce configuration space accordingly.
1557 * Return the maximum.
1558 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001559int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
1560 struct snd_pcm_hw_params *params,
1561 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562{
1563 int changed = _snd_pcm_hw_param_last(params, var);
1564 if (changed < 0)
1565 return changed;
1566 if (params->rmask) {
1567 int err = snd_pcm_hw_refine(pcm, params);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001568 if (snd_BUG_ON(err < 0))
1569 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 }
1571 return snd_pcm_hw_param_value(params, var, dir);
1572}
1573
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001574EXPORT_SYMBOL(snd_pcm_hw_param_last);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
1576/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001577 * snd_pcm_hw_param_choose - choose a configuration defined by @params
Takashi Iwaidf8db932005-09-07 13:38:19 +02001578 * @pcm: PCM instance
1579 * @params: the hw_params instance
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001581 * Choose one configuration from configuration space defined by @params.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 * The configuration chosen is that obtained fixing in this order:
1583 * first access, first format, first subformat, min channels,
1584 * min rate, min period time, max buffer size, min tick time
1585 */
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001586int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1587 struct snd_pcm_hw_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588{
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001589 static int vars[] = {
1590 SNDRV_PCM_HW_PARAM_ACCESS,
1591 SNDRV_PCM_HW_PARAM_FORMAT,
1592 SNDRV_PCM_HW_PARAM_SUBFORMAT,
1593 SNDRV_PCM_HW_PARAM_CHANNELS,
1594 SNDRV_PCM_HW_PARAM_RATE,
1595 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1596 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1597 SNDRV_PCM_HW_PARAM_TICK_TIME,
1598 -1
1599 };
1600 int err, *v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001602 for (v = vars; *v != -1; v++) {
1603 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
1604 err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1605 else
1606 err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001607 if (snd_BUG_ON(err < 0))
1608 return err;
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001609 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 return 0;
1611}
1612
Takashi Iwai877211f2005-11-17 13:59:38 +01001613static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 void *arg)
1615{
Takashi Iwai877211f2005-11-17 13:59:38 +01001616 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 unsigned long flags;
1618 snd_pcm_stream_lock_irqsave(substream, flags);
1619 if (snd_pcm_running(substream) &&
1620 snd_pcm_update_hw_ptr(substream) >= 0)
1621 runtime->status->hw_ptr %= runtime->buffer_size;
1622 else
1623 runtime->status->hw_ptr = 0;
1624 snd_pcm_stream_unlock_irqrestore(substream, flags);
1625 return 0;
1626}
1627
Takashi Iwai877211f2005-11-17 13:59:38 +01001628static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 void *arg)
1630{
Takashi Iwai877211f2005-11-17 13:59:38 +01001631 struct snd_pcm_channel_info *info = arg;
1632 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 int width;
1634 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
1635 info->offset = -1;
1636 return 0;
1637 }
1638 width = snd_pcm_format_physical_width(runtime->format);
1639 if (width < 0)
1640 return width;
1641 info->offset = 0;
1642 switch (runtime->access) {
1643 case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
1644 case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
1645 info->first = info->channel * width;
1646 info->step = runtime->channels * width;
1647 break;
1648 case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
1649 case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
1650 {
1651 size_t size = runtime->dma_bytes / runtime->channels;
1652 info->first = info->channel * size * 8;
1653 info->step = width;
1654 break;
1655 }
1656 default:
1657 snd_BUG();
1658 break;
1659 }
1660 return 0;
1661}
1662
Jaroslav Kysela8bea8692009-04-27 09:44:40 +02001663static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
1664 void *arg)
1665{
1666 struct snd_pcm_hw_params *params = arg;
1667 snd_pcm_format_t format;
1668 int channels, width;
1669
1670 params->fifo_size = substream->runtime->hw.fifo_size;
1671 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
1672 format = params_format(params);
1673 channels = params_channels(params);
1674 width = snd_pcm_format_physical_width(format);
1675 params->fifo_size /= width * channels;
1676 }
1677 return 0;
1678}
1679
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680/**
1681 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1682 * @substream: the pcm substream instance
1683 * @cmd: ioctl command
1684 * @arg: ioctl argument
1685 *
1686 * Processes the generic ioctl commands for PCM.
1687 * Can be passed as the ioctl callback for PCM ops.
1688 *
1689 * Returns zero if successful, or a negative error code on failure.
1690 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001691int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 unsigned int cmd, void *arg)
1693{
1694 switch (cmd) {
1695 case SNDRV_PCM_IOCTL1_INFO:
1696 return 0;
1697 case SNDRV_PCM_IOCTL1_RESET:
1698 return snd_pcm_lib_ioctl_reset(substream, arg);
1699 case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
1700 return snd_pcm_lib_ioctl_channel_info(substream, arg);
Jaroslav Kysela8bea8692009-04-27 09:44:40 +02001701 case SNDRV_PCM_IOCTL1_FIFO_SIZE:
1702 return snd_pcm_lib_ioctl_fifo_size(substream, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704 return -ENXIO;
1705}
1706
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001707EXPORT_SYMBOL(snd_pcm_lib_ioctl);
1708
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709/**
1710 * snd_pcm_period_elapsed - update the pcm status for the next period
1711 * @substream: the pcm substream instance
1712 *
1713 * This function is called from the interrupt handler when the
1714 * PCM has processed the period size. It will update the current
Takashi Iwai31e89602008-01-08 18:09:57 +01001715 * pointer, wake up sleepers, etc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 *
1717 * Even if more than one periods have elapsed since the last call, you
1718 * have to call this only once.
1719 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001720void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721{
Takashi Iwai877211f2005-11-17 13:59:38 +01001722 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 unsigned long flags;
1724
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001725 if (PCM_RUNTIME_CHECK(substream))
1726 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
1729 if (runtime->transfer_ack_begin)
1730 runtime->transfer_ack_begin(substream);
1731
1732 snd_pcm_stream_lock_irqsave(substream, flags);
1733 if (!snd_pcm_running(substream) ||
Jaroslav Kyselaf2404062010-01-05 17:19:34 +01001734 snd_pcm_update_hw_ptr0(substream, 1) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 goto _end;
1736
1737 if (substream->timer_running)
1738 snd_timer_interrupt(substream->timer, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 _end:
1740 snd_pcm_stream_unlock_irqrestore(substream, flags);
1741 if (runtime->transfer_ack_end)
1742 runtime->transfer_ack_end(substream);
1743 kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
1744}
1745
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001746EXPORT_SYMBOL(snd_pcm_period_elapsed);
1747
Takashi Iwai13075512008-01-08 18:08:14 +01001748/*
1749 * Wait until avail_min data becomes available
1750 * Returns a negative error code if any error occurs during operation.
1751 * The available space is stored on availp. When err = 0 and avail = 0
1752 * on the capture stream, it indicates the stream is in DRAINING state.
1753 */
David Dillow5daeba32010-06-27 00:13:20 +02001754static int wait_for_avail(struct snd_pcm_substream *substream,
Takashi Iwai13075512008-01-08 18:08:14 +01001755 snd_pcm_uframes_t *availp)
1756{
1757 struct snd_pcm_runtime *runtime = substream->runtime;
1758 int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
1759 wait_queue_t wait;
1760 int err = 0;
1761 snd_pcm_uframes_t avail = 0;
Takashi Iwaif2b36142011-05-26 08:09:38 +02001762 long wait_time, tout;
Takashi Iwai13075512008-01-08 18:08:14 +01001763
Arjan van de Ven763437a2011-09-15 08:49:25 +02001764 init_waitqueue_entry(&wait, current);
1765 set_current_state(TASK_INTERRUPTIBLE);
1766 add_wait_queue(&runtime->tsleep, &wait);
1767
Takashi Iwaif2b36142011-05-26 08:09:38 +02001768 if (runtime->no_period_wakeup)
1769 wait_time = MAX_SCHEDULE_TIMEOUT;
1770 else {
1771 wait_time = 10;
1772 if (runtime->rate) {
1773 long t = runtime->period_size * 2 / runtime->rate;
1774 wait_time = max(t, wait_time);
1775 }
1776 wait_time = msecs_to_jiffies(wait_time * 1000);
1777 }
Arjan van de Ven763437a2011-09-15 08:49:25 +02001778
Takashi Iwai13075512008-01-08 18:08:14 +01001779 for (;;) {
1780 if (signal_pending(current)) {
1781 err = -ERESTARTSYS;
1782 break;
1783 }
Arjan van de Ven763437a2011-09-15 08:49:25 +02001784
1785 /*
1786 * We need to check if space became available already
1787 * (and thus the wakeup happened already) first to close
1788 * the race of space already having become available.
1789 * This check must happen after been added to the waitqueue
1790 * and having current state be INTERRUPTIBLE.
1791 */
1792 if (is_playback)
1793 avail = snd_pcm_playback_avail(runtime);
1794 else
1795 avail = snd_pcm_capture_avail(runtime);
1796 if (avail >= runtime->twake)
1797 break;
Takashi Iwai13075512008-01-08 18:08:14 +01001798 snd_pcm_stream_unlock_irq(substream);
Arjan van de Ven763437a2011-09-15 08:49:25 +02001799
1800 tout = schedule_timeout(wait_time);
1801
Takashi Iwai13075512008-01-08 18:08:14 +01001802 snd_pcm_stream_lock_irq(substream);
Arjan van de Ven763437a2011-09-15 08:49:25 +02001803 set_current_state(TASK_INTERRUPTIBLE);
Takashi Iwai13075512008-01-08 18:08:14 +01001804 switch (runtime->status->state) {
1805 case SNDRV_PCM_STATE_SUSPENDED:
1806 err = -ESTRPIPE;
1807 goto _endloop;
1808 case SNDRV_PCM_STATE_XRUN:
1809 err = -EPIPE;
1810 goto _endloop;
1811 case SNDRV_PCM_STATE_DRAINING:
1812 if (is_playback)
1813 err = -EPIPE;
1814 else
1815 avail = 0; /* indicate draining */
1816 goto _endloop;
1817 case SNDRV_PCM_STATE_OPEN:
1818 case SNDRV_PCM_STATE_SETUP:
1819 case SNDRV_PCM_STATE_DISCONNECTED:
1820 err = -EBADFD;
1821 goto _endloop;
1822 }
1823 if (!tout) {
1824 snd_printd("%s write error (DMA or IRQ trouble?)\n",
1825 is_playback ? "playback" : "capture");
1826 err = -EIO;
1827 break;
1828 }
Takashi Iwai13075512008-01-08 18:08:14 +01001829 }
1830 _endloop:
Arjan van de Ven763437a2011-09-15 08:49:25 +02001831 set_current_state(TASK_RUNNING);
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01001832 remove_wait_queue(&runtime->tsleep, &wait);
Takashi Iwai13075512008-01-08 18:08:14 +01001833 *availp = avail;
1834 return err;
1835}
1836
Takashi Iwai877211f2005-11-17 13:59:38 +01001837static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 unsigned int hwoff,
1839 unsigned long data, unsigned int off,
1840 snd_pcm_uframes_t frames)
1841{
Takashi Iwai877211f2005-11-17 13:59:38 +01001842 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 int err;
1844 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1845 if (substream->ops->copy) {
1846 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1847 return err;
1848 } else {
1849 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1851 return -EFAULT;
1852 }
1853 return 0;
1854}
1855
Takashi Iwai877211f2005-11-17 13:59:38 +01001856typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 unsigned long data, unsigned int off,
1858 snd_pcm_uframes_t size);
1859
Takashi Iwai877211f2005-11-17 13:59:38 +01001860static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 unsigned long data,
1862 snd_pcm_uframes_t size,
1863 int nonblock,
1864 transfer_f transfer)
1865{
Takashi Iwai877211f2005-11-17 13:59:38 +01001866 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 snd_pcm_uframes_t xfer = 0;
1868 snd_pcm_uframes_t offset = 0;
1869 int err = 0;
1870
1871 if (size == 0)
1872 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
1874 snd_pcm_stream_lock_irq(substream);
1875 switch (runtime->status->state) {
1876 case SNDRV_PCM_STATE_PREPARED:
1877 case SNDRV_PCM_STATE_RUNNING:
1878 case SNDRV_PCM_STATE_PAUSED:
1879 break;
1880 case SNDRV_PCM_STATE_XRUN:
1881 err = -EPIPE;
1882 goto _end_unlock;
1883 case SNDRV_PCM_STATE_SUSPENDED:
1884 err = -ESTRPIPE;
1885 goto _end_unlock;
1886 default:
1887 err = -EBADFD;
1888 goto _end_unlock;
1889 }
1890
David Dillow5daeba32010-06-27 00:13:20 +02001891 runtime->twake = runtime->control->avail_min ? : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 while (size > 0) {
1893 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
1894 snd_pcm_uframes_t avail;
1895 snd_pcm_uframes_t cont;
Takashi Iwai31e89602008-01-08 18:09:57 +01001896 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 snd_pcm_update_hw_ptr(substream);
1898 avail = snd_pcm_playback_avail(runtime);
Takashi Iwai13075512008-01-08 18:08:14 +01001899 if (!avail) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 if (nonblock) {
1901 err = -EAGAIN;
1902 goto _end_unlock;
1903 }
David Dillow5daeba32010-06-27 00:13:20 +02001904 runtime->twake = min_t(snd_pcm_uframes_t, size,
1905 runtime->control->avail_min ? : 1);
1906 err = wait_for_avail(substream, &avail);
Takashi Iwai13075512008-01-08 18:08:14 +01001907 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 frames = size > avail ? avail : size;
1911 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1912 if (frames > cont)
1913 frames = cont;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001914 if (snd_BUG_ON(!frames)) {
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01001915 runtime->twake = 0;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001916 snd_pcm_stream_unlock_irq(substream);
1917 return -EINVAL;
1918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 appl_ptr = runtime->control->appl_ptr;
1920 appl_ofs = appl_ptr % runtime->buffer_size;
1921 snd_pcm_stream_unlock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01001922 err = transfer(substream, appl_ofs, data, offset, frames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 snd_pcm_stream_lock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01001924 if (err < 0)
1925 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 switch (runtime->status->state) {
1927 case SNDRV_PCM_STATE_XRUN:
1928 err = -EPIPE;
1929 goto _end_unlock;
1930 case SNDRV_PCM_STATE_SUSPENDED:
1931 err = -ESTRPIPE;
1932 goto _end_unlock;
1933 default:
1934 break;
1935 }
1936 appl_ptr += frames;
1937 if (appl_ptr >= runtime->boundary)
1938 appl_ptr -= runtime->boundary;
1939 runtime->control->appl_ptr = appl_ptr;
1940 if (substream->ops->ack)
1941 substream->ops->ack(substream);
1942
1943 offset += frames;
1944 size -= frames;
1945 xfer += frames;
1946 if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
1947 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
1948 err = snd_pcm_start(substream);
1949 if (err < 0)
1950 goto _end_unlock;
1951 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 }
1953 _end_unlock:
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01001954 runtime->twake = 0;
Jaroslav Kysela12509322010-01-07 15:36:31 +01001955 if (xfer > 0 && err >= 0)
1956 snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 snd_pcm_stream_unlock_irq(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
1959}
1960
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001961/* sanity-check for read/write methods */
1962static int pcm_sanity_check(struct snd_pcm_substream *substream)
1963{
1964 struct snd_pcm_runtime *runtime;
1965 if (PCM_RUNTIME_CHECK(substream))
1966 return -ENXIO;
1967 runtime = substream->runtime;
1968 if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
1969 return -EINVAL;
1970 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1971 return -EBADFD;
1972 return 0;
1973}
1974
Takashi Iwai877211f2005-11-17 13:59:38 +01001975snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976{
Takashi Iwai877211f2005-11-17 13:59:38 +01001977 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001979 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001981 err = pcm_sanity_check(substream);
1982 if (err < 0)
1983 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02001985 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
1987 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
1988 runtime->channels > 1)
1989 return -EINVAL;
1990 return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
1991 snd_pcm_lib_write_transfer);
1992}
1993
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001994EXPORT_SYMBOL(snd_pcm_lib_write);
1995
Takashi Iwai877211f2005-11-17 13:59:38 +01001996static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 unsigned int hwoff,
1998 unsigned long data, unsigned int off,
1999 snd_pcm_uframes_t frames)
2000{
Takashi Iwai877211f2005-11-17 13:59:38 +01002001 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 int err;
2003 void __user **bufs = (void __user **)data;
2004 int channels = runtime->channels;
2005 int c;
2006 if (substream->ops->copy) {
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002007 if (snd_BUG_ON(!substream->ops->silence))
2008 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 for (c = 0; c < channels; ++c, ++bufs) {
2010 if (*bufs == NULL) {
2011 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
2012 return err;
2013 } else {
2014 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2015 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2016 return err;
2017 }
2018 }
2019 } else {
2020 /* default transfer behaviour */
2021 size_t dma_csize = runtime->dma_bytes / channels;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 for (c = 0; c < channels; ++c, ++bufs) {
2023 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2024 if (*bufs == NULL) {
2025 snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
2026 } else {
2027 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2028 if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
2029 return -EFAULT;
2030 }
2031 }
2032 }
2033 return 0;
2034}
2035
Takashi Iwai877211f2005-11-17 13:59:38 +01002036snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 void __user **bufs,
2038 snd_pcm_uframes_t frames)
2039{
Takashi Iwai877211f2005-11-17 13:59:38 +01002040 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002042 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002044 err = pcm_sanity_check(substream);
2045 if (err < 0)
2046 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02002048 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
2050 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2051 return -EINVAL;
2052 return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
2053 nonblock, snd_pcm_lib_writev_transfer);
2054}
2055
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02002056EXPORT_SYMBOL(snd_pcm_lib_writev);
2057
Takashi Iwai877211f2005-11-17 13:59:38 +01002058static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 unsigned int hwoff,
2060 unsigned long data, unsigned int off,
2061 snd_pcm_uframes_t frames)
2062{
Takashi Iwai877211f2005-11-17 13:59:38 +01002063 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 int err;
2065 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
2066 if (substream->ops->copy) {
2067 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
2068 return err;
2069 } else {
2070 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
2072 return -EFAULT;
2073 }
2074 return 0;
2075}
2076
Takashi Iwai877211f2005-11-17 13:59:38 +01002077static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 unsigned long data,
2079 snd_pcm_uframes_t size,
2080 int nonblock,
2081 transfer_f transfer)
2082{
Takashi Iwai877211f2005-11-17 13:59:38 +01002083 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 snd_pcm_uframes_t xfer = 0;
2085 snd_pcm_uframes_t offset = 0;
2086 int err = 0;
2087
2088 if (size == 0)
2089 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 snd_pcm_stream_lock_irq(substream);
2092 switch (runtime->status->state) {
2093 case SNDRV_PCM_STATE_PREPARED:
2094 if (size >= runtime->start_threshold) {
2095 err = snd_pcm_start(substream);
2096 if (err < 0)
2097 goto _end_unlock;
2098 }
2099 break;
2100 case SNDRV_PCM_STATE_DRAINING:
2101 case SNDRV_PCM_STATE_RUNNING:
2102 case SNDRV_PCM_STATE_PAUSED:
2103 break;
2104 case SNDRV_PCM_STATE_XRUN:
2105 err = -EPIPE;
2106 goto _end_unlock;
2107 case SNDRV_PCM_STATE_SUSPENDED:
2108 err = -ESTRPIPE;
2109 goto _end_unlock;
2110 default:
2111 err = -EBADFD;
2112 goto _end_unlock;
2113 }
2114
David Dillow5daeba32010-06-27 00:13:20 +02002115 runtime->twake = runtime->control->avail_min ? : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 while (size > 0) {
2117 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
2118 snd_pcm_uframes_t avail;
2119 snd_pcm_uframes_t cont;
Takashi Iwai31e89602008-01-08 18:09:57 +01002120 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 snd_pcm_update_hw_ptr(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 avail = snd_pcm_capture_avail(runtime);
Takashi Iwai13075512008-01-08 18:08:14 +01002123 if (!avail) {
2124 if (runtime->status->state ==
2125 SNDRV_PCM_STATE_DRAINING) {
2126 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 goto _end_unlock;
2128 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 if (nonblock) {
2130 err = -EAGAIN;
2131 goto _end_unlock;
2132 }
David Dillow5daeba32010-06-27 00:13:20 +02002133 runtime->twake = min_t(snd_pcm_uframes_t, size,
2134 runtime->control->avail_min ? : 1);
2135 err = wait_for_avail(substream, &avail);
Takashi Iwai13075512008-01-08 18:08:14 +01002136 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 goto _end_unlock;
Takashi Iwai13075512008-01-08 18:08:14 +01002138 if (!avail)
2139 continue; /* draining */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 frames = size > avail ? avail : size;
2142 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2143 if (frames > cont)
2144 frames = cont;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002145 if (snd_BUG_ON(!frames)) {
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002146 runtime->twake = 0;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002147 snd_pcm_stream_unlock_irq(substream);
2148 return -EINVAL;
2149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 appl_ptr = runtime->control->appl_ptr;
2151 appl_ofs = appl_ptr % runtime->buffer_size;
2152 snd_pcm_stream_unlock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002153 err = transfer(substream, appl_ofs, data, offset, frames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 snd_pcm_stream_lock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002155 if (err < 0)
2156 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 switch (runtime->status->state) {
2158 case SNDRV_PCM_STATE_XRUN:
2159 err = -EPIPE;
2160 goto _end_unlock;
2161 case SNDRV_PCM_STATE_SUSPENDED:
2162 err = -ESTRPIPE;
2163 goto _end_unlock;
2164 default:
2165 break;
2166 }
2167 appl_ptr += frames;
2168 if (appl_ptr >= runtime->boundary)
2169 appl_ptr -= runtime->boundary;
2170 runtime->control->appl_ptr = appl_ptr;
2171 if (substream->ops->ack)
2172 substream->ops->ack(substream);
2173
2174 offset += frames;
2175 size -= frames;
2176 xfer += frames;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 }
2178 _end_unlock:
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002179 runtime->twake = 0;
Jaroslav Kysela12509322010-01-07 15:36:31 +01002180 if (xfer > 0 && err >= 0)
2181 snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 snd_pcm_stream_unlock_irq(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2184}
2185
Takashi Iwai877211f2005-11-17 13:59:38 +01002186snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187{
Takashi Iwai877211f2005-11-17 13:59:38 +01002188 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002190 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002192 err = pcm_sanity_check(substream);
2193 if (err < 0)
2194 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02002196 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
2198 return -EINVAL;
2199 return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
2200}
2201
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02002202EXPORT_SYMBOL(snd_pcm_lib_read);
2203
Takashi Iwai877211f2005-11-17 13:59:38 +01002204static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 unsigned int hwoff,
2206 unsigned long data, unsigned int off,
2207 snd_pcm_uframes_t frames)
2208{
Takashi Iwai877211f2005-11-17 13:59:38 +01002209 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 int err;
2211 void __user **bufs = (void __user **)data;
2212 int channels = runtime->channels;
2213 int c;
2214 if (substream->ops->copy) {
2215 for (c = 0; c < channels; ++c, ++bufs) {
2216 char __user *buf;
2217 if (*bufs == NULL)
2218 continue;
2219 buf = *bufs + samples_to_bytes(runtime, off);
2220 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2221 return err;
2222 }
2223 } else {
2224 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 for (c = 0; c < channels; ++c, ++bufs) {
2226 char *hwbuf;
2227 char __user *buf;
2228 if (*bufs == NULL)
2229 continue;
2230
2231 hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2232 buf = *bufs + samples_to_bytes(runtime, off);
2233 if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
2234 return -EFAULT;
2235 }
2236 }
2237 return 0;
2238}
2239
Takashi Iwai877211f2005-11-17 13:59:38 +01002240snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 void __user **bufs,
2242 snd_pcm_uframes_t frames)
2243{
Takashi Iwai877211f2005-11-17 13:59:38 +01002244 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002246 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002248 err = pcm_sanity_check(substream);
2249 if (err < 0)
2250 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2253 return -EBADFD;
2254
Takashi Iwai0df63e42006-04-28 15:13:41 +02002255 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2257 return -EINVAL;
2258 return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
2259}
2260
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261EXPORT_SYMBOL(snd_pcm_lib_readv);