学习笔记：linux驱动之字符设备驱动

已于 2023-10-07 19:34:44 修改
阅读量70 收藏
点赞数
分类专栏： linu开发学习笔记 文章标签： linux arm开发
于 2023-10-06 23:04:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46138233/article/details/133621845
版权

备注：

在学习字符设备驱动后，简单做一个总结·，以3568上GPIO为例。

1.驱动加载模块步骤

1.申请字符号

2.添加字符设备

3.生成设备节点

2.申请设备号

每一个设备都具有唯一的一个设备号，先申请设备号，后面对设备的所有描述都是通过设备号唯一确认的。

设备号类型：dev_t 。 dev_t 是一个无符号的 32 位整形类型（unsigned int），其中高 12 位表示主设备号，低 20 位表示次设备号。在“内核源码/include/linux/kdev_t.h”中提供了设备号相关的宏定义。申请设备号有两种方式，一种是静态申请，一种是动态申请。静态申请就是自己设置主次设备号，动态申请是由系统分配，动态申请可以避免设备号重复。

2.1静态申请设备号

函数原型

register_chrdev_region(dev_t from, unsigned count, const char *name);

from: 自定义的 dev_t 类型设备号 表示设备号的起始值

count: 申请设备的数量（次设备）
name: 申请的设备名称
函数返回值：申请成功返回 0，申请失败返回负数

2.2动态申请设备号

函数原型

alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name);

dev *: 会将申请完成的设备号保存在 dev 变量中
baseminor: 次设备号的起始地址，一般次设备号从0开始
count: 申请设备的数量（次设备）
name: 申请的设备名称
函数返回值：申请成功返回 0，申请失败返回负数

2.3使用动态设备号完成申请设备号举例

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

#define GPIO_DR 0xFDD60000
struct device_info{
	dev_t dev_num; //设备号
	int major ; //主设备号
	int minor ; //次设备号
	struct cdev cdev_info; // cdev
	struct class *class; //类
	struct device *device; //设备
	char kbuf[32];
	unsigned int *gpio0_B7;
};
struct device_info dev1;
static int __init chr_gpio0_B7_init(void)
{

    int ret;
	/*1 创建设备号*/
	ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "number_gpio0_B7"); //动态分配设备号
	if (ret < 0)
	{
		return -1;
	}
	dev1.major = MAJOR(dev1.dev_num); //获取主设备号
	dev1.minor = MINOR(dev1.dev_num); //获取次设备号



}

结构体device_info中包含一个字符设备的信息，后面会逐步将这个字符设备的信息补全。这里是对设备号的申请。

这里主要先看初始化函数里面的内容，通过alloc_chrdev_region(&dev1.dev_num, 0, 1, "gp");动态方式申请一个设备号，设备号放在dev1.dev_num中。

3.添加字符设备

在Linux中使用cdev结构体描述一个字符设备，cdev结构体定义在linux/linux/cdev.h文件中，结构体如下

struct cdev {
struct kobject kobj; 
struct module *owner; //该字符设备所在的内核模块的对象指针
const struct file_operations *ops; //该结构描述了字符设备所能实现的方法
struct list_head list; 
dev_t dev; //字符设备的设备号，由主设备号和次设备号构成
unsigned int count; //隶属于同一主设备号的次设备号的个数.
};

在结构体中，包含了一个file_operations结构体，它是系统调用和驱动的一个桥梁，通过这个桥梁我们能用系统调用的函数与驱动中的函数对应上。

file_operations定义在linux/fs.h中
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 (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	int (*readdir) (struct file *, void *, filldir_t);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
	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 *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, struct dentry *, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
	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 (*dir_notify)(struct file *filp, unsigned long arg);
	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);
    }；
   // 常用定义
