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(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr) 43 { 44 struct snd_pcm_runtime *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 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; 62 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) 63 return; 64 frames = runtime->silence_threshold - noise_dist; 65 if (frames > runtime->silence_size) 66 frames = runtime->silence_size; 67 } else { 68 if (new_hw_ptr == ULONG_MAX) { /* initialization */ 69 snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime); 70 runtime->silence_filled = avail > 0 ? avail : 0; 71 runtime->silence_start = (runtime->status->hw_ptr + 72 runtime->silence_filled) % 73 runtime->boundary; 74 } else { 75 ofs = runtime->status->hw_ptr; 76 frames = new_hw_ptr - ofs; 77 if ((snd_pcm_sframes_t)frames < 0) 78 frames += runtime->boundary; 79 runtime->silence_filled -= frames; 80 if ((snd_pcm_sframes_t)runtime->silence_filled < 0) { 81 runtime->silence_filled = 0; 82 runtime->silence_start = new_hw_ptr; 83 } else { 84 runtime->silence_start = ofs; 85 } 86 } 87 frames = runtime->buffer_size - runtime->silence_filled; 88 } 89 snd_assert(frames <= runtime->buffer_size, return); 90 if (frames == 0) 91 return; 92 ofs = runtime->silence_start % runtime->buffer_size; 93 while (frames > 0) { 94 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames; 95 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || 96 runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) { 97 if (substream->ops->silence) { 98 int err; 99 err = substream->ops->silence(substream, -1, ofs, transfer); 100 snd_assert(err >= 0, ); 101 } else { 102 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs); 103 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels); 104 } 105 } else { 106 unsigned int c; 107 unsigned int channels = runtime->channels; 108 if (substream->ops->silence) { 109 for (c = 0; c < channels; ++c) { 110 int err; 111 err = substream->ops->silence(substream, c, ofs, transfer); 112 snd_assert(err >= 0, ); 113 } 114 } else { 115 size_t dma_csize = runtime->dma_bytes / channels; 116 for (c = 0; c < channels; ++c) { 117 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs); 118 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer); 119 } 120 } 121 } 122 runtime->silence_filled += transfer; 123 frames -= transfer; 124 ofs = 0; 125 } 126 } 127 128 static void xrun(struct snd_pcm_substream *substream) 129 { 130 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); 131 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 132 if (substream->pstr->xrun_debug) { 133 snd_printd(KERN_DEBUG "XRUN: pcmC%dD%d%c\n", 134 substream->pcm->card->number, 135 substream->pcm->device, 136 substream->stream ? 'c' : 'p'); 137 if (substream->pstr->xrun_debug > 1) 138 dump_stack(); 139 } 140 #endif 141 } 142 143 static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream, 144 struct snd_pcm_runtime *runtime) 145 { 146 snd_pcm_uframes_t pos; 147 148 pos = substream->ops->pointer(substream); 149 if (pos == SNDRV_PCM_POS_XRUN) 150 return pos; /* XRUN */ 151 if (runtime->tstamp_mode & SNDRV_PCM_TSTAMP_MMAP) 152 getnstimeofday((struct timespec *)&runtime->status->tstamp); 153 #ifdef CONFIG_SND_DEBUG 154 if (pos >= runtime->buffer_size) { 155 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); 156 } 157 #endif 158 pos -= pos % runtime->min_align; 159 return pos; 160 } 161 162 static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream, 163 struct snd_pcm_runtime *runtime) 164 { 165 snd_pcm_uframes_t avail; 166 167 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 168 avail = snd_pcm_playback_avail(runtime); 169 else 170 avail = snd_pcm_capture_avail(runtime); 171 if (avail > runtime->avail_max) 172 runtime->avail_max = avail; 173 if (avail >= runtime->stop_threshold) { 174 if (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING) 175 snd_pcm_drain_done(substream); 176 else 177 xrun(substream); 178 return -EPIPE; 179 } 180 if (avail >= runtime->control->avail_min) 181 wake_up(&runtime->sleep); 182 return 0; 183 } 184 185 static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) 186 { 187 struct snd_pcm_runtime *runtime = substream->runtime; 188 snd_pcm_uframes_t pos; 189 snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt; 190 snd_pcm_sframes_t delta; 191 192 pos = snd_pcm_update_hw_ptr_pos(substream, runtime); 193 if (pos == SNDRV_PCM_POS_XRUN) { 194 xrun(substream); 195 return -EPIPE; 196 } 197 if (runtime->period_size == runtime->buffer_size) 198 goto __next_buf; 199 new_hw_ptr = runtime->hw_ptr_base + pos; 200 hw_ptr_interrupt = runtime->hw_ptr_interrupt + runtime->period_size; 201 202 delta = hw_ptr_interrupt - new_hw_ptr; 203 if (delta > 0) { 204 if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) { 205 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 206 if (runtime->periods > 1 && substream->pstr->xrun_debug) { 207 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); 208 if (substream->pstr->xrun_debug > 1) 209 dump_stack(); 210 } 211 #endif 212 return 0; 213 } 214 __next_buf: 215 runtime->hw_ptr_base += runtime->buffer_size; 216 if (runtime->hw_ptr_base == runtime->boundary) 217 runtime->hw_ptr_base = 0; 218 new_hw_ptr = runtime->hw_ptr_base + pos; 219 } 220 221 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 222 runtime->silence_size > 0) 223 snd_pcm_playback_silence(substream, new_hw_ptr); 224 225 runtime->status->hw_ptr = new_hw_ptr; 226 runtime->hw_ptr_interrupt = new_hw_ptr - new_hw_ptr % runtime->period_size; 227 228 return snd_pcm_update_hw_ptr_post(substream, runtime); 229 } 230 231 /* CAUTION: call it with irq disabled */ 232 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) 233 { 234 struct snd_pcm_runtime *runtime = substream->runtime; 235 snd_pcm_uframes_t pos; 236 snd_pcm_uframes_t old_hw_ptr, new_hw_ptr; 237 snd_pcm_sframes_t delta; 238 239 old_hw_ptr = runtime->status->hw_ptr; 240 pos = snd_pcm_update_hw_ptr_pos(substream, runtime); 241 if (pos == SNDRV_PCM_POS_XRUN) { 242 xrun(substream); 243 return -EPIPE; 244 } 245 new_hw_ptr = runtime->hw_ptr_base + pos; 246 247 delta = old_hw_ptr - new_hw_ptr; 248 if (delta > 0) { 249 if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) { 250 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 251 if (runtime->periods > 2 && substream->pstr->xrun_debug) { 252 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); 253 if (substream->pstr->xrun_debug > 1) 254 dump_stack(); 255 } 256 #endif 257 return 0; 258 } 259 runtime->hw_ptr_base += runtime->buffer_size; 260 if (runtime->hw_ptr_base == runtime->boundary) 261 runtime->hw_ptr_base = 0; 262 new_hw_ptr = runtime->hw_ptr_base + pos; 263 } 264 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 265 runtime->silence_size > 0) 266 snd_pcm_playback_silence(substream, new_hw_ptr); 267 268 runtime->status->hw_ptr = new_hw_ptr; 269 270 return snd_pcm_update_hw_ptr_post(substream, runtime); 271 } 272 273 /** 274 * snd_pcm_set_ops - set the PCM operators 275 * @pcm: the pcm instance 276 * @direction: stream direction, SNDRV_PCM_STREAM_XXX 277 * @ops: the operator table 278 * 279 * Sets the given PCM operators to the pcm instance. 280 */ 281 void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops) 282 { 283 struct snd_pcm_str *stream = &pcm->streams[direction]; 284 struct snd_pcm_substream *substream; 285 286 for (substream = stream->substream; substream != NULL; substream = substream->next) 287 substream->ops = ops; 288 } 289 290 EXPORT_SYMBOL(snd_pcm_set_ops); 291 292 /** 293 * snd_pcm_sync - set the PCM sync id 294 * @substream: the pcm substream 295 * 296 * Sets the PCM sync identifier for the card. 297 */ 298 void snd_pcm_set_sync(struct snd_pcm_substream *substream) 299 { 300 struct snd_pcm_runtime *runtime = substream->runtime; 301 302 runtime->sync.id32[0] = substream->pcm->card->number; 303 runtime->sync.id32[1] = -1; 304 runtime->sync.id32[2] = -1; 305 runtime->sync.id32[3] = -1; 306 } 307 308 EXPORT_SYMBOL(snd_pcm_set_sync); 309 310 /* 311 * Standard ioctl routine 312 */ 313 314 static inline unsigned int div32(unsigned int a, unsigned int b, 315 unsigned int *r) 316 { 317 if (b == 0) { 318 *r = 0; 319 return UINT_MAX; 320 } 321 *r = a % b; 322 return a / b; 323 } 324 325 static inline unsigned int div_down(unsigned int a, unsigned int b) 326 { 327 if (b == 0) 328 return UINT_MAX; 329 return a / b; 330 } 331 332 static inline unsigned int div_up(unsigned int a, unsigned int b) 333 { 334 unsigned int r; 335 unsigned int q; 336 if (b == 0) 337 return UINT_MAX; 338 q = div32(a, b, &r); 339 if (r) 340 ++q; 341 return q; 342 } 343 344 static inline unsigned int mul(unsigned int a, unsigned int b) 345 { 346 if (a == 0) 347 return 0; 348 if (div_down(UINT_MAX, a) < b) 349 return UINT_MAX; 350 return a * b; 351 } 352 353 static inline unsigned int muldiv32(unsigned int a, unsigned int b, 354 unsigned int c, unsigned int *r) 355 { 356 u_int64_t n = (u_int64_t) a * b; 357 if (c == 0) { 358 snd_assert(n > 0, ); 359 *r = 0; 360 return UINT_MAX; 361 } 362 div64_32(&n, c, r); 363 if (n >= UINT_MAX) { 364 *r = 0; 365 return UINT_MAX; 366 } 367 return n; 368 } 369 370 /** 371 * snd_interval_refine - refine the interval value of configurator 372 * @i: the interval value to refine 373 * @v: the interval value to refer to 374 * 375 * Refines the interval value with the reference value. 376 * The interval is changed to the range satisfying both intervals. 377 * The interval status (min, max, integer, etc.) are evaluated. 378 * 379 * Returns non-zero if the value is changed, zero if not changed. 380 */ 381 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) 382 { 383 int changed = 0; 384 snd_assert(!snd_interval_empty(i), return -EINVAL); 385 if (i->min < v->min) { 386 i->min = v->min; 387 i->openmin = v->openmin; 388 changed = 1; 389 } else if (i->min == v->min && !i->openmin && v->openmin) { 390 i->openmin = 1; 391 changed = 1; 392 } 393 if (i->max > v->max) { 394 i->max = v->max; 395 i->openmax = v->openmax; 396 changed = 1; 397 } else if (i->max == v->max && !i->openmax && v->openmax) { 398 i->openmax = 1; 399 changed = 1; 400 } 401 if (!i->integer && v->integer) { 402 i->integer = 1; 403 changed = 1; 404 } 405 if (i->integer) { 406 if (i->openmin) { 407 i->min++; 408 i->openmin = 0; 409 } 410 if (i->openmax) { 411 i->max--; 412 i->openmax = 0; 413 } 414 } else if (!i->openmin && !i->openmax && i->min == i->max) 415 i->integer = 1; 416 if (snd_interval_checkempty(i)) { 417 snd_interval_none(i); 418 return -EINVAL; 419 } 420 return changed; 421 } 422 423 EXPORT_SYMBOL(snd_interval_refine); 424 425 static int snd_interval_refine_first(struct snd_interval *i) 426 { 427 snd_assert(!snd_interval_empty(i), return -EINVAL); 428 if (snd_interval_single(i)) 429 return 0; 430 i->max = i->min; 431 i->openmax = i->openmin; 432 if (i->openmax) 433 i->max++; 434 return 1; 435 } 436 437 static int snd_interval_refine_last(struct snd_interval *i) 438 { 439 snd_assert(!snd_interval_empty(i), return -EINVAL); 440 if (snd_interval_single(i)) 441 return 0; 442 i->min = i->max; 443 i->openmin = i->openmax; 444 if (i->openmin) 445 i->min--; 446 return 1; 447 } 448 449 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) 450 { 451 if (a->empty || b->empty) { 452 snd_interval_none(c); 453 return; 454 } 455 c->empty = 0; 456 c->min = mul(a->min, b->min); 457 c->openmin = (a->openmin || b->openmin); 458 c->max = mul(a->max, b->max); 459 c->openmax = (a->openmax || b->openmax); 460 c->integer = (a->integer && b->integer); 461 } 462 463 /** 464 * snd_interval_div - refine the interval value with division 465 * @a: dividend 466 * @b: divisor 467 * @c: quotient 468 * 469 * c = a / b 470 * 471 * Returns non-zero if the value is changed, zero if not changed. 472 */ 473 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) 474 { 475 unsigned int r; 476 if (a->empty || b->empty) { 477 snd_interval_none(c); 478 return; 479 } 480 c->empty = 0; 481 c->min = div32(a->min, b->max, &r); 482 c->openmin = (r || a->openmin || b->openmax); 483 if (b->min > 0) { 484 c->max = div32(a->max, b->min, &r); 485 if (r) { 486 c->max++; 487 c->openmax = 1; 488 } else 489 c->openmax = (a->openmax || b->openmin); 490 } else { 491 c->max = UINT_MAX; 492 c->openmax = 0; 493 } 494 c->integer = 0; 495 } 496 497 /** 498 * snd_interval_muldivk - refine the interval value 499 * @a: dividend 1 500 * @b: dividend 2 501 * @k: divisor (as integer) 502 * @c: result 503 * 504 * c = a * b / k 505 * 506 * Returns non-zero if the value is changed, zero if not changed. 507 */ 508 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 509 unsigned int k, struct snd_interval *c) 510 { 511 unsigned int r; 512 if (a->empty || b->empty) { 513 snd_interval_none(c); 514 return; 515 } 516 c->empty = 0; 517 c->min = muldiv32(a->min, b->min, k, &r); 518 c->openmin = (r || a->openmin || b->openmin); 519 c->max = muldiv32(a->max, b->max, k, &r); 520 if (r) { 521 c->max++; 522 c->openmax = 1; 523 } else 524 c->openmax = (a->openmax || b->openmax); 525 c->integer = 0; 526 } 527 528 /** 529 * snd_interval_mulkdiv - refine the interval value 530 * @a: dividend 1 531 * @k: dividend 2 (as integer) 532 * @b: divisor 533 * @c: result 534 * 535 * c = a * k / b 536 * 537 * Returns non-zero if the value is changed, zero if not changed. 538 */ 539 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, 540 const struct snd_interval *b, struct snd_interval *c) 541 { 542 unsigned int r; 543 if (a->empty || b->empty) { 544 snd_interval_none(c); 545 return; 546 } 547 c->empty = 0; 548 c->min = muldiv32(a->min, k, b->max, &r); 549 c->openmin = (r || a->openmin || b->openmax); 550 if (b->min > 0) { 551 c->max = muldiv32(a->max, k, b->min, &r); 552 if (r) { 553 c->max++; 554 c->openmax = 1; 555 } else 556 c->openmax = (a->openmax || b->openmin); 557 } else { 558 c->max = UINT_MAX; 559 c->openmax = 0; 560 } 561 c->integer = 0; 562 } 563 564 /* ---- */ 565 566 567 /** 568 * snd_interval_ratnum - refine the interval value 569 * @i: interval to refine 570 * @rats_count: number of ratnum_t 571 * @rats: ratnum_t array 572 * @nump: pointer to store the resultant numerator 573 * @denp: pointer to store the resultant denominator 574 * 575 * Returns non-zero if the value is changed, zero if not changed. 576 */ 577 int snd_interval_ratnum(struct snd_interval *i, 578 unsigned int rats_count, struct snd_ratnum *rats, 579 unsigned int *nump, unsigned int *denp) 580 { 581 unsigned int best_num, best_diff, best_den; 582 unsigned int k; 583 struct snd_interval t; 584 int err; 585 586 best_num = best_den = best_diff = 0; 587 for (k = 0; k < rats_count; ++k) { 588 unsigned int num = rats[k].num; 589 unsigned int den; 590 unsigned int q = i->min; 591 int diff; 592 if (q == 0) 593 q = 1; 594 den = div_down(num, q); 595 if (den < rats[k].den_min) 596 continue; 597 if (den > rats[k].den_max) 598 den = rats[k].den_max; 599 else { 600 unsigned int r; 601 r = (den - rats[k].den_min) % rats[k].den_step; 602 if (r != 0) 603 den -= r; 604 } 605 diff = num - q * den; 606 if (best_num == 0 || 607 diff * best_den < best_diff * den) { 608 best_diff = diff; 609 best_den = den; 610 best_num = num; 611 } 612 } 613 if (best_den == 0) { 614 i->empty = 1; 615 return -EINVAL; 616 } 617 t.min = div_down(best_num, best_den); 618 t.openmin = !!(best_num % best_den); 619 620 best_num = best_den = best_diff = 0; 621 for (k = 0; k < rats_count; ++k) { 622 unsigned int num = rats[k].num; 623 unsigned int den; 624 unsigned int q = i->max; 625 int diff; 626 if (q == 0) { 627 i->empty = 1; 628 return -EINVAL; 629 } 630 den = div_up(num, q); 631 if (den > rats[k].den_max) 632 continue; 633 if (den < rats[k].den_min) 634 den = rats[k].den_min; 635 else { 636 unsigned int r; 637 r = (den - rats[k].den_min) % rats[k].den_step; 638 if (r != 0) 639 den += rats[k].den_step - r; 640 } 641 diff = q * den - num; 642 if (best_num == 0 || 643 diff * best_den < best_diff * den) { 644 best_diff = diff; 645 best_den = den; 646 best_num = num; 647 } 648 } 649 if (best_den == 0) { 650 i->empty = 1; 651 return -EINVAL; 652 } 653 t.max = div_up(best_num, best_den); 654 t.openmax = !!(best_num % best_den); 655 t.integer = 0; 656 err = snd_interval_refine(i, &t); 657 if (err < 0) 658 return err; 659 660 if (snd_interval_single(i)) { 661 if (nump) 662 *nump = best_num; 663 if (denp) 664 *denp = best_den; 665 } 666 return err; 667 } 668 669 EXPORT_SYMBOL(snd_interval_ratnum); 670 671 /** 672 * snd_interval_ratden - refine the interval value 673 * @i: interval to refine 674 * @rats_count: number of struct ratden 675 * @rats: struct ratden array 676 * @nump: pointer to store the resultant numerator 677 * @denp: pointer to store the resultant denominator 678 * 679 * Returns non-zero if the value is changed, zero if not changed. 680 */ 681 static int snd_interval_ratden(struct snd_interval *i, 682 unsigned int rats_count, struct snd_ratden *rats, 683 unsigned int *nump, unsigned int *denp) 684 { 685 unsigned int best_num, best_diff, best_den; 686 unsigned int k; 687 struct snd_interval t; 688 int err; 689 690 best_num = best_den = best_diff = 0; 691 for (k = 0; k < rats_count; ++k) { 692 unsigned int num; 693 unsigned int den = rats[k].den; 694 unsigned int q = i->min; 695 int diff; 696 num = mul(q, den); 697 if (num > rats[k].num_max) 698 continue; 699 if (num < rats[k].num_min) 700 num = rats[k].num_max; 701 else { 702 unsigned int r; 703 r = (num - rats[k].num_min) % rats[k].num_step; 704 if (r != 0) 705 num += rats[k].num_step - r; 706 } 707 diff = num - q * den; 708 if (best_num == 0 || 709 diff * best_den < best_diff * den) { 710 best_diff = diff; 711 best_den = den; 712 best_num = num; 713 } 714 } 715 if (best_den == 0) { 716 i->empty = 1; 717 return -EINVAL; 718 } 719 t.min = div_down(best_num, best_den); 720 t.openmin = !!(best_num % best_den); 721 722 best_num = best_den = best_diff = 0; 723 for (k = 0; k < rats_count; ++k) { 724 unsigned int num; 725 unsigned int den = rats[k].den; 726 unsigned int q = i->max; 727 int diff; 728 num = mul(q, den); 729 if (num < rats[k].num_min) 730 continue; 731 if (num > rats[k].num_max) 732 num = rats[k].num_max; 733 else { 734 unsigned int r; 735 r = (num - rats[k].num_min) % rats[k].num_step; 736 if (r != 0) 737 num -= r; 738 } 739 diff = q * den - num; 740 if (best_num == 0 || 741 diff * best_den < best_diff * den) { 742 best_diff = diff; 743 best_den = den; 744 best_num = num; 745 } 746 } 747 if (best_den == 0) { 748 i->empty = 1; 749 return -EINVAL; 750 } 751 t.max = div_up(best_num, best_den); 752 t.openmax = !!(best_num % best_den); 753 t.integer = 0; 754 err = snd_interval_refine(i, &t); 755 if (err < 0) 756 return err; 757 758 if (snd_interval_single(i)) { 759 if (nump) 760 *nump = best_num; 761 if (denp) 762 *denp = best_den; 763 } 764 return err; 765 } 766 767 /** 768 * snd_interval_list - refine the interval value from the list 769 * @i: the interval value to refine 770 * @count: the number of elements in the list 771 * @list: the value list 772 * @mask: the bit-mask to evaluate 773 * 774 * Refines the interval value from the list. 775 * When mask is non-zero, only the elements corresponding to bit 1 are 776 * evaluated. 777 * 778 * Returns non-zero if the value is changed, zero if not changed. 779 */ 780 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask) 781 { 782 unsigned int k; 783 int changed = 0; 784 785 if (!count) { 786 i->empty = 1; 787 return -EINVAL; 788 } 789 for (k = 0; k < count; k++) { 790 if (mask && !(mask & (1 << k))) 791 continue; 792 if (i->min == list[k] && !i->openmin) 793 goto _l1; 794 if (i->min < list[k]) { 795 i->min = list[k]; 796 i->openmin = 0; 797 changed = 1; 798 goto _l1; 799 } 800 } 801 i->empty = 1; 802 return -EINVAL; 803 _l1: 804 for (k = count; k-- > 0;) { 805 if (mask && !(mask & (1 << k))) 806 continue; 807 if (i->max == list[k] && !i->openmax) 808 goto _l2; 809 if (i->max > list[k]) { 810 i->max = list[k]; 811 i->openmax = 0; 812 changed = 1; 813 goto _l2; 814 } 815 } 816 i->empty = 1; 817 return -EINVAL; 818 _l2: 819 if (snd_interval_checkempty(i)) { 820 i->empty = 1; 821 return -EINVAL; 822 } 823 return changed; 824 } 825 826 EXPORT_SYMBOL(snd_interval_list); 827 828 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step) 829 { 830 unsigned int n; 831 int changed = 0; 832 n = (i->min - min) % step; 833 if (n != 0 || i->openmin) { 834 i->min += step - n; 835 changed = 1; 836 } 837 n = (i->max - min) % step; 838 if (n != 0 || i->openmax) { 839 i->max -= n; 840 changed = 1; 841 } 842 if (snd_interval_checkempty(i)) { 843 i->empty = 1; 844 return -EINVAL; 845 } 846 return changed; 847 } 848 849 /* Info constraints helpers */ 850 851 /** 852 * snd_pcm_hw_rule_add - add the hw-constraint rule 853 * @runtime: the pcm runtime instance 854 * @cond: condition bits 855 * @var: the variable to evaluate 856 * @func: the evaluation function 857 * @private: the private data pointer passed to function 858 * @dep: the dependent variables 859 * 860 * Returns zero if successful, or a negative error code on failure. 861 */ 862 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, 863 int var, 864 snd_pcm_hw_rule_func_t func, void *private, 865 int dep, ...) 866 { 867 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 868 struct snd_pcm_hw_rule *c; 869 unsigned int k; 870 va_list args; 871 va_start(args, dep); 872 if (constrs->rules_num >= constrs->rules_all) { 873 struct snd_pcm_hw_rule *new; 874 unsigned int new_rules = constrs->rules_all + 16; 875 new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL); 876 if (!new) 877 return -ENOMEM; 878 if (constrs->rules) { 879 memcpy(new, constrs->rules, 880 constrs->rules_num * sizeof(*c)); 881 kfree(constrs->rules); 882 } 883 constrs->rules = new; 884 constrs->rules_all = new_rules; 885 } 886 c = &constrs->rules[constrs->rules_num]; 887 c->cond = cond; 888 c->func = func; 889 c->var = var; 890 c->private = private; 891 k = 0; 892 while (1) { 893 snd_assert(k < ARRAY_SIZE(c->deps), return -EINVAL); 894 c->deps[k++] = dep; 895 if (dep < 0) 896 break; 897 dep = va_arg(args, int); 898 } 899 constrs->rules_num++; 900 va_end(args); 901 return 0; 902 } 903 904 EXPORT_SYMBOL(snd_pcm_hw_rule_add); 905 906 /** 907 * snd_pcm_hw_constraint_mask 908 * @runtime: PCM runtime instance 909 * @var: hw_params variable to apply the mask 910 * @mask: the bitmap mask 911 * 912 * Apply the constraint of the given bitmap mask to a mask parameter. 913 */ 914 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 915 u_int32_t mask) 916 { 917 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 918 struct snd_mask *maskp = constrs_mask(constrs, var); 919 *maskp->bits &= mask; 920 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ 921 if (*maskp->bits == 0) 922 return -EINVAL; 923 return 0; 924 } 925 926 /** 927 * snd_pcm_hw_constraint_mask64 928 * @runtime: PCM runtime instance 929 * @var: hw_params variable to apply the mask 930 * @mask: the 64bit bitmap mask 931 * 932 * Apply the constraint of the given bitmap mask to a mask parameter. 933 */ 934 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 935 u_int64_t mask) 936 { 937 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 938 struct snd_mask *maskp = constrs_mask(constrs, var); 939 maskp->bits[0] &= (u_int32_t)mask; 940 maskp->bits[1] &= (u_int32_t)(mask >> 32); 941 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ 942 if (! maskp->bits[0] && ! maskp->bits[1]) 943 return -EINVAL; 944 return 0; 945 } 946 947 /** 948 * snd_pcm_hw_constraint_integer 949 * @runtime: PCM runtime instance 950 * @var: hw_params variable to apply the integer constraint 951 * 952 * Apply the constraint of integer to an interval parameter. 953 */ 954 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var) 955 { 956 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 957 return snd_interval_setinteger(constrs_interval(constrs, var)); 958 } 959 960 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer); 961 962 /** 963 * snd_pcm_hw_constraint_minmax 964 * @runtime: PCM runtime instance 965 * @var: hw_params variable to apply the range 966 * @min: the minimal value 967 * @max: the maximal value 968 * 969 * Apply the min/max range constraint to an interval parameter. 970 */ 971 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 972 unsigned int min, unsigned int max) 973 { 974 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 975 struct snd_interval t; 976 t.min = min; 977 t.max = max; 978 t.openmin = t.openmax = 0; 979 t.integer = 0; 980 return snd_interval_refine(constrs_interval(constrs, var), &t); 981 } 982 983 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax); 984 985 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, 986 struct snd_pcm_hw_rule *rule) 987 { 988 struct snd_pcm_hw_constraint_list *list = rule->private; 989 return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask); 990 } 991 992 993 /** 994 * snd_pcm_hw_constraint_list 995 * @runtime: PCM runtime instance 996 * @cond: condition bits 997 * @var: hw_params variable to apply the list constraint 998 * @l: list 999 * 1000 * Apply the list of constraints to an interval parameter. 1001 */ 1002 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 1003 unsigned int cond, 1004 snd_pcm_hw_param_t var, 1005 struct snd_pcm_hw_constraint_list *l) 1006 { 1007 return snd_pcm_hw_rule_add(runtime, cond, var, 1008 snd_pcm_hw_rule_list, l, 1009 var, -1); 1010 } 1011 1012 EXPORT_SYMBOL(snd_pcm_hw_constraint_list); 1013 1014 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, 1015 struct snd_pcm_hw_rule *rule) 1016 { 1017 struct snd_pcm_hw_constraint_ratnums *r = rule->private; 1018 unsigned int num = 0, den = 0; 1019 int err; 1020 err = snd_interval_ratnum(hw_param_interval(params, rule->var), 1021 r->nrats, r->rats, &num, &den); 1022 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { 1023 params->rate_num = num; 1024 params->rate_den = den; 1025 } 1026 return err; 1027 } 1028 1029 /** 1030 * snd_pcm_hw_constraint_ratnums 1031 * @runtime: PCM runtime instance 1032 * @cond: condition bits 1033 * @var: hw_params variable to apply the ratnums constraint 1034 * @r: struct snd_ratnums constriants 1035 */ 1036 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 1037 unsigned int cond, 1038 snd_pcm_hw_param_t var, 1039 struct snd_pcm_hw_constraint_ratnums *r) 1040 { 1041 return snd_pcm_hw_rule_add(runtime, cond, var, 1042 snd_pcm_hw_rule_ratnums, r, 1043 var, -1); 1044 } 1045 1046 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums); 1047 1048 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, 1049 struct snd_pcm_hw_rule *rule) 1050 { 1051 struct snd_pcm_hw_constraint_ratdens *r = rule->private; 1052 unsigned int num = 0, den = 0; 1053 int err = snd_interval_ratden(hw_param_interval(params, rule->var), 1054 r->nrats, r->rats, &num, &den); 1055 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { 1056 params->rate_num = num; 1057 params->rate_den = den; 1058 } 1059 return err; 1060 } 1061 1062 /** 1063 * snd_pcm_hw_constraint_ratdens 1064 * @runtime: PCM runtime instance 1065 * @cond: condition bits 1066 * @var: hw_params variable to apply the ratdens constraint 1067 * @r: struct snd_ratdens constriants 1068 */ 1069 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 1070 unsigned int cond, 1071 snd_pcm_hw_param_t var, 1072 struct snd_pcm_hw_constraint_ratdens *r) 1073 { 1074 return snd_pcm_hw_rule_add(runtime, cond, var, 1075 snd_pcm_hw_rule_ratdens, r, 1076 var, -1); 1077 } 1078 1079 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens); 1080 1081 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, 1082 struct snd_pcm_hw_rule *rule) 1083 { 1084 unsigned int l = (unsigned long) rule->private; 1085 int width = l & 0xffff; 1086 unsigned int msbits = l >> 16; 1087 struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); 1088 if (snd_interval_single(i) && snd_interval_value(i) == width) 1089 params->msbits = msbits; 1090 return 0; 1091 } 1092 1093 /** 1094 * snd_pcm_hw_constraint_msbits 1095 * @runtime: PCM runtime instance 1096 * @cond: condition bits 1097 * @width: sample bits width 1098 * @msbits: msbits width 1099 */ 1100 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 1101 unsigned int cond, 1102 unsigned int width, 1103 unsigned int msbits) 1104 { 1105 unsigned long l = (msbits << 16) | width; 1106 return snd_pcm_hw_rule_add(runtime, cond, -1, 1107 snd_pcm_hw_rule_msbits, 1108 (void*) l, 1109 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); 1110 } 1111 1112 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits); 1113 1114 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, 1115 struct snd_pcm_hw_rule *rule) 1116 { 1117 unsigned long step = (unsigned long) rule->private; 1118 return snd_interval_step(hw_param_interval(params, rule->var), 0, step); 1119 } 1120 1121 /** 1122 * snd_pcm_hw_constraint_step 1123 * @runtime: PCM runtime instance 1124 * @cond: condition bits 1125 * @var: hw_params variable to apply the step constraint 1126 * @step: step size 1127 */ 1128 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, 1129 unsigned int cond, 1130 snd_pcm_hw_param_t var, 1131 unsigned long step) 1132 { 1133 return snd_pcm_hw_rule_add(runtime, cond, var, 1134 snd_pcm_hw_rule_step, (void *) step, 1135 var, -1); 1136 } 1137 1138 EXPORT_SYMBOL(snd_pcm_hw_constraint_step); 1139 1140 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) 1141 { 1142 static int pow2_sizes[] = { 1143 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, 1144 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15, 1145 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23, 1146 1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30 1147 }; 1148 return snd_interval_list(hw_param_interval(params, rule->var), 1149 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0); 1150 } 1151 1152 /** 1153 * snd_pcm_hw_constraint_pow2 1154 * @runtime: PCM runtime instance 1155 * @cond: condition bits 1156 * @var: hw_params variable to apply the power-of-2 constraint 1157 */ 1158 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, 1159 unsigned int cond, 1160 snd_pcm_hw_param_t var) 1161 { 1162 return snd_pcm_hw_rule_add(runtime, cond, var, 1163 snd_pcm_hw_rule_pow2, NULL, 1164 var, -1); 1165 } 1166 1167 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2); 1168 1169 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, 1170 snd_pcm_hw_param_t var) 1171 { 1172 if (hw_is_mask(var)) { 1173 snd_mask_any(hw_param_mask(params, var)); 1174 params->cmask |= 1 << var; 1175 params->rmask |= 1 << var; 1176 return; 1177 } 1178 if (hw_is_interval(var)) { 1179 snd_interval_any(hw_param_interval(params, var)); 1180 params->cmask |= 1 << var; 1181 params->rmask |= 1 << var; 1182 return; 1183 } 1184 snd_BUG(); 1185 } 1186 1187 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) 1188 { 1189 unsigned int k; 1190 memset(params, 0, sizeof(*params)); 1191 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) 1192 _snd_pcm_hw_param_any(params, k); 1193 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) 1194 _snd_pcm_hw_param_any(params, k); 1195 params->info = ~0U; 1196 } 1197 1198 EXPORT_SYMBOL(_snd_pcm_hw_params_any); 1199 1200 /** 1201 * snd_pcm_hw_param_value 1202 * @params: the hw_params instance 1203 * @var: parameter to retrieve 1204 * @dir: pointer to the direction (-1,0,1) or NULL 1205 * 1206 * Return the value for field PAR if it's fixed in configuration space 1207 * defined by PARAMS. Return -EINVAL otherwise 1208 */ 1209 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, 1210 snd_pcm_hw_param_t var, int *dir) 1211 { 1212 if (hw_is_mask(var)) { 1213 const struct snd_mask *mask = hw_param_mask_c(params, var); 1214 if (!snd_mask_single(mask)) 1215 return -EINVAL; 1216 if (dir) 1217 *dir = 0; 1218 return snd_mask_value(mask); 1219 } 1220 if (hw_is_interval(var)) { 1221 const struct snd_interval *i = hw_param_interval_c(params, var); 1222 if (!snd_interval_single(i)) 1223 return -EINVAL; 1224 if (dir) 1225 *dir = i->openmin; 1226 return snd_interval_value(i); 1227 } 1228 return -EINVAL; 1229 } 1230 1231 EXPORT_SYMBOL(snd_pcm_hw_param_value); 1232 1233 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, 1234 snd_pcm_hw_param_t var) 1235 { 1236 if (hw_is_mask(var)) { 1237 snd_mask_none(hw_param_mask(params, var)); 1238 params->cmask |= 1 << var; 1239 params->rmask |= 1 << var; 1240 } else if (hw_is_interval(var)) { 1241 snd_interval_none(hw_param_interval(params, var)); 1242 params->cmask |= 1 << var; 1243 params->rmask |= 1 << var; 1244 } else { 1245 snd_BUG(); 1246 } 1247 } 1248 1249 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty); 1250 1251 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, 1252 snd_pcm_hw_param_t var) 1253 { 1254 int changed; 1255 if (hw_is_mask(var)) 1256 changed = snd_mask_refine_first(hw_param_mask(params, var)); 1257 else if (hw_is_interval(var)) 1258 changed = snd_interval_refine_first(hw_param_interval(params, var)); 1259 else 1260 return -EINVAL; 1261 if (changed) { 1262 params->cmask |= 1 << var; 1263 params->rmask |= 1 << var; 1264 } 1265 return changed; 1266 } 1267 1268 1269 /** 1270 * snd_pcm_hw_param_first 1271 * @pcm: PCM instance 1272 * @params: the hw_params instance 1273 * @var: parameter to retrieve 1274 * @dir: pointer to the direction (-1,0,1) or NULL 1275 * 1276 * Inside configuration space defined by PARAMS remove from PAR all 1277 * values > minimum. Reduce configuration space accordingly. 1278 * Return the minimum. 1279 */ 1280 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 1281 struct snd_pcm_hw_params *params, 1282 snd_pcm_hw_param_t var, int *dir) 1283 { 1284 int changed = _snd_pcm_hw_param_first(params, var); 1285 if (changed < 0) 1286 return changed; 1287 if (params->rmask) { 1288 int err = snd_pcm_hw_refine(pcm, params); 1289 snd_assert(err >= 0, return err); 1290 } 1291 return snd_pcm_hw_param_value(params, var, dir); 1292 } 1293 1294 EXPORT_SYMBOL(snd_pcm_hw_param_first); 1295 1296 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, 1297 snd_pcm_hw_param_t var) 1298 { 1299 int changed; 1300 if (hw_is_mask(var)) 1301 changed = snd_mask_refine_last(hw_param_mask(params, var)); 1302 else if (hw_is_interval(var)) 1303 changed = snd_interval_refine_last(hw_param_interval(params, var)); 1304 else 1305 return -EINVAL; 1306 if (changed) { 1307 params->cmask |= 1 << var; 1308 params->rmask |= 1 << var; 1309 } 1310 return changed; 1311 } 1312 1313 1314 /** 1315 * snd_pcm_hw_param_last 1316 * @pcm: PCM instance 1317 * @params: the hw_params instance 1318 * @var: parameter to retrieve 1319 * @dir: pointer to the direction (-1,0,1) or NULL 1320 * 1321 * Inside configuration space defined by PARAMS remove from PAR all 1322 * values < maximum. Reduce configuration space accordingly. 1323 * Return the maximum. 1324 */ 1325 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 1326 struct snd_pcm_hw_params *params, 1327 snd_pcm_hw_param_t var, int *dir) 1328 { 1329 int changed = _snd_pcm_hw_param_last(params, var); 1330 if (changed < 0) 1331 return changed; 1332 if (params->rmask) { 1333 int err = snd_pcm_hw_refine(pcm, params); 1334 snd_assert(err >= 0, return err); 1335 } 1336 return snd_pcm_hw_param_value(params, var, dir); 1337 } 1338 1339 EXPORT_SYMBOL(snd_pcm_hw_param_last); 1340 1341 /** 1342 * snd_pcm_hw_param_choose 1343 * @pcm: PCM instance 1344 * @params: the hw_params instance 1345 * 1346 * Choose one configuration from configuration space defined by PARAMS 1347 * The configuration chosen is that obtained fixing in this order: 1348 * first access, first format, first subformat, min channels, 1349 * min rate, min period time, max buffer size, min tick time 1350 */ 1351 int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, 1352 struct snd_pcm_hw_params *params) 1353 { 1354 static int vars[] = { 1355 SNDRV_PCM_HW_PARAM_ACCESS, 1356 SNDRV_PCM_HW_PARAM_FORMAT, 1357 SNDRV_PCM_HW_PARAM_SUBFORMAT, 1358 SNDRV_PCM_HW_PARAM_CHANNELS, 1359 SNDRV_PCM_HW_PARAM_RATE, 1360 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1361 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 1362 SNDRV_PCM_HW_PARAM_TICK_TIME, 1363 -1 1364 }; 1365 int err, *v; 1366 1367 for (v = vars; *v != -1; v++) { 1368 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) 1369 err = snd_pcm_hw_param_first(pcm, params, *v, NULL); 1370 else 1371 err = snd_pcm_hw_param_last(pcm, params, *v, NULL); 1372 snd_assert(err >= 0, return err); 1373 } 1374 return 0; 1375 } 1376 1377 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, 1378 void *arg) 1379 { 1380 struct snd_pcm_runtime *runtime = substream->runtime; 1381 unsigned long flags; 1382 snd_pcm_stream_lock_irqsave(substream, flags); 1383 if (snd_pcm_running(substream) && 1384 snd_pcm_update_hw_ptr(substream) >= 0) 1385 runtime->status->hw_ptr %= runtime->buffer_size; 1386 else 1387 runtime->status->hw_ptr = 0; 1388 snd_pcm_stream_unlock_irqrestore(substream, flags); 1389 return 0; 1390 } 1391 1392 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, 1393 void *arg) 1394 { 1395 struct snd_pcm_channel_info *info = arg; 1396 struct snd_pcm_runtime *runtime = substream->runtime; 1397 int width; 1398 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { 1399 info->offset = -1; 1400 return 0; 1401 } 1402 width = snd_pcm_format_physical_width(runtime->format); 1403 if (width < 0) 1404 return width; 1405 info->offset = 0; 1406 switch (runtime->access) { 1407 case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED: 1408 case SNDRV_PCM_ACCESS_RW_INTERLEAVED: 1409 info->first = info->channel * width; 1410 info->step = runtime->channels * width; 1411 break; 1412 case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED: 1413 case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED: 1414 { 1415 size_t size = runtime->dma_bytes / runtime->channels; 1416 info->first = info->channel * size * 8; 1417 info->step = width; 1418 break; 1419 } 1420 default: 1421 snd_BUG(); 1422 break; 1423 } 1424 return 0; 1425 } 1426 1427 /** 1428 * snd_pcm_lib_ioctl - a generic PCM ioctl callback 1429 * @substream: the pcm substream instance 1430 * @cmd: ioctl command 1431 * @arg: ioctl argument 1432 * 1433 * Processes the generic ioctl commands for PCM. 1434 * Can be passed as the ioctl callback for PCM ops. 1435 * 1436 * Returns zero if successful, or a negative error code on failure. 1437 */ 1438 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, 1439 unsigned int cmd, void *arg) 1440 { 1441 switch (cmd) { 1442 case SNDRV_PCM_IOCTL1_INFO: 1443 return 0; 1444 case SNDRV_PCM_IOCTL1_RESET: 1445 return snd_pcm_lib_ioctl_reset(substream, arg); 1446 case SNDRV_PCM_IOCTL1_CHANNEL_INFO: 1447 return snd_pcm_lib_ioctl_channel_info(substream, arg); 1448 } 1449 return -ENXIO; 1450 } 1451 1452 EXPORT_SYMBOL(snd_pcm_lib_ioctl); 1453 1454 /* 1455 * Conditions 1456 */ 1457 1458 static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, 1459 unsigned long ticks) 1460 { 1461 struct snd_pcm_runtime *runtime = substream->runtime; 1462 if (ticks == 0) 1463 del_timer(&runtime->tick_timer); 1464 else { 1465 ticks += (1000000 / HZ) - 1; 1466 ticks /= (1000000 / HZ); 1467 mod_timer(&runtime->tick_timer, jiffies + ticks); 1468 } 1469 } 1470 1471 /* Temporary alias */ 1472 void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) 1473 { 1474 snd_pcm_system_tick_set(substream, ticks); 1475 } 1476 1477 void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) 1478 { 1479 struct snd_pcm_runtime *runtime = substream->runtime; 1480 snd_pcm_uframes_t frames = ULONG_MAX; 1481 snd_pcm_uframes_t avail, dist; 1482 unsigned int ticks; 1483 u_int64_t n; 1484 u_int32_t r; 1485 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 1486 if (runtime->silence_size >= runtime->boundary) { 1487 frames = 1; 1488 } else if (runtime->silence_size > 0 && 1489 runtime->silence_filled < runtime->buffer_size) { 1490 snd_pcm_sframes_t noise_dist; 1491 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; 1492 if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold) 1493 frames = noise_dist - runtime->silence_threshold; 1494 } 1495 avail = snd_pcm_playback_avail(runtime); 1496 } else { 1497 avail = snd_pcm_capture_avail(runtime); 1498 } 1499 if (avail < runtime->control->avail_min) { 1500 snd_pcm_sframes_t n = runtime->control->avail_min - avail; 1501 if (n > 0 && frames > (snd_pcm_uframes_t)n) 1502 frames = n; 1503 } 1504 if (avail < runtime->buffer_size) { 1505 snd_pcm_sframes_t n = runtime->buffer_size - avail; 1506 if (n > 0 && frames > (snd_pcm_uframes_t)n) 1507 frames = n; 1508 } 1509 if (frames == ULONG_MAX) { 1510 snd_pcm_tick_set(substream, 0); 1511 return; 1512 } 1513 dist = runtime->status->hw_ptr - runtime->hw_ptr_base; 1514 /* Distance to next interrupt */ 1515 dist = runtime->period_size - dist % runtime->period_size; 1516 if (dist <= frames) { 1517 snd_pcm_tick_set(substream, 0); 1518 return; 1519 } 1520 /* the base time is us */ 1521 n = frames; 1522 n *= 1000000; 1523 div64_32(&n, runtime->tick_time * runtime->rate, &r); 1524 ticks = n + (r > 0 ? 1 : 0); 1525 if (ticks < runtime->sleep_min) 1526 ticks = runtime->sleep_min; 1527 snd_pcm_tick_set(substream, (unsigned long) ticks); 1528 } 1529 1530 void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) 1531 { 1532 struct snd_pcm_runtime *runtime; 1533 unsigned long flags; 1534 1535 snd_assert(substream != NULL, return); 1536 runtime = substream->runtime; 1537 snd_assert(runtime != NULL, return); 1538 1539 snd_pcm_stream_lock_irqsave(substream, flags); 1540 if (!snd_pcm_running(substream) || 1541 snd_pcm_update_hw_ptr(substream) < 0) 1542 goto _end; 1543 if (runtime->sleep_min) 1544 snd_pcm_tick_prepare(substream); 1545 _end: 1546 snd_pcm_stream_unlock_irqrestore(substream, flags); 1547 } 1548 1549 /** 1550 * snd_pcm_period_elapsed - update the pcm status for the next period 1551 * @substream: the pcm substream instance 1552 * 1553 * This function is called from the interrupt handler when the 1554 * PCM has processed the period size. It will update the current 1555 * pointer, set up the tick, wake up sleepers, etc. 1556 * 1557 * Even if more than one periods have elapsed since the last call, you 1558 * have to call this only once. 1559 */ 1560 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) 1561 { 1562 struct snd_pcm_runtime *runtime; 1563 unsigned long flags; 1564 1565 snd_assert(substream != NULL, return); 1566 runtime = substream->runtime; 1567 snd_assert(runtime != NULL, return); 1568 1569 if (runtime->transfer_ack_begin) 1570 runtime->transfer_ack_begin(substream); 1571 1572 snd_pcm_stream_lock_irqsave(substream, flags); 1573 if (!snd_pcm_running(substream) || 1574 snd_pcm_update_hw_ptr_interrupt(substream) < 0) 1575 goto _end; 1576 1577 if (substream->timer_running) 1578 snd_timer_interrupt(substream->timer, 1); 1579 if (runtime->sleep_min) 1580 snd_pcm_tick_prepare(substream); 1581 _end: 1582 snd_pcm_stream_unlock_irqrestore(substream, flags); 1583 if (runtime->transfer_ack_end) 1584 runtime->transfer_ack_end(substream); 1585 kill_fasync(&runtime->fasync, SIGIO, POLL_IN); 1586 } 1587 1588 EXPORT_SYMBOL(snd_pcm_period_elapsed); 1589 1590 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, 1591 unsigned int hwoff, 1592 unsigned long data, unsigned int off, 1593 snd_pcm_uframes_t frames) 1594 { 1595 struct snd_pcm_runtime *runtime = substream->runtime; 1596 int err; 1597 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); 1598 if (substream->ops->copy) { 1599 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0) 1600 return err; 1601 } else { 1602 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); 1603 snd_assert(runtime->dma_area, return -EFAULT); 1604 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames))) 1605 return -EFAULT; 1606 } 1607 return 0; 1608 } 1609 1610 typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, 1611 unsigned long data, unsigned int off, 1612 snd_pcm_uframes_t size); 1613 1614 static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, 1615 unsigned long data, 1616 snd_pcm_uframes_t size, 1617 int nonblock, 1618 transfer_f transfer) 1619 { 1620 struct snd_pcm_runtime *runtime = substream->runtime; 1621 snd_pcm_uframes_t xfer = 0; 1622 snd_pcm_uframes_t offset = 0; 1623 int err = 0; 1624 1625 if (size == 0) 1626 return 0; 1627 if (size > runtime->xfer_align) 1628 size -= size % runtime->xfer_align; 1629 1630 snd_pcm_stream_lock_irq(substream); 1631 switch (runtime->status->state) { 1632 case SNDRV_PCM_STATE_PREPARED: 1633 case SNDRV_PCM_STATE_RUNNING: 1634 case SNDRV_PCM_STATE_PAUSED: 1635 break; 1636 case SNDRV_PCM_STATE_XRUN: 1637 err = -EPIPE; 1638 goto _end_unlock; 1639 case SNDRV_PCM_STATE_SUSPENDED: 1640 err = -ESTRPIPE; 1641 goto _end_unlock; 1642 default: 1643 err = -EBADFD; 1644 goto _end_unlock; 1645 } 1646 1647 while (size > 0) { 1648 snd_pcm_uframes_t frames, appl_ptr, appl_ofs; 1649 snd_pcm_uframes_t avail; 1650 snd_pcm_uframes_t cont; 1651 if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING) 1652 snd_pcm_update_hw_ptr(substream); 1653 avail = snd_pcm_playback_avail(runtime); 1654 if (((avail < runtime->control->avail_min && size > avail) || 1655 (size >= runtime->xfer_align && avail < runtime->xfer_align))) { 1656 wait_queue_t wait; 1657 enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state; 1658 long tout; 1659 1660 if (nonblock) { 1661 err = -EAGAIN; 1662 goto _end_unlock; 1663 } 1664 1665 init_waitqueue_entry(&wait, current); 1666 add_wait_queue(&runtime->sleep, &wait); 1667 while (1) { 1668 if (signal_pending(current)) { 1669 state = SIGNALED; 1670 break; 1671 } 1672 set_current_state(TASK_INTERRUPTIBLE); 1673 snd_pcm_stream_unlock_irq(substream); 1674 tout = schedule_timeout(10 * HZ); 1675 snd_pcm_stream_lock_irq(substream); 1676 if (tout == 0) { 1677 if (runtime->status->state != SNDRV_PCM_STATE_PREPARED && 1678 runtime->status->state != SNDRV_PCM_STATE_PAUSED) { 1679 state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED; 1680 break; 1681 } 1682 } 1683 switch (runtime->status->state) { 1684 case SNDRV_PCM_STATE_XRUN: 1685 case SNDRV_PCM_STATE_DRAINING: 1686 state = ERROR; 1687 goto _end_loop; 1688 case SNDRV_PCM_STATE_SUSPENDED: 1689 state = SUSPENDED; 1690 goto _end_loop; 1691 case SNDRV_PCM_STATE_SETUP: 1692 state = DROPPED; 1693 goto _end_loop; 1694 default: 1695 break; 1696 } 1697 avail = snd_pcm_playback_avail(runtime); 1698 if (avail >= runtime->control->avail_min) { 1699 state = READY; 1700 break; 1701 } 1702 } 1703 _end_loop: 1704 remove_wait_queue(&runtime->sleep, &wait); 1705 1706 switch (state) { 1707 case ERROR: 1708 err = -EPIPE; 1709 goto _end_unlock; 1710 case SUSPENDED: 1711 err = -ESTRPIPE; 1712 goto _end_unlock; 1713 case SIGNALED: 1714 err = -ERESTARTSYS; 1715 goto _end_unlock; 1716 case EXPIRED: 1717 snd_printd("playback write error (DMA or IRQ trouble?)\n"); 1718 err = -EIO; 1719 goto _end_unlock; 1720 case DROPPED: 1721 err = -EBADFD; 1722 goto _end_unlock; 1723 default: 1724 break; 1725 } 1726 } 1727 if (avail > runtime->xfer_align) 1728 avail -= avail % runtime->xfer_align; 1729 frames = size > avail ? avail : size; 1730 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size; 1731 if (frames > cont) 1732 frames = cont; 1733 snd_assert(frames != 0, snd_pcm_stream_unlock_irq(substream); return -EINVAL); 1734 appl_ptr = runtime->control->appl_ptr; 1735 appl_ofs = appl_ptr % runtime->buffer_size; 1736 snd_pcm_stream_unlock_irq(substream); 1737 if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0) 1738 goto _end; 1739 snd_pcm_stream_lock_irq(substream); 1740 switch (runtime->status->state) { 1741 case SNDRV_PCM_STATE_XRUN: 1742 err = -EPIPE; 1743 goto _end_unlock; 1744 case SNDRV_PCM_STATE_SUSPENDED: 1745 err = -ESTRPIPE; 1746 goto _end_unlock; 1747 default: 1748 break; 1749 } 1750 appl_ptr += frames; 1751 if (appl_ptr >= runtime->boundary) 1752 appl_ptr -= runtime->boundary; 1753 runtime->control->appl_ptr = appl_ptr; 1754 if (substream->ops->ack) 1755 substream->ops->ack(substream); 1756 1757 offset += frames; 1758 size -= frames; 1759 xfer += frames; 1760 if (runtime->status->state == SNDRV_PCM_STATE_PREPARED && 1761 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) { 1762 err = snd_pcm_start(substream); 1763 if (err < 0) 1764 goto _end_unlock; 1765 } 1766 if (runtime->sleep_min && 1767 runtime->status->state == SNDRV_PCM_STATE_RUNNING) 1768 snd_pcm_tick_prepare(substream); 1769 } 1770 _end_unlock: 1771 snd_pcm_stream_unlock_irq(substream); 1772 _end: 1773 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; 1774 } 1775 1776 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) 1777 { 1778 struct snd_pcm_runtime *runtime; 1779 int nonblock; 1780 1781 snd_assert(substream != NULL, return -ENXIO); 1782 runtime = substream->runtime; 1783 snd_assert(runtime != NULL, return -ENXIO); 1784 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL); 1785 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 1786 return -EBADFD; 1787 1788 nonblock = !!(substream->f_flags & O_NONBLOCK); 1789 1790 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && 1791 runtime->channels > 1) 1792 return -EINVAL; 1793 return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock, 1794 snd_pcm_lib_write_transfer); 1795 } 1796 1797 EXPORT_SYMBOL(snd_pcm_lib_write); 1798 1799 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, 1800 unsigned int hwoff, 1801 unsigned long data, unsigned int off, 1802 snd_pcm_uframes_t frames) 1803 { 1804 struct snd_pcm_runtime *runtime = substream->runtime; 1805 int err; 1806 void __user **bufs = (void __user **)data; 1807 int channels = runtime->channels; 1808 int c; 1809 if (substream->ops->copy) { 1810 snd_assert(substream->ops->silence != NULL, return -EINVAL); 1811 for (c = 0; c < channels; ++c, ++bufs) { 1812 if (*bufs == NULL) { 1813 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0) 1814 return err; 1815 } else { 1816 char __user *buf = *bufs + samples_to_bytes(runtime, off); 1817 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0) 1818 return err; 1819 } 1820 } 1821 } else { 1822 /* default transfer behaviour */ 1823 size_t dma_csize = runtime->dma_bytes / channels; 1824 snd_assert(runtime->dma_area, return -EFAULT); 1825 for (c = 0; c < channels; ++c, ++bufs) { 1826 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); 1827 if (*bufs == NULL) { 1828 snd_pcm_format_set_silence(runtime->format, hwbuf, frames); 1829 } else { 1830 char __user *buf = *bufs + samples_to_bytes(runtime, off); 1831 if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames))) 1832 return -EFAULT; 1833 } 1834 } 1835 } 1836 return 0; 1837 } 1838 1839 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, 1840 void __user **bufs, 1841 snd_pcm_uframes_t frames) 1842 { 1843 struct snd_pcm_runtime *runtime; 1844 int nonblock; 1845 1846 snd_assert(substream != NULL, return -ENXIO); 1847 runtime = substream->runtime; 1848 snd_assert(runtime != NULL, return -ENXIO); 1849 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL); 1850 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 1851 return -EBADFD; 1852 1853 nonblock = !!(substream->f_flags & O_NONBLOCK); 1854 1855 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) 1856 return -EINVAL; 1857 return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames, 1858 nonblock, snd_pcm_lib_writev_transfer); 1859 } 1860 1861 EXPORT_SYMBOL(snd_pcm_lib_writev); 1862 1863 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 1864 unsigned int hwoff, 1865 unsigned long data, unsigned int off, 1866 snd_pcm_uframes_t frames) 1867 { 1868 struct snd_pcm_runtime *runtime = substream->runtime; 1869 int err; 1870 char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); 1871 if (substream->ops->copy) { 1872 if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0) 1873 return err; 1874 } else { 1875 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); 1876 snd_assert(runtime->dma_area, return -EFAULT); 1877 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames))) 1878 return -EFAULT; 1879 } 1880 return 0; 1881 } 1882 1883 static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, 1884 unsigned long data, 1885 snd_pcm_uframes_t size, 1886 int nonblock, 1887 transfer_f transfer) 1888 { 1889 struct snd_pcm_runtime *runtime = substream->runtime; 1890 snd_pcm_uframes_t xfer = 0; 1891 snd_pcm_uframes_t offset = 0; 1892 int err = 0; 1893 1894 if (size == 0) 1895 return 0; 1896 if (size > runtime->xfer_align) 1897 size -= size % runtime->xfer_align; 1898 1899 snd_pcm_stream_lock_irq(substream); 1900 switch (runtime->status->state) { 1901 case SNDRV_PCM_STATE_PREPARED: 1902 if (size >= runtime->start_threshold) { 1903 err = snd_pcm_start(substream); 1904 if (err < 0) 1905 goto _end_unlock; 1906 } 1907 break; 1908 case SNDRV_PCM_STATE_DRAINING: 1909 case SNDRV_PCM_STATE_RUNNING: 1910 case SNDRV_PCM_STATE_PAUSED: 1911 break; 1912 case SNDRV_PCM_STATE_XRUN: 1913 err = -EPIPE; 1914 goto _end_unlock; 1915 case SNDRV_PCM_STATE_SUSPENDED: 1916 err = -ESTRPIPE; 1917 goto _end_unlock; 1918 default: 1919 err = -EBADFD; 1920 goto _end_unlock; 1921 } 1922 1923 while (size > 0) { 1924 snd_pcm_uframes_t frames, appl_ptr, appl_ofs; 1925 snd_pcm_uframes_t avail; 1926 snd_pcm_uframes_t cont; 1927 if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING) 1928 snd_pcm_update_hw_ptr(substream); 1929 __draining: 1930 avail = snd_pcm_capture_avail(runtime); 1931 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) { 1932 if (avail < runtime->xfer_align) { 1933 err = -EPIPE; 1934 goto _end_unlock; 1935 } 1936 } else if ((avail < runtime->control->avail_min && size > avail) || 1937 (size >= runtime->xfer_align && avail < runtime->xfer_align)) { 1938 wait_queue_t wait; 1939 enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state; 1940 long tout; 1941 1942 if (nonblock) { 1943 err = -EAGAIN; 1944 goto _end_unlock; 1945 } 1946 1947 init_waitqueue_entry(&wait, current); 1948 add_wait_queue(&runtime->sleep, &wait); 1949 while (1) { 1950 if (signal_pending(current)) { 1951 state = SIGNALED; 1952 break; 1953 } 1954 set_current_state(TASK_INTERRUPTIBLE); 1955 snd_pcm_stream_unlock_irq(substream); 1956 tout = schedule_timeout(10 * HZ); 1957 snd_pcm_stream_lock_irq(substream); 1958 if (tout == 0) { 1959 if (runtime->status->state != SNDRV_PCM_STATE_PREPARED && 1960 runtime->status->state != SNDRV_PCM_STATE_PAUSED) { 1961 state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED; 1962 break; 1963 } 1964 } 1965 switch (runtime->status->state) { 1966 case SNDRV_PCM_STATE_XRUN: 1967 state = ERROR; 1968 goto _end_loop; 1969 case SNDRV_PCM_STATE_SUSPENDED: 1970 state = SUSPENDED; 1971 goto _end_loop; 1972 case SNDRV_PCM_STATE_DRAINING: 1973 goto __draining; 1974 case SNDRV_PCM_STATE_SETUP: 1975 state = DROPPED; 1976 goto _end_loop; 1977 default: 1978 break; 1979 } 1980 avail = snd_pcm_capture_avail(runtime); 1981 if (avail >= runtime->control->avail_min) { 1982 state = READY; 1983 break; 1984 } 1985 } 1986 _end_loop: 1987 remove_wait_queue(&runtime->sleep, &wait); 1988 1989 switch (state) { 1990 case ERROR: 1991 err = -EPIPE; 1992 goto _end_unlock; 1993 case SUSPENDED: 1994 err = -ESTRPIPE; 1995 goto _end_unlock; 1996 case SIGNALED: 1997 err = -ERESTARTSYS; 1998 goto _end_unlock; 1999 case EXPIRED: 2000 snd_printd("capture read error (DMA or IRQ trouble?)\n"); 2001 err = -EIO; 2002 goto _end_unlock; 2003 case DROPPED: 2004 err = -EBADFD; 2005 goto _end_unlock; 2006 default: 2007 break; 2008 } 2009 } 2010 if (avail > runtime->xfer_align) 2011 avail -= avail % runtime->xfer_align; 2012 frames = size > avail ? avail : size; 2013 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size; 2014 if (frames > cont) 2015 frames = cont; 2016 snd_assert(frames != 0, snd_pcm_stream_unlock_irq(substream); return -EINVAL); 2017 appl_ptr = runtime->control->appl_ptr; 2018 appl_ofs = appl_ptr % runtime->buffer_size; 2019 snd_pcm_stream_unlock_irq(substream); 2020 if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0) 2021 goto _end; 2022 snd_pcm_stream_lock_irq(substream); 2023 switch (runtime->status->state) { 2024 case SNDRV_PCM_STATE_XRUN: 2025 err = -EPIPE; 2026 goto _end_unlock; 2027 case SNDRV_PCM_STATE_SUSPENDED: 2028 err = -ESTRPIPE; 2029 goto _end_unlock; 2030 default: 2031 break; 2032 } 2033 appl_ptr += frames; 2034 if (appl_ptr >= runtime->boundary) 2035 appl_ptr -= runtime->boundary; 2036 runtime->control->appl_ptr = appl_ptr; 2037 if (substream->ops->ack) 2038 substream->ops->ack(substream); 2039 2040 offset += frames; 2041 size -= frames; 2042 xfer += frames; 2043 if (runtime->sleep_min && 2044 runtime->status->state == SNDRV_PCM_STATE_RUNNING) 2045 snd_pcm_tick_prepare(substream); 2046 } 2047 _end_unlock: 2048 snd_pcm_stream_unlock_irq(substream); 2049 _end: 2050 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; 2051 } 2052 2053 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) 2054 { 2055 struct snd_pcm_runtime *runtime; 2056 int nonblock; 2057 2058 snd_assert(substream != NULL, return -ENXIO); 2059 runtime = substream->runtime; 2060 snd_assert(runtime != NULL, return -ENXIO); 2061 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL); 2062 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 2063 return -EBADFD; 2064 2065 nonblock = !!(substream->f_flags & O_NONBLOCK); 2066 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED) 2067 return -EINVAL; 2068 return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); 2069 } 2070 2071 EXPORT_SYMBOL(snd_pcm_lib_read); 2072 2073 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, 2074 unsigned int hwoff, 2075 unsigned long data, unsigned int off, 2076 snd_pcm_uframes_t frames) 2077 { 2078 struct snd_pcm_runtime *runtime = substream->runtime; 2079 int err; 2080 void __user **bufs = (void __user **)data; 2081 int channels = runtime->channels; 2082 int c; 2083 if (substream->ops->copy) { 2084 for (c = 0; c < channels; ++c, ++bufs) { 2085 char __user *buf; 2086 if (*bufs == NULL) 2087 continue; 2088 buf = *bufs + samples_to_bytes(runtime, off); 2089 if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0) 2090 return err; 2091 } 2092 } else { 2093 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; 2094 snd_assert(runtime->dma_area, return -EFAULT); 2095 for (c = 0; c < channels; ++c, ++bufs) { 2096 char *hwbuf; 2097 char __user *buf; 2098 if (*bufs == NULL) 2099 continue; 2100 2101 hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); 2102 buf = *bufs + samples_to_bytes(runtime, off); 2103 if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames))) 2104 return -EFAULT; 2105 } 2106 } 2107 return 0; 2108 } 2109 2110 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, 2111 void __user **bufs, 2112 snd_pcm_uframes_t frames) 2113 { 2114 struct snd_pcm_runtime *runtime; 2115 int nonblock; 2116 2117 snd_assert(substream != NULL, return -ENXIO); 2118 runtime = substream->runtime; 2119 snd_assert(runtime != NULL, return -ENXIO); 2120 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL); 2121 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 2122 return -EBADFD; 2123 2124 nonblock = !!(substream->f_flags & O_NONBLOCK); 2125 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) 2126 return -EINVAL; 2127 return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer); 2128 } 2129 2130 EXPORT_SYMBOL(snd_pcm_lib_readv); 2131