Linux 驱动开发 四十：Linux 中断（二）

最新推荐文章于 2024-08-27 19:23:12 发布
最新推荐文章于 2024-08-27 19:23:12 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： Linux驱动开发 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/122640055
版权

一、代码实现

1、原理图分析

在这里插入图片描述
通过原理图分析可以得到，当按键按下后 KEY0 为低电平，当按键释放后 KEY0 为高电平。通过原理图可以确定 KEY0 连接在 UART1_CTS 引脚上。UART1_CTS 引脚的 IO 编号为 GPIO1_IO18。

2、修改设备树

1、修改 SOC 级中断属性

根据《IMX6ULL参考手册》中 Chapter 3：Interrupts and DMA Events描述，具体描述如下：
在这里插入图片描述
在 imx6ull.dtsi 源码中已经存在 gpio1 中断相关描述，不需要我们修改，具体内容如下：

gpio1: gpio@0209c000 {
	compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
	reg = <0x0209c000 0x4000>;
	interrupts = <GIC_SPI 66 IRQ_TYPE_LEVEL_HIGH>,	// GIC_SPI：代表中断类型、66：代表中断号、IRQ_TYPE_LEVEL_HIGH：代表触发类型
		     <GIC_SPI 67 IRQ_TYPE_LEVEL_HIGH>;
	gpio-controller;
	#gpio-cells = <2>;
	interrupt-controller;
	#interrupt-cells = <2>;	// 代表子节点 interrupts 属性由 2 个字段描述（第一字段代表 GPIO 号，第二字段代表触发类型）
};

通过以上分析 GPIO1 中断相关属性已经由 NXP 完成，因此不需要修改。

总结：中断设备树定义了中断路由过程路径，子节点触发中断后向父节点路由中断信号。

2、修改设备级中断属性

在 imx6ull-lq-evk.dts 设备树源码中的 lq-key 节点添加中断属性，修改后节点信息如下：

lq-key {
	compatible = "lq-key";
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_key>;
	key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
	interrupt-parent = <&gpio1>;			// 指定中断父节点
	interrupts = <18 IRQ_TYPE_EDGE_BOTH>;	// 指定 GPIO 引脚和触发类型（双边沿触发）
};

对于触发类型详细描述见 include/linux/irq.h 文档，详细描述如下：

/*
 * IRQ line status.
 *
 * Bits 0-7 are the same as the IRQF_* bits in linux/interrupt.h
 *
 * IRQ_TYPE_NONE		- default, unspecified type
 * IRQ_TYPE_EDGE_RISING		- rising edge triggered
 * IRQ_TYPE_EDGE_FALLING	- falling edge triggered
 * IRQ_TYPE_EDGE_BOTH		- rising and falling edge triggered
 * IRQ_TYPE_LEVEL_HIGH		- high level triggered
 * IRQ_TYPE_LEVEL_LOW		- low level triggered
 * IRQ_TYPE_LEVEL_MASK		- Mask to filter out the level bits
 * IRQ_TYPE_SENSE_MASK		- Mask for all the above bits
 * IRQ_TYPE_DEFAULT		- For use by some PICs to ask irq_set_type
 *				  to setup the HW to a sane default (used
 *                                by irqdomain map() callbacks to synchronize
 *                                the HW state and SW flags for a newly
 *                                allocated descriptor).
 *
 * IRQ_TYPE_PROBE		- Special flag for probing in progress
 *
 * Bits which can be modified via irq_set/clear/modify_status_flags()
 * IRQ_LEVEL			- Interrupt is level type. Will be also
 *				  updated in the code when the above trigger
 *				  bits are modified via irq_set_irq_type()
 * IRQ_PER_CPU			- Mark an interrupt PER_CPU. Will protect
 *				  it from affinity setting
 * IRQ_NOPROBE			- Interrupt cannot be probed by autoprobing
 * IRQ_NOREQUEST		- Interrupt cannot be requested via
 *				  request_irq()
 * IRQ_NOTHREAD			- Interrupt cannot be threaded
 * IRQ_NOAUTOEN			- Interrupt is not automatically enabled in
 *				  request/setup_irq()
 * IRQ_NO_BALANCING		- Interrupt cannot be balanced (affinity set)
 * IRQ_MOVE_PCNTXT		- Interrupt can be migrated from process context
 * IRQ_NESTED_TRHEAD		- Interrupt nests into another thread
 * IRQ_PER_CPU_DEVID		- Dev_id is a per-cpu variable
 * IRQ_IS_POLLED		- Always polled by another interrupt. Exclude
 *				  it from the spurious interrupt detection
 *				  mechanism and from core side polling.
 */
enum {
	IRQ_TYPE_NONE		= 0x00000000,
	IRQ_TYPE_EDGE_RISING	= 0x00000001,
	IRQ_TYPE_EDGE_FALLING	= 0x00000002,
	IRQ_TYPE_EDGE_BOTH	= (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING),
	IRQ_TYPE_LEVEL_HIGH	= 0x00000004,
	IRQ_TYPE_LEVEL_LOW	= 0x00000008,
	IRQ_TYPE_LEVEL_MASK	= (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH),
	IRQ_TYPE_SENSE_MASK	= 0x0000000f,
	IRQ_TYPE_DEFAULT	= IRQ_TYPE_SENSE_MASK,

	IRQ_TYPE_PROBE		= 0x00000010,

