IOFWController.cpp [plain text]
#include <IOKit/assert.h>
#include "IOFWController.h"
#include "IOFWInterface.h"
#define super IONetworkController
OSDefineMetaClassAndAbstractStructors( IOFWController, IONetworkController)
OSMetaClassDefineReservedUnused( IOFWController, 0);
OSMetaClassDefineReservedUnused( IOFWController, 1);
OSMetaClassDefineReservedUnused( IOFWController, 2);
OSMetaClassDefineReservedUnused( IOFWController, 3);
OSMetaClassDefineReservedUnused( IOFWController, 4);
OSMetaClassDefineReservedUnused( IOFWController, 5);
OSMetaClassDefineReservedUnused( IOFWController, 6);
OSMetaClassDefineReservedUnused( IOFWController, 7);
OSMetaClassDefineReservedUnused( IOFWController, 8);
OSMetaClassDefineReservedUnused( IOFWController, 9);
OSMetaClassDefineReservedUnused( IOFWController, 10);
OSMetaClassDefineReservedUnused( IOFWController, 11);
OSMetaClassDefineReservedUnused( IOFWController, 12);
OSMetaClassDefineReservedUnused( IOFWController, 13);
OSMetaClassDefineReservedUnused( IOFWController, 14);
OSMetaClassDefineReservedUnused( IOFWController, 15);
OSMetaClassDefineReservedUnused( IOFWController, 16);
OSMetaClassDefineReservedUnused( IOFWController, 17);
OSMetaClassDefineReservedUnused( IOFWController, 18);
OSMetaClassDefineReservedUnused( IOFWController, 19);
OSMetaClassDefineReservedUnused( IOFWController, 20);
OSMetaClassDefineReservedUnused( IOFWController, 21);
OSMetaClassDefineReservedUnused( IOFWController, 22);
OSMetaClassDefineReservedUnused( IOFWController, 23);
OSMetaClassDefineReservedUnused( IOFWController, 24);
OSMetaClassDefineReservedUnused( IOFWController, 25);
OSMetaClassDefineReservedUnused( IOFWController, 26);
OSMetaClassDefineReservedUnused( IOFWController, 27);
OSMetaClassDefineReservedUnused( IOFWController, 28);
OSMetaClassDefineReservedUnused( IOFWController, 29);
OSMetaClassDefineReservedUnused( IOFWController, 30);
OSMetaClassDefineReservedUnused( IOFWController, 31);
#ifdef DEBUG
#define DLOG(fmt, args...) IOLog(fmt, ## args)
#else
#define DLOG(fmt, args...)
#endif
void IOFWController::initialize()
{
}
bool IOFWController::init(OSDictionary * properties)
{
if (!super::init(properties))
{
DLOG("IOFWController: super::init() failed\n");
return false;
}
return true;
}
void IOFWController::free()
{
super::free();
}
bool IOFWController::publishProperties()
{
bool ret = false;
IOFWAddress addr;
OSDictionary * dict;
do {
if (super::publishProperties() == false)
break;
if ( (getHardwareAddress(&addr) != kIOReturnSuccess) ||
(setProperty(kIOMACAddress, (void *) &addr,
kIOFWAddressSize) == false) )
{
break;
}
dict = OSDynamicCast(OSDictionary, getProperty(kIOPacketFilters));
if ( dict )
{
UInt32 filters;
OSNumber * num;
if ( getPacketFilters(gIOEthernetWakeOnLANFilterGroup,
&filters) != kIOReturnSuccess )
{
break;
}
num = OSNumber::withNumber(filters, sizeof(filters) * 8);
if (num == 0)
break;
ret = dict->setObject(gIOEthernetWakeOnLANFilterGroup, num);
num->release();
}
}
while (false);
return ret;
}
IOReturn
IOFWController::setHardwareAddress(const IOFWAddress * addr)
{
return kIOReturnUnsupported;
}
IOReturn IOFWController::setMulticastMode(bool active)
{
return kIOReturnUnsupported;
}
IOReturn IOFWController::setPromiscuousMode(bool active)
{
return kIOReturnUnsupported;
}
IOReturn IOFWController::setWakeOnMagicPacket(bool active)
{
return kIOReturnUnsupported;
}
IOReturn IOFWController::setMulticastList(IOFWAddress * ,
UInt32 )
{
return kIOReturnUnsupported;
}
IONetworkInterface * IOFWController::createInterface()
{
IOFWInterface * netif = new IOFWInterface;
if ( netif && ( netif->init( this ) == false ) )
{
netif->release();
netif = 0;
}
return netif;
}
IOReturn
IOFWController::getPacketFilters(const OSSymbol * group,
UInt32 * filters) const
{
*filters = 0;
if ( group == gIONetworkFilterGroup )
{
return getPacketFilters(filters);
}
else
{
return kIOReturnSuccess;
}
}
IOReturn IOFWController::getPacketFilters(UInt32 * filters) const
{
*filters = ( kIOPacketFilterUnicast |
kIOPacketFilterBroadcast |
kIOPacketFilterMulticast |
kIOPacketFilterPromiscuous );
return kIOReturnSuccess;
}
#define UCAST_BCAST_MASK \
( kIOPacketFilterUnicast | kIOPacketFilterBroadcast )
IOReturn IOFWController::enablePacketFilter(
const OSSymbol * group,
UInt32 aFilter,
UInt32 enabledFilters,
IOOptionBits options)
{
IOReturn ret = kIOReturnUnsupported;
UInt32 newFilters = enabledFilters | aFilter;
if ( group == gIONetworkFilterGroup )
{
if ( aFilter == kIOPacketFilterMulticast )
{
ret = setMulticastMode(true);
}
else if ( aFilter == kIOPacketFilterPromiscuous )
{
ret = setPromiscuousMode(true);
}
else if ( (newFilters ^ enabledFilters) & UCAST_BCAST_MASK )
{
ret = kIOReturnSuccess;
}
}
else if ( group == gIOEthernetWakeOnLANFilterGroup )
{
if ( aFilter == kIOFWWakeOnMagicPacket )
{
ret = setWakeOnMagicPacket(true);
}
}
return ret;
}
IOReturn IOFWController::disablePacketFilter(
const OSSymbol * group,
UInt32 aFilter,
UInt32 enabledFilters,
IOOptionBits options)
{
IOReturn ret = kIOReturnUnsupported;
UInt32 newFilters = enabledFilters & ~aFilter;
if ( group == gIONetworkFilterGroup )
{
if ( aFilter == kIOPacketFilterMulticast )
{
ret = setMulticastMode(false);
}
else if ( aFilter == kIOPacketFilterPromiscuous )
{
ret = setPromiscuousMode(false);
}
else if ( (newFilters ^ enabledFilters) & UCAST_BCAST_MASK )
{
ret = kIOReturnSuccess;
}
}
else if ( group == gIOEthernetWakeOnLANFilterGroup )
{
if ( aFilter == kIOFWWakeOnMagicPacket )
{
ret = setWakeOnMagicPacket(false);
}
}
return ret;
}
IOReturn
IOFWController::getHardwareAddress(void * addr,
UInt32 * inOutAddrBytes)
{
UInt32 bufBytes;
if (inOutAddrBytes == 0)
return kIOReturnBadArgument;
bufBytes = *inOutAddrBytes;
*inOutAddrBytes = kIOFWAddressSize;
if ((addr == 0) || (bufBytes < kIOFWAddressSize))
return kIOReturnNoSpace;
return getHardwareAddress((IOFWAddress *) addr);
}
IOReturn
IOFWController::setHardwareAddress(const void * addr,
UInt32 addrBytes)
{
if ((addr == 0) || (addrBytes != kIOFWAddressSize))
return kIOReturnBadArgument;
return setHardwareAddress((const IOFWAddress *) addr);
}
IOReturn IOFWController::getMaxPacketSize(UInt32 * maxSize) const
{
*maxSize = kIOFWMaxPacketSize;
return kIOReturnSuccess;
}
IOReturn IOFWController::getMinPacketSize(UInt32 * minSize) const
{
*minSize = kIOFWMinPacketSize;
return kIOReturnSuccess;
}