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