	IRQ_LEVEL		= (1 <<  8),
	IRQ_PER_CPU		= (1 <<  9),
	IRQ_NOPROBE		= (1 << 10),
	IRQ_NOREQUEST		= (1 << 11),
	IRQ_NOAUTOEN		= (1 << 12),
	IRQ_NO_BALANCING	= (1 << 13),
	IRQ_MOVE_PCNTXT		= (1 << 14),
	IRQ_NESTED_THREAD	= (1 << 15),
	IRQ_NOTHREAD		= (1 << 16),
	IRQ_PER_CPU_DEVID	= (1 << 17),
	IRQ_IS_POLLED		= (1 << 18),
};

3、编译设备树

onlylove@ubuntu:~/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga$ make dtbs
  CHK     include/config/kernel.release
  CHK     include/generated/uapi/linux/version.h
  CHK     include/generated/utsrelease.h
make[1]: 'include/generated/mach-types.h' is up to date.
  CHK     include/generated/bounds.h
  CHK     include/generated/asm-offsets.h
  CALL    scripts/checksyscalls.sh
  DTC     arch/arm/boot/dts/imx6ull-lq-evk.dtb
onlylove@ubuntu:~/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga$

4、验证

/ # ls
bin       etc       linuxrc   proc      sbin      timer.ko  usr
dev       lib       mnt       root      sys       tmp
/ # cd /sys/firmware/devicetree/base/
/sys/firmware/devicetree/base # ls
#address-cells                 lq-led
#size-cells                    memory
aliases                        model
backlight                      name
chosen                         pxp_v4l2
clocks                         regulators
compatible                     reserved-memory
cpus                           soc
gpioled                        sound
interrupt-controller@00a01000  spi4
lq-key
/sys/firmware/devicetree/base # cd lq-key/
/sys/firmware/devicetree/base/lq-key # ls
compatible        interrupts        name              pinctrl-names
interrupt-parent  key-gpio          pinctrl-0         status
/sys/firmware/devicetree/base/lq-key # ls -al
total 0
drwxr-xr-x    2 0        0                0 Jan  1 00:01 .
drwxr-xr-x   18 0        0                0 Jan  1 00:01 ..
-r--r--r--    1 0        0                7 Jan  1 00:01 compatible
-r--r--r--    1 0        0                4 Jan  1 00:01 interrupt-parent
-r--r--r--    1 0        0                8 Jan  1 00:01 interrupts
-r--r--r--    1 0        0               12 Jan  1 00:01 key-gpio
-r--r--r--    1 0        0                7 Jan  1 00:01 name
-r--r--r--    1 0        0                4 Jan  1 00:01 pinctrl-0
-r--r--r--    1 0        0                8 Jan  1 00:01 pinctrl-names
-r--r--r--    1 0        0                5 Jan  1 00:01 status
/sys/firmware/devicetree/base/lq-key #

通过以上日志可以确定 key 中断属性添加成功。

3、Makefile

KERNELDIR := /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := irq.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

4、搭建驱动框架

1、代码实现

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/printk.h"
#include "linux/cdev.h"
#include "linux/device.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

typedef struct{
    struct cdev dev;        /* cdev 结构体 (声明在 "linux/cdev.h")*/
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 (声明在 "linux/device.h")*/
    struct device *device;  /* 设备 (声明在 "linux/device.h") */
}newchrdev_t;

newchrdev_t newchrdev;

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

/*
 * MKDEV 声明在 "linux/kdev_t.h"
 * register_chrdev_region 声明在 "linux/fs.h"
 * printk 声明在 "linux/printk.h"
 * alloc_chrdev_region 声明在 "linux/fs.h"
 * cdev_init 声明在 "linux/cdev.h"
 * cdev_add 声明在 "linux/cdev.h"
 * class_create 声明在 "linux/device.h"
 */
/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    int ret;

    /* 1、字符设备号分配 */
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        /* 指定设备号 */
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        printk("newchrdev.major > 0!\r\n");
    }else{
        /* 系统分配设备号 */
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
        printk("newchrdev.major = 0!\r\n");
    }
     if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev devid = %d newchrdev major=%d,minor=%d\r\n",newchrdev.devid,newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    return 0;

//neschrdev_device_xxx_failed:    /* 其他操作失败(添加其他文件时，打开此选项) */
//    device_destroy(newchrdev.class,newchrdev.devid);
neschrdev_device_creat_failed:  /* 删除类 */
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:  /*注销字符设备 */
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:  /* 释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    printk("failed!\r\n");
    return ret;
}

/*
 * device_destroy 声明在 "linux/device.h"
 * class_destroy 声明在 "linux/device.h"
 * cdev_del 声明在 "linux/cdev.h"
 * unregister_chrdev_region 声明在 "linux/fs.h"
 */
/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
    printk("newchrdev_exit succed!\r\n");
}
/*
 * module_init 声明在 "linux/init.h"
 * module_exit 声明在 "linux/init.h"
 * MODULE_LICENSE 声明在 "linux/module.h"
 */
// 头文件 "linux/init.h"
module_init(newchrdev_init);
module_exit(newchrdev_exit);
MODULE_LICENSE("GPL");

2、编译

onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls -l
total 12
-rw-rw-r-- 1 onlylove onlylove 4367 Jan 18 07:09 irq.c
-rw-rw-r-- 1 onlylove onlylove  273 Jan 18 04:49 Makefile
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/8_irq modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/8_irq/irq.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls -l
total 36
-rw-rw-r-- 1 onlylove onlylove 4367 Jan 18 07:09 irq.c
-rw-rw-r-- 1 onlylove onlylove 5664 Jan 18 07:09 irq.ko
-rw-rw-r-- 1 onlylove onlylove 1266 Jan 18 07:09 irq.mod.c
-rw-rw-r-- 1 onlylove onlylove 2536 Jan 18 07:09 irq.mod.o
-rw-rw-r-- 1 onlylove onlylove 3844 Jan 18 07:09 irq.o
-rw-rw-r-- 1 onlylove onlylove  273 Jan 18 04:49 Makefile
-rw-rw-r-- 1 onlylove onlylove   61 Jan 18 07:09 modules.order
-rw-rw-r-- 1 onlylove onlylove    0 Jan 18 07:09 Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$

3、测试

/ # ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ # lsmod
Module                  Size  Used by    Not tainted
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # rmmod irq.ko
newchrdev_exit succed!
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # rmmod irq.ko
newchrdev_exit succed!
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # rmmod irq.ko
newchrdev_exit succed!
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # rmmod irq.ko
newchrdev_exit succed!
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # rmmod irq.ko
newchrdev_exit succed!
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
/ # lsmod
Module                  Size  Used by    Tainted: G
irq                     1494  0
/ # ls /dev/newchrdev -l
crw-rw----    1 0        0         248,   0 Jan  1 02:29 /dev/newchrdev
/ #
/ #
/ # rmmod irq.ko
newchrdev_exit succed!
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/newchrdev -l
ls: /dev/newchrdev: No such file or directory

5、key 引脚初始化

1、添加 key 数据类型

/* key 相关数据 */
typedef struct{
	int gpio;								/* gpio */
	int irqnum;								/* 中断号     */
	unsigned char value;					/* 按键对应的键值 */
	char name[10];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
}key_t;

关于 key 使用的相关数据组织成结构体类型便于管理，多个按键可以定义多个变量。

特变说明：按键相关设备树节点放在 newchrdev_t，因为它只有一个节点，不可能出现多个。

2、完善 newchrdev_t 类型

typedef struct{
    struct cdev dev;        /* cdev 结构体 (声明在 "linux/cdev.h")*/
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 (声明在 "linux/device.h")*/
    struct device *device;  /* 设备 (声明在 "linux/device.h") */

    struct device_node	*nd; /* 设备节点 (声明在 "linux/of.h") */
    key_t key_data;         /* 按键相关数据 */
}newchrdev_t;

新增加 nd 和 key_data 成员。

3、初始化 key 引脚

1、查找设备节点

2、从设备树中获取 GPIO 配置信息

3、申请一个 GPIO

4、设置 GPIO 为输入

5、获取中断号

6、申请中断

6、驱动代码：功能实现

1、源码

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/printk.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include "linux/of.h"
#include "linux/of_gpio.h"
#include "linux/gpio.h"
#include "linux/of_irq.h"
#include "linux/interrupt.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

int key_pin_init(void);
static irqreturn_t key_handler(int irq, void *dev_id);
void key_pin_exit(void);

/* key 相关数据 */
typedef struct{
	int gpio;								/* gpio */
	int irqnum;								/* 中断号     */
	unsigned char value;					/* 按键对应的键值 */
	char name[10];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
}newkey_t;

typedef struct{
    struct cdev dev;        /* cdev 结构体 (声明在 "linux/cdev.h")*/
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 (声明在 "linux/device.h")*/
    struct device *device;  /* 设备 (声明在 "linux/device.h") */

    struct device_node	*nd; /* 设备节点 (声明在 "linux/of.h") */
    newkey_t key_data;         /* 按键相关数据 */
}newchrdev_t;

newchrdev_t newchrdev;

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

/*
 * MKDEV 声明在 "linux/kdev_t.h"
 * register_chrdev_region 声明在 "linux/fs.h"
 * printk 声明在 "linux/printk.h"
 * alloc_chrdev_region 声明在 "linux/fs.h"
 * cdev_init 声明在 "linux/cdev.h"
 * cdev_add 声明在 "linux/cdev.h"
 * class_create 声明在 "linux/device.h"
 */
/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    int ret;

    /* 1、字符设备号分配 */
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        /* 指定设备号 */
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        printk("newchrdev.major > 0!\r\n");
    }else{
        /* 系统分配设备号 */
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
        printk("newchrdev.major = 0!\r\n");
    }
     if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev devid = %d newchrdev major=%d,minor=%d\r\n",newchrdev.devid,newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    /* 5、key 初始化 */
    ret = key_pin_init();
    if(ret < 0){
        printk("key_pin_init!\r\n");
        goto neschrdev_device_xxx_failed;
    }

    return 0;

neschrdev_device_xxx_failed:    /* 其他操作失败(添加其他文件时，打开此选项) */
    device_destroy(newchrdev.class,newchrdev.devid);
neschrdev_device_creat_failed:  /* 删除类 */
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:  /*注销字符设备 */
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:  /* 释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    printk("failed!\r\n");
    return ret;
}

/*
 * device_destroy 声明在 "linux/device.h"
 * class_destroy 声明在 "linux/device.h"
 * cdev_del 声明在 "linux/cdev.h"
 * unregister_chrdev_region 声明在 "linux/fs.h"
 */
