mcf5275_hi.c

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

    IRMD(INTC0, L7IACK, L7IACK, 8);
                
    if (!display_all)
        printf(INVREG,reg);
}
/********************************************************************/
static void
irmd_intc1 (char *reg, int regread, uint32 value)
{
    IRMD(INTC1, IPRH,   IPRH,   32);
    IRMD(INTC1, IPRL,   IPRL,   32);
    IRMD(INTC1, IMRH,   IMRH,   32);
    IRMD(INTC1, IMRL,   IMRL,   32);
    IRMD(INTC1, INTFRCH,    INTFRCH,    32);
    IRMD(INTC1, INTFRCL,    INTFRCL,    32);
    IRMD(INTC1, IRLR,   IRLR,   8);
    IRMD(INTC1, IACKLPR,    IACKLPR,    8);
    IRMD(INTC1, ICR8,   ICR8,   8);
    IRMD(INTC1, ICR9,   ICR9,   8);
    IRMD(INTC1, ICR10,  ICR10,  8);
    IRMD(INTC1, ICR11,  ICR11,  8);
    IRMD(INTC1, ICR12,  ICR12,  8);
    IRMD(INTC1, ICR13,  ICR13,  8);
    IRMD(INTC1, ICR14,  ICR14,  8);
    IRMD(INTC1, ICR15,  ICR15,  8);
    IRMD(INTC1, ICR16,  ICR16,  8);
    IRMD(INTC1, ICR17,  ICR17,  8);
    IRMD(INTC1, ICR18,  ICR18,  8);
    IRMD(INTC1, ICR19,  ICR19,  8);
    IRMD(INTC1, ICR20,  ICR20,  8);
    IRMD(INTC1, ICR21,  ICR21,  8);
    IRMD(INTC1, ICR22,  ICR22,  8);
    IRMD(INTC1, ICR23,  ICR23,  8);
    IRMD(INTC1, ICR24,  ICR24,  8);
    IRMD(INTC1, ICR25,  ICR25,  8);
    IRMD(INTC1, ICR26,  ICR26,  8);
    IRMD(INTC1, SWIACK, SWIACK, 8);
    IRMD(INTC1, L1IACK, L1IACK, 8);
    IRMD(INTC1, L2IACK, L2IACK, 8);
    IRMD(INTC1, L3IACK, L3IACK, 8);
    IRMD(INTC1, L4IACK, L4IACK, 8);
    IRMD(INTC1, L5IACK, L5IACK, 8);
    IRMD(INTC1, L6IACK, L6IACK, 8);
    IRMD(INTC1, L7IACK, L7IACK, 8);
                
    if (!display_all)
        printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_mdha (char *reg, int regread, uint32 value)
{
    IRMD(MDHA,  MDMR,   MDMR,   32);
    IRMD(MDHA,  MDCR,   MDCR,   32);
    IRMD(MDHA,  MDCMR,  MDCMR,  32);
    IRMD(MDHA,  MDSR,   MDSR,   32); 
    IRMD(MDHA,  MDIR,   MDIR,   32);
    IRMD(MDHA,  MDIMR,  MDIMR,  32);
    IRMD(MDHA,  MDDSR,  MDDSR,  32);
    IRMD(MDHA,  MDIN,   MDIN,   32);
    IRMD(MDHA,  MDA0,   MDA0,   32);
    IRMD(MDHA,  MDB0,   MDB0,   32);
    IRMD(MDHA,  MDC0,   MDC0,   32);
    IRMD(MDHA,  MDD0,   MDD0,   32);
    IRMD(MDHA,  MDE0,   MDE0,   32);
    IRMD(MDHA,  MDMDS,  MDMDS,  32);
    IRMD(MDHA,  MDA1,   MDA1,   32);
    IRMD(MDHA,  MDB1,   MDB1,   32);
    IRMD(MDHA,  MDC1,   MDC1,   32);
    IRMD(MDHA,  MDD1,   MDD1,   32);
    IRMD(MDHA,  MDE1,   MDE1,   32);
                
    if (!display_all)
        printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_skha (char *reg, int regread, uint32 value)
{
    IRMD(SKHA,  SKMR,   SKMR,  32);
    IRMD(SKHA,  SKCR,   SKCR,  32);
    IRMD(SKHA,  SKCMR,  SKCMR, 32);
    IRMD(SKHA,  SKSR,   SKSR,  32);
    IRMD(SKHA,  SKIR,   SKIR,  32);
    IRMD(SKHA,  SKIMR,  SKIMR, 32);
    IRMD(SKHA,  SKKSR,  SKKSR, 32);
    IRMD(SKHA,  SKDSR,  SKDSR, 32);
    IRMD(SKHA,  SKIN,   SKIN,  32);
    IRMD(SKHA,  SKOUT,  SKOUT, 32);
    IRMD(SKHA,  SKKDR0, SKKDR0,32);
    IRMD(SKHA,  SKKDR1, SKKDR1,32);
    IRMD(SKHA,  SKKDR2, SKKDR2,32);
    IRMD(SKHA,  SKKDR3, SKKDR3,32);
    IRMD(SKHA,  SKKDR4, SKKDR4,32);
    IRMD(SKHA,  SKKDR5, SKKDR5,32);
    IRMD(SKHA,  SKCR0,  SKCR0, 32);
    IRMD(SKHA,  SKCR1,  SKCR1, 32);
    IRMD(SKHA,  SKCR2,  SKCR2, 32);
    IRMD(SKHA,  SKCR3,  SKCR3, 32);
    IRMD(SKHA,  SKCR4,  SKCR4, 32);
    IRMD(SKHA,  SKCR5,  SKCR5, 32);
    IRMD(SKHA,  SKCR6,  SKCR6, 32);
    IRMD(SKHA,  SKCR7,  SKCR7, 32);
    IRMD(SKHA,  SKCR8,  SKCR8, 32);
    IRMD(SKHA,  SKCR9,  SKCR9, 32);
    IRMD(SKHA,  SKCR10, SKCR10,32);
    IRMD(SKHA,  SKCR11, SKCR11,32);

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

/********************************************************************/
static void
irmd_pwm (char *reg, int regread, uint32 value)
{
    IRMD(PWM,   PWME,    PWME,    8);
    IRMD(PWM,   PWMPOL,  PWMPOL,  8);
    IRMD(PWM,   PWMCLK,  PWMCLK,  8);
    IRMD(PWM,   PWMPRCLK,PWMPRCLK,8);
    IRMD(PWM,   PWMCAE,  PWMCAE,  8);
    IRMD(PWM,   PWMCTL,  PWMCTL,  8);
    IRMD(PWM,   PWMSCLA, PWMSCLA, 8);
    IRMD(PWM,   PWMSCLB, PWMSCLB, 8);
    IRMD(PWM,   PWMCNT0, PWMCNT0, 8);
    IRMD(PWM,   PWMCNT1, PWMCNT1, 8);
    IRMD(PWM,   PWMCNT2, PWMCNT2, 8);
    IRMD(PWM,   PWMCNT3, PWMCNT3, 8);
    IRMD(PWM,   PWMPER0, PWMPER0, 8);
    IRMD(PWM,   PWMPER1, PWMPER1, 8);
    IRMD(PWM,   PWMPER2, PWMPER2, 8);
    IRMD(PWM,   PWMPER3, PWMPER3, 8);
    IRMD(PWM,   PWMDTY0, PWMDTY0, 8);
    IRMD(PWM,   PWMDTY1, PWMDTY1, 8);
    IRMD(PWM,   PWMDTY2, PWMDTY2, 8);
    IRMD(PWM,   PWMDTY3, PWMDTY3, 8);

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

/********************************************************************/
static void
irmd_rng (char *reg, int regread, uint32 value)
{
    IRMD(RNG,   RNGCR,  RNGCR,  32);
    IRMD(RNG,   RNGSR,  RNGSR,  32);
    IRMD(RNG,   RNGER,  RNGER,  32);
    IRMD(RNG,   RNGOUT, RNGOUT, 32);

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

/********************************************************************/
static void
irmd_usb (char *reg, int regread, uint32 value)
{
    IRMD(USB,   FRAME,  FRAME,   32);
    IRMD(USB,   SPEC,   SPEC,    32);
    IRMD(USB,   SR,     SR,      32);
    IRMD(USB,   CR,     CR,      32);
    IRMD(USB,   DAR,    DAR,     32);
    IRMD(USB,   DDR,    DDR,     32);
    IRMD(USB,   ISR,    ISR,     32);
    IRMD(USB,   IMR,    IMR,     32);
    IRMD(USB,   MCR,    MCR,     32);
    IRMD(USB,   EP0SR,  EP0SR,   32);
    IRMD(USB,   EP1SR,  EP1SR,   32);
    IRMD(USB,   EP2SR,  EP2SR,   32);
    IRMD(USB,   EP3SR,  EP3SR,   32);

    IRMD(USB,   EP0ISR, EP0ISR,  32);
    IRMD(USB,   EP1ISR, EP1ISR,  32);
    IRMD(USB,   EP2ISR, EP2ISR,  32);
    IRMD(USB,   EP3ISR, EP3ISR,  32);

    IRMD(USB,   EP0IMR, EP0IMR,  32);
    IRMD(USB,   EP1IMR, EP1IMR,  32);
    IRMD(USB,   EP2IMR, EP2IMR,  32);
    IRMD(USB,   EP3IMR, EP3IMR,  32);

    IRMD(USB,   EP0FDR, EP0FDR,  32);
    IRMD(USB,   EP1FDR, EP1FDR,  32);
    IRMD(USB,   EP2FDR, EP2FDR,  32);
    IRMD(USB,   EP3FDR, EP3FDR,  32);

    IRMD(USB,   EP0FSR, EP0FSR,  32);
    IRMD(USB,   EP1FSR, EP1FSR,  32);
    IRMD(USB,   EP2FSR, EP2FSR,  32);
    IRMD(USB,   EP3FSR, EP3FSR,  32);

    IRMD(USB,   EP0FCR, EP0FCR,  32);
    IRMD(USB,   EP1FCR, EP1FCR,  32);
    IRMD(USB,   EP2FCR, EP2FCR,  32);
    IRMD(USB,   EP3FCR, EP3FCR,  32);

    IRMD(USB,   EP0LRFP,EP0LRFP, 32);
    IRMD(USB,   EP1LRFP,EP1LRFP, 32);
    IRMD(USB,   EP2LRFP,EP2LRFP, 32);
    IRMD(USB,   EP3LRFP,EP3LRFP, 32);

    IRMD(USB,   EP0LWFP,EP0LWFP, 32);
    IRMD(USB,   EP1LWFP,EP1LWFP, 32);
    IRMD(USB,   EP2LWFP,EP2LWFP, 32);
    IRMD(USB,   EP3LWFP,EP3LWFP, 32);

    IRMD(USB,   EP0FAR, EP0FAR,  32);
    IRMD(USB,   EP1FAR, EP1FAR,  32);
    IRMD(USB,   EP2FAR, EP2FAR,  32);
    IRMD(USB,   EP3FAR, EP3FAR,  32);

    IRMD(USB,   EP0FRP, EP0FRP,  32);
    IRMD(USB,   EP1FRP, EP1FRP,  32);
    IRMD(USB,   EP2FRP, EP2FRP,  32);
    IRMD(USB,   EP3FRP, EP3FRP,  32);

    IRMD(USB,   EP0FWP, EP0FWP,  32);
    IRMD(USB,   EP1FWP, EP1FWP,  32);
    IRMD(USB,   EP2FWP, EP2FWP,  32);
    IRMD(USB,   EP3FWP, EP3FWP,  32);

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

/********************************************************************/
static const struct module_t
{
    char    *module;
    void    (*func)(char *, int, uint32);
} MODULE[] =
{

    {"SCM",     irmd_scm},
    {"CS0",     irmd_cs0},
    {"CS1",     irmd_cs1},
    {"CS2",     irmd_cs2},
    {"CS3",     irmd_cs3},
    {"CS4",     irmd_cs4},
    {"CS5",     irmd_cs5},
    {"CS6",     irmd_cs6},
    {"CS7",     irmd_cs7},  
    {"GPIO",    irmd_gpio},
    {"QSPI",    irmd_qspi},
    {"DMA0",    irmd_dma0},
    {"DMA1",    irmd_dma1},
    {"DMA2",    irmd_dma2},
    {"DMA3",    irmd_dma3},
    {"UART0",   irmd_uart0},
    {"UART1",   irmd_uart1},
    {"UART2",   irmd_uart2},
    {"SDRAMC",  irmd_sdramc},
    {"TIMER0",  irmd_dma_timer0},
    {"TIMER1",  irmd_dma_timer1},
    {"TIMER2",  irmd_dma_timer2},
    {"TIMER3",  irmd_dma_timer3},
    {"FEC0",    irmd_fec0},
    {"FEC1",    irmd_fec1},
    {"I2C",     irmd_i2c},
    {"WTM",     irmd_wtm},
    {"PIT0",    irmd_pit0},
    {"PIT1",    irmd_pit1},
    {"PIT2",    irmd_pit2},
    {"PIT3",    irmd_pit3},
    {"RESET",   irmd_reset},
    {"CCM",     irmd_ccm},
    {"CLOCK",   irmd_clock},
    {"EPORT",   irmd_eport},
    {"INTC0",   irmd_intc0},
    {"INTC1",   irmd_intc1},
    {"MDHA",    irmd_mdha},
    {"SKHA",    irmd_skha},
    {"PWM", irmd_pwm},
    {"RNG", irmd_rng},
    {"USB", irmd_usb}
    

} ;

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

/********************************************************************/
void
mcf5275_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 (IPSBAR = %#08X):",IPSBAR_ADDRESS);
        for (mi = 0; mi < MODULE_SIZE; ++mi)
        {
            if (!(mi % 8))
                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)
{
    if (vector < 64 || vector > 192)
        return;
    switch (vector)
    {
        case 65: /* Eport Interrupt 1 */
        case 66: /* Eport Interrupt 2 */
        case 67: /* Eport Interrupt 3 */
        case 68: /* Eport Interrupt 4 */
        case 69: /* Eport Interrupt 5 */
        case 70: /* Eport Interrupt 6 */
        case 71: /* Eport Interrupt 7 */

            /* 
             * Clear the interrupt source 
             * This clears the flag for edge triggered interrupts
             */
            MCF_EPORT_EPFR = (uint8)(0x01 << (vector - 64));
            printf("Edge Port Interrupt #%d\n",vector - 64);
            break;  
        default:
            printf("User Defined Vector #%d\n",vector);
            break;
    }
}
/********************************************************************/