当前位置： 首页 > news >正文

linux - 字符设备驱动简介

news 2025/7/5 16:18:14

一、设备号

1.1 设备号概念

    设备号在内核中唯一确定某个设备，包括主设备号和次设备号，主设备号唯一，次设备号不唯一

1.2 设备号说明

可通过cat /proc/devices命令查看当前系统挂载的设备的主设备号及对应的名称。

dev_t类型：
定义在/include/linux/types.h如下。
typedef u32 __kernel_dev_t;

typedef __kernel_dev_t dev_t;
由上面两行代码得知dev_t实际为u32类型数据，默认高12位为主设备号，低20位为次设备号在文件include\linux\kdev_t.h文件中有定义。

同样include\linux\kdev_t.h提供了关于dev_t常用的几个宏定义包括，根据主次设备号组成dev_t，根据dev_t分别获得主次设备号。子设备号掩码等。

 1.3 设备号分配及注销

1. 静态分配一个设备号
      register_chrdev_region(dev_t, unsigned, const char *);

      需要明确知道我们系统里面哪些设备号没用。

    参数：

    第一个：设备号的起始值，类型为dev_t。

    第二个：次设备号的个数。

    第三个：设备的名称。

    返回值：成功返回0，失败返回其它。

2. 动态分配设备号

    int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);

    参数：

    第一个：声明的设备号的地址，保存生成的设备号。

    第二个：请求的第一个次设备号，通常是0。

    第三个：连续申请的次设备号个数。

    第四个：设备名称。

    返回值：成功返回0，失败返回其它。

    注意：使用动态分配设备号优先分配234-255的主设备号。

3. 另外根据主设备号分配（通常不用）

__register_chrdev(unsigned int major, unsigned int baseminor, unsigned int count, const char *name, const struct file_operations *fops);

上述函数通常会将同一主设备号的所有次设备号都注册掉，造成资源浪费，通常不用。

4. 注销设备号

   void unregister_chrdev_region(dev_t, unsigned);

    第一个：声明的设备号的起始地址dev_t。

    第二个：设备的数量。

1.4示例代码及说明

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/types.h>
#include<linux/kdev_t.h>

static int a,b;

module_param(a, int, S_IRUSR);//加载驱动时传递参数，若无传参，默认为0
module_param(b, int, S_IRUSR);

dev_t chr_dev;

static int chr_init(void)
{
int ret;

if(a==0){
printk("major=%d\n",a);
printk("minor=%d\n",b);
chr_dev= MKDEV(a,b);
ret= register_chrdev_region(chr_dev, 1, "chr_test");
if(ret!=0)
{
printk("register_chrdev_region err %d\n",ret);
return -1;
}
printk("alloc success!\n");
}else{
ret = alloc_chrdev_region(&chr_dev, 0, 1, "chr_test1");
if(ret!=0)
{
printk("alloc_chrdev_region err %d\n",ret);
return -1;
}
printk("alloc success! major=%d\n", MAJOR(chr_dev));
}
return 0;
}

static void chr_exit(void)
{
printk("bye bye");
unregister_chrdev_region(chr_dev,1);
}

module_init(chr_init);
module_exit(chr_exit);
MODULE_LICENSE("GPL");

上诉代码编译:

  1. 通过传递参数加载驱动可以静态获取设备号如下：

    2. 执行insmod chr.ko可以通过动态获取到设备号，在内核中可以获得以下log。

执行cat /proc/devices可以查找到对应的设备。

二、字符设备注册

2.1 说明

cdev结构体，描述一个字符设备：

struct cdev {

struct kobject kobj;
struct module *owner;//所有者
const struct file_operations *ops;//操作集合
struct list_head list;//字符设备链表
dev_t dev;//设备号
unsigned int count;//次设备号数量

};//其中写程序需要关注、owner、ops、dev、count

2.2步骤

1) 定义一个cdev结构体。

2）初始化cdev结构体成员变量：

void cdev_init(struct cdev *, const struct file_operations *);//作用是填充cdev结构体及字符设备链表

第一个参数：字符设备结构体指针。

第二个参数：文件操作集合。

3）注册进内核

int cdev_add(struct cdev *, dev_t, unsigned);

第一个参数：字符设备结构体指针。

第二个参数：设备号。

第三个参数：次设备号的数量

4）生成设备节点

第一种方法，使用mknod命令，格式：mknode 设备名 类型 主设备号 次设备号，例如： mknode /dev/test c 238 0

