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