mpc6xx_hi.c

Coldfire MCF5282 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;