cmds.c

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

#ifdef DBUG_FLASH
		if (strncasecmp("fl",argv[1],2) == 0)
		{
			flash_usage();
		}
#endif
		for (index = 0; index < UIF_NUM_CMD; index++)
		{
			if (strcasecmp(UIF_CMDTAB[index].cmd,argv[1]) == 0)
			{
				/*printf(HELPTITLE);*/
				printf(HELPFORMAT,"Command","Description","Syntax","");
				help_display(index);
				return;
			}
		}
		for (index = 0; index < UIF_NUM_CMD; index++)
		{
			if (strncasecmp(UIF_CMDTAB[index].cmd,argv[1],
				UIF_CMDTAB[index].unique) == 0)
			{
				/*printf(HELPTITLE);*/
				printf(HELPFORMAT,"Command","Description","Syntax","");
				help_display(index);
				return;
			}
		}
		printf(INVCMD,argv[1]);
	}
}

/********************************************************************/
void
uif_cmd_lr (int argc, char **argv)
{
	int size, success;
	ADDRESS addr;
	volatile uint32 junk;

	(void)argc;

	size = cpu_parse_size(argv[0]);

	addr = get_value(argv[1],&success,BASE);
	if (!success)
	{
		printf(INVALUE,argv[1]);
		return;
	}

	while (TRUE)
	{
		switch (size)
		{
			case SIZE_32:
				junk = *(volatile uint32 *)addr;
				break;
			case SIZE_16:
				junk = *(volatile uint16 *)addr;
				break;
			default:
			case SIZE_8:
				junk = *(volatile uint8 *)addr;
				break;
		}

		if (board_getchar_present())
		{
			board_getchar();
			break;
		}
	}
}

/********************************************************************/
void
uif_cmd_lw (int argc, char **argv)
{
	int size, success;
	ADDRESS addr;
	uint32 data;

	(void)argc;

	size = cpu_parse_size(argv[0]);

	addr = get_value(argv[1],&success,BASE);
	if (!success)
	{
		printf(INVALUE,argv[1]);
		return;
	}

	data = get_value(argv[2],&success,BASE);
	if (!success)
	{
		printf(INVALUE,argv[2]);
		return;
	}

	while (TRUE)
	{
		switch (size)
		{
			case SIZE_32:
				*(volatile uint32 *)addr = data;
				break;
			case SIZE_16:
				*(volatile uint16 *)addr = (uint16) data;
				break;
			default:
			case SIZE_8:
				*(volatile uint8 *)addr = (uint8) data;
				break;
		}

		if (board_getchar_present())
		{
			board_getchar();
			break;
		}
	}
}

/********************************************************************/
static void
dump_mem (ADDRESS begin, ADDRESS end, int size)
{
	uint32 data;
	ADDRESS curr;
	char line[16];
	char *lcur;
	int i, ch;

	curr = begin;

	do
	{
		printf("%08X:  ",curr);
		lcur = line;
		i = 0;
		while (i < 16)
		{
			data = cpu_read_data(curr,size);
			switch (size)
			{
				case SIZE_8:
					printf("%02X ", data);
					*(uint8 *)lcur = (uint8) data;
					curr++;
					lcur++;
					i++;
					break;
				case SIZE_16:
					printf("%04X ", data);
					*(uint16 *)lcur = (uint16) data;
					curr += 2;
					lcur += 2;
					i += 2;
					break;
				case SIZE_32:
					printf("%08X ", data);
					*(uint32 *)lcur = data;
					curr += 4;
					lcur += 4;
					i += 4;
					break;
			}
		}

		for (i = 0; i < 16; i++)
		{
			ch = line[i];
			if ((ch >= ' ') && (ch <= '~'))
				printf("%c",ch);
			else
				printf(".");
		}
		printf("\n");

	} while (curr < end);
}

