gdb-jtag-arm.c

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

	case 'c':	// continue
	    debug_run();
	    //answer_gdb(3,"S05");
	    //answer_gdb(2, "OK");
	    last_running=1;
	    printf("(continue)\n");
	    break;

	case 'C':	// continue with signal
	    answer_gdb(0,"\0");
	    printf("(continue with signal)\n");
	    break;
	    
	case 's':	// step
	    gdb_step();
	    answer_gdb(3,"S05");
	    printf("(step)\n");
	    break;

	case 'S':	// step with signal
	    answer_gdb(0,"\0");
	    printf("(step with signal)\n");
	    break;
	    
	case '?':	// query last signal
	    answer_gdb(3,"S05");
	    printf("(query last signal)\n");
	    break;
	    
	case 'D':	// detach
	    printf("(detach)\n");
	    printf ("Exiting\n");
	    close(client_socket);
	    client_socket=0;
	    debug_run();
	    break;

	case 'T':	// query is thread alive
	    answer_gdb(0,"\0");
	    printf("(query is thread alive)\n");
	    break;
	
	case 'R':	// restart the remote server
	    answer_gdb(0,"\0");
	    printf("(restart the remote server)\n");
	    break;
	
	case '!':	// use extended ops
	    answer_gdb(0,"\0");
	    printf("(use extended ops)\n");
	    break;

	case 'k':	// kill target
	    answer_gdb(0,"\0");
	    printf("(kill target)\n");
	    break;
	
	case 'd':	// toggle debug
	    answer_gdb(0,"\0");
	    printf("(toggle debug)\n");
	    break;
	
	case 'r':	// reset
	    answer_gdb(0,"\0");
	    printf("(reset)\n");
	    break;
	
	case 't':	// search memory
	    answer_gdb(0,"\0");
	    printf("(search memory)\n");
	    break;
	
	case 'q':	// general query
	    answer_gdb(0,"\0");
	    printf("(general query)\n");
	    break;
	
	case 'Q':	// general set
	    answer_gdb(0,"\0");
	    printf("(general set)\n");
	    break;
	    	
	default:
	    answer_gdb(0,"\0");
	    printf("(unknown command %c)\n", cmd[0]);
	    
    }

    printf("\n");    

}





int gdb_insert_breakpoint(int length, char *buffer)
{
    char type;
    unsigned long addr, range, mask;
    int idx = 0;
    int ret = 0;

    switch (type) {

	case '0':	// set software breakpoint
	    printf("Setze SW Breakpoint an %8.8x , Bereich %8.8x , Maske %8.8x\n",addr,range,mask);
	    idx=0;
	    while (idx<=sw_bp_max && sw_bp_memdata[idx]!=SW_BP_PATTERN) {
		if (sw_bp_addr[idx] == addr) {
		    printf("Breakpoint already set!\n");
		    return -1;
		}
		idx++;
	    }
	    if (idx < sw_bp_max) {
		memory_read(addr, &sw_bp_memdata[idx], 1);
		sw_bp_addr[idx]=addr;
		memory_write(addr, &SW_BP_PATTERN, 1);
	    } else {
	        printf("Too many SW BPs !!!\n");
	        ret=-1;
	    }
	    break;

	case '1':	// set hardware breakpoint
	    printf("Setze HW Breakpoint an %8.8x , Bereich %8.8x , Maske %8.8x\n", addr, range, mask);
	    printf("Not tested yet!\n");
	    if (!ice_wp_enabled(1)) {
		ice_set_hardware_breakpoint(1, addr, mask);
	    } else {
		printf("Too many HW BPs !!!\n");
		ret=-1;
	    }
	    break;

	case '2':	// set watchpoint
	    printf("Setze Watchpoint an %8.8x , Bereich %8.8x , Maske %8.8x\n", addr, range, mask);
	    printf("Not tested yet!\n");
	    if (!ice_wp_enabled(1)) {
		ice_set_hardware_watchpoint(1, addr, mask);
	    } else {
		printf("Too many HW WPs !!!\n", addr);
		ret=-1;
	    }
	    break;
	    
	default:
	
	    printf("Unbekanntes BP-Kommando: %c , Addresse: %8.8x , Bereich %8.8x , Maske %8.8x\n",
		   type, addr, range, mask);
	    ret=-1;
	    break;
    }
    
    return ret;
    
}




