root/dev/audio.c

DEFINITIONS

1. audioprobe
2. audioattach
3. audioactivate
4. audiodetach
5. au_portof
6. au_check_ports
7. audio_attach_mi
8. audioprint
9. audio_printsc
10. audio_print_params
11. audio_alloc_ring
12. audio_free_ring
13. audioopen
14. audioclose
15. audioread
16. audiowrite
17. audioioctl
18. audiopoll
19. audiommap
20. audio_init_ringbuffer
21. audio_initbufs
22. audio_calcwater
23. audio_sleep_timo
24. audio_sleep
25. audio_wakeup
26. audio_open
27. audio_init_record
28. audio_init_play
29. audio_drain
30. audio_close
31. audio_read
32. audio_clear
33. audio_calc_blksize
34. audio_fill_silence
35. audio_silence_copyout
36. audio_write
37. audio_ioctl
38. audio_selwakeup
39. audio_poll
40. audio_mmap
41. audiostartr
42. audiostartp
43. audio_pint_silence
44. audio_pint
45. audio_rint
46. audio_check_params
47. au_set_lr_value
48. au_set_gain
49. au_get_lr_value
50. au_get_gain
51. au_set_port
52. au_get_port
53. audiosetinfo
54. audiogetinfo
55. mixer_open
56. mixer_remove
57. mixer_signal
58. mixer_close
59. mixer_ioctl
60. audiokqfilter
61. filt_audiordetach
62. filt_audioread
63. filt_audiowdetach
64. filt_audiowrite
65. wskbd_get_mixerdev
66. wskbd_set_mixervolume

    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 $     */
    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  */
   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  */
   58 /*
   59  * Todo:
   60  * - Add softaudio() isr processing for wakeup, poll, signals,
   61  *   and silence fill.
   62  */
   64 #include "audio.h"
   65 #if NAUDIO > 0
   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>
   83 #include <dev/audio_if.h>
   84 #include <dev/audiovar.h>
   86 #include <dev/rndvar.h>
   88 #include <machine/endian.h>
   90 #include "wskbd.h"      /* NWSKBD (mixer tuning using keyboard) */
   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
  101 #define ROUNDSIZE(x) x &= -16   /* round to nice boundary */
  103 int     audio_blk_ms = AUDIO_BLK_MS;
  105 int     audiosetinfo(struct audio_softc *, struct audio_info *);
  106 int     audiogetinfo(struct audio_softc *, struct audio_info *);
  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 *);
paddr_t audio_mmap(dev_t, off_t, int);
  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 *);
  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 *);
  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 *);
  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);
  145 int     audio_alloc_ring(struct audio_softc *, struct audio_ringbuffer *, int, int);
  146 void    audio_free_ring(struct audio_softc *, struct audio_ringbuffer *);
  148 int     audioprint(void *, const char *);
  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);
  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 *,
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 *,
u_int *, u_char *);
  178 int     au_set_port(struct audio_softc *, struct au_mixer_ports *,
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 *);
  188 /* The default audio mode: 8 kHz mono ulaw */
  189 struct audio_params audio_default =
  190         { 8000, AUDIO_ENCODING_ULAW, 8, 1, 0, 1 };
  192 struct cfattach audio_ca = {
  193         sizeof(struct audio_softc), audioprobe, audioattach,
audiodetach, audioactivate
  195 };
  197 struct cfdriver audio_cd = {
NULL, "audio", DV_DULL
  199 };
  201 void filt_audiowdetach(struct knote *);
  202 int filt_audiowrite(struct knote *, long);
  204 struct filterops audiowrite_filtops =
  205         { 1, NULL, filt_audiowdetach, filt_audiowrite};
  207 void filt_audiordetach(struct knote *);
  208 int filt_audioread(struct knote *, long);
  210 struct filterops audioread_filtops =
  211         { 1, NULL, filt_audiordetach, filt_audioread};
  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
  219 int
audioprobe(struct device *parent, void *match, void *aux)
  221 {
  222         struct audio_attach_args *sa = aux;
DPRINTF(("audioprobe: type=%d sa=%p hw=%p\n",
sa->type, sa, sa->hwif));
  226         return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0;
  227 }
  229 void
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;
mixer_devinfo_t mi;
  238         int iclass, oclass, mclass;
printf("\n");
  242 #ifdef DIAGNOSTIC
  243         if (hwp == 0 ||
hwp->open == 0 ||
hwp->close == 0 ||
hwp->query_encoding == 0 ||
hwp->set_params == 0 ||
  248             (hwp->start_output == 0 && hwp->trigger_output == 0) ||
  249             (hwp->start_input == 0 && hwp->trigger_input == 0) ||
hwp->halt_output == 0 ||
hwp->halt_input == 0 ||
hwp->getdev == 0 ||
hwp->set_port == 0 ||
hwp->get_port == 0 ||
hwp->query_devinfo == 0 ||
hwp->get_props == 0) {
printf("audio: missing method\n");
sc->hw_if = 0;
  259                 return;
  260         }
  261 #endif
sc->hw_if = hwp;
sc->hw_hdl = hdlp;
sc->sc_dev = parent;
error = audio_alloc_ring(sc, &sc->sc_pr, AUMODE_PLAY, AU_RING_SIZE);
  268         if (error) {
sc->hw_if = 0;
printf("audio: could not allocate play buffer\n");
  271                 return;
  272         }
error = audio_alloc_ring(sc, &sc->sc_rr, AUMODE_RECORD, AU_RING_SIZE);
  274         if (error) {
audio_free_ring(sc, &sc->sc_pr);
sc->hw_if = 0;
printf("audio: could not allocate record buffer\n");
  278                 return;
  279         }
  281         /*
  282          * Set default softc params
  283          */
sc->sc_pparams = audio_default;
sc->sc_rparams = audio_default;
  287         /* Set up some default values */
sc->sc_blkset = 0;
audio_calc_blksize(sc, AUMODE_RECORD);
audio_calc_blksize(sc, AUMODE_PLAY);
audio_init_ringbuffer(&sc->sc_rr);
audio_init_ringbuffer(&sc->sc_pr);
audio_calcwater(sc);
iclass = oclass = mclass = -1;
sc->sc_inports.index = -1;
sc->sc_inports.nports = 0;
sc->sc_inports.isenum = 0;
sc->sc_inports.allports = 0;
sc->sc_outports.index = -1;
sc->sc_outports.nports = 0;
sc->sc_outports.isenum = 0;
sc->sc_outports.allports = 0;
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 &&
strcmp(mi.label.name, AudioCrecord) == 0)
iclass = mi.index;
  311                 if (mi.type == AUDIO_MIXER_CLASS &&
strcmp(mi.label.name, AudioCmonitor) == 0)
mclass = mi.index;
  314                 if (mi.type == AUDIO_MIXER_CLASS &&
strcmp(mi.label.name, AudioCoutputs) == 0)
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;
au_check_ports(sc, &sc->sc_inports,  &mi, iclass,
AudioNsource, AudioNrecord, itable);
au_check_ports(sc, &sc->sc_outports, &mi, oclass,
AudioNoutput, AudioNmaster, otable);
  327                 if (mi.mixer_class == mclass &&
  328                     (strcmp(mi.label.name, AudioNmonitor) == 0))
sc->sc_monitor_port = mi.index;
  330                 if ((sc->sc_monitor_port == -1) && (mi.mixer_class == oclass) &&
  331                     (strcmp(mi.label.name, AudioNmonitor) == 0))
sc->sc_monitor_port = mi.index;
  333         }
DPRINTF(("audio_attach: inputs ports=0x%x, output ports=0x%x\n",
sc->sc_inports.allports, sc->sc_outports.allports));
  336 }
  338 int
audioactivate(struct device *self, enum devact act)
  340 {
  341         struct audio_softc *sc = (struct audio_softc *)self;
  343         switch (act) {
  344         case DVACT_ACTIVATE:
  345                 break;
  347         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  349                 break;
  350         }
  351         return (0);
  352 }
  354 int
audiodetach(struct device *self, int flags)
  356 {
  357         struct audio_softc *sc = (struct audio_softc *)self;
  358         int maj, mn;
  359         int s;
DPRINTF(("audio_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
wakeup(&sc->sc_wchan);
wakeup(&sc->sc_rchan);
s = splaudio();
  368         if (--sc->sc_refcnt >= 0) {
  369                 if (tsleep(&sc->sc_refcnt, PZERO, "auddet", hz * 120))
printf("audiodetach: %s didn't detach\n",
sc->dev.dv_xname);
  372         }
splx(s);
  375         /* free resources */
audio_free_ring(sc, &sc->sc_pr);
audio_free_ring(sc, &sc->sc_rr);
  379         /* locate the major number */
  380         for (maj = 0; maj < nchrdev; maj++)
  381                 if (cdevsw[maj].d_open == audioopen)
  382                         break;
  384         /* Nuke the vnodes for any open instances (calls close). */
mn = self->dv_unit;
vdevgone(maj, mn | SOUND_DEVICE,    mn | SOUND_DEVICE, VCHR);
vdevgone(maj, mn | AUDIO_DEVICE,    mn | AUDIO_DEVICE, VCHR);
vdevgone(maj, mn | AUDIOCTL_DEVICE, mn | AUDIOCTL_DEVICE, VCHR);
vdevgone(maj, mn | MIXER_DEVICE,    mn | MIXER_DEVICE, VCHR);
  391         return (0);
  392 }
  394 int
au_portof(struct audio_softc *sc, char *name)
  396 {
mixer_devinfo_t mi;
  399         for(mi.index = 0;
sc->hw_if->query_devinfo(sc->hw_hdl, &mi) == 0;
mi.index++)
  402                 if (strcmp(mi.label.name, name) == 0)
  403                         return mi.index;
  404         return -1;
  405 }
  407 void
au_check_ports(struct audio_softc *sc, struct au_mixer_ports *ports,
mixer_devinfo_t *mi, int cls, char *name, char *mname, struct portname *tbl)
  410 {
  411         int i, j;
  413         if (mi->mixer_class != cls)
  414                 return;
  415         if (strcmp(mi->label.name, mname) == 0) {
ports->master = mi->index;
  417                 return;
  418         }
  419         if (strcmp(mi->label.name, name) != 0)
  420                 return;
  421         if (mi->type == AUDIO_MIXER_ENUM) {
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,
tbl[i].name) == 0) {
ports->aumask[ports->nports] = tbl[i].mask;
ports->misel [ports->nports] = mi->un.e.member[j].ord;
ports->miport[ports->nports++] =
au_portof(sc, mi->un.e.member[j].label.name);
ports->allports |= tbl[i].mask;
  432                     }
  433                 }
  434             }
ports->isenum = 1;
  436         } else if (mi->type == AUDIO_MIXER_SET) {
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,
tbl[i].name) == 0) {
ports->aumask[ports->nports] = tbl[i].mask;
ports->misel [ports->nports] = mi->un.s.member[j].mask;
ports->miport[ports->nports++] =
au_portof(sc, mi->un.s.member[j].label.name);
ports->allports |= tbl[i].mask;
  447                     }
  448                 }
  449             }
  450         }
  451 }
  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 *
