# Copyright (C) 1994 - 2001 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

# Please email any bugs, comments, and/or additions to this file to:
# bug-dejagnu@gnu.org

# This file was written by Bob Manson (manson@cygnus.com)
# based on earlier work by JT Conklin (jtc@cygnus.com)

#
# base68k_load -- load the program and execute it
#

proc base68k_ld { dest prog } {
    global tmpdir

    set shell_prompt [board_info $dest shell_prompt]

    if ![file exists $prog] then {
	verbose -log "$prog does not exist."
	return "untested"
    }
    if [is_remote host] {
	set prog [remote_download host $prog];
	if { $prog == "" } {
	    verbose -log "Unable to download $prog to host.";
	    return "untested";
	}
    }

    if [board_info $dest exists objcopy] {
	set OBJCOPY [board_info $dest objcopy];
	set exec_file "${prog}.srec"
	set objcopy_args ""
	if [board_info $dest exists use_vma_offset] {
	    set objcopy_args "--adjust-vma=[board_info $dest hex_startaddr]";
	}
	set status [remote_exec host "$OBJCOPY $objcopy_args -O srec $prog ${prog}.srec"]
	set result [lindex $status 1];
	regsub -all -- "\[\r\n\]*" $result "" result
	if { $result != ""  || [lindex $status 0] != 0 } {
	    warning "Got \"$result\" from $OBJCOPY"
	    verbose -log "Couldn't convert to srecord for downloading"
	    remote_close $dest;
	    return "untested"
	} else {
	    verbose "Converted $prog to an srecord." 2
	}
    } else {
	set exec_file $prog
    }

    set value 0;
    if ![board_info $dest exists fileid] {
	while { $value < 2 } {
	    set rom68k_shell_id [remote_open $dest]
	    if { $rom68k_shell_id < 0 } {
		if { $value > 0 || ![remote_reboot $dest] } {
		    verbose -log "$prog not executed, couldn't connect to target."
		    return "untested"
		}
		incr value;
	    } else {
		break;
	    }
	}
	# dbug has problems if we go into binary mode, so this allows us to
	# disable entry into binary mode.
	if ![board_info $dest exists no_binary_mode] {
	    remote_binary $dest;
	}
    }

    # if we built the srecord on a remote host, copy it back here so we
    # can load it
    if [is_remote host] {
	global objdir
	set exec_file [remote_upload host ${exec_file} "${objdir}/a.out"];
    }

    set got_p 0;
    for { set tries 0; } { (! $got_p) && $tries < 5 } { incr tries } {
	remote_send $dest "\r\n\r\n"
	remote_expect $dest 5 {
	    -re "${shell_prompt}$" {
		verbose "Got prompt."
		set result 0
		set got_p 1;
	    }
	    timeout {
		warning "Never got prompt."
	    }
	}
	if { ! $got_p } {
	    if $tries<=4 then {
		if { $tries == 3 } then {
		    remote_reboot $dest;
		} else {
		    remote_send $dest "\r\n"
		}
	    }
	}
    }

    # We need to do this in case the connection to the remote side is
    # scrogged -- the remote_expect above will fail in a lot of
    # non-clean ways.
    if { ! $got_p } {
	remote_close $dest;
	remote_reboot $dest;
	return "unresolved";
    } else {
	# Flush out any remaining cruft.
	remote_expect $dest 2 {
	    timeout { }
	    -re ".+" { exp_continue }
	    default { }
	}
    }

    if [board_info $dest exists download_command] {
	# Load the program.
	remote_send $dest "\r\n";
	# dbug has problems sending download command immediately after a
	# newline, so we wait for the prompt to come back first.
	remote_expect $dest 5 {
	    -re "${shell_prompt}$" {
		verbose -log "Got prompt."
	    }
	    timeout {
		warning "Never got prompt."
	    }
	}
	remote_send $dest [board_info $dest download_command]
	if [board_info $dest exists download_response] {
	    remote_expect $dest 5 {
		 [board_info $dest download_response] { }
		 timeout { 
		    perror "Download command never responded."
		    return "unresolved";
		}
	    }
	}
    }

    verbose "Writing records to target..."
    set status [remote_transmit $dest $exec_file];
    if { $exec_file != $prog } {
	remote_file build delete $exec_file
    }
    if { $status != 0 } {
	remote_close $dest;
	verbose -log "Transmission of $exec_file to the target failed." 3
	return "unresolved"
    }
    verbose "Wrote records to target...waiting for prompt."
    remote_send $dest "\n"
    set got_p 0;
    remote_expect $dest 50 {
	-re "$shell_prompt$" {
	    verbose "Got prompt."
	    set got_p 1;
	}
	timeout { }
    }
    if { $got_p } {
	# Flush any remaining cruft. 2 seconds may be too long, dunno.
	remote_expect $dest 2 {
	    timeout { }
	    -re ".+" { exp_continue }
	    default { }
	}
	return "pass";
    } else {
	remote_close $dest;
	remote_reboot $dest;
	return "unresolved";
    }

}


