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/ic/cs4231.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: cs4231.c,v 1.17 2005/01/15 15:19:52 kent Exp $ */
    2 
    3 /*-
    4  * Copyright (c) 1998, 1999 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Paul Kranenburg.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *        This product includes software developed by the NetBSD
   21  *        Foundation, Inc. and its contributors.
   22  * 4. Neither the name of The NetBSD Foundation nor the names of its
   23  *    contributors may be used to endorse or promote products derived
   24  *    from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   36  * POSSIBILITY OF SUCH DAMAGE.
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __KERNEL_RCSID(0, "$NetBSD: cs4231.c,v 1.17 2005/01/15 15:19:52 kent Exp $");
   41 
   42 #include "audio.h"
   43 #if NAUDIO > 0
   44 
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/errno.h>
   48 #include <sys/device.h>
   49 #include <sys/malloc.h>
   50 
   51 #include <machine/autoconf.h>
   52 #include <machine/cpu.h>
   53 
   54 #include <sys/audioio.h>
   55 #include <dev/audio_if.h>
   56 
   57 #include <dev/ic/ad1848reg.h>
   58 #include <dev/ic/cs4231reg.h>
   59 #include <dev/ic/ad1848var.h>
   60 #include <dev/ic/cs4231var.h>
   61 
   62 /*---*/
   63 #define CSAUDIO_DAC_LVL         0
   64 #define CSAUDIO_LINE_IN_LVL     1
   65 #define CSAUDIO_MONO_LVL        2
   66 #define CSAUDIO_CD_LVL          3
   67 #define CSAUDIO_OUTPUT_LVL      4
   68 #define CSAUDIO_OUT_LVL         5
   69 #define CSAUDIO_LINE_IN_MUTE    6
   70 #define CSAUDIO_DAC_MUTE        7
   71 #define CSAUDIO_CD_MUTE         8
   72 #define CSAUDIO_MONO_MUTE       9
   73 #define CSAUDIO_OUTPUT_MUTE     10
   74 #define CSAUDIO_OUT_MUTE        11
   75 #define CSAUDIO_REC_LVL         12
   76 #define CSAUDIO_RECORD_SOURCE   13
   77 
   78 #define CSAUDIO_INPUT_CLASS     14
   79 #define CSAUDIO_MONITOR_CLASS   15
   80 #define CSAUDIO_RECORD_CLASS    16
   81 
   82 #ifdef AUDIO_DEBUG
   83 int     cs4231_debug = 0;
   84 #define DPRINTF(x)      if (cs4231_debug) printf x
   85 #else
   86 #define DPRINTF(x)
   87 #endif
   88 
   89 struct audio_device cs4231_device = {
   90         "cs4231",
   91         "x",
   92         "audio"
   93 };
   94 
   95 
   96 /* ad1848 sc_{read,write}reg */
   97 static int      cs4231_read(struct ad1848_softc *, int);
   98 static void     cs4231_write(struct ad1848_softc *, int, int);
   99 
  100 int
  101 cs4231_read(struct ad1848_softc *sc, int index)
  102 {
  103 
  104         return bus_space_read_1(sc->sc_iot, sc->sc_ioh, (index << 2));
  105 }
  106 
  107 void
  108 cs4231_write(struct ad1848_softc *sc, int index, int value)
  109 {
  110 
  111         bus_space_write_1(sc->sc_iot, sc->sc_ioh, (index << 2), value);
  112 }
  113 
  114 
  115 void
  116 cs4231_common_attach(struct cs4231_softc *sc, bus_space_handle_t ioh)
  117 {
  118         char *buf;
  119         int reg;
  120 
  121         sc->sc_ad1848.parent = sc;
  122         sc->sc_ad1848.sc_iot = sc->sc_bustag;
  123         sc->sc_ad1848.sc_ioh = ioh;
  124         sc->sc_ad1848.sc_readreg = cs4231_read;
  125         sc->sc_ad1848.sc_writereg = cs4231_write;
  126 
  127         sc->sc_playback.t_name = "playback";
  128         sc->sc_capture.t_name = "capture";
  129 
  130         evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR,
  131                              NULL,
  132                              sc->sc_ad1848.sc_dev.dv_xname, "total");
  133 
  134         evcnt_attach_dynamic(&sc->sc_playback.t_intrcnt, EVCNT_TYPE_INTR,
  135                              &sc->sc_intrcnt,
  136                              sc->sc_ad1848.sc_dev.dv_xname, "playback");
  137 
  138         evcnt_attach_dynamic(&sc->sc_playback.t_ierrcnt, EVCNT_TYPE_INTR,
  139                              &sc->sc_intrcnt,
  140                              sc->sc_ad1848.sc_dev.dv_xname, "perrors");
  141 
  142         evcnt_attach_dynamic(&sc->sc_capture.t_intrcnt, EVCNT_TYPE_INTR,
  143                              &sc->sc_intrcnt,
  144                              sc->sc_ad1848.sc_dev.dv_xname, "capture");
  145 
  146         evcnt_attach_dynamic(&sc->sc_capture.t_ierrcnt, EVCNT_TYPE_INTR,
  147                              &sc->sc_intrcnt,
  148                              sc->sc_ad1848.sc_dev.dv_xname, "cerrors");
  149 
  150         /* put chip in native mode to access (extended) ID register */
  151         reg = ad_read(&sc->sc_ad1848, SP_MISC_INFO);
  152         ad_write(&sc->sc_ad1848, SP_MISC_INFO, reg | MODE2);
  153 
  154         /* read version numbers from I25 */
  155         reg = ad_read(&sc->sc_ad1848, CS_VERSION_ID);
  156         switch (reg & (CS_VERSION_NUMBER | CS_VERSION_CHIPID)) {
  157         case 0xa0:
  158                 sc->sc_ad1848.chip_name = "CS4231A";
  159                 break;
  160         case 0x80:
  161                 sc->sc_ad1848.chip_name = "CS4231";
  162                 break;
  163         case 0x82:
  164                 sc->sc_ad1848.chip_name = "CS4232";
  165                 break;
  166         default:
  167                 if ((buf = malloc(32, M_TEMP, M_NOWAIT)) != NULL) {
  168                         snprintf(buf, 32, "unknown rev: %x/%x",
  169                             reg&0xe0, reg&7);
  170                         sc->sc_ad1848.chip_name = buf;
  171                 }
  172         }
  173 
  174         sc->sc_ad1848.mode = 2; /* put ad1848 driver in `MODE 2' mode */
  175         ad1848_attach(&sc->sc_ad1848);
  176 }
  177 
  178 void *
  179 cs4231_malloc(void *addr, int direction, size_t size,
  180     struct malloc_type *pool, int flags)
  181 {
  182         struct cs4231_softc *sc;
  183         bus_dma_tag_t dmatag;
  184         struct cs_dma *p;
  185 
  186         sc = addr;
  187         dmatag = sc->sc_dmatag;
  188         p = malloc(sizeof(*p), pool, flags);
  189         if (p == NULL)
  190                 return NULL;
  191 
  192         /* Allocate a DMA map */
  193         if (bus_dmamap_create(dmatag, size, 1, size, 0,
  194             BUS_DMA_NOWAIT, &p->dmamap) != 0)
  195                 goto fail1;
  196 
  197         /* Allocate DMA memory */
  198         p->size = size;
  199         if (bus_dmamem_alloc(dmatag, size, 64*1024, 0,
  200             p->segs, sizeof(p->segs)/sizeof(p->segs[0]),
  201             &p->nsegs, BUS_DMA_NOWAIT) != 0)
  202                 goto fail2;
  203 
  204         /* Map DMA memory into kernel space */
  205         if (bus_dmamem_map(dmatag, p->segs, p->nsegs, p->size,
  206             &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT) != 0)
  207                 goto fail3;
  208 
  209         /* Load the buffer */
  210         if (bus_dmamap_load(dmatag, p->dmamap,
  211             p->addr, size, NULL, BUS_DMA_NOWAIT) != 0)
  212                 goto fail4;
  213 
  214         p->next = sc->sc_dmas;
  215         sc->sc_dmas = p;
  216         return p->addr;
  217 
  218 fail4:
  219         bus_dmamem_unmap(dmatag, p->addr, p->size);
  220 fail3:
  221         bus_dmamem_free(dmatag, p->segs, p->nsegs);
  222 fail2:
  223         bus_dmamap_destroy(dmatag, p->dmamap);
  224 fail1:
  225         free(p, pool);
  226         return NULL;
  227 }
  228 
  229 void
  230 cs4231_free(void *addr, void *ptr, struct malloc_type *pool)
  231 {
  232         struct cs4231_softc *sc;
  233         bus_dma_tag_t dmatag;
  234         struct cs_dma *p, **pp;
  235 
  236         sc = addr;
  237         dmatag = sc->sc_dmatag;
  238         for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) {
  239                 if (p->addr != ptr)
  240                         continue;
  241                 bus_dmamap_unload(dmatag, p->dmamap);
  242                 bus_dmamem_unmap(dmatag, p->addr, p->size);
  243                 bus_dmamem_free(dmatag, p->segs, p->nsegs);
  244                 bus_dmamap_destroy(dmatag, p->dmamap);
  245                 *pp = p->next;
  246                 free(p, pool);
  247                 return;
  248         }
  249         printf("cs4231_free: rogue pointer\n");
  250 }
  251 
  252 
  253 /*
  254  * Set up transfer and return DMA address and byte count in paddr and psize
  255  * for bus dependent trigger_{in,out}put to load into the DMA controller.
  256  */
  257 int
  258 cs4231_transfer_init(
  259         struct cs4231_softc *sc,
  260         struct cs_transfer *t,
  261         bus_addr_t *paddr,
  262         bus_size_t *psize,
  263         void *start, void *end,
  264         int blksize,
  265         void (*intr)(void *),
  266         void *arg)
  267 {
  268         struct cs_dma *p;
  269         vsize_t n;
  270 
  271         if (t->t_active) {
  272                 printf("%s: %s already running\n",
  273                        sc->sc_ad1848.sc_dev.dv_xname, t->t_name);
  274                 return EINVAL;
  275         }
  276 
  277         t->t_intr = intr;
  278         t->t_arg = arg;
  279 
  280         for (p = sc->sc_dmas; p != NULL && p->addr != start; p = p->next)
  281                 continue;
  282         if (p == NULL) {
  283                 printf("%s: bad %s addr %p\n",
  284                        sc->sc_ad1848.sc_dev.dv_xname, t->t_name, start);
  285                 return EINVAL;
  286         }
  287 
  288         n = (char *)end - (char *)start;
  289 
  290         t->t_dma = p;           /* the DMA memory segment */
  291         t->t_segsz = n;         /* size of DMA segment */
  292         t->t_blksz = blksize;   /* do transfers in blksize chunks */
  293 
  294         if (n > t->t_blksz)
  295                 n = t->t_blksz;
  296 
  297         t->t_cnt = n;
  298 
  299         /* for caller to load into DMA controller */
  300         *paddr = t->t_dma->dmamap->dm_segs[0].ds_addr;
  301         *psize = n;
  302 
  303         DPRINTF(("%s: init %s: [%p..%p] %lu bytes %lu blocks;"
  304                  " DMA at 0x%lx count %lu\n",
  305                  sc->sc_ad1848.sc_dev.dv_xname, t->t_name,
  306                  start, end, (u_long)t->t_segsz, (u_long)t->t_blksz,
  307                  (u_long)*paddr, (u_long)*psize));
  308 
  309         t->t_active = 1;
  310         return 0;
  311 }
  312 
  313 /*
  314  * Compute next DMA address/counter, update transfer status.
  315  */
  316 void
  317 cs4231_transfer_advance(struct cs_transfer *t, bus_addr_t *paddr,
  318     bus_size_t *psize)
  319 {
  320         bus_addr_t dmabase, nextaddr;
  321         bus_size_t togo;
  322 
  323         dmabase = t->t_dma->dmamap->dm_segs[0].ds_addr;
  324 
  325         togo = t->t_segsz - t->t_cnt;
  326         if (togo == 0) {        /* roll over */
  327                 nextaddr = dmabase;
  328                 t->t_cnt = togo = t->t_blksz;
  329         } else {
  330                 nextaddr = dmabase + t->t_cnt;
  331                 if (togo > t->t_blksz)
  332                         togo = t->t_blksz;
  333                 t->t_cnt += togo;
  334         }
  335 
  336         /* for caller to load into DMA controller */
  337         *paddr = nextaddr;
  338         *psize = togo;
  339 }
  340 
  341 
  342 int
  343 cs4231_open(void *addr, int flags)
  344 {
  345         struct cs4231_softc *sc;
  346 
  347         sc = addr;
  348         DPRINTF(("sa_open: unit %p\n", sc));
  349 
  350         sc->sc_playback.t_active = 0;
  351         sc->sc_playback.t_intr = NULL;
  352         sc->sc_playback.t_arg = NULL;
  353 
  354         sc->sc_capture.t_active = 0;
  355         sc->sc_capture.t_intr = NULL;
  356         sc->sc_capture.t_arg = NULL;
  357 
  358         /* no interrupts from ad1848 */
  359         ad_write(&sc->sc_ad1848, SP_PIN_CONTROL, 0);
  360         ad1848_reset(&sc->sc_ad1848);
  361 
  362         DPRINTF(("sa_open: ok -> sc=%p\n", sc));
  363         return 0;
  364 }
  365 
  366 void
  367 cs4231_close(void *addr)
  368 {
  369 
  370         DPRINTF(("sa_close: sc=%p\n", addr));
  371 
  372         /* audio(9) already called halt methods */
  373 
  374         DPRINTF(("sa_close: closed.\n"));
  375 }
  376 
  377 int
  378 cs4231_getdev(void *addr, struct audio_device *retp)
  379 {
  380 
  381         *retp = cs4231_device;
  382         return 0;
  383 }
  384 
  385 static ad1848_devmap_t csmapping[] = {
  386         { CSAUDIO_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL },
  387         { CSAUDIO_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL },
  388         { CSAUDIO_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL },
  389         { CSAUDIO_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL },
  390         { CSAUDIO_OUTPUT_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL },
  391         { CSAUDIO_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL },
  392         { CSAUDIO_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL },
  393         { CSAUDIO_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL },
  394         { CSAUDIO_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL },
  395         { CSAUDIO_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL },
  396         { CSAUDIO_OUTPUT_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL },
  397         { CSAUDIO_OUT_MUTE, AD1848_KIND_MUTE, AD1848_OUT_CHANNEL },
  398         { CSAUDIO_REC_LVL, AD1848_KIND_RECORDGAIN, -1 },
  399         { CSAUDIO_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 }
  400 };
  401 
  402 static int nummap = sizeof(csmapping) / sizeof(csmapping[0]);
  403 
  404 
  405 int
  406 cs4231_set_port(void *addr, mixer_ctrl_t *cp)
  407 {
  408         struct ad1848_softc *ac;
  409 
  410         DPRINTF(("cs4231_set_port: port=%d", cp->dev));
  411         ac = addr;
  412         return ad1848_mixer_set_port(ac, csmapping, nummap, cp);
  413 }
  414 
  415 int
  416 cs4231_get_port(void *addr, mixer_ctrl_t *cp)
  417 {
  418         struct ad1848_softc *ac;
  419 
  420         DPRINTF(("cs4231_get_port: port=%d", cp->dev));
  421         ac = addr;
  422         return ad1848_mixer_get_port(ac, csmapping, nummap, cp);
  423 }
  424 
  425 int
  426 cs4231_get_props(void *addr)
  427 {
  428 
  429         return AUDIO_PROP_FULLDUPLEX;
  430 }
  431 
  432 int
  433 cs4231_query_devinfo(void *addr, mixer_devinfo_t *dip)
  434 {
  435 
  436         switch(dip->index) {
  437 
  438         case CSAUDIO_DAC_LVL:           /*  dacout */
  439                 dip->type = AUDIO_MIXER_VALUE;
  440                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  441                 dip->prev = AUDIO_MIXER_LAST;
  442                 dip->next = CSAUDIO_DAC_MUTE;
  443                 strcpy(dip->label.name, AudioNdac);
  444                 dip->un.v.num_channels = 2;
  445                 strcpy(dip->un.v.units.name, AudioNvolume);
  446                 break;
  447 
  448         case CSAUDIO_LINE_IN_LVL:       /* line */
  449                 dip->type = AUDIO_MIXER_VALUE;
  450                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  451                 dip->prev = AUDIO_MIXER_LAST;
  452                 dip->next = CSAUDIO_LINE_IN_MUTE;
  453                 strcpy(dip->label.name, AudioNline);
  454                 dip->un.v.num_channels = 2;
  455                 strcpy(dip->un.v.units.name, AudioNvolume);
  456                 break;
  457 
  458         case CSAUDIO_MONO_LVL:  /* mono/microphone mixer */
  459                 dip->type = AUDIO_MIXER_VALUE;
  460                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  461                 dip->prev = AUDIO_MIXER_LAST;
  462                 dip->next = CSAUDIO_MONO_MUTE;
  463                 strcpy(dip->label.name, AudioNmicrophone);
  464                 dip->un.v.num_channels = 1;
  465                 strcpy(dip->un.v.units.name, AudioNvolume);
  466                 break;
  467 
  468         case CSAUDIO_CD_LVL:            /* cd */
  469                 dip->type = AUDIO_MIXER_VALUE;
  470                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  471                 dip->prev = AUDIO_MIXER_LAST;
  472                 dip->next = CSAUDIO_CD_MUTE;
  473                 strcpy(dip->label.name, AudioNcd);
  474                 dip->un.v.num_channels = 2;
  475                 strcpy(dip->un.v.units.name, AudioNvolume);
  476                 break;
  477 
  478 
  479         case CSAUDIO_OUTPUT_LVL:        /* monitor level */
  480                 dip->type = AUDIO_MIXER_VALUE;
  481                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  482                 dip->next = CSAUDIO_OUTPUT_MUTE;
  483                 dip->prev = AUDIO_MIXER_LAST;
  484                 strcpy(dip->label.name, AudioNmonitor);
  485                 dip->un.v.num_channels = 1;
  486                 strcpy(dip->un.v.units.name, AudioNvolume);
  487                 break;
  488 
  489         case CSAUDIO_OUT_LVL:           /* cs4231 output volume */
  490                 dip->type = AUDIO_MIXER_VALUE;
  491                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  492                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  493                 strcpy(dip->label.name, AudioNmaster);
  494                 dip->un.v.num_channels = 2;
  495                 strcpy(dip->un.v.units.name, AudioNvolume);
  496                 break;
  497 
  498         case CSAUDIO_OUT_MUTE: /* mute built-in speaker */
  499                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  500                 dip->type = AUDIO_MIXER_ENUM;
  501                 dip->prev = CSAUDIO_MONITOR_CLASS;
  502                 dip->next = AUDIO_MIXER_LAST;
  503                 strcpy(dip->label.name, AudioNmono);
  504                 /* names reversed, this is a "mute" value used as "mono enabled" */
  505                 dip->un.e.num_mem = 2;
  506                 strcpy(dip->un.e.member[0].label.name, AudioNon);
  507                 dip->un.e.member[0].ord = 0;
  508                 strcpy(dip->un.e.member[1].label.name, AudioNoff);
  509                 dip->un.e.member[1].ord = 1;
  510                 break;
  511 
  512         case CSAUDIO_LINE_IN_MUTE:
  513                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  514                 dip->type = AUDIO_MIXER_ENUM;
  515                 dip->prev = CSAUDIO_LINE_IN_LVL;
  516                 dip->next = AUDIO_MIXER_LAST;
  517                 goto mute;
  518 
  519         case CSAUDIO_DAC_MUTE:
  520                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  521                 dip->type = AUDIO_MIXER_ENUM;
  522                 dip->prev = CSAUDIO_DAC_LVL;
  523                 dip->next = AUDIO_MIXER_LAST;
  524                 goto mute;
  525 
  526         case CSAUDIO_CD_MUTE:
  527                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  528                 dip->type = AUDIO_MIXER_ENUM;
  529                 dip->prev = CSAUDIO_CD_LVL;
  530                 dip->next = AUDIO_MIXER_LAST;
  531                 goto mute;
  532 
  533         case CSAUDIO_MONO_MUTE:
  534                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  535                 dip->type = AUDIO_MIXER_ENUM;
  536                 dip->prev = CSAUDIO_MONO_LVL;
  537                 dip->next = AUDIO_MIXER_LAST;
  538                 goto mute;
  539 
  540         case CSAUDIO_OUTPUT_MUTE:
  541                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  542                 dip->type = AUDIO_MIXER_ENUM;
  543                 dip->prev = CSAUDIO_OUTPUT_LVL;
  544                 dip->next = AUDIO_MIXER_LAST;
  545         mute:
  546                 strcpy(dip->label.name, AudioNmute);
  547                 dip->un.e.num_mem = 2;
  548                 strcpy(dip->un.e.member[0].label.name, AudioNoff);
  549                 dip->un.e.member[0].ord = 0;
  550                 strcpy(dip->un.e.member[1].label.name, AudioNon);
  551                 dip->un.e.member[1].ord = 1;
  552                 break;
  553 
  554         case CSAUDIO_REC_LVL:   /* record level */
  555                 dip->type = AUDIO_MIXER_VALUE;
  556                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  557                 dip->prev = AUDIO_MIXER_LAST;
  558                 dip->next = CSAUDIO_RECORD_SOURCE;
  559                 strcpy(dip->label.name, AudioNrecord);
  560                 dip->un.v.num_channels = 2;
  561                 strcpy(dip->un.v.units.name, AudioNvolume);
  562                 break;
  563 
  564         case CSAUDIO_RECORD_SOURCE:
  565                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  566                 dip->type = AUDIO_MIXER_ENUM;
  567                 dip->prev = CSAUDIO_REC_LVL;
  568                 dip->next = AUDIO_MIXER_LAST;
  569                 strcpy(dip->label.name, AudioNsource);
  570                 dip->un.e.num_mem = 4;
  571                 strcpy(dip->un.e.member[0].label.name, AudioNoutput);
  572                 dip->un.e.member[0].ord = DAC_IN_PORT;
  573                 strcpy(dip->un.e.member[1].label.name, AudioNmicrophone);
  574                 dip->un.e.member[1].ord = MIC_IN_PORT;
  575                 strcpy(dip->un.e.member[2].label.name, AudioNdac);
  576                 dip->un.e.member[2].ord = AUX1_IN_PORT;
  577                 strcpy(dip->un.e.member[3].label.name, AudioNline);
  578                 dip->un.e.member[3].ord = LINE_IN_PORT;
  579                 break;
  580 
  581         case CSAUDIO_INPUT_CLASS:               /* input class descriptor */
  582                 dip->type = AUDIO_MIXER_CLASS;
  583                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  584                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  585                 strcpy(dip->label.name, AudioCinputs);
  586                 break;
  587 
  588         case CSAUDIO_MONITOR_CLASS:             /* output class descriptor */
  589                 dip->type = AUDIO_MIXER_CLASS;
  590                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  591                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  592                 strcpy(dip->label.name, AudioCmonitor);
  593                 break;
  594 
  595         case CSAUDIO_RECORD_CLASS:              /* record source class */
  596                 dip->type = AUDIO_MIXER_CLASS;
  597                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  598                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  599                 strcpy(dip->label.name, AudioCrecord);
  600                 break;
  601 
  602         default:
  603                 return ENXIO;
  604                 /*NOTREACHED*/
  605         }
  606         DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
  607 
  608         return 0;
  609 }
  610 
  611 #endif /* NAUDIO > 0 */

Cache object: 3afef7c4fa20debbad3361fbedca2fca


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