码迷，mamicode.com
首页 > 其他好文 > 详细

入门级的按键驱动——按键驱动笔记之poll机制-异步通知-同步互斥阻塞-定时器防抖

时间：2015-08-20 22:16:30      阅读：201      评论：0      收藏：0      [点我收藏+]

标签：

文章对应视频的第12课，第5、6、7、8节。

在这之前还有查询方式的驱动编写，中断方式的驱动编写，这篇文章中暂时没有这些类容。但这篇文章是以这些为基础写的，前面的内容有空补上。

 

按键驱动——按下按键，打印键值：

目录

  1. 概要
  2. poll机制
  3. 异步通知
  4. 同步互斥阻塞
  5. 定时器防抖

概要：

查询方式: 12-3
缺点：占用CPU99%的资源。
中断方式：12-4
缺点：调用read函数后如果没有按键按下，该函数永远不会结束，一直在等待按键按下。
优点：使用到了休眠机制，占用cpu资源极少。
poll机制: 12-5
优点：可以设置超时时间，来结束read函数。
缺点：需要主动去调用read函数来获取按键值。
同步互斥阻塞：12-7
优点：引入了原子操作、信号量，使得按键驱动同一时间只能有一个应用使用
异步通知：12-6
优点：当有按键按下时，可以主动通知应用程序，这样就不不需要应用程序主动调用read函数来获取按键值。
定时器防抖: 12-8
引入了系统中断xxx,每隔10ms xxx变量将自动加1。


poll机制：

目标：测试程序调用poll，如果5秒内有按键按下，则返回键值，如果没有按键按下则退出程序。
/********/
poll机制：
步骤：
/********/
一、将third全部替换成tourth。
二、添加poll机制需要的头文件：
#include <linux/poll.h>
三、在file_operations结构中增加poll函数：
.poll = forth_drv_poll,
四、编写poll函数：
static unsigned forth_drv_poll(struct file *file, poll_table *wait)
{
unsigned int mask = 0;
poll_wait(file, &button_waitq, wait); // 不会立即休眠

if (ev_press)
mask |= POLLIN | POLLRDNORM;

return mask;
}
完整测试程序请看下面：polldrv

技术分享 
/**************************************************************/
/****    polldrv    ***************************************/
/**************************************************************/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>


static struct class *forthdrv_class;
static struct class_device    *forthdrv_class_dev;


static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
static volatile int ev_press = 0;


struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};


/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};


/*
  * 确定按键值
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    struct pin_desc * pindesc = (struct pin_desc *)dev_id;
    unsigned int pinval;
    
    pinval = s3c2410_gpio_getpin(pindesc->pin);

    if (pinval)
    {
        /* 松开 */
        key_val = 0x80 | pindesc->key_val;
    }
    else
    {
        /* 按下 */
        key_val = pindesc->key_val;
    }

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */

    
    return IRQ_RETVAL(IRQ_HANDLED);
}

static int forth_drv_open(struct inode *inode, struct file *file)
{
    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
    request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
    request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    

    return 0;
}

ssize_t forth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    /* 如果没有按键动作, 休眠 */
    wait_event_interruptible(button_waitq, ev_press);

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;
    
    return 1;
}


int forth_drv_close(struct inode *inode, struct file *file)
{
    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11, &pins_desc[2]);
    free_irq(IRQ_EINT19, &pins_desc[3]);
    return 0;
}

static unsigned forth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (ev_press)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}



static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  forth_drv_open,     
    .read     =    forth_drv_read,       
    .release =  forth_drv_close,
    .poll    =  forth_drv_poll,
};


