linux 字符设备驱动框架

一、字符设备结构及原理

1.内核内部使用struct cdev结构来表示字符设备。在内核调用设备的操作之前，必须分配并注册一个或多个struct cdev。

struct cdev {
struct kobject kobj;                           //每个 cdev 都是一个 kobject
struct module *owner;                          //指向实现驱动的模块
const struct file_operations *ops;             //操纵这个字符设备文件的方法
struct list_head list;                         //与 cdev对应的字符设备文件的 inode->i_devices 的链表头
dev_t dev;                                     //起始设备编号
unsigned int count;                            //设备范围号大小
};

2.内核中所有已分配的字符设备编号都记录在一个名为 chrdevs 散列表里。该散列表中的每一个元素是一个 char_device_struct 结构，它的定义如下：

static struct char_device_struct {
struct char_device_struct *next;         // 指向散列冲突链表中的下一个元素的指针
unsigned int major;                      // 主设备号
unsigned int baseminor;                  // 起始次设备号
int minorct;                             // 设备编号的范围大小
char name[64];                           // 处理该设备编号范围内的设备驱动的名称
struct file_operations *fops;            // 没有使用
struct cdev *cdev;                       // 指向字符设备驱动程序描述符的指针
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

注意，内核并不是为每一个字符设备编号定义一个 char_device_struct 结构，而是为一组对应同一个字符设备驱动的设备编号范围定义一个 char_device_struct 结构。chrdevs 散列表的大小是255，散列算法是把每组字符设备编号范围的主设备号以 255 取模插入相应的散列桶中。同一个散列桶中的字符设备编号范围是按起始次设备号递增排序的。

3. kobj_map结构体是用来管理设备号及其对应的设备的。 内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。

当后续要打开一个字符设备文件时，通过调用 kobj_lookup() 函数，根据设备编号就可以找到 cdev 结构变量，从而取出其中的 ops 字段。

kobj_map()函数就是将指定的设备号加入到该数组，kobj_lookup()则查找该结构体，然后返回对应设备号的kobject对象，利用该kobject对象，我们可以得到包含它的对象如cdev。

struct probe *probes[255];。
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;           //指向struct cdev对象
} *probes[255];
struct mutex *lock;
}

4

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
int error;

p->dev = dev;
p->count = count;

//将cdev结构添加到cdev_map的数组中
error = kobj_map(cdev_map, dev, count, NULL,exact_match, exact_lock, p);
if (error)
return error;
//父kobject结构计数加1
kobject_get(p->kobj.parent);
return 0;
}

//内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。

//kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。当后续要打开一个字符设备文件时，通过调用 kobj_lookup() 函数，

//根据设备编号就可以找到 cdev 结构变量，从而取出其中的 ops 字段。

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)
{
//dev_t的前12位为主设备号，后20位为次设备号。
//n = MAJOR(dev + range - 1) - MAJOR(dev) + 1 表示设备号范围(dev, dev+range)中不同的主设备号的个数。通常n的值为1。
unsigned n = MAJOR(dev+range-1) - MAJOR(dev) + 1;
unsigned index = MAJOR(dev);//主设备号
unsigned i;
struct probe *p;

if (n > 255)//若n > 255，则超出了kobj_map中probes数组的大小
n = 255;
p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);//分配n个struct probe
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;//保存的是cdev结构
}
mutex_lock(domain->lock);

//从for循环可以看出kobj_map中的probes数组中每个元素为一个struct probe链表的头指针。
for(i = 0, p-=n; i < n; i++, p++, index++) {
struct probe **s = &domain->probes[index % 255];//从数组中找到主设备号为index的probe结构链表，在此链表中每个probe结构都是相同的主设备号index
//链表中的元素是按照range值从小到大排列的。while循环即是找出该将p插入的位置。
while(*s && (*s)->range < range)
s = &(*s)->next;
p->next = *s;
*s = p;//插入链表
}
mutex_unlock(domain->lock);
return 0;
}

二、字符设备的注册

1.一个 cdev 一般它有两种定义初始化方式：静态的和动态的。

(1)静态内存定义初始化：

struct cdev my_cdev;

cdev_init(&my_cdev, &fops);

my_cdev.owner = THIS_MODULE;

(2)动态内存定义初始化：

struct cdev *my_cdev = cdev_alloc();

my_cdev->ops = &fops;

my_cdev->owner = THIS_MODULE;

两种使用方式的功能是一样的，只是使用的内存区不一样，一般视实际的数据结构需求而定。

2.注册一个独立的cdev设备的基本过程如下：

(1)、为struct cdev 分配空间(如果已经将struct cdev 嵌入到自己的设备的特定结构体中，并分配了空间，这步略过！)

struct cdev *my_cdev = cdev_alloc();

my_cdev->ops=&my_ops;

(2)、初始化struct cdev

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

(3)、初始化cdev.owner

cdev.owner = THIS_MODULE;

(4)、添加cdev，通知内核struct cdev的信息（在执行这步之前必须确定你对struct cdev的以上设置已经完成！）

int cdev_add(struct cdev *p, dev_t dev, unsigned count)

//p是cdev结构, dev是这个设备响应的第一个设备号, count 是应当关联到设备的设备号的数目. 常常 count 是 1,

