struct audio_hw_if {
int (*open)(void *, int);
void (*close)(void *);
int (*drain)(void *);
int (*query_encoding)(void *, struct audio_encoding *);
int (*set_params)(void *, int, int,
audio_params_t *, audio_params_t *,
stream_filter_list_t *, stream_filter_list_t *);
int (*round_blocksize)(void *, int, int, const audio_params_t *);
int (*commit_settings)(void *);
int (*init_output)(void *, void *, int);
int (*init_input)(void *, void *, int);
int (*start_output)(void *, void *, int, void (*)(void *),
void *);
int (*start_input)(void *, void *, int, void (*)(void *),
void *);
int (*halt_output)(void *);
int (*halt_input)(void *);
int (*speaker_ctl)(void *, int);
#define SPKR_ON 1
#define SPKR_OFF 0
int (*getdev)(void *, struct audio_device *);
int (*setfd)(void *, int);
int (*set_port)(void *, mixer_ctrl_t *);
int (*get_port)(void *, mixer_ctrl_t *);
int (*query_devinfo)(void *, mixer_devinfo_t *);
void *(*allocm)(void *, int, size_t, struct malloc_type *, int);
void (*freem)(void *, void *, struct malloc_type *);
size_t (*round_buffersize)(void *, int, size_t);
paddr_t (*mappage)(void *, void *, off_t, int);
int (*get_props)(void *);
int (*trigger_output)(void *, void *, void *, int,
void (*)(void *), void *, const audio_params_t *);
int (*trigger_input)(void *, void *, void *, int,
void (*)(void *), void *, const audio_params_t *);
int (*dev_ioctl)(void *, u_long, void *, int, struct lwp *);
int (*powerstate)(void *, int);
#define AUDIOPOWER_ON 1
#define AUDIOPOWER_OFF 0
};
typedef struct audio_params {
u_int sample_rate; /* sample rate */
u_int encoding; /* e.g. mu-law, linear, etc */
u_int precision; /* bits/subframe */
u_int validbits; /* valid bits in a subframe */
u_int channels; /* mono(1), stereo(2) */
} audio_params_t;
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 processes in these. The data is presented to the lower level in smaller chunks, called blocks. If, during playback, there is no data available from the user process when the hardware request 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)
void
close(void
*hdl)
int
drain(void
*hdl)
AUDIO_DRAIN
is called.
It should make sure that no samples remain in to be played that could
be lost when
close
is called.
Return 0 on success, otherwise an error code.
int
query_encoding(void
*hdl,
struct
audio_encoding
*ae)
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,
audio_params_t *play, audio_params_t *rec,
stream_filter_list_t *pfil, stream_filter_list_t *rfil)
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 structures contain the encoding parameters that should be set. 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 supported, but one close enough is).
If the hardware requires software assistance with some encoding
(e.g., it might be lacking mu-law support) it should fill the
pfil
for playing or
rfil
for recording with conversion information.
For example, if
play
requests [8000Hz, mu-law, 8/8bit, 1ch] and the hardware does not
support 8bit mu-law, but 16bit slinear_le, the driver should call
pfil->append()
with
pfil,
mulaw_to_slinear16,
and audio_params_t representing [8000Hz, slinear_le, 16/16bit, 2ch].
If the driver needs multiple conversions, a conversion nearest to the
hardware should be set to the head of
pfil
or
rfil.
The definition of
stream_filter_list_t
follows:
typedef struct stream_filter_list {
void (*append)(struct stream_filter_list *,
stream_filter_factory_t,
const audio_params_t *);
void (*prepend)(struct stream_filter_list *,
stream_filter_factory_t,
const audio_params_t *);
void (*set)(struct stream_filter_list *, int,
stream_filter_factory_t,
const audio_params_t *);
int req_size;
struct stream_filter_req {
stream_filter_factory_t *factory;
audio_params_t param; /* from-param for recording,
to-param for playing */
} filters[AUDIO_MAX_FILTERS];
} stream_filter_list_t;
For playing,
pfil
constructs conversions as follows:
(play) == write(2) input
| pfil->filters[pfil->req_size-1].factory
(pfil->filters[pfil->req_size-1].param)
| pfil->filters[pfil->req_size-2].factory
:
| pfil->filters[1].factory
(pfil->filters[1].param)
| pfil->filters[0].factory
(pfil->filters[0].param) == hardware input
For recording,
rfil
constructs conversions as follows:
(rfil->filters[0].param) == hardware output
| rfil->filters[0].factory
(rfil->filters[1].param)
| rfil->filters[1].factory
:
| rfil->filters[rfil->req_size-2].factory
(rfil->filters[rfil->req_size-1].param)
| rfil->filters[rfil->req_size-1].factory
(rec) == read(2) output
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, otherwise an error code.
int
round_blocksize(void
*hdl,
int
bs,
int
mode,
const audio_params_t *param)
optional, is called with the block size,
bs,
that has been computed by the upper layer,
mode,
AUMODE_PLAY
or
AUMODE_RECORD
,
and
param,
encoding parameters for the hardware.
It should return a block size, possibly changed according to the needs
of the hardware driver.
int
commit_settings(void
*hdl)
int
init_output(void
*hdl,
void
*buffer,
int
size)
int
init_input(void
*hdl,
void
*buffer,
int
size)
int
start_output(void
*hdl,
void
*block,
int
blksize,
void (*intr)(void*), void *intrarg)
is called to start the transfer of blksize 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
blksize,
void (*intr)(void*), void *intrarg)
is called to start the transfer of blksize 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)
int
halt_input(void
*hdl)
int
speaker_ctl(void
*hdl,
int
on)
int
getdev(void
*hdl,
struct
audio_device
*ret)
int
setfd(void
*hdl,
int
fd)
AUDIO_SETFD
is used, but only if the device has AUDIO_PROP_FULLDUPLEX set.
Return 0 on success, otherwise an error code.
int
set_port(void
*hdl,
mixer_ctrl_t
*mc)
AUDIO_MIXER_WRITE
is used.
It should take data from the
mixer_ctrl_t
struct at set the corresponding mixer values.
Return 0 on success, otherwise an error code.
int
get_port(void
*hdl,
mixer_ctrl_t
*mc)
AUDIO_MIXER_READ
is used.
It should fill the
mixer_ctrl_t
struct.
Return 0 on success, otherwise an error code.
int
query_devinfo(void
*hdl,
mixer_devinfo_t
*di)
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, struct malloc_type *type, int flags)
optional, is called to allocate the device buffers. If not present malloc(9) is used instead (with the same arguments but the first two). The reason for using a device dependent routine instead 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,
struct
malloc_type
*type)
size_t
round_buffersize(void
*hdl,
int
direction,
size_t
bufsize)
paddr_t mappage(void *hdl, void *addr, off_t 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)
int
trigger_output(void
*hdl,
void
*start,
void
*end,
int blksize, void (*intr)(void*), void *intrarg,
const audio_params_t *param)
optional, is called to start the transfer of data from the circular buffer delimited by start and end to the audio hardware, parameterized as in param. The call should return when the data transfer has been initiated (normally with DMA). When the hardware is finished transferring each blksize sized block, the function 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 success, otherwise an error code.
int
trigger_input(void
*hdl,
void
*start,
void
*end,
int blksize, void (*intr)(void*), void *intrarg,
const audio_params_t *param)
optional, is called to start the transfer of data from the audio hardware, parameterized as in param, to the circular buffer delimited by start and end. The call should return when the data transfer has been initiated (normally with DMA). When the hardware is finished transferring each blksize sized block, the function 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 success, otherwise an error code.
int
dev_ioctl(void
*hdl,
u_long
cmd,
void
*addr,
int flag, struct lwp *l)
optional, is called when an ioctl(2) is not recognized by the generic audio driver. Return 0 on success, otherwise an error code.
int
powerstate(void
*hdl,
int
state)
optional, is called on the first open and last close of the audio
device.
state
may be one of
AUDIOPOWER_ON
or
AUDIOPOWER_OFF
.
Returns 0 on success, 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,
and
AUDIO_GETINFO
to read them, as follows.
If the record mixer 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.
Each of the named sources for which the recording level can be set
should have a control in the
AudioCrecord
class of type
AUDIO_MIXER_VALUE
,
except the
"mixerout
source is special,
and will never have its own control.
Its selection signifies,
rather,
that various sources in class
AudioCrecord
will be combined and presented to the single recording output
in the same fashion that the sources of class
AudioCinputs
are combined and presented to the playback output(s).
If the overall recording level can be changed,
regardless of the input source,
then this control should be named
AudioNmaster
and be of class
AudioCrecord
.
Controls for various sources that affect only the playback output,
as opposed to recording,
should be in the
AudioCinputs
class,
as of course should any controls that affect both playback and recording.
If the play
mixer is capable of output to more than one destination,
it should define
AudioNselect
in class
AudioCoutputs
.
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 for which the output level can be set,
there should be
a control in the
AudioCoutputs
class of type
AUDIO_MIXER_VALUE
.
If the overall output level can be changed,
which is invariably the case,
then this control should be named
AudioNmaster
and be of class
AudioCoutputs
.
There's one additional source recognized specially by
AUDIO_SETINFO
and
AUDIO_GETINFO
,
to be presented as monitor_gain,
and that is a control named
AudioNmonitor
,
of class
AudioCmonitor
.