iokit/Examples/drvGenericInterruptController/GenericInterruptController.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) 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
  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
 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
 125 GenericInterruptController::getInterruptHandlerAddress(void)
 126 {
 127         return (IOInterruptAction)handleInterrupt;
 128 }
 129
 130 // Handle all current interrupts.
 131 IOReturn
 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
 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
 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
 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
 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
 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 }