jtag-arm.c

GDB Remote Stub Backend for debugging an embedded ARM system via JTAG common hardware debug interfac

	/* ok trying to set a register value */
	reg = (int) hex_to_num(value);

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: regs [<reg> <value>]\n");
		return(1);
	}

	data = hex_to_num(value);

	regs_set(reg, data);
	regs_print();
	return(0);
}

int parse_hw_breakpoint(void)
{
	unsigned long nr;
	unsigned long address = 0;
	unsigned long mask = 0;

	char * value;

	if (ice_halted()) {
		printf("CPU already halted.\n");
		return(1);
	}

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: bp <0..1> [addr] [mask]\n");
		return(1);
	}
	nr = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value == 0) {
		ice_disable_wp(nr);
		return(0);
	} else
	    address = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value != 0) {
	    mask = hex_to_num(value);
	}
	
	ice_set_hardware_breakpoint(nr, address, mask);
	while (!ice_halted()) {
	    usleep(100);
	}
	debug_save_regs();
	ice_disable_wp(nr);

	return(0);
}

int parse_sw_breakpoint(void)
{
	unsigned long nr;
	unsigned long pattern = 0;

	char * value;

	if (ice_halted()) {
		printf("CPU already halted.\n");
		return(1);
	}

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: bp <0..1> [pattern]\n");
		return(1);
	}
	nr = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value == 0) {
		ice_disable_wp(nr);
		return(0);
	} else
	    pattern = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value != 0) {
	    pattern = hex_to_num(value);
	}
	
	ice_set_software_breakpoint(nr, pattern);
	while (!ice_halted()) {
	    usleep(100);
	}
	debug_save_regs();
	ice_disable_wp(nr);

	return(0);
}

