手机网站开发下载,桂城网站设计,链接检测工具,seo对各类网站的作用“异步通知”的核心就是信号#xff0c;由“驱动设备”主动报告给“应用程序”的。
1、添加“EXTI3.c”
#include EXTI3.h
#include linux/gpio.h
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_v…“异步通知”的核心就是信号由“驱动设备”主动报告给“应用程序”的。
1、添加“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(),占用cpu资源
#include linux/time.h
//使能msleep(),不会占用cpu资源
#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()#include EXTI3_drv.hstruct 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)
{if(atomic_read(strButton.button_irq_status) 0){//若信号发送没有结束则“驱动程序”则向“应用程序”发出信号,防止连续发出信号//在非中断程序中消抖减少占用CPU资源atomic_set(strButton.button_irq_status, 1);//设置原子变量值strButton.button_irq_status.counter1if(strEXTI3Driver.async_queue)kill_fasync(strEXTI3Driver.async_queue, SIGIO, POLL_IN);//当设备可以访问时“驱动程序”则向“应用程序”发出信号相当于产生“中断”。//fpstrEXTI3Driver.async_queue要操作的fasync_struct//sigSIGIO要发送的信号//bandPOLL_IN可读时设置为POLL_IN可写时设置为POLL_OUT}return IRQ_HANDLED;
}int Get_gpio_Button_num(void)
{int ret 0;const char *str;strButton.button_irq_status (atomic_t)ATOMIC_INIT(0);/*初始化原子变量*/atomic_set(strButton.button_irq_status, 0);/*设置原子变量初始值strButton.button_irq_status.counter0*/strButton.keyvalue0;/* 设置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//pronamestatus给定要读取的属性名字//out_stringstr:返回读取到的属性值//返回值:0读取成功负值读取失败。if(ret 0) return -EINVAL;if(strcmp(str, okay)) return -EINVAL;//strcmp(s1,s2),当s1s2时返回值为负数//strcmp(s1,s2),当s12时返回值为正数//strcmp(s1,s2),当s1s2时返回值为0/* 3、获取compatible属性值并进行匹配 */ret of_property_read_string(strButton.nd, compatible, str);//在key0节点中compatible zgq,key;//指定的设备节点strButton.nd//pronamecompatible给定要读取的属性名字//out_stringstr:返回读取到的属性值//返回值: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//npstrButton.nd,指定的“设备节点”//propnamekey-gpio给定要读取的属性名字//Index0,给定的GPIO索引为0//返回值正值获取到的GPIO编号负值失败。if(strButton.button_gpio_number 0) {printk(cant get key-gpio);return -EINVAL;}/* 5 、获取GPIO对应的中断号 */strButton.irq_num irq_of_parse_and_map(strButton.nd, 0);//devstrButton.nd为设备节点;//Index0索引号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);//gpiostrButton.button_gpio_number指定要申请的“gpio编号”//labelButton给这个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);//gpiostrButton.button_gpio_number,指定的“gpio编号”if(ret 0) {printk(cant set gpio!\r\n);}/* 获取设备树中指定的中断触发类型 */irq_flags irq_get_trigger_type(strButton.irq_num);//strButton.irq_num为中断号if ( irq_flagsIRQF_TRIGGER_NONE )irq_flags IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;/*申请中断*/ret request_irq(strButton.irq_num, key_interrupt_fun, irq_flags, Key0_IRQ, NULL);//irqstrButton.irq_num要申请中断的中断号//handlerkey_interrupt_fun中断处理函数当中断发生以后就会执行此中断处理函数//fagsirq_flags中断标志可以在文件“include/linux/interrupt.h”里面查看所有的中断标志//nameKey0_IRQ中断名字设置以后可以在“/proc/interrupts”文件中看到对应的中断名字//devNULL如果将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)
{u8 ch;int status;if(atomic_read(strButton.button_irq_status) 0){status -EAGAIN;//无按钮按下, Try again}else{ch10;while(ch)//消抖{//mdelay(10);//延时10毫秒消抖,占用cpu资源msleep(10);//延时10毫秒消抖,不会占用cpu资源if(gpio_get_value(strButton.button_gpio_number) 0) ch10;ch--;}ch0;if(strButton.keyvalue) ch1;if(ch)//关灯{strButton.keyvalueKEY_OFF;//准备中断返回值printk(Button: off\r\n);}else//开灯{strButton.keyvalueKEY_ON;//准备中断返回值printk(Button: on\r\n);}statusstrButton.keyvalue;//发送中断返回值atomic_set(strButton.button_irq_status, 0);/*原子变量初始值strButton.button_irq_status.counter0, 状态重置 */}return status;
}2、添加“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/wait.h //使能wait_queue_head_t结构#define KEY_ON 1 /* 按键按下 */
#define KEY_OFF 0 /* 按键松开 */struct Button_dev{struct device_node *nd; /*设备节点*/int button_gpio_number; /*Button所使用的GPIO编号*/int irq_num; /* 中断号 */atomic_t 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);#endif3、添加“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()#include linux/delay.h
//Linux内核中用到的延时函数
//使能ndelay()udelay()mdelay()
#include linux/poll.h
//使能poll(),poll_wait()#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.counter1时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;int value;value Read_Button();if( value -EAGAIN ) ret value;else{ret copy_to_user(buf, value, sizeof(value));//将value拷贝到buf[]中}return ret;
}/*fasync函数用于处理异步通知
fd : 文件描述符
filp : 要打开的设备文件(文件描述符)
on : 模式
返回值: 负数表示函数执行失败
*/
/*当“应用程序”通过“fcntl(fd,F SETFL, flags|FASYNC)”改变fasync标记的时候
“驱动程序” file_operations操作集中的EXTI3Driver_fasync()函数就会被执行*/
static int EXTI3Driver_fasync(int fd, struct file *filp, int on)
{struct EXTI3Driver_dev *dev filp-private_data;if (fasync_helper(fd, filp, on, dev-async_queue) 0){/*当“应用程序”通过“fcntl(fd,F SETFL, flags|FASYNC)”改变fasync标记的时候“驱动程序”file_operations操作集中的xxx_fasync()函数就会被执行*/return -EIO;}return 0;
}/* 向设备写数据将数据块首地址为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 EXTI3Driver_fasync(-1, filp, 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,.fasync EXTI3Driver_fasync,
};/*驱动入口函数 */
static int __init EXTI3Driver_init(void)
{int ret;strEXTI3Driver.lock (atomic_t)ATOMIC_INIT(0);/*初始化原子变量*/atomic_set(strEXTI3Driver.lock, 1);/*原子变量初始值strEXTI3Driver.lock.counter1*/retGet_gpio_Button_num();//读引脚编号if(ret 0) return ret; /* 1、申请“gpio编号”*/retButton_gpio_request();//申请“gpio编号” if(ret 0) return ret;//向gpio子系统申请使用“gpio编号” 失败/*2、申请设备号*/strEXTI3Driver.major0;if(strEXTI3Driver.major)/*如果指定了主设备号*/{strEXTI3Driver.devid MKDEV(strEXTI3Driver.major, 0);//输入参数strEXTI3Driver.major为“主设备号”//输入参数0为“次设备号”大部分驱动次设备号都选择0//将strEXTI3Driver.major左移20位再与0相或就得到“Linux设备号”retregister_chrdev_region( strEXTI3Driver.devid,\EXTI3Driver_CNT, \EXTI3Driver_NAME );//strEXTI3Driver.devid表示起始设备号//EXTI3Driver_CNT表示次设备号的数量//EXTI3Driver_NAME表示设备名if(ret 0)goto free_gpio;}else{ /* 没有定义设备号 */retalloc_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、添加字符设备*/retcdev_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是设备号;//参数drvdataNULL设备没有使用数据//EXTI3Driver_NAME是设备名字//如果设置fmtEXTI3Driver_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.”4、添加“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结构#include linux/fs.h //使能fasync_struct结构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; /*原子变量*/struct fasync_struct *async_queue; /* fasync_struct结构体 */
};
extern struct EXTI3Driver_dev strEXTI3Driver;#endif5、添加“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//pronamestatus给定要读取的属性名字//out_stringstr:返回读取到的属性值//返回值:0读取成功负值读取失败。if(ret 0) return -EINVAL;if (strcmp(str, okay)) return -EINVAL;//strcmp(s1,s2),当s1s2时返回值为负数//strcmp(s1,s2),当s12时返回值为正数//strcmp(s1,s2),当s1s2时返回值为0/* 3、获取compatible属性值并进行匹配 */ret of_property_read_string(strMyLED.nd, compatible, str);//在led0节点中compatible zgq,led;//指定的设备节点strMyLED.nd//pronamecompatible给定要读取的属性名字//out_stringstr:返回读取到的属性值//返回值: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//npstrMyLED.nd,指定的“设备节点”//propnameled-gpio给定要读取的属性名字//Index0,给定的GPIO索引为0//返回值正值获取到的GPIO编号负值失败。if(strMyLED.led_gpio_number 0) {printk(cant 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*16128return 0;
}int led_GPIO_request(void)
{int ret 0;/* 5.向gpio子系统申请使用“gpio编号” */ret gpio_request(strMyLED.led_gpio_number, LED-GPIO);//gpiostrMyLED.led_gpio_number指定要申请的“gpio编号”//IabelLED-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);//gpiostrMyLED.led_gpio_number,指定的“gpio编号”这里是128对应的是GI0引脚//value1设置引脚输出高电平//返回值0设置“引脚输出为vakued的值”成功;负值设置“引脚输出为vakued的值”失败。if(ret 0) {printk(cant 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灯 */}
}6、添加“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);#endif 7、添加“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.counter1时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.counter1*/retGet_led0_num();//读引脚编号if(ret 0) return ret; /* 1、申请“gpio编号”*/retled_GPIO_request();//申请“gpio编号” if(ret 0) return ret;//向gpio子系统申请使用“gpio编号” 失败/*2、申请设备号*/strLEDDriver.major0;if(strLEDDriver.major)/*如果指定了主设备号*/{strLEDDriver.devid MKDEV(strLEDDriver.major, 0);//输入参数strLEDDriver.major为“主设备号”//输入参数0为“次设备号”大部分驱动次设备号都选择0//将strLEDDriver.major左移20位再与0相或就得到“Linux设备号”
retregister_chrdev_region( strLEDDriver.devid,\LEDDriver_CNT, \LEDDriver_NAME );//strLEDDriver.devid表示起始设备号//LEDDriver_CNT表示次设备号的数量//LEDDriver_NAME表示设备名if(ret 0)goto free_gpio;}else{ /* 没有定义设备号 */
retalloc_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、添加字符设备*/retcdev_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是设备号;//参数drvdataNULL设备没有使用数据//LEDDriver_NAME是设备名字//如果设置fmtLEDDriver_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.” 8、添加“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 9、添加“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()
#include poll.h
//FD_ZERO(),FD_SET(),select(),FD_CLR(),FD_ISSET()#include signal.h#define LED_OFF 0 /* 关灯 */
#define LED_ON 1 /* 开灯 */static int fd_button;
static int fd_led;
/*
* SIGIO信号处理函数
signum : 信号值
*/
static void sigio_signal_func(int signum)
{unsigned int key_val 0;int keyvalue;int status;read(fd_button, keyvalue, sizeof(keyvalue));if (keyvalue LED_ON){//如果按键按下printf(KEY0 Press, value %#X\r\n, keyvalue);/* 按下 */status LED_ON;write(fd_led, status, 1);}else if (keyvalue LED_OFF){//如果按键松开printf(KEY0 Press, value %#X\r\n, keyvalue);/* 按下 */status LED_OFF;write(fd_led, status, 1);//file结构指针变量fd_led表示要打开的设备文件//bufstatus表示用户数据块的首地址//cnt1表示用户数据的长度单位为字节}
}/*
参数argc: argv[]数组元素个数
参数argv[]:是一个指针数组
返回值: 0 成功;其他 失败
./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver
*/
int main(int argc, char *argv[])
{int flags 0;int retvalue;/* 1. 判断参数 */if(argc ! 3){printf(Error Usage!\r\n);return -1;}//argv[]是指向输入参数“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver”/* 2. 打开文件 */fd_button open(argv[1], O_RDONLY | O_NONBLOCK);//O_RDONLY表示只读模式//O_NONBLOCK表示如果路径名指向FIFO/块文字/字符文件则把文件的打开和后继I/O设置为非阻塞//如果打开“/dev/EXTI3Driver”文件成功则fd_button为“文件描述符”,argv[1]/dev/EXTI3Driverif(fd_button 0){printf(Cant open file %s\r\n, argv[1]);return -1;}fd_led open(argv[2], O_RDWR);//如果打开“/dev/LEDDriver”文件成功则fd_led为“文件描述符”,argv[2]“/dev/LEDDriver”if(fd_led 0){printf(Cant open file %s\r\n, argv[2]);return -1;}signal(SIGIO, sigio_signal_func);/* 设置信号SIGIO的处理函数 */fcntl(fd_button, F_SETOWN, getpid()); /* 将当前进程的进程号告诉给内核 */flags fcntl(fd_button, F_GETFD); /*获取当前的进程状态 */fcntl(fd_button, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能 *//* 3. 读文件 */while(1){sleep(2);}/* 关闭设备 */retvalue close(fd_button);//fd_button表示要关闭的“文件描述符”//返回值等于0表示关闭成功//返回值小于0表示关闭失败if(retvalue 0){printf(Cant close file %s\r\n, argv[1]);return -1;}retvalue close(fd_led);//fd_led表示要关闭的“文件描述符”//返回值等于0表示关闭成功//返回值小于0表示关闭失败if(retvalue 0){printf(Cant close file %s\r\n, argv[2]);return -1;}return 0;
} 10、添加“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_APPobj-m : MyButton.o MyLED.oMyButton-y : EXTI3_drv.o EXTI3.o
MyLED-y : LED_drv.o LED.oCC : arm-none-linux-gnueabihf-gccdrv:$(MAKE) -C $(KERNELDIR) M$(CURRENT_PATH) modulesapp:$(CC) $(MyAPP).c -o $(MyAPP)clean:$(MAKE) -C $(KERNELDIR) M$(CURRENT_PATH) cleanrm $(MyAPP)install:sudo cp *.ko $(MyAPP) /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -f 11、添加“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/Asynchronous_Notification, /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: gnu14,intelliSenseMode: gcc-x64}],version: 4
}
12、编译
输入“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” 13、测试
启动开发板从网络下载程序
输入“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”查看有哪些驱动在工作 输入“ls /dev/EXTI3Driver -l回车”发现节点文件“/dev/EXTI3Driver”
输入“ls /dev/LEDDriver -l回车”发现节点文件“/dev/LEDDriver” 输入“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver回车”
按下按钮等待串口输出“KEY0 Press, value 0X1”同时LED会亮。 14、测试结果
