Subversion Repositories Aquarius

//===============================

// Monitor Program

//-------------------------------

// for VirtexE Evaluation Board

// May.1 2003 Ver.1

//===============================

//======================================================

// Address Map

//======================================================

// address           sz  wt wd device

// 00000000-00001FFF  8K 0  32 ROM (code)

// 00002000-00003DFF  6K 0  32 RAM (data)

// 00003E00-00003FFF 512 0  32 RAM (stack)

//

// 00000000-0000FFFF 64K 0  32 RAM (shadow every 16KB)

// 00010000-0001FFFF 64K 3  32 RAM (shadow every 16KB)

// 00020000-0002FFFF 64K 0  16 RAM (shadow every 16KB)

// 00030000-0003FFFF 64K 3  16 RAM (shadow every 16KB)

// 00040000-ABCCFFFF (shadow RAM)

// ABCD0000-ABCD00FF 256 3  32 PIO (shadow every 4B)

// ABCD0100-ABCD01FF 256 3  32 UART(shadow every 4B)

// ABCD0200-ABCD02FF 256 3  32 SYS (shadow every 8B)

// ABCD0300-FFFBFFFF (shadow RAM)

// FFFC0000-FFFCFFFF 64K 0  32 RAM (shadow every 16KB)

// FFFD0000-FFFDFFFF 64K 3  32 RAM (shadow every 16KB)

// FFFE0000-FFFEFFFF 64K 0  16 RAM (shadow every 16KB)

// FFFF0000-FFFFFFFF 64K 3  16 RAM (shadow every 16KB)

// 

//======================================================

// PORT OUTPUT

//======================================================

// ABCD0000 : reserved

//   31    30    29    28    27    26    25    24

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     |     |     |     |     |     |

//  -----------------------------------------------;

// 

// ABCD0001 : KEYYO (Key SCAN Y-axis out)

//   23    22    21    20    19    18    17    16

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     | KY4 | KY3 | KY2 | KY1 | KY0 |

//  -----------------------------------------------

// 

// ABCD0002 : LCDCON (LCD Control Signal)

//   15    14    13    12    11    10     9     8

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     |     |     |  E  | R/W |  RS |

//  -----------------------------------------------

// 

// ABCD0003 : LCDOUT (Write Data to LCD)

//    7     6     5     4     3     2     1     0

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// | DW7 | DW6 | DW5 | DW4 | DW3 | DW2 | DW1 | DW0 |

//  -----------------------------------------------

// 

//======================================================

// PORT INPUT

//======================================================

// ABCD0000 : reserved

//   31    30    29    28    27    26    25    24

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     |     |     |     |     |     |

//  -----------------------------------------------;

// 

// ABCD0001 : KEYXI (Key SCAN X-axis in)

//   23    22    21    20    19    18    17    16

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     | KX4 | KX3 | KX2 | KX1 | KX0 |

//  -----------------------------------------------

// 

// ABCD0002 : reserved

//  15    14    13    12    11    10     9     8

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |     |     |     |     |     |     |     |    |

//  -----------------------------------------------

// 

// ABCD0003 : LCDIN (Read Data from LCD)

//    7     6     5     4     3     2     1     0

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// | DR7 | DR6 | DR5 | DR4 | DR3 | DR2 | DR1 | DR0 |

//  -----------------------------------------------

// 

//======================================================

// UART: SASC (www.opencores.com)

// Simple Asynchronous Serial Communication Device

//======================================================

// ABCD0100 : UARTBG0 Baud Rate Generator Div0 (R/W)

//   31    30    29    28    27    26    25    24

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// | B07 | B06 | B05 | B04 | B03 | B02 | B01 | B00 |

//  -----------------------------------------------

// 

// ABCD0101 : UARTBG1 Baud Rate Generator Div1 (R/W)

//   23    22    21    20    19    18    17    16

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// | B17 | B16 | B15 | B14 | B13 | B12 | B11 | B10 |

//  -----------------------------------------------

// 

// ABCD0102 : UARTCON (TXF=full_o, RXE=empty_o) (R only)

//   15    14    13    12    11    10     9      8

//    7     6     5     4     3     2     1      0

//  -----------------------------------------------

