linux驱动---字符设备的注册register_chrdev说

首先我们在注册函数里面调用了register_chrdev(MEM_MAJOR,"mem",&memory_fops)，向内核注册了一个字符设备。

第一个参数是主设备号，0代表动态分配，这里的MEM_MAJOR是1。第二个参数是设备的名字，第三个参数是文件操作指针。

每个设备文件对应有两个设备号：一个是主设备号，标识该设备的种类，也标识了该设备所使用的驱动程序；另一个是次设备号，标识使用同一设备驱动程序的不同硬件设备。设备文件的主设备号必须与设备驱动程序在登录该设备时申请的主设备号一致，否则用户进程将无法访问到设备驱动程序。 

一般说来，PCI卡通常都属于字符设备

完成注册后，在/proc/devices中的第一个字符设备我们就看到了：1 mem。

1.前面提到了注册，那这个字符设备到底注册到哪里去了呢？这是要弄明白的第一个问题。

其实是注册到一个存放字符设备的链表中了：

fs/char_dev.c

1. static struct char_device_struct {  
2.     struct char_device_struct *next;  
3.     unsigned int major;  
4.     unsigned int baseminor;  
5.     int minorct;  
6.     char name[64];  
7.     struct cdev *cdev;      /* will die */  
8. } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];  

这里的CHRDEV_MAJOR_HASH_SIZE的大小是255，也就是这里最多能够存放的主设备号最多有255个。

这里还是一点需要注意的是这里分配的是一个指针数组。

1. cd->next = *cp;  
2. *cp = cd;  

首先*cp代表的是当前相同的主设备号中最后面的一个，当然这这里的*cp是指向NULL的，然后把*cp更新为cd。

可以注意到这里好像并没有struct cdev什么事情，下面就对其进行初始化。

2.cdev_add第二个任务,add a char device to the system,make it live immediately

先介绍两个遇到的结构体：

include/linux/cdev.h

1. struct cdev {  
2.     struct kobject kobj;  
3.     struct module *owner;  
4.     const struct file_operations *ops;  
5.     struct list_head list;  
6.     dev_t dev;  
7.     unsigned int count;  
8. };  

可进行的操作有：

1. void cdev_init(struct cdev *, const struct file_operations *);  
2. struct cdev *cdev_alloc(void);  
3. void cdev_put(struct cdev *p);  
4. int cdev_add(struct cdev *, dev_t, unsigned);  
5. void cdev_del(struct cdev *);  
6. void cd_forget(struct inode *);  

在结构体cdev里出现了另外一个极其重要的结构体struct kobject,include/linux/kobject.h

1. struct kobject {  
2.     const char      *name;  
3.     struct list_head    entry;  
4.     struct kobject      *parent;  
5.     struct kset     *kset;  
6.     struct kobj_type    *ktype;  
7.     struct sysfs_dirent *sd;  
8.     struct kref     kref;  
9.     unsigned int state_initialized:1;  
10.     unsigned int state_in_sysfs:1;  
11.     unsigned int state_add_uevent_sent:1;  
12.     unsigned int state_remove_uevent_sent:1;  
13.     unsigned int uevent_suppress:1;  
14. };  

主要的操作有：

1. extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);  
2. extern void kobject_del(struct kobject *kobj);  
3. extern struct kobject *kobject_get(struct kobject *kobj);  
4. extern void kobject_put(struct kobject *kobj);extern void kobject_put(struct kobject *kobj);  

cdev_add里面只调用了一个函数：kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);

cdev_map是fs/char_dev.h里定义的一个结构体变量，而kobj_map的作用就是初始化它。

1. static struct kobj_map *cdev_map;  

1. struct kobj_map {  
2.     struct probe {  
3.         struct probe *next;  
4.         dev_t dev;  
5.         unsigned long range;  
6.         struct module *owner;  
7.         kobj_probe_t *get;  
8.         int (*lock)(dev_t, void *);  
9.         void *data;  
10.     } *probes[255];  
11.     struct mutex *lock;  
12. };  

kobj_map:

 内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。当后续要打开一个字符设备文件时，通过调用 kobj_lookup() 函数，根据设备编号就可以找到 cdev 结构变量，从而取出其中的 ops 字段。

1. int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,  
2.          struct module *module, kobj_probe_t *probe,  
3.          int (*lock)(dev_t, void *), void *data)  
4. {  
5.     unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;  
6.     unsigned index = MAJOR(dev);  
7.     unsigned i;  
8.     struct probe *p;  
9.   
10.     if (n > 255)  
11.         n = 255;  
12.   
13.     p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);  
14.   
15.     if (p == NULL)  
16.         return -ENOMEM;  
17.   
18.     for (i = 0; i < n; i++, p++) {  
19.         p->owner = module;  
20.         p->get = probe;  
21.         p->lock = lock;  
22.         p->dev = dev;  
23.         p->range = range;  
24.         p->data = data;  
25.     }  
26.     mutex_lock(domain->lock);  
27.     for (i = 0, p -= n; i < n; i++, p++, index++) {  
28.         struct probe **s = &domain->probes[index % 255];  
29.         while (*s && (*s)->range < range)  
30.             s = &(*s)->next;  
31.         p->next = *s;  
32.         *s = p;  
33.     }  
34.     mutex_unlock(domain->lock);  
35.     return 0;  
36. }  

现在完成的仅仅是注册，下面还有一些重要的事情需要完成。