IOReturn IOFireWireMagicMatchingNub::message( UInt32 mess,
IOService * provider,
void * argument )
{
// Propagate bus reset start/end messages
if( kIOMessageServiceIsResumed == mess ||
kIOMessageServiceIsSuspended == mess ||
kIOMessageServiceIsRequestingClose == mess ||
kIOFWMessageServiceIsRequestingClose == mess )
{
messageClients( mess );
return kIOReturnSuccess;
}
if( kIOFWMessagePowerStateChanged == mess )
{
messageClients( mess );
return kIOReturnSuccess;
}
if( kIOFWMessageTopologyChanged == mess )
{
messageClients( mess );
return kIOReturnSuccess;
}
return IOService::message(mess, provider, argument );
}
IOReturn IOFireWireAVCLocalNode::message(UInt32 type, IOService *provider, void *argument)
{
IOReturn res = kIOReturnUnsupported;
//IOLog( "IOFireWireAVCLocalNode::message\n");
switch (type)
{
case kIOMessageServiceIsTerminated:
case kIOMessageServiceIsRequestingClose:
case kIOMessageServiceIsResumed:
res = kIOReturnSuccess;
break;
// This message is received when a bus-reset start happens!
case kIOMessageServiceIsSuspended:
res = kIOReturnSuccess;
if((fStarted == true) && (fPCRSpace))
fPCRSpace->clearAllP2PConnections();
break;
default:
break;
}
messageClients(type);
return res;
}
IOReturn IOFireWireSBP2LUN::message( UInt32 type, IOService *nub, void *arg )
{
IOReturn res = kIOReturnUnsupported;
//IOLog("IOFireWireSBP2LUN, message 0x%x\n", type);
res = IOService::message(type, nub, arg);
if( kIOReturnUnsupported == res )
{
switch (type)
{
case kIOMessageServiceIsTerminated:
terminateNotify();
FWKLOG( ( "IOFireWireSBP2LUN<%p> : kIOMessageServiceIsTerminated\n", this ) );
res = kIOReturnSuccess;
break;
case kIOMessageServiceIsSuspended:
FWKLOG( ( "IOFireWireSBP2LUN<%p> : kIOMessageServiceIsSuspended\n", this ) );
suspendedNotify();
res = kIOReturnSuccess;
break;
case kIOMessageServiceIsResumed:
FWKLOG( ( "IOFireWireSBP2LUN<%p> : kIOMessageServiceIsResumed\n", this ) );
resumeNotify();
res = kIOReturnSuccess;
break;
default: // default the action to return kIOReturnUnsupported
break;
}
}
// we must send resumeNotify and/or suspendNotify before messaging clients
if( type != kIOMessageServiceIsTerminated &&
type != (UInt32)kIOMessageFWSBP2ReconnectFailed &&
type != (UInt32)kIOMessageFWSBP2ReconnectComplete )
{
messageClients( type, arg );
}
// send reset notification for all busy orbs
// we must send orb reset notification after messaging clients
if( type == kIOMessageServiceIsSuspended )
clearAllTasksInSet();
return res;
}
void WMIHIKeyboardDevice::keyPressed(int code)
{
int i = 0, out;
do
{
if (keyMap[i].description == NULL && keyMap[i].in == 0 && keyMap[i].out == 0xFF)
{
DbgLog("%s: Unknown key %02X i=%d\n",this->getName(), code, i);
break;
}
if (keyMap[i].in == code)
{
out = keyMap[i].out;
messageClients(kIOACPIMessageDeviceNotification, &out);
DbgLog("%s: Key Pressed %02X i=%d\n",this->getName(), code, i);
break;
}
i++;
}
while (true);
}
IOReturn com_ximeta_driver_NDASLogicalDevice::message(
UInt32 mess,
IOService * provider,
void * argument
)
{
DbgIOLog(DEBUG_MASK_PNP_TRACE, ("message: Entered.\n"));
// Propagate power and eject messages
if ( kIOMessageServiceIsResumed == mess ||
kIOMessageServiceIsSuspended == mess ||
kIOMessageServiceIsRequestingClose == mess ||
kIOMessageServiceIsTerminated == mess
)
{
messageClients( mess );
return kIOReturnSuccess;
}
return IOService::message(mess, provider, argument );
}
IOReturn com_ximeta_driver_NDASDiskArrayController::message (
UInt32 type,
IOService * nub,
void * arg
)
{
DbgIOLog(DEBUG_MASK_NDAS_TRACE, ("message Entered.\n"));
IOReturn status = kIOReturnSuccess;
switch ( type )
{
case kIOMessageServiceIsSuspended:
{
DbgIOLog(DEBUG_MASK_POWER_INFO, ("kIOMessageServiceIsSuspended\n"));
// Now go to sleep.
fInSleepMode = true;
messageClients(kIOMessageServiceIsSuspended);
}
break;
case kIOMessageServiceIsResumed:
{
DbgIOLog(DEBUG_MASK_POWER_INFO, ("kIOMessageServiceIsResumed\n"));
fInSleepMode = false;
fWakeup = true;
// Disconnect.
for(int count = 0; count < MAX_NR_OF_TARGETS_PER_DEVICE; count++) {
if(fProvider->targetConnected(count)) {
fProvider->setTargetConnected(count, false);
fProvider->cleanupDataConnection(count);
//fProvider->unmount(count);
}
}
messageClients(kIOMessageServiceIsResumed);
}
break;
case kIOMessageServiceIsRequestingClose:
{
DbgIOLog(DEBUG_MASK_NDAS_INFO, ("kIOMessageServiceIsRequestingClose\n"));
// Terminate Thread.
fThreadTerminate = true;
semaphore_signal(fCommandSema);
// Wait Until the thread terminated.
semaphore_wait(fExitSema);
if ( fProvider != NULL ) {
fProvider->setController(NULL);
if ( fProvider->isOpen ( this ) ) {
fProvider->close ( this );
}
}
}
break;
case kIOMessageServiceIsTerminated:
DbgIOLog(DEBUG_MASK_NDAS_INFO, ("kIOMessageServiceIsTerminated\n"));
if ( fProvider != NULL ) {
fProvider->setController(NULL);
if ( fProvider->isOpen ( this ) ) {
fProvider->close ( this );
}
}
break;
default:
status = IOService::message (type, nub, arg);
break;
}
return status;
}
