关闭

嵌入式 linux下cdev详解

474人阅读 评论(0) 收藏 举报
分类:
一.前言
以前对于cdev仅仅是知其然,而不知其所以然。在本文中,将深入理解cdev的架构以及具体的实现。

二.真实的cdev
2.1 设备号
搞驱动的都应该知道的东西,在写gpio驱动时,往往会用到以下两个函数。
alloc_chrdev_region --自动分配设备号
register_chrdev_region --分配以设定的设备号。
上面两个函数的调用很简单,当时却没有深入去理解其实现的原理,只知道其采用了hash表,但是具体怎么实现的却不知道。在这里来好好理解一下。上面两个函数的核心是__register_chrdev_region;那来看源码的实现。
static struct char_device_struct {
struct char_device_struct *next;
unsigned int major;
unsigned int baseminor;
int minorct;
char name[64];
struct cdev *cdev;
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE]; --CHRDEV_MAJOR_HASH_SIZE =255
你看这个结构体会发现,其定义了一个指针数组,大小为255.
static struct char_device_struct *__register_chrdev_region(unsigned int major, unsigned intbaseminor,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) {--当调用alloc_chrdev_region时,传入的major为0,从表面上看调用alloc_chrdev_region会自动分配设备,但是有一个缺点就是其
分配的设备号只能在255内,而且并没有使用hash表,从而大大减少了linux所支持的设备号数。
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;
}
--以下以register_chrdev_region为例即传入major不为0。
cd->major = major;
cd->baseminor = baseminor;
cd->minorct = minorct;
strncpy(cd->name,name, 64);

i = major_to_index(major); -- major % CHRDEV_MAJOR_HASH_SIZE这里采用除留余数法来产生地址。

for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)--这个是用于处理散列表的冲突。在这里采用拉链法来处理散列冲突。
if ((*cp)->major > major ||((*cp)->major == major&&(((*cp)->baseminor >= baseminor)||((*cp)->baseminor + (*cp)->minorct > baseminor))))
break;


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;


if (new_max >= old_min && new_max <= old_max) {
ret = -EBUSY;
goto out;
}


if (new_min <= old_max && new_min >= old_min) {
ret = -EBUSY;
goto out;
}
}

cd->next = *cp; --这里是将cd插入链表中。
*cp = cd;
mutex_unlock(&chrdevs_lock);
return cd;
out:
mutex_unlock(&chrdevs_lock);
kfree(cd);
return ERR_PTR(ret);
}
上面是分配设备号的核心函数,上面的描述比较空洞,那来看一个例子。
在两个驱动文件中都采用register_chrdev_region来分配设备号。
A文件.
dev_t devt = MKDEV(506,0);
register_chrdev_region(devt,1,"A");
B文件.
dev_t devt = MKDEV(506,1);
register_chrdev_region(devt,1,"B");
也许有人会奇怪这两个module怎么会用同一个主设备号,有人会认为是在同一个主设备号下有两个从设备,所以会采用同一个主设备号,其实不然,在命令行中输入cat/proc/devices 时会发现竟然有两个主设备号为506的设备,并且这设备号竟然大于255。到此时,你在回去去看cdev设备号的hash表实现就不太难懂了。其实对于hash表的地址为506%5 = 251,而B的cd 等于A的cd->next.就是hash出现地址冲突时采用拉链法来解决冲突的。
OK,到此对于cdev的设备号是如何分配的应该很清楚了吧。

2.2 cdev的初始化和注册。
一般使用cdev的过程如下
struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
dev_t dev;
unsigned int count;
};
cdev_alloc->cdev_init->cdev_add
那就按照上面的顺序来分别解释。
cdev_alloc和cdev_init都比较简单,这里就不说了。在cdev_add中有一个很重要的函数kobj_map。
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
p->dev = dev;
p->count = count;
return kobj_map(cdev_map, dev, count, NULL, exact_match,exact_lock, p);
}
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;
} *probes[255];
struct mutex *lock;
};
其传入的参数cdev_map在刚开始的时候就分配内存并且初始化了。
int kobj_map(struct kobj_map *domain, dev_t dev, unsigned longrange,struct module *module, kobj_probe_t *probe,int (*lock)(dev_t,void *), void *data)
{
unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;--当rang小于1<<20时,n=1
unsigned index = MAJOR(dev);
unsigned i;
struct probe *p;

if (n > 255)
n = 255;

p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);

