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

/*
 * 分层分工设计演示
 * 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 = 0;
//设备名
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 = 0;
    
    //定义两个操作方法集指针用于保存新旧操作方法，
    const struct file_operations *old_f, *new_f = NULL;

    struct mydev *mydev = NULL;

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

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

    err = 0;
    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, 0, MYDEVMAX, mydevname);
    if (ret < 0) {
        printk(KERN_ERR "alloc_chrdev_region error.
");
        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
");
        ret = PTR_ERR(mydevclass);
        goto ERR_STEP_1;
    }

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

    printk(KERN_INFO "mydev_init done.
");
    
    return 0;

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

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

    class_destroy(mydevclass);

    printk(KERN_INFO "mydev_exit done.
");
}

module_init(mydev_init);
module_exit(mydev_exit);

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

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

    return mydevarr[minor];
}

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

    //先判断次设备号是否为自动分配（这里定义255位自动分配）
    if(DYNAMIC_MINOR == obj->minor){
        //遍历找到最小未用的次设备号
        for(i = 0; i < MYDEVMAX; i++){
            if(NULL == mydevarr[i])
                break;
        }
        
        //若设备已满返回错误（这里定义64个设备时就不能再添加了）
        if(MYDEVMAX == i){
            printk(KERN_ERR "[add_mydev]: Cann't alloc minor.
");
            return -EBUSY;
        }
        //保存分配到的次设备号
        obj->minor = i;
    } else {
        
        //指定的设备号已被用，返回错误
        if(NULL != find_mydev(obj->minor)){
            printk(KERN_ERR "[add_mydev]: a invalid minor.
");
            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
", mydev_major, obj->minor);
    
    return 0;
}

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

    mydevarr[obj->minor] = NULL;    

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

    return 0;
}

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

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

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

/*
 * 自定义设备框架
 * 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 = 0;

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

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

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

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
", minor, filep->f_path.dentry->d_inode);
    return 0;
}

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
", minor, filep->f_path.dentry->d_inode);
    return 0;
}

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.
");
    return add_mydev(&mydev);
}

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

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

#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(0 > fd){
        perror("open");
        return -1;
    }
    printf("open done. fd=%d
", fd);

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

    close(fd);
    printf("close done.
");
    return 0;
}

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

 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