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