3. 字符设备驱动---上篇

最新推荐文章于 2024-09-20 09:10:41 发布
最新推荐文章于 2024-09-20 09:10:41 发布
阅读量402 收藏 1
点赞数
分类专栏： linux--驱动开发 文章标签： linux 驱动开发 字符设备驱动 动态映射与静态映射 字符驱动开发框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43379278/article/details/129303083
版权
本文详细介绍了Linux字符设备驱动的工作原理，包括系统整体工作流程、字符驱动模型、注册字符设备驱动的过程，以及如何通过file_operations结构体实现驱动功能。文章还提供了驱动代码实践，展示了如何编写驱动的open、read、write等函数，并讨论了应用程序如何调用驱动，以及驱动中如何操控硬件，包括静态和动态地址映射的方法。最后，文章通过示例讲解了如何使用静态映射操作LED。
摘要由CSDN通过智能技术生成

文章目录

本文用于复习字符设备驱动知识，从目前的认知层面进行整理，如有不足，恳请大家指出，一起沟通交流，以博会友。
注： Kernel-4.19内核代码阅读网站

引言

在Linux文件系统中，需要了解以下几点：

  • 每个文件都用一个struct inode结构体来描述，该结构体记录了这个文件的所有信息，例如文件类型，访问权限等。
  • 每个驱动程序在应用层的/dev目录或者其他如/sys目录下都会有一个文件与之对应。
  • 每打开一次文件，Linux操作系统会在VFS层分配一个struct file结构体来描述打开的文件。
  • 每个驱动程序都有一个设备号。（用在众多的设备驱动中进行区分）
  • 用户必须知道设备驱动对应的设备节点(设备文件)
  • linux把所有到设备都看成文件

一、字符设备驱动工作原理

1.1 系统整体工作原理

(1) 应用层 -> API -> 设备驱动 -> 硬件
(2) API：open、read、write、close等
(3) 驱动源码中提供真正的open、read、write、close等函数实体

1.2 字符驱动模型

在这里插入图片描述

1.2.1 file_operations结构体

kernel-4.19/include/linux/fs.h

struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
	int (*iterate) (struct file *, struct dir_context *);
	int (*iterate_shared) (struct file *, struct dir_context *);
	__poll_t (*poll) (struct file *, struct poll_table_struct *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	unsigned long mmap_supported_flags;
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, loff_t, loff_t, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
    ......
#ifndef CONFIG_MMU
	unsigned (*mmap_capabilities)(struct file *);
#endif
	ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
			loff_t, size_t, unsigned int);
	int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
			u64);
	int (*dedupe_file_range)(struct file *, loff_t, struct file *, loff_t,
			u64);
	int (*fadvise)(struct file *, loff_t, loff_t, int);
} __randomize_layout;

(1) 成员主要是函数指针，用来连接实体函数地址
(2) 每个设备驱动都需要一个该结构体类型的变量
(3) 设备驱动向内核注册时提供该结构体类型的变量

1.2.2 注册字符设备驱动 — 申请主设备号

kernel-4.19/include/linux/fs.h

/* 
* 函数作用： 驱动向内核注册函数register_chrdev()
* 返回值 : int	返回0表示注册成功，返回一个负整数表示注册失败
* 参数 :	
* unsigned int major	主设备号(1~255)，可人为向内核申请，不能与已有的设备号重复。(如果等于0，则采用系统动态分配的主设备号；不为0，则表示静态注册)
* const char *name	输入型参数，表示驱动设备的名字
* const struct file_operations *fops	输入型参数，用于内核注册的结构体指针
*/
static inline int register_chrdev(unsigned int major, const char *name,
				  const struct file_operations *fops)--------------------------------驱动向内核注册自己的file_operations
{
	return __register_chrdev(major, 0, 256, name, fops);
}

static inline 关键字修饰的函数，大部分表现和普通的static关键字修饰的函数一样。只不过在调用static inline 修饰的函数时，gcc会在其调用处，将其汇编码展开编译，而不为这个函数生成独立的汇编码，可以减少开销。（inline 减少函数调用开销）

1.2.3 内核如何管理字符设备驱动

(1) 内核中有一个数组（最多有256个元素）用来存储注册的字符设备驱动，数组下标跟主设备号有关系
(2) register_chrdev() 内部将要注册的驱动信息存储在数组中相应的位置
(3) cat /proc/devices 查看内核中已经注册过的字符设备驱动和块设备驱动在这里插入图片描述

二、字符设备驱动代码实践

2.1 编写字符设备驱动的步骤和规范

    步骤：
        1，实现模块加载和卸载入口函数
                module_init(chr_dev_init);
                module_exit(chr_dev_exit);
        
        2，在模块加载入口函数中
            a， 申请主设备号  (内核中用于区分和管理不同字符设备)
                     register_chrdev(dev_major, "chr_dev_test", &my_fops);

            b，创建设备节点文件 (为用户提供一个可操作到文件接口--open())
                    struct  class *class_create(THIS_MODULE, "chr_cls");
                    struct  device *device_create(devcls, NULL, MKDEV(dev_major, 0), NULL, "chr2");

            c,  硬件的初始化
                   1，地址的映射
                        gpx2conf = ioremap(GPX2_CON, GPX2_SIZE);
                   2，中断的申请
                   3，实现硬件的寄存器到初始化
                        // 需要配置gpio功能为输出
                        *gpx2conf &= ~(0xf<<28);
                        *gpx2conf |= (0x1<<28);
            d，实现file_operations ---------   核心工作量：file_operations及其元素填充、注册驱动
                    const struct file_operations my_fops = {
                            .open = chr_drv_open,
                            .read = chr_drv_read,
                            .write = chr_drv_write,
                            .release = chr_drv_close,
                    };

由上面的步骤可以看出，驱动开发是有一定的思路和框架的。说到底，就是给空模块添加驱动壳子，再具体实现功能细节。

2.2 实践写驱动代码

脑海里先有框架，要知道目标是什么。
细节代码不需要一个字一个字敲，可以到内核中去寻找参考代码复制过来改。
写下的所有代码必须心里清楚明白，不能似懂非懂。

(1) 定义file_operations结构体变量
在这里插入图片描述
(2) open和close函数原型确定、内容填充
在这里插入图片描述
(3) 注册驱动

  • 主设备号的选择 (cat /proc/devices 查看当前可用的主设备号，确定没用过的先随便定一个)
  • 返回值的检查

在这里插入图片描述
(4) 卸载驱动

在这里插入图片描述

2.3 代码实现

#include <linux/module.h>		// module_init  module_exit
#include <linux/init.h>			// __init   __exit
#include <linux/fs.h>           // 记得包含头文件<linux/fs.h>

#define MYMAJOR		200
#define MYNAME		"testchar"
int mymajor;

static int test_chrdev_open(struct inode *inode, struct file *file)
{
	// 这个函数中真正应该放置的是打开这个设备的硬件操作代码部分
	// 但是现在暂时我们写不了这么多，所以用一个printk打印个信息来做代表。
	printk(KERN_INFO "test_chrdev_open\n");
	
	return 0;
}

static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release\n");
	return 0;
}

// 自定义一个file_operations结构体变量，并且去填充
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,				// 惯例，直接写即可
	
	.open		= test_chrdev_open,			// 将来应用open打开这个设备时实际调用的
	.release	= test_chrdev_release,		// 就是这个.open对应的函数
};

