test_mem.c

基于Linux的ffmepg decoder

#define TEST_MEM_GLOBALS
#include <stdlib.h>
#include "portab.h"
#include "vpe_m.h"
#ifdef LINUX
#include "../../faraday_mpeg4_common/dev_mem.h"
#else

int32_t dma_malloc(int size, void ** phy, void ** virt, void ** virt_ret)
{
	*phy = *virt = (void *) malloc(size);
	if (*virt != NULL)
		return 0;	//ok
	else
		return -1;//fail
}
int dma_free(uint32_t size, void * phy, void * virt, void *virt_ret)
{
	free ((uint8_t *)virt);
	return 0;	//ok
}
#endif
void * TM_DmaMalloc(uint32_t size, uint8_t align_size, uint8_t reserved_size, void ** phy_ptr)
{
	uint8_t *virt_mem_ptr;
	uint8_t *virt_ret;
//	uint32_t tsize;

	if (!align_size) {
		size += (reserved_size + 9);
	   	if (dma_malloc(size, phy_ptr, (void **)&virt_mem_ptr, (void **)&virt_ret) == 0) {
			/* Store (mem_ptr - "real allocated memory") in *(mem_ptr-9) */
			*(virt_mem_ptr + 0) = 9;
			/* Store (malloc size) in *(mem_ptr-8) ~ *(mem_ptr-5)*/
			*(virt_mem_ptr + 1) = (size >> 24) & 0xFF;
			*(virt_mem_ptr + 2) = (size >> 16) & 0xFF;
			*(virt_mem_ptr + 3) = (size >> 8) & 0xFF;
			*(virt_mem_ptr + 4) = (size >> 0) & 0xFF;
			/* Store (virt_ret at consistent_alloc) in *(mem_ptr-4) ~ *(mem_ptr-1)*/
			*(virt_mem_ptr + 5) = ((uint32_t)virt_ret >> 24) & 0xFF;
			*(virt_mem_ptr + 6) = ((uint32_t)virt_ret >> 16) & 0xFF;
			*(virt_mem_ptr + 7) = ((uint32_t)virt_ret >> 8) & 0xFF;
			*(virt_mem_ptr + 8) = ((uint32_t)virt_ret >> 0) & 0xFF;
			*(uint32_t *)phy_ptr += 9;
			/* Return the mem_ptr pointer */
			return (void *) (virt_mem_ptr + 9);
		}
	}
	else {
		uint8_t *tmp;

		/*
		 * Allocate the required size memory + alignment so we
		 * can realign the data if necessary
		 */
		size += (reserved_size + align_size + 8);
	   	if (dma_malloc(size, phy_ptr, (void **)&tmp, (void **)&virt_ret) == 0) {

			/* Align the tmp pointer */
			virt_mem_ptr =
				(uint8_t *) ((ptr_t) (tmp + 8 + align_size - 1) &
							 (~(ptr_t) (align_size - 1)));

			/*
			 * Special case where malloc have already satisfied the alignment
			 * We must add alignment to mem_ptr because we must store
			 * (mem_ptr - tmp) in *(mem_ptr-1)
			 * If we do not add alignment to mem_ptr then *(mem_ptr-1) points
			 * to a forbidden memory space
			 */
			while ((virt_mem_ptr - tmp) <= 8)
				virt_mem_ptr += align_size;
			*(uint32_t *)phy_ptr += (virt_mem_ptr - tmp);

			/*
			 * (mem_ptr - tmp) is stored in *(mem_ptr-1) so we are able to retrieve
			 * the real malloc block allocated and free it in free_align
			 */
			/* Store (mem_ptr - "real allocated memory") in *(mem_ptr-5) */
			*(virt_mem_ptr - 9) = (uint8_t) (virt_mem_ptr - tmp);
			/* Store (malloc size) in *(mem_ptr-8) ~ *(mem_ptr-5)*/
			*(virt_mem_ptr - 8) = (size >> 24) & 0xFF;
			*(virt_mem_ptr - 7) = (size >> 16) & 0xFF;
			*(virt_mem_ptr - 6) = (size >> 8) & 0xFF;
			*(virt_mem_ptr - 5) = (size >> 0) & 0xFF;
			/* Store (virt_ret at consistent_alloc) in *(mem_ptr-4) ~ *(mem_ptr-1)*/
			*(virt_mem_ptr - 4) = ((uint32_t)virt_ret >> 24) & 0xFF;
			*(virt_mem_ptr - 3) = ((uint32_t)virt_ret >> 16) & 0xFF;
			*(virt_mem_ptr - 2) = ((uint32_t)virt_ret >> 8) & 0xFF;
			*(virt_mem_ptr - 1) = ((uint32_t)virt_ret >> 0) & 0xFF;

mVpe_Indicator(0x94000000 + ((uint32_t)virt_mem_ptr >> 16) & 0xFFFF);
mVpe_Indicator(0x94100000 + ((uint32_t)virt_mem_ptr >> 0) & 0xFFFF);
			/* Return the aligned pointer */
			return (void *) virt_mem_ptr;
		}
	}

	return NULL;
}


void TM_DmaFree(void * virt_ptr, void * phy_ptr)
{
	uint32_t tsize;
	uint8_t *virt_ret;
	uint8_t offset;

	/* *(virt_mem_ptr - 1) give us the offset to the real malloc block */
	if (virt_ptr) {
		offset = *(uint8_t *) ((uint32_t) virt_ptr - 9);
		tsize = (*(uint8_t *)((uint32_t) virt_ptr - 8) << 24) +
		  	(*(uint8_t *)((uint32_t) virt_ptr - 7) << 16) +
			(*(uint8_t *)((uint32_t) virt_ptr - 6) << 8) +
			(*(uint8_t *)((uint32_t) virt_ptr - 5) << 0);
		virt_ret = (uint8_t*)((*(uint8_t *)((uint32_t) virt_ptr - 4) << 24) +
						(*(uint8_t *)((uint32_t) virt_ptr - 3) << 16) +
						(*(uint8_t *)((uint32_t) virt_ptr - 2) << 8) +
						(*(uint8_t *)((uint32_t) virt_ptr - 1) << 0));
		dma_free(tsize,								// total size
				(void *)((uint32_t) phy_ptr - offset),	// original phy point
				(void *)((uint32_t) virt_ptr - offset),		// original virt point
				virt_ret);					// 
 	}
}