[转]IIS音频驱动程序分析

Linux 下的IIS 音频驱动程序主要都在/kernel/drivers/sound/s3c2410-uda1341.c 文件中。

    在音频驱动程序中有2个比较重要的结构体：

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 */（音频缓冲区片数量）
dmach_t dma_ch;   /* DMA channel (channel2 for audio) */
} audio_stream_t;

这是一个管理多缓冲区的结构体，结构体audio_stream_t 为音频流数据组成了一个环形缓冲区。（audio_buf_t *buffers 同触摸屏驱动中struct TS_DEV 结构中的TS_RET buf[MAX_TS_BUF] 意义一样，都为环形缓冲区）用audio_buf_t 来管理一段内存，在用audio_stream_t 来管理N 个audio_buf_t。

    音频驱动的file_operations 结构定义如下：
static struct file_operations smdk2410_audio_fops = {
llseek:   smdk2410_audio_llseek,
write:   smdk2410_audio_write,
read:   smdk2410_audio_read,
poll:   smdk2410_audio_poll,
ioctl:   smdk2410_audio_ioctl,
open:   smdk2410_audio_open,
release: smdk2410_audio_release
};

static struct file_operations smdk2410_mixer_fops = {
ioctl:   smdk2410_mixer_ioctl,
open:   smdk2410_mixer_open,
release: smdk2410_mixer_release
};

这里定义了两种类型设备的file_operations 结构，前者是DSP 设备，后者是混频器设备。

------------------------------------------------------------------------
    和往常一样，先来看一下加载驱动模块时的初始化函数：
int __init s3c2410_uda1341_init(void)
该函数首先会初始化I/O 和UDA1341 芯片，然后申请2个DMA 通道用于音频传输。

local_irq_save(flags);

调用该宏函数来保存IRQ 中断使能状态，并禁止IRQ 中断。

在/kernel/include/asm-arm/system.h 文件中：
/* For spinlocks etc */
#define local_irq_save(x) __save_flags_cli(x)
#define local_irq_restore(x) __restore_flags(x)

在/kernel/include/asm-arm/proc-armo/system.h 文件中：
/*
* Save the current interrupt enable state & disable IRQs
*/
#define __save_flags_cli(x)     \
do {       \
   unsigned long temp;     \
   __asm__ __volatile__(     \
" mov %0, pc   @ save_flags_cli\n" \
" orr %1, %0, #0x08000000\n"    \
" and %0, %0, #0x0c000000\n"    \
" teqp %1, #0\n"     \
   : "=r" (x), "=r" (temp)    \
   :       \
   : "memory");      \
} while (0)

最后用ARM 汇编指令实现了保存IRQ 和FIQ 的中断使能状态，并禁止IRQ 中断。

/*
* restore saved IRQ & FIQ state
*/
#define __restore_flags(x)     \
do {       \
   unsigned long temp;     \
   __asm__ __volatile__(     \
" mov %0, pc   @ restore_flags\n" \
" bic %0, %0, #0x0c000000\n"    \
" orr %0, %0, %1\n"     \
" teqp %0, #0\n"     \
   : "=&r" (temp)     \
   : "r" (x)      \
   : "memory");      \
} while (0)

最后用ARM 汇编指令实现了恢复IRQ 和FIQ 的中断使能状态。

/* GPB 4: L3CLOCK, OUTPUT */
set_gpio_ctrl(GPIO_L3CLOCK);
/* GPB 3: L3DATA, OUTPUT */
set_gpio_ctrl(GPIO_L3DATA);
/* GPB 2: L3MODE, OUTPUT */
set_gpio_ctrl(GPIO_L3MODE);

/* GPE 3: I2SSDI */
set_gpio_ctrl(GPIO_E3 | GPIO_PULLUP_EN | GPIO_MODE_I2SSDI);
/* GPE 0: I2SLRCK */
set_gpio_ctrl(GPIO_E0 | GPIO_PULLUP_EN | GPIO_MODE_I2SSDI);
/* GPE 1: I2SSCLK */
set_gpio_ctrl(GPIO_E1 | GPIO_PULLUP_EN | GPIO_MODE_I2SSCLK);
/* GPE 2: CDCLK */
set_gpio_ctrl(GPIO_E2 | GPIO_PULLUP_EN | GPIO_MODE_CDCLK);
/* GPE 4: I2SSDO */
set_gpio_ctrl(GPIO_E4 | GPIO_PULLUP_EN | GPIO_MODE_I2SSDO);

    接下来马上设置与UDA1341 芯片相关GPIO 引脚。这里首先将GPB4，GPB3，GPB2 这3个GPIO 引脚设置为输出模式，参考原理图后，得知这3个引脚分别连接UDA1341 芯片的L3CLOCK，L3DATA，L3MODE 这3个引脚，作为这3个信号的输入。

在/kernel/drivers/sound/s3c2410-uda1341.c 文件中：
#define GPIO_L3CLOCK            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_B4)
#define GPIO_L3DATA             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_B3)
#define GPIO_L3MODE             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_B2)
   
    然后继续设置与IIS 控制器输出信号相关GPIO 引脚。将GPE0～GPE4 这5个引脚设置为IIS 接口的信号模式。需要通过配置GPECON 寄存器来设定该端口管脚的输出模式，对应位如下：

[9:8] [7:6] [5:4] [3:2] [1:0]
GPE4   GPE3   GPE2   GPE1   GPE0
参考S3C2410 芯片datasheet 的I/O口章节，都要设为10（二进制）。

local_irq_restore(flags);

    设置完GPIO 口的工作模式，就可以前面已经分析过的local_irq_restore 宏函数来恢复IRQ 和FIQ 的中断使能状态。

init_uda1341();

    这里调用了init_uda1341 函数来初始化UDA1341 芯片，该函数会在后面说明。

output_stream.dma_ch = DMA_CH2;

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 = DMA_CH1;

        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_stream_t 结构的变量，分别是output_stream 和input_stream，一个作为输出音频缓冲区，一个作为输入音频缓冲区。
    将输出音频缓冲区的DMA 通道设为通道2，输入音频缓冲区的DMA 通道设为通道1。

在/kernel/include/asm-arm/arch-s3c2410/dma.h 文件中：
#define DMA_CH0    0
#define DMA_CH1    1
#define DMA_CH2    2
#define DMA_CH3    3

通过查阅S3C2410 芯片datasheet 中的DMA 章节，知道该芯片共有4个DMA 通道，DMA 控制器的每个通道可以从4个DMA 源中选择一个DMA 请求源。其中，通道1具有IIS 输入源，而通道2具有IIS 输出和输入源。所以要以全双工模式进行音频数据传输的话，只有将输出音频缓冲区的设为DMA 通道2，输入音频缓冲区设为DMA 通道1。

    接着调用2次audio_init_dma 函数来分别对输出和输入音频缓冲区的DMA 通道进行初始化设置。该函数比较简单，定义如下：
static int __init audio_init_dma(audio_stream_t * s, char *desc)
{
if(s->dma_ch == DMA_CH2)
   return s3c2410_request_dma("I2SSDO", s->dma_ch, audio_dmaout_done_callback, NULL);
else if(s->dma_ch == DMA_CH1)
   return s3c2410_request_dma("I2SSDI", s->dma_ch, NULL ,audio_dmain_done_callback);
else
   return 1;
}

    这个函数其实就是对DMA 的通道号进行判断，然后调用了s3c2410_request_dma 函数来向内核申请一个DMA 通道。

在/kernel/arch/arm/mach-s3c2410/dma.c 文件中：
int s3c2410_request_dma(const char *device_id, dmach_t channel,
    dma_callback_t write_cb, dma_callback_t read_cb)