/********************************************************************/
void
uif_cmd_md (int argc, char **argv)
{
	int success, size;
	ADDRESS begin, end;
	uint32 contents;

	size = cpu_parse_size(argv[0]);

	if (argc > 1)
	{
		if ((argc == 2) && (argv[1][0] == '*'))
		{
			begin = get_value(&argv[1][1],&success,BASE);
			if (success)
			{
				contents = cpu_read_data(begin,SIZE_32);
				printf("%08X contains %08X\n", begin, contents);
				begin = contents;
				end = contents+(DEFAULT_MD_LINES*16);
				goto show_mem;
			}
			else
			{
				printf(INVALUE,argv[1]);
				return;
			}
		}

		begin = get_value(argv[1],&success,16);
		if (!success)
		{
			printf(INVALUE,argv[1]);
			return;
		}

		if (argc == 3)
		{
			end = get_value(argv[2],&success,16);
			if (!success)
			{
				printf(INVALUE,argv[2]);
				return;
			}

			if (begin > end)
			{
				ADDRESS temp = end;
				end = begin;
				begin = temp;
			}
		}
		else
		{
			end = begin + (DEFAULT_MD_LINES * 16);
		}
	}
	else
	{
		begin = md_last_address;
		size = md_last_size;
		end = begin + (DEFAULT_MD_LINES * 16);
	}

	show_mem:
		begin = cpu_align_address (begin,size);
		dump_mem(begin,end,size);
		md_last_address = end;
		md_last_size = size;
}

/********************************************************************/
void
uif_cmd_mm (int argc, char **argv)
{
	uint32 datar, dataw;
	int size, done, success, index;
	ADDRESS address;
	char string[UIF_MAX_LINE];

	(void)argc;

	size = cpu_parse_size(argv[0]);

	address = get_value(argv[1],&success,16);
	if (success == 0)
	{
		printf(INVALUE,argv[1]);
		return;
	}
	address = cpu_align_address (address,size);

	if (argv[2] != NULL)
	{
		/* the data has been specified */
		dataw = get_value(argv[2],&success,BASE);
		if (success == 0)
		{
			printf(INVALUE,argv[2]);
		}
		else
		{
			if ((index = flash_dlio_vda(address)) != 0)
				flash_program(address,(ADDRESS)&dataw,size/8,index,0,0);
			else
				cpu_write_data(address,size,dataw);
		}
		return;
	}
	else
	{
		done = FALSE;
		while (!done)
		{
			datar = cpu_read_data(address,size);
			printf("%08X:  ", address);
			switch (size)
			{
				case SIZE_8:
					printf("[%02X]  ", datar);
					break;
				case SIZE_16:
					printf("[%04X]  ", datar);
					break;
				case SIZE_32:
					printf("[%08X]  ", datar);
					break;
			}

			get_line(string);
			if (make_argv(string,NULL) == 0)
			{
				goto next_addr;
			}
			else
			{
				dataw = get_value(string,&success,BASE);
				if (!success)
				{
					/*
					 * Check for special cases
					 */
					if (string[0] == '=')
					{
						goto same_addr;
					}
					if (string[0] == '^')
					{
						switch (size)
						{
							case SIZE_8:
								address -= 1;
								break;
							case SIZE_16:
								address -= 2;
								break;
							case SIZE_32:
								address -= 4;
								break;
						}
						goto same_addr;
					}
					done = TRUE;
				}
				else
				{
					if ((index = flash_dlio_vda(address)) != 0)
						flash_program(address,(ADDRESS)&dataw,size/8,index,0,0);
					else
						cpu_write_data(address,size,dataw);
				}
			}

	next_addr:
			switch (size)
			{
				case SIZE_8:
					address += 1;
					break;
				case SIZE_16:
					address += 2;
					break;
				case SIZE_32:
					address += 4;
					break;
			}
	same_addr:
			;
		}
	}
}

/********************************************************************/
void
uif_cmd_rd (int argc, char **argv)
{
	int arg = 0;

	(void)argc;

	if (argv[1] == NULL)
		cpu_reg_display(NULL);
	else
	{
		while (argv[++arg] != NULL)
		{
			cpu_reg_display(argv[arg]);
		}
	}
}

