Subversion Repositories or1k

# Copyright (C) 92, 93, 94, 95, 96, 97, 98, 1999 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, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  

# Please email any bugs, comments, and/or additions to this file to:
# bug-dejagnu@prep.ai.mit.edu

# This file was written by Rob Savoye. (rob@cygnus.com)

#
# Connect to Spectra (VTRX) using xsh
#
proc xsh_open { hostname } {
    global hex
    global target_triplet
    global xsh_shell_prompt
    global board_info

    if [board_info $hostname exists fileid] {
        unset board_info($hostname,fileid);
    }

    if ![board_info $hostname exists spectra] {
        perror "No spectra directory for $hostname";
        return -1;
    } else {
        set spectra [board_info $hostname spectra];
    }

    if ![board_info $hostname exists xsh_shell_prompt] {
        set xsh_shell_prompt ".*> "
    } else {
        set xsh_shell_prompt [board_info $hostname shell_prompt];
    }

    set retries 0
    set result  0
    if ![board_info $hostname exists xsh_prog] {
        set xsh xsh;
    } else {
        set xsh [board_info $hostname xsh_prog];
    }

    if {[which $xsh] != 0} {
        spawn $xsh
    } else {
        warning "Can't find xsh in path"
        return -1
    }

    set shell_id $spawn_id

    # start the shell
    expect {
        "*Spectra Cross-Development Shell version*$xsh_shell_prompt" { 
            verbose "Got prompt"
            set result 0
        }
        timeout                 { 
            warning "Timed out trying to connect."
            set result -1
            incr retries
            if { $retries <= 2 } {
                exp_continue
            }
        }
    }

    # connect to the shell
    set retries 0
    send "connect $hostname\n"
    expect {
        "connect $hostname*$hostname connected \(non-os mode\)*\n" {
            set xsh_shell_prompt "$hostname> "
            verbose "Connected to $hostname"
        }
        "*connect: not attached*" {
            warning "Couldn't attach target"
            set result -1
        }
        -re ".* reset on target.*$" {
            send_user "Spectra was reset\n"
            exp_continue 
        }
        -re "\[0-9A-Fa-f\]+\[ 0x\]+\[0-9A-Fa-f\]+.*$" {
            exp_continue
        }
        "$hostname> " {
            #send "\n"
        }
        timeout {
            warning "Timed out trying to connect after $expect_out(seconds) seconds."
            set result -1
            incr retries
            if { $retries <= 2 } {
                exp_continue        
            }
        }
    }

    send "\n\n\n"
    expect {
        "*$hostname*$hostname" {
            verbose "Cleared reset messages" 1
        }
        timeout {
            warning "Couldn't clear reset messages"
            set result 1
        }
    }

    set board_info($hostname,fileid) $spawn_id;
    # load to operating system
    set timeout 20
    set retries 0
    if {[xsh_download $hostname $spectra/${target_triplet}-os.o "" {-e sys_start_crt0}]!=0} {
        perror "Couldn't load Spectra into target"
        return -1
    }

    set timeout 10
    # start the OS running
    set retries 0
    send "go\n"
    expect {
        -re ".*Multithreading on target darkstar.*$" {
            verbose "Spectra has been started..." 1
            set result 0
        }
        -re ".*reset on target.*$" {
            verbose "Spectra was reset"
            exp_continue 
        }
        -re "\[0-9A-Fa-f\]+\[ 0x\]+\[0-9A-Fa-f\]+.*$" {
            #send "\n"
            exp_continue
        }
        -re "go\n" { exp_continue }
        "$xsh_shell_prompt" { exp_continue }
        timeout {
            perror "Spectra wouldn't start"
            set result -1
            incr retries
            if { $retries <= 2 } {
                send "go\r"
                exp_continue
            }
        }
    }

    if { $result < 0 } {
        perror "Couldn't connect after $retries retries.\n"
        return -1
    } else {
        set board_info($hostname,fileid) $spawn_id;
        return $spawn_id
    }
}

