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