mpc8xxtest.c

motorola自己开发的针对coldfire 5272的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;
}