linux音频驱动分析

linux音频驱动分析
creator   [e-mail]
int __init utu2440_uda1341_init(void)
{
    int             ret = 0;
//printk("ghcstop.........probe/n");
//首先是对L3总线的一些控制操作。
    ret = l3_attach_client(&uda1341, "l3-bit-24x0-gpio", "uda1341");
    if (ret)
    {
        printk("l3_attach_client() failed./n");
        return ret;
    }
    l3_open(&uda1341);
    start_uda1341();
//定义输出和输入stream和对应的DMA
    output_stream.dma_ch = S3C2410_DMA_CH2;
    output_stream.dmaclient.name = "audio_out";
    //申请输出DMA
   
    if (audio_init_dma(&output_stream, "UDA1341 out"))
    {
        audio_clear_dma(&output_stream);
        printk(KERN_WARNING AUDIO_NAME_VERBOSE ": unable to get DMA channels/n");
        return -EBUSY;
    }
    input_stream.dma_ch = S3C2410_DMA_CH1;
    input_stream.dmaclient.name = "audio_in";
    if (audio_init_dma(&input_stream, "UDA1341 in"))
    {
        audio_clear_dma(&input_stream);
        printk(KERN_WARNING AUDIO_NAME_VERBOSE ": unable to get DMA channels/n");
        return -EBUSY;
    }
    audio_dev_dsp = register_sound_dsp(&utu2440_audio_fops, -1);
    audio_dev_mixer = register_sound_mixer(&utu2440_mixer_fops, -1);
    printk(AUDIO_NAME_VERBOSE " initialized/n");
    return 0;
}
    上述中audio_stream的数据结构如下：
