[linux-block.git] / arch / um / kernel / irq.c

/* 
 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 * Derived (i.e. mostly copied) from arch/i386/kernel/irq.c:
 *	Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
 */

#include "linux/kernel.h"
#include "linux/module.h"
#include "linux/smp.h"
#include "linux/kernel_stat.h"
#include "linux/interrupt.h"
#include "linux/random.h"
#include "linux/slab.h"
#include "linux/file.h"
#include "linux/proc_fs.h"
#include "linux/init.h"
#include "linux/seq_file.h"
#include "linux/profile.h"
#include "linux/hardirq.h"
#include "asm/irq.h"
#include "asm/hw_irq.h"
#include "asm/atomic.h"
#include "asm/signal.h"
#include "asm/system.h"
#include "asm/errno.h"
#include "asm/uaccess.h"
#include "user_util.h"
#include "kern_util.h"
#include "irq_user.h"
#include "irq_kern.h"
#include "os.h"
#include "sigio.h"
#include "misc_constants.h"

/*
 * Generic, controller-independent functions:
 */

int show_interrupts(struct seq_file *p, void *v)
{
	int i = *(loff_t *) v, j;
	struct irqaction * action;
	unsigned long flags;

	if (i == 0) {
		seq_printf(p, "           ");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%d       ",j);
		seq_putc(p, '\n');
	}

	if (i < NR_IRQS) {
		spin_lock_irqsave(&irq_desc[i].lock, flags);
		action = irq_desc[i].action;
		if (!action) 
			goto skip;
		seq_printf(p, "%3d: ",i);
#ifndef CONFIG_SMP
		seq_printf(p, "%10u ", kstat_irqs(i));
#else
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
#endif
		seq_printf(p, " %14s", irq_desc[i].chip->typename);
		seq_printf(p, "  %s", action->name);

		for (action=action->next; action; action = action->next)
			seq_printf(p, ", %s", action->name);

		seq_putc(p, '\n');
skip:
		spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	} else if (i == NR_IRQS) {
		seq_putc(p, '\n');
	}

	return 0;
}

struct irq_fd *active_fds = NULL;
static struct irq_fd **last_irq_ptr = &active_fds;

extern void free_irqs(void);

void sigio_handler(int sig, union uml_pt_regs *regs)
{
	struct irq_fd *irq_fd;
	int n;

	if (smp_sigio_handler())
		return;

	while (1) {
		n = os_waiting_for_events(active_fds);
		if (n <= 0) {
			if(n == -EINTR) continue;
			else break;
		}

		for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) {
			if (irq_fd->current_events != 0) {
				irq_fd->current_events = 0;
				do_IRQ(irq_fd->irq, regs);
			}
		}
	}

	free_irqs();
}

static DEFINE_SPINLOCK(irq_lock);

int activate_fd(int irq, int fd, int type, void *dev_id)
{
	struct pollfd *tmp_pfd;
	struct irq_fd *new_fd, *irq_fd;
	unsigned long flags;
	int pid, events, err, n;

	pid = os_getpid();
	err = os_set_fd_async(fd, pid);
	if (err < 0)
		goto out;

	new_fd = um_kmalloc(sizeof(*new_fd));
	err = -ENOMEM;
	if (new_fd == NULL)
		goto out;

	if (type == IRQ_READ)
		events = UM_POLLIN | UM_POLLPRI;
	else
		events = UM_POLLOUT;
	*new_fd = ((struct irq_fd) { .next  		= NULL,
				     .id 		= dev_id,
				     .fd 		= fd,
				     .type 		= type,
				     .irq 		= irq,
				     .pid  		= pid,
				     .events 		= events,
				     .current_events 	= 0 } );

	spin_lock_irqsave(&irq_lock, flags);
	for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) {
		if ((irq_fd->fd == fd) && (irq_fd->type == type)) {
			printk("Registering fd %d twice\n", fd);
			printk("Irqs : %d, %d\n", irq_fd->irq, irq);
			printk("Ids : 0x%p, 0x%p\n", irq_fd->id, dev_id);
			goto out_unlock;
		}
	}

	if (type == IRQ_WRITE)
		fd = -1;

	tmp_pfd = NULL;
	n = 0;

	while (1) {
		n = os_create_pollfd(fd, events, tmp_pfd, n);
		if (n == 0)
			break;

		/* n > 0
		 * It means we couldn't put new pollfd to current pollfds
		 * and tmp_fds is NULL or too small for new pollfds array.
		 * Needed size is equal to n as minimum.
		 *
		 * Here we have to drop the lock in order to call
		 * kmalloc, which might sleep.
		 * If something else came in and changed the pollfds array
		 * so we will not be able to put new pollfd struct to pollfds
		 * then we free the buffer tmp_fds and try again.
		 */
		spin_unlock_irqrestore(&irq_lock, flags);
		kfree(tmp_pfd);
		tmp_pfd = NULL;

		tmp_pfd = um_kmalloc(n);
		if (tmp_pfd == NULL)
			goto out_kfree;

		spin_lock_irqsave(&irq_lock, flags);
	}

	*last_irq_ptr = new_fd;
	last_irq_ptr = &new_fd->next;

	spin_unlock_irqrestore(&irq_lock, flags);

	/* This calls activate_fd, so it has to be outside the critical
	 * section.
	 */
	maybe_sigio_broken(fd, (type == IRQ_READ));

	return 0;

 out_unlock:
	spin_unlock_irqrestore(&irq_lock, flags);
 out_kfree:
	kfree(new_fd);
 out:
	return err;
}

