[net-next-2.6.git] / drivers / staging / lirc / lirc_parallel.c

/*
 * lirc_parallel.c
 *
 * lirc_parallel - device driver for infra-red signal receiving and
 *                 transmitting unit built by the author
 *
 * Copyright (C) 1998 Christoph Bartelmus <lirc@bartelmus.de>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*** Includes ***/

#ifdef CONFIG_SMP
#error "--- Sorry, this driver is not SMP safe. ---"
#endif

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/time.h>
#include <linux/mm.h>
#include <linux/delay.h>

#include <linux/io.h>
#include <linux/signal.h>
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <asm/div64.h>

#include <linux/poll.h>
#include <linux/parport.h>

#include <media/lirc.h>
#include <media/lirc_dev.h>

#include "lirc_parallel.h"

#define LIRC_DRIVER_NAME "lirc_parallel"

#ifndef LIRC_IRQ
#define LIRC_IRQ 7
#endif
#ifndef LIRC_PORT
#define LIRC_PORT 0x378
#endif
#ifndef LIRC_TIMER
#define LIRC_TIMER 65536
#endif

/*** Global Variables ***/

static int debug;
static int check_pselecd;

unsigned int irq = LIRC_IRQ;
unsigned int io = LIRC_PORT;
#ifdef LIRC_TIMER
unsigned int timer;
unsigned int default_timer = LIRC_TIMER;
#endif

#define RBUF_SIZE (256) /* this must be a power of 2 larger than 1 */

static int rbuf[RBUF_SIZE];

DECLARE_WAIT_QUEUE_HEAD(lirc_wait);

unsigned int rptr;
unsigned int wptr;
unsigned int lost_irqs;
int is_open;

struct parport *pport;
struct pardevice *ppdevice;
int is_claimed;

unsigned int tx_mask = 1;

/*** Internal Functions ***/

static unsigned int in(int offset)
{
	switch (offset) {
	case LIRC_LP_BASE:
		return parport_read_data(pport);
	case LIRC_LP_STATUS:
		return parport_read_status(pport);
	case LIRC_LP_CONTROL:
		return parport_read_control(pport);
	}
	return 0; /* make compiler happy */
}

static void out(int offset, int value)
{
	switch (offset) {
	case LIRC_LP_BASE:
		parport_write_data(pport, value);
		break;
	case LIRC_LP_CONTROL:
		parport_write_control(pport, value);
		break;
	case LIRC_LP_STATUS:
		printk(KERN_INFO "%s: attempt to write to status register\n",
		       LIRC_DRIVER_NAME);
		break;
	}
}

static unsigned int lirc_get_timer(void)
{
	return in(LIRC_PORT_TIMER) & LIRC_PORT_TIMER_BIT;
}

static unsigned int lirc_get_signal(void)
{
	return in(LIRC_PORT_SIGNAL) & LIRC_PORT_SIGNAL_BIT;
}

static void lirc_on(void)
{
	out(LIRC_PORT_DATA, tx_mask);
}

static void lirc_off(void)
{
	out(LIRC_PORT_DATA, 0);
}

static unsigned int init_lirc_timer(void)
{
	struct timeval tv, now;
	unsigned int level, newlevel, timeelapsed, newtimer;
	int count = 0;

	do_gettimeofday(&tv);
	tv.tv_sec++;                     /* wait max. 1 sec. */
	level = lirc_get_timer();
	do {
		newlevel = lirc_get_timer();
		if (level == 0 && newlevel != 0)
			count++;
		level = newlevel;
		do_gettimeofday(&now);
	} while (count < 1000 && (now.tv_sec < tv.tv_sec
			     || (now.tv_sec == tv.tv_sec
				 && now.tv_usec < tv.tv_usec)));

	timeelapsed = ((now.tv_sec + 1 - tv.tv_sec)*1000000
		     + (now.tv_usec - tv.tv_usec));
	if (count >= 1000 && timeelapsed > 0) {
		if (default_timer == 0) {
			/* autodetect timer */
			newtimer = (1000000*count)/timeelapsed;
			printk(KERN_INFO "%s: %u Hz timer detected\n",
			       LIRC_DRIVER_NAME, newtimer);
			return newtimer;
		}  else {
			newtimer = (1000000*count)/timeelapsed;
			if (abs(newtimer - default_timer) > default_timer/10) {
				/* bad timer */
				printk(KERN_NOTICE "%s: bad timer: %u Hz\n",
				       LIRC_DRIVER_NAME, newtimer);
				printk(KERN_NOTICE "%s: using default timer: "
				       "%u Hz\n",
				       LIRC_DRIVER_NAME, default_timer);
				return default_timer;
			} else {
				printk(KERN_INFO "%s: %u Hz timer detected\n",
				       LIRC_DRIVER_NAME, newtimer);
				return newtimer; /* use detected value */
			}
		}
	} else {
		printk(KERN_NOTICE "%s: no timer detected\n", LIRC_DRIVER_NAME);
		return 0;
	}
}

