pcm_lib.c 57.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *  Digital Audio (PCM) abstract layer
3
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *                   Abramo Bagnara <abramo@alsa-project.org>
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/slab.h>
#include <linux/time.h>
25
#include <linux/math64.h>
L
Linus Torvalds 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
#include <sound/core.h>
#include <sound/control.h>
#include <sound/info.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/timer.h>

/*
 * fill ring buffer with silence
 * runtime->silence_start: starting pointer to silence area
 * runtime->silence_filled: size filled with silence
 * runtime->silence_threshold: threshold from application
 * runtime->silence_size: maximal size from application
 *
 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
 */
T
Takashi Iwai 已提交
42
void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
L
Linus Torvalds 已提交
43
{
T
Takashi Iwai 已提交
44
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
45 46 47 48 49 50 51 52 53 54 55 56 57 58
	snd_pcm_uframes_t frames, ofs, transfer;

	if (runtime->silence_size < runtime->boundary) {
		snd_pcm_sframes_t noise_dist, n;
		if (runtime->silence_start != runtime->control->appl_ptr) {
			n = runtime->control->appl_ptr - runtime->silence_start;
			if (n < 0)
				n += runtime->boundary;
			if ((snd_pcm_uframes_t)n < runtime->silence_filled)
				runtime->silence_filled -= n;
			else
				runtime->silence_filled = 0;
			runtime->silence_start = runtime->control->appl_ptr;
		}
T
Takashi Iwai 已提交
59
		if (runtime->silence_filled >= runtime->buffer_size)
L
Linus Torvalds 已提交
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
			return;
		noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
		if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
			return;
		frames = runtime->silence_threshold - noise_dist;
		if (frames > runtime->silence_size)
			frames = runtime->silence_size;
	} else {
		if (new_hw_ptr == ULONG_MAX) {	/* initialization */
			snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
			runtime->silence_filled = avail > 0 ? avail : 0;
			runtime->silence_start = (runtime->status->hw_ptr +
						  runtime->silence_filled) %
						 runtime->boundary;
		} else {
			ofs = runtime->status->hw_ptr;
			frames = new_hw_ptr - ofs;
			if ((snd_pcm_sframes_t)frames < 0)
				frames += runtime->boundary;
			runtime->silence_filled -= frames;
			if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
				runtime->silence_filled = 0;
82
				runtime->silence_start = new_hw_ptr;
L
Linus Torvalds 已提交
83
			} else {
84
				runtime->silence_start = ofs;
L
Linus Torvalds 已提交
85 86 87 88
			}
		}
		frames = runtime->buffer_size - runtime->silence_filled;
	}
89 90
	if (snd_BUG_ON(frames > runtime->buffer_size))
		return;
L
Linus Torvalds 已提交
91 92
	if (frames == 0)
		return;
93
	ofs = runtime->silence_start % runtime->buffer_size;
L
Linus Torvalds 已提交
94 95 96 97 98 99 100
	while (frames > 0) {
		transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
		if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
		    runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
			if (substream->ops->silence) {
				int err;
				err = substream->ops->silence(substream, -1, ofs, transfer);
101
				snd_BUG_ON(err < 0);
L
Linus Torvalds 已提交
102 103 104 105 106 107 108 109 110 111 112
			} else {
				char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
				snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
			}
		} else {
			unsigned int c;
			unsigned int channels = runtime->channels;
			if (substream->ops->silence) {
				for (c = 0; c < channels; ++c) {
					int err;
					err = substream->ops->silence(substream, c, ofs, transfer);
113
					snd_BUG_ON(err < 0);
L
Linus Torvalds 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
				}
			} else {
				size_t dma_csize = runtime->dma_bytes / channels;
				for (c = 0; c < channels; ++c) {
					char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
					snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
				}
			}
		}
		runtime->silence_filled += transfer;
		frames -= transfer;
		ofs = 0;
	}
}

129 130 131 132 133 134 135 136 137 138
static void pcm_debug_name(struct snd_pcm_substream *substream,
			   char *name, size_t len)
{
	snprintf(name, len, "pcmC%dD%d%c:%d",
		 substream->pcm->card->number,
		 substream->pcm->device,
		 substream->stream ? 'c' : 'p',
		 substream->number);
}

139 140 141 142 143
#define XRUN_DEBUG_BASIC	(1<<0)
#define XRUN_DEBUG_STACK	(1<<1)	/* dump also stack */
#define XRUN_DEBUG_JIFFIESCHECK	(1<<2)	/* do jiffies check */
#define XRUN_DEBUG_PERIODUPDATE	(1<<3)	/* full period update info */
#define XRUN_DEBUG_HWPTRUPDATE	(1<<4)	/* full hwptr update info */
144 145
#define XRUN_DEBUG_LOG		(1<<5)	/* show last 10 positions on err */
#define XRUN_DEBUG_LOGONCE	(1<<6)	/* do above only once */
146

T
Takashi Iwai 已提交
147
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
148

149 150
#define xrun_debug(substream, mask) \
			((substream)->pstr->xrun_debug & (mask))
T
Takashi Iwai 已提交
151

152 153 154
#define dump_stack_on_xrun(substream) do {			\
		if (xrun_debug(substream, XRUN_DEBUG_STACK))	\
			dump_stack();				\
T
Takashi Iwai 已提交
155 156
	} while (0)

T
Takashi Iwai 已提交
157
static void xrun(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
158
{
159 160 161 162
	struct snd_pcm_runtime *runtime = substream->runtime;

	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
		snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
L
Linus Torvalds 已提交
163
	snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
164
	if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
165 166 167
		char name[16];
		pcm_debug_name(substream, name, sizeof(name));
		snd_printd(KERN_DEBUG "XRUN: %s\n", name);
T
Takashi Iwai 已提交
168
		dump_stack_on_xrun(substream);
L
Linus Torvalds 已提交
169 170 171
	}
}

172 173 174
#define hw_ptr_error(substream, fmt, args...)				\
	do {								\
		if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {		\
175
			xrun_log_show(substream);			\
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
			if (printk_ratelimit()) {			\
				snd_printd("PCM: " fmt, ##args);	\
			}						\
			dump_stack_on_xrun(substream);			\
		}							\
	} while (0)

#define XRUN_LOG_CNT	10

struct hwptr_log_entry {
	unsigned long jiffies;
	snd_pcm_uframes_t pos;
	snd_pcm_uframes_t period_size;
	snd_pcm_uframes_t buffer_size;
	snd_pcm_uframes_t old_hw_ptr;
	snd_pcm_uframes_t hw_ptr_base;
};

struct snd_pcm_hwptr_log {
	unsigned int idx;
	unsigned int hit: 1;
	struct hwptr_log_entry entries[XRUN_LOG_CNT];
};

static void xrun_log(struct snd_pcm_substream *substream,
		     snd_pcm_uframes_t pos)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
	struct hwptr_log_entry *entry;

	if (log == NULL) {
		log = kzalloc(sizeof(*log), GFP_ATOMIC);
		if (log == NULL)
			return;
		runtime->hwptr_log = log;
	} else {
		if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
			return;
	}
	entry = &log->entries[log->idx];
	entry->jiffies = jiffies;
	entry->pos = pos;
	entry->period_size = runtime->period_size;
	entry->buffer_size = runtime->buffer_size;;
	entry->old_hw_ptr = runtime->status->hw_ptr;
	entry->hw_ptr_base = runtime->hw_ptr_base;
	log->idx = (log->idx + 1) % XRUN_LOG_CNT;
}

static void xrun_log_show(struct snd_pcm_substream *substream)
{
	struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
	struct hwptr_log_entry *entry;
	char name[16];
	unsigned int idx;
	int cnt;

	if (log == NULL)
		return;
	if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
		return;
	pcm_debug_name(substream, name, sizeof(name));
	for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
		entry = &log->entries[idx];
		if (entry->period_size == 0)
			break;
243 244
		snd_printd("hwptr log: %s: j=%lu, pos=%ld/%ld/%ld, "
			   "hwptr=%ld/%ld\n",
245 246 247 248
			   name, entry->jiffies, (unsigned long)entry->pos,
			   (unsigned long)entry->period_size,
			   (unsigned long)entry->buffer_size,
			   (unsigned long)entry->old_hw_ptr,
249
			   (unsigned long)entry->hw_ptr_base);
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
		idx++;
		idx %= XRUN_LOG_CNT;
	}
	log->hit = 1;
}

#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */

#define xrun_debug(substream, mask)	0
#define xrun(substream)			do { } while (0)
#define hw_ptr_error(substream, fmt, args...) do { } while (0)
#define xrun_log(substream, pos)	do { } while (0)
#define xrun_log_show(substream)	do { } while (0)

#endif

266 267
static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
				      struct snd_pcm_runtime *runtime)
