#include <linux/module.h>
/**
 *  动态加载模块
 *  定义 LICESENCE(), AUTHOR等等.
 *  kobject kset 定义
 */
#include <linux/init.h>
/**
 * 模块初始化的相关定义
 */
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/slab.h>//kfree, kmalloc

#define MEM_SIZE 0x1000 //定义操作4KB内存
#define MEM_CLEAR 0x1 //定义fileoperations操作
#define MEM_MAJOR 250 //预设主设备号

#define EDITION 1 //调试版本

static int mem_major = MEM_MAJOR;//储存第一次分配到的主设备号,防止重复申请.
/**
 * 驱动操作的设备结构体
 */
struct mem_dev {
    int offset;
    struct cdev cdev;
    unsigned char mem[MEM_SIZE];
}*mem_devp;

int mem_open(struct inode *inode, struct file *filp)
{
//    if (down_interruptible(&mem_devp->sem))
//            return - ERESTARTSYS;
    filp->private_data = http://www.mamicode.com/mem_devp;//将设备结构体指针交给file,适合单设备驱动

    //TODO:多设备

    return 0;
}

int mem_release(struct inode *inode, struct file *filp)
{
    filp->private_data =http://www.mamicode.com/ NULL;
    return 0;
}
static int mem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct mem_dev *dev = filp->private_data;//推荐用这样的方法,而不是直接操作mem_devp,因filp可能会有很多设备

    switch (cmd) {
    case MEM_CLEAR:
        memset(dev->mem, 0, MEM_SIZE);
        printk(KERN_INFO "mem cleared\n");
        break;

    default :
        return - EINVAL;
    }
    return 0;
}
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    printk("read_ppos:%d\n", p);
    printk("read_filp->f_pos:%d\n", filp->f_pos);
    unsigned int count = size;
    int ret = 0;
    struct mem_dev *dev = filp->private_data;

    if (p >= MEM_SIZE) {
        printk(KERN_INFO "ppos >= mem size\n");
        return 0;
    }//越界
    if (count > MEM_SIZE - p) {
        count = MEM_SIZE - p;
    }//读取过多

    if (copy_to_user(buf, (void *)(dev->mem + p), count)) {
        printk(KERN_INFO "%s failed\n", __FUNCTION__);
        ret = - EFAULT;
    } else {
        *ppos += count;
        ret = count;
        printk(KERN_INFO "read %u bytes from %lu\n", count, p);
    }
    return ret;
}

static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    printk("write_ppos:%d\n", p);
    printk("write_filp->f_pos:%d\n", filp->f_pos);
    printk("filp->flag:0x%x\n", filp->f_flags);
    unsigned int count = size;
    int ret = 0;
    struct mem_dev *dev = filp->private_data;

    if (p >= MEM_SIZE) {
        printk(KERN_INFO "ppos >= mem size\n");
        return 0;
    }//越界
    if (count > MEM_SIZE - p) {
        count = MEM_SIZE - p;
    }//写过多

    if (copy_from_user(dev->mem + p, buf, count)) {
        printk(KERN_INFO "%s failed\n", __FUNCTION__);
        ret = - EFAULT;
    } else {
        *ppos += count;
        ret = count;
        printk(KERN_INFO "written %u bytes, now %lu to:%lu\n", count, p, *ppos);
    }
    return ret;
}

static loff_t mem_lseek(struct file *filp, loff_t offset, int orig)
{
    loff_t ret = 0;
    switch (orig) {
    case 0:
        if (offset < 0) {
            ret = - EINVAL;
            break;
        }
        if ((unsigned long)offset > MEM_SIZE) {
            ret = - EINVAL;
            break;
        }
        filp->f_pos = offset;
        ret = filp->f_pos;
        break;
    case 1:
        if ((filp->f_pos + offset) > MEM_SIZE) {
            ret = - EINVAL;
            break;
        }
        if ((filp->f_pos + offset) < 0) {
            ret = - EINVAL;
            break;
        }
        filp->f_pos += offset;
        ret = filp->f_pos;
        break;
    default:
        ret = - EINVAL;
        break;
    }
    return ret;
}

static const struct file_operations mem_fops = {
        .owner = THIS_MODULE,
        .llseek = mem_lseek,
        .read = mem_read,
        .write = mem_write,
        .release = mem_release,
        .open = mem_open,
        .compat_ioctl = mem_ioctl,
};

static void mem_setup_cdev(struct mem_dev *dev, int index)
{
    int err, devno = MKDEV(mem_major, index);//主,次设备号

    cdev_init(&dev->cdev, &mem_fops);//cdev的指针,fileoperations的指针
    dev->cdev.owner = THIS_MODULE;//TODO:THIS_MODULE的实现与作用
    err = cdev_add(&dev->cdev, devno, 1);
    if (err)
        printk(KERN_NOTICE "Error %d adding globalmem cdev:%d", err, index);
}

static int globalmem_init(void)
{
    int result;
    dev_t devno = MKDEV(mem_major, 0);
    if (mem_major)
        result = register_chrdev_region(devno, 1, "globalmem");
    else {
        result = alloc_chrdev_region(&devno, 0 ,1, "globalmem");
        mem_major = MAJOR(devno);
    }
    if (result<0)
        return result;
    mem_devp = kmalloc(sizeof(struct mem_dev), GFP_KERNEL);//get free pages
    if (!mem_devp) {
        result = - ENOMEM;
        goto fail_malloc;
    }
    memset(mem_devp, 0, sizeof(struct mem_dev));
    mem_setup_cdev(mem_devp, 0);
    mem_devp->offset = 0;
    printk(KERN_INFO "edition:%d init success_________________________________________________________\n", EDITION);
    return 0;//返回0或负值,如果不加return会返回17.弹出警告

fail_malloc:
    unregister_chrdev_region(devno, 1);
    return result;
}

static int globalmem_exit(void)
{
    cdev_del(&mem_devp->cdev);
    kfree(mem_devp);
    unregister_chrdev_region(MKDEV(mem_major, 0), 1);
    printk(KERN_INFO "exit success___________________________________________________________________\n");
    return 0;
}

MODULE_AUTHOR("huxy11");

module_param(mem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit)

struct cdev {
    struct kobject kobj;//KOBJECT系统
    struct module *owner;//THIS_MODULE
    const struct file_operations *ops;//file操作
    struct list_head list;//等待队列
    dev_t dev;//设备号
    unsigned int count;//一个计数器,是否和多设备有关
};