i.MX6ULL学习笔记--字符设备驱动程序

简介

字符设备的驱动程序适合于大多数的简单硬件设备，比较容易上手。字符设备不可寻址，仅提供数据的流式访问，通过特殊的文件“字符设备节点”来访问。

1.驱动的配置过程

字符驱动程序的装载过程如上图所示，当驱动编写者编译出.ko文件后，通过insmod指令，执行__init 函数，在该函数中将会调用函数register_chrdev()来完成操作，首先完成设备号的申请、char_device_struct的申请并挂载到哈希表chrdevs中，然后申请到结构体cdev并进行初始化操作（文件操作符、kobj的关联），最后调用函数cdev_add()、kob_map()完成struct probe的申请，将对应的cdev结构体关联到probe结构体中，然后将初始化后的probe结构体按照主次设备号挂载到结构体kobj_map中的哈希表probes中。下面介绍相关的概念。

1.1设备号

主设备号标识设备对应的驱动程序，而次设备号则供内核使用，用于确认设备文件所致的设备。例如鼠标、键盘等虽然是不同的设备文件，但是由于他们都是usb协议，所以可以使用一个USB的驱动程序来驱动，那么他们的主设备号就是一致的，但是次设备号则有所不同。（这里还是有点不清晰，一个驱动程序在装载的过程中已经完成主次设备号的分配了）

这里的区分主次设备号是为了后面注册设备节点做准备，在使用指令mknod时，主设备号是确认的，次设备号则根据当前设备节点使用情况和最大设备数量决定。

设备号的获取可以通过静态获取（即指定设备号进行获取）也可以通过动态获取。file_operations结构体通过主设备号被保存在哈希表（chrdevs：全局变量）中，对象设备通过次设备号被保存在哈希表（cdev_map->probe：全局变量）中。那么内核只要通过主次设备号和哈希表，就能找到驱动程序和对象设备。

相对来说，发布版本最好使用动态设备号获取，这是由于静态设备号可能会因为环境的变化而起冲突（动态设备号的获取只初始化函数需要在调用register_chrdev_region时传入的设备号为0，具体的原因已经在附录源代码处进行了注释）。

实际上。通过附录数据结构中的介绍，可以知道file_operations结构体本质上是裸机操作的接口，即通过封装的概念将一些底层的驱动程序封装在结构体中，然后在内核中申请设备号，并绑定底层的驱动接口，就可以驱动某些设备了。

//linux/kdev_t.h
#define MINORBITS	20
#define MINORMASK	((1U << MINORBITS) - 1)

#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))//主设备号
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))//次设备号
#define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi))
//[MAJOR MINOR]

在目前的linux内核中，设备号dev是一个32位的无符号整形数据，主设备号占用12位，次设备号则占用20位。通过内核提供的宏定义可以获取主次设备号。

1.2哈希表-chrdevs

哈希表本质上就是数组加链表的组合结构，这是综合这两者之间的优劣而形成的，他们之间具体的差异可以查看笔记FreeRTOS学习笔记-列表中的相关介绍。

哈希表的结构示意图：

哈希表拥有255个成员，其中每个成员是一个指向链表的指针，某些有关联的信息将构成一个节点，并将节点挂载到对应的链表中。对于这样的结构，快速的找到某个功能的链表入口，并进行访问，同样链表的遍历存在时效的问题。

在哈希表chrdevs中，以主设备号对255求模后的结果为数组的下标 ，次设备号用来辨识不同的设备文件。通过求模来尽量均分主设备号，以达到快速访问的目的。

在分配主设备号的过程中，有部分地方并不清晰，即函数__register_chrdev_region在调用函数find_dynamic_major后，返回了一个主设备号，按照代码执行情况，这个设备号应该是不会重复的：函数优先动态分配255-234的设备号，其次考虑511-384的设备号，在找到预分配设备号时，都会遍历所有的节点，当该节点的主设备号和预分配设备冲突时会重新分配。那么函数__register_chrdev_region中的重叠判断又显得多余了，这让我百思不得其解，有可能是没理解到位。

但是基于预分配非0时（即不通过函数find_dynamic_major动态分配）则会出现基于输入的主次设备号进行分配，那么可能会产生冲突。

主要的冲突在于主设备号冲突时，次设备号的映射范围是否重叠，若次设备号重叠了就无法通过主+次设备号的方式来唯一确认驱动程序和驱动对象！而重叠分为三类：左重叠、右重叠以及包含性重叠。

对于哈希表chrdevs来说，主要的功能是根据主次设备号存储char_device_struct，这个结构体与驱动是对应的。（内核如何使用该结构还不知道，具体看下方2.5）

