Release 4.7 drivers/staging/media/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
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

/*** Includes ***/

#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/ktime.h>
#include <linux/mm.h>
#include <linux/delay.h>

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

#include <linux/poll.h>
#include <linux/parport.h>
#include <linux/platform_device.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 bool debug;

static bool check_pselecd;


static unsigned int irq = LIRC_IRQ;

static unsigned int io = LIRC_PORT;
#ifdef LIRC_TIMER

static unsigned int timer;

static 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];

static DECLARE_WAIT_QUEUE_HEAD(lirc_wait);


static unsigned int rptr;

static unsigned int wptr;

static unsigned int lost_irqs;

static int is_open;


static struct parport *pport;

static struct pardevice *ppdevice;

static int is_claimed;


static 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 */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
47
100.00%
1
100.00%
Total
47
100.00%
1
100.00%



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:
		pr_info("attempt to write to status register\n");
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
47
95.92%
1
50.00%
toshiaki yamane
toshiaki yamane
2
4.08%
1
50.00%
Total
49
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



static unsigned int init_lirc_timer(void)
{
	ktime_t kt, now, timeout;
	unsigned int level, newlevel, timeelapsed, newtimer;
	int count = 0;

	kt = ktime_get();
	/* wait max. 1 sec. */
	timeout = ktime_add_ns(kt, NSEC_PER_SEC);
	level = lirc_get_timer();
	do {
		newlevel = lirc_get_timer();
		if (level == 0 && newlevel != 0)
			count++;
		level = newlevel;
		now = ktime_get();
	} while (count < 1000 && (ktime_before(now, timeout)));
	timeelapsed = ktime_us_delta(now, kt);
	if (count >= 1000 && timeelapsed > 0) {
		if (default_timer == 0) {
			/* autodetect timer */
			newtimer = (1000000*count)/timeelapsed;
			pr_info("%u Hz timer detected\n", newtimer);
			return newtimer;
		}
		newtimer = (1000000*count)/timeelapsed;
		if (abs(newtimer - default_timer) > default_timer/10) {
			/* bad timer */
			pr_notice("bad timer: %u Hz\n", newtimer);
			pr_notice("using default timer: %u Hz\n",
				  default_timer);
			return default_timer;
		}
		pr_info("%u Hz timer detected\n", newtimer);
		return newtimer; /* use detected value */
	}

	pr_notice("no timer detected\n");
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
170
81.34%
1
33.33%
arnd bergmann
arnd bergmann
29
13.88%
1
33.33%
toshiaki yamane
toshiaki yamane
10
4.78%
1
33.33%
Total
209
100.00%
3
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
58
90.62%
1
50.00%
toshiaki yamane
toshiaki yamane
6
9.38%
1
50.00%
Total
64
100.00%
2
100.00%

/*** 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++;
		pr_notice("buffer overrun\n");
		return;
	}
	rbuf[wptr] = signal;
	wptr = nwptr;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
54
96.43%
1
50.00%
toshiaki yamane
toshiaki yamane
2
3.57%
1
50.00%
Total
56
100.00%
2
100.00%



static void lirc_lirc_irq_handler(void *blah)
{
	ktime_t kt, delkt;
	static ktime_t lastkt;
	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) {
		kt = ktime_get();

		delkt = ktime_sub(kt, lastkt);
		if (ktime_compare(delkt, ktime_set(15, 0)) > 0)
			/* really long time */
			data = PULSE_MASK;
		else
			data = (int)(ktime_to_us(delkt) + 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;
			pr_notice("timeout\n");
			break;
		}
	} while (lirc_get_signal());

	if (signal != 0) {
		/* adjust value to usecs */
		__u64 helper;

		helper = ((__u64)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 */
	}
	lastkt = ktime_get();
#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);
        */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
278
87.15%
3
42.86%
arnd bergmann
arnd bergmann
37
11.60%
1
14.29%
toshiaki yamane
toshiaki yamane
2
0.63%
1
14.29%
uwe kleine-koenig
uwe kleine-koenig
1
0.31%
1
14.29%
mauro carvalho chehab
mauro carvalho chehab
1
0.31%
1
14.29%
Total
319
100.00%
7
100.00%

/*** file operations ***/



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%



static ssize_t lirc_read(struct file *filep, char __user *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, &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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
194
99.49%
1
50.00%
tuomas tynkkynen
tuomas tynkkynen
1
0.51%
1
50.00%
Total
195
100.00%
2
100.00%



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

	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) {
			ret = -EIO;
			goto out;
		}
	}

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

		helper = ((__u64)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);
				ret = -EIO;
				goto out;
			}
		} 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);
				ret = -EIO;
				goto out;
			}
		} while (counttimer < wbuf[i]);
		i++;
	}
	local_irq_restore(flags);
#else
	/* place code that handles write without external timer here */
#endif
	ret = n;
out:
	kfree(wbuf);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