audio_attach_mi(struct audio_hw_if *ahwp, void *hdlp, struct device *dev)
  459 {
  460         struct audio_attach_args arg;
  462 #ifdef DIAGNOSTIC
  463         if (ahwp == NULL) {
printf ("audio_attach_mi: NULL\n");
  465                 return 0;
  466         }
  467 #endif
arg.type = AUDIODEV_TYPE_AUDIO;
arg.hwif = ahwp;
arg.hdl = hdlp;
  472         return config_found(dev, &arg, audioprint);
  473 }
  475 #if NAUDIO > 0
  476 int
audioprint(void *aux, const char *pnp)
  478 {
  479         struct audio_attach_args *arg = aux;
  480         const char *type;
  482         if (pnp != NULL) {
  483                 switch (arg->type) {
  484                 case AUDIODEV_TYPE_AUDIO:
type = "audio";
  486                         break;
  487                 case AUDIODEV_TYPE_OPL:
type = "opl";
  489                         break;
  490                 case AUDIODEV_TYPE_MPU:
type = "mpu";
  492                         break;
  493                 default:
panic("audioprint: unknown type %d", arg->type);
  495                 }
printf("%s at %s", type, pnp);
  497         }
  498         return (UNCONF);
  499 }
  501 #endif /* NAUDIO > 0 */
  503 #ifdef AUDIO_DEBUG
  504 void    audio_printsc(struct audio_softc *);
  505 void    audio_print_params(char *, struct audio_params *);
  507 void
audio_printsc(struct audio_softc *sc)
  509 {
printf("hwhandle %p hw_if %p ", sc->hw_hdl, sc->hw_if);
printf("open 0x%x mode 0x%x\n", sc->sc_open, sc->sc_mode);
printf("rchan 0x%x wchan 0x%x ", sc->sc_rchan, sc->sc_wchan);
printf("rring used 0x%x pring used=%d\n", sc->sc_rr.used, sc->sc_pr.used);
printf("rbus 0x%x pbus 0x%x ", sc->sc_rbus, sc->sc_pbus);
printf("blksize %d", sc->sc_pr.blksize);
printf("hiwat %d lowat %d\n", sc->sc_pr.usedhigh, sc->sc_pr.usedlow);
  517 }
  519 void
audio_print_params(char *s, struct audio_params *p)
  521 {
printf("audio: %s sr=%ld, enc=%d, chan=%d, prec=%d\n", s,
p->sample_rate, p->encoding, p->channels, p->precision);
  524 }
  525 #endif
  527 int
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)
bufsize = AUMINBUF;
ROUNDSIZE(bufsize);
  539         if (hw->round_buffersize)
bufsize = hw->round_buffersize(hdl, direction, bufsize);
r->bufsize = bufsize;
  542         if (hw->allocm)
r->start = hw->allocm(hdl, direction, r->bufsize, M_DEVBUF,
M_WAITOK);
  545         else
r->start = malloc(bufsize, M_DEVBUF, M_WAITOK);
  547         if (r->start == 0)
  548                 return ENOMEM;
  549         return 0;
  550 }
  552 void
audio_free_ring(struct audio_softc *sc, struct audio_ringbuffer *r)
  554 {
  555         if (sc->hw_if->freem) {
sc->hw_if->freem(sc->hw_hdl, r->start, M_DEVBUF);
  557         } else {
free(r->start, M_DEVBUF);
  559         }
  560 }
  562 int
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;
  569         if (unit >= audio_cd.cd_ndevs ||
  570             (sc = audio_cd.cd_devs[unit]) == NULL)
  571                 return ENXIO;
  573         if (sc->sc_dying)
  574                 return (EIO);
  576         if (!sc->hw_if)
  577                 return (ENXIO);
sc->sc_refcnt ++;
  580         switch (AUDIODEV(dev)) {
  581         case SOUND_DEVICE:
  582         case AUDIO_DEVICE:
  583         case AUDIOCTL_DEVICE:
error = audio_open(dev, sc, flags, ifmt, p);
  585                 break;
  586         case MIXER_DEVICE:
error = mixer_open(dev, sc, flags, ifmt, p);
  588                 break;
  589         default:
error = ENXIO;
  591                 break;
  592         }
  594         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  597         return (error);
  598 }
  600 int
  601 audioclose(dev_t dev, int flags, int ifmt, struct proc *p)
  602 {
  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 }
  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;
  624         if (unit >= audio_cd.cd_ndevs ||
  625             (sc = audio_cd.cd_devs[unit]) == NULL)
  626                 return ENXIO;
  628         if (sc->sc_dying)
  629                 return (EIO);
sc->sc_refcnt ++;
  632         switch (AUDIODEV(dev)) {
  633         case SOUND_DEVICE:
  634         case AUDIO_DEVICE:
error = audio_read(dev, uio, ioflag);
  636                 break;
  637         case AUDIOCTL_DEVICE:
  638         case MIXER_DEVICE:
error = ENODEV;
  640                 break;
  641         default:
error = ENXIO;
  643                 break;
  644         }
  646         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  648         return (error);
  649 }
  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;
  658         if (unit >= audio_cd.cd_ndevs ||
  659             (sc = audio_cd.cd_devs[unit]) == NULL)
  660                 return ENXIO;
  662         if (sc->sc_dying)
  663                 return (EIO);
sc->sc_refcnt ++;
  666         switch (AUDIODEV(dev)) {
  667         case SOUND_DEVICE:
  668         case AUDIO_DEVICE:
error = audio_write(dev, uio, ioflag);
  670                 break;
  671         case AUDIOCTL_DEVICE:
  672         case MIXER_DEVICE:
error = ENODEV;
  674                 break;
  675         default:
error = ENXIO;
  677                 break;
  678         }
  680         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  682         return (error);
  683 }
  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;
  692         if (unit >= audio_cd.cd_ndevs ||
  693             (sc = audio_cd.cd_devs[unit]) == NULL)
  694                 return ENXIO;
  696         if (sc->sc_dying)
  697                 return (EIO);
sc->sc_refcnt ++;
  700         switch (AUDIODEV(dev)) {
  701         case SOUND_DEVICE:
  702         case AUDIO_DEVICE:
  703         case AUDIOCTL_DEVICE:
error = audio_ioctl(dev, cmd, addr, flag, p);
  705                 break;
  706         case MIXER_DEVICE:
error = mixer_ioctl(dev, cmd, addr, flag, p);
  708                 break;
  709         default:
error = ENXIO;
  711                 break;
  712         }
  714         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  716         return (error);
  717 }
  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;
  726         if (unit >= audio_cd.cd_ndevs ||
  727             (sc = audio_cd.cd_devs[unit]) == NULL)
  728                 return POLLERR;
  730         if (sc->sc_dying)
  731                 return POLLERR;
sc->sc_refcnt ++;
  734         switch (AUDIODEV(dev)) {
  735         case SOUND_DEVICE:
  736         case AUDIO_DEVICE:
error = audio_poll(dev, events, p);
  738                 break;
  739         case AUDIOCTL_DEVICE:
  740         case MIXER_DEVICE:
error = 0;
  742                 break;
  743         default:
error = 0;
  745                 break;
  746         }
  748         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  750         return (error);
  751 }
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;
  760         if (unit >= audio_cd.cd_ndevs ||
  761             (sc = audio_cd.cd_devs[unit]) == NULL)
  762                 return (-1);
  764         if (sc->sc_dying)
  765                 return (-1);
sc->sc_refcnt ++;
  768         switch (AUDIODEV(dev)) {
  769         case SOUND_DEVICE:
  770         case AUDIO_DEVICE:
ret = audio_mmap(dev, off, prot);
  772                 break;
  773         case AUDIOCTL_DEVICE:
  774         case MIXER_DEVICE:
ret = -1;
  776                 break;
  777         default:
ret = -1;
  779                 break;
  780         }
  782         if (--sc->sc_refcnt < 0)
wakeup(&sc->sc_refcnt);
  784         return (ret);
  785 }
  787 /*
  788  * Audio driver
  789  */
  790 void
audio_init_ringbuffer(struct audio_ringbuffer *rp)
  792 {
  793         int nblks;
  794         int blksize = rp->blksize;
  796         if (blksize < AUMINBLK)
blksize = AUMINBLK;
nblks = rp->bufsize / blksize;
  799         if (nblks < AUMINNOBLK) {
nblks = AUMINNOBLK;
blksize = rp->bufsize / nblks;
ROUNDSIZE(blksize);
  803         }
DPRINTF(("audio_init_ringbuffer: blksize=%d\n", blksize));
rp->blksize = blksize;
rp->maxblks = nblks;
rp->used = 0;
rp->end = rp->start + nblks * blksize;
rp->inp = rp->outp = rp->start;
rp->stamp = 0;
rp->stamp_last = 0;
rp->drops = 0;
rp->pdrops = 0;
rp->copying = 0;
rp->needfill = 0;
rp->mmapped = 0;
  817 }
  819 int
audio_initbufs(struct audio_softc *sc)
  821 {
  822         struct audio_hw_if *hw = sc->hw_if;
  823         int error;
DPRINTF(("audio_initbufs: mode=0x%x\n", sc->sc_mode));
audio_init_ringbuffer(&sc->sc_rr);
  827         if (hw->init_input && (sc->sc_mode & AUMODE_RECORD)) {
error = hw->init_input(sc->hw_hdl, sc->sc_rr.start,
sc->sc_rr.end - sc->sc_rr.start);
  830                 if (error)
  831                         return error;
  832         }
audio_init_ringbuffer(&sc->sc_pr);
sc->sc_sil_count = 0;
  836         if (hw->init_output && (sc->sc_mode & AUMODE_PLAY)) {
error = hw->init_output(sc->hw_hdl, sc->sc_pr.start,
sc->sc_pr.end - sc->sc_pr.start);
  839                 if (error)
  840                         return error;
  841         }
  843 #ifdef AUDIO_INTR_TIME
sc->sc_pnintr = 0;
sc->sc_pblktime = (u_long)(
  846             (u_long)sc->sc_pr.blksize * 100000 /
  847             (u_long)(sc->sc_pparams.precision / NBBY *
sc->sc_pparams.channels *
sc->sc_pparams.sample_rate)) * 10;
DPRINTF(("audio: play blktime = %lu for %d\n",
sc->sc_pblktime, sc->sc_pr.blksize));
sc->sc_rnintr = 0;
sc->sc_rblktime = (u_long)(
  854             (u_long)sc->sc_rr.blksize * 100000 /
  855             (u_long)(sc->sc_rparams.precision / NBBY *
sc->sc_rparams.channels *
sc->sc_rparams.sample_rate)) * 10;
DPRINTF(("audio: record blktime = %lu for %d\n",
sc->sc_rblktime, sc->sc_rr.blksize));
  860 #endif
  862         return 0;
  863 }
  865 void
audio_calcwater(struct audio_softc *sc)
  867 {
sc->sc_pr.usedhigh = sc->sc_pr.end - sc->sc_pr.start;
sc->sc_pr.usedlow = sc->sc_pr.usedhigh * 3 / 4; /* set lowater at 75% */
  870         if (sc->sc_pr.usedlow == sc->sc_pr.usedhigh)
sc->sc_pr.usedlow -= sc->sc_pr.blksize;
sc->sc_rr.usedhigh = sc->sc_rr.end - sc->sc_rr.start - sc->sc_rr.blksize;
sc->sc_rr.usedlow = 0;
  874 }
  876 static __inline int