static int lirc_claim(void)
{
	if (parport_claim(ppdevice) != 0) {
		printk(KERN_WARNING "%s: could not claim port\n",
		       LIRC_DRIVER_NAME);
		printk(KERN_WARNING "%s: waiting for port becoming available"
		       "\n", LIRC_DRIVER_NAME);
		if (parport_claim_or_block(ppdevice) < 0) {
			printk(KERN_NOTICE "%s: could not claim port, giving"
			       " up\n", LIRC_DRIVER_NAME);
			return 0;
		}
	}
	out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);
	is_claimed = 1;
	return 1;
}

/*** interrupt handler ***/

static void rbuf_write(int signal)
{
	unsigned int nwptr;

	nwptr = (wptr + 1) & (RBUF_SIZE - 1);
	if (nwptr == rptr) {
		/* no new signals will be accepted */
		lost_irqs++;
		printk(KERN_NOTICE "%s: buffer overrun\n", LIRC_DRIVER_NAME);
		return;
	}
	rbuf[wptr] = signal;
	wptr = nwptr;
}

static void irq_handler(void *blah)
{
	struct timeval tv;
	static struct timeval lasttv;
	static int init;
	long signal;
	int data;
	unsigned int level, newlevel;
	unsigned int timeout;

	if (!is_open)
		return;

	if (!is_claimed)
		return;

#if 0
	/* disable interrupt */
	  disable_irq(irq);
	  out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ) & (~LP_PINTEN));
#endif
	if (check_pselecd && (in(1) & LP_PSELECD))
		return;

#ifdef LIRC_TIMER
	if (init) {
		do_gettimeofday(&tv);

		signal = tv.tv_sec - lasttv.tv_sec;
		if (signal > 15)
			/* really long time */
			data = PULSE_MASK;
		else
			data = (int) (signal*1000000 +
					 tv.tv_usec - lasttv.tv_usec +
					 LIRC_SFH506_DELAY);

		rbuf_write(data); /* space */
	} else {
		if (timer == 0) {
			/*
			 * wake up; we'll lose this signal, but it will be
			 * garbage if the device is turned on anyway
			 */
			timer = init_lirc_timer();
			/* enable_irq(irq); */
			return;
		}
		init = 1;
	}

	timeout = timer/10;	/* timeout after 1/10 sec. */
	signal = 1;
	level = lirc_get_timer();
	do {
		newlevel = lirc_get_timer();
		if (level == 0 && newlevel != 0)
			signal++;
		level = newlevel;

		/* giving up */
		if (signal > timeout
		    || (check_pselecd && (in(1) & LP_PSELECD))) {
			signal = 0;
			printk(KERN_NOTICE "%s: timeout\n", LIRC_DRIVER_NAME);
			break;
		}
	} while (lirc_get_signal());

	if (signal != 0) {
		/* ajust value to usecs */
		unsigned long long helper;

		helper = ((unsigned long long) signal)*1000000;
		do_div(helper, timer);
		signal = (long) helper;

		if (signal > LIRC_SFH506_DELAY)
			data = signal - LIRC_SFH506_DELAY;
		else
			data = 1;
		rbuf_write(PULSE_BIT|data); /* pulse */
	}
	do_gettimeofday(&lasttv);
#else
	/* add your code here */
#endif

	wake_up_interruptible(&lirc_wait);

	/* enable interrupt */
	/*
	  enable_irq(irq);
	  out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ)|LP_PINTEN);
	*/
}

/*** file operations ***/

static loff_t lirc_lseek(struct file *filep, loff_t offset, int orig)
{
	return -ESPIPE;
}