typedef struct
{
    int             size;       /* buffer size */
    char           *start;      /* point to actual buffer */
    dma_addr_t      dma_addr;   /* physical buffer address */
    struct semaphore sem;       /* down before touching the buffer */
    int             master;     /* owner for buffer allocation, contain size when true */
} audio_buf_t;
typedef struct
{
    audio_buf_t    *buffers;    /* pointer to audio buffer structures */
    audio_buf_t    *buf;        /* current buffer used by read/write */
    u_int           buf_idx;    /* index for the pointer above */
    u_int           fragsize;   /* fragment i.e. buffer size */
    u_int           nbfrags;    /* nbr of fragments */
    int             bytecount;  /* nbr of processed bytes */
    int             fragcount;  /* nbr of fragment transitions */
    u_int           channels;   /* audio channels 1:mono, 2:stereo */
    u_int           rate;       /* audio rate */
    dmach_t         dma_ch;     /* DMA channel (channel2 for audio) */
    int             active:1;   /* actually in progress */
    int             stopped:1;  /* might be active but stopped */
    wait_queue_head_t frag_wq;  /* for poll(), etc. */
    s3c2410_dma_client_t dmaclient; /* kernel 2.6 dma client */
} audio_stream_t;
void __exit utu2440_uda1341_exit(void)
{
    unregister_sound_dsp(audio_dev_dsp);
    unregister_sound_mixer(audio_dev_mixer);
    audio_clear_dma(&output_stream);
    audio_clear_dma(&input_stream);
    l3_close(&uda1341);
    l3_detach_client(&uda1341);
    printk(AUDIO_NAME_VERBOSE " unloaded/n");
   
    //return 0;
}
/* s3c2410_request_dma
*
* get control of an dma channel
*/
//这个函数的任务就是申请DMA通道和DMA中断。
int s3c2410_dma_request(unsigned int channel, s3c2410_dma_client_t *client,
            void *dev)
{
    s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
    unsigned long flags;
    int err;
    pr_debug("dma%d: s3c2410_request_dma: client=%s, dev=%p/n",
         channel, client->name, dev);
    check_channel(channel);
    local_irq_save(flags);
    dbg_showchan(chan);
    if (chan->in_use) {
        if (client != chan->client) {
            printk(KERN_ERR "dma%d: already in use/n", channel);
            local_irq_restore(flags);
            return -EBUSY;
        } else {
            printk(KERN_ERR "dma%d: client already has channel/n", channel);
        }
    }
    chan->client = client;
    chan->in_use = 1;
    if (!chan->irq_claimed) {
        pr_debug("dma%d: %s : requesting irq %d/n",
             channel, __FUNCTION__, chan->irq);
        //申请DMA中断，每个通道有一个他对应的中断，但是所有的通道的中断
        //都是采用s3c2410_dma_irq函数进行处理的，所以要在s3c2410_dma_irq
        //函数中对通道进行判断，所以在request_irq中最后一个数据是channel的
        //指针。虽然这个申请的中断并不是共享中断。
        err = request_irq(chan->irq, s3c2410_dma_irq, SA_INTERRUPT,
                  client->name, (void *)chan);
        if (err) {
            chan->in_use = 0;
            local_irq_restore(flags);
            printk(KERN_ERR "%s: cannot get IRQ %d for DMA %d/n",
                   client->name, chan->irq, chan->number);
            return err;
        }
        chan->irq_claimed = 1;
        chan->irq_enabled = 1;
    }
    local_irq_restore(flags);
    /* need to setup */
    pr_debug("%s: channel initialised, %p/n", __FUNCTION__, chan);
    return 0;
}
//dma中断的处理程序。
static irqreturn_t
s3c2410_dma_irq(int irq, void *devpw, struct pt_regs *regs)
{
    s3c2410_dma_chan_t *chan = (s3c2410_dma_chan_t *)devpw;
    s3c2410_dma_buf_t  *buf;
    buf = chan->curr;
    dbg_showchan(chan);
    /* modify the channel state */
    switch (chan->load_state) {
    case S3C2410_DMALOAD_1RUNNING:
        /* TODO - if we are running only one buffer, we probably
         * want to reload here, and then worry about the buffer
         * callback */
        chan->load_state = S3C2410_DMALOAD_NONE;
        break;
    case S3C2410_DMALOAD_1LOADED:
        /* iirc, we should go back to NONE loaded here, we
         * had a buffer, and it was never verified as being
         * loaded.
         */
        chan->load_state = S3C2410_DMALOAD_NONE;
        break;
    case S3C2410_DMALOAD_1LOADED_1RUNNING:
        /* we'll worry about checking to see if another buffer is
         * ready after we've called back the owner. This should
         * ensure we do not wait around too long for the DMA
         * engine to start the next transfer
         */
        chan->load_state = S3C2410_DMALOAD_1LOADED;
        break;
    case S3C2410_DMALOAD_NONE:
        printk(KERN_ERR "dma%d: IRQ with no loaded buffer?/n",
               chan->number);
        break;
    default:
        printk(KERN_ERR "dma%d: IRQ in invalid load_state %d/n",
               chan->number, chan->load_state);
        break;
    }
    if (buf != NULL) {
        /* update the chain to make sure that if we load any more
         * buffers when we call the callback function, things should
         * work properly */
        chan->curr = buf->next;
        buf->next  = NULL;
        if (buf->magic != BUF_MAGIC) {
            printk(KERN_ERR "dma%d: %s: buf %p incorrect magic/n",
                   chan->number, __FUNCTION__, buf);
            return IRQ_HANDLED;
        }
        s3c2410_dma_buffdone(chan, buf, S3C2410_RES_OK);
        /* free resouces */
        s3c2410_dma_freebuf(buf);
    } else {
    }
    if (chan->next != NULL) {
        unsigned long flags;
        switch (chan->load_state) {
        case S3C2410_DMALOAD_1RUNNING:
            /* don't need to do anything for this state */
            break;
        case S3C2410_DMALOAD_NONE:
            /* can load buffer immediately */
            break;
        case S3C2410_DMALOAD_1LOADED:
            if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
                /* flag error? */
                printk(KERN_ERR "dma%d: timeout waiting for load/n",
                       chan->number);
                return IRQ_HANDLED;
            }
            break;
        case S3C2410_DMALOAD_1LOADED_1RUNNING:
            goto no_load;
        default:
            printk(KERN_ERR "dma%d: unknown load_state in irq, %d/n",
                   chan->number, chan->load_state);
            return IRQ_HANDLED;
        }
        local_irq_save(flags);
        s3c2410_dma_loadbuffer(chan, chan->next);
        local_irq_restore(flags);
    } else {
        s3c2410_dma_lastxfer(chan);
        /* see if we can stop this channel.. */
        if (chan->load_state == S3C2410_DMALOAD_NONE) {
            pr_debug("dma%d: end of transfer, stopping channel (%ld)/n",
                 chan->number, jiffies);
            s3c2410_dma_ctrl(chan->number, S3C2410_DMAOP_STOP);
        }
    }