L
Linus Torvalds 已提交
268 269 270 271 272 273 274 275 276
{
	snd_pcm_uframes_t avail;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		avail = snd_pcm_playback_avail(runtime);
	else
		avail = snd_pcm_capture_avail(runtime);
	if (avail > runtime->avail_max)
		runtime->avail_max = avail;
277 278
	if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
		if (avail >= runtime->buffer_size) {
L
Linus Torvalds 已提交
279
			snd_pcm_drain_done(substream);
280 281 282 283
			return -EPIPE;
		}
	} else {
		if (avail >= runtime->stop_threshold) {
L
Linus Torvalds 已提交
284
			xrun(substream);
285 286
			return -EPIPE;
		}
L
Linus Torvalds 已提交
287 288 289 290 291 292
	}
	if (avail >= runtime->control->avail_min)
		wake_up(&runtime->sleep);
	return 0;
}

293 294
static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
				  unsigned int in_interrupt)
L
Linus Torvalds 已提交
295
{
T
Takashi Iwai 已提交
296
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
297
	snd_pcm_uframes_t pos;
298
	snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
299 300
	snd_pcm_sframes_t hdelta, delta;
	unsigned long jdelta;
L
Linus Torvalds 已提交
301

302
	old_hw_ptr = runtime->status->hw_ptr;
303
	pos = substream->ops->pointer(substream);
L
Linus Torvalds 已提交
304 305 306 307
	if (pos == SNDRV_PCM_POS_XRUN) {
		xrun(substream);
		return -EPIPE;
	}
308 309 310 311 312 313 314 315 316 317 318
	if (pos >= runtime->buffer_size) {
		if (printk_ratelimit()) {
			char name[16];
			pcm_debug_name(substream, name, sizeof(name));
			xrun_log_show(substream);
			snd_printd(KERN_ERR  "BUG: %s, pos = %ld, "
				   "buffer size = %ld, period size = %ld\n",
				   name, pos, runtime->buffer_size,
				   runtime->period_size);
		}
		pos = 0;
319
	}
320 321 322
	pos -= pos % runtime->min_align;
	if (xrun_debug(substream, XRUN_DEBUG_LOG))
		xrun_log(substream, pos);
T
Takashi Iwai 已提交
323 324
	hw_base = runtime->hw_ptr_base;
	new_hw_ptr = hw_base + pos;
325 326 327 328 329 330
	if (in_interrupt) {
		/* we know that one period was processed */
		/* delta = "expected next hw_ptr" for in_interrupt != 0 */
		delta = old_hw_ptr - (old_hw_ptr % runtime->period_size)
			+ runtime->period_size;
		if (delta > new_hw_ptr) {
T
Takashi Iwai 已提交
331
			hw_base += runtime->buffer_size;
T
Takashi Iwai 已提交
332
			if (hw_base >= runtime->boundary)
T
Takashi Iwai 已提交
333 334
				hw_base = 0;
			new_hw_ptr = hw_base + pos;
335
			goto __delta;
L
Linus Torvalds 已提交
336 337
		}
	}
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
	/* new_hw_ptr might be lower than old_hw_ptr in case when */
	/* pointer crosses the end of the ring buffer */
	if (new_hw_ptr < old_hw_ptr) {
		hw_base += runtime->buffer_size;
		if (hw_base >= runtime->boundary)
			hw_base = 0;
		new_hw_ptr = hw_base + pos;
	}
      __delta:
	delta = (new_hw_ptr - old_hw_ptr) % runtime->boundary;
	if (xrun_debug(substream, in_interrupt ?
			XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
		char name[16];
		pcm_debug_name(substream, name, sizeof(name));
		snd_printd("%s_update: %s: pos=%u/%u/%u, "
			   "hwptr=%ld/%ld/%ld/%ld\n",
			   in_interrupt ? "period" : "hwptr",
			   name,
			   (unsigned int)pos,
			   (unsigned int)runtime->period_size,
			   (unsigned int)runtime->buffer_size,
			   (unsigned long)delta,
			   (unsigned long)old_hw_ptr,
			   (unsigned long)new_hw_ptr,
			   (unsigned long)runtime->hw_ptr_base);
	}
	/* something must be really wrong */
	if (delta >= runtime->buffer_size) {
		hw_ptr_error(substream,
			       "Unexpected hw_pointer value %s"
			       "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
			       "old_hw_ptr=%ld)\n",
				     in_interrupt ? "[Q] " : "[P]",
				     substream->stream, (long)pos,
				     (long)new_hw_ptr, (long)old_hw_ptr);
		return 0;
	}
375 376

	/* Do jiffies check only in xrun_debug mode */
377
	if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
378 379
		goto no_jiffies_check;

380 381 382 383 384 385
	/* Skip the jiffies check for hardwares with BATCH flag.
	 * Such hardware usually just increases the position at each IRQ,
	 * thus it can't give any strange position.
	 */
	if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
		goto no_jiffies_check;
386
	hdelta = delta;
387 388 389
	if (hdelta < runtime->delay)
		goto no_jiffies_check;
	hdelta -= runtime->delay;
390 391 392 393 394
	jdelta = jiffies - runtime->hw_ptr_jiffies;
	if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
		delta = jdelta /
			(((runtime->period_size * HZ) / runtime->rate)
								+ HZ/100);
395 396 397 398 399 400 401 402 403 404 405 406 407
		/* move new_hw_ptr according jiffies not pos variable */
		new_hw_ptr = old_hw_ptr;
		/* use loop to avoid checks for delta overflows */
		/* the delta value is small or zero in most cases */
		while (delta > 0) {
			new_hw_ptr += runtime->period_size;
			if (new_hw_ptr >= runtime->boundary)
				new_hw_ptr -= runtime->boundary;
			delta--;
		}
		/* align hw_base to buffer_size */
		hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
		delta = 0;
408
		hw_ptr_error(substream,
409
			     "hw_ptr skipping! %s"
410
			     "(pos=%ld, delta=%ld, period=%ld, "
411 412
			     "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
			     in_interrupt ? "[Q] " : "",
413 414
			     (long)pos, (long)hdelta,
			     (long)runtime->period_size, jdelta,
415 416 417
			     ((hdelta * HZ) / runtime->rate), delta,
			     (unsigned long)old_hw_ptr,
			     (unsigned long)new_hw_ptr);
418
	}
419
 no_jiffies_check:
420
	if (delta > runtime->period_size + runtime->period_size / 2) {
T
Takashi Iwai 已提交
421
		hw_ptr_error(substream,
422 423 424 425
			     "Lost interrupts? %s"
			     "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
			     "old_hw_ptr=%ld)\n",
			     in_interrupt ? "[Q] " : "",
T
Takashi Iwai 已提交
426
			     substream->stream, (long)delta,
427 428
			     (long)new_hw_ptr,
			     (long)old_hw_ptr);
T
Takashi Iwai 已提交
429
	}
430 431 432

	if (runtime->status->hw_ptr == new_hw_ptr)
		return 0;
433

L
Linus Torvalds 已提交
434 435 436 437
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
	    runtime->silence_size > 0)
		snd_pcm_playback_silence(substream, new_hw_ptr);

T
Takashi Iwai 已提交
438
	runtime->hw_ptr_base = hw_base;
L
Linus Torvalds 已提交
439
	runtime->status->hw_ptr = new_hw_ptr;
440
	runtime->hw_ptr_jiffies = jiffies;
441 442
	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
		snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
L
Linus Torvalds 已提交
443 444 445 446 447

	return snd_pcm_update_hw_ptr_post(substream, runtime);
}

/* CAUTION: call it with irq disabled */
T
Takashi Iwai 已提交
448
int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
449
{
450
	return snd_pcm_update_hw_ptr0(substream, 0);
L
Linus Torvalds 已提交
451 452 453 454 455 456 457 458 459 460
}

/**
 * snd_pcm_set_ops - set the PCM operators
 * @pcm: the pcm instance
 * @direction: stream direction, SNDRV_PCM_STREAM_XXX
 * @ops: the operator table
 *
 * Sets the given PCM operators to the pcm instance.
 */
T
Takashi Iwai 已提交
461
void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
L
Linus Torvalds 已提交
462
{
T
Takashi Iwai 已提交
463 464
	struct snd_pcm_str *stream = &pcm->streams[direction];
	struct snd_pcm_substream *substream;
L
Linus Torvalds 已提交
465 466 467 468 469
	
	for (substream = stream->substream; substream != NULL; substream = substream->next)
		substream->ops = ops;
}

470
EXPORT_SYMBOL(snd_pcm_set_ops);
L
Linus Torvalds 已提交
471 472 473 474 475 476 477

/**
 * snd_pcm_sync - set the PCM sync id
 * @substream: the pcm substream
 *
 * Sets the PCM sync identifier for the card.
 */