static struct file_operations cdev_gpio0_B7 = {
.owner = THIS_MODULE,//将 owner 字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
.open = chrdev_open,//将 open 字段指向 chrdev_open(...)函数
.read = chrdev_read,//将 read字段指向 chrdev_read(...)函数
.write = chrdev_write,//将 write 字段指向 chrdev_write(...)函数
.release = chrdev_release,//将release 字段指向 chrdev_release(...)函数，对应应用程序中close()函数
};
//在应用程序中使用open函数
fd=open("/dev/gpio0_B7",O_RDWR);
//驱动中open函数
static int chrdev_open(struct inode *inode, struct file *file)
{

return 0;
}
//调用open函数就会调用驱动中的chrdev_open函数

3.1初始化设备结构体

cdev_init函数用于初始化cdev结构体成员，建立cdev和file_operations之间的关系。

void cdev_init(struct cdev *, const struct file_operations *){
    menset(cdev,0,sizeof *cdev);
    INIT_LIST_HEAD(&cdev->list);
    kobject_init(&cdev->kobj,&ktype_cdev_default);
    cdev->ops = fops;

}

3.2添加一个设备结构体

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

(1)第一个参数为要添加的 struct cdev 类型的结构体

(2)第二个参数为申请的字符设备号

(3)第三个参数为该设备的数量。 这两个参数直接赋值给 struct cdev 的 dev 成员和 count 成员。

函数返回值：添加成功返回 0，添加失败返回负数。

3.3添加字符设备代码

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

#define GPIO_DR 0xFDD60000
struct device_info{
	dev_t dev_num; //设备号
	int major ; //主设备号
	int minor ; //次设备号
	struct cdev cdev_info; // cdev
	struct class *class; //类
	struct device *device; //设备
	char kbuf[32];
	unsigned int *gpio0_B7;
};
//定义一个结构体变量
struct device_info dev1;

static struct file_operations cdev_gpio0_B7 = {
.owner = THIS_MODULE,//将 owner 字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
.open = chrdev_open,//将 open 字段指向 chrdev_open(...)函数
.read = chrdev_read,//将 read字段指向 chrdev_read(...)函数
.write = chrdev_write,//将 write 字段指向 chrdev_write(...)函数
.release = chrdev_release,//将release 字段指向 chrdev_release(...)函数，对应应用程序中close()函数
};

static int chrdev_open(struct inode *inode, struct file *file)
{

	return 0;
}

/*向设备写入数据函数*/
static ssize_t chrdev_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	
	return 0;
}

/**从设备读取数据*/
static ssize_t chrdev_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
	
	return 0;
}

static int chrdev_release(struct inode *inode, struct file *file)
{
		
		return 0;
}

static int __init chr_gpio0_B7_init(void)
{

    int ret;
	/*1 创建设备号*/
	ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "number_gpio0_B7"); //动态分配设备号
	if (ret < 0)
	{
		return -1;
	}
	dev1.major = MAJOR(dev1.dev_num); //获取主设备号
	dev1.minor = MINOR(dev1.dev_num); //获取次设备号
	/*2 初始化 cdev*/
	dev1.cdev_test.owner = THIS_MODULE;
	cdev_init(&dev1.cdev_info, &cdev_gpio0_B7);
	/*3 添加一个 cdev,完成字符设备注册到内核*/
	ret = cdev_add(&dev1.cdev_info, dev1.dev_num, 1);
	if(ret<0)
	{
		
	}


}

在上面代码中新增加4个函数 chrdev_open(), chrdev_read,  chrdev_write, chrdev_release。通过结构体struct file_operations cdev_gpio0_B7将这四个函数分别与操作系统中open(),read(),write(),close()函数对应。

通过初始化函数cdev_init(&dev1.cdev_info, &cdev_gpio0_B7);将它的信息初始化给我们设备中的cdev即dev1.cdev_info。

再使用cdev_add(&dev1.cdev_info, dev1.dev_num, 1);添加设备到内核中，并且与设备号进行绑定

4.生成设备节点

在linux中，每个设备在Linux系统中都有一个对应的“设备文件”代表他们，应用程序通过操作这个“设备文件”，便可以操作对应的硬件。

