嵌入式（字符设备驱动基础上_基础框架）

已于 2022-11-18 15:45:57 修改
阅读量86 收藏
点赞数
分类专栏： Linux 驱动以及裸机 文章标签： 驱动开发 arm开发 linux
于 2022-11-14 22:12:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/afddasfa/article/details/127764063
版权

一、Linux内核对设备的分类

Linux的文件种类：

  1. -：普通文件
  2. d：目录文件
  3. p：管道文件
  4. s：本地socket文件
  5. l：链接文件
  6. c：字符设备
  7. b：块设备

Linux内核按驱动程序实现模型框架的不同，将设备分为三类：

  1. 字符设备：按字节流形式进行数据读写的设备，一般情况下按顺序访问，数据量不大，一般不设缓存
  2. 块设备：按整块进行数据读写的设备，最小的块大小为512字节（一个扇区），块的大小必须是扇区的整数倍，Linux系统的块大小一般为4096字节，随机访问，设缓存以提高效率
  3. 网络设备：针对网络数据收发的设备

总体框架图：在这里插入图片描述

二、设备号------内核中同类设备的区分

内核用设备号来区分同类里不同的设备，设备号是一个无符号32位整数，数据类型为dev_t，设备号分为两部分：

  1. 主设备号：占高12位，用来表示驱动程序相同的一类设备
  2. 次设备号：占低20位，用来表示被操作的哪个具体设备

应用程序打开一个设备文件时，通过设备号来查找定位内核中管理的设备。

MKDEV宏用来将主设备号和次设备号组合成32位完整的设备号，用法：

dev_t devno;
int major = 251;//主设备号
int minor = 2;//次设备号
devno = MKDEV(major,minor);

MAJOR宏用来从32位设备号中分离出主设备号，用法：

dev_t devno = MKDEV(249,1);
int major = MAJOR(devno);

MINOR宏用来从32位设备号中分离出次设备号，用法：

dev_t devno = MKDEV(249,1);
int minor = MINOR(devno);

如果已知一个设备的主次设备号，应用层指定好设备文件名，那么可以用mknod命令在/dev目录创建代表这个设备的文件，即此后应用程序对此文件的操作就是对其代表的设备操作，mknod用法如下：

@ cd /dev
@ mknod 设备文件名 设备种类(c为字符设备,b为块设备)  主设备号  次设备号    //ubuntu下需加sudo执行

在这里插入图片描述

在应用程序中如果要创建设备可以调用系统调用函数mknod，其原型如下：

int mknod(const char *pathname,mode_t mode,dev_t dev);
pathname:带路径的设备文件名，无路径默认为当前目录，一般都创建在/dev下
mode：文件权限 位或 S_IFCHR/S_IFBLK
dev:32位设备号
返回值：成功为0，失败-1

三、申请和注销设备号

字符驱动开发的第一步是通过模块的入口函数向内核添加本设备驱动的代码框架，主要完成：

  1. 申请设备号
  2. 定义、初始化、向内核添加代表本设备的结构体元素
int register_chrdev_region(dev_t from, unsigned count, const char *name)
功能：手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号
参数：
	from：自己指定的设备号
	count：申请的设备数量
	name：/proc/devices文件中与该设备对应的名字，方便用户层查询主设备号
返回值：
	成功为0，失败负数，绝对值为错误码

int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count, const char *name)
功能：动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号
参数：
	dev：分配设备号成功后用来存放分配到的设备号，分配结束后要把主设备号提取出来（major = MAJOR(devno);)因为主设备号会变所以要将变得重新赋值
	baseminior：起始的次设备号，一般为0
	count：申请的设备数量
	name：/proc/devices文件中与该设备对应的名字，方便用户层查询主次设备号
返回值：
	成功为0，失败负数，绝对值为错误码

分配成功后在/proc/devices可以查看到申请到主设备号和对应的设备名，mknod时参数可以参考查到的此设备信息

void unregister_chrdev_region(dev_t from, unsigned count)
功能：释放设备号
参数：
	from：已成功分配的设备号将被释放
	count：申请成功的设备数量

释放后/proc/devices文件对应的记录消失
在这里插入图片描述
在这里插入图片描述

四、函数指针复习

内存的作用-----用来存放程序运行过程中的

  1. 数据
  2. 指令

4.1、 内存四区

堆区

栈区

数据区（全局区）

代码区

4.2、C语言中内存数据的访问方式

