![[BACK]](/icons/back.gif){kind=icon}
Return to audio.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev|
Return to audio.c CVS log | Up to [local] / sys / dev |
1.1 nbrk 1: /* $OpenBSD: audio.c,v 1.72 2007/08/08 05:51:23 jakemsr Exp $ */
2: /* $NetBSD: audio.c,v 1.119 1999/11/09 16:50:47 augustss Exp $ */
3:
4: /*
5: * Copyright (c) 1991-1993 Regents of the University of California.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the Computer Systems
19: * Engineering Group at Lawrence Berkeley Laboratory.
20: * 4. Neither the name of the University nor of the Laboratory may be used
21: * to endorse or promote products derived from this software without
22: * specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: */
36:
37: /*
38: * This is a (partially) SunOS-compatible /dev/audio driver for NetBSD.
39: *
40: * This code tries to do something half-way sensible with
41: * half-duplex hardware, such as with the SoundBlaster hardware. With
42: * half-duplex hardware allowing O_RDWR access doesn't really make
43: * sense. However, closing and opening the device to "turn around the
44: * line" is relatively expensive and costs a card reset (which can
45: * take some time, at least for the SoundBlaster hardware). Instead
46: * we allow O_RDWR access, and provide an ioctl to set the "mode",
47: * i.e. playing or recording.
48: *
49: * If you write to a half-duplex device in record mode, the data is
50: * tossed. If you read from the device in play mode, you get silence
51: * filled buffers at the rate at which samples are naturally
52: * generated.
53: *
54: * If you try to set both play and record mode on a half-duplex
55: * device, playing takes precedence.
56: */
57:
58: /*
59: * Todo:
60: * - Add softaudio() isr processing for wakeup, poll, signals,
61: * and silence fill.
62: */
63:
64: #include "audio.h"
65: #if NAUDIO > 0
66:
67: #include <sys/param.h>
68: #include <sys/ioctl.h>
69: #include <sys/fcntl.h>
70: #include <sys/vnode.h>
71: #include <sys/selinfo.h>
72: #include <sys/poll.h>
73: #include <sys/malloc.h>
74: #include <sys/proc.h>
75: #include <sys/systm.h>
76: #include <sys/syslog.h>
77: #include <sys/kernel.h>
78: #include <sys/signalvar.h>
79: #include <sys/conf.h>
80: #include <sys/audioio.h>
81: #include <sys/device.h>
82:
83: #include <dev/audio_if.h>
84: #include <dev/audiovar.h>
85:
86: #include <dev/rndvar.h>
87:
88: #include <machine/endian.h>
89:
90: #include "wskbd.h" /* NWSKBD (mixer tuning using keyboard) */
91:
92: #ifdef AUDIO_DEBUG
93: #define DPRINTF(x) if (audiodebug) printf x
94: #define DPRINTFN(n,x) if (audiodebug>(n)) printf x
95: int audiodebug = 0;
96: #else
97: #define DPRINTF(x)
98: #define DPRINTFN(n,x)
99: #endif
100:
101: #define ROUNDSIZE(x) x &= -16 /* round to nice boundary */
102:
103: int audio_blk_ms = AUDIO_BLK_MS;
104:
105: int audiosetinfo(struct audio_softc *, struct audio_info *);
106: int audiogetinfo(struct audio_softc *, struct audio_info *);
107:
108: int audio_open(dev_t, struct audio_softc *, int, int, struct proc *);
109: int audio_close(dev_t, int, int, struct proc *);
110: int audio_read(dev_t, struct uio *, int);
111: int audio_write(dev_t, struct uio *, int);
112: int audio_ioctl(dev_t, u_long, caddr_t, int, struct proc *);
113: int audio_poll(dev_t, int, struct proc *);
114: paddr_t audio_mmap(dev_t, off_t, int);
115:
116: int mixer_open(dev_t, struct audio_softc *, int, int, struct proc *);
117: int mixer_close(dev_t, int, int, struct proc *);
118: int mixer_ioctl(dev_t, u_long, caddr_t, int, struct proc *);
119: static void mixer_remove(struct audio_softc *, struct proc *p);
120: static void mixer_signal(struct audio_softc *);
121:
122: void audio_init_record(struct audio_softc *);
123: void audio_init_play(struct audio_softc *);
124: int audiostartr(struct audio_softc *);
125: int audiostartp(struct audio_softc *);
126: void audio_rint(void *);
127: void audio_pint(void *);
128: int audio_check_params(struct audio_params *);
129:
130: void audio_calc_blksize(struct audio_softc *, int);
131: void audio_fill_silence(struct audio_params *, u_char *, int);
132: int audio_silence_copyout(struct audio_softc *, int, struct uio *);
133:
134: void audio_init_ringbuffer(struct audio_ringbuffer *);
135: int audio_initbufs(struct audio_softc *);
136: void audio_calcwater(struct audio_softc *);
137: static __inline int audio_sleep_timo(int *, char *, int);
138: static __inline int audio_sleep(int *, char *);
139: static __inline void audio_wakeup(int *);
140: void audio_selwakeup(struct audio_softc *sc, int play);
141: int audio_drain(struct audio_softc *);
142: void audio_clear(struct audio_softc *);
143: static __inline void audio_pint_silence(struct audio_softc *, struct audio_ringbuffer *, u_char *, int);
144:
145: int audio_alloc_ring(struct audio_softc *, struct audio_ringbuffer *, int, int);
146: void audio_free_ring(struct audio_softc *, struct audio_ringbuffer *);
147:
148: int audioprint(void *, const char *);
149:
150: int audioprobe(struct device *, void *, void *);
151: void audioattach(struct device *, struct device *, void *);
152: int audiodetach(struct device *, int);
153: int audioactivate(struct device *, enum devact);
154:
155: struct portname {
156: char *name;
157: int mask;
158: };
159: static struct portname itable[] = {
160: { AudioNmicrophone, AUDIO_MICROPHONE },
161: { AudioNline, AUDIO_LINE_IN },
162: { AudioNcd, AUDIO_CD },
163: { 0 }
164: };
165: static struct portname otable[] = {
166: { AudioNspeaker, AUDIO_SPEAKER },
167: { AudioNheadphone, AUDIO_HEADPHONE },
168: { AudioNline, AUDIO_LINE_OUT },
169: { 0 }
170: };
171: void au_check_ports(struct audio_softc *, struct au_mixer_ports *,
172: mixer_devinfo_t *, int, char *, char *,
173: struct portname *);
174: int au_set_gain(struct audio_softc *, struct au_mixer_ports *,
175: int, int);
176: void au_get_gain(struct audio_softc *, struct au_mixer_ports *,
177: u_int *, u_char *);
178: int au_set_port(struct audio_softc *, struct au_mixer_ports *,
179: u_int);
180: int au_get_port(struct audio_softc *, struct au_mixer_ports *);
181: int au_get_lr_value(struct audio_softc *, mixer_ctrl_t *,
182: int *, int *r);
183: int au_set_lr_value(struct audio_softc *, mixer_ctrl_t *,
184: int, int);
185: int au_portof(struct audio_softc *, char *);
186:
187:
188: /* The default audio mode: 8 kHz mono ulaw */
189: struct audio_params audio_default =
190: { 8000, AUDIO_ENCODING_ULAW, 8, 1, 0, 1 };
191:
192: struct cfattach audio_ca = {
193: sizeof(struct audio_softc), audioprobe, audioattach,
194: audiodetach, audioactivate
195: };
196:
197: struct cfdriver audio_cd = {
198: NULL, "audio", DV_DULL
199: };
200:
201: void filt_audiowdetach(struct knote *);
202: int filt_audiowrite(struct knote *, long);
203:
204: struct filterops audiowrite_filtops =
205: { 1, NULL, filt_audiowdetach, filt_audiowrite};
206:
207: void filt_audiordetach(struct knote *);
208: int filt_audioread(struct knote *, long);
209:
210: struct filterops audioread_filtops =
211: { 1, NULL, filt_audiordetach, filt_audioread};
212:
213: #if NWSKBD > 0
214: /* Mixer manipulation using keyboard */
215: int wskbd_get_mixerdev(struct audio_softc *, int, int *);
216: int wskbd_set_mixervolume(long);
217: #endif
218:
219: int
220: audioprobe(struct device *parent, void *match, void *aux)
221: {
222: struct audio_attach_args *sa = aux;
223:
224: DPRINTF(("audioprobe: type=%d sa=%p hw=%p\n",
225: sa->type, sa, sa->hwif));
226: return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0;
227: }
228:
229: void
230: audioattach(struct device *parent, struct device *self, void *aux)
231: {
232: struct audio_softc *sc = (void *)self;
233: struct audio_attach_args *sa = aux;
234: struct audio_hw_if *hwp = sa->hwif;
235: void *hdlp = sa->hdl;
236: int error;
237: mixer_devinfo_t mi;
238: int iclass, oclass, mclass;
239:
240: printf("\n");
241:
242: #ifdef DIAGNOSTIC
243: if (hwp == 0 ||
244: hwp->open == 0 ||
245: hwp->close == 0 ||
246: hwp->query_encoding == 0 ||
247: hwp->set_params == 0 ||
248: (hwp->start_output == 0 && hwp->trigger_output == 0) ||
249: (hwp->start_input == 0 && hwp->trigger_input == 0) ||
250: hwp->halt_output == 0 ||
251: hwp->halt_input == 0 ||
252: hwp->getdev == 0 ||
253: hwp->set_port == 0 ||
254: hwp->get_port == 0 ||
255: hwp->query_devinfo == 0 ||
256: hwp->get_props == 0) {
257: printf("audio: missing method\n");
258: sc->hw_if = 0;
259: return;
260: }
261: #endif
262:
263: sc->hw_if = hwp;
264: sc->hw_hdl = hdlp;
265: sc->sc_dev = parent;
266:
267: error = audio_alloc_ring(sc, &sc->sc_pr, AUMODE_PLAY, AU_RING_SIZE);
268: if (error) {
269: sc->hw_if = 0;
270: printf("audio: could not allocate play buffer\n");
271: return;
272: }
273: error = audio_alloc_ring(sc, &sc->sc_rr, AUMODE_RECORD, AU_RING_SIZE);
274: if (error) {
275: audio_free_ring(sc, &sc->sc_pr);
276: sc->hw_if = 0;
277: printf("audio: could not allocate record buffer\n");
278: return;
279: }
280:
281: /*
282: * Set default softc params
283: */
284: sc->sc_pparams = audio_default;
285: sc->sc_rparams = audio_default;
286:
287: /* Set up some default values */
288: sc->sc_blkset = 0;
289: audio_calc_blksize(sc, AUMODE_RECORD);
290: audio_calc_blksize(sc, AUMODE_PLAY);
291: audio_init_ringbuffer(&sc->sc_rr);
292: audio_init_ringbuffer(&sc->sc_pr);
293: audio_calcwater(sc);
294:
295: iclass = oclass = mclass = -1;
296: sc->sc_inports.index = -1;
297: sc->sc_inports.nports = 0;
298: sc->sc_inports.isenum = 0;
299: sc->sc_inports.allports = 0;
300: sc->sc_outports.index = -1;
301: sc->sc_outports.nports = 0;
302: sc->sc_outports.isenum = 0;
303: sc->sc_outports.allports = 0;
304: sc->sc_monitor_port = -1;
305: for(mi.index = 0; ; mi.index++) {
306: if (hwp->query_devinfo(hdlp, &mi) != 0)
307: break;
308: if (mi.type == AUDIO_MIXER_CLASS &&
309: strcmp(mi.label.name, AudioCrecord) == 0)
310: iclass = mi.index;
311: if (mi.type == AUDIO_MIXER_CLASS &&
312: strcmp(mi.label.name, AudioCmonitor) == 0)
313: mclass = mi.index;
314: if (mi.type == AUDIO_MIXER_CLASS &&
315: strcmp(mi.label.name, AudioCoutputs) == 0)
316: oclass = mi.index;
317: }
318: for(mi.index = 0; ; mi.index++) {
319: if (hwp->query_devinfo(hdlp, &mi) != 0)
320: break;
321: if (mi.type == AUDIO_MIXER_CLASS)
322: continue;
323: au_check_ports(sc, &sc->sc_inports, &mi, iclass,
324: AudioNsource, AudioNrecord, itable);
325: au_check_ports(sc, &sc->sc_outports, &mi, oclass,
326: AudioNoutput, AudioNmaster, otable);
327: if (mi.mixer_class == mclass &&
328: (strcmp(mi.label.name, AudioNmonitor) == 0))
329: sc->sc_monitor_port = mi.index;
330: if ((sc->sc_monitor_port == -1) && (mi.mixer_class == oclass) &&
331: (strcmp(mi.label.name, AudioNmonitor) == 0))
332: sc->sc_monitor_port = mi.index;
333: }
334: DPRINTF(("audio_attach: inputs ports=0x%x, output ports=0x%x\n",
335: sc->sc_inports.allports, sc->sc_outports.allports));
336: }
337:
338: int
339: audioactivate(struct device *self, enum devact act)
340: {
341: struct audio_softc *sc = (struct audio_softc *)self;
342:
343: switch (act) {
344: case DVACT_ACTIVATE:
345: break;
346:
347: case DVACT_DEACTIVATE:
348: sc->sc_dying = 1;
349: break;
350: }
351: return (0);
352: }
353:
354: int
355: audiodetach(struct device *self, int flags)
356: {
357: struct audio_softc *sc = (struct audio_softc *)self;
358: int maj, mn;
359: int s;
360:
361: DPRINTF(("audio_detach: sc=%p flags=%d\n", sc, flags));
362:
363: sc->sc_dying = 1;
364:
365: wakeup(&sc->sc_wchan);
366: wakeup(&sc->sc_rchan);
367: s = splaudio();
368: if (--sc->sc_refcnt >= 0) {
369: if (tsleep(&sc->sc_refcnt, PZERO, "auddet", hz * 120))
370: printf("audiodetach: %s didn't detach\n",
371: sc->dev.dv_xname);
372: }
373: splx(s);
374:
375: /* free resources */
376: audio_free_ring(sc, &sc->sc_pr);
377: audio_free_ring(sc, &sc->sc_rr);
378:
379: /* locate the major number */
380: for (maj = 0; maj < nchrdev; maj++)
381: if (cdevsw[maj].d_open == audioopen)
382: break;
383:
384: /* Nuke the vnodes for any open instances (calls close). */
385: mn = self->dv_unit;
386: vdevgone(maj, mn | SOUND_DEVICE, mn | SOUND_DEVICE, VCHR);
387: vdevgone(maj, mn | AUDIO_DEVICE, mn | AUDIO_DEVICE, VCHR);
388: vdevgone(maj, mn | AUDIOCTL_DEVICE, mn | AUDIOCTL_DEVICE, VCHR);
389: vdevgone(maj, mn | MIXER_DEVICE, mn | MIXER_DEVICE, VCHR);
390:
391: return (0);
392: }
393:
394: int
395: au_portof(struct audio_softc *sc, char *name)
396: {
397: mixer_devinfo_t mi;
398:
399: for(mi.index = 0;
400: sc->hw_if->query_devinfo(sc->hw_hdl, &mi) == 0;
401: mi.index++)
402: if (strcmp(mi.label.name, name) == 0)
403: return mi.index;
404: return -1;
405: }
406:
407: void
408: au_check_ports(struct audio_softc *sc, struct au_mixer_ports *ports,
409: mixer_devinfo_t *mi, int cls, char *name, char *mname, struct portname *tbl)
410: {
411: int i, j;
412:
413: if (mi->mixer_class != cls)
414: return;
415: if (strcmp(mi->label.name, mname) == 0) {
416: ports->master = mi->index;
417: return;
418: }
419: if (strcmp(mi->label.name, name) != 0)
420: return;
421: if (mi->type == AUDIO_MIXER_ENUM) {
422: ports->index = mi->index;
423: for(i = 0; tbl[i].name; i++) {
424: for(j = 0; j < mi->un.e.num_mem; j++) {
425: if (strcmp(mi->un.e.member[j].label.name,
426: tbl[i].name) == 0) {
427: ports->aumask[ports->nports] = tbl[i].mask;
428: ports->misel [ports->nports] = mi->un.e.member[j].ord;
429: ports->miport[ports->nports++] =
430: au_portof(sc, mi->un.e.member[j].label.name);
431: ports->allports |= tbl[i].mask;
432: }
433: }
434: }
435: ports->isenum = 1;
436: } else if (mi->type == AUDIO_MIXER_SET) {
437: ports->index = mi->index;
438: for(i = 0; tbl[i].name; i++) {
439: for(j = 0; j < mi->un.s.num_mem; j++) {
440: if (strcmp(mi->un.s.member[j].label.name,
441: tbl[i].name) == 0) {
442: ports->aumask[ports->nports] = tbl[i].mask;
443: ports->misel [ports->nports] = mi->un.s.member[j].mask;
444: ports->miport[ports->nports++] =
445: au_portof(sc, mi->un.s.member[j].label.name);
446: ports->allports |= tbl[i].mask;
447: }
448: }
449: }
450: }
451: }
452:
453: /*
454: * Called from hardware driver. This is where the MI audio driver gets
455: * probed/attached to the hardware driver.
456: */
457: struct device *
458: audio_attach_mi(struct audio_hw_if *ahwp, void *hdlp, struct device *dev)
459: {
460: struct audio_attach_args arg;
461:
462: #ifdef DIAGNOSTIC
463: if (ahwp == NULL) {
464: printf ("audio_attach_mi: NULL\n");
465: return 0;
466: }
467: #endif
468:
469: arg.type = AUDIODEV_TYPE_AUDIO;
470: arg.hwif = ahwp;
471: arg.hdl = hdlp;
472: return config_found(dev, &arg, audioprint);
473: }
474:
475: #if NAUDIO > 0
476: int
477: audioprint(void *aux, const char *pnp)
478: {
479: struct audio_attach_args *arg = aux;
480: const char *type;
481:
482: if (pnp != NULL) {
483: switch (arg->type) {
484: case AUDIODEV_TYPE_AUDIO:
485: type = "audio";
486: break;
487: case AUDIODEV_TYPE_OPL:
488: type = "opl";
489: break;
490: case AUDIODEV_TYPE_MPU:
491: type = "mpu";
492: break;
493: default:
494: panic("audioprint: unknown type %d", arg->type);
495: }
496: printf("%s at %s", type, pnp);
497: }
498: return (UNCONF);
499: }
500:
501: #endif /* NAUDIO > 0 */
502:
503: #ifdef AUDIO_DEBUG
504: void audio_printsc(struct audio_softc *);
505: void audio_print_params(char *, struct audio_params *);
506:
507: void
508: audio_printsc(struct audio_softc *sc)
509: {
510: printf("hwhandle %p hw_if %p ", sc->hw_hdl, sc->hw_if);
511: printf("open 0x%x mode 0x%x\n", sc->sc_open, sc->sc_mode);
512: printf("rchan 0x%x wchan 0x%x ", sc->sc_rchan, sc->sc_wchan);
513: printf("rring used 0x%x pring used=%d\n", sc->sc_rr.used, sc->sc_pr.used);
514: printf("rbus 0x%x pbus 0x%x ", sc->sc_rbus, sc->sc_pbus);
515: printf("blksize %d", sc->sc_pr.blksize);
516: printf("hiwat %d lowat %d\n", sc->sc_pr.usedhigh, sc->sc_pr.usedlow);
517: }
518:
519: void
520: audio_print_params(char *s, struct audio_params *p)
521: {
522: printf("audio: %s sr=%ld, enc=%d, chan=%d, prec=%d\n", s,
523: p->sample_rate, p->encoding, p->channels, p->precision);
524: }
525: #endif
526:
527: int
528: audio_alloc_ring(struct audio_softc *sc, struct audio_ringbuffer *r,
529: int direction, int bufsize)
530: {
531: struct audio_hw_if *hw = sc->hw_if;
532: void *hdl = sc->hw_hdl;
533: /*
534: * Alloc DMA play and record buffers
535: */
536: if (bufsize < AUMINBUF)
537: bufsize = AUMINBUF;
538: ROUNDSIZE(bufsize);
539: if (hw->round_buffersize)
540: bufsize = hw->round_buffersize(hdl, direction, bufsize);
541: r->bufsize = bufsize;
542: if (hw->allocm)
543: r->start = hw->allocm(hdl, direction, r->bufsize, M_DEVBUF,
544: M_WAITOK);
545: else
546: r->start = malloc(bufsize, M_DEVBUF, M_WAITOK);
547: if (r->start == 0)
548: return ENOMEM;
549: return 0;
550: }
551:
552: void
553: audio_free_ring(struct audio_softc *sc, struct audio_ringbuffer *r)
554: {
555: if (sc->hw_if->freem) {
556: sc->hw_if->freem(sc->hw_hdl, r->start, M_DEVBUF);
557: } else {
558: free(r->start, M_DEVBUF);
559: }
560: }
561:
562: int
563: audioopen(dev_t dev, int flags, int ifmt, struct proc *p)
564: {
565: int unit = AUDIOUNIT(dev);
566: struct audio_softc *sc;
567: int error;
568:
569: if (unit >= audio_cd.cd_ndevs ||
570: (sc = audio_cd.cd_devs[unit]) == NULL)
571: return ENXIO;
572:
573: if (sc->sc_dying)
574: return (EIO);
575:
576: if (!sc->hw_if)
577: return (ENXIO);
578:
579: sc->sc_refcnt ++;
580: switch (AUDIODEV(dev)) {
581: case SOUND_DEVICE:
582: case AUDIO_DEVICE:
583: case AUDIOCTL_DEVICE:
584: error = audio_open(dev, sc, flags, ifmt, p);
585: break;
586: case MIXER_DEVICE:
587: error = mixer_open(dev, sc, flags, ifmt, p);
588: break;
589: default:
590: error = ENXIO;
591: break;
592: }
593:
594: if (--sc->sc_refcnt < 0)
595: wakeup(&sc->sc_refcnt);
596:
597: return (error);
598: }
599:
600: int
601: audioclose(dev_t dev, int flags, int ifmt, struct proc *p)
602: {
603:
604: switch (AUDIODEV(dev)) {
605: case SOUND_DEVICE:
606: case AUDIO_DEVICE:
607: return (audio_close(dev, flags, ifmt, p));
608: case MIXER_DEVICE:
609: return (mixer_close(dev, flags, ifmt, p));
610: case AUDIOCTL_DEVICE:
611: return 0;
612: default:
613: return (ENXIO);
614: }
615: }
616:
617: int
618: audioread(dev_t dev, struct uio *uio, int ioflag)
619: {
620: int unit = AUDIOUNIT(dev);
621: struct audio_softc *sc;
622: int error;
623:
624: if (unit >= audio_cd.cd_ndevs ||
625: (sc = audio_cd.cd_devs[unit]) == NULL)
626: return ENXIO;
627:
628: if (sc->sc_dying)
629: return (EIO);
630:
631: sc->sc_refcnt ++;
632: switch (AUDIODEV(dev)) {
633: case SOUND_DEVICE:
634: case AUDIO_DEVICE:
635: error = audio_read(dev, uio, ioflag);
636: break;
637: case AUDIOCTL_DEVICE:
638: case MIXER_DEVICE:
639: error = ENODEV;
640: break;
641: default:
642: error = ENXIO;
643: break;
644: }
645:
646: if (--sc->sc_refcnt < 0)
647: wakeup(&sc->sc_refcnt);
648: return (error);
649: }
650:
651: int
652: audiowrite(dev_t dev, struct uio *uio, int ioflag)
653: {
654: int unit = AUDIOUNIT(dev);
655: struct audio_softc *sc;
656: int error;
657:
658: if (unit >= audio_cd.cd_ndevs ||
659: (sc = audio_cd.cd_devs[unit]) == NULL)
660: return ENXIO;
661:
662: if (sc->sc_dying)
663: return (EIO);
664:
665: sc->sc_refcnt ++;
666: switch (AUDIODEV(dev)) {
667: case SOUND_DEVICE:
668: case AUDIO_DEVICE:
669: error = audio_write(dev, uio, ioflag);
670: break;
671: case AUDIOCTL_DEVICE:
672: case MIXER_DEVICE:
673: error = ENODEV;
674: break;
675: default:
676: error = ENXIO;
677: break;
678: }
679:
680: if (--sc->sc_refcnt < 0)
681: wakeup(&sc->sc_refcnt);
682: return (error);
683: }
684:
685: int
686: audioioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
687: {
688: int unit = AUDIOUNIT(dev);
689: struct audio_softc *sc;
690: int error;
691:
692: if (unit >= audio_cd.cd_ndevs ||
693: (sc = audio_cd.cd_devs[unit]) == NULL)
694: return ENXIO;
695:
696: if (sc->sc_dying)
697: return (EIO);
698:
699: sc->sc_refcnt ++;
700: switch (AUDIODEV(dev)) {
701: case SOUND_DEVICE:
702: case AUDIO_DEVICE:
703: case AUDIOCTL_DEVICE:
704: error = audio_ioctl(dev, cmd, addr, flag, p);
705: break;
706: case MIXER_DEVICE:
707: error = mixer_ioctl(dev, cmd, addr, flag, p);
708: break;
709: default:
710: error = ENXIO;
711: break;
712: }
713:
714: if (--sc->sc_refcnt < 0)
715: wakeup(&sc->sc_refcnt);
716: return (error);
717: }
718:
719: int
720: audiopoll(dev_t dev, int events, struct proc *p)
721: {
722: int unit = AUDIOUNIT(dev);
723: struct audio_softc *sc;
724: int error;
725:
726: if (unit >= audio_cd.cd_ndevs ||
727: (sc = audio_cd.cd_devs[unit]) == NULL)
728: return POLLERR;
729:
730: if (sc->sc_dying)
731: return POLLERR;
732:
733: sc->sc_refcnt ++;
734: switch (AUDIODEV(dev)) {
735: case SOUND_DEVICE:
736: case AUDIO_DEVICE:
737: error = audio_poll(dev, events, p);
738: break;
739: case AUDIOCTL_DEVICE:
740: case MIXER_DEVICE:
741: error = 0;
742: break;
743: default:
744: error = 0;
745: break;
746: }
747:
748: if (--sc->sc_refcnt < 0)
749: wakeup(&sc->sc_refcnt);
750: return (error);
751: }
752:
753: paddr_t
754: audiommap(dev_t dev, off_t off, int prot)
755: {
756: int unit = AUDIOUNIT(dev);
757: struct audio_softc *sc;
758: int ret;
759:
760: if (unit >= audio_cd.cd_ndevs ||
761: (sc = audio_cd.cd_devs[unit]) == NULL)
762: return (-1);
763:
764: if (sc->sc_dying)
765: return (-1);
766:
767: sc->sc_refcnt ++;
768: switch (AUDIODEV(dev)) {
769: case SOUND_DEVICE:
770: case AUDIO_DEVICE:
771: ret = audio_mmap(dev, off, prot);
772: break;
773: case AUDIOCTL_DEVICE:
774: case MIXER_DEVICE:
775: ret = -1;
776: break;
777: default:
778: ret = -1;
779: break;
780: }
781:
782: if (--sc->sc_refcnt < 0)
783: wakeup(&sc->sc_refcnt);
784: return (ret);
785: }
786:
787: /*
788: * Audio driver
789: */
790: void
791: audio_init_ringbuffer(struct audio_ringbuffer *rp)
792: {
793: int nblks;
794: int blksize = rp->blksize;
795:
796: if (blksize < AUMINBLK)
797: blksize = AUMINBLK;
798: nblks = rp->bufsize / blksize;
799: if (nblks < AUMINNOBLK) {
800: nblks = AUMINNOBLK;
801: blksize = rp->bufsize / nblks;
802: ROUNDSIZE(blksize);
803: }
804: DPRINTF(("audio_init_ringbuffer: blksize=%d\n", blksize));
805: rp->blksize = blksize;
806: rp->maxblks = nblks;
807: rp->used = 0;
808: rp->end = rp->start + nblks * blksize;
809: rp->inp = rp->outp = rp->start;
810: rp->stamp = 0;
811: rp->stamp_last = 0;
812: rp->drops = 0;
813: rp->pdrops = 0;
814: rp->copying = 0;
815: rp->needfill = 0;
816: rp->mmapped = 0;
817: }
818:
819: int
820: audio_initbufs(struct audio_softc *sc)
821: {
822: struct audio_hw_if *hw = sc->hw_if;
823: int error;
824:
825: DPRINTF(("audio_initbufs: mode=0x%x\n", sc->sc_mode));
826: audio_init_ringbuffer(&sc->sc_rr);
827: if (hw->init_input && (sc->sc_mode & AUMODE_RECORD)) {
828: error = hw->init_input(sc->hw_hdl, sc->sc_rr.start,
829: sc->sc_rr.end - sc->sc_rr.start);
830: if (error)
831: return error;
832: }
833:
834: audio_init_ringbuffer(&sc->sc_pr);
835: sc->sc_sil_count = 0;
836: if (hw->init_output && (sc->sc_mode & AUMODE_PLAY)) {
837: error = hw->init_output(sc->hw_hdl, sc->sc_pr.start,
838: sc->sc_pr.end - sc->sc_pr.start);
839: if (error)
840: return error;
841: }
842:
843: #ifdef AUDIO_INTR_TIME
844: sc->sc_pnintr = 0;
845: sc->sc_pblktime = (u_long)(
846: (u_long)sc->sc_pr.blksize * 100000 /
847: (u_long)(sc->sc_pparams.precision / NBBY *
848: sc->sc_pparams.channels *
849: sc->sc_pparams.sample_rate)) * 10;
850: DPRINTF(("audio: play blktime = %lu for %d\n",
851: sc->sc_pblktime, sc->sc_pr.blksize));
852: sc->sc_rnintr = 0;
853: sc->sc_rblktime = (u_long)(
854: (u_long)sc->sc_rr.blksize * 100000 /
855: (u_long)(sc->sc_rparams.precision / NBBY *
856: sc->sc_rparams.channels *
857: sc->sc_rparams.sample_rate)) * 10;
858: DPRINTF(("audio: record blktime = %lu for %d\n",
859: sc->sc_rblktime, sc->sc_rr.blksize));
860: #endif
861:
862: return 0;
863: }
864:
865: void
866: audio_calcwater(struct audio_softc *sc)
867: {
868: sc->sc_pr.usedhigh = sc->sc_pr.end - sc->sc_pr.start;
869: sc->sc_pr.usedlow = sc->sc_pr.usedhigh * 3 / 4; /* set lowater at 75% */
870: if (sc->sc_pr.usedlow == sc->sc_pr.usedhigh)
871: sc->sc_pr.usedlow -= sc->sc_pr.blksize;
872: sc->sc_rr.usedhigh = sc->sc_rr.end - sc->sc_rr.start - sc->sc_rr.blksize;
873: sc->sc_rr.usedlow = 0;
874: }
875:
876: static __inline int
877: audio_sleep_timo(int *chan, char *label, int timo)
878: {
879: int st;
880:
881: if (!label)
882: label = "audio";
883:
884: DPRINTFN(3, ("audio_sleep_timo: chan=%p, label=%s, timo=%d\n",
885: chan, label, timo));
886: *chan = 1;
887: st = tsleep(chan, PWAIT | PCATCH, label, timo);
888: *chan = 0;
889: #ifdef AUDIO_DEBUG
890: if (st != 0)
891: printf("audio_sleep: woke up st=%d\n", st);
892: #endif
893: return (st);
894: }
895:
896: static __inline int
897: audio_sleep(int *chan, char *label)
898: {
899: return audio_sleep_timo(chan, label, 0);
900: }
901:
902: /* call at splaudio() */
903: static __inline void
904: audio_wakeup(int *chan)
905: {
906: DPRINTFN(3, ("audio_wakeup: chan=%p, *chan=%d\n", chan, *chan));
907: if (*chan) {
908: wakeup(chan);
909: *chan = 0;
910: }
911: }
912:
913: int
914: audio_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
915: struct proc *p)
916: {
917: int error;
918: int mode;
919: struct audio_info ai;
920:
921: DPRINTF(("audio_open: dev=0x%x flags=0x%x sc=%p hdl=%p\n", dev, flags, sc, sc->hw_hdl));
922:
923: if (ISDEVAUDIOCTL(dev))
924: return 0;
925:
926: if ((sc->sc_open & (AUOPEN_READ|AUOPEN_WRITE)) != 0)
927: return (EBUSY);
928:
929: error = sc->hw_if->open(sc->hw_hdl, flags);
930: if (error)
931: return (error);
932:
933: sc->sc_async_audio = 0;
934: sc->sc_rchan = 0;
935: sc->sc_wchan = 0;
936: sc->sc_blkset = 0; /* Block sizes not set yet */
937: sc->sc_sil_count = 0;
938: sc->sc_rbus = 0;
939: sc->sc_pbus = 0;
940: sc->sc_eof = 0;
941: sc->sc_playdrop = 0;
942:
943: sc->sc_full_duplex = 0;
944: /* doesn't always work right on SB.
945: (flags & (FWRITE|FREAD)) == (FWRITE|FREAD) &&
946: (sc->hw_if->get_props(sc->hw_hdl) & AUDIO_PROP_FULLDUPLEX);
947: */
948:
949: mode = 0;
950: if (flags & FREAD) {
951: sc->sc_open |= AUOPEN_READ;
952: mode |= AUMODE_RECORD;
953: }
954: if (flags & FWRITE) {
955: sc->sc_open |= AUOPEN_WRITE;
956: mode |= AUMODE_PLAY | AUMODE_PLAY_ALL;
957: }
958:
959: /*
960: * Multiplex device: /dev/audio (MU-Law) and /dev/sound (linear)
961: * The /dev/audio is always (re)set to 8-bit MU-Law mono
962: * For the other devices, you get what they were last set to.
963: */
964: if (ISDEVAUDIO(dev)) {
965: /* /dev/audio */
966: sc->sc_rparams = audio_default;
967: sc->sc_pparams = audio_default;
968: }
969: #ifdef DIAGNOSTIC
970: /*
971: * Sample rate and precision are supposed to be set to proper
972: * default values by the hardware driver, so that it may give
973: * us these values.
974: */
975: if (sc->sc_rparams.precision == 0 || sc->sc_pparams.precision == 0) {
976: printf("audio_open: 0 precision\n");
977: error = EINVAL;
978: goto bad;
979: }
980: #endif
981:
982: AUDIO_INITINFO(&ai);
983: ai.record.sample_rate = sc->sc_rparams.sample_rate;
984: ai.record.encoding = sc->sc_rparams.encoding;
985: ai.record.channels = sc->sc_rparams.channels;
986: ai.record.precision = sc->sc_rparams.precision;
987: ai.record.pause = 0;
988: ai.play.sample_rate = sc->sc_pparams.sample_rate;
989: ai.play.encoding = sc->sc_pparams.encoding;
990: ai.play.channels = sc->sc_pparams.channels;
991: ai.play.precision = sc->sc_pparams.precision;
992: ai.play.pause = 0;
993: ai.mode = mode;
994: sc->sc_pr.blksize = sc->sc_rr.blksize = 0; /* force recalculation */
995: error = audiosetinfo(sc, &ai);
996: if (error)
997: goto bad;
998:
999: DPRINTF(("audio_open: done sc_mode = 0x%x\n", sc->sc_mode));
1000:
1001: return 0;
1002:
1003: bad:
1004: sc->hw_if->close(sc->hw_hdl);
1005: sc->sc_open = 0;
1006: sc->sc_mode = 0;
1007: sc->sc_full_duplex = 0;
1008: return error;
1009: }
1010:
1011: /*
1012: * Must be called from task context.
1013: */
1014: void
1015: audio_init_record(struct audio_softc *sc)
1016: {
1017: int s = splaudio();
1018:
1019: if (sc->hw_if->speaker_ctl &&
1020: (!sc->sc_full_duplex || (sc->sc_mode & AUMODE_PLAY) == 0))
1021: sc->hw_if->speaker_ctl(sc->hw_hdl, SPKR_OFF);
1022: splx(s);
1023: }
1024:
1025: /*
1026: * Must be called from task context.
1027: */
1028: void
1029: audio_init_play(struct audio_softc *sc)
1030: {
1031: int s = splaudio();
1032:
1033: sc->sc_wstamp = sc->sc_pr.stamp;
1034: if (sc->hw_if->speaker_ctl)
1035: sc->hw_if->speaker_ctl(sc->hw_hdl, SPKR_ON);
1036: splx(s);
1037: }
1038:
1039: int
1040: audio_drain(struct audio_softc *sc)
1041: {
1042: int error, drops;
1043: struct audio_ringbuffer *cb = &sc->sc_pr;
1044: int s;
1045:
1046: DPRINTF(("audio_drain: enter busy=%d used=%d\n",
1047: sc->sc_pbus, sc->sc_pr.used));
1048: if (sc->sc_pr.mmapped || sc->sc_pr.used <= 0)
1049: return 0;
1050: if (!sc->sc_pbus) {
1051: /* We've never started playing, probably because the
1052: * block was too short. Pad it and start now.
1053: */
1054: int cc;
1055: u_char *inp = cb->inp;
1056:
1057: cc = cb->blksize - (inp - cb->start) % cb->blksize;
1058: if (sc->sc_pparams.sw_code) {
1059: int ncc = cc / sc->sc_pparams.factor;
1060: audio_fill_silence(&sc->sc_pparams, inp, ncc);
1061: sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
1062: } else
1063: audio_fill_silence(&sc->sc_pparams, inp, cc);
1064: inp += cc;
1065: if (inp >= cb->end)
1066: inp = cb->start;
1067: s = splaudio();
1068: cb->used += cc;
1069: cb->inp = inp;
1070: error = audiostartp(sc);
1071: splx(s);
1072: if (error)
1073: return error;
1074: }
1075: /*
1076: * Play until a silence block has been played, then we
1077: * know all has been drained.
1078: * XXX This should be done some other way to avoid
1079: * playing silence.
1080: */
1081: #ifdef DIAGNOSTIC
1082: if (cb->copying) {
1083: printf("audio_drain: copying in progress!?!\n");
1084: cb->copying = 0;
1085: }
1086: #endif
1087: drops = cb->drops;
1088: error = 0;
1089: s = splaudio();
1090: while (cb->drops == drops && !error) {
1091: DPRINTF(("audio_drain: used=%d, drops=%ld\n", sc->sc_pr.used, cb->drops));
1092: /*
1093: * When the process is exiting, it ignores all signals and
1094: * we can't interrupt this sleep, so we set a timeout just in case.
1095: */
1096: error = audio_sleep_timo(&sc->sc_wchan, "aud_dr", 30*hz);
1097: if (sc->sc_dying)
1098: error = EIO;
1099: }
1100: splx(s);
1101: return error;
1102: }
1103:
1104: /*
1105: * Close an audio chip.
1106: */
1107: /* ARGSUSED */
1108: int
1109: audio_close(dev_t dev, int flags, int ifmt, struct proc *p)
1110: {
1111: int unit = AUDIOUNIT(dev);
1112: struct audio_softc *sc = audio_cd.cd_devs[unit];
1113: struct audio_hw_if *hw = sc->hw_if;
1114: int s;
1115:
1116: DPRINTF(("audio_close: unit=%d flags=0x%x\n", unit, flags));
1117:
1118: s = splaudio();
1119: /* Stop recording. */
1120: if ((flags & FREAD) && sc->sc_rbus) {
1121: /*
1122: * XXX Some drivers (e.g. SB) use the same routine
1123: * to halt input and output so don't halt input if
1124: * in full duplex mode. These drivers should be fixed.
1125: */
1126: if (!sc->sc_full_duplex || sc->hw_if->halt_input != sc->hw_if->halt_output)
1127: sc->hw_if->halt_input(sc->hw_hdl);
1128: sc->sc_rbus = 0;
1129: }
1130: /*
1131: * Block until output drains, but allow ^C interrupt.
1132: */
1133: sc->sc_pr.usedlow = sc->sc_pr.blksize; /* avoid excessive wakeups */
1134: /*
1135: * If there is pending output, let it drain (unless
1136: * the output is paused).
1137: */
1138: if ((flags & FWRITE) && sc->sc_pbus) {
1139: if (!sc->sc_pr.pause && !audio_drain(sc) && hw->drain)
1140: (void)hw->drain(sc->hw_hdl);
1141: sc->hw_if->halt_output(sc->hw_hdl);
1142: sc->sc_pbus = 0;
1143: }
1144:
1145: hw->close(sc->hw_hdl);
1146:
1147: /*
1148: * If flags has neither read nor write then reset both
1149: * directions. Encountered when someone runs revoke(2).
1150: */
1151:
1152: if ((flags & FREAD) || ((flags & (FREAD|FWRITE)) == 0)) {
1153: sc->sc_open &= ~AUOPEN_READ;
1154: sc->sc_mode &= ~AUMODE_RECORD;
1155: }
1156: if ((flags & FWRITE) || ((flags & (FREAD|FWRITE)) == 0)) {
1157: sc->sc_open &= ~AUOPEN_WRITE;
1158: sc->sc_mode &= ~(AUMODE_PLAY|AUMODE_PLAY_ALL);
1159: }
1160:
1161: sc->sc_async_audio = 0;
1162: sc->sc_full_duplex = 0;
1163: splx(s);
1164: DPRINTF(("audio_close: done\n"));
1165:
1166: return (0);
1167: }
1168:
1169: int
1170: audio_read(dev_t dev, struct uio *uio, int ioflag)
1171: {
1172: int unit = AUDIOUNIT(dev);
1173: struct audio_softc *sc = audio_cd.cd_devs[unit];
1174: struct audio_ringbuffer *cb = &sc->sc_rr;
1175: u_char *outp;
1176: int error, s, used, cc, n;
1177:
1178: if (cb->mmapped)
1179: return EINVAL;
1180:
1181: DPRINTFN(1,("audio_read: cc=%d mode=%d\n",
1182: uio->uio_resid, sc->sc_mode));
1183:
1184: error = 0;
1185: /*
1186: * If hardware is half-duplex and currently playing, return
1187: * silence blocks based on the number of blocks we have output.
1188: */
1189: if (!sc->sc_full_duplex &&
1190: (sc->sc_mode & AUMODE_PLAY)) {
1191: while (uio->uio_resid > 0 && !error) {
1192: s = splaudio();
1193: for(;;) {
1194: cc = sc->sc_pr.stamp - sc->sc_wstamp;
1195: if (cc > 0)
1196: break;
1197: DPRINTF(("audio_read: stamp=%lu, wstamp=%lu\n",
1198: sc->sc_pr.stamp, sc->sc_wstamp));
1199: if (ioflag & IO_NDELAY) {
1200: splx(s);
1201: return EWOULDBLOCK;
1202: }
1203: error = audio_sleep(&sc->sc_rchan, "aud_hr");
1204: if (sc->sc_dying)
1205: error = EIO;
1206: if (error) {
1207: splx(s);
1208: return error;
1209: }
1210: }
1211: splx(s);
1212:
1213: if (uio->uio_resid < cc / sc->sc_rparams.factor)
1214: cc = uio->uio_resid * sc->sc_rparams.factor;
1215: DPRINTFN(1, ("audio_read: reading in write mode, cc=%d\n", cc));
1216: error = audio_silence_copyout(sc,
1217: cc / sc->sc_rparams.factor, uio);
1218: sc->sc_wstamp += cc;
1219: }
1220: return (error);
1221: }
1222: while (uio->uio_resid > 0 && !error) {
1223: s = splaudio();
1224: while (cb->used <= 0) {
1225: if (!sc->sc_rbus && !sc->sc_rr.pause) {
1226: error = audiostartr(sc);
1227: if (error) {
1228: splx(s);
1229: return error;
1230: }
1231: }
1232: if (ioflag & IO_NDELAY) {
1233: splx(s);
1234: return (EWOULDBLOCK);
1235: }
1236: DPRINTFN(2, ("audio_read: sleep used=%d\n", cb->used));
1237: error = audio_sleep(&sc->sc_rchan, "aud_rd");
1238: if (sc->sc_dying)
1239: error = EIO;
1240: if (error) {
1241: splx(s);
1242: return error;
1243: }
1244: }
1245: used = cb->used;
1246: outp = cb->outp;
1247: cb->copying = 1;
1248: splx(s);
1249: cc = used - cb->usedlow; /* maximum to read */
1250: n = cb->end - outp;
1251: if (n < cc)
1252: cc = n; /* don't read beyond end of buffer */
1253:
1254: /* and no more than we want */
1255: if (uio->uio_resid < cc / sc->sc_rparams.factor)
1256: cc = uio->uio_resid * sc->sc_rparams.factor;
1257:
1258: if (sc->sc_rparams.sw_code)
1259: sc->sc_rparams.sw_code(sc->hw_hdl, outp, cc);
1260: DPRINTFN(1,("audio_read: outp=%p, cc=%d\n", outp, cc));
1261: error = uiomove(outp, cc / sc->sc_rparams.factor, uio);
1262: used -= cc;
1263: outp += cc;
1264: if (outp >= cb->end)
1265: outp = cb->start;
1266: s = splaudio();
1267: cb->outp = outp;
1268: cb->used = used;
1269: cb->copying = 0;
1270: splx(s);
1271: }
1272: return (error);
1273: }
1274:
1275: void
1276: audio_clear(struct audio_softc *sc)
1277: {
1278: int s = splaudio();
1279:
1280: if (sc->sc_rbus) {
1281: audio_wakeup(&sc->sc_rchan);
1282: sc->hw_if->halt_input(sc->hw_hdl);
1283: sc->sc_rbus = 0;
1284: }
1285: if (sc->sc_pbus) {
1286: audio_wakeup(&sc->sc_wchan);
1287: sc->hw_if->halt_output(sc->hw_hdl);
1288: sc->sc_pbus = 0;
1289: }
1290: splx(s);
1291: }
1292:
1293: void
1294: audio_calc_blksize(struct audio_softc *sc, int mode)
1295: {
1296: struct audio_hw_if *hw = sc->hw_if;
1297: struct audio_params *parm;
1298: struct audio_ringbuffer *rb;
1299: int bs;
1300:
1301: if (sc->sc_blkset)
1302: return;
1303:
1304: if (mode == AUMODE_PLAY) {
1305: parm = &sc->sc_pparams;
1306: rb = &sc->sc_pr;
1307: } else {
1308: parm = &sc->sc_rparams;
1309: rb = &sc->sc_rr;
1310: }
1311:
1312: bs = parm->sample_rate * audio_blk_ms / 1000 *
1313: parm->channels * parm->precision / NBBY *
1314: parm->factor;
1315: ROUNDSIZE(bs);
1316: if (hw->round_blocksize)
1317: bs = hw->round_blocksize(sc->hw_hdl, bs);
1318: rb->blksize = bs;
1319:
1320: DPRINTF(("audio_calc_blksize: %s blksize=%d\n",
1321: mode == AUMODE_PLAY ? "play" : "record", bs));
1322: }
1323:
1324: void
1325: audio_fill_silence(struct audio_params *params, u_char *p, int n)
1326: {
1327: u_char auzero0, auzero1 = 0; /* initialize to please gcc */
1328: int nfill = 1;
1329:
1330: switch (params->encoding) {
1331: case AUDIO_ENCODING_ULAW:
1332: auzero0 = 0x7f;
1333: break;
1334: case AUDIO_ENCODING_ALAW:
1335: auzero0 = 0x55;
1336: break;
1337: case AUDIO_ENCODING_MPEG_L1_STREAM:
1338: case AUDIO_ENCODING_MPEG_L1_PACKETS:
1339: case AUDIO_ENCODING_MPEG_L1_SYSTEM:
1340: case AUDIO_ENCODING_MPEG_L2_STREAM:
1341: case AUDIO_ENCODING_MPEG_L2_PACKETS:
1342: case AUDIO_ENCODING_MPEG_L2_SYSTEM:
1343: case AUDIO_ENCODING_ADPCM: /* is this right XXX */
1344: case AUDIO_ENCODING_SLINEAR_LE:
1345: case AUDIO_ENCODING_SLINEAR_BE:
1346: auzero0 = 0; /* fortunately this works for both 8 and 16 bits */
1347: break;
1348: case AUDIO_ENCODING_ULINEAR_LE:
1349: case AUDIO_ENCODING_ULINEAR_BE:
1350: if (params->precision == 16) {
1351: nfill = 2;
1352: if (params->encoding == AUDIO_ENCODING_ULINEAR_LE) {
1353: auzero0 = 0;
1354: auzero1 = 0x80;
1355: } else {
1356: auzero0 = 0x80;
1357: auzero1 = 0;
1358: }
1359: } else
1360: auzero0 = 0x80;
1361: break;
1362: default:
1363: DPRINTF(("audio: bad encoding %d\n", params->encoding));
1364: auzero0 = 0;
1365: break;
1366: }
1367: if (nfill == 1) {
1368: while (--n >= 0)
1369: *p++ = auzero0; /* XXX memset */
1370: } else /* nfill must be 2 */ {
1371: while (n > 1) {
1372: *p++ = auzero0;
1373: *p++ = auzero1;
1374: n -= 2;
1375: }
1376: }
1377: }
1378:
1379: int
1380: audio_silence_copyout(struct audio_softc *sc, int n, struct uio *uio)
1381: {
1382: int error;
1383: int k;
1384: u_char zerobuf[128];
1385:
1386: audio_fill_silence(&sc->sc_rparams, zerobuf, sizeof zerobuf);
1387:
1388: error = 0;
1389: while (n > 0 && uio->uio_resid > 0 && !error) {
1390: k = min(n, min(uio->uio_resid, sizeof zerobuf));
1391: error = uiomove(zerobuf, k, uio);
1392: n -= k;
1393: }
1394: return (error);
1395: }
1396:
1397: int
1398: audio_write(dev_t dev, struct uio *uio, int ioflag)
1399: {
1400: int unit = AUDIOUNIT(dev);
1401: struct audio_softc *sc = audio_cd.cd_devs[unit];
1402: struct audio_ringbuffer *cb = &sc->sc_pr;
1403: u_char *inp, *einp;
1404: int saveerror, error, s, n, cc, used;
1405:
1406: DPRINTFN(2, ("audio_write: sc=%p(unit=%d) count=%d used=%d(hi=%d)\n", sc, unit,
1407: uio->uio_resid, sc->sc_pr.used, sc->sc_pr.usedhigh));
1408:
1409: if (cb->mmapped)
1410: return EINVAL;
1411:
1412: if (uio->uio_resid == 0) {
1413: sc->sc_eof++;
1414: return 0;
1415: }
1416:
1417: /*
1418: * If half-duplex and currently recording, throw away data.
1419: */
1420: if (!sc->sc_full_duplex &&
1421: (sc->sc_mode & AUMODE_RECORD)) {
1422: uio->uio_offset += uio->uio_resid;
1423: uio->uio_resid = 0;
1424: DPRINTF(("audio_write: half-dpx read busy\n"));
1425: return (0);
1426: }
1427:
1428: if (!(sc->sc_mode & AUMODE_PLAY_ALL) && sc->sc_playdrop > 0) {
1429: n = min(sc->sc_playdrop, uio->uio_resid * sc->sc_pparams.factor);
1430: DPRINTF(("audio_write: playdrop %d\n", n));
1431: uio->uio_offset += n / sc->sc_pparams.factor;
1432: uio->uio_resid -= n / sc->sc_pparams.factor;
1433: sc->sc_playdrop -= n;
1434: if (uio->uio_resid == 0)
1435: return 0;
1436: }
1437:
1438: DPRINTFN(1, ("audio_write: sr=%ld, enc=%d, prec=%d, chan=%d, sw=%p, fact=%d\n",
1439: sc->sc_pparams.sample_rate, sc->sc_pparams.encoding,
1440: sc->sc_pparams.precision, sc->sc_pparams.channels,
1441: sc->sc_pparams.sw_code, sc->sc_pparams.factor));
1442:
1443: error = 0;
1444: while (uio->uio_resid > 0 && !error) {
1445: s = splaudio();
1446: while (cb->used >= cb->usedhigh) {
1447: DPRINTFN(2, ("audio_write: sleep used=%d lowat=%d hiwat=%d\n",
1448: cb->used, cb->usedlow, cb->usedhigh));
1449: if (ioflag & IO_NDELAY) {
1450: splx(s);
1451: return (EWOULDBLOCK);
1452: }
1453: error = audio_sleep(&sc->sc_wchan, "aud_wr");
1454: if (sc->sc_dying)
1455: error = EIO;
1456: if (error) {
1457: splx(s);
1458: return error;
1459: }
1460: }
1461: used = cb->used;
1462: inp = cb->inp;
1463: cb->copying = 1;
1464: splx(s);
1465: cc = cb->usedhigh - used; /* maximum to write */
1466: n = cb->end - inp;
1467: if (sc->sc_pparams.factor != 1) {
1468: /* Compensate for software coding expansion factor. */
1469: n /= sc->sc_pparams.factor;
1470: cc /= sc->sc_pparams.factor;
1471: }
1472: if (n < cc)
1473: cc = n; /* don't write beyond end of buffer */
1474: if (uio->uio_resid < cc)
1475: cc = uio->uio_resid; /* and no more than we have */
1476:
1477: #ifdef DIAGNOSTIC
1478: /*
1479: * This should never happen since the block size and and
1480: * block pointers are always nicely aligned.
1481: */
1482: if (cc == 0) {
1483: printf("audio_write: cc == 0, swcode=%p, factor=%d\n",
1484: sc->sc_pparams.sw_code, sc->sc_pparams.factor);
1485: cb->copying = 0;
1486: return EINVAL;
1487: }
1488: #endif
1489: DPRINTFN(1, ("audio_write: uiomove cc=%d inp=%p, left=%d\n",
1490: cc, inp, uio->uio_resid));
1491: n = uio->uio_resid;
1492: error = uiomove(inp, cc, uio);
1493: cc = n - uio->uio_resid; /* number of bytes actually moved */
1494: #ifdef AUDIO_DEBUG
1495: if (error)
1496: printf("audio_write:(1) uiomove failed %d; cc=%d inp=%p\n",
1497: error, cc, inp);
1498: #endif
1499: /*
1500: * Continue even if uiomove() failed because we may have
1501: * gotten a partial block.
1502: */
1503:
1504: if (sc->sc_pparams.sw_code) {
1505: sc->sc_pparams.sw_code(sc->hw_hdl, inp, cc);
1506: /* Adjust count after the expansion. */
1507: cc *= sc->sc_pparams.factor;
1508: DPRINTFN(1, ("audio_write: expanded cc=%d\n", cc));
1509: }
1510:
1511: einp = cb->inp + cc;
1512: if (einp >= cb->end)
1513: einp = cb->start;
1514:
1515: s = splaudio();
1516: /*
1517: * This is a very suboptimal way of keeping track of
1518: * silence in the buffer, but it is simple.
1519: */
1520: sc->sc_sil_count = 0;
1521:
1522: cb->inp = einp;
1523: cb->used += cc;
1524: /* If the interrupt routine wants the last block filled AND
1525: * the copy did not fill the last block completely it needs to
1526: * be padded.
1527: */
1528: if (cb->needfill &&
1529: (inp - cb->start) / cb->blksize ==
1530: (einp - cb->start) / cb->blksize) {
1531: /* Figure out how many bytes there is to a block boundary. */
1532: cc = cb->blksize - (einp - cb->start) % cb->blksize;
1533: DPRINTF(("audio_write: partial fill %d\n", cc));
1534: } else
1535: cc = 0;
1536: cb->needfill = 0;
1537: cb->copying = 0;
1538: if (!sc->sc_pbus && !cb->pause) {
1539: saveerror = error;
1540: error = audiostartp(sc);
1541: if (saveerror != 0) {
1542: /* Report the first error that occurred. */
1543: error = saveerror;
1544: }
1545: }
1546: splx(s);
1547: if (cc) {
1548: DPRINTFN(1, ("audio_write: fill %d\n", cc));
1549: if (sc->sc_pparams.sw_code) {
1550: int ncc = cc / sc->sc_pparams.factor;
1551: audio_fill_silence(&sc->sc_pparams, einp, ncc);
1552: sc->sc_pparams.sw_code(sc->hw_hdl, einp, ncc);
1553: } else
1554: audio_fill_silence(&sc->sc_pparams, einp, cc);
1555: }
1556: }
1557: return (error);
1558: }
1559:
1560: int
1561: audio_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
1562: {
1563: int unit = AUDIOUNIT(dev);
1564: struct audio_softc *sc = audio_cd.cd_devs[unit];
1565: struct audio_hw_if *hw = sc->hw_if;
1566: struct audio_offset *ao;
1567: int error = 0, s, offs, fd;
1568: int rbus, pbus;
1569:
1570: DPRINTF(("audio_ioctl(%d,'%c',%d)\n",
1571: IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff));
1572: switch (cmd) {
1573: case FIONBIO:
1574: /* All handled in the upper FS layer. */
1575: break;
1576:
1577: case FIOASYNC:
1578: if (*(int *)addr) {
1579: if (sc->sc_async_audio)
1580: return (EBUSY);
1581: sc->sc_async_audio = p;
1582: DPRINTF(("audio_ioctl: FIOASYNC %p\n", p));
1583: } else
1584: sc->sc_async_audio = 0;
1585: break;
1586:
1587: case AUDIO_FLUSH:
1588: DPRINTF(("AUDIO_FLUSH\n"));
1589: rbus = sc->sc_rbus;
1590: pbus = sc->sc_pbus;
1591: audio_clear(sc);
1592: s = splaudio();
1593: error = audio_initbufs(sc);
1594: if (error) {
1595: splx(s);
1596: return error;
1597: }
1598: sc->sc_rr.pause = 0;
1599: sc->sc_pr.pause = 0;
1600: if ((sc->sc_mode & AUMODE_PLAY) && !sc->sc_pbus && pbus)
1601: error = audiostartp(sc);
1602: if (!error &&
1603: (sc->sc_mode & AUMODE_RECORD) && !sc->sc_rbus && rbus)
1604: error = audiostartr(sc);
1605: splx(s);
1606: break;
1607:
1608: /*
1609: * Number of read (write) samples dropped. We don't know where or
1610: * when they were dropped.
1611: *
1612: * The audio_ringbuffer->drops count is the number of buffer
1613: * sample size bytes. Convert it to userland sample size bytes,
1614: * then convert to samples. There is no easy way to get the
1615: * buffer sample size, but the userland sample size can be
1616: * calculated with userland channels and userland precision.
1617: *
1618: * original formula:
1619: * sc->sc_rr.drops /
1620: * sc->sc_rparams.factor /
1621: * (sc->sc_rparams.channels * (sc->sc_rparams.precision / NBBY))
1622: */
1623: case AUDIO_RERROR:
1624: *(int *)addr = (sc->sc_rr.drops * NBBY) /
1625: (sc->sc_rparams.factor * sc->sc_rparams.channels *
1626: sc->sc_rparams.precision);
1627: break;
1628:
1629: case AUDIO_PERROR:
1630: *(int *)addr = (sc->sc_pr.drops * NBBY) /
1631: (sc->sc_pparams.factor * sc->sc_pparams.channels *
1632: sc->sc_pparams.precision);
1633: break;
1634:
1635: /*
1636: * Offsets into buffer.
1637: */
1638: case AUDIO_GETIOFFS:
1639: s = splaudio();
1640: /* figure out where next DMA will start */
1641: ao = (struct audio_offset *)addr;
1642: ao->samples = sc->sc_rr.stamp;
1643: ao->deltablks = (sc->sc_rr.stamp - sc->sc_rr.stamp_last) / sc->sc_rr.blksize;
1644: sc->sc_rr.stamp_last = sc->sc_rr.stamp;
1645: ao->offset = sc->sc_rr.inp - sc->sc_rr.start;
1646: splx(s);
1647: break;
1648:
1649: case AUDIO_GETOOFFS:
1650: s = splaudio();
1651: /* figure out where next DMA will start */
1652: ao = (struct audio_offset *)addr;
1653: offs = sc->sc_pr.outp - sc->sc_pr.start + sc->sc_pr.blksize;
1654: if (sc->sc_pr.start + offs >= sc->sc_pr.end)
1655: offs = 0;
1656: ao->samples = sc->sc_pr.stamp;
1657: ao->deltablks = (sc->sc_pr.stamp - sc->sc_pr.stamp_last) / sc->sc_pr.blksize;
1658: sc->sc_pr.stamp_last = sc->sc_pr.stamp;
1659: ao->offset = offs;
1660: splx(s);
1661: break;
1662:
1663: /*
1664: * How many bytes will elapse until mike hears the first
1665: * sample of what we write next?
1666: */
1667: case AUDIO_WSEEK:
1668: *(u_long *)addr = sc->sc_pr.used / sc->sc_pparams.factor;
1669: break;
1670:
1671: case AUDIO_SETINFO:
1672: DPRINTF(("AUDIO_SETINFO mode=0x%x\n", sc->sc_mode));
1673: error = audiosetinfo(sc, (struct audio_info *)addr);
1674: break;
1675:
1676: case AUDIO_GETINFO:
1677: DPRINTF(("AUDIO_GETINFO\n"));
1678: error = audiogetinfo(sc, (struct audio_info *)addr);
1679: break;
1680:
1681: case AUDIO_DRAIN:
1682: DPRINTF(("AUDIO_DRAIN\n"));
1683: error = audio_drain(sc);
1684: if (!error && hw->drain)
1685: error = hw->drain(sc->hw_hdl);
1686: break;
1687:
1688: case AUDIO_GETDEV:
1689: DPRINTF(("AUDIO_GETDEV\n"));
1690: error = hw->getdev(sc->hw_hdl, (audio_device_t *)addr);
1691: break;
1692:
1693: case AUDIO_GETENC:
1694: DPRINTF(("AUDIO_GETENC\n"));
1695: /* Pass read/write info down to query_encoding */
1696: ((struct audio_encoding *)addr)->flags = sc->sc_open;
1697: error = hw->query_encoding(sc->hw_hdl, (struct audio_encoding *)addr);
1698: break;
1699:
1700: case AUDIO_GETFD:
1701: DPRINTF(("AUDIO_GETFD\n"));
1702: *(int *)addr = sc->sc_full_duplex;
1703: break;
1704:
1705: case AUDIO_SETFD:
1706: DPRINTF(("AUDIO_SETFD\n"));
1707: fd = *(int *)addr;
1708: if (hw->get_props(sc->hw_hdl) & AUDIO_PROP_FULLDUPLEX) {
1709: if (hw->setfd)
1710: error = hw->setfd(sc->hw_hdl, fd);
1711: else
1712: error = 0;
1713: if (!error)
1714: sc->sc_full_duplex = fd;
1715: } else {
1716: if (fd)
1717: error = ENOTTY;
1718: else
1719: error = 0;
1720: }
1721: break;
1722:
1723: case AUDIO_GETPROPS:
1724: DPRINTF(("AUDIO_GETPROPS\n"));
1725: *(int *)addr = hw->get_props(sc->hw_hdl);
1726: break;
1727:
1728: default:
1729: DPRINTF(("audio_ioctl: unknown ioctl\n"));
1730: error = ENOTTY;
1731: break;
1732: }
1733: DPRINTF(("audio_ioctl(%d,'%c',%d) result %d\n",
1734: IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff, error));
1735: return (error);
1736: }
1737:
1738: void
1739: audio_selwakeup(struct audio_softc *sc, int play)
1740: {
1741: struct selinfo *si;
1742:
1743: si = play? &sc->sc_wsel : &sc->sc_rsel;
1744:
1745: audio_wakeup(play? &sc->sc_wchan : &sc->sc_rchan);
1746: selwakeup(si);
1747: if (sc->sc_async_audio)
1748: psignal(sc->sc_async_audio, SIGIO);
1749: KNOTE(&si->si_note, 0);
1750: }
1751:
1752: #define AUDIO_FILTREAD(sc) ( \
1753: (!sc->sc_full_duplex && (sc->sc_mode & AUMODE_PLAY)) ? \
1754: sc->sc_pr.stamp > sc->sc_wstamp : sc->sc_rr.used > sc->sc_rr.usedlow)
1755:
1756: #define AUDIO_FILTWRITE(sc) ( \
1757: (!sc->sc_full_duplex && (sc->sc_mode & AUMODE_RECORD)) || \
1758: (!(sc->sc_mode & AUMODE_PLAY_ALL) && sc->sc_playdrop > 0) || \
1759: (sc->sc_pr.used <= sc->sc_pr.usedlow))
1760:
1761: int
1762: audio_poll(dev_t dev, int events, struct proc *p)
1763: {
1764: int unit = AUDIOUNIT(dev);
1765: struct audio_softc *sc = audio_cd.cd_devs[unit];
1766: int revents = 0, s = splaudio();
1767:
1768: DPRINTF(("audio_poll: events=0x%x mode=%d\n", events, sc->sc_mode));
1769:
1770: if (events & (POLLIN | POLLRDNORM)) {
1771: if (AUDIO_FILTREAD(sc))
1772: revents |= events & (POLLIN | POLLRDNORM);
1773: }
1774: if (events & (POLLOUT | POLLWRNORM)) {
1775: if (AUDIO_FILTWRITE(sc))
1776: revents |= events & (POLLOUT | POLLWRNORM);
1777: }
1778: if (revents == 0) {
1779: if (events & (POLLIN | POLLRDNORM))
1780: selrecord(p, &sc->sc_rsel);
1781: if (events & (POLLOUT | POLLWRNORM))
1782: selrecord(p, &sc->sc_wsel);
1783: }
1784: splx(s);
1785: return (revents);
1786: }
1787:
1788: paddr_t
1789: audio_mmap(dev_t dev, off_t off, int prot)
1790: {
1791: int s;
1792: int unit = AUDIOUNIT(dev);
1793: struct audio_softc *sc = audio_cd.cd_devs[unit];
1794: struct audio_hw_if *hw = sc->hw_if;
1795: struct audio_ringbuffer *cb;
1796:
1797: DPRINTF(("audio_mmap: off=%d, prot=%d\n", off, prot));
1798:
1799: if (!(hw->get_props(sc->hw_hdl) & AUDIO_PROP_MMAP) || !hw->mappage)
1800: return -1;
1801: #if 0
1802: /* XXX
1803: * The idea here was to use the protection to determine if
1804: * we are mapping the read or write buffer, but it fails.
1805: * The VM system is broken in (at least) two ways.
1806: * 1) If you map memory VM_PROT_WRITE you SIGSEGV
1807: * when writing to it, so VM_PROT_READ|VM_PROT_WRITE
1808: * has to be used for mmapping the play buffer.
1809: * 2) Even if calling mmap() with VM_PROT_READ|VM_PROT_WRITE
1810: * audio_mmap will get called at some point with VM_PROT_READ
1811: * only.
1812: * So, alas, we always map the play buffer for now.
1813: */
1814: if (prot == (VM_PROT_READ|VM_PROT_WRITE) ||
1815: prot == VM_PROT_WRITE)
1816: cb = &sc->sc_pr;
1817: else if (prot == VM_PROT_READ)
1818: cb = &sc->sc_rr;
1819: else
1820: return -1;
1821: #else
1822: cb = &sc->sc_pr;
1823: #endif
1824:
1825: if ((u_int)off >= cb->bufsize)
1826: return -1;
1827: if (!cb->mmapped) {
1828: cb->mmapped = 1;
1829: if (cb == &sc->sc_pr) {
1830: audio_fill_silence(&sc->sc_pparams, cb->start, cb->bufsize);
1831: s = splaudio();
1832: if (!sc->sc_pbus && !sc->sc_pr.pause)
1833: (void)audiostartp(sc);
1834: splx(s);
1835: } else {
1836: s = splaudio();
1837: if (!sc->sc_rbus && !sc->sc_rr.pause)
1838: (void)audiostartr(sc);
1839: splx(s);
1840: }
1841: }
1842:
1843: return hw->mappage(sc->hw_hdl, cb->start, off, prot);
1844: }
1845:
1846: int
1847: audiostartr(struct audio_softc *sc)
1848: {
1849: int error;
1850:
1851: DPRINTF(("audiostartr: start=%p used=%d(hi=%d) mmapped=%d\n",
1852: sc->sc_rr.start, sc->sc_rr.used, sc->sc_rr.usedhigh,
1853: sc->sc_rr.mmapped));
1854:
1855: if (sc->hw_if->trigger_input)
1856: error = sc->hw_if->trigger_input(sc->hw_hdl, sc->sc_rr.start,
1857: sc->sc_rr.end, sc->sc_rr.blksize,
1858: audio_rint, (void *)sc, &sc->sc_rparams);
1859: else
1860: error = sc->hw_if->start_input(sc->hw_hdl, sc->sc_rr.start,
1861: sc->sc_rr.blksize, audio_rint, (void *)sc);
1862: if (error) {
1863: DPRINTF(("audiostartr failed: %d\n", error));
1864: return error;
1865: }
1866: sc->sc_rbus = 1;
1867: return 0;
1868: }
1869:
1870: int
1871: audiostartp(struct audio_softc *sc)
1872: {
1873: int error;
1874:
1875: DPRINTF(("audiostartp: start=%p used=%d(hi=%d) mmapped=%d\n",
1876: sc->sc_pr.start, sc->sc_pr.used, sc->sc_pr.usedhigh,
1877: sc->sc_pr.mmapped));
1878:
1879: if (!sc->sc_pr.mmapped && sc->sc_pr.used < sc->sc_pr.blksize)
1880: return 0;
1881:
1882: if (sc->hw_if->trigger_output)
1883: error = sc->hw_if->trigger_output(sc->hw_hdl, sc->sc_pr.start,
1884: sc->sc_pr.end, sc->sc_pr.blksize,
1885: audio_pint, (void *)sc, &sc->sc_pparams);
1886: else
1887: error = sc->hw_if->start_output(sc->hw_hdl, sc->sc_pr.outp,
1888: sc->sc_pr.blksize, audio_pint, (void *)sc);
1889: if (error) {
1890: DPRINTF(("audiostartp failed: %d\n", error));
1891: return error;
1892: }
1893: sc->sc_pbus = 1;
1894: return 0;
1895: }
1896:
1897: /*
1898: * When the play interrupt routine finds that the write isn't keeping
1899: * the buffer filled it will insert silence in the buffer to make up
1900: * for this. The part of the buffer that is filled with silence
1901: * is kept track of in a very approximate way: it starts at sc_sil_start
1902: * and extends sc_sil_count bytes. If there is already silence in
1903: * the requested area nothing is done; so when the whole buffer is
1904: * silent nothing happens. When the writer starts again sc_sil_count
1905: * is set to 0.
1906: */
1907: /* XXX
1908: * Putting silence into the output buffer should not really be done
1909: * at splaudio, but there is no softaudio level to do it at yet.
1910: */
1911: static __inline void
1912: audio_pint_silence(struct audio_softc *sc, struct audio_ringbuffer *cb,
1913: u_char *inp, int cc)
1914: {
1915: u_char *s, *e, *p, *q;
1916:
1917: if (sc->sc_sil_count > 0) {
1918: s = sc->sc_sil_start; /* start of silence */
1919: e = s + sc->sc_sil_count; /* end of silence, may be beyond end */
1920: p = inp; /* adjusted pointer to area to fill */
1921: if (p < s)
1922: p += cb->end - cb->start;
1923: q = p+cc;
1924: /* Check if there is already silence. */
1925: if (!(s <= p && p < e &&
1926: s <= q && q <= e)) {
1927: if (s <= p)
1928: sc->sc_sil_count = max(sc->sc_sil_count, q-s);
1929: DPRINTFN(5, ("audio_pint_silence: fill cc=%d inp=%p, count=%d size=%d\n",
1930: cc, inp, sc->sc_sil_count, (int)(cb->end - cb->start)));
1931:
1932: if (sc->sc_pparams.sw_code) {
1933: int ncc = cc / sc->sc_pparams.factor;
1934: audio_fill_silence(&sc->sc_pparams, inp, ncc);
1935: sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
1936: } else
1937: audio_fill_silence(&sc->sc_pparams, inp, cc);
1938:
1939: } else {
1940: DPRINTFN(5, ("audio_pint_silence: already silent cc=%d inp=%p\n", cc, inp));
1941:
1942: }
1943: } else {
1944: sc->sc_sil_start = inp;
1945: sc->sc_sil_count = cc;
1946: DPRINTFN(5, ("audio_pint_silence: start fill %p %d\n",
1947: inp, cc));
1948:
1949: if (sc->sc_pparams.sw_code) {
1950: int ncc = cc / sc->sc_pparams.factor;
1951: audio_fill_silence(&sc->sc_pparams, inp, ncc);
1952: sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
1953: } else
1954: audio_fill_silence(&sc->sc_pparams, inp, cc);
1955:
1956: }
1957: }
1958:
1959: /*
1960: * Called from HW driver module on completion of dma output.
1961: * Start output of new block, wrap in ring buffer if needed.
1962: * If no more buffers to play, output zero instead.
1963: * Do a wakeup if necessary.
1964: */
1965: void
1966: audio_pint(void *v)
1967: {
1968: struct audio_softc *sc = v;
1969: struct audio_hw_if *hw = sc->hw_if;
1970: struct audio_ringbuffer *cb = &sc->sc_pr;
1971: u_char *inp;
1972: int cc;
1973: int blksize;
1974: int error;
1975:
1976: if (!sc->sc_open)
1977: return; /* ignore interrupt if not open */
1978:
1979: blksize = cb->blksize;
1980:
1981: add_audio_randomness((long)cb);
1982:
1983: cb->outp += blksize;
1984: if (cb->outp >= cb->end)
1985: cb->outp = cb->start;
1986: cb->stamp += blksize;
1987: if (cb->mmapped) {
1988: DPRINTFN(5, ("audio_pint: mmapped outp=%p cc=%d inp=%p\n",
1989: cb->outp, blksize, cb->inp));
1990: if (!hw->trigger_output)
1991: (void)hw->start_output(sc->hw_hdl, cb->outp,
1992: blksize, audio_pint, (void *)sc);
1993: return;
1994: }
1995:
1996: #ifdef AUDIO_INTR_TIME
1997: {
1998: struct timeval tv;
1999: u_long t;
2000: microtime(&tv);
2001: t = tv.tv_usec + 1000000 * tv.tv_sec;
2002: if (sc->sc_pnintr) {
2003: long lastdelta, totdelta;
2004: lastdelta = t - sc->sc_plastintr - sc->sc_pblktime;
2005: if (lastdelta > sc->sc_pblktime / 3) {
2006: printf("audio: play interrupt(%d) off relative by %ld us (%lu)\n",
2007: sc->sc_pnintr, lastdelta, sc->sc_pblktime);
2008: }
2009: totdelta = t - sc->sc_pfirstintr - sc->sc_pblktime * sc->sc_pnintr;
2010: if (totdelta > sc->sc_pblktime) {
2011: printf("audio: play interrupt(%d) off absolute by %ld us (%lu) (LOST)\n",
2012: sc->sc_pnintr, totdelta, sc->sc_pblktime);
2013: sc->sc_pnintr++; /* avoid repeated messages */
2014: }
2015: } else
2016: sc->sc_pfirstintr = t;
2017: sc->sc_plastintr = t;
2018: sc->sc_pnintr++;
2019: }
2020: #endif
2021:
2022: cb->used -= blksize;
2023: if (cb->used < blksize) {
2024: /* we don't have a full block to use */
2025: if (cb->copying) {
2026: /* writer is in progress, don't disturb */
2027: cb->needfill = 1;
2028: DPRINTFN(1, ("audio_pint: copying in progress\n"));
2029: } else {
2030: inp = cb->inp;
2031: cc = blksize - (inp - cb->start) % blksize;
2032: if (cb->pause)
2033: cb->pdrops += cc;
2034: else {
2035: cb->drops += cc;
2036: sc->sc_playdrop += cc;
2037: }
2038: audio_pint_silence(sc, cb, inp, cc);
2039: inp += cc;
2040: if (inp >= cb->end)
2041: inp = cb->start;
2042: cb->inp = inp;
2043: cb->used += cc;
2044:
2045: /* Clear next block so we keep ahead of the DMA. */
2046: if (cb->used + cc < cb->usedhigh)
2047: audio_pint_silence(sc, cb, inp, blksize);
2048: }
2049: }
2050:
2051: DPRINTFN(5, ("audio_pint: outp=%p cc=%d\n", cb->outp, blksize));
2052: if (!hw->trigger_output) {
2053: error = hw->start_output(sc->hw_hdl, cb->outp, blksize,
2054: audio_pint, (void *)sc);
2055: if (error) {
2056: /* XXX does this really help? */
2057: DPRINTF(("audio_pint restart failed: %d\n", error));
2058: audio_clear(sc);
2059: }
2060: }
2061:
2062: DPRINTFN(2, ("audio_pint: mode=%d pause=%d used=%d lowat=%d\n",
2063: sc->sc_mode, cb->pause, cb->used, cb->usedlow));
2064: if ((sc->sc_mode & AUMODE_PLAY) && !cb->pause &&
2065: cb->used <= cb->usedlow)
2066: audio_selwakeup(sc, 1);
2067:
2068: /* Possible to return one or more "phantom blocks" now. */
2069: if (!sc->sc_full_duplex && sc->sc_rchan)
2070: audio_selwakeup(sc, 0);
2071: }
2072:
2073: /*
2074: * Called from HW driver module on completion of dma input.
2075: * Mark it as input in the ring buffer (fiddle pointers).
2076: * Do a wakeup if necessary.
2077: */
2078: void
2079: audio_rint(void *v)
2080: {
2081: struct audio_softc *sc = v;
2082: struct audio_hw_if *hw = sc->hw_if;
2083: struct audio_ringbuffer *cb = &sc->sc_rr;
2084: int blksize;
2085: int error;
2086:
2087: if (!sc->sc_open)
2088: return; /* ignore interrupt if not open */
2089:
2090: add_audio_randomness((long)cb);
2091:
2092: blksize = cb->blksize;
2093:
2094: cb->inp += blksize;
2095: if (cb->inp >= cb->end)
2096: cb->inp = cb->start;
2097: cb->stamp += blksize;
2098: if (cb->mmapped) {
2099: DPRINTFN(2, ("audio_rint: mmapped inp=%p cc=%d\n",
2100: cb->inp, blksize));
2101: if (!hw->trigger_input)
2102: (void)hw->start_input(sc->hw_hdl, cb->inp, blksize,
2103: audio_rint, (void *)sc);
2104: return;
2105: }
2106:
2107: #ifdef AUDIO_INTR_TIME
2108: {
2109: struct timeval tv;
2110: u_long t;
2111: microtime(&tv);
2112: t = tv.tv_usec + 1000000 * tv.tv_sec;
2113: if (sc->sc_rnintr) {
2114: long lastdelta, totdelta;
2115: lastdelta = t - sc->sc_rlastintr - sc->sc_rblktime;
2116: if (lastdelta > sc->sc_rblktime / 5) {
2117: printf("audio: record interrupt(%d) off relative by %ld us (%lu)\n",
2118: sc->sc_rnintr, lastdelta, sc->sc_rblktime);
2119: }
2120: totdelta = t - sc->sc_rfirstintr - sc->sc_rblktime * sc->sc_rnintr;
2121: if (totdelta > sc->sc_rblktime / 2) {
2122: sc->sc_rnintr++;
2123: printf("audio: record interrupt(%d) off absolute by %ld us (%lu)\n",
2124: sc->sc_rnintr, totdelta, sc->sc_rblktime);
2125: sc->sc_rnintr++; /* avoid repeated messages */
2126: }
2127: } else
2128: sc->sc_rfirstintr = t;
2129: sc->sc_rlastintr = t;
2130: sc->sc_rnintr++;
2131: }
2132: #endif
2133:
2134: cb->used += blksize;
2135: if (cb->pause) {
2136: DPRINTFN(1, ("audio_rint: pdrops %lu\n", cb->pdrops));
2137: cb->pdrops += blksize;
2138: cb->outp += blksize;
2139: cb->used -= blksize;
2140: } else if (cb->used + blksize >= cb->usedhigh && !cb->copying) {
2141: DPRINTFN(1, ("audio_rint: drops %lu\n", cb->drops));
2142: cb->drops += blksize;
2143: cb->outp += blksize;
2144: cb->used -= blksize;
2145: }
2146:
2147: DPRINTFN(2, ("audio_rint: inp=%p cc=%d used=%d\n",
2148: cb->inp, blksize, cb->used));
2149: if (!hw->trigger_input) {
2150: error = hw->start_input(sc->hw_hdl, cb->inp, blksize,
2151: audio_rint, (void *)sc);
2152: if (error) {
2153: /* XXX does this really help? */
2154: DPRINTF(("audio_rint: restart failed: %d\n", error));
2155: audio_clear(sc);
2156: }
2157: }
2158:
2159: audio_selwakeup(sc, 0);
2160: }
2161:
2162: int
2163: audio_check_params(struct audio_params *p)
2164: {
2165: if (p->encoding == AUDIO_ENCODING_PCM16) {
2166: if (p->precision == 8)
2167: p->encoding = AUDIO_ENCODING_ULINEAR;
2168: else
2169: p->encoding = AUDIO_ENCODING_SLINEAR;
2170: } else if (p->encoding == AUDIO_ENCODING_PCM8) {
2171: if (p->precision == 8)
2172: p->encoding = AUDIO_ENCODING_ULINEAR;
2173: else
2174: return EINVAL;
2175: }
2176:
2177: if (p->encoding == AUDIO_ENCODING_SLINEAR)
2178: #if BYTE_ORDER == LITTLE_ENDIAN
2179: p->encoding = AUDIO_ENCODING_SLINEAR_LE;
2180: #else
2181: p->encoding = AUDIO_ENCODING_SLINEAR_BE;
2182: #endif
2183: if (p->encoding == AUDIO_ENCODING_ULINEAR)
2184: #if BYTE_ORDER == LITTLE_ENDIAN
2185: p->encoding = AUDIO_ENCODING_ULINEAR_LE;
2186: #else
2187: p->encoding = AUDIO_ENCODING_ULINEAR_BE;
2188: #endif
2189:
2190: switch (p->encoding) {
2191: case AUDIO_ENCODING_ULAW:
2192: case AUDIO_ENCODING_ALAW:
2193: case AUDIO_ENCODING_ADPCM:
2194: if (p->precision != 8)
2195: return (EINVAL);
2196: break;
2197: case AUDIO_ENCODING_SLINEAR_LE:
2198: case AUDIO_ENCODING_SLINEAR_BE:
2199: case AUDIO_ENCODING_ULINEAR_LE:
2200: case AUDIO_ENCODING_ULINEAR_BE:
2201: if (p->precision != 8 && p->precision != 16)
2202: return (EINVAL);
2203: break;
2204: case AUDIO_ENCODING_MPEG_L1_STREAM:
2205: case AUDIO_ENCODING_MPEG_L1_PACKETS:
2206: case AUDIO_ENCODING_MPEG_L1_SYSTEM:
2207: case AUDIO_ENCODING_MPEG_L2_STREAM:
2208: case AUDIO_ENCODING_MPEG_L2_PACKETS:
2209: case AUDIO_ENCODING_MPEG_L2_SYSTEM:
2210: break;
2211: default:
2212: return (EINVAL);
2213: }
2214:
2215: if (p->channels < 1 || p->channels > 8) /* sanity check # of channels */
2216: return (EINVAL);
2217:
2218: return (0);
2219: }
2220:
2221: int
2222: au_set_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int l, int r)
2223: {
2224: ct->type = AUDIO_MIXER_VALUE;
2225: ct->un.value.num_channels = 2;
2226: ct->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
2227: ct->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
2228: if (sc->hw_if->set_port(sc->hw_hdl, ct) == 0)
2229: return 0;
2230: ct->un.value.num_channels = 1;
2231: ct->un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r)/2;
2232: return sc->hw_if->set_port(sc->hw_hdl, ct);
2233: }
2234:
2235: int
2236: au_set_gain(struct audio_softc *sc, struct au_mixer_ports *ports, int gain,
2237: int balance)
2238: {
2239: mixer_ctrl_t ct;
2240: int i, error;
2241: int l, r;
2242: u_int mask;
2243: int nset;
2244:
2245: if (balance == AUDIO_MID_BALANCE) {
2246: l = r = gain;
2247: } else if (balance < AUDIO_MID_BALANCE) {
2248: r = gain;
2249: l = (balance * gain) / AUDIO_MID_BALANCE;
2250: } else {
2251: l = gain;
2252: r = ((AUDIO_RIGHT_BALANCE - balance) * gain)
2253: / AUDIO_MID_BALANCE;
2254: }
2255: DPRINTF(("au_set_gain: gain=%d balance=%d, l=%d r=%d\n",
2256: gain, balance, l, r));
2257:
2258: if (ports->index == -1) {
2259: usemaster:
2260: if (ports->master == -1)
2261: return 0; /* just ignore it silently */
2262: ct.dev = ports->master;
2263: error = au_set_lr_value(sc, &ct, l, r);
2264: } else {
2265: ct.dev = ports->index;
2266: if (ports->isenum) {
2267: ct.type = AUDIO_MIXER_ENUM;
2268: error = sc->hw_if->get_port(sc->hw_hdl, &ct);
2269: if (error)
2270: return error;
2271: for(i = 0; i < ports->nports; i++) {
2272: if (ports->misel[i] == ct.un.ord) {
2273: ct.dev = ports->miport[i];
2274: if (ct.dev == -1 ||
2275: au_set_lr_value(sc, &ct, l, r))
2276: goto usemaster;
2277: else
2278: break;
2279: }
2280: }
2281: } else {
2282: ct.type = AUDIO_MIXER_SET;
2283: error = sc->hw_if->get_port(sc->hw_hdl, &ct);
2284: if (error)
2285: return error;
2286: mask = ct.un.mask;
2287: nset = 0;
2288: for(i = 0; i < ports->nports; i++) {
2289: if (ports->misel[i] & mask) {
2290: ct.dev = ports->miport[i];
2291: if (ct.dev != -1 &&
2292: au_set_lr_value(sc, &ct, l, r) == 0)
2293: nset++;
2294: }
2295: }
2296: if (nset == 0)
2297: goto usemaster;
2298: }
2299: }
2300: if (!error)
2301: mixer_signal(sc);
2302: return error;
2303: }
2304:
2305: int
2306: au_get_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int *l, int *r)
2307: {
2308: int error;
2309:
2310: ct->un.value.num_channels = 2;
2311: if (sc->hw_if->get_port(sc->hw_hdl, ct) == 0) {
2312: *l = ct->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
2313: *r = ct->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
2314: } else {
2315: ct->un.value.num_channels = 1;
2316: error = sc->hw_if->get_port(sc->hw_hdl, ct);
2317: if (error)
2318: return error;
2319: *r = *l = ct->un.value.level[AUDIO_MIXER_LEVEL_MONO];
2320: }
2321: return 0;
2322: }
2323:
2324: void
2325: au_get_gain(struct audio_softc *sc, struct au_mixer_ports *ports, u_int *pgain,
2326: u_char *pbalance)
2327: {
2328: mixer_ctrl_t ct;
2329: int i, l, r, n;
2330: int lgain = AUDIO_MAX_GAIN/2, rgain = AUDIO_MAX_GAIN/2;
2331:
2332: if (ports->index == -1) {
2333: usemaster:
2334: if (ports->master == -1)
2335: goto bad;
2336: ct.dev = ports->master;
2337: ct.type = AUDIO_MIXER_VALUE;
2338: if (au_get_lr_value(sc, &ct, &lgain, &rgain))
2339: goto bad;
2340: } else {
2341: ct.dev = ports->index;
2342: if (ports->isenum) {
2343: ct.type = AUDIO_MIXER_ENUM;
2344: if (sc->hw_if->get_port(sc->hw_hdl, &ct))
2345: goto bad;
2346: ct.type = AUDIO_MIXER_VALUE;
2347: for(i = 0; i < ports->nports; i++) {
2348: if (ports->misel[i] == ct.un.ord) {
2349: ct.dev = ports->miport[i];
2350: if (ct.dev == -1 ||
2351: au_get_lr_value(sc, &ct,
2352: &lgain, &rgain))
2353: goto usemaster;
2354: else
2355: break;
2356: }
2357: }
2358: } else {
2359: ct.type = AUDIO_MIXER_SET;
2360: if (sc->hw_if->get_port(sc->hw_hdl, &ct))
2361: goto bad;
2362: ct.type = AUDIO_MIXER_VALUE;
2363: lgain = rgain = n = 0;
2364: for(i = 0; i < ports->nports; i++) {
2365: if (ports->misel[i] & ct.un.mask) {
2366: ct.dev = ports->miport[i];
2367: if (ct.dev == -1 ||
2368: au_get_lr_value(sc, &ct, &l, &r))
2369: goto usemaster;
2370: else {
2371: lgain += l;
2372: rgain += r;
2373: n++;
2374: }
2375: }
2376: }
2377: if (n != 0) {
2378: lgain /= n;
2379: rgain /= n;
2380: }
2381: }
2382: }
2383: bad:
2384: if (lgain == rgain) { /* handles lgain==rgain==0 */
2385: *pgain = lgain;
2386: *pbalance = AUDIO_MID_BALANCE;
2387: } else if (lgain < rgain) {
2388: *pgain = rgain;
2389: *pbalance = (AUDIO_MID_BALANCE * lgain) / rgain;
2390: } else /* lgain > rgain */ {
2391: *pgain = lgain;
2392: *pbalance = AUDIO_RIGHT_BALANCE -
2393: (AUDIO_MID_BALANCE * rgain) / lgain;
2394: }
2395: }
2396:
2397: int
2398: au_set_port(struct audio_softc *sc, struct au_mixer_ports *ports, u_int port)
2399: {
2400: mixer_ctrl_t ct;
2401: int i, error;
2402:
2403: if (port == 0) /* allow this special case */
2404: return 0;
2405:
2406: if (ports->index == -1)
2407: return EINVAL;
2408: ct.dev = ports->index;
2409: if (ports->isenum) {
2410: if (port & (port-1))
2411: return EINVAL; /* Only one port allowed */
2412: ct.type = AUDIO_MIXER_ENUM;
2413: error = EINVAL;
2414: for(i = 0; i < ports->nports; i++)
2415: if (ports->aumask[i] == port) {
2416: ct.un.ord = ports->misel[i];
2417: error = sc->hw_if->set_port(sc->hw_hdl, &ct);
2418: break;
2419: }
2420: } else {
2421: ct.type = AUDIO_MIXER_SET;
2422: ct.un.mask = 0;
2423: for(i = 0; i < ports->nports; i++)
2424: if (ports->aumask[i] & port)
2425: ct.un.mask |= ports->misel[i];
2426: if (port != 0 && ct.un.mask == 0)
2427: error = EINVAL;
2428: else
2429: error = sc->hw_if->set_port(sc->hw_hdl, &ct);
2430: }
2431: if (!error)
2432: mixer_signal(sc);
2433: return error;
2434: }
2435:
2436: int
2437: au_get_port(struct audio_softc *sc, struct au_mixer_ports *ports)
2438: {
2439: mixer_ctrl_t ct;
2440: int i, aumask;
2441:
2442: if (ports->index == -1)
2443: return 0;
2444: ct.dev = ports->index;
2445: ct.type = ports->isenum ? AUDIO_MIXER_ENUM : AUDIO_MIXER_SET;
2446: if (sc->hw_if->get_port(sc->hw_hdl, &ct))
2447: return 0;
2448: aumask = 0;
2449: if (ports->isenum) {
2450: for(i = 0; i < ports->nports; i++)
2451: if (ct.un.ord == ports->misel[i])
2452: aumask = ports->aumask[i];
2453: } else {
2454: for(i = 0; i < ports->nports; i++)
2455: if (ct.un.mask & ports->misel[i])
2456: aumask |= ports->aumask[i];
2457: }
2458: return aumask;
2459: }
2460:
2461: int
2462: audiosetinfo(struct audio_softc *sc, struct audio_info *ai)
2463: {
2464: struct audio_prinfo *r = &ai->record, *p = &ai->play;
2465: int cleared;
2466: int s, setmode, modechange = 0;
2467: int error;
2468: struct audio_hw_if *hw = sc->hw_if;
2469: struct audio_params pp, rp;
2470: int np, nr;
2471: unsigned int blks;
2472: int oldpblksize, oldrblksize;
2473: int rbus, pbus;
2474: u_int gain;
2475: u_char balance;
2476:
2477: if (hw == 0) /* HW has not attached */
2478: return(ENXIO);
2479:
2480: rbus = sc->sc_rbus;
2481: pbus = sc->sc_pbus;
2482: error = 0;
2483: cleared = 0;
2484:
2485: pp = sc->sc_pparams; /* Temporary encoding storage in */
2486: rp = sc->sc_rparams; /* case setting the modes fails. */
2487: nr = np = 0;
2488:
2489: if (p->sample_rate != ~0) {
2490: pp.sample_rate = p->sample_rate;
2491: np++;
2492: }
2493: if (r->sample_rate != ~0) {
2494: rp.sample_rate = r->sample_rate;
2495: nr++;
2496: }
2497: if (p->encoding != ~0) {
2498: pp.encoding = p->encoding;
2499: np++;
2500: }
2501: if (r->encoding != ~0) {
2502: rp.encoding = r->encoding;
2503: nr++;
2504: }
2505: if (p->precision != ~0) {
2506: pp.precision = p->precision;
2507: np++;
2508: }
2509: if (r->precision != ~0) {
2510: rp.precision = r->precision;
2511: nr++;
2512: }
2513: if (p->channels != ~0) {
2514: pp.channels = p->channels;
2515: np++;
2516: }
2517: if (r->channels != ~0) {
2518: rp.channels = r->channels;
2519: nr++;
2520: }
2521: #ifdef AUDIO_DEBUG
2522: if (audiodebug && nr)
2523: audio_print_params("Setting record params", &rp);
2524: if (audiodebug && np)
2525: audio_print_params("Setting play params", &pp);
2526: #endif
2527: if (nr && (error = audio_check_params(&rp)))
2528: return error;
2529: if (np && (error = audio_check_params(&pp)))
2530: return error;
2531: setmode = 0;
2532: if (nr) {
2533: if (!cleared)
2534: audio_clear(sc);
2535: modechange = cleared = 1;
2536: rp.sw_code = 0;
2537: rp.factor = 1;
2538: setmode |= AUMODE_RECORD;
2539: }
2540: if (np) {
2541: if (!cleared)
2542: audio_clear(sc);
2543: modechange = cleared = 1;
2544: pp.sw_code = 0;
2545: pp.factor = 1;
2546: setmode |= AUMODE_PLAY;
2547: }
2548:
2549: if (ai->mode != ~0) {
2550: if (!cleared)
2551: audio_clear(sc);
2552: modechange = cleared = 1;
2553: sc->sc_mode = ai->mode;
2554: if (sc->sc_mode & AUMODE_PLAY_ALL)
2555: sc->sc_mode |= AUMODE_PLAY;
2556: if ((sc->sc_mode & AUMODE_PLAY) && !sc->sc_full_duplex)
2557: /* Play takes precedence */
2558: sc->sc_mode &= ~AUMODE_RECORD;
2559: }
2560:
2561: if (modechange) {
2562: int indep = hw->get_props(sc->hw_hdl) & AUDIO_PROP_INDEPENDENT;
2563: if (!indep) {
2564: if (setmode == AUMODE_RECORD)
2565: pp = rp;
2566: else if (setmode == AUMODE_PLAY)
2567: rp = pp;
2568: }
2569: error = hw->set_params(sc->hw_hdl, setmode,
2570: sc->sc_mode & (AUMODE_PLAY | AUMODE_RECORD), &pp, &rp);
2571: if (error)
2572: return (error);
2573: if (!indep) {
2574: if (setmode == AUMODE_RECORD) {
2575: pp.sample_rate = rp.sample_rate;
2576: pp.encoding = rp.encoding;
2577: pp.channels = rp.channels;
2578: pp.precision = rp.precision;
2579: } else if (setmode == AUMODE_PLAY) {
2580: rp.sample_rate = pp.sample_rate;
2581: rp.encoding = pp.encoding;
2582: rp.channels = pp.channels;
2583: rp.precision = pp.precision;
2584: }
2585: }
2586: sc->sc_rparams = rp;
2587: sc->sc_pparams = pp;
2588: }
2589:
2590: oldpblksize = sc->sc_pr.blksize;
2591: oldrblksize = sc->sc_rr.blksize;
2592: /* Play params can affect the record params, so recalculate blksize. */
2593: if (nr || np) {
2594: audio_calc_blksize(sc, AUMODE_RECORD);
2595: audio_calc_blksize(sc, AUMODE_PLAY);
2596: }
2597: #ifdef AUDIO_DEBUG
2598: if (audiodebug > 1 && nr)
2599: audio_print_params("After setting record params", &sc->sc_rparams);
2600: if (audiodebug > 1 && np)
2601: audio_print_params("After setting play params", &sc->sc_pparams);
2602: #endif
2603:
2604: if (p->port != ~0) {
2605: if (!cleared)
2606: audio_clear(sc);
2607: cleared = 1;
2608:
2609: error = au_set_port(sc, &sc->sc_outports, p->port);
2610: if (error)
2611: return(error);
2612: }
2613: if (r->port != ~0) {
2614: if (!cleared)
2615: audio_clear(sc);
2616: cleared = 1;
2617:
2618: error = au_set_port(sc, &sc->sc_inports, r->port);
2619: if (error)
2620: return(error);
2621: }
2622: if (p->gain != ~0) {
2623: au_get_gain(sc, &sc->sc_outports, &gain, &balance);
2624: error = au_set_gain(sc, &sc->sc_outports, p->gain, balance);
2625: if (error)
2626: return(error);
2627: }
2628: if (r->gain != ~0) {
2629: au_get_gain(sc, &sc->sc_inports, &gain, &balance);
2630: error = au_set_gain(sc, &sc->sc_inports, r->gain, balance);
2631: if (error)
2632: return(error);
2633: }
2634:
2635: if (p->balance != (u_char)~0) {
2636: au_get_gain(sc, &sc->sc_outports, &gain, &balance);
2637: error = au_set_gain(sc, &sc->sc_outports, gain, p->balance);
2638: if (error)
2639: return(error);
2640: }
2641: if (r->balance != (u_char)~0) {
2642: au_get_gain(sc, &sc->sc_inports, &gain, &balance);
2643: error = au_set_gain(sc, &sc->sc_inports, gain, r->balance);
2644: if (error)
2645: return(error);
2646: }
2647:
2648: if (ai->monitor_gain != ~0 &&
2649: sc->sc_monitor_port != -1) {
2650: mixer_ctrl_t ct;
2651:
2652: ct.dev = sc->sc_monitor_port;
2653: ct.type = AUDIO_MIXER_VALUE;
2654: ct.un.value.num_channels = 1;
2655: ct.un.value.level[AUDIO_MIXER_LEVEL_MONO] = ai->monitor_gain;
2656: error = sc->hw_if->set_port(sc->hw_hdl, &ct);
2657: if (error)
2658: return(error);
2659: }
2660:
2661: if (ai->blocksize != ~0) {
2662: /* Block size specified explicitly. */
2663: if (!cleared)
2664: audio_clear(sc);
2665: cleared = 1;
2666:
2667: if (ai->blocksize == 0) {
2668: audio_calc_blksize(sc, AUMODE_RECORD);
2669: audio_calc_blksize(sc, AUMODE_PLAY);
2670: sc->sc_blkset = 0;
2671: } else {
2672: int rbs = ai->blocksize * sc->sc_rparams.factor;
2673: int pbs = ai->blocksize * sc->sc_pparams.factor;
2674: if (hw->round_blocksize) {
2675: rbs = hw->round_blocksize(sc->hw_hdl, rbs);
2676: pbs = hw->round_blocksize(sc->hw_hdl, pbs);
2677: }
2678: sc->sc_rr.blksize = rbs;
2679: sc->sc_pr.blksize = pbs;
2680: sc->sc_blkset = 1;
2681: }
2682: }
2683:
2684: if (ai->mode != ~0) {
2685: if (sc->sc_mode & AUMODE_PLAY)
2686: audio_init_play(sc);
2687: if (sc->sc_mode & AUMODE_RECORD)
2688: audio_init_record(sc);
2689: }
2690:
2691: if (hw->commit_settings) {
2692: error = hw->commit_settings(sc->hw_hdl);
2693: if (error)
2694: return (error);
2695: }
2696:
2697: if (cleared) {
2698: s = splaudio();
2699: error = audio_initbufs(sc);
2700: if (error) goto err;
2701: if (sc->sc_pr.blksize != oldpblksize ||
2702: sc->sc_rr.blksize != oldrblksize)
2703: audio_calcwater(sc);
2704: if ((sc->sc_mode & AUMODE_PLAY) &&
2705: pbus && !sc->sc_pbus && !sc->sc_pr.pause)
2706: error = audiostartp(sc);
2707: if (!error &&
2708: (sc->sc_mode & AUMODE_RECORD) &&
2709: rbus && !sc->sc_rbus && !sc->sc_rr.pause)
2710: error = audiostartr(sc);
2711: err:
2712: splx(s);
2713: if (error)
2714: return error;
2715: }
2716:
2717: /* Change water marks after initializing the buffers. */
2718: if (ai->hiwat != ~0) {
2719: blks = ai->hiwat;
2720: if (blks > sc->sc_pr.maxblks)
2721: blks = sc->sc_pr.maxblks;
2722: if (blks < 2)
2723: blks = 2;
2724: sc->sc_pr.usedhigh = blks * sc->sc_pr.blksize;
2725: }
2726: if (ai->lowat != ~0) {
2727: blks = ai->lowat;
2728: if (blks > sc->sc_pr.maxblks - 1)
2729: blks = sc->sc_pr.maxblks - 1;
2730: sc->sc_pr.usedlow = blks * sc->sc_pr.blksize;
2731: }
2732: if (ai->hiwat != ~0 || ai->lowat != ~0) {
2733: if (sc->sc_pr.usedlow > sc->sc_pr.usedhigh - sc->sc_pr.blksize)
2734: sc->sc_pr.usedlow = sc->sc_pr.usedhigh - sc->sc_pr.blksize;
2735: }
2736:
2737: if (p->pause != (u_char)~0) {
2738: sc->sc_pr.pause = p->pause;
2739: if (!p->pause && !sc->sc_pbus && (sc->sc_mode & AUMODE_PLAY)) {
2740: s = splaudio();
2741: error = audiostartp(sc);
2742: splx(s);
2743: if (error)
2744: return error;
2745: }
2746: }
2747: if (r->pause != (u_char)~0) {
2748: sc->sc_rr.pause = r->pause;
2749: if (!r->pause && !sc->sc_rbus && (sc->sc_mode & AUMODE_RECORD)) {
2750: s = splaudio();
2751: error = audiostartr(sc);
2752: splx(s);
2753: if (error)
2754: return error;
2755: }
2756: }
2757:
2758: return (0);
2759: }
2760:
2761: int
2762: audiogetinfo(struct audio_softc *sc, struct audio_info *ai)
2763: {
2764: struct audio_prinfo *r = &ai->record, *p = &ai->play;
2765: struct audio_hw_if *hw = sc->hw_if;
2766:
2767: if (hw == 0) /* HW has not attached */
2768: return(ENXIO);
2769:
2770: p->sample_rate = sc->sc_pparams.sample_rate;
2771: r->sample_rate = sc->sc_rparams.sample_rate;
2772: p->channels = sc->sc_pparams.channels;
2773: r->channels = sc->sc_rparams.channels;
2774: p->precision = sc->sc_pparams.precision;
2775: r->precision = sc->sc_rparams.precision;
2776: p->encoding = sc->sc_pparams.encoding;
2777: r->encoding = sc->sc_rparams.encoding;
2778:
2779: r->port = au_get_port(sc, &sc->sc_inports);
2780: p->port = au_get_port(sc, &sc->sc_outports);
2781:
2782: r->avail_ports = sc->sc_inports.allports;
2783: p->avail_ports = sc->sc_outports.allports;
2784:
2785: au_get_gain(sc, &sc->sc_inports, &r->gain, &r->balance);
2786: au_get_gain(sc, &sc->sc_outports, &p->gain, &p->balance);
2787:
2788: if (sc->sc_monitor_port != -1) {
2789: mixer_ctrl_t ct;
2790:
2791: ct.dev = sc->sc_monitor_port;
2792: ct.type = AUDIO_MIXER_VALUE;
2793: ct.un.value.num_channels = 1;
2794: if (sc->hw_if->get_port(sc->hw_hdl, &ct))
2795: ai->monitor_gain = 0;
2796: else
2797: ai->monitor_gain =
2798: ct.un.value.level[AUDIO_MIXER_LEVEL_MONO];
2799: } else
2800: ai->monitor_gain = 0;
2801:
2802: p->seek = sc->sc_pr.used / sc->sc_pparams.factor;
2803: r->seek = sc->sc_rr.used / sc->sc_rparams.factor;
2804:
2805: p->samples = sc->sc_pr.stamp - sc->sc_pr.drops;
2806: r->samples = sc->sc_rr.stamp - sc->sc_rr.drops;
2807:
2808: p->eof = sc->sc_eof;
2809: r->eof = 0;
2810:
2811: p->pause = sc->sc_pr.pause;
2812: r->pause = sc->sc_rr.pause;
2813:
2814: p->error = sc->sc_pr.drops != 0;
2815: r->error = sc->sc_rr.drops != 0;
2816:
2817: p->waiting = r->waiting = 0; /* open never hangs */
2818:
2819: p->open = (sc->sc_open & AUOPEN_WRITE) != 0;
2820: r->open = (sc->sc_open & AUOPEN_READ) != 0;
2821:
2822: p->active = sc->sc_pbus;
2823: r->active = sc->sc_rbus;
2824:
2825: p->buffer_size = sc->sc_pr.bufsize / sc->sc_pparams.factor;
2826: r->buffer_size = sc->sc_rr.bufsize / sc->sc_rparams.factor;
2827:
2828: if ((ai->blocksize = sc->sc_pr.blksize / sc->sc_pparams.factor) != 0) {
2829: ai->hiwat = sc->sc_pr.usedhigh / sc->sc_pr.blksize;
2830: ai->lowat = sc->sc_pr.usedlow / sc->sc_pr.blksize;
2831: } else {
2832: ai->hiwat = ai->lowat = 0;
2833: }
2834: ai->mode = sc->sc_mode;
2835:
2836: return (0);
2837: }
2838:
2839: /*
2840: * Mixer driver
2841: */
2842: int
2843: mixer_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
2844: struct proc *p)
2845: {
2846: DPRINTF(("mixer_open: dev=0x%x flags=0x%x sc=%p\n", dev, flags, sc));
2847:
2848: return (0);
2849: }
2850:
2851: /*
2852: * Remove a process from those to be signalled on mixer activity.
2853: */
2854: static void
2855: mixer_remove(struct audio_softc *sc, struct proc *p)
2856: {
2857: struct mixer_asyncs **pm, *m;
2858:
2859: for(pm = &sc->sc_async_mixer; *pm; pm = &(*pm)->next) {
2860: if ((*pm)->proc == p) {
2861: m = *pm;
2862: *pm = m->next;
2863: free(m, M_DEVBUF);
2864: return;
2865: }
2866: }
2867: }
2868:
2869: /*
2870: * Signal all processes waitinf for the mixer.
2871: */
2872: static void
2873: mixer_signal(struct audio_softc *sc)
2874: {
2875: struct mixer_asyncs *m;
2876:
2877: for(m = sc->sc_async_mixer; m; m = m->next)
2878: psignal(m->proc, SIGIO);
2879: }
2880:
2881: /*
2882: * Close a mixer device
2883: */
2884: /* ARGSUSED */
2885: int
2886: mixer_close(dev_t dev, int flags, int ifmt, struct proc *p)
2887: {
2888: int unit = AUDIOUNIT(dev);
2889: struct audio_softc *sc = audio_cd.cd_devs[unit];
2890:
2891: DPRINTF(("mixer_close: unit %d\n", AUDIOUNIT(dev)));
2892:
2893: mixer_remove(sc, p);
2894:
2895: return (0);
2896: }
2897:
2898: int
2899: mixer_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
2900: {
2901: int unit = AUDIOUNIT(dev);
2902: struct audio_softc *sc = audio_cd.cd_devs[unit];
2903: struct audio_hw_if *hw = sc->hw_if;
2904: int error = EINVAL;
2905:
2906: DPRINTF(("mixer_ioctl(%d,'%c',%d)\n",
2907: IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff));
2908:
2909: switch (cmd) {
2910: case FIOASYNC:
2911: mixer_remove(sc, p); /* remove old entry */
2912: if (*(int *)addr) {
2913: struct mixer_asyncs *ma;
2914: ma = malloc(sizeof (struct mixer_asyncs),
2915: M_DEVBUF, M_WAITOK);
2916: ma->next = sc->sc_async_mixer;
2917: ma->proc = p;
2918: sc->sc_async_mixer = ma;
2919: }
2920: error = 0;
2921: break;
2922:
2923: case AUDIO_GETDEV:
2924: DPRINTF(("AUDIO_GETDEV\n"));
2925: error = hw->getdev(sc->hw_hdl, (audio_device_t *)addr);
2926: break;
2927:
2928: case AUDIO_MIXER_DEVINFO:
2929: DPRINTF(("AUDIO_MIXER_DEVINFO\n"));
2930: ((mixer_devinfo_t *)addr)->un.v.delta = 0; /* default */
2931: error = hw->query_devinfo(sc->hw_hdl, (mixer_devinfo_t *)addr);
2932: break;
2933:
2934: case AUDIO_MIXER_READ:
2935: DPRINTF(("AUDIO_MIXER_READ\n"));
2936: error = hw->get_port(sc->hw_hdl, (mixer_ctrl_t *)addr);
2937: break;
2938:
2939: case AUDIO_MIXER_WRITE:
2940: if (!(flag & FWRITE))
2941: return (EACCES);
2942: DPRINTF(("AUDIO_MIXER_WRITE\n"));
2943: error = hw->set_port(sc->hw_hdl, (mixer_ctrl_t *)addr);
2944: if (!error && hw->commit_settings)
2945: error = hw->commit_settings(sc->hw_hdl);
2946: if (!error)
2947: mixer_signal(sc);
2948: break;
2949:
2950: default:
2951: error = ENOTTY;
2952: break;
2953: }
2954: DPRINTF(("mixer_ioctl(%d,'%c',%d) result %d\n",
2955: IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff, error));
2956: return (error);
2957: }
2958: #endif
2959:
2960: int
2961: audiokqfilter(dev_t dev, struct knote *kn)
2962: {
2963: int unit = AUDIOUNIT(dev);
2964: struct audio_softc *sc = audio_cd.cd_devs[unit];
2965: struct klist *klist;
2966: int s;
2967:
2968: switch (kn->kn_filter) {
2969: case EVFILT_READ:
2970: klist = &sc->sc_rsel.si_note;
2971: kn->kn_fop = &audioread_filtops;
2972: break;
2973: case EVFILT_WRITE:
2974: klist = &sc->sc_wsel.si_note;
2975: kn->kn_fop = &audiowrite_filtops;
2976: break;
2977: default:
2978: return (1);
2979: }
2980: kn->kn_hook = (void *)sc;
2981:
2982: s = splaudio();
2983: SLIST_INSERT_HEAD(klist, kn, kn_selnext);
2984: splx(s);
2985:
2986: return (0);
2987: }
2988:
2989: void
2990: filt_audiordetach(struct knote *kn)
2991: {
2992: struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
2993: int s = splaudio();
2994:
2995: SLIST_REMOVE(&sc->sc_rsel.si_note, kn, knote, kn_selnext);
2996: splx(s);
2997: }
2998:
2999: int
3000: filt_audioread(struct knote *kn, long hint)
3001: {
3002: struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
3003:
3004: return AUDIO_FILTREAD(sc);
3005: }
3006:
3007: void
3008: filt_audiowdetach(struct knote *kn)
3009: {
3010: struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
3011: int s = splaudio();
3012:
3013: SLIST_REMOVE(&sc->sc_wsel.si_note, kn, knote, kn_selnext);
3014: splx(s);
3015: }
3016:
3017: int
3018: filt_audiowrite(struct knote *kn, long hint)
3019: {
3020: struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
3021:
3022: return AUDIO_FILTWRITE(sc);
3023: }
3024:
3025: #if NAUDIO > 0 && NWSKBD > 0
3026: int
3027: wskbd_get_mixerdev(struct audio_softc *sc, int dir, int *index)
3028: {
3029: mixer_devinfo_t mi;
3030: int mixer_class;
3031: int error;
3032:
3033: /* looking for ``outputs'' */
3034: for (mi.index = 0; ; mi.index++) {
3035: error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
3036: if (error != 0)
3037: return (-1);
3038:
3039: if (mi.type == AUDIO_MIXER_CLASS &&
3040: strcmp(mi.label.name, AudioCoutputs) == 0) {
3041: mixer_class = mi.mixer_class;
3042: break;
3043: }
3044: }
3045:
3046: /*
3047: * looking for ``outputs.master''
3048: * start mi.index from 0 because ''outputs.master'' can precede
3049: * ''outputs''.
3050: */
3051: for (mi.index = 0; ; mi.index++) {
3052: error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
3053: if (error != 0)
3054: return (-1);
3055:
3056: if (mi.type == AUDIO_MIXER_VALUE &&
3057: mi.mixer_class == mixer_class &&
3058: strcmp(mi.label.name, AudioNmaster) == 0) {
3059: if (dir == 0) {
3060: /* looking for ``outputs.master.mute'' */
3061: if (mi.next < 0)
3062: return (-1);
3063:
3064: mi.index = mi.next;
3065: error = sc->hw_if->query_devinfo(sc->hw_hdl,
3066: &mi);
3067: if (error != 0)
3068: return (-1);
3069:
3070: if (mi.type != AUDIO_MIXER_ENUM ||
3071: strcmp(mi.label.name, AudioNmute) != 0)
3072: return (-1);
3073: }
3074:
3075: *index = mi.index;
3076: return (0);
3077: }
3078: }
3079:
3080: return (-1);
3081: }
3082:
3083: int
3084: wskbd_set_mixervolume(long dir)
3085: {
3086: struct audio_softc *sc;
3087: mixer_devinfo_t mi;
3088: mixer_ctrl_t ct;
3089: int l, r;
3090: int error;
3091:
3092: if (audio_cd.cd_ndevs == 0 || (sc = audio_cd.cd_devs[0]) == NULL) {
3093: DPRINTF(("wskbd_set_mixervolume: audio_cd\n"));
3094: return (ENXIO);
3095: }
3096:
3097: error = wskbd_get_mixerdev(sc, dir, &ct.dev);
3098: if (error == -1) {
3099: DPRINTF(("wskbd_set_mixervolume: wskbd_get_mixerdev\n"));
3100: return (ENXIO);
3101: }
3102:
3103: if (dir == 0) {
3104: /*
3105: * Mute.
3106: * Use mixer_ioctl() for writing. It does many things for us.
3107: */
3108: ct.type = AUDIO_MIXER_ENUM;
3109: error = sc->hw_if->get_port(sc->hw_hdl, &ct);
3110: if (error != 0) {
3111: DPRINTF(("wskbd_set_mixervolume:"
3112: " get_port: %d\n", error));
3113: return (error);
3114: }
3115:
3116: ct.un.ord = !ct.un.ord; /* toggle */
3117:
3118: error = mixer_ioctl(MIXER_DEVICE,
3119: AUDIO_MIXER_WRITE, (caddr_t)&ct, FWRITE, curproc);
3120: if (error != 0) {
3121: DPRINTF(("wskbd_set_mixervolume:"
3122: " mixer_ioctl: %d\n", error));
3123: return (error);
3124: }
3125: } else {
3126: mi.index = ct.dev;
3127: error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
3128: if (error != 0) {
3129: DPRINTF(("wskbd_set_mixervolume:"
3130: " query_devinfo: %d\n", error));
3131: return (error);
3132: }
3133:
3134: ct.type = AUDIO_MIXER_VALUE;
3135:
3136: error = au_get_lr_value(sc, &ct, &l, &r);
3137: if (error != 0) {
3138: DPRINTF(("wskbd_set_mixervolume:"
3139: " au_get_lr_value: %d\n", error));
3140: return (error);
3141: }
3142:
3143: if (dir > 0) {
3144: /*
3145: * Raise volume
3146: */
3147: if (l > AUDIO_MAX_GAIN - mi.un.v.delta)
3148: l = AUDIO_MAX_GAIN;
3149: else
3150: l += mi.un.v.delta;
3151:
3152: if (r > AUDIO_MAX_GAIN - mi.un.v.delta)
3153: r = AUDIO_MAX_GAIN;
3154: else
3155: r += mi.un.v.delta;
3156:
3157: } else {
3158: /*
3159: * Lower volume
3160: */
3161: if (l < AUDIO_MIN_GAIN + mi.un.v.delta)
3162: l = AUDIO_MIN_GAIN;
3163: else
3164: l -= mi.un.v.delta;
3165:
3166: if (r < AUDIO_MIN_GAIN + mi.un.v.delta)
3167: r = AUDIO_MIN_GAIN;
3168: else
3169: r -= mi.un.v.delta;
3170: }
3171:
3172: error = au_set_lr_value(sc, &ct, l, r);
3173: if (error != 0) {
3174: DPRINTF(("wskbd_set_mixervolume:"
3175: " au_set_lr_value: %d\n", error));
3176: return (error);
3177: }
3178: }
3179:
3180: return (0);
3181: }
3182: #endif /* NAUDIO > 0 && NWSKBD > 0 */