audio_sleep_timo(int *chan, char *label, int timo)
  878 {
  879         int st;
  881         if (!label)
label = "audio";
DPRINTFN(3, ("audio_sleep_timo: chan=%p, label=%s, timo=%d\n",
chan, label, timo));
  886         *chan = 1;
st = tsleep(chan, PWAIT | PCATCH, label, timo);
  888         *chan = 0;
  889 #ifdef AUDIO_DEBUG
  890         if (st != 0)
printf("audio_sleep: woke up st=%d\n", st);
  892 #endif
  893         return (st);
  894 }
  896 static __inline int
audio_sleep(int *chan, char *label)
  898 {
  899         return audio_sleep_timo(chan, label, 0);
  900 }
  902 /* call at splaudio() */
  903 static __inline void
audio_wakeup(int *chan)
  905 {
DPRINTFN(3, ("audio_wakeup: chan=%p, *chan=%d\n", chan, *chan));
  907         if (*chan) {
wakeup(chan);
  909                 *chan = 0;
  910         }
  911 }
  913 int
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;
DPRINTF(("audio_open: dev=0x%x flags=0x%x sc=%p hdl=%p\n", dev, flags, sc, sc->hw_hdl));
  923         if (ISDEVAUDIOCTL(dev))
  924                 return 0;
  926         if ((sc->sc_open & (AUOPEN_READ|AUOPEN_WRITE)) != 0)
  927                 return (EBUSY);
error = sc->hw_if->open(sc->hw_hdl, flags);
  930         if (error)
  931                 return (error);
sc->sc_async_audio = 0;
sc->sc_rchan = 0;
sc->sc_wchan = 0;
sc->sc_blkset = 0; /* Block sizes not set yet */
sc->sc_sil_count = 0;
sc->sc_rbus = 0;
sc->sc_pbus = 0;
sc->sc_eof = 0;
sc->sc_playdrop = 0;
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 */
mode = 0;
  950         if (flags & FREAD) {
sc->sc_open |= AUOPEN_READ;
mode |= AUMODE_RECORD;
  953         }
  954         if (flags & FWRITE) {
sc->sc_open |= AUOPEN_WRITE;
mode |= AUMODE_PLAY | AUMODE_PLAY_ALL;
  957         }
  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 */
sc->sc_rparams = audio_default;
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) {
printf("audio_open: 0 precision\n");
error = EINVAL;
  978                 goto bad;
  979         }
  980 #endif
AUDIO_INITINFO(&ai);
ai.record.sample_rate = sc->sc_rparams.sample_rate;
ai.record.encoding    = sc->sc_rparams.encoding;
ai.record.channels    = sc->sc_rparams.channels;
ai.record.precision   = sc->sc_rparams.precision;
ai.record.pause       = 0;
ai.play.sample_rate   = sc->sc_pparams.sample_rate;
ai.play.encoding       = sc->sc_pparams.encoding;
ai.play.channels      = sc->sc_pparams.channels;
ai.play.precision     = sc->sc_pparams.precision;
ai.play.pause         = 0;
ai.mode               = mode;
sc->sc_pr.blksize = sc->sc_rr.blksize = 0; /* force recalculation */
error = audiosetinfo(sc, &ai);
  996         if (error)
  997                 goto bad;
DPRINTF(("audio_open: done sc_mode = 0x%x\n", sc->sc_mode));
 1001         return 0;
bad:
sc->hw_if->close(sc->hw_hdl);
sc->sc_open = 0;
sc->sc_mode = 0;
sc->sc_full_duplex = 0;
 1008         return error;
 1009 }
 1011 /*
 1012  * Must be called from task context.
 1013  */
 1014 void
audio_init_record(struct audio_softc *sc)
 1016 {
 1017         int s = splaudio();
 1019         if (sc->hw_if->speaker_ctl &&
 1020             (!sc->sc_full_duplex || (sc->sc_mode & AUMODE_PLAY) == 0))
sc->hw_if->speaker_ctl(sc->hw_hdl, SPKR_OFF);
splx(s);
 1023 }
 1025 /*
 1026  * Must be called from task context.
 1027  */
 1028 void
audio_init_play(struct audio_softc *sc)
 1030 {
 1031         int s = splaudio();
sc->sc_wstamp = sc->sc_pr.stamp;
 1034         if (sc->hw_if->speaker_ctl)
sc->hw_if->speaker_ctl(sc->hw_hdl, SPKR_ON);
splx(s);
 1037 }
 1039 int
audio_drain(struct audio_softc *sc)
 1041 {
 1042         int error, drops;
 1043         struct audio_ringbuffer *cb = &sc->sc_pr;
 1044         int s;
DPRINTF(("audio_drain: enter busy=%d used=%d\n",
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;
u_char *inp = cb->inp;
cc = cb->blksize - (inp - cb->start) % cb->blksize;
 1058                 if (sc->sc_pparams.sw_code) {
 1059                         int ncc = cc / sc->sc_pparams.factor;
audio_fill_silence(&sc->sc_pparams, inp, ncc);
sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 1062                 } else
audio_fill_silence(&sc->sc_pparams, inp, cc);
inp += cc;
 1065                 if (inp >= cb->end)
inp = cb->start;
s = splaudio();
cb->used += cc;
cb->inp = inp;
error = audiostartp(sc);
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) {
printf("audio_drain: copying in progress!?!\n");
cb->copying = 0;
 1085         }
 1086 #endif
drops = cb->drops;
error = 0;
s = splaudio();
 1090         while (cb->drops == drops && !error) {
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                  */
error = audio_sleep_timo(&sc->sc_wchan, "aud_dr", 30*hz);
 1097                 if (sc->sc_dying)
error = EIO;
 1099         }
splx(s);
 1101         return error;
 1102 }
 1104 /*
 1105  * Close an audio chip.
 1106  */
 1107 /* ARGSUSED */
 1108 int
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;
DPRINTF(("audio_close: unit=%d flags=0x%x\n", unit, flags));
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)
sc->hw_if->halt_input(sc->hw_hdl);
sc->sc_rbus = 0;
 1129         }
 1130         /*
 1131          * Block until output drains, but allow ^C interrupt.
 1132          */
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);
sc->hw_if->halt_output(sc->hw_hdl);
sc->sc_pbus = 0;
 1143         }
hw->close(sc->hw_hdl);
 1147         /*
 1148          * If flags has neither read nor write then reset both
 1149          * directions. Encountered when someone runs revoke(2).
 1150          */
 1152         if ((flags & FREAD) || ((flags & (FREAD|FWRITE)) == 0)) {
sc->sc_open &= ~AUOPEN_READ;
sc->sc_mode &= ~AUMODE_RECORD;
 1155         }
 1156         if ((flags & FWRITE) || ((flags & (FREAD|FWRITE)) == 0)) {
sc->sc_open &= ~AUOPEN_WRITE;
sc->sc_mode &= ~(AUMODE_PLAY|AUMODE_PLAY_ALL);
 1159         }
sc->sc_async_audio = 0;
sc->sc_full_duplex = 0;
splx(s);
DPRINTF(("audio_close: done\n"));
 1166         return (0);
 1167 }
 1169 int
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;
u_char *outp;
 1176         int error, s, used, cc, n;
 1178         if (cb->mmapped)
 1179                 return EINVAL;
DPRINTFN(1,("audio_read: cc=%d mode=%d\n",
uio->uio_resid, sc->sc_mode));
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) {
s = splaudio();
 1193                         for(;;) {
cc = sc->sc_pr.stamp - sc->sc_wstamp;
 1195                                 if (cc > 0)
 1196                                         break;
DPRINTF(("audio_read: stamp=%lu, wstamp=%lu\n",
sc->sc_pr.stamp, sc->sc_wstamp));
 1199                                 if (ioflag & IO_NDELAY) {
splx(s);
 1201                                         return EWOULDBLOCK;
 1202                                 }
error = audio_sleep(&sc->sc_rchan, "aud_hr");
 1204                                 if (sc->sc_dying)
error = EIO;
 1206                                 if (error) {
splx(s);
 1208                                         return error;
 1209                                 }
 1210                         }
splx(s);
 1213                         if (uio->uio_resid < cc / sc->sc_rparams.factor)
cc = uio->uio_resid * sc->sc_rparams.factor;
DPRINTFN(1, ("audio_read: reading in write mode, cc=%d\n", cc));
error = audio_silence_copyout(sc,
cc / sc->sc_rparams.factor, uio);
sc->sc_wstamp += cc;
 1219                 }
 1220                 return (error);
 1221         }
 1222         while (uio->uio_resid > 0 && !error) {
s = splaudio();
 1224                 while (cb->used <= 0) {
 1225                         if (!sc->sc_rbus && !sc->sc_rr.pause) {
error = audiostartr(sc);
 1227                                 if (error) {
splx(s);
 1229                                         return error;
 1230                                 }
 1231                         }
 1232                         if (ioflag & IO_NDELAY) {
splx(s);
 1234                                 return (EWOULDBLOCK);
 1235                         }
DPRINTFN(2, ("audio_read: sleep used=%d\n", cb->used));
error = audio_sleep(&sc->sc_rchan, "aud_rd");
 1238                         if (sc->sc_dying)
error = EIO;
 1240                         if (error) {
splx(s);
 1242                                 return error;
 1243                         }
 1244                 }
used = cb->used;
outp = cb->outp;
cb->copying = 1;
splx(s);
cc = used - cb->usedlow; /* maximum to read */
n = cb->end - outp;
 1251                 if (n < cc)
cc = n; /* don't read beyond end of buffer */
 1254                  /* and no more than we want */
 1255                 if (uio->uio_resid < cc / sc->sc_rparams.factor)
cc = uio->uio_resid * sc->sc_rparams.factor;
 1258                 if (sc->sc_rparams.sw_code)
sc->sc_rparams.sw_code(sc->hw_hdl, outp, cc);
DPRINTFN(1,("audio_read: outp=%p, cc=%d\n", outp, cc));
error = uiomove(outp, cc / sc->sc_rparams.factor, uio);
used -= cc;
outp += cc;
 1264                 if (outp >= cb->end)
outp = cb->start;
s = splaudio();
cb->outp = outp;
cb->used = used;
cb->copying = 0;
splx(s);
 1271         }
 1272         return (error);
 1273 }
 1275 void
audio_clear(struct audio_softc *sc)
 1277 {
 1278         int s = splaudio();
 1280         if (sc->sc_rbus) {
audio_wakeup(&sc->sc_rchan);
sc->hw_if->halt_input(sc->hw_hdl);
sc->sc_rbus = 0;
 1284         }
 1285         if (sc->sc_pbus) {
audio_wakeup(&sc->sc_wchan);
sc->hw_if->halt_output(sc->hw_hdl);
sc->sc_pbus = 0;
 1289         }
splx(s);
 1291 }
 1293 void
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;
 1301         if (sc->sc_blkset)
 1302                 return;
 1304         if (mode == AUMODE_PLAY) {
parm = &sc->sc_pparams;
rb = &sc->sc_pr;
 1307         } else {
parm = &sc->sc_rparams;
rb = &sc->sc_rr;
 1310         }
bs = parm->sample_rate * audio_blk_ms / 1000 *
parm->channels * parm->precision / NBBY *
parm->factor;
ROUNDSIZE(bs);
 1316         if (hw->round_blocksize)
bs = hw->round_blocksize(sc->hw_hdl, bs);
rb->blksize = bs;
DPRINTF(("audio_calc_blksize: %s blksize=%d\n",
mode == AUMODE_PLAY ? "play" : "record", bs));
 1322 }
 1324 void
