sys/dev/sound/pcm/channel.c

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