1.使用platform总线驱动代码实现如下要求
a.应用程序通过阻塞的io模型来读取number变量的值
b.number是内核驱动中的一个变量
c.number的值随着按键按下而改变(按键中断)
例如number=0按下按键number=1,再次按下按键number=0
d.在按下按键的时候需要同时将1ed1的状态取反
e.驱动中需要编写字符设备驱动
f.驱动中需要自动创建设备节点
g.这个驱动需要的所有设备信息放在设备树的同一个节点中
h.利用定时器完成对KEY1的消抖
设备树节点
myplatform {
compatible = "hqyj,myplatform";
reg = <0x12345678 0x400>;
interrupt-parent = <&gpiof>;
interrupts = <9 0>,<7 0>,<8 0>;
led1-gpios = <&gpioe 10 0>;
key1-gpios = <&gpiof 9 0>;
};
ledkey.c(驱动文件)
/*
* Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
* @Author: Huijie Xia
* @Date: 2023-06-29 08:56:26
* @LastEditTime: 2023-07-13 16:44:43
* @FilePath: /B_Drive/day10/03_led_key_platform/ledkey.c
* @version:
* @Description: LED1、KEY1、IO阻塞练习驱动文件(platform实现)
*/
/*
* 1.使用platform总线驱动代码实现如下要求
* a.应用程序通过阻塞的io模型来读取number变量的值
* b.number是内核驱动中的一个变量
* c.number的值随着按键按下而改变(按键中断)
* 例如number=0按下按键number=1,再次按下按键number=0
* d.在按下按键的时候需要同时将1ed1的状态取反
* e.驱动中需要编写字符设备驱动
* f.驱动中需要自动创建设备节点
* g.这个驱动需要的所有设备信息放在设备树的同一个节点中
* h.利用定时器完成对KEY1的消抖
*/
/**
myplatform {
compatible = "hqyj,myplatform";
reg = <0x12345678 0x400>;
interrupt-parent = <&gpiof>;
interrupts = <9 0>,<7 0>,<8 0>;
led1-gpios = <&gpioe 10 0>;
key1-gpios = <&gpiof 9 0>;
};
*/
#include <linux/cdev.h>
#include <linux/gpio.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/timer.h>
#include <linux/wait.h>
unsigned int number = 0;
struct cdev* cdev; /* 字符设备驱动对象结构体 */
struct class* cls; /* 目录信息结构体 */
struct device* dev; /* 设备信息结构体 */
struct gpio_desc* desc; /* gpio对象结构体 */
struct gpio_desc* key1_desc; /* KEY1对象结构体 */
unsigned int irqno; /* 软中断号 */
wait_queue_head_t wq_head; /* 定义等待队列头 */
struct timer_list mytimer; /* 定义计时器对象 */
unsigned int condition = 0; /* 数据是否准备好的状态,默认没有准备好 */
/* !!!注意:静态指定时,主设备号major必须小于等于511!!! */
unsigned int major = 0;
unsigned int minor = 0;
const int count = 1;
char kbuf[128] = { 0 };
#define CNAME "LED_KEY"
void timer_irq_handler(struct timer_list* timer)
{
/* 判断KEY1引脚状态,如果是低电平,说明KEY1按下 */
if (!gpiod_get_value(key1_desc)) {
/* number取反 */
number = !number;
gpiod_set_value(desc, number);
condition = 1; /* 表示硬件数据准备就绪 */
wake_up_interruptible(&wq_head); /* 唤醒休眠的进程 */
}
}
/**
* @description: KEY1中断处理函数
* @param {int} irqno
* @param {void*} dev_id
* @return {*}
*/
irqreturn_t led_key_handler(int irqno, void* dev_id)
{
/* 重启定时器 */
mod_timer(&mytimer, jiffies + 1);
return IRQ_HANDLED;
}
/**
* @description: open操作方法
* @param {inode*} inode
* @param {file*} file
* @return {*}
*/
int mycdev_open(struct inode* inode, struct file* file)
{
printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
return 0;
}
/**
* @description: read操作方法
* @param {file*} file
* @param {char __user*} ubuf
* @param {size_t} size
* @param {loff_t*} offs
* @return {*}
*/
ssize_t mycdev_read(struct file* file, char __user* ubuf, size_t size, loff_t* offs)
{
int ret;
// printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
/* 判断用户是否以阻塞的方式打开设备文件 */
if (file->f_flags & O_NONBLOCK) {
/* 非阻塞方式 */
return -EINVAL;
} else {
/* 阻塞方式 */
ret = wait_event_interruptible(wq_head, condition);
if (ret) {
printk("receive signal ……\n");
return ret;
}
}
/* 将数据拷贝到用户空间 */
if (size > sizeof(number)) {
size = sizeof(number);
}
ret = copy_to_user(ubuf, &number, size);
if (ret) {
printk("copy data to user error!\n");
return -EIO;
}
/* 将condition清零:表示下一次硬件数据没有准备好 */
condition = 0;
return size;
}
/**
* @description: write操作方法
* @param {file*} file
* @param {char __user*} ubuf
* @param {size_t} size
* @param {loff_t*} offs
* @return {*}
*/
ssize_t mycdev_write(struct file* file, const char __user* ubuf, size_t size, loff_t* offs)
{
printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
return 0;
}
/**
* @description: close操作方法
* @param {inode*} inode
* @param {file*} file
* @return {*}
*/
int mycdev_close(struct inode* inode, struct file* file)
{
printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
return 0;
}
/**
* @description: 操作方法结构体
*/
struct file_operations fops = {
.open = mycdev_open,
.read = mycdev_read,
.write = mycdev_write,
.release = mycdev_close,
};
/**
* @description: probe函数,匹配设备成功时执行
* @param {platform_device*} pdev
* @return {*}
*/
int pdrv_probe(struct platform_device* pdev)
{
int ret;
dev_t devno;
/* 1. 创建字符设备驱动 */
/* 1.1 分配字符设备驱动对象空间 cdev_alloc */
cdev = cdev_alloc();
if (cdev == NULL) {
printk("cdev alloc memory error line : %d\n", __LINE__);
ret = -ENOMEM;
goto ERR1;
}
printk("cdev alloc memory successful line : %d\n", __LINE__);
/* 1.2 字符设备驱动对象部分初始化 cdev_init */
cdev_init(cdev, &fops);
/* 1.3 申请设备号 */
if (major > 0) {
/* 静态申请设备号 */
ret = register_chrdev_region(MKDEV(major, minor), count, CNAME);
if (ret) {
printk("static:request device number error line : %d\n", __LINE__);
goto ERR2;
}
printk("static:request device number successful line : %d\n", __LINE__);
} else {
/* 动态申请设备号 alloc_chrdev_region */
ret = alloc_chrdev_region(&devno, 0, count, CNAME);
if (ret) {
printk("dynamic:request device number error line : %d\n", __LINE__);
goto ERR2;
}
printk("dynamic:request device number successful line : %d\n", __LINE__);
major = MAJOR(devno);
minor = MINOR(devno);
}
/* 1.4 注册字符设备驱动对象 cdev_add */
ret = cdev_add(cdev, MKDEV(major, minor), count);
if (ret) {
printk("register char device driver error line : %d\n", __LINE__);
goto ERR3;
}
printk("register char device driver successful line : %d\n", __LINE__);
/* 2. 自动创建设备节点 */
/* 2.1 向上提交目录信息 class_create */
cls = class_create(THIS_MODULE, CNAME);
if (IS_ERR(cls)) {
printk("submit directory error line : %d\n", __LINE__);
goto ERR4;
}
printk("submit directory successful line : %d\n", __LINE__);
/* 2.2 向上提交设备节点信息 */
dev = device_create(cls, NULL, MKDEV(major, minor), NULL, CNAME);
if (IS_ERR(dev)) {
printk("submit device node infomation error line : %d\n", __LINE__);
goto ERR5;
}
printk("submit device node infomation successful line : %d\n", __LINE__);
/* 3.1 解析设备树节点得到led的gpio对象 */
desc = gpiod_get_from_of_node(pdev->dev.of_node, "led1-gpios", 0, GPIOD_OUT_HIGH, NULL);
if (IS_ERR(desc)) {
printk("get led1 desc error line : %d\n", __LINE__);
return PTR_ERR(desc);
goto ERR6;
}
/* 3.2 解析设备树节点得到key1的gpio对象 */
key1_desc = gpiod_get_from_of_node(pdev->dev.of_node, "key1-gpios", 0, GPIOD_ASIS, NULL);
if (IS_ERR(key1_desc)) {
printk("get key1 desc error line : %d\n", __LINE__);
return PTR_ERR(key1_desc);
goto ERR6;
}
/* 4. 配置按键1中断 */
/* 4.1 获取KEY1软中断号 */
irqno = platform_get_irq(pdev, 0);
if (irqno < 0) {
printk("request KEY1 soft interrupt number error! __%d__\n", __LINE__);
return -ENOMEM;
goto ERR7;
}
printk("request KEY1 soft interrupt number successful! KEY1 number = %d\n", irqno);
/* 4.2 注册KEY1中断 */
ret = request_irq(irqno, led_key_handler, IRQF_TRIGGER_FALLING, "KEY1", NULL);
if (ret) {
printk("KEY1 register interrupt error! __%d__\n", __LINE__);
goto ERR8;
}
printk("KEY1 register interrupt successful! __%d__\n", __LINE__);
/* 5. 初始化等待头队列 */
init_waitqueue_head(&wq_head);
/* 6. 初始化定时器 */
mytimer.expires = jiffies + 1; /* 定时10ms */
timer_setup(&mytimer, timer_irq_handler, 0);
add_timer(&mytimer);
return 0;
ERR8:
free_irq(irqno, NULL); /* 注销KEY1中断 */
ERR7:
gpiod_put(desc); /* 注销gpio对象 */
ERR6:
device_destroy(cls, MKDEV(major, minor)); /* 注销设备 */
ERR5:
class_destroy(cls); /* 销毁目录 */
ERR4:
cdev_del(cdev); /* 注销字符设备驱动对象 */
ERR3:
unregister_chrdev_region(MKDEV(major, minor), count); /* 注销设备号 */
ERR2:
kfree(cdev); /* 释放对象空间 */
ERR1:
return ret;
}
/**
* @description: remove函数,设备和驱动分离时执行
* @param {platform_device*} pdev
* @return {*}
*/
int pdrv_remove(struct platform_device* pdev)
{
/* 1. 注销KEY1中断 */
free_irq(irqno, NULL);
/* 2. 注销gpio对象 */
gpiod_put(desc);
gpiod_put(key1_desc);
/* 3. 注销设备 */
device_destroy(cls, MKDEV(major, minor));
/* 4. 销毁目录 */
class_destroy(cls);
/* 5. 注销字符设备驱动对象 */
cdev_del(cdev);
/* 6.注销设备号 */
unregister_chrdev_region(MKDEV(major, minor), count);
/* 7. 释放对象空间 */
kfree(cdev);
/* 8. 注销定时器 */
del_timer(&mytimer);
return 0;
}
struct of_device_id tree_table[] = {
{
.compatible = "hqyj,myplatform",
},
{},
};
struct platform_driver key_led_driver = {
.probe = pdrv_probe,
.remove = pdrv_remove,
.driver = {
.name = "first",
.of_match_table = tree_table, /* 设置设备树匹配 */
},
};
/* 一键注册宏 */
module_platform_driver(key_led_driver);
/* 许可证:遵从GPL协议 */
MODULE_LICENSE("GPL");
test.c(测试文件)
/*
* Copyright (c) 2023 by Huijie Xia, All Rights Reserved.
* @Author: Huijie Xia
* @Date: 2023-07-03 14:44:33
* @LastEditTime: 2023-07-13 09:21:50
* @FilePath: /B_Drive/day9/05_led_key_timer/test.c
* @version:
* @Description: LED1、KEY1、IO阻塞练习测试文件
*/
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define ERR_MSG(msg) \
do { \
fprintf(stderr, "line : %d\n", __LINE__); \
perror(msg); \
} while (0)
int main(int argc, const char* argv[])
{
int fd;
unsigned int number;
if ((fd = open("/dev/LED_KEY", O_RDWR)) == -1) {
ERR_MSG("LED_KEY open error");
}
while (1) {
read(fd, &number, sizeof(number));
printf("number = %d\n", number);
}
close(fd);
return 0;
}