toolchain/dejagnu/config/base68k.exp

   1 # Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
   2 # Foundation, Inc.
   3 #
   4 # This file is part of DejaGnu.
   5 #
   6 # DejaGnu is free software; you can redistribute it and/or modify it
   7 # under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # DejaGnu is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with DejaGnu; if not, write to the Free Software Foundation,
  18 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20 # This file was written by Bob Manson (manson@cygnus.com)
  21 # based on earlier work by JT Conklin (jtc@cygnus.com)
  22
  23 #
  24 # base68k_load -- load the program and execute it
  25 #
  26
  27 proc base68k_ld { dest prog } {
  28     global tmpdir
  29
  30     set shell_prompt [board_info $dest shell_prompt]
  31
  32     if ![file exists $prog] then {
  33         verbose -log "$prog does not exist."
  34         return "untested"
  35     }
  36     if [is_remote host] {
  37         set prog [remote_download host $prog]
  38         if { $prog == "" } {
  39             verbose -log "Unable to download $prog to host."
  40             return "untested"
  41         }
  42     }
  43
  44     if [board_info $dest exists objcopy] {
  45         set OBJCOPY [board_info $dest objcopy]
  46         set exec_file "${prog}.srec"
  47         set objcopy_args ""
  48         if [board_info $dest exists use_vma_offset] {
  49             set objcopy_args "--adjust-vma=[board_info $dest hex_startaddr]"
  50         }
  51         set status [remote_exec host "$OBJCOPY $objcopy_args -O srec $prog ${prog}.srec"]
  52         set result [lindex $status 1]
  53         regsub -all -- "\[\r\n\]*" $result "" result
  54         if { $result != ""  || [lindex $status 0] != 0 } {
  55             warning "Got \"$result\" from $OBJCOPY"
  56             verbose -log "Couldn't convert to srecord for downloading"
  57             remote_close $dest
  58             return "untested"
  59         } else {
  60             verbose "Converted $prog to an srecord." 2
  61         }
  62     } else {
  63         set exec_file $prog
  64     }
  65
  66     set value 0
  67     if ![board_info $dest exists fileid] {
  68         while { $value < 2 } {
  69             set rom68k_shell_id [remote_open $dest]
  70             if { $rom68k_shell_id < 0 } {
  71                 if { $value > 0 || ![remote_reboot $dest] } {
  72                     verbose -log "$prog not executed, couldn't connect to target."
  73                     return "untested"
  74                 }
  75                 incr value
  76             } else {
  77                 break
  78             }
  79         }
  80         # dbug has problems if we go into binary mode, so this allows us to
  81         # disable entry into binary mode.
  82         if ![board_info $dest exists no_binary_mode] {
  83             remote_binary $dest
  84         }
  85     }
  86
  87     # if we built the srecord on a remote host, copy it back here so we
  88     # can load it
  89     if [is_remote host] {
  90         global objdir
  91         set exec_file [remote_upload host ${exec_file} "${objdir}/a.out"]
  92     }
  93
  94     set got_p 0
  95     for { set tries 0 } { (! $got_p) && $tries < 5 } { incr tries } {
  96         remote_send $dest "\r\n\r\n"
  97         remote_expect $dest 5 {
  98             -re "${shell_prompt}$" {
  99                 verbose "Got prompt."
 100                 set result 0
 101                 set got_p 1
 102             }
 103             timeout {
 104                 warning "Never got prompt."
 105             }
 106         }
 107         if { ! $got_p } {
 108             if $tries<=4 then {
 109                 if { $tries == 3 } then {
 110                     remote_reboot $dest
 111                 } else {
 112                     remote_send $dest "\r\n"
 113                 }
 114             }
 115         }
 116     }
 117
 118     # We need to do this in case the connection to the remote side is
 119     # scrogged -- the remote_expect above will fail in a lot of
 120     # non-clean ways.
 121     if { ! $got_p } {
 122         remote_close $dest
 123         remote_reboot $dest
 124         return "unresolved"
 125     } else {
 126         # Flush out any remaining cruft.
 127         remote_expect $dest 2 {
 128             timeout { }
 129             -re ".+" { exp_continue }
 130             default { }
 131         }
 132     }
 133
 134     if [board_info $dest exists download_command] {
 135         # Load the program.
 136         remote_send $dest "\r\n"
 137         # dbug has problems sending download command immediately after a
 138         # newline, so we wait for the prompt to come back first.
 139         remote_expect $dest 5 {
 140             -re "${shell_prompt}$" {
 141                 verbose -log "Got prompt."
 142             }
 143             timeout {
 144                 warning "Never got prompt."
 145             }
 146         }
 147         remote_send $dest [board_info $dest download_command]
 148         if [board_info $dest exists download_response] {
 149             remote_expect $dest 5 {
 150                 [board_info $dest download_response] { }
 151                 timeout {
 152                     perror "Download command never responded."
 153                     return "unresolved"
 154                 }
 155             }
 156         }
 157     }
 158
 159     verbose "Writing records to target..."
 160     set status [remote_transmit $dest $exec_file]
 161     if { $exec_file != $prog } {
 162         remote_file build delete $exec_file
 163     }
 164     if { $status != 0 } {
 165         remote_close $dest
 166         verbose -log "Transmission of $exec_file to the target failed." 3
 167         return "unresolved"
 168     }
 169     verbose "Wrote records to target...waiting for prompt."
 170     remote_send $dest "\n"
 171     set got_p 0
 172     remote_expect $dest 50 {
 173         -re "$shell_prompt$" {
 174             verbose "Got prompt."
 175             set got_p 1
 176         }
 177         timeout { }
 178     }
 179     if { $got_p } {
 180         # Flush any remaining cruft. 2 seconds may be too long, dunno.
 181         remote_expect $dest 2 {
 182             timeout { }
 183             -re ".+" { exp_continue }
 184             default { }
 185         }
 186         return "pass"
 187     } else {
 188         remote_close $dest
 189         remote_reboot $dest
 190         return "unresolved"
 191     }
 192
 193 }
 194
 195
 196 proc base68k_spawn { dest prog args } {
 197     set shell_prompt [board_info $dest shell_prompt]
 198
 199     set result [remote_ld $dest $prog]
 200     if { $result != "pass" } {
 201         return [list $result ""]
 202     }
 203
 204     if [board_info $dest exists startaddr] {
 205         set go_command "[board_info $dest go_command] [board_info $dest startaddr]"
 206     } else {
 207         set go_command "[board_info $dest go_command]"
 208     }
 209
 210     verbose "Sending $go_command, waiting for results."
 211     remote_send $dest "${go_command}\n"
 212     return { "pass" "" }
 213 }
 214
 215 proc base68k_wait { dest timeout } {
 216     set shell_prompt [board_info $dest shell_prompt]
 217     set noappend 0
 218     set result -1
 219
 220     set output ""
 221
 222     remote_expect $dest $timeout {
 223         -re [board_info $dest go_response] {
 224             append output $expect_out(buffer)
 225             set noappend 1
 226             set result 0
 227             exp_continue -continue_timer
 228         }
 229         -re "$shell_prompt$" {
 230             verbose "Got prompt."
 231             set result 0
 232         }
 233         -re "\[\r\n\]+" {
 234             if { ! $noappend } {
 235                 append output $expect_out(buffer)
 236                 if { [string length $output] < 512000 } {
 237                     exp_continue -continue_timer
 238                 } else {
 239                     set result -1
 240                 }
 241             }
 242         }
 243         timeout {
 244             warning "Nothing ever came back."
 245             set result -1
 246         }
 247     }
 248
 249     if [board_info $dest exists output_end] {
 250         regsub "[board_info $dest output_end]" "$output" "\n" output
 251     }
 252
 253     # There has got to be a better way. (We need to do this in order to remove
 254     # the echoed "go command".
 255     if [board_info $dest exists startaddr] {
 256         set go_command "[board_info $dest go_command] [board_info $dest startaddr]"
 257     } else {
 258         set go_command "[board_info $dest go_command]"
 259     }
 260
 261     regsub "^.*$go_command\[\r\n\]*" "$output" "" output
 262     regsub "^.*$go_command\[\r\n\]*" "$output" "" output
 263
 264     # We always want to check for a status, even if there was a funky weird
 265     # failure above.
 266     set status [check_for_board_status output]
 267     if { $result == 0 } {
 268         set result $status
 269         verbose -log "exit status was $status"
 270     }
 271     # A negative value indicates that we should reboot. Otherwise, return
 272     # the exit status from the program if we got one (and we should have).
 273     return [list $result "$output"]
 274 }
 275
 276 proc base68k_load { dest prog args } {
 277     global base68k_retry
 278
 279     set shell_prompt [board_info $dest shell_prompt]
 280
 281     if { [llength $args] > 0 } {
 282         for { set x 0 } { $x < [llength $args] } { incr x } {
 283             if { [lindex $args $x] != "" } {
 284                 verbose -log "Cannot pass parameters or input file to this target"
 285                 return [list "unsupported" ""]
 286             }
 287         }
 288     }
 289
 290     set result [remote_spawn $dest $prog]
 291     if { [lindex $result 0] != "pass" } {
 292         return $result
 293     }
 294
 295     # FIXME: The value 360 below should be a parameter.
 296
 297     set result [remote_wait $dest 360]
 298     set output [lindex $result 1]
 299     set status [lindex $result 0]
 300
 301     verbose "output from board is $output"
 302
 303     # Make sure there's a newline before the PASS/FAIL/whatever for the log.
 304     send_log "\n"
 305
 306     if { $status > 0 } {
 307         return [list "fail" $output]
 308     } elseif { $status == 0 } {
 309         return [list "pass" $output]
 310     } else {
 311         if [info exists base68k_retry] {
 312             return [list "fail" $output]
 313         }
 314         set base68k_retry 1
 315         remote_reboot $dest
 316         set status [eval base68k_load \{$dest\} \{$prog\} $args]
 317         unset base68k_retry
 318         return $status
 319     }
 320 }
 321
 322 set_board_info protocol "base68k"
 323 set_board_info send_initial_cr 1