// 模块安装函数
static int __init chrdev_init(void)
{	
	printk(KERN_INFO "chrdev_init helloworld init\n");

	// 在module_init宏调用的函数中去注册字符设备驱动
	// major传0进去表示要让内核帮我们自动分配一个合适的空白的没被使用的主设备号
	// 内核如果成功分配就会返回分配的主设备好；如果分配失败会返回负数
	mymajor = register_chrdev(0, MYNAME, &test_fops);
	if (mymajor < 0)
	{
		printk(KERN_ERR "register_chrdev fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "register_chrdev success... mymajor = %d.\n", mymajor);

	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit helloworld exit\n");
	
	// 在module_exit宏调用的函数中去注销字符设备驱动
	unregister_chrdev(mymajor, MYNAME);
	
}

module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("aston");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			// 描述模块的别名信息

2.4 驱动测试

(1) 编译等 make && make cp
(2) insmod 查看设备注册的现象
(3) rmmod 查看设备注销的现象
在这里插入图片描述

三、应用程序如何调用驱动

3.1 驱动设备文件的创建

  1. 手动创建–缺点/dev/目录中文件都是在内存中，断电后/dev/文件就会消失
1）设备文件的关键信息是：设备号 = 主设备号 + 次设备号，使用ls -l去查看设备文件，就可以得到这个设备文件对应的主次设备号。
2）使用mknod创建设备文件：mknod  /dev/xxx c 主设备号 次设备号

在这里插入图片描述

  1. 自动创建（通过udev/mdev机制）
struct class *class_create()  // 创建一个类
struct device *device_create() // 创建一个设备文件

3.2 添加读写接口

（1） 在驱动代码中添加（注意截图代码注释）
在这里插入图片描述
（2）在应用代码中添加

	write(fd, "helloworld2222", 14);
	read(fd, buf, 100);

3.3 应用和驱动之间的数据交换

(1) copy_from_user，用来将数据从用户空间复制到内核空间。
(2) copy_to_user，用来将数据从内核空间复制到用户空间。

kernel-4.19/include/linux/uaccess.h

static __always_inline unsigned long __must_check
copy_from_user(void *to, const void __user *from, unsigned long n)
{
	if (likely(check_copy_size(to, n, false)))
		n = _copy_from_user(to, from, n);
	return n;
}

static __always_inline unsigned long __must_check
copy_to_user(void __user *to, const void *from, unsigned long n)
{
	if (likely(check_copy_size(from, n, true)))
		n = _copy_to_user(to, from, n);
	return n;
}

注意：

  1. copy_from_user函数的返回值定义，和常规有点不同。返回值如果成功复制则返回0，如果复制失败，则返回没有成功复制剩下的字节数。
  2. linux在系统调用进入内核时，为什么要将参数从用户空间拷贝到内核空间？不能直接访问，或使用memcpy吗？非要使用copy_from_user才行吗？
      原因是cpu运行指令时，运行级别分为用户态和数据态，这样可以避免内核数据被污染。

3.4 读写接口实践

（1）完成write和read函数
在这里插入图片描述
在这里插入图片描述
（2）读写回环测试

	// 读写文件
	write(fd, "helloworld2222", 14);
	read(fd, buf, 100);
	printf("读出来的内容是：%s.\n", buf);

3.5 代码实现

(1)目前为止应用已经能够读写驱动中的
(2)后续工作：添加硬件操作代码

3.5.1 驱动源码

#include <linux/module.h>		// module_init  module_exit
#include <linux/init.h>			// __init   __exit
#include <linux/fs.h>
#include <asm/uaccess.h>

#define MYMAJOR		200
#define MYNAME		"testchar"

int mymajor;

char kbuf[100];			// 内核空间的buf

static int test_chrdev_open(struct inode *inode, struct file *file)
{
	// 这个函数中真正应该放置的是打开这个设备的硬件操作代码部分
	// 但是现在暂时我们写不了这么多，所以用一个printk打印个信息来做代表。
	printk(KERN_INFO "test_chrdev_open\n");
	
	return 0;
}

static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release\n");
	
	return 0;
}

ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_read\n");
	
	ret = copy_to_user(ubuf, kbuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_to_user fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "copy_to_user success..\n");
		
	return 0;
}

// 写函数的本质就是将应用层传递过来的数据先复制到内核中，然后将之以正确的方式写入硬件完成操作。
static ssize_t test_chrdev_write(struct file *file, const char __user *ubuf,
	size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_write\n");

	// 使用该函数将应用层传过来的ubuf中的内容拷贝到驱动空间中的一个buf中
	//memcpy(kbuf, ubuf);		// 不行，因为2个不在一个地址空间中
	ret = copy_from_user(kbuf, ubuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_from_user fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "copy_from_user success..\n");

	// 真正的驱动中，数据从应用层复制到驱动中后，我们就要根据这个数据
	// 去写硬件完成硬件的操作。所以这下面就应该是操作硬件的代码
	
	return 0;
}


// 自定义一个file_operations结构体变量，并且去填充
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,				// 惯例，直接写即可
	
	.open		= test_chrdev_open,			// 将来应用open打开这个设备时实际调用的
	.release	= test_chrdev_release,		// 就是这个.open对应的函数
	.write 		= test_chrdev_write,
	.read		= test_chrdev_read,
};