// |     |     |     |     |     |     | TXF | RXE |

//  -----------------------------------------------

// 

// ABCD0103 : UARTTXD(W only)/UARTRXD(R only)

//    7     6     5     4     3     2     1     0

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// | TR7 | TR6 | TR5 | TR4 | TR3 | TR2 | TR1 | TR0 |

//  -----------------------------------------------

// 

//======================================================

// System Controller

// Interrupt and Exception Controller

//======================================================

// ABCD0200 : INTCTL Interrupt Control (32bit R/W only)

//   31    30    29    28    27    26    25    24

//  -----------------------------------------------

// |E_NMI|E_IRQ|E_CER|E_DER|E_MRS|     |TMRON|BRKON|

//  -----------------------------------------------

//   23    22    21    20    19    18    17    16

//  -----------------------------------------------

// |ILVL3|ILVL2|ILVL1|ILVL0|IVEC7|IVEC6|IVEC5|IVEC4|

//  ----------------------------------------------- 

//   15    14    13    12    11    10     9     8

//  -----------------------------------------------

// |IVEC3|IVEC2|IVEC1|IVEC0|TMR11|TMR10|TMR09|TMR08|

//  -----------------------------------------------  

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |TMR07|TMR06|TMR05|TMR04|TMR03|TMR02|TMR01|TMR00|

//  ----------------------------------------------- 

//     bit31: E_NMI Emulate NMI Interrupt     (W only)

//     bit30: E_IRQ Emulate IRQ Interrupt     (W only)

//     bit29: E_CER Emulate CPU Address Error (W only)

//     bit28: E_DER Emulate DMA Address Error (W only)

//     bit27: E_MRS Emulate Manual Reset      (W only)                               

//     bit26: reserved

//     bit25: TMRON INTTMR OFF/ON             (0:OFF, 1:ON)

//     bit24: BRKON Address Break(NMI) OFF/ON (0:OFF, 1:ON)

//     bit23: ILVL3 IRQ ILevel 3

//     bit22: ILVL2 IRQ ILevel 2

//     bit21: ILVL1 IRQ ILevel 1

//     bit20: ILVL0 IRQ ILevel 0

//     bit19: IVEC7 IRQ Vector 7

//     bit18: IVEC6 IRQ Vector 6

//     bit17: IVEC5 IRQ Vector 5

//     bit16: IVEC4 IRQ Vector 4

//     bit15: IVEC3 IRQ Vector 3

//     bit14: IVEC2 IRQ Vector 2

//     bit13: IVEC1 IRQ Vector 1

//     bit12: IVEC0 IRQ Vector 0

//     bit11: TMR11 (12 bit interval timer to generate IRQ)

//     ...

//     bit 0: TMR00 (12 bit interval timer to generate IRQ)

// 

// ABCD0204 : BRKADR Break Address (16bit R/W only)

//   15    14    13    12    11    10     9     8

//  -----------------------------------------------

// |ADR15|ADR14|ADR13|ADR12|ADR11|ADR10|ADR09|ADR08|

//  -----------------------------------------------  

//    7     6     5     4     3     2     1     0

//  -----------------------------------------------

// |ADR07|ADR06|ADR05|ADR04|ADR03|ADR02|ADR01|ADR00|

//  ----------------------------------------------- 

//     bit15: ADR15 Break Address15

//     ...

//     bit00: ADR00 Break Address00

// 

#include "common.h"

//=================

// Define Functions

//=================

void utility(void);

unsigned char command(unsigned long *data);

unsigned long get_sformat(void);

unsigned char get_byte_rx_echo(void);

unsigned char hex2asc(unsigned char hex);

unsigned char asc2hex(unsigned char asc);

void          waitNms(unsigned char n);

unsigned char key_scan();

unsigned char key_wait_on(void);

void          key_wait_off(void);

void          uart_tx(unsigned char data);

unsigned char uart_rx(void);

unsigned char uart_rx_echo(void);

void          uart_rx_flush(void);

void          uart_set_baudrate(void);

void          lcd_disp_long(unsigned long data);

void          lcd_cursor(unsigned char con);

void          lcd_erase(unsigned char pos);

void          lcd_message(unsigned char pos, unsigned char *pstr);