如fd=open("/dev/hello",O_RDWR);

打开的设备文件/dev/hello就是设备节点。所以Linux设备节点是应用程序沟通的一个桥梁。设备节点被创建在dev目录下。

如在图中 tty,tty0,tty1代表设备文件既设备节点，第一个字符C代表它是字符设备，tty0中的4代表主设备号，0代表次设备号。通过主设备号找到他对应的file_operations结构体。通过次设备号找到是同类设备的第几个，就确定了是哪个驱动。

创建设备节点也有两种方式，手动创建和自动创建

1、手动创建设备节点

通过命令mknod创建

mknod NAME TYPE MAJOR MINOR
NAME: 要创建的节点名称
TYPE: b 表示块设备，c 表示字符设备，p 表示管道
MAJOR：要链接设备的主设备号
MINOR: 要链接设备的从设备号
/*例如使用以下命令创建一个名为 my_device 的字符设备节点，链接设备的主设备号和从设备号分别为 123 和 0：*/
mknod /dev/my_device c 123 0

2、自动创建

udev机制:Linux中可以通过udev来实现设备节点的创建与删除，udev是一个用户程序，可以根据系统中设备的状态来创建或删除设备节点，比如当驱动程序成功加载到Linux时会自动在/dev目录下创建对应的设备节点，当驱动程序卸载的时候会自动删除/dev目录下设备节点。在嵌入式Linux中我们使用的是mdev,mdev是udev的简化版本。在使用busybox构建根文件系统的时候，busybox会自动创建mdev.

在加载设备驱动的时候，udev会去 /sys/class/xxx 寻找相关信息来创建 /dev/xxx 设备节点，所以要创建设备节点需要先创建类

4.1创建类

使用 class_create(owner, name)来创建类放在/sys/class/

class_create定义在/linux/device.h中
owner：struct module 结构体类型的指针，指向函数即将创建的这个 struct class 的模块。一般赋值为 THIS_MODULE。
name：char 类型的指针，代表即将创建的 struct class 变量的名字。也就是/sys/class/xxx 中的xxx
返回值：struct class * 类型的结构体。

删除设备逻辑类（删除类） extern void class_destroy(struct class *cls);

4.2创建设备

使用class_create创建好类以后，还需要使用device_create函数在类下面创建一个设备。定义在include/linux/device.h

struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);

函数作用：
用来在 class 类中下创建一个设备属性文件，udev 会自动识别从而进行设备节点的创建。
参数含义：
cls：指定所要创建的设备所从属的类。
parent:指定该设备的父设备，如果没有就指定为 NULL。
devt:指定创建设备的设备号。
drvdata:被添加到该设备回调的数据，没有则指定为 NULL。
fmt：添加到系统的设备节点名称。就是/dev/xxx  中的xxx
extern void device_destroy(struct class *cls, dev_t devt);
用来删除 class 类中的设备属性文件，udev 会自动识别从而进行设备节点的删除。
参数含义：
cls：指定所要创建的设备所从属的类。
devt:指定创建设备的设备号。

4.3代码补充

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

#define GPIO_DR 0xFDD60000
struct device_info{
	dev_t dev_num; //设备号
	int major ; //主设备号
	int minor ; //次设备号
	struct cdev cdev_info; // cdev
	struct class *class; //类
	struct device *device; //设备
	char kbuf[32];
	unsigned int *gpio0_B7;
};
//定义一个结构体变量
struct device_info dev1;

static struct file_operations cdev_gpio0_B7 = {
.owner = THIS_MODULE,//将 owner 字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
.open = chrdev_open,//将 open 字段指向 chrdev_open(...)函数
.read = chrdev_read,//将 read字段指向 chrdev_read(...)函数
.write = chrdev_write,//将 write 字段指向 chrdev_write(...)函数
.release = chrdev_release,//将release 字段指向 chrdev_release(...)函数，对应应用程序中close()函数
};