static void free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg)
{
	unsigned long flags;

	spin_lock_irqsave(&irq_lock, flags);
	os_free_irq_by_cb(test, arg, active_fds, &last_irq_ptr);
	spin_unlock_irqrestore(&irq_lock, flags);
}

struct irq_and_dev {
	int irq;
	void *dev;
};

static int same_irq_and_dev(struct irq_fd *irq, void *d)
{
	struct irq_and_dev *data = d;

	return ((irq->irq == data->irq) && (irq->id == data->dev));
}

void free_irq_by_irq_and_dev(unsigned int irq, void *dev)
{
	struct irq_and_dev data = ((struct irq_and_dev) { .irq  = irq,
							  .dev  = dev });

	free_irq_by_cb(same_irq_and_dev, &data);
}

static int same_fd(struct irq_fd *irq, void *fd)
{
	return (irq->fd == *((int *)fd));
}

void free_irq_by_fd(int fd)
{
	free_irq_by_cb(same_fd, &fd);
}

static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out)
{
	struct irq_fd *irq;
	int i = 0;
	int fdi;

	for (irq = active_fds; irq != NULL; irq = irq->next) {
		if ((irq->fd == fd) && (irq->irq == irqnum))
			break;
		i++;
	}
	if (irq == NULL) {
		printk("find_irq_by_fd doesn't have descriptor %d\n", fd);
		goto out;
	}
	fdi = os_get_pollfd(i);
	if ((fdi != -1) && (fdi != fd)) {
		printk("find_irq_by_fd - mismatch between active_fds and "
		       "pollfds, fd %d vs %d, need %d\n", irq->fd,
		       fdi, fd);
		irq = NULL;
		goto out;
	}
	*index_out = i;
 out:
	return irq;
}

void reactivate_fd(int fd, int irqnum)
{
	struct irq_fd *irq;
	unsigned long flags;
	int i;

	spin_lock_irqsave(&irq_lock, flags);
	irq = find_irq_by_fd(fd, irqnum, &i);
	if (irq == NULL) {
		spin_unlock_irqrestore(&irq_lock, flags);
		return;
	}
	os_set_pollfd(i, irq->fd);
	spin_unlock_irqrestore(&irq_lock, flags);

	add_sigio_fd(fd);
}

void deactivate_fd(int fd, int irqnum)
{
	struct irq_fd *irq;
	unsigned long flags;
	int i;

	spin_lock_irqsave(&irq_lock, flags);
	irq = find_irq_by_fd(fd, irqnum, &i);
	if(irq == NULL){
		spin_unlock_irqrestore(&irq_lock, flags);
		return;
	}

	os_set_pollfd(i, -1);
	spin_unlock_irqrestore(&irq_lock, flags);

	ignore_sigio_fd(fd);
}