/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 5、key退出 */
    key_pin_exit();
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
    printk("newchrdev_exit succed!\r\n");
}
/*
 * module_init 声明在 "linux/init.h"
 * module_exit 声明在 "linux/init.h"
 * MODULE_LICENSE 声明在 "linux/module.h"
 */
// 头文件 "linux/init.h"
module_init(newchrdev_init);
module_exit(newchrdev_exit);
MODULE_LICENSE("GPL");


/*
 * @description	: 按键 pin 初始化(从设备树中获取相关初始化数据)
 * @param 		: 无
 * @return 		: 无
 * 
 * of_find_node_by_path 声明在 "linux/of.h"
 * of_get_named_gpio 声明在 "linux/of_gpio.h"
 * memcpy 声明在 "asm/string.h"
 * gpio_request 声明在 "linux/gpio.h"
 * gpio_direction_input 声明在 "linux/gpio.h"
 * irq_of_parse_and_map 声明在 "linux/of_irq.h"
 * request_irq 声明在 "linux/interrupt.h"
 * IRQF_TRIGGER_FALLING 定义在 "linux/interrupt.h"
 * IRQF_TRIGGER_RISING 定义在 "linux/interrupt.h"
 */
int key_pin_init(void)
{
    int ret = 0;

    /* 1、查找设备节点 */
    newchrdev.nd = of_find_node_by_path("/lq-key");
    if (newchrdev.nd== NULL){
        printk("key node not find!\r\n");
        return -1;
    }

    /* 2、从设备树中获取 GPIO 配置信息 */
    newchrdev.key_data.gpio = of_get_named_gpio(newchrdev.nd,"key-gpio",0);
    if(newchrdev.key_data.gpio < 0){
        printk("can't get key-gpio\r\n");
        return -2;
    }

    /* 3、申请一个 GPIO */
    memcpy(newchrdev.key_data.name,"KEY",sizeof("KEY"));
    gpio_request(newchrdev.key_data.gpio,newchrdev.key_data.name);

    /* 4、设置 GPIO 为输入 */
    gpio_direction_input(newchrdev.key_data.gpio);

    /* 5、获取中断号 */
    newchrdev.key_data.irqnum = irq_of_parse_and_map(newchrdev.nd,0);
    printk("key:gpio=%d, irqnum=%d\r\n",newchrdev.key_data.gpio, newchrdev.key_data.irqnum);

    /* 6、申请中断 */
    newchrdev.key_data.handler = key_handler;
    ret = request_irq(newchrdev.key_data.irqnum,newchrdev.key_data.handler,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,newchrdev.key_data.name,&newchrdev);
    if(ret < 0){
        printk("can't request irq!\r\n");
        return -3;
    }

    return 0;
}

/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t key_handler(int irq, void *dev_id)
{
    printk("key0_handler\r\n");

    return IRQ_RETVAL(IRQ_HANDLED);
}

void key_pin_exit(void)
{
    free_irq(newchrdev.key_data.irqnum,&newchrdev);
}

2、编译

onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  Makefile
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/8_irq modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/8_irq/irq.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  irq.ko  irq.mod.c  irq.mod.o  irq.o  Makefile  modules.order  Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$

3、验证

/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
key:gpio=18, irqnum=49
/ # rmmod irq.ko
newchrdev_exit succed!
/ #
/ # ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
key:gpio=18, irqnum=49
/ # key0_handler
key0_handler
key0_handler
key0_handler
key0_handler
key0_handler
key0_handler
key0_handler

/ #

通过以上验证，功能基本实现，但按键消抖未实现。

7、驱动代码：使用中断下半部

我们使用 tasklet 作为中断下半部。

1、源码

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/printk.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include "linux/of.h"
#include "linux/of_gpio.h"
#include "linux/gpio.h"
#include "linux/of_irq.h"
#include "linux/interrupt.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

int key_pin_init(void);
static irqreturn_t key_handler(int irq, void *dev_id);
void key_pin_exit(void);
static void key_tasklet(unsigned long data);

/* key 相关数据 */
typedef struct{
	int gpio;								/* gpio */
	int irqnum;								/* 中断号     */
	unsigned char value;					/* 按键对应的键值 */
	char name[10];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */

    struct tasklet_struct tasklet;          /* tasklet 变量（中断下半部） */
    unsigned long tasklet_data;             /* 传递给 tasklet 处理函数的参数 */
}newkey_t;

typedef struct{
    struct cdev dev;        /* cdev 结构体 (声明在 "linux/cdev.h")*/
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 (声明在 "linux/device.h")*/
    struct device *device;  /* 设备 (声明在 "linux/device.h") */

    struct device_node	*nd; /* 设备节点 (声明在 "linux/of.h") */
    newkey_t key_data;         /* 按键相关数据 */
}newchrdev_t;

newchrdev_t newchrdev;

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

/*
 * MKDEV 声明在 "linux/kdev_t.h"
 * register_chrdev_region 声明在 "linux/fs.h"
 * printk 声明在 "linux/printk.h"
 * alloc_chrdev_region 声明在 "linux/fs.h"
 * cdev_init 声明在 "linux/cdev.h"
 * cdev_add 声明在 "linux/cdev.h"
 * class_create 声明在 "linux/device.h"
 */
