1、在stm32mp157d-atk.dts文件中添加“led0”和“key0”节点
打开虚拟机上“VSCode”，点击“文件”，点击“打开文件夹”，点击“zgq”，点击“linux”，点击“atk-mp1”，点击“linux”，点击“my_linux”，点击“linux-5.4.31”，点击“确定”，点击“stm32mp157d-atk.dts”。
stm32mp157d-atk.dts文件如下：
/dts-v1/;
#include "stm32mp157.dtsi"
#include "stm32mp15xd.dtsi"
#include "stm32mp15-pinctrl.dtsi"
#include "stm32mp15xxaa-pinctrl.dtsi"
#include "stm32mp157-m4-srm.dtsi"
#include "stm32mp157-m4-srm-pinctrl.dtsi"
#include "stm32mp157d-atk.dtsi"
/ {
model = "STMicroelectronics STM32MP157D eval daughter";
/*model属性用于描述开发板的名字或设备模块的信息*/
compatible = "st,stm32mp157d-ed1", "st,stm32mp157";
/*compatible属性用于将设备和驱动绑定起来*/
chosen { /*chosen子节点*/
stdout-path = "serial0:115200n8";
};
aliases { /*aliases子节点*/
serial0 = &uart4;
/*给&uart4起个别名叫“serial0”*/
};
reserved-memory {
gpu_reserved: gpu@f6000000 { /*gpu节点标签为gpu_reserved*/
reg = <0xf6000000 0x8000000>;
no-map;
};
optee_memory: optee@fe000000 {
reg = <0xfe000000 0x02000000>;
no-map;
};
};
stm32mp1_led {
compatible = "atkstm32mp1-led";
/*compatible属性用于将设备stm32mp1_led和驱动“.ko”绑定起来*/
status = "okay";
reg = <0X50000A28 0X04 /* RCC_MP_AHB4ENSETR */
0X5000A000 0X04 /* GPIOI_MODER */
0X5000A004 0X04 /* GPIOI_OTYPER */
0X5000A008 0X04 /* GPIOI_OSPEEDR */
0X5000A00C 0X04 /* GPIOI_PUPDR */
0X5000A018 0X04 >; /* GPIOI_BSRR */
};
};
&cpu1{
cpu-supply = <&vddcore>;
};
&gpu {
contiguous-area = <&gpu_reserved>;
status = "okay";
};
&optee {
status = "okay";
};
修改后的stm32mp157d-atk.dts文件如下：
/dts-v1/;
#include "stm32mp157.dtsi"
#include "stm32mp15xd.dtsi"
#include "stm32mp15-pinctrl.dtsi"
#include "stm32mp15xxaa-pinctrl.dtsi"
#include "stm32mp157-m4-srm.dtsi"
#include "stm32mp157-m4-srm-pinctrl.dtsi"
#include "stm32mp157d-atk.dtsi"
/ {
model = "STMicroelectronics STM32MP157D eval daughter";
/*model属性用于描述开发板的名字或设备模块的信息*/
compatible = "st,stm32mp157d-ed1", "st,stm32mp157";
/*compatible属性用于将设备和驱动绑定起来*/
chosen { /*chosen子节点*/
stdout-path = "serial0:115200n8";
};
aliases { /*aliases子节点*/
serial0 = &uart4;
/*给&uart4起个别名叫“serial0”*/
};
reserved-memory {
gpu_reserved: gpu@f6000000 { /*gpu节点标签为gpu_reserved*/
reg = <0xf6000000 0x8000000>;
no-map;
};
optee_memory: optee@fe000000 {
reg = <0xfe000000 0x02000000>;
no-map;
};
};
stm32mp1_led {
compatible = "atkstm32mp1-led";
/*compatible属性用于将设备stm32mp1_led和驱动“.ko”绑定起来*/
status = "okay";
reg = <0X50000A28 0X04 /* RCC_MP_AHB4ENSETR */
0X5000A000 0X04 /* GPIOI_MODER */
0X5000A004 0X04 /* GPIOI_OTYPER */
0X5000A008 0X04 /* GPIOI_OSPEEDR */
0X5000A00C 0X04 /* GPIOI_PUPDR */
0X5000A018 0X04 >; /* GPIOI_BSRR */
};
led0 {
compatible = "zgq,led";
status = "okay";
led-gpio = <&gpioi 0 GPIO_ACTIVE_LOW>;
};
key0 {
compatible = "zgq,key";
status = "okay";
key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>;
interrupt-parent = <&gpiog>;
/*指定父中断器为&gpiog*/
interrupts = <3 IRQ_TYPE_EDGE_FALLING>;
/*指定中断号为3，中断类型和触发方式为下降沿触发*/
};
};
&cpu1{
cpu-supply = <&vddcore>;
};
&gpu {
contiguous-area = <&gpu_reserved>;
status = "okay";
};
&optee {
status = "okay";
};
见下图：
2、编译设备树
1)、在VSCode终端，输入“make dtbs回车”，执行编译设备树
2)、输入“ls arch/arm/boot/uImage -l”
查看是否生成了新的“uImage”文件
3)、输入“ls arch/arm/boot/dts/stm32mp157d-atk.dtb -l”
查看是否生成了新的“stm32mp157d-atk.dtb”文件
拷贝输出的文件：
4)、输入“cp arch/arm/boot/uImage /home/zgq/linux/atk-mp1/linux/bootfs/ -f回车”，执行文件拷贝，准备烧录到EMMC；
5)、输入“cp arch/arm/boot/dts/stm32mp157d-atk.dtb /home/zgq/linux/atk-mp1/linux/bootfs/ -f回车”，执行文件拷贝，准备烧录到EMMC
6)、输入“cp arch/arm/boot/uImage /home/zgq/linux/tftpboot/ -f回车”，执行文件拷贝，准备从tftp下载；
7)、输入“cp arch/arm/boot/dts/stm32mp157d-atk.dtb /home/zgq/linux/tftpboot/ -f回车”，执行文件拷贝，准备从tftp下载；
8)、输入“ls -l /home/zgq/linux/atk-mp1/linux/bootfs/回车”，查看“/home/zgq/linux/atk-mp1/linux/bootfs/”目录下的所有文件和文件夹
9)、输入“ls -l /home/zgq/linux/tftpboot/回车”，查看“/home/zgq/linux/tftpboot/”目录下的所有文件和文件夹
输入“chmod 777 /home/zgq/linux/tftpboot/stm32mp157d-atk.dtb回车”
给“stm32mp157d-atk.dtb”文件赋予可执行权限
输入“chmod 777 /home/zgq/linux/tftpboot/uImage回车” ,给“uImage”文件赋予可执行权限
输入“ls /home/zgq/linux/tftpboot/回车”，查看“/home/zgq/linux/tftpboot/”目录下的所有文件和文件夹
3、查看“led0”节点和“key0”节点
启动开发板，从网络下载程序
输入“root”
输入“cd /proc/device-tree/回车”
切换到“/sys/firmware/devicetree/base”目录
输入“ls”查看“led0”节点和“key0”节点设备是否存在
输入“cd led0/回车”
输入“ls”查看“/sys/firmware/devicetree/base/led0”目录下的文件和文件夹
输入“cat compatible回车”
输入“cat led-gpio回车”
输入“cat name回车”
输入“cat status回车”
输入“cd ../回车”，返回到“/sys/firmware/devicetree/base”目录
输入“cd key0/回车”
输入“ls”查看“/sys/firmware/devicetree/base/key0”目录下的文件和文件夹
输入“cat compatible回车”
输入“cat key-gpio回车”
输入“cat name回车”
输入“cat status回车”
输入“cat interrupt-parent回车”
输入“cat interrupts回车”
4、创建EXTI目录
输入“cd /home/zgq/linux/Linux_Drivers/回车”
切换到“/home/zgq/linux/Linux_Drivers/”
输入“ls回车”，查看“/home/zgq/linux/Linux_Drivers/”
输入“mkdir EXTI3回车”，创建“EXTI3”目录
输入“ls回车”，查看“/home/zgq/linux/Linux_Drivers/”
5、添加“EXTI3.c”
#include "EXTI3.h"
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/of_gpio.h>
//使能of_gpio_named_count(),of_gpio_count(),of_get_named_gpio()
#include <linux/delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <linux/of_irq.h>
//使能irq_of_parse_and_map()
#include <linux/interrupt.h>
//request_irq(),free_irq(),enable_irq(),disable_irq(),disable_irq_nosync()struct Button_dev strButton;int Get_gpio_Button_num(void);
int Button_gpio_request(void);
void Button_free(void);
int Read_Button(void);static irqreturn_t key_interrupt_fun(int irq, void *dev_id)
{unsigned long flags;spin_lock_irqsave(&strButton.spinlock, flags);/* 自旋锁上锁 */strButton.button_irq_status = 1; /*记录按键产生中断*/spin_unlock_irqrestore(&strButton.spinlock, flags);/* 自旋锁解锁 */return IRQ_HANDLED;
}int Get_gpio_Button_num(void)
{int ret = 0;const char *str;strButton.keyvalue=0;spin_lock_init(&strButton.spinlock);/* 初始化自旋锁 *//* 设置Button所使用的GPIO *//* 1、获取设备节点：strButton */strButton.nd = of_find_node_by_path("/key0");//path="/key0，使用“全路径的节点名“在“stm32mp157d-atk.dts“中查找节点“key0”//返回值:返回找到的节点，如果为NULL，表示查找失败。if(strButton.nd == NULL) {printk("key0 device node not find!\r\n");return -EINVAL;}/* 2.读取status属性 */ret = of_property_read_string(strButton.nd, "status", &str);//在key0节点中，status = "okay";//指定的设备节点strButton.nd//proname="status"，给定要读取的属性名字//out_string=str:返回读取到的属性值//返回值:0，读取成功，负值，读取失败。if(ret < 0) return -EINVAL;if(strcmp(str, "okay")) return -EINVAL;//strcmp(s1,s2),当s1<s2时，返回值为负数//strcmp(s1,s2),当s1>2时，返回值为正数//strcmp(s1,s2),当s1=s2时，返回值为0/* 3、获取compatible属性值并进行匹配 */ret = of_property_read_string(strButton.nd, "compatible", &str);//在key0节点中，compatible = "zgq,key";//指定的设备节点strButton.nd//proname="compatible"，给定要读取的属性名字//out_string=str:返回读取到的属性值//返回值:0，读取成功，负值，读取失败。if(ret < 0) {printk("key0 node: Failed to get compatible property\n"); return -EINVAL;}if (strcmp(str, "zgq,key")) {printk("key0 node: Compatible match failed\n");return -EINVAL;}/* 4、 根据设备树中的"key-gpio"属性，得到key0所使用的key0编号 */strButton.button_gpio_number = of_get_named_gpio(strButton.nd, "key-gpio", 0);//在key0节点中，key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>//np=strButton.nd,指定的“设备节点”//propname="key-gpio"，给定要读取的属性名字//Index=0,给定的GPIO索引为0//返回值：正值，获取到的GPIO编号；负值，失败。if(strButton.button_gpio_number < 0) {printk("can't get key-gpio");return -EINVAL;}/* 5 、获取GPIO对应的中断号 */strButton.irq_num = irq_of_parse_and_map(strButton.nd, 0);//dev=strButton.nd：为设备节点;//Index=0：索引号，intemrupts属性可能包含多条中断信息，通过index指定要获取的信息；//返回值：中断号；if(!strButton.irq_num){return -EINVAL;}printk("key-gpio num = %d\r\n", strButton.button_gpio_number);//打印结果为：“key-gpio num = 99“//因为GPIO编号是从0开始的，GPIOG端口的序号是6，每个端口有16个IO口，因此GPIOI0的编号为6*16 + 3 = 99return 0;
}int Button_gpio_request(void)
{int ret = 0;unsigned long irq_flags;/* 5.向gpio子系统申请使用“gpio编号” */ret = gpio_request(strButton.button_gpio_number, "Button0");//gpio=strButton.button_gpio_number，指定要申请的“gpio编号”//label="Button"，给这个gpio引脚设置个名字为"Button"//返回值：0，申请“gpio编号”成功;其他值，申请“gpio编号”失败；if (ret) {printk(KERN_ERR "Button: Failed to request key0\n");return ret;}/* 6、设置PG3为输入模式*/ret = gpio_direction_input(strButton.button_gpio_number);//gpio=strButton.button_gpio_number,指定的“gpio编号”if(ret < 0) {printk("can't set gpio!\r\n");}/* 获取设备树中指定的中断触发类型 */irq_flags = irq_get_trigger_type(strButton.irq_num);//strButton.irq_num为中断号if ( irq_flags==IRQF_TRIGGER_NONE )irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;/*申请中断*/ret = request_irq(strButton.irq_num, key_interrupt_fun, irq_flags, "Key0_IRQ", NULL);//irq=strButton.irq_num：要申请中断的中断号；//handler=key_interrupt_fun：中断处理函数，当中断发生以后就会执行此中断处理函数；//fags=irq_flags：中断标志；可以在文件“include/linux/interrupt.h”里面查看所有的中断标志；//name="Key0_IRQ"：中断名字，设置以后可以在“/proc/interrupts”文件中看到对应的中断名字；//dev=NULL：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断。//一般情况下将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。//返回值：0表示中断申请成功，如果返回“-EBUSY”的话表示中断已经被申请过了, 其他负值，表示中断申请失败。if (ret) {printk(KERN_ERR "Button: Failed to request irq\n");return ret;}return 0;
}//函数功能：释放Button的gpio
void Button_free(void)
{free_irq(strButton.irq_num, NULL); /* 释放中断 */gpio_free(strButton.button_gpio_number);/* 释放IO */
}//读取按键的值
int Read_Button(void)
{unsigned long flags;int irq_status;u8 ch;int status;spin_lock_irqsave(&strButton.spinlock, flags);/* 自旋锁上锁 */irq_status=strButton.button_irq_status; /*读取按键中断标志*/if(irq_status)//按键中断{ch=0;if (gpio_get_value(strButton.button_gpio_number) == 0) ch=1;mdelay(150);//延时150毫秒if (gpio_get_value(strButton.button_gpio_number) == 0) ch=(u8)(ch<<1);if(ch==0x02){status=KEY_PRESS; /* 按钮被按下*/}else{status=KEY_RELEASE; /*按钮抖动*/ }if(status==KEY_PRESS)//按钮按下有效{if(strButton.keyvalue==1){strButton.keyvalue=0;printk("Button: off\r\n");}else{strButton.keyvalue=1;printk("Button: on\r\n");}}}strButton.button_irq_status=0; /*取消按键中断标志，为下次读按键中断作准备*/spin_unlock_irqrestore(&strButton.spinlock, flags);/* 自旋锁解锁 */return strButton.keyvalue;
}
6、添加“EXTI3.h”
#ifndef __EXTI3_H
#define __EXTI3_H#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/of.h> //使能device_node结构
#include <linux/spinlock_types.h> //使能spinlock_t结构#define KEY_PRESS 1 /* 按键按下 */
#define KEY_RELEASE 0 /* 按键松开 */struct Button_dev{struct device_node *nd; /*设备节点*/int button_gpio_number; /*Button所使用的GPIO编号*/int irq_num; /* 中断号 */spinlock_t spinlock; /* 自旋锁 */int button_irq_status;int keyvalue;
};
extern struct Button_dev strButton;extern int Get_gpio_Button_num(void);
extern int Button_gpio_request(void);
extern void Button_free(void);
extern int Read_Button(void);#endif
7、添加“EXTI3_drv.c”
#include "EXTI3_drv.h"
#include "EXTI3.h"
#include <linux/types.h>
//数据类型重命名
//使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
//使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
#include <linux/ide.h>
//使能copy_from_user(),copy_to_user()
#include <linux/module.h>
//使能EXTI3Driver_init(),EXTI3Driver_exit()
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/spinlock.h>
//使能DEFINE_SPINLOCK()，spin_lock_init(),spin_lock(),spin_trylock(),spin_is_locked()
//spin_lock_irq(),spin_unlock_irq(),spin_lock_irqsave(),spin_unlock_irqrestore()#define EXTI3Driver_CNT 1 //定义设备数量为1
#define EXTI3Driver_NAME "EXTI3Driver" //定义设备的名字struct EXTI3Driver_dev strEXTI3Driver;/* 打开设备 */
static int EXTI3Driver_open(struct inode *inode, struct file *filp)
{/*通过判断原子变量的值来检查EXTI3有没有被别的应用使用*/if (!atomic_dec_and_test(&strEXTI3Driver.lock)){//当strEXTI3Driver.lock.counter=1时，atomic_dec_and_test()返回1//从strEXTI3Driver.lock.counter减1，如果结果为0就返回1，否则返回0;atomic_inc(&strEXTI3Driver.lock);/*小于0的话就加1,使其原子变量等于0*/return -EBUSY; /* EXTI3被使用，返回忙*/}filp->private_data = &strEXTI3Driver; /*设置私有数据*/printk("EXTI3Driver_open!\r\n");return 0;
}/* 从设备读取数据，保存到首地址为buf的数据块中，长度为cnt个字节 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{int ret = 0;int value;value=Read_Button();//读取按键的值 ret = copy_to_user(buf, &value, sizeof(value));//将value拷贝到buf[]中return ret;
}/* 向设备写数据，将数据块首地址为buf的数据，长度为cnt个字节，发送给用户 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{return 0;
}/* 关闭/释放设备 */
static int EXTI3Driver_release(struct inode *inode, struct file *filp)
{struct EXTI3Driver_dev *dev = filp->private_data;atomic_inc(&dev->lock);/*关闭驱动文件的时候释放原子变量，便于其它线程使用*/printk("EXTI3Driver_release!\r\n");return 0;
}/*声明file_operations结构变量MyCharDevice_fops*/
/*它是指向设备的操作函数集合变量*/
const struct file_operations EXTI3Driver_fops = {.owner = THIS_MODULE,.open = EXTI3Driver_open,.read = EXTI3Driver_read,.write = EXTI3Driver_write,.release = EXTI3Driver_release,
};/*驱动入口函数 */
static int __init EXTI3Driver_init(void)
{int ret;strEXTI3Driver.lock = (atomic_t)ATOMIC_INIT(0);/*初始化原子变量*/atomic_set(&strEXTI3Driver.lock, 1);/*原子变量初始值strEXTI3Driver.lock.counter=1*/ret=Get_gpio_Button_num();//读引脚编号if(ret < 0) return ret; /* 1、申请“gpio编号”*/ret=Button_gpio_request();//申请“gpio编号” if(ret < 0) return ret;//向gpio子系统申请使用“gpio编号” 失败/*2、申请设备号*/strEXTI3Driver.major=0;if(strEXTI3Driver.major)/*如果指定了主设备号*/{strEXTI3Driver.devid = MKDEV(strEXTI3Driver.major, 0);//输入参数strEXTI3Driver.major为“主设备号”//输入参数0为“次设备号”，大部分驱动次设备号都选择0//将strEXTI3Driver.major左移20位，再与0相或，就得到“Linux设备号”ret=register_chrdev_region( strEXTI3Driver.devid,\EXTI3Driver_CNT, \EXTI3Driver_NAME );//strEXTI3Driver.devid表示起始设备号//EXTI3Driver_CNT表示次设备号的数量//EXTI3Driver_NAME表示设备名if(ret < 0)goto free_gpio;}else{ /* 没有定义设备号 */ret=alloc_chrdev_region( &strEXTI3Driver.devid,\0, \EXTI3Driver_CNT,\EXTI3Driver_NAME);/* 申请设备号 *///strEXTI3Driver.devid：保存申请到的设备号//0：次设备号的起始地址//EXTI3Driver_CNT：要申请的次设备号数量；//EXTI3Driver_NAME：表示“设备名字”if(ret < 0)goto free_gpio;strEXTI3Driver.major = MAJOR(strEXTI3Driver.devid);/* 获取分配号的主设备号 *///输入参数strEXTI3Driver.devid为“Linux设备号”//将strEXTI3Driver.devid右移20位得到“主设备号”strEXTI3Driver.minor = MINOR(strEXTI3Driver.devid);/* 获取分配号的次设备号 *///输入参数strEXTI3Driver.devid为“Linux设备号”//将strEXTI3Driver.devid与0xFFFFF相与后得到“次设备号”}/*3、注册字符设备*/strEXTI3Driver.cdev.owner = THIS_MODULE;//使用THIS_MODULE将owner指针指向当前这个模块cdev_init(&strEXTI3Driver.cdev,&EXTI3Driver_fops);//注册字符设备，初始化“字符设备结构变量strEXTI3Driver.cdev”//strEXTI3Driver.cdev是等待初始化的结构体变量//EXTI3Driver_fops就是字符设备文件操作函数集合/*4、添加字符设备*/ret=cdev_add(&strEXTI3Driver.cdev,strEXTI3Driver.devid,EXTI3Driver_CNT);//添加字符设备/*&strEXTI3Driver.cdev表示指向要添加的字符设备，即字符设备结构strEXTI3Driver.cdev变量*///strEXTI3Driver.devid表示设备号//EXTI3Driver_CNT表示需要添加的设备数量if(ret < 0 ) //添加字符设备失败goto del_register;printk("dev id major = %d,minor = %d\r\n", strEXTI3Driver.major, strEXTI3Driver.minor);printk("EXTI3Driver_init is ok!!!\r\n");/*5、自动创建设备节点 */strEXTI3Driver.class =class_create(THIS_MODULE, EXTI3Driver_NAME);if (IS_ERR(strEXTI3Driver.class)){goto del_cdev;}/*6、创建设备 */strEXTI3Driver.device = device_create(strEXTI3Driver.class, NULL, strEXTI3Driver.devid, NULL, EXTI3Driver_NAME);//创建设备//设备要创建在strEXTI3Driver.class类下面//NULL表示没有父设备//strEXTI3Driver.devid是设备号;//参数drvdata=NULL，设备没有使用数据//EXTI3Driver_NAME是设备名字//如果设置fmt=EXTI3Driver_NAME 的话，就会生成/dev/EXTI3Driver_NAME设备文件。//返回值就是创建好的设备。if (IS_ERR(strEXTI3Driver.device)){goto destroy_class;}return 0;destroy_class:class_destroy(strEXTI3Driver.class);//删除类//strEXTI3Driver.class就是要删除的类del_cdev:cdev_del(&strEXTI3Driver.cdev);//删除字符设备//&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构strEXTI3Driver.cdev变量del_register:unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);/* 释放设备号 *///strEXTI3Driver.devid：需要释放的起始设备号//EXTI3Driver_CNT：需要释放的次设备号数量；free_gpio://申请设备号失败/*释放gpio编号*/Button_free();return -EIO;
}/*驱动出口函数 */
static void __exit EXTI3Driver_exit(void)
{/*1、删除字符设备*/cdev_del(&strEXTI3Driver.cdev);/*删除字符设备*//*&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构&strEXTI3Driver.cdev变量*//*2、 释放设备号 */unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);/*释放设备号 *///strEXTI3Driver.devid：需要释放的起始设备号//EXTI3Driver_CNT：需要释放的次设备号数;/*3、 删除设备 */device_destroy(strEXTI3Driver.class, strEXTI3Driver.devid);//删除创建的设备//strEXTI3Driver.class是要删除的设备所处的类//strEXTI3Driver.devid是要删除的设备号/*4、删除类*/class_destroy(strEXTI3Driver.class);//删除类//strEXTI3Driver.class就是要删除的类/*5、释放gpio编号*/Button_free();
}module_init(EXTI3Driver_init);
//指定EXTI3Driver_init()为驱动入口函数
module_exit(EXTI3Driver_exit);
//指定EXTI3Driver_exit()为驱动出口函数MODULE_AUTHOR("Zhanggong");//添加作者名字
MODULE_LICENSE("GPL");//LICENSE采用“GPL协议”
MODULE_INFO(intree,"Y");
//去除显示“loading out-of-tree module taints kernel.”
8、添加“EXTI3_drv.h”
#ifndef __EXTI3_DRIVER_H
#define __EXTI3_DRIVER_H#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/cdev.h> //使能cdev结构
#include <linux/cdev.h> //使能class结构和device结构struct EXTI3Driver_dev{dev_t devid; /*声明32位变量devid用来给保存设备号*/int major; /*主设备号*/int minor; /*次设备号*/struct cdev cdev; /*字符设备结构变量cdev */struct class *class; /*类*/struct device *device; /*设备*/atomic_t lock; /*原子变量*/
};
extern struct EXTI3Driver_dev strEXTI3Driver;#endif
9、添加“LED.c”
#include "LED.h"
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/of_gpio.h>
//使能of_gpio_named_count(),of_gpio_count(),of_get_named_gpio()struct MyLED_dev strMyLED;int Get_led0_num(void);
int led_GPIO_request(void);
void MyLED_free(void);
void led_switch(u8 sta);int Get_led0_num(void)
{int ret = 0;const char *str;/* 设置LED所使用的GPIO *//* 1、获取设备节点：strMyLED */strMyLED.nd = of_find_node_by_path("/led0");//path="/led0，使用“全路径的节点名“在“stm32mp157d-atk.dts“中查找节点“led0”//返回值:返回找到的节点，如果为NULL，表示查找失败。if(strMyLED.nd == NULL) {printk("led0 node not find!\r\n");return -EINVAL;}/* 2.读取status属性 */ret = of_property_read_string(strMyLED.nd, "status", &str);//在led0节点中，status = "okay";//指定的设备节点strMyLED.nd//proname="status"，给定要读取的属性名字//out_string=str:返回读取到的属性值//返回值:0，读取成功，负值，读取失败。if(ret < 0) return -EINVAL;if (strcmp(str, "okay")) return -EINVAL;//strcmp(s1,s2),当s1<s2时，返回值为负数//strcmp(s1,s2),当s1>2时，返回值为正数//strcmp(s1,s2),当s1=s2时，返回值为0/* 3、获取compatible属性值并进行匹配 */ret = of_property_read_string(strMyLED.nd, "compatible", &str);//在led0节点中，compatible = "zgq,led";//指定的设备节点strMyLED.nd//proname="compatible"，给定要读取的属性名字//out_string=str:返回读取到的属性值//返回值:0，读取成功，负值，读取失败。if(ret < 0) {printk("led0 node: Failed to get compatible property\n"); return -EINVAL;}if (strcmp(str, "zgq,led")) {printk("led0 node: Compatible match failed\n");return -EINVAL;}/* 4、 根据设备树中的"led-gpio"属性，得到LED所使用的LED编号 */strMyLED.led_gpio_number = of_get_named_gpio(strMyLED.nd, "led-gpio", 0);//在led0节点中，led-gpio = <&gpioi 0 GPIO_ACTIVE_LOW>//np=strMyLED.nd,指定的“设备节点”//propname="led-gpio"，给定要读取的属性名字//Index=0,给定的GPIO索引为0//返回值：正值，获取到的GPIO编号；负值，失败。if(strMyLED.led_gpio_number < 0) {printk("can't get led-gpio");return -EINVAL;}printk("led-gpio num = %d\r\n", strMyLED.led_gpio_number);//打印结果为：“led-gpio num = 128“//因为GPIO编号是从0开始的，GPIOI端口的序号是8，每个端口有16个IO口，因此GPIOI0的编号为8*16=128return 0;
}int led_GPIO_request(void)
{int ret = 0;/* 5.向gpio子系统申请使用“gpio编号” */ret = gpio_request(strMyLED.led_gpio_number, "LED-GPIO");//gpio=strMyLED.led_gpio_number，指定要申请的“gpio编号”//Iabel="LED-GPIO"，给这个gpio引脚设置个名字为"LED-GPIO"//返回值：0，申请“gpio编号”成功;其他值，申请“gpio编号”失败；if (ret) {printk(KERN_ERR "strMyLED: Failed to request led-gpio\n");return ret;}/* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */ret = gpio_direction_output(strMyLED.led_gpio_number, 1);//gpio=strMyLED.led_gpio_number,指定的“gpio编号”，这里是128，对应的是GI0引脚//value=1，设置引脚输出高电平//返回值：0，设置“引脚输出为vakued的值”成功;负值，设置“引脚输出为vakued的值”失败。if(ret < 0) {printk("can't set gpio!\r\n");}return 0;
}//函数功能：释放MyLED的gpio
void MyLED_free(void)
{gpio_free(strMyLED.led_gpio_number);
}void led_switch(u8 sta)
{if(sta == LEDON) {gpio_set_value(strMyLED.led_gpio_number, 0); /* 打开LED灯 */}
else if(sta == LEDOFF) {gpio_set_value(strMyLED.led_gpio_number, 1); /* 关闭LED灯 */}
}10、添加“LED.h”
#ifndef __LED_H
#define __LED_H#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/of.h> //使能device_node结构#define LEDOFF 0 /* 关灯 */
#define LEDON 1 /* 开灯 */struct MyLED_dev{struct device_node *nd; /*设备节点*/int led_gpio_number; /*led所使用的GPIO编号*/
};
extern struct MyLED_dev strMyLED;extern int Get_led0_num(void);
extern int led_GPIO_request(void);
extern void MyLED_free(void);
extern void led_switch(u8 sta);#endif11、添加“LED_drv.c”
#include "LED_drv.h"
#include "LED.h"
#include <linux/types.h>
//数据类型重命名
//使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
//使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
#include <linux/ide.h>
//使能copy_from_user(),copy_to_user()
#include <linux/module.h>
//使能LEDDriver_init(),LEDDriver_exit()
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//gpio_direction_output(),gpio_get_value(),gpio_set_value()#define LEDDriver_CNT 1 //定义设备数量为1
#define LEDDriver_NAME "LEDDriver" //定义设备的名字struct LEDDriver_dev strLEDDriver;/* 打开设备 */
static int LEDDriver_open(struct inode *inode, struct file *filp)
{/*通过判断原子变量的值来检查LED有没有被别的应用使用*/if (!atomic_dec_and_test(&strLEDDriver.lock)){//当strLEDDriver.lock.counter=1时，atomic_dec_and_test()返回1//从strLEDDriver.lock.counter减1，如果结果为0就返回1，否则返回0;atomic_inc(&strLEDDriver.lock);/*小于0的话就加1,使其原子变量等于0*/return -EBUSY; /* LED被使用，返回忙*/}filp->private_data = &strLEDDriver; /*设置私有数据*/printk("LEDDriver_open!\r\n");return 0;
}/* 从设备读取数据，保存到首地址为buf的数据块中，长度为cnt个字节 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t LEDDriver_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{return 0;
}/* 向设备写数据，将数据块首地址为buf的数据，长度为cnt个字节，发送给用户 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t LEDDriver_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{int ret = 0;unsigned char databuf[1];unsigned char ledstat;ret = copy_from_user(databuf, buf, cnt);
//将buf[]中的前cnt个字节拷贝到databuf[]中if(ret <0){printk("kernel write failed!\r\n");ret = -EFAULT;}ledstat = databuf[0];/*获取到应用传递进来的开关灯状态*/led_switch(ledstat);/*执行开灯或执行关灯*/return ret;
}/* 关闭/释放设备 */
static int LEDDriver_release(struct inode *inode, struct file *filp)
{struct LEDDriver_dev *dev = filp->private_data;atomic_inc(&dev->lock);/*关闭驱动文件的时候释放原子变量，便于其它线程使用*/printk("LEDDriver_release!\r\n");return 0;
}/*声明file_operations结构变量MyCharDevice_fops*/
/*它是指向设备的操作函数集合变量*/
const struct file_operations LEDDriver_fops = {.owner = THIS_MODULE,.open = LEDDriver_open,.read = LEDDriver_read,.write = LEDDriver_write,.release = LEDDriver_release,
};/*驱动入口函数 */
static int __init LEDDriver_init(void)
{int ret;strLEDDriver.lock = (atomic_t)ATOMIC_INIT(0);/*初始化原子变量*/atomic_set(&strLEDDriver.lock, 1);/*原子变量初始值strLEDDriver.lock.counter=1*/ret=Get_led0_num();//读引脚编号if(ret < 0) return ret; /* 1、申请“gpio编号”*/ret=led_GPIO_request();//申请“gpio编号” if(ret < 0) return ret;//向gpio子系统申请使用“gpio编号” 失败/*2、申请设备号*/strLEDDriver.major=0;if(strLEDDriver.major)/*如果指定了主设备号*/{strLEDDriver.devid = MKDEV(strLEDDriver.major, 0);//输入参数strLEDDriver.major为“主设备号”//输入参数0为“次设备号”，大部分驱动次设备号都选择0//将strLEDDriver.major左移20位，再与0相或，就得到“Linux设备号”
ret=register_chrdev_region( strLEDDriver.devid,\LEDDriver_CNT, \LEDDriver_NAME );//strLEDDriver.devid表示起始设备号//LEDDriver_CNT表示次设备号的数量//LEDDriver_NAME表示设备名if(ret < 0)goto free_gpio;}else{ /* 没有定义设备号 */
ret=alloc_chrdev_region( &strLEDDriver.devid,\0, \LEDDriver_CNT,\LEDDriver_NAME);/* 申请设备号 *///strLEDDriver.devid：保存申请到的设备号//0：次设备号的起始地址//LEDDriver_CNT：要申请的次设备号数量；//LEDDriver_NAME：表示“设备名字”if(ret < 0)goto free_gpio;strLEDDriver.major = MAJOR(strLEDDriver.devid);/* 获取分配号的主设备号 *///输入参数strLEDDriver.devid为“Linux设备号”//将strLEDDriver.devid右移20位得到“主设备号”strLEDDriver.minor = MINOR(strLEDDriver.devid);/* 获取分配号的次设备号 *///输入参数strLEDDriver.devid为“Linux设备号”//将strLEDDriver.devid与0xFFFFF相与后得到“次设备号”}/*3、注册字符设备*/strLEDDriver.cdev.owner = THIS_MODULE;//使用THIS_MODULE将owner指针指向当前这个模块cdev_init(&strLEDDriver.cdev,&LEDDriver_fops);//注册字符设备，初始化“字符设备结构变量strLEDDriver.cdev”//strLEDDriver.cdev是等待初始化的结构体变量//LEDDriver_fops就是字符设备文件操作函数集合/*4、添加字符设备*/ret=cdev_add(&strLEDDriver.cdev,strLEDDriver.devid,LEDDriver_CNT);//添加字符设备/*&strLEDDriver.cdev表示指向要添加的字符设备，即字符设备结构strLEDDriver.cdev变量*///strLEDDriver.devid表示设备号//LEDDriver_CNT表示需要添加的设备数量if(ret < 0 ) //添加字符设备失败goto del_register;printk("dev id major = %d,minor = %d\r\n", strLEDDriver.major, strLEDDriver.minor);printk("LEDDriver_init is ok!!!\r\n");/*5、自动创建设备节点 */strLEDDriver.class =class_create(THIS_MODULE, LEDDriver_NAME);if (IS_ERR(strLEDDriver.class)){goto del_cdev;}/*6、创建设备 */strLEDDriver.device = device_create(strLEDDriver.class, NULL, strLEDDriver.devid, NULL, LEDDriver_NAME);//创建设备//设备要创建在strLEDDriver.class类下面//NULL表示没有父设备//strLEDDriver.devid是设备号;//参数drvdata=NULL，设备没有使用数据//LEDDriver_NAME是设备名字//如果设置fmt=LEDDriver_NAME 的话，就会生成/dev/LEDDriver_NAME设备文件。//返回值就是创建好的设备。if (IS_ERR(strLEDDriver.device)){goto destroy_class;}return 0;destroy_class:class_destroy(strLEDDriver.class);//删除类//strLEDDriver.class就是要删除的类del_cdev:cdev_del(&strLEDDriver.cdev);//删除字符设备//&strLEDDriver.cdev表示指向需要删除的字符设备，即字符设备结构strLEDDriver.cdev变量del_register:unregister_chrdev_region(strLEDDriver.devid, LEDDriver_CNT);/* 释放设备号 *///strLEDDriver.devid：需要释放的起始设备号//LEDDriver_CNT：需要释放的次设备号数量；free_gpio://申请设备号失败/*释放gpio编号*/MyLED_free();return -EIO;
}/*驱动出口函数 */
static void __exit LEDDriver_exit(void)
{/*1、删除字符设备*/cdev_del(&strLEDDriver.cdev);/*删除字符设备*//*&strLEDDriver.cdev表示指向需要删除的字符设备，即字符设备结构&strLEDDriver.cdev变量*//*2、 释放设备号 */unregister_chrdev_region(strLEDDriver.devid, LEDDriver_CNT);/*释放设备号 *///strLEDDriver.devid：需要释放的起始设备号//LEDDriver_CNT：需要释放的次设备号数;/*3、 删除设备 */device_destroy(strLEDDriver.class, strLEDDriver.devid);//删除创建的设备//strLEDDriver.class是要删除的设备所处的类//strLEDDriver.devid是要删除的设备号/*4、删除类*/class_destroy(strLEDDriver.class);//删除类//strLEDDriver.class就是要删除的类/*5、释放gpio编号*/MyLED_free();
}module_init(LEDDriver_init);
//指定LEDDriver_init()为驱动入口函数
module_exit(LEDDriver_exit);
//指定LEDDriver_exit()为驱动出口函数MODULE_AUTHOR("Zhanggong");//添加作者名字
MODULE_LICENSE("GPL");//LICENSE采用“GPL协议”
MODULE_INFO(intree,"Y");
//去除显示“loading out-of-tree module taints kernel.”12、添加“LED_drv.h”
#ifndef __LED_DRIVER_H
#define __LED_DRIVER_H#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/cdev.h>
//使能cdev结构
//使能class结构和device结构struct LEDDriver_dev{dev_t devid; /*声明32位变量devid用来给保存设备号*/int major; /*主设备号*/int minor; /*次设备号*/struct cdev cdev; /*字符设备结构变量cdev */struct class *class; /*类*/struct device *device; /*设备*/atomic_t lock; /*原子变量*/
};
extern struct LEDDriver_dev strLEDDriver;#endif
13、添加“ButtonLED_APP.c”
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"#include <unistd.h>
//Linux系统编程下用到的延时函数
//使能usleep(),sleep()//#include <delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()#define KEY0VALUE 1 /* 按键值 */
#define INVAKEY 0 /* 无效的按键值 */
#define LEDOFF 0 /* 关灯 */
#define LEDON 1 /* 开灯 *//*
参数argc: argv[]数组元素个数
参数argv[]:是一个指针数组
返回值: 0 成功;其他 失败
./ButtonLED_APP /dev/MyButton /dev/MyLED
*/
int main(int argc, char *argv[])
{int fd_button;int fd_led;int retvalue;int keyvalue;int status;/* 1. 判断参数 */if(argc != 3){printf("Error Usage!\r\n");return -1;}//argv[]是指向输入参数“./ButtonLED_APP /dev/MyButton /dev/MyLED”/* 2. 打开文件 */fd_button = open(argv[1], O_RDWR);//如果打开“/dev/MyButton”文件成功，则fd_button为“文件描述符”,argv[1]="/dev/MyButton"if(fd_button < 0){printf("Can't open file %s\r\n", argv[1]);return -1;}fd_led = open(argv[2], O_RDWR);//如果打开“/dev/MyLED”文件成功，则fd_led为“文件描述符”,argv[2]=“/dev/MyLED”if(fd_led < 0){printf("Can't open file %s\r\n", argv[2]);return -1;}/* 3. 读文件 */while(1){read(fd_button, &keyvalue, sizeof(keyvalue));if (keyvalue == KEY0VALUE){//如果按键按下printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */status = LEDON;write(fd_led, &status, 1);sleep(1);//保证LED亮1妙}else{//如果按键松开status = LEDOFF;write(fd_led, &status, 1);//file结构指针变量fd_led表示要打开的设备文件//buf=&status表示用户数据块的首地址//cnt=1表示用户数据的长度，单位为字节}}/* 关闭设备 */retvalue = close(fd_button);//fd_button表示要关闭的“文件描述符”//返回值等于0表示关闭成功//返回值小于0表示关闭失败if(retvalue < 0){printf("Can't close file %s\r\n", argv[1]);return -1;}retvalue = close(fd_led);//fd_led表示要关闭的“文件描述符”//返回值等于0表示关闭成功//返回值小于0表示关闭失败if(retvalue < 0){printf("Can't close file %s\r\n", argv[2]);return -1;}return 0;
}
12、添加“Makefile”
#Linux一个Makefile编译多个内核驱动
KERNELDIR := /home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31
#使用“:=”将其后面的字符串赋值给KERNELDIR
CURRENT_PATH := $(shell pwd)
#采用“shell pwd”获取当前打开的路径
#使用“$(变量名)”引用“变量的值”
MyAPP := ButtonLED_APP
obj-m := MyButton.o MyLED.o
MyButton-y := EXTI3_drv.o EXTI3.o
MyLED-y := LED_drv.o LED.o
CC := arm-none-linux-gnueabihf-gcc
drv:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
app:
$(CC) $(MyAPP).c -o $(MyAPP)
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
rm $(MyAPP)
install:
sudo cp *.ko $(MyAPP) /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -f
13、创建“c_cpp_properties.json” 的文件
按下“Ctrl+Shift+P”,打开VSCode控制台，然后输入“C/C++:Edit Configurations(JSON)”,打开以后会自动在“.vscode ”目录下生成一个名为“c_cpp_properties.json” 的文件，修改c_cpp_properties.json内容如下所示:
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31",
"/home/zgq/linux/Linux_Drivers/EXTI",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/include",
"/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include/generated"
],
"defines": [],
"compilerPath": "/usr/bin/gcc",
"cStandard": "gnu11",
"cppStandard": "gnu++14",
"intelliSenseMode": "gcc-x64"
}
],
"version": 4
}
14、编译
输入“make clean回车”
输入“make drv回车”
输入“make app回车”
输入“make install回车”
输入“ls /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -l回车”查看是存在“ButtonLED_APP,MyButton.ko和MyLED.ko”
15、测试
启动开发板，从网络下载程序
输入“root”
输入“cd /lib/modules/5.4.31/回车”
切换到“/lib/modules/5.4.31/”目录
注意：“lib/modules/5.4.31/”在虚拟机中是位于“/home/zgq/linux/nfs/rootfs/”目录下，但在开发板中，却是位于根目录中。
输入“ls -l”查看“ButtonLED_APP,MyButton.ko和MyLED.ko”是否存在
输入“depmod”,驱动在第一次执行时，需要运行“depmod”
输入“modprobe MyButton.ko”，加载“MyButton.ko”模块
输入“modprobe MyLED.ko”，加载“MyLED.ko”模块
输入“lsmod”查看有哪些驱动在工作
输入“cat /proc/interrupts”，查看中断是否注册；
输入“ls /dev/EXTI3Driver -l回车”，发现节点文件“/dev/EXTI3Driver”
输入“ls /dev/LEDDriver -l回车”，发现节点文件“/dev/LEDDriver”
输入“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver回车”
按下按钮，等待串口输出“KEY0 Press, value = 0X1”，同时LED会亮。
16、测试结果
Welcome to zgq STM32MP157
ATK-stm32mp1 login: root
[root@ATK-stm32mp1]:~$ cd /lib/modules/5.4.31/
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ ls -l
total 1980
-rwxr-xr-x 1 root root 12228 Mar 28 2024 ButtonLED_APP
-rwxr-xr-x 1 root root 12220 Mar 20 2024 Key_APP
-rwxr-xr-x 1 root root 12252 Mar 17 2024 LED_APP
-rw-r--r-- 1 root root 330464 Mar 28 2024 MyButton.ko
-rw-r--r-- 1 root root 322284 Mar 20 2024 MyKey0_Module.ko
-rw-r--r-- 1 root root 323420 Mar 28 2024 MyLED.ko
-rw-r--r-- 1 root root 321420 Mar 17 2024 MyMutexLED_Module.ko
-rw-r--r-- 1 root root 321636 Mar 17 2024 MySemaphoreLED_Module.ko
-rw-r--r-- 1 root root 341452 Mar 22 2024 MyTimer.ko
-rwxr-xr-x 1 root root 12300 Mar 22 2024 Timer_APP
-rw-r--r-- 1 root root 0 Mar 28 2024 modules.alias
-rw-r--r-- 1 root root 101 Mar 28 2024 modules.dep
-rw-r--r-- 1 root root 0 Mar 28 2024 modules.symbols
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ depmod
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ modprobe MyButton.ko
key-gpio num = 99
dev id major = 241,minor = 0
EXTI3Driver_init is ok!!!
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ modprobe MyLED.ko
led-gpio num = 128
dev id major = 240,minor = 0
LEDDriver_init is ok!!!
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ lsmod
Module Size Used by Not tainted
MyLED 16384 0
MyButton 16384 0
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ cat /proc/interrupts
CPU0 CPU1
18: 859 1054 GIC-0 27 Level arch_timer
20: 0 0 GIC-0 232 Level arm-pmu
21: 0 0 GIC-0 233 Level arm-pmu
22: 0 0 GIC-0 43 Level dma1chan0
23: 0 0 GIC-0 44 Level dma1chan1
24: 0 0 GIC-0 45 Level dma1chan2
25: 0 0 GIC-0 46 Level dma1chan3
26: 0 0 GIC-0 47 Level dma1chan4
27: 0 0 GIC-0 48 Level dma1chan5
28: 0 0 GIC-0 49 Level dma1chan6
29: 0 0 GIC-0 79 Level dma1chan7
30: 0 0 GIC-0 88 Level dma2chan0
31: 0 0 GIC-0 89 Level dma2chan1
32: 0 0 GIC-0 90 Level dma2chan2
33: 0 0 GIC-0 91 Level dma2chan3
34: 0 0 GIC-0 92 Level dma2chan4
35: 0 0 GIC-0 100 Level dma2chan5
36: 0 0 GIC-0 101 Level dma2chan6
37: 0 0 GIC-0 102 Level dma2chan7
38: 0 0 GIC-0 37 Level rcc irq
40: 0 0 GIC-0 179 Level stm_thermal
41: 0 0 GIC-0 112 Level 54002000.hash
42: 0 0 GIC-0 154 Level 58000000.dma
43: 107 0 GIC-0 81 Level mmci-pl18x (cmd)
44: 72 0 GIC-0 156 Level mmci-pl18x (cmd)
45: 10423 0 GIC-0 93 Level eth0
47: 213 0 stm32-exti-h-direct 30 Level 40010000.serial
48: 0 0 stm32-exti-h-direct 70 Level eth0
49: 0 0 stm32-exti-h-direct 19 Level 5c004000.rtc
50: 0 0 stm32-exti-h-direct 61 Edge 4c001000.mailbox
51: 0 0 GIC-0 133 Level 4c001000.mailbox
52: 0 0 stm32gpio 3 Edge Key0_IRQ
IPI0: 0 0 CPU wakeup interrupts
IPI1: 0 0 Timer broadcast interrupts
IPI2: 2403 6458 Rescheduling interrupts
IPI3: 3 0 Function call interrupts
IPI4: 0 0 CPU stop interrupts
IPI5: 0 0 IRQ work interrupts
IPI6: 0 0 completion interrupts
Err: 0
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ ls /dev/EXTI3Driver -l
crw-rw---- 1 root root 241, 0 Jan 1 01:05 /dev/EXTI3Driver
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ ls /dev/LEDDriver -l
crw-rw---- 1 root root 240, 0 Jan 1 01:05 /dev/LEDDriver
[root@ATK-stm32mp1]:/lib/modules/5.4.31$ ./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver
EXTI3Driver_open!
LEDDriver_open!
Button: on
KEY0 Press, value = 0X1
Button: off
Button: on
KEY0 Press, value = 0X1
Button: off
![[RoarCTF 2019]Online Proxy --不会编程的崽](https://img-blog.csdnimg.cn/direct/d378a999c7134e98a657ada912fa9a2f.png)
