linux 内核编程之字符设备驱动

【版权声明：转载请保留出处：blog.csdn.net/gentleliu。邮箱：shallnew*163.com】

首先需要注册设备号，有两个函数可以实现该功能：

int register_chrdev_region(dev_t from, unsigned count, const char *name)；int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)；

第一个函数参数用于已知设备号的情况，from为要分配设备号的起始值，count是所请求的连续设备号的个数，name为设备名称。
第二个函数参数用于未知设备号的情况，dev用于保存申请成功后的第一个设备号，baseminor第一个要使用的次设备号，常常为0，另外参数同上。该函数可以自动避开设备号重复的冲突，会使用一个未使用的设备号。

由于对字符设备的访问是通过文件系统内的设备名称来访问的,设备名称位于目录/dev下.为了便于系统管理,设置了和设备名称一一对应的设备号,它分为主设备号和次设备号.通常来说,主设备号标示了设备对应的驱动程序,次设备号则用来分辨拥有同一个主设备号的的各个不同设备。
使用第一个函数register_chrdev_region()需要给出一个自定义的设备号，在内核中,设备号使用类型dev_t来保存,它包括了主设备号和次设备号。dev_t是一个32位的整数,其中的12位用来标示主设备号,其余的20位用来标示次设备号.我们可以使用两个宏来获得设备的主设备号及次设备号:

    MAJOR(dev_t dev_id);    MINOR(dev_t dev_id);

    将主设备号和次设备号转换为dev_t类型,则可以使用下面的宏:

    MKDEV(int major, int minor);

    其中,major为主设备号,minor为次设备号。
我们将MKDEV返回的设备号传递给register_chrdev_region()函数的第一个参数。
上面宏的实现如下：

#define MINORBITS    20#define MINORMASK    ((1U << MINORBITS) - 1)#define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS))#define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK))#define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))

在分配好了设备号之后需要初始化设备结构体，使用函数

void cdev_init(struct cdev *cdev, const struct file_operations *fops)；

该函数带两参数，先看一下其结构体：

