mcf5204_hi.c

motorola 针对coldfire 5275 评估板的Dbug bootloader源程序

/*
 * File:        mcf5204_hi.c
 * Purpose:     MCF5204 high level processing.
 *
 * Notes:
 *
 */

#include "src/include/dbug.h"

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

/*
 * CPU name string and source code version for display at boot-up.
 */
const char CPU_STR[] = "ColdFire MCF5204";
const int  CPU_VER_MAJOR   = 1;
const char CPU_VER_MINOR   = 'a';

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

static const char FORMAT8[]  = "%8s: %02X\n";
static const char FORMAT16[] = "%8s: %04X\n";
static const char FORMAT32[] = "%8s: %08X\n";

static const char INVMOD[] = "Error: Invalid Module: %s\n";

#define IRMD(MOD,RDREG,WRREG,SIZE)  \
if ((strcasecmp(#RDREG,reg) == 0) || display_all)   \
{                                                   \
    if (regread)                                    \
    {                                               \
    printf(FORMAT ## SIZE, #RDREG, MCF5204_RD_ ## MOD ## _ ## RDREG(imm)); \
    pause(&displayed);                              \
    }                                               \
    else                                            \
        MCF5204_WR_ ## MOD ## _ ## WRREG(imm,value);    \
                                                    \
    if (!display_all)                               \
        return;                                     \
}

#define IRMD_NOWR(MOD,RDREG,SIZE)  \
if ((strcasecmp(#RDREG,reg) == 0) || display_all)       \
{                                                   \
    if (regread)                                    \
    {                                               \
    printf(FORMAT ## SIZE, #RDREG, MCF5204_RD_ ## MOD ## _ ## RDREG(imm)); \
    pause(&displayed);                              \
    }                                               \
                                                    \
    if (!display_all)                               \
        return;                                     \
}

#define IRMD_NORD(MOD,WRREG,SIZE)  \
if ((strcasecmp(#WRREG,reg) == 0) || display_all)   \
{                                                   \
    if (regread)                                    \
    {                                               \
        printf(" %8s: XX\n",#WRREG);                \
        pause(&displayed);                          \
    }                                               \
    else                                            \
        MCF5204_WR_ ## MOD ## _ ## WRREG(imm,value);    \
                                                    \
    if (!display_all)                               \
        return;                                     \
}

static int display_all;
static int displayed;

#define REGREAD     (1)
#define REGWRITE    (0)

/********************************************************************/
static void
irmd_sim (void *imm, char *reg, int regread, uint32 value)
{
    IRMD(SIM, SIMR,     SIMR,   8);
    IRMD(SIM, ICR_E0,   ICR_E0, 8);
    IRMD(SIM, ICR_E1,   ICR_E1, 8);
    IRMD(SIM, ICR_E2,   ICR_E2, 8);
    IRMD(SIM, ICR_E3,   ICR_E3, 8);
    IRMD(SIM, ICR_SW,   ICR_SW, 8);
    IRMD(SIM, ICR_T1,   ICR_T1, 8);
    IRMD(SIM, ICR_T2,   ICR_T2, 8);
    IRMD(SIM, ICR_U1,   ICR_U1, 8);
    IRMD(SIM, IMR,      IMR,    32);
    IRMD(SIM, IPR,      IPR,    32);
    IRMD(SIM, RSR,      RSR,    8);
    IRMD(SIM, SYPCR,    SYPCR,  8);
    IRMD(SIM, SWIVR,    SWIVR,  8);
    IRMD(SIM, SWSR,     SWSR,   8);
    IRMD(SIM, CSAR0,    CSAR0,  32);
    IRMD(SIM, CSMR0,    CSMR0,  32);
    IRMD(SIM, CSCR0,    CSCR0,  32);
    IRMD(SIM, CSAR1,    CSAR1,  32);
    IRMD(SIM, CSMR1,    CSMR1,  32);
    IRMD(SIM, CSCR1,    CSCR1,  32);
    IRMD(SIM, CSAR2,    CSAR2,  32);
    IRMD(SIM, CSMR2,    CSMR2,  32);
    IRMD(SIM, CSCR2,    CSCR2,  32);
    IRMD(SIM, CSAR3,    CSAR3,  32);
    IRMD(SIM, CSMR3,    CSMR3,  32);
    IRMD(SIM, CSCR3,    CSCR3,  32);
    IRMD(SIM, CSAR4,    CSAR4,  32);
    IRMD(SIM, CSMR4,    CSMR4,  32);
    IRMD(SIM, CSCR4,    CSCR4,  32);
    IRMD(SIM, CSAR5,    CSAR5,  32);
    IRMD(SIM, CSMR5,    CSMR5,  32);
    IRMD(SIM, CSCR5,    CSCR5,  32);
    IRMD(SIM, PAR,      PAR,    8);
    IRMD(SIM, PADDR,    PADDR,  8);
    IRMD(SIM, PADAT,    PADAT,  8);

    if (!display_all)
        printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_uart (void *imm, char *reg, int regread, uint32 value)
{
    IRMD(UART, UMR,     UMR,    8);
    IRMD(UART, USR,     UCSR,   8);
    IRMD_NORD(UART,     UCR,    8);
    IRMD(UART, URB,     UTB,    8);
    IRMD(UART, UIPCR,   UACR,   8);
    IRMD(UART, UISR,    UIMR,   8);
    IRMD_NORD(UART,     UBG1,   8);
    IRMD_NORD(UART,     UBG2,   8);
    IRMD(UART, UIVR,    UIVR,   8);
    IRMD_NOWR(UART,     UIP,    8);
    IRMD_NORD(UART,     UOP1,   8);
    IRMD_NORD(UART,     UOP0,   8);

    if (!display_all)
        printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_timer (void *imm, char *reg, int regread, uint32 value)
{
    IRMD(TIMER, TMR1,   TMR1,   16);
    IRMD(TIMER, TRR1,   TRR1,   16);
    IRMD(TIMER, TCR1,   TCR1,   16);
    IRMD(TIMER, TCN1,   TCN1,   16);
    IRMD(TIMER, TER1,   TER1,   8);
    IRMD(TIMER, TMR2,   TMR2,   16);
    IRMD(TIMER, TRR2,   TRR2,   16);
    IRMD(TIMER, TCR2,   TCR2,   16);
    IRMD(TIMER, TCN2,   TCN2,   16);
    IRMD(TIMER, TER2,   TER2,   8);

    if (!display_all)
        printf(INVREG,reg);
}

/********************************************************************/
static const struct module_t
{
    char    *module;
    void    (*func)(void *,char *, int, uint32);
} MODULE[] =
{
    {"SIM",     irmd_sim},
    {"UART",    irmd_uart},
    {"TIMER",   irmd_timer},
} ;
 
#define MODULE_SIZE (int)(sizeof(MODULE)/sizeof(struct module_t))

/********************************************************************/
void
mcf5204_irmd (int argc, char **argv)
{
    uint32 value;
    char *rstr;
    char mstr[20];
    int mi, success;

    display_all = FALSE;
    displayed = 0;

    if (argc == 1)
    {
        printf("Internal Modules (MBAR = %#08X):",MBAR_ADDRESS);
        for (mi = 0; mi < MODULE_SIZE; ++mi)
        {
            if ((mi % 8) == 0)
                printf("\n");
            printf("%-8s ",MODULE[mi].module);
        }
        printf("\n\n");
        return;
    }

    /*
     * Pick out module name and Point to register name
     */
    mi = 0;
    rstr = argv[1];
    while (*rstr != '.')
    {
        mstr[mi++] = *rstr;
        if (*++rstr == '\0')
        {
            rstr = NULL;
            break;
        }
    }
    mstr[mi] = '\0';
    if (rstr != NULL)
    {
        if (*rstr == '.')
            ++rstr;
    }

    /*
     * Get the new value
     */
    if (argc == 3)
    {
        if (rstr == NULL)
        {
            printf("Error:  Invalid Register:  %s\n",argv[1]);
            return;
        }
        value = get_value(argv[2],&success,16);
        if (success == 0)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }
    else
        value = 0;

    /*
     * Determine which module
     */
    for (mi = 0; mi < MODULE_SIZE; ++mi)
    {
        if (strcasecmp(MODULE[mi].module,mstr) == 0)
        {
            if (argc == 3)  /* modify operation */
            {
                MODULE[mi].func(rstr, REGWRITE, value);
            }
            else
            {
                /* display operation */
                if (rstr == NULL)
                {
                    display_all = TRUE;
                    printf("Module: %s\n",MODULE[mi].module);
                }
                MODULE[mi].func(rstr, REGREAD, 0);
            }
            return;
        }
    }

    printf(INVMOD,argv[1]);
}
/********************************************************************/
void
cpu_handle_interrupt (int vector)
{
    printf("User Defined Vector #%d\n",vector);
}
/********************************************************************/