bf34603a7a38b2d2b4651e25da99da1ec97396f1
[linux-2.6.git] / sound / core / pcm_lib.c
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 <sound/core.h>
26 #include <sound/control.h>
27 #include <sound/info.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/timer.h>
31
32 /*
33  * fill ring buffer with silence
34  * runtime->silence_start: starting pointer to silence area
35  * runtime->silence_filled: size filled with silence
36  * runtime->silence_threshold: threshold from application
37  * runtime->silence_size: maximal size from application
38  *
39  * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
40  */
41 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
42 {
43         struct snd_pcm_runtime *runtime = substream->runtime;
44         snd_pcm_uframes_t frames, ofs, transfer;
45
46         if (runtime->silence_size < runtime->boundary) {
47                 snd_pcm_sframes_t noise_dist, n;
48                 if (runtime->silence_start != runtime->control->appl_ptr) {
49                         n = runtime->control->appl_ptr - runtime->silence_start;
50                         if (n < 0)
51                                 n += runtime->boundary;
52                         if ((snd_pcm_uframes_t)n < runtime->silence_filled)
53                                 runtime->silence_filled -= n;
54                         else
55                                 runtime->silence_filled = 0;
56                         runtime->silence_start = runtime->control->appl_ptr;
57                 }
58                 if (runtime->silence_filled >= runtime->buffer_size)
59                         return;
60                 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
61                 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
62                         return;
63                 frames = runtime->silence_threshold - noise_dist;
64                 if (frames > runtime->silence_size)
65                         frames = runtime->silence_size;
66         } else {
67                 if (new_hw_ptr == ULONG_MAX) {  /* initialization */
68                         snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
69                         runtime->silence_filled = avail > 0 ? avail : 0;
70                         runtime->silence_start = (runtime->status->hw_ptr +
71                                                   runtime->silence_filled) %
72                                                  runtime->boundary;
73                 } else {
74                         ofs = runtime->status->hw_ptr;
75                         frames = new_hw_ptr - ofs;
76                         if ((snd_pcm_sframes_t)frames < 0)
77                                 frames += runtime->boundary;
78                         runtime->silence_filled -= frames;
79                         if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
80                                 runtime->silence_filled = 0;
81                                 runtime->silence_start = new_hw_ptr;
82                         } else {
83                                 runtime->silence_start = ofs;
84                         }
85                 }
86                 frames = runtime->buffer_size - runtime->silence_filled;
87         }
88         if (snd_BUG_ON(frames > runtime->buffer_size))
89                 return;
90         if (frames == 0)
91                 return;
92         ofs = runtime->silence_start % runtime->buffer_size;
93         while (frames > 0) {
94                 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
95                 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
96                     runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
97                         if (substream->ops->silence) {
98                                 int err;
99                                 err = substream->ops->silence(substream, -1, ofs, transfer);
100                                 snd_BUG_ON(err < 0);
101                         } else {
102                                 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
103                                 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
104                         }
105                 } else {
106                         unsigned int c;
107                         unsigned int channels = runtime->channels;
108                         if (substream->ops->silence) {
109                                 for (c = 0; c < channels; ++c) {
110                                         int err;
111                                         err = substream->ops->silence(substream, c, ofs, transfer);
112                                         snd_BUG_ON(err < 0);
113                                 }
114                         } else {
115                                 size_t dma_csize = runtime->dma_bytes / channels;
116                                 for (c = 0; c < channels; ++c) {
117                                         char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
118                                         snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
119                                 }
120                         }
121                 }
122                 runtime->silence_filled += transfer;
123                 frames -= transfer;
124                 ofs = 0;
125         }
126 }
127
128 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
129 #define xrun_debug(substream, mask)     ((substream)->pstr->xrun_debug & (mask))
130 #else
131 #define xrun_debug(substream, mask)     0
132 #endif
133
134 #define dump_stack_on_xrun(substream) do {              \
135                 if (xrun_debug(substream, 2))           \
136                         dump_stack();                   \
137         } while (0)
138
139 static void xrun(struct snd_pcm_substream *substream)
140 {
141         struct snd_pcm_runtime *runtime = substream->runtime;
142
143         if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
144                 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
145         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
146         if (xrun_debug(substream, 1)) {
147                 snd_printd(KERN_DEBUG "XRUN: pcmC%dD%d%c\n",
148                            substream->pcm->card->number,
149                            substream->pcm->device,
150                            substream->stream ? 'c' : 'p');
151                 dump_stack_on_xrun(substream);
152         }
153 }
154
155 static snd_pcm_uframes_t
156 snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream,
157                           struct snd_pcm_runtime *runtime)
158 {
159         snd_pcm_uframes_t pos;
160
161         pos = substream->ops->pointer(substream);
162         if (pos == SNDRV_PCM_POS_XRUN)
163                 return pos; /* XRUN */
164         if (pos >= runtime->buffer_size) {
165                 if (printk_ratelimit()) {
166                         snd_printd(KERN_ERR  "BUG: stream = %i, pos = 0x%lx, "
167                                    "buffer size = 0x%lx, period size = 0x%lx\n",
168                                    substream->stream, pos, runtime->buffer_size,
169                                    runtime->period_size);
170                 }
171                 pos = 0;
172         }
173         pos -= pos % runtime->min_align;
174         return pos;
175 }
176
177 static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
178                                       struct snd_pcm_runtime *runtime)
179 {
180         snd_pcm_uframes_t avail;
181
182         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
183                 avail = snd_pcm_playback_avail(runtime);
184         else
185                 avail = snd_pcm_capture_avail(runtime);
186         if (avail > runtime->avail_max)
187                 runtime->avail_max = avail;
188         if (avail >= runtime->stop_threshold) {
189                 if (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING)
190                         snd_pcm_drain_done(substream);
191                 else
192                         xrun(substream);
193                 return -EPIPE;
194         }
195         if (avail >= runtime->control->avail_min)
196                 wake_up(&runtime->sleep);
197         return 0;
198 }
199
200 #define hw_ptr_error(substream, fmt, args...)                           \
201         do {                                                            \
202                 if (xrun_debug(substream, 1)) {                         \
203                         if (printk_ratelimit()) {                       \
204                                 snd_printd("PCM: " fmt, ##args);        \
205                         }                                               \
206                         dump_stack_on_xrun(substream);                  \
207                 }                                                       \
208         } while (0)
209
210 static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
211 {
212         struct snd_pcm_runtime *runtime = substream->runtime;
213         snd_pcm_uframes_t pos;
214         snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_ptr_interrupt, hw_base;
215         snd_pcm_sframes_t hdelta, delta;
216         unsigned long jdelta;
217
218         old_hw_ptr = runtime->status->hw_ptr;
219         pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
220         if (pos == SNDRV_PCM_POS_XRUN) {
221                 xrun(substream);
222                 return -EPIPE;
223         }
224         hw_base = runtime->hw_ptr_base;
225         new_hw_ptr = hw_base + pos;
226         hw_ptr_interrupt = runtime->hw_ptr_interrupt + runtime->period_size;
227         delta = new_hw_ptr - hw_ptr_interrupt;
228         if (hw_ptr_interrupt >= runtime->boundary) {
229                 hw_ptr_interrupt -= runtime->boundary;
230                 if (hw_base < runtime->boundary / 2)
231                         /* hw_base was already lapped; recalc delta */
232                         delta = new_hw_ptr - hw_ptr_interrupt;
233         }
234         if (delta < 0) {
235                 delta += runtime->buffer_size;
236                 if (delta < 0) {
237                         hw_ptr_error(substream, 
238                                      "Unexpected hw_pointer value "
239                                      "(stream=%i, pos=%ld, intr_ptr=%ld)\n",
240                                      substream->stream, (long)pos,
241                                      (long)hw_ptr_interrupt);
242                         /* rebase to interrupt position */
243                         hw_base = new_hw_ptr = hw_ptr_interrupt;
244                         /* align hw_base to buffer_size */
245                         hw_base -= hw_base % runtime->buffer_size;
246                         delta = 0;
247                 } else {
248                         hw_base += runtime->buffer_size;
249                         if (hw_base >= runtime->boundary)
250                                 hw_base = 0;
251                         new_hw_ptr = hw_base + pos;
252                 }
253         }
254
255         /* Do jiffies check only in xrun_debug mode */
256         if (!xrun_debug(substream, 4))
257                 goto no_jiffies_check;
258
259         /* Skip the jiffies check for hardwares with BATCH flag.
260          * Such hardware usually just increases the position at each IRQ,
261          * thus it can't give any strange position.
262          */
263         if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
264                 goto no_jiffies_check;
265         hdelta = new_hw_ptr - old_hw_ptr;
266         if (hdelta < runtime->delay)
267                 goto no_jiffies_check;
268         hdelta -= runtime->delay;
269         jdelta = jiffies - runtime->hw_ptr_jiffies;
270         if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
271                 delta = jdelta /
272                         (((runtime->period_size * HZ) / runtime->rate)
273                                                                 + HZ/100);
274                 hw_ptr_error(substream,
275                              "hw_ptr skipping! [Q] "
276                              "(pos=%ld, delta=%ld, period=%ld, "
277                              "jdelta=%lu/%lu/%lu)\n",
278                              (long)pos, (long)hdelta,
279                              (long)runtime->period_size, jdelta,
280                              ((hdelta * HZ) / runtime->rate), delta);
281                 hw_ptr_interrupt = runtime->hw_ptr_interrupt +
282                                    runtime->period_size * delta;
283                 if (hw_ptr_interrupt >= runtime->boundary)
284                         hw_ptr_interrupt -= runtime->boundary;
285                 /* rebase to interrupt position */
286                 hw_base = new_hw_ptr = hw_ptr_interrupt;
287                 /* align hw_base to buffer_size */
288                 hw_base -= hw_base % runtime->buffer_size;
289                 delta = 0;
290         }
291  no_jiffies_check:
292         if (delta > runtime->period_size + runtime->period_size / 2) {
293                 hw_ptr_error(substream,
294                              "Lost interrupts? "
295                              "(stream=%i, delta=%ld, intr_ptr=%ld)\n",
296                              substream->stream, (long)delta,
297                              (long)hw_ptr_interrupt);
298                 /* rebase hw_ptr_interrupt */
299                 hw_ptr_interrupt =
300                         new_hw_ptr - new_hw_ptr % runtime->period_size;
301         }
302         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
303             runtime->silence_size > 0)
304                 snd_pcm_playback_silence(substream, new_hw_ptr);
305
306         if (runtime->status->hw_ptr == new_hw_ptr)
307                 return 0;
308
309         runtime->hw_ptr_base = hw_base;
310         runtime->status->hw_ptr = new_hw_ptr;
311         runtime->hw_ptr_jiffies = jiffies;
312         runtime->hw_ptr_interrupt = hw_ptr_interrupt;
313         if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
314                 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
315
316         return snd_pcm_update_hw_ptr_post(substream, runtime);
317 }
318
319 /* CAUTION: call it with irq disabled */
320 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
321 {
322         struct snd_pcm_runtime *runtime = substream->runtime;
323         snd_pcm_uframes_t pos;
324         snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
325         snd_pcm_sframes_t delta;
326         unsigned long jdelta;
327
328         old_hw_ptr = runtime->status->hw_ptr;
329         pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
330         if (pos == SNDRV_PCM_POS_XRUN) {
331                 xrun(substream);
332                 return -EPIPE;
333         }
334         hw_base = runtime->hw_ptr_base;
335         new_hw_ptr = hw_base + pos;
336
337         delta = new_hw_ptr - old_hw_ptr;
338         jdelta = jiffies - runtime->hw_ptr_jiffies;
339         if (delta < 0) {
340                 delta += runtime->buffer_size;
341                 if (delta < 0) {
342                         hw_ptr_error(substream, 
343                                      "Unexpected hw_pointer value [2] "
344                                      "(stream=%i, pos=%ld, old_ptr=%ld, jdelta=%li)\n",
345                                      substream->stream, (long)pos,
346                                      (long)old_hw_ptr, jdelta);
347                         return 0;
348                 }
349                 hw_base += runtime->buffer_size;
350                 if (hw_base >= runtime->boundary)
351                         hw_base = 0;
352                 new_hw_ptr = hw_base + pos;
353         }
354         /* Do jiffies check only in xrun_debug mode */
355         if (!xrun_debug(substream, 4))
356                 goto no_jiffies_check;
357         if (delta < runtime->delay)
358                 goto no_jiffies_check;
359         delta -= runtime->delay;
360         if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
361                 hw_ptr_error(substream,
362                              "hw_ptr skipping! "
363                              "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu)\n",
364                              (long)pos, (long)delta,
365                              (long)runtime->period_size, jdelta,
366                              ((delta * HZ) / runtime->rate));
367                 return 0;
368         }
369  no_jiffies_check:
370         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
371             runtime->silence_size > 0)
372                 snd_pcm_playback_silence(substream, new_hw_ptr);
373
374         if (runtime->status->hw_ptr == new_hw_ptr)
375                 return 0;
376
377         runtime->hw_ptr_base = hw_base;
378         runtime->status->hw_ptr = new_hw_ptr;
379         runtime->hw_ptr_jiffies = jiffies;
380         if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
381                 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
382
383         return snd_pcm_update_hw_ptr_post(substream, runtime);
384 }
385
386 /**
387  * snd_pcm_set_ops - set the PCM operators
388  * @pcm: the pcm instance
389  * @direction: stream direction, SNDRV_PCM_STREAM_XXX
390  * @ops: the operator table
391  *
392  * Sets the given PCM operators to the pcm instance.
393  */
394 void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
395 {
396         struct snd_pcm_str *stream = &pcm->streams[direction];
397         struct snd_pcm_substream *substream;
398         
399         for (substream = stream->substream; substream != NULL; substream = substream->next)
400                 substream->ops = ops;
401 }
402
403 EXPORT_SYMBOL(snd_pcm_set_ops);
404
405 /**
406  * snd_pcm_sync - set the PCM sync id
407  * @substream: the pcm substream
408  *
409  * Sets the PCM sync identifier for the card.
410  */
411 void snd_pcm_set_sync(struct snd_pcm_substream *substream)
412 {
413         struct snd_pcm_runtime *runtime = substream->runtime;
414         
415         runtime->sync.id32[0] = substream->pcm->card->number;
416         runtime->sync.id32[1] = -1;
417         runtime->sync.id32[2] = -1;
418         runtime->sync.id32[3] = -1;
419 }
420
421 EXPORT_SYMBOL(snd_pcm_set_sync);
422
423 /*
424  *  Standard ioctl routine
425  */
426
427 static inline unsigned int div32(unsigned int a, unsigned int b, 
428                                  unsigned int *r)
429 {
430         if (b == 0) {
431                 *r = 0;
432                 return UINT_MAX;
433         }
434         *r = a % b;
435         return a / b;
436 }
437
438 static inline unsigned int div_down(unsigned int a, unsigned int b)
439 {
440         if (b == 0)
441                 return UINT_MAX;
442         return a / b;
443 }
444
445 static inline unsigned int div_up(unsigned int a, unsigned int b)
446 {
447         unsigned int r;
448         unsigned int q;
449         if (b == 0)
450                 return UINT_MAX;
451         q = div32(a, b, &r);
452         if (r)
453                 ++q;
454         return q;
455 }
456
457 static inline unsigned int mul(unsigned int a, unsigned int b)
458 {
459         if (a == 0)
460                 return 0;
461         if (div_down(UINT_MAX, a) < b)
462                 return UINT_MAX;
463         return a * b;
464 }
465
466 static inline unsigned int muldiv32(unsigned int a, unsigned int b,
467                                     unsigned int c, unsigned int *r)
468 {
469         u_int64_t n = (u_int64_t) a * b;
470         if (c == 0) {
471                 snd_BUG_ON(!n);
472                 *r = 0;
473                 return UINT_MAX;
474         }
475         div64_32(&n, c, r);
476         if (n >= UINT_MAX) {
477                 *r = 0;
478                 return UINT_MAX;
479         }
480         return n;
481 }
482
483 /**
484  * snd_interval_refine - refine the interval value of configurator
485  * @i: the interval value to refine
486  * @v: the interval value to refer to
487  *
488  * Refines the interval value with the reference value.
489  * The interval is changed to the range satisfying both intervals.
490  * The interval status (min, max, integer, etc.) are evaluated.
491  *
492  * Returns non-zero if the value is changed, zero if not changed.
493  */
494 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
495 {
496         int changed = 0;
497         if (snd_BUG_ON(snd_interval_empty(i)))
498                 return -EINVAL;
499         if (i->min < v->min) {
500                 i->min = v->min;
501                 i->openmin = v->openmin;
502                 changed = 1;
503         } else if (i->min == v->min && !i->openmin && v->openmin) {
504                 i->openmin = 1;
505                 changed = 1;
506         }
507         if (i->max > v->max) {
508                 i->max = v->max;
509                 i->openmax = v->openmax;
510                 changed = 1;
511         } else if (i->max == v->max && !i->openmax && v->openmax) {
512                 i->openmax = 1;
513                 changed = 1;
514         }
515         if (!i->integer && v->integer) {
516                 i->integer = 1;
517                 changed = 1;
518         }
519         if (i->integer) {
520                 if (i->openmin) {
521                         i->min++;
522                         i->openmin = 0;
523                 }
524                 if (i->openmax) {
525                         i->max--;
526                         i->openmax = 0;
527                 }
528         } else if (!i->openmin && !i->openmax && i->min == i->max)
529                 i->integer = 1;
530         if (snd_interval_checkempty(i)) {
531                 snd_interval_none(i);
532                 return -EINVAL;
533         }
534         return changed;
535 }
536
537 EXPORT_SYMBOL(snd_interval_refine);
538
539 static int snd_interval_refine_first(struct snd_interval *i)
540 {
541         if (snd_BUG_ON(snd_interval_empty(i)))
542                 return -EINVAL;
543         if (snd_interval_single(i))
544                 return 0;
545         i->max = i->min;
546         i->openmax = i->openmin;
547         if (i->openmax)
548                 i->max++;
549         return 1;
550 }
551
552 static int snd_interval_refine_last(struct snd_interval *i)
553 {
554         if (snd_BUG_ON(snd_interval_empty(i)))
555                 return -EINVAL;
556         if (snd_interval_single(i))
557                 return 0;
558         i->min = i->max;
559         i->openmin = i->openmax;
560         if (i->openmin)
561                 i->min--;
562         return 1;
563 }
564
565 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
566 {
567         if (a->empty || b->empty) {
568                 snd_interval_none(c);
569                 return;
570         }
571         c->empty = 0;
572         c->min = mul(a->min, b->min);
573         c->openmin = (a->openmin || b->openmin);
574         c->max = mul(a->max,  b->max);
575         c->openmax = (a->openmax || b->openmax);
576         c->integer = (a->integer && b->integer);
577 }
578
579 /**
580  * snd_interval_div - refine the interval value with division
581  * @a: dividend
582  * @b: divisor
583  * @c: quotient
584  *
585  * c = a / b
586  *
587  * Returns non-zero if the value is changed, zero if not changed.
588  */
589 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
590 {
591         unsigned int r;
592         if (a->empty || b->empty) {
593                 snd_interval_none(c);
594                 return;
595         }
596         c->empty = 0;
597         c->min = div32(a->min, b->max, &r);
598         c->openmin = (r || a->openmin || b->openmax);
599         if (b->min > 0) {
600                 c->max = div32(a->max, b->min, &r);
601                 if (r) {
602                         c->max++;
603                         c->openmax = 1;
604                 } else
605                         c->openmax = (a->openmax || b->openmin);
606         } else {
607                 c->max = UINT_MAX;
608                 c->openmax = 0;
609         }
610         c->integer = 0;
611 }
612
613 /**
614  * snd_interval_muldivk - refine the interval value
615  * @a: dividend 1
616  * @b: dividend 2
617  * @k: divisor (as integer)
618  * @c: result
619   *
620  * c = a * b / k
621  *
622  * Returns non-zero if the value is changed, zero if not changed.
623  */
624 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
625                       unsigned int k, struct snd_interval *c)
626 {
627         unsigned int r;
628         if (a->empty || b->empty) {
629                 snd_interval_none(c);
630                 return;
631         }
632         c->empty = 0;
633         c->min = muldiv32(a->min, b->min, k, &r);
634         c->openmin = (r || a->openmin || b->openmin);
635         c->max = muldiv32(a->max, b->max, k, &r);
636         if (r) {
637                 c->max++;
638                 c->openmax = 1;
639         } else
640                 c->openmax = (a->openmax || b->openmax);
641         c->integer = 0;
642 }
643
644 /**
645  * snd_interval_mulkdiv - refine the interval value
646  * @a: dividend 1
647  * @k: dividend 2 (as integer)
648  * @b: divisor
649  * @c: result
650  *
651  * c = a * k / b
652  *
653  * Returns non-zero if the value is changed, zero if not changed.
654  */
655 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
656                       const struct snd_interval *b, struct snd_interval *c)
657 {
658         unsigned int r;
659         if (a->empty || b->empty) {
660                 snd_interval_none(c);
661                 return;
662         }
663         c->empty = 0;
664         c->min = muldiv32(a->min, k, b->max, &r);
665         c->openmin = (r || a->openmin || b->openmax);
666         if (b->min > 0) {
667                 c->max = muldiv32(a->max, k, b->min, &r);
668                 if (r) {
669                         c->max++;
670                         c->openmax = 1;
671                 } else
672                         c->openmax = (a->openmax || b->openmin);
673         } else {
674                 c->max = UINT_MAX;
675                 c->openmax = 0;
676         }
677         c->integer = 0;
678 }
679
680 /* ---- */
681
682
683 /**
684  * snd_interval_ratnum - refine the interval value
685  * @i: interval to refine
686  * @rats_count: number of ratnum_t 
687  * @rats: ratnum_t array
688  * @nump: pointer to store the resultant numerator
689  * @denp: pointer to store the resultant denominator
690  *
691  * Returns non-zero if the value is changed, zero if not changed.
692  */
693 int snd_interval_ratnum(struct snd_interval *i,
694                         unsigned int rats_count, struct snd_ratnum *rats,
695                         unsigned int *nump, unsigned int *denp)
696 {
697         unsigned int best_num, best_diff, best_den;
698         unsigned int k;
699         struct snd_interval t;
700         int err;
701
702         best_num = best_den = best_diff = 0;
703         for (k = 0; k < rats_count; ++k) {
704                 unsigned int num = rats[k].num;
705                 unsigned int den;
706                 unsigned int q = i->min;
707                 int diff;
708                 if (q == 0)
709                         q = 1;
710                 den = div_down(num, q);
711                 if (den < rats[k].den_min)
712                         continue;
713                 if (den > rats[k].den_max)
714                         den = rats[k].den_max;
715                 else {
716                         unsigned int r;
717                         r = (den - rats[k].den_min) % rats[k].den_step;
718                         if (r != 0)
719                                 den -= r;
720                 }
721                 diff = num - q * den;
722                 if (best_num == 0 ||
723                     diff * best_den < best_diff * den) {
724                         best_diff = diff;
725                         best_den = den;
726                         best_num = num;
727                 }
728         }
729         if (best_den == 0) {
730                 i->empty = 1;
731                 return -EINVAL;
732         }
733         t.min = div_down(best_num, best_den);
734         t.openmin = !!(best_num % best_den);
735         
736         best_num = best_den = best_diff = 0;
737         for (k = 0; k < rats_count; ++k) {
738                 unsigned int num = rats[k].num;
739                 unsigned int den;
740                 unsigned int q = i->max;
741                 int diff;
742                 if (q == 0) {
743                         i->empty = 1;
744                         return -EINVAL;
745                 }
746                 den = div_up(num, q);
747                 if (den > rats[k].den_max)
748                         continue;
749                 if (den < rats[k].den_min)
750                         den = rats[k].den_min;
751                 else {
752                         unsigned int r;
753                         r = (den - rats[k].den_min) % rats[k].den_step;
754                         if (r != 0)
755                                 den += rats[k].den_step - r;
756                 }
757                 diff = q * den - num;
758                 if (best_num == 0 ||
759                     diff * best_den < best_diff * den) {
760                         best_diff = diff;
761                         best_den = den;
762                         best_num = num;
763                 }
764         }
765         if (best_den == 0) {
766                 i->empty = 1;
767                 return -EINVAL;
768         }
769         t.max = div_up(best_num, best_den);
770         t.openmax = !!(best_num % best_den);
771         t.integer = 0;
772         err = snd_interval_refine(i, &t);
773         if (err < 0)
774                 return err;
775
776         if (snd_interval_single(i)) {
777                 if (nump)
778                         *nump = best_num;
779                 if (denp)
780                         *denp = best_den;
781         }
782         return err;
783 }
784
785 EXPORT_SYMBOL(snd_interval_ratnum);
786
787 /**
788  * snd_interval_ratden - refine the interval value
789  * @i: interval to refine
790  * @rats_count: number of struct ratden
791  * @rats: struct ratden array
792  * @nump: pointer to store the resultant numerator
793  * @denp: pointer to store the resultant denominator
794  *
795  * Returns non-zero if the value is changed, zero if not changed.
796  */
797 static int snd_interval_ratden(struct snd_interval *i,
798                                unsigned int rats_count, struct snd_ratden *rats,
799                                unsigned int *nump, unsigned int *denp)
800 {
801         unsigned int best_num, best_diff, best_den;
802         unsigned int k;
803         struct snd_interval t;
804         int err;
805
806         best_num = best_den = best_diff = 0;
807         for (k = 0; k < rats_count; ++k) {
808                 unsigned int num;
809                 unsigned int den = rats[k].den;
810                 unsigned int q = i->min;
811                 int diff;
812                 num = mul(q, den);
813                 if (num > rats[k].num_max)
814                         continue;
815                 if (num < rats[k].num_min)
816                         num = rats[k].num_max;
817                 else {
818                         unsigned int r;
819                         r = (num - rats[k].num_min) % rats[k].num_step;
820                         if (r != 0)
821                                 num += rats[k].num_step - r;
822                 }
823                 diff = num - q * den;
824                 if (best_num == 0 ||
825                     diff * best_den < best_diff * den) {
826                         best_diff = diff;
827                         best_den = den;
828                         best_num = num;
829                 }
830         }
831         if (best_den == 0) {
832                 i->empty = 1;
833                 return -EINVAL;
834         }
835         t.min = div_down(best_num, best_den);
836         t.openmin = !!(best_num % best_den);
837         
838         best_num = best_den = best_diff = 0;
839         for (k = 0; k < rats_count; ++k) {
840                 unsigned int num;
841                 unsigned int den = rats[k].den;
842                 unsigned int q = i->max;
843                 int diff;
844                 num = mul(q, den);
845                 if (num < rats[k].num_min)
846                         continue;
847                 if (num > rats[k].num_max)
848                         num = rats[k].num_max;
849                 else {
850                         unsigned int r;
851                         r = (num - rats[k].num_min) % rats[k].num_step;
852                         if (r != 0)
853                                 num -= r;
854                 }
855                 diff = q * den - num;
856                 if (best_num == 0 ||
857                     diff * best_den < best_diff * den) {
858                         best_diff = diff;
859                         best_den = den;
860                         best_num = num;
861                 }
862         }
863         if (best_den == 0) {
864                 i->empty = 1;
865                 return -EINVAL;
866         }
867         t.max = div_up(best_num, best_den);
868         t.openmax = !!(best_num % best_den);
869         t.integer = 0;
870         err = snd_interval_refine(i, &t);
871         if (err < 0)
872                 return err;
873
874         if (snd_interval_single(i)) {
875                 if (nump)
876                         *nump = best_num;
877                 if (denp)
878                         *denp = best_den;
879         }
880         return err;
881 }
882
883 /**
884  * snd_interval_list - refine the interval value from the list
885  * @i: the interval value to refine
886  * @count: the number of elements in the list
887  * @list: the value list
888  * @mask: the bit-mask to evaluate
889  *
890  * Refines the interval value from the list.
891  * When mask is non-zero, only the elements corresponding to bit 1 are
892  * evaluated.
893  *
894  * Returns non-zero if the value is changed, zero if not changed.
895  */
896 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask)
897 {
898         unsigned int k;
899         int changed = 0;
900
901         if (!count) {
902                 i->empty = 1;
903                 return -EINVAL;
904         }
905         for (k = 0; k < count; k++) {
906                 if (mask && !(mask & (1 << k)))
907                         continue;
908                 if (i->min == list[k] && !i->openmin)
909                         goto _l1;
910                 if (i->min < list[k]) {
911                         i->min = list[k];
912                         i->openmin = 0;
913                         changed = 1;
914                         goto _l1;
915                 }
916         }
917         i->empty = 1;
918         return -EINVAL;
919  _l1:
920         for (k = count; k-- > 0;) {
921                 if (mask && !(mask & (1 << k)))
922                         continue;
923                 if (i->max == list[k] && !i->openmax)
924                         goto _l2;
925                 if (i->max > list[k]) {
926                         i->max = list[k];
927                         i->openmax = 0;
928                         changed = 1;
929                         goto _l2;
930                 }
931         }
932         i->empty = 1;
933         return -EINVAL;
934  _l2:
935         if (snd_interval_checkempty(i)) {
936                 i->empty = 1;
937                 return -EINVAL;
938         }
939         return changed;
940 }
941
942 EXPORT_SYMBOL(snd_interval_list);
943
944 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
945 {
946         unsigned int n;
947         int changed = 0;
948         n = (i->min - min) % step;
949         if (n != 0 || i->openmin) {
950                 i->min += step - n;
951                 changed = 1;
952         }
953         n = (i->max - min) % step;
954         if (n != 0 || i->openmax) {
955                 i->max -= n;
956                 changed = 1;
957         }
958         if (snd_interval_checkempty(i)) {
959                 i->empty = 1;
960                 return -EINVAL;
961         }
962         return changed;
963 }
964
965 /* Info constraints helpers */
966
967 /**
968  * snd_pcm_hw_rule_add - add the hw-constraint rule
969  * @runtime: the pcm runtime instance
970  * @cond: condition bits
971  * @var: the variable to evaluate
972  * @func: the evaluation function
973  * @private: the private data pointer passed to function
974  * @dep: the dependent variables
975  *
976  * Returns zero if successful, or a negative error code on failure.
977  */
978 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
979                         int var,
980                         snd_pcm_hw_rule_func_t func, void *private,
981                         int dep, ...)
982 {
983         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
984         struct snd_pcm_hw_rule *c;
985         unsigned int k;
986         va_list args;
987         va_start(args, dep);
988         if (constrs->rules_num >= constrs->rules_all) {
989                 struct snd_pcm_hw_rule *new;
990                 unsigned int new_rules = constrs->rules_all + 16;
991                 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
992                 if (!new)
993                         return -ENOMEM;
994                 if (constrs->rules) {
995                         memcpy(new, constrs->rules,
996                                constrs->rules_num * sizeof(*c));
997                         kfree(constrs->rules);
998                 }
999                 constrs->rules = new;
1000                 constrs->rules_all = new_rules;
1001         }
1002         c = &constrs->rules[constrs->rules_num];
1003         c->cond = cond;
1004         c->func = func;
1005         c->var = var;
1006         c->private = private;
1007         k = 0;
1008         while (1) {
1009                 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps)))
1010                         return -EINVAL;
1011                 c->deps[k++] = dep;
1012                 if (dep < 0)
1013                         break;
1014                 dep = va_arg(args, int);
1015         }
1016         constrs->rules_num++;
1017         va_end(args);
1018         return 0;
1019 }                                   
1020
1021 EXPORT_SYMBOL(snd_pcm_hw_rule_add);
1022
1023 /**
1024  * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
1025  * @runtime: PCM runtime instance
1026  * @var: hw_params variable to apply the mask
1027  * @mask: the bitmap mask
1028  *
1029  * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
1030  */
1031 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1032                                u_int32_t mask)
1033 {
1034         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1035         struct snd_mask *maskp = constrs_mask(constrs, var);
1036         *maskp->bits &= mask;
1037         memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
1038         if (*maskp->bits == 0)
1039                 return -EINVAL;
1040         return 0;
1041 }
1042
1043 /**
1044  * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
1045  * @runtime: PCM runtime instance
1046  * @var: hw_params variable to apply the mask
1047  * @mask: the 64bit bitmap mask
1048  *
1049  * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
1050  */
1051 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1052                                  u_int64_t mask)
1053 {
1054         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1055         struct snd_mask *maskp = constrs_mask(constrs, var);
1056         maskp->bits[0] &= (u_int32_t)mask;
1057         maskp->bits[1] &= (u_int32_t)(mask >> 32);
1058         memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
1059         if (! maskp->bits[0] && ! maskp->bits[1])
1060                 return -EINVAL;
1061         return 0;
1062 }
1063
1064 /**
1065  * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
1066  * @runtime: PCM runtime instance
1067  * @var: hw_params variable to apply the integer constraint
1068  *
1069  * Apply the constraint of integer to an interval parameter.
1070  */
1071 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
1072 {
1073         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1074         return snd_interval_setinteger(constrs_interval(constrs, var));
1075 }
1076
1077 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
1078
1079 /**
1080  * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
1081  * @runtime: PCM runtime instance
1082  * @var: hw_params variable to apply the range
1083  * @min: the minimal value
1084  * @max: the maximal value
1085  * 
1086  * Apply the min/max range constraint to an interval parameter.
1087  */
1088 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1089                                  unsigned int min, unsigned int max)
1090 {
1091         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1092         struct snd_interval t;
1093         t.min = min;
1094         t.max = max;
1095         t.openmin = t.openmax = 0;
1096         t.integer = 0;
1097         return snd_interval_refine(constrs_interval(constrs, var), &t);
1098 }
1099
1100 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
1101
1102 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
1103                                 struct snd_pcm_hw_rule *rule)
1104 {
1105         struct snd_pcm_hw_constraint_list *list = rule->private;
1106         return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
1107 }               
1108
1109
1110 /**
1111  * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
1112  * @runtime: PCM runtime instance
1113  * @cond: condition bits
1114  * @var: hw_params variable to apply the list constraint
1115  * @l: list
1116  * 
1117  * Apply the list of constraints to an interval parameter.
1118  */
1119 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
1120                                unsigned int cond,
1121                                snd_pcm_hw_param_t var,
1122                                struct snd_pcm_hw_constraint_list *l)
1123 {
1124         return snd_pcm_hw_rule_add(runtime, cond, var,
1125                                    snd_pcm_hw_rule_list, l,
1126                                    var, -1);
1127 }
1128
1129 EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
1130
1131 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
1132                                    struct snd_pcm_hw_rule *rule)
1133 {
1134         struct snd_pcm_hw_constraint_ratnums *r = rule->private;
1135         unsigned int num = 0, den = 0;
1136         int err;
1137         err = snd_interval_ratnum(hw_param_interval(params, rule->var),
1138                                   r->nrats, r->rats, &num, &den);
1139         if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1140                 params->rate_num = num;
1141                 params->rate_den = den;
1142         }
1143         return err;
1144 }
1145
1146 /**
1147  * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
1148  * @runtime: PCM runtime instance
1149  * @cond: condition bits
1150  * @var: hw_params variable to apply the ratnums constraint
1151  * @r: struct snd_ratnums constriants
1152  */
1153 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 
1154                                   unsigned int cond,
1155                                   snd_pcm_hw_param_t var,
1156                                   struct snd_pcm_hw_constraint_ratnums *r)
1157 {
1158         return snd_pcm_hw_rule_add(runtime, cond, var,
1159                                    snd_pcm_hw_rule_ratnums, r,
1160                                    var, -1);
1161 }
1162
1163 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
1164
1165 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
1166                                    struct snd_pcm_hw_rule *rule)
1167 {
1168         struct snd_pcm_hw_constraint_ratdens *r = rule->private;
1169         unsigned int num = 0, den = 0;
1170         int err = snd_interval_ratden(hw_param_interval(params, rule->var),
1171                                   r->nrats, r->rats, &num, &den);
1172         if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1173                 params->rate_num = num;
1174                 params->rate_den = den;
1175         }
1176         return err;
1177 }
1178
1179 /**
1180  * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
1181  * @runtime: PCM runtime instance
1182  * @cond: condition bits
1183  * @var: hw_params variable to apply the ratdens constraint
1184  * @r: struct snd_ratdens constriants
1185  */
1186 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 
1187                                   unsigned int cond,
1188                                   snd_pcm_hw_param_t var,
1189                                   struct snd_pcm_hw_constraint_ratdens *r)
1190 {
1191         return snd_pcm_hw_rule_add(runtime, cond, var,
1192                                    snd_pcm_hw_rule_ratdens, r,
1193                                    var, -1);
1194 }
1195
1196 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
1197
1198 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
1199                                   struct snd_pcm_hw_rule *rule)
1200 {
1201         unsigned int l = (unsigned long) rule->private;
1202         int width = l & 0xffff;
1203         unsigned int msbits = l >> 16;
1204         struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
1205         if (snd_interval_single(i) && snd_interval_value(i) == width)
1206                 params->msbits = msbits;
1207         return 0;
1208 }
1209
1210 /**
1211  * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
1212  * @runtime: PCM runtime instance
1213  * @cond: condition bits
1214  * @width: sample bits width
1215  * @msbits: msbits width
1216  */
1217 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
1218                                  unsigned int cond,
1219                                  unsigned int width,
1220                                  unsigned int msbits)
1221 {
1222         unsigned long l = (msbits << 16) | width;
1223         return snd_pcm_hw_rule_add(runtime, cond, -1,
1224                                     snd_pcm_hw_rule_msbits,
1225                                     (void*) l,
1226                                     SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1227 }
1228
1229 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
1230
1231 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
1232                                 struct snd_pcm_hw_rule *rule)
1233 {
1234         unsigned long step = (unsigned long) rule->private;
1235         return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
1236 }
1237
1238 /**
1239  * snd_pcm_hw_constraint_step - add a hw constraint step rule
1240  * @runtime: PCM runtime instance
1241  * @cond: condition bits
1242  * @var: hw_params variable to apply the step constraint
1243  * @step: step size
1244  */
1245 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
1246                                unsigned int cond,
1247                                snd_pcm_hw_param_t var,
1248                                unsigned long step)
1249 {
1250         return snd_pcm_hw_rule_add(runtime, cond, var, 
1251                                    snd_pcm_hw_rule_step, (void *) step,
1252                                    var, -1);
1253 }
1254
1255 EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
1256
1257 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
1258 {
1259         static unsigned int pow2_sizes[] = {
1260                 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1261                 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1262                 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1263                 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1264         };
1265         return snd_interval_list(hw_param_interval(params, rule->var),
1266                                  ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
1267 }               
1268
1269 /**
1270  * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
1271  * @runtime: PCM runtime instance
1272  * @cond: condition bits
1273  * @var: hw_params variable to apply the power-of-2 constraint
1274  */
1275 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
1276                                unsigned int cond,
1277                                snd_pcm_hw_param_t var)
1278 {
1279         return snd_pcm_hw_rule_add(runtime, cond, var, 
1280                                    snd_pcm_hw_rule_pow2, NULL,
1281                                    var, -1);
1282 }
1283
1284 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
1285
1286 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
1287                                   snd_pcm_hw_param_t var)
1288 {
1289         if (hw_is_mask(var)) {
1290                 snd_mask_any(hw_param_mask(params, var));
1291                 params->cmask |= 1 << var;
1292                 params->rmask |= 1 << var;
1293                 return;
1294         }
1295         if (hw_is_interval(var)) {
1296                 snd_interval_any(hw_param_interval(params, var));
1297                 params->cmask |= 1 << var;
1298                 params->rmask |= 1 << var;
1299                 return;
1300         }
1301         snd_BUG();
1302 }
1303
1304 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
1305 {
1306         unsigned int k;
1307         memset(params, 0, sizeof(*params));
1308         for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
1309                 _snd_pcm_hw_param_any(params, k);
1310         for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
1311                 _snd_pcm_hw_param_any(params, k);
1312         params->info = ~0U;
1313 }
1314
1315 EXPORT_SYMBOL(_snd_pcm_hw_params_any);
1316
1317 /**
1318  * snd_pcm_hw_param_value - return @params field @var value
1319  * @params: the hw_params instance
1320  * @var: parameter to retrieve
1321  * @dir: pointer to the direction (-1,0,1) or %NULL
1322  *
1323  * Return the value for field @var if it's fixed in configuration space
1324  * defined by @params. Return -%EINVAL otherwise.
1325  */
1326 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
1327                            snd_pcm_hw_param_t var, int *dir)
1328 {
1329         if (hw_is_mask(var)) {
1330                 const struct snd_mask *mask = hw_param_mask_c(params, var);
1331                 if (!snd_mask_single(mask))
1332                         return -EINVAL;
1333                 if (dir)
1334                         *dir = 0;
1335                 return snd_mask_value(mask);
1336         }
1337         if (hw_is_interval(var)) {
1338                 const struct snd_interval *i = hw_param_interval_c(params, var);
1339                 if (!snd_interval_single(i))
1340                         return -EINVAL;
1341                 if (dir)
1342                         *dir = i->openmin;
1343                 return snd_interval_value(i);
1344         }
1345         return -EINVAL;
1346 }
1347
1348 EXPORT_SYMBOL(snd_pcm_hw_param_value);
1349
1350 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
1351                                 snd_pcm_hw_param_t var)
1352 {
1353         if (hw_is_mask(var)) {
1354                 snd_mask_none(hw_param_mask(params, var));
1355                 params->cmask |= 1 << var;
1356                 params->rmask |= 1 << var;
1357         } else if (hw_is_interval(var)) {
1358                 snd_interval_none(hw_param_interval(params, var));
1359                 params->cmask |= 1 << var;
1360                 params->rmask |= 1 << var;
1361         } else {
1362                 snd_BUG();
1363         }
1364 }
1365
1366 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
1367
1368 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
1369                                    snd_pcm_hw_param_t var)
1370 {
1371         int changed;
1372         if (hw_is_mask(var))
1373                 changed = snd_mask_refine_first(hw_param_mask(params, var));
1374         else if (hw_is_interval(var))
1375                 changed = snd_interval_refine_first(hw_param_interval(params, var));
1376         else
1377                 return -EINVAL;
1378         if (changed) {
1379                 params->cmask |= 1 << var;
1380                 params->rmask |= 1 << var;
1381         }
1382         return changed;
1383 }
1384
1385
1386 /**
1387  * snd_pcm_hw_param_first - refine config space and return minimum value
1388  * @pcm: PCM instance
1389  * @params: the hw_params instance
1390  * @var: parameter to retrieve
1391  * @dir: pointer to the direction (-1,0,1) or %NULL
1392  *
1393  * Inside configuration space defined by @params remove from @var all
1394  * values > minimum. Reduce configuration space accordingly.
1395  * Return the minimum.
1396  */
1397 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
1398                            struct snd_pcm_hw_params *params, 
1399                            snd_pcm_hw_param_t var, int *dir)
1400 {
1401         int changed = _snd_pcm_hw_param_first(params, var);
1402         if (changed < 0)
1403                 return changed;
1404         if (params->rmask) {
1405                 int err = snd_pcm_hw_refine(pcm, params);
1406                 if (snd_BUG_ON(err < 0))
1407                         return err;
1408         }
1409         return snd_pcm_hw_param_value(params, var, dir);
1410 }
1411
1412 EXPORT_SYMBOL(snd_pcm_hw_param_first);
1413
1414 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
1415                                   snd_pcm_hw_param_t var)
1416 {
1417         int changed;
1418         if (hw_is_mask(var))
1419                 changed = snd_mask_refine_last(hw_param_mask(params, var));
1420         else if (hw_is_interval(var))
1421                 changed = snd_interval_refine_last(hw_param_interval(params, var));
1422         else
1423                 return -EINVAL;
1424         if (changed) {
1425                 params->cmask |= 1 << var;
1426                 params->rmask |= 1 << var;
1427         }
1428         return changed;
1429 }
1430
1431
1432 /**
1433  * snd_pcm_hw_param_last - refine config space and return maximum value
1434  * @pcm: PCM instance
1435  * @params: the hw_params instance
1436  * @var: parameter to retrieve
1437  * @dir: pointer to the direction (-1,0,1) or %NULL
1438  *
1439  * Inside configuration space defined by @params remove from @var all
1440  * values < maximum. Reduce configuration space accordingly.
1441  * Return the maximum.
1442  */
1443 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
1444                           struct snd_pcm_hw_params *params,
1445                           snd_pcm_hw_param_t var, int *dir)
1446 {
1447         int changed = _snd_pcm_hw_param_last(params, var);
1448         if (changed < 0)
1449                 return changed;
1450         if (params->rmask) {
1451                 int err = snd_pcm_hw_refine(pcm, params);
1452                 if (snd_BUG_ON(err < 0))
1453                         return err;
1454         }
1455         return snd_pcm_hw_param_value(params, var, dir);
1456 }
1457
1458 EXPORT_SYMBOL(snd_pcm_hw_param_last);
1459
1460 /**
1461  * snd_pcm_hw_param_choose - choose a configuration defined by @params
1462  * @pcm: PCM instance
1463  * @params: the hw_params instance
1464  *
1465  * Choose one configuration from configuration space defined by @params.
1466  * The configuration chosen is that obtained fixing in this order:
1467  * first access, first format, first subformat, min channels,
1468  * min rate, min period time, max buffer size, min tick time
1469  */
1470 int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1471                              struct snd_pcm_hw_params *params)
1472 {
1473         static int vars[] = {
1474                 SNDRV_PCM_HW_PARAM_ACCESS,
1475                 SNDRV_PCM_HW_PARAM_FORMAT,
1476                 SNDRV_PCM_HW_PARAM_SUBFORMAT,
1477                 SNDRV_PCM_HW_PARAM_CHANNELS,
1478                 SNDRV_PCM_HW_PARAM_RATE,
1479                 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1480                 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1481                 SNDRV_PCM_HW_PARAM_TICK_TIME,
1482                 -1
1483         };
1484         int err, *v;
1485
1486         for (v = vars; *v != -1; v++) {
1487                 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
1488                         err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1489                 else
1490                         err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
1491                 if (snd_BUG_ON(err < 0))
1492                         return err;
1493         }
1494         return 0;
1495 }
1496
1497 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
1498                                    void *arg)
1499 {
1500         struct snd_pcm_runtime *runtime = substream->runtime;
1501         unsigned long flags;
1502         snd_pcm_stream_lock_irqsave(substream, flags);
1503         if (snd_pcm_running(substream) &&
1504             snd_pcm_update_hw_ptr(substream) >= 0)
1505                 runtime->status->hw_ptr %= runtime->buffer_size;
1506         else
1507                 runtime->status->hw_ptr = 0;
1508         snd_pcm_stream_unlock_irqrestore(substream, flags);
1509         return 0;
1510 }
1511
1512 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
1513                                           void *arg)
1514 {
1515         struct snd_pcm_channel_info *info = arg;
1516         struct snd_pcm_runtime *runtime = substream->runtime;
1517         int width;
1518         if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
1519                 info->offset = -1;
1520                 return 0;
1521         }
1522         width = snd_pcm_format_physical_width(runtime->format);
1523         if (width < 0)
1524                 return width;
1525         info->offset = 0;
1526         switch (runtime->access) {
1527         case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
1528         case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
1529                 info->first = info->channel * width;
1530                 info->step = runtime->channels * width;
1531                 break;
1532         case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
1533         case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
1534         {
1535                 size_t size = runtime->dma_bytes / runtime->channels;
1536                 info->first = info->channel * size * 8;
1537                 info->step = width;
1538                 break;
1539         }
1540         default:
1541                 snd_BUG();
1542                 break;
1543         }
1544         return 0;
1545 }
1546
1547 static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
1548                                        void *arg)
1549 {
1550         struct snd_pcm_hw_params *params = arg;
1551         snd_pcm_format_t format;
1552         int channels, width;
1553
1554         params->fifo_size = substream->runtime->hw.fifo_size;
1555         if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
1556                 format = params_format(params);
1557                 channels = params_channels(params);
1558                 width = snd_pcm_format_physical_width(format);
1559                 params->fifo_size /= width * channels;
1560         }
1561         return 0;
1562 }
1563
1564 /**
1565  * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1566  * @substream: the pcm substream instance
1567  * @cmd: ioctl command
1568  * @arg: ioctl argument
1569  *
1570  * Processes the generic ioctl commands for PCM.
1571  * Can be passed as the ioctl callback for PCM ops.
1572  *
1573  * Returns zero if successful, or a negative error code on failure.
1574  */
1575 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
1576                       unsigned int cmd, void *arg)
1577 {
1578         switch (cmd) {
1579         case SNDRV_PCM_IOCTL1_INFO:
1580                 return 0;
1581         case SNDRV_PCM_IOCTL1_RESET:
1582                 return snd_pcm_lib_ioctl_reset(substream, arg);
1583         case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
1584                 return snd_pcm_lib_ioctl_channel_info(substream, arg);
1585         case SNDRV_PCM_IOCTL1_FIFO_SIZE:
1586                 return snd_pcm_lib_ioctl_fifo_size(substream, arg);
1587         }
1588         return -ENXIO;
1589 }
1590
1591 EXPORT_SYMBOL(snd_pcm_lib_ioctl);
1592
1593 /**
1594  * snd_pcm_period_elapsed - update the pcm status for the next period
1595  * @substream: the pcm substream instance
1596  *
1597  * This function is called from the interrupt handler when the
1598  * PCM has processed the period size.  It will update the current
1599  * pointer, wake up sleepers, etc.
1600  *
1601  * Even if more than one periods have elapsed since the last call, you
1602  * have to call this only once.
1603  */
1604 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
1605 {
1606         struct snd_pcm_runtime *runtime;
1607         unsigned long flags;
1608
1609         if (PCM_RUNTIME_CHECK(substream))
1610                 return;
1611         runtime = substream->runtime;
1612
1613         if (runtime->transfer_ack_begin)
1614                 runtime->transfer_ack_begin(substream);
1615
1616         snd_pcm_stream_lock_irqsave(substream, flags);
1617         if (!snd_pcm_running(substream) ||
1618             snd_pcm_update_hw_ptr_interrupt(substream) < 0)
1619                 goto _end;
1620
1621         if (substream->timer_running)
1622                 snd_timer_interrupt(substream->timer, 1);
1623  _end:
1624         snd_pcm_stream_unlock_irqrestore(substream, flags);
1625         if (runtime->transfer_ack_end)
1626                 runtime->transfer_ack_end(substream);
1627         kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
1628 }
1629
1630 EXPORT_SYMBOL(snd_pcm_period_elapsed);
1631
1632 /*
1633  * Wait until avail_min data becomes available
1634  * Returns a negative error code if any error occurs during operation.
1635  * The available space is stored on availp.  When err = 0 and avail = 0
1636  * on the capture stream, it indicates the stream is in DRAINING state.
1637  */
1638 static int wait_for_avail_min(struct snd_pcm_substream *substream,
1639                               snd_pcm_uframes_t *availp)
1640 {
1641         struct snd_pcm_runtime *runtime = substream->runtime;
1642         int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
1643         wait_queue_t wait;
1644         int err = 0;
1645         snd_pcm_uframes_t avail = 0;
1646         long tout;
1647
1648         init_waitqueue_entry(&wait, current);
1649         add_wait_queue(&runtime->sleep, &wait);
1650         for (;;) {
1651                 if (signal_pending(current)) {
1652                         err = -ERESTARTSYS;
1653                         break;
1654                 }
1655                 set_current_state(TASK_INTERRUPTIBLE);
1656                 snd_pcm_stream_unlock_irq(substream);
1657                 tout = schedule_timeout(msecs_to_jiffies(10000));
1658                 snd_pcm_stream_lock_irq(substream);
1659                 switch (runtime->status->state) {
1660                 case SNDRV_PCM_STATE_SUSPENDED:
1661                         err = -ESTRPIPE;
1662                         goto _endloop;
1663                 case SNDRV_PCM_STATE_XRUN:
1664                         err = -EPIPE;
1665                         goto _endloop;
1666                 case SNDRV_PCM_STATE_DRAINING:
1667                         if (is_playback)
1668                                 err = -EPIPE;
1669                         else 
1670                                 avail = 0; /* indicate draining */
1671                         goto _endloop;
1672                 case SNDRV_PCM_STATE_OPEN:
1673                 case SNDRV_PCM_STATE_SETUP:
1674                 case SNDRV_PCM_STATE_DISCONNECTED:
1675                         err = -EBADFD;
1676                         goto _endloop;
1677                 }
1678                 if (!tout) {
1679                         snd_printd("%s write error (DMA or IRQ trouble?)\n",
1680                                    is_playback ? "playback" : "capture");
1681                         err = -EIO;
1682                         break;
1683                 }
1684                 if (is_playback)
1685                         avail = snd_pcm_playback_avail(runtime);
1686                 else
1687                         avail = snd_pcm_capture_avail(runtime);
1688                 if (avail >= runtime->control->avail_min)
1689                         break;
1690         }
1691  _endloop:
1692         remove_wait_queue(&runtime->sleep, &wait);
1693         *availp = avail;
1694         return err;
1695 }
1696         
1697 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
1698                                       unsigned int hwoff,
1699                                       unsigned long data, unsigned int off,
1700                                       snd_pcm_uframes_t frames)
1701 {
1702         struct snd_pcm_runtime *runtime = substream->runtime;
1703         int err;
1704         char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1705         if (substream->ops->copy) {
1706                 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1707                         return err;
1708         } else {
1709                 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1710                 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1711                         return -EFAULT;
1712         }
1713         return 0;
1714 }
1715  
1716 typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
1717                           unsigned long data, unsigned int off,
1718                           snd_pcm_uframes_t size);
1719
1720 static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, 
1721                                             unsigned long data,
1722                                             snd_pcm_uframes_t size,
1723                                             int nonblock,
1724                                             transfer_f transfer)
1725 {
1726         struct snd_pcm_runtime *runtime = substream->runtime;
1727         snd_pcm_uframes_t xfer = 0;
1728         snd_pcm_uframes_t offset = 0;
1729         int err = 0;
1730
1731         if (size == 0)
1732                 return 0;
1733
1734         snd_pcm_stream_lock_irq(substream);
1735         switch (runtime->status->state) {
1736         case SNDRV_PCM_STATE_PREPARED:
1737         case SNDRV_PCM_STATE_RUNNING:
1738         case SNDRV_PCM_STATE_PAUSED:
1739                 break;
1740         case SNDRV_PCM_STATE_XRUN:
1741                 err = -EPIPE;
1742                 goto _end_unlock;
1743         case SNDRV_PCM_STATE_SUSPENDED:
1744                 err = -ESTRPIPE;
1745                 goto _end_unlock;
1746         default:
1747                 err = -EBADFD;
1748                 goto _end_unlock;
1749         }
1750
1751         while (size > 0) {
1752                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
1753                 snd_pcm_uframes_t avail;
1754                 snd_pcm_uframes_t cont;
1755                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
1756                         snd_pcm_update_hw_ptr(substream);
1757                 avail = snd_pcm_playback_avail(runtime);
1758                 if (!avail) {
1759                         if (nonblock) {
1760                                 err = -EAGAIN;
1761                                 goto _end_unlock;
1762                         }
1763                         err = wait_for_avail_min(substream, &avail);
1764                         if (err < 0)
1765                                 goto _end_unlock;
1766                 }
1767                 frames = size > avail ? avail : size;
1768                 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1769                 if (frames > cont)
1770                         frames = cont;
1771                 if (snd_BUG_ON(!frames)) {
1772                         snd_pcm_stream_unlock_irq(substream);
1773                         return -EINVAL;
1774                 }
1775                 appl_ptr = runtime->control->appl_ptr;
1776                 appl_ofs = appl_ptr % runtime->buffer_size;
1777                 snd_pcm_stream_unlock_irq(substream);
1778                 if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
1779                         goto _end;
1780                 snd_pcm_stream_lock_irq(substream);
1781                 switch (runtime->status->state) {
1782                 case SNDRV_PCM_STATE_XRUN:
1783                         err = -EPIPE;
1784                         goto _end_unlock;
1785                 case SNDRV_PCM_STATE_SUSPENDED:
1786                         err = -ESTRPIPE;
1787                         goto _end_unlock;
1788                 default:
1789                         break;
1790                 }
1791                 appl_ptr += frames;
1792                 if (appl_ptr >= runtime->boundary)
1793                         appl_ptr -= runtime->boundary;
1794                 runtime->control->appl_ptr = appl_ptr;
1795                 if (substream->ops->ack)
1796                         substream->ops->ack(substream);
1797
1798                 offset += frames;
1799                 size -= frames;
1800                 xfer += frames;
1801                 if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
1802                     snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
1803                         err = snd_pcm_start(substream);
1804                         if (err < 0)
1805                                 goto _end_unlock;
1806                 }
1807         }
1808  _end_unlock:
1809         snd_pcm_stream_unlock_irq(substream);
1810  _end:
1811         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
1812 }
1813
1814 /* sanity-check for read/write methods */
1815 static int pcm_sanity_check(struct snd_pcm_substream *substream)
1816 {
1817         struct snd_pcm_runtime *runtime;
1818         if (PCM_RUNTIME_CHECK(substream))
1819                 return -ENXIO;
1820         runtime = substream->runtime;
1821         if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
1822                 return -EINVAL;
1823         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1824                 return -EBADFD;
1825         return 0;
1826 }
1827
1828 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
1829 {
1830         struct snd_pcm_runtime *runtime;
1831         int nonblock;
1832         int err;
1833
1834         err = pcm_sanity_check(substream);
1835         if (err < 0)
1836                 return err;
1837         runtime = substream->runtime;
1838         nonblock = !!(substream->f_flags & O_NONBLOCK);
1839
1840         if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
1841             runtime->channels > 1)
1842                 return -EINVAL;
1843         return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
1844                                   snd_pcm_lib_write_transfer);
1845 }
1846
1847 EXPORT_SYMBOL(snd_pcm_lib_write);
1848
1849 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
1850                                        unsigned int hwoff,
1851                                        unsigned long data, unsigned int off,
1852                                        snd_pcm_uframes_t frames)
1853 {
1854         struct snd_pcm_runtime *runtime = substream->runtime;
1855         int err;
1856         void __user **bufs = (void __user **)data;
1857         int channels = runtime->channels;
1858         int c;
1859         if (substream->ops->copy) {
1860                 if (snd_BUG_ON(!substream->ops->silence))
1861                         return -EINVAL;
1862                 for (c = 0; c < channels; ++c, ++bufs) {
1863                         if (*bufs == NULL) {
1864                                 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
1865                                         return err;
1866                         } else {
1867                                 char __user *buf = *bufs + samples_to_bytes(runtime, off);
1868                                 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
1869                                         return err;
1870                         }
1871                 }
1872         } else {
1873                 /* default transfer behaviour */
1874                 size_t dma_csize = runtime->dma_bytes / channels;
1875                 for (c = 0; c < channels; ++c, ++bufs) {
1876                         char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
1877                         if (*bufs == NULL) {
1878                                 snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
1879                         } else {
1880                                 char __user *buf = *bufs + samples_to_bytes(runtime, off);
1881                                 if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
1882                                         return -EFAULT;
1883                         }
1884                 }
1885         }
1886         return 0;
1887 }
1888  
1889 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
1890                                      void __user **bufs,
1891                                      snd_pcm_uframes_t frames)
1892 {
1893         struct snd_pcm_runtime *runtime;
1894         int nonblock;
1895         int err;
1896
1897         err = pcm_sanity_check(substream);
1898         if (err < 0)
1899                 return err;
1900         runtime = substream->runtime;
1901         nonblock = !!(substream->f_flags & O_NONBLOCK);
1902
1903         if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
1904                 return -EINVAL;
1905         return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
1906                                   nonblock, snd_pcm_lib_writev_transfer);
1907 }
1908
1909 EXPORT_SYMBOL(snd_pcm_lib_writev);
1910
1911 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 
1912                                      unsigned int hwoff,
1913                                      unsigned long data, unsigned int off,
1914                                      snd_pcm_uframes_t frames)
1915 {
1916         struct snd_pcm_runtime *runtime = substream->runtime;
1917         int err;
1918         char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1919         if (substream->ops->copy) {
1920                 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1921                         return err;
1922         } else {
1923                 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1924                 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
1925                         return -EFAULT;
1926         }
1927         return 0;
1928 }
1929
1930 static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
1931                                            unsigned long data,
1932                                            snd_pcm_uframes_t size,
1933                                            int nonblock,
1934                                            transfer_f transfer)
1935 {
1936         struct snd_pcm_runtime *runtime = substream->runtime;
1937         snd_pcm_uframes_t xfer = 0;
1938         snd_pcm_uframes_t offset = 0;
1939         int err = 0;
1940
1941         if (size == 0)
1942                 return 0;
1943
1944         snd_pcm_stream_lock_irq(substream);
1945         switch (runtime->status->state) {
1946         case SNDRV_PCM_STATE_PREPARED:
1947                 if (size >= runtime->start_threshold) {
1948                         err = snd_pcm_start(substream);
1949                         if (err < 0)
1950                                 goto _end_unlock;
1951                 }
1952                 break;
1953         case SNDRV_PCM_STATE_DRAINING:
1954         case SNDRV_PCM_STATE_RUNNING:
1955         case SNDRV_PCM_STATE_PAUSED:
1956                 break;
1957         case SNDRV_PCM_STATE_XRUN:
1958                 err = -EPIPE;
1959                 goto _end_unlock;
1960         case SNDRV_PCM_STATE_SUSPENDED:
1961                 err = -ESTRPIPE;
1962                 goto _end_unlock;
1963         default:
1964                 err = -EBADFD;
1965                 goto _end_unlock;
1966         }
1967
1968         while (size > 0) {
1969                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
1970                 snd_pcm_uframes_t avail;
1971                 snd_pcm_uframes_t cont;
1972                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
1973                         snd_pcm_update_hw_ptr(substream);
1974                 avail = snd_pcm_capture_avail(runtime);
1975                 if (!avail) {
1976                         if (runtime->status->state ==
1977                             SNDRV_PCM_STATE_DRAINING) {
1978                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1979                                 goto _end_unlock;
1980                         }
1981                         if (nonblock) {
1982                                 err = -EAGAIN;
1983                                 goto _end_unlock;
1984                         }
1985                         err = wait_for_avail_min(substream, &avail);
1986                         if (err < 0)
1987                                 goto _end_unlock;
1988                         if (!avail)
1989                                 continue; /* draining */
1990                 }
1991                 frames = size > avail ? avail : size;
1992                 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1993                 if (frames > cont)
1994                         frames = cont;
1995                 if (snd_BUG_ON(!frames)) {
1996                         snd_pcm_stream_unlock_irq(substream);
1997                         return -EINVAL;
1998                 }
1999                 appl_ptr = runtime->control->appl_ptr;
2000                 appl_ofs = appl_ptr % runtime->buffer_size;
2001                 snd_pcm_stream_unlock_irq(substream);
2002                 if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
2003                         goto _end;
2004                 snd_pcm_stream_lock_irq(substream);
2005                 switch (runtime->status->state) {
2006                 case SNDRV_PCM_STATE_XRUN:
2007                         err = -EPIPE;
2008                         goto _end_unlock;
2009                 case SNDRV_PCM_STATE_SUSPENDED:
2010                         err = -ESTRPIPE;
2011                         goto _end_unlock;
2012                 default:
2013                         break;
2014                 }
2015                 appl_ptr += frames;
2016                 if (appl_ptr >= runtime->boundary)
2017                         appl_ptr -= runtime->boundary;
2018                 runtime->control->appl_ptr = appl_ptr;
2019                 if (substream->ops->ack)
2020                         substream->ops->ack(substream);
2021
2022                 offset += frames;
2023                 size -= frames;
2024                 xfer += frames;
2025         }
2026  _end_unlock:
2027         snd_pcm_stream_unlock_irq(substream);
2028  _end:
2029         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2030 }
2031
2032 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
2033 {
2034         struct snd_pcm_runtime *runtime;
2035         int nonblock;
2036         int err;
2037         
2038         err = pcm_sanity_check(substream);
2039         if (err < 0)
2040                 return err;
2041         runtime = substream->runtime;
2042         nonblock = !!(substream->f_flags & O_NONBLOCK);
2043         if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
2044                 return -EINVAL;
2045         return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
2046 }
2047
2048 EXPORT_SYMBOL(snd_pcm_lib_read);
2049
2050 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
2051                                       unsigned int hwoff,
2052                                       unsigned long data, unsigned int off,
2053                                       snd_pcm_uframes_t frames)
2054 {
2055         struct snd_pcm_runtime *runtime = substream->runtime;
2056         int err;
2057         void __user **bufs = (void __user **)data;
2058         int channels = runtime->channels;
2059         int c;
2060         if (substream->ops->copy) {
2061                 for (c = 0; c < channels; ++c, ++bufs) {
2062                         char __user *buf;
2063                         if (*bufs == NULL)
2064                                 continue;
2065                         buf = *bufs + samples_to_bytes(runtime, off);
2066                         if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2067                                 return err;
2068                 }
2069         } else {
2070                 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
2071                 for (c = 0; c < channels; ++c, ++bufs) {
2072                         char *hwbuf;
2073                         char __user *buf;
2074                         if (*bufs == NULL)
2075                                 continue;
2076
2077                         hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2078                         buf = *bufs + samples_to_bytes(runtime, off);
2079                         if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
2080                                 return -EFAULT;
2081                 }
2082         }
2083         return 0;
2084 }
2085  
2086 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
2087                                     void __user **bufs,
2088                                     snd_pcm_uframes_t frames)
2089 {
2090         struct snd_pcm_runtime *runtime;
2091         int nonblock;
2092         int err;
2093
2094         err = pcm_sanity_check(substream);
2095         if (err < 0)
2096                 return err;
2097         runtime = substream->runtime;
2098         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2099                 return -EBADFD;
2100
2101         nonblock = !!(substream->f_flags & O_NONBLOCK);
2102         if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2103                 return -EINVAL;
2104         return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
2105 }
2106
2107 EXPORT_SYMBOL(snd_pcm_lib_readv);