直接访问：通过所在空间名称去访问

间接访问：通过所在空间首地址去访问

4.3、C语言中函数调用方式：

直接调用：通过函数名去调用函数

间接调用：通过函数在代码区所对应的那份空间的首地址去调用

int func(int a,int b)
{
    //......
}

int (int a,int b)  * pf;//语法错误
int *pf(int a,int b);//函数声明语句
int (*pf)(int a,int b);//定义一个函数指针
pf = &func;//&运算符后面如果是函数名的话可以省略不写
pf = func;  //一般用这种

y = func(3,4);//直接调用
y = (*pf)(3,4);//间接调用，*运算符后面如果是函数指针类型则可以省略不写
y = pf(3,4);//间接调用 一般用这种

typedef int myint;
typedef int (*)(int,int)  pft;//语法错误
typedef int (*pft)(int,int) ;
pft pt;

4.4 适用场合

前提：当有很多个同类函数待被调用时

A处：知道所有函数名，由此处来决定B处将会调用哪个函数

B处：负责调用A处指定的函数

思考：A处如何告诉B处被调用的是哪个函数呢，无非两个办法：

  1. 告诉B处函数名，怎么做呢？传字符串----“函数名”？ C语言没有对应语法支持
  2. 告诉B处对应函数在代码区的地址

五、注册字符设备

struct cdev
{
	struct kobject kobj;//表示该类型实体是一种内核对象
	struct module *owner;//填THIS_MODULE，表示该字符设备从属于哪个内核模块
	const struct file_operations *ops;//指向空间存放着针对该设备的各种操作函 数地址
	struct list_head list;//链表指针域
	dev_t dev;//设备号
	unsigned int count;//设备数量
};

自己定义的结构体中必须有一个成员为 struct cdev cdev，两种方法定义一个设备：

  1. 直接定义：定义结构体全局变量

  2. 动态申请：

struct cdev * cdev_alloc()

void cdev_init(struct cdev *cdev,const struct file_operations *fops)

struct file_operations 
{
   struct module *owner;           //填THIS_MODULE，表示该结构体对象从属于哪个内核模块
   int (*open) (struct inode *, struct file *);	//打开设备
   int (*release) (struct inode *, struct file *);	//关闭设备
   ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);	//读设备
   ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);    //写设备
   loff_t (*llseek) (struct file *, loff_t, int);		//定位
   long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);//读写设备参数，读设备状态、控制设备
   unsigned int (*poll) (struct file *, struct poll_table_struct *);	//POLL机制，实现多路复用的支持
   int (*mmap) (struct file *, struct vm_area_struct *); //映射内核空间到用户层
   int (*fasync) (int, struct file *, int); //信号驱动
   //......
};

该对象各个函数指针成员都对应相应的系统调用函数，应用层通过调用系统函数来间接调用这些函数指 针成员指向的设备驱动函数：

在这里插入图片描述

一般定义一个struct file_operations类型的全局变量并用自己实现各种操作函数名对其进行初始化

int cdev_add(struct cdev *p,dev_t dev,unsigned int count)
功能：将指定字符设备添加到内核
参数：
	p：指向被添加的设备
	dev：设备号
	count：设备数量，一般填1

void cdev_del(struct cdev *p)
功能：从内核中移除一个字符设备
参数：
	p：指向被移除的字符设备

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>

int major = 11;
int minor = 0;
int mychar_num = 1;

struct cdev mydev;

int mychar_open(struct inode *pnode,struct file *pfile)
{
        printk("mychar_open is called\n");
        return 0;
}

int mychar_close(struct inode *pnode,struct file *pfile)
{
        printk("mychar_close is called\n");
}

struct file_operations myops = {
        .owner = THIS_MODULE,
        .open = mychar_open,
        .release = mychar_close,
};

int __init mychar_init(void)
{
        int ret = 0;
        dev_t devno = MKDEV(major,minor);

        /*申请设备号*/
        ret = register_chrdev_region(devno,mychar_num,"mychar");
        if(ret)
        {
                ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
                if(ret)
                {
                        printk("get devno failed\n");
                        return -1;
                }
                major = MAJOR(devno);
        }
        /*给struct cdev对象指定操作函数集*/
        cdev_init(&mydev,&myops);

        /*将struct cdev对象添加到内核对应的数据结构里*/
        mydev.owner = THIS_MODULE;
        cdev_add(&mydev,devno,mychar_num);
        
        return 0;
}