T
Takashi Iwai 已提交
478
void snd_pcm_set_sync(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
479
{
T
Takashi Iwai 已提交
480
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
481 482 483 484 485 486 487
	
	runtime->sync.id32[0] = substream->pcm->card->number;
	runtime->sync.id32[1] = -1;
	runtime->sync.id32[2] = -1;
	runtime->sync.id32[3] = -1;
}

488 489
EXPORT_SYMBOL(snd_pcm_set_sync);

L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
/*
 *  Standard ioctl routine
 */

static inline unsigned int div32(unsigned int a, unsigned int b, 
				 unsigned int *r)
{
	if (b == 0) {
		*r = 0;
		return UINT_MAX;
	}
	*r = a % b;
	return a / b;
}

static inline unsigned int div_down(unsigned int a, unsigned int b)
{
	if (b == 0)
		return UINT_MAX;
	return a / b;
}

static inline unsigned int div_up(unsigned int a, unsigned int b)
{
	unsigned int r;
	unsigned int q;
	if (b == 0)
		return UINT_MAX;
	q = div32(a, b, &r);
	if (r)
		++q;
	return q;
}

static inline unsigned int mul(unsigned int a, unsigned int b)
{
	if (a == 0)
		return 0;
	if (div_down(UINT_MAX, a) < b)
		return UINT_MAX;
	return a * b;
}

static inline unsigned int muldiv32(unsigned int a, unsigned int b,
				    unsigned int c, unsigned int *r)
{
	u_int64_t n = (u_int64_t) a * b;
	if (c == 0) {
538
		snd_BUG_ON(!n);
L
Linus Torvalds 已提交
539 540 541
		*r = 0;
		return UINT_MAX;
	}
542
	n = div_u64_rem(n, c, r);
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
	if (n >= UINT_MAX) {
		*r = 0;
		return UINT_MAX;
	}
	return n;
}

/**
 * snd_interval_refine - refine the interval value of configurator
 * @i: the interval value to refine
 * @v: the interval value to refer to
 *
 * Refines the interval value with the reference value.
 * The interval is changed to the range satisfying both intervals.
 * The interval status (min, max, integer, etc.) are evaluated.
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
561
int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
L
Linus Torvalds 已提交
562 563
{
	int changed = 0;
564 565
	if (snd_BUG_ON(snd_interval_empty(i)))
		return -EINVAL;
L
Linus Torvalds 已提交
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
	if (i->min < v->min) {
		i->min = v->min;
		i->openmin = v->openmin;
		changed = 1;
	} else if (i->min == v->min && !i->openmin && v->openmin) {
		i->openmin = 1;
		changed = 1;
	}
	if (i->max > v->max) {
		i->max = v->max;
		i->openmax = v->openmax;
		changed = 1;
	} else if (i->max == v->max && !i->openmax && v->openmax) {
		i->openmax = 1;
		changed = 1;
	}
	if (!i->integer && v->integer) {
		i->integer = 1;
		changed = 1;
	}
	if (i->integer) {
		if (i->openmin) {
			i->min++;
			i->openmin = 0;
		}
		if (i->openmax) {
			i->max--;
			i->openmax = 0;
		}
	} else if (!i->openmin && !i->openmax && i->min == i->max)
		i->integer = 1;
	if (snd_interval_checkempty(i)) {
		snd_interval_none(i);
		return -EINVAL;
	}
	return changed;
}

604 605
EXPORT_SYMBOL(snd_interval_refine);

T
Takashi Iwai 已提交
606
static int snd_interval_refine_first(struct snd_interval *i)
L
Linus Torvalds 已提交
607
{
608 609
	if (snd_BUG_ON(snd_interval_empty(i)))
		return -EINVAL;
L
Linus Torvalds 已提交
610 611 612 613 614 615 616 617 618
	if (snd_interval_single(i))
		return 0;
	i->max = i->min;
	i->openmax = i->openmin;
	if (i->openmax)
		i->max++;
	return 1;
}

T
Takashi Iwai 已提交
619
static int snd_interval_refine_last(struct snd_interval *i)
L
Linus Torvalds 已提交
620
{
621 622
	if (snd_BUG_ON(snd_interval_empty(i)))
		return -EINVAL;
L
Linus Torvalds 已提交
623 624 625 626 627 628 629 630 631
	if (snd_interval_single(i))
		return 0;
	i->min = i->max;
	i->openmin = i->openmax;
	if (i->openmin)
		i->min--;
	return 1;
}

T
Takashi Iwai 已提交
632
void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
L
Linus Torvalds 已提交
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
{
	if (a->empty || b->empty) {
		snd_interval_none(c);
		return;
	}
	c->empty = 0;
	c->min = mul(a->min, b->min);
	c->openmin = (a->openmin || b->openmin);
	c->max = mul(a->max,  b->max);
	c->openmax = (a->openmax || b->openmax);
	c->integer = (a->integer && b->integer);
}

/**
 * snd_interval_div - refine the interval value with division
T
Takashi Iwai 已提交
648 649 650
 * @a: dividend
 * @b: divisor
 * @c: quotient
L
Linus Torvalds 已提交
651 652 653 654 655
 *
 * c = a / b
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
656
void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
{
	unsigned int r;
	if (a->empty || b->empty) {
		snd_interval_none(c);
		return;
	}
	c->empty = 0;
	c->min = div32(a->min, b->max, &r);
	c->openmin = (r || a->openmin || b->openmax);
	if (b->min > 0) {
		c->max = div32(a->max, b->min, &r);
		if (r) {
			c->max++;
			c->openmax = 1;
		} else
			c->openmax = (a->openmax || b->openmin);
	} else {
		c->max = UINT_MAX;
		c->openmax = 0;
	}
	c->integer = 0;
}

/**
 * snd_interval_muldivk - refine the interval value
T
Takashi Iwai 已提交
682 683 684 685 686
 * @a: dividend 1
 * @b: dividend 2
 * @k: divisor (as integer)
 * @c: result
  *
L
Linus Torvalds 已提交
687 688 689 690
 * c = a * b / k
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
691 692
void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
		      unsigned int k, struct snd_interval *c)
L
Linus Torvalds 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
{
	unsigned int r;
	if (a->empty || b->empty) {
		snd_interval_none(c);
		return;
	}
	c->empty = 0;
	c->min = muldiv32(a->min, b->min, k, &r);
	c->openmin = (r || a->openmin || b->openmin);
	c->max = muldiv32(a->max, b->max, k, &r);
	if (r) {
		c->max++;
		c->openmax = 1;
	} else
		c->openmax = (a->openmax || b->openmax);
	c->integer = 0;
}

/**
 * snd_interval_mulkdiv - refine the interval value
T
Takashi Iwai 已提交
713 714 715 716
 * @a: dividend 1
 * @k: dividend 2 (as integer)
 * @b: divisor
 * @c: result
L
Linus Torvalds 已提交
717 718 719 720 721
 *
 * c = a * k / b
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
722 723
void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
		      const struct snd_interval *b, struct snd_interval *c)
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
{
	unsigned int r;
	if (a->empty || b->empty) {
		snd_interval_none(c);
		return;
	}
	c->empty = 0;
	c->min = muldiv32(a->min, k, b->max, &r);
	c->openmin = (r || a->openmin || b->openmax);
	if (b->min > 0) {
		c->max = muldiv32(a->max, k, b->min, &r);
		if (r) {
			c->max++;
			c->openmax = 1;
		} else
			c->openmax = (a->openmax || b->openmin);
	} else {
		c->max = UINT_MAX;
		c->openmax = 0;
	}
	c->integer = 0;
}

/* ---- */


/**
 * snd_interval_ratnum - refine the interval value
T
Takashi Iwai 已提交
752 753 754 755 756
 * @i: interval to refine
 * @rats_count: number of ratnum_t 
 * @rats: ratnum_t array
 * @nump: pointer to store the resultant numerator
 * @denp: pointer to store the resultant denominator
L
Linus Torvalds 已提交
757 758 759
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
760 761 762
int snd_interval_ratnum(struct snd_interval *i,
			unsigned int rats_count, struct snd_ratnum *rats,
			unsigned int *nump, unsigned int *denp)
L
Linus Torvalds 已提交
763 764 765
{
	unsigned int best_num, best_diff, best_den;
	unsigned int k;
T
Takashi Iwai 已提交
766
	struct snd_interval t;
L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
	int err;

	best_num = best_den = best_diff = 0;
	for (k = 0; k < rats_count; ++k) {
		unsigned int num = rats[k].num;
		unsigned int den;
		unsigned int q = i->min;
		int diff;
		if (q == 0)
			q = 1;
		den = div_down(num, q);
		if (den < rats[k].den_min)
			continue;
		if (den > rats[k].den_max)
			den = rats[k].den_max;
		else {
			unsigned int r;
			r = (den - rats[k].den_min) % rats[k].den_step;
			if (r != 0)
				den -= r;
		}
		diff = num - q * den;
		if (best_num == 0 ||
		    diff * best_den < best_diff * den) {
			best_diff = diff;
			best_den = den;
			best_num = num;
		}
	}
	if (best_den == 0) {
		i->empty = 1;
		return -EINVAL;
	}
	t.min = div_down(best_num, best_den);
	t.openmin = !!(best_num % best_den);
	
	best_num = best_den = best_diff = 0;
	for (k = 0; k < rats_count; ++k) {
		unsigned int num = rats[k].num;
		unsigned int den;
		unsigned int q = i->max;
		int diff;
		if (q == 0) {
			i->empty = 1;
			return -EINVAL;
		}
		den = div_up(num, q);
		if (den > rats[k].den_max)
			continue;
		if (den < rats[k].den_min)
			den = rats[k].den_min;
		else {
			unsigned int r;
			r = (den - rats[k].den_min) % rats[k].den_step;
			if (r != 0)
				den += rats[k].den_step - r;
		}
		diff = q * den - num;
		if (best_num == 0 ||
		    diff * best_den < best_diff * den) {
			best_diff = diff;
			best_den = den;
			best_num = num;
		}
	}
	if (best_den == 0) {
		i->empty = 1;
		return -EINVAL;
	}
	t.max = div_up(best_num, best_den);
	t.openmax = !!(best_num % best_den);
	t.integer = 0;
	err = snd_interval_refine(i, &t);
	if (err < 0)
		return err;

	if (snd_interval_single(i)) {
		if (nump)
			*nump = best_num;
		if (denp)
			*denp = best_den;
	}
	return err;
}

852 853
EXPORT_SYMBOL(snd_interval_ratnum);

L
Linus Torvalds 已提交
854 855
/**
 * snd_interval_ratden - refine the interval value
T
Takashi Iwai 已提交
856
 * @i: interval to refine
T
Takashi Iwai 已提交
857 858
 * @rats_count: number of struct ratden
 * @rats: struct ratden array
T
Takashi Iwai 已提交
859 860
 * @nump: pointer to store the resultant numerator
 * @denp: pointer to store the resultant denominator
L
Linus Torvalds 已提交
861 862 863
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
864 865
static int snd_interval_ratden(struct snd_interval *i,
			       unsigned int rats_count, struct snd_ratden *rats,
L
Linus Torvalds 已提交
866 867 868 869
			       unsigned int *nump, unsigned int *denp)
{
	unsigned int best_num, best_diff, best_den;
	unsigned int k;
T
Takashi Iwai 已提交
870
	struct snd_interval t;
L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
	int err;

	best_num = best_den = best_diff = 0;
	for (k = 0; k < rats_count; ++k) {
		unsigned int num;
		unsigned int den = rats[k].den;
		unsigned int q = i->min;
		int diff;
		num = mul(q, den);
		if (num > rats[k].num_max)
			continue;
		if (num < rats[k].num_min)
			num = rats[k].num_max;
		else {
			unsigned int r;
			r = (num - rats[k].num_min) % rats[k].num_step;
			if (r != 0)
				num += rats[k].num_step - r;
		}
		diff = num - q * den;
		if (best_num == 0 ||
		    diff * best_den < best_diff * den) {
			best_diff = diff;
			best_den = den;
			best_num = num;
		}
	}
	if (best_den == 0) {
		i->empty = 1;
		return -EINVAL;
	}
	t.min = div_down(best_num, best_den);
	t.openmin = !!(best_num % best_den);
	
	best_num = best_den = best_diff = 0;
	for (k = 0; k < rats_count; ++k) {
		unsigned int num;
		unsigned int den = rats[k].den;
		unsigned int q = i->max;
		int diff;
		num = mul(q, den);
		if (num < rats[k].num_min)
			continue;
		if (num > rats[k].num_max)
			num = rats[k].num_max;
		else {
			unsigned int r;
			r = (num - rats[k].num_min) % rats[k].num_step;
			if (r != 0)
				num -= r;
		}
		diff = q * den - num;
		if (best_num == 0 ||
		    diff * best_den < best_diff * den) {
			best_diff = diff;
			best_den = den;
			best_num = num;
		}
	}
	if (best_den == 0) {
		i->empty = 1;
		return -EINVAL;
	}
	t.max = div_up(best_num, best_den);
	t.openmax = !!(best_num % best_den);
	t.integer = 0;
	err = snd_interval_refine(i, &t);
	if (err < 0)
		return err;

	if (snd_interval_single(i)) {
		if (nump)
			*nump = best_num;
		if (denp)
			*denp = best_den;
	}
	return err;
}

/**
 * snd_interval_list - refine the interval value from the list
 * @i: the interval value to refine
 * @count: the number of elements in the list
 * @list: the value list
 * @mask: the bit-mask to evaluate
 *
 * Refines the interval value from the list.
 * When mask is non-zero, only the elements corresponding to bit 1 are
 * evaluated.
 *
 * Returns non-zero if the value is changed, zero if not changed.
 */
T
Takashi Iwai 已提交
963
int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask)
L
Linus Torvalds 已提交
964 965
{
        unsigned int k;
966
	struct snd_interval list_range;
967 968 969 970 971

	if (!count) {
		i->empty = 1;
		return -EINVAL;
	}
972 973 974
	snd_interval_any(&list_range);
	list_range.min = UINT_MAX;
	list_range.max = 0;
L
Linus Torvalds 已提交
975 976 977
        for (k = 0; k < count; k++) {
		if (mask && !(mask & (1 << k)))
			continue;
978
		if (!snd_interval_test(i, list[k]))
L
Linus Torvalds 已提交
979
			continue;
980 981
		list_range.min = min(list_range.min, list[k]);
		list_range.max = max(list_range.max, list[k]);
L
Linus Torvalds 已提交
982
        }
983
	return snd_interval_refine(i, &list_range);
L
Linus Torvalds 已提交
984 985
}

