0
0

Linux 驱动开发基础知识—— 驱动设计的思想（六）

个人名片：

🦁作者简介：一名喜欢分享和记录学习的在校大学生
🐯个人主页：妄北y

🐧个人QQ：2061314755

🐻个人邮箱：2061314755@qq.com
🦉个人WeChat：Vir2021GKBS
🐼本文由妄北y原创，首发CSDN🎊🎊🎊
🐨座右铭：大多数人想要改造这个世界，但却罕有人想改造自己。

专栏导航：

妄北y系列专栏导航:

C/C++的基础算法：C/C++是一种常用的编程语言，可以用于实现各种算法，这里我们对一些基础算法进行了详细的介绍与分享。🎇🎇🎇

QT基础入门学习：对QT的基础图形化页面设计进行了一个简单的学习与认识，利用QT的基础知识进行了翻金币小游戏的制作🤹🤹🤹

Linux基础编程：初步认识什么是Linux，为什么学Linux，安装环境，进行基础命令的学习，入门级的shell编程。🍻🍻🍻

Linux应用开发基础开发：分享Linux的基本概念、命令行操作、文件系统、用户和权限管理等，网络编程相关知识，TCP/IP 协议、套接字（Socket）编程等，可以实现网络通信功能。💐💐💐

Linux项目开发：Linux基础知识的实践，做项目是最锻炼能力的一个学习方法，这里我们会学习到一些简单基础的项目开发与应用，而且都是毕业设计级别的哦。🤸🤸🤸

非常期待和您一起在这个小小的互联网世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨

文章介绍：

🎉本篇文章对Linux驱动基础学习的相关知识进行分享！🥳🥳🥳

Linux驱动设计思想的核心在于模块化、可重用、高度抽象和多层次结构，使用分离思想、分层设计思想、机与外设分隔思想等以确保在不同硬件平台上提供一致的。

如果您觉得文章不错，期待你的一键三连哦，你的鼓励是我创作动力的源泉，让我们一起加油，一起奔跑，让我们顶峰相见！！！💪💪💪

🎁感谢大家点赞👍收藏⭐评论✍️

目录：

一、设计思想

1.1 面向对象

    字符设备驱动程序抽象出一个** file_operations** 结构体；

    硬件程序针对硬件部分抽象出** led_operations **结构体。

1.2 分层

    上下分层，比如我们前面写的 LED 驱动程序就分为 2 层：

    上层实现**硬件无关的操作**，比如注册字符设备驱动：**leddrv.c**

    下层实现**硬件相关的操作**，比如 board_A.c 实现单板 A 的 LED 操作

1.3 分离

    在 board_A.c 中，实现了一个 led_operations，为 LED 引脚实现了初始化函数、控制函数：

static struct led_operations board_demo_led_opr = {
    .num = 1,
    .init = board_demo_led_init,
    .ctl = board_demo_led_ctl,
};

    如果硬件上**更换一个引脚来控制 LED 怎么办**？你要去修改上面结构体中的 init、ctl 函数。

     实际情况是，每一款芯片它的 GPIO 操作都是类似的。比如：GPIO1_3、 GPIO5_4 这 2 个引脚接到 LED：

** （1）GPIO1_3 属于第 1 组，即 GPIO1。**

             a) 有**方向寄存器 DIR、数据寄存器 DR **等，基础地址是 addr_base_addr_gpio1。

             b) 设置为 output 引脚：修改 GPIO1 的 DIR 寄存器的 bit3。

             c) 设置输出电平：修改 GPIO1 的 DR 寄存器的 bit3。