static int chrdev_open(struct inode *inode, struct file *file)
{

	return 0;
}

/*向设备写入数据函数*/
static ssize_t chrdev_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	
	return 0;
}

/**从设备读取数据*/
static ssize_t chrdev_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
	
	return 0;
}

static int chrdev_release(struct inode *inode, struct file *file)
{
		
		return 0;
}

static int __init chr_gpio0_B7_init(void)
{

    int ret;
	/*1 创建设备号*/
	ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "number_gpio0_B7"); //动态分配设备号
	if (ret < 0)
	{
		return -1;
	}
	dev1.major = MAJOR(dev1.dev_num); //获取主设备号
	dev1.minor = MINOR(dev1.dev_num); //获取次设备号
	/*2 初始化 cdev*/
	dev1.cdev_test.owner = THIS_MODULE;
	cdev_init(&dev1.cdev_info, &cdev_gpio0_B7);
	/*3 添加一个 cdev,完成字符设备注册到内核*/
	ret = cdev_add(&dev1.cdev_info, dev1.dev_num, 1);
	if(ret<0)
	{
		
	}
dev1. class = class_create(THIS_MODULE, "gpio0_B7_class");
	if(IS_ERR(dev1.class))
	{
		
	}
	/*5 创建设备*/
	dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "gpio0_B7_device");
	if(IS_ERR(dev1.device))
	{
	
	}


}

通过class_create(THIS_MODULE, "gpio0_B7_class");创建一个类，再通过dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "gpio0_B7_device");将类与设备号绑定，设置好设备的名称到此一个字符设备就完成了。

5.其他补充

5.1用户数据和内核数据交换

不能在用户态自接修改内核中的数据，即要想获取用户传递过来的信息需要先通过copy_from_user（）函数获取，不能将用户数据直接赋值给驱动中的变量，也就不能将用户传递的变量作为判断条件。

定义在了 kernel/include/linux/uaccess.h 文件下

unsigned long copy_to_user_inatomic(void __user *to, const void *from, unsigned long n);
copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf))
函数作用：
把内核空间的数据复制到用户空间。
参数含义：
*to 是用户空间的指针
*from 是内核空间的指针
n 是从内核空间向用户空间拷贝的字节数
unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
copy_from_user(test_dev->kbuf, buf, size)
函数作用：
把用户空间的数据复制到内核空间。
参数含义：
*to 是内核空间的指针

5.2私有数据

当同一类设备有多个驱动时，在申请时申请了多个，如GPIO(0-7)，这些设备主设备号相同次设备号不同。使用私有数据可以更方便。

在前面定义一个设备时，至少需要定义设备号，主设备号,次设备号，设备类，设备节点等全局变量，当需要多个同类设备时，使用全局变量就不方便管理。

//全局变量方式
dev_t dev_num; //设备号
int major=0 ; //主设备号
int minor=0 ; //次设备号
struct cdev cdev_test; // cdev
struct class *class; //类
struct device *device; //设备
char kbuf[32];
unsigned int *vir_gpio_dr;

//私有数据方式
struct device_test{
dev_t dev_num; //设备号
int major ; //主设备号
int minor ; //次设备号
struct cdev cdev_test; // cdev
struct class *class; //类
struct device *device; //设备
char kbuf[32];
unsigned int *vir_gpio_dr;
};
struct device_test dev1;
struct device_test dev2;
//如果该类设备只有一个，则可以在open函数中定义
file->private_data=&dev1;
//在read和write中
struct device_test *test_dev=(struct device_test *)file->private_data;
//通过操作test_dev结构体的成员变量来操作设备
//在驱动入口函数中对结构体变量赋值
ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "alloc_name"); //动态分配设备号
dev1.major = MAJOR(dev1.dev_num); //获取主设备号
dev1.minor = MINOR(dev1.dev_num); //获取次设备号
/*2 初始化 cdev*/
dev1.cdev_test.owner = THIS_MODULE;
cdev_init(&dev1.cdev_test, &cdev_test_fops);
/*3 添加一个 cdev,完成字符设备注册到内核*/
ret = cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
/*4 创建类*/
dev1. class = class_create(THIS_MODULE, "test");
/*5 创建设备*/
dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "test");