audio_fill_silence(struct audio_params *params, u_char *p, int n)
 1326 {
u_char auzero0, auzero1 = 0; /* initialize to please gcc */
 1328         int nfill = 1;
 1330         switch (params->encoding) {
 1331         case AUDIO_ENCODING_ULAW:
auzero0 = 0x7f;
 1333                 break;
 1334         case AUDIO_ENCODING_ALAW:
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:
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) {
nfill = 2;
 1352                         if (params->encoding == AUDIO_ENCODING_ULINEAR_LE) {
auzero0 = 0;
auzero1 = 0x80;
 1355                         } else {
auzero0 = 0x80;
auzero1 = 0;
 1358                         }
 1359                 } else
auzero0 = 0x80;
 1361                 break;
 1362         default:
DPRINTF(("audio: bad encoding %d\n", params->encoding));
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;
n -= 2;
 1375                 }
 1376         }
 1377 }
 1379 int
audio_silence_copyout(struct audio_softc *sc, int n, struct uio *uio)
 1381 {
 1382         int error;
 1383         int k;
u_char zerobuf[128];
audio_fill_silence(&sc->sc_rparams, zerobuf, sizeof zerobuf);
error = 0;
 1389         while (n > 0 && uio->uio_resid > 0 && !error) {
k = min(n, min(uio->uio_resid, sizeof zerobuf));
error = uiomove(zerobuf, k, uio);
n -= k;
 1393         }
 1394         return (error);
 1395 }
 1397 int
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;
u_char *inp, *einp;
 1404         int saveerror, error, s, n, cc, used;
DPRINTFN(2, ("audio_write: sc=%p(unit=%d) count=%d used=%d(hi=%d)\n", sc, unit,
uio->uio_resid, sc->sc_pr.used, sc->sc_pr.usedhigh));
 1409         if (cb->mmapped)
 1410                 return EINVAL;
 1412         if (uio->uio_resid == 0) {
sc->sc_eof++;
 1414                 return 0;
 1415         }
 1417         /*
 1418          * If half-duplex and currently recording, throw away data.
 1419          */
 1420         if (!sc->sc_full_duplex &&
 1421             (sc->sc_mode & AUMODE_RECORD)) {
uio->uio_offset += uio->uio_resid;
uio->uio_resid = 0;
DPRINTF(("audio_write: half-dpx read busy\n"));
 1425                 return (0);
 1426         }
 1428         if (!(sc->sc_mode & AUMODE_PLAY_ALL) && sc->sc_playdrop > 0) {
n = min(sc->sc_playdrop, uio->uio_resid * sc->sc_pparams.factor);
DPRINTF(("audio_write: playdrop %d\n", n));
uio->uio_offset += n / sc->sc_pparams.factor;
uio->uio_resid -= n / sc->sc_pparams.factor;
sc->sc_playdrop -= n;
 1434                 if (uio->uio_resid == 0)
 1435                         return 0;
 1436         }
DPRINTFN(1, ("audio_write: sr=%ld, enc=%d, prec=%d, chan=%d, sw=%p, fact=%d\n",
sc->sc_pparams.sample_rate, sc->sc_pparams.encoding,
sc->sc_pparams.precision, sc->sc_pparams.channels,
sc->sc_pparams.sw_code, sc->sc_pparams.factor));
error = 0;
 1444         while (uio->uio_resid > 0 && !error) {
s = splaudio();
 1446                 while (cb->used >= cb->usedhigh) {
DPRINTFN(2, ("audio_write: sleep used=%d lowat=%d hiwat=%d\n",
cb->used, cb->usedlow, cb->usedhigh));
 1449                         if (ioflag & IO_NDELAY) {
splx(s);
 1451                                 return (EWOULDBLOCK);
 1452                         }
error = audio_sleep(&sc->sc_wchan, "aud_wr");
 1454                         if (sc->sc_dying)
error = EIO;
 1456                         if (error) {
splx(s);
 1458                                 return error;
 1459                         }
 1460                 }
used = cb->used;
inp = cb->inp;
cb->copying = 1;
splx(s);
cc = cb->usedhigh - used;       /* maximum to write */
n = cb->end - inp;
 1467                 if (sc->sc_pparams.factor != 1) {
 1468                         /* Compensate for software coding expansion factor. */
n /= sc->sc_pparams.factor;
cc /= sc->sc_pparams.factor;
 1471                 }
 1472                 if (n < cc)
cc = n;                 /* don't write beyond end of buffer */
 1474                 if (uio->uio_resid < cc)
cc = uio->uio_resid;    /* and no more than we have */
 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) {
printf("audio_write: cc == 0, swcode=%p, factor=%d\n",
sc->sc_pparams.sw_code, sc->sc_pparams.factor);
cb->copying = 0;
 1486                         return EINVAL;
 1487                 }
 1488 #endif
DPRINTFN(1, ("audio_write: uiomove cc=%d inp=%p, left=%d\n",
cc, inp, uio->uio_resid));
n = uio->uio_resid;
error = uiomove(inp, cc, uio);
cc = n - uio->uio_resid; /* number of bytes actually moved */
 1494 #ifdef AUDIO_DEBUG
 1495                 if (error)
printf("audio_write:(1) uiomove failed %d; cc=%d inp=%p\n",
error, cc, inp);
 1498 #endif
 1499                 /*
 1500                  * Continue even if uiomove() failed because we may have
 1501                  * gotten a partial block.
 1502                  */
 1504                 if (sc->sc_pparams.sw_code) {
sc->sc_pparams.sw_code(sc->hw_hdl, inp, cc);
 1506                         /* Adjust count after the expansion. */
cc *= sc->sc_pparams.factor;
DPRINTFN(1, ("audio_write: expanded cc=%d\n", cc));
 1509                 }
einp = cb->inp + cc;
 1512                 if (einp >= cb->end)
einp = cb->start;
s = splaudio();
 1516                 /*
 1517                  * This is a very suboptimal way of keeping track of
 1518                  * silence in the buffer, but it is simple.
 1519                  */
sc->sc_sil_count = 0;
cb->inp = einp;
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. */
cc = cb->blksize - (einp - cb->start) % cb->blksize;
DPRINTF(("audio_write: partial fill %d\n", cc));
 1534                 } else
cc = 0;
cb->needfill = 0;
cb->copying = 0;
 1538                 if (!sc->sc_pbus && !cb->pause) {
saveerror = error;
error = audiostartp(sc);
 1541                         if (saveerror != 0) {
 1542                                 /* Report the first error that occurred. */
error = saveerror;
 1544                         }
 1545                 }
splx(s);
 1547                 if (cc) {
DPRINTFN(1, ("audio_write: fill %d\n", cc));
 1549                         if (sc->sc_pparams.sw_code) {
 1550                                 int ncc = cc / sc->sc_pparams.factor;
audio_fill_silence(&sc->sc_pparams, einp, ncc);
sc->sc_pparams.sw_code(sc->hw_hdl, einp, ncc);
 1553                         } else
audio_fill_silence(&sc->sc_pparams, einp, cc);
 1555                 }
 1556         }
 1557         return (error);
 1558 }
 1560 int
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;
DPRINTF(("audio_ioctl(%d,'%c',%d)\n",
IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff));
 1572         switch (cmd) {
 1573         case FIONBIO:
 1574                 /* All handled in the upper FS layer. */
 1575                 break;
 1577         case FIOASYNC:
 1578                 if (*(int *)addr) {
 1579                         if (sc->sc_async_audio)
 1580                                 return (EBUSY);
sc->sc_async_audio = p;
DPRINTF(("audio_ioctl: FIOASYNC %p\n", p));
 1583                 } else
sc->sc_async_audio = 0;
 1585                 break;
 1587         case AUDIO_FLUSH:
DPRINTF(("AUDIO_FLUSH\n"));
rbus = sc->sc_rbus;
pbus = sc->sc_pbus;
audio_clear(sc);
s = splaudio();
error = audio_initbufs(sc);
 1594                 if (error) {
splx(s);
 1596                         return error;
 1597                 }
sc->sc_rr.pause = 0;
sc->sc_pr.pause = 0;
 1600                 if ((sc->sc_mode & AUMODE_PLAY) && !sc->sc_pbus && pbus)
error = audiostartp(sc);
 1602                 if (!error &&
 1603                     (sc->sc_mode & AUMODE_RECORD) && !sc->sc_rbus && rbus)
error = audiostartr(sc);
splx(s);
 1606                 break;
 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 *
sc->sc_rparams.precision);
 1627                 break;
 1629         case AUDIO_PERROR:
 1630                 *(int *)addr = (sc->sc_pr.drops * NBBY) /
 1631                     (sc->sc_pparams.factor * sc->sc_pparams.channels *
sc->sc_pparams.precision);
 1633                 break;
 1635         /*
 1636          * Offsets into buffer.
 1637          */
 1638         case AUDIO_GETIOFFS:
s = splaudio();
 1640                 /* figure out where next DMA will start */
ao = (struct audio_offset *)addr;
ao->samples = sc->sc_rr.stamp;
ao->deltablks = (sc->sc_rr.stamp - sc->sc_rr.stamp_last) / sc->sc_rr.blksize;
sc->sc_rr.stamp_last = sc->sc_rr.stamp;
ao->offset = sc->sc_rr.inp - sc->sc_rr.start;
splx(s);
 1647                 break;
 1649         case AUDIO_GETOOFFS:
s = splaudio();
 1651                 /* figure out where next DMA will start */
ao = (struct audio_offset *)addr;
offs = sc->sc_pr.outp - sc->sc_pr.start + sc->sc_pr.blksize;
 1654                 if (sc->sc_pr.start + offs >= sc->sc_pr.end)
offs = 0;
ao->samples = sc->sc_pr.stamp;
ao->deltablks = (sc->sc_pr.stamp - sc->sc_pr.stamp_last) / sc->sc_pr.blksize;
sc->sc_pr.stamp_last = sc->sc_pr.stamp;
ao->offset = offs;
splx(s);
 1661                 break;
 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;
 1671         case AUDIO_SETINFO:
DPRINTF(("AUDIO_SETINFO mode=0x%x\n", sc->sc_mode));
error = audiosetinfo(sc, (struct audio_info *)addr);
 1674                 break;
 1676         case AUDIO_GETINFO:
DPRINTF(("AUDIO_GETINFO\n"));
error = audiogetinfo(sc, (struct audio_info *)addr);
 1679                 break;
 1681         case AUDIO_DRAIN:
DPRINTF(("AUDIO_DRAIN\n"));
error = audio_drain(sc);
 1684                 if (!error && hw->drain)
error = hw->drain(sc->hw_hdl);
 1686                 break;
 1688         case AUDIO_GETDEV:
DPRINTF(("AUDIO_GETDEV\n"));
error = hw->getdev(sc->hw_hdl, (audio_device_t *)addr);
 1691                 break;
 1693         case AUDIO_GETENC:
DPRINTF(("AUDIO_GETENC\n"));
 1695                 /* Pass read/write info down to query_encoding */
 1696                 ((struct audio_encoding *)addr)->flags = sc->sc_open;
error = hw->query_encoding(sc->hw_hdl, (struct audio_encoding *)addr);
 1698                 break;
 1700         case AUDIO_GETFD:
DPRINTF(("AUDIO_GETFD\n"));
 1702                 *(int *)addr = sc->sc_full_duplex;
 1703                 break;
 1705         case AUDIO_SETFD:
DPRINTF(("AUDIO_SETFD\n"));
fd = *(int *)addr;
 1708                 if (hw->get_props(sc->hw_hdl) & AUDIO_PROP_FULLDUPLEX) {
 1709                         if (hw->setfd)
error = hw->setfd(sc->hw_hdl, fd);
 1711                         else
error = 0;
 1713                         if (!error)
sc->sc_full_duplex = fd;
 1715                 } else {
 1716                         if (fd)
error = ENOTTY;
 1718                         else
error = 0;
 1720                 }
 1721                 break;
 1723         case AUDIO_GETPROPS:
DPRINTF(("AUDIO_GETPROPS\n"));
 1725                 *(int *)addr = hw->get_props(sc->hw_hdl);
 1726                 break;
 1728         default:
DPRINTF(("audio_ioctl: unknown ioctl\n"));
error = ENOTTY;
 1731                 break;
 1732         }
DPRINTF(("audio_ioctl(%d,'%c',%d) result %d\n",
IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff, error));
 1735         return (error);
 1736 }
 1738 void
audio_selwakeup(struct audio_softc *sc, int play)
 1740 {
 1741         struct selinfo *si;
si = play? &sc->sc_wsel : &sc->sc_rsel;
audio_wakeup(play? &sc->sc_wchan : &sc->sc_rchan);
selwakeup(si);
 1747         if (sc->sc_async_audio)
psignal(sc->sc_async_audio, SIGIO);
KNOTE(&si->si_note, 0);
 1750 }
 1752 #define AUDIO_FILTREAD(sc) ( \
 1753     (!sc->sc_full_duplex && (sc->sc_mode & AUMODE_PLAY)) ? \
sc->sc_pr.stamp > sc->sc_wstamp : sc->sc_rr.used > sc->sc_rr.usedlow)
 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))
 1761 int
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();
DPRINTF(("audio_poll: events=0x%x mode=%d\n", events, sc->sc_mode));
 1770         if (events & (POLLIN | POLLRDNORM)) {
 1771                 if (AUDIO_FILTREAD(sc))
revents |= events & (POLLIN | POLLRDNORM);
 1773         }
 1774         if (events & (POLLOUT | POLLWRNORM)) {
 1775                 if (AUDIO_FILTWRITE(sc))
revents |= events & (POLLOUT | POLLWRNORM);
 1777         }
 1778         if (revents == 0) {
 1779                 if (events & (POLLIN | POLLRDNORM))
selrecord(p, &sc->sc_rsel);
 1781                 if (events & (POLLOUT | POLLWRNORM))
selrecord(p, &sc->sc_wsel);
 1783         }
splx(s);
 1785         return (revents);
 1786 }
paddr_t
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;
DPRINTF(("audio_mmap: off=%d, prot=%d\n", off, prot));
 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) ||
prot == VM_PROT_WRITE)
cb = &sc->sc_pr;
 1817         else if (prot == VM_PROT_READ)
cb = &sc->sc_rr;
 1819         else
 1820                 return -1;
 1821 #else
cb = &sc->sc_pr;
 1823 #endif
 1825         if ((u_int)off >= cb->bufsize)
 1826                 return -1;
 1827         if (!cb->mmapped) {
cb->mmapped = 1;
 1829                 if (cb == &sc->sc_pr) {
audio_fill_silence(&sc->sc_pparams, cb->start, cb->bufsize);
s = splaudio();
 1832                         if (!sc->sc_pbus && !sc->sc_pr.pause)
 1833                                 (void)audiostartp(sc);
splx(s);
 1835                 } else {
s = splaudio();
 1837                         if (!sc->sc_rbus && !sc->sc_rr.pause)
 1838                                 (void)audiostartr(sc);
splx(s);
 1840                 }
 1841         }
 1843         return hw->mappage(sc->hw_hdl, cb->start, off, prot);
 1844 }
 1846 int
audiostartr(struct audio_softc *sc)
 1848 {
 1849         int error;
DPRINTF(("audiostartr: start=%p used=%d(hi=%d) mmapped=%d\n",
sc->sc_rr.start, sc->sc_rr.used, sc->sc_rr.usedhigh,
sc->sc_rr.mmapped));
 1855         if (sc->hw_if->trigger_input)
error = sc->hw_if->trigger_input(sc->hw_hdl, sc->sc_rr.start,
sc->sc_rr.end, sc->sc_rr.blksize,
audio_rint, (void *)sc, &sc->sc_rparams);
 1859         else
error = sc->hw_if->start_input(sc->hw_hdl, sc->sc_rr.start,
sc->sc_rr.blksize, audio_rint, (void *)sc);
 1862         if (error) {
DPRINTF(("audiostartr failed: %d\n", error));
 1864                 return error;
 1865         }
sc->sc_rbus = 1;
 1867         return 0;
 1868 }
 1870 int
audiostartp(struct audio_softc *sc)
 1872 {
 1873         int error;
DPRINTF(("audiostartp: start=%p used=%d(hi=%d) mmapped=%d\n",
sc->sc_pr.start, sc->sc_pr.used, sc->sc_pr.usedhigh,
sc->sc_pr.mmapped));
 1879         if (!sc->sc_pr.mmapped && sc->sc_pr.used < sc->sc_pr.blksize)
 1880                 return 0;
 1882         if (sc->hw_if->trigger_output)
error = sc->hw_if->trigger_output(sc->hw_hdl, sc->sc_pr.start,
sc->sc_pr.end, sc->sc_pr.blksize,
audio_pint, (void *)sc, &sc->sc_pparams);
 1886         else
error = sc->hw_if->start_output(sc->hw_hdl, sc->sc_pr.outp,
sc->sc_pr.blksize, audio_pint, (void *)sc);
 1889         if (error) {
DPRINTF(("audiostartp failed: %d\n", error));
 1891                 return error;
 1892         }
sc->sc_pbus = 1;
 1894         return 0;
 1895 }
 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
audio_pint_silence(struct audio_softc *sc, struct audio_ringbuffer *cb,
u_char *inp, int cc)
 1914 {
u_char *s, *e, *p, *q;
 1917         if (sc->sc_sil_count > 0) {
s = sc->sc_sil_start; /* start of silence */
e = s + sc->sc_sil_count; /* end of silence, may be beyond end */
p = inp;        /* adjusted pointer to area to fill */
 1921                 if (p < s)
p += cb->end - cb->start;
q = p+cc;
 1924                 /* Check if there is already silence. */
 1925                 if (!(s <= p && p <  e &&
s <= q && q <= e)) {
 1927                         if (s <= p)
sc->sc_sil_count = max(sc->sc_sil_count, q-s);
DPRINTFN(5, ("audio_pint_silence: fill cc=%d inp=%p, count=%d size=%d\n",
cc, inp, sc->sc_sil_count, (int)(cb->end - cb->start)));
 1932                         if (sc->sc_pparams.sw_code) {
 1933                                 int ncc = cc / sc->sc_pparams.factor;
audio_fill_silence(&sc->sc_pparams, inp, ncc);
sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 1936                         } else
audio_fill_silence(&sc->sc_pparams, inp, cc);
 1939                 } else {
DPRINTFN(5, ("audio_pint_silence: already silent cc=%d inp=%p\n", cc, inp));
 1942                 }
 1943         } else {
sc->sc_sil_start = inp;
sc->sc_sil_count = cc;
DPRINTFN(5, ("audio_pint_silence: start fill %p %d\n",
inp, cc));
 1949                 if (sc->sc_pparams.sw_code) {
 1950                         int ncc = cc / sc->sc_pparams.factor;
audio_fill_silence(&sc->sc_pparams, inp, ncc);
sc->sc_pparams.sw_code(sc->hw_hdl, inp, ncc);
 1953                 } else
audio_fill_silence(&sc->sc_pparams, inp, cc);
 1956         }
 1957 }
 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
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;
u_char *inp;
 1972         int cc;
 1973         int blksize;
 1974         int error;
 1976         if (!sc->sc_open)
 1977                 return;         /* ignore interrupt if not open */
blksize = cb->blksize;
add_audio_randomness((long)cb);
cb->outp += blksize;
 1984         if (cb->outp >= cb->end)
cb->outp = cb->start;
cb->stamp += blksize;
 1987         if (cb->mmapped) {
DPRINTFN(5, ("audio_pint: mmapped outp=%p cc=%d inp=%p\n",
cb->outp, blksize, cb->inp));
 1990                 if (!hw->trigger_output)
 1991                         (void)hw->start_output(sc->hw_hdl, cb->outp,
blksize, audio_pint, (void *)sc);
 1993                 return;
 1994         }
 1996 #ifdef AUDIO_INTR_TIME
 1997         {
 1998                 struct timeval tv;
u_long t;
microtime(&tv);
t = tv.tv_usec + 1000000 * tv.tv_sec;
 2002                 if (sc->sc_pnintr) {
 2003                         long lastdelta, totdelta;
lastdelta = t - sc->sc_plastintr - sc->sc_pblktime;
 2005                         if (lastdelta > sc->sc_pblktime / 3) {
printf("audio: play interrupt(%d) off relative by %ld us (%lu)\n",
sc->sc_pnintr, lastdelta, sc->sc_pblktime);
 2008                         }
totdelta = t - sc->sc_pfirstintr - sc->sc_pblktime * sc->sc_pnintr;
 2010                         if (totdelta > sc->sc_pblktime) {
printf("audio: play interrupt(%d) off absolute by %ld us (%lu) (LOST)\n",
sc->sc_pnintr, totdelta, sc->sc_pblktime);
sc->sc_pnintr++; /* avoid repeated messages */
 2014                         }
 2015                 } else
sc->sc_pfirstintr = t;
sc->sc_plastintr = t;
sc->sc_pnintr++;
 2019         }
 2020 #endif
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 */
cb->needfill = 1;
DPRINTFN(1, ("audio_pint: copying in progress\n"));
 2029                 } else {
inp = cb->inp;
cc = blksize - (inp - cb->start) % blksize;
 2032                         if (cb->pause)
cb->pdrops += cc;
 2034                         else {
cb->drops += cc;
sc->sc_playdrop += cc;
 2037                         }
audio_pint_silence(sc, cb, inp, cc);
inp += cc;
 2040                         if (inp >= cb->end)
inp = cb->start;
cb->inp = inp;
cb->used += cc;
 2045                         /* Clear next block so we keep ahead of the DMA. */
 2046                         if (cb->used + cc < cb->usedhigh)
audio_pint_silence(sc, cb, inp, blksize);
 2048                 }
 2049         }
DPRINTFN(5, ("audio_pint: outp=%p cc=%d\n", cb->outp, blksize));
 2052         if (!hw->trigger_output) {
error = hw->start_output(sc->hw_hdl, cb->outp, blksize,
audio_pint, (void *)sc);
 2055                 if (error) {
 2056                         /* XXX does this really help? */
DPRINTF(("audio_pint restart failed: %d\n", error));
audio_clear(sc);
 2059                 }
 2060         }
DPRINTFN(2, ("audio_pint: mode=%d pause=%d used=%d lowat=%d\n",
sc->sc_mode, cb->pause, cb->used, cb->usedlow));
 2064         if ((sc->sc_mode & AUMODE_PLAY) && !cb->pause &&
cb->used <= cb->usedlow)
audio_selwakeup(sc, 1);
 2068         /* Possible to return one or more "phantom blocks" now. */
 2069         if (!sc->sc_full_duplex && sc->sc_rchan)
