Linux驱动按键中断实验：字符设备驱动框架实现

一.  简介

前面一篇文章向设备树文件中添加了按键的中断信息。文章地址如下：

Linux驱动按键中断实验：添加按键节点的中断信息-CSDN博客

本文接下来开始按键中断代码的编写。本文具体来实现

二.  Linux驱动按键中断实验：字符设备驱动框架代码实现

1.  创建工程目录

这里我所存放的驱动实验代码在  ubuntu系统下的如下目录：

/home/wangtian/zhengdian_Linux/Linux_Drivers

(1) 首先，创建工程目录 12_key_irq，再创建 key_irq.c文件

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers$ mkdir 13_key_irq

在 工程目录下创建 key_irq.c文件：终端输入 "touch key_irq.c" 命令进行创建。

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/13_key_irq$ touch key_irq.c

（2）拷贝一份 .vscode与 Makefile文件。

将前面实验中的代码工程中 .vscode拷贝一份到 11_key工程目录下，这里将 8_semaphore工程中 .vscode目录及其下文件拷贝到该工程下：

注意： 拷贝.vscode 目录及其下文件的原因在于， .vscode目录下的文件，设置了 驱动程序可能会调用到的 Linux内核源码的路径（NXP官方）。

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/13_key_irq$ cp ../12_timer/.vscode/ ./ -rf

拷贝 Makefile文件

将8_semaphore工程中 Makefile拷贝到该工程下，操作如下：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/13_key_irq$ cp ../12_timer/Makefile ./ 

更改 Makefile文件的目标文件名，更改为如下：

obj-m := key_irq.o

2.   字符设备驱动框架代码实现

开始实现字符设备驱动框架代码，key_irq.c文件如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>

#define   IRQ_NAME   "key_irq"
#define   IRQ_CNT    1
#define   KEY_NUM    1 

/*key按键结构体 */
struct key_dev{
    int gpio_number;        //IO编号
    int interrupt_number;   //中断号
    unsigned char value;    //键值
    unsigned char name[50]; //按键名字
                //中断处理函数
};

/*imx6ull_irq设备结构体 */
struct irq_dev{
    dev_t devid;  //主设备号+次设备号
    int major; //主设备号
    int minor; //次设备号
    struct cdev cdev;
    struct class* class;
    struct device* device;
    struct device_node * dev_node;//设备节点
    struct key_dev key[KEY_NUM];

};

struct irq_dev irq;

/* 打开设备函数*/
static int irq_dev_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &irq;

    return 0;
}

ssize_t irq_dev_read(struct file * filp, char __user * buf, size_t count, loff_t * ppos)
{
    return 0;
}

/* 关闭设备函数 */
int irq_dev_close(struct inode * inode, struct file * filp)
{
    return 0;
}

static const struct file_operations irq_fops = {
	.open = irq_dev_open,
	.owner = THIS_MODULE,
	.read = irq_dev_read,
    .release = irq_dev_close, 
};

/*按键初始化 */
static int key_io_init(struct irq_dev* dev)
{
    int ret = 0;
    int i = 0;
    int n = 0;

    /*1.获取设备节点 */
    dev->dev_node = of_find_node_by_path("/key");
    if(NULL == dev->dev_node)
    {
        printk("find dev_node failed!\n");
        goto find_dev_node;
    }
    
    /*2.获取IO编号 */
    for(i=0; i< KEY_NUM; i++)
    {   
       dev->key[i].gpio_number = of_get_named_gpio(dev->dev_node, "key-gpio", i);
        if(dev->key[i].gpio_number < 0)
        {
            printk("get gpio number failed!\n");
            goto get_gpio_number;
        }
    }

    /*3.申请IO */
    for(i = 0; i< KEY_NUM; i++)
    {
        memset(dev->key[i].name, 0, sizeof(dev->key[i].name));
        sprintf(dev->key[i].name, "KEY%d", i);
        ret = gpio_request(dev->key[i].gpio_number, dev->key[i].name);
        if(ret != 0)
        {
            printk("gpio request fail!\n");
            goto gpio_request;
        }
        //将GPIO设置为输入
        gpio_direction_input(dev->key[i].gpio_number);
    }

    return 0;

gpio_request:
    for(n = 0; n<i; n++)
    {
        gpio_free(dev->key[n].gpio_number);
    }
get_gpio_number:
find_dev_node:
    return ret;
}

/*驱动入口函数 */
static int __init irq_init(void)
{
    int ret = 0;

    /*1. 注册/申请设备号 */
    irq.major = 0;  
    if(irq.major) //如果给出主设备号，则注册设备号
    {
        irq.devid = MKDEV(irq.major, 0);
        ret = register_chrdev_region(irq.devid, IRQ_CNT, IRQ_NAME);	
    }
    else //否则申请设备号
    {
      ret = alloc_chrdev_region(&irq.devid, 0, IRQ_CNT, IRQ_NAME);
      irq.major = MAJOR(irq.devid);
      irq.minor = MINOR(irq.devid);
    }
    if(ret < 0)
    {
        printk("devid apply failed!\n");
        goto devid_failed;
    }
    printk("major: %d minor: %d\n", irq.major,irq.minor);

    /*2. 设备初始化，添加设备*/
    irq.cdev.owner = THIS_MODULE;
    cdev_init(&irq.cdev, &irq_fops);
    ret = cdev_add(&irq.cdev, irq.devid, IRQ_CNT);
    if(ret < 0)
    {
        printk("cdev_add failed!\n");
        goto cdev_init_failed;
    }
    /*3. 自动创建设备节点 */
    irq.class = class_create(THIS_MODULE, IRQ_NAME);
    if(IS_ERR(irq.class)){
        printk(KERN_ERR "class_create failed!\n");
        ret = PTR_ERR(irq.class);
		goto class_create_failed;
    }
    irq.device = device_create(irq.class, NULL, irq.devid, NULL, IRQ_NAME);
    if (IS_ERR(irq.device)) {
		printk(KERN_ERR "device_create failed!\n");
		ret = PTR_ERR(irq.device);
		goto device_create_failed;
	}

    /*4. 按键初始化*/
    ret = key_io_init(&irq);
    if(ret != 0)
    {
        printk("key_io_init failed!\n");
        goto key_io_init_failed;
    }

    return 0;

key_io_init_failed:
    device_destroy(irq.class, irq.devid);
device_create_failed:
    class_destroy(irq.class);
class_create_failed:
    cdev_del(&irq.cdev);
cdev_init_failed: 
    unregister_chrdev_region(irq.devid, IRQ_CNT);
devid_failed:
    return ret;
}

/*驱动出口函数 */
static void __exit irq_exit(void)
{
    int i = 0;
    /*释放GPIO编号 */
    for(i=0; i< KEY_NUM; i++)
    {
        gpio_free(irq.key[i].gpio_number);
    }

    /*2. 删除设备 */
    cdev_del(&irq.cdev);
    /*3. 注销设备号*/
    unregister_chrdev_region(irq.devid, IRQ_CNT);

    /*4. 销毁设备 & 类*/
    device_destroy(irq.class, irq.devid);
    class_destroy(irq.class);
}

/*驱动入口与出口函数 */
module_init(irq_init);
module_exit(irq_exit);
MODULE_LICENSE("GPL"); //驱动 License
MODULE_AUTHOR("WeiYing"); //作者

三.  编译驱动模块

进入以上工程的根目录下，终端输入 "make"命令对代码进行编译：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/13_key_irq$ make 

我这里可以编译通过。生成了 key_irq.ko文件。

接下来对该驱动模块进行测试，即在开发板上进行加载，确定驱动模块是否存在问题。