#
# Download an executable using the load command in Spectra.
#     arg[0] - is a full path name to the file to download.
#     arg[1] - optional arguments to the load command.
#     returns  1 if a spectra error occured,
#             -1 if an internal error occured,
#              0 otherwise.
#
proc xsh_download { dest file destfile args } {
    global verbose
    global shell_id
    global decimal
    global hex
    global expect_out
    global board_info

    set result 1
    set retries 0
    set shell_id [board_info $dest fileid];

    if { [llength $args] > 1 } {
        set opts [lindex $args 1]
    } else {
        set opts ""
    }

    if { [llength $args] > 0 } {
        set destfile [lindex $args 0]
    }

    if ![file exists $file] {
        perror "$file doesn't exist."
        return 1
    }

    verbose "Downloading $file..."

    send -i $shell_id "load $opts $file\r"
    set force 0
    expect {
        -i $shell_id -re "\[0-9A-Fa-f\]+\[ 0x\]+\[0-9A-Fa-f\]+\r\n" {
            set timeout 1
            send "dout\n"
            while $force<2 {
                expect {
                    "dout*undefined kernel symbol*$xsh_shell_prompt" {
                        verbose "Attempted to flush I/O buffers" 1
                    }
                    timout {    
                        incr force      
                        flush stdout    
                    }
                }
            }
            set timeout 20
            exp_continue
        }
        -i $shell_id  "load $opts $file*\r" {
            verbose "Loading a.out..."
            exp_continue
        }
        -i $shell_id "Warm reset on target*\n" {
            verbose "Spectra did a warm reset"
            exp_continue 
        }
        -i $shell_id "Cold reset on target*\n" {
            verbose "Spectra did a cold reset"
            exp_continue
        }
        -i $shell_id "loading a.out*\r" {
            verbose "Loading a.out..."
            exp_continue
        }
        -i $shell_id "reading symbols*\r" {
            verbose "Reading symbols..."
            exp_continue
        }
        -i $shell_id "defining symbols*\r" {
            verbose "defining symbols..."
            exp_continue
        }
        -i $shell_id "*loading image*\r" {
            verbose "Loading image..."
            exp_continue
        }
        -i $shell_id -re ".*bytes loaded:.*$decimal.*$" {
            verbose "$expect_out(buffer)"
            exp_continue
        }
        -i $shell_id "*loading done*\r" {
            verbose "Loading done..."
            exp_continue
        }
        -i $shell_id "*setting PC*\r" {
            verbose "Setting PC..."
            exp_continue
        }
        -i $shell_id "*resolving symbols*\r" {
            verbose "Resolving symbols..."
            exp_continue
        }
        -i $shell_id -re ".*load module id = $decimal.*$" {
            verbose ""
        }
        -i $shell_id -re ".*load: undefined symbols.*$"  {
            perror "undefined symbols, make sure os is loaded and running"
            set result -1
        }
        -i $shell_id "$xsh_shell_prompt" {
            set result 0
            exp_continue 
        }
        -i $shell_id "load: no default target" {
            perror "default target isn't set"
            return -1
        }
        -i $shell_id timeout {
            perror "Timed out trying to download after $expect_out(seconds) seconds."
            incr retries
            set result 1
            if { $retries <= 2 } {
                exp_continue
            }
        }
    }

    set timeout 10
    if [info exists expect_out(buffer)] {
        send_log $expect_out(buffer)
    }
    set board_info($hostname,fileid) $shell_id
    return $result
}

#
# Exit the remote shell
#
proc xsh_close { hostname } {
    global board_info

    if ![board_info $hostname exists fileid] {
        return;
    }

    set shell_id [board_info ${hostname} fileid];
    send -i $shell_id "exit\n"
    unset board_info(${hostname},fileid);

    verbose "Exiting shell."
    return 0
}