Linux驱动开发cdev驱动分层设计

 #ifndef MYDEV_H
 #define MYDEV_H

 #define DYNAMIC_MINOR 256

 struct mydev{
     const char *name;
     const struct file_operations *fops;

     int minor;
     //private    设备文件 和互斥锁
     struct device *thisdev;
     struct mutex lock;
 };

 extern int add_mydev(struct mydev *);
 extern int del_mydev(struct mydev *);

 #endif

mydev.h

 /*
  * 分层分工设计演示
  * cdev为接口层
  * write by panzhh
  */

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/cdev.h>
 #include <linux/device.h>

 #include "../include/mydev.h"

 //用来存放设备文件目录指针
 static struct class *mydevclass = NULL;

 //最多为64个字符设备的数组
 #define MYDEVMAX 64
 static struct mydev *mydevarr[MYDEVMAX];

 //存放主设备号
 static int mydev_major = ;
 //设备名
 static const char mydevname[] = "mydev";

 //静态分配字符设备对象
 static struct cdev cdev;

 //自己定义的字符设备匹配方法（通过次设备号）
 static struct mydev *find_mydev(int minor);

 //open方法
 static int mydev_open(struct inode *inode, struct file *filp)
 {
     int err = ;

     //定义两个操作方法集指针用于保存新旧操作方法，
     const struct file_operations *old_f, *new_f = NULL;

     struct mydev *mydev = NULL;

     int minor = iminor(inode);
     printk(KERN_INFO "[%d]mydev_open\n", minor);

     //匹配字符设备
     mydev = find_mydev(minor);
     if(NULL == mydev){
         printk(KERN_ERR "find_mydev ERR.\n");
         return -ENXIO;
     }

     err = ;
     new_f = fops_get(mydev->fops);
     old_f = filp->f_op;
     filp->f_op = new_f;
     if (filp->f_op->open) {
         filp->private_data = mydev;
         err=filp->f_op->open(inode,filp);
         if (err) {
             fops_put(filp->f_op);
             filp->f_op = fops_get(old_f);
         }
     }
     fops_put(old_f);

     return err;
 }

 static struct file_operations mydevfops = {
     .owner    = THIS_MODULE,
     .open    = mydev_open,
 };

 ///////////////////////////////////////////////////////////////////////////////////通用字符设备 init 框架
 alloc_chrdev_region 分配设备号

 static int __init mydev_init(void)
 {
     int ret;
     dev_t dev;

     ret = alloc_chrdev_region(&dev, , MYDEVMAX, mydevname);
     if (ret < ) {
         printk(KERN_ERR "alloc_chrdev_region error.\n");
         return ret;
     }
     mydev_major = MAJOR(dev);

       cdev_init(&cdev, &mydevfops);
      ret = cdev_add(&cdev, dev, MYDEVMAX);
     if (ret) {
         printk(KERN_ERR "Error %d adding %s", ret, mydevname);
         goto ERR_STEP_0;
     }

     //sys/class/xxx
     mydevclass = class_create(THIS_MODULE, mydevname);
     if (IS_ERR(mydevclass)) {
         printk(KERN_ERR "Unable create sysfs class for demo\n");
         ret = PTR_ERR(mydevclass);
         goto ERR_STEP_1;
     }

     //初始化cdev对象指针数组为空，具体的对象在设备加载时得到 struct mydev
     for(ret = ; ret < MYDEVMAX; ret++){
         mydevarr[ret] = NULL;
     }

     printk(KERN_INFO "mydev_init done.\n");

     return ;

 ERR_STEP_1:
     cdev_del(&cdev);

 ERR_STEP_0:
     unregister_chrdev_region(dev, MYDEVMAX);

     return ret;
 }

 static void __exit mydev_exit(void)
 {
     dev_t dev;
     dev = MKDEV(mydev_major, );

     cdev_del(&cdev);
     unregister_chrdev_region(dev, MYDEVMAX);

     class_destroy(mydevclass);

     printk(KERN_INFO "mydev_exit done.\n");
 }

 module_init(mydev_init);
 module_exit(mydev_exit);

 ////////////////////////////////////////////////////////////////////

 static struct mydev *find_mydev(int minor)
 {
     if(minor >= MYDEVMAX){
         printk(KERN_ERR "a invalid minor.\n");
         return NULL;
     }

     return mydevarr[minor];
 }

 int add_mydev(struct mydev *obj)
 {
     int i;

     //先判断次设备号是否为自动分配（这里定义255位自动分配）
     if(DYNAMIC_MINOR == obj->minor){
         //遍历找到最小未用的次设备号
         for(i = ; i < MYDEVMAX; i++){
             if(NULL == mydevarr[i])
                 break;
         }

         //若设备已满返回错误（这里定义64个设备时就不能再添加了）
         if(MYDEVMAX == i){
             printk(KERN_ERR "[add_mydev]: Cann't alloc minor.\n");
             return -EBUSY;
         }
         //保存分配到的次设备号
         obj->minor = i;
     } else {

         //指定的设备号已被用，返回错误
         if(NULL != find_mydev(obj->minor)){
             printk(KERN_ERR "[add_mydev]: a invalid minor.\n");
             return -EINVAL;
         }
     }

     //sys/class/xxx/xxx0/dev        创建一个对应设备文件    父目录class指针    父对象 设备号 设备私有数据 设备名
     obj->thisdev = device_create(mydevclass, \
                 NULL, \
                 MKDEV(mydev_major, obj->minor), \
                 obj, \
                 "%s%d", obj->name, obj->minor);
     if (IS_ERR(obj->thisdev)) {
         return PTR_ERR(obj->thisdev);
     }

     mydevarr[obj->minor] = obj;
     printk(KERN_INFO "[add_mydev]: major=%d, minor=%d\n", mydev_major, obj->minor);

     return ;
 }

 int del_mydev(struct mydev *obj)
 {
     if(NULL == find_mydev(obj->minor)){
         printk(KERN_ERR "[del_mydev]: a invalid minor.\n");
         return -EINVAL;
     }

     mydevarr[obj->minor] = NULL;    

     //销毁设备文件
     device_destroy(mydevclass, MKDEV(mydev_major, obj->minor));
     printk(KERN_INFO "[del_mydev]: major=%d, minor=%d\n", mydev_major, obj->minor);

     return ;
 }

 EXPORT_SYMBOL(add_mydev);
 EXPORT_SYMBOL(del_mydev);

 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR ("panzhh");
 MODULE_DESCRIPTION ("Driver for mydev");
 MODULE_SUPPORTED_DEVICE ("mydev");