986 987
EXPORT_SYMBOL(snd_interval_list);

T
Takashi Iwai 已提交
988
static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
L
Linus Torvalds 已提交
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
{
	unsigned int n;
	int changed = 0;
	n = (i->min - min) % step;
	if (n != 0 || i->openmin) {
		i->min += step - n;
		changed = 1;
	}
	n = (i->max - min) % step;
	if (n != 0 || i->openmax) {
		i->max -= n;
		changed = 1;
	}
	if (snd_interval_checkempty(i)) {
		i->empty = 1;
		return -EINVAL;
	}
	return changed;
}

/* Info constraints helpers */

/**
 * snd_pcm_hw_rule_add - add the hw-constraint rule
 * @runtime: the pcm runtime instance
 * @cond: condition bits
 * @var: the variable to evaluate
 * @func: the evaluation function
 * @private: the private data pointer passed to function
 * @dep: the dependent variables
 *
 * Returns zero if successful, or a negative error code on failure.
 */
T
Takashi Iwai 已提交
1022
int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
L
Linus Torvalds 已提交
1023 1024 1025 1026
			int var,
			snd_pcm_hw_rule_func_t func, void *private,
			int dep, ...)
{
T
Takashi Iwai 已提交
1027 1028
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
	struct snd_pcm_hw_rule *c;
L
Linus Torvalds 已提交
1029 1030 1031 1032
	unsigned int k;
	va_list args;
	va_start(args, dep);
	if (constrs->rules_num >= constrs->rules_all) {
T
Takashi Iwai 已提交
1033
		struct snd_pcm_hw_rule *new;
L
Linus Torvalds 已提交
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
		unsigned int new_rules = constrs->rules_all + 16;
		new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
		if (!new)
			return -ENOMEM;
		if (constrs->rules) {
			memcpy(new, constrs->rules,
			       constrs->rules_num * sizeof(*c));
			kfree(constrs->rules);
		}
		constrs->rules = new;
		constrs->rules_all = new_rules;
	}
	c = &constrs->rules[constrs->rules_num];
	c->cond = cond;
	c->func = func;
	c->var = var;
	c->private = private;
	k = 0;
	while (1) {
1053 1054
		if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps)))
			return -EINVAL;
L
Linus Torvalds 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
		c->deps[k++] = dep;
		if (dep < 0)
			break;
		dep = va_arg(args, int);
	}
	constrs->rules_num++;
	va_end(args);
	return 0;
}				    

1065 1066
EXPORT_SYMBOL(snd_pcm_hw_rule_add);

L
Linus Torvalds 已提交
1067
/**
1068
 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
T
Takashi Iwai 已提交
1069 1070 1071 1072
 * @runtime: PCM runtime instance
 * @var: hw_params variable to apply the mask
 * @mask: the bitmap mask
 *
1073
 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
L
Linus Torvalds 已提交
1074
 */
T
Takashi Iwai 已提交
1075
int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
L
Linus Torvalds 已提交
1076 1077
			       u_int32_t mask)
{
T
Takashi Iwai 已提交
1078 1079
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
	struct snd_mask *maskp = constrs_mask(constrs, var);
L
Linus Torvalds 已提交
1080 1081 1082 1083 1084 1085 1086 1087
	*maskp->bits &= mask;
	memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
	if (*maskp->bits == 0)
		return -EINVAL;
	return 0;
}

/**
1088
 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
T
Takashi Iwai 已提交
1089 1090 1091 1092
 * @runtime: PCM runtime instance
 * @var: hw_params variable to apply the mask
 * @mask: the 64bit bitmap mask
 *
1093
 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
L
Linus Torvalds 已提交
1094
 */