void __exit mychar_exit(void)
{
        dev_t devno = MKDEV(major,minor);
        cdev_del(&mydev);
        unregister_chrdev_region(devno,mychar_num);
}

MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

app程序
文件名（open，close）通过main函数的argc参数传入
在这里插入图片描述
程序运行结果
在这里插入图片描述
小结：

字符设备驱动开发步骤：

  1. 如果设备有自己的一些控制数据，则定义一个包含struct cdev mydev，其它成员根据设备需求，设备简单则直接用struct cdev
  2. 定义一个struct mydev或struct cdev的全局变量来表示本设备；也可以定义一个struct mydev或struct cdev的全局指针（记得在init时动态分配）
  3. 定义三个全局变量分别来表示主设备号、次设备号、设备数
  4. 定义一个struct file_operations结构体变量，其owner成员置成THIS_MODULE
  5. module init函数流程：a. 申请设备号 b. 如果是全局设备指针则动态分配代表本设备的结构体元素 c. 初始化struct cdev成员 d. 设置struct cdev的owner成员为THIS_MODULE e. 添加字符设备到内核
  6. module exit函数：a. 注销设备号 b. 从内核中移除struct cdev c. 如果如果是全局设备指针则释放其指向空间
  7. 编写各个操作函数并将函数名初始化给struct file_operations结构体变量

验证操作步骤：

  1. 编写驱动代码mychar.c
  2. make生成ko文件
  3. insmod ./xxx.ko 将模块插入内核
  4. 查阅字符设备用到的设备号（主设备号）：cat /proc/devices | grep 申请设备号时用的名字
  5. 创建设备文件（设备节点） ： mknod /dev/??? c 上一步查询到的主设备号 代码中指定初始次设备号
  6. 编写app验证驱动（testmychar_app.c）
  7. 指定文件名 ./tca /dev/??? 与之前mknod创建的目录一致
  8. 编译运行app，dmesg命令查看内核打印信息

六、字符设备驱动框架解析

设备的操作函数如果比喻是桩的 话（性质类似于设备操作函数的函数，在一些场合被称为桩函数），则：

驱动实现设备操作函数 ----------- 做桩

insmod调用的init函数主要作用 --------- 钉桩

rmmod调用的exitt函数主要作用 --------- 拔桩

应用层通过系统调用函数间接调用这些设备操作函数 ------- 用桩

6.1 两个操作函数中常用的结构体说明

内核中记录文件元信息的结构体
struct inode
{
	//....
	dev_t  i_rdev;//设备号
	struct cdev  *i_cdev;//如果是字符设备才有此成员，指向对应设备驱动程序中的加入系统的struct cdev对象
	//....
}
/*
	1. 内核中每个该结构体对象对应着一个实际文件,一对一
	2. open一个文件时如果内核中该文件对应的inode对象已存在则不再创建，不存在才创建
	3. 内核中用此类型对象关联到对此文件的操作函数集（对设备而言就是关联到具体驱动代码）
*/

读写文件内容过程中用到的一些控制性数据组合而成的对象------文件操作引擎（文件操控器）
struct file
{
	//...
	mode_t f_mode;//不同用户的操作权限，驱动一般不用
	loff_t f_pos;//position 数据位置指示器，需要控制数据开始读写位置的设备有用，（读文件是从哪个位置读，读的位置就是指示器指向的位置）
	unsigned int f_flags;//open时的第二个参数flags存放在此，驱动中常用
	struct file_operations *f_op;//open时从struct inode中i_cdev的对应成员获得地址，驱动开发中用来协助理解工作原理，内核中使用
	void *private_data;//本次打开 5文件的私有数据，驱动中常来在几个操作函数间传递共用数据
	struct dentry *f_dentry;//驱动中一般不用，除非需要访问对应文件的inode，用法flip->f_dentry->d_inode
    int refcnt;//引用计数，保存着该对象地址的位置个数，close时发现refcnt为0才会销毁该struct file对象
	//...
};
/*
	1. open函数被调用成功一次，则创建一个该对象，因此可以认为一个该类型的对象对应一次指定文件的操作
	2. open同一个文件多次，每次open都会创建一个该类型的对象
	3. 文件描述符数组中存放的地址指向该类型的对象
	4. 每个文件描述符都对应一个struct file对象的地址
*/

6.2 字符设备驱动程序框架分析

驱动实现端：
在这里插入图片描述
驱动使用端：
在这里插入图片描述
syscall_open函数实现的伪代码：