/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    int ret;

    /* 1、字符设备号分配 */
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        /* 指定设备号 */
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        printk("newchrdev.major > 0!\r\n");
    }else{
        /* 系统分配设备号 */
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
        printk("newchrdev.major = 0!\r\n");
    }
     if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev devid = %d newchrdev major=%d,minor=%d\r\n",newchrdev.devid,newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    /* 5、key 初始化 */
    ret = key_pin_init();
    if(ret < 0){
        printk("key_pin_init!\r\n");
        goto neschrdev_device_xxx_failed;
    }

    return 0;

neschrdev_device_xxx_failed:    /* 其他操作失败(添加其他文件时，打开此选项) */
    device_destroy(newchrdev.class,newchrdev.devid);
neschrdev_device_creat_failed:  /* 删除类 */
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:  /*注销字符设备 */
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:  /* 释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    printk("failed!\r\n");
    return ret;
}

/*
 * device_destroy 声明在 "linux/device.h"
 * class_destroy 声明在 "linux/device.h"
 * cdev_del 声明在 "linux/cdev.h"
 * unregister_chrdev_region 声明在 "linux/fs.h"
 */
/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 5、key退出 */
    key_pin_exit();
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
    printk("newchrdev_exit succed!\r\n");
}
/*
 * module_init 声明在 "linux/init.h"
 * module_exit 声明在 "linux/init.h"
 * MODULE_LICENSE 声明在 "linux/module.h"
 */
// 头文件 "linux/init.h"
module_init(newchrdev_init);
module_exit(newchrdev_exit);
MODULE_LICENSE("GPL");


/*
 * @description	: 按键 pin 初始化(从设备树中获取相关初始化数据)
 * @param 		: 无
 * @return 		: 无
 * 
 * of_find_node_by_path 声明在 "linux/of.h"
 * of_get_named_gpio 声明在 "linux/of_gpio.h"
 * memcpy 声明在 "asm/string.h"
 * gpio_request 声明在 "linux/gpio.h"
 * gpio_direction_input 声明在 "linux/gpio.h"
 * irq_of_parse_and_map 声明在 "linux/of_irq.h"
 * request_irq 声明在 "linux/interrupt.h"
 * IRQF_TRIGGER_FALLING 定义在 "linux/interrupt.h"
 * IRQF_TRIGGER_RISING 定义在 "linux/interrupt.h"
 * tasklet_init 声明在 "linux/interrupt.h"
 */
int key_pin_init(void)
{
    int ret = 0;

    /* 1、查找设备节点 */
    newchrdev.nd = of_find_node_by_path("/lq-key");
    if (newchrdev.nd== NULL){
        printk("key node not find!\r\n");
        return -1;
    }

    /* 2、从设备树中获取 GPIO 配置信息 */
    newchrdev.key_data.gpio = of_get_named_gpio(newchrdev.nd,"key-gpio",0);
    if(newchrdev.key_data.gpio < 0){
        printk("can't get key-gpio\r\n");
        return -2;
    }

    /* 3、申请一个 GPIO */
    memcpy(newchrdev.key_data.name,"KEY",sizeof("KEY"));
    gpio_request(newchrdev.key_data.gpio,newchrdev.key_data.name);

    /* 4、设置 GPIO 为输入 */
    gpio_direction_input(newchrdev.key_data.gpio);

    /* 5、获取中断号 */
    newchrdev.key_data.irqnum = irq_of_parse_and_map(newchrdev.nd,0);
    printk("key:gpio=%d, irqnum=%d\r\n",newchrdev.key_data.gpio, newchrdev.key_data.irqnum);

    /* 6、申请中断 */
    newchrdev.key_data.handler = key_handler;
    ret = request_irq(newchrdev.key_data.irqnum,newchrdev.key_data.handler,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,newchrdev.key_data.name,&newchrdev);
    if(ret < 0){
        printk("can't request irq!\r\n");
        return -3;
    }

    /* 7、初始化中断下半部（tasklet） */
    tasklet_init(&newchrdev.key_data.tasklet,key_tasklet,newchrdev.key_data.tasklet_data);

    return 0;
}

/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t key_handler(int irq, void *dev_id)
{
    printk("key0_handler\r\n");
    tasklet_schedule(&newchrdev.key_data.tasklet);
    return IRQ_RETVAL(IRQ_HANDLED);
}

void key_pin_exit(void)
{
    free_irq(newchrdev.key_data.irqnum,&newchrdev);
}

static void key_tasklet(unsigned long data)
{
    printk("key_tasklet\r\n");
}

以上源码为根据 Linux 中断设计思路二完善源码。

2、编译

onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  Makefile
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/8_irq modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/8_irq/irq.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  irq.ko  irq.mod.c  irq.mod.o  irq.o  Makefile  modules.order  Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ cp irq.ko ~/linux/nfs/rootfs-l
rootfs-l/        rootfs-l.tar.gz  
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ cp irq.ko ~/linux/nfs/rootfs-l/
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  irq.ko  irq.mod.c  irq.mod.o  irq.o  Makefile  modules.order  Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$

3、验证

/ # ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ # lsmod
Module                  Size  Used by    Not tainted
/ #
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
key:gpio=18, irqnum=49
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
irq                     2563  0
/ # rmmod irq.ko
newchrdev_exit succed!
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
/ #
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
key:gpio=18, irqnum=49
/ #
/ # key0_handler
key_tasklet
key0_handler
key_tasklet