T
Takashi Iwai 已提交
1095
int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
L
Linus Torvalds 已提交
1096 1097
				 u_int64_t mask)
{
T
Takashi Iwai 已提交
1098 1099
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
	struct snd_mask *maskp = constrs_mask(constrs, var);
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108
	maskp->bits[0] &= (u_int32_t)mask;
	maskp->bits[1] &= (u_int32_t)(mask >> 32);
	memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
	if (! maskp->bits[0] && ! maskp->bits[1])
		return -EINVAL;
	return 0;
}

/**
1109
 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
T
Takashi Iwai 已提交
1110 1111 1112 1113
 * @runtime: PCM runtime instance
 * @var: hw_params variable to apply the integer constraint
 *
 * Apply the constraint of integer to an interval parameter.
L
Linus Torvalds 已提交
1114
 */
T
Takashi Iwai 已提交
1115
int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
L
Linus Torvalds 已提交
1116
{
T
Takashi Iwai 已提交
1117
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
L
Linus Torvalds 已提交
1118 1119 1120
	return snd_interval_setinteger(constrs_interval(constrs, var));
}

1121 1122
EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);

L
Linus Torvalds 已提交
1123
/**
1124
 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
T
Takashi Iwai 已提交
1125 1126 1127 1128 1129 1130
 * @runtime: PCM runtime instance
 * @var: hw_params variable to apply the range
 * @min: the minimal value
 * @max: the maximal value
 * 
 * Apply the min/max range constraint to an interval parameter.
L
Linus Torvalds 已提交
1131
 */
T
Takashi Iwai 已提交
1132
int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
L
Linus Torvalds 已提交
1133 1134
				 unsigned int min, unsigned int max)
{
T
Takashi Iwai 已提交
1135 1136
	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
	struct snd_interval t;
L
Linus Torvalds 已提交
1137 1138 1139 1140 1141 1142 1143
	t.min = min;
	t.max = max;
	t.openmin = t.openmax = 0;
	t.integer = 0;
	return snd_interval_refine(constrs_interval(constrs, var), &t);
}

1144 1145
EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);

T
Takashi Iwai 已提交
1146 1147
static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
				struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1148
{
T
Takashi Iwai 已提交
1149
	struct snd_pcm_hw_constraint_list *list = rule->private;
L
Linus Torvalds 已提交
1150 1151 1152 1153 1154
	return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
}		


/**
1155
 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
T
Takashi Iwai 已提交
1156 1157 1158 1159 1160 1161
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @var: hw_params variable to apply the list constraint
 * @l: list
 * 
 * Apply the list of constraints to an interval parameter.
L
Linus Torvalds 已提交
1162
 */
T
Takashi Iwai 已提交
1163
int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
L
Linus Torvalds 已提交
1164 1165
			       unsigned int cond,
			       snd_pcm_hw_param_t var,
T
Takashi Iwai 已提交
1166
			       struct snd_pcm_hw_constraint_list *l)
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171 1172
{
	return snd_pcm_hw_rule_add(runtime, cond, var,
				   snd_pcm_hw_rule_list, l,
				   var, -1);
}

1173 1174
EXPORT_SYMBOL(snd_pcm_hw_constraint_list);

T
Takashi Iwai 已提交
1175 1176
static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
				   struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1177
{
T
Takashi Iwai 已提交
1178
	struct snd_pcm_hw_constraint_ratnums *r = rule->private;
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
	unsigned int num = 0, den = 0;
	int err;
	err = snd_interval_ratnum(hw_param_interval(params, rule->var),
				  r->nrats, r->rats, &num, &den);
	if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
		params->rate_num = num;
		params->rate_den = den;
	}
	return err;
}

/**
1191
 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
T
Takashi Iwai 已提交
1192 1193 1194
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @var: hw_params variable to apply the ratnums constraint
T
Takashi Iwai 已提交
1195
 * @r: struct snd_ratnums constriants
L
Linus Torvalds 已提交
1196
 */
T
Takashi Iwai 已提交
1197
int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
L
Linus Torvalds 已提交
1198 1199
				  unsigned int cond,
				  snd_pcm_hw_param_t var,
T
Takashi Iwai 已提交
1200
				  struct snd_pcm_hw_constraint_ratnums *r)
L
Linus Torvalds 已提交
1201 1202 1203 1204 1205 1206
{
	return snd_pcm_hw_rule_add(runtime, cond, var,
				   snd_pcm_hw_rule_ratnums, r,
				   var, -1);
}

1207 1208
EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);

T
Takashi Iwai 已提交
1209 1210
static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
				   struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1211
{
T
Takashi Iwai 已提交
1212
	struct snd_pcm_hw_constraint_ratdens *r = rule->private;
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
	unsigned int num = 0, den = 0;
	int err = snd_interval_ratden(hw_param_interval(params, rule->var),
				  r->nrats, r->rats, &num, &den);
	if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
		params->rate_num = num;
		params->rate_den = den;
	}
	return err;
}

/**
1224
 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
T
Takashi Iwai 已提交
1225 1226 1227
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @var: hw_params variable to apply the ratdens constraint
T
Takashi Iwai 已提交
1228
 * @r: struct snd_ratdens constriants
L
Linus Torvalds 已提交
1229
 */
T
Takashi Iwai 已提交
1230
int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
L
Linus Torvalds 已提交
1231 1232
				  unsigned int cond,
				  snd_pcm_hw_param_t var,
T
Takashi Iwai 已提交
1233
				  struct snd_pcm_hw_constraint_ratdens *r)
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239
{
	return snd_pcm_hw_rule_add(runtime, cond, var,
				   snd_pcm_hw_rule_ratdens, r,
				   var, -1);
}

1240 1241
EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);

T
Takashi Iwai 已提交
1242 1243
static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
				  struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1244 1245 1246 1247
{
	unsigned int l = (unsigned long) rule->private;
	int width = l & 0xffff;
	unsigned int msbits = l >> 16;
T
Takashi Iwai 已提交
1248
	struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
L
Linus Torvalds 已提交
1249 1250 1251 1252 1253 1254
	if (snd_interval_single(i) && snd_interval_value(i) == width)
		params->msbits = msbits;
	return 0;
}

/**
1255
 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
T
Takashi Iwai 已提交
1256 1257 1258 1259
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @width: sample bits width
 * @msbits: msbits width
L
Linus Torvalds 已提交
1260
 */
T
Takashi Iwai 已提交
1261
int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
L
Linus Torvalds 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
				 unsigned int cond,
				 unsigned int width,
				 unsigned int msbits)
{
	unsigned long l = (msbits << 16) | width;
	return snd_pcm_hw_rule_add(runtime, cond, -1,
				    snd_pcm_hw_rule_msbits,
				    (void*) l,
				    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
}

1273 1274
EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);

T
Takashi Iwai 已提交
1275 1276
static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
				struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1277 1278 1279 1280 1281 1282
{
	unsigned long step = (unsigned long) rule->private;
	return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
}

/**
1283
 * snd_pcm_hw_constraint_step - add a hw constraint step rule
T
Takashi Iwai 已提交
1284 1285 1286 1287
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @var: hw_params variable to apply the step constraint
 * @step: step size
L
Linus Torvalds 已提交
1288
 */
T
Takashi Iwai 已提交
1289
int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
L
Linus Torvalds 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298
			       unsigned int cond,
			       snd_pcm_hw_param_t var,
			       unsigned long step)
{
	return snd_pcm_hw_rule_add(runtime, cond, var, 
				   snd_pcm_hw_rule_step, (void *) step,
				   var, -1);
}

1299 1300
EXPORT_SYMBOL(snd_pcm_hw_constraint_step);

T
Takashi Iwai 已提交
1301
static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
L
Linus Torvalds 已提交
1302
{
1303
	static unsigned int pow2_sizes[] = {
L
Linus Torvalds 已提交
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
		1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
		1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
		1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
		1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
	};
	return snd_interval_list(hw_param_interval(params, rule->var),
				 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
}		

/**
1314
 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
T
Takashi Iwai 已提交
1315 1316 1317
 * @runtime: PCM runtime instance
 * @cond: condition bits
 * @var: hw_params variable to apply the power-of-2 constraint
L
Linus Torvalds 已提交
1318
 */
T
Takashi Iwai 已提交
1319
int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
L
Linus Torvalds 已提交
1320 1321 1322 1323 1324 1325 1326 1327
			       unsigned int cond,
			       snd_pcm_hw_param_t var)
{
	return snd_pcm_hw_rule_add(runtime, cond, var, 
				   snd_pcm_hw_rule_pow2, NULL,
				   var, -1);
}

1328 1329
EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);

T
Takashi Iwai 已提交
1330
static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
1331
				  snd_pcm_hw_param_t var)
L
Linus Torvalds 已提交
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
{
	if (hw_is_mask(var)) {
		snd_mask_any(hw_param_mask(params, var));
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
		return;
	}
	if (hw_is_interval(var)) {
		snd_interval_any(hw_param_interval(params, var));
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
		return;
	}
	snd_BUG();
}

