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