int syscall_open(const char *filename,int flag)
{
    dev_t devno;
    struct inode *pnode = NULL;
    struct cdev *pcdev = NULL;
    struct file *pfile = NULL;
    int fd = -1;
    
    /*根据filename在内核中查找该文件对应的struct inode对象地址
        找到则pnode指向该对象
        未找到则创建新的struct inode对象，pnode指向该对象，并从文件系统中读取文件的元信息到该对象*/
    if(/*未找到对应的struct inode对象*/)
    {/*根据文件种类决定如何进行下面的操作，如果是字符设备则执行如下操作*/
    
    	/*从pnode指向对象中得到设备号*/
	    devno = pnode->i_rdev;
    
    	/*用devno在字符设备链表查找对应节点，并将该节点的地址赋值给pcdev*/
    
    	/*pcdev赋值给pnode的i_cdev成员*/
    	pnode->i_cdev = pcdev;
    }
    
    /*创建struct file对象，并将该对象的地址赋值给pfile*/
    
    pfile->f_op = pnode->i_cdev->ops;
    pfile->f_flags = flag;
    
    /*调用驱动程序的open函数*/
    pfile->f_op->open(pnode,pfile,flag);
    
    /*将struct file对象地址填入进程的描述符数组，得到对应位置的下标赋值给fd*/
    
    return fd;
}

syscall_read函数实现的伪代码

int syscall_read(int fd,void *pbuf,int size)
{
    struct file *pfile = NULL;
    struct file_operations *fops = NULL;
    int cnt；
    
    /*将fd作为下标，在进程的描述符数组中获得struct file对象的地址赋值给pfile*/
    
    /*从struct file对象的f_op成员中得到操作函数集对象地址赋值给fops*/
    
    /*从操作函数集对象的read成员得到该设备对应的驱动程序中read函数，并调用之*/
    cnt = fops->read(pfile,pbuf,size,&pfile->f_pos);
    
    。。。。
    return cnt;
}

6.3 参考原理图

在这里插入图片描述
在这里插入图片描述

6.4 常用操作函数说明

int (*open)(struct inode *, struct file *);	//打开设备
/*
	指向函数一般用来对设备进行硬件上的初始化，对于一些简单的设备该函数只需要return 0，对应open系统调用，是open系统调用函数实现过程中调用的函数,
*/

int (*release)(struct inode *, struct file *);	//关闭设备
/*
	,指向函数一般用来对设备进行硬件上的关闭操作，对于一些简单的设备该函数只需要return 0，对应close系统调用，是close系统调用函数实现过程中调用的函数
*/

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);	//读设备
/*
	指向函数用来将设备产生的数据读到用户空间，对应read系统调用，是read系统调用函数实现过程中调用的函数
*/

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);    //写设备
/*
	指向函数用来将用户空间的数据写进设备，对应write系统调用，是write系统调用函数实现过程中调用的函数
*/

loff_t (*llseek) (struct file *, loff_t, int);		//数据操作位置的定位
/*
	指向函数用来获取或设置设备数据的开始操作位置（位置指示器），对应lseek系统调用，是lseek系统调用函数实现过程中调用的函数
*/


long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);//读写设备参数，读设备状态、控制设备
/*
	指向函数用来获取、设置设备一些属性或设备的工作方式等非数据读写操作，对应ioctl系统调用，是ioctl系统调用函数实现过程中调用的函数
*/

unsigned int (*poll) (struct file *, struct poll_table_struct *);//POLL机制，实现对设备的多路复用方式的访问
/*
	指向函数用来协助多路复用机制完成对本设备可读、可写数据的监控，对应select、poll、epoll_wait系统调用，是select、poll、epoll_wait系统调用函数实现过程中调用的函数
*/
  
int (*fasync) (int, struct file *, int); //信号驱动
/*
	指向函数用来创建信号驱动机制的引擎，对应fcntl系统调用的FASYNC标记设置，是fcntl系统调用函数FASYNC标记设置过程中调用的函数
*/

七、读操作实现

ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
    pbuf：指向用户空间一块内存，用来保存读到的数据
    count：用户期望读取 的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值： 
    本次成功读取的字节数，失败返回-1

put_user(x,ptr)

x：char、int类型的简单变量名

unsigned long copy_to_user (void __user * to, const void * from, unsigned long n)

成功为返回0，失败非0

