Linux驱动开发学习记录01

已于 2024-03-22 10:42:26 修改
阅读量882 收藏 8
点赞数 28
文章标签： linux 驱动开发 学习
于 2024-03-22 10:36:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/saber_mine/article/details/136911078
版权

记录学习Linux驱动开发中遇到的一系列问题

Linux常用指令

记录一些在学习时常用的指令
一些特别常用的就不记录啦

  1. gedit 文件名//修改文件
  2. 卸载驱动，如果想卸载当前未被使用的模块，可以使用lsmod命令列出所有当前加载的模块，然后用rmmod 驱动名卸载。
  3. cp -rf ，用于递归地复制文件和目录，并且在复制过程中会覆盖已存在的目标文件。

Linux驱动开发

一.第一个实验（hello）

1.代码

①.hello_drv.c
#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>
#include <linux/uaccess.h>
#include <linux/module.h>
static int major;
static int hello_open(struct inode *node, struct file *filp){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏，横线为两个横线
	return 0;
};
static ssize_t hello_read(struct file *filp, char __user *buf, size_t size, loff_t *offset){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return size;
	};
static ssize_t  hello_write(struct file *flip, const char __user *buf, size_t size, loff_t *offset){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return size;
	};
static int hello_release (struct inode *node, struct file *filp){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return 0;
	};
