CNdisSharedMemory::~CNdisSharedMemory()
{
if(m_VA != nullptr)
{
NdisMFreeSharedMemory(m_DrvHandle, m_Size, m_IsCached, m_VA, m_PA);
}
}
/**********************************************************
NDIS6 implementation of shared memory freeing
Parameters:
context
tCompletePhysicalAddress *pAddresses
the structure accumulates all our knowledge
about the allocation (size, addresses, cacheability etc)
filled by ParaNdis_InitialAllocatePhysicalMemory
***********************************************************/
VOID ParaNdis_FreePhysicalMemory(
PARANDIS_ADAPTER *pContext,
tCompletePhysicalAddress *pAddresses)
{
NdisMFreeSharedMemory(
pContext->MiniportHandle,
pAddresses->size,
TRUE,
pAddresses->Virtual,
pAddresses->Physical);
}
/* allocate one page of cached, shared (dma-able) or regular memory */
NDIS_STATUS
shared_allocpage(
IN shared_info_t *shared,
IN BOOLEAN shared_mem,
IN BOOLEAN cached,
OUT page_t *page
)
{
NDIS_STATUS status;
/* uncached not supported */
ASSERT(cached);
bzero(page, sizeof(page_t));
if (shared_mem) {
NdisMAllocateSharedMemory(shared->adapterhandle, PAGE_SIZE, cached,
(void **) &page->va, &page->pa);
/* Make sure that we got valid address */
if (!osl_dmaddr_valid(shared->osh, page->pa.LowPart, page->pa.HighPart)) {
ND_ERROR(("%s%d: shared_allocpage: pa not valid \n", shared->id,
shared->unit));
NdisMFreeSharedMemory(shared->adapterhandle, PAGE_SIZE,
cached, (PVOID)page->va, page->pa);
return (NDIS_STATUS_RESOURCES);
}
} else
page->va = MALLOC(shared->osh, PAGE_SIZE);
if (page->va == NULL) {
ND_ERROR(("%s%d: shared_allocpage: out of memory, malloced %d bytes\n", shared->id,
shared->unit, MALLOCED(shared->osh)));
return (NDIS_STATUS_RESOURCES);
}
ASSERT(!shared_mem || ISALIGNED((uintptr)page->va, PAGE_SIZE));
ASSERT(page->pa.HighPart == 0);
ASSERT(ISALIGNED(page->pa.LowPart, PAGE_SIZE));
status = NDIS_STATUS_SUCCESS;
return (status);
}
void
shared_lb_free(
IN shared_info_t *shared,
IN struct lbfree *l,
IN BOOLEAN shared_mem,
IN BOOLEAN cached
)
{
uint i;
int maxpages;
ND_TRACE(("%s%d: shared_lb_free\n", shared->id, shared->unit));
ASSERT(l->count <= l->total);
/* uncached not supported */
ASSERT(cached);
/* free all buffer memory pages */
for (i = 0; i < l->npages; i++) {
if (!shared_mem)
MFREE(shared->osh, l->pages[i].va, PAGE_SIZE);
else {
NdisMFreeSharedMemory(shared->adapterhandle, PAGE_SIZE, cached,
(PVOID)l->pages[i].va, l->pages[i].pa);
}
}
/* free the page list */
if (l->pages) {
maxpages = (l->total * l->size) / PAGE_SIZE;
MFREE(shared->osh, (uchar *) l->pages, maxpages * sizeof(page_t));
}
l->free = NULL;
l->total = 0;
l->count = 0;
l->pages = NULL;
l->npages = 0;
NdisFreeSpinLock(&l->queue_lock);
}
VOID
NTAPI
MiniportHalt (
IN NDIS_HANDLE MiniportAdapterContext
)
{
PRTL_ADAPTER adapter = (PRTL_ADAPTER)MiniportAdapterContext;
ASSERT(adapter != NULL);
//
// Interrupts need to stop first
//
if (adapter->InterruptRegistered != FALSE)
{
NdisMDeregisterInterrupt(&adapter->Interrupt);
}
//
// If we have a mapped IO port range, we can talk to the NIC
//
if (adapter->IoBase != NULL)
{
if (adapter->ReceiveBuffer != NULL)
{
//
// Disassociate our shared buffer before freeing it to avoid
// NIC-induced memory corruption
//
NICRemoveReceiveBuffer(adapter);
NdisMFreeSharedMemory(adapter->MiniportAdapterHandle,
adapter->ReceiveBufferLength,
FALSE,
adapter->ReceiveBuffer,
adapter->ReceiveBufferPa);
}
if (adapter->RuntTxBuffers != NULL)
{
NdisMFreeSharedMemory(adapter->MiniportAdapterHandle,
MINIMUM_FRAME_SIZE * TX_DESC_COUNT,
FALSE,
adapter->RuntTxBuffers,
adapter->RuntTxBuffersPa);
}
//
// Unregister the IO range
//
NdisMDeregisterIoPortRange(adapter->MiniportAdapterHandle,
adapter->IoRangeStart,
adapter->IoRangeLength,
adapter->IoBase);
}
//
// Destroy the adapter context
//
NdisFreeMemory(adapter, sizeof(*adapter), 0);
}
/*+
*
* FreeAdapterMemory
*
* Routine Description:
*
* Frees the memory previously allocated by
* AllocateAdapterMemory
*
* Arguments:
*
* Adapter - The adapter to deallocate memory for.
*
* Return Value:
*
* None.
*
-*/
extern
VOID
FreeAdapterMemory(
IN PDC21X4_ADAPTER Adapter
)
{
PDC21X4_RECEIVE_DESCRIPTOR ReceiveDescriptor;
PRCV_HEADER RcvHeader;
PNDIS_PACKET Packet;
UINT i;
if ((PVOID)Adapter->DescriptorRing.AllocVa == (PVOID)NULL) {
// AllocateAdapterMemory failed on the first allocation:
// no ressources were allocated
return;
}
for (i = 0,
ReceiveDescriptor = (PDC21X4_RECEIVE_DESCRIPTOR)Adapter->ReceiveDescriptorRingVa;
i < Adapter->ReceiveRingSize;
i++,
(PCHAR)ReceiveDescriptor += Adapter->DescriptorSize
) {
if (ReceiveDescriptor->RcvHeader) {
RcvHeader = ReceiveDescriptor->RcvHeader;
if (RcvHeader->FlushBuffer) {
NdisFreeBuffer(RcvHeader->FlushBuffer);
}
if (RcvHeader->Packet) {
NdisFreePacket(RcvHeader->Packet);
}
if (!Adapter->RcvBufferSpace.Va)
{
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
RcvHeader->AllocSize,
TRUE,
(PVOID)RcvHeader->AllocVa,
RcvHeader->AllocPa
);
}
}
}
while (Adapter->FreeRcvList != NULL) {
RcvHeader = Adapter->FreeRcvList;
Adapter->FreeRcvList = RcvHeader->Next;
if (RcvHeader->FlushBuffer) {
NdisFreeBuffer(RcvHeader->FlushBuffer);
}
if ( !Adapter->RcvBufferSpace.Va
&& RcvHeader->AllocVa)
{
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
RcvHeader->AllocSize,
TRUE,
(PVOID)RcvHeader->AllocVa,
RcvHeader->AllocPa
);
}
}
while (Adapter->FreePacketList != NULL)
{
Packet = Adapter->FreePacketList;
Adapter->FreePacketList = RCV_RESERVED(Packet)->Next;
if (NULL != Packet)
{
NdisFreePacket(Packet);
}
}
if (Adapter->RcvBufferSpace.Va) {
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
Adapter->RcvBufferSpace.AllocSize,
TRUE,
(PVOID)Adapter->RcvBufferSpace.AllocVa,
Adapter->RcvBufferSpace.AllocPa
);
}
if (Adapter->ReceivePacketPool) {
NdisFreePacketPool((PVOID)Adapter->ReceivePacketPool);
}
for (i = 0; i < DC21X4_NUMBER_OF_MAX_TRANSMIT_BUFFERS;i ++ ) {
if (Adapter->MaxTransmitBuffer[i].AllocVa) {
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
Adapter->MaxTransmitBuffer[i].AllocSize,
TRUE,
(PVOID)Adapter->MaxTransmitBuffer[i].AllocVa,
Adapter->MaxTransmitBuffer[i].AllocPa
);
}
if (Adapter->MaxTransmitBuffer[i].FlushBuffer) {
NdisFreeBuffer(Adapter->MaxTransmitBuffer[i].FlushBuffer);
}
}
if (Adapter->MinTransmitBuffer[0].AllocVa &&
!Adapter->DontUseMinTransmitBuffer) {
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
Adapter->MinTransmitBuffer[0].AllocSize,
TRUE,
(PVOID)Adapter->MinTransmitBuffer[0].AllocVa,
Adapter->MinTransmitBuffer[0].AllocPa
);
}
for (i = 0; i < DC21X4_NUMBER_OF_MIN_TRANSMIT_BUFFERS;i ++ ) {
if (Adapter->MinTransmitBuffer[i].FlushBuffer) {
NdisFreeBuffer(Adapter->MinTransmitBuffer[i].FlushBuffer);
}
}
if (Adapter->FlushBufferPoolHandle) {
NdisFreeBufferPool(Adapter->FlushBufferPoolHandle);
}
if (Adapter->DescriptorRing.AllocVa) {
NdisMFreeSharedMemory(
Adapter->MiniportAdapterHandle,
Adapter->DescriptorRing.AllocSize,
FALSE,
(PVOID)Adapter->DescriptorRing.AllocVa,
Adapter->DescriptorRing.AllocPa
);
}
}