T
Takashi Iwai 已提交
1348
void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
L
Linus Torvalds 已提交
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
{
	unsigned int k;
	memset(params, 0, sizeof(*params));
	for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
		_snd_pcm_hw_param_any(params, k);
	for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
		_snd_pcm_hw_param_any(params, k);
	params->info = ~0U;
}

1359
EXPORT_SYMBOL(_snd_pcm_hw_params_any);
L
Linus Torvalds 已提交
1360 1361

/**
1362
 * snd_pcm_hw_param_value - return @params field @var value
T
Takashi Iwai 已提交
1363 1364
 * @params: the hw_params instance
 * @var: parameter to retrieve
1365
 * @dir: pointer to the direction (-1,0,1) or %NULL
L
Linus Torvalds 已提交
1366
 *
1367 1368
 * Return the value for field @var if it's fixed in configuration space
 * defined by @params. Return -%EINVAL otherwise.
L
Linus Torvalds 已提交
1369
 */
1370 1371
int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
			   snd_pcm_hw_param_t var, int *dir)
L
Linus Torvalds 已提交
1372 1373
{
	if (hw_is_mask(var)) {
T
Takashi Iwai 已提交
1374
		const struct snd_mask *mask = hw_param_mask_c(params, var);
L
Linus Torvalds 已提交
1375 1376 1377 1378 1379 1380 1381
		if (!snd_mask_single(mask))
			return -EINVAL;
		if (dir)
			*dir = 0;
		return snd_mask_value(mask);
	}
	if (hw_is_interval(var)) {
T
Takashi Iwai 已提交
1382
		const struct snd_interval *i = hw_param_interval_c(params, var);
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389 1390 1391
		if (!snd_interval_single(i))
			return -EINVAL;
		if (dir)
			*dir = i->openmin;
		return snd_interval_value(i);
	}
	return -EINVAL;
}

1392
EXPORT_SYMBOL(snd_pcm_hw_param_value);
L
Linus Torvalds 已提交
1393

T
Takashi Iwai 已提交
1394
void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
L
Linus Torvalds 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
				snd_pcm_hw_param_t var)
{
	if (hw_is_mask(var)) {
		snd_mask_none(hw_param_mask(params, var));
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
	} else if (hw_is_interval(var)) {
		snd_interval_none(hw_param_interval(params, var));
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
	} else {
		snd_BUG();
	}
}

1410
EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
L
Linus Torvalds 已提交
1411

T
Takashi Iwai 已提交
1412
static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
1413
				   snd_pcm_hw_param_t var)
L
Linus Torvalds 已提交
1414 1415 1416 1417 1418 1419
{
	int changed;
	if (hw_is_mask(var))
		changed = snd_mask_refine_first(hw_param_mask(params, var));
	else if (hw_is_interval(var))
		changed = snd_interval_refine_first(hw_param_interval(params, var));
1420
	else
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
		return -EINVAL;
	if (changed) {
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
	}
	return changed;
}


/**
1431
 * snd_pcm_hw_param_first - refine config space and return minimum value
T
Takashi Iwai 已提交
1432 1433 1434
 * @pcm: PCM instance
 * @params: the hw_params instance
 * @var: parameter to retrieve
1435
 * @dir: pointer to the direction (-1,0,1) or %NULL
L
Linus Torvalds 已提交
1436
 *
1437
 * Inside configuration space defined by @params remove from @var all
L
Linus Torvalds 已提交
1438 1439 1440
 * values > minimum. Reduce configuration space accordingly.
 * Return the minimum.
 */
1441 1442 1443
int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
			   struct snd_pcm_hw_params *params, 
			   snd_pcm_hw_param_t var, int *dir)
L
Linus Torvalds 已提交
1444 1445 1446 1447 1448 1449
{
	int changed = _snd_pcm_hw_param_first(params, var);
	if (changed < 0)
		return changed;
	if (params->rmask) {
		int err = snd_pcm_hw_refine(pcm, params);
1450 1451
		if (snd_BUG_ON(err < 0))
			return err;
L
Linus Torvalds 已提交
1452 1453 1454 1455
	}
	return snd_pcm_hw_param_value(params, var, dir);
}

1456 1457
EXPORT_SYMBOL(snd_pcm_hw_param_first);

T
Takashi Iwai 已提交
1458
static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
1459
				  snd_pcm_hw_param_t var)
L
Linus Torvalds 已提交
1460 1461 1462 1463 1464 1465
{
	int changed;
	if (hw_is_mask(var))
		changed = snd_mask_refine_last(hw_param_mask(params, var));
	else if (hw_is_interval(var))
		changed = snd_interval_refine_last(hw_param_interval(params, var));
1466
	else
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
		return -EINVAL;
	if (changed) {
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
	}
	return changed;
}


/**
1477
 * snd_pcm_hw_param_last - refine config space and return maximum value
T
Takashi Iwai 已提交
1478 1479 1480
 * @pcm: PCM instance
 * @params: the hw_params instance
 * @var: parameter to retrieve
1481
 * @dir: pointer to the direction (-1,0,1) or %NULL
L
Linus Torvalds 已提交
1482
 *
1483
 * Inside configuration space defined by @params remove from @var all
L
Linus Torvalds 已提交
1484 1485 1486
 * values < maximum. Reduce configuration space accordingly.
 * Return the maximum.
 */
1487 1488 1489
int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
			  struct snd_pcm_hw_params *params,
			  snd_pcm_hw_param_t var, int *dir)
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494 1495
{
	int changed = _snd_pcm_hw_param_last(params, var);
	if (changed < 0)
		return changed;
	if (params->rmask) {
		int err = snd_pcm_hw_refine(pcm, params);
1496 1497
		if (snd_BUG_ON(err < 0))
			return err;
L
Linus Torvalds 已提交
1498 1499 1500 1501
	}
	return snd_pcm_hw_param_value(params, var, dir);
}

1502
EXPORT_SYMBOL(snd_pcm_hw_param_last);
L
Linus Torvalds 已提交
1503 1504

/**
1505
 * snd_pcm_hw_param_choose - choose a configuration defined by @params
T
Takashi Iwai 已提交
1506 1507
 * @pcm: PCM instance
 * @params: the hw_params instance
L
Linus Torvalds 已提交
1508
 *
1509
 * Choose one configuration from configuration space defined by @params.
L
Linus Torvalds 已提交
1510 1511 1512 1513
 * The configuration chosen is that obtained fixing in this order:
 * first access, first format, first subformat, min channels,
 * min rate, min period time, max buffer size, min tick time
 */
1514 1515
int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
			     struct snd_pcm_hw_params *params)
L
Linus Torvalds 已提交
1516
{
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
	static int vars[] = {
		SNDRV_PCM_HW_PARAM_ACCESS,
		SNDRV_PCM_HW_PARAM_FORMAT,
		SNDRV_PCM_HW_PARAM_SUBFORMAT,
		SNDRV_PCM_HW_PARAM_CHANNELS,
		SNDRV_PCM_HW_PARAM_RATE,
		SNDRV_PCM_HW_PARAM_PERIOD_TIME,
		SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
		SNDRV_PCM_HW_PARAM_TICK_TIME,
		-1
	};
	int err, *v;
L
Linus Torvalds 已提交
1529

1530 1531 1532 1533 1534
	for (v = vars; *v != -1; v++) {
		if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
			err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
		else
			err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
1535 1536
		if (snd_BUG_ON(err < 0))
			return err;
1537
	}
L
Linus Torvalds 已提交
1538 1539 1540
	return 0;
}

T
Takashi Iwai 已提交
1541
static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1542 1543
				   void *arg)
{
T
Takashi Iwai 已提交
1544
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
	unsigned long flags;
	snd_pcm_stream_lock_irqsave(substream, flags);
	if (snd_pcm_running(substream) &&
	    snd_pcm_update_hw_ptr(substream) >= 0)
		runtime->status->hw_ptr %= runtime->buffer_size;
	else
		runtime->status->hw_ptr = 0;
	snd_pcm_stream_unlock_irqrestore(substream, flags);
	return 0;
}

T
Takashi Iwai 已提交
1556
static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1557 1558
					  void *arg)
{
T
Takashi Iwai 已提交
1559 1560
	struct snd_pcm_channel_info *info = arg;
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
	int width;
	if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
		info->offset = -1;
		return 0;
	}
	width = snd_pcm_format_physical_width(runtime->format);
	if (width < 0)
		return width;
	info->offset = 0;
	switch (runtime->access) {
	case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
	case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
		info->first = info->channel * width;
		info->step = runtime->channels * width;
		break;
	case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
	case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
	{
		size_t size = runtime->dma_bytes / runtime->channels;
		info->first = info->channel * size * 8;
		info->step = width;
		break;
	}
	default:
		snd_BUG();
		break;
	}
	return 0;
}