//如果有多个设备可以使用container_of函数来判断操作的时哪个设备
//函数原型：
container_of(ptr,type,member)
//函数作用：
//通过结构体变量中某个成员的首地址获取到整个结构体变量的首地址。
//参数含义：
//ptr 是结构体变量中某个成员的地址。
//type 是结构体的类型
//member 是该结构体变量的具体名字
static int cdev_test_open(struct inode *inode,struct file *file);
//在应用层使用fopen函数打开设备时，需要传入设备节点名 如/dev/gpio1 或 /dev/gpio0，根据不同的节点名找到对应的设备
//上层应用程序调用open()系统调用打开/dev/xxx设备节点时，最终会调用cdev->ops->open()。
//即调用函数int (*open) (struct inode *, struct file *);
struct inode *inode中保存传入设备的信息为gpio1还是gpio0，就可以获取到设备号，根据cdev确认打开的是哪个设备
//在open函数中
dev1.minor = 0; //设置 dev1 的次设备号为 0
dev2.minor = 1; //设置 dev2 的次设备号为 1
//inode->i_cdev 为该 inode 的cdev结构体，使用 container_of 函数找到结构体变量 dev1 dev2 的地址
//然后设置私有数据
file->private_data = container_of(inode->i_cdev, struct device_test, cdev_test);
在read和write根据次设备号完成对不同设备操作
struct device_test *test_dev = (struct device_test *)file->private_data;
//如果次设备号是 0，则为 dev1
if (test_dev->minor == 0)
{
}
//如果次设备号是 1，则为 dev2
else if(test_dev->minor == 1)
{

}

5.3物理地址映射

控制GPIO灯

在驱动中不能直接修改物理地址中寄存器的值，需要将物理地址映射后，修改虚拟地址中的值

在头文件<linux/io.h>

GPIO0_B7的数据寄存器为0xFDD60000

使用函数ioremap(0xFDD60000,4);转换地址为0xFDD60000，大小为4个字节

iounmap（FDD60000）转换失败使用取消转换函数

5.4错误处理

在编写驱动程序时，驱动程序应该提供函数执行失败后处理的能力。如果驱动程序中函数
执行失败了，必须取消掉所有失败前的注册，否则内核会处于一个不稳定的状态，因为它包含
了不存在代码的内部指针。在处理 Linux 错误时，最好使用 goto 语句。当错误发生时通过错误处理将设备去除掉。

6.代码汇总

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/io.h>
 
#define GPIO_DR 0xFDD60000
struct device_info{
	dev_t dev_num; //设备号
	int major ; //主设备号
	int minor ; //次设备号
	struct cdev cdev_info; // cdev
	struct class *class; //类
	struct device *device; //设备
	char kbuf[32];
	unsigned int *gpio0_B7_register;
};
//定义一个结构体变量
struct device_info dev1;
 
 
static int chrdev_open(struct inode *inode, struct file *file)
{
file->private_data=&dev1;//设置私有数据
	return 0;
}

 
/*向设备写入数据函数*/
static ssize_t chrdev_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	struct device_info *dev=(struct device_info *)file->private_data;
	if (copy_from_user(dev->kbuf, buf, size) != 0) // copy_from_user:用户空间向内核空间传数据
	{
		
		return -1;
	}
	if(dev->kbuf[0]==1){ //如果应用层传入的数据是 1，则打开灯
		*(dev->gpio0_B7_register) = 0x8000c040; //设置数据寄存器的值0x8000c040开灯	
	}
	else if(dev->kbuf[0]==0){ //如果应用层传入的数据是 0，则关闭灯
		*(dev->gpio0_B7_register) = 0x80004040; //设置数据寄存器的值0x80004040关灯
	}
	return 0;
}
 
