void
MolEnet::free()
{
int i;
if( is_open ) {
OSI_Enet2Cntrl( kEnet2Reset );
OSI_Enet2Close();
}
if( getWorkLoop() )
getWorkLoop()->disableAllEventSources();
if( _irq )
_irq->release();
if( transmitQueue )
transmitQueue->release();
if( networkInterface )
networkInterface->release();
if( rxMBufCursor )
rxMBufCursor->release();
if( txMBufCursor )
txMBufCursor->release();
if( mediumDict )
mediumDict->release();
if( rx_ring )
IOFreeContiguous( rx_ring, sizeof(enet2_ring_t) * RX_NUM_EL );
if( tx_ring )
IOFreeContiguous( tx_ring, sizeof(enet2_ring_t) * TX_NUM_EL );
if( workLoop ) {
workLoop->release();
workLoop = 0;
}
for( i=0; i<RX_NUM_EL; i++ )
if( rxMBuf[i] )
freePacket( rxMBuf[i] );
// free packets in progress
super::free();
}
RTR0DECL(void) RTMemContFree(void *pv, size_t cb)
{
RT_ASSERT_PREEMPTIBLE();
if (pv)
{
Assert(cb > 0);
AssertMsg(!((uintptr_t)pv & PAGE_OFFSET_MASK), ("pv=%p\n", pv));
IPRT_DARWIN_SAVE_EFL_AC();
cb = RT_ALIGN_Z(cb, PAGE_SIZE);
IOFreeContiguous(pv, cb);
IPRT_DARWIN_RESTORE_EFL_AC();
}
}
IOReturn AppleI386AGP::destroyAGPSpace( IOAGPDevice * master )
{
setAGPEnable( master, false, 0 );
if( gartArray) {
// IOMapPages( kernel_map, (vm_address_t) gartArray, gartPhys, gartLength, kIOMapDefaultCache );
IOFreeContiguous( (void *) gartArray, gartLength);
gartArray = 0;
}
if( agpRange) {
agpRange->release();
agpRange = 0;
}
if( systemLength)
systemLength = 0;
return( kIOReturnSuccess );
}
/*
* free:
*
* Free resources
*/
void IOBufferMemoryDescriptor::free()
{
// Cache all of the relevant information on the stack for use
// after we call super::free()!
IOOptionBits options = _options;
vm_size_t size = _capacity;
void * buffer = _buffer;
vm_map_t map = 0;
vm_offset_t alignment = _alignment;
if (reserved)
{
map = reserved->map;
IODelete( reserved, ExpansionData, 1 );
}
/* super::free may unwire - deallocate buffer afterwards */
super::free();
if (buffer)
{
if (options & kIOMemoryPageable)
{
if (map)
vm_deallocate(map, (vm_address_t) buffer, round_page_32(size));
else
IOFreePageable(buffer, size);
}
else
{
if (options & kIOMemoryPhysicallyContiguous)
IOFreeContiguous(buffer, size);
else if (alignment > 1)
IOFreeAligned(buffer, size);
else
IOFree(buffer, size);
}
}
if (map)
vm_map_deallocate(map);
}
RTR0DECL(void *) RTMemContAlloc(PRTCCPHYS pPhys, size_t cb)
{
/*
* validate input.
*/
AssertPtr(pPhys);
Assert(cb > 0);
RT_ASSERT_PREEMPTIBLE();
IPRT_DARWIN_SAVE_EFL_AC();
/*
* Allocate the memory and ensure that the API is still providing
* memory that's always below 4GB.
*/
cb = RT_ALIGN_Z(cb, PAGE_SIZE);
IOPhysicalAddress PhysAddr;
void *pv = IOMallocContiguous(cb, PAGE_SIZE, &PhysAddr);
if (pv)
{
if (PhysAddr + (cb - 1) <= (IOPhysicalAddress)0xffffffff)
{
if (!((uintptr_t)pv & PAGE_OFFSET_MASK))
{
*pPhys = PhysAddr;
IPRT_DARWIN_RESTORE_EFL_AC();
return pv;
}
AssertMsgFailed(("IOMallocContiguous didn't return a page aligned address - %p!\n", pv));
}
else
AssertMsgFailed(("IOMallocContiguous returned high address! PhysAddr=%RX64 cb=%#zx\n", (uint64_t)PhysAddr, cb));
IOFreeContiguous(pv, cb);
}
IPRT_DARWIN_RESTORE_EFL_AC();
return NULL;
}
void
free_kvar_pages( kernel_vars_t *kv )
{
IOFreeContiguous( kv, NUM_KVARS_PAGES * 0x1000 );
}
bool AppleMacIO::selfTest( void )
{
IODBDMADescriptor *dmaDescriptors;
UInt32 dmaDescriptorsPhys;
UInt32 i;
UInt32 status;
IODBDMADescriptor *dmaDesc;
volatile IODBDMAChannelRegisters *ioBaseDMA;
bool ok = false;
enum { kTestChannel = 0x8000 };
ioBaseDMA = (volatile IODBDMAChannelRegisters *)
(((UInt32)fMemory->getVirtualAddress())
+ kTestChannel );
do {
dmaDescriptors = (IODBDMADescriptor *)IOMallocContiguous(page_size, 1, & dmaDescriptorsPhys);
if (!dmaDescriptors)
continue;
if ( (UInt32)dmaDescriptors & (page_size - 1) ) {
IOLog("AppleMacIO::%s() - DMA Descriptor memory not page aligned!!", __FUNCTION__);
continue;
}
bzero( dmaDescriptors, page_size );
IODBDMAReset( ioBaseDMA );
dmaDesc = dmaDescriptors;
IOMakeDBDMADescriptor( dmaDesc,
kdbdmaNop,
kdbdmaKeyStream0,
kdbdmaIntNever,
kdbdmaBranchNever,
kdbdmaWaitNever,
0,
0 );
dmaDesc++;
IOMakeDBDMADescriptorDep( dmaDesc,
kdbdmaStoreQuad,
kdbdmaKeySystem,
kdbdmaIntNever,
kdbdmaBranchNever,
kdbdmaWaitNever,
4,
dmaDescriptorsPhys+16*sizeof(IODBDMADescriptor),
0x12345678 );
dmaDesc++;
IOMakeDBDMADescriptor( dmaDesc,
kdbdmaStop,
kdbdmaKeyStream0,
kdbdmaIntNever,
kdbdmaBranchNever,
kdbdmaWaitNever,
0,
0 );
for ( i = 0; (!ok) && (i < 3); i++ )
{
dmaDescriptors[16].operation = 0;
IOSetDBDMACommandPtr( ioBaseDMA, dmaDescriptorsPhys );
IODBDMAContinue( ioBaseDMA );
IODelay( 200 );
status = IOGetDBDMAChannelStatus( ioBaseDMA );
if ( ((status & kdbdmaActive) == 0)
&& ((status & kdbdmaDead) == 0)
&& (OSReadSwapInt32( &dmaDescriptors[16].operation, 0 ) == 0x12345678 ))
ok = true;
}
IODBDMAReset( ioBaseDMA );
} while (false);
if (dmaDescriptors)
IOFreeContiguous(dmaDescriptors, page_size);
return ok;
}
