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