So here we are on the final chapter of the ALSA driver series. We will finally fill in the meat of the driver with some simple handler callbacks for the PCM capture device we've been developing. In the previous post,
Writing an ALSA driver: Setting up capture, we defined
my_pcm_ops, which was used when calling
snd_pcm_set_ops() for our PCM device. Here is that structure again:
static struct snd_pcm_ops my_pcm_ops = {
.open = my_pcm_open,
.close = my_pcm_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = my_hw_params,
.hw_free = my_hw_free,
.prepare = my_pcm_prepare,
.trigger = my_pcm_trigger,
.pointer = my_pcm_pointer,
.copy = my_pcm_copy,
};
First let's start off with the open and close methods defined in this structure. This is where your driver gets notified that someone has opened the capture device (file open) and subsequently closed it.
static int my_pcm_open(struct snd_pcm_substream *ss)
{
ss->runtime->hw = my_pcm_hw;
ss->private_data = my_dev;
return 0;
}
static int my_pcm_close(struct snd_pcm_substream *ss)
{
ss->private_data = NULL;
return 0;
}
This is the minimum you would do for these two functions. If needed, you would allocate private data for this stream and free it on close.
For the ioctl handler, unless you need something special, you can just use the standard
snd_pcm_lib_ioctl callback.
The next three callbacks handle hardware setup.
static int my_hw_params(struct snd_pcm_substream *ss,
struct snd_pcm_hw_params *hw_params)
{
return snd_pcm_lib_malloc_pages(ss,
params_buffer_bytes(hw_params));
}
static int my_hw_free(struct snd_pcm_substream *ss)
{
return snd_pcm_lib_free_pages(ss);
}
static int my_pcm_prepare(struct snd_pcm_substream *ss)
{
return 0;
}
Since we've been using standard memory allocation routines from ALSA, these functions stay fairly simple. If you have some special exceptions between different versions of the hardware supported by your driver, you can make changes to the ss->hw structure here (e.g. if one version of your card supports 96khz, but the rest only support 48khz max).
The PCM prepare callback should handle anything your driver needs to do before alsa-lib can ask it to start sending buffers. My driver doesn't do anything special here, so I have an empty callback.
This next handler tells your driver when ALSA is going to start and stop capturing buffers from your device. Most likely you will enable and disable interrupts here.
static int my_pcm_trigger(struct snd_pcm_substream *ss,
int cmd)
{
struct my_device *my_dev = snd_pcm_substream_chip(ss);
int ret = 0;
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
// Start the hardware capture
break;
case SNDRV_PCM_TRIGGER_STOP:
// Stop the hardware capture
break;
default:
ret = -EINVAL;
}
return ret;
}
Let's move on to the handlers that are the work horse in my driver. Since the hardware that I'm writing my driver for cannot directly DMA into memory that ALSA has supplied for us to communicate with userspace, I need to make use of the copy handler to perform this operation.
static snd_pcm_uframes_t my_pcm_pointer(struct snd_pcm_substream *ss)
{
struct my_device *my_dev = snd_pcm_substream_chip(ss);
return my_dev->hw_idx;
}
static int my_pcm_copy(struct snd_pcm_substream *ss,
int channel, snd_pcm_uframes_t pos,
void __user *dst,
snd_pcm_uframes_t count)
{
struct my_device *my_dev = snd_pcm_substream_chip(ss);
return copy_to_user(dst, my_dev->buffer + pos, count);
}
So here we've defined a pointer function which gets called by userspace to find our where the hardware is in writing to the buffer.
Next, we have the actual copy function. You should note that count and pos are in sample sizes, not bytes. The buffer I've shown we assume to have been filled during interrupt.
Speaking of interrupt, that is where you should also signal to ALSA that you have more data to consume. In my ISR (interrupt service routine), I have this:
snd_pcm_period_elapsed(my_dev->ss);
And I think we're done. Hopefully now you have at least the stubs in place for a working driver, and will be able to fill in the details for your hardware. One day I may come back and write another post on how to add mixer controls (e.g. volume).
Hope this series has helped you out!
<< Prev