int major;
static int forth_drv_init(void)
{
    major = register_chrdev(0, "forth_drv", &sencod_drv_fops);

    forthdrv_class = class_create(THIS_MODULE, "forth_drv");

    forthdrv_class_dev = class_device_create(forthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

    return 0;
}

static void forth_drv_exit(void)
{
    unregister_chrdev(major, "forth_drv");
    class_device_unregister(forthdrv_class_dev);
    class_destroy(forthdrv_class);
    return 0;
}


module_init(forth_drv_init);

module_exit(forth_drv_exit);

MODULE_LICENSE("GPL");
polldrv

 

测试程序：
1.在thirtest中修改，增加头文件 #include <poll.h>
2.在虚拟机中输入 man poll ,查看poll 的用法。
3.使用此函数调用驱动程序中的poll函数：int poll(struct pollfd *fds, nfds_t nfds, int timeout);
返回值: 0表示有超时。
参数一：pollfd结构，用来保存需要查询的文件、参数。不太懂。
struct pollfd {
int fd; /* file descriptor */
short events; /* requested events */
short revents; /* returned events */
};
参数二：查询的文件数，fds为一个结构数组，存放需要查询的文件，本程序中为1，
参数三：超时时间，单位毫秒 5000ms=5s
4.定义上述函数的返回值、第一个参数struct pollfd *fds，并设置pollfd结构：
int ret; //存放返回值
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLIN; //该事件的含义是：There is data to read.(有要读取的数据)
5.调用poll:
ret = poll(fds, 1, 5000);
6.判断是否有超时，并打印相关数据：
if (ret == 0)
{
printf("time out\n");
}
else
{
read(fd, &key_val, 1);
printf("key_val = 0x%x\n", key_val);
}
完整测试程序请看下面：polltest

技术分享 
/**************************************************************/
/****    polltest    ***************************************/
/**************************************************************/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>


/* forthdrvtest 
  */
int main(int argc, char **argv)
{
    int fd;
    unsigned char key_val;
    int ret;

    struct pollfd fds[1];
    
    fd = open("/dev/buttons", O_RDWR);
    if (fd < 0)
    {
        printf("can‘t open!\n");
    }

    fds[0].fd     = fd;
    fds[0].events = POLLIN;
    while (1)
    {
        ret = poll(fds, 1, 5000);
        if (ret == 0)
        {
            printf("time out\n");
        }
        else
        {
            read(fd, &key_val, 1);
            printf("key_val = 0x%x\n", key_val);
        }
    }
    
    return 0;
}
polltest


异步通知：
目标：当按键按下时，驱动程序通知应用程序，
1、应用程序注册信号处理函数。
2、谁发、发给谁：驱动发信号给应用程序。
3、应用告诉驱动应用的PID是多少。
4、怎么发;kill_fasyn
/**************************/
异步通知 信号（signal）：
步骤：
/**************************/
发信号简介：
kill -9 PID(进程号)可以杀死某个进程
发送方 内容 接收方
写一个进程通信的例子：
用 man signal 查看signal怎么使用
#include <signal.h>
void my_signal_fun(int signum)
{
static int cnt = 0 ;
printf("signal = %d , %d time\n" , signum , ++cnt);
}

int main(int argc , char **argv)
{
signal(SIGUSR1, my_signal_fun);
while (1)
{
sleep(1000);
}
return 0;
}

编译：arm-linux-gcc -o signal signal.c
./signal //运行
PS //查看进程号
kill -USR1 xxx
kill -10 xxx

异步通知的要点：
1.注册信号处理函数
2.谁发
3.发给谁
4.怎么发
转化成代码:
1、应用程序注册信号处理函数。
2、谁发、发给谁：驱动发信号给应用程序。
3、应用程序告诉驱动应用程序的PID是多少。
4、怎么发：kill_fasync

驱动编写：
1、在forth_drv的基础上编写，将forth替换成fifth。
2、在file_operations结构中增加一个函数：
.fasync = fifth_drv_fasync,
3、定义fasync_struct结构体
static struct fasync_struct *button_async;
4、实现该函数，当应用程序调用fcntl(fd，F_SETFL, oflags | FASYNC );时，内核就得到应用程序的PID。
当标志位发生改变时此函数将被调用，初始化fasync_struct结构体，该结构体中有PID信息。（好像是这样的，不明白）
static int fifth_drv_fasync (int fd, struct file *filp, int on)
{
printk("driver: fifth_drv_fasync\n");
return fasync_helper (fd, filp, on, &button_async);
}
5、在中断处理函数中发送信号给应用程序：
kill_fasync (&button_async, SIGIO, POLL_IN);

完整代码请看下面：fifth_drv.c

技术分享 
/**************************************************************/
/****    fifth_drv.c：    ***************************************/
/**************************************************************/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>

static struct class *fifthdrv_class;
static struct class_device    *fifthdrv_class_dev;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，fifth_drv_read将它清0 */
static volatile int ev_press = 0;

static struct fasync_struct *button_async;

struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};

