#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <asm/io.h>
#include <linux/pci.h>

#define VENDOR_ID 0x14E4
#define DEVICE_ID 0x1600
#define SIZE 	  10000 

struct file_operations fops ;
static int major ;
struct pci_dev *pci_dev = NULL ;
dma_addr_t bus_addr ;

static int my_open(struct inode *inode, struct file *file)
{
	void *virt_addr = (void *)NULL ;
	printk("I am in my_open\n") ;
	
	virt_addr = pci_alloc_consistent(pci_dev, SIZE, &bus_addr) ;

    	if (virt_addr == NULL)
    	{
        	printk("pci_alloc_consistent failed\n") ;
        	return -ENOMEM ;
    	}	
	else
	{
		printk("pci_alloc_consistent successful, virt_addr = %ld\n", (unsigned long)virt_addr) ;
	}

	file->private_data = virt_addr ;
	return 0 ;
}

static int my_close(struct inode *inode, struct file *file)
{
	int *ptr, i ;
	void *virt_addr = file->private_data ;
	printk("I am in my_close\n") ;
	printk("%s virt_addr = %ld\n", (char *)virt_addr, (unsigned long)virt_addr) ;

	ptr = (int *)virt_addr ;

	printk("my_close : data read from kernel : \n") ;

	for(i = 0 ; i < 2048 ; i++)
    	{
        	printk("%d ", *(ptr + i)) ;
    	}

	pci_free_consistent(pci_dev,SIZE,virt_addr,bus_addr) ;

	return 0 ;
}

void my_vma_open(struct vm_area_struct *vma)
{
        printk("I am in my_vma_open\n") ;
}

void my_vma_close(struct vm_area_struct *vma)
{
        printk("I am in my_vma_close\n") ;
}

struct page *my_vma_nopage(struct vm_area_struct *vma, unsigned long address, int *type)
{
        struct page *page ;
        unsigned long offset = address - vma->vm_start ;
        void *base_kern_addr = vma->vm_private_data ;
        printk("I am in my_vma_nopage\n") ;

	printk("nopage : address = %ld, vma->vm_start = %ld, offset = %ld, base_kern_addr = %ld\n",
		address, (unsigned long)vma->vm_start, offset, (unsigned long)base_kern_addr) ;

        page = virt_to_page(base_kern_addr + offset) ;

        get_page(page) ;

        if (type)
        {
                *type = VM_FAULT_MINOR ;
        }

        return page ;
}

static struct vm_operations_struct my_vm_ops =
{
        .open = my_vma_open,
        .close = my_vma_close,
        .nopage = my_vma_nopage,
} ;

static int my_mmap(struct file *file, struct vm_area_struct *vma)
{
	void *data_ptr = (void *)file->private_data ;
	printk("I am in my_mmap\n") ;
	printk("data_ptr = %ld\n", (unsigned long) data_ptr) ;

	vma->vm_flags |= VM_RESERVED ;
        vma->vm_ops = &my_vm_ops ;
        vma->vm_private_data = data_ptr ;
        my_vma_open(vma) ;

	return 0 ;
}

int init_module(void)
{
	printk("I am in init_module\n") ;

	pci_dev = pci_get_device(VENDOR_ID, DEVICE_ID, pci_dev) ;

        if (pci_dev == (struct pci_dev *)NULL)
        {
            printk("pci_get_device failed\n") ;
	    return -1 ;
        }

	printk("pci_dev found, pci_dev = %ld\n", (unsigned long)pci_dev) ;

	major = register_chrdev(0, "mydriver", &fops) ;
	if(major == -1)
	{
		printk("register_chrdev failed\n") ;
		return -1 ;
	}
	printk("module is registered with major no = %d\n", major) ;
	return 0 ;
}

void cleanup_module(void)
{
	printk("I am in cleanup_module\n") ;
	unregister_chrdev(major, "mydriver") ;
}

struct file_operations fops = 
{
	.open = my_open,
	.release = my_close, 
	.mmap = my_mmap,
} ;