在该函数中会分配DMA 通道，并申请DMA 中断，即当DMA 传输结束时，会响应中断请求，调用回调函数。这里的参数中，device_id 为设备id 号，用字符串来表示；channel 为DMA 通道号，将前面定义的通道号1，2传入；write_cb 和read_cb 分别指向DMA 发送和读取结束时调用的函数，即DMA 传输结束时调用的回调函数。
在该函数中有：
err = request_irq(dma->irq, dma_irq_handler, 0 * SA_INTERRUPT,
       device_id, (void *)dma);

即申请了一个DMA 的中断号，中断处理子程序为dma_irq_handler 函数，然后：
dma->write.callback = write_cb;
dma->read.callback = read_cb;

将读写DMA 中断的两个回调函数指针传入。

在/kernel/arch/arm/mach-s3c2410/dma.c 文件中：
static void dma_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
{
s3c2410_dma_t *dma = (s3c2410_dma_t *)dev_id;

DPRINTK(__FUNCTION__"\n");

s3c2410_dma_done(dma);
}

在中断处理子程序中，调用了s3c2410_dma_done 函数，该函数定义如下：
static inline void s3c2410_dma_done(s3c2410_dma_t *dma)
{
dma_buf_t *buf = dma->curr;
dma_callback_t callback;

if (buf->write) callback = dma->write.callback;
else callback = dma->read.callback;

#ifdef HOOK_LOST_INT
stop_dma_timer();
#endif
DPRINTK("IRQ: b=%#x st=%ld\n", (int)buf->id, (long)dma->regs->DSTAT);
if (callback)
   callback(buf->id, buf->size);
kfree(buf);
dma->active = 0;
process_dma(dma);
}

最后在s3c2410_dma_done 函数中，通过callback 函数指针调用了DMA 发送和读取的回调函数。

    DMA 写入和读取的两个回调函数audio_dmaout_done_callback，audio_dmain_done_callback 会在后面说明。其中DMA 写入为音频输出，DMA 读取为音频输入。
    在调用audio_init_dma 函数来对输出和输入音频缓冲区的DMA 通道进行初始化设置时，如果返回失败，则会调用audio_clear_dma 函数来释放已申请的DMA 通道。在audio_clear_dma 函数中直接调用了s3c2410_free_dma 函数来进行动作。

在/kernel/arch/arm/mach-s3c2410/dma.c 文件中：
void s3c2410_free_dma(dmach_t channel)

该函数中释放了已申请的DMA 通道，并调用了free_irq 函数来释放已分配的DMA 发送和读取结束的中断号。

audio_dev_dsp = register_sound_dsp(&smdk2410_audio_fops, -1);
audio_dev_mixer = register_sound_mixer(&smdk2410_mixer_fops, -1);

    在驱动模块的初始化函数最后调用了register_sound_dsp，和register_sound_mixer 两个函数来分别注册驱动设备，前者注册为DSP 设备，后者注册为混频器设备。

在/kernel/drivers/sound/sound_core.c 文件中：
/**
* register_sound_dsp - register a DSP device
* @fops: File operations for the driver
* @dev: Unit number to allocate
*
* Allocate a DSP device. Unit is the number of the DSP requested.
* Pass -1 to request the next free DSP unit. On success the allocated
* number is returned, on failure a negative error code is returned.
*
* This function allocates both the audio and dsp device entries together
* and will always allocate them as a matching pair - eg dsp3/audio3
*/

int register_sound_dsp(struct file_operations *fops, int dev)

/**
* register_sound_mixer - register a mixer device
* @fops: File operations for the driver
* @dev: Unit number to allocate
*
* Allocate a mixer device. Unit is the number of the mixer requested.
* Pass -1 to request the next free mixer unit. On success the allocated
* number is returned, on failure a negative error code is returned.
*/

int register_sound_mixer(struct file_operations *fops, int dev)

这两个函数的参数一样，fops 为传给内核的file_operations 结构中的接口函数，dev 为分配的设备序号，设为-1 表示由内核自动分配一个空闲的序号。

------------------------------------------------------------------------
    紧接着就来看一下init_uda1341 这个初始化UDA1341 芯片的函数：
static void init_uda1341(void)

uda1341_volume = 62 - ((DEF_VOLUME * 61) / 100);
uda1341_boost = 0;
uda_sampling = DATA2_DEEMP_NONE;
uda_sampling &= ~(DATA2_MUTE);

    首先上来就是设定几个待会儿配置要用的参数。参考UDA1341 芯片datasheet 后，可以知道uda1341_volume 参数的含义，62 表示音量设置表中有效音量的总档数，61 表示音量总共有61 档，DEF_VOLUME％表示所要调的音量的百分比大小，这样61*DEF_VOLUME％所得出的就是所要调的音量是音量总档数的第几档，由于音量设 置表中列出值的是按衰减量递增的，所以刚才得到的音量档数需要在总档数下衰减多少才能得到呢？显然只要将音量总档数减去所要调到的音量档数即可，即62- 61*DEF_VOLUME％。

local_irq_save(flags);

    同先前一样，调用该宏函数来保存IRQ 中断使能状态，并禁止IRQ 中断。

write_gpio_bit(GPIO_L3MODE, 1);
write_gpio_bit(GPIO_L3CLOCK, 1);

    调用write_gpio_bit 宏函数，将GPIO 相应的引脚设为高电平或低电平。这里是把GPIO_L3MODE 和GPIO_L3CLOCK 这两个引脚设为高电平。

local_irq_restore(flags);

    同先前一样，调用该宏函数来恢复IRQ 和FIQ 的中断使能状态。

//*******************************************************
//* 2007.7.6
//*******************************************************

uda1341_l3_address(UDA1341_REG_STATUS);
        uda1341_l3_data(STAT0_SC_384FS | STAT0_IF_MSB);     // set 384 system clock, MSB
        uda1341_l3_data(STAT1 | STAT1_DAC_GAIN | STAT1_ADC_GAIN | STAT1_ADC_ON | STAT1_DAC_ON);

    下面就调用了uda1341_l3_address 函数和uda1341_l3_data 函数来对UDA1341 芯片进行配置。在看了UDA1341 芯片的datasheet 后知道了，原来S3C2410 与UDA1341 的通信就是通过L3CLOCK，L3DATA，L3MODE 这3个引脚，通信时序由GPIO 口编程控制，有点类似于SPI 接口时序。这两个函数会在后面进行说明。
    其中uda1341_l3_address 函数是L3 接口操作模式的地址模式，这里用00010110（二进制）（参考了UDA1341 芯片的datasheet 得知D7～D2 为设备地址，默认UDA1341TS 的设备地址为000101，而D1～D0 为数据传输的类型）参数设置为寄存器状态地址。uda1341_l3_data 函数是L3 接口操作模式的数据传输模式，这里先用00011000（二进制）参数将系统时钟设置为384fs，数据输入格式设置为MSB 模式，然后用11100011（二进制）参数将DAC 和ADC 的获取开关都设为6dB，将DAC 和ADC 电源控制都设为打开。

        uda1341_l3_address(UDA1341_REG_DATA0);
uda1341_l3_data(DATA0 |DATA0_VOLUME(uda1341_volume)); // maximum volume
uda1341_l3_data(DATA1 |DATA1_BASS(uda1341_boost)| DATA1_TREBLE(0));
        uda1341_l3_data(uda_sampling); /* --;;*/
uda1341_l3_data(EXTADDR(EXT2));
uda1341_l3_data(EXTDATA(EXT2_MIC_GAIN(0x6)) | EXT2_MIXMODE_CH1);

    再次调用uda1341_l3_address 函数，用00010100（二进制）参数设置为直接地址寄存器模式。接着分5次调用uda1341_l3_data 函数来进行配置，第一次用uda1341_volume 参数的值23（十进制）将音量大小设置为总音量的65％；第二次用01000000（二进制）参数将低音推进设置为0，高音设置为0；第三次用 00000000（二进制）参数又将音量调到衰减0dB，即调到最大（不理解为什么）；最后两次要一起看，先用11000010（二进制）参数将 EA2～EA0 设为010（二进制）进入设置特定功能的外部地址，然后用11111001（二进制）参数将ED4～ED0 设为11001（二进制）将MIC 的灵敏度设为+27dB，将混频器模式设为选择通道1输入（这时通道2输入关闭）。