int deactivate_all_fds(void)
{
	struct irq_fd *irq;
	int err;

	for (irq = active_fds; irq != NULL; irq = irq->next) {
		err = os_clear_fd_async(irq->fd);
		if (err)
			return err;
	}
	/* If there is a signal already queued, after unblocking ignore it */
	os_set_ioignore();

	return 0;
}

#ifdef CONFIG_MODE_TT
void forward_interrupts(int pid)
{
	struct irq_fd *irq;
	unsigned long flags;
	int err;

	spin_lock_irqsave(&irq_lock, flags);
	for (irq = active_fds; irq != NULL; irq = irq->next) {
		err = os_set_owner(irq->fd, pid);
		if (err < 0) {
			/* XXX Just remove the irq rather than
			 * print out an infinite stream of these
			 */
			printk("Failed to forward %d to pid %d, err = %d\n",
			       irq->fd, pid, -err);
		}

		irq->pid = pid;
	}
	spin_unlock_irqrestore(&irq_lock, flags);
}
#endif

/*
 * do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
 */
unsigned int do_IRQ(int irq, union uml_pt_regs *regs)
{
       irq_enter();
       __do_IRQ(irq);
       irq_exit();
       return 1;
}

int um_request_irq(unsigned int irq, int fd, int type,
		   irqreturn_t (*handler)(int, void *, struct pt_regs *),
		   unsigned long irqflags, const char * devname,
		   void *dev_id)
{
	int err;

	err = request_irq(irq, handler, irqflags, devname, dev_id);
	if (err)
		return err;

	if (fd != -1)
		err = activate_fd(irq, fd, type, dev_id);
	return err;
}
EXPORT_SYMBOL(um_request_irq);
EXPORT_SYMBOL(reactivate_fd);

/* hw_interrupt_type must define (startup || enable) &&
 * (shutdown || disable) && end */
static void dummy(unsigned int irq)
{
}

/* This is used for everything else than the timer. */
static struct hw_interrupt_type normal_irq_type = {
	.typename = "SIGIO",
	.release = free_irq_by_irq_and_dev,
	.disable = dummy,
	.enable = dummy,
	.ack = dummy,
	.end = dummy
};

static struct hw_interrupt_type SIGVTALRM_irq_type = {
	.typename = "SIGVTALRM",
	.release = free_irq_by_irq_and_dev,
	.shutdown = dummy, /* never called */
	.disable = dummy,
	.enable = dummy,
	.ack = dummy,
	.end = dummy
};

void __init init_IRQ(void)
{
	int i;

	irq_desc[TIMER_IRQ].status = IRQ_DISABLED;
	irq_desc[TIMER_IRQ].action = NULL;
	irq_desc[TIMER_IRQ].depth = 1;
	irq_desc[TIMER_IRQ].chip = &SIGVTALRM_irq_type;
	enable_irq(TIMER_IRQ);
	for (i = 1; i < NR_IRQS; i++) {
		irq_desc[i].status = IRQ_DISABLED;
		irq_desc[i].action = NULL;
		irq_desc[i].depth = 1;
		irq_desc[i].chip = &normal_irq_type;
		enable_irq(i);
	}
}

int init_aio_irq(int irq, char *name, irqreturn_t (*handler)(int, void *,
							     struct pt_regs *))
{
	int fds[2], err;

	err = os_pipe(fds, 1, 1);
	if (err) {
		printk("init_aio_irq - os_pipe failed, err = %d\n", -err);
		goto out;
	}

	err = um_request_irq(irq, fds[0], IRQ_READ, handler,
			     IRQF_DISABLED | IRQF_SAMPLE_RANDOM, name,
			     (void *) (long) fds[0]);
	if (err) {
		printk("init_aio_irq - : um_request_irq failed, err = %d\n",
		       err);
		goto out_close;
	}

	err = fds[1];
	goto out;