static ssize_t lirc_read(struct file *filep, char *buf, size_t n, loff_t *ppos)
{
	int result = 0;
	int count = 0;
	DECLARE_WAITQUEUE(wait, current);

	if (n % sizeof(int))
		return -EINVAL;

	add_wait_queue(&lirc_wait, &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (count < n) {
		if (rptr != wptr) {
			if (copy_to_user(buf+count, (char *) &rbuf[rptr],
					 sizeof(int))) {
				result = -EFAULT;
				break;
			}
			rptr = (rptr + 1) & (RBUF_SIZE - 1);
			count += sizeof(int);
		} else {
			if (filep->f_flags & O_NONBLOCK) {
				result = -EAGAIN;
				break;
			}
			if (signal_pending(current)) {
				result = -ERESTARTSYS;
				break;
			}
			schedule();
			set_current_state(TASK_INTERRUPTIBLE);
		}
	}
	remove_wait_queue(&lirc_wait, &wait);
	set_current_state(TASK_RUNNING);
	return count ? count : result;
}

static ssize_t lirc_write(struct file *filep, const char *buf, size_t n,
			  loff_t *ppos)
{
	int count;
	unsigned int i;
	unsigned int level, newlevel;
	unsigned long flags;
	int counttimer;
	int *wbuf;

	if (!is_claimed)
		return -EBUSY;

	count = n / sizeof(int);

	if (n % sizeof(int) || count % 2 == 0)
		return -EINVAL;

	wbuf = memdup_user(buf, n);
	if (IS_ERR(wbuf))
		return PTR_ERR(wbuf);

#ifdef LIRC_TIMER
	if (timer == 0) {
		/* try again if device is ready */
		timer = init_lirc_timer();
		if (timer == 0)
			return -EIO;
	}

	/* adjust values from usecs */
	for (i = 0; i < count; i++) {
		unsigned long long helper;

		helper = ((unsigned long long) wbuf[i])*timer;
		do_div(helper, 1000000);
		wbuf[i] = (int) helper;
	}

	local_irq_save(flags);
	i = 0;
	while (i < count) {
		level = lirc_get_timer();
		counttimer = 0;
		lirc_on();
		do {
			newlevel = lirc_get_timer();
			if (level == 0 && newlevel != 0)
				counttimer++;
			level = newlevel;
			if (check_pselecd && (in(1) & LP_PSELECD)) {
				lirc_off();
				local_irq_restore(flags);
				return -EIO;
			}
		} while (counttimer < wbuf[i]);
		i++;

		lirc_off();
		if (i == count)
			break;
		counttimer = 0;
		do {
			newlevel = lirc_get_timer();
			if (level == 0 && newlevel != 0)
				counttimer++;
			level = newlevel;
			if (check_pselecd && (in(1) & LP_PSELECD)) {
				local_irq_restore(flags);
				return -EIO;
			}
		} while (counttimer < wbuf[i]);
		i++;
	}
	local_irq_restore(flags);
#else
	/* place code that handles write without external timer here */
#endif
	return n;
}

static unsigned int lirc_poll(struct file *file, poll_table *wait)
{
	poll_wait(file, &lirc_wait, wait);
	if (rptr != wptr)
		return POLLIN | POLLRDNORM;
	return 0;
}

static long lirc_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
	int result;
	unsigned long features = LIRC_CAN_SET_TRANSMITTER_MASK |
				 LIRC_CAN_SEND_PULSE | LIRC_CAN_REC_MODE2;
	unsigned long mode;
	unsigned int ivalue;

	switch (cmd) {
	case LIRC_GET_FEATURES:
		result = put_user(features, (unsigned long *) arg);
		if (result)
			return result;
		break;
	case LIRC_GET_SEND_MODE:
		result = put_user(LIRC_MODE_PULSE, (unsigned long *) arg);
		if (result)
			return result;
		break;
	case LIRC_GET_REC_MODE:
		result = put_user(LIRC_MODE_MODE2, (unsigned long *) arg);
		if (result)
			return result;
		break;
	case LIRC_SET_SEND_MODE:
		result = get_user(mode, (unsigned long *) arg);
		if (result)
			return result;
		if (mode != LIRC_MODE_PULSE)
			return -EINVAL;
		break;
	case LIRC_SET_REC_MODE:
		result = get_user(mode, (unsigned long *) arg);
		if (result)
			return result;
		if (mode != LIRC_MODE_MODE2)
			return -ENOSYS;
		break;
	case LIRC_SET_TRANSMITTER_MASK:
		result = get_user(ivalue, (unsigned int *) arg);
		if (result)
			return result;
		if ((ivalue & LIRC_PARALLEL_TRANSMITTER_MASK) != ivalue)
			return LIRC_PARALLEL_MAX_TRANSMITTERS;
		tx_mask = ivalue;
		break;
	default:
		return -ENOIOCTLCMD;
	}
	return 0;
}

static int lirc_open(struct inode *node, struct file *filep)
{
	if (is_open || !lirc_claim())
		return -EBUSY;

	parport_enable_irq(pport);

	/* init read ptr */
	rptr = 0;
	wptr = 0;
	lost_irqs = 0;

	is_open = 1;
	return 0;
}

static int lirc_close(struct inode *node, struct file *filep)
{
	if (is_claimed) {
		is_claimed = 0;
		parport_release(ppdevice);
	}
	is_open = 0;
	return 0;
}

static const struct file_operations lirc_fops = {
	.owner		= THIS_MODULE,
	.llseek		= lirc_lseek,
	.read		= lirc_read,
	.write		= lirc_write,
	.poll		= lirc_poll,
	.unlocked_ioctl	= lirc_ioctl,
	.open		= lirc_open,
	.release	= lirc_close
};

static int set_use_inc(void *data)
{
	return 0;
}

static void set_use_dec(void *data)
{
}

static struct lirc_driver driver = {
       .name		= LIRC_DRIVER_NAME,
       .minor		= -1,
       .code_length	= 1,
       .sample_rate	= 0,
       .data		= NULL,
       .add_to_buf	= NULL,
       .set_use_inc	= set_use_inc,
       .set_use_dec	= set_use_dec,
       .fops		= &lirc_fops,
       .dev		= NULL,
       .owner		= THIS_MODULE,
};

static int pf(void *handle);
static void kf(void *handle);

static struct timer_list poll_timer;
static void poll_state(unsigned long ignored);

static void poll_state(unsigned long ignored)
{
	printk(KERN_NOTICE "%s: time\n",
	       LIRC_DRIVER_NAME);
	del_timer(&poll_timer);
	if (is_claimed)
		return;
	kf(NULL);
	if (!is_claimed) {
		printk(KERN_NOTICE "%s: could not claim port, giving up\n",
		       LIRC_DRIVER_NAME);
		init_timer(&poll_timer);
		poll_timer.expires = jiffies + HZ;
		poll_timer.data = (unsigned long)current;
		poll_timer.function = poll_state;
		add_timer(&poll_timer);
	}
}

