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