大型linux驱动项目框架基础

已于 2024-03-06 00:53:58 修改
阅读量483 收藏 9
点赞数 10
分类专栏： linux驱动 文章标签： linux
于 2024-03-01 23:14:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51189513/article/details/136407765
版权

大型linux驱动项目框架基础

文章目录

声明：尝试阶段，欢迎有志之士提出建议，或者共同完善
联系方式：qq:1614811057
博客目前状态：持续更新中

1.主入口

makefile

arch ?= x86
modname ?= hello_drv

ifeq ($(arch),arm)
	KERNELDIR := /home/psd/code_space/100ask_imx6ull-sdk/Linux-4.9.88
else
	KERNELDIR := /lib/modules/$(shell uname -r)/build/
endif

PWD := $(shell pwd)
# ccflags-y += -I$(PWD)/../irq_sr501
ccflags-y += -I/home/psd/code_space/100ask_imx6ull-sdk/my_project_space/project_test/irq/irq_sr501

all:
	make -C $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

obj-m += $(modname).o
obj-m += irq_main.o
obj-m += irq_sr501.o

main.c

#include "irq_main.h"

module_t mod_table[] = {
    { irq_sr501_init, irq_sr501_exit }, // 定义函数指针数组，用于存储模块初始化和退出函数的地址
};

sub_module_t kmd_module_table[] = {
    {
        .name = "irq_sr501",
        .code_num = 0,
        .sub_component = &mod_table[0]
    },
};

static int irq_main_init(void)
{
    int ret = 0;
    int i = 0;
    // 对模块进行初始化，遍历子模块数组，并依次调用其中存储的函数指针
    for (i = 0; i < ARRAY_SIZE(kmd_module_table); i++) {
        if (kmd_module_table[i].sub_component->init != NULL) {
            ret = (int)kmd_module_table[i].sub_component->init();
            printk("sucess to initialize module: %s %d %d\n", kmd_module_table[i].name, kmd_module_table[i].code_num, i);
            if (ret != 0) {
                // 如果初始化函数返回错误，则打印错误信息并返回
                printk(KERN_ERR "Failed to initialize module: %s %d %d\n", kmd_module_table[i].name, kmd_module_table[i].code_num, i);
                return ret;
            }
        }
    }
    return ret;
}

static void irq_main_exit(void)
{
    int i = 0;
    // 对模块进行退出操作，逆序遍历子模块数组，并依次调用其中存储的函数指针
    for (i = ARRAY_SIZE(kmd_module_table) - 1; i >= 0; i--) {
        if (kmd_module_table[i].sub_component->exit != NULL) {
            kmd_module_table[i].sub_component->exit();
            printk("sucess to initialize module: %s %d %d\n", kmd_module_table[i].name, kmd_module_table[i].code_num, i);
        }
    }
}

module_init(irq_main_init); // 设置模块初始化函数
module_exit(irq_main_exit); // 设置模块退出函数
MODULE_LICENSE("GPL"); // 设置模块许可证

main.h

#ifndef __IRQ_MAIN_H__
#define __IRQ_MAIN_H__

#include "irq_sr501.h"
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/kmod.h>
#include <linux/major.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/timer.h>
#include <linux/tty.h>

typedef struct kmd_module {
    int (*init)(void);
    void (*exit)(void);
} module_t;

typedef struct kmd_sub_module {
    char* name;
    int code_num;
    module_t* sub_component;
} sub_module_t;

static int irq_main_init(void);
static void irq_main_exit(void);

#endif

2.驱动模块

2.1温度中断传感器sr501

路径：

/home/psd/code_space/100ask_imx6ull-sdk/my_project_space/project_test/irq/irq_sr501

.c

#include "irq_sr501.h"



static int __init irq_sr501_init(void)
{

	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	return 0;
}


static void __exit irq_sr501_exit(void)
{

	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

}

.h

#ifndef __IRQ_SR501_H__
#define __IRQ_SR501_H__

#include <linux/module.h>
#include <linux/poll.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 <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

static int __init irq_sr501_init(void);
static void __exit irq_sr501_exit(void);

#endif

目前状态：

无法加载sr_501文件
从下面的实验已经可以找到问题所在了，但是这一块不急，先在同一目录下多集成几个模块之后再扩大规模

3.最新进展：

同目录下的不同模块集成已完成，
正在完善主入口文件里面的基础配套操作

3.1文件目录结构介绍

3.1.1目录：

在这里插入图片描述

3.1.2文件：
led_ctrl.h:
#ifndef __LED_CTRL_H__
#define __LED_CTRL_H__

#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define LED_NAME "led"
#define PATH_DTS_LED "/leds/led0"

