source: trunk/minix/kernel/system/do_irqctl.c@ 20

Last change on this file since 20 was 9, checked in by Mattia Monga, 14 years ago

Minix 3.1.2a
File size: 5.2 KB
Line 
1/* The kernel call implemented in this file:
2 * m_type: SYS_IRQCTL
3 *
4 * The parameters for this kernel call are:
5 * m5_c1: IRQ_REQUEST (control operation to perform)
6 * m5_c2: IRQ_VECTOR (irq line that must be controlled)
7 * m5_i1: IRQ_POLICY (irq policy allows reenabling interrupts)
8 * m5_l3: IRQ_HOOK_ID (provides index to be returned on interrupt)
9 * ,, ,, (returns index of irq hook assigned at kernel)
10 */
11
12#include "../system.h"
13
14#include <minix/endpoint.h>
15
16#if USE_IRQCTL
17
18FORWARD _PROTOTYPE(int generic_handler, (irq_hook_t *hook));
19
20/*===========================================================================*
21 * do_irqctl *
22 *===========================================================================*/
23PUBLIC int do_irqctl(m_ptr)
24register message *m_ptr; /* pointer to request message */
25{
26 /* Dismember the request message. */
27 int irq_vec;
28 int irq_hook_id;
29 int notify_id;
30 int r = OK;
31 int i;
32 irq_hook_t *hook_ptr;
33 struct proc *rp;
34 struct priv *privp;
35
36 /* Hook identifiers start at 1 and end at NR_IRQ_HOOKS. */
37 irq_hook_id = (unsigned) m_ptr->IRQ_HOOK_ID - 1;
38 irq_vec = (unsigned) m_ptr->IRQ_VECTOR;
39
40 /* See what is requested and take needed actions. */
41 switch(m_ptr->IRQ_REQUEST) {
42
43 /* Enable or disable IRQs. This is straightforward. */
44 case IRQ_ENABLE:
45 case IRQ_DISABLE:
46 if (irq_hook_id >= NR_IRQ_HOOKS || irq_hook_id < 0 ||
47 irq_hooks[irq_hook_id].proc_nr_e == NONE) return(EINVAL);
48 if (irq_hooks[irq_hook_id].proc_nr_e != m_ptr->m_source) return(EPERM);
49 if (m_ptr->IRQ_REQUEST == IRQ_ENABLE)
50 enable_irq(&irq_hooks[irq_hook_id]);
51 else
52 disable_irq(&irq_hooks[irq_hook_id]);
53 break;
54
55 /* Control IRQ policies. Set a policy and needed details in the IRQ table.
56 * This policy is used by a generic function to handle hardware interrupts.
57 */
58 case IRQ_SETPOLICY:
59
60 /* Check if IRQ line is acceptable. */
61 if (irq_vec < 0 || irq_vec >= NR_IRQ_VECTORS) return(EINVAL);
62
63 rp= proc_addr(who_p);
64 privp= priv(rp);
65 if (!privp)
66 {
67 kprintf("no priv structure!\n");
68 return EPERM;
69 }
70 if (privp->s_flags & CHECK_IRQ)
71 {
72 for (i= 0; i<privp->s_nr_irq; i++)
73 {
74 if (irq_vec == privp->s_irq_tab[i])
75 break;
76 }
77 if (i >= privp->s_nr_irq)
78 {
79 kprintf(
80 "do_irqctl: IRQ check failed for proc %d, IRQ %d\n",
81 m_ptr->m_source, irq_vec);
82 return EPERM;
83 }
84 }
85
86 /* Find a free IRQ hook for this mapping. */
87 hook_ptr = NULL;
88 for (irq_hook_id=0; irq_hook_id<NR_IRQ_HOOKS; irq_hook_id++) {
89 if (irq_hooks[irq_hook_id].proc_nr_e == NONE) {
90 hook_ptr = &irq_hooks[irq_hook_id]; /* free hook */
91 break;
92 }
93 }
94 if (hook_ptr == NULL) return(ENOSPC);
95
96 /* When setting a policy, the caller must provide an identifier that
97 * is returned on the notification message if a interrupt occurs.
98 */
99 notify_id = (unsigned) m_ptr->IRQ_HOOK_ID;
100 if (notify_id > CHAR_BIT * sizeof(irq_id_t) - 1) return(EINVAL);
101
102 /* Install the handler. */
103 hook_ptr->proc_nr_e = m_ptr->m_source; /* process to notify */
104 hook_ptr->notify_id = notify_id; /* identifier to pass */
105 hook_ptr->policy = m_ptr->IRQ_POLICY; /* policy for interrupts */
106 put_irq_handler(hook_ptr, irq_vec, generic_handler);
107
108 /* Return index of the IRQ hook in use. */
109 m_ptr->IRQ_HOOK_ID = irq_hook_id + 1;
110 break;
111
112 case IRQ_RMPOLICY:
113 if (irq_hook_id < 0 || irq_hook_id >= NR_IRQ_HOOKS ||
114 irq_hooks[irq_hook_id].proc_nr_e == NONE) {
115 return(EINVAL);
116 } else if (m_ptr->m_source != irq_hooks[irq_hook_id].proc_nr_e) {
117 return(EPERM);
118 }
119 /* Remove the handler and return. */
120 rm_irq_handler(&irq_hooks[irq_hook_id]);
121 break;
122
123 default:
124 r = EINVAL; /* invalid IRQ_REQUEST */
125 }
126 return(r);
127}
128
129/*===========================================================================*
130 * generic_handler *
131 *===========================================================================*/
132PRIVATE int generic_handler(hook)
133irq_hook_t *hook;
134{
135/* This function handles hardware interrupt in a simple and generic way. All
136 * interrupts are transformed into messages to a driver. The IRQ line will be
137 * reenabled if the policy says so.
138 */
139 int proc;
140
141 /* As a side-effect, the interrupt handler gathers random information by
142 * timestamping the interrupt events. This is used for /dev/random.
143 */
144 get_randomness(hook->irq);
145
146 /* Check if the handler is still alive. If not, forget about the
147 * interrupt. This should never happen, as processes that die
148 * automatically get their interrupt hooks unhooked.
149 */
150 if(!isokendpt(hook->proc_nr_e, &proc)) {
151 hook->proc_nr_e = NONE;
152 return 0;
153 }
154
155 /* Add a bit for this interrupt to the process' pending interrupts. When
156 * sending the notification message, this bit map will be magically set
157 * as an argument.
158 */
159 priv(proc_addr(proc))->s_int_pending |= (1 << hook->notify_id);
160
161 /* Build notification message and return. */
162 lock_notify(HARDWARE, hook->proc_nr_e);
163 return(hook->policy & IRQ_REENABLE);
164}
165
166#endif /* USE_IRQCTL */
167
Note: See TracBrowser for help on using the repository browser.