audio_selwakeup(sc, 0);
 2071 }
 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
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;
 2087         if (!sc->sc_open)
 2088                 return;         /* ignore interrupt if not open */
add_audio_randomness((long)cb);
blksize = cb->blksize;
cb->inp += blksize;
 2095         if (cb->inp >= cb->end)
cb->inp = cb->start;
cb->stamp += blksize;
 2098         if (cb->mmapped) {
DPRINTFN(2, ("audio_rint: mmapped inp=%p cc=%d\n",
cb->inp, blksize));
 2101                 if (!hw->trigger_input)
 2102                         (void)hw->start_input(sc->hw_hdl, cb->inp, blksize,
audio_rint, (void *)sc);
 2104                 return;
 2105         }
 2107 #ifdef AUDIO_INTR_TIME
 2108         {
 2109                 struct timeval tv;
u_long t;
microtime(&tv);
t = tv.tv_usec + 1000000 * tv.tv_sec;
 2113                 if (sc->sc_rnintr) {
 2114                         long lastdelta, totdelta;
lastdelta = t - sc->sc_rlastintr - sc->sc_rblktime;
 2116                         if (lastdelta > sc->sc_rblktime / 5) {
printf("audio: record interrupt(%d) off relative by %ld us (%lu)\n",
sc->sc_rnintr, lastdelta, sc->sc_rblktime);
 2119                         }
totdelta = t - sc->sc_rfirstintr - sc->sc_rblktime * sc->sc_rnintr;
 2121                         if (totdelta > sc->sc_rblktime / 2) {
sc->sc_rnintr++;
printf("audio: record interrupt(%d) off absolute by %ld us (%lu)\n",
sc->sc_rnintr, totdelta, sc->sc_rblktime);
sc->sc_rnintr++; /* avoid repeated messages */
 2126                         }
 2127                 } else
sc->sc_rfirstintr = t;
sc->sc_rlastintr = t;
sc->sc_rnintr++;
 2131         }
 2132 #endif
cb->used += blksize;
 2135         if (cb->pause) {
DPRINTFN(1, ("audio_rint: pdrops %lu\n", cb->pdrops));
cb->pdrops += blksize;
cb->outp += blksize;
cb->used -= blksize;
 2140         } else if (cb->used + blksize >= cb->usedhigh && !cb->copying) {
DPRINTFN(1, ("audio_rint: drops %lu\n", cb->drops));
cb->drops += blksize;
cb->outp += blksize;
cb->used -= blksize;
 2145         }
DPRINTFN(2, ("audio_rint: inp=%p cc=%d used=%d\n",
cb->inp, blksize, cb->used));
 2149         if (!hw->trigger_input) {
error = hw->start_input(sc->hw_hdl, cb->inp, blksize,
audio_rint, (void *)sc);
 2152                 if (error) {
 2153                         /* XXX does this really help? */
DPRINTF(("audio_rint: restart failed: %d\n", error));
audio_clear(sc);
 2156                 }
 2157         }
audio_selwakeup(sc, 0);
 2160 }
 2162 int
audio_check_params(struct audio_params *p)
 2164 {
 2165         if (p->encoding == AUDIO_ENCODING_PCM16) {
 2166                 if (p->precision == 8)
p->encoding = AUDIO_ENCODING_ULINEAR;
 2168                 else
p->encoding = AUDIO_ENCODING_SLINEAR;
 2170         } else if (p->encoding == AUDIO_ENCODING_PCM8) {
 2171                 if (p->precision == 8)
p->encoding = AUDIO_ENCODING_ULINEAR;
 2173                 else
 2174                         return EINVAL;
 2175         }
 2177         if (p->encoding == AUDIO_ENCODING_SLINEAR)
 2178 #if BYTE_ORDER == LITTLE_ENDIAN
p->encoding = AUDIO_ENCODING_SLINEAR_LE;
 2180 #else
p->encoding = AUDIO_ENCODING_SLINEAR_BE;
 2182 #endif
 2183         if (p->encoding == AUDIO_ENCODING_ULINEAR)
 2184 #if BYTE_ORDER == LITTLE_ENDIAN
p->encoding = AUDIO_ENCODING_ULINEAR_LE;
 2186 #else
p->encoding = AUDIO_ENCODING_ULINEAR_BE;
 2188 #endif
 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         }
 2215         if (p->channels < 1 || p->channels > 8) /* sanity check # of channels */
 2216                 return (EINVAL);
 2218         return (0);
 2219 }
 2221 int
au_set_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int l, int r)
 2223 {
ct->type = AUDIO_MIXER_VALUE;
ct->un.value.num_channels = 2;
ct->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
ct->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
 2228         if (sc->hw_if->set_port(sc->hw_hdl, ct) == 0)
 2229                 return 0;
ct->un.value.num_channels = 1;
ct->un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r)/2;
 2232         return sc->hw_if->set_port(sc->hw_hdl, ct);
 2233 }
 2235 int
au_set_gain(struct audio_softc *sc, struct au_mixer_ports *ports, int gain,
 2237     int balance)
 2238 {
mixer_ctrl_t ct;
 2240         int i, error;
 2241         int l, r;
u_int mask;
 2243         int nset;
 2245         if (balance == AUDIO_MID_BALANCE) {
l = r = gain;
 2247         } else if (balance < AUDIO_MID_BALANCE) {
r = gain;
l = (balance * gain) / AUDIO_MID_BALANCE;
 2250         } else {
l = gain;
r = ((AUDIO_RIGHT_BALANCE - balance) * gain)
 2253                     / AUDIO_MID_BALANCE;
 2254         }
DPRINTF(("au_set_gain: gain=%d balance=%d, l=%d r=%d\n",
gain, balance, l, r));
 2258         if (ports->index == -1) {
usemaster:
 2260                 if (ports->master == -1)
 2261                         return 0; /* just ignore it silently */
ct.dev = ports->master;
error = au_set_lr_value(sc, &ct, l, r);
 2264         } else {
ct.dev = ports->index;
 2266                 if (ports->isenum) {
ct.type = AUDIO_MIXER_ENUM;
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) {
ct.dev = ports->miport[i];
 2274                                         if (ct.dev == -1 ||
au_set_lr_value(sc, &ct, l, r))
 2276                                                 goto usemaster;
 2277                                         else
 2278                                                 break;
 2279                                 }
 2280                         }
 2281                 } else {
ct.type = AUDIO_MIXER_SET;
error = sc->hw_if->get_port(sc->hw_hdl, &ct);
 2284                         if (error)
 2285                                 return error;
mask = ct.un.mask;
nset = 0;
 2288                         for(i = 0; i < ports->nports; i++) {
 2289                                 if (ports->misel[i] & mask) {
ct.dev = ports->miport[i];
 2291                                     if (ct.dev != -1 &&
au_set_lr_value(sc, &ct, l, r) == 0)
nset++;
 2294                                 }
 2295                         }
 2296                         if (nset == 0)
 2297                                 goto usemaster;
 2298                 }
 2299         }
 2300         if (!error)
mixer_signal(sc);
 2302         return error;
 2303 }
 2305 int