proc base68k_spawn { dest prog args } {
    set shell_prompt [board_info $dest shell_prompt];

    set result [remote_ld $dest $prog];
    if { $result != "pass" } {
	return [list $result ""];
    }

    if [board_info $dest exists startaddr] {
	set go_command "[board_info $dest go_command] [board_info $dest startaddr]";
    } else {
	set go_command "[board_info $dest go_command]";
    }

    verbose "Sending $go_command, waiting for results.";
    remote_send $dest "${go_command}\n";
    return { "pass" "" };
}

proc base68k_wait { dest timeout } {
    set shell_prompt [board_info $dest shell_prompt];
    set noappend 0;
    set result -1;

    set output "";

    remote_expect $dest $timeout {
	-re [board_info $dest go_response] {
	    append output $expect_out(buffer);
	    set noappend 1;
	    set result 0;
	    exp_continue -continue_timer;
	}
	-re "$shell_prompt$" {
	    verbose "Got prompt.";
	    set result 0;
	}
	-re "\[\r\n\]+" {
	    if { ! $noappend } {
		append output $expect_out(buffer);
		if { [string length $output] < 512000 } {
		    exp_continue -continue_timer;
		} else {
		    set result -1;
		}
	    }
	}
	timeout {
	    warning "Nothing ever came back.";
	    set result -1;
	}
    }

    if [board_info $dest exists output_end] {
	regsub "[board_info $dest output_end]" "$output" "\n" output;
    }

    # There has got to be a better way. (We need to do this in order to remove
    # the echoed "go command".
    if [board_info $dest exists startaddr] {
	set go_command "[board_info $dest go_command] [board_info $dest startaddr]";
    } else {
	set go_command "[board_info $dest go_command]";
    }

    regsub "^.*$go_command\[\r\n\]*" "$output" "" output;
    regsub "^.*$go_command\[\r\n\]*" "$output" "" output;

    # We always want to check for a status, even if there was a funky weird
    # failure above.
    set status [check_for_board_status output];
    if { $result == 0 } {
	set result $status;
	verbose -log "exit status was $status";
    }
    # A negative value indicates that we should reboot. Otherwise, return
    # the exit status from the program if we got one (and we should have).
    return [list $result "$output"];
}

proc base68k_load { dest prog args } {
    global base68k_retry

    set shell_prompt [board_info $dest shell_prompt];

    if { [llength $args] > 0 } {
	for { set x 0; } { $x < [llength $args] } { incr x ; } {
	    if { [lindex $args $x] != "" } {
		verbose -log "Cannot pass parameters or input file to this target";
		return [list "unsupported" ""];
	    }
	}
    }

    set result [remote_spawn $dest $prog];
    if { [lindex $result 0] != "pass" } {
	return $result;
    }

    # FIXME: The value 360 below should be a parameter.

    set result [remote_wait $dest 360];
    set output [lindex $result 1];
    set status [lindex $result 0];

    verbose "output from board is $output"

    # Make sure there's a newline before the PASS/FAIL/whatever for the log.
    send_log "\n"

    if { $status > 0 } {
	return [list "fail" $output];
    } elseif { $status == 0 } {
	return [list "pass" $output];
    } else {
	if [info exists base68k_retry] {
	    return [list "fail" $output];
	}
	set base68k_retry 1;
	remote_reboot $dest;
	set status [eval base68k_load \{$dest\} \{$prog\} $args];
	unset base68k_retry;
	return $status;
    }
}

set_board_info protocol "base68k";
set_board_info send_initial_cr 1
