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
8 #include "linux/kernel.h"
9 #include "linux/module.h"
10 #include "linux/smp.h"
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"
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"
34 #include "um_malloc.h"
35 #include "misc_constants.h"
38 * Generic, controller-independent functions:
41 int show_interrupts(struct seq_file
*p
, void *v
)
43 int i
= *(loff_t
*) v
, j
;
44 struct irqaction
* action
;
49 for_each_online_cpu(j
)
50 seq_printf(p
, "CPU%d ",j
);
55 spin_lock_irqsave(&irq_desc
[i
].lock
, flags
);
56 action
= irq_desc
[i
].action
;
59 seq_printf(p
, "%3d: ",i
);
61 seq_printf(p
, "%10u ", kstat_irqs(i
));
63 for_each_online_cpu(j
)
64 seq_printf(p
, "%10u ", kstat_cpu(j
).irqs
[i
]);
66 seq_printf(p
, " %14s", irq_desc
[i
].chip
->typename
);
67 seq_printf(p
, " %s", action
->name
);
69 for (action
=action
->next
; action
; action
= action
->next
)
70 seq_printf(p
, ", %s", action
->name
);
74 spin_unlock_irqrestore(&irq_desc
[i
].lock
, flags
);
75 } else if (i
== NR_IRQS
) {
82 struct irq_fd
*active_fds
= NULL
;
83 static struct irq_fd
**last_irq_ptr
= &active_fds
;
85 extern void free_irqs(void);
87 void sigio_handler(int sig
, union uml_pt_regs
*regs
)
89 struct irq_fd
*irq_fd
;
92 if (smp_sigio_handler())
96 n
= os_waiting_for_events(active_fds
);
98 if(n
== -EINTR
) continue;
102 for (irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
) {
103 if (irq_fd
->current_events
!= 0) {
104 irq_fd
->current_events
= 0;
105 do_IRQ(irq_fd
->irq
, regs
);
113 static DEFINE_SPINLOCK(irq_lock
);
115 int activate_fd(int irq
, int fd
, int type
, void *dev_id
)
117 struct pollfd
*tmp_pfd
;
118 struct irq_fd
*new_fd
, *irq_fd
;
120 int pid
, events
, err
, n
;
123 err
= os_set_fd_async(fd
, pid
);
127 new_fd
= um_kmalloc(sizeof(*new_fd
));
132 if (type
== IRQ_READ
)
133 events
= UM_POLLIN
| UM_POLLPRI
;
136 *new_fd
= ((struct irq_fd
) { .next
= NULL
,
143 .current_events
= 0 } );
145 spin_lock_irqsave(&irq_lock
, flags
);
146 for (irq_fd
= active_fds
; irq_fd
!= NULL
; irq_fd
= irq_fd
->next
) {
147 if ((irq_fd
->fd
== fd
) && (irq_fd
->type
== type
)) {
148 printk("Registering fd %d twice\n", fd
);
149 printk("Irqs : %d, %d\n", irq_fd
->irq
, irq
);
150 printk("Ids : 0x%p, 0x%p\n", irq_fd
->id
, dev_id
);
155 if (type
== IRQ_WRITE
)
162 n
= os_create_pollfd(fd
, events
, tmp_pfd
, n
);
167 * It means we couldn't put new pollfd to current pollfds
168 * and tmp_fds is NULL or too small for new pollfds array.
169 * Needed size is equal to n as minimum.
171 * Here we have to drop the lock in order to call
172 * kmalloc, which might sleep.
173 * If something else came in and changed the pollfds array
174 * so we will not be able to put new pollfd struct to pollfds
175 * then we free the buffer tmp_fds and try again.
177 spin_unlock_irqrestore(&irq_lock
, flags
);
181 tmp_pfd
= um_kmalloc(n
);
185 spin_lock_irqsave(&irq_lock
, flags
);
188 *last_irq_ptr
= new_fd
;
189 last_irq_ptr
= &new_fd
->next
;
191 spin_unlock_irqrestore(&irq_lock
, flags
);
193 /* This calls activate_fd, so it has to be outside the critical
196 maybe_sigio_broken(fd
, (type
== IRQ_READ
));
201 spin_unlock_irqrestore(&irq_lock
, flags
);
208 static void free_irq_by_cb(int (*test
)(struct irq_fd
*, void *), void *arg
)
212 spin_lock_irqsave(&irq_lock
, flags
);
213 os_free_irq_by_cb(test
, arg
, active_fds
, &last_irq_ptr
);
214 spin_unlock_irqrestore(&irq_lock
, flags
);
222 static int same_irq_and_dev(struct irq_fd
*irq
, void *d
)
224 struct irq_and_dev
*data
= d
;
226 return ((irq
->irq
== data
->irq
) && (irq
->id
== data
->dev
));
229 void free_irq_by_irq_and_dev(unsigned int irq
, void *dev
)
231 struct irq_and_dev data
= ((struct irq_and_dev
) { .irq
= irq
,
234 free_irq_by_cb(same_irq_and_dev
, &data
);
237 static int same_fd(struct irq_fd
*irq
, void *fd
)
239 return (irq
->fd
== *((int *)fd
));
242 void free_irq_by_fd(int fd
)
244 free_irq_by_cb(same_fd
, &fd
);
247 static struct irq_fd
*find_irq_by_fd(int fd
, int irqnum
, int *index_out
)
253 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
254 if ((irq
->fd
== fd
) && (irq
->irq
== irqnum
))
259 printk("find_irq_by_fd doesn't have descriptor %d\n", fd
);
262 fdi
= os_get_pollfd(i
);
263 if ((fdi
!= -1) && (fdi
!= fd
)) {
264 printk("find_irq_by_fd - mismatch between active_fds and "
265 "pollfds, fd %d vs %d, need %d\n", irq
->fd
,
275 void reactivate_fd(int fd
, int irqnum
)
281 spin_lock_irqsave(&irq_lock
, flags
);
282 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
284 spin_unlock_irqrestore(&irq_lock
, flags
);
287 os_set_pollfd(i
, irq
->fd
);
288 spin_unlock_irqrestore(&irq_lock
, flags
);
293 void deactivate_fd(int fd
, int irqnum
)
299 spin_lock_irqsave(&irq_lock
, flags
);
300 irq
= find_irq_by_fd(fd
, irqnum
, &i
);
302 spin_unlock_irqrestore(&irq_lock
, flags
);
306 os_set_pollfd(i
, -1);
307 spin_unlock_irqrestore(&irq_lock
, flags
);
312 int deactivate_all_fds(void)
317 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
318 err
= os_clear_fd_async(irq
->fd
);
322 /* If there is a signal already queued, after unblocking ignore it */
328 #ifdef CONFIG_MODE_TT
329 void forward_interrupts(int pid
)
335 spin_lock_irqsave(&irq_lock
, flags
);
336 for (irq
= active_fds
; irq
!= NULL
; irq
= irq
->next
) {
337 err
= os_set_owner(irq
->fd
, pid
);
339 /* XXX Just remove the irq rather than
340 * print out an infinite stream of these
342 printk("Failed to forward %d to pid %d, err = %d\n",
348 spin_unlock_irqrestore(&irq_lock
, flags
);
353 * do_IRQ handles all normal device IRQ's (the special
354 * SMP cross-CPU interrupts have their own specific
357 unsigned int do_IRQ(int irq
, union uml_pt_regs
*regs
)
359 struct pt_regs
*old_regs
= set_irq_regs((struct pt_regs
*)regs
);
363 set_irq_regs(old_regs
);
367 int um_request_irq(unsigned int irq
, int fd
, int type
,
368 irq_handler_t handler
,
369 unsigned long irqflags
, const char * devname
,
374 err
= request_irq(irq
, handler
, irqflags
, devname
, dev_id
);
379 err
= activate_fd(irq
, fd
, type
, dev_id
);
382 EXPORT_SYMBOL(um_request_irq
);
383 EXPORT_SYMBOL(reactivate_fd
);
385 /* hw_interrupt_type must define (startup || enable) &&
386 * (shutdown || disable) && end */
387 static void dummy(unsigned int irq
)
391 /* This is used for everything else than the timer. */
392 static struct hw_interrupt_type normal_irq_type
= {
394 .release
= free_irq_by_irq_and_dev
,
401 static struct hw_interrupt_type SIGVTALRM_irq_type
= {
402 .typename
= "SIGVTALRM",
403 .release
= free_irq_by_irq_and_dev
,
404 .shutdown
= dummy
, /* never called */
411 void __init
init_IRQ(void)
415 irq_desc
[TIMER_IRQ
].status
= IRQ_DISABLED
;
416 irq_desc
[TIMER_IRQ
].action
= NULL
;
417 irq_desc
[TIMER_IRQ
].depth
= 1;
418 irq_desc
[TIMER_IRQ
].chip
= &SIGVTALRM_irq_type
;
419 enable_irq(TIMER_IRQ
);
420 for (i
= 1; i
< NR_IRQS
; i
++) {
421 irq_desc
[i
].status
= IRQ_DISABLED
;
422 irq_desc
[i
].action
= NULL
;
423 irq_desc
[i
].depth
= 1;
424 irq_desc
[i
].chip
= &normal_irq_type
;
429 int init_aio_irq(int irq
, char *name
, irq_handler_t handler
)
433 err
= os_pipe(fds
, 1, 1);
435 printk("init_aio_irq - os_pipe failed, err = %d\n", -err
);
439 err
= um_request_irq(irq
, fds
[0], IRQ_READ
, handler
,
440 IRQF_DISABLED
| IRQF_SAMPLE_RANDOM
, name
,
441 (void *) (long) fds
[0]);
443 printk("init_aio_irq - : um_request_irq failed, err = %d\n",
452 os_close_file(fds
[0]);
453 os_close_file(fds
[1]);