cmds.c

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

/*
 * File:		cmds.c
 * Purpose:		Core dBUG commands for general purpose debugging.
 *
 * Notes:
 *
 */

#include "src/include/dbug.h"
#include "src/uif/uif.h"
#ifdef DBUG_NETWORK
#include "src/uif/net/net.h"
#endif

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

#ifndef DEFAULT_MD_LINES
#define DEFAULT_MD_LINES    8
#endif

#ifndef TT_CHANNEL
#define TT_CHANNEL	0
#endif

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

/*
 * Default address and size for memory display.
 */
ADDRESS
md_last_address;

static int
md_last_size;

/*
 * Default address for disassembly.
 */
ADDRESS
disasm_last_address;

/*
 * Default address for assembly
 */
ADDRESS
asm_next_address;

extern void
download_srecord (int);

/*
 * Input source for downloading
 */
int
uif_dlio;

/********************************************************************/
void
uif_init (void)
{
	extern void breakpoint_init (void);
	extern void symtab_init (void);
	extern void history_init (void);
	extern void isr_init (void);
	extern void flash_init (void);

	BASE = 16;
	md_last_size = CPU_WORD_SIZE;
	md_last_address = 0;
	disasm_last_address = (ADDRESS)__USER_SPACE;
	asm_next_address = (ADDRESS)__USER_SPACE;

	breakpoint_init();
	symtab_init();
	history_init();
	isr_init();
	flash_init();
}

/********************************************************************/
uint32
get_value (char *s, int *success, int base)
{
	uint32 value;
	char *p;
	
	if (symtab_convert_string(s,&value))
	{
		*success = TRUE;
		return value;
	}

	value = strtoul(s,&p,base);
	if ((value == 0) && (p == s))
	{
		*success = FALSE;
		return 0;
	}
	else
	{
		*success = TRUE;
		return value;
	}
}

/********************************************************************/
void
uif_cmd_asm (int argc, char **argv)
{
	char asmline[UIF_MAX_LINE];
	char *asmargv[UIF_MAX_ARGS];
	int success, numargs;
	ADDRESS asm_pc, next_asm_pc, next_pc;

	if (argc >= 2)
	{
		asm_pc = get_value(argv[1],&success,BASE);
		if (!success)
		{
			printf("Error: Invalid address: %s\n", argv[1]);
			return;
		}
		if (!board_dlio_vda(asm_pc))
		{
			printf("Error: Cannot write to address %08X.\n", asm_pc); 
			return;
		}	
	}
	else
	{
		asm_pc = asm_next_address;
		if (!board_dlio_vda(asm_pc))
		{
			printf("Error: Cannot write to address %08X.\n", asm_pc); 
			return;
		}	
	}

	if ((argc == 1) || (argc == 2))
	{
		/* interactive assembly */
		while (TRUE)
		{
			next_pc = cpu_disasm(asm_pc,TRUE);
			printf("%08X> ",asm_pc);
			get_line(asmline);
			numargs = make_argv(asmline,asmargv);
			if (numargs == 0)
			{
				next_asm_pc = next_pc;
			}
			else
			{
				if (numargs == 1)
				{
					if (asmargv[0][0] == '.')
						break;
				}
				next_asm_pc = cpu_asm(asm_pc, asmargv);
				/* Break if we reach the end of a memory block */
				if (!board_dlio_vda(next_asm_pc))
					break;
				if (next_asm_pc != asm_pc)
					cpu_disasm(asm_pc,TRUE);
			}
			asm_pc = next_asm_pc;
		}
		asm_next_address = asm_pc;
	}
	else
	{
		asm_next_address = cpu_asm(asm_pc, &argv[2]);
	}
}

/********************************************************************/
void
uif_cmd_bc (int argc, char **argv)
{
	int success;
	unsigned int i, j, k, length;
	ADDRESS first, second;
	
	(void)argc;

	first = get_value(argv[1], &success, 16);
	if (success == 0)
	{
		printf(INVALUE,argv[1]);
		return;
	}
	
	second = get_value(argv[2], &success, 16); 
    if (success == 0) 
    { 
        printf(INVALUE,argv[2]); 
        return; 
    } 
	
	length = get_value(argv[3], &success, BASE); 
    if (success == 0) 
    { 
        printf(INVALUE,argv[3]); 
        return; 
    }

	i = (unsigned int) first;
	j = (unsigned int) second;
	k = 0;
	
	/* This isn't efficient, this loop compares BYTE at a time */
	success = TRUE;
	while (k < ((unsigned int)length - 1))
	{
		if ((int)cpu_read_data((ADDRESS)i,8) != (int)cpu_read_data((ADDRESS)j,8))
		{
			printf("Mismatch:  %#08X, %#08X\n",(ADDRESS)i, (ADDRESS)j);
			success = FALSE;
			break;
		}
		i++; j++; k++;
	}
	if (success)
		printf("Blocks starting at %#04X and %#04X of length %#02X are identical.\n",\
			first, second, length);

}
/********************************************************************/
void
uif_cmd_bf (int argc, char **argv)
{
	int size, success;
	uint32 data, inc;
	ADDRESS begin, end, index;

	size = cpu_parse_size(argv[0]);

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

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

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

	if (argc == 5)
	{
		inc = get_value(argv[4],&success,BASE);
		if (success == 0)
		{
			printf(INVALUE,argv[4]);
			return;
		}
	}
	else
		inc = 0;

	if (begin > end)
	{
		ADDRESS temp = begin;
		begin = end;
		end = temp;
	}

	index = begin;
	while (index < end)
	{
		cpu_write_data(index,size,data);
		switch (size)
		{
			case SIZE_8:
				index += 1;
				break;
			case SIZE_16:
				index += 2;
				break;
			case SIZE_32:
				index += 4;
				break;
			default:
				break;
		}
		data += inc;
	}
}

