内核定时器和延时学习笔记

一、相关结构与函数

n         timer_list

linux内核用timer_list表征一个定时器。

struct timer_list {

        struct list_head entry;

        unsigned long expires;

        void (*function)(unsigned long);

        unsigned long data;

        struct timer_base_s *base;

};

n         初始化定时器

1.void init_timer(struct timer_list *timer);

entry.next=NULL;base有初值

2.TIMER_INITALLIZER（_function,_expires,_data）

该宏用于赋值定时器结构体的function,expires,data和base成员。

3.DEFINE_TIMER(_name,_function,_expires,_data)

4.setup_timer(struct timer_list *timer,

void(*function)(unsigned long),

unsigned long data)

              初始化function和data两个成员

n         增加定时器

              void add_timer(struct timer_list *timer)

n         删除定时器

int del_timer(struct timer_list *timer);

n         修改定时器的expires

int mod_timer(struct timer_list *timer,unsigned long expires);

二、LPC3250相关

/mach-lpc32xx/timer-lpc32xx.c

n         clk_is_sysclk_mainosc(void);

判断sysclk的时钟源是否是基于主振荡器，是返回1，否返回0

n         local_clk_get_pllrate_from_reg(u32 inputclk, u32 regval);

根据regal寄存器的值来设置PLL，从而得到pll的时钟输出（HCLK PLL）

n         clk_get_pclk_div(void)

从HCLK分频器中获得PCLK的分频值

n         static irqreturn_t lpc32xx_timer_interrupt(int irq, void *dev_id)

定时器0的中断处理函数，其中一部分功能是让系统灯闪烁。

n         setup_irq (IRQ_TIMER0, &lpc32xx_timer_irq);

静态注册irqaction结构体，request_irq( )，最终也是调用这个函数实现的。

三、经查资料了解到，以上所说的定时器是属于软件定时，这和嵌入式开发中实际的硬件定时器不一样的。网上说可以利用clocksource和clock_event_device两个结构体来和实际的硬件定时器做连接。

（来自《linux设备开发详解》）

#include <linux/module.h>

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/cdev.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/uaccess.h>

#include <linux/timer.h> /*包括timer.h头文件*/

#include <asm/atomic.h>

 

#define SECOND_MAJOR 252    /*预设的second的主设备号*/

 

static int second_major = SECOND_MAJOR;

 

/*second设备结构体*/

struct second_dev

{

  struct cdev cdev; /*cdev结构体*/

  atomic_t counter;/* 一共经历了多少秒？*/

  struct timer_list s_timer; /*设备要使用的定时器*/

};

 

struct second_dev *second_devp; /*设备结构体指针*/

 

/*定时器处理函数*/

static void second_timer_handle(unsigned long arg)

{

  mod_timer(&second_devp->s_timer,jiffies + HZ);

  atomic_inc(&second_devp->counter);

 

  printk(KERN_NOTICE "current jiffies is %ld\n", jiffies);

}

 

/*文件打开函数*/

int second_open(struct inode *inode, struct file *filp)

{

  /*初始化定时器*/

  init_timer(&second_devp->s_timer);

  second_devp->s_timer.function = &second_timer_handle;

  second_devp->s_timer.expires = jiffies + HZ;

 

  add_timer(&second_devp->s_timer); /*添加（注册）定时器*/

 

  atomic_set(&second_devp->counter,0); //计数清0

 

  return 0;

}

/*文件释放函数*/

int second_release(struct inode *inode, struct file *filp)

{

  del_timer(&second_devp->s_timer);

 

  return 0;

}

 

/*globalfifo读函数*/

static ssize_t second_read(struct file *filp, char __user *buf, size_t count,

  loff_t *ppos)

{ 

  int counter;

 

  counter = atomic_read(&second_devp->counter);

  if(put_user(counter, (int*)buf))

      return - EFAULT;

  else

      return sizeof(unsigned int); 

}

 

/*文件操作结构体*/

static const struct file_operations second_fops =

{

  .owner = THIS_MODULE,

  .open = second_open,

  .release = second_release,

  .read = second_read,

};

 

/*初始化并注册cdev*/

static void second_setup_cdev(struct second_dev *dev, int index)

{

  int err, devno = MKDEV(second_major, index);

 

  cdev_init(&dev->cdev, &second_fops);

  dev->cdev.owner = THIS_MODULE;

  dev->cdev.ops = &second_fops;

  err = cdev_add(&dev->cdev, devno, 1);

  if (err)

    printk(KERN_NOTICE "Error %d adding LED%d", err, index);

}

 

/*设备驱动模块加载函数*/

int second_init(void)

{

  int ret;

  dev_t devno = MKDEV(second_major, 0);

 

  /* 申请设备号*/

  if (second_major)

    ret = register_chrdev_region(devno, 1, "second");

  else  /* 动态申请设备号 */

  {

    ret = alloc_chrdev_region(&devno, 0, 1, "second");

    second_major = MAJOR(devno);

  }

  if (ret < 0)

    return ret;

  /* 动态申请设备结构体的内存*/

  second_devp = kmalloc(sizeof(struct second_dev), GFP_KERNEL);

  if (!second_devp)    /*申请失败*/

  {

    ret =  - ENOMEM;

    goto fail_malloc;

  }

 

  memset(second_devp, 0, sizeof(struct second_dev));

 

  second_setup_cdev(second_devp, 0);

 

  return 0;

 

  fail_malloc: unregister_chrdev_region(devno, 1);

}

 

/*模块卸载函数*/

void second_exit(void)

{

  cdev_del(&second_devp->cdev);   /*注销cdev*/

  kfree(second_devp);     /*释放设备结构体内存*/

  unregister_chrdev_region(MKDEV(second_major, 0), 1); /*释放设备号*/

}

 

MODULE_AUTHOR("Song Baohua");

MODULE_LICENSE("Dual BSD/GPL");

 

module_param(second_major, int, S_IRUGO);

 

module_init(second_init);

module_exit(second_exit);

 

 

 

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/time.h>

 

main()

{

  int fd;

  int counter = 0;

  int old_counter = 0;

 

  /*打开/dev/second设备文件*/

  fd = open("/dev/second", O_RDONLY);

  if (fd !=  - 1)

  {

    while (1)

    {

      read(fd,&counter, sizeof(unsigned int));//读目前经历的秒数

      if(counter!=old_counter)

      { 

          printf("seconds after open /dev/second :%d\n",counter);

          old_counter = counter;

      } 

    }    

  }

  else

  {

    printf("Device open failure\n");

  }

 

四、延时

n         短延时

void ndelay(unsigned long nsecs);

void udelay(unsigned long usecs);

void mdelay(unsigned long msecs);

以上延迟实现的原理本质上是忙等待。

对于ms级以上的延时可以使用以下函数

void msleep(unsigned int millisecs);

unsigned long msleep_interruptible(unsigned int millisecs);

void ssleep(unsigned int seconds);

n         长延时

unsigned long delay = jiffies + 100;

while(time_before(jiffies,delay));

 

unsigned long delay = jiffies +2*HZ

while(time_before(jiffies,delay));

n         睡着延时

schedule_timeout()可以使当前任务睡眠指定的jiffies之后重新被调度执行。msleep()和msleep_interruptible()在本质上都是依靠包含了schedule_timeout()实现的。

下面两个函数可以让进程在等待队列上睡眠，当超时发生时，进程被唤醒。

sleep_on_timeout(wait_queue_head_t *q,unsigned long timeout);

interruptible_sleep_on_timeou(wait_queue_head_t *q,unsigned long timeout);