1.3哈希表-obj_map->probes

与哈希表chrdevs不同的是，probes被保存在全局变量结构体kobj_map中，同样是通过主次设备号进行排序（主设备号决定挂载在probes中的偏移量，次设备号决定在链表中的顺序）。功能上，从chrdevs中可以找到对应驱动设备的文件操作接口、引用次数等等属性。

1.4文件操作接口

内核给驱动程序开放了文件操作接口，该接口可以在附录数据结构中看到，包含了偏移、读取、写入、堵塞式操作等等。驱动开发者只需完善底层程序，然后在初始化函数中调用函数register_chrdev()，即可完成文件操作接口与cdev的结构体（字符设备管理结构体）的绑定。

1.5简单了解设备驱动模型

为了统一设备驱动的模型，Linux提供了sysfs文件系统，他和/proc文件系统是一样的，都希望用户态的程序可以访问到特定的内核数据信息。而普通的kobj结构体是sysfs文件系统的核心数据结构：每个kobj结构体都对应sysfs中的一个目录。具体到后面再进行深入学习。

在Linux中，无论是驱动还是目录都是以文件的形式存在，对于驱动而言，Linux通过结构体kset来关联一个驱动目录，将驱动相关的属性都挂载在这个目录下面。kset结构体的内容可以看附录中的数据结构，它自身继承了kobject结构体的属性（包含了一个这样的结构体），又使用一个表头来控制kobj结构体的链表。实际上Linux通过kset将kobject组织成一棵层次树，kset是同类型kobject结构的一个集合体，这个类型被记录在kset中的ktype中。可以通过调用函数kset_add();
kset_put();或者kobject_add();kobject_put();函数来增减引用的次数，实际上来说，kset的引用次数是引用内嵌的kobject的引用次数。

2.附录 （内附代码注释）

2.1数据结构

//与驱动模块相对应的文件操作接口
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 *);
	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);
	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;

file_operations结构体是内核作为接口提供给驱动模块的工具，在Linux中，任意的模块都可以被看成是一个文件，为了实现这样的哲学思想，Linux内核使用使用了对象与方法的思路，将所有的操作都封装成了方法，所有的文件都看成对象。所以一方面文件操作结构体向应用层提供了驱动的接口，也向驱动层提供了接口函数的形式（传参、返回类型）。
值得注意的是，内核中，初始化这些方法的形式与平常结构体略有不同：

//示例
struct file_operations scull_fops{
	.owner = THIS_MODULE,
	.llseek = scull_llseek,
	.read = scull_read,
};

在传统的结构体初始化中，必须是按顺序、全成员的赋值过程。而这里采用的是标准C的标记化结构初始语法，即在成员前加上一个.符号，这样的声明方式则不需要被束缚于传统的赋值规则，那么驱动开发者在开发时则不需要消耗过多的无用功（记忆成员），这样也能有效的提高效率（一些不需要赋值的成员即使赋值成NULL也会消耗性能），顺便吐槽下KEIL好像不支持这个操作。

//linux/char_dev.c
#define CHRDEV_MAJOR_HASH_SIZE 255

static struct char_device_struct {
	struct char_device_struct *next;//下一个节点
	unsigned int major;		//主设备号
	unsigned int baseminor;
	int minorct;//次设备号的数量
	char name[64];//设备名称
	struct cdev *cdev;		/* will die被废弃了 */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];//哈希表255个成员

这里展示了哈希表的初始化过程，他通过声明char_device_struct结构体来指定哈系表中的成员是指向该结构体的指针。

//from kobject.h

struct kobj_type {
	void (*release)(struct kobject *kobj);//kobject被释放时执行的函数（即kobject引用次数等于0时
	//被调用来释放kobject）
	const struct sysfs_ops *sysfs_ops;//指向sysfs操作表的指针
	struct attribute **default_attrs;//缺省属性链表
	const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
	const void *(*namespace)(struct kobject *kobj);
	void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);
};//这段描述了kobject的属性，实际上是描述了包括kobject的容器的属性

struct kobject {
	const char		*name;//驱动名称
	struct list_head	entry;//链表节点
	struct kobject		*parent;//上一级kobj结构体
	struct kset		*kset;//上一级kset结构体
	struct kobj_type	*ktype;//sysfs文件系统相关的操作和属性
	struct kernfs_node	*sd; /* sysfs directory entry */
	struct kref		kref;//引用次数
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
	struct delayed_work	release;
#endif
	unsigned int state_initialized:1;
	unsigned int state_in_sysfs:1;
	unsigned int state_add_uevent_sent:1;
	unsigned int state_remove_uevent_sent:1;
	unsigned int uevent_suppress:1;
};//
//管理字符设备对象的结构体from 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;//次设备号的数量
} __randomize_layout;