【其实这里的“uda1341_l3_data(uda_sampling); /* --;;*/”，这句话应该是不正确的，不是准备再将音量调到最大。应该改为：
uda_l3_data(DATA2 | uda_sampling);
即用10000000（二进制）参数设置静音关闭和高低音模式为flat 模式（高低音增益都为0dB）等。】

------------------------------------------------------------------------
    马上来看一下uda1341_l3_address 和uda1341_l3_data 这两个具体控制GPIO 口时序来传输数据的函数。首先看uda1341_l3_address 函数：
static void uda1341_l3_address(u8 data)

local_irq_save(flags);

    在对GPIO 口设置或操作前总要先调用该宏函数来保存IRQ 中断使能状态，并禁止IRQ 中断。

write_gpio_bit(GPIO_L3MODE, 0);
write_gpio_bit(GPIO_L3DATA, 0);
write_gpio_bit(GPIO_L3CLOCK, 1);

    分别将GPIO_L3MODE 引脚设为低电平，将GPIO_L3DATA 引脚设为低电平，将GPIO_L3CLOCK 引脚设为高电平。根据UDA1341 芯片datasheet 里的时序图，把GPIO_L3MODE 引脚设为低电平，就是地址模式。

udelay(1);

    调用udelay 函数来短暂延时1us。在驱动程序中用udelay 函数来延时微秒级时间，mdelay 函数来延时毫秒级时间，而在应用程序中用usleep 函数来延时微秒级时间，sleep 函数来延时毫秒级时间。

在/kernel/include/asm-arm/delay.h 文件中：
/*
* division by multiplication: you don't have to worry about
* loss of precision.
*
* Use only for very small delays ( < 1 msec). Should probably use a
* lookup table, really, as the multiplications take much too long with
* short delays. This is a "reasonable" implementation, though (and the
* first constant multiplications gets optimized away if the delay is
* a constant)
*/
extern void udelay(unsigned long usecs);

在/kernel/include/linux/delay.h 文件中：
#ifdef notdef
#define mdelay(n) (\
{unsigned long msec=(n); while (msec--) udelay(1000);})
#else
#define mdelay(n) (\
(__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : \
({unsigned long msec=(n); while (msec--) udelay(1000);}))
#endif

在/kernel/arch/arm/lib/delay.S 文件中：
/*
* 0 <= r0 <= 2000
*/
ENTRY(udelay)
   mov r2,     #0x6800
   orr r2, r2, #0x00db
   mul r1, r0, r2
   ldr r2, LC0
   ldr r2, [r2]
   mov r1, r1, lsr #11
   mov r2, r2, lsr #11
   mul r0, r1, r2
   movs r0, r0, lsr #6
   RETINSTR(moveq,pc,lr)

最后用ARM 汇编指令实现了微秒级的短暂延时。

for (i = 0; i < 8; i++) {
   if (data & 0x1) {
    write_gpio_bit(GPIO_L3CLOCK, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3DATA, 1);
    udelay(1);
    write_gpio_bit(GPIO_L3CLOCK, 1);
    udelay(1);
   } else {
    write_gpio_bit(GPIO_L3CLOCK, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3DATA, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3CLOCK, 1);
    udelay(1);
   }
   data >>= 1;
}

    接下来就是将一个字节一位一位通过GPIO 口发送出去的循环结构，从该字节的最低位（D0）开始发送。若D0 为1，则设置GPIO_L3DATA 引脚为高电平，否则为低电平。同时需要控制GPIO_L3CLOCK 引脚的时钟信号，数据会在时钟的上升沿写入UDA1341 芯片，所以需要在时钟引脚为低电平时准备好要传送的数据，然后再将时钟设为高电平。在设置时钟和数据引脚之间用udelay 函数进行短暂延时1us。

write_gpio_bit(GPIO_L3MODE, 1);
udelay(1);

    在地址模式下数据传送完成后，则设置GPIO_L3MODE 引脚为高电平，准备进入数据传输模式，并短暂延时1us。

local_irq_restore(flags);

    最后调用该宏函数来恢复IRQ 和FIQ 的中断使能状态。

------------------------------------------------------------------------
    接着来看uda1341_l3_data 函数：
static void uda1341_l3_data(u8 data)

local_irq_save(flags);

    同样首先要调用该宏函数来保存IRQ 中断使能状态，并禁止IRQ 中断。

write_gpio_bit(GPIO_L3MODE, 1);
udelay(1);

write_gpio_bit(GPIO_L3MODE, 0);
udelay(1);
write_gpio_bit(GPIO_L3MODE, 1);

    在进入数据传输模式前，先要将GPIO_L3MODE 信号需要有一个低电平的脉冲，所以依次设置该引脚为高电平，低电平，高电平，这样就进入了数据传输模式。

for (i = 0; i < 8; i++) {
   if (data & 0x1) {
    write_gpio_bit(GPIO_L3CLOCK, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3DATA, 1);
    udelay(1);
    write_gpio_bit(GPIO_L3CLOCK, 1);
    udelay(1);
   } else {
    write_gpio_bit(GPIO_L3CLOCK, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3DATA, 0);
    udelay(1);
    write_gpio_bit(GPIO_L3CLOCK, 1);
    udelay(1);
   }

   data >>= 1;
}

    接下来的这个步骤和uda1341_l3_address 函数一样，一位一位将数据发送出去。

write_gpio_bit(GPIO_L3MODE, 1);
write_gpio_bit(GPIO_L3MODE, 0);
udelay(1);
write_gpio_bit(GPIO_L3MODE, 1);

    最后，GPIO_L3MODE 信号同样需要有一个低电平的脉冲才表示数据传输模式结束，所以再次设置该引脚为高电平，低电平，高电平。

local_irq_restore(flags);

    完成后，调用该宏函数来恢复IRQ 和FIQ 的中断使能状态。

------------------------------------------------------------------------
    看一下卸载驱动模块时调用的函数：
void __exit s3c2410_uda1341_exit(void)

    这个函数就比较简单了。

unregister_sound_dsp(audio_dev_dsp);
unregister_sound_mixer(audio_dev_mixer);

    首先调用unregister_sound_dsp 和unregister_sound_mixer 这两个函数来分别注销原先注册的DSP 设备和混频器设备。

在/kernel/drivers/sound/sound_core.c 文件中：
/**
* unregister_sound_dsp - unregister a DSP device
* @unit: unit number to allocate
*
* Release a sound device that was allocated with register_sound_dsp().
* The unit passed is the return value from the register function.
*
* Both of the allocated units are released together automatically.
*/

void unregister_sound_dsp(int unit)

/**
* unregister_sound_mixer - unregister a mixer
* @unit: unit number to allocate
*
* Release a sound device that was allocated with register_sound_mixer().
* The unit passed is the return value from the register function.
*/

void unregister_sound_mixer(int unit)

这两个函数的参数一样，为刚才调用注册函数时返回的内核所分配的设备序号。

audio_clear_dma(&output_stream);
audio_clear_dma(&input_stream); /* input */

    分两次调用audio_clear_dma 函数来分别释放已申请的音频输入和音频输出的DMA 通道。

------------------------------------------------------------------------
    继续来看一下打开设备文件的接口函数，这里先看针对DSP 设备文件的函数：
