sys/dev/sound/pcm/mixer.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  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #ifdef HAVE_KERNEL_OPTION_HEADERS
  30 #include "opt_snd.h"
  31 #endif
  32
  33 #include <dev/sound/pcm/sound.h>
  34
  35 #include "feeder_if.h"
  36 #include "mixer_if.h"
  37
  38 SND_DECLARE_FILE("$FreeBSD$");
  39
  40 static MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
  41
  42 static int mixer_bypass = 1;
  43 TUNABLE_INT("hw.snd.vpc_mixer_bypass", &mixer_bypass);
  44 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_mixer_bypass, CTLFLAG_RW,
  45     &mixer_bypass, 0,
  46     "control channel pcm/rec volume, bypassing real mixer device");
  47
  48 #define MIXER_NAMELEN   16
  49 struct snd_mixer {
  50         KOBJ_FIELDS;
  51         void *devinfo;
  52         int busy;
  53         int hwvol_muted;
  54         int hwvol_mixer;
  55         int hwvol_step;
  56         int type;
  57         device_t dev;
  58         u_int32_t hwvol_mute_level;
  59         u_int32_t devs;
  60         u_int32_t recdevs;
  61         u_int32_t recsrc;
  62         u_int16_t level[32];
  63         u_int8_t parent[32];
  64         u_int32_t child[32];
  65         u_int8_t realdev[32];
  66         char name[MIXER_NAMELEN];
  67         struct mtx *lock;
  68         oss_mixer_enuminfo enuminfo;
  69         /**
  70          * Counter is incremented when applications change any of this
  71          * mixer's controls.  A change in value indicates that persistent
  72          * mixer applications should update their displays.
  73          */
  74         int modify_counter;
  75 };
  76
  77 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
  78         [SOUND_MIXER_VOLUME]    = 75,
  79         [SOUND_MIXER_BASS]      = 50,
  80         [SOUND_MIXER_TREBLE]    = 50,
  81         [SOUND_MIXER_SYNTH]     = 75,
  82         [SOUND_MIXER_PCM]       = 75,
  83         [SOUND_MIXER_SPEAKER]   = 75,
  84         [SOUND_MIXER_LINE]      = 75,
  85         [SOUND_MIXER_MIC]       = 25,
  86         [SOUND_MIXER_CD]        = 75,
  87         [SOUND_MIXER_IGAIN]     = 0,
  88         [SOUND_MIXER_LINE1]     = 75,
  89         [SOUND_MIXER_VIDEO]     = 75,
  90         [SOUND_MIXER_RECLEV]    = 75,
  91         [SOUND_MIXER_OGAIN]     = 50,
  92         [SOUND_MIXER_MONITOR]   = 75,
  93 };
  94
  95 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
  96
  97 static d_open_t mixer_open;
  98 static d_close_t mixer_close;
  99 static d_ioctl_t mixer_ioctl;
 100
 101 static struct cdevsw mixer_cdevsw = {
 102         .d_version =    D_VERSION,
 103         .d_open =       mixer_open,
 104         .d_close =      mixer_close,
 105         .d_ioctl =      mixer_ioctl,
 106         .d_name =       "mixer",
 107 };
 108
 109 /**
 110  * Keeps a count of mixer devices; used only by OSSv4 SNDCTL_SYSINFO ioctl.
 111  */
 112 int mixer_count = 0;
 113
 114 static eventhandler_tag mixer_ehtag = NULL;
 115
 116 static struct cdev *
 117 mixer_get_devt(device_t dev)
 118 {
 119         struct snddev_info *snddev;
 120
 121         snddev = device_get_softc(dev);
 122
 123         return snddev->mixer_dev;
 124 }
 125
 126 static int
 127 mixer_lookup(char *devname)
 128 {
 129         int i;
 130
 131         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 132                 if (strncmp(devname, snd_mixernames[i],
 133                     strlen(snd_mixernames[i])) == 0)
 134                         return i;
 135         return -1;
 136 }
 137
 138 #define MIXER_SET_UNLOCK(x, y)          do {                            \
 139         if ((y) != 0)                                                   \
 140                 snd_mtxunlock((x)->lock);                               \
 141 } while (0)
 142
 143 #define MIXER_SET_LOCK(x, y)            do {                            \
 144         if ((y) != 0)                                                   \
 145                 snd_mtxlock((x)->lock);                                 \
 146 } while (0)
 147
 148 static int
 149 mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d,
 150     u_int left, u_int right)
 151 {
 152         struct pcm_channel *c;
 153         int dropmtx, acquiremtx;
 154
 155         if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
 156                 return (EINVAL);
 157
 158         if (mtx_owned(m->lock))
 159                 dropmtx = 1;
 160         else
 161                 dropmtx = 0;
 162
 163         if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
 164                 acquiremtx = 0;
 165         else
 166                 acquiremtx = 1;
 167
 168         /*
 169          * Be careful here. If we're coming from cdev ioctl, it is OK to
 170          * not doing locking AT ALL (except on individual channel) since
 171          * we've been heavily guarded by pcm cv, or if we're still
 172          * under Giant influence. Since we also have mix_* calls, we cannot
 173          * assume such protection and just do the lock as usuall.
 174          */
 175         MIXER_SET_UNLOCK(m, dropmtx);
 176         MIXER_SET_LOCK(d, acquiremtx);
 177
 178         CHN_FOREACH(c, d, channels.pcm.busy) {
 179                 CHN_LOCK(c);
 180                 if (c->direction == PCMDIR_PLAY &&
 181                     (c->feederflags & (1 << FEEDER_VOLUME)))
 182                         chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right,
 183                             (left + right) >> 1);
 184                 CHN_UNLOCK(c);
 185         }
 186
 187         MIXER_SET_UNLOCK(d, acquiremtx);
 188         MIXER_SET_LOCK(m, dropmtx);
 189
 190         return (0);
 191 }
 192
 193 static int
 194 mixer_set_eq(struct snd_mixer *m, struct snddev_info *d,
 195     u_int dev, u_int level)
 196 {
 197         struct pcm_channel *c;
 198         struct pcm_feeder *f;
 199         int tone, dropmtx, acquiremtx;
 200
 201         if (dev == SOUND_MIXER_TREBLE)
 202                 tone = FEEDEQ_TREBLE;
 203         else if (dev == SOUND_MIXER_BASS)
 204                 tone = FEEDEQ_BASS;
 205         else
 206                 return (EINVAL);
 207
 208         if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
 209                 return (EINVAL);
 210
 211         if (mtx_owned(m->lock))
 212                 dropmtx = 1;
 213         else
 214                 dropmtx = 0;
 215
 216         if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
 217                 acquiremtx = 0;
 218         else
 219                 acquiremtx = 1;
 220
 221         /*
 222          * Be careful here. If we're coming from cdev ioctl, it is OK to
 223          * not doing locking AT ALL (except on individual channel) since
 224          * we've been heavily guarded by pcm cv, or if we're still
 225          * under Giant influence. Since we also have mix_* calls, we cannot
 226          * assume such protection and just do the lock as usuall.
 227          */
 228         MIXER_SET_UNLOCK(m, dropmtx);
 229         MIXER_SET_LOCK(d, acquiremtx);
 230
 231         CHN_FOREACH(c, d, channels.pcm.busy) {
 232                 CHN_LOCK(c);
 233                 f = chn_findfeeder(c, FEEDER_EQ);
 234                 if (f != NULL)
 235                         (void)FEEDER_SET(f, tone, level);
 236                 CHN_UNLOCK(c);
 237         }
 238
 239         MIXER_SET_UNLOCK(d, acquiremtx);
 240         MIXER_SET_LOCK(m, dropmtx);
 241
 242         return (0);
 243 }
 244
 245 static int
 246 mixer_set(struct snd_mixer *m, u_int dev, u_int lev)
 247 {
 248         struct snddev_info *d;
 249         u_int l, r, tl, tr;
 250         u_int32_t parent = SOUND_MIXER_NONE, child = 0;
 251         u_int32_t realdev;
 252         int i, dropmtx;
 253
 254         if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
 255             (0 == (m->devs & (1 << dev))))
 256                 return -1;
 257
 258         l = min((lev & 0x00ff), 100);
 259         r = min(((lev & 0xff00) >> 8), 100);
 260         realdev = m->realdev[dev];
 261
 262         d = device_get_softc(m->dev);
 263         if (d == NULL)
 264                 return -1;
 265
 266         /* It is safe to drop this mutex due to Giant. */
 267         if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0)
 268                 dropmtx = 1;
 269         else
 270                 dropmtx = 0;
 271
 272         MIXER_SET_UNLOCK(m, dropmtx);
 273
 274         /* TODO: recursive handling */
 275         parent = m->parent[dev];
 276         if (parent >= SOUND_MIXER_NRDEVICES)
 277                 parent = SOUND_MIXER_NONE;
 278         if (parent == SOUND_MIXER_NONE)
 279                 child = m->child[dev];
 280
 281         if (parent != SOUND_MIXER_NONE) {
 282                 tl = (l * (m->level[parent] & 0x00ff)) / 100;
 283                 tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100;
 284                 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
 285                         (void)mixer_set_softpcmvol(m, d, tl, tr);
 286                 else if (realdev != SOUND_MIXER_NONE &&
 287                     MIXER_SET(m, realdev, tl, tr) < 0) {
 288                         MIXER_SET_LOCK(m, dropmtx);
 289                         return -1;
 290                 }
 291         } else if (child != 0) {
 292                 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 293                         if (!(child & (1 << i)) || m->parent[i] != dev)
 294                                 continue;
 295                         realdev = m->realdev[i];
 296                         tl = (l * (m->level[i] & 0x00ff)) / 100;
 297                         tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100;
 298                         if (i == SOUND_MIXER_PCM &&
 299                             (d->flags & SD_F_SOFTPCMVOL))
 300                                 (void)mixer_set_softpcmvol(m, d, tl, tr);
 301                         else if (realdev != SOUND_MIXER_NONE)
 302                                 MIXER_SET(m, realdev, tl, tr);
 303                 }
 304                 realdev = m->realdev[dev];
 305                 if (realdev != SOUND_MIXER_NONE &&
 306                     MIXER_SET(m, realdev, l, r) < 0) {
 307                                 MIXER_SET_LOCK(m, dropmtx);
 308                                 return -1;
 309                 }
 310         } else {
 311                 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
 312                         (void)mixer_set_softpcmvol(m, d, l, r);
 313                 else if ((dev == SOUND_MIXER_TREBLE ||
 314                     dev == SOUND_MIXER_BASS) && (d->flags & SD_F_EQ))
 315                         (void)mixer_set_eq(m, d, dev, (l + r) >> 1);
 316                 else if (realdev != SOUND_MIXER_NONE &&
 317                     MIXER_SET(m, realdev, l, r) < 0) {
 318                         MIXER_SET_LOCK(m, dropmtx);
 319                         return -1;
 320                 }
 321         }
 322
 323         MIXER_SET_LOCK(m, dropmtx);
 324
 325         m->level[dev] = l | (r << 8);
 326         m->modify_counter++;
 327
 328         return 0;
 329 }
 330
 331 static int
 332 mixer_get(struct snd_mixer *mixer, int dev)
 333 {
 334         if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
 335                 return mixer->level[dev];
 336         else
 337                 return -1;
 338 }
 339
 340 static int
 341 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
 342 {
 343         struct snddev_info *d;
 344         u_int32_t recsrc;
 345         int dropmtx;
 346
 347         d = device_get_softc(mixer->dev);
 348         if (d == NULL)
 349                 return -1;
 350         if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0)
 351                 dropmtx = 1;
 352         else
 353                 dropmtx = 0;
 354         src &= mixer->recdevs;
 355         if (src == 0)
 356                 src = mixer->recdevs & SOUND_MASK_MIC;
 357         if (src == 0)
 358                 src = mixer->recdevs & SOUND_MASK_MONITOR;
 359         if (src == 0)
 360                 src = mixer->recdevs & SOUND_MASK_LINE;
 361         if (src == 0 && mixer->recdevs != 0)
 362                 src = (1 << (ffs(mixer->recdevs) - 1));
 363         /* It is safe to drop this mutex due to Giant. */
 364         MIXER_SET_UNLOCK(mixer, dropmtx);
 365         recsrc = MIXER_SETRECSRC(mixer, src);
 366         MIXER_SET_LOCK(mixer, dropmtx);
 367
 368         mixer->recsrc = recsrc;
 369
 370         return 0;
 371 }
 372
 373 static int
 374 mixer_getrecsrc(struct snd_mixer *mixer)
 375 {
 376         return mixer->recsrc;
 377 }
 378
 379 /**
 380  * @brief Retrieve the route number of the current recording device
 381  *
 382  * OSSv4 assigns routing numbers to recording devices, unlike the previous
 383  * API which relied on a fixed table of device numbers and names.  This
 384  * function returns the routing number of the device currently selected
 385  * for recording.
 386  *
 387  * For now, this function is kind of a goofy compatibility stub atop the
 388  * existing sound system.  (For example, in theory, the old sound system
 389  * allows multiple recording devices to be specified via a bitmask.)
 390  *
 391  * @param m     mixer context container thing
 392  *
 393  * @retval 0            success
 394  * @retval EIDRM        no recording device found (generally not possible)
 395  * @todo Ask about error code
 396  */
 397 static int
 398 mixer_get_recroute(struct snd_mixer *m, int *route)
 399 {
 400         int i, cnt;
 401
 402         cnt = 0;
 403
 404         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 405                 /** @todo can user set a multi-device mask? (== or &?) */
 406                 if ((1 << i) == m->recsrc)
 407                         break;
 408                 if ((1 << i) & m->recdevs)
 409                         ++cnt;
 410         }
 411
 412         if (i == SOUND_MIXER_NRDEVICES)
 413                 return EIDRM;
 414
 415         *route = cnt;
 416         return 0;
 417 }
 418
 419 /**
 420  * @brief Select a device for recording
 421  *
 422  * This function sets a recording source based on a recording device's
 423  * routing number.  Said number is translated to an old school recdev
 424  * mask and passed over mixer_setrecsrc.
 425  *
 426  * @param m     mixer context container thing
 427  *
 428  * @retval 0            success(?)
 429  * @retval EINVAL       User specified an invalid device number
 430  * @retval otherwise    error from mixer_setrecsrc
 431  */
 432 static int
 433 mixer_set_recroute(struct snd_mixer *m, int route)
 434 {
 435         int i, cnt, ret;
 436
 437         ret = 0;
 438         cnt = 0;
 439
 440         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 441                 if ((1 << i) & m->recdevs) {
 442                         if (route == cnt)
 443                                 break;
 444                         ++cnt;
 445                 }
 446         }
 447
 448         if (i == SOUND_MIXER_NRDEVICES)
 449                 ret = EINVAL;
 450         else
 451                 ret = mixer_setrecsrc(m, (1 << i));
 452
 453         return ret;
 454 }
 455
 456 void
 457 mix_setdevs(struct snd_mixer *m, u_int32_t v)
 458 {
 459         struct snddev_info *d;
 460         int i;
 461
 462         if (m == NULL)
 463                 return;
 464
 465         d = device_get_softc(m->dev);
 466         if (d != NULL && (d->flags & SD_F_SOFTPCMVOL))
 467                 v |= SOUND_MASK_PCM;
 468         if (d != NULL && (d->flags & SD_F_EQ))
 469                 v |= SOUND_MASK_TREBLE | SOUND_MASK_BASS;
 470         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 471                 if (m->parent[i] < SOUND_MIXER_NRDEVICES)
 472                         v |= 1 << m->parent[i];
 473                 v |= m->child[i];
 474         }
 475         m->devs = v;
 476 }
 477
 478 /**
 479  * @brief Record mask of available recording devices
 480  *
 481  * Calling functions are responsible for defining the mask of available
 482  * recording devices.  This function records that value in a structure
 483  * used by the rest of the mixer code.
 484  *
 485  * This function also populates a structure used by the SNDCTL_DSP_*RECSRC*
 486  * family of ioctls that are part of OSSV4.  All recording device labels
 487  * are concatenated in ascending order corresponding to their routing
 488  * numbers.  (Ex:  a system might have 0 => 'vol', 1 => 'cd', 2 => 'line',
 489  * etc.)  For now, these labels are just the standard recording device
 490  * names (cd, line1, etc.), but will eventually be fully dynamic and user
 491  * controlled.
 492  *
 493  * @param m     mixer device context container thing
 494  * @param v     mask of recording devices
 495  */
 496 void
 497 mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
 498 {
 499         oss_mixer_enuminfo *ei;
 500         char *loc;
 501         int i, nvalues, nwrote, nleft, ncopied;
 502
 503         ei = &m->enuminfo;
 504
 505         nvalues = 0;
 506         nwrote = 0;
 507         nleft = sizeof(ei->strings);
 508         loc = ei->strings;
 509
 510         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 511                 if ((1 << i) & v) {
 512                         ei->strindex[nvalues] = nwrote;
 513                         ncopied = strlcpy(loc, snd_mixernames[i], nleft) + 1;
 514                             /* strlcpy retval doesn't include terminator */
 515
 516                         nwrote += ncopied;
 517                         nleft -= ncopied;
 518                         nvalues++;
 519
 520                         /*
 521                          * XXX I don't think this should ever be possible.
 522                          * Even with a move to dynamic device/channel names,
 523                          * each label is limited to ~16 characters, so that'd
 524                          * take a LOT to fill this buffer.
 525                          */
 526                         if ((nleft <= 0) || (nvalues >= OSS_ENUM_MAXVALUE)) {
 527                                 device_printf(m->dev,
 528                                     "mix_setrecdevs:  Not enough room to store device names--please file a bug report.\n");
 529                                 device_printf(m->dev,
 530                                     "mix_setrecdevs:  Please include details about your sound hardware, OS version, etc.\n");
 531                                 break;
 532                         }
 533
 534                         loc = &ei->strings[nwrote];
 535                 }
 536         }
 537
 538         /*
 539          * NB:  The SNDCTL_DSP_GET_RECSRC_NAMES ioctl ignores the dev
 540          *      and ctrl fields.
 541          */
 542         ei->nvalues = nvalues;
 543         m->recdevs = v;
 544 }
 545
 546 void
 547 mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs)
 548 {
 549         u_int32_t mask = 0;
 550         int i;
 551
 552         if (m == NULL || parent >= SOUND_MIXER_NRDEVICES)
 553                 return;
 554         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 555                 if (i == parent)
 556                         continue;
 557                 if (childs & (1 << i)) {
 558                         mask |= 1 << i;
 559                         if (m->parent[i] < SOUND_MIXER_NRDEVICES)
 560                                 m->child[m->parent[i]] &= ~(1 << i);
 561                         m->parent[i] = parent;
 562                         m->child[i] = 0;
 563                 }
 564         }
 565         mask &= ~(1 << parent);
 566         m->child[parent] = mask;
 567 }
 568
 569 void
 570 mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev)
 571 {
 572         if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
 573             !(realdev == SOUND_MIXER_NONE || realdev < SOUND_MIXER_NRDEVICES))
 574                 return;
 575         m->realdev[dev] = realdev;
 576 }
 577
 578 u_int32_t
 579 mix_getparent(struct snd_mixer *m, u_int32_t dev)
 580 {
 581         if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
 582                 return SOUND_MIXER_NONE;
 583         return m->parent[dev];
 584 }
 585
 586 u_int32_t
 587 mix_getchild(struct snd_mixer *m, u_int32_t dev)
 588 {
 589         if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
 590                 return 0;
 591         return m->child[dev];
 592 }
 593
 594 u_int32_t
 595 mix_getdevs(struct snd_mixer *m)
 596 {
 597         return m->devs;
 598 }
 599
 600 u_int32_t
 601 mix_getrecdevs(struct snd_mixer *m)
 602 {
 603         return m->recdevs;
 604 }
 605
 606 void *
 607 mix_getdevinfo(struct snd_mixer *m)
 608 {
 609         return m->devinfo;
 610 }
 611
 612 static struct snd_mixer *
 613 mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo,
 614     int type, const char *desc)
 615 {
 616         struct snd_mixer *m;
 617         int i;
 618
 619         KASSERT(dev != NULL && cls != NULL && devinfo != NULL,
 620             ("%s(): NULL data dev=%p cls=%p devinfo=%p",
 621             __func__, dev, cls, devinfo));
 622         KASSERT(type == MIXER_TYPE_PRIMARY || type == MIXER_TYPE_SECONDARY,
 623             ("invalid mixer type=%d", type));
 624
 625         m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
 626         snprintf(m->name, sizeof(m->name), "%s:mixer",
 627             device_get_nameunit(dev));
 628         if (desc != NULL) {
 629                 strlcat(m->name, ":", sizeof(m->name));
 630                 strlcat(m->name, desc, sizeof(m->name));
 631         }
 632         m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ?
 633             "primary pcm mixer" : "secondary pcm mixer");
 634         m->type = type;
 635         m->devinfo = devinfo;
 636         m->busy = 0;
 637         m->dev = dev;
 638         for (i = 0; i < (sizeof(m->parent) / sizeof(m->parent[0])); i++) {
 639                 m->parent[i] = SOUND_MIXER_NONE;
 640                 m->child[i] = 0;
 641                 m->realdev[i] = i;
 642         }
 643
 644         if (MIXER_INIT(m)) {
 645                 snd_mtxlock(m->lock);
 646                 snd_mtxfree(m->lock);
 647                 kobj_delete((kobj_t)m, M_MIXER);
 648                 return (NULL);
 649         }
 650
 651         return (m);
 652 }
 653
 654 int
 655 mixer_delete(struct snd_mixer *m)
 656 {
 657         KASSERT(m != NULL, ("NULL snd_mixer"));
 658         KASSERT(m->type == MIXER_TYPE_SECONDARY,
 659             ("%s(): illegal mixer type=%d", __func__, m->type));
 660
 661         /* mixer uninit can sleep --hps */
 662
 663         MIXER_UNINIT(m);
 664
 665         snd_mtxfree(m->lock);
 666         kobj_delete((kobj_t)m, M_MIXER);
 667
 668         --mixer_count;
 669
 670         return (0);
 671 }
 672
 673 struct snd_mixer *
 674 mixer_create(device_t dev, kobj_class_t cls, void *devinfo, const char *desc)
 675 {
 676         struct snd_mixer *m;
 677
 678         m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_SECONDARY, desc);
 679
 680         if (m != NULL)
 681                 ++mixer_count;
 682
 683         return (m);
 684 }
 685
 686 int
 687 mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
 688 {
 689         struct snddev_info *snddev;
 690         struct snd_mixer *m;
 691         u_int16_t v;
 692         struct cdev *pdev;
 693         int i, unit, devunit, val;
 694
 695         snddev = device_get_softc(dev);
 696         if (snddev == NULL)
 697                 return (-1);
 698
 699         if (resource_int_value(device_get_name(dev),
 700             device_get_unit(dev), "eq", &val) == 0 && val != 0) {
 701                 snddev->flags |= SD_F_EQ;
 702                 if ((val & SD_F_EQ_MASK) == val)
 703                         snddev->flags |= val;
 704                 else
 705                         snddev->flags |= SD_F_EQ_DEFAULT;
 706                 snddev->eqpreamp = 0;
 707         }
 708
 709         m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_PRIMARY, NULL);
 710         if (m == NULL)
 711                 return (-1);
 712
 713         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 714                 v = snd_mixerdefaults[i];
 715
 716                 if (resource_int_value(device_get_name(dev),
 717                     device_get_unit(dev), snd_mixernames[i], &val) == 0) {
 718                         if (val >= 0 && val <= 100) {
 719                                 v = (u_int16_t) val;
 720                         }
 721                 }
 722
 723                 mixer_set(m, i, v | (v << 8));
 724         }
 725
 726         mixer_setrecsrc(m, 0); /* Set default input. */
 727
 728         unit = device_get_unit(dev);
 729         devunit = snd_mkunit(unit, SND_DEV_CTL, 0);
 730         pdev = make_dev(&mixer_cdevsw, PCMMINOR(devunit),
 731                  UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit);
 732         pdev->si_drv1 = m;
 733         snddev->mixer_dev = pdev;
 734
 735         ++mixer_count;
 736
 737         if (bootverbose) {
 738                 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 739                         if (!(m->devs & (1 << i)))
 740                                 continue;
 741                         if (m->realdev[i] != i) {
 742                                 device_printf(dev, "Mixer \"%s\" -> \"%s\":",
 743                                     snd_mixernames[i],
 744                                     (m->realdev[i] < SOUND_MIXER_NRDEVICES) ?
 745                                     snd_mixernames[m->realdev[i]] : "none");
 746                         } else {
 747                                 device_printf(dev, "Mixer \"%s\":",
 748                                     snd_mixernames[i]);
 749                         }
 750                         if (m->parent[i] < SOUND_MIXER_NRDEVICES)
 751                                 printf(" parent=\"%s\"",
 752                                     snd_mixernames[m->parent[i]]);
 753                         if (m->child[i] != 0)
 754                                 printf(" child=0x%08x", m->child[i]);
 755                         printf("\n");
 756                 }
 757                 if (snddev->flags & SD_F_SOFTPCMVOL)
 758                         device_printf(dev, "Soft PCM mixer ENABLED\n");
 759                 if (snddev->flags & SD_F_EQ)
 760                         device_printf(dev, "EQ Treble/Bass ENABLED\n");
 761         }
 762
 763         return (0);
 764 }
 765
 766 int
 767 mixer_uninit(device_t dev)
 768 {
 769         int i;
 770         struct snddev_info *d;
 771         struct snd_mixer *m;
 772         struct cdev *pdev;
 773
 774         d = device_get_softc(dev);
 775         pdev = mixer_get_devt(dev);
 776         if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL)
 777                 return EBADF;
 778
 779         m = pdev->si_drv1;
 780         KASSERT(m != NULL, ("NULL snd_mixer"));
 781         KASSERT(m->type == MIXER_TYPE_PRIMARY,
 782             ("%s(): illegal mixer type=%d", __func__, m->type));
 783
 784         snd_mtxlock(m->lock);
 785
 786         if (m->busy) {
 787                 snd_mtxunlock(m->lock);
 788                 return EBUSY;
 789         }
 790
 791         /* destroy dev can sleep --hps */
 792
 793         snd_mtxunlock(m->lock);
 794
 795         pdev->si_drv1 = NULL;
 796         destroy_dev(pdev);
 797
 798         snd_mtxlock(m->lock);
 799
 800         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 801                 mixer_set(m, i, 0);
 802
 803         mixer_setrecsrc(m, SOUND_MASK_MIC);
 804
 805         snd_mtxunlock(m->lock);
 806
 807         /* mixer uninit can sleep --hps */
 808
 809         MIXER_UNINIT(m);
 810
 811         snd_mtxfree(m->lock);
 812         kobj_delete((kobj_t)m, M_MIXER);
 813
 814         d->mixer_dev = NULL;
 815
 816         --mixer_count;
 817
 818         return 0;
 819 }
 820
 821 int
 822 mixer_reinit(device_t dev)
 823 {
 824         struct snd_mixer *m;
 825         struct cdev *pdev;
 826         int i;
 827
 828         pdev = mixer_get_devt(dev);
 829         m = pdev->si_drv1;
 830         snd_mtxlock(m->lock);
 831
 832         i = MIXER_REINIT(m);
 833         if (i) {
 834                 snd_mtxunlock(m->lock);
 835                 return i;
 836         }
 837
 838         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 839                 mixer_set(m, i, m->level[i]);
 840
 841         mixer_setrecsrc(m, m->recsrc);
 842         snd_mtxunlock(m->lock);
 843
 844         return 0;
 845 }
 846
 847 static int
 848 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
 849 {
 850         char devname[32];
 851         int error, dev;
 852         struct snd_mixer *m;
 853
 854         m = oidp->oid_arg1;
 855         snd_mtxlock(m->lock);
 856         strlcpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
 857         snd_mtxunlock(m->lock);
 858         error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
 859         snd_mtxlock(m->lock);
 860         if (error == 0 && req->newptr != NULL) {
 861                 dev = mixer_lookup(devname);
 862                 if (dev == -1) {
 863                         snd_mtxunlock(m->lock);
 864                         return EINVAL;
 865                 }
 866                 else if (dev != m->hwvol_mixer) {
 867                         m->hwvol_mixer = dev;
 868                         m->hwvol_muted = 0;
 869                 }
 870         }
 871         snd_mtxunlock(m->lock);
 872         return error;
 873 }
 874
 875 int
 876 mixer_hwvol_init(device_t dev)
 877 {
 878         struct snd_mixer *m;
 879         struct cdev *pdev;
 880
 881         pdev = mixer_get_devt(dev);
 882         m = pdev->si_drv1;
 883
 884         m->hwvol_mixer = SOUND_MIXER_VOLUME;
 885         m->hwvol_step = 5;
 886         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 887             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 888             OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
 889         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 890             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 891             OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
 892             sysctl_hw_snd_hwvol_mixer, "A", "");
 893         return 0;
 894 }
 895
 896 void
 897 mixer_hwvol_mute_locked(struct snd_mixer *m)
 898 {
 899         if (m->hwvol_muted) {
 900                 m->hwvol_muted = 0;
 901                 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level);
 902         } else {
 903                 m->hwvol_muted++;
 904                 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer);
 905                 mixer_set(m, m->hwvol_mixer, 0);
 906         }
 907 }
 908
 909 void
 910 mixer_hwvol_mute(device_t dev)
 911 {
 912         struct snd_mixer *m;
 913         struct cdev *pdev;
 914
 915         pdev = mixer_get_devt(dev);
 916         m = pdev->si_drv1;
 917         snd_mtxlock(m->lock);
 918         mixer_hwvol_mute_locked(m);
 919         snd_mtxunlock(m->lock);
 920 }
 921
 922 void
 923 mixer_hwvol_step_locked(struct snd_mixer *m, int left_step, int right_step)
 924 {
 925         int level, left, right;
 926
 927         if (m->hwvol_muted) {
 928                 m->hwvol_muted = 0;
 929                 level = m->hwvol_mute_level;
 930         } else
 931                 level = mixer_get(m, m->hwvol_mixer);
 932         if (level != -1) {
 933                 left = level & 0xff;
 934                 right = (level >> 8) & 0xff;
 935                 left += left_step * m->hwvol_step;
 936                 if (left < 0)
 937                         left = 0;
 938                 else if (left > 100)
 939                         left = 100;
 940                 right += right_step * m->hwvol_step;
 941                 if (right < 0)
 942                         right = 0;
 943                 else if (right > 100)
 944                         right = 100;
 945                 mixer_set(m, m->hwvol_mixer, left | right << 8);
 946         }
 947 }
 948
 949 void
 950 mixer_hwvol_step(device_t dev, int left_step, int right_step)
 951 {
 952         struct snd_mixer *m;
 953         struct cdev *pdev;
 954
 955         pdev = mixer_get_devt(dev);
 956         m = pdev->si_drv1;
 957         snd_mtxlock(m->lock);
 958         mixer_hwvol_step_locked(m, left_step, right_step);
 959         snd_mtxunlock(m->lock);
 960 }
 961
 962 int
 963 mixer_busy(struct snd_mixer *m)
 964 {
 965         KASSERT(m != NULL, ("NULL snd_mixer"));
 966
 967         return (m->busy);
 968 }
 969
 970 int
 971 mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right)
 972 {
 973         int ret;
 974
 975         KASSERT(m != NULL, ("NULL snd_mixer"));
 976
 977         snd_mtxlock(m->lock);
 978         ret = mixer_set(m, dev, left | (right << 8));
 979         snd_mtxunlock(m->lock);
 980
 981         return ((ret != 0) ? ENXIO : 0);
 982 }
 983
 984 int
 985 mix_get(struct snd_mixer *m, u_int dev)
 986 {
 987         int ret;
 988
 989         KASSERT(m != NULL, ("NULL snd_mixer"));
 990
 991         snd_mtxlock(m->lock);
 992         ret = mixer_get(m, dev);
 993         snd_mtxunlock(m->lock);
 994
 995         return (ret);
 996 }
 997
 998 int
 999 mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
