基于platform的ok6410按键中断实验

最新推荐文章于 2021-08-15 13:37:06 发布

杭城江城子

最新推荐文章于 2021-08-15 13:37:06 发布

阅读量175

点赞数

CC 4.0 BY-SA版权

分类专栏：嵌入式开发

本文链接：https://blog.csdn.net/caoshunxin01/article/details/79355046

嵌入式开发专栏收录该内容

233 篇文章

订阅专栏

本文介绍了一个针对OK6410开发板的按键驱动实现方案，包括平台设备资源分配、中断处理、文件操作接口定义及测试程序编写。通过平台设备与驱动的配合，实现了对开发板上六个按键的响应。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

plat_btn_device.c


#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/io.h>


#define DEVICE_NAME "ok6410_plat_btn"



static struct resource s3c_buttons_resource[] = {
        [0]={
                .start = IRQ_EINT(0),
                .end   = IRQ_EINT(0),
                .flags = IORESOURCE_IRQ,
        },
        [1]={
                .start = IRQ_EINT(1),
                .end   = IRQ_EINT(1),
                .flags = IORESOURCE_IRQ,
        },
        [2]={
                .start = IRQ_EINT(2),
                .end   = IRQ_EINT(2),
                .flags = IORESOURCE_IRQ,
        },
        [3]={
                .start = IRQ_EINT(3),
                .end   = IRQ_EINT(3),
                .flags = IORESOURCE_IRQ,
        },
        [4]={
                .start = IRQ_EINT(4),
                .end   = IRQ_EINT(4),
                .flags = IORESOURCE_IRQ,
        },
        [5]={
                .start = IRQ_EINT(5),
                .end   = IRQ_EINT(5),
                .flags = IORESOURCE_IRQ,
        }
};

static struct platform_device *s3c_buttons;


static int __init platform_init(void)
{

    s3c_buttons = platform_device_alloc(DEVICE_NAME,-1);

        //为平台设备s3c_buttons添加平台资源
    platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,6);

    
    platform_device_add(s3c_buttons);


}

static void __exit platform_exit(void)
{
    platform_device_unregister(s3c_buttons);
}

module_init(platform_init);
module_exit(platform_exit);

MODULE_AUTHOR("Sola");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ok6410_buttons");

plat_btn_driver.c


#include <linux/module.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <mach/map.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/unistd.h>
#include <linux/device.h>


#define DRIVER_NAME "ok6410_plat_btn"


//定义并初始化等待队列头
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;


static int key_value;
static struct device     *buttons_dev;  
static struct resource   *buttons_irq;


static int button_irqs[6];//中断号





static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
        int i;
        for(i=0; i<6; i++){
                if(irq == button_irqs[i]){
                        //printk("==>interrput number:%d\n",irq);  
                        key_value = i;
                        ev_press =1;
                        wake_up_interruptible(&button_waitq);           
                }
        }
        
    return IRQ_RETVAL(IRQ_HANDLED);
        
}



static int s3c6410_buttons_open(struct inode *inode, struct file *file)
{
        int i;
        int err = 0;
        
        for(i=0; i<6; i++){
                if (button_irqs[i] < 0) 
                        continue;
                                                    
                
        err = request_irq(button_irqs[i],buttons_interrupt,IRQF_TRIGGER_FALLING,NULL,NULL);
                if(err)
                  break;
        }

        if (err) {
                i--;
                for (; i >= 0; i--) {
                        if (button_irqs[i] < 0) {
                                continue;
                        }
                        disable_irq(button_irqs[i]);
                        free_irq(button_irqs[i], NULL);
                }
                return -EBUSY;
        }

    ev_press = 0;   
    return 0;
}

static int s3c6410_buttons_close(struct inode *inode, struct file *file)
{
    int i;    
    for (i=0; i<6; i++) {
                        if (button_irqs[i] < 0) {
                                continue;
                        }
                        free_irq(button_irqs[i],NULL);
    }
    return 0;
}

static int s3c6410_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
{
    unsigned long err;
    if (!ev_press) {//如果键没有被按下
                if (filp->f_flags & O_NONBLOCK)//如果是非阻塞模式，就直接返回
                        return -EAGAIN;
                else
                        //阻塞，直到按键按下
                        wait_event_interruptible(button_waitq, ev_press);
    }    
    ev_press = 0;
        
        //将键值送回到用户空间
    err = copy_to_user(buff, &key_value, sizeof(key_value));
    return sizeof(key_value);
}