/********************************************************************/
void
uif_cmd_bm (int argc, char **argv)
{
	int size, success;
	ADDRESS begin, end, dest, index;
	int b;			/* byte */

	(void)argc;

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

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

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

	if (begin > end)
	{
		ADDRESS temp;
		temp = begin;
		begin = end;
		end = temp;
	}

	size = (end - begin + 1);

	/* check for the two possible cases of overlap */
	if ( (((dest + size) >= begin) &&
		  ((dest + size) <= end)) ||
	 	  ((dest >= begin) && (dest <= end)) )
	{
		printf("Error:  Overlapping destination\n");
	}
	else
	{
		/* This isn't the most efficient way of doing this */
		for (index = begin; index <= end; index++)
		{
			b = cpu_read_data(index, SIZE_8);
			cpu_write_data(dest + index - begin, SIZE_8, b);
		}
	}
}

/********************************************************************/
void
uif_cmd_bs (int argc, char **argv)
{
	int success, size;
	ADDRESS begin, end, index;
	int found = FALSE;
	uint32 data;

	(void)argc;

	size = cpu_parse_size(argv[0]);

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

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

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

	if (begin > end)
	{
		ADDRESS temp = begin;
		begin = end;
		end = temp;
	}

	index = begin;
	while (index <= end)
	{
		if (data == cpu_read_data(index,size))
		{
			found = TRUE;
			break;
		}
		switch (size)
		{
			case SIZE_8:
				index += 1;
				break;
			case SIZE_16:
				index += 2;
				break;
			case SIZE_32:
				index += 4;
				break;
		}
	}

	if (found)
		printf("Data located at:  %#08X\n", index);
	else
		printf("Data not found.\n");
}

/********************************************************************/
void
uif_cmd_dc (int argc, char **argv)
{
	uint32 data;
	int success;

	(void)argc;

	data = get_value(argv[1],&success,0);
	printf("Hex: %#08X, Bin: %032b, Dec: %d\n", data, data, data);
}

/********************************************************************/
void
uif_cmd_dis (int argc, char **argv)
{
	ADDRESS pc;
	int index, success;

	pc = cpu_pc_get();

	if (argc == 2)
	{
		/* Address to start disasm at */
		pc = get_value(argv[1],&success,BASE);
		if (success == 0)
		{
			printf(INVALUE,argv[1]);
			return;
		}
	}
	else
	{
		/* command given with no args -- repeat */
		if (disasm_last_address != 0)
			pc = disasm_last_address;
	}

	for (index = 0; index < 16; index++)
		pc = cpu_disasm(pc,TRUE);
	disasm_last_address = pc;
}

/********************************************************************/
void
uif_cmd_go (int argc, char **argv)
{
	ADDRESS	address;
	int success;
	
	if (argc == 2)
	{
		address = get_value(argv[1],&success,BASE);
		if (success == 0)
		{
			printf(INVALUE,argv[1]);
			return;
		}
		cpu_pc_modify(address);
	}
	cpu_switch_context(FALSE);
}

/********************************************************************/
void
uif_cmd_gt (int argc, char **argv)
{
	ADDRESS	address;
	int success;
	
	(void)argc;

	address = get_value(argv[1],&success,BASE);
	if (success == 0)
	{
		printf(INVALUE,argv[1]);
		return;
	}
	breakpoint_add(address, BKPT_TEMP);
	cpu_switch_context(FALSE);
}

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

static const char HELPFORMAT[] = "%8s %-25s %s %s\n";

static void
help_display (int index)
{
	printf(HELPFORMAT,
		UIF_CMDTAB[index].cmd,
		UIF_CMDTAB[index].description,
		UIF_CMDTAB[index].cmd,
		UIF_CMDTAB[index].syntax);
}

void
uif_cmd_help (int argc, char **argv)
{
	int index, displayed;

	if (argc == 1)
	{
		/*
		 * Display all command summaries
		 */
		/*printf(HELPTITLE);*/
		printf(HELPFORMAT,"Command","Description","Syntax","");
		displayed = 1;
		for (index = 0; index < UIF_NUM_CMD; index++)
		{
			if (!(UIF_CMDTAB[index].flags & UIF_CMD_FLAG_HIDDEN))
			{
				help_display(index);
				if (pause(&displayed))
					return;
			}
		}
		printf("\nUser code may start at address %#08X\n", __USER_SPACE);
		return;
	}
	else
	{
		/*
		 * Display specific command summary
		 */