/*
 * 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;	
}