no_load:
    return IRQ_HANDLED;
}
Atomic transfer：指的是DMA的单次原子操作，它可以是Unit模式（传输1个data size），也可以是burst模式（传输4个data size），具体对应DCON[28]。
Data Size：指的是单次原子操作的数据位宽，8、16、32，具体对应DCON[21:20]。
Request Source：DMA请求的来源有两种，软件＆硬件模块，由DCON[23]控制；当为前者时，由软件对DMASKTRIG寄存器的位0置位触发一次DMA 操作。当为后者时，具体来源由DCON[26:24]控制，不同硬件模块的某时间触发一次DMA操作，具体要见不同的硬件模块。
   
DMA service mode：DMA的工作模式有两种，单一服务模式＆整体服务模式。前一模式下，一次DMA请求完成一项原子操作，并且transfer count的值减1。后一模式下，一次DMA请求完成一批原子操作，直到transfer count等于0表示完成一次整体服务。具体对应DCON[27]。
RELOAD：在reload模式下，当transfer count的值变为零时，将自动加src、dst、TC的值加载到CURR_DST、 CURR_SRC、CURR_TC，并开始一次新的DMA传输。该模式一般和整体服务模式一起使用，也就是说当一次整体服务开始后，src、dst、TC 的值都已经被加载，因此可以更改为下一次
   服务的地址，2410说明文档中建议加入以下语句来判断当前的服务开始，src、dst、TC的值可以被更改了：while((rDSTATn & 0xfffff) == 0) ;
Req&Ack：DMA请求和应答的协议有两种，Demard mode 和 Handshake mode。两者对Request和Ack的时序定义有所不同：在Demard模式下，如果
   DMA完成一次请求如果Request仍然有效，那么DMA就认为这是下一次DMA请求；在Handshake模式下，DMA完成一次请求后等待Request信号无效，然后把ACK也置无效，再等待下一次Request。这个设计外部DMA请求时可能要用到。
传输总长度：DMA一次整体服务传输的总长度为：
    Data Size × Atomic transfer size × TC（字节）。
