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.13 2003/09/10 11:53:53 uwe 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.13 2003/09/10 11:53:53 uwe 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(sc, index)
  102         struct ad1848_softc     *sc;
  103         int                     index;
  104 {
  105 
  106         return bus_space_read_1(sc->sc_iot, sc->sc_ioh, (index << 2));
  107 }
  108 
  109 void
  110 cs4231_write(sc, index, value)
  111         struct ad1848_softc     *sc;
  112         int                     index, value;
  113 {
  114 
  115         bus_space_write_1(sc->sc_iot, sc->sc_ioh, (index << 2), value);
  116 }
  117 
  118 
  119 void
  120 cs4231_common_attach(sc, ioh)
  121         struct cs4231_softc *sc;
  122         bus_space_handle_t ioh;
  123 {
  124         char *buf;
  125         int reg;
  126 
  127         sc->sc_ad1848.parent = sc;
  128         sc->sc_ad1848.sc_iot = sc->sc_bustag;
  129         sc->sc_ad1848.sc_ioh = ioh;
  130         sc->sc_ad1848.sc_readreg = cs4231_read;
  131         sc->sc_ad1848.sc_writereg = cs4231_write;
  132 
  133         sc->sc_playback.t_name = "playback";
  134         sc->sc_capture.t_name = "capture";
  135 
  136         evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR,
  137                              NULL,
  138                              sc->sc_ad1848.sc_dev.dv_xname, "total");
  139 
  140         evcnt_attach_dynamic(&sc->sc_playback.t_intrcnt, EVCNT_TYPE_INTR,
  141                              &sc->sc_intrcnt,
  142                              sc->sc_ad1848.sc_dev.dv_xname, "playback");
  143 
  144         evcnt_attach_dynamic(&sc->sc_playback.t_ierrcnt, EVCNT_TYPE_INTR,
  145                              &sc->sc_intrcnt,
  146                              sc->sc_ad1848.sc_dev.dv_xname, "perrors");
  147 
  148         evcnt_attach_dynamic(&sc->sc_capture.t_intrcnt, EVCNT_TYPE_INTR,
  149                              &sc->sc_intrcnt,
  150                              sc->sc_ad1848.sc_dev.dv_xname, "capture");
  151 
  152         evcnt_attach_dynamic(&sc->sc_capture.t_ierrcnt, EVCNT_TYPE_INTR,
  153                              &sc->sc_intrcnt,
  154                              sc->sc_ad1848.sc_dev.dv_xname, "cerrors");
  155 
  156         /* put chip in native mode to access (extended) ID register */
  157         reg = ad_read(&sc->sc_ad1848, SP_MISC_INFO);
  158         ad_write(&sc->sc_ad1848, SP_MISC_INFO, reg | MODE2);
  159 
  160         /* read version numbers from I25 */
  161         reg = ad_read(&sc->sc_ad1848, CS_VERSION_ID);
  162         switch (reg & (CS_VERSION_NUMBER | CS_VERSION_CHIPID)) {
  163         case 0xa0:
  164                 sc->sc_ad1848.chip_name = "CS4231A";
  165                 break;
  166         case 0x80:
  167                 sc->sc_ad1848.chip_name = "CS4231";
  168                 break;
  169         case 0x82:
  170                 sc->sc_ad1848.chip_name = "CS4232";
  171                 break;
  172         default:
  173                 if ((buf = malloc(32, M_TEMP, M_NOWAIT)) != NULL) {
  174                         sprintf(buf, "unknown rev: %x/%x", reg&0xe0, reg&7);
  175                         sc->sc_ad1848.chip_name = buf;
  176                 }
  177         }
  178 
  179         sc->sc_ad1848.mode = 2; /* put ad1848 driver in `MODE 2' mode */
  180         ad1848_attach(&sc->sc_ad1848);
  181 }
  182 
  183 void *
  184 cs4231_malloc(addr, direction, size, pool, flags)
  185         void *addr;
  186         int direction;
  187         size_t size;
  188         struct malloc_type *pool;
  189         int flags;
  190 {
  191         struct cs4231_softc *sc = addr;
  192         bus_dma_tag_t dmatag = sc->sc_dmatag;
  193         struct cs_dma *p;
  194 
  195         p = malloc(sizeof(*p), pool, flags);
  196         if (p == NULL)
  197                 return (NULL);
  198 
  199         /* Allocate a DMA map */
  200         if (bus_dmamap_create(dmatag, size, 1, size, 0,
  201                                 BUS_DMA_NOWAIT, &p->dmamap) != 0)
  202                 goto fail1;
  203 
  204         /* Allocate DMA memory */
  205         p->size = size;
  206         if (bus_dmamem_alloc(dmatag, size, 64*1024, 0,
  207                                 p->segs, sizeof(p->segs)/sizeof(p->segs[0]),
  208                                 &p->nsegs, BUS_DMA_NOWAIT) != 0)
  209                 goto fail2;
  210 
  211         /* Map DMA memory into kernel space */
  212         if (bus_dmamem_map(dmatag, p->segs, p->nsegs, p->size, 
  213                            &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT) != 0)
  214                 goto fail3;
  215 
  216         /* Load the buffer */
  217         if (bus_dmamap_load(dmatag, p->dmamap,
  218                             p->addr, size, NULL, BUS_DMA_NOWAIT) != 0)
  219                 goto fail4;
  220 
  221         p->next = sc->sc_dmas;
  222         sc->sc_dmas = p;
  223         return (p->addr);
  224 
  225 fail4:
  226         bus_dmamem_unmap(dmatag, p->addr, p->size);
  227 fail3:
  228         bus_dmamem_free(dmatag, p->segs, p->nsegs);
  229 fail2:
  230         bus_dmamap_destroy(dmatag, p->dmamap);
  231 fail1:
  232         free(p, pool);
  233         return (NULL);
  234 }
  235 
  236 void
  237 cs4231_free(addr, ptr, pool)
  238         void *addr;
  239         void *ptr;
  240         struct malloc_type *pool;
  241 {
  242         struct cs4231_softc *sc = addr;
  243         bus_dma_tag_t dmatag = sc->sc_dmatag;
  244         struct cs_dma *p, **pp;
  245 
  246         for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) {
  247                 if (p->addr != ptr)
  248                         continue;
  249                 bus_dmamap_unload(dmatag, p->dmamap);
  250                 bus_dmamem_unmap(dmatag, p->addr, p->size);
  251                 bus_dmamem_free(dmatag, p->segs, p->nsegs);
  252                 bus_dmamap_destroy(dmatag, p->dmamap);
  253                 *pp = p->next;
  254                 free(p, pool);
  255                 return;
  256         }
  257         printf("cs4231_free: rogue pointer\n");
  258 }
  259 
  260 
  261 /*
  262  * Set up transfer and return DMA address and byte count in paddr and psize
  263  * for bus dependent trigger_{in,out}put to load into the DMA controller.
  264  */
  265 int
  266 cs4231_transfer_init(sc, t, paddr, psize, start, end, blksize, intr, arg)
  267         struct cs4231_softc *sc;
  268         struct cs_transfer *t;
  269         bus_addr_t *paddr;
  270         bus_size_t *psize;
  271         void *start, *end;
  272         int blksize;
  273         void (*intr)(void *);
  274         void *arg;
  275 {
  276         struct cs_dma *p;
  277         vsize_t n;
  278 
  279         if (t->t_active) {
  280                 printf("%s: %s already running\n",
  281                        sc->sc_ad1848.sc_dev.dv_xname, t->t_name);
  282                 return (EINVAL);
  283         }
  284 
  285         t->t_intr = intr;
  286         t->t_arg = arg;
  287 
  288         for (p = sc->sc_dmas; p != NULL && p->addr != start; p = p->next)
  289                 continue;
  290         if (p == NULL) {
  291                 printf("%s: bad %s addr %p\n",
  292                        sc->sc_ad1848.sc_dev.dv_xname, t->t_name, start);
  293                 return (EINVAL);
  294         }
  295 
  296         n = (char *)end - (char *)start;
  297 
  298         t->t_dma = p;           /* the DMA memory segment */
  299         t->t_segsz = n;         /* size of DMA segment */
  300         t->t_blksz = blksize;   /* do transfers in blksize chunks */
  301 
  302         if (n > t->t_blksz)
  303                 n = t->t_blksz;
  304 
  305         t->t_cnt = n;
  306 
  307         /* for caller to load into DMA controller */
  308         *paddr = t->t_dma->dmamap->dm_segs[0].ds_addr;
  309         *psize = n;
  310 
  311         DPRINTF(("%s: init %s: [%p..%p] %lu bytes %lu blocks;"
  312                  " DMA at 0x%lx count %lu\n",
  313                  sc->sc_ad1848.sc_dev.dv_xname, t->t_name,
  314                  start, end, (u_long)t->t_segsz, (u_long)t->t_blksz,
  315                  (u_long)*paddr, (u_long)*psize));
  316 
  317         t->t_active = 1;
  318         return (0);
  319 }
  320 
  321 /*
  322  * Compute next DMA address/counter, update transfer status.
  323  */
  324 void
  325 cs4231_transfer_advance(t, paddr, psize)
  326         struct cs_transfer *t;
  327         bus_addr_t *paddr;
  328         bus_size_t *psize;
  329 {
  330         bus_addr_t dmabase, nextaddr;
  331         bus_size_t togo;
  332 
  333         dmabase = t->t_dma->dmamap->dm_segs[0].ds_addr;
  334 
  335         togo = t->t_segsz - t->t_cnt;
  336         if (togo == 0) {        /* roll over */
  337                 nextaddr = dmabase;
  338                 t->t_cnt = togo = t->t_blksz;
  339         } else {
  340                 nextaddr = dmabase + t->t_cnt;
  341                 if (togo > t->t_blksz)
  342                         togo = t->t_blksz;
  343                 t->t_cnt += togo;
  344         }
  345 
  346         /* for caller to load into DMA controller */
  347         *paddr = nextaddr;
  348         *psize = togo;
  349 }
  350 
  351 
  352 int
  353 cs4231_open(addr, flags)
  354         void *addr;
  355         int flags;
  356 {
  357         struct cs4231_softc *sc = addr;
  358 
  359         DPRINTF(("sa_open: unit %p\n", sc));
  360 
  361         if (sc->sc_open)
  362                 return (EBUSY);
  363 
  364         sc->sc_open = 1;
  365 
  366         sc->sc_playback.t_active = 0;
  367         sc->sc_playback.t_intr = NULL;
  368         sc->sc_playback.t_arg = NULL;
  369 
  370         sc->sc_capture.t_active = 0;
  371         sc->sc_capture.t_intr = NULL;
  372         sc->sc_capture.t_arg = NULL;
  373 
  374         /* no interrupts from ad1848 */
  375         ad_write(&sc->sc_ad1848, SP_PIN_CONTROL, 0);
  376         ad1848_reset(&sc->sc_ad1848);
  377 
  378         DPRINTF(("sa_open: ok -> sc=%p\n", sc));
  379         return (0);
  380 }
  381 
  382 void
  383 cs4231_close(addr)
  384         void *addr;
  385 {
  386         struct cs4231_softc *sc = addr;
  387 
  388         DPRINTF(("sa_close: sc=%p\n", sc));
  389 
  390         /* audio(9) already called halt methods */
  391         sc->sc_open = 0;
  392 
  393         DPRINTF(("sa_close: closed.\n"));
  394 }
  395 
  396 int
  397 cs4231_getdev(addr, retp)
  398         void *addr;
  399         struct audio_device *retp;
  400 {
  401 
  402         *retp = cs4231_device;
  403         return (0);
  404 }
  405 
  406 static ad1848_devmap_t csmapping[] = {
  407         { CSAUDIO_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL },
  408         { CSAUDIO_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL }, 
  409         { CSAUDIO_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL },
  410         { CSAUDIO_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL },
  411         { CSAUDIO_OUTPUT_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL },
  412         { CSAUDIO_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL },
  413         { CSAUDIO_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL },
  414         { CSAUDIO_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL },
  415         { CSAUDIO_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL },
  416         { CSAUDIO_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL },
  417         { CSAUDIO_OUTPUT_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL },
  418         { CSAUDIO_OUT_MUTE, AD1848_KIND_MUTE, AD1848_OUT_CHANNEL },
  419         { CSAUDIO_REC_LVL, AD1848_KIND_RECORDGAIN, -1 },
  420         { CSAUDIO_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 }
  421 };
  422 
  423 static int nummap = sizeof(csmapping) / sizeof(csmapping[0]);
  424 
  425 
  426 int
  427 cs4231_set_port(addr, cp)
  428         void *addr;
  429         mixer_ctrl_t *cp;
  430 {
  431         struct ad1848_softc *ac = addr;
  432 
  433         DPRINTF(("cs4231_set_port: port=%d", cp->dev));
  434         return (ad1848_mixer_set_port(ac, csmapping, nummap, cp));
  435 }
  436 
  437 int
  438 cs4231_get_port(addr, cp)
  439         void *addr;
  440         mixer_ctrl_t *cp;
  441 {
  442         struct ad1848_softc *ac = addr;
  443 
  444         DPRINTF(("cs4231_get_port: port=%d", cp->dev));
  445         return (ad1848_mixer_get_port(ac, csmapping, nummap, cp));
  446 }
  447 
  448 int
  449 cs4231_get_props(addr)
  450         void *addr;
  451 {
  452 
  453         return (AUDIO_PROP_FULLDUPLEX);
  454 }
  455 
  456 int
  457 cs4231_query_devinfo(addr, dip)
  458         void *addr;
  459         mixer_devinfo_t *dip;
  460 {
  461 
  462         switch(dip->index) {
  463 
  464         case CSAUDIO_DAC_LVL:           /*  dacout */
  465                 dip->type = AUDIO_MIXER_VALUE;
  466                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  467                 dip->prev = AUDIO_MIXER_LAST;
  468                 dip->next = CSAUDIO_DAC_MUTE;
  469                 strcpy(dip->label.name, AudioNdac);
  470                 dip->un.v.num_channels = 2;
  471                 strcpy(dip->un.v.units.name, AudioNvolume);
  472                 break;
  473 
  474         case CSAUDIO_LINE_IN_LVL:       /* line */
  475                 dip->type = AUDIO_MIXER_VALUE;
  476                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  477                 dip->prev = AUDIO_MIXER_LAST;
  478                 dip->next = CSAUDIO_LINE_IN_MUTE;
  479                 strcpy(dip->label.name, AudioNline);
  480                 dip->un.v.num_channels = 2;
  481                 strcpy(dip->un.v.units.name, AudioNvolume);
  482                 break;
  483 
  484         case CSAUDIO_MONO_LVL:  /* mono/microphone mixer */
  485                 dip->type = AUDIO_MIXER_VALUE;
  486                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  487                 dip->prev = AUDIO_MIXER_LAST;
  488                 dip->next = CSAUDIO_MONO_MUTE;
  489                 strcpy(dip->label.name, AudioNmicrophone);
  490                 dip->un.v.num_channels = 1;
  491                 strcpy(dip->un.v.units.name, AudioNvolume);
  492                 break;
  493 
  494         case CSAUDIO_CD_LVL:            /* cd */
  495                 dip->type = AUDIO_MIXER_VALUE;
  496                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  497                 dip->prev = AUDIO_MIXER_LAST;
  498                 dip->next = CSAUDIO_CD_MUTE;
  499                 strcpy(dip->label.name, AudioNcd);
  500                 dip->un.v.num_channels = 2;
  501                 strcpy(dip->un.v.units.name, AudioNvolume);
  502                 break;
  503 
  504 
  505         case CSAUDIO_OUTPUT_LVL:        /* monitor level */
  506                 dip->type = AUDIO_MIXER_VALUE;
  507                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  508                 dip->next = CSAUDIO_OUTPUT_MUTE;
  509                 dip->prev = AUDIO_MIXER_LAST;
  510                 strcpy(dip->label.name, AudioNmonitor);
  511                 dip->un.v.num_channels = 1;
  512                 strcpy(dip->un.v.units.name, AudioNvolume);
  513                 break;
  514 
  515         case CSAUDIO_OUT_LVL:           /* cs4231 output volume */
  516                 dip->type = AUDIO_MIXER_VALUE;
  517                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  518                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  519                 strcpy(dip->label.name, AudioNmaster);
  520                 dip->un.v.num_channels = 2;
  521                 strcpy(dip->un.v.units.name, AudioNvolume);
  522                 break;
  523 
  524         case CSAUDIO_OUT_MUTE: /* mute built-in speaker */
  525                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  526                 dip->type = AUDIO_MIXER_ENUM;
  527                 dip->prev = CSAUDIO_MONITOR_CLASS;
  528                 dip->next = AUDIO_MIXER_LAST;
  529                 strcpy(dip->label.name, AudioNmono);
  530                 /* names reversed, this is a "mute" value used as "mono enabled" */
  531                 dip->un.e.num_mem = 2;
  532                 strcpy(dip->un.e.member[0].label.name, AudioNon);
  533                 dip->un.e.member[0].ord = 0;
  534                 strcpy(dip->un.e.member[1].label.name, AudioNoff);
  535                 dip->un.e.member[1].ord = 1;
  536                 break;
  537 
  538         case CSAUDIO_LINE_IN_MUTE:
  539                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  540                 dip->type = AUDIO_MIXER_ENUM;
  541                 dip->prev = CSAUDIO_LINE_IN_LVL;
  542                 dip->next = AUDIO_MIXER_LAST;
  543                 goto mute;
  544                 
  545         case CSAUDIO_DAC_MUTE:
  546                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  547                 dip->type = AUDIO_MIXER_ENUM;
  548                 dip->prev = CSAUDIO_DAC_LVL;
  549                 dip->next = AUDIO_MIXER_LAST;
  550                 goto mute;
  551 
  552         case CSAUDIO_CD_MUTE:
  553                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  554                 dip->type = AUDIO_MIXER_ENUM;
  555                 dip->prev = CSAUDIO_CD_LVL;
  556                 dip->next = AUDIO_MIXER_LAST;
  557                 goto mute;
  558                 
  559         case CSAUDIO_MONO_MUTE:
  560                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  561                 dip->type = AUDIO_MIXER_ENUM;
  562                 dip->prev = CSAUDIO_MONO_LVL;
  563                 dip->next = AUDIO_MIXER_LAST;
  564                 goto mute;
  565 
  566         case CSAUDIO_OUTPUT_MUTE:
  567                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  568                 dip->type = AUDIO_MIXER_ENUM;
  569                 dip->prev = CSAUDIO_OUTPUT_LVL;
  570                 dip->next = AUDIO_MIXER_LAST;
  571         mute:
  572                 strcpy(dip->label.name, AudioNmute);
  573                 dip->un.e.num_mem = 2;
  574                 strcpy(dip->un.e.member[0].label.name, AudioNoff);
  575                 dip->un.e.member[0].ord = 0;
  576                 strcpy(dip->un.e.member[1].label.name, AudioNon);
  577                 dip->un.e.member[1].ord = 1;
  578                 break;
  579                 
  580         case CSAUDIO_REC_LVL:   /* record level */
  581                 dip->type = AUDIO_MIXER_VALUE;
  582                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  583                 dip->prev = AUDIO_MIXER_LAST;
  584                 dip->next = CSAUDIO_RECORD_SOURCE;
  585                 strcpy(dip->label.name, AudioNrecord);
  586                 dip->un.v.num_channels = 2;
  587                 strcpy(dip->un.v.units.name, AudioNvolume);
  588                 break;
  589 
  590         case CSAUDIO_RECORD_SOURCE:
  591                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  592                 dip->type = AUDIO_MIXER_ENUM;
  593                 dip->prev = CSAUDIO_REC_LVL;
  594                 dip->next = AUDIO_MIXER_LAST;
  595                 strcpy(dip->label.name, AudioNsource);
  596                 dip->un.e.num_mem = 4;
  597                 strcpy(dip->un.e.member[0].label.name, AudioNoutput);
  598                 dip->un.e.member[0].ord = DAC_IN_PORT;
  599                 strcpy(dip->un.e.member[1].label.name, AudioNmicrophone);
  600                 dip->un.e.member[1].ord = MIC_IN_PORT;
  601                 strcpy(dip->un.e.member[2].label.name, AudioNdac);
  602                 dip->un.e.member[2].ord = AUX1_IN_PORT;
  603                 strcpy(dip->un.e.member[3].label.name, AudioNline);
  604                 dip->un.e.member[3].ord = LINE_IN_PORT;
  605                 break;
  606 
  607         case CSAUDIO_INPUT_CLASS:               /* input class descriptor */
  608                 dip->type = AUDIO_MIXER_CLASS;
  609                 dip->mixer_class = CSAUDIO_INPUT_CLASS;
  610                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  611                 strcpy(dip->label.name, AudioCinputs);
  612                 break;
  613 
  614         case CSAUDIO_MONITOR_CLASS:             /* output class descriptor */
  615                 dip->type = AUDIO_MIXER_CLASS;
  616                 dip->mixer_class = CSAUDIO_MONITOR_CLASS;
  617                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  618                 strcpy(dip->label.name, AudioCmonitor);
  619                 break;
  620 
  621         case CSAUDIO_RECORD_CLASS:              /* record source class */
  622                 dip->type = AUDIO_MIXER_CLASS;
  623                 dip->mixer_class = CSAUDIO_RECORD_CLASS;
  624                 dip->next = dip->prev = AUDIO_MIXER_LAST;
  625                 strcpy(dip->label.name, AudioCrecord);
  626                 break;
  627 
  628         default:
  629                 return ENXIO;
  630                 /*NOTREACHED*/
  631         }
  632         DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
  633 
  634         return (0);
  635 }
  636 
  637 #endif /* NAUDIO > 0 */
Cache object: d56f18400e0e1263f673412ae427c311
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/dev/ic/cs4231.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/cs4231.c