// 模块安装函数
static int __init chrdev_init(void)
{	
	printk(KERN_INFO "chrdev_init helloworld init\n");

	// 在module_init宏调用的函数中去注册字符设备驱动
	// major传0进去表示要让内核帮我们自动分配一个合适的空白的没被使用的主设备号
	// 内核如果成功分配就会返回分配的主设备好；如果分配失败会返回负数
	mymajor = register_chrdev(0, MYNAME, &test_fops);
	if (mymajor < 0)
	{
		printk(KERN_ERR "register_chrdev fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "register_chrdev success... mymajor = %d.\n", mymajor);

	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit helloworld exit\n");
	
	// 在module_exit宏调用的函数中去注销字符设备驱动
	unregister_chrdev(mymajor, MYNAME);
	
}

module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("aston");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			    // 描述模块的别名信息

3.5.2 应用层源码

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


#define FILE	"/dev/test"			// 刚才mknod创建的设备文件名

char buf[100];

int main(void)
{
	int fd = -1;
	
	fd = open(FILE, O_RDWR);
	if (fd < 0)
	{
		printf("open %s error.\n", FILE);
		return -1;
	}
	printf("open %s success..\n", FILE);
	
	// 读写文件
	write(fd, "helloworld2222", 14);
	read(fd, buf, 100);
	printf("读出来的内容是：%s.\n", buf);
	
	// 关闭文件
	close(fd);
	
	return 0;
}

3.5.3 Makefile

#ubuntu的内核源码树，如果要编译在ubuntu中安装的模块就打开这2个
#KERN_VER = $(shell uname -r)
#KERN_DIR = /lib/modules/$(KERN_VER)/build	
		
#开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel

obj-m	+= module_test.o

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	arm-linux-gcc app.c -o app

cp:
	cp *.ko /x210_porting/rootfs/rootfs/driver_test
	cp app /x210_porting/rootfs/rootfs/driver_test
	
.PHONY: clean	
clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf app

3.6 测试结果

在这里插入图片描述

四、驱动中如何操控硬件

4.1 硬件物理原理不变

  • 硬件操作接口（寄存器）不变
  • 硬件操作代码不变

4.2 寄存器地址、编程方法改变

  • 寄存器地址不同。原来是直接用物理地址，现在需要用该物理地址在内核虚拟地址空间相对应的虚拟地址。寄存器的物理地址是CPU设计时决定的，从datasheet中查找到的。
  • 编程方法不同。裸机中习惯直接用指针操作寄存器地址，而kernel中习惯用封装好的io读写函数来操作寄存器，以实现最大程度可移植性。

4.3 内核的虚拟地址映射方法

4.3.1 为什么需要虚拟地址映射

更好维护，可移植。因为虚拟地址映射能够解决安全隐患、地址不确定问题，并缓解了效率的问题。
所谓虚拟地址映射就是从虚拟地址映射到物理地址，经由MMU内存管理单元映射到实际的物理地址。
注: 硬件 --> 物理地址(寄存器) --> MMU (MMU是实际管理内存的硬件) --> 虚拟地址 --> 驱动程序

4.3.2 内核中有2套虚拟地址映射方法

动态和静态

  • 静态映射方法的特点
      内核移植时以代码的形式硬编码（实质就是宏定义），如果要更改必须改源代码后重新编译内核。
    在内核启动时建立静态映射表，到内核关机时销毁，中间一直有效；
    对于移植好的内核，你用不用他都在那里。
  • 动态映射方法的特点
      驱动程序根据需要随时动态的建立映射、使用、销毁映射，映射是短期临时的。

4.4 如何选择虚拟地址映射方法

  • 2种映射并不排斥，可以同时使用
  • 静态映射类似于C语言中全局变量，动态方式类似于C语言中malloc堆内存
  • 静态映射的好处是执行效率高，坏处是始终占用虚拟地址空间；动态映射的好处是按需使用虚拟地址空间，坏处是每次使用前后都需要代码去建立映射&销毁映射（还得学会使用那些内核函数的使用）

4.5 操作寄存器地址的方式

在这里插入图片描述

   0,     
		led-- GPX2_7 —GPX2CON == 0x1100C40----------------gpio的输出功能配置寄存器
		GPX2DAT == 0x1100C44---------------------------------------数据寄存器
		将0x11000C40映射成虚拟地址
		对虚拟地址中的[31:28] = 0x1
    1， volatile unsigned long *gpxcon;
        *gpxcon &= ~(0xf<<28);
    
    2, readl/writel();
        u32 readl(const volatile void __iomem *addr)//从地址中读取地址空间的值
        void writel(unsigned long value , const volatile void __iomem *add) // 将value的值写入到addr地址
    
        例子：
            // gpio的输出功能配置寄存器
            u32 value = readl(led_dev->reg_virt_base);
            value &= ~(0xf<<28);
            value |= (0x1<<28)
            writel(value, led_dev->reg_virt_bas);    

        或者：
                *gpx2dat |= (1<<7);    // 数据寄存器
        替换成：
                writel( readl(led_dev->reg_virt_base + 4) | (1<<7),   led_dev->reg_virt_base + 4 );  // 操作地址时，+1 与+4的区别是因为数据类型不同。

五、静态映射操作LED

  1. 关于静态映射
  • 不同版本内核中静态映射表位置、文件名可能不同
  • 不同SoC的静态映射表位置、文件名可能不同
  • 所谓映射表其实就是头文件中的宏定义
  1. 三星版本内核中的静态映射表
    (1) 主映射表位于：arch/arm/plat-s5p/include/plat/map-s5p.h
      CPU在安排寄存器地址时不是随意乱序分布的，而是按照模块去区分的。每一个模块内部的很多个寄存器的地址是连续的。所以内核在定义寄存器地址时都是先找到基地址，然后再用基地址+偏移量来寻找具体的一个寄存器。
      map-s5p.h中定义的就是要用到的几个模块的寄存器基地址（并不全）。定义的是模块的寄存器基地址的虚拟地址。
    (2)虚拟地址基地址定义在：arch/arm/plat-samsung/include/plat/map-base.h
#define S3C_ADDR_BASE (0xFD000000) // 三星移植时确定的静态映射表的基地址，表中的所有虚拟地址都是以这个地址+偏移量来指定

  (3) GPIO相关的主映射表位于：arch/arm/mach-s5pv210/include/mach/regs-gpio.h
  表中是GPIO的各个端口的基地址的定义
  (4) GPIO的具体寄存器定义位于：arch/arm/mach-s5pv210/include/mach/gpio-bank.h
它们的层级关系如下：
在这里插入图片描述

  1. 裸机中的操作方法添加LED操作代码
    在这里插入图片描述
  2. 添加驱动中的写函数
  • 先定义好应用和用户之间的控制接口，这个是由自己来定义的。譬如定义为：应用向驱动写"on"则驱动让LED亮，应用向驱动写"off"，驱动就让LED灭，应用向驱动写"flash"则驱动让LED闪烁。
  • 应用和驱动的接口定义做的尽量简单，譬如用1个字目来表示。譬如定义为：应用写"1"表示灯亮，写"0"表示让灯灭。
    注：应用层一般用来满足用户需求，写更多的功能函数；驱动层一般只简单实现硬件的功能，比如控制LED的亮灭。
简言之, 上层玩策略，底层玩机制。
  1. 写应用来测试写函数
  2. 驱动和应用中来添加读功能
    注：内核中也有自己的memset()和strcmp(); 函数用法跟应用层一样，在驱动中使用时要包含头文件#include <linux/string.h>

5.1 应用层app源代码

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

#define FILE	"/dev/test"			// 刚才mknod创建的设备文件名

char buf[100];

int main(void)
{
	int fd = -1;
	int i = 0;
	fd = open(FILE, O_RDWR);
	if (fd < 0)
	{
		printf("open %s error.\n", FILE);
		return -1;
	}
	printf("open %s success..\n", FILE);

	while (1)
	{
		memset(buf, 0 , sizeof(buf));
		printf("请输入 on | off \n");
		scanf("%s", buf);
		if (!strcmp(buf, "on"))
		{
			write(fd, "1", 1);
		}
		else if (!strcmp(buf, "off"))
		{
			write(fd, "0", 1);
		}
		else if (!strcmp(buf, "flash"))
		{
			for (i=0; i<3; i++)
			{
				write(fd, "1", 1);
				sleep(1);
				write(fd, "0", 1);
				sleep(1);
			}
		}	
		else if (!strcmp(buf, "quit"))
		{
			break;
		}
	}
	
	// 关闭文件
	close(fd);
	
	return 0;
}

5.2 驱动源代码

#include <linux/module.h>		// module_init  module_exit
#include <linux/init.h>			// __init   __exit
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>		// arch/arm/mach-s5pv210/include/mach/gpio-bank.h
#include <linux/string.h>

#define MYMAJOR		200
#define MYNAME		"testchar"

#define GPJ0CON		S5PV210_GPJ0CON
#define GPJ0DAT		S5PV210_GPJ0DAT
#define rGPJ0CON	*((volatile unsigned int *)GPJ0CON)
#define rGPJ0DAT	*((volatile unsigned int *)GPJ0DAT)

int mymajor;
char kbuf[100];			// 内核空间的buf

static int test_chrdev_open(struct inode *inode, struct file *file)
{
	// 这个函数中真正应该放置的是打开这个设备的硬件操作代码部分
	// 但是现在暂时我们写不了这么多，所以用一个printk打印个信息来做代表。
	printk(KERN_INFO "test_chrdev_open\n");
	
	rGPJ0CON = 0x11111111;
	rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));		// 亮
	
	return 0;
}

