1 /*
2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
30 *
31 * DRI: Josh de Cesare
32 */
33
34 #include <IOKit/IOPlatformExpert.h>
35
36 #include "GenericInterruptController.h"
37
38 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
39
40 #undef super
41 #define super IOInterruptController
42
43 IODefineMetaClassAndStructors(GenericInterruptController,
44 IOInterruptController);
45
46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
47
48
49 bool
start(IOService * provider)50 GenericInterruptController::start(IOService *provider)
51 {
52 IOInterruptAction handler;
53 IOSymbol *interruptControllerName;
54
55 // If needed call the parents start.
56 if (!super::start(provider)) {
57 return false;
58 }
59
60 // Map the device's memory and initalize its state.
61
62 // For now you must allocate storage for the vectors.
63 // This will probably changed to something like: initVectors(numVectors).
64 // In the mean time something like this works well.
65 #if 0
66 // Allocate the memory for the vectors.
67 vectors = (IOInterruptVector *)IOMalloc(numVectors *
68 sizeof(IOInterruptVector));
69 if (vectors == NULL) {
70 return false;
71 }
72 bzero(vectors, numVectors * sizeof(IOInterruptVector));
73
74 // Allocate locks for the vectors.
75 for (cnt = 0; cnt < numVectors; cnt++) {
76 vectors[cnt].interruptLock = IOLockAlloc();
77 if (vectors[cnt].interruptLock == NULL) {
78 for (cnt = 0; cnt < numVectors; cnt++) {
79 if (vectors[cnt].interruptLock != NULL) {
80 IOLockFree(vectors[cnt].interruptLock);
81 }
82 }
83 }
84 }
85 #endif
86
87 // If you know that this interrupt controller is the primary
88 // interrupt controller, use this to set it nub properties properly.
89 // This may be done by the nub's creator.
90 getPlatform()->setCPUInterruptProperties(provider);
91
92 // register the interrupt handler so it can receive interrupts.
93 handler = getInterruptHandlerAddress();
94 provider->registerInterrupt(0, this, handler, 0);
95
96 // Just like any interrupt source, you must enable it to receive interrupts.
97 provider->enableInterrupt(0);
98
99 // Set interruptControllerName to the proper symbol.
100 //interruptControllerName = xxx;
101
102 // Register this interrupt controller so clients can find it.
103 getPlatform()->registerInterruptController(interruptControllerName, this);
104
105 // All done, so return true.
106 return true;
107 }
108
109 IOReturn
getInterruptType(IOService * nub,int source,int * interruptType)110 GenericInterruptController::getInterruptType(IOService *nub,
111 int source,
112 int *interruptType)
113 {
114 if (interruptType == 0) {
115 return kIOReturnBadArgument;
116 }
117
118 // Given the nub and source, set interruptType to level or edge.
119
120 return kIOReturnSuccess;
121 }
122
123 // Sadly this just has to be replicated in every interrupt controller.
124 IOInterruptAction
getInterruptHandlerAddress(void)125 GenericInterruptController::getInterruptHandlerAddress(void)
126 {
127 return (IOInterruptAction)handleInterrupt;
128 }
129
130 // Handle all current interrupts.
131 IOReturn
handleInterrupt(void * refCon,IOService * nub,int source)132 GenericInterruptController::handleInterrupt(void * refCon,
133 IOService * nub,
134 int source)
135 {
136 IOInterruptVector *vector;
137 int vectorNumber;
138
139 while (1) {
140 // Get vectorNumber from hardware some how and clear the event.
141
142 // Break if there are no more vectors to handle.
143 if (vectorNumber == 0 /*kNoVector*/) {
144 break;
145 }
146
147 // Get the vector's date from the controller's array.
148 vector = &vectors[vectorNumber];
149
150 // Set the vector as active. This store must compleat before
151 // moving on to prevent the disableInterrupt fuction from
152 // geting out of sync.
153 vector->interruptActive = 1;
154 //sync();
155 //isync();
156
157 // If the vector is not disabled soft, handle it.
158 if (!vector->interruptDisabledSoft) {
159 // Prevent speculative exacution as needed on your processor.
160 //isync();
161
162 // Call the handler if it exists.
163 if (vector->interruptRegistered) {
164 vector->handler(vector->target, vector->refCon,
165 vector->nub, vector->source);
166 }
167 } else {
168 // Hard disable the vector if is was only soft disabled.
169 vector->interruptDisabledHard = 1;
170 disableVectorHard(vectorNumber, vector);
171 }
172
173 // Done with this vector so, set it back to inactive.
174 vector->interruptActive = 0;
175 }
176
177 return kIOReturnSuccess;
178 }
179
180 bool
vectorCanBeShared(long vectorNumber,IOInterruptVector * vector)181 GenericInterruptController::vectorCanBeShared(long vectorNumber,
182 IOInterruptVector *vector)
183 {
184 // Given the vector number and the vector data, return if it can be shared.
185 return true;
186 }
187
188 void
initVector(long vectorNumber,IOInterruptVector * vector)189 GenericInterruptController::initVector(long vectorNumber,
190 IOInterruptVector *vector)
191 {
192 // Given the vector number and the vector data,
193 // get the hardware ready for the vector to generate interrupts.
194 // Make sure the vector is left disabled.
195 }
196
197 void
disableVectorHard(long vectorNumber,IOInterruptVector * vector)198 GenericInterruptController::disableVectorHard(long vectorNumber,
199 IOInterruptVector *vector)
200 {
201 // Given the vector number and the vector data,
202 // disable the vector at the hardware.
203 }
204
205 void
enableVector(long vectorNumber,IOInterruptVector * vector)206 GenericInterruptController::enableVector(long vectorNumber,
207 IOInterruptVector *vector)
208 {
209 // Given the vector number and the vector data,
210 // enable the vector at the hardware.
211 }
212
213 void
causeVector(long vectorNumber,IOInterruptVector * vector)214 GenericInterruptController::causeVector(long vectorNumber,
215 IOInterruptVector *vector)
216 {
217 // Given the vector number and the vector data,
218 // Set the vector pending and cause an interrupt at the parent controller.
219
220 // cause the interrupt at the parent controller. Source is usually zero,
221 // but it could be different for your controller.
222 getPlatform()->causeInterrupt(0);
223 }
224