ej_bbs.cpp

来自「ADI blackfin DSP的基于device friver的jpeg压缩算」· C++ 代码 · 共 501 行

#include <string.h>
#include "EJ_BBS.h"
#include "initialize.h"
#include "callback.h"
#include "WatchDog.h"
#include "creat_heap.h"
#include "set_cache.h"
#include "cplb_tables.h"

EJ_BBS::EJ_BBS()
{
	m_pDMAMgrData 	= NULL;
	m_pDevMgrData 	= NULL;
	m_pDCBMgrData 	= NULL;
	m_pIntMgrData   = NULL;
	m_DCBManagerHandle 		= NULL;
	m_DeviceManagerHandle 	= NULL;
	m_DMAManagerHandle    	= NULL;

#if defined (__ADSP_TETON__)
	m_ppiDeviceHandle_1		= NULL;
	m_ppiDeviceHandle_2		= NULL;
	m_mdma_1_Handle0		= NULL;
	m_mdma_1_Handle1		= NULL;
#else
	m_ppiDeviceHandle		= NULL;
	m_mdmaHandle0			= NULL;
	m_mdmaHandle1			= NULL;
#endif

	m_userid				= 3;
}

EJ_BBS::~EJ_BBS()
{
	// close ppi device
#if defined(__ADSP_TETON__)	
	if(m_ppiDeviceHandle_1)
	{
		adi_dev_Close(m_ppiDeviceHandle_1);
		m_ppiDeviceHandle_1 = NULL;
	}
	if(m_ppiDeviceHandle_2)
	{
		adi_dev_Close(m_ppiDeviceHandle_2);
		m_ppiDeviceHandle_2 = NULL;
	}
#else
	if(m_ppiDeviceHandle)
	{
		adi_dev_Close(m_ppiDeviceHandle);
		m_ppiDeviceHandle = NULL;
	}
#endif
	// close the Device Manager
	if(m_DeviceManagerHandle)
	{
		adi_dev_Terminate(m_DeviceManagerHandle);
		m_DeviceManagerHandle = NULL;
	}
	
	// close down the DMA Manager
	if(m_DMAManagerHandle)
	{
		adi_dma_Terminate(m_DMAManagerHandle);
		m_DMAManagerHandle = NULL;
	}
	// close down the Deferred Callback Manager
	if(m_DCBManagerHandle)
	{
		adi_dcb_Terminate();
		m_DCBManagerHandle = NULL;
	}
	// close down the Interrupt Manager
	adi_int_Terminate();

}

void EJ_BBS::init_core(void)
{
	init_hardware();
//	setup_watchdog();
	
}

RESULT EJ_BBS::init_system_service(u8 *pMemoryForSysService, size_t *MemorySizeUsed , 
									const size_t DmaChannelNum, const size_t IntSecHandlerNum, const size_t DcbCallbackNum)
{
	u32 ResponseCount = 0;
	u8 *pAddr = pMemoryForSysService;
	size_t memSize = 0;
	u32 rst = 0;
	
	// check parameters	
	if(pMemoryForSysService == NULL)
		return EJ_ERR_INVALID_PARAM;

	*MemorySizeUsed = 0;
	
	// init interrupt manager
	if(IntSecHandlerNum == 0)
	{
		adi_int_Init(NULL, 0, &ResponseCount, NULL);
	}
	else
	{
		m_pIntMgrData = pAddr;
		memSize = ADI_INT_SECONDARY_MEMORY*IntSecHandlerNum;
		memset(m_pIntMgrData, 0, memSize);
		
		adi_int_Init((void*)m_pIntMgrData, memSize, &ResponseCount, NULL);
		pAddr +=  memSize;
		*MemorySizeUsed += memSize;
	}
	
	// hook error handler
	rst = adi_int_CECHook(3, ExceptionHandler, NULL, FALSE);

	rst = adi_int_CECHook(5, HWErrorHandler, NULL, FALSE);
	
	if(rst)
		return EJ_ERR_UNKNOWN;

	// initialize the Deferred Callback Manager and setup a queue
	if(DcbCallbackNum != 0)
	{
		m_pDCBMgrData = pAddr;
		memSize = ADI_DCB_QUEUE_SIZE + ADI_DCB_ENTRY_SIZE*DcbCallbackNum;
		memset(m_pDCBMgrData, 0, memSize);
		
		rst = adi_dcb_Init(m_pDCBMgrData, ADI_DCB_QUEUE_SIZE, &ResponseCount, NULL);
		if(rst)
			return EJ_ERR_UNKNOWN;
		rst = adi_dcb_Open(14, (void*)((u8*)m_pDCBMgrData+ADI_DCB_QUEUE_SIZE),  ADI_DCB_ENTRY_SIZE*DcbCallbackNum, &ResponseCount, &m_DCBManagerHandle);
		if(rst)
			return EJ_ERR_UNKNOWN;
		pAddr += memSize;
		*MemorySizeUsed += memSize;
	}

	// initialize the DMA Manager
	m_pDMAMgrData = pAddr;
	memSize = ADI_DMA_BASE_MEMORY + ADI_DMA_CHANNEL_MEMORY * DmaChannelNum;
	pAddr += memSize;
	*MemorySizeUsed += memSize;
	
	memset(m_pDMAMgrData, 0, memSize);
	
	rst = adi_dma_Init((void*)m_pDMAMgrData, memSize, &ResponseCount, &m_DMAManagerHandle, NULL);
	if(rst)
		return EJ_ERR_UNKNOWN;
	
	return EJ_ERR_NONE;
}