/********************************************************************/
void
uif_cmd_rm (int argc, char **argv)
{
	uint32 value;
	int success;

	(void)argc;

	value = get_value(argv[2],&success,BASE);
	if (!success)
	{
		printf(INVALUE,argv[2]);
	}
	else
	{
		cpu_reg_modify(argv[1],value);
	}
}

/********************************************************************/
void
uif_cmd_sd (int argc, char **argv)
{
	char symstr[64];
	int success, displayed = 0;
	ADDRESS fp, backfp, retpc;
 
	if (argc == 2)
	{
		fp = (ADDRESS)get_value(argv[1], &success, BASE);
		if (!success)
		{
			printf(INVALUE, argv[1]);
			return;
		}
	}
	else
		fp = cpu_stack_frame(0,0);
 
	printf("Stk Frame Return PC\n");
	printf("--------- ---------\n");
 
	while (TRUE)
	{
		backfp = cpu_stack_frame(fp, &retpc);
 
		if (retpc == 0)
			break;
 
		printf("%08X: %08X", fp, retpc);
 
		if (symtab_convert_address2(retpc, symstr))
			printf("  %s", symstr);
		printf("\n");
 
		if ((backfp - fp) > 1024)
			break;
		else
			fp = backfp;
 
		if (++displayed >= 16)
			break;
	}
}

/********************************************************************/
void
uif_cmd_step (int argc, char **argv)
{
	/*
	 * This commands sets a breakpoint at one instruction
	 * further down the stream from the PC.  It does not
	 * attempt to account for branch conditions, but merely
	 * exists for BSR and JSR type instructions.
	 *
	 * NOTE:  Since this routine uses an entry in the breakpoint
	 * table, the user must allow at least one open slot for it!
	 */

	(void)argc;
	(void)argv;

	cpu_step_over = cpu_disasm(cpu_pc_get(),FALSE);
	breakpoint_add(cpu_step_over, BKPT_TEMP);
	cpu_switch_context(FALSE);
}

/********************************************************************/
void
uif_cmd_trace (int argc, char **argv)
{
	int success;

	cpu_trace_count = 1;

	if (argc == 2)
	{
		cpu_trace_count = get_value(argv[1],&success,10);
		if (!success)
		{
			cpu_trace_count = 1;
		}
	}
	cpu_switch_context(TRUE);
}

/********************************************************************/
void
uif_cmd_reset (int argc, char **argv)
{
	(void)argc;
	(void)argv;

	/*
	 * Call the board specific reset routine.  If that returns,
	 * then invoke normal reset entry point.
	 */
	board_reset();
	asm_startmeup();
}

/********************************************************************/
static const char CPU_BRD_STRING[] = "%s on the %s\n";
#ifdef __MWERKS__
static const char VERSION[] = "Firmware v%d%c.%d%c.%d%c (Built on %s %s)\n";
#else
static const char VERSION[] = "Firmware v%d%c.%d%c.%d%c (Build %d on %s %s)\n";
#endif

void
uif_cmd_ver (int argc, char **argv)
{
	(void)argc;
	(void)argv;

	printf("\n");
	printf(CPU_BRD_STRING, CPU_STR, BRD_STR);
	
#ifdef _MWERKS_
	printf(VERSION,
			UIF_VER_MAJOR, UIF_VER_MINOR,
			CPU_VER_MAJOR, CPU_VER_MINOR,
			BRD_VER_MAJOR, BRD_VER_MINOR,
			BRD_DATE, BRD_TIME);
#else
	printf(VERSION,
			UIF_VER_MAJOR, UIF_VER_MINOR,
			CPU_VER_MAJOR, CPU_VER_MINOR,
			BRD_VER_MAJOR, BRD_VER_MINOR,
			BRD_BUILD, BRD_DATE, BRD_TIME);
#endif
	printf(COPYRIGHT);
	printf(COPYRIGHT2);
	printf("\n");
}

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