/**从设备读取数据*/
static ssize_t chrdev_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
		struct device_info *dev=(struct device_info *)file->private_data;
	if (copy_to_user(buf, dev->kbuf, strlen( dev->kbuf)) != 0) // copy_to_user:内核空间向用户空
																		//间传数据
	{
		
		return -1;
	}
	return 0;
}
 
static int chrdev_release(struct inode *inode, struct file *file)
{
 
		return 0;
}

static struct file_operations cdev_gpio0_B7 = {
  .owner = THIS_MODULE,//将 owner 字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
  .open = chrdev_open,//将 open 字段指向 chrdev_open(...)函数
  .read = chrdev_read,//将 read字段指向 chrdev_read(...)函数
  .write = chrdev_write,//将 write 字段指向 chrdev_write(...)函数
  .release = chrdev_release,//将release 字段指向 chrdev_release(...)函数，对应应用程序中close()函数
  };
  static int __init chr_gpio0_B7_init(void)
{
 
    int ret;
	/*1 创建设备号*/
	ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "number_gpio0_B7"); //动态分配设备号
	if (ret < 0)
	{
	goto err_chrdev;
		return -1;
	}
	dev1.major = MAJOR(dev1.dev_num); //获取主设备号
	dev1.minor = MINOR(dev1.dev_num); //获取次设备号
	/*2 初始化 cdev*/
	dev1.cdev_info.owner = THIS_MODULE;
	cdev_init(&dev1.cdev_info, &cdev_gpio0_B7);
	/*3 添加一个 cdev,完成字符设备注册到内核*/
	ret = cdev_add(&dev1.cdev_info, dev1.dev_num, 1);
	if(ret<0)
	{
		goto err_chr_add;
	}
dev1. class = class_create(THIS_MODULE, "gpio0_B7_class");
	if(IS_ERR(dev1.class))
	{
		ret=PTR_ERR(dev1.class);
		goto err_class_create;
	}
	/*5 创建设备*/
	dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "gpio0_B7_device");
	if(IS_ERR(dev1.device))
	{
	ret=PTR_ERR(dev1.device);
		goto err_device_create;
	}
dev1.gpio0_B7_register=ioremap(GPIO_DR,4); //将物理地址转化为虚拟地址,长度为4
	if(IS_ERR(dev1.gpio0_B7_register))
	{
		ret=PTR_ERR(dev1.gpio0_B7_register); //PTR_ERR()来返回错误代码
		goto err_ioremap;
	}
	return 0;
err_ioremap:
	iounmap(dev1.gpio0_B7_register);
err_device_create:
	class_destroy(dev1.class); //删除类
err_class_create:
	cdev_del(&dev1.cdev_info); //删除 cdev
err_chr_add:
	unregister_chrdev_region(dev1.dev_num, 1); //注销设备号
err_chrdev:
	return ret;
 
}
static void __exit chr_fops_exit(void) //驱动出口函数
{
/*注销字符设备*/
	unregister_chrdev_region(dev1.dev_num, 1); //注销设备号
	cdev_del(&dev1.cdev_info); //删除 cdev
	device_destroy(dev1.class, dev1.dev_num); //删除设备
	class_destroy(dev1.class); //删除类
	iounmap(dev1.gpio0_B7_register);
}
module_init(chr_gpio0_B7_init);
module_exit(chr_fops_exit);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("guo");

一个完整操作GPIO字符设备代码

