/*
|
* sdram_hp.c
|
* Description:
|
*
|
* Created on: 2014-10-8
|
* Author: DELL
|
* Modify:
|
*/
|
#include <stdio.h>
|
#include <assert.h>
|
#include <stdlib.h>
|
#include "hmem.h"
|
|
//int _heap_install(void *base, size_t length, int userid, int pmdm /* -1 dm, 1 pm */);
|
|
#define dm_size (32*1024)//-6080*2)
|
#define pm_size (0*1024)
|
#define dm_static_size (16*1024)
|
#define sdram_size (1024*1024*8)
|
|
static int* pdm=0,*ppm=0, *pdm_static =0,*psdram =0 ;
|
static int dm_index =0 ,pm_index=0,sdram_index=0 ,dm_static_index=0;
|
static unsigned short total_inner_mem = 0;
|
|
static void dm_mem_init(void)
|
{
|
pdm = (void*)0x000e0000;//(void*)malloc(dm_size);(void*)0x000e0000;
|
assert(pdm!=0);
|
dm_index =0;
|
|
pdm_static = (void*)0x000b8000;
|
}
|
|
static void* dm_static_malloc(int size)
|
{
|
void* p = pdm_static + dm_static_index;
|
|
if(dm_static_index + size > dm_static_size){
|
return 0;
|
}
|
|
dm_static_index += size;
|
|
return p;
|
}
|
|
static void* dm_malloc(int size)
|
{
|
void* p = pdm+dm_index;
|
|
|
if(dm_index + size>dm_size){
|
return 0;
|
}
|
|
dm_index += size;
|
|
return p;
|
}
|
|
|
static void dm_entrie_free(void)
|
{
|
dm_index=0;
|
dm_static_index =0;
|
}
|
|
|
static void pm_mem_init(void)
|
{
|
ppm = (void*)0x000C5000;
|
// assert(size<=pm_size);
|
pm_index =0;
|
}
|
|
|
static void pm* pm_malloc(int size)
|
{
|
void* p = ppm+pm_index;
|
|
|
if(pm_index + size>pm_size){
|
return 0;
|
}
|
pm_index += size;
|
|
return (void pm*)p;
|
}
|
|
|
|
static void pm_entrie_free(void)
|
{
|
pm_index=0;
|
}
|
|
|
static void sdram_mem_init(void)
|
{
|
//sdram_index = heap_install((void*)0x00800000, sdram_size, 999, -1);
|
psdram = (void*)0x00660000;
|
|
sdram_index =0;
|
//assert (sdram_index > 0);
|
}
|
|
static void* sdram_malloc(int size)
|
{
|
//return heap_malloc(sdram_index,size);
|
|
void* p = psdram+sdram_index;
|
|
|
if(sdram_index + size>sdram_size){
|
return 0;
|
}
|
|
sdram_index += size;
|
|
return p;
|
}
|
|
static void sdram_free(void* _ptr)
|
{
|
//heap_free(sdram_index, _ptr);
|
}
|
|
|
static void sdram_entrie_free(void)
|
{
|
sdram_index =0;
|
}
|
|
|
|
uvoid hmem_init()
|
{
|
sdram_mem_init();
|
|
dm_mem_init();
|
|
pm_mem_init();
|
|
total_inner_mem = dm_size + pm_size + dm_static_size;
|
}
|
|
uvoidptr mymalloc(mymalloc_style type, uint32_t size)
|
{
|
uvoidptr ptr = unull;
|
|
switch(type){
|
case SRAM_DM:
|
ptr = dm_malloc(size);
|
if(ptr == unull){
|
ptr = dm_static_malloc(size);
|
}
|
break;
|
case SRAM_PM:
|
ptr = pm_malloc(size);
|
break;
|
case SRAM_DDR:
|
ptr = sdram_malloc(size);
|
break;
|
case SRAM_AUTO:
|
ptr = dm_static_malloc(size);
|
if(ptr == unull){
|
ptr = pm_malloc(size);
|
}
|
if(ptr == unull){
|
ptr = dm_malloc(size);
|
}
|
if(ptr == unull){
|
ptr = sdram_malloc(size);
|
}
|
break;
|
}
|
if(ptr == unull){
|
ptr = unull;
|
}
|
return ptr;
|
}
|
|
uvoid myfree(mymalloc_style type, uvoidptr ptr)
|
{
|
switch(type){
|
case SRAM_DM:
|
|
break;
|
case SRAM_PM:
|
|
break;
|
case SRAM_DDR:
|
sdram_free(ptr);
|
break;
|
case SRAM_AUTO:
|
|
break;
|
}
|
}
|
|
short hmem_perused(mymalloc_style type)
|
{
|
short used =0;
|
float used_ratio = 0;
|
|
switch(type){
|
case SRAM_DM:
|
used = dm_index+dm_static_index;
|
used = used*100/(dm_size+dm_static_size);
|
break;
|
case SRAM_PM:
|
// used = pm_index;
|
// used = used*100/pm_size;
|
break;
|
case SRAM_DDR:
|
used = sdram_index;
|
used = used*100/sdram_size;
|
break;
|
case SRAM_AUTO:
|
used = dm_index+dm_static_index + pm_index;
|
used_ratio = ((float)used)/((float)total_inner_mem);
|
used = used_ratio*10000;
|
//used = used*100/(dm_size+pm_size+dm_static_size);
|
break;
|
}
|
|
return used;
|
}
|
|
uvoid hmem_free()
|
{
|
dm_entrie_free();
|
pm_entrie_free();
|
sdram_entrie_free();
|
}
|
|
void* sram_malloc(int memtype , int size)
|
{
|
void* p = 0;
|
|
if(memtype == 2) {
|
p =mymalloc(SRAM_DDR, size);
|
}
|
else {
|
p = mymalloc(SRAM_AUTO, size);
|
}
|
|
return p;
|
}
|
|
void sram_free(int memtype ,void* ptr)
|
{
|
|
}
|
|
int sram_free_space(int memtype)
|
{
|
return 0;
|
}
|