 out_close:
	os_close_file(fds[0]);
	os_close_file(fds[1]);
 out:
	return err;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
	3	* Licensed under the GPL
	4	* Derived (i.e. mostly copied) from arch/i386/kernel/irq.c:
	5	* Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
	6	*/
	7
1da177e4 LT	8	#include "linux/kernel.h"
	9	#include "linux/module.h"
	10	#include "linux/smp.h"
1da177e4 LT	11	#include "linux/kernel_stat.h"
	12	#include "linux/interrupt.h"
	13	#include "linux/random.h"
	14	#include "linux/slab.h"
	15	#include "linux/file.h"
	16	#include "linux/proc_fs.h"
	17	#include "linux/init.h"
	18	#include "linux/seq_file.h"
	19	#include "linux/profile.h"
	20	#include "linux/hardirq.h"
	21	#include "asm/irq.h"
	22	#include "asm/hw_irq.h"
	23	#include "asm/atomic.h"
	24	#include "asm/signal.h"
	25	#include "asm/system.h"
	26	#include "asm/errno.h"
	27	#include "asm/uaccess.h"
	28	#include "user_util.h"
	29	#include "kern_util.h"
	30	#include "irq_user.h"
	31	#include "irq_kern.h"
75e5584c	32	#include "os.h"
9b4f018d JD	33	#include "sigio.h"
9b4f018d JD	34	#include "misc_constants.h"
1da177e4 LT	35
	36	/*
	37	* Generic, controller-independent functions:
	38	*/
	39
	40	int show_interrupts(struct seq_file p, void v)
	41	{
	42	int i = (loff_t ) v, j;
	43	struct irqaction * action;
	44	unsigned long flags;
	45
	46	if (i == 0) {
	47	seq_printf(p, " ");
	48	for_each_online_cpu(j)
	49	seq_printf(p, "CPU%d ",j);
	50	seq_putc(p, '\n');
	51	}
	52
	53	if (i < NR_IRQS) {
	54	spin_lock_irqsave(&irq_desc[i].lock, flags);
	55	action = irq_desc[i].action;
	56	if (!action)
	57	goto skip;
	58	seq_printf(p, "%3d: ",i);
	59	#ifndef CONFIG_SMP
	60	seq_printf(p, "%10u ", kstat_irqs(i));
	61	#else
	62	for_each_online_cpu(j)
	63	seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
	64	#endif
d1bef4ed	65	seq_printf(p, " %14s", irq_desc[i].chip->typename);
1da177e4 LT	66	seq_printf(p, " %s", action->name);
	67
	68	for (action=action->next; action; action = action->next)
	69	seq_printf(p, ", %s", action->name);
	70
	71	seq_putc(p, '\n');
	72	skip:
	73	spin_unlock_irqrestore(&irq_desc[i].lock, flags);
	74	} else if (i == NR_IRQS) {
	75	seq_putc(p, '\n');
	76	}
	77
	78	return 0;
	79	}
	80
9b4f018d JD	81	struct irq_fd *active_fds = NULL;
	82	static struct irq_fd **last_irq_ptr = &active_fds;
	83
	84	extern void free_irqs(void);
	85
	86	void sigio_handler(int sig, union uml_pt_regs *regs)
	87	{
	88	struct irq_fd *irq_fd;
	89	int n;
	90
191ef966 JJ	91	if (smp_sigio_handler())
	92	return;
	93
	94	while (1) {
9b4f018d JD	95	n = os_waiting_for_events(active_fds);
	96	if (n <= 0) {
	97	if(n == -EINTR) continue;
	98	else break;
	99	}
	100
191ef966 JJ	101	for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) {
191ef966 JJ	102	if (irq_fd->current_events != 0) {
9b4f018d JD	103	irq_fd->current_events = 0;
	104	do_IRQ(irq_fd->irq, regs);
	105	}
	106	}
	107	}
	108
	109	free_irqs();
	110	}
	111
