原创 两个linux按键驱动之二 read（定时器去抖动）

/* 记录键值并唤醒等待队列 */
static void keyEvent(unsigned key)
{
    BUF_HEAD = key_info_tab[key].key_code;                  // 记录键值
    utukey_dev.head = INCBUF(utukey_dev.head, MAX_KEY_BUF); // 调整缓冲区头指针
    wake_up_interruptible(&(utukey_dev.wq));                // 唤醒等待队列
}

/* 驱动读函数 */
static ssize_t utukey_read(struct file *filp,char __user *buffer, size_t count, loff_t *ppos)
{
    unsigned int key_ret;
    unsigned long flags;
retry:
    if (utukey_dev.head != utukey_dev.tail)                         // 缓冲区有数据？
    {
        local_irq_save(flags);                                      // 进入临界区 ，关中断      
        key_ret = BUF_TAIL;                                         // 读出键值
        utukey_dev.tail = INCBUF(utukey_dev.tail, MAX_KEY_BUF);     // 调整缓冲区尾指针
        local_irq_restore(flags);                                   // 退出临界区，开中断       
        copy_to_user(buffer, &key_ret, sizeof(unsigned int));       // 拷贝到用户空间
        return sizeof(unsigned int);
    }else   // 缓冲区没数据
    {
        if (filp->f_flags & O_NONBLOCK)                             // 若采用非阻塞方式读取则返回错误
        {
            return -EAGAIN;
        }
        interruptible_sleep_on(&(utukey_dev.wq));                   // 使进程睡眠
        if (signal_pending(current))                               //在这里等中断
        {   // 如果是信号中断
            return -ERESTARTSYS;
        }
        goto retry;
    }
   
    return sizeof(unsigned int);
}

/* ioctl设备控制函数 */
static int utukey_ioctl(struct inode *inodep, struct file *filp, unsigned
  int cmd, unsigned long arg)
{
    unsigned long flags;
   
    switch (cmd)
    {
        case BUF_CLEAR:                             // 清除按键缓冲区
     local_irq_save(flags);     
        utukey_dev.head = utukey_dev.tail = 0;
        local_irq_restore(flags);
        
        printk(KERN_INFO "key buffer is cleared\n");     
        break;

        default:
        return  -EINVAL;
    }
    return 0;
}

/* 定时器中断回调函数 */
static void utukey_timer_callback(unsigned long data)  //定时器时间到了调用  参数代表哪个定时器
{
    int key = data;
    if (ISKEY_DOWN(key))                                    // 按键处于按下状态？
    {
        if (utukey_dev.key_status[key] == KEYSTATUS_DOWNX)  // 已经延时10ms，完成去抖动？
        {
            utukey_dev.key_status[key] = KEYSTATUS_DOWN;   
            key_timer[key].expires = jiffies + KEY_TIME_DELAY; 
            keyEvent(key);                                  // 记录键值，唤醒等待队列
            add_timer(&key_timer[key]);     //抬起按键去抖动延时
        }else
        {   // 已经完成去抖动延时
            key_timer[key].expires = jiffies + KEY_TIME_DELAY;
            add_timer(&key_timer[key]);
        }
    }else
    {   // 按键已经抬起
        utukey_dev.key_status[key] = KEYSTATUS_UP;
        enable_irq(key_info_tab[key].irq_no);
    }
}

static int utukey_open(struct inode *inode, struct file *filp)
{
    printk(KERN_NOTICE "utukey opened\n");
    return 0;
}

static int utukey_release(struct inode *inode, struct file *filp)
{
    printk(KERN_NOTICE "utukey released\n");
    return 0;
}

static const struct file_operations utukey_fops =
{
    .owner = THIS_MODULE,
    .read  = utukey_read,
    .ioctl = utukey_ioctl,
    .open  = utukey_open,
    .release = utukey_release,
};

/* 初始化并注册cdev */
static void utukey_setup_cdev(void)
{
    int err,devno = MKDEV(utukey_major,0);
    cdev_init(&utukey_dev.cdev,&utukey_fops);
    utukey_dev.cdev.owner = THIS_MODULE;
    utukey_dev.cdev.ops = &utukey_fops;
    err = cdev_add(&utukey_dev.cdev, devno, 1);
    if (err)
        printk(KERN_NOTICE "Error %d adding utukey", err);
}

/* 初始化函数 */
static int __init utukey_init(void)
{
    int result, i;
    dev_t devno = MKDEV(utukey_major,0);    // 用主次设备号生成设备号
    /* 申请中断 */
    result = request_irqs();
    if (result) {
        unregister_chrdev_region(devno,1);
        return result;
    }
    /* 申请设备号 */
    if (utukey_major)
        result = register_chrdev_region(devno, 1, DEVICE_NAME);
    else    /* 动态申请设备号 */
    {
        result = alloc_chrdev_region(&devno, 0, 1, DEVICE_NAME);
        utukey_major = MAJOR(devno);
        printk(KERN_INFO "Todo: mknod /dev/%s c %d 0\n", DEVICE_NAME, utukey_major);
    }

    if (result < 0)
        return result;

    /* 动态申请设备结构体的内存 */
    utukey_devp = kmalloc(sizeof(struct utukey_dev), GFP_KERNEL);
    if (!utukey_devp)    /* 申请失败 */
    {
        result = -ENOMEM;
        goto fail_malloc;
    }

    memset(utukey_devp, 0, sizeof(struct utukey_dev));      /* 清零分配的设备结构体内存 */
    utukey_setup_cdev();
    init_waitqueue_head(&(utukey_dev.wq));                  /* 初始化等待队列头 */
    utukey_dev.head = utukey_dev.tail = 0;

    /* 初始化按键状态 */   
    for(i = 0; i < KEY_NUM; i++)
    {
        utukey_dev.key_status = KEYSTATUS_UP;
    }