#define KMD_ERR(str) \
	printk("%s %s line: %d %s \n", __FILE__, __FUNCTION__, __LINE__, str);

typedef struct led_ctrl {
    char *dev_name;
    struct device_node *led_node;
    int led_num;
} led_ctrl_t;

void test(void);
int led_ctrl_init(led_ctrl_t * led);

int led_ctrl_exit(led_ctrl_t * led);

#endif
led_ctrl.c:
#include"led_ctrl.h"

// led_ctrl_t led =
// {
//     .dev_name = LED_NAME,

// };
void test(void)
{
    KMD_ERR("led_ctrl_init 测试");
}
int led_ctrl_init(led_ctrl_t * led)
{
    // led->led_node = of_find_node_by_path(PATH_DTS_LED);
    KMD_ERR("led_ctrl_init 测试");
    return 0;
}

int led_ctrl_exit(led_ctrl_t * led)
{
    KMD_ERR("led_ctrl_exit 测试");
    return 0;
}
irq_base.h:
#ifndef __IRQ_BASE_H__
#define __IRQ_BASE_H__

#include <linux/module.h>
#include <linux/poll.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 <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

#define KMD_ERR(str) \
	printk("%s %s line: %d %s \n", __FILE__, __FUNCTION__, __LINE__, str);

typedef struct irq_base
{
    unsigned int major;
    const char *name;
    struct class *class;
    struct device * device;

} irq_base_t;

// 字符设备初始化
static int irq_cdev_init(void);   

#endif

irq_base.c

#include "irq_base.h"
#include "irq_sr501.h"

#define IRQ_BASE_NAME "IRQ_BASE"
static irq_base_t irq_base = {
	.name = IRQ_BASE_NAME,
};


static int irq_base_open(struct inode *inode, struct file *file)
{
	int ret = 0;
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	return -ret;
}

static ssize_t irq_base_read(struct file *file, char __user *buf,
			   size_t count, loff_t *ppos)
{
	int ret = 0;
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	return ret;
}

static ssize_t irq_base_write(struct file *file, const char __user *buf,
			    size_t count, loff_t *ppos)
{
	int ret = 0;
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	return ret;
}

static int irq_base_release(struct inode *inode, struct file *file)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	return 0;
}

static const struct file_operations irq_base_fops = {
	.owner		= THIS_MODULE,
	.open		= irq_base_open,
	.read		= irq_base_read,
	.write		= irq_base_write,
	.release	= irq_base_release,
};

static int irq_cdev_init(void)
{
	// 在/proc/devices文件中添加对应的字符设备信息和主设备号
	irq_base.major =  register_chrdev(0, irq_base.name, &irq_base_fops);
	if (irq_base.major < 0)
	{
		KMD_ERR("irq_base.major get ERR");
		goto ERR_IO;
	}
	// 在/sys/class/目录下添加了一个IRQ_BASE的目录，
	irq_base.class = class_create(THIS_MODULE, irq_base.name);
	if(IS_ERR(irq_base.class))
	{
		KMD_ERR("irq_base.class get ERR");
		return PTR_ERR(irq_base.class);
		goto class_ERR;
	}

	irq_base.device = device_create(irq_base.class,NULL, MKDEV(irq_base.major,0), NULL, "%s", irq_base.name);
	if(IS_ERR(irq_base.device))
	{
		KMD_ERR("irq_base.device get ERR");
		return PTR_ERR(irq_base.device);
		goto device_ERR;
	}
	return 0;
device_ERR:
	class_destroy(irq_base.class);
class_ERR:
	unregister_chrdev(irq_base.major, irq_base.name);
ERR_IO:
	return -EIO;			//没有这样的设备或地址
}

/* 在入口函数 */
static int __init irq_base_init(void)
{
	int ret = 0;
	// printk(KERN_ERR "irq_sr501_init 测试\n");
	if(irq_sr501_init())
	{
		printk(KERN_ERR "irq_sr501_init ERR\n");
		return -EINVAL;
	}

	if((ret = irq_cdev_init()) != 0)
	{
		KMD_ERR("irq_cdev_init ERR");
		return ret;
	}
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	return 0;
}

/* 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 */
static void __exit irq_base_exit(void)
{
	device_destroy(irq_base.class, MKDEV(irq_base.major, 0));
	class_destroy(irq_base.class);
	unregister_chrdev(irq_base.major, irq_base.name);
	irq_sr501_exit();
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

}

module_init(irq_base_init);
module_exit(irq_base_exit);

MODULE_DESCRIPTION("irq_base_driver");
MODULE_LICENSE("GPL");
irq_sr501.h
#ifndef __IRQ_SR501_H__
#define __IRQ_SR501_H__