/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};

/*
  * 确定按键值
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    struct pin_desc * pindesc = (struct pin_desc *)dev_id;
    unsigned int pinval;
    
    pinval = s3c2410_gpio_getpin(pindesc->pin);

    if (pinval)
    {
        /* 松开 */
        key_val = 0x80 | pindesc->key_val;
    }
    else
    {
        /* 按下 */
        key_val = pindesc->key_val;
    }

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    
    kill_fasync (&button_async, SIGIO, POLL_IN);
    
    return IRQ_RETVAL(IRQ_HANDLED);
}

static int fifth_drv_open(struct inode *inode, struct file *file)
{
    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
    request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
    request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    

    return 0;
}

ssize_t fifth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    /* 如果没有按键动作, 休眠 */
    wait_event_interruptible(button_waitq, ev_press);

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;
    
    return 1;
}

int fifth_drv_close(struct inode *inode, struct file *file)
{
    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11, &pins_desc[2]);
    free_irq(IRQ_EINT19, &pins_desc[3]);
    return 0;
}

static unsigned fifth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (ev_press)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}

static int fifth_drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: fifth_drv_fasync\n");
    return fasync_helper (fd, filp, on, &button_async);
}

static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  fifth_drv_open,     
    .read     =    fifth_drv_read,       
    .release =  fifth_drv_close,
    .poll    =  fifth_drv_poll,
    .fasync     =  fifth_drv_fasync,
};


int major;
static int fifth_drv_init(void)
{
    major = register_chrdev(0, "fifth_drv", &sencod_drv_fops);

    fifthdrv_class = class_create(THIS_MODULE, "fifth_drv");

    fifthdrv_class_dev = class_device_create(fifthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

    return 0;
}

static void fifth_drv_exit(void)
{
    unregister_chrdev(major, "fifth_drv");
    class_device_unregister(fifthdrv_class_dev);
    class_destroy(fifthdrv_class);
    return 0;
}

module_init(fifth_drv_init);
module_exit(fifth_drv_exit);
MODULE_LICENSE("GPL");
fifth_drv.c

 

测试程序请看下面：fifth_test.c

技术分享 
/**************************************************************/
/****    fifth_test.c：    ***************************************/
/**************************************************************/

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

/* fifthdrvtest 
  */
int fd;
void my_signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
    unsigned char key_val;
    int ret;
    int Oflags;

    signal(SIGIO, my_signal_fun);
    
    fd = open("/dev/buttons", O_RDWR);
    if (fd < 0)
    {
        printf("can‘t open!\n");
    }

    fcntl(fd, F_SETOWN, getpid());
    
    Oflags = fcntl(fd, F_GETFL); 
    
    fcntl(fd, F_SETFL, Oflags | FASYNC);


    while (1)
    {
        sleep(1000);
    }    
    return 0;
}
//关于 fcntl 可以参考： http://www.cnblogs.com/lonelycatcher/archive/2011/12/22/2297349.html
//我没看明白
fifth_test.c

 

原子操作、信号量
/********************/
同步互斥阻塞：12-7：
原子操作、信号量
步骤：
/********************/
原子相关：
原子操作的相关函数：
atomic_t v=ATOMIC_INIT(1); //定义原子变量v并初始化为1
atomic_read(atomic_t *v); //返回原子变量的值/
void atomic_inc(&v)； //自增1
void atomic_dec(&v)； //自减1
atomic_dec_and_test(&v)； //自减操作后测试其指是否为0，为0返回true，否则返回false

1、添加一个一个原子变量：atomic_t canopen=ATOMIC_INIT(1);
2、在open函数中增加一段判断代码：
if (!atomic_dec_and_test(&canopen))
{
atomic_inc(&canopen);
return -EBUSY; //当已经有应用程序打开该文件了，就返回忙
}
3、在close 中把变量加回来：
void atomic_inc(&canopen)；