1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
				       void *arg)
{
	struct snd_pcm_hw_params *params = arg;
	snd_pcm_format_t format;
	int channels, width;

	params->fifo_size = substream->runtime->hw.fifo_size;
	if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
		format = params_format(params);
		channels = params_channels(params);
		width = snd_pcm_format_physical_width(format);
		params->fifo_size /= width * channels;
	}
	return 0;
}

L
Linus Torvalds 已提交
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
/**
 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
 * @substream: the pcm substream instance
 * @cmd: ioctl command
 * @arg: ioctl argument
 *
 * Processes the generic ioctl commands for PCM.
 * Can be passed as the ioctl callback for PCM ops.
 *
 * Returns zero if successful, or a negative error code on failure.
 */
T
Takashi Iwai 已提交
1619
int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1620 1621 1622 1623 1624 1625 1626 1627 1628
		      unsigned int cmd, void *arg)
{
	switch (cmd) {
	case SNDRV_PCM_IOCTL1_INFO:
		return 0;
	case SNDRV_PCM_IOCTL1_RESET:
		return snd_pcm_lib_ioctl_reset(substream, arg);
	case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
		return snd_pcm_lib_ioctl_channel_info(substream, arg);
1629 1630
	case SNDRV_PCM_IOCTL1_FIFO_SIZE:
		return snd_pcm_lib_ioctl_fifo_size(substream, arg);
L
Linus Torvalds 已提交
1631 1632 1633 1634
	}
	return -ENXIO;
}

1635 1636
EXPORT_SYMBOL(snd_pcm_lib_ioctl);

L
Linus Torvalds 已提交
1637 1638 1639 1640 1641 1642
/**
 * snd_pcm_period_elapsed - update the pcm status for the next period
 * @substream: the pcm substream instance
 *
 * This function is called from the interrupt handler when the
 * PCM has processed the period size.  It will update the current
1643
 * pointer, wake up sleepers, etc.
L
Linus Torvalds 已提交
1644 1645 1646 1647
 *
 * Even if more than one periods have elapsed since the last call, you
 * have to call this only once.
 */
T
Takashi Iwai 已提交
1648
void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
1649
{
T
Takashi Iwai 已提交
1650
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
1651 1652
	unsigned long flags;

1653 1654
	if (PCM_RUNTIME_CHECK(substream))
		return;
L
Linus Torvalds 已提交
1655 1656 1657 1658 1659 1660 1661
	runtime = substream->runtime;

	if (runtime->transfer_ack_begin)
		runtime->transfer_ack_begin(substream);

	snd_pcm_stream_lock_irqsave(substream, flags);
	if (!snd_pcm_running(substream) ||
1662
	    snd_pcm_update_hw_ptr0(substream, 1) < 0)
L
Linus Torvalds 已提交
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
		goto _end;

	if (substream->timer_running)
		snd_timer_interrupt(substream->timer, 1);
 _end:
	snd_pcm_stream_unlock_irqrestore(substream, flags);
	if (runtime->transfer_ack_end)
		runtime->transfer_ack_end(substream);
	kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
}

1674 1675
EXPORT_SYMBOL(snd_pcm_period_elapsed);

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
/*
 * Wait until avail_min data becomes available
 * Returns a negative error code if any error occurs during operation.
 * The available space is stored on availp.  When err = 0 and avail = 0
 * on the capture stream, it indicates the stream is in DRAINING state.
 */
static int wait_for_avail_min(struct snd_pcm_substream *substream,
			      snd_pcm_uframes_t *availp)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
	wait_queue_t wait;
	int err = 0;
	snd_pcm_uframes_t avail = 0;
	long tout;

	init_waitqueue_entry(&wait, current);
	add_wait_queue(&runtime->sleep, &wait);
	for (;;) {
		if (signal_pending(current)) {
			err = -ERESTARTSYS;
			break;
		}
		set_current_state(TASK_INTERRUPTIBLE);
		snd_pcm_stream_unlock_irq(substream);
		tout = schedule_timeout(msecs_to_jiffies(10000));
		snd_pcm_stream_lock_irq(substream);
		switch (runtime->status->state) {
		case SNDRV_PCM_STATE_SUSPENDED:
			err = -ESTRPIPE;
			goto _endloop;
		case SNDRV_PCM_STATE_XRUN:
			err = -EPIPE;
			goto _endloop;
		case SNDRV_PCM_STATE_DRAINING:
			if (is_playback)
				err = -EPIPE;
			else 
				avail = 0; /* indicate draining */
			goto _endloop;
		case SNDRV_PCM_STATE_OPEN:
		case SNDRV_PCM_STATE_SETUP:
		case SNDRV_PCM_STATE_DISCONNECTED:
			err = -EBADFD;
			goto _endloop;
		}
		if (!tout) {
			snd_printd("%s write error (DMA or IRQ trouble?)\n",
				   is_playback ? "playback" : "capture");
			err = -EIO;
			break;
		}
		if (is_playback)
			avail = snd_pcm_playback_avail(runtime);
		else
			avail = snd_pcm_capture_avail(runtime);
		if (avail >= runtime->control->avail_min)
			break;
	}
 _endloop:
	remove_wait_queue(&runtime->sleep, &wait);
	*availp = avail;
	return err;
}
	
T
Takashi Iwai 已提交
1741
static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1742 1743 1744 1745
				      unsigned int hwoff,
				      unsigned long data, unsigned int off,
				      snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
1746
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
	int err;
	char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
	if (substream->ops->copy) {
		if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
			return err;
	} else {
		char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
		if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
			return -EFAULT;
	}
	return 0;
}
 
T
Takashi Iwai 已提交
1760
typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
L
Linus Torvalds 已提交
1761 1762 1763
			  unsigned long data, unsigned int off,
			  snd_pcm_uframes_t size);

T
Takashi Iwai 已提交
1764
static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, 
L
Linus Torvalds 已提交
1765 1766 1767 1768 1769
					    unsigned long data,
					    snd_pcm_uframes_t size,
					    int nonblock,
					    transfer_f transfer)
{
T
Takashi Iwai 已提交
1770
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
	snd_pcm_uframes_t xfer = 0;
	snd_pcm_uframes_t offset = 0;
	int err = 0;

	if (size == 0)
		return 0;

	snd_pcm_stream_lock_irq(substream);
	switch (runtime->status->state) {
	case SNDRV_PCM_STATE_PREPARED:
	case SNDRV_PCM_STATE_RUNNING:
	case SNDRV_PCM_STATE_PAUSED:
		break;
	case SNDRV_PCM_STATE_XRUN:
		err = -EPIPE;
		goto _end_unlock;
	case SNDRV_PCM_STATE_SUSPENDED:
		err = -ESTRPIPE;
		goto _end_unlock;
	default:
		err = -EBADFD;
		goto _end_unlock;
	}

	while (size > 0) {
		snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
		snd_pcm_uframes_t avail;
		snd_pcm_uframes_t cont;
1799
		if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
L
Linus Torvalds 已提交
1800 1801
			snd_pcm_update_hw_ptr(substream);
		avail = snd_pcm_playback_avail(runtime);
1802
		if (!avail) {
L
Linus Torvalds 已提交
1803 1804 1805 1806
			if (nonblock) {
				err = -EAGAIN;
				goto _end_unlock;
			}
1807 1808
			err = wait_for_avail_min(substream, &avail);
			if (err < 0)
1809
				goto _end_unlock;
L
Linus Torvalds 已提交
1810 1811 1812 1813 1814
		}
		frames = size > avail ? avail : size;
		cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
		if (frames > cont)
			frames = cont;
1815 1816 1817 1818
		if (snd_BUG_ON(!frames)) {
			snd_pcm_stream_unlock_irq(substream);
			return -EINVAL;
		}
L
Linus Torvalds 已提交
1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
		appl_ptr = runtime->control->appl_ptr;
		appl_ofs = appl_ptr % runtime->buffer_size;
		snd_pcm_stream_unlock_irq(substream);
		if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
			goto _end;
		snd_pcm_stream_lock_irq(substream);
		switch (runtime->status->state) {
		case SNDRV_PCM_STATE_XRUN:
			err = -EPIPE;
			goto _end_unlock;
		case SNDRV_PCM_STATE_SUSPENDED:
			err = -ESTRPIPE;
			goto _end_unlock;
		default:
			break;
		}
		appl_ptr += frames;
		if (appl_ptr >= runtime->boundary)
			appl_ptr -= runtime->boundary;
		runtime->control->appl_ptr = appl_ptr;
		if (substream->ops->ack)
			substream->ops->ack(substream);

		offset += frames;
		size -= frames;
		xfer += frames;
		if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
		    snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
			err = snd_pcm_start(substream);
			if (err < 0)
				goto _end_unlock;
		}
	}
 _end_unlock:
	snd_pcm_stream_unlock_irq(substream);
 _end:
	return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
}

