＜Linux开发＞驱动开发 -之-资源的并发与竞争处理

已于 2023-05-28 18:57:24 修改
阅读量745 收藏 2
点赞数
分类专栏： Linux驱动开发 文章标签： 驱动开发 linux arm开发
于 2023-05-28 18:57:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39257814/article/details/130914557
版权

＜Linux开发＞驱动开发 -之-资源的并发与竞争处理

交叉编译环境搭建：
＜Linux开发＞ linux开发工具-之-交叉编译环境搭建

uboot移植可参考以下：
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第一部分）
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第二部分）
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第三部分）(uboot移植完结)

Linux内核及设备树移植可参考以下：
＜Linux开发＞系统移植 -之- linux内核移植过程详细记录（第一部分）
＜Linux开发＞系统移植 -之- linux内核移植过程详细记录（第二部分完结）

Linux文件系统构建移植参考以下：
＜Linux开发＞系统移植 -之- linux构建BusyBox根文件系统及移植过程详细记录
＜Linux开发＞系统移植 -之-使用buildroot构建BusyBox根文件系统

Linux驱动开发参考以下：
＜Linux开发＞驱动开发 -之-pinctrl子系统
＜Linux开发＞驱动开发 -之-gpio子系统
＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的LED驱动
＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动

一 前言

对应资源的并发与竞争处理,主要涉及原子操作、自旋锁、信号量和互斥体这四个。不同进程同时访问同一个资源就会存在并发问题； 比如不同进程同时控制LED或beep。本文不过多解释四种处理并发的原理，读者可以自行查阅相关资料。这里只讲使用。那么我们接下来一个一个使用看看。

二 信号量

本次实现对beep的这个资源，来进行并发的处理，通过信号量的方式；
基于＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动，设备树无需改动，主要是修改驱动程序；

2.1 修改beep驱动

修改beep驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    struct semaphore sem;   /* 信号量 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    if (down_interruptible(&beep.sem)) {
        return -ERESTARTSYS;
    }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;
    up(&dev->sem);  /* 释放信号量，信号量值加 1 */
    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    sema_init(&beep.sem, 1);


    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

2.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

2.3 编写测试asme信号量的app

编写测试app如下：

#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"

/*************************************************************** 
 * Copyright © onefu Co., Ltd. 2019-2023. All rights reserved. 
 * 文件名 : beep_water_app.c 
 * 作者 : water 
 * 版本 : V1.0 
 * 描述 : beep 驱测试APP。 
 * 其他 : 使用方法：./beep_water_app /dev/beep <1>|<2>
 *                argv[2] 0:关闭beep
 *                argv[2] 1:打开beep
 * 日志 : 初版V1.0 2023/05/28 water创建 
 * ***************************************************************/ 

#define BEEPOFF 0
#define BEEPON  1

/* 
* @description : main主程序 
* @param - argc : argv数组元素个数 
* @param - argv : 具体参数 
* @return : 0 成功;其他 失败 
*/ 
int main(int argc, char *argv[])
{
    int fd, retvalue;               //fd: 文件描述符 用以对文件操作    retvalue:存放函数操作后的返回值
    char *filename;                 //filename：文件名，有主函数参数传入赋值
    unsigned char databuf[1];       //定义的buf，用来读写数据用 
    int cnt = 0;

    if(argc != 3){                  //判断主函数传入的函数的参数的个数
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];              //获取第1个参数，存放的是文件的路径（即要操作的设备文件路径）
    
    fd = open(filename,O_RDWR);                         /*打开驱动文件*/
    if(fd < 0){
        printf("Can't open file %s\r\n",filename);      /*打开失败，输出提示*/
        return -1;
    }

    databuf[0] = atoi(argv[2]);                         /* 要执行的操作：打开或关闭 */

    retvalue = write(fd, databuf, sizeof(databuf));     /*向设备驱动写入数据*/
    if(retvalue < 0){
        printf("BEEP Control Failed!\r\n",filename);     /*写入错误输出提示*/
        close(fd);
        return -1;
    }

    /* 模拟占用 50S LED */
    while(1) {
        sleep(1);
        cnt++;
        printf("beep App running times:%d\r\n", cnt);
        if(cnt >= 10) break;
    }
    printf("App running finished!");
    
    retvalue = close(fd);                               /*关闭文件*/
    if(retvalue < 0){
        printf("Can't close file %s\r\n",filename);     /*关闭错误输出提示*/
        return -1;
    }

    return 0;
}
//编译指令： arm-linux-gnueabihf-gcc  beep_water_app.c  -o  beep_water_app

