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

Cache object: a500dda1a283c0fb5d4c50582eac9055


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