INUX内核延时研究与函数代码分析

有时驱动程序需要非常短的延迟来与硬件同步。此时，使用jiffies值无法达到目的。这时就要用内核函数udelay和mdelay。u表示希腊字母“mu”（m），它代表“微”。它们的原型如下：
#include  
void udelay(unsigned long usecs); //软件循环延迟指定数目的微秒数
void mdelay(unsigned long msecs); //使用 udelay 做循环

该函数在绝大多数体系结构上是作为内联函数编译的。udelay函数里要用到BogoMips值：它的循环基于整数值loops_per_second，这个值是在引导阶段计算BogoMips时得到的结果。

udelay函数只能用于获取较短的时间延迟，因为loops_per_second值的精度只有8位，所以，当计算更长的延迟时会积累出相当大的误差。尽管最大能允许的延迟将近1s（因为更长的延迟就要溢出），推荐的udelay函数参数最大值是取1000us（1ms）。当延迟大于11ms时可以使用函数mdelay。许多驱动程序需要将任务延迟到以后处理，但又不想借助中断。Linux为此提供了三种方法：任务队列、tasklet和内核定时器。

要特别注意的是udelay是个忙等待函数，在延迟的时间段内无法运行其他的任务。源码见头文件。 
 
目前内核不支持大于1微秒而小于1个时钟滴答的延迟，但这不是个问题，因为延迟是给硬件或者人去识别的。百分之一秒的时间间隔对人来说延迟精度足够了，而1毫秒对硬件来说延迟时间也足够长。如果你真的需要其间的延迟间隔，你只要建立一个连续执行udelay(1000)函数的循环。

linux内核延时函数代码示例： 
1、#include
void do_gettimeofday(struct timeval *tv)
{
 unsigned long flags;
 unsigned long usec, sec;

 read_lock_irqsave(&xtime_lock, flags);
 sec = xtime.tv_sec;
 usec = xtime.tv_usec + do_gettimeoffset();
 read_unlock_irqrestore(&xtime_lock, flags);

 while (usec >= 1000000) {
  usec -= 1000000;
  sec++;
 }
 tv->tv_sec = sec;
 tv->tv_usec = usec;
}

void MyDelay(unsigned long delay)
{
 struct timeval tv;
 do_gettimeofday(&tv)
 unsigned long start = tv.tv_usec;//unsigned long start = tv.tv_sec;
 while(tv.tv_usec - start     do_gettimeofday(&tv)
}

2、如果驱动程序使用等待队列等待某个事件，而你又想确保在一段时间后运行该驱动程序时
extern inline long sleep_on_timeout(wait_queue_head_t *q, signed long timeout)
{
    signed long early = 0;
        
    current->timeout = jiffies + timeout;
    sleep_on (q);
    if (current->timeout > 0) {
        early = current->timeout - jiffies;
        current->timeout = 0;
    }
    return early;
}

extern inline long interruptible_sleep_on_timeout(wait_queue_head_t *q,
                signed long timeout)
{
    signed long early = 0;
        
    current->timeout = jiffies + timeout;
    interruptible_sleep_on (q);
    if (current->timeout > 0) {
        early = current->timeout - jiffies;
        current->timeout = 0;
    }
    return early;
}

3.无需等待其他事件，则可直接延时等待
extern inline void schedule_timeout(int timeout)
{
    current->timeout = jiffies + timeout;
    current->state = TASK_INTERRUPTIBLE;
    schedule();
    current->timeout = 0;
}
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(jit_delay*HZ);

4 非常短的延时与硬件同步 udelay推荐最大1000us
#include

void __delay(int loops)
{
 long long dummy;
 __asm__ __volatile__("gettr " __t0 ", %1\n\t"
        "_pta 4, " __t0 "\n\t"
        "addi %0, -1, %0\n\t"
        "bne %0, r63, " __t0 "\n\t"
        "ptabs %1, " __t0 "\n\t":"=r"(loops),
        "=r"(dummy)
        :"0"(loops));
}

void __udelay(unsigned long long usecs, unsigned long lpj)
{
 usecs *= (((unsigned long long) HZ << 32) / 1000000) * lpj;
 __delay((long long) usecs >> 32);
}

#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