八、写操作实现

ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
    pbuf：指向用户空间一块内存，用来保存被写的数据
    count：用户期望写入的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
    本次成功写入的字节数，失败返回-1

get_user(x,ptr)

x：char、int类型的简单变量名

unsigned long copy_from_user (void * to, const void __user * from, unsigned long n)

成功为返回0，失败非0
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
app代码
在这里插入图片描述
输出结果
在这里插入图片描述

九、ioctl操作实现

已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)
避免使用全局变量如下：
在这里插入图片描述
在这里插入图片描述

 long xxx_ioctl (struct file *filp, unsigned int cmd, unsigned long arg);
功能：对相应设备做指定的控制操作（各种属性的设置获取等等）
参数：
	filp：指向open产生的struct file类型的对象，表示本次ioctl对应的那次open
	cmd：用来表示做的是哪一个操作
    arg：和cmd配合用的参数
返回值：成功为0，失败-1

cmd组成
在这里插入图片描述

  1. dir（direction），ioctl 命令访问模式（属性数据传输方向），占据 2 bit，可以为 _IOC_NONE、_IOC_READ、_IOC_WRITE、_IOC_READ | _IOC_WRITE，分别指示了四种访问模式：无数据、读数据、写数据、读写数据；
  2. type（device type），设备类型，占据 8 bit，在一些文献中翻译为 “幻数” 或者 “魔数”，可以为任意 char 型字符，例如
    ‘a’、’b’、’c’ 等等，其主要作用是使 ioctl 命令有唯一的设备标识；
  3. nr（number），命令编号/序数，占据 8 bit，可以为任意 unsigned char 型数据，取值范围 0~255，如果定义了多个 ioctl 命令，通常从 0 开始编号递增；
  4. size，涉及到 ioctl 函数 第三个参数 arg ，占据 13bit 或者 14bit（体系相关，arm 架构一般为 14 位），指定了 arg 的数据类型及长度，如果在驱动的 ioctl 实现中不检查，通常可以忽略该参数；

.h文件在这里插入图片描述
.c文件
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
app
在这里插入图片描述

#define _IOC(dir,type,nr,size) (((dir)<<_IOC_DIRSHIFT)| \
                               ((type)<<_IOC_TYPESHIFT)| \
                               ((nr)<<_IOC_NRSHIFT)| \
                               ((size)<<_IOC_SIZESHIFT))
/* used to create numbers */

// 定义不带参数的 ioctl 命令
#define _IO(type,nr)   _IOC(_IOC_NONE,(type),(nr),0)

//定义带读参数的ioctl命令（copy_to_user） size为类型名
#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))

//定义带写参数的 ioctl 命令（copy_from_user） size为类型名
#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))

//定义带读写参数的 ioctl 命令 size为类型名
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))

/* used to decode ioctl numbers */
#define _IOC_DIR(nr)        (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr)       (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr)     (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr)      (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)

十、printk

//日志级别
#define	KERN_EMERG	"<0>"	/* system is unusable			*/
#define	KERN_ALERT	"<1>"	/* action must be taken immediately	*/
#define	KERN_CRIT	"<2>"	/* critical conditions			*/
#define	KERN_ERR	"<3>"	/* error conditions			*/

#define	KERN_WARNING	"<4>"	/* warning conditions			*/

#define	KERN_NOTICE	"<5>"	/* normal but significant condition	*/
#define	KERN_INFO	"<6>"	/* informational			*/
#define	KERN_DEBUG	"<7>"	/* debug-level messages			*/

用法：printk(KERN_INFO"....",....)
    
    printk(KERN_INFO"Hello World"); =====> printk("<6>""Hello World") ====> printk("<6>Hello World")

dmesg --level=emerg,alert,crit,err,warn,notice,info,debug

#define HELLO_DEBUG
#undef PDEBUG
#ifdef HELLO_DEBUG
#define PDEBUG(fmt, args...) printk(KERN_DEBUG fmt, ##args)
#else
#define PDEBUG(fmt, args...)
#endif

十一、多个次设备的支持

多个设备：一个主设备号，多个次设备号（同类设备）

每一个具体设备（次设备不一样的设备），必须有一个struct cdev来代表它

cdev_init

cdev.owner赋值

cdev_add

以上三个操作对每个具体设备都要进行
.c
在这里插入图片描述
int _init mychar（void）函数里面
在这里插入图片描述
void __exit mychar_exit(void)
在这里插入图片描述

