main.c

ADSP-BF561的应用程序

/*********************************************************************************
Copyright(c) 2005 Analog Devices, Inc. All Rights Reserved. 

This software is proprietary and confidential. By using this software you agree
to the terms of the associated Analog Devices License Agreement.
*********************************************************************************/


/*********************************************************************
Include files
*********************************************************************/

#include <services/services.h>
#include <drivers/adi_dev.h>
#include <drivers/ppi/adi_ppi.h>
#include "main.h"


extern void Init(void);

/*********************************************************************
Enumerations and defines
*********************************************************************/
#define USE_LOOPBACK			// enabled chained with loopback
#define NUM_BUFFERS (1)			// frame change rate = (NUM_BUFFERS/30)/second
#define Frame_Size 640 * 480	// Frame size of the image
#define PPI0		0			// PPI select
#define PPI1		1			// PPI select

/*********************************************************************
Variable global data
*********************************************************************/

/*********************************************************************
Static data
*********************************************************************/

// Create a buffer.
ADI_DEV_2D_BUFFER PingBuffer[NUM_BUFFERS];

// DMA Manager data (base memory + memory for 1 DMA channel)
static u8 DMAMgrData[ADI_DMA_BASE_MEMORY + (ADI_DMA_CHANNEL_MEMORY * 1)];

// Device Manager data (base memory + memory for 1 device)
static u8 DevMgrData[ADI_DEV_BASE_MEMORY + (ADI_DEV_DEVICE_MEMORY * 1)];

// Handle to the PPI driver
static ADI_DEV_DEVICE_HANDLE 	DriverHandle;


/*********************************************************************
	Function:	ExceptionHandler and HWErrorHandler
*********************************************************************/

static ADI_INT_HANDLER(ExceptionHandler)	// exception handler
{
	while(1);
}

static ADI_INT_HANDLER(HWErrorHandler)		// hardware error handler
{
	while(1);
}

static void Callback(
	void *AppHandle,
	u32  Event,
	void *pArg)
{
	
	ADI_DEV_BUFFER *pBuffer;			// pointer to the buffer that was processed
	
	// CASEOF (event type)
	switch (Event) {
		
		// CASE (buffer processed)
		case ADI_DEV_EVENT_BUFFER_PROCESSED:
			pBuffer = (ADI_DEV_BUFFER *)pArg;
		break;
			
		// CASE (an error)
		case ADI_DEV_EVENT_DMA_ERROR_INTERRUPT:
			while(1);
		case ADI_PPI_EVENT_ERROR_INTERRUPT:
			while(1);
		
	// ENDCASE
	}
	
}

/****************************************************************************
Function:	Init_Timers	
Set up timers for PWM mode to control HSYNC and VSYNC. Do not enable them here!
******************************************************************************/

