2 * Copyright (c) 1999-2000 Apple Computer, Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
29 * Copyright (c) 1999-2000 Apple Computer, Inc. All rights reserved.
36 #include <machine/machine_routines.h>
37 #include <pexpert/pexpert.h>
40 #include <machine/machine_routines.h>
42 #include <IOKit/IOLib.h>
43 #include <IOKit/IOPlatformExpert.h>
44 #include <IOKit/pwr_mgt/RootDomain.h>
45 #include <IOKit/IOUserClient.h>
46 #include <IOKit/IOKitKeysPrivate.h>
47 #include <IOKit/IOCPU.h>
49 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
50 #include <kern/queue.h>
52 typedef kern_return_t (*iocpu_platform_action_t
)(void * refcon0
, void * refcon1
, uint32_t priority
,
53 void * param1
, void * param2
, void * param3
);
55 struct iocpu_platform_action_entry
58 iocpu_platform_action_t action
;
62 struct iocpu_platform_action_entry
* alloc_list
;
64 typedef struct iocpu_platform_action_entry iocpu_platform_action_entry_t
;
67 iocpu_get_platform_quiesce_queue(void);
70 iocpu_get_platform_active_queue(void);
73 iocpu_platform_cpu_action_init(queue_head_t
* quiesce_queue
, queue_head_t
* init_queue
);
76 iocpu_add_platform_action(queue_head_t
* queue
, iocpu_platform_action_entry_t
* entry
);
79 iocpu_remove_platform_action(iocpu_platform_action_entry_t
* entry
);
82 iocpu_run_platform_actions(queue_head_t
* queue
, uint32_t first_priority
, uint32_t last_priority
,
83 void * param1
, void * param2
, void * param3
);
85 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
87 #define kBootCPUNumber 0
89 static iocpu_platform_action_entry_t
* gIOAllActionsQueue
;
90 static queue_head_t gIOSleepActionQueue
;
91 static queue_head_t gIOWakeActionQueue
;
93 static queue_head_t iocpu_quiesce_queue
;
94 static queue_head_t iocpu_active_queue
;
96 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
99 iocpu_platform_cpu_action_init(queue_head_t
* quiesce_queue
, __unused queue_head_t
* init_queue
)
102 enum { kNumQuiesceActions
= 2 };
103 static iocpu_platform_action_entry_t quiesce_actions
[kNumQuiesceActions
] =
105 { { NULL
, NULL
}, (iocpu_platform_action_t
) &clean_mmu_dcache
, 97000, 0, 0, NULL
},
106 { { NULL
, NULL
}, (iocpu_platform_action_t
) &arm_sleep
, 99000, 0, 0, NULL
},
110 for (idx
= 0; idx
< kNumQuiesceActions
; idx
++)
111 iocpu_add_platform_action(quiesce_queue
, &quiesce_actions
[idx
]);
115 queue_head_t
* iocpu_get_platform_quiesce_queue(void)
117 if (!iocpu_quiesce_queue
.next
)
119 queue_init(&iocpu_quiesce_queue
);
120 queue_init(&iocpu_active_queue
);
121 iocpu_platform_cpu_action_init(&iocpu_quiesce_queue
, &iocpu_active_queue
);
123 return (&iocpu_quiesce_queue
);
126 queue_head_t
* iocpu_get_platform_active_queue(void)
128 if (!iocpu_active_queue
.next
)
130 queue_init(&iocpu_quiesce_queue
);
131 queue_init(&iocpu_active_queue
);
132 iocpu_platform_cpu_action_init(&iocpu_quiesce_queue
, &iocpu_active_queue
);
134 return (&iocpu_active_queue
);
137 void iocpu_add_platform_action(queue_head_t
* queue
, iocpu_platform_action_entry_t
* entry
)
139 iocpu_platform_action_entry_t
* next
;
141 queue_iterate(queue
, next
, iocpu_platform_action_entry_t
*, link
)
143 if (next
->priority
> entry
->priority
)
145 queue_insert_before(queue
, entry
, next
, iocpu_platform_action_entry_t
*, link
);
149 queue_enter(queue
, entry
, iocpu_platform_action_entry_t
*, link
); // at tail
152 void iocpu_remove_platform_action(iocpu_platform_action_entry_t
* entry
)
154 remque(&entry
->link
);
158 iocpu_run_platform_actions(queue_head_t
* queue
, uint32_t first_priority
, uint32_t last_priority
,
159 void * param1
, void * param2
, void * param3
)
161 kern_return_t ret
= KERN_SUCCESS
;
162 kern_return_t result
= KERN_SUCCESS
;
163 iocpu_platform_action_entry_t
* next
;
165 queue_iterate(queue
, next
, iocpu_platform_action_entry_t
*, link
)
167 uint32_t pri
= (next
->priority
< 0) ? -next
->priority
: next
->priority
;
168 if ((pri
>= first_priority
) && (pri
<= last_priority
))
170 //kprintf("[%p]", next->action);
171 ret
= (*next
->action
)(next
->refcon0
, next
->refcon1
, pri
, param1
, param2
, param3
);
173 if (KERN_SUCCESS
== result
)
179 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
181 extern "C" kern_return_t
182 IOCPURunPlatformQuiesceActions(void)
184 return (iocpu_run_platform_actions(iocpu_get_platform_quiesce_queue(), 0, 0U-1,
188 extern "C" kern_return_t
189 IOCPURunPlatformActiveActions(void)
191 return (iocpu_run_platform_actions(iocpu_get_platform_active_queue(), 0, 0U-1,
196 IOServicePlatformAction(void * refcon0
, void * refcon1
, uint32_t priority
,
197 void * param1
, void * param2
, void * param3
)
200 IOService
* service
= (IOService
*) refcon0
;
201 const OSSymbol
* function
= (const OSSymbol
*) refcon1
;
203 kprintf("%s -> %s\n", function
->getCStringNoCopy(), service
->getName());
205 ret
= service
->callPlatformFunction(function
, false,
206 (void *) priority
, param1
, param2
, param3
);
212 IOInstallServicePlatformAction(IOService
* service
,
213 const OSSymbol
* key
, queue_head_t
* queue
,
217 iocpu_platform_action_entry_t
* entry
;
220 num
= OSDynamicCast(OSNumber
, service
->getProperty(key
));
224 entry
= IONew(iocpu_platform_action_entry_t
, 1);
225 entry
->action
= &IOServicePlatformAction
;
226 priority
= num
->unsigned32BitValue();
228 entry
->priority
= -priority
;
230 entry
->priority
= priority
;
231 entry
->refcon0
= service
;
232 entry
->refcon1
= (void *) key
;
234 iocpu_add_platform_action(queue
, entry
);
235 entry
->alloc_list
= gIOAllActionsQueue
;
236 gIOAllActionsQueue
= entry
;
239 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
241 kern_return_t
PE_cpu_start(cpu_id_t target
,
242 vm_offset_t start_paddr
, vm_offset_t arg_paddr
)
244 IOCPU
*targetCPU
= OSDynamicCast(IOCPU
, (OSObject
*)target
);
246 if (targetCPU
== 0) return KERN_FAILURE
;
247 return targetCPU
->startCPU(start_paddr
, arg_paddr
);
250 void PE_cpu_halt(cpu_id_t target
)
252 IOCPU
*targetCPU
= OSDynamicCast(IOCPU
, (OSObject
*)target
);
254 if (targetCPU
) targetCPU
->haltCPU();
257 void PE_cpu_signal(cpu_id_t source
, cpu_id_t target
)
259 IOCPU
*sourceCPU
= OSDynamicCast(IOCPU
, (OSObject
*)source
);
260 IOCPU
*targetCPU
= OSDynamicCast(IOCPU
, (OSObject
*)target
);
262 if (sourceCPU
&& targetCPU
) sourceCPU
->signalCPU(targetCPU
);
265 void PE_cpu_machine_init(cpu_id_t target
, boolean_t bootb
)
267 IOCPU
*targetCPU
= OSDynamicCast(IOCPU
, (OSObject
*)target
);
269 if (targetCPU
) targetCPU
->initCPU(bootb
);
272 void PE_cpu_machine_quiesce(cpu_id_t target
)
274 IOCPU
*targetCPU
= OSDynamicCast(IOCPU
, (OSObject
*)target
);
276 if (targetCPU
) targetCPU
->quiesceCPU();
280 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
282 #define super IOService
284 OSDefineMetaClassAndAbstractStructors(IOCPU
, IOService
);
285 OSMetaClassDefineReservedUnused(IOCPU
, 0);
286 OSMetaClassDefineReservedUnused(IOCPU
, 1);
287 OSMetaClassDefineReservedUnused(IOCPU
, 2);
288 OSMetaClassDefineReservedUnused(IOCPU
, 3);
289 OSMetaClassDefineReservedUnused(IOCPU
, 4);
290 OSMetaClassDefineReservedUnused(IOCPU
, 5);
291 OSMetaClassDefineReservedUnused(IOCPU
, 6);
292 OSMetaClassDefineReservedUnused(IOCPU
, 7);
294 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
296 static OSArray
*gIOCPUs
;
297 static const OSSymbol
*gIOCPUStateKey
;
298 static OSString
*gIOCPUStateNames
[kIOCPUStateCount
];
300 void IOCPUSleepKernel(void)
304 IOCPU
*bootCPU
= NULL
;
306 kprintf("IOCPUSleepKernel\n");
311 queue_init(&gIOSleepActionQueue
);
312 queue_init(&gIOWakeActionQueue
);
314 iter
= IORegistryIterator::iterateOver( gIOServicePlane
,
315 kIORegistryIterateRecursively
);
321 while((service
= (IOService
*) iter
->getNextObject()))
323 IOInstallServicePlatformAction(service
, gIOPlatformSleepActionKey
, &gIOSleepActionQueue
, false);
324 IOInstallServicePlatformAction(service
, gIOPlatformWakeActionKey
, &gIOWakeActionQueue
, true);
325 IOInstallServicePlatformAction(service
, gIOPlatformQuiesceActionKey
, iocpu_get_platform_quiesce_queue(), false);
326 IOInstallServicePlatformAction(service
, gIOPlatformActiveActionKey
, iocpu_get_platform_active_queue(), true);
329 while( !service
&& !iter
->isValid());
333 iocpu_run_platform_actions(&gIOSleepActionQueue
, 0, 0U-1,
336 numCPUs
= gIOCPUs
->getCount();
341 target
= OSDynamicCast(IOCPU
, gIOCPUs
->getObject(cnt
));
343 // We make certain that the bootCPU is the last to sleep
344 // We'll skip it for now, and halt it after finishing the
346 if (target
->getCPUNumber() == kBootCPUNumber
)
349 } else if (target
->getCPUState() == kIOCPUStateRunning
)
355 // Now sleep the boot CPU.
359 iocpu_run_platform_actions(&gIOWakeActionQueue
, 0, 0U-1,
362 iocpu_platform_action_entry_t
* entry
;
363 while ((entry
= gIOAllActionsQueue
))
365 gIOAllActionsQueue
= entry
->alloc_list
;
366 iocpu_remove_platform_action(entry
);
367 IODelete(entry
, iocpu_platform_action_entry_t
, 1);
370 if (!queue_empty(&gIOSleepActionQueue
))
371 panic("gIOSleepActionQueue");
372 if (!queue_empty(&gIOWakeActionQueue
))
373 panic("gIOWakeActionQueue");
375 // Wake the other CPUs.
376 for (cnt
= 0; cnt
< numCPUs
; cnt
++)
378 target
= OSDynamicCast(IOCPU
, gIOCPUs
->getObject(cnt
));
380 // Skip the already-woken boot CPU.
381 if ((target
->getCPUNumber() != kBootCPUNumber
)
382 && (target
->getCPUState() == kIOCPUStateStopped
))
384 processor_start(target
->getMachProcessor());
389 void IOCPU::initCPUs(void)
392 gIOCPUs
= OSArray::withCapacity(1);
394 gIOCPUStateKey
= OSSymbol::withCStringNoCopy("IOCPUState");
396 gIOCPUStateNames
[kIOCPUStateUnregistered
] =
397 OSString::withCStringNoCopy("Unregistered");
398 gIOCPUStateNames
[kIOCPUStateUninitalized
] =
399 OSString::withCStringNoCopy("Uninitalized");
400 gIOCPUStateNames
[kIOCPUStateStopped
] =
401 OSString::withCStringNoCopy("Stopped");
402 gIOCPUStateNames
[kIOCPUStateRunning
] =
403 OSString::withCStringNoCopy("Running");
407 bool IOCPU::start(IOService
*provider
)
409 OSData
*busFrequency
, *cpuFrequency
, *timebaseFrequency
;
411 if (!super::start(provider
)) return false;
418 gIOCPUs
->setObject(this);
420 // Correct the bus, cpu and timebase frequencies in the device tree.
421 if (gPEClockFrequencyInfo
.bus_frequency_hz
< 0x100000000ULL
) {
422 busFrequency
= OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo
.bus_clock_rate_hz
, 4);
424 busFrequency
= OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo
.bus_frequency_hz
, 8);
426 provider
->setProperty("bus-frequency", busFrequency
);
427 busFrequency
->release();
429 if (gPEClockFrequencyInfo
.cpu_frequency_hz
< 0x100000000ULL
) {
430 cpuFrequency
= OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo
.cpu_clock_rate_hz
, 4);
432 cpuFrequency
= OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo
.cpu_frequency_hz
, 8);
434 provider
->setProperty("clock-frequency", cpuFrequency
);
435 cpuFrequency
->release();
437 timebaseFrequency
= OSData::withBytesNoCopy((void *)&gPEClockFrequencyInfo
.timebase_frequency_hz
, 4);
438 provider
->setProperty("timebase-frequency", timebaseFrequency
);
439 timebaseFrequency
->release();
441 super::setProperty("IOCPUID", (uintptr_t)this, sizeof(uintptr_t)*8);
444 setCPUState(kIOCPUStateUnregistered
);
449 OSObject
*IOCPU::getProperty(const OSSymbol
*aKey
) const
451 if (aKey
== gIOCPUStateKey
) return gIOCPUStateNames
[_cpuState
];
453 return super::getProperty(aKey
);
456 bool IOCPU::setProperty(const OSSymbol
*aKey
, OSObject
*anObject
)
460 if (aKey
== gIOCPUStateKey
) {
461 stateStr
= OSDynamicCast(OSString
, anObject
);
462 if (stateStr
== 0) return false;
464 if (_cpuNumber
== 0) return false;
466 if (stateStr
->isEqualTo("running")) {
467 if (_cpuState
== kIOCPUStateStopped
) {
468 processor_start(machProcessor
);
469 } else if (_cpuState
!= kIOCPUStateRunning
) {
472 } else if (stateStr
->isEqualTo("stopped")) {
473 if (_cpuState
== kIOCPUStateRunning
) {
475 } else if (_cpuState
!= kIOCPUStateStopped
) {
483 return super::setProperty(aKey
, anObject
);
486 bool IOCPU::serializeProperties(OSSerialize
*serialize
) const
489 OSDictionary
*dict
= dictionaryWithProperties();
490 dict
->setObject(gIOCPUStateKey
, gIOCPUStateNames
[_cpuState
]);
491 result
= dict
->serialize(serialize
);
496 IOReturn
IOCPU::setProperties(OSObject
*properties
)
498 OSDictionary
*dict
= OSDynamicCast(OSDictionary
, properties
);
502 if (dict
== 0) return kIOReturnUnsupported
;
504 stateStr
= OSDynamicCast(OSString
, dict
->getObject(gIOCPUStateKey
));
506 result
= IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator
);
507 if (result
!= kIOReturnSuccess
) return result
;
509 if (setProperty(gIOCPUStateKey
, stateStr
)) return kIOReturnSuccess
;
511 return kIOReturnUnsupported
;
514 return kIOReturnUnsupported
;
517 void IOCPU::signalCPU(IOCPU */
*target*/
)
521 void IOCPU::enableCPUTimeBase(bool /*enable*/)
525 UInt32
IOCPU::getCPUNumber(void)
530 void IOCPU::setCPUNumber(UInt32 cpuNumber
)
532 _cpuNumber
= cpuNumber
;
533 super::setProperty("IOCPUNumber", _cpuNumber
, 32);
536 UInt32
IOCPU::getCPUState(void)
541 void IOCPU::setCPUState(UInt32 cpuState
)
543 if (cpuState
< kIOCPUStateCount
) {
544 _cpuState
= cpuState
;
548 OSArray
*IOCPU::getCPUGroup(void)
553 UInt32
IOCPU::getCPUGroupSize(void)
555 return _cpuGroup
->getCount();
558 processor_t
IOCPU::getMachProcessor(void)
560 return machProcessor
;
564 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
567 #define super IOInterruptController
569 OSDefineMetaClassAndStructors(IOCPUInterruptController
, IOInterruptController
);
571 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 0);
572 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 1);
573 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 2);
574 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 3);
575 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 4);
576 OSMetaClassDefineReservedUnused(IOCPUInterruptController
, 5);
580 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
583 IOReturn
IOCPUInterruptController::initCPUInterruptController(int sources
)
587 if (!super::init()) return kIOReturnInvalid
;
591 cpus
= (IOCPU
**)IOMalloc(numCPUs
* sizeof(IOCPU
*));
592 if (cpus
== 0) return kIOReturnNoMemory
;
593 bzero(cpus
, numCPUs
* sizeof(IOCPU
*));
595 vectors
= (IOInterruptVector
*)IOMalloc(numCPUs
* sizeof(IOInterruptVector
));
596 if (vectors
== 0) return kIOReturnNoMemory
;
597 bzero(vectors
, numCPUs
* sizeof(IOInterruptVector
));
599 // Allocate locks for the
600 for (cnt
= 0; cnt
< numCPUs
; cnt
++) {
601 vectors
[cnt
].interruptLock
= IOLockAlloc();
602 if (vectors
[cnt
].interruptLock
== NULL
) {
603 for (cnt
= 0; cnt
< numCPUs
; cnt
++) {
604 if (vectors
[cnt
].interruptLock
!= NULL
)
605 IOLockFree(vectors
[cnt
].interruptLock
);
607 return kIOReturnNoResources
;
611 ml_init_max_cpus(numCPUs
);
613 return kIOReturnSuccess
;
616 void IOCPUInterruptController::registerCPUInterruptController(void)
620 getPlatform()->registerInterruptController(gPlatformInterruptControllerName
,
624 void IOCPUInterruptController::setCPUInterruptProperties(IOService
*service
)
632 if ((service
->getProperty(gIOInterruptControllersKey
) != 0) &&
633 (service
->getProperty(gIOInterruptSpecifiersKey
) != 0))
636 // Create the interrupt specifer array.
637 specifier
= OSArray::withCapacity(numCPUs
);
638 for (cnt
= 0; cnt
< numCPUs
; cnt
++) {
640 tmpData
= OSData::withBytes(&tmpLong
, sizeof(tmpLong
));
641 specifier
->setObject(tmpData
);
645 // Create the interrupt controller array.
646 controller
= OSArray::withCapacity(numCPUs
);
647 for (cnt
= 0; cnt
< numCPUs
; cnt
++) {
648 controller
->setObject(gPlatformInterruptControllerName
);
651 // Put the two arrays into the property table.
652 service
->setProperty(gIOInterruptControllersKey
, controller
);
653 service
->setProperty(gIOInterruptSpecifiersKey
, specifier
);
654 controller
->release();
655 specifier
->release();
658 void IOCPUInterruptController::enableCPUInterrupt(IOCPU
*cpu
)
660 IOInterruptHandler handler
= OSMemberFunctionCast(
661 IOInterruptHandler
, this, &IOCPUInterruptController::handleInterrupt
);
663 ml_install_interrupt_handler(cpu
, cpu
->getCPUNumber(), this, handler
, 0);
667 if (enabledCPUs
== numCPUs
) thread_wakeup(this);
670 IOReturn
IOCPUInterruptController::registerInterrupt(IOService
*nub
,
673 IOInterruptHandler handler
,
676 IOInterruptVector
*vector
;
678 if (source
>= numCPUs
) return kIOReturnNoResources
;
680 vector
= &vectors
[source
];
682 // Get the lock for this vector.
683 IOTakeLock(vector
->interruptLock
);
685 // Make sure the vector is not in use.
686 if (vector
->interruptRegistered
) {
687 IOUnlock(vector
->interruptLock
);
688 return kIOReturnNoResources
;
691 // Fill in vector with the client's info.
692 vector
->handler
= handler
;
694 vector
->source
= source
;
695 vector
->target
= target
;
696 vector
->refCon
= refCon
;
698 // Get the vector ready. It starts hard disabled.
699 vector
->interruptDisabledHard
= 1;
700 vector
->interruptDisabledSoft
= 1;
701 vector
->interruptRegistered
= 1;
703 IOUnlock(vector
->interruptLock
);
705 if (enabledCPUs
!= numCPUs
) {
706 assert_wait(this, THREAD_UNINT
);
707 thread_block(THREAD_CONTINUE_NULL
);
710 return kIOReturnSuccess
;
713 IOReturn
IOCPUInterruptController::getInterruptType(IOService */
*nub*/
,
717 if (interruptType
== 0) return kIOReturnBadArgument
;
719 *interruptType
= kIOInterruptTypeLevel
;
721 return kIOReturnSuccess
;
724 IOReturn
IOCPUInterruptController::enableInterrupt(IOService */
*nub*/
,
727 // ml_set_interrupts_enabled(true);
728 return kIOReturnSuccess
;
731 IOReturn
IOCPUInterruptController::disableInterrupt(IOService */
*nub*/
,
734 // ml_set_interrupts_enabled(false);
735 return kIOReturnSuccess
;
738 IOReturn
IOCPUInterruptController::causeInterrupt(IOService */
*nub*/
,
741 ml_cause_interrupt();
742 return kIOReturnSuccess
;
745 IOReturn
IOCPUInterruptController::handleInterrupt(void */
*refCon*/
,
749 IOInterruptVector
*vector
;
751 vector
= &vectors
[source
];
753 if (!vector
->interruptRegistered
) return kIOReturnInvalid
;
755 vector
->handler(vector
->target
, vector
->refCon
,
756 vector
->nub
, vector
->source
);
758 return kIOReturnSuccess
;
761 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */