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