RESULT EJ_BBS::init_device_driver(u8 *pMemoryForDDR, size_t *MemorySizeUsed , const size_t DevNum)
{
	u32 ResponseCount = 0;
	u32 rst =0;
	// check parameters	
	if(pMemoryForDDR == NULL)
		return EJ_ERR_INVALID_PARAM;

	
	
	m_pDevMgrData = pMemoryForDDR;

	*MemorySizeUsed = ADI_DEV_BASE_MEMORY + (ADI_DEV_DEVICE_MEMORY * DevNum);
	
	memset(m_pDevMgrData, 0, *MemorySizeUsed);
	rst = adi_dev_Init(m_pDevMgrData, *MemorySizeUsed, &ResponseCount, &m_DeviceManagerHandle, NULL);
	if(rst)
		return EJ_ERR_UNKNOWN;

	return EJ_ERR_NONE;
}

RESULT EJ_BBS::config_device(u16 devType, ADI_DEV_CMD_VALUE_PAIR *configurationTable,  ADI_DCB_CALLBACK_FN ClientCallback)
{
	u32 rst = 0;
	switch (devType) 
	{
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
		case DEV_PPI:
		{
			// open the PPI driver for input
			rst = adi_dev_Open(m_DeviceManagerHandle, &ADIPPIEntryPoint, DECODER_PPI, this, 
				&m_ppiDeviceHandle, ADI_DEV_DIRECTION_INBOUND, m_DMAManagerHandle, m_DCBManagerHandle, ClientCallback);
			if(rst)
				return EJ_ERR_UNKNOWN;
			
			// configure the PPI driver with the values from the inbound configuration table
			rst = adi_dev_Control(m_ppiDeviceHandle, ADI_DEV_CMD_TABLE, configurationTable);
			if(rst)
				return EJ_ERR_UNKNOWN;
		}
		break;
#endif
//for bf561, not implement yet
#if defined(__ADSP_TETON__)	
	case DEV_PPI1:	//ppi1 for inbound
		{
		    rst = adi_dev_Open(m_DeviceManagerHandle, &ADIPPIEntryPoint, DECODER_PPI, this, 
				&m_ppiDeviceHandle_1, ADI_DEV_DIRECTION_INBOUND, m_DMAManagerHandle, m_DCBManagerHandle, ClientCallback);
			if(rst)
				return EJ_ERR_UNKNOWN;
			
			// configure the PPI driver with the values from the inbound configuration table
			rst = adi_dev_Control(m_ppiDeviceHandle_1, ADI_DEV_CMD_TABLE, configurationTable);
			if(rst)
				return EJ_ERR_UNKNOWN;
				
		}
		break;
	case DEV_PPI2:	//ppi2 for outbound
		{
		    rst = adi_dev_Open(m_DeviceManagerHandle, &ADIPPIEntryPoint, ENCODER_PPI, this, 
				&m_ppiDeviceHandle_2, ADI_DEV_DIRECTION_INBOUND, m_DMAManagerHandle, m_DCBManagerHandle, ClientCallback);
			if(rst)
				return EJ_ERR_UNKNOWN;
			
			// configure the PPI driver with the values from the inbound configuration table
			rst = adi_dev_Control(m_ppiDeviceHandle_2, ADI_DEV_CMD_TABLE, configurationTable);
			if(rst)
				return EJ_ERR_UNKNOWN;
		}
		break;
#endif
		default:
			return EJ_ERR_UNSUPPORTED;
	}

	return EJ_ERR_NONE;
}

