main.bak

ucos porting source for Am188

/************************************************************************/
/* PROGRAMER: CHAE BYOUNG CHEOL										    */
/* PROGRAM 	: MAIN.C                                                    */
/* COMPILER : BORLAND C/C++ 3.1 FOR DOS                                 */
/************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <dos.h>
#include <stdarg.h>
#include <math.h>

#include ".\header\main.h"

//**************************************************************************
// CONSTANTS
//**************************************************************************

#define	TASK_STK_SIZE     512	/* Size of each task's stacks (# of WORDs)*/

#define TASK_START_ID       0   /* Application tasks IDs                  */
#define TASK_1_ID           1                
#define TASK_2_ID           2
#define TASK_3_ID           3
#define TASK_4_ID           4
#define TASK_5_ID           5

#define TASK_START_PRIO    10   /* Application tasks priorities           */
#define TASK_1_PRIO        11                
#define TASK_2_PRIO        12
#define TASK_3_PRIO        13
#define TASK_4_PRIO        14
#define TASK_5_PRIO        15

//*****************************************************************************
// VARIABLES
//*****************************************************************************

OS_STK	TaskStartStk[TASK_STK_SIZE];	/* Startup    task stack           */
OS_STK  Task1Stk[TASK_STK_SIZE];       
OS_STK  Task2Stk[TASK_STK_SIZE];      
OS_STK  Task3Stk[TASK_STK_SIZE];     
OS_STK  Task4Stk[TASK_STK_SIZE];    
OS_STK  Task5Stk[TASK_STK_SIZE];   

OS_EVENT        *AckMbox;	/* Message mailboxes */
OS_EVENT        *TxMbox;

//****************************************************************************
// FUNCTION PROTOTYPES
//****************************************************************************

void	TaskStart(void *data);/* Function prototypes of tasks */
void    Task1(void *data);
void    Task2(void *data);
void    Task3(void *data);
void    Task4(void *data);
void    Task5(void *data);


#define WATCHDOG	0x2000

void InitSystem(void);
void DefineInterrupt(void);
void GotoMonitor(void);

void EnabletchDog(void);
void WatchDog(void);

/*
void static __interrupt far int_DIV(void);
void static __interrupt far int_TRACE(void);
void static __interrupt far int_NMI(void);
void static __interrupt far int_BREAK(void);
*/
void static __interrupt far int_OVERFLOW(void);
void static __interrupt far int_BOUNDS(void);
void static __interrupt far int_ILLOP(void);
void static __interrupt far int_ESC(void);
void static __interrupt far int_TMR0(void);
void static __interrupt far int_TMR1(void);
void static __interrupt far int_TMR2(void);
void static __interrupt far int_DMA0(void);
void static __interrupt far int_DMA1(void);
void static __interrupt far int_INT0(void);
void static __interrupt far int_INT1(void);
void static __interrupt far int_INT2(void);
void static __interrupt far int_INT3(void);
void static __interrupt far int_INT4(void);
void static __interrupt far int_INT5(void);
void static __interrupt far int_INT6(void);
void static __interrupt far int_SPRT0(void);
void static __interrupt far int_SPRT1(void);
void static __interrupt far int_WDOG_ES(void);

void Test(void);

