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