本文详细解析了Linux环境下IIS音频驱动的工作原理，包括初始化、DMA通道配置、信号量管理以及中断处理等关键部分。
转自：http://wenku.baidu.com/view/7a1be2afdd3383c4bb4cd27e.html
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 bufferaddress */（内存物理地址起始地
址）
struct semaphore sem; /* down beforetouching the buffer */
int master; /* owner for buffer allocation,contain size whentrue */
（内存大小）
} audio_buf_t;
typedef struct {
audio_buf_t *buffers; /* pointer to audiobuffer structures */
audio_buf_t *buf; /* current buffer used byread/write */
u_int buf_idx; /* index for the pointerabove */
u_int fragsize; /* fragment i.e. buffersize */（音频缓冲区片大小）
u_int nbfrags; /* nbr of fragments */（音频缓冲区片数量）
dmach_t dma_ch; /* DMA channel (channel2for 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_operationssmdk2410_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_operationssmdk2410_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 __initaudio_init_dma(audio_stream_t * s, char *desc)
{
if(s->dma_ch == DMA_CH2)
returns3c2410_request_dma("I2SSDO", s->dma_ch,
audio_dmaout_done_callback, NULL);
else if(s->dma_ch == DMA_CH1)
returns3c2410_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_tread_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 voids3c2410_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 DSPdevice
* @fops: File operations for the driver
* @dev: Unit number to allocate
*
* Allocate a DSP device. Unit is the numberof the DSP requested.
* Pass -1 to request the next free DSPunit. On success the allocated
* number is returned, on failure a negativeerror code is returned.
*
* This function allocates both the audioand dsp device entriestogether
* and will always allocate them as amatching pair - eg dsp3/audio3
*/
int register_sound_dsp(structfile_operations *fops, int dev)
/**
* register_sound_mixer - register a mixerdevice
* @fops: File operations for the driver
* @dev: Unit number to allocate
*
* Allocate a mixer device. Unit is thenumber of the mixer requested.
* Pass -1 to request the next free mixerunit. On success the allocated
* number is returned, on failure a negativeerror 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'thave to worry about
* loss of precision.
*
* Use only for very small delays ( < 1msec). Should probably use a
* lookup table, really, as themultiplications take much too long with
* short delays. This is a"reasonable" implementation, though (and the
* first constant multiplications getsoptimized 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 DSPdevice
* @unit: unit number to allocate
*
* Release a sound device that was allocatedwith register_sound_dsp().
* The unit passed is the return value fromthe register function.
*
* Both of the allocated units are releasedtogether automatically.
*/
void unregister_sound_dsp(int unit)
/**
* unregister_sound_mixer - unregister amixer
* @unit: unit number to allocate
*
* Release a sound device that was allocatedwith register_sound_mixer().
* The unit passed is the return value fromthe 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 DMAservice 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/channelis 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 FIFOaccess 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 FIFOaccess 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 abovemapping. We expressly forbid
* calling this from interrupt context.
*/
void consistent_free(void *vaddr, size_tsize, 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 voids3c2410_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 DMAaddress */
int ref; /* number of DMA references */
void *id; /* to identify buffer fromoutside */
int write; /* 1: buf to write , 0: but toread */
struct dma_buf_s *next; /* next buf toprocess */
} 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 ofbuffers in the queue */
int active; /* 1 if DMA is actuallyprocessing data */
dma_regs_t *regs; /* points to appropriateDMA 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_queuelist 中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;intsleepers;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 issubtle.
We jump to wake people up only if* thesemaphore was negative (== somebody
was waiting on it).* The default case (nocontention) will result in NO*
jumps for both down() and up().*/staticinline void up(struct semaphore
* sem){#ifWAITQUEUE_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(structinode *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(structfile *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(structsemaphore *sem)
{
#ifWAITQUEUE_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 @ setN\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 correctfor* having decremented the
count.** We could have done the trylockwith a* single "cmpxchg" 我
without failure cases,* but then itwouldn'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 thespinlock. */
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 defaultcase to fall through.*
"__down_interruptible" is theactual routine that waits...*/
static inline int down_interruptible(struct semaphore * sem)
{
#ifWAITQUEUE_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 减
去已写入数据的长度，为还要写入数据的长度。
if (b->size < s->fragsize)
{
up(&b->sem);
break;
}
若缓冲区地址的偏移量 b->size 小于频缓冲区片大小，则调用 up 函数释放信号
量，并跳出 while 大循环。但是一般情况不会进入该条件语句执行。
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); 下面又进入一个 dowhile 循环，
调用 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(structsemaphore *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缓冲区，然后返回出错信息
扫一扫
4329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