int parse_idcode(void)
{
    unsigned short version;		//  4 bits
    unsigned int part_number;		// 16 bits
    unsigned int manufacturer_id;	// 11 bits
    unsigned int marker;		//  1 bit
    static char manufacturer_str[25];
    static char part_str[12];

    unsigned short arm_core_id;		//  1 bit
    unsigned short capability_bits;	//  3 bits
    unsigned short family;		//  4 bits
    unsigned short device_number;	//  8 bits
    static char capability_str[50];
    static char device_str[40];

    printf("Device ID: 0x%8.8X\n", jtag_idcode);

    // generic JTAG IDCODE
    version         = (jtag_idcode & 0xF0000000) >> 28;
    part_number     = (jtag_idcode & 0x0FFFF000) >> 12;
    // manufacturer_id = (jtag_idcode & 0x00000FFE) >>  1;
    manufacturer_id = (jtag_idcode & 0x00000FFF) >>  0;
    marker          = (jtag_idcode & 0x00000001) >>  0;
    switch (manufacturer_id) {
	case 0xF0F: strcpy(manufacturer_str, "Default manufacturer");	break; // 0x787 without marker bit
	default:    strcpy(manufacturer_str, "Unknown manufacturer");
    }
    switch (part_number) {
	case 0x0700: strcpy(part_str, "ARM7TDMI"   );	break;
	case 0xF1F0: strcpy(part_str, "ARM7TDMI-S" );	break;
	case 0x7700: strcpy(part_str, "ARM7EJ-S"   );	break;
	case 0x0900: strcpy(part_str, "ARM9TDMI"   );	break;
	case 0x0720: strcpy(part_str, "ARM720T"    );	break;
	case 0x0920: strcpy(part_str, "ARM920T"    );	break;
	case 0x0922: strcpy(part_str, "ARM922T"    );	break;
	case 0x0940: strcpy(part_str, "ARM940T"    );	break;
	case 0x7926: strcpy(part_str, "ARM926EJ-S" );	break;
	case 0x5946: strcpy(part_str, "ARM946E-S"  );	break;
	case 0x5966: strcpy(part_str, "ARM966E-S"  );	break;
	case 0x7A26: strcpy(part_str, "ARM1026EJ-S");	break;
	case 0x7B36: strcpy(part_str, "ARM1136J-S" );	break;
	case 0xF0F0: strcpy(part_str, "default"    );	break;
	default:     strcpy(part_str, "unknown"    );
    }
    printf("--- JTAG ID code fields ---\n");
    printf("Marker         : 0x%4.1X (Always '1')\n", marker);
    printf("Manufacturer ID: 0x%4.3X (%s)\n", manufacturer_id, manufacturer_str);
    printf("Part Number    : 0x%4.4X (%s)\n", part_number, part_str);
    printf("Version        : 0x%4.1X (rev%d)\n", version, version);

    // ARM part number
    arm_core_id     = (part_number & 0x8000) >> 15;
    capability_bits = (part_number & 0x7000) >> 12;
    family          = (part_number & 0x0F00) >>  8;
    device_number   = (part_number & 0x00FF) >>  0;
    if (family < 11) {	// Capability - ARM7, ARM9, ARM10 Core Families
	switch ( (arm_core_id << 3) & capability_bits) {
    	    case 0x0: strcpy(capability_str, "ARM Processor pre E extension - hard macrocell");		break;
	    case 0x1: strcpy(capability_str, "ARM Processor pre E extension - soft macrocell");		break;
	    case 0x4: strcpy(capability_str, "ARM processor with E extension - hard macrocell");	break;
	    case 0x5: strcpy(capability_str, "ARM processor with E extension - soft macrocell");	break;
	    case 0x6: strcpy(capability_str, "ARM Processor with J extension - hard macrocell");	break;
	    case 0x7: strcpy(capability_str, "ARM Processor with J extension - soft macrocell");	break;
	    case 0x9: strcpy(capability_str, "Not a recognised executable ARM device");			break;
	    case 0xB: strcpy(capability_str, "ARM Embedded Trace Buffer");				break;
	    case 0xF: strcpy(capability_str, "Typically used for test chip boundary scan IDs");		break;
	    default:  strcpy(capability_str, "Reserved");
        }
    } else {	// Capability - ARM11 Core Family
	switch ( (arm_core_id << 3) & capability_bits) {
	    case 0x6: strcpy(capability_str, "ARM Processor with J extension - hard macrocell");	break;
	    case 0x7: strcpy(capability_str, "ARM Processor with J extension - soft macrocell");	break;
	    case 0x9: strcpy(capability_str, "Not a recognised executable ARM device");			break;
	    case 0xB: strcpy(capability_str, "ARM Trace Buffer");					break;
	    case 0xF: strcpy(capability_str, "Typically used for test chip boundary scan IDs");		break;
	    default:  strcpy(capability_str, "Reserved");
        }
    }
    switch (device_number) {
	case 0x00: strcpy(device_str, "Core only");						break;
	case 0x20: strcpy(device_str, "Core with MMU");						break;
	case 0x22: strcpy(device_str, "Core with MMU and half-size caches");			break;
	case 0x26: strcpy(device_str, "Core with MMU and TCM");					break;
	case 0x40: strcpy(device_str, "Core with MPU");						break;
	case 0x46: strcpy(device_str, "Core with MPU and TCM");					break;
	case 0x66: strcpy(device_str, "Core with TCM");						break;
	case 0x36: strcpy(device_str, "V6 architecture core with MMU");				break;
	default:   strcpy(device_str, "Unknown core");
    }
    printf("--- ARM Part Number ---\n");
    printf("ARM Core ID    : 0x%2.1X (%s)\n", arm_core_id, arm_core_id?"ARM core ID":"Non-ARM core ID");
    printf("Capability Bits: 0x%2.1X (%s)\n", capability_bits, capability_str);
    printf("Family         : 0x%2.1X (ARM%d)\n", family, family);
    printf("Device Number  : 0x%2.2X (%s)\n", device_number, device_str);

    return(0);
}

int parse_sc(void)
{
    unsigned long Data[6] = {0,0,0,0,0,0};

    sc_select(SC_Macrocell_scan_test);

    jtag_instruction(JTAG_SAMPLE_PRELOAD, Data, SC_sizes[SC_Macrocell_scan_test]);
    //jtag_instruction(JTAG_INTEST, Data, SC_sizes[SC_Macrocell_scan_test]);
    printf("%8.8x %8.8x %8.8x %8.8x %8.8x %8.8x\n", Data[5], Data[4], Data[3], Data[2], Data[1], Data[0]);

    jtag_instruction(JTAG_SAMPLE_PRELOAD, Data, SC_sizes[SC_Macrocell_scan_test]);
    //jtag_instruction(JTAG_EXTEST, Data, SC_sizes[SC_Macrocell_scan_test]);
    printf("%8.8x %8.8x %8.8x %8.8x %8.8x %8.8x\n", Data[5], Data[4], Data[3], Data[2], Data[1], Data[0]);

    printf("ID      : %8.8x\n", sc_read(Data, SC0_ID      ));	// 32..01	instruction data bus
    printf("SYSSPEED: %8.8x\n", sc_read(Data, SC0_SYSSPEED));	// 33		0: Breakpoint   1: Watchpoint
    printf("Unused  : %8.8x\n", sc_read(Data, SC0_Unused  ));	// 34
    printf("DDEN    : %8.8x\n", sc_read(Data, SC0_DDEN    ));	// 35		data data bus output enable
    printf("DD      : %8.8x\n", sc_read(Data, SC0_DD      ));	// 36..67	data data bus
    printf("DA      : %8.8x\n", sc_read(Data, SC0_DA      ));	// 68..99	data address bus
    jtag_instruction(JTAG_RESTART, NULL, 0);

    return(0);
}

