mpc6xxinc.c

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

/*
 * This program generates the offsets used by the assembly file
 * to access the MPC60X registers buffer.
 *
 * NOTE:  There is an important assumption in that the PowerPC
 * C compiler and the C compiler used to generate this file
 * match EXACTLY in the way the REGISTERS data structure is
 * produced.  Ie, no reordering, no alignment issues...
 *
 * NOTE: By using the form below, maximum capability between Diab and
 * GNU PPC assembler is achieved!!!!
 *
 *     .equ   symbol,value
 *
 * When compiling this utility from this directory, use:
 *
 * gcc -D CPU_MPC603 -I ../../../../../include/cpu mpc6xxinc.c
 *
 * 
 */

#include <cpu.h>
#include "mpc6xx.h"

static REGISTERS regs;

#define ENTRY(PPC,REG,SPR) {#PPC, #REG, SPR, (void *)&regs.REG}

typedef struct
{
    char *  proc;
    char *  reg;
    int     spr;
    void *  offset;
} ppc_reg;

#define REGTAB_SIZE (sizeof(regtab) / sizeof(ppc_reg))
#define REG_OFFSET(X)   (void *)((char *)X - (char *)&regs)

static const ppc_reg regtab[] =
{
     
ENTRY(0,r0,0),
ENTRY(0,r1,0),
ENTRY(0,r2,0),
ENTRY(0,r3,0),
ENTRY(0,r4,0),
ENTRY(0,r5,0),
ENTRY(0,r6,0),
ENTRY(0,r7,0),
ENTRY(0,r8,0),
ENTRY(0,r9,0),
ENTRY(0,r10,0),
ENTRY(0,r11,0),
ENTRY(0,r12,0),
ENTRY(0,r13,0),
ENTRY(0,r14,0),
ENTRY(0,r15,0),
ENTRY(0,r16,0),
ENTRY(0,r17,0),
ENTRY(0,r18,0),
ENTRY(0,r19,0),
ENTRY(0,r20,0),
ENTRY(0,r21,0),
ENTRY(0,r22,0),
ENTRY(0,r23,0),
ENTRY(0,r24,0),
ENTRY(0,r25,0),
ENTRY(0,r26,0),
ENTRY(0,r27,0),
ENTRY(0,r28,0),
ENTRY(0,r29,0),
ENTRY(0,r30,0),
ENTRY(0,r31,0),

ENTRY(0,f0,0),
ENTRY(0,f1,0),
ENTRY(0,f2,0),
ENTRY(0,f3,0),
ENTRY(0,f4,0),
ENTRY(0,f5,0),
ENTRY(0,f6,0),
ENTRY(0,f7,0),
ENTRY(0,f8,0),
ENTRY(0,f9,0),
ENTRY(0,f10,0),
ENTRY(0,f11,0),
ENTRY(0,f12,0),
ENTRY(0,f13,0),
ENTRY(0,f14,0),
ENTRY(0,f15,0),
ENTRY(0,f16,0),
ENTRY(0,f17,0),
ENTRY(0,f18,0),
ENTRY(0,f19,0),
ENTRY(0,f20,0),
ENTRY(0,f21,0),
ENTRY(0,f22,0),
ENTRY(0,f23,0),
ENTRY(0,f24,0),
ENTRY(0,f25,0),
ENTRY(0,f26,0),
ENTRY(0,f27,0),
ENTRY(0,f28,0),
ENTRY(0,f29,0),
ENTRY(0,f30,0),
ENTRY(0,f31,0),

ENTRY(0,cr,0),
ENTRY(0,fpscr,0),
ENTRY(0,xer,1),
ENTRY(0,lr,8),
ENTRY(0,ctr,9),

ENTRY(0,tbl,268),
ENTRY(0,tbu,269),

ENTRY(0,msr,0),

ENTRY(0,pvr,287),

ENTRY(0,ibat0u,528),
ENTRY(0,ibat0l,529),
ENTRY(0,ibat1u,530),
ENTRY(0,ibat1l,531),
ENTRY(0,ibat2u,532),
ENTRY(0,ibat2l,533),
ENTRY(0,ibat3u,534),
ENTRY(0,ibat3l,535),

ENTRY(0,dbat0u,536),
ENTRY(0,dbat0l,537),
ENTRY(0,dbat1u,538),
ENTRY(0,dbat1l,539),
ENTRY(0,dbat2u,540),
ENTRY(0,dbat2l,541),
ENTRY(0,dbat3u,542),
ENTRY(0,dbat3l,543),

ENTRY(0,sr0,0),
ENTRY(0,sr1,0),
ENTRY(0,sr2,0),
ENTRY(0,sr3,0),
ENTRY(0,sr4,0),
ENTRY(0,sr5,0),
ENTRY(0,sr6,0),
ENTRY(0,sr7,0),
ENTRY(0,sr8,0),
ENTRY(0,sr9,0),
ENTRY(0,sr10,0),
ENTRY(0,sr11,0),
ENTRY(0,sr12,0),
ENTRY(0,sr13,0),
ENTRY(0,sr14,0),
ENTRY(0,sr15,0),

ENTRY(0,sdr1,25),

ENTRY(0,dar,19),
ENTRY(0,dsisr,18),
ENTRY(0,srr0,26),
ENTRY(0,srr1,27),
ENTRY(0,sprg0,272),
ENTRY(0,sprg1,273),
ENTRY(0,sprg2,274),
ENTRY(0,sprg3,275),

ENTRY(0,dec,22),

/*
 * MPC603
 */
ENTRY(603,psr.mpc603.hid0,1008),
ENTRY(603,psr.mpc603.dmiss,976),
ENTRY(603,psr.mpc603.dcmp,977),
ENTRY(603,psr.mpc603.hash1,978),
ENTRY(603,psr.mpc603.hash2,979),
ENTRY(603,psr.mpc603.imiss,980),
ENTRY(603,psr.mpc603.icmp,981),
ENTRY(603,psr.mpc603.rpa,982),
ENTRY(603,psr.mpc603.iabr,1010),
ENTRY(603,psr.mpc603.ear,282),

/*
 * MPC603e
 */
ENTRY(603e,psr.mpc603e.hid0,1008),
ENTRY(603e,psr.mpc603e.hid1,1009),
ENTRY(603e,psr.mpc603e.dmiss,976),
ENTRY(603e,psr.mpc603e.dcmp,977),
ENTRY(603e,psr.mpc603e.hash1,978),
ENTRY(603e,psr.mpc603e.hash2,979),
ENTRY(603e,psr.mpc603e.imiss,980),
ENTRY(603e,psr.mpc603e.icmp,981),
ENTRY(603e,psr.mpc603e.rpa,982),
ENTRY(603e,psr.mpc603e.iabr,1010),
ENTRY(603e,psr.mpc603e.ear,282),

/*
 * MPC604
 */
ENTRY(604,psr.mpc604.hid0,1008),
ENTRY(604,psr.mpc604.pmc1,953),
ENTRY(604,psr.mpc604.pmc2,954),
ENTRY(604,psr.mpc604.mmcr0,952),
ENTRY(604,psr.mpc604.sda,959),
ENTRY(604,psr.mpc604.sia,955),
ENTRY(604,psr.mpc604.iabr,1010),
ENTRY(604,psr.mpc604.dabr,1013),
ENTRY(604,psr.mpc604.ear,282),
ENTRY(604,psr.mpc604.pir,1023),

/*
 * MPC604e
 */
ENTRY(604e,psr.mpc604e.hid0,1008),
ENTRY(604e,psr.mpc604e.hid1,1009),
ENTRY(604e,psr.mpc604e.pmc1,953),
ENTRY(604e,psr.mpc604e.pmc2,954),
ENTRY(604e,psr.mpc604e.pmc3,957),
ENTRY(604e,psr.mpc604e.pmc4,958),
ENTRY(604e,psr.mpc604e.mmcr0,952),
ENTRY(604e,psr.mpc604e.mmcr1,956),
ENTRY(604e,psr.mpc604e.sda,959),
ENTRY(604e,psr.mpc604e.sia,955),
ENTRY(604e,psr.mpc604e.iabr,1010),
ENTRY(604e,psr.mpc604e.dabr,1013),
ENTRY(604e,psr.mpc604e.ear,282),
ENTRY(604e,psr.mpc604e.pir,1023),

/*
 * MPC750
 */
ENTRY(750,psr.mpc750.upmc1,937),
ENTRY(750,psr.mpc750.upmc2,938),
ENTRY(750,psr.mpc750.upmc3,941),
ENTRY(750,psr.mpc750.upmc4,942),
ENTRY(750,psr.mpc750.usia,939),
ENTRY(750,psr.mpc750.ummcr0,936),
ENTRY(750,psr.mpc750.ummcr1,940),
ENTRY(750,psr.mpc750.hid0,1008),
ENTRY(750,psr.mpc750.hid1,1009),
ENTRY(750,psr.mpc750.pmc1,953),
ENTRY(750,psr.mpc750.pmc2,954),
ENTRY(750,psr.mpc750.pmc3,957),
ENTRY(750,psr.mpc750.pmc4,958),
ENTRY(750,psr.mpc750.mmcr0,952),
ENTRY(750,psr.mpc750.mmcr1,956),
ENTRY(750,psr.mpc750.sia,955),
ENTRY(750,psr.mpc750.thrm1,1020),
ENTRY(750,psr.mpc750.thrm2,1021),
ENTRY(750,psr.mpc750.thrm3,1022),
ENTRY(750,psr.mpc750.ictc,1019),
ENTRY(750,psr.mpc750.l2cr,1017),
ENTRY(750,psr.mpc750.iabr,1010),
ENTRY(750,psr.mpc750.dabr,1013),
ENTRY(750,psr.mpc750.ear,282),
} ;