static int pf(void *handle)
{
	parport_disable_irq(pport);
	is_claimed = 0;
	return 0;
}

static void kf(void *handle)
{
	if (!is_open)
		return;
	if (!lirc_claim())
		return;
	parport_enable_irq(pport);
	lirc_off();
	/* this is a bit annoying when you actually print...*/
	/*
	printk(KERN_INFO "%s: reclaimed port\n", LIRC_DRIVER_NAME);
	*/
}

/*** module initialization and cleanup ***/

static int __init lirc_parallel_init(void)
{
	pport = parport_find_base(io);
	if (pport == NULL) {
		printk(KERN_NOTICE "%s: no port at %x found\n",
		       LIRC_DRIVER_NAME, io);
		return -ENXIO;
	}
	ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
					   pf, kf, irq_handler, 0, NULL);
	parport_put_port(pport);
	if (ppdevice == NULL) {
		printk(KERN_NOTICE "%s: parport_register_device() failed\n",
		       LIRC_DRIVER_NAME);
		return -ENXIO;
	}
	if (parport_claim(ppdevice) != 0)
		goto skip_init;
	is_claimed = 1;
	out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);

#ifdef LIRC_TIMER
	if (debug)
		out(LIRC_PORT_DATA, tx_mask);

	timer = init_lirc_timer();

#if 0	/* continue even if device is offline */
	if (timer == 0) {
		is_claimed = 0;
		parport_release(pport);
		parport_unregister_device(ppdevice);
		return -EIO;
	}

#endif
	if (debug)
		out(LIRC_PORT_DATA, 0);
#endif

	is_claimed = 0;
	parport_release(ppdevice);
 skip_init:
	driver.minor = lirc_register_driver(&driver);
	if (driver.minor < 0) {
		printk(KERN_NOTICE "%s: register_chrdev() failed\n",
		       LIRC_DRIVER_NAME);
		parport_unregister_device(ppdevice);
		return -EIO;
	}
	printk(KERN_INFO "%s: installed using port 0x%04x irq %d\n",
	       LIRC_DRIVER_NAME, io, irq);
	return 0;
}

static void __exit lirc_parallel_exit(void)
{
	parport_unregister_device(ppdevice);
	lirc_unregister_driver(driver.minor);
}

module_init(lirc_parallel_init);
module_exit(lirc_parallel_exit);

MODULE_DESCRIPTION("Infrared receiver driver for parallel ports.");
MODULE_AUTHOR("Christoph Bartelmus");
MODULE_LICENSE("GPL");

module_param(io, int, S_IRUGO);
MODULE_PARM_DESC(io, "I/O address base (0x3bc, 0x378 or 0x278)");

module_param(irq, int, S_IRUGO);
MODULE_PARM_DESC(irq, "Interrupt (7 or 5)");

module_param(tx_mask, int, S_IRUGO);
MODULE_PARM_DESC(tx_maxk, "Transmitter mask (default: 0x01)");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Enable debugging messages");

