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