RESULT EJ_BBS::set_dev_buffer(u16 devType, ADI_DEV_BUFFER * devBuffer, ADI_DEV_BUFFER_TYPE BufferType)
{

	if(!devBuffer)
		return EJ_ERR_INVALID_PARAM;

	switch (devType) 
	{
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
		case DEV_PPI:
		{
			if(!m_ppiDeviceHandle)
				return EJ_ERR_BAD_STATE;	//not open !

			adi_dev_Read(m_ppiDeviceHandle, BufferType, devBuffer);
			
		}
#endif
 //for bf561
#if defined(__ADSP_TETON__)	
 		case DEV_PPI1:
		{
			if(!m_ppiDeviceHandle_1)
				return EJ_ERR_BAD_STATE;	//not open !

			adi_dev_Read(m_ppiDeviceHandle_1, BufferType, devBuffer);
		}
		break;
		case DEV_PPI2:
		{
			if(!m_ppiDeviceHandle_2)
				return EJ_ERR_BAD_STATE;	//not open !

			adi_dev_Read(m_ppiDeviceHandle_2, BufferType, devBuffer);
		}
		break;
#endif
		default:
			break;
	}
	return EJ_ERR_NONE;
}

void EJ_BBS::set_dev_start(u16 devType )
{

	switch (devType) 
	{
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
		case DEV_PPI:
		{
			if(!m_ppiDeviceHandle)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle, ADI_DEV_CMD_SET_DATAFLOW, (void *)TRUE);	
		}
#endif
 //for bf561
#if defined(__ADSP_TETON__)	
 		case DEV_PPI1:
 		{
 			if(!m_ppiDeviceHandle_1)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle_1, ADI_DEV_CMD_SET_DATAFLOW, (void *)TRUE);	
 		}
 		break;
 		case DEV_PPI2:
 		{
 			if(!m_ppiDeviceHandle_2)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle_2, ADI_DEV_CMD_SET_DATAFLOW, (void *)TRUE);	
 		}
 		break;
#endif
		default:
		 	break;
	}
	return;


}

void EJ_BBS::set_dev_stop(u16 devType )
{

	switch (devType) 
	{
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
		case DEV_PPI:
		{
			if(!m_ppiDeviceHandle)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle, ADI_DEV_CMD_SET_DATAFLOW, (void *)FALSE);	
		}
#endif
 //for bf561
#if defined(__ADSP_TETON__)	
 		case DEV_PPI1:
 		{
 			if(!m_ppiDeviceHandle_1)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle_1, ADI_DEV_CMD_SET_DATAFLOW, (void *)FALSE);	
 		}
 		break;
 		case DEV_PPI2:
 		{
 			if(!m_ppiDeviceHandle_2)
				return;	//not open !

			adi_dev_Control(m_ppiDeviceHandle_2, ADI_DEV_CMD_SET_DATAFLOW, (void *)FALSE);	
 		}
 		break;
#endif
		default:
		 	break;
	}
	return;


}

RESULT EJ_BBS::config_memdma(ADI_DMA_STREAM_ID StreamID)
{
	u32 rst = 0;
	
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
	// if stream 0
	if(StreamID == ADI_DMA_MDMA_0)
	{
		rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdmaHandle0, NULL);
	}
	// if stream 1
	if(StreamID == ADI_DMA_MDMA_1)
	{
		rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdmaHandle1, NULL);
	}
