243 lines
7.4 KiB
C
243 lines
7.4 KiB
C
/*
|
|
* Copyright 2001-2008 Texas Instruments - http://www.ti.com/
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* ======== memry.h ========
|
|
* DSP-BIOS Bridge driver support functions for TI OMAP processors.
|
|
* Purpose:
|
|
* Functional interface for the memory manager, exported by the DSP
|
|
* system API DLL. This interface is not publicly documented.
|
|
*
|
|
* Public Functions:
|
|
* MEMRY_Alloc
|
|
* MEMRY_BindMem
|
|
* MEMRY_Calloc
|
|
* MEMRY_Free
|
|
* MEMRY_FreeVM
|
|
* MEMRY_LinearAddress
|
|
* MEMRY_ReserveVM
|
|
* MEMRY_PageLock
|
|
* MEMRY_PageUnlock
|
|
* MEMRY_UnMapLinearAddress
|
|
*
|
|
*! Revision History:
|
|
*! ================
|
|
*! 01-Sep-2001 ag: Added MEMRY_[UnMap]LinearAddress.
|
|
*! 11-Oct-2000 ag: Added MEMRY_Reserve[Free]VM() & MEMRY_BindMem().
|
|
*! 12-Nov-1999 kc: Updated for WinCE.
|
|
*!
|
|
*/
|
|
|
|
#ifndef MEMRY_
|
|
#define MEMRY_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <dspapi.h>
|
|
|
|
#include <memdefs.h>
|
|
|
|
/*
|
|
* MEMRY_[GET]SET]VIRTUALSEGID is used by Node & Strm to access virtual
|
|
* address space in the correct client process context. The virtual to
|
|
* physical mapping is done in the client process context.
|
|
*/
|
|
#define MEMRY_SETVIRTUALSEGID MEM_SETVIRTUALSEGID
|
|
#define MEMRY_GETVIRTUALSEGID MEM_GETVIRTUALSEGID
|
|
#define MEMRY_MASKVIRTUALSEGID MEM_MASKVIRTUALSEGID
|
|
|
|
#ifndef LINUX
|
|
|
|
/*
|
|
* ======== MEMRY_Alloc ========
|
|
* Purpose:
|
|
* Allocate memory from the paged or non-paged pools.
|
|
* Parameters:
|
|
* cBytes: Number of bytes to allocate.
|
|
* type: Type of memory to allocate; one of:
|
|
* - MEM_PAGED: Allocate from the pageable memory.
|
|
* - MEM_NONPAGED:Allocate from page locked memory.
|
|
* Returns:
|
|
* Pointer to a block of memory; or NULL if memory couldn't be
|
|
* allocated.
|
|
* Requires:
|
|
* Ensures:
|
|
* PVOID pointer returned is a valid memory location.
|
|
*/
|
|
extern PVOID MEMRY_Alloc(ULONG cBytes, MEM_POOLATTRS type);
|
|
|
|
/*
|
|
* ======== MEMRY_BindBuf ========
|
|
* Purpose:
|
|
* Bind a Physical address to a Virtual Address.
|
|
* In WinCE performs a VirtualCopy().
|
|
* Parameters:
|
|
* pVA: Ptr to reserved memory allocated by MEMRY_ReserveVM().
|
|
* pPA: Ptr to a physical memory location.
|
|
* ulBytes: Size of physical memory in bytes.
|
|
* Returns:
|
|
* TRUE if successful, else FALSE.
|
|
* Requires:
|
|
* pPA != NULL.
|
|
* Ensures:
|
|
*/
|
|
extern bool MEMRY_BindMem(PVOID pVA, PVOID pPA, ULONG ulBytes);
|
|
|
|
/*
|
|
* ======== MEMRY_Calloc ========
|
|
* Purpose:
|
|
* Allocate zero-initialized memory from the paged or non-paged pools.
|
|
* Parameters:
|
|
* cBytes: Number of bytes to allocate.
|
|
* type: Type of memory to allocate; one of:
|
|
* - MEM_PAGED: Allocate from the pageable memory.
|
|
* - MEM_NONPAGED: Allocate from page locked memory.
|
|
* Returns:
|
|
* Pointer to a contiguous block of zeroed memory; or NULL if memory
|
|
* couldn't be allocated.
|
|
* Requires:
|
|
* Ensures:
|
|
* PVOID pointer returned is a valid memory location.
|
|
*/
|
|
extern PVOID WINAPI MEMRY_Calloc(ULONG cBytes, MEM_POOLATTRS type);
|
|
|
|
/*
|
|
* ======== MEMRY_Free ========
|
|
* Purpose:
|
|
* Free the given block of system memory.
|
|
* Parameters:
|
|
* pMemBuf: Pointer to memory allocated by MEMRY_Alloc().
|
|
* Returns:
|
|
* Requires:
|
|
* Ensures:
|
|
* pMemBuf is no longer a valid pointer to memory.
|
|
*/
|
|
extern VOID MEMRY_Free(IN PVOID pMemBuf);
|
|
|
|
/*
|
|
* ======== MEMRY_FreeVM ========
|
|
* Purpose:
|
|
* Free VM reserved by MEMRY_ReserveVM.
|
|
* Parameters:
|
|
* pVirtualAddr: Pointer to memory VM allocated by MEMRY_ReserveVM().
|
|
* Returns:
|
|
* TRUE on success, else FALSE.
|
|
* Requires:
|
|
* pVirtualAddr != 0
|
|
* Ensures:
|
|
*
|
|
*/
|
|
extern bool MEMRY_FreeVM(PVOID pVirtualAddr);
|
|
|
|
/*
|
|
* ======== MEMRY_PageLock ========
|
|
* Purpose:
|
|
* Calls kernel services to map the set of pages identified by a private
|
|
* process pointer and a byte count into the calling process's globally
|
|
* shared address space.
|
|
* Parameters
|
|
* lpBuffer: Pointer to a process-private data buffer.
|
|
* cSize: Size in bytes of the data buffer.
|
|
* Returns:
|
|
* A pointer to linear page locked memory, or
|
|
* NULL if failure locking memory.
|
|
* Requires:
|
|
* The size (cSize) must accurately reflect the size of the buffer to
|
|
* be locked, since the page count is derived from this number.
|
|
* Ensures:
|
|
* Memory locked by this service can be accessed at interrupt time, or
|
|
* from other memory contexts.
|
|
*/
|
|
extern DSPAPIDLL PVOID WINAPI MEMRY_PageLock(PVOID pBuffer,
|
|
ULONG cSize);
|
|
|
|
#endif /* ifndef LINUX */
|
|
|
|
/*
|
|
* ======== MEMRY_LinearAddress ========
|
|
* Purpose:
|
|
* Get the linear address corresponding to the given physical address.
|
|
* Parameters:
|
|
* pPhysAddr: Physical address to be mapped.
|
|
* cBytes: Number of bytes in physical range to map.
|
|
* Returns:
|
|
* The corresponding linear address, or NULL if unsuccessful.
|
|
* Requires:
|
|
* PhysAddr != 0
|
|
* Ensures:
|
|
* Notes:
|
|
* If valid linear address is returned, be sure to call
|
|
* MEMRY_UnMapLinearAddress().
|
|
*/
|
|
extern inline PVOID MEMRY_LinearAddress(PVOID pPhyAddr, ULONG cBytes) {
|
|
return pPhyAddr;
|
|
}
|
|
#ifndef LINUX
|
|
/*
|
|
* ======== MEMRY_PageUnlock ========
|
|
* Purpose:
|
|
* Unlocks a buffer previously locked using MEMRY_PageLock().
|
|
* Parameters:
|
|
* pBuffer: Pointer to locked memory (as returned by MEMRY_PageLock()).
|
|
* cSize: Size in bytes of the buffer.
|
|
* Returns:
|
|
* Returns DSP_SOK if unlock successful; else, returns DSP_EFAIL;
|
|
* Requires:
|
|
* pBuffer must be a pointer to a locked, shared data buffer previously
|
|
* locked with MEMRY_PageLock().
|
|
* Ensures:
|
|
* Will unlock the pages of memory when the lock count drops to zero.
|
|
* MEMRY_PageLock() increments the lock count, and MEMRY_PageUnlock
|
|
* decrements the count.
|
|
*/ extern DSPAPIDLL MEMRY_PageUnlock(PVOID pBuffer, ULONG cSize);
|
|
|
|
/*
|
|
* ======== MEMRY_ReserveVM ========
|
|
* Purpose:
|
|
* Reserve at least ulBytes (page size inc) virtual memory for this process.
|
|
* Parameters:
|
|
* ulBytes: Size in bytes of the minimum space to reserve.
|
|
* Returns:
|
|
* Returns NULL on failure, else valid VA of at least ulBytes size.
|
|
* Requires:
|
|
* Ensures:
|
|
*/
|
|
extern PVOID MEMRY_ReserveVM(ULONG cBytes);
|
|
|
|
#endif /* ifndef LINUX */
|
|
|
|
/*
|
|
* ======== MEMRY_UnMapLinearAddress ========
|
|
* Purpose:
|
|
* Unmap the linear address mapped in MEMRY_LinearAddress.
|
|
* Parameters:
|
|
* pBaseAddr: Ptr to mapped memory (as returned by MEMRY_LinearAddress()).
|
|
* Returns:
|
|
* Requires:
|
|
* - pBaseAddr is a valid linear address mapped in MEMRY_LinearAddress.
|
|
* Ensures:
|
|
* - pBaseAddr no longer points to a valid linear address.
|
|
*/
|
|
extern inline VOID MEMRY_UnMapLinearAddress(PVOID pBaseAddr) {
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* MEMRY_ */
|