字符驱动

//#include <linux/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/kernel.h>   /* printk() */
#include <linux/slab.h>   /* kmalloc() */
#include <linux/fs.h>       /* everything... */
#include <linux/errno.h>    /* error codes */
#include <linux/types.h>    /* size_t */
#include <linux/mm.h>
#include <linux/kdev_t.h>
#include <asm/page.h>
#include <linux/cdev.h>

#include <linux/device.h>
//主设备号
static int simple_major = 0;
//从设置号
static int minor=0;
module_param(simple_major, int, 0);
MODULE_AUTHOR("Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");
int simple_open (struct inode *inode, struct file *filp)
{
    return 0;
}

static int simple_release(struct inode *inode, struct file *filp)
{
    return 0;
}

void simple_vma_open(struct vm_area_struct *vma)
{
    printk(KERN_NOTICE "Simple VMA open, virt %lx, phys %lx\n",
           vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
}

void simple_vma_close(struct vm_area_struct *vma)
{
    printk(KERN_NOTICE "Simple VMA close.\n");
}

static struct vm_operations_struct simple_remap_vm_ops = {
    .open =  simple_vma_open,
    .close = simple_vma_close,
};

static int simple_remap_mmap(struct file *filp, struct vm_area_struct *vma)
{
    if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
                        vma->vm_end - vma->vm_start,
                        vma->vm_page_prot))
        return -EAGAIN;

    vma->vm_ops = &simple_remap_vm_ops;
    simple_vma_open(vma);
    return 0;
}

struct page *simple_vma_nopage(struct vm_area_struct *vma,
                               unsigned long address, int *type)
{
    struct page *pageptr;
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
    unsigned long physaddr = address - vma->vm_start + offset;
    unsigned long pageframe = physaddr >> PAGE_SHIFT;

    // Eventually remove these printks
    printk (KERN_NOTICE "---- Nopage, off %lx phys %lx\n", offset, physaddr);
    printk (KERN_NOTICE "VA is %p\n", __va (physaddr));
    printk (KERN_NOTICE "Page at %p\n", virt_to_page (__va (physaddr)));
    if (!pfn_valid(pageframe))
        //return NOPAGE_SIGBUS;
    return NULL;
    pageptr = pfn_to_page(pageframe);
    printk (KERN_NOTICE "page->index = %ld mapping %p\n", pageptr->index, pageptr->mapping);
    printk (KERN_NOTICE "Page frame %ld\n", pageframe);
    get_page(pageptr);
    if (type)
        *type = VM_FAULT_MINOR;
    return pageptr;
}

static struct vm_operations_struct simple_nopage_vm_ops = {
    .open =   simple_vma_open,
    .close =  simple_vma_close,
    //.nopage = simple_vma_nopage,
};

static int simple_nopage_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;

    if (offset >= __pa(high_memory) || (filp->f_flags & O_SYNC))
        vma->vm_flags |= VM_IO;
   // vma->vm_flags |= VM_RESERVED;
    vma->vm_flags |=(VM_DONTEXPAND | VM_DONTDUMP);

    vma->vm_ops = &simple_nopage_vm_ops;
    simple_vma_open(vma);
    return 0;
}

/*
 * Set up the cdev structure for a device.
 */
//https://www.cnblogs.com/chen-farsight/p/6181341.html
//struct file_operations {
//    　　struct module *owner;//拥有该结构的模块的指针，一般为THIS_MODULES
//    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);//仅用于读取目录，对于设备文件，该字段为NULL
//    unsigned int (*poll) (struct file *, struct poll_table_struct *); //轮询函数，判断目前是否可以进行非阻塞的读写或写入
//    　　int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); //执行设备I/O控制命令
//    　　long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); //不使用BLK文件系统，将使用此种函数指针代替ioctl
//    　　long (*compat_ioctl) (struct file *, unsigned int, unsigned long); //在64位系统上，32位的ioctl调用将使用此函数指针代替
//    　　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); //通知设备FASYNC标志发生变化
//    　　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 **);
//};
static void simple_setup_cdev(struct cdev *dev, int minor,
                              struct file_operations *fops)
{
    int err, devno = MKDEV(simple_major, minor);
    //字符设备注册
    cdev_init(dev, fops);
    //当前模块挺有这个设备
    dev->owner = THIS_MODULE;
    dev->ops = fops;
    //添加
    err = cdev_add (dev, devno, 1);
    if (err)
        printk (KERN_NOTICE "Error %d adding simple%d", err, minor);
}

//初始化
static struct file_operations simple_remap_ops = {
    .owner   = THIS_MODULE,
    .open    = simple_open,
    .release = simple_release,
    .mmap    = simple_remap_mmap,
};

//初始化
static struct file_operations simple_nopage_ops = {
    .owner   = THIS_MODULE,
    .open    = simple_open,
    .release = simple_release,
    .mmap    = simple_nopage_mmap,
};

#define MAX_SIMPLE_DEV 2

#if 0
static struct file_operations *simple_fops[MAX_SIMPLE_DEV] = {
    &simple_remap_ops,
    &simple_nopage_ops,
};
#endif

//俩个简单的字符设备
static struct cdev SimpleDevs[MAX_SIMPLE_DEV];

static int simple_init(void)
{
    int result;
    //MKDEV是将主设备号和次设备号转换成dev_t类型
    dev_t dev = MKDEV(simple_major, minor);

    //找出设备号
    if (simple_major)
        //进行字符设备设备节点的分配
        result = register_chrdev_region(dev, 2, "simple");
    else {
        //动态申请
        result = alloc_chrdev_region(&dev, 0, 2, "simple");
        simple_major = MAJOR(dev);
    }
    if (result < 0) {
        printk(KERN_WARNING "simple: unable to get major %d\n", simple_major);
        return result;
    }
    if (simple_major == 0)
        simple_major = result;
    printk(KERN_WARNING "haha!!!!\n");
    //设置俩个字符设备
    simple_setup_cdev(SimpleDevs, 0, &simple_remap_ops);
    simple_setup_cdev(SimpleDevs + 1, 1, &simple_nopage_ops);
    return 0;
}

static void simple_cleanup(void)
{
    cdev_del(SimpleDevs);
    cdev_del(SimpleDevs + 1);
    unregister_chrdev_region(MKDEV(simple_major, 0), 2);
}

module_init(simple_init);
module_exit(simple_cleanup);

//#include <linux/config.h>
#include <linux/mod