4412开发板学习之Linux驱动开发（六）：字符设备驱动的基本操作(申请设备号、注册设备）

前言

一开始纠结了半天这篇博客应该叫什么，本来想叫字符设备驱动开发流程，但是转念一想现在仅仅是学了一些皮毛，也仅仅是字符设备驱动的一些最基本的东西，仅仅是把前面杂项设备那里系统给完成的东西自己来实现了而已，除此之外并没有太多新的知识。
字符设备驱动是驱动开发最为重要的一个部分，绝大多数的设备都是字符设备，所以说掌握字符设备的开发是驱动工程师必须的要求，路漫漫其修远兮。

给模块传递参数

在介绍字符设备驱动的基本操作前先说一下如何给模块传递参数，类似于main函数的参数传递，当我们使用insmod加载模块时，是可以给模块传递参数的，这样就可以在模块中根据参数的不同实现不同的功能。

传递单个参数

头文件在linux/moduleparam.h
内核模块可以通过module_param来传单个参数

#define module_param(name, type, perm)	\
	module_param_named(name, name, type, perm)

• name：模块参数的名称
• type：模块参数的数据类型（支持int long short uint ulong ushort）
• perm：模块参数的访问权限（S_IRUSR参数表示所有文件所有者可读）
  参数perm表示此参数在sysfs文件系统中所对应的文件节点的属性，其权限在linux/stat.h中有定

	#define S_IRWXU 00700
	#define S_IRUSR 00400
	#define S_IWUSR 00200
	#define S_IXUSR 00100
	
	#define S_IRWXG 00070
	#define S_IRGRP 00040
	#define S_IWGRP 00020
	#define S_IXGRP 00010
	
	#define S_IRWXO 00007
	#define S_IROTH 00004
	#define S_IWOTH 00002
	#define S_IXOTH 00001

将最后三位转换为2进制 xxx xxx xxx 对应权限

传递多个参数

通过调用module_param_array

#define module_param_array(name, type, nump, perm)		\
	module_param_array_named(name, name, type, nump, perm)

• name：模块参数的名称
• type：模块参数的数据类型（支持int long short uint ulong ushort）
• nump：保存参数个数的地址
• perm：模块参数的访问权限

实验

代码

#include 
#include 
/*定义module_param module_param_array的头文件*/
#include 
/*定义module_param module_param_array中的参数perm的头文件*/
#include 

MODULE_LICENSE("Dual BSD/GPL");

MODULE_AUTHOR("GYY");

static int module_arg1,module_arg2;
static int int_array[50];
static int int_num;

module_param(module_arg1,int,S_IRUSR);//传递单个参数module_arg1
module_param(module_arg2,int,S_IRUSR);//传递单个参数module_arg2
module_param_array(int_array,int,&int_num,S_IRUSR);//传递多个参数，使用int_array接收

static int hello_init(void)
{
	int i;
	printk(KERN_EMERG "Hello World enter!\n");
	/*打印参数*/
	printk(KERN_EMERG "module_arg1 is %d \n",module_arg1);
	printk(KERN_EMERG "module_arg2 is %d \n",module_arg2);
	/*开始打印参数数组*/
	printk(KERN_EMERG "int_array start \n");
	for(i=0;i<int_num,i++)
	{
		printk(KERN_EMERG "module_arg%d is %d \n",i,int_array[i]);
	}
	return 0;
}

static void hello_exit(void)
{
	printk(KERN_EMERG "Hello World exit!\n");
}

module_init(hello_init);
module_exit(hello_exit);

代码分析

该代码实现了单个参数和多个参数的参数传递，在加载模块的时候向模块传递参数，然后模块运行时会将传递的参数依次打印出来

效果

传递参数

可以看出模块将我们传递的参数打印了出来
查看参数
在 /sys/module/模块名 的文件夹中存放了该模块的相关信息

其中parameters文件夹就是关于模块参数的文件夹

我们可以通过这样的方式来查看参数

申请字符类设备号

设备号包括主设备号和次设备号
前面介绍注册是杂项设备，主设备号已经固定（10）

静态申请字符类设备号

字符设备函数在/linux/fs.h中
内核提供了三个函数来注册一组字符设备编号

• register_chrdev()：老版本的设备号注册方式，只分配主设备号，从设备号再mknod的时候指定
• register_chrdev_region()：提前知道设备的主次设备号再去申请设备号
• alloc_chrdev_region()：动态分配主次设备号

重要的头文件

• 字符设备函数在/linux/fs.h中
  内核提供了三个函数来注册一组字符设备编号
  register_chrdev()：老版本的设备号注册方式，只分配主设备号，从设备号再mknod的时候指定
  register_chrdev_region()：提前知道设备的主次设备号再去申请设备号
  alloc_chrdev_region()：动态分配主次设备号
• 宏定义MKDEV的头文件 /linux/kdev_t.h
  有一系列设备号处理的宏命令，用于处理各种设备号的相关数据
• /linux/cdev.h
  cdev类型是字符设备描述的结构体
  其中的设备号必须用dev_t类型来描述，高12位为主设备号，低20位为次设备号

函数功能

extern int register_chrdev_region(dev_t, unsigned, const char *);

第一个参数为dev_t格式的设备号，第二个参数为设备数量，第三个参数为设备名

#define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi))

将主设备号和次设备号转换为dev_t的格式

实验

查看已经使用的设备号

cat /proc/devices

可以看到没有使用9

代码

#include 
#include 
/*定义module_param module_param_array的头文件*/
#include 
/*定义module_param module_param_array中的参数perm的头文件*/
#include 
/*三个字符设备注册函数*/
#include 
/*宏定义MKDEV的头文件，MKDEV转换设备号数据类型*/
#include 
/*定义字符设备的结构体*/
#include 

#define DEVICE_NEME "scdev"
#define DEVICE_MINOR_NUM 2
#define DEV_MAJOR 0
#define DEV_MINOR 0
MODULE_LICENSE("Dual BSD/GPL");

MODULE_AUTHOR("GYY");

int numdev_major = DEV_MAJOR;
int numdev_minor = DEV_MINOR;
/*输入主设备号*/
module_param(numdev_major,int,S_IRUSR);
/*输入次设备号*/
module_param(numdev_minor,int,S_IRUSR);

static int chardev_init(void)
{
	int ret;
	dev_t num_dev;
	
	printk(KERN_EMERG "chardev World enter!\n");
	printk(KERN_EMERG "numdev_major is %d \n",numdev_major);
	printk(KERN_EMERG "numdev_minor is %d \n",numdev_minor);
	
	if(numdev_major)
	{
		num_dev = MKDEV(numdev_major,numdev_minor);
		ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NEME);
	}
	else
	{
		printk(KERN_EMERG "numdev_major %d is faileed",numdev_major);
		return 0;
	}
	
	if(ret<0)
	{
		printk(KERN_EMERG "register_chrdev_region req %d is faileed",numdev_major);
	}
	return 0;
}