if (p == NULL)
return -ENOMEM;

for (i = 0; i < n; i++, p++) {
p->owner = module;
p->get = probe;
p->lock = lock;
p->dev = dev;
p->range = range;
p->data = data;
}
mutex_lock(domain->lock);
for (i = 0, p -= n; i < n; i++, p++, index++) {
struct probe **s = &domain->probes[index % 255];
while (*s && (*s)->range < range)
s = &(*s)->next;
p->next = *s;
*s = p;
}
mutex_unlock(domain->lock);
return 0;
}
上面还是一个链表型的数组,用于保存module的信息。至于这些信息的作用哪儿有用,不急,且听我慢慢道来。

三.cdev打开
话说每一个设备在打开的时候都会使用open,而每一个cdevopen的时候都会调用chrdev_open这个函数,而上面所说的cdev_add中的一些某明奇妙的东东都会在这里看到。
static int chrdev_open(struct inode *inode, struct file*filp)
{
struct cdev *p;
struct cdev *new = NULL;
int ret = 0;

spin_lock(&cdev_lock);
p = inode->i_cdev; --以此时p=NULL为例。
if (!p) {
struct kobject *kobj;
int idx;
spin_unlock(&cdev_lock);
kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);--查找kobject。这里面就知道kobj_mmap为什么那么做了。
if (!kobj)
return -ENXIO;
new = container_of(kobj, struct cdev, kobj); --根据kobj找到cdev
spin_lock(&cdev_lock);
p = inode->i_cdev;
if (!p) {
inode->i_cdev = p = new;
inode->i_cindex = idx;
list_add(&inode->i_devices, &p->list);
new = NULL;
} else if (!cdev_get(p))
ret = -ENXIO;
} else if (!cdev_get(p))
ret = -ENXIO;
spin_unlock(&cdev_lock);
cdev_put(new);
if (ret)
return ret;

ret = -ENXIO;
filp->f_op = fops_get(p->ops);--将file的f_op用cdev自己的ops代替。
if (!filp->f_op)
goto out_cdev_put;

if (filp->f_op->open) { --这里将会调用设备自己的open。
ret = filp->f_op->open(inode,filp);
if (ret)
goto out_cdev_put;
}

return 0;

out_cdev_put:
cdev_put(p);
return ret;
}

struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int*index)
{
struct kobject *kobj;
struct probe *p;
unsigned long best = ~0UL;

retry:
mutex_lock(domain->lock);
for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {--从链表头开始查询
struct kobject *(*probe)(dev_t, int *, void *);
struct module *owner;
void *data;

if (p->dev > dev || p->dev + p->range - 1 < dev)--还记否上面是根据什么来将probe节点插入到以probes[x]为头的链表中的。
continue;
if (p->range - 1 >= best) --我感觉这个错误时不会发生的。
break;
if (!try_module_get(p->owner))--判断module是否在内核中,在就增加计数。否则返回0表示module不在kernel中。
continue;
owner = p->owner; --这里就是cdev->owner
data = p->data; --data = cdev
probe = p->get; --在cdev_add中就说明是exact_match
best = p->range - 1; --就是cdev_add中的参数count。
*index = dev - p->dev;
if (p->lock && p->lock(dev, data) < 0) {--p->lock = exact_lock
module_put(owner);
continue;
}
mutex_unlock(domain->lock);
kobj = probe(dev, index, data); --返回时cdev的kobject
static struct kobject *exact_match(dev_t dev, int *part, void*data)
{
struct cdev *p = data;
return &p->kobj;
}

module_put(owner);
if (kobj)
return kobj;
goto retry;
}
mutex_unlock(domain->lock);
return NULL;
}
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1047308次
    • 积分:18285
    • 等级:
    • 排名:第521名
    • 原创:741篇
    • 转载:523篇
    • 译文:0篇
    • 评论:105条
    最新评论