sound/core/pcm_lib.c

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