static void chardev_exit(void)
{
	printk(KERN_EMERG "chardev World exit!\n");
	unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
}

module_init(chardev_init);
module_exit(chardev_exit);

代码分析

我们通过参数传递的方式来指定主设备号和次设备号，然后在chardev_init()函数中调用register_chrdev_region()来进行设备号的注册，在调用之前先使用MKDEV宏定义将主设备号和次设备号转换为dev_t 的格式（高12位为主设备号，低20位为次设备号），执行成功应当生成名为scdev的设备

效果

加载模块

查看设备

可以看到我们生成了名为scdev的设备

动态申请字符类设备号

函数功能

extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);//动态分配主次设备号

第一个参数

#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))

MAJOR宏定义用于获取主设备号
MINOR宏定义用于获取次设备号

实验

代码

#include 
#include 
/*定义module_param module_param_array的头文件*/
#include 
/*定义module_param module_param_array中的参数perm的头文件*/
#include 
/*三个字符设备注册函数*/
#include 
/*宏定义MKDEV的头文件，MKDEV转换设备号数据类型*/
#include 
/*定义字符设备的结构体*/
#include 

#define DEVICE_NEME "ascdev"
#define DEVICE_MINOR_NUM 2
#define DEV_MAJOR 0
#define DEV_MINOR 0
MODULE_LICENSE("Dual BSD/GPL");

MODULE_AUTHOR("GYY");

int numdev_major = DEV_MAJOR;
int numdev_minor = DEV_MINOR;

