sys/dev/sound/pcm/sound.c

   1 /*-
   2  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
   3  * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/sound/pcm/sound.c,v 1.93.2.5 2007/06/04 09:06:05 ariff Exp $
  28  * $DragonFly: src/sys/dev/sound/pcm/sound.c,v 1.12 2008/01/06 16:55:51 swildner Exp $
  29  */
  30
  31 #include <dev/sound/pcm/sound.h>
  32 #include <dev/sound/pcm/vchan.h>
  33 #include <dev/sound/pcm/dsp.h>
  34 #include <sys/sysctl.h>
  35
  36 #include "feeder_if.h"
  37
  38 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/sound.c,v 1.12 2008/01/06 16:55:51 swildner Exp $");
  39
  40 devclass_t pcm_devclass;
  41
  42 int pcm_veto_load = 1;
  43
  44 #ifdef USING_DEVFS
  45 int snd_unit = 0;
  46 TUNABLE_INT("hw.snd.unit", &snd_unit);
  47 #endif
  48
  49 int snd_maxautovchans = 4;
  50 TUNABLE_INT("hw.snd.maxautovchans", &snd_maxautovchans);
  51
  52 SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD, 0, "Sound driver");
  53
  54 static int sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose);
  55
  56 struct sysctl_ctx_list *
  57 snd_sysctl_tree(device_t dev)
  58 {
  59         struct snddev_info *d = device_get_softc(dev);
  60
  61         return &d->sysctl_tree;
  62 }
  63
  64 struct sysctl_oid *
  65 snd_sysctl_tree_top(device_t dev)
  66 {
  67         struct snddev_info *d = device_get_softc(dev);
  68
  69         return d->sysctl_tree_top;
  70 }
  71
  72 void *
  73 snd_mtxcreate(const char *desc, const char *type)
  74 {
  75 #ifdef USING_MUTEX
  76         struct lock     *m;
  77
  78         m = kmalloc(sizeof(*m), M_DEVBUF, M_WAITOK | M_ZERO);
  79         lockinit(m, __DECONST(char *, type), 0, LK_CANRECURSE);
  80         return m;
  81 #else
  82         return (void *)0xcafebabe;
  83 #endif
  84 }
  85
  86 void
  87 snd_mtxfree(void *m)
  88 {
  89 #ifdef USING_MUTEX
  90         struct lock *lk = m;
  91
  92         kfree(lk, M_DEVBUF);
  93 #endif
  94 }
  95
  96 void
  97 snd_mtxassert(void *m)
  98 {
  99 #ifdef USING_MUTEX
 100 #ifdef INVARIANTS
 101         /* XXX */
 102 #endif
 103 #endif
 104 }
 105
 106 void
 107 snd_mtxlock(void *m)
 108 {
 109 #ifdef USING_MUTEX
 110         struct lock *lk = m;
 111
 112         lockmgr(lk, LK_EXCLUSIVE | LK_RETRY);
 113 #endif
 114 }
 115
 116 void
 117 snd_mtxunlock(void *m)
 118 {
 119 #ifdef USING_MUTEX
 120         struct lock *lk = m;
 121
 122         lockmgr(lk, LK_RELEASE);
 123 #endif
 124 }
 125
 126 int
 127 snd_mtxsleep(void *addr, sndlock_t lock, int flags, const char *wmesg, int timo)
 128 {
 129         int r;
 130
 131         tsleep_interlock(addr, flags);
 132         snd_mtxunlock(lock);
 133         r = tsleep(addr, flags | PINTERLOCKED, wmesg, timo);
 134         snd_mtxlock(lock);
 135         return(r);
 136 }
 137
 138
 139
 140 int
 141 snd_setup_intr(device_t dev, struct resource *res, int flags, driver_intr_t hand, void *param, void **cookiep)
 142 {
 143 #ifdef USING_MUTEX
 144         flags &= INTR_MPSAFE;
 145         flags |= INTR_TYPE_AV;
 146 #else
 147         flags = INTR_TYPE_AV;
 148 #endif
 149         return bus_setup_intr(dev, res, flags, hand, param, cookiep, NULL);
 150 }
 151
 152 #ifndef PCM_DEBUG_MTX
 153 void
 154 pcm_lock(struct snddev_info *d)
 155 {
 156         snd_mtxlock(d->lock);
 157 }
 158
 159 void
 160 pcm_unlock(struct snddev_info *d)
 161 {
 162         snd_mtxunlock(d->lock);
 163 }
 164 #endif
 165
 166 struct pcm_channel *
 167 pcm_getfakechan(struct snddev_info *d)
 168 {
 169         return d->fakechan;
 170 }
 171
 172 static int
 173 pcm_setvchans(struct snddev_info *d, int newcnt)
 174 {
 175         struct snddev_channel *sce = NULL;
 176         struct pcm_channel *c = NULL;
 177         int err = 0, vcnt, dcnt, i;
 178
 179         pcm_inprog(d, 1);
 180
 181         if (!(d->flags & SD_F_AUTOVCHAN)) {
 182                 err = EINVAL;
 183                 goto setvchans_out;
 184         }
 185
 186         vcnt = d->vchancount;
 187         dcnt = d->playcount + d->reccount;
 188
 189         if (newcnt < 0 || (dcnt + newcnt) > (PCMMAXCHAN + 1)) {
 190                 err = E2BIG;
 191                 goto setvchans_out;
 192         }
 193
 194         dcnt += vcnt;
 195
 196         if (newcnt > vcnt) {
 197                 /* add new vchans - find a parent channel first */
 198                 SLIST_FOREACH(sce, &d->channels, link) {
 199                         c = sce->channel;
 200                         CHN_LOCK(c);
 201                         if (c->direction == PCMDIR_PLAY &&
 202                                         ((c->flags & CHN_F_HAS_VCHAN) ||
 203                                         (vcnt == 0 &&
 204                                         !(c->flags & (CHN_F_BUSY | CHN_F_VIRTUAL)))))
 205                                 goto addok;
 206                         CHN_UNLOCK(c);
 207                 }
 208                 err = EBUSY;
 209                 goto setvchans_out;
 210 addok:
 211                 c->flags |= CHN_F_BUSY;
 212                 while (err == 0 && newcnt > vcnt) {
 213                         if (dcnt > PCMMAXCHAN) {
 214                                 device_printf(d->dev, "%s: Maximum channel reached.\n", __func__);
 215                                 break;
 216                         }
 217                         err = vchan_create(c);
 218                         if (err == 0) {
 219                                 vcnt++;
 220                                 dcnt++;
 221                         } else if (err == E2BIG && newcnt > vcnt)
 222                                 device_printf(d->dev, "%s: err=%d Maximum channel reached.\n", __func__, err);
 223                 }
 224                 if (vcnt == 0)
 225                         c->flags &= ~CHN_F_BUSY;
 226                 CHN_UNLOCK(c);
 227         } else if (newcnt < vcnt) {
 228 #define ORPHAN_CDEVT(cdevt) \
 229         ((cdevt) == NULL || ((cdevt)->si_drv1 == NULL && \
 230         (cdevt)->si_drv2 == NULL))
 231                 while (err == 0 && newcnt < vcnt) {
 232                         i = 0;
 233                         SLIST_FOREACH(sce, &d->channels, link) {
 234                                 c = sce->channel;
 235                                 CHN_LOCK(c);
 236                                 if (c->direction == PCMDIR_PLAY &&
 237                                                 (c->flags & CHN_F_VIRTUAL) &&
 238                                                 (i++ == newcnt)) {
 239                                         if (!(c->flags & CHN_F_BUSY) &&
 240                                                         ORPHAN_CDEVT(sce->dsp_devt) &&
 241                                                         ORPHAN_CDEVT(sce->dspW_devt) &&
 242                                                         ORPHAN_CDEVT(sce->audio_devt) &&
 243                                                         ORPHAN_CDEVT(sce->dspr_devt))
 244                                                 goto remok;
 245                                         /*
 246                                          * Either we're busy, or our cdev
 247                                          * has been stolen by dsp_clone().
 248                                          * Skip, and increase newcnt.
 249                                          */
 250                                         if (!(c->flags & CHN_F_BUSY))
 251                                                 device_printf(d->dev,
 252                                                         "%s: <%s> somebody steal my cdev!\n",
 253                                                         __func__, c->name);
 254                                         newcnt++;
 255                                 }
 256                                 CHN_UNLOCK(c);
 257                         }
 258                         if (vcnt != newcnt)
 259                                 err = EBUSY;
 260                         break;
 261 remok:
 262                         CHN_UNLOCK(c);
 263                         err = vchan_destroy(c);
 264                         if (err == 0)
 265                                 vcnt--;
 266                         else
 267                                 device_printf(d->dev,
 268                                         "%s: WARNING: vchan_destroy() failed!",
 269                                         __func__);
 270                 }
 271         }
 272
 273 setvchans_out:
 274         pcm_inprog(d, -1);
 275         return err;
 276 }
 277
 278 /* return error status and a locked channel */
 279 int
 280 pcm_chnalloc(struct snddev_info *d, struct pcm_channel **ch, int direction,
 281                 pid_t pid, int chnum)
 282 {
 283         struct pcm_channel *c;
 284         struct snddev_channel *sce;
 285         int err;
 286
 287 retry_chnalloc:
 288         err = ENODEV;
 289         /* scan for a free channel */
 290         SLIST_FOREACH(sce, &d->channels, link) {
 291                 c = sce->channel;
 292                 CHN_LOCK(c);
 293                 if (c->direction == direction && !(c->flags & CHN_F_BUSY)) {
 294                         if (chnum < 0 || sce->chan_num == chnum) {
 295                                 c->flags |= CHN_F_BUSY;
 296                                 c->pid = pid;
 297                                 *ch = c;
 298                                 return 0;
 299                         }
 300                 }
 301                 if (sce->chan_num == chnum) {
 302                         if (c->direction != direction)
 303                                 err = EOPNOTSUPP;
 304                         else if (c->flags & CHN_F_BUSY)
 305                                 err = EBUSY;
 306                         else
 307                                 err = EINVAL;
 308                         CHN_UNLOCK(c);
 309                         return err;
 310                 } else if (c->direction == direction && (c->flags & CHN_F_BUSY))
 311                         err = EBUSY;
 312                 CHN_UNLOCK(c);
 313         }
 314
 315         /* no channel available */
 316         if (chnum == -1 && direction == PCMDIR_PLAY && d->vchancount > 0 &&
 317                         d->vchancount < snd_maxautovchans &&
 318                         d->devcount <= PCMMAXCHAN) {
 319                 err = pcm_setvchans(d, d->vchancount + 1);
 320                 if (err == 0) {
 321                         chnum = -2;
 322                         goto retry_chnalloc;
 323                 }
 324         }
 325
 326         return err;
 327 }
 328
 329 /* release a locked channel and unlock it */
 330 int
 331 pcm_chnrelease(struct pcm_channel *c)
 332 {
 333         CHN_LOCKASSERT(c);
 334         c->flags &= ~CHN_F_BUSY;
 335         c->pid = -1;
 336         CHN_UNLOCK(c);
 337         return 0;
 338 }
 339
 340 int
 341 pcm_chnref(struct pcm_channel *c, int ref)
 342 {
 343         int r;
 344
 345         CHN_LOCKASSERT(c);
 346         c->refcount += ref;
 347         r = c->refcount;
 348         return r;
 349 }
 350
 351 int
 352 pcm_inprog(struct snddev_info *d, int delta)
 353 {
 354         int r;
 355
 356         if (delta == 0)
 357                 return d->inprog;
 358
 359         /* backtrace(); */
 360         pcm_lock(d);
 361         d->inprog += delta;
 362         r = d->inprog;
 363         pcm_unlock(d);
 364         return r;
 365 }
 366
 367 static void
 368 pcm_setmaxautovchans(struct snddev_info *d, int num)
 369 {
 370         if (num > 0 && d->vchancount == 0)
 371                 pcm_setvchans(d, 1);
 372         else if (num == 0 && d->vchancount > 0)
 373                 pcm_setvchans(d, 0);
 374 }
 375
 376 #ifdef USING_DEVFS
 377 static int
 378 sysctl_hw_snd_unit(SYSCTL_HANDLER_ARGS)
 379 {
 380         struct snddev_info *d;
 381         int error, unit;
 382
 383         unit = snd_unit;
 384         error = sysctl_handle_int(oidp, &unit, sizeof(unit), req);
 385         if (error == 0 && req->newptr != NULL) {
 386                 if (unit < 0 || (pcm_devclass != NULL &&
 387                     unit >= devclass_get_maxunit(pcm_devclass)))
 388                         return EINVAL;
 389                 d = devclass_get_softc(pcm_devclass, unit);
 390                 if (d == NULL || SLIST_EMPTY(&d->channels))
 391                         return EINVAL;
 392                 snd_unit = unit;
 393         }
 394         return (error);
 395 }
 396 SYSCTL_PROC(_hw_snd, OID_AUTO, unit, CTLTYPE_INT | CTLFLAG_RW,
 397             0, sizeof(int), sysctl_hw_snd_unit, "I", "");
 398 #endif
 399
 400 static int
 401 sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
 402 {
 403         struct snddev_info *d;
 404         int i, v, error;
 405
 406         v = snd_maxautovchans;
 407         error = sysctl_handle_int(oidp, &v, sizeof(v), req);
 408         if (error == 0 && req->newptr != NULL) {
 409                 if (v < 0 || v > PCMMAXCHAN)
 410                         return E2BIG;
 411                 if (pcm_devclass != NULL && v != snd_maxautovchans) {
 412                         for (i = 0; i < devclass_get_maxunit(pcm_devclass); i++) {
 413                                 d = devclass_get_softc(pcm_devclass, i);
 414                                 if (!d)
 415                                         continue;
 416                                 pcm_setmaxautovchans(d, v);
 417                         }
 418                 }
 419                 snd_maxautovchans = v;
 420         }
 421         return (error);
 422 }
 423 SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans, CTLTYPE_INT | CTLFLAG_RW,
 424             0, sizeof(int), sysctl_hw_snd_maxautovchans, "I", "");
 425
 426 struct pcm_channel *
 427 pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, void *devinfo)
 428 {
 429         struct snddev_channel *sce;
 430         struct pcm_channel *ch, *c;
 431         char *dirs;
 432         uint32_t flsearch = 0;
 433         int direction, err, rpnum, *pnum;
 434
 435         switch(dir) {
 436         case PCMDIR_PLAY:
 437                 dirs = "play";
 438                 direction = PCMDIR_PLAY;
 439                 pnum = &d->playcount;
 440                 break;
 441
 442         case PCMDIR_REC:
 443                 dirs = "record";
 444                 direction = PCMDIR_REC;
 445                 pnum = &d->reccount;
 446                 break;
 447
 448         case PCMDIR_VIRTUAL:
 449                 dirs = "virtual";
 450                 direction = PCMDIR_PLAY;
 451                 pnum = &d->vchancount;
 452                 flsearch = CHN_F_VIRTUAL;
 453                 break;
 454
 455         default:
 456                 return NULL;
 457         }
 458
 459         ch = kmalloc(sizeof(*ch), M_DEVBUF, M_WAITOK | M_ZERO);
 460
 461         ch->methods = kobj_create(cls, M_DEVBUF, M_WAITOK);
 462         if (!ch->methods) {
 463                 kfree(ch, M_DEVBUF);
 464
 465                 return NULL;
 466         }
 467
 468         snd_mtxlock(d->lock);
 469         ch->num = 0;
 470         rpnum = 0;
 471         SLIST_FOREACH(sce, &d->channels, link) {
 472                 c = sce->channel;
 473                 if (direction != c->direction ||
 474                                 (c->flags & CHN_F_VIRTUAL) != flsearch)
 475                         continue;
 476                 if (ch->num == c->num)
 477                         ch->num++;
 478                 else {
 479 #if 0
 480                         device_printf(d->dev,
 481                                 "%s: %s channel numbering screwed (Expect: %d, Got: %d)\n",
 482                                 __func__, dirs, ch->num, c->num);
 483 #endif
 484                         goto retry_num_search;
 485                 }
 486                 rpnum++;
 487         }
 488         goto retry_num_search_out;
 489 retry_num_search:
 490         rpnum = 0;
 491         SLIST_FOREACH(sce, &d->channels, link) {
 492                 c = sce->channel;
 493                 if (direction != c->direction ||
 494                                 (c->flags & CHN_F_VIRTUAL) != flsearch)
 495                         continue;
 496                 if (ch->num == c->num) {
 497                         ch->num++;
 498                         goto retry_num_search;
 499                 }
 500                 rpnum++;
 501         }
 502 retry_num_search_out:
 503         if (*pnum != rpnum) {
 504                 device_printf(d->dev,
 505                         "%s: WARNING: pnum screwed : dirs=%s, pnum=%d, rpnum=%d\n",
 506                         __func__, dirs, *pnum, rpnum);
 507                 *pnum = rpnum;
 508         }
 509         (*pnum)++;
 510         snd_mtxunlock(d->lock);
 511
 512         ch->pid = -1;
 513         ch->parentsnddev = d;
 514         ch->parentchannel = parent;
 515         ch->dev = d->dev;
 516         ksnprintf(ch->name, CHN_NAMELEN, "%s:%s:%d", device_get_nameunit(ch->dev), dirs, ch->num);
 517
 518         err = chn_init(ch, devinfo, dir, direction);
 519         if (err) {
 520                 device_printf(d->dev, "chn_init(%s) failed: err = %d\n", ch->name, err);
 521                 kobj_delete(ch->methods, M_DEVBUF);
 522                 kfree(ch, M_DEVBUF);
 523                 snd_mtxlock(d->lock);
 524                 (*pnum)--;
 525                 snd_mtxunlock(d->lock);
 526
 527                 return NULL;
 528         }
 529
 530         return ch;
 531 }
 532
 533 struct pcm_channel *
 534 pcm_chn_iterate(struct snddev_info *d, void **cookie)
 535 {
 536         struct snddev_channel **last = (struct snddev_channel **)cookie;
 537
 538         if (*last == NULL)
 539                 *last = SLIST_FIRST(&d->channels);
 540         else
 541                 *last = SLIST_NEXT(*last, link);
 542
 543         if (*last == NULL)
 544                 return NULL;
 545         else
 546                 return (*last)->channel;
 547 }
 548
 549 int
 550 pcm_chn_destroy(struct pcm_channel *ch)
 551 {
 552         struct snddev_info *d;
 553         int err;
 554
 555         d = ch->parentsnddev;
 556         err = chn_kill(ch);
 557         if (err) {
 558                 device_printf(d->dev, "chn_kill(%s) failed, err = %d\n", ch->name, err);
 559                 return err;
 560         }
 561
 562         kobj_delete(ch->methods, M_DEVBUF);
 563         kfree(ch, M_DEVBUF);
 564
 565         return 0;
 566 }
 567
 568 int
 569 pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch)
 570 {
 571         struct snddev_channel *sce, *tmp, *after;
 572         unsigned rdevcount;
 573         int device = device_get_unit(d->dev);
 574         size_t namelen;
 575
 576         /*
 577          * Note it's confusing nomenclature.
 578          * dev_t
 579          * device -> pcm_device
 580          * unit -> pcm_channel
 581          * channel -> snddev_channel
 582          * device_t
 583          * unit -> pcm_device
 584          */
 585
 586         sce = kmalloc(sizeof(*sce), M_DEVBUF, M_WAITOK | M_ZERO);
 587
 588         snd_mtxlock(d->lock);
 589         sce->channel = ch;
 590         sce->chan_num = 0;
 591         rdevcount = 0;
 592         after = NULL;
 593         SLIST_FOREACH(tmp, &d->channels, link) {
 594                 if (sce->chan_num == tmp->chan_num)
 595                         sce->chan_num++;
 596                 else {
 597 #if 0
 598                         device_printf(d->dev,
 599                                 "%s: cdev numbering screwed (Expect: %d, Got: %d)\n",
 600                                 __func__, sce->chan_num, tmp->chan_num);
 601 #endif
 602                         goto retry_chan_num_search;
 603                 }
 604                 after = tmp;
 605                 rdevcount++;
 606         }
 607         goto retry_chan_num_search_out;
 608 retry_chan_num_search:
 609         /*
 610          * Look for possible channel numbering collision. This may not
 611          * be optimized, but it will ensure that no collision occured.
 612          * Can be considered cheap since none of the locking/unlocking
 613          * operations involved.
 614          */
 615         rdevcount = 0;
 616         after = NULL;
 617         SLIST_FOREACH(tmp, &d->channels, link) {
 618                 if (sce->chan_num == tmp->chan_num) {
 619                         sce->chan_num++;
 620                         goto retry_chan_num_search;
 621                 }
 622                 if (sce->chan_num > tmp->chan_num)
 623                         after = tmp;
 624                 rdevcount++;
 625         }
 626 retry_chan_num_search_out:
 627         /*
 628          * Don't overflow PCMMKMINOR / PCMMAXCHAN.
 629          */
 630         if (sce->chan_num > PCMMAXCHAN) {
 631                 snd_mtxunlock(d->lock);
 632                 device_printf(d->dev,
 633                         "%s: WARNING: sce->chan_num overflow! (%d)\n",
 634                         __func__, sce->chan_num);
 635                 kfree(sce, M_DEVBUF);
 636                 return E2BIG;
 637         }
 638         if (d->devcount != rdevcount) {
 639                 device_printf(d->dev,
 640                         "%s: WARNING: devcount screwed! d->devcount=%u, rdevcount=%u\n",
 641                         __func__, d->devcount, rdevcount);
 642                 d->devcount = rdevcount;
 643         }
 644         d->devcount++;
 645         if (after == NULL) {
 646                 SLIST_INSERT_HEAD(&d->channels, sce, link);
 647         } else {
 648                 SLIST_INSERT_AFTER(after, sce, link);
 649         }
 650 #if 0
 651         if (1) {
 652                 int cnum = 0;
 653                 SLIST_FOREACH(tmp, &d->channels, link) {
 654                         if (cnum != tmp->chan_num)
 655                                 device_printf(d->dev,
 656                                         "%s: WARNING: inconsistent cdev numbering! (Expect: %d, Got: %d)\n",
 657                                         __func__, cnum, tmp->chan_num);
 658                         cnum++;
 659                 }
 660         }
 661 #endif
 662
 663         namelen = strlen(ch->name);
 664         if ((CHN_NAMELEN - namelen) > 10) {     /* ":dspXX.YYY" */
 665                 ksnprintf(ch->name + namelen,
 666                         CHN_NAMELEN - namelen, ":dsp%d.%d",
 667                         device, sce->chan_num);
 668         }
 669         snd_mtxunlock(d->lock);
 670
 671         /*
 672          * I will revisit these someday, and nuke it mercilessly..
 673          */
 674         sce->dsp_devt = make_dev(&dsp_cdevsw,
 675                             PCMMKMINOR(device, SND_DEV_DSP, sce->chan_num),
 676                             UID_ROOT, GID_WHEEL, 0666, "dsp%d.%d",
 677                             device, sce->chan_num);
 678         reference_dev(sce->dsp_devt);
 679
 680         sce->dspW_devt = make_dev(&dsp_cdevsw,
 681                             PCMMKMINOR(device, SND_DEV_DSP16, sce->chan_num),
 682                             UID_ROOT, GID_WHEEL, 0666, "dspW%d.%d",
 683                             device, sce->chan_num);
 684         reference_dev(sce->dspW_devt);
 685
 686         sce->audio_devt = sce->dsp_devt;
 687         reference_dev(sce->audio_devt);
 688
 689         if (ch->direction == PCMDIR_REC) {
 690                 sce->dspr_devt = make_dev(&dsp_cdevsw,
 691                                     PCMMKMINOR(device, SND_DEV_DSPREC,
 692                                         sce->chan_num), UID_ROOT, GID_WHEEL,
 693                                     0666, "dspr%d.%d", device, sce->chan_num);
 694                 reference_dev(sce->dspr_devt);
 695         }
 696
 697         return 0;
 698 }
 699
 700 int
 701 pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch)
 702 {
 703         struct snddev_channel *sce;
 704 #if 0
 705         int ourlock;
 706
 707         ourlock = 0;
 708         if (!mtx_owned(d->lock)) {
 709                 snd_mtxlock(d->lock);
 710                 ourlock = 1;
 711         }
 712 #endif
 713
 714         SLIST_FOREACH(sce, &d->channels, link) {
 715                 if (sce->channel == ch)
 716                         goto gotit;
 717         }
 718 #if 0
 719         if (ourlock)
 720                 snd_mtxunlock(d->lock);
 721 #endif
 722         return EINVAL;
 723 gotit:
 724         SLIST_REMOVE(&d->channels, sce, snddev_channel, link);
 725
 726         if (ch->flags & CHN_F_VIRTUAL)
 727                 d->vchancount--;
 728         else if (ch->direction == PCMDIR_REC)
 729                 d->reccount--;
 730         else
 731                 d->playcount--;
 732
 733 #if 0
 734         if (ourlock)
 735                 snd_mtxunlock(d->lock);
 736 #endif
 737         kfree(sce, M_DEVBUF);
 738
 739         return 0;
 740 }
 741
 742 int
 743 pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
 744 {
 745         struct snddev_info *d = device_get_softc(dev);
 746         struct pcm_channel *ch;
 747         int err;
 748
 749         ch = pcm_chn_create(d, NULL, cls, dir, devinfo);
 750         if (!ch) {
 751                 device_printf(d->dev, "pcm_chn_create(%s, %d, %p) failed\n", cls->name, dir, devinfo);
 752                 return ENODEV;
 753         }
 754
 755         err = pcm_chn_add(d, ch);
 756         if (err) {
 757                 device_printf(d->dev, "pcm_chn_add(%s) failed, err=%d\n", ch->name, err);
 758                 pcm_chn_destroy(ch);
 759                 return err;
 760         }
 761
 762         return err;
 763 }
 764
 765 static int
 766 pcm_killchan(device_t dev)
 767 {
 768         struct snddev_info *d = device_get_softc(dev);
 769         struct snddev_channel *sce;
 770         struct pcm_channel *ch;
 771         int error = 0;
 772
 773         sce = SLIST_FIRST(&d->channels);
 774         ch = sce->channel;
 775
 776         error = pcm_chn_remove(d, sce->channel);
 777         if (error)
 778                 return (error);
 779         return (pcm_chn_destroy(ch));
 780 }
 781
 782 int
 783 pcm_setstatus(device_t dev, char *str)
 784 {
 785         struct snddev_info *d = device_get_softc(dev);
 786
 787         snd_mtxlock(d->lock);
 788         strncpy(d->status, str, SND_STATUSLEN);
 789         snd_mtxunlock(d->lock);
 790         if (snd_maxautovchans > 0)
 791                 pcm_setvchans(d, 1);
 792         return 0;
 793 }
 794
 795 uint32_t
 796 pcm_getflags(device_t dev)
 797 {
 798         struct snddev_info *d = device_get_softc(dev);
 799
 800         return d->flags;
 801 }
 802
 803 void
 804 pcm_setflags(device_t dev, uint32_t val)
 805 {
 806         struct snddev_info *d = device_get_softc(dev);
 807
 808         d->flags = val;
 809 }
 810
 811 void *
 812 pcm_getdevinfo(device_t dev)
 813 {
 814         struct snddev_info *d = device_get_softc(dev);
 815
 816         return d->devinfo;
 817 }
 818
 819 unsigned int
 820 pcm_getbuffersize(device_t dev, unsigned int min, unsigned int deflt, unsigned int max)
 821 {
 822         struct snddev_info *d = device_get_softc(dev);
 823         int sz, x;
 824
 825         sz = 0;
 826         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "buffersize", &sz) == 0) {
 827                 x = sz;
 828                 RANGE(sz, min, max);
 829                 if (x != sz)
 830                         device_printf(dev, "'buffersize=%d' hint is out of range (%d-%d), using %d\n", x, min, max, sz);
 831                 x = min;
 832                 while (x < sz)
 833                         x <<= 1;
 834                 if (x > sz)
 835                         x >>= 1;
 836                 if (x != sz) {
 837                         device_printf(dev, "'buffersize=%d' hint is not a power of 2, using %d\n", sz, x);
 838                         sz = x;
 839                 }
 840         } else {
 841                 sz = deflt;
 842         }
 843
 844         d->bufsz = sz;
 845
 846         return sz;
 847 }
 848
 849 int
 850 pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
 851 {
 852         struct snddev_info *d = device_get_softc(dev);
 853
 854         if (pcm_veto_load) {
 855                 device_printf(dev, "disabled due to an error while initialising: %d\n", pcm_veto_load);
 856
 857                 return EINVAL;
 858         }
 859
 860         d->lock = snd_mtxcreate(device_get_nameunit(dev), "sound cdev");
 861
 862 #if 0
 863         /*
 864          * d->flags should be cleared by the allocator of the softc.
 865          * We cannot clear this field here because several devices set
 866          * this flag before calling pcm_register().
 867          */
 868         d->flags = 0;
 869 #endif
 870         d->dev = dev;
 871         d->devinfo = devinfo;
 872         d->devcount = 0;
 873         d->reccount = 0;
 874         d->playcount = 0;
 875         d->vchancount = 0;
 876         d->inprog = 0;
 877
 878         SLIST_INIT(&d->channels);
 879
 880         if ((numplay == 0 || numrec == 0) && numplay != numrec)
 881                 d->flags |= SD_F_SIMPLEX;
 882
 883         d->fakechan = fkchan_setup(dev);
 884         chn_init(d->fakechan, NULL, 0, 0);
 885
 886 #ifdef SND_DYNSYSCTL
 887         sysctl_ctx_init(&d->sysctl_tree);
 888         d->sysctl_tree_top = SYSCTL_ADD_NODE(&d->sysctl_tree,
 889                                  SYSCTL_STATIC_CHILDREN(_hw_snd), OID_AUTO,
 890                                  device_get_nameunit(dev), CTLFLAG_RD, 0, "");
 891         if (d->sysctl_tree_top == NULL) {
 892                 sysctl_ctx_free(&d->sysctl_tree);
 893                 goto no;
 894         }
 895         SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
 896             OID_AUTO, "buffersize", CTLFLAG_RD, &d->bufsz, 0, "");
 897 #endif
 898         if (numplay > 0) {
 899                 d->flags |= SD_F_AUTOVCHAN;
 900                 vchan_initsys(dev);
 901         }
 902
 903         sndstat_register(dev, d->status, sndstat_prepare_pcm);
 904         return 0;
 905 no:
 906         snd_mtxfree(d->lock);
 907         return ENXIO;
 908 }
 909
 910 int
 911 pcm_unregister(device_t dev)
 912 {
 913         struct snddev_info *d = device_get_softc(dev);
 914         struct snddev_channel *sce;
 915         struct pcmchan_children *pce;
 916         struct pcm_channel *ch;
 917
 918         if (sndstat_acquire() != 0) {
 919                 device_printf(dev, "unregister: sndstat busy\n");
 920                 return EBUSY;
 921         }
 922
 923         snd_mtxlock(d->lock);
 924         if (d->inprog) {
 925                 device_printf(dev, "unregister: operation in progress\n");
 926                 snd_mtxunlock(d->lock);
 927                 sndstat_release();
 928                 return EBUSY;
 929         }
 930
 931         SLIST_FOREACH(sce, &d->channels, link) {
 932                 ch = sce->channel;
 933                 if (ch->refcount > 0) {
 934                         device_printf(dev, "unregister: channel %s busy (pid %d)\n", ch->name, ch->pid);
 935                         snd_mtxunlock(d->lock);
 936                         sndstat_release();
 937                         return EBUSY;
 938                 }
 939         }
 940
 941         if (mixer_uninit(dev) == EBUSY) {
 942                 device_printf(dev, "unregister: mixer busy\n");
 943                 snd_mtxunlock(d->lock);
 944                 sndstat_release();
 945                 return EBUSY;
 946         }
 947
 948         SLIST_FOREACH(sce, &d->channels, link) {
 949                 int unit = device_get_unit(d->dev);
 950
 951                 if (sce->dsp_devt) {
 952                         release_dev(sce->dsp_devt);
 953                         kprintf("devfs: Please check that only the correct dsp devices were removed!!!\n");
 954                         dev_ops_remove_minor(&dsp_cdevsw,
 955                                     /*PCMMKMINOR(-1, -1, 0),*/
 956                                     PCMMKMINOR(unit, SND_DEV_DSP, sce->chan_num));
 957                         sce->dsp_devt = NULL;
 958                 }
 959                 if (sce->dspW_devt) {
 960                         release_dev(sce->dspW_devt);
 961                         kprintf("devfs: Please check that only the correct dspW devices were removed!!!\n");
 962                         dev_ops_remove_minor(&dsp_cdevsw,
 963                                     /*PCMMKMINOR(-1, -1, 0),*/
 964                                     PCMMKMINOR(unit, SND_DEV_DSP16, sce->chan_num));
 965                         sce->dspW_devt = NULL;
 966                 }
 967                 if (sce->audio_devt) {
 968                         release_dev(sce->audio_devt);
 969                         sce->audio_devt = NULL;
 970                 }
 971                 if (sce->dspr_devt) {
 972                         release_dev(sce->dspr_devt);
 973                         kprintf("devfs: Please check that only the correct dspr devices were removed!!!!\n");
 974                         dev_ops_remove_minor(&dsp_cdevsw,
 975                                     /*PCMMKMINOR(-1, -1, 0),*/
 976                                     PCMMKMINOR(unit, SND_DEV_DSPREC, sce->chan_num));
 977                         sce->dspr_devt = NULL;
 978                 }
 979                 d->devcount--;
 980                 ch = sce->channel;
 981                 if (ch == NULL)
 982                         continue;
 983                 pce = SLIST_FIRST(&ch->children);
 984                 while (pce != NULL) {
 985 #if 0
 986                         device_printf(d->dev, "<%s> removing <%s>\n",
 987                                 ch->name, (pce->channel != NULL) ?
 988                                         pce->channel->name : "unknown");
 989 #endif
 990                         SLIST_REMOVE(&ch->children, pce, pcmchan_children, link);
 991                         kfree(pce, M_DEVBUF);
 992                         pce = SLIST_FIRST(&ch->children);
 993                 }
 994         }
 995
 996 #ifdef SND_DYNSYSCTL
 997         d->sysctl_tree_top = NULL;
 998         sysctl_ctx_free(&d->sysctl_tree);
 999 #endif
1000
1001 #if 0
1002         SLIST_FOREACH(sce, &d->channels, link) {
1003                 ch = sce->channel;
1004                 if (ch == NULL)
1005                         continue;
1006                 if (!SLIST_EMPTY(&ch->children))
1007                         device_printf(d->dev, "%s: WARNING: <%s> dangling child!\n",
1008                                 __func__, ch->name);
1009         }
1010 #endif
1011         while (!SLIST_EMPTY(&d->channels))
1012                 pcm_killchan(dev);
1013
1014         chn_kill(d->fakechan);
1015         fkchan_kill(d->fakechan);
1016
1017 #if 0
1018         device_printf(d->dev, "%s: devcount=%u, playcount=%u, "
1019                 "reccount=%u, vchancount=%u\n",
1020                 __func__, d->devcount, d->playcount, d->reccount,
1021                 d->vchancount);
1022 #endif
1023         snd_mtxunlock(d->lock);
1024         snd_mtxfree(d->lock);
1025         sndstat_unregister(dev);
1026         sndstat_release();
1027         return 0;
1028 }
1029
1030 /************************************************************************/
1031
1032 static int
1033 sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
1034 {
1035         struct snddev_info *d;
1036         struct snddev_channel *sce;
1037         struct pcm_channel *c;
1038         struct pcm_feeder *f;
1039         int pc, rc, vc;
1040
1041         if (verbose < 1)
1042                 return 0;
1043
1044         d = device_get_softc(dev);
1045         if (!d)
1046                 return ENXIO;
1047
1048         snd_mtxlock(d->lock);
1049         if (!SLIST_EMPTY(&d->channels)) {
1050                 pc = rc = vc = 0;
1051                 SLIST_FOREACH(sce, &d->channels, link) {
1052                         c = sce->channel;
1053                         if (c->direction == PCMDIR_PLAY) {
1054                                 if (c->flags & CHN_F_VIRTUAL)
1055                                         vc++;
1056                                 else
1057                                         pc++;
1058                         } else
1059                                 rc++;
1060                 }
1061                 sbuf_printf(s, " (%dp/%dr/%dv channels%s%s)", d->playcount, d->reccount, d->vchancount,
1062                                 (d->flags & SD_F_SIMPLEX)? "" : " duplex",
1063 #ifdef USING_DEVFS
1064                                 (device_get_unit(dev) == snd_unit)? " default" : ""
1065 #else
1066                                 ""
1067 #endif
1068                                 );
1069
1070                 if (verbose <= 1) {
1071                         snd_mtxunlock(d->lock);
1072                         return 0;
1073                 }
1074
1075                 SLIST_FOREACH(sce, &d->channels, link) {
1076                         c = sce->channel;
1077
1078                         KASSERT(c->bufhard != NULL && c->bufsoft != NULL,
1079                                 ("hosed pcm channel setup"));
1080
1081                         sbuf_printf(s, "\n\t");
1082
1083                         /* it would be better to indent child channels */
1084                         sbuf_printf(s, "%s[%s]: ", c->parentchannel? c->parentchannel->name : "", c->name);
1085                         sbuf_printf(s, "spd %d", c->speed);
1086                         if (c->speed != sndbuf_getspd(c->bufhard))
1087                                 sbuf_printf(s, "/%d", sndbuf_getspd(c->bufhard));
1088                         sbuf_printf(s, ", fmt 0x%08x", c->format);
1089                         if (c->format != sndbuf_getfmt(c->bufhard))
1090                                 sbuf_printf(s, "/0x%08x", sndbuf_getfmt(c->bufhard));
1091                         sbuf_printf(s, ", flags 0x%08x, 0x%08x", c->flags, c->feederflags);
1092                         if (c->pid != -1)
1093                                 sbuf_printf(s, ", pid %d", c->pid);
1094                         sbuf_printf(s, "\n\t");
1095
1096                         sbuf_printf(s, "interrupts %d, ", c->interrupts);
1097                         if (c->direction == PCMDIR_REC)
1098                                 sbuf_printf(s, "overruns %d, hfree %d, sfree %d [b:%d/%d/%d|bs:%d/%d/%d]",
1099                                         c->xruns, sndbuf_getfree(c->bufhard), sndbuf_getfree(c->bufsoft),
1100                                         sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
1101                                         sndbuf_getblkcnt(c->bufhard),
1102                                         sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
1103                                         sndbuf_getblkcnt(c->bufsoft));
1104                         else
1105                                 sbuf_printf(s, "underruns %d, ready %d [b:%d/%d/%d|bs:%d/%d/%d]",
1106                                         c->xruns, sndbuf_getready(c->bufsoft),
1107                                         sndbuf_getsize(c->bufhard), sndbuf_getblksz(c->bufhard),
1108                                         sndbuf_getblkcnt(c->bufhard),
1109                                         sndbuf_getsize(c->bufsoft), sndbuf_getblksz(c->bufsoft),
1110                                         sndbuf_getblkcnt(c->bufsoft));
1111                         sbuf_printf(s, "\n\t");
1112
1113                         sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "hardware" : "userland");
1114                         sbuf_printf(s, " -> ");
1115                         f = c->feeder;
1116                         while (f->source != NULL)
1117                                 f = f->source;
1118                         while (f != NULL) {
1119                                 sbuf_printf(s, "%s", f->class->name);
1120                                 if (f->desc->type == FEEDER_FMT)
1121                                         sbuf_printf(s, "(0x%08x -> 0x%08x)", f->desc->in, f->desc->out);
1122                                 if (f->desc->type == FEEDER_RATE)
1123                                         sbuf_printf(s, "(%d -> %d)", FEEDER_GET(f, FEEDRATE_SRC), FEEDER_GET(f, FEEDRATE_DST));
1124                                 if (f->desc->type == FEEDER_ROOT || f->desc->type == FEEDER_MIXER ||
1125                                                 f->desc->type == FEEDER_VOLUME)
1126                                         sbuf_printf(s, "(0x%08x)", f->desc->out);
1127                                 sbuf_printf(s, " -> ");
1128                                 f = f->parent;
1129                         }
1130                         sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "userland" : "hardware");
1131                 }
1132         } else
1133                 sbuf_printf(s, " (mixer only)");
1134         snd_mtxunlock(d->lock);
1135
1136         return 0;
1137 }
1138
1139 /************************************************************************/
1140
1141 #ifdef SND_DYNSYSCTL
1142 int
1143 sysctl_hw_snd_vchans(SYSCTL_HANDLER_ARGS)
1144 {
1145         struct snddev_info *d;
1146         int err, newcnt;
1147
1148         d = oidp->oid_arg1;
1149
1150         newcnt = d->vchancount;
1151         err = sysctl_handle_int(oidp, &newcnt, sizeof(newcnt), req);
1152
1153         if (err == 0 && req->newptr != NULL && d->vchancount != newcnt)
1154                 err = pcm_setvchans(d, newcnt);
1155
1156         return err;
1157 }
1158 #endif
1159
1160 /************************************************************************/
1161
1162 static int
1163 sound_modevent(module_t mod, int type, void *data)
1164 {
1165 #if 0
1166         return (midi_modevent(mod, type, data));
1167 #else
1168         return 0;
1169 #endif
1170 }
1171
1172 DEV_MODULE(sound, sound_modevent, NULL);
1173 MODULE_VERSION(sound, SOUND_MODVER);