mpc6xx_hi.c

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

        case MPC_PVR_MACH5:
            if (tab != NULL)
            {
                *tab = mpc604etab;
                *tabsize = REGTAB_SIZE(mpc604etab);
            }
            else
            {
                printf("MPC604e");
            }
            break;
        case MPC_PVR_750:
            if (tab != NULL)
            {
                *tab = mpc750tab;
                *tabsize = REGTAB_SIZE(mpc750tab);
            }
            else
            {
                printf("MPC750");
            }
            break;
        default:
            if (tab != NULL)
            {
                *tab = NULL;
                *tabsize = 0;
                retval = FALSE;
            }
            else
            {
                printf("Unknown");
            }
            break;
    }

    return retval;
}

/********************************************************************/
static ppc_reg *
find_spr (int spr)
{
    /*
     * This routine searches the register tables for the
     * register with SPR number `spr'.  If it is found, then
     * address of the register entry is returned, else NULL.
     */
    int index;
    const ppc_reg *tab;
    int tabsize;

    /*
     * First we search the common PowerPC registers.
     */
    for (index = 0; index < REGTAB_SIZE(ppctab); index++)
    {
        if (ppctab[index].reg_spr == spr)
            return (ppc_reg *)&ppctab[index];
    }

    /*
     * Try processor specific register table
     */
    if (cpu_regtab(&tab, &tabsize))
    {
        for (index = 0; index < tabsize; index++)
        {
            if (tab[index].reg_spr == spr)
                return (ppc_reg *)&tab[index];
        }
    }

    return NULL;
}

/*********************************************************************/
static ppc_reg *
find_register (char *reg)
{
    /*
     * This routine searches the register tables for the
     * register named `reg'.  If it is found, then the
     * address of the register entry is returned, else NULL.
     */
    int index, spr, success;
    const ppc_reg *tab;
    int tabsize;

    /*
     * First we search the common PowerPC registers.
     */
    for (index = 0; index < REGTAB_SIZE(ppctab); index++)
    {
        if (strcasecmp(ppctab[index].reg_name,reg) == 0)
            return (ppc_reg *)&ppctab[index];
    }

    /*
     * Try processor specific register table
     */
    if (cpu_regtab(&tab, &tabsize))
    {
        for (index = 0; index < tabsize; index++)
        {
            if (strcasecmp(tab[index].reg_name,reg) == 0)
                return (ppc_reg *)&tab[index];
        }
    }

    /*
     * See if an sprXXXX was requested
     */
    if (strncasecmp("spr",reg,3) == 0)
    {
        spr = get_value(&reg[3], &success, 10);
        if (success)
        {
            return find_spr(spr);
        }
    }

    return NULL;
}

/********************************************************************/
void
cpu_reg_modify (char *reg, uint32 value)
{
    ppc_reg *regp;

    if ((regp = find_register(reg)) != NULL)
    {
        *regp->reg_offset = value;
    }
    else
    {
        printf(INVREG,reg);
    }
}

/********************************************************************/
static void
dump_fprs (void)
{
    printf("fpscr:  %08X\n",context.fpscr);
    printf("f00-07: ");
    printf(FMT8REG,
        context.f0,
        context.f1,
        context.f2,
        context.f3,
        context.f4,
        context.f5,
        context.f6,
        context.f7  );
    printf("f08-15: ");
    printf(FMT8REG,
        context.f8,
        context.f9,
        context.f10,
        context.f11,
        context.f12,
        context.f13,
        context.f14,
        context.f15  );
    printf("f16-23: ");
    printf(FMT8REG,
        context.f16,
        context.f17,
        context.f18,
        context.f19,
        context.f20,
        context.f21,
        context.f22,
        context.f23  );
    printf("f24-31: ");
    printf(FMT8REG,
        context.f24,
        context.f25,
        context.f26,
        context.f27,
        context.f28,
        context.f29,
        context.f30,
        context.f31  );
}

/********************************************************************/
static void
dump_gprs (void)
{
    printf("r00-07: ");
    printf(FMT8REG,
        context.r0,
        context.r1,
        context.r2,
        context.r3,
        context.r4,
        context.r5,
        context.r6,
        context.r7  );
    printf("r08-15: ");
    printf(FMT8REG,
        context.r8,
        context.r9,
        context.r10,
        context.r11,
        context.r12,
        context.r13,
        context.r14,
        context.r15  );
    printf("r16-23: ");
    printf(FMT8REG,
        context.r16,
        context.r17,
        context.r18,
        context.r19,
        context.r20,
        context.r21,
        context.r22,
        context.r23  );
    printf("r24-31: ");
    printf(FMT8REG,
        context.r24,
        context.r25,
        context.r26,
        context.r27,
        context.r28,
        context.r29,
        context.r30,
        context.r31  );
}

