jtag-arm.c

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

/*
 *  Copyright (C) 2004 Tobias Lorenz
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/* command line client */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>

#include "pp.h"
#include "jtag.h"
#include "debug.h"
#include "memory.h"
#include "ice.h"
#include "lpec.h"

char previous_command_line[128] = "";
unsigned int lpec_init_done = 0;

unsigned long hex_to_num(char * value)
{
	int temp;
	unsigned long number;
	unsigned base =  16;

	number = 0;

	for (temp=0; temp < strlen(value); temp ++) {
		if (value[temp] < 58 && value[temp] > 47)
			/* number */
			number = (number * base) + (value[temp] - 48);
		else if (value[temp] < 103 && value[temp] > 96)
			/* letter */
			number = (number * base) + (value[temp] - 97 + 10);
		else if (value[temp] == 43) {
			number = 0;
			base = 10;
		} else
			/* illegal character */
			return(number);
	}
	
	return(number);
}

int regs_print(void)
{
    /* print out the registers */
    int temp;
    static char mode_str[5];

    printf("Registers:\n");
    for (temp = 0; temp < 8; temp++)
	printf("  R%2.2d - 0x%8.8x   R%2.2d - 0x%8.8x\n",
			temp, arm_regs.r[temp],
			temp+8, arm_regs.r[temp+8]);

    printf("\n");
    
    printf("  PC  - 0x%8.8x  CPSR - 0x%8.8x", arm_regs.pc, arm_regs.cpsr);

    switch(arm_regs.cpsr & 0x1F) {
	case PSR_M_usr:	strcpy(mode_str, "usr"); break;
	case PSR_M_fiq: strcpy(mode_str, "fiq"); break;
	case PSR_M_irq: strcpy(mode_str, "irq"); break;
	case PSR_M_svc: strcpy(mode_str, "svc"); break;
	case PSR_M_abt: strcpy(mode_str, "abt"); break;
	case PSR_M_und: strcpy(mode_str, "und"); break;
	case PSR_M_sys: strcpy(mode_str, "sys"); break;
	default:        strcpy(mode_str, "???");
    }

    printf("    CCF: %c%c%c%c  CB:%c%c%c  MB:%s\n",
	arm_regs.cpsr&PSR_N?'N':' ',
	arm_regs.cpsr&PSR_Z?'Z':' ',
	arm_regs.cpsr&PSR_C?'C':' ',
	arm_regs.cpsr&PSR_V?'V':' ',
	arm_regs.cpsr&PSR_I?'I':' ',
	arm_regs.cpsr&PSR_F?'F':' ',
	arm_regs.cpsr&PSR_T?'T':' ',
	mode_str);

    printf("\n");

    return(0);
}

int regs_set(int reg, unsigned long value)
{
    if (reg < 0 || reg > 15) {
    	printf("register must be between 0 and 15\n");
    	return(1);
    }

    arm_regs.r[reg] = value;
    return (0);
}

int parse_script(void)
{
	FILE * script_file;
	char script_line[128];
	char * value;

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: script <file_name>\n");
		return(1);
	}
	
	script_file = fopen(value, "r");

	if (script_file == 0) {
		printf("Error opening script file : %s\n", value);
		return(1);
	}
	
	while (fgets(script_line, sizeof(script_line), script_file)) {
		if(parse_main(script_line)) {
			printf("Abborted - Error running:\n%s\n", script_line);
			break;
		}
	}

	fclose(script_file);

	/* rebuild previous_command_line */
	strcpy(previous_command_line, "script ");
	strcat(previous_command_line, value);

	return(0);
}

int parse_echo(void)
{
	char * value;

	value = strtok(NULL, " ");
	while (value ) {
		printf("%s ", value);
		value = strtok(NULL, " ");
	}

	printf("\n");

	return(0);
}

