source: GPL/branches/uniaud32-2.1.x/lib32/irq.c@ 548

Last change on this file since 548 was 548, checked in by David Azarewicz, 14 years ago

APIC interrupt fixes from trunk
File size: 7.1 KB
Line 
1/* $Id: irq.c,v 1.1.1.1 2003/07/02 13:57:02 eleph Exp $ */
2/*
3 * OS/2 implementation of Linux irq kernel services
4 *
5 * (C) 2000-2002 InnoTek Systemberatung GmbH
6 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public
19 * License along with this program; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
21 * USA.
22 *
23 */
24
25#include "linux.h"
26#include <linux/init.h>
27#include <linux/poll.h>
28#include <asm/uaccess.h>
29#include <asm/hardirq.h>
30
31#define LINUX
32#include <ossidc.h>
33#include <ossidc32.h>
34#include <osspci.h>
35#include <dbgos2.h>
36#include "irqos2.h"
37
38
39BOOL fInInterrupt = FALSE;
40extern BOOL fSuspended; //pci.c
41
42
43//******************************************************************************
44//******************************************************************************
45
46static IRQ_SLOT arSlots[MAX_IRQ_SLOTS] = { 0 };
47static ULONG eoiIrq[255] = {0};
48
49
50//******************************************************************************
51//******************************************************************************
52static IRQ_SLOT *FindSlot(unsigned irq)
53{
54 IRQ_SLOT *pSlot;
55
56 for( pSlot = arSlots; pSlot != &arSlots[MAX_IRQ_SLOTS]; pSlot++ )
57 {
58 if( pSlot->irqNo == irq ) return pSlot;
59 }
60
61 return NULL;
62}
63
64
65//******************************************************************************
66//******************************************************************************
67
68int request_irq(unsigned irq, irq_handler_t handler,
69 unsigned long ulSharedFlag, const char *pchName, void *pUserData)
70{
71 IRQ_SLOT *pSlot = FindSlot(irq & 0xff);
72 unsigned u, uSlotNo = (unsigned)-1;
73 ULONG hRes;
74
75 rprintf(("request_irq: irq %d", irq & 0xff ));
76 if ( !pSlot ) {
77 // find empty slot
78 for( uSlotNo = 0; uSlotNo < MAX_IRQ_SLOTS; uSlotNo++ ) {
79 if( arSlots[uSlotNo].flHandlers == 0 ) {
80 pSlot = &arSlots[uSlotNo];
81 break;
82 }
83 }
84 }
85
86 if ( pSlot ) {
87 hRes = NULL;
88 if (RMRequestIRQ(irq, (ulSharedFlag & SA_SHIRQ) != 0, &hRes) == FALSE) {
89 rprintf(("RMRequestIRQ failed for irq %d", irq));
90 // return 0;
91 }
92 pSlot->irqNo = irq & 0xff;
93 pSlot->hRes = hRes;
94
95 for ( u = 0; u < MAX_SHAREDIRQS; u++ ) {
96 if ( pSlot->irqHandlers[u].handler == NULL ) {
97 pSlot->irqHandlers[u].handler = handler;
98 pSlot->irqHandlers[u].x0 = ulSharedFlag;
99 pSlot->irqHandlers[u].x1 = (char *)pchName;
100 pSlot->irqHandlers[u].x2 = pUserData;
101
102 if( pSlot->flHandlers != 0 || ALSA_SetIrq( irq & 0xff, uSlotNo, (ulSharedFlag & SA_SHIRQ) != 0) ) {
103 pSlot->flHandlers |= 1 << u;
104 return 0;
105 }
106
107 break;
108 }
109 }
110 }
111
112 rprintf(("request_irq: Unable to register irq handler for irq %d", irq & 0xff ));
113 return 1;
114}
115
116
117//******************************************************************************
118//******************************************************************************
119void free_irq(unsigned int irq, void *userdata)
120{
121 unsigned u;
122 IRQ_SLOT *pSlot;
123
124 if( (pSlot = FindSlot(irq&0xff)) != NULL ) {
125 for( u = 0; u < MAX_SHAREDIRQS; u++ ) {
126 if( pSlot->irqHandlers[u].x2 == userdata ) {
127 pSlot->flHandlers &= ~(1 << u);
128 if( pSlot->flHandlers == 0 ) {
129 rprintf(("free_irq: irq %d", irq & 0xff ));
130 ALSA_FreeIrq(pSlot->irqNo);
131 pSlot->irqNo = 0;
132 RMDeallocateIRQ(pSlot->hRes);
133 pSlot->hRes = NULL;
134 // pSlot->fEOI = 0;
135 }
136
137 pSlot->irqHandlers[u].handler = NULL;
138 pSlot->irqHandlers[u].x0 = 0;
139 pSlot->irqHandlers[u].x1 = NULL;
140 pSlot->irqHandlers[u].x2 = NULL;
141
142 return;
143
144 }
145 }
146 }
147}
148
149
150//******************************************************************************
151//******************************************************************************
152void eoi_irq(unsigned int irq)
153{
154 /*(void)irq; */
155 /*
156 IRQ_SLOT *pSlot = FindSlot(irq);
157
158 if( pSlot ) pSlot->fEOI = 1;
159 */
160 eoiIrq[irq & 0xff]++;
161}
162
163
164//******************************************************************************
165//******************************************************************************
166BOOL process_interrupt(ULONG ulSlotNo, ULONG *pulIrq)
167{
168 unsigned u;
169 int rc;
170 IRQ_SLOT *pSlot;
171
172 //dprintf(("enter int proc %d %d",ulSlotNo, *pulIrq));
173
174 if(fSuspended)
175 {//If our device is suspended, then we can't receive interrupts, so it must
176 //be for some other device
177 //Don't pass it to the linux handler as the device doesn't respond as expected
178 //when suspended
179 rprintf(("Slot %d IRQ %d suspended",ulSlotNo, *pulIrq));
180 return FALSE;
181 }
182
183 if( ulSlotNo < MAX_IRQ_SLOTS )
184 {
185 pSlot = &arSlots[ulSlotNo];
186
187 for( u = 0; u < MAX_SHAREDIRQS; u++ )
188 {
189 if(pSlot && pSlot->irqHandlers[u].handler )
190 {
191 fInInterrupt = TRUE;
192#if 0
193 rc = pSlot->irqHandlers[u].handler(pSlot->irqNo,
194 pSlot->irqHandlers[u].x2, 0);
195#else
196 rc = pSlot->irqHandlers[u].handler(pSlot->irqNo,
197 pSlot->irqHandlers[u].x2);
198#endif
199
200 // HDA Hardware generates controller interrupts and stream interrupts
201 // the uniaud16 driver only cares about stream interrupts.
202 // azx_interrupt in alsa-kernel/pci/hda/hda_intel.c will return rc 2 if
203 // the interrupt is from the controller. There is no need to call uniaud16
204 // for these interrupts
205 if ( rc == 2 ) {
206 fInInterrupt = FALSE;
207 *pulIrq = pSlot->irqNo;
208 eoiIrq[pSlot->irqNo] = 0;
209 return TRUE;
210 }
211
212 if (rc == 1) eoi_irq(pSlot->irqNo);
213 rc = (eoiIrq[pSlot->irqNo] > 0);
214 fInInterrupt = FALSE;
215
216 if( rc /*== 1 || pSlot->fEOI*/ ) {
217
218 *pulIrq = pSlot->irqNo;
219 // pSlot->fEOI = 0;
220
221 //ok, this interrupt was intended for us; notify the 16 bits MMPM/2 driver
222 OSS32_ProcessIRQ();
223 //dprintf(("exit(1) int proc %d %d",ulSlotNo, *pulIrq));
224 eoiIrq[pSlot->irqNo] = 0;
225 return TRUE;
226 }
227 }
228 }
229 }
230 //dprintf(("exit(0) int proc %d %d",ulSlotNo, *pulIrq));
231
232 return FALSE;
233}
234
235
236//******************************************************************************
237//******************************************************************************
238int in_interrupt()
239{
240 return fInInterrupt;
241}
242
243
244//******************************************************************************
245//******************************************************************************
246void disable_irq(int irq)
247{
248 dprintf(("disable_irq %d NOT implemented", irq));
249}
250
251//******************************************************************************
252//******************************************************************************
253
Note: See TracBrowser for help on using the repository browser.