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