7、內核定時器

 

在測試按鍵驅動時，可能會出現按鍵抖動的問題，也就是按下或松開一次，卻進入了多次中斷程序。如下圖所示：

產生這個問題是由於現實中的高電平轉成低電平脈沖過程是機械式開關，可能會有機械的抖動導致多次觸發中斷

針對這個問題，我們可以采用延時檢測來防止抖動，這就是這節要談論的內核定時器，內核定時器基於軟中斷，因此在處理函數中不允許睡眠

 

 

一、內核定時器的使用方法

定時器系列函數使用方法如下：

struct timer_list timer;    // 定義定時器

init_timer(&timer);            // 初始化定時器，初始化timer成員

timer.function = timer_func;        // 設置定時器觸發函數
或
setup_timer(&timer, timer_func, (unsigned long)arg);

/* 函數參數中jiffies表示表示當前的系統時鍾中斷總次數
 * 一秒內時鍾中斷的次數等於Hz
 * jiffies + HZ / 100表示此定時器的間隔時間為0.01秒，也就是10ms
 */
mod_timer(&timer, jiffies + HZ / 100);    // 設置定時器間隔時間

add_timer(&timer);        // 開始定時器

del_timer(&timer);        // 刪除定時器

 

代碼中的timer_func()函數需要執行的就是之前的中斷程序中的代碼，現在的中斷程序用於設置定時器間隔時間來進行延時操作

 

示例代碼如下：

struct key_device {
    ...
    struct timer_list key_timer;    // 定義定時器
};

static void key_timer_func(unsigned long arg)
{
    struct key_device* dev = (struct key_device *)arg;
    ...        /* 之前中斷程序的代碼 */
}

static irqreturn_t key_interrupt(int irq, void *dev_id)
{
    dev->pindesc = (struct pin_desc *)dev_id;

    mod_timer(&dev->key_timer, jiffies + HZ / 100);    // 設置延時

    return IRQ_HANDLED;
}

static int key_open(struct inode *nodep, struct file *filp)
{
    struct key_device *dev = container_of(nodep->i_cdev, struct key_device, cdev);
    ...

    init_timer(&dev->key_timer);    // 初始化定時器，初始化timer成員
    setup_timer(&dev->key_timer, key_timer_func, (unsigned long)dev);
    add_timer(&dev->key_timer);        // 啟動定時器

    return 0;
}

static int key_release(struct inode *nodep, struct file *filp)
{
    struct key_device *dev = filp->private_data;
    ...
    del_timer(&dev->key_timer);        // 刪除定時器
}

示例代碼中需要注意的是：在key_open()函數中並沒有設置定時器的間隔時間，而是在中斷中設置的

這是因為我們是在中斷中設置延時防止抖動；在其他函數中並不需要延時，直接啟動定時器即可

 

 

二、完整代碼

key源代碼：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/timer.h>
#include <linux/gpio.h>
#include <linux/sched.h>
#include <linux/mutex.h>

#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>

#include <mach/gpio.h>

#define KEY_MAJOR        255

struct pin_desc {
    int gpio;
    int val;
    char *name;
};

struct key_device {
    struct cdev cdev;
    wait_queue_head_t r_head;
    wait_queue_head_t w_head;
    struct mutex lock;
    struct fasync_struct *fasync;
    struct timer_list key_timer;
    struct pin_desc *pindesc;
};

static struct pin_desc desc[4] = {
    { EXYNOS4_GPX3(2), 0x01, "KEY0" },
    { EXYNOS4_GPX3(3), 0x02, "KEY1" },
    { EXYNOS4_GPX3(4), 0x03, "KEY2" },
    { EXYNOS4_GPX3(5), 0x04, "KEY3" },
};

static int g_major = KEY_MAJOR;
module_param(g_major, int, S_IRUGO);

static struct key_device*    dev;
static struct class*        scls;
static struct device*        sdev;
static unsigned char        key_val;

static void key_timer_func(unsigned long arg)
{
    struct key_device* dev = (struct key_device *)arg;

    unsigned int tmp;

    tmp = gpio_get_value(dev->pindesc->gpio);

    /* active low */
    printk(KERN_DEBUG "KEY %d: %08x\n", dev->pindesc->val, tmp);

    if (tmp)
        key_val = dev->pindesc->val;
    else
        key_val = dev->pindesc->val | 0x80;

    set_current_state(TASK_RUNNING);
}

static irqreturn_t key_interrupt(int irq, void *dev_id)
{
    dev->pindesc = (struct pin_desc *)dev_id;

    mod_timer(&dev->key_timer, jiffies + HZ / 100);

    return IRQ_HANDLED;
}