2.4 测试asme信号量的app编译

编译命令：

 arm-linux-gnueabihf-gcc  sema_beep_app.c  -o  sema_beep_app

在这里插入图片描述

2.5 运行验证

将编译的sema_beep_app执行文件放到设备的/root/water_soft/beep目录下；

cp sema_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

在这里插入图片描述
运行命令：

./sema_beep_app  /dev/beep 1&
 ./sema_beep_app  /dev/beep 0&

在这里插入图片描述
同时运行两个，第1个开启BEEP 10s,第2个关闭beep。
由现象可观测到，关闭命令 需要等待开启的命令运行完才会运行。所以可以知道，在操作Beep资源时，只有等待前面一个进程操作释放后，后一个进程才能操作beep资源。

三 互斥体

3.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    struct mutex lock;          /* 互斥体 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    if (mutex_lock_interruptible(&beep.lock)) {
        return -ERESTARTSYS;
    }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    mutex_unlock(&dev->lock);
    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    mutex_init(&beep.lock);

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

3.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

3.3 编写测试互斥体信号的app

编写测试app与2.3小结一样，重命名为mutex_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  mutex_beep_app.c  -o  mutex_beep_app
cp mutex_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

3.4 运行验证

运行命令：

 ./mutex_beep_app  /dev/beep  1&
 ./mutex_beep_app  /dev/beep  0&

在这里插入图片描述
实际现象与第二节内容一致，都是先运行完开启进程后，延时10s后才会执行第二个进程的关闭操作。

四 原子操作

4.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    // struct mutex lock;          /* 互斥体 */
    atomic_t lock; /* 原子变量 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{

    /* 通过判断原子变量的值来检查 beep 有没有被别的应用使用 */
    if (!atomic_dec_and_test(&beep.lock)) {
        atomic_inc(&beep.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
        return -EBUSY; /* beep 被使用，返回忙 */
    }

    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    // if (mutex_lock_interruptible(&beep.lock)) {
    //     return -ERESTARTSYS;
    // }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    // mutex_unlock(&dev->lock);

    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);

    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    // mutex_init(&beep.lock);

    /* 初始化原子变量 */
    atomic_set(&beep.lock, 1); /* 原子变量初始值为 1 */

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

4.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

4.3 编写测试原子操作的app

编写测试app与2.3小结一样，重命名为atomic_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  atomic_beep_app.c  -o  atomic_beep_app
 cp atomic_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

4.4 运行验证

运行命令：

 ./atomic_beep_app /dev/beep  1&
 ./atomic_beep_app /dev/beep  0&

在这里插入图片描述

实际现象是第2个进程使用beep时会报错，除非是第1个进程已经使用完beep释放了。

五 自旋锁

5.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    // struct mutex lock;          /* 互斥体 */
    // atomic_t lock; /* 原子变量 */
    int dev_stats;          /* 设备状态，0，设备未使用;>0,设备已经被使用 */
    spinlock_t lock;        /* 自旋锁 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    unsigned long flags;

    /* 通过判断原子变量的值来检查 beep 有没有被别的应用使用 */
    // if (!atomic_dec_and_test(&beep.lock)) {
    //     atomic_inc(&beep.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
    //     return -EBUSY; /* beep 被使用，返回忙 */
    // }

    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    // if (mutex_lock_interruptible(&beep.lock)) {
    //     return -ERESTARTSYS;
    // }

    spin_lock_irqsave(&beep.lock, flags); /* 上锁 */
    if (beep.dev_stats) { /* 如果设备被使用了 */
        spin_unlock_irqrestore(&beep.lock, flags); /* 解锁 */
        return -EBUSY;
    }
    beep.dev_stats++; /* 如果设备没有打开，那么就标记已经打开了 */
    spin_unlock_irqrestore(&beep.lock, flags);/* 解锁 */

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    // mutex_unlock(&dev->lock);

    /* 关闭驱动文件的时候释放原子变量 */
    // atomic_inc(&dev->lock);

    /* 关闭驱动文件的时候将 dev_stats 减 1 */
    spin_lock_irqsave(&dev->lock, flags); /* 上锁 */
    if (dev->dev_stats) {
        dev->dev_stats--;
    }
    spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */

    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    // mutex_init(&beep.lock);

    /* 初始化原子变量 */
    // atomic_set(&beep.lock, 1); /* 原子变量初始值为 1 */

    /* 初始化自旋锁 */
    spin_lock_init(&beep.lock);

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

