mcf5204_hi.c

motorola自己开发的针对coldfire 5272的Dbug bootloader程序

/*
 * File:		mcf5204_hi.c
 * Purpose:		MCF5204 high level processing.
 *
 * Notes:
 *
 */

#include "src/include/dbug.h"

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

/*
 * CPU name string and source code version for display at boot-up.
 */
const char CPU_STR[] = "ColdFire MCF5204";
const int  CPU_VER_MAJOR   = 1;
const char CPU_VER_MINOR   = 'a';

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

static const char FORMAT8[]  = "%8s: %02X\n";
static const char FORMAT16[] = "%8s: %04X\n";
static const char FORMAT32[] = "%8s: %08X\n";

static const char INVMOD[] = "Error: Invalid Module: %s\n";

#define IRMD(MOD,RDREG,WRREG,SIZE)  \
if ((strcasecmp(#RDREG,reg) == 0) || display_all)	\
{													\
	if (regread)									\
	{												\
	printf(FORMAT ## SIZE, #RDREG, MCF5204_RD_ ## MOD ## _ ## RDREG(imm)); \
	pause(&displayed);								\
	}												\
	else											\
		MCF5204_WR_ ## MOD ## _ ## WRREG(imm,value);	\
													\
	if (!display_all)								\
		return;										\
}

#define IRMD_NOWR(MOD,RDREG,SIZE)  \
if ((strcasecmp(#RDREG,reg) == 0) || display_all)		\
{													\
	if (regread)									\
	{												\
	printf(FORMAT ## SIZE, #RDREG, MCF5204_RD_ ## MOD ## _ ## RDREG(imm)); \
	pause(&displayed);								\
	}												\
													\
	if (!display_all)								\
		return;										\
}

#define IRMD_NORD(MOD,WRREG,SIZE)  \
if ((strcasecmp(#WRREG,reg) == 0) || display_all)	\
{													\
	if (regread)									\
	{												\
		printf(" %8s: XX\n",#WRREG);				\
		pause(&displayed);							\
	}												\
	else											\
		MCF5204_WR_ ## MOD ## _ ## WRREG(imm,value);	\
													\
	if (!display_all)								\
		return;										\
}

static int display_all;
static int displayed;

#define REGREAD		(1)
#define REGWRITE	(0)

/********************************************************************/
static void
irmd_sim (void *imm, char *reg, int regread, uint32 value)
{
	IRMD(SIM, SIMR,		SIMR,	8);
	IRMD(SIM, ICR_E0,	ICR_E0,	8);
	IRMD(SIM, ICR_E1,	ICR_E1,	8);
	IRMD(SIM, ICR_E2,	ICR_E2,	8);
	IRMD(SIM, ICR_E3,	ICR_E3,	8);
	IRMD(SIM, ICR_SW,	ICR_SW,	8);
	IRMD(SIM, ICR_T1,	ICR_T1,	8);
	IRMD(SIM, ICR_T2,	ICR_T2,	8);
	IRMD(SIM, ICR_U1,	ICR_U1,	8);
	IRMD(SIM, IMR,		IMR,	32);
	IRMD(SIM, IPR,		IPR,	32);
	IRMD(SIM, RSR,		RSR,	8);
	IRMD(SIM, SYPCR,	SYPCR,	8);
	IRMD(SIM, SWIVR,	SWIVR,	8);
	IRMD(SIM, SWSR,		SWSR,	8);
	IRMD(SIM, CSAR0,	CSAR0,	32);
	IRMD(SIM, CSMR0,	CSMR0,	32);
	IRMD(SIM, CSCR0,	CSCR0,	32);
	IRMD(SIM, CSAR1,	CSAR1,	32);
	IRMD(SIM, CSMR1,	CSMR1,	32);
	IRMD(SIM, CSCR1,	CSCR1,	32);
	IRMD(SIM, CSAR2,	CSAR2,	32);
	IRMD(SIM, CSMR2,	CSMR2,	32);
	IRMD(SIM, CSCR2,	CSCR2,	32);
	IRMD(SIM, CSAR3,	CSAR3,	32);
	IRMD(SIM, CSMR3,	CSMR3,	32);
	IRMD(SIM, CSCR3,	CSCR3,	32);
	IRMD(SIM, CSAR4,	CSAR4,	32);
	IRMD(SIM, CSMR4,	CSMR4,	32);
	IRMD(SIM, CSCR4,	CSCR4,	32);
	IRMD(SIM, CSAR5,	CSAR5,	32);
	IRMD(SIM, CSMR5,	CSMR5,	32);
	IRMD(SIM, CSCR5,	CSCR5,	32);
	IRMD(SIM, PAR,		PAR,	8);
	IRMD(SIM, PADDR,	PADDR,	8);
	IRMD(SIM, PADAT,	PADAT,	8);

	if (!display_all)
		printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_uart (void *imm, char *reg, int regread, uint32 value)
{
	IRMD(UART, UMR,		UMR,	8);
	IRMD(UART, USR,		UCSR,	8);
	IRMD_NORD(UART, 	UCR,	8);
	IRMD(UART, URB,		UTB,	8);
	IRMD(UART, UIPCR,	UACR,	8);
	IRMD(UART, UISR,	UIMR,	8);
	IRMD_NORD(UART, 	UBG1,	8);
	IRMD_NORD(UART, 	UBG2,	8);
	IRMD(UART, UIVR,	UIVR,	8);
	IRMD_NOWR(UART, 	UIP,	8);
	IRMD_NORD(UART, 	UOP1,	8);
	IRMD_NORD(UART, 	UOP0,	8);

	if (!display_all)
		printf(INVREG,reg);
}

/********************************************************************/
static void
irmd_timer (void *imm, char *reg, int regread, uint32 value)
{
	IRMD(TIMER, TMR1,	TMR1,	16);
	IRMD(TIMER, TRR1,	TRR1,	16);
	IRMD(TIMER, TCR1,	TCR1,	16);
	IRMD(TIMER, TCN1,	TCN1,	16);
	IRMD(TIMER, TER1,	TER1,	8);
	IRMD(TIMER, TMR2,	TMR2,	16);
	IRMD(TIMER, TRR2,	TRR2,	16);
	IRMD(TIMER, TCR2,	TCR2,	16);
	IRMD(TIMER, TCN2,	TCN2,	16);
	IRMD(TIMER, TER2,	TER2,	8);

	if (!display_all)
		printf(INVREG,reg);
}

/********************************************************************/
static const struct module_t
{
	char	*module;
	void	(*func)(void *,char *, int, uint32);
} MODULE[] =
{
	{"SIM",		irmd_sim},
	{"UART",	irmd_uart},
	{"TIMER",	irmd_timer},
} ;
 
#define MODULE_SIZE (int)(sizeof(MODULE)/sizeof(struct module_t))

/********************************************************************/
void
ird (int argc, char **argv)
{
	/*
	 * Display Internal Memory Mapped register contents
	 */
	void *imm;
	char *rstr;
	char mstr[20];
	int mi;

	(void)argc;

	imm = mcf5204_mbar();
	display_all = FALSE;
	displayed = 0;

	if (argv[1] == NULL)
	{
		printf("Internal Modules, MBAR, located at %#08X\n",imm);
		printf("Modules:  ");
		for (mi = 0; mi < MODULE_SIZE; ++mi)
		{
			printf("%s ",MODULE[mi].module);
		}
		printf("\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 == '.')
		++rstr;

	/*
	 * Display the module contents
	 */
	for (mi = 0; mi < MODULE_SIZE; ++mi)
	{
		if (strcasecmp(MODULE[mi].module,mstr) == 0)
		{
			if (rstr == NULL)
			{
				display_all = TRUE;
				printf("Module: %s\n",MODULE[mi].module);
			}
			MODULE[mi].func(imm, rstr, REGREAD, 0);
			return;
		}
	}
	printf(INVMOD,argv[1]);
}

/********************************************************************/
void
irm (int argc, char **argv)
{
	/*
	 * Modify Internal Memory Mapped register contents
	 */
	uint32 value;
	int success;
	void *imm;
	char *rstr;
	char mstr[20];
	int mi;

	(void)argc;

	imm = mcf5204_mbar();

	/*
	 * 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 == '.')
		++rstr;

	/*
	* Get the new value
	*/

	value = get_value(argv[2],&success,16);
	if(success == 0)
	{
		printf(INVALUE,argv[2]);
		return;
	}

	/*
	 * Modify the module contents
	 */
	for (mi = 0; mi < MODULE_SIZE; ++mi)
	{
		if (strcasecmp(MODULE[mi].module,mstr) == 0)
		{
			MODULE[mi].func(imm, rstr, REGWRITE, value);
			return;
		}
	}
	printf(INVMOD,argv[1]);
}

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