armlinux学习笔记--IIS音频驱动程序分析(1)
//*******************************************************
//* 2007.7.5
//*******************************************************
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,用于外部时钟块
armlinux学习笔记--IIS音频驱动程序分析(2)
//*******************************************************
//* 2007.7.9
//*******************************************************
IISCON = (IISCON_TX_DMA /* Transmit DMA service request */
|IISCON_RX_IDLE /* Receive Channel idle */
|IISCON_PRESCALE); /* IIS Prescaler Enable */
IISCON_TX_DMA = 1<<5 发送DMA 服务请求使能选择,设为1 表示使能发送DMA 服务请求
IISCON_RX_IDLE = 1<<2 接收通道空闲命令,设为1 表示接收通道空闲
IISCON_PRESCALE = 1<<1 IIS 预分频器使能选择,设为1 表示使能IIS 预分频器
| 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 */
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
| IISFCON_TX_EN); /* Transmit FIFO enable */
IISFCON_TX_DMA = 1<<15 发送FIFO 存取模式选择,设为1 表示为DMA 模式
IISFCON_TX_EN = 1<<13 发送FIFO 使能选择,设为1 表示使能发送FIFO
IISCON_EN = 1<<0 IIS 接口使能选择,设为1 表示使能IIS 接口
------------------------------------------------------------------------
计算预分频值函数:
static int iispsr_value(int s_bit_clock, int sample_rate)
首先通过调用s3c2410_get_bus_clk 函数来获得总线时钟,然后除以传入的频率参数,这里相当于:
APH/384 = N*fs
这里表示总线时钟进行384 分频后的值。
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;
}
}
------------------------------------------------------------------------
接下来init_s3c2410_iis_bus_rx 函数与前面的init_s3c2410_iis_bus_tx 函数形式上也差不多:
static void init_s3c2410_iis_bus_rx(void)
IISMOD = 0;
IISFIFOC = 0;
IISPSR = (IISPSR_A(iispsr_value(S_CLOCK_FREQ, 44100))
| IISPSR_B(iispsr_value(S_CLOCK_FREQ, 44100)));
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_TX_IDLE /* Receive Channel idle */
|IISCON_PRESCALE); /* IIS Prescaler Enable */
IISCON_RX_DMA = 1<<4 接收DMA 服务请求使能选择,设为1 表示使能接收DMA 服务请求
IISCON_TX_IDLE = 1<<3 发送通道空闲命令,设为1 表示发送通道空闲
IISCON_PRESCALE = 1<<1 IIS 预分频器使能选择,设为1 表示使能IIS 预分频器
| 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 */
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
| IISFCON_RX_EN); /* Transmit FIFO enable */
IISFCON_RX_DMA = 1<<14 接收FIFO 存取模式选择,设为1 表示为DMA 模式
IISFCON_RX_EN = 1<<12 接收FIFO 使能选择,设为1 表示使能接收FIFO
IISCON_EN = 1<<0 IIS 接口使能选择,设为1 表示使能IIS 接口
以上两个对S3C2410 芯片的IIS 相关寄存器进行配置的函数只是分别针对收发模式配置了相应的收发功能,其他配置方面都一样。
------------------------------------------------------------------------
再来看一下audio_clear_buf 这个函数,该函数的主要任务就是对DMA 缓冲区进行清空:
static void audio_clear_buf(audio_stream_t * s)
int s3c2410_dma_flush_all(dmach_t channel)
int 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;
}
/*
* 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)
s->buf = NULL;
------------------------------------------------------------------------
下面来看一下,DMA 写入和读取的两个回调函数audio_dmaout_done_callback,audio_dmain_done_callback,当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;
}
static inline void s3c2410_dma_done(s3c2410_dma_t *dma)
{
dma_buf_t *buf = dma->curr;
dma_callback_t callback;
else callback = dma->read.callback;
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 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;
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)
#define wake_up(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
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);
}
}
//*******************************************************
//* 2007.7.10
//*******************************************************
down()操作可以理解为申请资源,up()操作可以理解为释放资源,因此,信号量实际表示的是资源的数量以及是否有进程正在等待。
struct semaphore {
atomic_t count;
int sleepers;
wait_queue_head_t wait;
#if WAITQUEUE_DEBUG
long __magic;
#endif
};
一个典型的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_DEBUG
CHECK_MAGIC(sem->__magic);
#endif
}
#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"); /
})
__up_wakeup: /n/
stmfd sp!, {r0 - r3, lr} /n/
mov r0, ip /n/
bl __up /n/
ldmfd sp!, {r0 - r3, pc}^ /n/
{
wake_up(&sem->wait);
}
如果这样的话,就有一个问题,在上面的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)
wake_up(&b->sem.wait);
------------------------------------------------------------------------
继续来看一下释放设备函数smdk2410_audio_release:
static int smdk2410_audio_release(struct inode *inode, struct file *file)
if (audio_rd_refcount == 1)
audio_clear_buf(&input_stream);
audio_rd_refcount = 0;
}
if (audio_wr_refcount == 1) {
audio_sync(file);
audio_clear_buf(&output_stream);
audio_wr_refcount = 0;
}
}
------------------------------------------------------------------------
下面来仔细分析一下写设备文件函数smdk2410_audio_write,在该函数中创建了DMA 缓冲区,并对DMA 缓冲区进行了写入的操作,函数原型如下:
static ssize_t smdk2410_audio_write(struct file *file, const char *buffer,
size_t count, loff_t * ppos)
case O_WRONLY:
case O_RDWR:
break;
default:
return -EPERM;
}
return -ENOMEM;
ret = -EAGAIN;
if (down_trylock(&b->sem))
break;
} else {
ret = -ERESTARTSYS;
if (down_interruptible(&b->sem))
break;
}
这里若应用程序在调用write 函数时加入了O_NONBLOCK 参数,则会调用down_trylock 函数来试着获得信号量sem,如果能够立刻获得,它就获得该信号量并返回0,否则,表示不能获得信号量sem,返回值为非0值。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
static inline int down_trylock(struct semaphore *sem)
{
#if WAITQUEUE_DEBUG
CHECK_MAGIC(sem->__magic);
#endif
}
#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; /
})
__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/
* 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;
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);
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_DEBUG
CHECK_MAGIC(sem->__magic);
#endif
}
__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/
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;
}
//*******************************************************
//* 2007.7.11
//*******************************************************
对于“chunksize = s->fragsize - b->size”这一句一开始一直不太理解,不知道为什么要将音频缓冲区片大小减去DMA 缓冲区大小作为写入的数据长度,这两个量的大小是一样的,这样一减不是变为0 了吗?现在觉得其实b->size 只是一个缓冲区地址的偏移量,一开始这个偏移量应该为0,这样就不难理解用s->fragsize 作为写入的数据长度。
chunksize = (s->fragsize - b->size) >> 1;
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;
}
}
count -= chunksize;
up(&b->sem);
break;
}
s3c2410_dma_queue_buffer(s->dma_ch, (void *) b,
b->dma_addr, b->size, DMA_BUF_WR);
该函数原型在/kernel/arch/arm/mach-s3c2410/dma.c 文件中,会在后面专门进行分析。
NEXT_BUF(s, buf);
}
(_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;
ret = buffer - buffer0;
------------------------------------------------------------------------
马上来看一下创建DMA 缓冲区的函数audio_setup_buf:
static int audio_setup_buf(audio_stream_t * s)
return -EBUSY;
s->fragsize = audio_fragsize;
kmalloc(sizeof(audio_buf_t) * s->nbfrags, GFP_KERNEL);
调用kmalloc 函数来申请环形缓冲区所需要的内存空间,返回值为所分配内存空间的起始地址,且为物理地址。再将audio_stream_t 结构的环形缓冲区指针s->buffers 指向转换为audio_buf_t 结构指针的内存起始地址(物理地址)。这里申请的只是结构体所需要的空间容量,而不是DMA 缓冲区。
goto err;
audio_buf_t *b = &s->buffers[frag];
dmasize = (s->nbfrags - frag) * s->fragsize;
dmabuf = consistent_alloc(GFP_KERNEL|GFP_DMA,
dmasize, &dmaphys);
if (!dmabuf)
dmasize -= s->fragsize;
} while (!dmabuf && dmasize);
如果返回的dmabuf 值为0,则表示内存没有申请成功,那么要分配的内存空间dmasize 就需要进行减少,减去一个缓冲区片大小,再调用consistent_alloc 函数进行内存分配,知道分配成功或dmasize 为0 才退出循环。
goto err;
}
b->dma_addr = dmaphys;
static inline void sema_init(struct semaphore *sem, int val)
dmaphys += s->fragsize;
dmasize -= s->fragsize;
}
如果dmasize 不为0 的话,在进入下一次循环时,就不会进入do while 循环进行内存空间的分配了。但是如果第一次没有分配到8 个音频缓冲区片大小的内存空间,比如只分配到4 个音频缓冲区片大小的内存空间,则进入第5 次循环时,dmasize 为0 了,那么就会再次进入do while 循环进行内存空间的分配,不过分配的为剩下的4 个音频缓冲区片大小的内存空间。这个函数巧妙的解决了万一一次分配不到连续的8 个音频缓冲区片大小的内存空间,就会按几次来分配较小的连续的内存空间了。
其中b->master 参数只有第0个缓冲区地址有值,为总的缓冲区空间大小,其余缓冲区地址的b->master 都为0。
s->buf = &s->buffers[0];
audio_clear_buf(s);
return -ENOMEM;
------------------------------------------------------------------------
分析完了放音的写设备函数,再来看一下录音的读设备函数smdk2410_audio_read:
static ssize_t smdk2410_audio_read(struct file *file, char *buffer,
size_t count, loff_t * ppos)
return -ESPIPE;
int i;
if (audio_setup_buf(s))
return -ENOMEM;
for (i = 0; i < s->nbfrags; i++) {
audio_buf_t *b = s->buf;
down(&b->sem);
s3c2410_dma_queue_buffer(s->dma_ch, (void *) b,
b->dma_addr, s->fragsize, DMA_BUF_RD);
NEXT_BUF(s, buf);
}
}
如果先调用过写设备函数,那么在写设备函数中就已经创建了DMA 缓冲区,再来调用现在的读设备函数时,就不会再进入这里来执行了。
if (file->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
if (down_trylock(&b->sem))
break;
} else {
ret = -ERESTARTSYS;
if (down_interruptible(&b->sem))
break;
}
若没有加入了O_NONBLOCK 参数,即表示采用阻塞的文件IO方式,则会调用down_interruptible 函数来获得信号量sem。该函数将把sem 的值减1,如果信号量sem 的值非负,就直接返回,否则调用者将被挂起,直到别的任务释放该信号量才能继续运行。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
if (chunksize > count)
chunksize = count;
chunksize)) {
up(&b->sem);
return -EFAULT;
}
b->size -= chunksize;
count -= chunksize;
if (b->size > 0) {
up(&b->sem);
break;
}
s3c2410_dma_queue_buffer(s->dma_ch, (void *) b,
b->dma_addr, s->fragsize, DMA_BUF_RD);
}
ret = buffer - buffer0;
//*******************************************************
//* 2007.7.16
//*******************************************************
经过一个双修日的音频驱动调试,对S3C2410 的IIS 控制器和UDA1341 的频率配置有了进一步的了解,对控制放音的写设备文件函数smdk2410_audio_write 也有了更深的认识。下面就来总结一下相关的注意要点。
CDCLK 是由S3C2410 内部的APH 总线时钟首先经过一个IIS 的模式选择(256fs 或384fs),然后再经过一个IIS 的预分频器分频后得到。S3C2410 主频202M,它的APH 总线频率是202/4=50M,在选择IIS 的主时钟模式为384fs后,经过IIS 的PSR(分频比例因子)得到的由IPSR_A 分出的一个频率用于IIS 时钟输出也可以说是同步,另一个由IPSR_B 分出的频率CDCLK 则直接作为UDA1341 的系统时钟,即编解码时钟。
这里在分频前要进行IIS 的主时钟频率选择(这里选择了384fs)是因为在分频时会根据384 这个系数和采样频率fs 进行分频,最后将系数384 乘以fs 得到CDCLK 时钟输出频率。