au_get_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int *l, int *r)
 2307 {
 2308         int error;
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 {
ct->un.value.num_channels = 1;
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 }
 2324 void
au_get_gain(struct audio_softc *sc, struct au_mixer_ports *ports, u_int *pgain,
u_char *pbalance)
 2327 {
mixer_ctrl_t ct;
 2329         int i, l, r, n;
 2330         int lgain = AUDIO_MAX_GAIN/2, rgain = AUDIO_MAX_GAIN/2;
 2332         if (ports->index == -1) {
usemaster:
 2334                 if (ports->master == -1)
 2335                         goto bad;
ct.dev = ports->master;
ct.type = AUDIO_MIXER_VALUE;
 2338                 if (au_get_lr_value(sc, &ct, &lgain, &rgain))
 2339                         goto bad;
 2340         } else {
ct.dev = ports->index;
 2342                 if (ports->isenum) {
ct.type = AUDIO_MIXER_ENUM;
 2344                         if (sc->hw_if->get_port(sc->hw_hdl, &ct))
 2345                                 goto bad;
ct.type = AUDIO_MIXER_VALUE;
 2347                         for(i = 0; i < ports->nports; i++) {
 2348                                 if (ports->misel[i] == ct.un.ord) {
ct.dev = ports->miport[i];
 2350                                         if (ct.dev == -1 ||
au_get_lr_value(sc, &ct,
 2352                                                             &lgain, &rgain))
 2353                                                 goto usemaster;
 2354                                         else
 2355                                                 break;
 2356                                 }
 2357                         }
 2358                 } else {
ct.type = AUDIO_MIXER_SET;
 2360                         if (sc->hw_if->get_port(sc->hw_hdl, &ct))
 2361                                 goto bad;
ct.type = AUDIO_MIXER_VALUE;
lgain = rgain = n = 0;
 2364                         for(i = 0; i < ports->nports; i++) {
 2365                                 if (ports->misel[i] & ct.un.mask) {
ct.dev = ports->miport[i];
 2367                                         if (ct.dev == -1 ||
au_get_lr_value(sc, &ct, &l, &r))
 2369                                                 goto usemaster;
 2370                                         else {
lgain += l;
rgain += r;
n++;
 2374                                         }
 2375                                 }
 2376                         }
 2377                         if (n != 0) {
lgain /= n;
rgain /= n;
 2380                         }
 2381                 }
 2382         }
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 }
 2397 int
au_set_port(struct audio_softc *sc, struct au_mixer_ports *ports, u_int port)
 2399 {
mixer_ctrl_t ct;
 2401         int i, error;
 2403         if (port == 0)  /* allow this special case */
 2404                 return 0;
 2406         if (ports->index == -1)
 2407                 return EINVAL;
ct.dev = ports->index;
 2409         if (ports->isenum) {
 2410                 if (port & (port-1))
 2411                         return EINVAL; /* Only one port allowed */
ct.type = AUDIO_MIXER_ENUM;
error = EINVAL;
 2414                 for(i = 0; i < ports->nports; i++)
 2415                         if (ports->aumask[i] == port) {
ct.un.ord = ports->misel[i];
error = sc->hw_if->set_port(sc->hw_hdl, &ct);
 2418                                 break;
 2419                         }
 2420         } else {
ct.type = AUDIO_MIXER_SET;
ct.un.mask = 0;
 2423                 for(i = 0; i < ports->nports; i++)
 2424                         if (ports->aumask[i] & port)
ct.un.mask |= ports->misel[i];
 2426                 if (port != 0 && ct.un.mask == 0)
error = EINVAL;
 2428                 else
error = sc->hw_if->set_port(sc->hw_hdl, &ct);
 2430         }
 2431         if (!error)
mixer_signal(sc);
 2433         return error;
 2434 }
 2436 int
au_get_port(struct audio_softc *sc, struct au_mixer_ports *ports)
 2438 {
mixer_ctrl_t ct;
 2440         int i, aumask;
 2442         if (ports->index == -1)
 2443                 return 0;
ct.dev = ports->index;
ct.type = ports->isenum ? AUDIO_MIXER_ENUM : AUDIO_MIXER_SET;
 2446         if (sc->hw_if->get_port(sc->hw_hdl, &ct))
 2447                 return 0;
aumask = 0;
 2449         if (ports->isenum) {
 2450                 for(i = 0; i < ports->nports; i++)
 2451                         if (ct.un.ord == ports->misel[i])
aumask = ports->aumask[i];
 2453         } else {
 2454                 for(i = 0; i < ports->nports; i++)
 2455                         if (ct.un.mask & ports->misel[i])
aumask |= ports->aumask[i];
 2457         }
 2458         return aumask;
 2459 }
 2461 int
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;
u_int gain;
u_char balance;
 2477         if (hw == 0)            /* HW has not attached */
 2478                 return(ENXIO);
rbus = sc->sc_rbus;
pbus = sc->sc_pbus;
error = 0;
cleared = 0;
pp = sc->sc_pparams;    /* Temporary encoding storage in */
rp = sc->sc_rparams;    /* case setting the modes fails. */
nr = np = 0;
 2489         if (p->sample_rate != ~0) {
pp.sample_rate = p->sample_rate;
np++;
 2492         }
 2493         if (r->sample_rate != ~0) {
rp.sample_rate = r->sample_rate;
nr++;
 2496         }
 2497         if (p->encoding != ~0) {
pp.encoding = p->encoding;
np++;
 2500         }
 2501         if (r->encoding != ~0) {
rp.encoding = r->encoding;
nr++;
 2504         }
 2505         if (p->precision != ~0) {
pp.precision = p->precision;
np++;
 2508         }
 2509         if (r->precision != ~0) {
rp.precision = r->precision;
nr++;
 2512         }
 2513         if (p->channels != ~0) {
pp.channels = p->channels;
np++;
 2516         }
 2517         if (r->channels != ~0) {
rp.channels = r->channels;
nr++;
 2520         }
 2521 #ifdef AUDIO_DEBUG
 2522         if (audiodebug && nr)
audio_print_params("Setting record params", &rp);
 2524         if (audiodebug && np)
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;
setmode = 0;
 2532         if (nr) {
 2533                 if (!cleared)
audio_clear(sc);
modechange = cleared = 1;
rp.sw_code = 0;
rp.factor = 1;
setmode |= AUMODE_RECORD;
 2539         }
 2540         if (np) {
 2541                 if (!cleared)
audio_clear(sc);
modechange = cleared = 1;
pp.sw_code = 0;
pp.factor = 1;
setmode |= AUMODE_PLAY;
 2547         }
 2549         if (ai->mode != ~0) {
 2550                 if (!cleared)
audio_clear(sc);
modechange = cleared = 1;
sc->sc_mode = ai->mode;
 2554                 if (sc->sc_mode & AUMODE_PLAY_ALL)
sc->sc_mode |= AUMODE_PLAY;
 2556                 if ((sc->sc_mode & AUMODE_PLAY) && !sc->sc_full_duplex)
 2557                         /* Play takes precedence */
sc->sc_mode &= ~AUMODE_RECORD;
 2559         }
 2561         if (modechange) {
 2562                 int indep = hw->get_props(sc->hw_hdl) & AUDIO_PROP_INDEPENDENT;
 2563                 if (!indep) {
 2564                         if (setmode == AUMODE_RECORD)
pp = rp;
 2566                         else if (setmode == AUMODE_PLAY)
rp = pp;
 2568                 }
error = hw->set_params(sc->hw_hdl, setmode,
sc->sc_mode & (AUMODE_PLAY | AUMODE_RECORD), &pp, &rp);
 2571                 if (error)
 2572                         return (error);
 2573                 if (!indep) {
 2574                         if (setmode == AUMODE_RECORD) {
pp.sample_rate = rp.sample_rate;
pp.encoding    = rp.encoding;
pp.channels    = rp.channels;
pp.precision   = rp.precision;
 2579                         } else if (setmode == AUMODE_PLAY) {
rp.sample_rate = pp.sample_rate;
rp.encoding    = pp.encoding;
rp.channels    = pp.channels;
rp.precision   = pp.precision;
 2584                         }
 2585                 }
sc->sc_rparams = rp;
sc->sc_pparams = pp;
 2588         }
oldpblksize = sc->sc_pr.blksize;
oldrblksize = sc->sc_rr.blksize;
 2592         /* Play params can affect the record params, so recalculate blksize. */
 2593         if (nr || np) {
audio_calc_blksize(sc, AUMODE_RECORD);
audio_calc_blksize(sc, AUMODE_PLAY);
 2596         }
 2597 #ifdef AUDIO_DEBUG
 2598         if (audiodebug > 1 && nr)
audio_print_params("After setting record params", &sc->sc_rparams);
 2600         if (audiodebug > 1 && np)
audio_print_params("After setting play params", &sc->sc_pparams);
 2602 #endif
 2604         if (p->port != ~0) {
 2605                 if (!cleared)
audio_clear(sc);
cleared = 1;
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)
audio_clear(sc);
cleared = 1;
error = au_set_port(sc, &sc->sc_inports, r->port);
 2619                 if (error)
 2620                         return(error);
 2621         }
 2622         if (p->gain != ~0) {
au_get_gain(sc, &sc->sc_outports, &gain, &balance);
error = au_set_gain(sc, &sc->sc_outports, p->gain, balance);
 2625                 if (error)
 2626                         return(error);
 2627         }
 2628         if (r->gain != ~0) {
au_get_gain(sc, &sc->sc_inports, &gain, &balance);
error = au_set_gain(sc, &sc->sc_inports, r->gain, balance);
 2631                 if (error)
 2632                         return(error);
 2633         }
 2635         if (p->balance != (u_char)~0) {
au_get_gain(sc, &sc->sc_outports, &gain, &balance);
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) {
au_get_gain(sc, &sc->sc_inports, &gain, &balance);
error = au_set_gain(sc, &sc->sc_inports, gain, r->balance);
 2644                 if (error)
 2645                         return(error);
 2646         }
 2648         if (ai->monitor_gain != ~0 &&
sc->sc_monitor_port != -1) {
mixer_ctrl_t ct;
ct.dev = sc->sc_monitor_port;
ct.type = AUDIO_MIXER_VALUE;
ct.un.value.num_channels = 1;
ct.un.value.level[AUDIO_MIXER_LEVEL_MONO] = ai->monitor_gain;
error = sc->hw_if->set_port(sc->hw_hdl, &ct);
 2657                 if (error)
 2658                         return(error);
 2659         }
 2661         if (ai->blocksize != ~0) {
 2662                 /* Block size specified explicitly. */
 2663                 if (!cleared)
audio_clear(sc);
cleared = 1;
 2667                 if (ai->blocksize == 0) {
audio_calc_blksize(sc, AUMODE_RECORD);
audio_calc_blksize(sc, AUMODE_PLAY);
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) {
rbs = hw->round_blocksize(sc->hw_hdl, rbs);
pbs = hw->round_blocksize(sc->hw_hdl, pbs);
 2677                         }
sc->sc_rr.blksize = rbs;
sc->sc_pr.blksize = pbs;
sc->sc_blkset = 1;
 2681                 }
 2682         }
 2684         if (ai->mode != ~0) {
 2685                 if (sc->sc_mode & AUMODE_PLAY)
audio_init_play(sc);
 2687                 if (sc->sc_mode & AUMODE_RECORD)
audio_init_record(sc);
 2689         }
 2691         if (hw->commit_settings) {
error = hw->commit_settings(sc->hw_hdl);
 2693                 if (error)
 2694                         return (error);
 2695         }
 2697         if (cleared) {
s = splaudio();
error = audio_initbufs(sc);
 2700                 if (error) goto err;
 2701                 if (sc->sc_pr.blksize != oldpblksize ||
sc->sc_rr.blksize != oldrblksize)
audio_calcwater(sc);
 2704                 if ((sc->sc_mode & AUMODE_PLAY) &&
pbus && !sc->sc_pbus && !sc->sc_pr.pause)
error = audiostartp(sc);
 2707                 if (!error &&
 2708                     (sc->sc_mode & AUMODE_RECORD) &&
rbus && !sc->sc_rbus && !sc->sc_rr.pause)
error = audiostartr(sc);
err:
splx(s);
 2713                 if (error)
 2714                         return error;
 2715         }
 2717         /* Change water marks after initializing the buffers. */
 2718         if (ai->hiwat != ~0) {
blks = ai->hiwat;
 2720                 if (blks > sc->sc_pr.maxblks)
blks = sc->sc_pr.maxblks;
 2722                 if (blks < 2)
blks = 2;
sc->sc_pr.usedhigh = blks * sc->sc_pr.blksize;
 2725         }
 2726         if (ai->lowat != ~0) {
blks = ai->lowat;
 2728                 if (blks > sc->sc_pr.maxblks - 1)
blks = sc->sc_pr.maxblks - 1;
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)
sc->sc_pr.usedlow = sc->sc_pr.usedhigh - sc->sc_pr.blksize;
 2735         }
 2737         if (p->pause != (u_char)~0) {
sc->sc_pr.pause = p->pause;
 2739                 if (!p->pause && !sc->sc_pbus && (sc->sc_mode & AUMODE_PLAY)) {
s = splaudio();
error = audiostartp(sc);
splx(s);
 2743                         if (error)
 2744                                 return error;
 2745                 }
 2746         }
 2747         if (r->pause != (u_char)~0) {
sc->sc_rr.pause = r->pause;
 2749                 if (!r->pause && !sc->sc_rbus && (sc->sc_mode & AUMODE_RECORD)) {
s = splaudio();
error = audiostartr(sc);
splx(s);
 2753                         if (error)
 2754                                 return error;
 2755                 }
 2756         }
 2758         return (0);
 2759 }
 2761 int
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;
 2767         if (hw == 0)            /* HW has not attached */
 2768                 return(ENXIO);
p->sample_rate = sc->sc_pparams.sample_rate;
r->sample_rate = sc->sc_rparams.sample_rate;
p->channels = sc->sc_pparams.channels;
r->channels = sc->sc_rparams.channels;
p->precision = sc->sc_pparams.precision;
r->precision = sc->sc_rparams.precision;
p->encoding = sc->sc_pparams.encoding;
r->encoding = sc->sc_rparams.encoding;
r->port = au_get_port(sc, &sc->sc_inports);
p->port = au_get_port(sc, &sc->sc_outports);
r->avail_ports = sc->sc_inports.allports;
p->avail_ports = sc->sc_outports.allports;
au_get_gain(sc, &sc->sc_inports,  &r->gain, &r->balance);
au_get_gain(sc, &sc->sc_outports, &p->gain, &p->balance);
 2788         if (sc->sc_monitor_port != -1) {
mixer_ctrl_t ct;
ct.dev = sc->sc_monitor_port;
ct.type = AUDIO_MIXER_VALUE;
ct.un.value.num_channels = 1;
 2794                 if (sc->hw_if->get_port(sc->hw_hdl, &ct))
ai->monitor_gain = 0;
 2796                 else
ai->monitor_gain =
ct.un.value.level[AUDIO_MIXER_LEVEL_MONO];
 2799         } else
