在linux系统中,很多驱动是字符型驱动,有些是直接编译集成在内核中,另一些是单独编译成“。ko”动态加载的。其实字符驱动只是个外壳,用于内核与应用程序间通信,无非是调用open,release,read,write和ioctl等例程。所以根据应用不同,字符驱动能会调用其他驱动模块,如i2c、spi和v4l2等,于是字符驱动还可分WDT驱动、RTC驱动和MTD驱动等。所以在分析其他驱动模块之前有必要好好分析下字符设备驱动模型。本篇文章要讲的就是字符设备驱动模型,也就是字符设备驱动是怎么注册和注销的,怎么生成设备节点的,怎么和应用程序关联的,例程调用具体如何实现的等等。

一、字符设备驱动的注册和注销

对于写过linux-2.6内核(本文采用linux-2.6.18内核)字符驱动的程序员来说,对下面这段程序的形式肯定不陌生。int result;

/*

* Register the driver in the kernel

* Dynmically get the major number for the driver using

* alloc_chrdev_region function

*/

result = alloc_chrdev_region( 0, 1,“testchar”);

/* if it fails return error */

if (result dev = 1;

base->range = ~0; /*初始的范围很大*/

base->get = base_probe; /*保存函数指针*/

for (i = 0; i probes[i] = base; /*所有指针都指向同一个base */

p->lock = lock;

return p;

}.

复制代码该函数只是分配了一个结构体struct kobj_map,并做了初始化,保存了函数指针base_probe和全局锁lock。

下面就按照驱动注册流程一个个解析这些例程调用吧。首先是alloc_chrdev_region()函数,解析它之前,先看看结构体(定义了255个结构体指针),static struct char_device_struct {

/*被255整除后相同的设备号链成一个单向链表*/

struct char_device_struct *next;

unsigned int major; /*主设备号*/

unsigned int baseminor; /*次设备起始号*/

int minorct; /*次设备号范围*/

char name[64]; /*驱动的名字*/

struct file_operations *fops; /*保存文件操作指针,目前没有使用*/

struct cdev *cdev; /* will die */ /*目前没有使用*/

} *chrdevs[CHRDEV_MAJOR_HASH_SIZE]; /* CHRDEV_MAJOR_HASH_SIZE = 255 */

复制代码它的作用仅仅是用于注册字符设备驱动,保存已经注册字符驱动的一些信息,如主次设备号,次设备号的数量,驱动的名字等,便于字符设备驱动注册时索引查找。

 

alloc_chrdev_region()函数很简单,通过调用__register_chrdev_region()来实现,通过英语注释你也可以明白,这个函数有两个作用,一是,如果主设备号为0,则分配一个最近的主设备号,返回给调用者;二是,如果主设备号不为0,则占用好该主设备号对应的位置,返回给调用者。如下,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( /*这下看到了吧,加锁,就允许你一个人进来*/

/* temporary */

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;

}

/*这些不用说你懂的*/

cd->major = major;

cd->baseminor = baseminor;

cd->minorct = minorct;

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

i = major_to_index(major);

/*如果主设备号不为0,则占用好该主设备号对应的位置*/

for (cp = *cp; cp =

if ((*cp)->major > major ||

((*cp)->major == major (*cp)->baseminor >= baseminor))

break;

if (*cp (*cp)->major == major

(*cp)->baseminor next = *cp;

*cp = cd;

mutex_unlock( /*开锁,队列里的下一个人可以进来了*/

return cd;

out:

mutex_unlock(

kfree(cd);

return ERR_PTR(ret);

}

复制代码接着是cdev_init()函数,先说说cdev的结构体,struct cdev {

struct kobject kobj; /*不多解释了,看看鄙人前面写的文章吧*/

struct module *owner; /*模块锁定和加载时用得着*/

const struct file_operations *ops; /*保存文件操作例程结构体*/

struct list_head list; /* open时,会将其inode加到该链表中,方便判别是否空闲*/

dev_t dev; /*设备号*/

unsigned int count;

};

复制代码cdev结构体把字符设备驱动和文件系统相关联,后面解析字符设备驱动怎样运行的时候会详谈。

cdev_init()函数如下,void cdev_init(struct cdev *cdev, const struct file_operations *fops)

{

memset(cdev, 0, sizeof *cdev);

INIT_LIST_HEAD(

cdev->kobj.ktype = /*卸载驱动时会用到,别急,后面详讲*/

kobject_init(

cdev->ops = fops; /*用户写的字符设备驱动fops就保存在这了*/

}.

复制代码你也看到了,该函数就是对变量做了初始化,关于kobject的解析,建议你看看鄙人博客上写的《Linux设备模型浅析之设备篇》和《Linux设备模型浅析之驱动篇》两篇文章,这里就不详谈了。

用户的fops,在本文中是test_fops,一般形式是这样的,

static const struct file_operations test_fops = {

。owner = THIS_MODULE,

。open = test_fops_open,

。release = test_fops_release,

。ioctl = test_fops_ioctl,

。read = test_fops_read,

。write = test_fops_write,

};


复制代码

接着又调用了函数cdev_add(),这个函数又调用了kobj_map()函数,其作用就是分配一个struct probe结构体,填充该结构体中的变量并将其加入到全局的cdev_map中,说白了,就是分个一亩三分田给该字符设备驱动,并做好标记,放到主设备号对应的地方,等主人下次来找的时候能找到(使用kobj_lookup()函数,后面会讲到)。该函数是这样的,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;

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 owner = module;

p->get = probe; /*是exact_match ()函数,获取cdev结构体的kobject指针*/

p->lock = lock; /*是exact_lock()函数,增加引用*/

p->dev = dev;

p->range = range;

p->data = data; /* cdev保存到p->data中*/

}

mutex_lock(domain->lock);

/*将这一亩三分田加到主设备号对应的位置上去*/

for (i = 0, p -= n; i probes[index % 255];

while (*s (*s)->range next;

p->next = *s;

*s = p;

}

mutex_unlock(domain->lock);

return 0;

}

复制代码接下来有class_create()函数和class_device_create()函数,前者生成一个名字为"testchar"的class,后者作用就是在/dev目录下生成设备节点,当然,需要uevent和UDEVD的支持,具体可见鄙人博客上的文章《Linux设备模型浅析之uevent篇》。

顺带说下register_chrdev()函数,其也是注册字符设备驱动,只不过是封装好的,包含了所有前面讲的注册步骤——分配一个设备号,由一个主设备号和255个次设备号组成。如下,int register_chrdev(unsigned int major, const char *name,

const struct file_operations *fops)

{

struct char_device_struct *cd;

struct cdev *cdev;

char *s;

int err = -ENOMEM;

cd = __register_chrdev_region(major, 0, 256, name);

if (IS_ERR(cd))

return PTR_ERR(cd);

cdev = cdev_alloc(); /*这个有点不一样,动态分配的,不是调用者提供*/

if (!cdev)

goto out2;

cdev->owner = fops->owner;

cdev->ops = fops;

kobject_set_name( "%s", name);

for (s = strchr(kobject_name( s; s = strchr(s, '/'))

*s = '!';

err = cdev_add(cdev, MKDEV(cd->major, 0), 256);

if (err)

goto out;

cd->cdev = cdev;

return major ? 0 : cd->major;

out:

kobject_put(

out2:

kfree(__unregister_chrdev_region(cd->major, 0, 256));

return err;

}