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