** （2） GPIO5_4 属于第 5 组，即 GPIO5。**

            a) 有**方向寄存器 DIR、数据寄存器 DR **等，基础地址是 addr_base_addr_gpio5。

            b) 设置为 output 引脚：修改 GPIO5 的 DIR 寄存器的 bit4。

            c) 设置输出电平：修改 GPIO5 的 DR 寄存器的 bit4。

    既然引脚操作那么有规律，并且这是跟主芯片相关的，那可以针对该芯片写 出比较通用的硬件操作代码。

    比如 board_A.c 使用芯片 chipY，那就可以写出：chipY_gpio.c，它实现芯片 Y 的 GPIO 操作，适用于芯片 Y 的所有 GPIO 引脚。

    使用时，我们只需要在 board_A_led.c 中指定使用哪一个引脚即可。程序结构如下：


    以**面向对象的思想**，在 board_A_led.c 中实现** led_resouce **结构体，它定义“资源”──要用哪一个引脚。

     在 chipY_gpio.c 中仍是实现 led_operations 结构体，它要写得更完善， 支持所有 GPIO。

二、代码分析

    程序仍分为上下结构：

    上层** leddrv.c** 向内核注册** file_operations **结构体；下层 **chip_demo_gpio.c** 提供 **led_operations** 结构体来操作硬件。

    下层的代码分为 2 个：**chip_demo_gpio.c** 实现通用的** GPIO 操作**，** board_A_led.c** 指定使用**哪个 GPIO**，即“**资源**”。

2.1 ** led_resource.h**

   ** led_resource.h** 中定义了 **led_resource** 结构体，用来**描述 GPIO**：

#ifndef _LED_RESOURCE_H
#define _LED_RESOURCE_H

/* GPIO3_0 */
/* bit[31:16] = group */
/* bit[15:0]  = which pin */
#define GROUP(x) (x>>16)
#define PIN(x)   (x&0xFFFF)
#define GROUP_PIN(g,p) ((g<<16) | (p))

struct led_resource {
    int pin;
};

struct led_resource *get_led_resouce(void);

#endif

2.2 board_A_led.c

** board_A_led.c** 指定使用哪个 GPIO，它实现一个** led_resource** 结构体,并提供访问函数：

    当我们以后换了开发板我们只需要修改这里的资源函数


#include "led_resource.h"

static struct led_resource board_A_led = {
    .pin = GROUP_PIN(3,1),
};

struct led_resource *get_led_resouce(void)
{
    return &board_A_led;
}

第5行：表示第3组第1个引脚

.pin = GROUP_PIN(3,1)

第8~11行：便于访问这里的变量

2.3 ** chip_demo_gpio.c **

**    chip_demo_gpio.c **中，首先**获得 board_A_led.c 实现的 led_resource 结构体**，然后再进行其他操作。

#include <linux/module.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include "led_opr.h"
#include "led_resource.h"

static struct led_resource *led_rsc;
static int board_demo_led_init (int which) /* 初始化LED, which-哪个LED */       
{    
    //printk("%s %s line %d, led %d\n", __FILE__, __FUNCTION__, __LINE__, which);
    if (!led_rsc)
    {
        led_rsc = get_led_resouce();
    }
    
    printk("init gpio: group %d, pin %d\n", GROUP(led_rsc->pin), PIN(led_rsc->pin));
    switch(GROUP(led_rsc->pin))
    {
        case 0:
        {
            printk("init pin of group 0 ...\n");
            break;
        }
        case 1:
        {
            printk("init pin of group 1 ...\n");
            break;
        }
        case 2:
        {
            printk("init pin of group 2 ...\n");
            break;
        }
        case 3:
        {
            printk("init pin of group 3 ...\n");
            break;
        }
    }
    
    return 0;
}

static int board_demo_led_ctl (int which, char status) /* 控制LED, which-哪个LED, status:1-亮,0-灭 */
{
    //printk("%s %s line %d, led %d, %s\n", __FILE__, __FUNCTION__, __LINE__, which, status ? "on" : "off");
    printk("set led %s: group %d, pin %d\n", status ? "on" : "off", GROUP(led_rsc->pin), PIN(led_rsc->pin));

    switch(GROUP(led_rsc->pin))
    {
        case 0:
        {
            printk("set pin of group 0 ...\n");
            break;
        }
        case 1:
        {
            printk("set pin of group 1 ...\n");
            break;
        }
        case 2:
        {
            printk("set pin of group 2 ...\n");
            break;
        }
        case 3:
        {
            printk("set pin of group 3 ...\n");
            break;
        }
    }

    return 0;
}