//===================================================================
void main(void)
{
	InitSystem();

    COM_Printf(COM2, "START\r\n");
	
	OSInit();

    OSTaskCreateExt(TaskStart, (void *)0, &TaskStartStk[TASK_STK_SIZE-1], 
			        TASK_START_PRIO,TASK_START_ID, &TaskStartStk[0], 
					TASK_STK_SIZE, (void *)0, 
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
		
    OSTaskCreateExt(Task1, (void *)0, &Task1Stk[TASK_STK_SIZE-1], TASK_1_PRIO,
                   TASK_1_ID, &Task1Stk[0], TASK_STK_SIZE, (void *)0, 
                   OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

    OSTaskCreateExt(Task2, (void *)0, &Task2Stk[TASK_STK_SIZE-1], TASK_2_PRIO, 
                   TASK_2_ID, &Task2Stk[0], TASK_STK_SIZE, (void *)0, 
                   OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
                   
    OSTaskCreateExt(Task3, (void *)0, &Task3Stk[TASK_STK_SIZE-1], TASK_3_PRIO, 
                   TASK_3_ID, &Task3Stk[0], TASK_STK_SIZE, (void *)0, 
                   OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

    OSTaskCreateExt(Task4, (void *)0, &Task4Stk[TASK_STK_SIZE-1], TASK_4_PRIO, 
                   TASK_4_ID, &Task4Stk[0], TASK_STK_SIZE, (void *)0, 
                   OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

    OSTaskCreateExt(Task5, (void *)0, &Task5Stk[TASK_STK_SIZE-1], TASK_5_PRIO, 
                   TASK_5_ID, &Task5Stk[0], TASK_STK_SIZE, (void *)0, 
                   OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
	
	
	poke(0x0000, uCOS*4,  	FP_OFF(OSCtxSw));
    poke(0x0000, uCOS*4+2,	FP_SEG(OSCtxSw));

	OSStatInit();

	OSStart();
	
	OS_ENTER_CRITICAL(); 
	TIMER_Initialize();
    TMR_ON();
	OS_EXIT_CRITICAL();
    enable();
	
	while (1) ;
}


void TaskStart(void *data)
{
    data = data;

	for (;;)
    {
        OSCtxSwCtr = 0;
        COM_Printf(COM2, "a");
		OSTimeDly(1); 
    }
}


void Task1(void *data)
{
    data = data;
    for (;;)
    {
		COM_Printf(COM2, "b");
		OSTimeDly(1);              
    }
}


void Task2(void *data)
{
    data = data;
    for (;;)
    {
		COM_Printf(COM2, "c");
		OSTimeDly(1);
    }
}


void Task3(void *data)
{
    data = data;
    for (;;)
    {
		COM_Printf(COM2, "d");
        OSTimeDly(1);
    }
}


void Task4(void *data)
{
    data  = data;
    for (;;)
    {
		COM_Printf(COM2, "e");
        OSTimeDly(1);
    }
}


void Task5(void *data)
{
    data = data;
    for (;;)
    {
		COM_Printf(COM2, "f");
        OSTimeDly(1);    
    }
}


void InitSystem(void)
{
	disable();
    
	// PCS0 - 3
	outpw(CS_MPCS, CS_MPCS_64K);									
	outpw(CS_PACS, CS_PACS_RESERVED | 0x010F);	// 0000 0001 0111 xxxx
												// BASE ADDRESS = 1000h
												// PCS0 - 1000h~10FFh
												// PCS1 - 1100h-11FFh
												// PCS2 - 1200h-12FFh
												// PCS3 - 1300h-13FFh

	//SYSCON, DS Enabled 
	outpw(PDCN_REG, inpw(PDCN_REG) | PDCN_REG_DSDEN);
		
	// interrupt disable 
	outpw(INT_MASK, 
		  INT_I0 | INT_I1 | INT_I2 | INT_I3 | INT_I4 | INT_I5 | INT_I6);
   
	// define external interrupt registers
    outpw(INT_INT0, INT_ENABLE | INT_PRI5 | INT_LEVEL);		// SCC
	//outpw(INT_INT1, INT_ENABLE | INT_PRI7);	// RF CARD
	outpw(INT_INT2, INT_ENABLE | INT_PRI4);		// MSR TRACK2
	outpw(INT_INT3, INT_ENABLE | INT_PRI4);		// MSR TRACK3
#ifdef MODEM
	//outpw(INT_INT4, INT_ENABLE | INT_PRI6);	// MODEM
#endif	
	//outpw(INT_INT5, INT_ENABLE | INT_PRI7);
	//outpw(INT_INT6, INT_ENABLE | INT_PRI7);
	
	
	// | MODE | DIR | 	         FUNCTION            |
	// |------|-----|--------------------------------|
	// |   0  |  0  | Normal Operation               |
	// |   0  |  1  | PIO-input with pullup/pulldown |
	// |   1  |  0  | PIO-output                     |
	// |   1  |  1  | PIO-input  w/o pullup/pulldown |

	//V2.4
	outpw(PIO_DIR0,  0x1C10);   // xooi iixx xoxi oooo 
    outpw(PIO_DATA0, 0xBFBF);	// 1011 1111 1011 1111
	outpw(PIO_MODE0, 0x7C5F);	// 0111 1100 0101 1111
								// nnnp ppnn npnp pppp
    outpw(PIO_DIR1,  0x0000);	// xxox xooo xxoo xxxx 
    outpw(PIO_DATA1, 0xDFFF);	// 1101 1111 1111 1111 
	outpw(PIO_MODE1, 0x2730);	// 0010 0111 0011 0000
 	 							// nnpn nppp nnpp nnnn
	DefineInterrupt();
	
	COM_Initialize(COM1, 9600, 8, 'N', 1);
    COM_Initialize(COM2, 38400, 8, 'N', 1);
 
	SCC_Initialize(0, 9600, 8, 'N', 1);
	SCC_Initialize(1, 2400, 8, 'N', 1);
}

void EnabletchDog(void)
{
	outpw(WDOG_REG, WDOG_CLR1_ES);	// write enable	
	outpw(WDOG_REG, WDOG_CLR2_ES);

	outpw(WDOG_REG, WDOG_WR1_ES);	// clear watchdog register
	outpw(WDOG_REG, WDOG_WR2_ES);

	outpw(WDOG_REG, inpw(WDOG_REG) | WDOG_ENA_ES + 26); // enable, 1.67sec  	
}


void WatchDog(void)
{
	outpw(PIO_DATA0, inpw(PIO_DATA0) | WATCHDOG);
	outpw(PIO_DATA0, inpw(PIO_DATA0) & ~WATCHDOG);
}

/************************************************************************/
/* NAME 	:															*/
/* FUNCTION :															*/
/* ARGUMENT :															*/
/* RETURN	:															*/
/************************************************************************/
void GotoMonitor(void)
{
	__emit__(0xea,0xF0,0xFF,0x00,0xF0);
}

/************************************************************************/
/* NAME 	:															*/
/* FUNCTION :															*/
/* ARGUMENT :															*/
/* RETURN	:															*/
/************************************************************************/
void DefineInterrupt(void)
{
	/*	
	poke(0x0000, ITYPE_DIV*4,  		FP_OFF(int_DIV));
    poke(0x0000, ITYPE_DIV*4+2, 	FP_SEG(int_DIV));

    poke(0x0000, ITYPE_TRACE*4,  	FP_OFF(int_TRACE));
    poke(0x0000, ITYPE_TRACE*4+2,	FP_SEG(int_TRACE));

    poke(0x0000, ITYPE_NMI*4,  		FP_OFF(int_NMI));
    poke(0x0000, ITYPE_NMI*4+2,		FP_SEG(int_NMI));

    poke(0x0000, ITYPE_BREAK*4,  	FP_OFF(int_BREAK));
    poke(0x0000, ITYPE_BREAK*4+2,	FP_SEG(int_BREAK));
	*/
    poke(0x0000, ITYPE_OVERFLOW*4,  FP_OFF(int_OVERFLOW));
    poke(0x0000, ITYPE_OVERFLOW*4+2,FP_SEG(int_OVERFLOW));

    poke(0x0000, ITYPE_BOUNDS*4,  	FP_OFF(int_BOUNDS));
    poke(0x0000, ITYPE_BOUNDS*4+2,	FP_SEG(int_BOUNDS));

    poke(0x0000, ITYPE_ILLOP*4,  	FP_OFF(int_ILLOP));
    poke(0x0000, ITYPE_ILLOP*4+2,	FP_SEG(int_ILLOP));

    poke(0x0000, ITYPE_ESC*4,  		FP_OFF(int_ESC));
    poke(0x0000, ITYPE_ESC*4+2,		FP_SEG(int_ESC));

    poke(0x0000, ITYPE_TMR0*4,  	FP_OFF(int_TMR0));
    poke(0x0000, ITYPE_TMR0*4+2,	FP_SEG(int_TMR0));

    poke(0x0000, ITYPE_TMR1*4,  	FP_OFF(int_TMR1));  
    poke(0x0000, ITYPE_TMR1*4+2,	FP_SEG(int_TMR1));  
    
	poke(0x0000, ITYPE_TMR2*4,  	FP_OFF(int_TMR2));
    poke(0x0000, ITYPE_TMR2*4+2,	FP_SEG(int_TMR2));

	poke(0x0000, ITYPE_DMA0*4,  	FP_OFF(int_DMA0));
    poke(0x0000, ITYPE_DMA0*4+2,	FP_SEG(int_DMA0));

    poke(0x0000, ITYPE_DMA1*4,  	FP_OFF(int_DMA1));  
    poke(0x0000, ITYPE_DMA1*4+2,	FP_SEG(int_DMA1));
   
    poke(0x0000, ITYPE_INT0*4,  	FP_OFF(int_INT0));  
    poke(0x0000, ITYPE_INT0*4+2,	FP_SEG(int_INT0));  

	poke(0x0000, ITYPE_INT1*4,  	FP_OFF(int_INT1));  
    poke(0x0000, ITYPE_INT1*4+2,	FP_SEG(int_INT1));     
    
	poke(0x0000, ITYPE_INT2*4,  	FP_OFF(int_INT2));    
    poke(0x0000, ITYPE_INT2*4+2,	FP_SEG(int_INT2));      
    
	poke(0x0000, ITYPE_INT3*4,  	FP_OFF(int_INT3));  
	poke(0x0000, ITYPE_INT3*4+2,	FP_SEG(int_INT3));
    
	poke(0x0000, ITYPE_INT4*4,  	FP_OFF(int_INT4));
    poke(0x0000, ITYPE_INT4*4+2,	FP_SEG(int_INT4));
    
	poke(0x0000, ITYPE_INT5*4,  	FP_OFF(int_INT5));
    poke(0x0000, ITYPE_INT5*4+2,	FP_SEG(int_INT5));
    
	poke(0x0000, ITYPE_INT6*4,  	FP_OFF(int_INT6));
    poke(0x0000, ITYPE_INT6*4+2,	FP_SEG(int_INT6));
    
	poke(0x0000, ITYPE_SPRT0*4,  	FP_OFF(int_SPRT0));
    poke(0x0000, ITYPE_SPRT0*4+2,	FP_SEG(int_SPRT0));

	poke(0x0000, ITYPE_SPRT1*4,  	FP_OFF(int_SPRT1));
    poke(0x0000, ITYPE_SPRT1*4+2,	FP_SEG(int_SPRT1));
	
	poke(0x0000, ITYPE_WDOG_ES*4,  	FP_OFF(int_WDOG_ES));
    poke(0x0000, ITYPE_WDOG_ES*4+2,	FP_SEG(int_WDOG_ES));
	
}

/*
void static __interrupt far int_DIV(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_TRACE(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_NMI(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_BREAK(void)
{
	OSIntEnter();
	OSIntExit();
}
*/
void static __interrupt far int_OVERFLOW(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_BOUNDS(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_ILLOP(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_ESC(void)
{
	OSIntEnter();
	OSIntExit();
}

void static __interrupt far int_TMR0(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_TMR0);
	OSIntExit();
}

void static __interrupt far int_TMR1(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_TMR1);
	OSIntExit();
}

void static __interrupt far int_TMR2(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_TMR2);
	OSIntExit();
}

void static __interrupt far int_DMA0(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_DMA0);
	OSIntExit();
}

void static __interrupt far int_DMA1(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_DMA1);
	OSIntExit();
}

void static __interrupt far int_INT0(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT0);
	OSIntExit();
}

void static __interrupt far int_INT1(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT1);
	OSIntExit();
}

void static __interrupt far int_INT2(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT2);
	OSIntExit();
}

void static __interrupt far int_INT3(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT3);
	OSIntExit();
}

void static __interrupt far int_INT4(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT4);
	OSIntExit();
}

void static __interrupt far int_INT5(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT5);
	OSIntExit();
}

void static __interrupt far int_INT6(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_INT6);
	OSIntExit();
}

void static __interrupt far int_SPRT0(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_SPRT0);
	OSIntExit();
}

void static __interrupt far int_SPRT1(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_SPRT1);
	OSIntExit();
}

void static __interrupt far int_WDOG_ES(void)
{
	OSIntEnter();
	outpw(INT_EOI, EOITYPE_WDOG_EM);
	OSIntExit();
}