iokit/Kernel/IODMAEventSource.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 #define IOKIT_ENABLE_SHARED_PTR
  30
  31 #include <IOKit/IODMAEventSource.h>
  32 #include <IOKit/IOService.h>
  33
  34 #include "IOKitKernelInternal.h"
  35
  36
  37 #define super IOEventSource
  38 OSDefineMetaClassAndStructors(IODMAEventSource, IOEventSource);
  39
  40 bool
  41 IODMAEventSource::init(OSObject *inOwner,
  42     IOService *inProvider,
  43     Action inCompletion,
  44     Action inNotification,
  45     UInt32 inDMAIndex)
  46 {
  47         IOReturn result;
  48
  49         if (!super::init(inOwner)) {
  50                 return false;
  51         }
  52
  53         if (inProvider == NULL) {
  54                 return false;
  55         }
  56
  57         dmaProvider = inProvider;
  58         dmaIndex = 0xFFFFFFFF;
  59         dmaCompletionAction = inCompletion;
  60         dmaNotificationAction = inNotification;
  61
  62         dmaController.reset(IODMAController::getController(dmaProvider, inDMAIndex), OSRetain);
  63         if (dmaController == NULL) {
  64                 return false;
  65         }
  66
  67         result = dmaController->initDMAChannel(dmaProvider, this, &dmaIndex, inDMAIndex);
  68         if (result != kIOReturnSuccess) {
  69                 return false;
  70         }
  71
  72         queue_init(&dmaCommandsCompleted);
  73         dmaCommandsCompletedLock = IOSimpleLockAlloc();
  74
  75         return true;
  76 }
  77
  78 void
  79 IODMAEventSource::free()
  80 {
  81         if (dmaCommandsCompletedLock != NULL) {
  82                 IOSimpleLockFree(dmaCommandsCompletedLock);
  83         }
  84         super::free();
  85 }
  86
  87 OSSharedPtr<IODMAEventSource>
  88 IODMAEventSource::dmaEventSource(OSObject *inOwner,
  89     IOService *inProvider,
  90     Action inCompletion,
  91     Action inNotification,
  92     UInt32 inDMAIndex)
  93 {
  94         OSSharedPtr<IODMAEventSource> dmaES = OSMakeShared<IODMAEventSource>();
  95
  96         if (dmaES && !dmaES->init(inOwner, inProvider, inCompletion, inNotification, inDMAIndex)) {
  97                 return nullptr;
  98         }
  99
 100         return dmaES;
 101 }
 102
 103 IOReturn
 104 IODMAEventSource::startDMACommand(IODMACommand *dmaCommand, IODirection direction, IOByteCount byteCount, IOByteCount byteOffset)
 105 {
 106         IOReturn result;
 107
 108         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 109                 return kIOReturnError;
 110         }
 111
 112         if (dmaSynchBusy) {
 113                 return kIOReturnBusy;
 114         }
 115
 116         if (dmaCompletionAction == NULL) {
 117                 dmaSynchBusy = true;
 118         }
 119
 120         result = dmaController->startDMACommand(dmaIndex, dmaCommand, direction, byteCount, byteOffset);
 121
 122         if (result != kIOReturnSuccess) {
 123                 dmaSynchBusy = false;
 124                 return result;
 125         }
 126
 127         while (dmaSynchBusy) {
 128                 sleepGate(&dmaSynchBusy, THREAD_UNINT);
 129         }
 130
 131         return kIOReturnSuccess;
 132 }
 133
 134 IOReturn
 135 IODMAEventSource::stopDMACommand(bool flush, uint64_t timeout)
 136 {
 137         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 138                 return kIOReturnError;
 139         }
 140
 141         return dmaController->stopDMACommand(dmaIndex, flush, timeout);
 142 }
 143
 144
 145 IOReturn
 146 IODMAEventSource::queryDMACommand(IODMACommand **dmaCommand, IOByteCount *transferCount, bool waitForIdle)
 147 {
 148         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 149                 return kIOReturnError;
 150         }
 151
 152         return dmaController->queryDMACommand(dmaIndex, dmaCommand, transferCount, waitForIdle);
 153 }
 154
 155
 156 IOByteCount
 157 IODMAEventSource::getFIFODepth(IODirection direction)
 158 {
 159         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 160                 return 0;
 161         }
 162
 163         return dmaController->getFIFODepth(dmaIndex, direction);
 164 }
 165
 166
 167 IOReturn
 168 IODMAEventSource::setFIFODepth(IOByteCount depth)
 169 {
 170         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 171                 return kIOReturnError;
 172         }
 173
 174         return dmaController->setFIFODepth(dmaIndex, depth);
 175 }
 176
 177
 178 IOByteCount
 179 IODMAEventSource::validFIFODepth(IOByteCount depth, IODirection direction)
 180 {
 181         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 182                 return kIOReturnError;
 183         }
 184
 185         return dmaController->validFIFODepth(dmaIndex, depth, direction);
 186 }
 187
 188
 189 IOReturn
 190 IODMAEventSource::setFrameSize(UInt8 byteCount)
 191 {
 192         if ((dmaController == NULL) || (dmaIndex == 0xFFFFFFFF)) {
 193                 return kIOReturnError;
 194         }
 195
 196         return dmaController->setFrameSize(dmaIndex, byteCount);
 197 }
 198
 199 // protected
 200
 201 bool
 202 IODMAEventSource::checkForWork(void)
 203 {
 204         IODMACommand     *dmaCommand = NULL;
 205         bool work, again;
 206
 207         IOSimpleLockLock(dmaCommandsCompletedLock);
 208         work = !queue_empty(&dmaCommandsCompleted);
 209         if (work) {
 210                 queue_remove_first(&dmaCommandsCompleted, dmaCommand, IODMACommand *, fCommandChain);
 211                 again = !queue_empty(&dmaCommandsCompleted);
 212         } else {
 213                 again = false;
 214         }
 215         IOSimpleLockUnlock(dmaCommandsCompletedLock);
 216
 217         if (work) {
 218                 (*dmaCompletionAction)(owner, this, dmaCommand, dmaCommand->reserved->fStatus, dmaCommand->reserved->fActualByteCount, dmaCommand->reserved->fTimeStamp);
 219         }
 220
 221         return again;
 222 }
 223
 224 void
 225 IODMAEventSource::completeDMACommand(IODMACommand *dmaCommand)
 226 {
 227         if (dmaCompletionAction != NULL) {
 228                 IOSimpleLockLock(dmaCommandsCompletedLock);
 229                 queue_enter(&dmaCommandsCompleted, dmaCommand, IODMACommand *, fCommandChain);
 230                 IOSimpleLockUnlock(dmaCommandsCompletedLock);
 231
 232                 signalWorkAvailable();
 233         } else {
 234                 dmaSynchBusy = false;
 235                 wakeupGate(&dmaSynchBusy, true);
 236         }
 237 }
 238
 239 void
 240 IODMAEventSource::notifyDMACommand(IODMACommand *dmaCommand, IOReturn status, IOByteCount actualByteCount, AbsoluteTime timeStamp)
 241 {
 242         dmaCommand->reserved->fStatus = status;
 243         dmaCommand->reserved->fActualByteCount = actualByteCount;
 244         dmaCommand->reserved->fTimeStamp = timeStamp;
 245
 246         if (dmaNotificationAction != NULL) {
 247                 (*dmaNotificationAction)(owner, this, dmaCommand, status, actualByteCount, timeStamp);
 248         }
 249 }
 250
 251 IOReturn
 252 IODMAEventSource::setDMAConfig(UInt32 newReqIndex)
 253 {
 254         return dmaController->setDMAConfig(dmaIndex, dmaProvider, newReqIndex);
 255 }
 256
 257 bool
 258 IODMAEventSource::validDMAConfig(UInt32 newReqIndex)
 259 {
 260         return dmaController->validDMAConfig(dmaIndex, dmaProvider, newReqIndex);
 261 }