信号量相关：
信号量（semaphore）：
用于保护临界区的一种常用方法，只有得到信号得信号量的进程才能执行临界区代码。
当获取不到信号量是，进程进入休眠等待状态。
信号量的相关函数：
定义信号量：struct semaphore sem；
初始化信号量：
void sema_init(struct semaphore * sem, int val);
void init_MUTEX(struct semaphore * sem);
static DECLARE_MUTEX(button_lock); //定义互斥锁
获得信号量：
void down(struct semaphore * sem)
void down_interruptible(struct semaphore * sem)
void down_trylock(struct semaphore * sem)

释放信号量：
void up(struct semaphore *sem)

步骤和原子操作一样，都是定义一个信号量、在open中申请信号量、在close中释放
使用信号量与使用原子操作的区别在于，
当使用原子操作时，第二次申请失败后程序将退出，
而使用信号量的时候第二次申请失败时，进程将被挂起，等待其他程序释放该信号量，
当有其他程序释放该信号量时，此程序将被唤醒。


阻塞与非阻塞：
当应用程序选择阻塞方式访问驱动时，应用申请不到信号量将等待其他程序释放信号量
当应用程序选择非阻塞方式访问驱动时，应用申请不到信号量或没有按键触发时将直接退出，不会去等待信号量与按键触发
1、在open函数中增加判断，判断传入的参数是阻塞还是非阻塞：
if (file->f_flags & O_NONBLOCK)
{
if (down_trylock(&button_lock))
return -EBUSY;
}
else
{
/* 获取信号量 */
down(&button_lock);
}
2、在read函数中也增加判断：
if (file->f_flags & O_NONBLOCK)
{
if (!ev_press)
return -EAGAIN;
}
else
{
/* 如果没有按键动作, 休眠 */
wait_event_interruptible(button_waitq, ev_press);
}


完整代码请看下面：sixth_drv.c

技术分享 
/**************************************************************/
/****    sixth_drv.c：    ***********************************/
/**************************************************************/    
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>


static struct class *sixthdrv_class;
static struct class_device    *sixthdrv_class_dev;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，sixth_drv_read将它清0 */
static volatile int ev_press = 0;

static struct fasync_struct *button_async;


struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};


/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};

//static atomic_t canopen = ATOMIC_INIT(1);     //定义原子变量并初始化为1

static DECLARE_MUTEX(button_lock);     //定义互斥锁

/*
  * 确定按键值
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    struct pin_desc * pindesc = (struct pin_desc *)dev_id;
    unsigned int pinval;
    
    pinval = s3c2410_gpio_getpin(pindesc->pin);

    if (pinval)
    {
        /* 松开 */
        key_val = 0x80 | pindesc->key_val;
    }
    else
    {
        /* 按下 */
        key_val = pindesc->key_val;
    }

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    
    kill_fasync (&button_async, SIGIO, POLL_IN);
    
    return IRQ_RETVAL(IRQ_HANDLED);
}

static int sixth_drv_open(struct inode *inode, struct file *file)
{
#if 0    
    if (!atomic_dec_and_test(&canopen))
    {
        atomic_inc(&canopen);
        return -EBUSY;
    }
#endif        

    if (file->f_flags & O_NONBLOCK)
    {
        if (down_trylock(&button_lock))
            return -EBUSY;
    }
    else
    {
        /* 获取信号量 */
        down(&button_lock);
    }

    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
    request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
    request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    

    return 0;
}

ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    if (file->f_flags & O_NONBLOCK)
    {
        if (!ev_press)
            return -EAGAIN;
    }
    else
    {
        /* 如果没有按键动作, 休眠 */
        wait_event_interruptible(button_waitq, ev_press);
    }

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;
    
    return 1;
}


int sixth_drv_close(struct inode *inode, struct file *file)
{
    //atomic_inc(&canopen);
    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11, &pins_desc[2]);
    free_irq(IRQ_EINT19, &pins_desc[3]);
    up(&button_lock);
    return 0;
}

static unsigned sixth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (ev_press)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}

