1/*
2 * Copyright (c) 2007-2012 Apple Inc. All rights reserved.
3 * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
4 *
5 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
6 *
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. The rights granted to you under the License
11 * may not be used to create, or enable the creation or redistribution of,
12 * unlawful or unlicensed copies of an Apple operating system, or to
13 * circumvent, violate, or enable the circumvention or violation of, any
14 * terms of an Apple operating system software license agreement.
15 *
16 * Please obtain a copy of the License at
17 * http://www.opensource.apple.com/apsl/ and read it before using this file.
18 *
19 * The Original Code and all software distributed under the License are
20 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
21 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
22 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
24 * Please see the License for the specific language governing rights and
25 * limitations under the License.
26 *
27 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
28 */
29
30#include <IOKit/IOLib.h>
31#include <IOKit/IOService.h>
32#include <IOKit/IOPlatformExpert.h>
33#include <IOKit/IODeviceTreeSupport.h>
34#include <IOKit/IOInterrupts.h>
35#include <IOKit/IOInterruptController.h>
36#include <IOKit/IOKitDebug.h>
37#include <IOKit/IOTimeStamp.h>
38
39
40/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
41
42#define super IOService
43
44OSDefineMetaClassAndAbstractStructors(IOInterruptController, IOService);
45
46OSMetaClassDefineReservedUnused(IOInterruptController, 0);
47OSMetaClassDefineReservedUnused(IOInterruptController, 1);
48OSMetaClassDefineReservedUnused(IOInterruptController, 2);
49OSMetaClassDefineReservedUnused(IOInterruptController, 3);
50OSMetaClassDefineReservedUnused(IOInterruptController, 4);
51OSMetaClassDefineReservedUnused(IOInterruptController, 5);
52
53/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
54
55IOReturn IOInterruptController::registerInterrupt(IOService *nub, int source,
56 void *target,
57 IOInterruptHandler handler,
58 void *refCon)
59{
60 IOInterruptSource *interruptSources;
61 IOInterruptVectorNumber vectorNumber;
62 IOInterruptVector *vector;
63 int wasDisabledSoft;
64 IOReturn error;
65 OSData *vectorData;
66 IOOptionBits options;
67 bool canBeShared, shouldBeShared, wasAlreadyRegisterd;
68
69 IOService *originalNub = NULL; // Protected by wasAlreadyRegisterd
70 int originalSource = 0; // Protected by wasAlreadyRegisterd
71
72
73 interruptSources = nub->_interruptSources;
74 vectorData = interruptSources[source].vectorData;
75 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
76 vector = &vectors[vectorNumber];
77
78 // Get the lock for this vector.
79 IOLockLock(vector->interruptLock);
80
81 // Check if the interrupt source can/should be shared.
82 canBeShared = vectorCanBeShared(vectorNumber, vector);
83 IODTGetInterruptOptions(nub, source, &options);
84#if defined(__i386__) || defined(__x86_64__)
85 int interruptType;
86 if (OSDynamicCast(IOPlatformDevice, getProvider()) &&
87 (getInterruptType(nub, source, &interruptType) == kIOReturnSuccess) &&
88 (kIOInterruptTypeLevel & interruptType))
89 {
90 options |= kIODTInterruptShared;
91 }
92#endif
93 shouldBeShared = canBeShared && (options & kIODTInterruptShared);
94 wasAlreadyRegisterd = vector->interruptRegistered;
95
96 // If the vector is registered and can not be shared return error.
97 if (wasAlreadyRegisterd && !canBeShared) {
98 IOLockUnlock(vector->interruptLock);
99 return kIOReturnNoResources;
100 }
101
102 // If this vector is already in use, and can be shared (implied),
103 // or it is not registered and should be shared,
104 // register as a shared interrupt.
105 if (wasAlreadyRegisterd || shouldBeShared) {
106 // If this vector is not already shared, break it out.
107 if (vector->sharedController == 0) {
108 // Make the IOShareInterruptController instance
109 vector->sharedController = new IOSharedInterruptController;
110 if (vector->sharedController == 0) {
111 IOLockUnlock(vector->interruptLock);
112 return kIOReturnNoMemory;
113 }
114
115 if (wasAlreadyRegisterd) {
116 // Save the nub and source for the original consumer.
117 originalNub = vector->nub;
118 originalSource = vector->source;
119
120 // Physically disable the interrupt, but mark it as being enabled in the hardware.
121 // The interruptDisabledSoft now indicates the driver's request for enablement.
122 disableVectorHard(vectorNumber, vector);
123 vector->interruptDisabledHard = 0;
124 }
125
126 // Initialize the new shared interrupt controller.
127 error = vector->sharedController->initInterruptController(this, vectorData);
128 // If the IOSharedInterruptController could not be initalized,
129 // if needed, put the original consumer's interrupt back to normal and
130 // get rid of whats left of the shared controller.
131 if (error != kIOReturnSuccess) {
132 if (wasAlreadyRegisterd) enableInterrupt(originalNub, originalSource);
133 vector->sharedController->release();
134 vector->sharedController = 0;
135 IOLockUnlock(vector->interruptLock);
136 return error;
137 }
138
139 // If there was an original consumer try to register it on the shared controller.
140 if (wasAlreadyRegisterd) {
141 error = vector->sharedController->registerInterrupt(originalNub,
142 originalSource,
143 vector->target,
144 vector->handler,
145 vector->refCon);
146 // If the original consumer could not be moved to the shared controller,
147 // put the original consumor's interrupt back to normal and
148 // get rid of whats left of the shared controller.
149 if (error != kIOReturnSuccess) {
150 // Save the driver's interrupt enablement state.
151 wasDisabledSoft = vector->interruptDisabledSoft;
152
153 // Make the interrupt really hard disabled.
154 vector->interruptDisabledSoft = 1;
155 vector->interruptDisabledHard = 1;
156
157 // Enable the original consumer's interrupt if needed.
158 if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
159 enableInterrupt(originalNub, originalSource);
160
161 vector->sharedController->release();
162 vector->sharedController = 0;
163 IOLockUnlock(vector->interruptLock);
164 return error;
165 }
166 }
167
168 // Fill in vector with the shared controller's info.
169 vector->handler = (IOInterruptHandler)vector->sharedController->getInterruptHandlerAddress();
170 vector->nub = vector->sharedController;
171 vector->source = 0;
172 vector->target = vector->sharedController;
173 vector->refCon = 0;
174
175 // If the interrupt was already registered,
176 // save the driver's interrupt enablement state.
177 if (wasAlreadyRegisterd) wasDisabledSoft = vector->interruptDisabledSoft;
178 else wasDisabledSoft = true;
179
180 // Do any specific initalization for this vector if it has not yet been used.
181 if (!wasAlreadyRegisterd) initVector(vectorNumber, vector);
182
183 // Make the interrupt really hard disabled.
184 vector->interruptDisabledSoft = 1;
185 vector->interruptDisabledHard = 1;
186 vector->interruptRegistered = 1;
187
188 // Enable the original consumer's interrupt if needed.
189 // originalNub is protected by wasAlreadyRegisterd here (see line 184).
190 if (!wasDisabledSoft) originalNub->enableInterrupt(originalSource);
191 }
192
193 error = vector->sharedController->registerInterrupt(nub, source, target,
194 handler, refCon);
195 IOLockUnlock(vector->interruptLock);
196 return error;
197 }
198
199 // Fill in vector with the client's info.
200 vector->handler = handler;
201 vector->nub = nub;
202 vector->source = source;
203 vector->target = target;
204 vector->refCon = refCon;
205
206 // Do any specific initalization for this vector.
207 initVector(vectorNumber, vector);
208
209 // Get the vector ready. It starts hard disabled.
210 vector->interruptDisabledHard = 1;
211 vector->interruptDisabledSoft = 1;
212 vector->interruptRegistered = 1;
213
214 IOLockUnlock(vector->interruptLock);
215 return kIOReturnSuccess;
216}
217
218IOReturn IOInterruptController::unregisterInterrupt(IOService *nub, int source)
219{
220 IOInterruptSource *interruptSources;
221 IOInterruptVectorNumber vectorNumber;
222 IOInterruptVector *vector;
223 OSData *vectorData;
224
225 interruptSources = nub->_interruptSources;
226 vectorData = interruptSources[source].vectorData;
227 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
228 vector = &vectors[vectorNumber];
229
230 // Get the lock for this vector.
231 IOLockLock(vector->interruptLock);
232
233 // Return success if it is not already registered
234 if (!vector->interruptRegistered) {
235 IOLockUnlock(vector->interruptLock);
236 return kIOReturnSuccess;
237 }
238
239 // Soft disable the source.
240 disableInterrupt(nub, source);
241
242 // Turn the source off at hardware.
243 disableVectorHard(vectorNumber, vector);
244
245 // Clear all the storage for the vector except for interruptLock.
246 vector->interruptActive = 0;
247 vector->interruptDisabledSoft = 0;
248 vector->interruptDisabledHard = 0;
249 vector->interruptRegistered = 0;
250 vector->nub = 0;
251 vector->source = 0;
252 vector->handler = 0;
253 vector->target = 0;
254 vector->refCon = 0;
255
256 IOLockUnlock(vector->interruptLock);
257 return kIOReturnSuccess;
258}
259
260IOReturn IOInterruptController::getInterruptType(IOService *nub, int source,
261 int *interruptType)
262{
263 IOInterruptSource *interruptSources;
264 IOInterruptVectorNumber vectorNumber;
265 IOInterruptVector *vector;
266 OSData *vectorData;
267
268 if (interruptType == 0) return kIOReturnBadArgument;
269
270 interruptSources = nub->_interruptSources;
271 vectorData = interruptSources[source].vectorData;
272 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
273 vector = &vectors[vectorNumber];
274
275 *interruptType = getVectorType(vectorNumber, vector);
276
277 return kIOReturnSuccess;
278}
279
280IOReturn IOInterruptController::enableInterrupt(IOService *nub, int source)
281{
282 IOInterruptSource *interruptSources;
283 IOInterruptVectorNumber vectorNumber;
284 IOInterruptVector *vector;
285 OSData *vectorData;
286
287 interruptSources = nub->_interruptSources;
288 vectorData = interruptSources[source].vectorData;
289 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
290 vector = &vectors[vectorNumber];
291
292 if (vector->interruptDisabledSoft) {
293 vector->interruptDisabledSoft = 0;
294#if !defined(__i386__) && !defined(__x86_64__)
295 OSMemoryBarrier();
296#endif
297
298 if (!getPlatform()->atInterruptLevel()) {
299 while (vector->interruptActive)
300 {}
301 }
302 if (vector->interruptDisabledHard) {
303 vector->interruptDisabledHard = 0;
304
305 enableVector(vectorNumber, vector);
306 }
307 }
308
309 return kIOReturnSuccess;
310}
311
312IOReturn IOInterruptController::disableInterrupt(IOService *nub, int source)
313{
314 IOInterruptSource *interruptSources;
315 IOInterruptVectorNumber vectorNumber;
316 IOInterruptVector *vector;
317 OSData *vectorData;
318
319 interruptSources = nub->_interruptSources;
320 vectorData = interruptSources[source].vectorData;
321 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
322 vector = &vectors[vectorNumber];
323
324 vector->interruptDisabledSoft = 1;
325#if !defined(__i386__) && !defined(__x86_64__)
326 OSMemoryBarrier();
327#endif
328
329 if (!getPlatform()->atInterruptLevel()) {
330 while (vector->interruptActive)
331 {}
332 }
333
334 return kIOReturnSuccess;
335}
336
337IOReturn IOInterruptController::causeInterrupt(IOService *nub, int source)
338{
339 IOInterruptSource *interruptSources;
340 IOInterruptVectorNumber vectorNumber;
341 IOInterruptVector *vector;
342 OSData *vectorData;
343
344 interruptSources = nub->_interruptSources;
345 vectorData = interruptSources[source].vectorData;
346 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
347 vector = &vectors[vectorNumber];
348
349 causeVector(vectorNumber, vector);
350
351 return kIOReturnSuccess;
352}
353
354IOInterruptAction IOInterruptController::getInterruptHandlerAddress(void)
355{
356 return 0;
357}
358
359IOReturn IOInterruptController::handleInterrupt(void *refCon, IOService *nub,
360 int source)
361{
362 return kIOReturnInvalid;
363}
364
365
366// Methods to be overridden for simplifed interrupt controller subclasses.
367
368bool IOInterruptController::vectorCanBeShared(IOInterruptVectorNumber /*vectorNumber*/,
369 IOInterruptVector */*vector*/)
370{
371 return false;
372}
373
374void IOInterruptController::initVector(IOInterruptVectorNumber /*vectorNumber*/,
375 IOInterruptVector */*vector*/)
376{
377}
378
379int IOInterruptController::getVectorType(IOInterruptVectorNumber /*vectorNumber*/,
380 IOInterruptVector */*vector*/)
381{
382 return kIOInterruptTypeEdge;
383}
384
385void IOInterruptController::disableVectorHard(IOInterruptVectorNumber /*vectorNumber*/,
386 IOInterruptVector */*vector*/)
387{
388}
389
390void IOInterruptController::enableVector(IOInterruptVectorNumber /*vectorNumber*/,
391 IOInterruptVector */*vector*/)
392{
393}
394
395void IOInterruptController::causeVector(IOInterruptVectorNumber /*vectorNumber*/,
396 IOInterruptVector */*vector*/)
397{
398}
399
400void IOInterruptController::timeStampSpuriousInterrupt(void)
401{
402 uint64_t providerID = 0;
403 IOService * provider = getProvider();
404
405 if (provider) {
406 providerID = provider->getRegistryEntryID();
407 }
408
409 IOTimeStampConstant(IODBG_INTC(IOINTC_SPURIOUS), providerID);
410}
411
412void IOInterruptController::timeStampInterruptHandlerInternal(bool isStart, IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
413{
414 uint64_t providerID = 0;
415 vm_offset_t unslidHandler = 0;
416 vm_offset_t unslidTarget = 0;
417
418 IOService * provider = getProvider();
419
420 if (provider) {
421 providerID = provider->getRegistryEntryID();
422 }
423
424 if (vector) {
425 unslidHandler = VM_KERNEL_UNSLIDE((vm_offset_t)vector->handler);
426 unslidTarget = VM_KERNEL_UNSLIDE_OR_PERM((vm_offset_t)vector->target);
427 }
428
429
430 if (isStart) {
431 IOTimeStampStartConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler,
432 (uintptr_t)unslidTarget, (uintptr_t)providerID);
433 } else {
434 IOTimeStampEndConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler,
435 (uintptr_t)unslidTarget, (uintptr_t)providerID);
436 }
437}
438
439void IOInterruptController::timeStampInterruptHandlerStart(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
440{
441 timeStampInterruptHandlerInternal(true, vectorNumber, vector);
442}
443
444void IOInterruptController::timeStampInterruptHandlerEnd(IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector)
445{
446 timeStampInterruptHandlerInternal(false, vectorNumber, vector);
447}
448
449/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
450
451#undef super
452#define super IOInterruptController
453
454OSDefineMetaClassAndStructors(IOSharedInterruptController, IOInterruptController);
455
456OSMetaClassDefineReservedUnused(IOSharedInterruptController, 0);
457OSMetaClassDefineReservedUnused(IOSharedInterruptController, 1);
458OSMetaClassDefineReservedUnused(IOSharedInterruptController, 2);
459OSMetaClassDefineReservedUnused(IOSharedInterruptController, 3);
460
461/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
462
463#define kIOSharedInterruptControllerDefaultVectors (128)
464
465IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
466{
467 int cnt, interruptType;
468 IOReturn error;
469
470 if (!super::init())
471 return kIOReturnNoResources;
472
473 // Set provider to this so enable/disable nub stuff works.
474 provider = this;
475
476 // Allocate the IOInterruptSource so this can act like a nub.
477 _interruptSources = (IOInterruptSource *)IOMalloc(sizeof(IOInterruptSource));
478 if (_interruptSources == 0) return kIOReturnNoMemory;
479 _numInterruptSources = 1;
480
481 // Set up the IOInterruptSource to point at this.
482 parentController->retain();
483 parentSource->retain();
484 _interruptSources[0].interruptController = parentController;
485 _interruptSources[0].vectorData = parentSource;
486
487 sourceIsLevel = false;
488 error = provider->getInterruptType(0, &interruptType);
489 if (error == kIOReturnSuccess) {
490 if (interruptType & kIOInterruptTypeLevel)
491 sourceIsLevel = true;
492 }
493
494 // Allocate the memory for the vectors
495 numVectors = kIOSharedInterruptControllerDefaultVectors; // For now a constant number.
496 vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector));
497 if (vectors == NULL) {
498 IOFree(_interruptSources, sizeof(IOInterruptSource));
499 return kIOReturnNoMemory;
500 }
501 bzero(vectors, numVectors * sizeof(IOInterruptVector));
502
503 // Allocate the lock for the controller.
504 controllerLock = IOSimpleLockAlloc();
505 if (controllerLock == 0) return kIOReturnNoResources;
506
507 // Allocate locks for the vectors.
508 for (cnt = 0; cnt < numVectors; cnt++) {
509 vectors[cnt].interruptLock = IOLockAlloc();
510 if (vectors[cnt].interruptLock == NULL) {
511 for (cnt = 0; cnt < numVectors; cnt++) {
512 if (vectors[cnt].interruptLock != NULL)
513 IOLockFree(vectors[cnt].interruptLock);
514 }
515 return kIOReturnNoResources;
516 }
517 }
518
519 numVectors = 0; // reset the high water mark for used vectors
520 vectorsRegistered = 0;
521 vectorsEnabled = 0;
522 controllerDisabled = 1;
523
524 return kIOReturnSuccess;
525}
526
527IOReturn IOSharedInterruptController::registerInterrupt(IOService *nub,
528 int source,
529 void *target,
530 IOInterruptHandler handler,
531 void *refCon)
532{
533 IOInterruptSource *interruptSources;
534 IOInterruptVectorNumber vectorNumber;
535 IOInterruptVector *vector = 0;
536 OSData *vectorData;
537 IOInterruptState interruptState;
538
539 interruptSources = nub->_interruptSources;
540
541 // Find a free vector.
542 vectorNumber = kIOSharedInterruptControllerDefaultVectors;
543 while (vectorsRegistered != kIOSharedInterruptControllerDefaultVectors) {
544 for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
545 vector = &vectors[vectorNumber];
546
547 // Get the lock for this vector.
548 IOLockLock(vector->interruptLock);
549
550 // Is it unregistered?
551 if (!vector->interruptRegistered) break;
552
553 // Move along to the next one.
554 IOLockUnlock(vector->interruptLock);
555 }
556
557 if (vectorNumber != kIOSharedInterruptControllerDefaultVectors) break;
558 }
559
560 // Could not find a free one, so give up.
561 if (vectorNumber == kIOSharedInterruptControllerDefaultVectors) {
562 return kIOReturnNoResources;
563 }
564
565 // Create the vectorData for the IOInterruptSource.
566 vectorData = OSData::withBytes(&vectorNumber, sizeof(vectorNumber));
567 if (vectorData == 0) {
568 IOLockUnlock(vector->interruptLock);
569 return kIOReturnNoMemory;
570 }
571
572 // Fill in the IOInterruptSource with the controller's info.
573 interruptSources[source].interruptController = this;
574 interruptSources[source].vectorData = vectorData;
575
576 // Fill in vector with the client's info.
577 vector->handler = handler;
578 vector->nub = nub;
579 vector->source = source;
580 vector->target = target;
581 vector->refCon = refCon;
582
583 // Get the vector ready. It starts off soft disabled.
584 vector->interruptDisabledSoft = 1;
585 vector->interruptRegistered = 1;
586
587 interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
588 // Move the high water mark if needed
589 if (++vectorsRegistered > numVectors) numVectors = vectorsRegistered;
590 IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
591
592 IOLockUnlock(vector->interruptLock);
593 return kIOReturnSuccess;
594}
595
596IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
597 int source)
598{
599 IOInterruptVectorNumber vectorNumber;
600 IOInterruptVector *vector;
601 IOInterruptState interruptState;
602
603 for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
604 vector = &vectors[vectorNumber];
605
606 // Get the lock for this vector.
607 IOLockLock(vector->interruptLock);
608
609 // Return success if it is not already registered
610 if (!vector->interruptRegistered
611 || (vector->nub != nub) || (vector->source != source)) {
612 IOLockUnlock(vector->interruptLock);
613 continue;
614 }
615
616 // Soft disable the source and the controller too.
617 disableInterrupt(nub, source);
618
619 // Clear all the storage for the vector except for interruptLock.
620 vector->interruptActive = 0;
621 vector->interruptDisabledSoft = 0;
622 vector->interruptDisabledHard = 0;
623 vector->interruptRegistered = 0;
624 vector->nub = 0;
625 vector->source = 0;
626 vector->handler = 0;
627 vector->target = 0;
628 vector->refCon = 0;
629
630 interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
631 vectorsRegistered--;
632 IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
633
634 // Move along to the next one.
635 IOLockUnlock(vector->interruptLock);
636 }
637
638 // Re-enable the controller if all vectors are enabled.
639 if (vectorsEnabled == vectorsRegistered) {
640 controllerDisabled = 0;
641 provider->enableInterrupt(0);
642 }
643
644 return kIOReturnSuccess;
645}
646
647IOReturn IOSharedInterruptController::getInterruptType(IOService */*nub*/,
648 int /*source*/,
649 int *interruptType)
650{
651 return provider->getInterruptType(0, interruptType);
652}
653
654IOReturn IOSharedInterruptController::enableInterrupt(IOService *nub,
655 int source)
656{
657 IOInterruptSource *interruptSources;
658 IOInterruptVectorNumber vectorNumber;
659 IOInterruptVector *vector;
660 OSData *vectorData;
661 IOInterruptState interruptState;
662
663 interruptSources = nub->_interruptSources;
664 vectorData = interruptSources[source].vectorData;
665 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
666 vector = &vectors[vectorNumber];
667
668 interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
669 if (!vector->interruptDisabledSoft) {
670 IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
671 return kIOReturnSuccess;
672 }
673
674 vector->interruptDisabledSoft = 0;
675 vectorsEnabled++;
676 IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
677
678 if (controllerDisabled && (vectorsEnabled == vectorsRegistered)) {
679 controllerDisabled = 0;
680 provider->enableInterrupt(0);
681 }
682
683 return kIOReturnSuccess;
684}
685
686IOReturn IOSharedInterruptController::disableInterrupt(IOService *nub,
687 int source)
688{
689 IOInterruptSource *interruptSources;
690 IOInterruptVectorNumber vectorNumber;
691 IOInterruptVector *vector;
692 OSData *vectorData;
693 IOInterruptState interruptState;
694
695 interruptSources = nub->_interruptSources;
696 vectorData = interruptSources[source].vectorData;
697 vectorNumber = *(IOInterruptVectorNumber *)vectorData->getBytesNoCopy();
698 vector = &vectors[vectorNumber];
699
700 interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
701 if (!vector->interruptDisabledSoft) {
702 vector->interruptDisabledSoft = 1;
703#if !defined(__i386__) && !defined(__x86_64__)
704 OSMemoryBarrier();
705#endif
706
707 vectorsEnabled--;
708 }
709 IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
710
711 if (!getPlatform()->atInterruptLevel()) {
712 while (vector->interruptActive)
713 {}
714 }
715
716 return kIOReturnSuccess;
717}
718
719IOInterruptAction IOSharedInterruptController::getInterruptHandlerAddress(void)
720{
721 return OSMemberFunctionCast(IOInterruptAction,
722 this, &IOSharedInterruptController::handleInterrupt);
723}
724
725IOReturn IOSharedInterruptController::handleInterrupt(void * /*refCon*/,
726 IOService * nub,
727 int /*source*/)
728{
729 IOInterruptVectorNumber vectorNumber;
730 IOInterruptVector *vector;
731
732 for (vectorNumber = 0; vectorNumber < numVectors; vectorNumber++) {
733 vector = &vectors[vectorNumber];
734
735 vector->interruptActive = 1;
736#if !defined(__i386__) && !defined(__x86_64__)
737 OSMemoryBarrier();
738#endif
739
740 if (!vector->interruptDisabledSoft) {
741
742 // Call the handler if it exists.
743 if (vector->interruptRegistered) {
744
745 bool trace = (gIOKitTrace & kIOTraceInterrupts) ? true : false;
746
747 if (trace)
748 timeStampInterruptHandlerStart(vectorNumber, vector);
749
750 // Call handler.
751 vector->handler(vector->target, vector->refCon, vector->nub, vector->source);
752
753 if (trace)
754 timeStampInterruptHandlerEnd(vectorNumber, vector);
755 }
756 }
757
758 vector->interruptActive = 0;
759 }
760
761 // if any of the vectors are dissabled, then dissable this controller.
762 IOSimpleLockLock(controllerLock);
763 if (vectorsEnabled != vectorsRegistered) {
764 nub->disableInterrupt(0);
765 controllerDisabled = 1;
766 }
767 IOSimpleLockUnlock(controllerLock);
768
769 return kIOReturnSuccess;
770}
771
772