sys/dev/ic/cs4231.c

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