/********************************************************************/
static void
dump_srs (void)
{
    printf("sr0-7 : ");
    printf(FMT8REG,
        context.sr0,
        context.sr1,
        context.sr2,
        context.sr3,
        context.sr4,
        context.sr5,
        context.sr6,
        context.sr7  );
    printf("sr8-15: ");
    printf(FMT8REG,
        context.sr8,
        context.sr9,
        context.sr10,
        context.sr11,
        context.sr12,
        context.sr13,
        context.sr14,
        context.sr15  );
}

/********************************************************************/
static void
dump_sprs (void)
{
    const ppc_reg *tab;
    int tabsize;
    int index;
    int displayed = 0;

    for (index = 0; index < REGTAB_SIZE(ppctab); ++index)
    {
        if (ppctab[index].reg_spr != 0)
        {
            printf(" %-8s (spr%4d): %08X\n",
                ppctab[index].reg_name,
                ppctab[index].reg_spr,
                *ppctab[index].reg_offset);

            pause(&displayed);
        }
    }

    /*
     * Processor specific register table
     */
    if (cpu_regtab(&tab, &tabsize))
    {
        for (index = 0; index < tabsize; ++index)
        {
            if (tab[index].reg_spr != 0)
            {
                printf(" %-8s (spr%4d): %08X\n",
                    tab[index].reg_name,
                    tab[index].reg_spr,
                    *tab[index].reg_offset);

                pause(&displayed);
            }
        }
    }
}

/********************************************************************/
static void
dump_msr (void)
{
    int first = TRUE;
    uint32 mask = MPC_MSR_POW;  /* MSR[13,POW] */

    printf("[");
    while (mask)
    {
        if (context.msr & mask)
        {
            if (!first)
                printf(",");
            else
                first = FALSE;

            switch (context.msr & mask)
            {
                case MPC_MSR_POW:
                    printf("POW"); break;
                case MPC_MSR_TGPR:
                    printf("TGPR"); break;
                case MPC_MSR_ILE:
                    printf("ILE"); break;
                case MPC_MSR_EE:
                    printf("EE"); break;
                case MPC_MSR_PR:
                    printf("PR"); break;
                case MPC_MSR_FP:
                    printf("FP"); break;
                case MPC_MSR_ME:
                    printf("ME"); break;
                case MPC_MSR_FE0:
                    printf("FE0"); break;
                case MPC_MSR_SE:
                    printf("SE"); break;
                case MPC_MSR_BE:
                    printf("BE"); break;
                case MPC_MSR_FE1:
                    printf("FE1"); break;
                case MPC_MSR_IP:
                    printf("IP"); break;
                case MPC_MSR_IR:
                    printf("IR"); break;
                case MPC_MSR_DR:
                    printf("DR"); break;
                case MPC_MSR_RI:
                    printf("RI"); break;
                case MPC_MSR_LE:
                    printf("LE"); break;
                default:
                    break;
            }
        }
        mask >>= 1;
    }   
    printf("]");
}

/********************************************************************/
void
cpu_reg_display (char *reg)
{
    ppc_reg *regp;

    if (reg == NULL)
    {
        printf("    ip: %08X     msr: %08X ",
            context.srr0,
            context.msr
            );
        dump_msr();
        printf("\n");

        printf("    cr: %08X     xer: %08X      lr: %08X     ctr: %08X\n",
            context.cr,
            context.xer,
            context.lr,
            context.ctr
            );
        dump_gprs();
    }
    else
    {
        /* display specific reg */
        if ((regp = find_register(reg)) != NULL)
        {
            printf("%s:  %08X\n",
                regp->reg_name, *regp->reg_offset);
            return;
        }
        else
        {
            if (strcasecmp(reg,"gprs") == 0)
            {
                dump_gprs();
                return;
            }

            if (strcasecmp(reg,"fprs") == 0)
            {
                dump_fprs();
                return;
            }

            if (strcasecmp(reg,"srs") == 0)
            {
                dump_srs();
                return;
            }

            if (strcasecmp(reg,"sprs") == 0)
            {
                dump_sprs();
                return;
            }
        }
        printf(INVREG,reg);
    }
}

/********************************************************************/
void
cpu_pc_modify (ADDRESS address)
{
    context.srr0 = address;
}

/********************************************************************/
ADDRESS
cpu_pc_get (void)
{
    return (ADDRESS)context.srr0;
}

/********************************************************************/
int
cpu_parse_size (char *arg)
{
    int i, size = SIZE_32;

    for (i = 0; arg[i] != '\0'; i++)
    {
        if (arg[i] == '.')
        {
            switch (arg[i+1])
            {
                case 'b':
                case 'B':
                    size = SIZE_8;
                    break;
                case 'h':
                case 'H':
                    size = SIZE_16;