linux 添加字符驱动,linux字符设备驱动

字符设备驱动是较为基础的linux设备驱动。

字符设备驱动的加载的步骤是：首先申请设备号register_chrdev_region() à初始化字符设备cdev_init()(结构体初始化，并建立字符设备和文件操作指针之间的连接)-> 添加字符设备驱动

1. 字符设备驱动结构体

struct cdev {

structkobject kobj;

structmodule *owner;

conststruct file_operations *ops;

structlist_head list;

dev_tdev;

unsignedint count;

};

内置的kobject

struct kobject {

constchar              *name;

structlist_head       entry;

structkobject         *parent;

structkset              *kset;

structkobj_type     *ktype;

structsysfs_dirent   *sd;

structkref              kref;

unsignedint state_initialized:1;

unsignedint state_in_sysfs:1;

unsignedint state_add_uevent_sent:1;

unsignedint state_remove_uevent_sent:1;

unsignedint uevent_suppress:1;

};

2.设备号的申请

__register_chrdev_region(unsigned intmajor, unsigned int baseminor,

int minorct, const char *name)

{

struct char_device_struct *cd, **cp;

intret = 0;

inti;

cd= kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);//申请字符设备结构体

…

//填充设备号和设备名

cd->major = major;

cd->baseminor= baseminor;

cd->minorct= minorct;

strlcpy(cd->name,name, sizeof(cd->name));

mutex_lock(&chrdevs_lock);

/*temporary */

if(major == 0) {

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

if(chrdevs[i] == NULL)

break;

}

if(i == 0) {

ret= -EBUSY;

gotoout;

}

major= i;

ret= major;

}

。。。

cd->next = *cp;

*cp = cd;

}

static struct char_device_struct {

structchar_device_struct *next;

unsignedint major;

unsignedint baseminor;

intminorct;

charname[64];

structcdev *cdev;          /* will die */

} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

设备号的申请本质上是填充这个全局指针数组的元素值。

字符设备指针数组，数组长度为255，每个成员都是一个特定主设备字符设备结构的链表。数组的offset即为主设备号。

如果要动态获取主设备号，则遍历这个字符设备指针数组，如果指针为NULL，就将该数组元素的标号返回作为主设备号。

cd->next = *cp;

*cp = cd;

这两条语句将申请的新的字符设备指针添加到全局指针数组中去。

这样形成的结果是

不同的主设备号放在不同的数组中。每个数组元素指向一个链表头。

主设备号相同，次设备号不同的设备存在于同一个链表中。

所以主设备号的取值为0-255。

如果分配的主设备号和次设备号有效，则填充全局的字符设备指针数组。将新申请的设备结构体的指针赋值给对应的数组元素。

3. 字符设备初始化

void cdev_init(struct cdev *, const structfile_operations *);

初始化cdev成员，并建立和file_operations之间的连接。

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

{

memset(cdev,0, sizeof *cdev);

INIT_LIST_HEAD(&cdev->list);

kobject_init(&cdev->kobj,&ktype_cdev_default);

cdev->ops= fops; //文件操作结构体指针赋值

}

4.字符设备添加到系统中

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

{

p->dev= dev; //填充申请的设备号

p->count= count; //设备个数

returnkobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);//将字符设备添加到虚拟文件系统中

}

在对vfs初始化时就已经对cdev_map初始化了

void __init vfs_caches_init(unsigned longmempages)

struct kobj_map {

structprobe {

structprobe *next;

dev_tdev;

unsignedlong range;

structmodule *owner;

kobj_probe_t*get;

int(*lock)(dev_t, void *);

void*data;

}*probes[255];

structmutex *lock;

};

int kobj_map(struct kobj_map *domain, dev_tdev, unsigned long range,

struct module *module, kobj_probe_t*probe,

int (*lock)(dev_t, void *), void *data)

{

unsignedn = MAJOR(dev + range - 1) - MAJOR(dev) + 1;

unsignedindex = MAJOR(dev);

unsignedi;

structprobe *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++) {

structprobe **s = &domain->probes[index % 255];

while(*s && (*s)->range < range)

s= &(*s)->next;

p->next= *s;

*s= p;

}

mutex_unlock(domain->lock);

return0;

}

4. 字符设备号的释放

static struct char_device_struct *

__unregister_chrdev_region(unsigned major,unsigned baseminor, int minorct)

{

structchar_device_struct *cd = NULL, **cp;

inti = major_to_index(major);

mutex_lock(&chrdevs_lock);

for(cp = &chrdevs[i]; *cp; cp = &(*cp)->next)

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

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

(*cp)->minorct == minorct)

break;

if(*cp) {

cd = *cp;

*cp = cd->next;

}

mutex_unlock(&chrdevs_lock);

returncd;

}

红色的部分，删除了对应的字符设备指针节点。