static struct led_operations board_demo_led_opr = {
    .init = board_demo_led_init,
    .ctl  = board_demo_led_ctl,
};

struct led_operations *get_board_led_opr(void)
{
    return &board_demo_led_opr;
}

第26行：先获得 board_A_led.c 实现的 led_resource 结构体

第29~52行：查看初始化的GPIO哪一组

printk("init gpio: group %d, pin %d\n", GROUP(led_rsc->pin), PIN(led_rsc->pin));
    switch(GROUP(led_rsc->pin))
    {
        case 0:
        {
            printk("init pin of group 0 ...\n");
            break;
        }
        case 1:
        {
            printk("init pin of group 1 ...\n");
            break;
        }
        case 2:
        {
            printk("init pin of group 2 ...\n");
            break;
        }
        case 3:
        {
            printk("init pin of group 3 ...\n");
            break;
        }
    }

第60~84行：查看控制GPIO哪一组 

    printk("set led %s: group %d, pin %d\n", status ? "on" : "off", GROUP(led_rsc->pin), PIN(led_rsc->pin));

    switch(GROUP(led_rsc->pin))
    {
        case 0:
        {
            printk("set pin of group 0 ...\n");
            break;
        }
        case 1:
        {
            printk("set pin of group 1 ...\n");
            break;
        }
        case 2:
        {
            printk("set pin of group 2 ...\n");
            break;
        }
        case 3:
        {
            printk("set pin of group 3 ...\n");
            break;
        }
    }

2.4 Makefile


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR = /home/book/100ask_roc-rk3399-pc/linux-4.4

all:
    make -C $(KERN_DIR) M=`pwd` modules 
    $(CROSS_COMPILE)gcc -o ledtest ledtest.c 

clean:
    make -C $(KERN_DIR) M=`pwd` modules clean
    rm -rf modules.order
    rm -f ledtest

# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o

# leddrv.c board_demo.c 编译成 100ask.ko
100ask_led-y := leddrv.o chip_demo_gpio.o board_A_led.o
obj-m    += 100ask_led.o

2.5 ledtest


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/*
 * ./ledtest /dev/100ask_led0 on
 * ./ledtest /dev/100ask_led0 off
 */
int main(int argc, char **argv)
{
    int fd;
    char status;
    
    /* 1. 判断参数 */
    if (argc != 3) 
    {
        printf("Usage: %s <dev> <on | off>\n", argv[0]);
        return -1;
    }

    /* 2. 打开文件 */
    fd = open(argv[1], O_RDWR);
    if (fd == -1)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    /* 3. 写文件 */
    if (0 == strcmp(argv[2], "on"))
    {
        status = 1;
        write(fd, &status, 1);
    }
    else
    {
        status = 0;
        write(fd, &status, 1);
    }
    
    close(fd);
    
    return 0;
}

三、上机测试

3.1编译

编译程序，把代码上传代服务器后执行 make 命令。

cp 100ask_led.ko ledtest ~/nfs_rootfs/

3.2 挂载到开发板

在开发板上挂载 NFS

3.3 测试

最后在开发板上加载驱动程序，执行测试程序，如下：

echo "7    4    1    7" > /proc/sys/kernel/printk      //调整内核printk的打印级别

3.4 结果

大佬觉得有用的话点个赞 👍🏻 呗。
❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍

🔥🔥🔥任务在无形中完成，价值在无形中升华,让我们一起加油吧！🌙🌙🌙

标签： 驱动开发 linux 驱动设计思路
本文转载自: https://blog.csdn.net/m0_63168877/article/details/135884821
版权归原作者 妄北y 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Linux 驱动开发基础知识—— 驱动设计的思想（六）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

在Ubuntu中自动挂载SMB/CIFS共享

【在Linux世界中追寻伟大的One Piece】Reactor反应堆模式

如果大家想在win7上使用pycharm，就不能使用2019.3之后的版本（内附下载不同pycharm版本的链接）

如何使用vscode进行代码格式化设置

史上最简单open-webui安装方式!!!

前端文件预览整合（一）

mysql 您要的日期查询都在这

文章导航