bfaafd71 JD	112	static DEFINE_SPINLOCK(irq_lock);
bfaafd71 JD	113
9b4f018d JD	114	int activate_fd(int irq, int fd, int type, void *dev_id)
	115	{
	116	struct pollfd *tmp_pfd;
	117	struct irq_fd new_fd, irq_fd;
	118	unsigned long flags;
	119	int pid, events, err, n;
	120
	121	pid = os_getpid();
	122	err = os_set_fd_async(fd, pid);
191ef966	123	if (err < 0)
9b4f018d JD	124	goto out;
	125
	126	new_fd = um_kmalloc(sizeof(*new_fd));
	127	err = -ENOMEM;
191ef966	128	if (new_fd == NULL)
9b4f018d JD	129	goto out;
9b4f018d JD	130
191ef966 JJ	131	if (type == IRQ_READ)
	132	events = UM_POLLIN \| UM_POLLPRI;
	133	else
	134	events = UM_POLLOUT;
9b4f018d JD	135	*new_fd = ((struct irq_fd) { .next = NULL,
	136	.id = dev_id,
	137	.fd = fd,
	138	.type = type,
	139	.irq = irq,
	140	.pid = pid,
	141	.events = events,
	142	.current_events = 0 } );
	143
bfaafd71	144	spin_lock_irqsave(&irq_lock, flags);
191ef966 JJ	145	for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) {
191ef966 JJ	146	if ((irq_fd->fd == fd) && (irq_fd->type == type)) {
9b4f018d JD	147	printk("Registering fd %d twice\n", fd);
	148	printk("Irqs : %d, %d\n", irq_fd->irq, irq);
	149	printk("Ids : 0x%p, 0x%p\n", irq_fd->id, dev_id);
	150	goto out_unlock;
	151	}
	152	}
	153
191ef966	154	if (type == IRQ_WRITE)
9b4f018d JD	155	fd = -1;
	156
	157	tmp_pfd = NULL;
	158	n = 0;
	159
191ef966	160	while (1) {
9b4f018d JD	161	n = os_create_pollfd(fd, events, tmp_pfd, n);
	162	if (n == 0)
	163	break;
	164
	165	/* n > 0
	166	* It means we couldn't put new pollfd to current pollfds
	167	* and tmp_fds is NULL or too small for new pollfds array.
	168	* Needed size is equal to n as minimum.
	169	*
	170	* Here we have to drop the lock in order to call
	171	* kmalloc, which might sleep.
	172	* If something else came in and changed the pollfds array
	173	* so we will not be able to put new pollfd struct to pollfds
	174	* then we free the buffer tmp_fds and try again.
	175	*/
bfaafd71	176	spin_unlock_irqrestore(&irq_lock, flags);
191ef966 JJ	177	kfree(tmp_pfd);
191ef966 JJ	178	tmp_pfd = NULL;
9b4f018d JD	179
	180	tmp_pfd = um_kmalloc(n);
	181	if (tmp_pfd == NULL)
	182	goto out_kfree;
	183
bfaafd71	184	spin_lock_irqsave(&irq_lock, flags);
9b4f018d	185	}
9b4f018d JD	186
	187	*last_irq_ptr = new_fd;
	188	last_irq_ptr = &new_fd->next;
	189
bfaafd71	190	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d JD	191
	192	/* This calls activate_fd, so it has to be outside the critical
	193	* section.
	194	*/
8e64d96a	195	maybe_sigio_broken(fd, (type == IRQ_READ));
9b4f018d	196
19bdf040	197	return 0;
9b4f018d JD	198
9b4f018d JD	199	out_unlock:
bfaafd71	200	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d JD	201	out_kfree:
	202	kfree(new_fd);
	203	out:
19bdf040	204	return err;
9b4f018d JD	205	}
	206
	207	static void free_irq_by_cb(int (test)(struct irq_fd , void ), void arg)
	208	{
	209	unsigned long flags;
	210
bfaafd71	211	spin_lock_irqsave(&irq_lock, flags);
9b4f018d	212	os_free_irq_by_cb(test, arg, active_fds, &last_irq_ptr);
bfaafd71	213	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d JD	214	}
	215
	216	struct irq_and_dev {
	217	int irq;
	218	void *dev;
	219	};
	220
	221	static int same_irq_and_dev(struct irq_fd irq, void d)
	222	{
	223	struct irq_and_dev *data = d;
	224
191ef966	225	return ((irq->irq == data->irq) && (irq->id == data->dev));
9b4f018d JD	226	}
	227
	228	void free_irq_by_irq_and_dev(unsigned int irq, void *dev)
	229	{
	230	struct irq_and_dev data = ((struct irq_and_dev) { .irq = irq,
	231	.dev = dev });
	232
	233	free_irq_by_cb(same_irq_and_dev, &data);
	234	}
	235
	236	static int same_fd(struct irq_fd irq, void fd)
	237	{
191ef966	238	return (irq->fd == ((int )fd));
9b4f018d JD	239	}
	240
	241	void free_irq_by_fd(int fd)
	242	{
	243	free_irq_by_cb(same_fd, &fd);
	244	}
	245
	246	static struct irq_fd find_irq_by_fd(int fd, int irqnum, int index_out)
	247	{
	248	struct irq_fd *irq;
	249	int i = 0;
	250	int fdi;
	251
191ef966 JJ	252	for (irq = active_fds; irq != NULL; irq = irq->next) {
	253	if ((irq->fd == fd) && (irq->irq == irqnum))
	254	break;
9b4f018d JD	255	i++;
9b4f018d JD	256	}
191ef966	257	if (irq == NULL) {
9b4f018d JD	258	printk("find_irq_by_fd doesn't have descriptor %d\n", fd);
	259	goto out;
	260	}
	261	fdi = os_get_pollfd(i);
191ef966	262	if ((fdi != -1) && (fdi != fd)) {
9b4f018d JD	263	printk("find_irq_by_fd - mismatch between active_fds and "
	264	"pollfds, fd %d vs %d, need %d\n", irq->fd,
	265	fdi, fd);
	266	irq = NULL;
	267	goto out;
	268	}
	269	*index_out = i;
	270	out:
191ef966	271	return irq;
9b4f018d JD	272	}
	273
	274	void reactivate_fd(int fd, int irqnum)
	275	{
	276	struct irq_fd *irq;
	277	unsigned long flags;
	278	int i;
	279
bfaafd71	280	spin_lock_irqsave(&irq_lock, flags);
9b4f018d	281	irq = find_irq_by_fd(fd, irqnum, &i);
191ef966	282	if (irq == NULL) {
bfaafd71	283	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d JD	284	return;
	285	}
	286	os_set_pollfd(i, irq->fd);
bfaafd71	287	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d	288
19bdf040	289	add_sigio_fd(fd);
9b4f018d JD	290	}
	291
	292	void deactivate_fd(int fd, int irqnum)
	293	{
	294	struct irq_fd *irq;
	295	unsigned long flags;
	296	int i;
	297
bfaafd71	298	spin_lock_irqsave(&irq_lock, flags);
9b4f018d	299	irq = find_irq_by_fd(fd, irqnum, &i);
19bdf040 JD	300	if(irq == NULL){
	301	spin_unlock_irqrestore(&irq_lock, flags);
	302	return;
	303	}
	304
9b4f018d	305	os_set_pollfd(i, -1);
bfaafd71	306	spin_unlock_irqrestore(&irq_lock, flags);
19bdf040 JD	307
19bdf040 JD	308	ignore_sigio_fd(fd);
9b4f018d JD	309	}
	310
	311	int deactivate_all_fds(void)
	312	{
	313	struct irq_fd *irq;
	314	int err;
	315
191ef966	316	for (irq = active_fds; irq != NULL; irq = irq->next) {
9b4f018d	317	err = os_clear_fd_async(irq->fd);
191ef966 JJ	318	if (err)
191ef966 JJ	319	return err;
9b4f018d JD	320	}
	321	/* If there is a signal already queued, after unblocking ignore it */
	322	os_set_ioignore();
	323
191ef966	324	return 0;
9b4f018d JD	325	}
9b4f018d JD	326
8ae43ff8	327	#ifdef CONFIG_MODE_TT
9b4f018d JD	328	void forward_interrupts(int pid)
	329	{
	330	struct irq_fd *irq;
	331	unsigned long flags;
	332	int err;
	333
bfaafd71	334	spin_lock_irqsave(&irq_lock, flags);
191ef966	335	for (irq = active_fds; irq != NULL; irq = irq->next) {
9b4f018d	336	err = os_set_owner(irq->fd, pid);
191ef966	337	if (err < 0) {
9b4f018d JD	338	/* XXX Just remove the irq rather than
	339	* print out an infinite stream of these
	340	*/
	341	printk("Failed to forward %d to pid %d, err = %d\n",
	342	irq->fd, pid, -err);
	343	}
	344
	345	irq->pid = pid;
	346	}
bfaafd71	347	spin_unlock_irqrestore(&irq_lock, flags);
9b4f018d	348	}
8ae43ff8	349	#endif
9b4f018d	350
1da177e4 LT	351	/*
	352	* do_IRQ handles all normal device IRQ's (the special
	353	* SMP cross-CPU interrupts have their own specific
	354	* handlers).
	355	*/
	356	unsigned int do_IRQ(int irq, union uml_pt_regs *regs)
	357	{
	358	irq_enter();
96e1a873	359	__do_IRQ(irq);
1da177e4 LT	360	irq_exit();
	361	return 1;
	362	}
	363
	364	int um_request_irq(unsigned int irq, int fd, int type,
	365	irqreturn_t (handler)(int, void , struct pt_regs *),
	366	unsigned long irqflags, const char * devname,
	367	void *dev_id)
	368	{
	369	int err;
	370
	371	err = request_irq(irq, handler, irqflags, devname, dev_id);
191ef966 JJ	372	if (err)
191ef966 JJ	373	return err;
1da177e4	374
191ef966	375	if (fd != -1)
1da177e4	376	err = activate_fd(irq, fd, type, dev_id);
191ef966	377	return err;
1da177e4 LT	378	}
	379	EXPORT_SYMBOL(um_request_irq);
	380	EXPORT_SYMBOL(reactivate_fd);
	381