module_param(check_pselecd, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Check for printer (default: 0)");
Commit	Line	Data
805a8966 JW	1	/*
	2	* lirc_parallel.c
	3	*
	4	* lirc_parallel - device driver for infra-red signal receiving and
	5	* transmitting unit built by the author
	6	*
	7	* Copyright (C) 1998 Christoph Bartelmus <lirc@bartelmus.de>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*
	23	*/
	24
	25	/* Includes */
	26
	27	#ifdef CONFIG_SMP
	28	#error "--- Sorry, this driver is not SMP safe. ---"
	29	#endif
	30
	31	#include <linux/module.h>
	32	#include <linux/sched.h>
	33	#include <linux/errno.h>
	34	#include <linux/signal.h>
	35	#include <linux/fs.h>
	36	#include <linux/kernel.h>
	37	#include <linux/ioport.h>
	38	#include <linux/time.h>
	39	#include <linux/mm.h>
	40	#include <linux/delay.h>
	41
	42	#include <linux/io.h>
	43	#include <linux/signal.h>
	44	#include <linux/irq.h>
	45	#include <linux/uaccess.h>
	46	#include <asm/div64.h>
	47
	48	#include <linux/poll.h>
	49	#include <linux/parport.h>
	50
	51	#include <media/lirc.h>
	52	#include <media/lirc_dev.h>
	53
	54	#include "lirc_parallel.h"
	55
	56	#define LIRC_DRIVER_NAME "lirc_parallel"
	57
	58	#ifndef LIRC_IRQ
	59	#define LIRC_IRQ 7
	60	#endif
	61	#ifndef LIRC_PORT
	62	#define LIRC_PORT 0x378
	63	#endif
	64	#ifndef LIRC_TIMER
65	#define LIRC_TIMER 65536
66	#endif
67
68	/* Global Variables */
69
70	static int debug;
71	static int check_pselecd;
72
73	unsigned int irq = LIRC_IRQ;
74	unsigned int io = LIRC_PORT;
75	#ifdef LIRC_TIMER
76	unsigned int timer;
77	unsigned int default_timer = LIRC_TIMER;
78	#endif
79
80	#define RBUF_SIZE (256) /* this must be a power of 2 larger than 1 */
81
82	static int rbuf[RBUF_SIZE];
83
84	DECLARE_WAIT_QUEUE_HEAD(lirc_wait);
85
86	unsigned int rptr;
87	unsigned int wptr;
88	unsigned int lost_irqs;
89	int is_open;
90
91	struct parport *pport;
92	struct pardevice *ppdevice;
93	int is_claimed;
94
95	unsigned int tx_mask = 1;
96
97	/* Internal Functions */
98
99	static unsigned int in(int offset)
100	{
101	switch (offset) {
102	case LIRC_LP_BASE:
103	return parport_read_data(pport);
104	case LIRC_LP_STATUS:
105	return parport_read_status(pport);
106	case LIRC_LP_CONTROL:
107	return parport_read_control(pport);
108	}
109	return 0; /* make compiler happy */
110	}
111
112	static void out(int offset, int value)
113	{
114	switch (offset) {
115	case LIRC_LP_BASE:
116	parport_write_data(pport, value);
117	break;
118	case LIRC_LP_CONTROL:
119	parport_write_control(pport, value);
120	break;
121	case LIRC_LP_STATUS:
122	printk(KERN_INFO "%s: attempt to write to status register\n",
123	LIRC_DRIVER_NAME);
124	break;
125	}
126	}
127
128	static unsigned int lirc_get_timer(void)
129	{
130	return in(LIRC_PORT_TIMER) & LIRC_PORT_TIMER_BIT;
131	}
132
133	static unsigned int lirc_get_signal(void)
134	{
135	return in(LIRC_PORT_SIGNAL) & LIRC_PORT_SIGNAL_BIT;
136	}
137
138	static void lirc_on(void)
139	{
140	out(LIRC_PORT_DATA, tx_mask);
141	}
142
143	static void lirc_off(void)
144	{
145	out(LIRC_PORT_DATA, 0);
146	}
147
148	static unsigned int init_lirc_timer(void)
149	{
150	struct timeval tv, now;
151	unsigned int level, newlevel, timeelapsed, newtimer;
152	int count = 0;
153
154	do_gettimeofday(&tv);
155	tv.tv_sec++; /* wait max. 1 sec. */
156	level = lirc_get_timer();
157	do {
158	newlevel = lirc_get_timer();
159	if (level == 0 && newlevel != 0)
160	count++;
161	level = newlevel;
162	do_gettimeofday(&now);
163	} while (count < 1000 && (now.tv_sec < tv.tv_sec
164	\|\| (now.tv_sec == tv.tv_sec
165	&& now.tv_usec < tv.tv_usec)));
166
167	timeelapsed = ((now.tv_sec + 1 - tv.tv_sec)*1000000
168	+ (now.tv_usec - tv.tv_usec));
169	if (count >= 1000 && timeelapsed > 0) {
170	if (default_timer == 0) {
171	/* autodetect timer */
172	newtimer = (1000000*count)/timeelapsed;
173	printk(KERN_INFO "%s: %u Hz timer detected\n",
174	LIRC_DRIVER_NAME, newtimer);
175	return newtimer;
176	} else {
177	newtimer = (1000000*count)/timeelapsed;
178	if (abs(newtimer - default_timer) > default_timer/10) {
179	/* bad timer */
180	printk(KERN_NOTICE "%s: bad timer: %u Hz\n",
181	LIRC_DRIVER_NAME, newtimer);
182	printk(KERN_NOTICE "%s: using default timer: "
183	"%u Hz\n",
184	LIRC_DRIVER_NAME, default_timer);
185	return default_timer;
186	} else {
187	printk(KERN_INFO "%s: %u Hz timer detected\n",
188	LIRC_DRIVER_NAME, newtimer);
189	return newtimer; /* use detected value */
190	}
191	}
192	} else {
193	printk(KERN_NOTICE "%s: no timer detected\n", LIRC_DRIVER_NAME);
194	return 0;
195	}
196	}
197
198	static int lirc_claim(void)
199	{
200	if (parport_claim(ppdevice) != 0) {
201	printk(KERN_WARNING "%s: could not claim port\n",
202	LIRC_DRIVER_NAME);
203	printk(KERN_WARNING "%s: waiting for port becoming available"
204	"\n", LIRC_DRIVER_NAME);
205	if (parport_claim_or_block(ppdevice) < 0) {
206	printk(KERN_NOTICE "%s: could not claim port, giving"
207	" up\n", LIRC_DRIVER_NAME);
208	return 0;
209	}
210	}
211	out(LIRC_LP_CONTROL, LP_PSELECP\|LP_PINITP);
212	is_claimed = 1;
213	return 1;
214	}
215
216	/* interrupt handler */
217
218	static void rbuf_write(int signal)
219	{
220	unsigned int nwptr;
221
222	nwptr = (wptr + 1) & (RBUF_SIZE - 1);
223	if (nwptr == rptr) {
224	/* no new signals will be accepted */
225	lost_irqs++;
226	printk(KERN_NOTICE "%s: buffer overrun\n", LIRC_DRIVER_NAME);
227	return;
228	}
229	rbuf[wptr] = signal;
230	wptr = nwptr;
231	}
232
233	static void irq_handler(void *blah)
234	{
235	struct timeval tv;
236	static struct timeval lasttv;
237	static int init;
238	long signal;
239	int data;
240	unsigned int level, newlevel;
241	unsigned int timeout;
242
82ce67bf	243	if (!is_open)
805a8966 JW	244	return;
	245
	246	if (!is_claimed)
	247	return;
	248
	249	#if 0
	250	/* disable interrupt */
	251	disable_irq(irq);
	252	out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ) & (~LP_PINTEN));
	253	#endif
	254	if (check_pselecd && (in(1) & LP_PSELECD))
	255	return;
	256
	257	#ifdef LIRC_TIMER
	258	if (init) {
	259	do_gettimeofday(&tv);
	260
	261	signal = tv.tv_sec - lasttv.tv_sec;
	262	if (signal > 15)
	263	/* really long time */
	264	data = PULSE_MASK;
	265	else
	266	data = (int) (signal*1000000 +
	267	tv.tv_usec - lasttv.tv_usec +
	268	LIRC_SFH506_DELAY);
	269
	270	rbuf_write(data); /* space */
	271	} else {
	272	if (timer == 0) {
	273	/*
	274	* wake up; we'll lose this signal, but it will be
	275	* garbage if the device is turned on anyway
	276	*/
	277	timer = init_lirc_timer();
	278	/* enable_irq(irq); */
	279	return;
	280	}
	281	init = 1;
	282	}
	283
	284	timeout = timer/10; /* timeout after 1/10 sec. */
	285	signal = 1;
	286	level = lirc_get_timer();
	287	do {
	288	newlevel = lirc_get_timer();
	289	if (level == 0 && newlevel != 0)
	290	signal++;
	291	level = newlevel;
	292
	293	/* giving up */
	294	if (signal > timeout
	295	\|\| (check_pselecd && (in(1) & LP_PSELECD))) {
	296	signal = 0;
	297	printk(KERN_NOTICE "%s: timeout\n", LIRC_DRIVER_NAME);
	298	break;
	299	}
	300	} while (lirc_get_signal());
	301
	302	if (signal != 0) {
	303	/* ajust value to usecs */
	304	unsigned long long helper;
	305
	306	helper = ((unsigned long long) signal)*1000000;
	307	do_div(helper, timer);
308	signal = (long) helper;
309
310	if (signal > LIRC_SFH506_DELAY)
311	data = signal - LIRC_SFH506_DELAY;
312	else
313	data = 1;
314	rbuf_write(PULSE_BIT\|data); /* pulse */
315	}
316	do_gettimeofday(&lasttv);
317	#else
318	/* add your code here */
319	#endif
320
321	wake_up_interruptible(&lirc_wait);
322
323	/* enable interrupt */
324	/*
325	enable_irq(irq);
326	out(LIRC_PORT_IRQ, in(LIRC_PORT_IRQ)\|LP_PINTEN);
327	*/
328	}
329
330	/* file operations */
331
332	static loff_t lirc_lseek(struct file *filep, loff_t offset, int orig)
333	{
334	return -ESPIPE;
335	}
336
337	static ssize_t lirc_read(struct file filep, char buf, size_t n, loff_t *ppos)
338	{
339	int result = 0;
340	int count = 0;
341	DECLARE_WAITQUEUE(wait, current);
342
343	if (n % sizeof(int))
344	return -EINVAL;
345
346	add_wait_queue(&lirc_wait, &wait);
347	set_current_state(TASK_INTERRUPTIBLE);
348	while (count < n) {
349	if (rptr != wptr) {
350	if (copy_to_user(buf+count, (char *) &rbuf[rptr],
351	sizeof(int))) {
352	result = -EFAULT;
353	break;
354	}
355	rptr = (rptr + 1) & (RBUF_SIZE - 1);
356	count += sizeof(int);
357	} else {
358	if (filep->f_flags & O_NONBLOCK) {
359	result = -EAGAIN;
360	break;
361	}
362	if (signal_pending(current)) {
363	result = -ERESTARTSYS;
364	break;
365	}
366	schedule();
367	set_current_state(TASK_INTERRUPTIBLE);
368	}
369	}
370	remove_wait_queue(&lirc_wait, &wait);
371	set_current_state(TASK_RUNNING);
372	return count ? count : result;
373	}
374
375	static ssize_t lirc_write(struct file filep, const char buf, size_t n,
376	loff_t *ppos)
377	{
378	int count;
379	unsigned int i;
380	unsigned int level, newlevel;
381	unsigned long flags;
382	int counttimer;
383	int *wbuf;
384
385	if (!is_claimed)
386	return -EBUSY;
387
388	count = n / sizeof(int);
389
390	if (n % sizeof(int) \|\| count % 2 == 0)
391	return -EINVAL;
392
393	wbuf = memdup_user(buf, n);
394	if (IS_ERR(wbuf))
395	return PTR_ERR(wbuf);
396
397	#ifdef LIRC_TIMER
398	if (timer == 0) {
399	/* try again if device is ready */
400	timer = init_lirc_timer();
401	if (timer == 0)
402	return -EIO;
403	}
404
405	/* adjust values from usecs */
406	for (i = 0; i < count; i++) {
407	unsigned long long helper;
408
409	helper = ((unsigned long long) wbuf[i])*timer;
410	do_div(helper, 1000000);
411	wbuf[i] = (int) helper;
412	}
413
414	local_irq_save(flags);
415	i = 0;
416	while (i < count) {
417	level = lirc_get_timer();
418	counttimer = 0;
419	lirc_on();
420	do {
421	newlevel = lirc_get_timer();
422	if (level == 0 && newlevel != 0)
423	counttimer++;
424	level = newlevel;
425	if (check_pselecd && (in(1) & LP_PSELECD)) {
426	lirc_off();
427	local_irq_restore(flags);
428	return -EIO;
429	}
430	} while (counttimer < wbuf[i]);
431	i++;
432
433	lirc_off();
434	if (i == count)
435	break;
436	counttimer = 0;
437	do {
438	newlevel = lirc_get_timer();
439	if (level == 0 && newlevel != 0)
440	counttimer++;
441	level = newlevel;
442	if (check_pselecd && (in(1) & LP_PSELECD)) {
443	local_irq_restore(flags);
444	return -EIO;
445	}
446	} while (counttimer < wbuf[i]);
447	i++;
448	}
449	local_irq_restore(flags);
450	#else
451	/* place code that handles write without external timer here */
452	#endif
453	return n;
454	}
455
456	static unsigned int lirc_poll(struct file file, poll_table wait)
457	{
458	poll_wait(file, &lirc_wait, wait);
459	if (rptr != wptr)
460	return POLLIN \| POLLRDNORM;
461	return 0;
462	}
463
464	static long lirc_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
465	{
466	int result;
467	unsigned long features = LIRC_CAN_SET_TRANSMITTER_MASK \|
468	LIRC_CAN_SEND_PULSE \| LIRC_CAN_REC_MODE2;
469	unsigned long mode;
470	unsigned int ivalue;
471
472	switch (cmd) {
473	case LIRC_GET_FEATURES:
474	result = put_user(features, (unsigned long *) arg);
475	if (result)
476	return result;
477	break;
478	case LIRC_GET_SEND_MODE:
479	result = put_user(LIRC_MODE_PULSE, (unsigned long *) arg);
480	if (result)
481	return result;
482	break;
483	case LIRC_GET_REC_MODE:
484	result = put_user(LIRC_MODE_MODE2, (unsigned long *) arg);
485	if (result)
486	return result;
487	break;
488	case LIRC_SET_SEND_MODE:
489	result = get_user(mode, (unsigned long *) arg);
490	if (result)
491	return result;
492	if (mode != LIRC_MODE_PULSE)
493	return -EINVAL;
494	break;
495	case LIRC_SET_REC_MODE:
496	result = get_user(mode, (unsigned long *) arg);
497	if (result)
498	return result;
499	if (mode != LIRC_MODE_MODE2)
500	return -ENOSYS;
501	break;
502	case LIRC_SET_TRANSMITTER_MASK:
503	result = get_user(ivalue, (unsigned int *) arg);
504	if (result)
505	return result;
506	if ((ivalue & LIRC_PARALLEL_TRANSMITTER_MASK) != ivalue)
507	return LIRC_PARALLEL_MAX_TRANSMITTERS;
508	tx_mask = ivalue;
509	break;
510	default:
511	return -ENOIOCTLCMD;
512	}
513	return 0;
514	}
515
516	static int lirc_open(struct inode node, struct file filep)
517	{
82ce67bf	518	if (is_open \|\| !lirc_claim())
805a8966 JW	519	return -EBUSY;
	520
	521	parport_enable_irq(pport);
	522
	523	/* init read ptr */
	524	rptr = 0;
	525	wptr = 0;
	526	lost_irqs = 0;
	527
	528	is_open = 1;
	529	return 0;
	530	}
	531
	532	static int lirc_close(struct inode node, struct file filep)
	533	{
	534	if (is_claimed) {
	535	is_claimed = 0;
	536	parport_release(ppdevice);
	537	}
	538	is_open = 0;
	539	return 0;
	540	}
	541