static ssize_t key_read(struct file *filp, char __user *buf, size_t len, loff_t * loff)
{
    struct key_device *dev = filp->private_data;

    // 聲明等待隊列
    DECLARE_WAITQUEUE(rwait, current);    
    mutex_lock(&dev->lock);        // 上鎖
    add_wait_queue(&dev->r_head, &rwait);

    // 休眠
    __set_current_state(TASK_INTERRUPTIBLE);
    mutex_unlock(&dev->lock);    // 解鎖
    schedule();

    // 有數據
    kill_fasync(&dev->fasync, SIGIO, POLL_IN);

    mutex_lock(&dev->lock);        // 上鎖
    copy_to_user(buf, &key_val, 1);
    mutex_unlock(&dev->lock);    // 解鎖

    remove_wait_queue(&dev->r_head, &rwait);
    set_current_state(TASK_RUNNING);

    return 1;
}

static int key_open(struct inode *nodep, struct file *filp)
{
    struct key_device *dev = container_of(nodep->i_cdev, struct key_device, cdev);
    // 放入私有數據中
    filp->private_data = dev;

    int irq;
    int i, err = 0;

    for (i = 0; i < ARRAY_SIZE(desc); i++) {
        if (!desc[i].gpio)
            continue;

        irq = gpio_to_irq(desc[i].gpio);
        err = request_irq(irq, key_interrupt, IRQ_TYPE_EDGE_BOTH, 
                desc[i].name, (void *)&desc[i]);
        if (err)
            break;
    }
    
    if (err) {
        i--;
        for (; i >= 0; i--) {
            if (!desc[i].gpio)
                continue;

            irq = gpio_to_irq(desc[i].gpio);
            free_irq(irq, (void *)&desc[i]);
        }
        return -EBUSY;
    }
    
    init_waitqueue_head(&dev->r_head);
    mutex_init(&dev->lock);        // 初始化

    init_timer(&dev->key_timer);
    setup_timer(&dev->key_timer, key_timer_func, (unsigned long)dev);
    add_timer(&dev->key_timer);

    return 0;
}

static int key_fasync(int fd, struct file *filp, int mode)
{
    struct key_device *dev = filp->private_data;

    return fasync_helper(fd, filp, mode, &dev->fasync);
}

static int key_release(struct inode *nodep, struct file *filp)
{
    struct key_device *dev = filp->private_data;

    key_fasync(-1, filp, 0);
    
    // 釋放中斷
    int irq, i;

    for (i = 0; i < ARRAY_SIZE(desc); i++) {
        if (!desc[i].gpio)
            continue;

        irq = gpio_to_irq(desc[i].gpio);
        free_irq(irq, (void *)&desc[i]);
    }

    del_timer(&dev->key_timer);

    return 0;
}

static struct file_operations key_fops = {
    .owner    = THIS_MODULE,
    .read    = key_read,
    .open        = key_open,
    .fasync        = key_fasync,
    .release    = key_release,
};

static int keys_init(void)
{
    int ret;
    int devt;
    if (g_major) {
        devt = MKDEV(g_major, 0);
        ret = register_chrdev_region(devt, 1, "key");
    }
    else {
        ret = alloc_chrdev_region(&devt, 0, 1, "key");
        g_major = MAJOR(devt);
    }

    if (ret)
        return ret;

    dev = kzalloc(sizeof(struct key_device), GFP_KERNEL);
    if (!dev) {
        ret = -ENOMEM;
        goto fail_alloc;
    }

    cdev_init(&dev->cdev, &key_fops);
    ret = cdev_add(&dev->cdev, devt, 1);
    if (ret)
        return ret;

    scls = class_create(THIS_MODULE, "key");
    sdev = device_create(scls, NULL, devt, NULL, "key");

    return 0;

fail_alloc:
    unregister_chrdev_region(devt, 1);

    return ret;
}

static void keys_exit(void)
{
    dev_t devt = MKDEV(g_major, 0);

    device_destroy(scls, devt);
    class_destroy(scls);

    cdev_del(&(dev->cdev));
    kfree(dev);

    unregister_chrdev_region(devt, 1);
}

module_init(keys_init);
module_exit(keys_exit);

MODULE_LICENSE("GPL");

Makefile：

KERN_DIR = /work/tiny4412/tools/linux-3.5

all:
    make -C $(KERN_DIR) M=`pwd` modules 

clean:
    make -C $(KERN_DIR) M=`pwd` modules clean
    rm -rf modules.order

obj-m    += key.o

測試文件：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>

int fd;

static void sig_handler(int signo)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val = 0x%x\n", key_val);
}

int main(int argc, char** argv)
{
    int oflags = 0;
    
    signal(SIGIO, sig_handler);
    
    fd = open("/dev/key", O_RDWR);
    if (fd < 0) {
        printf("can't open /dev/key\n");
        return -1;
    }
    
    fcntl(fd, F_SETOWN, getpid());
    oflags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, oflags | FASYNC);

    while (1) {
        sleep(1000);
    }
    
    close(fd);

    return 0;
}

 

源代碼中59、60行代碼（如下），用於防止open()函數中add_timer()時進入timer函數

if (dev->pindesc == NULL)
    return;

 

 

下一章  8、輸入子系統