Subversion Repositories openrisc_2011-10-31

#!/bin/bash

# Copyright (C) 2010 Embecosm Limited

# Contributor Jeremy Bennett 

# Contributor Joern Rennecke 

# This file is a board description for testing OpenRISC with uClibc and

# Or1ksim running Linux.

# 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 3 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, see .

# -----------------------------------------------------------------------------

# For telnet targets we need to define some functions.

# -----------------------------------------------------------------------------

# Custom proc to close a telnet session

# @param[in] boardname  The board being closed.

# -----------------------------------------------------------------------------

proc telnet_close {hostname} {

    # Get the connected host name, if it exists (actually, we think this can

    # never be set, but it is for consistency with telnet_open

    if {[board_info $hostname exists name]} {

        set connhost [board_info $hostname name]

    } else {

        set connhost $hostname

    }

    # Use the standard close proc from remote.exp

    standard_close $hostname

}

# -----------------------------------------------------------------------------

# Custom proc to exec programs using telnet

# We seem to only pass in the first of the arguments supplied to the command.

# The timeout is a mess. It seems to always be 10, not the timeout needed to

# execute a regression test (typicall 300 seconds). Fixed by using our onw

# timeout data.

# @param[in] hostname  The board we are telnetting to

# @param[in] cmd        The command to run

# @param[in] args       Arguments to the command

# @return  A list of the return code (-1 on failure) and any error message.

# -----------------------------------------------------------------------------

proc telnet_exec {hostname cmd args} {

    global timeout

    global verbos

    set output "(no output)"

    # Save the old timeout, since its global, and we'll want to restore it.

    set old_timeout $timeout

    verbose "Executing $hostname $cmd $args"

    # Get the first argument, if any.

    if { [llength $args] > 0 } {

        set pargs [lindex $args 0];

    } else {

        set pargs ""

    }

    # Set the shell prompt

    if [board_info $hostname exists shell_prompt] {

        set shell_prompt [board_info $hostname shell_prompt]

    }

    if ![info exists shell_prompt] { # if no prompt, then set it to

        something generic

        set shell_prompt ".*> "

    }

    # Start a new telnet session if one doesn't already exist. If sucessful

    # the fileid field associated with $hostname will be set to the spawn_id

    # of the new telnet process.

    if ![board_info $hostname exists fileid] {

        if {[telnet_open $hostname] == -1} {

            return [list -1

                    "telnet to $hostname failed for $cmd, couldn't begin telnet session"]

        }

    }

    # Make the telnet session the current process. Short timeout for this.

    set spawn_id [board_info $hostname fileid]

    set timeout 10

    #Hit enter to make sure you get a shell prompt

    send -- "\r"

    expect {

        # A prompt indicates the current session is alive

        -re "$shell_prompt.*$" {

            verbose "Got a prompt"

        }

        default {

            # No response try closing the connection and reopening.

            telnet_close $hostname

            if {[telnet_open $hostname] != -1} {

                verbose "started new telnet session, spawn_id is [board_info

$hostname fileid]"

                send -- "\r"

                exp_continue

            } else {

                set timeout $old_timeout

                return [list -1 "telnet to $hostname failed for $cmd, couldn't get

a shell prompt"]

            }

            # I don't think we can get here. Comment out the old code and

            # trigger an error

            # send -- "\r"

            # exp_continue

            set timeout $old_timeout

            error "Problem reconnecting to telnet."

        }

    }

    # JPB to set custom timeout. Old timeout saved, so we can restore it,

    # since it's global. Not sure why we only use the first of the arguments.

    if [board_info $hostname exists telnet_exec_timeout] {

        set timeout [board_info $hostname telnet_exec_timeout]

        verbose "Telnet exec timeout set to $timeout"

    } else {

        # Appropriate default

        set timeout 300

        verbose "Telnet exec timeout set to default value $timeout"

    }

    send "$cmd $pargs\r"

    expect {

        -re "$shell_prompt.*$" {

        }

        timeout {

            if [info exists expect_out(buffer)] {

                set execute_output_string $expect_out(buffer)

            }

            set timeout $old_timeout

            telnet_close $hostname

            return [list -1 "telnet to $hostname for $cmd $pargs failed (timeout)"]

        }

    }

    #Remove unnecessary strings from the output string

    #If the file path contains any "+" signs, it will mess things up when $cmd

    #is used as a regsub pattern (2 lines down), so we replace all "+"s with "."

    regsub -all "\\+" $cmd "." cmd

    regsub -all $cmd "$expect_out(buffer)" {} output

    regsub "\(~ \)?$shell_prompt" $output {} output

    regsub -all "\[\r\n\]" $output {} output

    #Check the return status. Use a short timeout for this.

    set timeout 30

    send -- "echo \$?\r"

    expect -re "$shell_prompt.*$"

    #Regsub the output to get the status number

    regsub -all {echo \$\?} $expect_out(buffer) {} status

    regsub "\(~ \)?$shell_prompt" $status {} status

    regsub -all "\[\r\n \]" $status {} status

    #This probably isn't neccessary..

    if {[regexp {[0123456789]+} $status] != 1} {

        warning "status not a number, it is <$status>, setting it to 1"

        set status 1

    }

    # Restore timeout

    set timeout $old_timeout

    if {$status == 0} {

        return [list "0" "$output"]

    } else {

        return [list "1" "$output"]

    }

}