static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release\n");
	rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
	
	return 0;
}

ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_read\n");
	
	ret = copy_to_user(ubuf, kbuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_to_user fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "copy_to_user success..\n");
	
	return 0;
}

// 写函数的本质就是将应用层传递过来的数据先复制到内核中，然后将之以正确的方式写入硬件完成操作。
static ssize_t test_chrdev_write(struct file *file, const char __user *ubuf,
	size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_write\n");

	// 使用该函数将应用层传过来的ubuf中的内容拷贝到驱动空间中的一个buf中
	//memcpy(kbuf, ubuf);		// 不行，因为2个不在一个地址空间中
	memset(kbuf, 0, sizeof(kbuf));
	ret = copy_from_user(kbuf, ubuf, count);
	if (ret)
	{
		printk(KERN_ERR "copy_from_user fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "copy_from_user success..\n");
	
	if (kbuf[0] == '1')
	{
		rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));
	}
	else if (kbuf[0] == '0')
	{
		rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
	}
		
	return 0;
}


// 自定义一个file_operations结构体变量，并且去填充
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,				// 惯例，直接写即可
	
	.open		= test_chrdev_open,			// 将来应用open打开这个设备时实际调用的
	.release	= test_chrdev_release,		// 就是这个.open对应的函数
	.write 		= test_chrdev_write,
	.read		= test_chrdev_read,
};


