mcf5249_hi.c

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

    IRMD(UART1, UIVR,   UIVR,   8);
    IRMD_NOWR(UART1,    UIP,    8);
    IRMD_NORD(UART1,    UOP1,   8);
    IRMD_NORD(UART1,    UOP0,   8);

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

/********************************************************************/
static void
irmd_sdramc (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(DRAMC, DCR,    DCR,    16);
    IRMD(DRAMC, DACR0,  DACR0,  32);
    IRMD(DRAMC, DMR0,   DMR0,   32);
    IRMD(DRAMC, DACR1,  DACR1,  32);
    IRMD(DRAMC, DMR1,   DMR1,   32);

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

/********************************************************************/
static void
irmd_timer0 (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(TIMER0,    TMR,    TMR,    16);
    IRMD(TIMER0,    TRR,    TRR,    16);
    IRMD_NOWR(TIMER0,       TCR,    16);
    IRMD(TIMER0,    TCN,    TCN,    16);
    IRMD(TIMER0,    TER,    TER,    8);

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

/********************************************************************/
static void
irmd_timer1 (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(TIMER1,    TMR,    TMR,    16);
    IRMD(TIMER1,    TRR,    TRR,    16);
    IRMD_NOWR(TIMER1,       TCR,    16);
    IRMD(TIMER1,    TCN,    TCN,    16);
    IRMD(TIMER1,    TER,    TER,    8);

    if (!display_all)
        printf(INVREG,reg);
}
/********************************************************************/
static void
irmd_audio (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(AUDIO,     IIS1_CFG,   IIS1_CFG,   32);
    IRMD(AUDIO,     IIS2_CFG,   IIS2_CFG,   32);
    IRMD(AUDIO,     IIS3_CFG,   IIS3_CFG,   32);
    IRMD(AUDIO,     IIS4_CFG,   IIS4_CFG,   32);
    IRMD(AUDIO,     EBU_CFG,    EBU_CFG,    32);
    IRMD(AUDIO,     EBU_RCV_C_CH_1, EBU_RCV_C_CH_1, 32);
    IRMD(AUDIO,     EBU_TX_C_CH_1,  EBU_TX_C_CH_1,  32);
    IRMD(AUDIO,     EBU_TX_C_CH_2,  EBU_TX_C_CH_2,  32);

    IRMD(AUDIO,     DATA_IN_CONTROL,    DATA_IN_CONTROL,    16);
    IRMD(AUDIO,     PDIR1_L,    PDIR1_L,    32);
    IRMD(AUDIO,     PDIR3_L,    PDIR3_L,    32);
    IRMD(AUDIO,     PDIR1_R,    PDIR1_R,    32);
    IRMD(AUDIO,     PDIR3_R,    PDIR3_R,    32);

    IRMD(AUDIO,     PDOR1_L,    PDOR1_L,    32);
    IRMD(AUDIO,     PDOR1_R,    PDOR1_R,    32);
    IRMD(AUDIO,     PDOR2_L,    PDOR2_L,    32);
    IRMD(AUDIO,     PDOR2_R,    PDOR2_R,    32);
    IRMD(AUDIO,     PDOR3,  PDOR3,  32);
    IRMD(AUDIO,     PDIR,   PDIR,   32);

    IRMD(AUDIO,     U_CHANNEL_XMIT, U_CHANNEL_XMIT, 32);
    IRMD(AUDIO,     U_CHANNEL_RCV,  U_CHANNEL_RCV,  32);
    IRMD(AUDIO,     Q_CHANNEL_RCV,  Q_CHANNEL_RCV,  32);

    IRMD(AUDIO,     CD_TEXT_CONTROL,    CD_TEXT_CONTROL,    8);

    IRMD(AUDIO,     INTERRUPT_EN,   INTERRUPT_EN,   32);
    IRMD(AUDIO,     INTERRUPT_CLEAR,    INTERRUPT_CLEAR,    32);
    IRMD(AUDIO,     INTERRUPT_STAT, INTERRUPT_STAT, 32);
    IRMD(AUDIO,     DMA_CONFIG, DMA_CONFIG, 8);
    IRMD(AUDIO,     PHASE_CONFIG,   PHASE_CONFIG,   8);
    IRMD(AUDIO,     XTRIM,  XTRIM,  16);
    IRMD(AUDIO,     FREQ_MEAS,  FREQ_MEAS,  32);

    IRMD(AUDIO,     BLOCK_CONTROL,  BLOCK_CONTROL,  16);
    IRMD(AUDIO,     GLOB,   GLOB,   16);
    IRMD(AUDIO,     EBU2_CONFIG,    EBU2_CONFIG,    32);
    IRMD(AUDIO,     EBU2_RCV_C_CNL_1,   EBU2_RCV_C_CNL_1,   32);
    IRMD(AUDIO,     U2_CHANNEL_RCV, U2_CHANNEL_RCV, 32);
    IRMD(AUDIO,     Q2_CHANNEL_RCV, Q2_CHANNEL_RCV, 32);

    if (!display_all)
        printf(INVREG,reg);
}
/********************************************************************/
static void
irmd_adc (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(ADC,   ADCONFIG,   ADCONFIG,   16);
    IRMD(ADC,   ADVALUE,    ADVALUE,    16);

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

/********************************************************************/
static void
irmd_i2c (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(I2C,   MADR,   MADR,   8);
    IRMD(I2C,   MFDR,   MFDR,   8);
    IRMD(I2C,   MBCR,   MBCR,   8);
    IRMD(I2C,   MBSR,   MBSR,   8);
    IRMD(I2C,   MBDR,   MBDR,   8);

    if (!display_all)
        printf(INVREG,reg);
}
/********************************************************************/
static void
irmd_i2c2 (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(I2C2,  MADR,   MADR,   8);
    IRMD(I2C2,  MFDR,   MFDR,   8);
    IRMD(I2C2,  MBCR,   MBCR,   8);
    IRMD(I2C2,  MBSR,   MBSR,   8);
    IRMD(I2C2,  MBDR,   MBDR,   8);

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

/********************************************************************/
static void
irmd_flashmedia (/*void *imm,*/ char *reg, int regread, uint32 value)
{
    IRMD(FLASHMEDIA,    CONFIG, CONFIG, 32);
    IRMD(FLASHMEDIA,    CMD1,   CMD1,   32);
    IRMD(FLASHMEDIA,    CMD2,   CMD2,   32);
    IRMD(FLASHMEDIA,    DATA1,  DATA1,  32);
    IRMD(FLASHMEDIA,    DATA2,  DATA2,  32);
    IRMD(FLASHMEDIA,    STATUS, STATUS, 32);
    IRMD(FLASHMEDIA,    INT_EN, INT_EN, 32);
    IRMD(FLASHMEDIA,    INT_STAT,   INT_STAT,   32);
    IRMD(FLASHMEDIA,    INT_CLEAR,  INT_CLEAR,  32);

    if (!display_all)
        printf(INVREG,reg);
}
/********************************************************************/
static const struct module_t
{
    char    *module;
    void    (*func)(char *, int, uint32);
} MODULE[] =
{
    {"SIM",     irmd_sim},
    {"CS",      irmd_cs},
    {"PLL",     irmd_pll},
    {"QSPI",    irmd_qspi},
    {"DMA0",    irmd_dma0},
    {"DMA1",    irmd_dma1},
    {"DMA2",    irmd_dma2},
    {"DMA3",    irmd_dma3},
    {"UART0",   irmd_uart0},
    {"UART1",   irmd_uart1},
    {"SDRAMC",  irmd_sdramc},
    {"TIMER0",  irmd_timer0},
    {"TIMER1",  irmd_timer1},
    {"AUDIO",   irmd_audio},
    {"ADC", irmd_adc},
    {"I2C", irmd_i2c},
    {"I2C2",    irmd_i2c2},
    {"FLASHMEDIA",  irmd_flashmedia}


} ;

#define MODULE_SIZE (int)(sizeof(MODULE)/sizeof(struct module_t))

/********************************************************************/
void
mcf5249_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]);
}
/********************************************************************/