/*输入主设备号*/
module_param(numdev_major,int,S_IRUSR);
/*输入次设备号*/
module_param(numdev_minor,int,S_IRUSR);

static int chardev_init(void)
{
	int ret;
	dev_t num_dev;
	
	printk(KERN_EMERG "chardev World enter!\n");
	printk(KERN_EMERG "numdev_major is %d \n",numdev_major);
	printk(KERN_EMERG "numdev_minor is %d \n",numdev_minor);
	
	if(numdev_major)
	{
		num_dev = MKDEV(numdev_major,numdev_minor);
		ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NEME);
	}
	/*当不输入参数时默认进行动态分配主次设备号*/
	else
	{
		ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NEME);
		/*获取并打印主设备号*/
		numdev_major = MAJOR(num_dev);
		printk(KERN_EMERG "alloc_chrdev_region req %d\n",numdev_major);
	}

	if(ret<0)
	{
		printk(KERN_EMERG "register_chrdev_region req %d is failed",numdev_major);
	}
	
	printk(KERN_EMERG "ascdev_init\n");
	return 0;
}

static void chardev_exit(void)
{
	printk(KERN_EMERG "chardev World exit!\n");
	unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
}

module_init(chardev_init);
module_exit(chardev_exit);

代码分析

该代码是在静态分配设备号的例程上进行修改的，当我们不输入参数时就会动态分配设备号，分配完成后会打印主设备号，动态分配设备号是从高（255）往低找第一个空闲的设备号来分配的，它应当给我们分配248

演示

查看设备

加载模块

可以看出给我们分配的主设备号为248
查看设备

可以看出248号设备为ascdev

注册字符类设备

前面已经申请了设备号
接下来我们需要对设备进行注册

函数及头文件介绍

• 分配内存空间函数kmalloc
  分配连续的虚拟地址，用于小内存分配，在include/linux/slab.h文件中
  void *kmalloc(size_t size, int flags);
  参数1：申请的内存大小（最大128k）
  参数2：GFP_KERNEL，代表优先级，内存不够可以延迟分配
• 清空内存空间的数据函数memset
  可以清空内存空间，也就是去不写为0
  void * memset (void *s ,int c, size_t n);
  参数1：内存地址
  参数2：0
  参数3：内存长度
• 释放内存函数 kfree
  void kfree ( const void * objp);
  参数：数据指针
• 字符设备初始化函数cdev_init
  在头文件include/linux/cdev.h中
  void cdev_init(struct cdev *, const struct file_operations *);
  参数1：cdev字符设备文件结构体
  参数2：file_operations结构体
  注册设备本质是想linux设备文件中添加数据，这些数据需要初始化
• 字符设备注册函数cdev_add
  在头文件include/linux/cdev.h中
  int cdev_add(struct cdev *, dev_t, unsigned);
  参数1：cdev字符设备文件结构体
  参数2：设备号
  参数3：设备范围大小
  向系统注册设备，也就是向linux系统添加数据
• 字符设备卸载函数cdev_del
  void cdev_del(struct cdev *);
  参数1：cdev字符设备文件结构体

实验

代码

#include 
#include 
/*定义module_param module_param_array的头文件*/
#include 
/*定义module_param module_param_array中的参数perm的头文件*/
#include 
/*三个字符设备注册函数*/
#include 
/*宏定义MKDEV的头文件，MKDEV转换设备号数据类型*/
#include 
/*定义字符设备的结构体*/
#include 
/*分配内存空间函数头文件*/
#include 

#define DEVICE_NEME "ascdev"
#define DEVICE_MINOR_NUM 2
#define DEV_MAJOR 0
#define DEV_MINOR 0
#define REGDEV_SIZE 3000
MODULE_LICENSE("Dual BSD/GPL");

MODULE_AUTHOR("GYY");

int numdev_major = DEV_MAJOR;
int numdev_minor = DEV_MINOR;

/*输入主设备号*/
module_param(numdev_major,int,S_IRUSR);
/*输入次设备号*/
module_param(numdev_minor,int,S_IRUSR);

struct reg_dev
{
	char *data;
	unsigned long size;
	
	struct cdev cdev;
};

struct reg_dev *my_devices; 

