sound/core/pcm_lib.c

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