#include <linux/module.h>
#include <linux/poll.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 <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

int __init irq_sr501_init(void);
void __exit irq_sr501_exit(void);

#endif
irq_sr501.c
#include "irq_sr501.h"


/* 在入口函数 */
int __init irq_sr501_init(void)
{

	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	return 0;
}

/* 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 */
void __exit irq_sr501_exit(void)
{

	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

}
MODULE_DESCRIPTION("irq_sr501_driver");
MODULE_LICENSE("GPL");
makefile
arch ?= arm
modname ?= irq_base
PWD := $(shell pwd)
TARGET := IRQ_MAIN
INCLUDE_DIR := other_module
CFLAGS_DIR := $(PWD)/$(INCLUDE_DIR)
# 定义额外的编译选项,EXTRA_CFLAGS 变量用于指定额外的编译选项，可以通过它向编译器传递自定义的选项
EXTRA_CFLAGS += -I$(CFLAGS_DIR)
ifeq ($(arch),arm)
	KERNELDIR := /home/psd/code_space/100ask_imx6ull-sdk/Linux-4.9.88
else
	KERNELDIR := /lib/modules/$(shell uname -r)/build/
endif

$(TARGET)-objs := ./other_module/led_ctrl.o irq_sr501.o irq_base.o     #依赖的中间文件
obj-m += $(TARGET).o			#生成最终TARGET.ko文件
#  $(CFLAGS) INCDIR=$(PWD)/$(INCLUDE_DIR)
all:
	make -C $(KERNELDIR) M=$(PWD) EXTRA_CFLAGS='$(EXTRA_CFLAGS)' modules
	@echo "Copying module files to ~/nfs_rootfs/"
	@if [ -d ~/nfs_rootfs ]; then \
		if [ -e ~/nfs_rootfs/*.ko -o -e ~/nfs_rootfs/*.sh ]; then \
			rm -f ~/nfs_rootfs/*.ko ~/nfs_rootfs/*.sh; \
		fi; \
		if [ -e ./*.ko ]; then \
			cp -f ./*.ko ~/nfs_rootfs/; \
		fi; \
		if [ -e ./*.sh ]; then \
			cp -f ./*.sh ~/nfs_rootfs/; \
		fi; \
	fi
clean:
	make -C $(KERNELDIR) M=$(PWD) clean
#obj-m是模块化编译会生成.ko文件，obj-y则是编译进内核不会生成.ko文件
#-objs代表需要编译的依赖中间.o文件
op_mod.sh
lsmod
dmesg -c
rmmod *.ko
lsmod
dmesg
# 删除完之后打印下
insmod *.ko
dmesg
cat /proc/devices
ls /sys/class
ls /dev

3.2调试进展

已经可以调用其他目录下驱动模块代码

在这里插入图片描述

嵌入式修炼师
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux入门和Python数据分析第二版.pdf
07-01
4. 深度学习框架支持：许多深度学习框架如PyTorch，最初优先支持Linux。 常见的Linux发行版有CentOS、Ubuntu等，对于个人学习，Ubuntu是一个良好的起点，其用户界面友好，且拥有丰富的资源和支持。安装Ubuntu可以...
Spark01 基础解析.docx
06-28
Spark最初由加州大学伯克利分校AMPLab开发，后来逐渐演变为Apache顶级项目，成为业界广泛采用的大数据处理工具。 **Spark的核心组件** 1. **Spark Core**：Spark的基础架构，负责任务调度、内存管理、错误恢复以及...
Linux驱动开发：字符设备驱动开发实战
嵌入式学习记录站点
09-25 3005
Linux驱动开发：字符设备驱动开发实战
嵌入式Linux项目实战：三个大项目(数码相框、摄像头驱动和电源管理),九个衍生项目视频教程
06-03
包括3个大项目和若干衍生项目，涵盖：数码相框、电子书、指针、链表、Makefile、网络编程Socket、USB摄像头、CMOS摄像头、视频监控、WIFI、3G网卡、ALSA声卡、便携式视频监控（局域网通信）和电源管理。总体格调：应用为主驱动为辅，手把手现场写代码，再现项目实现过程
Linux下的几种驱动的开发步骤
最新发布
小桥流水 的专栏
04-01 1328
Linux的几种类型的驱动开发详解
最全Linux驱动开发全流程详细解析（持续更新）
热门推荐
拉依达不拉跨的博客
02-19 3万+
Linux驱动开发详细解析
Linux驱动——设备树
Linux驱动相关内容及Android开发
04-10 2509
设备树是用于描述一个机器或平台上所有设备信息的独立文件（一个结构体变量）例如：一块开发板有SOC、CPU、CLOCK，SOC中又存在外设IIC、UART等。
Linux驱动开发项目BL5372--hwclock用法及实现过程详解
xi_xix_i的博客
11-07 573
讲解了hwclock的用法以及实现过程，并且对如何编写合适的rtc驱动程序来适配该命令做出了一定探索
电信级Linux设备中驱动程序的研究与开发.pdf
09-07
文章提到，详细的Linux驱动程序编写和系统机制可以参考其他专业文献和硬件架构资料。这些规则和细则对所有涉及电信级驱动开发的项目都有指导价值。 总之，电信级Linux设备驱动程序的研究与开发是提升系统性能、...
简单、跨平台、企业级桌面软件开发框架
04-20
架构：单业务进程/模块化/多任务(进程，线程，渲染进程)，让开发大型项目变的简单。 简单高效：只需学习 js 语言；前端独立：理论上支持任何前端技术； 工程化：可以用前端、服务端的开发思维，来编写桌面软件； 高...
Linux与其他操作系统文件的互访.pdf
09-07
例如，Linux内核可以支持读取FAT和NTFS分区，但写入操作可能需要第三方软件，如FUSE（Filesystem in Userspace）框架下的ntfs-3g项目。这些工具允许Linux用户在不改变文件系统元数据的情况下，读取和写入Windows分区...
正点原子嵌入式linux驱动开发——Linux 网络设备驱动
xhj12138的博客
11-05 3889
正点原子linux驱动开发的学习笔记，这一篇是Linux下的网络设备驱动
Linux下驱动开发
weixin_44453694的博客
09-06 2070
驱动，是指驱动计算机里软件的程序。驱动程序全称设备驱动程序，是添加到操作系统中的特殊程序，其中包含有关硬件设备的信息。驱动程序是操作系统与硬件连接的桥梁。设备驱动最通俗的解释就是“驱使硬件设备行动”。驱动与底层硬件直接打交道，按照硬件设备的具体工作方式，读写设备的寄存器，完成设备的轮询、中断处理、DMA通信，进行物理内存向虚拟内存的映射等，最终让通信设备能收发数据，让显示设备能显示文字和画面，让存储设备能记录文件和数据。
Linux驱动开发
mxh3600的博客
03-10 5167
Linux驱动开发
Linux 驱动程序（一）
analog4535的博客
01-15 1193
Linux 驱动程序 1.Linux驱动的分类 字符驱动设备: IO的传输过程是以字符为单位的，没有缓冲。比如I2C、SPI都是字符设备 块设备驱动： IO的传输过程是以块为单位的。根存储相关的，都属于块设备，比如，tf卡 网络设备驱动：是以socket套接字来访问的。 其中，理解和掌握字符设备驱动的概念最为重要，在实际工作中遇到的大部分都是字符设备。 驱动分为四个部分： 头文件 驱动模块的入口和出口 声明信息 功能实现 /*******step1 包含头文件*************/ #
linux内核驱动开发案例
qq_41371920的博客
10-15 1036
linux分为用户态和内核态，内核态拥有更高的权限（例如可以关闭中断实现更高的优先级），这周在内核态开发了一个简单的驱动，做个经验总结。 任务背景： 由于业务需求433Mhz通讯，而采用的芯片为纯透传模式（无fifo寄存器），所以产生了较高的序要求，用户态无法 完成该工作，故在内核态开发（最高优先级，关闭所有中断，相当于百分百占用cpu）。 对于内核态与用户态最直观浅显的理解是：用户态运行程序的方式为： 编写.c文件→编译器用特定编译选项（适配当前系统）得到可执行文件→开整 内核态运行特定程序的方式为：
[转]编写Linux驱动程序
yijiejinlan的专栏
08-22 831
第6章  编写Linux驱动程序 6.1  Linux驱动程序概述 LINUX中的驱动设计是嵌入式LINUX开发中十分重要的部分，它要求开发者不仅要熟悉LINUX的内核机制、驱动程序与用户级应用程序的接口关系、考虑系统中对设备的并发操作等等，而且还要非常熟悉所开发硬件的工作原理。这对驱动开发者提出了比较高的要求，本章是给大家了解驱动设计提供一个简单入门的一个实例，并不需要提供太多与硬件相关的内
Linux 驱动开发简单实例
pengrenhui的博客
09-19 259
新手入门Linux驱动开发
linux驱动spi框架
06-09
Linux驱动SPI框架是一套用于支持SPI总线设备驱动的框架，其主要作用是提供一组API函数接口，用于SPI设备的注册、管理和操作。其主要包含以下几个组成部分： 1. SPI总线控制器驱动：负责管理和控制SPI总线硬件设备，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值