sys/dev/sound/pcm/sound.c

   1 /*-
   2  * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
   3  * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
   4  * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
   5  * Copyright (c) 1997 Luigi Rizzo
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ifdef HAVE_KERNEL_OPTION_HEADERS
  31 #include "opt_snd.h"
  32 #endif
  33
  34 #include <dev/sound/pcm/sound.h>
  35 #include <dev/sound/pcm/ac97.h>
  36 #include <dev/sound/pcm/vchan.h>
  37 #include <dev/sound/pcm/dsp.h>
  38 #include <dev/sound/pcm/sndstat.h>
  39 #include <dev/sound/version.h>
  40 #include <sys/devfs.h>
  41 #include <sys/limits.h>
  42 #include <sys/sysctl.h>
  43
  44 #include "feeder_if.h"
  45
  46 SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pcm/sound.c 274035 2014-11-03 11:11:45Z bapt $");
  47
  48 devclass_t pcm_devclass;
  49
  50 int pcm_veto_load = 1;
  51
  52 int snd_unit = -1;
  53 TUNABLE_INT("hw.snd.default_unit", &snd_unit);
  54
  55 static int snd_unit_auto = -1;
  56 TUNABLE_INT("hw.snd.default_auto", &snd_unit_auto);
  57 SYSCTL_INT(_hw_snd, OID_AUTO, default_auto, CTLFLAG_RW,
  58     &snd_unit_auto, 0, "assign default unit to a newly attached device");
  59
  60 int snd_maxautovchans = 16;
  61 /* XXX: a tunable implies that we may need more than one sound channel before
  62    the system can change a sysctl (/etc/sysctl.conf), do we really need
  63    this? */
  64 TUNABLE_INT("hw.snd.maxautovchans", &snd_maxautovchans);
  65
  66 SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD, 0, "Sound driver");
  67
  68 /*
  69  * XXX I've had enough with people not telling proper version/arch
  70  *     while reporting problems, not after 387397913213th questions/requests.
  71  */
  72 static char snd_driver_version[] =
  73     __XSTRING(SND_DRV_VERSION)"/"MACHINE_ARCH;
  74 SYSCTL_STRING(_hw_snd, OID_AUTO, version, CTLFLAG_RD, &snd_driver_version,
  75     0, "driver version/arch");
  76
  77 /**
  78  * @brief Unit number allocator for syncgroup IDs
  79  */
  80 struct unrhdr *pcmsg_unrhdr = NULL;
  81
  82 static int
  83 sndstat_prepare_pcm(SNDSTAT_PREPARE_PCM_ARGS)
  84 {
  85         SNDSTAT_PREPARE_PCM_BEGIN();
  86         SNDSTAT_PREPARE_PCM_END();
  87 }
  88
  89 void *
  90 snd_mtxcreate(const char *desc, const char *type)
  91 {
  92         struct lock *m;
  93
  94         m = kmalloc(sizeof(*m), M_DEVBUF, M_WAITOK | M_ZERO);
  95         lockinit(m, desc, 0, LK_CANRECURSE);
  96         return m;
  97 }
  98
  99 void
 100 snd_mtxfree(void *m)
 101 {
 102         struct lock *mtx = m;
 103
 104         lockuninit(mtx);
 105         kfree(mtx, M_DEVBUF);
 106 }
 107
 108 void
 109 snd_mtxassert(void *m)
 110 {
 111         struct lock *lk = m;
 112
 113         KKASSERT(lockstatus(lk, curthread) != 0);
 114 }
 115
 116 int
 117 snd_setup_intr(device_t dev, struct resource *res, int flags, driver_intr_t hand, void *param, void **cookiep)
 118 {
 119         struct snddev_info *d;
 120
 121         flags &= INTR_MPSAFE;
 122         d = device_get_softc(dev);
 123         if (d != NULL && (flags & INTR_MPSAFE))
 124                 d->flags |= SD_F_MPSAFE;
 125
 126         return bus_setup_intr(dev, res, flags, hand, param, cookiep, NULL);
 127 }
 128
 129 static void
 130 pcm_clonereset(struct snddev_info *d)
 131 {
 132         int cmax;
 133
 134         PCM_BUSYASSERT(d);
 135
 136         cmax = d->playcount + d->reccount - 1;
 137         if (d->pvchancount > 0)
 138                 cmax += max(d->pvchancount, snd_maxautovchans) - 1;
 139         if (d->rvchancount > 0)
 140                 cmax += max(d->rvchancount, snd_maxautovchans) - 1;
 141         if (cmax > PCMMAXCLONE)
 142                 cmax = PCMMAXCLONE;
 143         (void)snd_clone_gc(d->clones);
 144         (void)snd_clone_setmaxunit(d->clones, cmax);
 145 }
 146
 147 int
 148 pcm_setvchans(struct snddev_info *d, int direction, int newcnt, int num)
 149 {
 150         struct pcm_channel *c, *ch, *nch;
 151         struct pcmchan_caps *caps;
 152         int i, err, vcnt;
 153
 154         PCM_BUSYASSERT(d);
 155
 156         if ((direction == PCMDIR_PLAY && d->playcount < 1) ||
 157             (direction == PCMDIR_REC && d->reccount < 1))
 158                 return (ENODEV);
 159
 160         if (!(d->flags & SD_F_AUTOVCHAN))
 161                 return (EINVAL);
 162
 163         if (newcnt < 0 || newcnt > SND_MAXVCHANS)
 164                 return (E2BIG);
 165
 166         if (direction == PCMDIR_PLAY)
 167                 vcnt = d->pvchancount;
 168         else if (direction == PCMDIR_REC)
 169                 vcnt = d->rvchancount;
 170         else
 171                 return (EINVAL);
 172
 173         if (newcnt > vcnt) {
 174                 KASSERT(num == -1 ||
 175                     (num >= 0 && num < SND_MAXVCHANS && (newcnt - 1) == vcnt),
 176                     ("bogus vchan_create() request num=%d newcnt=%d vcnt=%d",
 177                     num, newcnt, vcnt));
 178                 /* add new vchans - find a parent channel first */
 179                 ch = NULL;
 180                 CHN_FOREACH(c, d, channels.pcm) {
 181                         CHN_LOCK(c);
 182                         if (c->direction == direction &&
 183                             ((c->flags & CHN_F_HAS_VCHAN) || (vcnt == 0 &&
 184                             c->refcount < 1 &&
 185                             !(c->flags & (CHN_F_BUSY | CHN_F_VIRTUAL))))) {
 186                                 /*
 187                                  * Reuse hw channel with vchans already
 188                                  * created.
 189                                  */
 190                                 if (c->flags & CHN_F_HAS_VCHAN) {
 191                                         ch = c;
 192                                         break;
 193                                 }
 194                                 /*
 195                                  * No vchans ever created, look for
 196                                  * channels with supported formats.
 197                                  */
 198                                 caps = chn_getcaps(c);
 199                                 if (caps == NULL) {
 200                                         CHN_UNLOCK(c);
 201                                         continue;
 202                                 }
 203                                 for (i = 0; caps->fmtlist[i] != 0; i++) {
 204                                         if (caps->fmtlist[i] & AFMT_CONVERTIBLE)
 205                                                 break;
 206                                 }
 207                                 if (caps->fmtlist[i] != 0) {
 208                                         ch = c;
 209                                         break;
 210                                 }
 211                         }
 212                         CHN_UNLOCK(c);
 213                 }
 214                 if (ch == NULL)
 215                         return (EBUSY);
 216                 ch->flags |= CHN_F_BUSY;
 217                 err = 0;
 218                 while (err == 0 && newcnt > vcnt) {
 219                         err = vchan_create(ch, num);
 220                         if (err == 0)
 221                                 vcnt++;
 222                         else if (err == E2BIG && newcnt > vcnt)
 223                                 device_printf(d->dev,
 224                                     "%s: err=%d Maximum channel reached.\n",
 225                                     __func__, err);
 226                 }
 227                 if (vcnt == 0)
 228                         ch->flags &= ~CHN_F_BUSY;
 229                 CHN_UNLOCK(ch);
 230                 if (err != 0)
 231                         return (err);
 232                 else
 233                         pcm_clonereset(d);
 234         } else if (newcnt < vcnt) {
 235                 KASSERT(num == -1,
 236                     ("bogus vchan_destroy() request num=%d", num));
 237                 CHN_FOREACH(c, d, channels.pcm) {
 238                         CHN_LOCK(c);
 239                         if (c->direction != direction ||
 240                             CHN_EMPTY(c, children) ||
 241                             !(c->flags & CHN_F_HAS_VCHAN)) {
 242                                 CHN_UNLOCK(c);
 243                                 continue;
 244                         }
 245                         CHN_FOREACH_SAFE(ch, c, nch, children) {
 246                                 CHN_LOCK(ch);
 247                                 if (vcnt == 1 && c->refcount > 0) {
 248                                         CHN_UNLOCK(ch);
 249                                         break;
 250                                 }
 251                                 if (!(ch->flags & CHN_F_BUSY) &&
 252                                     ch->refcount < 1) {
 253                                         err = vchan_destroy(ch);
 254                                         if (err == 0)
 255                                                 vcnt--;
 256                                 } else
 257                                         CHN_UNLOCK(ch);
 258                                 if (vcnt == newcnt)
 259                                         break;
 260                         }
 261                         CHN_UNLOCK(c);
 262                         break;
 263                 }
 264                 pcm_clonereset(d);
 265         }
 266
 267         return (0);
 268 }
 269
 270 /* return error status and a locked channel */
 271 int
 272 pcm_chnalloc(struct snddev_info *d, struct pcm_channel **ch, int direction,
 273     pid_t pid, char *comm, int devunit)
 274 {
 275         struct pcm_channel *c;
 276         int err, vchancount, vchan_num;
 277
 278         KASSERT(d != NULL && ch != NULL && (devunit == -1 ||
 279             !(devunit & ~(SND_U_MASK | SND_D_MASK | SND_C_MASK))) &&
 280             (direction == PCMDIR_PLAY || direction == PCMDIR_REC),
 281             ("%s(): invalid d=%p ch=%p direction=%d pid=%d devunit=%d",
 282             __func__, d, ch, direction, pid, devunit));
 283         PCM_BUSYASSERT(d);
 284
 285         /* Double check again. */
 286         if (devunit != -1) {
 287                 switch (snd_unit2d(devunit)) {
 288                 case SND_DEV_DSPHW_PLAY:
 289                 case SND_DEV_DSPHW_VPLAY:
 290                         if (direction != PCMDIR_PLAY)
 291                                 return (ENOTSUP);
 292                         break;
 293                 case SND_DEV_DSPHW_REC:
 294                 case SND_DEV_DSPHW_VREC:
 295                         if (direction != PCMDIR_REC)
 296                                 return (ENOTSUP);
 297                         break;
 298                 default:
 299                         if (!(direction == PCMDIR_PLAY ||
 300                             direction == PCMDIR_REC))
 301                                 return (ENOTSUP);
 302                         break;
 303                 }
 304         }
 305
 306         *ch = NULL;
 307         vchan_num = 0;
 308         vchancount = (direction == PCMDIR_PLAY) ? d->pvchancount :
 309             d->rvchancount;
 310
 311 retry_chnalloc:
 312         err = ENOTSUP;
 313         /* scan for a free channel */
 314         CHN_FOREACH(c, d, channels.pcm) {
 315                 CHN_LOCK(c);
 316                 if (devunit == -1 && c->direction == direction &&
 317                     (c->flags & CHN_F_VIRTUAL)) {
 318                         if (vchancount < snd_maxautovchans &&
 319                             vchan_num < CHN_CHAN(c)) {
 320                                 CHN_UNLOCK(c);
 321                                 goto vchan_alloc;
 322                         }
 323                         vchan_num++;
 324                 }
 325                 if (c->direction == direction && !(c->flags & CHN_F_BUSY) &&
 326                     (devunit == -1 || devunit == -2 || c->unit == devunit)) {
 327                         c->flags |= CHN_F_BUSY;
 328                         c->pid = pid;
 329                         strlcpy(c->comm, (comm != NULL) ? comm :
 330                             CHN_COMM_UNKNOWN, sizeof(c->comm));
 331                         *ch = c;
 332                         return (0);
 333                 } else if (c->unit == devunit) {
 334                         if (c->direction != direction)
 335                                 err = ENOTSUP;
 336                         else if (c->flags & CHN_F_BUSY)
 337                                 err = EBUSY;
 338                         else
 339                                 err = EINVAL;
 340                         CHN_UNLOCK(c);
 341                         return (err);
 342                 } else if ((devunit == -1 || devunit == -2) &&
 343                     c->direction == direction && (c->flags & CHN_F_BUSY))
 344                         err = EBUSY;
 345                 CHN_UNLOCK(c);
 346         }
 347
 348         if (devunit == -2)
 349                 return (err);
 350
 351 vchan_alloc:
 352         /* no channel available */
 353         if (devunit == -1 || snd_unit2d(devunit) == SND_DEV_DSPHW_VPLAY ||
 354             snd_unit2d(devunit) == SND_DEV_DSPHW_VREC) {
 355                 if (!(vchancount > 0 && vchancount < snd_maxautovchans) &&
 356                     (devunit == -1 || snd_unit2c(devunit) < snd_maxautovchans))
 357                         return (err);
 358                 err = pcm_setvchans(d, direction, vchancount + 1,
 359                     (devunit == -1) ? -1 : snd_unit2c(devunit));
 360                 if (err == 0) {
 361                         if (devunit == -1)
 362                                 devunit = -2;
 363                         goto retry_chnalloc;
 364                 }
 365         }
 366
 367         return (err);
 368 }
 369
 370 /* release a locked channel and unlock it */
 371 int
 372 pcm_chnrelease(struct pcm_channel *c)
 373 {
 374         PCM_BUSYASSERT(c->parentsnddev);
 375         CHN_LOCKASSERT(c);
 376
 377         c->flags &= ~CHN_F_BUSY;
 378         c->pid = -1;
 379         strlcpy(c->comm, CHN_COMM_UNUSED, sizeof(c->comm));
 380         CHN_UNLOCK(c);
 381
 382         return (0);
 383 }
 384
 385 int
 386 pcm_chnref(struct pcm_channel *c, int ref)
 387 {
 388         PCM_BUSYASSERT(c->parentsnddev);
 389         CHN_LOCKASSERT(c);
 390
 391         c->refcount += ref;
 392
 393         return (c->refcount);
 394 }
 395
 396 int
 397 pcm_inprog(struct snddev_info *d, int delta)
 398 {
 399         PCM_LOCKASSERT(d);
 400
 401         d->inprog += delta;
 402
 403         return (d->inprog);
 404 }
 405
 406 static void
 407 pcm_setmaxautovchans(struct snddev_info *d, int num)
 408 {
 409         PCM_BUSYASSERT(d);
 410
 411         if (num < 0)
 412                 return;
 413
 414         if (num >= 0 && d->pvchancount > num)
 415                 (void)pcm_setvchans(d, PCMDIR_PLAY, num, -1);
 416         else if (num > 0 && d->pvchancount == 0)
 417                 (void)pcm_setvchans(d, PCMDIR_PLAY, 1, -1);
 418
 419         if (num >= 0 && d->rvchancount > num)
 420                 (void)pcm_setvchans(d, PCMDIR_REC, num, -1);
 421         else if (num > 0 && d->rvchancount == 0)
 422                 (void)pcm_setvchans(d, PCMDIR_REC, 1, -1);
 423
 424         pcm_clonereset(d);
 425 }
 426
 427 static int
 428 sysctl_hw_snd_default_unit(SYSCTL_HANDLER_ARGS)
 429 {
 430         struct snddev_info *d;
 431         int error, unit;
 432
 433         unit = snd_unit;
 434         error = sysctl_handle_int(oidp, &unit, 0, req);
 435         if (error == 0 && req->newptr != NULL) {
 436                 d = devclass_get_softc(pcm_devclass, unit);
 437                 if (!PCM_REGISTERED(d) || CHN_EMPTY(d, channels.pcm))
 438                         return EINVAL;
 439                 snd_unit = unit;
 440                 snd_unit_auto = 0;
 441         }
 442         return (error);
 443 }
 444 /* XXX: do we need a way to let the user change the default unit? */
 445 SYSCTL_PROC(_hw_snd, OID_AUTO, default_unit,
 446             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
 447             0, sizeof(int), sysctl_hw_snd_default_unit, "I",
 448             "default sound device");
 449
 450 static int
 451 sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
 452 {
 453         struct snddev_info *d;
 454         int i, v, error;
 455
 456         v = snd_maxautovchans;
 457         error = sysctl_handle_int(oidp, &v, 0, req);
 458         if (error == 0 && req->newptr != NULL) {
 459                 if (v < 0)
 460                         v = 0;
 461                 if (v > SND_MAXVCHANS)
 462                         v = SND_MAXVCHANS;
 463                 snd_maxautovchans = v;
 464                 for (i = 0; pcm_devclass != NULL &&
 465                     i < devclass_get_maxunit(pcm_devclass); i++) {
 466                         d = devclass_get_softc(pcm_devclass, i);
 467                         if (!PCM_REGISTERED(d))
 468                                 continue;
 469                         PCM_ACQUIRE_QUICK(d);
 470                         pcm_setmaxautovchans(d, v);
 471                         PCM_RELEASE_QUICK(d);
 472                 }
 473         }
 474         return (error);
 475 }
 476 SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans, CTLTYPE_INT | CTLFLAG_RW,
 477             0, sizeof(int), sysctl_hw_snd_maxautovchans, "I", "maximum virtual channel");
 478
 479 struct pcm_channel *
 480 pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, int num, void *devinfo)
 481 {
 482         struct pcm_channel *ch;
 483         int direction, err, rpnum, *pnum, max;
 484         int udc, device, chan;
 485         char *dirs, *devname, buf[CHN_NAMELEN];
 486
 487         PCM_BUSYASSERT(d);
 488         PCM_LOCKASSERT(d);
 489         KASSERT(num >= -1, ("invalid num=%d", num));
 490
 491
 492         switch (dir) {
 493         case PCMDIR_PLAY:
 494                 dirs = "play";
 495                 direction = PCMDIR_PLAY;
 496                 pnum = &d->playcount;
 497                 device = SND_DEV_DSPHW_PLAY;
 498                 max = SND_MAXHWCHAN;
 499                 break;
 500         case PCMDIR_PLAY_VIRTUAL:
 501                 dirs = "virtual";
 502                 direction = PCMDIR_PLAY;
 503                 pnum = &d->pvchancount;
 504                 device = SND_DEV_DSPHW_VPLAY;
 505                 max = SND_MAXVCHANS;
 506                 break;
 507         case PCMDIR_REC:
 508                 dirs = "record";
 509                 direction = PCMDIR_REC;
 510                 pnum = &d->reccount;
 511                 device = SND_DEV_DSPHW_REC;
 512                 max = SND_MAXHWCHAN;
 513                 break;
 514         case PCMDIR_REC_VIRTUAL:
 515                 dirs = "virtual";
 516                 direction = PCMDIR_REC;
 517                 pnum = &d->rvchancount;
 518                 device = SND_DEV_DSPHW_VREC;
 519                 max = SND_MAXVCHANS;
 520                 break;
 521         default:
 522                 return (NULL);
 523         }
 524
 525         chan = (num == -1) ? 0 : num;
 526
 527         if (*pnum >= max || chan >= max)
 528                 return (NULL);
 529
 530         rpnum = 0;
 531
 532         CHN_FOREACH(ch, d, channels.pcm) {
 533                 if (CHN_DEV(ch) != device)
 534                         continue;
 535                 if (chan == CHN_CHAN(ch)) {
 536                         if (num != -1) {
 537                                 device_printf(d->dev,
 538                                     "channel num=%d allocated!\n", chan);
 539                                 return (NULL);
 540                         }
 541                         chan++;
 542                         if (chan >= max) {
 543                                 device_printf(d->dev,
 544                                     "chan=%d > %d\n", chan, max);
 545                                 return (NULL);
 546                         }
 547                 }
 548                 rpnum++;
 549         }
 550
 551         if (*pnum != rpnum) {
 552                 device_printf(d->dev,
 553                     "%s(): WARNING: pnum screwed : dirs=%s pnum=%d rpnum=%d\n",
 554                     __func__, dirs, *pnum, rpnum);
 555                 return (NULL);
 556         }
 557
 558         udc = snd_mkunit(device_get_unit(d->dev), device, chan);
 559         devname = dsp_unit2name(buf, sizeof(buf), udc);
 560
 561         if (devname == NULL) {
 562                 device_printf(d->dev,
 563                     "Failed to query device name udc=0x%08x\n", udc);
 564                 return (NULL);
 565         }
 566
 567         PCM_UNLOCK(d);
 568         ch = kmalloc(sizeof(*ch), M_DEVBUF, M_WAITOK | M_ZERO);
 569         ch->methods = kobj_create(cls, M_DEVBUF, M_WAITOK | M_ZERO);
 570         ch->unit = udc;
 571         ch->pid = -1;
 572         strlcpy(ch->comm, CHN_COMM_UNUSED, sizeof(ch->comm));
 573         ch->parentsnddev = d;
 574         ch->parentchannel = parent;
 575         ch->dev = d->dev;
 576         ch->trigger = PCMTRIG_STOP;
 577         ksnprintf(ch->name, sizeof(ch->name), "%s:%s:%s",
 578             device_get_nameunit(ch->dev), dirs, devname);
 579
 580         err = chn_init(ch, devinfo, dir, direction);
 581         PCM_LOCK(d);
 582         if (err) {
 583                 device_printf(d->dev, "chn_init(%s) failed: err = %d\n",
 584                     ch->name, err);
 585                 kobj_delete(ch->methods, M_DEVBUF);
 586                 kfree(ch, M_DEVBUF);
 587                 return (NULL);
 588         }
 589
 590         return (ch);
 591 }
 592
 593 int
 594 pcm_chn_destroy(struct pcm_channel *ch)
 595 {
 596         struct snddev_info *d;
 597         int err;
 598
 599         d = ch->parentsnddev;
 600         PCM_BUSYASSERT(d);
 601
 602         err = chn_kill(ch);
 603         if (err) {
 604                 device_printf(ch->dev, "chn_kill(%s) failed, err = %d\n",
 605                     ch->name, err);
 606                 return (err);
 607         }
 608
 609         kobj_delete(ch->methods, M_DEVBUF);
 610         kfree(ch, M_DEVBUF);
 611
 612         return (0);
 613 }
 614
 615 int
 616 pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch)
 617 {
 618         PCM_BUSYASSERT(d);
 619         PCM_LOCKASSERT(d);
 620         KASSERT(ch != NULL && (ch->direction == PCMDIR_PLAY ||
 621             ch->direction == PCMDIR_REC), ("Invalid pcm channel"));
 622
 623         CHN_INSERT_SORT_ASCEND(d, ch, channels.pcm);
 624
 625         switch (CHN_DEV(ch)) {
 626         case SND_DEV_DSPHW_PLAY:
 627                 d->playcount++;
 628                 break;
 629         case SND_DEV_DSPHW_VPLAY:
 630                 d->pvchancount++;
 631                 break;
 632         case SND_DEV_DSPHW_REC:
 633                 d->reccount++;
 634                 break;
 635         case SND_DEV_DSPHW_VREC:
 636                 d->rvchancount++;
 637                 break;
 638         default:
 639                 break;
 640         }
 641
 642         d->devcount++;
 643
 644         return (0);
 645 }
 646
 647 int
 648 pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch)
 649 {
 650         struct pcm_channel *tmp;
 651
 652         PCM_BUSYASSERT(d);
 653         PCM_LOCKASSERT(d);
 654
 655         tmp = NULL;
 656
 657         CHN_FOREACH(tmp, d, channels.pcm) {
 658                 if (tmp == ch)
 659                         break;
 660         }
 661
 662         if (tmp != ch)
 663                 return (EINVAL);
 664
 665         CHN_REMOVE(d, ch, channels.pcm);
 666
 667         switch (CHN_DEV(ch)) {
 668         case SND_DEV_DSPHW_PLAY:
 669                 d->playcount--;
 670                 break;
 671         case SND_DEV_DSPHW_VPLAY:
 672                 d->pvchancount--;
 673                 break;
 674         case SND_DEV_DSPHW_REC:
 675                 d->reccount--;
 676                 break;
 677         case SND_DEV_DSPHW_VREC:
 678                 d->rvchancount--;
 679                 break;
 680         default:
 681                 break;
 682         }
 683
 684         d->devcount--;
 685
 686         return (0);
 687 }
 688
 689 int
 690 pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
 691 {
 692         struct snddev_info *d = device_get_softc(dev);
 693         struct pcm_channel *ch;
 694         int err;
 695
 696         PCM_BUSYASSERT(d);
 697
 698         PCM_LOCK(d);
 699         ch = pcm_chn_create(d, NULL, cls, dir, -1, devinfo);
 700         if (!ch) {
 701                 device_printf(d->dev, "pcm_chn_create(%s, %d, %p) failed\n",
 702                     cls->name, dir, devinfo);
 703                 PCM_UNLOCK(d);
 704                 return (ENODEV);
 705         }
 706
 707         err = pcm_chn_add(d, ch);
 708         PCM_UNLOCK(d);
 709         if (err) {
 710                 device_printf(d->dev, "pcm_chn_add(%s) failed, err=%d\n",
 711                     ch->name, err);
 712                 pcm_chn_destroy(ch);
 713         }
 714
 715         return (err);
 716 }
 717
 718 static int
 719 pcm_killchan(device_t dev)
 720 {
 721         struct snddev_info *d = device_get_softc(dev);
 722         struct pcm_channel *ch;
 723         int error;
 724
 725         PCM_BUSYASSERT(d);
 726
 727         ch = CHN_FIRST(d, channels.pcm);
 728
 729         PCM_LOCK(d);
 730         error = pcm_chn_remove(d, ch);
 731         PCM_UNLOCK(d);
 732         if (error)
 733                 return (error);
 734         return (pcm_chn_destroy(ch));
 735 }
 736
 737 static int
 738 pcm_best_unit(int old)
 739 {
 740         struct snddev_info *d;
 741         int i, best, bestprio, prio;
 742
 743         best = -1;
 744         bestprio = -100;
 745         for (i = 0; pcm_devclass != NULL &&
 746             i < devclass_get_maxunit(pcm_devclass); i++) {
 747                 d = devclass_get_softc(pcm_devclass, i);
 748                 if (!PCM_REGISTERED(d))
 749                         continue;
 750                 prio = 0;
 751                 if (d->playcount == 0)
 752                         prio -= 10;
 753                 if (d->reccount == 0)
 754                         prio -= 2;
 755                 if (prio > bestprio || (prio == bestprio && i == old)) {
 756                         best = i;
 757                         bestprio = prio;
 758                 }
 759         }
 760         return (best);
 761 }
 762
 763 int
 764 pcm_setstatus(device_t dev, char *str)
 765 {
 766         struct snddev_info *d = device_get_softc(dev);
 767
 768         PCM_BUSYASSERT(d);
 769
 770         if (d->playcount == 0 || d->reccount == 0)
 771                 d->flags |= SD_F_SIMPLEX;
 772
 773         if ((d->playcount > 0 || d->reccount > 0) &&
 774             !(d->flags & SD_F_AUTOVCHAN)) {
 775                 d->flags |= SD_F_AUTOVCHAN;
 776                 vchan_initsys(dev);
 777         }
 778
 779         pcm_setmaxautovchans(d, snd_maxautovchans);
 780
 781         strlcpy(d->status, str, SND_STATUSLEN);
 782
 783         PCM_LOCK(d);
 784
 785         /* Last stage, enable cloning. */
 786         if (d->clones != NULL)
 787                 (void)snd_clone_enable(d->clones);
 788
 789         /* Done, we're ready.. */
 790         d->flags |= SD_F_REGISTERED;
 791
 792         PCM_RELEASE(d);
 793
 794         PCM_UNLOCK(d);
 795
 796         if (snd_unit_auto < 0)
 797                 snd_unit_auto = (snd_unit < 0) ? 1 : 0;
 798         if (snd_unit < 0 || snd_unit_auto > 1)
 799                 snd_unit = device_get_unit(dev);
 800         else if (snd_unit_auto == 1)
 801                 snd_unit = pcm_best_unit(snd_unit);
 802
 803         return (0);
 804 }
 805
 806 uint32_t
 807 pcm_getflags(device_t dev)
 808 {
 809         struct snddev_info *d = device_get_softc(dev);
 810
 811         return d->flags;
 812 }
 813
 814 void
 815 pcm_setflags(device_t dev, uint32_t val)
 816 {
 817         struct snddev_info *d = device_get_softc(dev);
 818
 819         d->flags = val;
 820 }
 821
 822 void *
 823 pcm_getdevinfo(device_t dev)
 824 {
 825         struct snddev_info *d = device_get_softc(dev);
 826
 827         return d->devinfo;
 828 }
 829
 830 unsigned int
 831 pcm_getbuffersize(device_t dev, unsigned int minbufsz, unsigned int deflt, unsigned int maxbufsz)
 832 {
 833         struct snddev_info *d = device_get_softc(dev);
 834         int sz, x;
 835
 836         sz = 0;
 837         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "buffersize", &sz) == 0) {
 838                 x = sz;
 839                 RANGE(sz, minbufsz, maxbufsz);
 840                 if (x != sz)
 841                         device_printf(dev, "'buffersize=%d' hint is out of range (%d-%d), using %d\n", x, minbufsz, maxbufsz, sz);
 842                 x = minbufsz;
 843                 while (x < sz)
 844                         x <<= 1;
 845                 if (x > sz)
 846                         x >>= 1;
 847                 if (x != sz) {
 848                         device_printf(dev, "'buffersize=%d' hint is not a power of 2, using %d\n", sz, x);
 849                         sz = x;
 850                 }
 851         } else {
 852                 sz = deflt;
 853         }
 854
 855         d->bufsz = sz;
 856
 857         return sz;
 858 }
 859
 860 static int
 861 sysctl_dev_pcm_bitperfect(SYSCTL_HANDLER_ARGS)
 862 {
 863         struct snddev_info *d;
 864         int err, val;
 865
 866         d = oidp->oid_arg1;
 867         if (!PCM_REGISTERED(d))
 868                 return (ENODEV);
 869
 870         PCM_LOCK(d);
 871         PCM_WAIT(d);
 872         val = (d->flags & SD_F_BITPERFECT) ? 1 : 0;
 873         PCM_ACQUIRE(d);
 874         PCM_UNLOCK(d);
 875
 876         err = sysctl_handle_int(oidp, &val, 0, req);
 877
 878         if (err == 0 && req->newptr != NULL) {
 879                 if (!(val == 0 || val == 1)) {
 880                         PCM_RELEASE_QUICK(d);
 881                         return (EINVAL);
 882                 }
 883
 884                 PCM_LOCK(d);
 885
 886                 d->flags &= ~SD_F_BITPERFECT;
 887                 d->flags |= (val != 0) ? SD_F_BITPERFECT : 0;
 888
 889                 PCM_RELEASE(d);
 890                 PCM_UNLOCK(d);
 891         } else
 892                 PCM_RELEASE_QUICK(d);
 893
 894         return (err);
 895 }
 896
 897 #ifdef SND_DEBUG
 898 static int
 899 sysctl_dev_pcm_clone_flags(SYSCTL_HANDLER_ARGS)
 900 {
 901         struct snddev_info *d;
 902         uint32_t flags;
 903         int err;
 904
 905         d = oidp->oid_arg1;
 906         if (!PCM_REGISTERED(d) || d->clones == NULL)
 907                 return (ENODEV);
 908
 909         PCM_ACQUIRE_QUICK(d);
 910
 911         flags = snd_clone_getflags(d->clones);
 912         err = sysctl_handle_int(oidp, &flags, 0, req);
 913
 914         if (err == 0 && req->newptr != NULL) {
 915                 if (flags & ~SND_CLONE_MASK)
 916                         err = EINVAL;
 917                 else
 918                         (void)snd_clone_setflags(d->clones, flags);
 919         }
 920
 921         PCM_RELEASE_QUICK(d);
 922
 923         return (err);
 924 }
 925
 926 static int
 927 sysctl_dev_pcm_clone_deadline(SYSCTL_HANDLER_ARGS)
 928 {
 929         struct snddev_info *d;
 930         int err, deadline;
 931
 932         d = oidp->oid_arg1;
 933         if (!PCM_REGISTERED(d) || d->clones == NULL)
 934                 return (ENODEV);
 935
 936         PCM_ACQUIRE_QUICK(d);
 937
 938         deadline = snd_clone_getdeadline(d->clones);
 939         err = sysctl_handle_int(oidp, &deadline, 0, req);
 940
 941         if (err == 0 && req->newptr != NULL) {
 942                 if (deadline < 0)
 943                         err = EINVAL;
 944                 else
 945                         (void)snd_clone_setdeadline(d->clones, deadline);
 946         }
 947
 948         PCM_RELEASE_QUICK(d);
 949
 950         return (err);
 951 }
 952
 953 static int
 954 sysctl_dev_pcm_clone_gc(SYSCTL_HANDLER_ARGS)
 955 {
 956         struct snddev_info *d;
 957         int err, val;
 958
 959         d = oidp->oid_arg1;
 960         if (!PCM_REGISTERED(d) || d->clones == NULL)
 961                 return (ENODEV);
 962
 963         val = 0;
 964         err = sysctl_handle_int(oidp, &val, 0, req);
 965
 966         if (err == 0 && req->newptr != NULL && val != 0) {
 967                 PCM_ACQUIRE_QUICK(d);
 968                 val = snd_clone_gc(d->clones);
 969                 PCM_RELEASE_QUICK(d);
 970                 if (bootverbose != 0 || snd_verbose > 3)
 971                         device_printf(d->dev, "clone gc: pruned=%d\n", val);
 972         }
 973
 974         return (err);
 975 }
 976
 977 static int
 978 sysctl_hw_snd_clone_gc(SYSCTL_HANDLER_ARGS)
 979 {
 980         struct snddev_info *d;
 981         int i, err, val;
 982
 983         val = 0;
 984         err = sysctl_handle_int(oidp, &val, 0, req);
 985
 986         if (err == 0 && req->newptr != NULL && val != 0) {
 987                 for (i = 0; pcm_devclass != NULL &&
 988                     i < devclass_get_maxunit(pcm_devclass); i++) {
 989                         d = devclass_get_softc(pcm_devclass, i);
 990                         if (!PCM_REGISTERED(d) || d->clones == NULL)
 991                                 continue;
 992                         PCM_ACQUIRE_QUICK(d);
 993                         val = snd_clone_gc(d->clones);
 994                         PCM_RELEASE_QUICK(d);
 995                         if (bootverbose != 0 || snd_verbose > 3)
 996                                 device_printf(d->dev, "clone gc: pruned=%d\n",
 997                                     val);
 998                 }
 999         }
1000
1001         return (err);
1002 }
1003 SYSCTL_PROC(_hw_snd, OID_AUTO, clone_gc, CTLTYPE_INT | CTLFLAG_RW,
1004     0, sizeof(int), sysctl_hw_snd_clone_gc, "I",
1005     "global clone garbage collector");
1006 #endif
1007
1008 int
1009 pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
1010 {
1011         struct snddev_info *d;
1012         int i;
1013
1014         if (pcm_veto_load) {
1015                 device_printf(dev, "disabled due to an error while initialising: %d\n", pcm_veto_load);
1016
1017                 return EINVAL;
1018         }
1019
1020         if (device_get_unit(dev) > PCMMAXUNIT) {
1021                 device_printf(dev, "PCMMAXUNIT reached : unit=%d > %d\n",
1022                     device_get_unit(dev), PCMMAXUNIT);
1023                 device_printf(dev,
1024                     "Use 'hw.snd.maxunit' tunable to raise the limit.\n");
1025                 return ENODEV;
1026         }
1027
1028         d = device_get_softc(dev);
1029         d->dev = dev;
1030         d->lock = snd_mtxcreate(device_get_nameunit(dev), "sound cdev");
1031         cv_init(&d->cv, device_get_nameunit(dev));
1032         PCM_ACQUIRE_QUICK(d);
1033         dsp_cdevinfo_init(d);
1034 #if 0
1035         /*
1036          * d->flags should be cleared by the allocator of the softc.
1037          * We cannot clear this field here because several devices set
1038          * this flag before calling pcm_register().
1039          */
1040         d->flags = 0;
1041 #endif
1042         i = 0;
1043         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
1044             "vpc", &i) != 0 || i != 0)
1045                 d->flags |= SD_F_VPC;
1046
1047         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
1048             "bitperfect", &i) == 0 && i != 0)
1049                 d->flags |= SD_F_BITPERFECT;
1050
1051         d->devinfo = devinfo;
1052         d->devcount = 0;
1053         d->reccount = 0;
1054         d->playcount = 0;
1055         d->pvchancount = 0;
1056         d->rvchancount = 0;
1057         d->pvchanrate = 0;
1058         d->pvchanformat = 0;
1059         d->rvchanrate = 0;
1060         d->rvchanformat = 0;
1061         d->inprog = 0;
1062
1063         /*
1064          * Create clone manager, disabled by default. Cloning will be
1065          * enabled during final stage of driver initialization through
1066          * pcm_setstatus().
1067          */
1068         d->clones = snd_clone_create(SND_U_MASK | SND_D_MASK, PCMMAXCLONE,
1069             SND_CLONE_DEADLINE_DEFAULT, SND_CLONE_WAITOK |
1070             SND_CLONE_GC_ENABLE | SND_CLONE_GC_UNREF |
1071             SND_CLONE_GC_LASTREF | SND_CLONE_GC_EXPIRED);
1072
1073         CHN_INIT(d, channels.pcm);
1074         CHN_INIT(d, channels.pcm.busy);
1075         CHN_INIT(d, channels.pcm.opened);
1076
1077         /* XXX This is incorrect, but lets play along for now. */
1078         if ((numplay == 0 || numrec == 0) && numplay != numrec)
1079                 d->flags |= SD_F_SIMPLEX;
1080
1081         sysctl_ctx_init(&d->play_sysctl_ctx);
1082         d->play_sysctl_tree = SYSCTL_ADD_NODE(&d->play_sysctl_ctx,
1083             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "play",
1084             CTLFLAG_RD, 0, "playback channels node");
1085         sysctl_ctx_init(&d->rec_sysctl_ctx);
1086         d->rec_sysctl_tree = SYSCTL_ADD_NODE(&d->rec_sysctl_ctx,
1087             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "rec",
1088             CTLFLAG_RD, 0, "record channels node");
1089         /* XXX: an user should be able to set this with a control tool, the
1090            sysadmin then needs min+max sysctls for this */
1091         SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
1092             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
1093             OID_AUTO, "buffersize", CTLFLAG_RD, &d->bufsz, 0, "allocated buffer size");
1094         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1095             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1096             "bitperfect", CTLTYPE_INT | CTLFLAG_RW, d, sizeof(d),
1097             sysctl_dev_pcm_bitperfect, "I",
1098             "bit-perfect playback/recording (0=disable, 1=enable)");
1099 #ifdef SND_DEBUG
1100         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1101             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1102             "clone_flags", CTLTYPE_UINT | CTLFLAG_RW, d, sizeof(d),
1103             sysctl_dev_pcm_clone_flags, "IU",
1104             "clone flags");
1105         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1106             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1107             "clone_deadline", CTLTYPE_INT | CTLFLAG_RW, d, sizeof(d),
1108             sysctl_dev_pcm_clone_deadline, "I",
1109             "clone expiration deadline (ms)");
1110         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1111             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1112             "clone_gc", CTLTYPE_INT | CTLFLAG_RW, d, sizeof(d),
1113             sysctl_dev_pcm_clone_gc, "I",
1114             "clone garbage collector");
1115 #endif
1116
1117         if (numplay > 0 || numrec > 0) {
1118                 d->flags |= SD_F_AUTOVCHAN;
1119                 vchan_initsys(dev);
1120         }
1121
1122         if (d->flags & SD_F_EQ)
1123                 feeder_eq_initsys(dev);
1124
1125         /* XXX use make_autoclone_dev? */
1126         /* XXX PCMMAXCHAN can be created for regular channels */
1127         d->dsp_clonedev = make_dev(&dsp_ops,
1128                             PCMMINOR(device_get_unit(dev)),
1129                             UID_ROOT, GID_WHEEL, 0666, "dsp%d",
1130                             device_get_unit(dev));
1131         devfs_clone_handler_add(devtoname(d->dsp_clonedev), dsp_clone);
1132
1133         sndstat_register(dev, d->status, sndstat_prepare_pcm);
1134
1135         return 0;
1136 }
1137
1138 int
1139 pcm_unregister(device_t dev)
1140 {
1141         struct snddev_info *d;
1142         struct pcm_channel *ch;
1143         struct thread *td;
1144
1145         td = curthread;
1146         d = device_get_softc(dev);
1147
1148         if (!PCM_ALIVE(d)) {
1149                 device_printf(dev, "unregister: device not configured\n");
1150                 return (0);
1151         }
1152
1153         if (sndstat_acquire(td) != 0) {
1154                 device_printf(dev, "unregister: sndstat busy\n");
1155                 return (EBUSY);
1156         }
1157
1158         PCM_LOCK(d);
1159         PCM_WAIT(d);
1160
1161         if (d->inprog != 0) {
1162                 device_printf(dev, "unregister: operation in progress\n");
1163                 PCM_UNLOCK(d);
1164                 sndstat_release(td);
1165                 return (EBUSY);
1166         }
1167
1168         PCM_ACQUIRE(d);
1169         PCM_UNLOCK(d);
1170
1171         CHN_FOREACH(ch, d, channels.pcm) {
1172                 CHN_LOCK(ch);
1173                 if (ch->refcount > 0) {
1174                         device_printf(dev,
1175                             "unregister: channel %s busy (pid %d)\n",
1176                             ch->name, ch->pid);
1177                         CHN_UNLOCK(ch);
1178                         PCM_RELEASE_QUICK(d);
1179                         sndstat_release(td);
1180                         return (EBUSY);
1181                 }
1182                 CHN_UNLOCK(ch);
1183         }
1184
1185         if (d->clones != NULL) {
1186                 if (snd_clone_busy(d->clones) != 0) {
1187                         device_printf(dev, "unregister: clone busy\n");
1188                         PCM_RELEASE_QUICK(d);
1189                         sndstat_release(td);
1190                         return (EBUSY);
1191                 } else {
1192                         PCM_LOCK(d);
1193                         (void)snd_clone_disable(d->clones);
1194                         PCM_UNLOCK(d);
1195                 }
1196         }
1197
1198         if (mixer_uninit(dev) == EBUSY) {
1199                 device_printf(dev, "unregister: mixer busy\n");
1200                 PCM_LOCK(d);
1201                 if (d->clones != NULL)
1202                         (void)snd_clone_enable(d->clones);
1203                 PCM_RELEASE(d);
1204                 PCM_UNLOCK(d);
1205                 sndstat_release(td);
1206                 return (EBUSY);
1207         }
1208
1209         PCM_LOCK(d);
1210         d->flags |= SD_F_DYING;
1211         d->flags &= ~SD_F_REGISTERED;
1212         PCM_UNLOCK(d);
1213
1214         /*
1215          * No lock being held, so this thing can be flushed without
1216          * stucking into devdrn oblivion.
1217          */
1218         if (d->clones != NULL) {
1219                 snd_clone_destroy(d->clones);
1220                 d->clones = NULL;
1221         }
1222
1223         if (d->play_sysctl_tree != NULL) {
1224                 sysctl_ctx_free(&d->play_sysctl_ctx);
1225                 d->play_sysctl_tree = NULL;
1226         }
1227         if (d->rec_sysctl_tree != NULL) {
1228                 sysctl_ctx_free(&d->rec_sysctl_ctx);
1229                 d->rec_sysctl_tree = NULL;
1230         }
1231
1232         while (!CHN_EMPTY(d, channels.pcm))
1233                 pcm_killchan(dev);
1234
1235         dsp_cdevinfo_flush(d);
1236
1237         PCM_LOCK(d);
1238         PCM_RELEASE(d);
1239         cv_destroy(&d->cv);
1240         PCM_UNLOCK(d);
1241         snd_mtxfree(d->lock);
1242         sndstat_unregister(dev);
1243         sndstat_release(td);
1244
1245         if (snd_unit == device_get_unit(dev)) {
1246                 snd_unit = pcm_best_unit(-1);
1247                 if (snd_unit_auto == 0)
1248                         snd_unit_auto = 1;
1249         }
1250
1251         return (0);
1252 }
1253
1254 /************************************************************************/
1255
1256 /**
1257  * @brief       Handle OSSv4 SNDCTL_SYSINFO ioctl.
1258  *
1259  * @param si    Pointer to oss_sysinfo struct where information about the
1260  *              sound subsystem will be written/copied.
1261  *
1262  * This routine returns information about the sound system, such as the
1263  * current OSS version, number of audio, MIDI, and mixer drivers, etc.
1264  * Also includes a bitmask showing which of the above types of devices
1265  * are open (busy).
1266  *
1267  * @note
1268  * Calling threads must not hold any snddev_info or pcm_channel locks.
1269  *
1270  * @author      Ryan Beasley <ryanb@FreeBSD.org>
1271  */
1272 void
1273 sound_oss_sysinfo(oss_sysinfo *si)
1274 {
1275         static char si_product[] = "FreeBSD native OSS ABI";
1276         static char si_version[] = __XSTRING(__FreeBSD_version);
1277         static char si_license[] = "BSD";
1278         static int intnbits = sizeof(int) * 8;  /* Better suited as macro?
1279                                                    Must pester a C guru. */
1280
1281         struct snddev_info *d;
1282         struct pcm_channel *c;
1283         int i, j, ncards;
1284
1285         ncards = 0;
1286
1287         strlcpy(si->product, si_product, sizeof(si->product));
1288         strlcpy(si->version, si_version, sizeof(si->version));
1289         si->versionnum = SOUND_VERSION;
1290         strlcpy(si->license, si_license, sizeof(si->license));
1291
1292         /*
1293          * Iterate over PCM devices and their channels, gathering up data
1294          * for the numaudios, ncards, and openedaudio fields.
1295          */
1296         si->numaudios = 0;
1297         bzero((void *)&si->openedaudio, sizeof(si->openedaudio));
1298
1299         j = 0;
1300
1301         for (i = 0; pcm_devclass != NULL &&
1302             i < devclass_get_maxunit(pcm_devclass); i++) {
1303                 d = devclass_get_softc(pcm_devclass, i);
1304                 if (!PCM_REGISTERED(d))
1305                         continue;
1306
1307                 /* XXX Need Giant magic entry ??? */
1308
1309                 /* See note in function's docblock */
1310                 PCM_UNLOCKASSERT(d);
1311                 PCM_LOCK(d);
1312
1313                 si->numaudios += d->devcount;
1314                 ++ncards;
1315
1316                 CHN_FOREACH(c, d, channels.pcm) {
1317                         CHN_UNLOCKASSERT(c);
1318                         CHN_LOCK(c);
1319                         if (c->flags & CHN_F_BUSY)
1320                                 si->openedaudio[j / intnbits] |=
1321                                     (1 << (j % intnbits));
1322                         CHN_UNLOCK(c);
1323                         j++;
1324                 }
1325
1326                 PCM_UNLOCK(d);
1327         }
1328         si->numaudioengines = si->numaudios;
1329
1330         si->numsynths = 0;      /* OSSv4 docs:  this field is obsolete */
1331         /**
1332          * @todo        Collect num{midis,timers}.
1333          *
1334          * Need access to sound/midi/midi.c::midistat_lock in order
1335          * to safely touch midi_devices and get a head count of, well,
1336          * MIDI devices.  midistat_lock is a global static (i.e., local to
1337          * midi.c), but midi_devices is a regular global; should the mutex
1338          * be publicized, or is there another way to get this information?
1339          *
1340          * NB:  MIDI/sequencer stuff is currently on hold.
1341          */
1342         si->nummidis = 0;
1343         si->numtimers = 0;
1344         si->nummixers = mixer_count;
1345         si->numcards = ncards;
1346                 /* OSSv4 docs:  Intended only for test apps; API doesn't
1347                    really have much of a concept of cards.  Shouldn't be
1348                    used by applications. */
1349
1350         /**
1351          * @todo        Fill in "busy devices" fields.
1352          *
1353          *  si->openedmidi = " MIDI devices
1354          */
1355         bzero((void *)&si->openedmidi, sizeof(si->openedmidi));
1356
1357         /*
1358          * Si->filler is a reserved array, but according to docs each
1359          * element should be set to -1.
1360          */
1361         for (i = 0; i < sizeof(si->filler)/sizeof(si->filler[0]); i++)
1362                 si->filler[i] = -1;
1363 }
1364
1365 int
1366 sound_oss_card_info(oss_card_info *si)
1367 {
1368         struct snddev_info *d;
1369         int i, ncards;
1370
1371         ncards = 0;
1372
1373         for (i = 0; pcm_devclass != NULL &&
1374             i < devclass_get_maxunit(pcm_devclass); i++) {
1375                 d = devclass_get_softc(pcm_devclass, i);
1376                 if (!PCM_REGISTERED(d))
1377                         continue;
1378
1379                 if (ncards++ != si->card)
1380                         continue;
1381
1382                 PCM_UNLOCKASSERT(d);
1383                 PCM_LOCK(d);
1384
1385                 strlcpy(si->shortname, device_get_nameunit(d->dev),
1386                     sizeof(si->shortname));
1387                 strlcpy(si->longname, device_get_desc(d->dev),
1388                     sizeof(si->longname));
1389                 strlcpy(si->hw_info, d->status, sizeof(si->hw_info));
1390                 si->intr_count = si->ack_count = 0;
1391
1392                 PCM_UNLOCK(d);
1393
1394                 return (0);
1395         }
1396         return (ENXIO);
1397 }
1398
1399 /************************************************************************/
1400
1401 static int
1402 sound_modevent(module_t mod, int type, void *data)
1403 {
1404         int ret;
1405 #if 0
1406         return (midi_modevent(mod, type, data));
1407 #else
1408         ret = 0;
1409
1410         switch(type) {
1411                 case MOD_LOAD:
1412                         pcmsg_unrhdr = new_unrhdr(1, INT_MAX, NULL);
1413                         break;
1414                 case MOD_UNLOAD:
1415                         ret = sndstat_acquire(curthread);
1416                         if (ret != 0)
1417                                 break;
1418                         if (pcmsg_unrhdr != NULL) {
1419                                 delete_unrhdr(pcmsg_unrhdr);
1420                                 pcmsg_unrhdr = NULL;
1421                         }
1422                         break;
1423                 case MOD_SHUTDOWN:
1424                         break;
1425                 default:
1426                         ret = ENOTSUP;
1427         }
1428
1429         return ret;
1430 #endif
1431 }
1432
1433 DEV_MODULE(sound, sound_modevent, NULL);
1434 MODULE_VERSION(sound, SOUND_MODVER);