path: root/misc-modules/silly.c

/*
 * silly.c -- Simple Tool for Unloading and Printing ISA Data
 *
 * 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: silly.c,v 1.3 2004/09/26 07:02:43 gregkh Exp $
 */

/* =========================> BIG FAT WARNING:
 * This will only work on architectures with an ISA memory range.
 * It won't work on other computers.
 */

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

#include <linux/sched.h>
#include <linux/kernel.h> /* printk() */
#include <linux/fs.h>	  /* everything... */
#include <linux/errno.h>  /* error codes */
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/poll.h>

#include <asm/io.h>
#include <asm/uaccess.h>

int silly_major = 0;
module_param(silly_major, int, 0);
MODULE_AUTHOR("Alessandro Rubini");
MODULE_LICENSE("Dual BSD/GPL");

/*
 * The devices access the 640k-1M memory.
 * minor 0 uses ioread8/iowrite8
 * minor 1 uses ioread16/iowrite16
 * minor 2 uses ioread32/iowrite32
 * minor 3 uses memcpy_fromio()/memcpy_toio()
 */

/*
 * Here's our address range, and a place to store the ioremap'd base.
 */
#define ISA_BASE	0xA0000
#define ISA_MAX		0x100000  /* for general memory access */

#define VIDEO_MAX	0xC0000  /* for vga access */
#define VGA_BASE	0xb8000
static void __iomem *io_base;



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

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

enum silly_modes {M_8=0, M_16, M_32, M_memcpy};

ssize_t silly_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
	int retval;
	int mode = iminor(filp->f_dentry->d_inode);
	void __iomem *add;
	unsigned long isa_addr = ISA_BASE + *f_pos;
	unsigned char *kbuf, *ptr;

	if (isa_addr + count > ISA_MAX) /* range: 0xA0000-0x100000 */
		count = ISA_MAX - isa_addr;

	/*
	 * too big an f_pos (caused by a malicious lseek())
	 * would result in a negative count
	 */
	if (count < 0)
		return 0;

	kbuf = kmalloc(count, GFP_KERNEL);
	if (!kbuf)
		return -ENOMEM;
	ptr = kbuf;
	retval = count;
	/*
	 * Convert our address into our remapped area.
	 */
	add = (void __iomem *)(io_base + (isa_addr - ISA_BASE));
	/*
	 * kbuf is aligned, but the reads might not. In order not to
	 * drive me mad with unaligned leading and trailing bytes,
	 * I downgrade the `mode' if unaligned xfers are requested.
	 */

	if (mode == M_32 && ((isa_addr | count) & 3))
		mode = M_16;
	if (mode == M_16 && ((isa_addr | count) & 1))
		mode = M_8;

	switch(mode) {
	  case M_32: 
		while (count >= 4) {
			*(u32 *)ptr = ioread32(add);
			add += 4;
			count -= 4;
			ptr += 4;
		}
		break;
	    
	  case M_16: 
		while (count >= 2) {
			*(u16 *)ptr = ioread16(add);
			add+=2;
			count-=2;
			ptr+=2;
		}
		break;
	    
	  case M_8: 
		while (count) {
			*ptr = ioread8(add);
			add++;
			count--;
			ptr++;
		}
		break;

	  case M_memcpy:
		memcpy_fromio(ptr, add, count);
		break;

	    default:
		return -EINVAL;
	}
	if ((retval > 0) && copy_to_user(buf, kbuf, retval))
		retval = -EFAULT;
	kfree(kbuf);
	*f_pos += retval;
	return retval;
}


ssize_t silly_write(struct file *filp, const char __user *buf, size_t count,
		    loff_t *f_pos)
{
	int retval;
	int mode = iminor(filp->f_dentry->d_inode);
	unsigned long isa_addr = ISA_BASE + *f_pos;
	unsigned char *kbuf, *ptr;
	void __iomem *add;

	/*
	 * Writing is dangerous.
	 * Allow root-only, independently of device permissions
	 */
	if (!capable(CAP_SYS_RAWIO))
		return -EPERM;

	if (isa_addr + count > ISA_MAX) /* range: 0xA0000-0x100000 */
		count = ISA_MAX - isa_addr;

	/*
	 * too big an f_pos (caused by a malicious lseek())
	 * results in a negative count
	 */
	if (count < 0)
		return 0;

	kbuf = kmalloc(count, GFP_KERNEL);
	if (!kbuf)
		return -ENOMEM;
	ptr = kbuf;
	retval=count;

	/*
	 * kbuf is aligned, but the writes might not. In order not to
	 * drive me mad with unaligned leading and trailing bytes,
	 * I downgrade the `mode' if unaligned xfers are requested.
	 */

	if (mode == M_32 && ((isa_addr | count) & 3))
		mode = M_16;
	if (mode == M_16 && ((isa_addr | count) & 1))
		mode = M_8;

	if (copy_from_user(kbuf, buf, count)) {
		kfree(kbuf);
		return -EFAULT;
	}
	ptr = kbuf;

	/*
	 * Switch over to our remapped address space.
	 */
	add = (void __iomem *)(io_base + (isa_addr - ISA_BASE));

	switch(mode) {
	  case M_32: 
		while (count >= 4) {
			iowrite8(*(u32 *)ptr, add);
			add += 4;
			count -= 4;
			ptr += 4;
		}
		break;
	    
	  case M_16: 
		while (count >= 2) {
			iowrite8(*(u16 *)ptr, add);
			add += 2;
			count -= 2;
			ptr += 2;
		}
		break;
	    
	  case M_8: 
		while (count) {
			iowrite8(*ptr, add);
			add++;
			count--;
			ptr++;
		}
		break;

	  case M_memcpy:
		memcpy_toio(add, ptr, count);
		break;

	  default:
		return -EINVAL;
	}
	*f_pos += retval;
	kfree(kbuf);
	return retval;
}


unsigned int silly_poll(struct file *filp, poll_table *wait)
{
    return POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM;
}


struct file_operations silly_fops = {
	.read =	    silly_read,
	.write =    silly_write,
	.poll =	    silly_poll,
	.open =	    silly_open,
	.release =  silly_release,
	.owner =    THIS_MODULE
};

int silly_init(void)
{
	int result = register_chrdev(silly_major, "silly", &silly_fops);
	if (result < 0) {
		printk(KERN_INFO "silly: can't get major number\n");
		return result;
	}
	if (silly_major == 0)
		silly_major = result; /* dynamic */
	/*
	 * Set up our I/O range.
	 */

	/* this line appears in silly_init */
	io_base = ioremap(ISA_BASE, ISA_MAX - ISA_BASE);
	return 0;
}

void silly_cleanup(void)
{
	iounmap(io_base);
	unregister_chrdev(silly_major, "silly");
}


module_init(silly_init);
module_exit(silly_cleanup);