iokit/Kernel/IOInterruptEventSource.cpp

   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) 1998 Apple Computer, Inc.  All rights reserved.
  30
  31 HISTORY
  32     1998-7-13   Godfrey van der Linden(gvdl)
  33         Created.
  34 */
  35 #include <IOKit/IOInterruptEventSource.h>
  36 #include <IOKit/IOLib.h>
  37 #include <IOKit/IOService.h>
  38 #include <IOKit/IOInterrupts.h>
  39 #include <IOKit/IOTimeStamp.h>
  40 #include <IOKit/IOWorkLoop.h>
  41
  42 #if KDEBUG
  43
  44 #define IOTimeTypeStampS(t)                                             \
  45 do {                                                                    \
  46     IOTimeStampStart(IODBG_INTES(t),                                    \
  47                      (unsigned int) this, (unsigned int) owner);        \
  48 } while(0)
  49
  50 #define IOTimeTypeStampE(t)                                             \
  51 do {                                                                    \
  52     IOTimeStampEnd(IODBG_INTES(t),                                      \
  53                    (unsigned int) this, (unsigned int) owner);          \
  54 } while(0)
  55
  56 #define IOTimeStampLatency()                                            \
  57 do {                                                                    \
  58     IOTimeStampEnd(IODBG_INTES(IOINTES_LAT),                            \
  59                    (unsigned int) this, (unsigned int) owner);          \
  60 } while(0)
  61
  62 #else /* !KDEBUG */
  63 #define IOTimeTypeStampS(t)
  64 #define IOTimeTypeStampE(t)
  65 #define IOTimeStampLatency()
  66 #endif /* KDEBUG */
  67
  68 #define super IOEventSource
  69
  70 OSDefineMetaClassAndStructors(IOInterruptEventSource, IOEventSource)
  71 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 0);
  72 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 1);
  73 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 2);
  74 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 3);
  75 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 4);
  76 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 5);
  77 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 6);
  78 OSMetaClassDefineReservedUnused(IOInterruptEventSource, 7);
  79
  80 bool IOInterruptEventSource::init(OSObject *inOwner,
  81                                   Action inAction,
  82                                   IOService *inProvider,
  83                                   int inIntIndex)
  84 {
  85     bool res = true;
  86
  87     if ( !super::init(inOwner, (IOEventSourceAction) inAction) )
  88         return false;
  89
  90     provider = inProvider;
  91     producerCount = consumerCount = 0;
  92     autoDisable = explicitDisable = false;
  93     intIndex = -1;
  94
  95     // Assumes inOwner holds a reference(retain) on the provider
  96     if (inProvider) {
  97         int intType;
  98
  99         res = (kIOReturnSuccess
 100                     == inProvider->getInterruptType(inIntIndex, &intType));
 101         if (res) {
 102             IOInterruptAction intHandler;
 103
 104             autoDisable = (intType == kIOInterruptTypeLevel);
 105             if (autoDisable) {
 106                 intHandler = OSMemberFunctionCast(IOInterruptAction,
 107                     this, &IOInterruptEventSource::disableInterruptOccurred);
 108             }
 109             else
 110                 intHandler = OSMemberFunctionCast(IOInterruptAction,
 111                     this, &IOInterruptEventSource::normalInterruptOccurred);
 112
 113             res = (kIOReturnSuccess == inProvider->registerInterrupt
 114                                         (inIntIndex, this, intHandler));
 115             if (res)
 116                 intIndex = inIntIndex;
 117         }
 118     }
 119
 120     return res;
 121 }
 122
 123 IOInterruptEventSource *
 124 IOInterruptEventSource::interruptEventSource(OSObject *inOwner,
 125                                              Action inAction,
 126                                              IOService *inProvider,
 127                                              int inIntIndex)
 128 {
 129     IOInterruptEventSource *me = new IOInterruptEventSource;
 130
 131     if (me && !me->init(inOwner, inAction, inProvider, inIntIndex)) {
 132         me->release();
 133         return 0;
 134     }
 135
 136     return me;
 137 }
 138
 139 void IOInterruptEventSource::free()
 140 {
 141     if (provider && intIndex != -1)
 142         provider->unregisterInterrupt(intIndex);
 143
 144     super::free();
 145 }
 146
 147 void IOInterruptEventSource::enable()
 148 {
 149     if (provider && intIndex != -1) {
 150         provider->enableInterrupt(intIndex);
 151         explicitDisable = false;
 152     }
 153 }
 154
 155 void IOInterruptEventSource::disable()
 156 {
 157     if (provider && intIndex != -1) {
 158         provider->disableInterrupt(intIndex);
 159         explicitDisable = true;
 160     }
 161 }
 162
 163 const IOService *IOInterruptEventSource::getProvider() const
 164 {
 165     return provider;
 166 }
 167
 168 int IOInterruptEventSource::getIntIndex() const
 169 {
 170     return intIndex;
 171 }
 172
 173 bool IOInterruptEventSource::getAutoDisable() const
 174 {
 175     return autoDisable;
 176 }
 177
 178 bool IOInterruptEventSource::checkForWork()
 179 {
 180     unsigned int cacheProdCount = producerCount;
 181     int numInts = cacheProdCount - consumerCount;
 182     IOInterruptEventAction intAction = (IOInterruptEventAction) action;
 183
 184     if (numInts > 0) {
 185
 186         IOTimeStampLatency();
 187         IOTimeTypeStampS(IOINTES_CLIENT);
 188             IOTimeStampConstant(IODBG_INTES(IOINTES_ACTION),
 189                                 (unsigned int) intAction, (unsigned int) owner);
 190             (*intAction)(owner, this,  numInts);
 191         IOTimeTypeStampE(IOINTES_CLIENT);
 192
 193         consumerCount = cacheProdCount;
 194         if (autoDisable && !explicitDisable)
 195             enable();
 196     }
 197     else if (numInts < 0) {
 198         IOTimeStampLatency();
 199         IOTimeTypeStampS(IOINTES_CLIENT);
 200             IOTimeStampConstant(IODBG_INTES(IOINTES_ACTION),
 201                                 (unsigned int) intAction, (unsigned int) owner);
 202              (*intAction)(owner, this, -numInts);
 203         IOTimeTypeStampE(IOINTES_CLIENT);
 204
 205         consumerCount = cacheProdCount;
 206         if (autoDisable && !explicitDisable)
 207             enable();
 208     }
 209
 210     return false;
 211 }
 212
 213 void IOInterruptEventSource::normalInterruptOccurred
 214     (void */*refcon*/, IOService */*prov*/, int /*source*/)
 215 {
 216 IOTimeTypeStampS(IOINTES_INTCTXT);
 217 IOTimeStampLatency();
 218
 219     producerCount++;
 220
 221 IOTimeTypeStampS(IOINTES_SEMA);
 222     signalWorkAvailable();
 223 IOTimeTypeStampE(IOINTES_SEMA);
 224
 225 IOTimeTypeStampE(IOINTES_INTCTXT);
 226 }
 227
 228 void IOInterruptEventSource::disableInterruptOccurred
 229     (void */*refcon*/, IOService *prov, int source)
 230 {
 231 IOTimeTypeStampS(IOINTES_INTCTXT);
 232 IOTimeStampLatency();
 233
 234     prov->disableInterrupt(source);     /* disable the interrupt */
 235
 236     producerCount++;
 237
 238 IOTimeTypeStampS(IOINTES_SEMA);
 239     signalWorkAvailable();
 240 IOTimeTypeStampE(IOINTES_SEMA);
 241
 242 IOTimeTypeStampE(IOINTES_INTCTXT);
 243 }
 244
 245 void IOInterruptEventSource::interruptOccurred
 246     (void *refcon, IOService *prov, int source)
 247 {
 248     if (autoDisable && prov)
 249         disableInterruptOccurred(refcon, prov, source);
 250     else
 251         normalInterruptOccurred(refcon, prov, source);
 252 }