#endif

#if defined(__ADSPBF561__)

	// dual core processors: use different streams for each core, which one to use for each core is arbitrary.
	if( adi_core_id() == 0)
	{
	    if(StreamID == ADI_DMA_MDMA1_0)
	    {
	        rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdma_1_Handle0, NULL);
	        
	    }
	    else if(StreamID == ADI_DMA_MDMA1_1)
	    {
	        rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdma_1_Handle1, NULL);

	    }
	    else
	    	return EJ_ERR_UNKNOWN;
	}
	else
	{
	    if(StreamID == ADI_DMA_MDMA2_0)
	    {
	        rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdma_2_Handle0, NULL);
	        
	    }
	    else if(StreamID == ADI_DMA_MDMA2_1)
	    {
	        rst = adi_dma_MemoryOpen(m_DMAManagerHandle, StreamID, this, &m_mdma_2_Handle1, NULL);

	    }
	    else
	    	return EJ_ERR_UNKNOWN;
	}
	
#endif

	if(rst)
		return EJ_ERR_UNKNOWN;
	
	return EJ_ERR_NONE;

}

RESULT EJ_BBS::start_memdma(ADI_DMA_STREAM_ID StreamID, ADI_DMA_2D_TRANSFER *pDest, ADI_DMA_2D_TRANSFER *pSrc, 
		u32 ElementWidth , ADI_DCB_CALLBACK_FN	ClientCallback)
{
	u32 rst = 0;
	
#if defined(__ADSP_EDINBURGH__) || defined(__ADSP_BRAEMAR__)
	if(StreamID == ADI_DMA_MDMA_0)
	{
		rst = adi_dma_MemoryCopy2D(m_mdmaHandle0,pDest, pSrc, ElementWidth, ClientCallback);
	}
	// if stream 1
	if(StreamID == ADI_DMA_MDMA_1)
	{
		rst = adi_dma_MemoryCopy2D(m_mdmaHandle1,pDest, pSrc, ElementWidth, ClientCallback);
	}
#endif

#if defined(__ADSPBF561__)
	// dual core processors: use different streams for each core, which one to use for each core is arbitrary.
	if( adi_core_id() == 0)
	{
	    if(StreamID == ADI_DMA_MDMA1_0)
	    {
	        rst = adi_dma_MemoryCopy2D(m_mdma_1_Handle0, pDest, pSrc, ElementWidth, ClientCallback);
	    }
	    else if(StreamID == ADI_DMA_MDMA1_1)
	    {
	        adi_dma_MemoryCopy2D(m_mdma_1_Handle1, pDest, pSrc, ElementWidth, ClientCallback);
	    }
	    else
	    	return EJ_ERR_UNKNOWN;
	}
	else
	{
	    if(StreamID == ADI_DMA_MDMA2_0)
	    {
	        rst = adi_dma_MemoryCopy2D(m_mdma_2_Handle0, pDest, pSrc, ElementWidth, ClientCallback);
	    }
	    else if(StreamID == ADI_DMA_MDMA2_1)
	    {
	        adi_dma_MemoryCopy2D(m_mdma_2_Handle1, pDest, pSrc, ElementWidth, ClientCallback);
	    }
	    else
	    	return EJ_ERR_UNKNOWN;
	}

#endif

	if(rst)
		return EJ_ERR_UNKNOWN;
	return EJ_ERR_NONE;
}



int EJ_BBS::creat_alternate_heap(void* heap_base_addr, u32 heap_size)
{
    int index = -1;
    
	
	index = creat_heaps(heap_base_addr, heap_size, m_userid);
	m_userid++;
	
	return index;
}		

void EJ_BBS::set_data_cache()
{
    disable_data_cache();
	configure_data_cache_cplbs(dcplbs_table);
	enable_data_cache();
}

void EJ_BBS::set_instruction_cache()
{
    disable_instruction_cache();
	configure_instruction_cache_cplbs(icplbs_table);
	enable_instruction_cache();
}