5.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

5.3 编写测试自旋锁的app

编写测试app与2.3小结一样，重命名为spinlock_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  spinlock_beep_app.c  -o  spinlock_beep_app
cp spinlock_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

5.4 运行验证

运行命令：

 ./spinlock_beep_app  /dev/beep  1&
 ./spinlock_beep_app  /dev/beep  0&

在这里插入图片描述
实际现象是第2个进程使用beep时会报错，除非是第1个进程已经使用完beep释放了。

六 LED互斥资源

针对资源的互斥访问问题，在经过前面4个测试案例，后续开发kernel实际使用，beep驱动使用自旋锁，而led驱动使用原子变量方式。
led驱动更改后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : gpioled.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 LED 灯。
其他 : 无
日志 : 初版 V1.0 2023/05/24 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT 1           /* 设备号个数 */
#define GPIOLED_NAME "gpioled"  /* 名字 */
#define LEDOFF 0                /* 关灯 */
#define LEDON 1                 /* 开灯 */

/* gpioled 设备结构体 */
struct gpioled_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int led_gpio;           /* led 所使用的 GPIO 编号 */
    atomic_t lock; /* 原子变量 */
};
 
struct gpioled_dev gpioled; /* led 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int led_open(struct inode *inode, struct file *filp)
{
    /* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
    if (!atomic_dec_and_test(&gpioled.lock)) {
        atomic_inc(&gpioled.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
        return -EBUSY; /* LED 被使用，返回忙 */
    }

    filp->private_data = &gpioled; /* 设置私有数据 */
    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t led_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t led_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;
    struct gpioled_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    ledstat = databuf[0]; /* 获取状态值 */

    if(ledstat == LEDON) { 
        gpio_set_value(dev->led_gpio, 0); /* 打开 LED 灯 */
    } else if(ledstat == LEDOFF) {
        gpio_set_value(dev->led_gpio, 1); /* 关闭 LED 灯 */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;

    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);
    return 0;
}

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .read = led_read,
    .write = led_write,
    .release = led_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_led_init(void)
{
    int ret = 0;

    /* 初始化原子变量 */
    atomic_set(&gpioled.lock, 1); /* 原子变量初始值为 1 */

    /* 设置 LED 所使用的 GPIO */
    /* 1、获取设备节点：gpioled */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if(gpioled.nd == NULL) {
        printk("gpioled node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("gpioled node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
    if(gpioled.led_gpio < 0) {
        printk("can't get led-gpio");
        return -EINVAL;
    }
    printk("led-gpio num = %d\r\n", gpioled.led_gpio);

    /* 3、设置 GPIO1_IO03 为输出，并且输出高电平，默认关闭 LED 灯 */
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (gpioled.major) { /* 定义了设备号 */
        gpioled.devid = MKDEV(gpioled.major, 0);
        register_chrdev_region(gpioled.devid, GPIOLED_CNT,
                                    GPIOLED_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, 
                                    GPIOLED_NAME); /* 申请设备号 */
        gpioled.major = MAJOR(gpioled.devid); /* 获取分配号的主设备号 */
        gpioled.minor = MINOR(gpioled.devid); /* 获取分配号的次设备号 */
    }
    printk("gpioled major=%d,minor=%d\r\n",gpioled.major,
                                    gpioled.minor); 

    /* 2、初始化 cdev */
    gpioled.cdev.owner = THIS_MODULE;
    cdev_init(&gpioled.cdev, &gpioled_fops);

    /* 3、添加一个 cdev */
    cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);

    /* 4、创建类 */
    gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
    if (IS_ERR(gpioled.class)) {
    return PTR_ERR(gpioled.class);
    }

    /* 5、创建设备 */
    gpioled.device = device_create(gpioled.class, NULL,
                            gpioled.devid, NULL, GPIOLED_NAME);
    if (IS_ERR(gpioled.device)) {
        return PTR_ERR(gpioled.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_led_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&gpioled.cdev); /* 删除 cdev */
    unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销 */

    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
}

module_init(water_led_init);
module_exit(water_led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

七 总结

学会如何让资源访问变得更加和，需要加入上述所说的一些方法，来让互斥访问变得合理和有效。 后续也将根据上述方法继续开发后面的驱动程序。

waterfxw
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
＜Linux开发＞驱动开发 -之- Linux RTC 驱动
qq_39257814的博客
06-24 2095
本文主要分析Linux系统下的RTC，也就是实时时钟，RTC时钟是用来记录当前系统时间的；对于Linux系统来说，时间是一个非常重要的功能；比如我们的windows/linux电脑，会需要时间，还比如 我们的手机、平板，都需要时间；而且在很多app 或功能内都需要与时间打交道如导航等。本文就来分析一下linux系统下的RTC时钟。如果学习过 STM32 的话应该知道，STM32 内部有一个 RTC 外设模块，这个模块需要一个32.768KHz 的晶振，对这个 RTC 模块进行初始化就可以得到一个实时时钟。
＜Linux开发＞驱动开发 -之- Linux LCD 驱动
qq_39257814的博客
06-23 2131
LCD 液晶屏是常用到的外设，通过 LCD 可以显示绚丽的图形、界面等，提高人机交互的效率。本系列文章所用的开发板I.MX6U 提供了一个 eLCDIF 接口用于连接 RGB 接口的液晶屏。LCD 全称是 Liquid Crystal Display，也就是液晶显示器，是现在最常用到的显示器，手机、电脑、各种人机交互设备等基本都用到了 LCD，最常见就是手机和电脑显示器了。
＜Linux开发＞驱动开发 -之-内核定时器与中断
qq_39257814的博客
06-13 2363
定时器是我们最常用到的功能，一般用来完成定时功能，熟悉一下 Linux 内核提供的定时器 API 函数，通过这些定时器 API 函数我们可以完成很多要求定时的应用。Linux内核也提供了短延时函数，比如微秒、纳秒、毫秒延时函数，本章我们就来学习一下这些和时间有关的功能。中断也是频繁使用的功能，Linux 内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。下面我们就来一一分析。
＜Linux开发＞驱动开发 -之-platform 驱动
qq_39257814的博客
06-18 1211
在前面几篇文章讲解分析编写的设备驱动是相对简单，都是对 IO进行最简单的读写操作。那么如果像I2C、SPI、LCD 等，这类比较复杂外设的驱动就不能这么去写了，如果每一个I2C芯片都单独写一个I2C驱动对应IO的话，这样内核代码会很累赘，所以Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，在这个思路下诞生了platform 设备驱动，也叫做平台设备驱动。本文主要分析一下 Linux 下的驱动分离与分层，以及 platform 框架下的设备驱动该如何编写。
＜Linux开发＞驱动开发 -之-Linux INPUT 子系统
qq_39257814的博客
06-19 1019
按键、鼠标、键盘、触摸屏等都属于输入(input)设备，Linux 内核为此专门做了一个叫做 input子系统的框架来处理输入事件。输入设备本质上还是字符设备，只是在此基础上套上了 input 框架，用户只需要负责上报输入事件，比如按键值、坐标等信息，input 核心层负责处理这些事件。本文我们就来看一下 Linux 内核中的 input 子系统。网上也有很多资料介绍 input子系统相关的，有兴趣也可执行查阅。
＜Linux开发＞驱动开发 -Linux MISC 驱动
qq_39257814的博客
06-19 1053
misc 的意思是混合、杂项的，因此 MISC 驱动也叫做杂项驱动，也就是当我们板子上的某些外设无法进行分类的时候，比如说某个外设，既不是I2C设备、也不是SPI设备、更不是USB等设备，就可以使用 MISC 驱动。MISC 驱动其实就是最简单的字符设备驱动，通常嵌套在 platform 总线驱动中，实现复杂的驱动，本文我们就来学习一下 MISC 驱动的编写。
＜Linux开发＞驱动开发 -之-阻塞、非阻塞IO和异步通知
qq_39257814的博客
06-15 814
在＜Linux开发＞驱动开发 -之-内核定时器与中断的末尾我们看到，当应用程序运行时cpu占用率时很高的，这是因为一直开循环读取设备导致的，那么有什么方法可以有效处理这种情况呢？在kernel中提供了 阻塞IO、非阻塞IO以及异步通知等方法。为有效提升资源利用和降低cpu占用率，从而提升效率，我们一一分析这三种方法。这里的 IO 指的是 Input/Output，也就是输入/输出，是应用程序对驱动设备的输入/输出操作。
Linux驱动开发之并发与竞争实验【完整教程】
weixin_57037095的博客
03-19 332
  Linux系统是个多任务操作系统，会有多个任务同时存在的可能性，这些任务的内存可能相互覆盖，导致内存数据混乱，并发访问带来的问题就是竞争，会有以下问题导致Linux系统并发产生： ①多线程并发访问，这是Linux系统最基本的。 ②抢占式并发访问，Linux2.6版本后支持抢占。 ③中断程序并发访问 ④SMP（多核）核间并发访问 1.保护的是什么   一开始写驱动的时候就要考虑并发与竞争，否则写完驱动后不容易查找错误，导致驱动调试难度加大、费时费力。竞争的东西便是资源（在系统里是数据），故我们需要保护的数
Linux驱动开发——（三）并发与竞争
wJen的博客
04-21 1601
讲述了Linux内核的并发与竞争，以及原子操作、自旋锁和信号量。
牛客网Linux高并发服务器开发.zip
02-10
1. **嵌入式Linux开发**： 嵌入式Linux是Linux操作系统在嵌入式设备上的应用，如路由器、智能电视、物联网设备等。它通常包括裁剪版的Linux内核、文件系统和开发工具链，用于满足特定硬件平台和应用需求。开发者...
ZYNQ 7010-7020实现原子变量测试（Linux驱动）.zip
03-21
对于Linux驱动开发，理解并正确使用原子变量是至关重要的，因为它们确保了在多线程环境中的数据一致性。 首先，让我们了解一下原子变量。在计算机科学中，原子变量是一种特殊类型的变量，它的读取和写入操作是不可...
linux-基于消息驱动的二级任务调度模型
08-13
在Linux系统中，任务调度是操作系统的核心功能之一，它决定了哪些进程可以运行以及它们如何共享处理器时间。在“基于消息驱动的二级任务调度模型”中，我们探讨的是一个更为复杂和灵活的任务调度策略，它结合了消息...
Linux驱动开发之旅（三）－－非阻塞的锁机制
01-03
在Linux驱动开发中，锁机制是确保并发访问资源时数据一致性的重要工具。本文将深入探讨非阻塞的锁机制，特别是在“Linux驱动开发之旅（三）”中提及的3_mutex，这种锁机制允许任务在无法获取锁时立即返回，而不是...
zynq的linux驱动5-使用原子操作实现mio资源的竞争保护
01-28
在Linux驱动程序开发中，特别是在多处理器系统如Zynq上，确保资源的并发访问安全是至关重要的。标题“zynq的linux驱动5-使用原子操作实现mio资源的竞争保护”表明我们将讨论如何通过使用原子操作来防止MIO...
PCIe驱动开发（3）— 驱动设备文件的创建与操作
最新发布
qq_38113006的博客
07-13 122
在 Linux 中一切皆为文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx” (xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。
底软驱动 | Linux字符设备驱动开发基础
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
07-13 369
/fops结构体dev_t dev;//设备号（包含主设备号和次设备号）;dev_t类型：typedef u_long dev_t;cdev_alloccdev_initcdev_addcdev_del(2)设备号：主设备号+次设备号MKDEV：由一个主设备号和次设备号算出设备号MAJOR：从设备号提取主设备号MINOR：从设备号提取次设备号代码示例：新的接口注册字符设备驱动需要两步(定义一个全局cdev结构体)│├── 模块安装函数xxx。
Linux驱动开发中设备节点、虚拟节点、逻辑节点之间的区别与关系
17岁boy的博客
07-13 213
每个节点都是对某一物理设备或功能抽象或具体的描述
Linux驱动开发-03字符设备驱动框架搭建
Abcd_cnom的博客
07-09 220
** @description : 打开设备* @param - inode : 传递给驱动的inode* @param - filp : 设备文件，file结构体有个叫做private_data的成员变量* 一般在open的时候将private_data指向设备结构体。* @return : 0 成功;其他 失败*//** @description : 从设备读取数据* @param - filp : 要打开的设备文件(文件描述符)
Linux设备驱动中的并发控制
06-03
在Linux设备驱动中，由于多个进程或线程可能会同时访问设备，因此需要进行并发控制以确保设备的正确性和稳定性。...在开发Linux设备驱动时，需要根据实际情况选择合适的并发控制方法，并注意避免死锁和竞争条件等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

waterfxw

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值