dma_mem.c

基于ARM核的HMS7202

#include "mon.h"
#include "dma_mem.h"
#include <reg7202.h>
#define BUFFER_MEM_BASE 0x40700000
#define BUFFER_MEM_END  (BUFFER_MEM_BASE + 0x00200000)

#define DMA_MEM_BASE 0x40700000
#define DMA_MEM_END  (DMA_MEM_BASE + 0x00400000)


_mem_t mem_list[] = {
#define LCD_DMA_BASE DMA_MEM_BASE
#define LCD_DMA_SIZE (320*240)
	{"lcd", DMA_TYPE, LCD_DMA_BASE, LCD_DMA_SIZE },

#define LAN_DMA_BASE (LCD_DMA_BASE+LCD_DMA_SIZE)
#define LAN_DMA_SIZE (4*1024)
	{"lan", DMA_TYPE, LAN_DMA_BASE, LAN_DMA_SIZE },

#define USB_DMA_BASE (LAN_DMA_BASE+LAN_DMA_SIZE)
#define USB_DMA_SIZE (1024*1024)
	{"usb", DMA_TYPE, USB_DMA_BASE, USB_DMA_SIZE },

#define SOUND_DMA_BASE (USB_DMA_BASE+USB_DMA_SIZE)
#define SOUND_DMA_SIZE (512*1024)
	{"sound", DMA_TYPE, SOUND_DMA_BASE, SOUND_DMA_SIZE },
#define I2S_DMA_BASE (SOUND_DMA_BASE+SOUND_DMA_SIZE)
#define I2S_DMA_SIZE (512*1024)
	{"I2S", DMA_TYPE, I2S_DMA_BASE, I2S_DMA_SIZE },

#define UART_BUFFER_BASE BUFFER_MEM_BASE
#define UART_BUFFER_SIZE (4*1024)
	{"uart", BUFFER_TYPE , UART_BUFFER_BASE, UART_BUFFER_SIZE },

#define LAN_BUFFER_BASE (UART_BUFFER_BASE + UART_BUFFER_SIZE)
#define LAN_BUFFER_SIZE (4*1024)
	{"lan", BUFFER_TYPE , LAN_BUFFER_BASE, LAN_BUFFER_SIZE },

#define SOUND_BUFFER_BASE (LAN_BUFFER_BASE+LAN_BUFFER_SIZE)
#define SOUND_BUFFER_SIZE (800*1024)
	{"sound", BUFFER_TYPE, SOUND_BUFFER_BASE, SOUND_BUFFER_SIZE },

#define USB_BUFFER_BASE (SOUND_BUFFER_BASE+SOUND_BUFFER_SIZE)
#define USB_BUFFER_SIZE (512*1024)
	{"usb", BUFFER_TYPE, USB_BUFFER_BASE, USB_BUFFER_SIZE },
	
#define ADC_BUFFER_BASE (USB_BUFFER_BASE+USB_BUFFER_SIZE)
#define ADC_BUFFER_SIZE (200*1024)
	{"adc", BUFFER_TYPE, ADC_BUFFER_BASE, ADC_BUFFER_SIZE },
};


static int entries = sizeof(mem_list) / sizeof(struct _mem_s);

int mem_init()
{
	ser_printf("DMA Memory base=0x%08X, end=0x%08X\n",DMA_MEM_BASE,DMA_MEM_END);
	ser_printf("BUFFER Memory base=0x%08X, end=0x%08X\n",BUFFER_MEM_BASE,BUFFER_MEM_END);
	if(check_mem_list() == MON_FAIL) {
		ser_printf("Check mem_list[] in %s\n", __FILE__);
		return MON_FAIL;
	}

	return MON_OK;

}
int check_mem_list()
{
	int i,j;
	_mem_t *mp;
	_mem_t *mp2;

	for(i=0; i < entries; i++) {
		mp = &mem_list[i];
//		ser_printf("Check %s : ", mp->name);
		if(mp->type == DMA_TYPE) {
//			ser_printf("DMA ");
			if(IS_DMA_SPACE(mp->base) && IS_DMA_SPACE(mp->base + mp->size)) {
//				ser_printf("OK ");
			}
			else {
//				ser_printf("INVALID ADDRESS SPACE -> FAIL\n");
				ser_printf("DMA %s :INVALID ADDRESS SPACE -> FAIL\n", mp->name);
				return MON_FAIL;
			}
		}
		else {
//			ser_printf("BUFFER ");
			if(IS_BUFFER_SPACE(mp->base) && IS_BUFFER_SPACE(mp->base + mp->size)) {
//				ser_printf("OK ");
			}
			else {
//				ser_printf("INVALID ADDRESS SPACE -> FAIL\n");
				ser_printf("BUFFER %s INVALID ADDRESS SPACE -> FAIL\n", mp->name);
				return MON_FAIL;
			}
		}

		for(j=0; j<i; j++){
			mp2 = &mem_list[j];
			if(mp2->type != mp->type)
				continue;
			if(IS_ADDRESS_IN(mp->base, mp2->base, mp2->size) &&
					IS_ADDRESS_IN( (mp->base+mp->size), mp2->base, mp2->size)) {
				ser_printf("Conflict with %s memory -> FAIL\n", mp2->name);
				return MON_FAIL;
			}	
		}
//		ser_printf("\n");
	}

	return MON_OK;
}

int get_dma_base_size(char *name, unsigned int *base, unsigned int *size)
{
	int i;

	for(i=0;i<entries;i++) {
		if(strcmp(name, mem_list[i].name)==0 && mem_list[i].type == DMA_TYPE){
			*base = mem_list[i].base;
			*size = mem_list[i].size;
			return MON_OK;
		}
	}
	return MON_FAIL;
}

int get_buffer_base_size(char *name, unsigned int *base, unsigned int *size)
{
	int i;

	for(i=0;i<entries;i++) {
		if(strcmp(name, mem_list[i].name)==0 && mem_list[i].type == BUFFER_TYPE){
			*base = mem_list[i].base;
			*size = mem_list[i].size;
			return MON_OK;
		}
	}
	return MON_FAIL;
}