/ # rmmod irq.ko
newchrdev_exit succed!
/ #

8、驱动代码：按键消抖

使用内核定时器完成按键消抖。

1、源码

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/printk.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include "linux/of.h"
#include "linux/of_gpio.h"
#include "linux/gpio.h"
#include "linux/of_irq.h"
#include "linux/interrupt.h"
#include "linux/jiffies.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

int key_pin_init(void);
static irqreturn_t key_handler(int irq, void *dev_id);
void key_pin_exit(void);
static void key_tasklet(unsigned long data);
void timer_function(unsigned long arg);
void key_timer_init(void);
void key_timer_exit(void);

/* key 相关数据 */
typedef struct{
	int gpio;								/* gpio */
	int irqnum;								/* 中断号     */
	unsigned char value;					/* 按键对应的键值 */
	char name[10];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */

    struct tasklet_struct tasklet;          /* tasklet 变量（中断下半部） */
    unsigned long tasklet_data;             /* 传递给 tasklet 处理函数的参数 */
    struct timer_list key_timer;            /* 中断定时器，用于按键消抖 */
}newkey_t;

typedef struct{
    struct cdev dev;        /* cdev 结构体 (声明在 "linux/cdev.h")*/
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 (声明在 "linux/device.h")*/
    struct device *device;  /* 设备 (声明在 "linux/device.h") */

    struct device_node	*nd; /* 设备节点 (声明在 "linux/of.h") */
    newkey_t key_data;         /* 按键相关数据 */
}newchrdev_t;

newchrdev_t newchrdev;

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

/*
 * MKDEV 声明在 "linux/kdev_t.h"
 * register_chrdev_region 声明在 "linux/fs.h"
 * printk 声明在 "linux/printk.h"
 * alloc_chrdev_region 声明在 "linux/fs.h"
 * cdev_init 声明在 "linux/cdev.h"
 * cdev_add 声明在 "linux/cdev.h"
 * class_create 声明在 "linux/device.h"
 */
/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    int ret;

    /* 1、字符设备号分配 */
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        /* 指定设备号 */
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        printk("newchrdev.major > 0!\r\n");
    }else{
        /* 系统分配设备号 */
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
        printk("newchrdev.major = 0!\r\n");
    }
     if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev devid = %d newchrdev major=%d,minor=%d\r\n",newchrdev.devid,newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    /* 5、key 初始化 */
    ret = key_pin_init();
    if(ret < 0){
        printk("key_pin_init!\r\n");
        goto neschrdev_device_xxx_failed;
    }

    return 0;

neschrdev_device_xxx_failed:    /* 其他操作失败(添加其他文件时，打开此选项) */
    device_destroy(newchrdev.class,newchrdev.devid);
neschrdev_device_creat_failed:  /* 删除类 */
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:  /*注销字符设备 */
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:  /* 释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    printk("failed!\r\n");
    return ret;
}

/*
 * device_destroy 声明在 "linux/device.h"
 * class_destroy 声明在 "linux/device.h"
 * cdev_del 声明在 "linux/cdev.h"
 * unregister_chrdev_region 声明在 "linux/fs.h"
 */
/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /*6、删除内核定时器（用于按键消抖）*/
    key_timer_exit();
    /* 5、key退出 */
    key_pin_exit();
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
    printk("newchrdev_exit succed!\r\n");
}
/*
 * module_init 声明在 "linux/init.h"
 * module_exit 声明在 "linux/init.h"
 * MODULE_LICENSE 声明在 "linux/module.h"
 */
// 头文件 "linux/init.h"
module_init(newchrdev_init);
module_exit(newchrdev_exit);
MODULE_LICENSE("GPL");


/*
 * @description	: 按键 pin 初始化(从设备树中获取相关初始化数据)
 * @param 		: 无
 * @return 		: 无
 * 
 * of_find_node_by_path 声明在 "linux/of.h"
 * of_get_named_gpio 声明在 "linux/of_gpio.h"
 * memcpy 声明在 "asm/string.h"
 * gpio_request 声明在 "linux/gpio.h"
 * gpio_direction_input 声明在 "linux/gpio.h"
 * irq_of_parse_and_map 声明在 "linux/of_irq.h"
 * request_irq 声明在 "linux/interrupt.h"
 * IRQF_TRIGGER_FALLING 定义在 "linux/interrupt.h"
 * IRQF_TRIGGER_RISING 定义在 "linux/interrupt.h"
 * tasklet_init 声明在 "linux/interrupt.h"
 * init_timer 声明在 "linux/timer.h"
 */