void InitTimers(void){
	//PPI_CLK
	//Setting up command table for Timer
	ADI_TMR_GP_CMD_VALUE_PAIR Timer0ConfigurationTable [] = {
		{ ADI_TMR_GP_CMD_SET_TIMER_MODE,			(void *)0x01			},
		{ ADI_TMR_GP_CMD_SET_COUNT_METHOD,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_INPUT_SELECT,			(void *)FALSE			},
		{ ADI_TMR_GP_CMD_SET_CLOCK_SELECT,			(void *)FALSE			},
		{ ADI_TMR_GP_CMD_RUN_DURING_EMULATION,		(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_PERIOD,				(void *)8				},
		{ ADI_TMR_GP_CMD_SET_WIDTH, 				(void *)4				},
		{ ADI_TMR_GP_CMD_END,						NULL					}, 
	};
	//HSYNC
	//Setting up command table for Timer
	ADI_TMR_GP_CMD_VALUE_PAIR Timer8ConfigurationTable [] = {
		{ ADI_TMR_GP_CMD_SET_TIMER_MODE,			(void *)0x01			},
		{ ADI_TMR_GP_CMD_SET_PULSE_HI,				(void *)FALSE			},
		{ ADI_TMR_GP_CMD_SET_COUNT_METHOD,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_INPUT_SELECT,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_CLOCK_SELECT,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_RUN_DURING_EMULATION,		(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_PERIOD,				(void *)996				},
		{ ADI_TMR_GP_CMD_SET_WIDTH, 				(void *)356				},
		{ ADI_TMR_GP_CMD_END,						NULL					}, 
	};
	//VSYNC	
	//Setting up command table for Timer
	ADI_TMR_GP_CMD_VALUE_PAIR Timer9ConfigurationTable [] = {
		{ ADI_TMR_GP_CMD_SET_TIMER_MODE,			(void *)0x01			},
		{ ADI_TMR_GP_CMD_SET_PULSE_HI,				(void *)FALSE			},
		{ ADI_TMR_GP_CMD_SET_COUNT_METHOD,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_INPUT_SELECT,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_CLOCK_SELECT,			(void *)TRUE			},
		{ ADI_TMR_GP_CMD_RUN_DURING_EMULATION,		(void *)TRUE			},
		{ ADI_TMR_GP_CMD_SET_PERIOD,				(void *)478080			},
		{ ADI_TMR_GP_CMD_SET_WIDTH, 				(void *)356 			},
		{ ADI_TMR_GP_CMD_END,						NULL					}, 
	};
	//Open timer for access
	adi_tmr_Open(ADI_TMR_GP_TIMER_0);
	//Program timer with Timer table
	adi_tmr_GPControl(ADI_TMR_GP_TIMER_0, ADI_TMR_GP_CMD_TABLE, Timer0ConfigurationTable);
	//Open Timer for access
	adi_tmr_Open(ADI_TMR_GP_TIMER_8);
	//Program timer with Timertable
	adi_tmr_GPControl(ADI_TMR_GP_TIMER_8, ADI_TMR_GP_CMD_TABLE, Timer8ConfigurationTable);
	//Open Timer for access
	adi_tmr_Open(ADI_TMR_GP_TIMER_9);
	//Program timer with timer table
	adi_tmr_GPControl(ADI_TMR_GP_TIMER_9, ADI_TMR_GP_CMD_TABLE, Timer9ConfigurationTable);
}

void ezErrorCheck(u32 Result)
{
	if(Result == 0)
		ssync();
	else
		while(1);	// error!
}
	
/*********************************************************************
*
*	Function:	main
*
*********************************************************************/
void main(void) {
	
	ADI_DEV_CMD_VALUE_PAIR ConfigurationTable [] = {	// table of PPI driver configuration values
		{ ADI_DEV_CMD_SET_DATAFLOW_METHOD, 		(void *)ADI_DEV_MODE_CHAINED_LOOPBACK },
		{ ADI_PPI_CMD_SET_CONTROL_REG,			(void *)0x011C		},	// 0xF91E		},
		{ ADI_PPI_CMD_SET_FS_INVERT,			(void *)TRUE		},
		{ ADI_PPI_CMD_SET_CLK_INVERT,			(void *)TRUE		},
		{ ADI_PPI_CMD_SET_DATA_LENGTH,			(void *)15			},
		{ ADI_PPI_CMD_SET_SKIP_EVEN_ODD,		(void *)FALSE		},
		{ ADI_PPI_CMD_SET_SKIP_ENABLE,			(void *)FALSE		},
		{ ADI_PPI_CMD_SET_PACK_ENABLE,			(void *)FALSE		},
		{ ADI_PPI_CMD_SET_ACTIVE_FIELD_SELECT,	(void *)FALSE		},
//		{ ADI_PPI_CMD_SET_PORT_CFG,				(void *)TRUE		},
//		{ ADI_PPI_CMD_SET_TRANSFER_TYPE,		(void *)TRUE		},
		{ ADI_PPI_CMD_SET_PORT_DIRECTION,		(void *)TRUE		},
		{ ADI_PPI_CMD_SET_TRIPLE_FRAME_SYNC,	(void *)FALSE		},
		{ ADI_PPI_CMD_SET_DELAY_COUNT_REG,		(void *)355			},
		{ ADI_PPI_CMD_SET_TRANSFER_COUNT_REG,	(void *)639			},
		{ ADI_DEV_CMD_SET_STREAMING,			(void *)TRUE		},
		{ ADI_DEV_CMD_END,						NULL				},
	};
	
	ADI_DCB_HANDLE			DCBManagerHandle;		// handle to the callback service
	ADI_DMA_MANAGER_HANDLE	DMAManagerHandle;		// handle to the DMA Manager
	ADI_DEV_MANAGER_HANDLE	DeviceManagerHandle;	// handle to the Device Manager
	ADI_DEV_2D_BUFFER 		Buffer2D;				// buffer to be sent to PPI Driver
	u32 					ResponseCount;			// response counter
	int						i;						// counter
	
	// Processor Specific Initialization (including Power Management)
	Init();
	
	// initialize the Interrupt Manager and hook the exception and hardware error interrupts
	ezErrorCheck(adi_int_Init(NULL, 0, &ResponseCount, NULL));
	ezErrorCheck(adi_int_CECHook(3, ExceptionHandler, NULL, FALSE));
	ezErrorCheck(adi_int_CECHook(5, HWErrorHandler, NULL, FALSE));
	
	DCBManagerHandle = NULL;
	
	// initialize the DMA Manager
	ezErrorCheck(adi_dma_Init(DMAMgrData, sizeof(DMAMgrData), &ResponseCount, &DMAManagerHandle, NULL));
	
	// initialize the Device Manager
	ezErrorCheck(adi_dev_Init(DevMgrData, sizeof(DevMgrData), &ResponseCount, &DeviceManagerHandle, NULL));
	
	// Buffer
	for (i = 0; i < NUM_BUFFERS; i++) {
		PingBuffer[i].Data = PingFrame;
		PingBuffer[i].ElementWidth = 4;
		PingBuffer[i].XCount = 320;
		PingBuffer[i].XModify = 4;
		PingBuffer[i].YCount = 480;
		PingBuffer[i].YModify = 20;
		PingBuffer[i].CallbackParameter = NULL;
		PingBuffer[i].pNext = &PingBuffer[i + 1];
	}
	PingBuffer[NUM_BUFFERS - 1].CallbackParameter = &PingBuffer[0];
	PingBuffer[NUM_BUFFERS - 1].pNext = NULL;
	
	// initialize the Timer manager
	InitTimers();
	
	for (i = 0; i < 100; i++)
		ssync();
	
	//enable timer for clock generation
	adi_tmr_GPGroupEnable(ADI_TMR_GP_TIMER_0, TRUE);
	
	//open the PPI driver for output
	ezErrorCheck(adi_dev_Open(DeviceManagerHandle, &ADIPPIEntryPoint, PPI0, NULL, &DriverHandle, ADI_DEV_DIRECTION_OUTBOUND, DMAManagerHandle, DCBManagerHandle, Callback));
	
	// configure the PPI driver with the values from the configuration table
	ezErrorCheck(adi_dev_Control(DriverHandle, ADI_DEV_CMD_TABLE, ConfigurationTable));
	
	// give the device the Ping buffer chain
	ezErrorCheck(adi_dev_Write(DriverHandle, ADI_DEV_2D, (ADI_DEV_BUFFER *)PingBuffer));
	
	// enable data flow
	ezErrorCheck(adi_dev_Control(DriverHandle, ADI_DEV_CMD_SET_DATAFLOW, (void *)TRUE));
	
	//enable PPI sync timers
	adi_tmr_GPGroupEnable(ADI_TMR_GP_TIMER_8 | ADI_TMR_GP_TIMER_9,TRUE);
	
	// keep going
	while (1);
}