// 模块安装函数
static int __init chrdev_init(void)
{	
	printk(KERN_INFO "chrdev_init helloworld init\n");

	// 在module_init宏调用的函数中去注册字符设备驱动
	// major传0进去表示要让内核帮我们自动分配一个合适的，空白的，没被使用的主设备号
	// 内核如果成功分配就会返回分配的主设备号；如果分配失败会返回负数
	mymajor = register_chrdev(0, MYNAME, &test_fops);
	if (mymajor < 0)
	{
		printk(KERN_ERR "register_chrdev fail\n");
		return -EINVAL;
	}
	printk(KERN_INFO "register_chrdev success... mymajor = %d.\n", mymajor);
	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit helloworld exit\n");	
	
	// 在module_exit宏调用的函数中去注销字符设备驱动
	unregister_chrdev(mymajor, MYNAME);
}

module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("aston");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			// 描述模块的别名信息

六、动态映射操作LED

6.1 如何建立动态映射

(1) request_mem_region，向内核申请（报告）需要映射的内存资源。
(2) ioremap，真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址

6.2 如何销毁动态映射

(1) iounmap ，解除映射
(2) release_mem_region，申请释放
注意：映射建立时，是要先申请再映射；然后使用；使用完要解除映射时要先解除映射再释放申请。

6.3 代码实践

(1) 2个寄存器分开独立映射
在这里插入图片描述
(2) 多个寄存器在一起映射
在这里插入图片描述

七、总结

常常认为，struct inode描述的是文件的静态信息，即这些信息很少会改变，而struct file描述的是动态信息，即对文件的操作的时候，struct file里面的信息经常会发生变化。典型的是struct file结构体里面的f_ops(记录当前文件的位移量)，每次读写一个普通文件时f_ops的值都会发生改变。此处借用kavin.zhu大佬制作的图，就不重复造轮子了。
在这里插入图片描述
从上图可以知道，如果想访问底层设备，就必须打开对应的设备文件。也就是在这个打开的过程中，Linux内核将应用层和对应的驱动程序关联起来。

(1) open()函数打开设备文件时，根据设备文件对应的struct inode结构体描述的信息，可以知道接下来要操作的设备类型（字符设备还是块设备），还会分配一个struct file结构体。

kernel-4.19/include/linux/fs.h

struct inode {
	umode_t			i_mode;-------------------- 记录设备类型
	unsigned short		i_opflags;
	kuid_t			i_uid;
	kgid_t			i_gid;
	unsigned int		i_flags;

	dev_t			i_rdev;  ------------------------------- 记录设备号
	loff_t			i_size;

	/* Misc */
	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
	struct file_lock_context	*i_flctx;
	struct address_space	i_data;
	struct list_head	i_devices;
	union {
		struct pipe_inode_info	*i_pipe;
		struct block_device	*i_bdev;
		struct cdev		*i_cdev; ----------------------------记录描述字符设备的结构体
		char			*i_link;
		unsigned		i_dir_seq;
	};

	__u32			i_generation;

	void			*i_private; /* fs or device private pointer */
}

struct file {
    ...
	struct path		f_path;
	struct inode		*f_inode;	/* cached value */
	const struct file_operations	*f_op;
	......
}

(2) 根据struct inode结构体里面记录的设备号，可以找到对应的驱动程序。这里以字符设备为例。在Linux操作系统中每个字符设备都有一个struct cdev结构体。此结构体描述了字符设备所有信息，其中最重要的一项就是字符设备的操作函数接口。
(3) 找到struct cdev结构体后，linux内核就会将struct cdev结构体所在的内存空间首地址记录在struct inode结构体的i_cdev成员中，将struct cdev结构体中的函数操作接口地址记录在struct file结构体的f_ops成员中。
(4) 任务完成，VFS层会给应用返回一个文件描述符（fd）。这个fd是和struct file结构体对应的。接下来上层应用程序就可以通过fd找到struct file，然后在有struct file找到操作字符设备的函数接口了。