ai->monitor_gain = 0;
p->seek = sc->sc_pr.used / sc->sc_pparams.factor;
r->seek = sc->sc_rr.used / sc->sc_rparams.factor;
p->samples = sc->sc_pr.stamp - sc->sc_pr.drops;
r->samples = sc->sc_rr.stamp - sc->sc_rr.drops;
p->eof = sc->sc_eof;
r->eof = 0;
p->pause = sc->sc_pr.pause;
r->pause = sc->sc_rr.pause;
p->error = sc->sc_pr.drops != 0;
r->error = sc->sc_rr.drops != 0;
p->waiting = r->waiting = 0;            /* open never hangs */
p->open = (sc->sc_open & AUOPEN_WRITE) != 0;
r->open = (sc->sc_open & AUOPEN_READ) != 0;
p->active = sc->sc_pbus;
r->active = sc->sc_rbus;
p->buffer_size = sc->sc_pr.bufsize / sc->sc_pparams.factor;
r->buffer_size = sc->sc_rr.bufsize / sc->sc_rparams.factor;
 2828         if ((ai->blocksize = sc->sc_pr.blksize / sc->sc_pparams.factor) != 0) {
ai->hiwat = sc->sc_pr.usedhigh / sc->sc_pr.blksize;
ai->lowat = sc->sc_pr.usedlow / sc->sc_pr.blksize;
 2831         } else {
ai->hiwat = ai->lowat = 0;
 2833         }
ai->mode = sc->sc_mode;
 2836         return (0);
 2837 }
 2839 /*
 2840  * Mixer driver
 2841  */
 2842 int
mixer_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
 2844     struct proc *p)
 2845 {
DPRINTF(("mixer_open: dev=0x%x flags=0x%x sc=%p\n", dev, flags, sc));
 2848         return (0);
 2849 }
 2851 /*
 2852  * Remove a process from those to be signalled on mixer activity.
 2853  */
 2854 static void
mixer_remove(struct audio_softc *sc, struct proc *p)
 2856 {
 2857         struct mixer_asyncs **pm, *m;
 2859         for(pm = &sc->sc_async_mixer; *pm; pm = &(*pm)->next) {
 2860                 if ((*pm)->proc == p) {
m = *pm;
 2862                         *pm = m->next;
free(m, M_DEVBUF);
 2864                         return;
 2865                 }
 2866         }
 2867 }
 2869 /*
 2870  * Signal all processes waitinf for the mixer.
 2871  */
 2872 static void
mixer_signal(struct audio_softc *sc)
 2874 {
 2875         struct mixer_asyncs *m;
 2877         for(m = sc->sc_async_mixer; m; m = m->next)
psignal(m->proc, SIGIO);
 2879 }
 2881 /*
 2882  * Close a mixer device
 2883  */
 2884 /* ARGSUSED */
 2885 int
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];
DPRINTF(("mixer_close: unit %d\n", AUDIOUNIT(dev)));
mixer_remove(sc, p);
 2895         return (0);
 2896 }
 2898 int
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;
DPRINTF(("mixer_ioctl(%d,'%c',%d)\n",
IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff));
 2909         switch (cmd) {
 2910         case FIOASYNC:
mixer_remove(sc, p); /* remove old entry */
 2912                 if (*(int *)addr) {
 2913                         struct mixer_asyncs *ma;
ma = malloc(sizeof (struct mixer_asyncs),
M_DEVBUF, M_WAITOK);
ma->next = sc->sc_async_mixer;
ma->proc = p;
sc->sc_async_mixer = ma;
 2919                 }
error = 0;
 2921                 break;
 2923         case AUDIO_GETDEV:
DPRINTF(("AUDIO_GETDEV\n"));
error = hw->getdev(sc->hw_hdl, (audio_device_t *)addr);
 2926                 break;
 2928         case AUDIO_MIXER_DEVINFO:
DPRINTF(("AUDIO_MIXER_DEVINFO\n"));
 2930                 ((mixer_devinfo_t *)addr)->un.v.delta = 0; /* default */
error = hw->query_devinfo(sc->hw_hdl, (mixer_devinfo_t *)addr);
 2932                 break;
 2934         case AUDIO_MIXER_READ:
DPRINTF(("AUDIO_MIXER_READ\n"));
error = hw->get_port(sc->hw_hdl, (mixer_ctrl_t *)addr);
 2937                 break;
 2939         case AUDIO_MIXER_WRITE:
 2940                 if (!(flag & FWRITE))
 2941                         return (EACCES);
DPRINTF(("AUDIO_MIXER_WRITE\n"));
error = hw->set_port(sc->hw_hdl, (mixer_ctrl_t *)addr);
 2944                 if (!error && hw->commit_settings)
error = hw->commit_settings(sc->hw_hdl);
 2946                 if (!error)
mixer_signal(sc);
 2948                 break;
 2950         default:
error = ENOTTY;
 2952                 break;
 2953         }
DPRINTF(("mixer_ioctl(%d,'%c',%d) result %d\n",
IOCPARM_LEN(cmd), IOCGROUP(cmd), cmd&0xff, error));
 2956         return (error);
 2957 }
 2958 #endif
 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;
 2968         switch (kn->kn_filter) {
 2969         case EVFILT_READ:
klist = &sc->sc_rsel.si_note;
kn->kn_fop = &audioread_filtops;
 2972                 break;
 2973         case EVFILT_WRITE:
klist = &sc->sc_wsel.si_note;
kn->kn_fop = &audiowrite_filtops;
 2976                 break;
 2977         default:
 2978                 return (1);
 2979         }
kn->kn_hook = (void *)sc;
s = splaudio();
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
splx(s);
 2986         return (0);
 2987 }
 2989 void
filt_audiordetach(struct knote *kn)
 2991 {
 2992         struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
 2993         int s = splaudio();
SLIST_REMOVE(&sc->sc_rsel.si_note, kn, knote, kn_selnext);
splx(s);
 2997 }
 2999 int
filt_audioread(struct knote *kn, long hint)
 3001 {
 3002         struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
 3004         return AUDIO_FILTREAD(sc);
 3005 }
 3007 void
filt_audiowdetach(struct knote *kn)
 3009 {
 3010         struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
 3011         int s = splaudio();
SLIST_REMOVE(&sc->sc_wsel.si_note, kn, knote, kn_selnext);
splx(s);
 3015 }
 3017 int
filt_audiowrite(struct knote *kn, long hint)
 3019 {
 3020         struct audio_softc *sc = (struct audio_softc *)kn->kn_hook;
 3022         return AUDIO_FILTWRITE(sc);
 3023 }
 3025 #if NAUDIO > 0 && NWSKBD > 0
 3026 int
wskbd_get_mixerdev(struct audio_softc *sc, int dir, int *index)
 3028 {
mixer_devinfo_t mi;
 3030         int mixer_class;
 3031         int error;
 3033         /* looking for ``outputs'' */
 3034         for (mi.index = 0; ; mi.index++) {
error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
 3036                 if (error != 0)
 3037                         return (-1);
 3039                 if (mi.type == AUDIO_MIXER_CLASS &&
strcmp(mi.label.name, AudioCoutputs) == 0) {
mixer_class = mi.mixer_class;
 3042                         break;
 3043                 }
 3044         }
 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++) {
error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
 3053                 if (error != 0)
 3054                         return (-1);
 3056                 if (mi.type == AUDIO_MIXER_VALUE &&
mi.mixer_class == mixer_class &&
strcmp(mi.label.name, AudioNmaster) == 0) {
 3059                         if (dir == 0) {
 3060                                 /* looking for ``outputs.master.mute'' */
 3061                                 if (mi.next < 0)
 3062                                         return (-1);
mi.index = mi.next;
error = sc->hw_if->query_devinfo(sc->hw_hdl,
 3066                                     &mi);
 3067                                 if (error != 0)
 3068                                         return (-1);
 3070                                 if (mi.type != AUDIO_MIXER_ENUM ||
strcmp(mi.label.name, AudioNmute) != 0)
 3072                                         return (-1);
 3073                         }
 3075                         *index = mi.index;
 3076                         return (0);
 3077                 }
 3078         }
 3080         return (-1);
 3081 }
 3083 int
wskbd_set_mixervolume(long dir)
 3085 {
 3086         struct audio_softc *sc;
mixer_devinfo_t mi;
mixer_ctrl_t ct;
 3089         int l, r;
 3090         int error;
 3092         if (audio_cd.cd_ndevs == 0 || (sc = audio_cd.cd_devs[0]) == NULL) {
DPRINTF(("wskbd_set_mixervolume: audio_cd\n"));
 3094                 return (ENXIO);
 3095         }
error = wskbd_get_mixerdev(sc, dir, &ct.dev);
 3098         if (error == -1) {
DPRINTF(("wskbd_set_mixervolume: wskbd_get_mixerdev\n"));
 3100                 return (ENXIO);
 3101         }
 3103         if (dir == 0) {
 3104                 /*
 3105                  * Mute.
 3106                  * Use mixer_ioctl() for writing. It does many things for us.
 3107                  */
ct.type = AUDIO_MIXER_ENUM;
error = sc->hw_if->get_port(sc->hw_hdl, &ct);
 3110                 if (error != 0) {
DPRINTF(("wskbd_set_mixervolume:"
 3112                             " get_port: %d\n", error));
 3113                         return (error);
 3114                 }
ct.un.ord = !ct.un.ord; /* toggle */
error = mixer_ioctl(MIXER_DEVICE,
AUDIO_MIXER_WRITE, (caddr_t)&ct, FWRITE, curproc);
 3120                 if (error != 0) {
DPRINTF(("wskbd_set_mixervolume:"
 3122                             " mixer_ioctl: %d\n", error));
 3123                         return (error);
 3124                 }
 3125         } else {
mi.index = ct.dev;
error = sc->hw_if->query_devinfo(sc->hw_hdl, &mi);
 3128                 if (error != 0) {
DPRINTF(("wskbd_set_mixervolume:"
 3130                             " query_devinfo: %d\n", error));
 3131                         return (error);
 3132                 }
ct.type = AUDIO_MIXER_VALUE;
error = au_get_lr_value(sc, &ct, &l, &r);
 3137                 if (error != 0) {
DPRINTF(("wskbd_set_mixervolume:"
 3139                             " au_get_lr_value: %d\n", error));
 3140                         return (error);
 3141                 }
 3143                 if (dir > 0) {
 3144                         /*
 3145                          * Raise volume
 3146                          */
 3147                         if (l > AUDIO_MAX_GAIN - mi.un.v.delta)
l = AUDIO_MAX_GAIN;
 3149                         else
l += mi.un.v.delta;
 3152                         if (r > AUDIO_MAX_GAIN - mi.un.v.delta)
r = AUDIO_MAX_GAIN;
 3154                         else
r += mi.un.v.delta;
 3157                 } else {
 3158                         /*
 3159                          * Lower volume
 3160                          */
 3161                         if (l < AUDIO_MIN_GAIN + mi.un.v.delta)
l = AUDIO_MIN_GAIN;
 3163                         else
l -= mi.un.v.delta;
 3166                         if (r < AUDIO_MIN_GAIN + mi.un.v.delta)
r = AUDIO_MIN_GAIN;
 3168                         else
r -= mi.un.v.delta;
 3170                 }
error = au_set_lr_value(sc, &ct, l, r);
 3173                 if (error != 0) {
DPRINTF(("wskbd_set_mixervolume:"
 3175                             " au_set_lr_value: %d\n", error));
 3176                         return (error);
 3177                 }
 3178         }
 3180         return (0);
 3181 }
 3182 #endif /* NAUDIO > 0 && NWSKBD > 0 */