# -----------------------------------------------------------------------------

# For FTP we need to redefine some existing functions to add additional

# features.

# -----------------------------------------------------------------------------

# Upload REMOTEFILE from HOST as LOCALFILE by FTP

# This version swaps the argument order, which is what the regression test

# seems to expect.

# Also allows a custom timeout to be set.

# @param[in] host        The host we are connected to.

# @param[in] localfile   The local file to send

# @param[in] remotefile  Name of file at remote end.

# -----------------------------------------------------------------------------

proc ftp_upload {host localfile remotefile} {

    set prompt "ftp>"

    verbose "ftping $remotefile from $host to $localfile"

    # JPB to set custom timeout (not marked global, so we don't need to save

    # and restore)

    if [board_info $host exists ftp_upload_timeout] {

        set timeout [board_info $host ftp_upload_timeout]

        verbose "FTP upload timeout set to $timeout"

    } else {

        # Appropriate default

        set timeout 15

        verbose "FTP upload timeout set to default value $timeout"

    }

    set spawn_id [ftp_open $host]

    if {$spawn_id < 0} {

        return ""

    }

    set loop 1

    while {$loop} {

        send -i $spawn_id "get $remotefile $localfile\n"

        expect {

            -i $spawn_id -re ".*Too many open files.*$prompt" {

                ftp_close $host

            }

            -i $spawn_id -re ".*No such file or directory.*$prompt" {

                set loop 0

                set remotefile ""

            }

            -i $spawn_id -re "(^|\[\r\n\])226.*$prompt" {set loop 0}

            -i $spawn_id -re "(^|\[\r\n\])\[0-9\]\[0-9\]\[0-9\].*$prompt" {

                set loop 0

                set remotefile ""

            }

            -i $spawn_id default {

                ftp_close $host

            }

        }

        if {$loop} {

            set spawn_id [ftp_open $host]

            if {$spawn_id < 0} {

                return ""

            }

        }

    }

    return $localfile

}

# -----------------------------------------------------------------------------

# Download LOCALFILE to HOST as REMOTEFILE by FTP

# This version takes a user specified timeout, which we need for our slow

# simulated connection.

# @param[in] host        The host we are connected to.

# @param[in] localfile   The local file to send

# @param[in] remotefile  Name of file at remote end.

# -----------------------------------------------------------------------------