void          lcd_disp(unsigned char chr);

void          lcd_pos(unsigned char pos);

void          lcd_ready(void);

unsigned char lcd_rd(int);

void          lcd_wr(int, unsigned char);

void          lcd_init(void);

//============

// IRQ Handler

//============

void irq_handler(void)

{

    unsigned char mes_irq[]  = "IRQ: Push to RTE";

    lcd_message(16, mes_irq);

    key_wait_off();

    key_wait_on();

    key_wait_off();

}

//============

// NMI Handler

//============

void nmi_handler(void)

{

    unsigned char mes_nmi[]  = "NMI/BRK:Goto Mon";

    SYS.INTCTL = SYS.INTCTL & 0xfeffffff; // BRK off

    lcd_message(16, mes_nmi);

    key_wait_off();

    key_wait_on();

    key_wait_off();

}

//=============

// TRAP Handler

//=============

void trap_handler(void)

{

    unsigned char mes_trap[] = "TRAP:Push to RTE";

    lcd_message(16, mes_trap);

    key_wait_off();

    key_wait_on();

    key_wait_off();

}

//====================

// Illegal Instruction

//====================

void illegal(void)

{

    unsigned char mes_ilgl[] = "Illegal:Goto Mon";

    lcd_message(16, mes_ilgl);

    key_wait_off();

    key_wait_on();

    key_wait_off();

}

//==============

// Address Error

//==============

void error(void)

{

    unsigned char mes_error[]= "AdrsErr:Goto Mon";

    lcd_message(16, mes_error);

    key_wait_off();

    key_wait_on();

    key_wait_off();

}

//=============

// Main Routine

//=============

void main_sh(void)

{

    unsigned char mes_welcome[]   = "SH-2 Monitor v.1";

    unsigned char mes_copyright[] = "(C) 2003 T.Aitch";

    unsigned char mes_memory[]    = "Memory--";

    unsigned char mes_run[]       = "Run---Good Luck!";

    unsigned char key;

    unsigned long adrs;

    unsigned long data;

    unsigned long data_edit;

    void (* userfunc)(void);

    long i;

    //-----------

    // Initialize

    //-----------

    lcd_init();

    uart_set_baudrate();

    uart_rx_flush();

    key_wait_off();

    //----------------

    // Welcome Message

    //----------------

    lcd_message( 0, mes_welcome);

    lcd_message(16, mes_copyright);

    for (i = 0 ; i < 2000000 ; i++);

    //----------

    // Clear LCD

    //----------

    key_wait_off();

    lcd_erase(0);

    lcd_erase(16);

    //----------------

    // Main Event Loop

    //----------------

    adrs = 0x00000000;

    while(1)

    {

        adrs = adrs & 0xfffffffc;

        data = * (unsigned long *) adrs;

        lcd_pos(0);

        lcd_disp_long(adrs);

        lcd_disp_long(data);

        lcd_message(16, mes_memory);

        data_edit = data;

        key = command(&data_edit);

        switch(key)

        {

            case KEYUTL: utility();

                         break;

            case KEYRUN: lcd_message(16, mes_run);

                         key_wait_off();

                         adrs = adrs & 0xfffffffe;

                         userfunc = (void (*)) adrs;

                         (* userfunc)();

                         break;

            case KEYGET: adrs = get_sformat();

                         break;

            case KEYPUT: break;

            case KEYADR: adrs = data_edit;

                         break;

            case KEYINC: adrs = adrs + 4;

                         break;

            case KEYDEC: adrs = adrs - 4;

                         break;

            case KEYDAT: * (unsigned long *) adrs = data_edit;

                         adrs = adrs + 4;

                         break;

            default:     break;

        }

    }

}

//****************************************************

//*                                                  *

//*                Service Utilities                 *

//*                                                  *

//****************************************************

//====================

// "Utility" Functions

//--------------------

//     Input  : none

//     Output : none

//====================

void utility(void)

