mirror of
https://github.com/dimoniche/solarium.git
synced 2026-01-30 09:53:30 +03:00
435 lines
19 KiB
Plaintext
435 lines
19 KiB
Plaintext
/*
|
||
*********************************************************************************************************
|
||
* uC/OS-II
|
||
* The Real-Time Kernel
|
||
* MEMORY MANAGEMENT
|
||
*
|
||
* (c) Copyright 1992-2007, Jean J. Labrosse, Weston, FL
|
||
* All Rights Reserved
|
||
*
|
||
* File : OS_MEM.C
|
||
* By : Jean J. Labrosse
|
||
* Version : V2.85
|
||
*
|
||
* LICENSING TERMS:
|
||
* ---------------
|
||
* uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.
|
||
* If you plan on using uC/OS-II in a commercial product you need to contact Micriµm to properly license
|
||
* its use in your product. We provide ALL the source code for your convenience and to help you experience
|
||
* uC/OS-II. The fact that the source is provided does NOT mean that you can use it without paying a
|
||
* licensing fee.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#ifndef OS_MASTER_FILE
|
||
#include <ucos_ii.h>
|
||
#endif
|
||
|
||
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
|
||
/*
|
||
*********************************************************************************************************
|
||
* CREATE A MEMORY PARTITION
|
||
*
|
||
* Description : Create a fixed-sized memory partition that will be managed by uC/OS-II.
|
||
*
|
||
* Arguments : addr is the starting address of the memory partition
|
||
*
|
||
* nblks is the number of memory blocks to create from the partition.
|
||
*
|
||
* blksize is the size (in bytes) of each block in the memory partition.
|
||
*
|
||
* perr is a pointer to a variable containing an error message which will be set by
|
||
* this function to either:
|
||
*
|
||
* OS_ERR_NONE if the memory partition has been created correctly.
|
||
* OS_ERR_MEM_INVALID_ADDR if you are specifying an invalid address for the memory
|
||
* storage of the partition or, the block does not align
|
||
* on a pointer boundary
|
||
* OS_ERR_MEM_INVALID_PART no free partitions available
|
||
* OS_ERR_MEM_INVALID_BLKS user specified an invalid number of blocks (must be >= 2)
|
||
* OS_ERR_MEM_INVALID_SIZE user specified an invalid block size
|
||
* - must be greater than the size of a pointer
|
||
* - must be able to hold an integral number of pointers
|
||
* Returns : != (OS_MEM *)0 is the partition was created
|
||
* == (OS_MEM *)0 if the partition was not created because of invalid arguments or, no
|
||
* free partition is available.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
OS_MEM *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *perr)
|
||
{
|
||
OS_MEM *pmem;
|
||
INT8U *pblk;
|
||
void **plink;
|
||
INT32U i;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (perr == (INT8U *)0) { /* Validate 'perr' */
|
||
return ((OS_MEM *)0);
|
||
}
|
||
if (addr == (void *)0) { /* Must pass a valid address for the memory part.*/
|
||
*perr = OS_ERR_MEM_INVALID_ADDR;
|
||
return ((OS_MEM *)0);
|
||
}
|
||
if (((INT32U)addr & (sizeof(void *) - 1)) != 0){ /* Must be pointer size aligned */
|
||
*perr = OS_ERR_MEM_INVALID_ADDR;
|
||
return ((OS_MEM *)0);
|
||
}
|
||
if (nblks < 2) { /* Must have at least 2 blocks per partition */
|
||
*perr = OS_ERR_MEM_INVALID_BLKS;
|
||
return ((OS_MEM *)0);
|
||
}
|
||
if (blksize < sizeof(void *)) { /* Must contain space for at least a pointer */
|
||
*perr = OS_ERR_MEM_INVALID_SIZE;
|
||
return ((OS_MEM *)0);
|
||
}
|
||
#endif
|
||
OS_ENTER_CRITICAL();
|
||
pmem = OSMemFreeList; /* Get next free memory partition */
|
||
if (OSMemFreeList != (OS_MEM *)0) { /* See if pool of free partitions was empty */
|
||
OSMemFreeList = (OS_MEM *)OSMemFreeList->OSMemFreeList;
|
||
}
|
||
OS_EXIT_CRITICAL();
|
||
if (pmem == (OS_MEM *)0) { /* See if we have a memory partition */
|
||
*perr = OS_ERR_MEM_INVALID_PART;
|
||
return ((OS_MEM *)0);
|
||
}
|
||
plink = (void **)addr; /* Create linked list of free memory blocks */
|
||
pblk = (INT8U *)((INT32U)addr + blksize);
|
||
for (i = 0; i < (nblks - 1); i++) {
|
||
*plink = (void *)pblk; /* Save pointer to NEXT block in CURRENT block */
|
||
plink = (void **)pblk; /* Position to NEXT block */
|
||
pblk = (INT8U *)((INT32U)pblk + blksize); /* Point to the FOLLOWING block */
|
||
}
|
||
*plink = (void *)0; /* Last memory block points to NULL */
|
||
pmem->OSMemAddr = addr; /* Store start address of memory partition */
|
||
pmem->OSMemFreeList = addr; /* Initialize pointer to pool of free blocks */
|
||
pmem->OSMemNFree = nblks; /* Store number of free blocks in MCB */
|
||
pmem->OSMemNBlks = nblks;
|
||
pmem->OSMemBlkSize = blksize; /* Store block size of each memory blocks */
|
||
*perr = OS_ERR_NONE;
|
||
return (pmem);
|
||
}
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* GET A MEMORY BLOCK
|
||
*
|
||
* Description : Get a memory block from a partition
|
||
*
|
||
* Arguments : pmem is a pointer to the memory partition control block
|
||
*
|
||
* perr is a pointer to a variable containing an error message which will be set by this
|
||
* function to either:
|
||
*
|
||
* OS_ERR_NONE if the memory partition has been created correctly.
|
||
* OS_ERR_MEM_NO_FREE_BLKS if there are no more free memory blocks to allocate to caller
|
||
* OS_ERR_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
|
||
*
|
||
* Returns : A pointer to a memory block if no error is detected
|
||
* A pointer to NULL if an error is detected
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
void *OSMemGet (OS_MEM *pmem, INT8U *perr)
|
||
{
|
||
void *pblk;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (perr == (INT8U *)0) { /* Validate 'perr' */
|
||
return ((void *)0);
|
||
}
|
||
if (pmem == (OS_MEM *)0) { /* Must point to a valid memory partition */
|
||
*perr = OS_ERR_MEM_INVALID_PMEM;
|
||
return ((void *)0);
|
||
}
|
||
#endif
|
||
OS_ENTER_CRITICAL();
|
||
if (pmem->OSMemNFree > 0) { /* See if there are any free memory blocks */
|
||
pblk = pmem->OSMemFreeList; /* Yes, point to next free memory block */
|
||
pmem->OSMemFreeList = *(void **)pblk; /* Adjust pointer to new free list */
|
||
pmem->OSMemNFree--; /* One less memory block in this partition */
|
||
OS_EXIT_CRITICAL();
|
||
*perr = OS_ERR_NONE; /* No error */
|
||
return (pblk); /* Return memory block to caller */
|
||
}
|
||
OS_EXIT_CRITICAL();
|
||
*perr = OS_ERR_MEM_NO_FREE_BLKS; /* No, Notify caller of empty memory partition */
|
||
return ((void *)0); /* Return NULL pointer to caller */
|
||
}
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* GET THE NAME OF A MEMORY PARTITION
|
||
*
|
||
* Description: This function is used to obtain the name assigned to a memory partition.
|
||
*
|
||
* Arguments : pmem is a pointer to the memory partition
|
||
*
|
||
* pname is a pointer to an ASCII string that will receive the name of the memory partition.
|
||
*
|
||
* perr is a pointer to an error code that can contain one of the following values:
|
||
*
|
||
* OS_ERR_NONE if the name was copied to 'pname'
|
||
* OS_ERR_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
|
||
* OS_ERR_PNAME_NULL You passed a NULL pointer for 'pname'
|
||
* OS_ERR_NAME_GET_ISR You called this function from an ISR
|
||
*
|
||
* Returns : The length of the string or 0 if 'pmem' is a NULL pointer.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#if OS_MEM_NAME_SIZE > 1
|
||
INT8U OSMemNameGet (OS_MEM *pmem, INT8U *pname, INT8U *perr)
|
||
{
|
||
INT8U len;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (perr == (INT8U *)0) { /* Validate 'perr' */
|
||
return (0);
|
||
}
|
||
if (pmem == (OS_MEM *)0) { /* Is 'pmem' a NULL pointer? */
|
||
*perr = OS_ERR_MEM_INVALID_PMEM;
|
||
return (0);
|
||
}
|
||
if (pname == (INT8U *)0) { /* Is 'pname' a NULL pointer? */
|
||
*perr = OS_ERR_PNAME_NULL;
|
||
return (0);
|
||
}
|
||
#endif
|
||
if (OSIntNesting > 0) { /* See if trying to call from an ISR */
|
||
*perr = OS_ERR_NAME_GET_ISR;
|
||
return (0);
|
||
}
|
||
OS_ENTER_CRITICAL();
|
||
len = OS_StrCopy(pname, pmem->OSMemName); /* Copy name from OS_MEM */
|
||
OS_EXIT_CRITICAL();
|
||
*perr = OS_ERR_NONE;
|
||
return (len);
|
||
}
|
||
#endif
|
||
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* ASSIGN A NAME TO A MEMORY PARTITION
|
||
*
|
||
* Description: This function assigns a name to a memory partition.
|
||
*
|
||
* Arguments : pmem is a pointer to the memory partition
|
||
*
|
||
* pname is a pointer to an ASCII string that contains the name of the memory partition.
|
||
*
|
||
* perr is a pointer to an error code that can contain one of the following values:
|
||
*
|
||
* OS_ERR_NONE if the name was copied to 'pname'
|
||
* OS_ERR_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
|
||
* OS_ERR_PNAME_NULL You passed a NULL pointer for 'pname'
|
||
* OS_ERR_MEM_NAME_TOO_LONG if the name doesn't fit in the storage area
|
||
* OS_ERR_NAME_SET_ISR if you called this function from an ISR
|
||
*
|
||
* Returns : None
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#if OS_MEM_NAME_SIZE > 1
|
||
void OSMemNameSet (OS_MEM *pmem, INT8U *pname, INT8U *perr)
|
||
{
|
||
INT8U len;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (perr == (INT8U *)0) { /* Validate 'perr' */
|
||
return;
|
||
}
|
||
if (pmem == (OS_MEM *)0) { /* Is 'pmem' a NULL pointer? */
|
||
*perr = OS_ERR_MEM_INVALID_PMEM;
|
||
return;
|
||
}
|
||
if (pname == (INT8U *)0) { /* Is 'pname' a NULL pointer? */
|
||
*perr = OS_ERR_PNAME_NULL;
|
||
return;
|
||
}
|
||
#endif
|
||
if (OSIntNesting > 0) { /* See if trying to call from an ISR */
|
||
*perr = OS_ERR_NAME_SET_ISR;
|
||
return;
|
||
}
|
||
OS_ENTER_CRITICAL();
|
||
len = OS_StrLen(pname); /* Can we fit the string in the storage area? */
|
||
if (len > (OS_MEM_NAME_SIZE - 1)) { /* No */
|
||
OS_EXIT_CRITICAL();
|
||
*perr = OS_ERR_MEM_NAME_TOO_LONG;
|
||
return;
|
||
}
|
||
(void)OS_StrCopy(pmem->OSMemName, pname); /* Yes, copy name to the memory partition header */
|
||
OS_EXIT_CRITICAL();
|
||
*perr = OS_ERR_NONE;
|
||
}
|
||
#endif
|
||
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* RELEASE A MEMORY BLOCK
|
||
*
|
||
* Description : Returns a memory block to a partition
|
||
*
|
||
* Arguments : pmem is a pointer to the memory partition control block
|
||
*
|
||
* pblk is a pointer to the memory block being released.
|
||
*
|
||
* Returns : OS_ERR_NONE if the memory block was inserted into the partition
|
||
* OS_ERR_MEM_FULL if you are returning a memory block to an already FULL memory
|
||
* partition (You freed more blocks than you allocated!)
|
||
* OS_ERR_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
|
||
* OS_ERR_MEM_INVALID_PBLK if you passed a NULL pointer for the block to release.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
INT8U OSMemPut (OS_MEM *pmem, void *pblk)
|
||
{
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (pmem == (OS_MEM *)0) { /* Must point to a valid memory partition */
|
||
return (OS_ERR_MEM_INVALID_PMEM);
|
||
}
|
||
if (pblk == (void *)0) { /* Must release a valid block */
|
||
return (OS_ERR_MEM_INVALID_PBLK);
|
||
}
|
||
#endif
|
||
OS_ENTER_CRITICAL();
|
||
if (pmem->OSMemNFree >= pmem->OSMemNBlks) { /* Make sure all blocks not already returned */
|
||
OS_EXIT_CRITICAL();
|
||
return (OS_ERR_MEM_FULL);
|
||
}
|
||
*(void **)pblk = pmem->OSMemFreeList; /* Insert released block into free block list */
|
||
pmem->OSMemFreeList = pblk;
|
||
pmem->OSMemNFree++; /* One more memory block in this partition */
|
||
OS_EXIT_CRITICAL();
|
||
return (OS_ERR_NONE); /* Notify caller that memory block was released */
|
||
}
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* QUERY MEMORY PARTITION
|
||
*
|
||
* Description : This function is used to determine the number of free memory blocks and the number of
|
||
* used memory blocks from a memory partition.
|
||
*
|
||
* Arguments : pmem is a pointer to the memory partition control block
|
||
*
|
||
* p_mem_data is a pointer to a structure that will contain information about the memory
|
||
* partition.
|
||
*
|
||
* Returns : OS_ERR_NONE if no errors were found.
|
||
* OS_ERR_MEM_INVALID_PMEM if you passed a NULL pointer for 'pmem'
|
||
* OS_ERR_MEM_INVALID_PDATA if you passed a NULL pointer to the data recipient.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#if OS_MEM_QUERY_EN > 0
|
||
INT8U OSMemQuery (OS_MEM *pmem, OS_MEM_DATA *p_mem_data)
|
||
{
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (pmem == (OS_MEM *)0) { /* Must point to a valid memory partition */
|
||
return (OS_ERR_MEM_INVALID_PMEM);
|
||
}
|
||
if (p_mem_data == (OS_MEM_DATA *)0) { /* Must release a valid storage area for the data */
|
||
return (OS_ERR_MEM_INVALID_PDATA);
|
||
}
|
||
#endif
|
||
OS_ENTER_CRITICAL();
|
||
p_mem_data->OSAddr = pmem->OSMemAddr;
|
||
p_mem_data->OSFreeList = pmem->OSMemFreeList;
|
||
p_mem_data->OSBlkSize = pmem->OSMemBlkSize;
|
||
p_mem_data->OSNBlks = pmem->OSMemNBlks;
|
||
p_mem_data->OSNFree = pmem->OSMemNFree;
|
||
OS_EXIT_CRITICAL();
|
||
p_mem_data->OSNUsed = p_mem_data->OSNBlks - p_mem_data->OSNFree;
|
||
return (OS_ERR_NONE);
|
||
}
|
||
#endif /* OS_MEM_QUERY_EN */
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* INITIALIZE MEMORY PARTITION MANAGER
|
||
*
|
||
* Description : This function is called by uC/OS-II to initialize the memory partition manager. Your
|
||
* application MUST NOT call this function.
|
||
*
|
||
* Arguments : none
|
||
*
|
||
* Returns : none
|
||
*
|
||
* Note(s) : This function is INTERNAL to uC/OS-II and your application should not call it.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
void OS_MemInit (void)
|
||
{
|
||
#if OS_MAX_MEM_PART == 1
|
||
OS_MemClr((INT8U *)&OSMemTbl[0], sizeof(OSMemTbl)); /* Clear the memory partition table */
|
||
OSMemFreeList = (OS_MEM *)&OSMemTbl[0]; /* Point to beginning of free list */
|
||
#if OS_MEM_NAME_SIZE > 1
|
||
OSMemFreeList->OSMemName[0] = '?'; /* Unknown name */
|
||
OSMemFreeList->OSMemName[1] = OS_ASCII_NUL;
|
||
#endif
|
||
#endif
|
||
|
||
#if OS_MAX_MEM_PART >= 2
|
||
OS_MEM *pmem;
|
||
INT16U i;
|
||
|
||
|
||
OS_MemClr((INT8U *)&OSMemTbl[0], sizeof(OSMemTbl)); /* Clear the memory partition table */
|
||
pmem = &OSMemTbl[0]; /* Point to memory control block (MCB) */
|
||
for (i = 0; i < (OS_MAX_MEM_PART - 1); i++) { /* Init. list of free memory partitions */
|
||
pmem->OSMemFreeList = (void *)&OSMemTbl[i+1]; /* Chain list of free partitions */
|
||
#if OS_MEM_NAME_SIZE > 1
|
||
pmem->OSMemName[0] = '?'; /* Unknown name */
|
||
pmem->OSMemName[1] = OS_ASCII_NUL;
|
||
#endif
|
||
pmem++;
|
||
}
|
||
pmem->OSMemFreeList = (void *)0; /* Initialize last node */
|
||
#if OS_MEM_NAME_SIZE > 1
|
||
pmem->OSMemName[0] = '?'; /* Unknown name */
|
||
pmem->OSMemName[1] = OS_ASCII_NUL;
|
||
#endif
|
||
|
||
OSMemFreeList = &OSMemTbl[0]; /* Point to beginning of free list */
|
||
#endif
|
||
}
|
||
#endif /* OS_MEM_EN */
|