注：大部分接口都是成对使用的，比如 : register_chrdev与unregister_chrdev。类似的学习博文

附

KERN_ERR、PTR_ERR 与 IS_ERR接口在编写驱动中的应用。

if(IS_ERR(led_dev->dev))
{
	printk(KERN_ERR "device_create error\n");  // KERN_ERR 
	ret = PTR_ERR(led_dev->dev);  //将指针出错的具体原因转换成一个出错码
	goto err_2;
}
多维不语
关注
专栏目录
u-boot-2012.04.01.tar.zip_u-boot-2012.04.01
09-24
3. **drivers**：包含了对各种设备驱动的支持，如网络控制器、存储设备等。 4. **lib**：提供了一些通用的库函数，如数学运算、字符串处理等。 5. **cmd**：包含了各种用户可执行的命令，如bootm、fatls、dhcp等。...
proc文件读写
gjioui123的博客
01-18 1290
读写/proc/cpuinfo 文件。
Linux 字符设备驱动（一）---cdev、file_operations、inode、file结构体详述，上层应用如何访问到底层驱动
the_wan的博客
09-06 2418
参考资料： 《Linux驱动开发入门与实战》，概念及源码主要参考《Linux驱动开发入门与实战》，务求准确。同时衷心感谢其他网友的分享。大部分内容都是手敲的，错漏之处望指正，谢谢！ linux设备驱动之字符设备驱动 https://www.linuxprobe.com/linux-device-driver.html Linux 字符设备驱动结构（一）—— cdev 结构体、设备号相关知识解析 https://blog.csdn.net/zqixiao_09/article/det...
File_operations结构体
m0_50620305的博客
10-18 940
File_operations结构体 file_operation就是把系统调用和驱动程序关联起来的关键数据结构。这个结构的每一个成员都对应着一个系统调用。读取file_operation中相应的函数指针，接着把控制权转交给函数，从而完成了Linux设备驱动程序的工作。 在系统内部，I/O设备的存取操作通过特定的入口点来进行，而这组特定的入口点恰恰是由设备驱动程序提供的。通常这组设备驱动程序接口是由结构file_operations结构体向系统说明的...
设备树的引入与体验(基于Linux 4.19)
刘铭
03-13 614
第01节_字符设备的三种写法怎么写驱动？ ① 看原理图： a. 确定引脚； b. 看芯片手册，确定如何操作引脚； ② 写驱动程序：驱动程序起封装作用 ③ 写测试程序； 如下原理图，VCC经过一个限流电阻到达LED的一端，再通向芯片的引脚上。 当芯片引脚输出低电平时，电流从高电平流向低电平，LED灯点亮； 当芯片引脚输出高电平时，没有电势差，没有电流流过，LED灯不亮； 从原理...
第一课:linux设备树的引入与体验(基于linux4.19内核版本)
韦东山嵌入式专栏
11-22 7735
本套视频面向如下三类学员： 1.有Linux驱动开发基础的人, 可以挑感兴趣的章节观看； 2.没有Linux驱动开发基础但是愿意学习的人,请按顺序全部观看,我会以比较简单的LED驱动为例讲解； 3.完全没有Linux驱动知识，又不想深入学习的人, 比如应用开发人员，不得已要改改驱动, 等全部录完后，我会更新本文档，那时再列出您需要观看的章节。 第01节_字符设备的三种写法 怎么写驱动？## ①看原...
linux-api-2.6.22.rar_linux-api-2.6.22_linux-api-2.6.22.chm
09-24
init_module()和cleanup_module()用于模块的加载和卸载，register_chrdev()和unregister_chrdev()则用于字符设备驱动的注册和注销。此外，module_init()和module_exit()宏确保模块正确地初始化和退出。 四、多线程...
Linux设备驱动程序学习(1)-字符设备驱动程序.pdf
10-08
本篇文章将详细讲解字符设备驱动程序的基础知识，以《Linux设备驱动程序（第3版）》第三章中的字符设备驱动程序——scull为例。 首先，字符设备驱动程序的核心是主设备号和次设备号。主设备号标识了对应驱动程序，...
ZYNQ 7010-7020实现SPI通信驱动（Linux驱动）.zip
03-21
本篇将深入讲解如何在ZYNQ 7010-7020上实现SPI通信的Linux驱动程序。 首先，SPI是一种同步串行通信协议，它允许主机与一个或多个设备进行全双工或半双工通信。SPI通信的核心组件包括主设备（Master）和从设备...
129.C语言程序设计--宿舍管理.docx
04-09
C语言程序设计在IT领域中占有重要地位，尤其在嵌入式系统、操作系统、设备驱动等低级编程中广泛使用。本篇文档是关于学生宿舍管理系统的课程设计，旨在帮助学生通过实际项目进一步掌握C语言的运用。 1. **C语言基础...
navicate远程linux上的pgsql提示密码失败
记录、分享、合作、共赢
09-14 370
2、postgresql.conf文件中，修改listen_addresses。3、重启pgsql，例如：systemctl restart pgsql。1、pg_hba.conf文件中，ipv4下面的内容改成。4、如果问题还在，检查firewalld防火墙，执行。5、再次尝试连接，成功！
【Linux】uImage头部信息详细解析
W__winter的博客
09-16 1562
【代码】【Linux】uImage头部信息详细解析。
linux-网络相关概念
zdd56789的博客
09-17 635
linux-网络相关概念
linux-进程管理-进程查看与控制
Flying_Fish_roe的博客
09-18 585
进程是操作系统中执行中的程序。Linux 将每个运行的程序看作是一个进程，每个进程都有唯一的进程ID (PID)。在 Linux 系统中，进程管理是非常重要的，它能够帮助系统管理员和用户查看、管理、优化系统资源的使用情况。Linux 提供了丰富的命令来查看和控制进程，例如pstophtopkill等等。这些命令允许用户监控和控制系统中运行的进程，以确保系统资源的合理使用，并避免进程阻塞或占用过多资源。在 Linux 系统中，进程管理是非常关键的操作。通过使用pstophtop。
Linux Kernel Makefiles 编译标志详解
m0_66404702的博客
09-18 485
ccflags-yccflags-y用于定义C编译器的编译选项，这些选项仅对当前Makefile文件有效。例如，如果你需要为特定的源文件添加宏定义，可以在Makefile中使用ccflags-y。asflags-y类似于ccflags-y，但asflags-y是为汇编器定义的选项。这些选项仅影响汇编过程，适用于需要特殊汇编指令或宏定义的场景。ldflags-yldflags-y用于定义链接器的选项，控制链接过程中的行为，如指定库文件的路径或链接时使用的特殊选项。
Linux3-cp,mv,rm,*
2301_80339607的博客
09-15 327
复制文件：cp test1.txt test2.txt，把当前目录下的test1.txt文件复制一份到当前目录下，并命名为text.txt。例如cp -r test1 test2，把当前目录下的test1文件夹复制一份到当前目录下，并命名为text2。强制删除：选项-f(force)，普通用户用不到，root用户使用，所以如果要使用需要先切换为root用户。(在test目录下)删除文件夹：带选项-r，例如rm -r test2。(在test1目录下)删除文件：rm test3.txt。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 1164
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
对目录的操作、获取文件信息
2303_80050865的博客
09-15 431
4）关于目录分隔符号，在windows下 "/ " 和 "//" 都可以，比如如"d://aaa//bbb//hi.txt"和"d:/aaa/bbb/hi.txt"，linux/unix是"/",比如 /root/home/aa.log 因此建议目录分隔符，为了兼容，linux和windows都使用"/"2）f.close()：刷新并关闭此流，也就是f.close()内置的flush功能。3）删除目录 d://aaa和d://bbb//ccc。2）创建多级目录 d://bbb//ccc。
Linux文件IO（四）-返回错误处理与errno详解
最新发布
Dola的博客
09-20 760
其实不然，在 Linux 系统下对常见的错误做了一个编号，每一个编号都代表着每一种不同的错误类型，当函数执行发生错误的时候，操作系统会将这个错误所对应的编号赋值给 errno 变量，每一个进程（程序）都维护了自己的 errno 变量，它是程序中的全局变量，该变量用于存储就近发生的函数执行错误编号，也就意味着下一次的错误码会覆盖上一次的错误码。从图中红框部分描述文字可知，当函数返回错误时会设置 errno，当然这里是以 open 函数为例，其它的系统调用也可以这样查找，大家可以自己试试！
Linux驱动开发：高级字符设备驱动详解
"这篇文档详细介绍了高级字符设备驱动程序，主要涵盖了Linux环境下设备驱动开发中的关键知识点，包括ioctl命令的使用、阻塞型I/O的实现以及poll方法的应用。" 在Linux设备驱动开发中，高级字符设备驱动程序是构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

多维不语

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

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

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

打赏作者

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

抵扣说明：

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

余额充值