1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 5 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006 6 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org> 7 * Portions Copyright (c) Luigi Rizzo <luigi@FreeBSD.org> - 1997-99 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include "opt_isa.h" 33 34 #ifdef HAVE_KERNEL_OPTION_HEADERS 35 #include "opt_snd.h" 36 #endif 37 38 #include <dev/sound/pcm/sound.h> 39 #include <dev/sound/pcm/vchan.h> 40 41 #include "feeder_if.h" 42 43 SND_DECLARE_FILE("$FreeBSD$"); 44 45 int report_soft_formats = 1; 46 SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_formats, CTLFLAG_RW, 47 &report_soft_formats, 0, "report software-emulated formats"); 48 49 int report_soft_matrix = 1; 50 SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_matrix, CTLFLAG_RW, 51 &report_soft_matrix, 0, "report software-emulated channel matrixing"); 52 53 int chn_latency = CHN_LATENCY_DEFAULT; 54 55 static int 56 sysctl_hw_snd_latency(SYSCTL_HANDLER_ARGS) 57 { 58 int err, val; 59 60 val = chn_latency; 61 err = sysctl_handle_int(oidp, &val, 0, req); 62 if (err != 0 || req->newptr == NULL) 63 return err; 64 if (val < CHN_LATENCY_MIN || val > CHN_LATENCY_MAX) 65 err = EINVAL; 66 else 67 chn_latency = val; 68 69 return err; 70 } 71 SYSCTL_PROC(_hw_snd, OID_AUTO, latency, 72 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), 73 sysctl_hw_snd_latency, "I", 74 "buffering latency (0=low ... 10=high)"); 75 76 int chn_latency_profile = CHN_LATENCY_PROFILE_DEFAULT; 77 78 static int 79 sysctl_hw_snd_latency_profile(SYSCTL_HANDLER_ARGS) 80 { 81 int err, val; 82 83 val = chn_latency_profile; 84 err = sysctl_handle_int(oidp, &val, 0, req); 85 if (err != 0 || req->newptr == NULL) 86 return err; 87 if (val < CHN_LATENCY_PROFILE_MIN || val > CHN_LATENCY_PROFILE_MAX) 88 err = EINVAL; 89 else 90 chn_latency_profile = val; 91 92 return err; 93 } 94 SYSCTL_PROC(_hw_snd, OID_AUTO, latency_profile, 95 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), 96 sysctl_hw_snd_latency_profile, "I", 97 "buffering latency profile (0=aggressive 1=safe)"); 98 99 static int chn_timeout = CHN_TIMEOUT; 100 101 static int 102 sysctl_hw_snd_timeout(SYSCTL_HANDLER_ARGS) 103 { 104 int err, val; 105 106 val = chn_timeout; 107 err = sysctl_handle_int(oidp, &val, 0, req); 108 if (err != 0 || req->newptr == NULL) 109 return err; 110 if (val < CHN_TIMEOUT_MIN || val > CHN_TIMEOUT_MAX) 111 err = EINVAL; 112 else 113 chn_timeout = val; 114 115 return err; 116 } 117 SYSCTL_PROC(_hw_snd, OID_AUTO, timeout, 118 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), 119 sysctl_hw_snd_timeout, "I", 120 "interrupt timeout (1 - 10) seconds"); 121 122 static int chn_vpc_autoreset = 1; 123 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_autoreset, CTLFLAG_RWTUN, 124 &chn_vpc_autoreset, 0, "automatically reset channels volume to 0db"); 125 126 static int chn_vol_0db_pcm = SND_VOL_0DB_PCM; 127 128 static void 129 chn_vpc_proc(int reset, int db) 130 { 131 struct snddev_info *d; 132 struct pcm_channel *c; 133 int i; 134 135 for (i = 0; pcm_devclass != NULL && 136 i < devclass_get_maxunit(pcm_devclass); i++) { 137 d = devclass_get_softc(pcm_devclass, i); 138 if (!PCM_REGISTERED(d)) 139 continue; 140 PCM_LOCK(d); 141 PCM_WAIT(d); 142 PCM_ACQUIRE(d); 143 CHN_FOREACH(c, d, channels.pcm) { 144 CHN_LOCK(c); 145 CHN_SETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_VOL_0DB, db); 146 if (reset != 0) 147 chn_vpc_reset(c, SND_VOL_C_PCM, 1); 148 CHN_UNLOCK(c); 149 } 150 PCM_RELEASE(d); 151 PCM_UNLOCK(d); 152 } 153 } 154 155 static int 156 sysctl_hw_snd_vpc_0db(SYSCTL_HANDLER_ARGS) 157 { 158 int err, val; 159 160 val = chn_vol_0db_pcm; 161 err = sysctl_handle_int(oidp, &val, 0, req); 162 if (err != 0 || req->newptr == NULL) 163 return (err); 164 if (val < SND_VOL_0DB_MIN || val > SND_VOL_0DB_MAX) 165 return (EINVAL); 166 167 chn_vol_0db_pcm = val; 168 chn_vpc_proc(0, val); 169 170 return (0); 171 } 172 SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_0db, 173 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, 0, sizeof(int), 174 sysctl_hw_snd_vpc_0db, "I", 175 "0db relative level"); 176 177 static int 178 sysctl_hw_snd_vpc_reset(SYSCTL_HANDLER_ARGS) 179 { 180 int err, val; 181 182 val = 0; 183 err = sysctl_handle_int(oidp, &val, 0, req); 184 if (err != 0 || req->newptr == NULL || val == 0) 185 return (err); 186 187 chn_vol_0db_pcm = SND_VOL_0DB_PCM; 188 chn_vpc_proc(1, SND_VOL_0DB_PCM); 189 190 return (0); 191 } 192 SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_reset, 193 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 0, sizeof(int), 194 sysctl_hw_snd_vpc_reset, "I", 195 "reset volume on all channels"); 196 197 static int chn_usefrags = 0; 198 static int chn_syncdelay = -1; 199 200 SYSCTL_INT(_hw_snd, OID_AUTO, usefrags, CTLFLAG_RWTUN, 201 &chn_usefrags, 0, "prefer setfragments() over setblocksize()"); 202 SYSCTL_INT(_hw_snd, OID_AUTO, syncdelay, CTLFLAG_RWTUN, 203 &chn_syncdelay, 0, 204 "append (0-1000) millisecond trailing buffer delay on each sync"); 205 206 /** 207 * @brief Channel sync group lock 208 * 209 * Clients should acquire this lock @b without holding any channel locks 210 * before touching syncgroups or the main syncgroup list. 211 */ 212 struct mtx snd_pcm_syncgroups_mtx; 213 MTX_SYSINIT(pcm_syncgroup, &snd_pcm_syncgroups_mtx, "PCM channel sync group lock", MTX_DEF); 214 /** 215 * @brief syncgroups' master list 216 * 217 * Each time a channel syncgroup is created, it's added to this list. This 218 * list should only be accessed with @sa snd_pcm_syncgroups_mtx held. 219 * 220 * See SNDCTL_DSP_SYNCGROUP for more information. 221 */ 222 struct pcm_synclist snd_pcm_syncgroups = SLIST_HEAD_INITIALIZER(snd_pcm_syncgroups); 223 224 static void 225 chn_lockinit(struct pcm_channel *c, int dir) 226 { 227 switch (dir) { 228 case PCMDIR_PLAY: 229 c->lock = snd_mtxcreate(c->name, "pcm play channel"); 230 cv_init(&c->intr_cv, "pcmwr"); 231 break; 232 case PCMDIR_PLAY_VIRTUAL: 233 c->lock = snd_mtxcreate(c->name, "pcm virtual play channel"); 234 cv_init(&c->intr_cv, "pcmwrv"); 235 break; 236 case PCMDIR_REC: 237 c->lock = snd_mtxcreate(c->name, "pcm record channel"); 238 cv_init(&c->intr_cv, "pcmrd"); 239 break; 240 case PCMDIR_REC_VIRTUAL: 241 c->lock = snd_mtxcreate(c->name, "pcm virtual record channel"); 242 cv_init(&c->intr_cv, "pcmrdv"); 243 break; 244 default: 245 panic("%s(): Invalid direction=%d", __func__, dir); 246 break; 247 } 248 249 cv_init(&c->cv, "pcmchn"); 250 } 251 252 static void 253 chn_lockdestroy(struct pcm_channel *c) 254 { 255 CHN_LOCKASSERT(c); 256 257 CHN_BROADCAST(&c->cv); 258 CHN_BROADCAST(&c->intr_cv); 259 260 cv_destroy(&c->cv); 261 cv_destroy(&c->intr_cv); 262 263 snd_mtxfree(c->lock); 264 } 265 266 /** 267 * @brief Determine channel is ready for I/O 268 * 269 * @retval 1 = ready for I/O 270 * @retval 0 = not ready for I/O 271 */ 272 static int 273 chn_polltrigger(struct pcm_channel *c) 274 { 275 struct snd_dbuf *bs = c->bufsoft; 276 u_int delta; 277 278 CHN_LOCKASSERT(c); 279 280 if (c->flags & CHN_F_MMAP) { 281 if (sndbuf_getprevtotal(bs) < c->lw) 282 delta = c->lw; 283 else 284 delta = sndbuf_gettotal(bs) - sndbuf_getprevtotal(bs); 285 } else { 286 if (c->direction == PCMDIR_PLAY) 287 delta = sndbuf_getfree(bs); 288 else 289 delta = sndbuf_getready(bs); 290 } 291 292 return ((delta < c->lw) ? 0 : 1); 293 } 294 295 static void 296 chn_pollreset(struct pcm_channel *c) 297 { 298 299 CHN_LOCKASSERT(c); 300 sndbuf_updateprevtotal(c->bufsoft); 301 } 302 303 static void 304 chn_wakeup(struct pcm_channel *c) 305 { 306 struct snd_dbuf *bs; 307 struct pcm_channel *ch; 308 309 CHN_LOCKASSERT(c); 310 311 bs = c->bufsoft; 312 313 if (CHN_EMPTY(c, children.busy)) { 314 if (SEL_WAITING(sndbuf_getsel(bs)) && chn_polltrigger(c)) 315 selwakeuppri(sndbuf_getsel(bs), PRIBIO); 316 if (c->flags & CHN_F_SLEEPING) { 317 /* 318 * Ok, I can just panic it right here since it is 319 * quite obvious that we never allow multiple waiters 320 * from userland. I'm too generous... 321 */ 322 CHN_BROADCAST(&c->intr_cv); 323 } 324 } else { 325 CHN_FOREACH(ch, c, children.busy) { 326 CHN_LOCK(ch); 327 chn_wakeup(ch); 328 CHN_UNLOCK(ch); 329 } 330 } 331 } 332 333 static int 334 chn_sleep(struct pcm_channel *c, int timeout) 335 { 336 int ret; 337 338 CHN_LOCKASSERT(c); 339 340 if (c->flags & CHN_F_DEAD) 341 return (EINVAL); 342 343 c->flags |= CHN_F_SLEEPING; 344 ret = cv_timedwait_sig(&c->intr_cv, c->lock, timeout); 345 c->flags &= ~CHN_F_SLEEPING; 346 347 return ((c->flags & CHN_F_DEAD) ? EINVAL : ret); 348 } 349 350 /* 351 * chn_dmaupdate() tracks the status of a dma transfer, 352 * updating pointers. 353 */ 354 355 static unsigned int 356 chn_dmaupdate(struct pcm_channel *c) 357 { 358 struct snd_dbuf *b = c->bufhard; 359 unsigned int delta, old, hwptr, amt; 360 361 KASSERT(sndbuf_getsize(b) > 0, ("bufsize == 0")); 362 CHN_LOCKASSERT(c); 363 364 old = sndbuf_gethwptr(b); 365 hwptr = chn_getptr(c); 366 delta = (sndbuf_getsize(b) + hwptr - old) % sndbuf_getsize(b); 367 sndbuf_sethwptr(b, hwptr); 368 369 if (c->direction == PCMDIR_PLAY) { 370 amt = min(delta, sndbuf_getready(b)); 371 amt -= amt % sndbuf_getalign(b); 372 if (amt > 0) 373 sndbuf_dispose(b, NULL, amt); 374 } else { 375 amt = min(delta, sndbuf_getfree(b)); 376 amt -= amt % sndbuf_getalign(b); 377 if (amt > 0) 378 sndbuf_acquire(b, NULL, amt); 379 } 380 if (snd_verbose > 3 && CHN_STARTED(c) && delta == 0) { 381 device_printf(c->dev, "WARNING: %s DMA completion " 382 "too fast/slow ! hwptr=%u, old=%u " 383 "delta=%u amt=%u ready=%u free=%u\n", 384 CHN_DIRSTR(c), hwptr, old, delta, amt, 385 sndbuf_getready(b), sndbuf_getfree(b)); 386 } 387 388 return delta; 389 } 390 391 static void 392 chn_wrfeed(struct pcm_channel *c) 393 { 394 struct snd_dbuf *b = c->bufhard; 395 struct snd_dbuf *bs = c->bufsoft; 396 unsigned int amt, want, wasfree; 397 398 CHN_LOCKASSERT(c); 399 400 if ((c->flags & CHN_F_MMAP) && !(c->flags & CHN_F_CLOSING)) 401 sndbuf_acquire(bs, NULL, sndbuf_getfree(bs)); 402 403 wasfree = sndbuf_getfree(b); 404 want = min(sndbuf_getsize(b), 405 imax(0, sndbuf_xbytes(sndbuf_getsize(bs), bs, b) - 406 sndbuf_getready(b))); 407 amt = min(wasfree, want); 408 if (amt > 0) 409 sndbuf_feed(bs, b, c, c->feeder, amt); 410 411 /* 412 * Possible xruns. There should be no empty space left in buffer. 413 */ 414 if (sndbuf_getready(b) < want) 415 c->xruns++; 416 417 if (sndbuf_getfree(b) < wasfree) 418 chn_wakeup(c); 419 } 420 421 #if 0 422 static void 423 chn_wrupdate(struct pcm_channel *c) 424 { 425 426 CHN_LOCKASSERT(c); 427 KASSERT(c->direction == PCMDIR_PLAY, ("%s(): bad channel", __func__)); 428 429 if ((c->flags & (CHN_F_MMAP | CHN_F_VIRTUAL)) || CHN_STOPPED(c)) 430 return; 431 chn_dmaupdate(c); 432 chn_wrfeed(c); 433 /* tell the driver we've updated the primary buffer */ 434 chn_trigger(c, PCMTRIG_EMLDMAWR); 435 } 436 #endif 437 438 static void 439 chn_wrintr(struct pcm_channel *c) 440 { 441 442 CHN_LOCKASSERT(c); 443 /* update pointers in primary buffer */ 444 chn_dmaupdate(c); 445 /* ...and feed from secondary to primary */ 446 chn_wrfeed(c); 447 /* tell the driver we've updated the primary buffer */ 448 chn_trigger(c, PCMTRIG_EMLDMAWR); 449 } 450 451 /* 452 * user write routine - uiomove data into secondary buffer, trigger if necessary 453 * if blocking, sleep, rinse and repeat. 454 * 455 * called externally, so must handle locking 456 */ 457 458 int 459 chn_write(struct pcm_channel *c, struct uio *buf) 460 { 461 struct snd_dbuf *bs = c->bufsoft; 462 void *off; 463 int ret, timeout, sz, t, p; 464 465 CHN_LOCKASSERT(c); 466 467 ret = 0; 468 timeout = chn_timeout * hz; 469 470 while (ret == 0 && buf->uio_resid > 0) { 471 sz = min(buf->uio_resid, sndbuf_getfree(bs)); 472 if (sz > 0) { 473 /* 474 * The following assumes that the free space in 475 * the buffer can never be less around the 476 * unlock-uiomove-lock sequence. 477 */ 478 while (ret == 0 && sz > 0) { 479 p = sndbuf_getfreeptr(bs); 480 t = min(sz, sndbuf_getsize(bs) - p); 481 off = sndbuf_getbufofs(bs, p); 482 CHN_UNLOCK(c); 483 ret = uiomove(off, t, buf); 484 CHN_LOCK(c); 485 sz -= t; 486 sndbuf_acquire(bs, NULL, t); 487 } 488 ret = 0; 489 if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) { 490 ret = chn_start(c, 0); 491 if (ret != 0) 492 c->flags |= CHN_F_DEAD; 493 } 494 } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER)) { 495 /** 496 * @todo Evaluate whether EAGAIN is truly desirable. 497 * 4Front drivers behave like this, but I'm 498 * not sure if it at all violates the "write 499 * should be allowed to block" model. 500 * 501 * The idea is that, while set with CHN_F_NOTRIGGER, 502 * a channel isn't playing, *but* without this we 503 * end up with "interrupt timeout / channel dead". 504 */ 505 ret = EAGAIN; 506 } else { 507 ret = chn_sleep(c, timeout); 508 if (ret == EAGAIN) { 509 ret = EINVAL; 510 c->flags |= CHN_F_DEAD; 511 device_printf(c->dev, "%s(): %s: " 512 "play interrupt timeout, channel dead\n", 513 __func__, c->name); 514 } else if (ret == ERESTART || ret == EINTR) 515 c->flags |= CHN_F_ABORTING; 516 } 517 } 518 519 return (ret); 520 } 521 522 /* 523 * Feed new data from the read buffer. Can be called in the bottom half. 524 */ 525 static void 526 chn_rdfeed(struct pcm_channel *c) 527 { 528 struct snd_dbuf *b = c->bufhard; 529 struct snd_dbuf *bs = c->bufsoft; 530 unsigned int amt; 531 532 CHN_LOCKASSERT(c); 533 534 if (c->flags & CHN_F_MMAP) 535 sndbuf_dispose(bs, NULL, sndbuf_getready(bs)); 536 537 amt = sndbuf_getfree(bs); 538 if (amt > 0) 539 sndbuf_feed(b, bs, c, c->feeder, amt); 540 541 amt = sndbuf_getready(b); 542 if (amt > 0) { 543 c->xruns++; 544 sndbuf_dispose(b, NULL, amt); 545 } 546 547 if (sndbuf_getready(bs) > 0) 548 chn_wakeup(c); 549 } 550 551 #if 0 552 static void 553 chn_rdupdate(struct pcm_channel *c) 554 { 555 556 CHN_LOCKASSERT(c); 557 KASSERT(c->direction == PCMDIR_REC, ("chn_rdupdate on bad channel")); 558 559 if ((c->flags & (CHN_F_MMAP | CHN_F_VIRTUAL)) || CHN_STOPPED(c)) 560 return; 561 chn_trigger(c, PCMTRIG_EMLDMARD); 562 chn_dmaupdate(c); 563 chn_rdfeed(c); 564 } 565 #endif 566 567 /* read interrupt routine. Must be called with interrupts blocked. */ 568 static void 569 chn_rdintr(struct pcm_channel *c) 570 { 571 572 CHN_LOCKASSERT(c); 573 /* tell the driver to update the primary buffer if non-dma */ 574 chn_trigger(c, PCMTRIG_EMLDMARD); 575 /* update pointers in primary buffer */ 576 chn_dmaupdate(c); 577 /* ...and feed from primary to secondary */ 578 chn_rdfeed(c); 579 } 580 581 /* 582 * user read routine - trigger if necessary, uiomove data from secondary buffer 583 * if blocking, sleep, rinse and repeat. 584 * 585 * called externally, so must handle locking 586 */ 587 588 int 589 chn_read(struct pcm_channel *c, struct uio *buf) 590 { 591 struct snd_dbuf *bs = c->bufsoft; 592 void *off; 593 int ret, timeout, sz, t, p; 594 595 CHN_LOCKASSERT(c); 596 597 if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) { 598 ret = chn_start(c, 0); 599 if (ret != 0) { 600 c->flags |= CHN_F_DEAD; 601 return (ret); 602 } 603 } 604 605 ret = 0; 606 timeout = chn_timeout * hz; 607 608 while (ret == 0 && buf->uio_resid > 0) { 609 sz = min(buf->uio_resid, sndbuf_getready(bs)); 610 if (sz > 0) { 611 /* 612 * The following assumes that the free space in 613 * the buffer can never be less around the 614 * unlock-uiomove-lock sequence. 615 */ 616 while (ret == 0 && sz > 0) { 617 p = sndbuf_getreadyptr(bs); 618 t = min(sz, sndbuf_getsize(bs) - p); 619 off = sndbuf_getbufofs(bs, p); 620 CHN_UNLOCK(c); 621 ret = uiomove(off, t, buf); 622 CHN_LOCK(c); 623 sz -= t; 624 sndbuf_dispose(bs, NULL, t); 625 } 626 ret = 0; 627 } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER)) 628 ret = EAGAIN; 629 else { 630 ret = chn_sleep(c, timeout); 631 if (ret == EAGAIN) { 632 ret = EINVAL; 633 c->flags |= CHN_F_DEAD; 634 device_printf(c->dev, "%s(): %s: " 635 "record interrupt timeout, channel dead\n", 636 __func__, c->name); 637 } else if (ret == ERESTART || ret == EINTR) 638 c->flags |= CHN_F_ABORTING; 639 } 640 } 641 642 return (ret); 643 } 644 645 void 646 chn_intr_locked(struct pcm_channel *c) 647 { 648 649 CHN_LOCKASSERT(c); 650 651 c->interrupts++; 652 653 if (c->direction == PCMDIR_PLAY) 654 chn_wrintr(c); 655 else 656 chn_rdintr(c); 657 } 658 659 void 660 chn_intr(struct pcm_channel *c) 661 { 662 663 if (CHN_LOCKOWNED(c)) { 664 chn_intr_locked(c); 665 return; 666 } 667 668 CHN_LOCK(c); 669 chn_intr_locked(c); 670 CHN_UNLOCK(c); 671 } 672 673 u_int32_t 674 chn_start(struct pcm_channel *c, int force) 675 { 676 u_int32_t i, j; 677 struct snd_dbuf *b = c->bufhard; 678 struct snd_dbuf *bs = c->bufsoft; 679 int err; 680 681 CHN_LOCKASSERT(c); 682 /* if we're running, or if we're prevented from triggering, bail */ 683 if (CHN_STARTED(c) || ((c->flags & CHN_F_NOTRIGGER) && !force)) 684 return (EINVAL); 685 686 err = 0; 687 688 if (force) { 689 i = 1; 690 j = 0; 691 } else { 692 if (c->direction == PCMDIR_REC) { 693 i = sndbuf_getfree(bs); 694 j = (i > 0) ? 1 : sndbuf_getready(b); 695 } else { 696 if (sndbuf_getfree(bs) == 0) { 697 i = 1; 698 j = 0; 699 } else { 700 struct snd_dbuf *pb; 701 702 pb = CHN_BUF_PARENT(c, b); 703 i = sndbuf_xbytes(sndbuf_getready(bs), bs, pb); 704 j = sndbuf_getalign(pb); 705 } 706 } 707 if (snd_verbose > 3 && CHN_EMPTY(c, children)) 708 device_printf(c->dev, "%s(): %s (%s) threshold " 709 "i=%d j=%d\n", __func__, CHN_DIRSTR(c), 710 (c->flags & CHN_F_VIRTUAL) ? "virtual" : 711 "hardware", i, j); 712 } 713 714 if (i >= j) { 715 c->flags |= CHN_F_TRIGGERED; 716 sndbuf_setrun(b, 1); 717 if (c->flags & CHN_F_CLOSING) 718 c->feedcount = 2; 719 else { 720 c->feedcount = 0; 721 c->interrupts = 0; 722 c->xruns = 0; 723 } 724 if (c->parentchannel == NULL) { 725 if (c->direction == PCMDIR_PLAY) 726 sndbuf_fillsilence_rl(b, 727 sndbuf_xbytes(sndbuf_getsize(bs), bs, b)); 728 if (snd_verbose > 3) 729 device_printf(c->dev, 730 "%s(): %s starting! (%s/%s) " 731 "(ready=%d force=%d i=%d j=%d " 732 "intrtimeout=%u latency=%dms)\n", 733 __func__, 734 (c->flags & CHN_F_HAS_VCHAN) ? 735 "VCHAN PARENT" : "HW", CHN_DIRSTR(c), 736 (c->flags & CHN_F_CLOSING) ? "closing" : 737 "running", 738 sndbuf_getready(b), 739 force, i, j, c->timeout, 740 (sndbuf_getsize(b) * 1000) / 741 (sndbuf_getalign(b) * sndbuf_getspd(b))); 742 } 743 err = chn_trigger(c, PCMTRIG_START); 744 } 745 746 return (err); 747 } 748 749 void 750 chn_resetbuf(struct pcm_channel *c) 751 { 752 struct snd_dbuf *b = c->bufhard; 753 struct snd_dbuf *bs = c->bufsoft; 754 755 c->blocks = 0; 756 sndbuf_reset(b); 757 sndbuf_reset(bs); 758 } 759 760 /* 761 * chn_sync waits until the space in the given channel goes above 762 * a threshold. The threshold is checked against fl or rl respectively. 763 * Assume that the condition can become true, do not check here... 764 */ 765 int 766 chn_sync(struct pcm_channel *c, int threshold) 767 { 768 struct snd_dbuf *b, *bs; 769 int ret, count, hcount, minflush, resid, residp, syncdelay, blksz; 770 u_int32_t cflag; 771 772 CHN_LOCKASSERT(c); 773 774 if (c->direction != PCMDIR_PLAY) 775 return (EINVAL); 776 777 bs = c->bufsoft; 778 779 if ((c->flags & (CHN_F_DEAD | CHN_F_ABORTING)) || 780 (threshold < 1 && sndbuf_getready(bs) < 1)) 781 return (0); 782 783 /* if we haven't yet started and nothing is buffered, else start*/ 784 if (CHN_STOPPED(c)) { 785 if (threshold > 0 || sndbuf_getready(bs) > 0) { 786 ret = chn_start(c, 1); 787 if (ret != 0) 788 return (ret); 789 } else 790 return (0); 791 } 792 793 b = CHN_BUF_PARENT(c, c->bufhard); 794 795 minflush = threshold + sndbuf_xbytes(sndbuf_getready(b), b, bs); 796 797 syncdelay = chn_syncdelay; 798 799 if (syncdelay < 0 && (threshold > 0 || sndbuf_getready(bs) > 0)) 800 minflush += sndbuf_xbytes(sndbuf_getsize(b), b, bs); 801 802 /* 803 * Append (0-1000) millisecond trailing buffer (if needed) 804 * for slower / high latency hardwares (notably USB audio) 805 * to avoid audible truncation. 806 */ 807 if (syncdelay > 0) 808 minflush += (sndbuf_getalign(bs) * sndbuf_getspd(bs) * 809 ((syncdelay > 1000) ? 1000 : syncdelay)) / 1000; 810 811 minflush -= minflush % sndbuf_getalign(bs); 812 813 if (minflush > 0) { 814 threshold = min(minflush, sndbuf_getfree(bs)); 815 sndbuf_clear(bs, threshold); 816 sndbuf_acquire(bs, NULL, threshold); 817 minflush -= threshold; 818 } 819 820 resid = sndbuf_getready(bs); 821 residp = resid; 822 blksz = sndbuf_getblksz(b); 823 if (blksz < 1) { 824 device_printf(c->dev, 825 "%s(): WARNING: blksz < 1 ! maxsize=%d [%d/%d/%d]\n", 826 __func__, sndbuf_getmaxsize(b), sndbuf_getsize(b), 827 sndbuf_getblksz(b), sndbuf_getblkcnt(b)); 828 if (sndbuf_getblkcnt(b) > 0) 829 blksz = sndbuf_getsize(b) / sndbuf_getblkcnt(b); 830 if (blksz < 1) 831 blksz = 1; 832 } 833 count = sndbuf_xbytes(minflush + resid, bs, b) / blksz; 834 hcount = count; 835 ret = 0; 836 837 if (snd_verbose > 3) 838 device_printf(c->dev, "%s(): [begin] timeout=%d count=%d " 839 "minflush=%d resid=%d\n", __func__, c->timeout, count, 840 minflush, resid); 841 842 cflag = c->flags & CHN_F_CLOSING; 843 c->flags |= CHN_F_CLOSING; 844 while (count > 0 && (resid > 0 || minflush > 0)) { 845 ret = chn_sleep(c, c->timeout); 846 if (ret == ERESTART || ret == EINTR) { 847 c->flags |= CHN_F_ABORTING; 848 break; 849 } else if (ret == 0 || ret == EAGAIN) { 850 resid = sndbuf_getready(bs); 851 if (resid == residp) { 852 --count; 853 if (snd_verbose > 3) 854 device_printf(c->dev, 855 "%s(): [stalled] timeout=%d " 856 "count=%d hcount=%d " 857 "resid=%d minflush=%d\n", 858 __func__, c->timeout, count, 859 hcount, resid, minflush); 860 } else if (resid < residp && count < hcount) { 861 ++count; 862 if (snd_verbose > 3) 863 device_printf(c->dev, 864 "%s((): [resume] timeout=%d " 865 "count=%d hcount=%d " 866 "resid=%d minflush=%d\n", 867 __func__, c->timeout, count, 868 hcount, resid, minflush); 869 } 870 if (minflush > 0 && sndbuf_getfree(bs) > 0) { 871 threshold = min(minflush, 872 sndbuf_getfree(bs)); 873 sndbuf_clear(bs, threshold); 874 sndbuf_acquire(bs, NULL, threshold); 875 resid = sndbuf_getready(bs); 876 minflush -= threshold; 877 } 878 residp = resid; 879 } else 880 break; 881 } 882 c->flags &= ~CHN_F_CLOSING; 883 c->flags |= cflag; 884 885 if (snd_verbose > 3) 886 device_printf(c->dev, 887 "%s(): timeout=%d count=%d hcount=%d resid=%d residp=%d " 888 "minflush=%d ret=%d\n", 889 __func__, c->timeout, count, hcount, resid, residp, 890 minflush, ret); 891 892 return (0); 893 } 894 895 /* called externally, handle locking */ 896 int 897 chn_poll(struct pcm_channel *c, int ev, struct thread *td) 898 { 899 struct snd_dbuf *bs = c->bufsoft; 900 int ret; 901 902 CHN_LOCKASSERT(c); 903 904 if (!(c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED))) { 905 ret = chn_start(c, 1); 906 if (ret != 0) 907 return (0); 908 } 909 910 ret = 0; 911 if (chn_polltrigger(c)) { 912 chn_pollreset(c); 913 ret = ev; 914 } else 915 selrecord(td, sndbuf_getsel(bs)); 916 917 return (ret); 918 } 919 920 /* 921 * chn_abort terminates a running dma transfer. it may sleep up to 200ms. 922 * it returns the number of bytes that have not been transferred. 923 * 924 * called from: dsp_close, dsp_ioctl, with channel locked 925 */ 926 int 927 chn_abort(struct pcm_channel *c) 928 { 929 int missing = 0; 930 struct snd_dbuf *b = c->bufhard; 931 struct snd_dbuf *bs = c->bufsoft; 932 933 CHN_LOCKASSERT(c); 934 if (CHN_STOPPED(c)) 935 return 0; 936 c->flags |= CHN_F_ABORTING; 937 938 c->flags &= ~CHN_F_TRIGGERED; 939 /* kill the channel */ 940 chn_trigger(c, PCMTRIG_ABORT); 941 sndbuf_setrun(b, 0); 942 if (!(c->flags & CHN_F_VIRTUAL)) 943 chn_dmaupdate(c); 944 missing = sndbuf_getready(bs); 945 946 c->flags &= ~CHN_F_ABORTING; 947 return missing; 948 } 949 950 /* 951 * this routine tries to flush the dma transfer. It is called 952 * on a close of a playback channel. 953 * first, if there is data in the buffer, but the dma has not yet 954 * begun, we need to start it. 955 * next, we wait for the play buffer to drain 956 * finally, we stop the dma. 957 * 958 * called from: dsp_close, not valid for record channels. 959 */ 960 961 int 962 chn_flush(struct pcm_channel *c) 963 { 964 struct snd_dbuf *b = c->bufhard; 965 966 CHN_LOCKASSERT(c); 967 KASSERT(c->direction == PCMDIR_PLAY, ("chn_flush on bad channel")); 968 DEB(printf("chn_flush: c->flags 0x%08x\n", c->flags)); 969 970 c->flags |= CHN_F_CLOSING; 971 chn_sync(c, 0); 972 c->flags &= ~CHN_F_TRIGGERED; 973 /* kill the channel */ 974 chn_trigger(c, PCMTRIG_ABORT); 975 sndbuf_setrun(b, 0); 976 977 c->flags &= ~CHN_F_CLOSING; 978 return 0; 979 } 980 981 int 982 snd_fmtvalid(uint32_t fmt, uint32_t *fmtlist) 983 { 984 int i; 985 986 for (i = 0; fmtlist[i] != 0; i++) { 987 if (fmt == fmtlist[i] || 988 ((fmt & AFMT_PASSTHROUGH) && 989 (AFMT_ENCODING(fmt) & fmtlist[i]))) 990 return (1); 991 } 992 993 return (0); 994 } 995 996 static const struct { 997 char *name, *alias1, *alias2; 998 uint32_t afmt; 999 } afmt_tab[] = { 1000 { "alaw", NULL, NULL, AFMT_A_LAW }, 1001 { "mulaw", NULL, NULL, AFMT_MU_LAW }, 1002 { "u8", "8", NULL, AFMT_U8 }, 1003 { "s8", NULL, NULL, AFMT_S8 }, 1004 #if BYTE_ORDER == LITTLE_ENDIAN 1005 { "s16le", "s16", "16", AFMT_S16_LE }, 1006 { "s16be", NULL, NULL, AFMT_S16_BE }, 1007 #else 1008 { "s16le", NULL, NULL, AFMT_S16_LE }, 1009 { "s16be", "s16", "16", AFMT_S16_BE }, 1010 #endif 1011 { "u16le", NULL, NULL, AFMT_U16_LE }, 1012 { "u16be", NULL, NULL, AFMT_U16_BE }, 1013 { "s24le", NULL, NULL, AFMT_S24_LE }, 1014 { "s24be", NULL, NULL, AFMT_S24_BE }, 1015 { "u24le", NULL, NULL, AFMT_U24_LE }, 1016 { "u24be", NULL, NULL, AFMT_U24_BE }, 1017 #if BYTE_ORDER == LITTLE_ENDIAN 1018 { "s32le", "s32", "32", AFMT_S32_LE }, 1019 { "s32be", NULL, NULL, AFMT_S32_BE }, 1020 #else 1021 { "s32le", NULL, NULL, AFMT_S32_LE }, 1022 { "s32be", "s32", "32", AFMT_S32_BE }, 1023 #endif 1024 { "u32le", NULL, NULL, AFMT_U32_LE }, 1025 { "u32be", NULL, NULL, AFMT_U32_BE }, 1026 { "ac3", NULL, NULL, AFMT_AC3 }, 1027 { NULL, NULL, NULL, 0 } 1028 }; 1029 1030 uint32_t 1031 snd_str2afmt(const char *req) 1032 { 1033 int ext; 1034 int ch; 1035 int i; 1036 char b1[8]; 1037 char b2[8]; 1038 1039 memset(b1, 0, sizeof(b1)); 1040 memset(b2, 0, sizeof(b2)); 1041 1042 i = sscanf(req, "%5[^:]:%6s", b1, b2); 1043 1044 if (i == 1) { 1045 if (strlen(req) != strlen(b1)) 1046 return (0); 1047 strlcpy(b2, "2.0", sizeof(b2)); 1048 } else if (i == 2) { 1049 if (strlen(req) != (strlen(b1) + 1 + strlen(b2))) 1050 return (0); 1051 } else 1052 return (0); 1053 1054 i = sscanf(b2, "%d.%d", &ch, &ext); 1055 1056 if (i == 0) { 1057 if (strcasecmp(b2, "mono") == 0) { 1058 ch = 1; 1059 ext = 0; 1060 } else if (strcasecmp(b2, "stereo") == 0) { 1061 ch = 2; 1062 ext = 0; 1063 } else if (strcasecmp(b2, "quad") == 0) { 1064 ch = 4; 1065 ext = 0; 1066 } else 1067 return (0); 1068 } else if (i == 1) { 1069 if (ch < 1 || ch > AFMT_CHANNEL_MAX) 1070 return (0); 1071 ext = 0; 1072 } else if (i == 2) { 1073 if (ext < 0 || ext > AFMT_EXTCHANNEL_MAX) 1074 return (0); 1075 if (ch < 1 || (ch + ext) > AFMT_CHANNEL_MAX) 1076 return (0); 1077 } else 1078 return (0); 1079 1080 for (i = 0; afmt_tab[i].name != NULL; i++) { 1081 if (strcasecmp(afmt_tab[i].name, b1) != 0) { 1082 if (afmt_tab[i].alias1 == NULL) 1083 continue; 1084 if (strcasecmp(afmt_tab[i].alias1, b1) != 0) { 1085 if (afmt_tab[i].alias2 == NULL) 1086 continue; 1087 if (strcasecmp(afmt_tab[i].alias2, b1) != 0) 1088 continue; 1089 } 1090 } 1091 /* found a match */ 1092 return (SND_FORMAT(afmt_tab[i].afmt, ch + ext, ext)); 1093 } 1094 /* not a valid format */ 1095 return (0); 1096 } 1097 1098 uint32_t 1099 snd_afmt2str(uint32_t afmt, char *buf, size_t len) 1100 { 1101 uint32_t enc; 1102 uint32_t ext; 1103 uint32_t ch; 1104 int i; 1105 1106 if (buf == NULL || len < AFMTSTR_LEN) 1107 return (0); 1108 1109 memset(buf, 0, len); 1110 1111 enc = AFMT_ENCODING(afmt); 1112 ch = AFMT_CHANNEL(afmt); 1113 ext = AFMT_EXTCHANNEL(afmt); 1114 /* check there is at least one channel */ 1115 if (ch <= ext) 1116 return (0); 1117 for (i = 0; afmt_tab[i].name != NULL; i++) { 1118 if (enc != afmt_tab[i].afmt) 1119 continue; 1120 /* found a match */ 1121 snprintf(buf, len, "%s:%d.%d", 1122 afmt_tab[i].name, ch - ext, ext); 1123 return (SND_FORMAT(enc, ch, ext)); 1124 } 1125 return (0); 1126 } 1127 1128 int 1129 chn_reset(struct pcm_channel *c, uint32_t fmt, uint32_t spd) 1130 { 1131 int r; 1132 1133 CHN_LOCKASSERT(c); 1134 c->feedcount = 0; 1135 c->flags &= CHN_F_RESET; 1136 c->interrupts = 0; 1137 c->timeout = 1; 1138 c->xruns = 0; 1139 1140 c->flags |= (pcm_getflags(c->dev) & SD_F_BITPERFECT) ? 1141 CHN_F_BITPERFECT : 0; 1142 1143 r = CHANNEL_RESET(c->methods, c->devinfo); 1144 if (r == 0 && fmt != 0 && spd != 0) { 1145 r = chn_setparam(c, fmt, spd); 1146 fmt = 0; 1147 spd = 0; 1148 } 1149 if (r == 0 && fmt != 0) 1150 r = chn_setformat(c, fmt); 1151 if (r == 0 && spd != 0) 1152 r = chn_setspeed(c, spd); 1153 if (r == 0) 1154 r = chn_setlatency(c, chn_latency); 1155 if (r == 0) { 1156 chn_resetbuf(c); 1157 r = CHANNEL_RESETDONE(c->methods, c->devinfo); 1158 } 1159 return r; 1160 } 1161 1162 int 1163 chn_init(struct pcm_channel *c, void *devinfo, int dir, int direction) 1164 { 1165 struct feeder_class *fc; 1166 struct snd_dbuf *b, *bs; 1167 int i, ret; 1168 1169 if (chn_timeout < CHN_TIMEOUT_MIN || chn_timeout > CHN_TIMEOUT_MAX) 1170 chn_timeout = CHN_TIMEOUT; 1171 1172 chn_lockinit(c, dir); 1173 1174 b = NULL; 1175 bs = NULL; 1176 CHN_INIT(c, children); 1177 CHN_INIT(c, children.busy); 1178 c->devinfo = NULL; 1179 c->feeder = NULL; 1180 c->latency = -1; 1181 c->timeout = 1; 1182 1183 ret = ENOMEM; 1184 b = sndbuf_create(c->dev, c->name, "primary", c); 1185 if (b == NULL) 1186 goto out; 1187 bs = sndbuf_create(c->dev, c->name, "secondary", c); 1188 if (bs == NULL) 1189 goto out; 1190 1191 CHN_LOCK(c); 1192 1193 ret = EINVAL; 1194 fc = feeder_getclass(NULL); 1195 if (fc == NULL) 1196 goto out; 1197 if (chn_addfeeder(c, fc, NULL)) 1198 goto out; 1199 1200 /* 1201 * XXX - sndbuf_setup() & sndbuf_resize() expect to be called 1202 * with the channel unlocked because they are also called 1203 * from driver methods that don't know about locking 1204 */ 1205 CHN_UNLOCK(c); 1206 sndbuf_setup(bs, NULL, 0); 1207 CHN_LOCK(c); 1208 c->bufhard = b; 1209 c->bufsoft = bs; 1210 c->flags = 0; 1211 c->feederflags = 0; 1212 c->sm = NULL; 1213 c->format = SND_FORMAT(AFMT_U8, 1, 0); 1214 c->speed = DSP_DEFAULT_SPEED; 1215 1216 c->matrix = *feeder_matrix_id_map(SND_CHN_MATRIX_1_0); 1217 c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL; 1218 1219 for (i = 0; i < SND_CHN_T_MAX; i++) { 1220 c->volume[SND_VOL_C_MASTER][i] = SND_VOL_0DB_MASTER; 1221 } 1222 1223 c->volume[SND_VOL_C_MASTER][SND_CHN_T_VOL_0DB] = SND_VOL_0DB_MASTER; 1224 c->volume[SND_VOL_C_PCM][SND_CHN_T_VOL_0DB] = chn_vol_0db_pcm; 1225 1226 memset(c->muted, 0, sizeof(c->muted)); 1227 1228 chn_vpc_reset(c, SND_VOL_C_PCM, 1); 1229 1230 ret = ENODEV; 1231 CHN_UNLOCK(c); /* XXX - Unlock for CHANNEL_INIT() malloc() call */ 1232 c->devinfo = CHANNEL_INIT(c->methods, devinfo, b, c, direction); 1233 CHN_LOCK(c); 1234 if (c->devinfo == NULL) 1235 goto out; 1236 1237 ret = ENOMEM; 1238 if ((sndbuf_getsize(b) == 0) && ((c->flags & CHN_F_VIRTUAL) == 0)) 1239 goto out; 1240 1241 ret = 0; 1242 c->direction = direction; 1243 1244 sndbuf_setfmt(b, c->format); 1245 sndbuf_setspd(b, c->speed); 1246 sndbuf_setfmt(bs, c->format); 1247 sndbuf_setspd(bs, c->speed); 1248 1249 /** 1250 * @todo Should this be moved somewhere else? The primary buffer 1251 * is allocated by the driver or via DMA map setup, and tmpbuf 1252 * seems to only come into existence in sndbuf_resize(). 1253 */ 1254 if (c->direction == PCMDIR_PLAY) { 1255 bs->sl = sndbuf_getmaxsize(bs); 1256 bs->shadbuf = malloc(bs->sl, M_DEVBUF, M_NOWAIT); 1257 if (bs->shadbuf == NULL) { 1258 ret = ENOMEM; 1259 goto out; 1260 } 1261 } 1262 1263 out: 1264 CHN_UNLOCK(c); 1265 if (ret) { 1266 if (c->devinfo) { 1267 if (CHANNEL_FREE(c->methods, c->devinfo)) 1268 sndbuf_free(b); 1269 } 1270 if (bs) 1271 sndbuf_destroy(bs); 1272 if (b) 1273 sndbuf_destroy(b); 1274 CHN_LOCK(c); 1275 c->flags |= CHN_F_DEAD; 1276 chn_lockdestroy(c); 1277 1278 return ret; 1279 } 1280 1281 return 0; 1282 } 1283 1284 int 1285 chn_kill(struct pcm_channel *c) 1286 { 1287 struct snd_dbuf *b = c->bufhard; 1288 struct snd_dbuf *bs = c->bufsoft; 1289 1290 if (CHN_STARTED(c)) { 1291 CHN_LOCK(c); 1292 chn_trigger(c, PCMTRIG_ABORT); 1293 CHN_UNLOCK(c); 1294 } 1295 while (chn_removefeeder(c) == 0) 1296 ; 1297 if (CHANNEL_FREE(c->methods, c->devinfo)) 1298 sndbuf_free(b); 1299 sndbuf_destroy(bs); 1300 sndbuf_destroy(b); 1301 CHN_LOCK(c); 1302 c->flags |= CHN_F_DEAD; 1303 chn_lockdestroy(c); 1304 1305 return (0); 1306 } 1307 1308 /* XXX Obsolete. Use *_matrix() variant instead. */ 1309 int 1310 chn_setvolume(struct pcm_channel *c, int left, int right) 1311 { 1312 int ret; 1313 1314 ret = chn_setvolume_matrix(c, SND_VOL_C_MASTER, SND_CHN_T_FL, left); 1315 ret |= chn_setvolume_matrix(c, SND_VOL_C_MASTER, SND_CHN_T_FR, 1316 right) << 8; 1317 1318 return (ret); 1319 } 1320 1321 int 1322 chn_setvolume_multi(struct pcm_channel *c, int vc, int left, int right, 1323 int center) 1324 { 1325 int i, ret; 1326 1327 ret = 0; 1328 1329 for (i = 0; i < SND_CHN_T_MAX; i++) { 1330 if ((1 << i) & SND_CHN_LEFT_MASK) 1331 ret |= chn_setvolume_matrix(c, vc, i, left); 1332 else if ((1 << i) & SND_CHN_RIGHT_MASK) 1333 ret |= chn_setvolume_matrix(c, vc, i, right) << 8; 1334 else 1335 ret |= chn_setvolume_matrix(c, vc, i, center) << 16; 1336 } 1337 1338 return (ret); 1339 } 1340 1341 int 1342 chn_setvolume_matrix(struct pcm_channel *c, int vc, int vt, int val) 1343 { 1344 int i; 1345 1346 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX && 1347 (vc == SND_VOL_C_MASTER || (vc & 1)) && 1348 (vt == SND_CHN_T_VOL_0DB || (vt >= SND_CHN_T_BEGIN && 1349 vt <= SND_CHN_T_END)) && (vt != SND_CHN_T_VOL_0DB || 1350 (val >= SND_VOL_0DB_MIN && val <= SND_VOL_0DB_MAX)), 1351 ("%s(): invalid volume matrix c=%p vc=%d vt=%d val=%d", 1352 __func__, c, vc, vt, val)); 1353 CHN_LOCKASSERT(c); 1354 1355 if (val < 0) 1356 val = 0; 1357 if (val > 100) 1358 val = 100; 1359 1360 c->volume[vc][vt] = val; 1361 1362 /* 1363 * Do relative calculation here and store it into class + 1 1364 * to ease the job of feeder_volume. 1365 */ 1366 if (vc == SND_VOL_C_MASTER) { 1367 for (vc = SND_VOL_C_BEGIN; vc <= SND_VOL_C_END; 1368 vc += SND_VOL_C_STEP) 1369 c->volume[SND_VOL_C_VAL(vc)][vt] = 1370 SND_VOL_CALC_VAL(c->volume, vc, vt); 1371 } else if (vc & 1) { 1372 if (vt == SND_CHN_T_VOL_0DB) 1373 for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END; 1374 i += SND_CHN_T_STEP) { 1375 c->volume[SND_VOL_C_VAL(vc)][i] = 1376 SND_VOL_CALC_VAL(c->volume, vc, i); 1377 } 1378 else 1379 c->volume[SND_VOL_C_VAL(vc)][vt] = 1380 SND_VOL_CALC_VAL(c->volume, vc, vt); 1381 } 1382 1383 return (val); 1384 } 1385 1386 int 1387 chn_getvolume_matrix(struct pcm_channel *c, int vc, int vt) 1388 { 1389 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX && 1390 (vt == SND_CHN_T_VOL_0DB || 1391 (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)), 1392 ("%s(): invalid volume matrix c=%p vc=%d vt=%d", 1393 __func__, c, vc, vt)); 1394 CHN_LOCKASSERT(c); 1395 1396 return (c->volume[vc][vt]); 1397 } 1398 1399 int 1400 chn_setmute_multi(struct pcm_channel *c, int vc, int mute) 1401 { 1402 int i, ret; 1403 1404 ret = 0; 1405 1406 for (i = 0; i < SND_CHN_T_MAX; i++) { 1407 if ((1 << i) & SND_CHN_LEFT_MASK) 1408 ret |= chn_setmute_matrix(c, vc, i, mute); 1409 else if ((1 << i) & SND_CHN_RIGHT_MASK) 1410 ret |= chn_setmute_matrix(c, vc, i, mute) << 8; 1411 else 1412 ret |= chn_setmute_matrix(c, vc, i, mute) << 16; 1413 } 1414 return (ret); 1415 } 1416 1417 int 1418 chn_setmute_matrix(struct pcm_channel *c, int vc, int vt, int mute) 1419 { 1420 int i; 1421 1422 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX && 1423 (vc == SND_VOL_C_MASTER || (vc & 1)) && 1424 (vt == SND_CHN_T_VOL_0DB || (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)), 1425 ("%s(): invalid mute matrix c=%p vc=%d vt=%d mute=%d", 1426 __func__, c, vc, vt, mute)); 1427 1428 CHN_LOCKASSERT(c); 1429 1430 mute = (mute != 0); 1431 1432 c->muted[vc][vt] = mute; 1433 1434 /* 1435 * Do relative calculation here and store it into class + 1 1436 * to ease the job of feeder_volume. 1437 */ 1438 if (vc == SND_VOL_C_MASTER) { 1439 for (vc = SND_VOL_C_BEGIN; vc <= SND_VOL_C_END; 1440 vc += SND_VOL_C_STEP) 1441 c->muted[SND_VOL_C_VAL(vc)][vt] = mute; 1442 } else if (vc & 1) { 1443 if (vt == SND_CHN_T_VOL_0DB) { 1444 for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END; 1445 i += SND_CHN_T_STEP) { 1446 c->muted[SND_VOL_C_VAL(vc)][i] = mute; 1447 } 1448 } else { 1449 c->muted[SND_VOL_C_VAL(vc)][vt] = mute; 1450 } 1451 } 1452 return (mute); 1453 } 1454 1455 int 1456 chn_getmute_matrix(struct pcm_channel *c, int vc, int vt) 1457 { 1458 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX && 1459 (vt == SND_CHN_T_VOL_0DB || 1460 (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)), 1461 ("%s(): invalid mute matrix c=%p vc=%d vt=%d", 1462 __func__, c, vc, vt)); 1463 CHN_LOCKASSERT(c); 1464 1465 return (c->muted[vc][vt]); 1466 } 1467 1468 struct pcmchan_matrix * 1469 chn_getmatrix(struct pcm_channel *c) 1470 { 1471 1472 KASSERT(c != NULL, ("%s(): NULL channel", __func__)); 1473 CHN_LOCKASSERT(c); 1474 1475 if (!(c->format & AFMT_CONVERTIBLE)) 1476 return (NULL); 1477 1478 return (&c->matrix); 1479 } 1480 1481 int 1482 chn_setmatrix(struct pcm_channel *c, struct pcmchan_matrix *m) 1483 { 1484 1485 KASSERT(c != NULL && m != NULL, 1486 ("%s(): NULL channel or matrix", __func__)); 1487 CHN_LOCKASSERT(c); 1488 1489 if (!(c->format & AFMT_CONVERTIBLE)) 1490 return (EINVAL); 1491 1492 c->matrix = *m; 1493 c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL; 1494 1495 return (chn_setformat(c, SND_FORMAT(c->format, m->channels, m->ext))); 1496 } 1497 1498 /* 1499 * XXX chn_oss_* exists for the sake of compatibility. 1500 */ 1501 int 1502 chn_oss_getorder(struct pcm_channel *c, unsigned long long *map) 1503 { 1504 1505 KASSERT(c != NULL && map != NULL, 1506 ("%s(): NULL channel or map", __func__)); 1507 CHN_LOCKASSERT(c); 1508 1509 if (!(c->format & AFMT_CONVERTIBLE)) 1510 return (EINVAL); 1511 1512 return (feeder_matrix_oss_get_channel_order(&c->matrix, map)); 1513 } 1514 1515 int 1516 chn_oss_setorder(struct pcm_channel *c, unsigned long long *map) 1517 { 1518 struct pcmchan_matrix m; 1519 int ret; 1520 1521 KASSERT(c != NULL && map != NULL, 1522 ("%s(): NULL channel or map", __func__)); 1523 CHN_LOCKASSERT(c); 1524 1525 if (!(c->format & AFMT_CONVERTIBLE)) 1526 return (EINVAL); 1527 1528 m = c->matrix; 1529 ret = feeder_matrix_oss_set_channel_order(&m, map); 1530 if (ret != 0) 1531 return (ret); 1532 1533 return (chn_setmatrix(c, &m)); 1534 } 1535 1536 #define SND_CHN_OSS_FRONT (SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FR) 1537 #define SND_CHN_OSS_SURR (SND_CHN_T_MASK_SL | SND_CHN_T_MASK_SR) 1538 #define SND_CHN_OSS_CENTER_LFE (SND_CHN_T_MASK_FC | SND_CHN_T_MASK_LF) 1539 #define SND_CHN_OSS_REAR (SND_CHN_T_MASK_BL | SND_CHN_T_MASK_BR) 1540 1541 int 1542 chn_oss_getmask(struct pcm_channel *c, uint32_t *retmask) 1543 { 1544 struct pcmchan_matrix *m; 1545 struct pcmchan_caps *caps; 1546 uint32_t i, format; 1547 1548 KASSERT(c != NULL && retmask != NULL, 1549 ("%s(): NULL channel or retmask", __func__)); 1550 CHN_LOCKASSERT(c); 1551 1552 caps = chn_getcaps(c); 1553 if (caps == NULL || caps->fmtlist == NULL) 1554 return (ENODEV); 1555 1556 for (i = 0; caps->fmtlist[i] != 0; i++) { 1557 format = caps->fmtlist[i]; 1558 if (!(format & AFMT_CONVERTIBLE)) { 1559 *retmask |= DSP_BIND_SPDIF; 1560 continue; 1561 } 1562 m = CHANNEL_GETMATRIX(c->methods, c->devinfo, format); 1563 if (m == NULL) 1564 continue; 1565 if (m->mask & SND_CHN_OSS_FRONT) 1566 *retmask |= DSP_BIND_FRONT; 1567 if (m->mask & SND_CHN_OSS_SURR) 1568 *retmask |= DSP_BIND_SURR; 1569 if (m->mask & SND_CHN_OSS_CENTER_LFE) 1570 *retmask |= DSP_BIND_CENTER_LFE; 1571 if (m->mask & SND_CHN_OSS_REAR) 1572 *retmask |= DSP_BIND_REAR; 1573 } 1574 1575 /* report software-supported binding mask */ 1576 if (!CHN_BITPERFECT(c) && report_soft_matrix) 1577 *retmask |= DSP_BIND_FRONT | DSP_BIND_SURR | 1578 DSP_BIND_CENTER_LFE | DSP_BIND_REAR; 1579 1580 return (0); 1581 } 1582 1583 void 1584 chn_vpc_reset(struct pcm_channel *c, int vc, int force) 1585 { 1586 int i; 1587 1588 KASSERT(c != NULL && vc >= SND_VOL_C_BEGIN && vc <= SND_VOL_C_END, 1589 ("%s(): invalid reset c=%p vc=%d", __func__, c, vc)); 1590 CHN_LOCKASSERT(c); 1591 1592 if (force == 0 && chn_vpc_autoreset == 0) 1593 return; 1594 1595 for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END; i += SND_CHN_T_STEP) 1596 CHN_SETVOLUME(c, vc, i, c->volume[vc][SND_CHN_T_VOL_0DB]); 1597 } 1598 1599 static u_int32_t 1600 round_pow2(u_int32_t v) 1601 { 1602 u_int32_t ret; 1603 1604 if (v < 2) 1605 v = 2; 1606 ret = 0; 1607 while (v >> ret) 1608 ret++; 1609 ret = 1 << (ret - 1); 1610 while (ret < v) 1611 ret <<= 1; 1612 return ret; 1613 } 1614 1615 static u_int32_t 1616 round_blksz(u_int32_t v, int round) 1617 { 1618 u_int32_t ret, tmp; 1619 1620 if (round < 1) 1621 round = 1; 1622 1623 ret = min(round_pow2(v), CHN_2NDBUFMAXSIZE >> 1); 1624 1625 if (ret > v && (ret >> 1) > 0 && (ret >> 1) >= ((v * 3) >> 2)) 1626 ret >>= 1; 1627 1628 tmp = ret - (ret % round); 1629 while (tmp < 16 || tmp < round) { 1630 ret <<= 1; 1631 tmp = ret - (ret % round); 1632 } 1633 1634 return ret; 1635 } 1636 1637 /* 1638 * 4Front call it DSP Policy, while we call it "Latency Profile". The idea 1639 * is to keep 2nd buffer short so that it doesn't cause long queue during 1640 * buffer transfer. 1641 * 1642 * Latency reference table for 48khz stereo 16bit: (PLAY) 1643 * 1644 * +---------+------------+-----------+------------+ 1645 * | Latency | Blockcount | Blocksize | Buffersize | 1646 * +---------+------------+-----------+------------+ 1647 * | 0 | 2 | 64 | 128 | 1648 * +---------+------------+-----------+------------+ 1649 * | 1 | 4 | 128 | 512 | 1650 * +---------+------------+-----------+------------+ 1651 * | 2 | 8 | 512 | 4096 | 1652 * +---------+------------+-----------+------------+ 1653 * | 3 | 16 | 512 | 8192 | 1654 * +---------+------------+-----------+------------+ 1655 * | 4 | 32 | 512 | 16384 | 1656 * +---------+------------+-----------+------------+ 1657 * | 5 | 32 | 1024 | 32768 | 1658 * +---------+------------+-----------+------------+ 1659 * | 6 | 16 | 2048 | 32768 | 1660 * +---------+------------+-----------+------------+ 1661 * | 7 | 8 | 4096 | 32768 | 1662 * +---------+------------+-----------+------------+ 1663 * | 8 | 4 | 8192 | 32768 | 1664 * +---------+------------+-----------+------------+ 1665 * | 9 | 2 | 16384 | 32768 | 1666 * +---------+------------+-----------+------------+ 1667 * | 10 | 2 | 32768 | 65536 | 1668 * +---------+------------+-----------+------------+ 1669 * 1670 * Recording need a different reference table. All we care is 1671 * gobbling up everything within reasonable buffering threshold. 1672 * 1673 * Latency reference table for 48khz stereo 16bit: (REC) 1674 * 1675 * +---------+------------+-----------+------------+ 1676 * | Latency | Blockcount | Blocksize | Buffersize | 1677 * +---------+------------+-----------+------------+ 1678 * | 0 | 512 | 32 | 16384 | 1679 * +---------+------------+-----------+------------+ 1680 * | 1 | 256 | 64 | 16384 | 1681 * +---------+------------+-----------+------------+ 1682 * | 2 | 128 | 128 | 16384 | 1683 * +---------+------------+-----------+------------+ 1684 * | 3 | 64 | 256 | 16384 | 1685 * +---------+------------+-----------+------------+ 1686 * | 4 | 32 | 512 | 16384 | 1687 * +---------+------------+-----------+------------+ 1688 * | 5 | 32 | 1024 | 32768 | 1689 * +---------+------------+-----------+------------+ 1690 * | 6 | 16 | 2048 | 32768 | 1691 * +---------+------------+-----------+------------+ 1692 * | 7 | 8 | 4096 | 32768 | 1693 * +---------+------------+-----------+------------+ 1694 * | 8 | 4 | 8192 | 32768 | 1695 * +---------+------------+-----------+------------+ 1696 * | 9 | 2 | 16384 | 32768 | 1697 * +---------+------------+-----------+------------+ 1698 * | 10 | 2 | 32768 | 65536 | 1699 * +---------+------------+-----------+------------+ 1700 * 1701 * Calculations for other data rate are entirely based on these reference 1702 * tables. For normal operation, Latency 5 seems give the best, well 1703 * balanced performance for typical workload. Anything below 5 will 1704 * eat up CPU to keep up with increasing context switches because of 1705 * shorter buffer space and usually require the application to handle it 1706 * aggresively through possibly real time programming technique. 1707 * 1708 */ 1709 #define CHN_LATENCY_PBLKCNT_REF \ 1710 {{1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1}, \ 1711 {1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1}} 1712 #define CHN_LATENCY_PBUFSZ_REF \ 1713 {{7, 9, 12, 13, 14, 15, 15, 15, 15, 15, 16}, \ 1714 {11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 17}} 1715 1716 #define CHN_LATENCY_RBLKCNT_REF \ 1717 {{9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1}, \ 1718 {9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1}} 1719 #define CHN_LATENCY_RBUFSZ_REF \ 1720 {{14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 16}, \ 1721 {15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 17}} 1722 1723 #define CHN_LATENCY_DATA_REF 192000 /* 48khz stereo 16bit ~ 48000 x 2 x 2 */ 1724 1725 static int 1726 chn_calclatency(int dir, int latency, int bps, u_int32_t datarate, 1727 u_int32_t max, int *rblksz, int *rblkcnt) 1728 { 1729 static int pblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = 1730 CHN_LATENCY_PBLKCNT_REF; 1731 static int pbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = 1732 CHN_LATENCY_PBUFSZ_REF; 1733 static int rblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = 1734 CHN_LATENCY_RBLKCNT_REF; 1735 static int rbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = 1736 CHN_LATENCY_RBUFSZ_REF; 1737 u_int32_t bufsz; 1738 int lprofile, blksz, blkcnt; 1739 1740 if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX || 1741 bps < 1 || datarate < 1 || 1742 !(dir == PCMDIR_PLAY || dir == PCMDIR_REC)) { 1743 if (rblksz != NULL) 1744 *rblksz = CHN_2NDBUFMAXSIZE >> 1; 1745 if (rblkcnt != NULL) 1746 *rblkcnt = 2; 1747 printf("%s(): FAILED dir=%d latency=%d bps=%d " 1748 "datarate=%u max=%u\n", 1749 __func__, dir, latency, bps, datarate, max); 1750 return CHN_2NDBUFMAXSIZE; 1751 } 1752 1753 lprofile = chn_latency_profile; 1754 1755 if (dir == PCMDIR_PLAY) { 1756 blkcnt = pblkcnts[lprofile][latency]; 1757 bufsz = pbufszs[lprofile][latency]; 1758 } else { 1759 blkcnt = rblkcnts[lprofile][latency]; 1760 bufsz = rbufszs[lprofile][latency]; 1761 } 1762 1763 bufsz = round_pow2(snd_xbytes(1 << bufsz, CHN_LATENCY_DATA_REF, 1764 datarate)); 1765 if (bufsz > max) 1766 bufsz = max; 1767 blksz = round_blksz(bufsz >> blkcnt, bps); 1768 1769 if (rblksz != NULL) 1770 *rblksz = blksz; 1771 if (rblkcnt != NULL) 1772 *rblkcnt = 1 << blkcnt; 1773 1774 return blksz << blkcnt; 1775 } 1776 1777 static int 1778 chn_resizebuf(struct pcm_channel *c, int latency, 1779 int blkcnt, int blksz) 1780 { 1781 struct snd_dbuf *b, *bs, *pb; 1782 int sblksz, sblkcnt, hblksz, hblkcnt, limit = 0, nsblksz, nsblkcnt; 1783 int ret; 1784 1785 CHN_LOCKASSERT(c); 1786 1787 if ((c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED)) || 1788 !(c->direction == PCMDIR_PLAY || c->direction == PCMDIR_REC)) 1789 return EINVAL; 1790 1791 if (latency == -1) { 1792 c->latency = -1; 1793 latency = chn_latency; 1794 } else if (latency == -2) { 1795 latency = c->latency; 1796 if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX) 1797 latency = chn_latency; 1798 } else if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX) 1799 return EINVAL; 1800 else { 1801 c->latency = latency; 1802 } 1803 1804 bs = c->bufsoft; 1805 b = c->bufhard; 1806 1807 if (!(blksz == 0 || blkcnt == -1) && 1808 (blksz < 16 || blksz < sndbuf_getalign(bs) || blkcnt < 2 || 1809 (blksz * blkcnt) > CHN_2NDBUFMAXSIZE)) 1810 return EINVAL; 1811 1812 chn_calclatency(c->direction, latency, sndbuf_getalign(bs), 1813 sndbuf_getalign(bs) * sndbuf_getspd(bs), CHN_2NDBUFMAXSIZE, 1814 &sblksz, &sblkcnt); 1815 1816 if (blksz == 0 || blkcnt == -1) { 1817 if (blkcnt == -1) 1818 c->flags &= ~CHN_F_HAS_SIZE; 1819 if (c->flags & CHN_F_HAS_SIZE) { 1820 blksz = sndbuf_getblksz(bs); 1821 blkcnt = sndbuf_getblkcnt(bs); 1822 } 1823 } else 1824 c->flags |= CHN_F_HAS_SIZE; 1825 1826 if (c->flags & CHN_F_HAS_SIZE) { 1827 /* 1828 * The application has requested their own blksz/blkcnt. 1829 * Just obey with it, and let them toast alone. We can 1830 * clamp it to the nearest latency profile, but that would 1831 * defeat the purpose of having custom control. The least 1832 * we can do is round it to the nearest ^2 and align it. 1833 */ 1834 sblksz = round_blksz(blksz, sndbuf_getalign(bs)); 1835 sblkcnt = round_pow2(blkcnt); 1836 } 1837 1838 if (c->parentchannel != NULL) { 1839 pb = c->parentchannel->bufsoft; 1840 CHN_UNLOCK(c); 1841 CHN_LOCK(c->parentchannel); 1842 chn_notify(c->parentchannel, CHN_N_BLOCKSIZE); 1843 CHN_UNLOCK(c->parentchannel); 1844 CHN_LOCK(c); 1845 if (c->direction == PCMDIR_PLAY) { 1846 limit = (pb != NULL) ? 1847 sndbuf_xbytes(sndbuf_getsize(pb), pb, bs) : 0; 1848 } else { 1849 limit = (pb != NULL) ? 1850 sndbuf_xbytes(sndbuf_getblksz(pb), pb, bs) * 2 : 0; 1851 } 1852 } else { 1853 hblkcnt = 2; 1854 if (c->flags & CHN_F_HAS_SIZE) { 1855 hblksz = round_blksz(sndbuf_xbytes(sblksz, bs, b), 1856 sndbuf_getalign(b)); 1857 hblkcnt = round_pow2(sndbuf_getblkcnt(bs)); 1858 } else 1859 chn_calclatency(c->direction, latency, 1860 sndbuf_getalign(b), 1861 sndbuf_getalign(b) * sndbuf_getspd(b), 1862 CHN_2NDBUFMAXSIZE, &hblksz, &hblkcnt); 1863 1864 if ((hblksz << 1) > sndbuf_getmaxsize(b)) 1865 hblksz = round_blksz(sndbuf_getmaxsize(b) >> 1, 1866 sndbuf_getalign(b)); 1867 1868 while ((hblksz * hblkcnt) > sndbuf_getmaxsize(b)) { 1869 if (hblkcnt < 4) 1870 hblksz >>= 1; 1871 else 1872 hblkcnt >>= 1; 1873 } 1874 1875 hblksz -= hblksz % sndbuf_getalign(b); 1876 1877 #if 0 1878 hblksz = sndbuf_getmaxsize(b) >> 1; 1879 hblksz -= hblksz % sndbuf_getalign(b); 1880 hblkcnt = 2; 1881 #endif 1882 1883 CHN_UNLOCK(c); 1884 if (chn_usefrags == 0 || 1885 CHANNEL_SETFRAGMENTS(c->methods, c->devinfo, 1886 hblksz, hblkcnt) != 0) 1887 sndbuf_setblksz(b, CHANNEL_SETBLOCKSIZE(c->methods, 1888 c->devinfo, hblksz)); 1889 CHN_LOCK(c); 1890 1891 if (!CHN_EMPTY(c, children)) { 1892 nsblksz = round_blksz( 1893 sndbuf_xbytes(sndbuf_getblksz(b), b, bs), 1894 sndbuf_getalign(bs)); 1895 nsblkcnt = sndbuf_getblkcnt(b); 1896 if (c->direction == PCMDIR_PLAY) { 1897 do { 1898 nsblkcnt--; 1899 } while (nsblkcnt >= 2 && 1900 nsblksz * nsblkcnt >= sblksz * sblkcnt); 1901 nsblkcnt++; 1902 } 1903 sblksz = nsblksz; 1904 sblkcnt = nsblkcnt; 1905 limit = 0; 1906 } else 1907 limit = sndbuf_xbytes(sndbuf_getblksz(b), b, bs) * 2; 1908 } 1909 1910 if (limit > CHN_2NDBUFMAXSIZE) 1911 limit = CHN_2NDBUFMAXSIZE; 1912 1913 #if 0 1914 while (limit > 0 && (sblksz * sblkcnt) > limit) { 1915 if (sblkcnt < 4) 1916 break; 1917 sblkcnt >>= 1; 1918 } 1919 #endif 1920 1921 while ((sblksz * sblkcnt) < limit) 1922 sblkcnt <<= 1; 1923 1924 while ((sblksz * sblkcnt) > CHN_2NDBUFMAXSIZE) { 1925 if (sblkcnt < 4) 1926 sblksz >>= 1; 1927 else 1928 sblkcnt >>= 1; 1929 } 1930 1931 sblksz -= sblksz % sndbuf_getalign(bs); 1932 1933 if (sndbuf_getblkcnt(bs) != sblkcnt || sndbuf_getblksz(bs) != sblksz || 1934 sndbuf_getsize(bs) != (sblkcnt * sblksz)) { 1935 ret = sndbuf_remalloc(bs, sblkcnt, sblksz); 1936 if (ret != 0) { 1937 device_printf(c->dev, "%s(): Failed: %d %d\n", 1938 __func__, sblkcnt, sblksz); 1939 return ret; 1940 } 1941 } 1942 1943 /* 1944 * Interrupt timeout 1945 */ 1946 c->timeout = ((u_int64_t)hz * sndbuf_getsize(bs)) / 1947 ((u_int64_t)sndbuf_getspd(bs) * sndbuf_getalign(bs)); 1948 if (c->parentchannel != NULL) 1949 c->timeout = min(c->timeout, c->parentchannel->timeout); 1950 if (c->timeout < 1) 1951 c->timeout = 1; 1952 1953 /* 1954 * OSSv4 docs: "By default OSS will set the low water level equal 1955 * to the fragment size which is optimal in most cases." 1956 */ 1957 c->lw = sndbuf_getblksz(bs); 1958 chn_resetbuf(c); 1959 1960 if (snd_verbose > 3) 1961 device_printf(c->dev, "%s(): %s (%s) timeout=%u " 1962 "b[%d/%d/%d] bs[%d/%d/%d] limit=%d\n", 1963 __func__, CHN_DIRSTR(c), 1964 (c->flags & CHN_F_VIRTUAL) ? "virtual" : "hardware", 1965 c->timeout, 1966 sndbuf_getsize(b), sndbuf_getblksz(b), 1967 sndbuf_getblkcnt(b), 1968 sndbuf_getsize(bs), sndbuf_getblksz(bs), 1969 sndbuf_getblkcnt(bs), limit); 1970 1971 return 0; 1972 } 1973 1974 int 1975 chn_setlatency(struct pcm_channel *c, int latency) 1976 { 1977 CHN_LOCKASSERT(c); 1978 /* Destroy blksz/blkcnt, enforce latency profile. */ 1979 return chn_resizebuf(c, latency, -1, 0); 1980 } 1981 1982 int 1983 chn_setblocksize(struct pcm_channel *c, int blkcnt, int blksz) 1984 { 1985 CHN_LOCKASSERT(c); 1986 /* Destroy latency profile, enforce blksz/blkcnt */ 1987 return chn_resizebuf(c, -1, blkcnt, blksz); 1988 } 1989 1990 int 1991 chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed) 1992 { 1993 struct pcmchan_caps *caps; 1994 uint32_t hwspeed, delta; 1995 int ret; 1996 1997 CHN_LOCKASSERT(c); 1998 1999 if (speed < 1 || format == 0 || CHN_STARTED(c)) 2000 return (EINVAL); 2001 2002 c->format = format; 2003 c->speed = speed; 2004 2005 caps = chn_getcaps(c); 2006 2007 hwspeed = speed; 2008 RANGE(hwspeed, caps->minspeed, caps->maxspeed); 2009 2010 sndbuf_setspd(c->bufhard, CHANNEL_SETSPEED(c->methods, c->devinfo, 2011 hwspeed)); 2012 hwspeed = sndbuf_getspd(c->bufhard); 2013 2014 delta = (hwspeed > speed) ? (hwspeed - speed) : (speed - hwspeed); 2015 2016 if (delta <= feeder_rate_round) 2017 c->speed = hwspeed; 2018 2019 ret = feeder_chain(c); 2020 2021 if (ret == 0) 2022 ret = CHANNEL_SETFORMAT(c->methods, c->devinfo, 2023 sndbuf_getfmt(c->bufhard)); 2024 2025 if (ret == 0) 2026 ret = chn_resizebuf(c, -2, 0, 0); 2027 2028 return (ret); 2029 } 2030 2031 int 2032 chn_setspeed(struct pcm_channel *c, uint32_t speed) 2033 { 2034 uint32_t oldformat, oldspeed, format; 2035 int ret; 2036 2037 #if 0 2038 /* XXX force 48k */ 2039 if (c->format & AFMT_PASSTHROUGH) 2040 speed = AFMT_PASSTHROUGH_RATE; 2041 #endif 2042 2043 oldformat = c->format; 2044 oldspeed = c->speed; 2045 format = oldformat; 2046 2047 ret = chn_setparam(c, format, speed); 2048 if (ret != 0) { 2049 if (snd_verbose > 3) 2050 device_printf(c->dev, 2051 "%s(): Setting speed %d failed, " 2052 "falling back to %d\n", 2053 __func__, speed, oldspeed); 2054 chn_setparam(c, c->format, oldspeed); 2055 } 2056 2057 return (ret); 2058 } 2059 2060 int 2061 chn_setformat(struct pcm_channel *c, uint32_t format) 2062 { 2063 uint32_t oldformat, oldspeed, speed; 2064 int ret; 2065 2066 /* XXX force stereo */ 2067 if ((format & AFMT_PASSTHROUGH) && AFMT_CHANNEL(format) < 2) { 2068 format = SND_FORMAT(format, AFMT_PASSTHROUGH_CHANNEL, 2069 AFMT_PASSTHROUGH_EXTCHANNEL); 2070 } 2071 2072 oldformat = c->format; 2073 oldspeed = c->speed; 2074 speed = oldspeed; 2075 2076 ret = chn_setparam(c, format, speed); 2077 if (ret != 0) { 2078 if (snd_verbose > 3) 2079 device_printf(c->dev, 2080 "%s(): Format change 0x%08x failed, " 2081 "falling back to 0x%08x\n", 2082 __func__, format, oldformat); 2083 chn_setparam(c, oldformat, oldspeed); 2084 } 2085 2086 return (ret); 2087 } 2088 2089 void 2090 chn_syncstate(struct pcm_channel *c) 2091 { 2092 struct snddev_info *d; 2093 struct snd_mixer *m; 2094 2095 d = (c != NULL) ? c->parentsnddev : NULL; 2096 m = (d != NULL && d->mixer_dev != NULL) ? d->mixer_dev->si_drv1 : 2097 NULL; 2098 2099 if (d == NULL || m == NULL) 2100 return; 2101 2102 CHN_LOCKASSERT(c); 2103 2104 if (c->feederflags & (1 << FEEDER_VOLUME)) { 2105 uint32_t parent; 2106 int vol, pvol, left, right, center; 2107 2108 if (c->direction == PCMDIR_PLAY && 2109 (d->flags & SD_F_SOFTPCMVOL)) { 2110 /* CHN_UNLOCK(c); */ 2111 vol = mix_get(m, SOUND_MIXER_PCM); 2112 parent = mix_getparent(m, SOUND_MIXER_PCM); 2113 if (parent != SOUND_MIXER_NONE) 2114 pvol = mix_get(m, parent); 2115 else 2116 pvol = 100 | (100 << 8); 2117 /* CHN_LOCK(c); */ 2118 } else { 2119 vol = 100 | (100 << 8); 2120 pvol = vol; 2121 } 2122 2123 if (vol == -1) { 2124 device_printf(c->dev, 2125 "Soft PCM Volume: Failed to read pcm " 2126 "default value\n"); 2127 vol = 100 | (100 << 8); 2128 } 2129 2130 if (pvol == -1) { 2131 device_printf(c->dev, 2132 "Soft PCM Volume: Failed to read parent " 2133 "default value\n"); 2134 pvol = 100 | (100 << 8); 2135 } 2136 2137 left = ((vol & 0x7f) * (pvol & 0x7f)) / 100; 2138 right = (((vol >> 8) & 0x7f) * ((pvol >> 8) & 0x7f)) / 100; 2139 center = (left + right) >> 1; 2140 2141 chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right, center); 2142 } 2143 2144 if (c->feederflags & (1 << FEEDER_EQ)) { 2145 struct pcm_feeder *f; 2146 int treble, bass, state; 2147 2148 /* CHN_UNLOCK(c); */ 2149 treble = mix_get(m, SOUND_MIXER_TREBLE); 2150 bass = mix_get(m, SOUND_MIXER_BASS); 2151 /* CHN_LOCK(c); */ 2152 2153 if (treble == -1) 2154 treble = 50; 2155 else 2156 treble = ((treble & 0x7f) + 2157 ((treble >> 8) & 0x7f)) >> 1; 2158 2159 if (bass == -1) 2160 bass = 50; 2161 else 2162 bass = ((bass & 0x7f) + ((bass >> 8) & 0x7f)) >> 1; 2163 2164 f = chn_findfeeder(c, FEEDER_EQ); 2165 if (f != NULL) { 2166 if (FEEDER_SET(f, FEEDEQ_TREBLE, treble) != 0) 2167 device_printf(c->dev, 2168 "EQ: Failed to set treble -- %d\n", 2169 treble); 2170 if (FEEDER_SET(f, FEEDEQ_BASS, bass) != 0) 2171 device_printf(c->dev, 2172 "EQ: Failed to set bass -- %d\n", 2173 bass); 2174 if (FEEDER_SET(f, FEEDEQ_PREAMP, d->eqpreamp) != 0) 2175 device_printf(c->dev, 2176 "EQ: Failed to set preamp -- %d\n", 2177 d->eqpreamp); 2178 if (d->flags & SD_F_EQ_BYPASSED) 2179 state = FEEDEQ_BYPASS; 2180 else if (d->flags & SD_F_EQ_ENABLED) 2181 state = FEEDEQ_ENABLE; 2182 else 2183 state = FEEDEQ_DISABLE; 2184 if (FEEDER_SET(f, FEEDEQ_STATE, state) != 0) 2185 device_printf(c->dev, 2186 "EQ: Failed to set state -- %d\n", state); 2187 } 2188 } 2189 } 2190 2191 int 2192 chn_trigger(struct pcm_channel *c, int go) 2193 { 2194 #ifdef DEV_ISA 2195 struct snd_dbuf *b = c->bufhard; 2196 #endif 2197 struct snddev_info *d = c->parentsnddev; 2198 int ret; 2199 2200 CHN_LOCKASSERT(c); 2201 #ifdef DEV_ISA 2202 if (SND_DMA(b) && (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)) 2203 sndbuf_dmabounce(b); 2204 #endif 2205 if (!PCMTRIG_COMMON(go)) 2206 return (CHANNEL_TRIGGER(c->methods, c->devinfo, go)); 2207 2208 if (go == c->trigger) 2209 return (0); 2210 2211 ret = CHANNEL_TRIGGER(c->methods, c->devinfo, go); 2212 if (ret != 0) 2213 return (ret); 2214 2215 switch (go) { 2216 case PCMTRIG_START: 2217 if (snd_verbose > 3) 2218 device_printf(c->dev, 2219 "%s() %s: calling go=0x%08x , " 2220 "prev=0x%08x\n", __func__, c->name, go, 2221 c->trigger); 2222 if (c->trigger != PCMTRIG_START) { 2223 c->trigger = go; 2224 CHN_UNLOCK(c); 2225 PCM_LOCK(d); 2226 CHN_INSERT_HEAD(d, c, channels.pcm.busy); 2227 PCM_UNLOCK(d); 2228 CHN_LOCK(c); 2229 chn_syncstate(c); 2230 } 2231 break; 2232 case PCMTRIG_STOP: 2233 case PCMTRIG_ABORT: 2234 if (snd_verbose > 3) 2235 device_printf(c->dev, 2236 "%s() %s: calling go=0x%08x , " 2237 "prev=0x%08x\n", __func__, c->name, go, 2238 c->trigger); 2239 if (c->trigger == PCMTRIG_START) { 2240 c->trigger = go; 2241 CHN_UNLOCK(c); 2242 PCM_LOCK(d); 2243 CHN_REMOVE(d, c, channels.pcm.busy); 2244 PCM_UNLOCK(d); 2245 CHN_LOCK(c); 2246 } 2247 break; 2248 default: 2249 break; 2250 } 2251 2252 return (0); 2253 } 2254 2255 /** 2256 * @brief Queries sound driver for sample-aligned hardware buffer pointer index 2257 * 2258 * This function obtains the hardware pointer location, then aligns it to 2259 * the current bytes-per-sample value before returning. (E.g., a channel 2260 * running in 16 bit stereo mode would require 4 bytes per sample, so a 2261 * hwptr value ranging from 32-35 would be returned as 32.) 2262 * 2263 * @param c PCM channel context 2264 * @returns sample-aligned hardware buffer pointer index 2265 */ 2266 int 2267 chn_getptr(struct pcm_channel *c) 2268 { 2269 int hwptr; 2270 2271 CHN_LOCKASSERT(c); 2272 hwptr = (CHN_STARTED(c)) ? CHANNEL_GETPTR(c->methods, c->devinfo) : 0; 2273 return (hwptr - (hwptr % sndbuf_getalign(c->bufhard))); 2274 } 2275 2276 struct pcmchan_caps * 2277 chn_getcaps(struct pcm_channel *c) 2278 { 2279 CHN_LOCKASSERT(c); 2280 return CHANNEL_GETCAPS(c->methods, c->devinfo); 2281 } 2282 2283 u_int32_t 2284 chn_getformats(struct pcm_channel *c) 2285 { 2286 u_int32_t *fmtlist, fmts; 2287 int i; 2288 2289 fmtlist = chn_getcaps(c)->fmtlist; 2290 fmts = 0; 2291 for (i = 0; fmtlist[i]; i++) 2292 fmts |= fmtlist[i]; 2293 2294 /* report software-supported formats */ 2295 if (!CHN_BITPERFECT(c) && report_soft_formats) 2296 fmts |= AFMT_CONVERTIBLE; 2297 2298 return (AFMT_ENCODING(fmts)); 2299 } 2300 2301 int 2302 chn_notify(struct pcm_channel *c, u_int32_t flags) 2303 { 2304 struct pcm_channel *ch; 2305 struct pcmchan_caps *caps; 2306 uint32_t bestformat, bestspeed, besthwformat, *vchanformat, *vchanrate; 2307 uint32_t vpflags; 2308 int dirty, err, run, nrun; 2309 2310 CHN_LOCKASSERT(c); 2311 2312 if (CHN_EMPTY(c, children)) 2313 return (ENODEV); 2314 2315 err = 0; 2316 2317 /* 2318 * If the hwchan is running, we can't change its rate, format or 2319 * blocksize 2320 */ 2321 run = (CHN_STARTED(c)) ? 1 : 0; 2322 if (run) 2323 flags &= CHN_N_VOLUME | CHN_N_TRIGGER; 2324 2325 if (flags & CHN_N_RATE) { 2326 /* 2327 * XXX I'll make good use of this someday. 2328 * However this is currently being superseded by 2329 * the availability of CHN_F_VCHAN_DYNAMIC. 2330 */ 2331 } 2332 2333 if (flags & CHN_N_FORMAT) { 2334 /* 2335 * XXX I'll make good use of this someday. 2336 * However this is currently being superseded by 2337 * the availability of CHN_F_VCHAN_DYNAMIC. 2338 */ 2339 } 2340 2341 if (flags & CHN_N_VOLUME) { 2342 /* 2343 * XXX I'll make good use of this someday, though 2344 * soft volume control is currently pretty much 2345 * integrated. 2346 */ 2347 } 2348 2349 if (flags & CHN_N_BLOCKSIZE) { 2350 /* 2351 * Set to default latency profile 2352 */ 2353 chn_setlatency(c, chn_latency); 2354 } 2355 2356 if ((flags & CHN_N_TRIGGER) && !(c->flags & CHN_F_VCHAN_DYNAMIC)) { 2357 nrun = CHN_EMPTY(c, children.busy) ? 0 : 1; 2358 if (nrun && !run) 2359 err = chn_start(c, 1); 2360 if (!nrun && run) 2361 chn_abort(c); 2362 flags &= ~CHN_N_TRIGGER; 2363 } 2364 2365 if (flags & CHN_N_TRIGGER) { 2366 if (c->direction == PCMDIR_PLAY) { 2367 vchanformat = &c->parentsnddev->pvchanformat; 2368 vchanrate = &c->parentsnddev->pvchanrate; 2369 } else { 2370 vchanformat = &c->parentsnddev->rvchanformat; 2371 vchanrate = &c->parentsnddev->rvchanrate; 2372 } 2373 2374 /* Dynamic Virtual Channel */ 2375 if (!(c->flags & CHN_F_VCHAN_ADAPTIVE)) { 2376 bestformat = *vchanformat; 2377 bestspeed = *vchanrate; 2378 } else { 2379 bestformat = 0; 2380 bestspeed = 0; 2381 } 2382 2383 besthwformat = 0; 2384 nrun = 0; 2385 caps = chn_getcaps(c); 2386 dirty = 0; 2387 vpflags = 0; 2388 2389 CHN_FOREACH(ch, c, children.busy) { 2390 CHN_LOCK(ch); 2391 if ((ch->format & AFMT_PASSTHROUGH) && 2392 snd_fmtvalid(ch->format, caps->fmtlist)) { 2393 bestformat = ch->format; 2394 bestspeed = ch->speed; 2395 CHN_UNLOCK(ch); 2396 vpflags = CHN_F_PASSTHROUGH; 2397 nrun++; 2398 break; 2399 } 2400 if ((ch->flags & CHN_F_EXCLUSIVE) && vpflags == 0) { 2401 if (c->flags & CHN_F_VCHAN_ADAPTIVE) { 2402 bestspeed = ch->speed; 2403 RANGE(bestspeed, caps->minspeed, 2404 caps->maxspeed); 2405 besthwformat = snd_fmtbest(ch->format, 2406 caps->fmtlist); 2407 if (besthwformat != 0) 2408 bestformat = besthwformat; 2409 } 2410 CHN_UNLOCK(ch); 2411 vpflags = CHN_F_EXCLUSIVE; 2412 nrun++; 2413 continue; 2414 } 2415 if (!(c->flags & CHN_F_VCHAN_ADAPTIVE) || 2416 vpflags != 0) { 2417 CHN_UNLOCK(ch); 2418 nrun++; 2419 continue; 2420 } 2421 if (ch->speed > bestspeed) { 2422 bestspeed = ch->speed; 2423 RANGE(bestspeed, caps->minspeed, 2424 caps->maxspeed); 2425 } 2426 besthwformat = snd_fmtbest(ch->format, caps->fmtlist); 2427 if (!(besthwformat & AFMT_VCHAN)) { 2428 CHN_UNLOCK(ch); 2429 nrun++; 2430 continue; 2431 } 2432 if (AFMT_CHANNEL(besthwformat) > 2433 AFMT_CHANNEL(bestformat)) 2434 bestformat = besthwformat; 2435 else if (AFMT_CHANNEL(besthwformat) == 2436 AFMT_CHANNEL(bestformat) && 2437 AFMT_BIT(besthwformat) > AFMT_BIT(bestformat)) 2438 bestformat = besthwformat; 2439 CHN_UNLOCK(ch); 2440 nrun++; 2441 } 2442 2443 if (bestformat == 0) 2444 bestformat = c->format; 2445 if (bestspeed == 0) 2446 bestspeed = c->speed; 2447 2448 if (bestformat != c->format || bestspeed != c->speed) 2449 dirty = 1; 2450 2451 c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE); 2452 c->flags |= vpflags; 2453 2454 if (nrun && !run) { 2455 if (dirty) { 2456 bestspeed = CHANNEL_SETSPEED(c->methods, 2457 c->devinfo, bestspeed); 2458 err = chn_reset(c, bestformat, bestspeed); 2459 } 2460 if (err == 0 && dirty) { 2461 CHN_FOREACH(ch, c, children.busy) { 2462 CHN_LOCK(ch); 2463 if (VCHAN_SYNC_REQUIRED(ch)) 2464 vchan_sync(ch); 2465 CHN_UNLOCK(ch); 2466 } 2467 } 2468 if (err == 0) { 2469 if (dirty) 2470 c->flags |= CHN_F_DIRTY; 2471 err = chn_start(c, 1); 2472 } 2473 } 2474 2475 if (nrun && run && dirty) { 2476 chn_abort(c); 2477 bestspeed = CHANNEL_SETSPEED(c->methods, c->devinfo, 2478 bestspeed); 2479 err = chn_reset(c, bestformat, bestspeed); 2480 if (err == 0) { 2481 CHN_FOREACH(ch, c, children.busy) { 2482 CHN_LOCK(ch); 2483 if (VCHAN_SYNC_REQUIRED(ch)) 2484 vchan_sync(ch); 2485 CHN_UNLOCK(ch); 2486 } 2487 } 2488 if (err == 0) { 2489 c->flags |= CHN_F_DIRTY; 2490 err = chn_start(c, 1); 2491 } 2492 } 2493 2494 if (err == 0 && !(bestformat & AFMT_PASSTHROUGH) && 2495 (bestformat & AFMT_VCHAN)) { 2496 *vchanformat = bestformat; 2497 *vchanrate = bestspeed; 2498 } 2499 2500 if (!nrun && run) { 2501 c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE); 2502 bestformat = *vchanformat; 2503 bestspeed = *vchanrate; 2504 chn_abort(c); 2505 if (c->format != bestformat || c->speed != bestspeed) 2506 chn_reset(c, bestformat, bestspeed); 2507 } 2508 } 2509 2510 return (err); 2511 } 2512 2513 /** 2514 * @brief Fetch array of supported discrete sample rates 2515 * 2516 * Wrapper for CHANNEL_GETRATES. Please see channel_if.m:getrates() for 2517 * detailed information. 2518 * 2519 * @note If the operation isn't supported, this function will just return 0 2520 * (no rates in the array), and *rates will be set to NULL. Callers 2521 * should examine rates @b only if this function returns non-zero. 2522 * 2523 * @param c pcm channel to examine 2524 * @param rates pointer to array of integers; rate table will be recorded here 2525 * 2526 * @return number of rates in the array pointed to be @c rates 2527 */ 2528 int 2529 chn_getrates(struct pcm_channel *c, int **rates) 2530 { 2531 KASSERT(rates != NULL, ("rates is null")); 2532 CHN_LOCKASSERT(c); 2533 return CHANNEL_GETRATES(c->methods, c->devinfo, rates); 2534 } 2535 2536 /** 2537 * @brief Remove channel from a sync group, if there is one. 2538 * 2539 * This function is initially intended for the following conditions: 2540 * - Starting a syncgroup (@c SNDCTL_DSP_SYNCSTART ioctl) 2541 * - Closing a device. (A channel can't be destroyed if it's still in use.) 2542 * 2543 * @note Before calling this function, the syncgroup list mutex must be 2544 * held. (Consider pcm_channel::sm protected by the SG list mutex 2545 * whether @c c is locked or not.) 2546 * 2547 * @param c channel device to be started or closed 2548 * @returns If this channel was the only member of a group, the group ID 2549 * is returned to the caller so that the caller can release it 2550 * via free_unr() after giving up the syncgroup lock. Else it 2551 * returns 0. 2552 */ 2553 int 2554 chn_syncdestroy(struct pcm_channel *c) 2555 { 2556 struct pcmchan_syncmember *sm; 2557 struct pcmchan_syncgroup *sg; 2558 int sg_id; 2559 2560 sg_id = 0; 2561 2562 PCM_SG_LOCKASSERT(MA_OWNED); 2563 2564 if (c->sm != NULL) { 2565 sm = c->sm; 2566 sg = sm->parent; 2567 c->sm = NULL; 2568 2569 KASSERT(sg != NULL, ("syncmember has null parent")); 2570 2571 SLIST_REMOVE(&sg->members, sm, pcmchan_syncmember, link); 2572 free(sm, M_DEVBUF); 2573 2574 if (SLIST_EMPTY(&sg->members)) { 2575 SLIST_REMOVE(&snd_pcm_syncgroups, sg, pcmchan_syncgroup, link); 2576 sg_id = sg->id; 2577 free(sg, M_DEVBUF); 2578 } 2579 } 2580 2581 return sg_id; 2582 } 2583 2584 #ifdef OSSV4_EXPERIMENT 2585 int 2586 chn_getpeaks(struct pcm_channel *c, int *lpeak, int *rpeak) 2587 { 2588 CHN_LOCKASSERT(c); 2589 return CHANNEL_GETPEAKS(c->methods, c->devinfo, lpeak, rpeak); 2590 } 2591 #endif 2592