mydev.c

 ifneq ($(KERNELRELEASE),)
     obj-m := mydev.o
 else
     KERNELDIR := /lib/modules/$(shell uname -r)/build
     PWD       := $(shell pwd)
 modules:
     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
     cp -a Module.symvers $(TOPDIR)/device
     mv *.ko $(TOPDIR)/modules/
 endif

 clean:
     rm -rf *.o *.symvers *.order *.ko *.mod.c *.markers .tmp_versions .*.cmd

mydev.c_Makefile

 ifneq ($(KERNELRELEASE),)
     obj-m := demoa.o
     obj-m += demob.o
 else
     KERNELDIR := /lib/modules/$(shell uname -r)/build
     PWD       := $(shell pwd)
 modules:
     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
     mv *.ko $(TOPDIR)/modules/
 endif

 clean:
     rm -rf *.o *.symvers *.order *.ko *.mod.c *.markers .tmp_versions .*.cmd

demo.c_Makefile

 /*
  * 自定义设备框架
  * write by panzhh
  * 设备具体驱动
  */

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/types.h>

 #include "../include/mydev.h"

 static int minor = ;

 //设备的具体操作方法（驱动）
 static int demo_open(struct inode *inode, struct file *filep)
 {
     minor = iminor(inode);

     printk(KERN_INFO "[%d]demo_open, inode=%p\n", minor, inode);
     return ;
 }

 static int demo_release(struct inode *inode, struct file *filp)
 {
     printk(KERN_INFO "[%d]demo_release\n", minor);
     return ;
 }

 static ssize_t demo_read(struct file *filep, char __user *buf, size_t count, loff_t *fpos)
 {
     printk(KERN_INFO "[%d]demo_read, inode=%p\n", minor, filep->f_path.dentry->d_inode);
     return ;
 }

 static ssize_t demo_write(struct file *filep, const char __user *buf, size_t count, loff_t *fpos)
 {
     printk(KERN_INFO "[%d]demo_write, inode=%p\n", minor, filep->f_path.dentry->d_inode);
     return ;
 }

 static struct file_operations fops = {
     .owner =    THIS_MODULE,
     .read =     demo_read,
     .write =    demo_write,
     .open =     demo_open,
     .release =  demo_release,
 };

 //每个设备的mydev空间在此次分配，并在 init 函数中交由 add_mydev() 进行处理
 struct mydev mydev = {
     .minor    = DYNAMIC_MINOR,
     .name    = "demo",
     .fops    = &fops,
 };

 static int __init demo_init(void)
 {
     printk(KERN_INFO "demo_init.\n");
     return add_mydev(&mydev);
 }

 static void __exit demo_exit(void)
 {
     del_mydev(&mydev);
     printk(KERN_INFO "demob_exit done.\n");
 }

 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR ("panzhh");
 MODULE_DESCRIPTION ("Driver for demo");
 MODULE_SUPPORTED_DEVICE ("demo");

 module_init(demo_init);
 module_exit(demo_exit);

devicedemo.c

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>

 int demofunc(char *devname)
 {
     int fd = open(devname, O_RDWR);
     if( > fd){
         perror("open");
         return -;
     }
     printf("open done. fd=%d\n", fd);

     #define MAX 64
     char buf[MAX]={};
     int ret = write(fd, buf, MAX);
     if( > ret){
         perror("write");
     }
     printf("write done. fd=%d, ret=%d\n", fd, ret);
     ret = read(fd, buf, MAX);
     if( > ret){
         perror("read");
     }
     printf("read done. fd=%d, ret=%d\n", fd, ret);
     getchar();

     close(fd);
     printf("close done.\n");
     return ;
 }

 int main()
 {
     demofunc("/dev/demo0");
     demofunc("/dev/demo1");
 }

test.c

  CC    = gcc
 CFLAGS    = -Wall -O2 -g -std=gnu99
 LDFLAGS    =

 APP    = app
 OBJS    = $(patsubst %.c, %.o, $(wildcard *.c))

 $(APP) : $(OBJS)
     $(CC) -o $@ $^ $(LDFLAGS)

 clean:
     rm -f $(OBJS) $(APP) *.o

test.c _Makefile