static unsigned int s3c6410_buttons_poll( struct file *file, struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait);//添加等待队列头
    if (ev_press){
        mask |= POLLIN | POLLRDNORM;
        }
        
        //返回掩码
    return mask;
}



static struct file_operations ok6410_buttons_fops = {
    .owner   =   THIS_MODULE,
    .open    =   s3c6410_buttons_open,
        .release =   s3c6410_buttons_close,
    .read    =   s3c6410_buttons_read,
        .poll    =   s3c6410_buttons_poll,
};



//声明一个混杂设备,设备名称为"buttons"
static struct miscdevice ok6410_miscdev = {
        
    .minor = MISC_DYNAMIC_MINOR,
    .name ="buttons",
    .fops = &ok6410_buttons_fops,//操作集
};


static int ok6410_buttons_probe(struct platform_device *pdev)
{
        struct resource *res;
        struct device *dev;
        int ret;
        int size;
        int i;
        
        printk("probe:%s\n", __func__);
        dev = &pdev->dev;
        buttons_dev = &pdev->dev;
        
        
 
  for(i=0; i<6; i++){
        //获取中断号
         buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);
         if(buttons_irq == NULL){
                dev_err(dev,"no irq resource specified\n");
                  ret = -ENOENT;
                return ret;
        }
        button_irqs[i] = buttons_irq->start;
        //printk("button_irqs[%d]=%d\n",i,button_irqs[i]);  
        }
        
        //注册混杂设备
        ret = misc_register(&ok6410_miscdev);
                
        

        return ret;
}

static int ok6410_buttons_remove(struct platform_device *dev)
{
        
        misc_deregister(&ok6410_miscdev);
        return 0;
}


static struct platform_driver ok6410_buttons_driver = {
        .probe          = ok6410_buttons_probe,//探针函数
        .remove         = ok6410_buttons_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = DRIVER_NAME,
        },
};

static char banner[] __initdata =
         "ok6410 Buttons Driver\n";

static int __init buttons_init(void)
{
        printk(banner);
        
        platform_driver_register(&ok6410_buttons_driver);
        return 0;
}

static void __exit buttons_exit(void)
{
        //平台驱动的注销
        platform_driver_unregister(&ok6410_buttons_driver);
}

module_init(buttons_init);
module_exit(buttons_exit);

MODULE_AUTHOR("David Xie");
MODULE_DESCRIPTION("ok6410 Buttons Driver");
MODULE_LICENSE("GPL");

测试程序:

app-button.c


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>

int main(void)
{
        int buttons_fd;
        int key_value;

        buttons_fd = open("/dev/buttons", 0);
        if (buttons_fd < 0) {
                perror("open device buttons");
                exit(1);
        }

        for (;;) {
                fd_set rds;
                int ret;

                FD_ZERO(&rds);
                FD_SET(buttons_fd, &rds);

                ret = select(buttons_fd + 1, &rds, NULL, NULL, NULL);
                if (ret < 0) {
                        perror("select");
                        exit(1);
                }
                if (ret == 0) {
                        printf("Timeout.\n");
                } else if (FD_ISSET(buttons_fd, &rds)) {
                        int ret = read(buttons_fd, &key_value, sizeof key_value);
                        if (ret != sizeof key_value) {
                                if (errno != EAGAIN)
                                        perror("read buttons\n");
                                continue;
                        } else {
                                printf("buttons_value: %d\n", key_value+1);
                        }
                                
                }
        }

        close(buttons_fd);
        return 0;
}

Makefile:


ifneq ($(KERNELRELEASE),)

obj-m := plat_btn_device.o plat_btn_driver.o

else
        
KDIR := /home/ok6410/kernel/linux2.6.28
all:
        make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
        rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*

endif

实验步骤，分别编译生成内核模块plat_btn_drvice.ko plat_btn_driver.ko

然后先加载plat_btn_device.ko内核模块，再加载plat_tbn_driver.ko

最后运行测试程序:app-button

实验结果如下: