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