static void
get_reg (char *outstr, char *instr)
{
    /*
     * Strip structure dereferences to get register name
     * Outstr can not be equal to instr
     */
    int slen = strlen(instr);
    int i, j;

    i = slen;

    while ((instr[i] != '.') && (i > 0))
        --i;

    if (instr[i] == '.') ++i;

    for (j = 0; i <= slen; ++j, ++i)
        outstr[j] = instr[i];
}

static void
dump_sprs (void)
{
    int index;
    char ppcreg[60];

    for (index = 0; index < REGTAB_SIZE; ++index)
    {
        get_reg(ppcreg, regtab[index].reg);
        if (regtab[index].spr != 0)
        {
            if (strcmp("0",regtab[index].proc) == 0)
                printf("    .equ    spr_%s,%d\n",
                ppcreg,
                regtab[index].spr);
            else
                printf("    .equ    spr_%s_%s,%d\n",
                regtab[index].proc,
                ppcreg,
                regtab[index].spr);
        }
    }
}
 
static void
dump_offsets (void)
{
    int index;
    char ppcreg[60];

    for (index = 0; index < REGTAB_SIZE; ++index)
    {
        get_reg(ppcreg, regtab[index].reg);
        if (strcmp("0",regtab[index].proc) == 0)
            printf("    .equ    o_%s,%#06x\n",
            ppcreg,
            REG_OFFSET(regtab[index].offset));
        else
            printf("    .equ    o_%s_%s,%#06x\n",
            regtab[index].proc,
            ppcreg,
            REG_OFFSET(regtab[index].offset));
    }
}
 
void main (void)
{
    printf("    #\n");
    printf("    # File:     mpc60x.inc\n");
    printf("    #\n");
    printf("    # Purpose:  Definitions for PowerPC registers\n");
    printf("    #\n");
    printf("    #\n");
    printf("    # Notes:    This file automatically generated.\n");
    printf("    #           See mpc60xinc.c utility.\n");
    printf("    #\n");
    printf("\n");
    printf("\n");
    printf("    #\n");
    printf("    # Offsets of registers in the REGISTERS data structure.\n");
    printf("    # NOTE:  Offsets must match compiler calculated offsets!\n");
    printf("    #\n");
    printf("\n");
    dump_offsets();
    printf("\n");
    printf("\n");
    printf("    #\n");
    printf("    # PowerPC Special Purpose Register numbers\n");
    printf("    #\n");
    printf("\n");
    dump_sprs();
    printf("\n");
    printf("\n");
}