驱动作业5 —— LED1、KEY1、IO阻塞练习

最新推荐文章于 2024-05-27 16:45:59 发布

欲上层楼再上层楼

最新推荐文章于 2024-05-27 16:45:59 发布

阅读量200

点赞数

文章标签：驱动开发

本文链接：https://blog.csdn.net/qq_43921012/article/details/131688695

版权

1.使用驱动代码实现如下要求

a.应用程序通过阻塞的io模型来读取number变量的值

b.number是内核驱动中的一个变量

c.number的值随着按键按下而改变(按键中断)

例如number=0按下按键number=1,再次按下按键number=0

d.在按下按键的时候需要同时将1ed1的状态取反

e.驱动中需要编写字符设备驱动

f.驱动中需要自动创建设备节点

g.这个驱动需要的所有设备信息放在设备树的同一个节点中

h.利用定时器完成对KEY1的消抖

设备树节点

led_key {
                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-12 19:15:35
 * @FilePath: /B_Drive/day9/05_led_key_timer/ledkey.c
 * @version:
 * @Description: LED1、KEY1、IO阻塞练习驱动文件
 */

/*
 * 1.使用驱动代码实现如下要求
 * a.应用程序通过阻塞的io模型来读取number变量的值
 * b.number是内核驱动中的一个变量
 * c.number的值随着按键按下而改变(按键中断)
 *   例如number=0按下按键number=1,再次按下按键number=0
 * d.在按下按键的时候需要同时将1ed1的状态取反
 * e.驱动中需要编写字符设备驱动
 * f.驱动中需要自动创建设备节点
 * g.这个驱动需要的所有设备信息放在设备树的同一个节点中
 * h.利用定时器完成对KEY1的消抖
 */

#include <linux/cdev.h>
#include <linux/gpio.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/timer.h>
#include <linux/wait.h>

/*
    led_key {
                interrupt-parent	= <&gpiof>;
                interrupts			= <9 0>,<7 0>,<8 0>;
                led1-gpios 			= <&gpioe 10 0>;
                key1-gpios			= <&gpiof 9 0>;
        };
*/

unsigned int number = 0;
struct cdev* cdev; /* 字符设备驱动对象结构体 */
struct class* cls; /* 目录信息结构体 */
struct device* dev; /* 设备信息结构体 */
struct device_node* dnode; /* 设备树节点结构体 */
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, (void*)&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: 入口：在安装驱动的时候入口函数执行,做资源申请的工作
 * demo_init:驱动入口的名字
 * __init:它是给编译器使用的,告诉编译器将这个函数放在.init.text段中
 * @return {*}
 */
static int __init demo_init(void)
{
    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. 通过路径获取设备树节点 */
    dnode = of_find_node_by_path("/led_key");
    if (dnode == NULL) {
        printk("get device tree node led_key error! __%d__\n", __LINE__);
        return -ENXIO;
        goto ERR6;
    }
    printk("get device tree node led_key successful! __%d__\n", __LINE__);

    /* 4.1 解析设备树节点得到led的gpio对象 */
    desc = gpiod_get_from_of_node(dnode, "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;
    }

    /* 4.2 解析设备树节点得到key1的gpio对象 */
    key1_desc = gpiod_get_from_of_node(dnode, "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;
    }

    /* 5. 配置按键1中断 */
    /* 5.1 获取KEY1软中断号 */
    irqno = irq_of_parse_and_map(dnode, 0);
    if (!irqno) {
        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);

    /* 5.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__);

    /* 6. 初始化等待头队列 */
    init_waitqueue_head(&wq_head);

    /* 7. 初始化定时器 */
    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: 出口：在卸载驱动的时候出口函数执行，做资源释放的工作
 * demo_exit:驱动出口的名字
 * __exit:它是给编译器使用的,告诉编译器将这个函数放在.exit.text段中
 * @return {*}
 */
static void __exit demo_exit(void)
{
    /* 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);
}

/* 告诉内核入口地址 */
module_init(demo_init);

/* 告诉内核出口地址 */
module_exit(demo_exit);

/* 许可证：遵从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-12 18:43:06
 * @FilePath: /B_Drive/day9/04_led_key/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;
}