//*******************************************************
//* 2009.8.23
//*******************************************************
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 的中断使能状态。
//*******************************************************
//* 2007.7.10
//*******************************************************
down()操作可以理解为申请资源，up()操作可以理解为释放资源，因此，信号量实际表示的是资源的数量以及是否有进程正在等待。
在/kernel/include/asm-arm/semaphore.h 文件中：
struct semaphore {
atomic_t count;
int sleepers;
wait_queue_head_t wait;
#if WAITQUEUE_DEBUG
long __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_DEBUG
CHECK_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_DEBUG
CHECK_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_DEBUG
CHECK_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通道，则进入执行。
//*******************************************************
//* 2007.7.11
//*******************************************************
对于“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);
下面又进入一个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 缓冲区，然后返回出错信息。
------------------------------------------------------------------------
分析完了放音的写设备函数，再来看一下录音的读设备函数smdk2410_audio_read：
static ssize_t smdk2410_audio_read(struct file *file, char *buffer,
size_t count, loff_t * ppos)
audio_stream_t *s = &input_stream;
该函数首先又定义了一个audio_stream_t 结构的指针变量指向输入音频缓冲区。
if (ppos != &file->f_pos)
return -ESPIPE;
然后判断如果表示文件当前位置的参数ppos 不等于该文件file 结构里的file->f_pos 文件位置，则返回退出。但实际上ppos 本来就是file->f_pos 的值，所以这一步一般不会出现。
if (!s->buffers) {
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);
}
}
若指向环形缓冲区的指针s->buffers 为空的话，则会进入执行。首先会调用audio_setup_buf 函数来创建DMA 缓冲区，创建成功则继续执行，否则返回错误并退出。接着进入一个for 循环，对连续s->nbfrags（8）个音频缓冲区片进行操作。重新定义了一个audio_buf_t 结构的指针指向输入音频缓冲区当前缓冲区，并调用down 函数来获取信号量，又调用了s3c2410_dma_queue_buffer 函数完成了管理DMA 缓冲区的相关数据结构s3c2410_dma_t 和dma_buf_t 进行了设置，并对S3C2410 芯片的DMA 控制器部分的相关寄存器进行了相应配置，不过这里工作模式为读DMA 缓冲区。最后调用NEXT_BUF 宏函数来将当前缓冲区的指针指向环形缓冲区中下一个缓冲区地址处。
如果先调用过写设备函数，那么在写设备函数中就已经创建了DMA 缓冲区，再来调用现在的读设备函数时，就不会再进入这里来执行了。
while (count > 0) {
若要读取的字节数大于0，则进入一个while 大循环。
audio_buf_t *b = s->buf;
在大循环一开始就定义了一个audio_buf_t 结构的指针变量指向前面定义的输入音频缓冲区里的当前缓冲区指针。
/* Wait for a buffer to become full */
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方法，则会调用down_trylock 函数来试着获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，表示不能获得信号量sem，返回值为非0值。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
若没有加入了O_NONBLOCK 参数，即表示采用阻塞的文件IO方式，则会调用down_interruptible 函数来获得信号量sem。该函数将把sem 的值减1，如果信号量sem 的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
chunksize = b->size;
if (chunksize > count)
chunksize = count;
将缓冲区地址的偏移量b->size 赋值给chunksize，这里b->size 一开始应该为一个DMA 缓冲区片大小，即一个s->fragsize 单位大小，若所要读取数据的长度count 小于chunksize 值，那就以count 为准备读取数据的长度。在count 大于chunksize 的情况下，读取的数据长度以一个s->fragsize 大小为单位。
if (copy_to_user(buffer, b->start + s->fragsize - b->size,
chunksize)) {
up(&b->sem);
return -EFAULT;
}
调用copy_to_user 函数将内存中的数据复制到用户层的buffer 中。这里b->start 为指向环形缓冲区中第0个缓冲区地址的内存起始地址（虚拟地址），加上s->fragsize - b->size（得0），即还是指向第0个缓冲区地址的内存起始地址（虚拟地址）。
b->size -= chunksize;
buffer += chunksize;
count -= chunksize;
当把一组音频缓冲区片大小的数据从内存读取出来后，将缓冲区地址的偏移量b->size 减去已读取数据的长度，即得0。用户层的buffer 指针加上已读取数据的长度，即指向了下一组将要读取的数据。所要写入的数据长度count 减去已读取数据的长度，为还要读取数据的长度。
if (b->size > 0) {
up(&b->sem);
break;
}
这时缓冲区地址的偏移量b->size 应该为0，如果还是大于0的话就会调用up 函数释放信号量，并跳出while 循环。所以在对DMA 缓冲区进行读取前，缓冲区地址的偏移量b->size 为一个DMA 缓冲区片大小，而读取后，缓冲区地址的偏移量b->size 则为0。
/* Make current buffer available for DMA again */
s3c2410_dma_queue_buffer(s->dma_ch, (void *) b,
b->dma_addr, s->fragsize, DMA_BUF_RD);
调用了s3c2410_dma_queue_buffer 函数完成了管理DMA 缓冲区的相关数据结构s3c2410_dma_t 和dma_buf_t 进行了设置，并对S3C2410 芯片的DMA 控制器部分的相关寄存器进行了相应配置，不过这里工作模式为读DMA 缓冲区。
NEXT_BUF(s, buf);
}
在while 大循环最后调用了NEXT_BUF 宏函数来将当前缓冲区的指针指向环形缓冲区中下一个缓冲区地址处。
if ((buffer - buffer0))
ret = buffer - buffer0;
return ret;
当count 长度的数据都读完后，就退出while 大循环。一开始定义了一个buffer0 的指针指向了buffer 的起始地址，在写数据的过程中，buffer 指针进行过向后移动，而buffer0 指针不变，buffer - buffer0 就得到了总共读取的数据长度，并将该长度值返回。
//*******************************************************
//* 2007.7.16
//*******************************************************
经过一个双修日的音频驱动调试，对S3C2410 的IIS 控制器和UDA1341 的频率配置有了进一步的了解，对控制放音的写设备文件函数smdk2410_audio_write 也有了更深的认识。下面就来总结一下相关的注意要点。
在S3C2410 芯片与UDA1341 芯片的连线中，关于时钟信号的连线有：I2SLRCLK 到WS，I2SSCLK 到BCK，CDCLK 到SYSCLK。其中CDCLK 为UDA1341 芯片提供系统的同步时钟，也称为编解码时钟，即提供UDA1341 芯片进行音频的A/D，D/A 采样时的采样时钟。而其他2组时钟只是在进行IIS 总线传输数据时提供串行数据的位时钟和左右声道的切换。
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 时钟输出频率。
而在UDA1341 芯片的初始化中也需要进行系统时钟的设置（512fs，384fs 或256fs），在进行音频的编解码时会根据SYSCLK 输入的系统时钟除以相应的系数，来得到采样频率fs。所以对于S3C2410 芯片的IIS 控制器和UDA1341 芯片，两者相应的CDCLK 和SYSCLK 的时钟频率需要设置一致。我在这里都设为了384fs，在调试过程中，我试着将两者设的不一致，结果就放不出声音了。还有一点要注意，由于预分频值与 384 这个系数和采样频率fs 有关，所以在计算预分频值的函数iispsr_value 中，384 这个系数也要和CDCLK 和SYSCLK 设置的系数一致。如果设置不一致的话，会导致声音播放的太快或太慢。
------------------------------------------------------------------------
9:52 | 添加评论 | 阅读评论 (1) | 发送消息 | 固定链接 | 查看引用通告 (0) | 写入日志 | 嵌入式软件技术
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，用于外部时钟块
9:51 | 添加评论 | 发送消息 | 固定链接 | 查看引用通告 (0) | 写入日志 | 嵌入式软件技术
armlinux学习笔记－－触摸屏驱动程序分析
//*******************************************************
//* 2007.6.26
//*******************************************************
Linux 下的触摸屏驱动程序主要都在/kernel/drivers/char/s3c2410-ts.c 文件中。
触摸屏的file_operations 结构定义如下：
static struct file_operations s3c2410_fops = {
owner: THIS_MODULE,
open: s3c2410_ts_open,
read: s3c2410_ts_read,
release: s3c2410_ts_release,
#ifdef USE_ASYNC
fasync: s3c2410_ts_fasync,
#endif
poll: s3c2410_ts_poll,
};
在触摸屏设备驱动程序中，全局变量struct TS_DEV tsdev 是很重要的，用来保存触摸屏的相关参数、等待处理的消息队列、当前采样数据、上一次采样数据等信息，数据结构struct TS_DEV 的定义如下：
typedef struct {
unsigned int penStatus; /* PEN_UP, PEN_DOWN, PEN_SAMPLE */
TS_RET buf[MAX_TS_BUF]; /* protect against overrun（环形缓冲区） */
unsigned int head, tail;/* head and tail for queued events （环形缓冲区的头尾）*/
wait_queue_head_t wq; //* 等待队列数据结构
spinlock_t lock; //* 自旋锁
#ifdef USE_ASYNC
struct fasync_struct *aq;
#endif
#ifdef CONFIG_PM
struct pm_dev *pm_dev;
#endif
} TS_DEV;
static TS_DEV tsdev;
在/kernel/include/asm-arm/linuette_ioctl.h 文件中：
typedef struct {
unsigned short pressure; //* 压力，这里可定义为笔按下，笔抬起，笔拖曳
unsigned short x; //* 横坐标的采样值
unsigned short y; //* 纵坐标的采样值
unsigned short pad; //* 填充位
} TS_RET;
在/kernel/include/linux/wait.h 文件中：
struct __wait_queue_head {
wq_lock_t lock;
struct list_head task_list;
#if WAITQUEUE_DEBUG
long __magic;
long __creator;
#endif
};
typedef struct __wait_queue_head wait_queue_head_t;
TS_RET结构体中的信息就是驱动程序提供给上层应用程序使用的信息，用来存储触摸屏的返回值。上层应用程序通过读接口，从底层驱动中读取信息，并根据得到的值进行其他方面的操作。
TS_DEV结构用于记录触摸屏运行的各种状态，PenStatus包括PEN_UP、PEN_DOWN和PEN_FLEETING。 buf[MAX_TS_BUF]是用来存放数据信息的事件队列，head、tail分别指向事件队列的头和尾。程序中的笔事件队列是一个环形结构，当有事件加入时，队列头加一，当有事件被取走时，队列尾加一，当头尾位置指针一致时读取笔事件的信息，进程会被安排进入睡眠。wq等待队列，包含一个锁变量和一个正在睡眠进程链表。当有好几个进程都在等待某件事时，Linux会把这些进程记录到这个等待队列。它的作用是当没有笔触事件发生时，阻塞上层的读操作，直到有笔触事件发生。lock使用自旋锁，自旋锁是基于共享变量来工作的，函数可以通过给某个变量设置一个特殊值来获得锁。而其他需要锁的函数则会循环查询锁是否可用。MAX_TS_BUF的值为16，即在没有被读取之前，系统缓冲区中最多可以存放16个笔触数据信息。（关于自旋锁的作用和概念可以参考一篇《Linux内核的同步机制》文章的相关章节。）
------------------------------------------------------------------------
模块初始化函数是调用s3c2410_ts_init 函数来实现的，主要完成触摸屏设备的内核模块加载、初始化系统I/O、中断注册、设备注册，为设备文件系统创建入口等标准的字符设备初始化工作。
static int __init s3c2410_ts_init(void)
ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
tsMajor = ret;
这里首先对字符设备进行注册，将触摸屏的file_operations 结构中的函数接口传入内核，注册成功后获得系统自动分配的主设备号。
set_gpio_ctrl(GPIO_YPON);
set_gpio_ctrl(GPIO_YMON);
set_gpio_ctrl(GPIO_XPON);
set_gpio_ctrl(GPIO_XMON);
在/kernel/include/asm-arm/arch-s3c2410/smdk.h 文件中：
#define GPIO_YPON (GPIO_MODE_nYPON | GPIO_PULLUP_DIS | GPIO_G15)
#define GPIO_YMON (GPIO_MODE_YMON | GPIO_PULLUP_EN | GPIO_G14)
#define GPIO_XPON (GPIO_MODE_nXPON | GPIO_PULLUP_DIS | GPIO_G13)
#define GPIO_XMON (GPIO_MODE_XMON | GPIO_PULLUP_EN | GPIO_G12)
GPIO 口的Port G 端口有4个管脚对应触摸屏的控制接口，分别是：
GPG15 --- nYPON Y+ 控制信号
GPG14 --- YMON Y- 控制信号
GPG13 --- nXPON X+ 控制信号
GPG12 --- XMON X- 控制信号
需要通过配置GPGCON 寄存器来设定该端口管脚的输出模式，对应位如下：
[31:30] [29:28] [27:26] [25:24]
GPG15 GPG14 GPG13 GPG12 ...
参考S3C2410 芯片datasheet 的I/O口章节，都要设为11（二进制）。
ADCDLY = 30000;
配置ADCDLY 寄存器，对自动转换模式来说是设定ADC 开始转换时的延时时间，以及对X轴和Y轴转换的时间间隔，对正常模式来说仅设定对X轴和Y轴转换的时间间隔。注意该值不能为0。
在/kernel/arch/arm/kernel/irq.c 文件中：
/**
* request_irq - allocate an interrupt line
* @irq: Interrupt line to allocate
* @handler: Function to be called when the IRQ occurs
* @irqflags: Interrupt type flags
* @devname: An ascii name for the claiming device
* @dev_id: A cookie passed back to the handler function
*
* This call allocates interrupt resources and enables the
* interrupt line and IRQ handling. From the point this
* call is made your handler function may be invoked. Since
* your handler function must clear any interrupt the board
* raises, you must take care both to initialise your hardware
* and to set up the interrupt handler in the right order.
*
* Dev_id must be globally unique. Normally the address of the
* device data structure is used as the cookie. Since the handler
* receives this value it makes sense to use it.
*
* If your interrupt is shared you must pass a non NULL dev_id
* as this is required when freeing the interrupt.
*
* Flags:
*
* SA_SHIRQ Interrupt is shared
*
* SA_INTERRUPT Disable local interrupts while processing
*
* SA_SAMPLE_RANDOM The interrupt can be used for entropy
*
*/
int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *),
unsigned long irq_flags, const char * devname, void *dev_id)
其中handler 函数指针的具体参数为：
void (*handler)(int irq, void *dev_id, struct pt_regs *regs)
函数request_irq 是Linux 系统中驱动程序注册中断的方法。irq 为所要申请的硬件中断号，handler 为系统所注册的中断处理子程序，irq_flags 为申请时的选项，devname 为指向设备名称的字符指针，dev_id 为申请时告诉系统的设备标识。若中断申请成功则返回0，失败则返回负值。
ret = request_irq(IRQ_ADC_DONE, s3c2410_isr_adc, SA_INTERRUPT,
DEVICE_NAME, s3c2410_isr_adc);
调用该函数来进行A/D转换的中断注册，所要申请的硬件中断号为IRQ_ADC_DONE（62）；系统所注册的中断处理子程序为 s3c2410_isr_adc 函数；申请中断选项为SA_INTERRUPT，表示中断处理程序是快速处理程序，即快速处理程序运行时，所有中断都被屏蔽；设备名称定义为 DEVICE_NAME，即"s3c2410-ts"；而设备标识仍然用中断处理子程序代替。
ret = request_irq(IRQ_TC, s3c2410_isr_tc, SA_INTERRUPT,
DEVICE_NAME, s3c2410_isr_tc);
接着继续调用该函数来进行触摸屏触摸的中断注册，所要申请的硬件中断号为IRQ_TC（61）；系统所注册的中断处理子程序为 s3c2410_isr_tc 函数；申请中断选项为SA_INTERRUPT，表示中断处理程序是快速处理程序，即快速处理程序运行时，所有中断都被屏蔽；设备名称定义为 DEVICE_NAME，即"s3c2410-ts"；而设备标识仍然用中断处理子程序代替。
/* Wait for touch screen interrupts */
wait_down_int();
调用该宏函数来设置触摸屏为等待中断模式【笔按下产生中断】，具体定义如下：
#define wait_down_int() { ADCTSC = DOWN_INT | XP_PULL_UP_EN | /
XP_AIN | XM_HIZ | YP_AIN | YM_GND | /
XP_PST(WAIT_INT_MODE); }
用该宏函数来设置ADC 触摸屏控制寄存器，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
DOWN_INT = 1<<8 * 0 该位保留且应该设为0 【笔按下或笔抬起中断信号控制位，设为0 表示笔按下产生中断信号】
XP_PULL_UP_EN = 1<<3 * 0 上拉开关使能，设为0 表示XP 引脚上拉使能
XP_AIN = 1<<4 * 1 选择nXPON 引脚输出值，设为1 表示nXPON 引脚输出1，则XP 引脚连接AIN[7] 引脚
XM_HIZ = 1<<5 * 0 选择XMON 引脚输出值，设为0 表示XMON 引脚输出0，则XM 引脚为高阻态
YP_AIN = 1<<6 * 1 选择nYPON 引脚输出值，设为1 表示nYPON 引脚输出1，则YP 引脚连接AIN[5] 引脚
YM_GND = 1<<7 * 1 选择YMON 引脚输出值，设为1 表示YMON 引脚输出1，则YM 引脚为接地
XP_PST(WAIT_INT_MODE); = 3 X坐标Y坐标手动测量设置，设为3 表示等待中断模式
#ifdef CONFIG_DEVFS_FS
devfs_ts_dir = devfs_mk_dir(NULL, "touchscreen", NULL);
devfs_tsraw = devfs_register(devfs_ts_dir, "0raw", DEVFS_FL_DEFAULT,
tsMajor, TSRAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR,
&s3c2410_fops, NULL);
#endif
以上这两个函数在我总结的一篇《LCD驱动程序分析》中有较详细的介绍。
这里调用了devfs_mk_dir 函数，在设备文件系统中创建了一个名为touchscreen 的目录，并返回一个带有目录结构的数据结构变量devfs_ts_dir。将该变量作为下一步devfs_register 函数的参数，该参数在调用设备文件系统注册清除函数devfs_unregister 时也要作为参数传入。
调用devfs_register 函数后，会在刚才创建的touchscreen 目录下再创建一个名为0raw 的设备文件节点。该函数的参数中，DEVFS_FL_DEFAULT 为该函数的标志选项，tsMajor 为注册字符设备时系统自动分配的主设备号，TSRAW_MINOR（1）为次设备号，S_IFCHR | S_IRUSR | S_IWUSR 为默认的文件模式，&s3c2410_fops 为传入内核的触摸屏file_operations 结构中的函数接口，私有数据指针为空。返回一个devfs_handle_t 数据结构的变量devfs_tsraw，这会在调用设备文件系统注册清除函数devfs_unregister 时作为参数传入。
------------------------------------------------------------------------
模块的退出函数为s3c2410_ts_exit，该函数的工作就是清除已注册的字符设备，中断以及设备文件系统。
#ifdef CONFIG_DEVFS_FS
devfs_unregister(devfs_tsraw);
devfs_unregister(devfs_ts_dir);
#endif
这里首先清除原先后一步创建设备文件节点0raw 的结构变量devfs_tsraw，然后再清除创建touchscreen 目录的结构变量devfs_ts_dir。
unregister_chrdev(tsMajor, DEVICE_NAME);
接下来删除字符设备的注册信息。
在/kernel/arch/arm/kernel/irq.c 文件中：
/**
* free_irq - free an interrupt
* @irq: Interrupt line to free
* @dev_id: Device identity to free
*
* Remove an interrupt handler. The handler is removed and if the
* interrupt line is no longer in use by any driver it is disabled.
* On a shared IRQ the caller must ensure the interrupt is disabled
* on the card it drives before calling this function.
*
* This function may be called from interrupt context.
*/
void free_irq(unsigned int irq, void *dev_id)
函数free_irq 与函数request_irq 相对应，通常在模块被卸载时调用，负责注销一个已经申请的中断。
free_irq(IRQ_ADC_DONE, s3c2410_isr_adc);
free_irq(IRQ_TC, s3c2410_isr_tc);
最后依次注销A/D转换和定时器这两个已经申请的中断。
------------------------------------------------------------------------
接下来看一下A/D转换的中断处理函数：
static void s3c2410_isr_adc(int irq, void *dev_id, struct pt_regs *reg)
其中参数irq 为中断号，dev_id 为申请中断时告诉系统的设备标识，regs 为中断发生时寄存器内容。该函数在中断产生时由系统来调用，调用时以上参数已经由系统传入。
在/kernel/include/linux/spinlock.h 文件中：
/*
* These are the generic versions of the spinlocks and read-write
* locks..
*/
#define spin_lock_irq(lock) do{local_irq_disable();spin_lock(lock);}while (0)
#define spin_unlock_irq(lock) do{spin_unlock(lock);local_irq_enable();}while(0)
#define DEBUG_SPINLOCKS 0 /* 0 == no debugging, 1 == maintain lock state, 2 == full debug */
#if (DEBUG_SPINLOCKS < 1)
typedef struct { } spinlock_t;
#define SPIN_LOCK_UNLOCKED (spinlock_t) { }
#define spin_lock_init(lock) do { } while(0)
#define spin_lock(lock) (void)(lock) /* Not "unused variable". */
#define spin_unlock_wait(lock) do { } while(0)
#define spin_unlock(lock) do { } while(0)
可见上面这四个宏函数都是空函数，这样的话spin_lock_irq(lock)和spin_unlock_irq(lock)这两个宏函数就相当于分别只调用了local_irq_disable();和local_irq_enable();两个宏函数。关于自旋锁的作用和概念可以参考一篇《Linux内核的同步机制》文章的相关章节。
在/kernel/include/asm-arm/system.h 文件中：
#define local_irq_disable() __cli()
#define local_irq_enable() __sti()
在/kernel/include/asm-arm/proc-armo/system.h 文件中：
/*
* Enable IRQs
*/
#define __sti() /
do { /
unsigned long temp; /
__asm__ __volatile__( /
" mov %0, pc @ sti/n" /
" bic %0, %0, #0x08000000/n" /
" teqp %0, #0/n" /
: "=r" (temp) /
: /
: "memory"); /
} while(0)
/*
* Disable IRQs
*/
#define __cli() /
do { /
unsigned long temp; /
__asm__ __volatile__( /
" mov %0, pc @ cli/n" /
" orr %0, %0, #0x08000000/n" /
" teqp %0, #0/n" /
: "=r" (temp) /
: /
: "memory"); /
} while(0)
最后用ARM 汇编指令实现了对IRQ 的使能和禁止。
spin_lock_irq(&(tsdev.lock));
这样调用spin_lock_irq 宏函数，实际上只是做了local_irq_disable();一步，就是禁止IRQ 中断。
if (tsdev.penStatus == PEN_UP)
s3c2410_get_XY();
然后根据变量tsdev.penStatus 所处的状态，若为笔抬起则调用s3c2410_get_XY 函数来取得A/D转换得到的坐标值，该函数会在后面说明。
#ifdef HOOK_FOR_DRAG
else
s3c2410_get_XY();
#endif
这里表示如果定义了笔拖曳，且在笔没有抬起的情况下，继续调用s3c2410_get_XY 函数来得到最新的坐标值。
spin_unlock_irq(&(tsdev.lock));
最后调用spin_unlock_irq 宏函数，相当于只做了local_irq_enable();一步，来重新使能IRQ 中断。最后退出这个中断服务子程序。
------------------------------------------------------------------------
继续来看一下另一个中断处理函数，即触摸屏触摸中断处理函数：
static void s3c2410_isr_tc(int irq, void *dev_id, struct pt_regs *reg)
该函数的参数和上面A/D转换中断处理函数的定义一样，不再累赘。
spin_lock_irq(&(tsdev.lock));
也同上面的意思一样，首先禁止IRQ 中断。
if (tsdev.penStatus == PEN_UP) {
start_ts_adc();
}
接着根据变量tsdev.penStatus 的状态值判断是否进行A/D转换。若笔抬起，则调用函数start_ts_adc 来进行A/D转换，该函数会在后面说明。
else {
tsdev.penStatus = PEN_UP;
DPRINTK("PEN UP: x: %08d, y: %08d/n", x, y);
wait_down_int();
tsEvent();
}
如果变量tsdev.penStatus 的状态值不是笔抬起，则先将该变量状态设为笔抬起，然后调用宏函数wait_down_int()。该宏函数已在前面说明，用来设置触摸屏为等待中断模式。最后调用tsEvent 函数指针所指的函数，在模块初始化函数s3c2410_ts_init 中，tsEvent 指向的是一个空函数tsEvent_dummy，而在打开设备函数s3c2410_ts_open 中，tsEvent 会指向tsEvent_raw 函数，该函数负责填充触摸屏缓冲区，并唤醒等待的进程。该函数也会在后面加以说明。
spin_unlock_irq(&(tsdev.lock));
中断处理函数的最后一步都一样，重新使能IRQ 中断。退出中断服务子程序。
------------------------------------------------------------------------
下面先来看启动A/D转换的函数：
static inline void start_ts_adc(void)
adc_state = 0;
mode_x_axis();
start_adc_x();
简简单单的3步。
第一步，对A/D转换的状态变量清零。
第二步，调用mode_x_axis 宏函数，具体定义如下：
#define mode_x_axis() { ADCTSC = XP_EXTVLT | XM_GND | YP_AIN | YM_HIZ | /
XP_PULL_UP_DIS | XP_PST(X_AXIS_MODE); }
//*******************************************************
//* 2007.6.27
//*******************************************************
该宏函数用来设置ADC触摸屏控制寄存器为测量X坐标模式，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
XP_EXTVLT = 1<<4 * 0 选择nXPON 引脚输出值，设为0 表示nXPON 引脚输出0，则XP 引脚为接外部电压
XM_GND = 1<<5 * 1 选择XMON 引脚输出值，设为1 表示XMON 引脚输出1，则XM 引脚为接地
YP_AIN = 1<<6 * 1 选择nYPON 引脚输出值，设为1 表示nYPON 引脚输出1，则YP 引脚连接AIN[5] 引脚
YM_HIZ = 1<<7 * 0 选择YMON 引脚输出值，设为0 表示YMON 引脚输出0，则YM 引脚为高阻态
XP_PULL_UP_DIS = 1<<3 * 1 上拉开关使能，设为1 表示XP 引脚上拉禁止
XP_PST(X_AXIS_MODE); = 1 X坐标Y坐标手动测量设置，设为1 表示X坐标测量模式
第三步，调用start_adc_x 宏函数，具体定义如下：
#define start_adc_x() { ADCCON = PRESCALE_EN | PRSCVL(49) | /
ADC_INPUT(ADC_IN5) | ADC_START_BY_RD_EN | /
ADC_NORMAL_MODE; /
ADCDAT0; }
该宏函数用来设置ADC控制寄存器启动X坐标的A/D转换，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
PRESCALE_EN = 1<<14 * 1 A/D转换器使能，设为1 表示使能A/D转换器
PRSCVL(49) = 49<<6 A/D转换器值，设为49
ADC_INPUT(ADC_IN5) = 5<<3 选择模拟输入通道，设为5 表示AIN[5] 引脚作为模拟输入通道
ADC_START_BY_RD_EN = 1<<1 * 1 A/D转换通过读启动，设为1 表示通过读操作启动A/D转换使能
ADC_NORMAL_MODE; = 1<<2 * 0 选择待命模式，设为0 表示正常操作模式
ADCDAT0; 读取X坐标的ADC转换数据寄存器
由于设置了A/D转换通过读启动，则该ADCCON 寄存器的最低位ENABLE_START 启动A/D转换位就无效了。在最后一步读取ADCDAT0 寄存器这一操作时就启动了A/D转换。
------------------------------------------------------------------------
static inline void s3c2410_get_XY(void)
这就是获取A/D转换所得到的坐标值的函数。
if (adc_state == 0)
{
adc_state = 1;
disable_ts_adc();
y = (ADCDAT0 & 0x3ff);
mode_y_axis();
start_adc_y();
}
这里首先查看A/D转换的状态变量，若为0 表示进行过X坐标的A/D转换，将该变量设为1。然后调用宏函数disable_ts_adc，该宏函数定义如下：
#define disable_ts_adc() { ADCCON &= ~(ADCCON_READ_START); }
这个宏函数主要工作就是禁止通过读操作启动A/D转换，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
ADCCON_READ_START = 1<<1 A/D转换通过读启动，设为0 表示通过读操作启动A/D转换禁止
然后y = (ADCDAT0 & 0x3ff); 这一步将X坐标的ADC转换数据寄存器的D9～D0 这10为读出到变量y（这里由于是竖屏，参考原理图后知道，硬件连线有过改动，将XP，XM 和YP，YM 进行了对换，这样ADCDAT0 里读出的是YP，YM 方向电阻导通的值，也就是y轴坐标值）。这个mode_y_axis 宏函数定义如下：
#define mode_y_axis() { ADCTSC = XP_AIN | XM_HIZ | YP_EXTVLT | YM_GND | /
XP_PULL_UP_DIS | XP_PST(Y_AXIS_MODE); }
该宏函数用来设置ADC触摸屏控制寄存器为测量Y坐标模式，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
XP_AIN = 1<<4 * 1 选择nXPON 引脚输出值，设为1 表示nXPON 引脚输出1，则XP 引脚连接AIN[7] 引脚
XM_HIZ = 1<<5 * 0 选择XMON 引脚输出值，设为0 表示XMON 引脚输出0，则XM 引脚为高阻态
YP_EXTVLT = 1<<6 * 0 选择nYPON 引脚输出值，设为0 表示nYPON 引脚输出0，则YP 引脚为接外部电压
YM_GND = 1<<7 * 1 选择YMON 引脚输出值，设为1 表示YMON 引脚输出1，则YM 引脚为接地
XP_PULL_UP_DIS = 1<<3 * 1 上拉开关使能，设为1 表示XP 引脚上拉禁止
XP_PST(Y_AXIS_MODE); = 2 X坐标Y坐标手动测量设置，设为2 表示Y坐标测量模式
最后调用start_adc_y 宏函数，具体定义如下：
#define start_adc_y() { ADCCON = PRESCALE_EN | PRSCVL(49) | /
ADC_INPUT(ADC_IN7) | ADC_START_BY_RD_EN | /
ADC_NORMAL_MODE; /
ADCDAT1; }
该宏函数用来设置ADC控制寄存器启动Y坐标的A/D转换，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
PRESCALE_EN = 1<<14 * 1 A/D转换器使能，设为1 表示使能A/D转换器
PRSCVL(49) = 49<<6 A/D转换器值，设为49
ADC_INPUT(ADC_IN7) = 7<<3 选择模拟输入通道，设为7 表示AIN[7] 引脚作为模拟输入通道
ADC_START_BY_RD_EN = 1<<1 * 1 A/D转换通过读启动，设为1 表示通过读操作启动A/D转换使能
ADC_NORMAL_MODE; = 1<<2 * 0 选择待命模式，设为0 表示正常操作模式
ADCDAT1; 读取Y坐标的ADC转换数据寄存器
else if (adc_state == 1)
{
adc_state = 0;
disable_ts_adc();
x = (ADCDAT1 & 0x3ff);
tsdev.penStatus = PEN_DOWN;
DPRINTK("PEN DOWN: x: %08d, y: %08d/n", x, y);
wait_up_int();
tsEvent();
}
若查看A/D转换的状态变量，若为1 表示进行过Y坐标的A/D转换，将该变量设为0。然后调用宏函数disable_ts_adc 来禁止通过读操作启动A/D转换。
接着将x = (ADCDAT1 & 0x3ff); 这一步将Y坐标的ADC转换数据寄存器的D9～D0 这10为读出到变量x（这里由于是竖屏，参考原理图后知道，硬件连线有过改动，将XP，XM 和YP，YM 进行了对换，这样ADCDAT1 里读出的是XP，XM 方向电阻导通的值，也就是x轴坐标值）。
随后将变量tsdev.penStatus 的状态值改为笔按下，并调用wait_up_int 宏函数来设置触摸屏为等待中断模式【笔抬起产生中断】，具体定义如下：
#define wait_up_int() { ADCTSC = UP_INT | XP_PULL_UP_EN | XP_AIN | XM_HIZ | /
YP_AIN | YM_GND | XP_PST(WAIT_INT_MODE); }
用该宏函数来设置ADC 触摸屏控制寄存器，参考S3C2410 芯片datasheet 中关于触摸屏的章节，具体设置参数如下：
UP_INT = 1<<8 * 1 该位保留且应该设为0，这里设为1 不知道为什么 【笔按下或笔抬起中断信号控制位，设为1 表示笔抬起产生中断信号】
XP_PULL_UP_EN = 1<<3 * 0 上拉开关使能，设为0 表示XP 引脚上拉使能
XP_AIN = 1<<4 * 1 选择nXPON 引脚输出值，设为1 表示nXPON 引脚输出1，则XP 引脚连接AIN[7] 引脚
XM_HIZ = 1<<5 * 0 选择XMON 引脚输出值，设为0 表示XMON 引脚输出0，则XM 引脚为高阻态
YP_AIN = 1<<6 * 1 选择nYPON 引脚输出值，设为1 表示nYPON 引脚输出1，则YP 引脚连接AIN[5] 引脚
YM_GND = 1<<7 * 1 选择YMON 引脚输出值，设为1 表示YMON 引脚输出1，则YM 引脚为接地
XP_PST(WAIT_INT_MODE); = 3 X坐标Y坐标手动测量设置，设为3 表示等待中断模式
最后调用函数指针tsEvent 所指向的函数。在s3c2410_get_XY 函数里面，应该表示这个驱动的设备文件已经打开，在打开设备文件函数中，tsEvent 函数指针就指向了tsEvent_raw 这个函数，也就是说，下面执行的是tsEvent_raw 函数。tsEvent_raw 函数负责填充触摸屏缓冲区，并唤醒等待的进程，该函数会在后面说明。
------------------------------------------------------------------------
static void tsEvent_raw(void)
来看一下tsEvent_raw 这个函数。
if (tsdev.penStatus == PEN_DOWN)
{
BUF_HEAD.x = x;
BUF_HEAD.y = y;
BUF_HEAD.pressure = PEN_DOWN;
一上来就根据变量tsdev.penStatus 的状态值进行判断，若为笔按下，将从A/D转换器中采集的x轴y轴坐标以及笔按下的状态存入变量tsdev 中的buf 成员中的相应变量中。
#ifdef HOOK_FOR_DRAG
ts_timer.expires = jiffies + TS_TIMER_DELAY;
add_timer(&ts_timer);
#endif
如果定义了笔拖曳，先将定时器的定时溢出值更新，然后调用add_timer 函数重新增加定时器计时，变量ts_timer 为struct timer_list 数据结构。
}
else
{
#ifdef HOOK_FOR_DRAG
del_timer(&ts_timer);
#endif
如果定义了笔拖曳，调用del_timer 函数来删除定时器，变量ts_timer 为struct timer_list 数据结构。
BUF_HEAD.x = 0;
BUF_HEAD.y = 0;
BUF_HEAD.pressure = PEN_UP;
}
若变量tsdev.penStatus 的状态值不是笔按下，则x轴y轴坐标写为0和笔抬起的状态一起存入变量tsdev 中的buf 成员中的相应变量中。
tsdev.head = INCBUF(tsdev.head, MAX_TS_BUF);
其中INCBUF 宏函数定义如下：
#define INCBUF(x,mod) ((++(x)) & ((mod) - 1))
由于这里MAX_TS_BUF=16，这样(mod) - 1)就为15（0x0F），所以这个宏函数相当于就是将变量tsdev.head 这个表示buf 头位置的值加1，然后取模16，即指向下一个buf ，形成一个在环形缓冲区上绕环的头指针。
在/kernel/include/linux/sched.h 文件中：
#define wake_up_interruptible(x) __wake_up((x),TASK_INTERRUPTIBLE, 1)
该宏函数定义为__wake_up 函数，参数TASK_INTERRUPTIBLE 为1，表示要唤醒的任务的状态为中断模式，参数1 表示要唤醒的互斥进程数目为1。
对应的唤醒操作包括wake_up_interruptible和wake_up。wake_up函数不仅可以唤醒状态为 TASK_UNINTERRUPTIBLE的进程，而且可以唤醒状态为TASK_INTERRUPTIBLE的进程。 wake_up_interruptible只负责唤醒状态为TASK_INTERRUPTIBLE的进程。关于 interruptible_sleep_on 和wake_up_interruptible 函数详细的用法可以参考一篇《关于linux内核中等待队列的问题》文档。
在/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 的中断使能状态。
/*
* The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just wake everything
* up. If it's an exclusive wakeup (nr_exclusive == small +ve number) then we wake all the
* non-exclusive tasks and one exclusive task.
*
* There are circumstances in which we can try to wake a task which has already
* started to run but is not in state TASK_RUNNING. try_to_wake_up() returns zero
* in this (rare) case, and we handle it by contonuing to scan the queue.
*/
static inline void __wake_up_common (wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, const int sync)
该函数的作用是唤醒在等待当前等待队列的进程。参数q 表示要操作的等待队列，mode 表示要唤醒任务的状态，如TASK_UNINTERRUPTIBLE 或TASK_INTERRUPTIBLE 等。nr_exclusive 是要唤醒的互斥进程数目，在这之前遇到的非互斥进程将被无条件唤醒。sync表示？？？
在/kernel/include/linux/wait.h 文件中：
struct __wait_queue_head {
wq_lock_t lock;
struct list_head task_list;
#if WAITQUEUE_DEBUG
long __magic;
long __creator;
#endif
};
typedef struct __wait_queue_head wait_queue_head_t;
这是等待队列数据结构。
# define wq_read_lock_irqsave spin_lock_irqsave
# define wq_read_unlock_irqrestore spin_unlock_irqrestore
看到这里可以知道其实宏函数wq_read_lock_irqsave 和wq_read_unlock_irqrestore 等价于宏函数spin_lock_irqsave 和spin_unlock_irqrestore，并直接将自己的参数传了下去。
在/kernel/include/linux/spinlock.h 文件中：
/*
* These are the generic versions of the spinlocks and read-write
* locks..
*/
#define spin_lock_irqsave(lock, flags) do {local_irq_save(flags);spin_lock(lock);}while (0)
#define spin_unlock_irqrestore(lock, flags) do {spin_unlock(lock); local_irq_restore(flags); } while (0)
在这两个宏函数中，前面已经提到spin_lock 和spin_unlock 其实都为空函数，那么实际只执行了local_irq_save 和local_irq_restore 这两个宏函数。
在/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)
这里local_irq_save 和local_irq_restore 这两个宏函数又分别等价于__save_flags_cli 和__restore_flags 这两个宏函数。
在/kernel/include/asm-arm/proc-armo/system.h 文件中：
/*
* A couple of speedups for the ARM
*/
/*
* 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)
/*
* 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 汇编指令实现了对当前程序状态寄存器CPSR 中的IRQ 和FIQ 中断使能状态的保存和恢复。而且在__save_flags_cli 宏函数中，除了对IRQ 和FIQ 中断使能状态的保存外，还禁止了IRQ 中断。
wake_up_interruptible(&(tsdev.wq));
在这个tsEvent_raw 函数最后，调用wake_up_interruptible 函数来以中断模式唤醒等待tsdev.wq 队列的进程。
------------------------------------------------------------------------
由于上面这个wake_up_interruptible 函数的作用还不是很明确，所以需要分析一下打开设备文件这个函数。触摸屏打开设备文件函数定义如下：
static int s3c2410_ts_open(struct inode *inode, struct file *filp)
tsdev.head = tsdev.tail = 0;
tsdev.penStatus = PEN_UP;
首先是最简单的将变量tsdev.head 和tsdev.tail 这两个表示buf 头尾位置的值清零，然后将变量tsdev.penStatus 的状态值初始化为笔抬起。
#ifdef HOOK_FOR_DRAG
init_timer(&ts_timer);
ts_timer.function = ts_timer_handler;
#endif
如果定义了笔拖曳，先调用init_timer 函数来初始化一个定时器，变量ts_timer 为struct timer_list 数据结构，然后将定时调用的函数指针指向ts_timer_handler 函数。
tsEvent = tsEvent_raw;
将函数指针tsEvent 指向tsEvent_raw 函数。
在/kernel/include/linux/wait.h 文件中：
static inline void init_waitqueue_head(wait_queue_head_t *q)
{
#if WAITQUEUE_DEBUG
if (!q)
WQ_BUG();
#endif
q->lock = WAITQUEUE_RW_LOCK_UNLOCKED;
INIT_LIST_HEAD(&q->task_list);
#if WAITQUEUE_DEBUG
q->__magic = (long)&q->__magic;
q->__creator = (long)current_text_addr();
#endif
}
该函数初始化一个已经存在的等待队列头，它将整个队列设置为"未上锁"状态，并将链表指针prev和next指向它自身。
init_waitqueue_head(&(tsdev.wq));
在这个s3c2410_ts_open 函数中，调用init_waitqueue_head 函数来初始化一个定义在变量tsdev 中的等待队列头的成员结构。
MOD_INC_USE_COUNT;
return 0;
最后调用MOD_INC_USE_COUNT; 来对设备文件计数器加一计数，并返回。
------------------------------------------------------------------------
再来分析一下用户层要调用的读取设备文件的接口函数：
static ssize_t s3c2410_ts_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
这个函数实现的任务是将事件队列从设备缓存中读到用户空间的数据缓存中。实现的过程主要是通过一个循环，只有在事件队列的头、尾指针不重合时，才能成功的从tsdev.tail指向的队列尾部读取到一组触摸信息数据，并退出循环。否则调用读取函数的进程就要进入睡眠。
TS_RET ts_ret;
retry:
if (tsdev.head != tsdev.tail)
{
int count;
count = tsRead(&ts_ret);
if (count) copy_to_user(buffer, (char *)&ts_ret, count);
return count;
}
这个函数中，首先通过变量tsdev.head 和tsdev.tail 是否相等来判断环形缓冲区是否为空。若不相等则表示环形缓冲区中有触摸屏数据，调用tsRead 函数将触摸屏数据读入TS_RET 数据结构的ts_ret 变量中，该函数会在后面说明。
接下来调用copy_to_user 函数来把内核空间的数据复制到用户空间，在这里就是把驱动程序里的变量ts_ret 中的数据复制到用户程序的buffer 中，然后返回复制的数据长度。
else
{
if (filp->f_flags & O_NONBLOCK)
return -EAGAIN;
interruptible_sleep_on(&(tsdev.wq));
if (signal_pending(current))
return -ERESTARTSYS;
goto retry;
}
若变量tsdev.head 和tsdev.tail 相等，则表示环形缓冲区为空，首先根据file->f_flags 与上O_NONBLOCK 值来进行判断，若为O_NONBLOCK 值，则表示采用非阻塞的文件IO方法，立即返回，否则才会调用interruptible_sleep_on 函数，调用该函数的进程将会进入睡眠，直到被唤醒。关于O_NONBLOCK 值的含义在我总结的《IIS音频驱动程序分析》一文中有详细说明。
在/kernel/kernel/sched.c 文件中：
void interruptible_sleep_on(wait_queue_head_t *q)
{
SLEEP_ON_VAR
current->state = TASK_INTERRUPTIBLE;
SLEEP_ON_HEAD
schedule();
SLEEP_ON_TAIL
}
常用的睡眠操作有interruptible_sleep_on和sleep_on。两个函数类似，只不过前者将进程的状态从就绪态（TASK_RUNNING）设置为TASK_INTERRUPTIBLE，允许通过发送signal唤醒它（即可中断的睡眠状态）；而后者将进程的状态设置为TASK_UNINTERRUPTIBLE，在这种状态下，不接收任何singal。关于interruptible_sleep_on 和wake_up_interruptible 函数详细的用法可以参考一篇《关于linux内核中等待队列的问题》文档。
如果进程被唤醒，则会继续跳到retry: 循环读取环形缓冲区，直到读取到一组触摸信息数据才会退出。
------------------------------------------------------------------------
static int tsRead(TS_RET * ts_ret)
这个函数主要将环形缓冲区的x轴y轴坐标数据和笔的状态数据传入该函数形式参数所指的指针变量中。
spin_lock_irq(&(tsdev.lock));
上文已经解释过了，调用该宏函数来禁止IRQ 中断。
ts_ret->x = BUF_TAIL.x;
ts_ret->y = BUF_TAIL.y;
ts_ret->pressure = BUF_TAIL.pressure;
tsdev.tail = INCBUF(tsdev.tail, MAX_TS_BUF);
接着把变量tsdev 的环形缓冲区中相关数据赋值给该函数形式参数所指的指针变量中，并将表示环形缓冲区队列尾部的变量tsdev.tail 加一，这就意味着从环形队列中读取一组数据，尾指针加一。
spin_unlock_irq(&(tsdev.lock));
return sizeof(TS_RET);
上文已经解释过了，调用该宏函数来重新使能IRQ 中断，然后返回。
------------------------------------------------------------------------
再来看一个定时器定时调用的函数：
#ifdef HOOK_FOR_DRAG
static void ts_timer_handler(unsigned long data)
{
spin_lock_irq(&(tsdev.lock));
if (tsdev.penStatus == PEN_DOWN) {
start_ts_adc();
}
spin_unlock_irq(&(tsdev.lock));
}
#endif
这个函数需要定义过笔拖曳才有效。首先调用宏函数spin_lock_irq 来禁止IRQ 中断。
然后在变量tsdev.penStatus 状态为笔按下的时候，调用宏函数start_ts_adc 来启动A/D转换，转换的是X轴的坐标。
最后再调用宏函数spin_unlock_irq 来重新使能IRQ 中断。
//*******************************************************
//* 2007.6.28
//*******************************************************
最后再来看一个释放设备文件的函数：
static int s3c2410_ts_release(struct inode *inode, struct file *filp)
#ifdef HOOK_FOR_DRAG
del_timer(&ts_timer);
#endif
MOD_DEC_USE_COUNT;
return 0;
其实也很简单，在定义了笔拖曳的情况下，调用del_timer 函数来删除定时器，变量ts_timer 为struct timer_list 数据结构，然后调用MOD_DEC_USE_COUNT; 将设备文件计数器减一计数，并返回。
------------------------------------------------------------------------
经过对整个触摸屏驱动程序的流程，以及S3C2410 芯片数据手册里的相关章节进行分析后，下面来总结一下触摸屏驱动程序的大致流程。
首先在驱动模块初始化函数中，除了对驱动的字符设备的注册外，还要对中断进行申请。这里申请了两个触摸屏相关的中断，一个是IRQ_TC 中断，查阅了数据手册后了解到，该中断在笔按下时，由XP 管脚产生表示中断的低电平信号，而笔抬起是没有中断信号产生的。另一个是IRQ_ADC_DONE 中断，该中断是当芯片内部A/D转换结束后，通知中断控制器产生中断，这时就可以去读取转换得到的数据。
当触摸屏按下后，就会出发中断，这时会调用申请中断时附带的s3c2410_isr_tc 中断回调函数，该函数中判断若为笔抬起则启动x轴坐标的A/D转换。当转换完毕后就会产生ADC中断，这时就会调用申请中断时附带的 s3c2410_isr_adc 中断回调函数，在该函数中进行判断，若x轴坐标转换结束马上进行y轴坐标的A/D转换转换；若y轴坐标转换结束，则重新回到等待中断模式，然后将坐标值写入环形缓冲区，并环形等待队列中的进程。
//*******************************************************
//* 2007.6.29
//*******************************************************
昨天晚上经过触摸屏驱动的调试，看出在S3C2410 的datasheet 中有一个问题。关于触摸屏中的ADC 触摸屏控制寄存器ADCTSC 的第8位，在原来的datasheet 中说该为保留，应设为0。而实际调试下来，该位是有功能的，参考了S3C2440 的datasheet 后得知ADCTSC 寄存器的第8位是笔按下或抬起的中断信号控制位，该位设为0，笔按下产生中断信号，该位设为1，笔抬起产生中断信号。经过测试，确实在笔按下和抬起时都会产生中断，并两次调用了s3c2410_isr_tc 中断回调函数。
现在要对前面涉及到ADCTSC 寄存器配置部分的说明做些改动，用“【 】”加以区分。
------------------------------------------------------------------------
9:44 | 添加评论 | 发送消息 | 固定链接 | 查看引用通告 (0) | 写入日志 | 嵌入式软件技术
armlinux学习笔记－－LCD驱动程序分析
//*******************************************************
//* 2007.6.18
//*******************************************************
在/kernel/include/asm-arm/arch-s3c2410/bitfield.h 文件中：
#ifndef __ASSEMBLY__
#define UData(Data) ((unsigned long) (Data))
#else
#define UData(Data) (Data)
#endif
例：UData(5); = 5
/*
* MACRO: Fld
*
* Purpose
* The macro "Fld" encodes a bit field, given its size and its shift value
* with respect to bit 0.
*
* Note
* A more intuitive way to encode bit fields would have been to use their
* mask. However, extracting size and shift value information from a bit
* field's mask is cumbersome and might break the assembler (255-character
* line-size limit).
*
* Input
* Size Size of the bit field, in number of bits.
* Shft Shift value of the bit field with respect to bit 0.
*
* Output
* Fld Encoded bit field.
*/
#define Fld(Size, Shft) (((Size) << 16) + (Shft))
例：Fld(2,5); = 0x20005
/*
* MACROS: FSize, FShft, FMsk, FAlnMsk, F1stBit
*
* Purpose
* The macros "FSize", "FShft", "FMsk", "FAlnMsk", and "F1stBit" return
* the size, shift value, mask, aligned mask, and first bit of a
* bit field.
*
* Input
* Field Encoded bit field (using the macro "Fld").
*
* Output
* FSize Size of the bit field, in number of bits.
* FShft Shift value of the bit field with respect to bit 0.
* FMsk Mask for the bit field.
* FAlnMsk Mask for the bit field, aligned on bit 0.
* F1stBit First bit of the bit field.
*/
#define FSize(Field) ((Field) >> 16)
例：FSize(0x20005); = 2
#define FShft(Field) ((Field) & 0x0000FFFF)
例：FShft(0x20005); = 5
/*
* MACRO: FInsrt
*
* Purpose
* The macro "FInsrt" inserts a value into a bit field by shifting the
* former appropriately.
*
* Input
* Value Bit-field value.
* Field Encoded bit field (using the macro "Fld").
*
* Output
* FInsrt Bit-field value positioned appropriately.
*/
#define FInsrt(Value, Field) /
(UData (Value) << FShft (Field))
例：FInsrt(0x3, 0x20005); = 0x3 << 0x0005 = 0x60
------------------------------------------------------------------------
在/kernel/include/asm-arm/arch-s3c2410/hardware.h 文件中：
/*
* S3C2410 internal I/O mappings
*
* We have the following mapping:
* phys virt
* 48000000 e8000000
*/
#define VIO_BASE 0xe8000000 /* virtual start of IO space */
#define PIO_START 0x48000000 /* physical start of IO space */
#define io_p2v(x) ((x) | 0xa0000000)
#define io_v2p(x) ((x) & ~0xa0000000)
# define __REG(x) io_p2v(x)
# define __PREG(x) io_v2p(x)
这里，在实际的寄存器操作中，都用__REG(x) 宏将物理地址转换为了虚拟地址，然后再对这些虚拟地址进行读写操作。
------------------------------------------------------------------------
当应用程序对设备文件进行ioctl操作时候会调用它们。对于fb_get_fix()，应用程序传入的是fb_fix_screeninfo结构，在函数中对其成员变量赋值，主要是smem_start（缓冲区起始地址）和smem_len（缓冲区长度），最终返回给应用程序。
在/kernel/drivers/video/s3c2410fb.c 文件中的s3c2410fb_map_video_memory 函数中：
fbi->fb.fix.smem_len = fbi->max_xres * fbi->max_yres *
fbi->max_bpp / 8;
fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
fbi->map_cpu = consistent_alloc(GFP_KERNEL, fbi->map_size,
&fbi->map_dma);
if (fbi->map_cpu)
{
fbi->screen_cpu = fbi->map_cpu + PAGE_SIZE;
fbi->screen_dma = fbi->map_dma + PAGE_SIZE;
fbi->fb.fix.smem_start = fbi->screen_dma;
}
在/kernel/include/asm-arm/proc-armo/page.h 文件中：
/* PAGE_SHIFT determines the page size. This is configurable. */
#if defined(CONFIG_PAGESIZE_16)
#define PAGE_SHIFT 14 /* 16K */
#else /* default */
#define PAGE_SHIFT 15 /* 32K */
#endif
在/kernel/include/asm-arm/page.h 文件中：
#define PAGE_SIZE (1UL << PAGE_SHIFT)
#define PAGE_MASK (~(PAGE_SIZE-1))
/* to align the pointer to the (next) page boundary */
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
在/kernel/arch/arm/mm/consistent.c 文件中：
/*
* This allocates one page of cache-coherent memory space and returns
* both the virtual and a "dma" address to that space. It is not clear
* whether this could be called from an interrupt context or not. For
* now, we expressly forbid it, especially as some of the stuff we do
* here is not interrupt context safe.
*
* Note that this does *not* zero the allocated area!
*/
void *consistent_alloc(int gfp, size_t size, dma_addr_t *dma_handle)
这里首先计算出需要视频缓冲区的大小（LCD屏的宽度 * LCD屏的高度 * 每像素的位数 / 每字节的位数）
fbi->fb.fix.smem_len = 240*320*16/8 = 0x25800 =150K（9.375个PAGE）
PAGE_SHIFT = 14
PAGE_SIZE = 1<<14 = 0x4000 = 16K （1个PAGE）
PAGE_MASK = 0xFFFFC000
fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE) = PAGE_ALIGN(150K + 16K) = PAGE_ALIGN(166K)
= (166K + 16K - 1) & 0xFFFFC000 = 0x2D7FF & 0xFFFFC000 = 0x2C000 =176K
consistent_alloc(GFP_KERNEL, 176K, &fbi->map_dma);
最后得到：
framebuffer（物理地址）
|---------------|
| ... |
-------|---------------| <-- fbi->map_dma
| 16K |
分配了 |---------------| <-- fbi->screen_dma = fbi->fb.fix.smem_start
176K | |
共11个 | | 160K = 10个PAGE
PAGE | 160K | 可以容下所需的150K 视频缓冲区大小
(16K) | |
| |
-------|---------------|-------
| ... |
|---------------|
//*******************************************************
//* 2007.6.19
//*******************************************************
在/kernel/drivers/video/s3c2410fb.c 文件中的s3c2410fb_activate_var 函数中：
unsigned long VideoPhysicalTemp = fbi->screen_dma;
这里已经得到了framebuffer 在内存中的起始地址为VideoPhysicalTemp，地址数据位为A[30:0]。
new_regs.lcdcon1 = fbi->reg.lcdcon1 & ~LCD1_ENVID;
new_regs.lcdcon2 = (fbi->reg.lcdcon2 & ~LCD2_LINEVAL_MSK)
| LCD2_LINEVAL(var->yres - 1);
/* TFT LCD only ! */
new_regs.lcdcon3 = (fbi->reg.lcdcon3 & ~LCD3_HOZVAL_MSK)
| LCD3_HOZVAL(var->xres - 1);
new_regs.lcdcon4 = fbi->reg.lcdcon4;
new_regs.lcdcon5 = fbi->reg.lcdcon5;
LCDCON1 首先需要禁止视频输出才能进行寄存器的设置，然后对LCDCON2，LCDCON3 进行设置，主要是增加LINEVAL 和HOZVAL 这两个显示尺寸的参数。LCDCON4，LCDCON5 按原来配置设置。
LCDBANK[29:21] 为系统内存中视频缓冲区在系统存储器内的段地址的A[30:22]
LCDBASEU[20:0] 为LCD framebuffer 的起始地址的A[21:1]
LCDBASEL[20:0] 为LCD framebuffer 的结束地址的A[21:1]
OFFSIZE[21:11] 为某一行的第一个半字与前一行最后一个半字之间的距离（单位：半字数，即2个字节）
PAGEWIDTH[10:0] 为显示存储区的可见帧宽度（单位：半字数，即2个字节）
new_regs.lcdsaddr1 =
LCDADDR_BANK(((unsigned long)VideoPhysicalTemp >> 22))
| LCDADDR_BASEU(((unsigned long)VideoPhysicalTemp >> 1));
new_regs.lcdsaddr2 = LCDADDR_BASEL(
((unsigned long)VideoPhysicalTemp + (var->xres * 2 * (var>yres))) >> 1);
这里LCDADDR_BASEL 的计算方法为用framebuffer 在内存中的起始地址VideoPhysicalTemp，加上framebuffer 的大小（LCD屏的宽度 * LCD屏的高度 * 每像素的位数 / 每字节的位数），得到framebuffer 在内存中的结束地址，然后右移1位。
new_regs.lcdsaddr3 = LCDADDR_OFFSET(0) | (LCDADDR_PAGE(var->xres));
这里PAGEWIDTH 的计算方法为：LCD屏的宽度*每像素的位数/16位 （半字）。
问题：以上这些操作是否已经对DMA 控制器进行了设置？
我认为这里将framebuffer 在内存中的起始地址为VideoPhysicalTemp 变换后载入LCDADDR1，LCDADDR2，LCDADDR3 中就已经完成了对LCDCDMA 控制器的源数据的基地址设置，当打开LCDCON1 |= LCD1_ENVID; 后就可以由LCDCDMA 控制器自动从framebuffer 中传数据到LCD 屏幕了。
------------------------------------------------------------------------
在/kernel/drivers/video/s3c2410fb.c 文件中的xxx_stn_info 结构体初始化中：
lcdcon5 : LCD5_FRM565 | LCD5_INVVLINE | LCD5_INVVFRAME | LCD5_HWSWP | LCD5_PWREN,
INVVCLK ， INVLINE ， INVFRAME ， INVVD ：通过前面的时序图，我们知道，CPU的LCD控制器输出的时序默认是正脉冲，而LCD需要VSYNC（VFRAME）、VLINE（HSYNC）均为负脉冲，因此 INVLINE 和 INVFRAME 必须设为“1 ”，即选择反相输出。 INVVDEN ， INVPWREN ， INVLEND 的功能同前面的类似。
PWREN 为LCD电源使能控制。在CPU LCD控制器的输出信号中，有一个电源使能管脚LCD_PWREN，用来做为LCD屏电源的开关信号。
其中LCD5_HWSWP 一项，设置了LCD从内存中显示数据时，经过了半字交换。
16BPP Display
(BSWP = 0, HWSWP = 0)
D[31:16] D[15:0]
000H P1 P2
004H P3 P4
008H P5 P6
...
(BSWP = 0, HWSWP = 1)
D[31:16] D[15:0]
000H P2 P1
004H P4 P3
008H P6 P5
...
像素显示顺序如下：
P1 P2 P3 P4 P5 ...
例如：内存地址的数据为：0x11223344 （32位）
系统存储器采用Big-Endian（大端模式）存储格式，地址数据格式如下：
D[31:16] D[15:0]
00 01 02 03
00H 0x11 0x22 0x33 0x44
(0x1122) (0x3344)
04H ...
08H ...
则首先显示0x3344 的数据到第一个像素，然后再显示0x1122 到第二个像素。
系统存储器采用Little-Endian（小端模式）存储格式，地址数据格式如下：
D[31:16] D[15:0]
03 02 01 00
00H 0x11 0x22 0x33 0x44
(0x1122) (0x3344)
04H ...
08H ...
则首先显示0x3344 的数据到第一个像素，然后再显示0x1122 到第二个像素。
//*******************************************************
//* 2007.6.20
//*******************************************************
在/kernel/arch/arm/mm/consistent.c 文件中的consistent_alloc 函数中：
void *consistent_alloc(int gfp, size_t size, dma_addr_t *dma_handle)
{
...
virt = page_address(page);
*dma_handle = virt_to_bus(virt);
ret = __ioremap(virt_to_phys(virt), size, 0);
...
}
这里调用该函数来分配一段内存空间有两个返回值，一个返回值返回给了ret 指针，另一个返回值返回给了dma_handle 指针。virt_to_bus 和virt_to_phys 函数的调用可以参考下面的分析。经过分析这两个函数作用一样，都是将virt 这个虚拟地址转换为物理地址。所以返回给指针dma_handle 的是所分配内存的起始地址（物理地址）。__ioremap 函数的调用也可以参考下面的说明，该函数也返回所分配内存的起始地址（虚拟地址），不过是经过I/O 内存映射的，把物理地址转换为了虚拟地址。
这样一来就很清楚了，返回的framebuffer 的物理地址给了指针dma_handle，也就是fbi->map_dma，到fbi->screen_dma，再到 fbi->fb.fix.smem_start，最后到了指针VideoPhysicalTemp，这样写入到LCDADDR1，LCDADDR2 寄存器中的framebuffer 的地址其实都是物理地址。
而返回的framebuffer 的虚拟地址给了指针ret，也就是fbi->map_cpu，到fbi->screen_cpu，最后到了 display->screen_base（见/kernel/drivers/video/s3c2410fb.c 文件中的s3c2410fb_set_var 函数）。
------------------------------------------------------------------------
在/kernel/drivers/video/fbmem.c 文件中：
/**
* register_framebuffer - registers a frame buffer device
* @fb_info: frame buffer info structure
*
* Registers a frame buffer device @fb_info.
*
* Returns negative errno on error, or zero for success.
*
*/
int
register_framebuffer(struct fb_info *fb_info)
/**
* unregister_framebuffer - releases a frame buffer device
* @fb_info: frame buffer info structure
*
* Unregisters a frame buffer device @fb_info.
*
* Returns negative errno on error, or zero for success.
*
*/
int
unregister_framebuffer(struct fb_info *fb_info)
static int
fb_open(struct inode *inode, struct file *file)
static int
fb_release(struct inode *inode, struct file *file)
static ssize_t
fb_read(struct file *file, char *buf, size_t count, loff_t *ppos)
static ssize_t
fb_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
static int
fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
static int
fb_mmap(struct file *file, struct vm_area_struct * vma)
在该文件中包含了所有驱动LCD 的函数。在fb_read 和fb_write 这两个函数中，都对framebuffer 进行了操作。
fb_read 函数中：
char *base_addr;
base_addr = info->disp->screen_base;
count -= copy_to_user(buf, base_addr+p, count);
fb_write 函数中：
char *base_addr;
base_addr = info->disp->screen_base;
count -= copy_from_user(base_addr+p, buf, count);
所读写的framebuffer 的基地址就是disp->screen_base，也就是fbi->screen_cpu 所指的framebuffer 的虚拟地址。
从而得到：
framebuffer（虚拟地址）
|---------------|
| ... |
-------|---------------| <-- fbi->map_cpu
| 16K |
分配了 |---------------| <-- fbi->screen_cpu = display->screen_base
176K | |
共11个 | | 160K = 10个PAGE
PAGE | 160K | 可以容下所需的150K 视频缓冲区大小
(16K) | |
| |
-------|---------------|-------
| ... |
|---------------|
其中display->screen_base 结构在/kernel/include/video/fbcon.h 文件中定义。
得出结论，在分配framebuffer 时一共返回两个指针，虽然是同一块内存空间，但一个返回的是实际的物理地址，另一个返回的是经过地址转换的虚拟地址。在设置LCD 控制器中framebuffer 起始地址寄存器时，用的是所分配内存的物理地址；而当要对framebuffer 进行读写操作时，用的是同一块内存的物理地址所转换后的虚拟地址。由此可以知道，内核在对每个I/O 地址进行读写操作时用的都是经过转换的虚拟地址。
------------------------------------------------------------------------
------------------------------------------------------------------------
在/kernel/include/asm-arm/arch-s3c2410/memory.h 文件中：
/*
* Page offset: 3GB
*/
#define PAGE_OFFSET (0xc0000000UL)
#define PHYS_OFFSET (0x30000000UL)
/*
* We take advantage of the fact that physical and virtual address can be the
* saem. Thu NUMA code is handling the large holes that might exist between
* all memory banks.
*/
#define __virt_to_phys__is_a_macro
#define __phys_to_virt__is_a_macro
#define __virt_to_phys(x) ((x) - PAGE_OFFSET + PHYS_OFFSET)
#define __phys_to_virt(x) ((x) - PHYS_OFFSET + PAGE_OFFSET)
由此可见： 起始点地址 PHYS_OFFSET PAGE_OFFSET
| |
|--0x30000000--|------间隔------|
PHYS_OFFSET（物理地址起始点）： |--------------|...........................
|
|-----------0xc0000000----------|
PAGE_OFFSET（虚拟地址起始点）： |-------------------------------|..........
物理地址与虚拟地址的间隔为：PAGE_OFFSET - PHYS_OFFSET。这样一来，以上对物理地址和虚拟地址之间转换的宏定义就很好理解了。
虚拟地址转为物理地址宏：__virt_to_phys(x)
= (x) - (PAGE_OFFSET - PHYS_OFFSET) = (x) - PAGE_OFFSET + PHYS_OFFSET
物理地址转为虚拟地址宏：__phys_to_virt(x)
= (x) + (PAGE_OFFSET - PHYS_OFFSET) = (x) + PAGE_OFFSET - PHYS_OFFSET
内核虚拟地址和实际物理地址仅仅是相差一个偏移量（PAGE_OFFSET），可以很方便的将其转化为物理内存地址，同时内核也提供了virt_to_phys() 函数将内核虚拟空间中的物理影射区地址转化为物理地址。
/*
* Virtual view <-> DMA view memory address translations
* virt_to_bus: Used to translate the virtual address to an
* address suitable to be passed to set_dma_addr
* bus_to_virt: Used to convert an address for DMA operations
* to an address that the kernel can use.
*/
#define __virt_to_bus__is_a_macro
#define __bus_to_virt__is_a_macro
#define __virt_to_bus(x) __virt_to_phys(x)
#define __bus_to_virt(x) __phys_to_virt(x)
这里注意：__virt_to_bus(x) 就等于__virt_to_phys(x)
------------------------------------------------------------------------
在/kernel/include/asm-arm/memory.h 文件中：
/*
* These are *only* valid on the kernel direct mapped RAM memory.
*/
static inline unsigned long virt_to_phys(volatile void *x)
{
return __virt_to_phys((unsigned long)(x));
}
/*
* Virtual <-> DMA view memory address translations
* Again, these are *only* valid on the kernel direct mapped RAM
* memory.
*/
#define virt_to_bus(x) (__virt_to_bus((unsigned long)(x)))
由上面的分析可知：virt_to_bus(x) 和virt_to_phys(volatile void *x) 这两个函数调用的都是__virt_to_phys(x) 即((x) - PAGE_OFFSET + PHYS_OFFSET)。所以这两个调用都是将虚拟地址转换为了物理地址。
------------------------------------------------------------------------
在/kernel/arch/arm/mm/ioremap.c 文件中：
/*
* Remap an arbitrary physical address space into the kernel virtual
* address space. Needed when the kernel wants to access high addresses
* directly.
*
* NOTE! We need to allow non-page-aligned mappings too: we will obviously
* have to convert them into an offset in a page-aligned mapping, but the
* caller shouldn't need to know that small detail.
*
* 'flags' are the extra L_PTE_ flags that you want to specify for this
* mapping. See include/asm-arm/proc-armv/pgtable.h for more information.
*/
void * __ioremap(unsigned long phys_addr, size_t size, unsigned long flags)
ioremap 函数的作用是将physical address以及bus address映射为kernel的
virtual adrress。
ioremap 的作用是把I/O 内存地址（物理地址）映射到虚拟地址空间，使用之前需要分配I/O 内存区域。但是，ioremap 函数的内部实现并不是简单的（(IO的物理地址)-0x10000000 +0xE4000000）。所以，得到的虚拟地址可能是不同的。
因为linux 用的是页面映射机制，CPU 不能按物理地址来访问存储空间，而必须使用虚拟地址，所以必须反向的从物理地址出发找到一片虚存空间并建立起映射。
//*******************************************************
//* 2007.6.22
//*******************************************************
在/kernel/drivers/video/fbmem.c 文件中：
static struct file_operations fb_fops = {
owner: THIS_MODULE,
read: fb_read,
write: fb_write,
ioctl: fb_ioctl,
mmap: fb_mmap,
open: fb_open,
release: fb_release,
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
get_unmapped_area: get_fb_unmapped_area,
#endif
};
这个结构中定义了对LCD 所分配的framebuffer 进行读写操作，以及一些内存映射之类的函数，这些源函数都在该文件中。
/**
* register_framebuffer - registers a frame buffer device
* @fb_info: frame buffer info structure
*
* Registers a frame buffer device @fb_info.
*
* Returns negative errno on error, or zero for success.
*
*/
int
register_framebuffer(struct fb_info *fb_info)
这个是对LCD 的framebuffer 设备进行注册时调用到的注册函数，该函数在/kernel/drivers/video/s3c2410fb.c 文件的s3c2410fb_init 函数里的最后部分被调用。
fb_info->devfs_handle =
devfs_register (devfs_handle, name_buf, DEVFS_FL_DEFAULT,
FB_MAJOR, i, S_IFCHR | S_IRUGO | S_IWUGO,
&fb_fops, NULL);
在注册函数的最后部分，将前面的fb_fops 结构里的各个驱动函数的入口点传入到devfs_register()设备注册函数中。
//*******************************************************
//* 2007.6.26
//*******************************************************
上面这个devfs_register 函数（原型在/kernel/fs/devfs/base.c 文件中）执行前，在fbmem_init 函数中调用了函数：
devfs_handle = devfs_mk_dir (NULL, "fb", NULL);
在/kernel/fs/devfs/base.c 文件中：
/**
* devfs_mk_dir - Create a directory in the devfs namespace.
* @dir: The handle to the parent devfs directory entry. If this is %NULL the
* new name is relative to the root of the devfs.
* @name: The name of the entry.
* @info: An arbitrary pointer which will be associated with the entry.
*
* Use of this function is optional. The devfs_register() function
* will automatically create intermediate directories as needed. This function
* is provided for efficiency reasons, as it provides a handle to a directory.
* Returns a handle which may later be used in a call to devfs_unregister().
* On failure %NULL is returned.
*/
devfs_handle_t devfs_mk_dir (devfs_handle_t dir, const char *name, void *info)
这个devfs_mk_dir 函数会在设备文件系统中创建一个名为fb 的目录，并返回一个带有devfs 设备文件系统目录结构的数据结构变量devfs_handle。然后把这个数据结构作为下一步调用devfs_register 函数时的参数，该参数在调用设备文件系统注册清除函数devfs_unregister 时也要作为参数传入。
/**
* devfs_register - Register a device entry.
* @dir: The handle to the parent devfs directory entry. If this is %NULL the
* new name is relative to the root of the devfs.
* @name: The name of the entry.
* @flags: A set of bitwise-ORed flags (DEVFS_FL_*).
* @major: The major number. Not needed for regular files.
* @minor: The minor number. Not needed for regular files.
* @mode: The default file mode.
* @ops: The &file_operations or &block_device_operations structure.
* This must not be externally deallocated.
* @info: An arbitrary pointer which will be written to the @private_data
* field of the &file structure passed to the device driver. You can set
* this to whatever you like, and change it once the file is opened (the next
* file opened will not see this change).
*
* Returns a handle which may later be used in a call to devfs_unregister().
* On failure %NULL is returned.
*/
devfs_handle_t devfs_register (devfs_handle_t dir, const char *name,
unsigned int flags,
unsigned int major, unsigned int minor,
umode_t mode, void *ops, void *info)
函数devfs_register 是设备文件系统的主册函数，会在刚才创建的目录下再创建一个名为name 的设备文件节点。返回的devfs_handle_t 数据结构变量会在调用设备文件系统注册清除函数devfs_unregister 时作为参数传入。
fb_info->devfs_handle =
devfs_register (devfs_handle, name_buf, DEVFS_FL_DEFAULT,
FB_MAJOR, i, S_IFCHR | S_IRUGO | S_IWUGO,
&fb_fops, NULL);
调用该函数后，会在刚才创建的fb 目录下再创建一个名为0 （name_buf）的设备文件节点，并赋予相应的权限，以及主次设备号和file_operations 结构的函数入口。
这样一来，Linux 设备文件的创建，删除和目录层次等都由各设备驱动程序管理，再也不用手工创建设备文件节点了，再也不需要mknod 时查找对应的主设备号了，也不用依靠复杂的脚本来管理设备文件了。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nick0411/archive/2008/08/19/2796623.aspx