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