dbce706e PBG	382	/* hw_interrupt_type must define (startup \|\| enable) &&
dbce706e PBG	383	* (shutdown \|\| disable) && end */
1da177e4 LT	384	static void dummy(unsigned int irq)
	385	{
	386	}
	387
dbce706e PBG	388	/* This is used for everything else than the timer. */
dbce706e PBG	389	static struct hw_interrupt_type normal_irq_type = {
1da177e4	390	.typename = "SIGIO",
dbce706e	391	.release = free_irq_by_irq_and_dev,
1da177e4 LT	392	.disable = dummy,
	393	.enable = dummy,
	394	.ack = dummy,
	395	.end = dummy
	396	};
	397
	398	static struct hw_interrupt_type SIGVTALRM_irq_type = {
	399	.typename = "SIGVTALRM",
dbce706e	400	.release = free_irq_by_irq_and_dev,
1da177e4 LT	401	.shutdown = dummy, /* never called */
	402	.disable = dummy,
	403	.enable = dummy,
	404	.ack = dummy,
	405	.end = dummy
	406	};
	407
	408	void __init init_IRQ(void)
	409	{
	410	int i;
	411
	412	irq_desc[TIMER_IRQ].status = IRQ_DISABLED;
	413	irq_desc[TIMER_IRQ].action = NULL;
	414	irq_desc[TIMER_IRQ].depth = 1;
d1bef4ed	415	irq_desc[TIMER_IRQ].chip = &SIGVTALRM_irq_type;
1da177e4	416	enable_irq(TIMER_IRQ);
191ef966	417	for (i = 1; i < NR_IRQS; i++) {
1da177e4 LT	418	irq_desc[i].status = IRQ_DISABLED;
	419	irq_desc[i].action = NULL;
	420	irq_desc[i].depth = 1;
d1bef4ed	421	irq_desc[i].chip = &normal_irq_type;
1da177e4 LT	422	enable_irq(i);
1da177e4 LT	423	}
1da177e4 LT	424	}
1da177e4 LT	425
75e5584c JD	426	int init_aio_irq(int irq, char name, irqreturn_t (handler)(int, void *,
	427	struct pt_regs *))
	428	{
	429	int fds[2], err;
	430
	431	err = os_pipe(fds, 1, 1);
191ef966	432	if (err) {
75e5584c JD	433	printk("init_aio_irq - os_pipe failed, err = %d\n", -err);
	434	goto out;
	435	}
	436
	437	err = um_request_irq(irq, fds[0], IRQ_READ, handler,
bd6aa650	438	IRQF_DISABLED \| IRQF_SAMPLE_RANDOM, name,
75e5584c	439	(void *) (long) fds[0]);
191ef966	440	if (err) {
75e5584c JD	441	printk("init_aio_irq - : um_request_irq failed, err = %d\n",
	442	err);
	443	goto out_close;
	444	}
	445
	446	err = fds[1];
	447	goto out;
	448
	449	out_close:
	450	os_close_file(fds[0]);
	451	os_close_file(fds[1]);
	452	out:
191ef966	453	return err;
75e5584c	454	}