struct file_operations my_fops = {
	.owner = THIS_MODULE
};
/*设备注册到系统*/
static void reg_init_cdev(struct reg_dev *dev,int index)
{
	int err;
	int devnum = MKDEV(numdev_major,numdev_minor+index);
	/*数据初始化*/
	cdev_init(&dev->cdev,&my_fops);
	dev->cdev.owner = THIS_MODULE;
	dev->cdev.ops = &my_fops;
	
	/*注册到系统*/
	err = cdev_add(&dev->cdev,devnum,1);
	/*打印信息*/
	if(err)
	{
		printk(KERN_EMERG "cdev_add is failed ,err : %d ,index : %d \n",err,index);
	}
	else
	{
		printk(KERN_EMERG "cdev_add is success ,index : %d \n",index);
	}
}

static int chardev_init(void)
{
	int ret,i;
	dev_t num_dev;
	
	printk(KERN_EMERG "chardev_init enter!\n");
	
	printk(KERN_EMERG "numdev_major is %d \n",numdev_major);
	printk(KERN_EMERG "numdev_minor is %d \n",numdev_minor);
	/*如果传入参数的话静态分配设备号*/
	if(numdev_major)
	{
		num_dev = MKDEV(numdev_major,numdev_minor);//转换为内核的设备号格式（高12位为主设备号，低20位为次设备号）
		/*静态分配设备号*/
		ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NEME);
	}
	/*不传入参数的话动态分配设备号*/
	else
	{
		/*动态分配设备号*/
		ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NEME);
		numdev_major = MAJOR(num_dev);//使用MAJOR宏定义获取主设备号
		printk(KERN_EMERG "alloc_chrdev_region req %d\n",numdev_major);//打印主设备号
	}
	/*如果分配设备号失败*/
	if(ret<0)
	{
		printk(KERN_EMERG "alloc_chrdev_region req %d is failed",numdev_major);
		return 0;
	}
	/*给my_devices结构体分配内存*/
	my_devices = kmalloc(DEVICE_MINOR_NUM*sizeof(struct reg_dev),GFP_KERNEL);
	/*如果内存分配失败，返回错误*/
	if(!my_devices)
	{
		ret = -ENOMEM;
		goto fail;
	}
	/*清空分配到的内存空间的数据*/
	memset(my_devices,0,DEVICE_MINOR_NUM*sizeof(struct reg_dev));
	
	/*设备初始化,一个一个初始化*/
	for(i=0;i<DEVICE_MINOR_NUM;i++)
	{
		/*分配内存空间*/
		my_devices[i].data = kmalloc(REGDEV_SIZE,GFP_KERNEL);
		/*清空分配到的内存空间的数据*/
		memset(my_devices[i].data,0,REGDEV_SIZE);
		/*设备注册到系统*/
		reg_init_cdev(&my_devices[i],i);
	}
	/*打印初始化函数信息*/
	printk(KERN_EMERG "ascdev_init\n");
	return 0;
	
	fail:
		/*注销设备号*/
		unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
		printk(KERN_EMERG "kmalloc is failed!\n");
		return ret;
}

static void chardev_exit(void)
{
	int i;
	printk(KERN_EMERG "chardev World exit!\n");
	/*卸载字符设备（一个一个卸载）*/
	for(i=0;i<DEVICE_MINOR_NUM;i++)
	{
		cdev_del(&my_devices[i].cdev);
	}
	/*注销设备号*/
	unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
}

module_init(chardev_init);
module_exit(chardev_exit);

代码分析

该代码在动态申请设备号代码的基础上得来，我们在动态申请设备号成功后进行设备的注册。
我们定义了一个reg_dev结构体来表示我们的每一个设备，并定义了该结构体类型的数组my_devices来表示所有的设备，因为DEVICE_MINOR_NUM为2，所以这个数组将会有两个变量
当我们动态申请设备号成功后先给my_devices分配内存空间并清空内存空间的数据
完成后我们分别对每一个设备进行初始化，在初始化过程中我们给my_devices[i].data分配内存，调用reg_init_cdev来注册设备
reg_init_cdev是我们自己定义的一个函数，它调用cdev_init实现了cdev变量的初始化并调用cdev_add将设备注册到系统
如果设备成功注册的话会打印出设备两个设备index（实际上也就是从设备号）

效果

安装模块

动态分配的主设备号为248，然后两个设备的从设备号分别为0和1
卸载模块