static int sixth_drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: sixth_drv_fasync\n");
    return fasync_helper (fd, filp, on, &button_async);
}


static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  sixth_drv_open,     
    .read     =    sixth_drv_read,       
    .release =  sixth_drv_close,
    .poll    =  sixth_drv_poll,
    .fasync     =  sixth_drv_fasync,
};


int major;
static int sixth_drv_init(void)
{
    major = register_chrdev(0, "sixth_drv", &sencod_drv_fops);

    sixthdrv_class = class_create(THIS_MODULE, "sixth_drv");

    sixthdrv_class_dev = class_device_create(sixthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

    return 0;
}

static void sixth_drv_exit(void)
{
    unregister_chrdev(major, "sixth_drv");
    class_device_unregister(sixthdrv_class_dev);
    class_destroy(sixthdrv_class);
    return 0;
}


module_init(sixth_drv_init);

module_exit(sixth_drv_exit);

MODULE_LICENSE("GPL");
sixth_drv.c

 

测试程序:
测试程序中打开驱动文件是可以传入一个阻塞非阻塞的参数，驱动程序中将会对其判断
非阻塞: fd = open("/dev/buttons", O_RDWR );
阻塞： fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);
完整代码请看下面：sixth_test.c

技术分享 
/**************************************************************/
/****    sixth_test.c：    ***************************************/
/**************************************************************/    

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


/* sixthdrvtest 
  */
int fd;

void my_signal_fun(int signum)
{
    unsigned char key_val;
    read(fd, &key_val, 1);
    printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
    unsigned char key_val;
    int ret;
    int Oflags;

    //signal(SIGIO, my_signal_fun);
    
    fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);
    if (fd < 0)
    {
        printf("can‘t open!\n");
        return -1;
    }

    //fcntl(fd, F_SETOWN, getpid());
    
    //Oflags = fcntl(fd, F_GETFL); 
    
    //fcntl(fd, F_SETFL, Oflags | FASYNC);


    while (1)
    {
        ret = read(fd, &key_val, 1);
        printf("key_val: 0x%x, ret = %d\n", key_val, ret);
        sleep(5);
    }
    
    return 0;
}
sixth_test.c

 

定时器防抖
/********************/
定时器防抖 12-8
/********************/
定时器两要素：
1、超时时间。2、超时处理函数
步骤：
1、定义一个timer：static struct timer_list buttons_timer;
2、在init函数中初始化timer，设置timer：
init_timer(&buttons_timer); //初始化
buttons_timer.function = buttons_timer_function; //超时处理函数
//buttons_timer.expires = 0;
add_timer(&buttons_timer); //将定时器告诉内核
3、在中断处理函数中增加：
/* 10ms后启动定时器 */
irq_pd = (struct pin_desc *)dev_id;
mod_timer(&buttons_timer, jiffies+HZ/100); //设置超时时间，如果抖动了，该函数将被重新调用，即重新设置超时时间
//jiffies为系统时钟中断，每隔10ms将自增1。可以 cat /proc/interrupts查看到一个Timer Tick
4、并将原来的irq函数里的内容放到超时处理函数中。
5、因为init函数中，设置timer是没有设置超时时间，即默认超时时间为0，即设置好后将立即调用超时函数，所以需要在超时函数中增加一个判断：
if (!pindesc)
return;
//pindesc在irq中设置了，当没有发生中断，而进入该函数，就直接返回。

完整代码请看下面：buttuns_alldrv.c

技术分享 
/**************************************************************/
/****    buttuns_alldrv.c：    ***************************************/
/**************************************************************/    
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>


static struct class *sixthdrv_class;
static struct class_device    *sixthdrv_class_dev;

static struct timer_list buttons_timer;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，sixth_drv_read将它清0 */
static volatile int ev_press = 0;

static struct fasync_struct *button_async;


struct pin_desc{
    unsigned int pin;
    unsigned int key_val;
};


/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
    {S3C2410_GPF0, 0x01},
    {S3C2410_GPF2, 0x02},
    {S3C2410_GPG3, 0x03},
    {S3C2410_GPG11, 0x04},
};

static struct pin_desc *irq_pd;

