1 /* $NetBSD: cs4231.c,v 1.18 2005/12/11 12:21:26 christos 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.18 2005/12/11 12:21:26 christos 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 */ 612