{

    unsigned char mes_util[]   = "BRK-Func Select?";

    unsigned char mes_menu[]   = "1:REG  2:BRK SET";

    unsigned char mes_break[]  = "Set Break Point.";

    unsigned char mes_adrs[]   = "Address?";

    unsigned char mes_brkok[]  = "Break Accepted. ";

    unsigned char mes_brkng[]  = "Break Canceled. ";

    unsigned char mes_SR[]     = "SR     :";

    unsigned char mes_PC[]     = "PC     :";

    unsigned char mes_SP[]     = "SP(R15):";

    unsigned char mes_PR[]     = "PR     :";

    unsigned char mes_R0[]     = "R0     :";

    unsigned char mes_R1[]     = "R1     :";

    unsigned char mes_R2[]     = "R2     :";

    unsigned char mes_R3[]     = "R3     :";

    unsigned char mes_R4[]     = "R4     :";

    unsigned char mes_R5[]     = "R5     :";

    unsigned char mes_R6[]     = "R6     :";

    unsigned char mes_R7[]     = "R7     :";

    unsigned char mes_R8[]     = "R8     :";

    unsigned char mes_R9[]     = "R9     :";

    unsigned char mes_R10[]    = "R10    :";

    unsigned char mes_R11[]    = "R11    :";

    unsigned char mes_R12[]    = "R12    :";

    unsigned char mes_R13[]    = "R13    :";

    unsigned char mes_R14[]    = "R14    :";

    unsigned char mes_R15[]    = "R15    :";

    unsigned char mes_MACH[]   = "MACH   :";

    unsigned char mes_MACL[]   = "MACL   :";

    unsigned char mes_GBR[]    = "GBR    :";

    unsigned char mes_VBR[]    = "VBR    :";

    unsigned char key;

    unsigned long adrs;

    lcd_message(0, mes_util);

    lcd_message(16, mes_menu);

    key_wait_off();

    key = key_wait_on();

    if (key == KEY1)       // Register Watcher

    {

        key_wait_off();

        lcd_message(0,  mes_SR);   lcd_disp_long(REG.SR);

        lcd_message(16, mes_PC);   lcd_disp_long(REG.PC);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_SP);   lcd_disp_long(REG.SP);

        lcd_message(16, mes_PR);   lcd_disp_long(REG.PR);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R0);   lcd_disp_long(REG.R0);

        lcd_message(16, mes_R1);   lcd_disp_long(REG.R1);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R2);   lcd_disp_long(REG.R2);

        lcd_message(16, mes_R3);   lcd_disp_long(REG.R3);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R4);   lcd_disp_long(REG.R4);

        lcd_message(16, mes_R5);   lcd_disp_long(REG.R5);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R6);   lcd_disp_long(REG.R6);

        lcd_message(16, mes_R7);   lcd_disp_long(REG.R7);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R8);   lcd_disp_long(REG.R8);

        lcd_message(16, mes_R9);   lcd_disp_long(REG.R9);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R10);  lcd_disp_long(REG.R10);

        lcd_message(16, mes_R11);  lcd_disp_long(REG.R11);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R12);  lcd_disp_long(REG.R12);

        lcd_message(16, mes_R13);  lcd_disp_long(REG.R13);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_R14);  lcd_disp_long(REG.R14);

        lcd_message(16, mes_R15);  lcd_disp_long(REG.R15);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_MACH); lcd_disp_long(REG.MACH);

        lcd_message(16, mes_MACL); lcd_disp_long(REG.MACL);

        key_wait_on();

        key_wait_off();

        lcd_message(0,  mes_GBR);  lcd_disp_long(REG.GBR);

        lcd_message(16, mes_VBR);  lcd_disp_long(REG.VBR);

        key_wait_on();

        key_wait_off();

    }

    else if (key == KEY2)  // Break Setting

    {

        lcd_message(0, mes_break);

        lcd_message(16, mes_adrs);

        adrs = SYS.BRKADR;

        key = command(&adrs);

        if (key == KEYDAT)

        {

            lcd_message(0, mes_brkok);

            key_wait_off();

            SYS.BRKADR = adrs;

            SYS.INTCTL = SYS.INTCTL | 0x01000000; // BRK on

        }

        else

        {

            lcd_message(0, mes_brkng);

            key_wait_off();

            SYS.INTCTL = SYS.INTCTL & 0xfeffffff; // BRK off

        }

    }

}

//=========================================

// Command Handler

//-----------------------------------------