394
99.75%
3
75.00%
tuomas tynkkynen
tuomas tynkkynen
1
0.25%
1
25.00%
Total
395
100.00%
4
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%



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

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
199
90.45%
2
66.67%
tuomas tynkkynen
tuomas tynkkynen
21
9.55%
1
33.33%
Total
220
100.00%
3
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
53
100.00%
2
100.00%
Total
53
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%


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,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= lirc_ioctl,
#endif
	.open		= lirc_open,
	.release	= lirc_close
};



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
13
100.00%
1
100.00%
Total
13
100.00%
1
100.00%



static void set_use_dec(void *data)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
9
100.00%
1
100.00%
Total
9
100.00%
1
100.00%


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 struct platform_device *lirc_parallel_dev;



static int lirc_parallel_probe(struct platform_device *dev)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
thomas viehweger
thomas viehweger
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%



static int lirc_parallel_remove(struct platform_device *dev)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
thomas viehweger
thomas viehweger
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%



static int lirc_parallel_suspend(struct platform_device *dev,
					pm_message_t state)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
thomas viehweger
thomas viehweger
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



static int lirc_parallel_resume(struct platform_device *dev)
{
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
thomas viehweger
thomas viehweger
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%


static struct platform_driver lirc_parallel_driver = {
	.probe	= lirc_parallel_probe,
	.remove	= lirc_parallel_remove,
	.suspend	= lirc_parallel_suspend,
	.resume	= lirc_parallel_resume,
	.driver	= {
		.name	= LIRC_DRIVER_NAME,
        },
};



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



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);
        */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
33
100.00%
1
100.00%
Total
33
100.00%
1
100.00%

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



static int __init lirc_parallel_init(void)
{
	int result;

	result = platform_driver_register(&lirc_parallel_driver);
	if (result) {
		pr_notice("platform_driver_register returned %d\n", result);
		return result;
	}

	lirc_parallel_dev = platform_device_alloc(LIRC_DRIVER_NAME, 0);
	if (!lirc_parallel_dev) {
		result = -ENOMEM;
		goto exit_driver_unregister;
	}

	result = platform_device_add(lirc_parallel_dev);
	if (result)
		goto exit_device_put;

	pport = parport_find_base(io);
	if (!pport) {
		pr_notice("no port at %x found\n", io);
		result = -ENXIO;
		goto exit_device_put;
	}
	ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
					   pf, kf, lirc_lirc_irq_handler, 0,
					   NULL);
	parport_put_port(pport);
	if (!ppdevice) {
		pr_notice("parport_register_device() failed\n");
		result = -ENXIO;
		goto exit_device_put;
	}
	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);
                result = -EIO;
                goto exit_device_put;
        }

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

	is_claimed = 0;
	parport_release(ppdevice);
 skip_init:
	driver.dev = &lirc_parallel_dev->dev;
	driver.minor = lirc_register_driver(&driver);
	if (driver.minor < 0) {
		pr_notice("register_chrdev() failed\n");
		parport_unregister_device(ppdevice);
		result = -EIO;
		goto exit_device_put;
	}
	pr_info("installed using port 0x%04x irq %d\n", io, irq);
	return 0;

exit_device_put:
	platform_device_put(lirc_parallel_dev);
exit_driver_unregister:
	platform_driver_unregister(&lirc_parallel_driver);
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
177
59.20%
1
20.00%
thomas viehweger
thomas viehweger
109
36.45%
1
20.00%
toshiaki yamane
toshiaki yamane
10
3.34%
1
20.00%
sudip mukherjee
sudip mukherjee
2
0.67%
1
20.00%
mauro carvalho chehab
mauro carvalho chehab
1
0.33%
1
20.00%
Total
299
100.00%
5
100.00%



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

	platform_device_unregister(lirc_parallel_dev);
	platform_driver_unregister(&lirc_parallel_driver);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
21
65.62%
1
50.00%
dave jones
dave jones
11
34.38%
1
50.00%
Total
32
100.00%
2
100.00%


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_mask, "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(check_pselecd, "Check for printer (default: 0)");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
jarod wilson
jarod wilson
2338
86.11%
5
27.78%
thomas viehweger
thomas viehweger
214
7.88%
1
5.56%
arnd bergmann
arnd bergmann
67
2.47%
1
5.56%
toshiaki yamane
toshiaki yamane
39
1.44%
1
5.56%
tuomas tynkkynen
tuomas tynkkynen
23
0.85%
1
5.56%
ebru akagunduz
ebru akagunduz
13
0.48%
1
5.56%
dave jones
dave jones
11
0.41%
1
5.56%
rusty russell
rusty russell
3
0.11%
2
11.11%
mauro carvalho chehab
mauro carvalho chehab
3
0.11%
2
11.11%
sudip mukherjee
sudip mukherjee
2
0.07%
1
5.56%
dan carpenter
dan carpenter
1
0.04%
1
5.56%
uwe kleine-koenig
uwe kleine-koenig
1
0.04%
1
5.56%
Total
2715
100.00%
18
100.00%
  
Directory: drivers/staging/media/lirc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.