iokit/Kernel/IOInterruptController.cpp

61   IOInterruptVector *vector;
75   vector = &vectors[vectorNumber];
77   // Get the lock for this vector.
78   IOLockLock(vector->interruptLock);
81   canBeShared = vectorCanBeShared(vectorNumber, vector);
93   wasAlreadyRegisterd = vector->interruptRegistered;
95   // If the vector is registered and can not be shared return error.
97     IOLockUnlock(vector->interruptLock);
101   // If this vector is already in use, and can be shared (implied),
105     // If this vector is not already shared, break it out.
106     if (vector->sharedController == 0) {
108       vector->sharedController = new IOSharedInterruptController;
109       if (vector->sharedController == 0) {
110         IOLockUnlock(vector->interruptLock);
116 	originalNub = vector->nub;
117 	originalSource = vector->source;
121 	disableVectorHard(vectorNumber, vector);
122 	vector->interruptDisabledHard = 0;
126       error = vector->sharedController->initInterruptController(this, vectorData);
132         vector->sharedController->release();
133         vector->sharedController = 0;
134         IOLockUnlock(vector->interruptLock);
140 	error = vector->sharedController->registerInterrupt(originalNub,
142 							    vector->target,
143 							    vector->handler,
144 							    vector->refCon);
150 	  wasDisabledSoft = vector->interruptDisabledSoft;
153 	  vector->interruptDisabledSoft = 1;
154 	  vector->interruptDisabledHard = 1;
160 	  vector->sharedController->release();
161 	  vector->sharedController = 0;
162 	  IOLockUnlock(vector->interruptLock);
167       // Fill in vector with the shared controller's info.
168       vector->handler = (IOInterruptHandler)vector->sharedController->getInterruptHandlerAddress();
169       vector->nub     = vector->sharedController;
170       vector->source  = 0;
171       vector->target  = vector->sharedController;
172       vector->refCon  = 0;
176       if (wasAlreadyRegisterd) wasDisabledSoft = vector->interruptDisabledSoft;
179       // Do any specific initalization for this vector if it has not yet been used.
180       if (!wasAlreadyRegisterd) initVector(vectorNumber, vector);
183       vector->interruptDisabledSoft = 1;
184       vector->interruptDisabledHard = 1;
185       vector->interruptRegistered   = 1;
192     error = vector->sharedController->registerInterrupt(nub, source, target,
194     IOLockUnlock(vector->interruptLock);
198   // Fill in vector with the client's info.
199   vector->handler = handler;
200   vector->nub     = nub;
201   vector->source  = source;
202   vector->target  = target;
203   vector->refCon  = refCon;
205   // Do any specific initalization for this vector.
206   initVector(vectorNumber, vector);
208   // Get the vector ready.  It starts hard disabled.
209   vector->interruptDisabledHard = 1;
210   vector->interruptDisabledSoft = 1;
211   vector->interruptRegistered   = 1;
213   IOLockUnlock(vector->interruptLock);
221   IOInterruptVector *vector;
227   vector = &vectors[vectorNumber];
229   // Get the lock for this vector.
230   IOLockLock(vector->interruptLock);
233   if (!vector->interruptRegistered) {
234     IOLockUnlock(vector->interruptLock);
242   disableVectorHard(vectorNumber, vector);
244   // Clear all the storage for the vector except for interruptLock.
245   vector->interruptActive = 0;
246   vector->interruptDisabledSoft = 0;
247   vector->interruptDisabledHard = 0;
248   vector->interruptRegistered = 0;
249   vector->nub = 0;
250   vector->source = 0;
251   vector->handler = 0;
252   vector->target = 0;
253   vector->refCon = 0;
255   IOLockUnlock(vector->interruptLock);
264   IOInterruptVector *vector;
272   vector = &vectors[vectorNumber];
274   *interruptType = getVectorType(vectorNumber, vector);
283   IOInterruptVector *vector;
289   vector = &vectors[vectorNumber];
291   if (vector->interruptDisabledSoft) {
292     vector->interruptDisabledSoft = 0;
295       while (vector->interruptActive)
298     if (vector->interruptDisabledHard) {
299       vector->interruptDisabledHard = 0;
301       enableVector(vectorNumber, vector);
312   IOInterruptVector *vector;
318   vector = &vectors[vectorNumber];
320   vector->interruptDisabledSoft = 1;
323     while (vector->interruptActive)
334   IOInterruptVector *vector;
340   vector = &vectors[vectorNumber];
342   causeVector(vectorNumber, vector);
362 					      IOInterruptVector */*vector*/)
368 				       IOInterruptVector */*vector*/)
373 					  IOInterruptVector */*vector*/)
379 					      IOInterruptVector */*vector*/)
384 					 IOInterruptVector */*vector*/)
389 					IOInterruptVector */*vector*/)
480   IOInterruptVector *vector = 0;
486   // Find a free vector.
490       vector = &vectors[vectorNumber];
492       // Get the lock for this vector.
493       IOLockLock(vector->interruptLock);
496       if (!vector->interruptRegistered) break;
499       IOLockUnlock(vector->interruptLock);
520   // Fill in vector with the client's info.
521   vector->handler = handler;
522   vector->nub     = nub;
523   vector->source  = source;
524   vector->target  = target;
525   vector->refCon  = refCon;
527   // Get the vector ready.  It starts off soft disabled.
528   vector->interruptDisabledSoft = 1;
529   vector->interruptRegistered   = 1;
536   IOLockUnlock(vector->interruptLock);
544   IOInterruptVector *vector;
548     vector = &vectors[vectorNumber];
550     // Get the lock for this vector.
551     IOLockLock(vector->interruptLock);
554     if (!vector->interruptRegistered
555      || (vector->nub != nub) || (vector->source != source)) {
556         IOLockUnlock(vector->interruptLock);
563     // Clear all the storage for the vector except for interruptLock.
564     vector->interruptActive = 0;
565     vector->interruptDisabledSoft = 0;
566     vector->interruptDisabledHard = 0;
567     vector->interruptRegistered = 0;
568     vector->nub = 0;
569     vector->source = 0;
570     vector->handler = 0;
571     vector->target = 0;
572     vector->refCon = 0;
579     IOLockUnlock(vector->interruptLock);
603   IOInterruptVector *vector;
610   vector = &vectors[vectorNumber];
613   if (!vector->interruptDisabledSoft) {
618   vector->interruptDisabledSoft = 0;
635   IOInterruptVector *vector;
642   vector = &vectors[vectorNumber];
645   if (!vector->interruptDisabledSoft) {
646     vector->interruptDisabledSoft = 1;
652     while (vector->interruptActive)
670   IOInterruptVector *vector;
673     vector = &vectors[vectorNumber];
675     vector->interruptActive = 1;
676 	if (!vector->interruptDisabledSoft) {
679 	  if (vector->interruptRegistered) {
685 									   (uintptr_t) vectorNumber, (uintptr_t) vector->handler, (uintptr_t)vector->target);
688 		  vector->handler(vector->target, vector->refCon, vector->nub, vector->source);
692 									 (uintptr_t) vectorNumber, (uintptr_t) vector->handler, (uintptr_t)vector->target);
697     vector->interruptActive = 0;