//from map.c
struct kobj_map {
	struct probe {
		struct probe *next;
		dev_t dev;
		unsigned long range;
		struct module *owner;
		kobj_probe_t *get;
		int (*lock)(dev_t, void *);
		void *data;//用于指向cdev结构体
	} *probes[255];
	struct mutex *lock;//互斥锁
};



struct kset {
	struct list_head list;//用于管理kobj结构体链表的表头
	spinlock_t list_lock;//自旋锁
	struct kobject kobj;//指向一个kobj
	const struct kset_uevent_ops *uevent_ops;//
} __randomize_layout;//from kobject.h


struct list_head {
	struct list_head *next, *prev;
};//from types.h

2.2函数

typedef unsigned long u_long;
typedef u_long dev_t;//from  coda.h

/**
 * register_chrdev_region() - register a range of device numbers
 * @from: the first in the desired range of device numbers; must include
 *        the major number.
 * @count: the number of consecutive device numbers required
 * @name: the name of the device or driver.
 *
 * Return value is zero on success, a negative error code on failure.
 */
int register_chrdev_region(dev_t from, unsigned count, const char *name)
{
	struct char_device_struct *cd;	//声明指向哈系表的指针
	dev_t to = from + count;
	dev_t n, next;

	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);//获取下一个设备号
		if (next > to)
			next = to;//防止异常越界
		cd = __register_chrdev_region(MAJOR(n), MINOR(n),
			       next - n, name);//申请设备号n
		if (IS_ERR(cd))
			goto fail;
	}
	return 0;
fail:
	to = n;
	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	}
	return PTR_ERR(cd);
}

/* Marks the bottom of the first segment of free char majors */
#define CHRDEV_MAJOR_DYN_END 234
/* Marks the top and bottom of the second segment of free char majors */
#define CHRDEV_MAJOR_DYN_EXT_START 511
#define CHRDEV_MAJOR_DYN_EXT_END 384

static int find_dynamic_major(void)
{
	int i;
	struct char_device_struct *cd;

	for (i = ARRAY_SIZE(chrdevs)-1; i >= CHRDEV_MAJOR_DYN_END; i--) {
		if (chrdevs[i] == NULL)//优先动态分配255-234的设备号
			return i;//若存在空的，则使用这个空的成员
	}

	for (i = CHRDEV_MAJOR_DYN_EXT_START;
	     i >= CHRDEV_MAJOR_DYN_EXT_END; i--) {//其次考虑511-384的设备号
		for (cd = chrdevs[major_to_index(i)]; cd; cd = cd->next)
			if (cd->major == i)//如果当前节点的主设备号已经存在，则不考虑这个节点
				break;

		if (cd == NULL)
			return i;//返回分配的设备号
	}

	return -EBUSY;
}


static DEFINE_MUTEX(chrdevs_lock);
/*
 * Register a single major with a specified minor range.
 *
 * If major == 0 this functions will dynamically allocate a major and return
 * its number.
 *
 * If major > 0 this function will attempt to reserve the passed range of
 * minors and will return zero on success.
 *
 * Returns a -ve errno on failure.
	major：主设备号
	baseminor：次设备号
	minorct：申请的设备数量
	name：设备名称
 */
