IOFireWireAVCProtocolUserClient.cpp [plain text]
#include "IOFireWireAVCProtocolUserClient.h"
#include <IOKit/avc/IOFireWireAVCConsts.h>
#include <IOKit/firewire/IOFireWireNub.h>
#include <IOKit/firewire/IOFireWireBus.h>
#include <IOKit/firewire/IOFWAddressSpace.h>
#include <IOKit/avc/IOFireWirePCRSpace.h>
#include <IOKit/avc/IOFireWireAVCTargetSpace.h>
#if FIRELOG
#import <IOKit/firewire/FireLog.h>
#define FIRELOG_MSG(x) FireLog x
#else
#define FIRELOG_MSG(x) do {} while (0)
#endif
struct PlugInfo {
IOFireWireAVCProtocolUserClient *fClient;
UInt32 fPlug;
OSAsyncReference64 fCallbackInfo;
uint64_t fUserRefcon; };
OSDefineMetaClassAndStructors(IOFireWireAVCProtocolUserClient, IOUserClient)
IOReturn IOFireWireAVCProtocolUserClient::externalMethod( uint32_t selector,
IOExternalMethodArguments * arguments,
IOExternalMethodDispatch * dispatch,
OSObject * target,
void * reference)
{
IOReturn result = kIOReturnBadArgument;
FIRELOG_MSG(("IOFireWireAVCProtocolUserClient::externalMethod (this=0x%08X), selector=0x%08X\n",this,selector));
switch (selector)
{
case kIOFWAVCProtocolUserClientSendAVCResponse:
result = sendAVCResponse(arguments->scalarInput[0],arguments->scalarInput[1], (const char*)arguments->structureInput, arguments->structureInputSize);
break;
case kIOFWAVCProtocolUserClientFreeInputPlug:
result = freeInputPlug(arguments->scalarInput[0]);
break;
case kIOFWAVCProtocolUserClientReadInputPlug:
result = readInputPlug((UInt32) arguments->scalarInput[0], arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientUpdateInputPlug:
result = updateInputPlug(arguments->scalarInput[0],arguments->scalarInput[1],arguments->scalarInput[2]);
break;
case kIOFWAVCProtocolUserClientFreeOutputPlug:
result = freeOutputPlug(arguments->scalarInput[0]);
break;
case kIOFWAVCProtocolUserClientReadOutputPlug:
result = readOutputPlug((UInt32) arguments->scalarInput[0], arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientUpdateOutputPlug:
result = updateOutputPlug(arguments->scalarInput[0],arguments->scalarInput[1],arguments->scalarInput[2]);
break;
case kIOFWAVCProtocolUserClientReadOutputMasterPlug:
result = readOutputMasterPlug(arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientUpdateOutputMasterPlug:
result = updateOutputMasterPlug(arguments->scalarInput[0],arguments->scalarInput[1]);
break;
case kIOFWAVCProtocolUserClientReadInputMasterPlug:
result = readInputMasterPlug(arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientUpdateInputMasterPlug:
result = updateInputMasterPlug(arguments->scalarInput[0],arguments->scalarInput[1]);
break;
case kIOFWAVCProtocolUserClientPublishAVCUnitDirectory:
result = publishAVCUnitDirectory();
break;
case kIOFWAVCProtocolUserClientSetSubunitPlugSignalFormat:
result = setSubunitPlugSignalFormat(arguments->scalarInput[0],(IOFWAVCPlugTypes)arguments->scalarInput[1],arguments->scalarInput[2],arguments->scalarInput[3]);
break;
case kIOFWAVCProtocolUserClientGetSubunitPlugSignalFormat:
result = getSubunitPlugSignalFormat(arguments->scalarInput[0],(IOFWAVCPlugTypes)arguments->scalarInput[1],arguments->scalarInput[2],arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientConnectTargetPlugs:
if( (arguments->structureInputSize != sizeof(AVCConnectTargetPlugsInParams)) || (arguments->structureOutputSize != sizeof(AVCConnectTargetPlugsOutParams)) )
return kIOReturnBadArgument;
result = connectTargetPlugs((AVCConnectTargetPlugsInParams *) arguments->structureInput, (AVCConnectTargetPlugsOutParams *) arguments->structureOutput);
break;
case kIOFWAVCProtocolUserClientDisconnectTargetPlugs:
result = disconnectTargetPlugs(arguments->scalarInput[0],
(IOFWAVCPlugTypes)arguments->scalarInput[1],
arguments->scalarInput[2],
arguments->scalarInput[3],
(IOFWAVCPlugTypes)arguments->scalarInput[4],
arguments->scalarInput[5]);
break;
case kIOFWAVCProtocolUserClientGetTargetPlugConnection:
if( (arguments->structureInputSize != sizeof(AVCGetTargetPlugConnectionInParams)) || (arguments->structureOutputSize != sizeof(AVCGetTargetPlugConnectionOutParams)) )
return kIOReturnBadArgument;
result = getTargetPlugConnection((AVCGetTargetPlugConnectionInParams *) arguments->structureInput,
(AVCGetTargetPlugConnectionOutParams *) arguments->structureOutput);
break;
case kIOFWAVCProtocolUserClientAVCRequestNotHandled:
result = AVCRequestNotHandled(arguments->scalarInput[0],
arguments->scalarInput[1],
(IOFWSpeed)arguments->scalarInput[2],
arguments->scalarInput[3],
(const char *)arguments->structureInput,
arguments->structureInputSize);
break;
case kIOFWAVCProtocolUserClientAllocateInputPlug:
result = allocateInputPlug(arguments->asyncReference, arguments->scalarInput[0], arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientAllocateOutputPlug:
result = allocateOutputPlug(arguments->asyncReference, arguments->scalarInput[0], arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientInstallAVCCommandHandler:
result = installAVCCommandHandler(arguments->asyncReference, arguments->scalarInput[0], arguments->scalarInput[1],arguments->scalarInput[2],arguments->scalarInput[3]);
break;
case kIOFWAVCProtocolUserClientAddSubunit:
result = addSubunit(arguments->asyncReference,
arguments->scalarInput[0],
arguments->scalarInput[1],
arguments->scalarInput[2],
arguments->scalarInput[3],
arguments->scalarInput[4],
arguments->scalarOutput);
break;
case kIOFWAVCProtocolUserClientSetAVCRequestCallback: result = kIOReturnUnsupported;
break;
default:
break;
};
return result;
}
void IOFireWireAVCProtocolUserClient::forwardPlugWrite(void *refcon, UInt16 nodeID, UInt32 plug, UInt32 oldVal, UInt32 newVal)
{
OSData *data = (OSData *)refcon;
const PlugInfo *info = (const PlugInfo *)(data->getBytesNoCopy());
io_user_reference_t args[kMaxAsyncArgs];
UInt32 generation;
UInt16 localID;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::forwardPlugWrite\n"));
info->fClient->fDevice->getNodeIDGeneration(generation, localID);
args[0] = info->fUserRefcon;
args[1] = generation;
args[2] = ((UInt32)nodeID);
args[3] = plug;
args[4] = oldVal;
args[5] = newVal;
info->fClient->sendAsyncResult64( ((PlugInfo *)info)->fCallbackInfo, kIOReturnSuccess, args, 6 );
}
void IOFireWireAVCProtocolUserClient::avcTargetCommandHandler(const AVCCommandHandlerInfo *pCmdInfo,
UInt32 generation,
UInt16 nodeID,
const void *command,
UInt32 cmdLen,
IOFWSpeed &speed,
UInt32 handlerSearchIndex)
{
io_user_reference_t args[kMaxAsyncArgs];
OSAsyncReference64 asyncRef;
UInt8 *src;
UInt8 *dst;
UInt32 copyLen;
UInt32 i;
UInt32 thisCopyLen;
UInt8 *thisLoopStartSrc;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::avcTargetCommandHandler\n"));
bcopy(pCmdInfo->asyncRef, asyncRef, sizeof(OSAsyncReference64));
args[0] = 0; args[2] = generation;
args[3] = ((UInt32)nodeID);
args[4] = cmdLen;
args[5] = pCmdInfo->userCallBack;
args[6] = pCmdInfo->userRefCon;
args[7] = speed;
args[8] = handlerSearchIndex;
src = (UInt8*)command;
dst = (UInt8 *)(args+9);
#if __BIG_ENDIAN__
dst += 4;
#endif
copyLen = cmdLen;
if(copyLen > (kMaxAsyncArgs - 9)*4)
copyLen = (kMaxAsyncArgs - 9)*4;
i = copyLen;
while (i > 0)
{
thisCopyLen = (i < 4) ? i : 4;
bcopy(src, dst, thisCopyLen);
i -= thisCopyLen;
src += 4;
dst += 8;
}
args[1] = copyLen;
pCmdInfo->userClient->sendAsyncResult64( asyncRef, kIOReturnSuccess,
args, 9+(copyLen+4-1)/4 );
cmdLen -= copyLen;
while(cmdLen) {
copyLen = cmdLen;
dst = (UInt8 *)(args+2);
#if __BIG_ENDIAN__
dst += 4;
#endif
if(copyLen > (kMaxAsyncArgs - 2)*4)
copyLen = (kMaxAsyncArgs - 2)*4;
i = copyLen;
thisLoopStartSrc = src;
while (i > 0)
{
thisCopyLen = (i < 4) ? i : 4;
bcopy(src, dst, thisCopyLen);
i -= thisCopyLen;
src += 4;
dst += 8;
}
args[0] = (thisLoopStartSrc - (const UInt8*)command); args[1] = copyLen;
pCmdInfo->userClient->sendAsyncResult64( asyncRef, kIOReturnSuccess,
args, 2+(copyLen+4-1)/4 );
cmdLen -= copyLen;
}
}
void IOFireWireAVCProtocolUserClient::avcSubunitPlugHandler(const AVCSubunitInfo *pSubunitInfo,
IOFWAVCSubunitPlugMessages plugMessage,
IOFWAVCPlugTypes plugType,
UInt32 plugNum,
UInt32 messageParams,
UInt32 generation,
UInt16 nodeID)
{
io_user_reference_t args[kMaxAsyncArgs];
OSAsyncReference64 asyncRef;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::avcSubunitPlugHandler\n"));
bcopy(pSubunitInfo->asyncRef, asyncRef, sizeof(OSAsyncReference64));
args[0] = pSubunitInfo->subunitTypeAndID;
args[1] = plugType;
args[2] = plugNum;
args[3] = plugMessage;
args[4] = messageParams;
args[5] = pSubunitInfo->userCallBack;
args[6] = pSubunitInfo->userRefCon;
args[7] = generation;
args[8] = ((UInt32)nodeID);
pSubunitInfo->userClient->sendAsyncResult64( asyncRef, kIOReturnSuccess,
args, 9);
}
void IOFireWireAVCProtocolUserClient::free()
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::free (%p)\n",this));
if(fInputPlugs) {
OSData *data;
while(data = OSDynamicCast(OSData, fInputPlugs->getAnyObject())) {
const PlugInfo *info = (const PlugInfo *)(data->getBytesNoCopy());
fPCRSpace->freeInputPlug(info->fPlug);
fInputPlugs->removeObject(data);
}
fInputPlugs->release();
}
if(fOutputPlugs) {
OSData *data;
while(data = OSDynamicCast(OSData, fOutputPlugs->getAnyObject())) {
const PlugInfo *info = (const PlugInfo *)(data->getBytesNoCopy());
fPCRSpace->freeOutputPlug(info->fPlug);
fOutputPlugs->removeObject(data);
}
fOutputPlugs->release();
}
if(fPCRSpace) {
fPCRSpace->deactivate();
fPCRSpace->release();
}
if(fAVCTargetSpace) {
fAVCTargetSpace->deactivateWithUserClient(this);
fAVCTargetSpace->release();
}
IOUserClient::free();
}
bool IOFireWireAVCProtocolUserClient::start(IOService *provider)
{
OSObject *prop;
IOFireWireNub *device;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::start (%p)\n", this));
device = OSDynamicCast(IOFireWireNub, provider->getProvider());
if(!device)
return false;
fBus = device->getBus();
fDevice = device;
prop = device->getProperty(gFireWire_GUID);
if(prop)
setProperty(gFireWire_GUID, prop);
fInputPlugs = OSSet::withCapacity(1);
fOutputPlugs = OSSet::withCapacity(1);
if(!fInputPlugs || !fOutputPlugs)
return false;
fPCRSpace = IOFireWirePCRSpace::getPCRAddressSpace(fDevice->getBus());
if(!fPCRSpace)
return false;
fPCRSpace->activate();
fAVCTargetSpace = IOFireWireAVCTargetSpace::getAVCTargetSpace(fDevice->getController());
if(!fAVCTargetSpace)
return false;
fAVCTargetSpace->activateWithUserClient(this);
fPCRSpace->setAVCTargetSpacePointer(fAVCTargetSpace);
registerService();
return true;
}
IOReturn IOFireWireAVCProtocolUserClient::newUserClient( task_t owningTask, void * securityID,
UInt32 type, OSDictionary * properties,
IOUserClient ** handler )
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::newUserClient (%p)\n", this));
if(fStarted)
return kIOReturnStillOpen;
retain();
*handler = this;
fStarted = true;
fTask = owningTask;
if (properties)
{
properties->setObject("IOUserClientCrossEndianCompatible", kOSBooleanTrue);
setProperty("IOUserClientCrossEndianCompatible", kOSBooleanTrue);
}
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::clientClose( void )
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::clientClose (%p)\n", this));
fStarted = false;
getProvider()->terminate( kIOServiceRequired );
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::clientDied( void )
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::clientDied (%p)\n", this));
return clientClose();
}
bool IOFireWireAVCProtocolUserClient::matchPropertyTable(OSDictionary * table)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::matchPropertyTable (%p)\n", this));
if (!IOService::matchPropertyTable(table)) return false;
bool res = compareProperty(table, gFireWire_GUID);
return res;
}
IOReturn
IOFireWireAVCProtocolUserClient::sendAVCResponse(UInt32 generation, UInt16 nodeID, const char *buffer, UInt32 size)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::sendAVCResponse (%p)\n", this));
IOMemoryDescriptor *desc = NULL;
IOFWWriteCommand *cmd = NULL;
IOReturn status;
do {
desc = IOMemoryDescriptor::withAddress((void *)buffer,size, kIODirectionOutIn);
if(!desc) {
status = kIOReturnNoMemory;
break;
}
status = desc->prepare();
if( status != kIOReturnSuccess )
{
break;
}
cmd = new IOFWWriteCommand;
if(!cmd) {
status = kIOReturnNoMemory;
break;
}
if(!cmd->initAll(fDevice->getController(), generation,
FWAddress(kCSRRegisterSpaceBaseAddressHi, kFCPResponseAddress, nodeID),
desc, NULL, NULL)) {
status = kIOReturnNoMemory;
break;
}
status = cmd->submit();
} while (false);
if(cmd)
cmd->release();
if(desc)
desc->release();
return status;
}
IOReturn
IOFireWireAVCProtocolUserClient::allocateInputPlug(io_user_reference_t *asyncRef, uint64_t userRefcon, uint64_t *plugPtr)
{
IOReturn status;
PlugInfo info;
OSData *data;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::allocateInputPlug (%p)\n", this));
data = OSData::withCapacity(sizeof(info));
if(!data)
return kIOReturnNoMemory;
do {
info.fPlug = 0x1234; status = fPCRSpace->allocateInputPlug(data, forwardPlugWrite, info.fPlug);
if(status != kIOReturnSuccess)
break;
bcopy(asyncRef, info.fCallbackInfo, sizeof(OSAsyncReference64));
info.fUserRefcon = userRefcon;
info.fClient = this;
if(!data->appendBytes(&info, sizeof(info))) {
status = kIOReturnNoMemory;
break;
}
if(!fInputPlugs->setObject(data)) {
status = kIOReturnNoMemory;
break;
}
*plugPtr = info.fPlug;
status = kIOReturnSuccess;
} while (false);
data->release(); if(status != kIOReturnSuccess && info.fPlug != 0x1234)
fPCRSpace->freeInputPlug(info.fPlug);
return status;
}
IOReturn
IOFireWireAVCProtocolUserClient::allocateOutputPlug(io_user_reference_t *asyncRef, uint64_t userRefcon, uint64_t *plugPtr)
{
IOReturn status;
PlugInfo info;
OSData *data;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::allocateOutputPlug (%p)\n", this));
data = OSData::withCapacity(sizeof(info));
if(!data)
return kIOReturnNoMemory;
do {
info.fPlug = 0x1234; status = fPCRSpace->allocateOutputPlug(data, forwardPlugWrite, info.fPlug);
if(status != kIOReturnSuccess)
break;
bcopy(asyncRef, info.fCallbackInfo, sizeof(OSAsyncReference64));
info.fUserRefcon = userRefcon;
info.fClient = this;
if(!data->appendBytes(&info, sizeof(info))) {
status = kIOReturnNoMemory;
break;
}
if(!fOutputPlugs->setObject(data)) {
status = kIOReturnNoMemory;
break;
}
*plugPtr = info.fPlug;
status = kIOReturnSuccess;
} while (false);
data->release(); if(status != kIOReturnSuccess && info.fPlug != 0x1234)
fPCRSpace->freeOutputPlug(info.fPlug);
return status;
}
IOReturn IOFireWireAVCProtocolUserClient::freeInputPlug(UInt32 plug)
{
OSIterator *plugIterator;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::freeInputPlug (%p)\n", this));
plugIterator = OSCollectionIterator::withCollection(fInputPlugs);
if( plugIterator) {
OSData * data;
while( (data = (OSData *)plugIterator->getNextObject())) {
const PlugInfo *info = (const PlugInfo *)(data->getBytesNoCopy());
if(info->fPlug == plug) {
fPCRSpace->freeInputPlug(info->fPlug);
fInputPlugs->removeObject(data);
}
}
plugIterator->release();
}
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::freeOutputPlug(UInt32 plug)
{
OSIterator *plugIterator;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::freeOutputPlug (%p)\n", this));
plugIterator = OSCollectionIterator::withCollection(fOutputPlugs);
if( plugIterator) {
OSData * data;
while( (data = (OSData *)plugIterator->getNextObject())) {
const PlugInfo *info = (const PlugInfo *)(data->getBytesNoCopy());
if(info->fPlug == plug) {
fPCRSpace->freeOutputPlug(info->fPlug);
fInputPlugs->removeObject(data);
}
}
plugIterator->release();
}
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::readInputPlug(UInt32 plug, uint64_t *valPtr)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::readInputPlug (%p)\n", this));
if(plug > 30)
return kIOReturnBadArgument;
*valPtr = fPCRSpace->readInputPlug(plug);
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::updateInputPlug(UInt32 plug, UInt32 oldVal, UInt32 newVal)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::updateInputPlug (%p)\n", this));
if(plug > 30)
return kIOReturnBadArgument;
return fPCRSpace->updateInputPlug(plug, oldVal, newVal);
}
IOReturn IOFireWireAVCProtocolUserClient::readOutputPlug(UInt32 plug, uint64_t *valPtr)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::readOutputPlug (%p)\n",this));
if(plug > 30)
return kIOReturnBadArgument;
*valPtr = fPCRSpace->readOutputPlug(plug);
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::updateOutputPlug(UInt32 plug, UInt32 oldVal, UInt32 newVal)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::updateOutputPlug (%p)\n", this));
if(plug > 30)
return kIOReturnBadArgument;
return fPCRSpace->updateOutputPlug(plug, oldVal, newVal);
}
IOReturn IOFireWireAVCProtocolUserClient::readOutputMasterPlug(uint64_t *valPtr)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::readOutputMasterPlug (%p)\n",this));
*valPtr = fPCRSpace->readOutputMasterPlug();
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::updateOutputMasterPlug(UInt32 oldVal, UInt32 newVal)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::updateOutputMasterPlug (%p)\n", this));
return fPCRSpace->updateOutputMasterPlug(oldVal, newVal);
}
IOReturn IOFireWireAVCProtocolUserClient::readInputMasterPlug(uint64_t *valPtr)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::readInputMasterPlug (%p)\n", this));
*valPtr = fPCRSpace->readInputMasterPlug();
return kIOReturnSuccess;
}
IOReturn IOFireWireAVCProtocolUserClient::updateInputMasterPlug(UInt32 oldVal, UInt32 newVal)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::updateInputMasterPlug (%p)\n", this));
return fPCRSpace->updateInputMasterPlug(oldVal, newVal);
}
IOReturn IOFireWireAVCProtocolUserClient::publishAVCUnitDirectory(void)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::publishAVCUnitDirectory (%p)\n", this));
return fAVCTargetSpace->publishAVCUnitDirectory();
}
IOReturn IOFireWireAVCProtocolUserClient::installAVCCommandHandler(io_user_reference_t *asyncRef, uint64_t subUnitTypeAndID, uint64_t opCode, uint64_t callback, uint64_t refCon)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::installAVCCommandHandler (%p)\n", this));
return fAVCTargetSpace->installAVCCommandHandler(this, avcTargetCommandHandler, asyncRef, subUnitTypeAndID, opCode, callback, refCon);
}
IOReturn IOFireWireAVCProtocolUserClient::addSubunit(io_user_reference_t *asyncRef,
uint64_t subunitType,
uint64_t numSourcePlugs,
uint64_t numDestPlugs,
uint64_t callBack,
uint64_t refCon,
uint64_t *subUnitTypeAndID)
{
IOReturn res = kIOReturnSuccess;
UInt32 subUnitID = 0x00;
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::addSubunit (%p)\n", this));
res = fAVCTargetSpace->addSubunit(this,
avcSubunitPlugHandler,
asyncRef,
subunitType,
numSourcePlugs,
numDestPlugs,
callBack,
refCon,
&subUnitID);
if (res == kIOReturnSuccess)
*subUnitTypeAndID = subUnitID;
return res;
}
IOReturn IOFireWireAVCProtocolUserClient::setSubunitPlugSignalFormat(UInt32 subunitTypeAndID,
IOFWAVCPlugTypes plugType,
UInt32 plugNum,
UInt32 signalFormat)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::setSubunitPlugSignalFormat (%p)\n", this));
return fAVCTargetSpace->setSubunitPlugSignalFormat(this,subunitTypeAndID, plugType, plugNum, signalFormat);
}
IOReturn IOFireWireAVCProtocolUserClient::getSubunitPlugSignalFormat(UInt32 subunitTypeAndID,
IOFWAVCPlugTypes plugType,
UInt32 plugNum,
uint64_t *pSignalFormat)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::getSubunitPlugSignalFormat (%p)\n", this));
UInt32 signalFormat;
IOReturn status;
status = fAVCTargetSpace->getSubunitPlugSignalFormat(this,subunitTypeAndID, plugType, plugNum, &signalFormat);
*pSignalFormat = signalFormat;
return status;
}
IOReturn IOFireWireAVCProtocolUserClient::connectTargetPlugs(AVCConnectTargetPlugsInParams *inParams,
AVCConnectTargetPlugsOutParams *outParams)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::connectTargetPlugs (%p)\n", this));
return fAVCTargetSpace->connectTargetPlugs(this,inParams,outParams);
}
IOReturn IOFireWireAVCProtocolUserClient::disconnectTargetPlugs(UInt32 sourceSubunitTypeAndID,
IOFWAVCPlugTypes sourcePlugType,
UInt32 sourcePlugNum,
UInt32 destSubunitTypeAndID,
IOFWAVCPlugTypes destPlugType,
UInt32 destPlugNum)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::disconnectTargetPlugs (%p)\n", this));
return fAVCTargetSpace->disconnectTargetPlugs(this,
sourceSubunitTypeAndID,
sourcePlugType,
sourcePlugNum,
destSubunitTypeAndID,
destPlugType,
destPlugNum);
}
IOReturn IOFireWireAVCProtocolUserClient::getTargetPlugConnection(AVCGetTargetPlugConnectionInParams *inParams,
AVCGetTargetPlugConnectionOutParams *outParams)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::getTargetPlugConnection (%p)\n", this));
return fAVCTargetSpace->getTargetPlugConnection(this,inParams,outParams);
}
IOReturn IOFireWireAVCProtocolUserClient::AVCRequestNotHandled(UInt32 generation,
UInt16 nodeID,
IOFWSpeed speed,
UInt32 handlerSearchIndex,
const char *pCmdBuf,
UInt32 cmdLen)
{
FIRELOG_MSG(( "IOFireWireAVCProtocolUserClient::AVCRequestNotHandled (%p)\n", this));
fAVCTargetSpace->findAVCRequestHandler(this,
generation,
nodeID,
speed,
handlerSearchIndex,
pCmdBuf,
cmdLen);
return kIOReturnSuccess;
}