1, 设备号的内部表示形式

类型：dev_t 32=12(主设备号) + 20(次设备号)

相关宏：<linux/kdev_t.h>

MAJOR(dev_t dev)

MINOR(dev_t dev)

MKDEV(int major, int minor);

2. 分配和释放设备号

相关函数：

//静态分配设备号

int register_chrdev_region(dev_t first, unsigned int count,

char *name);

//动态分配设备号

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,

unsigned int count, char *name);

void unregister_chrdev_region(dev_t first, unsigned int count);

3.获取设备号的通常写法

if (scull_major) {

dev = MKDEV(scull_major, scull_minor);

result = register_chrdev_region(dev, scull_nr_devs, "scull");

} else {

result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,

"scull");

scull_major = MAJOR(dev);

}

if (result < 0) {

printk(KERN_WARNING "scull: can't get major %d\n", scull_major);

return result;

}

4.一些重要的数据结构

struct file_operations

{

//用于防止一个正在使用的模块被卸载，通常值为THIS_MODULE

struct module *owner;

//seek

loff_t (*llseek) (struct file *, loff_t, int);

//read

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

ssize_t (*aio_read)(struct kiocb *, char __user *, size_t, loff_t);

//write

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

ssize_t (*aio_write)(struct kiocb *, const char __user *, size_t, loff_t *);

//readdir

int (*readdir) (struct file *, void *, filldir_t);

//poll

unsigned int (*poll) (struct file *, struct poll_table_struct *);

//ioctl

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);

//mmap

int (*mmap) (struct file *, struct vm_area_struct *);

//open

int (*open) (struct inode *, struct file *);

//flush

int (*flush) (struct file *);

//release

int (*release) (struct inode *, struct file *);

//fsync

int (*fsync) (struct file *, struct dentry *, int);

int (*aio_fsync)(struct kiocb *, int);

int (*fasync) (int, struct file *, int);

//lock

int (*lock) (struct file *, int, struct file_lock *);

//readv writev

ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);

ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);

//sendfile

ssize_t (*sendfile)(struct file *, loff_t *, size_t, read_actor_t, void *);

//sendpage

ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *,

int);

//get_unmapped_area

unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned

long, unsigned long, unsigned long);

//check_flags

int (*check_flags)(int)

//dir_notify

int (*dir_notify)(struct file *, unsigned long);

...

};

//代表打开的文件

struct file

{

//读写权限

mode_t f_mode;

//文件读写位置

loff_t f_pos;

//文件标志(O_RDONLY, O_NONBLOCK, O_SYNC)

unsigned int f_flags;

//文件操作

struct file_operations *f_op;

//设备文件的私有数据

void *private_data;

//与文件相关的目录,

struct dentry *f_dentry;

...

};

struct inode

{

//对于设备文件来说，此域表示真实的设备号

dev_t i_rdev;

//当引结点指向一个字符设备时，代表内核内部结构的字符设备

struct cdev *i_cdev;

};

//从I结点中获取次设备号

unsigned int iminor(struct inode *inode);

// 从I结点中获取主设备号

unsigned int imajor(struct inode *inode);

5. 注册字符设备

头文件：<linux/cdev.h>

cdev 结构体的定义：

struct cdev

{

struct kobject kobj;        /*内嵌的kobject对象*/

struct module *owner;   /*所属模块*/

struct file_operations *ops; /*相关的文件操作*/

struct list_head list;

dev_t dev;      /*设备模块*/

unsigned int count;

};

分配和初始化字符设备相关结构

方法1（将cdev作为单独的一个结构）：

struct cdev *my_cdev = cdev_alloc( ); //分配设备空间

my_cdev->ops = &my_fops;

//设备初始化

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

//添加设备

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

//删除设备

void cdev_del(struct cdev *dev);

方法2（将cdev作为自定义设备结构的一个成员）：

struct mydev

{

…

struct cdev;

}

设备分配初始化以及删除操作类似

PS: 2.6内核以前的字符设备注册方法

int register_chrdev(unsigned int major, const char *name, struct file_operations *fops);

int unregister_chrdev(unsigned int major, const char *name);

6. 字符设备驱动程序模板

字符设备驱动模块加载和卸载函数模板

//设备结构体

struct xxx_dev_t

{

struct cdev cdev;

…

};

//设备驱动模块加载函数

static int __init xxx_init(void)

{

…

//初始化cdev

cdev_init(&xxx_dev.cdev, &xxx_fops);

//获取字符设备号

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

}

//设备驱动模块卸载函数

static void __exit xxx_exit(void)

{

//释放占用的设备号

unregister_chrdev_region(xxx_dev_no, 1);

//注销设备

cdev_del(&xxx_dev.cdev);

…

}

字符设备常用I/O操作函数模板

//读设备

ssize_t xxx_read(struct file *filep, char __user *buf, size_t count, loff_t *f_pos)

{

…

copy_to_user(buf, …, …);

…

}

//写设备

ssize_t xxx_write(struct file *filep, const char __user *buf, size_t count, loff_t *f_pos)

{

…

copy_from_user(…, buf, …);

…

}

//ioctl函数

int xxx_ioctl(struct inode *inode, struct file *filep, unsigned int cmd, unsigned long arg)

{

…

switch(cmd)

{

case XXX_CMD1:

…

break;

case XXX_CMD2:

…

break;

default:

//不能支持的命令

return –ENOTTY;

}

return 0;

}

用户空间与内核空间的数据传输

//内核空间到用户空间数据的复制

unsigned long copy_to_user(void __user *to, const void *from,

unsigned long count);

//用户空间到内核空间的复制

unsigned long copy_from_user(void *to, const void __user *from,

unsinged long count);

上述函数均返回不能被复制的字节数，因此，如果完全复制成功，返回值为0.

如果要复制的内在是简单类型，如char, int,long等，则可以使用简单的put_user()和get_user()函数。

如：

int val;

…

get_user(val, (int*)arg);

…

put_user(val, (int*)arg);