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