mpc8xxtest.c

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

/*
 * In order for this to work, the processor in conjunction with the
 * compiler must utilize the same alignment scheme as PowerPC!!!!!!
 * And integer widths too!!!
 *
 * To compile, use the following, for example:
 *
 * % gcc -D CPU_MPC821 mpc8xxtest.c
 *
 * To run,
 *
 * % ./a.out
 *
 */

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;

/********************************************************************/

#if     (defined(CPU_MPC821))
#include "mpc821.h"

#elif   (defined(CPU_MPC823))
#include "mpc823.h"

#elif   (defined(CPU_MPC850))
#include "mpc850.h"

#elif   (defined(CPU_MPC860))
#include "mpc860.h"

#elif   (defined(CPU_MPC860SAR))
#include "mpc860sar.h"

#else
#error "Unknown CPU"
#endif

/********************************************************************/

#define REG(MOD,REG,ADDR)   \
    {   \
    printf("%15s.%-10s: %04X", #MOD, #REG, &imm->MOD.REG); \
    if (ADDR != (uint32)&imm->MOD.REG)  \
        printf(" <-- Expected: %04X", ADDR);        \
    printf("\n");   \
    }

#define MOD(MOD,ADDR)   \
    {   \
    printf("%15s: %04X", #MOD, &imm->MOD); \
    if (ADDR != (uint32)&imm->MOD)  \
        printf(" <-- Expected: %04X",  ADDR);       \
    printf("\n");   \
    }

/********************************************************************/
int
main (void)
{
    MPC8XX_IMM *imm = (MPC8XX_IMM *)0;

    REG(siu, SIUMCR,    0x0000);
    REG(siu, SYPCR,     0x0004);
#ifndef SWT
    REG(siu, SWT,       0x0008);
#endif
    REG(siu, SWSR,      0x000E);
    REG(siu, SIPEND,    0x0010);
    REG(siu, SIMASK,    0x0014);
    REG(siu, SIEL,      0x0018);
    REG(siu, SIVEC,     0x001C);
    REG(siu, TESR,      0x0020);
    REG(siu, SDCR,      0x0030);

    REG(pcmcia, PBR0,   0x0080);
    REG(pcmcia, POR0,   0x0084);
    REG(pcmcia, PBR1,   0x0088);
    REG(pcmcia, POR1,   0x008C);
    REG(pcmcia, PBR2,   0x0090);
    REG(pcmcia, POR2,   0x0094);
    REG(pcmcia, PBR3,   0x0098);
    REG(pcmcia, POR3,   0x009C);
    REG(pcmcia, PBR4,   0x00A0);
    REG(pcmcia, POR4,   0x00A4);
    REG(pcmcia, PBR5,   0x00A8);
    REG(pcmcia, POR5,   0x00AC);
    REG(pcmcia, PBR6,   0x00B0);
    REG(pcmcia, POR6,   0x00B4);
    REG(pcmcia, PBR7,   0x00B8);
    REG(pcmcia, POR7,   0x00BC);
#ifndef PGCRA
    REG(pcmcia, PGCRA,  0x00E0);
#endif
    REG(pcmcia, PGCRB,  0x00E4);
    REG(pcmcia, PSCR,   0x00E8);
    REG(pcmcia, PIPR,   0x00F0);
    REG(pcmcia, PER,    0x00F8);

    REG(memc, BR0,      0x0100);
    REG(memc, OR0,      0x0104);
    REG(memc, BR1,      0x0108);
    REG(memc, OR1,      0x010C);
    REG(memc, BR2,      0x0110);
    REG(memc, OR2,      0x0114);
    REG(memc, BR3,      0x0118);
    REG(memc, OR3,      0x011C);
    REG(memc, BR4,      0x0120);
    REG(memc, OR4,      0x0124);
    REG(memc, BR5,      0x0128);
    REG(memc, OR5,      0x012C);
    REG(memc, BR6,      0x0130);
    REG(memc, OR6,      0x0134);
    REG(memc, BR7,      0x0138);
    REG(memc, OR7,      0x013C);
    REG(memc, MAR,      0x0164);
    REG(memc, MCR,      0x0168);
    REG(memc, MAMR,     0x0170);
    REG(memc, MBMR,     0x0174);
    REG(memc, MSTAT,    0x0178);
    REG(memc, MPTPR,    0x017A);
    REG(memc, MDR,      0x017C);

    REG(sit, TBSCR,     0x0200);
    REG(sit, TBREFF0,   0x0204);
    REG(sit, TBREFF1,   0x0208);
    REG(sit, RTCSC,     0x0220);
    REG(sit, RTC,       0x0224);
    REG(sit, RTSEC,     0x0228);
    REG(sit, RTCAL,     0x022C);
    REG(sit, PISCR,     0x0240);
    REG(sit, PITC,      0x0244);
    REG(sit, PITR,      0x0248);

    REG(clock, SCCR,    0x0280);
    REG(clock, PLPRCR,  0x0284);
    REG(clock, RSR,     0x0288);

    REG(sitkey, TBSCRK, 0x0300);
    REG(sitkey, PITCK,  0x0344);

    REG(clockey, SCCRK,     0x0380);
    REG(clockey, PLPRCRK,   0x0384);
    REG(clockey, RSRK,      0x0388);

#ifdef Mpc8xx_video
    REG(video, VCCR,    0x0000);
    REG(video, VSR,     0x0000);
    REG(video, VCMR,    0x0000);
    REG(video, VBCB,    0x0000);
    REG(video, VFCR0,   0x0000);
    REG(video, VFAA0,   0x0000);
    REG(video, VFBA0,   0x0000);
    REG(video, VFCR1,   0x0000);
    REG(video, VFAA1,   0x0000);
    REG(video, VFBA1,   0x0000);
#endif

#ifdef Mpc8xx_lcd
    REG(lcd, LCCR,      0x0000);
    REG(lcd, LCHCR,     0x0000);
    REG(lcd, LCVCR,     0x0000);
    REG(lcd, LCFAA,     0x0000);
    REG(lcd, LCFBA,     0x0000);
    REG(lcd, LCSR,      0x0000);
#endif

    REG(i2c, I2MOD,     0x0860);
    REG(i2c, I2CMR,     0x0874);

    REG(dma, SDAR,      0x0904);
    REG(dma, IDMR2,     0x091C);

    REG(cpic, CIVR,     0x0930);
    REG(cpic, CISR,     0x094C);

    REG(portio, PADIR,  0x0950);
    REG(portio, PDDAT,  0x0976);

    REG(cpmtimer, TGCR, 0x0980);
    REG(cpmtimer, TER4, 0x09B6);

    REG(cp, CPCR,       0x09C0);
    REG(cp, RTMR,       0x09DA);

    REG(brgs, BRGC1,    0x09F0);
    REG(brgs, BRGC2,    0x09F4);
#ifndef BRGC3
    REG(brgs, BRGC3,    0x09F8);
#endif
#ifndef BRGC4
    REG(brgs, BRGC4,    0x09FC);
#endif

#ifdef Mpc8xx_usb
    REG(usb, USMOD,     0x0000);
    REG(usb, USADR,     0x0000);
    REG(usb, USCOM,     0x0000);
    REG(usb, USEP0,     0x0000);
    REG(usb, USEP1,     0x0000);
    REG(usb, USEP2,     0x0000);
    REG(usb, USEP3,     0x0000);
    REG(usb, USBER,     0x0000);
    REG(usb, USBMR,     0x0000);
    REG(usb, USBS,      0x0000);
#endif

#ifdef Mpc8xx_scc1
    REG(scc1, GSMR_L,   0x0A00);
    REG(scc1, GSMR_H,   0x0A04);
    REG(scc1, SCCS,     0x0A17);
#endif

#ifdef Mpc8xx_scc2
    REG(scc2, GSMR_L,   0x0A20);
    REG(scc2, GSMR_H,   0x0A24);
    REG(scc2, SCCS,     0x0A37);
#endif

#ifdef Mpc8xx_scc3
    REG(scc3, GSMR_L,   0x0A40);
    REG(scc3, GSMR_H,   0x0A44);
    REG(scc3, SCCS,     0x0A57);
#endif

#ifdef Mpc8xx_scc4
    REG(scc4, GSMR_L,   0x0A60);
    REG(scc4, GSMR_H,   0x0A64);
    REG(scc4, SCCS,     0x0A77);
#endif

    REG(smc1, SMCMR,    0x0A82);
    REG(smc1, SMCE,     0x0A86);
    REG(smc1, SMCM,     0x0A8A);

    REG(smc2, SMCMR,    0x0A92);
    REG(smc2, SMCE,     0x0A96);
    REG(smc2, SMCM,     0x0A9A);

    REG(spi, SPMODE,    0x0AA0);
    REG(spi, SPCOM,     0x0AAD);

    REG(pip, PIPC,      0x0AB2);
    REG(pip, PBDAT,     0x0AC4);

    REG(si, SIMODE,     0x0AE0);
    REG(si, SIRP,       0x0AF0);

    MOD(SIRAM,      0x0C00);
#ifdef Mpc8xx_video
    MOD(VCRAM,      0x0000);
#endif
#ifdef Mpc8xx_lcd
    MOD(LCOLR,      0x0000);
#endif
    MOD(dpram,      0x2000);
#ifdef Mpc8xx_scc1
    MOD(dpram.scc1,     0x3C00);
#endif
#ifdef Mpc8xx_usb
    MOD(dpram.usb,      0x0000);
#endif
    MOD(dpram.i2c,      0x3C80);
    MOD(dpram.misc,     0x3CB0);
    MOD(dpram.idma1,    0x3CC0);
#ifdef Mpc8xx_scc2
    MOD(dpram.scc2,     0x3D00);
#endif
    MOD(dpram.spi,      0x3D80);
    MOD(dpram.timers,   0x3DB0);
    MOD(dpram.idma2,    0x3DC0);
#ifdef Mpc8xx_scc3
    MOD(dpram.scc3,     0x3E00);
#endif
    MOD(dpram.smc1,     0x3E80);
    MOD(dpram.dsp1,     0x3EC0);
#ifdef Mpc8xx_scc4
    MOD(dpram.scc4,     0x3F00);
#endif
    MOD(dpram.smc2,     0x3F80);
    MOD(dpram.dsp2,     0x3FC0);

    return 0;
}