1 结构体说明:
    struct cdev {
        struct kobject kobj;          // 每个 cdev 都是一个 kobject
        struct module *owner;       // 指向实现驱动的模块
        const struct file_operations *ops;   // 操纵这个字符设备文件的方法
        struct list_head list;       // 与 cdev 对应的字符设备文件的 inode->i_devices 的链表头
        dev_t dev;                   // 起始设备编号
        unsigned int count;       // 设备范围号大小
    };
    内核中每个字符设备都对应一个 cdev 结构的变量。


    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 **);
    };
下面是常用的一些方法的介绍:
     loff_t (*llseek) (struct file * filp , loff_t  p,  int  orig);
        指针参数filp为进行读取信息的目标文件结构体指针;参数 p 为文件定位的目标偏移量(根据orig指定的位置的偏移量,这个值可以为负值);参数orig为对文件定位的起始地址,这个值可以为文件开头(SEEK_SET,0,当前位置(SEEK_CUR,1),文件末尾(SEEK_END,2)llseek 方法用作改变文件中的当前读/写位置, 
        该方法执行成功返回新位置,返回值小于0,表示执行失败。
        这个方法对应应用程序中的seek函数。


     ssize_t (*read) (struct file * filp, char __user * buffer, size_t    size , loff_t *  p);
        指针参数 filp 为进行读取信息的目标文件,指针参数buffer 为对应放置信息的缓冲区(即用户空间内存地址),参数size为要读取的数据的长度,参数 p 为读的位置相对于文件开头的偏移,在读取信息后,这个指针一般都会移动,移动的值为要读取信息的长度值
        该方法执行成功返回实际读取的字节数,返回负值表示执行失败。
        该方法对应应用程序中的read函数。
        最后需要注意的是buffer是用户空间的地址,所以不能用memcpy进行拷贝,必须要使用copy_to_user来进行内核空间到用户空间的拷贝。示例如下
        copy_to_user(buffer ,ptr ,len) ; buffer为用户空间的地址,ptr为内核空间的地址,len为要拷贝的长度。
   
    ssize_t (*write) (struct file *  filp, const char __user *   buffer, size_t  count, loff_t * ppos);
        参数filp为目标文件结构体指针,buffer为要写入文件的信息缓冲区,count为要写入信息的长度,ppos为当前的偏移位置,这个值通常是用来判断写文件是否越界
        函数执行成功返回实际发送的字节数,失败返回负值。
        该方法对应应用程序中的write函数。
        同read一样buffer是用户空间的地址,所以不能直接拷贝,需要用copy_from_user来进行拷贝,示例如下:
        copy_from_user(ptr , buffer ,len) ; buffer为用户空间的地址,ptr为内核空间的地址,len为要拷贝的长度。
    
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
        这是一个设备驱动中的轮询函数,第一个参数为file结构指针,第二个为轮询表指针.
        这个函数资源可用时返回设备资源的可获取状态,即POLLIN,POLLOUT,POLLPRI,POLLERR,POLLNVAL等宏的位“或”结果。否则返回0 。该函数详细的用法可以参考《select poll epoll使用示例》里面的介绍。


    int (*unlocked_ioctl) ( struct file *filp, unsigned int cmd, unsigned long arg);
        注意在2.6.36以后ioctl已经不再存在了,所以这里我们只说明unlocked_ioctl。unlocked_ioctl和ioctl的区别在于ioctl多了一个struct inode *的参数。这个在移植老代码的时候要注意修改,否则编译不过的,unlocked_ioctl和ioctl对应的都是应用程序中的ioctl函数,对于应用,不论是unlocked_ioctl还是ioctl都是不需要修改的。
        unlocked_ioctl主要用于对硬件设备的控制。第一个参数为file结构指针, 第二个参数cmd是用户传进来的操作码,驱动根据这个数据来决定执行什么操作。第三个参数arg是参数,这个参数可以是一个整数,或者是一个指针,如果是指针的话,在内核空间要通过 copy_to_user或者 copy_from_user拷贝数据。
        下面详细说明下cmd,cmd由4部分组成,设备类型(幻数),方向,序号,数据大小,linux提供了下面的宏进行操作
        _IO(type,nr)  
        _IOR(type,nr,size)  
        _IOW(type,nr,size)  
        _IOWR(type,nr,size) 
        还有下面的宏可以获取一个cmd设备类型(幻数),方向,序号,数据大小
        _IOC_DIR(nr)  
        _IOC_TYPE(nr) 
        _IOC_NR(nr)  
        _IOC_SIZE(nr)
        注意:对于我们定义的mcd,最好用根据方向、数据大小等用_IO、_IOR、_IOW、_IOWR来定义,而不要直接用一个数值,例如1、2、3这些数据。
        直接定义一个常数在早期的linux不会出错,但是在3.0以后,可能会造成某些cmd根本不会执行,但是返回的还是0。例如我曾经移植2.6.2的驱动到3.0下,结果该驱动有一个cmd定义的是2,结果之前没有问题,到3.0 应用调用ioctl返回0,没有报错,但是看串口信息,驱动中的unlocked_ioctl根本没有调用,将这个cmd用_IOR重新定义执行就正常了,
        unlocked_ioctl执行成功返回0 ,失败返回负值。
        
    int (*mmap) (struct file *, struct vm_area_struct *);
        mmap 用来请求将设备内存映射到进程的地址空间.这个函数对应的是应用程序中的mmap.
        函数执行成功返回0,失败返回负值。
        下面是示例代码:
    static int test_mmap( struct file *filp ,struct vm_area_struct *vma)
    {
                unsigned long size ;


                size = vma->vm_end-vma->vm_start;
                //这里的MAX_SIZE 是我们分配的用于映射的内存的大小,是我们在驱动中定义的
                //vm_pgoff是页偏移。也就是说如果应用中设置的偏移是4096(linux一页时4096字节) 那么驱动中vm_pgoff就是1,如果应用中是8192 那么驱动对应的就是2。
                if( (vma->vm_pgoff<<PAGE_SHIFT)+size > MAX_SIZE )
                {
                        return -EAGAIN;
                }
                /*标记这段虚拟内存映射为IO区域,并阻止系统将该区域包含在进程的存放转存中*/ 
                vma->vm_flags|=VM_IO;
                /*标记这段区域不能被换出*/
                vma->vm_flags|=VM_RESERVED;
 
                if(remap_pfn_range(vma,vma->vm_start,(virt_to_phys(ptr_mem)>>PAGE_SHIFT)+vma->vm_pgoff,size,vma->vm_page_prot))
                        return -EAGAIN;
                return 0;
    }
    另外我们需要注意的是mmap映射的地址是按页对齐的,也就是低12位的地址要为0。我们可以通过alloc_pages来分配内存用于映射。示例如下:
        struct page *page;
        page = alloc_pages(GFP_KERNEL,1);//alloc_pages的第二个参数是分配的页数,为2的n次方页。
        //例如 为0 表示分配1页(4096),为1表示分配两页(8192),为2表示分配4页
        if(page==NULL)
        {
                printk(KERN_ERR"alloc_pages return error\r\n");
                ptr_mem=NULL;
        }
        else
        {
                ptr_mem= page_address(page); 
                if(ptr_mem==NULL)
                {
                        printk(KERN_ERR"page_address return error\r\n");
                        free_pages((unsigned long)page, 1);
                }
        }        
        驱动卸载的时候调用
        if(ptr_mem)
        {
            free_pages(ptr_mem, 1);
        }
        释放分配的页。
        
        在应用中我们调用mmap函数获取映射地址的指针。
        mmap声明如下:
        void * mmap(void *addr,size_t length,int prot, int flags,int fd,off_t offset);
        该函数执行成功返回一个指针,应用可以直接对这个指针进行操作,就可以操作驱动中映射的内存了。
        参数说明如下:
        void *addr 是程序员所希望的虚拟地址作为起始映射地址,通常为NULL,内核自动分配。
                size_t length当然是指需要映射的区域大小。
                int flags是指对这段区域的保护方式。具体的可以参看内核源码的linux/mm.h。常用的是PROT_EXEC,PROT_READ,PROT_WRITE,PROT_NONE。
                int flags主要是指对这段区域的映射方式,主要分为两种方式MAP_SHARE,MAP_PRIVATE.其中的MAP_SHARE是指对映射区域的写操作会更新到文件中,这样就相当于直接操作文件。而MAP_PRIVATE通常采用一种称为"写时保护的机制"实现映射,对映射区的写操作不会更新到文件中,实现方法是将需要被写操作的页复制到重新分配的新页中,然后再对新的页进行写操作。原来的映射并没有改变,但是读操作并不会重新分配物理内存空间。具体的参考深入理解计算机系统。
                int fd是指将被映射的文件描述符,映射需要保证文件描述符的正确性。
                off_t offset是指从文件的具体位置开始映射,通常情况下可以设置为0,即从开头映射。这里需要注意的是这个偏移必须要页对齐的,就是说必须是4096的倍数,否则mmap将失败。这个对应的就是驱动中的vm_pgoff。
下面是应用调用的例子:
        fd1= open("/dev/filename", O_RDWR  );
        mmap_ptr = (unsigned char *)mmap(0, 4096, PROT_READ |PROT_WRITE , MAP_SHARED , fd1, 0);
        mmap_ptr2 = (unsigned char *)mmap(0, 4096, PROT_READ |PROT_WRITE , MAP_SHARED , fd1, 8192);
        。。。。。。。
        munmap(mmap_ptr ,4096);
        munmap(mmap_ptr2 ,4096);


    int (*open) (struct inode * inode , struct file *  filp ) ;
        inode 为文件节点,这个节点只有一个,无论用户打开多少个文件,都只是对应着一个inode结构;
        但是filp就不同,只要打开一个文件,就对应着一个file结构体,file结构体通常用来追踪文件在运行时的状态信息,所以我们通常会在open中分配针对该设备的将结构,然后将这个结构的地址赋值给struct file的private_data,这样在read、write等其他的方法中就可以使用这个分配的结构了。
        尽管这常常是对设备文件进行的第一个操作, 不要求驱动声明一个对应的方法. 如果这个项是 NULL, 设备打开一直成功, 但是你的驱动不会得到通知.


    int (*release) (struct inode *, struct file *);
        release ()函数当最后一个打开设备的用户进程执行close()系统调用的时候,内核将调用驱动程序release()函数.release函数的主要任务是清理未结束的输入输出操作,释放资源,用户自定义排他标志的复位等。在文件结构被释放时引用这个操作. 如同 open, release 可以为 NULL.


    struct file {
                /*
                * fu_list becomes invalid after file_free is called and queued via
                * fu_rcuhead for RCU freeing
                */
                union {
                struct list_headfu_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;
                
                /*
                * Protects f_ep_links, f_flags, f_pos vs i_size in lseek SEEK_CUR.
                * Must not be taken from IRQ context.
                */
                spinlock_t  f_lock;
                #ifdef CONFIG_SMP
                int f_sb_list_cpu;
                #endif
                atomic_long_t  f_count;
                unsigned int f_flags;
                fmode_t  f_mode;
                loff_t  f_pos;
                struct fown_structf_owner;
                const struct cred*f_cred;
                struct file_ra_statef_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_headf_ep_links;
                struct list_headf_tfile_llink;
                #endif /* #ifdef CONFIG_EPOLL */
                struct address_space*f_mapping;
                #ifdef CONFIG_DEBUG_WRITECOUNT
                unsigned long f_mnt_write_state;
                #endif
    };
    这个结构体代表一个打开的文件,系统中的每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建,并传递给在文件上进行操作的任何函数。
    下面介绍下我们需要关注的成员变量
    unsigned int  f_flags; 当打开文件时指定的标志,对应系统调用open的int flags参数。驱动程序为了支持非阻塞型操作需要检查这个标志。
    mode_t  f_mode; 对文件的读写模式,对应系统调用open的mod_t mode参数。如果驱动程序需要这个值,可以直接读取这个字段。
    void  *private_data;指向私有数据的指针,用户在open的时候可以创建自己的数据结构,用这个指针保存地址,在对设备操作的时候使用这个结构。


    struct inode {
                umode_t  i_mode;
                unsigned shorti_opflags;
                uid_t i_uid;
                gid_t i_gid;
                unsigned int  i_flags;
                
                #ifdef CONFIG_FS_POSIX_ACL
                struct posix_acl*i_acl;
                struct posix_acl*i_default_acl;
                #endif
                
                const struct inode_operations*i_op;
                struct super_block*i_sb;
                struct address_space*i_mapping;
                
                #ifdef CONFIG_SECURITY
                void *i_security;
                #endif
                
                
                /* Stat data, not accessed from path walking */
                unsigned long  i_ino;
                /*
                * Filesystems may only read i_nlink directly.  They shall use the
                * following functions for modification:
                *
                *    (set|clear|inc|drop)_nlink
                *    inode_(inc|dec)_link_count
                */
                union {
                        const unsigned int i_nlink;
                        unsigned int __i_nlink;
                };
                dev_t i_rdev;
                struct timespeci_atime;
                struct timespeci_mtime;
                struct timespeci_ctime;
                spinlock_t  i_lock; /* i_blocks, i_bytes, maybe i_size */
                unsigned short          i_bytes;
                blkcnt_t  i_blocks;
                loff_t  i_size;
                
                #ifdef __NEED_I_SIZE_ORDERED
                seqcount_t  i_size_seqcount;
                #endif
                
                /* Misc */
                unsigned long  i_state;
                struct mutex  i_mutex;
                
                unsigned long  dirtied_when; /* jiffies of first dirtying */
                
                struct hlist_nodei_hash;
                struct list_headi_wb_list;
                /* backing dev IO list */
                struct list_headi_lru;
                /* inode LRU list */
                struct list_headi_sb_list;
                union {
                        struct list_headi_dentry;
                        struct rcu_headi_rcu;
                };
                atomic_t  i_count;
                unsigned int  i_blkbits;
                u64 i_version;
                atomic_t  i_dio_count;
                atomic_t  i_writecount;
                const struct file_operations*i_fop;
                /* former ->i_op->default_file_ops */
                struct file_lock*i_flock;
                struct address_spacei_data;
                #ifdef CONFIG_QUOTA
                struct dquot  *i_dquot[MAXQUOTAS];
                #endif
                struct list_headi_devices;
                union {
                        struct pipe_inode_info*i_pipe;
                        struct block_device*i_bdev;
                        struct cdev  *i_cdev;
                };
                
                __u32 i_generation;
                
                #ifdef CONFIG_FSNOTIFY
                __u32 i_fsnotify_mask; /* all events this inode cares about */
                struct hlist_headi_fsnotify_marks;
                #endif
                
                
                #ifdef CONFIG_IMA
                atomic_t  i_readcount; /* struct files open RO */
                #endif
                void *i_private; /* fs or device private pointer */
    };
    每一个设备文件对应一个inode ,struct inode 和struct file 的区别在于,例如我有一个设备/dev/mytest,那么这个/dev/mytest就对应一个struct inode,而我每次打开/dev/mytest(可以同时打开多次),都会分配一个struct file。也就是一个设备文件只对应一个struct inode(同时打开多次,也只有一个),而如果这个设备文件被打开多次,那么就对应多个struct file。
    下面是我们需要关注的成员:
    dev_t i_rdev;该设备文件对应的设备号。
    struct cdev *i_cdev;该设备的cdev结构的指针。


2 相关的函数:
    int alloc_chrdev_region(dev_t *dev,unsigned int firstminor,unsigned int count,char *name);
    该函数的功能是动态分配一个设备号,通过dev带回。
    参数说明:dev是用来带回动态分配的设备号
            firstminor第一个次设备号,通常设置为0
            count 要分配的设备数
            name 分配的设备号对应的名字,这个名字我们可以在/proc/devices里面看到。可以用cat /proc/devices查看
    返回值: 0执行成功 小于0 失败。


    int register_chrdev_region(dev_t first, unsigned int count, char *name);
    该函数的功能是注册一个(或者一组)已经定义的设备号。
    参数说明:first 是要分配的起始设备编号.first 的次编号部分常常是 0。
           count 是请求的连续设备编号的总数
           name 注册的设备号对应的名字,这个名字我们可以在/proc/devices里面看到。可以用cat /proc/devices查看
    返回值: 0执行成功 小于0 失败。
    以上这两个函数功能类似,都是注册一个或者一组设备号,但是不同的是alloc_chrdev_region是动态分配的,系统会自动在没有分配的主设备号中找一个可用的来分配。而register_chrdev_region是用户自己定义一个主设备号,来注册的。调用这个函数我们必须要确保我们定义的设备号没有被使用,否则这个函数会失败。为了避免冲突和便于移植到其他平台,建议最好使用alloc_chrdev_region动态分配一个设备号。


    void unregister_chrdev_region(dev_t first, unsigned int count);
    该函数的功能是释放注册的设备号
    参数说明:first为第一个设备号 。
              count为申请释放的设备数量


    设备号操作的相关的宏:
    MKDEV(ma,mi) 该宏的功能是根据主设备号和次设备号得到一个设备号。ma为主设备号 ,mi为次设备号
    MAJOR(dev)   该宏的功能是获取主设备号 。dev为设备号
    MINOR(dev)   该宏的功能为获取次设备号。参数dev是设备号




    void cdev_init(struct cdev *cdev, const struct file_operations *fops);
    函数的功能是初始化一个cdev的结构。
    参数说明:struct cdev *cdev 已经定义的cdev结构的指针 ,
              const struct file_operations *fops 已经定义的file_operations 的结构的指针,该结构定义了设备文件的一系列操作。
    示例代码如下:
    struct cdev my_cdev;
    cdev_init(&my_cdev, &fops);
    my_cdev.owner = THIS_MODULE;


    struct cdev *cdev_alloc(void);
    函数的功能和cdev_init类似,但是这个函数是动态分配的一个struct cdev的结构。
    返回值:分配成功返回struct cdev的结构的地址失败返回NULL。
    示例代码如下:
    struct cdev *my_cdev = cdev_alloc();
    if(my_cdev)
    {
        my_cdev->ops = &fops;
        my_cdev->owner = THIS_MODULE;
    }


    int cdev_add(struct cdev *p, dev_t dev, unsigned count);
    函数的功能是将字符设备驱动程序注册到系统中。
    参数说明:struct cdev *p; 将要加入系统的cdev ,p是之前调用cdev_init或者cdev_alloc初始化好的。
     dev_t dev;已经注册的设备号。这个是通过alloc_chrdev_region或者register_chrdev_region注册的设备号。
              unsinged int count;要注册的设备的数目。
    返回值:执行成功返回0,失败返回负值




    void cdev_del(struct cdev *p);
    函数功能是释放之前注册的cdev。
    函数参数:struct cdev *p,之前用cdev_add注册的cdev的指针。


    struct class *class_create(struct module *owner, const char *name);
    函数功能是分配一个struct class的结构。
    参数说明:struct module *owner 指向模块owner的指针,通常设置为THIS_MODULE
              const char *name class的名字,这个名字可以在/sys/class/看到,系统将在/sys/class/下创建参数name指定的目录。
    返回值:执行成功返回struct class的地址,失败返回NULL。
    说明:实际上class_create不是一个函数而是一个宏,
    #define class_create(owner, name) \
    ({ \
                static struct lock_class_key __key;\
                __class_create(owner, name, &__key);\
    })
    不过对于我们在实际调用中,可以不需要关注的。


    void class_destroy(struct class *cls);
    函数功能是注销一个class。
    参数 cls就是我们之前用class_create分配的一个struct class的指针。
    这个函数和class_create成对使用的。


    int class_register(struct class *cls);
    函数功能和class_create类似,也是注册一个class,实际上class_create内部也会调用__class_register。不同的是这个函数的参数是已经分配好的结构。
    参数cls是struct class的指针
    返回值执行成功返回0,失败返回负值。
    实际上这个也是一个宏
    #define class_register(class) \
    ({ \
                static struct lock_class_key __key;\
                __class_register(class, &__key);\
    } )
    下面是class_register的示例代码:
    struct class  my_class;
    my_class->name = "myclass";
    my_class->owner = THIS_MODULE;   
    my_class->class_release = class_create_release;
    // 将class注册到内核中,同时会在/sys/class/下创建class对应的节点
    int retval = class_register(my_class);


    void class_unregister(struct class *cls);
    注销一个class,这个函数和class_register成对使用。


    struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void * drvdata, const char *fmt, ...);
    函数功能是用于动态的建立逻辑设备,并对新的逻辑设备类进行相应初始化,将其与函数的第一个参数所代表的逻辑类关联起来,然后将此逻辑设备加到linux内核系统的设备驱动程序模型中。函数能够自动在/sys/devices/virtual目录下创建新的逻辑设备目录,在/dev目录下创建于逻辑类对应的设备文件。
    参数说明:cls struct class 指针,必须在本函数调用之前先被调用class_register或者class_create注册的。
              parent 该设备的父设备的指针,如果没有就设置为NULL
              devt   该设备的设备号
     drvdata 传递给该设备的私有数据的指针,如果没有就直接用NULL
              fmt     设备名称,就是在dev目录下显示的设备名


    void device_destroy(struct class *cls, dev_t devt);
    函数功能:用于从linux内核系统设备驱动程序模型中移除一个设备,并删除/sys/devices/virtual目录下对应的设备目录及/dev/目录下对应的设备文件
    参数说明:cls struct class 指针
              devt 设备号


3 下面是示例代码:


在头文件中定义
#define SET1 _IOR('O', 1, int)
#define SET2 _IOR('O', 2, int)
#define SET3 _IOR('O', 3, int)


在C代码中
#define TEST_DEV_NAME "mytest"
#define MAX_DEV  3
typedef struct 
{
        dev_t    test_dev;
        struct   cdev test_cdev;
        struct   class *test_class;
 
}test_DEV_struct;


typedef struct
{
        char info[100];
        int offset;
}test_data;
 
static ssize_t test_write(struct file *filp, const char __user *data,size_t len, loff_t *ppos)
{
        test_data * ptr = filp->private_data;
        if(copy_from_user(ptr->info  ,data ,len) == 0 )
        {
                ptr->offset=0;
                return len;
        }
        else
        {
                return 0;
        }
}


static ssize_t test_read(struct file *filp, char __user *data, size_t len, loff_t *ppos)
{
        test_data * ptr = filp->private_data;
        
        int length =strlen( ptr->info);
        if(length<=ptr->offset)
        {
                return 0;
        }
        if(ptr->offset+len>length)
        {
                len = length-ptr->offset;
        }
         
        copy_to_user(data ,ptr->info+ptr->offset ,len+1) ;
        ptr->offset += len;
        
        return len;
}
static loff_t test_seek(struct file *filp, loff_t pos , int mod)
{
        return 0;
}
static int test_open (struct inode *inode, struct file *filp) 
{
        static int count = 0;
        dev_t dev = inode->i_rdev;
        filp->f_pos = 16;
        test_data * ptr=kmalloc(sizeof(test_data), GFP_KERNEL);
        sprintf(ptr->info ,"NO %d called major=0x%x minor=0x%x",count,MAJOR(dev),MINOR(dev));
        ptr->offset = 0;
        count++;
        filp->private_data = ptr;//注意这里的filp每个打开的设备(同一个设备代开多次)都会有一个独立的private_data
        return 0;
}
static int test_release (struct inode *inode, struct file *filp)
{
        kfree( filp->private_data ); 
        return 0;
}
static long test_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
        test_data * ptr = filp->private_data;
        char * p = (char*)arg;
        char buf[100];
        if(copy_from_user(buf ,p ,100) == 0 )
        {
        }
        else
        {
                printk(KERN_ERR"copy arg error\r\n");
                return -1;
        }
        switch(cmd)
        {
                case SET1:
                        sprintf(ptr->info ,"%s cmd=%d",buf,cmd);
                        break;
                case SET2:
                        sprintf(ptr->info ,"%s cmd=%d",buf,cmd);
                        break;
                case SET3:
                        sprintf(ptr->info ,"%s cmd=%d",buf,cmd);
                        break;
        }
        ptr->offset = 0;
        return 0;
}
struct file_operations test_fops =
{
        .owner  = THIS_MODULE,
        .open = test_open,
        .release  = test_release,
        .read       = test_read, 
        .write      = test_write,
        .llseek     = test_seek,
        .unlocked_ioctl = test_ioctl, 
};
test_DEV_struct *test_dev; 
static int __init test_init(void)
{
        int err = -ENOMEM;
        int ret;
        int i;
        int major;
        
        test_dev = kmalloc(sizeof( test_DEV_struct), GFP_KERNEL);
        if(test_dev == NULL)
                return -ENOMEM;
          
        // alloc_chrdev_region\class_create\device_create这三个函数中指定的名字,可以是不一样的,也不影响驱动的执行
        ret = alloc_chrdev_region(&(test_dev->test_dev), 0, MAX_DEV, TEST_DEV_NAME);
        if( ret<0 )
        {
                goto fail1 ;
        }
        major = MAJOR(test_dev->test_dev); 
        memset(&(test_dev->test_cdev), 0, sizeof(struct   cdev));
         
        cdev_init(&(test_dev->test_cdev), &test_fops);
        
        ret = cdev_add(&(test_dev->test_cdev), test_dev->test_dev, MAX_DEV );
        if(ret<0)
        {
                goto fail2;
        } 
        test_dev->test_class = class_create(THIS_MODULE, TEST_DEV_NAME);
        
        for(i=0;i<MAX_DEV;i++)
        {
            device_create(test_dev->test_class, NULL, MKDEV(major ,i), NULL, "%s%d",TEST_DEV_NAME,i);
        }
        printk("test driver is successfully loaded\n");
        return 0;
fail2:
        unregister_chrdev_region(test_dev->test_dev, MAX_DEV);
 
fail1:  
        kfree(test_dev);
        return err; 
}
static void __exit test_exit(void)
{
        int i;
        //这里要注意注销的顺序,如果先注销了class在调用device_destroy,会造成异常
        for(i=0;i<MAX_DEV;i++)
        {
                device_destroy(test_dev->test_class, test_dev->test_dev+i);
        } 
        cdev_del(&(test_dev->test_cdev));
        unregister_chrdev_region(test_dev->test_dev, MAX_DEV);
        class_destroy( test_dev->test_class ); 
        
        kfree(test_dev);  
}
module_init(test_init);
module_exit(test_exit);


MODULE_AUTHOR("xxx Inc.");
MODULE_DESCRIPTION("testfor application");
//MODULE_LICENSE是定义模块许可的,这个一定不能漏掉,否则在加载模块的时候可能会出错,造成模块无法加载。
MODULE_LICENSE("GPL");




运行上面个的代码,我们就可以在/dev目录下看到mytest0 、mytest1 、mytest2三个设备节点了,在应用中就可以通过open close read write 对这些设备进行操作了。
可能大家还有一个疑问,对于这个驱动,我们对应了三个设备,那么在open的时候我们怎么知道打开的到底是mytest0 还是mytest1 或者mytest2呢?
这个问题我们可以通过inode->i_rdev来区分了,inode->i_rdev就是设备的设备号,我们创建的三个设备的次设备号分别是0、1、2,所以我们只要读一下次设备号就知道对应的设备了。
Logo

更多推荐