第二种方法，驱动自动创建设备节点。后续详细介绍

5）注销

cdev_del(struct cdev *);

参数：字符设备结构体指针。

2.3 自动创建设备节点

使用udev实现设备节点创建，嵌入式设备通常使用mdev，mdev是udev的简化版

udev概念：根据系统中设备的状态更新设备文件，保证系统目录下都是存在的设备例如/dev下的设备节点。

创建设备节点注意包括两个步骤：

1）创建一个class：

class_create(owner, name)//4.4内核定义在include/linux/device.h。5.10内核定义在include/linux/device/class.h，class结构体同样定义在这两个文件

参数：

第一个参数,：所有者。

第二个参数：类的名称

返回值：类的指针

2）创建设备节点

device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...); 定义在include/linux/device/class.h

参数：

第一个参数：cls就是刚刚创建的。

第二个参数：父设备，通常为NULL。

第三个参数：设备号。

第四个参数：设备可能用到的数据，通常为NULL。

第五个参数：fmt为设备名字，即创建后的/dev目录下的名字

3）注销

class_destroy(struct class *cls);//注销类

device_destroy(struct class *cls, dev_t devt);//注销设备

2.4 示例程序

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/types.h>
#include<linux/kdev_t.h>
#include<linux/cdev.h>
#include<linux/device.h>

dev_t chr_dev;

static struct cdev chr_dev_test;

struct class *chr_dev_class;
struct device *chr_device;

int chr_dev_open(struct inode *inode, struct file *file)
{
printk("file open\n");
return 0;
}

struct file_operations chr_dev_ops = {
.owner = THIS_MODULE,
.open = chr_dev_open
};

static int chr_init(void)
{
int ret;

ret = alloc_chrdev_region(&chr_dev, 0, 1, "chr_test1");
if(ret!=0)
{
printk("alloc_chrdev_region err %d\n",ret);
return -1;
}
printk("alloc success! major=%d\n", MAJOR(chr_dev));

chr_dev_test.owner = THIS_MODULE;
cdev_init(&chr_dev_test,&chr_dev_ops);
cdev_add(&chr_dev_test, chr_dev, 1);
chr_dev_class = class_create(THIS_MODULE, "chr_dev_class");
chr_device =device_create(chr_dev_class, NULL, chr_dev, NULL, "chr_test");

return 0;
}

static void chr_exit(void)
{
unregister_chrdev_region(chr_dev,1);
cdev_del(&chr_dev_test);
class_destroy(chr_dev_class);
device_destroy(chr_dev_class, chr_dev);
printk("bye bye\n");
}

module_init(chr_init);
module_exit(chr_exit);
MODULE_LICENSE("GPL");

程序编译成ko加载之后可以在/sys/class目录和/dev目录得到对应的节点如下。

三、应用层和内核层的数据传输

在第二章中我们可以创建设备节点，Linux有一切皆文件的概念。因此我们对dev目录下的设备节点进行打开读写等操作时，会对应设备驱动里面的相应程序。

3.1 file_operations结构体

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 (*iopoll)(struct kiocb *kiocb, bool spin);
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 *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **, void **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
void (*show_fdinfo)(struct seq_file *m, struct file *f);
#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);
loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
struct file *file_out, loff_t pos_out,
loff_t len, unsigned int remap_flags);
int (*fadvise)(struct file *, loff_t, loff_t, int);
}

该结构体包含了应用层对设备节点的各种操作对应的函数。常用的如下

当应用层打开设备时，调用函数

(*open) (struct inode *, struct file *);

当应用层关闭设备时，调用函数

(*release) (struct inode *, struct file *);

当应用层对设备节点执行读操作时，调用函数

（*read) (struct file *, char __user *, size_t, loff_t *);

当应用层对设备节点执行写操作时，调用函数

 (*write) (struct file *, const char __user *, size_t, loff_t *);

当应用层对设备节点执行poll/select操作时，调用函数

(*poll) (struct file *, struct poll_table_struct *);

当应用层对设备节点执行ioctl操作时，调用函数