static int smdk2410_audio_open(struct inode *inode, struct file *file)

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;

    首先上来就是一大段条件判断，主要就是判断file->f_flags 这个表示设备文件的打开方式是读取，写入，还是可读写。用audio_rd_refcount 和audio_wr_refcount 这两个变量来设置类似于信号量一样的读写占位标志（要写设备的话，只要没有用写方式打开过设备即可；要读的话，则需要该设备同时没有用读或写方式打开 过），只要打开过设备文件，相应的方式标志就会加一。

if (cold) {
   audio_rate = AUDIO_RATE_DEFAULT;
   audio_channels = AUDIO_CHANNELS_DEFAULT;
   audio_fragsize = AUDIO_FRAGSIZE_DEFAULT;
   audio_nbfrags = AUDIO_NBFRAGS_DEFAULT;

    在audio_rd_refcount 和audio_wr_refcount 这两个变量都为0 的时候才进入这一步，即对已经打开过的设备文件不进行下面的操作。
    这里先设置一下待会儿要配置到IIS 相关寄存器中的变量。

   if ((file->f_mode & FMODE_WRITE)){
     init_s3c2410_iis_bus_tx();
     audio_clear_buf(&output_stream);
   }
   if ((file->f_mode & FMODE_READ)){
     init_s3c2410_iis_bus_rx();
     audio_clear_buf(&input_stream);
   }
}

    从file->f_mode 中判断文件是否可读可写，根据设备文件的打开模式，分别调用了init_s3c2410_iis_bus_tx 和init_s3c2410_iis_bus_rx 函数来进行对IIS 总线读写的初始化配置，在这两个函数中对S3C2410 芯片的IIS 相关寄存器进行了相应的配置，会在后面说明。然后又调用了audio_clear_buf 函数来分别对音频输入和输出两个DMA 缓冲区进行了清空，该函数也会在后面说明。
    因为读写操作控制必须用f_mode 来进行判断，所以这里要根据f_mode 为可读或可写的标识来进行读写模式的硬件设置。而read，write 函数不需要检查f_mode 因为读写权限的检查是由内核在调用他们之前进行的。  

MOD_INC_USE_COUNT;

    最后调用MOD_INC_USE_COUNT; 来对设备文件计数器加一计数，并返回。

------------------------------------------------------------------------
    下面马上来看一下init_s3c2410_iis_bus_tx 和init_s3c2410_iis_bus_rx 这两个函数，首先是init_s3c2410_iis_bus_tx 函数：
static void init_s3c2410_iis_bus_tx(void)

        IISCON = 0;
        IISMOD = 0;
        IISFIFOC = 0;

    首先初始化IIS 控制寄存器，IIS 模式寄存器和IIS FIFO 控制寄存器都为0。

    /* 44 KHz , 384fs */
IISPSR = (IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100))
   | IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100)));

    设置IIS 预分频寄存器，其中调用了iispsr_value 函数来计算预分频值，该函数会在后面说明。
    参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100)) = IISPSR_A(iispsr_value(384, 44100)) = (一个0～31 之间的值)<<5 预分频控制器A，用于内部时钟块
IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100))) = (一个0～31 之间的值)<<0 预分频控制器B，用于外部时钟块.

IISCON = (IISCON_TX_DMA   /* Transmit DMA service request */
|IISCON_RX_IDLE   /* Receive Channel idle */
   |IISCON_PRESCALE); /* IIS Prescaler Enable */ 设置IIS 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISCON_TX_DMA = 1<<5 发送DMA 服务请求使能选择，设为1 表示使能发送DMA 服务请求
IISCON_RX_IDLE = 1<<2 接收通道空闲命令，设为1 表示接收通道空闲
IISCON_PRESCALE = 1<<1 IIS 预分频器使能选择，设为1 表示使能IIS 预分频器
   IISMOD = (IISMOD_SEL_MA       /* Master mode */
| IISMOD_SEL_TX       /* Transmit */
   | IISMOD_CH_RIGHT    /* Low for left channel */
   | IISMOD_FMT_MSB        /* MSB-justified format */
   | IISMOD_BIT_16       /* Serial data bit/channel is 16 bit */
   | IISMOD_FREQ_384    /* Master clock freq = 384 fs */
   | IISMOD_SFREQ_32);     /* 32 fs */
设置IIS 模式寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISMOD_SEL_MA = 0<<8 主从模式选择，设为0 表示选择主设备模式，则IISLRCK 和IISCLK 引脚为输出模式
IISMOD_SEL_TX = 2<<6 发送接收模式选择，设为2 表示选择发送模式
IISMOD_CH_RIGHT = 0<<5 左右通道激活等级，设为0 表示左通道为低，右通道为高
IISMOD_FMT_MSB = 1<<4 串行接口格式，设为1 表示以最高位有效位MSB 为参考格式（即左对齐数据帧格式）
IISMOD_BIT_16 = 1<<3 每个通道串行数据位数，设为1 表示每个通道16位数据
IISMOD_FREQ_384 = 1<<2 主设备时钟频率选择，设为1 表示384fs（fs 为采样频率）
IISMOD_SFREQ_32 = 1<<0 串行位时钟频率选择，设为1 表示32fs
IISFIFOC = (IISFCON_TX_DMA    /* Transmit FIFO access mode: DMA */
   | IISFCON_TX_EN);    /* Transmit FIFO enable */
设置IIS FIFO 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISFCON_TX_DMA = 1<<15 发送FIFO 存取模式选择，设为1 表示为DMA 模式
IISFCON_TX_EN = 1<<13 发送FIFO 使能选择，设为1 表示使能发送FIFO
IISCON |= IISCON_EN;   /* IIS enable(start) */
再次设置IIS 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISCON_EN = 1<<0 IIS 接口使能选择，设为1 表示使能IIS 接口

------------------------------------------------------------------------
计算预分频值函数：
static int iispsr_value(int s_bit_clock, int sample_rate)
   tmpval384 = s3c2410_get_bus_clk(GET_PCLK) / s_bit_clock;
S3C2410 主频202M，它的APH 总线频率是202/4=50M，在经过IIS 的PSR（分频比例因子）得到的一个频率用于IIS 时钟输出也可以说是同步。
首先通过调用s3c2410_get_bus_clk 函数来获得总线时钟，然后除以传入的频率参数，这里相当于：
APH/384 = N*fs
这里表示总线时钟进行384 分频后的值。
其中s3c2410_get_bus_clk 及相关函数在/kernel/arch/arm/mach-s3c2410/cpu.c 文件和/kernel/include/asm-arm/arch-s3c2410/cpu_s3c2410.h 文件中，这里不再展开说明。

       for (i = 0; i < 32; i++) {
            tmpval = tmpval384/(i+1);
            if (PCM_ABS((sample_rate - tmpval)) < tmpval384min) {
                     tmpval384min = PCM_ABS((sample_rate - tmpval));
                     prescaler = i;
            }
       }
配置预分频控制器A 的值的范围是0～31，所以这里i 也从0～31。后面的算法就不太清楚了，最后算出系统输出时钟为384fs 和音频采样频率fs为44.1KHz 的情况下，所需要的预分频值，并返回。

------------------------------------------------------------------------
接下来init_s3c2410_iis_bus_rx 函数与前面的init_s3c2410_iis_bus_tx 函数形式上也差不多：
static void init_s3c2410_iis_bus_rx(void)
IISCON = 0;
       IISMOD = 0;
       IISFIFOC = 0;
首先初始化IIS 控制寄存器，IIS 模式寄存器和IIS FIFO 控制寄存器都为0。
       /* 44 KHz , 384fs */
       IISPSR = (IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100))
            | IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100)));
设置IIS 预分频寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100)) = IISPSR_A(iispsr_value(384, 44100)) = (一个0～31 之间的值)<<5 预分频控制器A，用于内部时钟块
IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100))) = (一个0～31 之间的值)<<0 预分频控制器B，用于外部时钟块
       IISCON = (IISCON_RX_DMA       /* Transmit DMA service request */
            |IISCON_TX_IDLE       /* Receive Channel idle */
            |IISCON_PRESCALE);    /* IIS Prescaler Enable */
