The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/pcm/mixer.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 9dda0522db0d1509b6a153b118b2bd0f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.