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 左右通道xx等级，设为0 表示左通道为低，右通道为高
IISMOD_FMT_MSB = 1<<4 串行接口格式，设为1 表示以{zg}位有效位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。后面的算法就不太清楚了，{zh1}算出系统输出时钟为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 左右通道xx等级，设为0 表示左通道为低，右通道为高
IISMOD_FMT_MSB = 1<<4 串行接口格式，设为1 表示以{zg}位有效位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 所分配的内存大小。{zh1}调用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;
{zh1}将环形缓冲区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。{zh1}在调用该函数指针所指的函数时将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);
{zh1}调用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 队列的进程，{zh1}再恢复IRQ 和FIQ 的中断使能状态。

down()操作可以理解为申请资源，up()操作可以理解为释放资源，因此，信号量实际表示的是资源的数量以及是否有进程正在等待。
在/kernel/include/asm-arm/semaphore.h 文件中：
struct semaphore {
    atomic_t count;int sleepers;wait_queue_head_t wait;#if WAITQUEUE_DEBUGlong __magic;#endif};
在semaphore 结构中，count 相当于资源计数，为正数或0 时表示可用资源数，-1 则表示没有空闲资源且有等待进程。而等待进程的数量并不关心。这种设计主要是考虑与信号量的原语相一致，当某个进程执行up 函数释放资源，点亮信号灯时，如果count 恢复到0，则表示尚有进程在等待该资源，因此执行唤醒操作。
   一个典型的down()-up()流程是这样的：down()-->count做原子减1操作，如果结果不小于0则表示成功申请，从down()中返回； 　
　　-->如果结果为负（实际上只可能是-1），则表示需要等待，则调用__down_fail()； 　
　　__down_fail()调用__down()，__down()用C代码实现，要求已不如down()和__down_fail()严格，在此作实际的等待。
在/kernel/include/asm-arm/semaphore.h 文件中：/** Note! This is subtle. We jump to wake people up only if* the semaphore was negative (== somebody was waiting on it).* The default case (no contention) will result in NO* jumps for both down() and up().*/static inline void up(struct semaphore * sem){#if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);#endif__up_op(sem, __up_wakeup);}在/kernel/include/asm-arm/proc-armo/locks.h 文件中：#define __up_op(ptr,wake) \({     \__asm__ __volatile__ ( \"@ up_op\n" \" mov ip, pc\n" \" orr lr, ip, #0x08000000\n"   \" teqp lr, #0\n" \" ldr lr, [%0]\n" \" and ip, ip, #0x0c000003\n"   \" adds lr, lr, #1\n" \" str lr, [%0]\n" \" orrle ip, ip, #0x80000000 @ set N - should this be mi ??? DAG ! \n" \" teqp ip, #0\n" \" movmi ip, %0\n" \" blmi " SYMBOL_NAME_STR(wake)   \:     \: "r" (ptr) \: "ip", "lr", "cc"); \})用ARM 汇编指令完成对信号量加一计数后，调用了wake 为标号的子程序，即传入的参数__up_wakeup 标号所在的子程序。在/kernel/arch/arm/kernel/semaphore.c 文件中：__up_wakeup:     \n\stmfd sp!, {r0 - r3, lr}   \n\mov r0, ip \n\bl __up \n\ldmfd sp!, {r0 - r3, pc}^   \n\这里又调用了__up 函数。void __up(struct semaphore *sem){wake_up(&sem->wait);}{zh1}在该函数中调用了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; {zh1}调用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的倍数。这样屏蔽掉所要写入字节数的{zh1}2位就是4的倍数了。
               while (count > 0)
             {     若要写入的字节数大于0，则进入一个while 大循环。
                 audio_buf_t *b = s->buf; 在大循环一开始就定义了一个audio_buf_t 结构的指针变量指向前面定义的输出音频缓冲区里的当前缓冲区指针。
                 if (file->f_flags & O_NONBLOCK)
                {
                   ret = -EAGAIN;
                   if (down_trylock(&b->sem))
                      break;
                } else
               {
                  ret = -ERESTARTSYS;
                  if (down_interruptible(&b->sem))
                     break;
              }
-------------------------------------------------------------------------------------------------------------------------------
      然后根据file->f_flags 与上O_NONBLOCK 值来进行判断。O_NONBLOCK 值表示采用非阻塞的文件IO方法，如果O_NONBLOCK 标记被设置，文件描述符将不被阻塞而被直接返回替代。一个例子是打开tty。如果用户不在终端调用里输入任何东西，read 将被阻塞，直到用户有输入，当O_NONBLOCK 标记被设置，read 调用将直接返回设置到EAGAIN 的值。这里若应用程序在调用write 函数时加入了O_NONBLOCK 参数，则会调用down_trylock 函数来试着获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，表示不能获得信号量sem，返回值为非0值。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
在/kernel/include/asm-arm/semaphore.h 文件中：
         static inline int down_trylock(struct semaphore *sem)
          {
             #if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);
              #endif
             return __down_op_ret(sem, __down_trylock_failed);
        }
   在/kernel/include/asm-arm/proc-armo/locks.h 文件中：
        #define __down_op_ret(ptr,fail) \
         ({\
            unsigned int result; \
              __asm__ __volatile__ ( \
            " @ down_op_ret\n" \
            " mov ip, pc\n" \
            " orr lr, ip, #0x08000000\n"   \
            " teqp lr, #0\n" \
            " ldr lr, [%1]\n" \
            " and ip, ip, #0x0c000003\n"   \
            " subs lr, lr, #1\n" \
            " str lr, [%1]\n" \
            " orrmi ip, ip, #0x80000000 @ set N\n" \
            " teqp ip, #0\n" \
            " movmi ip, %1\n" \
            " movpl ip, #0\n" \
            " blmi " SYMBOL_NAME_STR(fail) "\n" \
            " mov %0, ip" \
            : "=&r" (result) \
            : "r" (ptr) \
            : "ip", "lr", "cc"); \
            result;     \
         })用ARM 汇编指令完成对信号量减一计数后，调用了fail 为标号的子程序，即传入的参数__down_trylock_failed 标号所在的子程序。       在/kernel/arch/arm/kernel/semaphore.c 文件中：
             __down_trylock_failed: \n\
             stmfd sp!, {r0 - r3, lr}   \n\
             mov r0, ip \n\
             bl __down_trylock \n\
             mov ip, r0 \n\
             ldmfd sp!, {r0 - r3, pc}^   \n\这里又调用了__down_trylock 函数。
/** Trylock failed - make sure we correct for* having decremented the count.** We could have done the trylock with a* single "cmpxchg" 我without failure cases,* but then it wouldn't work on a 386.*/
     int __down_trylock(struct semaphore * sem)
     {
          int sleepers;
          unsigned long flags;
         spin_lock_irqsave(&semaphore_lock, flags);
         sleepers = sem->sleepers + 1;
         sem->sleepers = 0; /*   * Add "everybody else" and us into it. They aren't   * playing, because we own the spinlock.   */
        if (!atomic_add_negative(sleepers, &sem->count))  
           wake_up(&sem->wait);
           spin_unlock_irqrestore(&semaphore_lock, flags);
           return 1;
     }这里不再进一步深入说明。 若应用程序在调用write 函数时没有加入了O_NONBLOCK 参数，即表示采用阻塞的文件IO方式，则会调用down_interruptible 函数来获得信号量sem。该函数将把sem 的值减1，如果信号量sem 的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。
    down_interruptible 函数能被信号打断，因此该函数有返回值来区分是正常返回还是被信号中断，如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。该函数与相关函数在一篇《Linux内核的同步机制》中有详细说明。
       在/kernel/include/asm-arm/semaphore.h 文件中：
       /** This is ugly, but we want the default case to fall through.* "__down_interruptible" is the actual routine that waits...*/
     static inline int down_interruptible (struct semaphore * sem)
       {
            #if WAITQUEUE_DEBUGCHECK_MAGIC(sem->__magic);
            #endif
            return __down_op_ret(sem, __down_interruptible_failed);
      }
      函数__down_op_ret 在上面已经有过说明。
    在/kernel/arch/arm/kernel/semaphore.c 文件中：
      __down_interruptible_failed: \n\
        stmfd sp!, {r0 - r3, lr}   \n\
        mov r0, ip \n\
        bl __down_interruptible   \n\
        mov ip, r0 \n\
        ldmfd sp!, {r0 - r3, pc}^   \n\
         这里又调用了__down_interruptible 函数。
        int __down_interruptible(struct semaphore * sem)这里不再进一步深入说明。