//在使用 cdev_add 是有几个重要事情要记住. 第一个是这个调用可能失败. 如果它返回一个负的错误码, 你的设备没有增加到系统中. 它几乎会一直成功, 但是, 并 且带起了其他的点: cdev_add 一返回, 你的设备就是"活的"并且内核可以调用它的操作. 除非你的驱动完全准备好处理设备上的操作, 你不应当调用 cdev_add.

三、分配设备号

内核提供了三个函数来注册一组字符设备编号，这三个函数分别是 register_chrdev_region()、alloc_chrdev_region() 和 register_chrdev()。这三个函数都会调用一个共用的__register_chrdev_region() 函数来注册一组设备编号范围（即一个 char_device_struct 结构）。

register_chrdev_region( ) //分配指定的设备号范围

alloc_chrdev_region( ) //动态分配设备范围

register_chrdev( ) //申请指定的设备号,并且将其注册到字符设备驱动模型中.是一个老式分配设备编号范围的函数

//内核中所有已分配的字符设备编号都记录在一个名为 chrdevs 散列表里。该散列表中的每一个元素是一个 char_device_struct 结构

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);//分配一个新的 char_device_struct 结构

if (cd == NULL)

return ERR_PTR(-ENOMEM);

mutex_lock(&chrdevs_lock);

//如果申请的设备编号范围的主设备号为 0，那么表示设备驱动程序请求动态分配一个主设备号。

//动态分配主设备号的原则是从散列表的最后一个桶向前寻找，那个桶是空的，主设备号就是相应散列桶的序号。

//所以动态分配的主设备号总是小于 256，如果每个桶都有字符设备编号了，那动态分配就会失败。

if (major == 0) {

for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--)

if (chrdevs[i] == NULL)

break;

if (i == 0) {

ret = -EBUSY;

goto out;

}

major = i;

ret = major;

}

//根据参数设置 char_device_struct 结构中的初始设备号，范围大小及设备驱动名称。

cd->major = major;

cd->baseminor = baseminor;

cd->minorct = minorct;

strncpy(cd->name,name, 64);

i = major_to_index(major);

//计算出主设备号所对应的散列桶，为新的 char_device_struct 结构寻找正确的位置。同时，如果设备编号范围有重复的话，则出错返回。

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) {

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;

}

}

//将新的 char_device_struct 结构插入散列表中，并返回 char_device_struct 结构的地址。

cd->next = *cp;

*cp = cd;

mutex_unlock(&chrdevs_lock);

return cd;

out:

mutex_unlock(&chrdevs_lock);

kfree(cd);

return ERR_PTR(ret);

}

四.注册cdev设备老方法
1.如果你深入浏览 2.6 内核的大量驱动代码, 你可能注意到有许多字符驱动不使用我们刚刚描述过的 cdev 接口. 你见到的是还没有更新到 2.6 内核接口的老代码. 因为那个代码实际上能用, 这个更新可能很长时间不会发生. 为完整, 我们描述老的字符设备注册接口, 但是新代码不应当使用它; 这个机制在将来内核中可能会消失.
注册一个字符设备的经典方法是使用:
int register_chrdev(unsigned int major, const char *name, struct file_operations *fops);
这里, major 是感兴趣的主设备号, name 是驱动的名子(出现在 /proc/devices), fops 是缺省的 file_operations 结构. 一个对 register_chrdev 的调用为给定的主编号注册 0 - 255 的次编号, 并且为每一个建立一个缺省的 cdev 结构. 使用这个接口的驱动必须准备好处理对所有 256 个次编号的 open 调用( 不管它们是否对应真实设备 ), 它们不能使用大于 255 的主或次编号.register_chrdev函数的major参数如果等于0，则表示采用系统动态分配的主设备号。
它所做的事情为:
(1). 注册设备号, 通过调用 __register_chrdev_region() 来实现
(2). 分配一个cdev, 通过调用 cdev_alloc() 来实现
(3). 将cdev添加到驱动模型中, 这一步将设备号和驱动关联了起来. 通过调用 cdev_add() 来实现
(4). 将第一步中创建的 struct char_device_struct 对象的 cdev 指向第二步中分配的cdev. 由于register_chrdev()是老的接口,这一步在新的接口中并不需要.

2.如果你使用 register_chrdev, 从系统中去除你的设备的正确的函数是:
int unregister_chrdev(unsigned int major, const char *name);//major 和 name 必须和传递给 register_chrdev 的相同, 否则调用会失败.

五、字符设备驱动模板

（1）设置驱动文件操作结构体

static struct file_operations XXX_fops =

{

.owner = THIS_MODULE,

.read = xxx_read,

.write = xxx_write,

.ioctl = xxx_ioctl,

...

};

（2）编写字符设备驱动模块加载与卸载函数

static int _ _init xxx_init(void){                            //模块加载--〉申请设备号，添加设备
...
cdev_init(&xxx_dev.cdev, &xxx_fops);               //初始化cdev
xxx_dev.cdev.owner = THIS_MODULE;

if (xxx_major){//获取字符设备号
register_chrdev_region(xxx_dev_no, 1, DEV_NAME);
}
else{
alloc_chrdev_region(&xxx_dev_no, 0, 1, DEV_NAME);
}
ret = cdev_add(&xxx_dev.cdev, xxx_dev_no, 1); //注册设备

...//可能申请中断号request_irq
}

static void _ _exit xxx_exit(void){/*设备驱动模块卸载函数*/
unregister_chrdev_region(xxx_dev_no, 1); //释放占用的设备号
cdev_del(&xxx_dev.cdev); //注销设备
...//释放中断号free_irq
}