/* * Simple - REALLY simple memory mapping demonstration. * * Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet * Copyright (C) 2001 O'Reilly & Associates * * The source code in this file can be freely used, adapted, * and redistributed in source or binary form, so long as an * acknowledgment appears in derived source files.  The citation * should list that the code comes from the book "Linux Device * Drivers" by Alessandro Rubini and Jonathan Corbet, published * by O'Reilly & Associates.   No warranty is attached; * we cannot take responsibility for errors or fitness for use. * * $Id: simple.c,v 1.12 2005/01/31 16:15:31 rubini Exp $ */#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;module_param(simple_major, int, 0);MODULE_AUTHOR("Jonathan Corbet");MODULE_LICENSE("Dual BSD/GPL");/* * Open the device; in fact, there's nothing to do here. */static int simple_open (struct inode *inode, struct file *filp){	return 0;}/* * Closing is just as simpler. */static int simple_release(struct inode *inode, struct file *filp){	return 0;}/* * Common VMA ops. */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");}/* * The remap_pfn_range version of mmap.  This one is heavily borrowed * from drivers/char/mem.c. */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;}/* * The nopage version. */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;	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_ops = &simple_nopage_vm_ops;	simple_vma_open(vma);	return 0;}/* * Set up the cdev structure for a device. */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);	/* Fail gracefully if need be */	if (err)		printk (KERN_NOTICE "Error %d adding simple%d", err, minor);}/* * Our various sub-devices. *//* Device 0 uses remap_pfn_range */static struct file_operations simple_remap_ops = {	.owner   = THIS_MODULE,	.open    = simple_open,	.release = simple_release,	.mmap    = simple_remap_mmap,};/* Device 1 uses nopage */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 0static struct file_operations *simple_fops[MAX_SIMPLE_DEV] = {	&simple_remap_ops,	&simple_nopage_ops,};#endif/* * We export two simple devices.  There's no need for us to maintain any * special housekeeping info, so we just deal with raw cdevs. */static struct cdev SimpleDevs[MAX_SIMPLE_DEV];/* * Module housekeeping. */static int simple_init(void){	int result;	dev_t dev = MKDEV(simple_major, 0);	/* Figure out our device number. */	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;	/* Now set up two cdevs. */	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);