static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
/* definition of the chip-specific record */
- typedef struct snd_mychip mychip_t;
- struct snd_mychip {
- snd_card_t *card;
+ struct mychip {
+ struct snd_card *card;
// rest of implementation will be in the section
// "PCI Resource Managements"
};
/* chip-specific destructor
* (see "PCI Resource Managements")
*/
- static int snd_mychip_free(mychip_t *chip)
+ static int snd_mychip_free(struct mychip *chip)
{
.... // will be implemented later...
}
/* component-destructor
* (see "Management of Cards and Components")
*/
- static int snd_mychip_dev_free(snd_device_t *device)
+ static int snd_mychip_dev_free(struct snd_device *device)
{
- mychip_t *chip = device->device_data;
- return snd_mychip_free(chip);
+ return snd_mychip_free(device->device_data);
}
/* chip-specific constructor
* (see "Management of Cards and Components")
*/
- static int __devinit snd_mychip_create(snd_card_t *card,
+ static int __devinit snd_mychip_create(struct snd_card *card,
struct pci_dev *pci,
- mychip_t **rchip)
+ struct mychip **rchip)
{
- mychip_t *chip;
+ struct mychip *chip;
int err;
- static snd_device_ops_t ops = {
+ static struct snd_device_ops ops = {
.dev_free = snd_mychip_dev_free,
};
const struct pci_device_id *pci_id)
{
static int dev;
- snd_card_t *card;
- mychip_t *chip;
+ struct snd_card *card;
+ struct mychip *chip;
int err;
/* (1) */
<informalexample>
<programlisting>
<![CDATA[
- snd_card_t *card;
+ struct snd_card *card;
....
card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
]]>
<informalexample>
<programlisting>
<![CDATA[
- mychip_t *chip;
+ struct mychip *chip;
....
if ((err = snd_mychip_create(card, pci, &chip)) < 0) {
snd_card_free(card);
<informalexample>
<programlisting>
<![CDATA[
- snd_card_t *card;
+ struct snd_card *card;
card = snd_card_new(index, id, module, extra_size);
]]>
</programlisting>
<para>
After the card is created, you can attach the components
(devices) to the card instance. On ALSA driver, a component is
- represented as a <type>snd_device_t</type> object.
+ represented as a struct <structname>snd_device</structname> object.
A component can be a PCM instance, a control interface, a raw
MIDI interface, etc. Each of such instances has one component
entry.
The chip-specific information, e.g. the i/o port address, its
resource pointer, or the irq number, is stored in the
chip-specific record.
- Usually, the chip-specific record is typedef'ed as
- <type>xxx_t</type> like the following:
<informalexample>
<programlisting>
<![CDATA[
- typedef struct snd_mychip mychip_t;
- struct snd_mychip {
+ struct mychip {
....
};
]]>
<informalexample>
<programlisting>
<![CDATA[
- card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(mychip_t));
+ card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct mychip));
]]>
</programlisting>
</informalexample>
- whether <type>mychip_t</type> is the type of the chip record.
+ whether struct <structname>mychip</structname> is the type of the chip record.
</para>
<para>
<informalexample>
<programlisting>
<![CDATA[
- mychip_t *chip = (mychip_t *)card->private_data;
+ struct mychip *chip = (struct mychip *)card->private_data;
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- snd_card_t *card;
- mychip_t *chip;
+ struct snd_card *card;
+ struct mychip *chip;
card = snd_card_new(index[dev], id[dev], THIS_MODULE, NULL);
.....
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
<informalexample>
<programlisting>
<![CDATA[
- struct snd_mychip {
- snd_card_t *card;
+ struct mychip {
+ struct snd_card *card;
....
};
]]>
<informalexample>
<programlisting>
<![CDATA[
- static snd_device_ops_t ops = {
+ static struct snd_device_ops ops = {
.dev_free = snd_mychip_dev_free,
};
....
<informalexample>
<programlisting>
<![CDATA[
- static int snd_mychip_dev_free(snd_device_t *device)
+ static int snd_mychip_dev_free(struct snd_device *device)
{
- mychip_t *chip = device->device_data;
- return snd_mychip_free(chip);
+ return snd_mychip_free(device->device_data);
}
]]>
</programlisting>
<title>PCI Resource Managements Example</title>
<programlisting>
<![CDATA[
- struct snd_mychip {
- snd_card_t *card;
+ struct mychip {
+ struct snd_card *card;
struct pci_dev *pci;
unsigned long port;
int irq;
};
- static int snd_mychip_free(mychip_t *chip)
+ static int snd_mychip_free(struct mychip *chip)
{
/* disable hardware here if any */
.... // (not implemented in this document)
}
/* chip-specific constructor */
- static int __devinit snd_mychip_create(snd_card_t *card,
+ static int __devinit snd_mychip_create(struct snd_card *card,
struct pci_dev *pci,
- mychip_t **rchip)
+ struct mychip **rchip)
{
- mychip_t *chip;
+ struct mychip *chip;
int err;
- static snd_device_ops_t ops = {
+ static struct snd_device_ops ops = {
.dev_free = snd_mychip_dev_free,
};
}
chip->port = pci_resource_start(pci, 0);
if (request_irq(pci->irq, snd_mychip_interrupt,
- SA_INTERRUPT|SA_SHIRQ, "My Chip",
- (void *)chip)) {
+ SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) {
printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
snd_mychip_free(chip);
return -EBUSY;
<para>
Now assume that this PCI device has an I/O port with 8 bytes
- and an interrupt. Then <type>mychip_t</type> will have the
+ and an interrupt. Then struct <structname>mychip</structname> will have the
following fields:
<informalexample>
<programlisting>
<![CDATA[
- struct snd_mychip {
- snd_card_t *card;
+ struct mychip {
+ struct snd_card *card;
unsigned long port;
int irq;
<programlisting>
<![CDATA[
if (request_irq(pci->irq, snd_mychip_interrupt,
- SA_INTERRUPT|SA_SHIRQ, "My Chip",
- (void *)chip)) {
+ SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) {
printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
snd_mychip_free(chip);
return -EBUSY;
static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
struct pt_regs *regs)
{
- mychip_t *chip = dev_id;
+ struct mychip *chip = dev_id;
....
return IRQ_HANDLED;
}
<informalexample>
<programlisting>
<![CDATA[
- struct snd_mychip {
+ struct mychip {
....
unsigned long iobase_phys;
void __iomem *iobase_virt;
<informalexample>
<programlisting>
<![CDATA[
- static int snd_mychip_free(mychip_t *chip)
+ static int snd_mychip_free(struct mychip *chip)
{
....
if (chip->iobase_virt)
<title>Registration of Device Struct</title>
<para>
At some point, typically after calling <function>snd_device_new()</function>,
- you need to register the <structname>struct device</structname> of the chip
+ you need to register the struct <structname>device</structname> of the chip
you're handling for udev and co. ALSA provides a macro for compatibility with
older kernels. Simply call like the following:
<informalexample>
....
/* hardware definition */
- static snd_pcm_hardware_t snd_mychip_playback_hw = {
+ static struct snd_pcm_hardware snd_mychip_playback_hw = {
.info = (SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
};
/* hardware definition */
- static snd_pcm_hardware_t snd_mychip_capture_hw = {
+ static struct snd_pcm_hardware snd_mychip_capture_hw = {
.info = (SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
};
/* open callback */
- static int snd_mychip_playback_open(snd_pcm_substream_t *substream)
+ static int snd_mychip_playback_open(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
- snd_pcm_runtime_t *runtime = substream->runtime;
+ struct mychip *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_mychip_playback_hw;
// more hardware-initialization will be done here
}
/* close callback */
- static int snd_mychip_playback_close(snd_pcm_substream_t *substream)
+ static int snd_mychip_playback_close(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
+ struct mychip *chip = snd_pcm_substream_chip(substream);
// the hardware-specific codes will be here
return 0;
}
/* open callback */
- static int snd_mychip_capture_open(snd_pcm_substream_t *substream)
+ static int snd_mychip_capture_open(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
- snd_pcm_runtime_t *runtime = substream->runtime;
+ struct mychip *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_mychip_capture_hw;
// more hardware-initialization will be done here
}
/* close callback */
- static int snd_mychip_capture_close(snd_pcm_substream_t *substream)
+ static int snd_mychip_capture_close(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
+ struct mychip *chip = snd_pcm_substream_chip(substream);
// the hardware-specific codes will be here
return 0;
}
/* hw_params callback */
- static int snd_mychip_pcm_hw_params(snd_pcm_substream_t *substream,
- snd_pcm_hw_params_t * hw_params)
+ static int snd_mychip_pcm_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *hw_params)
{
return snd_pcm_lib_malloc_pages(substream,
params_buffer_bytes(hw_params));
}
/* hw_free callback */
- static int snd_mychip_pcm_hw_free(snd_pcm_substream_t *substream)
+ static int snd_mychip_pcm_hw_free(struct snd_pcm_substream *substream)
{
return snd_pcm_lib_free_pages(substream);
}
/* prepare callback */
- static int snd_mychip_pcm_prepare(snd_pcm_substream_t *substream)
+ static int snd_mychip_pcm_prepare(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
- snd_pcm_runtime_t *runtime = substream->runtime;
+ struct mychip *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
/* set up the hardware with the current configuration
* for example...
}
/* trigger callback */
- static int snd_mychip_pcm_trigger(snd_pcm_substream_t *substream,
+ static int snd_mychip_pcm_trigger(struct snd_pcm_substream *substream,
int cmd)
{
switch (cmd) {
/* pointer callback */
static snd_pcm_uframes_t
- snd_mychip_pcm_pointer(snd_pcm_substream_t *substream)
+ snd_mychip_pcm_pointer(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
+ struct mychip *chip = snd_pcm_substream_chip(substream);
unsigned int current_ptr;
/* get the current hardware pointer */
}
/* operators */
- static snd_pcm_ops_t snd_mychip_playback_ops = {
+ static struct snd_pcm_ops snd_mychip_playback_ops = {
.open = snd_mychip_playback_open,
.close = snd_mychip_playback_close,
.ioctl = snd_pcm_lib_ioctl,
};
/* operators */
- static snd_pcm_ops_t snd_mychip_capture_ops = {
+ static struct snd_pcm_ops snd_mychip_capture_ops = {
.open = snd_mychip_capture_open,
.close = snd_mychip_capture_close,
.ioctl = snd_pcm_lib_ioctl,
*/
/* create a pcm device */
- static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+ static int __devinit snd_mychip_new_pcm(struct mychip *chip)
{
- snd_pcm_t *pcm;
+ struct snd_pcm *pcm;
int err;
if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,
<informalexample>
<programlisting>
<![CDATA[
- static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+ static int __devinit snd_mychip_new_pcm(struct mychip *chip)
{
- snd_pcm_t *pcm;
+ struct snd_pcm *pcm;
int err;
if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,
specify more numbers, but they must be handled properly in
open/close, etc. callbacks. When you need to know which
substream you are referring to, then it can be obtained from
- <type>snd_pcm_substream_t</type> data passed to each callback
+ struct <structname>snd_pcm_substream</structname> data passed to each callback
as follows:
<informalexample>
<programlisting>
<![CDATA[
- snd_pcm_substream_t *substream;
+ struct snd_pcm_substream *substream;
int index = substream->number;
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- static snd_pcm_ops_t snd_mychip_playback_ops = {
+ static struct snd_pcm_ops snd_mychip_playback_ops = {
.open = snd_mychip_pcm_open,
.close = snd_mychip_pcm_close,
.ioctl = snd_pcm_lib_ioctl,
<title>PCM Instance with a Destructor</title>
<programlisting>
<![CDATA[
- static void mychip_pcm_free(snd_pcm_t *pcm)
+ static void mychip_pcm_free(struct snd_pcm *pcm)
{
- mychip_t *chip = snd_pcm_chip(pcm);
+ struct mychip *chip = snd_pcm_chip(pcm);
/* free your own data */
kfree(chip->my_private_pcm_data);
// do what you like else
....
}
- static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+ static int __devinit snd_mychip_new_pcm(struct mychip *chip)
{
- snd_pcm_t *pcm;
+ struct snd_pcm *pcm;
....
/* allocate your own data */
chip->my_private_pcm_data = kmalloc(...);
<![CDATA[
struct _snd_pcm_runtime {
/* -- Status -- */
- snd_pcm_substream_t *trigger_master;
+ struct snd_pcm_substream *trigger_master;
snd_timestamp_t trigger_tstamp; /* trigger timestamp */
int overrange;
snd_pcm_uframes_t avail_max;
snd_pcm_sync_id_t sync; /* hardware synchronization ID */
/* -- mmap -- */
- volatile snd_pcm_mmap_status_t *status;
- volatile snd_pcm_mmap_control_t *control;
+ volatile struct snd_pcm_mmap_status *status;
+ volatile struct snd_pcm_mmap_control *control;
atomic_t mmap_count;
/* -- locking / scheduling -- */
/* -- private section -- */
void *private_data;
- void (*private_free)(snd_pcm_runtime_t *runtime);
+ void (*private_free)(struct snd_pcm_runtime *runtime);
/* -- hardware description -- */
- snd_pcm_hardware_t hw;
- snd_pcm_hw_constraints_t hw_constraints;
+ struct snd_pcm_hardware hw;
+ struct snd_pcm_hw_constraints hw_constraints;
/* -- interrupt callbacks -- */
- void (*transfer_ack_begin)(snd_pcm_substream_t *substream);
- void (*transfer_ack_end)(snd_pcm_substream_t *substream);
+ void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
+ void (*transfer_ack_end)(struct snd_pcm_substream *substream);
/* -- timer -- */
unsigned int timer_resolution; /* timer resolution */
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
/* -- OSS things -- */
- snd_pcm_oss_runtime_t oss;
+ struct snd_pcm_oss_runtime oss;
#endif
};
]]>
<section id="pcm-interface-runtime-hw">
<title>Hardware Description</title>
<para>
- The hardware descriptor (<type>snd_pcm_hardware_t</type>)
+ The hardware descriptor (struct <structname>snd_pcm_hardware</structname>)
contains the definitions of the fundamental hardware
configuration. Above all, you'll need to define this in
<link linkend="pcm-interface-operators-open-callback"><citetitle>
<informalexample>
<programlisting>
<![CDATA[
- snd_pcm_runtime_t *runtime = substream->runtime;
+ struct snd_pcm_runtime *runtime = substream->runtime;
...
runtime->hw = snd_mychip_playback_hw; /* common definition */
if (chip->model == VERY_OLD_ONE)
<informalexample>
<programlisting>
<![CDATA[
- static snd_pcm_hardware_t snd_mychip_playback_hw = {
+ static struct snd_pcm_hardware snd_mychip_playback_hw = {
.info = (SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
<title>Running Status</title>
<para>
The running status can be referred via <constant>runtime->status</constant>.
- This is the pointer to <type>snd_pcm_mmap_status_t</type>
+ This is the pointer to struct <structname>snd_pcm_mmap_status</structname>
record. For example, you can get the current DMA hardware
pointer via <constant>runtime->status->hw_ptr</constant>.
</para>
<para>
The DMA application pointer can be referred via
<constant>runtime->control</constant>, which points
- <type>snd_pcm_mmap_control_t</type> record.
+ struct <structname>snd_pcm_mmap_control</structname> record.
However, accessing directly to this value is not recommended.
</para>
</section>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_open(snd_pcm_substream_t *substream)
+ static int snd_xxx_open(struct snd_pcm_substream *substream)
{
- my_pcm_data_t *data;
+ struct my_pcm_data *data;
....
data = kmalloc(sizeof(*data), GFP_KERNEL);
substream->runtime->private_data = data;
<para>
The callback function takes at least the argument with
- <type>snd_pcm_substream_t</type> pointer. For retrieving the
+ <structname>snd_pcm_substream</structname> pointer. For retrieving the
chip record from the given substream instance, you can use the
following macro.
<programlisting>
<![CDATA[
int xxx() {
- mychip_t *chip = snd_pcm_substream_chip(substream);
+ struct mychip *chip = snd_pcm_substream_chip(substream);
....
}
]]>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_open(snd_pcm_substream_t *substream);
+ static int snd_xxx_open(struct snd_pcm_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_open(snd_pcm_substream_t *substream)
+ static int snd_xxx_open(struct snd_pcm_substream *substream)
{
- mychip_t *chip = snd_pcm_substream_chip(substream);
- snd_pcm_runtime_t *runtime = substream->runtime;
+ struct mychip *chip = snd_pcm_substream_chip(substream);
+ struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_mychip_playback_hw;
return 0;
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_close(snd_pcm_substream_t *substream);
+ static int snd_xxx_close(struct snd_pcm_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_close(snd_pcm_substream_t *substream)
+ static int snd_xxx_close(struct snd_pcm_substream *substream)
{
....
kfree(substream->runtime->private_data);
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_hw_params(snd_pcm_substream_t * substream,
- snd_pcm_hw_params_t * hw_params);
+ static int snd_xxx_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *hw_params);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_hw_free(snd_pcm_substream_t * substream);
+ static int snd_xxx_hw_free(struct snd_pcm_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_prepare(snd_pcm_substream_t * substream);
+ static int snd_xxx_prepare(struct snd_pcm_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_trigger(snd_pcm_substream_t * substream, int cmd);
+ static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static snd_pcm_uframes_t snd_xxx_pointer(snd_pcm_substream_t * substream)
+ static snd_pcm_uframes_t snd_xxx_pointer(struct snd_pcm_substream *substream)
]]>
</programlisting>
</informalexample>
static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
struct pt_regs *regs)
{
- mychip_t *chip = dev_id;
+ struct mychip *chip = dev_id;
spin_lock(&chip->lock);
....
if (pcm_irq_invoked(chip)) {
static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
struct pt_regs *regs)
{
- mychip_t *chip = dev_id;
+ struct mychip *chip = dev_id;
spin_lock(&chip->lock);
....
if (pcm_irq_invoked(chip)) {
<![CDATA[
static unsigned int rates[] =
{4000, 10000, 22050, 44100};
- static snd_pcm_hw_constraint_list_t constraints_rates = {
+ static struct snd_pcm_hw_constraint_list constraints_rates = {
.count = ARRAY_SIZE(rates),
.list = rates,
.mask = 0,
};
- static int snd_mychip_pcm_open(snd_pcm_substream_t *substream)
+ static int snd_mychip_pcm_open(struct snd_pcm_substream *substream)
{
int err;
....
You can even define your own constraint rules.
For example, let's suppose my_chip can manage a substream of 1 channel
if and only if the format is S16_LE, otherwise it supports any format
- specified in the <type>snd_pcm_hardware_t</type> stucture (or in any
+ specified in the <structname>snd_pcm_hardware</structname> stucture (or in any
other constraint_list). You can build a rule like this:
<example>
<title>Example of Hardware Constraints for Channels</title>
<programlisting>
<![CDATA[
- static int hw_rule_format_by_channels(snd_pcm_hw_params_t *params,
- snd_pcm_hw_rule_t *rule)
+ static int hw_rule_format_by_channels(struct snd_pcm_hw_params *params,
+ struct snd_pcm_hw_rule *rule)
{
- snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
- snd_mask_t *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
- snd_mask_t fmt;
+ struct snd_interval *c = hw_param_interval(params,
+ SNDRV_PCM_HW_PARAM_CHANNELS);
+ struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+ struct snd_mask fmt;
snd_mask_any(&fmt); /* Init the struct */
if (c->min < 2) {
<title>Example of Hardware Constraints for Channels</title>
<programlisting>
<![CDATA[
- static int hw_rule_channels_by_format(snd_pcm_hw_params_t *params,
- snd_pcm_hw_rule_t *rule)
+ static int hw_rule_channels_by_format(struct snd_pcm_hw_params *params,
+ struct snd_pcm_hw_rule *rule)
{
- snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
- snd_mask_t *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
- snd_interval_t ch;
+ struct snd_interval *c = hw_param_interval(params,
+ SNDRV_PCM_HW_PARAM_CHANNELS);
+ struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+ struct snd_interval ch;
snd_interval_any(&ch);
if (f->bits[0] == SNDRV_PCM_FMTBIT_S16_LE) {
callbacks: <structfield>info</structfield>,
<structfield>get</structfield> and
<structfield>put</structfield>. Then, define a
- <type>snd_kcontrol_new_t</type> record, such as:
+ struct <structname>snd_kcontrol_new</structname> record, such as:
<example>
<title>Definition of a Control</title>
<programlisting>
<![CDATA[
- static snd_kcontrol_new_t my_control __devinitdata = {
+ static struct snd_kcontrol_new my_control __devinitdata = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Playback Switch",
.index = 0,
<para>
The <structfield>info</structfield> callback is used to get
the detailed information of this control. This must store the
- values of the given <type>snd_ctl_elem_info_t</type>
+ values of the given struct <structname>snd_ctl_elem_info</structname>
object. For example, for a boolean control with a single
element will be:
<title>Example of info callback</title>
<programlisting>
<![CDATA[
- static int snd_myctl_info(snd_kcontrol_t *kcontrol,
- snd_ctl_elem_info_t *uinfo)
+ static int snd_myctl_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 1;
<informalexample>
<programlisting>
<![CDATA[
- static int snd_myctl_info(snd_kcontrol_t *kcontrol,
- snd_ctl_elem_info_t *uinfo)
+ static int snd_myctl_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
static char *texts[4] = {
"First", "Second", "Third", "Fourth"
<title>Example of get callback</title>
<programlisting>
<![CDATA[
- static int snd_myctl_get(snd_kcontrol_t *kcontrol,
- snd_ctl_elem_value_t *ucontrol)
+ static int snd_myctl_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- mychip_t *chip = snd_kcontrol_chip(kcontrol);
+ struct mychip *chip = snd_kcontrol_chip(kcontrol);
ucontrol->value.integer.value[0] = get_some_value(chip);
return 0;
}
<informalexample>
<programlisting>
<![CDATA[
- static int snd_sbmixer_get_single(snd_kcontrol_t *kcontrol,
- snd_ctl_elem_value_t *ucontrol)
+ static int snd_sbmixer_get_single(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
int reg = kcontrol->private_value & 0xff;
int shift = (kcontrol->private_value >> 16) & 0xff;
<title>Example of put callback</title>
<programlisting>
<![CDATA[
- static int snd_myctl_put(snd_kcontrol_t *kcontrol,
- snd_ctl_elem_value_t *ucontrol)
+ static int snd_myctl_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- mychip_t *chip = snd_kcontrol_chip(kcontrol);
+ struct mychip *chip = snd_kcontrol_chip(kcontrol);
int changed = 0;
if (chip->current_value !=
ucontrol->value.integer.value[0]) {
</informalexample>
where <parameter>my_control</parameter> is the
- <type>snd_kcontrol_new_t</type> object defined above, and chip
+ struct <structname>snd_kcontrol_new</structname> object defined above, and chip
is the object pointer to be passed to
kcontrol->private_data
which can be referred in callbacks.
<para>
<function>snd_ctl_new1()</function> allocates a new
- <type>snd_kcontrol_t</type> instance (that's why the definition
+ <structname>snd_kcontrol</structname> instance (that's why the definition
of <parameter>my_control</parameter> can be with
<parameter>__devinitdata</parameter>
prefix), and <function>snd_ctl_add</function> assigns the given
control id pointer for the notification. The event-mask
specifies the types of notification, for example, in the above
example, the change of control values is notified.
- The id pointer is the pointer of <type>snd_ctl_elem_id_t</type>
+ The id pointer is the pointer of struct <structname>snd_ctl_elem_id</structname>
to be notified.
You can find some examples in <filename>es1938.c</filename> or
<filename>es1968.c</filename> for hardware volume interrupts.
<title>Example of AC97 Interface</title>
<programlisting>
<![CDATA[
- struct snd_mychip {
+ struct mychip {
....
- ac97_t *ac97;
+ struct snd_ac97 *ac97;
....
};
- static unsigned short snd_mychip_ac97_read(ac97_t *ac97,
+ static unsigned short snd_mychip_ac97_read(struct snd_ac97 *ac97,
unsigned short reg)
{
- mychip_t *chip = ac97->private_data;
+ struct mychip *chip = ac97->private_data;
....
// read a register value here from the codec
return the_register_value;
}
- static void snd_mychip_ac97_write(ac97_t *ac97,
+ static void snd_mychip_ac97_write(struct snd_ac97 *ac97,
unsigned short reg, unsigned short val)
{
- mychip_t *chip = ac97->private_data;
+ struct mychip *chip = ac97->private_data;
....
// write the given register value to the codec
}
- static int snd_mychip_ac97(mychip_t *chip)
+ static int snd_mychip_ac97(struct mychip *chip)
{
- ac97_bus_t *bus;
- ac97_template_t ac97;
+ struct snd_ac97_bus *bus;
+ struct snd_ac97_template ac97;
int err;
- static ac97_bus_ops_t ops = {
+ static struct snd_ac97_bus_ops ops = {
.write = snd_mychip_ac97_write,
.read = snd_mychip_ac97_read,
};
<informalexample>
<programlisting>
<![CDATA[
- ac97_bus_t *bus;
- static ac97_bus_ops_t ops = {
+ struct snd_ac97_bus *bus;
+ static struct snd_ac97_bus_ops ops = {
.write = snd_mychip_ac97_write,
.read = snd_mychip_ac97_read,
};
</para>
<para>
- And then call <function>snd_ac97_mixer()</function> with an <type>ac97_template_t</type>
+ And then call <function>snd_ac97_mixer()</function> with an
+ struct <structname>snd_ac97_template</structname>
record together with the bus pointer created above.
<informalexample>
<programlisting>
<![CDATA[
- ac97_template_t ac97;
+ struct snd_ac97_template ac97;
int err;
memset(&ac97, 0, sizeof(ac97));
<informalexample>
<programlisting>
<![CDATA[
- static unsigned short snd_mychip_ac97_read(ac97_t *ac97,
+ static unsigned short snd_mychip_ac97_read(struct snd_ac97 *ac97,
unsigned short reg)
{
- mychip_t *chip = ac97->private_data;
+ struct mychip *chip = ac97->private_data;
....
return the_register_value;
}
<informalexample>
<programlisting>
<![CDATA[
- static void snd_mychip_ac97_write(ac97_t *ac97,
+ static void snd_mychip_ac97_write(struct snd_ac97 *ac97,
unsigned short reg, unsigned short val)
]]>
</programlisting>
<title>Multiple Codecs</title>
<para>
When there are several codecs on the same card, you need to
- call <function>snd_ac97_new()</function> multiple times with
+ call <function>snd_ac97_mixer()</function> multiple times with
ac97.num=1 or greater. The <structfield>num</structfield> field
specifies the codec
number.
<informalexample>
<programlisting>
<![CDATA[
- snd_rawmidi_t *rmidi;
+ struct snd_rawmidi *rmidi;
snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port, integrated,
irq, irq_flags, &rmidi);
]]>
Usually, the port address corresponds to the command port and
port + 1 corresponds to the data port. If not, you may change
the <structfield>cport</structfield> field of
- <type>mpu401_t</type> manually
- afterward. However, <type>mpu401_t</type> pointer is not
+ struct <structname>snd_mpu401</structname> manually
+ afterward. However, <structname>snd_mpu401</structname> pointer is not
returned explicitly by
<function>snd_mpu401_uart_new()</function>. You need to cast
rmidi->private_data to
- <type>mpu401_t</type> explicitly,
+ <structname>snd_mpu401</structname> explicitly,
<informalexample>
<programlisting>
<![CDATA[
- mpu401_t *mpu;
+ struct snd_mpu401 *mpu;
mpu = rmidi->private_data;
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- snd_rawmidi_t *rmidi;
+ struct snd_rawmidi *rmidi;
err = snd_rawmidi_new(chip->card, "MyMIDI", 0, outs, ins, &rmidi);
if (err < 0)
return err;
<informalexample>
<programlisting>
<![CDATA[
- static snd_rawmidi_ops_t snd_mymidi_output_ops = {
+ static struct snd_rawmidi_ops snd_mymidi_output_ops = {
.open = snd_mymidi_output_open,
.close = snd_mymidi_output_close,
.trigger = snd_mymidi_output_trigger,
<programlisting>
<![CDATA[
struct list_head *list;
- snd_rawmidi_substream_t *substream;
+ struct snd_rawmidi_substream *substream;
list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {
- substream = list_entry(list, snd_rawmidi_substream_t, list);
+ substream = list_entry(list, struct snd_rawmidi_substream, list);
sprintf(substream->name, "My MIDI Port %d", substream->number + 1);
}
/* same for SNDRV_RAWMIDI_STREAM_INPUT */
<para>
If there is more than one port, your callbacks can determine the
- port index from the snd_rawmidi_substream_t data passed to each
+ port index from the struct snd_rawmidi_substream data passed to each
callback:
<informalexample>
<programlisting>
<![CDATA[
- snd_rawmidi_substream_t *substream;
+ struct snd_rawmidi_substream *substream;
int index = substream->number;
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_open(snd_rawmidi_substream_t *substream);
+ static int snd_xxx_open(struct snd_rawmidi_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static int snd_xxx_close(snd_rawmidi_substream_t *substream);
+ static int snd_xxx_close(struct snd_rawmidi_substream *substream);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static void snd_xxx_output_trigger(snd_rawmidi_substream_t *substream, int up);
+ static void snd_xxx_output_trigger(struct snd_rawmidi_substream *substream, int up);
]]>
</programlisting>
</informalexample>
<![CDATA[
unsigned char data;
while (snd_rawmidi_transmit_peek(substream, &data, 1) == 1) {
- if (mychip_try_to_transmit(data))
+ if (snd_mychip_try_to_transmit(data))
snd_rawmidi_transmit_ack(substream, 1);
else
break; /* hardware FIFO full */
<informalexample>
<programlisting>
<![CDATA[
- while (mychip_transmit_possible()) {
+ while (snd_mychip_transmit_possible()) {
unsigned char data;
if (snd_rawmidi_transmit(substream, &data, 1) != 1)
break; /* no more data */
- mychip_transmit(data);
+ snd_mychip_transmit(data);
}
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- static void snd_xxx_input_trigger(snd_rawmidi_substream_t *substream, int up);
+ static void snd_xxx_input_trigger(struct snd_rawmidi_substream *substream, int up);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<![CDATA[
- static void snd_xxx_drain(snd_rawmidi_substream_t *substream);
+ static void snd_xxx_drain(struct snd_rawmidi_substream *substream);
]]>
</programlisting>
</informalexample>
<para>
This callback is optional. If you do not set
- <structfield>drain</structfield> in the snd_rawmidi_ops_t
+ <structfield>drain</structfield> in the struct snd_rawmidi_ops
structure, ALSA will simply wait for 50 milliseconds
instead.
</para>
<informalexample>
<programlisting>
<![CDATA[
- opl3_t *opl3;
+ struct snd_opl3 *opl3;
snd_opl3_create(card, lport, rport, OPL3_HW_OPL3_XXX,
integrated, &opl3);
]]>
<informalexample>
<programlisting>
<![CDATA[
- opl3_t *opl3;
+ struct snd_opl3 *opl3;
snd_opl3_new(card, OPL3_HW_OPL3_XXX, &opl3);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- snd_hwdep_t *opl3hwdep;
+ struct snd_hwdep *opl3hwdep;
snd_opl3_hwdep_new(opl3, 0, 1, &opl3hwdep);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- snd_hwdep_t *hw;
+ struct snd_hwdep *hw;
snd_hwdep_new(card, "My HWDEP", 0, &hw);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- mydata_t *p = kmalloc(sizeof(*p), GFP_KERNEL);
+ struct mydata *p = kmalloc(sizeof(*p), GFP_KERNEL);
hw->private_data = p;
hw->private_free = mydata_free;
]]>
<informalexample>
<programlisting>
<![CDATA[
- static void mydata_free(snd_hwdep_t *hw)
+ static void mydata_free(struct snd_hwdep *hw)
{
- mydata_t *p = hw->private_data;
+ struct mydata *p = hw->private_data;
kfree(p);
}
]]>
<informalexample>
<programlisting>
<![CDATA[
- static int playback_copy(snd_pcm_substream_t *substream, int channel,
+ static int playback_copy(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, void *src, snd_pcm_uframes_t count);
- static int capture_copy(snd_pcm_substream_t *substream, int channel,
+ static int capture_copy(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, void *dst, snd_pcm_uframes_t count);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- static int silence(snd_pcm_substream_t *substream, int channel,
+ static int silence(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- snd_pcm_sgbuf_t *sgbuf = (snd_pcm_sgbuf_t*)substream->dma_private;
+ struct snd_sg_buf *sgbuf = (struct snd_sg_buf_t*)substream->dma_private;
]]>
</programlisting>
</informalexample>
#include <linux/vmalloc.h>
/* get the physical page pointer on the given offset */
- static struct page *mychip_page(snd_pcm_substream_t *substream,
+ static struct page *mychip_page(struct snd_pcm_substream *substream,
unsigned long offset)
{
void *pageptr = substream->runtime->dma_area + offset;
<informalexample>
<programlisting>
<![CDATA[
- snd_info_entry_t *entry;
+ struct snd_info_entry *entry;
int err = snd_card_proc_new(card, "my-file", &entry);
]]>
</programlisting>
<informalexample>
<programlisting>
<![CDATA[
- static void my_proc_read(snd_info_entry_t *entry,
- snd_info_buffer_t *buffer);
+ static void my_proc_read(struct snd_info_entry *entry,
+ struct snd_info_buffer *buffer);
]]>
</programlisting>
</informalexample>
<informalexample>
<programlisting>
<
projects / linux-2.6 / commitdiff