0f9313ad	542	static const struct file_operations lirc_fops = {
805a8966 JW	543	.owner = THIS_MODULE,
	544	.llseek = lirc_lseek,
	545	.read = lirc_read,
	546	.write = lirc_write,
	547	.poll = lirc_poll,
	548	.unlocked_ioctl = lirc_ioctl,
	549	.open = lirc_open,
	550	.release = lirc_close
	551	};
	552
	553	static int set_use_inc(void *data)
	554	{
	555	return 0;
	556	}
	557
	558	static void set_use_dec(void *data)
	559	{
	560	}
	561
	562	static struct lirc_driver driver = {
	563	.name = LIRC_DRIVER_NAME,
	564	.minor = -1,
	565	.code_length = 1,
	566	.sample_rate = 0,
	567	.data = NULL,
	568	.add_to_buf = NULL,
	569	.set_use_inc = set_use_inc,
	570	.set_use_dec = set_use_dec,
	571	.fops = &lirc_fops,
	572	.dev = NULL,
	573	.owner = THIS_MODULE,
	574	};
	575
	576	static int pf(void *handle);
	577	static void kf(void *handle);
	578
	579	static struct timer_list poll_timer;
	580	static void poll_state(unsigned long ignored);
	581
	582	static void poll_state(unsigned long ignored)
	583	{
	584	printk(KERN_NOTICE "%s: time\n",
	585	LIRC_DRIVER_NAME);
	586	del_timer(&poll_timer);
	587	if (is_claimed)
	588	return;
	589	kf(NULL);
	590	if (!is_claimed) {
	591	printk(KERN_NOTICE "%s: could not claim port, giving up\n",
	592	LIRC_DRIVER_NAME);
	593	init_timer(&poll_timer);
	594	poll_timer.expires = jiffies + HZ;
	595	poll_timer.data = (unsigned long)current;
	596	poll_timer.function = poll_state;
	597	add_timer(&poll_timer);
	598	}
	599	}
	600
	601	static int pf(void *handle)
	602	{
	603	parport_disable_irq(pport);
	604	is_claimed = 0;
	605	return 0;
	606	}
