//*******************************************************
//* 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