static struct char_device_struct *
__register_chrdev_region(unsigned int major, unsigned int baseminor,
			   int minorct, const char *name)
{
	struct char_device_struct *cd, **cp;
	int ret = 0;
	int i;

	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);//申请节点内存
	if (cd == NULL)
		return ERR_PTR(-ENOMEM);

	mutex_lock(&chrdevs_lock);

	if (major == 0) {//若主设备号为0，则动态分配
		ret = find_dynamic_major();//寻找主设备号
		if (ret < 0) {
			pr_err("CHRDEV \"%s\" dynamic allocation region is full\n",
			       name);
			goto out;
		}
		major = ret;
	}

	if (major >= CHRDEV_MAJOR_MAX) {//边界检查
		pr_err("CHRDEV \"%s\" major requested (%u) is greater than the maximum (%u)\n",
		       name, major, CHRDEV_MAJOR_MAX-1);
		ret = -EINVAL;//被定义在 errno-base.h中
		goto out;
	}

	cd->major = major;
	cd->baseminor = baseminor;
	cd->minorct = minorct;
	strlcpy(cd->name, name, sizeof(cd->name));//初始化节点信息

	i = major_to_index(major);//找到映射的索引号

	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next){
		if ((*cp)->major > major || 
		    ((*cp)->major == major &&
		     (((*cp)->baseminor >= baseminor) ||
		      ((*cp)->baseminor + (*cp)->minorct > baseminor))))
			break;}//在哈系表指定的成员中的链表遍历进行排序

	/* Check for overlapping minor ranges.  */
	if (*cp && (*cp)->major == major) {//是否重叠？通过位与来判断，若A&&B=C，则A=B=C，均不等于0
		int old_min = (*cp)->baseminor;
		int old_max = (*cp)->baseminor + (*cp)->minorct - 1;  //获得冲突的次设备号的作用域
		int new_min = baseminor;
		int new_max = baseminor + minorct - 1;	//获得新的次设备号的作用域

		/* New driver overlaps from the left.  */
		if (new_max >= old_min && new_max <= old_max) {//新的次设备号的作用域的最大值被包含在冲突的设备号中
			ret = -EBUSY;
			goto out;
		}

		/* New driver overlaps from the right.  */
		if (new_min <= old_max && new_min >= old_min) {//新的次设备号的作用域的最小值被包含在冲突的设备号中
			ret = -EBUSY;
			goto out;
		}

		if (new_min < old_min && new_max > old_max) {//新的次设备号的作用域包含了冲突的设备号中
			ret = -EBUSY;
			goto out;
		}

	}
//新成员赋值
	cd->next = *cp;
	*cp = cd;
	mutex_unlock(&chrdevs_lock);
	return cd;
out:
	mutex_unlock(&chrdevs_lock);
	kfree(cd);
	return ERR_PTR(ret);
}

int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,
	     struct module *module, kobj_probe_t *probe,
	     int (*lock)(dev_t, void *), void *data)
{
	unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;	
	//在定义中，dev是一个32位的无符号整形（主设备号），
	//而range是次设备号，这里计算出range高于256的数据？即可以简化成n=range/256;？
	//（x>>8）=>x/256,(x+y-1)>>8 => (uint16_t)(x/256+y/256-1/256)-x/256+1，
	//不考虑这个步骤，这里出来的是range是指定数据的倍数，即需要多少个主设备来保证次设备号的管理。
	unsigned index = MAJOR(dev);
	unsigned i;
	struct probe *p;

	if (n > 255)
		n = 255;

	p = kmalloc_array(n, sizeof(struct probe), GFP_KERNEL);
	if (p == NULL)
		return -ENOMEM;

	for (i = 0; i < n; i++, p++) {//初始化刚申请的probe结构体（每个结构体对应一个主设备号）
		p->owner = module;
		p->get = probe;
		p->lock = lock;
		p->dev = dev;
		p->range = range;
		p->data = data;//将kobj_map中的data变量指向cdev结构体
	}
	mutex_lock(domain->lock);
	for (i = 0, p -= n; i < n; i++, p++, index++) {
		struct probe **s = &domain->probes[index % 255];
		//定义了指向probe的双层指针并获取到哈系表的指定入口（主设备号对）求余
		while (*s && (*s)->range < range)//指定probes[]中的probe是否为存在（发生冲突）且子设备号是否小于等待插入的子设备号
			s = &(*s)->next;//依次寻找（排序过程，通过比较子设备号的大小）
		p->next = *s;
		*s = p;//插入
	}
	mutex_unlock(domain->lock);
	return 0;
}
/**
 * cdev_add() - add a char device to the system
 * @p: the cdev structure for the device
 * @dev: the first device number for which this device is responsible
 * @count: the number of consecutive minor numbers corresponding to this
 *         device
 *
 * cdev_add() adds the device represented by @p to the system, making it
 * live immediately.  A negative error code is returned on failure.
 */
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
	int error;

	p->dev = dev;//保存设备号
	p->count = count;//次设备号

	error = kobj_map(cdev_map, dev, count, NULL,
			 exact_match, exact_lock, p);
	if (error)
		return error;

	kobject_get(p->kobj.parent);

	return 0;
}


/**
 * cdev_init() - initialize a cdev structure
 * @cdev: the structure to initialize
 * @fops: the file_operations for this device
 *
 * Initializes @cdev, remembering @fops, making it ready to add to the
 * system with cdev_add().
 */
void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
	memset(cdev, 0, sizeof *cdev);
	INIT_LIST_HEAD(&cdev->list);
	kobject_init(&cdev->kobj, &ktype_cdev_default);
	cdev->ops = fops;
}