(*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

3.2 应用层和内核层数据传输

1）内核向应用传输copy_to_user(void __user * to, const void * from, unsigned long n)

参数：

第一个参数to标识数据要传输的地址。

第二个参数from是要传输的数据指针。

第三个参数是传输数据的长度。

2）应用向内核传输copy_from_user(void * to, const void __user * from, unsigned long n)

第一个参数to标识数据要传输的地址。

第二个参数from是要传输的数据地址。

第三个参数是传输数据的长度。

3.3 ioctl 方式

  1. unlocked_ioctl接口（linux3.0之前为ioctrl接口）。

ioctl是带锁的因此造成了内核实时性能变弱，为了提高实时性能去掉了锁变为unlocked_ctl，功能和对应的系统调用均没有改变。包含在在文件操作集合里面。

      2. unlocked_ioctl与read/write的相同点和不同点。

都可以实现内核和应用层通信。

不同点，ioctl同时实现读写功能，但是读取大数据的时候效率不如read/write。ioctl适合设置设备参数

      3.  ioctl接口命令规则。

参数：总共32位，

第一分区：0-7，命令的编号，范围是0-255。

第二分区：8-15，命令的幻数（魔数)。与第一分区一起主要作用是来区分命令的，防止出现同样命令。

第三分区：16-29，标识传递的数据大小。

第四分区：30-31，标识读写方向。

00：表示用户和驱动没有数据交换，

10：表示用户在驱动里面读数据，

01：表示用户向驱动里面写数据，

11：表示用户先向驱动写数据，再从驱动读数据。

      4. 命令的合成宏和分解宏

合成宏

_IO(type, nr)               : 用来定义没有数据读写的命令，type表示幻数对应8-15， nr是编号，对应0-7

_IOR(type, nr, size)     : 用来定义从驱动中读数据，type表示幻数， nr是编号，size是传输数据大小

_IOW(type, nr, size)    : 用来定义向驱动中写数据，type表示幻数， nr是编号，size是传输数据大小

_IOWR(type, nr, size)  : 用来定义先向驱动中写数据再从驱动中读数据，type表示幻数， nr是编号，size是传输数据大小

分解宏

_IOC_DIR(nr)               : 获取输入或输出方向，nr为命令。

_IOC_TYPE(nr)             : 获取命令幻数，nr为命令。

_IOC_NR(nr)                : 获取命令编号，nr为命令。

_IOC_SIZE(nr)              : 获取数据大小，nr为命令。

3.4 示例程序

在上一章程序的基础上扩充file_operations 结构体，添加以下代码

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/types.h>
#include<linux/kdev_t.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/uaccess.h>

#define TEST_IO_READ _IOR('A',1,int)//定义读命令宏
#define TEST_IO_WRITE _IOW('A',2,int)


dev_t chr_dev;

static struct cdev chr_dev_test;

struct class *chr_dev_class;
struct device *chr_device;


int chr_dev_open(struct inode *inode, struct file *file)
{
printk("file open\n");
return 0;
}

ssize_t chr_dev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
char s[64]="123";
if(copy_to_user(ubuf, s, strlen(s))){
printk("copy_to_user error \n");
return -1;
}
return 0;
}

ssize_t chr_dev_write(struct file *file,const char __user *ubuf, size_t size, loff_t *loff)
{
char s[64]={0};
if(copy_from_user(s, ubuf, size)){
printk("copy_from_user error\n");
return -1;
}
printk("get string %s\n",s);
return 0;
}

int chr_dev_close(struct inode *inode, struct file *file)
{
printk("closed\n");
return 0;
}

long chr_dev_ioctl(struct file *file, unsigned int cmd, unsigned long val)
{
int value=7;
switch (cmd)
{
case TEST_IO_READ:
if(copy_to_user((int *)val, &value, sizeof(value))){
printk("copy_to_user error \n");
return -1;
}
break;
case TEST_IO_WRITE:
printk("get val %d\n",val);
}
return 0;
}

struct file_operations chr_dev_ops = {
.owner = THIS_MODULE,
.open = chr_dev_open,
.release = chr_dev_close,
.read = chr_dev_read,
.write = chr_dev_write,
.unlocked_ioctl = chr_dev_ioctl
};

static int chr_init(void)
{
int ret;

ret = alloc_chrdev_region(&chr_dev, 0, 1, "chr_test1");
if(ret!=0)
{
printk("alloc_chrdev_region err %d\n",ret);
return -1;
}
printk("alloc success! major=%d\n", MAJOR(chr_dev));

chr_dev_test.owner = THIS_MODULE;
cdev_init(&chr_dev_test,&chr_dev_ops);
cdev_add(&chr_dev_test, chr_dev, 1);
chr_dev_class = class_create(THIS_MODULE, "chr_dev_class");
chr_device =device_create(chr_dev_class, NULL, chr_dev, NULL, "chr_test");

return 0;
}