static int __init audio_init_dma(audio_stream_t * s, char *desc)
{
    int ret;
   
    if (s->dma_ch == S3C2410_DMA_CH2) // 输出DMA
    {
            //申请DMA
        ret = s3c2410_dma_request(s->dma_ch, &(s->dmaclient), NULL);
        if( ret )
        {
            dprintk("%s: dma request err/n", __FUNCTION__ );
            return ret;
        }
        
        ao_dcon = S3C2410_DCON_HANDSHAKE|S3C2410_DCON_SYNC_PCLK|S3C2410_DCON_TSZUNIT|S3C2410_DCON_SSERVE|S3C2410_DCON_CH2_I2SSDO|S3C2410_DCON_NORELOAD|
        s3c2410_dma_config(s->dma_ch, 2, ao_dcon); // a out, halfword
        /* flags */
#define S3C2410_DMAF_SLOW         (1dma_ch, S3C2410_DMAF_AUTOSTART); // a out
                //在这里定义buffdone callback，他会在dma中断里面调用。
        s3c2410_dma_set_buffdone_fn(s->dma_ch, audio_dmaout_done_callback);
        //设定sourc为mem，
        #define BUF_ON_MEM        (ON_AHB | ADDR_INC)
                #define BUF_ON_APB        (ON_APB    | ADDR_FIX)
        s3c2410_dma_devconfig(s->dma_ch, S3C2410_DMASRC_MEM, BUF_ON_APB, 0x55000010);
        dprintk("%s: dma request done audio out channel/n", __FUNCTION__ );
        
        
        
        return 0;
    }
    else if (s->dma_ch == S3C2410_DMA_CH1)
    {
        ret = s3c2410_dma_request(s->dma_ch, &(s->dmaclient), NULL);
        if( ret )
        {
            dprintk("%s: dma request err/n", __FUNCTION__ );
            return ret;
        }
        ai_dcon = S3C2410_DCON_HANDSHAKE|S3C2410_DCON_SYNC_PCLK|S3C2410_DCON_TSZUNIT|S3C2410_DCON_SSERVE|S3C2410_DCON_CH1_I2SSDI|S3C2410_DCON_NORELOAD|
        s3c2410_dma_config(s->dma_ch, 2, ai_dcon); // a in, halfword
        s3c2410_dma_setflags(s->dma_ch, S3C2410_DMAF_AUTOSTART); // a in
        
        s3c2410_dma_set_buffdone_fn(s->dma_ch, audio_dmain_done_callback);
        s3c2410_dma_devconfig(s->dma_ch, S3C2410_DMASRC_HW, BUF_ON_APB, 0x55000010);         
        
        dprintk("%s: dma request done audio in channel/n", __FUNCTION__ );
        return 0;
    }
    else
        return 1;
}
然后就是对open的介绍了。
static int
utu2440_audio_open(struct inode *inode, struct file *file)
{
    int             cold = !audio_active;
    dprintk("audio_open/n");
    if ((file->f_flags & O_ACCMODE) == O_RDONLY)
    {
        if (audio_rd_refcount || audio_wr_refcount)
            return -EBUSY;
        audio_rd_refcount++;
    }
    else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
    {
        if (audio_wr_refcount)
            return -EBUSY;
        audio_wr_refcount++;
    }
    else if ((file->f_flags & O_ACCMODE) == O_RDWR)
    {
        if (audio_rd_refcount || audio_wr_refcount)
            return -EBUSY;
        audio_rd_refcount++;
        audio_wr_refcount++;
    }
    else
        return -EINVAL;
    if (cold)
    {
        audio_rate = AUDIO_RATE_DEFAULT;
        audio_channels = AUDIO_CHANNELS_DEFAULT;
        /*
         * the UDA1341 is stereo only ==> 2 channels
         */
        if ((file->f_mode & FMODE_WRITE))
        {
            output_stream.fragsize = AUDIO_FRAGSIZE_DEFAULT; //每个缓冲区的大小
            output_stream.nbfrags = AUDIO_NBFRAGS_DEFAULT; //环形缓冲区的数量
            output_stream.channels = audio_channels;
            start_utu2440_iis_bus_tx();
            audio_clear_buf(&output_stream);
            init_waitqueue_head(&output_stream.frag_wq);
        }
        if ((file->f_mode & FMODE_READ))
        {
            input_stream.fragsize = AUDIO_FRAGSIZE_DEFAULT;
            input_stream.nbfrags = AUDIO_NBFRAGS_DEFAULT;
            input_stream.channels = audio_channels;
            start_utu2440_iis_bus_rx();
            audio_clear_buf(&input_stream);
            init_waitqueue_head(&input_stream.frag_wq);
        }
    }
    return 0;
}
关键部分的函数。
static          ssize_t
utu2440_audio_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
{
    const char     *buffer0 = buffer;
    audio_stream_t *s = &output_stream;
    int             chunksize,
                    ret = 0;
    dprintk("audio_write : start count=%d/n", count);
    switch (file->f_flags & O_ACCMODE)
    {
    case O_WRONLY:
    case O_RDWR:
        break;
    default:
        return -EPERM;
    }
    if (!s->buffers && audio_setup_buf(s))
        return -ENOMEM;
    count &= ~0x03;
    while (count > 0)
    {
        audio_buf_t    *b = s->buf;
        if (file->f_flags & O_NONBLOCK)
        {
            ret = -EAGAIN;
            if (down_trylock(&b->sem))
                break;
        }
        else
        {
            ret = -ERESTARTSYS;
            if (down_interruptible(&b->sem))
                break;
        }
        if (s->channels == 2)
        {   //每次传输的是一个缓冲区的大小，b->size代表目前传输了多少。
            chunksize = s->fragsize - b->size;
            if (chunksize > count)
                chunksize = count;
            dprintk("write %d to %d/n", chunksize, s->buf_idx);
            if (copy_from_user(b->start + b->size, buffer, chunksize))
            {
                up(&b->sem);
                return -EFAULT;
            }
            b->size += chunksize;
        }
        else
        {
            chunksize = (s->fragsize - b->size) >> 1;
            if (chunksize > count)
                chunksize = count;
            dprintk("write %d to %d/n", chunksize * 2, s->buf_idx);
            if (copy_from_user_mono_stereo(b->start + b->size, buffer, chunksize))
            {
                up(&b->sem);
                return -EFAULT;
            }
            b->size += chunksize * 2;
        }
        buffer += chunksize;
        count -= chunksize;
        if (b->size fragsize)
        {
            up(&b->sem);
            break;
        }
        s->active = 1;          // ghcstop add
        //每次从b->dma_addr开始传输 b->size个数据，一直传输到所有的缓冲区满，
        //等待dma传输中断，释放sem，可以有空闲的缓冲区。
        s3c2410_dma_enqueue(s->dma_ch, (void *) b, b->dma_addr, b->size);
        
        b->size = 0;
        NEXT_BUF(s, buf);
    }
    if ((buffer - buffer0))
        ret = buffer - buffer0;
    dprintk("audio_write : end count=%d/n/n", ret);
    return ret;
}