proc ftp_download {host localfile remotefile} {

    set prompt "ftp>"

    verbose "putting $localfile $remotefile"

    if [board_info $host exists hostname] {

        set remotehost [board_info $host hostname]

    } else {

        set remotehost $host

    }

    set spawn_id [ftp_open $host]

    if {$spawn_id < 0} {

        return ""

    }

    set loop 1

    # JPB to set custom timeout (not marked global, so we don't need to save

    # and restore)

    if [board_info $host exists ftp_download_timeout] {

        set timeout [board_info $host ftp_download_timeout]

        verbose "FTP download timeout set to $timeout"

    } else {

        # Appropriate default

        set timeout 15

        verbose "FTP download timeout set to default value $timeout"

    }

    while {$loop} {

        send -i $spawn_id "put $localfile $remotefile\n"

        expect {

            -i $spawn_id -re ".*Too many open files.*$prompt" {

                ftp_close $host

            }

            -i $spawn_id -re ".*No such file or directory.*$prompt" {

                set loop 0

                set remotefile ""

            }

            -re "(^|\[\r\n\])150.*connection for (.*) \[(\]\[0-9.,\]+\\)\[\r\n\]" {

                set remotefile $expect_out(2,string)

                exp_continue

            }

            -i $spawn_id -re "(^|\[\r\n\])226.*$prompt" {

                set loop 0

            }

            -i $spawn_id -re "Timeout.*$prompt" {

                ftp_close $host

            }

            -i $spawn_id -re "(^|\[\r\n\])\[0-9\]\[0-9\]\[0-9\].*$prompt" {

                set loop 0

                set remotefile ""

            }

            -i $spawn_id default {

                ftp_close $host

            }

        }

        if {$loop} {

            set spawn_id [ftp_open $host]

            if {$spawn_id < 0} {

                return ""

            }

        }

    }

    return $remotefile

}

# This is a list of toolchains that are supported on this board.

set_board_info target_install {or32-linux}

# No multilib options needed by default.

process_multilib_options ""

# Load the generic configuration for this board. This will define a basic set

# of routines needed by the tool to communicate with the board.

load_generic_config "unix"

# Set up remote target info. We select the IP address using an external

# program which knows about all available Linuxes.

set linux_hostname [exec [file dirname $env(DEJAGNU)]/get-ip.sh --rotate]

set_board_info hostname $linux_hostname

send_user "OR32 target hostname is $linux_hostname\n"

set_board_info username root

# Use the installed compilers to ensure we get search paths that will find

# uClibc.

send_user "set_board_info compiler /opt/or32-new/bin/or32-linux-gcc\n"

global GCC_UNDER_TEST

set GCC_UNDER_TEST "/opt/or32-new/bin/or32-linux-gcc"

global GXX_UNDER_TEST

set GXX_UNDER_TEST "/opt/or32-new/bin/or32-linux-g++"

set_board_info compiler /opt/or32-new/bin/or32-linux-gcc

set_board_info c++compiler /opt/or32-new/bin/or32-linux-g++

set target_alias "or32-linux"

set_board_info connect telnet

set_board_info shell_prompt          "# "

set_board_info telnet_username       "root"

set_board_info telnet_password       ""

set_board_info telnet_exec_timeout   1200

set_board_info file_transfer         ftp

set_board_info ftp_username          root

set_board_info ftp_password          ""

set_board_info ftp_download_timeout  120

set_board_info ftp_upload_timeout    120

# Options for the simulator

# set cfg_file [lookfor_file ${srcdir} libgloss/or32/sim.cfg]

#set_board_info sim,options "-a \"-f ${cfg_file}\""

# We only support uClibc on this target.  We assume that all multilib options

# have been specified before we get here.

#set_board_info compiler  "[find_gcc]"

# We need to define this flag to generate default .gcda files if we are using

# a stock compiler, without the profopt.exp changes. No problem with doubling

# up the argument in normal circumstances.

set_board_info cflags    "-fprofile-dir=."

set_board_info cxxflags  "-fprofile-dir=."

# No linker script needed.

set_board_info ldscript ""

# This simulator isn't slow.

set_board_info slow_simulator 0

# Can't pass arguments to programs on this target..

set_board_info noargs  1

# Used by a few gcc.c-torture testcases to delimit how large the stack can

# be.

set_board_info gcc,stack_size 65536

# GDB options

# We can't do input in GDB (yet! HA!). It *will* do output, hurrah.

set_board_info gdb,noinferiorio 1

# Or pass arguments.

set_board_info gdb,noargs  1

set_board_info noargs 1

# And there's no support for signals.

set_board_info gdb,nosignals  1