" /* informational /
#define KERN_DEBUG “<7>” / debug-level messages */

用法：printk(KERN_INFO"…",…)

printk(KERN_INFO"Hello World"); =====> printk("<6>""Hello World") ====> printk("<6>Hello World")


dmesg --level=emerg,alert,crit,err,warn,notice,info,debug

```c
#define HELLO_DEBUG
#undef PDEBUG
#ifdef HELLO_DEBUG
#define PDEBUG(fmt, args...) printk(KERN_DEBUG fmt, ##args)
#else
#define PDEBUG(fmt, args...)
#endif

十一、多个次设备的支持

每一个具体设备（次设备不一样的设备），必须有一个struct cdev来代表它

cdev_init

cdev.owner赋值

cdev_add

以上三个操作对每个具体设备都要进行

嵌入式学习者。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
嵌入式Linux驱动模块注册字符设备号
yangxueyangxue的博客
01-17 339
Linux 的设备管理是和文件系统紧密结合的， 各种设备都以文件的形式存放在/dev 目录下， 称为设备文件。 应用程序可以打开、 关闭和读写这些设备文件， 完成对设备的操作， 就像操作普通的数据文件一样。为了管理这些设备， 系统为设备编了号， 每个设备号又分为主设备号和次设备号。 主设备号用来区分不同类型的设备， 而次设备号用来区分同一类型的多个设备。
Linux 嵌入式开发记录（二）设备驱动
dreamliweiming的博客
09-23 423
Linux 嵌入式开发 驱动
【Linux】内核驱动篇三--字符设备驱动基础
修成真的博客
05-16 1042
内核驱动篇三--字符设备驱动基础一、Linux内核对设备的分类二、设备号------内核中同类设备的区分三、申请和注销设备号四、注册字符设备五、字符设备驱动框架解析5.1 两个操作函数中常用的结构体说明5.2 字符设备驱动程序框架分析5.3 参考原理图5.4 常用操作函数说明六、读操作实现七、写操作实现八、ioctl操作实现九、printk十、多个次设备的支持 一、Linux内核对设备的分类 linux的文件种类： -：普通文件 d：目录文件 p：管道文件 s：本地socket文件 l：链接文件 c：.
嵌入式驱动初级-字符设备驱动基础
weixin_44681745的博客
11-25 1068
字符设备驱动
迅为嵌入式linux驱动开发笔记（二）—地址映射与字符设备
梅山
03-03 1069
一、linux物理地址到虚拟地址的映射 linux不能直接对物理地址进行操作，如果需要操作硬件，需要先把物理地址转成虚拟地址，因为linux使能了MMU，所以不能直接操作物理地址。 1、使能MMU有什么好处？ （1）让虚拟地址成了可能 （2）可以让系统更加安全，有了MMU，上层应用看到的内存都是虚拟内存，应用就不能直接访问硬件，这样保证了系统安全。 2、MMU非常复杂，如何完成物理地址到虚拟地址的转换呢？ 内核提供了相关的函数。 在include/asm-generic 下的io.h ioremap：把物理
嵌入式学习10--浅析输入子系统
origina1s的博客
09-02 233
1.输入子系统handler 我们先从输入子系统的核心层文件开始解析，kernel\drivers\input\input.c中包含了输入子系统框架需要的函数 从入口input_init开始，可以看到注册一个input_class->input_proc_init->register_chrdev 在这里只注册了输入子系统的class，但是没有注册device，因为此时我们也...
嵌入式Linux字符设备和杂项设备总结
yangxueyangxue的博客
01-07 730
字符设备是 3 大类设备（字符设备、 块设备和网络设备） 中的一类， 其驱动程序完成的主要工作是初始化、 添加和删除 cdev 结构体， 申请和释放设备号， 以及填充 file_operations 结构体中的操作函数， 实现file_operations 结构体中的 read（） 、 write（） 和 ioctl（） 等函数是驱动设计的主体工作。
主线剧情07.3-Linux驱动编程-内核态API总结备查
空有精品无人问，倒也自然
06-04 623
Linux驱动编程-内核态常用API总结备查。
【嵌入式环境下linux内核及驱动学习笔记-（3-字符设备驱动详解）】
weixin_45499326的博客
04-10 1187
项目说明语法功能将主设备号和次设备号转换成dev_t类型头文件参数major为主设备号，minor为次设备号宏定义返回值成功执行返回dev_t类型的设备编号变量用途说明设备号，标识设备的身份标号，可以解析出主设备号与次设备号创建于驱动加载之时，也存于cdev结构体内表示设备的结构体，将设备号与操作函数结构体file_operations关联起来创建于驱动加载之时，加载到内核的cdev链表中驱动实际操作的函数入口，是具体的设备驱动函数集合的入口。
嵌入式Linux之字符设备的驱动
菠萝菠萝哒X
03-18 1327
驱动程序是字符设备。写一个驱动程序：1、写框架；2、完善硬件的操作：a、看原理图；                                b、看芯片手册；                                c、写代码。LED驱动程序      裸板开发时使用的是物理地址，在嵌入式linux系统驱动开发时所使用的是虚拟地址，通过 ioremap（）函数 进行虚拟地址的映射。使用i...
嵌入式系统/ARM技术中的Linux字符设备驱动程序的编写框架
11-12
设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能: 　1、对设备初始化...
嵌入式Linux设备驱动开发视频教程
09-02
linux嵌入式开发 教程描述：介绍Linux设备驱动...字符设备、块设备、TTY设备、I2C设备、LCD设备、音频设备、USB设备、网络设备、PCI设备等Linux设备驱动的架构和框架中各个复杂数据架构和函数的关系，并讲解了Linux
嵌入式Linux设备驱动程序开发PPT课件.pptx
10-07
本资源主要讲解了嵌入式Linux设备驱动程序的开发，包括设备驱动相关概念、字符设备驱动程序的开发、程序框架、实验要求、HelloWorldModule例程和Demo程序设计等。 设备驱动的概念 设备驱动是位于应用和物理设备...
一个最基本的Linux LED字符设备驱动，支持多个LED灯
03-02
一个最基本的Linux LED字符设备驱动，纯字符设备驱动，不适用任何框架，支持多个LED灯。
嵌入式Linux设备驱动开发
02-29
字符设备、块设备、TTY设备、I2C设备、LCD设备、音频设备、USB设备、网络设备、PCI设备等Linux设备驱动的架构和框架中各个复杂数据架构和函数的关系，并讲解了大量Linux驱动开发的大量实例，使读者能够独立开发各类...
Spring注解驱动开发与第三方整合实战指南
2301_80237574的博客
06-02 759
Spring注解驱动开发与第三方整合实战指南
ARM-V9 RME(Realm Management Extension)系统架构之系统能力的执行隔离
security²-卢鸿波-安全二次方
05-29 488
本博客探讨RME 所需系统能力的执行隔离，以保证 Arm CCA 对于 Realms 的安全性和隔离特性。
【ARM Cache 系列文章 2.1 -- Cache PoP 及 PoDP 介绍】
最新发布
CodingCos的博客
06-05 62
点对深度持久性（Point of Deep Persistence, PoDP）是内存系统中的一个点，在该点达到的任何写操作即使在系统供电瞬时硬件故障的情况下也是持久的。这意味着，一旦数据写入操作达到 PoDP，即使发生断电或其他硬件故障，这些数据也不会丢失。这通常通过使用某些形式的非易失性存储来实现，如固态硬盘（SSD）或其他形式的持久性内存技术。点对持久性（Point of Persistence, PoP）的概念与PoDP紧密相关，但它在ARM体系结构中有更具体的含义，取决于实现了哪些特性：关于 Po
【ARM-Linux篇】内核编译
m0_66492811的博客
06-02 784
内核编译
嵌入式设备驱动内核模块框架
06-12
嵌入式设备驱动内核模块通常包括以下几个组成部分： 1. 设备注册：通常在内核启动时完成设备的注册工作，将设备信息与对应的驱动程序进行关联。 2. 设备初始化：在设备注册完成后，需要对设备进行初始化，包括配置设备寄存器、中断控制等。 3. 设备操作：设备操作通常包括读取和写入设备寄存器、控制设备中断等。 4. 中断处理：如果设备支持中断，内核模块需要实现中断处理程序，处理设备产生的中断事件。 5. 设备释放：在设备不再使用时，需要释放设备资源，包括解除设备与驱动之间的关联、释放设备内存等。 在 Linux 内核中，设备驱动通常采用字符设备驱动、块设备驱动和网络设备驱动等不同类型，每种类型的驱动都有对应的内核模块框架和接口。开发者可以根据具体的需求选择相应的驱动类型，并按照对应的内核模块框架进行开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嵌入式学习者。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值