int key_pin_init(void)
{
    int ret = 0;

    /* 1、查找设备节点 */
    newchrdev.nd = of_find_node_by_path("/lq-key");
    if (newchrdev.nd== NULL){
        printk("key node not find!\r\n");
        return -1;
    }

    /* 2、从设备树中获取 GPIO 配置信息 */
    newchrdev.key_data.gpio = of_get_named_gpio(newchrdev.nd,"key-gpio",0);
    if(newchrdev.key_data.gpio < 0){
        printk("can't get key-gpio\r\n");
        return -2;
    }

    /* 3、申请一个 GPIO */
    memcpy(newchrdev.key_data.name,"KEY",sizeof("KEY"));
    gpio_request(newchrdev.key_data.gpio,newchrdev.key_data.name);

    /* 4、设置 GPIO 为输入 */
    gpio_direction_input(newchrdev.key_data.gpio);

    /* 5、获取中断号 */
    newchrdev.key_data.irqnum = irq_of_parse_and_map(newchrdev.nd,0);
    printk("key:gpio=%d, irqnum=%d\r\n",newchrdev.key_data.gpio, newchrdev.key_data.irqnum);

    /* 6、申请中断 */
    newchrdev.key_data.handler = key_handler;
    ret = request_irq(newchrdev.key_data.irqnum,newchrdev.key_data.handler,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,newchrdev.key_data.name,&newchrdev);
    if(ret < 0){
        printk("can't request irq!\r\n");
        return -3;
    }

    /* 7、初始化中断下半部（tasklet） */
    tasklet_init(&newchrdev.key_data.tasklet,key_tasklet,newchrdev.key_data.tasklet_data);

    /* 8、初始化定时器（用于按键消抖） */
    key_timer_init();

    return 0;
}

/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t key_handler(int irq, void *dev_id)
{
    printk("key0_handler\r\n");
    tasklet_schedule(&newchrdev.key_data.tasklet);
    return IRQ_RETVAL(IRQ_HANDLED);
}

void key_pin_exit(void)
{
    free_irq(newchrdev.key_data.irqnum,&newchrdev);
}

/*
 * jiffies 定义在 "linux/jiffies.h"
 * msecs_to_jiffies 声明在 "linux/jiffies.h"
 * 
 */
static void key_tasklet(unsigned long data)
{
    printk("key_tasklet\r\n");
    newchrdev.key_data.key_timer.data = (unsigned long)(&newchrdev.key_data.key_timer);
    mod_timer(&newchrdev.key_data.key_timer,jiffies + msecs_to_jiffies(2000));
}

void timer_function(unsigned long arg)
{
    printk("timer_function\r\n");
}

void key_timer_init(void)
{
    init_timer(&newchrdev.key_data.key_timer);
    newchrdev.key_data.key_timer.function = timer_function;
}

void key_timer_exit(void)
{
    del_timer(&newchrdev.key_data.key_timer);
}

2、编译

onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  Makefile
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/8_irq modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/8_irq/irq.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/8_irq/irq.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  irq.ko  irq.mod.c  irq.mod.o  irq.o  Makefile  modules.order  Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ cp irq.ko ~/linux/nfs/rootfs-l
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$ ls
irq.c  irq.ko  irq.mod.c  irq.mod.o  irq.o  Makefile  modules.order  Module.symvers
onlylove@ubuntu:~/linux/driver/linux_driver/8_irq$

3、验证

/ # ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ # rm irq.ko
/ # random: nonblocking pool is initialized
ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ # insmod irq.ko
newchrdev.major = 0!
newchrdev devid = 260046848 newchrdev major=248,minor=0
key:gpio=18, irqnum=49
/ # key0_handler
key_tasklet
key0_handler
key0_handler
key_tasklet
timer_function
key0_handler
key_tasklet
key0_handler
key_tasklet
timer_function
key0_handler
key_tasklet
key0_handler
key_tasklet
timer_function

