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