int gdb_remove_breakpoint(int length, char *buffer)
{
    char type;
    unsigned long addr, range, mask;
    int idx = 0;
    int ret = 0;

    /* read command from buffer */
    type = buffer[0];
    buffer+=2;

    while (idx<8 && buffer[idx]!=',') idx++;
    buffer[idx]='\0';
    addr=HexString_to_Long(buffer);

    buffer+=idx+1;
    range=HexString_to_Long(buffer);
    mask=range-1;

    /* now do something with it */
    switch (type) {

	case '0':	// remove software breakpoint
	    printf("Entferne SW Breakpoint an %8.8x\n", addr);
	    idx=0; while (idx<=sw_bp_max && sw_bp_addr[idx]!=addr && sw_bp_memdata[idx]!=SW_BP_PATTERN) idx++;
	    if (idx<sw_bp_max) {
	        memory_write(sw_bp_addr[idx], &sw_bp_memdata[idx], 1);
	        sw_bp_memdata[idx]=SW_BP_PATTERN;
	    } else {
		ret=-1;
		printf("SW BP not found !!!\n");
	    }

	    break;

	case '1':	// remove hardware breakpoint
	    printf("Entferne HW Breakpoint an %8.8x , Bereich %8.8x , Maske %8.8x\n", addr, range, mask);
	    printf("Not tested yet!\n");
	    if (!ice_wp_enabled(1) && ice_get_breakpoint_addr(1)==addr) {
		ice_disable_wp(1);
	    } else {
		printf("HW BP not found !!!\n");
		ret=-1;
	    }
	    break;

	case '2':	// remove watchpoint
	    printf("Entferne Watchpoint an %8.8x , Bereich %8.8x , Maske %8.8x\n", addr, range, mask);
	    printf("Not tested yet!\n");
	    if (ice_wp_enabled(1) && ice_get_watchpoint_addr(1)==addr) {
		ice_disable_wp(1);
	    } else {
		printf("WP not found !!!\n");
		ret=-1;
	    }
	    break;
	    
	default:
	    printf("Unbekanntes BP-Kommando: %c , Addresse: %8.8x , Bereich %8.8x , Maske %8.8x\n",
		   type, addr, range, mask);
	    ret=-1;
	    break;
    }
    
    return ret;
}


void gdb_step() {
    int idx = 0;

    /* before stepping restore all memory data and clear breakpoints there */
    /* after  stepping reinstall software breakpoints and enable breakpoints */

    /* software breakpoints */
    while (idx<=sw_bp_max && sw_bp_memdata[idx]!=SW_BP_PATTERN && sw_bp_addr[idx]!=arm_regs.pc) idx++;
    if (idx < sw_bp_max)
	memory_write(sw_bp_addr[idx], &sw_bp_memdata[idx], 1);

    /* step now */
    if (idx < sw_bp_max)
	printf("Stepping over software breakpoint %i\n", idx);
    debug_step();

    /* software breakpoints */
    if (idx < sw_bp_max)
	memory_write(sw_bp_addr[idx], &SW_BP_PATTERN, 1);
}


int gdb_read_registers(int length, char *buffer)
{
    int temp;
    int realsize=0;
    unsigned long padding = 0;

    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  PC  - 0x%8.8x\n", arm_regs.pc);

    // r0..r15 (32 bits)
    for (temp = 0; temp<=15; temp++)
	realsize+=sprintf(buffer+realsize, "%8.8x", arm_regs.r[temp]);
    // f0..f7 (4*32 bits)
    for (temp = 0; temp<=7; temp++)
    	realsize+=sprintf(buffer+realsize, "%8.8x%8.8x%8.8x", padding, padding, padding);
    // fps (32 bits)
    realsize+=sprintf(buffer+realsize, "%8.8X", padding);
    // cpsr (32 bits)
    realsize+=sprintf(buffer+realsize, "%8.8X", arm_regs.cpsr);

    //printf("Returning %d Bytes for Registers\n",realsize);
    return realsize;
}