607
608	static void kf(void *handle)
609	{
610	if (!is_open)
611	return;
612	if (!lirc_claim())
613	return;
614	parport_enable_irq(pport);
615	lirc_off();
616	/* this is a bit annoying when you actually print...*/
617	/*
618	printk(KERN_INFO "%s: reclaimed port\n", LIRC_DRIVER_NAME);
619	*/
620	}
621
622	/* module initialization and cleanup */
623
624	static int __init lirc_parallel_init(void)
625	{
626	pport = parport_find_base(io);
627	if (pport == NULL) {
628	printk(KERN_NOTICE "%s: no port at %x found\n",
629	LIRC_DRIVER_NAME, io);
630	return -ENXIO;
631	}
632	ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
633	pf, kf, irq_handler, 0, NULL);
634	parport_put_port(pport);
635	if (ppdevice == NULL) {
636	printk(KERN_NOTICE "%s: parport_register_device() failed\n",
637	LIRC_DRIVER_NAME);
638	return -ENXIO;
639	}
640	if (parport_claim(ppdevice) != 0)
641	goto skip_init;
642	is_claimed = 1;
643	out(LIRC_LP_CONTROL, LP_PSELECP\|LP_PINITP);
644
645	#ifdef LIRC_TIMER
646	if (debug)
647	out(LIRC_PORT_DATA, tx_mask);
648
649	timer = init_lirc_timer();
650
651	#if 0 /* continue even if device is offline */
652	if (timer == 0) {
653	is_claimed = 0;
654	parport_release(pport);
655	parport_unregister_device(ppdevice);
656	return -EIO;
657	}
658
659	#endif
660	if (debug)
661	out(LIRC_PORT_DATA, 0);
662	#endif
663
664	is_claimed = 0;
665	parport_release(ppdevice);
666	skip_init:
667	driver.minor = lirc_register_driver(&driver);
668	if (driver.minor < 0) {
669	printk(KERN_NOTICE "%s: register_chrdev() failed\n",
670	LIRC_DRIVER_NAME);
671	parport_unregister_device(ppdevice);
672	return -EIO;
673	}
674	printk(KERN_INFO "%s: installed using port 0x%04x irq %d\n",
675	LIRC_DRIVER_NAME, io, irq);
676	return 0;
677	}
678
679	static void __exit lirc_parallel_exit(void)
680	{
681	parport_unregister_device(ppdevice);
682	lirc_unregister_driver(driver.minor);
683	}
684
685	module_init(lirc_parallel_init);
686	module_exit(lirc_parallel_exit);
687
688	MODULE_DESCRIPTION("Infrared receiver driver for parallel ports.");
689	MODULE_AUTHOR("Christoph Bartelmus");
690	MODULE_LICENSE("GPL");
691
692	module_param(io, int, S_IRUGO);
693	MODULE_PARM_DESC(io, "I/O address base (0x3bc, 0x378 or 0x278)");
694
695	module_param(irq, int, S_IRUGO);
696	MODULE_PARM_DESC(irq, "Interrupt (7 or 5)");
697
698	module_param(tx_mask, int, S_IRUGO);
699	MODULE_PARM_DESC(tx_maxk, "Transmitter mask (default: 0x01)");
700
701	module_param(debug, bool, S_IRUGO \| S_IWUSR);
702	MODULE_PARM_DESC(debug, "Enable debugging messages");
703
704	module_param(check_pselecd, bool, S_IRUGO \| S_IWUSR);
705	MODULE_PARM_DESC(debug, "Check for printer (default: 0)");