AUDIO(9)                     OpenBSD Kernel Manual                    AUDIO(9)

NAME
     audio - interface between low and high level audio drivers

DESCRIPTION
     The audio device driver is divided into a high level, hardware indepen-
     dent layer, and a low level hardware dependent layer.  The interface be-
     tween these is the audio_hw_if structure.

     struct audio_hw_if {
             int     (*open)__P((void *, int));
             void    (*close)__P((void *));
             int     (*drain)__P((void *));

             int     (*query_encoding)__P((void *, struct audio_encoding *));
             int     (*set_params)__P((void *, int, int,
                             struct audio_params *, struct audio_params *));
             int     (*round_blocksize)__P((void *, int));

             int     (*commit_settings)__P((void *));

             int     (*init_output)__P((void *, void *, int));
             int     (*init_input)__P((void *, void *, int));
             int     (*start_output)__P((void *, void *, int,
                                         void (*)(void *), void *));
             int     (*start_input)__P((void *, void *, int,
                                        void (*)(void *), void *));
             int     (*halt_output)__P((void *));
             int     (*halt_input)__P((void *));

             int     (*speaker_ctl)__P((void *, int));
     #define SPKR_ON  1
     #define SPKR_OFF 0

             int     (*getdev)__P((void *, struct audio_device *));
             int     (*setfd)__P((void *, int));

             int     (*set_port)__P((void *, mixer_ctrl_t *));
             int     (*get_port)__P((void *, mixer_ctrl_t *));

             int     (*query_devinfo)__P((void *, mixer_devinfo_t *));

             void    *(*allocm)__P((void *, int, size_t, int, int));
             void    (*freem)__P((void *, void *, int));
             size_t  (*round_buffersize)__P((void *, int, size_t));
             int     (*mappage)__P((void *, void *, int, int));

             int     (*get_props)__P((void *));

             int     (*trigger_output)__P((void *, void *, void *, int,
                             void (*)(void *), void *, struct audio_params *));
             int     (*trigger_input)__P((void *, void *, void *, int,
                             void (*)(void *), void *, struct audio_params *));
     };

     struct audio_params {
             u_long  sample_rate;            /* sample rate */
             u_int   encoding;               /* ulaw, linear, etc */
             u_int   precision;              /* bits/sample */
             u_int   channels;               /* mono(1), stereo(2) */
             /* Software en/decode functions, set if SW coding required by HW */
             void    (*sw_code)__P((void *, u_char *, int));
             int     factor;                 /* coding space change */
     };

     The high level audio driver attaches to the low level driver when the
     latter calls audio_attach_mi. This call should be

         void
         audio_attach_mi(ahwp, hdl, dev)
             struct audio_hw_if *ahwp;
             void *hdl;
             struct device *dev;

     The audio_hw_if struct is as shown above.  The hdl argument is a handle
     to some low level data structure.  It is sent as the first argument to
     all the functions in audio_hw_if when the high level driver calls them.
     dev is the device struct for the hardware device.

     The upper layer of the audio driver allocates one buffer for playing and
     one for recording.  It handles the buffering of data from the user pro-
     cesses in these.  The data is presented to the lower level in smaller
     chunks, called blocks.  If there, during playback, is no data available
     from the user process when the hardware requests another block, a block
     of silence will be used instead.  Furthermore, if the user process does
     not read data quickly enough during recording, data will be thrown away.

     The fields of audio_hw_if are described in some more detail below.  Some
     fields are optional and can be set to 0 if not needed.

     int open(void *hdl, int flags)
             is called when the audio device is opened.  It should initialize
             the hardware for I/O.  Every successful call to open is matched
             by a call to close. Return 0 on success, otherwise an error code.

     void close(void *hdl)
             is called when the audio device is closed.

     int drain(void *hdl)
             optional, is called before the device is closed or when
             AUDIO_DRAIN is called.  It should make sure that no samples re-
             main to be played that could be lost when close is called.  Re-
             turn 0 on success, otherwise an error code.

     int query_encoding(void *hdl, struct audio_encoding *ae)
             is used when AUDIO_GETENC is called.  It should fill the
             audio_encoding structure and return 0 or, if there is no encoding
             with the given number, return EINVAL.

     int set_params(void *hdl, int setmode, int usemode,
             struct audio_params *play, struct audio_params *rec)
             Called to set the audio encoding mode.  setmode is a combination
             of the AUMODE_RECORD and AUMODE_PLAY flags to indicate which
             mode(s) are to be set.  usemode is also a combination of these
             flags, but indicates the current mode of the device (i.e., the
             value of mode in the audio_info struct).  The play and rec struc-
             tures contain the encoding parameters that should be set.  If the
             hardware requires software assistance with some encoding (e.g.,
             it might be lacking mulaw support) it should fill the sw_code and
             factor fields of these structures.  The values of the structures
             may also be modified if the hardware cannot be set to exactly the
             requested mode (e.g., if the requested sampling rate is not sup-
             ported, but one close enough is).  If the device does not have
             the AUDIO_PROP_INDEPENDENT property the same value is passed in
             both play and rec and the encoding parameters from play is copied
             into rec after the call to set_params. Return 0 on success, oth-
             erwise an error code.

     int round_blocksize(void *hdl, int bs)
             optional, is called with the block size, bs, that has been com-
             puted by the upper layer.  It should return a block size, possi-
             bly changed according to the needs of the hardware driver.

     int commit_settings(void *hdl)
             optional, is called after all calls to set_params, and set_port,
             are done.  A hardware driver that needs to get the hardware in
             and out of command mode for each change can save all the changes
             during previous calls and do them all here.  Return 0 on success,
             otherwise an error code.

     int init_output(void *hdl, void *buffer, int size)
             optional, is called before any output starts, but when the total
             size of the output buffer has been determined.  It can be used to
             initialize looping DMA for hardware that needs it.  Return 0 on
             success, otherwise an error code.

     int init_input(void *hdl, void *buffer, int size)
             optional, is called before any input starts, but when the total
             size of the input buffer has been determined.  It can be used to
             initialize looping DMA for hardware that needs it.  Return 0 on
             success, otherwise an error code.

     int start_output(void *hdl, void *block, int bsize,
             void (*intr)(void*), void *intrarg)
             is called to start the transfer of bsize bytes from block to the
             audio hardware.  The call should return when the data transfer
             has been initiated (normally with DMA).  When the hardware is
             ready to accept more samples the function intr should be called
             with the argument intrarg. Calling intr will normally initiate
             another call to start_output. Return 0 on success, otherwise an
             error code.

     int start_input(void *hdl, void *block, int bsize,
             void (*intr)(void*), void *intrarg)
             is called to start the transfer of bsize bytes to block from the
             audio hardware.  The call should return when the data transfer
             has been initiated (normally with DMA).  When the hardware is
             ready to deliver more samples the function intr should be called
             with the argument intrarg. Calling intr will normally initiate
             another call to start_input. Return 0 on success, otherwise an
             error code.

     int halt_output(void *hdl)
             is called to abort the output transfer (started by start_output)
             in progress.  Return 0 on success, otherwise an error code.

     int halt_input(void *hdl)
             is called to abort the input transfer (started by start_input) in
             progress.  Return 0 on success, otherwise an error code.

     int speaker_ctl(void *hdl, int on)
             optional, is called when a half duplex device changes between
             playing and recording.  It can, e.g., be used to turn the speaker
             on and off.  Return 0 on success, otherwise an error code.

     int getdev(void *hdl, struct audio_device *ret)
             Should fill the audio_device struct with relevant information
             about the driver.  Return 0 on success, otherwise an error code.

     int setfd(void *hdl, int fd)
             optional, is called when AUDIO_SETFD is used, but only if the de-
             vice has AUDIO_PROP_FULLDUPLEX set.  Return 0 on success, other-
             wise an error code.

     int set_port(void *hdl, mixer_ctl_t *mc)
             is called in when AUDIO_MIXER_WRITE is used.  It should take data
             from the mixer_ctl_t struct at set the corresponding mixer val-
             ues.  Return 0 on success, otherwise an error code.

     int get_port(void *hdl, mixer_ctl_t *mc)
             is called in when AUDIO_MIXER_READ is used.  It should fill the
             mixer_ctl_t struct.  Return 0 on success, otherwise an error
             code.

     int query_devinfo(void *hdl, mixer_devinfo_t *di)
             is called in when AUDIO_MIXER_DEVINFO is used.  It should fill
             the mixer_devinfo_t struct.  Return 0 on success, otherwise an
             error code.

     void *allocm(void *hdl, int direction, size_t size, int type, int flags)
             optional, is called to allocate the device buffers.  If not pre-
             sent malloc(9) is used instead (with the same arguments but the
             first two).  The reason for using a device dependent routine in-
             stead of malloc(9) is that some buses need special allocation to
             do DMA.  Returns the address of the buffer, or 0 on failure.

     void freem(void *hdl, void *addr, int type)
             optional, is called to free memory allocated by alloc. If not
             supplied free(9) is used.

     size_t round_buffersize(void *hdl, int direction, size_t bufsize)
             optional, is called at startup to determine the audio buffer
             size.  The upper layer supplies the suggested size in bufsize,
             which the hardware driver can then change if needed.  E.g., DMA
             on the ISA bus cannot exceed 65536 bytes.

     int mappage(void *hdl, void *addr, int offs, int prot)
             optional, is called for mmap(2). Should return the map value for
             the page at offset offs from address addr mapped with protection
             prot. Returns -1 on failure, or a machine dependent opaque value
             on success.

     int get_props(void *hdl)
             Should return the device properties; i.e., a combination of AU-
             DIO_PROP_xxx.

     int trigger_output(void *hdl, void *start, void *end,
             int blksize, void (*intr)(void*), void *intrarg,
             stuct audio_params *param)
             optional, is called to start the transfer of data from the circu-
             lar buffer delimited by start and end to the audio hardware, pa-
             rameterized as in param. The call should return when the data
             transfer has been initiated (normally with DMA).  When the hard-
             ware is finished transferring each bsize sized block, the func-
             tion intr should be called with the argument intrarg (typically
             from the audio hardware interrupt service routine).  Once started
             the transfer may be stopped using halt_output. Return 0 on suc-
             cess, otherwise an error code.

     int trigger_input(void *hdl, void *start, void *end,
             int blksize, void (*intr)(void*), void *intrarg,
             stuct audio_params *param)
             optional, is called to start the transfer of data from the audio
             hardware, parameterized as in param, to the circular buffer de-
             limited by start and end. The call should return when the data
             transfer has been initiated (normally with DMA).  When the hard-
             ware is finished transferring each bsize sized block, the func-
             tion intr should be called with the argument intrarg (typically
             from the audio hardware interrupt service routine).  Once started
             the transfer may be stopped using halt_input. Return 0 on suc-
             cess, otherwise an error code.

     The query_devinfo method should define certain mixer controls for
     AUDIO_SETINFO to be able to change the port and gain.

     If the audio hardware is capable of input from more than one source it
     should define AudioNsource in class AudioCrecord. This mixer control
     should be of type AUDIO_MIXER_ENUM or AUDIO_MIXER_SET and enumerate the
     possible input sources.  For each of the named sources there should be a
     control in the AudioCinputs class of type AUDIO_MIXER_VALUE if recording
     level of the source can be set.  If the overall recording level can be
     changed (i.e., regardless of the input source) then this control should
     be named AudioNrecord and be of class AudioCinputs.

     If the audio hardware is capable of output to more than one destination
     it should define AudioNoutput in class AudioCmonitor. This mixer control
     should be of type AUDIO_MIXER_ENUM or AUDIO_MIXER_SET and enumerate the
     possible destinations.  For each of the named destinations there should
     be a control in the AudioCoutputs class of type AUDIO_MIXER_VALUE if out-
     put level of the destination can be set.  If the overall output level can
     be changed (i.e., regardless of the destination) then this control should
     be named AudioNmaster and be of class AudioCoutputs.

SEE ALSO
     audio(4)

HISTORY
     This audio interface first appeared in NetBSD 1.3.

OpenBSD 2.8                    February 11, 2000                             5