小九飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux字符设备驱动程序学习笔记
06-30
字符设备是一种按字节来访问的设备，字符驱动则负责驱动字符设备，这样的驱动通常实现 open、close、read 和 write 系统调用。 Linux 驱动程序可以分为三类：字符设备驱动、网络接口驱动和块设备驱动。字符设备驱动...
Linux内核设备驱动之Linux内核基础笔记整理
09-15
Linux内核设备驱动的学习是一个深入的过程，涵盖了从简单的字符设备驱动到复杂的网络和存储驱动的广泛内容。通过不断地实践和学习，开发者可以掌握驱动开发的精髓，为Linux系统提供强大的硬件支持。
linux字符设备驱动开发（设备号的注册和设备结点的创建）
qq_45001063的博客
12-11 890
自动创建设备节点的工作是在驱动程序的入口函数中完成的，一般在 cdev_add 函数后面添加自动创建设备节点相关代码。本节就来讲解一下如何实现自动创建设备节点，在驱动中实现自动创建设备节点的功能以后，使用 modprobe 加载驱动模块成功的话就会自动在/dev 目录下创建对应的设备文件。卸载驱动的时候一定要使用 cdev_del 函数从 Linux 内核中删除相应的字符设备，cdev_del。参数 class 是要删除的设备所处的类，参数 devt 是要删除的设备号。返回值就是创建好的设备。
linux设备号静态申请,设备号的静态申请与动态分配
weixin_39826984的博客
05-10 208
设备号的静态申请与动态分配(2013-01-15 22:01:24)设备号是在驱动module中分配并注册的，也就是说，驱动module拥有这个设备号(我的理解)，而/dev目录下的设备文件是根据这个设备号创建的，因此，当访问/dev目录下的设备文件时，驱动module就知道，自己该出场服务了(当然是由内核通知)。在Linux内核看来，主设备号标识设备对应的驱动程序，告诉Linux内核使用哪一个驱...
Linux下静态/动态申请字符类设备号
西岸贤
10-29 1603
字符设备是指以字符为单位进行I/O传输的设备，例如键盘，打印机等，字符设备也拥有相应的结点。字符设备可以使用与普通文件相同的文件操作命令对字符设备文件进行打开、关闭、读写等操作。字符设备和杂项设备的区别：杂项设备的主设备号是固定的，为10，字符类设备的主设备号需要通过静态方式自己分配或者由系统来动态分配。杂项设备可以自动生成设备节点，字符设备需要我们自己生成设备节点。
Linux字符设备驱动模型之设备号
ymj321的专栏
11-01 369
从上文（Linux 字符设备驱动模型之框架解说）可知，在Linux用户空间中，如若需要操作硬件设备，均通过/dev目录下的设备文件节点进行操作，基本上每一种设备都会存在一个或者多个的设备节点。 并且在Linux内核中，其表示字符设备的结构成员也提供了相应的设备号。 设备号成员为dev_t dev;那么其与设备之间的关系是什么呢？它又与用户空间的操作是和关系？？ 一、设备号 那么设备文件节点...
Linux 学习笔记：Linux 字符设备 驱动--1
gdut_liujiangyi的专栏
05-11 457
一、Linux 驱动概述 1.1 Linux 中的三大类驱动 块设备和网络设备驱动要比字符设备驱动复杂，半导体厂商一般都给我们编写好了，大多数情况下都是直接使用。 1.1.1 字符设备驱动 字符设备是Linux 驱动中最基本的一类设备驱动，字符设备就是一个个字节，安好字节流进行读写操作的设备，读写数据是分先后顺序的。例如我们最常见的点灯、按键、IIC、SPI 等都是字符设备，这些设备的驱动就叫做字符设备驱动。 1.1.2 块设备驱动 所谓块设备驱动就是存储器设备的驱动，比如EMMC，NAND、SD卡和U盘等
Linux 驱动学习笔记 ——（1）字符设备驱动
Super辉sir的博客
07-07 4049
字符设备是 Linux 驱动中最基本的一类设备驱动，字节设备就是按照字节流来读写的设备，常见的字符设备包括：LED、蜂鸣器、按键、I2C 以及 SPI 等。
Linux驱动开发笔记（一）字符驱动
sincerelover的博客
04-19 1041
本文将通过字符驱动正式展开Linux驱动开发的学习。
LDD学习笔记 -- Linux字符设备驱动
weixin_42040046的博客
01-07 1122
例如前面的伪字符设备，有一块内存数组（设备内存buffer）。当用户程序在该设备文件上发出read系统调用时，应该将数据从设备buffer传到用户buffer。设备创建时候在VFS注册设备号，虚拟文件系统，将设备文件的设备号与驱动程序列表进行比较，选择正确的驱动程序，并将用户请求连接到对应驱动程序的文件操作方法。用户空间的指针不是完全可信的，用户地址空间有时可能无效，虚拟内存管理器可以交换出这些内存位置。字符设备指的是像内存区域这样的硬件组件，通常称为伪设备；可以动态申请主设备号，保证唯一性，传输设备号（
【嵌入式环境下linux内核及驱动学习笔记-（3-字符设备驱动详解）】
weixin_45499326的博客
04-10 1520
项目说明语法功能将主设备号和次设备号转换成dev_t类型头文件参数major为主设备号，minor为次设备号宏定义返回值成功执行返回dev_t类型的设备编号变量用途说明设备号，标识设备的身份标号，可以解析出主设备号与次设备号创建于驱动加载之时，也存于cdev结构体内表示设备的结构体，将设备号与操作函数结构体file_operations关联起来创建于驱动加载之时，加载到内核的cdev链表中驱动实际操作的函数入口，是具体的设备驱动函数集合的入口。
Linux 学习笔记：Linux MISC 驱动
gdut_liujiangyi的专栏
11-23 457
misc 杂项驱动
linux字符设备驱动学习笔记借鉴.pdf
12-01
Linux 字符设备驱动学习笔记 本文档主要讲述 Linux 字符设备驱动学习笔记，涵盖了设备文件、主次设备号、字符设备驱动中的数据结构等知识点。 一、 设备文件 设备文件是一种特殊类型的文件，用来代表一个设备。...
linux字符设备驱动学习笔记文.pdf
11-04
Linux字符设备驱动是操作系统与硬件设备交互的关键组件，它提供了软件层面与硬件设备通信的接口。在Linux系统中，设备通常被表示为文件，这种特殊类型的文件被称为设备文件。设备文件使得用户空间的应用程序能够通过...
Linux 定时任务
flash的博客
08-14 407
在Linux系统中，cron是一个广泛使用的定时任务工具，允许用户安排周期性执行的任务（脚本或命令）。cron守护进程（crond）会读取配置文件（通常位于/etc/crontab），并根据这些配置文件中指定的时间规则来执行相应的任务。
linux：有关目录、链接文件的函数 Makefil、gdb的使用
T66656的博客
08-15 1023
功能:根据用户id到/etc/passwd文件下解析获得结构体信息参数:uid:用户id返回值:成功返回id对应用户的信息失败返回NULLpasswd结构体的定义通常如下所示。
linux开启RNDIS，实现虚拟网卡
轩辕霸天L
08-15 494
首先要 `make clean`，清空之前的编译结果。
Linux~MySQL数据库具体操作
最新发布
javaMov的专栏
08-15 337
第二种：mysql -u root -p -e "CREATE DATABASE my_new_database;performance_schema : #【默认】：系统运行的状态信息，性能信息的存储库；语法：【mysqldump -uroot -p1 [备份参数] > /路径/文件名.sql】information_schema ：【默认】：系统运行的状态信息，性能信息的存储库；2.-B 数据库名 #备份指定数据库的数据信息。-B 数据库名 #备份指定数据库的数据信息。注意：需要先关闭数据库进行操作。
Linux设备驱动学习笔记：字符设备驱动实战
“Linux设备驱动程序的学习笔记，涵盖了字符设备驱动的编写，包括NFS挂载、字符设备驱动的基本操作如open、write、close的实现，以及file_operations结构体的使用和驱动注册。” 在Linux操作系统中，设备驱动是操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值