int parse_pause(void)
{
	char * value;
	unsigned long snooze;

	value = strtok(NULL, " ");

	if (value ) {
		snooze = hex_to_num(value);
		printf("Pausing for 0x%8.8X seconds\n", snooze);
		sleep(snooze);
	}

	return(0);
}

int parse_read(void)
{
	unsigned long address;
	unsigned long *data, *dataptr;
	unsigned long length = 1;
	FILE * file = 0;

	char * value;

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: read <address> [<length>] [<file>]\n");
		return(1);
	}
	address = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value != 0) {
		length = hex_to_num(value);

		value = strtok(NULL, " ");
		if (value != 0)
		    file = fopen(value, "w");
	}

	data = malloc(length*4);
	dataptr = data;
	memory_read(address, data, length);
	if (file)
	    fwrite(data, sizeof(unsigned long), length, file);
	while (length>0) {
	    printf("0x%8.8X: 0x%8.8X\n", address, *dataptr );
	    address += 4;
	    dataptr ++;
	    length  --;
	}
	free(data);
	if (file)
	    fclose(file);

	return(0);
}

int parse_write(void)
{
	unsigned long address;
	unsigned long data;
	char * value;

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: write <address> <data>\n");
		return(1);
	}
	address = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: write <address> <data>\n");
		return(1);
	}
	data = hex_to_num(value);

	memory_write(address, &data, 1);

	return(0);
}

int parse_load(void)
{
	char * value;

	FILE * data_file;
	unsigned long address;
	unsigned long * data;
	unsigned long * data_start;
	unsigned long length;

	unsigned long temp;
	unsigned long temp2;
	unsigned char data_byte;
	unsigned char data_ended = 0;

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: load <file_name> <address> [<length>]\n");
		return(1);
	}
	
	data_file = fopen(value, "rb");

	if (data_file == 0) {
		printf("Error opening file : %s\n", value);
		return(1);
	}
	
	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: load <file_name> <address> [<length>]\n");
		return(1);
	}
	address = hex_to_num(value);

	value = strtok(NULL, " ");
	if (value != 0)
		/* length in long words */
		length = hex_to_num(value)/4;
	else
		/* do whole file */
		length = 0xFFFFFFFF;

	data_start = malloc(1024 * sizeof(unsigned long));

	if (data_start == NULL) {
		printf("Unable to allocate temporary storage\n");
		fclose(data_file);
		return(1);
	}

	data = data_start;

	while (length) {
		for (temp = 0; temp < 1024; temp++) {
			*data = 0;
	
			/* read in bytes convert to long words */
			for (temp2 = 0; temp2 < 4; temp2++) {
#if 1
				if (fread(&data_byte, sizeof(data_byte), 1, data_file) == 0) {
					data_ended = (unsigned char) EOF;
					break;
				}

#else
				data_byte = fgetc(data_file);

				if (data_byte == (unsigned char)EOF)
					break;
#endif				
				*data = (*data >> 8) + (data_byte << 24);
			}
			
			if (data_ended == (unsigned char)EOF) {
				length = temp + 1;
				break;
			}
	
			data++;
		}

		if (length < 1024 ) {
			memory_write(address, data_start, length);
			length = 0;
		} else {
			memory_write(address, data_start, temp);
			address = address + 4096;
			length = length - 1024;
			data = data_start;
		}
	}
		
	
	fclose(data_file);
	free(data_start);

	return(0);
}

int parse_run(void)
{
	char * value;

	value = strtok(NULL, " ");
	if (value == 0) {
		printf("Usage: run <address>\n");
		return(1);
	}

	// set pc to address and execute in usr mode
	arm_regs.pc = hex_to_num(value);
	arm_regs.cpsr &= ~PSR_M_sys;
	arm_regs.cpsr |= PSR_M_usr;
	regs_print();
	debug_run();

	return(0);
}

int parse_regs(void)
{
	int reg;
	unsigned long data;
	char * value;

	value = strtok(NULL, " ");
	if (value == 0) {
		regs_print();
		return(0);
	}