int parse_help(void)
{
	printf("--- basic commands ---\n");
	printf("#\n");
	printf("script\n");
	printf("echo\n");
	printf("pause\n");
	printf("quit\n");
	printf("help\n");
	printf("--- jtag commands ---\n");
	printf("jtag\n");
	printf("idcode\n");
	printf("--- debug commands ---\n");
	printf("stop\n");
	printf("step\n");
	printf("restart\n");
	printf("run <address>\n");
	printf("--- memory commands ---\n");
	printf("read <address> [<length>]\n");
	printf("write <address> <data>\n");
	printf("load <file_name> <address> [<length>]\n");
	printf("--- register commands ---\n");
	printf("regs [<reg> <value>]\n");
	printf("--- breakpoint commands ---\n");
	printf("bphw <0..1> [addr] [mask]\n");
	printf("bpsw <0..1> [pattern]\n");
	return(0);
}


int parse_main(char * command_line)
{
	char * command;

	if (*command_line == '.')
		strcpy(command_line, previous_command_line);
	else 
		strcpy(previous_command_line, command_line);

	/* strip off \n and get commmand head */
	command = strtok(command_line, "\n");
	command = strtok(command, " ");

	if (command) {
		/* basic commands */
		if (strcmp(command, "#") == 0)
			return(0);
		if (strcmp(command, "script") == 0)
			return(parse_script());
		if (strcmp(command, "echo") == 0)
			return(parse_echo());
		if (strcmp(command, "pause") == 0)
			return(parse_pause());
		if (strcmp(command, "quit") == 0)
			exit(0);
		if (strcmp(command, "help") == 0)
			return(parse_help());

		/* jtag commands */
		if (strcmp(command, "jtag") == 0) {
			tapsm_reset(0);
			return(0);
		}
		if (strcmp(command, "idcode") == 0)
			return(parse_idcode());

		/* debug commands */
		if (strcmp(command,"stop") == 0) {
			debug_stop();
			if (!lpec_init_done) {
			    lpec_init();
			    lpec_init_done = 1;
			}
			return(0);
		}
		if (strcmp(command,"step") == 0) {
			debug_step();
			return(0);
		}
		if (strcmp(command,"restart") == 0) {
			debug_run();
			return(0);
		}
		if (strcmp(command,"run") == 0) {
			parse_run();
			return(0);
		}

		/* scan chain commands */
		if (strcmp(command, "sc") == 0)
			return(parse_sc());
		
		/* memory commands */
		if (strcmp(command, "read") == 0)
			return(parse_read());
		if (strcmp(command, "write") == 0)
			return(parse_write());
		if (strcmp(command, "load") == 0)
			return(parse_load());

		/* register commands */
		if (strcmp(command, "regs") == 0)
			return(parse_regs());

		/* breakpoint commands */
		if (strcmp(command, "bphw") == 0)
			return(parse_hw_breakpoint());
		if (strcmp(command, "bpsw") == 0)
			return(parse_sw_breakpoint());

		if (strcmp(command, "status") == 0) {
			ice_show_status();
			return(0);
		}

		printf("Unknown command: %s\n", command);
	}

	return(1);	
}


int main(void)
{
	char input_line[128];
	int temp;

	printf("JTAG-ARM - JTAG interface to the ARM processor family\n");
	printf("by Tobias Lorenz and Lars Kristian Klauske (Jan 2004)\n");
	printf("based on code by Simon Wood. July 2001\n\n");

	pp_init();
	tapsm_reset(1);
	jtag_get_idcode();

	while (1) {
		printf("Jtag:>");
		fgets(input_line, sizeof(input_line), stdin);

		parse_main(input_line);
	}

	pp_done();
	exit(0);
}