设置IIS 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISCON_RX_DMA = 1<<4 接收DMA 服务请求使能选择，设为1 表示使能接收DMA 服务请求
IISCON_TX_IDLE = 1<<3 发送通道空闲命令，设为1 表示发送通道空闲
IISCON_PRESCALE = 1<<1 IIS 预分频器使能选择，设为1 表示使能IIS 预分频器
       IISMOD = (IISMOD_SEL_MA       /* Master mode */
            | IISMOD_SEL_RX       /* Transmit */
            | IISMOD_CH_RIGHT    /* Low for left channel */
            | IISMOD_FMT_MSB        /* MSB-justified format */
            | IISMOD_BIT_16       /* Serial data bit/channel is 16 bit */
            | IISMOD_FREQ_384    /* Master clock freq = 384 fs */
            | IISMOD_SFREQ_32);     /* 32 fs */
设置IIS 模式寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISMOD_SEL_MA = 0<<8 主从模式选择，设为0 表示选择主设备模式，则IISLRCK 和IISCLK 引脚为输出模式
IISMOD_SEL_RX = 1<<6 发送接收模式选择，设为1 表示选择接收模式
IISMOD_CH_RIGHT = 0<<5 左右通道激活等级，设为0 表示左通道为低，右通道为高
IISMOD_FMT_MSB = 1<<4 串行接口格式，设为1 表示以最高位有效位MSB 为参考格式（即左对齐数据帧格式）
IISMOD_BIT_16 = 1<<3 每个通道串行数据位数，设为1 表示每个通道16位数据
IISMOD_FREQ_384 = 1<<2 主设备时钟频率选择，设为1 表示384fs（fs 为采样频率）
IISMOD_SFREQ_32 = 1<<0 串行位时钟频率选择，设为1 表示32fs
       IISFIFOC = (IISFCON_RX_DMA    /* Transmit FIFO access mode: DMA */
            | IISFCON_RX_EN);    /* Transmit FIFO enable */
设置IIS FIFO 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISFCON_RX_DMA = 1<<14 接收FIFO 存取模式选择，设为1 表示为DMA 模式
IISFCON_RX_EN = 1<<12 接收FIFO 使能选择，设为1 表示使能接收FIFO
       IISCON |= IISCON_EN;          /* IIS enable(start) */
再次设置IIS 控制寄存器，参考S3C2410 芯片datasheet 中关于IIS 总线接口的章节，具体设置参数如下：
IISCON_EN = 1<<0 IIS 接口使能选择，设为1 表示使能IIS 接口

以上两个对S3C2410 芯片的IIS 相关寄存器进行配置的函数只是分别针对收发模式配置了相应的收发功能，其他配置方面都一样。

------------------------------------------------------------------------
再来看一下audio_clear_buf 这个函数，该函数的主要任务就是对DMA 缓冲区进行清空：
static void audio_clear_buf(audio_stream_t * s)
s3c2410_dma_flush_all(s->dma_ch);
调用该函数来刷新所指定的DMA 通道缓冲区。
在/kernel/arch/arm/mach-s3c2410/dma.c 文件中：
int s3c2410_dma_flush_all(dmach_t channel)
这个函数会释放所指定的DMA 通道对应的内存缓冲区。
if (s->buffers) {
   int frag;
   for (frag = 0; frag < s->nbfrags; frag++) {
if (!s->buffers[frag].master)
continue;
consistent_free(s->buffers[frag].start,
    s->buffers[frag].master,
    s->buffers[frag].dma_addr);
   }
   kfree(s->buffers);
   s->buffers = NULL;
}
接下来判断，如果环形缓冲区不为空，通过调用consistent_free 函数来释放环形缓冲区中的s->nbfrags 个buffer 所分配的内存空间，其中s->buffers[frag].master 表示buffer 所分配的内存大小。最后调用kfree 函数，将整个s->buffers 指针所指的已分配的内存释放掉，并将它设为空指针。
在/kernel/arch/arm/mm/consistent.c 文件中：
/*
* free a page as defined by the above mapping.   We expressly forbid
* calling this from interrupt context.
*/
void consistent_free(void *vaddr, size_t size, dma_addr_t handle)
该函数的参数vaddr 为指向内存虚拟地址起始地址的指针，size 为要释放的内存大小，handle 为所分配的内存物理地址的起始地址。
s->buf_idx = 0;
s->buf = NULL;
最后将环形缓冲区buffer 索引号和当前buf 指针都清空，返回。

------------------------------------------------------------------------
下面来看一下，DMA 写入和读取的两个回调函数audio_dmaout_done_callback，audio_dmain_done_callback，当DMA 写入或读取完成就会产生中断，并调用这两个中断处理函数。在分析这两个函数之前，需要重新了解一下这两个函数被调用的过程以及传入参数的意义。
从前面对申请DMA 通道函数的分析中，可以知道DMA 写入和读取的中断处理函数是在s3c2410_dma_done 函数中被调用的，而s3c2410_dma_done 函数又是在真正的DMA 中断处理函数dma_irq_handler 中被调用的。

在/kernel/arch/arm/mach-s3c2410/dma.c 文件中：
static void dma_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
{
s3c2410_dma_t *dma = (s3c2410_dma_t *)dev_id;
DPRINTK(__FUNCTION__"\n");
s3c2410_dma_done(dma);
}
在该函数中，首先定义了一个s3c2410_dma_t 结构的指针变量指向中断处理程序的参数dev_id，然后将它再作为参数传入s3c2410_dma_done 函数中。
接着在s3c2410_dma_done 函数中做如下操作：
static inline void s3c2410_dma_done(s3c2410_dma_t *dma)
{
dma_buf_t *buf = dma->curr;
dma_callback_t callback;
if (buf->write) callback = dma->write.callback;
else callback = dma->read.callback;
#ifdef HOOK_LOST_INT
stop_dma_timer();
#endif
DPRINTK("IRQ: b=%#x st=%ld\n", (int)buf->id, (long)dma->regs->DSTAT);
if (callback)
   callback(buf->id, buf->size);
kfree(buf);
dma->active = 0;
process_dma(dma);
}
在该函数中又定义了一个dma_buf_t 结构的指针变量，指向了参数中的dma->curr，即指向当前DMA 缓冲区的指针。
在/kernel/arch/arm/mach-s3c2410/dma.h 文件中：
/* DMA buffer struct */
typedef struct dma_buf_s {
int size;   /* buffer size */
dma_addr_t dma_start; /* starting DMA address */
int ref;   /* number of DMA references */
void *id;   /* to identify buffer from outside */
int write;   /* 1: buf to write , 0: but to read   */
struct dma_buf_s *next; /* next buf to process */
} dma_buf_t;
/* DMA channel structure */
typedef struct {
dmach_t channel;
unsigned int in_use; /* Device is allocated */
const char *device_id; /* Device name */
dma_buf_t *head; /* where to insert buffers */
dma_buf_t *tail; /* where to remove buffers */
dma_buf_t *curr; /* buffer currently DMA'ed */
unsigned long queue_count; /* number of buffers in the queue */
int active;   /* 1 if DMA is actually processing data */
dma_regs_t *regs; /* points to appropriate DMA registers */
int irq;   /* IRQ used by the channel */
dma_device_t write; /* to write */
dma_device_t read; /* to read */
} s3c2410_dma_t;

然后根据buf->write 这个DMA 读写标志来对callback 函数指针进行设置，是指向写DMA 函数dma->write.callback，还是读DMA 函数dma->read.callback。最后在调用该函数指针所指的函数时将buf->id，buf->size 这两个值作为参数传入，即是原来定义在dma_irq_handler 函数中的dma 变量的dma->curr->id 和dma->curr->size，分别表示当前DMA 缓冲区的id 号和缓冲区大小。

