# Copyright (C) 1992 - 2002, 2003 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@gnu.org

# This file was written by Rob Savoye. (rob@welcomehome.org)

#
# 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
}