struct cdev {    struct kobject kobj;    struct module *owner;    //所属模块    const struct file_operations *ops;//文件操作结构体    struct list_head list;    dev_t dev;    //设备号    unsigned int count;};struct file_operations {    struct module *owner;    loff_t (*llseek) (struct file *, loff_t, int);    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);    int (*readdir) (struct file *, void *, filldir_t);    unsigned int (*poll) (struct file *, struct poll_table_struct *);    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);    int (*mmap) (struct file *, struct vm_area_struct *);    int (*open) (struct inode *, struct file *);    int (*flush) (struct file *, fl_owner_t id);    int (*release) (struct inode *, struct file *);    int (*fsync) (struct file *, struct dentry *, int datasync);    int (*aio_fsync) (struct kiocb *, int datasync);    int (*fasync) (int, struct file *, int);    int (*lock) (struct file *, int, struct file_lock *);    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);    int (*check_flags)(int);    int (*flock) (struct file *, int, struct file_lock *);    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);    int (*setlease)(struct file *, long, struct file_lock **);};

该结构体里面的函数是字符设备驱动设计的主要内容，实现该设备驱动主要就是实现该结构体里面的函数，这些函数会在linux应用层使用函数open，close，read，write，lseek等时进行调用。
再来看以下该函数的实现：

void cdev_init(struct cdev *cdev, const struct file_operations *fops){    memset(cdev, 0, sizeof *cdev);    INIT_LIST_HEAD(&cdev->list);    kobject_init(&cdev->kobj, &ktype_cdev_default);    cdev->ops = fops;//这一行就是将传入的第二个参数赋值给cdev的ops。}

所以在调用该函数之前，还需要初始化file_operations结构体。一般使用C标记式结构初始化语法，如下：

static const struct file_operations xxx_fops ={  .owner = THIS_MODULE,  .llseek = xxx_llseek,  .read = xxx_read,  .write = xxx_write,  .ioctl = xxx_ioctl,  .open = xxx_open,  .release = xxx_release,};

之后再定义该设备结构体所有者：

cdev.owner = THIS_MODULE;

然后就可以向模快添加该设备结构体，使用函数

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

参数p为将要添加的设备结构体，dev为该设备要求的第一个设备号，count为关联到设备的设备号数目，常常为1。
其内核实现如下:

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

到此，设备创建就成功了，剩下的只需要实现设备上的操作了。该函数的调用通常发生在驱动模块加载函数中。

当你不使用设备时，可以注销设备，使用

void cdev_del(struct cdev *dev);

还应该释放原先申请的设备号：使用

void unregister_chrdev_region(dev_t from, unsigned count)；

这两函数的调用通常发生在驱动模块卸载函数中。
下面给一个字符驱动编写的模板框架：

#include <linux/init.h>#include <linux/module.h>#include <linux/cdev.h>#include <linux/fs.h>#define DEV_NAME        "xxx_cdev"int     xxx_major = 0;dev_t   xxx_devno;struct xxx_cdev_t {    struct cdev cdev;} xxx_dev;int xxx_open(struct inode *inode, struct file *filep){    return 0;}static const struct file_operations xxx_fops = {    .owner = THIS_MODULE,    .open = xxx_open,};static int __init xxx_init(void){    int         ret;    if (xxx_major) {        xxx_devno = MKDEV(xxx_major, 0);        register_chrdev_region(xxx_devno, 1, DEV_NAME);    } else {        alloc_chrdev_region(&xxx_devno, 0, 1, DEV_NAME);    }    cdev_init(&xxx_dev.cdev, &xxx_fops);    xxx_dev.cdev.owner = THIS_MODULE;    if ((ret = cdev_add(&xxx_dev.cdev, xxx_devno, 1) < 0)) {        unregister_chrdev_region(xxx_devno, 1);        return ret;    }    return 0;}static void __exit xxx_exit(void){    unregister_chrdev_region(xxx_devno, 1);    cdev_del(&xxx_dev.cdev);}module_init(xxx_init);module_exit(xxx_exit);MODULE_LICENSE("GPL");

下面来讲一讲file_operations结构体成员函数的实现，因为这些函数是字符设备和内核接口，用户态应系统调用的最终实施者，实现字符设备驱动主要就是实现这些函数。一般read，write，ioctl这些函数一般都会实现。
通过上面file_operations结构体可以看到该结构体内函数的原型，其中有一个很重要的结构struct file，该结构体如下：

struct file {    /*     * fu_list becomes invalid after file_free is called and queued via     * fu_rcuhead for RCU freeing     */    union {        struct list_head    fu_list;        struct rcu_head     fu_rcuhead;    } f_u;    struct path        f_path;#define f_dentry    f_path.dentry#define f_vfsmnt    f_path.mnt    const struct file_operations    *f_op;    spinlock_t        f_lock;  /* f_ep_links, f_flags, no IRQ */    atomic_long_t        f_count;    unsigned int         f_flags;    fmode_t            f_mode;    loff_t            f_pos;    struct fown_struct    f_owner;    const struct cred    *f_cred;    struct file_ra_state    f_ra;    u64            f_version;#ifdef CONFIG_SECURITY    void            *f_security;#endif    /* needed for tty driver, and maybe others */    void            *private_data;#ifdef CONFIG_EPOLL    /* Used by fs/eventpoll.c to link all the hooks to this file */    struct list_head    f_ep_links;#endif /* #ifdef CONFIG_EPOLL */    struct address_space    *f_mapping;#ifdef CONFIG_DEBUG_WRITECOUNT    unsigned long f_mnt_write_state;#endif};

其中private_data 是一个有用的资源, 在系统调用间保留状态信息，一般在open中设置它。

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

读写函数第一个参数为文件结构体指针，第二个参数是用户空间的内存地址，在内核空间不能直接读写，第三个参数是要读写的文件字节数，第四个参数是读写位置相对于文件开头的位置。
内核空间和用户空间不能直接相互访问，要借助函数copy_to_user和copy_from_user才能实现内核空间和用户空间的内存拷贝。者两函数原型为：

unsigned long copy_from_user(void *to, const void _ _user *from, unsigned long count);unsigned long copy_to_user(void _ _user *to, const void *from, unsigned long count);

函数返回不能复制的字节数，完全复制返回0。

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

第三个参数为命令，第四个参数为要传入的参数。
编写Linux驱动时一般将文件的私有数据 private_data
指向设备结构体,在 read()、write()、ioctl()、llseek()等函数通过 private_data 访问设备结构体。
一般在open时设置private_data数据。
struct inode结构体中包含了大量有关文件的信息，该结构体中包含一个字符设备结构i_cdev。当inode指向一个字符设备文件时，该字段包含了指向struct cdev结构的指针， 我们可以通过该结构体找到包含字符设备的私有信息