This document is free; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This document is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Table of Contents
Table of Contents
snd_card_create — create and initialize a soundcard structure
int snd_card_create ( | idx, | |
| xid, | ||
| module, | ||
| extra_size, | ||
card_ret); |
int idx;const char * xid;struct module * module;int extra_size;struct snd_card ** card_ret;snd_card_disconnect — disconnect all APIs from the file-operations (user space)
int snd_card_disconnect ( | card); |
struct snd_card * card;snd_card_set_id — set card identification name
void snd_card_set_id ( | card, | |
nid); |
struct snd_card * card;const char * nid;snd_card_register — register the soundcard
int snd_card_register ( | card); |
struct snd_card * card;This function registers all the devices assigned to the soundcard. Until calling this, the ALSA control interface is blocked from the external accesses. Thus, you should call this function at the end of the initialization of the card.
Returns zero otherwise a negative error code if the registration failed.
snd_component_add — add a component string
int snd_component_add ( | card, | |
component); |
struct snd_card * card;const char * component;snd_card_file_add — add the file to the file list of the card
int snd_card_file_add ( | card, | |
file); |
struct snd_card * card;struct file * file;snd_card_file_remove — remove the file from the file list
int snd_card_file_remove ( | card, | |
file); |
struct snd_card * card;struct file * file;snd_device_new — create an ALSA device component
int snd_device_new ( | card, | |
| type, | ||
| device_data, | ||
ops); |
struct snd_card * card;snd_device_type_t type;void * device_data;struct snd_device_ops * ops;cardthe card instance
typethe device type, SNDRV_DEV_XXX
device_datathe data pointer of this device
opsthe operator table
Creates a new device component for the given data pointer. The device will be assigned to the card and managed together by the card.
The data pointer plays a role as the identifier, too, so the pointer address must be unique and unchanged.
Returns zero if successful, or a negative error code on failure.
snd_device_free — release the device from the card
int snd_device_free ( | card, | |
device_data); |
struct snd_card * card;void * device_data;snd_device_register — register the device
int snd_device_register ( | card, | |
device_data); |
struct snd_card * card;void * device_data;
Registers the device which was already created via
snd_device_new. Usually this is called from snd_card_register,
but it can be called later if any new devices are created after
invocation of snd_card_register.
Returns zero if successful, or a negative error code on failure or if the device not found.
snd_lookup_minor_data — get user data of a registered device
void * snd_lookup_minor_data ( | minor, | |
type); |
unsigned int minor;int type;snd_register_device_for_dev — Register the ALSA device file for the card
int snd_register_device_for_dev ( | type, | |
| card, | ||
| dev, | ||
| f_ops, | ||
| private_data, | ||
| name, | ||
device); |
int type;struct snd_card * card;int dev;const struct file_operations * f_ops;void * private_data;const char * name;struct device * device;copy_to_user_fromio — copy data from mmio-space to user-space
int copy_to_user_fromio ( | dst, | |
| src, | ||
count); |
void __user * dst;const volatile void __iomem * src;size_t count;copy_from_user_toio — copy data from user-space to mmio-space
int copy_from_user_toio ( | dst, | |
| src, | ||
count); |
volatile void __iomem * dst;const void __user * src;size_t count;snd_malloc_pages — allocate pages with the given size
void * snd_malloc_pages ( | size, | |
gfp_flags); |
size_t size;gfp_t gfp_flags;snd_free_pages — release the pages
void snd_free_pages ( | ptr, | |
size); |
void * ptr;size_t size;snd_dma_alloc_pages — allocate the buffer area according to the given type
int snd_dma_alloc_pages ( | type, | |
| device, | ||
| size, | ||
dmab); |
int type;struct device * device;size_t size;struct snd_dma_buffer * dmab;snd_dma_alloc_pages_fallback — allocate the buffer area according to the given type with fallback
int snd_dma_alloc_pages_fallback ( | type, | |
| device, | ||
| size, | ||
dmab); |
int type;struct device * device;size_t size;struct snd_dma_buffer * dmab;typethe DMA buffer type
devicethe device pointer
sizethe buffer size to allocate
dmabbuffer allocation record to store the allocated data
Calls the memory-allocator function for the corresponding buffer type. When no space is left, this function reduces the size and tries to allocate again. The size actually allocated is stored in res_size argument.
Returns zero if the buffer with the given size is allocated successfuly, other a negative value at error.
snd_dma_free_pages — release the allocated buffer
void snd_dma_free_pages ( | dmab); |
struct snd_dma_buffer * dmab;snd_dma_get_reserved_buf — get the reserved buffer for the given device
size_t snd_dma_get_reserved_buf ( | dmab, | |
id); |
struct snd_dma_buffer * dmab;unsigned int id;Table of Contents
snd_pcm_new_stream — create a new PCM stream
int snd_pcm_new_stream ( | pcm, | |
| stream, | ||
substream_count); |
struct snd_pcm * pcm;int stream;int substream_count;snd_pcm_new — create a new PCM instance
int snd_pcm_new ( | card, | |
| id, | ||
| device, | ||
| playback_count, | ||
| capture_count, | ||
rpcm); |
struct snd_card * card;const char * id;int device;int playback_count;int capture_count;struct snd_pcm ** rpcm;snd_pcm_set_ops — set the PCM operators
void snd_pcm_set_ops ( | pcm, | |
| direction, | ||
ops); |
struct snd_pcm * pcm;int direction;struct snd_pcm_ops * ops;snd_pcm_set_sync — set the PCM sync id
void snd_pcm_set_sync ( | substream); |
struct snd_pcm_substream * substream;snd_interval_refine — refine the interval value of configurator
int snd_interval_refine ( | i, | |
v); |
struct snd_interval * i;const struct snd_interval * v;snd_interval_ratnum — refine the interval value
int snd_interval_ratnum ( | i, | |
| rats_count, | ||
| rats, | ||
| nump, | ||
denp); |
struct snd_interval * i;unsigned int rats_count;struct snd_ratnum * rats;unsigned int * nump;unsigned int * denp;snd_interval_list — refine the interval value from the list
int snd_interval_list ( | i, | |
| count, | ||
| list, | ||
mask); |
struct snd_interval * i;unsigned int count;unsigned int * list;unsigned int mask;snd_pcm_hw_rule_add — add the hw-constraint rule
int snd_pcm_hw_rule_add ( | runtime, | |
| cond, | ||
| var, | ||
| func, | ||
| private, | ||
| dep, | ||
...); |
struct snd_pcm_runtime * runtime;unsigned int cond;int var;snd_pcm_hw_rule_func_t func;void * private;int dep; ...;snd_pcm_hw_constraint_integer — apply an integer constraint to an interval
int snd_pcm_hw_constraint_integer ( | runtime, | |
var); |
struct snd_pcm_runtime * runtime;snd_pcm_hw_param_t var;snd_pcm_hw_constraint_minmax — apply a min/max range constraint to an interval
int snd_pcm_hw_constraint_minmax ( | runtime, | |
| var, | ||
| min, | ||
max); |
struct snd_pcm_runtime * runtime;snd_pcm_hw_param_t var;unsigned int min;unsigned int max;snd_pcm_hw_constraint_list — apply a list of constraints to a parameter
int snd_pcm_hw_constraint_list ( | runtime, | |
| cond, | ||
| var, | ||
l); |
struct snd_pcm_runtime * runtime;unsigned int cond;snd_pcm_hw_param_t var;struct snd_pcm_hw_constraint_list * l;snd_pcm_hw_constraint_ratnums — apply ratnums constraint to a parameter
int snd_pcm_hw_constraint_ratnums ( | runtime, | |
| cond, | ||
| var, | ||
r); |
struct snd_pcm_runtime * runtime;unsigned int cond;snd_pcm_hw_param_t var;struct snd_pcm_hw_constraint_ratnums * r;snd_pcm_hw_constraint_ratdens — apply ratdens constraint to a parameter
int snd_pcm_hw_constraint_ratdens ( | runtime, | |
| cond, | ||
| var, | ||
r); |
struct snd_pcm_runtime * runtime;unsigned int cond;snd_pcm_hw_param_t var;struct snd_pcm_hw_constraint_ratdens * r;snd_pcm_hw_constraint_msbits — add a hw constraint msbits rule
int snd_pcm_hw_constraint_msbits ( | runtime, | |
| cond, | ||
| width, | ||
msbits); |
struct snd_pcm_runtime * runtime;unsigned int cond;unsigned int width;unsigned int msbits;snd_pcm_hw_constraint_step — add a hw constraint step rule
int snd_pcm_hw_constraint_step ( | runtime, | |
| cond, | ||
| var, | ||
step); |
struct snd_pcm_runtime * runtime;unsigned int cond;snd_pcm_hw_param_t var;unsigned long step;snd_pcm_hw_constraint_pow2 — add a hw constraint power-of-2 rule
int snd_pcm_hw_constraint_pow2 ( | runtime, | |
| cond, | ||
var); |
struct snd_pcm_runtime * runtime;unsigned int cond;snd_pcm_hw_param_t var;snd_pcm_hw_param_value —
return params field var value
int snd_pcm_hw_param_value ( | params, | |
| var, | ||
dir); |
const struct snd_pcm_hw_params * params;snd_pcm_hw_param_t var;int * dir;snd_pcm_hw_param_first — refine config space and return minimum value
int snd_pcm_hw_param_first ( | pcm, | |
| params, | ||
| var, | ||
dir); |
struct snd_pcm_substream * pcm;struct snd_pcm_hw_params * params;snd_pcm_hw_param_t var;int * dir;snd_pcm_hw_param_last — refine config space and return maximum value
int snd_pcm_hw_param_last ( | pcm, | |
| params, | ||
| var, | ||
dir); |
struct snd_pcm_substream * pcm;struct snd_pcm_hw_params * params;snd_pcm_hw_param_t var;int * dir;snd_pcm_lib_ioctl — a generic PCM ioctl callback
int snd_pcm_lib_ioctl ( | substream, | |
| cmd, | ||
arg); |
struct snd_pcm_substream * substream;unsigned int cmd;void * arg;snd_pcm_period_elapsed — update the pcm status for the next period
void snd_pcm_period_elapsed ( | substream); |
struct snd_pcm_substream * substream;snd_pcm_stop — try to stop all running streams in the substream group
int snd_pcm_stop ( | substream, | |
state); |
struct snd_pcm_substream * substream;snd_pcm_state_t state;snd_pcm_format_signed — Check the PCM format is signed linear
int snd_pcm_format_signed ( | format); |
snd_pcm_format_t format;snd_pcm_format_unsigned — Check the PCM format is unsigned linear
int snd_pcm_format_unsigned ( | format); |
snd_pcm_format_t format;snd_pcm_format_linear — Check the PCM format is linear
int snd_pcm_format_linear ( | format); |
snd_pcm_format_t format;snd_pcm_format_little_endian — Check the PCM format is little-endian
int snd_pcm_format_little_endian ( | format); |
snd_pcm_format_t format;snd_pcm_format_big_endian — Check the PCM format is big-endian
int snd_pcm_format_big_endian ( | format); |
snd_pcm_format_t format;snd_pcm_format_width — return the bit-width of the format
int snd_pcm_format_width ( | format); |
snd_pcm_format_t format;snd_pcm_format_physical_width — return the physical bit-width of the format
int snd_pcm_format_physical_width ( | format); |
snd_pcm_format_t format;snd_pcm_format_size — return the byte size of samples on the given format
ssize_t snd_pcm_format_size ( | format, | |
samples); |
snd_pcm_format_t format;size_t samples;snd_pcm_format_silence_64 — return the silent data in 8 bytes array
const unsigned char * snd_pcm_format_silence_64 ( | format); |
snd_pcm_format_t format;snd_pcm_format_set_silence — set the silence data on the buffer
int snd_pcm_format_set_silence ( | format, | |
| data, | ||
samples); |
snd_pcm_format_t format;void * data;unsigned int samples;snd_pcm_limit_hw_rates — determine rate_min/rate_max fields
int snd_pcm_limit_hw_rates ( | runtime); |
struct snd_pcm_runtime * runtime;snd_pcm_lib_preallocate_free_for_all — release all pre-allocated buffers on the pcm
int snd_pcm_lib_preallocate_free_for_all ( | pcm); |
struct snd_pcm * pcm;snd_pcm_lib_preallocate_pages — pre-allocation for the given DMA type
int snd_pcm_lib_preallocate_pages ( | substream, | |
| type, | ||
| data, | ||
| size, | ||
max); |
struct snd_pcm_substream * substream;int type;struct device * data;size_t size;size_t max;substreamthe pcm substream instance
typeDMA type (SNDRV_DMA_TYPE_*)
dataDMA type dependent data
sizethe requested pre-allocation size in bytes
maxthe max. allowed pre-allocation size
Do pre-allocation for the given DMA buffer type.
When substream->dma_buf_id is set, the function tries to look for
the reserved buffer, and the buffer is not freed but reserved at
destruction time. The dma_buf_id must be unique for all systems
(in the same DMA buffer type) e.g. using snd_dma_pci_buf_id.
Returns zero if successful, or a negative error code on failure.
snd_pcm_lib_preallocate_pages_for_all — pre-allocation for continuous memory type (all substreams)
int snd_pcm_lib_preallocate_pages_for_all ( | pcm, | |
| type, | ||
| data, | ||
| size, | ||
max); |
struct snd_pcm * pcm;int type;void * data;size_t size;size_t max;snd_pcm_sgbuf_ops_page — get the page struct at the given offset
struct page * snd_pcm_sgbuf_ops_page ( | substream, | |
offset); |
struct snd_pcm_substream * substream;unsigned long offset;snd_pcm_lib_malloc_pages — allocate the DMA buffer
int snd_pcm_lib_malloc_pages ( | substream, | |
size); |
struct snd_pcm_substream * substream;size_t size;snd_pcm_lib_free_pages — release the allocated DMA buffer.
int snd_pcm_lib_free_pages ( | substream); |
struct snd_pcm_substream * substream;snd_pcm_lib_free_vmalloc_buffer — free vmalloc buffer
int snd_pcm_lib_free_vmalloc_buffer ( | substream); |
struct snd_pcm_substream * substream;snd_pcm_lib_get_vmalloc_page — map vmalloc buffer offset to page struct
struct page * snd_pcm_lib_get_vmalloc_page ( | substream, | |
offset); |
struct snd_pcm_substream * substream;unsigned long offset;Table of Contents
snd_ctl_new1 — create a control instance from the template
struct snd_kcontrol * snd_ctl_new1 ( | ncontrol, | |
private_data); |
const struct snd_kcontrol_new * ncontrol;void * private_data;snd_ctl_free_one — release the control instance
void snd_ctl_free_one ( | kcontrol); |
struct snd_kcontrol * kcontrol;snd_ctl_add — add the control instance to the card
int snd_ctl_add ( | card, | |
kcontrol); |
struct snd_card * card;struct snd_kcontrol * kcontrol;snd_ctl_replace — replace the control instance of the card
int snd_ctl_replace ( | card, | |
| kcontrol, | ||
add_on_replace); |
struct snd_card * card;struct snd_kcontrol * kcontrol;bool add_on_replace;cardthe card instance
kcontrolthe control instance to replace
add_on_replaceadd the control if not already added
Replaces the given control. If the given control does not exist and the add_on_replace flag is set, the control is added. If the control exists, it is destroyed first.
Returns zero if successful, or a negative error code on failure.
It frees automatically the control which cannot be added or replaced.
snd_ctl_remove — remove the control from the card and release it
int snd_ctl_remove ( | card, | |
kcontrol); |
struct snd_card * card;struct snd_kcontrol * kcontrol;snd_ctl_remove_id — remove the control of the given id and release it
int snd_ctl_remove_id ( | card, | |
id); |
struct snd_card * card;struct snd_ctl_elem_id * id;snd_ctl_activate_id — activate/inactivate the control of the given id
int snd_ctl_activate_id ( | card, | |
| id, | ||
active); |
struct snd_card * card;struct snd_ctl_elem_id * id;int active;snd_ctl_rename_id — replace the id of a control on the card
int snd_ctl_rename_id ( | card, | |
| src_id, | ||
dst_id); |
struct snd_card * card;struct snd_ctl_elem_id * src_id;struct snd_ctl_elem_id * dst_id;snd_ctl_find_numid — find the control instance with the given number-id
struct snd_kcontrol * snd_ctl_find_numid ( | card, | |
numid); |
struct snd_card * card;unsigned int numid;snd_ctl_find_id — find the control instance with the given id
struct snd_kcontrol * snd_ctl_find_id ( | card, | |
id); |
struct snd_card * card;struct snd_ctl_elem_id * id;snd_ctl_enum_info — fills the info structure for an enumerated control
int snd_ctl_enum_info ( | info, | |
| channels, | ||
| items, | ||
names[]); |
struct snd_ctl_elem_info * info;unsigned int channels;unsigned int items;const char *const names[];snd_ac97_write — write a value on the given register
void snd_ac97_write ( | ac97, | |
| reg, | ||
value); |
struct snd_ac97 * ac97;unsigned short reg;unsigned short value;snd_ac97_read — read a value from the given register
unsigned short snd_ac97_read ( | ac97, | |
reg); |
struct snd_ac97 * ac97;unsigned short reg;snd_ac97_write_cache — write a value on the given register and update the cache
void snd_ac97_write_cache ( | ac97, | |
| reg, | ||
value); |
struct snd_ac97 * ac97;unsigned short reg;unsigned short value;snd_ac97_update — update the value on the given register
int snd_ac97_update ( | ac97, | |
| reg, | ||
value); |
struct snd_ac97 * ac97;unsigned short reg;unsigned short value;snd_ac97_update_bits — update the bits on the given register
int snd_ac97_update_bits ( | ac97, | |
| reg, | ||
| mask, | ||
value); |
struct snd_ac97 * ac97;unsigned short reg;unsigned short mask;unsigned short value;snd_ac97_get_short_name — retrieve codec name
const char * snd_ac97_get_short_name ( | ac97); |
struct snd_ac97 * ac97;snd_ac97_bus — create an AC97 bus component
int snd_ac97_bus ( | card, | |
| num, | ||
| ops, | ||
| private_data, | ||
rbus); |
struct snd_card * card;int num;struct snd_ac97_bus_ops * ops;void * private_data;struct snd_ac97_bus ** rbus;cardthe card instance
numthe bus number
opsthe bus callbacks table
private_dataprivate data pointer for the new instance
rbusthe pointer to store the new AC97 bus instance.
Creates an AC97 bus component. An struct snd_ac97_bus instance is newly allocated and initialized.
The ops table must include valid callbacks (at least read and write). The other callbacks, wait and reset, are not mandatory.
The clock is set to 48000. If another clock is needed, set (*rbus)->clock manually.
The AC97 bus instance is registered as a low-level device, so you don't have to release it manually.
Returns zero if successful, or a negative error code on failure.
snd_ac97_mixer — create an Codec97 component
int snd_ac97_mixer ( | bus, | |
| template, | ||
rac97); |
struct snd_ac97_bus * bus;struct snd_ac97_template * template;struct snd_ac97 ** rac97;busthe AC97 bus which codec is attached to
templatethe template of ac97, including index, callbacks and the private data.
rac97the pointer to store the new ac97 instance.
Creates an Codec97 component. An struct snd_ac97 instance is newly allocated and initialized from the template. The codec is then initialized by the standard procedure.
The template must include the codec number (num) and address (addr), and the private data (private_data).
The ac97 instance is registered as a low-level device, so you don't have to release it manually.
Returns zero if successful, or a negative error code on failure.
snd_ac97_update_power — update the powerdown register
int snd_ac97_update_power ( | ac97, | |
| reg, | ||
powerup); |
struct snd_ac97 * ac97;int reg;int powerup;snd_ac97_suspend — General suspend function for AC97 codec
void snd_ac97_suspend ( | ac97); |
struct snd_ac97 * ac97;snd_ac97_resume — General resume function for AC97 codec
void snd_ac97_resume ( | ac97); |
struct snd_ac97 * ac97;snd_ac97_tune_hardware — tune up the hardware
int snd_ac97_tune_hardware ( | ac97, | |
| quirk, | ||
override); |
struct snd_ac97 * ac97;struct ac97_quirk * quirk;const char * override;snd_ac97_set_rate — change the rate of the given input/output.
int snd_ac97_set_rate ( | ac97, | |
| reg, | ||
rate); |
struct snd_ac97 * ac97;int reg;unsigned int rate;Changes the rate of the given input/output on the codec. If the codec doesn't support VAR, the rate must be 48000 (except for SPDIF).
The valid registers are AC97_PMC_MIC_ADC_RATE, AC97_PCM_FRONT_DAC_RATE, AC97_PCM_LR_ADC_RATE. AC97_PCM_SURR_DAC_RATE and AC97_PCM_LFE_DAC_RATE are accepted if the codec supports them. AC97_SPDIF is accepted as a pseudo register to modify the SPDIF status bits.
Returns zero if successful, or a negative error code on failure.
snd_ac97_pcm_assign — assign AC97 slots to given PCM streams
int snd_ac97_pcm_assign ( | bus, | |
| pcms_count, | ||
pcms); |
struct snd_ac97_bus * bus;unsigned short pcms_count;const struct ac97_pcm * pcms;snd_ac97_pcm_open — opens the given AC97 pcm
int snd_ac97_pcm_open ( | pcm, | |
| rate, | ||
| cfg, | ||
slots); |
struct ac97_pcm * pcm;unsigned int rate;enum ac97_pcm_cfg cfg;unsigned short slots;snd_ac97_pcm_close — closes the given AC97 pcm
int snd_ac97_pcm_close ( | pcm); |
struct ac97_pcm * pcm;snd_ctl_make_virtual_master — Create a virtual master control
struct snd_kcontrol * snd_ctl_make_virtual_master ( | name, | |
tlv); |
char * name;const unsigned int * tlv;namename string of the control element to create
tlvoptional TLV int array for dB information
Creates a virtual matster control with the given name string. Returns the created control element, or NULL for errors (ENOMEM).
After creating a vmaster element, you can add the slave controls
via snd_ctl_add_slave or snd_ctl_add_slave_uncached.
The optional argument tlv can be used to specify the TLV information
for dB scale of the master control. It should be a single element
with #SNDRV_CTL_TLVT_DB_SCALE, #SNDRV_CTL_TLV_DB_MINMAX or
#SNDRV_CTL_TLVT_DB_MINMAX_MUTE type, and should be the max 0dB.
snd_ctl_add_slave — Add a virtual slave control
int snd_ctl_add_slave ( | master, | |
slave); |
struct snd_kcontrol * master;struct snd_kcontrol * slave;
Add a virtual slave control to the given master element created via
snd_ctl_create_virtual_master beforehand.
Returns zero if successful or a negative error code.
All slaves must be the same type (returning the same information via info callback). The function doesn't check it, so it's your responsibility.
Also, some additional limitations: at most two channels, logarithmic volume control (dB level) thus no linear volume, master can only attenuate the volume without gain
snd_ctl_add_slave_uncached — Add a virtual slave control
int snd_ctl_add_slave_uncached ( | master, | |
slave); |
struct snd_kcontrol * master;struct snd_kcontrol * slave;
Add a virtual slave control to the given master.
Unlike snd_ctl_add_slave, the element added via this function
is supposed to have volatile values, and get callback is called
at each time quried from the master.
When the control peeks the hardware values directly and the value can be changed by other means than the put callback of the element, this function should be used to keep the value always up-to-date.
Table of Contents
snd_rawmidi_receive — receive the input data from the device
int snd_rawmidi_receive ( | substream, | |
| buffer, | ||
count); |
struct snd_rawmidi_substream * substream;const unsigned char * buffer;int count;snd_rawmidi_transmit_empty — check whether the output buffer is empty
int snd_rawmidi_transmit_empty ( | substream); |
struct snd_rawmidi_substream * substream;snd_rawmidi_transmit_peek — copy data from the internal buffer
int snd_rawmidi_transmit_peek ( | substream, | |
| buffer, | ||
count); |
struct snd_rawmidi_substream * substream;unsigned char * buffer;int count;snd_rawmidi_transmit_ack — acknowledge the transmission
int snd_rawmidi_transmit_ack ( | substream, | |
count); |
struct snd_rawmidi_substream * substream;int count;snd_rawmidi_transmit — copy from the buffer to the device
int snd_rawmidi_transmit ( | substream, | |
| buffer, | ||
count); |
struct snd_rawmidi_substream * substream;unsigned char * buffer;int count;snd_rawmidi_new — create a rawmidi instance
int snd_rawmidi_new ( | card, | |
| id, | ||
| device, | ||
| output_count, | ||
| input_count, | ||
rrawmidi); |
struct snd_card * card;char * id;int device;int output_count;int input_count;struct snd_rawmidi ** rrawmidi;snd_mpu401_uart_interrupt — generic MPU401-UART interrupt handler
irqreturn_t snd_mpu401_uart_interrupt ( | irq, | |
dev_id); |
int irq;void * dev_id;snd_mpu401_uart_interrupt_tx — generic MPU401-UART transmit irq handler
irqreturn_t snd_mpu401_uart_interrupt_tx ( | irq, | |
dev_id); |
int irq;void * dev_id;snd_mpu401_uart_new — create an MPU401-UART instance
int snd_mpu401_uart_new ( | card, | |
| device, | ||
| hardware, | ||
| port, | ||
| info_flags, | ||
| irq, | ||
| irq_flags, | ||
rrawmidi); |
struct snd_card * card;int device;unsigned short hardware;unsigned long port;unsigned int info_flags;int irq;int irq_flags;struct snd_rawmidi ** rrawmidi;cardthe card instance
devicethe device index, zero-based
hardwarethe hardware type, MPU401_HW_XXXX
portthe base address of MPU401 port
info_flagsbitflags MPU401_INFO_XXX
irqthe irq number, -1 if no interrupt for mpu
irq_flagsthe irq request flags (SA_XXX), 0 if irq was already reserved.
rrawmidithe pointer to store the new rawmidi instance
Creates a new MPU-401 instance.
Note that the rawmidi instance is returned on the rrawmidi argument, not the mpu401 instance itself. To access to the mpu401 instance, cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
Returns zero if successful, or a negative error code.
Table of Contents
snd_iprintf — printf on the procfs buffer
int snd_iprintf ( | buffer, | |
| fmt, | ||
...); |
struct snd_info_buffer * buffer;const char * fmt; ...;snd_info_get_line — read one line from the procfs buffer
int snd_info_get_line ( | buffer, | |
| line, | ||
len); |
struct snd_info_buffer * buffer;char * line;int len;snd_info_get_str — parse a string token
const char * snd_info_get_str ( | dest, | |
| src, | ||
len); |
char * dest;const char * src;int len;snd_info_create_module_entry — create an info entry for the given module
struct snd_info_entry * snd_info_create_module_entry ( | module, | |
| name, | ||
parent); |
struct module * module;const char * name;struct snd_info_entry * parent;snd_info_create_card_entry — create an info entry for the given card
struct snd_info_entry * snd_info_create_card_entry ( | card, | |
| name, | ||
parent); |
struct snd_card * card;const char * name;struct snd_info_entry * parent;snd_card_proc_new — create an info entry for the given card
int snd_card_proc_new ( | card, | |
| name, | ||
entryp); |
struct snd_card * card;const char * name;struct snd_info_entry ** entryp;
Creates a new info entry and assigns it to the given card.
Unlike snd_info_create_card_entry, this function registers the
info entry as an ALSA device component, so that it can be
unregistered/released without explicit call.
Also, you don't have to register this entry via snd_info_register,
since this will be registered by snd_card_register automatically.
The parent is assumed as card->proc_root.
For releasing this entry, use snd_device_free instead of
snd_info_free_entry.
Returns zero if successful, or a negative error code on failure.
Table of Contents
snd_hwdep_new — create a new hwdep instance
int snd_hwdep_new ( | card, | |
| id, | ||
| device, | ||
rhwdep); |
struct snd_card * card;char * id;int device;struct snd_hwdep ** rhwdep;snd_jack_new — Create a new jack
int snd_jack_new ( | card, | |
| id, | ||
| type, | ||
jjack); |
struct snd_card * card;const char * id;int type;struct snd_jack ** jjack;snd_jack_set_parent — Set the parent device for a jack
void snd_jack_set_parent ( | jack, | |
parent); |
struct snd_jack * jack;struct device * parent;snd_jack_set_key — Set a key mapping on a jack
int snd_jack_set_key ( | jack, | |
| type, | ||
keytype); |
struct snd_jack * jack;enum snd_jack_types type;int keytype;jackThe jack to configure
typeJack report type for this key
keytypeInput layer key type to be reported
Map a SND_JACK_BTN_ button type to an input layer key, allowing reporting of keys on accessories via the jack abstraction. If no mapping is provided but keys are enabled in the jack type then BTN_n numeric buttons will be reported.
Note that this is intended to be use by simple devices with small numbers of keys that can be reported. It is also possible to access the input device directly - devices with complex input capabilities on accessories should consider doing this rather than using this abstraction.
This function may only be called prior to registration of the jack.
snd_dma_program — program an ISA DMA transfer
void snd_dma_program ( | dma, | |
| addr, | ||
| size, | ||
mode); |
unsigned long dma;unsigned long addr;unsigned int size;unsigned short mode;snd_register_device — Register the ALSA device file for the card
int snd_register_device ( | type, | |
| card, | ||
| dev, | ||
| f_ops, | ||
| private_data, | ||
name); |
int type;struct snd_card * card;int dev;const struct file_operations * f_ops;void * private_data;const char * name;snd_BUG_ON — debugging check macro
snd_BUG_ON ( | cond); |
cond;