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