现在可以先来看一下DMA 写入中断处理函数audio_dmaout_done_callback：
static void audio_dmaout_done_callback(void *buf_id, int size)
audio_buf_t *b = (audio_buf_t *) buf_id;
在该函数中首先就定义了一个audio_buf_t 结构的指针变量，并指向传入的参数。
up(&b->sem);
up 函数在这里表示释放信号量，关于该函数和另一个down 函数的具体细节会在后面说明。
wake_up(&b->sem.wait);
最后调用wake_up 函数来唤醒所有在等待该信号量的进程。对于该函数的说明可以参考一篇《关于linux内核中等待队列的问题》的文档。
在/kernel/include/linux/sched.h 文件中：
#define wake_up(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
该宏函数定义为__wake_up 函数，参数TASK_INTERRUPTIBLE 为1，TASK_UNINTERRUPTIBLE 为2，两者相或，表示将wait_queue list 中 process->state 是TASK_INTERRUPTIBLE 或TASK_UNINTERRUPTIBLE 的所有进程叫醒。
在/kernel/kernel/sched.c 文件中：
void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr)
{
if (q) {
   unsigned long flags;
   wq_read_lock_irqsave(&q->lock, flags);
   __wake_up_common(q, mode, nr, 0);
   wq_read_unlock_irqrestore(&q->lock, flags);
}
}
宏函数wq_read_lock_irqsave 的作用主要就是保存IRQ 和FIQ 的中断使能状态，并禁止IRQ 中断；而宏函数wq_read_unlock_irqrestore 的作用就是恢复IRQ 和FIQ 的中断使能状态。现在可以得知__wake_up 这个函数的作用，它首先保存IRQ 和FIQ 的中断使能状态，并禁止IRQ 中断，接着调用__wake_up_common 函数来唤醒等待q 队列的进程，最后再恢复IRQ 和FIQ 的中断使能状态。