//     Input  : data    = display long data

//     Output : command = input command

//              data    = input long data

//=========================================

unsigned char command(unsigned long *data)

{

    unsigned char key;

    int i;

    lcd_pos(24);

    lcd_disp_long(*data);

    lcd_cursor(1);

    i = 0;

    do

    {

        if (i == 0) lcd_pos(24);

        key_wait_off();

        key = key_wait_on();

        if (key <= KEYF)

        {

            lcd_disp(hex2asc(key));

            *data = (*data & ~((0x0000000F) << ((7-i) * 4))) | (key << ((7-i) * 4));

        }

        i = (i + 1) % 8;

    } while (key <= KEYF);

    lcd_cursor(0);

    return(key);

}

//=================================================

// Get S-Format

//-------------------------------------------------

//     Input  : none

//     Output : get_sformat = address of top-record

//=================================================

unsigned long get_sformat(void)

{

    unsigned char mes_get[]       = "Get S-Format(S3)";

    unsigned char mes_send[]      = "please send.....";

    unsigned char mes_receive[]   = "-----OK!";

    unsigned char mes_get_error[] = "ERR:Bad S-Format";

    int topflag;

    int endflag;

    unsigned char rc;

    unsigned char rxdata;

    unsigned long adrs;

    unsigned long adrs_record;

    unsigned long adrs_top = 0;

    int count;

    unsigned char checksum;

    int error;

    int i;

    error = 0;

    topflag = 1;

    endflag = 0;

    uart_rx_flush();

    lcd_message( 0, mes_get);

    lcd_message(16, mes_send);

    while(endflag == 0)

    {

        //

        // Wait 'S' character

        //

        while (uart_rx_echo() != 'S');

        //

        // Check Record Type

        //

        switch(rc = uart_rx_echo())

        {

            case '3': //-------- Record of 4 byte length address

            case '7': //-------- End of Record

                      //

                      // Get Record Length

                      //

                      rxdata = get_byte_rx_echo();

                      checksum = rxdata;

                      count = rxdata - 5;

                      //

                      // Get Record Address

                      //

                      adrs = 0;

                      for (i = 0 ; i < 4 ; i++)

                      {

                          rxdata = get_byte_rx_echo();

                          checksum = checksum + rxdata;

                          adrs  = (adrs << 8) + (unsigned long) rxdata;

                      }

                      adrs_record = adrs;

                      if (topflag)

                      {

                          adrs_top = adrs;

                          topflag = 0;

                      }

                      //

                      // Get Record Data and Save to memory

                      //

                      while(count > 0)

                      {

                          rxdata = get_byte_rx_echo();

                          checksum = checksum + rxdata;

                          * (unsigned char *) adrs = rxdata;

                          adrs = adrs + 1;

                          count = count - 1;

                      }

                      //

                      // Check checksum

                      //

                      rxdata = get_byte_rx_echo();

                      checksum = (~checksum) & 0x0ff;

                      error = (checksum != rxdata);

                      //

                      // Continue ? or Finish ?

                      //

                      if (rc == '3') // S3 format

                          break;

                      else           // S7 format

                      {

                          endflag = 1;

                          break;

                      }

            //

            // ignore another Record

            //

            default : continue;

        }

        if (error)

        {

            lcd_message(16, mes_get_error);

            rc = key_wait_on();

            break;

        }

        else

        {

            lcd_pos(16);

            lcd_disp_long(adrs_record);

            lcd_message(24, mes_receive);

        }

    }

    return(adrs_top);

}

//==============================================

// Get Byte from Rx with echo

//----------------------------------------------

//     Input  : none

//     Output : get_byte_rx_echo = received byte

//==============================================

unsigned char get_byte_rx_echo(void)

{

    unsigned char hex;

    hex = asc2hex(uart_rx_echo());

    hex = (hex << 4) + asc2hex(uart_rx_echo());

    return(hex);

}

//=============================

// Convert Hex(nibble) to Ascii

//-----------------------------

//     Input  : hex (0x00-0x0F)

//     Output : hex2asc

//=============================

unsigned char hex2asc(unsigned char hex)

{

    hex = hex & 0x0f;

    if (hex <= 0x09)

        return(hex + '0');

    else