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