blob: 41b3dfe68698985e2d5f7e85a4e8411cb6a6371e [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>
Paul Gortmakerd81a6d72011-09-22 09:34:58 -040026#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <sound/core.h>
28#include <sound/control.h>
Takashi Iwai2d3391e2012-07-27 18:27:00 +020029#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <sound/info.h>
31#include <sound/pcm.h>
32#include <sound/pcm_params.h>
33#include <sound/timer.h>
34
35/*
36 * fill ring buffer with silence
37 * runtime->silence_start: starting pointer to silence area
38 * runtime->silence_filled: size filled with silence
39 * runtime->silence_threshold: threshold from application
40 * runtime->silence_size: maximal size from application
41 *
42 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
43 */
Takashi Iwai877211f2005-11-17 13:59:38 +010044void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
Takashi Iwai877211f2005-11-17 13:59:38 +010046 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 snd_pcm_uframes_t frames, ofs, transfer;
48
49 if (runtime->silence_size < runtime->boundary) {
50 snd_pcm_sframes_t noise_dist, n;
51 if (runtime->silence_start != runtime->control->appl_ptr) {
52 n = runtime->control->appl_ptr - runtime->silence_start;
53 if (n < 0)
54 n += runtime->boundary;
55 if ((snd_pcm_uframes_t)n < runtime->silence_filled)
56 runtime->silence_filled -= n;
57 else
58 runtime->silence_filled = 0;
59 runtime->silence_start = runtime->control->appl_ptr;
60 }
Takashi Iwai235475c2005-12-07 15:28:07 +010061 if (runtime->silence_filled >= runtime->buffer_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
64 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
65 return;
66 frames = runtime->silence_threshold - noise_dist;
67 if (frames > runtime->silence_size)
68 frames = runtime->silence_size;
69 } else {
70 if (new_hw_ptr == ULONG_MAX) { /* initialization */
71 snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
Jaroslav Kysela9e216e82010-07-19 16:37:39 +020072 if (avail > runtime->buffer_size)
73 avail = runtime->buffer_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 runtime->silence_filled = avail > 0 ? avail : 0;
75 runtime->silence_start = (runtime->status->hw_ptr +
76 runtime->silence_filled) %
77 runtime->boundary;
78 } else {
79 ofs = runtime->status->hw_ptr;
80 frames = new_hw_ptr - ofs;
81 if ((snd_pcm_sframes_t)frames < 0)
82 frames += runtime->boundary;
83 runtime->silence_filled -= frames;
84 if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
85 runtime->silence_filled = 0;
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020086 runtime->silence_start = new_hw_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 } else {
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020088 runtime->silence_start = ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 }
91 frames = runtime->buffer_size - runtime->silence_filled;
92 }
Takashi Iwai7eaa9432008-08-08 17:09:09 +020093 if (snd_BUG_ON(frames > runtime->buffer_size))
94 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 if (frames == 0)
96 return;
Clemens Ladisch9a826dd2006-10-23 16:26:57 +020097 ofs = runtime->silence_start % runtime->buffer_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 while (frames > 0) {
99 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
100 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
101 runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
102 if (substream->ops->silence) {
103 int err;
104 err = substream->ops->silence(substream, -1, ofs, transfer);
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200105 snd_BUG_ON(err < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 } else {
107 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
108 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
109 }
110 } else {
111 unsigned int c;
112 unsigned int channels = runtime->channels;
113 if (substream->ops->silence) {
114 for (c = 0; c < channels; ++c) {
115 int err;
116 err = substream->ops->silence(substream, c, ofs, transfer);
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200117 snd_BUG_ON(err < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 }
119 } else {
120 size_t dma_csize = runtime->dma_bytes / channels;
121 for (c = 0; c < channels; ++c) {
122 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
123 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
124 }
125 }
126 }
127 runtime->silence_filled += transfer;
128 frames -= transfer;
129 ofs = 0;
130 }
131}
132
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200133#ifdef CONFIG_SND_DEBUG
134void snd_pcm_debug_name(struct snd_pcm_substream *substream,
Takashi Iwaic0070112009-06-08 15:58:48 +0200135 char *name, size_t len)
136{
137 snprintf(name, len, "pcmC%dD%d%c:%d",
138 substream->pcm->card->number,
139 substream->pcm->device,
140 substream->stream ? 'c' : 'p',
141 substream->number);
142}
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200143EXPORT_SYMBOL(snd_pcm_debug_name);
144#endif
Takashi Iwaic0070112009-06-08 15:58:48 +0200145
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100146#define XRUN_DEBUG_BASIC (1<<0)
147#define XRUN_DEBUG_STACK (1<<1) /* dump also stack */
148#define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */
149#define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */
150#define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */
151#define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */
152#define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */
153
154#ifdef CONFIG_SND_PCM_XRUN_DEBUG
155
156#define xrun_debug(substream, mask) \
157 ((substream)->pstr->xrun_debug & (mask))
Jarkko Nikula0f170142010-03-26 16:07:25 +0200158#else
159#define xrun_debug(substream, mask) 0
160#endif
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100161
162#define dump_stack_on_xrun(substream) do { \
163 if (xrun_debug(substream, XRUN_DEBUG_STACK)) \
164 dump_stack(); \
165 } while (0)
166
Takashi Iwai877211f2005-11-17 13:59:38 +0100167static void xrun(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Jaroslav Kysela13f040f2009-05-28 11:31:20 +0200169 struct snd_pcm_runtime *runtime = substream->runtime;
170
171 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
172 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
Jaroslav Kysela741b20c2009-12-17 17:34:39 +0100174 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
Takashi Iwaic0070112009-06-08 15:58:48 +0200175 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200176 snd_pcm_debug_name(substream, name, sizeof(name));
Takashi Iwaic0070112009-06-08 15:58:48 +0200177 snd_printd(KERN_DEBUG "XRUN: %s\n", name);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100178 dump_stack_on_xrun(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180}
181
Jarkko Nikula0f170142010-03-26 16:07:25 +0200182#ifdef CONFIG_SND_PCM_XRUN_DEBUG
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100183#define hw_ptr_error(substream, fmt, args...) \
184 do { \
185 if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100186 xrun_log_show(substream); \
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100187 if (printk_ratelimit()) { \
188 snd_printd("PCM: " fmt, ##args); \
189 } \
190 dump_stack_on_xrun(substream); \
191 } \
192 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100194#define XRUN_LOG_CNT 10
195
196struct hwptr_log_entry {
Ben Gardinerec08b142011-05-18 10:03:34 -0400197 unsigned int in_interrupt;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100198 unsigned long jiffies;
199 snd_pcm_uframes_t pos;
200 snd_pcm_uframes_t period_size;
201 snd_pcm_uframes_t buffer_size;
202 snd_pcm_uframes_t old_hw_ptr;
203 snd_pcm_uframes_t hw_ptr_base;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100204};
205
206struct snd_pcm_hwptr_log {
207 unsigned int idx;
208 unsigned int hit: 1;
209 struct hwptr_log_entry entries[XRUN_LOG_CNT];
210};
211
212static void xrun_log(struct snd_pcm_substream *substream,
Ben Gardinerec08b142011-05-18 10:03:34 -0400213 snd_pcm_uframes_t pos, int in_interrupt)
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100214{
215 struct snd_pcm_runtime *runtime = substream->runtime;
216 struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
217 struct hwptr_log_entry *entry;
218
219 if (log == NULL) {
220 log = kzalloc(sizeof(*log), GFP_ATOMIC);
221 if (log == NULL)
222 return;
223 runtime->hwptr_log = log;
224 } else {
225 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
226 return;
Takashi Iwai7c22f1a2005-10-10 11:46:31 +0200227 }
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100228 entry = &log->entries[log->idx];
Ben Gardinerec08b142011-05-18 10:03:34 -0400229 entry->in_interrupt = in_interrupt;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100230 entry->jiffies = jiffies;
231 entry->pos = pos;
232 entry->period_size = runtime->period_size;
Joe Perchesc80c1d52010-11-14 19:05:02 -0800233 entry->buffer_size = runtime->buffer_size;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100234 entry->old_hw_ptr = runtime->status->hw_ptr;
235 entry->hw_ptr_base = runtime->hw_ptr_base;
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100236 log->idx = (log->idx + 1) % XRUN_LOG_CNT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100239static void xrun_log_show(struct snd_pcm_substream *substream)
240{
241 struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
242 struct hwptr_log_entry *entry;
243 char name[16];
244 unsigned int idx;
245 int cnt;
246
247 if (log == NULL)
248 return;
249 if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
250 return;
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200251 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100252 for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
253 entry = &log->entries[idx];
254 if (entry->period_size == 0)
255 break;
Ben Gardinerec08b142011-05-18 10:03:34 -0400256 snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100257 "hwptr=%ld/%ld\n",
Ben Gardinerec08b142011-05-18 10:03:34 -0400258 name, entry->in_interrupt ? "[Q] " : "",
259 entry->jiffies,
260 (unsigned long)entry->pos,
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100261 (unsigned long)entry->period_size,
262 (unsigned long)entry->buffer_size,
263 (unsigned long)entry->old_hw_ptr,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100264 (unsigned long)entry->hw_ptr_base);
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100265 idx++;
266 idx %= XRUN_LOG_CNT;
267 }
268 log->hit = 1;
269}
270
271#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
272
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100273#define hw_ptr_error(substream, fmt, args...) do { } while (0)
Ben Gardiner217658f2011-05-18 23:52:38 -0400274#define xrun_log(substream, pos, in_interrupt) do { } while (0)
Jaroslav Kysela4d96eb22009-12-20 11:47:57 +0100275#define xrun_log_show(substream) do { } while (0)
276
277#endif
278
Jaroslav Kysela12509322010-01-07 15:36:31 +0100279int snd_pcm_update_state(struct snd_pcm_substream *substream,
280 struct snd_pcm_runtime *runtime)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282 snd_pcm_uframes_t avail;
283
284 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
285 avail = snd_pcm_playback_avail(runtime);
286 else
287 avail = snd_pcm_capture_avail(runtime);
288 if (avail > runtime->avail_max)
289 runtime->avail_max = avail;
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200290 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
291 if (avail >= runtime->buffer_size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 snd_pcm_drain_done(substream);
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200293 return -EPIPE;
294 }
295 } else {
296 if (avail >= runtime->stop_threshold) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 xrun(substream);
Takashi Iwai4cdc1152009-08-20 16:40:16 +0200298 return -EPIPE;
299 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
David Dillow5daeba32010-06-27 00:13:20 +0200301 if (runtime->twake) {
302 if (avail >= runtime->twake)
303 wake_up(&runtime->tsleep);
304 } else if (avail >= runtime->control->avail_min)
305 wake_up(&runtime->sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 return 0;
307}
308
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100309static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
310 unsigned int in_interrupt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Takashi Iwai877211f2005-11-17 13:59:38 +0100312 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 snd_pcm_uframes_t pos;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100314 snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200315 snd_pcm_sframes_t hdelta, delta;
316 unsigned long jdelta;
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500317 unsigned long curr_jiffies;
318 struct timespec curr_tstamp;
Pierre-Louis Bossart4eeaaea2012-10-22 16:42:15 -0500319 struct timespec audio_tstamp;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500320 int crossed_boundary = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200322 old_hw_ptr = runtime->status->hw_ptr;
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500323
324 /*
325 * group pointer, time and jiffies reads to allow for more
326 * accurate correlations/corrections.
327 * The values are stored at the end of this routine after
328 * corrections for hw_ptr position
329 */
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100330 pos = substream->ops->pointer(substream);
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500331 curr_jiffies = jiffies;
Pierre-Louis Bossart4eeaaea2012-10-22 16:42:15 -0500332 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500333 snd_pcm_gettime(runtime, (struct timespec *)&curr_tstamp);
334
Pierre-Louis Bossart4eeaaea2012-10-22 16:42:15 -0500335 if ((runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK) &&
336 (substream->ops->wall_clock))
337 substream->ops->wall_clock(substream, &audio_tstamp);
338 }
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 if (pos == SNDRV_PCM_POS_XRUN) {
341 xrun(substream);
342 return -EPIPE;
343 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100344 if (pos >= runtime->buffer_size) {
345 if (printk_ratelimit()) {
346 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200347 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100348 xrun_log_show(substream);
349 snd_printd(KERN_ERR "BUG: %s, pos = %ld, "
350 "buffer size = %ld, period size = %ld\n",
351 name, pos, runtime->buffer_size,
352 runtime->period_size);
353 }
354 pos = 0;
Takashi Iwaicedb8112009-07-23 11:04:13 +0200355 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100356 pos -= pos % runtime->min_align;
357 if (xrun_debug(substream, XRUN_DEBUG_LOG))
Ben Gardinerec08b142011-05-18 10:03:34 -0400358 xrun_log(substream, pos, in_interrupt);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100359 hw_base = runtime->hw_ptr_base;
360 new_hw_ptr = hw_base + pos;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100361 if (in_interrupt) {
362 /* we know that one period was processed */
363 /* delta = "expected next hw_ptr" for in_interrupt != 0 */
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100364 delta = runtime->hw_ptr_interrupt + runtime->period_size;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100365 if (delta > new_hw_ptr) {
Jaroslav Kyselabd76af02010-08-18 14:16:54 +0200366 /* check for double acknowledged interrupts */
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500367 hdelta = curr_jiffies - runtime->hw_ptr_jiffies;
Jaroslav Kyselabd76af02010-08-18 14:16:54 +0200368 if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
369 hw_base += runtime->buffer_size;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500370 if (hw_base >= runtime->boundary) {
Jaroslav Kyselabd76af02010-08-18 14:16:54 +0200371 hw_base = 0;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500372 crossed_boundary++;
373 }
Jaroslav Kyselabd76af02010-08-18 14:16:54 +0200374 new_hw_ptr = hw_base + pos;
375 goto __delta;
376 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100379 /* new_hw_ptr might be lower than old_hw_ptr in case when */
380 /* pointer crosses the end of the ring buffer */
381 if (new_hw_ptr < old_hw_ptr) {
382 hw_base += runtime->buffer_size;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500383 if (hw_base >= runtime->boundary) {
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100384 hw_base = 0;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500385 crossed_boundary++;
386 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100387 new_hw_ptr = hw_base + pos;
388 }
389 __delta:
Clemens Ladischb406e612010-05-25 09:01:46 +0200390 delta = new_hw_ptr - old_hw_ptr;
391 if (delta < 0)
392 delta += runtime->boundary;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100393 if (xrun_debug(substream, in_interrupt ?
394 XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
395 char name[16];
Eliot Blennerhassettacb03d42011-07-23 12:36:25 +1200396 snd_pcm_debug_name(substream, name, sizeof(name));
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100397 snd_printd("%s_update: %s: pos=%u/%u/%u, "
398 "hwptr=%ld/%ld/%ld/%ld\n",
399 in_interrupt ? "period" : "hwptr",
400 name,
401 (unsigned int)pos,
402 (unsigned int)runtime->period_size,
403 (unsigned int)runtime->buffer_size,
404 (unsigned long)delta,
405 (unsigned long)old_hw_ptr,
406 (unsigned long)new_hw_ptr,
407 (unsigned long)runtime->hw_ptr_base);
408 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100409
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100410 if (runtime->no_period_wakeup) {
Kelly Anderson12ff4142011-04-01 11:58:25 +0200411 snd_pcm_sframes_t xrun_threshold;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100412 /*
413 * Without regular period interrupts, we have to check
414 * the elapsed time to detect xruns.
415 */
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500416 jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
Clemens Ladisch47228e42010-11-18 09:53:07 +0100417 if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
418 goto no_delta_check;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100419 hdelta = jdelta - delta * HZ / runtime->rate;
Kelly Anderson12ff4142011-04-01 11:58:25 +0200420 xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
421 while (hdelta > xrun_threshold) {
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100422 delta += runtime->buffer_size;
423 hw_base += runtime->buffer_size;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500424 if (hw_base >= runtime->boundary) {
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100425 hw_base = 0;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500426 crossed_boundary++;
427 }
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100428 new_hw_ptr = hw_base + pos;
429 hdelta -= runtime->hw_ptr_buffer_jiffies;
430 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100431 goto no_delta_check;
Clemens Ladisch59ff8782010-11-18 09:43:52 +0100432 }
Clemens Ladischab69a492010-11-15 10:46:23 +0100433
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100434 /* something must be really wrong */
Jaroslav Kysela7b3a1772010-01-08 08:43:01 +0100435 if (delta >= runtime->buffer_size + runtime->period_size) {
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100436 hw_ptr_error(substream,
437 "Unexpected hw_pointer value %s"
438 "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
439 "old_hw_ptr=%ld)\n",
440 in_interrupt ? "[Q] " : "[P]",
441 substream->stream, (long)pos,
442 (long)new_hw_ptr, (long)old_hw_ptr);
443 return 0;
444 }
Takashi Iwaic87d9732009-05-27 10:53:33 +0200445
446 /* Do jiffies check only in xrun_debug mode */
Jaroslav Kysela741b20c2009-12-17 17:34:39 +0100447 if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
Takashi Iwaic87d9732009-05-27 10:53:33 +0200448 goto no_jiffies_check;
449
Takashi Iwai3e5b5012009-04-28 12:07:08 +0200450 /* Skip the jiffies check for hardwares with BATCH flag.
451 * Such hardware usually just increases the position at each IRQ,
452 * thus it can't give any strange position.
453 */
454 if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
455 goto no_jiffies_check;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100456 hdelta = delta;
Jaroslav Kyselaa4444da2009-05-28 12:31:56 +0200457 if (hdelta < runtime->delay)
458 goto no_jiffies_check;
459 hdelta -= runtime->delay;
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500460 jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200461 if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
462 delta = jdelta /
463 (((runtime->period_size * HZ) / runtime->rate)
464 + HZ/100);
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100465 /* move new_hw_ptr according jiffies not pos variable */
466 new_hw_ptr = old_hw_ptr;
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100467 hw_base = delta;
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100468 /* use loop to avoid checks for delta overflows */
469 /* the delta value is small or zero in most cases */
470 while (delta > 0) {
471 new_hw_ptr += runtime->period_size;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500472 if (new_hw_ptr >= runtime->boundary) {
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100473 new_hw_ptr -= runtime->boundary;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500474 crossed_boundary--;
475 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100476 delta--;
477 }
478 /* align hw_base to buffer_size */
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200479 hw_ptr_error(substream,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100480 "hw_ptr skipping! %s"
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200481 "(pos=%ld, delta=%ld, period=%ld, "
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100482 "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
483 in_interrupt ? "[Q] " : "",
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200484 (long)pos, (long)hdelta,
485 (long)runtime->period_size, jdelta,
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100486 ((hdelta * HZ) / runtime->rate), hw_base,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100487 (unsigned long)old_hw_ptr,
488 (unsigned long)new_hw_ptr);
Jaroslav Kyselaed69c6a2010-01-13 08:12:31 +0100489 /* reset values to proper state */
490 delta = 0;
491 hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200492 }
Takashi Iwai3e5b5012009-04-28 12:07:08 +0200493 no_jiffies_check:
Jaroslav Kyselabbf6ad12009-04-10 12:28:58 +0200494 if (delta > runtime->period_size + runtime->period_size / 2) {
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100495 hw_ptr_error(substream,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100496 "Lost interrupts? %s"
497 "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
498 "old_hw_ptr=%ld)\n",
499 in_interrupt ? "[Q] " : "",
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100500 substream->stream, (long)delta,
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100501 (long)new_hw_ptr,
502 (long)old_hw_ptr);
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100503 }
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100504
Clemens Ladischab69a492010-11-15 10:46:23 +0100505 no_delta_check:
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100506 if (runtime->status->hw_ptr == new_hw_ptr)
507 return 0;
Takashi Iwaiab1863f2009-06-07 12:09:17 +0200508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
510 runtime->silence_size > 0)
511 snd_pcm_playback_silence(substream, new_hw_ptr);
512
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100513 if (in_interrupt) {
Clemens Ladischead40462010-05-21 09:15:59 +0200514 delta = new_hw_ptr - runtime->hw_ptr_interrupt;
515 if (delta < 0)
516 delta += runtime->boundary;
517 delta -= (snd_pcm_uframes_t)delta % runtime->period_size;
518 runtime->hw_ptr_interrupt += delta;
519 if (runtime->hw_ptr_interrupt >= runtime->boundary)
520 runtime->hw_ptr_interrupt -= runtime->boundary;
Jaroslav Kyselae7636922010-01-26 17:08:24 +0100521 }
Takashi Iwaied3da3d2009-03-03 17:00:15 +0100522 runtime->hw_ptr_base = hw_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 runtime->status->hw_ptr = new_hw_ptr;
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500524 runtime->hw_ptr_jiffies = curr_jiffies;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -0500525 if (crossed_boundary) {
526 snd_BUG_ON(crossed_boundary != 1);
527 runtime->hw_ptr_wrap += runtime->boundary;
528 }
Pierre-Louis Bossart4eeaaea2012-10-22 16:42:15 -0500529 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
Pierre-Louis Bossart3509a032012-05-22 14:54:02 -0500530 runtime->status->tstamp = curr_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Pierre-Louis Bossart4eeaaea2012-10-22 16:42:15 -0500532 if (!(runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK)) {
533 /*
534 * no wall clock available, provide audio timestamp
535 * derived from pointer position+delay
536 */
537 u64 audio_frames, audio_nsecs;
538
539 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
540 audio_frames = runtime->hw_ptr_wrap
541 + runtime->status->hw_ptr
542 - runtime->delay;
543 else
544 audio_frames = runtime->hw_ptr_wrap
545 + runtime->status->hw_ptr
546 + runtime->delay;
547 audio_nsecs = div_u64(audio_frames * 1000000000LL,
548 runtime->rate);
549 audio_tstamp = ns_to_timespec(audio_nsecs);
550 }
551 runtime->status->audio_tstamp = audio_tstamp;
552 }
553
Jaroslav Kysela12509322010-01-07 15:36:31 +0100554 return snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
557/* CAUTION: call it with irq disabled */
Takashi Iwai877211f2005-11-17 13:59:38 +0100558int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
Jaroslav Kyselaf2404062010-01-05 17:19:34 +0100560 return snd_pcm_update_hw_ptr0(substream, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
562
563/**
564 * snd_pcm_set_ops - set the PCM operators
565 * @pcm: the pcm instance
566 * @direction: stream direction, SNDRV_PCM_STREAM_XXX
567 * @ops: the operator table
568 *
569 * Sets the given PCM operators to the pcm instance.
570 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100571void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Takashi Iwai877211f2005-11-17 13:59:38 +0100573 struct snd_pcm_str *stream = &pcm->streams[direction];
574 struct snd_pcm_substream *substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 for (substream = stream->substream; substream != NULL; substream = substream->next)
577 substream->ops = ops;
578}
579
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200580EXPORT_SYMBOL(snd_pcm_set_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582/**
583 * snd_pcm_sync - set the PCM sync id
584 * @substream: the pcm substream
585 *
586 * Sets the PCM sync identifier for the card.
587 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100588void snd_pcm_set_sync(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
Takashi Iwai877211f2005-11-17 13:59:38 +0100590 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
592 runtime->sync.id32[0] = substream->pcm->card->number;
593 runtime->sync.id32[1] = -1;
594 runtime->sync.id32[2] = -1;
595 runtime->sync.id32[3] = -1;
596}
597
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200598EXPORT_SYMBOL(snd_pcm_set_sync);
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600/*
601 * Standard ioctl routine
602 */
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604static inline unsigned int div32(unsigned int a, unsigned int b,
605 unsigned int *r)
606{
607 if (b == 0) {
608 *r = 0;
609 return UINT_MAX;
610 }
611 *r = a % b;
612 return a / b;
613}
614
615static inline unsigned int div_down(unsigned int a, unsigned int b)
616{
617 if (b == 0)
618 return UINT_MAX;
619 return a / b;
620}
621
622static inline unsigned int div_up(unsigned int a, unsigned int b)
623{
624 unsigned int r;
625 unsigned int q;
626 if (b == 0)
627 return UINT_MAX;
628 q = div32(a, b, &r);
629 if (r)
630 ++q;
631 return q;
632}
633
634static inline unsigned int mul(unsigned int a, unsigned int b)
635{
636 if (a == 0)
637 return 0;
638 if (div_down(UINT_MAX, a) < b)
639 return UINT_MAX;
640 return a * b;
641}
642
643static inline unsigned int muldiv32(unsigned int a, unsigned int b,
644 unsigned int c, unsigned int *r)
645{
646 u_int64_t n = (u_int64_t) a * b;
647 if (c == 0) {
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200648 snd_BUG_ON(!n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 *r = 0;
650 return UINT_MAX;
651 }
Takashi Iwai3f7440a2009-06-05 17:40:04 +0200652 n = div_u64_rem(n, c, r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (n >= UINT_MAX) {
654 *r = 0;
655 return UINT_MAX;
656 }
657 return n;
658}
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660/**
661 * snd_interval_refine - refine the interval value of configurator
662 * @i: the interval value to refine
663 * @v: the interval value to refer to
664 *
665 * Refines the interval value with the reference value.
666 * The interval is changed to the range satisfying both intervals.
667 * The interval status (min, max, integer, etc.) are evaluated.
668 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100669 * Return: Positive if the value is changed, zero if it's not changed, or a
670 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100672int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674 int changed = 0;
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 (i->min < v->min) {
678 i->min = v->min;
679 i->openmin = v->openmin;
680 changed = 1;
681 } else if (i->min == v->min && !i->openmin && v->openmin) {
682 i->openmin = 1;
683 changed = 1;
684 }
685 if (i->max > v->max) {
686 i->max = v->max;
687 i->openmax = v->openmax;
688 changed = 1;
689 } else if (i->max == v->max && !i->openmax && v->openmax) {
690 i->openmax = 1;
691 changed = 1;
692 }
693 if (!i->integer && v->integer) {
694 i->integer = 1;
695 changed = 1;
696 }
697 if (i->integer) {
698 if (i->openmin) {
699 i->min++;
700 i->openmin = 0;
701 }
702 if (i->openmax) {
703 i->max--;
704 i->openmax = 0;
705 }
706 } else if (!i->openmin && !i->openmax && i->min == i->max)
707 i->integer = 1;
708 if (snd_interval_checkempty(i)) {
709 snd_interval_none(i);
710 return -EINVAL;
711 }
712 return changed;
713}
714
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200715EXPORT_SYMBOL(snd_interval_refine);
716
Takashi Iwai877211f2005-11-17 13:59:38 +0100717static int snd_interval_refine_first(struct snd_interval *i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200719 if (snd_BUG_ON(snd_interval_empty(i)))
720 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 if (snd_interval_single(i))
722 return 0;
723 i->max = i->min;
724 i->openmax = i->openmin;
725 if (i->openmax)
726 i->max++;
727 return 1;
728}
729
Takashi Iwai877211f2005-11-17 13:59:38 +0100730static int snd_interval_refine_last(struct snd_interval *i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
Takashi Iwai7eaa9432008-08-08 17:09:09 +0200732 if (snd_BUG_ON(snd_interval_empty(i)))
733 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 if (snd_interval_single(i))
735 return 0;
736 i->min = i->max;
737 i->openmin = i->openmax;
738 if (i->openmin)
739 i->min--;
740 return 1;
741}
742
Takashi Iwai877211f2005-11-17 13:59:38 +0100743void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 if (a->empty || b->empty) {
746 snd_interval_none(c);
747 return;
748 }
749 c->empty = 0;
750 c->min = mul(a->min, b->min);
751 c->openmin = (a->openmin || b->openmin);
752 c->max = mul(a->max, b->max);
753 c->openmax = (a->openmax || b->openmax);
754 c->integer = (a->integer && b->integer);
755}
756
757/**
758 * snd_interval_div - refine the interval value with division
Takashi Iwaidf8db932005-09-07 13:38:19 +0200759 * @a: dividend
760 * @b: divisor
761 * @c: quotient
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 *
763 * c = a / b
764 *
765 * Returns non-zero if the value is changed, zero if not changed.
766 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100767void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768{
769 unsigned int r;
770 if (a->empty || b->empty) {
771 snd_interval_none(c);
772 return;
773 }
774 c->empty = 0;
775 c->min = div32(a->min, b->max, &r);
776 c->openmin = (r || a->openmin || b->openmax);
777 if (b->min > 0) {
778 c->max = div32(a->max, b->min, &r);
779 if (r) {
780 c->max++;
781 c->openmax = 1;
782 } else
783 c->openmax = (a->openmax || b->openmin);
784 } else {
785 c->max = UINT_MAX;
786 c->openmax = 0;
787 }
788 c->integer = 0;
789}
790
791/**
792 * snd_interval_muldivk - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200793 * @a: dividend 1
794 * @b: dividend 2
795 * @k: divisor (as integer)
796 * @c: result
797 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 * c = a * b / k
799 *
800 * Returns non-zero if the value is changed, zero if not changed.
801 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100802void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
803 unsigned int k, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804{
805 unsigned int r;
806 if (a->empty || b->empty) {
807 snd_interval_none(c);
808 return;
809 }
810 c->empty = 0;
811 c->min = muldiv32(a->min, b->min, k, &r);
812 c->openmin = (r || a->openmin || b->openmin);
813 c->max = muldiv32(a->max, b->max, k, &r);
814 if (r) {
815 c->max++;
816 c->openmax = 1;
817 } else
818 c->openmax = (a->openmax || b->openmax);
819 c->integer = 0;
820}
821
822/**
823 * snd_interval_mulkdiv - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200824 * @a: dividend 1
825 * @k: dividend 2 (as integer)
826 * @b: divisor
827 * @c: result
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 *
829 * c = a * k / b
830 *
831 * Returns non-zero if the value is changed, zero if not changed.
832 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100833void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
834 const struct snd_interval *b, struct snd_interval *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835{
836 unsigned int r;
837 if (a->empty || b->empty) {
838 snd_interval_none(c);
839 return;
840 }
841 c->empty = 0;
842 c->min = muldiv32(a->min, k, b->max, &r);
843 c->openmin = (r || a->openmin || b->openmax);
844 if (b->min > 0) {
845 c->max = muldiv32(a->max, k, b->min, &r);
846 if (r) {
847 c->max++;
848 c->openmax = 1;
849 } else
850 c->openmax = (a->openmax || b->openmin);
851 } else {
852 c->max = UINT_MAX;
853 c->openmax = 0;
854 }
855 c->integer = 0;
856}
857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858/* ---- */
859
860
861/**
862 * snd_interval_ratnum - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200863 * @i: interval to refine
864 * @rats_count: number of ratnum_t
865 * @rats: ratnum_t array
866 * @nump: pointer to store the resultant numerator
867 * @denp: pointer to store the resultant denominator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100869 * Return: Positive if the value is changed, zero if it's not changed, or a
870 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100872int snd_interval_ratnum(struct snd_interval *i,
873 unsigned int rats_count, struct snd_ratnum *rats,
874 unsigned int *nump, unsigned int *denp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
Krzysztof Helt8374e242009-12-21 17:07:08 +0100876 unsigned int best_num, best_den;
877 int best_diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 unsigned int k;
Takashi Iwai877211f2005-11-17 13:59:38 +0100879 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 int err;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100881 unsigned int result_num, result_den;
882 int result_diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
884 best_num = best_den = best_diff = 0;
885 for (k = 0; k < rats_count; ++k) {
886 unsigned int num = rats[k].num;
887 unsigned int den;
888 unsigned int q = i->min;
889 int diff;
890 if (q == 0)
891 q = 1;
Krzysztof Helt40962d72009-12-19 18:31:04 +0100892 den = div_up(num, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 if (den < rats[k].den_min)
894 continue;
895 if (den > rats[k].den_max)
896 den = rats[k].den_max;
897 else {
898 unsigned int r;
899 r = (den - rats[k].den_min) % rats[k].den_step;
900 if (r != 0)
901 den -= r;
902 }
903 diff = num - q * den;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100904 if (diff < 0)
905 diff = -diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 if (best_num == 0 ||
907 diff * best_den < best_diff * den) {
908 best_diff = diff;
909 best_den = den;
910 best_num = num;
911 }
912 }
913 if (best_den == 0) {
914 i->empty = 1;
915 return -EINVAL;
916 }
917 t.min = div_down(best_num, best_den);
918 t.openmin = !!(best_num % best_den);
919
Krzysztof Helt8374e242009-12-21 17:07:08 +0100920 result_num = best_num;
921 result_diff = best_diff;
922 result_den = best_den;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 best_num = best_den = best_diff = 0;
924 for (k = 0; k < rats_count; ++k) {
925 unsigned int num = rats[k].num;
926 unsigned int den;
927 unsigned int q = i->max;
928 int diff;
929 if (q == 0) {
930 i->empty = 1;
931 return -EINVAL;
932 }
Krzysztof Helt40962d72009-12-19 18:31:04 +0100933 den = div_down(num, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (den > rats[k].den_max)
935 continue;
936 if (den < rats[k].den_min)
937 den = rats[k].den_min;
938 else {
939 unsigned int r;
940 r = (den - rats[k].den_min) % rats[k].den_step;
941 if (r != 0)
942 den += rats[k].den_step - r;
943 }
944 diff = q * den - num;
Krzysztof Helt8374e242009-12-21 17:07:08 +0100945 if (diff < 0)
946 diff = -diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 if (best_num == 0 ||
948 diff * best_den < best_diff * den) {
949 best_diff = diff;
950 best_den = den;
951 best_num = num;
952 }
953 }
954 if (best_den == 0) {
955 i->empty = 1;
956 return -EINVAL;
957 }
958 t.max = div_up(best_num, best_den);
959 t.openmax = !!(best_num % best_den);
960 t.integer = 0;
961 err = snd_interval_refine(i, &t);
962 if (err < 0)
963 return err;
964
965 if (snd_interval_single(i)) {
Krzysztof Helt8374e242009-12-21 17:07:08 +0100966 if (best_diff * result_den < result_diff * best_den) {
967 result_num = best_num;
968 result_den = best_den;
969 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 if (nump)
Krzysztof Helt8374e242009-12-21 17:07:08 +0100971 *nump = result_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 if (denp)
Krzysztof Helt8374e242009-12-21 17:07:08 +0100973 *denp = result_den;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975 return err;
976}
977
Takashi Iwaie88e8ae62006-04-28 15:13:40 +0200978EXPORT_SYMBOL(snd_interval_ratnum);
979
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980/**
981 * snd_interval_ratden - refine the interval value
Takashi Iwaidf8db932005-09-07 13:38:19 +0200982 * @i: interval to refine
Takashi Iwai877211f2005-11-17 13:59:38 +0100983 * @rats_count: number of struct ratden
984 * @rats: struct ratden array
Takashi Iwaidf8db932005-09-07 13:38:19 +0200985 * @nump: pointer to store the resultant numerator
986 * @denp: pointer to store the resultant denominator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +0100988 * Return: Positive if the value is changed, zero if it's not changed, or a
989 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 */
Takashi Iwai877211f2005-11-17 13:59:38 +0100991static int snd_interval_ratden(struct snd_interval *i,
992 unsigned int rats_count, struct snd_ratden *rats,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 unsigned int *nump, unsigned int *denp)
994{
995 unsigned int best_num, best_diff, best_den;
996 unsigned int k;
Takashi Iwai877211f2005-11-17 13:59:38 +0100997 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 int err;
999
1000 best_num = best_den = best_diff = 0;
1001 for (k = 0; k < rats_count; ++k) {
1002 unsigned int num;
1003 unsigned int den = rats[k].den;
1004 unsigned int q = i->min;
1005 int diff;
1006 num = mul(q, den);
1007 if (num > rats[k].num_max)
1008 continue;
1009 if (num < rats[k].num_min)
1010 num = rats[k].num_max;
1011 else {
1012 unsigned int r;
1013 r = (num - rats[k].num_min) % rats[k].num_step;
1014 if (r != 0)
1015 num += rats[k].num_step - r;
1016 }
1017 diff = num - q * den;
1018 if (best_num == 0 ||
1019 diff * best_den < best_diff * den) {
1020 best_diff = diff;
1021 best_den = den;
1022 best_num = num;
1023 }
1024 }
1025 if (best_den == 0) {
1026 i->empty = 1;
1027 return -EINVAL;
1028 }
1029 t.min = div_down(best_num, best_den);
1030 t.openmin = !!(best_num % best_den);
1031
1032 best_num = best_den = best_diff = 0;
1033 for (k = 0; k < rats_count; ++k) {
1034 unsigned int num;
1035 unsigned int den = rats[k].den;
1036 unsigned int q = i->max;
1037 int diff;
1038 num = mul(q, den);
1039 if (num < rats[k].num_min)
1040 continue;
1041 if (num > rats[k].num_max)
1042 num = rats[k].num_max;
1043 else {
1044 unsigned int r;
1045 r = (num - rats[k].num_min) % rats[k].num_step;
1046 if (r != 0)
1047 num -= r;
1048 }
1049 diff = q * den - num;
1050 if (best_num == 0 ||
1051 diff * best_den < best_diff * den) {
1052 best_diff = diff;
1053 best_den = den;
1054 best_num = num;
1055 }
1056 }
1057 if (best_den == 0) {
1058 i->empty = 1;
1059 return -EINVAL;
1060 }
1061 t.max = div_up(best_num, best_den);
1062 t.openmax = !!(best_num % best_den);
1063 t.integer = 0;
1064 err = snd_interval_refine(i, &t);
1065 if (err < 0)
1066 return err;
1067
1068 if (snd_interval_single(i)) {
1069 if (nump)
1070 *nump = best_num;
1071 if (denp)
1072 *denp = best_den;
1073 }
1074 return err;
1075}
1076
1077/**
1078 * snd_interval_list - refine the interval value from the list
1079 * @i: the interval value to refine
1080 * @count: the number of elements in the list
1081 * @list: the value list
1082 * @mask: the bit-mask to evaluate
1083 *
1084 * Refines the interval value from the list.
1085 * When mask is non-zero, only the elements corresponding to bit 1 are
1086 * evaluated.
1087 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001088 * Return: Positive if the value is changed, zero if it's not changed, or a
1089 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 */
Mark Brown4af87a92012-03-14 19:48:43 +00001091int snd_interval_list(struct snd_interval *i, unsigned int count,
1092 const unsigned int *list, unsigned int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093{
1094 unsigned int k;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001095 struct snd_interval list_range;
Takashi Iwai0981a262007-02-01 14:53:49 +01001096
1097 if (!count) {
1098 i->empty = 1;
1099 return -EINVAL;
1100 }
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001101 snd_interval_any(&list_range);
1102 list_range.min = UINT_MAX;
1103 list_range.max = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 for (k = 0; k < count; k++) {
1105 if (mask && !(mask & (1 << k)))
1106 continue;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001107 if (!snd_interval_test(i, list[k]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 continue;
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001109 list_range.min = min(list_range.min, list[k]);
1110 list_range.max = max(list_range.max, list[k]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 }
Clemens Ladischb1ddaf62009-08-25 08:15:41 +02001112 return snd_interval_refine(i, &list_range);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113}
1114
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001115EXPORT_SYMBOL(snd_interval_list);
1116
Takashi Iwai877211f2005-11-17 13:59:38 +01001117static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
1119 unsigned int n;
1120 int changed = 0;
1121 n = (i->min - min) % step;
1122 if (n != 0 || i->openmin) {
1123 i->min += step - n;
1124 changed = 1;
1125 }
1126 n = (i->max - min) % step;
1127 if (n != 0 || i->openmax) {
1128 i->max -= n;
1129 changed = 1;
1130 }
1131 if (snd_interval_checkempty(i)) {
1132 i->empty = 1;
1133 return -EINVAL;
1134 }
1135 return changed;
1136}
1137
1138/* Info constraints helpers */
1139
1140/**
1141 * snd_pcm_hw_rule_add - add the hw-constraint rule
1142 * @runtime: the pcm runtime instance
1143 * @cond: condition bits
1144 * @var: the variable to evaluate
1145 * @func: the evaluation function
1146 * @private: the private data pointer passed to function
1147 * @dep: the dependent variables
1148 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001149 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001151int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 int var,
1153 snd_pcm_hw_rule_func_t func, void *private,
1154 int dep, ...)
1155{
Takashi Iwai877211f2005-11-17 13:59:38 +01001156 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1157 struct snd_pcm_hw_rule *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 unsigned int k;
1159 va_list args;
1160 va_start(args, dep);
1161 if (constrs->rules_num >= constrs->rules_all) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001162 struct snd_pcm_hw_rule *new;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 unsigned int new_rules = constrs->rules_all + 16;
1164 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001165 if (!new) {
1166 va_end(args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 return -ENOMEM;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 if (constrs->rules) {
1170 memcpy(new, constrs->rules,
1171 constrs->rules_num * sizeof(*c));
1172 kfree(constrs->rules);
1173 }
1174 constrs->rules = new;
1175 constrs->rules_all = new_rules;
1176 }
1177 c = &constrs->rules[constrs->rules_num];
1178 c->cond = cond;
1179 c->func = func;
1180 c->var = var;
1181 c->private = private;
1182 k = 0;
1183 while (1) {
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001184 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
1185 va_end(args);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001186 return -EINVAL;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001187 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 c->deps[k++] = dep;
1189 if (dep < 0)
1190 break;
1191 dep = va_arg(args, int);
1192 }
1193 constrs->rules_num++;
1194 va_end(args);
1195 return 0;
Jesper Juhl87a1c8a2010-12-21 00:03:17 +01001196}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001198EXPORT_SYMBOL(snd_pcm_hw_rule_add);
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001201 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
Takashi Iwaidf8db932005-09-07 13:38:19 +02001202 * @runtime: PCM runtime instance
1203 * @var: hw_params variable to apply the mask
1204 * @mask: the bitmap mask
1205 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001206 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001207 *
1208 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001210int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 u_int32_t mask)
1212{
Takashi Iwai877211f2005-11-17 13:59:38 +01001213 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1214 struct snd_mask *maskp = constrs_mask(constrs, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 *maskp->bits &= mask;
1216 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
1217 if (*maskp->bits == 0)
1218 return -EINVAL;
1219 return 0;
1220}
1221
1222/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001223 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
Takashi Iwaidf8db932005-09-07 13:38:19 +02001224 * @runtime: PCM runtime instance
1225 * @var: hw_params variable to apply the mask
1226 * @mask: the 64bit bitmap mask
1227 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001228 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001229 *
1230 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001232int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 u_int64_t mask)
1234{
Takashi Iwai877211f2005-11-17 13:59:38 +01001235 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1236 struct snd_mask *maskp = constrs_mask(constrs, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 maskp->bits[0] &= (u_int32_t)mask;
1238 maskp->bits[1] &= (u_int32_t)(mask >> 32);
1239 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
1240 if (! maskp->bits[0] && ! maskp->bits[1])
1241 return -EINVAL;
1242 return 0;
1243}
1244
1245/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001246 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
Takashi Iwaidf8db932005-09-07 13:38:19 +02001247 * @runtime: PCM runtime instance
1248 * @var: hw_params variable to apply the integer constraint
1249 *
1250 * Apply the constraint of integer to an interval parameter.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001251 *
1252 * Return: Positive if the value is changed, zero if it's not changed, or a
1253 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001255int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256{
Takashi Iwai877211f2005-11-17 13:59:38 +01001257 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 return snd_interval_setinteger(constrs_interval(constrs, var));
1259}
1260
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001261EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
1262
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001264 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
Takashi Iwaidf8db932005-09-07 13:38:19 +02001265 * @runtime: PCM runtime instance
1266 * @var: hw_params variable to apply the range
1267 * @min: the minimal value
1268 * @max: the maximal value
1269 *
1270 * Apply the min/max range constraint to an interval parameter.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001271 *
1272 * Return: Positive if the value is changed, zero if it's not changed, or a
1273 * negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001275int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 unsigned int min, unsigned int max)
1277{
Takashi Iwai877211f2005-11-17 13:59:38 +01001278 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1279 struct snd_interval t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 t.min = min;
1281 t.max = max;
1282 t.openmin = t.openmax = 0;
1283 t.integer = 0;
1284 return snd_interval_refine(constrs_interval(constrs, var), &t);
1285}
1286
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001287EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
1288
Takashi Iwai877211f2005-11-17 13:59:38 +01001289static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
1290 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291{
Takashi Iwai877211f2005-11-17 13:59:38 +01001292 struct snd_pcm_hw_constraint_list *list = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
1294}
1295
1296
1297/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001298 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001299 * @runtime: PCM runtime instance
1300 * @cond: condition bits
1301 * @var: hw_params variable to apply the list constraint
1302 * @l: list
1303 *
1304 * Apply the list of constraints to an interval parameter.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001305 *
1306 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001308int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 unsigned int cond,
1310 snd_pcm_hw_param_t var,
Mark Brown14641892012-07-05 12:15:01 +01001311 const struct snd_pcm_hw_constraint_list *l)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312{
1313 return snd_pcm_hw_rule_add(runtime, cond, var,
Mark Brown14641892012-07-05 12:15:01 +01001314 snd_pcm_hw_rule_list, (void *)l,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 var, -1);
1316}
1317
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001318EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
1319
Takashi Iwai877211f2005-11-17 13:59:38 +01001320static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
1321 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322{
Takashi Iwai877211f2005-11-17 13:59:38 +01001323 struct snd_pcm_hw_constraint_ratnums *r = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 unsigned int num = 0, den = 0;
1325 int err;
1326 err = snd_interval_ratnum(hw_param_interval(params, rule->var),
1327 r->nrats, r->rats, &num, &den);
1328 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1329 params->rate_num = num;
1330 params->rate_den = den;
1331 }
1332 return err;
1333}
1334
1335/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001336 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001337 * @runtime: PCM runtime instance
1338 * @cond: condition bits
1339 * @var: hw_params variable to apply the ratnums constraint
Takashi Iwai877211f2005-11-17 13:59:38 +01001340 * @r: struct snd_ratnums constriants
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001341 *
1342 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001344int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 unsigned int cond,
1346 snd_pcm_hw_param_t var,
Takashi Iwai877211f2005-11-17 13:59:38 +01001347 struct snd_pcm_hw_constraint_ratnums *r)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
1349 return snd_pcm_hw_rule_add(runtime, cond, var,
1350 snd_pcm_hw_rule_ratnums, r,
1351 var, -1);
1352}
1353
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001354EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
1355
Takashi Iwai877211f2005-11-17 13:59:38 +01001356static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
1357 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358{
Takashi Iwai877211f2005-11-17 13:59:38 +01001359 struct snd_pcm_hw_constraint_ratdens *r = rule->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 unsigned int num = 0, den = 0;
1361 int err = snd_interval_ratden(hw_param_interval(params, rule->var),
1362 r->nrats, r->rats, &num, &den);
1363 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1364 params->rate_num = num;
1365 params->rate_den = den;
1366 }
1367 return err;
1368}
1369
1370/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001371 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
Takashi Iwaidf8db932005-09-07 13:38:19 +02001372 * @runtime: PCM runtime instance
1373 * @cond: condition bits
1374 * @var: hw_params variable to apply the ratdens constraint
Takashi Iwai877211f2005-11-17 13:59:38 +01001375 * @r: struct snd_ratdens constriants
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001376 *
1377 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001379int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 unsigned int cond,
1381 snd_pcm_hw_param_t var,
Takashi Iwai877211f2005-11-17 13:59:38 +01001382 struct snd_pcm_hw_constraint_ratdens *r)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383{
1384 return snd_pcm_hw_rule_add(runtime, cond, var,
1385 snd_pcm_hw_rule_ratdens, r,
1386 var, -1);
1387}
1388
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001389EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
1390
Takashi Iwai877211f2005-11-17 13:59:38 +01001391static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
1392 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393{
1394 unsigned int l = (unsigned long) rule->private;
1395 int width = l & 0xffff;
1396 unsigned int msbits = l >> 16;
Takashi Iwai877211f2005-11-17 13:59:38 +01001397 struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 if (snd_interval_single(i) && snd_interval_value(i) == width)
1399 params->msbits = msbits;
1400 return 0;
1401}
1402
1403/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001404 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001405 * @runtime: PCM runtime instance
1406 * @cond: condition bits
1407 * @width: sample bits width
1408 * @msbits: msbits width
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001409 *
1410 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001412int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 unsigned int cond,
1414 unsigned int width,
1415 unsigned int msbits)
1416{
1417 unsigned long l = (msbits << 16) | width;
1418 return snd_pcm_hw_rule_add(runtime, cond, -1,
1419 snd_pcm_hw_rule_msbits,
1420 (void*) l,
1421 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1422}
1423
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001424EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
1425
Takashi Iwai877211f2005-11-17 13:59:38 +01001426static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
1427 struct snd_pcm_hw_rule *rule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428{
1429 unsigned long step = (unsigned long) rule->private;
1430 return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
1431}
1432
1433/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001434 * snd_pcm_hw_constraint_step - add a hw constraint step rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001435 * @runtime: PCM runtime instance
1436 * @cond: condition bits
1437 * @var: hw_params variable to apply the step constraint
1438 * @step: step size
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001439 *
1440 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001442int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 unsigned int cond,
1444 snd_pcm_hw_param_t var,
1445 unsigned long step)
1446{
1447 return snd_pcm_hw_rule_add(runtime, cond, var,
1448 snd_pcm_hw_rule_step, (void *) step,
1449 var, -1);
1450}
1451
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001452EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
1453
Takashi Iwai877211f2005-11-17 13:59:38 +01001454static 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 -07001455{
Marcin Åšlusarz67c39312007-12-14 12:53:21 +01001456 static unsigned int pow2_sizes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1458 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1459 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1460 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1461 };
1462 return snd_interval_list(hw_param_interval(params, rule->var),
1463 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
1464}
1465
1466/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001467 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
Takashi Iwaidf8db932005-09-07 13:38:19 +02001468 * @runtime: PCM runtime instance
1469 * @cond: condition bits
1470 * @var: hw_params variable to apply the power-of-2 constraint
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001471 *
1472 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001474int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 unsigned int cond,
1476 snd_pcm_hw_param_t var)
1477{
1478 return snd_pcm_hw_rule_add(runtime, cond, var,
1479 snd_pcm_hw_rule_pow2, NULL,
1480 var, -1);
1481}
1482
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001483EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
1484
Clemens Ladischd5b702a2011-09-16 23:03:02 +02001485static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,
1486 struct snd_pcm_hw_rule *rule)
1487{
1488 unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;
1489 struct snd_interval *rate;
1490
1491 rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1492 return snd_interval_list(rate, 1, &base_rate, 0);
1493}
1494
1495/**
1496 * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
1497 * @runtime: PCM runtime instance
1498 * @base_rate: the rate at which the hardware does not resample
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001499 *
1500 * Return: Zero if successful, or a negative error code on failure.
Clemens Ladischd5b702a2011-09-16 23:03:02 +02001501 */
1502int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
1503 unsigned int base_rate)
1504{
1505 return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,
1506 SNDRV_PCM_HW_PARAM_RATE,
1507 snd_pcm_hw_rule_noresample_func,
1508 (void *)(uintptr_t)base_rate,
1509 SNDRV_PCM_HW_PARAM_RATE, -1);
1510}
1511EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);
1512
Takashi Iwai877211f2005-11-17 13:59:38 +01001513static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001514 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515{
1516 if (hw_is_mask(var)) {
1517 snd_mask_any(hw_param_mask(params, var));
1518 params->cmask |= 1 << var;
1519 params->rmask |= 1 << var;
1520 return;
1521 }
1522 if (hw_is_interval(var)) {
1523 snd_interval_any(hw_param_interval(params, var));
1524 params->cmask |= 1 << var;
1525 params->rmask |= 1 << var;
1526 return;
1527 }
1528 snd_BUG();
1529}
1530
Takashi Iwai877211f2005-11-17 13:59:38 +01001531void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532{
1533 unsigned int k;
1534 memset(params, 0, sizeof(*params));
1535 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
1536 _snd_pcm_hw_param_any(params, k);
1537 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
1538 _snd_pcm_hw_param_any(params, k);
1539 params->info = ~0U;
1540}
1541
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001542EXPORT_SYMBOL(_snd_pcm_hw_params_any);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543
1544/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001545 * snd_pcm_hw_param_value - return @params field @var value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001546 * @params: the hw_params instance
1547 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001548 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001550 * Return: The value for field @var if it's fixed in configuration space
1551 * defined by @params. -%EINVAL otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001553int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
1554 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555{
1556 if (hw_is_mask(var)) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001557 const struct snd_mask *mask = hw_param_mask_c(params, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 if (!snd_mask_single(mask))
1559 return -EINVAL;
1560 if (dir)
1561 *dir = 0;
1562 return snd_mask_value(mask);
1563 }
1564 if (hw_is_interval(var)) {
Takashi Iwai877211f2005-11-17 13:59:38 +01001565 const struct snd_interval *i = hw_param_interval_c(params, var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 if (!snd_interval_single(i))
1567 return -EINVAL;
1568 if (dir)
1569 *dir = i->openmin;
1570 return snd_interval_value(i);
1571 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 return -EINVAL;
1573}
1574
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001575EXPORT_SYMBOL(snd_pcm_hw_param_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Takashi Iwai877211f2005-11-17 13:59:38 +01001577void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 snd_pcm_hw_param_t var)
1579{
1580 if (hw_is_mask(var)) {
1581 snd_mask_none(hw_param_mask(params, var));
1582 params->cmask |= 1 << var;
1583 params->rmask |= 1 << var;
1584 } else if (hw_is_interval(var)) {
1585 snd_interval_none(hw_param_interval(params, var));
1586 params->cmask |= 1 << var;
1587 params->rmask |= 1 << var;
1588 } else {
1589 snd_BUG();
1590 }
1591}
1592
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001593EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Takashi Iwai877211f2005-11-17 13:59:38 +01001595static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001596 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597{
1598 int changed;
1599 if (hw_is_mask(var))
1600 changed = snd_mask_refine_first(hw_param_mask(params, var));
1601 else if (hw_is_interval(var))
1602 changed = snd_interval_refine_first(hw_param_interval(params, var));
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001603 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 if (changed) {
1606 params->cmask |= 1 << var;
1607 params->rmask |= 1 << var;
1608 }
1609 return changed;
1610}
1611
1612
1613/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001614 * snd_pcm_hw_param_first - refine config space and return minimum value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001615 * @pcm: PCM instance
1616 * @params: the hw_params instance
1617 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001618 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001620 * Inside configuration space defined by @params remove from @var all
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 * values > minimum. Reduce configuration space accordingly.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001622 *
1623 * Return: The minimum, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001625int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
1626 struct snd_pcm_hw_params *params,
1627 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628{
1629 int changed = _snd_pcm_hw_param_first(params, var);
1630 if (changed < 0)
1631 return changed;
1632 if (params->rmask) {
1633 int err = snd_pcm_hw_refine(pcm, params);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001634 if (snd_BUG_ON(err < 0))
1635 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 }
1637 return snd_pcm_hw_param_value(params, var, dir);
1638}
1639
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001640EXPORT_SYMBOL(snd_pcm_hw_param_first);
1641
Takashi Iwai877211f2005-11-17 13:59:38 +01001642static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
Adrian Bunk123992f2005-05-18 18:02:04 +02001643 snd_pcm_hw_param_t var)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644{
1645 int changed;
1646 if (hw_is_mask(var))
1647 changed = snd_mask_refine_last(hw_param_mask(params, var));
1648 else if (hw_is_interval(var))
1649 changed = snd_interval_refine_last(hw_param_interval(params, var));
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001650 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 if (changed) {
1653 params->cmask |= 1 << var;
1654 params->rmask |= 1 << var;
1655 }
1656 return changed;
1657}
1658
1659
1660/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001661 * snd_pcm_hw_param_last - refine config space and return maximum value
Takashi Iwaidf8db932005-09-07 13:38:19 +02001662 * @pcm: PCM instance
1663 * @params: the hw_params instance
1664 * @var: parameter to retrieve
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001665 * @dir: pointer to the direction (-1,0,1) or %NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001667 * Inside configuration space defined by @params remove from @var all
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 * values < maximum. Reduce configuration space accordingly.
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001669 *
1670 * Return: The maximum, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 */
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001672int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
1673 struct snd_pcm_hw_params *params,
1674 snd_pcm_hw_param_t var, int *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675{
1676 int changed = _snd_pcm_hw_param_last(params, var);
1677 if (changed < 0)
1678 return changed;
1679 if (params->rmask) {
1680 int err = snd_pcm_hw_refine(pcm, params);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001681 if (snd_BUG_ON(err < 0))
1682 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
1684 return snd_pcm_hw_param_value(params, var, dir);
1685}
1686
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001687EXPORT_SYMBOL(snd_pcm_hw_param_last);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689/**
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001690 * snd_pcm_hw_param_choose - choose a configuration defined by @params
Takashi Iwaidf8db932005-09-07 13:38:19 +02001691 * @pcm: PCM instance
1692 * @params: the hw_params instance
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 *
Randy Dunlap1c85cc62008-10-15 14:38:40 -07001694 * Choose one configuration from configuration space defined by @params.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 * The configuration chosen is that obtained fixing in this order:
1696 * first access, first format, first subformat, min channels,
1697 * min rate, min period time, max buffer size, min tick time
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001698 *
1699 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 */
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001701int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1702 struct snd_pcm_hw_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001704 static int vars[] = {
1705 SNDRV_PCM_HW_PARAM_ACCESS,
1706 SNDRV_PCM_HW_PARAM_FORMAT,
1707 SNDRV_PCM_HW_PARAM_SUBFORMAT,
1708 SNDRV_PCM_HW_PARAM_CHANNELS,
1709 SNDRV_PCM_HW_PARAM_RATE,
1710 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1711 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1712 SNDRV_PCM_HW_PARAM_TICK_TIME,
1713 -1
1714 };
1715 int err, *v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001717 for (v = vars; *v != -1; v++) {
1718 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
1719 err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1720 else
1721 err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001722 if (snd_BUG_ON(err < 0))
1723 return err;
Takashi Iwai2f4ca8e2006-04-28 15:13:40 +02001724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 return 0;
1726}
1727
Takashi Iwai877211f2005-11-17 13:59:38 +01001728static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 void *arg)
1730{
Takashi Iwai877211f2005-11-17 13:59:38 +01001731 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 unsigned long flags;
1733 snd_pcm_stream_lock_irqsave(substream, flags);
1734 if (snd_pcm_running(substream) &&
1735 snd_pcm_update_hw_ptr(substream) >= 0)
1736 runtime->status->hw_ptr %= runtime->buffer_size;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -05001737 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 runtime->status->hw_ptr = 0;
Pierre-Louis Bossart0e8014d2012-10-22 16:42:14 -05001739 runtime->hw_ptr_wrap = 0;
1740 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 snd_pcm_stream_unlock_irqrestore(substream, flags);
1742 return 0;
1743}
1744
Takashi Iwai877211f2005-11-17 13:59:38 +01001745static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 void *arg)
1747{
Takashi Iwai877211f2005-11-17 13:59:38 +01001748 struct snd_pcm_channel_info *info = arg;
1749 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 int width;
1751 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
1752 info->offset = -1;
1753 return 0;
1754 }
1755 width = snd_pcm_format_physical_width(runtime->format);
1756 if (width < 0)
1757 return width;
1758 info->offset = 0;
1759 switch (runtime->access) {
1760 case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
1761 case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
1762 info->first = info->channel * width;
1763 info->step = runtime->channels * width;
1764 break;
1765 case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
1766 case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
1767 {
1768 size_t size = runtime->dma_bytes / runtime->channels;
1769 info->first = info->channel * size * 8;
1770 info->step = width;
1771 break;
1772 }
1773 default:
1774 snd_BUG();
1775 break;
1776 }
1777 return 0;
1778}
1779
Jaroslav Kysela8bea8692009-04-27 09:44:40 +02001780static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
1781 void *arg)
1782{
1783 struct snd_pcm_hw_params *params = arg;
1784 snd_pcm_format_t format;
1785 int channels, width;
1786
1787 params->fifo_size = substream->runtime->hw.fifo_size;
1788 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
1789 format = params_format(params);
1790 channels = params_channels(params);
1791 width = snd_pcm_format_physical_width(format);
1792 params->fifo_size /= width * channels;
1793 }
1794 return 0;
1795}
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797/**
1798 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1799 * @substream: the pcm substream instance
1800 * @cmd: ioctl command
1801 * @arg: ioctl argument
1802 *
1803 * Processes the generic ioctl commands for PCM.
1804 * Can be passed as the ioctl callback for PCM ops.
1805 *
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01001806 * Return: Zero if successful, or a negative error code on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001808int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 unsigned int cmd, void *arg)
1810{
1811 switch (cmd) {
1812 case SNDRV_PCM_IOCTL1_INFO:
1813 return 0;
1814 case SNDRV_PCM_IOCTL1_RESET:
1815 return snd_pcm_lib_ioctl_reset(substream, arg);
1816 case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
1817 return snd_pcm_lib_ioctl_channel_info(substream, arg);
Jaroslav Kysela8bea8692009-04-27 09:44:40 +02001818 case SNDRV_PCM_IOCTL1_FIFO_SIZE:
1819 return snd_pcm_lib_ioctl_fifo_size(substream, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 }
1821 return -ENXIO;
1822}
1823
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001824EXPORT_SYMBOL(snd_pcm_lib_ioctl);
1825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826/**
1827 * snd_pcm_period_elapsed - update the pcm status for the next period
1828 * @substream: the pcm substream instance
1829 *
1830 * This function is called from the interrupt handler when the
1831 * PCM has processed the period size. It will update the current
Takashi Iwai31e89602008-01-08 18:09:57 +01001832 * pointer, wake up sleepers, etc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 *
1834 * Even if more than one periods have elapsed since the last call, you
1835 * have to call this only once.
1836 */
Takashi Iwai877211f2005-11-17 13:59:38 +01001837void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838{
Takashi Iwai877211f2005-11-17 13:59:38 +01001839 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 unsigned long flags;
1841
Takashi Iwai7eaa9432008-08-08 17:09:09 +02001842 if (PCM_RUNTIME_CHECK(substream))
1843 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845
1846 if (runtime->transfer_ack_begin)
1847 runtime->transfer_ack_begin(substream);
1848
1849 snd_pcm_stream_lock_irqsave(substream, flags);
1850 if (!snd_pcm_running(substream) ||
Jaroslav Kyselaf2404062010-01-05 17:19:34 +01001851 snd_pcm_update_hw_ptr0(substream, 1) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 goto _end;
1853
1854 if (substream->timer_running)
1855 snd_timer_interrupt(substream->timer, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 _end:
1857 snd_pcm_stream_unlock_irqrestore(substream, flags);
1858 if (runtime->transfer_ack_end)
1859 runtime->transfer_ack_end(substream);
1860 kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
1861}
1862
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02001863EXPORT_SYMBOL(snd_pcm_period_elapsed);
1864
Takashi Iwai13075512008-01-08 18:08:14 +01001865/*
1866 * Wait until avail_min data becomes available
1867 * Returns a negative error code if any error occurs during operation.
1868 * The available space is stored on availp. When err = 0 and avail = 0
1869 * on the capture stream, it indicates the stream is in DRAINING state.
1870 */
David Dillow5daeba32010-06-27 00:13:20 +02001871static int wait_for_avail(struct snd_pcm_substream *substream,
Takashi Iwai13075512008-01-08 18:08:14 +01001872 snd_pcm_uframes_t *availp)
1873{
1874 struct snd_pcm_runtime *runtime = substream->runtime;
1875 int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
1876 wait_queue_t wait;
1877 int err = 0;
1878 snd_pcm_uframes_t avail = 0;
Takashi Iwaif2b36142011-05-26 08:09:38 +02001879 long wait_time, tout;
Takashi Iwai13075512008-01-08 18:08:14 +01001880
Arjan van de Ven763437a2011-09-15 08:49:25 +02001881 init_waitqueue_entry(&wait, current);
1882 set_current_state(TASK_INTERRUPTIBLE);
1883 add_wait_queue(&runtime->tsleep, &wait);
1884
Takashi Iwaif2b36142011-05-26 08:09:38 +02001885 if (runtime->no_period_wakeup)
1886 wait_time = MAX_SCHEDULE_TIMEOUT;
1887 else {
1888 wait_time = 10;
1889 if (runtime->rate) {
1890 long t = runtime->period_size * 2 / runtime->rate;
1891 wait_time = max(t, wait_time);
1892 }
1893 wait_time = msecs_to_jiffies(wait_time * 1000);
1894 }
Arjan van de Ven763437a2011-09-15 08:49:25 +02001895
Takashi Iwai13075512008-01-08 18:08:14 +01001896 for (;;) {
1897 if (signal_pending(current)) {
1898 err = -ERESTARTSYS;
1899 break;
1900 }
Arjan van de Ven763437a2011-09-15 08:49:25 +02001901
1902 /*
1903 * We need to check if space became available already
1904 * (and thus the wakeup happened already) first to close
1905 * the race of space already having become available.
1906 * This check must happen after been added to the waitqueue
1907 * and having current state be INTERRUPTIBLE.
1908 */
1909 if (is_playback)
1910 avail = snd_pcm_playback_avail(runtime);
1911 else
1912 avail = snd_pcm_capture_avail(runtime);
1913 if (avail >= runtime->twake)
1914 break;
Takashi Iwai13075512008-01-08 18:08:14 +01001915 snd_pcm_stream_unlock_irq(substream);
Arjan van de Ven763437a2011-09-15 08:49:25 +02001916
1917 tout = schedule_timeout(wait_time);
1918
Takashi Iwai13075512008-01-08 18:08:14 +01001919 snd_pcm_stream_lock_irq(substream);
Arjan van de Ven763437a2011-09-15 08:49:25 +02001920 set_current_state(TASK_INTERRUPTIBLE);
Takashi Iwai13075512008-01-08 18:08:14 +01001921 switch (runtime->status->state) {
1922 case SNDRV_PCM_STATE_SUSPENDED:
1923 err = -ESTRPIPE;
1924 goto _endloop;
1925 case SNDRV_PCM_STATE_XRUN:
1926 err = -EPIPE;
1927 goto _endloop;
1928 case SNDRV_PCM_STATE_DRAINING:
1929 if (is_playback)
1930 err = -EPIPE;
1931 else
1932 avail = 0; /* indicate draining */
1933 goto _endloop;
1934 case SNDRV_PCM_STATE_OPEN:
1935 case SNDRV_PCM_STATE_SETUP:
1936 case SNDRV_PCM_STATE_DISCONNECTED:
1937 err = -EBADFD;
1938 goto _endloop;
1939 }
1940 if (!tout) {
1941 snd_printd("%s write error (DMA or IRQ trouble?)\n",
1942 is_playback ? "playback" : "capture");
1943 err = -EIO;
1944 break;
1945 }
Takashi Iwai13075512008-01-08 18:08:14 +01001946 }
1947 _endloop:
Arjan van de Ven763437a2011-09-15 08:49:25 +02001948 set_current_state(TASK_RUNNING);
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01001949 remove_wait_queue(&runtime->tsleep, &wait);
Takashi Iwai13075512008-01-08 18:08:14 +01001950 *availp = avail;
1951 return err;
1952}
1953
Takashi Iwai877211f2005-11-17 13:59:38 +01001954static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 unsigned int hwoff,
1956 unsigned long data, unsigned int off,
1957 snd_pcm_uframes_t frames)
1958{
Takashi Iwai877211f2005-11-17 13:59:38 +01001959 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 int err;
1961 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1962 if (substream->ops->copy) {
1963 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1964 return err;
1965 } else {
1966 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1968 return -EFAULT;
1969 }
1970 return 0;
1971}
1972
Takashi Iwai877211f2005-11-17 13:59:38 +01001973typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 unsigned long data, unsigned int off,
1975 snd_pcm_uframes_t size);
1976
Takashi Iwai877211f2005-11-17 13:59:38 +01001977static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 unsigned long data,
1979 snd_pcm_uframes_t size,
1980 int nonblock,
1981 transfer_f transfer)
1982{
Takashi Iwai877211f2005-11-17 13:59:38 +01001983 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 snd_pcm_uframes_t xfer = 0;
1985 snd_pcm_uframes_t offset = 0;
Takashi Iwai0910c212012-05-11 17:50:49 +02001986 snd_pcm_uframes_t avail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 int err = 0;
1988
1989 if (size == 0)
1990 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992 snd_pcm_stream_lock_irq(substream);
1993 switch (runtime->status->state) {
1994 case SNDRV_PCM_STATE_PREPARED:
1995 case SNDRV_PCM_STATE_RUNNING:
1996 case SNDRV_PCM_STATE_PAUSED:
1997 break;
1998 case SNDRV_PCM_STATE_XRUN:
1999 err = -EPIPE;
2000 goto _end_unlock;
2001 case SNDRV_PCM_STATE_SUSPENDED:
2002 err = -ESTRPIPE;
2003 goto _end_unlock;
2004 default:
2005 err = -EBADFD;
2006 goto _end_unlock;
2007 }
2008
David Dillow5daeba32010-06-27 00:13:20 +02002009 runtime->twake = runtime->control->avail_min ? : 1;
Takashi Iwai0910c212012-05-11 17:50:49 +02002010 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
2011 snd_pcm_update_hw_ptr(substream);
2012 avail = snd_pcm_playback_avail(runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 while (size > 0) {
2014 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 snd_pcm_uframes_t cont;
Takashi Iwai13075512008-01-08 18:08:14 +01002016 if (!avail) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 if (nonblock) {
2018 err = -EAGAIN;
2019 goto _end_unlock;
2020 }
David Dillow5daeba32010-06-27 00:13:20 +02002021 runtime->twake = min_t(snd_pcm_uframes_t, size,
2022 runtime->control->avail_min ? : 1);
2023 err = wait_for_avail(substream, &avail);
Takashi Iwai13075512008-01-08 18:08:14 +01002024 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 frames = size > avail ? avail : size;
2028 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2029 if (frames > cont)
2030 frames = cont;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002031 if (snd_BUG_ON(!frames)) {
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002032 runtime->twake = 0;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002033 snd_pcm_stream_unlock_irq(substream);
2034 return -EINVAL;
2035 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 appl_ptr = runtime->control->appl_ptr;
2037 appl_ofs = appl_ptr % runtime->buffer_size;
2038 snd_pcm_stream_unlock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002039 err = transfer(substream, appl_ofs, data, offset, frames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 snd_pcm_stream_lock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002041 if (err < 0)
2042 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 switch (runtime->status->state) {
2044 case SNDRV_PCM_STATE_XRUN:
2045 err = -EPIPE;
2046 goto _end_unlock;
2047 case SNDRV_PCM_STATE_SUSPENDED:
2048 err = -ESTRPIPE;
2049 goto _end_unlock;
2050 default:
2051 break;
2052 }
2053 appl_ptr += frames;
2054 if (appl_ptr >= runtime->boundary)
2055 appl_ptr -= runtime->boundary;
2056 runtime->control->appl_ptr = appl_ptr;
2057 if (substream->ops->ack)
2058 substream->ops->ack(substream);
2059
2060 offset += frames;
2061 size -= frames;
2062 xfer += frames;
Takashi Iwai0910c212012-05-11 17:50:49 +02002063 avail -= frames;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
2065 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
2066 err = snd_pcm_start(substream);
2067 if (err < 0)
2068 goto _end_unlock;
2069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 }
2071 _end_unlock:
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002072 runtime->twake = 0;
Jaroslav Kysela12509322010-01-07 15:36:31 +01002073 if (xfer > 0 && err >= 0)
2074 snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 snd_pcm_stream_unlock_irq(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2077}
2078
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002079/* sanity-check for read/write methods */
2080static int pcm_sanity_check(struct snd_pcm_substream *substream)
2081{
2082 struct snd_pcm_runtime *runtime;
2083 if (PCM_RUNTIME_CHECK(substream))
2084 return -ENXIO;
2085 runtime = substream->runtime;
2086 if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
2087 return -EINVAL;
2088 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2089 return -EBADFD;
2090 return 0;
2091}
2092
Takashi Iwai877211f2005-11-17 13:59:38 +01002093snd_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 -07002094{
Takashi Iwai877211f2005-11-17 13:59:38 +01002095 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002097 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002099 err = pcm_sanity_check(substream);
2100 if (err < 0)
2101 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02002103 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
2105 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
2106 runtime->channels > 1)
2107 return -EINVAL;
2108 return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
2109 snd_pcm_lib_write_transfer);
2110}
2111
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02002112EXPORT_SYMBOL(snd_pcm_lib_write);
2113
Takashi Iwai877211f2005-11-17 13:59:38 +01002114static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 unsigned int hwoff,
2116 unsigned long data, unsigned int off,
2117 snd_pcm_uframes_t frames)
2118{
Takashi Iwai877211f2005-11-17 13:59:38 +01002119 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 int err;
2121 void __user **bufs = (void __user **)data;
2122 int channels = runtime->channels;
2123 int c;
2124 if (substream->ops->copy) {
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002125 if (snd_BUG_ON(!substream->ops->silence))
2126 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 for (c = 0; c < channels; ++c, ++bufs) {
2128 if (*bufs == NULL) {
2129 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
2130 return err;
2131 } else {
2132 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2133 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2134 return err;
2135 }
2136 }
2137 } else {
2138 /* default transfer behaviour */
2139 size_t dma_csize = runtime->dma_bytes / channels;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 for (c = 0; c < channels; ++c, ++bufs) {
2141 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2142 if (*bufs == NULL) {
2143 snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
2144 } else {
2145 char __user *buf = *bufs + samples_to_bytes(runtime, off);
2146 if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
2147 return -EFAULT;
2148 }
2149 }
2150 }
2151 return 0;
2152}
2153
Takashi Iwai877211f2005-11-17 13:59:38 +01002154snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 void __user **bufs,
2156 snd_pcm_uframes_t frames)
2157{
Takashi Iwai877211f2005-11-17 13:59:38 +01002158 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002160 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002162 err = pcm_sanity_check(substream);
2163 if (err < 0)
2164 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02002166 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
2168 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2169 return -EINVAL;
2170 return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
2171 nonblock, snd_pcm_lib_writev_transfer);
2172}
2173
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02002174EXPORT_SYMBOL(snd_pcm_lib_writev);
2175
Takashi Iwai877211f2005-11-17 13:59:38 +01002176static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 unsigned int hwoff,
2178 unsigned long data, unsigned int off,
2179 snd_pcm_uframes_t frames)
2180{
Takashi Iwai877211f2005-11-17 13:59:38 +01002181 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 int err;
2183 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
2184 if (substream->ops->copy) {
2185 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
2186 return err;
2187 } else {
2188 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
2190 return -EFAULT;
2191 }
2192 return 0;
2193}
2194
Takashi Iwai877211f2005-11-17 13:59:38 +01002195static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 unsigned long data,
2197 snd_pcm_uframes_t size,
2198 int nonblock,
2199 transfer_f transfer)
2200{
Takashi Iwai877211f2005-11-17 13:59:38 +01002201 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 snd_pcm_uframes_t xfer = 0;
2203 snd_pcm_uframes_t offset = 0;
Takashi Iwai0910c212012-05-11 17:50:49 +02002204 snd_pcm_uframes_t avail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 int err = 0;
2206
2207 if (size == 0)
2208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
2210 snd_pcm_stream_lock_irq(substream);
2211 switch (runtime->status->state) {
2212 case SNDRV_PCM_STATE_PREPARED:
2213 if (size >= runtime->start_threshold) {
2214 err = snd_pcm_start(substream);
2215 if (err < 0)
2216 goto _end_unlock;
2217 }
2218 break;
2219 case SNDRV_PCM_STATE_DRAINING:
2220 case SNDRV_PCM_STATE_RUNNING:
2221 case SNDRV_PCM_STATE_PAUSED:
2222 break;
2223 case SNDRV_PCM_STATE_XRUN:
2224 err = -EPIPE;
2225 goto _end_unlock;
2226 case SNDRV_PCM_STATE_SUSPENDED:
2227 err = -ESTRPIPE;
2228 goto _end_unlock;
2229 default:
2230 err = -EBADFD;
2231 goto _end_unlock;
2232 }
2233
David Dillow5daeba32010-06-27 00:13:20 +02002234 runtime->twake = runtime->control->avail_min ? : 1;
Takashi Iwai0910c212012-05-11 17:50:49 +02002235 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
2236 snd_pcm_update_hw_ptr(substream);
2237 avail = snd_pcm_capture_avail(runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 while (size > 0) {
2239 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 snd_pcm_uframes_t cont;
Takashi Iwai13075512008-01-08 18:08:14 +01002241 if (!avail) {
2242 if (runtime->status->state ==
2243 SNDRV_PCM_STATE_DRAINING) {
2244 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 goto _end_unlock;
2246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 if (nonblock) {
2248 err = -EAGAIN;
2249 goto _end_unlock;
2250 }
David Dillow5daeba32010-06-27 00:13:20 +02002251 runtime->twake = min_t(snd_pcm_uframes_t, size,
2252 runtime->control->avail_min ? : 1);
2253 err = wait_for_avail(substream, &avail);
Takashi Iwai13075512008-01-08 18:08:14 +01002254 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 goto _end_unlock;
Takashi Iwai13075512008-01-08 18:08:14 +01002256 if (!avail)
2257 continue; /* draining */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 frames = size > avail ? avail : size;
2260 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2261 if (frames > cont)
2262 frames = cont;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002263 if (snd_BUG_ON(!frames)) {
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002264 runtime->twake = 0;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002265 snd_pcm_stream_unlock_irq(substream);
2266 return -EINVAL;
2267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 appl_ptr = runtime->control->appl_ptr;
2269 appl_ofs = appl_ptr % runtime->buffer_size;
2270 snd_pcm_stream_unlock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002271 err = transfer(substream, appl_ofs, data, offset, frames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 snd_pcm_stream_lock_irq(substream);
Jaroslav Kysela12509322010-01-07 15:36:31 +01002273 if (err < 0)
2274 goto _end_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 switch (runtime->status->state) {
2276 case SNDRV_PCM_STATE_XRUN:
2277 err = -EPIPE;
2278 goto _end_unlock;
2279 case SNDRV_PCM_STATE_SUSPENDED:
2280 err = -ESTRPIPE;
2281 goto _end_unlock;
2282 default:
2283 break;
2284 }
2285 appl_ptr += frames;
2286 if (appl_ptr >= runtime->boundary)
2287 appl_ptr -= runtime->boundary;
2288 runtime->control->appl_ptr = appl_ptr;
2289 if (substream->ops->ack)
2290 substream->ops->ack(substream);
2291
2292 offset += frames;
2293 size -= frames;
2294 xfer += frames;
Takashi Iwai0910c212012-05-11 17:50:49 +02002295 avail -= frames;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 }
2297 _end_unlock:
Jaroslav Kyselac91a9882010-01-21 10:32:15 +01002298 runtime->twake = 0;
Jaroslav Kysela12509322010-01-07 15:36:31 +01002299 if (xfer > 0 && err >= 0)
2300 snd_pcm_update_state(substream, runtime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 snd_pcm_stream_unlock_irq(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2303}
2304
Takashi Iwai877211f2005-11-17 13:59:38 +01002305snd_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 -07002306{
Takashi Iwai877211f2005-11-17 13:59:38 +01002307 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002309 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002311 err = pcm_sanity_check(substream);
2312 if (err < 0)
2313 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 runtime = substream->runtime;
Takashi Iwai0df63e42006-04-28 15:13:41 +02002315 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
2317 return -EINVAL;
2318 return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
2319}
2320
Takashi Iwaie88e8ae62006-04-28 15:13:40 +02002321EXPORT_SYMBOL(snd_pcm_lib_read);
2322
Takashi Iwai877211f2005-11-17 13:59:38 +01002323static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 unsigned int hwoff,
2325 unsigned long data, unsigned int off,
2326 snd_pcm_uframes_t frames)
2327{
Takashi Iwai877211f2005-11-17 13:59:38 +01002328 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 int err;
2330 void __user **bufs = (void __user **)data;
2331 int channels = runtime->channels;
2332 int c;
2333 if (substream->ops->copy) {
2334 for (c = 0; c < channels; ++c, ++bufs) {
2335 char __user *buf;
2336 if (*bufs == NULL)
2337 continue;
2338 buf = *bufs + samples_to_bytes(runtime, off);
2339 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2340 return err;
2341 }
2342 } else {
2343 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 for (c = 0; c < channels; ++c, ++bufs) {
2345 char *hwbuf;
2346 char __user *buf;
2347 if (*bufs == NULL)
2348 continue;
2349
2350 hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2351 buf = *bufs + samples_to_bytes(runtime, off);
2352 if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
2353 return -EFAULT;
2354 }
2355 }
2356 return 0;
2357}
2358
Takashi Iwai877211f2005-11-17 13:59:38 +01002359snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360 void __user **bufs,
2361 snd_pcm_uframes_t frames)
2362{
Takashi Iwai877211f2005-11-17 13:59:38 +01002363 struct snd_pcm_runtime *runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 int nonblock;
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002365 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
Takashi Iwai7eaa9432008-08-08 17:09:09 +02002367 err = pcm_sanity_check(substream);
2368 if (err < 0)
2369 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2372 return -EBADFD;
2373
Takashi Iwai0df63e42006-04-28 15:13:41 +02002374 nonblock = !!(substream->f_flags & O_NONBLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2376 return -EINVAL;
2377 return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
2378}
2379
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380EXPORT_SYMBOL(snd_pcm_lib_readv);
Takashi Iwai2d3391e2012-07-27 18:27:00 +02002381
2382/*
2383 * standard channel mapping helpers
2384 */
2385
2386/* default channel maps for multi-channel playbacks, up to 8 channels */
2387const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[] = {
2388 { .channels = 1,
Takashi Iwai5efbc262012-09-13 14:48:46 +02002389 .map = { SNDRV_CHMAP_MONO } },
Takashi Iwai2d3391e2012-07-27 18:27:00 +02002390 { .channels = 2,
2391 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2392 { .channels = 4,
2393 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2394 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2395 { .channels = 6,
2396 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2397 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2398 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
2399 { .channels = 8,
2400 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2401 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2402 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2403 SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2404 { }
2405};
2406EXPORT_SYMBOL_GPL(snd_pcm_std_chmaps);
2407
2408/* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2409const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[] = {
2410 { .channels = 1,
Takashi Iwai5efbc262012-09-13 14:48:46 +02002411 .map = { SNDRV_CHMAP_MONO } },
Takashi Iwai2d3391e2012-07-27 18:27:00 +02002412 { .channels = 2,
2413 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2414 { .channels = 4,
2415 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2416 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2417 { .channels = 6,
2418 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2419 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2420 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2421 { .channels = 8,
2422 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2423 SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2424 SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2425 SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2426 { }
2427};
2428EXPORT_SYMBOL_GPL(snd_pcm_alt_chmaps);
2429
2430static bool valid_chmap_channels(const struct snd_pcm_chmap *info, int ch)
2431{
2432 if (ch > info->max_channels)
2433 return false;
2434 return !info->channel_mask || (info->channel_mask & (1U << ch));
2435}
2436
2437static int pcm_chmap_ctl_info(struct snd_kcontrol *kcontrol,
2438 struct snd_ctl_elem_info *uinfo)
2439{
2440 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2441
2442 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2443 uinfo->count = 0;
2444 uinfo->count = info->max_channels;
2445 uinfo->value.integer.min = 0;
2446 uinfo->value.integer.max = SNDRV_CHMAP_LAST;
2447 return 0;
2448}
2449
2450/* get callback for channel map ctl element
2451 * stores the channel position firstly matching with the current channels
2452 */
2453static int pcm_chmap_ctl_get(struct snd_kcontrol *kcontrol,
2454 struct snd_ctl_elem_value *ucontrol)
2455{
2456 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2457 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2458 struct snd_pcm_substream *substream;
2459 const struct snd_pcm_chmap_elem *map;
2460
2461 if (snd_BUG_ON(!info->chmap))
2462 return -EINVAL;
2463 substream = snd_pcm_chmap_substream(info, idx);
2464 if (!substream)
2465 return -ENODEV;
2466 memset(ucontrol->value.integer.value, 0,
2467 sizeof(ucontrol->value.integer.value));
2468 if (!substream->runtime)
2469 return 0; /* no channels set */
2470 for (map = info->chmap; map->channels; map++) {
2471 int i;
2472 if (map->channels == substream->runtime->channels &&
2473 valid_chmap_channels(info, map->channels)) {
2474 for (i = 0; i < map->channels; i++)
2475 ucontrol->value.integer.value[i] = map->map[i];
2476 return 0;
2477 }
2478 }
2479 return -EINVAL;
2480}
2481
2482/* tlv callback for channel map ctl element
2483 * expands the pre-defined channel maps in a form of TLV
2484 */
2485static int pcm_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2486 unsigned int size, unsigned int __user *tlv)
2487{
2488 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2489 const struct snd_pcm_chmap_elem *map;
2490 unsigned int __user *dst;
2491 int c, count = 0;
2492
2493 if (snd_BUG_ON(!info->chmap))
2494 return -EINVAL;
2495 if (size < 8)
2496 return -ENOMEM;
2497 if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
2498 return -EFAULT;
2499 size -= 8;
2500 dst = tlv + 2;
2501 for (map = info->chmap; map->channels; map++) {
2502 int chs_bytes = map->channels * 4;
2503 if (!valid_chmap_channels(info, map->channels))
2504 continue;
2505 if (size < 8)
2506 return -ENOMEM;
2507 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||
2508 put_user(chs_bytes, dst + 1))
2509 return -EFAULT;
2510 dst += 2;
2511 size -= 8;
2512 count += 8;
2513 if (size < chs_bytes)
2514 return -ENOMEM;
2515 size -= chs_bytes;
2516 count += chs_bytes;
2517 for (c = 0; c < map->channels; c++) {
2518 if (put_user(map->map[c], dst))
2519 return -EFAULT;
2520 dst++;
2521 }
2522 }
2523 if (put_user(count, tlv + 1))
2524 return -EFAULT;
2525 return 0;
2526}
2527
2528static void pcm_chmap_ctl_private_free(struct snd_kcontrol *kcontrol)
2529{
2530 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2531 info->pcm->streams[info->stream].chmap_kctl = NULL;
2532 kfree(info);
2533}
2534
2535/**
2536 * snd_pcm_add_chmap_ctls - create channel-mapping control elements
2537 * @pcm: the assigned PCM instance
2538 * @stream: stream direction
2539 * @chmap: channel map elements (for query)
2540 * @max_channels: the max number of channels for the stream
2541 * @private_value: the value passed to each kcontrol's private_value field
2542 * @info_ret: store struct snd_pcm_chmap instance if non-NULL
2543 *
2544 * Create channel-mapping control elements assigned to the given PCM stream(s).
Yacine Belkadieb7c06e2013-03-11 22:05:14 +01002545 * Return: Zero if successful, or a negative error value.
Takashi Iwai2d3391e2012-07-27 18:27:00 +02002546 */
2547int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
2548 const struct snd_pcm_chmap_elem *chmap,
2549 int max_channels,
2550 unsigned long private_value,
2551 struct snd_pcm_chmap **info_ret)
2552{
2553 struct snd_pcm_chmap *info;
2554 struct snd_kcontrol_new knew = {
2555 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2556 .access = SNDRV_CTL_ELEM_ACCESS_READ |
Takashi Iwai2d3391e2012-07-27 18:27:00 +02002557 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2558 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
2559 .info = pcm_chmap_ctl_info,
2560 .get = pcm_chmap_ctl_get,
2561 .tlv.c = pcm_chmap_ctl_tlv,
2562 };
2563 int err;
2564
2565 info = kzalloc(sizeof(*info), GFP_KERNEL);
2566 if (!info)
2567 return -ENOMEM;
2568 info->pcm = pcm;
2569 info->stream = stream;
2570 info->chmap = chmap;
2571 info->max_channels = max_channels;
2572 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2573 knew.name = "Playback Channel Map";
2574 else
2575 knew.name = "Capture Channel Map";
2576 knew.device = pcm->device;
2577 knew.count = pcm->streams[stream].substream_count;
2578 knew.private_value = private_value;
2579 info->kctl = snd_ctl_new1(&knew, info);
2580 if (!info->kctl) {
2581 kfree(info);
2582 return -ENOMEM;
2583 }
2584 info->kctl->private_free = pcm_chmap_ctl_private_free;
2585 err = snd_ctl_add(pcm->card, info->kctl);
2586 if (err < 0)
2587 return err;
2588 pcm->streams[stream].chmap_kctl = info->kctl;
2589 if (info_ret)
2590 *info_ret = info;
2591 return 0;
2592}
2593EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls);