minix/netbsd
1
0
Fork 0
mirror of https://github.com/Stichting-MINIX-Research-Foundation/netbsd.git synced 2025-08-10 06:29:51 -04:00
Code Issues Packages Projects Releases Wiki Activity
netbsd/sys/dev/pci/n8/common/n8_memory.c
Lionel Sambuc 58d5f9a2a4 2012/10/17 12:00:00 UTC
2013-04-06 16:48:33 +02:00

809 lines
30 KiB
C
Raw Permalink Blame History

/*-
* Copyright (C) 2001-2003 by NBMK Encryption Technologies.
* All rights reserved.
*
* NBMK Encryption Technologies provides no support of any kind for
* this software. Questions or concerns about it may be addressed to
* the members of the relevant open-source community at
* <tech-crypto@netbsd.org>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*****************************************************************************
* @(#) n8_memory.c 1.47@(#)
*****************************************************************************/
/*****************************************************************************/
/** @file n8_memory.c *
* @brief Memory Services - Cross-Platform *
* *
* This file implements the kernel only portions of the memory allocation *
* and management service for the NSP2000 devices, to accomplish two basic *
* objectives : *
* *
* - Size limitations in allocation requests. Linux only allows up to *
* 128K to be allocated in a single call. n8_memory enables the api *
* to allocate larger physically contiguous space. *
* *
* n8_memoryInit - *
* Obtains the large allocated space. It allocates the large pool *
* with n8_GetLargeAllocation (platform-specific). *
* n8_memory_Release - *
* Purges the allocation map and deallocates the large allocation space.*
* *
*****************************************************************************/
/*****************************************************************************
* Revision history:
* 02/17/04 jpw Change n8_memoryInit() memory allocation failure messages
* to kernel warning level and make it clear that the driver
* has not loaded. Suggest reserving space with bigphysarea
* 05/08/03 brr Reworked user pools to make better use of multiple driver
* banks. Moved user pool setup into the kernel.
* 05/02/03 brr Reset global pointer when memory is freed.
* 04/30/03 brr Reconcile differences between 2.4 & 3.0 baselines.
* 04/22/03 brr Correct semaphore initialization problem.
* 04/22/03 brr Removed redundant parameter from n8_FreeLargeAllocation.
* 04/21/03 brr Added support for multiple memory banks.
* 11/25/02 brr Clean up comments and format to coding standards.
* 11/01/02 brr Correct order of resource deallocation in n8_memoryRelease.
* 10/25/02 brr Clean up function prototypes & include files.
* 07/02/02 brr Added N8_QueryMemStatistics & access curAllocated as an
* atomic variable.
* 06/26/02 brr Remove bank parameter from calls to N8_PhysToVirt.
* 06/25/02 brr Rework user pool allocation to only mmap portion used by
* the individual process.
* 06/14/02 hml Change the type of an allocated buffer to
* N8_MEMORY_KERNEL_BUFFER and store the physical address of the
* bank in the memory struct.
* 06/12/02 hml Calls to N8_PhysToVirt now take the bank parameter. We
* also set the bank index in N8_BufferAllocate call.
* 06/11/02 hml Added include of n8_semaphore.h.
* 06/11/02 hml Use the new process sem calls instead of *Atomic*.
* 06/11/02 hml Removed some dangling prototypes.
* 06/10/02 hml Make n8_memoryRelease check for a NULL pointer.
* 06/10/02 hml Moved some functionality into n8_manage_memory.c.
* 05/22/02 hml Removed use of global variables and moved allocation map
* into the allocated space.
* 04/30/02 brr Do not memset the buffer to zero in N8_AllocateBuffer.
* 04/06/02 brr Make print for memory init already complete conditional.
* 03/27/02 brr Removed semaphore from free function since they are called
* from interrupt context and are not needed. Rework allocation
* so they are done in a round robin fashon.
* 03/26/02 brr Modified pfreeSessID to not free buffers on the command queue.
* 03/22/02 brr Move clearing of memory out of n8_pmalloc to avoid two calls
* to PhysToVirt.
* 03/22/02 hml N8_AllocateBuffer now calls N8_GET_SESSION_ID instead of
* hardcoding a session id.
* 03/18/02 brr Pass sessionID into allocate & free functions.
* 03/13/02 brr Make n8_memoryInit reentrant to support BSD initialization.
* 03/08/02 brr Removed use of N8_UTIL_MALLOC.
* 02/26/02 brr Redo some of the print statements.
* 02/22/02 spm Converted printk's to DBG's. Added include of n8_OS_intf.h.
* 02/18/02 brr Renamed management fuctions to match those in n8_driver_api.c
* 02/14/02 brr Reconcile memory management differences with 2.0.
* 01/17/02 brr Function name cleanup.
* 01/11/02 bac Added debug messages to warn if the driver is forced to clean
* up after an exiting process. Also, track the users requested
* allocation size in bytes.
* 12/20/01 brr Use numBlocks instead of sessionID to determine availability.
* This allows driver to do static allocations with session ID 0.
* 12/19/01 brr Reset firstFreeIndex in n8_pfreeSessID.
* 12/18/01 brr Added n8_pfreeSessID.
* 12/14/01 brr Memory management performance improvements.
* 05/17/01 mmd Original version.
****************************************************************************/
/** @defgroup NSP2000Driver Memory Allocation Services - Cross-Platform.
*/
#include "n8_OS_intf.h"
#include "helper.h"
#include "n8_driver_parms.h"
#include "n8_driver_api.h"
#include "n8_malloc_common.h"
#include "n8_memory.h"
#include "n8_semaphore.h"
#include "n8_version.h"
#include "userPool.h"
/* Local global that indicates whether debugging messages are enabled */
static int DebugFlag_g = 0;
/* The control structures for all memory banks */
MemBankCtl_t *memBankCtl_gp[N8_MEMBANK_MAX + DEF_USER_POOL_BANKS] = {NULL};
void n8_calculateSize(MemBankCtl_t *memCtl_p, unsigned long size);
void n8_setupAllocatedMemory(MemBankCtl_t *memCtl_p, unsigned long size);
/*****************************************************************************
* n8_memoryDebug
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief Enable/disable debug messages.
*
* This routine enables or disables debug messages in the n8 memory module.
*
* @par Externals:
* DebugFlag_g RO: Switch to enable/disable debug messages.
*
* @return
* N/A
*
* @par Errors:
* See return section for error information.
*****************************************************************************/
void n8_memoryDebug(int enable)
{
DebugFlag_g = enable;
}
/*****************************************************************************
* n8_memoryDisplay
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief Display contents of allocation map.
*
* This debugging routine simply displays the contents of the allocation map
* via the standard kernel debugging message facility. It also assumes that
* the caller has properly locked the allocation map.
*
* @param memCtl_p RW: The memory bank in question. The result of this
* function is stored in the maxEntries field.
*
* @return
* N/A
*
* @par Errors:
* See return section for error information.
*****************************************************************************/
void n8_memoryDisplay(N8_MemoryType_t bank)
{
int idx = 0;
MemCtlList_t* memCtlList_p;
MemBankCtl_t *memCtl_p = memBankCtl_gp[bank];
if (memCtl_p->maxEntries == 0)
{
return;
}
N8_PRINT( "n8_memory: " N8_VERSION_STRING);
N8_PRINT( "n8_memory: <******* PHYSICAL ALLOCATION MAP STATISTICS ******>\n");
N8_PRINT( "n8_memory: Memory Allocated for bank %d - %d KB\n",
bank, memCtl_p->allocSize / N8_ONE_KILOBYTE);
N8_PRINT( "n8_memory: Memory Granularity for this bank - %ld \n",
memCtl_p->granularity );
N8_PRINT( "n8_memory: Current Allocation - %d / %d blocks %d %%\n",
n8_atomic_read(memCtl_p->curAllocated), memCtl_p->maxEntries,
((n8_atomic_read(memCtl_p->curAllocated) * 100)/ memCtl_p->maxEntries));
N8_PRINT( "n8_memory: Maximum Allocation - %d / %d blocks %d %%\n",
memCtl_p->maxAllocated, memCtl_p->maxEntries,
((memCtl_p->maxAllocated * 100)/ memCtl_p->maxEntries));
N8_PRINT( "n8_memory: Failed Allocations - %d, Next Index - %d\n",
memCtl_p->failedAllocs, memCtl_p->nextIndex);
N8_PRINT( "n8_memory: <******* PHYSICAL ALLOCATION MAP START at %lx *******>\n",
memCtl_p->memBaseAddress );
memCtlList_p = (MemCtlList_t *)
N8_PhysToVirt(memCtl_p->memBaseAddress + sizeof(MemBankCtl_t));
while (idx < memCtl_p->maxEntries)
{
if (memCtlList_p[idx].numBlocks)
{
N8_PRINT( "n8_memory: #%04d-Addr=%08lx SessID=%08d Num Blocks=%d \n",
idx,
(int)memCtl_p->memBankPtr + (idx * memCtl_p->granularity),
memCtlList_p[idx].sessionID,
memCtlList_p[idx].numBlocks);
idx += memCtlList_p[idx].numBlocks;
}
else
{
idx++;
}
}
N8_PRINT( "n8_memory: <********* PHYSICAL ALLOCATION MAP END ***********>\n");
return;
}
/*****************************************************************************
* n8_calculateSize
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief Calculate the number of blocks of a given granularity that can
* be carved out of a contiguous memory area of a given size, given
* the need for the management structure to be part of the memory area.
*
* Time to revisit Algebra I!
*
* The diagram below shows the layout of the
* allocated space. First we have the space for the MemBankCtl_t
* structure. This is the constant M. Next we have the
* space for the memory control list for the area. The size of this
* area = sizeof(MemCtlList_t) (N) * the number of data blocks that can
* fit in the remainder of the buffer (C). This depends on the total size
* of the buffer. The remainder of the used space in the buffer (D) is
* composed of C data blocks each of size granularity (G). Of course, we
* have between 0 and G - 1 bytes wasted at the end of the buffer.
*
* ////////////////////////////////////////////////////////////////
* / / / /
* /<--- M -------->/<--- N * C ------->/<------- D ------------->/
* / (MemBankCtl_t) / (MemCtlList_t * /<----- C * G ----------->/
* / / Count of blocks) / (Data = C * Granularity)/
* / / / /
* ////////////////////////////////////////////////////////////////
* | |
* |<----- S (Total size of buffer) ----->|
*
* This gives us the following equations:
*
* 1) S = M + (N * C) + D
* 2) C = D / G
*
* Substiting D/G for C in 1 gives
*
* 3) S = M + (N * (D/G) + D
*
* By combining terms and subtraction we have
*
* 4) S - M = (N * D)/ G + D
*
* Multiplying both sides by G yields
*
* 5) G * (S - M) = (N * D) + (G * D) = (N + G) * D
*
* Now divide both sides by (N + G) to get
*
* 6) (G * (S - M))/(N + G) = D
*
* What we actually want is C. Since C = D/G, we can divide both sides by
* G and get
*
* 7) (S - M)/(N + G) = C
*
* Since G, S, M and N are all constant we can now get the number of data
* blocks (C).
*
* @param memCtl_p RW: The memory bank in question. The result of this
* function is stored in the maxEntries field.
* @param size RO: The size of the memory bank.
*
* @par Externals:
* Debug_g RO: Switch to enable/disable debug messages. <BR>
*
* @return
* NULL pointer if process failed
*
* @par Errors:
* We will set the maxEntries field to 0 if size is NULL.
*****************************************************************************/
void n8_calculateSize(MemBankCtl_t *memCtl_p, unsigned long size)
{
unsigned int dividend; /* dividend of equation 7 */
unsigned int divisor; /* divisor of equation 7 */
/* Do some minimal error checking */
if (memCtl_p == NULL)
{
return;
}
else if (size <= sizeof(MemBankCtl_t))
{
memCtl_p->maxEntries = 0;
return;
}
/* Equation 7 */
dividend = size - sizeof(MemBankCtl_t);
divisor = sizeof(MemCtlList_t) + memCtl_p->granularity;
/* Integer divide is good, since we want complete blocks */
memCtl_p->maxEntries = dividend / divisor;
}
/*****************************************************************************
* n8_setupAllocatedMemory
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief API - n8_memory initialization after the large allocation.
*
* This routine should be called after a large memory block such as a
* bank or a pool is allocated. The routine sets up the memBankCtl structure
* and initializes the allocation map. It does not do the initilization of the
* lock, which can be done before or after this routine is called.
*
* @param memCtl_p RW: Virtual pointer to the memBankCtl_t to initialize.
* @param size RO: The size of the allocated block.
*
* @par Externals:
* Debug_g RO: Switch to enable/disable debug messages. <BR>
*
* @return
* NULL pointer if process failed
* non-NULL void physical pointer to the base of the big allocation
*
* @par Errors:
* See return section for error information.
*
* @par Assumptions:
* We assume that the granularity field of the MemBankCtl_t structure is set
* before this routine is called and that memCtl_p is a virtual pointer
*****************************************************************************/
void n8_setupAllocatedMemory(MemBankCtl_t *memCtl_p, unsigned long size)
{
int ctlListSize;
/* Save the total size of the allocated block */
memCtl_p->allocSize = size;
/* Calculate the maximum number of entries */
n8_calculateSize(memCtl_p, size);
/* INITIALIZE ALLOCATION LIST AND MARK BANK BOUNDARIES */
memCtl_p->nextIndex = 0;
n8_atomic_set(memCtl_p->curAllocated, 0);
memCtl_p->maxAllocated = 0;
memCtl_p->failedAllocs = 0;
/* Set the mem bank ptr to the address after the bank control structure
and the allocation map rounded up to next granularity. */
memCtl_p->memBankPtr = (char *)(memCtl_p->memBaseAddress +
(((size/memCtl_p->granularity) - memCtl_p->maxEntries) *memCtl_p->granularity));
/* Clear the allocation map */
ctlListSize = sizeof(MemCtlList_t) * memCtl_p->maxEntries;
memset(&memCtl_p->memCtlList, 0, ctlListSize);
}
/*****************************************************************************
* n8_memoryInit
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief API - n8_memory initialization and large allocation.
*
* This routine should be called when a driver is loaded and initialized,
* before making any other n8_memory calls. It first performs some OS-specific
* tasks to allocate the requested large memory size, from physically
* contiguous memory. If it fails, we immediately free everything and return
* a NULL pointer. If successful, we return a pointer to the base of the
* entire big allocation. which the caller may use or discard as it sees fit -
* it is not needed again.
*
* @param bank RO: Index which specifies the enumerated bank type
* @param size RO: Specifies the desired allocation size per bank
* @param granularity RO: The size of the smallest allocation.
*
* @par Externals:
* memBankCtl_gp RW: Global pointers to memory control structures<BR>
*
* @return
* NULL pointer if process failed
* non-NULL void physical pointer to the base of the allocation
*
* @par Errors:
* See return section for error information.
*****************************************************************************/
void *n8_memoryInit(N8_MemoryType_t bank,
unsigned long size,
unsigned long granularity)
{
MemBankCtl_t tmpBankCtl;
MemBankCtl_t *memBankCtl_p = memBankCtl_gp[bank];
if (bank >= N8_MEMBANK_MAX+DEF_USER_POOL_BANKS)
{
return NULL;
}
if (memBankCtl_p != NULL)
{
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "n8_memoryInit: Initialize already complete exiting...\n");
}
return (void *)((memBankCtl_p)->memBaseAddress);
}
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "n8_memoryInit: size = %ld.\n", size);
}
/* We are using the temporary bank pointer because on at least one
OS we support (linux) we need some of the space in the memBankCtl
to complete the large allocation. Because we want to end up with
the memBankCtl in the allocated space, we use a temporary that
is allocated automatically, then copy the temp structure into the
allocated space after the large allocation is complete. */
/* Insure everything starts nice and clean */
memset(&tmpBankCtl, 0x0, sizeof(tmpBankCtl));
/* Set the desired granularity and bank */
tmpBankCtl.granularity = granularity;
tmpBankCtl.bankIndex = bank;
/* Perform OS-specific large allocation */
tmpBankCtl.memBaseAddress = n8_GetLargeAllocation(bank, size, DebugFlag_g);
if (!tmpBankCtl.memBaseAddress)
{
N8_PRINT(KERN_WARNING "NSP2000: n8_memoryInit: Failed to allocate %ld bytes, bank %d .\n", size, bank);
N8_PRINT(KERN_WARNING "NSP2000: Driver NOT loaded. \n");
N8_PRINT(KERN_WARNING "NSP2000: Reserve space with bigphysarea patch \n");
N8_PRINT(KERN_WARNING "NSP2000: or decrease EA or PK Pool request.\n");
return NULL;
}
/* Set the memBankCtl pointer to the virtual address of the beginning
of the block */
memBankCtl_p = (MemBankCtl_t *) N8_PhysToVirt(tmpBankCtl.memBaseAddress);
/* Copy the tmp structure to inside the allocated block */
memcpy(memBankCtl_p, &tmpBankCtl, sizeof(MemBankCtl_t));
/* Set up the atomic lock */
N8_initProcessSem(&(memBankCtl_p->allocationMapLock));
/* Setup the memBankCtl_p and the allocation map */
n8_setupAllocatedMemory(memBankCtl_p, size);
memBankCtl_gp[bank] = memBankCtl_p;
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "n8_memoryInit: returning %lx.\n", memBankCtl_p->memBaseAddress);
}
/* Return the physical (non-zero) address */
return (void *)((memBankCtl_p)->memBaseAddress);
}
/*****************************************************************************
* n8_memoryRelease
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief API - Memory deactivation and release.
*
* This routine deallocates and releases the large space allocated with
* n8_memoryInit.
*
* @param bank RO: Index which specifies the enumerated bank type
*
* @par Externals:
* memBankCtl_gp RO: Global pointers to memory control structures<BR>
*
* @return
* N/A
*
* @par Errors:
* See return section for error information.
*****************************************************************************/
void n8_memoryRelease(N8_MemoryType_t bank)
{
MemBankCtl_t *memCtl_p = memBankCtl_gp[bank];
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "n8_memoryRelease: bank = %d, memCtl_p %p.\n", bank, memCtl_p);
}
/* Check for null in case this is called because the second memory
segment was not created. */
if (memCtl_p == NULL)
{
return;
}
N8_acquireProcessSem(&memCtl_p->allocationMapLock);
memBankCtl_gp[bank] = NULL;
N8_releaseProcessSem(&memCtl_p->allocationMapLock);
memCtl_p->memBaseAddress = 0;
N8_deleteProcessSem(&memCtl_p->allocationMapLock);
n8_FreeLargeAllocation(bank, DebugFlag_g);
}
/*****************************************************************************
* n8_pfreeSessID
*****************************************************************************/
/** @ingroup NSP2000Driver
* @brief API - Releases a all allocations of a given session ID.
*
*
* @param bank RO: Index which specifies the enumerated bank type
* @param sessionID R0: Session ID of the exiting process.
*
* @par Externals:
* memBankCtl_gp RO: Global pointers to memory control structures<BR>
* Debug_g RO: Global flag that indicates whether debugging<BR>
* messages are enabled. <BR>
*
* @return
* N/A
*
* @par Errors:
* See return section for error information.
*****************************************************************************/
void n8_pfreeSessID(N8_MemoryType_t bank, unsigned long sessionID)
{
MemCtlList_t *memCtlList_p;
int index;
int numBlocks;
N8_MemoryHandle_t *kmem_p;
MemBankCtl_t *memCtl_p = memBankCtl_gp[bank];
if (memCtl_p == NULL)
{
return;
}
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "n8_pfreeSessID: sessionID %ld, for bank %d\n",
sessionID, bank);
}
/* Retrieve the memCltList_p in the bank structure. */
memCtlList_p = &memCtl_p->memCtlList[0];
index = 0;
while (index < memCtl_p->maxEntries)
{
/* If this entry been allocated, see if it matches our session ID */
if (memCtlList_p[index].numBlocks)
{
numBlocks = memCtlList_p[index].numBlocks;
/* Determine whether this entry matches the sessionID passed int */
if (memCtlList_p[index].sessionID == sessionID)
{
char *ptr;
ptr = index * memCtl_p->granularity + memCtl_p->memBankPtr;
/* If we have a match on the session ID, convert the pointer to */
/* a virtual address to determine whether it is currently in use */
/* by one of the command queues. */
kmem_p = (N8_MemoryHandle_t *)N8_PhysToVirt((int)ptr);
if (kmem_p->bufferState != N8_BUFFER_QUEUED)
{
/* The Buffer is not on a command queue, free it. */
if (DebugFlag_g)
{
N8_PRINT("Kernel mem leak on exit %d bytes at %lx\n",
memCtlList_p[index].reqSize, (unsigned long) ptr);
}
n8_pfree(memCtl_p->bankIndex, ptr);
}
else
{
/* Mark the buffer so QMgr frees it
when the command has completed */
if (DebugFlag_g)
{
N8_PRINT(KERN_CRIT "Kernel mem leak on exit"
"skipped queued buffer %d bytes at %lx\n",
memCtlList_p[index].reqSize, (unsigned long) ptr);
}
kmem_p->bufferState = N8_BUFFER_SESS_DELETED;
}
}
index += numBlocks;
}
else
{
index++;
}
}
return;
}
/*****************************************************************************
* N8_AllocateBuffer
*****************************************************************************/
/** @ingroup NSP2000_Driver_API
* @brief Allocates a buffer and maps it between user and kernel space.
*
* This routine first requests that the driver allocate a physically
* contiguous memory space of a specified size. With the returned physical
* base address, it then maps it to user-space.
*
* The N8_MemoryHandle_t should be treated as read-only upon return from this
* call, for subsequent calls to N8_TestBuffer and N8_FreeBuffer.
*
* @param size RO: Amount of memory to allocate.
*
* @par Externals:
* MemBankCtl_p RW: Bank control structure to allocate from.
*
* @return
* Address of the new memory handle or NULL if the allocation could not be
* completed.
* @par Errors:
* See return section for error information.
*****************************************************************************/
N8_MemoryHandle_t *N8_AllocateBuffer(const unsigned int size)
{
N8_MemoryHandle_t *buffPtr;
unsigned long physaddr;
unsigned long sessionID = N8_GET_KERNEL_ID;
/* Do not attempt allocations of zero size */
if (!size)
{
return NULL;
}
/* Allocate a buffer from the physically contigious pool */
if ((physaddr = n8_pmalloc(N8_MEMBANK_EA,size + N8_BUFFER_HEADER_SIZE, sessionID)) == 0)
{
return NULL;
}
/* Set up a N8_MemoryHandle in the head of the buffer */
buffPtr = (N8_MemoryHandle_t *)N8_PhysToVirt(physaddr);
/* Ensure the buffer is cleared */
/* memset(buffPtr, 0x0, size + N8_BUFFER_HEADER_SIZE); */
buffPtr->Size = size;
buffPtr->PhysicalAddress = physaddr + N8_BUFFER_HEADER_SIZE;
buffPtr->VirtualAddress = (unsigned long *)((int)buffPtr + N8_BUFFER_HEADER_SIZE);
buffPtr->bankPhysAddress = memBankCtl_gp[N8_MEMBANK_EA]->memBaseAddress;
buffPtr->bankAddress = (unsigned long) memBankCtl_gp[N8_MEMBANK_EA];
buffPtr->bankIndex = N8_MEMBANK_EA;
return buffPtr;
}
N8_MemoryHandle_t *N8_AllocateBufferPK(const unsigned int size)
{
N8_MemoryHandle_t *buffPtr;
unsigned long physaddr;
unsigned long sessionID = N8_GET_KERNEL_ID;
/* Do not attempt allocations of zero size */
if (!size)
{
return NULL;
}
/* Allocate a buffer from the physically contigious pool */
if ((physaddr = n8_pmalloc(N8_MEMBANK_PK,size + N8_BUFFER_HEADER_SIZE, sessionID)) == 0)
{
return NULL;
}
/* Set up a N8_MemoryHandle in the head of the buffer */
buffPtr =
(N8_MemoryHandle_t *)N8_PhysToVirt(physaddr);
/* Ensure the buffer is cleared */
/* memset(buffPtr, 0x0, size + N8_BUFFER_HEADER_SIZE); */
buffPtr->Size = size;
buffPtr->PhysicalAddress = physaddr + N8_BUFFER_HEADER_SIZE;
buffPtr->VirtualAddress = (unsigned long *)((int)buffPtr + N8_BUFFER_HEADER_SIZE);
buffPtr->bankPhysAddress = memBankCtl_gp[N8_MEMBANK_PK]->memBaseAddress;
buffPtr->bankAddress = (unsigned long) memBankCtl_gp[N8_MEMBANK_PK];
buffPtr->bankIndex = N8_MEMBANK_PK;
return buffPtr;
}
/*****************************************************************************
* N8_FreeBuffer
*****************************************************************************/
/** @ingroup NSP2000_Driver_API
* @brief Releases and unmaps buffers allocated with N8_AllocateBuffer.
*
* This routine follows two steps. It first unmaps the specified buffer from
* user-space. It then requests that the driver free the buffer. Because
* unique keys are used to identify buffers, only if a corresponding buffer is
* located, is anything freed. If not found, nothing happens.
*
* @param MemoryStruct RO: Pointer to a struct that associates the necessary
* parameters that completely identify an allocated
* buffer.
*
* @par Externals:
* N/A
*
* @return
* N/A
*
* @par Errors:
* See return section for error information.
*
* NOTE: THIS FUNCTION MAY BE CALLED FROM INTERRUPT CONTEXT and cannot take
* semaphores or print. It also assumes it will only be called to free
* buffers allocted from the kernel buffer allocation pool.
*****************************************************************************/
void N8_FreeBuffer(N8_MemoryHandle_t *MemoryStruct_p)
{
/* DIRECT DRIVER TO DEALLOCATE THE BUSMASTERED BUFFER */
n8_pfree(MemoryStruct_p->bankIndex,
(void *)(MemoryStruct_p->PhysicalAddress - N8_BUFFER_HEADER_SIZE));
}
N8_Status_t N8_QueryMemStatistics(MemStats_t *memStatsPtr)
{
int bankIndex;
MemBankCtl_t *memCtl_p;
for (bankIndex = 0; bankIndex <= N8_MEMBANK_PK; bankIndex++)
{
memCtl_p = memBankCtl_gp[bankIndex];
/* Retrieve stats for the base kernel buffer pool */
memStatsPtr->curAllocated = n8_atomic_read(memCtl_p->curAllocated);
memStatsPtr->maxAllocated = memCtl_p->maxAllocated;
memStatsPtr->maxEntries = memCtl_p->maxEntries;
memStatsPtr->failedAllocs = memCtl_p->failedAllocs;
memStatsPtr++;
}
return (N8_STATUS_OK);
}
Reference in New Issue View Git Blame Copy Permalink