static void chr_exit(void)
{
unregister_chrdev_region(chr_dev,1);
cdev_del(&chr_dev_test);
class_destroy(chr_dev_class);
device_destroy(chr_dev_class, chr_dev);
printk("bye bye\n");
}

module_init(chr_init);
module_exit(chr_exit);
MODULE_LICENSE("GPL");

编写应用层示例程序

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


int main(int argc, char *argv){
int fd;
char buf[64]={0};

fd = open("/dev/chr_test",O_RDWR);
if(fd<0){
printf("open failed\n");
return fd;
}
read(fd,buf,64);
printf("get buf %s\n",buf);
//memset(buf,"abc",3);
*buf = 'a';
printf("put buf %s\n",buf);
write(fd,buf,strlen(buf));

int val;
while(1){
ioctl(fd,_IOW('A',2,int),1);
sleep(2);
ioctl(fd, _IOR('A',1,int),&val);
printf("get val:%d\n",val);
sleep(2);
}
close(fd);

return 0;
}

程序执行结果：

上层应用在代码层读到的数据如下：

内核从上层得到的数据如下：

四、物理地址到虚拟地址的映射

单片机上往往都是直接对寄存器地址读写实现硬件控制，在Linux系统是不行的，需要先把物理地址映射为虚拟地址。Linux系统使用了MMU，内核通过对虚拟地址的操作实现对设备寄存器读写。

4.1 有了MMU的好处：

首先可以实现虚拟内存，使每个进程可以获取到连续的内存，使虚拟地址连续物理地址不连续成为可能。减内存碎片，方便程序管理及提高代码可移植性。

上层应用不能直接通过物理地址来操作硬件，隔绝了上层对物理设备的修改。保证了系统安全。

4.2 如何将物理地址映射到虚拟地址

1）ioremap(phys_addr_t offset, size_t size);//映射函数

第一个参数：要映射的物理地址的起始地址。

第二个参数：要映射物理地址的大小。

返回值：成功执行返回虚拟地址的首地址。失败返回NULL。

2) iounmap(void __iomem *addr)//释放

参数，要释放的虚拟地址

注意：物理地址只能映射一次，多次映射会失败。

可以通过cat /proc/iomem查看已经映射的物理地址。

五、总结

最终驱动在init的时候转换一下虚拟地址，在用户读写的时候根据虚拟地址对设备的寄存器进行读写实现简单字符设备的读写。

http://www.dtcms.com/a/109541.html

相关文章：

  • MySql 数据库题目
  • 三防笔记本有什么用 | 三防笔记本有什么特别
  • CentOS中挂载新盘LVM指南：轻松扩展存储空间，解决磁盘容量不足问题
  • ORM mybits mybits-plus
  • 探索现代网络技术：从负载均衡到 Kubernetes
  • ECMAScript介绍
  • 使用C#写的一个Kafka的使用工具
  • git的作用，以及和github的区别
  • 数据结构与算法学习笔记----贪心区间问题
  • C++中的IO流
  • 【动态规划】最长上升子序列模板
  • 网络编程—网络概念
  • 国产编辑器EverEdit - 扩展脚本：让EverEdit支持“批量查找”功能
  • 使用 requests 和 BeautifulSoup 解析淘宝商品
  • 安利免费开源的声音克隆、文本转语音整合包软件、一键本地安装！
  • Shopify独立站开发与运营全解析
  • iOS 18.4修复多个核心安全漏洞，间接增强Find My服务的数据保护能力
  • 基于javaweb的SSM羽毛球会员俱乐部系统场馆课程运动设计与实现(源码+文档+部署讲解）
  • 五种音频器件综合对比——《器件手册--音频器件》
  • 【C++游戏引擎开发】《几何算法》（2）：OBB射线检测
  • 【总结】SQL注入防护手段
  • 【11408学习记录】[特殊字符] 三步攻克英语长难句：嵌套结构×平行结构全解析
  • Linux中系统安全及应用
  • axios取消重复请求
  • Java基础：面向对象入门（一）
  • 【AI News | 20250403】每日AI进展
  • Java 实现 字母异位词分组
  • 5. 数据交互基础：从文本加载到向量存储的完整流程
  • Nyquist插件基础：LISP语法-运算符
  • c++基础-----c++ 成员变量初始化顺序