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  * 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: stable/10/sys/dev/sound/pcm/mixer.c 359887 2020-04-13 16:32:18Z hselasky $");
   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 }

Cache object: deec5569d8f285abeea9214bb4c3731c


[ 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.