/ # rmmod irq.ko
newchrdev_exit succed!
/ # ls
bin      etc      lib      mnt      root     sys      usr
dev      irq.ko   linuxrc  proc     sbin     tmp
/ #
lqonlylove
关注
专栏目录
linux中断驱动程序
LuckyDog0623的博客
10-24 3058
1、内核和芯片初始化代码已经将异常或者中断的架构处理了。此时需要用户提供处理函数。也就说用户需要告诉内核当某一个中发生时，处理哪些内容！！ 需要使用到的注册函数request_irq int request_irq(unsigned int irq, irq_handler_t handler,unsigned long irqflags, const char *devname, void *dev_id) { （1）分配一个irqaction结构 action = kmalloc(si...
i.MX6ULL Linux开发板 ：pinctrl 子系统----按键中断控制实验
小白语记
01-21 836
# i.MX6ULL Linux开发板
linux驱动--中断&等待队列
最新发布
jcf5832的博客
08-27 1135
中断、等待队列
linux字符设备驱动之中断篇(二)
myselfzhangji的博客
06-01 769
一 前言 在谈linux中断框架时，我们先来简单回顾一下单片机中断系统的设计方式，一般地，比如gpio中断，cpu检测到发生中断，先保存被中断的现场，然后跳转到异常向量入口函数，执行中断处理函数，执行完之后，恢复之前被中断的现场，继续执行。 单片机程序中，首先分辨是哪个中断，然后调用处理函数，在中断函数中清中断(一般地，有些中断需要软件清除，有些中断在响应中断服务程序的时候会自动清除)。 本篇文章...
linux系统硬件定时器中断,问一个关于操作系统的弱智问题
weixin_35112750的博客
04-29 398
单处理器上运行多个进程，不是很明白。虽然说各进程有自己的时间片。但是在操作系统下有一个调度进程负责进程间切换等工作，如此说来该调度进程是不是一直执行的？如果一直执行，其他进程就没有执行时间了。但是它又可以对各个进程进行调度。单CPU上一个时刻只运行一条指令，该指令明显只能属于一个活动进程。那到底是怎么做到的呢？|谁跟你说有调度进程的？进程的调度都是通过定时器实现的，没有专门一个进程负责调度比如1...
Linux中断流程分析
Android开发
12-09 1151
参考文档 IHI0048B_b_gic_architecture_specification.pdf IHI0069E_gic_architecture_specification.pdf DUI0471M_software_development_guide.pdf GIC400架构 中断的类型 SGI:software generatedinterrupt,软件出发产生...
Linux设备驱动开发详解：基于最新的Linux4.0内核,linux设备驱动开发详解pdf,LINUX
09-10
《Linux设备驱动开发详解》是一本深度探讨Linux内核驱动程序开发的专业书籍，它以Linux 4.0内核为背景，为驱动工程师提供了一条深入理解与实践Linux设备驱动的路径。这本书涵盖了许多关键的知识点，对于想要在Linux...
《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码.zip
04-29
Linux驱动开发是连接硬件与操作系统内核的重要桥梁，对于理解和优化系统的性能至关重要。在Linux系统中，驱动程序是作为内核的一部分运行，它们负责处理硬件的输入和输出，使应用程序能够通过标准接口与硬件交互。 ...
《Linux设备驱动开发详解——基于最新的Linux4.0内核》源码.zip
02-10
1. **驱动程序的结构**：理解Linux驱动的基本结构，包括初始化、设备注册、设备注销、中断处理等关键函数。 2. **字符设备驱动**：学习如何创建和管理字符设备，使用`struct file_operations`结构体定义设备的操作...
Linux设备驱动开发详解-基于最新的Linux4.0内核》配套代码.zip
02-10
《Linux设备驱动开发详解-基于最新的Linux4.0内核》是一本深入讲解Linux设备驱动程序开发的专业书籍，配套代码存放在"learn-ldd-master-main"这个压缩包中，旨在帮助开发者理解并掌握在嵌入式Linux系统上编写驱动...
GIC驱动代码分析
Rain的专栏
01-09 948
GIC驱动代码分析 作者：linuxer 发布于：2014-7-4 14:34 分类：Linux内核分析 一、前言 GIC（Generic Interrupt Controller）是ARM公司提供的一个通用的中断控制器。GIC通过AMBA（Advanced Microcontroller Bus Architecture）这样的片上总线连接到一个或者多个ARM processo
linux IRQ Management（六）- DTS及调试
weixin_41028621的博客
09-30 1981
了解DTS Interrupt 设置方式。 1.DTS 中 interrupt 描述 interrupt-controller - 一个空的属性定义， 该节点作为一个接收中断信号的设备。 #interrupt-cells - 这是一个中断控制器节点的属性。它声明了该中断控制器的中断指示符中 cell 的个数（类似于 #address-cells 和 #size-cells）。 in...
Linux驱动进阶(三)——中断与时钟机制
m0_56145255的博客
07-13 1651
中断和时钟机制是Linux驱动中重要的两项技术。使用这些技术，可以帮助驱动程序更高效地完成任务。在写设备驱动程序的过程中，为了使系统知道硬件在做什么，必须使用中断。如果没有中断，设备几乎什么都不能做。本章将详细讲解中断与时钟机制。
设备树学习总结：
a1809032425的博客
09-23 1514
设备树学习链接： 1、https://blog.csdn.net/qq_41782149/article/details/101149210 2、https://blog.csdn.net/Klaus_Wei/article/details/42915545 3、https://blog.csdn.net/stoic163/article/details/56489195 4、https://www.cnblogs.com/liuwanpeng/p/7421661.html ...
linux安装nginx详细步骤和make编译报错问题（保姆级）
热门推荐
weixin_69306012的博客
09-09 1万+
保姆级教程
arm linux gpio 中断,arm-linux-2.6.29的GPIO宏与中断使用个人备忘录
weixin_31966453的博客
05-14 170
ARM中linux中断使用方法：1.定义中断号结构体，在申请中断前在模块加载函数中定义此GPIO的功能为中断功能，设置中断触发方式：例如按键中断中：(1)结构体：static struct key_info{intirq_no;//中断号unsigned intgpio_port;//GPIO端口intkey_no;//键值} key_info_tab[4]={{IRQ_EINT10,S3C...
Linux Kernel 5.14 arm64异常向量表解读-中断处理解读
baron-周贺贺-代码改变世界ctw
09-11 4545
Linux Kernel arm64中断向量表的定义 (linux/arch/arm64/kernel/entry.S) /* * Exception vectors. */ .pushsection ".entry.text", "ax" .align 11 SYM_CODE_START(vectors) kernel_ventry 1, sync_invalid // Synchronous EL1t kernel_ventry 1, irq_invalid // IRQ EL1
Exynos4412 中断驱动开发（三）—— 设备树中中断节点的创建
知秋一叶
03-17 1万+
提到中断就必须了解到GIC，下面先了解一下GIC 一、GIC概念         GIC（Generic Interrupt Controller）是ARM公司提供的一个通用的中断控制器。GIC通过AMBA（Advanced Microcontroller Bus Architecture）这样的片上总线连接到一个或者多个ARM processor上。         下面是Exynos44
Linux UART驱动开发详解：接口、中断与终端集成
2. Linux中断机制及中断共享： 文档强调了Linux的中断处理机制，包括中断的开启与关闭，以及中断共享。中断是串口通信的关键，它允许设备在数据可用时通知CPU，从而提高了效率。中断共享机制确保在多个串口同时使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值