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