FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/cs4231.c
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
|