Subversion Repositories or1k_old

# Copyright (C) 1994, 1996, 1997 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:
# DejaGnu@cygnus.com

# 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