1/*
2 * Copyright (c) 1998-2010 Apple 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/IOFilterInterruptEventSource.h>
32#include <IOKit/IOService.h>
33#include <IOKit/IOKitDebug.h>
34#include <IOKit/IOTimeStamp.h>
35#include <IOKit/IOWorkLoop.h>
36#include <IOKit/IOInterruptAccountingPrivate.h>
37#include <libkern/Block.h>
38
39#if IOKITSTATS
40
41#define IOStatisticsInitializeCounter() \
42do { \
43 IOStatistics::setCounterType(IOEventSource::reserved->counter, kIOStatisticsFilterInterruptEventSourceCounter); \
44} while (0)
45
46#define IOStatisticsInterrupt() \
47do { \
48 IOStatistics::countInterrupt(IOEventSource::reserved->counter); \
49} while (0)
50
51#else
52
53#define IOStatisticsInitializeCounter()
54#define IOStatisticsInterrupt()
55
56#endif /* IOKITSTATS */
57
58#define super IOInterruptEventSource
59
60OSDefineMetaClassAndStructors
61(IOFilterInterruptEventSource, IOInterruptEventSource)
62OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 0);
63OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 1);
64OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 2);
65OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 3);
66OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 4);
67OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 5);
68OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 6);
69OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 7);
70
71/*
72 * Implement the call throughs for the private protection conversion
73 */
74bool
75IOFilterInterruptEventSource::init(OSObject *inOwner,
76 Action inAction,
77 IOService *inProvider,
78 int inIntIndex)
79{
80 return false;
81}
82
83OSSharedPtr<IOInterruptEventSource>
84IOFilterInterruptEventSource::interruptEventSource(OSObject *inOwner,
85 Action inAction,
86 IOService *inProvider,
87 int inIntIndex)
88{
89 return NULL;
90}
91
92bool
93IOFilterInterruptEventSource::init(OSObject *inOwner,
94 Action inAction,
95 Filter inFilterAction,
96 IOService *inProvider,
97 int inIntIndex)
98{
99 if (!super::init(owner: inOwner, action: inAction, provider: inProvider, intIndex: inIntIndex)) {
100 return false;
101 }
102
103 if (!inFilterAction) {
104 return false;
105 }
106
107 filterAction = inFilterAction;
108
109 IOStatisticsInitializeCounter();
110
111 return true;
112}
113
114OSSharedPtr<IOFilterInterruptEventSource>
115IOFilterInterruptEventSource
116::filterInterruptEventSource(OSObject *inOwner,
117 Action inAction,
118 Filter inFilterAction,
119 IOService *inProvider,
120 int inIntIndex)
121{
122 OSSharedPtr<IOFilterInterruptEventSource> me = OSMakeShared<IOFilterInterruptEventSource>();
123
124 if (me
125 && !me->init(inOwner, inAction, inFilterAction, inProvider, inIntIndex)) {
126 return nullptr;
127 }
128
129 return me;
130}
131
132
133OSSharedPtr<IOFilterInterruptEventSource>
134IOFilterInterruptEventSource
135::filterInterruptEventSource(OSObject *inOwner,
136 IOService *inProvider,
137 int inIntIndex,
138 ActionBlock inAction,
139 FilterBlock inFilterAction)
140{
141 OSSharedPtr<IOFilterInterruptEventSource> me = OSMakeShared<IOFilterInterruptEventSource>();
142
143 FilterBlock filter = Block_copy(inFilterAction);
144 if (!filter) {
145 return nullptr;
146 }
147
148 if (me
149 && !me->init(inOwner, inAction: (Action) NULL, inFilterAction: (Filter) (void (*)(void))filter, inProvider, inIntIndex)) {
150 Block_release(filter);
151 return nullptr;
152 }
153 me->flags |= kFilterBlock;
154 me->setActionBlock((IOEventSource::ActionBlock) inAction);
155
156 return me;
157}
158
159
160void
161IOFilterInterruptEventSource::free( void )
162{
163 if ((kFilterBlock & flags) && filterActionBlock) {
164 Block_release(filterActionBlock);
165 }
166
167 super::free();
168}
169
170void
171IOFilterInterruptEventSource::signalInterrupt()
172{
173 bool trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
174
175 IOStatisticsInterrupt();
176 producerCount++;
177
178 if (trace) {
179 IOTimeStampStartConstant(IODBG_INTES(IOINTES_SEMA), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(owner));
180 }
181
182 signalWorkAvailable();
183
184 if (trace) {
185 IOTimeStampEndConstant(IODBG_INTES(IOINTES_SEMA), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(owner));
186 }
187}
188
189
190IOFilterInterruptEventSource::Filter
191IOFilterInterruptEventSource::getFilterAction() const
192{
193 if (kFilterBlock & flags) {
194 return NULL;
195 }
196 return filterAction;
197}
198
199IOFilterInterruptEventSource::FilterBlock
200IOFilterInterruptEventSource::getFilterActionBlock() const
201{
202 if (kFilterBlock & flags) {
203 return filterActionBlock;
204 }
205 return NULL;
206}
207
208void
209IOFilterInterruptEventSource::normalInterruptOccurred
210(void */*refcon*/, IOService */*prov*/, int /*source*/)
211{
212 bool filterRes;
213 uint64_t startTime = 0;
214 uint64_t endTime = 0;
215 bool trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
216
217 if (trace) {
218 IOTimeStampStartConstant(IODBG_INTES(IOINTES_FILTER),
219 VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
220 }
221
222 if (IOInterruptEventSource::reserved->statistics) {
223 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)
224 || IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
225 startTime = mach_absolute_time();
226 }
227 if (IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
228 IOInterruptEventSource::reserved->statistics->primaryTimestamp = startTime;
229 }
230 }
231
232 // Call the filter.
233 if (kFilterBlock & flags) {
234 filterRes = (filterActionBlock)(this);
235 } else {
236 filterRes = (*filterAction)(owner, this);
237 }
238
239 if (IOInterruptEventSource::reserved->statistics) {
240 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelCountIndex)) {
241 IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelCountIndex], 1);
242 }
243
244 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)) {
245 endTime = mach_absolute_time();
246 IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelTimeIndex], endTime - startTime);
247 }
248 }
249
250 if (trace) {
251 IOTimeStampEndConstant(IODBG_INTES(IOINTES_FILTER),
252 VM_KERNEL_ADDRHIDE(filterAction), VM_KERNEL_ADDRHIDE(owner),
253 VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
254 }
255
256 if (filterRes) {
257 signalInterrupt();
258 }
259}
260
261void
262IOFilterInterruptEventSource::disableInterruptOccurred
263(void */*refcon*/, IOService *prov, int source)
264{
265 bool filterRes;
266 uint64_t startTime = 0;
267 uint64_t endTime = 0;
268 bool trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
269
270 if (trace) {
271 IOTimeStampStartConstant(IODBG_INTES(IOINTES_FILTER),
272 VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
273 }
274
275 if (IOInterruptEventSource::reserved->statistics) {
276 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)
277 || IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
278 startTime = mach_absolute_time();
279 }
280 if (IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
281 IOInterruptEventSource::reserved->statistics->primaryTimestamp = startTime;
282 }
283 }
284
285 // Call the filter.
286 if (kFilterBlock & flags) {
287 filterRes = (filterActionBlock)(this);
288 } else {
289 filterRes = (*filterAction)(owner, this);
290 }
291
292 if (IOInterruptEventSource::reserved->statistics) {
293 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelCountIndex)) {
294 IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelCountIndex], 1);
295 }
296
297 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)) {
298 endTime = mach_absolute_time();
299 IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelTimeIndex], endTime - startTime);
300 }
301 }
302
303 if (trace) {
304 IOTimeStampEndConstant(IODBG_INTES(IOINTES_FILTER),
305 VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
306 }
307
308 if (filterRes) {
309 prov->disableInterrupt(source); /* disable the interrupt */
310 signalInterrupt();
311 }
312}
313