1000 {
1001         int ret;
1002
1003         KASSERT(m != NULL, ("NULL snd_mixer"));
1004
1005         snd_mtxlock(m->lock);
1006         ret = mixer_setrecsrc(m, src);
1007         snd_mtxunlock(m->lock);
1008
1009         return ((ret != 0) ? ENXIO : 0);
1010 }
1011
1012 u_int32_t
1013 mix_getrecsrc(struct snd_mixer *m)
1014 {
1015         u_int32_t ret;
1016
1017         KASSERT(m != NULL, ("NULL snd_mixer"));
1018
1019         snd_mtxlock(m->lock);
1020         ret = mixer_getrecsrc(m);
1021         snd_mtxunlock(m->lock);
1022
1023         return (ret);
1024 }
1025
1026 int
1027 mix_get_type(struct snd_mixer *m)
1028 {
1029         KASSERT(m != NULL, ("NULL snd_mixer"));
1030
1031         return (m->type);
1032 }
1033
1034 device_t
1035 mix_get_dev(struct snd_mixer *m)
1036 {
1037         KASSERT(m != NULL, ("NULL snd_mixer"));
1038
1039         return (m->dev);
1040 }
1041
1042 /* ----------------------------------------------------------------------- */
1043
1044 static int
1045 mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
1046 {
1047         struct snddev_info *d;
1048         struct snd_mixer *m;
1049
1050
1051         if (i_dev == NULL || i_dev->si_drv1 == NULL)
1052                 return (EBADF);
1053
1054         m = i_dev->si_drv1;
1055         d = device_get_softc(m->dev);
1056         if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
1057                 return (EBADF);
1058
1059         /* XXX Need Giant magic entry ??? */
1060
1061         snd_mtxlock(m->lock);
1062         m->busy = 1;
1063         snd_mtxunlock(m->lock);
1064
1065         return (0);
1066 }
1067
1068 static int
1069 mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
1070 {
1071         struct snddev_info *d;
1072         struct snd_mixer *m;
1073         int ret;
1074
1075         if (i_dev == NULL || i_dev->si_drv1 == NULL)
1076                 return (EBADF);
1077
1078         m = i_dev->si_drv1;
1079         d = device_get_softc(m->dev);
1080         if (!PCM_REGISTERED(d))
1081                 return (EBADF);
1082
1083         /* XXX Need Giant magic entry ??? */
1084
1085         snd_mtxlock(m->lock);
1086         ret = (m->busy == 0) ? EBADF : 0;
1087         m->busy = 0;
1088         snd_mtxunlock(m->lock);
1089
1090         return (ret);
1091 }
1092
1093 static int
1094 mixer_ioctl_channel(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
1095     struct thread *td, int from)
1096 {
1097         struct snddev_info *d;
1098         struct snd_mixer *m;
1099         struct pcm_channel *c, *rdch, *wrch;
1100         pid_t pid;
1101         int j, ret;
1102
1103         if (td == NULL || td->td_proc == NULL)
1104                 return (-1);
1105
1106         m = dev->si_drv1;
1107         d = device_get_softc(m->dev);
1108         j = cmd & 0xff;
1109
1110         switch (j) {
1111         case SOUND_MIXER_PCM:
1112         case SOUND_MIXER_RECLEV:
1113         case SOUND_MIXER_DEVMASK:
1114         case SOUND_MIXER_CAPS:
1115         case SOUND_MIXER_STEREODEVS:
1116                 break;
1117         default:
1118                 return (-1);
1119                 break;
1120         }
1121
1122         pid = td->td_proc->p_pid;
1123         rdch = NULL;
1124         wrch = NULL;
1125         c = NULL;
1126         ret = -1;
1127
1128         /*
1129          * This is unfair. Imagine single proc opening multiple
1130          * instances of same direction. What we do right now
1131          * is looking for the first matching proc/pid, and just
1132          * that. Nothing more. Consider it done.
1133          *
1134          * The better approach of controlling specific channel
1135          * pcm or rec volume is by doing mixer ioctl
1136          * (SNDCTL_DSP_[SET|GET][PLAY|REC]VOL / SOUND_MIXER_[PCM|RECLEV]
1137          * on its open fd, rather than cracky mixer bypassing here.
1138          */
1139         CHN_FOREACH(c, d, channels.pcm.opened) {
1140                 CHN_LOCK(c);
1141                 if (c->pid != pid ||
1142                     !(c->feederflags & (1 << FEEDER_VOLUME))) {
1143                         CHN_UNLOCK(c);
1144                         continue;
1145                 }
1146                 if (rdch == NULL && c->direction == PCMDIR_REC) {
1147                         rdch = c;
1148                         if (j == SOUND_MIXER_RECLEV)
1149                                 goto mixer_ioctl_channel_proc;
1150                 } else if (wrch == NULL && c->direction == PCMDIR_PLAY) {
1151                         wrch = c;
1152                         if (j == SOUND_MIXER_PCM)
1153                                 goto mixer_ioctl_channel_proc;
1154                 }
1155                 CHN_UNLOCK(c);
1156                 if (rdch != NULL && wrch != NULL)
1157                         break;
1158         }
1159
1160         if (rdch == NULL && wrch == NULL)
1161                 return (-1);
1162
1163         if ((j == SOUND_MIXER_DEVMASK || j == SOUND_MIXER_CAPS ||
1164             j == SOUND_MIXER_STEREODEVS) &&
1165             (cmd & ~0xff) == MIXER_READ(0)) {
1166                 snd_mtxlock(m->lock);
1167                 *(int *)arg = mix_getdevs(m);
1168                 snd_mtxunlock(m->lock);
1169                 if (rdch != NULL)
1170                         *(int *)arg |= SOUND_MASK_RECLEV;
1171                 if (wrch != NULL)
1172                         *(int *)arg |= SOUND_MASK_PCM;
1173                 ret = 0;
1174         }
1175
1176         return (ret);
1177
1178 mixer_ioctl_channel_proc:
1179
1180         KASSERT(c != NULL, ("%s(): NULL channel", __func__));
1181         CHN_LOCKASSERT(c);
1182
1183         if ((cmd & ~0xff) == MIXER_WRITE(0)) {
1184                 int left, right, center;
1185
1186                 left = *(int *)arg & 0x7f;
1187                 right = (*(int *)arg >> 8) & 0x7f;
1188                 center = (left + right) >> 1;
1189                 chn_setvolume_multi(c, SND_VOL_C_PCM, left, right, center);
1190         } else if ((cmd & ~0xff) == MIXER_READ(0)) {
1191                 *(int *)arg = CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FL);
1192                 *(int *)arg |=
1193                     CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR) << 8;
1194         }
1195
1196         CHN_UNLOCK(c);
1197
1198         return (0);
1199 }
1200
1201 static int
1202 mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
1203     struct thread *td)
1204 {
1205         struct snddev_info *d;
1206         int ret;
1207
1208         if (i_dev == NULL || i_dev->si_drv1 == NULL)
1209                 return (EBADF);
1210
1211         d = device_get_softc(((struct snd_mixer *)i_dev->si_drv1)->dev);
1212         if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
1213                 return (EBADF);
1214
1215         PCM_GIANT_ENTER(d);
1216         PCM_ACQUIRE_QUICK(d);
1217
1218         ret = -1;
1219
1220         if (mixer_bypass != 0 && (d->flags & SD_F_VPC))
1221                 ret = mixer_ioctl_channel(i_dev, cmd, arg, mode, td,
1222                     MIXER_CMD_CDEV);
1223
1224         if (ret == -1)
1225                 ret = mixer_ioctl_cmd(i_dev, cmd, arg, mode, td,
1226                     MIXER_CMD_CDEV);
1227
1228         PCM_RELEASE_QUICK(d);
1229         PCM_GIANT_LEAVE(d);
1230
1231         return (ret);
1232 }
1233
1234 static void
1235 mixer_mixerinfo(struct snd_mixer *m, mixer_info *mi)
1236 {
1237         bzero((void *)mi, sizeof(*mi));
1238         strlcpy(mi->id, m->name, sizeof(mi->id));
1239         strlcpy(mi->name, device_get_desc(m->dev), sizeof(mi->name));
1240         mi->modify_counter = m->modify_counter;
1241 }
1242
1243 /*
1244  * XXX Make sure you can guarantee concurrency safety before calling this
1245  *     function, be it through Giant, PCM_*, etc !
1246  */
1247 int
1248 mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
1249     struct thread *td, int from)
1250 {
1251         struct snd_mixer *m;
1252         int ret = EINVAL, *arg_i = (int *)arg;
1253         int v = -1, j = cmd & 0xff;
1254
1255         /*
1256          * Certain ioctls may be made on any type of device (audio, mixer,
1257          * and MIDI).  Handle those special cases here.
1258          */
1259         if (IOCGROUP(cmd) == 'X') {
1260                 switch (cmd) {
1261                 case SNDCTL_SYSINFO:
1262                         sound_oss_sysinfo((oss_sysinfo *)arg);
1263                         return (0);
1264                 case SNDCTL_CARDINFO:
1265                         return (sound_oss_card_info((oss_card_info *)arg));
1266                 case SNDCTL_AUDIOINFO:
1267                 case SNDCTL_AUDIOINFO_EX:
1268                 case SNDCTL_ENGINEINFO:
1269                         return (dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg));
1270                 case SNDCTL_MIXERINFO:
1271                         return (mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg));
1272                 }
1273                 return (EINVAL);
1274         }
1275
1276         m = i_dev->si_drv1;
1277
1278         if (m == NULL)
1279                 return (EBADF);
1280
1281         snd_mtxlock(m->lock);
1282         if (from == MIXER_CMD_CDEV && !m->busy) {
1283                 snd_mtxunlock(m->lock);
1284                 return (EBADF);
1285         }
1286         switch (cmd) {
1287         case SNDCTL_DSP_GET_RECSRC_NAMES:
1288                 bcopy((void *)&m->enuminfo, arg, sizeof(oss_mixer_enuminfo));
1289                 ret = 0;
1290                 goto done;
1291         case SNDCTL_DSP_GET_RECSRC:
1292                 ret = mixer_get_recroute(m, arg_i);
1293                 goto done;
1294         case SNDCTL_DSP_SET_RECSRC:
1295                 ret = mixer_set_recroute(m, *arg_i);
1296                 goto done;
1297         case OSS_GETVERSION:
1298                 *arg_i = SOUND_VERSION;
1299                 ret = 0;
1300                 goto done;
1301         case SOUND_MIXER_INFO:
1302                 mixer_mixerinfo(m, (mixer_info *)arg);
1303                 ret = 0;
1304                 goto done;
1305         }
1306         if ((cmd & ~0xff) == MIXER_WRITE(0)) {
1307                 if (j == SOUND_MIXER_RECSRC)
1308                         ret = mixer_setrecsrc(m, *arg_i);
1309                 else
1310                         ret = mixer_set(m, j, *arg_i);
1311                 snd_mtxunlock(m->lock);
1312                 return ((ret == 0) ? 0 : ENXIO);
1313         }
1314         if ((cmd & ~0xff) == MIXER_READ(0)) {
1315                 switch (j) {
1316                 case SOUND_MIXER_DEVMASK:
1317                 case SOUND_MIXER_CAPS:
1318                 case SOUND_MIXER_STEREODEVS:
1319                         v = mix_getdevs(m);
1320                         break;
1321                 case SOUND_MIXER_RECMASK:
1322                         v = mix_getrecdevs(m);
1323                         break;
1324                 case SOUND_MIXER_RECSRC:
1325                         v = mixer_getrecsrc(m);
1326                         break;
1327                 default:
1328                         v = mixer_get(m, j);
1329                 }
1330                 *arg_i = v;
1331                 snd_mtxunlock(m->lock);
1332                 return ((v != -1) ? 0 : ENXIO);
1333         }
1334 done:
1335         snd_mtxunlock(m->lock);
1336         return (ret);
1337 }
1338
1339 static void
1340 mixer_clone(void *arg,
1341 #if __FreeBSD_version >= 600034
1342     struct ucred *cred,
1343 #endif
1344     char *name, int namelen, struct cdev **dev)
1345 {
1346         struct snddev_info *d;
1347
1348         if (*dev != NULL)
1349                 return;
1350         if (strcmp(name, "mixer") == 0) {
1351                 d = devclass_get_softc(pcm_devclass, snd_unit);
1352                 if (PCM_REGISTERED(d) && d->mixer_dev != NULL) {
1353                         *dev = d->mixer_dev;
1354                         dev_ref(*dev);
1355                 }
1356         }
1357 }
1358
1359 static void
1360 mixer_sysinit(void *p)
1361 {
1362         if (mixer_ehtag != NULL)
1363                 return;
1364         mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
1365 }
1366
1367 static void
1368 mixer_sysuninit(void *p)
1369 {
1370         if (mixer_ehtag == NULL)
1371                 return;
1372         EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
1373         mixer_ehtag = NULL;
1374 }
1375
1376 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
1377 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
1378
1379 /**
1380  * @brief Handler for SNDCTL_MIXERINFO
1381  *
1382  * This function searches for a mixer based on the numeric ID stored
1383  * in oss_miserinfo::dev.  If set to -1, then information about the
1384  * current mixer handling the request is provided.  Note, however, that
1385  * this ioctl may be made with any sound device (audio, mixer, midi).
1386  *
1387  * @note Caller must not hold any PCM device, channel, or mixer locks.
1388  *
1389  * See http://manuals.opensound.com/developer/SNDCTL_MIXERINFO.html for
1390  * more information.
1391  *
1392  * @param i_dev character device on which the ioctl arrived
1393  * @param arg   user argument (oss_mixerinfo *)
1394  *
1395  * @retval EINVAL       oss_mixerinfo::dev specified a bad value
1396  * @retval 0            success
1397  */
1398 int
1399 mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
1400 {
1401         struct snddev_info *d;
1402         struct snd_mixer *m;
1403         int nmix, i;
1404
1405         /*
1406          * If probing the device handling the ioctl, make sure it's a mixer
1407          * device.  (This ioctl is valid on audio, mixer, and midi devices.)
1408          */
1409         if (mi->dev == -1 && i_dev->si_devsw != &mixer_cdevsw)
1410                 return (EINVAL);
1411
1412         d = NULL;
1413         m = NULL;
1414         nmix = 0;
1415
1416         /*
1417          * There's a 1:1 relationship between mixers and PCM devices, so
1418          * begin by iterating over PCM devices and search for our mixer.
1419          */
1420         for (i = 0; pcm_devclass != NULL &&
1421             i < devclass_get_maxunit(pcm_devclass); i++) {
1422                 d = devclass_get_softc(pcm_devclass, i);
1423                 if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
1424                         continue;
1425
1426                 /* XXX Need Giant magic entry */
1427
1428                 /* See the note in function docblock. */
1429                 PCM_UNLOCKASSERT(d);
1430                 PCM_LOCK(d);
1431
1432                 if (d->mixer_dev != NULL && d->mixer_dev->si_drv1 != NULL &&
1433                     ((mi->dev == -1 && d->mixer_dev == i_dev) ||
1434                     mi->dev == nmix)) {
1435                         m = d->mixer_dev->si_drv1;
1436                         mtx_lock(m->lock);
1437
1438                         /*
1439                          * At this point, the following synchronization stuff
1440                          * has happened:
1441                          * - a specific PCM device is locked.
1442                          * - a specific mixer device has been locked, so be
1443                          *   sure to unlock when existing.
1444                          */
1445                         bzero((void *)mi, sizeof(*mi));
1446                         mi->dev = nmix;
1447                         snprintf(mi->id, sizeof(mi->id), "mixer%d", i);
1448                         strlcpy(mi->name, m->name, sizeof(mi->name));
1449                         mi->modify_counter = m->modify_counter;
1450                         mi->card_number = i;
1451                         /*
1452                          * Currently, FreeBSD assumes 1:1 relationship between
1453                          * a pcm and mixer devices, so this is hardcoded to 0.
1454                          */
1455                         mi->port_number = 0;
1456
1457                         /**
1458                          * @todo Fill in @sa oss_mixerinfo::mixerhandle.
1459                          * @note From 4Front:  "mixerhandle is an arbitrary
1460                          *       string that identifies the mixer better than
1461                          *       the device number (mixerinfo.dev).  Device
1462                          *       numbers may change depending on the order the
1463                          *       drivers are loaded. However the handle should
1464                          *       remain the same provided that the sound card
1465                          *       is not moved to another PCI slot."
1466                          */
1467
1468                         /**
1469                          * @note
1470                          * @sa oss_mixerinfo::magic is a reserved field.
1471                          *
1472                          * @par
1473                          * From 4Front:  "magic is usually 0. However some
1474                          * devices may have dedicated setup utilities and the
1475                          * magic field may contain an unique driver specific
1476                          * value (managed by [4Front])."
1477                          */
1478
1479                         mi->enabled = device_is_attached(m->dev) ? 1 : 0;
1480                         /**
1481                          * The only flag for @sa oss_mixerinfo::caps is
1482                          * currently MIXER_CAP_VIRTUAL, which I'm not sure we
1483                          * really worry about.
1484                          */
1485                         /**
1486                          * Mixer extensions currently aren't supported, so
1487                          * leave @sa oss_mixerinfo::nrext blank for now.
1488                          */
1489                         /**
1490                          * @todo Fill in @sa oss_mixerinfo::priority (requires
1491                          *       touching drivers?)
1492                          * @note The priority field is for mixer applets to
1493                          * determine which mixer should be the default, with 0
1494                          * being least preferred and 10 being most preferred.
1495                          * From 4Front:  "OSS drivers like ICH use higher
1496                          * values (10) because such chips are known to be used
1497                          * only on motherboards.  Drivers for high end pro
1498                          * devices use 0 because they will never be the
1499                          * default mixer. Other devices use values 1 to 9
1500                          * depending on the estimated probability of being the
1501                          * default device.
1502                          *
1503                          * XXX Described by Hannu@4Front, but not found in
1504                          *     soundcard.h.
1505                         strlcpy(mi->devnode, devtoname(d->mixer_dev),
1506                         sizeof(mi->devnode));
1507                         mi->legacy_device = i;
1508                          */
1509                         mtx_unlock(m->lock);
1510                 } else
1511                         ++nmix;
1512
1513                 PCM_UNLOCK(d);
1514
1515                 if (m != NULL)
1516                         return (0);
1517         }
1518
1519         return (EINVAL);
1520 }
1521
1522 /*
1523  * Allow the sound driver to use the mixer lock to protect its mixer
1524  * data:
1525  */
1526 struct mtx *
1527 mixer_get_lock(struct snd_mixer *m)
1528 {
1529         if (m->lock == NULL) {
1530                 return (&Giant);
1531         }
1532         return (m->lock);
1533 }
1534
1535 int
1536 mix_get_locked(struct snd_mixer *m, u_int dev, int *pleft, int *pright)
1537 {
1538         int level;
1539
1540         level = mixer_get(m, dev);
1541         if (level < 0) {
1542                 *pright = *pleft = -1;
1543                 return (-1);
1544         }
1545
1546         *pleft = level & 0xFF;
1547         *pright = (level >> 8) & 0xFF;
1548
1549         return (0);
1550 }
1551
1552 int
1553 mix_set_locked(struct snd_mixer *m, u_int dev, int left, int right)
1554 {
1555         int level;
1556
1557         level = (left & 0xFF) | ((right & 0xFF) << 8);
1558
1559         return (mixer_set(m, dev, level));
1560 }