mcf548x_hi.c

来自「motorola 针对coldfire 5275 评估板的Dbug bootlo」· C语言 代码 · 共 1,127 行 · 第 1/3 页

    IRMD(USB, EP1LRFP,  32);
    IRMD(USB, EP2LRFP,  32);
    IRMD(USB, EP3LRFP,  32);
    IRMD(USB, EP4LRFP,  32);
    IRMD(USB, EP5LRFP,  32);
    IRMD(USB, EP6LRFP,  32);
    IRMD(USB, EP0LWFP,  32);
    IRMD(USB, EP1LWFP,  32);
    IRMD(USB, EP2LWFP,  32);
    IRMD(USB, EP3LWFP,  32);
    IRMD(USB, EP4LWFP,  32);
    IRMD(USB, EP5LWFP,  32);
    IRMD(USB, EP6LWFP,  32);
}
/********************************************************************/
#ifdef CPU_MCF548X
static void
irmd_can0 (char *reg, int regread, uint32 value)
{
    IRMD(CAN, CANMCR0,   32);
    IRMD(CAN, CANCTRL0,  32);
    IRMD(CAN, TIMER0,    32);
    IRMD(CAN, RXGMASK0,  32);
    IRMD(CAN, RX14MASK0, 32);
    IRMD(CAN, RX15MASK0, 32);
    IRMD(CAN, ERRCNT0,   32);
    IRMD(CAN, ERRSTAT0,  32);
    IRMD(CAN, IMASK0,    16);
    IRMD(CAN, IFLAG0,    16);
}
/********************************************************************/
static void
irmd_can1 (char *reg, int regread, uint32 value)
{
    IRMD(CAN, CANMCR1,   32);
    IRMD(CAN, CANCTRL1,  32);
    IRMD(CAN, TIMER1,    32);
    IRMD(CAN, RXGMASK1,  32);
    IRMD(CAN, RX14MASK1, 32);
    IRMD(CAN, RX15MASK1, 32);
    IRMD(CAN, ERRCNT1,   32);
    IRMD(CAN, ERRSTAT1,  32);
    IRMD(CAN, IMASK1,    16);
    IRMD(CAN, IFLAG1,    16);
}
#endif
/********************************************************************/
static void
irmd_psc0 (char *reg, int regread, uint32 value)
{
    IRMD(PSC, MR0,       8);
    IRMD(PSC, SR0,      16);
    IRMD(PSC, CSR0,      8);
    IRMD(PSC, CR0,       8);
    IRMD(PSC, RB0,      32);
    IRMD(PSC, TB0,      32);
    IRMD(PSC, IPCR0,     8);
    IRMD(PSC, ACR0,      8);
    IRMD(PSC, ISR0,     16);
    IRMD(PSC, IMR0,     16);
    IRMD(PSC, CTUR0,     8);
    IRMD(PSC, CTLR0,     8);
    IRMD(PSC, IP0,       8);
    IRMD(PSC, OPSET0,    8);
    IRMD(PSC, OPRESET0,  8);
    IRMD(PSC, SICR0,     8);
    IRMD(PSC, IRCR10,    8);
    IRMD(PSC, IRCR20,    8);
    IRMD(PSC, IRSDR0,    8);
    IRMD(PSC, IRMDR0,    8);
    IRMD(PSC, IRFDR0,    8);
    IRMD(PSC, RFCNT0,   16);
    IRMD(PSC, TFCNT0,   16);
    IRMD(PSC, RFSR0,    16);
    IRMD(PSC, TFSR0,    16);
    IRMD(PSC, RFCR0,    32);
    IRMD(PSC, TFCR0,    32);
    IRMD(PSC, RFAR0,    16);
    IRMD(PSC, TFAR0,    16);
    IRMD(PSC, RFRP0,    16);
    IRMD(PSC, TFRP0,    16);
    IRMD(PSC, RFWP0,    16);
    IRMD(PSC, TFWP0,    16);
    IRMD(PSC, RLRFP0,   16);
    IRMD(PSC, TLRFP0,   16);
    IRMD(PSC, RLWFP0,   16);
    IRMD(PSC, TLWFP0,   16);
}
/********************************************************************/
static void
irmd_psc1 (char *reg, int regread, uint32 value)
{
    IRMD(PSC, MR1,       8);
    IRMD(PSC, SR1,      16);
    IRMD(PSC, CSR1,      8);
    IRMD(PSC, CR1,       8);
    IRMD(PSC, RB1,      32);
    IRMD(PSC, TB1,      32);
    IRMD(PSC, IPCR1,     8);
    IRMD(PSC, ACR1,      8);
    IRMD(PSC, ISR1,     16);
    IRMD(PSC, IMR1,     16);
    IRMD(PSC, CTUR1,     8);
    IRMD(PSC, CTLR1,     8);
    IRMD(PSC, IP1,       8);
    IRMD(PSC, OPSET1,    8);
    IRMD(PSC, OPRESET1,  8);
    IRMD(PSC, SICR1,     8);
    IRMD(PSC, IRCR11,    8);
    IRMD(PSC, IRCR21,    8);
    IRMD(PSC, IRSDR1,    8);
    IRMD(PSC, IRMDR1,    8);
    IRMD(PSC, IRFDR1,    8);
    IRMD(PSC, RFCNT1,   16);
    IRMD(PSC, TFCNT1,   16);
    IRMD(PSC, RFSR1,    16);
    IRMD(PSC, TFSR1,    16);
    IRMD(PSC, RFCR1,    32);
    IRMD(PSC, TFCR1,    32);
    IRMD(PSC, RFAR1,    16);
    IRMD(PSC, TFAR1,    16);
    IRMD(PSC, RFRP1,    16);
    IRMD(PSC, TFRP1,    16);
    IRMD(PSC, RFWP1,    16);
    IRMD(PSC, TFWP1,    16);
    IRMD(PSC, RLRFP1,   16);
    IRMD(PSC, TLRFP1,   16);
    IRMD(PSC, RLWFP1,   16);
    IRMD(PSC, TLWFP1,   16);
}
/********************************************************************/
static void
irmd_psc2 (char *reg, int regread, uint32 value)
{
    IRMD(PSC, MR2,       8);
    IRMD(PSC, SR2,      16);
    IRMD(PSC, CSR2,      8);
    IRMD(PSC, CR2,       8);
    IRMD(PSC, RB2,      32);
    IRMD(PSC, TB2,      32);
    IRMD(PSC, IPCR2,     8);
    IRMD(PSC, ACR2,      8);
    IRMD(PSC, ISR2,     16);
    IRMD(PSC, IMR2,     16);
    IRMD(PSC, CTUR2,     8);
    IRMD(PSC, CTLR2,     8);
    IRMD(PSC, IP2,       8);
    IRMD(PSC, OPSET2,    8);
    IRMD(PSC, OPRESET2,  8);
    IRMD(PSC, SICR2,     8);
    IRMD(PSC, IRCR12,    8);
    IRMD(PSC, IRCR22,    8);
    IRMD(PSC, IRSDR2,    8);
    IRMD(PSC, IRMDR2,    8);
    IRMD(PSC, IRFDR2,    8);
    IRMD(PSC, RFCNT2,   16);
    IRMD(PSC, TFCNT2,   16);
    IRMD(PSC, RFSR2,    16);
    IRMD(PSC, TFSR2,    16);
    IRMD(PSC, RFCR2,    32);
    IRMD(PSC, TFCR2,    32);
    IRMD(PSC, RFAR2,    16);
    IRMD(PSC, TFAR2,    16);
    IRMD(PSC, RFRP2,    16);
    IRMD(PSC, TFRP2,    16);
    IRMD(PSC, RFWP2,    16);
    IRMD(PSC, TFWP2,    16);
    IRMD(PSC, RLRFP2,   16);
    IRMD(PSC, TLRFP2,   16);
    IRMD(PSC, RLWFP2,   16);
    IRMD(PSC, TLWFP2,   16);
}
/********************************************************************/
static void
irmd_psc3 (char *reg, int regread, uint32 value)
{
    IRMD(PSC, MR3,       8);
    IRMD(PSC, SR3,      16);
    IRMD(PSC, CSR3,      8);
    IRMD(PSC, CR3,       8);
    IRMD(PSC, RB3,      32);
    IRMD(PSC, TB3,      32);
    IRMD(PSC, IPCR3,     8);
    IRMD(PSC, ACR3,      8);
    IRMD(PSC, ISR3,     16);
    IRMD(PSC, IMR3,     16);
    IRMD(PSC, CTUR3,     8);
    IRMD(PSC, CTLR3,     8);
    IRMD(PSC, IP3,       8);
    IRMD(PSC, OPSET3,    8);
    IRMD(PSC, OPRESET3,  8);
    IRMD(PSC, SICR3,     8);
    IRMD(PSC, IRCR13,    8);
    IRMD(PSC, IRCR23,    8);
    IRMD(PSC, IRSDR3,    8);
    IRMD(PSC, IRMDR3,    8);
    IRMD(PSC, IRFDR3,    8);
    IRMD(PSC, RFCNT3,   16);
    IRMD(PSC, TFCNT3,   16);
    IRMD(PSC, RFSR3,    16);
    IRMD(PSC, TFSR3,    16);
    IRMD(PSC, RFCR3,    32);
    IRMD(PSC, TFCR3,    32);
    IRMD(PSC, RFAR3,    16);
    IRMD(PSC, TFAR3,    16);
    IRMD(PSC, RFRP3,    16);
    IRMD(PSC, TFRP3,    16);
    IRMD(PSC, RFWP3,    16);
    IRMD(PSC, TFWP3,    16);
    IRMD(PSC, RLRFP3,   16);
    IRMD(PSC, TLRFP3,   16);
    IRMD(PSC, RLWFP3,   16);
    IRMD(PSC, TLWFP3,   16);
}
/********************************************************************/
static const struct module_t
{
    char    *module;
    void    (*func)(char *, int, uint32);
} MODULE[] =
{
    {"SIU",     irmd_siu},
    {"GPT",     irmd_gpt},
    {"SLT",     irmd_slt},
    {"INTC",    irmd_intc},
    {"EPORT",   irmd_eport},
    {"GPIO",    irmd_gpio},
    {"SRAM",    irmd_sram},
    {"FBCS",    irmd_fbcs},
    {"SDRAMC",  irmd_sdramc},
    {"PCI",     irmd_pci},
    {"PCIARB",  irmd_pciarb},
    {"FEC0",    irmd_fec0},
    {"FEC1",    irmd_fec1},
    {"CTM",     irmd_ctm},
    {"DSPI",    irmd_dspi},
    {"I2C",     irmd_i2c},
    {"SEC",     irmd_sec},
    {"USB",     irmd_usb},
#ifdef CPU_MCF548X
    {"CAN0",    irmd_can0},
    {"CAN1",    irmd_can1},
#endif
    {"PSC0",    irmd_psc0},
    {"PSC1",    irmd_psc1},
    {"PSC2",    irmd_psc2},
    {"PSC3",    irmd_psc3}
};

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

/********************************************************************/
void
mcf548x_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))
                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 > 128)
        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("\nEdge Port Interrupt #%d\n",vector - 64);
            break;  
        default:
            printf("\nUser Defined Vector #%d\n",vector);
            break;
    }
}
/********************************************************************/