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