down()操作可以理解为申请资源，up()操作可以理解为释放资源，因此，信号量实际表示的是资源的数量以及是否有进程正在等待。
在/kernel/include/asm-arm/semaphore.h 文件中：
struct semaphore {
    atomic_t count;int sleepers;wait_queue_head_t wait;#if WAITQUEUE_DEBUGlong __magic;#endif};
在semaphore 结构中，count 相当于资源计数，为正数或0 时表示可用资源数，-1 则表示没有空闲资源且有等待进程。而等待进程的数量并不关心。这种设计主要是考虑与信号量的原语相一致，当某个进程执行up 函数释放资源，点亮信号灯时，如果count 恢复到0，则表示尚有进程在等待该资源，因此执行唤醒操作。
   一个典型的down()-up()流程是这样的：down()-->count做原子减1操作，如果结果不小于0则表示成功申请，从down()中返回； 　
　　-->如果结果为负（实际上只可能是-1），则表示需要等待，则调用__down_fail()； 　
　　__down_fail()调用__down()，__down()用C代码实现，要求已不如down()和__down_fail()严格，在此作实际的等待。
在/kernel/include/asm-arm/semaphore.h 文件中：/** Note! This is subtle. We jump to wake people up only if* the semaphore was negative (== somebody was waiting on it).* The default case (no contention) will result in NO* jumps for both down() and up().*/static inline void up(struct semaphore * sem){#if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);#endif__up_op(sem, __up_wakeup);}在/kernel/include/asm-arm/proc-armo/locks.h 文件中：#define __up_op(ptr,wake) \({     \__asm__ __volatile__ ( \"@ up_op\n" \" mov ip, pc\n" \" orr lr, ip, #0x08000000\n"   \" teqp lr, #0\n" \" ldr lr, [%0]\n" \" and ip, ip, #0x0c000003\n"   \" adds lr, lr, #1\n" \" str lr, [%0]\n" \" orrle ip, ip, #0x80000000 @ set N - should this be mi ??? DAG ! \n" \" teqp ip, #0\n" \" movmi ip, %0\n" \" blmi " SYMBOL_NAME_STR(wake)   \:     \: "r" (ptr) \: "ip", "lr", "cc"); \})用ARM 汇编指令完成对信号量加一计数后，调用了wake 为标号的子程序，即传入的参数__up_wakeup 标号所在的子程序。在/kernel/arch/arm/kernel/semaphore.c 文件中：__up_wakeup:     \n\stmfd sp!, {r0 - r3, lr}   \n\mov r0, ip \n\bl __up \n\ldmfd sp!, {r0 - r3, pc}^   \n\这里又调用了__up 函数。void __up(struct semaphore *sem){wake_up(&sem->wait);}最后在该函数中调用了wake_up 函数来唤醒所有等待信号量的进程，wake_up 函数在上面已经有过说明。 如果这样的话，就有一个问题，在上面的audio_dmaout_done_callback 函数中，先后调用了这两个函数：up(&b->sem);wake_up(&b->sem.wait);其实在up 函数中也调用了wake_up 函数，这样不是重复调用了wake_up 函数嘛，不知道为什么。

再来看一下DMA 读取中断处理函数audio_dmain_done_callback：
   static void audio_dmain_done_callback(void *buf_id, int size)
       audio_buf_t *b = (audio_buf_t *) buf_id;
    在该函数中首先就定义了一个audio_buf_t 结构的指针变量，并指向传入的参数。
      b->size = size; 将b->size 赋值为传入的参数，即当前缓冲区的大小。
     up(&b->sem);
     wake_up(&b->sem.wait); 这两步和DMA 写入中断处理函数一样，调用up 函数释放信号量，然后再调用wake_up 函数来唤醒所有在等待该信号量的进程。

继续来看一下释放设备函数smdk2410_audio_release：
         static int smdk2410_audio_release(struct inode *inode, struct file *file)if (file->f_mode & FMODE_READ)
         {  
          if (audio_rd_refcount == 1)
               audio_clear_buf(&input_stream);
             audio_rd_refcount = 0;
         }
        该函数中，首先根据file->f_mode 判断文件是否可读，若为读取模式，则继续根据变量audio_rd_refcount 来判断，若已经用读取模式打开过该设备文件，则调用audio_clear_buf 函数来清空输入音频DMA 缓冲区，接着把audio_rd_refcount 这个读占位标志清零。
        if(file->f_mode & FMODE_WRITE)
         {   
            if (audio_wr_refcount == 1)
             {        audio_sync(file);     
                    audio_clear_buf(&output_stream);
                    audio_wr_refcount = 0;
             }
         }
     接着再根据file->f_mode 判断文件是否可写，若为写入模式，则继续根据变量audio_wr_refcount 来判断，若已经用写入模式打开过该设备文件，则先调用audio_sync 函数来保存内存数据到flash，该函数会在后面说明。然后再调用audio_clear_buf 函数来清空输出音频DMA 缓冲区，接着把audio_wr_refcount 这个写占位标志清零。MOD_DEC_USE_COUNT; 最后调用MOD_DEC_USE_COUNT; 来对设备文件计数器减一计数，并返回。

    下面来仔细分析一下写设备文件函数smdk2410_audio_write，在该函数中创建了DMA 缓冲区，并对DMA 缓冲区进行了写入的操作，函数原型如下：
      static ssize_t smdk2410_audio_write(struct file *file, const char *buffer,size_t count, loff_t * ppos)
              audio_stream_t *s = &output_stream;
                该函数首先又定义了一个audio_stream_t 结构的指针变量指向输出音频缓冲区。
                 switch (file->f_flags & O_ACCMODE)
                 { case O_WRONLY:
                   case O_RDWR:
                     break; default:    
                  return -EPERM;
                 }
           然后根据file->f_flags 这个表示设备文件的打开方式是读取，写入，还是可读写的标志进行判断，若为写入或可读写则继续执行，否则就会返回退出。
               if (!s->buffers && audio_setup_buf(s))
                    return -ENOMEM;
             这里通过s->buffers 指针是否为空来判断有没有创建过DMA 缓冲区。若s->buffers 指针不为空，则表示已经创建过DMA 缓冲区，那么就不会执行audio_setup_buf 函数了；若s->buffers 指针为空，则就会执行audio_setup_buf 函数来创建DMA 缓冲区，创建成功的话就会返回0，这样就会继续执行下面的代码。该函数会在后面说明。

              count &= ~0x03; 由于DMA 数据必须4字节对齐传输，即每次传输4个字节，因此驱动程序需要保证每次写入的数据都是4的倍数。这样屏蔽掉所要写入字节数的最后2位就是4的倍数了。
               while (count > 0)
             {     若要写入的字节数大于0，则进入一个while 大循环。
                 audio_buf_t *b = s->buf; 在大循环一开始就定义了一个audio_buf_t 结构的指针变量指向前面定义的输出音频缓冲区里的当前缓冲区指针。
                 if (file->f_flags & O_NONBLOCK)
                {
                   ret = -EAGAIN;
                   if (down_trylock(&b->sem))
                      break;
                } else
               {
                  ret = -ERESTARTSYS;
                  if (down_interruptible(&b->sem))
                     break;
              }
-------------------------------------------------------------------------------------------------------------------------------
      然后根据file->f_flags 与上O_NONBLOCK 值来进行判断。O_NONBLOCK 值表示采用非阻塞的文件IO方法，如果O_NONBLOCK 标记被设置，文件描述符将不被阻塞而被直接返回替代。一个例子是打开tty。如果用户不在终端调用里输入任何东西，read 将被阻塞，直到用户有输入，当O_NONBLOCK 标记被设置，read 调用将直接返回设置到EAGAIN 的值。 这里若应用程序在调用write 函数时加入了O_NONBLOCK 参数，则会调用down_trylock 函数来试着获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，表示不能获得信号量sem，返回值为非0值。该函数与相关函数在一篇 《Linux内核的同步机制》中有详细说明。
在/kernel/include/asm-arm/semaphore.h 文件中：
         static inline int down_trylock(struct semaphore *sem)
          {
             #if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);
              #endif
             return __down_op_ret(sem, __down_trylock_failed);
        }
   在/kernel/include/asm-arm/proc-armo/locks.h 文件中：
        #define __down_op_ret(ptr,fail) \
         ({\
            unsigned int result; \
              __asm__ __volatile__ ( \
            " @ down_op_ret\n" \
            " mov ip, pc\n" \
            " orr lr, ip, #0x08000000\n"   \
            " teqp lr, #0\n" \
            " ldr lr, [%1]\n" \
            " and ip, ip, #0x0c000003\n"   \
            " subs lr, lr, #1\n" \
            " str lr, [%1]\n" \
            " orrmi ip, ip, #0x80000000 @ set N\n" \
            " teqp ip, #0\n" \
            " movmi ip, %1\n" \
            " movpl ip, #0\n" \
            " blmi " SYMBOL_NAME_STR(fail) "\n" \
            " mov %0, ip" \
            : "=&r" (result) \
            : "r" (ptr) \
            : "ip", "lr", "cc"); \
            result;     \
         })用ARM 汇编指令完成对信号量减一计数后，调用了fail 为标号的子程序，即传入的参数__down_trylock_failed 标号所在的子程序。       在/kernel/arch/arm/kernel/semaphore.c 文件中：
             __down_trylock_failed: \n\
             stmfd sp!, {r0 - r3, lr}   \n\
             mov r0, ip \n\
             bl __down_trylock \n\
             mov ip, r0 \n\
             ldmfd sp!, {r0 - r3, pc}^   \n\这里又调用了__down_trylock 函数。
/** Trylock failed - make sure we correct for* having decremented the count.** We could have done the trylock with a* single "cmpxchg" 我without failure cases,* but then it wouldn't work on a 386.*/
     int __down_trylock(struct semaphore * sem)
     {
          int sleepers;
          unsigned long flags;
         spin_lock_irqsave(&semaphore_lock, flags);
         sleepers = sem->sleepers + 1;
         sem->sleepers = 0; /*   * Add "everybody else" and us into it. They aren't   * playing, because we own the spinlock.   */
        if (!atomic_add_negative(sleepers, &sem->count))  
           wake_up(&sem->wait);
           spin_unlock_irqrestore(&semaphore_lock, flags);
           return 1;
     }这里不再进一步深入说明。 若应用程序在调用write 函数时没有加入了O_NONBLOCK 参数，即表示采用阻塞的文件IO方式，则会调用down_interruptible 函数来获得信号量sem。该函数将把sem 的值减1，如果信号量sem 的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。
    down_interruptible 函数能被信号打断，因此该函数有返回值来区分是正常返回还是被信号中断，如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。该函数 与相关函数在一篇《Linux内核的同步机制》中有详细说明。
       在/kernel/include/asm-arm/semaphore.h 文件中：
       /** This is ugly, but we want the default case to fall through.* "__down_interruptible" is the actual routine that waits...*/
     static inline int down_interruptible (struct semaphore * sem)
       {
            #if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);
            #endif
            return __down_op_ret(sem, __down_interruptible_failed);
      }
      函数__down_op_ret 在上面已经有过说明。
    在/kernel/arch/arm/kernel/semaphore.c 文件中：
      __down_interruptible_failed: \n\
        stmfd sp!, {r0 - r3, lr}   \n\
        mov r0, ip \n\
        bl __down_interruptible   \n\
        mov ip, r0 \n\
        ldmfd sp!, {r0 - r3, pc}^   \n\
         这里又调用了__down_interruptible 函数。
        int __down_interruptible(struct semaphore * sem)这里不再进一步深入说明。  
-------------------------------------------------------------------------------------------------------------------------------

     if (audio_channels == 2)
      {
            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;
     }
    下面继续对音频通道数量进行判断，如果音频通道数为先前打开设备文件时设的2通道，则进入执行
    对于“chunksize = s->fragsize - b->size”这一句一开始一直不太理解，不知道为什么要将音频缓冲区片大小减去DMA 缓冲区大小作为写入的数据长度，这两个量的大小是一样的，这样一减不是变为0 了吗？现在觉得其实b->size 只是一个缓冲区地址的偏移量，一开始这个偏移量应该为0，这样就不难理解用s->fragsize 作为写入的数据长度。 接下去判断，如果所要写入的数据长度count 小于chunksize 值，那就以count 为准备写入数据的长度。在count 大于chunksize 的情况下，写入的数据长度以一个s->fragsize 大小为单位。 然后调用了copy_from_user 函数将用户空间buffer 里的数据复制到内核空间起始地址为b->start + b->size 的内存中，复制数据长度为chunksize。
     这里b->start 为指向环形缓冲区中第0个缓冲区地址的内存起始地址（虚拟地址），用这个起始地址加上缓冲区地址的偏移量（0）还是指向第0个缓冲区地址（共8个）的起始 地址（虚拟地址）。 若copy_from_user 函数执行成功，则返回0，继续执行将缓冲区地址的偏移量b->size 加上已写入的数据长度chunksize。若copy_from_user 函数执行失败，就调用up 函数释放信号量，并退出写设备文件函数。
        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;  
}
如果音频通道数不等于先前打开设备文件时设的2通道，则进入执行。这里暂时先不进行分析，以后再来分析。

    buffer += chunksize;
    count -= chunksize;
当把一组音频缓冲区片大小的数据写入内存后，用户层的buffer 指针加上已写入数据的长度，即指向了下一组将要写入的数据。所要写入的数据长度count 减去已写入数据的长度，为还要写入数据的长度。

/*
    只有将当前缓冲区写满才会将其加入dma队列，否则，释放刚刚获取的信号量，下次继续对其后面空的部分填充
*/

if (b->size < s->fragsize)
   {
     up(&b->sem);
     break;  
}

   s3c2410_dma_queue_buffer(s->dma_ch, (void *) b, b->dma_addr, b->size, DMA_BUF_WR);
该函数完成了管理DMA 缓冲区的相关数据结构s3c2410_dma_t 和dma_buf_t 进行了设置，并对S3C2410 芯片的DMA 控制器部分的相关寄存器进行了相应配置。传入的参数为DMA 通道号，一个空指针，DMA 缓冲区的物理起始地址，DMA 缓冲区大小，DMA 缓冲区工作模式，这里工作模式为写DMA 缓冲区。 该函数原型在/kernel/arch/arm/mach-s3c2410/dma.c 文件中，会在后面专门进行分析。

    b->size = 0;
    NEXT_BUF(s, buf);
}

在while 大循环最后将缓冲区地址的偏移量b->size 清零，然后调用宏函数NEXT_BUF 来将当前缓冲区的指针指向环形缓冲区中下一个缓冲区地址处。所以在对DMA 缓冲区进行填写的前后，缓冲区地址的偏移量b->size 都为0。 接着如果要写入的数据长度count 还大于0，则继续在该循环中执行。

#define NEXT_BUF(_s_,_b_) { \
       (_s_)->_b_##_idx++; \     
       (_s_)->_b_##_idx %= (_s_)->nbfrags; \  
       (_s_)->_b_ = (_s_)->buffers + (_s_)->_b_##_idx;
}

