/* * short.c -- Simple Hardware Operations and Raw Tests * short.c -- also a brief example of interrupt handling ("short int") * * 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: short.c,v 1.16 2004/10/29 16:45:40 corbet Exp $ *//* * FIXME: this driver is not safe with concurrent readers or * writers. */#include <linux/config.h>#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/init.h>#include <linux/sched.h>#include <linux/kernel.h>	/* printk() */#include <linux/fs.h>		/* everything... */#include <linux/errno.h>	/* error codes */#include <linux/delay.h>	/* udelay */#include <linux/kdev_t.h>#include <linux/slab.h>#include <linux/mm.h>#include <linux/ioport.h>#include <linux/interrupt.h>#include <linux/workqueue.h>#include <linux/poll.h>#include <linux/wait.h>#include <asm/io.h>#define SHORT_NR_PORTS	8	/* use 8 ports by default *//* * all of the parameters have no "short_" prefix, to save typing when * specifying them at load time */static int major = 0;	/* dynamic by default */module_param(major, int, 0);static int use_mem = 0;	/* default is I/O-mapped */module_param(use_mem, int, 0);/* default is the first printer port on PC's. "short_base" is there too   because it's what we want to use in the code */static unsigned long base = 0x378;unsigned long short_base = 0;module_param(base, long, 0);/* The interrupt line is undefined by default. "short_irq" is as above */static int irq = -1;volatile int short_irq = -1;module_param(irq, int, 0);static int probe = 0;	/* select at load time how to probe irq line */module_param(probe, int, 0);static int wq = 0;	/* select at load time whether a workqueue is used */module_param(wq, int, 0);static int tasklet = 0;	/* select whether a tasklet is used */module_param(tasklet, int, 0);static int share = 0;	/* select at load time whether install a shared irq */module_param(share, int, 0);MODULE_AUTHOR ("Alessandro Rubini");MODULE_LICENSE("Dual BSD/GPL");unsigned long short_buffer = 0;unsigned long volatile short_head;volatile unsigned long short_tail;DECLARE_WAIT_QUEUE_HEAD(short_queue);/* Set up our tasklet if we're doing that. */void short_do_tasklet(unsigned long);DECLARE_TASKLET(short_tasklet, short_do_tasklet, 0);/* * Atomicly increment an index into short_buffer */static inline void short_incr_bp(volatile unsigned long *index, int delta){	unsigned long new = *index + delta;	barrier();  /* Don't optimize these two together */	*index = (new >= (short_buffer + PAGE_SIZE)) ? short_buffer : new;}/* * The devices with low minor numbers write/read burst of data to/from * specific I/O ports (by default the parallel ones). *  * The device with 128 as minor number returns ascii strings telling * when interrupts have been received. Writing to the device toggles * 00/FF on the parallel data lines. If there is a loopback wire, this * generates interrupts.   */int short_open (struct inode *inode, struct file *filp){	extern struct file_operations short_i_fops;	if (iminor (inode) & 0x80)		filp->f_op = &short_i_fops; /* the interrupt-driven node */	return 0;}int short_release (struct inode *inode, struct file *filp){	return 0;}/* first, the port-oriented device */enum short_modes {SHORT_DEFAULT=0, SHORT_PAUSE, SHORT_STRING, SHORT_MEMORY};ssize_t do_short_read (struct inode *inode, struct file *filp, char __user *buf,		size_t count, loff_t *f_pos){	int retval = count, minor = iminor (inode);	unsigned long port = short_base + (minor&0x0f);	void *address = (void *) short_base + (minor&0x0f);	int mode = (minor&0x70) >> 4;	unsigned char *kbuf = kmalloc(count, GFP_KERNEL), *ptr;    	if (!kbuf)		return -ENOMEM;	ptr = kbuf;	if (use_mem)		mode = SHORT_MEMORY;		switch(mode) {	    case SHORT_STRING:		insb(port, ptr, count);		rmb();		break;	    case SHORT_DEFAULT:		while (count--) {			*(ptr++) = inb(port);			rmb();		}		break;	    case SHORT_MEMORY:		while (count--) {			*ptr++ = ioread8(address);			rmb();		}		break;	    case SHORT_PAUSE:		while (count--) {			*(ptr++) = inb_p(port);			rmb();		}		break;	    default: /* no more modes defined by now */		retval = -EINVAL;		break;	}	if ((retval > 0) && copy_to_user(buf, kbuf, retval))		retval = -EFAULT;	kfree(kbuf);	return retval;}/* * Version-specific methods for the fops structure.  FIXME don't need anymore. */ssize_t short_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos){	return do_short_read(filp->f_dentry->d_inode, filp, buf, count, f_pos);}ssize_t do_short_write (struct inode *inode, struct file *filp, const char __user *buf,		size_t count, loff_t *f_pos){	int retval = count, minor = iminor(inode);	unsigned long port = short_base + (minor&0x0f);	void *address = (void *) short_base + (minor&0x0f);	int mode = (minor&0x70) >> 4;	unsigned char *kbuf = kmalloc(count, GFP_KERNEL), *ptr;	if (!kbuf)		return -ENOMEM;	if (copy_from_user(kbuf, buf, count))		return -EFAULT;	ptr = kbuf;	if (use_mem)		mode = SHORT_MEMORY;	switch(mode) {	case SHORT_PAUSE:		while (count--) {			outb_p(*(ptr++), port);			wmb();		}		break;	case SHORT_STRING:		outsb(port, ptr, count);		wmb();		break;	case SHORT_DEFAULT:		while (count--) {			outb(*(ptr++), port);			wmb();		}		break;	case SHORT_MEMORY:		while (count--) {			iowrite8(*ptr++, address);			wmb();		}		break;	default: /* no more modes defined by now */		retval = -EINVAL;		break;	}	kfree(kbuf);	return retval;}ssize_t short_write(struct file *filp, const char __user *buf, size_t count,		loff_t *f_pos){	return do_short_write(filp->f_dentry->d_inode, filp, buf, count, f_pos);}unsigned int short_poll(struct file *filp, poll_table *wait){	return POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM;}struct file_operations short_fops = {	.owner	 = THIS_MODULE,	.read	 = short_read,	.write	 = short_write,	.poll	        = short_poll,	.open	 = short_open,	.release = short_release,};/* then,  the interrupt-related device */ssize_t short_i_read (struct file *filp, char __user *buf, size_t count, loff_t *f_pos){	int count0;	DEFINE_WAIT(wait);	while (short_head == short_tail) {		prepare_to_wait(&short_queue, &wait, TASK_INTERRUPTIBLE);		if (short_head == short_tail)			schedule();		finish_wait(&short_queue, &wait);		if (signal_pending (current))  /* a signal arrived */			return -ERESTARTSYS; /* tell the fs layer to handle it */	} 	/* count0 is the number of readable data bytes */	count0 = short_head - short_tail;	if (count0 < 0) /* wrapped */		count0 = short_buffer + PAGE_SIZE - short_tail;	if (count0 < count) count = count0;	if (copy_to_user(buf, (char *)short_tail, count))		return -EFAULT;	short_incr_bp (&short_tail, count);	return count;}ssize_t short_i_write (struct file *filp, const char __user *buf, size_t count,		loff_t *f_pos){	int written = 0, odd = *f_pos & 1;	unsigned long port = short_base; /* output to the parallel data latch */	void *address = (void *) short_base;	if (use_mem) {		while (written < count)			iowrite8(0xff * ((++written + odd) & 1), address);	} else {		while (written < count)			outb(0xff * ((++written + odd) & 1), port);	}	*f_pos += count;	return written;}struct file_operations short_i_fops = {	.owner	 = THIS_MODULE,	.read	 = short_i_read,	.write	 = short_i_write,	.open	 = short_open,	.release = short_release,};irqreturn_t short_interrupt(int irq, void *dev_id, struct pt_regs *regs){	struct timeval tv;	int written;	do_gettimeofday(&tv);	    /* Write a 16 byte record. Assume PAGE_SIZE is a multiple of 16 */	written = sprintf((char *)short_head,"%08u.%06u\n",			(int)(tv.tv_sec % 100000000), (int)(tv.tv_usec));	BUG_ON(written != 16);	short_incr_bp(&short_head, written);