1858 1859
/* sanity-check for read/write methods */
static int pcm_sanity_check(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
1860
{
T
Takashi Iwai 已提交
1861
	struct snd_pcm_runtime *runtime;
1862 1863
	if (PCM_RUNTIME_CHECK(substream))
		return -ENXIO;
L
Linus Torvalds 已提交
1864
	runtime = substream->runtime;
1865 1866
	if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
		return -EINVAL;
L
Linus Torvalds 已提交
1867 1868
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
		return -EBADFD;
1869 1870 1871 1872 1873 1874 1875 1876
	return 0;
}

snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
{
	struct snd_pcm_runtime *runtime;
	int nonblock;
	int err;
L
Linus Torvalds 已提交
1877

1878 1879 1880 1881
	err = pcm_sanity_check(substream);
	if (err < 0)
		return err;
	runtime = substream->runtime;
1882
	nonblock = !!(substream->f_flags & O_NONBLOCK);
L
Linus Torvalds 已提交
1883 1884 1885 1886 1887 1888 1889 1890

	if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
	    runtime->channels > 1)
		return -EINVAL;
	return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
				  snd_pcm_lib_write_transfer);
}

1891 1892
EXPORT_SYMBOL(snd_pcm_lib_write);

T
Takashi Iwai 已提交
1893
static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1894 1895 1896 1897
				       unsigned int hwoff,
				       unsigned long data, unsigned int off,
				       snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
1898
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1899 1900 1901 1902 1903
	int err;
	void __user **bufs = (void __user **)data;
	int channels = runtime->channels;
	int c;
	if (substream->ops->copy) {
1904 1905
		if (snd_BUG_ON(!substream->ops->silence))
			return -EINVAL;
L
Linus Torvalds 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
		for (c = 0; c < channels; ++c, ++bufs) {
			if (*bufs == NULL) {
				if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
					return err;
			} else {
				char __user *buf = *bufs + samples_to_bytes(runtime, off);
				if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
					return err;
			}
		}
	} else {
		/* default transfer behaviour */
		size_t dma_csize = runtime->dma_bytes / channels;
		for (c = 0; c < channels; ++c, ++bufs) {
			char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
			if (*bufs == NULL) {
				snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
			} else {
				char __user *buf = *bufs + samples_to_bytes(runtime, off);
				if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
					return -EFAULT;
			}
		}
	}
	return 0;
}
 
T
Takashi Iwai 已提交
1933
snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1934 1935 1936
				     void __user **bufs,
				     snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
1937
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
1938
	int nonblock;
1939
	int err;
L
Linus Torvalds 已提交
1940

1941 1942 1943
	err = pcm_sanity_check(substream);
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
1944
	runtime = substream->runtime;
1945
	nonblock = !!(substream->f_flags & O_NONBLOCK);
L
Linus Torvalds 已提交
1946 1947 1948 1949 1950 1951 1952

	if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
		return -EINVAL;
	return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
				  nonblock, snd_pcm_lib_writev_transfer);
}

1953 1954
EXPORT_SYMBOL(snd_pcm_lib_writev);

T
Takashi Iwai 已提交
1955
static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 
L
Linus Torvalds 已提交
1956 1957 1958 1959
				     unsigned int hwoff,
				     unsigned long data, unsigned int off,
				     snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
1960
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
	int err;
	char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
	if (substream->ops->copy) {
		if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
			return err;
	} else {
		char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
		if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
			return -EFAULT;
	}
	return 0;
}

T
Takashi Iwai 已提交
1974
static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
1975 1976 1977 1978 1979
					   unsigned long data,
					   snd_pcm_uframes_t size,
					   int nonblock,
					   transfer_f transfer)
{
T
Takashi Iwai 已提交
1980
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015
	snd_pcm_uframes_t xfer = 0;
	snd_pcm_uframes_t offset = 0;
	int err = 0;

	if (size == 0)
		return 0;

	snd_pcm_stream_lock_irq(substream);
	switch (runtime->status->state) {
	case SNDRV_PCM_STATE_PREPARED:
		if (size >= runtime->start_threshold) {
			err = snd_pcm_start(substream);
			if (err < 0)
				goto _end_unlock;
		}
		break;
	case SNDRV_PCM_STATE_DRAINING:
	case SNDRV_PCM_STATE_RUNNING:
	case SNDRV_PCM_STATE_PAUSED:
		break;
	case SNDRV_PCM_STATE_XRUN:
		err = -EPIPE;
		goto _end_unlock;
	case SNDRV_PCM_STATE_SUSPENDED:
		err = -ESTRPIPE;
		goto _end_unlock;
	default:
		err = -EBADFD;
		goto _end_unlock;
	}

	while (size > 0) {
		snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
		snd_pcm_uframes_t avail;
		snd_pcm_uframes_t cont;
2016
		if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
L
Linus Torvalds 已提交
2017 2018
			snd_pcm_update_hw_ptr(substream);
		avail = snd_pcm_capture_avail(runtime);
2019 2020 2021 2022
		if (!avail) {
			if (runtime->status->state ==
			    SNDRV_PCM_STATE_DRAINING) {
				snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
L
Linus Torvalds 已提交
2023 2024 2025 2026 2027 2028
				goto _end_unlock;
			}
			if (nonblock) {
				err = -EAGAIN;
				goto _end_unlock;
			}
2029 2030
			err = wait_for_avail_min(substream, &avail);
			if (err < 0)
2031
				goto _end_unlock;
2032 2033
			if (!avail)
				continue; /* draining */
L
Linus Torvalds 已提交
2034 2035 2036 2037 2038
		}
		frames = size > avail ? avail : size;
		cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
		if (frames > cont)
			frames = cont;
2039 2040 2041 2042
		if (snd_BUG_ON(!frames)) {
			snd_pcm_stream_unlock_irq(substream);
			return -EINVAL;
		}
L
Linus Torvalds 已提交
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
		appl_ptr = runtime->control->appl_ptr;
		appl_ofs = appl_ptr % runtime->buffer_size;
		snd_pcm_stream_unlock_irq(substream);
		if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
			goto _end;
		snd_pcm_stream_lock_irq(substream);
		switch (runtime->status->state) {
		case SNDRV_PCM_STATE_XRUN:
			err = -EPIPE;
			goto _end_unlock;
		case SNDRV_PCM_STATE_SUSPENDED:
			err = -ESTRPIPE;
			goto _end_unlock;
		default:
			break;
		}
		appl_ptr += frames;
		if (appl_ptr >= runtime->boundary)
			appl_ptr -= runtime->boundary;
		runtime->control->appl_ptr = appl_ptr;
		if (substream->ops->ack)
			substream->ops->ack(substream);

		offset += frames;
		size -= frames;
		xfer += frames;
	}
 _end_unlock:
	snd_pcm_stream_unlock_irq(substream);
 _end:
	return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
}

T
Takashi Iwai 已提交
2076
snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
L
Linus Torvalds 已提交
2077
{
T
Takashi Iwai 已提交
2078
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
2079
	int nonblock;
2080
	int err;
L
Linus Torvalds 已提交
2081
	
2082 2083 2084
	err = pcm_sanity_check(substream);
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
2085
	runtime = substream->runtime;
2086
	nonblock = !!(substream->f_flags & O_NONBLOCK);
L
Linus Torvalds 已提交
2087 2088 2089 2090 2091
	if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
		return -EINVAL;
	return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
}

2092 2093
EXPORT_SYMBOL(snd_pcm_lib_read);

T
Takashi Iwai 已提交
2094
static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
2095 2096 2097 2098
				      unsigned int hwoff,
				      unsigned long data, unsigned int off,
				      snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
2099
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
	int err;
	void __user **bufs = (void __user **)data;
	int channels = runtime->channels;
	int c;
	if (substream->ops->copy) {
		for (c = 0; c < channels; ++c, ++bufs) {
			char __user *buf;
			if (*bufs == NULL)
				continue;
			buf = *bufs + samples_to_bytes(runtime, off);
			if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
				return err;
		}
	} else {
		snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
		for (c = 0; c < channels; ++c, ++bufs) {
			char *hwbuf;
			char __user *buf;
			if (*bufs == NULL)
				continue;

			hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
			buf = *bufs + samples_to_bytes(runtime, off);
			if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
				return -EFAULT;
		}
	}
	return 0;
}
 
T
Takashi Iwai 已提交
2130
snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
L
Linus Torvalds 已提交
2131 2132 2133
				    void __user **bufs,
				    snd_pcm_uframes_t frames)
{
T
Takashi Iwai 已提交
2134
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
2135
	int nonblock;
2136
	int err;
L
Linus Torvalds 已提交
2137

2138 2139 2140
	err = pcm_sanity_check(substream);
	if (err < 0)
		return err;
L
Linus Torvalds 已提交
2141 2142 2143 2144
	runtime = substream->runtime;
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
		return -EBADFD;

2145
	nonblock = !!(substream->f_flags & O_NONBLOCK);
L
Linus Torvalds 已提交
2146 2147 2148 2149 2150 2151
	if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
		return -EINVAL;
	return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
}

EXPORT_SYMBOL(snd_pcm_lib_readv);