该宏函数相当与执行了一下语句：
     s->buf_idx++;
     s->buf_idx %= s->nbfrags;
     s->buf = s->buffers + s->buf_idx;

先将环形缓冲区索引号加一，并取模音频缓冲区片个数（8），这样就得到了绕环递增的环形缓冲区序号。最后将当前缓冲区的指针指向环形缓冲区起始地址加上新的索引号，即指向了环形缓冲区中的下一组缓冲区地址。
   if ((buffer - buffer0))
       ret = buffer - buffer0;

     return ret; 当count 长度的数据都写完后，就退出while 大循环。一开始定义了一个buffer0 的指针指向了buffer 的起始地址，在写数据的过程中，buffer 指针进行过向后移动，而buffer0 指针不变，buffer - buffer0 就得到了总共写入的数据长度，并将该长度值返回。

马上来看一下创建DMA 缓冲区的函数 audio_setup_buf：
     static int audio_setup_buf(audio_stream_t * s)
         if (s->buffers)
              return -EBUSY; 若环形缓冲区指针s->buffers 不为空的话，则立即返回。表示已经创建过DMA 缓冲区了，则不再重复创建。
        s->nbfrags = audio_nbfrags;
        s->fragsize = audio_fragsize;
    接着分别将音频缓冲区片数量和音频缓冲区片大小赋值给audio_stream_t 结构中相应的成员，s->nbfrags 音频缓冲区片数量为8，s->fragsize 音频缓冲区片大小为8192。
      s->buffers = (audio_buf_t *)kmalloc(sizeof(audio_buf_t) * s->nbfrags, GFP_KERNEL);
        调用kmalloc 函数来申请环形缓冲区所需要的内存空间，返回值为所分配内存空间的起始地址，且为物理地址。再将audio_stream_t 结构的环形缓冲区指针s->buffers 指向转换为audio_buf_t 结构指针的内存起始地址（物理地址）。这里申请的只是结构体所需要的空间容量，而不是DMA 缓冲区。
   if (!s->buffers)  
      goto err; 如果内存空间申请成功，则s->buffers 指针不为空，继续执行，否则直接跳到err 标号处执行。
    memset(s->buffers, 0, sizeof(audio_buf_t) * s->nbfrags); 调用memset 函数对刚才分配的那块内存空间进行清零操作。
    for (frag = 0; frag < s->nbfrags; frag++) 接着进入一个for 大循环，对连续的s->nbfrags 个音频缓冲区片进行操作。
   {
       audio_buf_t *b = &s->buffers[frag]; 首先又定义了一个audio_buf_t 结构的指针变量指向audio_stream_t 结构变量的各个缓冲区地址s->buffers[frag]，其中frag 从0～8，即8个缓冲区组成一个环形缓冲区。
      if (!dmasize)
      {
          dmasize = (s->nbfrags - frag) * s->fragsize; 接着进行判断，如果dmasize 为0，则继续执行。这里一开始就定义了dmasize 为0。一开始，先将dmasize 赋值为所需要的最大的缓冲区空间，即(8-0)*8192。
         do {
              dmabuf = consistent_alloc(GFP_KERNEL|GFP_DMA, dmasize, &dmaphys);
              if (!dmabuf)  
                dmasize -= s->fragsize;
         } while (!dmabuf && dmasize); 下面又进入一个do while 循环，调用consistent_alloc 函数来进行内存分配，该函数在《LCD驱动程序分析》一文中有过详细分析。通过调用该函数来分配先前dmasize 大小的内存空间（所需要的最大的缓冲区空间）。返回两个值，一个是dmabuf，为所分配内存空间的起始地址，为虚拟地址；另一个是dmaphys，也为 所分配内存空间的起始地址，为物理地址。 如果返回的dmabuf 值为0，则表示内存没有申请成功，那么要分配的内存空间dmasize 就需要进行减少，减去一个缓冲区片大小，再调用consistent_alloc 函数进行内存分配，知道分配成功或dmasize 为0 才退出循环。
       if (!dmabuf)
          goto err; 如果最后dmabuf 值还为0，则表示内存没有申请成功，直接跳到err 标号处执行。
         b->master = dmasize;  
    } 接着把所分配的内存大小赋值给b->master 表示内存大小的结构参数。

     b->start = dmabuf;
     b->dma_addr = dmaphys; 将所分配的内存空间起始地址的虚拟地址赋值给b->start 这个虚拟地址指针，物理地址赋值给b->dma_addr 这个DMA 缓冲区地址。         sema_init(&b->sem, 1); 调用sema_init 函数来初始化一个信号量，将信号量的初值设置为1。
在/kernel/include/asm-arm/semaphore.h 文件中：
      static inline void sema_init(struct semaphore *sem, int val)关于该函数和相关函数的说明可以参考一篇《Linux内核的同步机制》的文档。
     dmabuf += s->fragsize;
     dmaphys += s->fragsize;  
     dmasize -= s->fragsize;
} 在for 大循环的最后，将所分配内存起始地址的虚拟地址和物理地址都加上音频缓冲区片的大小，而总的缓冲区空间大小是减去音频缓冲区片的大小。前面两个参数都将作 为下一个缓冲区地址audio_buf_t 结构中的虚拟地址指针和DMA 缓冲区地址的参数。 如果dmasize 不为0 的话，在进入下一次循环时，就不会进入do while 循环进行内存空间的分配了。但是如果第一次没有分配到8 个音频缓冲区片大小的内存空间，比如只分配到4 个音频缓冲区片大小的内存空间，则进入第5 次循环时，dmasize 为0 了，那么就会再次进入do while 循环进行内存空间的分配，不过分配的为剩下的4 个音频缓冲区片大小的内存空间。这个函数巧妙的解决了万一一次分配不到连续的8 个音频缓冲区片大小的内存空间，就会按几次来分配较小的连续的内存空间了。
    其中b->master 参数只有第0个缓冲区地址有值，为总的缓冲区空间大小，其余缓冲区地址的b->master 都为0。
      s->buf_idx = 0;
      s->buf = &s->buffers[0];
      return 0; 将环形缓冲区索引号设为0，将当前缓冲区指针指向环形缓冲区的第0个缓冲区地址，然后返回0。
   err:audio_clear_buf(s);
         return -ENOMEM; 如果程序跳转到err 标号处，则执行audio_clear_buf 函数来清空输出音频DMA 缓冲区，然后返回出错信息.