//1.构造operations结构体
static const struct file_operations hello_drv = {
	.owner=THIS_MODULE,
	.read		= hello_read,**//.read其实是函数指针，右面应该是取地址，&hello_read，但是函数可以省略取地址**
	.write		= hello_write,
	.open		= hello_open,
	.release	= hello_release,
};
//2.resister_ chrdev
//3.入口
static int  hello_init(void)
{
	major=register_chrdev(0,"hello",&hello_drv);
	return 0;
}
//4.出口
static void  hello_exit(void)
{
	unregister_chrdev(major,"hello");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
②.hello_test.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
int fd;
int len;
char buf[100];
int main(int argc,char**argv){

    if(argc<2){
        printf("Usage:\n");
        printf("%s <dev> [string]\n",argv[0]);   //<>表示不能省略   []表示可以省略
        return -1;
    }
//open
fd=open(argv[1],O_RDWR);
if(fd<0){
    printf("cannot open file %s\n",argv[0]);
    return -1;
}
//write
if(argc==3){
    len=write(fd,argv[2],strlen(argv[2]+1));//write函数write(fd,buf,len)，
    /*注意strlen(argv[2]+1)，+ 1 是为了包含字符串末尾的空字符（null character）
    C语言中的字符串是以空字符（\0）作为字符串的结束标志的。strlen函数会计算字符串中除了
    空字符之外的字符数量。当你使用write函数将字符串写入文件时，通常需要包含空字符，以确
    保完整地写入整个字符串，包括字符串的结束标志。因此，strlen(argv[2]) + 1 用于计算
    存储在 argv[2] 中的字符串的长度，并添加额外的 1 个字节来包含空字符。这样，write函
    数将会写入整个字符串，包括空字符，确保数据的完整性。*/
    printf("write ret=%d\n",len);
}
else{
//read
    len=read(fd,buf,100);//read函数write(fd,buf,len)
    buf[99]='\0';
    printf("read str:%s\n",buf);
}
//close
    close(fd);
    return 0;
    }
③.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_imx6ull-sdk/Linux-4.9.88

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

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

obj-m	+= hello_drv.o

makefile写完后保存并make

4.执行步骤

1.连接开发板（有一次串口连接没连上，搜不到串口，后重启才连上）。
2.挂载网络系统

mount -t nfs -o nolock,vers=3 192.168.5.11:/home/book/nfs_rootfs /mnt

3.有些板子把内核信息屏蔽了，打开内核信息，echo "7 4 1 7" > /proc/sys/kernel/printk
4.有的内核太老了，需要更新板子内核（不详细解释）
5.在开发板中进入/mnt/（后面是挂载的文件夹）
6.输入insmod hello_drv.ko
7.装载成功后，输入cat /proc/devices查看所有设备，记录新添加的hello主设备号，本例为240
8.可以改名（存疑）mknod /dev/xyz c 240 0xyz表示名字不重要，c表示是字符型设备，240为主设备号，0为次设备号
9.进行测试

./hello_test /dev/xyz
./hello_test /dev/xyz 123

可以看到不输入123时只进行读操作，输入123时就开始写操作，是由argc==3判断的

5.注意事项

  1. bear make //bear命令用来生成compile_commands.json,它会记录make过程编译文件时用到的命令。如果之前曾经编译过内核，要用make clearn清除掉,然后bear make zImage -j 4重新编译,编译成功后就会在当前目录下得到文件compile_commands.json。然后将里面的cc全部替换为arm-buildroot-linux-gnueabihf-gcc。在这个文档里可以看到引用的头文件。

二.hello驱动程序实验改进

1.基础知识

①APP和驱动的交互方式
  1. app和驱动之间通过copy_to _user和copy_from_user传递数据
  2. 驱动程序和硬件之间可以通过使用原始函数或者直接通过ioremap去映射寄存器地址后，直接访问寄存器
②APP使用驱动的四种方式

驱动程序：提供能力，不提供策略

  1. 非阻塞（查询）：不会等待，有就是有没有就是没有，该实验代码就是非阻塞
  2. 阻塞（休眠-唤醒）：等待有数据
  3. poll（定个闹钟）：唤醒条件a时间到；b发生了中断
  4. 异步通知
③中断

2.修改代码

①读取和存入数据
static unsigned char hello_buf[100];//先定义一个内核空间
static ssize_t hello_read(struct file *filp, char __user *buf, size_t size, loff_t *offset){
	unsigned long len=size>100?100:size;
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏	
	copy_to_user(buf,hello_buf,len);//从内核空间读到用户空间
	return len;
	};
static ssize_t  hello_write(struct file *flip, const char __user *buf, size_t size, loff_t *offset){
	copy_from_user(hello_buf,buf,len)；//从用户空间写到内核空间
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return len;
	};
②class和device讲解

先定义一个全局变量

static struct class *hello_class;

再进行创建，记得销毁

static int  hello_init(void)
{
	major=register_chrdev(0,"hello",&hello_drv);
	hello_class=class_create(THIS_MODULE,"hellonihao");
		if(IS_ERR(hello_class)){
			printk("failed\n");
			return PTR_ERR(hello_class);
		}
	device_create(hello_class,NULL,MKDEV(major,0),NULL,"hello");//创建一个设备节点，名字为hello，与类的名字没有关系
	return 0;
}
static void  hello_exit(void)
{
	device_destroy(hello_class,MKDEV(major,0));
	class_destroy(hello_class);//创建完还要销毁
	unregister_chrdev(major,"hello");
}

class和device这两个函数，实际上是在sys文件架下创建了虚拟节点

240和0为主设备号和次设备号，系统后台程序根据信息生成设备节点，即生成/dev/hello

3.完整代码

①hello_drv.c
#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>
#include <linux/uaccess.h>
#include <linux/module.h>
static int major;
static unsigned char hello_buf[100];
static struct class *hello_class;
static int hello_open(struct inode *node, struct file *filp){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return 0;
};
static ssize_t hello_read(struct file *filp, char __user *buf, size_t size, loff_t *offset){
	unsigned long len=size>100?100:size;
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏copy_to_user(buf,hello_buf,len);
	copy_to_user(buf,hello_buf,len);
	return len;
	};
static ssize_t  hello_write(struct file *flip, const char __user *buf, size_t size, loff_t *offset){
	unsigned long len=size>100?100:size;
	copy_from_user(hello_buf,buf,len);
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return len;
	};
static int hello_release (struct inode *node, struct file *filp){
	printk("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);//使用宏
	return 0;
	};
//1.构造operations结构体
static const struct file_operations hello_drv = {
	.owner=THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
	.release	= hello_release,
};
//2.resister_ chrdev
//3.入口
static int  hello_init(void)
{
	major=register_chrdev(0,"hello",&hello_drv);
	hello_class=class_create(THIS_MODULE,"hello");
		if(IS_ERR(hello_class)){
			printk("failed\n");
			return PTR_ERR(hello_class);
		}
	device_create(hello_class,NULL,MKDEV(major,0),NULL,"hello");
	return 0;
}
//4.出口
static void  hello_exit(void)
{
	device_destroy(hello_class,MKDEV(major,0));
	class_destroy(hello_class);
	unregister_chrdev(major,"hello");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
②hello_test.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
int fd;
int len;
char buf[100];
int main(int argc,char**argv){
    if(argc<2){
        printf("Usage:\n");
        printf("%s <dev> [string]\n",argv[0]);   //<>biaoshibunengshenglue    []biaoshikeyishenglue
        return -1;
    }
//open
fd=open(argv[1],O_RDWR);
if(fd<0){
    printf("cannot open file %s\n",argv[0]);
    return -1;
}
//write
if(argc==3){
    len=write(fd,argv[2],strlen(argv[2])+1);
    printf("write ret=%d\n",len);
}
else{
//read
    len=read(fd,buf,100);
    buf[99]='\0';
    printf("read str:%s\n",buf);
}
//close
    close(fd);
    return 0;
    }

makefile不变

4.最终结果

在这里插入图片描述

三.字符设备的另一种注册方式

按上述注册的话，一次注册一个主设备号，最多只有255个，一个设备霸占一个主设备号的所有次设备号，所以可以改进，但是没有很大的必要。一般还是使用register_chrdev。
先申请一个主次设备号的空间，然后初始化cdev，与file_operations挂钩，然后再添加cdev

static struct cdev hello_cdev;
static dev_t dev;//先定义一个结构体
static int  hello_init(void)
{
	int ret;
	ret = alloc_chrdev_region(&dev, 0, 1, "hello");//申请一个区域。次设备号从0开始，获得一个次设备号
	cdev_init(&hello_cdev,&hello_drv);
	ret=cdev_add(&hello_cdev,dev,1);
	if(ret){
	return -1;
}
	if (ret < 0) {
		printk(KERN_ERR "alloc_chrdev_region() failed for hello\n");
		return -1;
	}
	hello_class=class_create(THIS_MODULE,"hello");
		if(IS_ERR(hello_class)){
			printk("failed\n");
			return PTR_ERR(hello_class);
		}
	device_create(hello_class,NULL,dev,NULL,"hello");
	return 0;
}
//出口也要删除掉cdev
static void  hello_exit(void)
{
	device_destroy(hello_class,dev);
	class_destroy(hello_class);
	cdev_del(&hello_cdev);
	unregister_chrdev_region(dev,1);//释放申请的区域，一个
}

代码注意修改部分，MKDEV(major,0)改为了dev，一次只申请了一个，如果选哟申请多个子设备号，需将1改为2。

Leweellll
关注
  • 28
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Linux设备驱动开发学习笔记（上）
02-09
在系统学习Linux的过程中的，Linux设备驱动开发学习的笔记，笔记有两部分，这是上篇，主要学习内容是《Linux设备驱动开发》的1-4章，其中第4章是重点。
Linux设备驱动开发学习笔记（下）
02-16
在系统学习Linux的过程中的，Linux设备驱动开发学习的笔记，笔记有两部分，这是下篇，主要学习内容是《Linux设备驱动开发详解》的7-9章。
Linux驱动开发学习笔记-驱动开发基础知识
weixin_45593094的博客
06-02 1414
《原子Linux开发》1. 字符设备开发基础知识：1)字符设备：就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。 比如常见的点灯，按键，IIC，SPI，LCD等都是字符设备。2)Linux中一切皆文件，驱动加载成功后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx是具体驱动文件名)进行 相应操作即可实现对硬件的操作。3)应用程序运行在用户空间，驱动运行于内核空间，用户空间不能直接对内核进行操作，因此必须使用“系统调用”的方式
最全Linux驱动开发全流程详细解析（持续更新）
热门推荐
拉依达不拉跨的博客
02-19 4万+
Linux驱动开发详细解析
Linux驱动开发学习笔记
Wakabaka101的博客
02-07 2938
观看正点原子Linux驱动开发教程的学习笔记
Linux驱动开发笔记（零）驱动基础知识及准备
sincerelover的博客
04-19 1841
在简单结束应用层的开发学习后，本系列将开启驱动层的学习，本文作为该系列第一期旨在归纳前期需要准备的知识。Linux内核模块是Linux内核向外部提供的一个插口，也被称为动态可加载内核模块（Loadable Kernel Module，LKM）。它是一个具有独立功能的程序，可以被单独编译，但不能独立运行。在运行时，内核模块被链接到内核作为内核的一部分在内核空间运行。内核模块的主要作用是扩展内核的功能，而无需重新编译整个内核。例如，内核模块通常用于添加新的设备驱动程序、文件系统或其他功能到内核中。
【嵌入式Linux学习笔记】Linux驱动开发
weixin_45728705的博客
03-14 2520
嵌入式Linux学习笔记
(零)Linux驱动开发学习
zhuxc_001的博客
01-08 164
该系列文章记录了我学习Linux驱动开发的过程。
Linux开发（驱动&应用）学习
嵌入式学习记录站点
10-28 7535
Linux开发（驱动&应用）学习路线规划
基于VSCODE配置linux驱动开发环境笔记
u012736362的博客
06-26 2202
在驱动开发领域，Source Insight是一个常用的商业代码编辑器，它提供了一些方便的功能，如代码浏览、函数跳转等。然而，由于Source Insight需要付费，并且在函数跳转等方面存在一些不便之处，因此一些开发者选择使用Visual Studio Code（简称VSCODE）作为驱动开发的替代工具。Visual Studio Code是一个开源、跨平台的代码编辑器，具有丰富的插件生态系统和强大的功能，可以提供类似Source Insight的功能，并且免费使用。
Linux驱动学习笔记1-学习路径
Follow excellent, success will chase you !
05-07 310
准备切入Linux驱动学习，购买了正点原子 “i.MX6ULL Linux阿尔法开发板”，下载了学习资料。接下来准备是利用6-12月的时间将开发板的例程学完。第三篇：Uboot、Linux 和根文件系统移植。第一篇：Ubuntu 操作系统入门。第四篇： Linux 驱动开发。第二篇： ARM 裸机开发。
LINUX驱动开发学习笔记---ARM汇编基础
weixin_42542969的博客
11-10 1415
最近在学习LINUX驱动开发，记录一下。带着问题来学习，方便以后查阅巩固。 一、ARM汇编基础 Q: linux驱动开发为什么需要汇编？ A: 因为 Cortex-A芯片一上电 SP指针还没初始化， C环境还没准备好，所以肯定不能运行 C代码，必须先用汇编语言设置好 C环境，比如初始化 DDR、设置 SP指针等等，当汇编把 C环境设置好了以后才可以运行 C代码。所以 Cortex-A一开始肯定是汇编代码，其实 STM32也一样的，一开始也是汇编，以 STM32F103为例，启动文件sta
linux驱动开发学习笔记.pdf
08-17
以上就是Linux驱动开发学习笔记中提及的各个知识点，详细讲解了Linux驱动开发的基础知识和核心概念。每个知识点都与具体的Linux内核机制和编程实践紧密结合，是学习Linux内核驱动开发人员的宝贵资料。
linux驱动开发学习笔记十一：初识设备树
01-06
一、什么是设备树？...关键是这些板级信息文件还都是.c 或.h 文件，它们都会被编译进 Linux 内核中，导致 Linux 内核“虚胖”。因此为了解决这个问题，引入设备树。 设备树(Device Tree)，将这个词分开就是“设备
linux驱动开发文档笔记
01-22
Linux 驱动开发文档笔记 Linux 驱动开发是 Linux 操作系统中的一种核心技术，它使得开发者可以创建自己的驱动程序，以控制和管理硬件设备。在 Linux 驱动开发中，需要掌握一些基本的数据结构和处理函数，本文将对...
[Linux]在Ubuntu中安装samba并且正确配置（详细）
c858845275的博客
08-23 1052
讲述了samba的安装配置与连接以及最基本的错误解决办法。
Linux基础知识（一、什么是Linux）
最新发布
心寒的博客
08-26 614
什么是Linux Linux创始人
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 1095
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
Linux 线程的控制 互斥与同步
qq_63145217的博客
08-23 928
include //头文件sem_t sem;信号量的类型 信号量的变量。
Linux驱动开发学习笔记与资源汇总
"这是一份全面的Linux编程学习资料，涵盖了从驱动开发到应用程序的多个层面，适合有志于深入Linux技术的开发者。" 在Linux编程领域，这份资料提供了丰富的知识，包括驱动开发、嵌入式网络编程以及高级系统编程等...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值