int gdb_write_registers(char *buffer) {
    long realsize=0;
    long mytemp=0;
    long tempL=0;
    char minibuffer[10];

    buffer++;
    for (tempL=0;(tempL<buffersize-1) && (buffer[tempL]!='\0');tempL++) realsize=tempL;

    printf("Found %d bytes for register-write.\n",realsize);

    for(mytemp=0; mytemp<=realsize; mytemp++) {
	minibuffer[mytemp%8] = buffer[mytemp];
	if (mytemp%8 == 7) {
	    minibuffer[8]='\0';
	    tempL=(mytemp-(mytemp%8))>>3;
	    arm_regs.r[tempL]=HexString_to_Long(minibuffer);
	    printf("Register %d written: %8.8x - %s\n",tempL,arm_regs.r[mytemp],minibuffer);
	}
    }
    // always switch to usr mode
    arm_regs.cpsr &= ~PSR_M_sys;
    arm_regs.cpsr |= PSR_M_usr;

    return 0;
}


#define change_endian(l) (	\
    ((l & 0x000000ff) << 24) |	\
    ((l & 0x0000ff00) <<  8) |	\
    ((l & 0x00ff0000) >>  8) |	\
    ((l & 0xff000000) >> 24));

void gdb_write_memory(unsigned long addr, unsigned long length, char *buffer) {
    unsigned long writeaddr;	// memory_write Adresse
    unsigned long *writedata;	// memory_write Anfang
    unsigned long writelength;	// memory_write L鋘ge
    unsigned long *longptr;
    unsigned char *charptr;
    unsigned long data;
    
    // im Speicher alles, in der selben Reihenfolge, wie den Datenstrom schreiben
    //  ===> BIG-ENDIAN auf little-Endian Maschine

    writeaddr   = addr;
    writedata   = malloc(sizeof(long)*(length+2));
    writelength = length;
    charptr     = (char *) writedata;

    // Verschnitt am Anfang
    if (writeaddr%4 != 0) {
	printf("Unaligned begin address: ");
	writeaddr &= ~(0x03);
	memory_read(writeaddr, &data, 1);
	printf("%8.8x\n", data);
	*writedata = change_endian(data);
	writelength += addr % 4;
	charptr = (char *) ( (unsigned long) charptr + addr % 4 );
    }
    
    // Verschnitt am Ende
    if (writelength%4 != 0) {
	printf("Unaligned end address  : ");
	writelength &= ~(0x03);
	// printf("addr+length=%x+%x=%x\n", writeaddr, writelength, writeaddr+writelength);
	memory_read(writeaddr+writelength, &data, 1);
	printf("%8.8x\n", data);
	longptr = (long *) ((unsigned long) writedata + writelength);
	*longptr = change_endian(data);
	writelength += 4;
    }
    
    // Bytes einlesen
    while (length > 0) {
	*charptr = HexByte_to_Value(*buffer)*16 + HexByte_to_Value(*(buffer+1));
	buffer += 2;
	*charptr++;
	length--;
    }

    // im Speicher stehen jetzt Big-Endians auf einer Little-Endian (Intel) Maschine
    /*
    printf("%x,%x:", writeaddr, writelength);
    length = writelength;
    longptr = writedata;
    while (length > 0) {
	*longptr = change_endian(*longptr);
	printf("%8.8x", *longptr);
	length-=4;
	longptr++;
    }
    printf("\n");
    */

    // so... und alles schreiben
    memory_write(writeaddr, writedata, writelength);

    free(writedata);
}

int main(void)
{
	int temp;

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

	pp_init();
	tapsm_reset(1);

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

	    //parse_main(input_line);

	    do_gdb();


	    //}

	pp_done();
	exit(0);
}