//static atomic_t canopen = ATOMIC_INIT(1);     //定义原子变量并初始化为1

static DECLARE_MUTEX(button_lock);     //定义互斥锁

/*
  * 确定按键值
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    /* 10ms后启动定时器 */
    irq_pd = (struct pin_desc *)dev_id;
    mod_timer(&buttons_timer, jiffies+HZ/100);
    return IRQ_RETVAL(IRQ_HANDLED);
}

static int sixth_drv_open(struct inode *inode, struct file *file)
{
#if 0    
    if (!atomic_dec_and_test(&canopen))
    {
        atomic_inc(&canopen);
        return -EBUSY;
    }
#endif        

    if (file->f_flags & O_NONBLOCK)
    {
        if (down_trylock(&button_lock))
            return -EBUSY;
    }
    else
    {
        /* 获取信号量 */
        down(&button_lock);
    }

    /* 配置GPF0,2为输入引脚 */
    /* 配置GPG3,11为输入引脚 */
    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
    request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
    request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    

    return 0;
}

ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    if (size != 1)
        return -EINVAL;

    if (file->f_flags & O_NONBLOCK)
    {
        if (!ev_press)
            return -EAGAIN;
    }
    else
    {
        /* 如果没有按键动作, 休眠 */
        wait_event_interruptible(button_waitq, ev_press);
    }

    /* 如果有按键动作, 返回键值 */
    copy_to_user(buf, &key_val, 1);
    ev_press = 0;
    
    return 1;
}


int sixth_drv_close(struct inode *inode, struct file *file)
{
    //atomic_inc(&canopen);
    free_irq(IRQ_EINT0, &pins_desc[0]);
    free_irq(IRQ_EINT2, &pins_desc[1]);
    free_irq(IRQ_EINT11, &pins_desc[2]);
    free_irq(IRQ_EINT19, &pins_desc[3]);
    up(&button_lock);
    return 0;
}

static unsigned sixth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait); // 不会立即休眠

    if (ev_press)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}

static int sixth_drv_fasync (int fd, struct file *filp, int on)
{
    printk("driver: sixth_drv_fasync\n");
    return fasync_helper (fd, filp, on, &button_async);
}


static struct file_operations sencod_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  sixth_drv_open,     
    .read     =    sixth_drv_read,       
    .release =  sixth_drv_close,
    .poll    =  sixth_drv_poll,
    .fasync     =  sixth_drv_fasync,
};


int major;

static void buttons_timer_function(unsigned long data)
{
    struct pin_desc * pindesc = irq_pd;
    unsigned int pinval;

    if (!pindesc)
        return;
    
    pinval = s3c2410_gpio_getpin(pindesc->pin);

    if (pinval)
    {
        /* 松开 */
        key_val = 0x80 | pindesc->key_val;
    }
    else
    {
        /* 按下 */
        key_val = pindesc->key_val;
    }

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    
    kill_fasync (&button_async, SIGIO, POLL_IN);
}


static int sixth_drv_init(void)
{
    init_timer(&buttons_timer);
    buttons_timer.function = buttons_timer_function;
    //buttons_timer.expires  = 0;
    add_timer(&buttons_timer); 

    major = register_chrdev(0, "sixth_drv", &sencod_drv_fops);

    sixthdrv_class = class_create(THIS_MODULE, "sixth_drv");

    sixthdrv_class_dev = class_device_create(sixthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

    return 0;
}

static void sixth_drv_exit(void)
{
    unregister_chrdev(major, "sixth_drv");
    class_device_unregister(sixthdrv_class_dev);
    class_destroy(sixthdrv_class);
    return 0;
}

module_init(sixth_drv_init);
module_exit(sixth_drv_exit);
MODULE_LICENSE("GPL");
buttuns_alldrv.c

 

代码都是韦老师的，自己有好几处都不是很明白。我是纯新手，里面肯定有好多地方理解错了，暂时先这样写。如果看到我写错了，希望各位千万要指出来，感谢！

入门级的按键驱动——按键驱动笔记之poll机制-异步通知-同步互斥阻塞-定时器防抖

标签：

原文地址：http://www.cnblogs.com/wwwying9/p/4746272.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！